commit ec80b339e2f47300f34540db20936ac981382886 Author: Matthias Date: Tue Apr 11 15:49:21 2017 +0200 Initial commit diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100755 index 0000000..7676e7d --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,96 @@ +project(WFR-lib C CXX) +cmake_minimum_required(VERSION 2.8) + + +# cmake options +OPTION(BUILD_WFR_SHARED "Build libwfr as shared library" ON) + + +# Compiler flags +set(CMAKE_CXX_FLAGS_DEBUG "-O0 -g3 -DNDEBUG -Wall") +set(CMAKE_C_FLAGS_DEBUG "-O0 -g3 -DNDEBUG -Wall") +#set(CMAKE_CXX_FLAGS_RELEASE "-O3 -Wall") +#set(CMAKE_C_FLAGS_RELEASE "-O3 -Wall") +#set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS_RELEASE}") +#set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS_RELEASE}") + + +# Initialize variables +set(WFR_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/include) +set(WFR_DIR "${CMAKE_CURRENT_SOURCE_DIR}") +set(WFR_LIBRARY_DIR "${CMAKE_CURRENT_BINARY_DIR}") +set(wfr_add_include_dirs "") +set(wfr_cpp_files "") + + +# Check whether we are called by another script +get_directory_property(hasParent PARENT_DIRECTORY) + + +# Override default libs install directory +if (NOT hasParent) + if (CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT) + set(CMAKE_INSTALL_PREFIX "${CMAKE_CURRENT_SOURCE_DIR}/dist") + endif() +endif() + + +# Include third-party stuff +include(third-party/cmake.inc) + +# Include wfr source code +include(src/cmake.inc) + + +# Set include dir and compiler command line options for compiling +include_directories(${WFR_INCLUDE_DIR} ${Libodb_common_INCLUDE_DIR} ${Boost_INCLUDE_DIR} ${Libodb_sqlite_INCLUDE_DIR} ${Rapidjson_INCLUDE_DIR} ${wfr_add_include_dirs}) +ADD_DEFINITIONS( + -std=c++11 + -Wno-unknown-pragmas +) + + +# Add wfr library +if (BUILD_WFR_SHARED) + add_library(wfr_lib SHARED ${wfr_cpp_files}) + set(WFR_LIBRARY_EXTENSION ".so") +else() + add_library(wfr_lib STATIC ${wfr_cpp_files}) + set(WFR_LIBRARY_EXTENSION ".a") +endif() +add_dependencies(wfr_lib libodb sqlite3 Boost) +set_target_properties(wfr_lib PROPERTIES OUTPUT_NAME wfr) + + +# Set variables +set(WFR_LIBRARIES + wfr_lib + "${Boost_LIBRARIES}" + "${Libodb_sqlite_LIBRARIES}" + "${Libodb_common_LIBRARIES}" + "${Sqlite3_LIBRARIES}" + pthread + dl +) + +message("WFR_LIBRARIES: ${WFR_LIBRARIES}") +message("Boost_LIBRARIES: ${Boost_LIBRARIES}") +message("Libodb_sqlite_LIBRARIES: ${Libodb_sqlite_LIBRARIES}") +message("Libodb_common_LIBRARIES: ${Libodb_common_LIBRARIES}") +message("Sqlite3_LIBRARIES: ${Sqlite3_LIBRARIES}") + +# Where to install the wfr stuff +install(DIRECTORY ${WFR_INCLUDE_DIR} DESTINATION ${CMAKE_INSTALL_PREFIX}) +install(TARGETS wfr_lib DESTINATION ${CMAKE_INSTALL_PREFIX}/lib) +install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/cmake/wfr-config.cmake DESTINATION ${CMAKE_INSTALL_PREFIX}) + + +# Provide some variables to parent script +if(hasParent) + set(WFR_FOUND "TRUE" PARENT_SCOPE) + set(WFR_DIR "${WFR_DIR}" PARENT_SCOPE) + set(WFR_INCLUDE_DIR "${WFR_INCLUDE_DIR}" PARENT_SCOPE) + set(WFR_LIBRARY_DIR "${WFR_LIBRARY_DIR}" PARENT_SCOPE) + set(WFR_LIBRARIES ${WFR_LIBRARIES} PARENT_SCOPE) +endif() + diff --git a/SourceLayout.txt b/SourceLayout.txt new file mode 100755 index 0000000..c7d72e6 --- /dev/null +++ b/SourceLayout.txt @@ -0,0 +1,18 @@ + +Directory Layout: +================= + +common: Objects used by all other modules. +enactment: Enactment Engine +eventsystem: Global Event System +execution: ExecutionLayer +wfr.h: Contains all includes needed for a workflow program + +NameSpace Layout: +================= + +wfr: NameSpace containing all "visible" (visible to a workflow program) objects +wfr::wfs: Workflow Structure Objects +wfr::wep: Workflow Executionplan Objects + +wfri: Internal Objects diff --git a/cmake/wfr-config.cmake b/cmake/wfr-config.cmake new file mode 100755 index 0000000..8e4eb97 --- /dev/null +++ b/cmake/wfr-config.cmake @@ -0,0 +1,25 @@ + +set(SELF_DIR ${CMAKE_CURRENT_LIST_DIR}) + +# Where to find WFR +if (NOT WFR_DIR) + set(WFR_DIR "${SELF_DIR}") +endif() +set(WFR_INCLUDE_DIR "${WFR_DIR}/include") +set(WFR_LIBRARY_DIR "${WFR_DIR}/lib") + +# WFR requires C++11 +ADD_DEFINITIONS( -std=c++11 ) + +# Search for required libraries (prefer static over shared) +set(wfr_lib_paths ${WFR_LIBRARY_DIR}) # Where to search +find_library(wfr_lib NAMES libwfr.a wfr PATHS ${wfr_lib_paths}) +find_library(boost_program_options_lib NAMES libboost_program_options.a boost_program_options PATHS ${wfr_lib_paths}) +find_library(boost_system_lib NAMES libboost_system.a boost_system PATHS ${wfr_lib_paths}) +find_library(boost_filesystem_lib NAMES libboost_filesystem.a boost_filesystem PATHS ${wfr_lib_paths}) +find_library(odb_lib NAMES libodb.a odb PATHS ${wfr_lib_paths}) +find_library(odb_sqlite_lib NAMES libodb-sqlite.a odb-sqlite PATHS ${wfr_lib_paths}) +find_library(sqlite_lib NAMES libsqlite3.a sqlite3 PATHS ${wfr_lib_paths}) +# Store required libraries into single variable +set(WFR_LIBRARIES ${wfr_lib} ${boost_system_lib} ${boost_program_options_lib} ${boost_filesystem_lib} ${odb_sqlite_lib} ${odb_lib} ${sqlite_lib} pthread dl) + diff --git a/figures/WorkflowStructure.ecore b/figures/WorkflowStructure.ecore new file mode 100755 index 0000000..f083d55 --- /dev/null +++ b/figures/WorkflowStructure.ecore @@ -0,0 +1,95 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/figures/WorkflowStructure.ecorediag b/figures/WorkflowStructure.ecorediag new file mode 100755 index 0000000..7cd3cff --- /dev/null +++ b/figures/WorkflowStructure.ecorediag @@ -0,0 +1,721 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/figures/WorkflowStructure.png b/figures/WorkflowStructure.png new file mode 100755 index 0000000..a22d65d Binary files /dev/null and b/figures/WorkflowStructure.png differ diff --git a/figures/classdiagram.ecore b/figures/classdiagram.ecore new file mode 100755 index 0000000..9da4721 --- /dev/null +++ b/figures/classdiagram.ecore @@ -0,0 +1,74 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/figures/classdiagram.ecorediag b/figures/classdiagram.ecorediag new file mode 100755 index 0000000..fc68e71 --- /dev/null +++ b/figures/classdiagram.ecorediag @@ -0,0 +1,443 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/include/wfr/WorkflowRuntime.h b/include/wfr/WorkflowRuntime.h new file mode 100755 index 0000000..a778640 --- /dev/null +++ b/include/wfr/WorkflowRuntime.h @@ -0,0 +1,208 @@ + +#pragma once + +#include +#include +#include +#include +#include +#include + +namespace wfr { + +// Forward declarations +namespace wfs { class Workflow; } +namespace wfs { class WorkflowTemplate; } + +class WorkflowRuntime { +friend class wfs::WorkflowTemplate; +private: + struct ConfigEntry { + std::string stringData; // std::string and unions don't go well together + union { + bool boolData; + uint64_t uintData; + int64_t intData; + double doubleData; + } data; + }; + + static std::map globalConfig; + + static std::default_random_engine randomEngine; + + static std::unordered_set> workflowInstances; + + static void addWorkflowInstance(const std::shared_ptr& wf) { + workflowInstances.insert(wf); + } + +public: + static void init(int argc = 0, char** argv = nullptr); + + static void finish(); + + static void logMessage( std::string message, + const wfr_timestamp_sc_t& timestamp = std::chrono::system_clock::now(), + bool noLocking = false ); + + template + static T setGlobalConfig(const std::string& key, const T& value) { + throw exception::wfr_fatal_error("Function \"setGlobalConfig\" not implemented."); + } + + template + static T getGlobalConfig(const std::string& key, const T& defaultValue = T()) { + throw exception::wfr_fatal_error("Function \"getGlobalConfig\" not implemented."); + } + + template + static T getRandomNumber(const T& min, const T& max) { + throw exception::wfr_fatal_error("Function not implemented."); + } +}; + + + +template<> +inline bool WorkflowRuntime::setGlobalConfig(const std::string& key, const bool& value) { + bool retval = false; + auto e = globalConfig.find(key); + if (e != globalConfig.end()) { + retval = e->second.data.boolData; + e->second.data.boolData = value; + } else { + ConfigEntry e; + e.data.boolData = value; + globalConfig.insert({key, e}); + } + return retval; +} + +template<> +inline uint64_t WorkflowRuntime::setGlobalConfig(const std::string& key, const uint64_t& value) { + uint64_t retval = 0; + auto e = globalConfig.find(key); + if (e != globalConfig.end()) { + retval = e->second.data.uintData; + e->second.data.uintData = value; + } else { + ConfigEntry e; + e.data.uintData = value; + globalConfig.insert({key, e}); + } + return retval; +} + +template<> +inline int64_t WorkflowRuntime::setGlobalConfig(const std::string& key, const int64_t& value) { + int64_t retval = 0; + auto e = globalConfig.find(key); + if (e != globalConfig.end()) { + retval = e->second.data.intData; + e->second.data.intData = value; + } else { + ConfigEntry e; + e.data.intData = value; + globalConfig.insert({key, e}); + } + return retval; +} + +template<> +inline double WorkflowRuntime::setGlobalConfig(const std::string& key, const double& value) { + double retval = 0; + auto e = globalConfig.find(key); + if (e != globalConfig.end()) { + retval = e->second.data.doubleData; + e->second.data.doubleData = value; + } else { + ConfigEntry e; + e.data.doubleData = value; + globalConfig.insert({key, e}); + } + return retval; +} + + + + +template<> +inline std::string WorkflowRuntime::getGlobalConfig(const std::string& key, const std::string& defaultValue) { + std::string retval = defaultValue; + auto e = globalConfig.find(key); + if (e != globalConfig.end()) { + retval = e->second.stringData; + } + return retval; +} + +template<> +inline bool WorkflowRuntime::getGlobalConfig(const std::string& key, const bool& defaultValue) { + bool retval = defaultValue; + auto e = globalConfig.find(key); + if (e != globalConfig.end()) { + retval = e->second.data.boolData; + } + return retval; +} + +template<> +inline uint64_t WorkflowRuntime::getGlobalConfig(const std::string& key, const uint64_t& defaultValue) { + uint64_t retval = defaultValue; + auto e = globalConfig.find(key); + if (e != globalConfig.end()) { + retval = e->second.data.uintData; + } + return retval; +} + +template<> +inline int64_t WorkflowRuntime::getGlobalConfig(const std::string& key, const int64_t& defaultValue) { + int64_t retval = defaultValue; + auto e = globalConfig.find(key); + if (e != globalConfig.end()) { + retval = e->second.data.intData; + } + return retval; +} + +template<> +inline double WorkflowRuntime::getGlobalConfig(const std::string& key, const double& defaultValue) { + double retval = defaultValue; + auto e = globalConfig.find(key); + if (e != globalConfig.end()) { + retval = e->second.data.doubleData; + } + return retval; +} + +template<> +inline std::string WorkflowRuntime::setGlobalConfig(const std::string& key, const std::string& value) { + std::string retval; + auto e = globalConfig.find(key); + if (e != globalConfig.end()) { + retval = e->second.stringData; + e->second.stringData = value; + } else { + ConfigEntry e; + e.stringData = value; + globalConfig.insert({key, e}); + } + return retval; +} + +template<> +inline double WorkflowRuntime::getRandomNumber(const double& min, const double& max) { + std::uniform_real_distribution distribution(min, max); + return distribution(randomEngine); +} + +template<> +inline wfr_size_t WorkflowRuntime::getRandomNumber(const wfr_size_t& min, const wfr_size_t& max) { + std::uniform_int_distribution distribution(min, max); + return distribution(randomEngine); +} + +} /* namespace wfr */ + diff --git a/include/wfr/common/eventsystem/Event.h b/include/wfr/common/eventsystem/Event.h new file mode 100755 index 0000000..6a02c14 --- /dev/null +++ b/include/wfr/common/eventsystem/Event.h @@ -0,0 +1,276 @@ + +#pragma once + + +#include +#include +#include +#include +#include + + +namespace wfr { + +namespace wfs { +// Forward declarations +class Workflow; +class Activity; +class ActivityInstance; +class AtomicActivityImplementation; +} + + +// main namespace +namespace eventsystem { + + +/** + * Event Types. + **/ +enum class EventType + : int { GeneralLoggingEvent, + WorkflowStatusEvent, + ActivityStatusEvent, + ActivityInstanceStatusEvent, + ComputingResourceStatusEvent, + ComponentStatusEvent }; + +/** + * Abstract event base class. + **/ +class Event { + +// Invariant parameters that can be accessed directly +public: + const EventType eventType; + const wfr_timestamp_sc_t timestamp; + +// Public functions +public: + Event(EventType type, const wfr_timestamp_sc_t& timestamp) noexcept + : eventType(type), timestamp(timestamp) {} + virtual ~Event() noexcept {} + + virtual std::string toString() const noexcept = 0; + + template + T& as() noexcept { return *static_cast(this); } + + template + const T& as() const noexcept { return *static_cast(this); } +}; + + +/** + * Event for logging arbitrary messages + **/ +class GeneralLoggingEvent : public Event { +protected: + std::string logMessage; + +public: + GeneralLoggingEvent( const std::string& message, + const wfr_timestamp_sc_t& timestamp = std::chrono::system_clock::now() ) noexcept + : Event(EventType::GeneralLoggingEvent, timestamp), logMessage(message) {} + + const std::string& getMessage() const noexcept { return logMessage; } + + virtual std::string toString() const noexcept override; + + static std::shared_ptr fireEvent( const std::string& message, + const wfr_timestamp_sc_t& timestamp = std::chrono::system_clock::now(), + bool noLocking = false ) noexcept; +}; + + +/** + * Event to indicate that the state of a workflow changed. + **/ +class WorkflowStatusEvent : public Event { +protected: + wfr::wfs::Workflow& workflow; + wfr::wfs::WorkflowStatus oldStatus; + wfr::wfs::WorkflowStatus newStatus; + +public: + WorkflowStatusEvent( wfr::wfs::Workflow& workflow, + wfr::wfs::WorkflowStatus& oldStatus, + wfr::wfs::WorkflowStatus& newStatus, + const wfr_timestamp_sc_t& timestamp = std::chrono::system_clock::now() ) noexcept + : Event(EventType::WorkflowStatusEvent, timestamp), workflow(workflow), oldStatus(oldStatus), newStatus(newStatus) {} + + wfr::wfs::WorkflowStatus getNewStatus() const noexcept { return newStatus; } + + wfr::wfs::WorkflowStatus getOldStatus() const noexcept { return oldStatus; } + + wfr::wfs::Workflow& getWorkflow() const noexcept { return workflow; } + + virtual std::string toString() const noexcept override; + + static std::shared_ptr fireEvent( wfr::wfs::Workflow& workflow, + wfr::wfs::WorkflowStatus& oldStatus, + wfr::wfs::WorkflowStatus& newStatus, + const wfr_timestamp_sc_t& timestamp = std::chrono::system_clock::now(), + bool noLocking = false ) noexcept; +}; + + +/** + * Event to indicate that the state of an activity changed. + **/ +class ActivityStatusEvent : public Event { +protected: + wfr::wfs::Activity& activity; + wfr::wfs::ActivityStatus oldStatus; + wfr::wfs::ActivityStatus newStatus; + +public: + ActivityStatusEvent( wfr::wfs::Activity& activity, + wfr::wfs::ActivityStatus oldStatus, + wfr::wfs::ActivityStatus newStatus, + const wfr_timestamp_sc_t& timestamp = std::chrono::system_clock::now() ) noexcept + : Event(EventType::ActivityStatusEvent, timestamp), activity(activity), oldStatus(oldStatus), newStatus(newStatus) {} + + wfr::wfs::Activity& getActivity() const noexcept { return activity; } + + wfr::wfs::ActivityStatus getNewStatus() const noexcept { return newStatus; } + + wfr::wfs::ActivityStatus getOldStatus() const noexcept { return oldStatus; } + + virtual std::string toString() const noexcept override; + + static std::shared_ptr fireEvent( wfr::wfs::Activity& activity, + wfr::wfs::ActivityStatus oldStatus, + wfr::wfs::ActivityStatus newStatus, + const wfr_timestamp_sc_t& timestamp = std::chrono::system_clock::now(), + bool noLocking = false ) noexcept; +}; + + +/** + * Event to indicate that the state of an activity instance changed. + **/ +class ActivityInstanceStatusEvent : public Event { +protected: + wfr::wfs::ActivityInstance& activityInstance; + wfr::wfs::ActivityInstanceStatus oldStatus; + wfr::wfs::ActivityInstanceStatus newStatus; + +public: + ActivityInstanceStatusEvent( wfr::wfs::ActivityInstance& activityInstance, + wfr::wfs::ActivityInstanceStatus oldStatus, + wfr::wfs::ActivityInstanceStatus newStatus, + const wfr_timestamp_sc_t& timestamp = std::chrono::system_clock::now() ) noexcept + : Event(EventType::ActivityInstanceStatusEvent, timestamp), activityInstance(activityInstance), oldStatus(oldStatus), newStatus(newStatus) {} + + wfr::wfs::ActivityInstance& getActivityInstance() const noexcept { return activityInstance; } + + wfr::wfs::ActivityInstanceStatus getNewStatus() const noexcept { return newStatus; } + + wfr::wfs::ActivityInstanceStatus getOldStatus() const noexcept { return oldStatus; } + + virtual std::string toString() const noexcept override; + + static std::shared_ptr fireEvent( wfr::wfs::ActivityInstance& activity, + wfr::wfs::ActivityInstanceStatus oldStatus, + wfr::wfs::ActivityInstanceStatus newStatus, + const wfr_timestamp_sc_t& timestamp = std::chrono::system_clock::now(), + bool noLocking = false ) noexcept; +}; + + +/** + * Event to indicate that the state of a WFR component changed. + */ +class ComponentStatusEvent : public Event { +protected: + wfs::ComponentType componentType; + wfs::ComponentStatus oldStatus; + wfs::ComponentStatus newStatus; + wfr::wfs::Workflow* workflow; + +public: + ComponentStatusEvent( wfs::ComponentType componentType, + wfs::ComponentStatus oldStatus, + wfs::ComponentStatus newStatus, + wfr::wfs::Workflow* wf = nullptr, + const wfr_timestamp_sc_t& timestamp = std::chrono::system_clock::now()) noexcept + : Event(EventType::ComponentStatusEvent, timestamp), componentType(componentType), oldStatus(oldStatus), newStatus(newStatus), workflow(wf) {} + + wfs::ComponentType getComponentType() const noexcept { return componentType; } + + wfs::ComponentStatus getNewStatus() const noexcept { return newStatus; } + + wfs::ComponentStatus getOldStatus() const noexcept { return oldStatus; } + + wfr::wfs::Workflow* getWorkflow() const noexcept { return workflow; } + + virtual std::string toString() const noexcept override; + + static std::shared_ptr fireEvent( wfs::ComponentType componentType, + wfs::ComponentStatus oldStatus, + wfs::ComponentStatus newStatus, + wfr::wfs::Workflow* wf = nullptr, + const wfr_timestamp_sc_t& timestamp = std::chrono::system_clock::now(), + bool noLocking = false ) noexcept; +}; + + +/** + * Event to indicate that the state of a computing resource changed. + **/ +class ComputingResourceStatusEvent : public Event { +protected: + wfr::wfs::Workflow* workflow; + wfr::wfs::ActivityImplementationType deviceType; + wfr_id_t deviceID; + wfr::wfs::ComputingResourceStatus oldStatus; + wfr::wfs::ComputingResourceStatus newStatus; + wfr::wfs::ActivityInstance* executedTask; + wfr::wfs::AtomicActivityImplementation* executedImpl; + wfr_size_t deviceSlotCount; + +public: + ComputingResourceStatusEvent(wfr::wfs::Workflow* wf, wfr::wfs::ActivityImplementationType deviceType, wfr_id_t deviceID, + wfr::wfs::ComputingResourceStatus oldStatus, wfr::wfs::ComputingResourceStatus newStatus, + wfr::wfs::ActivityInstance* executedTask = nullptr, wfr::wfs::AtomicActivityImplementation* executedImpl = nullptr, + wfr_size_t deviceSlotCount = 0, + wfr_timestamp_sc_t timestamp = std::chrono::system_clock::now()) noexcept + : Event(EventType::ComputingResourceStatusEvent, timestamp), workflow(wf), deviceType(deviceType), + deviceID(deviceID), oldStatus(oldStatus), newStatus(newStatus), executedTask(executedTask), + executedImpl(executedImpl), deviceSlotCount(deviceSlotCount) {} + + wfr::wfs::ActivityImplementationType getDeviceType() const noexcept { return deviceType; } + + wfr::wfs::Workflow* getWorkflow() const noexcept { return workflow; } + + wfr_id_t getDeviceID() const noexcept { return deviceID; } + + wfr::wfs::ComputingResourceStatus getNewStatus() const noexcept { return newStatus; } + + wfr::wfs::ComputingResourceStatus getOldStatus() const noexcept { return oldStatus; } + + wfr::wfs::ActivityInstance* getExecutedTask() const noexcept { return executedTask; } + + wfr::wfs::AtomicActivityImplementation* getExecutedImpl() const noexcept { return executedImpl; } + + wfr_size_t getDeviceSlotCount() const noexcept { return deviceSlotCount; } + + virtual std::string toString() const noexcept override; + + static std::shared_ptr fireEvent( wfr::wfs::Workflow* wf, + wfr::wfs::ActivityImplementationType deviceType, + wfr_id_t deviceID, + wfr::wfs::ComputingResourceStatus oldStatus, + wfr::wfs::ComputingResourceStatus newStatus, + wfr::wfs::ActivityInstance* executedTask = nullptr, + wfr::wfs::AtomicActivityImplementation* executedImpl = nullptr, + wfr_size_t deviceSlotCount = 0, + wfr_timestamp_sc_t timestamp = std::chrono::system_clock::now(), + bool noLocking = false ) noexcept; +}; + + +} /* namespace eventsystem */ +} /* namespace wfr */ + diff --git a/include/wfr/common/eventsystem/EventListener.h b/include/wfr/common/eventsystem/EventListener.h new file mode 100755 index 0000000..c56d613 --- /dev/null +++ b/include/wfr/common/eventsystem/EventListener.h @@ -0,0 +1,23 @@ + +#pragma once + +#include + +namespace wfr { +namespace eventsystem { + +class Event; + +/* + * Event listener interface + */ +class EventListener { +public: + virtual ~EventListener() {} + + virtual void notifyEvent(const std::shared_ptr& event) noexcept = 0; +}; + + +} /* namespace eventsystem */ +} /* namespace wfr */ diff --git a/include/wfr/common/eventsystem/EventSystem.h b/include/wfr/common/eventsystem/EventSystem.h new file mode 100755 index 0000000..da921d0 --- /dev/null +++ b/include/wfr/common/eventsystem/EventSystem.h @@ -0,0 +1,85 @@ + +#pragma once + +#include +#include +#include +#include +#include +#include +#include +#include + + +namespace wfr { + +// forward declarations +class WorkflowRuntime; + +namespace eventsystem { + +// forward declarations +class EventListener; +class Event; +class OStreamLogger; +class SQLiteLogger; + + +class EventSystem { +friend class wfr::WorkflowRuntime; + +// Singleton instances +private: + static EventSystem singleton; + #ifdef WFR_ENABLE_STDLOGGER + static std::unique_ptr oStreamLogger; + #endif + #ifdef WFR_ENABLE_PERFDATABASE + static std::unique_ptr sqliteLogger; + #endif + +// Non-public parameters +private: + std::unordered_set eventListeners; + std::queue> eventQueue; + std::unique_ptr eventThread; + std::mutex eventThreadMutex; + std::condition_variable eventThreadCondVar; + bool stopThread = false; + std::atomic_bool threadStarted; + bool isFinished = false; + +// Non-public static functions +private: + static void eventThreadFunc(EventSystem* eventSystem) noexcept; + + static void init(int argc, char** argv); + static void finish() noexcept; + +// Non-public functions +private: + EventSystem() noexcept; + + void finishInstance() noexcept; + +// Public functions +public: + ~EventSystem() noexcept; + static EventSystem& getInstance() noexcept { return singleton; } + + /** + * Adds an event to the event queue. + * + * It is discouraged to use this function directly. + * Use the static fireEvent function found in each Event class instead (e.g. GeneralLoggingEvent::fireEvent(....)). + **/ + void fireEvent(std::shared_ptr event, bool noLocking = false) noexcept; + + bool addListener(EventListener& listener) noexcept; + bool removeListener(EventListener& listener) noexcept; +}; + + +} /* namespace eventsystem */ +} /* namespace wfr */ + diff --git a/include/wfr/common/exceptions/exceptions.h b/include/wfr/common/exceptions/exceptions.h new file mode 100755 index 0000000..b16bb4d --- /dev/null +++ b/include/wfr/common/exceptions/exceptions.h @@ -0,0 +1,74 @@ + +#pragma once + + +#include +#include +#include + +namespace wfr { +namespace exception { + + +/** + * Exception base class. + */ +class wfr_exception : public std::exception { + protected: + const std::string message; + std::shared_ptr cause; + + public: + wfr_exception(const std::string& message = "", std::shared_ptr cause = std::shared_ptr()) noexcept + : message(message), cause(cause) {} + + wfr_exception(const wfr_exception& e) noexcept + : message(e.message), cause(e.cause) {} + + virtual ~wfr_exception() noexcept {} + + virtual const std::string& getMessage() noexcept { return message; } + virtual std::weak_ptr getCause() noexcept { return cause; } + virtual const char* what() const noexcept override { return message.c_str(); }; + +}; + + +/** + * Represents a fatal error that results in program abortion + **/ +class wfr_fatal_error : public wfr_exception { + public: + using wfr_exception::wfr_exception; +}; + + +/** + * Represents a not found exception. + **/ +class wfr_not_found : public wfr_exception { + public: + using wfr_exception::wfr_exception; +}; + + +/** + * Represents a not found activity instance. + **/ +class wfr_missing_instance : public wfr_exception { + public: + using wfr_exception::wfr_exception; +}; + + +/** + * Represents an illegal argument. + **/ +class wfr_illegal_argument : public wfr_exception { + public: + using wfr_exception::wfr_exception; +}; + + +} // namespace exception +} // namespace wfr diff --git a/include/wfr/common/macros/lwdmacros.h b/include/wfr/common/macros/lwdmacros.h new file mode 100755 index 0000000..debe657 --- /dev/null +++ b/include/wfr/common/macros/lwdmacros.h @@ -0,0 +1,836 @@ + +#pragma once + + +#include +#include + + + +/******************* + * LWD Type Macros * + *******************/ + + +#define WFR_PORT_STRUCT(name, id, members) \ + struct name : public wfr::lwd::_wfr_lwd { \ + name() : _wfr_lwd(id, sizeof(name)) {} \ + members \ + }; + + +#define WFR_PORT_MEMBER(name, type) \ + wfr::lwd::_lwd_member_type name; + + +#define WFR_PORT_MEMBER_IWIRINT(name) \ + wfr::lwd::iwir_int name; + + +#define WFR_PORT_MEMBER_IWIRDOUBLE(name) \ + wfr::lwd::iwir_double name; + + +#define WFR_PORT_MEMBER_IWIRBOOL(name) \ + wfr::lwd::iwir_bool name; + + +#define WFR_PORT_MEMBER_IWIRSTRING(name) \ + wfr::lwd::iwir_string name; + + +#define WFR_PORT_MEMBER_IWIRFILE(name) \ + wfr::lwd::iwir_file name; + + +#define WFR_PORT_MEMBER_IWIRCOLLECTION(name, type, level) \ + wfr::lwd::iwir_collection name; + + +#define WFR_PORT_MEMBER_LOOPPORT(name, type) \ + wfr::lwd::_lwd_loop_port name; + + + +/********************* + * LWD Access Macros * + *********************/ + + +//// Outbuffer //// + +#define WFR_SELF_OUTBUFFER_INIT(name, type) \ + type* name = (type*)instance.getOutputData(); \ + if (name == nullptr) { \ + name = new type(); \ + instance.setOutputData(name); \ + } + + +#define WFR_SELF_OUTBUFFER_GET(name, type) \ + type* name = (type*)instance.getOutputData(); + + +#define WFR_INSTANCE_OUTBUFFER_INIT(name, type, instance) \ + type* name = nullptr; \ + if (instance != nullptr) { \ + name = (type*)(instance)->getOutputData(); \ + if (name == nullptr) { \ + name = new type(); \ + (instance)->setOutputData(name); \ + } \ + } else { \ + throw wfr::exception::wfr_missing_instance("Cannot initialise the outbuffer of a non-existing instance."); \ + } + + +#define WFR_INSTANCE_OUTBUFFER_TRYINIT(name, type, instance) \ + type* name nullptr; \ + if (instance != nullptr) { \ + name = (type*)(instance)->getOutputData(); \ + if (name == nullptr) { \ + name = new type(); \ + (instance)->setOutputData(name); \ + } \ + } + + +#define WFR_INSTANCE_OUTBUFFER_GET(name, type, instance) \ + type* name = nullptr; \ + if (instance != nullptr) { \ + name = (type*)(instance)->getOutputData(); \ + } else { \ + throw wfr::exception::wfr_missing_instance("Cannot get the outbuffer of a non-existing instance."); \ + } + + +#define WFR_INSTANCE_OUTBUFFER_TRYGET(name, type, instance) \ + type* name = nullptr; \ + if (instance != nullptr) { \ + name = (type*)(instance)->getOutputData(); \ + } + + +#define WFR_PARENT_OUTBUFFER_INIT(name, type, parentname) \ + auto parentname = instance.getParentActivity(); \ + type* name = nullptr; \ + if (parentname != nullptr) { \ + name = (type*)(parentname)->getOutputData(); \ + if (name == nullptr) { \ + name = new type(); \ + (parentname)->setOutputData(name); \ + } \ + } else { \ + throw wfr::exception::wfr_missing_instance("Cannot initialise the outbuffer of a non-existing parent."); \ + } + + +#define WFR_PARENT_OUTBUFFER_TRYINIT(name, type, parentname) \ + auto parentname = instance.getParentActivity(); \ + type* name = nullptr; \ + if (parentname != nullptr) { \ + name = (type*)(parentname)->getOutputData(); \ + if (name == nullptr) { \ + name = new type(); \ + (parentname)->setOutputData(name); \ + } \ + } + + +#define WFR_PARENT_OUTBUFFER_GET(name, type, parentname) \ + auto parentname = instance.getParentActivity(); \ + type* name = nullptr; \ + if (parentname != nullptr) { \ + name = (type*)(parentname)->getOutputData(); \ + } else { \ + throw wfr::exception::wfr_missing_instance("Cannot get the outbuffer of a non-existing parent."); \ + } + + +#define WFR_PARENT_OUTBUFFER_TRYGET(name, type, parentname) \ + auto parentname = instance.getParentActivity(); \ + type* name = nullptr; \ + if (parentname != nullptr) { \ + name = (type*)(parentname)->getOutputData(); \ + } + + +#define WFR_CHILD_OUTBUFFER_INIT(name, type, childname, childActivityID, childIterationID) \ + auto childname = WFR_SELF_GETCHILDBYID(childActivityID, childIterationID); \ + type* name = nullptr; \ + if (childname != nullptr) { \ + name = (type*)(childname)->getOutputData(); \ + if (name == nullptr) { \ + name = new type(); \ + (childname)->setOutputData(name); \ + } \ + } else { \ + std::stringstream ss; \ + ss << "Cannot initialise the outbuffer of non-existing child with activityID=" << childActivityID; \ + ss << " and iterationID=" << childIterationID << "."; \ + throw wfr::exception::wfr_missing_instance(ss.str()); \ + } + + +#define WFR_CHILD_OUTBUFFER_TRYINIT(name, type, childname, childActivityID, childIterationID) \ + auto childname = WFR_SELF_GETCHILDBYID(childActivityID, childIterationID); \ + type* name = nullptr; \ + if (childname != nullptr) { \ + name = (type*)(childname)->getOutputData(); \ + if (name == nullptr) { \ + name = new type(); \ + (childname)->setOutputData(name); \ + } \ + } + + +#define WFR_CHILD_OUTBUFFER_GET(name, type, childname, childActivityID, childIterationID) \ + auto childname = WFR_SELF_GETCHILDBYID(childActivityID, childIterationID); \ + type* name = nullptr; \ + if (childname != nullptr) { \ + name = (type*)(childname)->getOutputData(); \ + } else { \ + std::stringstream ss; \ + ss << "Cannot get the outbuffer of non-existing child with activityID=" << childActivityID; \ + ss << " and iterationID=" << childIterationID << "."; \ + throw wfr::exception::wfr_missing_instance(ss.str()); \ + } + + +#define WFR_CHILD_OUTBUFFER_TRYGET(name, type, childname, childActivityID, childIterationID) \ + auto childname = WFR_SELF_GETCHILDBYID(childActivityID, childIterationID); \ + type* name = nullptr; \ + if (childname != nullptr) { \ + name = (type*)(childname)->getOutputData(); \ + } + + +#define WFR_PRED_OUTBUFFER_INIT(name, type, predname, predIndex) \ + auto predname = instance.getPredecessor(predIndex); \ + type* name = nullptr; \ + if (predname != nullptr) { \ + name = (type*)(predname)->getOutputData(); \ + if (name == nullptr) { \ + name = new type(); \ + (predname)->setOutputData(name); \ + } \ + } else { \ + std::stringstream ss; \ + ss << "Cannot initialise the inbuffer of non-existing predecessor with index=" << predIndex << "."; \ + throw wfr::exception::wfr_missing_instance(ss.str()); \ + } + + +#define WFR_PRED_OUTBUFFER_TRYINIT(name, type, predname, predIndex) \ + auto predname = instance.getPredecessor(predIndex); \ + type* name = nullptr; \ + if (predname != nullptr) { \ + name = (type*)(predname)->getOutputData(); \ + if (name == nullptr) { \ + name = new type(); \ + (predname)->setOutputData(name); \ + } \ + } + + +#define WFR_PRED_OUTBUFFER_GET(name, type, predname, predIndex) \ + auto predname = instance.getPredecessor(predIndex); \ + type* name = nullptr; \ + if (predname != nullptr) { \ + name = (type*)(predname)->getOutputData(); \ + } else { \ + std::stringstream ss; \ + ss << "Cannot get the inbuffer of non-existing predecessor with index=" << predIndex << "."; \ + throw wfr::exception::wfr_missing_instance(ss.str()); \ + } + + +#define WFR_PRED_OUTBUFFER_TRYGET(name, type, predname, predIndex) \ + auto predname = instance.getPredecessor(predIndex); \ + type* name = nullptr; \ + if (predname != nullptr) { \ + name = (type*)(predname)->getOutputData(); \ + } + + +#define WFR_SUCC_OUTBUFFER_INIT(name, type, succname, succIndex) \ + auto succname = instance.getSuccessors()[succIndex]; \ + type* name = nullptr; \ + if (succname != nullptr) { \ + name = (type*)(succname)->getOutputData(); \ + if (name == nullptr) { \ + name = new type(); \ + (succname)->setOutputData(name); \ + } \ + } else { \ + std::stringstream ss; \ + ss << "Cannot initialise the inbuffer of non-existing successor with index=" << succIndex << "."; \ + throw wfr::exception::wfr_missing_instance(ss.str()); \ + } + + +#define WFR_SUCC_OUTBUFFER_TRYINIT(name, type, succname, succIndex) \ + auto succname = instance.getSuccessors()[succIndex]; \ + type* name = nullptr; \ + if (succname != nullptr) { \ + name = (type*)(succname)->getOutputData(); \ + if (name == nullptr) { \ + name = new type(); \ + (succname)->setOutputData(name); \ + } \ + } + + +#define WFR_SUCC_OUTBUFFER_GET(name, type, succname, succIndex) \ + auto succname = instance.getSuccessors()[succIndex]; \ + type* name = nullptr; \ + if (succname != nullptr) { \ + name = (type*)(succname)->getOutputData(); \ + } else { \ + std::stringstream ss; \ + ss << "Cannot get the inbuffer of non-existing successor with index=" << succIndex << "."; \ + throw wfr::exception::wfr_missing_instance(ss.str()); \ + } + + +#define WFR_SUCC_OUTBUFFER_TRYGET(name, type, succname, succIndex) \ + auto succname = instance.getSuccessors()[succIndex]; \ + type* name = nullptr; \ + if (succname != nullptr) { \ + name = (type*)(succname)->getOutputData(); \ + } + + +//// Inbuffer //// + + +#define WFR_SELF_INBUFFER_INIT(name, type) \ + type* name = (type*)instance.getInputData(); \ + if (name == nullptr) { \ + name = new type(); \ + instance.setInputData(name); \ + } + + +#define WFR_SELF_INBUFFER_GET(name, type) \ + type* name = (type*)instance.getInputData(); + + +#define WFR_INSTANCE_INBUFFER_INIT(name, type, instance) \ + type* name = nullptr; \ + if (instance != nullptr) { \ + name = (type*)(instance)->getInputData(); \ + if (name == nullptr) { \ + name = new type(); \ + (instance)->setInputData(name); \ + } \ + } else { \ + throw wfr::exception::wfr_missing_instance("Cannot initialise the inbuffer of a non-existing instance."); \ + } + + +#define WFR_INSTANCE_INBUFFER_TRYINIT(name, type, instance) \ + type* name nullptr; \ + if (instance != nullptr) { \ + name = (type*)(instance)->getInputData(); \ + if (name == nullptr) { \ + name = new type(); \ + (instance)->setInputData(name); \ + } \ + } + + +#define WFR_INSTANCE_INBUFFER_GET(name, type, instance) \ + type* name = nullptr; \ + if (instance != nullptr) { \ + name = (type*)(instance)->getInputData(); \ + } else { \ + throw wfr::exception::wfr_missing_instance("Cannot get the inbuffer of a non-existing instance."); \ + } + + +#define WFR_INSTANCE_INBUFFER_TRYGET(name, type, instance) \ + type* name = nullptr; \ + if (instance != nullptr) { \ + name = (type*)(instance)->getInputData(); \ + } + + +#define WFR_PARENT_INBUFFER_INIT(name, type, parentname) \ + auto parentname = instance.getParentActivity(); \ + type* name = nullptr; \ + if (parentname != nullptr) { \ + name = (type*)(parentname)->getInputData(); \ + if (name == nullptr) { \ + name = new type(); \ + (parentname)->setInputData(name); \ + } \ + } else { \ + throw wfr::exception::wfr_missing_instance("Cannot initialise the inbuffer of a non-existing parent."); \ + } + + +#define WFR_PARENT_INBUFFER_TRYINIT(name, type, parentname) \ + auto parentname = instance.getParentActivity(); \ + type* name = nullptr; \ + if (parentname != nullptr) { \ + name = (type*)(parentname)->getInputData(); \ + if (name == nullptr) { \ + name = new type(); \ + (parentname)->setInputData(name); \ + } \ + } + + +#define WFR_PARENT_INBUFFER_GET(name, type, parentname) \ + auto parentname = instance.getParentActivity(); \ + type* name = nullptr; \ + if (parentname != nullptr) { \ + name = (type*)(parentname)->getInputData(); \ + } else { \ + throw wfr::exception::wfr_missing_instance("Cannot get the inbuffer of a non-existing parent."); \ + } + + +#define WFR_PARENT_INBUFFER_TRYGET(name, type, parentname) \ + auto parentname = instance.getParentActivity(); \ + type* name = nullptr; \ + if (parentname != nullptr) { \ + name = (type*)(parentname)->getInputData(); \ + } + + +#define WFR_CHILD_INBUFFER_INIT(name, type, childname, childActivityID, childIterationID) \ + auto childname = WFR_SELF_GETCHILDBYID(childActivityID, childIterationID); \ + type* name = nullptr; \ + if (childname != nullptr) { \ + name = (type*)(childname)->getInputData(); \ + if (name == nullptr) { \ + name = new type(); \ + (childname)->setInputData(name); \ + } \ + } else { \ + std::stringstream ss; \ + ss << "Cannot initialise the inbuffer of non-existing child with activityID=" << childActivityID; \ + ss << " and iterationID=" << childIterationID << "."; \ + throw wfr::exception::wfr_missing_instance(ss.str()); \ + } + + +#define WFR_CHILD_INBUFFER_TRYINIT(name, type, childname, childActivityID, childIterationID) \ + auto childname = WFR_SELF_GETCHILDBYID(childActivityID, childIterationID); \ + type* name = nullptr; \ + if (childname != nullptr) { \ + name = (type*)(childname)->getInputData(); \ + if (name == nullptr) { \ + name = new type(); \ + (childname)->setInputData(name); \ + } \ + } + + +#define WFR_CHILD_INBUFFER_GET(name, type, childname, childActivityID, childIterationID) \ + auto childname = WFR_SELF_GETCHILDBYID(childActivityID, childIterationID); \ + type* name = nullptr; \ + if (childname != nullptr) { \ + name = (type*)(childname)->getInputData(); \ + } else { \ + std::stringstream ss; \ + ss << "Cannot get the inbuffer of non-existing child with activityID=" << childActivityID; \ + ss << " and iterationID=" << childIterationID << "."; \ + throw wfr::exception::wfr_missing_instance(ss.str()); \ + } + + +#define WFR_CHILD_INBUFFER_TRYGET(name, type, childname, childActivityID, childIterationID) \ + auto childname = WFR_SELF_GETCHILDBYID(childActivityID, childIterationID); \ + type* name = nullptr; \ + if (childname != nullptr) { \ + name = (type*)(childname)->getInputData(); \ + } + + +#define WFR_PRED_INBUFFER_INIT(name, type, predname, predIndex) \ + auto predname = instance.getPredecessor(predIndex); \ + type* name = nullptr; \ + if (predname != nullptr) { \ + name = (type*)(predname)->getInputData(); \ + if (name == nullptr) { \ + name = new type(); \ + (predname)->setInputData(name); \ + } \ + } else { \ + std::stringstream ss; \ + ss << "Cannot initialise the inbuffer of non-existing predecessor with index=" << predIndex << "."; \ + throw wfr::exception::wfr_missing_instance(ss.str()); \ + } + + +#define WFR_PRED_INBUFFER_TRYINIT(name, type, predname, predIndex) \ + auto predname = instance.getPredecessor(predIndex); \ + type* name = nullptr; \ + if (predname != nullptr) { \ + name = (type*)(predname)->getInputData(); \ + if (name == nullptr) { \ + name = new type(); \ + (predname)->setInputData(name); \ + } \ + } + + +#define WFR_PRED_INBUFFER_GET(name, type, predname, predIndex) \ + auto predname = instance.getPredecessor(predIndex); \ + type* name = nullptr; \ + if (predname != nullptr) { \ + name = (type*)(predname)->getInputData(); \ + } else { \ + std::stringstream ss; \ + ss << "Cannot get the inbuffer of non-existing predecessor with index=" << predIndex << "."; \ + throw wfr::exception::wfr_missing_instance(ss.str()); \ + } + + +#define WFR_PRED_INBUFFER_TRYGET(name, type, predname, predIndex) \ + auto predname = instance.getPredecessor(predIndex); \ + type* name = nullptr; \ + if (predname != nullptr) { \ + name = (type*)(predname)->getInputData(); \ + } + + +#define WFR_SUCC_INBUFFER_INIT(name, type, succname, succIndex) \ + auto succname = instance.getSuccessors()[succIndex]; \ + type* name = nullptr; \ + if (succname != nullptr) { \ + name = (type*)(succname)->getInputData(); \ + if (name == nullptr) { \ + name = new type(); \ + (succname)->setInputData(name); \ + } \ + } else { \ + std::stringstream ss; \ + ss << "Cannot initialise the inbuffer of non-existing successor with index=" << succIndex << "."; \ + throw wfr::exception::wfr_missing_instance(ss.str()); \ + } + + +#define WFR_SUCC_INBUFFER_TRYINIT(name, type, succname, succIndex) \ + auto succname = instance.getSuccessors()[succIndex]; \ + type* name = nullptr; \ + if (succname != nullptr) { \ + name = (type*)(succname)->getInputData(); \ + if (name == nullptr) { \ + name = new type(); \ + (succname)->setInputData(name); \ + } \ + } + + +#define WFR_SUCC_INBUFFER_GET(name, type, succname, succIndex) \ + auto succname = instance.getSuccessors()[succIndex]; \ + type* name = nullptr; \ + if (succname != nullptr) { \ + name = (type*)(succname)->getInputData(); \ + } else { \ + std::stringstream ss; \ + ss << "Cannot get the inbuffer of non-existing successor with index=" << succIndex << "."; \ + throw wfr::exception::wfr_missing_instance(ss.str()); \ + } + + +#define WFR_SUCC_INBUFFER_TRYGET(name, type, succname, succIndex) \ + auto succname = instance.getSuccessors()[succIndex]; \ + type* name = nullptr; \ + if (succname != nullptr) { \ + name = (type*)(succname)->getInputData(); \ + } + + +#define WFR_LOOP_FINALIZE_COLLECTION(collection, member) \ + if (instance.as().isFinalised() && !collection->member.isFinalised() \ + && instance.as().getIterationCount() == collection->member.getSize()) { \ + collection->member.setFinalised(true); \ + } + + +#define WFR_FINALIZE_COLLECTION(collection, member) \ + if (!collection->member.isFinalised() && collection->member.getSize() > 0 \ + && collection->member.getSize() == collection->member.getReadyCount()) { \ + collection->member.setFinalised(true); \ + } + + +#define WFR_LOOP_FINALIZE() \ + instance.as().setFinalised(true); + + +#define WFR_FORLOOP_GET_COUNTER_VALUE(forloop, member) \ + if (forloop->as().isLoopCounterValueAvailable()) { \ + member.setValue(forloop->as().getLoopCounterValue(instance.iterationID)); \ + } + + +#define WRF_PRED_ISFINISHED(predIndex) \ + wfr_pred_isfinished(instance, predIndex) + +#define WRF_PRED_ISREADY(predIndex) \ + wfr_pred_isready(instance, predIndex) + +#define WRF_PARENT_ISFINISHED() \ + wfr_parent_isfinished(instance) + +#define WRF_PARENT_ISREADY() \ + wfr_parent_isReady(instance) + +#define WFR_PARENT_ISPREVITERFINISHED() \ + wfr_previter_isfinished(*instance.getParentActivity(), instance.iterationID) + + +/* + * + */ + +#define WFR_SELF_CHECK_AREALLINPUTSAVAILABLE(condition) \ + if (condition) { \ + instance.setAllInputsAvailable(true); \ + } + +#define WFR_SELF_CHECK_AREALLOUTPUTSAVAILABLE(condition) \ + if (condition) { \ + instance.setAllOutputsAvailable(true); \ + } + +#define WFR_SELF_CHECK_ISREADYFOREXECUTION(condition) \ + if (condition && instance.getInstanceStatus() < wfr::wfs::ActivityInstanceStatus::ReadyForExecution) { \ + instance.setInstanceStatus(wfr::wfs::ActivityInstanceStatus::ReadyForExecution); \ + } + +#define WFR_SELF_CHECK_ISREADYFOREXECUTION2(condition1, condition2) \ + if (condition1 && condition2 && instance.getInstanceStatus() < wfr::wfs::ActivityInstanceStatus::ReadyForExecution ) { \ + instance.setInstanceStatus(wfr::wfs::ActivityInstanceStatus::ReadyForExecution); \ + } else if (condition1 && instance.getInstanceStatus() < wfr::wfs::ActivityInstanceStatus::ReadyForExecution) { \ + instance.setInstanceStatus(wfr::wfs::ActivityInstanceStatus::WaitingForDependency); \ + } + + + +/* + * + * + */ + + + +#define WFR_INIT_FORLOOPCOUNTER(start, step, stop) \ + if (!instance.as().isFinalised()) { \ + instance.setLoopCounter(start, step, stop); \ + instance.setInstanceStatus(wfr::wfs::ActivityInstanceStatus::ReadyForExecution); \ + instance.as().setFinalised(true); \ + retval = true; \ + } + +#define WFR_INIT_FORLOOPCOUNTER2(start, step, stop) \ + if (!instance.as().isFinalised()) { \ + instance.setLoopCounter(start, step, stop); \ + instance.as().setFinalised(true); \ + retval = true; \ + } + +#define WFR_COLLECT_OUTVALUES_FROM_CHILDREN(collection, type, member, childID) \ + for (wfr_size_t t = 0; t < WFR_SELF_GETITERATIONCOUNT(); t++) { \ + WFR_CHILD_OUTBUFFER_GET(chout, type, ch, childID, t); \ + if (chout != nullptr /*&& collection.getSize() > t*/) { \ + WFR_HOOK_SET_RETVAL(wfr::portbuffer_copy(collection, chout->member, t)); \ + } \ + } + +#define WFR_COLLECT_OUTVALUES_FROM_CHILDREN_FLATTEN(collection, flatten, type, member, childID) \ + { \ + bool doFinalize = false; \ + wfr_size_t index = 0; \ + for (wfr_size_t t = 0; t < WFR_SELF_GETITERATIONCOUNT(); t++) { \ + WFR_CHILD_OUTBUFFER_GET(chout, type, ch, childID, t); \ + if (chout != nullptr) { \ + wfr_size_t ecount = wfr::portbuffer_copy_flatten(collection, chout->member, index); \ + if (ecount == 0) { \ + doFinalize = false; \ + break; \ + } else { \ + index += ecount; \ + doFinalize = true; \ + } \ + } \ + } \ + if (doFinalize) { \ + collection.setFinalised(true); \ + } \ + } + +#define WFR_PORT_INIT_COLLECTION(collection) \ + if (!collection.isFinalised() ) { \ + collection.init(0); \ + } + +#define WFR_PORT_INIT_COLLECTION_LOOP(collection) \ + if (!collection.isFinalised() ) { \ + collection.init(WFR_SELF_GETITERATIONCOUNT()); \ + if (instance.as().isFinalised()) { \ + collection.setFinalised(true); \ + } \ + } + +#define WFR_LOOPPORT_COPY_LAST(dest, srcmember, type, childID) \ + if (instance.as().isFinalised()) { \ + WFR_CHILD_OUTBUFFER_GET(chout, type, ch, childID, WFR_SELF_GETITERATIONCOUNT()-1); \ + if (chout != nullptr) { \ + WFR_HOOK_SET_RETVAL(wfr::portbuffer_copy(dest, chout->srcmember)); \ + } \ + } + +#define WFR_PORT_SETVALUE(var, val) \ + if (!var.isReady()) { \ + var.setValue(val); \ + retval = true; \ + } + +#define WFR_PORT_SETVALUE2(var, val) \ + if (!var.isReady()) { \ + var.setValue(val); \ + } + + +#define WFR_SELF_GETCHILDBYID(activityID, iterationID) \ + instance.as().getChild(activityID, iterationID) + +#define WFR_SELF_GETPREDECESSORBYINDEX(index) \ + (instance).getPredecessor(index) + + +#define WFR_SELF_GETITERATIONCOUNT() \ + instance.as().getIterationCount() + +#define WFR_SELF_GETITERATIONID() \ + instance.as().iterationID + +#define WFR_INSTANCE_GETITERATIONCOUNT(instance) \ + instance.as().getIterationCount() + +#define WFR_SELF_SETITERATIONCOUNT(count) \ + instance.as().setIterationCount(count); + +#define WFR_SELF_SETFORLOOPCOUNTERVALUES(start, step, max) \ + instance.as().setLoopCounter(start, step, max); + +#define WFR_SELF_GETCONDBRANCHID() \ + instance.as().getExecutionBranchID() + +#define WFR_SELF_SETCONDBRANCHID(value) \ + instance.as().setExecutionBranchID(value) + +#define WFR_SELF_GETHANDLEDITERATIONCOUNT() \ + instance.as().getHandledIterationCount() + + + + +#define WFR_ACTIVITY_IMPLEMENTATIONS(name, label, ...) \ + auto name = wfr::wfs::AtomicActivityType::create(label, { \ + __VA_ARGS__ \ + }); + + +#define WFR_WORKFLOW(name, label, actTableName, topLevelID, ...) \ + std::unique_ptr name(new wfr::wfs::WorkflowTemplate(label, topLevelID, { \ + __VA_ARGS__ \ + })); + + +/* + * WRF Hook Function Macros + */ + +#define WFR_INPUT_HOOK(name) \ + bool name(wfr::wfs::ActivityInstance& instance) + +#define WFR_OUTPUT_HOOK(name) \ + bool name(wfr::wfs::ActivityInstance& instance) + +#define WFR_EXEC_HOOK(name) \ + bool name(wfr::wfs::ActivityInstance& instance) + +#define WFR_BRANCHCONDITION_HOOK(name) \ + bool name(wfr::wfs::ConditionalActivityInstance& instance) + +#define WFR_LOOPITERATION_HOOK(name) \ + bool name(wfr::wfs::LoopActivityInstance& instance) + +#define WFR_WHILECONDITION_HOOK(name) \ + bool name(wfr::wfs::WhileLoopActivityInstance& instance) + +#define WFR_FORCOUNTER_HOOK(name) \ + bool name(wfr::wfs::ForLoopActivityInstance& instance) + + +/* + * + */ + +#define WFR_HOOK_SET_RETVAL(func) \ + if (func) { \ + retval = true; \ + } + + +/* + * Simulation Mode + */ + +#define EXECUTE_SIMULATION_MODE instance.executeSimMode(); + + +/********************************* + * Hook Function Prologs/Epilogs * + *********************************/ + +#define WFR_INPUT_HOOK_PROLOG \ + bool retval = false; + +#define WFR_INPUT_HOOK_EPILOG \ + return retval; + +#define WFR_OUTPUT_HOOK_PROLOG \ + bool retval = false; + +#define WFR_OUTPUT_HOOK_EPILOG \ + return retval; + +#define WFR_EXEC_HOOK_PROLOG \ + bool retval = false; + +#define WFR_EXEC_HOOK_EPILOG \ + return retval; + +#define WFR_BRANCHCONDITION_HOOK_PROLOG \ + bool retval = false; + +#define WFR_BRANCHCONDITION_HOOK_EPILOG \ + return retval; + +#define WFR_LOOPITERATION_HOOK_PROLOG \ + bool retval = false; + +#define WFR_LOOPITERATION_HOOK_EPILOG \ + return retval; + +#define WFR_WHILECONDITION_HOOK_PROLOG \ + bool retval = false; + +#define WFR_WHILECONDITION_HOOK_EPILOG \ + return retval; + +#define WFR_FORCOUNTER_HOOK_PROLOG \ + bool retval = false; + +#define WFR_FORCOUNTER_HOOK_EPILOG \ + return retval; + diff --git a/include/wfr/common/prediction/AbstractPredictionService.h b/include/wfr/common/prediction/AbstractPredictionService.h new file mode 100755 index 0000000..384a21d --- /dev/null +++ b/include/wfr/common/prediction/AbstractPredictionService.h @@ -0,0 +1,20 @@ + +#pragma once + +namespace wfr { +namespace prediction { + + +class PredictionService { +public: + virtual ExecutionTimeResult predictExecutionTime(wfs::ActivityInstance& instance, wfs::ActivityImplementation& implementation, + const std::string& resourceName, const wfr_size_t& slots = 1) = 0; + + virtual CommunicationTimeResult predictCommunicationTime(wfs::ActivityInstance& srcInstance, resource::ComputingResource& srcResource, + wfs::ActivityInstance& destInstance, resource::ComputingResource& destResource) = 0; +}; + + +} /* namespace prediction */ +} /* namespace wfr */ + diff --git a/include/wfr/common/resource/Resource.h b/include/wfr/common/resource/Resource.h new file mode 100755 index 0000000..a502d57 --- /dev/null +++ b/include/wfr/common/resource/Resource.h @@ -0,0 +1,174 @@ + +#pragma once + +#include +#include +#include +#include +#include +#include +#include + + +namespace wfr { + +// Forward declarations +namespace wfs { class AtomicActivityImplementation; } + +namespace resource { + + + +class AbstractResource { + +// Invariant properties that can be accessed directly. +public: + const ResourceClass resourceClass; + const std::string resourceIdentifier; + +// Public Functions +public: + AbstractResource( ResourceClass resourceClass, const std::string& resourceIdentifier ) noexcept + : resourceClass(resourceClass), resourceIdentifier(resourceIdentifier) {} + virtual ~AbstractResource() {} + + virtual bool hasCapability(const RequiredResourceCapability& type) const noexcept = 0; +}; + + + +class AbstractResourceType { + +// Invariant properties that can be accessed directly. +public: + const ResourceClass resourceClass; + const std::string resourceTypeName; + +// Mutable properties that need to be accessed via getter-/setter-functions. +protected: + std::set capabilities; + std::map properties; + +// Public Functions +public: + AbstractResourceType( ResourceClass resourceClass, const std::string& resourceName, + const std::set& capabilities = std::set(), + const std::map& properties = std::map() ) noexcept + : resourceClass(resourceClass), resourceTypeName(resourceName), capabilities(capabilities), properties(properties) {} + virtual ~AbstractResourceType() {} + + wfr_size_t getCapabilityCount() const noexcept { return capabilities.size(); } + const std::set& getCapabilities() const noexcept { return capabilities; } + bool hasCapability(const RequiredResourceCapability& type) const noexcept; + bool hasCapability(wfr::resource::ResourceCapabilityType type) const noexcept; + + wfr_size_t getPropertyCount() const noexcept { return properties.size(); } + const std::map& getProperties() const noexcept { return properties; } + std::vector getPropertyKeys() const noexcept; + std::string getProperty(const std::string& key) const noexcept; +}; + + + +template +class ResourceTypeBase : public AbstractResourceType { + +// Mutable properties that need to be accessed via getter-/setter-functions. +private: + std::vector resources; + +// Public Functions +public: + ResourceTypeBase( ResourceClass resourceClass, const std::string& resourceName, + const std::set& capabilities = std::set(), + const std::map& properties = std::map() ) noexcept + : AbstractResourceType(resourceClass, resourceName, capabilities, properties) {} + + wfr_size_t getResourceCount() const noexcept { return resources.size(); } + const std::vector getResources() const noexcept { return resources; } + void addResource(Resource* resource) noexcept { resources.push_back(resource); } +}; + + + +template +class ResourceBase : public AbstractResource { + +// Invariant properties that can be accessed directly. +public: + RType& resourceType; + +// Public Functions +public: + ResourceBase(ResourceClass resourceClass, const std::string& resourceIdentifier, RType& resourceType ) noexcept + : AbstractResource(resourceClass, resourceIdentifier), resourceType(resourceType) {} + + virtual bool hasCapability(const RequiredResourceCapability& type) const noexcept { return resourceType.hasCapability(type); } + virtual bool hasCapability(wfr::resource::ResourceCapabilityType type) const noexcept { return resourceType.hasCapability(type); } +}; + + +class ComputingResource; + +class ComputingResourceType : public ResourceTypeBase { + +// Invariant properties that can be accessed directly. +public: + const ComputingDeviceClass computingDeviceClass; + const wfr_size_t maxSlots; + + +// Public Functions +public: + ComputingResourceType( const std::string& resourceName, ComputingDeviceClass computingDeviceClass, wfr_size_t maxSlots, + const std::set& capabilities = std::set(), + const std::map& properties = std::map() ) noexcept + : ResourceTypeBase(ResourceClass::ComputingResource, resourceName, capabilities, properties), + computingDeviceClass(computingDeviceClass), maxSlots(maxSlots) {} +}; + + + +class ComputingResource : public ResourceBase { + +// Mutable properties that need to be accessed via getter-/setter-functions. +protected: + wfr_size_t reservedSlots =0; + wfr_size_t busySlots = 0; + +// Public Functions +public: + ComputingResource( const std::string& resourceIdentifier, ComputingResourceType& resourceType ) noexcept + : ResourceBase(ResourceClass::ComputingResource, resourceIdentifier, resourceType) { + resourceType.addResource(this); + } + + wfr_size_t getMaxSlotCount() const noexcept { return resourceType.maxSlots; } + wfr_size_t getReservedSlotCount() const noexcept { return reservedSlots; } + wfr_size_t getBusySlotCount() const noexcept { return busySlots; } + wfr_size_t getFreeSlotCount() const noexcept { return resourceType.maxSlots - (busySlots + reservedSlots); } + + bool reserveSlots(const wfr_size_t& slots) noexcept; + bool markReservedSlotsBusy(const wfr_size_t& slots) noexcept; + bool markFreeSlotsBusy(const wfr_size_t& slots) noexcept; + bool releaseBusySlots(const wfr_size_t& slots) noexcept; +}; + + + +ComputingDeviceClass parseComputingDeviceType(const std::string& type); + +std::string getComputingDeviceTypeString(const ComputingDeviceClass& type); + + + +ResourceCapabilityType parseResourceCapabilityType(const std::string& type); + +std::string getResourceCapabilityTypeString(const ResourceCapabilityType& type); + + + +} /* namespace resource */ +} /* namespace wfr */ + + diff --git a/include/wfr/common/resource/ResourceCapabilities.h b/include/wfr/common/resource/ResourceCapabilities.h new file mode 100755 index 0000000..9f43658 --- /dev/null +++ b/include/wfr/common/resource/ResourceCapabilities.h @@ -0,0 +1,108 @@ + +#pragma once + +#include + + +namespace wfr { +namespace resource { + + +/** + * Represents the capabilities of a resource. + */ +class ResourceCapability { +public: + const ResourceCapabilityType type; + const wfr_size_t majorVersion; + const wfr_size_t minorVersion; + +public: + ResourceCapability() + : type(ResourceCapabilityType::Unknown), majorVersion(0), minorVersion(0) {} + + ResourceCapability(const ResourceCapabilityType& type, const wfr_size_t& majorVersion, const wfr_size_t& minorVersion) + : type(type), majorVersion(majorVersion), minorVersion(minorVersion) {} + + + static ResourceCapability GenericCPU() { + return ResourceCapability(ResourceCapabilityType::GenericCPU, 0, 0); + } + + static ResourceCapability OpenCL(const wfr_size_t& majorVersion, const wfr_size_t& minorVersion) { + return ResourceCapability(ResourceCapabilityType::OpenCL, majorVersion, minorVersion); + } + + static ResourceCapability CUDA(const wfr_size_t& majorVersion, const wfr_size_t& minorVersion) { + return ResourceCapability(ResourceCapabilityType::CUDA, majorVersion, minorVersion); + } +}; + + +/** + * Represents the requirements of an activity implementation. + **/ +class RequiredResourceCapability { +public: + const ResourceCapabilityType type; + const wfr_size_t minMajorVersion; + const wfr_size_t minMinorVersion; + const wfr_size_t maxMajorVersion; + const wfr_size_t maxMinorVersion; + +public: + RequiredResourceCapability() + : type(ResourceCapabilityType::Unknown), minMajorVersion(0), minMinorVersion(0), maxMajorVersion(0), maxMinorVersion(0) {} + + RequiredResourceCapability(const ResourceCapabilityType& type, const wfr_size_t& minMajorVersion, const wfr_size_t& minMinorVersion, + const wfr_size_t& maxMajorVersion = 0, const wfr_size_t& maxMinorVersion = 0) + : type(type), minMajorVersion(minMajorVersion), minMinorVersion(minMinorVersion), + maxMajorVersion(maxMajorVersion), maxMinorVersion(maxMinorVersion) {} + + + static RequiredResourceCapability GenericCPU() { + return RequiredResourceCapability(ResourceCapabilityType::GenericCPU, 0, 0, 0, 0); + } + + static RequiredResourceCapability OpenCL(const wfr_size_t& minMajorVersion, const wfr_size_t& minMinorVersion, + const wfr_size_t& maxMajorVersion = 0, const wfr_size_t& maxMinorVersion = 0) { + return RequiredResourceCapability(ResourceCapabilityType::OpenCL, minMajorVersion, minMinorVersion, maxMajorVersion, maxMinorVersion); + } + + static RequiredResourceCapability CUDA(const wfr_size_t& minMajorVersion, const wfr_size_t& minMinorVersion, + const wfr_size_t& maxMajorVersion = 0, const wfr_size_t& maxMinorVersion = 0) { + return RequiredResourceCapability(ResourceCapabilityType::CUDA, minMajorVersion, minMinorVersion, maxMajorVersion, maxMinorVersion); + } +}; + + +typedef std::initializer_list CapabilityList; +typedef std::initializer_list RequiredCapabilityList; + +inline bool operator<(const wfr::resource::ResourceCapability& dev1, const wfr::resource::ResourceCapability& dev2) { + if (dev1.type == dev2.type) { + if (dev1.majorVersion == dev2.majorVersion) { + return dev1.minorVersion < dev2.minorVersion; + } else { + return dev1.majorVersion < dev2.majorVersion; + } + } else { + return dev1.type < dev2.type; + } +} + +inline bool operator==(const wfr::resource::ResourceCapability& cap, const wfr::resource::RequiredResourceCapability& rcap) { + if (cap.type == rcap.type) { + if (cap.majorVersion >= rcap.minMajorVersion && cap.majorVersion <= rcap.maxMajorVersion) { + return true; + } else { + return false; + } + } else { + return false; + } +} + +} /* namespace resource */ +} /* namespace wfr */ + diff --git a/include/wfr/common/resource/ResourceManager.h b/include/wfr/common/resource/ResourceManager.h new file mode 100755 index 0000000..f8afb68 --- /dev/null +++ b/include/wfr/common/resource/ResourceManager.h @@ -0,0 +1,69 @@ + +#pragma once + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +namespace wfr { +namespace resource { + +class AbstractResource; +class ComputingResource; +class ComputingResourceType; +class ComputingResourceReservation; +class RequiredResourceCapability; + +class ResourceManager { +private: + static ResourceManager* singleton; + +// Mutable properties that need to be accessed via getter-/setter-functions. +private: + std::mutex managerMutex; + std::map computingResourceTypes; + std::map computingResources; + +// Non-public functions +private: + ResourceManager(std::string resourceConfigFile, bool cpuAutoConfig, bool printResourceTable); + + void readConfigFile(std::string configFile); + +// Public static functions +public: + static void init(int argc, char** argv); + static void finish() noexcept; + static ResourceManager& getInstance() noexcept; + +// Public functions +public: + ~ResourceManager() noexcept; + + wfr_size_t getComputingResourceCount() const noexcept { return computingResources.size(); } + std::vector getComputingResources() const noexcept; + ComputingResource* getComputingResource(std::string identifier) const noexcept; + std::vector filterComputingResources(std::vector filter) const noexcept; + + ComputingResourceReservation reserveComputingResource(ComputingResource* device, const wfr_size_t& slots = 1) noexcept; + bool releaseComputingResources(ComputingResourceReservation* handle) noexcept; + + wfr_size_t getComputingResourceTypeCount() const noexcept { return computingResourceTypes.size(); } + std::vector getComputingResourceTypes() const noexcept; + ComputingResourceType* getComputingResourceType(std::string name) const noexcept; + + void printResourceTable(std::ostream& out) const noexcept; +}; + + +} /* namespace resource */ +} /* namespace wfr */ + diff --git a/include/wfr/common/resource/ResourceReservation.h b/include/wfr/common/resource/ResourceReservation.h new file mode 100755 index 0000000..953a2c9 --- /dev/null +++ b/include/wfr/common/resource/ResourceReservation.h @@ -0,0 +1,35 @@ + +#pragma once + +#include + +namespace wfr { +namespace resource { + +class ComputingResource; + +class ComputingResourceReservation { + +// Invariant properties that can be accessed directly. +public: + resource::ComputingResource* const resource = nullptr; + const wfr_size_t slotCount = 0; + +// Mutable properties that need to be accessed via getter-/setter-functions. +protected: + bool isValidFlag = false; + +// Public Functions +public: + ComputingResourceReservation() noexcept {} + ComputingResourceReservation(resource::ComputingResource* resource, const wfr_size_t& slotCount = 1) noexcept + : resource(resource), slotCount(slotCount), isValidFlag(true) {} + virtual ~ComputingResourceReservation() noexcept {} + + bool isValid() const noexcept { return isValidFlag; } + void invalidateReservation() noexcept { isValidFlag = false; } +}; + +} /* namespace resource */ +} /* namespace wfr */ + diff --git a/include/wfr/common/scheduling/SchedulingDecision.h b/include/wfr/common/scheduling/SchedulingDecision.h new file mode 100755 index 0000000..ecf4e9e --- /dev/null +++ b/include/wfr/common/scheduling/SchedulingDecision.h @@ -0,0 +1,54 @@ + +#pragma once + +#include +#include +#include + +namespace wfr { +namespace wfs { +class ActivityInstance; +class AtomicActivityImplementation; +} +namespace wep { +class WorkflowExecutionPlan; +} + + +namespace scheduling { + +class SchedulingDecision { + +// Invariant properties that can be accessed directly. +public: + wfs::ActivityInstance* const activityInstance = nullptr; + wfs::AtomicActivityImplementation* const activityImplementation = nullptr; + wep::WorkflowExecutionPlan* const wep = nullptr; + resource::ComputingResource* const resource = nullptr; + resource::ComputingResourceReservation reservationHandle; + wfr_size_t slotCount = 0; + +// Mutable properties that need to be accessed via getter-/setter-functions. +// Some of them are invariant, but this class needs to be copyable, so no const properties :( +private: + prediction::ExecutionTimeResult prediction; + +// Public functions +public: + SchedulingDecision(wfs::ActivityInstance* activityInstance, wfs::AtomicActivityImplementation* activityImplementation, + wep::WorkflowExecutionPlan* wep, resource::ComputingResourceReservation reservationHandle) noexcept + : activityInstance(activityInstance), activityImplementation(activityImplementation), wep(wep), + resource(reservationHandle.resource), reservationHandle(reservationHandle), slotCount(reservationHandle.slotCount) {} + SchedulingDecision(wfs::ActivityInstance* activityInstance, wfs::AtomicActivityImplementation* activityImplementation, + wep::WorkflowExecutionPlan* wep, resource::ComputingResource* resource = nullptr, const wfr_size_t& slotCount = 1) noexcept + : activityInstance(activityInstance), activityImplementation(activityImplementation), wep(wep), + resource(resource), slotCount(slotCount) {} + ~SchedulingDecision() noexcept {} + + const prediction::ExecutionTimeResult& getPrediction() const noexcept { return prediction; } + void setPrediction(const prediction::ExecutionTimeResult& prediction) noexcept { this->prediction = prediction; } +}; + +} /* namespace scheduling */ +} /* namespace wfr */ + diff --git a/include/wfr/common/types/LwdTypes.h b/include/wfr/common/types/LwdTypes.h new file mode 100755 index 0000000..f46ef18 --- /dev/null +++ b/include/wfr/common/types/LwdTypes.h @@ -0,0 +1,233 @@ + +#pragma once + + +#include +#include +#include +#include +#include +#include + + +namespace wfr { +namespace lwd { + + +/** + * Base-class of all lightweight data structs holding input and output values. + **/ +class _wfr_lwd { +private: + uint32_t type_id; + uint32_t payload_size; + // actual content will be stored here (in derived structs) + +public: + virtual ~_wfr_lwd() noexcept {} + + _wfr_lwd(const uint32_t& type, const uint32_t& struct_size) : type_id(type), payload_size(struct_size - sizeof(_wfr_lwd)) {} + uint32_t getTypeID() const { return type_id; } + uint32_t getPayloadSize() const { return payload_size; } +}; + + +/** + * Enum representing the status of lightweight data struct members + **/ +enum class LWDMemberStatus + : int { Pending, + Ready }; + + + + + +/** + * Base-class for a lwd struct data member. + **/ +template +class _lwd_member_type { +protected: + T data; + lwd::LWDMemberStatus status; + +public: + _lwd_member_type() : data(), status(lwd::LWDMemberStatus::Pending) {} + _lwd_member_type(const T& data, const LWDMemberStatus& status = LWDMemberStatus::Ready) : data(data), status(status) {} + virtual ~_lwd_member_type() noexcept {} + + bool isReady() const { return (status == wfr::lwd::LWDMemberStatus::Ready); } + const T& getValue() const { return data; } + void setValue (const T& value) { + data = value; + status = wfr::lwd::LWDMemberStatus::Ready; + } + void setValue (const _lwd_member_type& value) { + if (value.isReady()) { + setValue(value.getValue()); + } + } +}; + + +/** + * Base-class for a loop port. + **/ +template +class _lwd_loop_port : public T { +private: + wfr_id_t nextIterationID = 0; + +public: + virtual ~_lwd_loop_port() noexcept {} + + wfr_id_t getNextIterationID() const { return nextIterationID; } + void setNextIterationID(const wfr_id_t& id) { nextIterationID = id; } +}; + + + +template +struct collection_is_level_greater_one { + static const bool value = true; +}; +template<> +struct collection_is_level_greater_one<1> { + static const bool value = false; +}; + + +/** + * Base-class for a collection. + **/ +template +class iwir_collection : public _lwd_member_type::value, iwir_collection, BASETYPE>::type>>> { +public: + typedef typename std::conditional::value, iwir_collection, BASETYPE>::type CollectionBaseType; +private: + wfr_size_t size = 0; + wfr_size_t readyCount = 0; + bool finalisedFlag = false; +public: + iwir_collection() { + assert(NESTINGLEVEL>0); + } + bool init(const wfr_size_t& csize, const CollectionBaseType& defaultvalue = CollectionBaseType()) { + if (csize > 0 && this->size < csize) { + for (wfr::wfr_size_t t = this->size; t < csize; t++) { + //this->data.push_back({defaultvalue, wfr::lwd::LWDMemberStatus::Pending}); + this->data.push_back(_lwd_member_type(defaultvalue, wfr::lwd::LWDMemberStatus::Pending)); + } + this->size = csize; + return true; + } else { + return false; + } + } + wfr_size_t getNestingLevel() const noexcept { return NESTINGLEVEL; } + bool isFinalised() const { return finalisedFlag; } + void setFinalised(const bool& v) { + finalisedFlag = v; + if (finalisedFlag && readyCount == this->size) { + this->status = wfr::lwd::LWDMemberStatus::Ready; + } + } + wfr_size_t getReadyCount() const { return readyCount; } + wfr_size_t getSize() const { return size; } + _lwd_member_type& getEntry(const wfr_id_t& index) { + return this->data[index]; + } + const CollectionBaseType& getEntryValue(const wfr_id_t& index) const { + return this->data[index].getValue(); + } + bool getEntryStatus(const wfr_id_t& index) const { + return this->data[index].isReady(); + } + void setEntryValue(const wfr_id_t& index, const CollectionBaseType& value) { + if (this->size <= index) { + for (wfr::wfr_size_t t = this->size; t < index; t++) { + this->data.emplace_back(CollectionBaseType(), wfr::lwd::LWDMemberStatus::Pending); + } + this->data.emplace_back(value, wfr::lwd::LWDMemberStatus::Ready); + this->size = index+1; + readyCount++; + } else { + if (!this->data[index].isReady()) { + this->data[index].setValue(value); + readyCount++; + } + } + if (finalisedFlag && readyCount == this->size) { + this->status = wfr::lwd::LWDMemberStatus::Ready; + } + } + void assign(const std::initializer_list& ilist, const bool& finalize = false) { + this->data.clear(); + for (auto& e : ilist) { + this->data.push_back(_lwd_member_type(e)); + } + size = ilist.size(); + readyCount = size; + if (finalize) { + finalisedFlag = finalize; + this->status = wfr::lwd::LWDMemberStatus::Ready; + } + } + typename std::vector<_lwd_member_type>::iterator begin() { + return this->data.begin(); + } + typename std::vector<_lwd_member_type>::iterator end() { + return this->data.end(); + } + typename std::vector<_lwd_member_type>::const_iterator begin() const { + return this->data.begin(); + } + typename std::vector<_lwd_member_type>::const_iterator end() const { + return this->data.end(); + } +}; + + + +/** + * Typedefs representing IWIR base types. + **/ + +typedef long _lwd_iwir_basetype_int; + +typedef double _lwd_iwir_basetype_double; + +typedef bool _lwd_iwir_basetype_bool; + +typedef std::string _lwd_iwir_basetype_string; + +typedef std::string _lwd_iwir_basetype_file; + + + +/** + * Typedefs representing IWIR lwd members types. + **/ + +typedef _lwd_member_type<_lwd_iwir_basetype_string> iwir_string; + +typedef _lwd_member_type<_lwd_iwir_basetype_int> iwir_int; + +typedef _lwd_member_type<_lwd_iwir_basetype_double> iwir_double; + +typedef _lwd_member_type<_lwd_iwir_basetype_bool> iwir_bool; + +typedef _lwd_member_type<_lwd_iwir_basetype_file> iwir_file; + + +/** + * Typedefs representing other lwd member types. + **/ + +typedef _lwd_member_type lwdm_void_pointer; + + + +} // namespace lwd +} // namespace wfr diff --git a/include/wfr/common/types/ResourceTypes.h b/include/wfr/common/types/ResourceTypes.h new file mode 100755 index 0000000..9ac53cf --- /dev/null +++ b/include/wfr/common/types/ResourceTypes.h @@ -0,0 +1,36 @@ + +#pragma once + + +#include +#include + +namespace wfr { +namespace resource { + + + +enum class ResourceClass { + Unknown, + ComputingResource +}; + + + +enum class ComputingDeviceClass + : int { Unknown, + CPU, + GPU }; + + +enum class ResourceCapabilityType + : int { Unknown, + // ComputingResource Capabilities + GenericCPU, + OpenCL, + CUDA }; + + +} // namespace wfr +} // namespace resource + diff --git a/include/wfr/common/types/WepTypes.h b/include/wfr/common/types/WepTypes.h new file mode 100755 index 0000000..12646b7 --- /dev/null +++ b/include/wfr/common/types/WepTypes.h @@ -0,0 +1,22 @@ + +#pragma once + +namespace wfr { +namespace wep { + +/** + * Enum representing the different types of the workflow execution plan nodes. + **/ +enum class WepNodeType + : int { Unknown, + Atomic, + Assign, + CompositeStart, + CompositeEnd, + IterationStart, + IterationEnd, + Hole }; + +} /* namespace wep */ +} /* namespace wfr */ + diff --git a/include/wfr/common/types/WfrTypes.h b/include/wfr/common/types/WfrTypes.h new file mode 100755 index 0000000..0f0a673 --- /dev/null +++ b/include/wfr/common/types/WfrTypes.h @@ -0,0 +1,93 @@ + +#pragma once + +#include +#include + +// main namespace +namespace wfr { + + /** + * Type used for IDs. + **/ + typedef uint64_t wfr_id_t; + + /** + * Type used for sizes or counts. + **/ + typedef uint64_t wfr_size_t; + + /** + * Type used for timestamps and time durations. + **/ + typedef std::chrono::system_clock::time_point wfr_timestamp_sc_t; + typedef std::chrono::system_clock::duration wfr_duration_sc_t; + + + /** + * Type used for numeric measurements. + * + * Numeric measurements usually come with a value and a standard deviation (or variance). + **/ + class NumericalMeasurement { + private: + double value; + double deviation; + bool valid; + public: + NumericalMeasurement() + : value(0), deviation(0), valid(false) {} + + NumericalMeasurement(double value, double deviation = 0, bool valid = true) + : value(value), deviation(deviation), valid(valid) {} + + double getValue() const { return value; } + double getDeviation() const { return deviation; } + bool isValid() const { return valid; } + + bool operator<(const NumericalMeasurement& other) const { + return value < other.value; + } + + bool operator<=(const NumericalMeasurement& other) const { + return value <= other.value; + } + + bool operator>(const NumericalMeasurement& other) const { + return value > other.value; + } + + bool operator>=(const NumericalMeasurement& other) const { + return value >= other.value; + } + + bool operator==(const NumericalMeasurement& other) const { + return value == other.value; + } + + NumericalMeasurement& operator+=(const NumericalMeasurement& other) { + value += other.value; + // ToDo: Fehlerfortpflanzungsgesetz + valid = other.valid; + return *this; + } + + NumericalMeasurement operator+(const NumericalMeasurement& other) { + NumericalMeasurement retval(*this); + if (retval.isValid() && other.isValid()) { + retval.value += other.value; + } + // ToDo: Fehlerfortpflanzungsgesetz + return retval; + } + + NumericalMeasurement& operator/=(wfr_size_t other) { + value /= other; + // ToDo: Fehlerfortpflanzungsgesetz + return *this; + } +}; + +} // namespace wfr + + diff --git a/include/wfr/common/types/WfsTypes.h b/include/wfr/common/types/WfsTypes.h new file mode 100755 index 0000000..db8bac7 --- /dev/null +++ b/include/wfr/common/types/WfsTypes.h @@ -0,0 +1,137 @@ + +#pragma once + +#include +#include + + +namespace wfr { +namespace wfs { + +// Forward declarations +class ActivityInstance; +class ConditionalActivityInstance; +class WhileLoopActivityInstance; +class ForLoopActivityInstance; +class LoopActivityInstance; + + +/** + * Enum representing the different types of workflow items. + **/ +enum class ActivityType + : int { Unknown, + Atomic, + Container, + ForLoop, + WhileLoop, + Conditional, + Assign }; + +enum class ActivityImplementationType + : int { Unknown, + PThread, + OpenMP, + OpenCL, + CUDA }; + + + +/** + * Enum for Workflow status + **/ +enum class WorkflowStatus + : int { Unknown, + Created, + Initialized, + Running, + Finished, + Error + }; + + +/** + * Enum for Activity status + **/ +enum class ActivityStatus + : int { Unknown, + Created, + Initialized, + Running, + Finished, + Error + }; + + +/** + * Enum for Activity Instance status + **/ +enum class ActivityInstanceStatus + : int { Unknown, + Created, + Initialized, + WaitingForData, + WaitingForDependency, + ReadyForExecution, + // SchedulerStates + Scheduled, + // ExecutionLayerStates + Queued, + WaitingForFreeResources, + Running, + Finished, + Error + }; + + +/** + * Enum for Device Instance status + **/ +enum class ComputingResourceStatus + : int { Unknown, + Created, + Idle, + Sleep, + WokenUp, + Busy, + ExecutingTask, + FinishedTask, + Shutdown, + Error + }; + + + + +enum class ComponentType + : int { Unknown, + Enactment, + Scheduler, + ExecutionLayer }; + + +enum class ComponentStatus + : int { Unknown, + Idle, + Busy, + Finished, + Error }; + + +/** + * Types used for hook functions. + **/ +typedef std::function InputHookFunc; +typedef std::function OutputHookFunc; +typedef std::function ExecutionHookFunc; +typedef std::function BranchConditionHookFunc; +typedef std::function LoopIterationHookFunc; +typedef std::function WhileConditionHookFunc; +typedef std::function ForCounterHookFunc; + + + + +} // namespace lwd +} // namespace wfr + diff --git a/include/wfr/common/utils/Properties.h b/include/wfr/common/utils/Properties.h new file mode 100755 index 0000000..5fee331 --- /dev/null +++ b/include/wfr/common/utils/Properties.h @@ -0,0 +1,55 @@ + +#pragma once + +#include +#include +#include +#include +#include +#include +#include +#include + + +namespace wfr { +namespace utils { + +typedef std::initializer_list> PropertyList; + + +class Properties { +private: + std::map properties; + +public: + Properties() {} + Properties(PropertyList props) { + for (auto i : props) { + properties.insert(i); + } + } + + bool hasProperty(const std::string& key) const noexcept { + return properties.find(key) != properties.end(); + } + + const std::string& getProperty(const std::string& key) const { + auto i = properties.find(key); + if (i != properties.end()) { + return i->second; + } else { + throw exception::wfr_not_found((boost::format("Property \"%1%\" not found.") % key).str()); + } + } + + const std::map& getProperties() const { + return properties; + } + + void addProperty(const std::string& key, const std::string& value) noexcept { + properties[key] = value; + } +}; + +} /* namespace utils */ +} /* namespace wfr */ diff --git a/include/wfr/common/utils/filesystem.h b/include/wfr/common/utils/filesystem.h new file mode 100755 index 0000000..025554f --- /dev/null +++ b/include/wfr/common/utils/filesystem.h @@ -0,0 +1,28 @@ + +#pragma once + + +/* Precompiled boost was not compiled with -std=c++11 */ +#define BOOST_NO_CXX11_SCOPED_ENUMS + +#include +#include + + +namespace wfr { + +namespace filesystem { + + +boost::filesystem::path createWorkingFolder(wfr::wfs::ActivityInstance& instance); +boost::filesystem::path createWorkingFolder(std::string name); + +boost::filesystem::path createFolder(wfr::wfs::ActivityInstance& instance, boost::filesystem::path pdir, std::string fname); + +void copy_file(const boost::filesystem::path& from, const boost::filesystem::path& to, + boost::filesystem::copy_option::enum_type option = boost::filesystem::copy_option::enum_type::overwrite_if_exists); + + +} // end namespace filesystem +} // end namespace wfr + diff --git a/include/wfr/common/utils/print.h b/include/wfr/common/utils/print.h new file mode 100644 index 0000000..763cf60 --- /dev/null +++ b/include/wfr/common/utils/print.h @@ -0,0 +1,268 @@ + +#pragma once + +#include +#include + +#include +#include +#include +#include + + +namespace wfr { +namespace print { + + +inline std::string toString(const wfs::WorkflowStatus& status) { + std::string retval; + switch (status) { + case wfs::WorkflowStatus::Unknown: + retval = "Unknown"; + break; + case wfs::WorkflowStatus::Created: + retval = "Created"; + break; + case wfs::WorkflowStatus::Initialized: + retval = "Initialized"; + break; + case wfs::WorkflowStatus::Running: + retval = "Running"; + break; + case wfs::WorkflowStatus::Finished: + retval = "Finished"; + break; + case wfs::WorkflowStatus::Error: + retval = "Error"; + break; + default: + retval = "<>"; + break; + } + return retval; +} + +inline std::string toString(const wfs::ActivityStatus& status) { + std::string retval; + switch (status) { + case wfs::ActivityStatus::Unknown: + retval = "Unknown"; + break; + case wfs::ActivityStatus::Created: + retval = "Created"; + break; + case wfs::ActivityStatus::Initialized: + retval = "Initialized"; + break; + case wfs::ActivityStatus::Running: + retval = "Running"; + break; + case wfs::ActivityStatus::Finished: + retval = "Finished"; + break; + case wfs::ActivityStatus::Error: + retval = "Error"; + break; + default: + retval = "<>"; + break; + } + return retval; +} + +inline std::string toString(const wfs::ActivityInstanceStatus& status) { + std::string retval; + switch (status) { + case wfs::ActivityInstanceStatus::Unknown: + retval = "Unknown"; + break; + case wfs::ActivityInstanceStatus::Created: + retval = "Created"; + break; + case wfs::ActivityInstanceStatus::Initialized: + retval = "Initialized"; + break; + case wfs::ActivityInstanceStatus::WaitingForData: + retval = "WaitingForData"; + break; + case wfs::ActivityInstanceStatus::WaitingForDependency: + retval = "WaitingForDependency"; + break; + case wfs::ActivityInstanceStatus::ReadyForExecution: + retval = "ReadyForExecution"; + break; + case wfs::ActivityInstanceStatus::Scheduled: + retval = "Scheduled"; + break; + case wfs::ActivityInstanceStatus::Queued: + retval = "Queued"; + break; + case wfs::ActivityInstanceStatus::WaitingForFreeResources: + retval = "WaitingForFreeResources"; + break; + case wfs::ActivityInstanceStatus::Running: + retval = "Running"; + break; + case wfs::ActivityInstanceStatus::Error: + retval = "Error"; + break; + case wfs::ActivityInstanceStatus::Finished: + retval = "Finished"; + break; + default: + retval = "<>"; + break; + } + return retval; +} + + +inline std::string toString(const wfs::ComputingResourceStatus& status) { + std::string retval; + switch (status) { + case wfs::ComputingResourceStatus::Unknown: + retval = "Unknown"; + break; + case wfs::ComputingResourceStatus::Created: + retval = "Created"; + break; + case wfs::ComputingResourceStatus::Idle: + retval = "Idle"; + break; + case wfs::ComputingResourceStatus::Sleep: + retval = "Sleep"; + break; + case wfs::ComputingResourceStatus::WokenUp: + retval = "WokenUp"; + break; + case wfs::ComputingResourceStatus::Busy: + retval = "Busy"; + break; + case wfs::ComputingResourceStatus::ExecutingTask: + retval = "ExecutingTask"; + break; + case wfs::ComputingResourceStatus::FinishedTask: + retval = "FinishedTask"; + break; + case wfs::ComputingResourceStatus::Shutdown: + retval = "Shutdown"; + break; + case wfs::ComputingResourceStatus::Error: + retval = "Error"; + break; + default: + retval = "<>"; + break; + } + return retval; +} + + +inline std::string toString(const wfs::ActivityImplementationType& type) { + std::string retval; + switch (type) { + case wfs::ActivityImplementationType::PThread: + retval = "PThread"; + break; + case wfs::ActivityImplementationType::OpenMP: + retval = "OpenMP"; + break; + case wfs::ActivityImplementationType::OpenCL: + retval = "OpenCL"; + break; + case wfs::ActivityImplementationType::CUDA: + retval = "CUDA"; + break; + default: + retval = "<>"; + break; + } + return retval; +} + + +inline std::string toString(const wfs::ComponentType& type) { + std::string retval; + switch (type) { + case wfs::ComponentType::Unknown: + retval = "Unknown"; + break; + case wfs::ComponentType::Enactment: + retval = "Enactment"; + break; + case wfs::ComponentType::Scheduler: + retval = "Scheduler"; + break; + case wfs::ComponentType::ExecutionLayer: + retval = "ExecutionLayer"; + break; + default: + retval = "<>"; + break; + } + return retval; +} + + +inline std::string toString(const wfs::ComponentStatus& state) { + std::string retval; + switch (state) { + case wfs::ComponentStatus::Unknown: + retval = "Unknown"; + break; + case wfs::ComponentStatus::Idle: + retval = "Idle"; + break; + case wfs::ComponentStatus::Busy: + retval = "Busy"; + break; + case wfs::ComponentStatus::Finished: + retval = "Finished"; + break; + case wfs::ComponentStatus::Error: + retval = "Error"; + break; + default: + retval = "<>"; + break; + } + return retval; +} + + +inline std::string toString(const wfs::ActivityType& type) { + switch (type) { + case wfs::ActivityType::Atomic: + return "Atomic"; + case wfs::ActivityType::Conditional: + return "Conditional"; + case wfs::ActivityType::Container: + return "Container"; + case wfs::ActivityType::ForLoop: + return "ForLoop"; + case wfs::ActivityType::WhileLoop: + return "WhileLoop"; + case wfs::ActivityType::Unknown: + return "Unknown"; + default: + break; + } + return "<>"; +} + + +inline std::string toString(const wfr_timestamp_sc_t& timestamp) { + std::stringstream ss; + std::time_t time = std::chrono::system_clock::to_time_t(timestamp); + std::tm* tm_time = std::localtime(&time); + char temp[30]; + std::strftime(temp, sizeof(temp), "%d.%m.%Y %H:%M:", tm_time); + ss << temp; + std::chrono::duration msecs = timestamp - std::chrono::system_clock::from_time_t(time) + std::chrono::seconds(tm_time->tm_sec); + ss << std::fixed << std::setw(9) << std::setfill('0') << msecs.count(); + return ss.str(); +} + + +} /* namespace print */ +} /* namespace wfr */ diff --git a/include/wfr/common/utils/utils.h b/include/wfr/common/utils/utils.h new file mode 100755 index 0000000..7448817 --- /dev/null +++ b/include/wfr/common/utils/utils.h @@ -0,0 +1,216 @@ + +#pragma once + + +#include +#include +#include + +namespace wfr { + + + +/** + * Copy port values. + * + * Generic case + **/ + +template +inline bool portbuffer_copy(C& dest, const C& src) { + if ( !dest.isReady() && src.isReady() ) { + dest = src; + return true; + } else { + return false; + } +} + +template +inline bool portbuffer_copy(C& dest, const lwd::_lwd_member_type& src) { + if ( !dest.isReady() && src.getValue().isReady() ) { + dest = src.getValue(); + return true; + } else { + return false; + } +} + + + +/** + * Copy port values. + * + * Specialised cases for loop ports. + **/ + +template +inline bool portbuffer_copy(lwd::_lwd_loop_port& dest, const C& src, const wfr_size_t& nextIter) { + if ( src.isReady() && dest.getNextIterationID() < nextIter ) { + dest.setValue(src.getValue()); + dest.setNextIterationID(nextIter); + return true; + } else { + return false; + } +} + +template +inline bool portbuffer_copy(C& dest, const lwd::_lwd_loop_port& src, const wfr_id_t& iterationID) { + if ( !dest.isReady() && src.getNextIterationID()-1 == iterationID ) { + dest.setValue(src.getValue()); + return true; + } else { + return false; + } +} + + + +/** + * Copy port values. + * + * Specialised cases for collections. + **/ + +template +inline bool portbuffer_copy(lwd::iwir_collection& dest, const C& src, const wfr_id_t& index) { + if (dest.getSize() <= index || !dest.getEntry(index).isReady()) { + dest.setEntryValue(index, src); + return true; + } else { + return false; + } +} + +template +inline bool portbuffer_copy(lwd::iwir_collection& dest, const lwd::_lwd_member_type& src, const wfr_id_t& index) { + if ((dest.getSize() <= index || !dest.getEntry(index).isReady()) && src.isReady() ) { + dest.setEntryValue(index, src.getValue()); + return true; + } else { + return false; + } +} + +template +inline bool portbuffer_copy(lwd::iwir_collection& dest, const lwd::iwir_collection& src, const wfr_id_t& index) { + if (dest.getSize() <= index || !dest.getEntry(index).isReady()) { + dest.setEntryValue(index, src); + return true; + } else { + return false; + } +} + +template +inline bool portbuffer_copy(lwd::iwir_collection& dest, const lwd::_lwd_member_type>& src, const wfr_id_t& index) { + if ((dest.getSize() <= index || !dest.getEntry(index).isReady()) && src.isReady() ) { + dest.setEntryValue(index, src.getValue()); + return true; + } else { + return false; + } +} + +template +struct collection_flatten { + inline wfr_size_t operator()(lwd::iwir_collection& dest, const lwd::iwir_collection& src, const wfr_id_t& index) { + wfr_size_t retval = 0; + for (wfr_size_t i = 0; i < src.getSize(); i++) { + retval += collection_flatten()(dest, src.getEntryValue(i), index + retval); + } + return retval; + } +}; + +template +struct collection_flatten { + inline wfr_size_t operator()(lwd::iwir_collection& dest, const lwd::iwir_collection& src, const wfr_id_t& index) { + for (wfr_size_t i = 0; i < src.getSize(); i++) { + if (dest.getSize() <= index+i || !dest.getEntryStatus(index + i)) { + dest.setEntryValue(index + i, src.getEntryValue(i)); + } + } + return src.getSize(); + } +}; + + +template +inline wfr_size_t portbuffer_copy_flatten(lwd::iwir_collection& dest, const lwd::iwir_collection& src, const wfr_id_t& index = 0) { + if (!dest.isReady() && src.isReady()) { + return collection_flatten()(dest, src, index); + } else { + return 0; + } +} + + +/** + * Returns whether the predecessor with the given index has finished execution. + **/ +inline bool wfr_pred_isfinished(const wfs::ActivityInstance& instance, const wfr_id_t& predIndex) { + auto predname = instance.getPredecessors()[predIndex]; + if (predname != nullptr) { + return predname->getInstanceStatus() == wfr::wfs::ActivityInstanceStatus::Finished; + } else { + return false; + } +} + + +/** + * Returns whether the predecessor with the given index is ready-for-execution. + **/ +inline bool wfr_pred_isReady(const wfr::wfs::ActivityInstance& instance, const wfr_id_t& predIndex) { + auto predname = instance.getPredecessors()[predIndex]; + if (predname != nullptr) { + return predname->getInstanceStatus() == wfr::wfs::ActivityInstanceStatus::ReadyForExecution; + } else { + return false; + } +} + + +/** + * Returns whether the previous loop iteration has finished execution. + **/ +inline bool wfr_previter_isfinished(const wfr::wfs::ActivityInstance& loopinstance, const wfr_id_t& currentIterID) { + if (currentIterID == 0) { + return true; + } else { + return loopinstance.as().hasIterationFinished(currentIterID -1); + } + +} + + +/** + * Returns whether the parent activity is ready-for-execution. + **/ +inline bool wfr_parent_isReady(const wfr::wfs::ActivityInstance& instance) { + auto predname = instance.getParentActivity(); + if (predname != nullptr) { + return predname->getInstanceStatus() == wfr::wfs::ActivityInstanceStatus::ReadyForExecution; + } else { + return false; + } +} + + +/** + * Returns whether the parent activity has finished execution. + **/ +inline bool wfr_parent_isfinished(const wfr::wfs::ActivityInstance& instance) { + auto predname = instance.getParentActivity(); + if (predname != nullptr) { + return predname->getInstanceStatus() == wfr::wfs::ActivityInstanceStatus::Finished; + } else { + return false; + } +} + + + +} // end namespace wfr diff --git a/include/wfr/common/wep/AbstractWepNode.h b/include/wfr/common/wep/AbstractWepNode.h new file mode 100755 index 0000000..1bdb3e3 --- /dev/null +++ b/include/wfr/common/wep/AbstractWepNode.h @@ -0,0 +1,79 @@ + +#pragma once + +#include +#include +#include +#include +#include +#include +#include + + +namespace wfr { + +// Forward declarations +namespace enactment { +class WepBuilder; +} + +namespace wep { + + +class AbstractWepNode { +friend class enactment::WepBuilder; + +// Static non-public properties +protected: + /** + * Static variable holding the next free wepID. + **/ + static std::atomic nextWepNodeID; + + /** + * Returns the next free wepID. + * + * @return next free wepID. + */ + static wfr_id_t getNextWepNodeID() noexcept { return nextWepNodeID.fetch_add(1); } + +// Mutable properties that need to be accessed via getter-/setter-functions. +protected: + std::vector predecessors; + std::vector successors; + std::shared_ptr userData; + uint64_t visitationCount = 0; + +// Invariant properties that can be accessed directly. +public: + const wfr_id_t nodeID; + const WepNodeType nodeType; + const bool withActivityInstance; + +// Public functions +public: + AbstractWepNode(WepNodeType nodeType, bool withInstance) noexcept + : nodeID(getNextWepNodeID()), nodeType(nodeType), withActivityInstance(withInstance) {} + virtual ~AbstractWepNode() noexcept {} + + const std::vector& getPredecessors() const noexcept { return predecessors; } + std::vector& getPredecessors() noexcept { return predecessors; } + const std::vector& getSuccessors() const noexcept { return successors; } + std::vector& getSuccessors() noexcept { return successors; } + + std::shared_ptr getUserData() const noexcept { return userData; } + void setUserData(std::shared_ptr data) noexcept { userData = data; } + + uint64_t getVisitationCount() const noexcept { return visitationCount; } + virtual void addToVisitationCount(uint64_t val = 1) noexcept { visitationCount += val; } + + template + T& as() noexcept { return *static_cast(this); } + + template + const T& as() const noexcept { return *static_cast(this); } +}; + +} /* namespace wep */ +} /* namespace wfr */ + diff --git a/include/wfr/common/wep/ActivityWepNode.h b/include/wfr/common/wep/ActivityWepNode.h new file mode 100755 index 0000000..d3b0fed --- /dev/null +++ b/include/wfr/common/wep/ActivityWepNode.h @@ -0,0 +1,43 @@ + +#pragma once + +#include + + +// Forward declarations +namespace wfr { +namespace enactment { +class WepBuilder; +} +namespace wfs { +class ActivityInstance; +} + +// Main namespace +namespace wep { + + +class ActivityWepNode : public AbstractWepNode { +friend class enactment::WepBuilder; + +// Mutable properties that need to be accessed via getter-/setter-functions. +protected: + wfr::wfs::ActivityInstanceStatus lastKnownActivityStatus; + +// Invariant properties that can be accessed directly. +public: + wfs::ActivityInstance& activity; + +public: + ActivityWepNode(WepNodeType nodeType, wfs::ActivityInstance& activity) noexcept; + + virtual void addToVisitationCount(uint64_t val = 1) noexcept override; + + virtual wfs::ActivityInstanceStatus getLastKnownInstanceStatus() const noexcept { return lastKnownActivityStatus; } + + virtual void updateInstanceStatus(); +}; + +} /* namespace wep */ +} /* namespace wfr */ + diff --git a/include/wfr/common/wep/WorkflowExecutionPlan.h b/include/wfr/common/wep/WorkflowExecutionPlan.h new file mode 100755 index 0000000..1a41a9f --- /dev/null +++ b/include/wfr/common/wep/WorkflowExecutionPlan.h @@ -0,0 +1,65 @@ + +#pragma once + + +#include +#include +#include + +// Forward declarations +namespace wfr { +namespace wfs { +class Workflow; +} + +// Main namespace +namespace wep { + + +class AbstractWepNode; + +class WorkflowExecutionPlan { + +// Static non-public properties +private: + /** + * Static variable holding the next free wepID. + **/ + static std::atomic nextWepID; + + /** + * Returns the next free wepID. + * + * @return next free wepID. + */ + static wfr_id_t getNextWepID() { return nextWepID.fetch_add(1); } + +// Mutable properties that need to be accessed via getter-/setter-functions. +private: + AbstractWepNode* startNode; + AbstractWepNode* endNode; + + wfr_id_t version = 0; + +// Invariant properties that can be accessed directly. +public: + const wfr_id_t wepID; + wfr::wfs::Workflow& workflow; + +// Public functions +public: + WorkflowExecutionPlan(wfr::wfs::Workflow& wf, AbstractWepNode* startNode, AbstractWepNode* endNode) noexcept + : startNode(startNode), endNode(endNode), wepID(getNextWepID()), workflow(wf) {} + ~WorkflowExecutionPlan() noexcept; + + AbstractWepNode* getStartNode() const noexcept { return startNode; } + AbstractWepNode* getEndNode() const noexcept { return endNode; } + + wfr_id_t getVersion() const noexcept { return version; } + + void increaseVersion(wfr_id_t value = 1) noexcept { this->version += value; } +}; + +} /* namespace wep */ +} /* namespace wfr */ + diff --git a/include/wfr/common/wep/activities/AssignWepNode.h b/include/wfr/common/wep/activities/AssignWepNode.h new file mode 100755 index 0000000..baa0094 --- /dev/null +++ b/include/wfr/common/wep/activities/AssignWepNode.h @@ -0,0 +1,29 @@ + +#pragma once + +#include + + +namespace wfr { + +// Forward declarations +namespace enactment { +class WepBuilder; +} + +namespace wep { + + +class AssignWepNode: public ActivityWepNode { +friend class enactment::WepBuilder; + +public: + AssignWepNode(wfs::ActivityInstance& instance) + : ActivityWepNode(WepNodeType::Assign, instance) {} +}; + + +} /* namespace wep */ +} /* namespace wfr */ + + diff --git a/include/wfr/common/wep/activities/AtomicWepNode.h b/include/wfr/common/wep/activities/AtomicWepNode.h new file mode 100755 index 0000000..eca2f92 --- /dev/null +++ b/include/wfr/common/wep/activities/AtomicWepNode.h @@ -0,0 +1,29 @@ + +#pragma once + +#include + + +namespace wfr { + +// Forward declarations +namespace enactment { +class WepBuilder; +} + +namespace wep { + + +class AtomicWepNode: public ActivityWepNode { +friend class enactment::WepBuilder; + +public: + AtomicWepNode(wfs::ActivityInstance& instance) + : ActivityWepNode(WepNodeType::Atomic, instance) {} +}; + + +} /* namespace wep */ +} /* namespace wfr */ + + diff --git a/include/wfr/common/wep/activities/CompositeEndWepNode.h b/include/wfr/common/wep/activities/CompositeEndWepNode.h new file mode 100755 index 0000000..3f26d01 --- /dev/null +++ b/include/wfr/common/wep/activities/CompositeEndWepNode.h @@ -0,0 +1,36 @@ + +#pragma once + +#include + + +namespace wfr { + +// Forward declarations +namespace enactment { +class WepBuilder; +} + +namespace wep { + +// Forward declarations +class CompositeStartWepNode; + + +class CompositeEndWepNode: public ActivityWepNode { +friend class enactment::WepBuilder; + +private: + CompositeStartWepNode* startNode = nullptr; + +public: + CompositeEndWepNode(wfs::ActivityInstance& instance) noexcept + : ActivityWepNode(WepNodeType::CompositeEnd, instance) {} + + CompositeStartWepNode* getStartNode() const noexcept { return startNode; } +}; + + +} /* namespace wep */ +} /* namespace wfr */ + diff --git a/include/wfr/common/wep/activities/CompositeStartWepNode.h b/include/wfr/common/wep/activities/CompositeStartWepNode.h new file mode 100755 index 0000000..662ee79 --- /dev/null +++ b/include/wfr/common/wep/activities/CompositeStartWepNode.h @@ -0,0 +1,36 @@ + +#pragma once + +#include + + +namespace wfr { + +// Forward declarations +namespace enactment { +class WepBuilder; +} + +namespace wep { + +// Forward declarations +class CompositeEndWepNode; + + +class CompositeStartWepNode: public ActivityWepNode { +friend class enactment::WepBuilder; + +private: + CompositeEndWepNode* endNode = nullptr; + +public: + CompositeStartWepNode(wfs::ActivityInstance& instance) + : ActivityWepNode(WepNodeType::CompositeStart, instance) {} + + CompositeEndWepNode* getEndNode() const noexcept { return endNode; } +}; + + +} /* namespace wep */ +} /* namespace wfr */ + diff --git a/include/wfr/common/wep/activities/IterationEndWepNode.h b/include/wfr/common/wep/activities/IterationEndWepNode.h new file mode 100755 index 0000000..7253dba --- /dev/null +++ b/include/wfr/common/wep/activities/IterationEndWepNode.h @@ -0,0 +1,42 @@ + +#pragma once + +#include + + +namespace wfr { + +// Forward declarations +namespace enactment { +class WepBuilder; +} + +namespace wep { + +class IterationStartWepNode; + + +class IterationEndWepNode: public ActivityWepNode { +friend class enactment::WepBuilder; + +private: + IterationStartWepNode* startNode = nullptr; + +public: + const wfr_id_t iterationID; + +public: + IterationEndWepNode(wfs::ActivityInstance& instance, wfr_id_t iterationID) + : ActivityWepNode(WepNodeType::IterationEnd, instance), iterationID(iterationID) {} + + virtual void updateInstanceStatus() override; + + virtual wfs::ActivityInstanceStatus getLastKnownInstanceStatus() const noexcept override; + + IterationStartWepNode* getStartNode() const noexcept { return startNode; } +}; + + +} /* namespace wep */ +} /* namespace wfr */ + diff --git a/include/wfr/common/wep/activities/IterationStartWepNode.h b/include/wfr/common/wep/activities/IterationStartWepNode.h new file mode 100755 index 0000000..7655802 --- /dev/null +++ b/include/wfr/common/wep/activities/IterationStartWepNode.h @@ -0,0 +1,40 @@ + +#pragma once + +#include + + +namespace wfr { + +// Forward declarations +namespace enactment { +class WepBuilder; +} + +namespace wep { + +class IterationEndWepNode; + + +class IterationStartWepNode: public ActivityWepNode { +friend class enactment::WepBuilder; + +private: + IterationEndWepNode* endNode = nullptr; + +public: + const wfr_id_t iterationID; + +public: + IterationStartWepNode(wfs::ActivityInstance& instance, wfr_id_t iterationID) + : ActivityWepNode(WepNodeType::IterationStart, instance), iterationID(iterationID) {} + + virtual void updateInstanceStatus() override; + + IterationEndWepNode* getEndNode() const noexcept { return endNode; } +}; + + +} /* namespace wep */ +} /* namespace wfr */ + diff --git a/include/wfr/common/wfs/Activity.h b/include/wfr/common/wfs/Activity.h new file mode 100755 index 0000000..2383d75 --- /dev/null +++ b/include/wfr/common/wfs/Activity.h @@ -0,0 +1,209 @@ + +#pragma once + + +#include +#include +#include + + +namespace wfr { + +// Forward declarations +namespace enactment { +class WepBuilder; +} + +namespace wfs { + +// Forward declarations +class Workflow; +class ActivityInstance; +class ActivityTemplate; + + +class Activity { +friend class ActivityTemplate; +friend class Workflow; +friend class enactment::WepBuilder; + +// Static non-public properties +private: + /** + * Static variable holding the next free activityID. + **/ + static std::atomic nextActivityID; + + /** + * Returns the next free activityID. + * + * @return next free activityID. + */ + static wfr_id_t getNextActivityID() { return nextActivityID.fetch_add(1); } + +// Mutable properties that need to be accessed via getter-/setter-functions. +private: + /** Status of this activity object. **/ + ActivityStatus status; + + /** Vector holding references to instances of this workflow activity. **/ + std::vector instanceList; + + /** Reference to the parent of this activity object (structure-wise). **/ + Activity* parent = nullptr; + + std::vector successors; + + std::vector predecessors; + +// Invariant properties that can be accessed directly. +public: + /** Unique ID of this workflow activity. **/ + const wfr_id_t activityID; + + /** Parent workflow instance of this activity object. **/ + Workflow& workflow; + + /** Parent activitiy template of this activity object. **/ + ActivityTemplate& baseTemplate; + + +// Non-public functions +private: + /** + * Constructor. + * + * @param workflow workflow instance this activity object belongs to. + * @param baseTemplate activity template this object is associated with. + * @param parent the parent activity of this object (structure-wise). + */ + Activity( Workflow& workflow, ActivityTemplate& baseTemplate ); + + /** + * Initialises this activity object. + * + * @param activities list of activities for successor/predecessor lists generation. + **/ + void initActivity(); + + /** + * Creates a new activity instance of this activity object. + * + * @return new activity instance. + **/ + ActivityInstance* createNewInstance(wfr_id_t iterationID = 0); + +// Public functions +public: + /** Destructor. **/ + ~Activity() noexcept; + + ActivityType activityType() const noexcept; + + bool isCompositeActivity() const noexcept; + + bool isLoop() const noexcept; + + bool isConditional() const noexcept; + + /** + * Returns the number of activity instances of this activity object. + * + * @return number of activity instances. + **/ + wfr_size_t getInstanceCount() const noexcept { return instanceList.size(); } + + /** + * Returns a reference to the vector holding the activity instance references. + * + * @return reference to the vector holding the activity instance references. + **/ + const std::vector& getInstanceList() const noexcept { return instanceList; } + + /** + * Returns the parent activity of this object (structure-wise). + * + * @return parent activity. + **/ + Activity* getParent() const noexcept { return parent; } + + wfr_size_t getChildrenCount(wfr_id_t branchID = 0) const noexcept; + + std::vector getChildren(wfr_id_t branchID = 0) const noexcept; + + + /** + * Returns the number of successors. + * + * @return number of successors. + **/ + wfr_size_t getSuccessorCount() const noexcept { return successors.size(); } + + /** + * Returns a reference to the array holding the successors. + * + * @return reference to the array holding the successors. + **/ + const std::vector getSuccessors() const noexcept { return successors; } + + /** + * Returns whether the given activityID belongs to a successor. + * + * @param aid activityID to test. + * @return true if successor, false otherwise. + */ + bool isSuccessor(wfr_id_t aid) const noexcept; + + /** + * Returns whether the given reference is a successor. + * + * @param act reference to test + * @return true if successor, false otherwise. + */ + bool isSuccessor(Activity& act) const noexcept; + + + /** + * Returns the number of predecessors. + * + * @return number of predecessors. + **/ + wfr_size_t getPredecessorCount() const noexcept { return predecessors.size(); } + + /** + * Returns a reference to the array holding the predecessors. + * + * @return reference to the array holding the predecessors. + **/ + const std::vector getPredecessors() { return predecessors; } + + /** + * Returns whether the given activityID belongs to a predecessor. + * + * @param aid activityID to test. + * @return true if predecessor, false otherwise. + */ + bool isPredecessor(wfr_id_t aid) const noexcept; + + /** + * Returns whether the given reference is a predecessor. + * + * @param act reference to test + * @return true if predecessor, false otherwise. + */ + bool isPredecessor(Activity& act) const noexcept; + + /** + * Returns the status of this activity. + * + * @return activity status. + **/ + ActivityStatus getActivityStatus() const noexcept { return status; } + + void setActivityStatus(ActivityStatus status); + +}; + +} /* namespace wfs */ +} /* namespace wfr */ + diff --git a/include/wfr/common/wfs/ActivityInstance.h b/include/wfr/common/wfs/ActivityInstance.h new file mode 100755 index 0000000..562873c --- /dev/null +++ b/include/wfr/common/wfs/ActivityInstance.h @@ -0,0 +1,282 @@ + +#pragma once + + +#include +#include +#include +#include +#include +#include + +namespace wfr { + +// Forward declarations +namespace scheduling { class SchedulingDecision; } +namespace enactment { class WepBuilder; } + +namespace wfs { + +// Forward declarations +class Activity; + + +class ActivityInstance { +friend class enactment::WepBuilder; + +// Static non-public properties +private: + /** + * Static variable holding the next free activity instanceID. + **/ + static std::atomic nextInstanceID; + + /** + * Returns the next free activity instanceID. + * + * @return next free activity instanceID. + */ + static wfr_id_t getNextInstanceID(); + +// Mutable properties that need to be accessed via getter-/setter-functions. +protected: + /** Activity instance state. **/ + ActivityInstanceStatus status; + + /** Reference to the parent of this activity instance object (structure-wise). **/ + ActivityInstance* parentActivity = nullptr; + + /** Vector of successors. **/ + std::vector successors; + + /** Vector of predecessors. **/ + std::vector predecessors; + + /** Reference to input data struct. **/ + lwd::_wfr_lwd *inputData = nullptr; + bool inputDataOwnership = false; + + /** Reference to output data struct. **/ + lwd::_wfr_lwd *outputData = nullptr; + bool outputDataOwnership = false; + + bool allInputsAvailable = false; + + bool allOutputsAvailable = false; + + std::exception_ptr errorCause; + + wfr::wfr_timestamp_sc_t readyTime; + + wfr::wfr_timestamp_sc_t startTime; + + wfr::wfr_timestamp_sc_t endTime; + + uint64_t visitationCount = 0; + + bool dirtyStateFlag = false; + + std::shared_ptr userData; + + std::shared_ptr schedulingDecision; + +// Invariant properties that can be accessed directly. +public: + /** Unique ID of this activity instance object. **/ + const wfr_id_t instanceID; + + /** Activity this object is an instance of. **/ + const Activity& baseActivity; + + const wfr_id_t iterationID; + +// Public functions +public: + /** + * Constructor. + * + * @param parentActivity activity this object is an instance of. + */ + ActivityInstance(Activity& baseActivity, const wfr_id_t& iterationID = 0) noexcept; + + /** Destructor. **/ + virtual ~ActivityInstance() noexcept { + if (inputData && inputDataOwnership) { + delete inputData; + inputData = nullptr; + } + if (outputData && outputDataOwnership) { + delete outputData; + outputData = nullptr; + } + } + + ActivityType activityType() const noexcept; + + bool isCompositeActivity() const noexcept; + + bool isLoop() const noexcept; + + bool isConditional() const noexcept; + + /** + * Returns the state of this activity instance. + * + * @return state of this activity instance. + **/ + ActivityInstanceStatus getInstanceStatus() const noexcept { return status; } + + /** + * Sets the state of this activity instance. + * + * @param status new state. + **/ + void setInstanceStatus(const ActivityInstanceStatus& status); + + /** + * + * Returns a reference to this activity instance input data. + * + * @return input data. + **/ + lwd::_wfr_lwd* const getInputData() const noexcept { return inputData; } + + /** + * Sets this instants input data. + * + * @param data input data. + */ + void setInputData(lwd::_wfr_lwd* data, bool ownership = true) noexcept { + inputData = data; + inputDataOwnership = ownership; + } + + /** + * + * Returns a reference to this activity instance output data. + * + * @return output data. + **/ + lwd::_wfr_lwd* const getOutputData() const noexcept { return outputData; } + + /** + * Sets this instants output data. + * + * @param data output data. + */ + void setOutputData(lwd::_wfr_lwd* data, bool ownership = true) noexcept { + outputData = data; + outputDataOwnership = ownership; + } + + /** + * Returns the number of predecessors. + * + * @return number of predecessors. + **/ + wfr_size_t getPredecessorCount() const noexcept { return predecessors.size(); } + + const std::vector& getPredecessors() const noexcept { return predecessors; } + + std::vector& getPredecessors() noexcept { return predecessors; } + + ActivityInstance* const getPredecessor(wfr_size_t index) const noexcept { + return predecessors.at(index); + } + + /** + * Returns the number of successors. + * + * @return number of successors. + **/ + wfr_size_t getSuccessorCount() const noexcept { return successors.size(); } + + const std::vector& getSuccessors() const noexcept { return successors; } + + std::vector& getSuccessors() noexcept { return successors; } + + ActivityInstance* const getSuccessor(int index) const noexcept { + return successors.at(index); + } + + /** + * Returns the parent of this instance (structure-wise). + * + * @return parent of this instance. + **/ + ActivityInstance* const getParentActivity() const noexcept { return parentActivity; } + + /** + * Sets the parent of this instance (structure-wise). + * + * parent parent of this instance. + **/ + void setParentActivity(ActivityInstance* parent) noexcept { this->parentActivity = parent; } + + + bool areAllInputsAvailable() const noexcept { return allInputsAvailable; } + + void setAllInputsAvailable(const bool& areAvailable = true) noexcept { allInputsAvailable = areAvailable; } + + bool areAllOutputsAvailable() const noexcept { return allOutputsAvailable; } + + void setAllOutputsAvailable(const bool& areAvailable = true) noexcept { allOutputsAvailable = areAvailable; } + + + std::exception_ptr getErrorCause() const noexcept { return errorCause; } + + void setErrorState(std::exception_ptr exception = nullptr)noexcept; + + + const wfr::wfr_timestamp_sc_t& getReadyTime() const noexcept { return readyTime; } + + const wfr::wfr_timestamp_sc_t& getStartTime() const noexcept { return startTime; } + + const wfr::wfr_timestamp_sc_t& getEndTime() const noexcept { return endTime; } + + + uint64_t getVisitationCount() const noexcept { return visitationCount; } + + void addToVisitationCount(uint64_t val = 1) noexcept { visitationCount += val; } + + + void setDirtyState() { dirtyStateFlag = true; } + + bool isDirtyState() const { return dirtyStateFlag; } + + void resetDirtyState() { dirtyStateFlag = false; } + + + virtual bool executePreExecutionHooks(bool earlyEvaluation) { return false; } + + virtual bool executeExecutionHook(bool earlyEvaluation) { return false; } + + virtual bool executePostExecutionHooks(bool earlyEvaluation) { return false; } + + std::shared_ptr getUserData() { return userData; } + + void setUserData(std::shared_ptr data) { userData = data; } + + void setSchedulingDecision(std::shared_ptr sd = std::shared_ptr()) noexcept { + if (sd) { + this->schedulingDecision = sd; + } else { + this->schedulingDecision.reset(); + } + } + + virtual void executeSimMode() noexcept; + + + + template + T& as() noexcept { return *static_cast(this); } + + template + const T& as() const noexcept { return *static_cast(this); } + +}; + +} /* namespace wfs */ +} /* namespace wfr */ + diff --git a/include/wfr/common/wfs/ActivityTemplate.h b/include/wfr/common/wfs/ActivityTemplate.h new file mode 100755 index 0000000..f663c30 --- /dev/null +++ b/include/wfr/common/wfs/ActivityTemplate.h @@ -0,0 +1,257 @@ + +#pragma once + +#include +#include +#include +#include +#include +#include + + +namespace wfr { +namespace wfs { + +// forward declarations +class Workflow; +class WorkflowTemplate; +class Activity; +class AtomicActivityImplementation; +class AtomicActivityType; + + +class ActivityTemplate { +friend class WorkflowTemplate; +friend class Workflow; +friend class Activity; +// Mutable properties that need to be accessed via getter-/setter-functions. +protected: + /** Parent activity. **/ + ActivityTemplate* parentActivity = nullptr; + + /** Parent workflow. **/ + WorkflowTemplate* parentWorkflow = nullptr; + + // Successors + std::initializer_list succRawList; + std::vector successors; + + // Predecessors + std::initializer_list predRawList; + std::vector predecessors; + +// Invariant properties that can be accessed directly. +public: + /** Unique ID (>0).**/ + const wfr_id_t templateID; + + const std::string activityName; + + const ActivityType activityType; + + const wfr_size_t parentActivityID; + + /** BranchID of the parents execution branch (0 represents default branch). **/ + const wfr_id_t branchID; + + const bool isCompositeActivity; + + const bool isLoop; + + const bool isConditional; + +// Non-public functions. +protected: + /** + * Constructor. + * + * @param id templateID of this template object. + * @param type type of this template object. + * @param branchID ID of the parents (structure-wise) execution branch this object belongs to. + * @param succList list of templateIDs representing this objects successors (structure-wise). + * @param predList list of templateIDs representing this objects predecessors (structure-wise). + * @param name activity name of this object. + **/ + ActivityTemplate( wfr_id_t id, + ActivityType type, + const std::string& name, + wfr_id_t parentID, + wfr_id_t branchID, + const std::initializer_list& succList, + const std::initializer_list& predList, + bool isCompositeActivity, + bool isLoop, + bool isConditional ) noexcept; + + void initActivityTemplate(WorkflowTemplate& parentWorkflow); + + virtual void checkStructure(); + + Activity* createActivityFromTemplate(wfr::wfs::Workflow& workflow); + +// Public functions. +public: + virtual ~ActivityTemplate() noexcept {} + + ActivityTemplate* getParentActivity() const noexcept { return parentActivity;} + + WorkflowTemplate* getParentWorkflow() const noexcept { + assert(parentWorkflow != nullptr); + return parentWorkflow; + } + + /** + * Returns the number of this objects successors. + * @return number of successors. + **/ + wfr_size_t getSuccessorCount() const noexcept { return successors.size(); } + + /** + * Returns all successors. + * @return reference to vector with successors + **/ + const std::vector& getSuccessors() const noexcept { return successors; } + + /** + * Returns the successor with the given index. + * @param index index of successor + * @return successor with given index + **/ + ActivityTemplate* getSuccessor(wfr_size_t index) const noexcept { + if (index < successors.size()) { + return successors[index]; + } else { + return nullptr; + } + } + + /** + * Returns whether the given activity is a successor of this object. + * @param activity reference to test. + * @return true if the given reference represents a successor, otherwise false. + **/ + bool isSuccessor(const ActivityTemplate& activity) const noexcept { + for (auto i : successors) { + if (i == &activity) { + return true; + } + } + return false; + } + + /** + * Returns the number of this objects predecessors. + * @return number of predecessors. + **/ + wfr_size_t getPredecessorCount() const noexcept { return predecessors.size(); } + + /** + * Returns all predecessors. + * @return reference to vector with predecessors + **/ + const std::vector& getPredecessors() const noexcept { return predecessors; } + + /** + * Returns the predecessor with the given index. + * @param index index of predecessor + * @return predecessor with given index + **/ + ActivityTemplate* getPredecessor(wfr_size_t index) const noexcept { + if (index < predecessors.size()) { + return predecessors[index]; + } else { + return nullptr; + } + } + + /** + * Returns whether the given activity is a successor of this object. + * @param activity reference to test. + * @return true if the given reference represents a successor, otherwise false. + **/ + bool isPredecessor(const ActivityTemplate& activity) const noexcept { + for (auto i : predecessors) { + if (i == &activity) { + return true; + } + } + return false; + } + + template + T& as() noexcept { return *static_cast(this); } + + template + const T& as() const noexcept { return *static_cast(this); } + + +/* ********************************************************** * + * Convenience functions for activity template instantiation. * + * ********************************************************** */ +public: + + static ActivityTemplate* atomic( wfr_id_t id, + const std::string& name, + wfr_id_t parentID, + wfr_id_t branchID, + std::initializer_list succList, + std::initializer_list predList, + InputHookFunc inputHook, + std::shared_ptr atomicActivityType ); + + static ActivityTemplate* assign( wfr_id_t id, + const std::string& name, + wfr_id_t parentID, + wfr_id_t branchID, + std::initializer_list succList, + std::initializer_list predList, + InputHookFunc inputHook, + ExecutionHookFunc execHook ); + + static ActivityTemplate* container( wfr_id_t id, + const std::string& name, + wfr_id_t parentID, + wfr_id_t branchID, + std::initializer_list succList, + std::initializer_list predList, + InputHookFunc inputHook, + OutputHookFunc outputHook ); + + static ActivityTemplate* forLoop( wfr_id_t id, + const std::string& name, + wfr_id_t parentID, + wfr_id_t branchID, + const std::initializer_list& succList, + const std::initializer_list& predList, + InputHookFunc inputFuncHook, + OutputHookFunc outputFuncHook, + ForCounterHookFunc counterFuncHook, + LoopIterationHookFunc iterationFuncHook, + bool isParallel ); + + static ActivityTemplate* whileLoop( wfr_id_t id, + const std::string& name, + wfr_id_t parentID, + wfr_id_t branchID, + const std::initializer_list& succList, + const std::initializer_list& predList, + InputHookFunc inputFuncHook, + OutputHookFunc outputFuncHook, + WhileConditionHookFunc conditionFuncHook, + LoopIterationHookFunc iterationFuncHook ); + + static ActivityTemplate* conditional( wfr_id_t id, + const std::string& name, + wfr_id_t parentID, + wfr_id_t branchID, + const std::initializer_list& succList, + const std::initializer_list& predList, + InputHookFunc inputFuncHook, + OutputHookFunc outputFuncHook, + BranchConditionHookFunc branchFuncHook ); +}; + + +} /* namespace wfs */ +} /* namespace wfr */ + diff --git a/include/wfr/common/wfs/AtomicActivityImplementation.h b/include/wfr/common/wfs/AtomicActivityImplementation.h new file mode 100755 index 0000000..f32dd8c --- /dev/null +++ b/include/wfr/common/wfs/AtomicActivityImplementation.h @@ -0,0 +1,124 @@ + +#pragma once + +#include +#include +#include +#include +#include +#include +#include + + +namespace wfr { +namespace wfs { + + +/** + * Base class for atomic activity implementations. + * + * Must be cast to type specific class to be able to access type specific information. + * Currently implemented sub-classes: + * x) PThreadActivityImplementation + * x) OpenCLActivityImplementation + * x) CUDAActivityImplementation + **/ +class AtomicActivityImplementation { + +// Static objects to guarantee unique implementation IDs. +private: + static std::atomic nextImplementationID; + static wfr_id_t getNextImplementationID() { + return nextImplementationID.fetch_add(1); + } + +// Mutable properties that need to be accessed via getter-/setter-functions. +protected: + std::vector requiredCapabilities; + utils::Properties properties; + +// Invariant properties that can be accessed directly. +public: + const wfr_id_t implementationID; + const ActivityImplementationType implementationType; + const std::string name; + +// Non-public functions. +protected: + AtomicActivityImplementation( ActivityImplementationType implementationType, + const std::vector& capabilities, + const utils::Properties& properties, + const std::string& name) noexcept + : requiredCapabilities(capabilities), properties(properties), + implementationID(getNextImplementationID()), implementationType(implementationType), name(name) {} + +// Public functions. +public: + virtual ~AtomicActivityImplementation() noexcept {} + + /** + * Returns a vector with capabilities required for execution of this implementation. + **/ + const std::vector& getRequiredCapabilities() const noexcept { return requiredCapabilities; } + + /** + * Returns properties associated with this implementation. + **/ + const utils::Properties& getProperties() const noexcept { return properties; } + + /** + * Helper function to ease cast operations. + **/ + template + T& as() noexcept { return *static_cast(this); } + + /** + * Const helper function to ease cast operations. + **/ + template + const T& as() const noexcept { return *static_cast(this); } + +/* + * Static factory functions for creating activity implementation objects. + * + * Returned objects need to be manually deleted (Using smartpointers here causes too much overhead). + * AtomicActivityImplementation objects are usually passed to an AtomicActivityType object which manages the lifecycle. + */ +public: + /** + * Returns a new pthread implementation object. + * + * Do not add GenericCPU capability as it is already automatically added. + **/ + static AtomicActivityImplementation* PThread( const ExecutionHookFunc& executionFuncHook, + const std::string& name = "", + utils::PropertyList properties = {}, + resource::RequiredCapabilityList capabilities = {} ) noexcept; + + /** + * Returns a new OpenCL implementation object. + * + * Do not add OpenCL capability as it is already automatically added. + **/ + static AtomicActivityImplementation* OpenCL( const ExecutionHookFunc& executionFuncHook, + const std::string& name = "", + std::initializer_list minVersion = {0, 0}, + std::initializer_list maxVersion = {0, 0}, + utils::PropertyList properties = {}, + resource::RequiredCapabilityList capabilities = {} ) noexcept; + + /** + * Returns a new CUDA implementation object. + **/ + static AtomicActivityImplementation* CUDA( const ExecutionHookFunc& executionFuncHook, + const std::string& name = "", + std::initializer_list minVersion = {0, 0}, + std::initializer_list maxVersion = {0, 0}, + utils::PropertyList properties = {}, + resource::RequiredCapabilityList capabilities = {} ) noexcept; +}; + + +} /* namespace wfs */ +} /* namespace wfr */ + diff --git a/include/wfr/common/wfs/AtomicActivityType.h b/include/wfr/common/wfs/AtomicActivityType.h new file mode 100755 index 0000000..91aaf82 --- /dev/null +++ b/include/wfr/common/wfs/AtomicActivityType.h @@ -0,0 +1,68 @@ + +#pragma once + +#include +#include +#include +#include +#include +#include + + +namespace wfr { +namespace wfs { + +// forward declarations +class AtomicActivityImplementation; + +/** + * Represents an atomic activity type. + **/ +class AtomicActivityType { + +// Mutable properties that need to be accessed via getter-/setter-functions. +private: + std::vector implementations; + +// Invariant properties that can be accessed directly. +public: + const std::string name; + +// Non-public functions. +private: + AtomicActivityType(const std::string& name, const std::initializer_list& implementations) noexcept + : implementations(implementations), name(name) {} + +// Public functions. +public: + ~AtomicActivityType() noexcept; + + /** + * Returns the number of implementations. + **/ + wfr_size_t getImplementationCount() const noexcept { return implementations.size(); } + + /** + * Returns a vector containing all implementations. + **/ + const std::vector& getImplementations() const noexcept { return implementations; } + + +/* + * Static factory functions for creating atomic activity type objects. + * + * Returned objects may be referenced by more than one object and there is no single parent object, + * therefore we are using shared pointers. + */ +public: + /** + * Returns a new atomic activity type object. + **/ + static std::shared_ptr create(const std::string& name, const std::initializer_list& implementations) noexcept { + return std::shared_ptr(new AtomicActivityType(name, implementations)); + } +}; + + +} /* namespace wfs */ +} /* namespace wfr */ diff --git a/include/wfr/common/wfs/Workflow.h b/include/wfr/common/wfs/Workflow.h new file mode 100755 index 0000000..7fe568e --- /dev/null +++ b/include/wfr/common/wfs/Workflow.h @@ -0,0 +1,260 @@ + +#pragma once + +#include +#include +#include +#include +#include +#include +#include +#include + +namespace wfr { +namespace wfs { + +// Forward declarations +class Activity; +class WorkflowTemplate; + + +class Workflow { +friend class WorkflowTemplate; + +// Static non-public properties +private: + /** + * Static variable holding the next free workflow instanceID. + **/ + static std::atomic nextWorkflowID; + + /** + * Returns the next free workflow instanceID. + * + * @return next free workflow instanceID. + */ + static wfr_id_t getNextWorkflowID() { return nextWorkflowID.fetch_add(1); } + +// Mutable properties that need to be accessed via getter-/setter-functions. +private: + /** + * The current status of this workflow instance. + **/ + WorkflowStatus status; + + /** + * Flag to indicate that the workflow is about to be finished. + */ + bool finishFlag = false; + + /** + * Vector holding the activities of this workflow instance. + **/ + std::vector activities; + + /** + * Reference to top-level activity. + **/ + Activity* topLevelActivity = nullptr; + + /** + * Cause of error. + **/ + std::exception_ptr errorCause; + + wfr::wfr_timestamp_sc_t createTime; + wfr::wfr_timestamp_sc_t startTime; + wfr::wfr_timestamp_sc_t endTime; + + #ifdef WFR_ENABLE_STATISTICS + std::mutex statMutex; + + wfr::wfr_duration_sc_t enactmentTime = wfr::wfr_duration_sc_t::zero(); + + std::atomic createdCompositeInstanceCount = ATOMIC_VAR_INIT(0); + std::atomic finishedCompositeInstanceCount = ATOMIC_VAR_INIT(0); + std::atomic errorCompositeInstanceCount = ATOMIC_VAR_INIT(0); + + std::atomic createdAtomicInstanceCount = ATOMIC_VAR_INIT(0); + std::atomic finishedAtomicInstanceCount = ATOMIC_VAR_INIT(0); + std::atomic errorAtomicInstanceCount = ATOMIC_VAR_INIT(0); + + wfr::wfr_duration_sc_t cumulativeAtomicReadyWaitingDuration = wfr::wfr_duration_sc_t::zero(); + wfr::wfr_duration_sc_t cumulativeAtomicRunningDuration = wfr::wfr_duration_sc_t::zero(); + + std::atomic wepNodeCount = ATOMIC_VAR_INIT(0); + std::atomic wepVisitationCount = ATOMIC_VAR_INIT(0); + std::atomic wepUpdateCount = ATOMIC_VAR_INIT(0); + std::atomic wepUpdateNotifyCount = ATOMIC_VAR_INIT(0); + + std::atomic cummulativePredictionTime = ATOMIC_VAR_INIT(0.0); + #endif + +// Invariant properties that can be accessed directly. +public: + /** + * The instanceID of this workflow instance object. + **/ + const wfr_id_t workflowID; + + /** + * The parent workflow object of this workflow instance. + **/ + WorkflowTemplate& baseTemplate; + + +// Non-public functions +private: + /** + * Constructor + * + * @param parent parent workflow object of this workflow instance. + */ + Workflow(WorkflowTemplate& baseTemplate); + +// Public functions +public: + /** Destructor. **/ + ~Workflow() noexcept; + + /** + * Returns the status of this workflow instance. + * + * @return workflow instance status. + */ + WorkflowStatus getWorkflowStatus() const noexcept { return status; } + + void setWorkflowStatus (WorkflowStatus status); + + bool getFinishFlag() { return finishFlag; } + + void setFinishFlag(bool val = true) { finishFlag = val; } + + /** + * Returns the number of contained workflow activities. + * + * @return number of contained workflow activities. + **/ + wfr_size_t getActivityCount() const noexcept { return activities.size(); } + + /** + * Returns a reference to the static array holding the contained workflow activities. + * + * @return Reference to the array of contained workflow activities. + */ + const std::vector getActivities() const noexcept { return activities; } + + /** + * Returns the workflow activity with the given activityID. + * + * @param id activityID. + * @return workflow activity with the given activityID. + */ + Activity* getActivityByID(wfr_id_t id) const noexcept; + + /** + * Returns the workflow activity with the given templateID. + * + * @param id templateID. + * @return workflow activity with the given templateID. + */ + Activity* getActivityByTemplateID(wfr_id_t id) const noexcept; + + /** + * Returns a reference to the top-level activity. + * + * @return top-level activity. + */ + Activity* getTopLevelActivity() const noexcept { + assert(topLevelActivity); + return topLevelActivity; + } + + /** + * Starts the execution of this workflow instance. + * + * The function blocks till the execution has finished. + * + * @param input reference to workflow input data. + * @param output reference to workflow output data. + * @return + */ + WorkflowStatus executeSync( lwd::_wfr_lwd* input, lwd::_wfr_lwd* output ); + + + std::exception_ptr getErrorCause() const noexcept { return errorCause; } + void setErrorState(std::exception_ptr cause = std::exception_ptr()); + + + const wfr::wfr_timestamp_sc_t& getCreateTime() const noexcept { return createTime; } + const wfr::wfr_timestamp_sc_t& getStartTime() const noexcept { return startTime; } + const wfr::wfr_timestamp_sc_t& getEndTime() const noexcept { return endTime; } + wfr::wfr_duration_sc_t getWorkflowDuration() const noexcept { return endTime - startTime; }; + wfr::wfr_duration_sc_t getMakespan() const noexcept { return endTime - createTime; }; + + #ifdef WFR_ENABLE_STATISTICS + + wfr::wfr_duration_sc_t getEnactmentTime() const noexcept { return enactmentTime; } + void addToEnactmentTime(wfr::wfr_duration_sc_t time) { + std::lock_guard lock(statMutex); + enactmentTime += time; + } + + wfr_size_t getCreatedCompositeInstanceCount() { return createdCompositeInstanceCount; } + void addToCreatedCompositeInstanceCount(wfr_size_t value = 1) { createdCompositeInstanceCount.fetch_add(value); } + + wfr_size_t getFinishedCompositeInstanceCount() { return finishedCompositeInstanceCount; } + void addToFinishedCompositeInstanceCount(wfr_size_t value = 1) { finishedCompositeInstanceCount.fetch_add(value); } + + wfr_size_t getErrorCompositeInstanceCount() { return errorCompositeInstanceCount; } + void addToErrorCompositeInstanceCount(wfr_size_t value = 1) { errorCompositeInstanceCount.fetch_add(value); } + + + wfr_size_t getCreatedAtomicInstanceCount() { return createdAtomicInstanceCount; } + void addToCreatedAtomicInstanceCount(wfr_size_t value = 1) { createdAtomicInstanceCount.fetch_add(value); } + + wfr_size_t getFinishedAtomicInstanceCount() { return finishedAtomicInstanceCount; } + void addToFinishedAtomicInstanceCount(wfr_size_t value = 1) { finishedAtomicInstanceCount.fetch_add(value); } + + wfr_size_t getErrorAtomicInstanceCount() { return errorAtomicInstanceCount; } + void addToErrorAtomicInstanceCount(wfr_size_t value = 1) { errorAtomicInstanceCount.fetch_add(value); } + + wfr::wfr_duration_sc_t getCumulaticeAtomicRunningDuration() { + std::lock_guard lock(statMutex); + return cumulativeAtomicRunningDuration; + } + void addToCumulaticeAtomicRunningDuration(wfr::wfr_duration_sc_t time) { + std::lock_guard lock(statMutex); + cumulativeAtomicRunningDuration += time; + } + + wfr::wfr_duration_sc_t getCumulaticeAtomicReadyWaitingDuration() { + std::lock_guard lock(statMutex); + return cumulativeAtomicReadyWaitingDuration; + } + void addToCumulaticeAtomicReadyWaitingDuration(wfr::wfr_duration_sc_t time) { + std::lock_guard lock(statMutex); + cumulativeAtomicReadyWaitingDuration += time; + } + + wfr_size_t getWepNodeCount() { return wepNodeCount; } + void setWepNodeCount(wfr_size_t count) { wepNodeCount = count; } + + wfr_size_t getWepVisitationCount() { return wepVisitationCount; } + void addToWepVisitationCount(wfr_size_t value = 1) { wepVisitationCount.fetch_add(value); } + + wfr_size_t getWepUpdateCount() { return wepUpdateCount; } + void addToWepUpdateCount(wfr_size_t value = 1) { wepUpdateCount.fetch_add(value); } + + wfr_size_t getWepUpdateNotifyCount() { return wepUpdateNotifyCount; } + void addToWepUpdateNotifyCount(wfr_size_t value = 1) { wepUpdateNotifyCount.fetch_add(value); } + + void printStatistics(std::ostream& sout = std::cout); + + #endif + +}; + +} /* namespace wfs */ +} /* namespace wfr */ + diff --git a/include/wfr/common/wfs/WorkflowTemplate.h b/include/wfr/common/wfs/WorkflowTemplate.h new file mode 100755 index 0000000..9cdedb3 --- /dev/null +++ b/include/wfr/common/wfs/WorkflowTemplate.h @@ -0,0 +1,102 @@ + +#pragma once + +#include +#include +#include + + +namespace wfr { +namespace wfs { + + +class ActivityTemplate; +class Workflow; + +/** + * Represents a workflow. + * + * Holds all invariant information that can be shared between different workflow instances (e.g. workflow name, structure). + **/ +class WorkflowTemplate { +// Mutable properties that need to be accessed via getter-/setter-functions. +private: + std::vector activities; + ActivityTemplate* toplevelActivity = nullptr; + +// Invariant properties that can be accessed directly. +public: + const std::string workflowName; + const wfr_id_t topLevelActivityID; + +// Non-public functions. +private: + void checkStructure(); + +// Public functions. +public: + /** + * Constructor. + * + * @param activities workflow activity templates. + * @param topLevelActivityID ID of top-level workflow activity template. + * @param name name of the workflow. + **/ + WorkflowTemplate( const std::string& name, + wfr_id_t topLevelActivityID, + std::initializer_list activities ); + + ~WorkflowTemplate() noexcept; + + /** + * Returns the number of workflow activities. + * + * @return number of workflow activities + **/ + wfr_size_t getActivityCount() const noexcept { return activities.size(); } + + /** + * Returns a pointer to the array of workflow activities. + * + * @return pointer to the array of workflow activities + **/ + const std::vector& getActivities() const noexcept { return activities; } + + /** + * Returns the activity template with the specified ID. + * + * @param id ID of workflow activity template. + * @return workflow activity template. + **/ + ActivityTemplate* getActivityByID(wfr_id_t id) const noexcept; + + /** + * Returns the ID of the top-level workflow activity template. + * + * @return ID of the top-level workflow activity template. + **/ + wfr_id_t getTopLevelActivityID() const noexcept { return topLevelActivityID; } + + /** + * Returns the top-level workflow activity template. + * + * @return top-level workflow activity template. + **/ + ActivityTemplate* getTopLevelActivity() const noexcept { return toplevelActivity; } + + + /** + * Executes the workflow. + * + * Blocks till execution has finished. + * + * @param input workflow input data. + * @param input workflow output data. + * @return status. + **/ + std::shared_ptr execute(lwd::_wfr_lwd* input, lwd::_wfr_lwd* output); +}; + +} /* namespace wfs */ +} /* namespace wfr */ + diff --git a/include/wfr/common/wfs/implementations/CUDAActivityImplementation.h b/include/wfr/common/wfs/implementations/CUDAActivityImplementation.h new file mode 100755 index 0000000..41b5100 --- /dev/null +++ b/include/wfr/common/wfs/implementations/CUDAActivityImplementation.h @@ -0,0 +1,26 @@ + +#pragma once + +#include + + +namespace wfr { +namespace wfs { + + +class CUDAActivityImplementation : public AtomicActivityImplementation { +public: + const ExecutionHookFunc executionFuncHook; +public: + CUDAActivityImplementation( const ExecutionHookFunc& executionFuncHook, + const std::vector& capabilities, + const utils::Properties& properties, + const std::string& name = "") noexcept + : AtomicActivityImplementation(ActivityImplementationType::CUDA, capabilities, properties, name), + executionFuncHook(executionFuncHook) {} +}; + + +} /* namespace wfs */ +} /* namespace wfr */ + diff --git a/include/wfr/common/wfs/implementations/OpenCLActivityImplementation.h b/include/wfr/common/wfs/implementations/OpenCLActivityImplementation.h new file mode 100755 index 0000000..980ce4d --- /dev/null +++ b/include/wfr/common/wfs/implementations/OpenCLActivityImplementation.h @@ -0,0 +1,26 @@ + +#pragma once + +#include + + +namespace wfr { +namespace wfs { + + +class OpenCLActivityImplementation : public AtomicActivityImplementation { +public: + const ExecutionHookFunc executionFuncHook; +public: + OpenCLActivityImplementation( const ExecutionHookFunc& executionFuncHook, + const std::vector& capabilities, + const utils::Properties& properties, + const std::string& name = "") noexcept + : AtomicActivityImplementation(ActivityImplementationType::OpenCL, capabilities, properties, name), + executionFuncHook(executionFuncHook) {} +}; + + +} /* namespace wfs */ +} /* namespace wfr */ + diff --git a/include/wfr/common/wfs/implementations/PThreadActivityImplementation.h b/include/wfr/common/wfs/implementations/PThreadActivityImplementation.h new file mode 100755 index 0000000..3fe9b5c --- /dev/null +++ b/include/wfr/common/wfs/implementations/PThreadActivityImplementation.h @@ -0,0 +1,26 @@ + +#pragma once + +#include + + +namespace wfr { +namespace wfs { + + +class PThreadActivityImplementation : public AtomicActivityImplementation { +public: + const ExecutionHookFunc executionFuncHook; +public: + PThreadActivityImplementation( const ExecutionHookFunc& executionFuncHook, + const std::vector& capabilities, + const utils::Properties& properties, + const std::string& name ) noexcept + : AtomicActivityImplementation(ActivityImplementationType::PThread, capabilities, properties, name), + executionFuncHook(executionFuncHook) {} +}; + + +} /* namespace wfs */ +} /* namespace wfr */ + diff --git a/include/wfr/common/wfs/instances/AssignActivityInstance.h b/include/wfr/common/wfs/instances/AssignActivityInstance.h new file mode 100755 index 0000000..fc7f766 --- /dev/null +++ b/include/wfr/common/wfs/instances/AssignActivityInstance.h @@ -0,0 +1,29 @@ + +#pragma once + +#include + +namespace wfr { +namespace wfs { + +// Forward declarations +class Activity; +class AtomicActivityImplementation; + + +class AssignActivityInstance: public wfr::wfs::ActivityInstance { + +// Public functions +public: + AssignActivityInstance(Activity& baseActivity, wfr_id_t iterationID = 0) noexcept + : ActivityInstance(baseActivity, iterationID) {} + + virtual bool executePreExecutionHooks(bool earlyEvaluation) override; + + virtual bool executeExecutionHook(bool earlyEvaluation) override; + + virtual void notifyParent() noexcept; +}; + +} /* namespace wfs */ +} /* namespace wfr */ diff --git a/include/wfr/common/wfs/instances/AtomicActivityInstance.h b/include/wfr/common/wfs/instances/AtomicActivityInstance.h new file mode 100755 index 0000000..1ddc90b --- /dev/null +++ b/include/wfr/common/wfs/instances/AtomicActivityInstance.h @@ -0,0 +1,33 @@ + +#pragma once + +#include + +namespace wfr { +namespace wfs { + +// Forward declarations +class Activity; +class AtomicActivityImplementation; + + +class AtomicActivityInstance: public wfr::wfs::ActivityInstance { + +// Mutable properties that need to be accessed via getter-/setter-functions. +protected: + bool _ownedByExecutionLayer = false; + +// Public functions +public: + AtomicActivityInstance(Activity& baseActivity, wfr_id_t iterationID = 0) noexcept + : ActivityInstance(baseActivity, iterationID) {} + + virtual bool executePreExecutionHooks(bool earlyEvaluation) override; + + bool ownedByExecutionLayer() const noexcept { return _ownedByExecutionLayer; } + + void setOwnedByExecutionLayer(bool owned) noexcept { _ownedByExecutionLayer = owned; } +}; + +} /* namespace wfs */ +} /* namespace wfr */ diff --git a/include/wfr/common/wfs/instances/CompositeActivityInstance.h b/include/wfr/common/wfs/instances/CompositeActivityInstance.h new file mode 100755 index 0000000..7d19869 --- /dev/null +++ b/include/wfr/common/wfs/instances/CompositeActivityInstance.h @@ -0,0 +1,48 @@ + +#pragma once + +#include + +#include + +namespace wfr { + +// Forward declaration +namespace enactment { +class WepBuilder; +} + +namespace wfs { + +// Forward declarations +class Activity; + + +class CompositeActivityInstance: public wfr::wfs::ActivityInstance { +friend class enactment::WepBuilder; + +// Mutable properties that need to be accessed via getter-/setter-functions. +protected: + std::vector children; + std::map childrenByInstanceID; + std::map> childrenByActivityID; + wfr_size_t finishedChildrenCount = 0; + +// Public functions +public: + CompositeActivityInstance(Activity& baseActivity, wfr_id_t iterationID = 0) noexcept + : ActivityInstance(baseActivity, iterationID) {} + + wfr_size_t getChildrenCount() const noexcept { return children.size(); } + const std::vector& getChildren() const noexcept { return children; } + ActivityInstance* getChild(wfr_id_t instanceID) const noexcept; + ActivityInstance* getChild(wfr_id_t activityID, wfr_id_t iterationID) const noexcept; + + + wfr_size_t getFinishedChildrenCount() const noexcept { return finishedChildrenCount; } + + virtual void notifyChildHasFinished(ActivityInstance& ai) noexcept; +}; + +} /* namespace wfs */ +} /* namespace wfr */ diff --git a/include/wfr/common/wfs/instances/ConditionalActivityInstance.h b/include/wfr/common/wfs/instances/ConditionalActivityInstance.h new file mode 100755 index 0000000..e0d852b --- /dev/null +++ b/include/wfr/common/wfs/instances/ConditionalActivityInstance.h @@ -0,0 +1,34 @@ + +#pragma once + +#include + +namespace wfr { +namespace wfs { + +// Forward declarations +class Activity; + + +class ConditionalActivityInstance: public CompositeActivityInstance { + +// Mutable properties that need to be accessed via getter-/setter-functions. +private: + wfr_size_t activeExecutionBranchID = 0; + +// Public functions +public: + ConditionalActivityInstance(Activity& baseActivity, wfr_id_t iterationID = 0) noexcept + : CompositeActivityInstance(baseActivity, iterationID) {} + + wfr_id_t getExecutionBranchID() const noexcept { return activeExecutionBranchID; } + + void setExecutionBranchID(wfr_size_t branchId) noexcept { this->activeExecutionBranchID = branchId; } + + virtual bool executePreExecutionHooks(bool earlyEvaluation) override; + + virtual bool executePostExecutionHooks(bool earlyEvaluation) override; +}; + +} /* namespace wfs */ +} /* namespace wfr */ diff --git a/include/wfr/common/wfs/instances/ContainerActivityInstance.h b/include/wfr/common/wfs/instances/ContainerActivityInstance.h new file mode 100755 index 0000000..d98eeda --- /dev/null +++ b/include/wfr/common/wfs/instances/ContainerActivityInstance.h @@ -0,0 +1,26 @@ + +#pragma once + +#include + +namespace wfr { +namespace wfs { + +// Forward declarations +class Activity; + + +class ContainerActivityInstance: public CompositeActivityInstance { + +// Public functions +public: + ContainerActivityInstance(Activity& baseActivity, wfr_id_t iterationID = 0) noexcept + : CompositeActivityInstance(baseActivity, iterationID) {} + + virtual bool executePreExecutionHooks(bool earlyEvaluation) override; + + virtual bool executePostExecutionHooks(bool earlyEvalation) override; +}; + +} /* namespace wfs */ +} /* namespace wfr */ diff --git a/include/wfr/common/wfs/instances/ForLoopActivityInstance.h b/include/wfr/common/wfs/instances/ForLoopActivityInstance.h new file mode 100755 index 0000000..78f3cad --- /dev/null +++ b/include/wfr/common/wfs/instances/ForLoopActivityInstance.h @@ -0,0 +1,50 @@ + +#pragma once + +#include + + +namespace wfr { +namespace wfs { + +// Forward declarations +class Activity; + + +class ForLoopActivityInstance: public LoopActivityInstance { + +// Mutable properties that need to be accessed via getter-/setter-functions. +private: + wfr_size_t loopCounterStart = 0; + wfr_size_t loopCounterStep = 1; + wfr_size_t loopCounterMax = 0; + bool loopCounterValueSet = false; + +// Public functions +public: + ForLoopActivityInstance(Activity& baseActivity, bool isParallel, wfr_id_t iterationID = 0) noexcept + : LoopActivityInstance(baseActivity, isParallel, iterationID) {} + + + void setLoopCounter(wfr_size_t start, wfr_size_t step, wfr_size_t max); + + wfr_size_t getLoopCounterStart() const noexcept { return loopCounterStart; } + + wfr_size_t getLoopCounterStep() const noexcept { return loopCounterStep; } + + wfr_size_t getLoopCounterMax() const noexcept { return loopCounterMax; } + + bool isLoopCounterValueAvailable() const noexcept { return loopCounterValueSet; } + + wfr_size_t getLoopCounterValue(wfr_id_t iterationID) const noexcept { return loopCounterStart + (iterationID * loopCounterStep); } + + + virtual void notifyChildHasFinished(ActivityInstance& ai) noexcept; + + virtual bool executePreExecutionHooks(bool earlyEvaluation) override; + + virtual bool executePostExecutionHooks(bool earlyEvaluation) override; +}; + +} /* namespace wfs */ +} /* namespace wfr */ diff --git a/include/wfr/common/wfs/instances/LoopActivityInstance.h b/include/wfr/common/wfs/instances/LoopActivityInstance.h new file mode 100755 index 0000000..a6348ad --- /dev/null +++ b/include/wfr/common/wfs/instances/LoopActivityInstance.h @@ -0,0 +1,75 @@ + +#pragma once + +#include +#include + +namespace wfr { + +// Forward declarations +namespace enactment { +class WepBuilder; +} + +namespace wfs { + +// Forward declarations +class Activity; + + +class LoopActivityInstance: public CompositeActivityInstance { +friend class enactment::WepBuilder; + +// Mutable properties that need to be accessed via getter-/setter-functions. +protected: + wfr_size_t iterationCount = 0; + wfr_size_t handledIterationCount = 0; + bool finalisedFlag = false; + std::vector finishedChildrenPerIteration; + std::vector finishedIterations; + std::vector runningIterations; + +// Invariant properties that can be accessed directly. +public: + const bool isParallel; + +// Public functions +public: + LoopActivityInstance(Activity& baseActivity, bool isParallel, wfr_id_t iterationID = 0) noexcept + : CompositeActivityInstance(baseActivity, iterationID), isParallel(isParallel) {} + + wfr_size_t getIterationCount() const noexcept { return iterationCount; } + + void setIterationCount(wfr_size_t count) noexcept; + + void setHandledIterationCount(wfr_size_t handledIterationCount) noexcept { this->handledIterationCount = handledIterationCount; } + + wfr_size_t getHandledIterationCount() const noexcept { return handledIterationCount; } + + bool isFinalised() const noexcept { return finalisedFlag; } + + void setFinalised(bool v) noexcept { finalisedFlag = v; } + + bool hasIterationFinished(wfr_id_t iterationID) const noexcept { + if (iterationID < finishedIterations.size()) + return finishedIterations[iterationID]; + else + return false; + } + + bool isIterationRunning(wfr_id_t iterationID)const noexcept { + if (iterationID < runningIterations.size()) + return runningIterations[iterationID]; + else + return false; + } + + ActivityInstanceStatus getIterationInstanceStatus(wfr_id_t iterationID) const noexcept; + + + virtual void notifyChildHasFinished(ActivityInstance& ai) noexcept override; +}; + + +} /* namespace wfs */ +} /* namespace wfr */ diff --git a/include/wfr/common/wfs/instances/WhileLoopActivityInstance.h b/include/wfr/common/wfs/instances/WhileLoopActivityInstance.h new file mode 100755 index 0000000..8b18878 --- /dev/null +++ b/include/wfr/common/wfs/instances/WhileLoopActivityInstance.h @@ -0,0 +1,29 @@ + +#pragma once + +#include + + +namespace wfr { +namespace wfs { + +// Forward declarations +class Activity; + + +class WhileLoopActivityInstance : public LoopActivityInstance { + +// Public functions +public: + WhileLoopActivityInstance(Activity& baseActivity, wfr_id_t iterationID = 0) noexcept + : LoopActivityInstance(baseActivity, false, iterationID) {} + + virtual bool executePreExecutionHooks(bool earlyEvaluation) override; + + virtual bool executePostExecutionHooks(bool earlyEvaluation) override; + + virtual void notifyChildHasFinished(ActivityInstance& ai) noexcept; +}; + +} /* namespace wfs */ +} /* namespace wfr */ diff --git a/include/wfr/common/wfs/templates/AssignActivityTemplate.h b/include/wfr/common/wfs/templates/AssignActivityTemplate.h new file mode 100755 index 0000000..cd0489f --- /dev/null +++ b/include/wfr/common/wfs/templates/AssignActivityTemplate.h @@ -0,0 +1,37 @@ + +#pragma once + +#include +#include + + +namespace wfr { +namespace wfs { + + +class AssignActivityTemplate : public ActivityTemplate { +friend class ActivityTemplate; + +// Invariant properties that can be accessed directly. +public: + const InputHookFunc inputFuncHook; + const ExecutionHookFunc execFuncHook; + +// Non-public functions. +private: + AssignActivityTemplate( wfr_id_t id, + const std::string& name, + wfr_id_t parentID, + wfr_id_t branchID, + const std::initializer_list& succList, + const std::initializer_list& predList, + InputHookFunc inputFuncHook, + ExecutionHookFunc execFuncHook ) noexcept + : ActivityTemplate(id, ActivityType::Assign, name, parentID, branchID, succList, predList, false, false, false), + inputFuncHook(inputFuncHook), execFuncHook(execFuncHook) {} +}; + + +} /* namespace wfs */ +} /* namespace wfr */ + diff --git a/include/wfr/common/wfs/templates/AtomicActivityTemplate.h b/include/wfr/common/wfs/templates/AtomicActivityTemplate.h new file mode 100755 index 0000000..4e3f035 --- /dev/null +++ b/include/wfr/common/wfs/templates/AtomicActivityTemplate.h @@ -0,0 +1,37 @@ + +#pragma once + +#include +#include + + +namespace wfr { +namespace wfs { + + +class AtomicActivityTemplate : public ActivityTemplate { +friend class ActivityTemplate; + +// Invariant properties that can be accessed directly. +public: + const InputHookFunc inputFuncHook; + const std::shared_ptr atomicActivityType; + +// Non-public functions. +private: + AtomicActivityTemplate( wfr_id_t id, + const std::string& name, + wfr_id_t parentID, + wfr_id_t branchID, + const std::initializer_list& succList, + const std::initializer_list& predList, + InputHookFunc inputFuncHook, + std::shared_ptr atomicActivityType ) noexcept + : ActivityTemplate(id, ActivityType::Atomic, name, parentID, branchID, succList, predList, false, false, false), + inputFuncHook(inputFuncHook), atomicActivityType(atomicActivityType) {} +}; + + +} /* namespace wfs */ +} /* namespace wfr */ + diff --git a/include/wfr/common/wfs/templates/ConditionalActivityTemplate.h b/include/wfr/common/wfs/templates/ConditionalActivityTemplate.h new file mode 100755 index 0000000..44c948b --- /dev/null +++ b/include/wfr/common/wfs/templates/ConditionalActivityTemplate.h @@ -0,0 +1,37 @@ + +#pragma once + +#include + + +namespace wfr { +namespace wfs { + + +class ConditionalActivityTemplate : public ActivityTemplate { +friend class ActivityTemplate; + +// Invariant properties that can be accessed directly. +public: + const InputHookFunc inputFuncHook; + const OutputHookFunc outputFuncHook; + const BranchConditionHookFunc branchFuncHook; + +// Non-public functions. +private: + ConditionalActivityTemplate( wfr_id_t id, + const std::string& name, + wfr_id_t parentID, + wfr_id_t branchID, + const std::initializer_list& succList, + const std::initializer_list& predList, + InputHookFunc inputFuncHook, + OutputHookFunc outputFuncHook, + BranchConditionHookFunc branchFuncHook ) noexcept + : ActivityTemplate(id, ActivityType::Conditional, name, parentID, branchID, succList, predList, true, false, true), + inputFuncHook(inputFuncHook), outputFuncHook(outputFuncHook), branchFuncHook(branchFuncHook) {} +}; + + +} /* namespace wfs */ +} /* namespace wfr */ diff --git a/include/wfr/common/wfs/templates/ContainerActivityTemplate.h b/include/wfr/common/wfs/templates/ContainerActivityTemplate.h new file mode 100755 index 0000000..ee17434 --- /dev/null +++ b/include/wfr/common/wfs/templates/ContainerActivityTemplate.h @@ -0,0 +1,35 @@ + +#pragma once + +#include + + +namespace wfr { +namespace wfs { + + +class ContainerActivityTemplate : public ActivityTemplate { +friend class ActivityTemplate; + +// Invariant properties that can be accessed directly. +public: + const InputHookFunc inputFuncHook; + const OutputHookFunc outputFuncHook; + +// Non-public functions. +private: + ContainerActivityTemplate( wfr_id_t id, + const std::string& name, + wfr_id_t parentID, + wfr_id_t branchID, + const std::initializer_list& succList, + const std::initializer_list& predList, + InputHookFunc inputFuncHook, + OutputHookFunc outputFuncHook ) noexcept + : ActivityTemplate(id, ActivityType::Container, name, parentID, branchID, succList, predList, true, false, false), + inputFuncHook(inputFuncHook), outputFuncHook(outputFuncHook) {} +}; + + +} /* namespace wfs */ +} /* namespace wfr */ diff --git a/include/wfr/common/wfs/templates/ForLoopActivityTemplate.h b/include/wfr/common/wfs/templates/ForLoopActivityTemplate.h new file mode 100755 index 0000000..3daf9ed --- /dev/null +++ b/include/wfr/common/wfs/templates/ForLoopActivityTemplate.h @@ -0,0 +1,42 @@ + +#pragma once + +#include + + +namespace wfr { +namespace wfs { + + +class ForLoopActivityTemplate : public ActivityTemplate { +friend class ActivityTemplate; + +// Invariant properties that can be accessed directly. +public: + const InputHookFunc inputFuncHook; + const OutputHookFunc outputFuncHook; + const ForCounterHookFunc counterFuncHook; + const LoopIterationHookFunc iterationFuncHook; + const bool isParallel; + +// Non-public functions. +private: + ForLoopActivityTemplate( wfr_id_t id, + const std::string& name, + wfr_id_t parentID, + wfr_id_t branchID, + const std::initializer_list& succList, + const std::initializer_list& predList, + InputHookFunc inputFuncHook, + OutputHookFunc outputFuncHook, + ForCounterHookFunc counterFuncHook, + LoopIterationHookFunc iterationFuncHook, + bool isParallel ) noexcept + : ActivityTemplate(id, ActivityType::ForLoop, name, parentID, branchID, succList, predList, true, true, false), + inputFuncHook(inputFuncHook), outputFuncHook(outputFuncHook), counterFuncHook(counterFuncHook), + iterationFuncHook(iterationFuncHook), isParallel(isParallel) {} +}; + + +} /* namespace wfs */ +} /* namespace wfr */ diff --git a/include/wfr/common/wfs/templates/WhileLoopActivityTemplate.h b/include/wfr/common/wfs/templates/WhileLoopActivityTemplate.h new file mode 100755 index 0000000..960c255 --- /dev/null +++ b/include/wfr/common/wfs/templates/WhileLoopActivityTemplate.h @@ -0,0 +1,40 @@ + +#pragma once + +#include + + +namespace wfr { +namespace wfs { + + +class WhileLoopActivityTemplate : public ActivityTemplate { +friend class ActivityTemplate; + +// Invariant properties that can be accessed directly. +public: + const InputHookFunc inputFuncHook; + const OutputHookFunc outputFuncHook; + const WhileConditionHookFunc conditionFuncHook; + const LoopIterationHookFunc iterationFuncHook; + +// Non-public functions. +private: + WhileLoopActivityTemplate( wfr_id_t id, + const std::string& name, + wfr_id_t parentID, + wfr_id_t branchID, + const std::initializer_list& succList, + const std::initializer_list& predList, + InputHookFunc inputFuncHook, + OutputHookFunc outputFuncHook, + WhileConditionHookFunc conditionFuncHook, + LoopIterationHookFunc iterationFuncHook ) noexcept + : ActivityTemplate(id, ActivityType::WhileLoop, name, parentID, branchID, succList, predList, true, true, false), + inputFuncHook(inputFuncHook), outputFuncHook(outputFuncHook), conditionFuncHook(conditionFuncHook), + iterationFuncHook(iterationFuncHook) {} +}; + + +} /* namespace wfs */ +} /* namespace wfr */ diff --git a/include/wfr/config.h b/include/wfr/config.h new file mode 100755 index 0000000..b2e1023 --- /dev/null +++ b/include/wfr/config.h @@ -0,0 +1,12 @@ + +#pragma once + + +#define WFR_ENABLE_STATISTICS + +#define WFR_ENABLE_WEPDOTWRITER + +#define WFR_ENABLE_PERFDATABASE + +#define WFR_ENABLE_STDLOGGER + diff --git a/include/wfr/enactment/EnactmentEngine.h b/include/wfr/enactment/EnactmentEngine.h new file mode 100755 index 0000000..80c0034 --- /dev/null +++ b/include/wfr/enactment/EnactmentEngine.h @@ -0,0 +1,66 @@ + +#pragma once + +#include +#include +#include +#include +#include + + +namespace wfr { + +//Forward declarations +namespace wfs { +class Workflow; +class ActivityInstance; +} +namespace wep { +class WorkflowExecutionPlan; +} +namespace scheduling { +class AbstractScheduler; +} + +// Main namespace +namespace enactment { + + +class EnactmentEngine { + +// Mutable properties that need to be accessed via getter-/setter-functions. +private: + std::shared_ptr wep; + + bool breakExecutionLoop = false; + + std::queue updateQueue; + std::mutex updateMutex; + std::condition_variable updateCondition; + + bool enableWepDotFileWriter; + bool enableEarlyEvaluation; + +// Invariant properties that can be accessed directly. +public: + wfs::Workflow& workflow; + scheduling::AbstractScheduler& scheduler; + +// Public static functions +public: + static void init(int argc, char** argv); + static void finish(); + +// Public functions +public: + EnactmentEngine(wfs::Workflow& workflow, scheduling::AbstractScheduler& scheduler) noexcept; + + void workflowExecutionLoop(lwd::_wfr_lwd* input, lwd::_wfr_lwd* output); + + void notifyActivityInstanceStateUpdate(wfs::ActivityInstance& ai, scheduling::AbstractScheduler& scheduler); +}; + +} /* namespace wep */ +} /* namespace wfr */ + + diff --git a/include/wfr/enactment/WepBuilder.h b/include/wfr/enactment/WepBuilder.h new file mode 100755 index 0000000..9f0a895 --- /dev/null +++ b/include/wfr/enactment/WepBuilder.h @@ -0,0 +1,85 @@ + +#pragma once + +#include +#include +#include +#include +#include +#include +#include + + +// Forward declarations +namespace wfr { +namespace wfs { +class Workflow; +class ActivityInstance; +class CompositeActivityInstance; +class Activity; +} +namespace wep { +class WorkflowExecutionPlan; +class AbstractWepNode; +class AtomicWepNode; +class AssignWepNode; +class CompositeStartWepNode; +class CompositeEndWepNode; +class IterationStartWepNode; +class IterationEndWepNode; +} + + +// Main namespace +namespace enactment { + + +class WepBuilder { + +// Mutable properties that need to be accessed via getter-/setter-functions. +private: + std::shared_ptr wep; + + typedef std::map activityInstanceMap_t; + typedef std::map> wepNodeMap_t; + + std::stack parentStack; + std::stack> parentWepStack; + std::stack iterationIdStack; + wepNodeMap_t wepNodeMap; + + std::vector readyToExecuteAtomicNodes; + std::vector readyToExecuteAssignNodes; + + wfr_size_t wepNodeCount = 0; + wfr_size_t wepVisitationCount = 0; + + bool earlyEvaluationMode; + +// Non-public functions +private: + wepNodeMap_t::mapped_type createWEPnode(wfs::Activity& a, wfs::ActivityInstance& ai, wepNodeMap_t& wepNodeMap); + + void visitActivity(wfs::Activity& element, activityInstanceMap_t& instanceMap, wepNodeMap_t& wepNodeMap); + + wepNodeMap_t::mapped_type createIterationWepNodes(wfr::wfs::ActivityInstance& ai, wepNodeMap_t::mapped_type& parent, wfr_id_t iterationID); + + void handleChildren(wfs::CompositeActivityInstance& composite, wepNodeMap_t::mapped_type& parent, wepNodeMap_t::mapped_type* prevIter = nullptr); + +// Public functions +public: + WepBuilder(bool earlyEvaluation) : earlyEvaluationMode(earlyEvaluation) {} + virtual ~WepBuilder(); + + std::shared_ptr createWEP(wfs::Workflow& wf, lwd::_wfr_lwd* input, lwd::_wfr_lwd* output); + + bool updateExecutionPlan(std::queue& updateInstances); + + const std::vector& getReadyToExecuteAtomicNodes() { return readyToExecuteAtomicNodes; } + + const std::vector& getReadyToExecuteAssignNodes() { return readyToExecuteAssignNodes; } +}; + +} /* namespace enactment */ +} /* namespace wfr */ + diff --git a/include/wfr/eventsystem/OStreamLogger.h b/include/wfr/eventsystem/OStreamLogger.h new file mode 100755 index 0000000..e7534ea --- /dev/null +++ b/include/wfr/eventsystem/OStreamLogger.h @@ -0,0 +1,32 @@ + +#pragma once + +#include +#include + + +namespace wfr { +namespace eventsystem { + +// forward declarations +class Event; +class WorkflowStatusEvent; +class ActivityStatusEvent; +class ActivityInstanceStatusEvent; + +/** + * Logs events to a std::ostream (e.g. std::cout). + **/ +class OStreamLogger: public wfr::eventsystem::EventListener { +private: + std::ostream& oStream; + +public: + OStreamLogger(std::ostream& oStream) : oStream(oStream) {}; + + virtual void notifyEvent(const std::shared_ptr& event) noexcept override; +}; + +} /* namespace eventsystem */ +} /* namespace wfr */ + diff --git a/include/wfr/eventsystem/SQLiteLogger.h b/include/wfr/eventsystem/SQLiteLogger.h new file mode 100755 index 0000000..b1a5d1a --- /dev/null +++ b/include/wfr/eventsystem/SQLiteLogger.h @@ -0,0 +1,105 @@ + +#pragma once + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#include + + + +namespace wfr { +namespace wfs { +class Workflow; +class Activity; +class ActivityInstance; +} +} + +namespace wfr { +namespace eventsystem { + +namespace odbmodel { + +class Workflow; +class Activity; +class ActivityInstance; + +} + +class Event; +class WorkflowStatusEvent; +class ActivityStatusEvent; +class ActivityInstanceStatusEvent; +class ComputingResourceStatusEvent; +class ComponentStatusEvent; + +class SQLiteLogger : public EventListener { +protected: + static void dbwriterfunc(SQLiteLogger* logger); + + std::unique_ptr loggerThread; + bool threadRunning = false; + bool threadBreakFlag = false; + std::mutex threadMutex; + std::condition_variable threadCondition; + std::queue> eventQueue; + + std::string filename; + std::unique_ptr dbHandle; + bool readyFlag = false; + + int statProcessedEvents; + int statWrittenEvents; + + /*typedef std::map> workflowMap_t; + typedef std::map> activityMap_t; + typedef std::map> activityInstanceMap_t; + + workflowMap_t workflowMap; + activityMap_t activityMap; + activityInstanceMap_t activityInstanceMap;*/ + + /*void handleWorkflowStatusEvent(WorkflowStatusEvent &event); + void handleActicityStatusEvent(ActivityStatusEvent &event); + void handleActicityInstanceStatusEvent(ActivityInstanceStatusEvent &event); + void handleComputingResourceStatusEvent(ComputingResourceStatusEvent &event); + void handleComponentStatusEvent(ComponentStatusEvent &event); + + std::shared_ptr getWorkflowFromWfsMap(wfs::Workflow& wf); + void persistWorkflow(std::shared_ptr& wfp, wfs::Workflow& wf); + std::shared_ptr getActivityFromWfsMap(wfs::Activity& act); + void persistActivity(std::shared_ptr& ap, wfs::Activity& a); + std::shared_ptr getActivityInstanceFromWfsMap(wfs::ActivityInstance& act); + void persistActivityInstance(std::shared_ptr& ap, wfs::ActivityInstance& a); + + void writeWorkflowStatus(std::shared_ptr& pWf, WorkflowStatusEvent &event); + void writeActivityStatus(std::shared_ptr& pA, ActivityStatusEvent &event); + void writeActivityInstanceStatus(std::shared_ptr& pA, ActivityInstanceStatusEvent &event); + void writeComputingResourceStatus(std::shared_ptr& pwf, std::shared_ptr& pai, ComputingResourceStatusEvent &event); + void writeComponentStatus(std::shared_ptr& pwf, ComponentStatusEvent &event);*/ + +public: + SQLiteLogger(std::string filename); + virtual ~SQLiteLogger(); + + bool isReady() { return readyFlag; } + + virtual void notifyEvent(const std::shared_ptr& event) noexcept; +}; + +} /* namespace eventsystem */ +} /* namespace wfr */ + diff --git a/include/wfr/eventsystem/odb-model/SimpleDBModel.h b/include/wfr/eventsystem/odb-model/SimpleDBModel.h new file mode 100755 index 0000000..6e06b2a --- /dev/null +++ b/include/wfr/eventsystem/odb-model/SimpleDBModel.h @@ -0,0 +1,650 @@ +/* + * SimpleDBModel.h + * + * Created on: 09.05.2014 + * Author: matthias + */ + +#ifndef SIMPLEDBMODEL_H_ +#define SIMPLEDBMODEL_H_ + +#include +#include +#include +#include +#include + +namespace wfr { +namespace eventsystem { +#pragma db namespace session +namespace odbmodel { + +class Workflow; +class Activity; +class ActivityInstance; +class WorkflowStatusEvent; +class ActivityStatusEvent; +class ActivityInstanceStatusEvent; + + +#pragma db value(wfr_id_t) type("BigInt") +#pragma db value(wfr_size_t) type("BigInt") + + +#pragma db object pointer(std::shared_ptr) +class Workflow { + + friend class odb::access; + + private: + #pragma db id auto + uint32_t oid; + + wfr_id_t wfid; + + std::string uuid; + + std::string name; + + #pragma db inverse(parentWorkflow) + std::vector> activities; + + std::weak_ptr toplevelActivity; + + #pragma db inverse(parentWorkflow) + std::vector> statusEvents; + + + public: + Workflow() : oid(0), wfid(0) {} + + Workflow(wfr_id_t wfid, std::string uuid) : oid(0), wfid(wfid), uuid(uuid) {} + + std::vector >& getActivities() { + return activities; + } + + const std::string& getName() const { + return name; + } + + void setName(const std::string& name) { + this->name = name; + } + + const std::weak_ptr& getToplevelActivity() const { + return toplevelActivity; + } + + void setToplevelActivity(const std::weak_ptr& toplevelActivity) { + this->toplevelActivity = toplevelActivity; + } + + wfr_id_t getOid() const { + return oid; + } + + const std::string& getUuid() const { + return uuid; + } + + wfr_id_t getWfid() const { + return wfid; + } + + void setWfid(wfr_id_t wfid) { + this->wfid = wfid; + } +}; + +#pragma db object pointer(std::shared_ptr) +class WorkflowStatusEvent { + + friend class odb::access; + + private: + #pragma db id auto + uint32_t oid; + + #pragma db not_null + std::shared_ptr parentWorkflow; + + std::string newStatus; + + std::string oldStatus; + + uint64_t timestamp; + + public: + WorkflowStatusEvent() : oid(0), timestamp(0) {} + + const std::string& getNewStatus() { + return newStatus; + } + + void setNewStatus(const std::string& newStatus) { + this->newStatus = newStatus; + } + + wfr_id_t getOid() { + return oid; + } + + const std::string& getOldStatus() { + return oldStatus; + } + + void setOldStatus(const std::string& oldStatus) { + this->oldStatus = oldStatus; + } + + const std::shared_ptr& getParentWorkflow() { + return parentWorkflow; + } + + void setParentWorkflow(const std::shared_ptr& parentWorkflow) { + this->parentWorkflow = parentWorkflow; + } + + uint64_t getTimestamp() { + return timestamp; + } + + void setTimestamp(uint64_t timestamp) { + this->timestamp = timestamp; + } +}; + + + +#pragma db object pointer(std::shared_ptr) +class Activity { + + friend class odb::access; + + private: + #pragma db id auto + uint32_t oid; + + wfr_id_t actid; + + std::string name; + + #pragma db not_null + std::shared_ptr parentWorkflow; + + std::shared_ptr parent; + + #pragma db inverse(parentActivity) + std::vector> statusEvents; + + std::string type; + + wfr_id_t branchID; + + #pragma db inverse(baseActivity) + std::vector> instances; + + std::vector> successors; + + std::vector> predecessors; + + public: + Activity() : oid(0), actid(0), branchID(0) {} + + Activity(wfr_id_t actid, wfr_id_t branchid) : oid(0), actid(actid), branchID(branchid) {} + + wfr_id_t getBranchId() const { + return branchID; + } + + std::vector >& getInstances() { + return instances; + } + + const std::string& getName() const { + return name; + } + + void setName(const std::string& name) { + this->name = name; + } + + const std::shared_ptr& getParentWorkflow() const { + return parentWorkflow; + } + + void setParentWorkflow(const std::shared_ptr& parentWorkflow) { + this->parentWorkflow = parentWorkflow; + } + + const std::shared_ptr& getParent() const { + return parent; + } + + void setParent(const std::shared_ptr& parent) { + this->parent = parent; + } + + std::vector >& getPredecessors() { + return predecessors; + } + + std::vector >& getSuccessors() { + return successors; + } + + const std::string& getType() const { + return type; + } + + void setType(const std::string& type) { + this->type = type; + } + + wfr_id_t getOid() const { + return oid; + } + + wfr_id_t getActid() const { + return actid; + } + + void setActid(wfr_id_t actid) { + this->actid = actid; + } +}; + + +#pragma db object pointer(std::shared_ptr) +class ActivityStatusEvent { + + friend class odb::access; + + private: + #pragma db id auto + uint32_t oid; + + #pragma db not_null + std::shared_ptr parentActivity; + + std::string newStatus; + + std::string oldStatus; + + uint64_t timestamp; + + public: + ActivityStatusEvent() : oid(0), timestamp(0) {} + + const std::string& getNewStatus() { + return newStatus; + } + + void setNewStatus(const std::string& newStatus) { + this->newStatus = newStatus; + } + + wfr_id_t getOid() { + return oid; + } + + const std::string& getOldStatus() { + return oldStatus; + } + + void setOldStatus(const std::string& oldStatus) { + this->oldStatus = oldStatus; + } + + const std::shared_ptr& getParentActivity() { + return parentActivity; + } + + void setParentActivity(const std::shared_ptr& parentActivity) { + this->parentActivity = parentActivity; + } + + uint64_t getTimestamp() { + return timestamp; + } + + void setTimestamp(uint64_t timestamp) { + this->timestamp = timestamp; + } +}; + + +#pragma db object pointer(std::shared_ptr) +class ActivityInstance { + + friend class odb::access; + + private: + #pragma db id auto + uint32_t oid; + + wfr_id_t instid; + + wfr_id_t iterationID; + + std::vector> successors; + + std::vector> predecessors; + + #pragma db not_null + std::shared_ptr baseActivity; + + #pragma db not_null + std::shared_ptr parentWorkflow; + + std::shared_ptr parentInstance; + + #pragma db inverse(parentInstance) + std::vector> statusEvents; + + public: + ActivityInstance() : oid(0), instid(0), iterationID(0) {} + + ActivityInstance(wfr_id_t instid, wfr_id_t iterationID) : oid(0), instid(instid), iterationID(iterationID) {} + + wfr_id_t getInstid() { + return instid; + } + + void setInstid(wfr_id_t instid) { + this->instid = instid; + } + + wfr_id_t getIterationId() { + return iterationID; + } + + void setIterationId(wfr_id_t iterationId) { + iterationID = iterationId; + } + + wfr_id_t getOid() { + return oid; + } + + std::shared_ptr& getBaseActivity() { + return baseActivity; + } + + void setBaseActivity(std::shared_ptr& parentActivity) { + this->baseActivity = parentActivity; + } + + std::vector >& getPredecessors() { + return predecessors; + } + + std::vector >& getSuccessors() { + return successors; + } + + const std::shared_ptr& getParentInstance() const { + return parentInstance; + } + + void setParentInstance( + const std::shared_ptr& parentInstance) { + this->parentInstance = parentInstance; + } + + std::shared_ptr& getParentWorkflow() { + return parentWorkflow; + } + + void setParentWorkflow(std::shared_ptr& parentWorkflow) { + this->parentWorkflow = parentWorkflow; + } +}; + + +#pragma db object pointer(std::shared_ptr) +class ActivityInstanceStatusEvent { + + friend class odb::access; + + private: + #pragma db id auto + uint32_t oid; + + #pragma db not_null + std::shared_ptr parentInstance; + + std::string newStatus; + + std::string oldStatus; + + uint64_t timestamp; + + public: + ActivityInstanceStatusEvent() : oid(0), timestamp(0) {} + + const std::string& getNewStatus() { + return newStatus; + } + + void setNewStatus(const std::string& newStatus) { + this->newStatus = newStatus; + } + + wfr_id_t getOid() { + return oid; + } + + const std::string& getOldStatus() { + return oldStatus; + } + + void setOldStatus(const std::string& oldStatus) { + this->oldStatus = oldStatus; + } + + const std::shared_ptr& getParentInstance() { + return parentInstance; + } + + void setParentInstance(const std::shared_ptr& parentActivity) { + this->parentInstance = parentActivity; + } + + uint64_t getTimestamp() { + return timestamp; + } + + void setTimestamp(uint64_t timestamp) { + this->timestamp = timestamp; + } +}; + + +#pragma db object pointer(std::shared_ptr) +class DeviceInstanceStatusEvent { + + friend class odb::access; + + private: + #pragma db id auto + uint32_t oid; + + std::shared_ptr parentWorkflow; + + std::string deviceType; + + wfr_id_t deviceID; + + std::string newStatus; + + std::string oldStatus; + + uint64_t timestamp; + + std::shared_ptr executedInstance; + + wfr_id_t executedImplID; + + wfr_size_t deviceSlotCount; + + public: + DeviceInstanceStatusEvent() : oid(0), deviceID(0), timestamp(0), executedImplID(0), deviceSlotCount(0) {} + + const std::string& getNewStatus() { + return newStatus; + } + + void setNewStatus(const std::string& newStatus) { + this->newStatus = newStatus; + } + + wfr_id_t getOid() { + return oid; + } + + const std::string& getOldStatus() { + return oldStatus; + } + + void setOldStatus(const std::string& oldStatus) { + this->oldStatus = oldStatus; + } + + const std::shared_ptr& getParentWorkflow() { + return parentWorkflow; + } + + void setParentWorkflow(const std::shared_ptr& parentWorkflow) { + this->parentWorkflow = parentWorkflow; + } + + uint64_t getTimestamp() { + return timestamp; + } + + void setTimestamp(uint64_t timestamp) { + this->timestamp = timestamp; + } + + wfr_id_t getDeviceId() { + return deviceID; + } + + void setDeviceId(wfr_id_t deviceId) { + deviceID = deviceId; + } + + wfr_size_t getDeviceSlotCount() { + return deviceSlotCount; + } + + void setDeviceSlotCount(wfr_size_t deviceSlotCount) { + this->deviceSlotCount = deviceSlotCount; + } + + const std::string& getDeviceType() { + return deviceType; + } + + void setDeviceType(const std::string& deviceType) { + this->deviceType = deviceType; + } + + wfr_id_t getExecutedImplId() { + return executedImplID; + } + + void setExecutedImplId(wfr_id_t executedImplId) { + executedImplID = executedImplId; + } + + const std::shared_ptr& getExecutedInstance() { + return executedInstance; + } + + void setExecutedInstance(const std::shared_ptr& executedInstance) { + this->executedInstance = executedInstance; + } +}; + + +#pragma db object pointer(std::shared_ptr) +class ComponentStatusEvent { + + friend class odb::access; + + private: + #pragma db id auto + uint32_t oid; + + std::shared_ptr workflow; + + std::string componentType; + + std::string newStatus; + + std::string oldStatus; + + uint64_t timestamp; + + public: + ComponentStatusEvent() : oid(0), timestamp(0) {} + + std::string& getComponentType() { + return componentType; + } + + void setComponentType(const std::string& componentType) { + this->componentType = componentType; + } + + std::string& getNewStatus() { + return newStatus; + } + + void setNewStatus(const std::string& newStatus) { + this->newStatus = newStatus; + } + + wfr_id_t getOid() { + return oid; + } + + std::string& getOldStatus() { + return oldStatus; + } + + void setOldStatus(const std::string& oldStatus) { + this->oldStatus = oldStatus; + } + + uint64_t getTimestamp() { + return timestamp; + } + + void setTimestamp(uint64_t timestamp) { + this->timestamp = timestamp; + } + + std::shared_ptr& getWorkflow() { + return workflow; + } + + void setWorkflow(const std::shared_ptr& workflow) { + this->workflow = workflow; + } +}; + + + + + +} /* namespace odbmodel */ +} /* namespace eventsystem */ +} /* namespace wfr */ + + + +#endif /* SIMPLEDBMODEL_H_ */ diff --git a/include/wfr/execution/ExecutionHandle.h b/include/wfr/execution/ExecutionHandle.h new file mode 100755 index 0000000..83c771a --- /dev/null +++ b/include/wfr/execution/ExecutionHandle.h @@ -0,0 +1,49 @@ + +#pragma once + +#include +#include + +namespace wfr { + +// Forward declarations +namespace scheduling { +class SchedulingDecision; +} + +namespace execution { + + +enum class ExecutionHandleState + : int { Unknown, + Pending, + Running, + Finished, + Error }; + +class ExecutionHandle { + +// Invariant properties that can be accessed directly. +public: + std::shared_ptr schedulingDecision = nullptr; + +// Mutable properties that need to be accessed via getter-/setter-functions. +private: + ExecutionHandleState state = ExecutionHandleState::Unknown; + std::exception_ptr errorCause = nullptr; + +public: + ExecutionHandle(std::shared_ptr schedulingDecision) noexcept : + schedulingDecision(schedulingDecision), state(ExecutionHandleState::Pending) {} + + std::exception_ptr getErrorCause() const noexcept { return errorCause; } + + void setErrorCause(std::exception_ptr errorCause) noexcept { this->errorCause = errorCause; } + + ExecutionHandleState getState() const noexcept { return state; } + + void setState(ExecutionHandleState state) noexcept { this->state = state; } +}; + +} /* namespace execution */ +} /* namespace wfr */ diff --git a/include/wfr/execution/ExecutionManager.h b/include/wfr/execution/ExecutionManager.h new file mode 100755 index 0000000..492a7e0 --- /dev/null +++ b/include/wfr/execution/ExecutionManager.h @@ -0,0 +1,59 @@ + +#pragma once + + +#include +#include +#include +#include +#include +#include +#include +#include + +namespace wfr { +namespace scheduling { +class SchedulingDecision; +class AbstractScheduler; +class PThreadBackend; +} +namespace execution { +class PThreadBackend; +class CudaBackend; +} + + +namespace execution { + + +class ExecutionHandle; + +class ExecutionManager { +private: + ExecutionManager(); + static ExecutionManager singleton; + + std::mutex managerMutex; + + PThreadBackend* pThreadBackend = nullptr; + CudaBackend* cudaBackend = nullptr; + + std::map schedulerHandleMap; + std::queue updateQueue; + +public: + static void init(int argc, char** argv); + + static void finish(); + + ~ExecutionManager(); + + static ExecutionManager& getInstance() { return singleton; } + + bool executeSchedulingDecision(std::shared_ptr sd, scheduling::AbstractScheduler& scheduler); + + void notifyExecutionHandleUpdate(ExecutionHandle& handle); +}; + +} /* namespace execution */ +} /* namespace wfr */ diff --git a/include/wfr/execution/backends/pthreads/PThreadBackend.h b/include/wfr/execution/backends/pthreads/PThreadBackend.h new file mode 100755 index 0000000..e01cf74 --- /dev/null +++ b/include/wfr/execution/backends/pthreads/PThreadBackend.h @@ -0,0 +1,57 @@ + +#pragma once + +#include +#include +#include +#include +#include + +namespace wfr { + +namespace resource { +class Resource; +class ComputingResource; +} + +namespace execution { + +class ExecutionManager; +class ExecutionHandle; +class PThreadWorker; + +class PThreadBackend { +private: + std::mutex objMutex; + std::condition_variable workerCondVar; + ExecutionManager& manager; + std::set workers; + std::set idleWorkers; + std::set resources; + std::queue taskQueue; + wfr_size_t maxWorkerCount; + wfr_size_t currentTotalWorkerCount = 0; + wfr_size_t currentBusyWorkerCount = 0; + wfr_size_t occupiedSlotCount = 0; + wfr_size_t slotsInQueue = 0; + bool isShutdown = false; + +public: + PThreadBackend(ExecutionManager& manager, const std::set& resources); + virtual ~PThreadBackend(); + + void notifyExecutionHandleUpdate(ExecutionHandle& handle, PThreadWorker& worker); + + bool queueTaskExecution(ExecutionHandle& handle); + + ExecutionHandle* popTaskExecution(PThreadWorker& worker); + + wfr_size_t getBusyWorkerCount() { return currentBusyWorkerCount; } + + wfr_size_t getTotalSlotCount() { return maxWorkerCount; } + +}; + +} /* namespace execution */ +} /* namespace wfr */ + diff --git a/include/wfr/execution/backends/pthreads/PThreadWorker.h b/include/wfr/execution/backends/pthreads/PThreadWorker.h new file mode 100755 index 0000000..b6ca2bc --- /dev/null +++ b/include/wfr/execution/backends/pthreads/PThreadWorker.h @@ -0,0 +1,81 @@ + +#pragma once + +#include +#include +#include +#include +#include + + +namespace wfr { + +namespace resource { +class Resource; +} + +namespace scheduling { +class SchedulingDecision; +} + +namespace execution { + +class PThreadBackend; +class ExecutionHandle; + +class PThreadWorker { +private: + /** + * Static variable holding the next free threadID. + **/ + static std::atomic nextThreadID; + + /** + * Returns the next free threadID. + * + * @return next free threadID. + */ + static wfr_id_t getNextThreadID(); + + static void workerFunc(PThreadWorker* threadObj); + +private: + wfr_id_t threadID; + bool stopThread; + bool threadRunning; + bool threadBusy; + PThreadBackend& backend; + std::mutex threadMutex; + std::thread* thread; + wfr_size_t usedSlotCount; + wfs::ComputingResourceStatus status; + + PThreadWorker(PThreadBackend& backend); + +public: + virtual ~PThreadWorker(); + + wfr_size_t getThreadID() { return threadID; } + + bool isBusy() { return threadBusy; } + + void setBusy(bool val) {threadBusy = val; } + + wfr_size_t getUsedSlotCount() { return usedSlotCount; } + + void setUsedSlotCount(wfr_size_t count) { usedSlotCount += count; } + + void finishThread(); + + void join(); + + wfs::ComputingResourceStatus getStatus() { return status; } + + void setStatus(wfs::ComputingResourceStatus status, std::shared_ptr sd = nullptr); + + static PThreadWorker* createNewThread(PThreadBackend& backend); +}; + +} /* namespace execution */ +} /* namespace wfr */ + diff --git a/include/wfr/prediction/PredictionManager.h b/include/wfr/prediction/PredictionManager.h new file mode 100755 index 0000000..ccd44b3 --- /dev/null +++ b/include/wfr/prediction/PredictionManager.h @@ -0,0 +1,108 @@ + +#pragma once + + +#include +#include +#include + +namespace wfr { + +namespace wfs { +class AtomicActivityImplementation; +class ActivityInstance; +} + +namespace resource { +class Resource; +class ComputingResourceType; +class ComputingResource; +class ResourceManager; +} + +namespace prediction { + +class PredictionService; + + + +class ExecutionTimeResult { + +// Mutable properties that need to be accessed via getter-/setter-functions. +// Some of them are invariant, but this class needs to be copyable, so no const properties :( +public: + wfs::ActivityInstance* instance = nullptr; + wfs::AtomicActivityImplementation* implementation = nullptr; + resource::ComputingResourceType* resourceType = nullptr; + wfr::NumericalMeasurement executionTime; + wfr_size_t slots = 0; + bool validFlag = false; + +// Public functions +public: + ExecutionTimeResult() noexcept {} + ExecutionTimeResult(wfs::ActivityInstance* instance, wfs::AtomicActivityImplementation* implementation, + resource::ComputingResourceType* resourceType, wfr::NumericalMeasurement executionTime, wfr_size_t slots = 1, bool validFlag = true) noexcept + : instance(instance), implementation(implementation), resourceType(resourceType), executionTime(executionTime), + slots(slots), validFlag(validFlag) {} + + wfs::ActivityInstance* getActivityInstance() const noexcept { return instance; } + wfs::AtomicActivityImplementation* getActivityImplementation() const noexcept { return implementation; } + resource::ComputingResourceType* getResourceType() const noexcept { return resourceType; } + const wfr::NumericalMeasurement& getExecutionTime() const noexcept { return executionTime; } + wfr_size_t getSlots() const noexcept { return slots; } + bool isValid() const noexcept { return validFlag; } + operator bool() const noexcept { return validFlag; } +}; + + + +class CommunicationTimeResult { + +// Invariant properties that can be accessed directly. +public: + wfs::ActivityInstance* const srcInstance = nullptr; + resource::ComputingResource* const srcResource = nullptr; + wfs::ActivityInstance* const destInstance = nullptr; + resource::ComputingResource* const destResource = nullptr; + const wfr::NumericalMeasurement communicationTime; + const bool isValid = false; +public: + CommunicationTimeResult() noexcept {} + CommunicationTimeResult(wfs::ActivityInstance* srcInstance, resource::ComputingResource* srcResource, + wfs::ActivityInstance* destInstance, resource::ComputingResource* destResource, + wfr::NumericalMeasurement communicationTime, bool validFlag = true) noexcept + : srcInstance(srcInstance), srcResource(srcResource), destInstance(destInstance), destResource(destResource), + communicationTime(communicationTime), isValid(validFlag) {} + + operator bool() const { + return isValid; + } +}; + + +class PredictionManager { +private: + static PredictionManager singleton; + PredictionService* service = nullptr; +public: + static void init(int argc, char** argv); + + static void finish() noexcept; + + static PredictionManager& getInstance() noexcept { return singleton; } + +public: + ~PredictionManager() noexcept; + + ExecutionTimeResult predictExecutionTime(wfs::ActivityInstance& instance, wfs::AtomicActivityImplementation& implementation, + resource::ComputingResourceType& resourceType, const wfr_size_t& slots = 1) noexcept; + + CommunicationTimeResult predictCommunicationTime(wfs::ActivityInstance& srcInstance, resource::ComputingResource& srcResource, + wfs::ActivityInstance& destInstance, resource::ComputingResource& destResource) noexcept; +}; + + +} /* namespace prediction */ +} /* namespace wfr */ + diff --git a/include/wfr/prediction/PredictionService.h b/include/wfr/prediction/PredictionService.h new file mode 100755 index 0000000..b6a96dc --- /dev/null +++ b/include/wfr/prediction/PredictionService.h @@ -0,0 +1,31 @@ + +#pragma once + +#include + +namespace wfr { + +namespace resource { +class Resource; +class ComputingResourceType; +class ComputingResource; +class ResourceManager; +} + +namespace prediction { + +class PredictionService { +public: + virtual ~PredictionService() {} + + virtual ExecutionTimeResult predictExecutionTime(wfs::ActivityInstance& instance, wfs::AtomicActivityImplementation& implementation, + resource::ComputingResourceType& resourceType, const wfr_size_t& slots = 1) = 0; + + virtual CommunicationTimeResult predictCommunicationTime(wfs::ActivityInstance& srcInstance, resource::ComputingResource& srcResource, + wfs::ActivityInstance& destInstance, resource::ComputingResource& destResource) = 0; +}; + + +} /* namespace prediction */ +} /* namespace wfr */ + diff --git a/include/wfr/prediction/services/oracle/OraclePredictionService.h b/include/wfr/prediction/services/oracle/OraclePredictionService.h new file mode 100755 index 0000000..4f1b0ca --- /dev/null +++ b/include/wfr/prediction/services/oracle/OraclePredictionService.h @@ -0,0 +1,33 @@ + +#pragma once + +#include +#include +#include + +namespace wfr { + +namespace prediction { + + +class OraclePredictionService : public PredictionService { +private: + struct PredictionTableEntry { + NumericalMeasurement prediction; + }; + + // Primary Key: (ActivityType, ActivityImplementation, Device) + std::map>> predictionTable; +public: + OraclePredictionService(const std::string& config = std::string()); + + virtual ExecutionTimeResult predictExecutionTime(wfs::ActivityInstance& instance, wfs::AtomicActivityImplementation& implementation, + resource::ComputingResourceType& resourceType, const wfr_size_t& slots = 1) override; + + virtual CommunicationTimeResult predictCommunicationTime(wfs::ActivityInstance& srcInstance, resource::ComputingResource& srcResource, + wfs::ActivityInstance& destInstance, resource::ComputingResource& destResource) override; +}; + + +} /* namespace prediction */ +} /* namespace wfr */ diff --git a/include/wfr/scheduling/AbstractScheduler.h b/include/wfr/scheduling/AbstractScheduler.h new file mode 100755 index 0000000..a6bb7e2 --- /dev/null +++ b/include/wfr/scheduling/AbstractScheduler.h @@ -0,0 +1,141 @@ + +#pragma once + + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace wfr { + +// Forward declarations +namespace wep { +class WorkflowExecutionPlan; +class AtomicWepNode; +} +namespace enactment { +class EnactmentEngine; +} +namespace execution { +class ExecutionManager; +} +namespace prediction { +class PredictionManager; +} +namespace resource { +class ResourceManager; +} + + +// Main namespace +namespace scheduling { + +// Forward declaration +class SchedulingDecision; + + +/* + * Represents the interface every scheduler needs to implement. + * + * Workflow execution sequence: + * 1) registerWEP() is called by enactment engine to register new workflow instance + * 2) notifyWEPUpdate() is called by enactment engine to notify scheduler of workflow progress + * 3) The scheduler creates scheduling decisions objects and passes them to the execution layer + * - uses convenience function SchedulerBase::executeSchedulingDecision, or + * - directly calls ExecutionManager::executeSchedulingDecision + * 4) The execution layer calls notifySchedulingDecisionStatusUpdate to notify scheduler about executed (or failed) activities. + * - the scheduler needs then to call EnactmentEngine::notifyActivityInstanceStateUpdate() to notify the enactment engine. + * - SchedulerBase already automatically notifies the enactment engine. + * 5) Goto 2) till unregisterWEP() is called. + */ +class AbstractScheduler { +public: + virtual ~AbstractScheduler() noexcept {} + + /* + * Is called by the enactment engine to let the scheduler know of a new workflow instance. + * + * @param wep workflow execution plan object representing the workflow instance + * @param ee reference to enactment engine + */ + virtual void registerWEP(wep::WorkflowExecutionPlan& wep, enactment::EnactmentEngine& ee) noexcept = 0; + + /* + * Is called by the enactment engine to let the scheduler know that a workflow instance has finished + * + * @param wep workflow execution plan object representing the workflow instance + */ + virtual void unregisterWEP(wep::WorkflowExecutionPlan& wep) noexcept = 0; + + /* + * Is called by the enactment engine to let the scheduler know about changes to the workflow execution plan. + * + * @param wep workflow execution plan object representing the workflow instance + * @param readytoExecute set of new ready-to-execute activities (for convenience) + */ + virtual void notifyWEPUpdate(wep::WorkflowExecutionPlan& wep, std::set readyToExecute) noexcept = 0; + + /* + * Called by the execution layer to notify the scheduler that an activity finished (or failed) execution. + * + * @param sd reference to scheduling decision object. + */ + virtual void notifySchedulingDecisionStatusUpdate(std::shared_ptr sd) noexcept = 0; + + virtual double getCummulativePredictionTime() noexcept = 0; +}; + + + +/* + * Scheduler base class implementing common scheduler functionality. + */ +class SchedulerBase : public AbstractScheduler { +public: + struct WepMapEntry { + WepMapEntry(enactment::EnactmentEngine* engine, wep::WorkflowExecutionPlan* wep) + : engine(engine), wep(wep) {} + enactment::EnactmentEngine* engine; + wep::WorkflowExecutionPlan* wep; + std::set> decisions; + void* userData = nullptr; + }; +protected: + typedef std::map wepMap_t; + std::mutex schedulerMutex; + wepMap_t wepMap; + bool simulationMode; + double cummulativePredictionTime = 0; + +protected: + // Hook functions for AbstractScheduler functions below to allow customisation of common functionality + virtual void _registerWEP(WepMapEntry& wepe, std::unique_lock& schedulerLock) {}; + virtual void _unregisterWEP(WepMapEntry& wepe, std::unique_lock& schedulerLock) {} + virtual void _notifyWEPUpdate(WepMapEntry& wepe, std::set readyToExecute, std::unique_lock& schedulerLock) {} + virtual void _notifySchedulingDecisionStatusUpdate(WepMapEntry& wepe, std::shared_ptr sd, std::unique_lock& schedulerLock) {} + + // Convenience functions for passing a scheduling decision to the execution layer. + bool executeSchedulingDecision(WepMapEntry& wepe, std::shared_ptr sd, std::unique_lock& schedulerLock) noexcept; + +public: + SchedulerBase(); + virtual ~SchedulerBase() noexcept; + + // From AbstractScheduler class + virtual void registerWEP(wep::WorkflowExecutionPlan& wep, enactment::EnactmentEngine& ee) noexcept override; + virtual void unregisterWEP(wep::WorkflowExecutionPlan& wep) noexcept override; + virtual void notifyWEPUpdate(wep::WorkflowExecutionPlan& wep, std::set readyToExecute) noexcept override; + virtual void notifySchedulingDecisionStatusUpdate(std::shared_ptr wep) noexcept override; + virtual double getCummulativePredictionTime() noexcept override { return cummulativePredictionTime; } +}; + + +} /* namespace scheduling */ +} /* namespace wfr */ diff --git a/include/wfr/scheduling/SchedulerManager.h b/include/wfr/scheduling/SchedulerManager.h new file mode 100755 index 0000000..9a19613 --- /dev/null +++ b/include/wfr/scheduling/SchedulerManager.h @@ -0,0 +1,44 @@ + +#pragma once + +#include +#include +#include + +namespace wfr { +namespace scheduling { + +class AbstractScheduler; + +class SchedulerManager { +private: + static SchedulerManager* singleton; + +private: + typedef std::map> factoryMap_t; + std::string defaultScheduler; + factoryMap_t schedulerFactories; + +private: + SchedulerManager(std::string defaultScheduler); + +public: + static void init(int argc, char** argv); + + static void finish(); + + static SchedulerManager& getInstance(); + +public: + ~SchedulerManager() {} + + AbstractScheduler* getDefaultScheduler(); + + AbstractScheduler* getSchedulerByName(std::string& name); + + void markSchedulerForDeletion(AbstractScheduler* scheduler); +}; + +} /* namespace scheduling */ +} /* namespace wfr */ + diff --git a/include/wfr/scheduling/scheduler/dummy/DummyScheduler.h b/include/wfr/scheduling/scheduler/dummy/DummyScheduler.h new file mode 100755 index 0000000..e1009ed --- /dev/null +++ b/include/wfr/scheduling/scheduler/dummy/DummyScheduler.h @@ -0,0 +1,33 @@ + +#pragma once + + +#include + + +namespace wfr { +namespace wep { +class AtomicWepNode; +class WEPnode; +} +} + + +namespace wfr { +namespace scheduling { + +class DummyScheduler: public wfr::scheduling::SchedulerBase { +private: + resource::ResourceManager& resourceManager; + prediction::PredictionManager& predictionManager; + +public: + DummyScheduler(resource::ResourceManager& resourceManager, prediction::PredictionManager& predictionManager) + : resourceManager(resourceManager), predictionManager(predictionManager) {} + + virtual void _notifyWEPUpdate(SchedulerBase::WepMapEntry& wepe, std::set readyToExecute, std::unique_lock& schedulerLock); +}; + +} /* namespace scheduling */ +} /* namespace wfr */ + diff --git a/include/wfr/scheduling/scheduler/heft/HEFTScheduler.h b/include/wfr/scheduling/scheduler/heft/HEFTScheduler.h new file mode 100755 index 0000000..3a588c2 --- /dev/null +++ b/include/wfr/scheduling/scheduler/heft/HEFTScheduler.h @@ -0,0 +1,104 @@ + +#pragma once + + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace wfr { + +namespace wfs { +class AtomicActivityInstance; +} + +namespace wep { +class AtomicWepNode; +class AbstractWepNode; +} +namespace resource { +class ResourceManager; +} +namespace prediction { +class PredictionManager; +} +} + + +namespace wfr { +namespace scheduling { + + + + +class HEFTScheduler: public scheduling::SchedulerBase { +protected: + struct InstanceUserData { + bool isComplete = false; + bool isScheduled = false; + NumericalMeasurement rank; + NumericalMeasurement averageComputingCost; + // resourceName => (fastest implementation, prediction); + std::map> predictions; + }; + struct SchedulingQueueEntry { + InstanceUserData* instanceData = nullptr; + wfs::AtomicActivityInstance* instance = nullptr; + wep::AbstractWepNode* node = nullptr; + }; + struct _SchedulingQueueEntryComparison { + bool operator()(const SchedulingQueueEntry& e1, const SchedulingQueueEntry& e2) { + if (e1.instanceData && !e2.instanceData) { + return false; + } else if (!e1.instanceData && e2.instanceData) { + return true; + } else if (e1.instanceData && e2.instanceData) { + return e1.instanceData->rank.getValue() < e2.instanceData->rank.getValue(); + } else { + return false; + } + } + }; + std::priority_queue, _SchedulingQueueEntryComparison> schedulingPriorityQueue; + + + + resource::ResourceManager& resourceManager; + prediction::PredictionManager& predictionManager; + + std::vector debugLines; + wfr_size_t debugIteration = 0; + + + + NumericalMeasurement getRank(wfs::AtomicActivityInstance& ai, InstanceUserData* instanceData, const std::vector& resourceTypes, const std::vector& resources); + NumericalMeasurement getAverageExecutionCost(wfs::AtomicActivityInstance& ai, InstanceUserData* instanceData, const std::vector& resources); + NumericalMeasurement getMaxSuccValue(wfs::AtomicActivityInstance& ai, InstanceUserData* instanceData, const std::vector& resourceTypes, const std::vector& resources); + +public: + HEFTScheduler(resource::ResourceManager& resourceManager, prediction::PredictionManager& predictionManager) + : resourceManager(resourceManager), predictionManager(predictionManager) {} + + ~HEFTScheduler() { + /*for (auto s : debugLines) { + std::cout << s << std::endl; + }*/ + } + + virtual void _notifyWEPUpdate(SchedulerBase::WepMapEntry& wepe, std::set readyToExecute, std::unique_lock& schedulerLock); +}; + +} /* namespace scheduling */ +} /* namespace wfr */ + + diff --git a/include/wfr/scheduling/scheduler/justintime/JustInTimeScheduler.h b/include/wfr/scheduling/scheduler/justintime/JustInTimeScheduler.h new file mode 100755 index 0000000..ffcc89d --- /dev/null +++ b/include/wfr/scheduling/scheduler/justintime/JustInTimeScheduler.h @@ -0,0 +1,34 @@ + +#pragma once + + +#include + + +namespace wfr { +namespace wep { +class AtomicWepNode; +class WEPnode; +} +} + + +namespace wfr { +namespace scheduling { + +class JustInTimeScheduler: public wfr::scheduling::SchedulerBase { +private: + resource::ResourceManager& resourceManager; + prediction::PredictionManager& predictionManager; + std::set nodeQueue; + +public: + JustInTimeScheduler(resource::ResourceManager& resourceManager, prediction::PredictionManager& predictionManager) + : resourceManager(resourceManager), predictionManager(predictionManager) {} + + virtual void _notifyWEPUpdate(SchedulerBase::WepMapEntry& wepe, std::set readyToExecute, std::unique_lock& schedulerLock); +}; + +} /* namespace scheduling */ +} /* namespace wfr */ + diff --git a/include/wfr/scheduling/scheduler/random/RandomScheduler.h b/include/wfr/scheduling/scheduler/random/RandomScheduler.h new file mode 100755 index 0000000..a18cdbf --- /dev/null +++ b/include/wfr/scheduling/scheduler/random/RandomScheduler.h @@ -0,0 +1,34 @@ + +#pragma once + + +#include + + +namespace wfr { +namespace wep { +class AtomicWepNode; +class WEPnode; +} +} + + +namespace wfr { +namespace scheduling { + +class RandomScheduler: public wfr::scheduling::SchedulerBase { +private: + resource::ResourceManager& resourceManager; + prediction::PredictionManager& predictionManager; + std::set nodeQueue; + +public: + RandomScheduler(resource::ResourceManager& resourceManager, prediction::PredictionManager& predictionManager) + : resourceManager(resourceManager), predictionManager(predictionManager) {} + + virtual void _notifyWEPUpdate(SchedulerBase::WepMapEntry& wepe, std::set readyToExecute, std::unique_lock& schedulerLock); +}; + +} /* namespace scheduling */ +} /* namespace wfr */ + diff --git a/include/wfr/wep/utils/WepDotFileWriter.h b/include/wfr/wep/utils/WepDotFileWriter.h new file mode 100755 index 0000000..c863d1e --- /dev/null +++ b/include/wfr/wep/utils/WepDotFileWriter.h @@ -0,0 +1,53 @@ + +#pragma once + + +#include +#include +#include +#include + + +namespace wfr { +namespace wep { + +// Forward declarations +class WorkflowExecutionPlan; +class AbstractWepNode; + +// main namespace +namespace utils { + + +class WepDotFileWriter { + +// Invariant properties that can be accessed directly. +public: + typedef std::set visitedNodes_t; + const std::shared_ptr wep; + const std::string workflowName; + +// Non-Public functions +private: + void writeWepNodeAndEdges(std::ofstream& outfile, AbstractWepNode* node, visitedNodes_t& visitedNodes); + + std::string getNodeType(AbstractWepNode* node); + std::string getNodeLabel(AbstractWepNode* node); + std::string getNodeID(AbstractWepNode* node); + std::string getNodeShape(AbstractWepNode* node); + std::string getNodeStatus(AbstractWepNode* node); + std::string getNodeVisitationCount(AbstractWepNode* node); + +public: + WepDotFileWriter(const std::shared_ptr& wep) noexcept; + + void printToFile(); + void printToFile(const std::string fileName); + +}; + + +} /* namespace utils */ +} /* namespace wep */ +} /* namespace wfr */ + diff --git a/include/wfr/wep/utils/WepSearch.h b/include/wfr/wep/utils/WepSearch.h new file mode 100755 index 0000000..736c728 --- /dev/null +++ b/include/wfr/wep/utils/WepSearch.h @@ -0,0 +1,94 @@ + +#pragma once + + +#include + +namespace wfr { +namespace wep { +class AbstractWepNode; +} + +namespace utils { +namespace wep { + + + +template +void wepDepthFirstSearch(wfr::wep::AbstractWepNode* startNode, const VisitType& visitFunction, + std::set& visitedNodes = std::set()) { + visitedNodes.insert(startNode); + if (visitFunction(startNode)) { + for (auto c : startNode->getSuccessors()) { + if (visitedNodes.find(c) == visitedNodes.end()) { + wepDepthFirstSearch(c, visitFunction, visitedNodes); + } + } + } +} + + + +template +void wepBreadthFirstSearch(wfr::wep::AbstractWepNode* startNode, const VisitType& visitFunction) { + std::vector nodeQueue; + std::set visitedNodes; + nodeQueue.push_back(startNode); + while (!nodeQueue.empty()) { + auto cn = nodeQueue.front(); + visitedNodes.insert(cn); + nodeQueue.erase(nodeQueue.begin()); + if (visitFunction(cn)) { + for (auto c : cn->getSuccessors()) { + if (visitedNodes.find(c) == visitedNodes.end()) { + bool isInQueue = false; + for (auto e : nodeQueue) { + if (c == e) { + isInQueue = true; + break; + } + } + if (!isInQueue) { + nodeQueue.push_back(c); + } + } + } + } + } +} + + + +template +void wepBreadthFirstReverseSearch(wfr::wep::AbstractWepNode* startNode, const VisitType& visitFunction) { + std::vector nodeQueue; + std::set visitedNodes; + nodeQueue.push_back(startNode); + while (!nodeQueue.empty()) { + auto cn = nodeQueue.front(); + visitedNodes.insert(cn); + nodeQueue.erase(nodeQueue.begin()); + if (visitFunction(cn)) { + for (auto c : cn->getPredecessors()) { + if (visitedNodes.find(c) == visitedNodes.end()) { + bool isInQueue = false; + for (auto e : nodeQueue) { + if (c == e) { + isInQueue = true; + break; + } + } + if (!isInQueue) { + nodeQueue.push_back(c); + } + } + } + } + } +} + + +} +} +} + diff --git a/include/wfr/wfr.h b/include/wfr/wfr.h new file mode 100755 index 0000000..2499d4c --- /dev/null +++ b/include/wfr/wfr.h @@ -0,0 +1,33 @@ + +#pragma once + + +#include + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +using namespace wfr; + +/* +#include +*/ + diff --git a/src/WorkflowRuntime.cpp b/src/WorkflowRuntime.cpp new file mode 100755 index 0000000..df9ce29 --- /dev/null +++ b/src/WorkflowRuntime.cpp @@ -0,0 +1,74 @@ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +namespace wfr { + + +std::map WorkflowRuntime::globalConfig; + +std::default_random_engine WorkflowRuntime::randomEngine; + +std::unordered_set> WorkflowRuntime::workflowInstances; + + +void WorkflowRuntime::init(int argc, char** argv) { + bool isHelp = false; + + boost::program_options::options_description opts("Global Options"); + opts.add_options() + ("help", "Print help message.") + ("sim-mode", "Enable simulation-mode."); + boost::program_options::variables_map vm; + auto parsed = boost::program_options::command_line_parser(argc, argv).options(opts).allow_unregistered().run(); + boost::program_options::store(parsed, vm); + boost::program_options::notify(vm); + + if (vm.count("help")) { + std::cerr << opts << std::endl; + isHelp = true; + } + if (vm.count("sim-mode")) { + setGlobalConfig("sim-mode", true); + } + + wfr::eventsystem::EventSystem::init(argc, argv); + wfr::resource::ResourceManager::init(argc, argv); + wfr::enactment::EnactmentEngine::init(argc, argv); + wfr::prediction::PredictionManager::init(argc, argv); + wfr::execution::ExecutionManager::init(argc, argv); + wfr::scheduling::SchedulerManager::init(argc, argv); + + if (isHelp) exit(0); +} + +void WorkflowRuntime::finish() { + wfr::scheduling::SchedulerManager::finish(); + wfr::execution::ExecutionManager::finish(); + wfr::prediction::PredictionManager::finish(); + wfr::enactment::EnactmentEngine::finish(); + wfr::resource::ResourceManager::finish(); + wfr::eventsystem::EventSystem::finish(); + if (workflowInstances.size() == 1) { + (*workflowInstances.begin())->printStatistics(); + } else if (workflowInstances.size() > 1) { + std::cerr << "ERROR: Print statistics for more than one workflow instance not implemented." << std::endl; + } +} + +void WorkflowRuntime::logMessage(std::string message, const wfr_timestamp_sc_t& timestamp, bool noLocking) { + wfr::eventsystem::GeneralLoggingEvent::fireEvent(message, timestamp, noLocking); +} + + +} /* namespace wfr */ diff --git a/src/cmake.inc b/src/cmake.inc new file mode 100755 index 0000000..8171444 --- /dev/null +++ b/src/cmake.inc @@ -0,0 +1,13 @@ + +set(wfr_cpp_files "${wfr_cpp_files}" + src/WorkflowRuntime.cpp +) + +include(src/common/cmake.inc) +include(src/eventsystem/cmake.inc) +include(src/enactment/cmake.inc) +include(src/wep/cmake.inc) +include(src/utils/cmake.inc) +include(src/prediction/cmake.inc) +include(src/scheduling/cmake.inc) +include(src/execution/cmake.inc) diff --git a/src/common/cmake.inc b/src/common/cmake.inc new file mode 100755 index 0000000..cd7ac1f --- /dev/null +++ b/src/common/cmake.inc @@ -0,0 +1,4 @@ + +include(src/common/wfs/cmake.inc) +include(src/common/wep/cmake.inc) +include(src/common/resource/cmake.inc) diff --git a/src/common/resource/Resource.cpp b/src/common/resource/Resource.cpp new file mode 100755 index 0000000..6b3d53e --- /dev/null +++ b/src/common/resource/Resource.cpp @@ -0,0 +1,155 @@ + +#include +#include +#include + + +namespace wfr { +namespace resource { + + +bool AbstractResourceType::hasCapability(const RequiredResourceCapability& type) const noexcept { + for (auto& cap : capabilities) { + if (cap == type) { + return true; + } + } + return false; +} + + +bool AbstractResourceType::hasCapability(wfr::resource::ResourceCapabilityType type) const noexcept { + for (auto& cap : capabilities) { + if (cap.type == type) { + return true; + } + } + return false; +} + + +std::vector AbstractResourceType::getPropertyKeys() const noexcept { + std::vector retval; + for (auto i : properties) { + retval.push_back(i.first); + } + return retval; +} + + +std::string AbstractResourceType::getProperty(const std::string& key) const noexcept { + auto i = properties.find(key); + if (i != properties.end()) { + return i->second; + } else { + return std::string(); + } +} + + + +std::map registeredDeviceTypes = { + {"cpu", ComputingDeviceClass::CPU}, + {"gpu", ComputingDeviceClass::GPU} +}; + + + +std::map registeredDeviceCapabilityTypes = { + {"genericcpu", ResourceCapabilityType::GenericCPU}, + {"cuda", ResourceCapabilityType::CUDA}, + {"opencl", ResourceCapabilityType::OpenCL} +}; + + + +ComputingDeviceClass parseComputingDeviceType(const std::string& type) { + ComputingDeviceClass retval = ComputingDeviceClass::Unknown; + std::string tmp(type); + std::transform(tmp.begin(), tmp.end(), tmp.begin(), ::tolower); + auto item = registeredDeviceTypes.find(tmp); + if (item != registeredDeviceTypes.end()) { + retval = item->second; + } + return retval; +} + + +std::string getComputingDeviceTypeString(const ComputingDeviceClass& type) { + std::string retval; + for (auto& item : registeredDeviceTypes) { + if (item.second == type) { + retval = item.first; + break; + } + } + return retval; +} + + +ResourceCapabilityType parseResourceCapabilityType(const std::string& type) { + ResourceCapabilityType retval = ResourceCapabilityType::Unknown; + std::string tmp(type); + std::transform(tmp.begin(), tmp.end(), tmp.begin(), ::tolower); + auto item = registeredDeviceCapabilityTypes.find(tmp); + if (item != registeredDeviceCapabilityTypes.end()) { + retval = item->second; + } + return retval; +} + + +std::string getResourceCapabilityTypeString(const ResourceCapabilityType& type) { + std::string retval; + for (auto& item : registeredDeviceCapabilityTypes) { + if (item.second == type) { + retval = item.first; + break; + } + } + return retval; +} + + +bool ComputingResource::reserveSlots(const wfr_size_t& slots) noexcept { + if (slots <= getFreeSlotCount()) { + reservedSlots += slots; + return true; + } else { + return false; + } +} + +bool ComputingResource::markReservedSlotsBusy(const wfr_size_t& slots) noexcept { + if (slots <= reservedSlots) { + reservedSlots -= slots; + busySlots += slots; + return true; + } else { + return false; + } + +} + +bool ComputingResource::markFreeSlotsBusy(const wfr_size_t& slots) noexcept { + if (slots <= getFreeSlotCount()) { + busySlots += slots; + return true; + } else { + return false; + } +} + +bool ComputingResource::releaseBusySlots(const wfr_size_t& slots) noexcept { + if (slots <= busySlots) { + busySlots -= slots; + return true; + } else { + return false; + } +} + + + +} /* namespace resource */ +} /* namespace wfr */ diff --git a/src/common/resource/ResourceManager.cpp b/src/common/resource/ResourceManager.cpp new file mode 100755 index 0000000..9bbfc16 --- /dev/null +++ b/src/common/resource/ResourceManager.cpp @@ -0,0 +1,372 @@ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace wfr { +namespace resource { + + +ResourceManager* ResourceManager::singleton = nullptr; + +void ResourceManager::init(int argc, char** argv) { + std::string resourceConfigFile; + bool cpuAutoConfig = true; + bool printResourceTable = false; + + boost::program_options::options_description opts("ResourceManager Options"); + opts.add_options() + ("help", "Print help message.") + ("no-cpu-autoconfig", "Disable CPU auto-configuration.") + ("print-resource-table", "Print resource table.") + ("resource-config-file", boost::program_options::value(), "Set resource config file."); + boost::program_options::variables_map vm; + auto parsed = boost::program_options::command_line_parser(argc, argv).options(opts).allow_unregistered().run(); + boost::program_options::store(parsed, vm); + boost::program_options::notify(vm); + if (vm.count("help")) { + std::cerr << opts << std::endl; + return; + } + if (vm.count("no-cpu-autoconfig")) { + cpuAutoConfig = false; + } + if (vm.count("print-resource-table")) { + printResourceTable = true; + } + if (vm.count("resource-config-file")) { + resourceConfigFile = vm["resource-config-file"].as(); + boost::filesystem::path resourceConfigFilePath(resourceConfigFile); + if (boost::filesystem::is_regular_file(resourceConfigFilePath)) { + std::cerr << "Resource config file is set to \""<< resourceConfigFile << "\"." << std::endl; + } else { + throw wfr::exception::wfr_illegal_argument((boost::format("%1% does not exist or is not a file.") % resourceConfigFile).str()); + } + } + + singleton = new ResourceManager(resourceConfigFile, cpuAutoConfig, printResourceTable); +} + +void ResourceManager::finish() noexcept { + if (singleton != nullptr) { + delete singleton; + singleton = nullptr; + } +} + +ResourceManager& ResourceManager::getInstance() noexcept { + if (singleton == nullptr) { + throw wfr::exception::wfr_missing_instance("ResourceManager instance not found."); + } + return *singleton; +} + +ResourceManager::ResourceManager(std::string resourceConfigFile, bool cpuAutoConfig, bool printResourceTable) { + if (cpuAutoConfig) { + unsigned threadCount = std::thread::hardware_concurrency(); + ComputingResourceType* resType = new ComputingResourceType("CPU", ComputingDeviceClass::CPU, threadCount, {{ResourceCapabilityType::GenericCPU, 0, 0}}); + std::string tmp(resType->resourceTypeName); + computingResourceTypes.insert({tmp, resType}); + ComputingResource* dev = new ComputingResource("cpu0", *resType); + computingResources.insert({dev->resourceIdentifier, dev}); + } + if (!resourceConfigFile.empty()) { + readConfigFile(resourceConfigFile); + } + if (printResourceTable) { + std::this_thread::sleep_for(std::chrono::milliseconds(10)); + this->printResourceTable(std::cout); + std::this_thread::sleep_for(std::chrono::milliseconds(10)); + } +} + + +void ResourceManager::readConfigFile(std::string resourceConfigFile) { + std::ifstream configFile(resourceConfigFile); + std::string configContent((std::istreambuf_iterator(configFile)), std::istreambuf_iterator()); + rapidjson::Document configDocument; + if (!configDocument.Parse(configContent.c_str()).HasParseError()) { + if (!configDocument.IsObject()) { + throw wfr::exception::wfr_fatal_error("Resource config file: toplevel item is not an object."); + } + if (!configDocument.HasMember("devicetypes")) { + throw wfr::exception::wfr_fatal_error("Resource config file: No devicetypes item found."); + } + auto& types = configDocument["devicetypes"]; + if (!types.IsObject()) { + throw wfr::exception::wfr_fatal_error("Resource config file: devicetypes item is not an object."); + } + // Iterate over device types + for(rapidjson::Value::ConstMemberIterator it=types.MemberBegin(); it != types.MemberEnd(); it++) { + auto& type = *it; + if (!type.value.IsObject()) { + throw wfr::exception::wfr_fatal_error("Resource config file: type item is not an object."); + } + std::string resourceName = type.name.GetString(); + ComputingDeviceClass computingDeviceClass = ComputingDeviceClass::Unknown; + if (!type.value.HasMember("deviceClass")) { + throw wfr::exception::wfr_fatal_error((boost::format("Resource config file: device type \"%1%\" has no deviceClass property.") % resourceName).str()); + } + if (!type.value["deviceClass"].IsString()) { + throw wfr::exception::wfr_fatal_error("Resource config file: device type property \"deviceClass\" has wrong type."); + } + std::string classStr = type.value["deviceClass"].GetString(); + if (classStr.compare("CPU") == 0) { + computingDeviceClass = ComputingDeviceClass::CPU; + } else if (classStr.compare("GPU") == 0) { + computingDeviceClass = ComputingDeviceClass::GPU; + } else { + computingDeviceClass = ComputingDeviceClass::Unknown; + } + if (computingDeviceClass == ComputingDeviceClass::Unknown) { + throw wfr::exception::wfr_fatal_error((boost::format("Resource config file: unknown device type class \"%1%\".") % classStr).str()); + } + wfr_size_t deviceSlots = 1; + if (type.value.HasMember("slots")) { + if (!type.value["slots"].IsUint()) { + throw wfr::exception::wfr_fatal_error("Resource config file: device type property \"slots\" has wrong type."); + } + deviceSlots = type.value["slots"].GetUint(); + } + std::set capabilities = std::set(); + if (type.value.HasMember("capabilities")) { + if (!type.value["capabilities"].IsArray()) { + throw wfr::exception::wfr_fatal_error("Resource config file: device type property \"capabilities\" has wrong type."); + } + auto& caps = type.value["capabilities"]; + for(rapidjson::Value::ConstValueIterator it2=caps.Begin(); it2 != caps.End(); it2++) { + auto& cap = *it2; + if (!cap.IsArray()) { + throw wfr::exception::wfr_fatal_error("Resource config file: capability has wrong type."); + } + if (!cap[0].IsString()) { + throw wfr::exception::wfr_fatal_error("Resource config file: capability param 0 has wrong type."); + } + if (!cap[1].IsInt()) { + throw wfr::exception::wfr_fatal_error("Resource config file: capability param 1 has wrong type."); + } + if (!cap[2].IsInt()) { + throw wfr::exception::wfr_fatal_error("Resource config file: capability param 2 has wrong type."); + } + std::string capname = cap[0].GetString(); + ResourceCapabilityType captype = ResourceCapabilityType::Unknown; + if (capname.compare("GenericCPU") == 0) { + captype = ResourceCapabilityType::GenericCPU; + } else if (capname.compare("OpenCL") == 0) { + captype = ResourceCapabilityType::OpenCL; + } else if (capname.compare("CUDA") == 0) { + captype = ResourceCapabilityType::CUDA; + } else { + throw wfr::exception::wfr_fatal_error((boost::format("Resource config file: unknown capability \"%1%\".") % capname).str()); + } + wfr_size_t minVersion = cap[1].GetInt(); + wfr_size_t maxVersion = cap[2].GetInt(); + capabilities.insert({captype, minVersion, maxVersion}); + } + } + std::map properties = std::map(); + if (type.value.HasMember("properties")) { + if (!type.value["properties"].IsArray()) { + throw wfr::exception::wfr_fatal_error("Resource config file: device type property \"properties\" has wrong type."); + } + auto& props = type.value["properties"]; + for(rapidjson::Value::ConstValueIterator it2=props.Begin(); it2 != props.End(); it2++) { + auto& prop = *it2; + if (!prop.IsArray()) { + throw wfr::exception::wfr_fatal_error("Resource config file: property has wrong type."); + } + if (!prop[0].IsString()) { + throw wfr::exception::wfr_fatal_error("Resource config file: property name has wrong type."); + } + if (!prop[1].IsString()) { + throw wfr::exception::wfr_fatal_error("Resource config file: property value has wrong type."); + } + properties.insert({prop[0].GetString(), prop[1].GetString()}); + } + } + ComputingResourceType* resType = new ComputingResourceType(resourceName, computingDeviceClass, deviceSlots, capabilities, properties); + computingResourceTypes.insert({resourceName, resType}); + } + if (!configDocument.HasMember("devices")) { + throw wfr::exception::wfr_fatal_error("Resource config file: No devices item found."); + } + auto& devices = configDocument["devices"]; + if (!devices.IsObject()) { + throw wfr::exception::wfr_fatal_error("Resource config file: devices item is not an object."); + } + // Iterate over devices + for(rapidjson::Value::ConstMemberIterator it2=devices.MemberBegin(); it2 != devices.MemberEnd(); it2++) { + auto& dev = *it2; + if (!dev.value.IsString()) { + throw wfr::exception::wfr_fatal_error("Resource config file: device item is not a string."); + } + std::string devName = dev.name.GetString(); + std::string devTypeName = dev.value.GetString(); + auto devType = computingResourceTypes.find(devTypeName); + if (devType == computingResourceTypes.end()) { + throw wfr::exception::wfr_fatal_error((boost::format("Resource config file: unknown device type \"%1%\".") % devTypeName).str()); + } + + ComputingResource* device = new ComputingResource(devName, *(*devType).second); + computingResources.insert({device->resourceIdentifier, device}); + } + + } else { + rapidjson::ParseErrorCode e = configDocument.GetParseError(); + size_t o = configDocument.GetErrorOffset(); + std::stringstream ss; + ss << "Error during parsing resource config file: \"" << rapidjson::GetParseError_En(e) << "\""; + ss << " at offset " << o << " near '" << configContent.substr(o, 10) << "...'" << std::endl; + throw wfr::exception::wfr_fatal_error(ss.str()); + } +} + + +std::vector ResourceManager::getComputingResources() const noexcept { + std::vector retval; + for (auto dev : computingResources) { + retval.push_back(dev.second); + } + return retval; +} + + +ComputingResource* ResourceManager::getComputingResource(std::string identifier) const noexcept { + std::vector retval; + for (auto dev : computingResources) { + if (dev.second->resourceIdentifier.compare(identifier) == 0) { + return dev.second; + } + } + return nullptr; +} + + +std::vector ResourceManager::filterComputingResources(std::vector filter) const noexcept { + std::vector retval; + for (auto dev : computingResources) { + for (auto cap : filter) { + if (dev.second->hasCapability(cap)) { + retval.push_back(dev.second); + } + } + } + return retval; +} + + +ComputingResourceReservation ResourceManager::reserveComputingResource(ComputingResource* device, const wfr_size_t& slots) noexcept { + if (device->getFreeSlotCount() >= slots) { + if (device->reserveSlots(slots)) { + return ComputingResourceReservation(device, slots); + } + } + return ComputingResourceReservation(); +} + + + +std::vector ResourceManager::getComputingResourceTypes() const noexcept { + std::vector retval; + for (auto i : computingResourceTypes) { + retval.push_back(i.second); + } + return retval; +} + + +ComputingResourceType* ResourceManager::getComputingResourceType(std::string name) const noexcept { + return computingResourceTypes.at(name); +} + + + +ResourceManager::~ResourceManager() { + for (auto dev : computingResources) { + delete dev.second; + } + computingResources.clear(); + for (auto type : computingResourceTypes) { + delete type.second; + } + computingResourceTypes.clear(); +} + + + +void ResourceManager::printResourceTable(std::ostream& out) const noexcept { + out << "======= Computing Resource Type Table ========" << std::endl; + for (auto& res : computingResourceTypes) { + out << "ResourceType: \"" << res.first << "\":" << std::endl; + std::string deviceClassStr; + switch (res.second->computingDeviceClass) { + case ComputingDeviceClass::CPU: + deviceClassStr = "CPU"; + break; + case ComputingDeviceClass::GPU: + deviceClassStr = "GPU"; + break; + default: + deviceClassStr = "Unknown"; + break; + } + out << "\tDeviceClass: " << deviceClassStr << std::endl; + out << "\tSlots: " << res.second->maxSlots << std::endl; + out << "\tCapabilities: " << std::endl; + auto& caps = res.second->getCapabilities(); + if (caps.size() > 0) { + for (auto& cap : caps) { + std::string capName; + switch (cap.type) { + case ResourceCapabilityType::GenericCPU: + capName = "GenericCPU"; + break; + case ResourceCapabilityType::CUDA: + capName = "CUDA"; + break; + case ResourceCapabilityType::OpenCL: + capName = "OpenCL"; + break; + default: + capName = "Unknown"; + break; + } + out << "\t\t" << capName << " (Min: " << cap.minorVersion << ", Max: " << cap.majorVersion << ")" << std::endl; + } + } else { + out << "\t\tNone" << std::endl; + } + out << "\tProperties: " << std::endl; + auto& props = res.second->getProperties(); + if (props.size() > 0) { + for (auto& prop : props) { + out << "\t\t" << prop.first << " = " << prop.second << std::endl; + } + } else { + out << "\t\tNone" << std::endl; + } + } + out << "===== Computing Resource Type Table End ======" << std::endl; + out << "======= Computing Resource Table ========" << std::endl; + for (auto& res : computingResources) { + out << "Resource: \"" << res.second->resourceIdentifier << "\":" << std::endl; + out << "\tResourceType: \"" << res.second->resourceType.resourceTypeName << "\"" << std::endl; + } + out << "===== Computing Resource Table End ======" << std::endl; +} + +} /* namespace resource */ +} /* namespace wfr */ diff --git a/src/common/resource/cmake.inc b/src/common/resource/cmake.inc new file mode 100755 index 0000000..a740eaa --- /dev/null +++ b/src/common/resource/cmake.inc @@ -0,0 +1,5 @@ + +set(wfr_cpp_files "${wfr_cpp_files}" + src/common/resource/Resource.cpp + src/common/resource/ResourceManager.cpp +) diff --git a/src/common/wep/AbstractWepNode.cpp b/src/common/wep/AbstractWepNode.cpp new file mode 100755 index 0000000..7c0537a --- /dev/null +++ b/src/common/wep/AbstractWepNode.cpp @@ -0,0 +1,15 @@ + +#include + +namespace wfr { +namespace wep { + +std::atomic AbstractWepNode::nextWepNodeID = ATOMIC_VAR_INIT(1); + +} /* namespace wep */ +} /* namespace wfr */ + + + + + diff --git a/src/common/wep/ActivityWepNode.cpp b/src/common/wep/ActivityWepNode.cpp new file mode 100755 index 0000000..f12ec40 --- /dev/null +++ b/src/common/wep/ActivityWepNode.cpp @@ -0,0 +1,26 @@ + +#include +#include + +namespace wfr { +namespace wep { + +ActivityWepNode::ActivityWepNode(WepNodeType nodeType, wfs::ActivityInstance& activity) noexcept + : AbstractWepNode(nodeType, true), lastKnownActivityStatus(activity.getInstanceStatus()), activity(activity) {} + +void ActivityWepNode::updateInstanceStatus() { + lastKnownActivityStatus = activity.getInstanceStatus(); +} + +void ActivityWepNode::addToVisitationCount(uint64_t val) noexcept { + visitationCount += val; + activity.addToVisitationCount(val); +} + +} /* namespace wep */ +} /* namespace wfr */ + + + + + diff --git a/src/common/wep/WorkflowExecutionPlan.cpp b/src/common/wep/WorkflowExecutionPlan.cpp new file mode 100755 index 0000000..e507677 --- /dev/null +++ b/src/common/wep/WorkflowExecutionPlan.cpp @@ -0,0 +1,36 @@ + +#include +#include +#include +#include + +namespace wfr { +namespace wep { + +std::atomic WorkflowExecutionPlan::nextWepID = ATOMIC_VAR_INIT(1); + + +WorkflowExecutionPlan::~WorkflowExecutionPlan() noexcept { + if (startNode) { + std::set visitedNodes; + std::queue nodeQueue; + nodeQueue.push(startNode); + visitedNodes.insert(startNode); + do { + auto node = nodeQueue.front(); + nodeQueue.pop(); + for (auto s : node->getSuccessors()) { + if (visitedNodes.find(s) == visitedNodes.end()) { + nodeQueue.push(s); + visitedNodes.insert(s); + } + } + delete node; + } while (!nodeQueue.empty()); + } +} + + +} /* namespace wep */ +} /* namespace wfr */ + diff --git a/src/common/wep/activities/IterationEndWepNode.cpp b/src/common/wep/activities/IterationEndWepNode.cpp new file mode 100755 index 0000000..bedd5db --- /dev/null +++ b/src/common/wep/activities/IterationEndWepNode.cpp @@ -0,0 +1,22 @@ + +#include +#include + + +namespace wfr { +namespace wep { + + +void IterationEndWepNode::updateInstanceStatus() { + startNode->updateInstanceStatus(); +} + + +wfs::ActivityInstanceStatus IterationEndWepNode::getLastKnownInstanceStatus() const noexcept { + return startNode->getLastKnownInstanceStatus(); +} + + +} /* namespace wep */ +} /* namespace wfr */ + diff --git a/src/common/wep/activities/IterationStartWepNode.cpp b/src/common/wep/activities/IterationStartWepNode.cpp new file mode 100755 index 0000000..6914e4d --- /dev/null +++ b/src/common/wep/activities/IterationStartWepNode.cpp @@ -0,0 +1,16 @@ + +#include + + +namespace wfr { +namespace wep { + + +void IterationStartWepNode::updateInstanceStatus() { + +} + + +} /* namespace wep */ +} /* namespace wfr */ + diff --git a/src/common/wep/cmake.inc b/src/common/wep/cmake.inc new file mode 100755 index 0000000..7af9c2c --- /dev/null +++ b/src/common/wep/cmake.inc @@ -0,0 +1,8 @@ + +set(wfr_cpp_files "${wfr_cpp_files}" + src/common/wep/AbstractWepNode.cpp + src/common/wep/ActivityWepNode.cpp + src/common/wep/WorkflowExecutionPlan.cpp + src/common/wep/activities/IterationStartWepNode.cpp + src/common/wep/activities/IterationEndWepNode.cpp +) diff --git a/src/common/wfs/Activity.cpp b/src/common/wfs/Activity.cpp new file mode 100755 index 0000000..7f70c5f --- /dev/null +++ b/src/common/wfs/Activity.cpp @@ -0,0 +1,183 @@ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace wfr { +namespace wfs { + + +std::atomic Activity::nextActivityID = ATOMIC_VAR_INIT(1); + + +Activity::Activity( Workflow& workflow, ActivityTemplate& baseTemplate ) + : status(ActivityStatus::Unknown), + activityID(getNextActivityID()), + workflow(workflow), + baseTemplate(baseTemplate) { + setActivityStatus(ActivityStatus::Created); +} + + +Activity::~Activity() { + for (auto i : instanceList) { + if (i) delete i; + } + instanceList.clear(); +} + + +ActivityType Activity::activityType() const noexcept { + return baseTemplate.activityType; +} + +bool Activity::isCompositeActivity() const noexcept { + return baseTemplate.isCompositeActivity; +} + +bool Activity::isLoop() const noexcept { + return baseTemplate.isLoop; +} + +bool Activity::isConditional() const noexcept { + return baseTemplate.isConditional; +} + + +wfr_size_t Activity::getChildrenCount(wfr_id_t branchID) const noexcept { + wfr_size_t retval = 0; + for (auto i : workflow.getActivities()) { + if (i->parent && i->parent->activityID == activityID && i->baseTemplate.branchID == branchID) { + retval++; + } + } + return retval; +} + +std::vector Activity::getChildren(wfr_id_t branchID) const noexcept { + std::vector retval; + for (auto i : workflow.getActivities()) { + if (i->parent && i->parent->activityID == activityID && i->baseTemplate.branchID == branchID) { + retval.push_back(i); + } + } + return retval; +} + +bool Activity::isSuccessor(wfr_id_t aid) const noexcept { + for (auto i : successors) { + if (i->activityID == aid) { + return true; + } + } + return false; +} + +bool Activity::isSuccessor(Activity& act) const noexcept { + for (auto i : successors) { + if (i == &act) { + return true; + } + } + return false; +} + +bool Activity::isPredecessor(wfr_id_t aid) const noexcept { + for (auto i : predecessors) { + if (i->activityID == aid) { + return true; + } + } + return false; +} + +bool Activity::isPredecessor(Activity& act) const noexcept { + for (auto i : predecessors) { + if (i == &act) { + return true; + } + } + return false; +} + + +void Activity::setActivityStatus(ActivityStatus status) { + if (status != this->status) { + if (this->status > status) { + throw exception::wfr_exception((boost::format("Illegal state change in activity with id %1%.") % activityID).str()); + } + ActivityStatus oldStatus = this->status; + this->status = status; + wfr::eventsystem::ActivityStatusEvent::fireEvent(*this, oldStatus, status); + } +} + + +void Activity::initActivity() { + // Retrieve parent activity + if (baseTemplate.parentActivityID > 0) { + parent = workflow.getActivityByTemplateID(baseTemplate.parentActivityID); + assert(parent); + } + // Retrieve successors + for (auto i : baseTemplate.succRawList) { + auto tmp = workflow.getActivityByTemplateID(i); + assert(tmp); + successors.push_back(tmp); + } + // Retrieve predecessors + for (auto i : baseTemplate.predRawList) { + auto tmp = workflow.getActivityByTemplateID(i); + assert(tmp); + predecessors.push_back(tmp); + } + setActivityStatus(ActivityStatus::Initialized); +} + + + +ActivityInstance* Activity::createNewInstance(wfr_id_t iterationID) { + ActivityInstance* retval = nullptr; + switch (activityType()) { + case ActivityType::Atomic: + retval = new AtomicActivityInstance(*this, iterationID); + break; + case ActivityType::Assign: + retval = new AssignActivityInstance(*this, iterationID); + break; + case ActivityType::Conditional: + retval = new ConditionalActivityInstance(*this, iterationID); + break; + case ActivityType::Container: + retval = new ContainerActivityInstance(*this, iterationID); + break; + case ActivityType::ForLoop: + retval = new ForLoopActivityInstance(*this, baseTemplate.as().isParallel, iterationID); + break; + case ActivityType::WhileLoop: + retval = new WhileLoopActivityInstance(*this, iterationID); + break; + default: + throw wfr::exception::wfr_fatal_error("Unknown instance type encountered."); + } + if (retval != nullptr) { + instanceList.push_back(retval); + } + return retval; +} + + +} /* namespace wfs */ +} /* namespace wfr */ + + diff --git a/src/common/wfs/ActivityInstance.cpp b/src/common/wfs/ActivityInstance.cpp new file mode 100755 index 0000000..52ca7b1 --- /dev/null +++ b/src/common/wfs/ActivityInstance.cpp @@ -0,0 +1,176 @@ +/* + * ActivityInstance.cpp + * + * Created on: 06.02.2014 + * Author: matthias + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace wfr { +namespace wfs { + + + +std::atomicActivityInstance::nextInstanceID = ATOMIC_VAR_INIT(1); + +wfr_id_t ActivityInstance::getNextInstanceID() { + return nextInstanceID.fetch_add(1); +} + + +ActivityInstance::ActivityInstance(Activity& baseActivity, const wfr_id_t& iterationID) noexcept + : status(ActivityInstanceStatus::Unknown), + instanceID(getNextInstanceID()), + baseActivity(baseActivity), + iterationID(iterationID) { + setInstanceStatus(ActivityInstanceStatus::Created); +} + +ActivityType ActivityInstance::activityType() const noexcept { + return baseActivity.baseTemplate.activityType; +} + +bool ActivityInstance::isCompositeActivity() const noexcept { + return baseActivity.baseTemplate.isCompositeActivity; +} + +bool ActivityInstance::isLoop() const noexcept { + return baseActivity.baseTemplate.isLoop; +} + +bool ActivityInstance::isConditional() const noexcept { + return baseActivity.baseTemplate.isConditional; +} + +void ActivityInstance::setInstanceStatus(const ActivityInstanceStatus& status) { + if (status != this->status) { + if (this->status > status) { + throw wfr::exception::wfr_fatal_error((boost::format("Illegal activity instance state change in activity instance with id %1%.") % instanceID).str()); + } + + ActivityInstanceStatus oldStatus = this->status; + this->status = status; + + switch (status) { + case wfr::wfs::ActivityInstanceStatus::ReadyForExecution: + readyTime = std::chrono::system_clock::now(); + break; + case wfr::wfs::ActivityInstanceStatus::Running: + startTime = std::chrono::system_clock::now(); + break; + case wfr::wfs::ActivityInstanceStatus::Finished: + endTime = std::chrono::system_clock::now(); + /*if (parentActivity) { + if (parentActivity->isCompositeActivity()) { + wfr::wfs::CompositeActivityInstance& composite = parentActivity->as(); + composite.notifyChildHasFinished(*this); + } else { + throw wfr::exception::wfr_fatal_error("Non-Composite activity cannot be a parent."); + } + }*/ + break; + case wfr::wfs::ActivityInstanceStatus::Error: + endTime = std::chrono::system_clock::now(); + break; + default: + break; + } + + eventsystem::ActivityInstanceStatusEvent::fireEvent(*this, oldStatus, status); + + #ifdef WFR_ENABLE_STATISTICS + switch (activityType()) { + case ActivityType::Atomic: + switch (status) { + case wfr::wfs::ActivityInstanceStatus::Created: + baseActivity.workflow.addToCreatedAtomicInstanceCount(); + break; + case wfr::wfs::ActivityInstanceStatus::Running: + baseActivity.workflow.addToCumulaticeAtomicReadyWaitingDuration(startTime-readyTime); + break; + case wfr::wfs::ActivityInstanceStatus::Finished: + baseActivity.workflow.addToFinishedAtomicInstanceCount(); + baseActivity.workflow.addToCumulaticeAtomicRunningDuration(endTime-startTime); + break; + case wfr::wfs::ActivityInstanceStatus::Error: + baseActivity.workflow.addToErrorAtomicInstanceCount(); + baseActivity.workflow.addToCumulaticeAtomicRunningDuration(endTime-startTime); + break; + default: + break; + } + break; + default: + switch (status) { + case wfr::wfs::ActivityInstanceStatus::Created: + baseActivity.workflow.addToCreatedCompositeInstanceCount(); + break; + case wfr::wfs::ActivityInstanceStatus::Finished: + baseActivity.workflow.addToFinishedCompositeInstanceCount(); + break; + case wfr::wfs::ActivityInstanceStatus::Error: + baseActivity.workflow.addToErrorCompositeInstanceCount(); + break; + default: + break; + } + break; + } + #endif + } +} + + +void ActivityInstance::setErrorState(std::exception_ptr exception) noexcept { + errorCause = exception; + setInstanceStatus(ActivityInstanceStatus::Error); +} + + +void ActivityInstance::executeSimMode() noexcept { + if (WorkflowRuntime::getGlobalConfig("sim-mode")) { + if (schedulingDecision) { + std::cout << "Simulating execution ... " << std::endl; + auto prediction = schedulingDecision->getPrediction(); + if (prediction) { + auto& predTime = prediction.getExecutionTime(); + double time = WorkflowRuntime::getRandomNumber(predTime.getValue() - predTime.getDeviation(), predTime.getValue() + predTime.getDeviation()); + std::cout << "Sleeping for " << time << " seconds." << std::endl; + std::this_thread::sleep_for(std::chrono::milliseconds((long int)(time * 1000))); + /*std::cout << "Doing stuff for " << time << " seconds." << std::endl; + std::chrono::system_clock::time_point endtime = std::chrono::system_clock::now() + std::chrono::milliseconds((long int)(time * 1000)); + while (true) { + if (std::chrono::system_clock::now() >= endtime) { + break; + } else { + volatile int i = 0; + for (int t = 0; t < 1000; t++) { + i++; + } + } + }*/ + } else { + std::cout << "Warning: No valid prediction found" << std::endl; + } + } else { + throw exception::wfr_fatal_error("No scheduling decision found."); + } + } +} + + +} /* namespace wfs */ +} /* namespace wfr */ + diff --git a/src/common/wfs/ActivityTemplate.cpp b/src/common/wfs/ActivityTemplate.cpp new file mode 100755 index 0000000..bf7b2f6 --- /dev/null +++ b/src/common/wfs/ActivityTemplate.cpp @@ -0,0 +1,181 @@ + + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +#include +namespace wfr { +namespace wfs { + + + +ActivityTemplate::ActivityTemplate( wfr_id_t id, + ActivityType type, + const std::string& name, + wfr_id_t parentID, + wfr_id_t branchID, + const std::initializer_list& succList, + const std::initializer_list& predList, + bool isCompositeActivity, + bool isLoop, + bool isConditional ) noexcept + : succRawList(succList), predRawList(predList), templateID(id), activityName(name), activityType(type), parentActivityID(parentID), + branchID(branchID), isCompositeActivity(isCompositeActivity), isLoop(isLoop), isConditional(isConditional) { + if (id == 0) { + throw exception::wfr_fatal_error((boost::format("ID of Activity template \"%1%\" must be greater than 0.") % activityName).str()); + } +} + + +void ActivityTemplate::initActivityTemplate(WorkflowTemplate& parentWorkflow) { + this->parentWorkflow = &parentWorkflow; + if (parentActivityID > 0) { + this->parentActivity = parentWorkflow.getActivityByID(parentActivityID); + if (!this->parentActivity) { + throw exception::wfr_fatal_error((boost::format("Activity template \"%1%\" has invalid parent activity id.") % activityName).str()); + } + } + for (auto i : succRawList) { + auto act = parentWorkflow.getActivityByID(i); + if (!act) { + throw exception::wfr_fatal_error((boost::format("Activity template \"%1%\" has invalid successor id %2%.") % activityName % i).str()); + } else { + successors.push_back(act); + } + } + for (auto i : predRawList) { + auto act = parentWorkflow.getActivityByID(i); + if (!act) { + throw exception::wfr_fatal_error((boost::format("Activity template \"%1%\" has invalid predecessor id %2%.") % activityName % i).str()); + } else { + predecessors.push_back(act); + } + } +} + + + +void ActivityTemplate::checkStructure() { + // Check parent activity + if (parentActivity) { + if (!parentActivity->isCompositeActivity) { + throw exception::wfr_fatal_error((boost::format("Parent \"%1%\" of activity template \"%2%\" is is not a composite activity.") % parentActivity->activityName % activityName).str()); + } + } + // Check that every successor has this activity as predecessor + for (auto i : successors) { + if (!i->isPredecessor(*this)) { + throw exception::wfr_fatal_error((boost::format("Activity template \"%2%\" is a successor of \"%1%\", but \"%1%\" is not a predecessor of \"%2%\".") % activityName % i->activityName).str()); + } + } + // Check that every predecessor has this activity as successor + for (auto i : predecessors) { + if (!i->isSuccessor(*this)) { + throw exception::wfr_fatal_error((boost::format("Activity template \"%2%\" is a predecessor of \"%1%\", but \"%1%\" is not a successor of \"%2%\".") % activityName % i->activityName).str()); + } + } +} + + + +Activity* ActivityTemplate::createActivityFromTemplate(wfr::wfs::Workflow& workflow) { + return new Activity(workflow, *this); +} + + + +ActivityTemplate* ActivityTemplate::atomic( wfr_id_t id, + const std::string& name, + wfr_id_t parentID, + wfr_id_t branchID, + std::initializer_list succList, + std::initializer_list predList, + InputHookFunc inputHook, + std::shared_ptr atomicActivityType ) { + return new AtomicActivityTemplate(id, name, parentID, branchID, succList, predList, inputHook, atomicActivityType); +} + + +ActivityTemplate* ActivityTemplate::assign( wfr_id_t id, + const std::string& name, + wfr_id_t parentID, + wfr_id_t branchID, + std::initializer_list succList, + std::initializer_list predList, + InputHookFunc inputHook, + ExecutionHookFunc execHook ) { + return new AssignActivityTemplate(id, name, parentID, branchID, succList, predList, inputHook, execHook); +} + + +ActivityTemplate* ActivityTemplate::container( wfr_id_t id, + const std::string& name, + wfr_id_t parentID, + wfr_id_t branchID, + std::initializer_list succList, + std::initializer_list predList, + InputHookFunc inputHook, + OutputHookFunc outputHook ) { + return new ContainerActivityTemplate(id, name, parentID, branchID, succList, predList, inputHook, outputHook); +} + + +ActivityTemplate* ActivityTemplate::forLoop( wfr_id_t id, + const std::string& name, + wfr_id_t parentID, + wfr_id_t branchID, + const std::initializer_list& succList, + const std::initializer_list& predList, + InputHookFunc inputFuncHook, + OutputHookFunc outputFuncHook, + ForCounterHookFunc counterFuncHook, + LoopIterationHookFunc iterationFuncHook, + bool isParallel ) { + return new ForLoopActivityTemplate(id, name, parentID, branchID, succList, predList, inputFuncHook, outputFuncHook, counterFuncHook, iterationFuncHook, isParallel); +} + + + +ActivityTemplate* ActivityTemplate::whileLoop( wfr_id_t id, + const std::string& name, + wfr_id_t parentID, + wfr_id_t branchID, + const std::initializer_list& succList, + const std::initializer_list& predList, + InputHookFunc inputFuncHook, + OutputHookFunc outputFuncHook, + WhileConditionHookFunc conditionFuncHook, + LoopIterationHookFunc iterationFuncHook ) { + return new WhileLoopActivityTemplate(id, name, parentID, branchID, succList, predList, inputFuncHook, outputFuncHook, conditionFuncHook, iterationFuncHook); +} + + + +ActivityTemplate* ActivityTemplate::conditional( wfr_id_t id, + const std::string& name, + wfr_id_t parentID, + wfr_id_t branchID, + const std::initializer_list& succList, + const std::initializer_list& predList, + InputHookFunc inputFuncHook, + OutputHookFunc outputFuncHook, + BranchConditionHookFunc branchFuncHook ) { + return new ConditionalActivityTemplate(id, name, parentID, branchID, succList, predList, inputFuncHook, outputFuncHook, branchFuncHook); +} + +} /* namespace wfs */ +} /* namespace wfr */ + + + + diff --git a/src/common/wfs/AtomicActivityImplementation.cpp b/src/common/wfs/AtomicActivityImplementation.cpp new file mode 100755 index 0000000..59a53ad --- /dev/null +++ b/src/common/wfs/AtomicActivityImplementation.cpp @@ -0,0 +1,100 @@ + +#include +#include +#include +#include +#include +#include + +namespace wfr { +namespace wfs { + + +std::atomic AtomicActivityImplementation::nextImplementationID = ATOMIC_VAR_INIT(1); + + +AtomicActivityImplementation* +AtomicActivityImplementation::PThread( const ExecutionHookFunc& executionFuncHook, + const std::string& name, + utils::PropertyList properties, + resource::RequiredCapabilityList capabilities ) noexcept { + std::vector caps(capabilities); + caps.push_back(wfr::resource::RequiredResourceCapability::GenericCPU()); + return new PThreadActivityImplementation(executionFuncHook, caps, properties, name); +} + + +AtomicActivityImplementation* +AtomicActivityImplementation::OpenCL( const ExecutionHookFunc& executionFuncHook, + const std::string& name, + std::initializer_list minVersion, + std::initializer_list maxVersion, + utils::PropertyList properties, + resource::RequiredCapabilityList capabilities ) noexcept { + std::vector caps(capabilities); + wfr_size_t minVersion1 = 0, minVersion2 = 0, maxVersion1 = 0, maxVersion2 = 0; + wfr_size_t versionCount = 0; + for (auto i : minVersion) { + if (versionCount == 0) { + minVersion1 = i; + } else if (versionCount == 1) { + minVersion2 = i; + } else { + break; + } + versionCount++; + } + versionCount = 0; + for (auto i : maxVersion) { + if (versionCount == 0) { + maxVersion1 = i; + } else if (versionCount == 1) { + maxVersion2 = i; + } else { + break; + } + versionCount++; + } + caps.push_back(wfr::resource::RequiredResourceCapability::OpenCL(minVersion1, minVersion2, maxVersion1, maxVersion2)); + return new OpenCLActivityImplementation(executionFuncHook, capabilities, properties, name); +} + + +AtomicActivityImplementation* +AtomicActivityImplementation::CUDA( const ExecutionHookFunc& executionFuncHook, + const std::string& name, + std::initializer_list minVersion, + std::initializer_list maxVersion, + utils::PropertyList properties, + resource::RequiredCapabilityList capabilities ) noexcept { + std::vector caps(capabilities); + wfr_size_t minVersion1 = 0, minVersion2 = 0, maxVersion1 = 0, maxVersion2 = 0; + wfr_size_t versionCount = 0; + for (auto i : minVersion) { + if (versionCount == 0) { + minVersion1 = i; + } else if (versionCount == 1) { + minVersion2 = i; + } else { + break; + } + versionCount++; + } + versionCount = 0; + for (auto i : maxVersion) { + if (versionCount == 0) { + maxVersion1 = i; + } else if (versionCount == 1) { + maxVersion2 = i; + } else { + break; + } + versionCount++; + } + caps.push_back(wfr::resource::RequiredResourceCapability::CUDA(minVersion1, minVersion2, maxVersion1, maxVersion2)); + return new CUDAActivityImplementation(executionFuncHook, capabilities, properties, name); +} + + +} /* namespace execution */ +} /* namespace wfr */ diff --git a/src/common/wfs/AtomicActivityType.cpp b/src/common/wfs/AtomicActivityType.cpp new file mode 100755 index 0000000..48827a3 --- /dev/null +++ b/src/common/wfs/AtomicActivityType.cpp @@ -0,0 +1,21 @@ + +#include +#include + + +namespace wfr { +namespace wfs { + +AtomicActivityType::~AtomicActivityType() noexcept { + for (auto i : implementations) { + if (i) delete i; + } + implementations.clear(); + } + + +} /* namespace wfs */ +} /* namespace wfr */ + + + diff --git a/src/common/wfs/Workflow.cpp b/src/common/wfs/Workflow.cpp new file mode 100755 index 0000000..8a01831 --- /dev/null +++ b/src/common/wfs/Workflow.cpp @@ -0,0 +1,156 @@ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace wfr { + +namespace scheduling { class AbstractScheduler; } + +namespace wfs { + + + +std::atomic Workflow::nextWorkflowID = ATOMIC_VAR_INIT(1); + + +Workflow::Workflow(WorkflowTemplate& baseTemplate) + : status(WorkflowStatus::Unknown), + workflowID(getNextWorkflowID()), + baseTemplate(baseTemplate) { + setWorkflowStatus(WorkflowStatus::Created); + // Create activity instances + for (auto i : baseTemplate.getActivities()) { + auto tmp = i->createActivityFromTemplate(*this); + assert(tmp); + activities.push_back(tmp); + } + // Init activity instances + for (auto i : activities) { + i->initActivity(); + } + // Retrieve top-level activity + topLevelActivity = getActivityByID(baseTemplate.getTopLevelActivityID()); + assert(topLevelActivity); + setWorkflowStatus(WorkflowStatus::Initialized); +} + +Workflow::~Workflow() { + for (auto i : activities) { + if (i) delete i; + } + activities.clear(); +} + + + +void Workflow::setWorkflowStatus (WorkflowStatus status) { + if (status != this->status) { + if (this->status > status) { + throw exception::wfr_exception((boost::format("Illegal state change in workflow with id %1%.") % workflowID).str()); + } + WorkflowStatus oldStatus = this->status; + this->status = status; + switch (status) { + case WorkflowStatus::Created: + createTime = std::chrono::system_clock::now(); + break; + case WorkflowStatus::Running: + startTime = std::chrono::system_clock::now(); + break; + case WorkflowStatus::Finished: + case WorkflowStatus::Error: + endTime = std::chrono::system_clock::now(); + break; + default: + break; + } + wfr::eventsystem::WorkflowStatusEvent::fireEvent(*this, oldStatus, status); + } +} + +Activity* Workflow::getActivityByID(wfr_id_t id) const noexcept { + for (auto i : activities) { + if (i->activityID == id) return i; + } + return nullptr; +} + + +Activity* Workflow::getActivityByTemplateID(wfr_id_t id) const noexcept { + for (auto i : activities) { + if (i->baseTemplate.templateID == id) return i; + } + return nullptr; +} + + +void Workflow::setErrorState(std::exception_ptr cause) { + errorCause = cause; + setWorkflowStatus(WorkflowStatus::Error); +} + + +WorkflowStatus Workflow::executeSync( lwd::_wfr_lwd* input, lwd::_wfr_lwd* output ) { + scheduling::AbstractScheduler* scheduler = scheduling::SchedulerManager::getInstance().getDefaultScheduler(); + { // We want to have the enactment engine in its own scope so that it does not exist anymore when we delete the scheduler. + enactment::EnactmentEngine engine(*this, *scheduler); + setWorkflowStatus(WorkflowStatus::Running); + engine.workflowExecutionLoop(input, output); + } + cummulativePredictionTime = scheduler->getCummulativePredictionTime(); + delete scheduler; + return status; +} + + +#ifdef WFR_ENABLE_STATISTICS + + void Workflow::printStatistics(std::ostream& sout) { + sout << "WFR-Statistics: Created Instances: " << (createdCompositeInstanceCount+createdAtomicInstanceCount) << std::endl; + sout << "WFR-Statistics: Finished Instances: " << (finishedCompositeInstanceCount+finishedAtomicInstanceCount) << std::endl; + sout << "WFR-Statistics: Error Instances: " << (errorCompositeInstanceCount+errorAtomicInstanceCount) << std::endl; + + sout << "WFR-Statistics: Created Composite Instances: " << createdCompositeInstanceCount << std::endl; + sout << "WFR-Statistics: Finished Composite Instances: " << finishedCompositeInstanceCount << std::endl; + sout << "WFR-Statistics: Error Composite Instances: " << errorCompositeInstanceCount << std::endl; + + sout << "WFR-Statistics: Created Atomic Instances: " << createdAtomicInstanceCount << std::endl; + sout << "WFR-Statistics: Finished Atomic Instances: " << finishedAtomicInstanceCount << std::endl; + sout << "WFR-Statistics: Error Atomic Instances: " << errorAtomicInstanceCount << std::endl; + + sout << "WFR-Statistics: WEP Node Count: " << wepNodeCount << std::endl; + sout << "WFR-Statistics: WEP Visitation Count: " << wepVisitationCount << std::endl; + sout << "WFR-Statistics: WEP Update Count: " << wepUpdateCount << std::endl; + sout << "WFR-Statistics: WEP Update Notify Count: " << wepUpdateNotifyCount << std::endl; + + sout << "WFR-Statistics: Cumulative Atomic ReadyWait Duration: " + << ((double)std::chrono::duration_cast(cumulativeAtomicReadyWaitingDuration).count())/1000.0 << " sec" << std::endl; + sout << "WFR-Statistics: Cumulative Atomic Running Duration: " + << ((double)std::chrono::duration_cast(cumulativeAtomicRunningDuration).count())/1000.0 << " sec" << std::endl; + sout << "WFR-Statistics: Cumulative Prediction Time: " << cummulativePredictionTime << " sec" << std::endl; + + sout << "WFR-Statistics: Enactment Time: " + << ((double)std::chrono::duration_cast(enactmentTime).count())/1000.0 << " sec" << std::endl; + sout << "WFR-Statistics: Workflow Duration: " + << ((double)std::chrono::duration_cast(getWorkflowDuration()).count())/1000.0 << " sec" << std::endl; + sout << "WFR-Statistics: Makespan: " + << ((double)std::chrono::duration_cast(getMakespan()).count())/1000.0 << " sec" << std::endl; + } + +#endif + +} /* namespace wfs */ +} /* namespace wfr */ + + + diff --git a/src/common/wfs/WorkflowTemplate.cpp b/src/common/wfs/WorkflowTemplate.cpp new file mode 100755 index 0000000..dea90bf --- /dev/null +++ b/src/common/wfs/WorkflowTemplate.cpp @@ -0,0 +1,72 @@ + +#include +#include +#include +#include +#include + +namespace wfr { +namespace wfs { + + +WorkflowTemplate::WorkflowTemplate( const std::string& name, + wfr_id_t topLevelActivityID, + std::initializer_list activities) + : activities(activities), workflowName(name), topLevelActivityID(topLevelActivityID) { + if (activities.size() == 0) { + throw exception::wfr_fatal_error((boost::format("Workflow \"%1%\" has no activities.") % workflowName).str()); + } + for (auto i : activities) { + i->initActivityTemplate(*this); + } + toplevelActivity = getActivityByID(topLevelActivityID); + if (!toplevelActivity) { + throw exception::wfr_fatal_error((boost::format("Workflow \"%1%\" has invalid top-level activity id %2%.") % workflowName % topLevelActivityID).str()); + } + checkStructure(); +} + + +WorkflowTemplate::~WorkflowTemplate() noexcept { + for (auto i : activities) { + if (i) delete i; + } + activities.clear(); +} + + +ActivityTemplate* WorkflowTemplate::getActivityByID(wfr_id_t id) const noexcept { + ActivityTemplate* retval = nullptr; + for (auto i : activities) { + if (i->templateID == id) { + retval = i; + break; + } + } + return retval; +} + + +void WorkflowTemplate::checkStructure() { + for (auto i : activities) { + i->checkStructure(); + } +} + + +std::shared_ptr WorkflowTemplate::execute(lwd::_wfr_lwd* input, lwd::_wfr_lwd* output) { + std::shared_ptr wf = std::shared_ptr(new Workflow(*this)); + WorkflowRuntime::addWorkflowInstance(wf); + try { + wf->executeSync(input, output); + } catch (std::exception& e) { + std::cerr << "Error while executing workflow: Caught exception: " << e.what() << std::endl; + } catch (...) { + std::cerr << "Error while executing workflow: Caught unknown exception." << std::endl; + } + return wf; +} + + +} /* namespace wfs */ +} /* namespace wfr */ diff --git a/src/common/wfs/cmake.inc b/src/common/wfs/cmake.inc new file mode 100755 index 0000000..ef73387 --- /dev/null +++ b/src/common/wfs/cmake.inc @@ -0,0 +1,18 @@ + +set(wfr_cpp_files "${wfr_cpp_files}" + src/common/wfs/WorkflowTemplate.cpp + src/common/wfs/Workflow.cpp + src/common/wfs/ActivityTemplate.cpp + src/common/wfs/Activity.cpp + src/common/wfs/ActivityInstance.cpp + src/common/wfs/AtomicActivityImplementation.cpp + src/common/wfs/AtomicActivityType.cpp + src/common/wfs/instances/AssignActivityInstance.cpp + src/common/wfs/instances/AtomicActivityInstance.cpp + src/common/wfs/instances/CompositeActivityInstance.cpp + src/common/wfs/instances/ConditionalActivityInstance.cpp + src/common/wfs/instances/ContainerActivityInstance.cpp + src/common/wfs/instances/LoopActivityInstance.cpp + src/common/wfs/instances/ForLoopActivityInstance.cpp + src/common/wfs/instances/WhileLoopActivityInstance.cpp +) diff --git a/src/common/wfs/instances/AssignActivityInstance.cpp b/src/common/wfs/instances/AssignActivityInstance.cpp new file mode 100755 index 0000000..a749339 --- /dev/null +++ b/src/common/wfs/instances/AssignActivityInstance.cpp @@ -0,0 +1,55 @@ + +#include +#include +#include +#include +#include + + +namespace wfr { +namespace wfs { + + +bool AssignActivityInstance::executePreExecutionHooks(bool earlyEvaluation) { + bool retval = false; + if (getInstanceStatus() == ActivityInstanceStatus::Initialized) { + setInstanceStatus(ActivityInstanceStatus::WaitingForData); + } + + auto& templ = baseActivity.baseTemplate.as(); + if (templ.inputFuncHook != nullptr) { + retval = templ.inputFuncHook(*this); + } else { + allInputsAvailable = true; + setInstanceStatus(ActivityInstanceStatus::ReadyForExecution); + } + return retval; +} + +bool AssignActivityInstance::executeExecutionHook(bool earlyEvaluation) { + bool retval = false; + setInstanceStatus(ActivityInstanceStatus::Running); + auto& templ = baseActivity.baseTemplate.as(); + if (templ.execFuncHook != nullptr) { + retval = templ.execFuncHook(*this); + } + setInstanceStatus(ActivityInstanceStatus::Finished); + return retval; +} + + +void AssignActivityInstance::notifyParent() noexcept { + if (parentActivity != nullptr) { // propagate to parent + parentActivity->as().notifyChildHasFinished(*this); + } else { // if there is no parent then it's the toplevel activity + //baseActivity.workflow.setWorkflowStatus(WorkflowStatus::Finished); + baseActivity.workflow.setFinishFlag(true); + } +} + +} /* namespace wfs */ +} /* namespace wfr */ + + + + diff --git a/src/common/wfs/instances/AtomicActivityInstance.cpp b/src/common/wfs/instances/AtomicActivityInstance.cpp new file mode 100755 index 0000000..48918c9 --- /dev/null +++ b/src/common/wfs/instances/AtomicActivityInstance.cpp @@ -0,0 +1,30 @@ + +#include +#include +#include + + +namespace wfr { +namespace wfs { + +bool AtomicActivityInstance::executePreExecutionHooks(bool earlyEvaluation) { + bool retval = false; + if (getInstanceStatus() == ActivityInstanceStatus::Initialized) { + setInstanceStatus(ActivityInstanceStatus::WaitingForData); + } + auto& templ = baseActivity.baseTemplate.as(); + if (templ.inputFuncHook != nullptr) { + retval = templ.inputFuncHook(*this); + } else { + allInputsAvailable = true; + setInstanceStatus(ActivityInstanceStatus::ReadyForExecution); + } + return retval; +} + +} /* namespace wfs */ +} /* namespace wfr */ + + + + diff --git a/src/common/wfs/instances/CompositeActivityInstance.cpp b/src/common/wfs/instances/CompositeActivityInstance.cpp new file mode 100755 index 0000000..40949e7 --- /dev/null +++ b/src/common/wfs/instances/CompositeActivityInstance.cpp @@ -0,0 +1,62 @@ + +#include +#include +#include + + +namespace wfr { +namespace wfs { + +ActivityInstance* CompositeActivityInstance::getChild(wfr_id_t instanceID) const noexcept { + auto i = childrenByInstanceID.find(instanceID); + if (i != childrenByInstanceID.end()) { + return i->second; + } else { + return nullptr; + } + /*for (auto i : children) { + if (i->instanceID == instanceID) { + return i; + } + } + return nullptr;*/ +} + +ActivityInstance* CompositeActivityInstance::getChild(wfr_id_t activityID, wfr_id_t iterationID) const noexcept { + /*auto i = childrenByActivityID.find(activityID); + if (i != childrenByActivityID.end()) { + for (auto a : i->second) { + if (a->iterationID == iterationID) { + return a; + } + } + } + return nullptr;*/ + + for (auto i : children) { + if (i->baseActivity.activityID == activityID && i->iterationID == iterationID) { + return i; + } + } + return nullptr; +} + +void CompositeActivityInstance::notifyChildHasFinished(ActivityInstance& ai) noexcept { + finishedChildrenCount++; + //std::cout << "notifyChildHasFinished(" << finishedChildrenCount << ", " << baseActivity.getChildrenCount() << ")" << std::endl; + if (finishedChildrenCount >= baseActivity.getChildrenCount()) { // see if all children are finished + //std::cout << "notifyChildHasFinished: parent now finished" << std::endl; + setInstanceStatus(ActivityInstanceStatus::Finished); + if (parentActivity != nullptr) { // propagate to parent + parentActivity->as().notifyChildHasFinished(*this); + } else { // if there is no parent then it's the toplevel activity + //baseActivity.workflow.setWorkflowStatus(WorkflowStatus::Finished); + baseActivity.workflow.setFinishFlag(true); + } + } +} + +} /* namespace wfs */ +} /* namespace wfr */ + + diff --git a/src/common/wfs/instances/ConditionalActivityInstance.cpp b/src/common/wfs/instances/ConditionalActivityInstance.cpp new file mode 100755 index 0000000..5c359f5 --- /dev/null +++ b/src/common/wfs/instances/ConditionalActivityInstance.cpp @@ -0,0 +1,46 @@ + +#include +#include +#include + + +namespace wfr { +namespace wfs { + + +bool ConditionalActivityInstance::executePreExecutionHooks(bool earlyEvaluation) { + bool retval = false; + if (getInstanceStatus() == ActivityInstanceStatus::Initialized) { + setInstanceStatus(ActivityInstanceStatus::WaitingForData); + } + auto& templ = baseActivity.baseTemplate.as(); + if (templ.inputFuncHook != nullptr) { + retval = templ.inputFuncHook(*this); + } else { + allInputsAvailable = true; + } + if (templ.branchFuncHook != nullptr) { + retval = templ.branchFuncHook(*this) || retval; + } else { + setErrorState(std::make_exception_ptr(wfr::exception::wfr_fatal_error("BranchFuncHook is null."))); + } + return retval; +} + + +bool ConditionalActivityInstance::executePostExecutionHooks(bool earlyEvaluation) { + bool retval = false; + if (status >= ActivityInstanceStatus::ReadyForExecution) { + auto& templ = baseActivity.baseTemplate.as(); + if (templ.outputFuncHook != nullptr) { + retval = templ.outputFuncHook(*this); + } else { + setErrorState(std::make_exception_ptr(wfr::exception::wfr_fatal_error("OutputFuncHook is null."))); + } + } + return retval; +} + + +} /* namespace wfs */ +} /* namespace wfr */ diff --git a/src/common/wfs/instances/ContainerActivityInstance.cpp b/src/common/wfs/instances/ContainerActivityInstance.cpp new file mode 100755 index 0000000..3fe0aa7 --- /dev/null +++ b/src/common/wfs/instances/ContainerActivityInstance.cpp @@ -0,0 +1,42 @@ + +#include +#include +#include + + +namespace wfr { +namespace wfs { + + +bool ContainerActivityInstance::executePreExecutionHooks(bool earlyEvaluation) { + bool retval = false; + if (getInstanceStatus() == ActivityInstanceStatus::Initialized) { + setInstanceStatus(ActivityInstanceStatus::WaitingForData); + } + auto& templ = baseActivity.baseTemplate.as(); + if (templ.inputFuncHook != nullptr) { + retval = templ.inputFuncHook(*this); + } else { + allInputsAvailable = true; + setInstanceStatus(ActivityInstanceStatus::ReadyForExecution); + } + return retval; +} + + +bool ContainerActivityInstance::executePostExecutionHooks(bool earlyEvaluation) { + bool retval = false; + if (status >= ActivityInstanceStatus::ReadyForExecution) { + auto& templ = baseActivity.baseTemplate.as(); + if (templ.outputFuncHook != nullptr) { + retval = templ.outputFuncHook(*this); + } else { + setErrorState(std::make_exception_ptr(wfr::exception::wfr_fatal_error("OutputFuncHook is null."))); + } + } + return retval; +} + + +} /* namespace wfs */ +} /* namespace wfr */ diff --git a/src/common/wfs/instances/ForLoopActivityInstance.cpp b/src/common/wfs/instances/ForLoopActivityInstance.cpp new file mode 100755 index 0000000..4dff4a5 --- /dev/null +++ b/src/common/wfs/instances/ForLoopActivityInstance.cpp @@ -0,0 +1,66 @@ + +#include +#include +#include + + +namespace wfr { +namespace wfs { + + +void ForLoopActivityInstance::notifyChildHasFinished(ActivityInstance& ai) noexcept { + LoopActivityInstance::notifyChildHasFinished(ai); + auto& templ = baseActivity.baseTemplate.as(); + if (templ.iterationFuncHook != nullptr) { + templ.iterationFuncHook(*this); + } +} + +bool ForLoopActivityInstance::executePreExecutionHooks(bool earlyEvaluation) { + bool retval = false; + if (getInstanceStatus() == ActivityInstanceStatus::Initialized) { + setInstanceStatus(ActivityInstanceStatus::WaitingForData); + } + auto& templ = baseActivity.baseTemplate.as(); + if (templ.inputFuncHook != nullptr) { + retval = templ.inputFuncHook(*this); + } else { + allInputsAvailable = true; + } + if (templ.counterFuncHook != nullptr) { + retval = templ.counterFuncHook(*this) || retval; + } else { + setErrorState(std::make_exception_ptr(wfr::exception::wfr_fatal_error("IteratorFuncHook is null."))); + } + return retval; +} + +bool ForLoopActivityInstance::executePostExecutionHooks(bool earlyEvaluation) { + bool retval = false; + if (status >= ActivityInstanceStatus::ReadyForExecution) { + if (earlyEvaluation || (finalisedFlag && finishedChildrenCount >= children.size())) { + auto& templ = baseActivity.baseTemplate.as(); + if (templ.outputFuncHook != nullptr) { + retval = templ.outputFuncHook(*this); + } else { + setErrorState(std::make_exception_ptr(wfr::exception::wfr_fatal_error("OutputFuncHook is null."))); + } + } + } + return retval; +} + +void ForLoopActivityInstance::setLoopCounter(wfr_size_t start, wfr_size_t step, wfr_size_t max) { + this->loopCounterStart = start; + this->loopCounterStep = step; + this->loopCounterMax = max; + wfr_size_t iters = ((max + 1) - start) / step; + if (start + iters*step < max) { + iters++; + } + setIterationCount(iters); + loopCounterValueSet = true; +} + +} /* namespace wfs */ +} /* namespace wfr */ diff --git a/src/common/wfs/instances/LoopActivityInstance.cpp b/src/common/wfs/instances/LoopActivityInstance.cpp new file mode 100755 index 0000000..c03daca --- /dev/null +++ b/src/common/wfs/instances/LoopActivityInstance.cpp @@ -0,0 +1,57 @@ + +#include +#include +#include + + +namespace wfr { +namespace wfs { + + +void LoopActivityInstance::setIterationCount(wfr_size_t count) noexcept { + iterationCount = count; + finishedChildrenPerIteration.resize(count, 0); + finishedIterations.resize(count, false); + runningIterations.resize(count, false); +} + +void LoopActivityInstance::notifyChildHasFinished(ActivityInstance& ai) noexcept { + finishedChildrenCount++; + auto iid = ai.iterationID; + finishedChildrenPerIteration[iid]++; + if (finishedChildrenPerIteration[iid] >= baseActivity.getChildrenCount()) { + finishedIterations[iid] = true; + } + if (finishedChildrenCount >= baseActivity.getChildrenCount() * iterationCount) { // see if all children are finished + setInstanceStatus(ActivityInstanceStatus::Finished); + if (parentActivity != nullptr) { // propagate to parent + parentActivity->as().notifyChildHasFinished(*this); + } else { // if there is no parent then it's the toplevel activity + //baseActivity.workflow.setWorkflowStatus(WorkflowStatus::Finished); + baseActivity.workflow.setFinishFlag(true); + } + } +} + + +ActivityInstanceStatus LoopActivityInstance::getIterationInstanceStatus(wfr_id_t iterationID) const noexcept { + if (iterationID >= getIterationCount()) { + return wfs::ActivityInstanceStatus::Unknown; + } + if (status == wfs::ActivityInstanceStatus::ReadyForExecution) { + if (hasIterationFinished(iterationID)) { + return wfs::ActivityInstanceStatus::Finished; + } else if (isIterationRunning(iterationID)) { + return wfs::ActivityInstanceStatus::Running; + } else { + if (!isParallel && iterationID > 0 && !hasIterationFinished(iterationID-1)) { + return wfs::ActivityInstanceStatus::WaitingForDependency; + } + } + } + return status; +} + + +} /* namespace wfs */ +} /* namespace wfr */ diff --git a/src/common/wfs/instances/WhileLoopActivityInstance.cpp b/src/common/wfs/instances/WhileLoopActivityInstance.cpp new file mode 100755 index 0000000..4ff6f15 --- /dev/null +++ b/src/common/wfs/instances/WhileLoopActivityInstance.cpp @@ -0,0 +1,79 @@ + +#include +#include +#include +#include + + +namespace wfr { +namespace wfs { + +bool WhileLoopActivityInstance::executePreExecutionHooks(bool earlyEvaluation) { + bool retval = false; + if (getInstanceStatus() == ActivityInstanceStatus::Initialized) { + setInstanceStatus(ActivityInstanceStatus::WaitingForData); + } + auto& templ = baseActivity.baseTemplate.as(); + if (templ.inputFuncHook != nullptr) { + retval = templ.inputFuncHook(*this); + } else { + retval = true; + allInputsAvailable = true; + } + if (templ.conditionFuncHook != nullptr) { + if (iterationCount <= 0 || finishedIterations[iterationCount-1]) { + retval = templ.conditionFuncHook(*this) || retval; + } + } else { + setErrorState(std::make_exception_ptr(wfr::exception::wfr_fatal_error("ConditionFuncHook is null."))); + } + return retval; +} + +bool WhileLoopActivityInstance::executePostExecutionHooks(bool earlyEvaluation) { + bool retval = false; + if (status >= ActivityInstanceStatus::ReadyForExecution) { + if (earlyEvaluation || (finalisedFlag && finishedChildrenCount >= children.size())) { + auto& templ = baseActivity.baseTemplate.as(); + if (templ.outputFuncHook != nullptr) { + retval = templ.outputFuncHook(*this); + } else { + setErrorState(std::make_exception_ptr(wfr::exception::wfr_fatal_error("OutputFuncHook is null."))); + } + } + } + return retval; +} + +void WhileLoopActivityInstance::notifyChildHasFinished(ActivityInstance& ai) noexcept { + auto& templ = baseActivity.baseTemplate.as(); + finishedChildrenCount++; + auto iid = ai.iterationID; + finishedChildrenPerIteration[iid]++; + if (finishedChildrenPerIteration[iid] >= baseActivity.getChildrenCount()) { + finishedIterations[iid] = true; + } + if (templ.iterationFuncHook != nullptr && finishedIterations[iid]) { + templ.iterationFuncHook(*this); + } + if (!finalisedFlag && finishedIterations[iid]) { + if (templ.conditionFuncHook != nullptr) { + templ.conditionFuncHook(*this); + } else { + setErrorState(std::make_exception_ptr(wfr::exception::wfr_fatal_error("ConditionFuncHook is null."))); + } + } + if (finishedChildrenCount >= baseActivity.getChildrenCount() * iterationCount) { // see if all children are finished + setInstanceStatus(ActivityInstanceStatus::Finished); + if (parentActivity != nullptr) { // propagate to parent + parentActivity->as().notifyChildHasFinished(*this); + } else { // if there is no parent then it's the toplevel activity + //baseActivity.workflow.setWorkflowStatus(WorkflowStatus::Finished); + baseActivity.workflow.setFinishFlag(true); + } + } +} + + +} /* namespace wfs */ +} /* namespace wfr */ diff --git a/src/enactment/EnactmentEngine.cpp b/src/enactment/EnactmentEngine.cpp new file mode 100755 index 0000000..37855e1 --- /dev/null +++ b/src/enactment/EnactmentEngine.cpp @@ -0,0 +1,173 @@ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +namespace wfr { +namespace enactment { + + +void EnactmentEngine::init(int argc, char** argv) { + boost::program_options::options_description opts("EnactmentEngine Options"); + opts.add_options() + ("help", "Print help message.") + ("disable-wepdotwriter", "Disable WEP to .dot writer.") + ("early-evaluation", "Enables early evaluation.") + ("late-evaluation", "Enables late evaluation [Default]."); + boost::program_options::variables_map vm; + auto parsed = boost::program_options::command_line_parser(argc, argv).options(opts).allow_unregistered().run(); + boost::program_options::store(parsed, vm); + boost::program_options::notify(vm); + if (vm.count("help")) { + boost::program_options::options_description show_opts("EnactmentEngine Options"); + show_opts.add_options() + ("disable-wepdotwriter", "Disable WEP to .dot writer.") + ("early-evaluation", "Enables early evaluation [Default].") + ("late-evaluation", "Enables late evaluation."); + std::cerr << show_opts << std::endl; + return; + } + + if (vm.count("disable-wepdotwriter")) { + WorkflowRuntime::setGlobalConfig("dotWriterEnabled", false); + std::cerr << "WEP-to-.dot writer is disabled." << std::endl; + } else { + WorkflowRuntime::setGlobalConfig("dotWriterEnabled", true); + std::cerr << "WEP-to-.dot writer is enabled." << std::endl; + } + + if (vm.count("early-evaluation") && vm.count("late-evaluation")) { + std::cerr << "Cannot have early and late evaluation enabled at the same time." << std::endl; + std::abort(); + } else if (vm.count("late-evaluation")) { + WorkflowRuntime::setGlobalConfig("earlyEvaluationEnabled", false); + std::cerr << "Using late evaluation mode." << std::endl; + } else { + WorkflowRuntime::setGlobalConfig("earlyEvaluationEnabled", true); + std::cerr << "Using early evaluation mode." << std::endl; + } +} + +void EnactmentEngine::finish() { + // NOP +} + + +EnactmentEngine::EnactmentEngine(wfs::Workflow& workflow, scheduling::AbstractScheduler& scheduler) noexcept + : enableWepDotFileWriter(WorkflowRuntime::getGlobalConfig("dotWriterEnabled")), + enableEarlyEvaluation(WorkflowRuntime::getGlobalConfig("earlyEvaluationEnabled")), + workflow(workflow), scheduler(scheduler) {} + + +void EnactmentEngine::workflowExecutionLoop(lwd::_wfr_lwd* input, lwd::_wfr_lwd* output) { + + // Give thread a higher priority + pid_t myPID = getpid(); + int oldPriority = getpriority(PRIO_PROCESS, myPID); + setpriority(PRIO_PROCESS, myPID, -20); + + auto eventBusy = eventsystem::ComponentStatusEvent::fireEvent(wfs::ComponentType::Enactment, + wfs::ComponentStatus::Unknown, wfs::ComponentStatus::Busy, &workflow); + + WepBuilder wepBuilder(enableEarlyEvaluation); + wep = wepBuilder.createWEP(workflow, input, output); + + #ifdef WFR_ENABLE_WEPDOTWRITER + std::shared_ptr dotWriter; + if (enableWepDotFileWriter) { + dotWriter = std::make_shared(wep); + dotWriter->printToFile(); + } + #endif + + scheduler.registerWEP(*wep, *this); + auto ren = wepBuilder.getReadyToExecuteAtomicNodes(); + scheduler.notifyWEPUpdate(*wep, std::set(ren.begin(), ren.end())); + + while (!breakExecutionLoop) { + bool dirtyFlag = false; + std::set readyToExecuteAtomicNodes; + { + std::unique_lock lk(updateMutex); + bool eventWasSend = false; + while (updateQueue.empty()) { + if (!eventWasSend) { + auto event = eventsystem::ComponentStatusEvent::fireEvent(wfs::ComponentType::Enactment, + wfs::ComponentStatus::Busy, wfs::ComponentStatus::Idle, &workflow); + eventWasSend = true; + workflow.addToEnactmentTime(event->timestamp - eventBusy->timestamp); + eventBusy.reset(); + } + updateCondition.wait(lk); + } + if (eventWasSend) { + eventBusy = eventsystem::ComponentStatusEvent::fireEvent(wfs::ComponentType::Enactment, wfs::ComponentStatus::Idle, + wfs::ComponentStatus::Busy, &workflow); + } + + //std::cout << "Starting Execution Plan Update: " << updateQueue.size() << " Nodes in Queue." << std::endl; + workflow.addToWepUpdateCount(); + + dirtyFlag = wepBuilder.updateExecutionPlan(updateQueue); + auto ren = wepBuilder.getReadyToExecuteAtomicNodes(); + readyToExecuteAtomicNodes.insert(ren.begin(), ren.end()); + } + // update wep here + if (dirtyFlag) { + #ifdef WFR_ENABLE_WEPDOTWRITER + if (enableWepDotFileWriter) { + dotWriter->printToFile(); + } + #endif + if (wep->workflow.getWorkflowStatus() == wfr::wfs::WorkflowStatus::Error + || wep->workflow.getWorkflowStatus() == wfr::wfs::WorkflowStatus::Finished) { + breakExecutionLoop = true; + } else if (wep->workflow.getFinishFlag()) { + breakExecutionLoop = true; + wep->workflow.setWorkflowStatus(wfs::WorkflowStatus::Finished); + } else { + scheduler.notifyWEPUpdate(*wep, readyToExecuteAtomicNodes); + workflow.addToWepUpdateNotifyCount(); + } + } + } + auto event = eventsystem::ComponentStatusEvent::fireEvent(wfs::ComponentType::Enactment, + wfs::ComponentStatus::Busy, wfs::ComponentStatus::Finished, &workflow); + workflow.addToEnactmentTime(event->timestamp - eventBusy->timestamp); + eventBusy.reset(); + scheduler.unregisterWEP(*wep.get()); + + // Reset thread priority + setpriority(PRIO_PROCESS, myPID, oldPriority); +} + + +void wfr::enactment::EnactmentEngine::notifyActivityInstanceStateUpdate(wfs::ActivityInstance& ai, scheduling::AbstractScheduler& scheduler) { + std::lock_guard lk(updateMutex); + //std::cout << "notifyActivityInstanceStateUpdate: " << ai.baseActivity.baseTemplate.activityName << " - " << ai.baseActivity.activityID << "-" << ai.instanceID << std::endl; + updateQueue.push(&ai); + updateCondition.notify_one(); +} + +} /* namespace wep */ +} /* namespace wfr */ + + + diff --git a/src/enactment/EnactmentEngine.cpp.orig b/src/enactment/EnactmentEngine.cpp.orig new file mode 100755 index 0000000..e69de29 diff --git a/src/enactment/WepBuilder.cpp b/src/enactment/WepBuilder.cpp new file mode 100755 index 0000000..cb0aab9 --- /dev/null +++ b/src/enactment/WepBuilder.cpp @@ -0,0 +1,595 @@ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +namespace wfr { +namespace enactment { + +WepBuilder::~WepBuilder() { + if (wep) { + wep->workflow.setWepNodeCount(wepNodeCount); + wep->workflow.addToWepVisitationCount(wepVisitationCount); + } +} + +std::shared_ptr WepBuilder::createWEP(wfr::wfs::Workflow& wf, lwd::_wfr_lwd* input, lwd::_wfr_lwd* output) { + readyToExecuteAtomicNodes.clear(); + readyToExecuteAssignNodes.clear(); + + // Create top-level Activity Instance + auto ta = wf.getTopLevelActivity(); + auto ti = ta->createNewInstance(0); + + // Set Workflow input/output buffer + ti->setInputData(input, false); + ti->setOutputData(output, false); + + // Execute pre-execution hooks + ti->executePreExecutionHooks(earlyEvaluationMode); + + // Create WEPnode + auto wepNode = createWEPnode(*ta, *ti, wepNodeMap); + + // Check activity status (top-level threads needs to be ReadyForExecution, everything else is an error) + if (ti->getInstanceStatus() == wfs::ActivityInstanceStatus::ReadyForExecution) { + + // Composite activity branch + if (ta->isCompositeActivity()) { + + // Fetch child activities + std::vector children; + if (ti->isConditional()) { + children = ta->getChildren(ti->as().getExecutionBranchID()); + } else { + children = ta->getChildren(); + } + + // Push parent on stacks + parentStack.push(ti); + parentWepStack.push(wepNode); + + // Loop Branch + if (ti->isLoop()) { + auto loop = ti->as(); + auto maxIterCount = loop.getIterationCount(); + wfr_id_t i; + for ( i = loop.getHandledIterationCount(); i < maxIterCount; i++ ) { + // Create and push iteration wep-node + auto iterationWepNode = createIterationWepNodes(*ti, wepNode, i); + iterationIdStack.push(i); + parentWepStack.push(iterationWepNode); + activityInstanceMap_t instanceMap; + // Visit children + for (auto& child : children) { + visitActivity(*child, instanceMap, wepNodeMap); + } + iterationIdStack.pop(); + parentWepStack.pop(); + } + loop.setHandledIterationCount(i); + + // Non-Loop Branch + } else { + iterationIdStack.push(0); + activityInstanceMap_t instanceMap; + // Visit children + for (auto& child : children) { + visitActivity(*child, instanceMap, wepNodeMap); + } + iterationIdStack.pop(); + } + + // Pop parent from stack + parentStack.pop(); + parentWepStack.pop(); + + // Assign Activity branch + } else if (wepNode.first->nodeType == wep::WepNodeType::Assign) { + wepNode.first->as().activity.executeExecutionHook(earlyEvaluationMode); + readyToExecuteAssignNodes.push_back(&wepNode.first->as()); + + // Atomic Activity branch + } else { + readyToExecuteAtomicNodes.push_back(&wepNode.first->as()); + } + + } else if (ti->getInstanceStatus() == wfs::ActivityInstanceStatus::WaitingForData) { + if (wepNode.first->getSuccessors().empty()) { + wepNode.first->successors.push_back(wepNode.second); + wepNode.second->predecessors.push_back(wepNode.first); + } + + } else { + throw wfr::exception::wfr_fatal_error("toplevel node is not ready for execution"); + } + for (auto n : readyToExecuteAssignNodes) { + n->activity.as().notifyParent(); + } + readyToExecuteAssignNodes.clear(); + // Create and return execution plan + wep = std::make_shared(wf, wepNode.first, wepNode.second); + return wep; +} + + +WepBuilder::wepNodeMap_t::mapped_type WepBuilder::createIterationWepNodes(wfr::wfs::ActivityInstance& ai, wepNodeMap_t::mapped_type& parent, wfr_id_t iterationID) { + wep::IterationStartWepNode* isn = new wep::IterationStartWepNode(ai, iterationID); + wep::IterationEndWepNode* ien = new wep::IterationEndWepNode(ai, iterationID); + isn->endNode = ien; + ien->startNode = isn; + bool isParallel = true; + if (ai.isLoop()) { + isParallel = ai.as().isParallel; + } + if (isParallel) { + isn->predecessors.push_back(parent.first); + parent.first->successors.push_back(isn); + ien->successors.push_back(parent.second); + parent.second->predecessors.push_back(ien); + } else { + wfr_size_t pPredCount = parent.second->getPredecessors().size(); + if (pPredCount > 0) { + auto lastIter = parent.second->getPredecessors()[pPredCount-1]; + lastIter->successors.clear(); + lastIter->successors.push_back(isn); + isn->predecessors.push_back(lastIter); + parent.second->predecessors.clear(); + parent.second->predecessors.push_back(ien); + ien->successors.push_back(parent.second); + } else { + parent.first->successors.push_back(isn); + isn->predecessors.push_back(parent.first); + parent.second->predecessors.push_back(ien); + ien->successors.push_back(parent.second); + + } + } + wepNodeMap_t::mapped_type wepNodeMapEntry; + wepNodeMapEntry.first = isn; + wepNodeMapEntry.second= ien; + wepNodeCount++; + if (wepNodeMapEntry.first != wepNodeMapEntry.second) { + wepNodeCount++; + } + return wepNodeMapEntry; +} + + +WepBuilder::wepNodeMap_t::mapped_type WepBuilder::createWEPnode(wfs::Activity& a, wfs::ActivityInstance& ai, wepNodeMap_t& wepNodeMap) { + wepNodeMap_t::mapped_type wepNodeMapEntry; + if (a.isCompositeActivity()) { + wep::CompositeStartWepNode* cs = new wep::CompositeStartWepNode(ai); + wep::CompositeEndWepNode* ce = new wep::CompositeEndWepNode(ai); + cs->endNode = ce; + ce->startNode = cs; + wepNodeMapEntry.first = cs; + wepNodeMapEntry.second= ce; + } else if (a.activityType() == wfr::wfs::ActivityType::Atomic) { + wep::AtomicWepNode* a = new wep::AtomicWepNode(ai); + wepNodeMapEntry.first = a; + wepNodeMapEntry.second= a; + } else if (a.activityType() == wfr::wfs::ActivityType::Assign) { + wep::AssignWepNode* a = new wep::AssignWepNode(ai); + wepNodeMapEntry.first = a; + wepNodeMapEntry.second= a; + } else { + throw wfr::exception::wfr_fatal_error("This branch should never be executed."); + } + wepNodeCount++; + if (wepNodeMapEntry.first != wepNodeMapEntry.second) { + wepNodeCount++; + } + wepNodeMap.insert(wepNodeMap_t::value_type(&ai, wepNodeMapEntry)); + return wepNodeMapEntry; +} + + + +void WepBuilder::visitActivity(wfr::wfs::Activity& element, activityInstanceMap_t& instanceMap, wepNodeMap_t& wepNodeMap) { + + //wep->workflow.addToWepVisitationCount(); + wepVisitationCount++; + + // Create activity instance + auto ti = element.createNewInstance(iterationIdStack.top()); + auto parent = parentStack.top(); + ti->setParentActivity(parent); + + // Add to parents children + if (parent->isCompositeActivity()) { + parent->as().children.push_back(ti); + parent->as().childrenByInstanceID.insert({ti->instanceID, ti}); + + auto tmpi = parent->as().childrenByActivityID.find(ti->baseActivity.activityID); + if (tmpi != parent->as().childrenByActivityID.end()) { + tmpi->second.push_back(ti); + } else { + std::vector tmp; + tmp.push_back(ti); + parent->as().childrenByActivityID.insert({ti->baseActivity.activityID, tmp}); + } + } else { + throw wfr::exception::wfr_fatal_error("Cannot add a child to a non-composite activity"); + } + + // Save into instance-map + instanceMap[&element] = ti; + + // Set predecessors/successors + auto& preds = element.getPredecessors(); + auto predCount = element.getPredecessorCount(); + for (wfr_id_t i = 0; i < predCount; i++) { + auto pred = preds[i]; + auto predRef = instanceMap.find(pred); + if (predRef == instanceMap.end()) { + throw wfr::exception::wfr_fatal_error("Could not find predRef"); + } + ti->predecessors.push_back(predRef->second); + predRef->second->successors.push_back(ti); + } + ti->setInstanceStatus(wfs::ActivityInstanceStatus::Initialized); + // Execute pre-execution hooks + try { + ti->executePreExecutionHooks(earlyEvaluationMode); + } catch (...) { + ti->setErrorState(std::current_exception()); + } + // Create WEPnode + auto wepNode = createWEPnode(element, *ti, wepNodeMap); + wepNode.first->addToVisitationCount(); + // Set wep predecessors/successors + for (wfr_id_t i = 0; i < predCount; i++) { + auto pred = preds[i]; + auto predRef = instanceMap.find(pred); + if (predRef == instanceMap.end()) { + throw wfr::exception::wfr_fatal_error("Could not find predRef"); + } + auto predWepNode = wepNodeMap.find((*predRef).second); + if (predWepNode == wepNodeMap.end()) { + throw wfr::exception::wfr_fatal_error("Could not find predWepNode"); + } + wepNode.first->predecessors.push_back(predWepNode->second.second); + predWepNode->second.second->successors.push_back(wepNode.first); + } + // set parent as wep-predecessors if there are no other predecessors + if (ti->getParentActivity() != nullptr && element.getPredecessorCount() == 0) { + auto pWepNode = parentWepStack.top(); + wepNode.first->predecessors.push_back(pWepNode.first); + pWepNode.first->successors.push_back(wepNode.first); + } + // set parent as wep-successors if there are no other successors + if (ti->getParentActivity() != nullptr && element.getSuccessorCount() == 0) { + auto pWepNode = parentWepStack.top(); + wepNode.second->successors.push_back(pWepNode.second); + pWepNode.second->predecessors.push_back(wepNode.second); + } + // Check activity status + if (ti->getInstanceStatus() == wfr::wfs::ActivityInstanceStatus::ReadyForExecution + || ti->getInstanceStatus() == wfr::wfs::ActivityInstanceStatus::WaitingForDependency) { + if (element.isCompositeActivity()) { // Composite activity branch + auto& composite = ti->as(); + // Push parent on stacks + parentStack.push(ti); + parentWepStack.push(wepNode); + // Handle Children + handleChildren(composite, wepNode); + // Execute post-execution hooks (can we skip this?) + ti->executePostExecutionHooks(earlyEvaluationMode); + // Pop parent from stack + parentStack.pop(); + parentWepStack.pop(); + } else if (ti->activityType() == wfs::ActivityType::Assign) { + if (ti->getInstanceStatus() == wfr::wfs::ActivityInstanceStatus::ReadyForExecution) { + wepNode.first->as().activity.executeExecutionHook(earlyEvaluationMode); + readyToExecuteAssignNodes.push_back(&wepNode.first->as()); + } + } else { // Atomic Activity branch + if (ti->getInstanceStatus() == wfr::wfs::ActivityInstanceStatus::ReadyForExecution) { + readyToExecuteAtomicNodes.push_back(&wepNode.first->as()); + } + } + } else /*if (ti->getInstanceStatus() == wfr::wfs::ActivityInstanceStatus::WaitingForData)*/ { + if (wepNode.first->getSuccessors().empty() && wepNode.first != wepNode.second) { + wepNode.first->successors.push_back(wepNode.second); + wepNode.second->predecessors.push_back(wepNode.first); + } + } +} + + +void WepBuilder::handleChildren(wfs::CompositeActivityInstance& composite, wepNodeMap_t::mapped_type& parent, wepNodeMap_t::mapped_type* prevIter) { + // Fetch child activities + std::vector children; + if (composite.isConditional()) { + children = composite.baseActivity.getChildren(composite.as().getExecutionBranchID()); + } else { + children = composite.baseActivity.getChildren(); + } + if (composite.isLoop()) { // Loop Branch + auto& loop = composite.as(); + auto maxIterCount = loop.getIterationCount(); + wfr_id_t i; + for ( i = loop.getHandledIterationCount(); i < maxIterCount; i++ ) { + // Create and push iteration wep-node + auto iterationWepNode = createIterationWepNodes(composite, parent, i); + iterationIdStack.push(i); + parentWepStack.push(iterationWepNode); + activityInstanceMap_t instanceMap; + // Visit children + for (auto& child : children) { + visitActivity(*child, instanceMap, wepNodeMap); + } + iterationIdStack.pop(); + parentWepStack.pop(); + } + loop.setHandledIterationCount(i); + } else { // Non-Loop Branch + iterationIdStack.push(0); + activityInstanceMap_t instanceMap; + // Visit children + for (auto& child : children) { + visitActivity(*child, instanceMap, wepNodeMap); + } + iterationIdStack.pop(); + } + if (parent.first->successors.empty()) { + parent.first->successors.push_back(parent.second); + parent.second->predecessors.push_back(parent.first); + } +} + + +bool WepBuilder::updateExecutionPlan(std::queue& updateInstances) { + bool dirtyFlag = false; + bool isError = false; + readyToExecuteAtomicNodes.clear(); + readyToExecuteAssignNodes.clear(); + + auto visitFunc = [&](wep::AbstractWepNode* n) -> bool { + bool localDirtyFlag = false; + bool stateChange = false; + auto& node = n->as(); + + wepVisitationCount++; + n->addToVisitationCount(); + + /*std::cout << "Visiting node " + << node.activity.baseActivity.baseTemplate.activityName + << " (" << node.nodeID << ")" + << " [" << print::toString(node.activity.activityType()) << "]: " + << node.activity.baseActivity.baseTemplate.activityName << " - " << node.activity.baseActivity.activityID << "-" << node.activity.instanceID + << std::endl;*/ + + // This activity is currently running. Do nothing since this activity will be handled when it has finished + if (node.nodeType == wep::WepNodeType::Atomic && node.activity.as().ownedByExecutionLayer()) { + //std::cout << "Activity is currently running, abort" << std::endl; + return false; + } + + // Execute pre-execution hooks + if (!node.activity.areAllInputsAvailable() && node.activity.getInstanceStatus() < wfr::wfs::ActivityInstanceStatus::Finished) { + node.activity.executePreExecutionHooks(earlyEvaluationMode); + } + + //std::cout << "ActivityState: " << print::toString(node.activity.getInstanceStatus()) << " - " << print::toString(node.getLastKnownInstanceStatus()) << std::endl; + // Activity instance is dirty + if (node.getLastKnownInstanceStatus() != node.activity.getInstanceStatus() || node.activity.isDirtyState()) { + //std::cout << "State is dirty, old state: " << print::toString(node.getLastKnownInstanceStatus()) << std::endl; + // handle state-change + switch (node.nodeType) { + case wep::WepNodeType::Atomic: + //Check error condition + if (node.activity.getInstanceStatus() == wfs::ActivityInstanceStatus::Error) { + // Propagate Error to Parents + wfr::wfs::ActivityInstance* ai = node.activity.parentActivity; + while (ai != nullptr) { + ai->setErrorState(std::make_exception_ptr(wfr::exception::wfr_fatal_error("A child activity is in error state."))); + ai = ai->parentActivity; + } + wep->workflow.setErrorState(std::make_exception_ptr(wfr::exception::wfr_fatal_error("A child activity is in error state."))); + isError = true; + // Check finish condition + } else if (!isError && node.activity.getInstanceStatus() == wfs::ActivityInstanceStatus::Finished) { + // Propagate Finish state to Parents + wfr::wfs::ActivityInstance* ai = node.activity.parentActivity; + if (ai) { + //std::cout << "Propagate finish state to parent" << std::endl; + if (ai->isCompositeActivity()) { + wfr::wfs::CompositeActivityInstance& composite = ai->as(); + composite.notifyChildHasFinished(node.activity); + } else { + throw wfr::exception::wfr_fatal_error("Non-Composite activity cannot be a parent."); + } + } else { // if there is no parent then it's the toplevel activity + //node.activity.baseActivity.workflow.setWorkflowStatus(wfs::WorkflowStatus::Finished); + node.activity.baseActivity.workflow.setFinishFlag(true); + } + } else if (node.activity.getInstanceStatus() == wfs::ActivityInstanceStatus::ReadyForExecution) { + readyToExecuteAtomicNodes.push_back(&node.as()); + } + break; + case wep::WepNodeType::Assign: + if (node.activity.getInstanceStatus() == wfs::ActivityInstanceStatus::ReadyForExecution) { + readyToExecuteAssignNodes.push_back(&node.as()); + node.activity.as().executeExecutionHook(earlyEvaluationMode); + } + break; + case wep::WepNodeType::CompositeStart: + //Check if we need to unroll + if (node.getLastKnownInstanceStatus() == wfs::ActivityInstanceStatus::WaitingForData) { + activityInstanceMap_t instanceMap; + parentStack.push(&node.activity); + auto wnmi = wepNodeMap.find(&node.activity); + if (wnmi != wepNodeMap.end()) { + wnmi->second.first->getSuccessors().clear(); + wnmi->second.second->getPredecessors().clear(); + parentWepStack.push((*wnmi).second); + // Handle Children + handleChildren(node.activity.as(), wnmi->second); + parentWepStack.pop(); + } else { + throw wfr::exception::wfr_fatal_error("Could not find wepNodeMap entry."); + } + + parentStack.pop(); + } + break; + case wep::WepNodeType::IterationStart: + break; + case wep::WepNodeType::Hole: + break; + case wep::WepNodeType::CompositeEnd: + break; + case wep::WepNodeType::IterationEnd: + break; + default: + break; + } + // Further unroll while loop + if (!isError && node.activity.getInstanceStatus() == wfs::ActivityInstanceStatus::Finished) { + wfr::wfs::ActivityInstance* ai = node.activity.parentActivity; + if (ai != nullptr && ai->isCompositeActivity()) { + auto& composite = ai->as(); + if (composite.baseActivity.activityType() == wfs::ActivityType::WhileLoop) { + auto& loop = composite.as(); + if (loop.getHandledIterationCount() < loop.getIterationCount()) { + this->parentStack.push(&composite); + auto wnmi = wepNodeMap.find(&composite); + handleChildren(composite, wnmi->second); + this->parentStack.pop(); + } + } + } else if (ai != nullptr) { + throw wfr::exception::wfr_fatal_error("Non-Composite activity cannot be a parent."); + } + } + node.updateInstanceStatus(); + dirtyFlag = true; + localDirtyFlag = true; + stateChange = true; + node.activity.resetDirtyState(); + } else { + switch (node.nodeType) { + case wep::WepNodeType::Atomic: + break; + case wep::WepNodeType::CompositeStart: + case wep::WepNodeType::IterationStart: + case wep::WepNodeType::Hole: + case wep::WepNodeType::CompositeEnd: + case wep::WepNodeType::IterationEnd: + localDirtyFlag = true; + break; + default: + break; + } + } + + // Execute post-execution hooks + if (!node.activity.areAllOutputsAvailable()) { + try { + node.activity.executePostExecutionHooks(earlyEvaluationMode); + } catch (wfr::exception::wfr_exception& e) { + node.activity.setErrorState(std::current_exception()); + } + } + + if (earlyEvaluationMode) { + return localDirtyFlag; + } else if (localDirtyFlag) { + + // if node is composite: + // - if node is CompositeStart or IterationStart => true + // - statechange => true + + // if node is atomic: + // - if parent is finished => true + // - statechange => true + if (node.activity.isCompositeActivity()) { + if (node.nodeType == wep::WepNodeType::CompositeStart || node.nodeType == wep::WepNodeType::IterationStart) { + return true; + } else if (stateChange) { + return true; + } else { + if (node.activity.isLoop()) { + auto& loop = node.activity.as(); + if (!loop.isParallel && node.nodeType == wep::WepNodeType::IterationEnd) { + return true; + } + } + return false; + } + } else { + auto& parent = node.activity.parentActivity->as(); + if (stateChange) { + return true; + } else if (parent.getInstanceStatus() >= wfs::ActivityInstanceStatus::Finished) { + return true; + } else { + return false; + } + } + + } else { + return false; + } + }; + + wfr_size_t ec = updateInstances.size(); + for (wfr_size_t t = 0; t < ec; t++) { + auto updateInstance = updateInstances.front(); + updateInstances.pop(); + auto startNode = wepNodeMap.find(updateInstance)->second.first; + + //std::cout << "handleActivityUpdate: " << updateInstance->baseActivity.baseTemplate.activityName << " - " << updateInstance->baseActivity.activityID << "-" << updateInstance->instanceID << std::endl; + + + if (updateInstance->activityType() == wfs::ActivityType::Atomic) { + updateInstance->as().setOwnedByExecutionLayer(false); + } + + /*if (startNode->withActivityInstance) { + auto& inode = startNode->as(); + std::cout << "Updating from Instance " + << inode.activity.baseActivity.baseTemplate.activityName + << " (" << inode.activity.instanceID << ")" + << " [" << print::toString(inode.activity.baseActivity.activityType()) << "]" + << std::endl; + } else { + std::cout << "Updating from unknown WEP node" << std::endl; + }*/ + + wfr::utils::wep::wepBreadthFirstSearch(startNode, visitFunc); + } + for (auto n : readyToExecuteAssignNodes) { + n->activity.as().notifyParent(); + } + readyToExecuteAssignNodes.clear(); + if (dirtyFlag) { + wep->increaseVersion(); + } + return dirtyFlag; +} + +} /* namespace enactment */ +} /* namespace wfr */ + + diff --git a/src/enactment/cmake.inc b/src/enactment/cmake.inc new file mode 100755 index 0000000..44cd177 --- /dev/null +++ b/src/enactment/cmake.inc @@ -0,0 +1,5 @@ + +set(wfr_cpp_files "${wfr_cpp_files}" + src/enactment/EnactmentEngine.cpp + src/enactment/WepBuilder.cpp +) diff --git a/src/eventsystem/Event.cpp b/src/eventsystem/Event.cpp new file mode 100755 index 0000000..46c41a9 --- /dev/null +++ b/src/eventsystem/Event.cpp @@ -0,0 +1,202 @@ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +namespace wfr { +namespace eventsystem { + + +std::string GeneralLoggingEvent::toString() const noexcept { + std::stringstream ss; + ss << print::toString(timestamp); + ss << ": General Message: "; + ss << logMessage; + return ss.str(); +} + +std::shared_ptr GeneralLoggingEvent::fireEvent(const std::string& message, const wfr_timestamp_sc_t& timestamp, bool noLocking) noexcept { + auto event = std::make_shared(message, timestamp); + EventSystem::getInstance().fireEvent(event, noLocking); + return event; +} + + +std::string WorkflowStatusEvent::toString() const noexcept { + std::stringstream ss; + ss << print::toString(timestamp); + ss << ": WorkflowStatusEvent: \""; + ss << workflow.baseTemplate.workflowName; + ss << "\"["; + ss << workflow.workflowID; + ss << "] changed from '"; + ss << print::toString(oldStatus); + ss << "' to '"; + ss << print::toString(newStatus); + ss << "'."; + return ss.str(); +} + +std::shared_ptr WorkflowStatusEvent::fireEvent(wfr::wfs::Workflow& workflow, + wfr::wfs::WorkflowStatus& oldStatus, + wfr::wfs::WorkflowStatus& newStatus, + const wfr_timestamp_sc_t& timestamp, + bool noLocking ) noexcept { + auto event = std::make_shared(workflow, oldStatus, newStatus, timestamp); + EventSystem::getInstance().fireEvent(event, noLocking); + return event; +} + + + +std::string ActivityStatusEvent::toString() const noexcept { + std::stringstream ss; + ss << print::toString(timestamp); + ss << ": ActivityStatusEvent: \""; + ss << activity.baseTemplate.activityName; + ss << "\"["; + ss << activity.workflow.workflowID; + ss << "-"; + ss << activity.activityID; + ss << "] changed from '"; + ss << print::toString(oldStatus); + ss << "' to '"; + ss << print::toString(newStatus); + ss << "'."; + return ss.str(); +} + +std::shared_ptr ActivityStatusEvent::fireEvent(wfr::wfs::Activity& activity, + wfr::wfs::ActivityStatus oldStatus, + wfr::wfs::ActivityStatus newStatus, + const wfr_timestamp_sc_t& timestamp, + bool noLocking ) noexcept { + auto event = std::make_shared(activity, oldStatus, newStatus, timestamp); + EventSystem::getInstance().fireEvent(event, noLocking); + return event; +} + + + + +std::string ActivityInstanceStatusEvent::toString() const noexcept { + std::stringstream ss; + ss << print::toString(timestamp); + ss << ": ActivityInstanceStatusEvent: \""; + ss << activityInstance.baseActivity.baseTemplate.activityName; + ss << "\"["; + ss << activityInstance.baseActivity.workflow.workflowID; + ss << "-"; + ss << activityInstance.baseActivity.activityID; + ss << "-"; + ss << activityInstance.instanceID; + ss << "] changed from '"; + ss << print::toString(oldStatus); + ss << "' to '"; + ss << print::toString(newStatus); + ss << "'."; + if (newStatus == wfs::ActivityInstanceStatus::Error) { + // Really no better way than to rethrow? + try { + auto eptr = activityInstance.getErrorCause(); + if (eptr) { + std::rethrow_exception(eptr); + } + } catch(const std::exception& e) { + ss << " Error Cause: " << e.what(); + } + } + return ss.str(); +} + +std::shared_ptr ActivityInstanceStatusEvent::fireEvent(wfr::wfs::ActivityInstance& activity, + wfr::wfs::ActivityInstanceStatus oldStatus, + wfr::wfs::ActivityInstanceStatus newStatus, + const wfr_timestamp_sc_t& timestamp, + bool noLocking ) noexcept { + auto event = std::make_shared(activity, oldStatus, newStatus, timestamp); + EventSystem::getInstance().fireEvent(event, noLocking); + return event; +} + +std::string ComponentStatusEvent::toString() const noexcept { + std::stringstream ss; + ss << print::toString(timestamp); + ss << ": ComponentStatusEvent: "; + ss << print::toString(componentType); + ss << " changed from '"; + ss << print::toString(oldStatus); + ss << "' to '"; + ss << print::toString(newStatus); + ss << "'."; + return ss.str(); +} + +std::shared_ptr ComponentStatusEvent::fireEvent( wfs::ComponentType componentType, + wfs::ComponentStatus oldStatus, + wfs::ComponentStatus newStatus, + wfr::wfs::Workflow* wf, + const wfr_timestamp_sc_t& timestamp, + bool noLocking ) noexcept { + auto event = std::make_shared(componentType, oldStatus, newStatus, wf, timestamp); + EventSystem::getInstance().fireEvent(event, noLocking); + return event; +} + + + +std::string ComputingResourceStatusEvent::toString() const noexcept { + std::stringstream ss; + ss << print::toString(timestamp); + ss << ": DeviceInstanceStatusEvent: "; + ss << print::toString(deviceType); + ss << "["; + ss << deviceID; + ss << "] changed from '"; + ss << print::toString(oldStatus); + ss << "' to '"; + ss << print::toString(newStatus); + if (executedTask != nullptr) { + ss << "' - Task: "; + ss << executedTask->baseActivity.baseTemplate.activityName; + ss << " [InstID="; + ss << executedTask->instanceID; + ss << ", ImplID="; + ss << executedImpl->implementationID; + ss << ", slots="; + ss << deviceSlotCount; + ss << "]."; + } else { + ss << "'."; + } + return ss.str(); +} + +std::shared_ptr ComputingResourceStatusEvent::fireEvent( wfr::wfs::Workflow* wf, + wfr::wfs::ActivityImplementationType deviceType, + wfr_id_t deviceID, + wfr::wfs::ComputingResourceStatus oldStatus, + wfr::wfs::ComputingResourceStatus newStatus, + wfr::wfs::ActivityInstance* executedTask, + wfr::wfs::AtomicActivityImplementation* executedImpl, + wfr_size_t deviceSlotCount, + wfr_timestamp_sc_t timestamp, + bool noLocking ) noexcept { + auto event = std::make_shared(wf, deviceType, deviceID, oldStatus, newStatus, executedTask, executedImpl, deviceSlotCount, timestamp); + EventSystem::getInstance().fireEvent(event, noLocking); + return event; +} + +} /* namespace eventsystem */ +} /* namespace wfr */ + diff --git a/src/eventsystem/EventSystem.cpp b/src/eventsystem/EventSystem.cpp new file mode 100755 index 0000000..d40e6b7 --- /dev/null +++ b/src/eventsystem/EventSystem.cpp @@ -0,0 +1,203 @@ +/* + * EventSystem.cpp + * + * Created on: 17.02.2014 + * Author: matthias + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace wfr { +namespace eventsystem { + + +EventSystem EventSystem::singleton; + +#ifdef WFR_ENABLE_STDLOGGER + std::unique_ptr EventSystem::oStreamLogger; +#endif + +#ifdef WFR_ENABLE_PERFDATABASE + std::unique_ptr EventSystem::sqliteLogger; +#endif + + +void EventSystem::init(int argc, char** argv) { + std::string sqliteFile; + bool disableStdLogger = false; + bool disableSqlite = false; + + boost::program_options::options_description opts("EventSystem Options"); + opts.add_options() + ("help", "Print help message.") + ("disable-stdlogger", "Disable logging to standard out.") + ("disable-sqlite", "Disable logging to sqlite.") + ("sqlite-file", boost::program_options::value(), "Set sqlite database file."); + boost::program_options::variables_map vm; + auto parsed = boost::program_options::command_line_parser(argc, argv).options(opts).allow_unregistered().run(); + boost::program_options::store(parsed, vm); + boost::program_options::notify(vm); + if (vm.count("help")) { + boost::program_options::options_description show_opts("EventSystem Options"); + show_opts.add_options() + ("disable-stdlogger", "Disable logging to standard out.") + ("disable-sqlite", "Disable logging to sqlite.") + ("sqlite-file", boost::program_options::value(), "Set sqlite database file."); + std::cerr << show_opts << std::endl; + return; + } + if (vm.count("disable-stdlogger")) { + disableStdLogger = true; + std::cerr << "Logging to standard out is disabled." << std::endl; + } + if (vm.count("disable-sqlite")) { + disableSqlite = true; + std::cerr << "Logging to sqlite is disabled." << std::endl; + } + if (vm.count("sqlite-file")) { + sqliteFile = vm["sqlite-file"].as(); + std::cerr << "Sqlite database file is set to \""<< sqliteFile << "\"." << std::endl; + } + + #ifdef WFR_ENABLE_STDLOGGER + if (!disableStdLogger) { + oStreamLogger = std::unique_ptr(new wfr::eventsystem::OStreamLogger(std::cout)); + singleton.addListener(*oStreamLogger.get()); + } + #endif + + #ifdef WFR_ENABLE_PERFDATABASE + if (!disableSqlite) { + if (sqliteFile.empty()) { + sqliteFile = "wfr_events.sqlite"; + } + if (!sqliteFile.empty()) { + sqliteLogger = std::unique_ptr(new wfr::eventsystem::SQLiteLogger(sqliteFile)); + if (sqliteLogger->isReady()) { + singleton.addListener(*sqliteLogger.get()); + } else { + sqliteLogger.reset(); + } + } + } + #endif +} + + + +EventSystem::EventSystem() noexcept + : threadStarted(false) { + try { + eventThread = std::unique_ptr(new std::thread(eventThreadFunc, this)); + while (!threadStarted.load()) { + std::this_thread::yield(); + } + } catch (const std::system_error& e) { + std::string message = (boost::format("Caught exception while trying to start event thread: %1% (%2%)") % e.what() % e.code()).str(); + throw exception::wfr_fatal_error(message, std::shared_ptr(new std::runtime_error(e))); + } +} + + +void EventSystem::finish() noexcept { + if (!singleton.isFinished) { + singleton.finishInstance(); + #ifdef WFR_ENABLE_PERFDATABASE + if (sqliteLogger != nullptr) { + singleton.removeListener(*sqliteLogger.get()); + sqliteLogger.reset(); + } + #endif + #ifdef WFR_ENABLE_STDLOGGER + if (oStreamLogger != nullptr) { + singleton.removeListener(*oStreamLogger.get()); + oStreamLogger.reset(); + } + #endif + } +} + +void EventSystem::finishInstance() noexcept { + { // mutex region + std::lock_guard threadLock(eventThreadMutex); + stopThread = true; + eventThreadCondVar.notify_one(); + } // mutex region end + eventThread->join(); + isFinished = true; +} + +EventSystem::~EventSystem() noexcept { + if (!isFinished) { + finishInstance(); + } +} + + + +void EventSystem::eventThreadFunc(EventSystem* eventSystem) noexcept { + std::unique_lock threadLock(eventSystem->eventThreadMutex); + eventSystem->threadStarted.store(true); + while (!eventSystem->stopThread || !eventSystem->eventQueue.empty()) { + // Go through event queue and notify listeners + while (!eventSystem->eventQueue.empty()) { + auto event = eventSystem->eventQueue.front(); + eventSystem->eventQueue.pop(); + // iterate through listeners + for (auto l : eventSystem->eventListeners) { + l->notifyEvent(event); + } + } // end while + // Go to sleep and wait for new events + if (!eventSystem->stopThread) { + eventSystem->eventThreadCondVar.wait(threadLock); + } + } + eventSystem->threadStarted = true; +} + + +void EventSystem::fireEvent(std::shared_ptr event, bool noLocking) noexcept { + if (event != nullptr) { + if (noLocking) { + eventQueue.push(event); + eventThreadCondVar.notify_one(); + } else { + std::lock_guard lock(eventThreadMutex); + eventQueue.push(event); + eventThreadCondVar.notify_one(); + } + } +} + + +bool EventSystem::addListener(EventListener& listener) noexcept { + std::unique_lock threadLock(eventThreadMutex); + if (eventListeners.find(&listener) == eventListeners.end()) { + eventListeners.insert(&listener); + return true; + } else { + return false; + } +} + +bool EventSystem::removeListener(EventListener& listener) noexcept { + std::unique_lock threadLock(eventThreadMutex); + if (eventListeners.find(&listener) != eventListeners.end()) { + eventListeners.erase(&listener); + return true; + } else { + return false; + } +} + +} /* namespace eventsystem */ +} /* namespace wfr */ diff --git a/src/eventsystem/OStreamLogger.cpp b/src/eventsystem/OStreamLogger.cpp new file mode 100755 index 0000000..29c23b3 --- /dev/null +++ b/src/eventsystem/OStreamLogger.cpp @@ -0,0 +1,15 @@ + +#include +#include +#include + +namespace wfr { +namespace eventsystem { + +void OStreamLogger::notifyEvent(const std::shared_ptr& event) noexcept { + oStream << event->toString() << std::endl; + oStream.flush(); +} + +} /* namespace eventsystem */ +} /* namespace wfr */ diff --git a/src/eventsystem/SQLiteLogger.cpp b/src/eventsystem/SQLiteLogger.cpp new file mode 100755 index 0000000..d7a2d87 --- /dev/null +++ b/src/eventsystem/SQLiteLogger.cpp @@ -0,0 +1,483 @@ +/* + * SQLiteLogger.cpp + * + * Created on: 05.05.2014 + * Author: matthias + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#include +#include +#include +#include + +#include +#include +#include +#include + + +namespace wfr { +namespace eventsystem { + + +SQLiteLogger::SQLiteLogger(std::string filename) : filename(filename), statProcessedEvents(0), statWrittenEvents(0) { + std::stringstream ss; + ss << "Writting event data to sqlite database \"" << filename << "\""; + WorkflowRuntime::logMessage(ss.str()); + try { + dbHandle = std::unique_ptr(new odb::sqlite::database(filename, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE)); + } catch (odb::exception& e) { + std::stringstream ss; + ss << "Could not open sqlite database \"" << filename << "\": " << e.what(); + WorkflowRuntime::logMessage(ss.str()); + dbHandle = nullptr; + } + try { + if (odb::schema_catalog::exists(*dbHandle, "")) { + odb::transaction t(dbHandle->begin()); + odb::schema_catalog::create_schema(*dbHandle, "", false); + t.commit(); + } else { + WorkflowRuntime::logMessage("No database schema detected ..."); + } + } catch (odb::exception& e) { + std::stringstream ss; + ss << "Could not create sqlite database schema: " << e.what(); + WorkflowRuntime::logMessage(ss.str()); + } + loggerThread = std::unique_ptr(new std::thread(dbwriterfunc, this)); + readyFlag = true; +} + + +SQLiteLogger::~SQLiteLogger() { + if (loggerThread) { + threadBreakFlag = true; + { + std::lock_guard lock(threadMutex); + threadCondition.notify_one(); + } + wfr_timestamp_sc_t timestamp; + bool queueNotEmpty = false; + if (!eventQueue.empty()) { + queueNotEmpty = true; + timestamp = std::chrono::system_clock::now(); + WorkflowRuntime::logMessage("SQLiteLogger is still writing events ..."); + } + loggerThread->join(); + if (queueNotEmpty) { + wfr_duration_sc_t diff = std::chrono::system_clock::now() - timestamp; + std::chrono::milliseconds ms = std::chrono::duration_cast(diff); + std::stringstream ss; + ss << "SQLiteLogger finished writing events (needed " << ms.count() << " ms)."; + WorkflowRuntime::logMessage(ss.str()); + } + loggerThread.reset(); + } + if (dbHandle) { + dbHandle.reset(); + } +} + + +void SQLiteLogger::dbwriterfunc(SQLiteLogger* logger) { + + // Give thread a lower priority + pid_t myPID = getpid(); + setpriority(PRIO_PROCESS, myPID, 19); + + odb::session mysession; + + logger->threadRunning = true; + odb::transaction* trans = nullptr; + uint32_t statsWrittenSnapshot = 0; + while (!logger->threadBreakFlag || !logger->eventQueue.empty()) { + std::shared_ptr event; + { + std::unique_lock threadLock(logger->threadMutex); + while (logger->eventQueue.empty() && !logger->threadBreakFlag) { + logger->threadCondition.wait(threadLock); + } + if (!logger->eventQueue.empty()) { + event = logger->eventQueue.front(); + logger->eventQueue.pop(); + } + } + if (event) { + logger->statProcessedEvents++; + + if (trans == nullptr) { + trans = new odb::transaction(logger->dbHandle->begin()); + statsWrittenSnapshot = logger->statWrittenEvents; + } + /*switch (event->eventType) { + case EventType::WorkflowStatusEvent: + logger->handleWorkflowStatusEvent((WorkflowStatusEvent&)*event); + logger->statWrittenEvents++; + break; + case EventType::ActivityStatusEvent: + logger->handleActicityStatusEvent((ActivityStatusEvent&)*event); + logger->statWrittenEvents++; + break; + case EventType::ActivityInstanceStatusEvent: + logger->handleActicityInstanceStatusEvent((ActivityInstanceStatusEvent&)*event); + logger->statWrittenEvents++; + break; + case EventType::ComputingResourceStatusEvent: + logger->handleComputingResourceStatusEvent((ComputingResourceStatusEvent&)*event); + logger->statWrittenEvents++; + break; + case EventType::ComponentStatusEvent: + logger->handleComponentStatusEvent((ComponentStatusEvent&)*event); + logger->statWrittenEvents++; + break; + default: + break; + }*/ + if (trans != nullptr && logger->statWrittenEvents - statsWrittenSnapshot > 100) { + trans->commit(); + delete trans; + trans = nullptr; + } + } + } + if (trans != nullptr) { + trans->commit(); + delete trans; + trans = nullptr; + } + { + std::stringstream ss; + ss << "SQLiteLogger: processed " << logger->statProcessedEvents << " Events."; + WorkflowRuntime::logMessage(ss.str()); + } + { + std::stringstream ss; + ss << "SQLiteLogger: wrote " << logger->statWrittenEvents << " Events."; + WorkflowRuntime::logMessage(ss.str()); + } + logger->threadRunning = false; +} + + +void SQLiteLogger::notifyEvent(const std::shared_ptr& event) noexcept { + std::lock_guard lock(threadMutex); + eventQueue.push(event); + threadCondition.notify_one(); +} + + +/* +std::shared_ptr SQLiteLogger::getWorkflowFromWfsMap(wfs::Workflow& wf) { + std::shared_ptr ret; + auto iter = workflowMap.find(wf.getWorkflowID()); + if (iter != workflowMap.end()) { + ret = (*iter).second; + } + return ret; +} + +void SQLiteLogger::persistWorkflow(std::shared_ptr& pWf, wfs::Workflow& wf) { + dbHandle->persist(pWf); + workflowMap.insert(workflowMap_t::value_type(wf.getWorkflowID(), pWf)); +} + +std::shared_ptr SQLiteLogger::getActivityFromWfsMap(wfs::Activity& act) { + std::shared_ptr ret; + auto iter = activityMap.find(act.getActivityID()); + if (iter != activityMap.end()) { + ret = (*iter).second; + } + return ret; +} + +void SQLiteLogger::persistActivity(std::shared_ptr& ap, wfs::Activity& a) { + dbHandle->persist(ap); + activityMap.insert(activityMap_t::value_type(a.getActivityID(), ap)); +} + +std::shared_ptr SQLiteLogger::getActivityInstanceFromWfsMap(wfs::ActivityInstance& act) { + std::shared_ptr ret; + auto iter = activityInstanceMap.find(act.getInstanceID()); + if (iter != activityInstanceMap.end()) { + ret = (*iter).second; + } + return ret; +} + +void SQLiteLogger::persistActivityInstance(std::shared_ptr& ap, wfs::ActivityInstance& a) { + dbHandle->persist(ap); + activityInstanceMap.insert(activityInstanceMap_t::value_type(a.getInstanceID(), ap)); +} + + +void SQLiteLogger::handleWorkflowStatusEvent(WorkflowStatusEvent &event) { + auto& wf = event.getWorkflow(); + switch (event.getNewStatus()) { + case wfs::WorkflowStatus::Created: { + + boost::uuids::uuid uuid = boost::uuids::random_generator()(); + const std::string tmp = boost::lexical_cast(uuid); + + std::shared_ptr pWf(new odbmodel::Workflow(wf.getWorkflowID(), tmp)); + pWf->setName(wf.getBaseTemplate().getWorkflowName()); + persistWorkflow(pWf, wf); + writeWorkflowStatus(pWf, event); + } + break; + case wfs::WorkflowStatus::Initialized: { + auto wfp = getWorkflowFromWfsMap(wf); + auto ap = getActivityFromWfsMap(*wf.getTopLevelActivity()); + if (wfp != nullptr && ap != nullptr) { + wfp->setToplevelActivity(ap); + dbHandle->update(wfp); + writeWorkflowStatus(wfp, event); + } else { + WorkflowRuntime::logMessage("Workflow or Activity not found in wfsMaps", true); + } + } + break; + default: + auto wfp = getWorkflowFromWfsMap(wf); + if (wfp != nullptr) { + writeWorkflowStatus(wfp, event); + } + break; + } +} + +void SQLiteLogger::writeWorkflowStatus(std::shared_ptr& pWf, WorkflowStatusEvent &event) { + + std::shared_ptr pWSE(new odbmodel::WorkflowStatusEvent()); + pWSE->setParentWorkflow(pWf); + pWSE->setOldStatus(EventMemberUtils::toString(event.getOldStatus())); + pWSE->setNewStatus(EventMemberUtils::toString(event.getNewStatus())); + + typedef std::chrono::time_point ns_t; + ns_t ns = std::chrono::time_point_cast(event.getTimestamp()); + pWSE->setTimestamp(ns.time_since_epoch().count()); + + dbHandle->persist(pWSE); +} + + +void SQLiteLogger::handleActicityStatusEvent(ActivityStatusEvent &event) { + auto& a = event.getActivity(); + auto& wf = a.getWorkflow(); + switch (event.getNewStatus()) { + case wfs::ActivityStatus::Created: { + auto wfp = getWorkflowFromWfsMap(wf); + if (wfp != nullptr) { + std::shared_ptr pA(new odbmodel::Activity(a.getActivityID(), a.getBaseTemplate().getBranchID())); + pA->setName(a.getBaseTemplate().getActivityName()); + pA->setType(EventMemberUtils::toString(a.getActivityType())); + pA->setParentWorkflow(wfp); + persistActivity(pA, a); + writeActivityStatus(pA, event); + } else { + WorkflowRuntime::logMessage("Workflow not found in wfsMaps", true); + } + } + break; + case wfs::ActivityStatus::Initialized: { + auto wfp = getWorkflowFromWfsMap(wf); + auto ap = getActivityFromWfsMap(a); + if (wfp != nullptr && ap != nullptr) { + for (wfr_size_t t = 0; t < a.getSuccessorCount(); t++) { + auto sp = getActivityFromWfsMap(*a.getSuccessorList()[t]); + if (sp != nullptr) { + ap->getSuccessors().push_back(sp); + } + } + for (wfr_size_t t = 0; t < a.getPredecessorCount(); t++) { + auto pp = getActivityFromWfsMap(*a.getPredecessorList()[t]); + if (pp != nullptr) { + ap->getPredecessors().push_back(pp); + } + } + wfs::Activity* parent = a.getParent(); + if (parent != nullptr) { + auto pa = getActivityFromWfsMap(*parent); + ap->setParent(pa); + } + dbHandle->update(ap); + writeActivityStatus(ap, event); + } else { + WorkflowRuntime::logMessage("Workflow or Activity not found in wfsMaps", true); + } + } + break; + default: + auto ap = getActivityFromWfsMap(a); + if (ap != nullptr) { + writeActivityStatus(ap, event); + } + break; + } +} + +void SQLiteLogger::writeActivityStatus(std::shared_ptr& pA, ActivityStatusEvent &event) { + + std::shared_ptr pASE(new odbmodel::ActivityStatusEvent()); + pASE->setParentActivity(pA); + pASE->setOldStatus(EventMemberUtils::toString(event.getOldStatus())); + pASE->setNewStatus(EventMemberUtils::toString(event.getNewStatus())); + + typedef std::chrono::time_point ns_t; + ns_t ns = std::chrono::time_point_cast(event.getTimestamp()); + pASE->setTimestamp(ns.time_since_epoch().count()); + + dbHandle->persist(pASE); +} + + +void SQLiteLogger::handleActicityInstanceStatusEvent(ActivityInstanceStatusEvent &event) { + auto& ai = event.getActivityInstance(); + auto pai = ai.getParent(); + auto& a = ai.getBaseActivity(); + auto& wf = a.getWorkflow(); + switch (event.getNewStatus()) { + case wfs::ActivityInstanceStatus::Created: { + auto wfp = getWorkflowFromWfsMap(wf); + auto ap = getActivityFromWfsMap(a); + if (wfp != nullptr && ap != nullptr) { + std::shared_ptr pAI(new odbmodel::ActivityInstance(ai.getInstanceID(), ai.getIterationID())); + pAI->setBaseActivity(ap); + pAI->setParentWorkflow(wfp); + persistActivityInstance(pAI, ai); + writeActivityInstanceStatus(pAI, event); + } else { + WorkflowRuntime::logMessage("Workflow or Activity not found in wfsMaps", true); + } + } + break; + case wfs::ActivityInstanceStatus::Initialized: { + auto pAi = getActivityInstanceFromWfsMap(ai); + auto ppAi = getActivityInstanceFromWfsMap(*pai); + if (pAi != nullptr && ppAi != nullptr) { + pAi->setParentInstance(ppAi); + for (wfr_size_t t = 0; t < ai.getPredecessorCount(); t++) { + auto ppai = getActivityInstanceFromWfsMap(*ai.getPredecessor(t)); + if (ppai != nullptr) { + pAi->getPredecessors().push_back(ppai); + } + } + dbHandle->update(pAi); + writeActivityInstanceStatus(pAi, event); + } else { + WorkflowRuntime::logMessage("Workflow or Activity not found in wfsMaps", true); + } + } + break; + default: + auto aip = getActivityInstanceFromWfsMap(ai); + if (aip != nullptr) { + writeActivityInstanceStatus(aip, event); + } + break; + } +} + + +void SQLiteLogger::writeActivityInstanceStatus(std::shared_ptr& pA, ActivityInstanceStatusEvent &event) { + + std::shared_ptr pASE(new odbmodel::ActivityInstanceStatusEvent()); + pASE->setParentInstance(pA); + pASE->setOldStatus(EventMemberUtils::toString(event.getOldStatus())); + pASE->setNewStatus(EventMemberUtils::toString(event.getNewStatus())); + + typedef std::chrono::time_point ns_t; + ns_t ns = std::chrono::time_point_cast(event.getTimestamp()); + pASE->setTimestamp(ns.time_since_epoch().count()); + + dbHandle->persist(pASE); +} + + +void SQLiteLogger::handleDeviceInstanceStatusEvent(DeviceInstanceStatusEvent &event) { + auto ai = event.getExecutedTask(); + auto wf = event.getWorkflow(); + std::shared_ptr pai; + std::shared_ptr pwf; + if (ai != nullptr) { + pai = getActivityInstanceFromWfsMap(*ai); + } + if (wf != nullptr) { + pwf = getWorkflowFromWfsMap(*wf); + } + writeDeviceInstanceStatus(pwf, pai, event); +} + + +void SQLiteLogger::writeDeviceInstanceStatus(std::shared_ptr& pwf, std::shared_ptr& pai, DeviceInstanceStatusEvent &event) { + + std::shared_ptr pDSE(new odbmodel::DeviceInstanceStatusEvent()); + pDSE->setParentWorkflow(pwf); + pDSE->setDeviceSlotCount(event.getDeviceSlotCount()); + pDSE->setDeviceId(event.getDeviceID()); + pDSE->setDeviceType(EventMemberUtils::toString(event.getDeviceType())); + if (pai != nullptr) { + pDSE->setExecutedInstance(pai); + } + if (event.getExecutedImpl() != nullptr) { + pDSE->setExecutedImplId(event.getExecutedImpl()->getImplementationId()); + } + + pDSE->setOldStatus(EventMemberUtils::toString(event.getOldStatus())); + pDSE->setNewStatus(EventMemberUtils::toString(event.getNewStatus())); + + typedef std::chrono::time_point ns_t; + ns_t ns = std::chrono::time_point_cast(event.getTimestamp()); + pDSE->setTimestamp(ns.time_since_epoch().count()); + + dbHandle->persist(pDSE); +} + + +void SQLiteLogger::handleComponentStatusEvent(ComponentStatusEvent &event) { + auto wf = event.getWorkflow(); + std::shared_ptr pai; + std::shared_ptr pwf; + if (wf != nullptr) { + pwf = getWorkflowFromWfsMap(*wf); + } + writeComponentStatus(pwf, event); +} + + +void SQLiteLogger::writeComponentStatus(std::shared_ptr& pwf, ComponentStatusEvent &event) { + + std::shared_ptr pCSE(new odbmodel::ComponentStatusEvent()); + pCSE->setWorkflow(pwf); + pCSE->setComponentType(EventMemberUtils::toString(event.getComponentType())); + + pCSE->setOldStatus(EventMemberUtils::toString(event.getOldStatus())); + pCSE->setNewStatus(EventMemberUtils::toString(event.getNewStatus())); + + typedef std::chrono::time_point ns_t; + ns_t ns = std::chrono::time_point_cast(event.getTimestamp()); + pCSE->setTimestamp(ns.time_since_epoch().count()); + + dbHandle->persist(pCSE); +} +*/ + +} /* namespace eventsystem */ +} /* namespace wfr */ diff --git a/src/eventsystem/cmake.inc b/src/eventsystem/cmake.inc new file mode 100755 index 0000000..9c16cd5 --- /dev/null +++ b/src/eventsystem/cmake.inc @@ -0,0 +1,32 @@ + +set(wfr_cpp_files "${wfr_cpp_files}" + src/eventsystem/Event.cpp + src/eventsystem/EventSystem.cpp + src/eventsystem/OStreamLogger.cpp + src/eventsystem/SQLiteLogger.cpp +) + +set(wfr_eventsystem_odbmodel_dir "include/wfr/eventsystem/odb-model") +set(wfr_eventsystem_odbmodel_files "SimpleDBModel.h") +set(wfr_eventsystem_odbmodel_outdir "${CMAKE_CURRENT_BINARY_DIR}/odb-model") +list(APPEND wfr_add_include_dirs "${WFR_INCLUDE_DIR}/wfr/eventsystem/odb-model" "${CMAKE_CURRENT_BINARY_DIR}/odb-model") + +set(odb_args --database sqlite --std c++11 --schema-format embedded --schema-format sql --generate-schema --generate-query) + +set(wfr_eventsystem_odbmodel_incfiles "") +foreach(_file ${wfr_eventsystem_odbmodel_files}) + string(REPLACE ".h" "-odb.cxx" gencppfile ${_file}) + string(REPLACE ".h" "-odb.hxx" genhxxfile ${_file}) + add_custom_command( + OUTPUT ${wfr_eventsystem_odbmodel_outdir}/${gencppfile} + COMMAND mkdir -p ${wfr_eventsystem_odbmodel_outdir} + && ${Odb_Bin} ${odb_args} -o ${wfr_eventsystem_odbmodel_outdir} ${CMAKE_CURRENT_SOURCE_DIR}/${wfr_eventsystem_odbmodel_dir}/${_file} -I${WFR_INCLUDE_DIR} + DEPENDS libodb ${wfr_eventsystem_odbmodel_dir}/${_file} + COMMENT "Building odb-model for ${_file}" + ) + list(APPEND wfr_cpp_files ${wfr_eventsystem_odbmodel_outdir}/${gencppfile}) + list(APPEND wfr_eventsystem_odbmodel_incfiles ${wfr_eventsystem_odbmodel_outdir}/${genhxxfile}) +endforeach() + +install(FILES ${wfr_eventsystem_odbmodel_incfiles} DESTINATION ${CMAKE_INSTALL_PREFIX}/include) + diff --git a/src/execution/ExecutionManager.cpp b/src/execution/ExecutionManager.cpp new file mode 100755 index 0000000..9aeeb6e --- /dev/null +++ b/src/execution/ExecutionManager.cpp @@ -0,0 +1,122 @@ + +#include +#include +#include +//#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace wfr { +namespace execution { + + +ExecutionManager ExecutionManager::singleton; + +void ExecutionManager::init(int argc, char** argv) { + boost::program_options::options_description opts("Execution Options"); + opts.add_options() + ("help", "Print help message."); + boost::program_options::variables_map vm; + auto parsed = boost::program_options::command_line_parser(argc, argv).options(opts).allow_unregistered().run(); + boost::program_options::store(parsed, vm); + boost::program_options::notify(vm); + if (vm.count("help")) { + std::cerr << opts << std::endl; + return; + } + + auto& resourceManager = resource::ResourceManager::getInstance(); + + std::set pthreadResources; + for (auto dev : resourceManager.getComputingResources()) { + if (dev->hasCapability(resource::ResourceCapabilityType::GenericCPU)) { + pthreadResources.insert(dev); + } + } + singleton.pThreadBackend = new PThreadBackend(singleton, pthreadResources); + + std::set cudaResources; + for (auto dev : resourceManager.getComputingResources()) { + if (dev->hasCapability(resource::ResourceCapabilityType::CUDA)) { + cudaResources.insert(dev); + } + } + //singleton.cudaBackend = new CudaBackend(singleton, cudaResources); + + { + std::stringstream ss; + ss << "ExecutionManager: PthreadBackend: using " << singleton.pThreadBackend->getTotalSlotCount() << " pthread threads."; + wfr::WorkflowRuntime::logMessage(ss.str()); + } +} + +void ExecutionManager::finish() { + delete singleton.pThreadBackend; +} + +ExecutionManager::ExecutionManager() : pThreadBackend(nullptr) { +} + +ExecutionManager::~ExecutionManager() { +} + + +bool ExecutionManager::executeSchedulingDecision( std::shared_ptr sd, scheduling::AbstractScheduler& scheduler) { + std::lock_guard lock(managerMutex); + bool retval = false; + auto type = sd->activityImplementation->implementationType; + switch (type) { + case wfs::ActivityImplementationType::PThread: + { + ExecutionHandle* handle = new ExecutionHandle(sd); + if (pThreadBackend->queueTaskExecution(*handle)) { + schedulerHandleMap.insert({handle, &scheduler}); + retval = true; + } else { + throw exception::wfr_fatal_error("ToDo: Not implemented"); + } + } + break; + case wfs::ActivityImplementationType::CUDA: + /*{ + ExecutionHandle* handle = new ExecutionHandle(&sd); + if (cudaBackend->queueTaskExecution(*handle)) { + schedulerHandleMap.insert({handle, &scheduler}); + retval = true; + } else { + throw exception::wfr_fatal_error("ToDo: Not implemented"); + } + }*/ + break; + case wfs::ActivityImplementationType::OpenCL: + case wfs::ActivityImplementationType::OpenMP: + default: + sd->activityInstance->setErrorState(std::make_exception_ptr(wfr::exception::wfr_exception("Unknown Device Type"))); + retval = false; + break; + } + return retval; +} + +void ExecutionManager::notifyExecutionHandleUpdate(ExecutionHandle& handle) { + std::lock_guard lock(managerMutex); + auto iter = schedulerHandleMap.find(&handle); + if (iter != schedulerHandleMap.end()) { + (*iter).second->notifySchedulingDecisionStatusUpdate(handle.schedulingDecision); + schedulerHandleMap.erase(iter); + } + delete &handle; +} + +} /* namespace execution */ +} /* namespace wfr */ diff --git a/src/execution/backends/pthreads/PThreadBackend.cpp b/src/execution/backends/pthreads/PThreadBackend.cpp new file mode 100755 index 0000000..1f29bc2 --- /dev/null +++ b/src/execution/backends/pthreads/PThreadBackend.cpp @@ -0,0 +1,124 @@ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace wfr { +namespace execution { + +PThreadBackend::PThreadBackend(ExecutionManager& manager, const std::set& resources) + : manager(manager), resources(resources), maxWorkerCount(0) { + for (auto dev : resources) { + maxWorkerCount += dev->getMaxSlotCount(); + } +} + +PThreadBackend::~PThreadBackend() { + std::unique_lock objLock(objMutex); + while (currentBusyWorkerCount > 0 || !taskQueue.empty()) { + objLock.unlock(); + std::this_thread::yield(); + objLock.lock(); + } + for (auto w : idleWorkers) { + w->finishThread(); + } + isShutdown = true; + workerCondVar.notify_all(); + for (auto w : idleWorkers) { + objLock.unlock(); + w->join(); + objLock.lock(); + delete w; + } + idleWorkers.clear(); +} + +void PThreadBackend::notifyExecutionHandleUpdate(ExecutionHandle& handle, PThreadWorker& worker) { + manager.notifyExecutionHandleUpdate(handle); +} + + +ExecutionHandle* PThreadBackend::popTaskExecution(PThreadWorker& worker) { + std::unique_lock objLock(objMutex); + if (worker.isBusy()) { + occupiedSlotCount-=worker.getUsedSlotCount(); + worker.setUsedSlotCount(0); + currentBusyWorkerCount--; + worker.setBusy(false); + worker.setStatus(wfr::wfs::ComputingResourceStatus::Idle); + } + bool wasPutIntoIdlePool = false; + ExecutionHandle* handle = nullptr; + while (!isShutdown && handle == nullptr) { + while (!isShutdown && taskQueue.empty()) { + if (!wasPutIntoIdlePool) { + idleWorkers.insert(&worker); + wasPutIntoIdlePool = true; + } + worker.setStatus(wfr::wfs::ComputingResourceStatus::Sleep); + workerCondVar.wait(objLock); + worker.setStatus(wfr::wfs::ComputingResourceStatus::WokenUp); + } + if (!isShutdown) { + handle = taskQueue.front(); + taskQueue.pop(); + slotsInQueue -= handle->schedulingDecision->slotCount; + } + } + if (!isShutdown) { + if (wasPutIntoIdlePool) { + idleWorkers.erase(idleWorkers.find(&worker)); + } + currentBusyWorkerCount++; + worker.setBusy(true); + worker.setUsedSlotCount(handle->schedulingDecision->slotCount); + auto sd = handle->schedulingDecision; + auto reservation = sd->reservationHandle; + if (reservation.isValid()) { + reservation.resource->markReservedSlotsBusy(reservation.slotCount); + } else if (sd->resource) { + sd->resource->markFreeSlotsBusy(sd->slotCount); + } + occupiedSlotCount+=worker.getUsedSlotCount(); + //#ifdef WFR_ENABLE_STATISTICS + // statistics::WfrStatistics::setMaxObservedBusyPthreadCount(currentBusyWorkerCount); + //#endif + worker.setStatus(wfr::wfs::ComputingResourceStatus::Busy, handle->schedulingDecision); + return handle; + } else { + return nullptr; + } +} + +bool PThreadBackend::queueTaskExecution(ExecutionHandle& handle) { + bool retval = true; + std::lock_guard objLock(objMutex); + taskQueue.push(&handle); + slotsInQueue += handle.schedulingDecision->slotCount; + handle.schedulingDecision->activityInstance->setInstanceStatus(wfs::ActivityInstanceStatus::Queued); + if (slotsInQueue > idleWorkers.size()) { + if (maxWorkerCount == 0 || currentTotalWorkerCount < maxWorkerCount) { + PThreadWorker::createNewThread(*this); + currentTotalWorkerCount++; + //#ifdef WFR_ENABLE_STATISTICS + // statistics::WfrStatistics::setMaxObservedCurrentPthreadCount(currentTotalWorkerCount); + //#endif + } else { + handle.schedulingDecision->activityInstance->setInstanceStatus(wfs::ActivityInstanceStatus::WaitingForFreeResources); + } + } + workerCondVar.notify_all(); + return retval; +} + +} /* namespace execution */ +} /* namespace wfr */ diff --git a/src/execution/backends/pthreads/PThreadWorker.cpp b/src/execution/backends/pthreads/PThreadWorker.cpp new file mode 100755 index 0000000..97c3c77 --- /dev/null +++ b/src/execution/backends/pthreads/PThreadWorker.cpp @@ -0,0 +1,107 @@ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace wfr { +namespace execution { + +std::atomic PThreadWorker::nextThreadID = ATOMIC_VAR_INIT(1); + +wfr_id_t PThreadWorker::getNextThreadID() { + return nextThreadID.fetch_add(1); +} + +PThreadWorker::PThreadWorker(PThreadBackend& backend) + : threadID(getNextThreadID()), stopThread(false), threadRunning(false), threadBusy(false), backend(backend), thread(nullptr), + usedSlotCount(0), status(wfs::ComputingResourceStatus::Created) { + thread = new std::thread(workerFunc, this); + + wfr::eventsystem::ComputingResourceStatusEvent::fireEvent(nullptr, wfr::wfs::ActivityImplementationType::PThread, threadID, + wfr::wfs::ComputingResourceStatus::Unknown, wfr::wfs::ComputingResourceStatus::Created); +} + +PThreadWorker::~PThreadWorker() { + if (thread != nullptr) { + while (threadRunning) { + std::this_thread::yield(); + } + delete thread; + thread = nullptr; + } +} + + +void PThreadWorker::workerFunc(PThreadWorker* threadObj) { + threadObj->threadRunning = true; + while (!threadObj->stopThread) { + ExecutionHandle* handle; + while ((handle = threadObj->backend.popTaskExecution(*threadObj)) != nullptr) { + auto sd = handle->schedulingDecision; + auto execFunc = sd->activityImplementation->as().executionFuncHook; + sd->activityInstance->setInstanceStatus(wfr::wfs::ActivityInstanceStatus::Running); + threadObj->setStatus(wfs::ComputingResourceStatus::ExecutingTask, handle->schedulingDecision); + handle->setState(ExecutionHandleState::Running); + try { + execFunc(*sd->activityInstance); + auto reservation = sd->reservationHandle; + if (reservation.isValid()) { + reservation.resource->releaseBusySlots(reservation.slotCount); + reservation.invalidateReservation(); + } else if (sd->resource) { + sd->resource->releaseBusySlots(sd->slotCount); + } + handle->setState(ExecutionHandleState::Finished); + threadObj->setStatus(wfr::wfs::ComputingResourceStatus::FinishedTask, handle->schedulingDecision); + sd->activityInstance->setInstanceStatus(wfr::wfs::ActivityInstanceStatus::Finished); + } catch (exception::wfr_exception& e) { + // Need to implement better error handling, but for now just rethrow + throw e; + /* + handle->setErrorCause(std::current_exception()); + threadObj->setStatus(wfr::wfs::DeviceInstanceStatus::Error, &handle->getSchedulingDecision()); + sd.getActivityInstance().setInstanceStatus(wfr::wfs::ActivityInstanceStatus::Error); + */ + } + threadObj->backend.notifyExecutionHandleUpdate(*handle, *threadObj); + } + } + threadObj->threadRunning = false; +} + + +void PThreadWorker::finishThread() { + stopThread = true; +} + +void PThreadWorker::join() { + if (thread != nullptr) { + thread->join(); + } +} + +void PThreadWorker::setStatus(wfs::ComputingResourceStatus status, std::shared_ptr sd) { + wfr::eventsystem::ComputingResourceStatusEvent::fireEvent( (sd.get() == nullptr) ? nullptr : &sd->activityInstance->baseActivity.workflow, + wfr::wfs::ActivityImplementationType::PThread, threadID, this->status, status, (sd.get() == nullptr) ? nullptr : sd->activityInstance, + (sd.get() == nullptr) ? nullptr : sd->activityImplementation, (sd.get() == nullptr) ? 0 : sd->slotCount); + this->status = status; +} + +PThreadWorker* PThreadWorker::createNewThread(PThreadBackend& backend) { + auto thread = new PThreadWorker(backend); + return thread; +} + +} /* namespace execution */ +} /* namespace wfr */ diff --git a/src/execution/cmake.inc b/src/execution/cmake.inc new file mode 100755 index 0000000..95b7584 --- /dev/null +++ b/src/execution/cmake.inc @@ -0,0 +1,6 @@ + +set(wfr_cpp_files "${wfr_cpp_files}" + src/execution/backends/pthreads/PThreadWorker.cpp + src/execution/backends/pthreads/PThreadBackend.cpp + src/execution/ExecutionManager.cpp +) diff --git a/src/prediction/PredictionManager.cpp b/src/prediction/PredictionManager.cpp new file mode 100755 index 0000000..af87256 --- /dev/null +++ b/src/prediction/PredictionManager.cpp @@ -0,0 +1,71 @@ + +#include +#include +#include +#include +#include +#include + + + +namespace wfr { +namespace prediction { + + +PredictionManager PredictionManager::singleton; + +void PredictionManager::init(int argc, char** argv) { + std::string predictionConfig; + boost::program_options::options_description opts("Prediction Options"); + opts.add_options() + ("predictionconfig", boost::program_options::value(), "Set prediction service config.") + ("help", "Print help message."); + boost::program_options::variables_map vm; + auto parsed = boost::program_options::command_line_parser(argc, argv).options(opts).allow_unregistered().run(); + boost::program_options::store(parsed, vm); + boost::program_options::notify(vm); + if (vm.count("help")) { + std::cerr << opts << std::endl; + return; + } + if (vm.count("predictionconfig")) { + predictionConfig = vm["predictionconfig"].as(); + std::cerr << "Prediction Service Config is set to \""<< predictionConfig << "\"." << std::endl; + } + singleton.service = new OraclePredictionService(predictionConfig); +} + + +void PredictionManager::finish() noexcept { +} + + +PredictionManager::~PredictionManager() noexcept { + if (service) { + delete service; + service = nullptr; + } +} + + +ExecutionTimeResult PredictionManager::predictExecutionTime(wfs::ActivityInstance& instance, wfs::AtomicActivityImplementation& implementation, resource::ComputingResourceType& resourceType, const wfr_size_t& slots) noexcept { + if (service) { + return service->predictExecutionTime(instance, implementation, resourceType, slots); + } else { + std::cerr << "No Prediction Service configured." << std::endl; + return ExecutionTimeResult(); + } +} + +CommunicationTimeResult PredictionManager::predictCommunicationTime(wfs::ActivityInstance& srcInstance, resource::ComputingResource& srcResource, + wfs::ActivityInstance& destInstance, resource::ComputingResource& destResource) noexcept { + if (service) { + return service->predictCommunicationTime(srcInstance, srcResource, destInstance, destResource); + } else { + std::cerr << "No Prediction Service configured." << std::endl; + return CommunicationTimeResult(); + } +} + +} /* namespace prediction */ +} /* namespace wfr */ diff --git a/src/prediction/cmake.inc b/src/prediction/cmake.inc new file mode 100755 index 0000000..60f0636 --- /dev/null +++ b/src/prediction/cmake.inc @@ -0,0 +1,6 @@ + +set(wfr_cpp_files "${wfr_cpp_files}" + src/prediction/PredictionManager.cpp + src/prediction/services/oracle/OraclePredictionService.cpp +) + diff --git a/src/prediction/services/oracle/OraclePredictionService.cpp b/src/prediction/services/oracle/OraclePredictionService.cpp new file mode 100755 index 0000000..0c933b3 --- /dev/null +++ b/src/prediction/services/oracle/OraclePredictionService.cpp @@ -0,0 +1,49 @@ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +namespace wfr { +namespace prediction { + + +OraclePredictionService::OraclePredictionService(const std::string& config) { + +} + + +ExecutionTimeResult OraclePredictionService::predictExecutionTime(wfs::ActivityInstance& instance, wfs::AtomicActivityImplementation& implementation, + resource::ComputingResourceType& resourceType, const wfr_size_t& slots) { + auto& props = implementation.getProperties(); + for (auto& prop : props.getProperties()) { + if (boost::algorithm::starts_with(prop.first, "exectime.")) { + auto devname = prop.first.substr(9); + if (devname.compare(resourceType.resourceTypeName) == 0) { + double exectime = boost::lexical_cast(prop.second); + std::cout << "Exectime: " << devname << " = " << exectime << std::endl; + return ExecutionTimeResult(&instance, &implementation, &resourceType, NumericalMeasurement(exectime, 0)); + } + } + } + return ExecutionTimeResult(&instance, &implementation, &resourceType, NumericalMeasurement(1, 0)); +} + + +CommunicationTimeResult OraclePredictionService::predictCommunicationTime(wfs::ActivityInstance& srcInstance, resource::ComputingResource& srcResource, + wfs::ActivityInstance& destInstance, resource::ComputingResource& destResource) { + return CommunicationTimeResult(&srcInstance, &srcResource, &destInstance, &destResource, NumericalMeasurement(0, 0, true)); +} + + +} /* namespace prediction */ +} /* namespace wfr */ + + + diff --git a/src/scheduling/AbstractScheduler.cpp b/src/scheduling/AbstractScheduler.cpp new file mode 100755 index 0000000..cea4a5f --- /dev/null +++ b/src/scheduling/AbstractScheduler.cpp @@ -0,0 +1,108 @@ + +#include "wfr/scheduling/AbstractScheduler.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +namespace wfr { +namespace scheduling { + +SchedulerBase::SchedulerBase() : simulationMode(WorkflowRuntime::getGlobalConfig("sim-mode")) {} + + +SchedulerBase::~SchedulerBase() noexcept { + wepMap.clear(); +} + + +void SchedulerBase::registerWEP(wep::WorkflowExecutionPlan& wep, enactment::EnactmentEngine& ee) noexcept { + { + std::unique_lock objLock(schedulerMutex); + wepMap.emplace(std::make_pair(&wep, WepMapEntry(&ee, &wep))); + _registerWEP(wepMap.find(&wep)->second, objLock); + } +} + + +void SchedulerBase::unregisterWEP(wep::WorkflowExecutionPlan& wep) noexcept { + std::unique_lock objLock(schedulerMutex); + auto wepe = wepMap.find(&wep); + if (wepe != wepMap.end()) { + // Wait till all pending scheduling decisions have been handled + while (!wepe->second.decisions.empty()) { + objLock.unlock(); + std::this_thread::yield(); + objLock.lock(); + } + _unregisterWEP(wepe->second, objLock); + wepMap.erase(wepe); + } +} + + +void SchedulerBase::notifyWEPUpdate(wep::WorkflowExecutionPlan& wep, std::set readyToExecute) noexcept { + std::unique_lock objLock(schedulerMutex); + auto wepe = wepMap.find(&wep); + if (wepe != wepMap.end()) { + _notifyWEPUpdate(wepe->second, readyToExecute, objLock); + } +} + + +bool SchedulerBase::executeSchedulingDecision(WepMapEntry& wepe, std::shared_ptr sd, std::unique_lock& schedulerLock) noexcept { + wepe.decisions.insert(sd); + schedulerLock.unlock(); + sd->activityInstance->setSchedulingDecision(sd); + if (sd->activityInstance->activityType() == wfs::ActivityType::Atomic) { + sd->activityInstance->as().setOwnedByExecutionLayer(true); + } + if (sd->getPrediction().isValid()) { + cummulativePredictionTime += sd->getPrediction().executionTime.getValue(); + } + bool retval = execution::ExecutionManager::getInstance().executeSchedulingDecision(sd, *this); + if (!retval) { + // Some error happened (Notify enactment engine) + notifySchedulingDecisionStatusUpdate(sd); + sd->activityInstance->setSchedulingDecision(); + wepe.decisions.erase(sd); + } + schedulerLock.lock(); + return retval; +} + + +void SchedulerBase::notifySchedulingDecisionStatusUpdate(std::shared_ptr sd) noexcept { + { + std::unique_lock objLock(schedulerMutex); + auto wepe = wepMap.find(sd->wep); + if (wepe != wepMap.end()) { + _notifySchedulingDecisionStatusUpdate(wepe->second, sd, objLock); + // Notify enactment engine + auto ee = wepe->second.engine; + ee->notifyActivityInstanceStateUpdate(*sd->activityInstance, *this); + wepe->second.decisions.erase(sd); + sd->activityInstance->setSchedulingDecision(); + } + } +} + + +} /* namespace scheduling */ +} /* namespace wfr */ + + + diff --git a/src/scheduling/SchedulerManager.cpp b/src/scheduling/SchedulerManager.cpp new file mode 100755 index 0000000..de89c4a --- /dev/null +++ b/src/scheduling/SchedulerManager.cpp @@ -0,0 +1,107 @@ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace wfr { +namespace scheduling { + + +SchedulerManager* SchedulerManager::singleton = nullptr; + + +void SchedulerManager::init(int argc, char** argv) { + std::string defaultScheduler = "dummy"; + + boost::program_options::options_description opts("SchedulerFactory Options"); + opts.add_options() + ("help", "Print help message.") + ("list-schedulers", "List available schedulers.") + ("default-scheduler", boost::program_options::value(), "Set the default scheduler."); + boost::program_options::variables_map vm; + auto parsed = boost::program_options::command_line_parser(argc, argv).options(opts).allow_unregistered().run(); + boost::program_options::store(parsed, vm); + boost::program_options::notify(vm); + if (vm.count("help")) { + std::cerr << opts << std::endl; + return; + } + if (vm.count("default-scheduler")) { + defaultScheduler = vm["default-scheduler"].as(); + std::cerr << "Default scheduler is set to \""<< defaultScheduler << "\"." << std::endl; + } + + singleton = new SchedulerManager(defaultScheduler); + + if (vm.count("list-schedulers")) { + std::cerr << "Available schedulers:" << std::endl; + for (auto item : singleton->schedulerFactories) { + std::cerr << "\t" << item.first << std::endl; + } + exit(0); + } +} + +void SchedulerManager::finish() { + if (singleton != nullptr) { + delete singleton; + singleton = nullptr; + } +} + +SchedulerManager& SchedulerManager::getInstance() { + if (singleton == nullptr) { + throw wfr::exception::wfr_missing_instance("ResourceManager instance not found."); + } + return *singleton; +} + + +SchedulerManager::SchedulerManager(std::string defaultScheduler) : defaultScheduler(defaultScheduler) { + schedulerFactories.insert(factoryMap_t::value_type("dummy", []()->AbstractScheduler* { + return new DummyScheduler(resource::ResourceManager::getInstance(), prediction::PredictionManager::getInstance()); + })); + schedulerFactories.insert(factoryMap_t::value_type("heft", []()->AbstractScheduler* { + return new HEFTScheduler(resource::ResourceManager::getInstance(), prediction::PredictionManager::getInstance()); + })); + schedulerFactories.insert(factoryMap_t::value_type("random", []()->AbstractScheduler* { + return new RandomScheduler(resource::ResourceManager::getInstance(), prediction::PredictionManager::getInstance()); + })); + schedulerFactories.insert(factoryMap_t::value_type("jit", []()->AbstractScheduler* { + return new JustInTimeScheduler(resource::ResourceManager::getInstance(), prediction::PredictionManager::getInstance()); + })); + if (schedulerFactories.find(defaultScheduler) == schedulerFactories.end()) { + throw wfr::exception::wfr_fatal_error((boost::format("Default scheduler \"%1%\" does not exist.") % defaultScheduler).str()); + } +} + +AbstractScheduler* SchedulerManager::getDefaultScheduler() { + return getSchedulerByName(defaultScheduler); +} + +AbstractScheduler* SchedulerManager::getSchedulerByName(std::string& name) { + auto scheduler = schedulerFactories.find(name); + if (scheduler != schedulerFactories.end()) { + return scheduler->second(); + } else { + throw wfr::exception::wfr_illegal_argument((boost::format("Could not find scheduler \"%1%\".") % name).str()); + } +} + +void SchedulerManager::markSchedulerForDeletion(AbstractScheduler* scheduler) { + delete scheduler; +} + +} /* namespace scheduling */ +} /* namespace wfr */ + + diff --git a/src/scheduling/cmake.inc b/src/scheduling/cmake.inc new file mode 100755 index 0000000..5e3738c --- /dev/null +++ b/src/scheduling/cmake.inc @@ -0,0 +1,9 @@ + +set(wfr_cpp_files "${wfr_cpp_files}" + src/scheduling/AbstractScheduler.cpp + src/scheduling/SchedulerManager.cpp + src/scheduling/scheduler/dummy/DummyScheduler.cpp + src/scheduling/scheduler/heft/HEFTScheduler.cpp + src/scheduling/scheduler/random/RandomScheduler.cpp + src/scheduling/scheduler/justintime/JustInTimeScheduler.cpp +) diff --git a/src/scheduling/scheduler/dummy/DummyScheduler.cpp b/src/scheduling/scheduler/dummy/DummyScheduler.cpp new file mode 100755 index 0000000..f78dcfa --- /dev/null +++ b/src/scheduling/scheduler/dummy/DummyScheduler.cpp @@ -0,0 +1,51 @@ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +namespace wfr { +namespace scheduling { + + +void DummyScheduler::_notifyWEPUpdate(SchedulerBase::WepMapEntry& wepe, std::set readyToExecute, std::unique_lock& schedulerLock) { + auto resourceTypes = resourceManager.getComputingResourceTypes(); + for (auto n : readyToExecute) { + auto& ai = n->activity.as(); + ai.setInstanceStatus(wfs::ActivityInstanceStatus::Scheduled); + wfs::AtomicActivityImplementation* impl = nullptr; + auto& tmp = *ai.baseActivity.baseTemplate.as().atomicActivityType; + for (auto i : tmp.getImplementations()) { + if (i->implementationType == wfs::ActivityImplementationType::PThread) { + impl = i; + break; + } + } + if (impl) { + std::shared_ptr sd = std::make_shared(&ai, impl, wepe.wep); + executeSchedulingDecision(wepe, sd, schedulerLock); + } else { + throw exception::wfr_fatal_error("No suitable activity implementation found."); + } + } +} + + +} /* namespace scheduling */ +} /* namespace wfr */ diff --git a/src/scheduling/scheduler/heft/HEFTScheduler.cpp b/src/scheduling/scheduler/heft/HEFTScheduler.cpp new file mode 100755 index 0000000..323d39f --- /dev/null +++ b/src/scheduling/scheduler/heft/HEFTScheduler.cpp @@ -0,0 +1,212 @@ + + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +namespace wfr { +namespace scheduling { + + + +NumericalMeasurement HEFTScheduler::getAverageExecutionCost(wfs::AtomicActivityInstance& ai, InstanceUserData* instanceData, const std::vector& resources) { + // Iterate over resources and calculate average execution time + NumericalMeasurement average; + wfr_size_t _count = 0; + for (auto dev : resources) { + NumericalMeasurement resTime; + // Get fastest implementation (better said its execution time) for given resource + auto& aat = ai.baseActivity.baseTemplate.as(); + if (aat.atomicActivityType->getImplementationCount() > 0) { + for (auto i : aat.atomicActivityType->getImplementations()) { + auto execPred = predictionManager.predictExecutionTime(ai, *i, *dev); + if (execPred.isValid() && (!resTime.isValid() || execPred.getExecutionTime() < resTime)) { + resTime = execPred.getExecutionTime(); + instanceData->predictions[dev] = std::make_tuple(i, execPred); + } + } + if (resTime.isValid()) { + _count++; + average += resTime; + } + } + } + if (_count > 0) { + average /= _count; + } + return average; +} + + +NumericalMeasurement HEFTScheduler::getMaxSuccValue(wfs::AtomicActivityInstance& ai, InstanceUserData* instanceData, const std::vector& resourceTypes, const std::vector& resources) { + NumericalMeasurement retval(0, 0, true); + + // iterate over successors + for(wfr_size_t i = 0; i < ai.getSuccessorCount(); i++) { + auto succ = ai.getSuccessor(i); + + auto succDataPtr = succ->getUserData(); + InstanceUserData* succData; + if (succDataPtr) { + succData = (InstanceUserData*)succDataPtr.get(); + } else { + succ->setUserData(std::make_shared()); + succData = (InstanceUserData*)succ->getUserData().get(); + } + auto succRank = getRank(succ->as(), instanceData, resourceTypes, resources); + if (succRank.isValid()) { + + // Calculate average communication costs + NumericalMeasurement average(0, 0, true); + wfr_size_t _count = 0; + for (auto& dev1 : resources) { + for (auto& dev2 : resources) { + if (dev1 != dev2) { + auto commTime = predictionManager.predictCommunicationTime(ai, *dev1, *succ, *dev2); + if (commTime.isValid) { + _count++; + average += commTime.communicationTime; + } + } + } + } + if (_count > 0) { + average /= _count; + } + NumericalMeasurement tmp = succData->rank + average; + if (tmp.isValid() && (!retval.isValid() || retval < tmp)) { + retval = tmp; + } + } else { + throw exception::wfr_fatal_error("Invalid successor rank!"); + } + } + return retval; +} + + +NumericalMeasurement HEFTScheduler::getRank(wfs::AtomicActivityInstance& ai, InstanceUserData* instanceData, const std::vector& resourceTypes, const std::vector& resources) { + + if (!instanceData->isComplete) { + if (!instanceData->averageComputingCost.isValid()) { + instanceData->averageComputingCost = getAverageExecutionCost(ai, instanceData, resourceTypes); + } + NumericalMeasurement maxSuccRank = getMaxSuccValue(ai, instanceData, resourceTypes, resources); + if (instanceData->averageComputingCost.isValid() && maxSuccRank.isValid()) { + instanceData->rank = instanceData->averageComputingCost + maxSuccRank; + instanceData->isComplete = true; + } + } + + return instanceData->rank; +} + + +void HEFTScheduler::_notifyWEPUpdate(SchedulerBase::WepMapEntry& wepe, std::set readyToExecute, std::unique_lock& schedulerLock) { + + auto resourceTypes = resourceManager.getComputingResourceTypes(); + auto resources = resourceManager.getComputingResources(); + + // Visitor function for breadth first search. + auto visitFunc = [&](wep::AbstractWepNode* node) -> bool { + if (node->nodeType == wep::WepNodeType::Atomic) { + auto& ai = node->as().activity.as(); + auto instanceDataPtr = ai.getUserData(); + InstanceUserData* instanceData; + if (instanceDataPtr) { + instanceData = (InstanceUserData*)instanceDataPtr.get(); + } else { + ai.setUserData(std::make_shared()); + instanceData = (InstanceUserData*)ai.getUserData().get(); + } + + getRank(ai, instanceData, resourceTypes, resources); + if (instanceData->isComplete && !instanceData->isScheduled && ai.getInstanceStatus() == wfs::ActivityInstanceStatus::ReadyForExecution) { + SchedulingQueueEntry tmp; + tmp.instance = &ai; + tmp.instanceData = instanceData; + tmp.node = node; + schedulingPriorityQueue.push(tmp); + instanceData->isScheduled = true; + } + } + return true; + }; + // Visit all nodes of the WEP and calculate the rank for each atomic activity. + wfr::utils::wep::wepBreadthFirstReverseSearch(wepe.wep->getEndNode(), visitFunc); + + + // Go through scheduling queue and schedule activities; + /*while (!schedulingQueue.empty()) { + auto e = schedulingQueue.front();*/ + while (!schedulingPriorityQueue.empty()) { + auto e = schedulingPriorityQueue.top(); + wfs::AtomicActivityImplementation* fastestImpl = nullptr; + resource::ComputingResource* fastestResource = nullptr; + prediction::ExecutionTimeResult prediction; + wfr_size_t busyResourceCount = 0; + for (auto res : resources) { + if (res->getFreeSlotCount() > 0) { + auto& pe = e.instanceData->predictions[&res->resourceType]; + wfs::AtomicActivityImplementation* impl = std::get<0>(pe); + if (impl) { + auto& pred = std::get<1>(pe); + if (pred.isValid() && (!prediction.isValid() || pred.getExecutionTime() < prediction.getExecutionTime())) { + fastestImpl = std::get<0>(pe); + fastestResource = res; + prediction = pred; + } + } + } else { + busyResourceCount++; + } + } + if (fastestImpl) { + auto reservation = resourceManager.reserveComputingResource(fastestResource, 1); + if (reservation.isValid()) { + std::shared_ptr sd = std::make_shared(e.instance, fastestImpl, wepe.wep, reservation); + sd->setPrediction(prediction); + e.instance->setInstanceStatus(wfs::ActivityInstanceStatus::Scheduled); + executeSchedulingDecision(wepe, sd, schedulerLock); + //schedulingQueue.pop(); + schedulingPriorityQueue.pop(); + + /*std::string d1 = (boost::format("%4%: %1%: Rank %2%, Prediction %3%") + % e.instance->baseActivity.baseTemplate.activityName + % e.instanceData->rank.getValue() + % prediction.executionTime.getValue() + % debugIteration).str(); + debugLines.push_back(d1);*/ + + } + } else if (busyResourceCount == resources.size()) { + // If all resources are busy we can break the loop + break; + } + } + debugIteration++; +} + + + +} /* namespace scheduler */ +} /* namespace wfr */ + + diff --git a/src/scheduling/scheduler/justintime/JustInTimeScheduler.cpp b/src/scheduling/scheduler/justintime/JustInTimeScheduler.cpp new file mode 100755 index 0000000..cbdc9f1 --- /dev/null +++ b/src/scheduling/scheduler/justintime/JustInTimeScheduler.cpp @@ -0,0 +1,78 @@ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +namespace wfr { +namespace scheduling { + + +void JustInTimeScheduler::_notifyWEPUpdate(SchedulerBase::WepMapEntry& wepe, std::set readyToExecute, std::unique_lock& schedulerLock) { + for (auto n : readyToExecute) { + nodeQueue.insert(n); + } + auto resourceTypes = resourceManager.getComputingResourceTypes(); + std::vector scheduledQueue; + for (auto n : nodeQueue) { + auto& ai = n->activity.as(); + wfs::AtomicActivityImplementation* fastestImpl = nullptr; + resource::ComputingResource* fastestRes = nullptr; + prediction::ExecutionTimeResult fastestPred; + for (auto restype : resourceTypes) { + resource::ComputingResource* freeRes = nullptr; + for (auto res : restype->getResources()) { + if (res->getFreeSlotCount() > 0) { + freeRes = res; + break; + } + } + if (freeRes) { + auto& aat = ai.baseActivity.baseTemplate.as(); + for (auto impl : aat.atomicActivityType->getImplementations()) { + auto execPred = predictionManager.predictExecutionTime(ai, *impl, *restype); + if (execPred.isValid()) { + if (!fastestImpl || !fastestPred.isValid() || execPred.executionTime.getValue() < fastestPred.executionTime.getValue()) { + fastestImpl = impl; + fastestRes = freeRes; + fastestPred = execPred; + } + } + } + } + } + if (fastestImpl) { + auto reservation = resourceManager.reserveComputingResource(fastestRes, 1); + auto sd = std::make_shared(&ai, fastestImpl, wepe.wep, reservation); + sd->setPrediction(fastestPred); + ai.setInstanceStatus(wfs::ActivityInstanceStatus::Scheduled); + scheduledQueue.push_back(n); + executeSchedulingDecision(wepe, sd, schedulerLock); + } else { + //throw exception::wfr_fatal_error("JustInTimeScheduler could not find a suitable implementation."); + } + } + for (auto n : scheduledQueue) { + nodeQueue.erase(n); + } +} + + +} /* namespace scheduling */ +} /* namespace wfr */ diff --git a/src/scheduling/scheduler/random/RandomScheduler.cpp b/src/scheduling/scheduler/random/RandomScheduler.cpp new file mode 100755 index 0000000..2edbe9b --- /dev/null +++ b/src/scheduling/scheduler/random/RandomScheduler.cpp @@ -0,0 +1,80 @@ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +namespace wfr { +namespace scheduling { + + +void RandomScheduler::_notifyWEPUpdate(SchedulerBase::WepMapEntry& wepe, std::set readyToExecute, std::unique_lock& schedulerLock) { + for (auto n : readyToExecute) { + nodeQueue.insert(n); + } + auto resourceTypes = resourceManager.getComputingResourceTypes(); + std::vector scheduledQueue; + for (auto n : nodeQueue) { + auto& ai = n->activity.as(); + std::vector> predResults; + for (auto restype : resourceTypes) { + resource::ComputingResource* freeRes = nullptr; + for (auto res : restype->getResources()) { + if (res->getFreeSlotCount() > 0) { + freeRes = res; + break; + } + } + if (freeRes) { + auto& aat = ai.baseActivity.baseTemplate.as(); + for (auto impl : aat.atomicActivityType->getImplementations()) { + auto execPred = predictionManager.predictExecutionTime(ai, *impl, *restype); + if (execPred.isValid()) { + auto tuple = std::make_tuple(&ai, impl, freeRes, execPred); + predResults.push_back(tuple); + } + } + } + } + if (predResults.size() > 0) { + auto dice = WorkflowRuntime::getRandomNumber(0, predResults.size()-1); + auto& selected = predResults[dice]; + auto instance = std::get<0>(selected); + auto impl = std::get<1>(selected); + auto res = std::get<2>(selected); + auto pred = std::get<3>(selected); + auto reservation = resourceManager.reserveComputingResource(res, 1); + auto sd = std::make_shared(instance, impl, wepe.wep, reservation); + sd->setPrediction(pred); + instance->setInstanceStatus(wfs::ActivityInstanceStatus::Scheduled); + scheduledQueue.push_back(n); + executeSchedulingDecision(wepe, sd, schedulerLock); + } else { + //throw exception::wfr_fatal_error("RandomScheduler could not find a suitable implementation."); + } + } + for (auto n : scheduledQueue) { + nodeQueue.erase(n); + } +} + + +} /* namespace scheduling */ +} /* namespace wfr */ diff --git a/src/utils/cmake.inc b/src/utils/cmake.inc new file mode 100755 index 0000000..250c89c --- /dev/null +++ b/src/utils/cmake.inc @@ -0,0 +1,4 @@ + +set(wfr_cpp_files "${wfr_cpp_files}" + src/utils/filesystem.cpp +) diff --git a/src/utils/filesystem.cpp b/src/utils/filesystem.cpp new file mode 100755 index 0000000..8faeee9 --- /dev/null +++ b/src/utils/filesystem.cpp @@ -0,0 +1,80 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +namespace wfr { + +namespace filesystem { + + +boost::filesystem::path createWorkingFolder(wfr::wfs::ActivityInstance& instance) { + boost::uuids::uuid uuid = boost::uuids::random_generator()(); + std::string tmp = "wfr_wdir_"; + tmp += instance.baseActivity.baseTemplate.activityName + std::string("_"); + tmp = tmp + boost::lexical_cast(uuid); + + boost::filesystem::path wdir(tmp); + boost::system::error_code ec; + if (boost::filesystem::create_directories(wdir, ec)) { + eventsystem::GeneralLoggingEvent::fireEvent(boost::str(boost::format("Created working directory \"%1%\" for activity instance ID %2%.") % tmp % instance.instanceID)); + } else { + std::string errmsg = boost::str(boost::format("Failed to create working directory \"%1%\" for activity instance ID %2%: %3%") % tmp % instance.instanceID % ec.message()); + throw exception::wfr_fatal_error(errmsg); + } + return wdir; +} + +boost::filesystem::path createWorkingFolder(std::string activityName) { + + boost::uuids::uuid uuid = boost::uuids::random_generator()(); + std::string tmp = "wfr_wdir_" + activityName + std::string("_"); + tmp = tmp + boost::lexical_cast(uuid); + + boost::filesystem::path wdir(tmp); + boost::system::error_code ec; + if (boost::filesystem::create_directories(wdir, ec)) { + eventsystem::GeneralLoggingEvent::fireEvent(boost::str(boost::format("Created working directory \"%1%\" for activity \"%2%\".") % tmp % activityName)); + } else { + std::string errmsg = boost::str(boost::format("Failed to create working directory \"%1%\" for activity \"%2%\": %3%") % tmp % activityName % ec.message()); + throw exception::wfr_fatal_error(errmsg); + } + return wdir; +} + +boost::filesystem::path createFolder(wfr::wfs::ActivityInstance& instance, boost::filesystem::path pdir, std::string fname) { + + boost::filesystem::path folder = pdir/boost::filesystem::path(fname); + boost::system::error_code ec; + if (boost::filesystem::create_directories(folder, ec)) { + eventsystem::GeneralLoggingEvent::fireEvent(boost::str(boost::format("Created directory \"%1%\" for activity instance ID %2%.") % folder.string() % instance.instanceID)); + } else { + std::string errmsg = boost::str(boost::format("Failed to create directory \"%1%\" for activity instance ID %2%: %3%") % folder.string() % instance.instanceID % ec.message()); + throw exception::wfr_fatal_error(errmsg); + } + return folder; +} + + +void copy_file(const boost::filesystem::path& from, const boost::filesystem::path& to, boost::filesystem::copy_option::enum_type option) { + boost::system::error_code ec; + boost::filesystem::copy_file(from, to, option, ec); + if (ec) { + std::string errmsg = boost::str(boost::format("Failed to copy file \"%1%\" to \"%2%\": %3%") % from.string() % to.string() % ec.message()); + throw exception::wfr_fatal_error(errmsg); + } +} + + +} // end namespace filesystem + +} // end namespace wfr + diff --git a/src/wep/cmake.inc b/src/wep/cmake.inc new file mode 100755 index 0000000..07ee24e --- /dev/null +++ b/src/wep/cmake.inc @@ -0,0 +1,4 @@ + +set(wfr_cpp_files "${wfr_cpp_files}" + src/wep/utils/WepDotFileWriter.cpp +) diff --git a/src/wep/utils/WepDotFileWriter.cpp b/src/wep/utils/WepDotFileWriter.cpp new file mode 100755 index 0000000..7a9572e --- /dev/null +++ b/src/wep/utils/WepDotFileWriter.cpp @@ -0,0 +1,211 @@ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +namespace wfr { +namespace wep { +namespace utils { + + +WepDotFileWriter::WepDotFileWriter(const std::shared_ptr& wep) noexcept + : wep(wep), workflowName(wep->workflow.baseTemplate.workflowName) { + assert(wep); +} + + +void WepDotFileWriter::printToFile() { + printToFile((boost::format("%1%.%2%.dot") % workflowName % wep->getVersion()).str()); +} + + +void WepDotFileWriter::printToFile(const std::string fileName) { + std::ofstream outfile(fileName); + + // Write Prolog + outfile << "digraph \"" << workflowName << "_" << wep->getVersion() << "\" {" << std::endl; + + // Write Nodes and Edges + visitedNodes_t visitedNodes; + writeWepNodeAndEdges(outfile, wep->getStartNode(), visitedNodes); + + // Write Epilog + outfile << "}" << std::endl; + + // Flush and Close + outfile.flush(); + outfile.close(); + + // Log + wfr::WorkflowRuntime::logMessage((boost::format("WEP to DOT-File Writer: Finished writing WEP version %1% to file \"%2%\"") % wep->getVersion() % fileName).str()); +} + + +void WepDotFileWriter::writeWepNodeAndEdges(std::ofstream& outfile, AbstractWepNode* node, visitedNodes_t& visitedNodes) { + if (visitedNodes.find(node) == visitedNodes.end()) { + visitedNodes.insert(node); + + // Write node info + outfile << "\t" << getNodeID(node) << " [" + << "label=\"" << getNodeLabel(node) << "\"" + << ",shape=" << getNodeShape(node) + << "]" << std::endl; + + // Call this function recursively for successors and then write edges + std::string nodeID = getNodeID(node); + for (auto e : node->getSuccessors()) { + writeWepNodeAndEdges(outfile, e, visitedNodes); + outfile << "\t" << nodeID << " -> " << getNodeID(e) << std::endl; + } + } +} + + +std::string WepDotFileWriter::getNodeType(AbstractWepNode* node) { + if (node->withActivityInstance) { + switch (node->as().activity.activityType()) { + case wfs::ActivityType::Conditional: + return "Conditional"; + case wfs::ActivityType::Container: + return "Container"; + case wfs::ActivityType::ForLoop: + return "ForLoop"; + case wfs::ActivityType::WhileLoop: + return "WhileLoop"; + case wfs::ActivityType::Atomic: + return "Atomic"; + case wfs::ActivityType::Assign: + return "Assign"; + default: + return "<>"; + } + } else { + return "<>"; + } +} + + +std::string WepDotFileWriter::getNodeLabel(AbstractWepNode* node) { + std::stringstream ss; + ss << "#" << node->nodeID << "\\n"; + switch (node->nodeType) { + case wep::WepNodeType::Atomic: + ss << node->as().activity.baseActivity.baseTemplate.activityName + << " (IID: " << node->as().activity.instanceID << ")" + << "\\n<" << getNodeStatus(node) << ">"; + break; + case wep::WepNodeType::Assign: + ss << node->as().activity.baseActivity.baseTemplate.activityName + << " (IID: " << node->as().activity.instanceID << ")" + << "\\n<" << getNodeStatus(node) << ">"; + break; + case wep::WepNodeType::CompositeStart: + ss << getNodeType(node) + << "\\n<" << getNodeStatus(node) << ">"; + break; + case wep::WepNodeType::CompositeEnd: + ss << getNodeType(node); + break; + case wep::WepNodeType::IterationStart: + + ss << "Iteration " << node->as().iterationID + << "\\n<" << getNodeStatus(node) << ">"; + break; + case wep::WepNodeType::IterationEnd: + ss << "Iteration " << node->as().iterationID; + break; + case wep::WepNodeType::Hole: + ss << getNodeType(node) + << "\\n<" << getNodeStatus(node) << ">"; + break; + default: + ss << "<>"; + break; + } + ss << "\\nVisitations(" << getNodeVisitationCount(node) << ")"; + return ss.str(); +} + + +std::string WepDotFileWriter::getNodeStatus(AbstractWepNode* node) { + if (node->withActivityInstance) { + auto& inode = node->as(); + switch (inode.getLastKnownInstanceStatus()) { + case wfr::wfs::ActivityInstanceStatus::Created: + return "Created"; + case wfr::wfs::ActivityInstanceStatus::Initialized: + return "Initialized"; + case wfr::wfs::ActivityInstanceStatus::WaitingForData: + return "WaitingForData"; + case wfr::wfs::ActivityInstanceStatus::WaitingForDependency: + return "WaitingForDependency"; + case wfr::wfs::ActivityInstanceStatus::ReadyForExecution: + return "ReadyForExecution"; + case wfs::ActivityInstanceStatus::Scheduled: + return "Scheduled"; + case wfs::ActivityInstanceStatus::Queued: + return "Queued"; + case wfs::ActivityInstanceStatus::WaitingForFreeResources: + return "WaitingForFreeResources"; + case wfs::ActivityInstanceStatus::Running: + return "Running"; + case wfr::wfs::ActivityInstanceStatus::Finished: + return "Finished"; + case wfr::wfs::ActivityInstanceStatus::Error: + return "Error"; + default: + return "<>"; + } + } else { + return "<>"; + } +} + +std::string WepDotFileWriter::getNodeID(AbstractWepNode* node) { + return (boost::format("node_%1%") % node->nodeID).str(); +} + +std::string WepDotFileWriter::getNodeShape(AbstractWepNode* node) { + switch (node->nodeType) { + case wep::WepNodeType::Atomic: + return "box"; + case wep::WepNodeType::Assign: + return "box"; + case wep::WepNodeType::CompositeStart: + return "triangle"; + case wep::WepNodeType::CompositeEnd: + return "invtriangle"; + case wep::WepNodeType::IterationStart: + return "octagon"; + case wep::WepNodeType::IterationEnd: + return "doubleoctagon"; + case wep::WepNodeType::Hole: + return "egg"; + default: + return "<>"; + } +} + + +std::string WepDotFileWriter::getNodeVisitationCount(AbstractWepNode* node) { + return std::to_string(node->getVisitationCount()); +} + +} /* namespace utils */ +} /* namespace wep */ +} /* namespace wfr */ + + diff --git a/third-party/.directory b/third-party/.directory new file mode 100755 index 0000000..408e9d7 --- /dev/null +++ b/third-party/.directory @@ -0,0 +1,4 @@ +[Dolphin] +Timestamp=2015,3,20,16,24,3 +Version=3 +ViewMode=1 diff --git a/third-party/boost/.directory b/third-party/boost/.directory new file mode 100755 index 0000000..81f4e04 --- /dev/null +++ b/third-party/boost/.directory @@ -0,0 +1,4 @@ +[Dolphin] +Timestamp=2015,3,23,11,37,14 +Version=3 +ViewMode=1 diff --git a/third-party/boost/CMakeLists.txt b/third-party/boost/CMakeLists.txt new file mode 100755 index 0000000..02816d2 --- /dev/null +++ b/third-party/boost/CMakeLists.txt @@ -0,0 +1,71 @@ +cmake_minimum_required(VERSION 2.8) +project(WFR-lib_boost CXX) + + +# cmake options +OPTION(USE_BUILDIN_BOOST "Use buildin boost" ON) + + +# Check whether we are called by another script +get_directory_property(hasParent PARENT_DIRECTORY) + +# Let's build our own copy of boost +if (USE_BUILDIN_BOOST) + include(ExternalProject) + + # Set boost version + if(hasParent) + set(boost_version "1.57.0" PARENT_SCOPE) + set(boost_version "1.57.0") + else() + set(boost_version "1.57.0") + endif() + + # How to build boost + ExternalProject_Add(Boost + DEPENDS + SOURCE_DIR ${CMAKE_CURRENT_BINARY_DIR}/boost/src/boost-${boost_version} + DOWNLOAD_COMMAND mkdir -p boost-${boost_version} && tar xf ${CMAKE_CURRENT_SOURCE_DIR}/boost-${boost_version}.tar.gz --strip=1 -C boost-${boost_version} + PREFIX ${CMAKE_CURRENT_BINARY_DIR}/boost + CONFIGURE_COMMAND cd ${CMAKE_CURRENT_BINARY_DIR}/boost/src/boost-${boost_version} && ./bootstrap.sh --with-libraries=system,filesystem,program_options --prefix=${CMAKE_CURRENT_BINARY_DIR}/boost/install --libdir=${CMAKE_CURRENT_BINARY_DIR}/boost/install/lib + BUILD_COMMAND cd ${CMAKE_CURRENT_BINARY_DIR}/boost/src/boost-${boost_version} && ./b2 install + INSTALL_COMMAND echo "" + ) + + # Where to install boost + install(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/boost/install/include DESTINATION ${CMAKE_INSTALL_PREFIX}) + install(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/boost/install/lib DESTINATION ${CMAKE_INSTALL_PREFIX}) + + # Provide some variables to parent script + if(hasParent) + set(Boost_INCLUDE_DIR "${CMAKE_CURRENT_BINARY_DIR}/boost/install/include") + set(Boost_INCLUDE_DIR "${Boost_INCLUDE_DIR}" PARENT_SCOPE) + set(Boost_INCLUDE_DIRS "${Boost_INCLUDE_DIR}") + set(Boost_INCLUDE_DIRS "${Boost_INCLUDE_DIRS}" PARENT_SCOPE) + set(Boost_LIBRARY_DIR "${CMAKE_CURRENT_BINARY_DIR}/boost/install/lib") + set(Boost_LIBRARY_DIR "${Boost_LIBRARY_DIR}" PARENT_SCOPE) + set(Boost_LIBRARY_DIRS "${Boost_LIBRARY_DIR}") + set(Boost_LIBRARY_DIRS "${Boost_LIBRARY_DIRS}" PARENT_SCOPE) + set(Boost_LIBRARIES + "${Boost_LIBRARY_DIR}/libboost_system.so" + "${Boost_LIBRARY_DIR}/libboost_filesystem.so" + "${Boost_LIBRARY_DIR}/libboost_program_options.so" + ) + set(Boost_LIBRARIES "${Boost_LIBRARIES}" PARENT_SCOPE) + endif() + + +# Let's use an existing copy of boost +else() + add_custom_target(Boost) # Dummy target for add_dependencies + find_package(Boost COMPONENTS system filesystem program_options REQUIRED) + if(hasParent) + set(Boost_INCLUDE_DIR "${Boost_INCLUDE_DIR}" PARENT_SCOPE) + set(Boost_INCLUDE_DIRS "${Boost_INCLUDE_DIRS}" PARENT_SCOPE) + set(Boost_LIBRARY_DIR "${Boost_LIBRARY_DIR}" PARENT_SCOPE) + set(Boost_LIBRARY_DIRS "${Boost_LIBRARY_DIRS}" PARENT_SCOPE) + set(Boost_LIBRARIES "${Boost_LIBRARIES}" PARENT_SCOPE) + endif() +endif () + + diff --git a/third-party/boost/boost-1.57.0.tar.gz b/third-party/boost/boost-1.57.0.tar.gz new file mode 100755 index 0000000..628d8bc Binary files /dev/null and b/third-party/boost/boost-1.57.0.tar.gz differ diff --git a/third-party/cmake.inc b/third-party/cmake.inc new file mode 100755 index 0000000..738df79 --- /dev/null +++ b/third-party/cmake.inc @@ -0,0 +1,4 @@ + +add_subdirectory(third-party/boost) +add_subdirectory(third-party/odb) +add_subdirectory(third-party/rapidjson) diff --git a/third-party/odb/.directory b/third-party/odb/.directory new file mode 100755 index 0000000..35b2d78 --- /dev/null +++ b/third-party/odb/.directory @@ -0,0 +1,4 @@ +[Dolphin] +Timestamp=2015,3,20,14,7,57 +Version=3 +ViewMode=1 diff --git a/third-party/odb/CMakeLists.txt b/third-party/odb/CMakeLists.txt new file mode 100755 index 0000000..38e1734 --- /dev/null +++ b/third-party/odb/CMakeLists.txt @@ -0,0 +1,118 @@ +cmake_minimum_required(VERSION 2.8) +project(WFR-lib_odb CXX) + + +# cmake options +OPTION(USE_BUILDIN_ODB "Use buildin odb" ON) + + +# Check whether we are called by another script +get_directory_property(hasParent PARENT_DIRECTORY) + +# Include libsqlite3 +add_subdirectory(sqlite3) +# Provide some variables to parent script +if(hasParent) + set(Sqlite3_INCLUDE_DIR "${Sqlite3_INCLUDE_DIR}" PARENT_SCOPE) + set(Sqlite3_LIBRARY_DIR "${Sqlite3_LIBRARY_DIR}" PARENT_SCOPE) + set(Sqlite3_LIBRARIES "${Sqlite3_LIBRARIES}" PARENT_SCOPE) +endif() + +# Let's build our own copy of odb +if (USE_BUILDIN_ODB) + include(ExternalProject) + + # Set odb version + if(hasParent) + set(odb_version "2.4.0" PARENT_SCOPE) + set(odb_version "2.4.0") + else() + set(odb_version "2.4.0") + endif() + + set(libodb_common_CPPFLAGS "") + set(libodb_common_CPPFLAGS "") + set(libodb_common_DEPENDS "") + set(libodb_common_include "-I${CMAKE_CURRENT_BINARY_DIR}/libodb_common/install/include") + set(libodb_common_lib "-L${CMAKE_CURRENT_BINARY_DIR}/libodb_common/install/lib") + + set(libodb_sqlite_CPPFLAGS "${libodb_common_include} -I${Sqlite3_INCLUDE_DIR}") + set(libodb_sqlite_LDFLAGS "${libodb_common_lib} -L${Sqlite3_LIBRARY_DIR}") + set(libodb_sqlite_DEPENDS "libodb_common") + set(libodb_sqlite_include "-I${CMAKE_CURRENT_BINARY_DIR}/libodb_sqlite/install/include -I${Sqlite3_INCLUDE_DIR}") + set(libodb_sqlite_lib "-L${CMAKE_CURRENT_BINARY_DIR}/libodb_sqlite/install/lib") + + set(libodb_sqlite_DEPENDS ${libodb_sqlite_DEPENDS} sqlite3) + + # How to build libodb-common + ExternalProject_Add(libodb_common + DEPENDS ${libodb_common_DEPENDS} + SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/libodb-${odb_version} + CONFIGURE_COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/libodb-${odb_version}/configure --prefix=${CMAKE_CURRENT_BINARY_DIR}/libodb_common/install --libdir=${CMAKE_CURRENT_BINARY_DIR}/libodb_common/install/lib "CPPFLAGS=${libodb_common_CPPFLAGS}" "LDFLAGS=${libodb_common_LDFLAGS}" + PREFIX ${CMAKE_CURRENT_BINARY_DIR}/libodb_common + BUILD_COMMAND make install + ) + + # How to build libodb-sqlite + ExternalProject_Add(libodb_sqlite + DEPENDS ${libodb_sqlite_DEPENDS} + SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/libodb-sqlite-${odb_version} + CONFIGURE_COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/libodb-sqlite-${odb_version}/configure --prefix=${CMAKE_CURRENT_BINARY_DIR}/libodb_sqlite/install --libdir=${CMAKE_CURRENT_BINARY_DIR}/libodb_sqlite/install/lib "CPPFLAGS=${libodb_sqlite_CPPFLAGS}" "LDFLAGS=${libodb_sqlite_LDFLAGS}" LIBS=-ldl + PREFIX ${CMAKE_CURRENT_BINARY_DIR}/libodb_sqlite + BUILD_COMMAND make install + ) + + # Where to install odb + install(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/libodb_common/install/include DESTINATION ${CMAKE_INSTALL_PREFIX}) + install(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/libodb_common/install/lib DESTINATION ${CMAKE_INSTALL_PREFIX}) + install(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/libodb_sqlite/install/include DESTINATION ${CMAKE_INSTALL_PREFIX}) + install(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/libodb_sqlite/install/lib DESTINATION ${CMAKE_INSTALL_PREFIX}) + install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/odb-${odb_version}-x86_64-linux-gnu/ USE_SOURCE_PERMISSIONS DESTINATION ${CMAKE_INSTALL_PREFIX}) + install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/cmake/odb-config.cmake DESTINATION ${CMAKE_INSTALL_PREFIX}) + + # Provide some variables to parent script + if(hasParent) + set(Odb_Bin "${CMAKE_CURRENT_SOURCE_DIR}/odb-${odb_version}-x86_64-linux-gnu/bin/odb") + set(Odb_Bin "${Odb_Bin}" PARENT_SCOPE) + set(Libodb_common_INCLUDE_DIR "${CMAKE_CURRENT_BINARY_DIR}/libodb_common/install/include") + set(Libodb_common_INCLUDE_DIR "${Libodb_common_INCLUDE_DIR}" PARENT_SCOPE) + set(Libodb_common_INCLUDE_DIRS "${Libodb_common_INCLUDE_DIR}" PARENT_SCOPE) + set(Libodb_common_LIBRARY_DIR "${CMAKE_CURRENT_BINARY_DIR}/libodb_common/install/lib") + set(Libodb_common_LIBRARY_DIR "${Libodb_common_LIBRARY_DIR}" PARENT_SCOPE) + set(Libodb_common_LIBRARY_DIRS "${Libodb_common_LIBRARY_DIR}" PARENT_SCOPE) + set(Libodb_common_LIBRARIES "${Libodb_common_LIBRARY_DIR}/libodb.a" PARENT_SCOPE) + set(Libodb_sqlite_INCLUDE_DIR "${CMAKE_CURRENT_BINARY_DIR}/libodb_sqlite/install/include") + set(Libodb_sqlite_INCLUDE_DIR "${Libodb_sqlite_INCLUDE_DIR}" PARENT_SCOPE) + set(Libodb_sqlite_INCLUDE_DIRS "${Libodb_sqlite_INCLUDE_DIR}" PARENT_SCOPE) + set(Libodb_sqlite_LIBRARY_DIR "${CMAKE_CURRENT_BINARY_DIR}/libodb_sqlite/install/lib") + set(Libodb_sqlite_LIBRARY_DIR "${Libodb_sqlite_LIBRARY_DIR}" PARENT_SCOPE) + set(Libodb_sqlite_LIBRARY_DIRS "${Libodb_sqlite_LIBRARY_DIR}" PARENT_SCOPE) + set(Libodb_sqlite_LIBRARIES "${Libodb_sqlite_LIBRARY_DIR}/libodb-sqlite.a" PARENT_SCOPE) + endif() + + add_custom_target(libodb) # Dummy target for add_dependencies + add_dependencies(libodb libodb_common libodb_sqlite) + + +# Let's use an existing copy of odb +else() + add_custom_target(libodb) # Dummy target for add_dependencies + find_package(ODB REQUIRED) + if(hasParent) + set(ODB_INCLUDE_DIR "${ODB_INCLUDE_DIR}" PARENT_SCOPE) + set(ODB_LIBRARY_DIR "${ODB_LIBRARY_DIR}" PARENT_SCOPE) + set(ODB_LIBRARIES "${ODB_LIBRARIES}" PARENT_SCOPE) + set(Libodb_common_INCLUDE_DIR "${ODB_INCLUDE_DIR}" PARENT_SCOPE) + set(Libodb_common_INCLUDE_DIRS "${Libodb_common_INCLUDE_DIR}" PARENT_SCOPE) + set(Libodb_common_LIBRARY_DIR "${ODB_LIBRARY_DIR}" PARENT_SCOPE) + set(Libodb_common_LIBRARY_DIRS "${Libodb_common_LIBRARY_DIR}" PARENT_SCOPE) + set(Libodb_common_LIBRARIES "${Libodb_common_LIBRARIES}" PARENT_SCOPE) + set(Libodb_sqlite_INCLUDE_DIR "${ODB_INCLUDE_DIR}" PARENT_SCOPE) + set(Libodb_sqlite_INCLUDE_DIRS "${Libodb_sqlite_INCLUDE_DIR}" PARENT_SCOPE) + set(Libodb_sqlite_LIBRARY_DIR "${ODB_LIBRARY_DIR}" PARENT_SCOPE) + set(Libodb_sqlite_LIBRARY_DIRS "${Libodb_sqlite_LIBRARY_DIR}" PARENT_SCOPE) + set(Libodb_sqlite_LIBRARIES "${Libodb_sqlite_LIBRARIES}" PARENT_SCOPE) + set(Odb_Bin "${Odb_Bin}" PARENT_SCOPE) + endif() +endif () + diff --git a/third-party/odb/cmake/odb-config.cmake b/third-party/odb/cmake/odb-config.cmake new file mode 100755 index 0000000..8cca2f6 --- /dev/null +++ b/third-party/odb/cmake/odb-config.cmake @@ -0,0 +1,20 @@ + +set(SELF_DIR ${CMAKE_CURRENT_LIST_DIR}) + +# Where to find ODB +if (NOT ODB_DIR) + set(ODB_DIR "${SELF_DIR}") +endif() + +set(Libodb_common_INCLUDE_DIR "${ODB_DIR}/include") +set(Libodb_common_LIBRARY_DIR "${ODB_DIR}/lib") +set(Libodb_common_LIBRARIES "${ODB_DIR}/lib/libodb.a") +set(Libodb_sqlite_INCLUDE_DIR "${ODB_DIR}/include") +set(Libodb_sqlite_LIBRARY_DIR "${ODB_DIR}/lib") +set(Libodb_sqlite_LIBRARIES "${ODB_DIR}/lib/libodb-sqlite.a") + +set(ODB_INCLUDE_DIR "${ODB_DIR}/include") +set(ODB_LIBRARY_DIR "${ODB_DIR}/lib") +set(ODB_LIBRARIES "${ODB_DIR}/lib/libodb.a" "${ODB_DIR}/lib/libodb-sqlite.a") + +set(Odb_Bin "${ODB_DIR}/bin/odb") diff --git a/third-party/odb/libodb-2.4.0/GPLv2 b/third-party/odb/libodb-2.4.0/GPLv2 new file mode 100755 index 0000000..3912109 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/GPLv2 @@ -0,0 +1,340 @@ + GNU GENERAL PUBLIC LICENSE + Version 2, June 1991 + + Copyright (C) 1989, 1991 Free Software Foundation, Inc. + 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +License is intended to guarantee your freedom to share and change free +software--to make sure the software is free for all its users. This +General Public License applies to most of the Free Software +Foundation's software and to any other program whose authors commit to +using it. (Some other Free Software Foundation software is covered by +the GNU Library General Public License instead.) You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +this service if you wish), that you receive source code or can get it +if you want it, that you can change the software or use pieces of it +in new free programs; and that you know you can do these things. + + To protect your rights, we need to make restrictions that forbid +anyone to deny you these rights or to ask you to surrender the rights. +These restrictions translate to certain responsibilities for you if you +distribute copies of the software, or if you modify it. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must give the recipients all the rights that +you have. You must make sure that they, too, receive or can get the +source code. And you must show them these terms so they know their +rights. + + We protect your rights with two steps: (1) copyright the software, and +(2) offer you this license which gives you legal permission to copy, +distribute and/or modify the software. + + Also, for each author's protection and ours, we want to make certain +that everyone understands that there is no warranty for this free +software. If the software is modified by someone else and passed on, we +want its recipients to know that what they have is not the original, so +that any problems introduced by others will not reflect on the original +authors' reputations. + + Finally, any free program is threatened constantly by software +patents. We wish to avoid the danger that redistributors of a free +program will individually obtain patent licenses, in effect making the +program proprietary. To prevent this, we have made it clear that any +patent must be licensed for everyone's free use or not licensed at all. + + The precise terms and conditions for copying, distribution and +modification follow. + + GNU GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License applies to any program or other work which contains +a notice placed by the copyright holder saying it may be distributed +under the terms of this General Public License. The "Program", below, +refers to any such program or work, and a "work based on the Program" +means either the Program or any derivative work under copyright law: +that is to say, a work containing the Program or a portion of it, +either verbatim or with modifications and/or translated into another +language. (Hereinafter, translation is included without limitation in +the term "modification".) Each licensee is addressed as "you". + +Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running the Program is not restricted, and the output from the Program +is covered only if its contents constitute a work based on the +Program (independent of having been made by running the Program). +Whether that is true depends on what the Program does. + + 1. You may copy and distribute verbatim copies of the Program's +source code as you receive it, in any medium, provided that you +conspicuously and appropriately publish on each copy an appropriate +copyright notice and disclaimer of warranty; keep intact all the +notices that refer to this License and to the absence of any warranty; +and give any other recipients of the Program a copy of this License +along with the Program. + +You may charge a fee for the physical act of transferring a copy, and +you may at your option offer warranty protection in exchange for a fee. + + 2. You may modify your copy or copies of the Program or any portion +of it, thus forming a work based on the Program, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) You must cause the modified files to carry prominent notices + stating that you changed the files and the date of any change. + + b) You must cause any work that you distribute or publish, that in + whole or in part contains or is derived from the Program or any + part thereof, to be licensed as a whole at no charge to all third + parties under the terms of this License. + + c) If the modified program normally reads commands interactively + when run, you must cause it, when started running for such + interactive use in the most ordinary way, to print or display an + announcement including an appropriate copyright notice and a + notice that there is no warranty (or else, saying that you provide + a warranty) and that users may redistribute the program under + these conditions, and telling the user how to view a copy of this + License. (Exception: if the Program itself is interactive but + does not normally print such an announcement, your work based on + the Program is not required to print an announcement.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Program, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Program, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Program. + +In addition, mere aggregation of another work not based on the Program +with the Program (or with a work based on the Program) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may copy and distribute the Program (or a work based on it, +under Section 2) in object code or executable form under the terms of +Sections 1 and 2 above provided that you also do one of the following: + + a) Accompany it with the complete corresponding machine-readable + source code, which must be distributed under the terms of Sections + 1 and 2 above on a medium customarily used for software interchange; or, + + b) Accompany it with a written offer, valid for at least three + years, to give any third party, for a charge no more than your + cost of physically performing source distribution, a complete + machine-readable copy of the corresponding source code, to be + distributed under the terms of Sections 1 and 2 above on a medium + customarily used for software interchange; or, + + c) Accompany it with the information you received as to the offer + to distribute corresponding source code. (This alternative is + allowed only for noncommercial distribution and only if you + received the program in object code or executable form with such + an offer, in accord with Subsection b above.) + +The source code for a work means the preferred form of the work for +making modifications to it. For an executable work, complete source +code means all the source code for all modules it contains, plus any +associated interface definition files, plus the scripts used to +control compilation and installation of the executable. However, as a +special exception, the source code distributed need not include +anything that is normally distributed (in either source or binary +form) with the major components (compiler, kernel, and so on) of the +operating system on which the executable runs, unless that component +itself accompanies the executable. + +If distribution of executable or object code is made by offering +access to copy from a designated place, then offering equivalent +access to copy the source code from the same place counts as +distribution of the source code, even though third parties are not +compelled to copy the source along with the object code. + + 4. You may not copy, modify, sublicense, or distribute the Program +except as expressly provided under this License. Any attempt +otherwise to copy, modify, sublicense or distribute the Program is +void, and will automatically terminate your rights under this License. +However, parties who have received copies, or rights, from you under +this License will not have their licenses terminated so long as such +parties remain in full compliance. + + 5. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Program or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Program (or any work based on the +Program), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Program or works based on it. + + 6. Each time you redistribute the Program (or any work based on the +Program), the recipient automatically receives a license from the +original licensor to copy, distribute or modify the Program subject to +these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties to +this License. + + 7. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Program at all. For example, if a patent +license would not permit royalty-free redistribution of the Program by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Program. + +If any portion of this section is held invalid or unenforceable under +any particular circumstance, the balance of the section is intended to +apply and the section as a whole is intended to apply in other +circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system, which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 8. If the distribution and/or use of the Program is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Program under this License +may add an explicit geographical distribution limitation excluding +those countries, so that distribution is permitted only in or among +countries not thus excluded. In such case, this License incorporates +the limitation as if written in the body of this License. + + 9. The Free Software Foundation may publish revised and/or new versions +of the General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + +Each version is given a distinguishing version number. If the Program +specifies a version number of this License which applies to it and "any +later version", you have the option of following the terms and conditions +either of that version or of any later version published by the Free +Software Foundation. If the Program does not specify a version number of +this License, you may choose any version ever published by the Free Software +Foundation. + + 10. If you wish to incorporate parts of the Program into other free +programs whose distribution conditions are different, write to the author +to ask for permission. For software which is copyrighted by the Free +Software Foundation, write to the Free Software Foundation; we sometimes +make exceptions for this. Our decision will be guided by the two goals +of preserving the free status of all derivatives of our free software and +of promoting the sharing and reuse of software generally. + + NO WARRANTY + + 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY +FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN +OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES +PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED +OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS +TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE +PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, +REPAIR OR CORRECTION. + + 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR +REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, +INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING +OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED +TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY +YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER +PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE +POSSIBILITY OF SUCH DAMAGES. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + + +Also add information on how to contact you by electronic and paper mail. + +If the program is interactive, make it output a short notice like this +when it starts in an interactive mode: + + Gnomovision version 69, Copyright (C) year name of author + Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, the commands you use may +be called something other than `show w' and `show c'; they could even be +mouse-clicks or menu items--whatever suits your program. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the program, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the program + `Gnomovision' (which makes passes at compilers) written by James Hacker. + + , 1 April 1989 + Ty Coon, President of Vice + +This General Public License does not permit incorporating your program into +proprietary programs. If your program is a subroutine library, you may +consider it more useful to permit linking proprietary applications with the +library. If this is what you want to do, use the GNU Library General +Public License instead of this License. diff --git a/third-party/odb/libodb-2.4.0/INSTALL b/third-party/odb/libodb-2.4.0/INSTALL new file mode 100755 index 0000000..0e6dcc6 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/INSTALL @@ -0,0 +1,81 @@ +Building on UNIX +================ + +The following build instructions are for the Linux/UNIX/Mac OS X +operating systems as well as for Cygwin and MinGW on Windows. + +The standard autotools-based build system is used on these platforms. After +unpacking the source code archive, change to the libodb package directory +(referred to as libodb/ from now on) and run the configure script: + +./configure + +To see the available configuration options run configure with --help: + +./configure --help + +As an example, the following configure command only builds shared libraries, +uses the specified C++ compiler, and compiles with optimization and without +debug information: + +./configure --disable-static CXX=g++-4.5 CXXFLAGS=-O3 + +Once configuration is complete, run make to build libodb: + +make + +Once the build is completed successfully, you can install the libodb headers +and libraries using the install target (you may need to do this step as root +depending on the installation directory): + +make install + + +Building on Windows +=================== + +The following build instructions are for Windows using Microsoft Visual +Studio. If you would like to build libodb with GCC either using Cygwin +or MinGW, refer to the "Building on UNIX" section above. + +The standard Visual Studio project and solution files are used on this +platform. To build libodb, unpack the source code archive and open the +libodb-vc.sln file located in the libodb package directory (referred +to as libodb\ from now on). Here is the version of Visual Studio that +you are using. Once the solution is open, select the desired build +configuration (Debug or Release) and platform (Win32 or x64) and build +the solution. + +The resulting 32-bit DLLs and import libraries are placed into the +libodb\bin\ and libodb\lib\ directories, respectively. Similarly, the +64-bit DLLs and import libraries are placed into libodb\bin64\ and +libodb\lib64\. The Release versions of the import libraries are named +odb.lib and the Debug versions are named odb-d.lib. + +To configure Visual Studio to automatically locate the libodb headers, +DLLs, and import libraries, add the following paths to your VC++ +Directories: + +Win32: + + Include: ...\libodb + Library: ...\libodb\lib + Executable: ...\libodb\bin + +x64: + + Include: ...\libodb + Library: ...\libodb\lib64 + Executable: ...\libodb\bin64 + +Note also that by default libodb uses the __declspec(thread) storage-class +modifier for TLS support. This mechanism is known not to work correctly on +Windows XP/Server 2003 and earlier versions of Windows if a DLL that uses +this modifier is loaded dynamically. If you are planning to link libodb to a +DLL that will be loaded dynamically (e.g., delay loading, COM DLL, explicit +LoadLibrary() call, etc), then you will need to comment out the definition +of the ODB_THREADS_TLS_DECLSPEC macro in the odb\details\config-vc.h file +prior to building libodb. On the other hand, if you plan to link libodb +directly to an executable or another DLL that will be linked directly to +an executable or if you only need to support Windows Vista/Server 2008, +then you don't need to make this change. diff --git a/third-party/odb/libodb-2.4.0/LICENSE b/third-party/odb/libodb-2.4.0/LICENSE new file mode 100755 index 0000000..612c66c --- /dev/null +++ b/third-party/odb/libodb-2.4.0/LICENSE @@ -0,0 +1,18 @@ +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License version 2 as +published by the Free Software Foundation. + +For more information on ODB licensing as well as for answers to +some of the common licensing questions, visit the ODB License +page: + +http://www.codesynthesis.com/products/odb/license.xhtml + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for details. + +You should have received a copy of the GNU General Public License +along with this program; if not, write to the Free Software +Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA diff --git a/third-party/odb/libodb-2.4.0/Makefile.am b/third-party/odb/libodb-2.4.0/Makefile.am new file mode 100755 index 0000000..343751f --- /dev/null +++ b/third-party/odb/libodb-2.4.0/Makefile.am @@ -0,0 +1,11 @@ +# file : Makefile.am +# copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +# license : GNU GPL v2; see accompanying LICENSE file + +SUBDIRS = odb +dist_doc_DATA = GPLv2 LICENSE README NEWS version +EXTRA_DIST = INSTALL libodb-vc8.sln libodb-vc9.sln libodb-vc10.sln libodb-vc11.sln libodb-vc12.sln bootstrap +ACLOCAL_AMFLAGS = -I m4 + +pkgconfigdir = @pkgconfigdir@ +pkgconfig_DATA= libodb.pc diff --git a/third-party/odb/libodb-2.4.0/Makefile.in b/third-party/odb/libodb-2.4.0/Makefile.in new file mode 100755 index 0000000..2c92b6a --- /dev/null +++ b/third-party/odb/libodb-2.4.0/Makefile.in @@ -0,0 +1,859 @@ +# Makefile.in generated by automake 1.12.6 from Makefile.am. +# @configure_input@ + +# Copyright (C) 1994-2012 Free Software Foundation, Inc. + +# This Makefile.in is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY, to the extent permitted by law; without +# even the implied warranty of MERCHANTABILITY or FITNESS FOR A +# PARTICULAR PURPOSE. + +@SET_MAKE@ + +# file : Makefile.am +# copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +# license : GNU GPL v2; see accompanying LICENSE file + +VPATH = @srcdir@ +am__make_dryrun = \ + { \ + am__dry=no; \ + case $$MAKEFLAGS in \ + *\\[\ \ ]*) \ + echo 'am--echo: ; @echo "AM" OK' | $(MAKE) -f - 2>/dev/null \ + | grep '^AM OK$$' >/dev/null || am__dry=yes;; \ + *) \ + for am__flg in $$MAKEFLAGS; do \ + case $$am__flg in \ + *=*|--*) ;; \ + *n*) am__dry=yes; break;; \ + esac; \ + done;; \ + esac; \ + test $$am__dry = yes; \ + } +pkgdatadir = $(datadir)/@PACKAGE@ +pkgincludedir = $(includedir)/@PACKAGE@ +pkglibdir = $(libdir)/@PACKAGE@ +pkglibexecdir = $(libexecdir)/@PACKAGE@ +am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd +install_sh_DATA = $(install_sh) -c -m 644 +install_sh_PROGRAM = $(install_sh) -c +install_sh_SCRIPT = $(install_sh) -c +INSTALL_HEADER = $(INSTALL_DATA) +transform = $(program_transform_name) +NORMAL_INSTALL = : +PRE_INSTALL = : +POST_INSTALL = : +NORMAL_UNINSTALL = : +PRE_UNINSTALL = : +POST_UNINSTALL = : +build_triplet = @build@ +host_triplet = @host@ +subdir = . +DIST_COMMON = README $(am__configure_deps) $(dist_doc_DATA) \ + $(srcdir)/Makefile.am $(srcdir)/Makefile.in \ + $(srcdir)/libodb.pc.in $(top_srcdir)/config/ar-lib \ + $(top_srcdir)/config/config.guess \ + $(top_srcdir)/config/config.sub \ + $(top_srcdir)/config/install-sh $(top_srcdir)/config/ltmain.sh \ + $(top_srcdir)/config/missing $(top_srcdir)/configure \ + $(top_srcdir)/odb/details/config.h.in INSTALL NEWS \ + config/ar-lib config/config.guess config/config.sub \ + config/install-sh config/ltmain.sh config/missing +ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 +am__aclocal_m4_deps = $(top_srcdir)/m4/acx-pthread.m4 \ + $(top_srcdir)/m4/disable-rpath.m4 \ + $(top_srcdir)/m4/libtool-link.m4 $(top_srcdir)/m4/libtool.m4 \ + $(top_srcdir)/m4/ltoptions.m4 $(top_srcdir)/m4/ltsugar.m4 \ + $(top_srcdir)/m4/ltversion.m4 $(top_srcdir)/m4/lt~obsolete.m4 \ + $(top_srcdir)/m4/pkgconfig.m4 $(top_srcdir)/m4/static-lib.m4 \ + $(top_srcdir)/m4/threads.m4 $(top_srcdir)/configure.ac +am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \ + $(ACLOCAL_M4) +am__CONFIG_DISTCLEAN_FILES = config.status config.cache config.log \ + configure.lineno config.status.lineno +mkinstalldirs = $(install_sh) -d +CONFIG_HEADER = $(top_builddir)/odb/config.h \ + $(top_builddir)/odb/details/config.h +CONFIG_CLEAN_FILES = libodb.pc +CONFIG_CLEAN_VPATH_FILES = +SOURCES = +DIST_SOURCES = +RECURSIVE_TARGETS = all-recursive check-recursive dvi-recursive \ + html-recursive info-recursive install-data-recursive \ + install-dvi-recursive install-exec-recursive \ + install-html-recursive install-info-recursive \ + install-pdf-recursive install-ps-recursive install-recursive \ + installcheck-recursive installdirs-recursive pdf-recursive \ + ps-recursive uninstall-recursive +am__can_run_installinfo = \ + case $$AM_UPDATE_INFO_DIR in \ + n|no|NO) false;; \ + *) (install-info --version) >/dev/null 2>&1;; \ + esac +am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`; +am__vpath_adj = case $$p in \ + $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \ + *) f=$$p;; \ + esac; +am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`; +am__install_max = 40 +am__nobase_strip_setup = \ + srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'` +am__nobase_strip = \ + for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||" +am__nobase_list = $(am__nobase_strip_setup); \ + for p in $$list; do echo "$$p $$p"; done | \ + sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \ + $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \ + if (++n[$$2] == $(am__install_max)) \ + { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \ + END { for (dir in files) print dir, files[dir] }' +am__base_list = \ + sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \ + sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g' +am__uninstall_files_from_dir = { \ + test -z "$$files" \ + || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \ + || { echo " ( cd '$$dir' && rm -f" $$files ")"; \ + $(am__cd) "$$dir" && rm -f $$files; }; \ + } +am__installdirs = "$(DESTDIR)$(docdir)" "$(DESTDIR)$(pkgconfigdir)" +DATA = $(dist_doc_DATA) $(pkgconfig_DATA) +RECURSIVE_CLEAN_TARGETS = mostlyclean-recursive clean-recursive \ + distclean-recursive maintainer-clean-recursive +AM_RECURSIVE_TARGETS = $(RECURSIVE_TARGETS:-recursive=) \ + $(RECURSIVE_CLEAN_TARGETS:-recursive=) tags TAGS ctags CTAGS \ + cscope distdir dist dist-all distcheck +ETAGS = etags +CTAGS = ctags +CSCOPE = cscope +DIST_SUBDIRS = $(SUBDIRS) +DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) +distdir = $(PACKAGE)-$(VERSION) +top_distdir = $(distdir) +am__remove_distdir = \ + if test -d "$(distdir)"; then \ + find "$(distdir)" -type d ! -perm -200 -exec chmod u+w {} ';' \ + && rm -rf "$(distdir)" \ + || { sleep 5 && rm -rf "$(distdir)"; }; \ + else :; fi +am__post_remove_distdir = $(am__remove_distdir) +am__relativize = \ + dir0=`pwd`; \ + sed_first='s,^\([^/]*\)/.*$$,\1,'; \ + sed_rest='s,^[^/]*/*,,'; \ + sed_last='s,^.*/\([^/]*\)$$,\1,'; \ + sed_butlast='s,/*[^/]*$$,,'; \ + while test -n "$$dir1"; do \ + first=`echo "$$dir1" | sed -e "$$sed_first"`; \ + if test "$$first" != "."; then \ + if test "$$first" = ".."; then \ + dir2=`echo "$$dir0" | sed -e "$$sed_last"`/"$$dir2"; \ + dir0=`echo "$$dir0" | sed -e "$$sed_butlast"`; \ + else \ + first2=`echo "$$dir2" | sed -e "$$sed_first"`; \ + if test "$$first2" = "$$first"; then \ + dir2=`echo "$$dir2" | sed -e "$$sed_rest"`; \ + else \ + dir2="../$$dir2"; \ + fi; \ + dir0="$$dir0"/"$$first"; \ + fi; \ + fi; \ + dir1=`echo "$$dir1" | sed -e "$$sed_rest"`; \ + done; \ + reldir="$$dir2" +DIST_ARCHIVES = $(distdir).tar.gz $(distdir).tar.bz2 $(distdir).zip +GZIP_ENV = --best +DIST_TARGETS = dist-bzip2 dist-gzip dist-zip +distuninstallcheck_listfiles = find . -type f -print +am__distuninstallcheck_listfiles = $(distuninstallcheck_listfiles) \ + | sed 's|^\./|$(prefix)/|' | grep -v '$(infodir)/dir$$' +distcleancheck_listfiles = find . -type f -print +ACLOCAL = @ACLOCAL@ +AMTAR = @AMTAR@ +AR = @AR@ +AS = @AS@ +AUTOCONF = @AUTOCONF@ +AUTOHEADER = @AUTOHEADER@ +AUTOMAKE = @AUTOMAKE@ +AWK = @AWK@ +CC = @CC@ +CCDEPMODE = @CCDEPMODE@ +CFLAGS = @CFLAGS@ +CPP = @CPP@ +CPPFLAGS = @CPPFLAGS@ +CXX = @CXX@ +CXXCPP = @CXXCPP@ +CXXDEPMODE = @CXXDEPMODE@ +CXXFLAGS = @CXXFLAGS@ +CYGPATH_W = @CYGPATH_W@ +DEFS = @DEFS@ +DEPDIR = @DEPDIR@ +DLLTOOL = @DLLTOOL@ +DSYMUTIL = @DSYMUTIL@ +DUMPBIN = @DUMPBIN@ +ECHO_C = @ECHO_C@ +ECHO_N = @ECHO_N@ +ECHO_T = @ECHO_T@ +EGREP = @EGREP@ +EXEEXT = @EXEEXT@ +FGREP = @FGREP@ +GREP = @GREP@ +INSTALL = @INSTALL@ +INSTALL_DATA = @INSTALL_DATA@ +INSTALL_PROGRAM = @INSTALL_PROGRAM@ +INSTALL_SCRIPT = @INSTALL_SCRIPT@ +INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@ +LD = @LD@ +LDFLAGS = @LDFLAGS@ +LIBOBJS = @LIBOBJS@ +LIBS = @LIBS@ +LIBTOOL = @LIBTOOL@ +LIPO = @LIPO@ +LN_S = @LN_S@ +LTLIBOBJS = @LTLIBOBJS@ +MAKEINFO = @MAKEINFO@ +MANIFEST_TOOL = @MANIFEST_TOOL@ +MKDIR_P = @MKDIR_P@ +NM = @NM@ +NMEDIT = @NMEDIT@ +OBJDUMP = @OBJDUMP@ +OBJEXT = @OBJEXT@ +OTOOL = @OTOOL@ +OTOOL64 = @OTOOL64@ +PACKAGE = @PACKAGE@ +PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@ +PACKAGE_NAME = @PACKAGE_NAME@ +PACKAGE_STRING = @PACKAGE_STRING@ +PACKAGE_TARNAME = @PACKAGE_TARNAME@ +PACKAGE_URL = @PACKAGE_URL@ +PACKAGE_VERSION = @PACKAGE_VERSION@ +PATH_SEPARATOR = @PATH_SEPARATOR@ +PTHREAD_CXX = @PTHREAD_CXX@ +PTHREAD_CXXFLAGS = @PTHREAD_CXXFLAGS@ +PTHREAD_LIBS = @PTHREAD_LIBS@ +RANLIB = @RANLIB@ +SED = @SED@ +SET_MAKE = @SET_MAKE@ +SHELL = @SHELL@ +STRIP = @STRIP@ +VERSION = @VERSION@ +abs_builddir = @abs_builddir@ +abs_srcdir = @abs_srcdir@ +abs_top_builddir = @abs_top_builddir@ +abs_top_srcdir = @abs_top_srcdir@ +ac_ct_AR = @ac_ct_AR@ +ac_ct_CC = @ac_ct_CC@ +ac_ct_CXX = @ac_ct_CXX@ +ac_ct_DUMPBIN = @ac_ct_DUMPBIN@ +acx_pthread_config = @acx_pthread_config@ +am__include = @am__include@ +am__leading_dot = @am__leading_dot@ +am__quote = @am__quote@ +am__tar = @am__tar@ +am__untar = @am__untar@ +bindir = @bindir@ +build = @build@ +build_alias = @build_alias@ +build_cpu = @build_cpu@ +build_os = @build_os@ +build_vendor = @build_vendor@ +builddir = @builddir@ +datadir = @datadir@ +datarootdir = @datarootdir@ +docdir = @docdir@ +dvidir = @dvidir@ +exec_prefix = @exec_prefix@ +host = @host@ +host_alias = @host_alias@ +host_cpu = @host_cpu@ +host_os = @host_os@ +host_vendor = @host_vendor@ +htmldir = @htmldir@ +includedir = @includedir@ +infodir = @infodir@ +install_sh = @install_sh@ +libdir = @libdir@ +libexecdir = @libexecdir@ +localedir = @localedir@ +localstatedir = @localstatedir@ +mandir = @mandir@ +mkdir_p = @mkdir_p@ +oldincludedir = @oldincludedir@ +pdfdir = @pdfdir@ +pkgconfigdir = @pkgconfigdir@ +prefix = @prefix@ +program_transform_name = @program_transform_name@ +psdir = @psdir@ +sbindir = @sbindir@ +sharedstatedir = @sharedstatedir@ +srcdir = @srcdir@ +sysconfdir = @sysconfdir@ +target_alias = @target_alias@ +top_build_prefix = @top_build_prefix@ +top_builddir = @top_builddir@ +top_srcdir = @top_srcdir@ +SUBDIRS = odb +dist_doc_DATA = GPLv2 LICENSE README NEWS version +EXTRA_DIST = INSTALL libodb-vc8.sln libodb-vc9.sln libodb-vc10.sln libodb-vc11.sln libodb-vc12.sln bootstrap +ACLOCAL_AMFLAGS = -I m4 +pkgconfig_DATA = libodb.pc +all: all-recursive + +.SUFFIXES: +am--refresh: Makefile + @: +$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps) + @for dep in $?; do \ + case '$(am__configure_deps)' in \ + *$$dep*) \ + echo ' cd $(srcdir) && $(AUTOMAKE) --foreign'; \ + $(am__cd) $(srcdir) && $(AUTOMAKE) --foreign \ + && exit 0; \ + exit 1;; \ + esac; \ + done; \ + echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign Makefile'; \ + $(am__cd) $(top_srcdir) && \ + $(AUTOMAKE) --foreign Makefile +.PRECIOUS: Makefile +Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status + @case '$?' in \ + *config.status*) \ + echo ' $(SHELL) ./config.status'; \ + $(SHELL) ./config.status;; \ + *) \ + echo ' cd $(top_builddir) && $(SHELL) ./config.status $@ $(am__depfiles_maybe)'; \ + cd $(top_builddir) && $(SHELL) ./config.status $@ $(am__depfiles_maybe);; \ + esac; + +$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) + $(SHELL) ./config.status --recheck + +$(top_srcdir)/configure: $(am__configure_deps) + $(am__cd) $(srcdir) && $(AUTOCONF) +$(ACLOCAL_M4): $(am__aclocal_m4_deps) + $(am__cd) $(srcdir) && $(ACLOCAL) $(ACLOCAL_AMFLAGS) +$(am__aclocal_m4_deps): + +odb/details/config.h: odb/details/stamp-h2 + @if test ! -f $@; then rm -f odb/details/stamp-h2; else :; fi + @if test ! -f $@; then $(MAKE) $(AM_MAKEFLAGS) odb/details/stamp-h2; else :; fi + +odb/details/stamp-h2: $(top_srcdir)/odb/details/config.h.in $(top_builddir)/config.status + @rm -f odb/details/stamp-h2 + cd $(top_builddir) && $(SHELL) ./config.status odb/details/config.h + +distclean-hdr: + -rm -f odb/details/config.h odb/details/stamp-h2 +libodb.pc: $(top_builddir)/config.status $(srcdir)/libodb.pc.in + cd $(top_builddir) && $(SHELL) ./config.status $@ + +mostlyclean-libtool: + -rm -f *.lo + +clean-libtool: + -rm -rf .libs _libs + +distclean-libtool: + -rm -f libtool config.lt +install-dist_docDATA: $(dist_doc_DATA) + @$(NORMAL_INSTALL) + @list='$(dist_doc_DATA)'; test -n "$(docdir)" || list=; \ + if test -n "$$list"; then \ + echo " $(MKDIR_P) '$(DESTDIR)$(docdir)'"; \ + $(MKDIR_P) "$(DESTDIR)$(docdir)" || exit 1; \ + fi; \ + for p in $$list; do \ + if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \ + echo "$$d$$p"; \ + done | $(am__base_list) | \ + while read files; do \ + echo " $(INSTALL_DATA) $$files '$(DESTDIR)$(docdir)'"; \ + $(INSTALL_DATA) $$files "$(DESTDIR)$(docdir)" || exit $$?; \ + done + +uninstall-dist_docDATA: + @$(NORMAL_UNINSTALL) + @list='$(dist_doc_DATA)'; test -n "$(docdir)" || list=; \ + files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \ + dir='$(DESTDIR)$(docdir)'; $(am__uninstall_files_from_dir) +install-pkgconfigDATA: $(pkgconfig_DATA) + @$(NORMAL_INSTALL) + @list='$(pkgconfig_DATA)'; test -n "$(pkgconfigdir)" || list=; \ + if test -n "$$list"; then \ + echo " $(MKDIR_P) '$(DESTDIR)$(pkgconfigdir)'"; \ + $(MKDIR_P) "$(DESTDIR)$(pkgconfigdir)" || exit 1; \ + fi; \ + for p in $$list; do \ + if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \ + echo "$$d$$p"; \ + done | $(am__base_list) | \ + while read files; do \ + echo " $(INSTALL_DATA) $$files '$(DESTDIR)$(pkgconfigdir)'"; \ + $(INSTALL_DATA) $$files "$(DESTDIR)$(pkgconfigdir)" || exit $$?; \ + done + +uninstall-pkgconfigDATA: + @$(NORMAL_UNINSTALL) + @list='$(pkgconfig_DATA)'; test -n "$(pkgconfigdir)" || list=; \ + files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \ + dir='$(DESTDIR)$(pkgconfigdir)'; $(am__uninstall_files_from_dir) + +# This directory's subdirectories are mostly independent; you can cd +# into them and run 'make' without going through this Makefile. +# To change the values of 'make' variables: instead of editing Makefiles, +# (1) if the variable is set in 'config.status', edit 'config.status' +# (which will cause the Makefiles to be regenerated when you run 'make'); +# (2) otherwise, pass the desired values on the 'make' command line. +$(RECURSIVE_TARGETS) $(RECURSIVE_CLEAN_TARGETS): + @fail= failcom='exit 1'; \ + for f in x $$MAKEFLAGS; do \ + case $$f in \ + *=* | --[!k]*);; \ + *k*) failcom='fail=yes';; \ + esac; \ + done; \ + dot_seen=no; \ + target=`echo $@ | sed s/-recursive//`; \ + case "$@" in \ + distclean-* | maintainer-clean-*) list='$(DIST_SUBDIRS)' ;; \ + *) list='$(SUBDIRS)' ;; \ + esac; \ + for subdir in $$list; do \ + echo "Making $$target in $$subdir"; \ + if test "$$subdir" = "."; then \ + dot_seen=yes; \ + local_target="$$target-am"; \ + else \ + local_target="$$target"; \ + fi; \ + ($(am__cd) $$subdir && $(MAKE) $(AM_MAKEFLAGS) $$local_target) \ + || eval $$failcom; \ + done; \ + if test "$$dot_seen" = "no"; then \ + $(MAKE) $(AM_MAKEFLAGS) "$$target-am" || exit 1; \ + fi; test -z "$$fail" +tags-recursive: + list='$(SUBDIRS)'; for subdir in $$list; do \ + test "$$subdir" = . || ($(am__cd) $$subdir && $(MAKE) $(AM_MAKEFLAGS) tags); \ + done +ctags-recursive: + list='$(SUBDIRS)'; for subdir in $$list; do \ + test "$$subdir" = . || ($(am__cd) $$subdir && $(MAKE) $(AM_MAKEFLAGS) ctags); \ + done +cscopelist-recursive: + list='$(SUBDIRS)'; for subdir in $$list; do \ + test "$$subdir" = . || ($(am__cd) $$subdir && $(MAKE) $(AM_MAKEFLAGS) cscopelist); \ + done + +ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES) + list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | \ + $(AWK) '{ files[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in files) print i; }; }'`; \ + mkid -fID $$unique +tags: TAGS + +TAGS: tags-recursive $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \ + $(TAGS_FILES) $(LISP) + set x; \ + here=`pwd`; \ + if ($(ETAGS) --etags-include --version) >/dev/null 2>&1; then \ + include_option=--etags-include; \ + empty_fix=.; \ + else \ + include_option=--include; \ + empty_fix=; \ + fi; \ + list='$(SUBDIRS)'; for subdir in $$list; do \ + if test "$$subdir" = .; then :; else \ + test ! -f $$subdir/TAGS || \ + set "$$@" "$$include_option=$$here/$$subdir/TAGS"; \ + fi; \ + done; \ + list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | \ + $(AWK) '{ files[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in files) print i; }; }'`; \ + shift; \ + if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \ + test -n "$$unique" || unique=$$empty_fix; \ + if test $$# -gt 0; then \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + "$$@" $$unique; \ + else \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + $$unique; \ + fi; \ + fi +ctags: CTAGS +CTAGS: ctags-recursive $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \ + $(TAGS_FILES) $(LISP) + list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | \ + $(AWK) '{ files[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in files) print i; }; }'`; \ + test -z "$(CTAGS_ARGS)$$unique" \ + || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \ + $$unique + +GTAGS: + here=`$(am__cd) $(top_builddir) && pwd` \ + && $(am__cd) $(top_srcdir) \ + && gtags -i $(GTAGS_ARGS) "$$here" + +cscope: cscope.files + test ! -s cscope.files \ + || $(CSCOPE) -b -q $(AM_CSCOPEFLAGS) $(CSCOPEFLAGS) -i cscope.files $(CSCOPE_ARGS) + +clean-cscope: + -rm -f cscope.files + +cscope.files: clean-cscope cscopelist-recursive cscopelist + +cscopelist: cscopelist-recursive $(HEADERS) $(SOURCES) $(LISP) + list='$(SOURCES) $(HEADERS) $(LISP)'; \ + case "$(srcdir)" in \ + [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \ + *) sdir=$(subdir)/$(srcdir) ;; \ + esac; \ + for i in $$list; do \ + if test -f "$$i"; then \ + echo "$(subdir)/$$i"; \ + else \ + echo "$$sdir/$$i"; \ + fi; \ + done >> $(top_builddir)/cscope.files + +distclean-tags: + -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags + -rm -f cscope.out cscope.in.out cscope.po.out cscope.files + +distdir: $(DISTFILES) + $(am__remove_distdir) + test -d "$(distdir)" || mkdir "$(distdir)" + @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + list='$(DISTFILES)'; \ + dist_files=`for file in $$list; do echo $$file; done | \ + sed -e "s|^$$srcdirstrip/||;t" \ + -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \ + case $$dist_files in \ + */*) $(MKDIR_P) `echo "$$dist_files" | \ + sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \ + sort -u` ;; \ + esac; \ + for file in $$dist_files; do \ + if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \ + if test -d $$d/$$file; then \ + dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \ + if test -d "$(distdir)/$$file"; then \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \ + cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \ + else \ + test -f "$(distdir)/$$file" \ + || cp -p $$d/$$file "$(distdir)/$$file" \ + || exit 1; \ + fi; \ + done + @list='$(DIST_SUBDIRS)'; for subdir in $$list; do \ + if test "$$subdir" = .; then :; else \ + $(am__make_dryrun) \ + || test -d "$(distdir)/$$subdir" \ + || $(MKDIR_P) "$(distdir)/$$subdir" \ + || exit 1; \ + dir1=$$subdir; dir2="$(distdir)/$$subdir"; \ + $(am__relativize); \ + new_distdir=$$reldir; \ + dir1=$$subdir; dir2="$(top_distdir)"; \ + $(am__relativize); \ + new_top_distdir=$$reldir; \ + echo " (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) top_distdir="$$new_top_distdir" distdir="$$new_distdir" \\"; \ + echo " am__remove_distdir=: am__skip_length_check=: am__skip_mode_fix=: distdir)"; \ + ($(am__cd) $$subdir && \ + $(MAKE) $(AM_MAKEFLAGS) \ + top_distdir="$$new_top_distdir" \ + distdir="$$new_distdir" \ + am__remove_distdir=: \ + am__skip_length_check=: \ + am__skip_mode_fix=: \ + distdir) \ + || exit 1; \ + fi; \ + done + -test -n "$(am__skip_mode_fix)" \ + || find "$(distdir)" -type d ! -perm -755 \ + -exec chmod u+rwx,go+rx {} \; -o \ + ! -type d ! -perm -444 -links 1 -exec chmod a+r {} \; -o \ + ! -type d ! -perm -400 -exec chmod a+r {} \; -o \ + ! -type d ! -perm -444 -exec $(install_sh) -c -m a+r {} {} \; \ + || chmod -R a+r "$(distdir)" +dist-gzip: distdir + tardir=$(distdir) && $(am__tar) | GZIP=$(GZIP_ENV) gzip -c >$(distdir).tar.gz + $(am__post_remove_distdir) +dist-bzip2: distdir + tardir=$(distdir) && $(am__tar) | BZIP2=$${BZIP2--9} bzip2 -c >$(distdir).tar.bz2 + $(am__post_remove_distdir) + +dist-lzip: distdir + tardir=$(distdir) && $(am__tar) | lzip -c $${LZIP_OPT--9} >$(distdir).tar.lz + $(am__post_remove_distdir) + +dist-xz: distdir + tardir=$(distdir) && $(am__tar) | XZ_OPT=$${XZ_OPT--e} xz -c >$(distdir).tar.xz + $(am__post_remove_distdir) + +dist-tarZ: distdir + tardir=$(distdir) && $(am__tar) | compress -c >$(distdir).tar.Z + $(am__post_remove_distdir) + +dist-shar: distdir + shar $(distdir) | GZIP=$(GZIP_ENV) gzip -c >$(distdir).shar.gz + $(am__post_remove_distdir) +dist-zip: distdir + -rm -f $(distdir).zip + zip -rq $(distdir).zip $(distdir) + $(am__post_remove_distdir) + +dist dist-all: + $(MAKE) $(AM_MAKEFLAGS) $(DIST_TARGETS) am__post_remove_distdir='@:' + $(am__post_remove_distdir) + +# This target untars the dist file and tries a VPATH configuration. Then +# it guarantees that the distribution is self-contained by making another +# tarfile. +distcheck: dist + case '$(DIST_ARCHIVES)' in \ + *.tar.gz*) \ + GZIP=$(GZIP_ENV) gzip -dc $(distdir).tar.gz | $(am__untar) ;;\ + *.tar.bz2*) \ + bzip2 -dc $(distdir).tar.bz2 | $(am__untar) ;;\ + *.tar.lz*) \ + lzip -dc $(distdir).tar.lz | $(am__untar) ;;\ + *.tar.xz*) \ + xz -dc $(distdir).tar.xz | $(am__untar) ;;\ + *.tar.Z*) \ + uncompress -c $(distdir).tar.Z | $(am__untar) ;;\ + *.shar.gz*) \ + GZIP=$(GZIP_ENV) gzip -dc $(distdir).shar.gz | unshar ;;\ + *.zip*) \ + unzip $(distdir).zip ;;\ + esac + chmod -R a-w $(distdir) + chmod u+w $(distdir) + mkdir $(distdir)/_build $(distdir)/_inst + chmod a-w $(distdir) + test -d $(distdir)/_build || exit 0; \ + dc_install_base=`$(am__cd) $(distdir)/_inst && pwd | sed -e 's,^[^:\\/]:[\\/],/,'` \ + && dc_destdir="$${TMPDIR-/tmp}/am-dc-$$$$/" \ + && am__cwd=`pwd` \ + && $(am__cd) $(distdir)/_build \ + && ../configure --srcdir=.. --prefix="$$dc_install_base" \ + $(AM_DISTCHECK_CONFIGURE_FLAGS) \ + $(DISTCHECK_CONFIGURE_FLAGS) \ + && $(MAKE) $(AM_MAKEFLAGS) \ + && $(MAKE) $(AM_MAKEFLAGS) dvi \ + && $(MAKE) $(AM_MAKEFLAGS) check \ + && $(MAKE) $(AM_MAKEFLAGS) install \ + && $(MAKE) $(AM_MAKEFLAGS) installcheck \ + && $(MAKE) $(AM_MAKEFLAGS) uninstall \ + && $(MAKE) $(AM_MAKEFLAGS) distuninstallcheck_dir="$$dc_install_base" \ + distuninstallcheck \ + && chmod -R a-w "$$dc_install_base" \ + && ({ \ + (cd ../.. && umask 077 && mkdir "$$dc_destdir") \ + && $(MAKE) $(AM_MAKEFLAGS) DESTDIR="$$dc_destdir" install \ + && $(MAKE) $(AM_MAKEFLAGS) DESTDIR="$$dc_destdir" uninstall \ + && $(MAKE) $(AM_MAKEFLAGS) DESTDIR="$$dc_destdir" \ + distuninstallcheck_dir="$$dc_destdir" distuninstallcheck; \ + } || { rm -rf "$$dc_destdir"; exit 1; }) \ + && rm -rf "$$dc_destdir" \ + && $(MAKE) $(AM_MAKEFLAGS) dist \ + && rm -rf $(DIST_ARCHIVES) \ + && $(MAKE) $(AM_MAKEFLAGS) distcleancheck \ + && cd "$$am__cwd" \ + || exit 1 + $(am__post_remove_distdir) + @(echo "$(distdir) archives ready for distribution: "; \ + list='$(DIST_ARCHIVES)'; for i in $$list; do echo $$i; done) | \ + sed -e 1h -e 1s/./=/g -e 1p -e 1x -e '$$p' -e '$$x' +distuninstallcheck: + @test -n '$(distuninstallcheck_dir)' || { \ + echo 'ERROR: trying to run $@ with an empty' \ + '$$(distuninstallcheck_dir)' >&2; \ + exit 1; \ + }; \ + $(am__cd) '$(distuninstallcheck_dir)' || { \ + echo 'ERROR: cannot chdir into $(distuninstallcheck_dir)' >&2; \ + exit 1; \ + }; \ + test `$(am__distuninstallcheck_listfiles) | wc -l` -eq 0 \ + || { echo "ERROR: files left after uninstall:" ; \ + if test -n "$(DESTDIR)"; then \ + echo " (check DESTDIR support)"; \ + fi ; \ + $(distuninstallcheck_listfiles) ; \ + exit 1; } >&2 +distcleancheck: distclean + @if test '$(srcdir)' = . ; then \ + echo "ERROR: distcleancheck can only run from a VPATH build" ; \ + exit 1 ; \ + fi + @test `$(distcleancheck_listfiles) | wc -l` -eq 0 \ + || { echo "ERROR: files left in build directory after distclean:" ; \ + $(distcleancheck_listfiles) ; \ + exit 1; } >&2 +check-am: all-am +check: check-recursive +all-am: Makefile $(DATA) +installdirs: installdirs-recursive +installdirs-am: + for dir in "$(DESTDIR)$(docdir)" "$(DESTDIR)$(pkgconfigdir)"; do \ + test -z "$$dir" || $(MKDIR_P) "$$dir"; \ + done +install: install-recursive +install-exec: install-exec-recursive +install-data: install-data-recursive +uninstall: uninstall-recursive + +install-am: all-am + @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am + +installcheck: installcheck-recursive +install-strip: + if test -z '$(STRIP)'; then \ + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + install; \ + else \ + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \ + fi +mostlyclean-generic: + +clean-generic: + +distclean-generic: + -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES) + -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES) + +maintainer-clean-generic: + @echo "This command is intended for maintainers to use" + @echo "it deletes files that may require special tools to rebuild." +clean: clean-recursive + +clean-am: clean-generic clean-libtool mostlyclean-am + +distclean: distclean-recursive + -rm -f $(am__CONFIG_DISTCLEAN_FILES) + -rm -f Makefile +distclean-am: clean-am distclean-generic distclean-hdr \ + distclean-libtool distclean-tags + +dvi: dvi-recursive + +dvi-am: + +html: html-recursive + +html-am: + +info: info-recursive + +info-am: + +install-data-am: install-dist_docDATA install-pkgconfigDATA + +install-dvi: install-dvi-recursive + +install-dvi-am: + +install-exec-am: + +install-html: install-html-recursive + +install-html-am: + +install-info: install-info-recursive + +install-info-am: + +install-man: + +install-pdf: install-pdf-recursive + +install-pdf-am: + +install-ps: install-ps-recursive + +install-ps-am: + +installcheck-am: + +maintainer-clean: maintainer-clean-recursive + -rm -f $(am__CONFIG_DISTCLEAN_FILES) + -rm -rf $(top_srcdir)/autom4te.cache + -rm -f Makefile +maintainer-clean-am: distclean-am maintainer-clean-generic + +mostlyclean: mostlyclean-recursive + +mostlyclean-am: mostlyclean-generic mostlyclean-libtool + +pdf: pdf-recursive + +pdf-am: + +ps: ps-recursive + +ps-am: + +uninstall-am: uninstall-dist_docDATA uninstall-pkgconfigDATA + +.MAKE: $(RECURSIVE_CLEAN_TARGETS) $(RECURSIVE_TARGETS) \ + cscopelist-recursive ctags-recursive install-am install-strip \ + tags-recursive + +.PHONY: $(RECURSIVE_CLEAN_TARGETS) $(RECURSIVE_TARGETS) CTAGS GTAGS \ + all all-am am--refresh check check-am clean clean-cscope \ + clean-generic clean-libtool cscope cscopelist \ + cscopelist-recursive ctags ctags-recursive dist dist-all \ + dist-bzip2 dist-gzip dist-lzip dist-shar dist-tarZ dist-xz \ + dist-zip distcheck distclean distclean-generic distclean-hdr \ + distclean-libtool distclean-tags distcleancheck distdir \ + distuninstallcheck dvi dvi-am html html-am info info-am \ + install install-am install-data install-data-am \ + install-dist_docDATA install-dvi install-dvi-am install-exec \ + install-exec-am install-html install-html-am install-info \ + install-info-am install-man install-pdf install-pdf-am \ + install-pkgconfigDATA install-ps install-ps-am install-strip \ + installcheck installcheck-am installdirs installdirs-am \ + maintainer-clean maintainer-clean-generic mostlyclean \ + mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \ + tags tags-recursive uninstall uninstall-am \ + uninstall-dist_docDATA uninstall-pkgconfigDATA + + +# Tell versions [3.59,3.63) of GNU make to not export all variables. +# Otherwise a system limit (for SysV at least) may be exceeded. +.NOEXPORT: diff --git a/third-party/odb/libodb-2.4.0/NEWS b/third-party/odb/libodb-2.4.0/NEWS new file mode 100755 index 0000000..72d0f8b --- /dev/null +++ b/third-party/odb/libodb-2.4.0/NEWS @@ -0,0 +1 @@ +See the common NEWS file in the ODB compiler package. diff --git a/third-party/odb/libodb-2.4.0/README b/third-party/odb/libodb-2.4.0/README new file mode 100755 index 0000000..902e20b --- /dev/null +++ b/third-party/odb/libodb-2.4.0/README @@ -0,0 +1,20 @@ +ODB is an object-relational mapping (ORM) system for C++. It provides +tools, APIs, and library support that allow you to persist C++ objects +to a relational database (RDBMS) without having to deal with tables, +columns, or SQL and without manually writing any of the mapping code. +For more information see: + +http://www.codesynthesis.com/products/odb/ + +This package contains the common ODB runtime library. Every application +that includes code generated by the ODB compiler will need to link to +this library. + +See the NEWS file for the user-visible changes from the previous release. + +See the LICENSE file for distribution conditions. + +See the INSTALL file for prerequisites and installation instructions. + +Send questions, bug reports, or any other feedback to the +odb-users@codesynthesis.com mailing list. diff --git a/third-party/odb/libodb-2.4.0/aclocal.m4 b/third-party/odb/libodb-2.4.0/aclocal.m4 new file mode 100755 index 0000000..2361c38 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/aclocal.m4 @@ -0,0 +1,1031 @@ +# generated automatically by aclocal 1.12.6 -*- Autoconf -*- + +# Copyright (C) 1996-2012 Free Software Foundation, Inc. + +# This file is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY, to the extent permitted by law; without +# even the implied warranty of MERCHANTABILITY or FITNESS FOR A +# PARTICULAR PURPOSE. + +m4_ifndef([AC_AUTOCONF_VERSION], + [m4_copy([m4_PACKAGE_VERSION], [AC_AUTOCONF_VERSION])])dnl +m4_if(m4_defn([AC_AUTOCONF_VERSION]), [2.69],, +[m4_warning([this file was generated for autoconf 2.69. +You have another version of autoconf. It may work, but is not guaranteed to. +If you have problems, you may need to regenerate the build system entirely. +To do so, use the procedure documented by the package, typically 'autoreconf'.])]) + +# Copyright (C) 2002-2012 Free Software Foundation, Inc. +# +# This file is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# AM_AUTOMAKE_VERSION(VERSION) +# ---------------------------- +# Automake X.Y traces this macro to ensure aclocal.m4 has been +# generated from the m4 files accompanying Automake X.Y. +# (This private macro should not be called outside this file.) +AC_DEFUN([AM_AUTOMAKE_VERSION], +[am__api_version='1.12' +dnl Some users find AM_AUTOMAKE_VERSION and mistake it for a way to +dnl require some minimum version. Point them to the right macro. +m4_if([$1], [1.12.6], [], + [AC_FATAL([Do not call $0, use AM_INIT_AUTOMAKE([$1]).])])dnl +]) + +# _AM_AUTOCONF_VERSION(VERSION) +# ----------------------------- +# aclocal traces this macro to find the Autoconf version. +# This is a private macro too. Using m4_define simplifies +# the logic in aclocal, which can simply ignore this definition. +m4_define([_AM_AUTOCONF_VERSION], []) + +# AM_SET_CURRENT_AUTOMAKE_VERSION +# ------------------------------- +# Call AM_AUTOMAKE_VERSION and AM_AUTOMAKE_VERSION so they can be traced. +# This function is AC_REQUIREd by AM_INIT_AUTOMAKE. +AC_DEFUN([AM_SET_CURRENT_AUTOMAKE_VERSION], +[AM_AUTOMAKE_VERSION([1.12.6])dnl +m4_ifndef([AC_AUTOCONF_VERSION], + [m4_copy([m4_PACKAGE_VERSION], [AC_AUTOCONF_VERSION])])dnl +_AM_AUTOCONF_VERSION(m4_defn([AC_AUTOCONF_VERSION]))]) + +# Copyright (C) 2011-2012 Free Software Foundation, Inc. +# +# This file is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# AM_PROG_AR([ACT-IF-FAIL]) +# ------------------------- +# Try to determine the archiver interface, and trigger the ar-lib wrapper +# if it is needed. If the detection of archiver interface fails, run +# ACT-IF-FAIL (default is to abort configure with a proper error message). +AC_DEFUN([AM_PROG_AR], +[AC_BEFORE([$0], [LT_INIT])dnl +AC_BEFORE([$0], [AC_PROG_LIBTOOL])dnl +AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl +AC_REQUIRE_AUX_FILE([ar-lib])dnl +AC_CHECK_TOOLS([AR], [ar lib "link -lib"], [false]) +: ${AR=ar} + +AC_CACHE_CHECK([the archiver ($AR) interface], [am_cv_ar_interface], + [am_cv_ar_interface=ar + AC_COMPILE_IFELSE([AC_LANG_SOURCE([[int some_variable = 0;]])], + [am_ar_try='$AR cru libconftest.a conftest.$ac_objext >&AS_MESSAGE_LOG_FD' + AC_TRY_EVAL([am_ar_try]) + if test "$ac_status" -eq 0; then + am_cv_ar_interface=ar + else + am_ar_try='$AR -NOLOGO -OUT:conftest.lib conftest.$ac_objext >&AS_MESSAGE_LOG_FD' + AC_TRY_EVAL([am_ar_try]) + if test "$ac_status" -eq 0; then + am_cv_ar_interface=lib + else + am_cv_ar_interface=unknown + fi + fi + rm -f conftest.lib libconftest.a + ]) + ]) + +case $am_cv_ar_interface in +ar) + ;; +lib) + # Microsoft lib, so override with the ar-lib wrapper script. + # FIXME: It is wrong to rewrite AR. + # But if we don't then we get into trouble of one sort or another. + # A longer-term fix would be to have automake use am__AR in this case, + # and then we could set am__AR="$am_aux_dir/ar-lib \$(AR)" or something + # similar. + AR="$am_aux_dir/ar-lib $AR" + ;; +unknown) + m4_default([$1], + [AC_MSG_ERROR([could not determine $AR interface])]) + ;; +esac +AC_SUBST([AR])dnl +]) + +# AM_AUX_DIR_EXPAND -*- Autoconf -*- + +# Copyright (C) 2001-2012 Free Software Foundation, Inc. +# +# This file is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# For projects using AC_CONFIG_AUX_DIR([foo]), Autoconf sets +# $ac_aux_dir to '$srcdir/foo'. In other projects, it is set to +# '$srcdir', '$srcdir/..', or '$srcdir/../..'. +# +# Of course, Automake must honor this variable whenever it calls a +# tool from the auxiliary directory. The problem is that $srcdir (and +# therefore $ac_aux_dir as well) can be either absolute or relative, +# depending on how configure is run. This is pretty annoying, since +# it makes $ac_aux_dir quite unusable in subdirectories: in the top +# source directory, any form will work fine, but in subdirectories a +# relative path needs to be adjusted first. +# +# $ac_aux_dir/missing +# fails when called from a subdirectory if $ac_aux_dir is relative +# $top_srcdir/$ac_aux_dir/missing +# fails if $ac_aux_dir is absolute, +# fails when called from a subdirectory in a VPATH build with +# a relative $ac_aux_dir +# +# The reason of the latter failure is that $top_srcdir and $ac_aux_dir +# are both prefixed by $srcdir. In an in-source build this is usually +# harmless because $srcdir is '.', but things will broke when you +# start a VPATH build or use an absolute $srcdir. +# +# So we could use something similar to $top_srcdir/$ac_aux_dir/missing, +# iff we strip the leading $srcdir from $ac_aux_dir. That would be: +# am_aux_dir='\$(top_srcdir)/'`expr "$ac_aux_dir" : "$srcdir//*\(.*\)"` +# and then we would define $MISSING as +# MISSING="\${SHELL} $am_aux_dir/missing" +# This will work as long as MISSING is not called from configure, because +# unfortunately $(top_srcdir) has no meaning in configure. +# However there are other variables, like CC, which are often used in +# configure, and could therefore not use this "fixed" $ac_aux_dir. +# +# Another solution, used here, is to always expand $ac_aux_dir to an +# absolute PATH. The drawback is that using absolute paths prevent a +# configured tree to be moved without reconfiguration. + +AC_DEFUN([AM_AUX_DIR_EXPAND], +[dnl Rely on autoconf to set up CDPATH properly. +AC_PREREQ([2.50])dnl +# expand $ac_aux_dir to an absolute path +am_aux_dir=`cd $ac_aux_dir && pwd` +]) + +# AM_CONDITIONAL -*- Autoconf -*- + +# Copyright (C) 1997-2012 Free Software Foundation, Inc. +# +# This file is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# AM_CONDITIONAL(NAME, SHELL-CONDITION) +# ------------------------------------- +# Define a conditional. +AC_DEFUN([AM_CONDITIONAL], +[AC_PREREQ([2.52])dnl + m4_if([$1], [TRUE], [AC_FATAL([$0: invalid condition: $1])], + [$1], [FALSE], [AC_FATAL([$0: invalid condition: $1])])dnl +AC_SUBST([$1_TRUE])dnl +AC_SUBST([$1_FALSE])dnl +_AM_SUBST_NOTMAKE([$1_TRUE])dnl +_AM_SUBST_NOTMAKE([$1_FALSE])dnl +m4_define([_AM_COND_VALUE_$1], [$2])dnl +if $2; then + $1_TRUE= + $1_FALSE='#' +else + $1_TRUE='#' + $1_FALSE= +fi +AC_CONFIG_COMMANDS_PRE( +[if test -z "${$1_TRUE}" && test -z "${$1_FALSE}"; then + AC_MSG_ERROR([[conditional "$1" was never defined. +Usually this means the macro was only invoked conditionally.]]) +fi])]) + +# Copyright (C) 1999-2012 Free Software Foundation, Inc. +# +# This file is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + + +# There are a few dirty hacks below to avoid letting 'AC_PROG_CC' be +# written in clear, in which case automake, when reading aclocal.m4, +# will think it sees a *use*, and therefore will trigger all it's +# C support machinery. Also note that it means that autoscan, seeing +# CC etc. in the Makefile, will ask for an AC_PROG_CC use... + + +# _AM_DEPENDENCIES(NAME) +# ---------------------- +# See how the compiler implements dependency checking. +# NAME is "CC", "CXX", "OBJC", "OBJCXX", "UPC", or "GJC". +# We try a few techniques and use that to set a single cache variable. +# +# We don't AC_REQUIRE the corresponding AC_PROG_CC since the latter was +# modified to invoke _AM_DEPENDENCIES(CC); we would have a circular +# dependency, and given that the user is not expected to run this macro, +# just rely on AC_PROG_CC. +AC_DEFUN([_AM_DEPENDENCIES], +[AC_REQUIRE([AM_SET_DEPDIR])dnl +AC_REQUIRE([AM_OUTPUT_DEPENDENCY_COMMANDS])dnl +AC_REQUIRE([AM_MAKE_INCLUDE])dnl +AC_REQUIRE([AM_DEP_TRACK])dnl + +m4_if([$1], [CC], [depcc="$CC" am_compiler_list=], + [$1], [CXX], [depcc="$CXX" am_compiler_list=], + [$1], [OBJC], [depcc="$OBJC" am_compiler_list='gcc3 gcc'], + [$1], [OBJCXX], [depcc="$OBJCXX" am_compiler_list='gcc3 gcc'], + [$1], [UPC], [depcc="$UPC" am_compiler_list=], + [$1], [GCJ], [depcc="$GCJ" am_compiler_list='gcc3 gcc'], + [depcc="$$1" am_compiler_list=]) + +AC_CACHE_CHECK([dependency style of $depcc], + [am_cv_$1_dependencies_compiler_type], +[if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then + # We make a subdir and do the tests there. Otherwise we can end up + # making bogus files that we don't know about and never remove. For + # instance it was reported that on HP-UX the gcc test will end up + # making a dummy file named 'D' -- because '-MD' means "put the output + # in D". + rm -rf conftest.dir + mkdir conftest.dir + # Copy depcomp to subdir because otherwise we won't find it if we're + # using a relative directory. + cp "$am_depcomp" conftest.dir + cd conftest.dir + # We will build objects and dependencies in a subdirectory because + # it helps to detect inapplicable dependency modes. For instance + # both Tru64's cc and ICC support -MD to output dependencies as a + # side effect of compilation, but ICC will put the dependencies in + # the current directory while Tru64 will put them in the object + # directory. + mkdir sub + + am_cv_$1_dependencies_compiler_type=none + if test "$am_compiler_list" = ""; then + am_compiler_list=`sed -n ['s/^#*\([a-zA-Z0-9]*\))$/\1/p'] < ./depcomp` + fi + am__universal=false + m4_case([$1], [CC], + [case " $depcc " in #( + *\ -arch\ *\ -arch\ *) am__universal=true ;; + esac], + [CXX], + [case " $depcc " in #( + *\ -arch\ *\ -arch\ *) am__universal=true ;; + esac]) + + for depmode in $am_compiler_list; do + # Setup a source with many dependencies, because some compilers + # like to wrap large dependency lists on column 80 (with \), and + # we should not choose a depcomp mode which is confused by this. + # + # We need to recreate these files for each test, as the compiler may + # overwrite some of them when testing with obscure command lines. + # This happens at least with the AIX C compiler. + : > sub/conftest.c + for i in 1 2 3 4 5 6; do + echo '#include "conftst'$i'.h"' >> sub/conftest.c + # Using ": > sub/conftst$i.h" creates only sub/conftst1.h with + # Solaris 10 /bin/sh. + echo '/* dummy */' > sub/conftst$i.h + done + echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf + + # We check with '-c' and '-o' for the sake of the "dashmstdout" + # mode. It turns out that the SunPro C++ compiler does not properly + # handle '-M -o', and we need to detect this. Also, some Intel + # versions had trouble with output in subdirs. + am__obj=sub/conftest.${OBJEXT-o} + am__minus_obj="-o $am__obj" + case $depmode in + gcc) + # This depmode causes a compiler race in universal mode. + test "$am__universal" = false || continue + ;; + nosideeffect) + # After this tag, mechanisms are not by side-effect, so they'll + # only be used when explicitly requested. + if test "x$enable_dependency_tracking" = xyes; then + continue + else + break + fi + ;; + msvc7 | msvc7msys | msvisualcpp | msvcmsys) + # This compiler won't grok '-c -o', but also, the minuso test has + # not run yet. These depmodes are late enough in the game, and + # so weak that their functioning should not be impacted. + am__obj=conftest.${OBJEXT-o} + am__minus_obj= + ;; + none) break ;; + esac + if depmode=$depmode \ + source=sub/conftest.c object=$am__obj \ + depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \ + $SHELL ./depcomp $depcc -c $am__minus_obj sub/conftest.c \ + >/dev/null 2>conftest.err && + grep sub/conftst1.h sub/conftest.Po > /dev/null 2>&1 && + grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 && + grep $am__obj sub/conftest.Po > /dev/null 2>&1 && + ${MAKE-make} -s -f confmf > /dev/null 2>&1; then + # icc doesn't choke on unknown options, it will just issue warnings + # or remarks (even with -Werror). So we grep stderr for any message + # that says an option was ignored or not supported. + # When given -MP, icc 7.0 and 7.1 complain thusly: + # icc: Command line warning: ignoring option '-M'; no argument required + # The diagnosis changed in icc 8.0: + # icc: Command line remark: option '-MP' not supported + if (grep 'ignoring option' conftest.err || + grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else + am_cv_$1_dependencies_compiler_type=$depmode + break + fi + fi + done + + cd .. + rm -rf conftest.dir +else + am_cv_$1_dependencies_compiler_type=none +fi +]) +AC_SUBST([$1DEPMODE], [depmode=$am_cv_$1_dependencies_compiler_type]) +AM_CONDITIONAL([am__fastdep$1], [ + test "x$enable_dependency_tracking" != xno \ + && test "$am_cv_$1_dependencies_compiler_type" = gcc3]) +]) + + +# AM_SET_DEPDIR +# ------------- +# Choose a directory name for dependency files. +# This macro is AC_REQUIREd in _AM_DEPENDENCIES. +AC_DEFUN([AM_SET_DEPDIR], +[AC_REQUIRE([AM_SET_LEADING_DOT])dnl +AC_SUBST([DEPDIR], ["${am__leading_dot}deps"])dnl +]) + + +# AM_DEP_TRACK +# ------------ +AC_DEFUN([AM_DEP_TRACK], +[AC_ARG_ENABLE([dependency-tracking], [dnl +AS_HELP_STRING( + [--enable-dependency-tracking], + [do not reject slow dependency extractors]) +AS_HELP_STRING( + [--disable-dependency-tracking], + [speeds up one-time build])]) +if test "x$enable_dependency_tracking" != xno; then + am_depcomp="$ac_aux_dir/depcomp" + AMDEPBACKSLASH='\' + am__nodep='_no' +fi +AM_CONDITIONAL([AMDEP], [test "x$enable_dependency_tracking" != xno]) +AC_SUBST([AMDEPBACKSLASH])dnl +_AM_SUBST_NOTMAKE([AMDEPBACKSLASH])dnl +AC_SUBST([am__nodep])dnl +_AM_SUBST_NOTMAKE([am__nodep])dnl +]) + +# Generate code to set up dependency tracking. -*- Autoconf -*- + +# Copyright (C) 1999-2012 Free Software Foundation, Inc. +# +# This file is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + + +# _AM_OUTPUT_DEPENDENCY_COMMANDS +# ------------------------------ +AC_DEFUN([_AM_OUTPUT_DEPENDENCY_COMMANDS], +[{ + # Autoconf 2.62 quotes --file arguments for eval, but not when files + # are listed without --file. Let's play safe and only enable the eval + # if we detect the quoting. + case $CONFIG_FILES in + *\'*) eval set x "$CONFIG_FILES" ;; + *) set x $CONFIG_FILES ;; + esac + shift + for mf + do + # Strip MF so we end up with the name of the file. + mf=`echo "$mf" | sed -e 's/:.*$//'` + # Check whether this is an Automake generated Makefile or not. + # We used to match only the files named 'Makefile.in', but + # some people rename them; so instead we look at the file content. + # Grep'ing the first line is not enough: some people post-process + # each Makefile.in and add a new line on top of each file to say so. + # Grep'ing the whole file is not good either: AIX grep has a line + # limit of 2048, but all sed's we know have understand at least 4000. + if sed -n 's,^#.*generated by automake.*,X,p' "$mf" | grep X >/dev/null 2>&1; then + dirpart=`AS_DIRNAME("$mf")` + else + continue + fi + # Extract the definition of DEPDIR, am__include, and am__quote + # from the Makefile without running 'make'. + DEPDIR=`sed -n 's/^DEPDIR = //p' < "$mf"` + test -z "$DEPDIR" && continue + am__include=`sed -n 's/^am__include = //p' < "$mf"` + test -z "am__include" && continue + am__quote=`sed -n 's/^am__quote = //p' < "$mf"` + # Find all dependency output files, they are included files with + # $(DEPDIR) in their names. We invoke sed twice because it is the + # simplest approach to changing $(DEPDIR) to its actual value in the + # expansion. + for file in `sed -n " + s/^$am__include $am__quote\(.*(DEPDIR).*\)$am__quote"'$/\1/p' <"$mf" | \ + sed -e 's/\$(DEPDIR)/'"$DEPDIR"'/g'`; do + # Make sure the directory exists. + test -f "$dirpart/$file" && continue + fdir=`AS_DIRNAME(["$file"])` + AS_MKDIR_P([$dirpart/$fdir]) + # echo "creating $dirpart/$file" + echo '# dummy' > "$dirpart/$file" + done + done +} +])# _AM_OUTPUT_DEPENDENCY_COMMANDS + + +# AM_OUTPUT_DEPENDENCY_COMMANDS +# ----------------------------- +# This macro should only be invoked once -- use via AC_REQUIRE. +# +# This code is only required when automatic dependency tracking +# is enabled. FIXME. This creates each '.P' file that we will +# need in order to bootstrap the dependency handling code. +AC_DEFUN([AM_OUTPUT_DEPENDENCY_COMMANDS], +[AC_CONFIG_COMMANDS([depfiles], + [test x"$AMDEP_TRUE" != x"" || _AM_OUTPUT_DEPENDENCY_COMMANDS], + [AMDEP_TRUE="$AMDEP_TRUE" ac_aux_dir="$ac_aux_dir"]) +]) + +# Do all the work for Automake. -*- Autoconf -*- + +# Copyright (C) 1996-2012 Free Software Foundation, Inc. +# +# This file is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# This macro actually does too much. Some checks are only needed if +# your package does certain things. But this isn't really a big deal. + +# AM_INIT_AUTOMAKE(PACKAGE, VERSION, [NO-DEFINE]) +# AM_INIT_AUTOMAKE([OPTIONS]) +# ----------------------------------------------- +# The call with PACKAGE and VERSION arguments is the old style +# call (pre autoconf-2.50), which is being phased out. PACKAGE +# and VERSION should now be passed to AC_INIT and removed from +# the call to AM_INIT_AUTOMAKE. +# We support both call styles for the transition. After +# the next Automake release, Autoconf can make the AC_INIT +# arguments mandatory, and then we can depend on a new Autoconf +# release and drop the old call support. +AC_DEFUN([AM_INIT_AUTOMAKE], +[AC_PREREQ([2.62])dnl +dnl Autoconf wants to disallow AM_ names. We explicitly allow +dnl the ones we care about. +m4_pattern_allow([^AM_[A-Z]+FLAGS$])dnl +AC_REQUIRE([AM_SET_CURRENT_AUTOMAKE_VERSION])dnl +AC_REQUIRE([AC_PROG_INSTALL])dnl +if test "`cd $srcdir && pwd`" != "`pwd`"; then + # Use -I$(srcdir) only when $(srcdir) != ., so that make's output + # is not polluted with repeated "-I." + AC_SUBST([am__isrc], [' -I$(srcdir)'])_AM_SUBST_NOTMAKE([am__isrc])dnl + # test to see if srcdir already configured + if test -f $srcdir/config.status; then + AC_MSG_ERROR([source directory already configured; run "make distclean" there first]) + fi +fi + +# test whether we have cygpath +if test -z "$CYGPATH_W"; then + if (cygpath --version) >/dev/null 2>/dev/null; then + CYGPATH_W='cygpath -w' + else + CYGPATH_W=echo + fi +fi +AC_SUBST([CYGPATH_W]) + +# Define the identity of the package. +dnl Distinguish between old-style and new-style calls. +m4_ifval([$2], +[AC_DIAGNOSE([obsolete], +[$0: two- and three-arguments forms are deprecated. For more info, see: +http://www.gnu.org/software/automake/manual/automake.html#Modernize-AM_INIT_AUTOMAKE-invocation]) +m4_ifval([$3], [_AM_SET_OPTION([no-define])])dnl + AC_SUBST([PACKAGE], [$1])dnl + AC_SUBST([VERSION], [$2])], +[_AM_SET_OPTIONS([$1])dnl +dnl Diagnose old-style AC_INIT with new-style AM_AUTOMAKE_INIT. +m4_if( + m4_ifdef([AC_PACKAGE_NAME], [ok]):m4_ifdef([AC_PACKAGE_VERSION], [ok]), + [ok:ok],, + [m4_fatal([AC_INIT should be called with package and version arguments])])dnl + AC_SUBST([PACKAGE], ['AC_PACKAGE_TARNAME'])dnl + AC_SUBST([VERSION], ['AC_PACKAGE_VERSION'])])dnl + +_AM_IF_OPTION([no-define],, +[AC_DEFINE_UNQUOTED([PACKAGE], ["$PACKAGE"], [Name of package]) + AC_DEFINE_UNQUOTED([VERSION], ["$VERSION"], [Version number of package])])dnl + +# Some tools Automake needs. +AC_REQUIRE([AM_SANITY_CHECK])dnl +AC_REQUIRE([AC_ARG_PROGRAM])dnl +AM_MISSING_PROG([ACLOCAL], [aclocal-${am__api_version}]) +AM_MISSING_PROG([AUTOCONF], [autoconf]) +AM_MISSING_PROG([AUTOMAKE], [automake-${am__api_version}]) +AM_MISSING_PROG([AUTOHEADER], [autoheader]) +AM_MISSING_PROG([MAKEINFO], [makeinfo]) +AC_REQUIRE([AM_PROG_INSTALL_SH])dnl +AC_REQUIRE([AM_PROG_INSTALL_STRIP])dnl +AC_REQUIRE([AC_PROG_MKDIR_P])dnl +# For better backward compatibility. To be removed once Automake 1.9.x +# dies out for good. For more background, see: +# +# +AC_SUBST([mkdir_p], ['$(MKDIR_P)']) +# We need awk for the "check" target. The system "awk" is bad on +# some platforms. +AC_REQUIRE([AC_PROG_AWK])dnl +AC_REQUIRE([AC_PROG_MAKE_SET])dnl +AC_REQUIRE([AM_SET_LEADING_DOT])dnl +_AM_IF_OPTION([tar-ustar], [_AM_PROG_TAR([ustar])], + [_AM_IF_OPTION([tar-pax], [_AM_PROG_TAR([pax])], + [_AM_PROG_TAR([v7])])]) +_AM_IF_OPTION([no-dependencies],, +[AC_PROVIDE_IFELSE([AC_PROG_CC], + [_AM_DEPENDENCIES([CC])], + [m4_define([AC_PROG_CC], + m4_defn([AC_PROG_CC])[_AM_DEPENDENCIES([CC])])])dnl +AC_PROVIDE_IFELSE([AC_PROG_CXX], + [_AM_DEPENDENCIES([CXX])], + [m4_define([AC_PROG_CXX], + m4_defn([AC_PROG_CXX])[_AM_DEPENDENCIES([CXX])])])dnl +AC_PROVIDE_IFELSE([AC_PROG_OBJC], + [_AM_DEPENDENCIES([OBJC])], + [m4_define([AC_PROG_OBJC], + m4_defn([AC_PROG_OBJC])[_AM_DEPENDENCIES([OBJC])])])dnl +dnl Support for Objective C++ was only introduced in Autoconf 2.65, +dnl but we still cater to Autoconf 2.62. +m4_ifdef([AC_PROG_OBJCXX], +[AC_PROVIDE_IFELSE([AC_PROG_OBJCXX], + [_AM_DEPENDENCIES([OBJCXX])], + [m4_define([AC_PROG_OBJCXX], + m4_defn([AC_PROG_OBJCXX])[_AM_DEPENDENCIES([OBJCXX])])])])dnl +]) +_AM_IF_OPTION([silent-rules], [AC_REQUIRE([AM_SILENT_RULES])])dnl +dnl The 'parallel-tests' driver may need to know about EXEEXT, so add the +dnl 'am__EXEEXT' conditional if _AM_COMPILER_EXEEXT was seen. This macro +dnl is hooked onto _AC_COMPILER_EXEEXT early, see below. +AC_CONFIG_COMMANDS_PRE(dnl +[m4_provide_if([_AM_COMPILER_EXEEXT], + [AM_CONDITIONAL([am__EXEEXT], [test -n "$EXEEXT"])])])dnl +]) + +dnl Hook into '_AC_COMPILER_EXEEXT' early to learn its expansion. Do not +dnl add the conditional right here, as _AC_COMPILER_EXEEXT may be further +dnl mangled by Autoconf and run in a shell conditional statement. +m4_define([_AC_COMPILER_EXEEXT], +m4_defn([_AC_COMPILER_EXEEXT])[m4_provide([_AM_COMPILER_EXEEXT])]) + + +# When config.status generates a header, we must update the stamp-h file. +# This file resides in the same directory as the config header +# that is generated. The stamp files are numbered to have different names. + +# Autoconf calls _AC_AM_CONFIG_HEADER_HOOK (when defined) in the +# loop where config.status creates the headers, so we can generate +# our stamp files there. +AC_DEFUN([_AC_AM_CONFIG_HEADER_HOOK], +[# Compute $1's index in $config_headers. +_am_arg=$1 +_am_stamp_count=1 +for _am_header in $config_headers :; do + case $_am_header in + $_am_arg | $_am_arg:* ) + break ;; + * ) + _am_stamp_count=`expr $_am_stamp_count + 1` ;; + esac +done +echo "timestamp for $_am_arg" >`AS_DIRNAME(["$_am_arg"])`/stamp-h[]$_am_stamp_count]) + +# Copyright (C) 2001-2012 Free Software Foundation, Inc. +# +# This file is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# AM_PROG_INSTALL_SH +# ------------------ +# Define $install_sh. +AC_DEFUN([AM_PROG_INSTALL_SH], +[AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl +if test x"${install_sh}" != xset; then + case $am_aux_dir in + *\ * | *\ *) + install_sh="\${SHELL} '$am_aux_dir/install-sh'" ;; + *) + install_sh="\${SHELL} $am_aux_dir/install-sh" + esac +fi +AC_SUBST([install_sh])]) + +# Copyright (C) 2003-2012 Free Software Foundation, Inc. +# +# This file is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# Check whether the underlying file-system supports filenames +# with a leading dot. For instance MS-DOS doesn't. +AC_DEFUN([AM_SET_LEADING_DOT], +[rm -rf .tst 2>/dev/null +mkdir .tst 2>/dev/null +if test -d .tst; then + am__leading_dot=. +else + am__leading_dot=_ +fi +rmdir .tst 2>/dev/null +AC_SUBST([am__leading_dot])]) + +# Check to see how 'make' treats includes. -*- Autoconf -*- + +# Copyright (C) 2001-2012 Free Software Foundation, Inc. +# +# This file is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# AM_MAKE_INCLUDE() +# ----------------- +# Check to see how make treats includes. +AC_DEFUN([AM_MAKE_INCLUDE], +[am_make=${MAKE-make} +cat > confinc << 'END' +am__doit: + @echo this is the am__doit target +.PHONY: am__doit +END +# If we don't find an include directive, just comment out the code. +AC_MSG_CHECKING([for style of include used by $am_make]) +am__include="#" +am__quote= +_am_result=none +# First try GNU make style include. +echo "include confinc" > confmf +# Ignore all kinds of additional output from 'make'. +case `$am_make -s -f confmf 2> /dev/null` in #( +*the\ am__doit\ target*) + am__include=include + am__quote= + _am_result=GNU + ;; +esac +# Now try BSD make style include. +if test "$am__include" = "#"; then + echo '.include "confinc"' > confmf + case `$am_make -s -f confmf 2> /dev/null` in #( + *the\ am__doit\ target*) + am__include=.include + am__quote="\"" + _am_result=BSD + ;; + esac +fi +AC_SUBST([am__include]) +AC_SUBST([am__quote]) +AC_MSG_RESULT([$_am_result]) +rm -f confinc confmf +]) + +# Fake the existence of programs that GNU maintainers use. -*- Autoconf -*- + +# Copyright (C) 1997-2012 Free Software Foundation, Inc. +# +# This file is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# AM_MISSING_PROG(NAME, PROGRAM) +# ------------------------------ +AC_DEFUN([AM_MISSING_PROG], +[AC_REQUIRE([AM_MISSING_HAS_RUN]) +$1=${$1-"${am_missing_run}$2"} +AC_SUBST($1)]) + +# AM_MISSING_HAS_RUN +# ------------------ +# Define MISSING if not defined so far and test if it supports --run. +# If it does, set am_missing_run to use it, otherwise, to nothing. +AC_DEFUN([AM_MISSING_HAS_RUN], +[AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl +AC_REQUIRE_AUX_FILE([missing])dnl +if test x"${MISSING+set}" != xset; then + case $am_aux_dir in + *\ * | *\ *) + MISSING="\${SHELL} \"$am_aux_dir/missing\"" ;; + *) + MISSING="\${SHELL} $am_aux_dir/missing" ;; + esac +fi +# Use eval to expand $SHELL +if eval "$MISSING --run true"; then + am_missing_run="$MISSING --run " +else + am_missing_run= + AC_MSG_WARN(['missing' script is too old or missing]) +fi +]) + +# Helper functions for option handling. -*- Autoconf -*- + +# Copyright (C) 2001-2012 Free Software Foundation, Inc. +# +# This file is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# _AM_MANGLE_OPTION(NAME) +# ----------------------- +AC_DEFUN([_AM_MANGLE_OPTION], +[[_AM_OPTION_]m4_bpatsubst($1, [[^a-zA-Z0-9_]], [_])]) + +# _AM_SET_OPTION(NAME) +# -------------------- +# Set option NAME. Presently that only means defining a flag for this option. +AC_DEFUN([_AM_SET_OPTION], +[m4_define(_AM_MANGLE_OPTION([$1]), [1])]) + +# _AM_SET_OPTIONS(OPTIONS) +# ------------------------ +# OPTIONS is a space-separated list of Automake options. +AC_DEFUN([_AM_SET_OPTIONS], +[m4_foreach_w([_AM_Option], [$1], [_AM_SET_OPTION(_AM_Option)])]) + +# _AM_IF_OPTION(OPTION, IF-SET, [IF-NOT-SET]) +# ------------------------------------------- +# Execute IF-SET if OPTION is set, IF-NOT-SET otherwise. +AC_DEFUN([_AM_IF_OPTION], +[m4_ifset(_AM_MANGLE_OPTION([$1]), [$2], [$3])]) + +# Copyright (C) 2001-2012 Free Software Foundation, Inc. +# +# This file is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# AM_RUN_LOG(COMMAND) +# ------------------- +# Run COMMAND, save the exit status in ac_status, and log it. +# (This has been adapted from Autoconf's _AC_RUN_LOG macro.) +AC_DEFUN([AM_RUN_LOG], +[{ echo "$as_me:$LINENO: $1" >&AS_MESSAGE_LOG_FD + ($1) >&AS_MESSAGE_LOG_FD 2>&AS_MESSAGE_LOG_FD + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&AS_MESSAGE_LOG_FD + (exit $ac_status); }]) + +# Check to make sure that the build environment is sane. -*- Autoconf -*- + +# Copyright (C) 1996-2012 Free Software Foundation, Inc. +# +# This file is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# AM_SANITY_CHECK +# --------------- +AC_DEFUN([AM_SANITY_CHECK], +[AC_MSG_CHECKING([whether build environment is sane]) +# Reject unsafe characters in $srcdir or the absolute working directory +# name. Accept space and tab only in the latter. +am_lf=' +' +case `pwd` in + *[[\\\"\#\$\&\'\`$am_lf]]*) + AC_MSG_ERROR([unsafe absolute working directory name]);; +esac +case $srcdir in + *[[\\\"\#\$\&\'\`$am_lf\ \ ]]*) + AC_MSG_ERROR([unsafe srcdir value: '$srcdir']);; +esac + +# Do 'set' in a subshell so we don't clobber the current shell's +# arguments. Must try -L first in case configure is actually a +# symlink; some systems play weird games with the mod time of symlinks +# (eg FreeBSD returns the mod time of the symlink's containing +# directory). +if ( + am_has_slept=no + for am_try in 1 2; do + echo "timestamp, slept: $am_has_slept" > conftest.file + set X `ls -Lt "$srcdir/configure" conftest.file 2> /dev/null` + if test "$[*]" = "X"; then + # -L didn't work. + set X `ls -t "$srcdir/configure" conftest.file` + fi + if test "$[*]" != "X $srcdir/configure conftest.file" \ + && test "$[*]" != "X conftest.file $srcdir/configure"; then + + # If neither matched, then we have a broken ls. This can happen + # if, for instance, CONFIG_SHELL is bash and it inherits a + # broken ls alias from the environment. This has actually + # happened. Such a system could not be considered "sane". + AC_MSG_ERROR([ls -t appears to fail. Make sure there is not a broken + alias in your environment]) + fi + if test "$[2]" = conftest.file || test $am_try -eq 2; then + break + fi + # Just in case. + sleep 1 + am_has_slept=yes + done + test "$[2]" = conftest.file + ) +then + # Ok. + : +else + AC_MSG_ERROR([newly created file is older than distributed files! +Check your system clock]) +fi +AC_MSG_RESULT([yes]) +# If we didn't sleep, we still need to ensure time stamps of config.status and +# generated files are strictly newer. +am_sleep_pid= +if grep 'slept: no' conftest.file >/dev/null 2>&1; then + ( sleep 1 ) & + am_sleep_pid=$! +fi +AC_CONFIG_COMMANDS_PRE( + [AC_MSG_CHECKING([that generated files are newer than configure]) + if test -n "$am_sleep_pid"; then + # Hide warnings about reused PIDs. + wait $am_sleep_pid 2>/dev/null + fi + AC_MSG_RESULT([done])]) +rm -f conftest.file +]) + +# Copyright (C) 2001-2012 Free Software Foundation, Inc. +# +# This file is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# AM_PROG_INSTALL_STRIP +# --------------------- +# One issue with vendor 'install' (even GNU) is that you can't +# specify the program used to strip binaries. This is especially +# annoying in cross-compiling environments, where the build's strip +# is unlikely to handle the host's binaries. +# Fortunately install-sh will honor a STRIPPROG variable, so we +# always use install-sh in "make install-strip", and initialize +# STRIPPROG with the value of the STRIP variable (set by the user). +AC_DEFUN([AM_PROG_INSTALL_STRIP], +[AC_REQUIRE([AM_PROG_INSTALL_SH])dnl +# Installed binaries are usually stripped using 'strip' when the user +# run "make install-strip". However 'strip' might not be the right +# tool to use in cross-compilation environments, therefore Automake +# will honor the 'STRIP' environment variable to overrule this program. +dnl Don't test for $cross_compiling = yes, because it might be 'maybe'. +if test "$cross_compiling" != no; then + AC_CHECK_TOOL([STRIP], [strip], :) +fi +INSTALL_STRIP_PROGRAM="\$(install_sh) -c -s" +AC_SUBST([INSTALL_STRIP_PROGRAM])]) + +# Copyright (C) 2006-2012 Free Software Foundation, Inc. +# +# This file is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# _AM_SUBST_NOTMAKE(VARIABLE) +# --------------------------- +# Prevent Automake from outputting VARIABLE = @VARIABLE@ in Makefile.in. +# This macro is traced by Automake. +AC_DEFUN([_AM_SUBST_NOTMAKE]) + +# AM_SUBST_NOTMAKE(VARIABLE) +# -------------------------- +# Public sister of _AM_SUBST_NOTMAKE. +AC_DEFUN([AM_SUBST_NOTMAKE], [_AM_SUBST_NOTMAKE($@)]) + +# Check how to create a tarball. -*- Autoconf -*- + +# Copyright (C) 2004-2012 Free Software Foundation, Inc. +# +# This file is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# _AM_PROG_TAR(FORMAT) +# -------------------- +# Check how to create a tarball in format FORMAT. +# FORMAT should be one of 'v7', 'ustar', or 'pax'. +# +# Substitute a variable $(am__tar) that is a command +# writing to stdout a FORMAT-tarball containing the directory +# $tardir. +# tardir=directory && $(am__tar) > result.tar +# +# Substitute a variable $(am__untar) that extract such +# a tarball read from stdin. +# $(am__untar) < result.tar +AC_DEFUN([_AM_PROG_TAR], +[# Always define AMTAR for backward compatibility. Yes, it's still used +# in the wild :-( We should find a proper way to deprecate it ... +AC_SUBST([AMTAR], ['$${TAR-tar}']) +m4_if([$1], [v7], + [am__tar='$${TAR-tar} chof - "$$tardir"' am__untar='$${TAR-tar} xf -'], + [m4_case([$1], [ustar],, [pax],, + [m4_fatal([Unknown tar format])]) +AC_MSG_CHECKING([how to create a $1 tar archive]) +# Loop over all known methods to create a tar archive until one works. +_am_tools='gnutar m4_if([$1], [ustar], [plaintar]) pax cpio none' +_am_tools=${am_cv_prog_tar_$1-$_am_tools} +# Do not fold the above two line into one, because Tru64 sh and +# Solaris sh will not grok spaces in the rhs of '-'. +for _am_tool in $_am_tools +do + case $_am_tool in + gnutar) + for _am_tar in tar gnutar gtar; + do + AM_RUN_LOG([$_am_tar --version]) && break + done + am__tar="$_am_tar --format=m4_if([$1], [pax], [posix], [$1]) -chf - "'"$$tardir"' + am__tar_="$_am_tar --format=m4_if([$1], [pax], [posix], [$1]) -chf - "'"$tardir"' + am__untar="$_am_tar -xf -" + ;; + plaintar) + # Must skip GNU tar: if it does not support --format= it doesn't create + # ustar tarball either. + (tar --version) >/dev/null 2>&1 && continue + am__tar='tar chf - "$$tardir"' + am__tar_='tar chf - "$tardir"' + am__untar='tar xf -' + ;; + pax) + am__tar='pax -L -x $1 -w "$$tardir"' + am__tar_='pax -L -x $1 -w "$tardir"' + am__untar='pax -r' + ;; + cpio) + am__tar='find "$$tardir" -print | cpio -o -H $1 -L' + am__tar_='find "$tardir" -print | cpio -o -H $1 -L' + am__untar='cpio -i -H $1 -d' + ;; + none) + am__tar=false + am__tar_=false + am__untar=false + ;; + esac + + # If the value was cached, stop now. We just wanted to have am__tar + # and am__untar set. + test -n "${am_cv_prog_tar_$1}" && break + + # tar/untar a dummy directory, and stop if the command works + rm -rf conftest.dir + mkdir conftest.dir + echo GrepMe > conftest.dir/file + AM_RUN_LOG([tardir=conftest.dir && eval $am__tar_ >conftest.tar]) + rm -rf conftest.dir + if test -s conftest.tar; then + AM_RUN_LOG([$am__untar /dev/null 2>&1 && break + fi +done +rm -rf conftest.dir + +AC_CACHE_VAL([am_cv_prog_tar_$1], [am_cv_prog_tar_$1=$_am_tool]) +AC_MSG_RESULT([$am_cv_prog_tar_$1])]) +AC_SUBST([am__tar]) +AC_SUBST([am__untar]) +]) # _AM_PROG_TAR + +m4_include([m4/acx-pthread.m4]) +m4_include([m4/disable-rpath.m4]) +m4_include([m4/libtool-link.m4]) +m4_include([m4/libtool.m4]) +m4_include([m4/ltoptions.m4]) +m4_include([m4/ltsugar.m4]) +m4_include([m4/ltversion.m4]) +m4_include([m4/lt~obsolete.m4]) +m4_include([m4/pkgconfig.m4]) +m4_include([m4/static-lib.m4]) +m4_include([m4/threads.m4]) diff --git a/third-party/odb/libodb-2.4.0/bootstrap b/third-party/odb/libodb-2.4.0/bootstrap new file mode 100755 index 0000000..8953df9 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/bootstrap @@ -0,0 +1,17 @@ +#! /bin/sh + +# file : bootstrap +# copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +# license : GNU GPL v2; see accompanying LICENSE file + +# +# Bootstrap the automake build system. +# + +rm -f config.cache + +if test ! -d m4; then + mkdir m4 +fi + +autoreconf --install diff --git a/third-party/odb/libodb-2.4.0/config/ar-lib b/third-party/odb/libodb-2.4.0/config/ar-lib new file mode 100755 index 0000000..67f5f36 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/config/ar-lib @@ -0,0 +1,270 @@ +#! /bin/sh +# Wrapper for Microsoft lib.exe + +me=ar-lib +scriptversion=2012-03-01.08; # UTC + +# Copyright (C) 2010-2012 Free Software Foundation, Inc. +# Written by Peter Rosin . +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2, or (at your option) +# any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + +# As a special exception to the GNU General Public License, if you +# distribute this file as part of a program that contains a +# configuration script generated by Autoconf, you may include it under +# the same distribution terms that you use for the rest of that program. + +# This file is maintained in Automake, please report +# bugs to or send patches to +# . + + +# func_error message +func_error () +{ + echo "$me: $1" 1>&2 + exit 1 +} + +file_conv= + +# func_file_conv build_file +# Convert a $build file to $host form and store it in $file +# Currently only supports Windows hosts. +func_file_conv () +{ + file=$1 + case $file in + / | /[!/]*) # absolute file, and not a UNC file + if test -z "$file_conv"; then + # lazily determine how to convert abs files + case `uname -s` in + MINGW*) + file_conv=mingw + ;; + CYGWIN*) + file_conv=cygwin + ;; + *) + file_conv=wine + ;; + esac + fi + case $file_conv in + mingw) + file=`cmd //C echo "$file " | sed -e 's/"\(.*\) " *$/\1/'` + ;; + cygwin) + file=`cygpath -m "$file" || echo "$file"` + ;; + wine) + file=`winepath -w "$file" || echo "$file"` + ;; + esac + ;; + esac +} + +# func_at_file at_file operation archive +# Iterate over all members in AT_FILE performing OPERATION on ARCHIVE +# for each of them. +# When interpreting the content of the @FILE, do NOT use func_file_conv, +# since the user would need to supply preconverted file names to +# binutils ar, at least for MinGW. +func_at_file () +{ + operation=$2 + archive=$3 + at_file_contents=`cat "$1"` + eval set x "$at_file_contents" + shift + + for member + do + $AR -NOLOGO $operation:"$member" "$archive" || exit $? + done +} + +case $1 in + '') + func_error "no command. Try '$0 --help' for more information." + ;; + -h | --h*) + cat <. +# +# As a special exception to the GNU General Public License, if you +# distribute this file as part of a program that contains a +# configuration script generated by Autoconf, you may include it under +# the same distribution terms that you use for the rest of that +# program. This Exception is an additional permission under section 7 +# of the GNU General Public License, version 3 ("GPLv3"). +# +# Originally written by Per Bothner. +# +# You can get the latest version of this script from: +# http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.guess;hb=HEAD +# +# Please send patches with a ChangeLog entry to config-patches@gnu.org. + + +me=`echo "$0" | sed -e 's,.*/,,'` + +usage="\ +Usage: $0 [OPTION] + +Output the configuration name of the system \`$me' is run on. + +Operation modes: + -h, --help print this help, then exit + -t, --time-stamp print date of last modification, then exit + -v, --version print version number, then exit + +Report bugs and patches to ." + +version="\ +GNU config.guess ($timestamp) + +Originally written by Per Bothner. +Copyright 1992-2014 Free Software Foundation, Inc. + +This is free software; see the source for copying conditions. There is NO +warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE." + +help=" +Try \`$me --help' for more information." + +# Parse command line +while test $# -gt 0 ; do + case $1 in + --time-stamp | --time* | -t ) + echo "$timestamp" ; exit ;; + --version | -v ) + echo "$version" ; exit ;; + --help | --h* | -h ) + echo "$usage"; exit ;; + -- ) # Stop option processing + shift; break ;; + - ) # Use stdin as input. + break ;; + -* ) + echo "$me: invalid option $1$help" >&2 + exit 1 ;; + * ) + break ;; + esac +done + +if test $# != 0; then + echo "$me: too many arguments$help" >&2 + exit 1 +fi + +trap 'exit 1' 1 2 15 + +# CC_FOR_BUILD -- compiler used by this script. Note that the use of a +# compiler to aid in system detection is discouraged as it requires +# temporary files to be created and, as you can see below, it is a +# headache to deal with in a portable fashion. + +# Historically, `CC_FOR_BUILD' used to be named `HOST_CC'. We still +# use `HOST_CC' if defined, but it is deprecated. + +# Portable tmp directory creation inspired by the Autoconf team. + +set_cc_for_build=' +trap "exitcode=\$?; (rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null) && exit \$exitcode" 0 ; +trap "rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null; exit 1" 1 2 13 15 ; +: ${TMPDIR=/tmp} ; + { tmp=`(umask 077 && mktemp -d "$TMPDIR/cgXXXXXX") 2>/dev/null` && test -n "$tmp" && test -d "$tmp" ; } || + { test -n "$RANDOM" && tmp=$TMPDIR/cg$$-$RANDOM && (umask 077 && mkdir $tmp) ; } || + { tmp=$TMPDIR/cg-$$ && (umask 077 && mkdir $tmp) && echo "Warning: creating insecure temp directory" >&2 ; } || + { echo "$me: cannot create a temporary directory in $TMPDIR" >&2 ; exit 1 ; } ; +dummy=$tmp/dummy ; +tmpfiles="$dummy.c $dummy.o $dummy.rel $dummy" ; +case $CC_FOR_BUILD,$HOST_CC,$CC in + ,,) echo "int x;" > $dummy.c ; + for c in cc gcc c89 c99 ; do + if ($c -c -o $dummy.o $dummy.c) >/dev/null 2>&1 ; then + CC_FOR_BUILD="$c"; break ; + fi ; + done ; + if test x"$CC_FOR_BUILD" = x ; then + CC_FOR_BUILD=no_compiler_found ; + fi + ;; + ,,*) CC_FOR_BUILD=$CC ;; + ,*,*) CC_FOR_BUILD=$HOST_CC ;; +esac ; set_cc_for_build= ;' + +# This is needed to find uname on a Pyramid OSx when run in the BSD universe. +# (ghazi@noc.rutgers.edu 1994-08-24) +if (test -f /.attbin/uname) >/dev/null 2>&1 ; then + PATH=$PATH:/.attbin ; export PATH +fi + +UNAME_MACHINE=`(uname -m) 2>/dev/null` || UNAME_MACHINE=unknown +UNAME_RELEASE=`(uname -r) 2>/dev/null` || UNAME_RELEASE=unknown +UNAME_SYSTEM=`(uname -s) 2>/dev/null` || UNAME_SYSTEM=unknown +UNAME_VERSION=`(uname -v) 2>/dev/null` || UNAME_VERSION=unknown + +case "${UNAME_SYSTEM}" in +Linux|GNU|GNU/*) + # If the system lacks a compiler, then just pick glibc. + # We could probably try harder. + LIBC=gnu + + eval $set_cc_for_build + cat <<-EOF > $dummy.c + #include + #if defined(__UCLIBC__) + LIBC=uclibc + #elif defined(__dietlibc__) + LIBC=dietlibc + #else + LIBC=gnu + #endif + EOF + eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null | grep '^LIBC' | sed 's, ,,g'` + ;; +esac + +# Note: order is significant - the case branches are not exclusive. + +case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in + *:NetBSD:*:*) + # NetBSD (nbsd) targets should (where applicable) match one or + # more of the tuples: *-*-netbsdelf*, *-*-netbsdaout*, + # *-*-netbsdecoff* and *-*-netbsd*. For targets that recently + # switched to ELF, *-*-netbsd* would select the old + # object file format. This provides both forward + # compatibility and a consistent mechanism for selecting the + # object file format. + # + # Note: NetBSD doesn't particularly care about the vendor + # portion of the name. We always set it to "unknown". + sysctl="sysctl -n hw.machine_arch" + UNAME_MACHINE_ARCH=`(/sbin/$sysctl 2>/dev/null || \ + /usr/sbin/$sysctl 2>/dev/null || echo unknown)` + case "${UNAME_MACHINE_ARCH}" in + armeb) machine=armeb-unknown ;; + arm*) machine=arm-unknown ;; + sh3el) machine=shl-unknown ;; + sh3eb) machine=sh-unknown ;; + sh5el) machine=sh5le-unknown ;; + *) machine=${UNAME_MACHINE_ARCH}-unknown ;; + esac + # The Operating System including object format, if it has switched + # to ELF recently, or will in the future. + case "${UNAME_MACHINE_ARCH}" in + arm*|i386|m68k|ns32k|sh3*|sparc|vax) + eval $set_cc_for_build + if echo __ELF__ | $CC_FOR_BUILD -E - 2>/dev/null \ + | grep -q __ELF__ + then + # Once all utilities can be ECOFF (netbsdecoff) or a.out (netbsdaout). + # Return netbsd for either. FIX? + os=netbsd + else + os=netbsdelf + fi + ;; + *) + os=netbsd + ;; + esac + # The OS release + # Debian GNU/NetBSD machines have a different userland, and + # thus, need a distinct triplet. However, they do not need + # kernel version information, so it can be replaced with a + # suitable tag, in the style of linux-gnu. + case "${UNAME_VERSION}" in + Debian*) + release='-gnu' + ;; + *) + release=`echo ${UNAME_RELEASE}|sed -e 's/[-_].*/\./'` + ;; + esac + # Since CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM: + # contains redundant information, the shorter form: + # CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM is used. + echo "${machine}-${os}${release}" + exit ;; + *:Bitrig:*:*) + UNAME_MACHINE_ARCH=`arch | sed 's/Bitrig.//'` + echo ${UNAME_MACHINE_ARCH}-unknown-bitrig${UNAME_RELEASE} + exit ;; + *:OpenBSD:*:*) + UNAME_MACHINE_ARCH=`arch | sed 's/OpenBSD.//'` + echo ${UNAME_MACHINE_ARCH}-unknown-openbsd${UNAME_RELEASE} + exit ;; + *:ekkoBSD:*:*) + echo ${UNAME_MACHINE}-unknown-ekkobsd${UNAME_RELEASE} + exit ;; + *:SolidBSD:*:*) + echo ${UNAME_MACHINE}-unknown-solidbsd${UNAME_RELEASE} + exit ;; + macppc:MirBSD:*:*) + echo powerpc-unknown-mirbsd${UNAME_RELEASE} + exit ;; + *:MirBSD:*:*) + echo ${UNAME_MACHINE}-unknown-mirbsd${UNAME_RELEASE} + exit ;; + alpha:OSF1:*:*) + case $UNAME_RELEASE in + *4.0) + UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $3}'` + ;; + *5.*) + UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $4}'` + ;; + esac + # According to Compaq, /usr/sbin/psrinfo has been available on + # OSF/1 and Tru64 systems produced since 1995. I hope that + # covers most systems running today. This code pipes the CPU + # types through head -n 1, so we only detect the type of CPU 0. + ALPHA_CPU_TYPE=`/usr/sbin/psrinfo -v | sed -n -e 's/^ The alpha \(.*\) processor.*$/\1/p' | head -n 1` + case "$ALPHA_CPU_TYPE" in + "EV4 (21064)") + UNAME_MACHINE="alpha" ;; + "EV4.5 (21064)") + UNAME_MACHINE="alpha" ;; + "LCA4 (21066/21068)") + UNAME_MACHINE="alpha" ;; + "EV5 (21164)") + UNAME_MACHINE="alphaev5" ;; + "EV5.6 (21164A)") + UNAME_MACHINE="alphaev56" ;; + "EV5.6 (21164PC)") + UNAME_MACHINE="alphapca56" ;; + "EV5.7 (21164PC)") + UNAME_MACHINE="alphapca57" ;; + "EV6 (21264)") + UNAME_MACHINE="alphaev6" ;; + "EV6.7 (21264A)") + UNAME_MACHINE="alphaev67" ;; + "EV6.8CB (21264C)") + UNAME_MACHINE="alphaev68" ;; + "EV6.8AL (21264B)") + UNAME_MACHINE="alphaev68" ;; + "EV6.8CX (21264D)") + UNAME_MACHINE="alphaev68" ;; + "EV6.9A (21264/EV69A)") + UNAME_MACHINE="alphaev69" ;; + "EV7 (21364)") + UNAME_MACHINE="alphaev7" ;; + "EV7.9 (21364A)") + UNAME_MACHINE="alphaev79" ;; + esac + # A Pn.n version is a patched version. + # A Vn.n version is a released version. + # A Tn.n version is a released field test version. + # A Xn.n version is an unreleased experimental baselevel. + # 1.2 uses "1.2" for uname -r. + echo ${UNAME_MACHINE}-dec-osf`echo ${UNAME_RELEASE} | sed -e 's/^[PVTX]//' | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` + # Reset EXIT trap before exiting to avoid spurious non-zero exit code. + exitcode=$? + trap '' 0 + exit $exitcode ;; + Alpha\ *:Windows_NT*:*) + # How do we know it's Interix rather than the generic POSIX subsystem? + # Should we change UNAME_MACHINE based on the output of uname instead + # of the specific Alpha model? + echo alpha-pc-interix + exit ;; + 21064:Windows_NT:50:3) + echo alpha-dec-winnt3.5 + exit ;; + Amiga*:UNIX_System_V:4.0:*) + echo m68k-unknown-sysv4 + exit ;; + *:[Aa]miga[Oo][Ss]:*:*) + echo ${UNAME_MACHINE}-unknown-amigaos + exit ;; + *:[Mm]orph[Oo][Ss]:*:*) + echo ${UNAME_MACHINE}-unknown-morphos + exit ;; + *:OS/390:*:*) + echo i370-ibm-openedition + exit ;; + *:z/VM:*:*) + echo s390-ibm-zvmoe + exit ;; + *:OS400:*:*) + echo powerpc-ibm-os400 + exit ;; + arm:RISC*:1.[012]*:*|arm:riscix:1.[012]*:*) + echo arm-acorn-riscix${UNAME_RELEASE} + exit ;; + arm*:riscos:*:*|arm*:RISCOS:*:*) + echo arm-unknown-riscos + exit ;; + SR2?01:HI-UX/MPP:*:* | SR8000:HI-UX/MPP:*:*) + echo hppa1.1-hitachi-hiuxmpp + exit ;; + Pyramid*:OSx*:*:* | MIS*:OSx*:*:* | MIS*:SMP_DC-OSx*:*:*) + # akee@wpdis03.wpafb.af.mil (Earle F. Ake) contributed MIS and NILE. + if test "`(/bin/universe) 2>/dev/null`" = att ; then + echo pyramid-pyramid-sysv3 + else + echo pyramid-pyramid-bsd + fi + exit ;; + NILE*:*:*:dcosx) + echo pyramid-pyramid-svr4 + exit ;; + DRS?6000:unix:4.0:6*) + echo sparc-icl-nx6 + exit ;; + DRS?6000:UNIX_SV:4.2*:7* | DRS?6000:isis:4.2*:7*) + case `/usr/bin/uname -p` in + sparc) echo sparc-icl-nx7; exit ;; + esac ;; + s390x:SunOS:*:*) + echo ${UNAME_MACHINE}-ibm-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` + exit ;; + sun4H:SunOS:5.*:*) + echo sparc-hal-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` + exit ;; + sun4*:SunOS:5.*:* | tadpole*:SunOS:5.*:*) + echo sparc-sun-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` + exit ;; + i86pc:AuroraUX:5.*:* | i86xen:AuroraUX:5.*:*) + echo i386-pc-auroraux${UNAME_RELEASE} + exit ;; + i86pc:SunOS:5.*:* | i86xen:SunOS:5.*:*) + eval $set_cc_for_build + SUN_ARCH="i386" + # If there is a compiler, see if it is configured for 64-bit objects. + # Note that the Sun cc does not turn __LP64__ into 1 like gcc does. + # This test works for both compilers. + if [ "$CC_FOR_BUILD" != 'no_compiler_found' ]; then + if (echo '#ifdef __amd64'; echo IS_64BIT_ARCH; echo '#endif') | \ + (CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) | \ + grep IS_64BIT_ARCH >/dev/null + then + SUN_ARCH="x86_64" + fi + fi + echo ${SUN_ARCH}-pc-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` + exit ;; + sun4*:SunOS:6*:*) + # According to config.sub, this is the proper way to canonicalize + # SunOS6. Hard to guess exactly what SunOS6 will be like, but + # it's likely to be more like Solaris than SunOS4. + echo sparc-sun-solaris3`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` + exit ;; + sun4*:SunOS:*:*) + case "`/usr/bin/arch -k`" in + Series*|S4*) + UNAME_RELEASE=`uname -v` + ;; + esac + # Japanese Language versions have a version number like `4.1.3-JL'. + echo sparc-sun-sunos`echo ${UNAME_RELEASE}|sed -e 's/-/_/'` + exit ;; + sun3*:SunOS:*:*) + echo m68k-sun-sunos${UNAME_RELEASE} + exit ;; + sun*:*:4.2BSD:*) + UNAME_RELEASE=`(sed 1q /etc/motd | awk '{print substr($5,1,3)}') 2>/dev/null` + test "x${UNAME_RELEASE}" = "x" && UNAME_RELEASE=3 + case "`/bin/arch`" in + sun3) + echo m68k-sun-sunos${UNAME_RELEASE} + ;; + sun4) + echo sparc-sun-sunos${UNAME_RELEASE} + ;; + esac + exit ;; + aushp:SunOS:*:*) + echo sparc-auspex-sunos${UNAME_RELEASE} + exit ;; + # The situation for MiNT is a little confusing. The machine name + # can be virtually everything (everything which is not + # "atarist" or "atariste" at least should have a processor + # > m68000). The system name ranges from "MiNT" over "FreeMiNT" + # to the lowercase version "mint" (or "freemint"). Finally + # the system name "TOS" denotes a system which is actually not + # MiNT. But MiNT is downward compatible to TOS, so this should + # be no problem. + atarist[e]:*MiNT:*:* | atarist[e]:*mint:*:* | atarist[e]:*TOS:*:*) + echo m68k-atari-mint${UNAME_RELEASE} + exit ;; + atari*:*MiNT:*:* | atari*:*mint:*:* | atarist[e]:*TOS:*:*) + echo m68k-atari-mint${UNAME_RELEASE} + exit ;; + *falcon*:*MiNT:*:* | *falcon*:*mint:*:* | *falcon*:*TOS:*:*) + echo m68k-atari-mint${UNAME_RELEASE} + exit ;; + milan*:*MiNT:*:* | milan*:*mint:*:* | *milan*:*TOS:*:*) + echo m68k-milan-mint${UNAME_RELEASE} + exit ;; + hades*:*MiNT:*:* | hades*:*mint:*:* | *hades*:*TOS:*:*) + echo m68k-hades-mint${UNAME_RELEASE} + exit ;; + *:*MiNT:*:* | *:*mint:*:* | *:*TOS:*:*) + echo m68k-unknown-mint${UNAME_RELEASE} + exit ;; + m68k:machten:*:*) + echo m68k-apple-machten${UNAME_RELEASE} + exit ;; + powerpc:machten:*:*) + echo powerpc-apple-machten${UNAME_RELEASE} + exit ;; + RISC*:Mach:*:*) + echo mips-dec-mach_bsd4.3 + exit ;; + RISC*:ULTRIX:*:*) + echo mips-dec-ultrix${UNAME_RELEASE} + exit ;; + VAX*:ULTRIX*:*:*) + echo vax-dec-ultrix${UNAME_RELEASE} + exit ;; + 2020:CLIX:*:* | 2430:CLIX:*:*) + echo clipper-intergraph-clix${UNAME_RELEASE} + exit ;; + mips:*:*:UMIPS | mips:*:*:RISCos) + eval $set_cc_for_build + sed 's/^ //' << EOF >$dummy.c +#ifdef __cplusplus +#include /* for printf() prototype */ + int main (int argc, char *argv[]) { +#else + int main (argc, argv) int argc; char *argv[]; { +#endif + #if defined (host_mips) && defined (MIPSEB) + #if defined (SYSTYPE_SYSV) + printf ("mips-mips-riscos%ssysv\n", argv[1]); exit (0); + #endif + #if defined (SYSTYPE_SVR4) + printf ("mips-mips-riscos%ssvr4\n", argv[1]); exit (0); + #endif + #if defined (SYSTYPE_BSD43) || defined(SYSTYPE_BSD) + printf ("mips-mips-riscos%sbsd\n", argv[1]); exit (0); + #endif + #endif + exit (-1); + } +EOF + $CC_FOR_BUILD -o $dummy $dummy.c && + dummyarg=`echo "${UNAME_RELEASE}" | sed -n 's/\([0-9]*\).*/\1/p'` && + SYSTEM_NAME=`$dummy $dummyarg` && + { echo "$SYSTEM_NAME"; exit; } + echo mips-mips-riscos${UNAME_RELEASE} + exit ;; + Motorola:PowerMAX_OS:*:*) + echo powerpc-motorola-powermax + exit ;; + Motorola:*:4.3:PL8-*) + echo powerpc-harris-powermax + exit ;; + Night_Hawk:*:*:PowerMAX_OS | Synergy:PowerMAX_OS:*:*) + echo powerpc-harris-powermax + exit ;; + Night_Hawk:Power_UNIX:*:*) + echo powerpc-harris-powerunix + exit ;; + m88k:CX/UX:7*:*) + echo m88k-harris-cxux7 + exit ;; + m88k:*:4*:R4*) + echo m88k-motorola-sysv4 + exit ;; + m88k:*:3*:R3*) + echo m88k-motorola-sysv3 + exit ;; + AViiON:dgux:*:*) + # DG/UX returns AViiON for all architectures + UNAME_PROCESSOR=`/usr/bin/uname -p` + if [ $UNAME_PROCESSOR = mc88100 ] || [ $UNAME_PROCESSOR = mc88110 ] + then + if [ ${TARGET_BINARY_INTERFACE}x = m88kdguxelfx ] || \ + [ ${TARGET_BINARY_INTERFACE}x = x ] + then + echo m88k-dg-dgux${UNAME_RELEASE} + else + echo m88k-dg-dguxbcs${UNAME_RELEASE} + fi + else + echo i586-dg-dgux${UNAME_RELEASE} + fi + exit ;; + M88*:DolphinOS:*:*) # DolphinOS (SVR3) + echo m88k-dolphin-sysv3 + exit ;; + M88*:*:R3*:*) + # Delta 88k system running SVR3 + echo m88k-motorola-sysv3 + exit ;; + XD88*:*:*:*) # Tektronix XD88 system running UTekV (SVR3) + echo m88k-tektronix-sysv3 + exit ;; + Tek43[0-9][0-9]:UTek:*:*) # Tektronix 4300 system running UTek (BSD) + echo m68k-tektronix-bsd + exit ;; + *:IRIX*:*:*) + echo mips-sgi-irix`echo ${UNAME_RELEASE}|sed -e 's/-/_/g'` + exit ;; + ????????:AIX?:[12].1:2) # AIX 2.2.1 or AIX 2.1.1 is RT/PC AIX. + echo romp-ibm-aix # uname -m gives an 8 hex-code CPU id + exit ;; # Note that: echo "'`uname -s`'" gives 'AIX ' + i*86:AIX:*:*) + echo i386-ibm-aix + exit ;; + ia64:AIX:*:*) + if [ -x /usr/bin/oslevel ] ; then + IBM_REV=`/usr/bin/oslevel` + else + IBM_REV=${UNAME_VERSION}.${UNAME_RELEASE} + fi + echo ${UNAME_MACHINE}-ibm-aix${IBM_REV} + exit ;; + *:AIX:2:3) + if grep bos325 /usr/include/stdio.h >/dev/null 2>&1; then + eval $set_cc_for_build + sed 's/^ //' << EOF >$dummy.c + #include + + main() + { + if (!__power_pc()) + exit(1); + puts("powerpc-ibm-aix3.2.5"); + exit(0); + } +EOF + if $CC_FOR_BUILD -o $dummy $dummy.c && SYSTEM_NAME=`$dummy` + then + echo "$SYSTEM_NAME" + else + echo rs6000-ibm-aix3.2.5 + fi + elif grep bos324 /usr/include/stdio.h >/dev/null 2>&1; then + echo rs6000-ibm-aix3.2.4 + else + echo rs6000-ibm-aix3.2 + fi + exit ;; + *:AIX:*:[4567]) + IBM_CPU_ID=`/usr/sbin/lsdev -C -c processor -S available | sed 1q | awk '{ print $1 }'` + if /usr/sbin/lsattr -El ${IBM_CPU_ID} | grep ' POWER' >/dev/null 2>&1; then + IBM_ARCH=rs6000 + else + IBM_ARCH=powerpc + fi + if [ -x /usr/bin/oslevel ] ; then + IBM_REV=`/usr/bin/oslevel` + else + IBM_REV=${UNAME_VERSION}.${UNAME_RELEASE} + fi + echo ${IBM_ARCH}-ibm-aix${IBM_REV} + exit ;; + *:AIX:*:*) + echo rs6000-ibm-aix + exit ;; + ibmrt:4.4BSD:*|romp-ibm:BSD:*) + echo romp-ibm-bsd4.4 + exit ;; + ibmrt:*BSD:*|romp-ibm:BSD:*) # covers RT/PC BSD and + echo romp-ibm-bsd${UNAME_RELEASE} # 4.3 with uname added to + exit ;; # report: romp-ibm BSD 4.3 + *:BOSX:*:*) + echo rs6000-bull-bosx + exit ;; + DPX/2?00:B.O.S.:*:*) + echo m68k-bull-sysv3 + exit ;; + 9000/[34]??:4.3bsd:1.*:*) + echo m68k-hp-bsd + exit ;; + hp300:4.4BSD:*:* | 9000/[34]??:4.3bsd:2.*:*) + echo m68k-hp-bsd4.4 + exit ;; + 9000/[34678]??:HP-UX:*:*) + HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/[^.]*.[0B]*//'` + case "${UNAME_MACHINE}" in + 9000/31? ) HP_ARCH=m68000 ;; + 9000/[34]?? ) HP_ARCH=m68k ;; + 9000/[678][0-9][0-9]) + if [ -x /usr/bin/getconf ]; then + sc_cpu_version=`/usr/bin/getconf SC_CPU_VERSION 2>/dev/null` + sc_kernel_bits=`/usr/bin/getconf SC_KERNEL_BITS 2>/dev/null` + case "${sc_cpu_version}" in + 523) HP_ARCH="hppa1.0" ;; # CPU_PA_RISC1_0 + 528) HP_ARCH="hppa1.1" ;; # CPU_PA_RISC1_1 + 532) # CPU_PA_RISC2_0 + case "${sc_kernel_bits}" in + 32) HP_ARCH="hppa2.0n" ;; + 64) HP_ARCH="hppa2.0w" ;; + '') HP_ARCH="hppa2.0" ;; # HP-UX 10.20 + esac ;; + esac + fi + if [ "${HP_ARCH}" = "" ]; then + eval $set_cc_for_build + sed 's/^ //' << EOF >$dummy.c + + #define _HPUX_SOURCE + #include + #include + + int main () + { + #if defined(_SC_KERNEL_BITS) + long bits = sysconf(_SC_KERNEL_BITS); + #endif + long cpu = sysconf (_SC_CPU_VERSION); + + switch (cpu) + { + case CPU_PA_RISC1_0: puts ("hppa1.0"); break; + case CPU_PA_RISC1_1: puts ("hppa1.1"); break; + case CPU_PA_RISC2_0: + #if defined(_SC_KERNEL_BITS) + switch (bits) + { + case 64: puts ("hppa2.0w"); break; + case 32: puts ("hppa2.0n"); break; + default: puts ("hppa2.0"); break; + } break; + #else /* !defined(_SC_KERNEL_BITS) */ + puts ("hppa2.0"); break; + #endif + default: puts ("hppa1.0"); break; + } + exit (0); + } +EOF + (CCOPTS= $CC_FOR_BUILD -o $dummy $dummy.c 2>/dev/null) && HP_ARCH=`$dummy` + test -z "$HP_ARCH" && HP_ARCH=hppa + fi ;; + esac + if [ ${HP_ARCH} = "hppa2.0w" ] + then + eval $set_cc_for_build + + # hppa2.0w-hp-hpux* has a 64-bit kernel and a compiler generating + # 32-bit code. hppa64-hp-hpux* has the same kernel and a compiler + # generating 64-bit code. GNU and HP use different nomenclature: + # + # $ CC_FOR_BUILD=cc ./config.guess + # => hppa2.0w-hp-hpux11.23 + # $ CC_FOR_BUILD="cc +DA2.0w" ./config.guess + # => hppa64-hp-hpux11.23 + + if echo __LP64__ | (CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) | + grep -q __LP64__ + then + HP_ARCH="hppa2.0w" + else + HP_ARCH="hppa64" + fi + fi + echo ${HP_ARCH}-hp-hpux${HPUX_REV} + exit ;; + ia64:HP-UX:*:*) + HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/[^.]*.[0B]*//'` + echo ia64-hp-hpux${HPUX_REV} + exit ;; + 3050*:HI-UX:*:*) + eval $set_cc_for_build + sed 's/^ //' << EOF >$dummy.c + #include + int + main () + { + long cpu = sysconf (_SC_CPU_VERSION); + /* The order matters, because CPU_IS_HP_MC68K erroneously returns + true for CPU_PA_RISC1_0. CPU_IS_PA_RISC returns correct + results, however. */ + if (CPU_IS_PA_RISC (cpu)) + { + switch (cpu) + { + case CPU_PA_RISC1_0: puts ("hppa1.0-hitachi-hiuxwe2"); break; + case CPU_PA_RISC1_1: puts ("hppa1.1-hitachi-hiuxwe2"); break; + case CPU_PA_RISC2_0: puts ("hppa2.0-hitachi-hiuxwe2"); break; + default: puts ("hppa-hitachi-hiuxwe2"); break; + } + } + else if (CPU_IS_HP_MC68K (cpu)) + puts ("m68k-hitachi-hiuxwe2"); + else puts ("unknown-hitachi-hiuxwe2"); + exit (0); + } +EOF + $CC_FOR_BUILD -o $dummy $dummy.c && SYSTEM_NAME=`$dummy` && + { echo "$SYSTEM_NAME"; exit; } + echo unknown-hitachi-hiuxwe2 + exit ;; + 9000/7??:4.3bsd:*:* | 9000/8?[79]:4.3bsd:*:* ) + echo hppa1.1-hp-bsd + exit ;; + 9000/8??:4.3bsd:*:*) + echo hppa1.0-hp-bsd + exit ;; + *9??*:MPE/iX:*:* | *3000*:MPE/iX:*:*) + echo hppa1.0-hp-mpeix + exit ;; + hp7??:OSF1:*:* | hp8?[79]:OSF1:*:* ) + echo hppa1.1-hp-osf + exit ;; + hp8??:OSF1:*:*) + echo hppa1.0-hp-osf + exit ;; + i*86:OSF1:*:*) + if [ -x /usr/sbin/sysversion ] ; then + echo ${UNAME_MACHINE}-unknown-osf1mk + else + echo ${UNAME_MACHINE}-unknown-osf1 + fi + exit ;; + parisc*:Lites*:*:*) + echo hppa1.1-hp-lites + exit ;; + C1*:ConvexOS:*:* | convex:ConvexOS:C1*:*) + echo c1-convex-bsd + exit ;; + C2*:ConvexOS:*:* | convex:ConvexOS:C2*:*) + if getsysinfo -f scalar_acc + then echo c32-convex-bsd + else echo c2-convex-bsd + fi + exit ;; + C34*:ConvexOS:*:* | convex:ConvexOS:C34*:*) + echo c34-convex-bsd + exit ;; + C38*:ConvexOS:*:* | convex:ConvexOS:C38*:*) + echo c38-convex-bsd + exit ;; + C4*:ConvexOS:*:* | convex:ConvexOS:C4*:*) + echo c4-convex-bsd + exit ;; + CRAY*Y-MP:*:*:*) + echo ymp-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' + exit ;; + CRAY*[A-Z]90:*:*:*) + echo ${UNAME_MACHINE}-cray-unicos${UNAME_RELEASE} \ + | sed -e 's/CRAY.*\([A-Z]90\)/\1/' \ + -e y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/ \ + -e 's/\.[^.]*$/.X/' + exit ;; + CRAY*TS:*:*:*) + echo t90-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' + exit ;; + CRAY*T3E:*:*:*) + echo alphaev5-cray-unicosmk${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' + exit ;; + CRAY*SV1:*:*:*) + echo sv1-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' + exit ;; + *:UNICOS/mp:*:*) + echo craynv-cray-unicosmp${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' + exit ;; + F30[01]:UNIX_System_V:*:* | F700:UNIX_System_V:*:*) + FUJITSU_PROC=`uname -m | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` + FUJITSU_SYS=`uname -p | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/\///'` + FUJITSU_REL=`echo ${UNAME_RELEASE} | sed -e 's/ /_/'` + echo "${FUJITSU_PROC}-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}" + exit ;; + 5000:UNIX_System_V:4.*:*) + FUJITSU_SYS=`uname -p | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/\///'` + FUJITSU_REL=`echo ${UNAME_RELEASE} | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/ /_/'` + echo "sparc-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}" + exit ;; + i*86:BSD/386:*:* | i*86:BSD/OS:*:* | *:Ascend\ Embedded/OS:*:*) + echo ${UNAME_MACHINE}-pc-bsdi${UNAME_RELEASE} + exit ;; + sparc*:BSD/OS:*:*) + echo sparc-unknown-bsdi${UNAME_RELEASE} + exit ;; + *:BSD/OS:*:*) + echo ${UNAME_MACHINE}-unknown-bsdi${UNAME_RELEASE} + exit ;; + *:FreeBSD:*:*) + UNAME_PROCESSOR=`/usr/bin/uname -p` + case ${UNAME_PROCESSOR} in + amd64) + echo x86_64-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;; + *) + echo ${UNAME_PROCESSOR}-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;; + esac + exit ;; + i*:CYGWIN*:*) + echo ${UNAME_MACHINE}-pc-cygwin + exit ;; + *:MINGW64*:*) + echo ${UNAME_MACHINE}-pc-mingw64 + exit ;; + *:MINGW*:*) + echo ${UNAME_MACHINE}-pc-mingw32 + exit ;; + *:MSYS*:*) + echo ${UNAME_MACHINE}-pc-msys + exit ;; + i*:windows32*:*) + # uname -m includes "-pc" on this system. + echo ${UNAME_MACHINE}-mingw32 + exit ;; + i*:PW*:*) + echo ${UNAME_MACHINE}-pc-pw32 + exit ;; + *:Interix*:*) + case ${UNAME_MACHINE} in + x86) + echo i586-pc-interix${UNAME_RELEASE} + exit ;; + authenticamd | genuineintel | EM64T) + echo x86_64-unknown-interix${UNAME_RELEASE} + exit ;; + IA64) + echo ia64-unknown-interix${UNAME_RELEASE} + exit ;; + esac ;; + [345]86:Windows_95:* | [345]86:Windows_98:* | [345]86:Windows_NT:*) + echo i${UNAME_MACHINE}-pc-mks + exit ;; + 8664:Windows_NT:*) + echo x86_64-pc-mks + exit ;; + i*:Windows_NT*:* | Pentium*:Windows_NT*:*) + # How do we know it's Interix rather than the generic POSIX subsystem? + # It also conflicts with pre-2.0 versions of AT&T UWIN. Should we + # UNAME_MACHINE based on the output of uname instead of i386? + echo i586-pc-interix + exit ;; + i*:UWIN*:*) + echo ${UNAME_MACHINE}-pc-uwin + exit ;; + amd64:CYGWIN*:*:* | x86_64:CYGWIN*:*:*) + echo x86_64-unknown-cygwin + exit ;; + p*:CYGWIN*:*) + echo powerpcle-unknown-cygwin + exit ;; + prep*:SunOS:5.*:*) + echo powerpcle-unknown-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` + exit ;; + *:GNU:*:*) + # the GNU system + echo `echo ${UNAME_MACHINE}|sed -e 's,[-/].*$,,'`-unknown-${LIBC}`echo ${UNAME_RELEASE}|sed -e 's,/.*$,,'` + exit ;; + *:GNU/*:*:*) + # other systems with GNU libc and userland + echo ${UNAME_MACHINE}-unknown-`echo ${UNAME_SYSTEM} | sed 's,^[^/]*/,,' | tr '[A-Z]' '[a-z]'``echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'`-${LIBC} + exit ;; + i*86:Minix:*:*) + echo ${UNAME_MACHINE}-pc-minix + exit ;; + aarch64:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-${LIBC} + exit ;; + aarch64_be:Linux:*:*) + UNAME_MACHINE=aarch64_be + echo ${UNAME_MACHINE}-unknown-linux-${LIBC} + exit ;; + alpha:Linux:*:*) + case `sed -n '/^cpu model/s/^.*: \(.*\)/\1/p' < /proc/cpuinfo` in + EV5) UNAME_MACHINE=alphaev5 ;; + EV56) UNAME_MACHINE=alphaev56 ;; + PCA56) UNAME_MACHINE=alphapca56 ;; + PCA57) UNAME_MACHINE=alphapca56 ;; + EV6) UNAME_MACHINE=alphaev6 ;; + EV67) UNAME_MACHINE=alphaev67 ;; + EV68*) UNAME_MACHINE=alphaev68 ;; + esac + objdump --private-headers /bin/sh | grep -q ld.so.1 + if test "$?" = 0 ; then LIBC="gnulibc1" ; fi + echo ${UNAME_MACHINE}-unknown-linux-${LIBC} + exit ;; + arc:Linux:*:* | arceb:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-${LIBC} + exit ;; + arm*:Linux:*:*) + eval $set_cc_for_build + if echo __ARM_EABI__ | $CC_FOR_BUILD -E - 2>/dev/null \ + | grep -q __ARM_EABI__ + then + echo ${UNAME_MACHINE}-unknown-linux-${LIBC} + else + if echo __ARM_PCS_VFP | $CC_FOR_BUILD -E - 2>/dev/null \ + | grep -q __ARM_PCS_VFP + then + echo ${UNAME_MACHINE}-unknown-linux-${LIBC}eabi + else + echo ${UNAME_MACHINE}-unknown-linux-${LIBC}eabihf + fi + fi + exit ;; + avr32*:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-${LIBC} + exit ;; + cris:Linux:*:*) + echo ${UNAME_MACHINE}-axis-linux-${LIBC} + exit ;; + crisv32:Linux:*:*) + echo ${UNAME_MACHINE}-axis-linux-${LIBC} + exit ;; + frv:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-${LIBC} + exit ;; + hexagon:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-${LIBC} + exit ;; + i*86:Linux:*:*) + echo ${UNAME_MACHINE}-pc-linux-${LIBC} + exit ;; + ia64:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-${LIBC} + exit ;; + m32r*:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-${LIBC} + exit ;; + m68*:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-${LIBC} + exit ;; + mips:Linux:*:* | mips64:Linux:*:*) + eval $set_cc_for_build + sed 's/^ //' << EOF >$dummy.c + #undef CPU + #undef ${UNAME_MACHINE} + #undef ${UNAME_MACHINE}el + #if defined(__MIPSEL__) || defined(__MIPSEL) || defined(_MIPSEL) || defined(MIPSEL) + CPU=${UNAME_MACHINE}el + #else + #if defined(__MIPSEB__) || defined(__MIPSEB) || defined(_MIPSEB) || defined(MIPSEB) + CPU=${UNAME_MACHINE} + #else + CPU= + #endif + #endif +EOF + eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null | grep '^CPU'` + test x"${CPU}" != x && { echo "${CPU}-unknown-linux-${LIBC}"; exit; } + ;; + openrisc*:Linux:*:*) + echo or1k-unknown-linux-${LIBC} + exit ;; + or32:Linux:*:* | or1k*:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-${LIBC} + exit ;; + padre:Linux:*:*) + echo sparc-unknown-linux-${LIBC} + exit ;; + parisc64:Linux:*:* | hppa64:Linux:*:*) + echo hppa64-unknown-linux-${LIBC} + exit ;; + parisc:Linux:*:* | hppa:Linux:*:*) + # Look for CPU level + case `grep '^cpu[^a-z]*:' /proc/cpuinfo 2>/dev/null | cut -d' ' -f2` in + PA7*) echo hppa1.1-unknown-linux-${LIBC} ;; + PA8*) echo hppa2.0-unknown-linux-${LIBC} ;; + *) echo hppa-unknown-linux-${LIBC} ;; + esac + exit ;; + ppc64:Linux:*:*) + echo powerpc64-unknown-linux-${LIBC} + exit ;; + ppc:Linux:*:*) + echo powerpc-unknown-linux-${LIBC} + exit ;; + ppc64le:Linux:*:*) + echo powerpc64le-unknown-linux-${LIBC} + exit ;; + ppcle:Linux:*:*) + echo powerpcle-unknown-linux-${LIBC} + exit ;; + s390:Linux:*:* | s390x:Linux:*:*) + echo ${UNAME_MACHINE}-ibm-linux-${LIBC} + exit ;; + sh64*:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-${LIBC} + exit ;; + sh*:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-${LIBC} + exit ;; + sparc:Linux:*:* | sparc64:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-${LIBC} + exit ;; + tile*:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-${LIBC} + exit ;; + vax:Linux:*:*) + echo ${UNAME_MACHINE}-dec-linux-${LIBC} + exit ;; + x86_64:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-${LIBC} + exit ;; + xtensa*:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-${LIBC} + exit ;; + i*86:DYNIX/ptx:4*:*) + # ptx 4.0 does uname -s correctly, with DYNIX/ptx in there. + # earlier versions are messed up and put the nodename in both + # sysname and nodename. + echo i386-sequent-sysv4 + exit ;; + i*86:UNIX_SV:4.2MP:2.*) + # Unixware is an offshoot of SVR4, but it has its own version + # number series starting with 2... + # I am not positive that other SVR4 systems won't match this, + # I just have to hope. -- rms. + # Use sysv4.2uw... so that sysv4* matches it. + echo ${UNAME_MACHINE}-pc-sysv4.2uw${UNAME_VERSION} + exit ;; + i*86:OS/2:*:*) + # If we were able to find `uname', then EMX Unix compatibility + # is probably installed. + echo ${UNAME_MACHINE}-pc-os2-emx + exit ;; + i*86:XTS-300:*:STOP) + echo ${UNAME_MACHINE}-unknown-stop + exit ;; + i*86:atheos:*:*) + echo ${UNAME_MACHINE}-unknown-atheos + exit ;; + i*86:syllable:*:*) + echo ${UNAME_MACHINE}-pc-syllable + exit ;; + i*86:LynxOS:2.*:* | i*86:LynxOS:3.[01]*:* | i*86:LynxOS:4.[02]*:*) + echo i386-unknown-lynxos${UNAME_RELEASE} + exit ;; + i*86:*DOS:*:*) + echo ${UNAME_MACHINE}-pc-msdosdjgpp + exit ;; + i*86:*:4.*:* | i*86:SYSTEM_V:4.*:*) + UNAME_REL=`echo ${UNAME_RELEASE} | sed 's/\/MP$//'` + if grep Novell /usr/include/link.h >/dev/null 2>/dev/null; then + echo ${UNAME_MACHINE}-univel-sysv${UNAME_REL} + else + echo ${UNAME_MACHINE}-pc-sysv${UNAME_REL} + fi + exit ;; + i*86:*:5:[678]*) + # UnixWare 7.x, OpenUNIX and OpenServer 6. + case `/bin/uname -X | grep "^Machine"` in + *486*) UNAME_MACHINE=i486 ;; + *Pentium) UNAME_MACHINE=i586 ;; + *Pent*|*Celeron) UNAME_MACHINE=i686 ;; + esac + echo ${UNAME_MACHINE}-unknown-sysv${UNAME_RELEASE}${UNAME_SYSTEM}${UNAME_VERSION} + exit ;; + i*86:*:3.2:*) + if test -f /usr/options/cb.name; then + UNAME_REL=`sed -n 's/.*Version //p' /dev/null >/dev/null ; then + UNAME_REL=`(/bin/uname -X|grep Release|sed -e 's/.*= //')` + (/bin/uname -X|grep i80486 >/dev/null) && UNAME_MACHINE=i486 + (/bin/uname -X|grep '^Machine.*Pentium' >/dev/null) \ + && UNAME_MACHINE=i586 + (/bin/uname -X|grep '^Machine.*Pent *II' >/dev/null) \ + && UNAME_MACHINE=i686 + (/bin/uname -X|grep '^Machine.*Pentium Pro' >/dev/null) \ + && UNAME_MACHINE=i686 + echo ${UNAME_MACHINE}-pc-sco$UNAME_REL + else + echo ${UNAME_MACHINE}-pc-sysv32 + fi + exit ;; + pc:*:*:*) + # Left here for compatibility: + # uname -m prints for DJGPP always 'pc', but it prints nothing about + # the processor, so we play safe by assuming i586. + # Note: whatever this is, it MUST be the same as what config.sub + # prints for the "djgpp" host, or else GDB configury will decide that + # this is a cross-build. + echo i586-pc-msdosdjgpp + exit ;; + Intel:Mach:3*:*) + echo i386-pc-mach3 + exit ;; + paragon:*:*:*) + echo i860-intel-osf1 + exit ;; + i860:*:4.*:*) # i860-SVR4 + if grep Stardent /usr/include/sys/uadmin.h >/dev/null 2>&1 ; then + echo i860-stardent-sysv${UNAME_RELEASE} # Stardent Vistra i860-SVR4 + else # Add other i860-SVR4 vendors below as they are discovered. + echo i860-unknown-sysv${UNAME_RELEASE} # Unknown i860-SVR4 + fi + exit ;; + mini*:CTIX:SYS*5:*) + # "miniframe" + echo m68010-convergent-sysv + exit ;; + mc68k:UNIX:SYSTEM5:3.51m) + echo m68k-convergent-sysv + exit ;; + M680?0:D-NIX:5.3:*) + echo m68k-diab-dnix + exit ;; + M68*:*:R3V[5678]*:*) + test -r /sysV68 && { echo 'm68k-motorola-sysv'; exit; } ;; + 3[345]??:*:4.0:3.0 | 3[34]??A:*:4.0:3.0 | 3[34]??,*:*:4.0:3.0 | 3[34]??/*:*:4.0:3.0 | 4400:*:4.0:3.0 | 4850:*:4.0:3.0 | SKA40:*:4.0:3.0 | SDS2:*:4.0:3.0 | SHG2:*:4.0:3.0 | S7501*:*:4.0:3.0) + OS_REL='' + test -r /etc/.relid \ + && OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid` + /bin/uname -p 2>/dev/null | grep 86 >/dev/null \ + && { echo i486-ncr-sysv4.3${OS_REL}; exit; } + /bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \ + && { echo i586-ncr-sysv4.3${OS_REL}; exit; } ;; + 3[34]??:*:4.0:* | 3[34]??,*:*:4.0:*) + /bin/uname -p 2>/dev/null | grep 86 >/dev/null \ + && { echo i486-ncr-sysv4; exit; } ;; + NCR*:*:4.2:* | MPRAS*:*:4.2:*) + OS_REL='.3' + test -r /etc/.relid \ + && OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid` + /bin/uname -p 2>/dev/null | grep 86 >/dev/null \ + && { echo i486-ncr-sysv4.3${OS_REL}; exit; } + /bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \ + && { echo i586-ncr-sysv4.3${OS_REL}; exit; } + /bin/uname -p 2>/dev/null | /bin/grep pteron >/dev/null \ + && { echo i586-ncr-sysv4.3${OS_REL}; exit; } ;; + m68*:LynxOS:2.*:* | m68*:LynxOS:3.0*:*) + echo m68k-unknown-lynxos${UNAME_RELEASE} + exit ;; + mc68030:UNIX_System_V:4.*:*) + echo m68k-atari-sysv4 + exit ;; + TSUNAMI:LynxOS:2.*:*) + echo sparc-unknown-lynxos${UNAME_RELEASE} + exit ;; + rs6000:LynxOS:2.*:*) + echo rs6000-unknown-lynxos${UNAME_RELEASE} + exit ;; + PowerPC:LynxOS:2.*:* | PowerPC:LynxOS:3.[01]*:* | PowerPC:LynxOS:4.[02]*:*) + echo powerpc-unknown-lynxos${UNAME_RELEASE} + exit ;; + SM[BE]S:UNIX_SV:*:*) + echo mips-dde-sysv${UNAME_RELEASE} + exit ;; + RM*:ReliantUNIX-*:*:*) + echo mips-sni-sysv4 + exit ;; + RM*:SINIX-*:*:*) + echo mips-sni-sysv4 + exit ;; + *:SINIX-*:*:*) + if uname -p 2>/dev/null >/dev/null ; then + UNAME_MACHINE=`(uname -p) 2>/dev/null` + echo ${UNAME_MACHINE}-sni-sysv4 + else + echo ns32k-sni-sysv + fi + exit ;; + PENTIUM:*:4.0*:*) # Unisys `ClearPath HMP IX 4000' SVR4/MP effort + # says + echo i586-unisys-sysv4 + exit ;; + *:UNIX_System_V:4*:FTX*) + # From Gerald Hewes . + # How about differentiating between stratus architectures? -djm + echo hppa1.1-stratus-sysv4 + exit ;; + *:*:*:FTX*) + # From seanf@swdc.stratus.com. + echo i860-stratus-sysv4 + exit ;; + i*86:VOS:*:*) + # From Paul.Green@stratus.com. + echo ${UNAME_MACHINE}-stratus-vos + exit ;; + *:VOS:*:*) + # From Paul.Green@stratus.com. + echo hppa1.1-stratus-vos + exit ;; + mc68*:A/UX:*:*) + echo m68k-apple-aux${UNAME_RELEASE} + exit ;; + news*:NEWS-OS:6*:*) + echo mips-sony-newsos6 + exit ;; + R[34]000:*System_V*:*:* | R4000:UNIX_SYSV:*:* | R*000:UNIX_SV:*:*) + if [ -d /usr/nec ]; then + echo mips-nec-sysv${UNAME_RELEASE} + else + echo mips-unknown-sysv${UNAME_RELEASE} + fi + exit ;; + BeBox:BeOS:*:*) # BeOS running on hardware made by Be, PPC only. + echo powerpc-be-beos + exit ;; + BeMac:BeOS:*:*) # BeOS running on Mac or Mac clone, PPC only. + echo powerpc-apple-beos + exit ;; + BePC:BeOS:*:*) # BeOS running on Intel PC compatible. + echo i586-pc-beos + exit ;; + BePC:Haiku:*:*) # Haiku running on Intel PC compatible. + echo i586-pc-haiku + exit ;; + x86_64:Haiku:*:*) + echo x86_64-unknown-haiku + exit ;; + SX-4:SUPER-UX:*:*) + echo sx4-nec-superux${UNAME_RELEASE} + exit ;; + SX-5:SUPER-UX:*:*) + echo sx5-nec-superux${UNAME_RELEASE} + exit ;; + SX-6:SUPER-UX:*:*) + echo sx6-nec-superux${UNAME_RELEASE} + exit ;; + SX-7:SUPER-UX:*:*) + echo sx7-nec-superux${UNAME_RELEASE} + exit ;; + SX-8:SUPER-UX:*:*) + echo sx8-nec-superux${UNAME_RELEASE} + exit ;; + SX-8R:SUPER-UX:*:*) + echo sx8r-nec-superux${UNAME_RELEASE} + exit ;; + Power*:Rhapsody:*:*) + echo powerpc-apple-rhapsody${UNAME_RELEASE} + exit ;; + *:Rhapsody:*:*) + echo ${UNAME_MACHINE}-apple-rhapsody${UNAME_RELEASE} + exit ;; + *:Darwin:*:*) + UNAME_PROCESSOR=`uname -p` || UNAME_PROCESSOR=unknown + eval $set_cc_for_build + if test "$UNAME_PROCESSOR" = unknown ; then + UNAME_PROCESSOR=powerpc + fi + if test `echo "$UNAME_RELEASE" | sed -e 's/\..*//'` -le 10 ; then + if [ "$CC_FOR_BUILD" != 'no_compiler_found' ]; then + if (echo '#ifdef __LP64__'; echo IS_64BIT_ARCH; echo '#endif') | \ + (CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) | \ + grep IS_64BIT_ARCH >/dev/null + then + case $UNAME_PROCESSOR in + i386) UNAME_PROCESSOR=x86_64 ;; + powerpc) UNAME_PROCESSOR=powerpc64 ;; + esac + fi + fi + elif test "$UNAME_PROCESSOR" = i386 ; then + # Avoid executing cc on OS X 10.9, as it ships with a stub + # that puts up a graphical alert prompting to install + # developer tools. Any system running Mac OS X 10.7 or + # later (Darwin 11 and later) is required to have a 64-bit + # processor. This is not true of the ARM version of Darwin + # that Apple uses in portable devices. + UNAME_PROCESSOR=x86_64 + fi + echo ${UNAME_PROCESSOR}-apple-darwin${UNAME_RELEASE} + exit ;; + *:procnto*:*:* | *:QNX:[0123456789]*:*) + UNAME_PROCESSOR=`uname -p` + if test "$UNAME_PROCESSOR" = "x86"; then + UNAME_PROCESSOR=i386 + UNAME_MACHINE=pc + fi + echo ${UNAME_PROCESSOR}-${UNAME_MACHINE}-nto-qnx${UNAME_RELEASE} + exit ;; + *:QNX:*:4*) + echo i386-pc-qnx + exit ;; + NEO-?:NONSTOP_KERNEL:*:*) + echo neo-tandem-nsk${UNAME_RELEASE} + exit ;; + NSE-*:NONSTOP_KERNEL:*:*) + echo nse-tandem-nsk${UNAME_RELEASE} + exit ;; + NSR-?:NONSTOP_KERNEL:*:*) + echo nsr-tandem-nsk${UNAME_RELEASE} + exit ;; + *:NonStop-UX:*:*) + echo mips-compaq-nonstopux + exit ;; + BS2000:POSIX*:*:*) + echo bs2000-siemens-sysv + exit ;; + DS/*:UNIX_System_V:*:*) + echo ${UNAME_MACHINE}-${UNAME_SYSTEM}-${UNAME_RELEASE} + exit ;; + *:Plan9:*:*) + # "uname -m" is not consistent, so use $cputype instead. 386 + # is converted to i386 for consistency with other x86 + # operating systems. + if test "$cputype" = "386"; then + UNAME_MACHINE=i386 + else + UNAME_MACHINE="$cputype" + fi + echo ${UNAME_MACHINE}-unknown-plan9 + exit ;; + *:TOPS-10:*:*) + echo pdp10-unknown-tops10 + exit ;; + *:TENEX:*:*) + echo pdp10-unknown-tenex + exit ;; + KS10:TOPS-20:*:* | KL10:TOPS-20:*:* | TYPE4:TOPS-20:*:*) + echo pdp10-dec-tops20 + exit ;; + XKL-1:TOPS-20:*:* | TYPE5:TOPS-20:*:*) + echo pdp10-xkl-tops20 + exit ;; + *:TOPS-20:*:*) + echo pdp10-unknown-tops20 + exit ;; + *:ITS:*:*) + echo pdp10-unknown-its + exit ;; + SEI:*:*:SEIUX) + echo mips-sei-seiux${UNAME_RELEASE} + exit ;; + *:DragonFly:*:*) + echo ${UNAME_MACHINE}-unknown-dragonfly`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` + exit ;; + *:*VMS:*:*) + UNAME_MACHINE=`(uname -p) 2>/dev/null` + case "${UNAME_MACHINE}" in + A*) echo alpha-dec-vms ; exit ;; + I*) echo ia64-dec-vms ; exit ;; + V*) echo vax-dec-vms ; exit ;; + esac ;; + *:XENIX:*:SysV) + echo i386-pc-xenix + exit ;; + i*86:skyos:*:*) + echo ${UNAME_MACHINE}-pc-skyos`echo ${UNAME_RELEASE}` | sed -e 's/ .*$//' + exit ;; + i*86:rdos:*:*) + echo ${UNAME_MACHINE}-pc-rdos + exit ;; + i*86:AROS:*:*) + echo ${UNAME_MACHINE}-pc-aros + exit ;; + x86_64:VMkernel:*:*) + echo ${UNAME_MACHINE}-unknown-esx + exit ;; +esac + +cat >&2 < in order to provide the needed +information to handle your system. + +config.guess timestamp = $timestamp + +uname -m = `(uname -m) 2>/dev/null || echo unknown` +uname -r = `(uname -r) 2>/dev/null || echo unknown` +uname -s = `(uname -s) 2>/dev/null || echo unknown` +uname -v = `(uname -v) 2>/dev/null || echo unknown` + +/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null` +/bin/uname -X = `(/bin/uname -X) 2>/dev/null` + +hostinfo = `(hostinfo) 2>/dev/null` +/bin/universe = `(/bin/universe) 2>/dev/null` +/usr/bin/arch -k = `(/usr/bin/arch -k) 2>/dev/null` +/bin/arch = `(/bin/arch) 2>/dev/null` +/usr/bin/oslevel = `(/usr/bin/oslevel) 2>/dev/null` +/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null` + +UNAME_MACHINE = ${UNAME_MACHINE} +UNAME_RELEASE = ${UNAME_RELEASE} +UNAME_SYSTEM = ${UNAME_SYSTEM} +UNAME_VERSION = ${UNAME_VERSION} +EOF + +exit 1 + +# Local variables: +# eval: (add-hook 'write-file-hooks 'time-stamp) +# time-stamp-start: "timestamp='" +# time-stamp-format: "%:y-%02m-%02d" +# time-stamp-end: "'" +# End: diff --git a/third-party/odb/libodb-2.4.0/config/config.sub b/third-party/odb/libodb-2.4.0/config/config.sub new file mode 100755 index 0000000..bba4efb --- /dev/null +++ b/third-party/odb/libodb-2.4.0/config/config.sub @@ -0,0 +1,1799 @@ +#! /bin/sh +# Configuration validation subroutine script. +# Copyright 1992-2014 Free Software Foundation, Inc. + +timestamp='2014-09-11' + +# This file is free software; you can redistribute it and/or modify it +# under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, see . +# +# As a special exception to the GNU General Public License, if you +# distribute this file as part of a program that contains a +# configuration script generated by Autoconf, you may include it under +# the same distribution terms that you use for the rest of that +# program. This Exception is an additional permission under section 7 +# of the GNU General Public License, version 3 ("GPLv3"). + + +# Please send patches with a ChangeLog entry to config-patches@gnu.org. +# +# Configuration subroutine to validate and canonicalize a configuration type. +# Supply the specified configuration type as an argument. +# If it is invalid, we print an error message on stderr and exit with code 1. +# Otherwise, we print the canonical config type on stdout and succeed. + +# You can get the latest version of this script from: +# http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.sub;hb=HEAD + +# This file is supposed to be the same for all GNU packages +# and recognize all the CPU types, system types and aliases +# that are meaningful with *any* GNU software. +# Each package is responsible for reporting which valid configurations +# it does not support. The user should be able to distinguish +# a failure to support a valid configuration from a meaningless +# configuration. + +# The goal of this file is to map all the various variations of a given +# machine specification into a single specification in the form: +# CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM +# or in some cases, the newer four-part form: +# CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM +# It is wrong to echo any other type of specification. + +me=`echo "$0" | sed -e 's,.*/,,'` + +usage="\ +Usage: $0 [OPTION] CPU-MFR-OPSYS + $0 [OPTION] ALIAS + +Canonicalize a configuration name. + +Operation modes: + -h, --help print this help, then exit + -t, --time-stamp print date of last modification, then exit + -v, --version print version number, then exit + +Report bugs and patches to ." + +version="\ +GNU config.sub ($timestamp) + +Copyright 1992-2014 Free Software Foundation, Inc. + +This is free software; see the source for copying conditions. There is NO +warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE." + +help=" +Try \`$me --help' for more information." + +# Parse command line +while test $# -gt 0 ; do + case $1 in + --time-stamp | --time* | -t ) + echo "$timestamp" ; exit ;; + --version | -v ) + echo "$version" ; exit ;; + --help | --h* | -h ) + echo "$usage"; exit ;; + -- ) # Stop option processing + shift; break ;; + - ) # Use stdin as input. + break ;; + -* ) + echo "$me: invalid option $1$help" + exit 1 ;; + + *local*) + # First pass through any local machine types. + echo $1 + exit ;; + + * ) + break ;; + esac +done + +case $# in + 0) echo "$me: missing argument$help" >&2 + exit 1;; + 1) ;; + *) echo "$me: too many arguments$help" >&2 + exit 1;; +esac + +# Separate what the user gave into CPU-COMPANY and OS or KERNEL-OS (if any). +# Here we must recognize all the valid KERNEL-OS combinations. +maybe_os=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\2/'` +case $maybe_os in + nto-qnx* | linux-gnu* | linux-android* | linux-dietlibc | linux-newlib* | \ + linux-musl* | linux-uclibc* | uclinux-uclibc* | uclinux-gnu* | kfreebsd*-gnu* | \ + knetbsd*-gnu* | netbsd*-gnu* | \ + kopensolaris*-gnu* | \ + storm-chaos* | os2-emx* | rtmk-nova*) + os=-$maybe_os + basic_machine=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\1/'` + ;; + android-linux) + os=-linux-android + basic_machine=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\1/'`-unknown + ;; + *) + basic_machine=`echo $1 | sed 's/-[^-]*$//'` + if [ $basic_machine != $1 ] + then os=`echo $1 | sed 's/.*-/-/'` + else os=; fi + ;; +esac + +### Let's recognize common machines as not being operating systems so +### that things like config.sub decstation-3100 work. We also +### recognize some manufacturers as not being operating systems, so we +### can provide default operating systems below. +case $os in + -sun*os*) + # Prevent following clause from handling this invalid input. + ;; + -dec* | -mips* | -sequent* | -encore* | -pc532* | -sgi* | -sony* | \ + -att* | -7300* | -3300* | -delta* | -motorola* | -sun[234]* | \ + -unicom* | -ibm* | -next | -hp | -isi* | -apollo | -altos* | \ + -convergent* | -ncr* | -news | -32* | -3600* | -3100* | -hitachi* |\ + -c[123]* | -convex* | -sun | -crds | -omron* | -dg | -ultra | -tti* | \ + -harris | -dolphin | -highlevel | -gould | -cbm | -ns | -masscomp | \ + -apple | -axis | -knuth | -cray | -microblaze*) + os= + basic_machine=$1 + ;; + -bluegene*) + os=-cnk + ;; + -sim | -cisco | -oki | -wec | -winbond) + os= + basic_machine=$1 + ;; + -scout) + ;; + -wrs) + os=-vxworks + basic_machine=$1 + ;; + -chorusos*) + os=-chorusos + basic_machine=$1 + ;; + -chorusrdb) + os=-chorusrdb + basic_machine=$1 + ;; + -hiux*) + os=-hiuxwe2 + ;; + -sco6) + os=-sco5v6 + basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` + ;; + -sco5) + os=-sco3.2v5 + basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` + ;; + -sco4) + os=-sco3.2v4 + basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` + ;; + -sco3.2.[4-9]*) + os=`echo $os | sed -e 's/sco3.2./sco3.2v/'` + basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` + ;; + -sco3.2v[4-9]*) + # Don't forget version if it is 3.2v4 or newer. + basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` + ;; + -sco5v6*) + # Don't forget version if it is 3.2v4 or newer. + basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` + ;; + -sco*) + os=-sco3.2v2 + basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` + ;; + -udk*) + basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` + ;; + -isc) + os=-isc2.2 + basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` + ;; + -clix*) + basic_machine=clipper-intergraph + ;; + -isc*) + basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` + ;; + -lynx*178) + os=-lynxos178 + ;; + -lynx*5) + os=-lynxos5 + ;; + -lynx*) + os=-lynxos + ;; + -ptx*) + basic_machine=`echo $1 | sed -e 's/86-.*/86-sequent/'` + ;; + -windowsnt*) + os=`echo $os | sed -e 's/windowsnt/winnt/'` + ;; + -psos*) + os=-psos + ;; + -mint | -mint[0-9]*) + basic_machine=m68k-atari + os=-mint + ;; +esac + +# Decode aliases for certain CPU-COMPANY combinations. +case $basic_machine in + # Recognize the basic CPU types without company name. + # Some are omitted here because they have special meanings below. + 1750a | 580 \ + | a29k \ + | aarch64 | aarch64_be \ + | alpha | alphaev[4-8] | alphaev56 | alphaev6[78] | alphapca5[67] \ + | alpha64 | alpha64ev[4-8] | alpha64ev56 | alpha64ev6[78] | alpha64pca5[67] \ + | am33_2.0 \ + | arc | arceb \ + | arm | arm[bl]e | arme[lb] | armv[2-8] | armv[3-8][lb] | armv7[arm] \ + | avr | avr32 \ + | be32 | be64 \ + | bfin \ + | c4x | c8051 | clipper \ + | d10v | d30v | dlx | dsp16xx \ + | epiphany \ + | fido | fr30 | frv \ + | h8300 | h8500 | hppa | hppa1.[01] | hppa2.0 | hppa2.0[nw] | hppa64 \ + | hexagon \ + | i370 | i860 | i960 | ia64 \ + | ip2k | iq2000 \ + | k1om \ + | le32 | le64 \ + | lm32 \ + | m32c | m32r | m32rle | m68000 | m68k | m88k \ + | maxq | mb | microblaze | microblazeel | mcore | mep | metag \ + | mips | mipsbe | mipseb | mipsel | mipsle \ + | mips16 \ + | mips64 | mips64el \ + | mips64octeon | mips64octeonel \ + | mips64orion | mips64orionel \ + | mips64r5900 | mips64r5900el \ + | mips64vr | mips64vrel \ + | mips64vr4100 | mips64vr4100el \ + | mips64vr4300 | mips64vr4300el \ + | mips64vr5000 | mips64vr5000el \ + | mips64vr5900 | mips64vr5900el \ + | mipsisa32 | mipsisa32el \ + | mipsisa32r2 | mipsisa32r2el \ + | mipsisa32r6 | mipsisa32r6el \ + | mipsisa64 | mipsisa64el \ + | mipsisa64r2 | mipsisa64r2el \ + | mipsisa64r6 | mipsisa64r6el \ + | mipsisa64sb1 | mipsisa64sb1el \ + | mipsisa64sr71k | mipsisa64sr71kel \ + | mipsr5900 | mipsr5900el \ + | mipstx39 | mipstx39el \ + | mn10200 | mn10300 \ + | moxie \ + | mt \ + | msp430 \ + | nds32 | nds32le | nds32be \ + | nios | nios2 | nios2eb | nios2el \ + | ns16k | ns32k \ + | open8 | or1k | or1knd | or32 \ + | pdp10 | pdp11 | pj | pjl \ + | powerpc | powerpc64 | powerpc64le | powerpcle \ + | pyramid \ + | riscv32 | riscv64 \ + | rl78 | rx \ + | score \ + | sh | sh[1234] | sh[24]a | sh[24]aeb | sh[23]e | sh[34]eb | sheb | shbe | shle | sh[1234]le | sh3ele \ + | sh64 | sh64le \ + | sparc | sparc64 | sparc64b | sparc64v | sparc86x | sparclet | sparclite \ + | sparcv8 | sparcv9 | sparcv9b | sparcv9v \ + | spu \ + | tahoe | tic4x | tic54x | tic55x | tic6x | tic80 | tron \ + | ubicom32 \ + | v850 | v850e | v850e1 | v850e2 | v850es | v850e2v3 \ + | we32k \ + | x86 | xc16x | xstormy16 | xtensa \ + | z8k | z80) + basic_machine=$basic_machine-unknown + ;; + c54x) + basic_machine=tic54x-unknown + ;; + c55x) + basic_machine=tic55x-unknown + ;; + c6x) + basic_machine=tic6x-unknown + ;; + m6811 | m68hc11 | m6812 | m68hc12 | m68hcs12x | nvptx | picochip) + basic_machine=$basic_machine-unknown + os=-none + ;; + m88110 | m680[12346]0 | m683?2 | m68360 | m5200 | v70 | w65 | z8k) + ;; + ms1) + basic_machine=mt-unknown + ;; + + strongarm | thumb | xscale) + basic_machine=arm-unknown + ;; + xgate) + basic_machine=$basic_machine-unknown + os=-none + ;; + xscaleeb) + basic_machine=armeb-unknown + ;; + + xscaleel) + basic_machine=armel-unknown + ;; + + # We use `pc' rather than `unknown' + # because (1) that's what they normally are, and + # (2) the word "unknown" tends to confuse beginning users. + i*86 | x86_64) + basic_machine=$basic_machine-pc + ;; + # Object if more than one company name word. + *-*-*) + echo Invalid configuration \`$1\': machine \`$basic_machine\' not recognized 1>&2 + exit 1 + ;; + # Recognize the basic CPU types with company name. + 580-* \ + | a29k-* \ + | aarch64-* | aarch64_be-* \ + | alpha-* | alphaev[4-8]-* | alphaev56-* | alphaev6[78]-* \ + | alpha64-* | alpha64ev[4-8]-* | alpha64ev56-* | alpha64ev6[78]-* \ + | alphapca5[67]-* | alpha64pca5[67]-* | arc-* | arceb-* \ + | arm-* | armbe-* | armle-* | armeb-* | armv*-* \ + | avr-* | avr32-* \ + | be32-* | be64-* \ + | bfin-* | bs2000-* \ + | c[123]* | c30-* | [cjt]90-* | c4x-* \ + | c8051-* | clipper-* | craynv-* | cydra-* \ + | d10v-* | d30v-* | dlx-* \ + | elxsi-* \ + | f30[01]-* | f700-* | fido-* | fr30-* | frv-* | fx80-* \ + | h8300-* | h8500-* \ + | hppa-* | hppa1.[01]-* | hppa2.0-* | hppa2.0[nw]-* | hppa64-* \ + | hexagon-* \ + | i*86-* | i860-* | i960-* | ia64-* \ + | ip2k-* | iq2000-* \ + | k1om-* \ + | le32-* | le64-* \ + | lm32-* \ + | m32c-* | m32r-* | m32rle-* \ + | m68000-* | m680[012346]0-* | m68360-* | m683?2-* | m68k-* \ + | m88110-* | m88k-* | maxq-* | mcore-* | metag-* \ + | microblaze-* | microblazeel-* \ + | mips-* | mipsbe-* | mipseb-* | mipsel-* | mipsle-* \ + | mips16-* \ + | mips64-* | mips64el-* \ + | mips64octeon-* | mips64octeonel-* \ + | mips64orion-* | mips64orionel-* \ + | mips64r5900-* | mips64r5900el-* \ + | mips64vr-* | mips64vrel-* \ + | mips64vr4100-* | mips64vr4100el-* \ + | mips64vr4300-* | mips64vr4300el-* \ + | mips64vr5000-* | mips64vr5000el-* \ + | mips64vr5900-* | mips64vr5900el-* \ + | mipsisa32-* | mipsisa32el-* \ + | mipsisa32r2-* | mipsisa32r2el-* \ + | mipsisa32r6-* | mipsisa32r6el-* \ + | mipsisa64-* | mipsisa64el-* \ + | mipsisa64r2-* | mipsisa64r2el-* \ + | mipsisa64r6-* | mipsisa64r6el-* \ + | mipsisa64sb1-* | mipsisa64sb1el-* \ + | mipsisa64sr71k-* | mipsisa64sr71kel-* \ + | mipsr5900-* | mipsr5900el-* \ + | mipstx39-* | mipstx39el-* \ + | mmix-* \ + | mt-* \ + | msp430-* \ + | nds32-* | nds32le-* | nds32be-* \ + | nios-* | nios2-* | nios2eb-* | nios2el-* \ + | none-* | np1-* | ns16k-* | ns32k-* \ + | open8-* \ + | or1k*-* \ + | orion-* \ + | pdp10-* | pdp11-* | pj-* | pjl-* | pn-* | power-* \ + | powerpc-* | powerpc64-* | powerpc64le-* | powerpcle-* \ + | pyramid-* \ + | rl78-* | romp-* | rs6000-* | rx-* \ + | sh-* | sh[1234]-* | sh[24]a-* | sh[24]aeb-* | sh[23]e-* | sh[34]eb-* | sheb-* | shbe-* \ + | shle-* | sh[1234]le-* | sh3ele-* | sh64-* | sh64le-* \ + | sparc-* | sparc64-* | sparc64b-* | sparc64v-* | sparc86x-* | sparclet-* \ + | sparclite-* \ + | sparcv8-* | sparcv9-* | sparcv9b-* | sparcv9v-* | sv1-* | sx?-* \ + | tahoe-* \ + | tic30-* | tic4x-* | tic54x-* | tic55x-* | tic6x-* | tic80-* \ + | tile*-* \ + | tron-* \ + | ubicom32-* \ + | v850-* | v850e-* | v850e1-* | v850es-* | v850e2-* | v850e2v3-* \ + | vax-* \ + | we32k-* \ + | x86-* | x86_64-* | xc16x-* | xps100-* \ + | xstormy16-* | xtensa*-* \ + | ymp-* \ + | z8k-* | z80-*) + ;; + # Recognize the basic CPU types without company name, with glob match. + xtensa*) + basic_machine=$basic_machine-unknown + ;; + # Recognize the various machine names and aliases which stand + # for a CPU type and a company and sometimes even an OS. + 386bsd) + basic_machine=i386-unknown + os=-bsd + ;; + 3b1 | 7300 | 7300-att | att-7300 | pc7300 | safari | unixpc) + basic_machine=m68000-att + ;; + 3b*) + basic_machine=we32k-att + ;; + a29khif) + basic_machine=a29k-amd + os=-udi + ;; + abacus) + basic_machine=abacus-unknown + ;; + adobe68k) + basic_machine=m68010-adobe + os=-scout + ;; + alliant | fx80) + basic_machine=fx80-alliant + ;; + altos | altos3068) + basic_machine=m68k-altos + ;; + am29k) + basic_machine=a29k-none + os=-bsd + ;; + amd64) + basic_machine=x86_64-pc + ;; + amd64-*) + basic_machine=x86_64-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; + amdahl) + basic_machine=580-amdahl + os=-sysv + ;; + amiga | amiga-*) + basic_machine=m68k-unknown + ;; + amigaos | amigados) + basic_machine=m68k-unknown + os=-amigaos + ;; + amigaunix | amix) + basic_machine=m68k-unknown + os=-sysv4 + ;; + apollo68) + basic_machine=m68k-apollo + os=-sysv + ;; + apollo68bsd) + basic_machine=m68k-apollo + os=-bsd + ;; + aros) + basic_machine=i386-pc + os=-aros + ;; + aux) + basic_machine=m68k-apple + os=-aux + ;; + balance) + basic_machine=ns32k-sequent + os=-dynix + ;; + blackfin) + basic_machine=bfin-unknown + os=-linux + ;; + blackfin-*) + basic_machine=bfin-`echo $basic_machine | sed 's/^[^-]*-//'` + os=-linux + ;; + bluegene*) + basic_machine=powerpc-ibm + os=-cnk + ;; + c54x-*) + basic_machine=tic54x-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; + c55x-*) + basic_machine=tic55x-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; + c6x-*) + basic_machine=tic6x-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; + c90) + basic_machine=c90-cray + os=-unicos + ;; + cegcc) + basic_machine=arm-unknown + os=-cegcc + ;; + convex-c1) + basic_machine=c1-convex + os=-bsd + ;; + convex-c2) + basic_machine=c2-convex + os=-bsd + ;; + convex-c32) + basic_machine=c32-convex + os=-bsd + ;; + convex-c34) + basic_machine=c34-convex + os=-bsd + ;; + convex-c38) + basic_machine=c38-convex + os=-bsd + ;; + cray | j90) + basic_machine=j90-cray + os=-unicos + ;; + craynv) + basic_machine=craynv-cray + os=-unicosmp + ;; + cr16 | cr16-*) + basic_machine=cr16-unknown + os=-elf + ;; + crds | unos) + basic_machine=m68k-crds + ;; + crisv32 | crisv32-* | etraxfs*) + basic_machine=crisv32-axis + ;; + cris | cris-* | etrax*) + basic_machine=cris-axis + ;; + crx) + basic_machine=crx-unknown + os=-elf + ;; + da30 | da30-*) + basic_machine=m68k-da30 + ;; + decstation | decstation-3100 | pmax | pmax-* | pmin | dec3100 | decstatn) + basic_machine=mips-dec + ;; + decsystem10* | dec10*) + basic_machine=pdp10-dec + os=-tops10 + ;; + decsystem20* | dec20*) + basic_machine=pdp10-dec + os=-tops20 + ;; + delta | 3300 | motorola-3300 | motorola-delta \ + | 3300-motorola | delta-motorola) + basic_machine=m68k-motorola + ;; + delta88) + basic_machine=m88k-motorola + os=-sysv3 + ;; + dicos) + basic_machine=i686-pc + os=-dicos + ;; + djgpp) + basic_machine=i586-pc + os=-msdosdjgpp + ;; + dpx20 | dpx20-*) + basic_machine=rs6000-bull + os=-bosx + ;; + dpx2* | dpx2*-bull) + basic_machine=m68k-bull + os=-sysv3 + ;; + ebmon29k) + basic_machine=a29k-amd + os=-ebmon + ;; + elxsi) + basic_machine=elxsi-elxsi + os=-bsd + ;; + encore | umax | mmax) + basic_machine=ns32k-encore + ;; + es1800 | OSE68k | ose68k | ose | OSE) + basic_machine=m68k-ericsson + os=-ose + ;; + fx2800) + basic_machine=i860-alliant + ;; + genix) + basic_machine=ns32k-ns + ;; + gmicro) + basic_machine=tron-gmicro + os=-sysv + ;; + go32) + basic_machine=i386-pc + os=-go32 + ;; + h3050r* | hiux*) + basic_machine=hppa1.1-hitachi + os=-hiuxwe2 + ;; + h8300hms) + basic_machine=h8300-hitachi + os=-hms + ;; + h8300xray) + basic_machine=h8300-hitachi + os=-xray + ;; + h8500hms) + basic_machine=h8500-hitachi + os=-hms + ;; + harris) + basic_machine=m88k-harris + os=-sysv3 + ;; + hp300-*) + basic_machine=m68k-hp + ;; + hp300bsd) + basic_machine=m68k-hp + os=-bsd + ;; + hp300hpux) + basic_machine=m68k-hp + os=-hpux + ;; + hp3k9[0-9][0-9] | hp9[0-9][0-9]) + basic_machine=hppa1.0-hp + ;; + hp9k2[0-9][0-9] | hp9k31[0-9]) + basic_machine=m68000-hp + ;; + hp9k3[2-9][0-9]) + basic_machine=m68k-hp + ;; + hp9k6[0-9][0-9] | hp6[0-9][0-9]) + basic_machine=hppa1.0-hp + ;; + hp9k7[0-79][0-9] | hp7[0-79][0-9]) + basic_machine=hppa1.1-hp + ;; + hp9k78[0-9] | hp78[0-9]) + # FIXME: really hppa2.0-hp + basic_machine=hppa1.1-hp + ;; + hp9k8[67]1 | hp8[67]1 | hp9k80[24] | hp80[24] | hp9k8[78]9 | hp8[78]9 | hp9k893 | hp893) + # FIXME: really hppa2.0-hp + basic_machine=hppa1.1-hp + ;; + hp9k8[0-9][13679] | hp8[0-9][13679]) + basic_machine=hppa1.1-hp + ;; + hp9k8[0-9][0-9] | hp8[0-9][0-9]) + basic_machine=hppa1.0-hp + ;; + hppa-next) + os=-nextstep3 + ;; + hppaosf) + basic_machine=hppa1.1-hp + os=-osf + ;; + hppro) + basic_machine=hppa1.1-hp + os=-proelf + ;; + i370-ibm* | ibm*) + basic_machine=i370-ibm + ;; + i*86v32) + basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'` + os=-sysv32 + ;; + i*86v4*) + basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'` + os=-sysv4 + ;; + i*86v) + basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'` + os=-sysv + ;; + i*86sol2) + basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'` + os=-solaris2 + ;; + i386mach) + basic_machine=i386-mach + os=-mach + ;; + i386-vsta | vsta) + basic_machine=i386-unknown + os=-vsta + ;; + iris | iris4d) + basic_machine=mips-sgi + case $os in + -irix*) + ;; + *) + os=-irix4 + ;; + esac + ;; + isi68 | isi) + basic_machine=m68k-isi + os=-sysv + ;; + m68knommu) + basic_machine=m68k-unknown + os=-linux + ;; + m68knommu-*) + basic_machine=m68k-`echo $basic_machine | sed 's/^[^-]*-//'` + os=-linux + ;; + m88k-omron*) + basic_machine=m88k-omron + ;; + magnum | m3230) + basic_machine=mips-mips + os=-sysv + ;; + merlin) + basic_machine=ns32k-utek + os=-sysv + ;; + microblaze*) + basic_machine=microblaze-xilinx + ;; + mingw64) + basic_machine=x86_64-pc + os=-mingw64 + ;; + mingw32) + basic_machine=i686-pc + os=-mingw32 + ;; + mingw32ce) + basic_machine=arm-unknown + os=-mingw32ce + ;; + miniframe) + basic_machine=m68000-convergent + ;; + *mint | -mint[0-9]* | *MiNT | *MiNT[0-9]*) + basic_machine=m68k-atari + os=-mint + ;; + mips3*-*) + basic_machine=`echo $basic_machine | sed -e 's/mips3/mips64/'` + ;; + mips3*) + basic_machine=`echo $basic_machine | sed -e 's/mips3/mips64/'`-unknown + ;; + monitor) + basic_machine=m68k-rom68k + os=-coff + ;; + morphos) + basic_machine=powerpc-unknown + os=-morphos + ;; + moxiebox) + basic_machine=moxie-unknown + os=-moxiebox + ;; + msdos) + basic_machine=i386-pc + os=-msdos + ;; + ms1-*) + basic_machine=`echo $basic_machine | sed -e 's/ms1-/mt-/'` + ;; + msys) + basic_machine=i686-pc + os=-msys + ;; + mvs) + basic_machine=i370-ibm + os=-mvs + ;; + nacl) + basic_machine=le32-unknown + os=-nacl + ;; + ncr3000) + basic_machine=i486-ncr + os=-sysv4 + ;; + netbsd386) + basic_machine=i386-unknown + os=-netbsd + ;; + netwinder) + basic_machine=armv4l-rebel + os=-linux + ;; + news | news700 | news800 | news900) + basic_machine=m68k-sony + os=-newsos + ;; + news1000) + basic_machine=m68030-sony + os=-newsos + ;; + news-3600 | risc-news) + basic_machine=mips-sony + os=-newsos + ;; + necv70) + basic_machine=v70-nec + os=-sysv + ;; + next | m*-next ) + basic_machine=m68k-next + case $os in + -nextstep* ) + ;; + -ns2*) + os=-nextstep2 + ;; + *) + os=-nextstep3 + ;; + esac + ;; + nh3000) + basic_machine=m68k-harris + os=-cxux + ;; + nh[45]000) + basic_machine=m88k-harris + os=-cxux + ;; + nindy960) + basic_machine=i960-intel + os=-nindy + ;; + mon960) + basic_machine=i960-intel + os=-mon960 + ;; + nonstopux) + basic_machine=mips-compaq + os=-nonstopux + ;; + np1) + basic_machine=np1-gould + ;; + neo-tandem) + basic_machine=neo-tandem + ;; + nse-tandem) + basic_machine=nse-tandem + ;; + nsr-tandem) + basic_machine=nsr-tandem + ;; + op50n-* | op60c-*) + basic_machine=hppa1.1-oki + os=-proelf + ;; + openrisc | openrisc-*) + basic_machine=or32-unknown + ;; + os400) + basic_machine=powerpc-ibm + os=-os400 + ;; + OSE68000 | ose68000) + basic_machine=m68000-ericsson + os=-ose + ;; + os68k) + basic_machine=m68k-none + os=-os68k + ;; + pa-hitachi) + basic_machine=hppa1.1-hitachi + os=-hiuxwe2 + ;; + paragon) + basic_machine=i860-intel + os=-osf + ;; + parisc) + basic_machine=hppa-unknown + os=-linux + ;; + parisc-*) + basic_machine=hppa-`echo $basic_machine | sed 's/^[^-]*-//'` + os=-linux + ;; + pbd) + basic_machine=sparc-tti + ;; + pbb) + basic_machine=m68k-tti + ;; + pc532 | pc532-*) + basic_machine=ns32k-pc532 + ;; + pc98) + basic_machine=i386-pc + ;; + pc98-*) + basic_machine=i386-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; + pentium | p5 | k5 | k6 | nexgen | viac3) + basic_machine=i586-pc + ;; + pentiumpro | p6 | 6x86 | athlon | athlon_*) + basic_machine=i686-pc + ;; + pentiumii | pentium2 | pentiumiii | pentium3) + basic_machine=i686-pc + ;; + pentium4) + basic_machine=i786-pc + ;; + pentium-* | p5-* | k5-* | k6-* | nexgen-* | viac3-*) + basic_machine=i586-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; + pentiumpro-* | p6-* | 6x86-* | athlon-*) + basic_machine=i686-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; + pentiumii-* | pentium2-* | pentiumiii-* | pentium3-*) + basic_machine=i686-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; + pentium4-*) + basic_machine=i786-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; + pn) + basic_machine=pn-gould + ;; + power) basic_machine=power-ibm + ;; + ppc | ppcbe) basic_machine=powerpc-unknown + ;; + ppc-* | ppcbe-*) + basic_machine=powerpc-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; + ppcle | powerpclittle | ppc-le | powerpc-little) + basic_machine=powerpcle-unknown + ;; + ppcle-* | powerpclittle-*) + basic_machine=powerpcle-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; + ppc64) basic_machine=powerpc64-unknown + ;; + ppc64-*) basic_machine=powerpc64-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; + ppc64le | powerpc64little | ppc64-le | powerpc64-little) + basic_machine=powerpc64le-unknown + ;; + ppc64le-* | powerpc64little-*) + basic_machine=powerpc64le-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; + ps2) + basic_machine=i386-ibm + ;; + pw32) + basic_machine=i586-unknown + os=-pw32 + ;; + rdos | rdos64) + basic_machine=x86_64-pc + os=-rdos + ;; + rdos32) + basic_machine=i386-pc + os=-rdos + ;; + rom68k) + basic_machine=m68k-rom68k + os=-coff + ;; + rm[46]00) + basic_machine=mips-siemens + ;; + rtpc | rtpc-*) + basic_machine=romp-ibm + ;; + s390 | s390-*) + basic_machine=s390-ibm + ;; + s390x | s390x-*) + basic_machine=s390x-ibm + ;; + sa29200) + basic_machine=a29k-amd + os=-udi + ;; + sb1) + basic_machine=mipsisa64sb1-unknown + ;; + sb1el) + basic_machine=mipsisa64sb1el-unknown + ;; + sde) + basic_machine=mipsisa32-sde + os=-elf + ;; + sei) + basic_machine=mips-sei + os=-seiux + ;; + sequent) + basic_machine=i386-sequent + ;; + sh) + basic_machine=sh-hitachi + os=-hms + ;; + sh5el) + basic_machine=sh5le-unknown + ;; + sh64) + basic_machine=sh64-unknown + ;; + sparclite-wrs | simso-wrs) + basic_machine=sparclite-wrs + os=-vxworks + ;; + sps7) + basic_machine=m68k-bull + os=-sysv2 + ;; + spur) + basic_machine=spur-unknown + ;; + st2000) + basic_machine=m68k-tandem + ;; + stratus) + basic_machine=i860-stratus + os=-sysv4 + ;; + strongarm-* | thumb-*) + basic_machine=arm-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; + sun2) + basic_machine=m68000-sun + ;; + sun2os3) + basic_machine=m68000-sun + os=-sunos3 + ;; + sun2os4) + basic_machine=m68000-sun + os=-sunos4 + ;; + sun3os3) + basic_machine=m68k-sun + os=-sunos3 + ;; + sun3os4) + basic_machine=m68k-sun + os=-sunos4 + ;; + sun4os3) + basic_machine=sparc-sun + os=-sunos3 + ;; + sun4os4) + basic_machine=sparc-sun + os=-sunos4 + ;; + sun4sol2) + basic_machine=sparc-sun + os=-solaris2 + ;; + sun3 | sun3-*) + basic_machine=m68k-sun + ;; + sun4) + basic_machine=sparc-sun + ;; + sun386 | sun386i | roadrunner) + basic_machine=i386-sun + ;; + sv1) + basic_machine=sv1-cray + os=-unicos + ;; + symmetry) + basic_machine=i386-sequent + os=-dynix + ;; + t3e) + basic_machine=alphaev5-cray + os=-unicos + ;; + t90) + basic_machine=t90-cray + os=-unicos + ;; + tile*) + basic_machine=$basic_machine-unknown + os=-linux-gnu + ;; + tx39) + basic_machine=mipstx39-unknown + ;; + tx39el) + basic_machine=mipstx39el-unknown + ;; + toad1) + basic_machine=pdp10-xkl + os=-tops20 + ;; + tower | tower-32) + basic_machine=m68k-ncr + ;; + tpf) + basic_machine=s390x-ibm + os=-tpf + ;; + udi29k) + basic_machine=a29k-amd + os=-udi + ;; + ultra3) + basic_machine=a29k-nyu + os=-sym1 + ;; + v810 | necv810) + basic_machine=v810-nec + os=-none + ;; + vaxv) + basic_machine=vax-dec + os=-sysv + ;; + vms) + basic_machine=vax-dec + os=-vms + ;; + vpp*|vx|vx-*) + basic_machine=f301-fujitsu + ;; + vxworks960) + basic_machine=i960-wrs + os=-vxworks + ;; + vxworks68) + basic_machine=m68k-wrs + os=-vxworks + ;; + vxworks29k) + basic_machine=a29k-wrs + os=-vxworks + ;; + w65*) + basic_machine=w65-wdc + os=-none + ;; + w89k-*) + basic_machine=hppa1.1-winbond + os=-proelf + ;; + xbox) + basic_machine=i686-pc + os=-mingw32 + ;; + xps | xps100) + basic_machine=xps100-honeywell + ;; + xscale-* | xscalee[bl]-*) + basic_machine=`echo $basic_machine | sed 's/^xscale/arm/'` + ;; + ymp) + basic_machine=ymp-cray + os=-unicos + ;; + z8k-*-coff) + basic_machine=z8k-unknown + os=-sim + ;; + z80-*-coff) + basic_machine=z80-unknown + os=-sim + ;; + none) + basic_machine=none-none + os=-none + ;; + +# Here we handle the default manufacturer of certain CPU types. It is in +# some cases the only manufacturer, in others, it is the most popular. + w89k) + basic_machine=hppa1.1-winbond + ;; + op50n) + basic_machine=hppa1.1-oki + ;; + op60c) + basic_machine=hppa1.1-oki + ;; + romp) + basic_machine=romp-ibm + ;; + mmix) + basic_machine=mmix-knuth + ;; + rs6000) + basic_machine=rs6000-ibm + ;; + vax) + basic_machine=vax-dec + ;; + pdp10) + # there are many clones, so DEC is not a safe bet + basic_machine=pdp10-unknown + ;; + pdp11) + basic_machine=pdp11-dec + ;; + we32k) + basic_machine=we32k-att + ;; + sh[1234] | sh[24]a | sh[24]aeb | sh[34]eb | sh[1234]le | sh[23]ele) + basic_machine=sh-unknown + ;; + sparc | sparcv8 | sparcv9 | sparcv9b | sparcv9v) + basic_machine=sparc-sun + ;; + cydra) + basic_machine=cydra-cydrome + ;; + orion) + basic_machine=orion-highlevel + ;; + orion105) + basic_machine=clipper-highlevel + ;; + mac | mpw | mac-mpw) + basic_machine=m68k-apple + ;; + pmac | pmac-mpw) + basic_machine=powerpc-apple + ;; + *-unknown) + # Make sure to match an already-canonicalized machine name. + ;; + *) + echo Invalid configuration \`$1\': machine \`$basic_machine\' not recognized 1>&2 + exit 1 + ;; +esac + +# Here we canonicalize certain aliases for manufacturers. +case $basic_machine in + *-digital*) + basic_machine=`echo $basic_machine | sed 's/digital.*/dec/'` + ;; + *-commodore*) + basic_machine=`echo $basic_machine | sed 's/commodore.*/cbm/'` + ;; + *) + ;; +esac + +# Decode manufacturer-specific aliases for certain operating systems. + +if [ x"$os" != x"" ] +then +case $os in + # First match some system type aliases + # that might get confused with valid system types. + # -solaris* is a basic system type, with this one exception. + -auroraux) + os=-auroraux + ;; + -solaris1 | -solaris1.*) + os=`echo $os | sed -e 's|solaris1|sunos4|'` + ;; + -solaris) + os=-solaris2 + ;; + -svr4*) + os=-sysv4 + ;; + -unixware*) + os=-sysv4.2uw + ;; + -gnu/linux*) + os=`echo $os | sed -e 's|gnu/linux|linux-gnu|'` + ;; + # First accept the basic system types. + # The portable systems comes first. + # Each alternative MUST END IN A *, to match a version number. + # -sysv* is not here because it comes later, after sysvr4. + -gnu* | -bsd* | -mach* | -minix* | -genix* | -ultrix* | -irix* \ + | -*vms* | -sco* | -esix* | -isc* | -aix* | -cnk* | -sunos | -sunos[34]*\ + | -hpux* | -unos* | -osf* | -luna* | -dgux* | -auroraux* | -solaris* \ + | -sym* | -kopensolaris* | -plan9* \ + | -amigaos* | -amigados* | -msdos* | -newsos* | -unicos* | -aof* \ + | -aos* | -aros* \ + | -nindy* | -vxsim* | -vxworks* | -ebmon* | -hms* | -mvs* \ + | -clix* | -riscos* | -uniplus* | -iris* | -rtu* | -xenix* \ + | -hiux* | -386bsd* | -knetbsd* | -mirbsd* | -netbsd* \ + | -bitrig* | -openbsd* | -solidbsd* \ + | -ekkobsd* | -kfreebsd* | -freebsd* | -riscix* | -lynxos* \ + | -bosx* | -nextstep* | -cxux* | -aout* | -elf* | -oabi* \ + | -ptx* | -coff* | -ecoff* | -winnt* | -domain* | -vsta* \ + | -udi* | -eabi* | -lites* | -ieee* | -go32* | -aux* \ + | -chorusos* | -chorusrdb* | -cegcc* \ + | -cygwin* | -msys* | -pe* | -psos* | -moss* | -proelf* | -rtems* \ + | -mingw32* | -mingw64* | -linux-gnu* | -linux-android* \ + | -linux-newlib* | -linux-musl* | -linux-uclibc* \ + | -uxpv* | -beos* | -mpeix* | -udk* | -moxiebox* \ + | -interix* | -uwin* | -mks* | -rhapsody* | -darwin* | -opened* \ + | -openstep* | -oskit* | -conix* | -pw32* | -nonstopux* \ + | -storm-chaos* | -tops10* | -tenex* | -tops20* | -its* \ + | -os2* | -vos* | -palmos* | -uclinux* | -nucleus* \ + | -morphos* | -superux* | -rtmk* | -rtmk-nova* | -windiss* \ + | -powermax* | -dnix* | -nx6 | -nx7 | -sei* | -dragonfly* \ + | -skyos* | -haiku* | -rdos* | -toppers* | -drops* | -es* | -tirtos*) + # Remember, each alternative MUST END IN *, to match a version number. + ;; + -qnx*) + case $basic_machine in + x86-* | i*86-*) + ;; + *) + os=-nto$os + ;; + esac + ;; + -nto-qnx*) + ;; + -nto*) + os=`echo $os | sed -e 's|nto|nto-qnx|'` + ;; + -sim | -es1800* | -hms* | -xray | -os68k* | -none* | -v88r* \ + | -windows* | -osx | -abug | -netware* | -os9* | -beos* | -haiku* \ + | -macos* | -mpw* | -magic* | -mmixware* | -mon960* | -lnews*) + ;; + -mac*) + os=`echo $os | sed -e 's|mac|macos|'` + ;; + -linux-dietlibc) + os=-linux-dietlibc + ;; + -linux*) + os=`echo $os | sed -e 's|linux|linux-gnu|'` + ;; + -sunos5*) + os=`echo $os | sed -e 's|sunos5|solaris2|'` + ;; + -sunos6*) + os=`echo $os | sed -e 's|sunos6|solaris3|'` + ;; + -opened*) + os=-openedition + ;; + -os400*) + os=-os400 + ;; + -wince*) + os=-wince + ;; + -osfrose*) + os=-osfrose + ;; + -osf*) + os=-osf + ;; + -utek*) + os=-bsd + ;; + -dynix*) + os=-bsd + ;; + -acis*) + os=-aos + ;; + -atheos*) + os=-atheos + ;; + -syllable*) + os=-syllable + ;; + -386bsd) + os=-bsd + ;; + -ctix* | -uts*) + os=-sysv + ;; + -nova*) + os=-rtmk-nova + ;; + -ns2 ) + os=-nextstep2 + ;; + -nsk*) + os=-nsk + ;; + # Preserve the version number of sinix5. + -sinix5.*) + os=`echo $os | sed -e 's|sinix|sysv|'` + ;; + -sinix*) + os=-sysv4 + ;; + -tpf*) + os=-tpf + ;; + -triton*) + os=-sysv3 + ;; + -oss*) + os=-sysv3 + ;; + -svr4) + os=-sysv4 + ;; + -svr3) + os=-sysv3 + ;; + -sysvr4) + os=-sysv4 + ;; + # This must come after -sysvr4. + -sysv*) + ;; + -ose*) + os=-ose + ;; + -es1800*) + os=-ose + ;; + -xenix) + os=-xenix + ;; + -*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*) + os=-mint + ;; + -aros*) + os=-aros + ;; + -zvmoe) + os=-zvmoe + ;; + -dicos*) + os=-dicos + ;; + -nacl*) + ;; + -none) + ;; + *) + # Get rid of the `-' at the beginning of $os. + os=`echo $os | sed 's/[^-]*-//'` + echo Invalid configuration \`$1\': system \`$os\' not recognized 1>&2 + exit 1 + ;; +esac +else + +# Here we handle the default operating systems that come with various machines. +# The value should be what the vendor currently ships out the door with their +# machine or put another way, the most popular os provided with the machine. + +# Note that if you're going to try to match "-MANUFACTURER" here (say, +# "-sun"), then you have to tell the case statement up towards the top +# that MANUFACTURER isn't an operating system. Otherwise, code above +# will signal an error saying that MANUFACTURER isn't an operating +# system, and we'll never get to this point. + +case $basic_machine in + score-*) + os=-elf + ;; + spu-*) + os=-elf + ;; + *-acorn) + os=-riscix1.2 + ;; + arm*-rebel) + os=-linux + ;; + arm*-semi) + os=-aout + ;; + c4x-* | tic4x-*) + os=-coff + ;; + c8051-*) + os=-elf + ;; + hexagon-*) + os=-elf + ;; + tic54x-*) + os=-coff + ;; + tic55x-*) + os=-coff + ;; + tic6x-*) + os=-coff + ;; + # This must come before the *-dec entry. + pdp10-*) + os=-tops20 + ;; + pdp11-*) + os=-none + ;; + *-dec | vax-*) + os=-ultrix4.2 + ;; + m68*-apollo) + os=-domain + ;; + i386-sun) + os=-sunos4.0.2 + ;; + m68000-sun) + os=-sunos3 + ;; + m68*-cisco) + os=-aout + ;; + mep-*) + os=-elf + ;; + mips*-cisco) + os=-elf + ;; + mips*-*) + os=-elf + ;; + or32-*) + os=-coff + ;; + *-tti) # must be before sparc entry or we get the wrong os. + os=-sysv3 + ;; + sparc-* | *-sun) + os=-sunos4.1.1 + ;; + *-be) + os=-beos + ;; + *-haiku) + os=-haiku + ;; + *-ibm) + os=-aix + ;; + *-knuth) + os=-mmixware + ;; + *-wec) + os=-proelf + ;; + *-winbond) + os=-proelf + ;; + *-oki) + os=-proelf + ;; + *-hp) + os=-hpux + ;; + *-hitachi) + os=-hiux + ;; + i860-* | *-att | *-ncr | *-altos | *-motorola | *-convergent) + os=-sysv + ;; + *-cbm) + os=-amigaos + ;; + *-dg) + os=-dgux + ;; + *-dolphin) + os=-sysv3 + ;; + m68k-ccur) + os=-rtu + ;; + m88k-omron*) + os=-luna + ;; + *-next ) + os=-nextstep + ;; + *-sequent) + os=-ptx + ;; + *-crds) + os=-unos + ;; + *-ns) + os=-genix + ;; + i370-*) + os=-mvs + ;; + *-next) + os=-nextstep3 + ;; + *-gould) + os=-sysv + ;; + *-highlevel) + os=-bsd + ;; + *-encore) + os=-bsd + ;; + *-sgi) + os=-irix + ;; + *-siemens) + os=-sysv4 + ;; + *-masscomp) + os=-rtu + ;; + f30[01]-fujitsu | f700-fujitsu) + os=-uxpv + ;; + *-rom68k) + os=-coff + ;; + *-*bug) + os=-coff + ;; + *-apple) + os=-macos + ;; + *-atari*) + os=-mint + ;; + *) + os=-none + ;; +esac +fi + +# Here we handle the case where we know the os, and the CPU type, but not the +# manufacturer. We pick the logical manufacturer. +vendor=unknown +case $basic_machine in + *-unknown) + case $os in + -riscix*) + vendor=acorn + ;; + -sunos*) + vendor=sun + ;; + -cnk*|-aix*) + vendor=ibm + ;; + -beos*) + vendor=be + ;; + -hpux*) + vendor=hp + ;; + -mpeix*) + vendor=hp + ;; + -hiux*) + vendor=hitachi + ;; + -unos*) + vendor=crds + ;; + -dgux*) + vendor=dg + ;; + -luna*) + vendor=omron + ;; + -genix*) + vendor=ns + ;; + -mvs* | -opened*) + vendor=ibm + ;; + -os400*) + vendor=ibm + ;; + -ptx*) + vendor=sequent + ;; + -tpf*) + vendor=ibm + ;; + -vxsim* | -vxworks* | -windiss*) + vendor=wrs + ;; + -aux*) + vendor=apple + ;; + -hms*) + vendor=hitachi + ;; + -mpw* | -macos*) + vendor=apple + ;; + -*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*) + vendor=atari + ;; + -vos*) + vendor=stratus + ;; + esac + basic_machine=`echo $basic_machine | sed "s/unknown/$vendor/"` + ;; +esac + +echo $basic_machine$os +exit + +# Local variables: +# eval: (add-hook 'write-file-hooks 'time-stamp) +# time-stamp-start: "timestamp='" +# time-stamp-format: "%:y-%02m-%02d" +# time-stamp-end: "'" +# End: diff --git a/third-party/odb/libodb-2.4.0/config/depcomp b/third-party/odb/libodb-2.4.0/config/depcomp new file mode 100755 index 0000000..e1f51f4 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/config/depcomp @@ -0,0 +1,787 @@ +#! /bin/sh +# depcomp - compile a program generating dependencies as side-effects + +scriptversion=2012-07-12.20; # UTC + +# Copyright (C) 1999-2012 Free Software Foundation, Inc. + +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2, or (at your option) +# any later version. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + +# As a special exception to the GNU General Public License, if you +# distribute this file as part of a program that contains a +# configuration script generated by Autoconf, you may include it under +# the same distribution terms that you use for the rest of that program. + +# Originally written by Alexandre Oliva . + +case $1 in + '') + echo "$0: No command. Try '$0 --help' for more information." 1>&2 + exit 1; + ;; + -h | --h*) + cat <<\EOF +Usage: depcomp [--help] [--version] PROGRAM [ARGS] + +Run PROGRAMS ARGS to compile a file, generating dependencies +as side-effects. + +Environment variables: + depmode Dependency tracking mode. + source Source file read by 'PROGRAMS ARGS'. + object Object file output by 'PROGRAMS ARGS'. + DEPDIR directory where to store dependencies. + depfile Dependency file to output. + tmpdepfile Temporary file to use when outputting dependencies. + libtool Whether libtool is used (yes/no). + +Report bugs to . +EOF + exit $? + ;; + -v | --v*) + echo "depcomp $scriptversion" + exit $? + ;; +esac + +# A tabulation character. +tab=' ' +# A newline character. +nl=' +' + +if test -z "$depmode" || test -z "$source" || test -z "$object"; then + echo "depcomp: Variables source, object and depmode must be set" 1>&2 + exit 1 +fi + +# Dependencies for sub/bar.o or sub/bar.obj go into sub/.deps/bar.Po. +depfile=${depfile-`echo "$object" | + sed 's|[^\\/]*$|'${DEPDIR-.deps}'/&|;s|\.\([^.]*\)$|.P\1|;s|Pobj$|Po|'`} +tmpdepfile=${tmpdepfile-`echo "$depfile" | sed 's/\.\([^.]*\)$/.T\1/'`} + +rm -f "$tmpdepfile" + +# Avoid interferences from the environment. +gccflag= dashmflag= + +# Some modes work just like other modes, but use different flags. We +# parameterize here, but still list the modes in the big case below, +# to make depend.m4 easier to write. Note that we *cannot* use a case +# here, because this file can only contain one case statement. +if test "$depmode" = hp; then + # HP compiler uses -M and no extra arg. + gccflag=-M + depmode=gcc +fi + +if test "$depmode" = dashXmstdout; then + # This is just like dashmstdout with a different argument. + dashmflag=-xM + depmode=dashmstdout +fi + +cygpath_u="cygpath -u -f -" +if test "$depmode" = msvcmsys; then + # This is just like msvisualcpp but w/o cygpath translation. + # Just convert the backslash-escaped backslashes to single forward + # slashes to satisfy depend.m4 + cygpath_u='sed s,\\\\,/,g' + depmode=msvisualcpp +fi + +if test "$depmode" = msvc7msys; then + # This is just like msvc7 but w/o cygpath translation. + # Just convert the backslash-escaped backslashes to single forward + # slashes to satisfy depend.m4 + cygpath_u='sed s,\\\\,/,g' + depmode=msvc7 +fi + +if test "$depmode" = xlc; then + # IBM C/C++ Compilers xlc/xlC can output gcc-like dependency information. + gccflag=-qmakedep=gcc,-MF + depmode=gcc +fi + +case "$depmode" in +gcc3) +## gcc 3 implements dependency tracking that does exactly what +## we want. Yay! Note: for some reason libtool 1.4 doesn't like +## it if -MD -MP comes after the -MF stuff. Hmm. +## Unfortunately, FreeBSD c89 acceptance of flags depends upon +## the command line argument order; so add the flags where they +## appear in depend2.am. Note that the slowdown incurred here +## affects only configure: in makefiles, %FASTDEP% shortcuts this. + for arg + do + case $arg in + -c) set fnord "$@" -MT "$object" -MD -MP -MF "$tmpdepfile" "$arg" ;; + *) set fnord "$@" "$arg" ;; + esac + shift # fnord + shift # $arg + done + "$@" + stat=$? + if test $stat -eq 0; then : + else + rm -f "$tmpdepfile" + exit $stat + fi + mv "$tmpdepfile" "$depfile" + ;; + +gcc) +## Note that this doesn't just cater to obsosete pre-3.x GCC compilers. +## but also to in-use compilers like IMB xlc/xlC and the HP C compiler. +## (see the conditional assignment to $gccflag above). +## There are various ways to get dependency output from gcc. Here's +## why we pick this rather obscure method: +## - Don't want to use -MD because we'd like the dependencies to end +## up in a subdir. Having to rename by hand is ugly. +## (We might end up doing this anyway to support other compilers.) +## - The DEPENDENCIES_OUTPUT environment variable makes gcc act like +## -MM, not -M (despite what the docs say). Also, it might not be +## supported by the other compilers which use the 'gcc' depmode. +## - Using -M directly means running the compiler twice (even worse +## than renaming). + if test -z "$gccflag"; then + gccflag=-MD, + fi + "$@" -Wp,"$gccflag$tmpdepfile" + stat=$? + if test $stat -eq 0; then : + else + rm -f "$tmpdepfile" + exit $stat + fi + rm -f "$depfile" + echo "$object : \\" > "$depfile" + alpha=ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz +## The second -e expression handles DOS-style file names with drive letters. + sed -e 's/^[^:]*: / /' \ + -e 's/^['$alpha']:\/[^:]*: / /' < "$tmpdepfile" >> "$depfile" +## This next piece of magic avoids the "deleted header file" problem. +## The problem is that when a header file which appears in a .P file +## is deleted, the dependency causes make to die (because there is +## typically no way to rebuild the header). We avoid this by adding +## dummy dependencies for each header file. Too bad gcc doesn't do +## this for us directly. + tr ' ' "$nl" < "$tmpdepfile" | +## Some versions of gcc put a space before the ':'. On the theory +## that the space means something, we add a space to the output as +## well. hp depmode also adds that space, but also prefixes the VPATH +## to the object. Take care to not repeat it in the output. +## Some versions of the HPUX 10.20 sed can't process this invocation +## correctly. Breaking it into two sed invocations is a workaround. + sed -e 's/^\\$//' -e '/^$/d' -e "s|.*$object$||" -e '/:$/d' \ + | sed -e 's/$/ :/' >> "$depfile" + rm -f "$tmpdepfile" + ;; + +hp) + # This case exists only to let depend.m4 do its work. It works by + # looking at the text of this script. This case will never be run, + # since it is checked for above. + exit 1 + ;; + +sgi) + if test "$libtool" = yes; then + "$@" "-Wp,-MDupdate,$tmpdepfile" + else + "$@" -MDupdate "$tmpdepfile" + fi + stat=$? + if test $stat -eq 0; then : + else + rm -f "$tmpdepfile" + exit $stat + fi + rm -f "$depfile" + + if test -f "$tmpdepfile"; then # yes, the sourcefile depend on other files + echo "$object : \\" > "$depfile" + + # Clip off the initial element (the dependent). Don't try to be + # clever and replace this with sed code, as IRIX sed won't handle + # lines with more than a fixed number of characters (4096 in + # IRIX 6.2 sed, 8192 in IRIX 6.5). We also remove comment lines; + # the IRIX cc adds comments like '#:fec' to the end of the + # dependency line. + tr ' ' "$nl" < "$tmpdepfile" \ + | sed -e 's/^.*\.o://' -e 's/#.*$//' -e '/^$/ d' | \ + tr "$nl" ' ' >> "$depfile" + echo >> "$depfile" + + # The second pass generates a dummy entry for each header file. + tr ' ' "$nl" < "$tmpdepfile" \ + | sed -e 's/^.*\.o://' -e 's/#.*$//' -e '/^$/ d' -e 's/$/:/' \ + >> "$depfile" + else + # The sourcefile does not contain any dependencies, so just + # store a dummy comment line, to avoid errors with the Makefile + # "include basename.Plo" scheme. + echo "#dummy" > "$depfile" + fi + rm -f "$tmpdepfile" + ;; + +xlc) + # This case exists only to let depend.m4 do its work. It works by + # looking at the text of this script. This case will never be run, + # since it is checked for above. + exit 1 + ;; + +aix) + # The C for AIX Compiler uses -M and outputs the dependencies + # in a .u file. In older versions, this file always lives in the + # current directory. Also, the AIX compiler puts '$object:' at the + # start of each line; $object doesn't have directory information. + # Version 6 uses the directory in both cases. + dir=`echo "$object" | sed -e 's|/[^/]*$|/|'` + test "x$dir" = "x$object" && dir= + base=`echo "$object" | sed -e 's|^.*/||' -e 's/\.o$//' -e 's/\.lo$//'` + if test "$libtool" = yes; then + tmpdepfile1=$dir$base.u + tmpdepfile2=$base.u + tmpdepfile3=$dir.libs/$base.u + "$@" -Wc,-M + else + tmpdepfile1=$dir$base.u + tmpdepfile2=$dir$base.u + tmpdepfile3=$dir$base.u + "$@" -M + fi + stat=$? + + if test $stat -eq 0; then : + else + rm -f "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3" + exit $stat + fi + + for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3" + do + test -f "$tmpdepfile" && break + done + if test -f "$tmpdepfile"; then + # Each line is of the form 'foo.o: dependent.h'. + # Do two passes, one to just change these to + # '$object: dependent.h' and one to simply 'dependent.h:'. + sed -e "s,^.*\.[a-z]*:,$object:," < "$tmpdepfile" > "$depfile" + sed -e 's,^.*\.[a-z]*:['"$tab"' ]*,,' -e 's,$,:,' < "$tmpdepfile" >> "$depfile" + else + # The sourcefile does not contain any dependencies, so just + # store a dummy comment line, to avoid errors with the Makefile + # "include basename.Plo" scheme. + echo "#dummy" > "$depfile" + fi + rm -f "$tmpdepfile" + ;; + +icc) + # Intel's C compiler anf tcc (Tiny C Compiler) understand '-MD -MF file'. + # However on + # $CC -MD -MF foo.d -c -o sub/foo.o sub/foo.c + # ICC 7.0 will fill foo.d with something like + # foo.o: sub/foo.c + # foo.o: sub/foo.h + # which is wrong. We want + # sub/foo.o: sub/foo.c + # sub/foo.o: sub/foo.h + # sub/foo.c: + # sub/foo.h: + # ICC 7.1 will output + # foo.o: sub/foo.c sub/foo.h + # and will wrap long lines using '\': + # foo.o: sub/foo.c ... \ + # sub/foo.h ... \ + # ... + # tcc 0.9.26 (FIXME still under development at the moment of writing) + # will emit a similar output, but also prepend the continuation lines + # with horizontal tabulation characters. + "$@" -MD -MF "$tmpdepfile" + stat=$? + if test $stat -eq 0; then : + else + rm -f "$tmpdepfile" + exit $stat + fi + rm -f "$depfile" + # Each line is of the form 'foo.o: dependent.h', + # or 'foo.o: dep1.h dep2.h \', or ' dep3.h dep4.h \'. + # Do two passes, one to just change these to + # '$object: dependent.h' and one to simply 'dependent.h:'. + sed -e "s/^[ $tab][ $tab]*/ /" -e "s,^[^:]*:,$object :," \ + < "$tmpdepfile" > "$depfile" + sed ' + s/[ '"$tab"'][ '"$tab"']*/ /g + s/^ *// + s/ *\\*$// + s/^[^:]*: *// + /^$/d + /:$/d + s/$/ :/ + ' < "$tmpdepfile" >> "$depfile" + rm -f "$tmpdepfile" + ;; + +## The order of this option in the case statement is important, since the +## shell code in configure will try each of these formats in the order +## listed in this file. A plain '-MD' option would be understood by many +## compilers, so we must ensure this comes after the gcc and icc options. +pgcc) + # Portland's C compiler understands '-MD'. + # Will always output deps to 'file.d' where file is the root name of the + # source file under compilation, even if file resides in a subdirectory. + # The object file name does not affect the name of the '.d' file. + # pgcc 10.2 will output + # foo.o: sub/foo.c sub/foo.h + # and will wrap long lines using '\' : + # foo.o: sub/foo.c ... \ + # sub/foo.h ... \ + # ... + dir=`echo "$object" | sed -e 's|/[^/]*$|/|'` + test "x$dir" = "x$object" && dir= + # Use the source, not the object, to determine the base name, since + # that's sadly what pgcc will do too. + base=`echo "$source" | sed -e 's|^.*/||' -e 's/\.[-_a-zA-Z0-9]*$//'` + tmpdepfile="$base.d" + + # For projects that build the same source file twice into different object + # files, the pgcc approach of using the *source* file root name can cause + # problems in parallel builds. Use a locking strategy to avoid stomping on + # the same $tmpdepfile. + lockdir="$base.d-lock" + trap "echo '$0: caught signal, cleaning up...' >&2; rm -rf $lockdir" 1 2 13 15 + numtries=100 + i=$numtries + while test $i -gt 0 ; do + # mkdir is a portable test-and-set. + if mkdir $lockdir 2>/dev/null; then + # This process acquired the lock. + "$@" -MD + stat=$? + # Release the lock. + rm -rf $lockdir + break + else + ## the lock is being held by a different process, + ## wait until the winning process is done or we timeout + while test -d $lockdir && test $i -gt 0; do + sleep 1 + i=`expr $i - 1` + done + fi + i=`expr $i - 1` + done + trap - 1 2 13 15 + if test $i -le 0; then + echo "$0: failed to acquire lock after $numtries attempts" >&2 + echo "$0: check lockdir '$lockdir'" >&2 + exit 1 + fi + + if test $stat -ne 0; then + rm -f "$tmpdepfile" + exit $stat + fi + rm -f "$depfile" + # Each line is of the form `foo.o: dependent.h', + # or `foo.o: dep1.h dep2.h \', or ` dep3.h dep4.h \'. + # Do two passes, one to just change these to + # `$object: dependent.h' and one to simply `dependent.h:'. + sed "s,^[^:]*:,$object :," < "$tmpdepfile" > "$depfile" + # Some versions of the HPUX 10.20 sed can't process this invocation + # correctly. Breaking it into two sed invocations is a workaround. + sed 's,^[^:]*: \(.*\)$,\1,;s/^\\$//;/^$/d;/:$/d' < "$tmpdepfile" | + sed -e 's/$/ :/' >> "$depfile" + rm -f "$tmpdepfile" + ;; + +hp2) + # The "hp" stanza above does not work with aCC (C++) and HP's ia64 + # compilers, which have integrated preprocessors. The correct option + # to use with these is +Maked; it writes dependencies to a file named + # 'foo.d', which lands next to the object file, wherever that + # happens to be. + # Much of this is similar to the tru64 case; see comments there. + dir=`echo "$object" | sed -e 's|/[^/]*$|/|'` + test "x$dir" = "x$object" && dir= + base=`echo "$object" | sed -e 's|^.*/||' -e 's/\.o$//' -e 's/\.lo$//'` + if test "$libtool" = yes; then + tmpdepfile1=$dir$base.d + tmpdepfile2=$dir.libs/$base.d + "$@" -Wc,+Maked + else + tmpdepfile1=$dir$base.d + tmpdepfile2=$dir$base.d + "$@" +Maked + fi + stat=$? + if test $stat -eq 0; then : + else + rm -f "$tmpdepfile1" "$tmpdepfile2" + exit $stat + fi + + for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2" + do + test -f "$tmpdepfile" && break + done + if test -f "$tmpdepfile"; then + sed -e "s,^.*\.[a-z]*:,$object:," "$tmpdepfile" > "$depfile" + # Add 'dependent.h:' lines. + sed -ne '2,${ + s/^ *// + s/ \\*$// + s/$/:/ + p + }' "$tmpdepfile" >> "$depfile" + else + echo "#dummy" > "$depfile" + fi + rm -f "$tmpdepfile" "$tmpdepfile2" + ;; + +tru64) + # The Tru64 compiler uses -MD to generate dependencies as a side + # effect. 'cc -MD -o foo.o ...' puts the dependencies into 'foo.o.d'. + # At least on Alpha/Redhat 6.1, Compaq CCC V6.2-504 seems to put + # dependencies in 'foo.d' instead, so we check for that too. + # Subdirectories are respected. + dir=`echo "$object" | sed -e 's|/[^/]*$|/|'` + test "x$dir" = "x$object" && dir= + base=`echo "$object" | sed -e 's|^.*/||' -e 's/\.o$//' -e 's/\.lo$//'` + + if test "$libtool" = yes; then + # With Tru64 cc, shared objects can also be used to make a + # static library. This mechanism is used in libtool 1.4 series to + # handle both shared and static libraries in a single compilation. + # With libtool 1.4, dependencies were output in $dir.libs/$base.lo.d. + # + # With libtool 1.5 this exception was removed, and libtool now + # generates 2 separate objects for the 2 libraries. These two + # compilations output dependencies in $dir.libs/$base.o.d and + # in $dir$base.o.d. We have to check for both files, because + # one of the two compilations can be disabled. We should prefer + # $dir$base.o.d over $dir.libs/$base.o.d because the latter is + # automatically cleaned when .libs/ is deleted, while ignoring + # the former would cause a distcleancheck panic. + tmpdepfile1=$dir.libs/$base.lo.d # libtool 1.4 + tmpdepfile2=$dir$base.o.d # libtool 1.5 + tmpdepfile3=$dir.libs/$base.o.d # libtool 1.5 + tmpdepfile4=$dir.libs/$base.d # Compaq CCC V6.2-504 + "$@" -Wc,-MD + else + tmpdepfile1=$dir$base.o.d + tmpdepfile2=$dir$base.d + tmpdepfile3=$dir$base.d + tmpdepfile4=$dir$base.d + "$@" -MD + fi + + stat=$? + if test $stat -eq 0; then : + else + rm -f "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3" "$tmpdepfile4" + exit $stat + fi + + for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3" "$tmpdepfile4" + do + test -f "$tmpdepfile" && break + done + if test -f "$tmpdepfile"; then + sed -e "s,^.*\.[a-z]*:,$object:," < "$tmpdepfile" > "$depfile" + sed -e 's,^.*\.[a-z]*:['"$tab"' ]*,,' -e 's,$,:,' < "$tmpdepfile" >> "$depfile" + else + echo "#dummy" > "$depfile" + fi + rm -f "$tmpdepfile" + ;; + +msvc7) + if test "$libtool" = yes; then + showIncludes=-Wc,-showIncludes + else + showIncludes=-showIncludes + fi + "$@" $showIncludes > "$tmpdepfile" + stat=$? + grep -v '^Note: including file: ' "$tmpdepfile" + if test "$stat" = 0; then : + else + rm -f "$tmpdepfile" + exit $stat + fi + rm -f "$depfile" + echo "$object : \\" > "$depfile" + # The first sed program below extracts the file names and escapes + # backslashes for cygpath. The second sed program outputs the file + # name when reading, but also accumulates all include files in the + # hold buffer in order to output them again at the end. This only + # works with sed implementations that can handle large buffers. + sed < "$tmpdepfile" -n ' +/^Note: including file: *\(.*\)/ { + s//\1/ + s/\\/\\\\/g + p +}' | $cygpath_u | sort -u | sed -n ' +s/ /\\ /g +s/\(.*\)/'"$tab"'\1 \\/p +s/.\(.*\) \\/\1:/ +H +$ { + s/.*/'"$tab"'/ + G + p +}' >> "$depfile" + rm -f "$tmpdepfile" + ;; + +msvc7msys) + # This case exists only to let depend.m4 do its work. It works by + # looking at the text of this script. This case will never be run, + # since it is checked for above. + exit 1 + ;; + +#nosideeffect) + # This comment above is used by automake to tell side-effect + # dependency tracking mechanisms from slower ones. + +dashmstdout) + # Important note: in order to support this mode, a compiler *must* + # always write the preprocessed file to stdout, regardless of -o. + "$@" || exit $? + + # Remove the call to Libtool. + if test "$libtool" = yes; then + while test "X$1" != 'X--mode=compile'; do + shift + done + shift + fi + + # Remove '-o $object'. + IFS=" " + for arg + do + case $arg in + -o) + shift + ;; + $object) + shift + ;; + *) + set fnord "$@" "$arg" + shift # fnord + shift # $arg + ;; + esac + done + + test -z "$dashmflag" && dashmflag=-M + # Require at least two characters before searching for ':' + # in the target name. This is to cope with DOS-style filenames: + # a dependency such as 'c:/foo/bar' could be seen as target 'c' otherwise. + "$@" $dashmflag | + sed 's:^['"$tab"' ]*[^:'"$tab"' ][^:][^:]*\:['"$tab"' ]*:'"$object"'\: :' > "$tmpdepfile" + rm -f "$depfile" + cat < "$tmpdepfile" > "$depfile" + tr ' ' "$nl" < "$tmpdepfile" | \ +## Some versions of the HPUX 10.20 sed can't process this invocation +## correctly. Breaking it into two sed invocations is a workaround. + sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' | sed -e 's/$/ :/' >> "$depfile" + rm -f "$tmpdepfile" + ;; + +dashXmstdout) + # This case only exists to satisfy depend.m4. It is never actually + # run, as this mode is specially recognized in the preamble. + exit 1 + ;; + +makedepend) + "$@" || exit $? + # Remove any Libtool call + if test "$libtool" = yes; then + while test "X$1" != 'X--mode=compile'; do + shift + done + shift + fi + # X makedepend + shift + cleared=no eat=no + for arg + do + case $cleared in + no) + set ""; shift + cleared=yes ;; + esac + if test $eat = yes; then + eat=no + continue + fi + case "$arg" in + -D*|-I*) + set fnord "$@" "$arg"; shift ;; + # Strip any option that makedepend may not understand. Remove + # the object too, otherwise makedepend will parse it as a source file. + -arch) + eat=yes ;; + -*|$object) + ;; + *) + set fnord "$@" "$arg"; shift ;; + esac + done + obj_suffix=`echo "$object" | sed 's/^.*\././'` + touch "$tmpdepfile" + ${MAKEDEPEND-makedepend} -o"$obj_suffix" -f"$tmpdepfile" "$@" + rm -f "$depfile" + # makedepend may prepend the VPATH from the source file name to the object. + # No need to regex-escape $object, excess matching of '.' is harmless. + sed "s|^.*\($object *:\)|\1|" "$tmpdepfile" > "$depfile" + sed '1,2d' "$tmpdepfile" | tr ' ' "$nl" | \ +## Some versions of the HPUX 10.20 sed can't process this invocation +## correctly. Breaking it into two sed invocations is a workaround. + sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' | sed -e 's/$/ :/' >> "$depfile" + rm -f "$tmpdepfile" "$tmpdepfile".bak + ;; + +cpp) + # Important note: in order to support this mode, a compiler *must* + # always write the preprocessed file to stdout. + "$@" || exit $? + + # Remove the call to Libtool. + if test "$libtool" = yes; then + while test "X$1" != 'X--mode=compile'; do + shift + done + shift + fi + + # Remove '-o $object'. + IFS=" " + for arg + do + case $arg in + -o) + shift + ;; + $object) + shift + ;; + *) + set fnord "$@" "$arg" + shift # fnord + shift # $arg + ;; + esac + done + + "$@" -E | + sed -n -e '/^# [0-9][0-9]* "\([^"]*\)".*/ s:: \1 \\:p' \ + -e '/^#line [0-9][0-9]* "\([^"]*\)".*/ s:: \1 \\:p' | + sed '$ s: \\$::' > "$tmpdepfile" + rm -f "$depfile" + echo "$object : \\" > "$depfile" + cat < "$tmpdepfile" >> "$depfile" + sed < "$tmpdepfile" '/^$/d;s/^ //;s/ \\$//;s/$/ :/' >> "$depfile" + rm -f "$tmpdepfile" + ;; + +msvisualcpp) + # Important note: in order to support this mode, a compiler *must* + # always write the preprocessed file to stdout. + "$@" || exit $? + + # Remove the call to Libtool. + if test "$libtool" = yes; then + while test "X$1" != 'X--mode=compile'; do + shift + done + shift + fi + + IFS=" " + for arg + do + case "$arg" in + -o) + shift + ;; + $object) + shift + ;; + "-Gm"|"/Gm"|"-Gi"|"/Gi"|"-ZI"|"/ZI") + set fnord "$@" + shift + shift + ;; + *) + set fnord "$@" "$arg" + shift + shift + ;; + esac + done + "$@" -E 2>/dev/null | + sed -n '/^#line [0-9][0-9]* "\([^"]*\)"/ s::\1:p' | $cygpath_u | sort -u > "$tmpdepfile" + rm -f "$depfile" + echo "$object : \\" > "$depfile" + sed < "$tmpdepfile" -n -e 's% %\\ %g' -e '/^\(.*\)$/ s::'"$tab"'\1 \\:p' >> "$depfile" + echo "$tab" >> "$depfile" + sed < "$tmpdepfile" -n -e 's% %\\ %g' -e '/^\(.*\)$/ s::\1\::p' >> "$depfile" + rm -f "$tmpdepfile" + ;; + +msvcmsys) + # This case exists only to let depend.m4 do its work. It works by + # looking at the text of this script. This case will never be run, + # since it is checked for above. + exit 1 + ;; + +none) + exec "$@" + ;; + +*) + echo "Unknown depmode $depmode" 1>&2 + exit 1 + ;; +esac + +exit 0 + +# Local Variables: +# mode: shell-script +# sh-indentation: 2 +# eval: (add-hook 'write-file-hooks 'time-stamp) +# time-stamp-start: "scriptversion=" +# time-stamp-format: "%:y-%02m-%02d.%02H" +# time-stamp-time-zone: "UTC" +# time-stamp-end: "; # UTC" +# End: diff --git a/third-party/odb/libodb-2.4.0/config/install-sh b/third-party/odb/libodb-2.4.0/config/install-sh new file mode 100755 index 0000000..377bb86 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/config/install-sh @@ -0,0 +1,527 @@ +#!/bin/sh +# install - install a program, script, or datafile + +scriptversion=2011-11-20.07; # UTC + +# This originates from X11R5 (mit/util/scripts/install.sh), which was +# later released in X11R6 (xc/config/util/install.sh) with the +# following copyright and license. +# +# Copyright (C) 1994 X Consortium +# +# 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 +# X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +# AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNEC- +# TION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +# +# Except as contained in this notice, the name of the X Consortium shall not +# be used in advertising or otherwise to promote the sale, use or other deal- +# ings in this Software without prior written authorization from the X Consor- +# tium. +# +# +# FSF changes to this file are in the public domain. +# +# Calling this script install-sh is preferred over install.sh, to prevent +# 'make' implicit rules from creating a file called install from it +# when there is no Makefile. +# +# This script is compatible with the BSD install script, but was written +# from scratch. + +nl=' +' +IFS=" "" $nl" + +# set DOITPROG to echo to test this script + +# Don't use :- since 4.3BSD and earlier shells don't like it. +doit=${DOITPROG-} +if test -z "$doit"; then + doit_exec=exec +else + doit_exec=$doit +fi + +# Put in absolute file names if you don't have them in your path; +# or use environment vars. + +chgrpprog=${CHGRPPROG-chgrp} +chmodprog=${CHMODPROG-chmod} +chownprog=${CHOWNPROG-chown} +cmpprog=${CMPPROG-cmp} +cpprog=${CPPROG-cp} +mkdirprog=${MKDIRPROG-mkdir} +mvprog=${MVPROG-mv} +rmprog=${RMPROG-rm} +stripprog=${STRIPPROG-strip} + +posix_glob='?' +initialize_posix_glob=' + test "$posix_glob" != "?" || { + if (set -f) 2>/dev/null; then + posix_glob= + else + posix_glob=: + fi + } +' + +posix_mkdir= + +# Desired mode of installed file. +mode=0755 + +chgrpcmd= +chmodcmd=$chmodprog +chowncmd= +mvcmd=$mvprog +rmcmd="$rmprog -f" +stripcmd= + +src= +dst= +dir_arg= +dst_arg= + +copy_on_change=false +no_target_directory= + +usage="\ +Usage: $0 [OPTION]... [-T] SRCFILE DSTFILE + or: $0 [OPTION]... SRCFILES... DIRECTORY + or: $0 [OPTION]... -t DIRECTORY SRCFILES... + or: $0 [OPTION]... -d DIRECTORIES... + +In the 1st form, copy SRCFILE to DSTFILE. +In the 2nd and 3rd, copy all SRCFILES to DIRECTORY. +In the 4th, create DIRECTORIES. + +Options: + --help display this help and exit. + --version display version info and exit. + + -c (ignored) + -C install only if different (preserve the last data modification time) + -d create directories instead of installing files. + -g GROUP $chgrpprog installed files to GROUP. + -m MODE $chmodprog installed files to MODE. + -o USER $chownprog installed files to USER. + -s $stripprog installed files. + -t DIRECTORY install into DIRECTORY. + -T report an error if DSTFILE is a directory. + +Environment variables override the default commands: + CHGRPPROG CHMODPROG CHOWNPROG CMPPROG CPPROG MKDIRPROG MVPROG + RMPROG STRIPPROG +" + +while test $# -ne 0; do + case $1 in + -c) ;; + + -C) copy_on_change=true;; + + -d) dir_arg=true;; + + -g) chgrpcmd="$chgrpprog $2" + shift;; + + --help) echo "$usage"; exit $?;; + + -m) mode=$2 + case $mode in + *' '* | *' '* | *' +'* | *'*'* | *'?'* | *'['*) + echo "$0: invalid mode: $mode" >&2 + exit 1;; + esac + shift;; + + -o) chowncmd="$chownprog $2" + shift;; + + -s) stripcmd=$stripprog;; + + -t) dst_arg=$2 + # Protect names problematic for 'test' and other utilities. + case $dst_arg in + -* | [=\(\)!]) dst_arg=./$dst_arg;; + esac + shift;; + + -T) no_target_directory=true;; + + --version) echo "$0 $scriptversion"; exit $?;; + + --) shift + break;; + + -*) echo "$0: invalid option: $1" >&2 + exit 1;; + + *) break;; + esac + shift +done + +if test $# -ne 0 && test -z "$dir_arg$dst_arg"; then + # When -d is used, all remaining arguments are directories to create. + # When -t is used, the destination is already specified. + # Otherwise, the last argument is the destination. Remove it from $@. + for arg + do + if test -n "$dst_arg"; then + # $@ is not empty: it contains at least $arg. + set fnord "$@" "$dst_arg" + shift # fnord + fi + shift # arg + dst_arg=$arg + # Protect names problematic for 'test' and other utilities. + case $dst_arg in + -* | [=\(\)!]) dst_arg=./$dst_arg;; + esac + done +fi + +if test $# -eq 0; then + if test -z "$dir_arg"; then + echo "$0: no input file specified." >&2 + exit 1 + fi + # It's OK to call 'install-sh -d' without argument. + # This can happen when creating conditional directories. + exit 0 +fi + +if test -z "$dir_arg"; then + do_exit='(exit $ret); exit $ret' + trap "ret=129; $do_exit" 1 + trap "ret=130; $do_exit" 2 + trap "ret=141; $do_exit" 13 + trap "ret=143; $do_exit" 15 + + # Set umask so as not to create temps with too-generous modes. + # However, 'strip' requires both read and write access to temps. + case $mode in + # Optimize common cases. + *644) cp_umask=133;; + *755) cp_umask=22;; + + *[0-7]) + if test -z "$stripcmd"; then + u_plus_rw= + else + u_plus_rw='% 200' + fi + cp_umask=`expr '(' 777 - $mode % 1000 ')' $u_plus_rw`;; + *) + if test -z "$stripcmd"; then + u_plus_rw= + else + u_plus_rw=,u+rw + fi + cp_umask=$mode$u_plus_rw;; + esac +fi + +for src +do + # Protect names problematic for 'test' and other utilities. + case $src in + -* | [=\(\)!]) src=./$src;; + esac + + if test -n "$dir_arg"; then + dst=$src + dstdir=$dst + test -d "$dstdir" + dstdir_status=$? + else + + # Waiting for this to be detected by the "$cpprog $src $dsttmp" command + # might cause directories to be created, which would be especially bad + # if $src (and thus $dsttmp) contains '*'. + if test ! -f "$src" && test ! -d "$src"; then + echo "$0: $src does not exist." >&2 + exit 1 + fi + + if test -z "$dst_arg"; then + echo "$0: no destination specified." >&2 + exit 1 + fi + dst=$dst_arg + + # If destination is a directory, append the input filename; won't work + # if double slashes aren't ignored. + if test -d "$dst"; then + if test -n "$no_target_directory"; then + echo "$0: $dst_arg: Is a directory" >&2 + exit 1 + fi + dstdir=$dst + dst=$dstdir/`basename "$src"` + dstdir_status=0 + else + # Prefer dirname, but fall back on a substitute if dirname fails. + dstdir=` + (dirname "$dst") 2>/dev/null || + expr X"$dst" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ + X"$dst" : 'X\(//\)[^/]' \| \ + X"$dst" : 'X\(//\)$' \| \ + X"$dst" : 'X\(/\)' \| . 2>/dev/null || + echo X"$dst" | + sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ + s//\1/ + q + } + /^X\(\/\/\)[^/].*/{ + s//\1/ + q + } + /^X\(\/\/\)$/{ + s//\1/ + q + } + /^X\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q' + ` + + test -d "$dstdir" + dstdir_status=$? + fi + fi + + obsolete_mkdir_used=false + + if test $dstdir_status != 0; then + case $posix_mkdir in + '') + # Create intermediate dirs using mode 755 as modified by the umask. + # This is like FreeBSD 'install' as of 1997-10-28. + umask=`umask` + case $stripcmd.$umask in + # Optimize common cases. + *[2367][2367]) mkdir_umask=$umask;; + .*0[02][02] | .[02][02] | .[02]) mkdir_umask=22;; + + *[0-7]) + mkdir_umask=`expr $umask + 22 \ + - $umask % 100 % 40 + $umask % 20 \ + - $umask % 10 % 4 + $umask % 2 + `;; + *) mkdir_umask=$umask,go-w;; + esac + + # With -d, create the new directory with the user-specified mode. + # Otherwise, rely on $mkdir_umask. + if test -n "$dir_arg"; then + mkdir_mode=-m$mode + else + mkdir_mode= + fi + + posix_mkdir=false + case $umask in + *[123567][0-7][0-7]) + # POSIX mkdir -p sets u+wx bits regardless of umask, which + # is incompatible with FreeBSD 'install' when (umask & 300) != 0. + ;; + *) + tmpdir=${TMPDIR-/tmp}/ins$RANDOM-$$ + trap 'ret=$?; rmdir "$tmpdir/d" "$tmpdir" 2>/dev/null; exit $ret' 0 + + if (umask $mkdir_umask && + exec $mkdirprog $mkdir_mode -p -- "$tmpdir/d") >/dev/null 2>&1 + then + if test -z "$dir_arg" || { + # Check for POSIX incompatibilities with -m. + # HP-UX 11.23 and IRIX 6.5 mkdir -m -p sets group- or + # other-writable bit of parent directory when it shouldn't. + # FreeBSD 6.1 mkdir -m -p sets mode of existing directory. + ls_ld_tmpdir=`ls -ld "$tmpdir"` + case $ls_ld_tmpdir in + d????-?r-*) different_mode=700;; + d????-?--*) different_mode=755;; + *) false;; + esac && + $mkdirprog -m$different_mode -p -- "$tmpdir" && { + ls_ld_tmpdir_1=`ls -ld "$tmpdir"` + test "$ls_ld_tmpdir" = "$ls_ld_tmpdir_1" + } + } + then posix_mkdir=: + fi + rmdir "$tmpdir/d" "$tmpdir" + else + # Remove any dirs left behind by ancient mkdir implementations. + rmdir ./$mkdir_mode ./-p ./-- 2>/dev/null + fi + trap '' 0;; + esac;; + esac + + if + $posix_mkdir && ( + umask $mkdir_umask && + $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir" + ) + then : + else + + # The umask is ridiculous, or mkdir does not conform to POSIX, + # or it failed possibly due to a race condition. Create the + # directory the slow way, step by step, checking for races as we go. + + case $dstdir in + /*) prefix='/';; + [-=\(\)!]*) prefix='./';; + *) prefix='';; + esac + + eval "$initialize_posix_glob" + + oIFS=$IFS + IFS=/ + $posix_glob set -f + set fnord $dstdir + shift + $posix_glob set +f + IFS=$oIFS + + prefixes= + + for d + do + test X"$d" = X && continue + + prefix=$prefix$d + if test -d "$prefix"; then + prefixes= + else + if $posix_mkdir; then + (umask=$mkdir_umask && + $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir") && break + # Don't fail if two instances are running concurrently. + test -d "$prefix" || exit 1 + else + case $prefix in + *\'*) qprefix=`echo "$prefix" | sed "s/'/'\\\\\\\\''/g"`;; + *) qprefix=$prefix;; + esac + prefixes="$prefixes '$qprefix'" + fi + fi + prefix=$prefix/ + done + + if test -n "$prefixes"; then + # Don't fail if two instances are running concurrently. + (umask $mkdir_umask && + eval "\$doit_exec \$mkdirprog $prefixes") || + test -d "$dstdir" || exit 1 + obsolete_mkdir_used=true + fi + fi + fi + + if test -n "$dir_arg"; then + { test -z "$chowncmd" || $doit $chowncmd "$dst"; } && + { test -z "$chgrpcmd" || $doit $chgrpcmd "$dst"; } && + { test "$obsolete_mkdir_used$chowncmd$chgrpcmd" = false || + test -z "$chmodcmd" || $doit $chmodcmd $mode "$dst"; } || exit 1 + else + + # Make a couple of temp file names in the proper directory. + dsttmp=$dstdir/_inst.$$_ + rmtmp=$dstdir/_rm.$$_ + + # Trap to clean up those temp files at exit. + trap 'ret=$?; rm -f "$dsttmp" "$rmtmp" && exit $ret' 0 + + # Copy the file name to the temp name. + (umask $cp_umask && $doit_exec $cpprog "$src" "$dsttmp") && + + # and set any options; do chmod last to preserve setuid bits. + # + # If any of these fail, we abort the whole thing. If we want to + # ignore errors from any of these, just make sure not to ignore + # errors from the above "$doit $cpprog $src $dsttmp" command. + # + { test -z "$chowncmd" || $doit $chowncmd "$dsttmp"; } && + { test -z "$chgrpcmd" || $doit $chgrpcmd "$dsttmp"; } && + { test -z "$stripcmd" || $doit $stripcmd "$dsttmp"; } && + { test -z "$chmodcmd" || $doit $chmodcmd $mode "$dsttmp"; } && + + # If -C, don't bother to copy if it wouldn't change the file. + if $copy_on_change && + old=`LC_ALL=C ls -dlL "$dst" 2>/dev/null` && + new=`LC_ALL=C ls -dlL "$dsttmp" 2>/dev/null` && + + eval "$initialize_posix_glob" && + $posix_glob set -f && + set X $old && old=:$2:$4:$5:$6 && + set X $new && new=:$2:$4:$5:$6 && + $posix_glob set +f && + + test "$old" = "$new" && + $cmpprog "$dst" "$dsttmp" >/dev/null 2>&1 + then + rm -f "$dsttmp" + else + # Rename the file to the real destination. + $doit $mvcmd -f "$dsttmp" "$dst" 2>/dev/null || + + # The rename failed, perhaps because mv can't rename something else + # to itself, or perhaps because mv is so ancient that it does not + # support -f. + { + # Now remove or move aside any old file at destination location. + # We try this two ways since rm can't unlink itself on some + # systems and the destination file might be busy for other + # reasons. In this case, the final cleanup might fail but the new + # file should still install successfully. + { + test ! -f "$dst" || + $doit $rmcmd -f "$dst" 2>/dev/null || + { $doit $mvcmd -f "$dst" "$rmtmp" 2>/dev/null && + { $doit $rmcmd -f "$rmtmp" 2>/dev/null; :; } + } || + { echo "$0: cannot unlink or rename $dst" >&2 + (exit 1); exit 1 + } + } && + + # Now rename the file to the real destination. + $doit $mvcmd "$dsttmp" "$dst" + } + fi || exit 1 + + trap '' 0 + fi +done + +# Local variables: +# eval: (add-hook 'write-file-hooks 'time-stamp) +# time-stamp-start: "scriptversion=" +# time-stamp-format: "%:y-%02m-%02d.%02H" +# time-stamp-time-zone: "UTC" +# time-stamp-end: "; # UTC" +# End: diff --git a/third-party/odb/libodb-2.4.0/config/ltmain.sh b/third-party/odb/libodb-2.4.0/config/ltmain.sh new file mode 100755 index 0000000..499e473 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/config/ltmain.sh @@ -0,0 +1,9661 @@ + +# libtool (GNU libtool) 2.4.2 +# Written by Gordon Matzigkeit , 1996 + +# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006, +# 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc. +# This is free software; see the source for copying conditions. There is NO +# warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + +# GNU Libtool is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. +# +# As a special exception to the GNU General Public License, +# if you distribute this file as part of a program or library that +# is built using GNU Libtool, you may include this file under the +# same distribution terms that you use for the rest of that program. +# +# GNU Libtool is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with GNU Libtool; see the file COPYING. If not, a copy +# can be downloaded from http://www.gnu.org/licenses/gpl.html, +# or obtained by writing to the Free Software Foundation, Inc., +# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + +# Usage: $progname [OPTION]... [MODE-ARG]... +# +# Provide generalized library-building support services. +# +# --config show all configuration variables +# --debug enable verbose shell tracing +# -n, --dry-run display commands without modifying any files +# --features display basic configuration information and exit +# --mode=MODE use operation mode MODE +# --preserve-dup-deps don't remove duplicate dependency libraries +# --quiet, --silent don't print informational messages +# --no-quiet, --no-silent +# print informational messages (default) +# --no-warn don't display warning messages +# --tag=TAG use configuration variables from tag TAG +# -v, --verbose print more informational messages than default +# --no-verbose don't print the extra informational messages +# --version print version information +# -h, --help, --help-all print short, long, or detailed help message +# +# MODE must be one of the following: +# +# clean remove files from the build directory +# compile compile a source file into a libtool object +# execute automatically set library path, then run a program +# finish complete the installation of libtool libraries +# install install libraries or executables +# link create a library or an executable +# uninstall remove libraries from an installed directory +# +# MODE-ARGS vary depending on the MODE. When passed as first option, +# `--mode=MODE' may be abbreviated as `MODE' or a unique abbreviation of that. +# Try `$progname --help --mode=MODE' for a more detailed description of MODE. +# +# When reporting a bug, please describe a test case to reproduce it and +# include the following information: +# +# host-triplet: $host +# shell: $SHELL +# compiler: $LTCC +# compiler flags: $LTCFLAGS +# linker: $LD (gnu? $with_gnu_ld) +# $progname: (GNU libtool) 2.4.2 Debian-2.4.2-1.2 +# automake: $automake_version +# autoconf: $autoconf_version +# +# Report bugs to . +# GNU libtool home page: . +# General help using GNU software: . + +PROGRAM=libtool +PACKAGE=libtool +VERSION="2.4.2 Debian-2.4.2-1.2" +TIMESTAMP="" +package_revision=1.3337 + +# Be Bourne compatible +if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then + emulate sh + NULLCMD=: + # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which + # is contrary to our usage. Disable this feature. + alias -g '${1+"$@"}'='"$@"' + setopt NO_GLOB_SUBST +else + case `(set -o) 2>/dev/null` in *posix*) set -o posix;; esac +fi +BIN_SH=xpg4; export BIN_SH # for Tru64 +DUALCASE=1; export DUALCASE # for MKS sh + +# A function that is used when there is no print builtin or printf. +func_fallback_echo () +{ + eval 'cat <<_LTECHO_EOF +$1 +_LTECHO_EOF' +} + +# NLS nuisances: We save the old values to restore during execute mode. +lt_user_locale= +lt_safe_locale= +for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES +do + eval "if test \"\${$lt_var+set}\" = set; then + save_$lt_var=\$$lt_var + $lt_var=C + export $lt_var + lt_user_locale=\"$lt_var=\\\$save_\$lt_var; \$lt_user_locale\" + lt_safe_locale=\"$lt_var=C; \$lt_safe_locale\" + fi" +done +LC_ALL=C +LANGUAGE=C +export LANGUAGE LC_ALL + +$lt_unset CDPATH + + +# Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh +# is ksh but when the shell is invoked as "sh" and the current value of +# the _XPG environment variable is not equal to 1 (one), the special +# positional parameter $0, within a function call, is the name of the +# function. +progpath="$0" + + + +: ${CP="cp -f"} +test "${ECHO+set}" = set || ECHO=${as_echo-'printf %s\n'} +: ${MAKE="make"} +: ${MKDIR="mkdir"} +: ${MV="mv -f"} +: ${RM="rm -f"} +: ${SHELL="${CONFIG_SHELL-/bin/sh}"} +: ${Xsed="$SED -e 1s/^X//"} + +# Global variables: +EXIT_SUCCESS=0 +EXIT_FAILURE=1 +EXIT_MISMATCH=63 # $? = 63 is used to indicate version mismatch to missing. +EXIT_SKIP=77 # $? = 77 is used to indicate a skipped test to automake. + +exit_status=$EXIT_SUCCESS + +# Make sure IFS has a sensible default +lt_nl=' +' +IFS=" $lt_nl" + +dirname="s,/[^/]*$,," +basename="s,^.*/,," + +# func_dirname file append nondir_replacement +# Compute the dirname of FILE. If nonempty, add APPEND to the result, +# otherwise set result to NONDIR_REPLACEMENT. +func_dirname () +{ + func_dirname_result=`$ECHO "${1}" | $SED "$dirname"` + if test "X$func_dirname_result" = "X${1}"; then + func_dirname_result="${3}" + else + func_dirname_result="$func_dirname_result${2}" + fi +} # func_dirname may be replaced by extended shell implementation + + +# func_basename file +func_basename () +{ + func_basename_result=`$ECHO "${1}" | $SED "$basename"` +} # func_basename may be replaced by extended shell implementation + + +# func_dirname_and_basename file append nondir_replacement +# perform func_basename and func_dirname in a single function +# call: +# dirname: Compute the dirname of FILE. If nonempty, +# add APPEND to the result, otherwise set result +# to NONDIR_REPLACEMENT. +# value returned in "$func_dirname_result" +# basename: Compute filename of FILE. +# value retuned in "$func_basename_result" +# Implementation must be kept synchronized with func_dirname +# and func_basename. For efficiency, we do not delegate to +# those functions but instead duplicate the functionality here. +func_dirname_and_basename () +{ + # Extract subdirectory from the argument. + func_dirname_result=`$ECHO "${1}" | $SED -e "$dirname"` + if test "X$func_dirname_result" = "X${1}"; then + func_dirname_result="${3}" + else + func_dirname_result="$func_dirname_result${2}" + fi + func_basename_result=`$ECHO "${1}" | $SED -e "$basename"` +} # func_dirname_and_basename may be replaced by extended shell implementation + + +# func_stripname prefix suffix name +# strip PREFIX and SUFFIX off of NAME. +# PREFIX and SUFFIX must not contain globbing or regex special +# characters, hashes, percent signs, but SUFFIX may contain a leading +# dot (in which case that matches only a dot). +# func_strip_suffix prefix name +func_stripname () +{ + case ${2} in + .*) func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%\\\\${2}\$%%"`;; + *) func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%${2}\$%%"`;; + esac +} # func_stripname may be replaced by extended shell implementation + + +# These SED scripts presuppose an absolute path with a trailing slash. +pathcar='s,^/\([^/]*\).*$,\1,' +pathcdr='s,^/[^/]*,,' +removedotparts=':dotsl + s@/\./@/@g + t dotsl + s,/\.$,/,' +collapseslashes='s@/\{1,\}@/@g' +finalslash='s,/*$,/,' + +# func_normal_abspath PATH +# Remove doubled-up and trailing slashes, "." path components, +# and cancel out any ".." path components in PATH after making +# it an absolute path. +# value returned in "$func_normal_abspath_result" +func_normal_abspath () +{ + # Start from root dir and reassemble the path. + func_normal_abspath_result= + func_normal_abspath_tpath=$1 + func_normal_abspath_altnamespace= + case $func_normal_abspath_tpath in + "") + # Empty path, that just means $cwd. + func_stripname '' '/' "`pwd`" + func_normal_abspath_result=$func_stripname_result + return + ;; + # The next three entries are used to spot a run of precisely + # two leading slashes without using negated character classes; + # we take advantage of case's first-match behaviour. + ///*) + # Unusual form of absolute path, do nothing. + ;; + //*) + # Not necessarily an ordinary path; POSIX reserves leading '//' + # and for example Cygwin uses it to access remote file shares + # over CIFS/SMB, so we conserve a leading double slash if found. + func_normal_abspath_altnamespace=/ + ;; + /*) + # Absolute path, do nothing. + ;; + *) + # Relative path, prepend $cwd. + func_normal_abspath_tpath=`pwd`/$func_normal_abspath_tpath + ;; + esac + # Cancel out all the simple stuff to save iterations. We also want + # the path to end with a slash for ease of parsing, so make sure + # there is one (and only one) here. + func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \ + -e "$removedotparts" -e "$collapseslashes" -e "$finalslash"` + while :; do + # Processed it all yet? + if test "$func_normal_abspath_tpath" = / ; then + # If we ascended to the root using ".." the result may be empty now. + if test -z "$func_normal_abspath_result" ; then + func_normal_abspath_result=/ + fi + break + fi + func_normal_abspath_tcomponent=`$ECHO "$func_normal_abspath_tpath" | $SED \ + -e "$pathcar"` + func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \ + -e "$pathcdr"` + # Figure out what to do with it + case $func_normal_abspath_tcomponent in + "") + # Trailing empty path component, ignore it. + ;; + ..) + # Parent dir; strip last assembled component from result. + func_dirname "$func_normal_abspath_result" + func_normal_abspath_result=$func_dirname_result + ;; + *) + # Actual path component, append it. + func_normal_abspath_result=$func_normal_abspath_result/$func_normal_abspath_tcomponent + ;; + esac + done + # Restore leading double-slash if one was found on entry. + func_normal_abspath_result=$func_normal_abspath_altnamespace$func_normal_abspath_result +} + +# func_relative_path SRCDIR DSTDIR +# generates a relative path from SRCDIR to DSTDIR, with a trailing +# slash if non-empty, suitable for immediately appending a filename +# without needing to append a separator. +# value returned in "$func_relative_path_result" +func_relative_path () +{ + func_relative_path_result= + func_normal_abspath "$1" + func_relative_path_tlibdir=$func_normal_abspath_result + func_normal_abspath "$2" + func_relative_path_tbindir=$func_normal_abspath_result + + # Ascend the tree starting from libdir + while :; do + # check if we have found a prefix of bindir + case $func_relative_path_tbindir in + $func_relative_path_tlibdir) + # found an exact match + func_relative_path_tcancelled= + break + ;; + $func_relative_path_tlibdir*) + # found a matching prefix + func_stripname "$func_relative_path_tlibdir" '' "$func_relative_path_tbindir" + func_relative_path_tcancelled=$func_stripname_result + if test -z "$func_relative_path_result"; then + func_relative_path_result=. + fi + break + ;; + *) + func_dirname $func_relative_path_tlibdir + func_relative_path_tlibdir=${func_dirname_result} + if test "x$func_relative_path_tlibdir" = x ; then + # Have to descend all the way to the root! + func_relative_path_result=../$func_relative_path_result + func_relative_path_tcancelled=$func_relative_path_tbindir + break + fi + func_relative_path_result=../$func_relative_path_result + ;; + esac + done + + # Now calculate path; take care to avoid doubling-up slashes. + func_stripname '' '/' "$func_relative_path_result" + func_relative_path_result=$func_stripname_result + func_stripname '/' '/' "$func_relative_path_tcancelled" + if test "x$func_stripname_result" != x ; then + func_relative_path_result=${func_relative_path_result}/${func_stripname_result} + fi + + # Normalisation. If bindir is libdir, return empty string, + # else relative path ending with a slash; either way, target + # file name can be directly appended. + if test ! -z "$func_relative_path_result"; then + func_stripname './' '' "$func_relative_path_result/" + func_relative_path_result=$func_stripname_result + fi +} + +# The name of this program: +func_dirname_and_basename "$progpath" +progname=$func_basename_result + +# Make sure we have an absolute path for reexecution: +case $progpath in + [\\/]*|[A-Za-z]:\\*) ;; + *[\\/]*) + progdir=$func_dirname_result + progdir=`cd "$progdir" && pwd` + progpath="$progdir/$progname" + ;; + *) + save_IFS="$IFS" + IFS=${PATH_SEPARATOR-:} + for progdir in $PATH; do + IFS="$save_IFS" + test -x "$progdir/$progname" && break + done + IFS="$save_IFS" + test -n "$progdir" || progdir=`pwd` + progpath="$progdir/$progname" + ;; +esac + +# Sed substitution that helps us do robust quoting. It backslashifies +# metacharacters that are still active within double-quoted strings. +Xsed="${SED}"' -e 1s/^X//' +sed_quote_subst='s/\([`"$\\]\)/\\\1/g' + +# Same as above, but do not quote variable references. +double_quote_subst='s/\(["`\\]\)/\\\1/g' + +# Sed substitution that turns a string into a regex matching for the +# string literally. +sed_make_literal_regex='s,[].[^$\\*\/],\\&,g' + +# Sed substitution that converts a w32 file name or path +# which contains forward slashes, into one that contains +# (escaped) backslashes. A very naive implementation. +lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g' + +# Re-`\' parameter expansions in output of double_quote_subst that were +# `\'-ed in input to the same. If an odd number of `\' preceded a '$' +# in input to double_quote_subst, that '$' was protected from expansion. +# Since each input `\' is now two `\'s, look for any number of runs of +# four `\'s followed by two `\'s and then a '$'. `\' that '$'. +bs='\\' +bs2='\\\\' +bs4='\\\\\\\\' +dollar='\$' +sed_double_backslash="\ + s/$bs4/&\\ +/g + s/^$bs2$dollar/$bs&/ + s/\\([^$bs]\\)$bs2$dollar/\\1$bs2$bs$dollar/g + s/\n//g" + +# Standard options: +opt_dry_run=false +opt_help=false +opt_quiet=false +opt_verbose=false +opt_warning=: + +# func_echo arg... +# Echo program name prefixed message, along with the current mode +# name if it has been set yet. +func_echo () +{ + $ECHO "$progname: ${opt_mode+$opt_mode: }$*" +} + +# func_verbose arg... +# Echo program name prefixed message in verbose mode only. +func_verbose () +{ + $opt_verbose && func_echo ${1+"$@"} + + # A bug in bash halts the script if the last line of a function + # fails when set -e is in force, so we need another command to + # work around that: + : +} + +# func_echo_all arg... +# Invoke $ECHO with all args, space-separated. +func_echo_all () +{ + $ECHO "$*" +} + +# func_error arg... +# Echo program name prefixed message to standard error. +func_error () +{ + $ECHO "$progname: ${opt_mode+$opt_mode: }"${1+"$@"} 1>&2 +} + +# func_warning arg... +# Echo program name prefixed warning message to standard error. +func_warning () +{ + $opt_warning && $ECHO "$progname: ${opt_mode+$opt_mode: }warning: "${1+"$@"} 1>&2 + + # bash bug again: + : +} + +# func_fatal_error arg... +# Echo program name prefixed message to standard error, and exit. +func_fatal_error () +{ + func_error ${1+"$@"} + exit $EXIT_FAILURE +} + +# func_fatal_help arg... +# Echo program name prefixed message to standard error, followed by +# a help hint, and exit. +func_fatal_help () +{ + func_error ${1+"$@"} + func_fatal_error "$help" +} +help="Try \`$progname --help' for more information." ## default + + +# func_grep expression filename +# Check whether EXPRESSION matches any line of FILENAME, without output. +func_grep () +{ + $GREP "$1" "$2" >/dev/null 2>&1 +} + + +# func_mkdir_p directory-path +# Make sure the entire path to DIRECTORY-PATH is available. +func_mkdir_p () +{ + my_directory_path="$1" + my_dir_list= + + if test -n "$my_directory_path" && test "$opt_dry_run" != ":"; then + + # Protect directory names starting with `-' + case $my_directory_path in + -*) my_directory_path="./$my_directory_path" ;; + esac + + # While some portion of DIR does not yet exist... + while test ! -d "$my_directory_path"; do + # ...make a list in topmost first order. Use a colon delimited + # list incase some portion of path contains whitespace. + my_dir_list="$my_directory_path:$my_dir_list" + + # If the last portion added has no slash in it, the list is done + case $my_directory_path in */*) ;; *) break ;; esac + + # ...otherwise throw away the child directory and loop + my_directory_path=`$ECHO "$my_directory_path" | $SED -e "$dirname"` + done + my_dir_list=`$ECHO "$my_dir_list" | $SED 's,:*$,,'` + + save_mkdir_p_IFS="$IFS"; IFS=':' + for my_dir in $my_dir_list; do + IFS="$save_mkdir_p_IFS" + # mkdir can fail with a `File exist' error if two processes + # try to create one of the directories concurrently. Don't + # stop in that case! + $MKDIR "$my_dir" 2>/dev/null || : + done + IFS="$save_mkdir_p_IFS" + + # Bail out if we (or some other process) failed to create a directory. + test -d "$my_directory_path" || \ + func_fatal_error "Failed to create \`$1'" + fi +} + + +# func_mktempdir [string] +# Make a temporary directory that won't clash with other running +# libtool processes, and avoids race conditions if possible. If +# given, STRING is the basename for that directory. +func_mktempdir () +{ + my_template="${TMPDIR-/tmp}/${1-$progname}" + + if test "$opt_dry_run" = ":"; then + # Return a directory name, but don't create it in dry-run mode + my_tmpdir="${my_template}-$$" + else + + # If mktemp works, use that first and foremost + my_tmpdir=`mktemp -d "${my_template}-XXXXXXXX" 2>/dev/null` + + if test ! -d "$my_tmpdir"; then + # Failing that, at least try and use $RANDOM to avoid a race + my_tmpdir="${my_template}-${RANDOM-0}$$" + + save_mktempdir_umask=`umask` + umask 0077 + $MKDIR "$my_tmpdir" + umask $save_mktempdir_umask + fi + + # If we're not in dry-run mode, bomb out on failure + test -d "$my_tmpdir" || \ + func_fatal_error "cannot create temporary directory \`$my_tmpdir'" + fi + + $ECHO "$my_tmpdir" +} + + +# func_quote_for_eval arg +# Aesthetically quote ARG to be evaled later. +# This function returns two values: FUNC_QUOTE_FOR_EVAL_RESULT +# is double-quoted, suitable for a subsequent eval, whereas +# FUNC_QUOTE_FOR_EVAL_UNQUOTED_RESULT has merely all characters +# which are still active within double quotes backslashified. +func_quote_for_eval () +{ + case $1 in + *[\\\`\"\$]*) + func_quote_for_eval_unquoted_result=`$ECHO "$1" | $SED "$sed_quote_subst"` ;; + *) + func_quote_for_eval_unquoted_result="$1" ;; + esac + + case $func_quote_for_eval_unquoted_result in + # Double-quote args containing shell metacharacters to delay + # word splitting, command substitution and and variable + # expansion for a subsequent eval. + # Many Bourne shells cannot handle close brackets correctly + # in scan sets, so we specify it separately. + *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"") + func_quote_for_eval_result="\"$func_quote_for_eval_unquoted_result\"" + ;; + *) + func_quote_for_eval_result="$func_quote_for_eval_unquoted_result" + esac +} + + +# func_quote_for_expand arg +# Aesthetically quote ARG to be evaled later; same as above, +# but do not quote variable references. +func_quote_for_expand () +{ + case $1 in + *[\\\`\"]*) + my_arg=`$ECHO "$1" | $SED \ + -e "$double_quote_subst" -e "$sed_double_backslash"` ;; + *) + my_arg="$1" ;; + esac + + case $my_arg in + # Double-quote args containing shell metacharacters to delay + # word splitting and command substitution for a subsequent eval. + # Many Bourne shells cannot handle close brackets correctly + # in scan sets, so we specify it separately. + *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"") + my_arg="\"$my_arg\"" + ;; + esac + + func_quote_for_expand_result="$my_arg" +} + + +# func_show_eval cmd [fail_exp] +# Unless opt_silent is true, then output CMD. Then, if opt_dryrun is +# not true, evaluate CMD. If the evaluation of CMD fails, and FAIL_EXP +# is given, then evaluate it. +func_show_eval () +{ + my_cmd="$1" + my_fail_exp="${2-:}" + + ${opt_silent-false} || { + func_quote_for_expand "$my_cmd" + eval "func_echo $func_quote_for_expand_result" + } + + if ${opt_dry_run-false}; then :; else + eval "$my_cmd" + my_status=$? + if test "$my_status" -eq 0; then :; else + eval "(exit $my_status); $my_fail_exp" + fi + fi +} + + +# func_show_eval_locale cmd [fail_exp] +# Unless opt_silent is true, then output CMD. Then, if opt_dryrun is +# not true, evaluate CMD. If the evaluation of CMD fails, and FAIL_EXP +# is given, then evaluate it. Use the saved locale for evaluation. +func_show_eval_locale () +{ + my_cmd="$1" + my_fail_exp="${2-:}" + + ${opt_silent-false} || { + func_quote_for_expand "$my_cmd" + eval "func_echo $func_quote_for_expand_result" + } + + if ${opt_dry_run-false}; then :; else + eval "$lt_user_locale + $my_cmd" + my_status=$? + eval "$lt_safe_locale" + if test "$my_status" -eq 0; then :; else + eval "(exit $my_status); $my_fail_exp" + fi + fi +} + +# func_tr_sh +# Turn $1 into a string suitable for a shell variable name. +# Result is stored in $func_tr_sh_result. All characters +# not in the set a-zA-Z0-9_ are replaced with '_'. Further, +# if $1 begins with a digit, a '_' is prepended as well. +func_tr_sh () +{ + case $1 in + [0-9]* | *[!a-zA-Z0-9_]*) + func_tr_sh_result=`$ECHO "$1" | $SED 's/^\([0-9]\)/_\1/; s/[^a-zA-Z0-9_]/_/g'` + ;; + * ) + func_tr_sh_result=$1 + ;; + esac +} + + +# func_version +# Echo version message to standard output and exit. +func_version () +{ + $opt_debug + + $SED -n '/(C)/!b go + :more + /\./!{ + N + s/\n# / / + b more + } + :go + /^# '$PROGRAM' (GNU /,/# warranty; / { + s/^# // + s/^# *$// + s/\((C)\)[ 0-9,-]*\( [1-9][0-9]*\)/\1\2/ + p + }' < "$progpath" + exit $? +} + +# func_usage +# Echo short help message to standard output and exit. +func_usage () +{ + $opt_debug + + $SED -n '/^# Usage:/,/^# *.*--help/ { + s/^# // + s/^# *$// + s/\$progname/'$progname'/ + p + }' < "$progpath" + echo + $ECHO "run \`$progname --help | more' for full usage" + exit $? +} + +# func_help [NOEXIT] +# Echo long help message to standard output and exit, +# unless 'noexit' is passed as argument. +func_help () +{ + $opt_debug + + $SED -n '/^# Usage:/,/# Report bugs to/ { + :print + s/^# // + s/^# *$// + s*\$progname*'$progname'* + s*\$host*'"$host"'* + s*\$SHELL*'"$SHELL"'* + s*\$LTCC*'"$LTCC"'* + s*\$LTCFLAGS*'"$LTCFLAGS"'* + s*\$LD*'"$LD"'* + s/\$with_gnu_ld/'"$with_gnu_ld"'/ + s/\$automake_version/'"`(${AUTOMAKE-automake} --version) 2>/dev/null |$SED 1q`"'/ + s/\$autoconf_version/'"`(${AUTOCONF-autoconf} --version) 2>/dev/null |$SED 1q`"'/ + p + d + } + /^# .* home page:/b print + /^# General help using/b print + ' < "$progpath" + ret=$? + if test -z "$1"; then + exit $ret + fi +} + +# func_missing_arg argname +# Echo program name prefixed message to standard error and set global +# exit_cmd. +func_missing_arg () +{ + $opt_debug + + func_error "missing argument for $1." + exit_cmd=exit +} + + +# func_split_short_opt shortopt +# Set func_split_short_opt_name and func_split_short_opt_arg shell +# variables after splitting SHORTOPT after the 2nd character. +func_split_short_opt () +{ + my_sed_short_opt='1s/^\(..\).*$/\1/;q' + my_sed_short_rest='1s/^..\(.*\)$/\1/;q' + + func_split_short_opt_name=`$ECHO "$1" | $SED "$my_sed_short_opt"` + func_split_short_opt_arg=`$ECHO "$1" | $SED "$my_sed_short_rest"` +} # func_split_short_opt may be replaced by extended shell implementation + + +# func_split_long_opt longopt +# Set func_split_long_opt_name and func_split_long_opt_arg shell +# variables after splitting LONGOPT at the `=' sign. +func_split_long_opt () +{ + my_sed_long_opt='1s/^\(--[^=]*\)=.*/\1/;q' + my_sed_long_arg='1s/^--[^=]*=//' + + func_split_long_opt_name=`$ECHO "$1" | $SED "$my_sed_long_opt"` + func_split_long_opt_arg=`$ECHO "$1" | $SED "$my_sed_long_arg"` +} # func_split_long_opt may be replaced by extended shell implementation + +exit_cmd=: + + + + + +magic="%%%MAGIC variable%%%" +magic_exe="%%%MAGIC EXE variable%%%" + +# Global variables. +nonopt= +preserve_args= +lo2o="s/\\.lo\$/.${objext}/" +o2lo="s/\\.${objext}\$/.lo/" +extracted_archives= +extracted_serial=0 + +# If this variable is set in any of the actions, the command in it +# will be execed at the end. This prevents here-documents from being +# left over by shells. +exec_cmd= + +# func_append var value +# Append VALUE to the end of shell variable VAR. +func_append () +{ + eval "${1}=\$${1}\${2}" +} # func_append may be replaced by extended shell implementation + +# func_append_quoted var value +# Quote VALUE and append to the end of shell variable VAR, separated +# by a space. +func_append_quoted () +{ + func_quote_for_eval "${2}" + eval "${1}=\$${1}\\ \$func_quote_for_eval_result" +} # func_append_quoted may be replaced by extended shell implementation + + +# func_arith arithmetic-term... +func_arith () +{ + func_arith_result=`expr "${@}"` +} # func_arith may be replaced by extended shell implementation + + +# func_len string +# STRING may not start with a hyphen. +func_len () +{ + func_len_result=`expr "${1}" : ".*" 2>/dev/null || echo $max_cmd_len` +} # func_len may be replaced by extended shell implementation + + +# func_lo2o object +func_lo2o () +{ + func_lo2o_result=`$ECHO "${1}" | $SED "$lo2o"` +} # func_lo2o may be replaced by extended shell implementation + + +# func_xform libobj-or-source +func_xform () +{ + func_xform_result=`$ECHO "${1}" | $SED 's/\.[^.]*$/.lo/'` +} # func_xform may be replaced by extended shell implementation + + +# func_fatal_configuration arg... +# Echo program name prefixed message to standard error, followed by +# a configuration failure hint, and exit. +func_fatal_configuration () +{ + func_error ${1+"$@"} + func_error "See the $PACKAGE documentation for more information." + func_fatal_error "Fatal configuration error." +} + + +# func_config +# Display the configuration for all the tags in this script. +func_config () +{ + re_begincf='^# ### BEGIN LIBTOOL' + re_endcf='^# ### END LIBTOOL' + + # Default configuration. + $SED "1,/$re_begincf CONFIG/d;/$re_endcf CONFIG/,\$d" < "$progpath" + + # Now print the configurations for the tags. + for tagname in $taglist; do + $SED -n "/$re_begincf TAG CONFIG: $tagname\$/,/$re_endcf TAG CONFIG: $tagname\$/p" < "$progpath" + done + + exit $? +} + +# func_features +# Display the features supported by this script. +func_features () +{ + echo "host: $host" + if test "$build_libtool_libs" = yes; then + echo "enable shared libraries" + else + echo "disable shared libraries" + fi + if test "$build_old_libs" = yes; then + echo "enable static libraries" + else + echo "disable static libraries" + fi + + exit $? +} + +# func_enable_tag tagname +# Verify that TAGNAME is valid, and either flag an error and exit, or +# enable the TAGNAME tag. We also add TAGNAME to the global $taglist +# variable here. +func_enable_tag () +{ + # Global variable: + tagname="$1" + + re_begincf="^# ### BEGIN LIBTOOL TAG CONFIG: $tagname\$" + re_endcf="^# ### END LIBTOOL TAG CONFIG: $tagname\$" + sed_extractcf="/$re_begincf/,/$re_endcf/p" + + # Validate tagname. + case $tagname in + *[!-_A-Za-z0-9,/]*) + func_fatal_error "invalid tag name: $tagname" + ;; + esac + + # Don't test for the "default" C tag, as we know it's + # there but not specially marked. + case $tagname in + CC) ;; + *) + if $GREP "$re_begincf" "$progpath" >/dev/null 2>&1; then + taglist="$taglist $tagname" + + # Evaluate the configuration. Be careful to quote the path + # and the sed script, to avoid splitting on whitespace, but + # also don't use non-portable quotes within backquotes within + # quotes we have to do it in 2 steps: + extractedcf=`$SED -n -e "$sed_extractcf" < "$progpath"` + eval "$extractedcf" + else + func_error "ignoring unknown tag $tagname" + fi + ;; + esac +} + +# func_check_version_match +# Ensure that we are using m4 macros, and libtool script from the same +# release of libtool. +func_check_version_match () +{ + if test "$package_revision" != "$macro_revision"; then + if test "$VERSION" != "$macro_version"; then + if test -z "$macro_version"; then + cat >&2 <<_LT_EOF +$progname: Version mismatch error. This is $PACKAGE $VERSION, but the +$progname: definition of this LT_INIT comes from an older release. +$progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION +$progname: and run autoconf again. +_LT_EOF + else + cat >&2 <<_LT_EOF +$progname: Version mismatch error. This is $PACKAGE $VERSION, but the +$progname: definition of this LT_INIT comes from $PACKAGE $macro_version. +$progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION +$progname: and run autoconf again. +_LT_EOF + fi + else + cat >&2 <<_LT_EOF +$progname: Version mismatch error. This is $PACKAGE $VERSION, revision $package_revision, +$progname: but the definition of this LT_INIT comes from revision $macro_revision. +$progname: You should recreate aclocal.m4 with macros from revision $package_revision +$progname: of $PACKAGE $VERSION and run autoconf again. +_LT_EOF + fi + + exit $EXIT_MISMATCH + fi +} + + +# Shorthand for --mode=foo, only valid as the first argument +case $1 in +clean|clea|cle|cl) + shift; set dummy --mode clean ${1+"$@"}; shift + ;; +compile|compil|compi|comp|com|co|c) + shift; set dummy --mode compile ${1+"$@"}; shift + ;; +execute|execut|execu|exec|exe|ex|e) + shift; set dummy --mode execute ${1+"$@"}; shift + ;; +finish|finis|fini|fin|fi|f) + shift; set dummy --mode finish ${1+"$@"}; shift + ;; +install|instal|insta|inst|ins|in|i) + shift; set dummy --mode install ${1+"$@"}; shift + ;; +link|lin|li|l) + shift; set dummy --mode link ${1+"$@"}; shift + ;; +uninstall|uninstal|uninsta|uninst|unins|unin|uni|un|u) + shift; set dummy --mode uninstall ${1+"$@"}; shift + ;; +esac + + + +# Option defaults: +opt_debug=: +opt_dry_run=false +opt_config=false +opt_preserve_dup_deps=false +opt_features=false +opt_finish=false +opt_help=false +opt_help_all=false +opt_silent=: +opt_warning=: +opt_verbose=: +opt_silent=false +opt_verbose=false + + +# Parse options once, thoroughly. This comes as soon as possible in the +# script to make things like `--version' happen as quickly as we can. +{ + # this just eases exit handling + while test $# -gt 0; do + opt="$1" + shift + case $opt in + --debug|-x) opt_debug='set -x' + func_echo "enabling shell trace mode" + $opt_debug + ;; + --dry-run|--dryrun|-n) + opt_dry_run=: + ;; + --config) + opt_config=: +func_config + ;; + --dlopen|-dlopen) + optarg="$1" + opt_dlopen="${opt_dlopen+$opt_dlopen +}$optarg" + shift + ;; + --preserve-dup-deps) + opt_preserve_dup_deps=: + ;; + --features) + opt_features=: +func_features + ;; + --finish) + opt_finish=: +set dummy --mode finish ${1+"$@"}; shift + ;; + --help) + opt_help=: + ;; + --help-all) + opt_help_all=: +opt_help=': help-all' + ;; + --mode) + test $# = 0 && func_missing_arg $opt && break + optarg="$1" + opt_mode="$optarg" +case $optarg in + # Valid mode arguments: + clean|compile|execute|finish|install|link|relink|uninstall) ;; + + # Catch anything else as an error + *) func_error "invalid argument for $opt" + exit_cmd=exit + break + ;; +esac + shift + ;; + --no-silent|--no-quiet) + opt_silent=false +func_append preserve_args " $opt" + ;; + --no-warning|--no-warn) + opt_warning=false +func_append preserve_args " $opt" + ;; + --no-verbose) + opt_verbose=false +func_append preserve_args " $opt" + ;; + --silent|--quiet) + opt_silent=: +func_append preserve_args " $opt" + opt_verbose=false + ;; + --verbose|-v) + opt_verbose=: +func_append preserve_args " $opt" +opt_silent=false + ;; + --tag) + test $# = 0 && func_missing_arg $opt && break + optarg="$1" + opt_tag="$optarg" +func_append preserve_args " $opt $optarg" +func_enable_tag "$optarg" + shift + ;; + + -\?|-h) func_usage ;; + --help) func_help ;; + --version) func_version ;; + + # Separate optargs to long options: + --*=*) + func_split_long_opt "$opt" + set dummy "$func_split_long_opt_name" "$func_split_long_opt_arg" ${1+"$@"} + shift + ;; + + # Separate non-argument short options: + -\?*|-h*|-n*|-v*) + func_split_short_opt "$opt" + set dummy "$func_split_short_opt_name" "-$func_split_short_opt_arg" ${1+"$@"} + shift + ;; + + --) break ;; + -*) func_fatal_help "unrecognized option \`$opt'" ;; + *) set dummy "$opt" ${1+"$@"}; shift; break ;; + esac + done + + # Validate options: + + # save first non-option argument + if test "$#" -gt 0; then + nonopt="$opt" + shift + fi + + # preserve --debug + test "$opt_debug" = : || func_append preserve_args " --debug" + + case $host in + *cygwin* | *mingw* | *pw32* | *cegcc*) + # don't eliminate duplications in $postdeps and $predeps + opt_duplicate_compiler_generated_deps=: + ;; + *) + opt_duplicate_compiler_generated_deps=$opt_preserve_dup_deps + ;; + esac + + $opt_help || { + # Sanity checks first: + func_check_version_match + + if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then + func_fatal_configuration "not configured to build any kind of library" + fi + + # Darwin sucks + eval std_shrext=\"$shrext_cmds\" + + # Only execute mode is allowed to have -dlopen flags. + if test -n "$opt_dlopen" && test "$opt_mode" != execute; then + func_error "unrecognized option \`-dlopen'" + $ECHO "$help" 1>&2 + exit $EXIT_FAILURE + fi + + # Change the help message to a mode-specific one. + generic_help="$help" + help="Try \`$progname --help --mode=$opt_mode' for more information." + } + + + # Bail if the options were screwed + $exit_cmd $EXIT_FAILURE +} + + + + +## ----------- ## +## Main. ## +## ----------- ## + +# func_lalib_p file +# True iff FILE is a libtool `.la' library or `.lo' object file. +# This function is only a basic sanity check; it will hardly flush out +# determined imposters. +func_lalib_p () +{ + test -f "$1" && + $SED -e 4q "$1" 2>/dev/null \ + | $GREP "^# Generated by .*$PACKAGE" > /dev/null 2>&1 +} + +# func_lalib_unsafe_p file +# True iff FILE is a libtool `.la' library or `.lo' object file. +# This function implements the same check as func_lalib_p without +# resorting to external programs. To this end, it redirects stdin and +# closes it afterwards, without saving the original file descriptor. +# As a safety measure, use it only where a negative result would be +# fatal anyway. Works if `file' does not exist. +func_lalib_unsafe_p () +{ + lalib_p=no + if test -f "$1" && test -r "$1" && exec 5<&0 <"$1"; then + for lalib_p_l in 1 2 3 4 + do + read lalib_p_line + case "$lalib_p_line" in + \#\ Generated\ by\ *$PACKAGE* ) lalib_p=yes; break;; + esac + done + exec 0<&5 5<&- + fi + test "$lalib_p" = yes +} + +# func_ltwrapper_script_p file +# True iff FILE is a libtool wrapper script +# This function is only a basic sanity check; it will hardly flush out +# determined imposters. +func_ltwrapper_script_p () +{ + func_lalib_p "$1" +} + +# func_ltwrapper_executable_p file +# True iff FILE is a libtool wrapper executable +# This function is only a basic sanity check; it will hardly flush out +# determined imposters. +func_ltwrapper_executable_p () +{ + func_ltwrapper_exec_suffix= + case $1 in + *.exe) ;; + *) func_ltwrapper_exec_suffix=.exe ;; + esac + $GREP "$magic_exe" "$1$func_ltwrapper_exec_suffix" >/dev/null 2>&1 +} + +# func_ltwrapper_scriptname file +# Assumes file is an ltwrapper_executable +# uses $file to determine the appropriate filename for a +# temporary ltwrapper_script. +func_ltwrapper_scriptname () +{ + func_dirname_and_basename "$1" "" "." + func_stripname '' '.exe' "$func_basename_result" + func_ltwrapper_scriptname_result="$func_dirname_result/$objdir/${func_stripname_result}_ltshwrapper" +} + +# func_ltwrapper_p file +# True iff FILE is a libtool wrapper script or wrapper executable +# This function is only a basic sanity check; it will hardly flush out +# determined imposters. +func_ltwrapper_p () +{ + func_ltwrapper_script_p "$1" || func_ltwrapper_executable_p "$1" +} + + +# func_execute_cmds commands fail_cmd +# Execute tilde-delimited COMMANDS. +# If FAIL_CMD is given, eval that upon failure. +# FAIL_CMD may read-access the current command in variable CMD! +func_execute_cmds () +{ + $opt_debug + save_ifs=$IFS; IFS='~' + for cmd in $1; do + IFS=$save_ifs + eval cmd=\"$cmd\" + func_show_eval "$cmd" "${2-:}" + done + IFS=$save_ifs +} + + +# func_source file +# Source FILE, adding directory component if necessary. +# Note that it is not necessary on cygwin/mingw to append a dot to +# FILE even if both FILE and FILE.exe exist: automatic-append-.exe +# behavior happens only for exec(3), not for open(2)! Also, sourcing +# `FILE.' does not work on cygwin managed mounts. +func_source () +{ + $opt_debug + case $1 in + */* | *\\*) . "$1" ;; + *) . "./$1" ;; + esac +} + + +# func_resolve_sysroot PATH +# Replace a leading = in PATH with a sysroot. Store the result into +# func_resolve_sysroot_result +func_resolve_sysroot () +{ + func_resolve_sysroot_result=$1 + case $func_resolve_sysroot_result in + =*) + func_stripname '=' '' "$func_resolve_sysroot_result" + func_resolve_sysroot_result=$lt_sysroot$func_stripname_result + ;; + esac +} + +# func_replace_sysroot PATH +# If PATH begins with the sysroot, replace it with = and +# store the result into func_replace_sysroot_result. +func_replace_sysroot () +{ + case "$lt_sysroot:$1" in + ?*:"$lt_sysroot"*) + func_stripname "$lt_sysroot" '' "$1" + func_replace_sysroot_result="=$func_stripname_result" + ;; + *) + # Including no sysroot. + func_replace_sysroot_result=$1 + ;; + esac +} + +# func_infer_tag arg +# Infer tagged configuration to use if any are available and +# if one wasn't chosen via the "--tag" command line option. +# Only attempt this if the compiler in the base compile +# command doesn't match the default compiler. +# arg is usually of the form 'gcc ...' +func_infer_tag () +{ + $opt_debug + if test -n "$available_tags" && test -z "$tagname"; then + CC_quoted= + for arg in $CC; do + func_append_quoted CC_quoted "$arg" + done + CC_expanded=`func_echo_all $CC` + CC_quoted_expanded=`func_echo_all $CC_quoted` + case $@ in + # Blanks in the command may have been stripped by the calling shell, + # but not from the CC environment variable when configure was run. + " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \ + " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*) ;; + # Blanks at the start of $base_compile will cause this to fail + # if we don't check for them as well. + *) + for z in $available_tags; do + if $GREP "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then + # Evaluate the configuration. + eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`" + CC_quoted= + for arg in $CC; do + # Double-quote args containing other shell metacharacters. + func_append_quoted CC_quoted "$arg" + done + CC_expanded=`func_echo_all $CC` + CC_quoted_expanded=`func_echo_all $CC_quoted` + case "$@ " in + " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \ + " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*) + # The compiler in the base compile command matches + # the one in the tagged configuration. + # Assume this is the tagged configuration we want. + tagname=$z + break + ;; + esac + fi + done + # If $tagname still isn't set, then no tagged configuration + # was found and let the user know that the "--tag" command + # line option must be used. + if test -z "$tagname"; then + func_echo "unable to infer tagged configuration" + func_fatal_error "specify a tag with \`--tag'" +# else +# func_verbose "using $tagname tagged configuration" + fi + ;; + esac + fi +} + + + +# func_write_libtool_object output_name pic_name nonpic_name +# Create a libtool object file (analogous to a ".la" file), +# but don't create it if we're doing a dry run. +func_write_libtool_object () +{ + write_libobj=${1} + if test "$build_libtool_libs" = yes; then + write_lobj=\'${2}\' + else + write_lobj=none + fi + + if test "$build_old_libs" = yes; then + write_oldobj=\'${3}\' + else + write_oldobj=none + fi + + $opt_dry_run || { + cat >${write_libobj}T </dev/null` + if test "$?" -eq 0 && test -n "${func_convert_core_file_wine_to_w32_tmp}"; then + func_convert_core_file_wine_to_w32_result=`$ECHO "$func_convert_core_file_wine_to_w32_tmp" | + $SED -e "$lt_sed_naive_backslashify"` + else + func_convert_core_file_wine_to_w32_result= + fi + fi +} +# end: func_convert_core_file_wine_to_w32 + + +# func_convert_core_path_wine_to_w32 ARG +# Helper function used by path conversion functions when $build is *nix, and +# $host is mingw, cygwin, or some other w32 environment. Relies on a correctly +# configured wine environment available, with the winepath program in $build's +# $PATH. Assumes ARG has no leading or trailing path separator characters. +# +# ARG is path to be converted from $build format to win32. +# Result is available in $func_convert_core_path_wine_to_w32_result. +# Unconvertible file (directory) names in ARG are skipped; if no directory names +# are convertible, then the result may be empty. +func_convert_core_path_wine_to_w32 () +{ + $opt_debug + # unfortunately, winepath doesn't convert paths, only file names + func_convert_core_path_wine_to_w32_result="" + if test -n "$1"; then + oldIFS=$IFS + IFS=: + for func_convert_core_path_wine_to_w32_f in $1; do + IFS=$oldIFS + func_convert_core_file_wine_to_w32 "$func_convert_core_path_wine_to_w32_f" + if test -n "$func_convert_core_file_wine_to_w32_result" ; then + if test -z "$func_convert_core_path_wine_to_w32_result"; then + func_convert_core_path_wine_to_w32_result="$func_convert_core_file_wine_to_w32_result" + else + func_append func_convert_core_path_wine_to_w32_result ";$func_convert_core_file_wine_to_w32_result" + fi + fi + done + IFS=$oldIFS + fi +} +# end: func_convert_core_path_wine_to_w32 + + +# func_cygpath ARGS... +# Wrapper around calling the cygpath program via LT_CYGPATH. This is used when +# when (1) $build is *nix and Cygwin is hosted via a wine environment; or (2) +# $build is MSYS and $host is Cygwin, or (3) $build is Cygwin. In case (1) or +# (2), returns the Cygwin file name or path in func_cygpath_result (input +# file name or path is assumed to be in w32 format, as previously converted +# from $build's *nix or MSYS format). In case (3), returns the w32 file name +# or path in func_cygpath_result (input file name or path is assumed to be in +# Cygwin format). Returns an empty string on error. +# +# ARGS are passed to cygpath, with the last one being the file name or path to +# be converted. +# +# Specify the absolute *nix (or w32) name to cygpath in the LT_CYGPATH +# environment variable; do not put it in $PATH. +func_cygpath () +{ + $opt_debug + if test -n "$LT_CYGPATH" && test -f "$LT_CYGPATH"; then + func_cygpath_result=`$LT_CYGPATH "$@" 2>/dev/null` + if test "$?" -ne 0; then + # on failure, ensure result is empty + func_cygpath_result= + fi + else + func_cygpath_result= + func_error "LT_CYGPATH is empty or specifies non-existent file: \`$LT_CYGPATH'" + fi +} +#end: func_cygpath + + +# func_convert_core_msys_to_w32 ARG +# Convert file name or path ARG from MSYS format to w32 format. Return +# result in func_convert_core_msys_to_w32_result. +func_convert_core_msys_to_w32 () +{ + $opt_debug + # awkward: cmd appends spaces to result + func_convert_core_msys_to_w32_result=`( cmd //c echo "$1" ) 2>/dev/null | + $SED -e 's/[ ]*$//' -e "$lt_sed_naive_backslashify"` +} +#end: func_convert_core_msys_to_w32 + + +# func_convert_file_check ARG1 ARG2 +# Verify that ARG1 (a file name in $build format) was converted to $host +# format in ARG2. Otherwise, emit an error message, but continue (resetting +# func_to_host_file_result to ARG1). +func_convert_file_check () +{ + $opt_debug + if test -z "$2" && test -n "$1" ; then + func_error "Could not determine host file name corresponding to" + func_error " \`$1'" + func_error "Continuing, but uninstalled executables may not work." + # Fallback: + func_to_host_file_result="$1" + fi +} +# end func_convert_file_check + + +# func_convert_path_check FROM_PATHSEP TO_PATHSEP FROM_PATH TO_PATH +# Verify that FROM_PATH (a path in $build format) was converted to $host +# format in TO_PATH. Otherwise, emit an error message, but continue, resetting +# func_to_host_file_result to a simplistic fallback value (see below). +func_convert_path_check () +{ + $opt_debug + if test -z "$4" && test -n "$3"; then + func_error "Could not determine the host path corresponding to" + func_error " \`$3'" + func_error "Continuing, but uninstalled executables may not work." + # Fallback. This is a deliberately simplistic "conversion" and + # should not be "improved". See libtool.info. + if test "x$1" != "x$2"; then + lt_replace_pathsep_chars="s|$1|$2|g" + func_to_host_path_result=`echo "$3" | + $SED -e "$lt_replace_pathsep_chars"` + else + func_to_host_path_result="$3" + fi + fi +} +# end func_convert_path_check + + +# func_convert_path_front_back_pathsep FRONTPAT BACKPAT REPL ORIG +# Modifies func_to_host_path_result by prepending REPL if ORIG matches FRONTPAT +# and appending REPL if ORIG matches BACKPAT. +func_convert_path_front_back_pathsep () +{ + $opt_debug + case $4 in + $1 ) func_to_host_path_result="$3$func_to_host_path_result" + ;; + esac + case $4 in + $2 ) func_append func_to_host_path_result "$3" + ;; + esac +} +# end func_convert_path_front_back_pathsep + + +################################################## +# $build to $host FILE NAME CONVERSION FUNCTIONS # +################################################## +# invoked via `$to_host_file_cmd ARG' +# +# In each case, ARG is the path to be converted from $build to $host format. +# Result will be available in $func_to_host_file_result. + + +# func_to_host_file ARG +# Converts the file name ARG from $build format to $host format. Return result +# in func_to_host_file_result. +func_to_host_file () +{ + $opt_debug + $to_host_file_cmd "$1" +} +# end func_to_host_file + + +# func_to_tool_file ARG LAZY +# converts the file name ARG from $build format to toolchain format. Return +# result in func_to_tool_file_result. If the conversion in use is listed +# in (the comma separated) LAZY, no conversion takes place. +func_to_tool_file () +{ + $opt_debug + case ,$2, in + *,"$to_tool_file_cmd",*) + func_to_tool_file_result=$1 + ;; + *) + $to_tool_file_cmd "$1" + func_to_tool_file_result=$func_to_host_file_result + ;; + esac +} +# end func_to_tool_file + + +# func_convert_file_noop ARG +# Copy ARG to func_to_host_file_result. +func_convert_file_noop () +{ + func_to_host_file_result="$1" +} +# end func_convert_file_noop + + +# func_convert_file_msys_to_w32 ARG +# Convert file name ARG from (mingw) MSYS to (mingw) w32 format; automatic +# conversion to w32 is not available inside the cwrapper. Returns result in +# func_to_host_file_result. +func_convert_file_msys_to_w32 () +{ + $opt_debug + func_to_host_file_result="$1" + if test -n "$1"; then + func_convert_core_msys_to_w32 "$1" + func_to_host_file_result="$func_convert_core_msys_to_w32_result" + fi + func_convert_file_check "$1" "$func_to_host_file_result" +} +# end func_convert_file_msys_to_w32 + + +# func_convert_file_cygwin_to_w32 ARG +# Convert file name ARG from Cygwin to w32 format. Returns result in +# func_to_host_file_result. +func_convert_file_cygwin_to_w32 () +{ + $opt_debug + func_to_host_file_result="$1" + if test -n "$1"; then + # because $build is cygwin, we call "the" cygpath in $PATH; no need to use + # LT_CYGPATH in this case. + func_to_host_file_result=`cygpath -m "$1"` + fi + func_convert_file_check "$1" "$func_to_host_file_result" +} +# end func_convert_file_cygwin_to_w32 + + +# func_convert_file_nix_to_w32 ARG +# Convert file name ARG from *nix to w32 format. Requires a wine environment +# and a working winepath. Returns result in func_to_host_file_result. +func_convert_file_nix_to_w32 () +{ + $opt_debug + func_to_host_file_result="$1" + if test -n "$1"; then + func_convert_core_file_wine_to_w32 "$1" + func_to_host_file_result="$func_convert_core_file_wine_to_w32_result" + fi + func_convert_file_check "$1" "$func_to_host_file_result" +} +# end func_convert_file_nix_to_w32 + + +# func_convert_file_msys_to_cygwin ARG +# Convert file name ARG from MSYS to Cygwin format. Requires LT_CYGPATH set. +# Returns result in func_to_host_file_result. +func_convert_file_msys_to_cygwin () +{ + $opt_debug + func_to_host_file_result="$1" + if test -n "$1"; then + func_convert_core_msys_to_w32 "$1" + func_cygpath -u "$func_convert_core_msys_to_w32_result" + func_to_host_file_result="$func_cygpath_result" + fi + func_convert_file_check "$1" "$func_to_host_file_result" +} +# end func_convert_file_msys_to_cygwin + + +# func_convert_file_nix_to_cygwin ARG +# Convert file name ARG from *nix to Cygwin format. Requires Cygwin installed +# in a wine environment, working winepath, and LT_CYGPATH set. Returns result +# in func_to_host_file_result. +func_convert_file_nix_to_cygwin () +{ + $opt_debug + func_to_host_file_result="$1" + if test -n "$1"; then + # convert from *nix to w32, then use cygpath to convert from w32 to cygwin. + func_convert_core_file_wine_to_w32 "$1" + func_cygpath -u "$func_convert_core_file_wine_to_w32_result" + func_to_host_file_result="$func_cygpath_result" + fi + func_convert_file_check "$1" "$func_to_host_file_result" +} +# end func_convert_file_nix_to_cygwin + + +############################################# +# $build to $host PATH CONVERSION FUNCTIONS # +############################################# +# invoked via `$to_host_path_cmd ARG' +# +# In each case, ARG is the path to be converted from $build to $host format. +# The result will be available in $func_to_host_path_result. +# +# Path separators are also converted from $build format to $host format. If +# ARG begins or ends with a path separator character, it is preserved (but +# converted to $host format) on output. +# +# All path conversion functions are named using the following convention: +# file name conversion function : func_convert_file_X_to_Y () +# path conversion function : func_convert_path_X_to_Y () +# where, for any given $build/$host combination the 'X_to_Y' value is the +# same. If conversion functions are added for new $build/$host combinations, +# the two new functions must follow this pattern, or func_init_to_host_path_cmd +# will break. + + +# func_init_to_host_path_cmd +# Ensures that function "pointer" variable $to_host_path_cmd is set to the +# appropriate value, based on the value of $to_host_file_cmd. +to_host_path_cmd= +func_init_to_host_path_cmd () +{ + $opt_debug + if test -z "$to_host_path_cmd"; then + func_stripname 'func_convert_file_' '' "$to_host_file_cmd" + to_host_path_cmd="func_convert_path_${func_stripname_result}" + fi +} + + +# func_to_host_path ARG +# Converts the path ARG from $build format to $host format. Return result +# in func_to_host_path_result. +func_to_host_path () +{ + $opt_debug + func_init_to_host_path_cmd + $to_host_path_cmd "$1" +} +# end func_to_host_path + + +# func_convert_path_noop ARG +# Copy ARG to func_to_host_path_result. +func_convert_path_noop () +{ + func_to_host_path_result="$1" +} +# end func_convert_path_noop + + +# func_convert_path_msys_to_w32 ARG +# Convert path ARG from (mingw) MSYS to (mingw) w32 format; automatic +# conversion to w32 is not available inside the cwrapper. Returns result in +# func_to_host_path_result. +func_convert_path_msys_to_w32 () +{ + $opt_debug + func_to_host_path_result="$1" + if test -n "$1"; then + # Remove leading and trailing path separator characters from ARG. MSYS + # behavior is inconsistent here; cygpath turns them into '.;' and ';.'; + # and winepath ignores them completely. + func_stripname : : "$1" + func_to_host_path_tmp1=$func_stripname_result + func_convert_core_msys_to_w32 "$func_to_host_path_tmp1" + func_to_host_path_result="$func_convert_core_msys_to_w32_result" + func_convert_path_check : ";" \ + "$func_to_host_path_tmp1" "$func_to_host_path_result" + func_convert_path_front_back_pathsep ":*" "*:" ";" "$1" + fi +} +# end func_convert_path_msys_to_w32 + + +# func_convert_path_cygwin_to_w32 ARG +# Convert path ARG from Cygwin to w32 format. Returns result in +# func_to_host_file_result. +func_convert_path_cygwin_to_w32 () +{ + $opt_debug + func_to_host_path_result="$1" + if test -n "$1"; then + # See func_convert_path_msys_to_w32: + func_stripname : : "$1" + func_to_host_path_tmp1=$func_stripname_result + func_to_host_path_result=`cygpath -m -p "$func_to_host_path_tmp1"` + func_convert_path_check : ";" \ + "$func_to_host_path_tmp1" "$func_to_host_path_result" + func_convert_path_front_back_pathsep ":*" "*:" ";" "$1" + fi +} +# end func_convert_path_cygwin_to_w32 + + +# func_convert_path_nix_to_w32 ARG +# Convert path ARG from *nix to w32 format. Requires a wine environment and +# a working winepath. Returns result in func_to_host_file_result. +func_convert_path_nix_to_w32 () +{ + $opt_debug + func_to_host_path_result="$1" + if test -n "$1"; then + # See func_convert_path_msys_to_w32: + func_stripname : : "$1" + func_to_host_path_tmp1=$func_stripname_result + func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1" + func_to_host_path_result="$func_convert_core_path_wine_to_w32_result" + func_convert_path_check : ";" \ + "$func_to_host_path_tmp1" "$func_to_host_path_result" + func_convert_path_front_back_pathsep ":*" "*:" ";" "$1" + fi +} +# end func_convert_path_nix_to_w32 + + +# func_convert_path_msys_to_cygwin ARG +# Convert path ARG from MSYS to Cygwin format. Requires LT_CYGPATH set. +# Returns result in func_to_host_file_result. +func_convert_path_msys_to_cygwin () +{ + $opt_debug + func_to_host_path_result="$1" + if test -n "$1"; then + # See func_convert_path_msys_to_w32: + func_stripname : : "$1" + func_to_host_path_tmp1=$func_stripname_result + func_convert_core_msys_to_w32 "$func_to_host_path_tmp1" + func_cygpath -u -p "$func_convert_core_msys_to_w32_result" + func_to_host_path_result="$func_cygpath_result" + func_convert_path_check : : \ + "$func_to_host_path_tmp1" "$func_to_host_path_result" + func_convert_path_front_back_pathsep ":*" "*:" : "$1" + fi +} +# end func_convert_path_msys_to_cygwin + + +# func_convert_path_nix_to_cygwin ARG +# Convert path ARG from *nix to Cygwin format. Requires Cygwin installed in a +# a wine environment, working winepath, and LT_CYGPATH set. Returns result in +# func_to_host_file_result. +func_convert_path_nix_to_cygwin () +{ + $opt_debug + func_to_host_path_result="$1" + if test -n "$1"; then + # Remove leading and trailing path separator characters from + # ARG. msys behavior is inconsistent here, cygpath turns them + # into '.;' and ';.', and winepath ignores them completely. + func_stripname : : "$1" + func_to_host_path_tmp1=$func_stripname_result + func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1" + func_cygpath -u -p "$func_convert_core_path_wine_to_w32_result" + func_to_host_path_result="$func_cygpath_result" + func_convert_path_check : : \ + "$func_to_host_path_tmp1" "$func_to_host_path_result" + func_convert_path_front_back_pathsep ":*" "*:" : "$1" + fi +} +# end func_convert_path_nix_to_cygwin + + +# func_mode_compile arg... +func_mode_compile () +{ + $opt_debug + # Get the compilation command and the source file. + base_compile= + srcfile="$nonopt" # always keep a non-empty value in "srcfile" + suppress_opt=yes + suppress_output= + arg_mode=normal + libobj= + later= + pie_flag= + + for arg + do + case $arg_mode in + arg ) + # do not "continue". Instead, add this to base_compile + lastarg="$arg" + arg_mode=normal + ;; + + target ) + libobj="$arg" + arg_mode=normal + continue + ;; + + normal ) + # Accept any command-line options. + case $arg in + -o) + test -n "$libobj" && \ + func_fatal_error "you cannot specify \`-o' more than once" + arg_mode=target + continue + ;; + + -pie | -fpie | -fPIE) + func_append pie_flag " $arg" + continue + ;; + + -shared | -static | -prefer-pic | -prefer-non-pic) + func_append later " $arg" + continue + ;; + + -no-suppress) + suppress_opt=no + continue + ;; + + -Xcompiler) + arg_mode=arg # the next one goes into the "base_compile" arg list + continue # The current "srcfile" will either be retained or + ;; # replaced later. I would guess that would be a bug. + + -Wc,*) + func_stripname '-Wc,' '' "$arg" + args=$func_stripname_result + lastarg= + save_ifs="$IFS"; IFS=',' + for arg in $args; do + IFS="$save_ifs" + func_append_quoted lastarg "$arg" + done + IFS="$save_ifs" + func_stripname ' ' '' "$lastarg" + lastarg=$func_stripname_result + + # Add the arguments to base_compile. + func_append base_compile " $lastarg" + continue + ;; + + *) + # Accept the current argument as the source file. + # The previous "srcfile" becomes the current argument. + # + lastarg="$srcfile" + srcfile="$arg" + ;; + esac # case $arg + ;; + esac # case $arg_mode + + # Aesthetically quote the previous argument. + func_append_quoted base_compile "$lastarg" + done # for arg + + case $arg_mode in + arg) + func_fatal_error "you must specify an argument for -Xcompile" + ;; + target) + func_fatal_error "you must specify a target with \`-o'" + ;; + *) + # Get the name of the library object. + test -z "$libobj" && { + func_basename "$srcfile" + libobj="$func_basename_result" + } + ;; + esac + + # Recognize several different file suffixes. + # If the user specifies -o file.o, it is replaced with file.lo + case $libobj in + *.[cCFSifmso] | \ + *.ada | *.adb | *.ads | *.asm | \ + *.c++ | *.cc | *.ii | *.class | *.cpp | *.cxx | \ + *.[fF][09]? | *.for | *.java | *.go | *.obj | *.sx | *.cu | *.cup) + func_xform "$libobj" + libobj=$func_xform_result + ;; + esac + + case $libobj in + *.lo) func_lo2o "$libobj"; obj=$func_lo2o_result ;; + *) + func_fatal_error "cannot determine name of library object from \`$libobj'" + ;; + esac + + func_infer_tag $base_compile + + for arg in $later; do + case $arg in + -shared) + test "$build_libtool_libs" != yes && \ + func_fatal_configuration "can not build a shared library" + build_old_libs=no + continue + ;; + + -static) + build_libtool_libs=no + build_old_libs=yes + continue + ;; + + -prefer-pic) + pic_mode=yes + continue + ;; + + -prefer-non-pic) + pic_mode=no + continue + ;; + esac + done + + func_quote_for_eval "$libobj" + test "X$libobj" != "X$func_quote_for_eval_result" \ + && $ECHO "X$libobj" | $GREP '[]~#^*{};<>?"'"'"' &()|`$[]' \ + && func_warning "libobj name \`$libobj' may not contain shell special characters." + func_dirname_and_basename "$obj" "/" "" + objname="$func_basename_result" + xdir="$func_dirname_result" + lobj=${xdir}$objdir/$objname + + test -z "$base_compile" && \ + func_fatal_help "you must specify a compilation command" + + # Delete any leftover library objects. + if test "$build_old_libs" = yes; then + removelist="$obj $lobj $libobj ${libobj}T" + else + removelist="$lobj $libobj ${libobj}T" + fi + + # On Cygwin there's no "real" PIC flag so we must build both object types + case $host_os in + cygwin* | mingw* | pw32* | os2* | cegcc*) + pic_mode=default + ;; + esac + if test "$pic_mode" = no && test "$deplibs_check_method" != pass_all; then + # non-PIC code in shared libraries is not supported + pic_mode=default + fi + + # Calculate the filename of the output object if compiler does + # not support -o with -c + if test "$compiler_c_o" = no; then + output_obj=`$ECHO "$srcfile" | $SED 's%^.*/%%; s%\.[^.]*$%%'`.${objext} + lockfile="$output_obj.lock" + else + output_obj= + need_locks=no + lockfile= + fi + + # Lock this critical section if it is needed + # We use this script file to make the link, it avoids creating a new file + if test "$need_locks" = yes; then + until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do + func_echo "Waiting for $lockfile to be removed" + sleep 2 + done + elif test "$need_locks" = warn; then + if test -f "$lockfile"; then + $ECHO "\ +*** ERROR, $lockfile exists and contains: +`cat $lockfile 2>/dev/null` + +This indicates that another process is trying to use the same +temporary object file, and libtool could not work around it because +your compiler does not support \`-c' and \`-o' together. If you +repeat this compilation, it may succeed, by chance, but you had better +avoid parallel builds (make -j) in this platform, or get a better +compiler." + + $opt_dry_run || $RM $removelist + exit $EXIT_FAILURE + fi + func_append removelist " $output_obj" + $ECHO "$srcfile" > "$lockfile" + fi + + $opt_dry_run || $RM $removelist + func_append removelist " $lockfile" + trap '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE' 1 2 15 + + func_to_tool_file "$srcfile" func_convert_file_msys_to_w32 + srcfile=$func_to_tool_file_result + func_quote_for_eval "$srcfile" + qsrcfile=$func_quote_for_eval_result + + # Only build a PIC object if we are building libtool libraries. + if test "$build_libtool_libs" = yes; then + # Without this assignment, base_compile gets emptied. + fbsd_hideous_sh_bug=$base_compile + + if test "$pic_mode" != no; then + command="$base_compile $qsrcfile $pic_flag" + else + # Don't build PIC code + command="$base_compile $qsrcfile" + fi + + func_mkdir_p "$xdir$objdir" + + if test -z "$output_obj"; then + # Place PIC objects in $objdir + func_append command " -o $lobj" + fi + + func_show_eval_locale "$command" \ + 'test -n "$output_obj" && $RM $removelist; exit $EXIT_FAILURE' + + if test "$need_locks" = warn && + test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then + $ECHO "\ +*** ERROR, $lockfile contains: +`cat $lockfile 2>/dev/null` + +but it should contain: +$srcfile + +This indicates that another process is trying to use the same +temporary object file, and libtool could not work around it because +your compiler does not support \`-c' and \`-o' together. If you +repeat this compilation, it may succeed, by chance, but you had better +avoid parallel builds (make -j) in this platform, or get a better +compiler." + + $opt_dry_run || $RM $removelist + exit $EXIT_FAILURE + fi + + # Just move the object if needed, then go on to compile the next one + if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then + func_show_eval '$MV "$output_obj" "$lobj"' \ + 'error=$?; $opt_dry_run || $RM $removelist; exit $error' + fi + + # Allow error messages only from the first compilation. + if test "$suppress_opt" = yes; then + suppress_output=' >/dev/null 2>&1' + fi + fi + + # Only build a position-dependent object if we build old libraries. + if test "$build_old_libs" = yes; then + if test "$pic_mode" != yes; then + # Don't build PIC code + command="$base_compile $qsrcfile$pie_flag" + else + command="$base_compile $qsrcfile $pic_flag" + fi + if test "$compiler_c_o" = yes; then + func_append command " -o $obj" + fi + + # Suppress compiler output if we already did a PIC compilation. + func_append command "$suppress_output" + func_show_eval_locale "$command" \ + '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE' + + if test "$need_locks" = warn && + test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then + $ECHO "\ +*** ERROR, $lockfile contains: +`cat $lockfile 2>/dev/null` + +but it should contain: +$srcfile + +This indicates that another process is trying to use the same +temporary object file, and libtool could not work around it because +your compiler does not support \`-c' and \`-o' together. If you +repeat this compilation, it may succeed, by chance, but you had better +avoid parallel builds (make -j) in this platform, or get a better +compiler." + + $opt_dry_run || $RM $removelist + exit $EXIT_FAILURE + fi + + # Just move the object if needed + if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then + func_show_eval '$MV "$output_obj" "$obj"' \ + 'error=$?; $opt_dry_run || $RM $removelist; exit $error' + fi + fi + + $opt_dry_run || { + func_write_libtool_object "$libobj" "$objdir/$objname" "$objname" + + # Unlock the critical section if it was locked + if test "$need_locks" != no; then + removelist=$lockfile + $RM "$lockfile" + fi + } + + exit $EXIT_SUCCESS +} + +$opt_help || { + test "$opt_mode" = compile && func_mode_compile ${1+"$@"} +} + +func_mode_help () +{ + # We need to display help for each of the modes. + case $opt_mode in + "") + # Generic help is extracted from the usage comments + # at the start of this file. + func_help + ;; + + clean) + $ECHO \ +"Usage: $progname [OPTION]... --mode=clean RM [RM-OPTION]... FILE... + +Remove files from the build directory. + +RM is the name of the program to use to delete files associated with each FILE +(typically \`/bin/rm'). RM-OPTIONS are options (such as \`-f') to be passed +to RM. + +If FILE is a libtool library, object or program, all the files associated +with it are deleted. Otherwise, only FILE itself is deleted using RM." + ;; + + compile) + $ECHO \ +"Usage: $progname [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE + +Compile a source file into a libtool library object. + +This mode accepts the following additional options: + + -o OUTPUT-FILE set the output file name to OUTPUT-FILE + -no-suppress do not suppress compiler output for multiple passes + -prefer-pic try to build PIC objects only + -prefer-non-pic try to build non-PIC objects only + -shared do not build a \`.o' file suitable for static linking + -static only build a \`.o' file suitable for static linking + -Wc,FLAG pass FLAG directly to the compiler + +COMPILE-COMMAND is a command to be used in creating a \`standard' object file +from the given SOURCEFILE. + +The output file name is determined by removing the directory component from +SOURCEFILE, then substituting the C source code suffix \`.c' with the +library object suffix, \`.lo'." + ;; + + execute) + $ECHO \ +"Usage: $progname [OPTION]... --mode=execute COMMAND [ARGS]... + +Automatically set library path, then run a program. + +This mode accepts the following additional options: + + -dlopen FILE add the directory containing FILE to the library path + +This mode sets the library path environment variable according to \`-dlopen' +flags. + +If any of the ARGS are libtool executable wrappers, then they are translated +into their corresponding uninstalled binary, and any of their required library +directories are added to the library path. + +Then, COMMAND is executed, with ARGS as arguments." + ;; + + finish) + $ECHO \ +"Usage: $progname [OPTION]... --mode=finish [LIBDIR]... + +Complete the installation of libtool libraries. + +Each LIBDIR is a directory that contains libtool libraries. + +The commands that this mode executes may require superuser privileges. Use +the \`--dry-run' option if you just want to see what would be executed." + ;; + + install) + $ECHO \ +"Usage: $progname [OPTION]... --mode=install INSTALL-COMMAND... + +Install executables or libraries. + +INSTALL-COMMAND is the installation command. The first component should be +either the \`install' or \`cp' program. + +The following components of INSTALL-COMMAND are treated specially: + + -inst-prefix-dir PREFIX-DIR Use PREFIX-DIR as a staging area for installation + +The rest of the components are interpreted as arguments to that command (only +BSD-compatible install options are recognized)." + ;; + + link) + $ECHO \ +"Usage: $progname [OPTION]... --mode=link LINK-COMMAND... + +Link object files or libraries together to form another library, or to +create an executable program. + +LINK-COMMAND is a command using the C compiler that you would use to create +a program from several object files. + +The following components of LINK-COMMAND are treated specially: + + -all-static do not do any dynamic linking at all + -avoid-version do not add a version suffix if possible + -bindir BINDIR specify path to binaries directory (for systems where + libraries must be found in the PATH setting at runtime) + -dlopen FILE \`-dlpreopen' FILE if it cannot be dlopened at runtime + -dlpreopen FILE link in FILE and add its symbols to lt_preloaded_symbols + -export-dynamic allow symbols from OUTPUT-FILE to be resolved with dlsym(3) + -export-symbols SYMFILE + try to export only the symbols listed in SYMFILE + -export-symbols-regex REGEX + try to export only the symbols matching REGEX + -LLIBDIR search LIBDIR for required installed libraries + -lNAME OUTPUT-FILE requires the installed library libNAME + -module build a library that can dlopened + -no-fast-install disable the fast-install mode + -no-install link a not-installable executable + -no-undefined declare that a library does not refer to external symbols + -o OUTPUT-FILE create OUTPUT-FILE from the specified objects + -objectlist FILE Use a list of object files found in FILE to specify objects + -precious-files-regex REGEX + don't remove output files matching REGEX + -release RELEASE specify package release information + -rpath LIBDIR the created library will eventually be installed in LIBDIR + -R[ ]LIBDIR add LIBDIR to the runtime path of programs and libraries + -shared only do dynamic linking of libtool libraries + -shrext SUFFIX override the standard shared library file extension + -static do not do any dynamic linking of uninstalled libtool libraries + -static-libtool-libs + do not do any dynamic linking of libtool libraries + -version-info CURRENT[:REVISION[:AGE]] + specify library version info [each variable defaults to 0] + -weak LIBNAME declare that the target provides the LIBNAME interface + -Wc,FLAG + -Xcompiler FLAG pass linker-specific FLAG directly to the compiler + -Wl,FLAG + -Xlinker FLAG pass linker-specific FLAG directly to the linker + -XCClinker FLAG pass link-specific FLAG to the compiler driver (CC) + +All other options (arguments beginning with \`-') are ignored. + +Every other argument is treated as a filename. Files ending in \`.la' are +treated as uninstalled libtool libraries, other files are standard or library +object files. + +If the OUTPUT-FILE ends in \`.la', then a libtool library is created, +only library objects (\`.lo' files) may be specified, and \`-rpath' is +required, except when creating a convenience library. + +If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created +using \`ar' and \`ranlib', or on Windows using \`lib'. + +If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file +is created, otherwise an executable program is created." + ;; + + uninstall) + $ECHO \ +"Usage: $progname [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE... + +Remove libraries from an installation directory. + +RM is the name of the program to use to delete files associated with each FILE +(typically \`/bin/rm'). RM-OPTIONS are options (such as \`-f') to be passed +to RM. + +If FILE is a libtool library, all the files associated with it are deleted. +Otherwise, only FILE itself is deleted using RM." + ;; + + *) + func_fatal_help "invalid operation mode \`$opt_mode'" + ;; + esac + + echo + $ECHO "Try \`$progname --help' for more information about other modes." +} + +# Now that we've collected a possible --mode arg, show help if necessary +if $opt_help; then + if test "$opt_help" = :; then + func_mode_help + else + { + func_help noexit + for opt_mode in compile link execute install finish uninstall clean; do + func_mode_help + done + } | sed -n '1p; 2,$s/^Usage:/ or: /p' + { + func_help noexit + for opt_mode in compile link execute install finish uninstall clean; do + echo + func_mode_help + done + } | + sed '1d + /^When reporting/,/^Report/{ + H + d + } + $x + /information about other modes/d + /more detailed .*MODE/d + s/^Usage:.*--mode=\([^ ]*\) .*/Description of \1 mode:/' + fi + exit $? +fi + + +# func_mode_execute arg... +func_mode_execute () +{ + $opt_debug + # The first argument is the command name. + cmd="$nonopt" + test -z "$cmd" && \ + func_fatal_help "you must specify a COMMAND" + + # Handle -dlopen flags immediately. + for file in $opt_dlopen; do + test -f "$file" \ + || func_fatal_help "\`$file' is not a file" + + dir= + case $file in + *.la) + func_resolve_sysroot "$file" + file=$func_resolve_sysroot_result + + # Check to see that this really is a libtool archive. + func_lalib_unsafe_p "$file" \ + || func_fatal_help "\`$lib' is not a valid libtool archive" + + # Read the libtool library. + dlname= + library_names= + func_source "$file" + + # Skip this library if it cannot be dlopened. + if test -z "$dlname"; then + # Warn if it was a shared library. + test -n "$library_names" && \ + func_warning "\`$file' was not linked with \`-export-dynamic'" + continue + fi + + func_dirname "$file" "" "." + dir="$func_dirname_result" + + if test -f "$dir/$objdir/$dlname"; then + func_append dir "/$objdir" + else + if test ! -f "$dir/$dlname"; then + func_fatal_error "cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'" + fi + fi + ;; + + *.lo) + # Just add the directory containing the .lo file. + func_dirname "$file" "" "." + dir="$func_dirname_result" + ;; + + *) + func_warning "\`-dlopen' is ignored for non-libtool libraries and objects" + continue + ;; + esac + + # Get the absolute pathname. + absdir=`cd "$dir" && pwd` + test -n "$absdir" && dir="$absdir" + + # Now add the directory to shlibpath_var. + if eval "test -z \"\$$shlibpath_var\""; then + eval "$shlibpath_var=\"\$dir\"" + else + eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\"" + fi + done + + # This variable tells wrapper scripts just to set shlibpath_var + # rather than running their programs. + libtool_execute_magic="$magic" + + # Check if any of the arguments is a wrapper script. + args= + for file + do + case $file in + -* | *.la | *.lo ) ;; + *) + # Do a test to see if this is really a libtool program. + if func_ltwrapper_script_p "$file"; then + func_source "$file" + # Transform arg to wrapped name. + file="$progdir/$program" + elif func_ltwrapper_executable_p "$file"; then + func_ltwrapper_scriptname "$file" + func_source "$func_ltwrapper_scriptname_result" + # Transform arg to wrapped name. + file="$progdir/$program" + fi + ;; + esac + # Quote arguments (to preserve shell metacharacters). + func_append_quoted args "$file" + done + + if test "X$opt_dry_run" = Xfalse; then + if test -n "$shlibpath_var"; then + # Export the shlibpath_var. + eval "export $shlibpath_var" + fi + + # Restore saved environment variables + for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES + do + eval "if test \"\${save_$lt_var+set}\" = set; then + $lt_var=\$save_$lt_var; export $lt_var + else + $lt_unset $lt_var + fi" + done + + # Now prepare to actually exec the command. + exec_cmd="\$cmd$args" + else + # Display what would be done. + if test -n "$shlibpath_var"; then + eval "\$ECHO \"\$shlibpath_var=\$$shlibpath_var\"" + echo "export $shlibpath_var" + fi + $ECHO "$cmd$args" + exit $EXIT_SUCCESS + fi +} + +test "$opt_mode" = execute && func_mode_execute ${1+"$@"} + + +# func_mode_finish arg... +func_mode_finish () +{ + $opt_debug + libs= + libdirs= + admincmds= + + for opt in "$nonopt" ${1+"$@"} + do + if test -d "$opt"; then + func_append libdirs " $opt" + + elif test -f "$opt"; then + if func_lalib_unsafe_p "$opt"; then + func_append libs " $opt" + else + func_warning "\`$opt' is not a valid libtool archive" + fi + + else + func_fatal_error "invalid argument \`$opt'" + fi + done + + if test -n "$libs"; then + if test -n "$lt_sysroot"; then + sysroot_regex=`$ECHO "$lt_sysroot" | $SED "$sed_make_literal_regex"` + sysroot_cmd="s/\([ ']\)$sysroot_regex/\1/g;" + else + sysroot_cmd= + fi + + # Remove sysroot references + if $opt_dry_run; then + for lib in $libs; do + echo "removing references to $lt_sysroot and \`=' prefixes from $lib" + done + else + tmpdir=`func_mktempdir` + for lib in $libs; do + sed -e "${sysroot_cmd} s/\([ ']-[LR]\)=/\1/g; s/\([ ']\)=/\1/g" $lib \ + > $tmpdir/tmp-la + mv -f $tmpdir/tmp-la $lib + done + ${RM}r "$tmpdir" + fi + fi + + if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then + for libdir in $libdirs; do + if test -n "$finish_cmds"; then + # Do each command in the finish commands. + func_execute_cmds "$finish_cmds" 'admincmds="$admincmds +'"$cmd"'"' + fi + if test -n "$finish_eval"; then + # Do the single finish_eval. + eval cmds=\"$finish_eval\" + $opt_dry_run || eval "$cmds" || func_append admincmds " + $cmds" + fi + done + fi + + # Exit here if they wanted silent mode. + $opt_silent && exit $EXIT_SUCCESS + + if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then + echo "----------------------------------------------------------------------" + echo "Libraries have been installed in:" + for libdir in $libdirs; do + $ECHO " $libdir" + done + echo + echo "If you ever happen to want to link against installed libraries" + echo "in a given directory, LIBDIR, you must either use libtool, and" + echo "specify the full pathname of the library, or use the \`-LLIBDIR'" + echo "flag during linking and do at least one of the following:" + if test -n "$shlibpath_var"; then + echo " - add LIBDIR to the \`$shlibpath_var' environment variable" + echo " during execution" + fi + if test -n "$runpath_var"; then + echo " - add LIBDIR to the \`$runpath_var' environment variable" + echo " during linking" + fi + if test -n "$hardcode_libdir_flag_spec"; then + libdir=LIBDIR + eval flag=\"$hardcode_libdir_flag_spec\" + + $ECHO " - use the \`$flag' linker flag" + fi + if test -n "$admincmds"; then + $ECHO " - have your system administrator run these commands:$admincmds" + fi + if test -f /etc/ld.so.conf; then + echo " - have your system administrator add LIBDIR to \`/etc/ld.so.conf'" + fi + echo + + echo "See any operating system documentation about shared libraries for" + case $host in + solaris2.[6789]|solaris2.1[0-9]) + echo "more information, such as the ld(1), crle(1) and ld.so(8) manual" + echo "pages." + ;; + *) + echo "more information, such as the ld(1) and ld.so(8) manual pages." + ;; + esac + echo "----------------------------------------------------------------------" + fi + exit $EXIT_SUCCESS +} + +test "$opt_mode" = finish && func_mode_finish ${1+"$@"} + + +# func_mode_install arg... +func_mode_install () +{ + $opt_debug + # There may be an optional sh(1) argument at the beginning of + # install_prog (especially on Windows NT). + if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh || + # Allow the use of GNU shtool's install command. + case $nonopt in *shtool*) :;; *) false;; esac; then + # Aesthetically quote it. + func_quote_for_eval "$nonopt" + install_prog="$func_quote_for_eval_result " + arg=$1 + shift + else + install_prog= + arg=$nonopt + fi + + # The real first argument should be the name of the installation program. + # Aesthetically quote it. + func_quote_for_eval "$arg" + func_append install_prog "$func_quote_for_eval_result" + install_shared_prog=$install_prog + case " $install_prog " in + *[\\\ /]cp\ *) install_cp=: ;; + *) install_cp=false ;; + esac + + # We need to accept at least all the BSD install flags. + dest= + files= + opts= + prev= + install_type= + isdir=no + stripme= + no_mode=: + for arg + do + arg2= + if test -n "$dest"; then + func_append files " $dest" + dest=$arg + continue + fi + + case $arg in + -d) isdir=yes ;; + -f) + if $install_cp; then :; else + prev=$arg + fi + ;; + -g | -m | -o) + prev=$arg + ;; + -s) + stripme=" -s" + continue + ;; + -*) + ;; + *) + # If the previous option needed an argument, then skip it. + if test -n "$prev"; then + if test "x$prev" = x-m && test -n "$install_override_mode"; then + arg2=$install_override_mode + no_mode=false + fi + prev= + else + dest=$arg + continue + fi + ;; + esac + + # Aesthetically quote the argument. + func_quote_for_eval "$arg" + func_append install_prog " $func_quote_for_eval_result" + if test -n "$arg2"; then + func_quote_for_eval "$arg2" + fi + func_append install_shared_prog " $func_quote_for_eval_result" + done + + test -z "$install_prog" && \ + func_fatal_help "you must specify an install program" + + test -n "$prev" && \ + func_fatal_help "the \`$prev' option requires an argument" + + if test -n "$install_override_mode" && $no_mode; then + if $install_cp; then :; else + func_quote_for_eval "$install_override_mode" + func_append install_shared_prog " -m $func_quote_for_eval_result" + fi + fi + + if test -z "$files"; then + if test -z "$dest"; then + func_fatal_help "no file or destination specified" + else + func_fatal_help "you must specify a destination" + fi + fi + + # Strip any trailing slash from the destination. + func_stripname '' '/' "$dest" + dest=$func_stripname_result + + # Check to see that the destination is a directory. + test -d "$dest" && isdir=yes + if test "$isdir" = yes; then + destdir="$dest" + destname= + else + func_dirname_and_basename "$dest" "" "." + destdir="$func_dirname_result" + destname="$func_basename_result" + + # Not a directory, so check to see that there is only one file specified. + set dummy $files; shift + test "$#" -gt 1 && \ + func_fatal_help "\`$dest' is not a directory" + fi + case $destdir in + [\\/]* | [A-Za-z]:[\\/]*) ;; + *) + for file in $files; do + case $file in + *.lo) ;; + *) + func_fatal_help "\`$destdir' must be an absolute directory name" + ;; + esac + done + ;; + esac + + # This variable tells wrapper scripts just to set variables rather + # than running their programs. + libtool_install_magic="$magic" + + staticlibs= + future_libdirs= + current_libdirs= + for file in $files; do + + # Do each installation. + case $file in + *.$libext) + # Do the static libraries later. + func_append staticlibs " $file" + ;; + + *.la) + func_resolve_sysroot "$file" + file=$func_resolve_sysroot_result + + # Check to see that this really is a libtool archive. + func_lalib_unsafe_p "$file" \ + || func_fatal_help "\`$file' is not a valid libtool archive" + + library_names= + old_library= + relink_command= + func_source "$file" + + # Add the libdir to current_libdirs if it is the destination. + if test "X$destdir" = "X$libdir"; then + case "$current_libdirs " in + *" $libdir "*) ;; + *) func_append current_libdirs " $libdir" ;; + esac + else + # Note the libdir as a future libdir. + case "$future_libdirs " in + *" $libdir "*) ;; + *) func_append future_libdirs " $libdir" ;; + esac + fi + + func_dirname "$file" "/" "" + dir="$func_dirname_result" + func_append dir "$objdir" + + if test -n "$relink_command"; then + # Determine the prefix the user has applied to our future dir. + inst_prefix_dir=`$ECHO "$destdir" | $SED -e "s%$libdir\$%%"` + + # Don't allow the user to place us outside of our expected + # location b/c this prevents finding dependent libraries that + # are installed to the same prefix. + # At present, this check doesn't affect windows .dll's that + # are installed into $libdir/../bin (currently, that works fine) + # but it's something to keep an eye on. + test "$inst_prefix_dir" = "$destdir" && \ + func_fatal_error "error: cannot install \`$file' to a directory not ending in $libdir" + + if test -n "$inst_prefix_dir"; then + # Stick the inst_prefix_dir data into the link command. + relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"` + else + relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%%"` + fi + + func_warning "relinking \`$file'" + func_show_eval "$relink_command" \ + 'func_fatal_error "error: relink \`$file'\'' with the above command before installing it"' + fi + + # See the names of the shared library. + set dummy $library_names; shift + if test -n "$1"; then + realname="$1" + shift + + srcname="$realname" + test -n "$relink_command" && srcname="$realname"T + + # Install the shared library and build the symlinks. + func_show_eval "$install_shared_prog $dir/$srcname $destdir/$realname" \ + 'exit $?' + tstripme="$stripme" + case $host_os in + cygwin* | mingw* | pw32* | cegcc*) + case $realname in + *.dll.a) + tstripme="" + ;; + esac + ;; + esac + if test -n "$tstripme" && test -n "$striplib"; then + func_show_eval "$striplib $destdir/$realname" 'exit $?' + fi + + if test "$#" -gt 0; then + # Delete the old symlinks, and create new ones. + # Try `ln -sf' first, because the `ln' binary might depend on + # the symlink we replace! Solaris /bin/ln does not understand -f, + # so we also need to try rm && ln -s. + for linkname + do + test "$linkname" != "$realname" \ + && func_show_eval "(cd $destdir && { $LN_S -f $realname $linkname || { $RM $linkname && $LN_S $realname $linkname; }; })" + done + fi + + # Do each command in the postinstall commands. + lib="$destdir/$realname" + func_execute_cmds "$postinstall_cmds" 'exit $?' + fi + + # Install the pseudo-library for information purposes. + func_basename "$file" + name="$func_basename_result" + instname="$dir/$name"i + func_show_eval "$install_prog $instname $destdir/$name" 'exit $?' + + # Maybe install the static library, too. + test -n "$old_library" && func_append staticlibs " $dir/$old_library" + ;; + + *.lo) + # Install (i.e. copy) a libtool object. + + # Figure out destination file name, if it wasn't already specified. + if test -n "$destname"; then + destfile="$destdir/$destname" + else + func_basename "$file" + destfile="$func_basename_result" + destfile="$destdir/$destfile" + fi + + # Deduce the name of the destination old-style object file. + case $destfile in + *.lo) + func_lo2o "$destfile" + staticdest=$func_lo2o_result + ;; + *.$objext) + staticdest="$destfile" + destfile= + ;; + *) + func_fatal_help "cannot copy a libtool object to \`$destfile'" + ;; + esac + + # Install the libtool object if requested. + test -n "$destfile" && \ + func_show_eval "$install_prog $file $destfile" 'exit $?' + + # Install the old object if enabled. + if test "$build_old_libs" = yes; then + # Deduce the name of the old-style object file. + func_lo2o "$file" + staticobj=$func_lo2o_result + func_show_eval "$install_prog \$staticobj \$staticdest" 'exit $?' + fi + exit $EXIT_SUCCESS + ;; + + *) + # Figure out destination file name, if it wasn't already specified. + if test -n "$destname"; then + destfile="$destdir/$destname" + else + func_basename "$file" + destfile="$func_basename_result" + destfile="$destdir/$destfile" + fi + + # If the file is missing, and there is a .exe on the end, strip it + # because it is most likely a libtool script we actually want to + # install + stripped_ext="" + case $file in + *.exe) + if test ! -f "$file"; then + func_stripname '' '.exe' "$file" + file=$func_stripname_result + stripped_ext=".exe" + fi + ;; + esac + + # Do a test to see if this is really a libtool program. + case $host in + *cygwin* | *mingw*) + if func_ltwrapper_executable_p "$file"; then + func_ltwrapper_scriptname "$file" + wrapper=$func_ltwrapper_scriptname_result + else + func_stripname '' '.exe' "$file" + wrapper=$func_stripname_result + fi + ;; + *) + wrapper=$file + ;; + esac + if func_ltwrapper_script_p "$wrapper"; then + notinst_deplibs= + relink_command= + + func_source "$wrapper" + + # Check the variables that should have been set. + test -z "$generated_by_libtool_version" && \ + func_fatal_error "invalid libtool wrapper script \`$wrapper'" + + finalize=yes + for lib in $notinst_deplibs; do + # Check to see that each library is installed. + libdir= + if test -f "$lib"; then + func_source "$lib" + fi + libfile="$libdir/"`$ECHO "$lib" | $SED 's%^.*/%%g'` ### testsuite: skip nested quoting test + if test -n "$libdir" && test ! -f "$libfile"; then + func_warning "\`$lib' has not been installed in \`$libdir'" + finalize=no + fi + done + + relink_command= + func_source "$wrapper" + + outputname= + if test "$fast_install" = no && test -n "$relink_command"; then + $opt_dry_run || { + if test "$finalize" = yes; then + tmpdir=`func_mktempdir` + func_basename "$file$stripped_ext" + file="$func_basename_result" + outputname="$tmpdir/$file" + # Replace the output file specification. + relink_command=`$ECHO "$relink_command" | $SED 's%@OUTPUT@%'"$outputname"'%g'` + + $opt_silent || { + func_quote_for_expand "$relink_command" + eval "func_echo $func_quote_for_expand_result" + } + if eval "$relink_command"; then : + else + func_error "error: relink \`$file' with the above command before installing it" + $opt_dry_run || ${RM}r "$tmpdir" + continue + fi + file="$outputname" + else + func_warning "cannot relink \`$file'" + fi + } + else + # Install the binary that we compiled earlier. + file=`$ECHO "$file$stripped_ext" | $SED "s%\([^/]*\)$%$objdir/\1%"` + fi + fi + + # remove .exe since cygwin /usr/bin/install will append another + # one anyway + case $install_prog,$host in + */usr/bin/install*,*cygwin*) + case $file:$destfile in + *.exe:*.exe) + # this is ok + ;; + *.exe:*) + destfile=$destfile.exe + ;; + *:*.exe) + func_stripname '' '.exe' "$destfile" + destfile=$func_stripname_result + ;; + esac + ;; + esac + func_show_eval "$install_prog\$stripme \$file \$destfile" 'exit $?' + $opt_dry_run || if test -n "$outputname"; then + ${RM}r "$tmpdir" + fi + ;; + esac + done + + for file in $staticlibs; do + func_basename "$file" + name="$func_basename_result" + + # Set up the ranlib parameters. + oldlib="$destdir/$name" + func_to_tool_file "$oldlib" func_convert_file_msys_to_w32 + tool_oldlib=$func_to_tool_file_result + + func_show_eval "$install_prog \$file \$oldlib" 'exit $?' + + if test -n "$stripme" && test -n "$old_striplib"; then + func_show_eval "$old_striplib $tool_oldlib" 'exit $?' + fi + + # Do each command in the postinstall commands. + func_execute_cmds "$old_postinstall_cmds" 'exit $?' + done + + test -n "$future_libdirs" && \ + func_warning "remember to run \`$progname --finish$future_libdirs'" + + if test -n "$current_libdirs"; then + # Maybe just do a dry run. + $opt_dry_run && current_libdirs=" -n$current_libdirs" + exec_cmd='$SHELL $progpath $preserve_args --finish$current_libdirs' + else + exit $EXIT_SUCCESS + fi +} + +test "$opt_mode" = install && func_mode_install ${1+"$@"} + + +# func_generate_dlsyms outputname originator pic_p +# Extract symbols from dlprefiles and create ${outputname}S.o with +# a dlpreopen symbol table. +func_generate_dlsyms () +{ + $opt_debug + my_outputname="$1" + my_originator="$2" + my_pic_p="${3-no}" + my_prefix=`$ECHO "$my_originator" | sed 's%[^a-zA-Z0-9]%_%g'` + my_dlsyms= + + if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then + if test -n "$NM" && test -n "$global_symbol_pipe"; then + my_dlsyms="${my_outputname}S.c" + else + func_error "not configured to extract global symbols from dlpreopened files" + fi + fi + + if test -n "$my_dlsyms"; then + case $my_dlsyms in + "") ;; + *.c) + # Discover the nlist of each of the dlfiles. + nlist="$output_objdir/${my_outputname}.nm" + + func_show_eval "$RM $nlist ${nlist}S ${nlist}T" + + # Parse the name list into a source file. + func_verbose "creating $output_objdir/$my_dlsyms" + + $opt_dry_run || $ECHO > "$output_objdir/$my_dlsyms" "\ +/* $my_dlsyms - symbol resolution table for \`$my_outputname' dlsym emulation. */ +/* Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION */ + +#ifdef __cplusplus +extern \"C\" { +#endif + +#if defined(__GNUC__) && (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 4)) || (__GNUC__ > 4)) +#pragma GCC diagnostic ignored \"-Wstrict-prototypes\" +#endif + +/* Keep this code in sync between libtool.m4, ltmain, lt_system.h, and tests. */ +#if defined(_WIN32) || defined(__CYGWIN__) || defined(_WIN32_WCE) +/* DATA imports from DLLs on WIN32 con't be const, because runtime + relocations are performed -- see ld's documentation on pseudo-relocs. */ +# define LT_DLSYM_CONST +#elif defined(__osf__) +/* This system does not cope well with relocations in const data. */ +# define LT_DLSYM_CONST +#else +# define LT_DLSYM_CONST const +#endif + +/* External symbol declarations for the compiler. */\ +" + + if test "$dlself" = yes; then + func_verbose "generating symbol list for \`$output'" + + $opt_dry_run || echo ': @PROGRAM@ ' > "$nlist" + + # Add our own program objects to the symbol list. + progfiles=`$ECHO "$objs$old_deplibs" | $SP2NL | $SED "$lo2o" | $NL2SP` + for progfile in $progfiles; do + func_to_tool_file "$progfile" func_convert_file_msys_to_w32 + func_verbose "extracting global C symbols from \`$func_to_tool_file_result'" + $opt_dry_run || eval "$NM $func_to_tool_file_result | $global_symbol_pipe >> '$nlist'" + done + + if test -n "$exclude_expsyms"; then + $opt_dry_run || { + eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T' + eval '$MV "$nlist"T "$nlist"' + } + fi + + if test -n "$export_symbols_regex"; then + $opt_dry_run || { + eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T' + eval '$MV "$nlist"T "$nlist"' + } + fi + + # Prepare the list of exported symbols + if test -z "$export_symbols"; then + export_symbols="$output_objdir/$outputname.exp" + $opt_dry_run || { + $RM $export_symbols + eval "${SED} -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"' + case $host in + *cygwin* | *mingw* | *cegcc* ) + eval "echo EXPORTS "'> "$output_objdir/$outputname.def"' + eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"' + ;; + esac + } + else + $opt_dry_run || { + eval "${SED} -e 's/\([].[*^$]\)/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"' + eval '$GREP -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T' + eval '$MV "$nlist"T "$nlist"' + case $host in + *cygwin* | *mingw* | *cegcc* ) + eval "echo EXPORTS "'> "$output_objdir/$outputname.def"' + eval 'cat "$nlist" >> "$output_objdir/$outputname.def"' + ;; + esac + } + fi + fi + + for dlprefile in $dlprefiles; do + func_verbose "extracting global C symbols from \`$dlprefile'" + func_basename "$dlprefile" + name="$func_basename_result" + case $host in + *cygwin* | *mingw* | *cegcc* ) + # if an import library, we need to obtain dlname + if func_win32_import_lib_p "$dlprefile"; then + func_tr_sh "$dlprefile" + eval "curr_lafile=\$libfile_$func_tr_sh_result" + dlprefile_dlbasename="" + if test -n "$curr_lafile" && func_lalib_p "$curr_lafile"; then + # Use subshell, to avoid clobbering current variable values + dlprefile_dlname=`source "$curr_lafile" && echo "$dlname"` + if test -n "$dlprefile_dlname" ; then + func_basename "$dlprefile_dlname" + dlprefile_dlbasename="$func_basename_result" + else + # no lafile. user explicitly requested -dlpreopen . + $sharedlib_from_linklib_cmd "$dlprefile" + dlprefile_dlbasename=$sharedlib_from_linklib_result + fi + fi + $opt_dry_run || { + if test -n "$dlprefile_dlbasename" ; then + eval '$ECHO ": $dlprefile_dlbasename" >> "$nlist"' + else + func_warning "Could not compute DLL name from $name" + eval '$ECHO ": $name " >> "$nlist"' + fi + func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32 + eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe | + $SED -e '/I __imp/d' -e 's/I __nm_/D /;s/_nm__//' >> '$nlist'" + } + else # not an import lib + $opt_dry_run || { + eval '$ECHO ": $name " >> "$nlist"' + func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32 + eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'" + } + fi + ;; + *) + $opt_dry_run || { + eval '$ECHO ": $name " >> "$nlist"' + func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32 + eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'" + } + ;; + esac + done + + $opt_dry_run || { + # Make sure we have at least an empty file. + test -f "$nlist" || : > "$nlist" + + if test -n "$exclude_expsyms"; then + $EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T + $MV "$nlist"T "$nlist" + fi + + # Try sorting and uniquifying the output. + if $GREP -v "^: " < "$nlist" | + if sort -k 3 /dev/null 2>&1; then + sort -k 3 + else + sort +2 + fi | + uniq > "$nlist"S; then + : + else + $GREP -v "^: " < "$nlist" > "$nlist"S + fi + + if test -f "$nlist"S; then + eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$my_dlsyms"' + else + echo '/* NONE */' >> "$output_objdir/$my_dlsyms" + fi + + echo >> "$output_objdir/$my_dlsyms" "\ + +/* The mapping between symbol names and symbols. */ +typedef struct { + const char *name; + void *address; +} lt_dlsymlist; +extern LT_DLSYM_CONST lt_dlsymlist +lt_${my_prefix}_LTX_preloaded_symbols[]; +LT_DLSYM_CONST lt_dlsymlist +lt_${my_prefix}_LTX_preloaded_symbols[] = +{\ + { \"$my_originator\", (void *) 0 }," + + case $need_lib_prefix in + no) + eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$my_dlsyms" + ;; + *) + eval "$global_symbol_to_c_name_address_lib_prefix" < "$nlist" >> "$output_objdir/$my_dlsyms" + ;; + esac + echo >> "$output_objdir/$my_dlsyms" "\ + {0, (void *) 0} +}; + +/* This works around a problem in FreeBSD linker */ +#ifdef FREEBSD_WORKAROUND +static const void *lt_preloaded_setup() { + return lt_${my_prefix}_LTX_preloaded_symbols; +} +#endif + +#ifdef __cplusplus +} +#endif\ +" + } # !$opt_dry_run + + pic_flag_for_symtable= + case "$compile_command " in + *" -static "*) ;; + *) + case $host in + # compiling the symbol table file with pic_flag works around + # a FreeBSD bug that causes programs to crash when -lm is + # linked before any other PIC object. But we must not use + # pic_flag when linking with -static. The problem exists in + # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1. + *-*-freebsd2.*|*-*-freebsd3.0*|*-*-freebsdelf3.0*) + pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND" ;; + *-*-hpux*) + pic_flag_for_symtable=" $pic_flag" ;; + *) + if test "X$my_pic_p" != Xno; then + pic_flag_for_symtable=" $pic_flag" + fi + ;; + esac + ;; + esac + symtab_cflags= + for arg in $LTCFLAGS; do + case $arg in + -pie | -fpie | -fPIE) ;; + *) func_append symtab_cflags " $arg" ;; + esac + done + + # Now compile the dynamic symbol file. + func_show_eval '(cd $output_objdir && $LTCC$symtab_cflags -c$no_builtin_flag$pic_flag_for_symtable "$my_dlsyms")' 'exit $?' + + # Clean up the generated files. + func_show_eval '$RM "$output_objdir/$my_dlsyms" "$nlist" "${nlist}S" "${nlist}T"' + + # Transform the symbol file into the correct name. + symfileobj="$output_objdir/${my_outputname}S.$objext" + case $host in + *cygwin* | *mingw* | *cegcc* ) + if test -f "$output_objdir/$my_outputname.def"; then + compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"` + finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"` + else + compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"` + finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"` + fi + ;; + *) + compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"` + finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"` + ;; + esac + ;; + *) + func_fatal_error "unknown suffix for \`$my_dlsyms'" + ;; + esac + else + # We keep going just in case the user didn't refer to + # lt_preloaded_symbols. The linker will fail if global_symbol_pipe + # really was required. + + # Nullify the symbol file. + compile_command=`$ECHO "$compile_command" | $SED "s% @SYMFILE@%%"` + finalize_command=`$ECHO "$finalize_command" | $SED "s% @SYMFILE@%%"` + fi +} + +# func_win32_libid arg +# return the library type of file 'arg' +# +# Need a lot of goo to handle *both* DLLs and import libs +# Has to be a shell function in order to 'eat' the argument +# that is supplied when $file_magic_command is called. +# Despite the name, also deal with 64 bit binaries. +func_win32_libid () +{ + $opt_debug + win32_libid_type="unknown" + win32_fileres=`file -L $1 2>/dev/null` + case $win32_fileres in + *ar\ archive\ import\ library*) # definitely import + win32_libid_type="x86 archive import" + ;; + *ar\ archive*) # could be an import, or static + # Keep the egrep pattern in sync with the one in _LT_CHECK_MAGIC_METHOD. + if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null | + $EGREP 'file format (pei*-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)' >/dev/null; then + func_to_tool_file "$1" func_convert_file_msys_to_w32 + win32_nmres=`eval $NM -f posix -A \"$func_to_tool_file_result\" | + $SED -n -e ' + 1,100{ + / I /{ + s,.*,import, + p + q + } + }'` + case $win32_nmres in + import*) win32_libid_type="x86 archive import";; + *) win32_libid_type="x86 archive static";; + esac + fi + ;; + *DLL*) + win32_libid_type="x86 DLL" + ;; + *executable*) # but shell scripts are "executable" too... + case $win32_fileres in + *MS\ Windows\ PE\ Intel*) + win32_libid_type="x86 DLL" + ;; + esac + ;; + esac + $ECHO "$win32_libid_type" +} + +# func_cygming_dll_for_implib ARG +# +# Platform-specific function to extract the +# name of the DLL associated with the specified +# import library ARG. +# Invoked by eval'ing the libtool variable +# $sharedlib_from_linklib_cmd +# Result is available in the variable +# $sharedlib_from_linklib_result +func_cygming_dll_for_implib () +{ + $opt_debug + sharedlib_from_linklib_result=`$DLLTOOL --identify-strict --identify "$1"` +} + +# func_cygming_dll_for_implib_fallback_core SECTION_NAME LIBNAMEs +# +# The is the core of a fallback implementation of a +# platform-specific function to extract the name of the +# DLL associated with the specified import library LIBNAME. +# +# SECTION_NAME is either .idata$6 or .idata$7, depending +# on the platform and compiler that created the implib. +# +# Echos the name of the DLL associated with the +# specified import library. +func_cygming_dll_for_implib_fallback_core () +{ + $opt_debug + match_literal=`$ECHO "$1" | $SED "$sed_make_literal_regex"` + $OBJDUMP -s --section "$1" "$2" 2>/dev/null | + $SED '/^Contents of section '"$match_literal"':/{ + # Place marker at beginning of archive member dllname section + s/.*/====MARK====/ + p + d + } + # These lines can sometimes be longer than 43 characters, but + # are always uninteresting + /:[ ]*file format pe[i]\{,1\}-/d + /^In archive [^:]*:/d + # Ensure marker is printed + /^====MARK====/p + # Remove all lines with less than 43 characters + /^.\{43\}/!d + # From remaining lines, remove first 43 characters + s/^.\{43\}//' | + $SED -n ' + # Join marker and all lines until next marker into a single line + /^====MARK====/ b para + H + $ b para + b + :para + x + s/\n//g + # Remove the marker + s/^====MARK====// + # Remove trailing dots and whitespace + s/[\. \t]*$// + # Print + /./p' | + # we now have a list, one entry per line, of the stringified + # contents of the appropriate section of all members of the + # archive which possess that section. Heuristic: eliminate + # all those which have a first or second character that is + # a '.' (that is, objdump's representation of an unprintable + # character.) This should work for all archives with less than + # 0x302f exports -- but will fail for DLLs whose name actually + # begins with a literal '.' or a single character followed by + # a '.'. + # + # Of those that remain, print the first one. + $SED -e '/^\./d;/^.\./d;q' +} + +# func_cygming_gnu_implib_p ARG +# This predicate returns with zero status (TRUE) if +# ARG is a GNU/binutils-style import library. Returns +# with nonzero status (FALSE) otherwise. +func_cygming_gnu_implib_p () +{ + $opt_debug + func_to_tool_file "$1" func_convert_file_msys_to_w32 + func_cygming_gnu_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $EGREP ' (_head_[A-Za-z0-9_]+_[ad]l*|[A-Za-z0-9_]+_[ad]l*_iname)$'` + test -n "$func_cygming_gnu_implib_tmp" +} + +# func_cygming_ms_implib_p ARG +# This predicate returns with zero status (TRUE) if +# ARG is an MS-style import library. Returns +# with nonzero status (FALSE) otherwise. +func_cygming_ms_implib_p () +{ + $opt_debug + func_to_tool_file "$1" func_convert_file_msys_to_w32 + func_cygming_ms_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $GREP '_NULL_IMPORT_DESCRIPTOR'` + test -n "$func_cygming_ms_implib_tmp" +} + +# func_cygming_dll_for_implib_fallback ARG +# Platform-specific function to extract the +# name of the DLL associated with the specified +# import library ARG. +# +# This fallback implementation is for use when $DLLTOOL +# does not support the --identify-strict option. +# Invoked by eval'ing the libtool variable +# $sharedlib_from_linklib_cmd +# Result is available in the variable +# $sharedlib_from_linklib_result +func_cygming_dll_for_implib_fallback () +{ + $opt_debug + if func_cygming_gnu_implib_p "$1" ; then + # binutils import library + sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$7' "$1"` + elif func_cygming_ms_implib_p "$1" ; then + # ms-generated import library + sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$6' "$1"` + else + # unknown + sharedlib_from_linklib_result="" + fi +} + + +# func_extract_an_archive dir oldlib +func_extract_an_archive () +{ + $opt_debug + f_ex_an_ar_dir="$1"; shift + f_ex_an_ar_oldlib="$1" + if test "$lock_old_archive_extraction" = yes; then + lockfile=$f_ex_an_ar_oldlib.lock + until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do + func_echo "Waiting for $lockfile to be removed" + sleep 2 + done + fi + func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" \ + 'stat=$?; rm -f "$lockfile"; exit $stat' + if test "$lock_old_archive_extraction" = yes; then + $opt_dry_run || rm -f "$lockfile" + fi + if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then + : + else + func_fatal_error "object name conflicts in archive: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib" + fi +} + + +# func_extract_archives gentop oldlib ... +func_extract_archives () +{ + $opt_debug + my_gentop="$1"; shift + my_oldlibs=${1+"$@"} + my_oldobjs="" + my_xlib="" + my_xabs="" + my_xdir="" + + for my_xlib in $my_oldlibs; do + # Extract the objects. + case $my_xlib in + [\\/]* | [A-Za-z]:[\\/]*) my_xabs="$my_xlib" ;; + *) my_xabs=`pwd`"/$my_xlib" ;; + esac + func_basename "$my_xlib" + my_xlib="$func_basename_result" + my_xlib_u=$my_xlib + while :; do + case " $extracted_archives " in + *" $my_xlib_u "*) + func_arith $extracted_serial + 1 + extracted_serial=$func_arith_result + my_xlib_u=lt$extracted_serial-$my_xlib ;; + *) break ;; + esac + done + extracted_archives="$extracted_archives $my_xlib_u" + my_xdir="$my_gentop/$my_xlib_u" + + func_mkdir_p "$my_xdir" + + case $host in + *-darwin*) + func_verbose "Extracting $my_xabs" + # Do not bother doing anything if just a dry run + $opt_dry_run || { + darwin_orig_dir=`pwd` + cd $my_xdir || exit $? + darwin_archive=$my_xabs + darwin_curdir=`pwd` + darwin_base_archive=`basename "$darwin_archive"` + darwin_arches=`$LIPO -info "$darwin_archive" 2>/dev/null | $GREP Architectures 2>/dev/null || true` + if test -n "$darwin_arches"; then + darwin_arches=`$ECHO "$darwin_arches" | $SED -e 's/.*are://'` + darwin_arch= + func_verbose "$darwin_base_archive has multiple architectures $darwin_arches" + for darwin_arch in $darwin_arches ; do + func_mkdir_p "unfat-$$/${darwin_base_archive}-${darwin_arch}" + $LIPO -thin $darwin_arch -output "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" "${darwin_archive}" + cd "unfat-$$/${darwin_base_archive}-${darwin_arch}" + func_extract_an_archive "`pwd`" "${darwin_base_archive}" + cd "$darwin_curdir" + $RM "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" + done # $darwin_arches + ## Okay now we've a bunch of thin objects, gotta fatten them up :) + darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print | $SED -e "$basename" | sort -u` + darwin_file= + darwin_files= + for darwin_file in $darwin_filelist; do + darwin_files=`find unfat-$$ -name $darwin_file -print | sort | $NL2SP` + $LIPO -create -output "$darwin_file" $darwin_files + done # $darwin_filelist + $RM -rf unfat-$$ + cd "$darwin_orig_dir" + else + cd $darwin_orig_dir + func_extract_an_archive "$my_xdir" "$my_xabs" + fi # $darwin_arches + } # !$opt_dry_run + ;; + *) + func_extract_an_archive "$my_xdir" "$my_xabs" + ;; + esac + my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | sort | $NL2SP` + done + + func_extract_archives_result="$my_oldobjs" +} + + +# func_emit_wrapper [arg=no] +# +# Emit a libtool wrapper script on stdout. +# Don't directly open a file because we may want to +# incorporate the script contents within a cygwin/mingw +# wrapper executable. Must ONLY be called from within +# func_mode_link because it depends on a number of variables +# set therein. +# +# ARG is the value that the WRAPPER_SCRIPT_BELONGS_IN_OBJDIR +# variable will take. If 'yes', then the emitted script +# will assume that the directory in which it is stored is +# the $objdir directory. This is a cygwin/mingw-specific +# behavior. +func_emit_wrapper () +{ + func_emit_wrapper_arg1=${1-no} + + $ECHO "\ +#! $SHELL + +# $output - temporary wrapper script for $objdir/$outputname +# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION +# +# The $output program cannot be directly executed until all the libtool +# libraries that it depends on are installed. +# +# This wrapper script should never be moved out of the build directory. +# If it is, it will not operate correctly. + +# Sed substitution that helps us do robust quoting. It backslashifies +# metacharacters that are still active within double-quoted strings. +sed_quote_subst='$sed_quote_subst' + +# Be Bourne compatible +if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then + emulate sh + NULLCMD=: + # Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which + # is contrary to our usage. Disable this feature. + alias -g '\${1+\"\$@\"}'='\"\$@\"' + setopt NO_GLOB_SUBST +else + case \`(set -o) 2>/dev/null\` in *posix*) set -o posix;; esac +fi +BIN_SH=xpg4; export BIN_SH # for Tru64 +DUALCASE=1; export DUALCASE # for MKS sh + +# The HP-UX ksh and POSIX shell print the target directory to stdout +# if CDPATH is set. +(unset CDPATH) >/dev/null 2>&1 && unset CDPATH + +relink_command=\"$relink_command\" + +# This environment variable determines our operation mode. +if test \"\$libtool_install_magic\" = \"$magic\"; then + # install mode needs the following variables: + generated_by_libtool_version='$macro_version' + notinst_deplibs='$notinst_deplibs' +else + # When we are sourced in execute mode, \$file and \$ECHO are already set. + if test \"\$libtool_execute_magic\" != \"$magic\"; then + file=\"\$0\"" + + qECHO=`$ECHO "$ECHO" | $SED "$sed_quote_subst"` + $ECHO "\ + +# A function that is used when there is no print builtin or printf. +func_fallback_echo () +{ + eval 'cat <<_LTECHO_EOF +\$1 +_LTECHO_EOF' +} + ECHO=\"$qECHO\" + fi + +# Very basic option parsing. These options are (a) specific to +# the libtool wrapper, (b) are identical between the wrapper +# /script/ and the wrapper /executable/ which is used only on +# windows platforms, and (c) all begin with the string "--lt-" +# (application programs are unlikely to have options which match +# this pattern). +# +# There are only two supported options: --lt-debug and +# --lt-dump-script. There is, deliberately, no --lt-help. +# +# The first argument to this parsing function should be the +# script's $0 value, followed by "$@". +lt_option_debug= +func_parse_lt_options () +{ + lt_script_arg0=\$0 + shift + for lt_opt + do + case \"\$lt_opt\" in + --lt-debug) lt_option_debug=1 ;; + --lt-dump-script) + lt_dump_D=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%/[^/]*$%%'\` + test \"X\$lt_dump_D\" = \"X\$lt_script_arg0\" && lt_dump_D=. + lt_dump_F=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%^.*/%%'\` + cat \"\$lt_dump_D/\$lt_dump_F\" + exit 0 + ;; + --lt-*) + \$ECHO \"Unrecognized --lt- option: '\$lt_opt'\" 1>&2 + exit 1 + ;; + esac + done + + # Print the debug banner immediately: + if test -n \"\$lt_option_debug\"; then + echo \"${outputname}:${output}:\${LINENO}: libtool wrapper (GNU $PACKAGE$TIMESTAMP) $VERSION\" 1>&2 + fi +} + +# Used when --lt-debug. Prints its arguments to stdout +# (redirection is the responsibility of the caller) +func_lt_dump_args () +{ + lt_dump_args_N=1; + for lt_arg + do + \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[\$lt_dump_args_N]: \$lt_arg\" + lt_dump_args_N=\`expr \$lt_dump_args_N + 1\` + done +} + +# Core function for launching the target application +func_exec_program_core () +{ +" + case $host in + # Backslashes separate directories on plain windows + *-*-mingw | *-*-os2* | *-cegcc*) + $ECHO "\ + if test -n \"\$lt_option_debug\"; then + \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[0]: \$progdir\\\\\$program\" 1>&2 + func_lt_dump_args \${1+\"\$@\"} 1>&2 + fi + exec \"\$progdir\\\\\$program\" \${1+\"\$@\"} +" + ;; + + *) + $ECHO "\ + if test -n \"\$lt_option_debug\"; then + \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[0]: \$progdir/\$program\" 1>&2 + func_lt_dump_args \${1+\"\$@\"} 1>&2 + fi + exec \"\$progdir/\$program\" \${1+\"\$@\"} +" + ;; + esac + $ECHO "\ + \$ECHO \"\$0: cannot exec \$program \$*\" 1>&2 + exit 1 +} + +# A function to encapsulate launching the target application +# Strips options in the --lt-* namespace from \$@ and +# launches target application with the remaining arguments. +func_exec_program () +{ + case \" \$* \" in + *\\ --lt-*) + for lt_wr_arg + do + case \$lt_wr_arg in + --lt-*) ;; + *) set x \"\$@\" \"\$lt_wr_arg\"; shift;; + esac + shift + done ;; + esac + func_exec_program_core \${1+\"\$@\"} +} + + # Parse options + func_parse_lt_options \"\$0\" \${1+\"\$@\"} + + # Find the directory that this script lives in. + thisdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*$%%'\` + test \"x\$thisdir\" = \"x\$file\" && thisdir=. + + # Follow symbolic links until we get to the real thisdir. + file=\`ls -ld \"\$file\" | $SED -n 's/.*-> //p'\` + while test -n \"\$file\"; do + destdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*\$%%'\` + + # If there was a directory component, then change thisdir. + if test \"x\$destdir\" != \"x\$file\"; then + case \"\$destdir\" in + [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;; + *) thisdir=\"\$thisdir/\$destdir\" ;; + esac + fi + + file=\`\$ECHO \"\$file\" | $SED 's%^.*/%%'\` + file=\`ls -ld \"\$thisdir/\$file\" | $SED -n 's/.*-> //p'\` + done + + # Usually 'no', except on cygwin/mingw when embedded into + # the cwrapper. + WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_arg1 + if test \"\$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\" = \"yes\"; then + # special case for '.' + if test \"\$thisdir\" = \".\"; then + thisdir=\`pwd\` + fi + # remove .libs from thisdir + case \"\$thisdir\" in + *[\\\\/]$objdir ) thisdir=\`\$ECHO \"\$thisdir\" | $SED 's%[\\\\/][^\\\\/]*$%%'\` ;; + $objdir ) thisdir=. ;; + esac + fi + + # Try to get the absolute directory name. + absdir=\`cd \"\$thisdir\" && pwd\` + test -n \"\$absdir\" && thisdir=\"\$absdir\" +" + + if test "$fast_install" = yes; then + $ECHO "\ + program=lt-'$outputname'$exeext + progdir=\"\$thisdir/$objdir\" + + if test ! -f \"\$progdir/\$program\" || + { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\ + test \"X\$file\" != \"X\$progdir/\$program\"; }; then + + file=\"\$\$-\$program\" + + if test ! -d \"\$progdir\"; then + $MKDIR \"\$progdir\" + else + $RM \"\$progdir/\$file\" + fi" + + $ECHO "\ + + # relink executable if necessary + if test -n \"\$relink_command\"; then + if relink_command_output=\`eval \$relink_command 2>&1\`; then : + else + $ECHO \"\$relink_command_output\" >&2 + $RM \"\$progdir/\$file\" + exit 1 + fi + fi + + $MV \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null || + { $RM \"\$progdir/\$program\"; + $MV \"\$progdir/\$file\" \"\$progdir/\$program\"; } + $RM \"\$progdir/\$file\" + fi" + else + $ECHO "\ + program='$outputname' + progdir=\"\$thisdir/$objdir\" +" + fi + + $ECHO "\ + + if test -f \"\$progdir/\$program\"; then" + + # fixup the dll searchpath if we need to. + # + # Fix the DLL searchpath if we need to. Do this before prepending + # to shlibpath, because on Windows, both are PATH and uninstalled + # libraries must come first. + if test -n "$dllsearchpath"; then + $ECHO "\ + # Add the dll search path components to the executable PATH + PATH=$dllsearchpath:\$PATH +" + fi + + # Export our shlibpath_var if we have one. + if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then + $ECHO "\ + # Add our own library path to $shlibpath_var + $shlibpath_var=\"$temp_rpath\$$shlibpath_var\" + + # Some systems cannot cope with colon-terminated $shlibpath_var + # The second colon is a workaround for a bug in BeOS R4 sed + $shlibpath_var=\`\$ECHO \"\$$shlibpath_var\" | $SED 's/::*\$//'\` + + export $shlibpath_var +" + fi + + $ECHO "\ + if test \"\$libtool_execute_magic\" != \"$magic\"; then + # Run the actual program with our arguments. + func_exec_program \${1+\"\$@\"} + fi + else + # The program doesn't exist. + \$ECHO \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2 + \$ECHO \"This script is just a wrapper for \$program.\" 1>&2 + \$ECHO \"See the $PACKAGE documentation for more information.\" 1>&2 + exit 1 + fi +fi\ +" +} + + +# func_emit_cwrapperexe_src +# emit the source code for a wrapper executable on stdout +# Must ONLY be called from within func_mode_link because +# it depends on a number of variable set therein. +func_emit_cwrapperexe_src () +{ + cat < +#include +#ifdef _MSC_VER +# include +# include +# include +#else +# include +# include +# ifdef __CYGWIN__ +# include +# endif +#endif +#include +#include +#include +#include +#include +#include +#include +#include + +/* declarations of non-ANSI functions */ +#if defined(__MINGW32__) +# ifdef __STRICT_ANSI__ +int _putenv (const char *); +# endif +#elif defined(__CYGWIN__) +# ifdef __STRICT_ANSI__ +char *realpath (const char *, char *); +int putenv (char *); +int setenv (const char *, const char *, int); +# endif +/* #elif defined (other platforms) ... */ +#endif + +/* portability defines, excluding path handling macros */ +#if defined(_MSC_VER) +# define setmode _setmode +# define stat _stat +# define chmod _chmod +# define getcwd _getcwd +# define putenv _putenv +# define S_IXUSR _S_IEXEC +# ifndef _INTPTR_T_DEFINED +# define _INTPTR_T_DEFINED +# define intptr_t int +# endif +#elif defined(__MINGW32__) +# define setmode _setmode +# define stat _stat +# define chmod _chmod +# define getcwd _getcwd +# define putenv _putenv +#elif defined(__CYGWIN__) +# define HAVE_SETENV +# define FOPEN_WB "wb" +/* #elif defined (other platforms) ... */ +#endif + +#if defined(PATH_MAX) +# define LT_PATHMAX PATH_MAX +#elif defined(MAXPATHLEN) +# define LT_PATHMAX MAXPATHLEN +#else +# define LT_PATHMAX 1024 +#endif + +#ifndef S_IXOTH +# define S_IXOTH 0 +#endif +#ifndef S_IXGRP +# define S_IXGRP 0 +#endif + +/* path handling portability macros */ +#ifndef DIR_SEPARATOR +# define DIR_SEPARATOR '/' +# define PATH_SEPARATOR ':' +#endif + +#if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \ + defined (__OS2__) +# define HAVE_DOS_BASED_FILE_SYSTEM +# define FOPEN_WB "wb" +# ifndef DIR_SEPARATOR_2 +# define DIR_SEPARATOR_2 '\\' +# endif +# ifndef PATH_SEPARATOR_2 +# define PATH_SEPARATOR_2 ';' +# endif +#endif + +#ifndef DIR_SEPARATOR_2 +# define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR) +#else /* DIR_SEPARATOR_2 */ +# define IS_DIR_SEPARATOR(ch) \ + (((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2)) +#endif /* DIR_SEPARATOR_2 */ + +#ifndef PATH_SEPARATOR_2 +# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR) +#else /* PATH_SEPARATOR_2 */ +# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2) +#endif /* PATH_SEPARATOR_2 */ + +#ifndef FOPEN_WB +# define FOPEN_WB "w" +#endif +#ifndef _O_BINARY +# define _O_BINARY 0 +#endif + +#define XMALLOC(type, num) ((type *) xmalloc ((num) * sizeof(type))) +#define XFREE(stale) do { \ + if (stale) { free ((void *) stale); stale = 0; } \ +} while (0) + +#if defined(LT_DEBUGWRAPPER) +static int lt_debug = 1; +#else +static int lt_debug = 0; +#endif + +const char *program_name = "libtool-wrapper"; /* in case xstrdup fails */ + +void *xmalloc (size_t num); +char *xstrdup (const char *string); +const char *base_name (const char *name); +char *find_executable (const char *wrapper); +char *chase_symlinks (const char *pathspec); +int make_executable (const char *path); +int check_executable (const char *path); +char *strendzap (char *str, const char *pat); +void lt_debugprintf (const char *file, int line, const char *fmt, ...); +void lt_fatal (const char *file, int line, const char *message, ...); +static const char *nonnull (const char *s); +static const char *nonempty (const char *s); +void lt_setenv (const char *name, const char *value); +char *lt_extend_str (const char *orig_value, const char *add, int to_end); +void lt_update_exe_path (const char *name, const char *value); +void lt_update_lib_path (const char *name, const char *value); +char **prepare_spawn (char **argv); +void lt_dump_script (FILE *f); +EOF + + cat <= 0) + && (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH))) + return 1; + else + return 0; +} + +int +make_executable (const char *path) +{ + int rval = 0; + struct stat st; + + lt_debugprintf (__FILE__, __LINE__, "(make_executable): %s\n", + nonempty (path)); + if ((!path) || (!*path)) + return 0; + + if (stat (path, &st) >= 0) + { + rval = chmod (path, st.st_mode | S_IXOTH | S_IXGRP | S_IXUSR); + } + return rval; +} + +/* Searches for the full path of the wrapper. Returns + newly allocated full path name if found, NULL otherwise + Does not chase symlinks, even on platforms that support them. +*/ +char * +find_executable (const char *wrapper) +{ + int has_slash = 0; + const char *p; + const char *p_next; + /* static buffer for getcwd */ + char tmp[LT_PATHMAX + 1]; + int tmp_len; + char *concat_name; + + lt_debugprintf (__FILE__, __LINE__, "(find_executable): %s\n", + nonempty (wrapper)); + + if ((wrapper == NULL) || (*wrapper == '\0')) + return NULL; + + /* Absolute path? */ +#if defined (HAVE_DOS_BASED_FILE_SYSTEM) + if (isalpha ((unsigned char) wrapper[0]) && wrapper[1] == ':') + { + concat_name = xstrdup (wrapper); + if (check_executable (concat_name)) + return concat_name; + XFREE (concat_name); + } + else + { +#endif + if (IS_DIR_SEPARATOR (wrapper[0])) + { + concat_name = xstrdup (wrapper); + if (check_executable (concat_name)) + return concat_name; + XFREE (concat_name); + } +#if defined (HAVE_DOS_BASED_FILE_SYSTEM) + } +#endif + + for (p = wrapper; *p; p++) + if (*p == '/') + { + has_slash = 1; + break; + } + if (!has_slash) + { + /* no slashes; search PATH */ + const char *path = getenv ("PATH"); + if (path != NULL) + { + for (p = path; *p; p = p_next) + { + const char *q; + size_t p_len; + for (q = p; *q; q++) + if (IS_PATH_SEPARATOR (*q)) + break; + p_len = q - p; + p_next = (*q == '\0' ? q : q + 1); + if (p_len == 0) + { + /* empty path: current directory */ + if (getcwd (tmp, LT_PATHMAX) == NULL) + lt_fatal (__FILE__, __LINE__, "getcwd failed: %s", + nonnull (strerror (errno))); + tmp_len = strlen (tmp); + concat_name = + XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1); + memcpy (concat_name, tmp, tmp_len); + concat_name[tmp_len] = '/'; + strcpy (concat_name + tmp_len + 1, wrapper); + } + else + { + concat_name = + XMALLOC (char, p_len + 1 + strlen (wrapper) + 1); + memcpy (concat_name, p, p_len); + concat_name[p_len] = '/'; + strcpy (concat_name + p_len + 1, wrapper); + } + if (check_executable (concat_name)) + return concat_name; + XFREE (concat_name); + } + } + /* not found in PATH; assume curdir */ + } + /* Relative path | not found in path: prepend cwd */ + if (getcwd (tmp, LT_PATHMAX) == NULL) + lt_fatal (__FILE__, __LINE__, "getcwd failed: %s", + nonnull (strerror (errno))); + tmp_len = strlen (tmp); + concat_name = XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1); + memcpy (concat_name, tmp, tmp_len); + concat_name[tmp_len] = '/'; + strcpy (concat_name + tmp_len + 1, wrapper); + + if (check_executable (concat_name)) + return concat_name; + XFREE (concat_name); + return NULL; +} + +char * +chase_symlinks (const char *pathspec) +{ +#ifndef S_ISLNK + return xstrdup (pathspec); +#else + char buf[LT_PATHMAX]; + struct stat s; + char *tmp_pathspec = xstrdup (pathspec); + char *p; + int has_symlinks = 0; + while (strlen (tmp_pathspec) && !has_symlinks) + { + lt_debugprintf (__FILE__, __LINE__, + "checking path component for symlinks: %s\n", + tmp_pathspec); + if (lstat (tmp_pathspec, &s) == 0) + { + if (S_ISLNK (s.st_mode) != 0) + { + has_symlinks = 1; + break; + } + + /* search backwards for last DIR_SEPARATOR */ + p = tmp_pathspec + strlen (tmp_pathspec) - 1; + while ((p > tmp_pathspec) && (!IS_DIR_SEPARATOR (*p))) + p--; + if ((p == tmp_pathspec) && (!IS_DIR_SEPARATOR (*p))) + { + /* no more DIR_SEPARATORS left */ + break; + } + *p = '\0'; + } + else + { + lt_fatal (__FILE__, __LINE__, + "error accessing file \"%s\": %s", + tmp_pathspec, nonnull (strerror (errno))); + } + } + XFREE (tmp_pathspec); + + if (!has_symlinks) + { + return xstrdup (pathspec); + } + + tmp_pathspec = realpath (pathspec, buf); + if (tmp_pathspec == 0) + { + lt_fatal (__FILE__, __LINE__, + "could not follow symlinks for %s", pathspec); + } + return xstrdup (tmp_pathspec); +#endif +} + +char * +strendzap (char *str, const char *pat) +{ + size_t len, patlen; + + assert (str != NULL); + assert (pat != NULL); + + len = strlen (str); + patlen = strlen (pat); + + if (patlen <= len) + { + str += len - patlen; + if (strcmp (str, pat) == 0) + *str = '\0'; + } + return str; +} + +void +lt_debugprintf (const char *file, int line, const char *fmt, ...) +{ + va_list args; + if (lt_debug) + { + (void) fprintf (stderr, "%s:%s:%d: ", program_name, file, line); + va_start (args, fmt); + (void) vfprintf (stderr, fmt, args); + va_end (args); + } +} + +static void +lt_error_core (int exit_status, const char *file, + int line, const char *mode, + const char *message, va_list ap) +{ + fprintf (stderr, "%s:%s:%d: %s: ", program_name, file, line, mode); + vfprintf (stderr, message, ap); + fprintf (stderr, ".\n"); + + if (exit_status >= 0) + exit (exit_status); +} + +void +lt_fatal (const char *file, int line, const char *message, ...) +{ + va_list ap; + va_start (ap, message); + lt_error_core (EXIT_FAILURE, file, line, "FATAL", message, ap); + va_end (ap); +} + +static const char * +nonnull (const char *s) +{ + return s ? s : "(null)"; +} + +static const char * +nonempty (const char *s) +{ + return (s && !*s) ? "(empty)" : nonnull (s); +} + +void +lt_setenv (const char *name, const char *value) +{ + lt_debugprintf (__FILE__, __LINE__, + "(lt_setenv) setting '%s' to '%s'\n", + nonnull (name), nonnull (value)); + { +#ifdef HAVE_SETENV + /* always make a copy, for consistency with !HAVE_SETENV */ + char *str = xstrdup (value); + setenv (name, str, 1); +#else + int len = strlen (name) + 1 + strlen (value) + 1; + char *str = XMALLOC (char, len); + sprintf (str, "%s=%s", name, value); + if (putenv (str) != EXIT_SUCCESS) + { + XFREE (str); + } +#endif + } +} + +char * +lt_extend_str (const char *orig_value, const char *add, int to_end) +{ + char *new_value; + if (orig_value && *orig_value) + { + int orig_value_len = strlen (orig_value); + int add_len = strlen (add); + new_value = XMALLOC (char, add_len + orig_value_len + 1); + if (to_end) + { + strcpy (new_value, orig_value); + strcpy (new_value + orig_value_len, add); + } + else + { + strcpy (new_value, add); + strcpy (new_value + add_len, orig_value); + } + } + else + { + new_value = xstrdup (add); + } + return new_value; +} + +void +lt_update_exe_path (const char *name, const char *value) +{ + lt_debugprintf (__FILE__, __LINE__, + "(lt_update_exe_path) modifying '%s' by prepending '%s'\n", + nonnull (name), nonnull (value)); + + if (name && *name && value && *value) + { + char *new_value = lt_extend_str (getenv (name), value, 0); + /* some systems can't cope with a ':'-terminated path #' */ + int len = strlen (new_value); + while (((len = strlen (new_value)) > 0) && IS_PATH_SEPARATOR (new_value[len-1])) + { + new_value[len-1] = '\0'; + } + lt_setenv (name, new_value); + XFREE (new_value); + } +} + +void +lt_update_lib_path (const char *name, const char *value) +{ + lt_debugprintf (__FILE__, __LINE__, + "(lt_update_lib_path) modifying '%s' by prepending '%s'\n", + nonnull (name), nonnull (value)); + + if (name && *name && value && *value) + { + char *new_value = lt_extend_str (getenv (name), value, 0); + lt_setenv (name, new_value); + XFREE (new_value); + } +} + +EOF + case $host_os in + mingw*) + cat <<"EOF" + +/* Prepares an argument vector before calling spawn(). + Note that spawn() does not by itself call the command interpreter + (getenv ("COMSPEC") != NULL ? getenv ("COMSPEC") : + ({ OSVERSIONINFO v; v.dwOSVersionInfoSize = sizeof(OSVERSIONINFO); + GetVersionEx(&v); + v.dwPlatformId == VER_PLATFORM_WIN32_NT; + }) ? "cmd.exe" : "command.com"). + Instead it simply concatenates the arguments, separated by ' ', and calls + CreateProcess(). We must quote the arguments since Win32 CreateProcess() + interprets characters like ' ', '\t', '\\', '"' (but not '<' and '>') in a + special way: + - Space and tab are interpreted as delimiters. They are not treated as + delimiters if they are surrounded by double quotes: "...". + - Unescaped double quotes are removed from the input. Their only effect is + that within double quotes, space and tab are treated like normal + characters. + - Backslashes not followed by double quotes are not special. + - But 2*n+1 backslashes followed by a double quote become + n backslashes followed by a double quote (n >= 0): + \" -> " + \\\" -> \" + \\\\\" -> \\" + */ +#define SHELL_SPECIAL_CHARS "\"\\ \001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037" +#define SHELL_SPACE_CHARS " \001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037" +char ** +prepare_spawn (char **argv) +{ + size_t argc; + char **new_argv; + size_t i; + + /* Count number of arguments. */ + for (argc = 0; argv[argc] != NULL; argc++) + ; + + /* Allocate new argument vector. */ + new_argv = XMALLOC (char *, argc + 1); + + /* Put quoted arguments into the new argument vector. */ + for (i = 0; i < argc; i++) + { + const char *string = argv[i]; + + if (string[0] == '\0') + new_argv[i] = xstrdup ("\"\""); + else if (strpbrk (string, SHELL_SPECIAL_CHARS) != NULL) + { + int quote_around = (strpbrk (string, SHELL_SPACE_CHARS) != NULL); + size_t length; + unsigned int backslashes; + const char *s; + char *quoted_string; + char *p; + + length = 0; + backslashes = 0; + if (quote_around) + length++; + for (s = string; *s != '\0'; s++) + { + char c = *s; + if (c == '"') + length += backslashes + 1; + length++; + if (c == '\\') + backslashes++; + else + backslashes = 0; + } + if (quote_around) + length += backslashes + 1; + + quoted_string = XMALLOC (char, length + 1); + + p = quoted_string; + backslashes = 0; + if (quote_around) + *p++ = '"'; + for (s = string; *s != '\0'; s++) + { + char c = *s; + if (c == '"') + { + unsigned int j; + for (j = backslashes + 1; j > 0; j--) + *p++ = '\\'; + } + *p++ = c; + if (c == '\\') + backslashes++; + else + backslashes = 0; + } + if (quote_around) + { + unsigned int j; + for (j = backslashes; j > 0; j--) + *p++ = '\\'; + *p++ = '"'; + } + *p = '\0'; + + new_argv[i] = quoted_string; + } + else + new_argv[i] = (char *) string; + } + new_argv[argc] = NULL; + + return new_argv; +} +EOF + ;; + esac + + cat <<"EOF" +void lt_dump_script (FILE* f) +{ +EOF + func_emit_wrapper yes | + $SED -n -e ' +s/^\(.\{79\}\)\(..*\)/\1\ +\2/ +h +s/\([\\"]\)/\\\1/g +s/$/\\n/ +s/\([^\n]*\).*/ fputs ("\1", f);/p +g +D' + cat <<"EOF" +} +EOF +} +# end: func_emit_cwrapperexe_src + +# func_win32_import_lib_p ARG +# True if ARG is an import lib, as indicated by $file_magic_cmd +func_win32_import_lib_p () +{ + $opt_debug + case `eval $file_magic_cmd \"\$1\" 2>/dev/null | $SED -e 10q` in + *import*) : ;; + *) false ;; + esac +} + +# func_mode_link arg... +func_mode_link () +{ + $opt_debug + case $host in + *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*) + # It is impossible to link a dll without this setting, and + # we shouldn't force the makefile maintainer to figure out + # which system we are compiling for in order to pass an extra + # flag for every libtool invocation. + # allow_undefined=no + + # FIXME: Unfortunately, there are problems with the above when trying + # to make a dll which has undefined symbols, in which case not + # even a static library is built. For now, we need to specify + # -no-undefined on the libtool link line when we can be certain + # that all symbols are satisfied, otherwise we get a static library. + allow_undefined=yes + ;; + *) + allow_undefined=yes + ;; + esac + libtool_args=$nonopt + base_compile="$nonopt $@" + compile_command=$nonopt + finalize_command=$nonopt + + compile_rpath= + finalize_rpath= + compile_shlibpath= + finalize_shlibpath= + convenience= + old_convenience= + deplibs= + old_deplibs= + compiler_flags= + linker_flags= + dllsearchpath= + lib_search_path=`pwd` + inst_prefix_dir= + new_inherited_linker_flags= + + avoid_version=no + bindir= + dlfiles= + dlprefiles= + dlself=no + export_dynamic=no + export_symbols= + export_symbols_regex= + generated= + libobjs= + ltlibs= + module=no + no_install=no + objs= + non_pic_objects= + precious_files_regex= + prefer_static_libs=no + preload=no + prev= + prevarg= + release= + rpath= + xrpath= + perm_rpath= + temp_rpath= + thread_safe=no + vinfo= + vinfo_number=no + weak_libs= + single_module="${wl}-single_module" + func_infer_tag $base_compile + + # We need to know -static, to get the right output filenames. + for arg + do + case $arg in + -shared) + test "$build_libtool_libs" != yes && \ + func_fatal_configuration "can not build a shared library" + build_old_libs=no + break + ;; + -all-static | -static | -static-libtool-libs) + case $arg in + -all-static) + if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then + func_warning "complete static linking is impossible in this configuration" + fi + if test -n "$link_static_flag"; then + dlopen_self=$dlopen_self_static + fi + prefer_static_libs=yes + ;; + -static) + if test -z "$pic_flag" && test -n "$link_static_flag"; then + dlopen_self=$dlopen_self_static + fi + prefer_static_libs=built + ;; + -static-libtool-libs) + if test -z "$pic_flag" && test -n "$link_static_flag"; then + dlopen_self=$dlopen_self_static + fi + prefer_static_libs=yes + ;; + esac + build_libtool_libs=no + build_old_libs=yes + break + ;; + esac + done + + # See if our shared archives depend on static archives. + test -n "$old_archive_from_new_cmds" && build_old_libs=yes + + # Go through the arguments, transforming them on the way. + while test "$#" -gt 0; do + arg="$1" + shift + func_quote_for_eval "$arg" + qarg=$func_quote_for_eval_unquoted_result + func_append libtool_args " $func_quote_for_eval_result" + + # If the previous option needs an argument, assign it. + if test -n "$prev"; then + case $prev in + output) + func_append compile_command " @OUTPUT@" + func_append finalize_command " @OUTPUT@" + ;; + esac + + case $prev in + bindir) + bindir="$arg" + prev= + continue + ;; + dlfiles|dlprefiles) + if test "$preload" = no; then + # Add the symbol object into the linking commands. + func_append compile_command " @SYMFILE@" + func_append finalize_command " @SYMFILE@" + preload=yes + fi + case $arg in + *.la | *.lo) ;; # We handle these cases below. + force) + if test "$dlself" = no; then + dlself=needless + export_dynamic=yes + fi + prev= + continue + ;; + self) + if test "$prev" = dlprefiles; then + dlself=yes + elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then + dlself=yes + else + dlself=needless + export_dynamic=yes + fi + prev= + continue + ;; + *) + if test "$prev" = dlfiles; then + func_append dlfiles " $arg" + else + func_append dlprefiles " $arg" + fi + prev= + continue + ;; + esac + ;; + expsyms) + export_symbols="$arg" + test -f "$arg" \ + || func_fatal_error "symbol file \`$arg' does not exist" + prev= + continue + ;; + expsyms_regex) + export_symbols_regex="$arg" + prev= + continue + ;; + framework) + case $host in + *-*-darwin*) + case "$deplibs " in + *" $qarg.ltframework "*) ;; + *) func_append deplibs " $qarg.ltframework" # this is fixed later + ;; + esac + ;; + esac + prev= + continue + ;; + inst_prefix) + inst_prefix_dir="$arg" + prev= + continue + ;; + objectlist) + if test -f "$arg"; then + save_arg=$arg + moreargs= + for fil in `cat "$save_arg"` + do +# func_append moreargs " $fil" + arg=$fil + # A libtool-controlled object. + + # Check to see that this really is a libtool object. + if func_lalib_unsafe_p "$arg"; then + pic_object= + non_pic_object= + + # Read the .lo file + func_source "$arg" + + if test -z "$pic_object" || + test -z "$non_pic_object" || + test "$pic_object" = none && + test "$non_pic_object" = none; then + func_fatal_error "cannot find name of object for \`$arg'" + fi + + # Extract subdirectory from the argument. + func_dirname "$arg" "/" "" + xdir="$func_dirname_result" + + if test "$pic_object" != none; then + # Prepend the subdirectory the object is found in. + pic_object="$xdir$pic_object" + + if test "$prev" = dlfiles; then + if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then + func_append dlfiles " $pic_object" + prev= + continue + else + # If libtool objects are unsupported, then we need to preload. + prev=dlprefiles + fi + fi + + # CHECK ME: I think I busted this. -Ossama + if test "$prev" = dlprefiles; then + # Preload the old-style object. + func_append dlprefiles " $pic_object" + prev= + fi + + # A PIC object. + func_append libobjs " $pic_object" + arg="$pic_object" + fi + + # Non-PIC object. + if test "$non_pic_object" != none; then + # Prepend the subdirectory the object is found in. + non_pic_object="$xdir$non_pic_object" + + # A standard non-PIC object + func_append non_pic_objects " $non_pic_object" + if test -z "$pic_object" || test "$pic_object" = none ; then + arg="$non_pic_object" + fi + else + # If the PIC object exists, use it instead. + # $xdir was prepended to $pic_object above. + non_pic_object="$pic_object" + func_append non_pic_objects " $non_pic_object" + fi + else + # Only an error if not doing a dry-run. + if $opt_dry_run; then + # Extract subdirectory from the argument. + func_dirname "$arg" "/" "" + xdir="$func_dirname_result" + + func_lo2o "$arg" + pic_object=$xdir$objdir/$func_lo2o_result + non_pic_object=$xdir$func_lo2o_result + func_append libobjs " $pic_object" + func_append non_pic_objects " $non_pic_object" + else + func_fatal_error "\`$arg' is not a valid libtool object" + fi + fi + done + else + func_fatal_error "link input file \`$arg' does not exist" + fi + arg=$save_arg + prev= + continue + ;; + precious_regex) + precious_files_regex="$arg" + prev= + continue + ;; + release) + release="-$arg" + prev= + continue + ;; + rpath | xrpath) + # We need an absolute path. + case $arg in + [\\/]* | [A-Za-z]:[\\/]*) ;; + *) + func_fatal_error "only absolute run-paths are allowed" + ;; + esac + if test "$prev" = rpath; then + case "$rpath " in + *" $arg "*) ;; + *) func_append rpath " $arg" ;; + esac + else + case "$xrpath " in + *" $arg "*) ;; + *) func_append xrpath " $arg" ;; + esac + fi + prev= + continue + ;; + shrext) + shrext_cmds="$arg" + prev= + continue + ;; + weak) + func_append weak_libs " $arg" + prev= + continue + ;; + xcclinker) + func_append linker_flags " $qarg" + func_append compiler_flags " $qarg" + prev= + func_append compile_command " $qarg" + func_append finalize_command " $qarg" + continue + ;; + xcompiler) + func_append compiler_flags " $qarg" + prev= + func_append compile_command " $qarg" + func_append finalize_command " $qarg" + continue + ;; + xlinker) + func_append linker_flags " $qarg" + func_append compiler_flags " $wl$qarg" + prev= + func_append compile_command " $wl$qarg" + func_append finalize_command " $wl$qarg" + continue + ;; + *) + eval "$prev=\"\$arg\"" + prev= + continue + ;; + esac + fi # test -n "$prev" + + prevarg="$arg" + + case $arg in + -all-static) + if test -n "$link_static_flag"; then + # See comment for -static flag below, for more details. + func_append compile_command " $link_static_flag" + func_append finalize_command " $link_static_flag" + fi + continue + ;; + + -allow-undefined) + # FIXME: remove this flag sometime in the future. + func_fatal_error "\`-allow-undefined' must not be used because it is the default" + ;; + + -avoid-version) + avoid_version=yes + continue + ;; + + -bindir) + prev=bindir + continue + ;; + + -dlopen) + prev=dlfiles + continue + ;; + + -dlpreopen) + prev=dlprefiles + continue + ;; + + -export-dynamic) + export_dynamic=yes + continue + ;; + + -export-symbols | -export-symbols-regex) + if test -n "$export_symbols" || test -n "$export_symbols_regex"; then + func_fatal_error "more than one -exported-symbols argument is not allowed" + fi + if test "X$arg" = "X-export-symbols"; then + prev=expsyms + else + prev=expsyms_regex + fi + continue + ;; + + -framework) + prev=framework + continue + ;; + + -inst-prefix-dir) + prev=inst_prefix + continue + ;; + + # The native IRIX linker understands -LANG:*, -LIST:* and -LNO:* + # so, if we see these flags be careful not to treat them like -L + -L[A-Z][A-Z]*:*) + case $with_gcc/$host in + no/*-*-irix* | /*-*-irix*) + func_append compile_command " $arg" + func_append finalize_command " $arg" + ;; + esac + continue + ;; + + -L*) + func_stripname "-L" '' "$arg" + if test -z "$func_stripname_result"; then + if test "$#" -gt 0; then + func_fatal_error "require no space between \`-L' and \`$1'" + else + func_fatal_error "need path for \`-L' option" + fi + fi + func_resolve_sysroot "$func_stripname_result" + dir=$func_resolve_sysroot_result + # We need an absolute path. + case $dir in + [\\/]* | [A-Za-z]:[\\/]*) ;; + *) + absdir=`cd "$dir" && pwd` + test -z "$absdir" && \ + func_fatal_error "cannot determine absolute directory name of \`$dir'" + dir="$absdir" + ;; + esac + case "$deplibs " in + *" -L$dir "* | *" $arg "*) + # Will only happen for absolute or sysroot arguments + ;; + *) + # Preserve sysroot, but never include relative directories + case $dir in + [\\/]* | [A-Za-z]:[\\/]* | =*) func_append deplibs " $arg" ;; + *) func_append deplibs " -L$dir" ;; + esac + func_append lib_search_path " $dir" + ;; + esac + case $host in + *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*) + testbindir=`$ECHO "$dir" | $SED 's*/lib$*/bin*'` + case :$dllsearchpath: in + *":$dir:"*) ;; + ::) dllsearchpath=$dir;; + *) func_append dllsearchpath ":$dir";; + esac + case :$dllsearchpath: in + *":$testbindir:"*) ;; + ::) dllsearchpath=$testbindir;; + *) func_append dllsearchpath ":$testbindir";; + esac + ;; + esac + continue + ;; + + -l*) + if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then + case $host in + *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos* | *-cegcc* | *-*-haiku*) + # These systems don't actually have a C or math library (as such) + continue + ;; + *-*-os2*) + # These systems don't actually have a C library (as such) + test "X$arg" = "X-lc" && continue + ;; + *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*) + # Do not include libc due to us having libc/libc_r. + test "X$arg" = "X-lc" && continue + ;; + *-*-rhapsody* | *-*-darwin1.[012]) + # Rhapsody C and math libraries are in the System framework + func_append deplibs " System.ltframework" + continue + ;; + *-*-sco3.2v5* | *-*-sco5v6*) + # Causes problems with __ctype + test "X$arg" = "X-lc" && continue + ;; + *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*) + # Compiler inserts libc in the correct place for threads to work + test "X$arg" = "X-lc" && continue + ;; + esac + elif test "X$arg" = "X-lc_r"; then + case $host in + *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*) + # Do not include libc_r directly, use -pthread flag. + continue + ;; + esac + fi + func_append deplibs " $arg" + continue + ;; + + -module) + module=yes + continue + ;; + + # Tru64 UNIX uses -model [arg] to determine the layout of C++ + # classes, name mangling, and exception handling. + # Darwin uses the -arch flag to determine output architecture. + -model|-arch|-isysroot|--sysroot) + func_append compiler_flags " $arg" + func_append compile_command " $arg" + func_append finalize_command " $arg" + prev=xcompiler + continue + ;; + + -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe \ + |-threads|-fopenmp|-openmp|-mp|-xopenmp|-omp|-qsmp=*) + func_append compiler_flags " $arg" + func_append compile_command " $arg" + func_append finalize_command " $arg" + case "$new_inherited_linker_flags " in + *" $arg "*) ;; + * ) func_append new_inherited_linker_flags " $arg" ;; + esac + continue + ;; + + -multi_module) + single_module="${wl}-multi_module" + continue + ;; + + -no-fast-install) + fast_install=no + continue + ;; + + -no-install) + case $host in + *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-darwin* | *-cegcc*) + # The PATH hackery in wrapper scripts is required on Windows + # and Darwin in order for the loader to find any dlls it needs. + func_warning "\`-no-install' is ignored for $host" + func_warning "assuming \`-no-fast-install' instead" + fast_install=no + ;; + *) no_install=yes ;; + esac + continue + ;; + + -no-undefined) + allow_undefined=no + continue + ;; + + -objectlist) + prev=objectlist + continue + ;; + + -o) prev=output ;; + + -precious-files-regex) + prev=precious_regex + continue + ;; + + -release) + prev=release + continue + ;; + + -rpath) + prev=rpath + continue + ;; + + -R) + prev=xrpath + continue + ;; + + -R*) + func_stripname '-R' '' "$arg" + dir=$func_stripname_result + # We need an absolute path. + case $dir in + [\\/]* | [A-Za-z]:[\\/]*) ;; + =*) + func_stripname '=' '' "$dir" + dir=$lt_sysroot$func_stripname_result + ;; + *) + func_fatal_error "only absolute run-paths are allowed" + ;; + esac + case "$xrpath " in + *" $dir "*) ;; + *) func_append xrpath " $dir" ;; + esac + continue + ;; + + -shared) + # The effects of -shared are defined in a previous loop. + continue + ;; + + -shrext) + prev=shrext + continue + ;; + + -static | -static-libtool-libs) + # The effects of -static are defined in a previous loop. + # We used to do the same as -all-static on platforms that + # didn't have a PIC flag, but the assumption that the effects + # would be equivalent was wrong. It would break on at least + # Digital Unix and AIX. + continue + ;; + + -thread-safe) + thread_safe=yes + continue + ;; + + -version-info) + prev=vinfo + continue + ;; + + -version-number) + prev=vinfo + vinfo_number=yes + continue + ;; + + -weak) + prev=weak + continue + ;; + + -Wc,*) + func_stripname '-Wc,' '' "$arg" + args=$func_stripname_result + arg= + save_ifs="$IFS"; IFS=',' + for flag in $args; do + IFS="$save_ifs" + func_quote_for_eval "$flag" + func_append arg " $func_quote_for_eval_result" + func_append compiler_flags " $func_quote_for_eval_result" + done + IFS="$save_ifs" + func_stripname ' ' '' "$arg" + arg=$func_stripname_result + ;; + + -Wl,*) + func_stripname '-Wl,' '' "$arg" + args=$func_stripname_result + arg= + save_ifs="$IFS"; IFS=',' + for flag in $args; do + IFS="$save_ifs" + func_quote_for_eval "$flag" + func_append arg " $wl$func_quote_for_eval_result" + func_append compiler_flags " $wl$func_quote_for_eval_result" + func_append linker_flags " $func_quote_for_eval_result" + done + IFS="$save_ifs" + func_stripname ' ' '' "$arg" + arg=$func_stripname_result + ;; + + -Xcompiler) + prev=xcompiler + continue + ;; + + -Xlinker) + prev=xlinker + continue + ;; + + -XCClinker) + prev=xcclinker + continue + ;; + + # -msg_* for osf cc + -msg_*) + func_quote_for_eval "$arg" + arg="$func_quote_for_eval_result" + ;; + + # Flags to be passed through unchanged, with rationale: + # -64, -mips[0-9] enable 64-bit mode for the SGI compiler + # -r[0-9][0-9]* specify processor for the SGI compiler + # -xarch=*, -xtarget=* enable 64-bit mode for the Sun compiler + # +DA*, +DD* enable 64-bit mode for the HP compiler + # -q* compiler args for the IBM compiler + # -m*, -t[45]*, -txscale* architecture-specific flags for GCC + # -F/path path to uninstalled frameworks, gcc on darwin + # -p, -pg, --coverage, -fprofile-* profiling flags for GCC + # @file GCC response files + # -tp=* Portland pgcc target processor selection + # --sysroot=* for sysroot support + # -O*, -flto*, -fwhopr*, -fuse-linker-plugin GCC link-time optimization + -64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \ + -t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*|-tp=*|--sysroot=*| \ + -O*|-flto*|-fwhopr*|-fuse-linker-plugin) + func_quote_for_eval "$arg" + arg="$func_quote_for_eval_result" + func_append compile_command " $arg" + func_append finalize_command " $arg" + func_append compiler_flags " $arg" + continue + ;; + + # Some other compiler flag. + -* | +*) + func_quote_for_eval "$arg" + arg="$func_quote_for_eval_result" + ;; + + *.$objext) + # A standard object. + func_append objs " $arg" + ;; + + *.lo) + # A libtool-controlled object. + + # Check to see that this really is a libtool object. + if func_lalib_unsafe_p "$arg"; then + pic_object= + non_pic_object= + + # Read the .lo file + func_source "$arg" + + if test -z "$pic_object" || + test -z "$non_pic_object" || + test "$pic_object" = none && + test "$non_pic_object" = none; then + func_fatal_error "cannot find name of object for \`$arg'" + fi + + # Extract subdirectory from the argument. + func_dirname "$arg" "/" "" + xdir="$func_dirname_result" + + if test "$pic_object" != none; then + # Prepend the subdirectory the object is found in. + pic_object="$xdir$pic_object" + + if test "$prev" = dlfiles; then + if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then + func_append dlfiles " $pic_object" + prev= + continue + else + # If libtool objects are unsupported, then we need to preload. + prev=dlprefiles + fi + fi + + # CHECK ME: I think I busted this. -Ossama + if test "$prev" = dlprefiles; then + # Preload the old-style object. + func_append dlprefiles " $pic_object" + prev= + fi + + # A PIC object. + func_append libobjs " $pic_object" + arg="$pic_object" + fi + + # Non-PIC object. + if test "$non_pic_object" != none; then + # Prepend the subdirectory the object is found in. + non_pic_object="$xdir$non_pic_object" + + # A standard non-PIC object + func_append non_pic_objects " $non_pic_object" + if test -z "$pic_object" || test "$pic_object" = none ; then + arg="$non_pic_object" + fi + else + # If the PIC object exists, use it instead. + # $xdir was prepended to $pic_object above. + non_pic_object="$pic_object" + func_append non_pic_objects " $non_pic_object" + fi + else + # Only an error if not doing a dry-run. + if $opt_dry_run; then + # Extract subdirectory from the argument. + func_dirname "$arg" "/" "" + xdir="$func_dirname_result" + + func_lo2o "$arg" + pic_object=$xdir$objdir/$func_lo2o_result + non_pic_object=$xdir$func_lo2o_result + func_append libobjs " $pic_object" + func_append non_pic_objects " $non_pic_object" + else + func_fatal_error "\`$arg' is not a valid libtool object" + fi + fi + ;; + + *.$libext) + # An archive. + func_append deplibs " $arg" + func_append old_deplibs " $arg" + continue + ;; + + *.la) + # A libtool-controlled library. + + func_resolve_sysroot "$arg" + if test "$prev" = dlfiles; then + # This library was specified with -dlopen. + func_append dlfiles " $func_resolve_sysroot_result" + prev= + elif test "$prev" = dlprefiles; then + # The library was specified with -dlpreopen. + func_append dlprefiles " $func_resolve_sysroot_result" + prev= + else + func_append deplibs " $func_resolve_sysroot_result" + fi + continue + ;; + + # Some other compiler argument. + *) + # Unknown arguments in both finalize_command and compile_command need + # to be aesthetically quoted because they are evaled later. + func_quote_for_eval "$arg" + arg="$func_quote_for_eval_result" + ;; + esac # arg + + # Now actually substitute the argument into the commands. + if test -n "$arg"; then + func_append compile_command " $arg" + func_append finalize_command " $arg" + fi + done # argument parsing loop + + test -n "$prev" && \ + func_fatal_help "the \`$prevarg' option requires an argument" + + if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then + eval arg=\"$export_dynamic_flag_spec\" + func_append compile_command " $arg" + func_append finalize_command " $arg" + fi + + oldlibs= + # calculate the name of the file, without its directory + func_basename "$output" + outputname="$func_basename_result" + libobjs_save="$libobjs" + + if test -n "$shlibpath_var"; then + # get the directories listed in $shlibpath_var + eval shlib_search_path=\`\$ECHO \"\${$shlibpath_var}\" \| \$SED \'s/:/ /g\'\` + else + shlib_search_path= + fi + eval sys_lib_search_path=\"$sys_lib_search_path_spec\" + eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\" + + func_dirname "$output" "/" "" + output_objdir="$func_dirname_result$objdir" + func_to_tool_file "$output_objdir/" + tool_output_objdir=$func_to_tool_file_result + # Create the object directory. + func_mkdir_p "$output_objdir" + + # Determine the type of output + case $output in + "") + func_fatal_help "you must specify an output file" + ;; + *.$libext) linkmode=oldlib ;; + *.lo | *.$objext) linkmode=obj ;; + *.la) linkmode=lib ;; + *) linkmode=prog ;; # Anything else should be a program. + esac + + specialdeplibs= + + libs= + # Find all interdependent deplibs by searching for libraries + # that are linked more than once (e.g. -la -lb -la) + for deplib in $deplibs; do + if $opt_preserve_dup_deps ; then + case "$libs " in + *" $deplib "*) func_append specialdeplibs " $deplib" ;; + esac + fi + func_append libs " $deplib" + done + + if test "$linkmode" = lib; then + libs="$predeps $libs $compiler_lib_search_path $postdeps" + + # Compute libraries that are listed more than once in $predeps + # $postdeps and mark them as special (i.e., whose duplicates are + # not to be eliminated). + pre_post_deps= + if $opt_duplicate_compiler_generated_deps; then + for pre_post_dep in $predeps $postdeps; do + case "$pre_post_deps " in + *" $pre_post_dep "*) func_append specialdeplibs " $pre_post_deps" ;; + esac + func_append pre_post_deps " $pre_post_dep" + done + fi + pre_post_deps= + fi + + deplibs= + newdependency_libs= + newlib_search_path= + need_relink=no # whether we're linking any uninstalled libtool libraries + notinst_deplibs= # not-installed libtool libraries + notinst_path= # paths that contain not-installed libtool libraries + + case $linkmode in + lib) + passes="conv dlpreopen link" + for file in $dlfiles $dlprefiles; do + case $file in + *.la) ;; + *) + func_fatal_help "libraries can \`-dlopen' only libtool libraries: $file" + ;; + esac + done + ;; + prog) + compile_deplibs= + finalize_deplibs= + alldeplibs=no + newdlfiles= + newdlprefiles= + passes="conv scan dlopen dlpreopen link" + ;; + *) passes="conv" + ;; + esac + + for pass in $passes; do + # The preopen pass in lib mode reverses $deplibs; put it back here + # so that -L comes before libs that need it for instance... + if test "$linkmode,$pass" = "lib,link"; then + ## FIXME: Find the place where the list is rebuilt in the wrong + ## order, and fix it there properly + tmp_deplibs= + for deplib in $deplibs; do + tmp_deplibs="$deplib $tmp_deplibs" + done + deplibs="$tmp_deplibs" + fi + + if test "$linkmode,$pass" = "lib,link" || + test "$linkmode,$pass" = "prog,scan"; then + libs="$deplibs" + deplibs= + fi + if test "$linkmode" = prog; then + case $pass in + dlopen) libs="$dlfiles" ;; + dlpreopen) libs="$dlprefiles" ;; + link) + libs="$deplibs %DEPLIBS%" + test "X$link_all_deplibs" != Xno && libs="$libs $dependency_libs" + ;; + esac + fi + if test "$linkmode,$pass" = "lib,dlpreopen"; then + # Collect and forward deplibs of preopened libtool libs + for lib in $dlprefiles; do + # Ignore non-libtool-libs + dependency_libs= + func_resolve_sysroot "$lib" + case $lib in + *.la) func_source "$func_resolve_sysroot_result" ;; + esac + + # Collect preopened libtool deplibs, except any this library + # has declared as weak libs + for deplib in $dependency_libs; do + func_basename "$deplib" + deplib_base=$func_basename_result + case " $weak_libs " in + *" $deplib_base "*) ;; + *) func_append deplibs " $deplib" ;; + esac + done + done + libs="$dlprefiles" + fi + if test "$pass" = dlopen; then + # Collect dlpreopened libraries + save_deplibs="$deplibs" + deplibs= + fi + + for deplib in $libs; do + lib= + found=no + case $deplib in + -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe \ + |-threads|-fopenmp|-openmp|-mp|-xopenmp|-omp|-qsmp=*) + if test "$linkmode,$pass" = "prog,link"; then + compile_deplibs="$deplib $compile_deplibs" + finalize_deplibs="$deplib $finalize_deplibs" + else + func_append compiler_flags " $deplib" + if test "$linkmode" = lib ; then + case "$new_inherited_linker_flags " in + *" $deplib "*) ;; + * ) func_append new_inherited_linker_flags " $deplib" ;; + esac + fi + fi + continue + ;; + -l*) + if test "$linkmode" != lib && test "$linkmode" != prog; then + func_warning "\`-l' is ignored for archives/objects" + continue + fi + func_stripname '-l' '' "$deplib" + name=$func_stripname_result + if test "$linkmode" = lib; then + searchdirs="$newlib_search_path $lib_search_path $compiler_lib_search_dirs $sys_lib_search_path $shlib_search_path" + else + searchdirs="$newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path" + fi + for searchdir in $searchdirs; do + for search_ext in .la $std_shrext .so .a; do + # Search the libtool library + lib="$searchdir/lib${name}${search_ext}" + if test -f "$lib"; then + if test "$search_ext" = ".la"; then + found=yes + else + found=no + fi + break 2 + fi + done + done + if test "$found" != yes; then + # deplib doesn't seem to be a libtool library + if test "$linkmode,$pass" = "prog,link"; then + compile_deplibs="$deplib $compile_deplibs" + finalize_deplibs="$deplib $finalize_deplibs" + else + deplibs="$deplib $deplibs" + test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs" + fi + continue + else # deplib is a libtool library + # If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib, + # We need to do some special things here, and not later. + if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then + case " $predeps $postdeps " in + *" $deplib "*) + if func_lalib_p "$lib"; then + library_names= + old_library= + func_source "$lib" + for l in $old_library $library_names; do + ll="$l" + done + if test "X$ll" = "X$old_library" ; then # only static version available + found=no + func_dirname "$lib" "" "." + ladir="$func_dirname_result" + lib=$ladir/$old_library + if test "$linkmode,$pass" = "prog,link"; then + compile_deplibs="$deplib $compile_deplibs" + finalize_deplibs="$deplib $finalize_deplibs" + else + deplibs="$deplib $deplibs" + test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs" + fi + continue + fi + fi + ;; + *) ;; + esac + fi + fi + ;; # -l + *.ltframework) + if test "$linkmode,$pass" = "prog,link"; then + compile_deplibs="$deplib $compile_deplibs" + finalize_deplibs="$deplib $finalize_deplibs" + else + deplibs="$deplib $deplibs" + if test "$linkmode" = lib ; then + case "$new_inherited_linker_flags " in + *" $deplib "*) ;; + * ) func_append new_inherited_linker_flags " $deplib" ;; + esac + fi + fi + continue + ;; + -L*) + case $linkmode in + lib) + deplibs="$deplib $deplibs" + test "$pass" = conv && continue + newdependency_libs="$deplib $newdependency_libs" + func_stripname '-L' '' "$deplib" + func_resolve_sysroot "$func_stripname_result" + func_append newlib_search_path " $func_resolve_sysroot_result" + ;; + prog) + if test "$pass" = conv; then + deplibs="$deplib $deplibs" + continue + fi + if test "$pass" = scan; then + deplibs="$deplib $deplibs" + else + compile_deplibs="$deplib $compile_deplibs" + finalize_deplibs="$deplib $finalize_deplibs" + fi + func_stripname '-L' '' "$deplib" + func_resolve_sysroot "$func_stripname_result" + func_append newlib_search_path " $func_resolve_sysroot_result" + ;; + *) + func_warning "\`-L' is ignored for archives/objects" + ;; + esac # linkmode + continue + ;; # -L + -R*) + if test "$pass" = link; then + func_stripname '-R' '' "$deplib" + func_resolve_sysroot "$func_stripname_result" + dir=$func_resolve_sysroot_result + # Make sure the xrpath contains only unique directories. + case "$xrpath " in + *" $dir "*) ;; + *) func_append xrpath " $dir" ;; + esac + fi + deplibs="$deplib $deplibs" + continue + ;; + *.la) + func_resolve_sysroot "$deplib" + lib=$func_resolve_sysroot_result + ;; + *.$libext) + if test "$pass" = conv; then + deplibs="$deplib $deplibs" + continue + fi + case $linkmode in + lib) + # Linking convenience modules into shared libraries is allowed, + # but linking other static libraries is non-portable. + case " $dlpreconveniencelibs " in + *" $deplib "*) ;; + *) + valid_a_lib=no + case $deplibs_check_method in + match_pattern*) + set dummy $deplibs_check_method; shift + match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"` + if eval "\$ECHO \"$deplib\"" 2>/dev/null | $SED 10q \ + | $EGREP "$match_pattern_regex" > /dev/null; then + valid_a_lib=yes + fi + ;; + pass_all) + valid_a_lib=yes + ;; + esac + if test "$valid_a_lib" != yes; then + echo + $ECHO "*** Warning: Trying to link with static lib archive $deplib." + echo "*** I have the capability to make that library automatically link in when" + echo "*** you link to this library. But I can only do this if you have a" + echo "*** shared version of the library, which you do not appear to have" + echo "*** because the file extensions .$libext of this argument makes me believe" + echo "*** that it is just a static archive that I should not use here." + else + echo + $ECHO "*** Warning: Linking the shared library $output against the" + $ECHO "*** static library $deplib is not portable!" + deplibs="$deplib $deplibs" + fi + ;; + esac + continue + ;; + prog) + if test "$pass" != link; then + deplibs="$deplib $deplibs" + else + compile_deplibs="$deplib $compile_deplibs" + finalize_deplibs="$deplib $finalize_deplibs" + fi + continue + ;; + esac # linkmode + ;; # *.$libext + *.lo | *.$objext) + if test "$pass" = conv; then + deplibs="$deplib $deplibs" + elif test "$linkmode" = prog; then + if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then + # If there is no dlopen support or we're linking statically, + # we need to preload. + func_append newdlprefiles " $deplib" + compile_deplibs="$deplib $compile_deplibs" + finalize_deplibs="$deplib $finalize_deplibs" + else + func_append newdlfiles " $deplib" + fi + fi + continue + ;; + %DEPLIBS%) + alldeplibs=yes + continue + ;; + esac # case $deplib + + if test "$found" = yes || test -f "$lib"; then : + else + func_fatal_error "cannot find the library \`$lib' or unhandled argument \`$deplib'" + fi + + # Check to see that this really is a libtool archive. + func_lalib_unsafe_p "$lib" \ + || func_fatal_error "\`$lib' is not a valid libtool archive" + + func_dirname "$lib" "" "." + ladir="$func_dirname_result" + + dlname= + dlopen= + dlpreopen= + libdir= + library_names= + old_library= + inherited_linker_flags= + # If the library was installed with an old release of libtool, + # it will not redefine variables installed, or shouldnotlink + installed=yes + shouldnotlink=no + avoidtemprpath= + + + # Read the .la file + func_source "$lib" + + # Convert "-framework foo" to "foo.ltframework" + if test -n "$inherited_linker_flags"; then + tmp_inherited_linker_flags=`$ECHO "$inherited_linker_flags" | $SED 's/-framework \([^ $]*\)/\1.ltframework/g'` + for tmp_inherited_linker_flag in $tmp_inherited_linker_flags; do + case " $new_inherited_linker_flags " in + *" $tmp_inherited_linker_flag "*) ;; + *) func_append new_inherited_linker_flags " $tmp_inherited_linker_flag";; + esac + done + fi + dependency_libs=`$ECHO " $dependency_libs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'` + if test "$linkmode,$pass" = "lib,link" || + test "$linkmode,$pass" = "prog,scan" || + { test "$linkmode" != prog && test "$linkmode" != lib; }; then + test -n "$dlopen" && func_append dlfiles " $dlopen" + test -n "$dlpreopen" && func_append dlprefiles " $dlpreopen" + fi + + if test "$pass" = conv; then + # Only check for convenience libraries + deplibs="$lib $deplibs" + if test -z "$libdir"; then + if test -z "$old_library"; then + func_fatal_error "cannot find name of link library for \`$lib'" + fi + # It is a libtool convenience library, so add in its objects. + func_append convenience " $ladir/$objdir/$old_library" + func_append old_convenience " $ladir/$objdir/$old_library" + tmp_libs= + for deplib in $dependency_libs; do + deplibs="$deplib $deplibs" + if $opt_preserve_dup_deps ; then + case "$tmp_libs " in + *" $deplib "*) func_append specialdeplibs " $deplib" ;; + esac + fi + func_append tmp_libs " $deplib" + done + elif test "$linkmode" != prog && test "$linkmode" != lib; then + func_fatal_error "\`$lib' is not a convenience library" + fi + continue + fi # $pass = conv + + + # Get the name of the library we link against. + linklib= + if test -n "$old_library" && + { test "$prefer_static_libs" = yes || + test "$prefer_static_libs,$installed" = "built,no"; }; then + linklib=$old_library + else + for l in $old_library $library_names; do + linklib="$l" + done + fi + if test -z "$linklib"; then + func_fatal_error "cannot find name of link library for \`$lib'" + fi + + # This library was specified with -dlopen. + if test "$pass" = dlopen; then + if test -z "$libdir"; then + func_fatal_error "cannot -dlopen a convenience library: \`$lib'" + fi + if test -z "$dlname" || + test "$dlopen_support" != yes || + test "$build_libtool_libs" = no; then + # If there is no dlname, no dlopen support or we're linking + # statically, we need to preload. We also need to preload any + # dependent libraries so libltdl's deplib preloader doesn't + # bomb out in the load deplibs phase. + func_append dlprefiles " $lib $dependency_libs" + else + func_append newdlfiles " $lib" + fi + continue + fi # $pass = dlopen + + # We need an absolute path. + case $ladir in + [\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;; + *) + abs_ladir=`cd "$ladir" && pwd` + if test -z "$abs_ladir"; then + func_warning "cannot determine absolute directory name of \`$ladir'" + func_warning "passing it literally to the linker, although it might fail" + abs_ladir="$ladir" + fi + ;; + esac + func_basename "$lib" + laname="$func_basename_result" + + # Find the relevant object directory and library name. + if test "X$installed" = Xyes; then + if test ! -f "$lt_sysroot$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then + func_warning "library \`$lib' was moved." + dir="$ladir" + absdir="$abs_ladir" + libdir="$abs_ladir" + else + dir="$lt_sysroot$libdir" + absdir="$lt_sysroot$libdir" + fi + test "X$hardcode_automatic" = Xyes && avoidtemprpath=yes + else + if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then + dir="$ladir" + absdir="$abs_ladir" + # Remove this search path later + func_append notinst_path " $abs_ladir" + else + dir="$ladir/$objdir" + absdir="$abs_ladir/$objdir" + # Remove this search path later + func_append notinst_path " $abs_ladir" + fi + fi # $installed = yes + func_stripname 'lib' '.la' "$laname" + name=$func_stripname_result + + # This library was specified with -dlpreopen. + if test "$pass" = dlpreopen; then + if test -z "$libdir" && test "$linkmode" = prog; then + func_fatal_error "only libraries may -dlpreopen a convenience library: \`$lib'" + fi + case "$host" in + # special handling for platforms with PE-DLLs. + *cygwin* | *mingw* | *cegcc* ) + # Linker will automatically link against shared library if both + # static and shared are present. Therefore, ensure we extract + # symbols from the import library if a shared library is present + # (otherwise, the dlopen module name will be incorrect). We do + # this by putting the import library name into $newdlprefiles. + # We recover the dlopen module name by 'saving' the la file + # name in a special purpose variable, and (later) extracting the + # dlname from the la file. + if test -n "$dlname"; then + func_tr_sh "$dir/$linklib" + eval "libfile_$func_tr_sh_result=\$abs_ladir/\$laname" + func_append newdlprefiles " $dir/$linklib" + else + func_append newdlprefiles " $dir/$old_library" + # Keep a list of preopened convenience libraries to check + # that they are being used correctly in the link pass. + test -z "$libdir" && \ + func_append dlpreconveniencelibs " $dir/$old_library" + fi + ;; + * ) + # Prefer using a static library (so that no silly _DYNAMIC symbols + # are required to link). + if test -n "$old_library"; then + func_append newdlprefiles " $dir/$old_library" + # Keep a list of preopened convenience libraries to check + # that they are being used correctly in the link pass. + test -z "$libdir" && \ + func_append dlpreconveniencelibs " $dir/$old_library" + # Otherwise, use the dlname, so that lt_dlopen finds it. + elif test -n "$dlname"; then + func_append newdlprefiles " $dir/$dlname" + else + func_append newdlprefiles " $dir/$linklib" + fi + ;; + esac + fi # $pass = dlpreopen + + if test -z "$libdir"; then + # Link the convenience library + if test "$linkmode" = lib; then + deplibs="$dir/$old_library $deplibs" + elif test "$linkmode,$pass" = "prog,link"; then + compile_deplibs="$dir/$old_library $compile_deplibs" + finalize_deplibs="$dir/$old_library $finalize_deplibs" + else + deplibs="$lib $deplibs" # used for prog,scan pass + fi + continue + fi + + + if test "$linkmode" = prog && test "$pass" != link; then + func_append newlib_search_path " $ladir" + deplibs="$lib $deplibs" + + linkalldeplibs=no + if test "$link_all_deplibs" != no || test -z "$library_names" || + test "$build_libtool_libs" = no; then + linkalldeplibs=yes + fi + + tmp_libs= + for deplib in $dependency_libs; do + case $deplib in + -L*) func_stripname '-L' '' "$deplib" + func_resolve_sysroot "$func_stripname_result" + func_append newlib_search_path " $func_resolve_sysroot_result" + ;; + esac + # Need to link against all dependency_libs? + if test "$linkalldeplibs" = yes; then + deplibs="$deplib $deplibs" + else + # Need to hardcode shared library paths + # or/and link against static libraries + newdependency_libs="$deplib $newdependency_libs" + fi + if $opt_preserve_dup_deps ; then + case "$tmp_libs " in + *" $deplib "*) func_append specialdeplibs " $deplib" ;; + esac + fi + func_append tmp_libs " $deplib" + done # for deplib + continue + fi # $linkmode = prog... + + if test "$linkmode,$pass" = "prog,link"; then + if test -n "$library_names" && + { { test "$prefer_static_libs" = no || + test "$prefer_static_libs,$installed" = "built,yes"; } || + test -z "$old_library"; }; then + # We need to hardcode the library path + if test -n "$shlibpath_var" && test -z "$avoidtemprpath" ; then + # Make sure the rpath contains only unique directories. + case "$temp_rpath:" in + *"$absdir:"*) ;; + *) func_append temp_rpath "$absdir:" ;; + esac + fi + + # Hardcode the library path. + # Skip directories that are in the system default run-time + # search path. + case " $sys_lib_dlsearch_path " in + *" $absdir "*) ;; + *) + case "$compile_rpath " in + *" $absdir "*) ;; + *) func_append compile_rpath " $absdir" ;; + esac + ;; + esac + case " $sys_lib_dlsearch_path " in + *" $libdir "*) ;; + *) + case "$finalize_rpath " in + *" $libdir "*) ;; + *) func_append finalize_rpath " $libdir" ;; + esac + ;; + esac + fi # $linkmode,$pass = prog,link... + + if test "$alldeplibs" = yes && + { test "$deplibs_check_method" = pass_all || + { test "$build_libtool_libs" = yes && + test -n "$library_names"; }; }; then + # We only need to search for static libraries + continue + fi + fi + + link_static=no # Whether the deplib will be linked statically + use_static_libs=$prefer_static_libs + if test "$use_static_libs" = built && test "$installed" = yes; then + use_static_libs=no + fi + if test -n "$library_names" && + { test "$use_static_libs" = no || test -z "$old_library"; }; then + case $host in + *cygwin* | *mingw* | *cegcc*) + # No point in relinking DLLs because paths are not encoded + func_append notinst_deplibs " $lib" + need_relink=no + ;; + *) + if test "$installed" = no; then + func_append notinst_deplibs " $lib" + need_relink=yes + fi + ;; + esac + # This is a shared library + + # Warn about portability, can't link against -module's on some + # systems (darwin). Don't bleat about dlopened modules though! + dlopenmodule="" + for dlpremoduletest in $dlprefiles; do + if test "X$dlpremoduletest" = "X$lib"; then + dlopenmodule="$dlpremoduletest" + break + fi + done + if test -z "$dlopenmodule" && test "$shouldnotlink" = yes && test "$pass" = link; then + echo + if test "$linkmode" = prog; then + $ECHO "*** Warning: Linking the executable $output against the loadable module" + else + $ECHO "*** Warning: Linking the shared library $output against the loadable module" + fi + $ECHO "*** $linklib is not portable!" + fi + if test "$linkmode" = lib && + test "$hardcode_into_libs" = yes; then + # Hardcode the library path. + # Skip directories that are in the system default run-time + # search path. + case " $sys_lib_dlsearch_path " in + *" $absdir "*) ;; + *) + case "$compile_rpath " in + *" $absdir "*) ;; + *) func_append compile_rpath " $absdir" ;; + esac + ;; + esac + case " $sys_lib_dlsearch_path " in + *" $libdir "*) ;; + *) + case "$finalize_rpath " in + *" $libdir "*) ;; + *) func_append finalize_rpath " $libdir" ;; + esac + ;; + esac + fi + + if test -n "$old_archive_from_expsyms_cmds"; then + # figure out the soname + set dummy $library_names + shift + realname="$1" + shift + libname=`eval "\\$ECHO \"$libname_spec\""` + # use dlname if we got it. it's perfectly good, no? + if test -n "$dlname"; then + soname="$dlname" + elif test -n "$soname_spec"; then + # bleh windows + case $host in + *cygwin* | mingw* | *cegcc*) + func_arith $current - $age + major=$func_arith_result + versuffix="-$major" + ;; + esac + eval soname=\"$soname_spec\" + else + soname="$realname" + fi + + # Make a new name for the extract_expsyms_cmds to use + soroot="$soname" + func_basename "$soroot" + soname="$func_basename_result" + func_stripname 'lib' '.dll' "$soname" + newlib=libimp-$func_stripname_result.a + + # If the library has no export list, then create one now + if test -f "$output_objdir/$soname-def"; then : + else + func_verbose "extracting exported symbol list from \`$soname'" + func_execute_cmds "$extract_expsyms_cmds" 'exit $?' + fi + + # Create $newlib + if test -f "$output_objdir/$newlib"; then :; else + func_verbose "generating import library for \`$soname'" + func_execute_cmds "$old_archive_from_expsyms_cmds" 'exit $?' + fi + # make sure the library variables are pointing to the new library + dir=$output_objdir + linklib=$newlib + fi # test -n "$old_archive_from_expsyms_cmds" + + if test "$linkmode" = prog || test "$opt_mode" != relink; then + add_shlibpath= + add_dir= + add= + lib_linked=yes + case $hardcode_action in + immediate | unsupported) + if test "$hardcode_direct" = no; then + add="$dir/$linklib" + case $host in + *-*-sco3.2v5.0.[024]*) add_dir="-L$dir" ;; + *-*-sysv4*uw2*) add_dir="-L$dir" ;; + *-*-sysv5OpenUNIX* | *-*-sysv5UnixWare7.[01].[10]* | \ + *-*-unixware7*) add_dir="-L$dir" ;; + *-*-darwin* ) + # if the lib is a (non-dlopened) module then we can not + # link against it, someone is ignoring the earlier warnings + if /usr/bin/file -L $add 2> /dev/null | + $GREP ": [^:]* bundle" >/dev/null ; then + if test "X$dlopenmodule" != "X$lib"; then + $ECHO "*** Warning: lib $linklib is a module, not a shared library" + if test -z "$old_library" ; then + echo + echo "*** And there doesn't seem to be a static archive available" + echo "*** The link will probably fail, sorry" + else + add="$dir/$old_library" + fi + elif test -n "$old_library"; then + add="$dir/$old_library" + fi + fi + esac + elif test "$hardcode_minus_L" = no; then + case $host in + *-*-sunos*) add_shlibpath="$dir" ;; + esac + add_dir="-L$dir" + add="-l$name" + elif test "$hardcode_shlibpath_var" = no; then + add_shlibpath="$dir" + add="-l$name" + else + lib_linked=no + fi + ;; + relink) + if test "$hardcode_direct" = yes && + test "$hardcode_direct_absolute" = no; then + add="$dir/$linklib" + elif test "$hardcode_minus_L" = yes; then + add_dir="-L$absdir" + # Try looking first in the location we're being installed to. + if test -n "$inst_prefix_dir"; then + case $libdir in + [\\/]*) + func_append add_dir " -L$inst_prefix_dir$libdir" + ;; + esac + fi + add="-l$name" + elif test "$hardcode_shlibpath_var" = yes; then + add_shlibpath="$dir" + add="-l$name" + else + lib_linked=no + fi + ;; + *) lib_linked=no ;; + esac + + if test "$lib_linked" != yes; then + func_fatal_configuration "unsupported hardcode properties" + fi + + if test -n "$add_shlibpath"; then + case :$compile_shlibpath: in + *":$add_shlibpath:"*) ;; + *) func_append compile_shlibpath "$add_shlibpath:" ;; + esac + fi + if test "$linkmode" = prog; then + test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs" + test -n "$add" && compile_deplibs="$add $compile_deplibs" + else + test -n "$add_dir" && deplibs="$add_dir $deplibs" + test -n "$add" && deplibs="$add $deplibs" + if test "$hardcode_direct" != yes && + test "$hardcode_minus_L" != yes && + test "$hardcode_shlibpath_var" = yes; then + case :$finalize_shlibpath: in + *":$libdir:"*) ;; + *) func_append finalize_shlibpath "$libdir:" ;; + esac + fi + fi + fi + + if test "$linkmode" = prog || test "$opt_mode" = relink; then + add_shlibpath= + add_dir= + add= + # Finalize command for both is simple: just hardcode it. + if test "$hardcode_direct" = yes && + test "$hardcode_direct_absolute" = no; then + add="$libdir/$linklib" + elif test "$hardcode_minus_L" = yes; then + add_dir="-L$libdir" + add="-l$name" + elif test "$hardcode_shlibpath_var" = yes; then + case :$finalize_shlibpath: in + *":$libdir:"*) ;; + *) func_append finalize_shlibpath "$libdir:" ;; + esac + add="-l$name" + elif test "$hardcode_automatic" = yes; then + if test -n "$inst_prefix_dir" && + test -f "$inst_prefix_dir$libdir/$linklib" ; then + add="$inst_prefix_dir$libdir/$linklib" + else + add="$libdir/$linklib" + fi + else + # We cannot seem to hardcode it, guess we'll fake it. + add_dir="-L$libdir" + # Try looking first in the location we're being installed to. + if test -n "$inst_prefix_dir"; then + case $libdir in + [\\/]*) + func_append add_dir " -L$inst_prefix_dir$libdir" + ;; + esac + fi + add="-l$name" + fi + + if test "$linkmode" = prog; then + test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs" + test -n "$add" && finalize_deplibs="$add $finalize_deplibs" + else + test -n "$add_dir" && deplibs="$add_dir $deplibs" + test -n "$add" && deplibs="$add $deplibs" + fi + fi + elif test "$linkmode" = prog; then + # Here we assume that one of hardcode_direct or hardcode_minus_L + # is not unsupported. This is valid on all known static and + # shared platforms. + if test "$hardcode_direct" != unsupported; then + test -n "$old_library" && linklib="$old_library" + compile_deplibs="$dir/$linklib $compile_deplibs" + finalize_deplibs="$dir/$linklib $finalize_deplibs" + else + compile_deplibs="-l$name -L$dir $compile_deplibs" + finalize_deplibs="-l$name -L$dir $finalize_deplibs" + fi + elif test "$build_libtool_libs" = yes; then + # Not a shared library + if test "$deplibs_check_method" != pass_all; then + # We're trying link a shared library against a static one + # but the system doesn't support it. + + # Just print a warning and add the library to dependency_libs so + # that the program can be linked against the static library. + echo + $ECHO "*** Warning: This system can not link to static lib archive $lib." + echo "*** I have the capability to make that library automatically link in when" + echo "*** you link to this library. But I can only do this if you have a" + echo "*** shared version of the library, which you do not appear to have." + if test "$module" = yes; then + echo "*** But as you try to build a module library, libtool will still create " + echo "*** a static module, that should work as long as the dlopening application" + echo "*** is linked with the -dlopen flag to resolve symbols at runtime." + if test -z "$global_symbol_pipe"; then + echo + echo "*** However, this would only work if libtool was able to extract symbol" + echo "*** lists from a program, using \`nm' or equivalent, but libtool could" + echo "*** not find such a program. So, this module is probably useless." + echo "*** \`nm' from GNU binutils and a full rebuild may help." + fi + if test "$build_old_libs" = no; then + build_libtool_libs=module + build_old_libs=yes + else + build_libtool_libs=no + fi + fi + else + deplibs="$dir/$old_library $deplibs" + link_static=yes + fi + fi # link shared/static library? + + if test "$linkmode" = lib; then + if test -n "$dependency_libs" && + { test "$hardcode_into_libs" != yes || + test "$build_old_libs" = yes || + test "$link_static" = yes; }; then + # Extract -R from dependency_libs + temp_deplibs= + for libdir in $dependency_libs; do + case $libdir in + -R*) func_stripname '-R' '' "$libdir" + temp_xrpath=$func_stripname_result + case " $xrpath " in + *" $temp_xrpath "*) ;; + *) func_append xrpath " $temp_xrpath";; + esac;; + *) func_append temp_deplibs " $libdir";; + esac + done + dependency_libs="$temp_deplibs" + fi + + func_append newlib_search_path " $absdir" + # Link against this library + test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs" + # ... and its dependency_libs + tmp_libs= + for deplib in $dependency_libs; do + newdependency_libs="$deplib $newdependency_libs" + case $deplib in + -L*) func_stripname '-L' '' "$deplib" + func_resolve_sysroot "$func_stripname_result";; + *) func_resolve_sysroot "$deplib" ;; + esac + if $opt_preserve_dup_deps ; then + case "$tmp_libs " in + *" $func_resolve_sysroot_result "*) + func_append specialdeplibs " $func_resolve_sysroot_result" ;; + esac + fi + func_append tmp_libs " $func_resolve_sysroot_result" + done + + if test "$link_all_deplibs" != no; then + # Add the search paths of all dependency libraries + for deplib in $dependency_libs; do + path= + case $deplib in + -L*) path="$deplib" ;; + *.la) + func_resolve_sysroot "$deplib" + deplib=$func_resolve_sysroot_result + func_dirname "$deplib" "" "." + dir=$func_dirname_result + # We need an absolute path. + case $dir in + [\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;; + *) + absdir=`cd "$dir" && pwd` + if test -z "$absdir"; then + func_warning "cannot determine absolute directory name of \`$dir'" + absdir="$dir" + fi + ;; + esac + if $GREP "^installed=no" $deplib > /dev/null; then + case $host in + *-*-darwin*) + depdepl= + eval deplibrary_names=`${SED} -n -e 's/^library_names=\(.*\)$/\1/p' $deplib` + if test -n "$deplibrary_names" ; then + for tmp in $deplibrary_names ; do + depdepl=$tmp + done + if test -f "$absdir/$objdir/$depdepl" ; then + depdepl="$absdir/$objdir/$depdepl" + darwin_install_name=`${OTOOL} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'` + if test -z "$darwin_install_name"; then + darwin_install_name=`${OTOOL64} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'` + fi + func_append compiler_flags " ${wl}-dylib_file ${wl}${darwin_install_name}:${depdepl}" + func_append linker_flags " -dylib_file ${darwin_install_name}:${depdepl}" + path= + fi + fi + ;; + *) + path="-L$absdir/$objdir" + ;; + esac + else + eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib` + test -z "$libdir" && \ + func_fatal_error "\`$deplib' is not a valid libtool archive" + test "$absdir" != "$libdir" && \ + func_warning "\`$deplib' seems to be moved" + + path="-L$absdir" + fi + ;; + esac + case " $deplibs " in + *" $path "*) ;; + *) deplibs="$path $deplibs" ;; + esac + done + fi # link_all_deplibs != no + fi # linkmode = lib + done # for deplib in $libs + if test "$pass" = link; then + if test "$linkmode" = "prog"; then + compile_deplibs="$new_inherited_linker_flags $compile_deplibs" + finalize_deplibs="$new_inherited_linker_flags $finalize_deplibs" + else + compiler_flags="$compiler_flags "`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'` + fi + fi + dependency_libs="$newdependency_libs" + if test "$pass" = dlpreopen; then + # Link the dlpreopened libraries before other libraries + for deplib in $save_deplibs; do + deplibs="$deplib $deplibs" + done + fi + if test "$pass" != dlopen; then + if test "$pass" != conv; then + # Make sure lib_search_path contains only unique directories. + lib_search_path= + for dir in $newlib_search_path; do + case "$lib_search_path " in + *" $dir "*) ;; + *) func_append lib_search_path " $dir" ;; + esac + done + newlib_search_path= + fi + + if test "$linkmode,$pass" != "prog,link"; then + vars="deplibs" + else + vars="compile_deplibs finalize_deplibs" + fi + for var in $vars dependency_libs; do + # Add libraries to $var in reverse order + eval tmp_libs=\"\$$var\" + new_libs= + for deplib in $tmp_libs; do + # FIXME: Pedantically, this is the right thing to do, so + # that some nasty dependency loop isn't accidentally + # broken: + #new_libs="$deplib $new_libs" + # Pragmatically, this seems to cause very few problems in + # practice: + case $deplib in + -L*) new_libs="$deplib $new_libs" ;; + -R*) ;; + *) + # And here is the reason: when a library appears more + # than once as an explicit dependence of a library, or + # is implicitly linked in more than once by the + # compiler, it is considered special, and multiple + # occurrences thereof are not removed. Compare this + # with having the same library being listed as a + # dependency of multiple other libraries: in this case, + # we know (pedantically, we assume) the library does not + # need to be listed more than once, so we keep only the + # last copy. This is not always right, but it is rare + # enough that we require users that really mean to play + # such unportable linking tricks to link the library + # using -Wl,-lname, so that libtool does not consider it + # for duplicate removal. + case " $specialdeplibs " in + *" $deplib "*) new_libs="$deplib $new_libs" ;; + *) + case " $new_libs " in + *" $deplib "*) ;; + *) new_libs="$deplib $new_libs" ;; + esac + ;; + esac + ;; + esac + done + tmp_libs= + for deplib in $new_libs; do + case $deplib in + -L*) + case " $tmp_libs " in + *" $deplib "*) ;; + *) func_append tmp_libs " $deplib" ;; + esac + ;; + *) func_append tmp_libs " $deplib" ;; + esac + done + eval $var=\"$tmp_libs\" + done # for var + fi + # Last step: remove runtime libs from dependency_libs + # (they stay in deplibs) + tmp_libs= + for i in $dependency_libs ; do + case " $predeps $postdeps $compiler_lib_search_path " in + *" $i "*) + i="" + ;; + esac + if test -n "$i" ; then + func_append tmp_libs " $i" + fi + done + dependency_libs=$tmp_libs + done # for pass + if test "$linkmode" = prog; then + dlfiles="$newdlfiles" + fi + if test "$linkmode" = prog || test "$linkmode" = lib; then + dlprefiles="$newdlprefiles" + fi + + case $linkmode in + oldlib) + if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then + func_warning "\`-dlopen' is ignored for archives" + fi + + case " $deplibs" in + *\ -l* | *\ -L*) + func_warning "\`-l' and \`-L' are ignored for archives" ;; + esac + + test -n "$rpath" && \ + func_warning "\`-rpath' is ignored for archives" + + test -n "$xrpath" && \ + func_warning "\`-R' is ignored for archives" + + test -n "$vinfo" && \ + func_warning "\`-version-info/-version-number' is ignored for archives" + + test -n "$release" && \ + func_warning "\`-release' is ignored for archives" + + test -n "$export_symbols$export_symbols_regex" && \ + func_warning "\`-export-symbols' is ignored for archives" + + # Now set the variables for building old libraries. + build_libtool_libs=no + oldlibs="$output" + func_append objs "$old_deplibs" + ;; + + lib) + # Make sure we only generate libraries of the form `libNAME.la'. + case $outputname in + lib*) + func_stripname 'lib' '.la' "$outputname" + name=$func_stripname_result + eval shared_ext=\"$shrext_cmds\" + eval libname=\"$libname_spec\" + ;; + *) + test "$module" = no && \ + func_fatal_help "libtool library \`$output' must begin with \`lib'" + + if test "$need_lib_prefix" != no; then + # Add the "lib" prefix for modules if required + func_stripname '' '.la' "$outputname" + name=$func_stripname_result + eval shared_ext=\"$shrext_cmds\" + eval libname=\"$libname_spec\" + else + func_stripname '' '.la' "$outputname" + libname=$func_stripname_result + fi + ;; + esac + + if test -n "$objs"; then + if test "$deplibs_check_method" != pass_all; then + func_fatal_error "cannot build libtool library \`$output' from non-libtool objects on this host:$objs" + else + echo + $ECHO "*** Warning: Linking the shared library $output against the non-libtool" + $ECHO "*** objects $objs is not portable!" + func_append libobjs " $objs" + fi + fi + + test "$dlself" != no && \ + func_warning "\`-dlopen self' is ignored for libtool libraries" + + set dummy $rpath + shift + test "$#" -gt 1 && \ + func_warning "ignoring multiple \`-rpath's for a libtool library" + + install_libdir="$1" + + oldlibs= + if test -z "$rpath"; then + if test "$build_libtool_libs" = yes; then + # Building a libtool convenience library. + # Some compilers have problems with a `.al' extension so + # convenience libraries should have the same extension an + # archive normally would. + oldlibs="$output_objdir/$libname.$libext $oldlibs" + build_libtool_libs=convenience + build_old_libs=yes + fi + + test -n "$vinfo" && \ + func_warning "\`-version-info/-version-number' is ignored for convenience libraries" + + test -n "$release" && \ + func_warning "\`-release' is ignored for convenience libraries" + else + + # Parse the version information argument. + save_ifs="$IFS"; IFS=':' + set dummy $vinfo 0 0 0 + shift + IFS="$save_ifs" + + test -n "$7" && \ + func_fatal_help "too many parameters to \`-version-info'" + + # convert absolute version numbers to libtool ages + # this retains compatibility with .la files and attempts + # to make the code below a bit more comprehensible + + case $vinfo_number in + yes) + number_major="$1" + number_minor="$2" + number_revision="$3" + # + # There are really only two kinds -- those that + # use the current revision as the major version + # and those that subtract age and use age as + # a minor version. But, then there is irix + # which has an extra 1 added just for fun + # + case $version_type in + # correct linux to gnu/linux during the next big refactor + darwin|linux|osf|windows|none) + func_arith $number_major + $number_minor + current=$func_arith_result + age="$number_minor" + revision="$number_revision" + ;; + freebsd-aout|freebsd-elf|qnx|sunos) + current="$number_major" + revision="$number_minor" + age="0" + ;; + irix|nonstopux) + func_arith $number_major + $number_minor + current=$func_arith_result + age="$number_minor" + revision="$number_minor" + lt_irix_increment=no + ;; + *) + func_fatal_configuration "$modename: unknown library version type \`$version_type'" + ;; + esac + ;; + no) + current="$1" + revision="$2" + age="$3" + ;; + esac + + # Check that each of the things are valid numbers. + case $current in + 0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;; + *) + func_error "CURRENT \`$current' must be a nonnegative integer" + func_fatal_error "\`$vinfo' is not valid version information" + ;; + esac + + case $revision in + 0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;; + *) + func_error "REVISION \`$revision' must be a nonnegative integer" + func_fatal_error "\`$vinfo' is not valid version information" + ;; + esac + + case $age in + 0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;; + *) + func_error "AGE \`$age' must be a nonnegative integer" + func_fatal_error "\`$vinfo' is not valid version information" + ;; + esac + + if test "$age" -gt "$current"; then + func_error "AGE \`$age' is greater than the current interface number \`$current'" + func_fatal_error "\`$vinfo' is not valid version information" + fi + + # Calculate the version variables. + major= + versuffix= + verstring= + case $version_type in + none) ;; + + darwin) + # Like Linux, but with the current version available in + # verstring for coding it into the library header + func_arith $current - $age + major=.$func_arith_result + versuffix="$major.$age.$revision" + # Darwin ld doesn't like 0 for these options... + func_arith $current + 1 + minor_current=$func_arith_result + xlcverstring="${wl}-compatibility_version ${wl}$minor_current ${wl}-current_version ${wl}$minor_current.$revision" + verstring="-compatibility_version $minor_current -current_version $minor_current.$revision" + ;; + + freebsd-aout) + major=".$current" + versuffix=".$current.$revision"; + ;; + + freebsd-elf) + major=".$current" + versuffix=".$current" + ;; + + irix | nonstopux) + if test "X$lt_irix_increment" = "Xno"; then + func_arith $current - $age + else + func_arith $current - $age + 1 + fi + major=$func_arith_result + + case $version_type in + nonstopux) verstring_prefix=nonstopux ;; + *) verstring_prefix=sgi ;; + esac + verstring="$verstring_prefix$major.$revision" + + # Add in all the interfaces that we are compatible with. + loop=$revision + while test "$loop" -ne 0; do + func_arith $revision - $loop + iface=$func_arith_result + func_arith $loop - 1 + loop=$func_arith_result + verstring="$verstring_prefix$major.$iface:$verstring" + done + + # Before this point, $major must not contain `.'. + major=.$major + versuffix="$major.$revision" + ;; + + linux) # correct to gnu/linux during the next big refactor + func_arith $current - $age + major=.$func_arith_result + versuffix="$major.$age.$revision" + ;; + + osf) + func_arith $current - $age + major=.$func_arith_result + versuffix=".$current.$age.$revision" + verstring="$current.$age.$revision" + + # Add in all the interfaces that we are compatible with. + loop=$age + while test "$loop" -ne 0; do + func_arith $current - $loop + iface=$func_arith_result + func_arith $loop - 1 + loop=$func_arith_result + verstring="$verstring:${iface}.0" + done + + # Make executables depend on our current version. + func_append verstring ":${current}.0" + ;; + + qnx) + major=".$current" + versuffix=".$current" + ;; + + sunos) + major=".$current" + versuffix=".$current.$revision" + ;; + + windows) + # Use '-' rather than '.', since we only want one + # extension on DOS 8.3 filesystems. + func_arith $current - $age + major=$func_arith_result + versuffix="-$major" + ;; + + *) + func_fatal_configuration "unknown library version type \`$version_type'" + ;; + esac + + # Clear the version info if we defaulted, and they specified a release. + if test -z "$vinfo" && test -n "$release"; then + major= + case $version_type in + darwin) + # we can't check for "0.0" in archive_cmds due to quoting + # problems, so we reset it completely + verstring= + ;; + *) + verstring="0.0" + ;; + esac + if test "$need_version" = no; then + versuffix= + else + versuffix=".0.0" + fi + fi + + # Remove version info from name if versioning should be avoided + if test "$avoid_version" = yes && test "$need_version" = no; then + major= + versuffix= + verstring="" + fi + + # Check to see if the archive will have undefined symbols. + if test "$allow_undefined" = yes; then + if test "$allow_undefined_flag" = unsupported; then + func_warning "undefined symbols not allowed in $host shared libraries" + build_libtool_libs=no + build_old_libs=yes + fi + else + # Don't allow undefined symbols. + allow_undefined_flag="$no_undefined_flag" + fi + + fi + + func_generate_dlsyms "$libname" "$libname" "yes" + func_append libobjs " $symfileobj" + test "X$libobjs" = "X " && libobjs= + + if test "$opt_mode" != relink; then + # Remove our outputs, but don't remove object files since they + # may have been created when compiling PIC objects. + removelist= + tempremovelist=`$ECHO "$output_objdir/*"` + for p in $tempremovelist; do + case $p in + *.$objext | *.gcno) + ;; + $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*) + if test "X$precious_files_regex" != "X"; then + if $ECHO "$p" | $EGREP -e "$precious_files_regex" >/dev/null 2>&1 + then + continue + fi + fi + func_append removelist " $p" + ;; + *) ;; + esac + done + test -n "$removelist" && \ + func_show_eval "${RM}r \$removelist" + fi + + # Now set the variables for building old libraries. + if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then + func_append oldlibs " $output_objdir/$libname.$libext" + + # Transform .lo files to .o files. + oldobjs="$objs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; $lo2o" | $NL2SP` + fi + + # Eliminate all temporary directories. + #for path in $notinst_path; do + # lib_search_path=`$ECHO "$lib_search_path " | $SED "s% $path % %g"` + # deplibs=`$ECHO "$deplibs " | $SED "s% -L$path % %g"` + # dependency_libs=`$ECHO "$dependency_libs " | $SED "s% -L$path % %g"` + #done + + if test -n "$xrpath"; then + # If the user specified any rpath flags, then add them. + temp_xrpath= + for libdir in $xrpath; do + func_replace_sysroot "$libdir" + func_append temp_xrpath " -R$func_replace_sysroot_result" + case "$finalize_rpath " in + *" $libdir "*) ;; + *) func_append finalize_rpath " $libdir" ;; + esac + done + if test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then + dependency_libs="$temp_xrpath $dependency_libs" + fi + fi + + # Make sure dlfiles contains only unique files that won't be dlpreopened + old_dlfiles="$dlfiles" + dlfiles= + for lib in $old_dlfiles; do + case " $dlprefiles $dlfiles " in + *" $lib "*) ;; + *) func_append dlfiles " $lib" ;; + esac + done + + # Make sure dlprefiles contains only unique files + old_dlprefiles="$dlprefiles" + dlprefiles= + for lib in $old_dlprefiles; do + case "$dlprefiles " in + *" $lib "*) ;; + *) func_append dlprefiles " $lib" ;; + esac + done + + if test "$build_libtool_libs" = yes; then + if test -n "$rpath"; then + case $host in + *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos* | *-cegcc* | *-*-haiku*) + # these systems don't actually have a c library (as such)! + ;; + *-*-rhapsody* | *-*-darwin1.[012]) + # Rhapsody C library is in the System framework + func_append deplibs " System.ltframework" + ;; + *-*-netbsd*) + # Don't link with libc until the a.out ld.so is fixed. + ;; + *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*) + # Do not include libc due to us having libc/libc_r. + ;; + *-*-sco3.2v5* | *-*-sco5v6*) + # Causes problems with __ctype + ;; + *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*) + # Compiler inserts libc in the correct place for threads to work + ;; + *) + # Add libc to deplibs on all other systems if necessary. + if test "$build_libtool_need_lc" = "yes"; then + func_append deplibs " -lc" + fi + ;; + esac + fi + + # Transform deplibs into only deplibs that can be linked in shared. + name_save=$name + libname_save=$libname + release_save=$release + versuffix_save=$versuffix + major_save=$major + # I'm not sure if I'm treating the release correctly. I think + # release should show up in the -l (ie -lgmp5) so we don't want to + # add it in twice. Is that correct? + release="" + versuffix="" + major="" + newdeplibs= + droppeddeps=no + case $deplibs_check_method in + pass_all) + # Don't check for shared/static. Everything works. + # This might be a little naive. We might want to check + # whether the library exists or not. But this is on + # osf3 & osf4 and I'm not really sure... Just + # implementing what was already the behavior. + newdeplibs=$deplibs + ;; + test_compile) + # This code stresses the "libraries are programs" paradigm to its + # limits. Maybe even breaks it. We compile a program, linking it + # against the deplibs as a proxy for the library. Then we can check + # whether they linked in statically or dynamically with ldd. + $opt_dry_run || $RM conftest.c + cat > conftest.c </dev/null` + $nocaseglob + else + potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null` + fi + for potent_lib in $potential_libs; do + # Follow soft links. + if ls -lLd "$potent_lib" 2>/dev/null | + $GREP " -> " >/dev/null; then + continue + fi + # The statement above tries to avoid entering an + # endless loop below, in case of cyclic links. + # We might still enter an endless loop, since a link + # loop can be closed while we follow links, + # but so what? + potlib="$potent_lib" + while test -h "$potlib" 2>/dev/null; do + potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'` + case $potliblink in + [\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";; + *) potlib=`$ECHO "$potlib" | $SED 's,[^/]*$,,'`"$potliblink";; + esac + done + if eval $file_magic_cmd \"\$potlib\" 2>/dev/null | + $SED -e 10q | + $EGREP "$file_magic_regex" > /dev/null; then + func_append newdeplibs " $a_deplib" + a_deplib="" + break 2 + fi + done + done + fi + if test -n "$a_deplib" ; then + droppeddeps=yes + echo + $ECHO "*** Warning: linker path does not have real file for library $a_deplib." + echo "*** I have the capability to make that library automatically link in when" + echo "*** you link to this library. But I can only do this if you have a" + echo "*** shared version of the library, which you do not appear to have" + echo "*** because I did check the linker path looking for a file starting" + if test -z "$potlib" ; then + $ECHO "*** with $libname but no candidates were found. (...for file magic test)" + else + $ECHO "*** with $libname and none of the candidates passed a file format test" + $ECHO "*** using a file magic. Last file checked: $potlib" + fi + fi + ;; + *) + # Add a -L argument. + func_append newdeplibs " $a_deplib" + ;; + esac + done # Gone through all deplibs. + ;; + match_pattern*) + set dummy $deplibs_check_method; shift + match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"` + for a_deplib in $deplibs; do + case $a_deplib in + -l*) + func_stripname -l '' "$a_deplib" + name=$func_stripname_result + if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then + case " $predeps $postdeps " in + *" $a_deplib "*) + func_append newdeplibs " $a_deplib" + a_deplib="" + ;; + esac + fi + if test -n "$a_deplib" ; then + libname=`eval "\\$ECHO \"$libname_spec\""` + for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do + potential_libs=`ls $i/$libname[.-]* 2>/dev/null` + for potent_lib in $potential_libs; do + potlib="$potent_lib" # see symlink-check above in file_magic test + if eval "\$ECHO \"$potent_lib\"" 2>/dev/null | $SED 10q | \ + $EGREP "$match_pattern_regex" > /dev/null; then + func_append newdeplibs " $a_deplib" + a_deplib="" + break 2 + fi + done + done + fi + if test -n "$a_deplib" ; then + droppeddeps=yes + echo + $ECHO "*** Warning: linker path does not have real file for library $a_deplib." + echo "*** I have the capability to make that library automatically link in when" + echo "*** you link to this library. But I can only do this if you have a" + echo "*** shared version of the library, which you do not appear to have" + echo "*** because I did check the linker path looking for a file starting" + if test -z "$potlib" ; then + $ECHO "*** with $libname but no candidates were found. (...for regex pattern test)" + else + $ECHO "*** with $libname and none of the candidates passed a file format test" + $ECHO "*** using a regex pattern. Last file checked: $potlib" + fi + fi + ;; + *) + # Add a -L argument. + func_append newdeplibs " $a_deplib" + ;; + esac + done # Gone through all deplibs. + ;; + none | unknown | *) + newdeplibs="" + tmp_deplibs=`$ECHO " $deplibs" | $SED 's/ -lc$//; s/ -[LR][^ ]*//g'` + if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then + for i in $predeps $postdeps ; do + # can't use Xsed below, because $i might contain '/' + tmp_deplibs=`$ECHO " $tmp_deplibs" | $SED "s,$i,,"` + done + fi + case $tmp_deplibs in + *[!\ \ ]*) + echo + if test "X$deplibs_check_method" = "Xnone"; then + echo "*** Warning: inter-library dependencies are not supported in this platform." + else + echo "*** Warning: inter-library dependencies are not known to be supported." + fi + echo "*** All declared inter-library dependencies are being dropped." + droppeddeps=yes + ;; + esac + ;; + esac + versuffix=$versuffix_save + major=$major_save + release=$release_save + libname=$libname_save + name=$name_save + + case $host in + *-*-rhapsody* | *-*-darwin1.[012]) + # On Rhapsody replace the C library with the System framework + newdeplibs=`$ECHO " $newdeplibs" | $SED 's/ -lc / System.ltframework /'` + ;; + esac + + if test "$droppeddeps" = yes; then + if test "$module" = yes; then + echo + echo "*** Warning: libtool could not satisfy all declared inter-library" + $ECHO "*** dependencies of module $libname. Therefore, libtool will create" + echo "*** a static module, that should work as long as the dlopening" + echo "*** application is linked with the -dlopen flag." + if test -z "$global_symbol_pipe"; then + echo + echo "*** However, this would only work if libtool was able to extract symbol" + echo "*** lists from a program, using \`nm' or equivalent, but libtool could" + echo "*** not find such a program. So, this module is probably useless." + echo "*** \`nm' from GNU binutils and a full rebuild may help." + fi + if test "$build_old_libs" = no; then + oldlibs="$output_objdir/$libname.$libext" + build_libtool_libs=module + build_old_libs=yes + else + build_libtool_libs=no + fi + else + echo "*** The inter-library dependencies that have been dropped here will be" + echo "*** automatically added whenever a program is linked with this library" + echo "*** or is declared to -dlopen it." + + if test "$allow_undefined" = no; then + echo + echo "*** Since this library must not contain undefined symbols," + echo "*** because either the platform does not support them or" + echo "*** it was explicitly requested with -no-undefined," + echo "*** libtool will only create a static version of it." + if test "$build_old_libs" = no; then + oldlibs="$output_objdir/$libname.$libext" + build_libtool_libs=module + build_old_libs=yes + else + build_libtool_libs=no + fi + fi + fi + fi + # Done checking deplibs! + deplibs=$newdeplibs + fi + # Time to change all our "foo.ltframework" stuff back to "-framework foo" + case $host in + *-*-darwin*) + newdeplibs=`$ECHO " $newdeplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'` + new_inherited_linker_flags=`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'` + deplibs=`$ECHO " $deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'` + ;; + esac + + # move library search paths that coincide with paths to not yet + # installed libraries to the beginning of the library search list + new_libs= + for path in $notinst_path; do + case " $new_libs " in + *" -L$path/$objdir "*) ;; + *) + case " $deplibs " in + *" -L$path/$objdir "*) + func_append new_libs " -L$path/$objdir" ;; + esac + ;; + esac + done + for deplib in $deplibs; do + case $deplib in + -L*) + case " $new_libs " in + *" $deplib "*) ;; + *) func_append new_libs " $deplib" ;; + esac + ;; + *) func_append new_libs " $deplib" ;; + esac + done + deplibs="$new_libs" + + # All the library-specific variables (install_libdir is set above). + library_names= + old_library= + dlname= + + # Test again, we may have decided not to build it any more + if test "$build_libtool_libs" = yes; then + # Remove ${wl} instances when linking with ld. + # FIXME: should test the right _cmds variable. + case $archive_cmds in + *\$LD\ *) wl= ;; + esac + if test "$hardcode_into_libs" = yes; then + # Hardcode the library paths + hardcode_libdirs= + dep_rpath= + rpath="$finalize_rpath" + test "$opt_mode" != relink && rpath="$compile_rpath$rpath" + for libdir in $rpath; do + if test -n "$hardcode_libdir_flag_spec"; then + if test -n "$hardcode_libdir_separator"; then + func_replace_sysroot "$libdir" + libdir=$func_replace_sysroot_result + if test -z "$hardcode_libdirs"; then + hardcode_libdirs="$libdir" + else + # Just accumulate the unique libdirs. + case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in + *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*) + ;; + *) + func_append hardcode_libdirs "$hardcode_libdir_separator$libdir" + ;; + esac + fi + else + eval flag=\"$hardcode_libdir_flag_spec\" + func_append dep_rpath " $flag" + fi + elif test -n "$runpath_var"; then + case "$perm_rpath " in + *" $libdir "*) ;; + *) func_append perm_rpath " $libdir" ;; + esac + fi + done + # Substitute the hardcoded libdirs into the rpath. + if test -n "$hardcode_libdir_separator" && + test -n "$hardcode_libdirs"; then + libdir="$hardcode_libdirs" + eval "dep_rpath=\"$hardcode_libdir_flag_spec\"" + fi + if test -n "$runpath_var" && test -n "$perm_rpath"; then + # We should set the runpath_var. + rpath= + for dir in $perm_rpath; do + func_append rpath "$dir:" + done + eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var" + fi + test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs" + fi + + shlibpath="$finalize_shlibpath" + test "$opt_mode" != relink && shlibpath="$compile_shlibpath$shlibpath" + if test -n "$shlibpath"; then + eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var" + fi + + # Get the real and link names of the library. + eval shared_ext=\"$shrext_cmds\" + eval library_names=\"$library_names_spec\" + set dummy $library_names + shift + realname="$1" + shift + + if test -n "$soname_spec"; then + eval soname=\"$soname_spec\" + else + soname="$realname" + fi + if test -z "$dlname"; then + dlname=$soname + fi + + lib="$output_objdir/$realname" + linknames= + for link + do + func_append linknames " $link" + done + + # Use standard objects if they are pic + test -z "$pic_flag" && libobjs=`$ECHO "$libobjs" | $SP2NL | $SED "$lo2o" | $NL2SP` + test "X$libobjs" = "X " && libobjs= + + delfiles= + if test -n "$export_symbols" && test -n "$include_expsyms"; then + $opt_dry_run || cp "$export_symbols" "$output_objdir/$libname.uexp" + export_symbols="$output_objdir/$libname.uexp" + func_append delfiles " $export_symbols" + fi + + orig_export_symbols= + case $host_os in + cygwin* | mingw* | cegcc*) + if test -n "$export_symbols" && test -z "$export_symbols_regex"; then + # exporting using user supplied symfile + if test "x`$SED 1q $export_symbols`" != xEXPORTS; then + # and it's NOT already a .def file. Must figure out + # which of the given symbols are data symbols and tag + # them as such. So, trigger use of export_symbols_cmds. + # export_symbols gets reassigned inside the "prepare + # the list of exported symbols" if statement, so the + # include_expsyms logic still works. + orig_export_symbols="$export_symbols" + export_symbols= + always_export_symbols=yes + fi + fi + ;; + esac + + # Prepare the list of exported symbols + if test -z "$export_symbols"; then + if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then + func_verbose "generating symbol list for \`$libname.la'" + export_symbols="$output_objdir/$libname.exp" + $opt_dry_run || $RM $export_symbols + cmds=$export_symbols_cmds + save_ifs="$IFS"; IFS='~' + for cmd1 in $cmds; do + IFS="$save_ifs" + # Take the normal branch if the nm_file_list_spec branch + # doesn't work or if tool conversion is not needed. + case $nm_file_list_spec~$to_tool_file_cmd in + *~func_convert_file_noop | *~func_convert_file_msys_to_w32 | ~*) + try_normal_branch=yes + eval cmd=\"$cmd1\" + func_len " $cmd" + len=$func_len_result + ;; + *) + try_normal_branch=no + ;; + esac + if test "$try_normal_branch" = yes \ + && { test "$len" -lt "$max_cmd_len" \ + || test "$max_cmd_len" -le -1; } + then + func_show_eval "$cmd" 'exit $?' + skipped_export=false + elif test -n "$nm_file_list_spec"; then + func_basename "$output" + output_la=$func_basename_result + save_libobjs=$libobjs + save_output=$output + output=${output_objdir}/${output_la}.nm + func_to_tool_file "$output" + libobjs=$nm_file_list_spec$func_to_tool_file_result + func_append delfiles " $output" + func_verbose "creating $NM input file list: $output" + for obj in $save_libobjs; do + func_to_tool_file "$obj" + $ECHO "$func_to_tool_file_result" + done > "$output" + eval cmd=\"$cmd1\" + func_show_eval "$cmd" 'exit $?' + output=$save_output + libobjs=$save_libobjs + skipped_export=false + else + # The command line is too long to execute in one step. + func_verbose "using reloadable object file for export list..." + skipped_export=: + # Break out early, otherwise skipped_export may be + # set to false by a later but shorter cmd. + break + fi + done + IFS="$save_ifs" + if test -n "$export_symbols_regex" && test "X$skipped_export" != "X:"; then + func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"' + func_show_eval '$MV "${export_symbols}T" "$export_symbols"' + fi + fi + fi + + if test -n "$export_symbols" && test -n "$include_expsyms"; then + tmp_export_symbols="$export_symbols" + test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols" + $opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"' + fi + + if test "X$skipped_export" != "X:" && test -n "$orig_export_symbols"; then + # The given exports_symbols file has to be filtered, so filter it. + func_verbose "filter symbol list for \`$libname.la' to tag DATA exports" + # FIXME: $output_objdir/$libname.filter potentially contains lots of + # 's' commands which not all seds can handle. GNU sed should be fine + # though. Also, the filter scales superlinearly with the number of + # global variables. join(1) would be nice here, but unfortunately + # isn't a blessed tool. + $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter + func_append delfiles " $export_symbols $output_objdir/$libname.filter" + export_symbols=$output_objdir/$libname.def + $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols + fi + + tmp_deplibs= + for test_deplib in $deplibs; do + case " $convenience " in + *" $test_deplib "*) ;; + *) + func_append tmp_deplibs " $test_deplib" + ;; + esac + done + deplibs="$tmp_deplibs" + + if test -n "$convenience"; then + if test -n "$whole_archive_flag_spec" && + test "$compiler_needs_object" = yes && + test -z "$libobjs"; then + # extract the archives, so we have objects to list. + # TODO: could optimize this to just extract one archive. + whole_archive_flag_spec= + fi + if test -n "$whole_archive_flag_spec"; then + save_libobjs=$libobjs + eval libobjs=\"\$libobjs $whole_archive_flag_spec\" + test "X$libobjs" = "X " && libobjs= + else + gentop="$output_objdir/${outputname}x" + func_append generated " $gentop" + + func_extract_archives $gentop $convenience + func_append libobjs " $func_extract_archives_result" + test "X$libobjs" = "X " && libobjs= + fi + fi + + if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then + eval flag=\"$thread_safe_flag_spec\" + func_append linker_flags " $flag" + fi + + # Make a backup of the uninstalled library when relinking + if test "$opt_mode" = relink; then + $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}U && $MV $realname ${realname}U)' || exit $? + fi + + # Do each of the archive commands. + if test "$module" = yes && test -n "$module_cmds" ; then + if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then + eval test_cmds=\"$module_expsym_cmds\" + cmds=$module_expsym_cmds + else + eval test_cmds=\"$module_cmds\" + cmds=$module_cmds + fi + else + if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then + eval test_cmds=\"$archive_expsym_cmds\" + cmds=$archive_expsym_cmds + else + eval test_cmds=\"$archive_cmds\" + cmds=$archive_cmds + fi + fi + + if test "X$skipped_export" != "X:" && + func_len " $test_cmds" && + len=$func_len_result && + test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then + : + else + # The command line is too long to link in one step, link piecewise + # or, if using GNU ld and skipped_export is not :, use a linker + # script. + + # Save the value of $output and $libobjs because we want to + # use them later. If we have whole_archive_flag_spec, we + # want to use save_libobjs as it was before + # whole_archive_flag_spec was expanded, because we can't + # assume the linker understands whole_archive_flag_spec. + # This may have to be revisited, in case too many + # convenience libraries get linked in and end up exceeding + # the spec. + if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then + save_libobjs=$libobjs + fi + save_output=$output + func_basename "$output" + output_la=$func_basename_result + + # Clear the reloadable object creation command queue and + # initialize k to one. + test_cmds= + concat_cmds= + objlist= + last_robj= + k=1 + + if test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "$with_gnu_ld" = yes; then + output=${output_objdir}/${output_la}.lnkscript + func_verbose "creating GNU ld script: $output" + echo 'INPUT (' > $output + for obj in $save_libobjs + do + func_to_tool_file "$obj" + $ECHO "$func_to_tool_file_result" >> $output + done + echo ')' >> $output + func_append delfiles " $output" + func_to_tool_file "$output" + output=$func_to_tool_file_result + elif test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "X$file_list_spec" != X; then + output=${output_objdir}/${output_la}.lnk + func_verbose "creating linker input file list: $output" + : > $output + set x $save_libobjs + shift + firstobj= + if test "$compiler_needs_object" = yes; then + firstobj="$1 " + shift + fi + for obj + do + func_to_tool_file "$obj" + $ECHO "$func_to_tool_file_result" >> $output + done + func_append delfiles " $output" + func_to_tool_file "$output" + output=$firstobj\"$file_list_spec$func_to_tool_file_result\" + else + if test -n "$save_libobjs"; then + func_verbose "creating reloadable object files..." + output=$output_objdir/$output_la-${k}.$objext + eval test_cmds=\"$reload_cmds\" + func_len " $test_cmds" + len0=$func_len_result + len=$len0 + + # Loop over the list of objects to be linked. + for obj in $save_libobjs + do + func_len " $obj" + func_arith $len + $func_len_result + len=$func_arith_result + if test "X$objlist" = X || + test "$len" -lt "$max_cmd_len"; then + func_append objlist " $obj" + else + # The command $test_cmds is almost too long, add a + # command to the queue. + if test "$k" -eq 1 ; then + # The first file doesn't have a previous command to add. + reload_objs=$objlist + eval concat_cmds=\"$reload_cmds\" + else + # All subsequent reloadable object files will link in + # the last one created. + reload_objs="$objlist $last_robj" + eval concat_cmds=\"\$concat_cmds~$reload_cmds~\$RM $last_robj\" + fi + last_robj=$output_objdir/$output_la-${k}.$objext + func_arith $k + 1 + k=$func_arith_result + output=$output_objdir/$output_la-${k}.$objext + objlist=" $obj" + func_len " $last_robj" + func_arith $len0 + $func_len_result + len=$func_arith_result + fi + done + # Handle the remaining objects by creating one last + # reloadable object file. All subsequent reloadable object + # files will link in the last one created. + test -z "$concat_cmds" || concat_cmds=$concat_cmds~ + reload_objs="$objlist $last_robj" + eval concat_cmds=\"\${concat_cmds}$reload_cmds\" + if test -n "$last_robj"; then + eval concat_cmds=\"\${concat_cmds}~\$RM $last_robj\" + fi + func_append delfiles " $output" + + else + output= + fi + + if ${skipped_export-false}; then + func_verbose "generating symbol list for \`$libname.la'" + export_symbols="$output_objdir/$libname.exp" + $opt_dry_run || $RM $export_symbols + libobjs=$output + # Append the command to create the export file. + test -z "$concat_cmds" || concat_cmds=$concat_cmds~ + eval concat_cmds=\"\$concat_cmds$export_symbols_cmds\" + if test -n "$last_robj"; then + eval concat_cmds=\"\$concat_cmds~\$RM $last_robj\" + fi + fi + + test -n "$save_libobjs" && + func_verbose "creating a temporary reloadable object file: $output" + + # Loop through the commands generated above and execute them. + save_ifs="$IFS"; IFS='~' + for cmd in $concat_cmds; do + IFS="$save_ifs" + $opt_silent || { + func_quote_for_expand "$cmd" + eval "func_echo $func_quote_for_expand_result" + } + $opt_dry_run || eval "$cmd" || { + lt_exit=$? + + # Restore the uninstalled library and exit + if test "$opt_mode" = relink; then + ( cd "$output_objdir" && \ + $RM "${realname}T" && \ + $MV "${realname}U" "$realname" ) + fi + + exit $lt_exit + } + done + IFS="$save_ifs" + + if test -n "$export_symbols_regex" && ${skipped_export-false}; then + func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"' + func_show_eval '$MV "${export_symbols}T" "$export_symbols"' + fi + fi + + if ${skipped_export-false}; then + if test -n "$export_symbols" && test -n "$include_expsyms"; then + tmp_export_symbols="$export_symbols" + test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols" + $opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"' + fi + + if test -n "$orig_export_symbols"; then + # The given exports_symbols file has to be filtered, so filter it. + func_verbose "filter symbol list for \`$libname.la' to tag DATA exports" + # FIXME: $output_objdir/$libname.filter potentially contains lots of + # 's' commands which not all seds can handle. GNU sed should be fine + # though. Also, the filter scales superlinearly with the number of + # global variables. join(1) would be nice here, but unfortunately + # isn't a blessed tool. + $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter + func_append delfiles " $export_symbols $output_objdir/$libname.filter" + export_symbols=$output_objdir/$libname.def + $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols + fi + fi + + libobjs=$output + # Restore the value of output. + output=$save_output + + if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then + eval libobjs=\"\$libobjs $whole_archive_flag_spec\" + test "X$libobjs" = "X " && libobjs= + fi + # Expand the library linking commands again to reset the + # value of $libobjs for piecewise linking. + + # Do each of the archive commands. + if test "$module" = yes && test -n "$module_cmds" ; then + if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then + cmds=$module_expsym_cmds + else + cmds=$module_cmds + fi + else + if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then + cmds=$archive_expsym_cmds + else + cmds=$archive_cmds + fi + fi + fi + + if test -n "$delfiles"; then + # Append the command to remove temporary files to $cmds. + eval cmds=\"\$cmds~\$RM $delfiles\" + fi + + # Add any objects from preloaded convenience libraries + if test -n "$dlprefiles"; then + gentop="$output_objdir/${outputname}x" + func_append generated " $gentop" + + func_extract_archives $gentop $dlprefiles + func_append libobjs " $func_extract_archives_result" + test "X$libobjs" = "X " && libobjs= + fi + + save_ifs="$IFS"; IFS='~' + for cmd in $cmds; do + IFS="$save_ifs" + eval cmd=\"$cmd\" + $opt_silent || { + func_quote_for_expand "$cmd" + eval "func_echo $func_quote_for_expand_result" + } + $opt_dry_run || eval "$cmd" || { + lt_exit=$? + + # Restore the uninstalled library and exit + if test "$opt_mode" = relink; then + ( cd "$output_objdir" && \ + $RM "${realname}T" && \ + $MV "${realname}U" "$realname" ) + fi + + exit $lt_exit + } + done + IFS="$save_ifs" + + # Restore the uninstalled library and exit + if test "$opt_mode" = relink; then + $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}T && $MV $realname ${realname}T && $MV ${realname}U $realname)' || exit $? + + if test -n "$convenience"; then + if test -z "$whole_archive_flag_spec"; then + func_show_eval '${RM}r "$gentop"' + fi + fi + + exit $EXIT_SUCCESS + fi + + # Create links to the real library. + for linkname in $linknames; do + if test "$realname" != "$linkname"; then + func_show_eval '(cd "$output_objdir" && $RM "$linkname" && $LN_S "$realname" "$linkname")' 'exit $?' + fi + done + + # If -module or -export-dynamic was specified, set the dlname. + if test "$module" = yes || test "$export_dynamic" = yes; then + # On all known operating systems, these are identical. + dlname="$soname" + fi + fi + ;; + + obj) + if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then + func_warning "\`-dlopen' is ignored for objects" + fi + + case " $deplibs" in + *\ -l* | *\ -L*) + func_warning "\`-l' and \`-L' are ignored for objects" ;; + esac + + test -n "$rpath" && \ + func_warning "\`-rpath' is ignored for objects" + + test -n "$xrpath" && \ + func_warning "\`-R' is ignored for objects" + + test -n "$vinfo" && \ + func_warning "\`-version-info' is ignored for objects" + + test -n "$release" && \ + func_warning "\`-release' is ignored for objects" + + case $output in + *.lo) + test -n "$objs$old_deplibs" && \ + func_fatal_error "cannot build library object \`$output' from non-libtool objects" + + libobj=$output + func_lo2o "$libobj" + obj=$func_lo2o_result + ;; + *) + libobj= + obj="$output" + ;; + esac + + # Delete the old objects. + $opt_dry_run || $RM $obj $libobj + + # Objects from convenience libraries. This assumes + # single-version convenience libraries. Whenever we create + # different ones for PIC/non-PIC, this we'll have to duplicate + # the extraction. + reload_conv_objs= + gentop= + # reload_cmds runs $LD directly, so let us get rid of + # -Wl from whole_archive_flag_spec and hope we can get by with + # turning comma into space.. + wl= + + if test -n "$convenience"; then + if test -n "$whole_archive_flag_spec"; then + eval tmp_whole_archive_flags=\"$whole_archive_flag_spec\" + reload_conv_objs=$reload_objs\ `$ECHO "$tmp_whole_archive_flags" | $SED 's|,| |g'` + else + gentop="$output_objdir/${obj}x" + func_append generated " $gentop" + + func_extract_archives $gentop $convenience + reload_conv_objs="$reload_objs $func_extract_archives_result" + fi + fi + + # If we're not building shared, we need to use non_pic_objs + test "$build_libtool_libs" != yes && libobjs="$non_pic_objects" + + # Create the old-style object. + reload_objs="$objs$old_deplibs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; /\.lib$/d; $lo2o" | $NL2SP`" $reload_conv_objs" ### testsuite: skip nested quoting test + + output="$obj" + func_execute_cmds "$reload_cmds" 'exit $?' + + # Exit if we aren't doing a library object file. + if test -z "$libobj"; then + if test -n "$gentop"; then + func_show_eval '${RM}r "$gentop"' + fi + + exit $EXIT_SUCCESS + fi + + if test "$build_libtool_libs" != yes; then + if test -n "$gentop"; then + func_show_eval '${RM}r "$gentop"' + fi + + # Create an invalid libtool object if no PIC, so that we don't + # accidentally link it into a program. + # $show "echo timestamp > $libobj" + # $opt_dry_run || eval "echo timestamp > $libobj" || exit $? + exit $EXIT_SUCCESS + fi + + if test -n "$pic_flag" || test "$pic_mode" != default; then + # Only do commands if we really have different PIC objects. + reload_objs="$libobjs $reload_conv_objs" + output="$libobj" + func_execute_cmds "$reload_cmds" 'exit $?' + fi + + if test -n "$gentop"; then + func_show_eval '${RM}r "$gentop"' + fi + + exit $EXIT_SUCCESS + ;; + + prog) + case $host in + *cygwin*) func_stripname '' '.exe' "$output" + output=$func_stripname_result.exe;; + esac + test -n "$vinfo" && \ + func_warning "\`-version-info' is ignored for programs" + + test -n "$release" && \ + func_warning "\`-release' is ignored for programs" + + test "$preload" = yes \ + && test "$dlopen_support" = unknown \ + && test "$dlopen_self" = unknown \ + && test "$dlopen_self_static" = unknown && \ + func_warning "\`LT_INIT([dlopen])' not used. Assuming no dlopen support." + + case $host in + *-*-rhapsody* | *-*-darwin1.[012]) + # On Rhapsody replace the C library is the System framework + compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's/ -lc / System.ltframework /'` + finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's/ -lc / System.ltframework /'` + ;; + esac + + case $host in + *-*-darwin*) + # Don't allow lazy linking, it breaks C++ global constructors + # But is supposedly fixed on 10.4 or later (yay!). + if test "$tagname" = CXX ; then + case ${MACOSX_DEPLOYMENT_TARGET-10.0} in + 10.[0123]) + func_append compile_command " ${wl}-bind_at_load" + func_append finalize_command " ${wl}-bind_at_load" + ;; + esac + fi + # Time to change all our "foo.ltframework" stuff back to "-framework foo" + compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'` + finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'` + ;; + esac + + + # move library search paths that coincide with paths to not yet + # installed libraries to the beginning of the library search list + new_libs= + for path in $notinst_path; do + case " $new_libs " in + *" -L$path/$objdir "*) ;; + *) + case " $compile_deplibs " in + *" -L$path/$objdir "*) + func_append new_libs " -L$path/$objdir" ;; + esac + ;; + esac + done + for deplib in $compile_deplibs; do + case $deplib in + -L*) + case " $new_libs " in + *" $deplib "*) ;; + *) func_append new_libs " $deplib" ;; + esac + ;; + *) func_append new_libs " $deplib" ;; + esac + done + compile_deplibs="$new_libs" + + + func_append compile_command " $compile_deplibs" + func_append finalize_command " $finalize_deplibs" + + if test -n "$rpath$xrpath"; then + # If the user specified any rpath flags, then add them. + for libdir in $rpath $xrpath; do + # This is the magic to use -rpath. + case "$finalize_rpath " in + *" $libdir "*) ;; + *) func_append finalize_rpath " $libdir" ;; + esac + done + fi + + # Now hardcode the library paths + rpath= + hardcode_libdirs= + for libdir in $compile_rpath $finalize_rpath; do + if test -n "$hardcode_libdir_flag_spec"; then + if test -n "$hardcode_libdir_separator"; then + if test -z "$hardcode_libdirs"; then + hardcode_libdirs="$libdir" + else + # Just accumulate the unique libdirs. + case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in + *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*) + ;; + *) + func_append hardcode_libdirs "$hardcode_libdir_separator$libdir" + ;; + esac + fi + else + eval flag=\"$hardcode_libdir_flag_spec\" + func_append rpath " $flag" + fi + elif test -n "$runpath_var"; then + case "$perm_rpath " in + *" $libdir "*) ;; + *) func_append perm_rpath " $libdir" ;; + esac + fi + case $host in + *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*) + testbindir=`${ECHO} "$libdir" | ${SED} -e 's*/lib$*/bin*'` + case :$dllsearchpath: in + *":$libdir:"*) ;; + ::) dllsearchpath=$libdir;; + *) func_append dllsearchpath ":$libdir";; + esac + case :$dllsearchpath: in + *":$testbindir:"*) ;; + ::) dllsearchpath=$testbindir;; + *) func_append dllsearchpath ":$testbindir";; + esac + ;; + esac + done + # Substitute the hardcoded libdirs into the rpath. + if test -n "$hardcode_libdir_separator" && + test -n "$hardcode_libdirs"; then + libdir="$hardcode_libdirs" + eval rpath=\" $hardcode_libdir_flag_spec\" + fi + compile_rpath="$rpath" + + rpath= + hardcode_libdirs= + for libdir in $finalize_rpath; do + if test -n "$hardcode_libdir_flag_spec"; then + if test -n "$hardcode_libdir_separator"; then + if test -z "$hardcode_libdirs"; then + hardcode_libdirs="$libdir" + else + # Just accumulate the unique libdirs. + case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in + *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*) + ;; + *) + func_append hardcode_libdirs "$hardcode_libdir_separator$libdir" + ;; + esac + fi + else + eval flag=\"$hardcode_libdir_flag_spec\" + func_append rpath " $flag" + fi + elif test -n "$runpath_var"; then + case "$finalize_perm_rpath " in + *" $libdir "*) ;; + *) func_append finalize_perm_rpath " $libdir" ;; + esac + fi + done + # Substitute the hardcoded libdirs into the rpath. + if test -n "$hardcode_libdir_separator" && + test -n "$hardcode_libdirs"; then + libdir="$hardcode_libdirs" + eval rpath=\" $hardcode_libdir_flag_spec\" + fi + finalize_rpath="$rpath" + + if test -n "$libobjs" && test "$build_old_libs" = yes; then + # Transform all the library objects into standard objects. + compile_command=`$ECHO "$compile_command" | $SP2NL | $SED "$lo2o" | $NL2SP` + finalize_command=`$ECHO "$finalize_command" | $SP2NL | $SED "$lo2o" | $NL2SP` + fi + + func_generate_dlsyms "$outputname" "@PROGRAM@" "no" + + # template prelinking step + if test -n "$prelink_cmds"; then + func_execute_cmds "$prelink_cmds" 'exit $?' + fi + + wrappers_required=yes + case $host in + *cegcc* | *mingw32ce*) + # Disable wrappers for cegcc and mingw32ce hosts, we are cross compiling anyway. + wrappers_required=no + ;; + *cygwin* | *mingw* ) + if test "$build_libtool_libs" != yes; then + wrappers_required=no + fi + ;; + *) + if test "$need_relink" = no || test "$build_libtool_libs" != yes; then + wrappers_required=no + fi + ;; + esac + if test "$wrappers_required" = no; then + # Replace the output file specification. + compile_command=`$ECHO "$compile_command" | $SED 's%@OUTPUT@%'"$output"'%g'` + link_command="$compile_command$compile_rpath" + + # We have no uninstalled library dependencies, so finalize right now. + exit_status=0 + func_show_eval "$link_command" 'exit_status=$?' + + if test -n "$postlink_cmds"; then + func_to_tool_file "$output" + postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'` + func_execute_cmds "$postlink_cmds" 'exit $?' + fi + + # Delete the generated files. + if test -f "$output_objdir/${outputname}S.${objext}"; then + func_show_eval '$RM "$output_objdir/${outputname}S.${objext}"' + fi + + exit $exit_status + fi + + if test -n "$compile_shlibpath$finalize_shlibpath"; then + compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command" + fi + if test -n "$finalize_shlibpath"; then + finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command" + fi + + compile_var= + finalize_var= + if test -n "$runpath_var"; then + if test -n "$perm_rpath"; then + # We should set the runpath_var. + rpath= + for dir in $perm_rpath; do + func_append rpath "$dir:" + done + compile_var="$runpath_var=\"$rpath\$$runpath_var\" " + fi + if test -n "$finalize_perm_rpath"; then + # We should set the runpath_var. + rpath= + for dir in $finalize_perm_rpath; do + func_append rpath "$dir:" + done + finalize_var="$runpath_var=\"$rpath\$$runpath_var\" " + fi + fi + + if test "$no_install" = yes; then + # We don't need to create a wrapper script. + link_command="$compile_var$compile_command$compile_rpath" + # Replace the output file specification. + link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output"'%g'` + # Delete the old output file. + $opt_dry_run || $RM $output + # Link the executable and exit + func_show_eval "$link_command" 'exit $?' + + if test -n "$postlink_cmds"; then + func_to_tool_file "$output" + postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'` + func_execute_cmds "$postlink_cmds" 'exit $?' + fi + + exit $EXIT_SUCCESS + fi + + if test "$hardcode_action" = relink; then + # Fast installation is not supported + link_command="$compile_var$compile_command$compile_rpath" + relink_command="$finalize_var$finalize_command$finalize_rpath" + + func_warning "this platform does not like uninstalled shared libraries" + func_warning "\`$output' will be relinked during installation" + else + if test "$fast_install" != no; then + link_command="$finalize_var$compile_command$finalize_rpath" + if test "$fast_install" = yes; then + relink_command=`$ECHO "$compile_var$compile_command$compile_rpath" | $SED 's%@OUTPUT@%\$progdir/\$file%g'` + else + # fast_install is set to needless + relink_command= + fi + else + link_command="$compile_var$compile_command$compile_rpath" + relink_command="$finalize_var$finalize_command$finalize_rpath" + fi + fi + + # Replace the output file specification. + link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'` + + # Delete the old output files. + $opt_dry_run || $RM $output $output_objdir/$outputname $output_objdir/lt-$outputname + + func_show_eval "$link_command" 'exit $?' + + if test -n "$postlink_cmds"; then + func_to_tool_file "$output_objdir/$outputname" + postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'` + func_execute_cmds "$postlink_cmds" 'exit $?' + fi + + # Now create the wrapper script. + func_verbose "creating $output" + + # Quote the relink command for shipping. + if test -n "$relink_command"; then + # Preserve any variables that may affect compiler behavior + for var in $variables_saved_for_relink; do + if eval test -z \"\${$var+set}\"; then + relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command" + elif eval var_value=\$$var; test -z "$var_value"; then + relink_command="$var=; export $var; $relink_command" + else + func_quote_for_eval "$var_value" + relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command" + fi + done + relink_command="(cd `pwd`; $relink_command)" + relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"` + fi + + # Only actually do things if not in dry run mode. + $opt_dry_run || { + # win32 will think the script is a binary if it has + # a .exe suffix, so we strip it off here. + case $output in + *.exe) func_stripname '' '.exe' "$output" + output=$func_stripname_result ;; + esac + # test for cygwin because mv fails w/o .exe extensions + case $host in + *cygwin*) + exeext=.exe + func_stripname '' '.exe' "$outputname" + outputname=$func_stripname_result ;; + *) exeext= ;; + esac + case $host in + *cygwin* | *mingw* ) + func_dirname_and_basename "$output" "" "." + output_name=$func_basename_result + output_path=$func_dirname_result + cwrappersource="$output_path/$objdir/lt-$output_name.c" + cwrapper="$output_path/$output_name.exe" + $RM $cwrappersource $cwrapper + trap "$RM $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15 + + func_emit_cwrapperexe_src > $cwrappersource + + # The wrapper executable is built using the $host compiler, + # because it contains $host paths and files. If cross- + # compiling, it, like the target executable, must be + # executed on the $host or under an emulation environment. + $opt_dry_run || { + $LTCC $LTCFLAGS -o $cwrapper $cwrappersource + $STRIP $cwrapper + } + + # Now, create the wrapper script for func_source use: + func_ltwrapper_scriptname $cwrapper + $RM $func_ltwrapper_scriptname_result + trap "$RM $func_ltwrapper_scriptname_result; exit $EXIT_FAILURE" 1 2 15 + $opt_dry_run || { + # note: this script will not be executed, so do not chmod. + if test "x$build" = "x$host" ; then + $cwrapper --lt-dump-script > $func_ltwrapper_scriptname_result + else + func_emit_wrapper no > $func_ltwrapper_scriptname_result + fi + } + ;; + * ) + $RM $output + trap "$RM $output; exit $EXIT_FAILURE" 1 2 15 + + func_emit_wrapper no > $output + chmod +x $output + ;; + esac + } + exit $EXIT_SUCCESS + ;; + esac + + # See if we need to build an old-fashioned archive. + for oldlib in $oldlibs; do + + if test "$build_libtool_libs" = convenience; then + oldobjs="$libobjs_save $symfileobj" + addlibs="$convenience" + build_libtool_libs=no + else + if test "$build_libtool_libs" = module; then + oldobjs="$libobjs_save" + build_libtool_libs=no + else + oldobjs="$old_deplibs $non_pic_objects" + if test "$preload" = yes && test -f "$symfileobj"; then + func_append oldobjs " $symfileobj" + fi + fi + addlibs="$old_convenience" + fi + + if test -n "$addlibs"; then + gentop="$output_objdir/${outputname}x" + func_append generated " $gentop" + + func_extract_archives $gentop $addlibs + func_append oldobjs " $func_extract_archives_result" + fi + + # Do each command in the archive commands. + if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then + cmds=$old_archive_from_new_cmds + else + + # Add any objects from preloaded convenience libraries + if test -n "$dlprefiles"; then + gentop="$output_objdir/${outputname}x" + func_append generated " $gentop" + + func_extract_archives $gentop $dlprefiles + func_append oldobjs " $func_extract_archives_result" + fi + + # POSIX demands no paths to be encoded in archives. We have + # to avoid creating archives with duplicate basenames if we + # might have to extract them afterwards, e.g., when creating a + # static archive out of a convenience library, or when linking + # the entirety of a libtool archive into another (currently + # not supported by libtool). + if (for obj in $oldobjs + do + func_basename "$obj" + $ECHO "$func_basename_result" + done | sort | sort -uc >/dev/null 2>&1); then + : + else + echo "copying selected object files to avoid basename conflicts..." + gentop="$output_objdir/${outputname}x" + func_append generated " $gentop" + func_mkdir_p "$gentop" + save_oldobjs=$oldobjs + oldobjs= + counter=1 + for obj in $save_oldobjs + do + func_basename "$obj" + objbase="$func_basename_result" + case " $oldobjs " in + " ") oldobjs=$obj ;; + *[\ /]"$objbase "*) + while :; do + # Make sure we don't pick an alternate name that also + # overlaps. + newobj=lt$counter-$objbase + func_arith $counter + 1 + counter=$func_arith_result + case " $oldobjs " in + *[\ /]"$newobj "*) ;; + *) if test ! -f "$gentop/$newobj"; then break; fi ;; + esac + done + func_show_eval "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj" + func_append oldobjs " $gentop/$newobj" + ;; + *) func_append oldobjs " $obj" ;; + esac + done + fi + func_to_tool_file "$oldlib" func_convert_file_msys_to_w32 + tool_oldlib=$func_to_tool_file_result + eval cmds=\"$old_archive_cmds\" + + func_len " $cmds" + len=$func_len_result + if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then + cmds=$old_archive_cmds + elif test -n "$archiver_list_spec"; then + func_verbose "using command file archive linking..." + for obj in $oldobjs + do + func_to_tool_file "$obj" + $ECHO "$func_to_tool_file_result" + done > $output_objdir/$libname.libcmd + func_to_tool_file "$output_objdir/$libname.libcmd" + oldobjs=" $archiver_list_spec$func_to_tool_file_result" + cmds=$old_archive_cmds + else + # the command line is too long to link in one step, link in parts + func_verbose "using piecewise archive linking..." + save_RANLIB=$RANLIB + RANLIB=: + objlist= + concat_cmds= + save_oldobjs=$oldobjs + oldobjs= + # Is there a better way of finding the last object in the list? + for obj in $save_oldobjs + do + last_oldobj=$obj + done + eval test_cmds=\"$old_archive_cmds\" + func_len " $test_cmds" + len0=$func_len_result + len=$len0 + for obj in $save_oldobjs + do + func_len " $obj" + func_arith $len + $func_len_result + len=$func_arith_result + func_append objlist " $obj" + if test "$len" -lt "$max_cmd_len"; then + : + else + # the above command should be used before it gets too long + oldobjs=$objlist + if test "$obj" = "$last_oldobj" ; then + RANLIB=$save_RANLIB + fi + test -z "$concat_cmds" || concat_cmds=$concat_cmds~ + eval concat_cmds=\"\${concat_cmds}$old_archive_cmds\" + objlist= + len=$len0 + fi + done + RANLIB=$save_RANLIB + oldobjs=$objlist + if test "X$oldobjs" = "X" ; then + eval cmds=\"\$concat_cmds\" + else + eval cmds=\"\$concat_cmds~\$old_archive_cmds\" + fi + fi + fi + func_execute_cmds "$cmds" 'exit $?' + done + + test -n "$generated" && \ + func_show_eval "${RM}r$generated" + + # Now create the libtool archive. + case $output in + *.la) + old_library= + test "$build_old_libs" = yes && old_library="$libname.$libext" + func_verbose "creating $output" + + # Preserve any variables that may affect compiler behavior + for var in $variables_saved_for_relink; do + if eval test -z \"\${$var+set}\"; then + relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command" + elif eval var_value=\$$var; test -z "$var_value"; then + relink_command="$var=; export $var; $relink_command" + else + func_quote_for_eval "$var_value" + relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command" + fi + done + # Quote the link command for shipping. + relink_command="(cd `pwd`; $SHELL $progpath $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)" + relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"` + if test "$hardcode_automatic" = yes ; then + relink_command= + fi + + # Only create the output if not a dry run. + $opt_dry_run || { + for installed in no yes; do + if test "$installed" = yes; then + if test -z "$install_libdir"; then + break + fi + output="$output_objdir/$outputname"i + # Replace all uninstalled libtool libraries with the installed ones + newdependency_libs= + for deplib in $dependency_libs; do + case $deplib in + *.la) + func_basename "$deplib" + name="$func_basename_result" + func_resolve_sysroot "$deplib" + eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $func_resolve_sysroot_result` + test -z "$libdir" && \ + func_fatal_error "\`$deplib' is not a valid libtool archive" + func_append newdependency_libs " ${lt_sysroot:+=}$libdir/$name" + ;; + -L*) + func_stripname -L '' "$deplib" + func_replace_sysroot "$func_stripname_result" + func_append newdependency_libs " -L$func_replace_sysroot_result" + ;; + -R*) + func_stripname -R '' "$deplib" + func_replace_sysroot "$func_stripname_result" + func_append newdependency_libs " -R$func_replace_sysroot_result" + ;; + *) func_append newdependency_libs " $deplib" ;; + esac + done + dependency_libs="$newdependency_libs" + newdlfiles= + + for lib in $dlfiles; do + case $lib in + *.la) + func_basename "$lib" + name="$func_basename_result" + eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib` + test -z "$libdir" && \ + func_fatal_error "\`$lib' is not a valid libtool archive" + func_append newdlfiles " ${lt_sysroot:+=}$libdir/$name" + ;; + *) func_append newdlfiles " $lib" ;; + esac + done + dlfiles="$newdlfiles" + newdlprefiles= + for lib in $dlprefiles; do + case $lib in + *.la) + # Only pass preopened files to the pseudo-archive (for + # eventual linking with the app. that links it) if we + # didn't already link the preopened objects directly into + # the library: + func_basename "$lib" + name="$func_basename_result" + eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib` + test -z "$libdir" && \ + func_fatal_error "\`$lib' is not a valid libtool archive" + func_append newdlprefiles " ${lt_sysroot:+=}$libdir/$name" + ;; + esac + done + dlprefiles="$newdlprefiles" + else + newdlfiles= + for lib in $dlfiles; do + case $lib in + [\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;; + *) abs=`pwd`"/$lib" ;; + esac + func_append newdlfiles " $abs" + done + dlfiles="$newdlfiles" + newdlprefiles= + for lib in $dlprefiles; do + case $lib in + [\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;; + *) abs=`pwd`"/$lib" ;; + esac + func_append newdlprefiles " $abs" + done + dlprefiles="$newdlprefiles" + fi + $RM $output + # place dlname in correct position for cygwin + # In fact, it would be nice if we could use this code for all target + # systems that can't hard-code library paths into their executables + # and that have no shared library path variable independent of PATH, + # but it turns out we can't easily determine that from inspecting + # libtool variables, so we have to hard-code the OSs to which it + # applies here; at the moment, that means platforms that use the PE + # object format with DLL files. See the long comment at the top of + # tests/bindir.at for full details. + tdlname=$dlname + case $host,$output,$installed,$module,$dlname in + *cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll | *cegcc*,*lai,yes,no,*.dll) + # If a -bindir argument was supplied, place the dll there. + if test "x$bindir" != x ; + then + func_relative_path "$install_libdir" "$bindir" + tdlname=$func_relative_path_result$dlname + else + # Otherwise fall back on heuristic. + tdlname=../bin/$dlname + fi + ;; + esac + $ECHO > $output "\ +# $outputname - a libtool library file +# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION +# +# Please DO NOT delete this file! +# It is necessary for linking the library. + +# The name that we can dlopen(3). +dlname='$tdlname' + +# Names of this library. +library_names='$library_names' + +# The name of the static archive. +old_library='$old_library' + +# Linker flags that can not go in dependency_libs. +inherited_linker_flags='$new_inherited_linker_flags' + +# Libraries that this one depends upon. +dependency_libs='$dependency_libs' + +# Names of additional weak libraries provided by this library +weak_library_names='$weak_libs' + +# Version information for $libname. +current=$current +age=$age +revision=$revision + +# Is this an already installed library? +installed=$installed + +# Should we warn about portability when linking against -modules? +shouldnotlink=$module + +# Files to dlopen/dlpreopen +dlopen='$dlfiles' +dlpreopen='$dlprefiles' + +# Directory that this library needs to be installed in: +libdir='$install_libdir'" + if test "$installed" = no && test "$need_relink" = yes; then + $ECHO >> $output "\ +relink_command=\"$relink_command\"" + fi + done + } + + # Do a symbolic link so that the libtool archive can be found in + # LD_LIBRARY_PATH before the program is installed. + func_show_eval '( cd "$output_objdir" && $RM "$outputname" && $LN_S "../$outputname" "$outputname" )' 'exit $?' + ;; + esac + exit $EXIT_SUCCESS +} + +{ test "$opt_mode" = link || test "$opt_mode" = relink; } && + func_mode_link ${1+"$@"} + + +# func_mode_uninstall arg... +func_mode_uninstall () +{ + $opt_debug + RM="$nonopt" + files= + rmforce= + exit_status=0 + + # This variable tells wrapper scripts just to set variables rather + # than running their programs. + libtool_install_magic="$magic" + + for arg + do + case $arg in + -f) func_append RM " $arg"; rmforce=yes ;; + -*) func_append RM " $arg" ;; + *) func_append files " $arg" ;; + esac + done + + test -z "$RM" && \ + func_fatal_help "you must specify an RM program" + + rmdirs= + + for file in $files; do + func_dirname "$file" "" "." + dir="$func_dirname_result" + if test "X$dir" = X.; then + odir="$objdir" + else + odir="$dir/$objdir" + fi + func_basename "$file" + name="$func_basename_result" + test "$opt_mode" = uninstall && odir="$dir" + + # Remember odir for removal later, being careful to avoid duplicates + if test "$opt_mode" = clean; then + case " $rmdirs " in + *" $odir "*) ;; + *) func_append rmdirs " $odir" ;; + esac + fi + + # Don't error if the file doesn't exist and rm -f was used. + if { test -L "$file"; } >/dev/null 2>&1 || + { test -h "$file"; } >/dev/null 2>&1 || + test -f "$file"; then + : + elif test -d "$file"; then + exit_status=1 + continue + elif test "$rmforce" = yes; then + continue + fi + + rmfiles="$file" + + case $name in + *.la) + # Possibly a libtool archive, so verify it. + if func_lalib_p "$file"; then + func_source $dir/$name + + # Delete the libtool libraries and symlinks. + for n in $library_names; do + func_append rmfiles " $odir/$n" + done + test -n "$old_library" && func_append rmfiles " $odir/$old_library" + + case "$opt_mode" in + clean) + case " $library_names " in + *" $dlname "*) ;; + *) test -n "$dlname" && func_append rmfiles " $odir/$dlname" ;; + esac + test -n "$libdir" && func_append rmfiles " $odir/$name $odir/${name}i" + ;; + uninstall) + if test -n "$library_names"; then + # Do each command in the postuninstall commands. + func_execute_cmds "$postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1' + fi + + if test -n "$old_library"; then + # Do each command in the old_postuninstall commands. + func_execute_cmds "$old_postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1' + fi + # FIXME: should reinstall the best remaining shared library. + ;; + esac + fi + ;; + + *.lo) + # Possibly a libtool object, so verify it. + if func_lalib_p "$file"; then + + # Read the .lo file + func_source $dir/$name + + # Add PIC object to the list of files to remove. + if test -n "$pic_object" && + test "$pic_object" != none; then + func_append rmfiles " $dir/$pic_object" + fi + + # Add non-PIC object to the list of files to remove. + if test -n "$non_pic_object" && + test "$non_pic_object" != none; then + func_append rmfiles " $dir/$non_pic_object" + fi + fi + ;; + + *) + if test "$opt_mode" = clean ; then + noexename=$name + case $file in + *.exe) + func_stripname '' '.exe' "$file" + file=$func_stripname_result + func_stripname '' '.exe' "$name" + noexename=$func_stripname_result + # $file with .exe has already been added to rmfiles, + # add $file without .exe + func_append rmfiles " $file" + ;; + esac + # Do a test to see if this is a libtool program. + if func_ltwrapper_p "$file"; then + if func_ltwrapper_executable_p "$file"; then + func_ltwrapper_scriptname "$file" + relink_command= + func_source $func_ltwrapper_scriptname_result + func_append rmfiles " $func_ltwrapper_scriptname_result" + else + relink_command= + func_source $dir/$noexename + fi + + # note $name still contains .exe if it was in $file originally + # as does the version of $file that was added into $rmfiles + func_append rmfiles " $odir/$name $odir/${name}S.${objext}" + if test "$fast_install" = yes && test -n "$relink_command"; then + func_append rmfiles " $odir/lt-$name" + fi + if test "X$noexename" != "X$name" ; then + func_append rmfiles " $odir/lt-${noexename}.c" + fi + fi + fi + ;; + esac + func_show_eval "$RM $rmfiles" 'exit_status=1' + done + + # Try to remove the ${objdir}s in the directories where we deleted files + for dir in $rmdirs; do + if test -d "$dir"; then + func_show_eval "rmdir $dir >/dev/null 2>&1" + fi + done + + exit $exit_status +} + +{ test "$opt_mode" = uninstall || test "$opt_mode" = clean; } && + func_mode_uninstall ${1+"$@"} + +test -z "$opt_mode" && { + help="$generic_help" + func_fatal_help "you must specify a MODE" +} + +test -z "$exec_cmd" && \ + func_fatal_help "invalid operation mode \`$opt_mode'" + +if test -n "$exec_cmd"; then + eval exec "$exec_cmd" + exit $EXIT_FAILURE +fi + +exit $exit_status + + +# The TAGs below are defined such that we never get into a situation +# in which we disable both kinds of libraries. Given conflicting +# choices, we go for a static library, that is the most portable, +# since we can't tell whether shared libraries were disabled because +# the user asked for that or because the platform doesn't support +# them. This is particularly important on AIX, because we don't +# support having both static and shared libraries enabled at the same +# time on that platform, so we default to a shared-only configuration. +# If a disable-shared tag is given, we'll fallback to a static-only +# configuration. But we'll never go from static-only to shared-only. + +# ### BEGIN LIBTOOL TAG CONFIG: disable-shared +build_libtool_libs=no +build_old_libs=yes +# ### END LIBTOOL TAG CONFIG: disable-shared + +# ### BEGIN LIBTOOL TAG CONFIG: disable-static +build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac` +# ### END LIBTOOL TAG CONFIG: disable-static + +# Local Variables: +# mode:shell-script +# sh-indentation:2 +# End: +# vi:sw=2 + diff --git a/third-party/odb/libodb-2.4.0/config/missing b/third-party/odb/libodb-2.4.0/config/missing new file mode 100755 index 0000000..9a55648 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/config/missing @@ -0,0 +1,330 @@ +#! /bin/sh +# Common stub for a few missing GNU programs while installing. + +scriptversion=2012-01-06.18; # UTC + +# Copyright (C) 1996-2012 Free Software Foundation, Inc. +# Originally by Fran,cois Pinard , 1996. + +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2, or (at your option) +# any later version. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + +# As a special exception to the GNU General Public License, if you +# distribute this file as part of a program that contains a +# configuration script generated by Autoconf, you may include it under +# the same distribution terms that you use for the rest of that program. + +if test $# -eq 0; then + echo 1>&2 "Try '$0 --help' for more information" + exit 1 +fi + +run=: +sed_output='s/.* --output[ =]\([^ ]*\).*/\1/p' +sed_minuso='s/.* -o \([^ ]*\).*/\1/p' + +# In the cases where this matters, 'missing' is being run in the +# srcdir already. +if test -f configure.ac; then + configure_ac=configure.ac +else + configure_ac=configure.in +fi + +msg="missing on your system" + +case $1 in +--run) + # Try to run requested program, and just exit if it succeeds. + run= + shift + "$@" && exit 0 + # Exit code 63 means version mismatch. This often happens + # when the user try to use an ancient version of a tool on + # a file that requires a minimum version. In this case we + # we should proceed has if the program had been absent, or + # if --run hadn't been passed. + if test $? = 63; then + run=: + msg="probably too old" + fi + ;; + + -h|--h|--he|--hel|--help) + echo "\ +$0 [OPTION]... PROGRAM [ARGUMENT]... + +Handle 'PROGRAM [ARGUMENT]...' for when PROGRAM is missing, or return an +error status if there is no known handling for PROGRAM. + +Options: + -h, --help display this help and exit + -v, --version output version information and exit + --run try to run the given command, and emulate it if it fails + +Supported PROGRAM values: + aclocal touch file 'aclocal.m4' + autoconf touch file 'configure' + autoheader touch file 'config.h.in' + autom4te touch the output file, or create a stub one + automake touch all 'Makefile.in' files + bison create 'y.tab.[ch]', if possible, from existing .[ch] + flex create 'lex.yy.c', if possible, from existing .c + help2man touch the output file + lex create 'lex.yy.c', if possible, from existing .c + makeinfo touch the output file + yacc create 'y.tab.[ch]', if possible, from existing .[ch] + +Version suffixes to PROGRAM as well as the prefixes 'gnu-', 'gnu', and +'g' are ignored when checking the name. + +Send bug reports to ." + exit $? + ;; + + -v|--v|--ve|--ver|--vers|--versi|--versio|--version) + echo "missing $scriptversion (GNU Automake)" + exit $? + ;; + + -*) + echo 1>&2 "$0: Unknown '$1' option" + echo 1>&2 "Try '$0 --help' for more information" + exit 1 + ;; + +esac + +# normalize program name to check for. +program=`echo "$1" | sed ' + s/^gnu-//; t + s/^gnu//; t + s/^g//; t'` + +# Now exit if we have it, but it failed. Also exit now if we +# don't have it and --version was passed (most likely to detect +# the program). This is about non-GNU programs, so use $1 not +# $program. +case $1 in + lex*|yacc*) + # Not GNU programs, they don't have --version. + ;; + + *) + if test -z "$run" && ($1 --version) > /dev/null 2>&1; then + # We have it, but it failed. + exit 1 + elif test "x$2" = "x--version" || test "x$2" = "x--help"; then + # Could not run --version or --help. This is probably someone + # running '$TOOL --version' or '$TOOL --help' to check whether + # $TOOL exists and not knowing $TOOL uses missing. + exit 1 + fi + ;; +esac + +# If it does not exist, or fails to run (possibly an outdated version), +# try to emulate it. +case $program in + aclocal*) + echo 1>&2 "\ +WARNING: '$1' is $msg. You should only need it if + you modified 'acinclude.m4' or '${configure_ac}'. You might want + to install the Automake and Perl packages. Grab them from + any GNU archive site." + touch aclocal.m4 + ;; + + autoconf*) + echo 1>&2 "\ +WARNING: '$1' is $msg. You should only need it if + you modified '${configure_ac}'. You might want to install the + Autoconf and GNU m4 packages. Grab them from any GNU + archive site." + touch configure + ;; + + autoheader*) + echo 1>&2 "\ +WARNING: '$1' is $msg. You should only need it if + you modified 'acconfig.h' or '${configure_ac}'. You might want + to install the Autoconf and GNU m4 packages. Grab them + from any GNU archive site." + files=`sed -n 's/^[ ]*A[CM]_CONFIG_HEADER(\([^)]*\)).*/\1/p' ${configure_ac}` + test -z "$files" && files="config.h" + touch_files= + for f in $files; do + case $f in + *:*) touch_files="$touch_files "`echo "$f" | + sed -e 's/^[^:]*://' -e 's/:.*//'`;; + *) touch_files="$touch_files $f.in";; + esac + done + touch $touch_files + ;; + + automake*) + echo 1>&2 "\ +WARNING: '$1' is $msg. You should only need it if + you modified 'Makefile.am', 'acinclude.m4' or '${configure_ac}'. + You might want to install the Automake and Perl packages. + Grab them from any GNU archive site." + find . -type f -name Makefile.am -print | + sed 's/\.am$/.in/' | + while read f; do touch "$f"; done + ;; + + autom4te*) + echo 1>&2 "\ +WARNING: '$1' is needed, but is $msg. + You might have modified some files without having the + proper tools for further handling them. + You can get '$1' as part of Autoconf from any GNU + archive site." + + file=`echo "$*" | sed -n "$sed_output"` + test -z "$file" && file=`echo "$*" | sed -n "$sed_minuso"` + if test -f "$file"; then + touch $file + else + test -z "$file" || exec >$file + echo "#! /bin/sh" + echo "# Created by GNU Automake missing as a replacement of" + echo "# $ $@" + echo "exit 0" + chmod +x $file + exit 1 + fi + ;; + + bison*|yacc*) + echo 1>&2 "\ +WARNING: '$1' $msg. You should only need it if + you modified a '.y' file. You may need the Bison package + in order for those modifications to take effect. You can get + Bison from any GNU archive site." + rm -f y.tab.c y.tab.h + if test $# -ne 1; then + eval LASTARG=\${$#} + case $LASTARG in + *.y) + SRCFILE=`echo "$LASTARG" | sed 's/y$/c/'` + if test -f "$SRCFILE"; then + cp "$SRCFILE" y.tab.c + fi + SRCFILE=`echo "$LASTARG" | sed 's/y$/h/'` + if test -f "$SRCFILE"; then + cp "$SRCFILE" y.tab.h + fi + ;; + esac + fi + if test ! -f y.tab.h; then + echo >y.tab.h + fi + if test ! -f y.tab.c; then + echo 'main() { return 0; }' >y.tab.c + fi + ;; + + lex*|flex*) + echo 1>&2 "\ +WARNING: '$1' is $msg. You should only need it if + you modified a '.l' file. You may need the Flex package + in order for those modifications to take effect. You can get + Flex from any GNU archive site." + rm -f lex.yy.c + if test $# -ne 1; then + eval LASTARG=\${$#} + case $LASTARG in + *.l) + SRCFILE=`echo "$LASTARG" | sed 's/l$/c/'` + if test -f "$SRCFILE"; then + cp "$SRCFILE" lex.yy.c + fi + ;; + esac + fi + if test ! -f lex.yy.c; then + echo 'main() { return 0; }' >lex.yy.c + fi + ;; + + help2man*) + echo 1>&2 "\ +WARNING: '$1' is $msg. You should only need it if + you modified a dependency of a manual page. You may need the + Help2man package in order for those modifications to take + effect. You can get Help2man from any GNU archive site." + + file=`echo "$*" | sed -n "$sed_output"` + test -z "$file" && file=`echo "$*" | sed -n "$sed_minuso"` + if test -f "$file"; then + touch $file + else + test -z "$file" || exec >$file + echo ".ab help2man is required to generate this page" + exit $? + fi + ;; + + makeinfo*) + echo 1>&2 "\ +WARNING: '$1' is $msg. You should only need it if + you modified a '.texi' or '.texinfo' file, or any other file + indirectly affecting the aspect of the manual. The spurious + call might also be the consequence of using a buggy 'make' (AIX, + DU, IRIX). You might want to install the Texinfo package or + the GNU make package. Grab either from any GNU archive site." + # The file to touch is that specified with -o ... + file=`echo "$*" | sed -n "$sed_output"` + test -z "$file" && file=`echo "$*" | sed -n "$sed_minuso"` + if test -z "$file"; then + # ... or it is the one specified with @setfilename ... + infile=`echo "$*" | sed 's/.* \([^ ]*\) *$/\1/'` + file=`sed -n ' + /^@setfilename/{ + s/.* \([^ ]*\) *$/\1/ + p + q + }' $infile` + # ... or it is derived from the source name (dir/f.texi becomes f.info) + test -z "$file" && file=`echo "$infile" | sed 's,.*/,,;s,.[^.]*$,,'`.info + fi + # If the file does not exist, the user really needs makeinfo; + # let's fail without touching anything. + test -f $file || exit 1 + touch $file + ;; + + *) + echo 1>&2 "\ +WARNING: '$1' is needed, and is $msg. + You might have modified some files without having the + proper tools for further handling them. Check the 'README' file, + it often tells you about the needed prerequisites for installing + this package. You may also peek at any GNU archive site, in case + some other package would contain this missing '$1' program." + exit 1 + ;; +esac + +exit 0 + +# Local variables: +# eval: (add-hook 'write-file-hooks 'time-stamp) +# time-stamp-start: "scriptversion=" +# time-stamp-format: "%:y-%02m-%02d.%02H" +# time-stamp-time-zone: "UTC" +# time-stamp-end: "; # UTC" +# End: diff --git a/third-party/odb/libodb-2.4.0/configure b/third-party/odb/libodb-2.4.0/configure new file mode 100755 index 0000000..c8f8e4c --- /dev/null +++ b/third-party/odb/libodb-2.4.0/configure @@ -0,0 +1,20342 @@ +#! /bin/sh +# Guess values for system-dependent variables and create Makefiles. +# Generated by GNU Autoconf 2.69 for libodb 2.4.0. +# +# Report bugs to . +# +# +# Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc. +# +# +# This configure script is free software; the Free Software Foundation +# gives unlimited permission to copy, distribute and modify it. +## -------------------- ## +## M4sh Initialization. ## +## -------------------- ## + +# Be more Bourne compatible +DUALCASE=1; export DUALCASE # for MKS sh +if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then : + emulate sh + NULLCMD=: + # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which + # is contrary to our usage. Disable this feature. + alias -g '${1+"$@"}'='"$@"' + setopt NO_GLOB_SUBST +else + case `(set -o) 2>/dev/null` in #( + *posix*) : + set -o posix ;; #( + *) : + ;; +esac +fi + + +as_nl=' +' +export as_nl +# Printing a long string crashes Solaris 7 /usr/bin/printf. +as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' +as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo +as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo +# Prefer a ksh shell builtin over an external printf program on Solaris, +# but without wasting forks for bash or zsh. +if test -z "$BASH_VERSION$ZSH_VERSION" \ + && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then + as_echo='print -r --' + as_echo_n='print -rn --' +elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then + as_echo='printf %s\n' + as_echo_n='printf %s' +else + if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then + as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"' + as_echo_n='/usr/ucb/echo -n' + else + as_echo_body='eval expr "X$1" : "X\\(.*\\)"' + as_echo_n_body='eval + arg=$1; + case $arg in #( + *"$as_nl"*) + expr "X$arg" : "X\\(.*\\)$as_nl"; + arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;; + esac; + expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl" + ' + export as_echo_n_body + as_echo_n='sh -c $as_echo_n_body as_echo' + fi + export as_echo_body + as_echo='sh -c $as_echo_body as_echo' +fi + +# The user is always right. +if test "${PATH_SEPARATOR+set}" != set; then + PATH_SEPARATOR=: + (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && { + (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 || + PATH_SEPARATOR=';' + } +fi + + +# IFS +# We need space, tab and new line, in precisely that order. Quoting is +# there to prevent editors from complaining about space-tab. +# (If _AS_PATH_WALK were called with IFS unset, it would disable word +# splitting by setting IFS to empty value.) +IFS=" "" $as_nl" + +# Find who we are. Look in the path if we contain no directory separator. +as_myself= +case $0 in #(( + *[\\/]* ) as_myself=$0 ;; + *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break + done +IFS=$as_save_IFS + + ;; +esac +# We did not find ourselves, most probably we were run as `sh COMMAND' +# in which case we are not to be found in the path. +if test "x$as_myself" = x; then + as_myself=$0 +fi +if test ! -f "$as_myself"; then + $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2 + exit 1 +fi + +# Unset variables that we do not need and which cause bugs (e.g. in +# pre-3.0 UWIN ksh). But do not cause bugs in bash 2.01; the "|| exit 1" +# suppresses any "Segmentation fault" message there. '((' could +# trigger a bug in pdksh 5.2.14. +for as_var in BASH_ENV ENV MAIL MAILPATH +do eval test x\${$as_var+set} = xset \ + && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || : +done +PS1='$ ' +PS2='> ' +PS4='+ ' + +# NLS nuisances. +LC_ALL=C +export LC_ALL +LANGUAGE=C +export LANGUAGE + +# CDPATH. +(unset CDPATH) >/dev/null 2>&1 && unset CDPATH + +# Use a proper internal environment variable to ensure we don't fall + # into an infinite loop, continuously re-executing ourselves. + if test x"${_as_can_reexec}" != xno && test "x$CONFIG_SHELL" != x; then + _as_can_reexec=no; export _as_can_reexec; + # We cannot yet assume a decent shell, so we have to provide a +# neutralization value for shells without unset; and this also +# works around shells that cannot unset nonexistent variables. +# Preserve -v and -x to the replacement shell. +BASH_ENV=/dev/null +ENV=/dev/null +(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV +case $- in # (((( + *v*x* | *x*v* ) as_opts=-vx ;; + *v* ) as_opts=-v ;; + *x* ) as_opts=-x ;; + * ) as_opts= ;; +esac +exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"} +# Admittedly, this is quite paranoid, since all the known shells bail +# out after a failed `exec'. +$as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2 +as_fn_exit 255 + fi + # We don't want this to propagate to other subprocesses. + { _as_can_reexec=; unset _as_can_reexec;} +if test "x$CONFIG_SHELL" = x; then + as_bourne_compatible="if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then : + emulate sh + NULLCMD=: + # Pre-4.2 versions of Zsh do word splitting on \${1+\"\$@\"}, which + # is contrary to our usage. Disable this feature. + alias -g '\${1+\"\$@\"}'='\"\$@\"' + setopt NO_GLOB_SUBST +else + case \`(set -o) 2>/dev/null\` in #( + *posix*) : + set -o posix ;; #( + *) : + ;; +esac +fi +" + as_required="as_fn_return () { (exit \$1); } +as_fn_success () { as_fn_return 0; } +as_fn_failure () { as_fn_return 1; } +as_fn_ret_success () { return 0; } +as_fn_ret_failure () { return 1; } + +exitcode=0 +as_fn_success || { exitcode=1; echo as_fn_success failed.; } +as_fn_failure && { exitcode=1; echo as_fn_failure succeeded.; } +as_fn_ret_success || { exitcode=1; echo as_fn_ret_success failed.; } +as_fn_ret_failure && { exitcode=1; echo as_fn_ret_failure succeeded.; } +if ( set x; as_fn_ret_success y && test x = \"\$1\" ); then : + +else + exitcode=1; echo positional parameters were not saved. +fi +test x\$exitcode = x0 || exit 1 +test -x / || exit 1" + as_suggested=" as_lineno_1=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_1a=\$LINENO + as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO + eval 'test \"x\$as_lineno_1'\$as_run'\" != \"x\$as_lineno_2'\$as_run'\" && + test \"x\`expr \$as_lineno_1'\$as_run' + 1\`\" = \"x\$as_lineno_2'\$as_run'\"' || exit 1 + + test -n \"\${ZSH_VERSION+set}\${BASH_VERSION+set}\" || ( + ECHO='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' + ECHO=\$ECHO\$ECHO\$ECHO\$ECHO\$ECHO + ECHO=\$ECHO\$ECHO\$ECHO\$ECHO\$ECHO\$ECHO + PATH=/empty FPATH=/empty; export PATH FPATH + test \"X\`printf %s \$ECHO\`\" = \"X\$ECHO\" \\ + || test \"X\`print -r -- \$ECHO\`\" = \"X\$ECHO\" ) || exit 1 +test \$(( 1 + 1 )) = 2 || exit 1" + if (eval "$as_required") 2>/dev/null; then : + as_have_required=yes +else + as_have_required=no +fi + if test x$as_have_required = xyes && (eval "$as_suggested") 2>/dev/null; then : + +else + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +as_found=false +for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + as_found=: + case $as_dir in #( + /*) + for as_base in sh bash ksh sh5; do + # Try only shells that exist, to save several forks. + as_shell=$as_dir/$as_base + if { test -f "$as_shell" || test -f "$as_shell.exe"; } && + { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$as_shell"; } 2>/dev/null; then : + CONFIG_SHELL=$as_shell as_have_required=yes + if { $as_echo "$as_bourne_compatible""$as_suggested" | as_run=a "$as_shell"; } 2>/dev/null; then : + break 2 +fi +fi + done;; + esac + as_found=false +done +$as_found || { if { test -f "$SHELL" || test -f "$SHELL.exe"; } && + { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$SHELL"; } 2>/dev/null; then : + CONFIG_SHELL=$SHELL as_have_required=yes +fi; } +IFS=$as_save_IFS + + + if test "x$CONFIG_SHELL" != x; then : + export CONFIG_SHELL + # We cannot yet assume a decent shell, so we have to provide a +# neutralization value for shells without unset; and this also +# works around shells that cannot unset nonexistent variables. +# Preserve -v and -x to the replacement shell. +BASH_ENV=/dev/null +ENV=/dev/null +(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV +case $- in # (((( + *v*x* | *x*v* ) as_opts=-vx ;; + *v* ) as_opts=-v ;; + *x* ) as_opts=-x ;; + * ) as_opts= ;; +esac +exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"} +# Admittedly, this is quite paranoid, since all the known shells bail +# out after a failed `exec'. +$as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2 +exit 255 +fi + + if test x$as_have_required = xno; then : + $as_echo "$0: This script requires a shell more modern than all" + $as_echo "$0: the shells that I found on your system." + if test x${ZSH_VERSION+set} = xset ; then + $as_echo "$0: In particular, zsh $ZSH_VERSION has bugs and should" + $as_echo "$0: be upgraded to zsh 4.3.4 or later." + else + $as_echo "$0: Please tell bug-autoconf@gnu.org and +$0: odb-users@codesynthesis.com about your system, +$0: including any error possibly output before this +$0: message. Then install a modern shell, or manually run +$0: the script under such a shell if you do have one." + fi + exit 1 +fi +fi +fi +SHELL=${CONFIG_SHELL-/bin/sh} +export SHELL +# Unset more variables known to interfere with behavior of common tools. +CLICOLOR_FORCE= GREP_OPTIONS= +unset CLICOLOR_FORCE GREP_OPTIONS + +## --------------------- ## +## M4sh Shell Functions. ## +## --------------------- ## +# as_fn_unset VAR +# --------------- +# Portably unset VAR. +as_fn_unset () +{ + { eval $1=; unset $1;} +} +as_unset=as_fn_unset + +# as_fn_set_status STATUS +# ----------------------- +# Set $? to STATUS, without forking. +as_fn_set_status () +{ + return $1 +} # as_fn_set_status + +# as_fn_exit STATUS +# ----------------- +# Exit the shell with STATUS, even in a "trap 0" or "set -e" context. +as_fn_exit () +{ + set +e + as_fn_set_status $1 + exit $1 +} # as_fn_exit + +# as_fn_mkdir_p +# ------------- +# Create "$as_dir" as a directory, including parents if necessary. +as_fn_mkdir_p () +{ + + case $as_dir in #( + -*) as_dir=./$as_dir;; + esac + test -d "$as_dir" || eval $as_mkdir_p || { + as_dirs= + while :; do + case $as_dir in #( + *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'( + *) as_qdir=$as_dir;; + esac + as_dirs="'$as_qdir' $as_dirs" + as_dir=`$as_dirname -- "$as_dir" || +$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ + X"$as_dir" : 'X\(//\)[^/]' \| \ + X"$as_dir" : 'X\(//\)$' \| \ + X"$as_dir" : 'X\(/\)' \| . 2>/dev/null || +$as_echo X"$as_dir" | + sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ + s//\1/ + q + } + /^X\(\/\/\)[^/].*/{ + s//\1/ + q + } + /^X\(\/\/\)$/{ + s//\1/ + q + } + /^X\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q'` + test -d "$as_dir" && break + done + test -z "$as_dirs" || eval "mkdir $as_dirs" + } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir" + + +} # as_fn_mkdir_p + +# as_fn_executable_p FILE +# ----------------------- +# Test if FILE is an executable regular file. +as_fn_executable_p () +{ + test -f "$1" && test -x "$1" +} # as_fn_executable_p +# as_fn_append VAR VALUE +# ---------------------- +# Append the text in VALUE to the end of the definition contained in VAR. Take +# advantage of any shell optimizations that allow amortized linear growth over +# repeated appends, instead of the typical quadratic growth present in naive +# implementations. +if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then : + eval 'as_fn_append () + { + eval $1+=\$2 + }' +else + as_fn_append () + { + eval $1=\$$1\$2 + } +fi # as_fn_append + +# as_fn_arith ARG... +# ------------------ +# Perform arithmetic evaluation on the ARGs, and store the result in the +# global $as_val. Take advantage of shells that can avoid forks. The arguments +# must be portable across $(()) and expr. +if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then : + eval 'as_fn_arith () + { + as_val=$(( $* )) + }' +else + as_fn_arith () + { + as_val=`expr "$@" || test $? -eq 1` + } +fi # as_fn_arith + + +# as_fn_error STATUS ERROR [LINENO LOG_FD] +# ---------------------------------------- +# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are +# provided, also output the error to LOG_FD, referencing LINENO. Then exit the +# script with STATUS, using 1 if that was 0. +as_fn_error () +{ + as_status=$1; test $as_status -eq 0 && as_status=1 + if test "$4"; then + as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4 + fi + $as_echo "$as_me: error: $2" >&2 + as_fn_exit $as_status +} # as_fn_error + +if expr a : '\(a\)' >/dev/null 2>&1 && + test "X`expr 00001 : '.*\(...\)'`" = X001; then + as_expr=expr +else + as_expr=false +fi + +if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then + as_basename=basename +else + as_basename=false +fi + +if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then + as_dirname=dirname +else + as_dirname=false +fi + +as_me=`$as_basename -- "$0" || +$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ + X"$0" : 'X\(//\)$' \| \ + X"$0" : 'X\(/\)' \| . 2>/dev/null || +$as_echo X/"$0" | + sed '/^.*\/\([^/][^/]*\)\/*$/{ + s//\1/ + q + } + /^X\/\(\/\/\)$/{ + s//\1/ + q + } + /^X\/\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q'` + +# Avoid depending upon Character Ranges. +as_cr_letters='abcdefghijklmnopqrstuvwxyz' +as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ' +as_cr_Letters=$as_cr_letters$as_cr_LETTERS +as_cr_digits='0123456789' +as_cr_alnum=$as_cr_Letters$as_cr_digits + + + as_lineno_1=$LINENO as_lineno_1a=$LINENO + as_lineno_2=$LINENO as_lineno_2a=$LINENO + eval 'test "x$as_lineno_1'$as_run'" != "x$as_lineno_2'$as_run'" && + test "x`expr $as_lineno_1'$as_run' + 1`" = "x$as_lineno_2'$as_run'"' || { + # Blame Lee E. McMahon (1931-1989) for sed's syntax. :-) + sed -n ' + p + /[$]LINENO/= + ' <$as_myself | + sed ' + s/[$]LINENO.*/&-/ + t lineno + b + :lineno + N + :loop + s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/ + t loop + s/-\n.*// + ' >$as_me.lineno && + chmod +x "$as_me.lineno" || + { $as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; } + + # If we had to re-execute with $CONFIG_SHELL, we're ensured to have + # already done that, so ensure we don't try to do so again and fall + # in an infinite loop. This has already happened in practice. + _as_can_reexec=no; export _as_can_reexec + # Don't try to exec as it changes $[0], causing all sort of problems + # (the dirname of $[0] is not the place where we might find the + # original and so on. Autoconf is especially sensitive to this). + . "./$as_me.lineno" + # Exit status is that of the last command. + exit +} + +ECHO_C= ECHO_N= ECHO_T= +case `echo -n x` in #((((( +-n*) + case `echo 'xy\c'` in + *c*) ECHO_T=' ';; # ECHO_T is single tab character. + xy) ECHO_C='\c';; + *) echo `echo ksh88 bug on AIX 6.1` > /dev/null + ECHO_T=' ';; + esac;; +*) + ECHO_N='-n';; +esac + +rm -f conf$$ conf$$.exe conf$$.file +if test -d conf$$.dir; then + rm -f conf$$.dir/conf$$.file +else + rm -f conf$$.dir + mkdir conf$$.dir 2>/dev/null +fi +if (echo >conf$$.file) 2>/dev/null; then + if ln -s conf$$.file conf$$ 2>/dev/null; then + as_ln_s='ln -s' + # ... but there are two gotchas: + # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail. + # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable. + # In both cases, we have to default to `cp -pR'. + ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe || + as_ln_s='cp -pR' + elif ln conf$$.file conf$$ 2>/dev/null; then + as_ln_s=ln + else + as_ln_s='cp -pR' + fi +else + as_ln_s='cp -pR' +fi +rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file +rmdir conf$$.dir 2>/dev/null + +if mkdir -p . 2>/dev/null; then + as_mkdir_p='mkdir -p "$as_dir"' +else + test -d ./-p && rmdir ./-p + as_mkdir_p=false +fi + +as_test_x='test -x' +as_executable_p=as_fn_executable_p + +# Sed expression to map a string onto a valid CPP name. +as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'" + +# Sed expression to map a string onto a valid variable name. +as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'" + +SHELL=${CONFIG_SHELL-/bin/sh} + + +test -n "$DJDIR" || exec 7<&0 &1 + +# Name of the host. +# hostname on some systems (SVR3.2, old GNU/Linux) returns a bogus exit status, +# so uname gets run too. +ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q` + +# +# Initializations. +# +ac_default_prefix=/usr/local +ac_clean_files= +ac_config_libobj_dir=. +LIBOBJS= +cross_compiling=no +subdirs= +MFLAGS= +MAKEFLAGS= + +# Identity of this package. +PACKAGE_NAME='libodb' +PACKAGE_TARNAME='libodb' +PACKAGE_VERSION='2.4.0' +PACKAGE_STRING='libodb 2.4.0' +PACKAGE_BUGREPORT='odb-users@codesynthesis.com' +PACKAGE_URL='' + +ac_unique_file="odb/version.hxx" +# Factoring default headers for most tests. +ac_includes_default="\ +#include +#ifdef HAVE_SYS_TYPES_H +# include +#endif +#ifdef HAVE_SYS_STAT_H +# include +#endif +#ifdef STDC_HEADERS +# include +# include +#else +# ifdef HAVE_STDLIB_H +# include +# endif +#endif +#ifdef HAVE_STRING_H +# if !defined STDC_HEADERS && defined HAVE_MEMORY_H +# include +# endif +# include +#endif +#ifdef HAVE_STRINGS_H +# include +#endif +#ifdef HAVE_INTTYPES_H +# include +#endif +#ifdef HAVE_STDINT_H +# include +#endif +#ifdef HAVE_UNISTD_H +# include +#endif" + +ac_subst_vars='am__EXEEXT_FALSE +am__EXEEXT_TRUE +LTLIBOBJS +LIBOBJS +pkgconfigdir +ODB_THREADS_POSIX_FALSE +ODB_THREADS_POSIX_TRUE +ODB_THREADS_WIN32_FALSE +ODB_THREADS_WIN32_TRUE +ODB_THREADS_NONE_FALSE +ODB_THREADS_NONE_TRUE +PTHREAD_CXX +PTHREAD_CXXFLAGS +PTHREAD_LIBS +acx_pthread_config +ODB_WIN32_FALSE +ODB_WIN32_TRUE +CXXCPP +am__fastdepCXX_FALSE +am__fastdepCXX_TRUE +CXXDEPMODE +ac_ct_CXX +CXXFLAGS +CXX +CPP +OTOOL64 +OTOOL +LIPO +NMEDIT +DSYMUTIL +MANIFEST_TOOL +RANLIB +LN_S +NM +ac_ct_DUMPBIN +DUMPBIN +LD +FGREP +EGREP +GREP +SED +host_os +host_vendor +host_cpu +host +build_os +build_vendor +build_cpu +build +LIBTOOL +OBJDUMP +DLLTOOL +AS +am__fastdepCC_FALSE +am__fastdepCC_TRUE +CCDEPMODE +am__nodep +AMDEPBACKSLASH +AMDEP_FALSE +AMDEP_TRUE +am__quote +am__include +DEPDIR +OBJEXT +EXEEXT +ac_ct_CC +CPPFLAGS +LDFLAGS +CFLAGS +CC +ac_ct_AR +AR +am__untar +am__tar +AMTAR +am__leading_dot +SET_MAKE +AWK +mkdir_p +MKDIR_P +INSTALL_STRIP_PROGRAM +STRIP +install_sh +MAKEINFO +AUTOHEADER +AUTOMAKE +AUTOCONF +ACLOCAL +VERSION +PACKAGE +CYGPATH_W +am__isrc +INSTALL_DATA +INSTALL_SCRIPT +INSTALL_PROGRAM +target_alias +host_alias +build_alias +LIBS +ECHO_T +ECHO_N +ECHO_C +DEFS +mandir +localedir +libdir +psdir +pdfdir +dvidir +htmldir +infodir +docdir +oldincludedir +includedir +localstatedir +sharedstatedir +sysconfdir +datadir +datarootdir +libexecdir +sbindir +bindir +program_transform_name +prefix +exec_prefix +PACKAGE_URL +PACKAGE_BUGREPORT +PACKAGE_STRING +PACKAGE_VERSION +PACKAGE_TARNAME +PACKAGE_NAME +PATH_SEPARATOR +SHELL' +ac_subst_files='' +ac_user_opts=' +enable_option_checking +enable_dependency_tracking +enable_shared +enable_static +with_pic +enable_fast_install +with_gnu_ld +with_sysroot +enable_libtool_lock +enable_threads +with_pkgconfigdir +enable_rpath +' + ac_precious_vars='build_alias +host_alias +target_alias +CC +CFLAGS +LDFLAGS +LIBS +CPPFLAGS +CPP +CXX +CXXFLAGS +CCC +CXXCPP' + + +# Initialize some variables set by options. +ac_init_help= +ac_init_version=false +ac_unrecognized_opts= +ac_unrecognized_sep= +# The variables have the same names as the options, with +# dashes changed to underlines. +cache_file=/dev/null +exec_prefix=NONE +no_create= +no_recursion= +prefix=NONE +program_prefix=NONE +program_suffix=NONE +program_transform_name=s,x,x, +silent= +site= +srcdir= +verbose= +x_includes=NONE +x_libraries=NONE + +# Installation directory options. +# These are left unexpanded so users can "make install exec_prefix=/foo" +# and all the variables that are supposed to be based on exec_prefix +# by default will actually change. +# Use braces instead of parens because sh, perl, etc. also accept them. +# (The list follows the same order as the GNU Coding Standards.) +bindir='${exec_prefix}/bin' +sbindir='${exec_prefix}/sbin' +libexecdir='${exec_prefix}/libexec' +datarootdir='${prefix}/share' +datadir='${datarootdir}' +sysconfdir='${prefix}/etc' +sharedstatedir='${prefix}/com' +localstatedir='${prefix}/var' +includedir='${prefix}/include' +oldincludedir='/usr/include' +docdir='${datarootdir}/doc/${PACKAGE_TARNAME}' +infodir='${datarootdir}/info' +htmldir='${docdir}' +dvidir='${docdir}' +pdfdir='${docdir}' +psdir='${docdir}' +libdir='${exec_prefix}/lib' +localedir='${datarootdir}/locale' +mandir='${datarootdir}/man' + +ac_prev= +ac_dashdash= +for ac_option +do + # If the previous option needs an argument, assign it. + if test -n "$ac_prev"; then + eval $ac_prev=\$ac_option + ac_prev= + continue + fi + + case $ac_option in + *=?*) ac_optarg=`expr "X$ac_option" : '[^=]*=\(.*\)'` ;; + *=) ac_optarg= ;; + *) ac_optarg=yes ;; + esac + + # Accept the important Cygnus configure options, so we can diagnose typos. + + case $ac_dashdash$ac_option in + --) + ac_dashdash=yes ;; + + -bindir | --bindir | --bindi | --bind | --bin | --bi) + ac_prev=bindir ;; + -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*) + bindir=$ac_optarg ;; + + -build | --build | --buil | --bui | --bu) + ac_prev=build_alias ;; + -build=* | --build=* | --buil=* | --bui=* | --bu=*) + build_alias=$ac_optarg ;; + + -cache-file | --cache-file | --cache-fil | --cache-fi \ + | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c) + ac_prev=cache_file ;; + -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \ + | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*) + cache_file=$ac_optarg ;; + + --config-cache | -C) + cache_file=config.cache ;; + + -datadir | --datadir | --datadi | --datad) + ac_prev=datadir ;; + -datadir=* | --datadir=* | --datadi=* | --datad=*) + datadir=$ac_optarg ;; + + -datarootdir | --datarootdir | --datarootdi | --datarootd | --dataroot \ + | --dataroo | --dataro | --datar) + ac_prev=datarootdir ;; + -datarootdir=* | --datarootdir=* | --datarootdi=* | --datarootd=* \ + | --dataroot=* | --dataroo=* | --dataro=* | --datar=*) + datarootdir=$ac_optarg ;; + + -disable-* | --disable-*) + ac_useropt=`expr "x$ac_option" : 'x-*disable-\(.*\)'` + # Reject names that are not valid shell variable names. + expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && + as_fn_error $? "invalid feature name: $ac_useropt" + ac_useropt_orig=$ac_useropt + ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` + case $ac_user_opts in + *" +"enable_$ac_useropt" +"*) ;; + *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--disable-$ac_useropt_orig" + ac_unrecognized_sep=', ';; + esac + eval enable_$ac_useropt=no ;; + + -docdir | --docdir | --docdi | --doc | --do) + ac_prev=docdir ;; + -docdir=* | --docdir=* | --docdi=* | --doc=* | --do=*) + docdir=$ac_optarg ;; + + -dvidir | --dvidir | --dvidi | --dvid | --dvi | --dv) + ac_prev=dvidir ;; + -dvidir=* | --dvidir=* | --dvidi=* | --dvid=* | --dvi=* | --dv=*) + dvidir=$ac_optarg ;; + + -enable-* | --enable-*) + ac_useropt=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'` + # Reject names that are not valid shell variable names. + expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && + as_fn_error $? "invalid feature name: $ac_useropt" + ac_useropt_orig=$ac_useropt + ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` + case $ac_user_opts in + *" +"enable_$ac_useropt" +"*) ;; + *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--enable-$ac_useropt_orig" + ac_unrecognized_sep=', ';; + esac + eval enable_$ac_useropt=\$ac_optarg ;; + + -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \ + | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \ + | --exec | --exe | --ex) + ac_prev=exec_prefix ;; + -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \ + | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \ + | --exec=* | --exe=* | --ex=*) + exec_prefix=$ac_optarg ;; + + -gas | --gas | --ga | --g) + # Obsolete; use --with-gas. + with_gas=yes ;; + + -help | --help | --hel | --he | -h) + ac_init_help=long ;; + -help=r* | --help=r* | --hel=r* | --he=r* | -hr*) + ac_init_help=recursive ;; + -help=s* | --help=s* | --hel=s* | --he=s* | -hs*) + ac_init_help=short ;; + + -host | --host | --hos | --ho) + ac_prev=host_alias ;; + -host=* | --host=* | --hos=* | --ho=*) + host_alias=$ac_optarg ;; + + -htmldir | --htmldir | --htmldi | --htmld | --html | --htm | --ht) + ac_prev=htmldir ;; + -htmldir=* | --htmldir=* | --htmldi=* | --htmld=* | --html=* | --htm=* \ + | --ht=*) + htmldir=$ac_optarg ;; + + -includedir | --includedir | --includedi | --included | --include \ + | --includ | --inclu | --incl | --inc) + ac_prev=includedir ;; + -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \ + | --includ=* | --inclu=* | --incl=* | --inc=*) + includedir=$ac_optarg ;; + + -infodir | --infodir | --infodi | --infod | --info | --inf) + ac_prev=infodir ;; + -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*) + infodir=$ac_optarg ;; + + -libdir | --libdir | --libdi | --libd) + ac_prev=libdir ;; + -libdir=* | --libdir=* | --libdi=* | --libd=*) + libdir=$ac_optarg ;; + + -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \ + | --libexe | --libex | --libe) + ac_prev=libexecdir ;; + -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \ + | --libexe=* | --libex=* | --libe=*) + libexecdir=$ac_optarg ;; + + -localedir | --localedir | --localedi | --localed | --locale) + ac_prev=localedir ;; + -localedir=* | --localedir=* | --localedi=* | --localed=* | --locale=*) + localedir=$ac_optarg ;; + + -localstatedir | --localstatedir | --localstatedi | --localstated \ + | --localstate | --localstat | --localsta | --localst | --locals) + ac_prev=localstatedir ;; + -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \ + | --localstate=* | --localstat=* | --localsta=* | --localst=* | --locals=*) + localstatedir=$ac_optarg ;; + + -mandir | --mandir | --mandi | --mand | --man | --ma | --m) + ac_prev=mandir ;; + -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*) + mandir=$ac_optarg ;; + + -nfp | --nfp | --nf) + # Obsolete; use --without-fp. + with_fp=no ;; + + -no-create | --no-create | --no-creat | --no-crea | --no-cre \ + | --no-cr | --no-c | -n) + no_create=yes ;; + + -no-recursion | --no-recursion | --no-recursio | --no-recursi \ + | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r) + no_recursion=yes ;; + + -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \ + | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \ + | --oldin | --oldi | --old | --ol | --o) + ac_prev=oldincludedir ;; + -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \ + | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \ + | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*) + oldincludedir=$ac_optarg ;; + + -prefix | --prefix | --prefi | --pref | --pre | --pr | --p) + ac_prev=prefix ;; + -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*) + prefix=$ac_optarg ;; + + -program-prefix | --program-prefix | --program-prefi | --program-pref \ + | --program-pre | --program-pr | --program-p) + ac_prev=program_prefix ;; + -program-prefix=* | --program-prefix=* | --program-prefi=* \ + | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*) + program_prefix=$ac_optarg ;; + + -program-suffix | --program-suffix | --program-suffi | --program-suff \ + | --program-suf | --program-su | --program-s) + ac_prev=program_suffix ;; + -program-suffix=* | --program-suffix=* | --program-suffi=* \ + | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*) + program_suffix=$ac_optarg ;; + + -program-transform-name | --program-transform-name \ + | --program-transform-nam | --program-transform-na \ + | --program-transform-n | --program-transform- \ + | --program-transform | --program-transfor \ + | --program-transfo | --program-transf \ + | --program-trans | --program-tran \ + | --progr-tra | --program-tr | --program-t) + ac_prev=program_transform_name ;; + -program-transform-name=* | --program-transform-name=* \ + | --program-transform-nam=* | --program-transform-na=* \ + | --program-transform-n=* | --program-transform-=* \ + | --program-transform=* | --program-transfor=* \ + | --program-transfo=* | --program-transf=* \ + | --program-trans=* | --program-tran=* \ + | --progr-tra=* | --program-tr=* | --program-t=*) + program_transform_name=$ac_optarg ;; + + -pdfdir | --pdfdir | --pdfdi | --pdfd | --pdf | --pd) + ac_prev=pdfdir ;; + -pdfdir=* | --pdfdir=* | --pdfdi=* | --pdfd=* | --pdf=* | --pd=*) + pdfdir=$ac_optarg ;; + + -psdir | --psdir | --psdi | --psd | --ps) + ac_prev=psdir ;; + -psdir=* | --psdir=* | --psdi=* | --psd=* | --ps=*) + psdir=$ac_optarg ;; + + -q | -quiet | --quiet | --quie | --qui | --qu | --q \ + | -silent | --silent | --silen | --sile | --sil) + silent=yes ;; + + -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb) + ac_prev=sbindir ;; + -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \ + | --sbi=* | --sb=*) + sbindir=$ac_optarg ;; + + -sharedstatedir | --sharedstatedir | --sharedstatedi \ + | --sharedstated | --sharedstate | --sharedstat | --sharedsta \ + | --sharedst | --shareds | --shared | --share | --shar \ + | --sha | --sh) + ac_prev=sharedstatedir ;; + -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \ + | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \ + | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \ + | --sha=* | --sh=*) + sharedstatedir=$ac_optarg ;; + + -site | --site | --sit) + ac_prev=site ;; + -site=* | --site=* | --sit=*) + site=$ac_optarg ;; + + -srcdir | --srcdir | --srcdi | --srcd | --src | --sr) + ac_prev=srcdir ;; + -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*) + srcdir=$ac_optarg ;; + + -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \ + | --syscon | --sysco | --sysc | --sys | --sy) + ac_prev=sysconfdir ;; + -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \ + | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*) + sysconfdir=$ac_optarg ;; + + -target | --target | --targe | --targ | --tar | --ta | --t) + ac_prev=target_alias ;; + -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*) + target_alias=$ac_optarg ;; + + -v | -verbose | --verbose | --verbos | --verbo | --verb) + verbose=yes ;; + + -version | --version | --versio | --versi | --vers | -V) + ac_init_version=: ;; + + -with-* | --with-*) + ac_useropt=`expr "x$ac_option" : 'x-*with-\([^=]*\)'` + # Reject names that are not valid shell variable names. + expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && + as_fn_error $? "invalid package name: $ac_useropt" + ac_useropt_orig=$ac_useropt + ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` + case $ac_user_opts in + *" +"with_$ac_useropt" +"*) ;; + *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--with-$ac_useropt_orig" + ac_unrecognized_sep=', ';; + esac + eval with_$ac_useropt=\$ac_optarg ;; + + -without-* | --without-*) + ac_useropt=`expr "x$ac_option" : 'x-*without-\(.*\)'` + # Reject names that are not valid shell variable names. + expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && + as_fn_error $? "invalid package name: $ac_useropt" + ac_useropt_orig=$ac_useropt + ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` + case $ac_user_opts in + *" +"with_$ac_useropt" +"*) ;; + *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--without-$ac_useropt_orig" + ac_unrecognized_sep=', ';; + esac + eval with_$ac_useropt=no ;; + + --x) + # Obsolete; use --with-x. + with_x=yes ;; + + -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \ + | --x-incl | --x-inc | --x-in | --x-i) + ac_prev=x_includes ;; + -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \ + | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*) + x_includes=$ac_optarg ;; + + -x-libraries | --x-libraries | --x-librarie | --x-librari \ + | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l) + ac_prev=x_libraries ;; + -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \ + | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*) + x_libraries=$ac_optarg ;; + + -*) as_fn_error $? "unrecognized option: \`$ac_option' +Try \`$0 --help' for more information" + ;; + + *=*) + ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='` + # Reject names that are not valid shell variable names. + case $ac_envvar in #( + '' | [0-9]* | *[!_$as_cr_alnum]* ) + as_fn_error $? "invalid variable name: \`$ac_envvar'" ;; + esac + eval $ac_envvar=\$ac_optarg + export $ac_envvar ;; + + *) + # FIXME: should be removed in autoconf 3.0. + $as_echo "$as_me: WARNING: you should use --build, --host, --target" >&2 + expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null && + $as_echo "$as_me: WARNING: invalid host type: $ac_option" >&2 + : "${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}" + ;; + + esac +done + +if test -n "$ac_prev"; then + ac_option=--`echo $ac_prev | sed 's/_/-/g'` + as_fn_error $? "missing argument to $ac_option" +fi + +if test -n "$ac_unrecognized_opts"; then + case $enable_option_checking in + no) ;; + fatal) as_fn_error $? "unrecognized options: $ac_unrecognized_opts" ;; + *) $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;; + esac +fi + +# Check all directory arguments for consistency. +for ac_var in exec_prefix prefix bindir sbindir libexecdir datarootdir \ + datadir sysconfdir sharedstatedir localstatedir includedir \ + oldincludedir docdir infodir htmldir dvidir pdfdir psdir \ + libdir localedir mandir +do + eval ac_val=\$$ac_var + # Remove trailing slashes. + case $ac_val in + */ ) + ac_val=`expr "X$ac_val" : 'X\(.*[^/]\)' \| "X$ac_val" : 'X\(.*\)'` + eval $ac_var=\$ac_val;; + esac + # Be sure to have absolute directory names. + case $ac_val in + [\\/$]* | ?:[\\/]* ) continue;; + NONE | '' ) case $ac_var in *prefix ) continue;; esac;; + esac + as_fn_error $? "expected an absolute directory name for --$ac_var: $ac_val" +done + +# There might be people who depend on the old broken behavior: `$host' +# used to hold the argument of --host etc. +# FIXME: To remove some day. +build=$build_alias +host=$host_alias +target=$target_alias + +# FIXME: To remove some day. +if test "x$host_alias" != x; then + if test "x$build_alias" = x; then + cross_compiling=maybe + elif test "x$build_alias" != "x$host_alias"; then + cross_compiling=yes + fi +fi + +ac_tool_prefix= +test -n "$host_alias" && ac_tool_prefix=$host_alias- + +test "$silent" = yes && exec 6>/dev/null + + +ac_pwd=`pwd` && test -n "$ac_pwd" && +ac_ls_di=`ls -di .` && +ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` || + as_fn_error $? "working directory cannot be determined" +test "X$ac_ls_di" = "X$ac_pwd_ls_di" || + as_fn_error $? "pwd does not report name of working directory" + + +# Find the source files, if location was not specified. +if test -z "$srcdir"; then + ac_srcdir_defaulted=yes + # Try the directory containing this script, then the parent directory. + ac_confdir=`$as_dirname -- "$as_myself" || +$as_expr X"$as_myself" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ + X"$as_myself" : 'X\(//\)[^/]' \| \ + X"$as_myself" : 'X\(//\)$' \| \ + X"$as_myself" : 'X\(/\)' \| . 2>/dev/null || +$as_echo X"$as_myself" | + sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ + s//\1/ + q + } + /^X\(\/\/\)[^/].*/{ + s//\1/ + q + } + /^X\(\/\/\)$/{ + s//\1/ + q + } + /^X\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q'` + srcdir=$ac_confdir + if test ! -r "$srcdir/$ac_unique_file"; then + srcdir=.. + fi +else + ac_srcdir_defaulted=no +fi +if test ! -r "$srcdir/$ac_unique_file"; then + test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .." + as_fn_error $? "cannot find sources ($ac_unique_file) in $srcdir" +fi +ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work" +ac_abs_confdir=`( + cd "$srcdir" && test -r "./$ac_unique_file" || as_fn_error $? "$ac_msg" + pwd)` +# When building in place, set srcdir=. +if test "$ac_abs_confdir" = "$ac_pwd"; then + srcdir=. +fi +# Remove unnecessary trailing slashes from srcdir. +# Double slashes in file names in object file debugging info +# mess up M-x gdb in Emacs. +case $srcdir in +*/) srcdir=`expr "X$srcdir" : 'X\(.*[^/]\)' \| "X$srcdir" : 'X\(.*\)'`;; +esac +for ac_var in $ac_precious_vars; do + eval ac_env_${ac_var}_set=\${${ac_var}+set} + eval ac_env_${ac_var}_value=\$${ac_var} + eval ac_cv_env_${ac_var}_set=\${${ac_var}+set} + eval ac_cv_env_${ac_var}_value=\$${ac_var} +done + +# +# Report the --help message. +# +if test "$ac_init_help" = "long"; then + # Omit some internal or obsolete options to make the list less imposing. + # This message is too long to be a string in the A/UX 3.1 sh. + cat <<_ACEOF +\`configure' configures libodb 2.4.0 to adapt to many kinds of systems. + +Usage: $0 [OPTION]... [VAR=VALUE]... + +To assign environment variables (e.g., CC, CFLAGS...), specify them as +VAR=VALUE. See below for descriptions of some of the useful variables. + +Defaults for the options are specified in brackets. + +Configuration: + -h, --help display this help and exit + --help=short display options specific to this package + --help=recursive display the short help of all the included packages + -V, --version display version information and exit + -q, --quiet, --silent do not print \`checking ...' messages + --cache-file=FILE cache test results in FILE [disabled] + -C, --config-cache alias for \`--cache-file=config.cache' + -n, --no-create do not create output files + --srcdir=DIR find the sources in DIR [configure dir or \`..'] + +Installation directories: + --prefix=PREFIX install architecture-independent files in PREFIX + [$ac_default_prefix] + --exec-prefix=EPREFIX install architecture-dependent files in EPREFIX + [PREFIX] + +By default, \`make install' will install all the files in +\`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc. You can specify +an installation prefix other than \`$ac_default_prefix' using \`--prefix', +for instance \`--prefix=\$HOME'. + +For better control, use the options below. + +Fine tuning of the installation directories: + --bindir=DIR user executables [EPREFIX/bin] + --sbindir=DIR system admin executables [EPREFIX/sbin] + --libexecdir=DIR program executables [EPREFIX/libexec] + --sysconfdir=DIR read-only single-machine data [PREFIX/etc] + --sharedstatedir=DIR modifiable architecture-independent data [PREFIX/com] + --localstatedir=DIR modifiable single-machine data [PREFIX/var] + --libdir=DIR object code libraries [EPREFIX/lib] + --includedir=DIR C header files [PREFIX/include] + --oldincludedir=DIR C header files for non-gcc [/usr/include] + --datarootdir=DIR read-only arch.-independent data root [PREFIX/share] + --datadir=DIR read-only architecture-independent data [DATAROOTDIR] + --infodir=DIR info documentation [DATAROOTDIR/info] + --localedir=DIR locale-dependent data [DATAROOTDIR/locale] + --mandir=DIR man documentation [DATAROOTDIR/man] + --docdir=DIR documentation root [DATAROOTDIR/doc/libodb] + --htmldir=DIR html documentation [DOCDIR] + --dvidir=DIR dvi documentation [DOCDIR] + --pdfdir=DIR pdf documentation [DOCDIR] + --psdir=DIR ps documentation [DOCDIR] +_ACEOF + + cat <<\_ACEOF + +Program names: + --program-prefix=PREFIX prepend PREFIX to installed program names + --program-suffix=SUFFIX append SUFFIX to installed program names + --program-transform-name=PROGRAM run sed PROGRAM on installed program names + +System types: + --build=BUILD configure for building on BUILD [guessed] + --host=HOST cross-compile to build programs to run on HOST [BUILD] +_ACEOF +fi + +if test -n "$ac_init_help"; then + case $ac_init_help in + short | recursive ) echo "Configuration of libodb 2.4.0:";; + esac + cat <<\_ACEOF + +Optional Features: + --disable-option-checking ignore unrecognized --enable/--with options + --disable-FEATURE do not include FEATURE (same as --enable-FEATURE=no) + --enable-FEATURE[=ARG] include FEATURE [ARG=yes] + --enable-dependency-tracking + do not reject slow dependency extractors + --disable-dependency-tracking + speeds up one-time build + --enable-shared[=PKGS] build shared libraries [default=yes] + --enable-static[=PKGS] build static libraries [default=yes] + --enable-fast-install[=PKGS] + optimize for fast installation [default=yes] + --disable-libtool-lock avoid locking (might break parallel builds) + --disable-threads disable threads (enabled by default) + --disable-rpath patch libtool to not use rpath + +Optional Packages: + --with-PACKAGE[=ARG] use PACKAGE [ARG=yes] + --without-PACKAGE do not use PACKAGE (same as --with-PACKAGE=no) + --with-pic[=PKGS] try to use only PIC/non-PIC objects [default=use + both] + --with-gnu-ld assume the C compiler uses GNU ld [default=no] + --with-sysroot=DIR Search for dependent libraries within DIR + (or the compiler's sysroot if not specified). + --with-pkgconfigdir=DIR location of pkgconfig dir (default is + libdir/pkgconfig) + +Some influential environment variables: + CC C compiler command + CFLAGS C compiler flags + LDFLAGS linker flags, e.g. -L if you have libraries in a + nonstandard directory + LIBS libraries to pass to the linker, e.g. -l + CPPFLAGS (Objective) C/C++ preprocessor flags, e.g. -I if + you have headers in a nonstandard directory + CPP C preprocessor + CXX C++ compiler command + CXXFLAGS C++ compiler flags + CXXCPP C++ preprocessor + +Use these variables to override the choices made by `configure' or to help +it to find libraries and programs with nonstandard names/locations. + +Report bugs to . +_ACEOF +ac_status=$? +fi + +if test "$ac_init_help" = "recursive"; then + # If there are subdirs, report their specific --help. + for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue + test -d "$ac_dir" || + { cd "$srcdir" && ac_pwd=`pwd` && srcdir=. && test -d "$ac_dir"; } || + continue + ac_builddir=. + +case "$ac_dir" in +.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;; +*) + ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'` + # A ".." for each directory in $ac_dir_suffix. + ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'` + case $ac_top_builddir_sub in + "") ac_top_builddir_sub=. ac_top_build_prefix= ;; + *) ac_top_build_prefix=$ac_top_builddir_sub/ ;; + esac ;; +esac +ac_abs_top_builddir=$ac_pwd +ac_abs_builddir=$ac_pwd$ac_dir_suffix +# for backward compatibility: +ac_top_builddir=$ac_top_build_prefix + +case $srcdir in + .) # We are building in place. + ac_srcdir=. + ac_top_srcdir=$ac_top_builddir_sub + ac_abs_top_srcdir=$ac_pwd ;; + [\\/]* | ?:[\\/]* ) # Absolute name. + ac_srcdir=$srcdir$ac_dir_suffix; + ac_top_srcdir=$srcdir + ac_abs_top_srcdir=$srcdir ;; + *) # Relative name. + ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix + ac_top_srcdir=$ac_top_build_prefix$srcdir + ac_abs_top_srcdir=$ac_pwd/$srcdir ;; +esac +ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix + + cd "$ac_dir" || { ac_status=$?; continue; } + # Check for guested configure. + if test -f "$ac_srcdir/configure.gnu"; then + echo && + $SHELL "$ac_srcdir/configure.gnu" --help=recursive + elif test -f "$ac_srcdir/configure"; then + echo && + $SHELL "$ac_srcdir/configure" --help=recursive + else + $as_echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2 + fi || ac_status=$? + cd "$ac_pwd" || { ac_status=$?; break; } + done +fi + +test -n "$ac_init_help" && exit $ac_status +if $ac_init_version; then + cat <<\_ACEOF +libodb configure 2.4.0 +generated by GNU Autoconf 2.69 + +Copyright (C) 2012 Free Software Foundation, Inc. +This configure script is free software; the Free Software Foundation +gives unlimited permission to copy, distribute and modify it. +_ACEOF + exit +fi + +## ------------------------ ## +## Autoconf initialization. ## +## ------------------------ ## + +# ac_fn_c_try_compile LINENO +# -------------------------- +# Try to compile conftest.$ac_ext, and return whether this succeeded. +ac_fn_c_try_compile () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + rm -f conftest.$ac_objext + if { { ac_try="$ac_compile" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_compile") 2>conftest.err + ac_status=$? + if test -s conftest.err; then + grep -v '^ *+' conftest.err >conftest.er1 + cat conftest.er1 >&5 + mv -f conftest.er1 conftest.err + fi + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } && { + test -z "$ac_c_werror_flag" || + test ! -s conftest.err + } && test -s conftest.$ac_objext; then : + ac_retval=0 +else + $as_echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_retval=1 +fi + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno + as_fn_set_status $ac_retval + +} # ac_fn_c_try_compile + +# ac_fn_c_try_link LINENO +# ----------------------- +# Try to link conftest.$ac_ext, and return whether this succeeded. +ac_fn_c_try_link () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + rm -f conftest.$ac_objext conftest$ac_exeext + if { { ac_try="$ac_link" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_link") 2>conftest.err + ac_status=$? + if test -s conftest.err; then + grep -v '^ *+' conftest.err >conftest.er1 + cat conftest.er1 >&5 + mv -f conftest.er1 conftest.err + fi + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } && { + test -z "$ac_c_werror_flag" || + test ! -s conftest.err + } && test -s conftest$ac_exeext && { + test "$cross_compiling" = yes || + test -x conftest$ac_exeext + }; then : + ac_retval=0 +else + $as_echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_retval=1 +fi + # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information + # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would + # interfere with the next link command; also delete a directory that is + # left behind by Apple's compiler. We do this before executing the actions. + rm -rf conftest.dSYM conftest_ipa8_conftest.oo + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno + as_fn_set_status $ac_retval + +} # ac_fn_c_try_link + +# ac_fn_c_check_header_compile LINENO HEADER VAR INCLUDES +# ------------------------------------------------------- +# Tests whether HEADER exists and can be compiled using the include files in +# INCLUDES, setting the cache variable VAR accordingly. +ac_fn_c_check_header_compile () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 +$as_echo_n "checking for $2... " >&6; } +if eval \${$3+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +$4 +#include <$2> +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + eval "$3=yes" +else + eval "$3=no" +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +fi +eval ac_res=\$$3 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 +$as_echo "$ac_res" >&6; } + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno + +} # ac_fn_c_check_header_compile + +# ac_fn_c_try_cpp LINENO +# ---------------------- +# Try to preprocess conftest.$ac_ext, and return whether this succeeded. +ac_fn_c_try_cpp () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + if { { ac_try="$ac_cpp conftest.$ac_ext" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err + ac_status=$? + if test -s conftest.err; then + grep -v '^ *+' conftest.err >conftest.er1 + cat conftest.er1 >&5 + mv -f conftest.er1 conftest.err + fi + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } > conftest.i && { + test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" || + test ! -s conftest.err + }; then : + ac_retval=0 +else + $as_echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_retval=1 +fi + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno + as_fn_set_status $ac_retval + +} # ac_fn_c_try_cpp + +# ac_fn_c_try_run LINENO +# ---------------------- +# Try to link conftest.$ac_ext, and return whether this succeeded. Assumes +# that executables *can* be run. +ac_fn_c_try_run () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + if { { ac_try="$ac_link" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_link") 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } && { ac_try='./conftest$ac_exeext' + { { case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_try") 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; }; then : + ac_retval=0 +else + $as_echo "$as_me: program exited with status $ac_status" >&5 + $as_echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_retval=$ac_status +fi + rm -rf conftest.dSYM conftest_ipa8_conftest.oo + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno + as_fn_set_status $ac_retval + +} # ac_fn_c_try_run + +# ac_fn_c_check_func LINENO FUNC VAR +# ---------------------------------- +# Tests whether FUNC exists, setting the cache variable VAR accordingly +ac_fn_c_check_func () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 +$as_echo_n "checking for $2... " >&6; } +if eval \${$3+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +/* Define $2 to an innocuous variant, in case declares $2. + For example, HP-UX 11i declares gettimeofday. */ +#define $2 innocuous_$2 + +/* System header to define __stub macros and hopefully few prototypes, + which can conflict with char $2 (); below. + Prefer to if __STDC__ is defined, since + exists even on freestanding compilers. */ + +#ifdef __STDC__ +# include +#else +# include +#endif + +#undef $2 + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char $2 (); +/* The GNU C library defines this for functions which it implements + to always fail with ENOSYS. Some functions are actually named + something starting with __ and the normal name is an alias. */ +#if defined __stub_$2 || defined __stub___$2 +choke me +#endif + +int +main () +{ +return $2 (); + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + eval "$3=yes" +else + eval "$3=no" +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +fi +eval ac_res=\$$3 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 +$as_echo "$ac_res" >&6; } + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno + +} # ac_fn_c_check_func + +# ac_fn_cxx_try_compile LINENO +# ---------------------------- +# Try to compile conftest.$ac_ext, and return whether this succeeded. +ac_fn_cxx_try_compile () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + rm -f conftest.$ac_objext + if { { ac_try="$ac_compile" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_compile") 2>conftest.err + ac_status=$? + if test -s conftest.err; then + grep -v '^ *+' conftest.err >conftest.er1 + cat conftest.er1 >&5 + mv -f conftest.er1 conftest.err + fi + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } && { + test -z "$ac_cxx_werror_flag" || + test ! -s conftest.err + } && test -s conftest.$ac_objext; then : + ac_retval=0 +else + $as_echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_retval=1 +fi + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno + as_fn_set_status $ac_retval + +} # ac_fn_cxx_try_compile + +# ac_fn_cxx_try_cpp LINENO +# ------------------------ +# Try to preprocess conftest.$ac_ext, and return whether this succeeded. +ac_fn_cxx_try_cpp () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + if { { ac_try="$ac_cpp conftest.$ac_ext" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err + ac_status=$? + if test -s conftest.err; then + grep -v '^ *+' conftest.err >conftest.er1 + cat conftest.er1 >&5 + mv -f conftest.er1 conftest.err + fi + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } > conftest.i && { + test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" || + test ! -s conftest.err + }; then : + ac_retval=0 +else + $as_echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_retval=1 +fi + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno + as_fn_set_status $ac_retval + +} # ac_fn_cxx_try_cpp + +# ac_fn_cxx_try_link LINENO +# ------------------------- +# Try to link conftest.$ac_ext, and return whether this succeeded. +ac_fn_cxx_try_link () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + rm -f conftest.$ac_objext conftest$ac_exeext + if { { ac_try="$ac_link" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_link") 2>conftest.err + ac_status=$? + if test -s conftest.err; then + grep -v '^ *+' conftest.err >conftest.er1 + cat conftest.er1 >&5 + mv -f conftest.er1 conftest.err + fi + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } && { + test -z "$ac_cxx_werror_flag" || + test ! -s conftest.err + } && test -s conftest$ac_exeext && { + test "$cross_compiling" = yes || + test -x conftest$ac_exeext + }; then : + ac_retval=0 +else + $as_echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_retval=1 +fi + # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information + # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would + # interfere with the next link command; also delete a directory that is + # left behind by Apple's compiler. We do this before executing the actions. + rm -rf conftest.dSYM conftest_ipa8_conftest.oo + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno + as_fn_set_status $ac_retval + +} # ac_fn_cxx_try_link +cat >config.log <<_ACEOF +This file contains any messages produced by compilers while +running configure, to aid debugging if configure makes a mistake. + +It was created by libodb $as_me 2.4.0, which was +generated by GNU Autoconf 2.69. Invocation command line was + + $ $0 $@ + +_ACEOF +exec 5>>config.log +{ +cat <<_ASUNAME +## --------- ## +## Platform. ## +## --------- ## + +hostname = `(hostname || uname -n) 2>/dev/null | sed 1q` +uname -m = `(uname -m) 2>/dev/null || echo unknown` +uname -r = `(uname -r) 2>/dev/null || echo unknown` +uname -s = `(uname -s) 2>/dev/null || echo unknown` +uname -v = `(uname -v) 2>/dev/null || echo unknown` + +/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown` +/bin/uname -X = `(/bin/uname -X) 2>/dev/null || echo unknown` + +/bin/arch = `(/bin/arch) 2>/dev/null || echo unknown` +/usr/bin/arch -k = `(/usr/bin/arch -k) 2>/dev/null || echo unknown` +/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown` +/usr/bin/hostinfo = `(/usr/bin/hostinfo) 2>/dev/null || echo unknown` +/bin/machine = `(/bin/machine) 2>/dev/null || echo unknown` +/usr/bin/oslevel = `(/usr/bin/oslevel) 2>/dev/null || echo unknown` +/bin/universe = `(/bin/universe) 2>/dev/null || echo unknown` + +_ASUNAME + +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + $as_echo "PATH: $as_dir" + done +IFS=$as_save_IFS + +} >&5 + +cat >&5 <<_ACEOF + + +## ----------- ## +## Core tests. ## +## ----------- ## + +_ACEOF + + +# Keep a trace of the command line. +# Strip out --no-create and --no-recursion so they do not pile up. +# Strip out --silent because we don't want to record it for future runs. +# Also quote any args containing shell meta-characters. +# Make two passes to allow for proper duplicate-argument suppression. +ac_configure_args= +ac_configure_args0= +ac_configure_args1= +ac_must_keep_next=false +for ac_pass in 1 2 +do + for ac_arg + do + case $ac_arg in + -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;; + -q | -quiet | --quiet | --quie | --qui | --qu | --q \ + | -silent | --silent | --silen | --sile | --sil) + continue ;; + *\'*) + ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;; + esac + case $ac_pass in + 1) as_fn_append ac_configure_args0 " '$ac_arg'" ;; + 2) + as_fn_append ac_configure_args1 " '$ac_arg'" + if test $ac_must_keep_next = true; then + ac_must_keep_next=false # Got value, back to normal. + else + case $ac_arg in + *=* | --config-cache | -C | -disable-* | --disable-* \ + | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \ + | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \ + | -with-* | --with-* | -without-* | --without-* | --x) + case "$ac_configure_args0 " in + "$ac_configure_args1"*" '$ac_arg' "* ) continue ;; + esac + ;; + -* ) ac_must_keep_next=true ;; + esac + fi + as_fn_append ac_configure_args " '$ac_arg'" + ;; + esac + done +done +{ ac_configure_args0=; unset ac_configure_args0;} +{ ac_configure_args1=; unset ac_configure_args1;} + +# When interrupted or exit'd, cleanup temporary files, and complete +# config.log. We remove comments because anyway the quotes in there +# would cause problems or look ugly. +# WARNING: Use '\'' to represent an apostrophe within the trap. +# WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug. +trap 'exit_status=$? + # Save into config.log some information that might help in debugging. + { + echo + + $as_echo "## ---------------- ## +## Cache variables. ## +## ---------------- ##" + echo + # The following way of writing the cache mishandles newlines in values, +( + for ac_var in `(set) 2>&1 | sed -n '\''s/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'\''`; do + eval ac_val=\$$ac_var + case $ac_val in #( + *${as_nl}*) + case $ac_var in #( + *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5 +$as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;; + esac + case $ac_var in #( + _ | IFS | as_nl) ;; #( + BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #( + *) { eval $ac_var=; unset $ac_var;} ;; + esac ;; + esac + done + (set) 2>&1 | + case $as_nl`(ac_space='\'' '\''; set) 2>&1` in #( + *${as_nl}ac_space=\ *) + sed -n \ + "s/'\''/'\''\\\\'\'''\''/g; + s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\''\\2'\''/p" + ;; #( + *) + sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p" + ;; + esac | + sort +) + echo + + $as_echo "## ----------------- ## +## Output variables. ## +## ----------------- ##" + echo + for ac_var in $ac_subst_vars + do + eval ac_val=\$$ac_var + case $ac_val in + *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;; + esac + $as_echo "$ac_var='\''$ac_val'\''" + done | sort + echo + + if test -n "$ac_subst_files"; then + $as_echo "## ------------------- ## +## File substitutions. ## +## ------------------- ##" + echo + for ac_var in $ac_subst_files + do + eval ac_val=\$$ac_var + case $ac_val in + *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;; + esac + $as_echo "$ac_var='\''$ac_val'\''" + done | sort + echo + fi + + if test -s confdefs.h; then + $as_echo "## ----------- ## +## confdefs.h. ## +## ----------- ##" + echo + cat confdefs.h + echo + fi + test "$ac_signal" != 0 && + $as_echo "$as_me: caught signal $ac_signal" + $as_echo "$as_me: exit $exit_status" + } >&5 + rm -f core *.core core.conftest.* && + rm -f -r conftest* confdefs* conf$$* $ac_clean_files && + exit $exit_status +' 0 +for ac_signal in 1 2 13 15; do + trap 'ac_signal='$ac_signal'; as_fn_exit 1' $ac_signal +done +ac_signal=0 + +# confdefs.h avoids OS command line length limits that DEFS can exceed. +rm -f -r conftest* confdefs.h + +$as_echo "/* confdefs.h */" > confdefs.h + +# Predefined preprocessor variables. + +cat >>confdefs.h <<_ACEOF +#define PACKAGE_NAME "$PACKAGE_NAME" +_ACEOF + +cat >>confdefs.h <<_ACEOF +#define PACKAGE_TARNAME "$PACKAGE_TARNAME" +_ACEOF + +cat >>confdefs.h <<_ACEOF +#define PACKAGE_VERSION "$PACKAGE_VERSION" +_ACEOF + +cat >>confdefs.h <<_ACEOF +#define PACKAGE_STRING "$PACKAGE_STRING" +_ACEOF + +cat >>confdefs.h <<_ACEOF +#define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT" +_ACEOF + +cat >>confdefs.h <<_ACEOF +#define PACKAGE_URL "$PACKAGE_URL" +_ACEOF + + +# Let the site file select an alternate cache file if it wants to. +# Prefer an explicitly selected file to automatically selected ones. +ac_site_file1=NONE +ac_site_file2=NONE +if test -n "$CONFIG_SITE"; then + # We do not want a PATH search for config.site. + case $CONFIG_SITE in #(( + -*) ac_site_file1=./$CONFIG_SITE;; + */*) ac_site_file1=$CONFIG_SITE;; + *) ac_site_file1=./$CONFIG_SITE;; + esac +elif test "x$prefix" != xNONE; then + ac_site_file1=$prefix/share/config.site + ac_site_file2=$prefix/etc/config.site +else + ac_site_file1=$ac_default_prefix/share/config.site + ac_site_file2=$ac_default_prefix/etc/config.site +fi +for ac_site_file in "$ac_site_file1" "$ac_site_file2" +do + test "x$ac_site_file" = xNONE && continue + if test /dev/null != "$ac_site_file" && test -r "$ac_site_file"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5 +$as_echo "$as_me: loading site script $ac_site_file" >&6;} + sed 's/^/| /' "$ac_site_file" >&5 + . "$ac_site_file" \ + || { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 +$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} +as_fn_error $? "failed to load site script $ac_site_file +See \`config.log' for more details" "$LINENO" 5; } + fi +done + +if test -r "$cache_file"; then + # Some versions of bash will fail to source /dev/null (special files + # actually), so we avoid doing that. DJGPP emulates it as a regular file. + if test /dev/null != "$cache_file" && test -f "$cache_file"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5 +$as_echo "$as_me: loading cache $cache_file" >&6;} + case $cache_file in + [\\/]* | ?:[\\/]* ) . "$cache_file";; + *) . "./$cache_file";; + esac + fi +else + { $as_echo "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5 +$as_echo "$as_me: creating cache $cache_file" >&6;} + >$cache_file +fi + +# Check that the precious variables saved in the cache have kept the same +# value. +ac_cache_corrupted=false +for ac_var in $ac_precious_vars; do + eval ac_old_set=\$ac_cv_env_${ac_var}_set + eval ac_new_set=\$ac_env_${ac_var}_set + eval ac_old_val=\$ac_cv_env_${ac_var}_value + eval ac_new_val=\$ac_env_${ac_var}_value + case $ac_old_set,$ac_new_set in + set,) + { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5 +$as_echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;} + ac_cache_corrupted=: ;; + ,set) + { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was not set in the previous run" >&5 +$as_echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;} + ac_cache_corrupted=: ;; + ,);; + *) + if test "x$ac_old_val" != "x$ac_new_val"; then + # differences in whitespace do not lead to failure. + ac_old_val_w=`echo x $ac_old_val` + ac_new_val_w=`echo x $ac_new_val` + if test "$ac_old_val_w" != "$ac_new_val_w"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' has changed since the previous run:" >&5 +$as_echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;} + ac_cache_corrupted=: + else + { $as_echo "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5 +$as_echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;} + eval $ac_var=\$ac_old_val + fi + { $as_echo "$as_me:${as_lineno-$LINENO}: former value: \`$ac_old_val'" >&5 +$as_echo "$as_me: former value: \`$ac_old_val'" >&2;} + { $as_echo "$as_me:${as_lineno-$LINENO}: current value: \`$ac_new_val'" >&5 +$as_echo "$as_me: current value: \`$ac_new_val'" >&2;} + fi;; + esac + # Pass precious variables to config.status. + if test "$ac_new_set" = set; then + case $ac_new_val in + *\'*) ac_arg=$ac_var=`$as_echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;; + *) ac_arg=$ac_var=$ac_new_val ;; + esac + case " $ac_configure_args " in + *" '$ac_arg' "*) ;; # Avoid dups. Use of quotes ensures accuracy. + *) as_fn_append ac_configure_args " '$ac_arg'" ;; + esac + fi +done +if $ac_cache_corrupted; then + { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 +$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} + { $as_echo "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5 +$as_echo "$as_me: error: changes in the environment can compromise the build" >&2;} + as_fn_error $? "run \`make distclean' and/or \`rm $cache_file' and start over" "$LINENO" 5 +fi +## -------------------- ## +## Main body of script. ## +## -------------------- ## + +ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu + + +ac_aux_dir= +for ac_dir in config "$srcdir"/config; do + if test -f "$ac_dir/install-sh"; then + ac_aux_dir=$ac_dir + ac_install_sh="$ac_aux_dir/install-sh -c" + break + elif test -f "$ac_dir/install.sh"; then + ac_aux_dir=$ac_dir + ac_install_sh="$ac_aux_dir/install.sh -c" + break + elif test -f "$ac_dir/shtool"; then + ac_aux_dir=$ac_dir + ac_install_sh="$ac_aux_dir/shtool install -c" + break + fi +done +if test -z "$ac_aux_dir"; then + as_fn_error $? "cannot find install-sh, install.sh, or shtool in config \"$srcdir\"/config" "$LINENO" 5 +fi + +# These three variables are undocumented and unsupported, +# and are intended to be withdrawn in a future Autoconf release. +# They can cause serious problems if a builder's source tree is in a directory +# whose full name contains unusual characters. +ac_config_guess="$SHELL $ac_aux_dir/config.guess" # Please don't use this var. +ac_config_sub="$SHELL $ac_aux_dir/config.sub" # Please don't use this var. +ac_configure="$SHELL $ac_aux_dir/configure" # Please don't use this var. + + + + + +am__api_version='1.12' + +# Find a good install program. We prefer a C program (faster), +# so one script is as good as another. But avoid the broken or +# incompatible versions: +# SysV /etc/install, /usr/sbin/install +# SunOS /usr/etc/install +# IRIX /sbin/install +# AIX /bin/install +# AmigaOS /C/install, which installs bootblocks on floppy discs +# AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag +# AFS /usr/afsws/bin/install, which mishandles nonexistent args +# SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff" +# OS/2's system install, which has a completely different semantic +# ./install, which can be erroneously created by make from ./install.sh. +# Reject install programs that cannot install multiple files. +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for a BSD-compatible install" >&5 +$as_echo_n "checking for a BSD-compatible install... " >&6; } +if test -z "$INSTALL"; then +if ${ac_cv_path_install+:} false; then : + $as_echo_n "(cached) " >&6 +else + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + # Account for people who put trailing slashes in PATH elements. +case $as_dir/ in #(( + ./ | .// | /[cC]/* | \ + /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \ + ?:[\\/]os2[\\/]install[\\/]* | ?:[\\/]OS2[\\/]INSTALL[\\/]* | \ + /usr/ucb/* ) ;; + *) + # OSF1 and SCO ODT 3.0 have their own names for install. + # Don't use installbsd from OSF since it installs stuff as root + # by default. + for ac_prog in ginstall scoinst install; do + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then + if test $ac_prog = install && + grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then + # AIX install. It has an incompatible calling convention. + : + elif test $ac_prog = install && + grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then + # program-specific install script used by HP pwplus--don't use. + : + else + rm -rf conftest.one conftest.two conftest.dir + echo one > conftest.one + echo two > conftest.two + mkdir conftest.dir + if "$as_dir/$ac_prog$ac_exec_ext" -c conftest.one conftest.two "`pwd`/conftest.dir" && + test -s conftest.one && test -s conftest.two && + test -s conftest.dir/conftest.one && + test -s conftest.dir/conftest.two + then + ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c" + break 3 + fi + fi + fi + done + done + ;; +esac + + done +IFS=$as_save_IFS + +rm -rf conftest.one conftest.two conftest.dir + +fi + if test "${ac_cv_path_install+set}" = set; then + INSTALL=$ac_cv_path_install + else + # As a last resort, use the slow shell script. Don't cache a + # value for INSTALL within a source directory, because that will + # break other packages using the cache if that directory is + # removed, or if the value is a relative name. + INSTALL=$ac_install_sh + fi +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $INSTALL" >&5 +$as_echo "$INSTALL" >&6; } + +# Use test -z because SunOS4 sh mishandles braces in ${var-val}. +# It thinks the first close brace ends the variable substitution. +test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}' + +test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}' + +test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644' + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether build environment is sane" >&5 +$as_echo_n "checking whether build environment is sane... " >&6; } +# Reject unsafe characters in $srcdir or the absolute working directory +# name. Accept space and tab only in the latter. +am_lf=' +' +case `pwd` in + *[\\\"\#\$\&\'\`$am_lf]*) + as_fn_error $? "unsafe absolute working directory name" "$LINENO" 5;; +esac +case $srcdir in + *[\\\"\#\$\&\'\`$am_lf\ \ ]*) + as_fn_error $? "unsafe srcdir value: '$srcdir'" "$LINENO" 5;; +esac + +# Do 'set' in a subshell so we don't clobber the current shell's +# arguments. Must try -L first in case configure is actually a +# symlink; some systems play weird games with the mod time of symlinks +# (eg FreeBSD returns the mod time of the symlink's containing +# directory). +if ( + am_has_slept=no + for am_try in 1 2; do + echo "timestamp, slept: $am_has_slept" > conftest.file + set X `ls -Lt "$srcdir/configure" conftest.file 2> /dev/null` + if test "$*" = "X"; then + # -L didn't work. + set X `ls -t "$srcdir/configure" conftest.file` + fi + if test "$*" != "X $srcdir/configure conftest.file" \ + && test "$*" != "X conftest.file $srcdir/configure"; then + + # If neither matched, then we have a broken ls. This can happen + # if, for instance, CONFIG_SHELL is bash and it inherits a + # broken ls alias from the environment. This has actually + # happened. Such a system could not be considered "sane". + as_fn_error $? "ls -t appears to fail. Make sure there is not a broken + alias in your environment" "$LINENO" 5 + fi + if test "$2" = conftest.file || test $am_try -eq 2; then + break + fi + # Just in case. + sleep 1 + am_has_slept=yes + done + test "$2" = conftest.file + ) +then + # Ok. + : +else + as_fn_error $? "newly created file is older than distributed files! +Check your system clock" "$LINENO" 5 +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +$as_echo "yes" >&6; } +# If we didn't sleep, we still need to ensure time stamps of config.status and +# generated files are strictly newer. +am_sleep_pid= +if grep 'slept: no' conftest.file >/dev/null 2>&1; then + ( sleep 1 ) & + am_sleep_pid=$! +fi + +rm -f conftest.file + +test "$program_prefix" != NONE && + program_transform_name="s&^&$program_prefix&;$program_transform_name" +# Use a double $ so make ignores it. +test "$program_suffix" != NONE && + program_transform_name="s&\$&$program_suffix&;$program_transform_name" +# Double any \ or $. +# By default was `s,x,x', remove it if useless. +ac_script='s/[\\$]/&&/g;s/;s,x,x,$//' +program_transform_name=`$as_echo "$program_transform_name" | sed "$ac_script"` + +# expand $ac_aux_dir to an absolute path +am_aux_dir=`cd $ac_aux_dir && pwd` + +if test x"${MISSING+set}" != xset; then + case $am_aux_dir in + *\ * | *\ *) + MISSING="\${SHELL} \"$am_aux_dir/missing\"" ;; + *) + MISSING="\${SHELL} $am_aux_dir/missing" ;; + esac +fi +# Use eval to expand $SHELL +if eval "$MISSING --run true"; then + am_missing_run="$MISSING --run " +else + am_missing_run= + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: 'missing' script is too old or missing" >&5 +$as_echo "$as_me: WARNING: 'missing' script is too old or missing" >&2;} +fi + +if test x"${install_sh}" != xset; then + case $am_aux_dir in + *\ * | *\ *) + install_sh="\${SHELL} '$am_aux_dir/install-sh'" ;; + *) + install_sh="\${SHELL} $am_aux_dir/install-sh" + esac +fi + +# Installed binaries are usually stripped using 'strip' when the user +# run "make install-strip". However 'strip' might not be the right +# tool to use in cross-compilation environments, therefore Automake +# will honor the 'STRIP' environment variable to overrule this program. +if test "$cross_compiling" != no; then + if test -n "$ac_tool_prefix"; then + # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args. +set dummy ${ac_tool_prefix}strip; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_STRIP+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$STRIP"; then + ac_cv_prog_STRIP="$STRIP" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_STRIP="${ac_tool_prefix}strip" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +STRIP=$ac_cv_prog_STRIP +if test -n "$STRIP"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5 +$as_echo "$STRIP" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test -z "$ac_cv_prog_STRIP"; then + ac_ct_STRIP=$STRIP + # Extract the first word of "strip", so it can be a program name with args. +set dummy strip; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_ac_ct_STRIP+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_STRIP"; then + ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_STRIP="strip" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP +if test -n "$ac_ct_STRIP"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_STRIP" >&5 +$as_echo "$ac_ct_STRIP" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + if test "x$ac_ct_STRIP" = x; then + STRIP=":" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + STRIP=$ac_ct_STRIP + fi +else + STRIP="$ac_cv_prog_STRIP" +fi + +fi +INSTALL_STRIP_PROGRAM="\$(install_sh) -c -s" + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for a thread-safe mkdir -p" >&5 +$as_echo_n "checking for a thread-safe mkdir -p... " >&6; } +if test -z "$MKDIR_P"; then + if ${ac_cv_path_mkdir+:} false; then : + $as_echo_n "(cached) " >&6 +else + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH$PATH_SEPARATOR/opt/sfw/bin +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_prog in mkdir gmkdir; do + for ac_exec_ext in '' $ac_executable_extensions; do + as_fn_executable_p "$as_dir/$ac_prog$ac_exec_ext" || continue + case `"$as_dir/$ac_prog$ac_exec_ext" --version 2>&1` in #( + 'mkdir (GNU coreutils) '* | \ + 'mkdir (coreutils) '* | \ + 'mkdir (fileutils) '4.1*) + ac_cv_path_mkdir=$as_dir/$ac_prog$ac_exec_ext + break 3;; + esac + done + done + done +IFS=$as_save_IFS + +fi + + test -d ./--version && rmdir ./--version + if test "${ac_cv_path_mkdir+set}" = set; then + MKDIR_P="$ac_cv_path_mkdir -p" + else + # As a last resort, use the slow shell script. Don't cache a + # value for MKDIR_P within a source directory, because that will + # break other packages using the cache if that directory is + # removed, or if the value is a relative name. + MKDIR_P="$ac_install_sh -d" + fi +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR_P" >&5 +$as_echo "$MKDIR_P" >&6; } + +for ac_prog in gawk mawk nawk awk +do + # Extract the first word of "$ac_prog", so it can be a program name with args. +set dummy $ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_AWK+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$AWK"; then + ac_cv_prog_AWK="$AWK" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_AWK="$ac_prog" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +AWK=$ac_cv_prog_AWK +if test -n "$AWK"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5 +$as_echo "$AWK" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$AWK" && break +done + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${MAKE-make} sets \$(MAKE)" >&5 +$as_echo_n "checking whether ${MAKE-make} sets \$(MAKE)... " >&6; } +set x ${MAKE-make} +ac_make=`$as_echo "$2" | sed 's/+/p/g; s/[^a-zA-Z0-9_]/_/g'` +if eval \${ac_cv_prog_make_${ac_make}_set+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat >conftest.make <<\_ACEOF +SHELL = /bin/sh +all: + @echo '@@@%%%=$(MAKE)=@@@%%%' +_ACEOF +# GNU make sometimes prints "make[1]: Entering ...", which would confuse us. +case `${MAKE-make} -f conftest.make 2>/dev/null` in + *@@@%%%=?*=@@@%%%*) + eval ac_cv_prog_make_${ac_make}_set=yes;; + *) + eval ac_cv_prog_make_${ac_make}_set=no;; +esac +rm -f conftest.make +fi +if eval test \$ac_cv_prog_make_${ac_make}_set = yes; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +$as_echo "yes" >&6; } + SET_MAKE= +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } + SET_MAKE="MAKE=${MAKE-make}" +fi + +rm -rf .tst 2>/dev/null +mkdir .tst 2>/dev/null +if test -d .tst; then + am__leading_dot=. +else + am__leading_dot=_ +fi +rmdir .tst 2>/dev/null + +if test "`cd $srcdir && pwd`" != "`pwd`"; then + # Use -I$(srcdir) only when $(srcdir) != ., so that make's output + # is not polluted with repeated "-I." + am__isrc=' -I$(srcdir)' + # test to see if srcdir already configured + if test -f $srcdir/config.status; then + as_fn_error $? "source directory already configured; run \"make distclean\" there first" "$LINENO" 5 + fi +fi + +# test whether we have cygpath +if test -z "$CYGPATH_W"; then + if (cygpath --version) >/dev/null 2>/dev/null; then + CYGPATH_W='cygpath -w' + else + CYGPATH_W=echo + fi +fi + + +# Define the identity of the package. + PACKAGE='libodb' + VERSION='2.4.0' + + +cat >>confdefs.h <<_ACEOF +#define PACKAGE "$PACKAGE" +_ACEOF + + +cat >>confdefs.h <<_ACEOF +#define VERSION "$VERSION" +_ACEOF + +# Some tools Automake needs. + +ACLOCAL=${ACLOCAL-"${am_missing_run}aclocal-${am__api_version}"} + + +AUTOCONF=${AUTOCONF-"${am_missing_run}autoconf"} + + +AUTOMAKE=${AUTOMAKE-"${am_missing_run}automake-${am__api_version}"} + + +AUTOHEADER=${AUTOHEADER-"${am_missing_run}autoheader"} + + +MAKEINFO=${MAKEINFO-"${am_missing_run}makeinfo"} + +# For better backward compatibility. To be removed once Automake 1.9.x +# dies out for good. For more background, see: +# +# +mkdir_p='$(MKDIR_P)' + +# We need awk for the "check" target. The system "awk" is bad on +# some platforms. +# Always define AMTAR for backward compatibility. Yes, it's still used +# in the wild :-( We should find a proper way to deprecate it ... +AMTAR='$${TAR-tar}' + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to create a ustar tar archive" >&5 +$as_echo_n "checking how to create a ustar tar archive... " >&6; } +# Loop over all known methods to create a tar archive until one works. +_am_tools='gnutar plaintar pax cpio none' +_am_tools=${am_cv_prog_tar_ustar-$_am_tools} +# Do not fold the above two line into one, because Tru64 sh and +# Solaris sh will not grok spaces in the rhs of '-'. +for _am_tool in $_am_tools +do + case $_am_tool in + gnutar) + for _am_tar in tar gnutar gtar; + do + { echo "$as_me:$LINENO: $_am_tar --version" >&5 + ($_am_tar --version) >&5 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && break + done + am__tar="$_am_tar --format=ustar -chf - "'"$$tardir"' + am__tar_="$_am_tar --format=ustar -chf - "'"$tardir"' + am__untar="$_am_tar -xf -" + ;; + plaintar) + # Must skip GNU tar: if it does not support --format= it doesn't create + # ustar tarball either. + (tar --version) >/dev/null 2>&1 && continue + am__tar='tar chf - "$$tardir"' + am__tar_='tar chf - "$tardir"' + am__untar='tar xf -' + ;; + pax) + am__tar='pax -L -x ustar -w "$$tardir"' + am__tar_='pax -L -x ustar -w "$tardir"' + am__untar='pax -r' + ;; + cpio) + am__tar='find "$$tardir" -print | cpio -o -H ustar -L' + am__tar_='find "$tardir" -print | cpio -o -H ustar -L' + am__untar='cpio -i -H ustar -d' + ;; + none) + am__tar=false + am__tar_=false + am__untar=false + ;; + esac + + # If the value was cached, stop now. We just wanted to have am__tar + # and am__untar set. + test -n "${am_cv_prog_tar_ustar}" && break + + # tar/untar a dummy directory, and stop if the command works + rm -rf conftest.dir + mkdir conftest.dir + echo GrepMe > conftest.dir/file + { echo "$as_me:$LINENO: tardir=conftest.dir && eval $am__tar_ >conftest.tar" >&5 + (tardir=conftest.dir && eval $am__tar_ >conftest.tar) >&5 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } + rm -rf conftest.dir + if test -s conftest.tar; then + { echo "$as_me:$LINENO: $am__untar &5 + ($am__untar &5 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } + grep GrepMe conftest.dir/file >/dev/null 2>&1 && break + fi +done +rm -rf conftest.dir + +if ${am_cv_prog_tar_ustar+:} false; then : + $as_echo_n "(cached) " >&6 +else + am_cv_prog_tar_ustar=$_am_tool +fi + +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_prog_tar_ustar" >&5 +$as_echo "$am_cv_prog_tar_ustar" >&6; } + + + + + +DEPDIR="${am__leading_dot}deps" + +ac_config_commands="$ac_config_commands depfiles" + + +am_make=${MAKE-make} +cat > confinc << 'END' +am__doit: + @echo this is the am__doit target +.PHONY: am__doit +END +# If we don't find an include directive, just comment out the code. +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for style of include used by $am_make" >&5 +$as_echo_n "checking for style of include used by $am_make... " >&6; } +am__include="#" +am__quote= +_am_result=none +# First try GNU make style include. +echo "include confinc" > confmf +# Ignore all kinds of additional output from 'make'. +case `$am_make -s -f confmf 2> /dev/null` in #( +*the\ am__doit\ target*) + am__include=include + am__quote= + _am_result=GNU + ;; +esac +# Now try BSD make style include. +if test "$am__include" = "#"; then + echo '.include "confinc"' > confmf + case `$am_make -s -f confmf 2> /dev/null` in #( + *the\ am__doit\ target*) + am__include=.include + am__quote="\"" + _am_result=BSD + ;; + esac +fi + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $_am_result" >&5 +$as_echo "$_am_result" >&6; } +rm -f confinc confmf + +# Check whether --enable-dependency-tracking was given. +if test "${enable_dependency_tracking+set}" = set; then : + enableval=$enable_dependency_tracking; +fi + +if test "x$enable_dependency_tracking" != xno; then + am_depcomp="$ac_aux_dir/depcomp" + AMDEPBACKSLASH='\' + am__nodep='_no' +fi + if test "x$enable_dependency_tracking" != xno; then + AMDEP_TRUE= + AMDEP_FALSE='#' +else + AMDEP_TRUE='#' + AMDEP_FALSE= +fi + + +ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu +if test -n "$ac_tool_prefix"; then + # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args. +set dummy ${ac_tool_prefix}gcc; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_CC+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$CC"; then + ac_cv_prog_CC="$CC" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_CC="${ac_tool_prefix}gcc" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +CC=$ac_cv_prog_CC +if test -n "$CC"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 +$as_echo "$CC" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test -z "$ac_cv_prog_CC"; then + ac_ct_CC=$CC + # Extract the first word of "gcc", so it can be a program name with args. +set dummy gcc; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_ac_ct_CC+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_CC"; then + ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_CC="gcc" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_CC=$ac_cv_prog_ac_ct_CC +if test -n "$ac_ct_CC"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5 +$as_echo "$ac_ct_CC" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + if test "x$ac_ct_CC" = x; then + CC="" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + CC=$ac_ct_CC + fi +else + CC="$ac_cv_prog_CC" +fi + +if test -z "$CC"; then + if test -n "$ac_tool_prefix"; then + # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args. +set dummy ${ac_tool_prefix}cc; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_CC+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$CC"; then + ac_cv_prog_CC="$CC" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_CC="${ac_tool_prefix}cc" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +CC=$ac_cv_prog_CC +if test -n "$CC"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 +$as_echo "$CC" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + fi +fi +if test -z "$CC"; then + # Extract the first word of "cc", so it can be a program name with args. +set dummy cc; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_CC+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$CC"; then + ac_cv_prog_CC="$CC" # Let the user override the test. +else + ac_prog_rejected=no +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then + ac_prog_rejected=yes + continue + fi + ac_cv_prog_CC="cc" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +if test $ac_prog_rejected = yes; then + # We found a bogon in the path, so make sure we never use it. + set dummy $ac_cv_prog_CC + shift + if test $# != 0; then + # We chose a different compiler from the bogus one. + # However, it has the same basename, so the bogon will be chosen + # first if we set CC to just the basename; use the full file name. + shift + ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@" + fi +fi +fi +fi +CC=$ac_cv_prog_CC +if test -n "$CC"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 +$as_echo "$CC" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test -z "$CC"; then + if test -n "$ac_tool_prefix"; then + for ac_prog in cl.exe + do + # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args. +set dummy $ac_tool_prefix$ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_CC+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$CC"; then + ac_cv_prog_CC="$CC" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_CC="$ac_tool_prefix$ac_prog" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +CC=$ac_cv_prog_CC +if test -n "$CC"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 +$as_echo "$CC" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$CC" && break + done +fi +if test -z "$CC"; then + ac_ct_CC=$CC + for ac_prog in cl.exe +do + # Extract the first word of "$ac_prog", so it can be a program name with args. +set dummy $ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_ac_ct_CC+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_CC"; then + ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_CC="$ac_prog" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_CC=$ac_cv_prog_ac_ct_CC +if test -n "$ac_ct_CC"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5 +$as_echo "$ac_ct_CC" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$ac_ct_CC" && break +done + + if test "x$ac_ct_CC" = x; then + CC="" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + CC=$ac_ct_CC + fi +fi + +fi + + +test -z "$CC" && { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 +$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} +as_fn_error $? "no acceptable C compiler found in \$PATH +See \`config.log' for more details" "$LINENO" 5; } + +# Provide some information about the compiler. +$as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5 +set X $ac_compile +ac_compiler=$2 +for ac_option in --version -v -V -qversion; do + { { ac_try="$ac_compiler $ac_option >&5" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_compiler $ac_option >&5") 2>conftest.err + ac_status=$? + if test -s conftest.err; then + sed '10a\ +... rest of stderr output deleted ... + 10q' conftest.err >conftest.er1 + cat conftest.er1 >&5 + fi + rm -f conftest.er1 conftest.err + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } +done + +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +ac_clean_files_save=$ac_clean_files +ac_clean_files="$ac_clean_files a.out a.out.dSYM a.exe b.out" +# Try to create an executable without -o first, disregard a.out. +# It will help us diagnose broken compilers, and finding out an intuition +# of exeext. +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C compiler works" >&5 +$as_echo_n "checking whether the C compiler works... " >&6; } +ac_link_default=`$as_echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'` + +# The possible output files: +ac_files="a.out conftest.exe conftest a.exe a_out.exe b.out conftest.*" + +ac_rmfiles= +for ac_file in $ac_files +do + case $ac_file in + *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;; + * ) ac_rmfiles="$ac_rmfiles $ac_file";; + esac +done +rm -f $ac_rmfiles + +if { { ac_try="$ac_link_default" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_link_default") 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then : + # Autoconf-2.13 could set the ac_cv_exeext variable to `no'. +# So ignore a value of `no', otherwise this would lead to `EXEEXT = no' +# in a Makefile. We should not override ac_cv_exeext if it was cached, +# so that the user can short-circuit this test for compilers unknown to +# Autoconf. +for ac_file in $ac_files '' +do + test -f "$ac_file" || continue + case $ac_file in + *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) + ;; + [ab].out ) + # We found the default executable, but exeext='' is most + # certainly right. + break;; + *.* ) + if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no; + then :; else + ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'` + fi + # We set ac_cv_exeext here because the later test for it is not + # safe: cross compilers may not add the suffix if given an `-o' + # argument, so we may need to know it at that point already. + # Even if this section looks crufty: it has the advantage of + # actually working. + break;; + * ) + break;; + esac +done +test "$ac_cv_exeext" = no && ac_cv_exeext= + +else + ac_file='' +fi +if test -z "$ac_file"; then : + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +$as_echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 +$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} +as_fn_error 77 "C compiler cannot create executables +See \`config.log' for more details" "$LINENO" 5; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +$as_echo "yes" >&6; } +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler default output file name" >&5 +$as_echo_n "checking for C compiler default output file name... " >&6; } +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_file" >&5 +$as_echo "$ac_file" >&6; } +ac_exeext=$ac_cv_exeext + +rm -f -r a.out a.out.dSYM a.exe conftest$ac_cv_exeext b.out +ac_clean_files=$ac_clean_files_save +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of executables" >&5 +$as_echo_n "checking for suffix of executables... " >&6; } +if { { ac_try="$ac_link" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_link") 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then : + # If both `conftest.exe' and `conftest' are `present' (well, observable) +# catch `conftest.exe'. For instance with Cygwin, `ls conftest' will +# work properly (i.e., refer to `conftest.exe'), while it won't with +# `rm'. +for ac_file in conftest.exe conftest conftest.*; do + test -f "$ac_file" || continue + case $ac_file in + *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;; + *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'` + break;; + * ) break;; + esac +done +else + { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 +$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} +as_fn_error $? "cannot compute suffix of executables: cannot compile and link +See \`config.log' for more details" "$LINENO" 5; } +fi +rm -f conftest conftest$ac_cv_exeext +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5 +$as_echo "$ac_cv_exeext" >&6; } + +rm -f conftest.$ac_ext +EXEEXT=$ac_cv_exeext +ac_exeext=$EXEEXT +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +int +main () +{ +FILE *f = fopen ("conftest.out", "w"); + return ferror (f) || fclose (f) != 0; + + ; + return 0; +} +_ACEOF +ac_clean_files="$ac_clean_files conftest.out" +# Check that the compiler produces executables we can run. If not, either +# the compiler is broken, or we cross compile. +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are cross compiling" >&5 +$as_echo_n "checking whether we are cross compiling... " >&6; } +if test "$cross_compiling" != yes; then + { { ac_try="$ac_link" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_link") 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } + if { ac_try='./conftest$ac_cv_exeext' + { { case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_try") 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; }; then + cross_compiling=no + else + if test "$cross_compiling" = maybe; then + cross_compiling=yes + else + { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 +$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} +as_fn_error $? "cannot run C compiled programs. +If you meant to cross compile, use \`--host'. +See \`config.log' for more details" "$LINENO" 5; } + fi + fi +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $cross_compiling" >&5 +$as_echo "$cross_compiling" >&6; } + +rm -f conftest.$ac_ext conftest$ac_cv_exeext conftest.out +ac_clean_files=$ac_clean_files_save +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5 +$as_echo_n "checking for suffix of object files... " >&6; } +if ${ac_cv_objext+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +rm -f conftest.o conftest.obj +if { { ac_try="$ac_compile" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_compile") 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then : + for ac_file in conftest.o conftest.obj conftest.*; do + test -f "$ac_file" || continue; + case $ac_file in + *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM ) ;; + *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'` + break;; + esac +done +else + $as_echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 +$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} +as_fn_error $? "cannot compute suffix of object files: cannot compile +See \`config.log' for more details" "$LINENO" 5; } +fi +rm -f conftest.$ac_cv_objext conftest.$ac_ext +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objext" >&5 +$as_echo "$ac_cv_objext" >&6; } +OBJEXT=$ac_cv_objext +ac_objext=$OBJEXT +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C compiler" >&5 +$as_echo_n "checking whether we are using the GNU C compiler... " >&6; } +if ${ac_cv_c_compiler_gnu+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ +#ifndef __GNUC__ + choke me +#endif + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + ac_compiler_gnu=yes +else + ac_compiler_gnu=no +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +ac_cv_c_compiler_gnu=$ac_compiler_gnu + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5 +$as_echo "$ac_cv_c_compiler_gnu" >&6; } +if test $ac_compiler_gnu = yes; then + GCC=yes +else + GCC= +fi +ac_test_CFLAGS=${CFLAGS+set} +ac_save_CFLAGS=$CFLAGS +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5 +$as_echo_n "checking whether $CC accepts -g... " >&6; } +if ${ac_cv_prog_cc_g+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_save_c_werror_flag=$ac_c_werror_flag + ac_c_werror_flag=yes + ac_cv_prog_cc_g=no + CFLAGS="-g" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + ac_cv_prog_cc_g=yes +else + CFLAGS="" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + +else + ac_c_werror_flag=$ac_save_c_werror_flag + CFLAGS="-g" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + ac_cv_prog_cc_g=yes +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext + ac_c_werror_flag=$ac_save_c_werror_flag +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5 +$as_echo "$ac_cv_prog_cc_g" >&6; } +if test "$ac_test_CFLAGS" = set; then + CFLAGS=$ac_save_CFLAGS +elif test $ac_cv_prog_cc_g = yes; then + if test "$GCC" = yes; then + CFLAGS="-g -O2" + else + CFLAGS="-g" + fi +else + if test "$GCC" = yes; then + CFLAGS="-O2" + else + CFLAGS= + fi +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C89" >&5 +$as_echo_n "checking for $CC option to accept ISO C89... " >&6; } +if ${ac_cv_prog_cc_c89+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_cv_prog_cc_c89=no +ac_save_CC=$CC +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +#include +struct stat; +/* Most of the following tests are stolen from RCS 5.7's src/conf.sh. */ +struct buf { int x; }; +FILE * (*rcsopen) (struct buf *, struct stat *, int); +static char *e (p, i) + char **p; + int i; +{ + return p[i]; +} +static char *f (char * (*g) (char **, int), char **p, ...) +{ + char *s; + va_list v; + va_start (v,p); + s = g (p, va_arg (v,int)); + va_end (v); + return s; +} + +/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default. It has + function prototypes and stuff, but not '\xHH' hex character constants. + These don't provoke an error unfortunately, instead are silently treated + as 'x'. The following induces an error, until -std is added to get + proper ANSI mode. Curiously '\x00'!='x' always comes out true, for an + array size at least. It's necessary to write '\x00'==0 to get something + that's true only with -std. */ +int osf4_cc_array ['\x00' == 0 ? 1 : -1]; + +/* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters + inside strings and character constants. */ +#define FOO(x) 'x' +int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1]; + +int test (int i, double x); +struct s1 {int (*f) (int a);}; +struct s2 {int (*f) (double a);}; +int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int); +int argc; +char **argv; +int +main () +{ +return f (e, argv, 0) != argv[0] || f (e, argv, 1) != argv[1]; + ; + return 0; +} +_ACEOF +for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \ + -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__" +do + CC="$ac_save_CC $ac_arg" + if ac_fn_c_try_compile "$LINENO"; then : + ac_cv_prog_cc_c89=$ac_arg +fi +rm -f core conftest.err conftest.$ac_objext + test "x$ac_cv_prog_cc_c89" != "xno" && break +done +rm -f conftest.$ac_ext +CC=$ac_save_CC + +fi +# AC_CACHE_VAL +case "x$ac_cv_prog_cc_c89" in + x) + { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5 +$as_echo "none needed" >&6; } ;; + xno) + { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5 +$as_echo "unsupported" >&6; } ;; + *) + CC="$CC $ac_cv_prog_cc_c89" + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5 +$as_echo "$ac_cv_prog_cc_c89" >&6; } ;; +esac +if test "x$ac_cv_prog_cc_c89" != xno; then : + +fi + +ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu + +depcc="$CC" am_compiler_list= + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking dependency style of $depcc" >&5 +$as_echo_n "checking dependency style of $depcc... " >&6; } +if ${am_cv_CC_dependencies_compiler_type+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then + # We make a subdir and do the tests there. Otherwise we can end up + # making bogus files that we don't know about and never remove. For + # instance it was reported that on HP-UX the gcc test will end up + # making a dummy file named 'D' -- because '-MD' means "put the output + # in D". + rm -rf conftest.dir + mkdir conftest.dir + # Copy depcomp to subdir because otherwise we won't find it if we're + # using a relative directory. + cp "$am_depcomp" conftest.dir + cd conftest.dir + # We will build objects and dependencies in a subdirectory because + # it helps to detect inapplicable dependency modes. For instance + # both Tru64's cc and ICC support -MD to output dependencies as a + # side effect of compilation, but ICC will put the dependencies in + # the current directory while Tru64 will put them in the object + # directory. + mkdir sub + + am_cv_CC_dependencies_compiler_type=none + if test "$am_compiler_list" = ""; then + am_compiler_list=`sed -n 's/^#*\([a-zA-Z0-9]*\))$/\1/p' < ./depcomp` + fi + am__universal=false + case " $depcc " in #( + *\ -arch\ *\ -arch\ *) am__universal=true ;; + esac + + for depmode in $am_compiler_list; do + # Setup a source with many dependencies, because some compilers + # like to wrap large dependency lists on column 80 (with \), and + # we should not choose a depcomp mode which is confused by this. + # + # We need to recreate these files for each test, as the compiler may + # overwrite some of them when testing with obscure command lines. + # This happens at least with the AIX C compiler. + : > sub/conftest.c + for i in 1 2 3 4 5 6; do + echo '#include "conftst'$i'.h"' >> sub/conftest.c + # Using ": > sub/conftst$i.h" creates only sub/conftst1.h with + # Solaris 10 /bin/sh. + echo '/* dummy */' > sub/conftst$i.h + done + echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf + + # We check with '-c' and '-o' for the sake of the "dashmstdout" + # mode. It turns out that the SunPro C++ compiler does not properly + # handle '-M -o', and we need to detect this. Also, some Intel + # versions had trouble with output in subdirs. + am__obj=sub/conftest.${OBJEXT-o} + am__minus_obj="-o $am__obj" + case $depmode in + gcc) + # This depmode causes a compiler race in universal mode. + test "$am__universal" = false || continue + ;; + nosideeffect) + # After this tag, mechanisms are not by side-effect, so they'll + # only be used when explicitly requested. + if test "x$enable_dependency_tracking" = xyes; then + continue + else + break + fi + ;; + msvc7 | msvc7msys | msvisualcpp | msvcmsys) + # This compiler won't grok '-c -o', but also, the minuso test has + # not run yet. These depmodes are late enough in the game, and + # so weak that their functioning should not be impacted. + am__obj=conftest.${OBJEXT-o} + am__minus_obj= + ;; + none) break ;; + esac + if depmode=$depmode \ + source=sub/conftest.c object=$am__obj \ + depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \ + $SHELL ./depcomp $depcc -c $am__minus_obj sub/conftest.c \ + >/dev/null 2>conftest.err && + grep sub/conftst1.h sub/conftest.Po > /dev/null 2>&1 && + grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 && + grep $am__obj sub/conftest.Po > /dev/null 2>&1 && + ${MAKE-make} -s -f confmf > /dev/null 2>&1; then + # icc doesn't choke on unknown options, it will just issue warnings + # or remarks (even with -Werror). So we grep stderr for any message + # that says an option was ignored or not supported. + # When given -MP, icc 7.0 and 7.1 complain thusly: + # icc: Command line warning: ignoring option '-M'; no argument required + # The diagnosis changed in icc 8.0: + # icc: Command line remark: option '-MP' not supported + if (grep 'ignoring option' conftest.err || + grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else + am_cv_CC_dependencies_compiler_type=$depmode + break + fi + fi + done + + cd .. + rm -rf conftest.dir +else + am_cv_CC_dependencies_compiler_type=none +fi + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_CC_dependencies_compiler_type" >&5 +$as_echo "$am_cv_CC_dependencies_compiler_type" >&6; } +CCDEPMODE=depmode=$am_cv_CC_dependencies_compiler_type + + if + test "x$enable_dependency_tracking" != xno \ + && test "$am_cv_CC_dependencies_compiler_type" = gcc3; then + am__fastdepCC_TRUE= + am__fastdepCC_FALSE='#' +else + am__fastdepCC_TRUE='#' + am__fastdepCC_FALSE= +fi + + + +if test -n "$ac_tool_prefix"; then + for ac_prog in ar lib "link -lib" + do + # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args. +set dummy $ac_tool_prefix$ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_AR+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$AR"; then + ac_cv_prog_AR="$AR" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_AR="$ac_tool_prefix$ac_prog" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +AR=$ac_cv_prog_AR +if test -n "$AR"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AR" >&5 +$as_echo "$AR" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$AR" && break + done +fi +if test -z "$AR"; then + ac_ct_AR=$AR + for ac_prog in ar lib "link -lib" +do + # Extract the first word of "$ac_prog", so it can be a program name with args. +set dummy $ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_ac_ct_AR+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_AR"; then + ac_cv_prog_ac_ct_AR="$ac_ct_AR" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_AR="$ac_prog" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_AR=$ac_cv_prog_ac_ct_AR +if test -n "$ac_ct_AR"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_AR" >&5 +$as_echo "$ac_ct_AR" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$ac_ct_AR" && break +done + + if test "x$ac_ct_AR" = x; then + AR="false" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + AR=$ac_ct_AR + fi +fi + +: ${AR=ar} + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking the archiver ($AR) interface" >&5 +$as_echo_n "checking the archiver ($AR) interface... " >&6; } +if ${am_cv_ar_interface+:} false; then : + $as_echo_n "(cached) " >&6 +else + am_cv_ar_interface=ar + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +int some_variable = 0; +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + am_ar_try='$AR cru libconftest.a conftest.$ac_objext >&5' + { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$am_ar_try\""; } >&5 + (eval $am_ar_try) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } + if test "$ac_status" -eq 0; then + am_cv_ar_interface=ar + else + am_ar_try='$AR -NOLOGO -OUT:conftest.lib conftest.$ac_objext >&5' + { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$am_ar_try\""; } >&5 + (eval $am_ar_try) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } + if test "$ac_status" -eq 0; then + am_cv_ar_interface=lib + else + am_cv_ar_interface=unknown + fi + fi + rm -f conftest.lib libconftest.a + +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_ar_interface" >&5 +$as_echo "$am_cv_ar_interface" >&6; } + +case $am_cv_ar_interface in +ar) + ;; +lib) + # Microsoft lib, so override with the ar-lib wrapper script. + # FIXME: It is wrong to rewrite AR. + # But if we don't then we get into trouble of one sort or another. + # A longer-term fix would be to have automake use am__AR in this case, + # and then we could set am__AR="$am_aux_dir/ar-lib \$(AR)" or something + # similar. + AR="$am_aux_dir/ar-lib $AR" + ;; +unknown) + as_fn_error $? "could not determine $AR interface" "$LINENO" 5 + ;; +esac + # Required by automake 1.12. + +case `pwd` in + *\ * | *\ *) + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Libtool does not cope well with whitespace in \`pwd\`" >&5 +$as_echo "$as_me: WARNING: Libtool does not cope well with whitespace in \`pwd\`" >&2;} ;; +esac + + + +macro_version='2.4.2' +macro_revision='1.3337' + + + + + + + + + + + + + +ltmain="$ac_aux_dir/ltmain.sh" + +# Make sure we can run config.sub. +$SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 || + as_fn_error $? "cannot run $SHELL $ac_aux_dir/config.sub" "$LINENO" 5 + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking build system type" >&5 +$as_echo_n "checking build system type... " >&6; } +if ${ac_cv_build+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_build_alias=$build_alias +test "x$ac_build_alias" = x && + ac_build_alias=`$SHELL "$ac_aux_dir/config.guess"` +test "x$ac_build_alias" = x && + as_fn_error $? "cannot guess build type; you must specify one" "$LINENO" 5 +ac_cv_build=`$SHELL "$ac_aux_dir/config.sub" $ac_build_alias` || + as_fn_error $? "$SHELL $ac_aux_dir/config.sub $ac_build_alias failed" "$LINENO" 5 + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5 +$as_echo "$ac_cv_build" >&6; } +case $ac_cv_build in +*-*-*) ;; +*) as_fn_error $? "invalid value of canonical build" "$LINENO" 5;; +esac +build=$ac_cv_build +ac_save_IFS=$IFS; IFS='-' +set x $ac_cv_build +shift +build_cpu=$1 +build_vendor=$2 +shift; shift +# Remember, the first character of IFS is used to create $*, +# except with old shells: +build_os=$* +IFS=$ac_save_IFS +case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking host system type" >&5 +$as_echo_n "checking host system type... " >&6; } +if ${ac_cv_host+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test "x$host_alias" = x; then + ac_cv_host=$ac_cv_build +else + ac_cv_host=`$SHELL "$ac_aux_dir/config.sub" $host_alias` || + as_fn_error $? "$SHELL $ac_aux_dir/config.sub $host_alias failed" "$LINENO" 5 +fi + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5 +$as_echo "$ac_cv_host" >&6; } +case $ac_cv_host in +*-*-*) ;; +*) as_fn_error $? "invalid value of canonical host" "$LINENO" 5;; +esac +host=$ac_cv_host +ac_save_IFS=$IFS; IFS='-' +set x $ac_cv_host +shift +host_cpu=$1 +host_vendor=$2 +shift; shift +# Remember, the first character of IFS is used to create $*, +# except with old shells: +host_os=$* +IFS=$ac_save_IFS +case $host_os in *\ *) host_os=`echo "$host_os" | sed 's/ /-/g'`;; esac + + +# Backslashify metacharacters that are still active within +# double-quoted strings. +sed_quote_subst='s/\(["`$\\]\)/\\\1/g' + +# Same as above, but do not quote variable references. +double_quote_subst='s/\(["`\\]\)/\\\1/g' + +# Sed substitution to delay expansion of an escaped shell variable in a +# double_quote_subst'ed string. +delay_variable_subst='s/\\\\\\\\\\\$/\\\\\\$/g' + +# Sed substitution to delay expansion of an escaped single quote. +delay_single_quote_subst='s/'\''/'\'\\\\\\\'\''/g' + +# Sed substitution to avoid accidental globbing in evaled expressions +no_glob_subst='s/\*/\\\*/g' + +ECHO='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' +ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO +ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO$ECHO + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to print strings" >&5 +$as_echo_n "checking how to print strings... " >&6; } +# Test print first, because it will be a builtin if present. +if test "X`( print -r -- -n ) 2>/dev/null`" = X-n && \ + test "X`print -r -- $ECHO 2>/dev/null`" = "X$ECHO"; then + ECHO='print -r --' +elif test "X`printf %s $ECHO 2>/dev/null`" = "X$ECHO"; then + ECHO='printf %s\n' +else + # Use this function as a fallback that always works. + func_fallback_echo () + { + eval 'cat <<_LTECHO_EOF +$1 +_LTECHO_EOF' + } + ECHO='func_fallback_echo' +fi + +# func_echo_all arg... +# Invoke $ECHO with all args, space-separated. +func_echo_all () +{ + $ECHO "" +} + +case "$ECHO" in + printf*) { $as_echo "$as_me:${as_lineno-$LINENO}: result: printf" >&5 +$as_echo "printf" >&6; } ;; + print*) { $as_echo "$as_me:${as_lineno-$LINENO}: result: print -r" >&5 +$as_echo "print -r" >&6; } ;; + *) { $as_echo "$as_me:${as_lineno-$LINENO}: result: cat" >&5 +$as_echo "cat" >&6; } ;; +esac + + + + + + + + + + + + + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5 +$as_echo_n "checking for a sed that does not truncate output... " >&6; } +if ${ac_cv_path_SED+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/ + for ac_i in 1 2 3 4 5 6 7; do + ac_script="$ac_script$as_nl$ac_script" + done + echo "$ac_script" 2>/dev/null | sed 99q >conftest.sed + { ac_script=; unset ac_script;} + if test -z "$SED"; then + ac_path_SED_found=false + # Loop through the user's path and test for each of PROGNAME-LIST + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_prog in sed gsed; do + for ac_exec_ext in '' $ac_executable_extensions; do + ac_path_SED="$as_dir/$ac_prog$ac_exec_ext" + as_fn_executable_p "$ac_path_SED" || continue +# Check for GNU ac_path_SED and select it if it is found. + # Check for GNU $ac_path_SED +case `"$ac_path_SED" --version 2>&1` in +*GNU*) + ac_cv_path_SED="$ac_path_SED" ac_path_SED_found=:;; +*) + ac_count=0 + $as_echo_n 0123456789 >"conftest.in" + while : + do + cat "conftest.in" "conftest.in" >"conftest.tmp" + mv "conftest.tmp" "conftest.in" + cp "conftest.in" "conftest.nl" + $as_echo '' >> "conftest.nl" + "$ac_path_SED" -f conftest.sed < "conftest.nl" >"conftest.out" 2>/dev/null || break + diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break + as_fn_arith $ac_count + 1 && ac_count=$as_val + if test $ac_count -gt ${ac_path_SED_max-0}; then + # Best one so far, save it but keep looking for a better one + ac_cv_path_SED="$ac_path_SED" + ac_path_SED_max=$ac_count + fi + # 10*(2^10) chars as input seems more than enough + test $ac_count -gt 10 && break + done + rm -f conftest.in conftest.tmp conftest.nl conftest.out;; +esac + + $ac_path_SED_found && break 3 + done + done + done +IFS=$as_save_IFS + if test -z "$ac_cv_path_SED"; then + as_fn_error $? "no acceptable sed could be found in \$PATH" "$LINENO" 5 + fi +else + ac_cv_path_SED=$SED +fi + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5 +$as_echo "$ac_cv_path_SED" >&6; } + SED="$ac_cv_path_SED" + rm -f conftest.sed + +test -z "$SED" && SED=sed +Xsed="$SED -e 1s/^X//" + + + + + + + + + + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5 +$as_echo_n "checking for grep that handles long lines and -e... " >&6; } +if ${ac_cv_path_GREP+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -z "$GREP"; then + ac_path_GREP_found=false + # Loop through the user's path and test for each of PROGNAME-LIST + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_prog in grep ggrep; do + for ac_exec_ext in '' $ac_executable_extensions; do + ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext" + as_fn_executable_p "$ac_path_GREP" || continue +# Check for GNU ac_path_GREP and select it if it is found. + # Check for GNU $ac_path_GREP +case `"$ac_path_GREP" --version 2>&1` in +*GNU*) + ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;; +*) + ac_count=0 + $as_echo_n 0123456789 >"conftest.in" + while : + do + cat "conftest.in" "conftest.in" >"conftest.tmp" + mv "conftest.tmp" "conftest.in" + cp "conftest.in" "conftest.nl" + $as_echo 'GREP' >> "conftest.nl" + "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break + diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break + as_fn_arith $ac_count + 1 && ac_count=$as_val + if test $ac_count -gt ${ac_path_GREP_max-0}; then + # Best one so far, save it but keep looking for a better one + ac_cv_path_GREP="$ac_path_GREP" + ac_path_GREP_max=$ac_count + fi + # 10*(2^10) chars as input seems more than enough + test $ac_count -gt 10 && break + done + rm -f conftest.in conftest.tmp conftest.nl conftest.out;; +esac + + $ac_path_GREP_found && break 3 + done + done + done +IFS=$as_save_IFS + if test -z "$ac_cv_path_GREP"; then + as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5 + fi +else + ac_cv_path_GREP=$GREP +fi + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5 +$as_echo "$ac_cv_path_GREP" >&6; } + GREP="$ac_cv_path_GREP" + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5 +$as_echo_n "checking for egrep... " >&6; } +if ${ac_cv_path_EGREP+:} false; then : + $as_echo_n "(cached) " >&6 +else + if echo a | $GREP -E '(a|b)' >/dev/null 2>&1 + then ac_cv_path_EGREP="$GREP -E" + else + if test -z "$EGREP"; then + ac_path_EGREP_found=false + # Loop through the user's path and test for each of PROGNAME-LIST + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_prog in egrep; do + for ac_exec_ext in '' $ac_executable_extensions; do + ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext" + as_fn_executable_p "$ac_path_EGREP" || continue +# Check for GNU ac_path_EGREP and select it if it is found. + # Check for GNU $ac_path_EGREP +case `"$ac_path_EGREP" --version 2>&1` in +*GNU*) + ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;; +*) + ac_count=0 + $as_echo_n 0123456789 >"conftest.in" + while : + do + cat "conftest.in" "conftest.in" >"conftest.tmp" + mv "conftest.tmp" "conftest.in" + cp "conftest.in" "conftest.nl" + $as_echo 'EGREP' >> "conftest.nl" + "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break + diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break + as_fn_arith $ac_count + 1 && ac_count=$as_val + if test $ac_count -gt ${ac_path_EGREP_max-0}; then + # Best one so far, save it but keep looking for a better one + ac_cv_path_EGREP="$ac_path_EGREP" + ac_path_EGREP_max=$ac_count + fi + # 10*(2^10) chars as input seems more than enough + test $ac_count -gt 10 && break + done + rm -f conftest.in conftest.tmp conftest.nl conftest.out;; +esac + + $ac_path_EGREP_found && break 3 + done + done + done +IFS=$as_save_IFS + if test -z "$ac_cv_path_EGREP"; then + as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5 + fi +else + ac_cv_path_EGREP=$EGREP +fi + + fi +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5 +$as_echo "$ac_cv_path_EGREP" >&6; } + EGREP="$ac_cv_path_EGREP" + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for fgrep" >&5 +$as_echo_n "checking for fgrep... " >&6; } +if ${ac_cv_path_FGREP+:} false; then : + $as_echo_n "(cached) " >&6 +else + if echo 'ab*c' | $GREP -F 'ab*c' >/dev/null 2>&1 + then ac_cv_path_FGREP="$GREP -F" + else + if test -z "$FGREP"; then + ac_path_FGREP_found=false + # Loop through the user's path and test for each of PROGNAME-LIST + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_prog in fgrep; do + for ac_exec_ext in '' $ac_executable_extensions; do + ac_path_FGREP="$as_dir/$ac_prog$ac_exec_ext" + as_fn_executable_p "$ac_path_FGREP" || continue +# Check for GNU ac_path_FGREP and select it if it is found. + # Check for GNU $ac_path_FGREP +case `"$ac_path_FGREP" --version 2>&1` in +*GNU*) + ac_cv_path_FGREP="$ac_path_FGREP" ac_path_FGREP_found=:;; +*) + ac_count=0 + $as_echo_n 0123456789 >"conftest.in" + while : + do + cat "conftest.in" "conftest.in" >"conftest.tmp" + mv "conftest.tmp" "conftest.in" + cp "conftest.in" "conftest.nl" + $as_echo 'FGREP' >> "conftest.nl" + "$ac_path_FGREP" FGREP < "conftest.nl" >"conftest.out" 2>/dev/null || break + diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break + as_fn_arith $ac_count + 1 && ac_count=$as_val + if test $ac_count -gt ${ac_path_FGREP_max-0}; then + # Best one so far, save it but keep looking for a better one + ac_cv_path_FGREP="$ac_path_FGREP" + ac_path_FGREP_max=$ac_count + fi + # 10*(2^10) chars as input seems more than enough + test $ac_count -gt 10 && break + done + rm -f conftest.in conftest.tmp conftest.nl conftest.out;; +esac + + $ac_path_FGREP_found && break 3 + done + done + done +IFS=$as_save_IFS + if test -z "$ac_cv_path_FGREP"; then + as_fn_error $? "no acceptable fgrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5 + fi +else + ac_cv_path_FGREP=$FGREP +fi + + fi +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_FGREP" >&5 +$as_echo "$ac_cv_path_FGREP" >&6; } + FGREP="$ac_cv_path_FGREP" + + +test -z "$GREP" && GREP=grep + + + + + + + + + + + + + + + + + + + +# Check whether --with-gnu-ld was given. +if test "${with_gnu_ld+set}" = set; then : + withval=$with_gnu_ld; test "$withval" = no || with_gnu_ld=yes +else + with_gnu_ld=no +fi + +ac_prog=ld +if test "$GCC" = yes; then + # Check if gcc -print-prog-name=ld gives a path. + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ld used by $CC" >&5 +$as_echo_n "checking for ld used by $CC... " >&6; } + case $host in + *-*-mingw*) + # gcc leaves a trailing carriage return which upsets mingw + ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;; + *) + ac_prog=`($CC -print-prog-name=ld) 2>&5` ;; + esac + case $ac_prog in + # Accept absolute paths. + [\\/]* | ?:[\\/]*) + re_direlt='/[^/][^/]*/\.\./' + # Canonicalize the pathname of ld + ac_prog=`$ECHO "$ac_prog"| $SED 's%\\\\%/%g'` + while $ECHO "$ac_prog" | $GREP "$re_direlt" > /dev/null 2>&1; do + ac_prog=`$ECHO $ac_prog| $SED "s%$re_direlt%/%"` + done + test -z "$LD" && LD="$ac_prog" + ;; + "") + # If it fails, then pretend we aren't using GCC. + ac_prog=ld + ;; + *) + # If it is relative, then search for the first ld in PATH. + with_gnu_ld=unknown + ;; + esac +elif test "$with_gnu_ld" = yes; then + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GNU ld" >&5 +$as_echo_n "checking for GNU ld... " >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for non-GNU ld" >&5 +$as_echo_n "checking for non-GNU ld... " >&6; } +fi +if ${lt_cv_path_LD+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -z "$LD"; then + lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR + for ac_dir in $PATH; do + IFS="$lt_save_ifs" + test -z "$ac_dir" && ac_dir=. + if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then + lt_cv_path_LD="$ac_dir/$ac_prog" + # Check to see if the program is GNU ld. I'd rather use --version, + # but apparently some variants of GNU ld only accept -v. + # Break only if it was the GNU/non-GNU ld that we prefer. + case `"$lt_cv_path_LD" -v 2>&1 &5 +$as_echo "$LD" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi +test -z "$LD" && as_fn_error $? "no acceptable ld found in \$PATH" "$LINENO" 5 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if the linker ($LD) is GNU ld" >&5 +$as_echo_n "checking if the linker ($LD) is GNU ld... " >&6; } +if ${lt_cv_prog_gnu_ld+:} false; then : + $as_echo_n "(cached) " >&6 +else + # I'd rather use --version here, but apparently some GNU lds only accept -v. +case `$LD -v 2>&1 &5 +$as_echo "$lt_cv_prog_gnu_ld" >&6; } +with_gnu_ld=$lt_cv_prog_gnu_ld + + + + + + + + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for BSD- or MS-compatible name lister (nm)" >&5 +$as_echo_n "checking for BSD- or MS-compatible name lister (nm)... " >&6; } +if ${lt_cv_path_NM+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$NM"; then + # Let the user override the test. + lt_cv_path_NM="$NM" +else + lt_nm_to_check="${ac_tool_prefix}nm" + if test -n "$ac_tool_prefix" && test "$build" = "$host"; then + lt_nm_to_check="$lt_nm_to_check nm" + fi + for lt_tmp_nm in $lt_nm_to_check; do + lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR + for ac_dir in $PATH /usr/ccs/bin/elf /usr/ccs/bin /usr/ucb /bin; do + IFS="$lt_save_ifs" + test -z "$ac_dir" && ac_dir=. + tmp_nm="$ac_dir/$lt_tmp_nm" + if test -f "$tmp_nm" || test -f "$tmp_nm$ac_exeext" ; then + # Check to see if the nm accepts a BSD-compat flag. + # Adding the `sed 1q' prevents false positives on HP-UX, which says: + # nm: unknown option "B" ignored + # Tru64's nm complains that /dev/null is an invalid object file + case `"$tmp_nm" -B /dev/null 2>&1 | sed '1q'` in + */dev/null* | *'Invalid file or object type'*) + lt_cv_path_NM="$tmp_nm -B" + break + ;; + *) + case `"$tmp_nm" -p /dev/null 2>&1 | sed '1q'` in + */dev/null*) + lt_cv_path_NM="$tmp_nm -p" + break + ;; + *) + lt_cv_path_NM=${lt_cv_path_NM="$tmp_nm"} # keep the first match, but + continue # so that we can try to find one that supports BSD flags + ;; + esac + ;; + esac + fi + done + IFS="$lt_save_ifs" + done + : ${lt_cv_path_NM=no} +fi +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_path_NM" >&5 +$as_echo "$lt_cv_path_NM" >&6; } +if test "$lt_cv_path_NM" != "no"; then + NM="$lt_cv_path_NM" +else + # Didn't find any BSD compatible name lister, look for dumpbin. + if test -n "$DUMPBIN"; then : + # Let the user override the test. + else + if test -n "$ac_tool_prefix"; then + for ac_prog in dumpbin "link -dump" + do + # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args. +set dummy $ac_tool_prefix$ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_DUMPBIN+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$DUMPBIN"; then + ac_cv_prog_DUMPBIN="$DUMPBIN" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_DUMPBIN="$ac_tool_prefix$ac_prog" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +DUMPBIN=$ac_cv_prog_DUMPBIN +if test -n "$DUMPBIN"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DUMPBIN" >&5 +$as_echo "$DUMPBIN" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$DUMPBIN" && break + done +fi +if test -z "$DUMPBIN"; then + ac_ct_DUMPBIN=$DUMPBIN + for ac_prog in dumpbin "link -dump" +do + # Extract the first word of "$ac_prog", so it can be a program name with args. +set dummy $ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_ac_ct_DUMPBIN+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_DUMPBIN"; then + ac_cv_prog_ac_ct_DUMPBIN="$ac_ct_DUMPBIN" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_DUMPBIN="$ac_prog" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_DUMPBIN=$ac_cv_prog_ac_ct_DUMPBIN +if test -n "$ac_ct_DUMPBIN"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DUMPBIN" >&5 +$as_echo "$ac_ct_DUMPBIN" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$ac_ct_DUMPBIN" && break +done + + if test "x$ac_ct_DUMPBIN" = x; then + DUMPBIN=":" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + DUMPBIN=$ac_ct_DUMPBIN + fi +fi + + case `$DUMPBIN -symbols /dev/null 2>&1 | sed '1q'` in + *COFF*) + DUMPBIN="$DUMPBIN -symbols" + ;; + *) + DUMPBIN=: + ;; + esac + fi + + if test "$DUMPBIN" != ":"; then + NM="$DUMPBIN" + fi +fi +test -z "$NM" && NM=nm + + + + + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking the name lister ($NM) interface" >&5 +$as_echo_n "checking the name lister ($NM) interface... " >&6; } +if ${lt_cv_nm_interface+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_nm_interface="BSD nm" + echo "int some_variable = 0;" > conftest.$ac_ext + (eval echo "\"\$as_me:$LINENO: $ac_compile\"" >&5) + (eval "$ac_compile" 2>conftest.err) + cat conftest.err >&5 + (eval echo "\"\$as_me:$LINENO: $NM \\\"conftest.$ac_objext\\\"\"" >&5) + (eval "$NM \"conftest.$ac_objext\"" 2>conftest.err > conftest.out) + cat conftest.err >&5 + (eval echo "\"\$as_me:$LINENO: output\"" >&5) + cat conftest.out >&5 + if $GREP 'External.*some_variable' conftest.out > /dev/null; then + lt_cv_nm_interface="MS dumpbin" + fi + rm -f conftest* +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_nm_interface" >&5 +$as_echo "$lt_cv_nm_interface" >&6; } + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ln -s works" >&5 +$as_echo_n "checking whether ln -s works... " >&6; } +LN_S=$as_ln_s +if test "$LN_S" = "ln -s"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +$as_echo "yes" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no, using $LN_S" >&5 +$as_echo "no, using $LN_S" >&6; } +fi + +# find the maximum length of command line arguments +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking the maximum length of command line arguments" >&5 +$as_echo_n "checking the maximum length of command line arguments... " >&6; } +if ${lt_cv_sys_max_cmd_len+:} false; then : + $as_echo_n "(cached) " >&6 +else + i=0 + teststring="ABCD" + + case $build_os in + msdosdjgpp*) + # On DJGPP, this test can blow up pretty badly due to problems in libc + # (any single argument exceeding 2000 bytes causes a buffer overrun + # during glob expansion). Even if it were fixed, the result of this + # check would be larger than it should be. + lt_cv_sys_max_cmd_len=12288; # 12K is about right + ;; + + gnu*) + # Under GNU Hurd, this test is not required because there is + # no limit to the length of command line arguments. + # Libtool will interpret -1 as no limit whatsoever + lt_cv_sys_max_cmd_len=-1; + ;; + + cygwin* | mingw* | cegcc*) + # On Win9x/ME, this test blows up -- it succeeds, but takes + # about 5 minutes as the teststring grows exponentially. + # Worse, since 9x/ME are not pre-emptively multitasking, + # you end up with a "frozen" computer, even though with patience + # the test eventually succeeds (with a max line length of 256k). + # Instead, let's just punt: use the minimum linelength reported by + # all of the supported platforms: 8192 (on NT/2K/XP). + lt_cv_sys_max_cmd_len=8192; + ;; + + mint*) + # On MiNT this can take a long time and run out of memory. + lt_cv_sys_max_cmd_len=8192; + ;; + + amigaos*) + # On AmigaOS with pdksh, this test takes hours, literally. + # So we just punt and use a minimum line length of 8192. + lt_cv_sys_max_cmd_len=8192; + ;; + + netbsd* | freebsd* | openbsd* | darwin* | dragonfly*) + # This has been around since 386BSD, at least. Likely further. + if test -x /sbin/sysctl; then + lt_cv_sys_max_cmd_len=`/sbin/sysctl -n kern.argmax` + elif test -x /usr/sbin/sysctl; then + lt_cv_sys_max_cmd_len=`/usr/sbin/sysctl -n kern.argmax` + else + lt_cv_sys_max_cmd_len=65536 # usable default for all BSDs + fi + # And add a safety zone + lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4` + lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3` + ;; + + interix*) + # We know the value 262144 and hardcode it with a safety zone (like BSD) + lt_cv_sys_max_cmd_len=196608 + ;; + + os2*) + # The test takes a long time on OS/2. + lt_cv_sys_max_cmd_len=8192 + ;; + + osf*) + # Dr. Hans Ekkehard Plesser reports seeing a kernel panic running configure + # due to this test when exec_disable_arg_limit is 1 on Tru64. It is not + # nice to cause kernel panics so lets avoid the loop below. + # First set a reasonable default. + lt_cv_sys_max_cmd_len=16384 + # + if test -x /sbin/sysconfig; then + case `/sbin/sysconfig -q proc exec_disable_arg_limit` in + *1*) lt_cv_sys_max_cmd_len=-1 ;; + esac + fi + ;; + sco3.2v5*) + lt_cv_sys_max_cmd_len=102400 + ;; + sysv5* | sco5v6* | sysv4.2uw2*) + kargmax=`grep ARG_MAX /etc/conf/cf.d/stune 2>/dev/null` + if test -n "$kargmax"; then + lt_cv_sys_max_cmd_len=`echo $kargmax | sed 's/.*[ ]//'` + else + lt_cv_sys_max_cmd_len=32768 + fi + ;; + *) + lt_cv_sys_max_cmd_len=`(getconf ARG_MAX) 2> /dev/null` + if test -n "$lt_cv_sys_max_cmd_len" && \ + test undefined != "$lt_cv_sys_max_cmd_len"; then + lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4` + lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3` + else + # Make teststring a little bigger before we do anything with it. + # a 1K string should be a reasonable start. + for i in 1 2 3 4 5 6 7 8 ; do + teststring=$teststring$teststring + done + SHELL=${SHELL-${CONFIG_SHELL-/bin/sh}} + # If test is not a shell built-in, we'll probably end up computing a + # maximum length that is only half of the actual maximum length, but + # we can't tell. + while { test "X"`env echo "$teststring$teststring" 2>/dev/null` \ + = "X$teststring$teststring"; } >/dev/null 2>&1 && + test $i != 17 # 1/2 MB should be enough + do + i=`expr $i + 1` + teststring=$teststring$teststring + done + # Only check the string length outside the loop. + lt_cv_sys_max_cmd_len=`expr "X$teststring" : ".*" 2>&1` + teststring= + # Add a significant safety factor because C++ compilers can tack on + # massive amounts of additional arguments before passing them to the + # linker. It appears as though 1/2 is a usable value. + lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 2` + fi + ;; + esac + +fi + +if test -n $lt_cv_sys_max_cmd_len ; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_sys_max_cmd_len" >&5 +$as_echo "$lt_cv_sys_max_cmd_len" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: none" >&5 +$as_echo "none" >&6; } +fi +max_cmd_len=$lt_cv_sys_max_cmd_len + + + + + + +: ${CP="cp -f"} +: ${MV="mv -f"} +: ${RM="rm -f"} + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the shell understands some XSI constructs" >&5 +$as_echo_n "checking whether the shell understands some XSI constructs... " >&6; } +# Try some XSI features +xsi_shell=no +( _lt_dummy="a/b/c" + test "${_lt_dummy##*/},${_lt_dummy%/*},${_lt_dummy#??}"${_lt_dummy%"$_lt_dummy"}, \ + = c,a/b,b/c, \ + && eval 'test $(( 1 + 1 )) -eq 2 \ + && test "${#_lt_dummy}" -eq 5' ) >/dev/null 2>&1 \ + && xsi_shell=yes +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $xsi_shell" >&5 +$as_echo "$xsi_shell" >&6; } + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the shell understands \"+=\"" >&5 +$as_echo_n "checking whether the shell understands \"+=\"... " >&6; } +lt_shell_append=no +( foo=bar; set foo baz; eval "$1+=\$2" && test "$foo" = barbaz ) \ + >/dev/null 2>&1 \ + && lt_shell_append=yes +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_shell_append" >&5 +$as_echo "$lt_shell_append" >&6; } + + +if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then + lt_unset=unset +else + lt_unset=false +fi + + + + + +# test EBCDIC or ASCII +case `echo X|tr X '\101'` in + A) # ASCII based system + # \n is not interpreted correctly by Solaris 8 /usr/ucb/tr + lt_SP2NL='tr \040 \012' + lt_NL2SP='tr \015\012 \040\040' + ;; + *) # EBCDIC based system + lt_SP2NL='tr \100 \n' + lt_NL2SP='tr \r\n \100\100' + ;; +esac + + + + + + + + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to convert $build file names to $host format" >&5 +$as_echo_n "checking how to convert $build file names to $host format... " >&6; } +if ${lt_cv_to_host_file_cmd+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $host in + *-*-mingw* ) + case $build in + *-*-mingw* ) # actually msys + lt_cv_to_host_file_cmd=func_convert_file_msys_to_w32 + ;; + *-*-cygwin* ) + lt_cv_to_host_file_cmd=func_convert_file_cygwin_to_w32 + ;; + * ) # otherwise, assume *nix + lt_cv_to_host_file_cmd=func_convert_file_nix_to_w32 + ;; + esac + ;; + *-*-cygwin* ) + case $build in + *-*-mingw* ) # actually msys + lt_cv_to_host_file_cmd=func_convert_file_msys_to_cygwin + ;; + *-*-cygwin* ) + lt_cv_to_host_file_cmd=func_convert_file_noop + ;; + * ) # otherwise, assume *nix + lt_cv_to_host_file_cmd=func_convert_file_nix_to_cygwin + ;; + esac + ;; + * ) # unhandled hosts (and "normal" native builds) + lt_cv_to_host_file_cmd=func_convert_file_noop + ;; +esac + +fi + +to_host_file_cmd=$lt_cv_to_host_file_cmd +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_to_host_file_cmd" >&5 +$as_echo "$lt_cv_to_host_file_cmd" >&6; } + + + + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to convert $build file names to toolchain format" >&5 +$as_echo_n "checking how to convert $build file names to toolchain format... " >&6; } +if ${lt_cv_to_tool_file_cmd+:} false; then : + $as_echo_n "(cached) " >&6 +else + #assume ordinary cross tools, or native build. +lt_cv_to_tool_file_cmd=func_convert_file_noop +case $host in + *-*-mingw* ) + case $build in + *-*-mingw* ) # actually msys + lt_cv_to_tool_file_cmd=func_convert_file_msys_to_w32 + ;; + esac + ;; +esac + +fi + +to_tool_file_cmd=$lt_cv_to_tool_file_cmd +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_to_tool_file_cmd" >&5 +$as_echo "$lt_cv_to_tool_file_cmd" >&6; } + + + + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $LD option to reload object files" >&5 +$as_echo_n "checking for $LD option to reload object files... " >&6; } +if ${lt_cv_ld_reload_flag+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_ld_reload_flag='-r' +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ld_reload_flag" >&5 +$as_echo "$lt_cv_ld_reload_flag" >&6; } +reload_flag=$lt_cv_ld_reload_flag +case $reload_flag in +"" | " "*) ;; +*) reload_flag=" $reload_flag" ;; +esac +reload_cmds='$LD$reload_flag -o $output$reload_objs' +case $host_os in + cygwin* | mingw* | pw32* | cegcc*) + if test "$GCC" != yes; then + reload_cmds=false + fi + ;; + darwin*) + if test "$GCC" = yes; then + reload_cmds='$LTCC $LTCFLAGS -nostdlib ${wl}-r -o $output$reload_objs' + else + reload_cmds='$LD$reload_flag -o $output$reload_objs' + fi + ;; +esac + + + + + + + + + +if test -n "$ac_tool_prefix"; then + # Extract the first word of "${ac_tool_prefix}objdump", so it can be a program name with args. +set dummy ${ac_tool_prefix}objdump; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_OBJDUMP+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$OBJDUMP"; then + ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_OBJDUMP="${ac_tool_prefix}objdump" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +OBJDUMP=$ac_cv_prog_OBJDUMP +if test -n "$OBJDUMP"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OBJDUMP" >&5 +$as_echo "$OBJDUMP" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test -z "$ac_cv_prog_OBJDUMP"; then + ac_ct_OBJDUMP=$OBJDUMP + # Extract the first word of "objdump", so it can be a program name with args. +set dummy objdump; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_ac_ct_OBJDUMP+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_OBJDUMP"; then + ac_cv_prog_ac_ct_OBJDUMP="$ac_ct_OBJDUMP" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_OBJDUMP="objdump" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_OBJDUMP=$ac_cv_prog_ac_ct_OBJDUMP +if test -n "$ac_ct_OBJDUMP"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OBJDUMP" >&5 +$as_echo "$ac_ct_OBJDUMP" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + if test "x$ac_ct_OBJDUMP" = x; then + OBJDUMP="false" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + OBJDUMP=$ac_ct_OBJDUMP + fi +else + OBJDUMP="$ac_cv_prog_OBJDUMP" +fi + +test -z "$OBJDUMP" && OBJDUMP=objdump + + + + + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to recognize dependent libraries" >&5 +$as_echo_n "checking how to recognize dependent libraries... " >&6; } +if ${lt_cv_deplibs_check_method+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_file_magic_cmd='$MAGIC_CMD' +lt_cv_file_magic_test_file= +lt_cv_deplibs_check_method='unknown' +# Need to set the preceding variable on all platforms that support +# interlibrary dependencies. +# 'none' -- dependencies not supported. +# `unknown' -- same as none, but documents that we really don't know. +# 'pass_all' -- all dependencies passed with no checks. +# 'test_compile' -- check by making test program. +# 'file_magic [[regex]]' -- check by looking for files in library path +# which responds to the $file_magic_cmd with a given extended regex. +# If you have `file' or equivalent on your system and you're not sure +# whether `pass_all' will *always* work, you probably want this one. + +case $host_os in +aix[4-9]*) + lt_cv_deplibs_check_method=pass_all + ;; + +beos*) + lt_cv_deplibs_check_method=pass_all + ;; + +bsdi[45]*) + lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (shared object|dynamic lib)' + lt_cv_file_magic_cmd='/usr/bin/file -L' + lt_cv_file_magic_test_file=/shlib/libc.so + ;; + +cygwin*) + # func_win32_libid is a shell function defined in ltmain.sh + lt_cv_deplibs_check_method='file_magic ^x86 archive import|^x86 DLL' + lt_cv_file_magic_cmd='func_win32_libid' + ;; + +mingw* | pw32*) + # Base MSYS/MinGW do not provide the 'file' command needed by + # func_win32_libid shell function, so use a weaker test based on 'objdump', + # unless we find 'file', for example because we are cross-compiling. + # func_win32_libid assumes BSD nm, so disallow it if using MS dumpbin. + if ( test "$lt_cv_nm_interface" = "BSD nm" && file / ) >/dev/null 2>&1; then + lt_cv_deplibs_check_method='file_magic ^x86 archive import|^x86 DLL' + lt_cv_file_magic_cmd='func_win32_libid' + else + # Keep this pattern in sync with the one in func_win32_libid. + lt_cv_deplibs_check_method='file_magic file format (pei*-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)' + lt_cv_file_magic_cmd='$OBJDUMP -f' + fi + ;; + +cegcc*) + # use the weaker test based on 'objdump'. See mingw*. + lt_cv_deplibs_check_method='file_magic file format pe-arm-.*little(.*architecture: arm)?' + lt_cv_file_magic_cmd='$OBJDUMP -f' + ;; + +darwin* | rhapsody*) + lt_cv_deplibs_check_method=pass_all + ;; + +freebsd* | dragonfly*) + if echo __ELF__ | $CC -E - | $GREP __ELF__ > /dev/null; then + case $host_cpu in + i*86 ) + # Not sure whether the presence of OpenBSD here was a mistake. + # Let's accept both of them until this is cleared up. + lt_cv_deplibs_check_method='file_magic (FreeBSD|OpenBSD|DragonFly)/i[3-9]86 (compact )?demand paged shared library' + lt_cv_file_magic_cmd=/usr/bin/file + lt_cv_file_magic_test_file=`echo /usr/lib/libc.so.*` + ;; + esac + else + lt_cv_deplibs_check_method=pass_all + fi + ;; + +haiku*) + lt_cv_deplibs_check_method=pass_all + ;; + +hpux10.20* | hpux11*) + lt_cv_file_magic_cmd=/usr/bin/file + case $host_cpu in + ia64*) + lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|ELF-[0-9][0-9]) shared object file - IA64' + lt_cv_file_magic_test_file=/usr/lib/hpux32/libc.so + ;; + hppa*64*) + lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|ELF[ -][0-9][0-9])(-bit)?( [LM]SB)? shared object( file)?[, -]* PA-RISC [0-9]\.[0-9]' + lt_cv_file_magic_test_file=/usr/lib/pa20_64/libc.sl + ;; + *) + lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|PA-RISC[0-9]\.[0-9]) shared library' + lt_cv_file_magic_test_file=/usr/lib/libc.sl + ;; + esac + ;; + +interix[3-9]*) + # PIC code is broken on Interix 3.x, that's why |\.a not |_pic\.a here + lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so|\.a)$' + ;; + +irix5* | irix6* | nonstopux*) + case $LD in + *-32|*"-32 ") libmagic=32-bit;; + *-n32|*"-n32 ") libmagic=N32;; + *-64|*"-64 ") libmagic=64-bit;; + *) libmagic=never-match;; + esac + lt_cv_deplibs_check_method=pass_all + ;; + +# This must be glibc/ELF. +linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*) + lt_cv_deplibs_check_method=pass_all + ;; + +netbsd* | netbsdelf*-gnu) + if echo __ELF__ | $CC -E - | $GREP __ELF__ > /dev/null; then + lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so\.[0-9]+\.[0-9]+|_pic\.a)$' + else + lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so|_pic\.a)$' + fi + ;; + +newos6*) + lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (executable|dynamic lib)' + lt_cv_file_magic_cmd=/usr/bin/file + lt_cv_file_magic_test_file=/usr/lib/libnls.so + ;; + +*nto* | *qnx*) + lt_cv_deplibs_check_method=pass_all + ;; + +openbsd*) + if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then + lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so\.[0-9]+\.[0-9]+|\.so|_pic\.a)$' + else + lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so\.[0-9]+\.[0-9]+|_pic\.a)$' + fi + ;; + +osf3* | osf4* | osf5*) + lt_cv_deplibs_check_method=pass_all + ;; + +rdos*) + lt_cv_deplibs_check_method=pass_all + ;; + +solaris*) + lt_cv_deplibs_check_method=pass_all + ;; + +sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*) + lt_cv_deplibs_check_method=pass_all + ;; + +sysv4 | sysv4.3*) + case $host_vendor in + motorola) + lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (shared object|dynamic lib) M[0-9][0-9]* Version [0-9]' + lt_cv_file_magic_test_file=`echo /usr/lib/libc.so*` + ;; + ncr) + lt_cv_deplibs_check_method=pass_all + ;; + sequent) + lt_cv_file_magic_cmd='/bin/file' + lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [LM]SB (shared object|dynamic lib )' + ;; + sni) + lt_cv_file_magic_cmd='/bin/file' + lt_cv_deplibs_check_method="file_magic ELF [0-9][0-9]*-bit [LM]SB dynamic lib" + lt_cv_file_magic_test_file=/lib/libc.so + ;; + siemens) + lt_cv_deplibs_check_method=pass_all + ;; + pc) + lt_cv_deplibs_check_method=pass_all + ;; + esac + ;; + +tpf*) + lt_cv_deplibs_check_method=pass_all + ;; +esac + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_deplibs_check_method" >&5 +$as_echo "$lt_cv_deplibs_check_method" >&6; } + +file_magic_glob= +want_nocaseglob=no +if test "$build" = "$host"; then + case $host_os in + mingw* | pw32*) + if ( shopt | grep nocaseglob ) >/dev/null 2>&1; then + want_nocaseglob=yes + else + file_magic_glob=`echo aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ | $SED -e "s/\(..\)/s\/[\1]\/[\1]\/g;/g"` + fi + ;; + esac +fi + +file_magic_cmd=$lt_cv_file_magic_cmd +deplibs_check_method=$lt_cv_deplibs_check_method +test -z "$deplibs_check_method" && deplibs_check_method=unknown + + + + + + + + + + + + + + + + + + + + + + +if test -n "$ac_tool_prefix"; then + # Extract the first word of "${ac_tool_prefix}dlltool", so it can be a program name with args. +set dummy ${ac_tool_prefix}dlltool; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_DLLTOOL+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$DLLTOOL"; then + ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_DLLTOOL="${ac_tool_prefix}dlltool" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +DLLTOOL=$ac_cv_prog_DLLTOOL +if test -n "$DLLTOOL"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DLLTOOL" >&5 +$as_echo "$DLLTOOL" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test -z "$ac_cv_prog_DLLTOOL"; then + ac_ct_DLLTOOL=$DLLTOOL + # Extract the first word of "dlltool", so it can be a program name with args. +set dummy dlltool; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_ac_ct_DLLTOOL+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_DLLTOOL"; then + ac_cv_prog_ac_ct_DLLTOOL="$ac_ct_DLLTOOL" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_DLLTOOL="dlltool" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_DLLTOOL=$ac_cv_prog_ac_ct_DLLTOOL +if test -n "$ac_ct_DLLTOOL"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DLLTOOL" >&5 +$as_echo "$ac_ct_DLLTOOL" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + if test "x$ac_ct_DLLTOOL" = x; then + DLLTOOL="false" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + DLLTOOL=$ac_ct_DLLTOOL + fi +else + DLLTOOL="$ac_cv_prog_DLLTOOL" +fi + +test -z "$DLLTOOL" && DLLTOOL=dlltool + + + + + + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to associate runtime and link libraries" >&5 +$as_echo_n "checking how to associate runtime and link libraries... " >&6; } +if ${lt_cv_sharedlib_from_linklib_cmd+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_sharedlib_from_linklib_cmd='unknown' + +case $host_os in +cygwin* | mingw* | pw32* | cegcc*) + # two different shell functions defined in ltmain.sh + # decide which to use based on capabilities of $DLLTOOL + case `$DLLTOOL --help 2>&1` in + *--identify-strict*) + lt_cv_sharedlib_from_linklib_cmd=func_cygming_dll_for_implib + ;; + *) + lt_cv_sharedlib_from_linklib_cmd=func_cygming_dll_for_implib_fallback + ;; + esac + ;; +*) + # fallback: assume linklib IS sharedlib + lt_cv_sharedlib_from_linklib_cmd="$ECHO" + ;; +esac + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_sharedlib_from_linklib_cmd" >&5 +$as_echo "$lt_cv_sharedlib_from_linklib_cmd" >&6; } +sharedlib_from_linklib_cmd=$lt_cv_sharedlib_from_linklib_cmd +test -z "$sharedlib_from_linklib_cmd" && sharedlib_from_linklib_cmd=$ECHO + + + + + + + +if test -n "$ac_tool_prefix"; then + for ac_prog in ar + do + # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args. +set dummy $ac_tool_prefix$ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_AR+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$AR"; then + ac_cv_prog_AR="$AR" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_AR="$ac_tool_prefix$ac_prog" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +AR=$ac_cv_prog_AR +if test -n "$AR"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AR" >&5 +$as_echo "$AR" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$AR" && break + done +fi +if test -z "$AR"; then + ac_ct_AR=$AR + for ac_prog in ar +do + # Extract the first word of "$ac_prog", so it can be a program name with args. +set dummy $ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_ac_ct_AR+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_AR"; then + ac_cv_prog_ac_ct_AR="$ac_ct_AR" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_AR="$ac_prog" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_AR=$ac_cv_prog_ac_ct_AR +if test -n "$ac_ct_AR"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_AR" >&5 +$as_echo "$ac_ct_AR" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$ac_ct_AR" && break +done + + if test "x$ac_ct_AR" = x; then + AR="false" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + AR=$ac_ct_AR + fi +fi + +: ${AR=ar} +: ${AR_FLAGS=cru} + + + + + + + + + + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for archiver @FILE support" >&5 +$as_echo_n "checking for archiver @FILE support... " >&6; } +if ${lt_cv_ar_at_file+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_ar_at_file=no + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + echo conftest.$ac_objext > conftest.lst + lt_ar_try='$AR $AR_FLAGS libconftest.a @conftest.lst >&5' + { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$lt_ar_try\""; } >&5 + (eval $lt_ar_try) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } + if test "$ac_status" -eq 0; then + # Ensure the archiver fails upon bogus file names. + rm -f conftest.$ac_objext libconftest.a + { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$lt_ar_try\""; } >&5 + (eval $lt_ar_try) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } + if test "$ac_status" -ne 0; then + lt_cv_ar_at_file=@ + fi + fi + rm -f conftest.* libconftest.a + +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ar_at_file" >&5 +$as_echo "$lt_cv_ar_at_file" >&6; } + +if test "x$lt_cv_ar_at_file" = xno; then + archiver_list_spec= +else + archiver_list_spec=$lt_cv_ar_at_file +fi + + + + + + + +if test -n "$ac_tool_prefix"; then + # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args. +set dummy ${ac_tool_prefix}strip; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_STRIP+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$STRIP"; then + ac_cv_prog_STRIP="$STRIP" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_STRIP="${ac_tool_prefix}strip" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +STRIP=$ac_cv_prog_STRIP +if test -n "$STRIP"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5 +$as_echo "$STRIP" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test -z "$ac_cv_prog_STRIP"; then + ac_ct_STRIP=$STRIP + # Extract the first word of "strip", so it can be a program name with args. +set dummy strip; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_ac_ct_STRIP+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_STRIP"; then + ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_STRIP="strip" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP +if test -n "$ac_ct_STRIP"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_STRIP" >&5 +$as_echo "$ac_ct_STRIP" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + if test "x$ac_ct_STRIP" = x; then + STRIP=":" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + STRIP=$ac_ct_STRIP + fi +else + STRIP="$ac_cv_prog_STRIP" +fi + +test -z "$STRIP" && STRIP=: + + + + + + +if test -n "$ac_tool_prefix"; then + # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args. +set dummy ${ac_tool_prefix}ranlib; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_RANLIB+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$RANLIB"; then + ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +RANLIB=$ac_cv_prog_RANLIB +if test -n "$RANLIB"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RANLIB" >&5 +$as_echo "$RANLIB" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test -z "$ac_cv_prog_RANLIB"; then + ac_ct_RANLIB=$RANLIB + # Extract the first word of "ranlib", so it can be a program name with args. +set dummy ranlib; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_ac_ct_RANLIB+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_RANLIB"; then + ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_RANLIB="ranlib" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB +if test -n "$ac_ct_RANLIB"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_RANLIB" >&5 +$as_echo "$ac_ct_RANLIB" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + if test "x$ac_ct_RANLIB" = x; then + RANLIB=":" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + RANLIB=$ac_ct_RANLIB + fi +else + RANLIB="$ac_cv_prog_RANLIB" +fi + +test -z "$RANLIB" && RANLIB=: + + + + + + +# Determine commands to create old-style static archives. +old_archive_cmds='$AR $AR_FLAGS $oldlib$oldobjs' +old_postinstall_cmds='chmod 644 $oldlib' +old_postuninstall_cmds= + +if test -n "$RANLIB"; then + case $host_os in + openbsd*) + old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB -t \$tool_oldlib" + ;; + *) + old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB \$tool_oldlib" + ;; + esac + old_archive_cmds="$old_archive_cmds~\$RANLIB \$tool_oldlib" +fi + +case $host_os in + darwin*) + lock_old_archive_extraction=yes ;; + *) + lock_old_archive_extraction=no ;; +esac + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +# If no C compiler was specified, use CC. +LTCC=${LTCC-"$CC"} + +# If no C compiler flags were specified, use CFLAGS. +LTCFLAGS=${LTCFLAGS-"$CFLAGS"} + +# Allow CC to be a program name with arguments. +compiler=$CC + + +# Check for command to grab the raw symbol name followed by C symbol from nm. +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking command to parse $NM output from $compiler object" >&5 +$as_echo_n "checking command to parse $NM output from $compiler object... " >&6; } +if ${lt_cv_sys_global_symbol_pipe+:} false; then : + $as_echo_n "(cached) " >&6 +else + +# These are sane defaults that work on at least a few old systems. +# [They come from Ultrix. What could be older than Ultrix?!! ;)] + +# Character class describing NM global symbol codes. +symcode='[BCDEGRST]' + +# Regexp to match symbols that can be accessed directly from C. +sympat='\([_A-Za-z][_A-Za-z0-9]*\)' + +# Define system-specific variables. +case $host_os in +aix*) + symcode='[BCDT]' + ;; +cygwin* | mingw* | pw32* | cegcc*) + symcode='[ABCDGISTW]' + ;; +hpux*) + if test "$host_cpu" = ia64; then + symcode='[ABCDEGRST]' + fi + ;; +irix* | nonstopux*) + symcode='[BCDEGRST]' + ;; +osf*) + symcode='[BCDEGQRST]' + ;; +solaris*) + symcode='[BDRT]' + ;; +sco3.2v5*) + symcode='[DT]' + ;; +sysv4.2uw2*) + symcode='[DT]' + ;; +sysv5* | sco5v6* | unixware* | OpenUNIX*) + symcode='[ABDT]' + ;; +sysv4) + symcode='[DFNSTU]' + ;; +esac + +# If we're using GNU nm, then use its standard symbol codes. +case `$NM -V 2>&1` in +*GNU* | *'with BFD'*) + symcode='[ABCDGIRSTW]' ;; +esac + +# Transform an extracted symbol line into a proper C declaration. +# Some systems (esp. on ia64) link data and code symbols differently, +# so use this general approach. +lt_cv_sys_global_symbol_to_cdecl="sed -n -e 's/^T .* \(.*\)$/extern int \1();/p' -e 's/^$symcode* .* \(.*\)$/extern char \1;/p'" + +# Transform an extracted symbol line into symbol name and symbol address +lt_cv_sys_global_symbol_to_c_name_address="sed -n -e 's/^: \([^ ]*\)[ ]*$/ {\\\"\1\\\", (void *) 0},/p' -e 's/^$symcode* \([^ ]*\) \([^ ]*\)$/ {\"\2\", (void *) \&\2},/p'" +lt_cv_sys_global_symbol_to_c_name_address_lib_prefix="sed -n -e 's/^: \([^ ]*\)[ ]*$/ {\\\"\1\\\", (void *) 0},/p' -e 's/^$symcode* \([^ ]*\) \(lib[^ ]*\)$/ {\"\2\", (void *) \&\2},/p' -e 's/^$symcode* \([^ ]*\) \([^ ]*\)$/ {\"lib\2\", (void *) \&\2},/p'" + +# Handle CRLF in mingw tool chain +opt_cr= +case $build_os in +mingw*) + opt_cr=`$ECHO 'x\{0,1\}' | tr x '\015'` # option cr in regexp + ;; +esac + +# Try without a prefix underscore, then with it. +for ac_symprfx in "" "_"; do + + # Transform symcode, sympat, and symprfx into a raw symbol and a C symbol. + symxfrm="\\1 $ac_symprfx\\2 \\2" + + # Write the raw and C identifiers. + if test "$lt_cv_nm_interface" = "MS dumpbin"; then + # Fake it for dumpbin and say T for any non-static function + # and D for any global variable. + # Also find C++ and __fastcall symbols from MSVC++, + # which start with @ or ?. + lt_cv_sys_global_symbol_pipe="$AWK '"\ +" {last_section=section; section=\$ 3};"\ +" /^COFF SYMBOL TABLE/{for(i in hide) delete hide[i]};"\ +" /Section length .*#relocs.*(pick any)/{hide[last_section]=1};"\ +" \$ 0!~/External *\|/{next};"\ +" / 0+ UNDEF /{next}; / UNDEF \([^|]\)*()/{next};"\ +" {if(hide[section]) next};"\ +" {f=0}; \$ 0~/\(\).*\|/{f=1}; {printf f ? \"T \" : \"D \"};"\ +" {split(\$ 0, a, /\||\r/); split(a[2], s)};"\ +" s[1]~/^[@?]/{print s[1], s[1]; next};"\ +" s[1]~prfx {split(s[1],t,\"@\"); print t[1], substr(t[1],length(prfx))}"\ +" ' prfx=^$ac_symprfx" + else + lt_cv_sys_global_symbol_pipe="sed -n -e 's/^.*[ ]\($symcode$symcode*\)[ ][ ]*$ac_symprfx$sympat$opt_cr$/$symxfrm/p'" + fi + lt_cv_sys_global_symbol_pipe="$lt_cv_sys_global_symbol_pipe | sed '/ __gnu_lto/d'" + + # Check to see that the pipe works correctly. + pipe_works=no + + rm -f conftest* + cat > conftest.$ac_ext <<_LT_EOF +#ifdef __cplusplus +extern "C" { +#endif +char nm_test_var; +void nm_test_func(void); +void nm_test_func(void){} +#ifdef __cplusplus +} +#endif +int main(){nm_test_var='a';nm_test_func();return(0);} +_LT_EOF + + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 + (eval $ac_compile) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then + # Now try to grab the symbols. + nlist=conftest.nm + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$NM conftest.$ac_objext \| "$lt_cv_sys_global_symbol_pipe" \> $nlist\""; } >&5 + (eval $NM conftest.$ac_objext \| "$lt_cv_sys_global_symbol_pipe" \> $nlist) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } && test -s "$nlist"; then + # Try sorting and uniquifying the output. + if sort "$nlist" | uniq > "$nlist"T; then + mv -f "$nlist"T "$nlist" + else + rm -f "$nlist"T + fi + + # Make sure that we snagged all the symbols we need. + if $GREP ' nm_test_var$' "$nlist" >/dev/null; then + if $GREP ' nm_test_func$' "$nlist" >/dev/null; then + cat <<_LT_EOF > conftest.$ac_ext +/* Keep this code in sync between libtool.m4, ltmain, lt_system.h, and tests. */ +#if defined(_WIN32) || defined(__CYGWIN__) || defined(_WIN32_WCE) +/* DATA imports from DLLs on WIN32 con't be const, because runtime + relocations are performed -- see ld's documentation on pseudo-relocs. */ +# define LT_DLSYM_CONST +#elif defined(__osf__) +/* This system does not cope well with relocations in const data. */ +# define LT_DLSYM_CONST +#else +# define LT_DLSYM_CONST const +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +_LT_EOF + # Now generate the symbol file. + eval "$lt_cv_sys_global_symbol_to_cdecl"' < "$nlist" | $GREP -v main >> conftest.$ac_ext' + + cat <<_LT_EOF >> conftest.$ac_ext + +/* The mapping between symbol names and symbols. */ +LT_DLSYM_CONST struct { + const char *name; + void *address; +} +lt__PROGRAM__LTX_preloaded_symbols[] = +{ + { "@PROGRAM@", (void *) 0 }, +_LT_EOF + $SED "s/^$symcode$symcode* \(.*\) \(.*\)$/ {\"\2\", (void *) \&\2},/" < "$nlist" | $GREP -v main >> conftest.$ac_ext + cat <<\_LT_EOF >> conftest.$ac_ext + {0, (void *) 0} +}; + +/* This works around a problem in FreeBSD linker */ +#ifdef FREEBSD_WORKAROUND +static const void *lt_preloaded_setup() { + return lt__PROGRAM__LTX_preloaded_symbols; +} +#endif + +#ifdef __cplusplus +} +#endif +_LT_EOF + # Now try linking the two files. + mv conftest.$ac_objext conftstm.$ac_objext + lt_globsym_save_LIBS=$LIBS + lt_globsym_save_CFLAGS=$CFLAGS + LIBS="conftstm.$ac_objext" + CFLAGS="$CFLAGS$lt_prog_compiler_no_builtin_flag" + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5 + (eval $ac_link) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } && test -s conftest${ac_exeext}; then + pipe_works=yes + fi + LIBS=$lt_globsym_save_LIBS + CFLAGS=$lt_globsym_save_CFLAGS + else + echo "cannot find nm_test_func in $nlist" >&5 + fi + else + echo "cannot find nm_test_var in $nlist" >&5 + fi + else + echo "cannot run $lt_cv_sys_global_symbol_pipe" >&5 + fi + else + echo "$progname: failed program was:" >&5 + cat conftest.$ac_ext >&5 + fi + rm -rf conftest* conftst* + + # Do not use the global_symbol_pipe unless it works. + if test "$pipe_works" = yes; then + break + else + lt_cv_sys_global_symbol_pipe= + fi +done + +fi + +if test -z "$lt_cv_sys_global_symbol_pipe"; then + lt_cv_sys_global_symbol_to_cdecl= +fi +if test -z "$lt_cv_sys_global_symbol_pipe$lt_cv_sys_global_symbol_to_cdecl"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: failed" >&5 +$as_echo "failed" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5 +$as_echo "ok" >&6; } +fi + +# Response file support. +if test "$lt_cv_nm_interface" = "MS dumpbin"; then + nm_file_list_spec='@' +elif $NM --help 2>/dev/null | grep '[@]FILE' >/dev/null; then + nm_file_list_spec='@' +fi + + + + + + + + + + + + + + + + + + + + + + + + + + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for sysroot" >&5 +$as_echo_n "checking for sysroot... " >&6; } + +# Check whether --with-sysroot was given. +if test "${with_sysroot+set}" = set; then : + withval=$with_sysroot; +else + with_sysroot=no +fi + + +lt_sysroot= +case ${with_sysroot} in #( + yes) + if test "$GCC" = yes; then + lt_sysroot=`$CC --print-sysroot 2>/dev/null` + fi + ;; #( + /*) + lt_sysroot=`echo "$with_sysroot" | sed -e "$sed_quote_subst"` + ;; #( + no|'') + ;; #( + *) + { $as_echo "$as_me:${as_lineno-$LINENO}: result: ${with_sysroot}" >&5 +$as_echo "${with_sysroot}" >&6; } + as_fn_error $? "The sysroot must be an absolute path." "$LINENO" 5 + ;; +esac + + { $as_echo "$as_me:${as_lineno-$LINENO}: result: ${lt_sysroot:-no}" >&5 +$as_echo "${lt_sysroot:-no}" >&6; } + + + + + +# Check whether --enable-libtool-lock was given. +if test "${enable_libtool_lock+set}" = set; then : + enableval=$enable_libtool_lock; +fi + +test "x$enable_libtool_lock" != xno && enable_libtool_lock=yes + +# Some flags need to be propagated to the compiler or linker for good +# libtool support. +case $host in +ia64-*-hpux*) + # Find out which ABI we are using. + echo 'int i;' > conftest.$ac_ext + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 + (eval $ac_compile) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then + case `/usr/bin/file conftest.$ac_objext` in + *ELF-32*) + HPUX_IA64_MODE="32" + ;; + *ELF-64*) + HPUX_IA64_MODE="64" + ;; + esac + fi + rm -rf conftest* + ;; +*-*-irix6*) + # Find out which ABI we are using. + echo '#line '$LINENO' "configure"' > conftest.$ac_ext + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 + (eval $ac_compile) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then + if test "$lt_cv_prog_gnu_ld" = yes; then + case `/usr/bin/file conftest.$ac_objext` in + *32-bit*) + LD="${LD-ld} -melf32bsmip" + ;; + *N32*) + LD="${LD-ld} -melf32bmipn32" + ;; + *64-bit*) + LD="${LD-ld} -melf64bmip" + ;; + esac + else + case `/usr/bin/file conftest.$ac_objext` in + *32-bit*) + LD="${LD-ld} -32" + ;; + *N32*) + LD="${LD-ld} -n32" + ;; + *64-bit*) + LD="${LD-ld} -64" + ;; + esac + fi + fi + rm -rf conftest* + ;; + +x86_64-*kfreebsd*-gnu|x86_64-*linux*|ppc*-*linux*|powerpc*-*linux*| \ +s390*-*linux*|s390*-*tpf*|sparc*-*linux*) + # Find out which ABI we are using. + echo 'int i;' > conftest.$ac_ext + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 + (eval $ac_compile) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then + case `/usr/bin/file conftest.o` in + *32-bit*) + case $host in + x86_64-*kfreebsd*-gnu) + LD="${LD-ld} -m elf_i386_fbsd" + ;; + x86_64-*linux*) + case `/usr/bin/file conftest.o` in + *x86-64*) + LD="${LD-ld} -m elf32_x86_64" + ;; + *) + LD="${LD-ld} -m elf_i386" + ;; + esac + ;; + ppc64-*linux*|powerpc64-*linux*) + LD="${LD-ld} -m elf32ppclinux" + ;; + s390x-*linux*) + LD="${LD-ld} -m elf_s390" + ;; + sparc64-*linux*) + LD="${LD-ld} -m elf32_sparc" + ;; + esac + ;; + *64-bit*) + case $host in + x86_64-*kfreebsd*-gnu) + LD="${LD-ld} -m elf_x86_64_fbsd" + ;; + x86_64-*linux*) + LD="${LD-ld} -m elf_x86_64" + ;; + ppc*-*linux*|powerpc*-*linux*) + LD="${LD-ld} -m elf64ppc" + ;; + s390*-*linux*|s390*-*tpf*) + LD="${LD-ld} -m elf64_s390" + ;; + sparc*-*linux*) + LD="${LD-ld} -m elf64_sparc" + ;; + esac + ;; + esac + fi + rm -rf conftest* + ;; + +*-*-sco3.2v5*) + # On SCO OpenServer 5, we need -belf to get full-featured binaries. + SAVE_CFLAGS="$CFLAGS" + CFLAGS="$CFLAGS -belf" + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C compiler needs -belf" >&5 +$as_echo_n "checking whether the C compiler needs -belf... " >&6; } +if ${lt_cv_cc_needs_belf+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu + + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + lt_cv_cc_needs_belf=yes +else + lt_cv_cc_needs_belf=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext + ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_cc_needs_belf" >&5 +$as_echo "$lt_cv_cc_needs_belf" >&6; } + if test x"$lt_cv_cc_needs_belf" != x"yes"; then + # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf + CFLAGS="$SAVE_CFLAGS" + fi + ;; +*-*solaris*) + # Find out which ABI we are using. + echo 'int i;' > conftest.$ac_ext + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 + (eval $ac_compile) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then + case `/usr/bin/file conftest.o` in + *64-bit*) + case $lt_cv_prog_gnu_ld in + yes*) + case $host in + i?86-*-solaris*) + LD="${LD-ld} -m elf_x86_64" + ;; + sparc*-*-solaris*) + LD="${LD-ld} -m elf64_sparc" + ;; + esac + # GNU ld 2.21 introduced _sol2 emulations. Use them if available. + if ${LD-ld} -V | grep _sol2 >/dev/null 2>&1; then + LD="${LD-ld}_sol2" + fi + ;; + *) + if ${LD-ld} -64 -r -o conftest2.o conftest.o >/dev/null 2>&1; then + LD="${LD-ld} -64" + fi + ;; + esac + ;; + esac + fi + rm -rf conftest* + ;; +esac + +need_locks="$enable_libtool_lock" + +if test -n "$ac_tool_prefix"; then + # Extract the first word of "${ac_tool_prefix}mt", so it can be a program name with args. +set dummy ${ac_tool_prefix}mt; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_MANIFEST_TOOL+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$MANIFEST_TOOL"; then + ac_cv_prog_MANIFEST_TOOL="$MANIFEST_TOOL" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_MANIFEST_TOOL="${ac_tool_prefix}mt" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +MANIFEST_TOOL=$ac_cv_prog_MANIFEST_TOOL +if test -n "$MANIFEST_TOOL"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MANIFEST_TOOL" >&5 +$as_echo "$MANIFEST_TOOL" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test -z "$ac_cv_prog_MANIFEST_TOOL"; then + ac_ct_MANIFEST_TOOL=$MANIFEST_TOOL + # Extract the first word of "mt", so it can be a program name with args. +set dummy mt; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_ac_ct_MANIFEST_TOOL+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_MANIFEST_TOOL"; then + ac_cv_prog_ac_ct_MANIFEST_TOOL="$ac_ct_MANIFEST_TOOL" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_MANIFEST_TOOL="mt" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_MANIFEST_TOOL=$ac_cv_prog_ac_ct_MANIFEST_TOOL +if test -n "$ac_ct_MANIFEST_TOOL"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_MANIFEST_TOOL" >&5 +$as_echo "$ac_ct_MANIFEST_TOOL" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + if test "x$ac_ct_MANIFEST_TOOL" = x; then + MANIFEST_TOOL=":" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + MANIFEST_TOOL=$ac_ct_MANIFEST_TOOL + fi +else + MANIFEST_TOOL="$ac_cv_prog_MANIFEST_TOOL" +fi + +test -z "$MANIFEST_TOOL" && MANIFEST_TOOL=mt +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if $MANIFEST_TOOL is a manifest tool" >&5 +$as_echo_n "checking if $MANIFEST_TOOL is a manifest tool... " >&6; } +if ${lt_cv_path_mainfest_tool+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_path_mainfest_tool=no + echo "$as_me:$LINENO: $MANIFEST_TOOL '-?'" >&5 + $MANIFEST_TOOL '-?' 2>conftest.err > conftest.out + cat conftest.err >&5 + if $GREP 'Manifest Tool' conftest.out > /dev/null; then + lt_cv_path_mainfest_tool=yes + fi + rm -f conftest* +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_path_mainfest_tool" >&5 +$as_echo "$lt_cv_path_mainfest_tool" >&6; } +if test "x$lt_cv_path_mainfest_tool" != xyes; then + MANIFEST_TOOL=: +fi + + + + + + + case $host_os in + rhapsody* | darwin*) + if test -n "$ac_tool_prefix"; then + # Extract the first word of "${ac_tool_prefix}dsymutil", so it can be a program name with args. +set dummy ${ac_tool_prefix}dsymutil; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_DSYMUTIL+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$DSYMUTIL"; then + ac_cv_prog_DSYMUTIL="$DSYMUTIL" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_DSYMUTIL="${ac_tool_prefix}dsymutil" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +DSYMUTIL=$ac_cv_prog_DSYMUTIL +if test -n "$DSYMUTIL"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5 +$as_echo "$DSYMUTIL" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test -z "$ac_cv_prog_DSYMUTIL"; then + ac_ct_DSYMUTIL=$DSYMUTIL + # Extract the first word of "dsymutil", so it can be a program name with args. +set dummy dsymutil; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_ac_ct_DSYMUTIL+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_DSYMUTIL"; then + ac_cv_prog_ac_ct_DSYMUTIL="$ac_ct_DSYMUTIL" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_DSYMUTIL="dsymutil" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_DSYMUTIL=$ac_cv_prog_ac_ct_DSYMUTIL +if test -n "$ac_ct_DSYMUTIL"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DSYMUTIL" >&5 +$as_echo "$ac_ct_DSYMUTIL" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + if test "x$ac_ct_DSYMUTIL" = x; then + DSYMUTIL=":" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + DSYMUTIL=$ac_ct_DSYMUTIL + fi +else + DSYMUTIL="$ac_cv_prog_DSYMUTIL" +fi + + if test -n "$ac_tool_prefix"; then + # Extract the first word of "${ac_tool_prefix}nmedit", so it can be a program name with args. +set dummy ${ac_tool_prefix}nmedit; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_NMEDIT+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$NMEDIT"; then + ac_cv_prog_NMEDIT="$NMEDIT" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_NMEDIT="${ac_tool_prefix}nmedit" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +NMEDIT=$ac_cv_prog_NMEDIT +if test -n "$NMEDIT"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NMEDIT" >&5 +$as_echo "$NMEDIT" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test -z "$ac_cv_prog_NMEDIT"; then + ac_ct_NMEDIT=$NMEDIT + # Extract the first word of "nmedit", so it can be a program name with args. +set dummy nmedit; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_ac_ct_NMEDIT+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_NMEDIT"; then + ac_cv_prog_ac_ct_NMEDIT="$ac_ct_NMEDIT" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_NMEDIT="nmedit" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_NMEDIT=$ac_cv_prog_ac_ct_NMEDIT +if test -n "$ac_ct_NMEDIT"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_NMEDIT" >&5 +$as_echo "$ac_ct_NMEDIT" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + if test "x$ac_ct_NMEDIT" = x; then + NMEDIT=":" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + NMEDIT=$ac_ct_NMEDIT + fi +else + NMEDIT="$ac_cv_prog_NMEDIT" +fi + + if test -n "$ac_tool_prefix"; then + # Extract the first word of "${ac_tool_prefix}lipo", so it can be a program name with args. +set dummy ${ac_tool_prefix}lipo; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_LIPO+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$LIPO"; then + ac_cv_prog_LIPO="$LIPO" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_LIPO="${ac_tool_prefix}lipo" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +LIPO=$ac_cv_prog_LIPO +if test -n "$LIPO"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LIPO" >&5 +$as_echo "$LIPO" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test -z "$ac_cv_prog_LIPO"; then + ac_ct_LIPO=$LIPO + # Extract the first word of "lipo", so it can be a program name with args. +set dummy lipo; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_ac_ct_LIPO+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_LIPO"; then + ac_cv_prog_ac_ct_LIPO="$ac_ct_LIPO" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_LIPO="lipo" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_LIPO=$ac_cv_prog_ac_ct_LIPO +if test -n "$ac_ct_LIPO"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_LIPO" >&5 +$as_echo "$ac_ct_LIPO" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + if test "x$ac_ct_LIPO" = x; then + LIPO=":" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + LIPO=$ac_ct_LIPO + fi +else + LIPO="$ac_cv_prog_LIPO" +fi + + if test -n "$ac_tool_prefix"; then + # Extract the first word of "${ac_tool_prefix}otool", so it can be a program name with args. +set dummy ${ac_tool_prefix}otool; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_OTOOL+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$OTOOL"; then + ac_cv_prog_OTOOL="$OTOOL" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_OTOOL="${ac_tool_prefix}otool" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +OTOOL=$ac_cv_prog_OTOOL +if test -n "$OTOOL"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OTOOL" >&5 +$as_echo "$OTOOL" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test -z "$ac_cv_prog_OTOOL"; then + ac_ct_OTOOL=$OTOOL + # Extract the first word of "otool", so it can be a program name with args. +set dummy otool; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_ac_ct_OTOOL+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_OTOOL"; then + ac_cv_prog_ac_ct_OTOOL="$ac_ct_OTOOL" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_OTOOL="otool" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_OTOOL=$ac_cv_prog_ac_ct_OTOOL +if test -n "$ac_ct_OTOOL"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OTOOL" >&5 +$as_echo "$ac_ct_OTOOL" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + if test "x$ac_ct_OTOOL" = x; then + OTOOL=":" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + OTOOL=$ac_ct_OTOOL + fi +else + OTOOL="$ac_cv_prog_OTOOL" +fi + + if test -n "$ac_tool_prefix"; then + # Extract the first word of "${ac_tool_prefix}otool64", so it can be a program name with args. +set dummy ${ac_tool_prefix}otool64; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_OTOOL64+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$OTOOL64"; then + ac_cv_prog_OTOOL64="$OTOOL64" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_OTOOL64="${ac_tool_prefix}otool64" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +OTOOL64=$ac_cv_prog_OTOOL64 +if test -n "$OTOOL64"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OTOOL64" >&5 +$as_echo "$OTOOL64" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test -z "$ac_cv_prog_OTOOL64"; then + ac_ct_OTOOL64=$OTOOL64 + # Extract the first word of "otool64", so it can be a program name with args. +set dummy otool64; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_ac_ct_OTOOL64+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_OTOOL64"; then + ac_cv_prog_ac_ct_OTOOL64="$ac_ct_OTOOL64" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_OTOOL64="otool64" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_OTOOL64=$ac_cv_prog_ac_ct_OTOOL64 +if test -n "$ac_ct_OTOOL64"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OTOOL64" >&5 +$as_echo "$ac_ct_OTOOL64" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + if test "x$ac_ct_OTOOL64" = x; then + OTOOL64=":" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + OTOOL64=$ac_ct_OTOOL64 + fi +else + OTOOL64="$ac_cv_prog_OTOOL64" +fi + + + + + + + + + + + + + + + + + + + + + + + + + + + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for -single_module linker flag" >&5 +$as_echo_n "checking for -single_module linker flag... " >&6; } +if ${lt_cv_apple_cc_single_mod+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_apple_cc_single_mod=no + if test -z "${LT_MULTI_MODULE}"; then + # By default we will add the -single_module flag. You can override + # by either setting the environment variable LT_MULTI_MODULE + # non-empty at configure time, or by adding -multi_module to the + # link flags. + rm -rf libconftest.dylib* + echo "int foo(void){return 1;}" > conftest.c + echo "$LTCC $LTCFLAGS $LDFLAGS -o libconftest.dylib \ +-dynamiclib -Wl,-single_module conftest.c" >&5 + $LTCC $LTCFLAGS $LDFLAGS -o libconftest.dylib \ + -dynamiclib -Wl,-single_module conftest.c 2>conftest.err + _lt_result=$? + # If there is a non-empty error log, and "single_module" + # appears in it, assume the flag caused a linker warning + if test -s conftest.err && $GREP single_module conftest.err; then + cat conftest.err >&5 + # Otherwise, if the output was created with a 0 exit code from + # the compiler, it worked. + elif test -f libconftest.dylib && test $_lt_result -eq 0; then + lt_cv_apple_cc_single_mod=yes + else + cat conftest.err >&5 + fi + rm -rf libconftest.dylib* + rm -f conftest.* + fi +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_apple_cc_single_mod" >&5 +$as_echo "$lt_cv_apple_cc_single_mod" >&6; } + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for -exported_symbols_list linker flag" >&5 +$as_echo_n "checking for -exported_symbols_list linker flag... " >&6; } +if ${lt_cv_ld_exported_symbols_list+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_ld_exported_symbols_list=no + save_LDFLAGS=$LDFLAGS + echo "_main" > conftest.sym + LDFLAGS="$LDFLAGS -Wl,-exported_symbols_list,conftest.sym" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + lt_cv_ld_exported_symbols_list=yes +else + lt_cv_ld_exported_symbols_list=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext + LDFLAGS="$save_LDFLAGS" + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ld_exported_symbols_list" >&5 +$as_echo "$lt_cv_ld_exported_symbols_list" >&6; } + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for -force_load linker flag" >&5 +$as_echo_n "checking for -force_load linker flag... " >&6; } +if ${lt_cv_ld_force_load+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_ld_force_load=no + cat > conftest.c << _LT_EOF +int forced_loaded() { return 2;} +_LT_EOF + echo "$LTCC $LTCFLAGS -c -o conftest.o conftest.c" >&5 + $LTCC $LTCFLAGS -c -o conftest.o conftest.c 2>&5 + echo "$AR cru libconftest.a conftest.o" >&5 + $AR cru libconftest.a conftest.o 2>&5 + echo "$RANLIB libconftest.a" >&5 + $RANLIB libconftest.a 2>&5 + cat > conftest.c << _LT_EOF +int main() { return 0;} +_LT_EOF + echo "$LTCC $LTCFLAGS $LDFLAGS -o conftest conftest.c -Wl,-force_load,./libconftest.a" >&5 + $LTCC $LTCFLAGS $LDFLAGS -o conftest conftest.c -Wl,-force_load,./libconftest.a 2>conftest.err + _lt_result=$? + if test -s conftest.err && $GREP force_load conftest.err; then + cat conftest.err >&5 + elif test -f conftest && test $_lt_result -eq 0 && $GREP forced_load conftest >/dev/null 2>&1 ; then + lt_cv_ld_force_load=yes + else + cat conftest.err >&5 + fi + rm -f conftest.err libconftest.a conftest conftest.c + rm -rf conftest.dSYM + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ld_force_load" >&5 +$as_echo "$lt_cv_ld_force_load" >&6; } + case $host_os in + rhapsody* | darwin1.[012]) + _lt_dar_allow_undefined='${wl}-undefined ${wl}suppress' ;; + darwin1.*) + _lt_dar_allow_undefined='${wl}-flat_namespace ${wl}-undefined ${wl}suppress' ;; + darwin*) # darwin 5.x on + # if running on 10.5 or later, the deployment target defaults + # to the OS version, if on x86, and 10.4, the deployment + # target defaults to 10.4. Don't you love it? + case ${MACOSX_DEPLOYMENT_TARGET-10.0},$host in + 10.0,*86*-darwin8*|10.0,*-darwin[91]*) + _lt_dar_allow_undefined='${wl}-undefined ${wl}dynamic_lookup' ;; + 10.[012]*) + _lt_dar_allow_undefined='${wl}-flat_namespace ${wl}-undefined ${wl}suppress' ;; + 10.*) + _lt_dar_allow_undefined='${wl}-undefined ${wl}dynamic_lookup' ;; + esac + ;; + esac + if test "$lt_cv_apple_cc_single_mod" = "yes"; then + _lt_dar_single_mod='$single_module' + fi + if test "$lt_cv_ld_exported_symbols_list" = "yes"; then + _lt_dar_export_syms=' ${wl}-exported_symbols_list,$output_objdir/${libname}-symbols.expsym' + else + _lt_dar_export_syms='~$NMEDIT -s $output_objdir/${libname}-symbols.expsym ${lib}' + fi + if test "$DSYMUTIL" != ":" && test "$lt_cv_ld_force_load" = "no"; then + _lt_dsymutil='~$DSYMUTIL $lib || :' + else + _lt_dsymutil= + fi + ;; + esac + +ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor" >&5 +$as_echo_n "checking how to run the C preprocessor... " >&6; } +# On Suns, sometimes $CPP names a directory. +if test -n "$CPP" && test -d "$CPP"; then + CPP= +fi +if test -z "$CPP"; then + if ${ac_cv_prog_CPP+:} false; then : + $as_echo_n "(cached) " >&6 +else + # Double quotes because CPP needs to be expanded + for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp" + do + ac_preproc_ok=false +for ac_c_preproc_warn_flag in '' yes +do + # Use a header file that comes with gcc, so configuring glibc + # with a fresh cross-compiler works. + # Prefer to if __STDC__ is defined, since + # exists even on freestanding compilers. + # On the NeXT, cc -E runs the code through the compiler's parser, + # not just through cpp. "Syntax error" is here to catch this case. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#ifdef __STDC__ +# include +#else +# include +#endif + Syntax error +_ACEOF +if ac_fn_c_try_cpp "$LINENO"; then : + +else + # Broken: fails on valid input. +continue +fi +rm -f conftest.err conftest.i conftest.$ac_ext + + # OK, works on sane cases. Now check whether nonexistent headers + # can be detected and how. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +_ACEOF +if ac_fn_c_try_cpp "$LINENO"; then : + # Broken: success on invalid input. +continue +else + # Passes both tests. +ac_preproc_ok=: +break +fi +rm -f conftest.err conftest.i conftest.$ac_ext + +done +# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. +rm -f conftest.i conftest.err conftest.$ac_ext +if $ac_preproc_ok; then : + break +fi + + done + ac_cv_prog_CPP=$CPP + +fi + CPP=$ac_cv_prog_CPP +else + ac_cv_prog_CPP=$CPP +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPP" >&5 +$as_echo "$CPP" >&6; } +ac_preproc_ok=false +for ac_c_preproc_warn_flag in '' yes +do + # Use a header file that comes with gcc, so configuring glibc + # with a fresh cross-compiler works. + # Prefer to if __STDC__ is defined, since + # exists even on freestanding compilers. + # On the NeXT, cc -E runs the code through the compiler's parser, + # not just through cpp. "Syntax error" is here to catch this case. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#ifdef __STDC__ +# include +#else +# include +#endif + Syntax error +_ACEOF +if ac_fn_c_try_cpp "$LINENO"; then : + +else + # Broken: fails on valid input. +continue +fi +rm -f conftest.err conftest.i conftest.$ac_ext + + # OK, works on sane cases. Now check whether nonexistent headers + # can be detected and how. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +_ACEOF +if ac_fn_c_try_cpp "$LINENO"; then : + # Broken: success on invalid input. +continue +else + # Passes both tests. +ac_preproc_ok=: +break +fi +rm -f conftest.err conftest.i conftest.$ac_ext + +done +# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. +rm -f conftest.i conftest.err conftest.$ac_ext +if $ac_preproc_ok; then : + +else + { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 +$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} +as_fn_error $? "C preprocessor \"$CPP\" fails sanity check +See \`config.log' for more details" "$LINENO" 5; } +fi + +ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for ANSI C header files" >&5 +$as_echo_n "checking for ANSI C header files... " >&6; } +if ${ac_cv_header_stdc+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +#include +#include +#include + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + ac_cv_header_stdc=yes +else + ac_cv_header_stdc=no +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext + +if test $ac_cv_header_stdc = yes; then + # SunOS 4.x string.h does not declare mem*, contrary to ANSI. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include + +_ACEOF +if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | + $EGREP "memchr" >/dev/null 2>&1; then : + +else + ac_cv_header_stdc=no +fi +rm -f conftest* + +fi + +if test $ac_cv_header_stdc = yes; then + # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include + +_ACEOF +if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | + $EGREP "free" >/dev/null 2>&1; then : + +else + ac_cv_header_stdc=no +fi +rm -f conftest* + +fi + +if test $ac_cv_header_stdc = yes; then + # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi. + if test "$cross_compiling" = yes; then : + : +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +#include +#if ((' ' & 0x0FF) == 0x020) +# define ISLOWER(c) ('a' <= (c) && (c) <= 'z') +# define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c)) +#else +# define ISLOWER(c) \ + (('a' <= (c) && (c) <= 'i') \ + || ('j' <= (c) && (c) <= 'r') \ + || ('s' <= (c) && (c) <= 'z')) +# define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c)) +#endif + +#define XOR(e, f) (((e) && !(f)) || (!(e) && (f))) +int +main () +{ + int i; + for (i = 0; i < 256; i++) + if (XOR (islower (i), ISLOWER (i)) + || toupper (i) != TOUPPER (i)) + return 2; + return 0; +} +_ACEOF +if ac_fn_c_try_run "$LINENO"; then : + +else + ac_cv_header_stdc=no +fi +rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ + conftest.$ac_objext conftest.beam conftest.$ac_ext +fi + +fi +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdc" >&5 +$as_echo "$ac_cv_header_stdc" >&6; } +if test $ac_cv_header_stdc = yes; then + +$as_echo "#define STDC_HEADERS 1" >>confdefs.h + +fi + +# On IRIX 5.3, sys/types and inttypes.h are conflicting. +for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \ + inttypes.h stdint.h unistd.h +do : + as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh` +ac_fn_c_check_header_compile "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default +" +if eval test \"x\$"$as_ac_Header"\" = x"yes"; then : + cat >>confdefs.h <<_ACEOF +#define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1 +_ACEOF + +fi + +done + + +for ac_header in dlfcn.h +do : + ac_fn_c_check_header_compile "$LINENO" "dlfcn.h" "ac_cv_header_dlfcn_h" "$ac_includes_default +" +if test "x$ac_cv_header_dlfcn_h" = xyes; then : + cat >>confdefs.h <<_ACEOF +#define HAVE_DLFCN_H 1 +_ACEOF + +fi + +done + + + + + +# Set options +enable_win32_dll=yes + +case $host in +*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-cegcc*) + if test -n "$ac_tool_prefix"; then + # Extract the first word of "${ac_tool_prefix}as", so it can be a program name with args. +set dummy ${ac_tool_prefix}as; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_AS+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$AS"; then + ac_cv_prog_AS="$AS" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_AS="${ac_tool_prefix}as" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +AS=$ac_cv_prog_AS +if test -n "$AS"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AS" >&5 +$as_echo "$AS" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test -z "$ac_cv_prog_AS"; then + ac_ct_AS=$AS + # Extract the first word of "as", so it can be a program name with args. +set dummy as; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_ac_ct_AS+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_AS"; then + ac_cv_prog_ac_ct_AS="$ac_ct_AS" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_AS="as" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_AS=$ac_cv_prog_ac_ct_AS +if test -n "$ac_ct_AS"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_AS" >&5 +$as_echo "$ac_ct_AS" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + if test "x$ac_ct_AS" = x; then + AS="false" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + AS=$ac_ct_AS + fi +else + AS="$ac_cv_prog_AS" +fi + + if test -n "$ac_tool_prefix"; then + # Extract the first word of "${ac_tool_prefix}dlltool", so it can be a program name with args. +set dummy ${ac_tool_prefix}dlltool; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_DLLTOOL+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$DLLTOOL"; then + ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_DLLTOOL="${ac_tool_prefix}dlltool" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +DLLTOOL=$ac_cv_prog_DLLTOOL +if test -n "$DLLTOOL"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DLLTOOL" >&5 +$as_echo "$DLLTOOL" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test -z "$ac_cv_prog_DLLTOOL"; then + ac_ct_DLLTOOL=$DLLTOOL + # Extract the first word of "dlltool", so it can be a program name with args. +set dummy dlltool; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_ac_ct_DLLTOOL+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_DLLTOOL"; then + ac_cv_prog_ac_ct_DLLTOOL="$ac_ct_DLLTOOL" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_DLLTOOL="dlltool" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_DLLTOOL=$ac_cv_prog_ac_ct_DLLTOOL +if test -n "$ac_ct_DLLTOOL"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DLLTOOL" >&5 +$as_echo "$ac_ct_DLLTOOL" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + if test "x$ac_ct_DLLTOOL" = x; then + DLLTOOL="false" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + DLLTOOL=$ac_ct_DLLTOOL + fi +else + DLLTOOL="$ac_cv_prog_DLLTOOL" +fi + + if test -n "$ac_tool_prefix"; then + # Extract the first word of "${ac_tool_prefix}objdump", so it can be a program name with args. +set dummy ${ac_tool_prefix}objdump; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_OBJDUMP+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$OBJDUMP"; then + ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_OBJDUMP="${ac_tool_prefix}objdump" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +OBJDUMP=$ac_cv_prog_OBJDUMP +if test -n "$OBJDUMP"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OBJDUMP" >&5 +$as_echo "$OBJDUMP" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test -z "$ac_cv_prog_OBJDUMP"; then + ac_ct_OBJDUMP=$OBJDUMP + # Extract the first word of "objdump", so it can be a program name with args. +set dummy objdump; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_ac_ct_OBJDUMP+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_OBJDUMP"; then + ac_cv_prog_ac_ct_OBJDUMP="$ac_ct_OBJDUMP" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_OBJDUMP="objdump" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_OBJDUMP=$ac_cv_prog_ac_ct_OBJDUMP +if test -n "$ac_ct_OBJDUMP"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OBJDUMP" >&5 +$as_echo "$ac_ct_OBJDUMP" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + if test "x$ac_ct_OBJDUMP" = x; then + OBJDUMP="false" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + OBJDUMP=$ac_ct_OBJDUMP + fi +else + OBJDUMP="$ac_cv_prog_OBJDUMP" +fi + + ;; +esac + +test -z "$AS" && AS=as + + + + + +test -z "$DLLTOOL" && DLLTOOL=dlltool + + + + + +test -z "$OBJDUMP" && OBJDUMP=objdump + + + + + + + + enable_dlopen=no + + + + # Check whether --enable-shared was given. +if test "${enable_shared+set}" = set; then : + enableval=$enable_shared; p=${PACKAGE-default} + case $enableval in + yes) enable_shared=yes ;; + no) enable_shared=no ;; + *) + enable_shared=no + # Look at the argument we got. We use all the common list separators. + lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR," + for pkg in $enableval; do + IFS="$lt_save_ifs" + if test "X$pkg" = "X$p"; then + enable_shared=yes + fi + done + IFS="$lt_save_ifs" + ;; + esac +else + enable_shared=yes +fi + + + + + + + + + + # Check whether --enable-static was given. +if test "${enable_static+set}" = set; then : + enableval=$enable_static; p=${PACKAGE-default} + case $enableval in + yes) enable_static=yes ;; + no) enable_static=no ;; + *) + enable_static=no + # Look at the argument we got. We use all the common list separators. + lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR," + for pkg in $enableval; do + IFS="$lt_save_ifs" + if test "X$pkg" = "X$p"; then + enable_static=yes + fi + done + IFS="$lt_save_ifs" + ;; + esac +else + enable_static=yes +fi + + + + + + + + + + +# Check whether --with-pic was given. +if test "${with_pic+set}" = set; then : + withval=$with_pic; lt_p=${PACKAGE-default} + case $withval in + yes|no) pic_mode=$withval ;; + *) + pic_mode=default + # Look at the argument we got. We use all the common list separators. + lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR," + for lt_pkg in $withval; do + IFS="$lt_save_ifs" + if test "X$lt_pkg" = "X$lt_p"; then + pic_mode=yes + fi + done + IFS="$lt_save_ifs" + ;; + esac +else + pic_mode=default +fi + + +test -z "$pic_mode" && pic_mode=default + + + + + + + + # Check whether --enable-fast-install was given. +if test "${enable_fast_install+set}" = set; then : + enableval=$enable_fast_install; p=${PACKAGE-default} + case $enableval in + yes) enable_fast_install=yes ;; + no) enable_fast_install=no ;; + *) + enable_fast_install=no + # Look at the argument we got. We use all the common list separators. + lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR," + for pkg in $enableval; do + IFS="$lt_save_ifs" + if test "X$pkg" = "X$p"; then + enable_fast_install=yes + fi + done + IFS="$lt_save_ifs" + ;; + esac +else + enable_fast_install=yes +fi + + + + + + + + + + + +# This can be used to rebuild libtool when needed +LIBTOOL_DEPS="$ltmain" + +# Always use our own libtool. +LIBTOOL='$(SHELL) $(top_builddir)/libtool' + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +test -z "$LN_S" && LN_S="ln -s" + + + + + + + + + + + + + + +if test -n "${ZSH_VERSION+set}" ; then + setopt NO_GLOB_SUBST +fi + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for objdir" >&5 +$as_echo_n "checking for objdir... " >&6; } +if ${lt_cv_objdir+:} false; then : + $as_echo_n "(cached) " >&6 +else + rm -f .libs 2>/dev/null +mkdir .libs 2>/dev/null +if test -d .libs; then + lt_cv_objdir=.libs +else + # MS-DOS does not allow filenames that begin with a dot. + lt_cv_objdir=_libs +fi +rmdir .libs 2>/dev/null +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_objdir" >&5 +$as_echo "$lt_cv_objdir" >&6; } +objdir=$lt_cv_objdir + + + + + +cat >>confdefs.h <<_ACEOF +#define LT_OBJDIR "$lt_cv_objdir/" +_ACEOF + + + + +case $host_os in +aix3*) + # AIX sometimes has problems with the GCC collect2 program. For some + # reason, if we set the COLLECT_NAMES environment variable, the problems + # vanish in a puff of smoke. + if test "X${COLLECT_NAMES+set}" != Xset; then + COLLECT_NAMES= + export COLLECT_NAMES + fi + ;; +esac + +# Global variables: +ofile=libtool +can_build_shared=yes + +# All known linkers require a `.a' archive for static linking (except MSVC, +# which needs '.lib'). +libext=a + +with_gnu_ld="$lt_cv_prog_gnu_ld" + +old_CC="$CC" +old_CFLAGS="$CFLAGS" + +# Set sane defaults for various variables +test -z "$CC" && CC=cc +test -z "$LTCC" && LTCC=$CC +test -z "$LTCFLAGS" && LTCFLAGS=$CFLAGS +test -z "$LD" && LD=ld +test -z "$ac_objext" && ac_objext=o + +for cc_temp in $compiler""; do + case $cc_temp in + compile | *[\\/]compile | ccache | *[\\/]ccache ) ;; + distcc | *[\\/]distcc | purify | *[\\/]purify ) ;; + \-*) ;; + *) break;; + esac +done +cc_basename=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"` + + +# Only perform the check for file, if the check method requires it +test -z "$MAGIC_CMD" && MAGIC_CMD=file +case $deplibs_check_method in +file_magic*) + if test "$file_magic_cmd" = '$MAGIC_CMD'; then + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ${ac_tool_prefix}file" >&5 +$as_echo_n "checking for ${ac_tool_prefix}file... " >&6; } +if ${lt_cv_path_MAGIC_CMD+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $MAGIC_CMD in +[\\/*] | ?:[\\/]*) + lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path. + ;; +*) + lt_save_MAGIC_CMD="$MAGIC_CMD" + lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR + ac_dummy="/usr/bin$PATH_SEPARATOR$PATH" + for ac_dir in $ac_dummy; do + IFS="$lt_save_ifs" + test -z "$ac_dir" && ac_dir=. + if test -f $ac_dir/${ac_tool_prefix}file; then + lt_cv_path_MAGIC_CMD="$ac_dir/${ac_tool_prefix}file" + if test -n "$file_magic_test_file"; then + case $deplibs_check_method in + "file_magic "*) + file_magic_regex=`expr "$deplibs_check_method" : "file_magic \(.*\)"` + MAGIC_CMD="$lt_cv_path_MAGIC_CMD" + if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null | + $EGREP "$file_magic_regex" > /dev/null; then + : + else + cat <<_LT_EOF 1>&2 + +*** Warning: the command libtool uses to detect shared libraries, +*** $file_magic_cmd, produces output that libtool cannot recognize. +*** The result is that libtool may fail to recognize shared libraries +*** as such. This will affect the creation of libtool libraries that +*** depend on shared libraries, but programs linked with such libtool +*** libraries will work regardless of this problem. Nevertheless, you +*** may want to report the problem to your system manager and/or to +*** bug-libtool@gnu.org + +_LT_EOF + fi ;; + esac + fi + break + fi + done + IFS="$lt_save_ifs" + MAGIC_CMD="$lt_save_MAGIC_CMD" + ;; +esac +fi + +MAGIC_CMD="$lt_cv_path_MAGIC_CMD" +if test -n "$MAGIC_CMD"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MAGIC_CMD" >&5 +$as_echo "$MAGIC_CMD" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + + + +if test -z "$lt_cv_path_MAGIC_CMD"; then + if test -n "$ac_tool_prefix"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for file" >&5 +$as_echo_n "checking for file... " >&6; } +if ${lt_cv_path_MAGIC_CMD+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $MAGIC_CMD in +[\\/*] | ?:[\\/]*) + lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path. + ;; +*) + lt_save_MAGIC_CMD="$MAGIC_CMD" + lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR + ac_dummy="/usr/bin$PATH_SEPARATOR$PATH" + for ac_dir in $ac_dummy; do + IFS="$lt_save_ifs" + test -z "$ac_dir" && ac_dir=. + if test -f $ac_dir/file; then + lt_cv_path_MAGIC_CMD="$ac_dir/file" + if test -n "$file_magic_test_file"; then + case $deplibs_check_method in + "file_magic "*) + file_magic_regex=`expr "$deplibs_check_method" : "file_magic \(.*\)"` + MAGIC_CMD="$lt_cv_path_MAGIC_CMD" + if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null | + $EGREP "$file_magic_regex" > /dev/null; then + : + else + cat <<_LT_EOF 1>&2 + +*** Warning: the command libtool uses to detect shared libraries, +*** $file_magic_cmd, produces output that libtool cannot recognize. +*** The result is that libtool may fail to recognize shared libraries +*** as such. This will affect the creation of libtool libraries that +*** depend on shared libraries, but programs linked with such libtool +*** libraries will work regardless of this problem. Nevertheless, you +*** may want to report the problem to your system manager and/or to +*** bug-libtool@gnu.org + +_LT_EOF + fi ;; + esac + fi + break + fi + done + IFS="$lt_save_ifs" + MAGIC_CMD="$lt_save_MAGIC_CMD" + ;; +esac +fi + +MAGIC_CMD="$lt_cv_path_MAGIC_CMD" +if test -n "$MAGIC_CMD"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MAGIC_CMD" >&5 +$as_echo "$MAGIC_CMD" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + else + MAGIC_CMD=: + fi +fi + + fi + ;; +esac + +# Use C for the default configuration in the libtool script + +lt_save_CC="$CC" +ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu + + +# Source file extension for C test sources. +ac_ext=c + +# Object file extension for compiled C test sources. +objext=o +objext=$objext + +# Code to be used in simple compile tests +lt_simple_compile_test_code="int some_variable = 0;" + +# Code to be used in simple link tests +lt_simple_link_test_code='int main(){return(0);}' + + + + + + + +# If no C compiler was specified, use CC. +LTCC=${LTCC-"$CC"} + +# If no C compiler flags were specified, use CFLAGS. +LTCFLAGS=${LTCFLAGS-"$CFLAGS"} + +# Allow CC to be a program name with arguments. +compiler=$CC + +# Save the default compiler, since it gets overwritten when the other +# tags are being tested, and _LT_TAGVAR(compiler, []) is a NOP. +compiler_DEFAULT=$CC + +# save warnings/boilerplate of simple test code +ac_outfile=conftest.$ac_objext +echo "$lt_simple_compile_test_code" >conftest.$ac_ext +eval "$ac_compile" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err +_lt_compiler_boilerplate=`cat conftest.err` +$RM conftest* + +ac_outfile=conftest.$ac_objext +echo "$lt_simple_link_test_code" >conftest.$ac_ext +eval "$ac_link" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err +_lt_linker_boilerplate=`cat conftest.err` +$RM -r conftest* + + +## CAVEAT EMPTOR: +## There is no encapsulation within the following macros, do not change +## the running order or otherwise move them around unless you know exactly +## what you are doing... +if test -n "$compiler"; then + +lt_prog_compiler_no_builtin_flag= + +if test "$GCC" = yes; then + case $cc_basename in + nvcc*) + lt_prog_compiler_no_builtin_flag=' -Xcompiler -fno-builtin' ;; + *) + lt_prog_compiler_no_builtin_flag=' -fno-builtin' ;; + esac + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -fno-rtti -fno-exceptions" >&5 +$as_echo_n "checking if $compiler supports -fno-rtti -fno-exceptions... " >&6; } +if ${lt_cv_prog_compiler_rtti_exceptions+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_prog_compiler_rtti_exceptions=no + ac_outfile=conftest.$ac_objext + echo "$lt_simple_compile_test_code" > conftest.$ac_ext + lt_compiler_flag="-fno-rtti -fno-exceptions" + # Insert the option either (1) after the last *FLAGS variable, or + # (2) before a word containing "conftest.", or (3) at the end. + # Note that $ac_compile itself does not contain backslashes and begins + # with a dollar sign (not a hyphen), so the echo should work correctly. + # The option is referenced via a variable to avoid confusing sed. + lt_compile=`echo "$ac_compile" | $SED \ + -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \ + -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \ + -e 's:$: $lt_compiler_flag:'` + (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&5) + (eval "$lt_compile" 2>conftest.err) + ac_status=$? + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + if (exit $ac_status) && test -s "$ac_outfile"; then + # The compiler can only warn and ignore the option if not recognized + # So say no if there are warnings other than the usual output. + $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' >conftest.exp + $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2 + if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then + lt_cv_prog_compiler_rtti_exceptions=yes + fi + fi + $RM conftest* + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_rtti_exceptions" >&5 +$as_echo "$lt_cv_prog_compiler_rtti_exceptions" >&6; } + +if test x"$lt_cv_prog_compiler_rtti_exceptions" = xyes; then + lt_prog_compiler_no_builtin_flag="$lt_prog_compiler_no_builtin_flag -fno-rtti -fno-exceptions" +else + : +fi + +fi + + + + + + + lt_prog_compiler_wl= +lt_prog_compiler_pic= +lt_prog_compiler_static= + + + if test "$GCC" = yes; then + lt_prog_compiler_wl='-Wl,' + lt_prog_compiler_static='-static' + + case $host_os in + aix*) + # All AIX code is PIC. + if test "$host_cpu" = ia64; then + # AIX 5 now supports IA64 processor + lt_prog_compiler_static='-Bstatic' + fi + ;; + + amigaos*) + case $host_cpu in + powerpc) + # see comment about AmigaOS4 .so support + lt_prog_compiler_pic='-fPIC' + ;; + m68k) + # FIXME: we need at least 68020 code to build shared libraries, but + # adding the `-m68020' flag to GCC prevents building anything better, + # like `-m68040'. + lt_prog_compiler_pic='-m68020 -resident32 -malways-restore-a4' + ;; + esac + ;; + + beos* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*) + # PIC is the default for these OSes. + ;; + + mingw* | cygwin* | pw32* | os2* | cegcc*) + # This hack is so that the source file can tell whether it is being + # built for inclusion in a dll (and should export symbols for example). + # Although the cygwin gcc ignores -fPIC, still need this for old-style + # (--disable-auto-import) libraries + lt_prog_compiler_pic='-DDLL_EXPORT' + ;; + + darwin* | rhapsody*) + # PIC is the default on this platform + # Common symbols not allowed in MH_DYLIB files + lt_prog_compiler_pic='-fno-common' + ;; + + haiku*) + # PIC is the default for Haiku. + # The "-static" flag exists, but is broken. + lt_prog_compiler_static= + ;; + + hpux*) + # PIC is the default for 64-bit PA HP-UX, but not for 32-bit + # PA HP-UX. On IA64 HP-UX, PIC is the default but the pic flag + # sets the default TLS model and affects inlining. + case $host_cpu in + hppa*64*) + # +Z the default + ;; + *) + lt_prog_compiler_pic='-fPIC' + ;; + esac + ;; + + interix[3-9]*) + # Interix 3.x gcc -fpic/-fPIC options generate broken code. + # Instead, we relocate shared libraries at runtime. + ;; + + msdosdjgpp*) + # Just because we use GCC doesn't mean we suddenly get shared libraries + # on systems that don't support them. + lt_prog_compiler_can_build_shared=no + enable_shared=no + ;; + + *nto* | *qnx*) + # QNX uses GNU C++, but need to define -shared option too, otherwise + # it will coredump. + lt_prog_compiler_pic='-fPIC -shared' + ;; + + sysv4*MP*) + if test -d /usr/nec; then + lt_prog_compiler_pic=-Kconform_pic + fi + ;; + + *) + lt_prog_compiler_pic='-fPIC' + ;; + esac + + case $cc_basename in + nvcc*) # Cuda Compiler Driver 2.2 + lt_prog_compiler_wl='-Xlinker ' + if test -n "$lt_prog_compiler_pic"; then + lt_prog_compiler_pic="-Xcompiler $lt_prog_compiler_pic" + fi + ;; + esac + else + # PORTME Check for flag to pass linker flags through the system compiler. + case $host_os in + aix*) + lt_prog_compiler_wl='-Wl,' + if test "$host_cpu" = ia64; then + # AIX 5 now supports IA64 processor + lt_prog_compiler_static='-Bstatic' + else + lt_prog_compiler_static='-bnso -bI:/lib/syscalls.exp' + fi + ;; + + mingw* | cygwin* | pw32* | os2* | cegcc*) + # This hack is so that the source file can tell whether it is being + # built for inclusion in a dll (and should export symbols for example). + lt_prog_compiler_pic='-DDLL_EXPORT' + ;; + + hpux9* | hpux10* | hpux11*) + lt_prog_compiler_wl='-Wl,' + # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but + # not for PA HP-UX. + case $host_cpu in + hppa*64*|ia64*) + # +Z the default + ;; + *) + lt_prog_compiler_pic='+Z' + ;; + esac + # Is there a better lt_prog_compiler_static that works with the bundled CC? + lt_prog_compiler_static='${wl}-a ${wl}archive' + ;; + + irix5* | irix6* | nonstopux*) + lt_prog_compiler_wl='-Wl,' + # PIC (with -KPIC) is the default. + lt_prog_compiler_static='-non_shared' + ;; + + linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*) + case $cc_basename in + # old Intel for x86_64 which still supported -KPIC. + ecc*) + lt_prog_compiler_wl='-Wl,' + lt_prog_compiler_pic='-KPIC' + lt_prog_compiler_static='-static' + ;; + # icc used to be incompatible with GCC. + # ICC 10 doesn't accept -KPIC any more. + icc* | ifort*) + lt_prog_compiler_wl='-Wl,' + lt_prog_compiler_pic='-fPIC' + lt_prog_compiler_static='-static' + ;; + # Lahey Fortran 8.1. + lf95*) + lt_prog_compiler_wl='-Wl,' + lt_prog_compiler_pic='--shared' + lt_prog_compiler_static='--static' + ;; + nagfor*) + # NAG Fortran compiler + lt_prog_compiler_wl='-Wl,-Wl,,' + lt_prog_compiler_pic='-PIC' + lt_prog_compiler_static='-Bstatic' + ;; + pgcc* | pgf77* | pgf90* | pgf95* | pgfortran*) + # Portland Group compilers (*not* the Pentium gcc compiler, + # which looks to be a dead project) + lt_prog_compiler_wl='-Wl,' + lt_prog_compiler_pic='-fpic' + lt_prog_compiler_static='-Bstatic' + ;; + ccc*) + lt_prog_compiler_wl='-Wl,' + # All Alpha code is PIC. + lt_prog_compiler_static='-non_shared' + ;; + xl* | bgxl* | bgf* | mpixl*) + # IBM XL C 8.0/Fortran 10.1, 11.1 on PPC and BlueGene + lt_prog_compiler_wl='-Wl,' + lt_prog_compiler_pic='-qpic' + lt_prog_compiler_static='-qstaticlink' + ;; + *) + case `$CC -V 2>&1 | sed 5q` in + *Sun\ Ceres\ Fortran* | *Sun*Fortran*\ [1-7].* | *Sun*Fortran*\ 8.[0-3]*) + # Sun Fortran 8.3 passes all unrecognized flags to the linker + lt_prog_compiler_pic='-KPIC' + lt_prog_compiler_static='-Bstatic' + lt_prog_compiler_wl='' + ;; + *Sun\ F* | *Sun*Fortran*) + lt_prog_compiler_pic='-KPIC' + lt_prog_compiler_static='-Bstatic' + lt_prog_compiler_wl='-Qoption ld ' + ;; + *Sun\ C*) + # Sun C 5.9 + lt_prog_compiler_pic='-KPIC' + lt_prog_compiler_static='-Bstatic' + lt_prog_compiler_wl='-Wl,' + ;; + *Intel*\ [CF]*Compiler*) + lt_prog_compiler_wl='-Wl,' + lt_prog_compiler_pic='-fPIC' + lt_prog_compiler_static='-static' + ;; + *Portland\ Group*) + lt_prog_compiler_wl='-Wl,' + lt_prog_compiler_pic='-fpic' + lt_prog_compiler_static='-Bstatic' + ;; + esac + ;; + esac + ;; + + newsos6) + lt_prog_compiler_pic='-KPIC' + lt_prog_compiler_static='-Bstatic' + ;; + + *nto* | *qnx*) + # QNX uses GNU C++, but need to define -shared option too, otherwise + # it will coredump. + lt_prog_compiler_pic='-fPIC -shared' + ;; + + osf3* | osf4* | osf5*) + lt_prog_compiler_wl='-Wl,' + # All OSF/1 code is PIC. + lt_prog_compiler_static='-non_shared' + ;; + + rdos*) + lt_prog_compiler_static='-non_shared' + ;; + + solaris*) + lt_prog_compiler_pic='-KPIC' + lt_prog_compiler_static='-Bstatic' + case $cc_basename in + f77* | f90* | f95* | sunf77* | sunf90* | sunf95*) + lt_prog_compiler_wl='-Qoption ld ';; + *) + lt_prog_compiler_wl='-Wl,';; + esac + ;; + + sunos4*) + lt_prog_compiler_wl='-Qoption ld ' + lt_prog_compiler_pic='-PIC' + lt_prog_compiler_static='-Bstatic' + ;; + + sysv4 | sysv4.2uw2* | sysv4.3*) + lt_prog_compiler_wl='-Wl,' + lt_prog_compiler_pic='-KPIC' + lt_prog_compiler_static='-Bstatic' + ;; + + sysv4*MP*) + if test -d /usr/nec ;then + lt_prog_compiler_pic='-Kconform_pic' + lt_prog_compiler_static='-Bstatic' + fi + ;; + + sysv5* | unixware* | sco3.2v5* | sco5v6* | OpenUNIX*) + lt_prog_compiler_wl='-Wl,' + lt_prog_compiler_pic='-KPIC' + lt_prog_compiler_static='-Bstatic' + ;; + + unicos*) + lt_prog_compiler_wl='-Wl,' + lt_prog_compiler_can_build_shared=no + ;; + + uts4*) + lt_prog_compiler_pic='-pic' + lt_prog_compiler_static='-Bstatic' + ;; + + *) + lt_prog_compiler_can_build_shared=no + ;; + esac + fi + +case $host_os in + # For platforms which do not support PIC, -DPIC is meaningless: + *djgpp*) + lt_prog_compiler_pic= + ;; + *) + lt_prog_compiler_pic="$lt_prog_compiler_pic -DPIC" + ;; +esac + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $compiler option to produce PIC" >&5 +$as_echo_n "checking for $compiler option to produce PIC... " >&6; } +if ${lt_cv_prog_compiler_pic+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_prog_compiler_pic=$lt_prog_compiler_pic +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic" >&5 +$as_echo "$lt_cv_prog_compiler_pic" >&6; } +lt_prog_compiler_pic=$lt_cv_prog_compiler_pic + +# +# Check to make sure the PIC flag actually works. +# +if test -n "$lt_prog_compiler_pic"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler PIC flag $lt_prog_compiler_pic works" >&5 +$as_echo_n "checking if $compiler PIC flag $lt_prog_compiler_pic works... " >&6; } +if ${lt_cv_prog_compiler_pic_works+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_prog_compiler_pic_works=no + ac_outfile=conftest.$ac_objext + echo "$lt_simple_compile_test_code" > conftest.$ac_ext + lt_compiler_flag="$lt_prog_compiler_pic -DPIC" + # Insert the option either (1) after the last *FLAGS variable, or + # (2) before a word containing "conftest.", or (3) at the end. + # Note that $ac_compile itself does not contain backslashes and begins + # with a dollar sign (not a hyphen), so the echo should work correctly. + # The option is referenced via a variable to avoid confusing sed. + lt_compile=`echo "$ac_compile" | $SED \ + -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \ + -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \ + -e 's:$: $lt_compiler_flag:'` + (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&5) + (eval "$lt_compile" 2>conftest.err) + ac_status=$? + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + if (exit $ac_status) && test -s "$ac_outfile"; then + # The compiler can only warn and ignore the option if not recognized + # So say no if there are warnings other than the usual output. + $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' >conftest.exp + $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2 + if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then + lt_cv_prog_compiler_pic_works=yes + fi + fi + $RM conftest* + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic_works" >&5 +$as_echo "$lt_cv_prog_compiler_pic_works" >&6; } + +if test x"$lt_cv_prog_compiler_pic_works" = xyes; then + case $lt_prog_compiler_pic in + "" | " "*) ;; + *) lt_prog_compiler_pic=" $lt_prog_compiler_pic" ;; + esac +else + lt_prog_compiler_pic= + lt_prog_compiler_can_build_shared=no +fi + +fi + + + + + + + + + + + +# +# Check to make sure the static flag actually works. +# +wl=$lt_prog_compiler_wl eval lt_tmp_static_flag=\"$lt_prog_compiler_static\" +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler static flag $lt_tmp_static_flag works" >&5 +$as_echo_n "checking if $compiler static flag $lt_tmp_static_flag works... " >&6; } +if ${lt_cv_prog_compiler_static_works+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_prog_compiler_static_works=no + save_LDFLAGS="$LDFLAGS" + LDFLAGS="$LDFLAGS $lt_tmp_static_flag" + echo "$lt_simple_link_test_code" > conftest.$ac_ext + if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then + # The linker can only warn and ignore the option if not recognized + # So say no if there are warnings + if test -s conftest.err; then + # Append any errors to the config.log. + cat conftest.err 1>&5 + $ECHO "$_lt_linker_boilerplate" | $SED '/^$/d' > conftest.exp + $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2 + if diff conftest.exp conftest.er2 >/dev/null; then + lt_cv_prog_compiler_static_works=yes + fi + else + lt_cv_prog_compiler_static_works=yes + fi + fi + $RM -r conftest* + LDFLAGS="$save_LDFLAGS" + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_static_works" >&5 +$as_echo "$lt_cv_prog_compiler_static_works" >&6; } + +if test x"$lt_cv_prog_compiler_static_works" = xyes; then + : +else + lt_prog_compiler_static= +fi + + + + + + + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -c -o file.$ac_objext" >&5 +$as_echo_n "checking if $compiler supports -c -o file.$ac_objext... " >&6; } +if ${lt_cv_prog_compiler_c_o+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_prog_compiler_c_o=no + $RM -r conftest 2>/dev/null + mkdir conftest + cd conftest + mkdir out + echo "$lt_simple_compile_test_code" > conftest.$ac_ext + + lt_compiler_flag="-o out/conftest2.$ac_objext" + # Insert the option either (1) after the last *FLAGS variable, or + # (2) before a word containing "conftest.", or (3) at the end. + # Note that $ac_compile itself does not contain backslashes and begins + # with a dollar sign (not a hyphen), so the echo should work correctly. + lt_compile=`echo "$ac_compile" | $SED \ + -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \ + -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \ + -e 's:$: $lt_compiler_flag:'` + (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&5) + (eval "$lt_compile" 2>out/conftest.err) + ac_status=$? + cat out/conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + if (exit $ac_status) && test -s out/conftest2.$ac_objext + then + # The compiler can only warn and ignore the option if not recognized + # So say no if there are warnings + $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' > out/conftest.exp + $SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2 + if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then + lt_cv_prog_compiler_c_o=yes + fi + fi + chmod u+w . 2>&5 + $RM conftest* + # SGI C++ compiler will create directory out/ii_files/ for + # template instantiation + test -d out/ii_files && $RM out/ii_files/* && rmdir out/ii_files + $RM out/* && rmdir out + cd .. + $RM -r conftest + $RM conftest* + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o" >&5 +$as_echo "$lt_cv_prog_compiler_c_o" >&6; } + + + + + + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -c -o file.$ac_objext" >&5 +$as_echo_n "checking if $compiler supports -c -o file.$ac_objext... " >&6; } +if ${lt_cv_prog_compiler_c_o+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_prog_compiler_c_o=no + $RM -r conftest 2>/dev/null + mkdir conftest + cd conftest + mkdir out + echo "$lt_simple_compile_test_code" > conftest.$ac_ext + + lt_compiler_flag="-o out/conftest2.$ac_objext" + # Insert the option either (1) after the last *FLAGS variable, or + # (2) before a word containing "conftest.", or (3) at the end. + # Note that $ac_compile itself does not contain backslashes and begins + # with a dollar sign (not a hyphen), so the echo should work correctly. + lt_compile=`echo "$ac_compile" | $SED \ + -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \ + -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \ + -e 's:$: $lt_compiler_flag:'` + (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&5) + (eval "$lt_compile" 2>out/conftest.err) + ac_status=$? + cat out/conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + if (exit $ac_status) && test -s out/conftest2.$ac_objext + then + # The compiler can only warn and ignore the option if not recognized + # So say no if there are warnings + $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' > out/conftest.exp + $SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2 + if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then + lt_cv_prog_compiler_c_o=yes + fi + fi + chmod u+w . 2>&5 + $RM conftest* + # SGI C++ compiler will create directory out/ii_files/ for + # template instantiation + test -d out/ii_files && $RM out/ii_files/* && rmdir out/ii_files + $RM out/* && rmdir out + cd .. + $RM -r conftest + $RM conftest* + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o" >&5 +$as_echo "$lt_cv_prog_compiler_c_o" >&6; } + + + + +hard_links="nottested" +if test "$lt_cv_prog_compiler_c_o" = no && test "$need_locks" != no; then + # do not overwrite the value of need_locks provided by the user + { $as_echo "$as_me:${as_lineno-$LINENO}: checking if we can lock with hard links" >&5 +$as_echo_n "checking if we can lock with hard links... " >&6; } + hard_links=yes + $RM conftest* + ln conftest.a conftest.b 2>/dev/null && hard_links=no + touch conftest.a + ln conftest.a conftest.b 2>&5 || hard_links=no + ln conftest.a conftest.b 2>/dev/null && hard_links=no + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $hard_links" >&5 +$as_echo "$hard_links" >&6; } + if test "$hard_links" = no; then + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&5 +$as_echo "$as_me: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&2;} + need_locks=warn + fi +else + need_locks=no +fi + + + + + + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the $compiler linker ($LD) supports shared libraries" >&5 +$as_echo_n "checking whether the $compiler linker ($LD) supports shared libraries... " >&6; } + + runpath_var= + allow_undefined_flag= + always_export_symbols=no + archive_cmds= + archive_expsym_cmds= + compiler_needs_object=no + enable_shared_with_static_runtimes=no + export_dynamic_flag_spec= + export_symbols_cmds='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols' + hardcode_automatic=no + hardcode_direct=no + hardcode_direct_absolute=no + hardcode_libdir_flag_spec= + hardcode_libdir_separator= + hardcode_minus_L=no + hardcode_shlibpath_var=unsupported + inherit_rpath=no + link_all_deplibs=unknown + module_cmds= + module_expsym_cmds= + old_archive_from_new_cmds= + old_archive_from_expsyms_cmds= + thread_safe_flag_spec= + whole_archive_flag_spec= + # include_expsyms should be a list of space-separated symbols to be *always* + # included in the symbol list + include_expsyms= + # exclude_expsyms can be an extended regexp of symbols to exclude + # it will be wrapped by ` (' and `)$', so one must not match beginning or + # end of line. Example: `a|bc|.*d.*' will exclude the symbols `a' and `bc', + # as well as any symbol that contains `d'. + exclude_expsyms='_GLOBAL_OFFSET_TABLE_|_GLOBAL__F[ID]_.*' + # Although _GLOBAL_OFFSET_TABLE_ is a valid symbol C name, most a.out + # platforms (ab)use it in PIC code, but their linkers get confused if + # the symbol is explicitly referenced. Since portable code cannot + # rely on this symbol name, it's probably fine to never include it in + # preloaded symbol tables. + # Exclude shared library initialization/finalization symbols. + extract_expsyms_cmds= + + case $host_os in + cygwin* | mingw* | pw32* | cegcc*) + # FIXME: the MSVC++ port hasn't been tested in a loooong time + # When not using gcc, we currently assume that we are using + # Microsoft Visual C++. + if test "$GCC" != yes; then + with_gnu_ld=no + fi + ;; + interix*) + # we just hope/assume this is gcc and not c89 (= MSVC++) + with_gnu_ld=yes + ;; + openbsd*) + with_gnu_ld=no + ;; + linux* | k*bsd*-gnu | gnu*) + link_all_deplibs=no + ;; + esac + + ld_shlibs=yes + + # On some targets, GNU ld is compatible enough with the native linker + # that we're better off using the native interface for both. + lt_use_gnu_ld_interface=no + if test "$with_gnu_ld" = yes; then + case $host_os in + aix*) + # The AIX port of GNU ld has always aspired to compatibility + # with the native linker. However, as the warning in the GNU ld + # block says, versions before 2.19.5* couldn't really create working + # shared libraries, regardless of the interface used. + case `$LD -v 2>&1` in + *\ \(GNU\ Binutils\)\ 2.19.5*) ;; + *\ \(GNU\ Binutils\)\ 2.[2-9]*) ;; + *\ \(GNU\ Binutils\)\ [3-9]*) ;; + *) + lt_use_gnu_ld_interface=yes + ;; + esac + ;; + *) + lt_use_gnu_ld_interface=yes + ;; + esac + fi + + if test "$lt_use_gnu_ld_interface" = yes; then + # If archive_cmds runs LD, not CC, wlarc should be empty + wlarc='${wl}' + + # Set some defaults for GNU ld with shared library support. These + # are reset later if shared libraries are not supported. Putting them + # here allows them to be overridden if necessary. + runpath_var=LD_RUN_PATH + hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir' + export_dynamic_flag_spec='${wl}--export-dynamic' + # ancient GNU ld didn't support --whole-archive et. al. + if $LD --help 2>&1 | $GREP 'no-whole-archive' > /dev/null; then + whole_archive_flag_spec="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive' + else + whole_archive_flag_spec= + fi + supports_anon_versioning=no + case `$LD -v 2>&1` in + *GNU\ gold*) supports_anon_versioning=yes ;; + *\ [01].* | *\ 2.[0-9].* | *\ 2.10.*) ;; # catch versions < 2.11 + *\ 2.11.93.0.2\ *) supports_anon_versioning=yes ;; # RH7.3 ... + *\ 2.11.92.0.12\ *) supports_anon_versioning=yes ;; # Mandrake 8.2 ... + *\ 2.11.*) ;; # other 2.11 versions + *) supports_anon_versioning=yes ;; + esac + + # See if GNU ld supports shared libraries. + case $host_os in + aix[3-9]*) + # On AIX/PPC, the GNU linker is very broken + if test "$host_cpu" != ia64; then + ld_shlibs=no + cat <<_LT_EOF 1>&2 + +*** Warning: the GNU linker, at least up to release 2.19, is reported +*** to be unable to reliably create shared libraries on AIX. +*** Therefore, libtool is disabling shared libraries support. If you +*** really care for shared libraries, you may want to install binutils +*** 2.20 or above, or modify your PATH so that a non-GNU linker is found. +*** You will then need to restart the configuration process. + +_LT_EOF + fi + ;; + + amigaos*) + case $host_cpu in + powerpc) + # see comment about AmigaOS4 .so support + archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + archive_expsym_cmds='' + ;; + m68k) + archive_cmds='$RM $output_objdir/a2ixlibrary.data~$ECHO "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$ECHO "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$ECHO "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$ECHO "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)' + hardcode_libdir_flag_spec='-L$libdir' + hardcode_minus_L=yes + ;; + esac + ;; + + beos*) + if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then + allow_undefined_flag=unsupported + # Joseph Beckenbach says some releases of gcc + # support --undefined. This deserves some investigation. FIXME + archive_cmds='$CC -nostart $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + else + ld_shlibs=no + fi + ;; + + cygwin* | mingw* | pw32* | cegcc*) + # _LT_TAGVAR(hardcode_libdir_flag_spec, ) is actually meaningless, + # as there is no search path for DLLs. + hardcode_libdir_flag_spec='-L$libdir' + export_dynamic_flag_spec='${wl}--export-all-symbols' + allow_undefined_flag=unsupported + always_export_symbols=no + enable_shared_with_static_runtimes=yes + export_symbols_cmds='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[BCDGRS][ ]/s/.*[ ]\([^ ]*\)/\1 DATA/;s/^.*[ ]__nm__\([^ ]*\)[ ][^ ]*/\1 DATA/;/^I[ ]/d;/^[AITW][ ]/s/.* //'\'' | sort | uniq > $export_symbols' + exclude_expsyms='[_]+GLOBAL_OFFSET_TABLE_|[_]+GLOBAL__[FID]_.*|[_]+head_[A-Za-z0-9_]+_dll|[A-Za-z0-9_]+_dll_iname' + + if $LD --help 2>&1 | $GREP 'auto-import' > /dev/null; then + archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib' + # If the export-symbols file already is a .def file (1st line + # is EXPORTS), use it as is; otherwise, prepend... + archive_expsym_cmds='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then + cp $export_symbols $output_objdir/$soname.def; + else + echo EXPORTS > $output_objdir/$soname.def; + cat $export_symbols >> $output_objdir/$soname.def; + fi~ + $CC -shared $output_objdir/$soname.def $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib' + else + ld_shlibs=no + fi + ;; + + haiku*) + archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + link_all_deplibs=yes + ;; + + interix[3-9]*) + hardcode_direct=no + hardcode_shlibpath_var=no + hardcode_libdir_flag_spec='${wl}-rpath,$libdir' + export_dynamic_flag_spec='${wl}-E' + # Hack: On Interix 3.x, we cannot compile PIC because of a broken gcc. + # Instead, shared libraries are loaded at an image base (0x10000000 by + # default) and relocated if they conflict, which is a slow very memory + # consuming and fragmenting process. To avoid this, we pick a random, + # 256 KiB-aligned image base between 0x50000000 and 0x6FFC0000 at link + # time. Moving up from 0x10000000 also allows more sbrk(2) space. + archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib' + archive_expsym_cmds='sed "s,^,_," $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--retain-symbols-file,$output_objdir/$soname.expsym ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib' + ;; + + gnu* | linux* | tpf* | k*bsd*-gnu | kopensolaris*-gnu) + tmp_diet=no + if test "$host_os" = linux-dietlibc; then + case $cc_basename in + diet\ *) tmp_diet=yes;; # linux-dietlibc with static linking (!diet-dyn) + esac + fi + if $LD --help 2>&1 | $EGREP ': supported targets:.* elf' > /dev/null \ + && test "$tmp_diet" = no + then + tmp_addflag=' $pic_flag' + tmp_sharedflag='-shared' + case $cc_basename,$host_cpu in + pgcc*) # Portland Group C compiler + whole_archive_flag_spec='${wl}--whole-archive`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive' + tmp_addflag=' $pic_flag' + ;; + pgf77* | pgf90* | pgf95* | pgfortran*) + # Portland Group f77 and f90 compilers + whole_archive_flag_spec='${wl}--whole-archive`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive' + tmp_addflag=' $pic_flag -Mnomain' ;; + ecc*,ia64* | icc*,ia64*) # Intel C compiler on ia64 + tmp_addflag=' -i_dynamic' ;; + efc*,ia64* | ifort*,ia64*) # Intel Fortran compiler on ia64 + tmp_addflag=' -i_dynamic -nofor_main' ;; + ifc* | ifort*) # Intel Fortran compiler + tmp_addflag=' -nofor_main' ;; + lf95*) # Lahey Fortran 8.1 + whole_archive_flag_spec= + tmp_sharedflag='--shared' ;; + xl[cC]* | bgxl[cC]* | mpixl[cC]*) # IBM XL C 8.0 on PPC (deal with xlf below) + tmp_sharedflag='-qmkshrobj' + tmp_addflag= ;; + nvcc*) # Cuda Compiler Driver 2.2 + whole_archive_flag_spec='${wl}--whole-archive`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive' + compiler_needs_object=yes + ;; + esac + case `$CC -V 2>&1 | sed 5q` in + *Sun\ C*) # Sun C 5.9 + whole_archive_flag_spec='${wl}--whole-archive`new_convenience=; for conv in $convenience\"\"; do test -z \"$conv\" || new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive' + compiler_needs_object=yes + tmp_sharedflag='-G' ;; + *Sun\ F*) # Sun Fortran 8.3 + tmp_sharedflag='-G' ;; + esac + archive_cmds='$CC '"$tmp_sharedflag""$tmp_addflag"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + + if test "x$supports_anon_versioning" = xyes; then + archive_expsym_cmds='echo "{ global:" > $output_objdir/$libname.ver~ + cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~ + echo "local: *; };" >> $output_objdir/$libname.ver~ + $CC '"$tmp_sharedflag""$tmp_addflag"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-version-script ${wl}$output_objdir/$libname.ver -o $lib' + fi + + case $cc_basename in + xlf* | bgf* | bgxlf* | mpixlf*) + # IBM XL Fortran 10.1 on PPC cannot create shared libs itself + whole_archive_flag_spec='--whole-archive$convenience --no-whole-archive' + hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir' + archive_cmds='$LD -shared $libobjs $deplibs $linker_flags -soname $soname -o $lib' + if test "x$supports_anon_versioning" = xyes; then + archive_expsym_cmds='echo "{ global:" > $output_objdir/$libname.ver~ + cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~ + echo "local: *; };" >> $output_objdir/$libname.ver~ + $LD -shared $libobjs $deplibs $linker_flags -soname $soname -version-script $output_objdir/$libname.ver -o $lib' + fi + ;; + esac + else + ld_shlibs=no + fi + ;; + + netbsd* | netbsdelf*-gnu) + if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then + archive_cmds='$LD -Bshareable $libobjs $deplibs $linker_flags -o $lib' + wlarc= + else + archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + archive_expsym_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + fi + ;; + + solaris*) + if $LD -v 2>&1 | $GREP 'BFD 2\.8' > /dev/null; then + ld_shlibs=no + cat <<_LT_EOF 1>&2 + +*** Warning: The releases 2.8.* of the GNU linker cannot reliably +*** create shared libraries on Solaris systems. Therefore, libtool +*** is disabling shared libraries support. We urge you to upgrade GNU +*** binutils to release 2.9.1 or newer. Another option is to modify +*** your PATH or compiler configuration so that the native linker is +*** used, and then restart. + +_LT_EOF + elif $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then + archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + archive_expsym_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + else + ld_shlibs=no + fi + ;; + + sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX*) + case `$LD -v 2>&1` in + *\ [01].* | *\ 2.[0-9].* | *\ 2.1[0-5].*) + ld_shlibs=no + cat <<_LT_EOF 1>&2 + +*** Warning: Releases of the GNU linker prior to 2.16.91.0.3 can not +*** reliably create shared libraries on SCO systems. Therefore, libtool +*** is disabling shared libraries support. We urge you to upgrade GNU +*** binutils to release 2.16.91.0.3 or newer. Another option is to modify +*** your PATH or compiler configuration so that the native linker is +*** used, and then restart. + +_LT_EOF + ;; + *) + # For security reasons, it is highly recommended that you always + # use absolute paths for naming shared libraries, and exclude the + # DT_RUNPATH tag from executables and libraries. But doing so + # requires that you compile everything twice, which is a pain. + if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then + hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir' + archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + archive_expsym_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + else + ld_shlibs=no + fi + ;; + esac + ;; + + sunos4*) + archive_cmds='$LD -assert pure-text -Bshareable -o $lib $libobjs $deplibs $linker_flags' + wlarc= + hardcode_direct=yes + hardcode_shlibpath_var=no + ;; + + *) + if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then + archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + archive_expsym_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + else + ld_shlibs=no + fi + ;; + esac + + if test "$ld_shlibs" = no; then + runpath_var= + hardcode_libdir_flag_spec= + export_dynamic_flag_spec= + whole_archive_flag_spec= + fi + else + # PORTME fill in a description of your system's linker (not GNU ld) + case $host_os in + aix3*) + allow_undefined_flag=unsupported + always_export_symbols=yes + archive_expsym_cmds='$LD -o $output_objdir/$soname $libobjs $deplibs $linker_flags -bE:$export_symbols -T512 -H512 -bM:SRE~$AR $AR_FLAGS $lib $output_objdir/$soname' + # Note: this linker hardcodes the directories in LIBPATH if there + # are no directories specified by -L. + hardcode_minus_L=yes + if test "$GCC" = yes && test -z "$lt_prog_compiler_static"; then + # Neither direct hardcoding nor static linking is supported with a + # broken collect2. + hardcode_direct=unsupported + fi + ;; + + aix[4-9]*) + if test "$host_cpu" = ia64; then + # On IA64, the linker does run time linking by default, so we don't + # have to do anything special. + aix_use_runtimelinking=no + exp_sym_flag='-Bexport' + no_entry_flag="" + else + # If we're using GNU nm, then we don't want the "-C" option. + # -C means demangle to AIX nm, but means don't demangle with GNU nm + # Also, AIX nm treats weak defined symbols like other global + # defined symbols, whereas GNU nm marks them as "W". + if $NM -V 2>&1 | $GREP 'GNU' > /dev/null; then + export_symbols_cmds='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W")) && (substr(\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols' + else + export_symbols_cmds='$NM -BCpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B")) && (substr(\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols' + fi + aix_use_runtimelinking=no + + # Test if we are trying to use run time linking or normal + # AIX style linking. If -brtl is somewhere in LDFLAGS, we + # need to do runtime linking. + case $host_os in aix4.[23]|aix4.[23].*|aix[5-9]*) + for ld_flag in $LDFLAGS; do + if (test $ld_flag = "-brtl" || test $ld_flag = "-Wl,-brtl"); then + aix_use_runtimelinking=yes + break + fi + done + ;; + esac + + exp_sym_flag='-bexport' + no_entry_flag='-bnoentry' + fi + + # When large executables or shared objects are built, AIX ld can + # have problems creating the table of contents. If linking a library + # or program results in "error TOC overflow" add -mminimal-toc to + # CXXFLAGS/CFLAGS for g++/gcc. In the cases where that is not + # enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS. + + archive_cmds='' + hardcode_direct=yes + hardcode_direct_absolute=yes + hardcode_libdir_separator=':' + link_all_deplibs=yes + file_list_spec='${wl}-f,' + + if test "$GCC" = yes; then + case $host_os in aix4.[012]|aix4.[012].*) + # We only want to do this on AIX 4.2 and lower, the check + # below for broken collect2 doesn't work under 4.3+ + collect2name=`${CC} -print-prog-name=collect2` + if test -f "$collect2name" && + strings "$collect2name" | $GREP resolve_lib_name >/dev/null + then + # We have reworked collect2 + : + else + # We have old collect2 + hardcode_direct=unsupported + # It fails to find uninstalled libraries when the uninstalled + # path is not listed in the libpath. Setting hardcode_minus_L + # to unsupported forces relinking + hardcode_minus_L=yes + hardcode_libdir_flag_spec='-L$libdir' + hardcode_libdir_separator= + fi + ;; + esac + shared_flag='-shared' + if test "$aix_use_runtimelinking" = yes; then + shared_flag="$shared_flag "'${wl}-G' + fi + link_all_deplibs=no + else + # not using gcc + if test "$host_cpu" = ia64; then + # VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release + # chokes on -Wl,-G. The following line is correct: + shared_flag='-G' + else + if test "$aix_use_runtimelinking" = yes; then + shared_flag='${wl}-G' + else + shared_flag='${wl}-bM:SRE' + fi + fi + fi + + export_dynamic_flag_spec='${wl}-bexpall' + # It seems that -bexpall does not export symbols beginning with + # underscore (_), so it is better to generate a list of symbols to export. + always_export_symbols=yes + if test "$aix_use_runtimelinking" = yes; then + # Warning - without using the other runtime loading flags (-brtl), + # -berok will link without error, but may produce a broken library. + allow_undefined_flag='-berok' + # Determine the default libpath from the value encoded in an + # empty executable. + if test "${lt_cv_aix_libpath+set}" = set; then + aix_libpath=$lt_cv_aix_libpath +else + if ${lt_cv_aix_libpath_+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + + lt_aix_libpath_sed=' + /Import File Strings/,/^$/ { + /^0/ { + s/^0 *\([^ ]*\) *$/\1/ + p + } + }' + lt_cv_aix_libpath_=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"` + # Check for a 64-bit object if we didn't find anything. + if test -z "$lt_cv_aix_libpath_"; then + lt_cv_aix_libpath_=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"` + fi +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext + if test -z "$lt_cv_aix_libpath_"; then + lt_cv_aix_libpath_="/usr/lib:/lib" + fi + +fi + + aix_libpath=$lt_cv_aix_libpath_ +fi + + hardcode_libdir_flag_spec='${wl}-blibpath:$libdir:'"$aix_libpath" + archive_expsym_cmds='$CC -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then func_echo_all "${wl}${allow_undefined_flag}"; else :; fi` '"\${wl}$exp_sym_flag:\$export_symbols $shared_flag" + else + if test "$host_cpu" = ia64; then + hardcode_libdir_flag_spec='${wl}-R $libdir:/usr/lib:/lib' + allow_undefined_flag="-z nodefs" + archive_expsym_cmds="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$exp_sym_flag:\$export_symbols" + else + # Determine the default libpath from the value encoded in an + # empty executable. + if test "${lt_cv_aix_libpath+set}" = set; then + aix_libpath=$lt_cv_aix_libpath +else + if ${lt_cv_aix_libpath_+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + + lt_aix_libpath_sed=' + /Import File Strings/,/^$/ { + /^0/ { + s/^0 *\([^ ]*\) *$/\1/ + p + } + }' + lt_cv_aix_libpath_=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"` + # Check for a 64-bit object if we didn't find anything. + if test -z "$lt_cv_aix_libpath_"; then + lt_cv_aix_libpath_=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"` + fi +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext + if test -z "$lt_cv_aix_libpath_"; then + lt_cv_aix_libpath_="/usr/lib:/lib" + fi + +fi + + aix_libpath=$lt_cv_aix_libpath_ +fi + + hardcode_libdir_flag_spec='${wl}-blibpath:$libdir:'"$aix_libpath" + # Warning - without using the other run time loading flags, + # -berok will link without error, but may produce a broken library. + no_undefined_flag=' ${wl}-bernotok' + allow_undefined_flag=' ${wl}-berok' + if test "$with_gnu_ld" = yes; then + # We only use this code for GNU lds that support --whole-archive. + whole_archive_flag_spec='${wl}--whole-archive$convenience ${wl}--no-whole-archive' + else + # Exported symbols can be pulled into shared objects from archives + whole_archive_flag_spec='$convenience' + fi + archive_cmds_need_lc=yes + # This is similar to how AIX traditionally builds its shared libraries. + archive_expsym_cmds="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs ${wl}-bnoentry $compiler_flags ${wl}-bE:$export_symbols${allow_undefined_flag}~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$soname' + fi + fi + ;; + + amigaos*) + case $host_cpu in + powerpc) + # see comment about AmigaOS4 .so support + archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + archive_expsym_cmds='' + ;; + m68k) + archive_cmds='$RM $output_objdir/a2ixlibrary.data~$ECHO "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$ECHO "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$ECHO "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$ECHO "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)' + hardcode_libdir_flag_spec='-L$libdir' + hardcode_minus_L=yes + ;; + esac + ;; + + bsdi[45]*) + export_dynamic_flag_spec=-rdynamic + ;; + + cygwin* | mingw* | pw32* | cegcc*) + # When not using gcc, we currently assume that we are using + # Microsoft Visual C++. + # hardcode_libdir_flag_spec is actually meaningless, as there is + # no search path for DLLs. + case $cc_basename in + cl*) + # Native MSVC + hardcode_libdir_flag_spec=' ' + allow_undefined_flag=unsupported + always_export_symbols=yes + file_list_spec='@' + # Tell ltmain to make .lib files, not .a files. + libext=lib + # Tell ltmain to make .dll files, not .so files. + shrext_cmds=".dll" + # FIXME: Setting linknames here is a bad hack. + archive_cmds='$CC -o $output_objdir/$soname $libobjs $compiler_flags $deplibs -Wl,-dll~linknames=' + archive_expsym_cmds='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then + sed -n -e 's/\\\\\\\(.*\\\\\\\)/-link\\\ -EXPORT:\\\\\\\1/' -e '1\\\!p' < $export_symbols > $output_objdir/$soname.exp; + else + sed -e 's/\\\\\\\(.*\\\\\\\)/-link\\\ -EXPORT:\\\\\\\1/' < $export_symbols > $output_objdir/$soname.exp; + fi~ + $CC -o $tool_output_objdir$soname $libobjs $compiler_flags $deplibs "@$tool_output_objdir$soname.exp" -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~ + linknames=' + # The linker will not automatically build a static lib if we build a DLL. + # _LT_TAGVAR(old_archive_from_new_cmds, )='true' + enable_shared_with_static_runtimes=yes + exclude_expsyms='_NULL_IMPORT_DESCRIPTOR|_IMPORT_DESCRIPTOR_.*' + export_symbols_cmds='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[BCDGRS][ ]/s/.*[ ]\([^ ]*\)/\1,DATA/'\'' | $SED -e '\''/^[AITW][ ]/s/.*[ ]//'\'' | sort | uniq > $export_symbols' + # Don't use ranlib + old_postinstall_cmds='chmod 644 $oldlib' + postlink_cmds='lt_outputfile="@OUTPUT@"~ + lt_tool_outputfile="@TOOL_OUTPUT@"~ + case $lt_outputfile in + *.exe|*.EXE) ;; + *) + lt_outputfile="$lt_outputfile.exe" + lt_tool_outputfile="$lt_tool_outputfile.exe" + ;; + esac~ + if test "$MANIFEST_TOOL" != ":" && test -f "$lt_outputfile.manifest"; then + $MANIFEST_TOOL -manifest "$lt_tool_outputfile.manifest" -outputresource:"$lt_tool_outputfile" || exit 1; + $RM "$lt_outputfile.manifest"; + fi' + ;; + *) + # Assume MSVC wrapper + hardcode_libdir_flag_spec=' ' + allow_undefined_flag=unsupported + # Tell ltmain to make .lib files, not .a files. + libext=lib + # Tell ltmain to make .dll files, not .so files. + shrext_cmds=".dll" + # FIXME: Setting linknames here is a bad hack. + archive_cmds='$CC -o $lib $libobjs $compiler_flags `func_echo_all "$deplibs" | $SED '\''s/ -lc$//'\''` -link -dll~linknames=' + # The linker will automatically build a .lib file if we build a DLL. + old_archive_from_new_cmds='true' + # FIXME: Should let the user specify the lib program. + old_archive_cmds='lib -OUT:$oldlib$oldobjs$old_deplibs' + enable_shared_with_static_runtimes=yes + ;; + esac + ;; + + darwin* | rhapsody*) + + + archive_cmds_need_lc=no + hardcode_direct=no + hardcode_automatic=yes + hardcode_shlibpath_var=unsupported + if test "$lt_cv_ld_force_load" = "yes"; then + whole_archive_flag_spec='`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience ${wl}-force_load,$conv\"; done; func_echo_all \"$new_convenience\"`' + + else + whole_archive_flag_spec='' + fi + link_all_deplibs=yes + allow_undefined_flag="$_lt_dar_allow_undefined" + case $cc_basename in + ifort*) _lt_dar_can_shared=yes ;; + *) _lt_dar_can_shared=$GCC ;; + esac + if test "$_lt_dar_can_shared" = "yes"; then + output_verbose_link_cmd=func_echo_all + archive_cmds="\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring $_lt_dar_single_mod${_lt_dsymutil}" + module_cmds="\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags${_lt_dsymutil}" + archive_expsym_cmds="sed 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring ${_lt_dar_single_mod}${_lt_dar_export_syms}${_lt_dsymutil}" + module_expsym_cmds="sed -e 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags${_lt_dar_export_syms}${_lt_dsymutil}" + + else + ld_shlibs=no + fi + + ;; + + dgux*) + archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + hardcode_libdir_flag_spec='-L$libdir' + hardcode_shlibpath_var=no + ;; + + # FreeBSD 2.2.[012] allows us to include c++rt0.o to get C++ constructor + # support. Future versions do this automatically, but an explicit c++rt0.o + # does not break anything, and helps significantly (at the cost of a little + # extra space). + freebsd2.2*) + archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags /usr/lib/c++rt0.o' + hardcode_libdir_flag_spec='-R$libdir' + hardcode_direct=yes + hardcode_shlibpath_var=no + ;; + + # Unfortunately, older versions of FreeBSD 2 do not have this feature. + freebsd2.*) + archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags' + hardcode_direct=yes + hardcode_minus_L=yes + hardcode_shlibpath_var=no + ;; + + # FreeBSD 3 and greater uses gcc -shared to do shared libraries. + freebsd* | dragonfly*) + archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags' + hardcode_libdir_flag_spec='-R$libdir' + hardcode_direct=yes + hardcode_shlibpath_var=no + ;; + + hpux9*) + if test "$GCC" = yes; then + archive_cmds='$RM $output_objdir/$soname~$CC -shared $pic_flag ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $libobjs $deplibs $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib' + else + archive_cmds='$RM $output_objdir/$soname~$LD -b +b $install_libdir -o $output_objdir/$soname $libobjs $deplibs $linker_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib' + fi + hardcode_libdir_flag_spec='${wl}+b ${wl}$libdir' + hardcode_libdir_separator=: + hardcode_direct=yes + + # hardcode_minus_L: Not really in the search PATH, + # but as the default location of the library. + hardcode_minus_L=yes + export_dynamic_flag_spec='${wl}-E' + ;; + + hpux10*) + if test "$GCC" = yes && test "$with_gnu_ld" = no; then + archive_cmds='$CC -shared $pic_flag ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags' + else + archive_cmds='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags' + fi + if test "$with_gnu_ld" = no; then + hardcode_libdir_flag_spec='${wl}+b ${wl}$libdir' + hardcode_libdir_separator=: + hardcode_direct=yes + hardcode_direct_absolute=yes + export_dynamic_flag_spec='${wl}-E' + # hardcode_minus_L: Not really in the search PATH, + # but as the default location of the library. + hardcode_minus_L=yes + fi + ;; + + hpux11*) + if test "$GCC" = yes && test "$with_gnu_ld" = no; then + case $host_cpu in + hppa*64*) + archive_cmds='$CC -shared ${wl}+h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags' + ;; + ia64*) + archive_cmds='$CC -shared $pic_flag ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags' + ;; + *) + archive_cmds='$CC -shared $pic_flag ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags' + ;; + esac + else + case $host_cpu in + hppa*64*) + archive_cmds='$CC -b ${wl}+h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags' + ;; + ia64*) + archive_cmds='$CC -b ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags' + ;; + *) + + # Older versions of the 11.00 compiler do not understand -b yet + # (HP92453-01 A.11.01.20 doesn't, HP92453-01 B.11.X.35175-35176.GP does) + { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC understands -b" >&5 +$as_echo_n "checking if $CC understands -b... " >&6; } +if ${lt_cv_prog_compiler__b+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_prog_compiler__b=no + save_LDFLAGS="$LDFLAGS" + LDFLAGS="$LDFLAGS -b" + echo "$lt_simple_link_test_code" > conftest.$ac_ext + if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then + # The linker can only warn and ignore the option if not recognized + # So say no if there are warnings + if test -s conftest.err; then + # Append any errors to the config.log. + cat conftest.err 1>&5 + $ECHO "$_lt_linker_boilerplate" | $SED '/^$/d' > conftest.exp + $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2 + if diff conftest.exp conftest.er2 >/dev/null; then + lt_cv_prog_compiler__b=yes + fi + else + lt_cv_prog_compiler__b=yes + fi + fi + $RM -r conftest* + LDFLAGS="$save_LDFLAGS" + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler__b" >&5 +$as_echo "$lt_cv_prog_compiler__b" >&6; } + +if test x"$lt_cv_prog_compiler__b" = xyes; then + archive_cmds='$CC -b ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags' +else + archive_cmds='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags' +fi + + ;; + esac + fi + if test "$with_gnu_ld" = no; then + hardcode_libdir_flag_spec='${wl}+b ${wl}$libdir' + hardcode_libdir_separator=: + + case $host_cpu in + hppa*64*|ia64*) + hardcode_direct=no + hardcode_shlibpath_var=no + ;; + *) + hardcode_direct=yes + hardcode_direct_absolute=yes + export_dynamic_flag_spec='${wl}-E' + + # hardcode_minus_L: Not really in the search PATH, + # but as the default location of the library. + hardcode_minus_L=yes + ;; + esac + fi + ;; + + irix5* | irix6* | nonstopux*) + if test "$GCC" = yes; then + archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' + # Try to use the -exported_symbol ld option, if it does not + # work, assume that -exports_file does not work either and + # implicitly export all symbols. + # This should be the same for all languages, so no per-tag cache variable. + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the $host_os linker accepts -exported_symbol" >&5 +$as_echo_n "checking whether the $host_os linker accepts -exported_symbol... " >&6; } +if ${lt_cv_irix_exported_symbol+:} false; then : + $as_echo_n "(cached) " >&6 +else + save_LDFLAGS="$LDFLAGS" + LDFLAGS="$LDFLAGS -shared ${wl}-exported_symbol ${wl}foo ${wl}-update_registry ${wl}/dev/null" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +int foo (void) { return 0; } +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + lt_cv_irix_exported_symbol=yes +else + lt_cv_irix_exported_symbol=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext + LDFLAGS="$save_LDFLAGS" +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_irix_exported_symbol" >&5 +$as_echo "$lt_cv_irix_exported_symbol" >&6; } + if test "$lt_cv_irix_exported_symbol" = yes; then + archive_expsym_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations ${wl}-exports_file ${wl}$export_symbols -o $lib' + fi + else + archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib' + archive_expsym_cmds='$CC -shared $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -exports_file $export_symbols -o $lib' + fi + archive_cmds_need_lc='no' + hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir' + hardcode_libdir_separator=: + inherit_rpath=yes + link_all_deplibs=yes + ;; + + netbsd* | netbsdelf*-gnu) + if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then + archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags' # a.out + else + archive_cmds='$LD -shared -o $lib $libobjs $deplibs $linker_flags' # ELF + fi + hardcode_libdir_flag_spec='-R$libdir' + hardcode_direct=yes + hardcode_shlibpath_var=no + ;; + + newsos6) + archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + hardcode_direct=yes + hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir' + hardcode_libdir_separator=: + hardcode_shlibpath_var=no + ;; + + *nto* | *qnx*) + ;; + + openbsd*) + if test -f /usr/libexec/ld.so; then + hardcode_direct=yes + hardcode_shlibpath_var=no + hardcode_direct_absolute=yes + if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then + archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags' + archive_expsym_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags ${wl}-retain-symbols-file,$export_symbols' + hardcode_libdir_flag_spec='${wl}-rpath,$libdir' + export_dynamic_flag_spec='${wl}-E' + else + case $host_os in + openbsd[01].* | openbsd2.[0-7] | openbsd2.[0-7].*) + archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags' + hardcode_libdir_flag_spec='-R$libdir' + ;; + *) + archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags' + hardcode_libdir_flag_spec='${wl}-rpath,$libdir' + ;; + esac + fi + else + ld_shlibs=no + fi + ;; + + os2*) + hardcode_libdir_flag_spec='-L$libdir' + hardcode_minus_L=yes + allow_undefined_flag=unsupported + archive_cmds='$ECHO "LIBRARY $libname INITINSTANCE" > $output_objdir/$libname.def~$ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~echo DATA >> $output_objdir/$libname.def~echo " SINGLE NONSHARED" >> $output_objdir/$libname.def~echo EXPORTS >> $output_objdir/$libname.def~emxexp $libobjs >> $output_objdir/$libname.def~$CC -Zdll -Zcrtdll -o $lib $libobjs $deplibs $compiler_flags $output_objdir/$libname.def' + old_archive_from_new_cmds='emximp -o $output_objdir/$libname.a $output_objdir/$libname.def' + ;; + + osf3*) + if test "$GCC" = yes; then + allow_undefined_flag=' ${wl}-expect_unresolved ${wl}\*' + archive_cmds='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' + else + allow_undefined_flag=' -expect_unresolved \*' + archive_cmds='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib' + fi + archive_cmds_need_lc='no' + hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir' + hardcode_libdir_separator=: + ;; + + osf4* | osf5*) # as osf3* with the addition of -msym flag + if test "$GCC" = yes; then + allow_undefined_flag=' ${wl}-expect_unresolved ${wl}\*' + archive_cmds='$CC -shared${allow_undefined_flag} $pic_flag $libobjs $deplibs $compiler_flags ${wl}-msym ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' + hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir' + else + allow_undefined_flag=' -expect_unresolved \*' + archive_cmds='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags -msym -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib' + archive_expsym_cmds='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done; printf "%s\\n" "-hidden">> $lib.exp~ + $CC -shared${allow_undefined_flag} ${wl}-input ${wl}$lib.exp $compiler_flags $libobjs $deplibs -soname $soname `test -n "$verstring" && $ECHO "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib~$RM $lib.exp' + + # Both c and cxx compiler support -rpath directly + hardcode_libdir_flag_spec='-rpath $libdir' + fi + archive_cmds_need_lc='no' + hardcode_libdir_separator=: + ;; + + solaris*) + no_undefined_flag=' -z defs' + if test "$GCC" = yes; then + wlarc='${wl}' + archive_cmds='$CC -shared $pic_flag ${wl}-z ${wl}text ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags' + archive_expsym_cmds='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~ + $CC -shared $pic_flag ${wl}-z ${wl}text ${wl}-M ${wl}$lib.exp ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags~$RM $lib.exp' + else + case `$CC -V 2>&1` in + *"Compilers 5.0"*) + wlarc='' + archive_cmds='$LD -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $linker_flags' + archive_expsym_cmds='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~ + $LD -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $linker_flags~$RM $lib.exp' + ;; + *) + wlarc='${wl}' + archive_cmds='$CC -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $compiler_flags' + archive_expsym_cmds='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~ + $CC -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $compiler_flags~$RM $lib.exp' + ;; + esac + fi + hardcode_libdir_flag_spec='-R$libdir' + hardcode_shlibpath_var=no + case $host_os in + solaris2.[0-5] | solaris2.[0-5].*) ;; + *) + # The compiler driver will combine and reorder linker options, + # but understands `-z linker_flag'. GCC discards it without `$wl', + # but is careful enough not to reorder. + # Supported since Solaris 2.6 (maybe 2.5.1?) + if test "$GCC" = yes; then + whole_archive_flag_spec='${wl}-z ${wl}allextract$convenience ${wl}-z ${wl}defaultextract' + else + whole_archive_flag_spec='-z allextract$convenience -z defaultextract' + fi + ;; + esac + link_all_deplibs=yes + ;; + + sunos4*) + if test "x$host_vendor" = xsequent; then + # Use $CC to link under sequent, because it throws in some extra .o + # files that make .init and .fini sections work. + archive_cmds='$CC -G ${wl}-h $soname -o $lib $libobjs $deplibs $compiler_flags' + else + archive_cmds='$LD -assert pure-text -Bstatic -o $lib $libobjs $deplibs $linker_flags' + fi + hardcode_libdir_flag_spec='-L$libdir' + hardcode_direct=yes + hardcode_minus_L=yes + hardcode_shlibpath_var=no + ;; + + sysv4) + case $host_vendor in + sni) + archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + hardcode_direct=yes # is this really true??? + ;; + siemens) + ## LD is ld it makes a PLAMLIB + ## CC just makes a GrossModule. + archive_cmds='$LD -G -o $lib $libobjs $deplibs $linker_flags' + reload_cmds='$CC -r -o $output$reload_objs' + hardcode_direct=no + ;; + motorola) + archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + hardcode_direct=no #Motorola manual says yes, but my tests say they lie + ;; + esac + runpath_var='LD_RUN_PATH' + hardcode_shlibpath_var=no + ;; + + sysv4.3*) + archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + hardcode_shlibpath_var=no + export_dynamic_flag_spec='-Bexport' + ;; + + sysv4*MP*) + if test -d /usr/nec; then + archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + hardcode_shlibpath_var=no + runpath_var=LD_RUN_PATH + hardcode_runpath_var=yes + ld_shlibs=yes + fi + ;; + + sysv4*uw2* | sysv5OpenUNIX* | sysv5UnixWare7.[01].[10]* | unixware7* | sco3.2v5.0.[024]*) + no_undefined_flag='${wl}-z,text' + archive_cmds_need_lc=no + hardcode_shlibpath_var=no + runpath_var='LD_RUN_PATH' + + if test "$GCC" = yes; then + archive_cmds='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + archive_expsym_cmds='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + else + archive_cmds='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + archive_expsym_cmds='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + fi + ;; + + sysv5* | sco3.2v5* | sco5v6*) + # Note: We can NOT use -z defs as we might desire, because we do not + # link with -lc, and that would cause any symbols used from libc to + # always be unresolved, which means just about no library would + # ever link correctly. If we're not using GNU ld we use -z text + # though, which does catch some bad symbols but isn't as heavy-handed + # as -z defs. + no_undefined_flag='${wl}-z,text' + allow_undefined_flag='${wl}-z,nodefs' + archive_cmds_need_lc=no + hardcode_shlibpath_var=no + hardcode_libdir_flag_spec='${wl}-R,$libdir' + hardcode_libdir_separator=':' + link_all_deplibs=yes + export_dynamic_flag_spec='${wl}-Bexport' + runpath_var='LD_RUN_PATH' + + if test "$GCC" = yes; then + archive_cmds='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + archive_expsym_cmds='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + else + archive_cmds='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + archive_expsym_cmds='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + fi + ;; + + uts4*) + archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + hardcode_libdir_flag_spec='-L$libdir' + hardcode_shlibpath_var=no + ;; + + *) + ld_shlibs=no + ;; + esac + + if test x$host_vendor = xsni; then + case $host in + sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*) + export_dynamic_flag_spec='${wl}-Blargedynsym' + ;; + esac + fi + fi + +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ld_shlibs" >&5 +$as_echo "$ld_shlibs" >&6; } +test "$ld_shlibs" = no && can_build_shared=no + +with_gnu_ld=$with_gnu_ld + + + + + + + + + + + + + + + +# +# Do we need to explicitly link libc? +# +case "x$archive_cmds_need_lc" in +x|xyes) + # Assume -lc should be added + archive_cmds_need_lc=yes + + if test "$enable_shared" = yes && test "$GCC" = yes; then + case $archive_cmds in + *'~'*) + # FIXME: we may have to deal with multi-command sequences. + ;; + '$CC '*) + # Test whether the compiler implicitly links with -lc since on some + # systems, -lgcc has to come before -lc. If gcc already passes -lc + # to ld, don't add -lc before -lgcc. + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether -lc should be explicitly linked in" >&5 +$as_echo_n "checking whether -lc should be explicitly linked in... " >&6; } +if ${lt_cv_archive_cmds_need_lc+:} false; then : + $as_echo_n "(cached) " >&6 +else + $RM conftest* + echo "$lt_simple_compile_test_code" > conftest.$ac_ext + + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 + (eval $ac_compile) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } 2>conftest.err; then + soname=conftest + lib=conftest + libobjs=conftest.$ac_objext + deplibs= + wl=$lt_prog_compiler_wl + pic_flag=$lt_prog_compiler_pic + compiler_flags=-v + linker_flags=-v + verstring= + output_objdir=. + libname=conftest + lt_save_allow_undefined_flag=$allow_undefined_flag + allow_undefined_flag= + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$archive_cmds 2\>\&1 \| $GREP \" -lc \" \>/dev/null 2\>\&1\""; } >&5 + (eval $archive_cmds 2\>\&1 \| $GREP \" -lc \" \>/dev/null 2\>\&1) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } + then + lt_cv_archive_cmds_need_lc=no + else + lt_cv_archive_cmds_need_lc=yes + fi + allow_undefined_flag=$lt_save_allow_undefined_flag + else + cat conftest.err 1>&5 + fi + $RM conftest* + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_archive_cmds_need_lc" >&5 +$as_echo "$lt_cv_archive_cmds_need_lc" >&6; } + archive_cmds_need_lc=$lt_cv_archive_cmds_need_lc + ;; + esac + fi + ;; +esac + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking dynamic linker characteristics" >&5 +$as_echo_n "checking dynamic linker characteristics... " >&6; } + +if test "$GCC" = yes; then + case $host_os in + darwin*) lt_awk_arg="/^libraries:/,/LR/" ;; + *) lt_awk_arg="/^libraries:/" ;; + esac + case $host_os in + mingw* | cegcc*) lt_sed_strip_eq="s,=\([A-Za-z]:\),\1,g" ;; + *) lt_sed_strip_eq="s,=/,/,g" ;; + esac + lt_search_path_spec=`$CC -print-search-dirs | awk $lt_awk_arg | $SED -e "s/^libraries://" -e $lt_sed_strip_eq` + case $lt_search_path_spec in + *\;*) + # if the path contains ";" then we assume it to be the separator + # otherwise default to the standard path separator (i.e. ":") - it is + # assumed that no part of a normal pathname contains ";" but that should + # okay in the real world where ";" in dirpaths is itself problematic. + lt_search_path_spec=`$ECHO "$lt_search_path_spec" | $SED 's/;/ /g'` + ;; + *) + lt_search_path_spec=`$ECHO "$lt_search_path_spec" | $SED "s/$PATH_SEPARATOR/ /g"` + ;; + esac + # Ok, now we have the path, separated by spaces, we can step through it + # and add multilib dir if necessary. + lt_tmp_lt_search_path_spec= + lt_multi_os_dir=`$CC $CPPFLAGS $CFLAGS $LDFLAGS -print-multi-os-directory 2>/dev/null` + for lt_sys_path in $lt_search_path_spec; do + if test -d "$lt_sys_path/$lt_multi_os_dir"; then + lt_tmp_lt_search_path_spec="$lt_tmp_lt_search_path_spec $lt_sys_path/$lt_multi_os_dir" + else + test -d "$lt_sys_path" && \ + lt_tmp_lt_search_path_spec="$lt_tmp_lt_search_path_spec $lt_sys_path" + fi + done + lt_search_path_spec=`$ECHO "$lt_tmp_lt_search_path_spec" | awk ' +BEGIN {RS=" "; FS="/|\n";} { + lt_foo=""; + lt_count=0; + for (lt_i = NF; lt_i > 0; lt_i--) { + if ($lt_i != "" && $lt_i != ".") { + if ($lt_i == "..") { + lt_count++; + } else { + if (lt_count == 0) { + lt_foo="/" $lt_i lt_foo; + } else { + lt_count--; + } + } + } + } + if (lt_foo != "") { lt_freq[lt_foo]++; } + if (lt_freq[lt_foo] == 1) { print lt_foo; } +}'` + # AWK program above erroneously prepends '/' to C:/dos/paths + # for these hosts. + case $host_os in + mingw* | cegcc*) lt_search_path_spec=`$ECHO "$lt_search_path_spec" |\ + $SED 's,/\([A-Za-z]:\),\1,g'` ;; + esac + sys_lib_search_path_spec=`$ECHO "$lt_search_path_spec" | $lt_NL2SP` +else + sys_lib_search_path_spec="/lib /usr/lib /usr/local/lib" +fi +library_names_spec= +libname_spec='lib$name' +soname_spec= +shrext_cmds=".so" +postinstall_cmds= +postuninstall_cmds= +finish_cmds= +finish_eval= +shlibpath_var= +shlibpath_overrides_runpath=unknown +version_type=none +dynamic_linker="$host_os ld.so" +sys_lib_dlsearch_path_spec="/lib /usr/lib" +need_lib_prefix=unknown +hardcode_into_libs=no + +# when you set need_version to no, make sure it does not cause -set_version +# flags to be left without arguments +need_version=unknown + +case $host_os in +aix3*) + version_type=linux # correct to gnu/linux during the next big refactor + library_names_spec='${libname}${release}${shared_ext}$versuffix $libname.a' + shlibpath_var=LIBPATH + + # AIX 3 has no versioning support, so we append a major version to the name. + soname_spec='${libname}${release}${shared_ext}$major' + ;; + +aix[4-9]*) + version_type=linux # correct to gnu/linux during the next big refactor + need_lib_prefix=no + need_version=no + hardcode_into_libs=yes + if test "$host_cpu" = ia64; then + # AIX 5 supports IA64 + library_names_spec='${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext}$versuffix $libname${shared_ext}' + shlibpath_var=LD_LIBRARY_PATH + else + # With GCC up to 2.95.x, collect2 would create an import file + # for dependence libraries. The import file would start with + # the line `#! .'. This would cause the generated library to + # depend on `.', always an invalid library. This was fixed in + # development snapshots of GCC prior to 3.0. + case $host_os in + aix4 | aix4.[01] | aix4.[01].*) + if { echo '#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 97)' + echo ' yes ' + echo '#endif'; } | ${CC} -E - | $GREP yes > /dev/null; then + : + else + can_build_shared=no + fi + ;; + esac + # AIX (on Power*) has no versioning support, so currently we can not hardcode correct + # soname into executable. Probably we can add versioning support to + # collect2, so additional links can be useful in future. + if test "$aix_use_runtimelinking" = yes; then + # If using run time linking (on AIX 4.2 or later) use lib.so + # instead of lib.a to let people know that these are not + # typical AIX shared libraries. + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + else + # We preserve .a as extension for shared libraries through AIX4.2 + # and later when we are not doing run time linking. + library_names_spec='${libname}${release}.a $libname.a' + soname_spec='${libname}${release}${shared_ext}$major' + fi + shlibpath_var=LIBPATH + fi + ;; + +amigaos*) + case $host_cpu in + powerpc) + # Since July 2007 AmigaOS4 officially supports .so libraries. + # When compiling the executable, add -use-dynld -Lsobjs: to the compileline. + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + ;; + m68k) + library_names_spec='$libname.ixlibrary $libname.a' + # Create ${libname}_ixlibrary.a entries in /sys/libs. + finish_eval='for lib in `ls $libdir/*.ixlibrary 2>/dev/null`; do libname=`func_echo_all "$lib" | $SED '\''s%^.*/\([^/]*\)\.ixlibrary$%\1%'\''`; test $RM /sys/libs/${libname}_ixlibrary.a; $show "cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a"; cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a || exit 1; done' + ;; + esac + ;; + +beos*) + library_names_spec='${libname}${shared_ext}' + dynamic_linker="$host_os ld.so" + shlibpath_var=LIBRARY_PATH + ;; + +bsdi[45]*) + version_type=linux # correct to gnu/linux during the next big refactor + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + finish_cmds='PATH="\$PATH:/sbin" ldconfig $libdir' + shlibpath_var=LD_LIBRARY_PATH + sys_lib_search_path_spec="/shlib /usr/lib /usr/X11/lib /usr/contrib/lib /lib /usr/local/lib" + sys_lib_dlsearch_path_spec="/shlib /usr/lib /usr/local/lib" + # the default ld.so.conf also contains /usr/contrib/lib and + # /usr/X11R6/lib (/usr/X11 is a link to /usr/X11R6), but let us allow + # libtool to hard-code these into programs + ;; + +cygwin* | mingw* | pw32* | cegcc*) + version_type=windows + shrext_cmds=".dll" + need_version=no + need_lib_prefix=no + + case $GCC,$cc_basename in + yes,*) + # gcc + library_names_spec='$libname.dll.a' + # DLL is installed to $(libdir)/../bin by postinstall_cmds + postinstall_cmds='base_file=`basename \${file}`~ + dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i; echo \$dlname'\''`~ + dldir=$destdir/`dirname \$dlpath`~ + test -d \$dldir || mkdir -p \$dldir~ + $install_prog $dir/$dlname \$dldir/$dlname~ + chmod a+x \$dldir/$dlname~ + if test -n '\''$stripme'\'' && test -n '\''$striplib'\''; then + eval '\''$striplib \$dldir/$dlname'\'' || exit \$?; + fi' + postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~ + dlpath=$dir/\$dldll~ + $RM \$dlpath' + shlibpath_overrides_runpath=yes + + case $host_os in + cygwin*) + # Cygwin DLLs use 'cyg' prefix rather than 'lib' + soname_spec='`echo ${libname} | sed -e 's/^lib/cyg/'``echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}' + + sys_lib_search_path_spec="$sys_lib_search_path_spec /usr/lib/w32api" + ;; + mingw* | cegcc*) + # MinGW DLLs use traditional 'lib' prefix + soname_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}' + ;; + pw32*) + # pw32 DLLs use 'pw' prefix rather than 'lib' + library_names_spec='`echo ${libname} | sed -e 's/^lib/pw/'``echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}' + ;; + esac + dynamic_linker='Win32 ld.exe' + ;; + + *,cl*) + # Native MSVC + libname_spec='$name' + soname_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}' + library_names_spec='${libname}.dll.lib' + + case $build_os in + mingw*) + sys_lib_search_path_spec= + lt_save_ifs=$IFS + IFS=';' + for lt_path in $LIB + do + IFS=$lt_save_ifs + # Let DOS variable expansion print the short 8.3 style file name. + lt_path=`cd "$lt_path" 2>/dev/null && cmd //C "for %i in (".") do @echo %~si"` + sys_lib_search_path_spec="$sys_lib_search_path_spec $lt_path" + done + IFS=$lt_save_ifs + # Convert to MSYS style. + sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | sed -e 's|\\\\|/|g' -e 's| \\([a-zA-Z]\\):| /\\1|g' -e 's|^ ||'` + ;; + cygwin*) + # Convert to unix form, then to dos form, then back to unix form + # but this time dos style (no spaces!) so that the unix form looks + # like /cygdrive/c/PROGRA~1:/cygdr... + sys_lib_search_path_spec=`cygpath --path --unix "$LIB"` + sys_lib_search_path_spec=`cygpath --path --dos "$sys_lib_search_path_spec" 2>/dev/null` + sys_lib_search_path_spec=`cygpath --path --unix "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"` + ;; + *) + sys_lib_search_path_spec="$LIB" + if $ECHO "$sys_lib_search_path_spec" | $GREP ';[c-zC-Z]:/' >/dev/null; then + # It is most probably a Windows format PATH. + sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'` + else + sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"` + fi + # FIXME: find the short name or the path components, as spaces are + # common. (e.g. "Program Files" -> "PROGRA~1") + ;; + esac + + # DLL is installed to $(libdir)/../bin by postinstall_cmds + postinstall_cmds='base_file=`basename \${file}`~ + dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i; echo \$dlname'\''`~ + dldir=$destdir/`dirname \$dlpath`~ + test -d \$dldir || mkdir -p \$dldir~ + $install_prog $dir/$dlname \$dldir/$dlname' + postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~ + dlpath=$dir/\$dldll~ + $RM \$dlpath' + shlibpath_overrides_runpath=yes + dynamic_linker='Win32 link.exe' + ;; + + *) + # Assume MSVC wrapper + library_names_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext} $libname.lib' + dynamic_linker='Win32 ld.exe' + ;; + esac + # FIXME: first we should search . and the directory the executable is in + shlibpath_var=PATH + ;; + +darwin* | rhapsody*) + dynamic_linker="$host_os dyld" + version_type=darwin + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${major}$shared_ext ${libname}$shared_ext' + soname_spec='${libname}${release}${major}$shared_ext' + shlibpath_overrides_runpath=yes + shlibpath_var=DYLD_LIBRARY_PATH + shrext_cmds='`test .$module = .yes && echo .so || echo .dylib`' + + sys_lib_search_path_spec="$sys_lib_search_path_spec /usr/local/lib" + sys_lib_dlsearch_path_spec='/usr/local/lib /lib /usr/lib' + ;; + +dgux*) + version_type=linux # correct to gnu/linux during the next big refactor + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname$shared_ext' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + ;; + +freebsd* | dragonfly*) + # DragonFly does not have aout. When/if they implement a new + # versioning mechanism, adjust this. + if test -x /usr/bin/objformat; then + objformat=`/usr/bin/objformat` + else + case $host_os in + freebsd[23].*) objformat=aout ;; + *) objformat=elf ;; + esac + fi + version_type=freebsd-$objformat + case $version_type in + freebsd-elf*) + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}' + need_version=no + need_lib_prefix=no + ;; + freebsd-*) + library_names_spec='${libname}${release}${shared_ext}$versuffix $libname${shared_ext}$versuffix' + need_version=yes + ;; + esac + shlibpath_var=LD_LIBRARY_PATH + case $host_os in + freebsd2.*) + shlibpath_overrides_runpath=yes + ;; + freebsd3.[01]* | freebsdelf3.[01]*) + shlibpath_overrides_runpath=yes + hardcode_into_libs=yes + ;; + freebsd3.[2-9]* | freebsdelf3.[2-9]* | \ + freebsd4.[0-5] | freebsdelf4.[0-5] | freebsd4.1.1 | freebsdelf4.1.1) + shlibpath_overrides_runpath=no + hardcode_into_libs=yes + ;; + *) # from 4.6 on, and DragonFly + shlibpath_overrides_runpath=yes + hardcode_into_libs=yes + ;; + esac + ;; + +haiku*) + version_type=linux # correct to gnu/linux during the next big refactor + need_lib_prefix=no + need_version=no + dynamic_linker="$host_os runtime_loader" + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}${major} ${libname}${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LIBRARY_PATH + shlibpath_overrides_runpath=yes + sys_lib_dlsearch_path_spec='/boot/home/config/lib /boot/common/lib /boot/system/lib' + hardcode_into_libs=yes + ;; + +hpux9* | hpux10* | hpux11*) + # Give a soname corresponding to the major version so that dld.sl refuses to + # link against other versions. + version_type=sunos + need_lib_prefix=no + need_version=no + case $host_cpu in + ia64*) + shrext_cmds='.so' + hardcode_into_libs=yes + dynamic_linker="$host_os dld.so" + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes # Unless +noenvvar is specified. + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + if test "X$HPUX_IA64_MODE" = X32; then + sys_lib_search_path_spec="/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib" + else + sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64" + fi + sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec + ;; + hppa*64*) + shrext_cmds='.sl' + hardcode_into_libs=yes + dynamic_linker="$host_os dld.sl" + shlibpath_var=LD_LIBRARY_PATH # How should we handle SHLIB_PATH + shlibpath_overrides_runpath=yes # Unless +noenvvar is specified. + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + sys_lib_search_path_spec="/usr/lib/pa20_64 /usr/ccs/lib/pa20_64" + sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec + ;; + *) + shrext_cmds='.sl' + dynamic_linker="$host_os dld.sl" + shlibpath_var=SHLIB_PATH + shlibpath_overrides_runpath=no # +s is required to enable SHLIB_PATH + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + ;; + esac + # HP-UX runs *really* slowly unless shared libraries are mode 555, ... + postinstall_cmds='chmod 555 $lib' + # or fails outright, so override atomically: + install_override_mode=555 + ;; + +interix[3-9]*) + version_type=linux # correct to gnu/linux during the next big refactor + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + dynamic_linker='Interix 3.x ld.so.1 (PE, like ELF)' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + hardcode_into_libs=yes + ;; + +irix5* | irix6* | nonstopux*) + case $host_os in + nonstopux*) version_type=nonstopux ;; + *) + if test "$lt_cv_prog_gnu_ld" = yes; then + version_type=linux # correct to gnu/linux during the next big refactor + else + version_type=irix + fi ;; + esac + need_lib_prefix=no + need_version=no + soname_spec='${libname}${release}${shared_ext}$major' + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext} $libname${shared_ext}' + case $host_os in + irix5* | nonstopux*) + libsuff= shlibsuff= + ;; + *) + case $LD in # libtool.m4 will add one of these switches to LD + *-32|*"-32 "|*-melf32bsmip|*"-melf32bsmip ") + libsuff= shlibsuff= libmagic=32-bit;; + *-n32|*"-n32 "|*-melf32bmipn32|*"-melf32bmipn32 ") + libsuff=32 shlibsuff=N32 libmagic=N32;; + *-64|*"-64 "|*-melf64bmip|*"-melf64bmip ") + libsuff=64 shlibsuff=64 libmagic=64-bit;; + *) libsuff= shlibsuff= libmagic=never-match;; + esac + ;; + esac + shlibpath_var=LD_LIBRARY${shlibsuff}_PATH + shlibpath_overrides_runpath=no + sys_lib_search_path_spec="/usr/lib${libsuff} /lib${libsuff} /usr/local/lib${libsuff}" + sys_lib_dlsearch_path_spec="/usr/lib${libsuff} /lib${libsuff}" + hardcode_into_libs=yes + ;; + +# No shared lib support for Linux oldld, aout, or coff. +linux*oldld* | linux*aout* | linux*coff*) + dynamic_linker=no + ;; + +# This must be glibc/ELF. +linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*) + version_type=linux # correct to gnu/linux during the next big refactor + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + finish_cmds='PATH="\$PATH:/sbin" ldconfig -n $libdir' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + + # Some binutils ld are patched to set DT_RUNPATH + if ${lt_cv_shlibpath_overrides_runpath+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_shlibpath_overrides_runpath=no + save_LDFLAGS=$LDFLAGS + save_libdir=$libdir + eval "libdir=/foo; wl=\"$lt_prog_compiler_wl\"; \ + LDFLAGS=\"\$LDFLAGS $hardcode_libdir_flag_spec\"" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + if ($OBJDUMP -p conftest$ac_exeext) 2>/dev/null | grep "RUNPATH.*$libdir" >/dev/null; then : + lt_cv_shlibpath_overrides_runpath=yes +fi +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext + LDFLAGS=$save_LDFLAGS + libdir=$save_libdir + +fi + + shlibpath_overrides_runpath=$lt_cv_shlibpath_overrides_runpath + + # This implies no fast_install, which is unacceptable. + # Some rework will be needed to allow for fast_install + # before this can be enabled. + hardcode_into_libs=yes + + # Append ld.so.conf contents to the search path + if test -f /etc/ld.so.conf; then + lt_ld_extra=`awk '/^include / { system(sprintf("cd /etc; cat %s 2>/dev/null", \$2)); skip = 1; } { if (!skip) print \$0; skip = 0; }' < /etc/ld.so.conf | $SED -e 's/#.*//;/^[ ]*hwcap[ ]/d;s/[:, ]/ /g;s/=[^=]*$//;s/=[^= ]* / /g;s/"//g;/^$/d' | tr '\n' ' '` + sys_lib_dlsearch_path_spec="/lib /usr/lib $lt_ld_extra" + fi + + # We used to test for /lib/ld.so.1 and disable shared libraries on + # powerpc, because MkLinux only supported shared libraries with the + # GNU dynamic linker. Since this was broken with cross compilers, + # most powerpc-linux boxes support dynamic linking these days and + # people can always --disable-shared, the test was removed, and we + # assume the GNU/Linux dynamic linker is in use. + dynamic_linker='GNU/Linux ld.so' + ;; + +netbsdelf*-gnu) + version_type=linux + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + hardcode_into_libs=yes + dynamic_linker='NetBSD ld.elf_so' + ;; + +netbsd*) + version_type=sunos + need_lib_prefix=no + need_version=no + if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix' + finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir' + dynamic_linker='NetBSD (a.out) ld.so' + else + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + dynamic_linker='NetBSD ld.elf_so' + fi + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + hardcode_into_libs=yes + ;; + +newsos6) + version_type=linux # correct to gnu/linux during the next big refactor + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + ;; + +*nto* | *qnx*) + version_type=qnx + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + hardcode_into_libs=yes + dynamic_linker='ldqnx.so' + ;; + +openbsd*) + version_type=sunos + sys_lib_dlsearch_path_spec="/usr/lib" + need_lib_prefix=no + # Some older versions of OpenBSD (3.3 at least) *do* need versioned libs. + case $host_os in + openbsd3.3 | openbsd3.3.*) need_version=yes ;; + *) need_version=no ;; + esac + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix' + finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir' + shlibpath_var=LD_LIBRARY_PATH + if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then + case $host_os in + openbsd2.[89] | openbsd2.[89].*) + shlibpath_overrides_runpath=no + ;; + *) + shlibpath_overrides_runpath=yes + ;; + esac + else + shlibpath_overrides_runpath=yes + fi + ;; + +os2*) + libname_spec='$name' + shrext_cmds=".dll" + need_lib_prefix=no + library_names_spec='$libname${shared_ext} $libname.a' + dynamic_linker='OS/2 ld.exe' + shlibpath_var=LIBPATH + ;; + +osf3* | osf4* | osf5*) + version_type=osf + need_lib_prefix=no + need_version=no + soname_spec='${libname}${release}${shared_ext}$major' + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + shlibpath_var=LD_LIBRARY_PATH + sys_lib_search_path_spec="/usr/shlib /usr/ccs/lib /usr/lib/cmplrs/cc /usr/lib /usr/local/lib /var/shlib" + sys_lib_dlsearch_path_spec="$sys_lib_search_path_spec" + ;; + +rdos*) + dynamic_linker=no + ;; + +solaris*) + version_type=linux # correct to gnu/linux during the next big refactor + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + hardcode_into_libs=yes + # ldd complains unless libraries are executable + postinstall_cmds='chmod +x $lib' + ;; + +sunos4*) + version_type=sunos + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix' + finish_cmds='PATH="\$PATH:/usr/etc" ldconfig $libdir' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + if test "$with_gnu_ld" = yes; then + need_lib_prefix=no + fi + need_version=yes + ;; + +sysv4 | sysv4.3*) + version_type=linux # correct to gnu/linux during the next big refactor + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + case $host_vendor in + sni) + shlibpath_overrides_runpath=no + need_lib_prefix=no + runpath_var=LD_RUN_PATH + ;; + siemens) + need_lib_prefix=no + ;; + motorola) + need_lib_prefix=no + need_version=no + shlibpath_overrides_runpath=no + sys_lib_search_path_spec='/lib /usr/lib /usr/ccs/lib' + ;; + esac + ;; + +sysv4*MP*) + if test -d /usr/nec ;then + version_type=linux # correct to gnu/linux during the next big refactor + library_names_spec='$libname${shared_ext}.$versuffix $libname${shared_ext}.$major $libname${shared_ext}' + soname_spec='$libname${shared_ext}.$major' + shlibpath_var=LD_LIBRARY_PATH + fi + ;; + +sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*) + version_type=freebsd-elf + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + hardcode_into_libs=yes + if test "$with_gnu_ld" = yes; then + sys_lib_search_path_spec='/usr/local/lib /usr/gnu/lib /usr/ccs/lib /usr/lib /lib' + else + sys_lib_search_path_spec='/usr/ccs/lib /usr/lib' + case $host_os in + sco3.2v5*) + sys_lib_search_path_spec="$sys_lib_search_path_spec /lib" + ;; + esac + fi + sys_lib_dlsearch_path_spec='/usr/lib' + ;; + +tpf*) + # TPF is a cross-target only. Preferred cross-host = GNU/Linux. + version_type=linux # correct to gnu/linux during the next big refactor + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + hardcode_into_libs=yes + ;; + +uts4*) + version_type=linux # correct to gnu/linux during the next big refactor + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + ;; + +*) + dynamic_linker=no + ;; +esac +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $dynamic_linker" >&5 +$as_echo "$dynamic_linker" >&6; } +test "$dynamic_linker" = no && can_build_shared=no + +variables_saved_for_relink="PATH $shlibpath_var $runpath_var" +if test "$GCC" = yes; then + variables_saved_for_relink="$variables_saved_for_relink GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH" +fi + +if test "${lt_cv_sys_lib_search_path_spec+set}" = set; then + sys_lib_search_path_spec="$lt_cv_sys_lib_search_path_spec" +fi +if test "${lt_cv_sys_lib_dlsearch_path_spec+set}" = set; then + sys_lib_dlsearch_path_spec="$lt_cv_sys_lib_dlsearch_path_spec" +fi + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to hardcode library paths into programs" >&5 +$as_echo_n "checking how to hardcode library paths into programs... " >&6; } +hardcode_action= +if test -n "$hardcode_libdir_flag_spec" || + test -n "$runpath_var" || + test "X$hardcode_automatic" = "Xyes" ; then + + # We can hardcode non-existent directories. + if test "$hardcode_direct" != no && + # If the only mechanism to avoid hardcoding is shlibpath_var, we + # have to relink, otherwise we might link with an installed library + # when we should be linking with a yet-to-be-installed one + ## test "$_LT_TAGVAR(hardcode_shlibpath_var, )" != no && + test "$hardcode_minus_L" != no; then + # Linking always hardcodes the temporary library directory. + hardcode_action=relink + else + # We can link without hardcoding, and we can hardcode nonexisting dirs. + hardcode_action=immediate + fi +else + # We cannot hardcode anything, or else we can only hardcode existing + # directories. + hardcode_action=unsupported +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $hardcode_action" >&5 +$as_echo "$hardcode_action" >&6; } + +if test "$hardcode_action" = relink || + test "$inherit_rpath" = yes; then + # Fast installation is not supported + enable_fast_install=no +elif test "$shlibpath_overrides_runpath" = yes || + test "$enable_shared" = no; then + # Fast installation is not necessary + enable_fast_install=needless +fi + + + + + + + if test "x$enable_dlopen" != xyes; then + enable_dlopen=unknown + enable_dlopen_self=unknown + enable_dlopen_self_static=unknown +else + lt_cv_dlopen=no + lt_cv_dlopen_libs= + + case $host_os in + beos*) + lt_cv_dlopen="load_add_on" + lt_cv_dlopen_libs= + lt_cv_dlopen_self=yes + ;; + + mingw* | pw32* | cegcc*) + lt_cv_dlopen="LoadLibrary" + lt_cv_dlopen_libs= + ;; + + cygwin*) + lt_cv_dlopen="dlopen" + lt_cv_dlopen_libs= + ;; + + darwin*) + # if libdl is installed we need to link against it + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5 +$as_echo_n "checking for dlopen in -ldl... " >&6; } +if ${ac_cv_lib_dl_dlopen+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-ldl $LIBS" +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char dlopen (); +int +main () +{ +return dlopen (); + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + ac_cv_lib_dl_dlopen=yes +else + ac_cv_lib_dl_dlopen=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5 +$as_echo "$ac_cv_lib_dl_dlopen" >&6; } +if test "x$ac_cv_lib_dl_dlopen" = xyes; then : + lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl" +else + + lt_cv_dlopen="dyld" + lt_cv_dlopen_libs= + lt_cv_dlopen_self=yes + +fi + + ;; + + *) + ac_fn_c_check_func "$LINENO" "shl_load" "ac_cv_func_shl_load" +if test "x$ac_cv_func_shl_load" = xyes; then : + lt_cv_dlopen="shl_load" +else + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for shl_load in -ldld" >&5 +$as_echo_n "checking for shl_load in -ldld... " >&6; } +if ${ac_cv_lib_dld_shl_load+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-ldld $LIBS" +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char shl_load (); +int +main () +{ +return shl_load (); + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + ac_cv_lib_dld_shl_load=yes +else + ac_cv_lib_dld_shl_load=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dld_shl_load" >&5 +$as_echo "$ac_cv_lib_dld_shl_load" >&6; } +if test "x$ac_cv_lib_dld_shl_load" = xyes; then : + lt_cv_dlopen="shl_load" lt_cv_dlopen_libs="-ldld" +else + ac_fn_c_check_func "$LINENO" "dlopen" "ac_cv_func_dlopen" +if test "x$ac_cv_func_dlopen" = xyes; then : + lt_cv_dlopen="dlopen" +else + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5 +$as_echo_n "checking for dlopen in -ldl... " >&6; } +if ${ac_cv_lib_dl_dlopen+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-ldl $LIBS" +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char dlopen (); +int +main () +{ +return dlopen (); + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + ac_cv_lib_dl_dlopen=yes +else + ac_cv_lib_dl_dlopen=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5 +$as_echo "$ac_cv_lib_dl_dlopen" >&6; } +if test "x$ac_cv_lib_dl_dlopen" = xyes; then : + lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl" +else + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -lsvld" >&5 +$as_echo_n "checking for dlopen in -lsvld... " >&6; } +if ${ac_cv_lib_svld_dlopen+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-lsvld $LIBS" +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char dlopen (); +int +main () +{ +return dlopen (); + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + ac_cv_lib_svld_dlopen=yes +else + ac_cv_lib_svld_dlopen=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_svld_dlopen" >&5 +$as_echo "$ac_cv_lib_svld_dlopen" >&6; } +if test "x$ac_cv_lib_svld_dlopen" = xyes; then : + lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-lsvld" +else + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dld_link in -ldld" >&5 +$as_echo_n "checking for dld_link in -ldld... " >&6; } +if ${ac_cv_lib_dld_dld_link+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-ldld $LIBS" +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char dld_link (); +int +main () +{ +return dld_link (); + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + ac_cv_lib_dld_dld_link=yes +else + ac_cv_lib_dld_dld_link=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dld_dld_link" >&5 +$as_echo "$ac_cv_lib_dld_dld_link" >&6; } +if test "x$ac_cv_lib_dld_dld_link" = xyes; then : + lt_cv_dlopen="dld_link" lt_cv_dlopen_libs="-ldld" +fi + + +fi + + +fi + + +fi + + +fi + + +fi + + ;; + esac + + if test "x$lt_cv_dlopen" != xno; then + enable_dlopen=yes + else + enable_dlopen=no + fi + + case $lt_cv_dlopen in + dlopen) + save_CPPFLAGS="$CPPFLAGS" + test "x$ac_cv_header_dlfcn_h" = xyes && CPPFLAGS="$CPPFLAGS -DHAVE_DLFCN_H" + + save_LDFLAGS="$LDFLAGS" + wl=$lt_prog_compiler_wl eval LDFLAGS=\"\$LDFLAGS $export_dynamic_flag_spec\" + + save_LIBS="$LIBS" + LIBS="$lt_cv_dlopen_libs $LIBS" + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether a program can dlopen itself" >&5 +$as_echo_n "checking whether a program can dlopen itself... " >&6; } +if ${lt_cv_dlopen_self+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test "$cross_compiling" = yes; then : + lt_cv_dlopen_self=cross +else + lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2 + lt_status=$lt_dlunknown + cat > conftest.$ac_ext <<_LT_EOF +#line $LINENO "configure" +#include "confdefs.h" + +#if HAVE_DLFCN_H +#include +#endif + +#include + +#ifdef RTLD_GLOBAL +# define LT_DLGLOBAL RTLD_GLOBAL +#else +# ifdef DL_GLOBAL +# define LT_DLGLOBAL DL_GLOBAL +# else +# define LT_DLGLOBAL 0 +# endif +#endif + +/* We may have to define LT_DLLAZY_OR_NOW in the command line if we + find out it does not work in some platform. */ +#ifndef LT_DLLAZY_OR_NOW +# ifdef RTLD_LAZY +# define LT_DLLAZY_OR_NOW RTLD_LAZY +# else +# ifdef DL_LAZY +# define LT_DLLAZY_OR_NOW DL_LAZY +# else +# ifdef RTLD_NOW +# define LT_DLLAZY_OR_NOW RTLD_NOW +# else +# ifdef DL_NOW +# define LT_DLLAZY_OR_NOW DL_NOW +# else +# define LT_DLLAZY_OR_NOW 0 +# endif +# endif +# endif +# endif +#endif + +/* When -fvisbility=hidden is used, assume the code has been annotated + correspondingly for the symbols needed. */ +#if defined(__GNUC__) && (((__GNUC__ == 3) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 3)) +int fnord () __attribute__((visibility("default"))); +#endif + +int fnord () { return 42; } +int main () +{ + void *self = dlopen (0, LT_DLGLOBAL|LT_DLLAZY_OR_NOW); + int status = $lt_dlunknown; + + if (self) + { + if (dlsym (self,"fnord")) status = $lt_dlno_uscore; + else + { + if (dlsym( self,"_fnord")) status = $lt_dlneed_uscore; + else puts (dlerror ()); + } + /* dlclose (self); */ + } + else + puts (dlerror ()); + + return status; +} +_LT_EOF + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5 + (eval $ac_link) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } && test -s conftest${ac_exeext} 2>/dev/null; then + (./conftest; exit; ) >&5 2>/dev/null + lt_status=$? + case x$lt_status in + x$lt_dlno_uscore) lt_cv_dlopen_self=yes ;; + x$lt_dlneed_uscore) lt_cv_dlopen_self=yes ;; + x$lt_dlunknown|x*) lt_cv_dlopen_self=no ;; + esac + else : + # compilation failed + lt_cv_dlopen_self=no + fi +fi +rm -fr conftest* + + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_dlopen_self" >&5 +$as_echo "$lt_cv_dlopen_self" >&6; } + + if test "x$lt_cv_dlopen_self" = xyes; then + wl=$lt_prog_compiler_wl eval LDFLAGS=\"\$LDFLAGS $lt_prog_compiler_static\" + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether a statically linked program can dlopen itself" >&5 +$as_echo_n "checking whether a statically linked program can dlopen itself... " >&6; } +if ${lt_cv_dlopen_self_static+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test "$cross_compiling" = yes; then : + lt_cv_dlopen_self_static=cross +else + lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2 + lt_status=$lt_dlunknown + cat > conftest.$ac_ext <<_LT_EOF +#line $LINENO "configure" +#include "confdefs.h" + +#if HAVE_DLFCN_H +#include +#endif + +#include + +#ifdef RTLD_GLOBAL +# define LT_DLGLOBAL RTLD_GLOBAL +#else +# ifdef DL_GLOBAL +# define LT_DLGLOBAL DL_GLOBAL +# else +# define LT_DLGLOBAL 0 +# endif +#endif + +/* We may have to define LT_DLLAZY_OR_NOW in the command line if we + find out it does not work in some platform. */ +#ifndef LT_DLLAZY_OR_NOW +# ifdef RTLD_LAZY +# define LT_DLLAZY_OR_NOW RTLD_LAZY +# else +# ifdef DL_LAZY +# define LT_DLLAZY_OR_NOW DL_LAZY +# else +# ifdef RTLD_NOW +# define LT_DLLAZY_OR_NOW RTLD_NOW +# else +# ifdef DL_NOW +# define LT_DLLAZY_OR_NOW DL_NOW +# else +# define LT_DLLAZY_OR_NOW 0 +# endif +# endif +# endif +# endif +#endif + +/* When -fvisbility=hidden is used, assume the code has been annotated + correspondingly for the symbols needed. */ +#if defined(__GNUC__) && (((__GNUC__ == 3) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 3)) +int fnord () __attribute__((visibility("default"))); +#endif + +int fnord () { return 42; } +int main () +{ + void *self = dlopen (0, LT_DLGLOBAL|LT_DLLAZY_OR_NOW); + int status = $lt_dlunknown; + + if (self) + { + if (dlsym (self,"fnord")) status = $lt_dlno_uscore; + else + { + if (dlsym( self,"_fnord")) status = $lt_dlneed_uscore; + else puts (dlerror ()); + } + /* dlclose (self); */ + } + else + puts (dlerror ()); + + return status; +} +_LT_EOF + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5 + (eval $ac_link) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } && test -s conftest${ac_exeext} 2>/dev/null; then + (./conftest; exit; ) >&5 2>/dev/null + lt_status=$? + case x$lt_status in + x$lt_dlno_uscore) lt_cv_dlopen_self_static=yes ;; + x$lt_dlneed_uscore) lt_cv_dlopen_self_static=yes ;; + x$lt_dlunknown|x*) lt_cv_dlopen_self_static=no ;; + esac + else : + # compilation failed + lt_cv_dlopen_self_static=no + fi +fi +rm -fr conftest* + + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_dlopen_self_static" >&5 +$as_echo "$lt_cv_dlopen_self_static" >&6; } + fi + + CPPFLAGS="$save_CPPFLAGS" + LDFLAGS="$save_LDFLAGS" + LIBS="$save_LIBS" + ;; + esac + + case $lt_cv_dlopen_self in + yes|no) enable_dlopen_self=$lt_cv_dlopen_self ;; + *) enable_dlopen_self=unknown ;; + esac + + case $lt_cv_dlopen_self_static in + yes|no) enable_dlopen_self_static=$lt_cv_dlopen_self_static ;; + *) enable_dlopen_self_static=unknown ;; + esac +fi + + + + + + + + + + + + + + + + + +striplib= +old_striplib= +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether stripping libraries is possible" >&5 +$as_echo_n "checking whether stripping libraries is possible... " >&6; } +if test -n "$STRIP" && $STRIP -V 2>&1 | $GREP "GNU strip" >/dev/null; then + test -z "$old_striplib" && old_striplib="$STRIP --strip-debug" + test -z "$striplib" && striplib="$STRIP --strip-unneeded" + { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +$as_echo "yes" >&6; } +else +# FIXME - insert some real tests, host_os isn't really good enough + case $host_os in + darwin*) + if test -n "$STRIP" ; then + striplib="$STRIP -x" + old_striplib="$STRIP -S" + { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +$as_echo "yes" >&6; } + else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } + fi + ;; + *) + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } + ;; + esac +fi + + + + + + + + + + + + + # Report which library types will actually be built + { $as_echo "$as_me:${as_lineno-$LINENO}: checking if libtool supports shared libraries" >&5 +$as_echo_n "checking if libtool supports shared libraries... " >&6; } + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $can_build_shared" >&5 +$as_echo "$can_build_shared" >&6; } + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to build shared libraries" >&5 +$as_echo_n "checking whether to build shared libraries... " >&6; } + test "$can_build_shared" = "no" && enable_shared=no + + # On AIX, shared libraries and static libraries use the same namespace, and + # are all built from PIC. + case $host_os in + aix3*) + test "$enable_shared" = yes && enable_static=no + if test -n "$RANLIB"; then + archive_cmds="$archive_cmds~\$RANLIB \$lib" + postinstall_cmds='$RANLIB $lib' + fi + ;; + + aix[4-9]*) + if test "$host_cpu" != ia64 && test "$aix_use_runtimelinking" = no ; then + test "$enable_shared" = yes && enable_static=no + fi + ;; + esac + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $enable_shared" >&5 +$as_echo "$enable_shared" >&6; } + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to build static libraries" >&5 +$as_echo_n "checking whether to build static libraries... " >&6; } + # Make sure either enable_shared or enable_static is yes. + test "$enable_shared" = yes || enable_static=yes + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $enable_static" >&5 +$as_echo "$enable_static" >&6; } + + + + +fi +ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu + +CC="$lt_save_CC" + + + + + + + + + + + + + + + + ac_config_commands="$ac_config_commands libtool" + + + + +# Only expand once: + + + + + +# Check for C++ compiler and use it to compile the tests. +# +ac_ext=cpp +ac_cpp='$CXXCPP $CPPFLAGS' +ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_cxx_compiler_gnu +if test -z "$CXX"; then + if test -n "$CCC"; then + CXX=$CCC + else + if test -n "$ac_tool_prefix"; then + for ac_prog in g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC + do + # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args. +set dummy $ac_tool_prefix$ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_CXX+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$CXX"; then + ac_cv_prog_CXX="$CXX" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_CXX="$ac_tool_prefix$ac_prog" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +CXX=$ac_cv_prog_CXX +if test -n "$CXX"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXX" >&5 +$as_echo "$CXX" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$CXX" && break + done +fi +if test -z "$CXX"; then + ac_ct_CXX=$CXX + for ac_prog in g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC +do + # Extract the first word of "$ac_prog", so it can be a program name with args. +set dummy $ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_ac_ct_CXX+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_CXX"; then + ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_CXX="$ac_prog" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_CXX=$ac_cv_prog_ac_ct_CXX +if test -n "$ac_ct_CXX"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CXX" >&5 +$as_echo "$ac_ct_CXX" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$ac_ct_CXX" && break +done + + if test "x$ac_ct_CXX" = x; then + CXX="g++" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + CXX=$ac_ct_CXX + fi +fi + + fi +fi +# Provide some information about the compiler. +$as_echo "$as_me:${as_lineno-$LINENO}: checking for C++ compiler version" >&5 +set X $ac_compile +ac_compiler=$2 +for ac_option in --version -v -V -qversion; do + { { ac_try="$ac_compiler $ac_option >&5" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_compiler $ac_option >&5") 2>conftest.err + ac_status=$? + if test -s conftest.err; then + sed '10a\ +... rest of stderr output deleted ... + 10q' conftest.err >conftest.er1 + cat conftest.er1 >&5 + fi + rm -f conftest.er1 conftest.err + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } +done + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C++ compiler" >&5 +$as_echo_n "checking whether we are using the GNU C++ compiler... " >&6; } +if ${ac_cv_cxx_compiler_gnu+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ +#ifndef __GNUC__ + choke me +#endif + + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_compile "$LINENO"; then : + ac_compiler_gnu=yes +else + ac_compiler_gnu=no +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +ac_cv_cxx_compiler_gnu=$ac_compiler_gnu + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_cxx_compiler_gnu" >&5 +$as_echo "$ac_cv_cxx_compiler_gnu" >&6; } +if test $ac_compiler_gnu = yes; then + GXX=yes +else + GXX= +fi +ac_test_CXXFLAGS=${CXXFLAGS+set} +ac_save_CXXFLAGS=$CXXFLAGS +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CXX accepts -g" >&5 +$as_echo_n "checking whether $CXX accepts -g... " >&6; } +if ${ac_cv_prog_cxx_g+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_save_cxx_werror_flag=$ac_cxx_werror_flag + ac_cxx_werror_flag=yes + ac_cv_prog_cxx_g=no + CXXFLAGS="-g" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_compile "$LINENO"; then : + ac_cv_prog_cxx_g=yes +else + CXXFLAGS="" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_compile "$LINENO"; then : + +else + ac_cxx_werror_flag=$ac_save_cxx_werror_flag + CXXFLAGS="-g" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_compile "$LINENO"; then : + ac_cv_prog_cxx_g=yes +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext + ac_cxx_werror_flag=$ac_save_cxx_werror_flag +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cxx_g" >&5 +$as_echo "$ac_cv_prog_cxx_g" >&6; } +if test "$ac_test_CXXFLAGS" = set; then + CXXFLAGS=$ac_save_CXXFLAGS +elif test $ac_cv_prog_cxx_g = yes; then + if test "$GXX" = yes; then + CXXFLAGS="-g -O2" + else + CXXFLAGS="-g" + fi +else + if test "$GXX" = yes; then + CXXFLAGS="-O2" + else + CXXFLAGS= + fi +fi +ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu + +depcc="$CXX" am_compiler_list= + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking dependency style of $depcc" >&5 +$as_echo_n "checking dependency style of $depcc... " >&6; } +if ${am_cv_CXX_dependencies_compiler_type+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then + # We make a subdir and do the tests there. Otherwise we can end up + # making bogus files that we don't know about and never remove. For + # instance it was reported that on HP-UX the gcc test will end up + # making a dummy file named 'D' -- because '-MD' means "put the output + # in D". + rm -rf conftest.dir + mkdir conftest.dir + # Copy depcomp to subdir because otherwise we won't find it if we're + # using a relative directory. + cp "$am_depcomp" conftest.dir + cd conftest.dir + # We will build objects and dependencies in a subdirectory because + # it helps to detect inapplicable dependency modes. For instance + # both Tru64's cc and ICC support -MD to output dependencies as a + # side effect of compilation, but ICC will put the dependencies in + # the current directory while Tru64 will put them in the object + # directory. + mkdir sub + + am_cv_CXX_dependencies_compiler_type=none + if test "$am_compiler_list" = ""; then + am_compiler_list=`sed -n 's/^#*\([a-zA-Z0-9]*\))$/\1/p' < ./depcomp` + fi + am__universal=false + case " $depcc " in #( + *\ -arch\ *\ -arch\ *) am__universal=true ;; + esac + + for depmode in $am_compiler_list; do + # Setup a source with many dependencies, because some compilers + # like to wrap large dependency lists on column 80 (with \), and + # we should not choose a depcomp mode which is confused by this. + # + # We need to recreate these files for each test, as the compiler may + # overwrite some of them when testing with obscure command lines. + # This happens at least with the AIX C compiler. + : > sub/conftest.c + for i in 1 2 3 4 5 6; do + echo '#include "conftst'$i'.h"' >> sub/conftest.c + # Using ": > sub/conftst$i.h" creates only sub/conftst1.h with + # Solaris 10 /bin/sh. + echo '/* dummy */' > sub/conftst$i.h + done + echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf + + # We check with '-c' and '-o' for the sake of the "dashmstdout" + # mode. It turns out that the SunPro C++ compiler does not properly + # handle '-M -o', and we need to detect this. Also, some Intel + # versions had trouble with output in subdirs. + am__obj=sub/conftest.${OBJEXT-o} + am__minus_obj="-o $am__obj" + case $depmode in + gcc) + # This depmode causes a compiler race in universal mode. + test "$am__universal" = false || continue + ;; + nosideeffect) + # After this tag, mechanisms are not by side-effect, so they'll + # only be used when explicitly requested. + if test "x$enable_dependency_tracking" = xyes; then + continue + else + break + fi + ;; + msvc7 | msvc7msys | msvisualcpp | msvcmsys) + # This compiler won't grok '-c -o', but also, the minuso test has + # not run yet. These depmodes are late enough in the game, and + # so weak that their functioning should not be impacted. + am__obj=conftest.${OBJEXT-o} + am__minus_obj= + ;; + none) break ;; + esac + if depmode=$depmode \ + source=sub/conftest.c object=$am__obj \ + depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \ + $SHELL ./depcomp $depcc -c $am__minus_obj sub/conftest.c \ + >/dev/null 2>conftest.err && + grep sub/conftst1.h sub/conftest.Po > /dev/null 2>&1 && + grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 && + grep $am__obj sub/conftest.Po > /dev/null 2>&1 && + ${MAKE-make} -s -f confmf > /dev/null 2>&1; then + # icc doesn't choke on unknown options, it will just issue warnings + # or remarks (even with -Werror). So we grep stderr for any message + # that says an option was ignored or not supported. + # When given -MP, icc 7.0 and 7.1 complain thusly: + # icc: Command line warning: ignoring option '-M'; no argument required + # The diagnosis changed in icc 8.0: + # icc: Command line remark: option '-MP' not supported + if (grep 'ignoring option' conftest.err || + grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else + am_cv_CXX_dependencies_compiler_type=$depmode + break + fi + fi + done + + cd .. + rm -rf conftest.dir +else + am_cv_CXX_dependencies_compiler_type=none +fi + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_CXX_dependencies_compiler_type" >&5 +$as_echo "$am_cv_CXX_dependencies_compiler_type" >&6; } +CXXDEPMODE=depmode=$am_cv_CXX_dependencies_compiler_type + + if + test "x$enable_dependency_tracking" != xno \ + && test "$am_cv_CXX_dependencies_compiler_type" = gcc3; then + am__fastdepCXX_TRUE= + am__fastdepCXX_FALSE='#' +else + am__fastdepCXX_TRUE='#' + am__fastdepCXX_FALSE= +fi + + + + +func_stripname_cnf () +{ + case ${2} in + .*) func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%\\\\${2}\$%%"`;; + *) func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%${2}\$%%"`;; + esac +} # func_stripname_cnf + + if test -n "$CXX" && ( test "X$CXX" != "Xno" && + ( (test "X$CXX" = "Xg++" && `g++ -v >/dev/null 2>&1` ) || + (test "X$CXX" != "Xg++"))) ; then + ac_ext=cpp +ac_cpp='$CXXCPP $CPPFLAGS' +ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_cxx_compiler_gnu +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C++ preprocessor" >&5 +$as_echo_n "checking how to run the C++ preprocessor... " >&6; } +if test -z "$CXXCPP"; then + if ${ac_cv_prog_CXXCPP+:} false; then : + $as_echo_n "(cached) " >&6 +else + # Double quotes because CXXCPP needs to be expanded + for CXXCPP in "$CXX -E" "/lib/cpp" + do + ac_preproc_ok=false +for ac_cxx_preproc_warn_flag in '' yes +do + # Use a header file that comes with gcc, so configuring glibc + # with a fresh cross-compiler works. + # Prefer to if __STDC__ is defined, since + # exists even on freestanding compilers. + # On the NeXT, cc -E runs the code through the compiler's parser, + # not just through cpp. "Syntax error" is here to catch this case. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#ifdef __STDC__ +# include +#else +# include +#endif + Syntax error +_ACEOF +if ac_fn_cxx_try_cpp "$LINENO"; then : + +else + # Broken: fails on valid input. +continue +fi +rm -f conftest.err conftest.i conftest.$ac_ext + + # OK, works on sane cases. Now check whether nonexistent headers + # can be detected and how. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +_ACEOF +if ac_fn_cxx_try_cpp "$LINENO"; then : + # Broken: success on invalid input. +continue +else + # Passes both tests. +ac_preproc_ok=: +break +fi +rm -f conftest.err conftest.i conftest.$ac_ext + +done +# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. +rm -f conftest.i conftest.err conftest.$ac_ext +if $ac_preproc_ok; then : + break +fi + + done + ac_cv_prog_CXXCPP=$CXXCPP + +fi + CXXCPP=$ac_cv_prog_CXXCPP +else + ac_cv_prog_CXXCPP=$CXXCPP +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXXCPP" >&5 +$as_echo "$CXXCPP" >&6; } +ac_preproc_ok=false +for ac_cxx_preproc_warn_flag in '' yes +do + # Use a header file that comes with gcc, so configuring glibc + # with a fresh cross-compiler works. + # Prefer to if __STDC__ is defined, since + # exists even on freestanding compilers. + # On the NeXT, cc -E runs the code through the compiler's parser, + # not just through cpp. "Syntax error" is here to catch this case. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#ifdef __STDC__ +# include +#else +# include +#endif + Syntax error +_ACEOF +if ac_fn_cxx_try_cpp "$LINENO"; then : + +else + # Broken: fails on valid input. +continue +fi +rm -f conftest.err conftest.i conftest.$ac_ext + + # OK, works on sane cases. Now check whether nonexistent headers + # can be detected and how. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +_ACEOF +if ac_fn_cxx_try_cpp "$LINENO"; then : + # Broken: success on invalid input. +continue +else + # Passes both tests. +ac_preproc_ok=: +break +fi +rm -f conftest.err conftest.i conftest.$ac_ext + +done +# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. +rm -f conftest.i conftest.err conftest.$ac_ext +if $ac_preproc_ok; then : + +else + { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 +$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} +as_fn_error $? "C++ preprocessor \"$CXXCPP\" fails sanity check +See \`config.log' for more details" "$LINENO" 5; } +fi + +ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu + +else + _lt_caught_CXX_error=yes +fi + +ac_ext=cpp +ac_cpp='$CXXCPP $CPPFLAGS' +ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_cxx_compiler_gnu + +archive_cmds_need_lc_CXX=no +allow_undefined_flag_CXX= +always_export_symbols_CXX=no +archive_expsym_cmds_CXX= +compiler_needs_object_CXX=no +export_dynamic_flag_spec_CXX= +hardcode_direct_CXX=no +hardcode_direct_absolute_CXX=no +hardcode_libdir_flag_spec_CXX= +hardcode_libdir_separator_CXX= +hardcode_minus_L_CXX=no +hardcode_shlibpath_var_CXX=unsupported +hardcode_automatic_CXX=no +inherit_rpath_CXX=no +module_cmds_CXX= +module_expsym_cmds_CXX= +link_all_deplibs_CXX=unknown +old_archive_cmds_CXX=$old_archive_cmds +reload_flag_CXX=$reload_flag +reload_cmds_CXX=$reload_cmds +no_undefined_flag_CXX= +whole_archive_flag_spec_CXX= +enable_shared_with_static_runtimes_CXX=no + +# Source file extension for C++ test sources. +ac_ext=cpp + +# Object file extension for compiled C++ test sources. +objext=o +objext_CXX=$objext + +# No sense in running all these tests if we already determined that +# the CXX compiler isn't working. Some variables (like enable_shared) +# are currently assumed to apply to all compilers on this platform, +# and will be corrupted by setting them based on a non-working compiler. +if test "$_lt_caught_CXX_error" != yes; then + # Code to be used in simple compile tests + lt_simple_compile_test_code="int some_variable = 0;" + + # Code to be used in simple link tests + lt_simple_link_test_code='int main(int, char *[]) { return(0); }' + + # ltmain only uses $CC for tagged configurations so make sure $CC is set. + + + + + + +# If no C compiler was specified, use CC. +LTCC=${LTCC-"$CC"} + +# If no C compiler flags were specified, use CFLAGS. +LTCFLAGS=${LTCFLAGS-"$CFLAGS"} + +# Allow CC to be a program name with arguments. +compiler=$CC + + + # save warnings/boilerplate of simple test code + ac_outfile=conftest.$ac_objext +echo "$lt_simple_compile_test_code" >conftest.$ac_ext +eval "$ac_compile" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err +_lt_compiler_boilerplate=`cat conftest.err` +$RM conftest* + + ac_outfile=conftest.$ac_objext +echo "$lt_simple_link_test_code" >conftest.$ac_ext +eval "$ac_link" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err +_lt_linker_boilerplate=`cat conftest.err` +$RM -r conftest* + + + # Allow CC to be a program name with arguments. + lt_save_CC=$CC + lt_save_CFLAGS=$CFLAGS + lt_save_LD=$LD + lt_save_GCC=$GCC + GCC=$GXX + lt_save_with_gnu_ld=$with_gnu_ld + lt_save_path_LD=$lt_cv_path_LD + if test -n "${lt_cv_prog_gnu_ldcxx+set}"; then + lt_cv_prog_gnu_ld=$lt_cv_prog_gnu_ldcxx + else + $as_unset lt_cv_prog_gnu_ld + fi + if test -n "${lt_cv_path_LDCXX+set}"; then + lt_cv_path_LD=$lt_cv_path_LDCXX + else + $as_unset lt_cv_path_LD + fi + test -z "${LDCXX+set}" || LD=$LDCXX + CC=${CXX-"c++"} + CFLAGS=$CXXFLAGS + compiler=$CC + compiler_CXX=$CC + for cc_temp in $compiler""; do + case $cc_temp in + compile | *[\\/]compile | ccache | *[\\/]ccache ) ;; + distcc | *[\\/]distcc | purify | *[\\/]purify ) ;; + \-*) ;; + *) break;; + esac +done +cc_basename=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"` + + + if test -n "$compiler"; then + # We don't want -fno-exception when compiling C++ code, so set the + # no_builtin_flag separately + if test "$GXX" = yes; then + lt_prog_compiler_no_builtin_flag_CXX=' -fno-builtin' + else + lt_prog_compiler_no_builtin_flag_CXX= + fi + + if test "$GXX" = yes; then + # Set up default GNU C++ configuration + + + +# Check whether --with-gnu-ld was given. +if test "${with_gnu_ld+set}" = set; then : + withval=$with_gnu_ld; test "$withval" = no || with_gnu_ld=yes +else + with_gnu_ld=no +fi + +ac_prog=ld +if test "$GCC" = yes; then + # Check if gcc -print-prog-name=ld gives a path. + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ld used by $CC" >&5 +$as_echo_n "checking for ld used by $CC... " >&6; } + case $host in + *-*-mingw*) + # gcc leaves a trailing carriage return which upsets mingw + ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;; + *) + ac_prog=`($CC -print-prog-name=ld) 2>&5` ;; + esac + case $ac_prog in + # Accept absolute paths. + [\\/]* | ?:[\\/]*) + re_direlt='/[^/][^/]*/\.\./' + # Canonicalize the pathname of ld + ac_prog=`$ECHO "$ac_prog"| $SED 's%\\\\%/%g'` + while $ECHO "$ac_prog" | $GREP "$re_direlt" > /dev/null 2>&1; do + ac_prog=`$ECHO $ac_prog| $SED "s%$re_direlt%/%"` + done + test -z "$LD" && LD="$ac_prog" + ;; + "") + # If it fails, then pretend we aren't using GCC. + ac_prog=ld + ;; + *) + # If it is relative, then search for the first ld in PATH. + with_gnu_ld=unknown + ;; + esac +elif test "$with_gnu_ld" = yes; then + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GNU ld" >&5 +$as_echo_n "checking for GNU ld... " >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for non-GNU ld" >&5 +$as_echo_n "checking for non-GNU ld... " >&6; } +fi +if ${lt_cv_path_LD+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -z "$LD"; then + lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR + for ac_dir in $PATH; do + IFS="$lt_save_ifs" + test -z "$ac_dir" && ac_dir=. + if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then + lt_cv_path_LD="$ac_dir/$ac_prog" + # Check to see if the program is GNU ld. I'd rather use --version, + # but apparently some variants of GNU ld only accept -v. + # Break only if it was the GNU/non-GNU ld that we prefer. + case `"$lt_cv_path_LD" -v 2>&1 &5 +$as_echo "$LD" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi +test -z "$LD" && as_fn_error $? "no acceptable ld found in \$PATH" "$LINENO" 5 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if the linker ($LD) is GNU ld" >&5 +$as_echo_n "checking if the linker ($LD) is GNU ld... " >&6; } +if ${lt_cv_prog_gnu_ld+:} false; then : + $as_echo_n "(cached) " >&6 +else + # I'd rather use --version here, but apparently some GNU lds only accept -v. +case `$LD -v 2>&1 &5 +$as_echo "$lt_cv_prog_gnu_ld" >&6; } +with_gnu_ld=$lt_cv_prog_gnu_ld + + + + + + + + # Check if GNU C++ uses GNU ld as the underlying linker, since the + # archiving commands below assume that GNU ld is being used. + if test "$with_gnu_ld" = yes; then + archive_cmds_CXX='$CC $pic_flag -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib' + archive_expsym_cmds_CXX='$CC $pic_flag -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + + hardcode_libdir_flag_spec_CXX='${wl}-rpath ${wl}$libdir' + export_dynamic_flag_spec_CXX='${wl}--export-dynamic' + + # If archive_cmds runs LD, not CC, wlarc should be empty + # XXX I think wlarc can be eliminated in ltcf-cxx, but I need to + # investigate it a little bit more. (MM) + wlarc='${wl}' + + # ancient GNU ld didn't support --whole-archive et. al. + if eval "`$CC -print-prog-name=ld` --help 2>&1" | + $GREP 'no-whole-archive' > /dev/null; then + whole_archive_flag_spec_CXX="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive' + else + whole_archive_flag_spec_CXX= + fi + else + with_gnu_ld=no + wlarc= + + # A generic and very simple default shared library creation + # command for GNU C++ for the case where it uses the native + # linker, instead of GNU ld. If possible, this setting should + # overridden to take advantage of the native linker features on + # the platform it is being used on. + archive_cmds_CXX='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $lib' + fi + + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"' + + else + GXX=no + with_gnu_ld=no + wlarc= + fi + + # PORTME: fill in a description of your system's C++ link characteristics + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the $compiler linker ($LD) supports shared libraries" >&5 +$as_echo_n "checking whether the $compiler linker ($LD) supports shared libraries... " >&6; } + ld_shlibs_CXX=yes + case $host_os in + aix3*) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + aix[4-9]*) + if test "$host_cpu" = ia64; then + # On IA64, the linker does run time linking by default, so we don't + # have to do anything special. + aix_use_runtimelinking=no + exp_sym_flag='-Bexport' + no_entry_flag="" + else + aix_use_runtimelinking=no + + # Test if we are trying to use run time linking or normal + # AIX style linking. If -brtl is somewhere in LDFLAGS, we + # need to do runtime linking. + case $host_os in aix4.[23]|aix4.[23].*|aix[5-9]*) + for ld_flag in $LDFLAGS; do + case $ld_flag in + *-brtl*) + aix_use_runtimelinking=yes + break + ;; + esac + done + ;; + esac + + exp_sym_flag='-bexport' + no_entry_flag='-bnoentry' + fi + + # When large executables or shared objects are built, AIX ld can + # have problems creating the table of contents. If linking a library + # or program results in "error TOC overflow" add -mminimal-toc to + # CXXFLAGS/CFLAGS for g++/gcc. In the cases where that is not + # enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS. + + archive_cmds_CXX='' + hardcode_direct_CXX=yes + hardcode_direct_absolute_CXX=yes + hardcode_libdir_separator_CXX=':' + link_all_deplibs_CXX=yes + file_list_spec_CXX='${wl}-f,' + + if test "$GXX" = yes; then + case $host_os in aix4.[012]|aix4.[012].*) + # We only want to do this on AIX 4.2 and lower, the check + # below for broken collect2 doesn't work under 4.3+ + collect2name=`${CC} -print-prog-name=collect2` + if test -f "$collect2name" && + strings "$collect2name" | $GREP resolve_lib_name >/dev/null + then + # We have reworked collect2 + : + else + # We have old collect2 + hardcode_direct_CXX=unsupported + # It fails to find uninstalled libraries when the uninstalled + # path is not listed in the libpath. Setting hardcode_minus_L + # to unsupported forces relinking + hardcode_minus_L_CXX=yes + hardcode_libdir_flag_spec_CXX='-L$libdir' + hardcode_libdir_separator_CXX= + fi + esac + shared_flag='-shared' + if test "$aix_use_runtimelinking" = yes; then + shared_flag="$shared_flag "'${wl}-G' + fi + else + # not using gcc + if test "$host_cpu" = ia64; then + # VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release + # chokes on -Wl,-G. The following line is correct: + shared_flag='-G' + else + if test "$aix_use_runtimelinking" = yes; then + shared_flag='${wl}-G' + else + shared_flag='${wl}-bM:SRE' + fi + fi + fi + + export_dynamic_flag_spec_CXX='${wl}-bexpall' + # It seems that -bexpall does not export symbols beginning with + # underscore (_), so it is better to generate a list of symbols to + # export. + always_export_symbols_CXX=yes + if test "$aix_use_runtimelinking" = yes; then + # Warning - without using the other runtime loading flags (-brtl), + # -berok will link without error, but may produce a broken library. + allow_undefined_flag_CXX='-berok' + # Determine the default libpath from the value encoded in an empty + # executable. + if test "${lt_cv_aix_libpath+set}" = set; then + aix_libpath=$lt_cv_aix_libpath +else + if ${lt_cv_aix_libpath__CXX+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_link "$LINENO"; then : + + lt_aix_libpath_sed=' + /Import File Strings/,/^$/ { + /^0/ { + s/^0 *\([^ ]*\) *$/\1/ + p + } + }' + lt_cv_aix_libpath__CXX=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"` + # Check for a 64-bit object if we didn't find anything. + if test -z "$lt_cv_aix_libpath__CXX"; then + lt_cv_aix_libpath__CXX=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"` + fi +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext + if test -z "$lt_cv_aix_libpath__CXX"; then + lt_cv_aix_libpath__CXX="/usr/lib:/lib" + fi + +fi + + aix_libpath=$lt_cv_aix_libpath__CXX +fi + + hardcode_libdir_flag_spec_CXX='${wl}-blibpath:$libdir:'"$aix_libpath" + + archive_expsym_cmds_CXX='$CC -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then func_echo_all "${wl}${allow_undefined_flag}"; else :; fi` '"\${wl}$exp_sym_flag:\$export_symbols $shared_flag" + else + if test "$host_cpu" = ia64; then + hardcode_libdir_flag_spec_CXX='${wl}-R $libdir:/usr/lib:/lib' + allow_undefined_flag_CXX="-z nodefs" + archive_expsym_cmds_CXX="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$exp_sym_flag:\$export_symbols" + else + # Determine the default libpath from the value encoded in an + # empty executable. + if test "${lt_cv_aix_libpath+set}" = set; then + aix_libpath=$lt_cv_aix_libpath +else + if ${lt_cv_aix_libpath__CXX+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_link "$LINENO"; then : + + lt_aix_libpath_sed=' + /Import File Strings/,/^$/ { + /^0/ { + s/^0 *\([^ ]*\) *$/\1/ + p + } + }' + lt_cv_aix_libpath__CXX=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"` + # Check for a 64-bit object if we didn't find anything. + if test -z "$lt_cv_aix_libpath__CXX"; then + lt_cv_aix_libpath__CXX=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"` + fi +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext + if test -z "$lt_cv_aix_libpath__CXX"; then + lt_cv_aix_libpath__CXX="/usr/lib:/lib" + fi + +fi + + aix_libpath=$lt_cv_aix_libpath__CXX +fi + + hardcode_libdir_flag_spec_CXX='${wl}-blibpath:$libdir:'"$aix_libpath" + # Warning - without using the other run time loading flags, + # -berok will link without error, but may produce a broken library. + no_undefined_flag_CXX=' ${wl}-bernotok' + allow_undefined_flag_CXX=' ${wl}-berok' + if test "$with_gnu_ld" = yes; then + # We only use this code for GNU lds that support --whole-archive. + whole_archive_flag_spec_CXX='${wl}--whole-archive$convenience ${wl}--no-whole-archive' + else + # Exported symbols can be pulled into shared objects from archives + whole_archive_flag_spec_CXX='$convenience' + fi + archive_cmds_need_lc_CXX=yes + # This is similar to how AIX traditionally builds its shared + # libraries. + archive_expsym_cmds_CXX="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs ${wl}-bnoentry $compiler_flags ${wl}-bE:$export_symbols${allow_undefined_flag}~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$soname' + fi + fi + ;; + + beos*) + if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then + allow_undefined_flag_CXX=unsupported + # Joseph Beckenbach says some releases of gcc + # support --undefined. This deserves some investigation. FIXME + archive_cmds_CXX='$CC -nostart $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + else + ld_shlibs_CXX=no + fi + ;; + + chorus*) + case $cc_basename in + *) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + esac + ;; + + cygwin* | mingw* | pw32* | cegcc*) + case $GXX,$cc_basename in + ,cl* | no,cl*) + # Native MSVC + # hardcode_libdir_flag_spec is actually meaningless, as there is + # no search path for DLLs. + hardcode_libdir_flag_spec_CXX=' ' + allow_undefined_flag_CXX=unsupported + always_export_symbols_CXX=yes + file_list_spec_CXX='@' + # Tell ltmain to make .lib files, not .a files. + libext=lib + # Tell ltmain to make .dll files, not .so files. + shrext_cmds=".dll" + # FIXME: Setting linknames here is a bad hack. + archive_cmds_CXX='$CC -o $output_objdir/$soname $libobjs $compiler_flags $deplibs -Wl,-dll~linknames=' + archive_expsym_cmds_CXX='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then + $SED -n -e 's/\\\\\\\(.*\\\\\\\)/-link\\\ -EXPORT:\\\\\\\1/' -e '1\\\!p' < $export_symbols > $output_objdir/$soname.exp; + else + $SED -e 's/\\\\\\\(.*\\\\\\\)/-link\\\ -EXPORT:\\\\\\\1/' < $export_symbols > $output_objdir/$soname.exp; + fi~ + $CC -o $tool_output_objdir$soname $libobjs $compiler_flags $deplibs "@$tool_output_objdir$soname.exp" -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~ + linknames=' + # The linker will not automatically build a static lib if we build a DLL. + # _LT_TAGVAR(old_archive_from_new_cmds, CXX)='true' + enable_shared_with_static_runtimes_CXX=yes + # Don't use ranlib + old_postinstall_cmds_CXX='chmod 644 $oldlib' + postlink_cmds_CXX='lt_outputfile="@OUTPUT@"~ + lt_tool_outputfile="@TOOL_OUTPUT@"~ + case $lt_outputfile in + *.exe|*.EXE) ;; + *) + lt_outputfile="$lt_outputfile.exe" + lt_tool_outputfile="$lt_tool_outputfile.exe" + ;; + esac~ + func_to_tool_file "$lt_outputfile"~ + if test "$MANIFEST_TOOL" != ":" && test -f "$lt_outputfile.manifest"; then + $MANIFEST_TOOL -manifest "$lt_tool_outputfile.manifest" -outputresource:"$lt_tool_outputfile" || exit 1; + $RM "$lt_outputfile.manifest"; + fi' + ;; + *) + # g++ + # _LT_TAGVAR(hardcode_libdir_flag_spec, CXX) is actually meaningless, + # as there is no search path for DLLs. + hardcode_libdir_flag_spec_CXX='-L$libdir' + export_dynamic_flag_spec_CXX='${wl}--export-all-symbols' + allow_undefined_flag_CXX=unsupported + always_export_symbols_CXX=no + enable_shared_with_static_runtimes_CXX=yes + + if $LD --help 2>&1 | $GREP 'auto-import' > /dev/null; then + archive_cmds_CXX='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib' + # If the export-symbols file already is a .def file (1st line + # is EXPORTS), use it as is; otherwise, prepend... + archive_expsym_cmds_CXX='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then + cp $export_symbols $output_objdir/$soname.def; + else + echo EXPORTS > $output_objdir/$soname.def; + cat $export_symbols >> $output_objdir/$soname.def; + fi~ + $CC -shared -nostdlib $output_objdir/$soname.def $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib' + else + ld_shlibs_CXX=no + fi + ;; + esac + ;; + darwin* | rhapsody*) + + + archive_cmds_need_lc_CXX=no + hardcode_direct_CXX=no + hardcode_automatic_CXX=yes + hardcode_shlibpath_var_CXX=unsupported + if test "$lt_cv_ld_force_load" = "yes"; then + whole_archive_flag_spec_CXX='`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience ${wl}-force_load,$conv\"; done; func_echo_all \"$new_convenience\"`' + + else + whole_archive_flag_spec_CXX='' + fi + link_all_deplibs_CXX=yes + allow_undefined_flag_CXX="$_lt_dar_allow_undefined" + case $cc_basename in + ifort*) _lt_dar_can_shared=yes ;; + *) _lt_dar_can_shared=$GCC ;; + esac + if test "$_lt_dar_can_shared" = "yes"; then + output_verbose_link_cmd=func_echo_all + archive_cmds_CXX="\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring $_lt_dar_single_mod${_lt_dsymutil}" + module_cmds_CXX="\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags${_lt_dsymutil}" + archive_expsym_cmds_CXX="sed 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring ${_lt_dar_single_mod}${_lt_dar_export_syms}${_lt_dsymutil}" + module_expsym_cmds_CXX="sed -e 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags${_lt_dar_export_syms}${_lt_dsymutil}" + if test "$lt_cv_apple_cc_single_mod" != "yes"; then + archive_cmds_CXX="\$CC -r -keep_private_externs -nostdlib -o \${lib}-master.o \$libobjs~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \${lib}-master.o \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring${_lt_dsymutil}" + archive_expsym_cmds_CXX="sed 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC -r -keep_private_externs -nostdlib -o \${lib}-master.o \$libobjs~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \${lib}-master.o \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring${_lt_dar_export_syms}${_lt_dsymutil}" + fi + + else + ld_shlibs_CXX=no + fi + + ;; + + dgux*) + case $cc_basename in + ec++*) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + ghcx*) + # Green Hills C++ Compiler + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + *) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + esac + ;; + + freebsd2.*) + # C++ shared libraries reported to be fairly broken before + # switch to ELF + ld_shlibs_CXX=no + ;; + + freebsd-elf*) + archive_cmds_need_lc_CXX=no + ;; + + freebsd* | dragonfly*) + # FreeBSD 3 and later use GNU C++ and GNU ld with standard ELF + # conventions + ld_shlibs_CXX=yes + ;; + + haiku*) + archive_cmds_CXX='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + link_all_deplibs_CXX=yes + ;; + + hpux9*) + hardcode_libdir_flag_spec_CXX='${wl}+b ${wl}$libdir' + hardcode_libdir_separator_CXX=: + export_dynamic_flag_spec_CXX='${wl}-E' + hardcode_direct_CXX=yes + hardcode_minus_L_CXX=yes # Not in the search PATH, + # but as the default + # location of the library. + + case $cc_basename in + CC*) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + aCC*) + archive_cmds_CXX='$RM $output_objdir/$soname~$CC -b ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib' + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + # + # There doesn't appear to be a way to prevent this compiler from + # explicitly linking system object files so we need to strip them + # from the output so that they don't get included in the library + # dependencies. + output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | $EGREP "\-L"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"' + ;; + *) + if test "$GXX" = yes; then + archive_cmds_CXX='$RM $output_objdir/$soname~$CC -shared -nostdlib $pic_flag ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib' + else + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + fi + ;; + esac + ;; + + hpux10*|hpux11*) + if test $with_gnu_ld = no; then + hardcode_libdir_flag_spec_CXX='${wl}+b ${wl}$libdir' + hardcode_libdir_separator_CXX=: + + case $host_cpu in + hppa*64*|ia64*) + ;; + *) + export_dynamic_flag_spec_CXX='${wl}-E' + ;; + esac + fi + case $host_cpu in + hppa*64*|ia64*) + hardcode_direct_CXX=no + hardcode_shlibpath_var_CXX=no + ;; + *) + hardcode_direct_CXX=yes + hardcode_direct_absolute_CXX=yes + hardcode_minus_L_CXX=yes # Not in the search PATH, + # but as the default + # location of the library. + ;; + esac + + case $cc_basename in + CC*) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + aCC*) + case $host_cpu in + hppa*64*) + archive_cmds_CXX='$CC -b ${wl}+h ${wl}$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' + ;; + ia64*) + archive_cmds_CXX='$CC -b ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' + ;; + *) + archive_cmds_CXX='$CC -b ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' + ;; + esac + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + # + # There doesn't appear to be a way to prevent this compiler from + # explicitly linking system object files so we need to strip them + # from the output so that they don't get included in the library + # dependencies. + output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | $GREP "\-L"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"' + ;; + *) + if test "$GXX" = yes; then + if test $with_gnu_ld = no; then + case $host_cpu in + hppa*64*) + archive_cmds_CXX='$CC -shared -nostdlib -fPIC ${wl}+h ${wl}$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' + ;; + ia64*) + archive_cmds_CXX='$CC -shared -nostdlib $pic_flag ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' + ;; + *) + archive_cmds_CXX='$CC -shared -nostdlib $pic_flag ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' + ;; + esac + fi + else + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + fi + ;; + esac + ;; + + interix[3-9]*) + hardcode_direct_CXX=no + hardcode_shlibpath_var_CXX=no + hardcode_libdir_flag_spec_CXX='${wl}-rpath,$libdir' + export_dynamic_flag_spec_CXX='${wl}-E' + # Hack: On Interix 3.x, we cannot compile PIC because of a broken gcc. + # Instead, shared libraries are loaded at an image base (0x10000000 by + # default) and relocated if they conflict, which is a slow very memory + # consuming and fragmenting process. To avoid this, we pick a random, + # 256 KiB-aligned image base between 0x50000000 and 0x6FFC0000 at link + # time. Moving up from 0x10000000 also allows more sbrk(2) space. + archive_cmds_CXX='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib' + archive_expsym_cmds_CXX='sed "s,^,_," $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--retain-symbols-file,$output_objdir/$soname.expsym ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib' + ;; + irix5* | irix6*) + case $cc_basename in + CC*) + # SGI C++ + archive_cmds_CXX='$CC -shared -all -multigot $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib' + + # Archives containing C++ object files must be created using + # "CC -ar", where "CC" is the IRIX C++ compiler. This is + # necessary to make sure instantiated templates are included + # in the archive. + old_archive_cmds_CXX='$CC -ar -WR,-u -o $oldlib $oldobjs' + ;; + *) + if test "$GXX" = yes; then + if test "$with_gnu_ld" = no; then + archive_cmds_CXX='$CC -shared $pic_flag -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' + else + archive_cmds_CXX='$CC -shared $pic_flag -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` -o $lib' + fi + fi + link_all_deplibs_CXX=yes + ;; + esac + hardcode_libdir_flag_spec_CXX='${wl}-rpath ${wl}$libdir' + hardcode_libdir_separator_CXX=: + inherit_rpath_CXX=yes + ;; + + linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*) + case $cc_basename in + KCC*) + # Kuck and Associates, Inc. (KAI) C++ Compiler + + # KCC will only create a shared library if the output file + # ends with ".so" (or ".sl" for HP-UX), so rename the library + # to its proper name (with version) after linking. + archive_cmds_CXX='tempext=`echo $shared_ext | $SED -e '\''s/\([^()0-9A-Za-z{}]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib' + archive_expsym_cmds_CXX='tempext=`echo $shared_ext | $SED -e '\''s/\([^()0-9A-Za-z{}]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib ${wl}-retain-symbols-file,$export_symbols; mv \$templib $lib' + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + # + # There doesn't appear to be a way to prevent this compiler from + # explicitly linking system object files so we need to strip them + # from the output so that they don't get included in the library + # dependencies. + output_verbose_link_cmd='templist=`$CC $CFLAGS -v conftest.$objext -o libconftest$shared_ext 2>&1 | $GREP "ld"`; rm -f libconftest$shared_ext; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"' + + hardcode_libdir_flag_spec_CXX='${wl}-rpath,$libdir' + export_dynamic_flag_spec_CXX='${wl}--export-dynamic' + + # Archives containing C++ object files must be created using + # "CC -Bstatic", where "CC" is the KAI C++ compiler. + old_archive_cmds_CXX='$CC -Bstatic -o $oldlib $oldobjs' + ;; + icpc* | ecpc* ) + # Intel C++ + with_gnu_ld=yes + # version 8.0 and above of icpc choke on multiply defined symbols + # if we add $predep_objects and $postdep_objects, however 7.1 and + # earlier do not add the objects themselves. + case `$CC -V 2>&1` in + *"Version 7."*) + archive_cmds_CXX='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib' + archive_expsym_cmds_CXX='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + ;; + *) # Version 8.0 or newer + tmp_idyn= + case $host_cpu in + ia64*) tmp_idyn=' -i_dynamic';; + esac + archive_cmds_CXX='$CC -shared'"$tmp_idyn"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + archive_expsym_cmds_CXX='$CC -shared'"$tmp_idyn"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + ;; + esac + archive_cmds_need_lc_CXX=no + hardcode_libdir_flag_spec_CXX='${wl}-rpath,$libdir' + export_dynamic_flag_spec_CXX='${wl}--export-dynamic' + whole_archive_flag_spec_CXX='${wl}--whole-archive$convenience ${wl}--no-whole-archive' + ;; + pgCC* | pgcpp*) + # Portland Group C++ compiler + case `$CC -V` in + *pgCC\ [1-5].* | *pgcpp\ [1-5].*) + prelink_cmds_CXX='tpldir=Template.dir~ + rm -rf $tpldir~ + $CC --prelink_objects --instantiation_dir $tpldir $objs $libobjs $compile_deplibs~ + compile_command="$compile_command `find $tpldir -name \*.o | sort | $NL2SP`"' + old_archive_cmds_CXX='tpldir=Template.dir~ + rm -rf $tpldir~ + $CC --prelink_objects --instantiation_dir $tpldir $oldobjs$old_deplibs~ + $AR $AR_FLAGS $oldlib$oldobjs$old_deplibs `find $tpldir -name \*.o | sort | $NL2SP`~ + $RANLIB $oldlib' + archive_cmds_CXX='tpldir=Template.dir~ + rm -rf $tpldir~ + $CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~ + $CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | sort | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib' + archive_expsym_cmds_CXX='tpldir=Template.dir~ + rm -rf $tpldir~ + $CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~ + $CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | sort | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname ${wl}-retain-symbols-file ${wl}$export_symbols -o $lib' + ;; + *) # Version 6 and above use weak symbols + archive_cmds_CXX='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib' + archive_expsym_cmds_CXX='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname ${wl}-retain-symbols-file ${wl}$export_symbols -o $lib' + ;; + esac + + hardcode_libdir_flag_spec_CXX='${wl}--rpath ${wl}$libdir' + export_dynamic_flag_spec_CXX='${wl}--export-dynamic' + whole_archive_flag_spec_CXX='${wl}--whole-archive`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive' + ;; + cxx*) + # Compaq C++ + archive_cmds_CXX='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib' + archive_expsym_cmds_CXX='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib ${wl}-retain-symbols-file $wl$export_symbols' + + runpath_var=LD_RUN_PATH + hardcode_libdir_flag_spec_CXX='-rpath $libdir' + hardcode_libdir_separator_CXX=: + + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + # + # There doesn't appear to be a way to prevent this compiler from + # explicitly linking system object files so we need to strip them + # from the output so that they don't get included in the library + # dependencies. + output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "ld"`; templist=`func_echo_all "$templist" | $SED "s/\(^.*ld.*\)\( .*ld .*$\)/\1/"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "X$list" | $Xsed' + ;; + xl* | mpixl* | bgxl*) + # IBM XL 8.0 on PPC, with GNU ld + hardcode_libdir_flag_spec_CXX='${wl}-rpath ${wl}$libdir' + export_dynamic_flag_spec_CXX='${wl}--export-dynamic' + archive_cmds_CXX='$CC -qmkshrobj $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + if test "x$supports_anon_versioning" = xyes; then + archive_expsym_cmds_CXX='echo "{ global:" > $output_objdir/$libname.ver~ + cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~ + echo "local: *; };" >> $output_objdir/$libname.ver~ + $CC -qmkshrobj $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-version-script ${wl}$output_objdir/$libname.ver -o $lib' + fi + ;; + *) + case `$CC -V 2>&1 | sed 5q` in + *Sun\ C*) + # Sun C++ 5.9 + no_undefined_flag_CXX=' -zdefs' + archive_cmds_CXX='$CC -G${allow_undefined_flag} -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' + archive_expsym_cmds_CXX='$CC -G${allow_undefined_flag} -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-retain-symbols-file ${wl}$export_symbols' + hardcode_libdir_flag_spec_CXX='-R$libdir' + whole_archive_flag_spec_CXX='${wl}--whole-archive`new_convenience=; for conv in $convenience\"\"; do test -z \"$conv\" || new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive' + compiler_needs_object_CXX=yes + + # Not sure whether something based on + # $CC $CFLAGS -v conftest.$objext -o libconftest$shared_ext 2>&1 + # would be better. + output_verbose_link_cmd='func_echo_all' + + # Archives containing C++ object files must be created using + # "CC -xar", where "CC" is the Sun C++ compiler. This is + # necessary to make sure instantiated templates are included + # in the archive. + old_archive_cmds_CXX='$CC -xar -o $oldlib $oldobjs' + ;; + esac + ;; + esac + ;; + + lynxos*) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + + m88k*) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + + mvs*) + case $cc_basename in + cxx*) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + *) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + esac + ;; + + netbsd*) + if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then + archive_cmds_CXX='$LD -Bshareable -o $lib $predep_objects $libobjs $deplibs $postdep_objects $linker_flags' + wlarc= + hardcode_libdir_flag_spec_CXX='-R$libdir' + hardcode_direct_CXX=yes + hardcode_shlibpath_var_CXX=no + fi + # Workaround some broken pre-1.5 toolchains + output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP conftest.$objext | $SED -e "s:-lgcc -lc -lgcc::"' + ;; + + *nto* | *qnx*) + ld_shlibs_CXX=yes + ;; + + openbsd2*) + # C++ shared libraries are fairly broken + ld_shlibs_CXX=no + ;; + + openbsd*) + if test -f /usr/libexec/ld.so; then + hardcode_direct_CXX=yes + hardcode_shlibpath_var_CXX=no + hardcode_direct_absolute_CXX=yes + archive_cmds_CXX='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $lib' + hardcode_libdir_flag_spec_CXX='${wl}-rpath,$libdir' + if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then + archive_expsym_cmds_CXX='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-retain-symbols-file,$export_symbols -o $lib' + export_dynamic_flag_spec_CXX='${wl}-E' + whole_archive_flag_spec_CXX="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive' + fi + output_verbose_link_cmd=func_echo_all + else + ld_shlibs_CXX=no + fi + ;; + + osf3* | osf4* | osf5*) + case $cc_basename in + KCC*) + # Kuck and Associates, Inc. (KAI) C++ Compiler + + # KCC will only create a shared library if the output file + # ends with ".so" (or ".sl" for HP-UX), so rename the library + # to its proper name (with version) after linking. + archive_cmds_CXX='tempext=`echo $shared_ext | $SED -e '\''s/\([^()0-9A-Za-z{}]\)/\\\\\1/g'\''`; templib=`echo "$lib" | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib' + + hardcode_libdir_flag_spec_CXX='${wl}-rpath,$libdir' + hardcode_libdir_separator_CXX=: + + # Archives containing C++ object files must be created using + # the KAI C++ compiler. + case $host in + osf3*) old_archive_cmds_CXX='$CC -Bstatic -o $oldlib $oldobjs' ;; + *) old_archive_cmds_CXX='$CC -o $oldlib $oldobjs' ;; + esac + ;; + RCC*) + # Rational C++ 2.4.1 + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + cxx*) + case $host in + osf3*) + allow_undefined_flag_CXX=' ${wl}-expect_unresolved ${wl}\*' + archive_cmds_CXX='$CC -shared${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $soname `test -n "$verstring" && func_echo_all "${wl}-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib' + hardcode_libdir_flag_spec_CXX='${wl}-rpath ${wl}$libdir' + ;; + *) + allow_undefined_flag_CXX=' -expect_unresolved \*' + archive_cmds_CXX='$CC -shared${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib' + archive_expsym_cmds_CXX='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done~ + echo "-hidden">> $lib.exp~ + $CC -shared$allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname ${wl}-input ${wl}$lib.exp `test -n "$verstring" && $ECHO "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib~ + $RM $lib.exp' + hardcode_libdir_flag_spec_CXX='-rpath $libdir' + ;; + esac + + hardcode_libdir_separator_CXX=: + + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + # + # There doesn't appear to be a way to prevent this compiler from + # explicitly linking system object files so we need to strip them + # from the output so that they don't get included in the library + # dependencies. + output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "ld" | $GREP -v "ld:"`; templist=`func_echo_all "$templist" | $SED "s/\(^.*ld.*\)\( .*ld.*$\)/\1/"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"' + ;; + *) + if test "$GXX" = yes && test "$with_gnu_ld" = no; then + allow_undefined_flag_CXX=' ${wl}-expect_unresolved ${wl}\*' + case $host in + osf3*) + archive_cmds_CXX='$CC -shared -nostdlib ${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' + ;; + *) + archive_cmds_CXX='$CC -shared $pic_flag -nostdlib ${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-msym ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' + ;; + esac + + hardcode_libdir_flag_spec_CXX='${wl}-rpath ${wl}$libdir' + hardcode_libdir_separator_CXX=: + + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"' + + else + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + fi + ;; + esac + ;; + + psos*) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + + sunos4*) + case $cc_basename in + CC*) + # Sun C++ 4.x + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + lcc*) + # Lucid + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + *) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + esac + ;; + + solaris*) + case $cc_basename in + CC* | sunCC*) + # Sun C++ 4.2, 5.x and Centerline C++ + archive_cmds_need_lc_CXX=yes + no_undefined_flag_CXX=' -zdefs' + archive_cmds_CXX='$CC -G${allow_undefined_flag} -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' + archive_expsym_cmds_CXX='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~ + $CC -G${allow_undefined_flag} ${wl}-M ${wl}$lib.exp -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp' + + hardcode_libdir_flag_spec_CXX='-R$libdir' + hardcode_shlibpath_var_CXX=no + case $host_os in + solaris2.[0-5] | solaris2.[0-5].*) ;; + *) + # The compiler driver will combine and reorder linker options, + # but understands `-z linker_flag'. + # Supported since Solaris 2.6 (maybe 2.5.1?) + whole_archive_flag_spec_CXX='-z allextract$convenience -z defaultextract' + ;; + esac + link_all_deplibs_CXX=yes + + output_verbose_link_cmd='func_echo_all' + + # Archives containing C++ object files must be created using + # "CC -xar", where "CC" is the Sun C++ compiler. This is + # necessary to make sure instantiated templates are included + # in the archive. + old_archive_cmds_CXX='$CC -xar -o $oldlib $oldobjs' + ;; + gcx*) + # Green Hills C++ Compiler + archive_cmds_CXX='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib' + + # The C++ compiler must be used to create the archive. + old_archive_cmds_CXX='$CC $LDFLAGS -archive -o $oldlib $oldobjs' + ;; + *) + # GNU C++ compiler with Solaris linker + if test "$GXX" = yes && test "$with_gnu_ld" = no; then + no_undefined_flag_CXX=' ${wl}-z ${wl}defs' + if $CC --version | $GREP -v '^2\.7' > /dev/null; then + archive_cmds_CXX='$CC -shared $pic_flag -nostdlib $LDFLAGS $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib' + archive_expsym_cmds_CXX='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~ + $CC -shared $pic_flag -nostdlib ${wl}-M $wl$lib.exp -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp' + + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"' + else + # g++ 2.7 appears to require `-G' NOT `-shared' on this + # platform. + archive_cmds_CXX='$CC -G -nostdlib $LDFLAGS $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib' + archive_expsym_cmds_CXX='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~ + $CC -G -nostdlib ${wl}-M $wl$lib.exp -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp' + + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + output_verbose_link_cmd='$CC -G $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"' + fi + + hardcode_libdir_flag_spec_CXX='${wl}-R $wl$libdir' + case $host_os in + solaris2.[0-5] | solaris2.[0-5].*) ;; + *) + whole_archive_flag_spec_CXX='${wl}-z ${wl}allextract$convenience ${wl}-z ${wl}defaultextract' + ;; + esac + fi + ;; + esac + ;; + + sysv4*uw2* | sysv5OpenUNIX* | sysv5UnixWare7.[01].[10]* | unixware7* | sco3.2v5.0.[024]*) + no_undefined_flag_CXX='${wl}-z,text' + archive_cmds_need_lc_CXX=no + hardcode_shlibpath_var_CXX=no + runpath_var='LD_RUN_PATH' + + case $cc_basename in + CC*) + archive_cmds_CXX='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + archive_expsym_cmds_CXX='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + ;; + *) + archive_cmds_CXX='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + archive_expsym_cmds_CXX='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + ;; + esac + ;; + + sysv5* | sco3.2v5* | sco5v6*) + # Note: We can NOT use -z defs as we might desire, because we do not + # link with -lc, and that would cause any symbols used from libc to + # always be unresolved, which means just about no library would + # ever link correctly. If we're not using GNU ld we use -z text + # though, which does catch some bad symbols but isn't as heavy-handed + # as -z defs. + no_undefined_flag_CXX='${wl}-z,text' + allow_undefined_flag_CXX='${wl}-z,nodefs' + archive_cmds_need_lc_CXX=no + hardcode_shlibpath_var_CXX=no + hardcode_libdir_flag_spec_CXX='${wl}-R,$libdir' + hardcode_libdir_separator_CXX=':' + link_all_deplibs_CXX=yes + export_dynamic_flag_spec_CXX='${wl}-Bexport' + runpath_var='LD_RUN_PATH' + + case $cc_basename in + CC*) + archive_cmds_CXX='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + archive_expsym_cmds_CXX='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + old_archive_cmds_CXX='$CC -Tprelink_objects $oldobjs~ + '"$old_archive_cmds_CXX" + reload_cmds_CXX='$CC -Tprelink_objects $reload_objs~ + '"$reload_cmds_CXX" + ;; + *) + archive_cmds_CXX='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + archive_expsym_cmds_CXX='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + ;; + esac + ;; + + tandem*) + case $cc_basename in + NCC*) + # NonStop-UX NCC 3.20 + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + *) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + esac + ;; + + vxworks*) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + + *) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + esac + + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ld_shlibs_CXX" >&5 +$as_echo "$ld_shlibs_CXX" >&6; } + test "$ld_shlibs_CXX" = no && can_build_shared=no + + GCC_CXX="$GXX" + LD_CXX="$LD" + + ## CAVEAT EMPTOR: + ## There is no encapsulation within the following macros, do not change + ## the running order or otherwise move them around unless you know exactly + ## what you are doing... + # Dependencies to place before and after the object being linked: +predep_objects_CXX= +postdep_objects_CXX= +predeps_CXX= +postdeps_CXX= +compiler_lib_search_path_CXX= + +cat > conftest.$ac_ext <<_LT_EOF +class Foo +{ +public: + Foo (void) { a = 0; } +private: + int a; +}; +_LT_EOF + + +_lt_libdeps_save_CFLAGS=$CFLAGS +case "$CC $CFLAGS " in #( +*\ -flto*\ *) CFLAGS="$CFLAGS -fno-lto" ;; +*\ -fwhopr*\ *) CFLAGS="$CFLAGS -fno-whopr" ;; +*\ -fuse-linker-plugin*\ *) CFLAGS="$CFLAGS -fno-use-linker-plugin" ;; +esac + +if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 + (eval $ac_compile) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then + # Parse the compiler output and extract the necessary + # objects, libraries and library flags. + + # Sentinel used to keep track of whether or not we are before + # the conftest object file. + pre_test_object_deps_done=no + + for p in `eval "$output_verbose_link_cmd"`; do + case ${prev}${p} in + + -L* | -R* | -l*) + # Some compilers place space between "-{L,R}" and the path. + # Remove the space. + if test $p = "-L" || + test $p = "-R"; then + prev=$p + continue + fi + + # Expand the sysroot to ease extracting the directories later. + if test -z "$prev"; then + case $p in + -L*) func_stripname_cnf '-L' '' "$p"; prev=-L; p=$func_stripname_result ;; + -R*) func_stripname_cnf '-R' '' "$p"; prev=-R; p=$func_stripname_result ;; + -l*) func_stripname_cnf '-l' '' "$p"; prev=-l; p=$func_stripname_result ;; + esac + fi + case $p in + =*) func_stripname_cnf '=' '' "$p"; p=$lt_sysroot$func_stripname_result ;; + esac + if test "$pre_test_object_deps_done" = no; then + case ${prev} in + -L | -R) + # Internal compiler library paths should come after those + # provided the user. The postdeps already come after the + # user supplied libs so there is no need to process them. + if test -z "$compiler_lib_search_path_CXX"; then + compiler_lib_search_path_CXX="${prev}${p}" + else + compiler_lib_search_path_CXX="${compiler_lib_search_path_CXX} ${prev}${p}" + fi + ;; + # The "-l" case would never come before the object being + # linked, so don't bother handling this case. + esac + else + if test -z "$postdeps_CXX"; then + postdeps_CXX="${prev}${p}" + else + postdeps_CXX="${postdeps_CXX} ${prev}${p}" + fi + fi + prev= + ;; + + *.lto.$objext) ;; # Ignore GCC LTO objects + *.$objext) + # This assumes that the test object file only shows up + # once in the compiler output. + if test "$p" = "conftest.$objext"; then + pre_test_object_deps_done=yes + continue + fi + + if test "$pre_test_object_deps_done" = no; then + if test -z "$predep_objects_CXX"; then + predep_objects_CXX="$p" + else + predep_objects_CXX="$predep_objects_CXX $p" + fi + else + if test -z "$postdep_objects_CXX"; then + postdep_objects_CXX="$p" + else + postdep_objects_CXX="$postdep_objects_CXX $p" + fi + fi + ;; + + *) ;; # Ignore the rest. + + esac + done + + # Clean up. + rm -f a.out a.exe +else + echo "libtool.m4: error: problem compiling CXX test program" +fi + +$RM -f confest.$objext +CFLAGS=$_lt_libdeps_save_CFLAGS + +# PORTME: override above test on systems where it is broken +case $host_os in +interix[3-9]*) + # Interix 3.5 installs completely hosed .la files for C++, so rather than + # hack all around it, let's just trust "g++" to DTRT. + predep_objects_CXX= + postdep_objects_CXX= + postdeps_CXX= + ;; + +linux*) + case `$CC -V 2>&1 | sed 5q` in + *Sun\ C*) + # Sun C++ 5.9 + + # The more standards-conforming stlport4 library is + # incompatible with the Cstd library. Avoid specifying + # it if it's in CXXFLAGS. Ignore libCrun as + # -library=stlport4 depends on it. + case " $CXX $CXXFLAGS " in + *" -library=stlport4 "*) + solaris_use_stlport4=yes + ;; + esac + + if test "$solaris_use_stlport4" != yes; then + postdeps_CXX='-library=Cstd -library=Crun' + fi + ;; + esac + ;; + +solaris*) + case $cc_basename in + CC* | sunCC*) + # The more standards-conforming stlport4 library is + # incompatible with the Cstd library. Avoid specifying + # it if it's in CXXFLAGS. Ignore libCrun as + # -library=stlport4 depends on it. + case " $CXX $CXXFLAGS " in + *" -library=stlport4 "*) + solaris_use_stlport4=yes + ;; + esac + + # Adding this requires a known-good setup of shared libraries for + # Sun compiler versions before 5.6, else PIC objects from an old + # archive will be linked into the output, leading to subtle bugs. + if test "$solaris_use_stlport4" != yes; then + postdeps_CXX='-library=Cstd -library=Crun' + fi + ;; + esac + ;; +esac + + +case " $postdeps_CXX " in +*" -lc "*) archive_cmds_need_lc_CXX=no ;; +esac + compiler_lib_search_dirs_CXX= +if test -n "${compiler_lib_search_path_CXX}"; then + compiler_lib_search_dirs_CXX=`echo " ${compiler_lib_search_path_CXX}" | ${SED} -e 's! -L! !g' -e 's!^ !!'` +fi + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + lt_prog_compiler_wl_CXX= +lt_prog_compiler_pic_CXX= +lt_prog_compiler_static_CXX= + + + # C++ specific cases for pic, static, wl, etc. + if test "$GXX" = yes; then + lt_prog_compiler_wl_CXX='-Wl,' + lt_prog_compiler_static_CXX='-static' + + case $host_os in + aix*) + # All AIX code is PIC. + if test "$host_cpu" = ia64; then + # AIX 5 now supports IA64 processor + lt_prog_compiler_static_CXX='-Bstatic' + fi + ;; + + amigaos*) + case $host_cpu in + powerpc) + # see comment about AmigaOS4 .so support + lt_prog_compiler_pic_CXX='-fPIC' + ;; + m68k) + # FIXME: we need at least 68020 code to build shared libraries, but + # adding the `-m68020' flag to GCC prevents building anything better, + # like `-m68040'. + lt_prog_compiler_pic_CXX='-m68020 -resident32 -malways-restore-a4' + ;; + esac + ;; + + beos* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*) + # PIC is the default for these OSes. + ;; + mingw* | cygwin* | os2* | pw32* | cegcc*) + # This hack is so that the source file can tell whether it is being + # built for inclusion in a dll (and should export symbols for example). + # Although the cygwin gcc ignores -fPIC, still need this for old-style + # (--disable-auto-import) libraries + lt_prog_compiler_pic_CXX='-DDLL_EXPORT' + ;; + darwin* | rhapsody*) + # PIC is the default on this platform + # Common symbols not allowed in MH_DYLIB files + lt_prog_compiler_pic_CXX='-fno-common' + ;; + *djgpp*) + # DJGPP does not support shared libraries at all + lt_prog_compiler_pic_CXX= + ;; + haiku*) + # PIC is the default for Haiku. + # The "-static" flag exists, but is broken. + lt_prog_compiler_static_CXX= + ;; + interix[3-9]*) + # Interix 3.x gcc -fpic/-fPIC options generate broken code. + # Instead, we relocate shared libraries at runtime. + ;; + sysv4*MP*) + if test -d /usr/nec; then + lt_prog_compiler_pic_CXX=-Kconform_pic + fi + ;; + hpux*) + # PIC is the default for 64-bit PA HP-UX, but not for 32-bit + # PA HP-UX. On IA64 HP-UX, PIC is the default but the pic flag + # sets the default TLS model and affects inlining. + case $host_cpu in + hppa*64*) + ;; + *) + lt_prog_compiler_pic_CXX='-fPIC' + ;; + esac + ;; + *qnx* | *nto*) + # QNX uses GNU C++, but need to define -shared option too, otherwise + # it will coredump. + lt_prog_compiler_pic_CXX='-fPIC -shared' + ;; + *) + lt_prog_compiler_pic_CXX='-fPIC' + ;; + esac + else + case $host_os in + aix[4-9]*) + # All AIX code is PIC. + if test "$host_cpu" = ia64; then + # AIX 5 now supports IA64 processor + lt_prog_compiler_static_CXX='-Bstatic' + else + lt_prog_compiler_static_CXX='-bnso -bI:/lib/syscalls.exp' + fi + ;; + chorus*) + case $cc_basename in + cxch68*) + # Green Hills C++ Compiler + # _LT_TAGVAR(lt_prog_compiler_static, CXX)="--no_auto_instantiation -u __main -u __premain -u _abort -r $COOL_DIR/lib/libOrb.a $MVME_DIR/lib/CC/libC.a $MVME_DIR/lib/classix/libcx.s.a" + ;; + esac + ;; + mingw* | cygwin* | os2* | pw32* | cegcc*) + # This hack is so that the source file can tell whether it is being + # built for inclusion in a dll (and should export symbols for example). + lt_prog_compiler_pic_CXX='-DDLL_EXPORT' + ;; + dgux*) + case $cc_basename in + ec++*) + lt_prog_compiler_pic_CXX='-KPIC' + ;; + ghcx*) + # Green Hills C++ Compiler + lt_prog_compiler_pic_CXX='-pic' + ;; + *) + ;; + esac + ;; + freebsd* | dragonfly*) + # FreeBSD uses GNU C++ + ;; + hpux9* | hpux10* | hpux11*) + case $cc_basename in + CC*) + lt_prog_compiler_wl_CXX='-Wl,' + lt_prog_compiler_static_CXX='${wl}-a ${wl}archive' + if test "$host_cpu" != ia64; then + lt_prog_compiler_pic_CXX='+Z' + fi + ;; + aCC*) + lt_prog_compiler_wl_CXX='-Wl,' + lt_prog_compiler_static_CXX='${wl}-a ${wl}archive' + case $host_cpu in + hppa*64*|ia64*) + # +Z the default + ;; + *) + lt_prog_compiler_pic_CXX='+Z' + ;; + esac + ;; + *) + ;; + esac + ;; + interix*) + # This is c89, which is MS Visual C++ (no shared libs) + # Anyone wants to do a port? + ;; + irix5* | irix6* | nonstopux*) + case $cc_basename in + CC*) + lt_prog_compiler_wl_CXX='-Wl,' + lt_prog_compiler_static_CXX='-non_shared' + # CC pic flag -KPIC is the default. + ;; + *) + ;; + esac + ;; + linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*) + case $cc_basename in + KCC*) + # KAI C++ Compiler + lt_prog_compiler_wl_CXX='--backend -Wl,' + lt_prog_compiler_pic_CXX='-fPIC' + ;; + ecpc* ) + # old Intel C++ for x86_64 which still supported -KPIC. + lt_prog_compiler_wl_CXX='-Wl,' + lt_prog_compiler_pic_CXX='-KPIC' + lt_prog_compiler_static_CXX='-static' + ;; + icpc* ) + # Intel C++, used to be incompatible with GCC. + # ICC 10 doesn't accept -KPIC any more. + lt_prog_compiler_wl_CXX='-Wl,' + lt_prog_compiler_pic_CXX='-fPIC' + lt_prog_compiler_static_CXX='-static' + ;; + pgCC* | pgcpp*) + # Portland Group C++ compiler + lt_prog_compiler_wl_CXX='-Wl,' + lt_prog_compiler_pic_CXX='-fpic' + lt_prog_compiler_static_CXX='-Bstatic' + ;; + cxx*) + # Compaq C++ + # Make sure the PIC flag is empty. It appears that all Alpha + # Linux and Compaq Tru64 Unix objects are PIC. + lt_prog_compiler_pic_CXX= + lt_prog_compiler_static_CXX='-non_shared' + ;; + xlc* | xlC* | bgxl[cC]* | mpixl[cC]*) + # IBM XL 8.0, 9.0 on PPC and BlueGene + lt_prog_compiler_wl_CXX='-Wl,' + lt_prog_compiler_pic_CXX='-qpic' + lt_prog_compiler_static_CXX='-qstaticlink' + ;; + *) + case `$CC -V 2>&1 | sed 5q` in + *Sun\ C*) + # Sun C++ 5.9 + lt_prog_compiler_pic_CXX='-KPIC' + lt_prog_compiler_static_CXX='-Bstatic' + lt_prog_compiler_wl_CXX='-Qoption ld ' + ;; + esac + ;; + esac + ;; + lynxos*) + ;; + m88k*) + ;; + mvs*) + case $cc_basename in + cxx*) + lt_prog_compiler_pic_CXX='-W c,exportall' + ;; + *) + ;; + esac + ;; + netbsd* | netbsdelf*-gnu) + ;; + *qnx* | *nto*) + # QNX uses GNU C++, but need to define -shared option too, otherwise + # it will coredump. + lt_prog_compiler_pic_CXX='-fPIC -shared' + ;; + osf3* | osf4* | osf5*) + case $cc_basename in + KCC*) + lt_prog_compiler_wl_CXX='--backend -Wl,' + ;; + RCC*) + # Rational C++ 2.4.1 + lt_prog_compiler_pic_CXX='-pic' + ;; + cxx*) + # Digital/Compaq C++ + lt_prog_compiler_wl_CXX='-Wl,' + # Make sure the PIC flag is empty. It appears that all Alpha + # Linux and Compaq Tru64 Unix objects are PIC. + lt_prog_compiler_pic_CXX= + lt_prog_compiler_static_CXX='-non_shared' + ;; + *) + ;; + esac + ;; + psos*) + ;; + solaris*) + case $cc_basename in + CC* | sunCC*) + # Sun C++ 4.2, 5.x and Centerline C++ + lt_prog_compiler_pic_CXX='-KPIC' + lt_prog_compiler_static_CXX='-Bstatic' + lt_prog_compiler_wl_CXX='-Qoption ld ' + ;; + gcx*) + # Green Hills C++ Compiler + lt_prog_compiler_pic_CXX='-PIC' + ;; + *) + ;; + esac + ;; + sunos4*) + case $cc_basename in + CC*) + # Sun C++ 4.x + lt_prog_compiler_pic_CXX='-pic' + lt_prog_compiler_static_CXX='-Bstatic' + ;; + lcc*) + # Lucid + lt_prog_compiler_pic_CXX='-pic' + ;; + *) + ;; + esac + ;; + sysv5* | unixware* | sco3.2v5* | sco5v6* | OpenUNIX*) + case $cc_basename in + CC*) + lt_prog_compiler_wl_CXX='-Wl,' + lt_prog_compiler_pic_CXX='-KPIC' + lt_prog_compiler_static_CXX='-Bstatic' + ;; + esac + ;; + tandem*) + case $cc_basename in + NCC*) + # NonStop-UX NCC 3.20 + lt_prog_compiler_pic_CXX='-KPIC' + ;; + *) + ;; + esac + ;; + vxworks*) + ;; + *) + lt_prog_compiler_can_build_shared_CXX=no + ;; + esac + fi + +case $host_os in + # For platforms which do not support PIC, -DPIC is meaningless: + *djgpp*) + lt_prog_compiler_pic_CXX= + ;; + *) + lt_prog_compiler_pic_CXX="$lt_prog_compiler_pic_CXX -DPIC" + ;; +esac + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $compiler option to produce PIC" >&5 +$as_echo_n "checking for $compiler option to produce PIC... " >&6; } +if ${lt_cv_prog_compiler_pic_CXX+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_prog_compiler_pic_CXX=$lt_prog_compiler_pic_CXX +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic_CXX" >&5 +$as_echo "$lt_cv_prog_compiler_pic_CXX" >&6; } +lt_prog_compiler_pic_CXX=$lt_cv_prog_compiler_pic_CXX + +# +# Check to make sure the PIC flag actually works. +# +if test -n "$lt_prog_compiler_pic_CXX"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler PIC flag $lt_prog_compiler_pic_CXX works" >&5 +$as_echo_n "checking if $compiler PIC flag $lt_prog_compiler_pic_CXX works... " >&6; } +if ${lt_cv_prog_compiler_pic_works_CXX+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_prog_compiler_pic_works_CXX=no + ac_outfile=conftest.$ac_objext + echo "$lt_simple_compile_test_code" > conftest.$ac_ext + lt_compiler_flag="$lt_prog_compiler_pic_CXX -DPIC" + # Insert the option either (1) after the last *FLAGS variable, or + # (2) before a word containing "conftest.", or (3) at the end. + # Note that $ac_compile itself does not contain backslashes and begins + # with a dollar sign (not a hyphen), so the echo should work correctly. + # The option is referenced via a variable to avoid confusing sed. + lt_compile=`echo "$ac_compile" | $SED \ + -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \ + -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \ + -e 's:$: $lt_compiler_flag:'` + (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&5) + (eval "$lt_compile" 2>conftest.err) + ac_status=$? + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + if (exit $ac_status) && test -s "$ac_outfile"; then + # The compiler can only warn and ignore the option if not recognized + # So say no if there are warnings other than the usual output. + $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' >conftest.exp + $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2 + if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then + lt_cv_prog_compiler_pic_works_CXX=yes + fi + fi + $RM conftest* + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic_works_CXX" >&5 +$as_echo "$lt_cv_prog_compiler_pic_works_CXX" >&6; } + +if test x"$lt_cv_prog_compiler_pic_works_CXX" = xyes; then + case $lt_prog_compiler_pic_CXX in + "" | " "*) ;; + *) lt_prog_compiler_pic_CXX=" $lt_prog_compiler_pic_CXX" ;; + esac +else + lt_prog_compiler_pic_CXX= + lt_prog_compiler_can_build_shared_CXX=no +fi + +fi + + + + + +# +# Check to make sure the static flag actually works. +# +wl=$lt_prog_compiler_wl_CXX eval lt_tmp_static_flag=\"$lt_prog_compiler_static_CXX\" +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler static flag $lt_tmp_static_flag works" >&5 +$as_echo_n "checking if $compiler static flag $lt_tmp_static_flag works... " >&6; } +if ${lt_cv_prog_compiler_static_works_CXX+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_prog_compiler_static_works_CXX=no + save_LDFLAGS="$LDFLAGS" + LDFLAGS="$LDFLAGS $lt_tmp_static_flag" + echo "$lt_simple_link_test_code" > conftest.$ac_ext + if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then + # The linker can only warn and ignore the option if not recognized + # So say no if there are warnings + if test -s conftest.err; then + # Append any errors to the config.log. + cat conftest.err 1>&5 + $ECHO "$_lt_linker_boilerplate" | $SED '/^$/d' > conftest.exp + $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2 + if diff conftest.exp conftest.er2 >/dev/null; then + lt_cv_prog_compiler_static_works_CXX=yes + fi + else + lt_cv_prog_compiler_static_works_CXX=yes + fi + fi + $RM -r conftest* + LDFLAGS="$save_LDFLAGS" + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_static_works_CXX" >&5 +$as_echo "$lt_cv_prog_compiler_static_works_CXX" >&6; } + +if test x"$lt_cv_prog_compiler_static_works_CXX" = xyes; then + : +else + lt_prog_compiler_static_CXX= +fi + + + + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -c -o file.$ac_objext" >&5 +$as_echo_n "checking if $compiler supports -c -o file.$ac_objext... " >&6; } +if ${lt_cv_prog_compiler_c_o_CXX+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_prog_compiler_c_o_CXX=no + $RM -r conftest 2>/dev/null + mkdir conftest + cd conftest + mkdir out + echo "$lt_simple_compile_test_code" > conftest.$ac_ext + + lt_compiler_flag="-o out/conftest2.$ac_objext" + # Insert the option either (1) after the last *FLAGS variable, or + # (2) before a word containing "conftest.", or (3) at the end. + # Note that $ac_compile itself does not contain backslashes and begins + # with a dollar sign (not a hyphen), so the echo should work correctly. + lt_compile=`echo "$ac_compile" | $SED \ + -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \ + -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \ + -e 's:$: $lt_compiler_flag:'` + (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&5) + (eval "$lt_compile" 2>out/conftest.err) + ac_status=$? + cat out/conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + if (exit $ac_status) && test -s out/conftest2.$ac_objext + then + # The compiler can only warn and ignore the option if not recognized + # So say no if there are warnings + $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' > out/conftest.exp + $SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2 + if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then + lt_cv_prog_compiler_c_o_CXX=yes + fi + fi + chmod u+w . 2>&5 + $RM conftest* + # SGI C++ compiler will create directory out/ii_files/ for + # template instantiation + test -d out/ii_files && $RM out/ii_files/* && rmdir out/ii_files + $RM out/* && rmdir out + cd .. + $RM -r conftest + $RM conftest* + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o_CXX" >&5 +$as_echo "$lt_cv_prog_compiler_c_o_CXX" >&6; } + + + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -c -o file.$ac_objext" >&5 +$as_echo_n "checking if $compiler supports -c -o file.$ac_objext... " >&6; } +if ${lt_cv_prog_compiler_c_o_CXX+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_prog_compiler_c_o_CXX=no + $RM -r conftest 2>/dev/null + mkdir conftest + cd conftest + mkdir out + echo "$lt_simple_compile_test_code" > conftest.$ac_ext + + lt_compiler_flag="-o out/conftest2.$ac_objext" + # Insert the option either (1) after the last *FLAGS variable, or + # (2) before a word containing "conftest.", or (3) at the end. + # Note that $ac_compile itself does not contain backslashes and begins + # with a dollar sign (not a hyphen), so the echo should work correctly. + lt_compile=`echo "$ac_compile" | $SED \ + -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \ + -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \ + -e 's:$: $lt_compiler_flag:'` + (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&5) + (eval "$lt_compile" 2>out/conftest.err) + ac_status=$? + cat out/conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + if (exit $ac_status) && test -s out/conftest2.$ac_objext + then + # The compiler can only warn and ignore the option if not recognized + # So say no if there are warnings + $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' > out/conftest.exp + $SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2 + if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then + lt_cv_prog_compiler_c_o_CXX=yes + fi + fi + chmod u+w . 2>&5 + $RM conftest* + # SGI C++ compiler will create directory out/ii_files/ for + # template instantiation + test -d out/ii_files && $RM out/ii_files/* && rmdir out/ii_files + $RM out/* && rmdir out + cd .. + $RM -r conftest + $RM conftest* + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o_CXX" >&5 +$as_echo "$lt_cv_prog_compiler_c_o_CXX" >&6; } + + + + +hard_links="nottested" +if test "$lt_cv_prog_compiler_c_o_CXX" = no && test "$need_locks" != no; then + # do not overwrite the value of need_locks provided by the user + { $as_echo "$as_me:${as_lineno-$LINENO}: checking if we can lock with hard links" >&5 +$as_echo_n "checking if we can lock with hard links... " >&6; } + hard_links=yes + $RM conftest* + ln conftest.a conftest.b 2>/dev/null && hard_links=no + touch conftest.a + ln conftest.a conftest.b 2>&5 || hard_links=no + ln conftest.a conftest.b 2>/dev/null && hard_links=no + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $hard_links" >&5 +$as_echo "$hard_links" >&6; } + if test "$hard_links" = no; then + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&5 +$as_echo "$as_me: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&2;} + need_locks=warn + fi +else + need_locks=no +fi + + + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the $compiler linker ($LD) supports shared libraries" >&5 +$as_echo_n "checking whether the $compiler linker ($LD) supports shared libraries... " >&6; } + + export_symbols_cmds_CXX='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols' + exclude_expsyms_CXX='_GLOBAL_OFFSET_TABLE_|_GLOBAL__F[ID]_.*' + case $host_os in + aix[4-9]*) + # If we're using GNU nm, then we don't want the "-C" option. + # -C means demangle to AIX nm, but means don't demangle with GNU nm + # Also, AIX nm treats weak defined symbols like other global defined + # symbols, whereas GNU nm marks them as "W". + if $NM -V 2>&1 | $GREP 'GNU' > /dev/null; then + export_symbols_cmds_CXX='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W")) && (substr(\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols' + else + export_symbols_cmds_CXX='$NM -BCpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B")) && (substr(\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols' + fi + ;; + pw32*) + export_symbols_cmds_CXX="$ltdll_cmds" + ;; + cygwin* | mingw* | cegcc*) + case $cc_basename in + cl*) + exclude_expsyms_CXX='_NULL_IMPORT_DESCRIPTOR|_IMPORT_DESCRIPTOR_.*' + ;; + *) + export_symbols_cmds_CXX='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[BCDGRS][ ]/s/.*[ ]\([^ ]*\)/\1 DATA/;s/^.*[ ]__nm__\([^ ]*\)[ ][^ ]*/\1 DATA/;/^I[ ]/d;/^[AITW][ ]/s/.* //'\'' | sort | uniq > $export_symbols' + exclude_expsyms_CXX='[_]+GLOBAL_OFFSET_TABLE_|[_]+GLOBAL__[FID]_.*|[_]+head_[A-Za-z0-9_]+_dll|[A-Za-z0-9_]+_dll_iname' + ;; + esac + ;; + linux* | k*bsd*-gnu | gnu*) + link_all_deplibs_CXX=no + ;; + *) + export_symbols_cmds_CXX='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols' + ;; + esac + +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ld_shlibs_CXX" >&5 +$as_echo "$ld_shlibs_CXX" >&6; } +test "$ld_shlibs_CXX" = no && can_build_shared=no + +with_gnu_ld_CXX=$with_gnu_ld + + + + + + +# +# Do we need to explicitly link libc? +# +case "x$archive_cmds_need_lc_CXX" in +x|xyes) + # Assume -lc should be added + archive_cmds_need_lc_CXX=yes + + if test "$enable_shared" = yes && test "$GCC" = yes; then + case $archive_cmds_CXX in + *'~'*) + # FIXME: we may have to deal with multi-command sequences. + ;; + '$CC '*) + # Test whether the compiler implicitly links with -lc since on some + # systems, -lgcc has to come before -lc. If gcc already passes -lc + # to ld, don't add -lc before -lgcc. + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether -lc should be explicitly linked in" >&5 +$as_echo_n "checking whether -lc should be explicitly linked in... " >&6; } +if ${lt_cv_archive_cmds_need_lc_CXX+:} false; then : + $as_echo_n "(cached) " >&6 +else + $RM conftest* + echo "$lt_simple_compile_test_code" > conftest.$ac_ext + + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 + (eval $ac_compile) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } 2>conftest.err; then + soname=conftest + lib=conftest + libobjs=conftest.$ac_objext + deplibs= + wl=$lt_prog_compiler_wl_CXX + pic_flag=$lt_prog_compiler_pic_CXX + compiler_flags=-v + linker_flags=-v + verstring= + output_objdir=. + libname=conftest + lt_save_allow_undefined_flag=$allow_undefined_flag_CXX + allow_undefined_flag_CXX= + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$archive_cmds_CXX 2\>\&1 \| $GREP \" -lc \" \>/dev/null 2\>\&1\""; } >&5 + (eval $archive_cmds_CXX 2\>\&1 \| $GREP \" -lc \" \>/dev/null 2\>\&1) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } + then + lt_cv_archive_cmds_need_lc_CXX=no + else + lt_cv_archive_cmds_need_lc_CXX=yes + fi + allow_undefined_flag_CXX=$lt_save_allow_undefined_flag + else + cat conftest.err 1>&5 + fi + $RM conftest* + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_archive_cmds_need_lc_CXX" >&5 +$as_echo "$lt_cv_archive_cmds_need_lc_CXX" >&6; } + archive_cmds_need_lc_CXX=$lt_cv_archive_cmds_need_lc_CXX + ;; + esac + fi + ;; +esac + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking dynamic linker characteristics" >&5 +$as_echo_n "checking dynamic linker characteristics... " >&6; } + +library_names_spec= +libname_spec='lib$name' +soname_spec= +shrext_cmds=".so" +postinstall_cmds= +postuninstall_cmds= +finish_cmds= +finish_eval= +shlibpath_var= +shlibpath_overrides_runpath=unknown +version_type=none +dynamic_linker="$host_os ld.so" +sys_lib_dlsearch_path_spec="/lib /usr/lib" +need_lib_prefix=unknown +hardcode_into_libs=no + +# when you set need_version to no, make sure it does not cause -set_version +# flags to be left without arguments +need_version=unknown + +case $host_os in +aix3*) + version_type=linux # correct to gnu/linux during the next big refactor + library_names_spec='${libname}${release}${shared_ext}$versuffix $libname.a' + shlibpath_var=LIBPATH + + # AIX 3 has no versioning support, so we append a major version to the name. + soname_spec='${libname}${release}${shared_ext}$major' + ;; + +aix[4-9]*) + version_type=linux # correct to gnu/linux during the next big refactor + need_lib_prefix=no + need_version=no + hardcode_into_libs=yes + if test "$host_cpu" = ia64; then + # AIX 5 supports IA64 + library_names_spec='${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext}$versuffix $libname${shared_ext}' + shlibpath_var=LD_LIBRARY_PATH + else + # With GCC up to 2.95.x, collect2 would create an import file + # for dependence libraries. The import file would start with + # the line `#! .'. This would cause the generated library to + # depend on `.', always an invalid library. This was fixed in + # development snapshots of GCC prior to 3.0. + case $host_os in + aix4 | aix4.[01] | aix4.[01].*) + if { echo '#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 97)' + echo ' yes ' + echo '#endif'; } | ${CC} -E - | $GREP yes > /dev/null; then + : + else + can_build_shared=no + fi + ;; + esac + # AIX (on Power*) has no versioning support, so currently we can not hardcode correct + # soname into executable. Probably we can add versioning support to + # collect2, so additional links can be useful in future. + if test "$aix_use_runtimelinking" = yes; then + # If using run time linking (on AIX 4.2 or later) use lib.so + # instead of lib.a to let people know that these are not + # typical AIX shared libraries. + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + else + # We preserve .a as extension for shared libraries through AIX4.2 + # and later when we are not doing run time linking. + library_names_spec='${libname}${release}.a $libname.a' + soname_spec='${libname}${release}${shared_ext}$major' + fi + shlibpath_var=LIBPATH + fi + ;; + +amigaos*) + case $host_cpu in + powerpc) + # Since July 2007 AmigaOS4 officially supports .so libraries. + # When compiling the executable, add -use-dynld -Lsobjs: to the compileline. + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + ;; + m68k) + library_names_spec='$libname.ixlibrary $libname.a' + # Create ${libname}_ixlibrary.a entries in /sys/libs. + finish_eval='for lib in `ls $libdir/*.ixlibrary 2>/dev/null`; do libname=`func_echo_all "$lib" | $SED '\''s%^.*/\([^/]*\)\.ixlibrary$%\1%'\''`; test $RM /sys/libs/${libname}_ixlibrary.a; $show "cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a"; cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a || exit 1; done' + ;; + esac + ;; + +beos*) + library_names_spec='${libname}${shared_ext}' + dynamic_linker="$host_os ld.so" + shlibpath_var=LIBRARY_PATH + ;; + +bsdi[45]*) + version_type=linux # correct to gnu/linux during the next big refactor + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + finish_cmds='PATH="\$PATH:/sbin" ldconfig $libdir' + shlibpath_var=LD_LIBRARY_PATH + sys_lib_search_path_spec="/shlib /usr/lib /usr/X11/lib /usr/contrib/lib /lib /usr/local/lib" + sys_lib_dlsearch_path_spec="/shlib /usr/lib /usr/local/lib" + # the default ld.so.conf also contains /usr/contrib/lib and + # /usr/X11R6/lib (/usr/X11 is a link to /usr/X11R6), but let us allow + # libtool to hard-code these into programs + ;; + +cygwin* | mingw* | pw32* | cegcc*) + version_type=windows + shrext_cmds=".dll" + need_version=no + need_lib_prefix=no + + case $GCC,$cc_basename in + yes,*) + # gcc + library_names_spec='$libname.dll.a' + # DLL is installed to $(libdir)/../bin by postinstall_cmds + postinstall_cmds='base_file=`basename \${file}`~ + dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i; echo \$dlname'\''`~ + dldir=$destdir/`dirname \$dlpath`~ + test -d \$dldir || mkdir -p \$dldir~ + $install_prog $dir/$dlname \$dldir/$dlname~ + chmod a+x \$dldir/$dlname~ + if test -n '\''$stripme'\'' && test -n '\''$striplib'\''; then + eval '\''$striplib \$dldir/$dlname'\'' || exit \$?; + fi' + postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~ + dlpath=$dir/\$dldll~ + $RM \$dlpath' + shlibpath_overrides_runpath=yes + + case $host_os in + cygwin*) + # Cygwin DLLs use 'cyg' prefix rather than 'lib' + soname_spec='`echo ${libname} | sed -e 's/^lib/cyg/'``echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}' + + ;; + mingw* | cegcc*) + # MinGW DLLs use traditional 'lib' prefix + soname_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}' + ;; + pw32*) + # pw32 DLLs use 'pw' prefix rather than 'lib' + library_names_spec='`echo ${libname} | sed -e 's/^lib/pw/'``echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}' + ;; + esac + dynamic_linker='Win32 ld.exe' + ;; + + *,cl*) + # Native MSVC + libname_spec='$name' + soname_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}' + library_names_spec='${libname}.dll.lib' + + case $build_os in + mingw*) + sys_lib_search_path_spec= + lt_save_ifs=$IFS + IFS=';' + for lt_path in $LIB + do + IFS=$lt_save_ifs + # Let DOS variable expansion print the short 8.3 style file name. + lt_path=`cd "$lt_path" 2>/dev/null && cmd //C "for %i in (".") do @echo %~si"` + sys_lib_search_path_spec="$sys_lib_search_path_spec $lt_path" + done + IFS=$lt_save_ifs + # Convert to MSYS style. + sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | sed -e 's|\\\\|/|g' -e 's| \\([a-zA-Z]\\):| /\\1|g' -e 's|^ ||'` + ;; + cygwin*) + # Convert to unix form, then to dos form, then back to unix form + # but this time dos style (no spaces!) so that the unix form looks + # like /cygdrive/c/PROGRA~1:/cygdr... + sys_lib_search_path_spec=`cygpath --path --unix "$LIB"` + sys_lib_search_path_spec=`cygpath --path --dos "$sys_lib_search_path_spec" 2>/dev/null` + sys_lib_search_path_spec=`cygpath --path --unix "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"` + ;; + *) + sys_lib_search_path_spec="$LIB" + if $ECHO "$sys_lib_search_path_spec" | $GREP ';[c-zC-Z]:/' >/dev/null; then + # It is most probably a Windows format PATH. + sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'` + else + sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"` + fi + # FIXME: find the short name or the path components, as spaces are + # common. (e.g. "Program Files" -> "PROGRA~1") + ;; + esac + + # DLL is installed to $(libdir)/../bin by postinstall_cmds + postinstall_cmds='base_file=`basename \${file}`~ + dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i; echo \$dlname'\''`~ + dldir=$destdir/`dirname \$dlpath`~ + test -d \$dldir || mkdir -p \$dldir~ + $install_prog $dir/$dlname \$dldir/$dlname' + postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~ + dlpath=$dir/\$dldll~ + $RM \$dlpath' + shlibpath_overrides_runpath=yes + dynamic_linker='Win32 link.exe' + ;; + + *) + # Assume MSVC wrapper + library_names_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext} $libname.lib' + dynamic_linker='Win32 ld.exe' + ;; + esac + # FIXME: first we should search . and the directory the executable is in + shlibpath_var=PATH + ;; + +darwin* | rhapsody*) + dynamic_linker="$host_os dyld" + version_type=darwin + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${major}$shared_ext ${libname}$shared_ext' + soname_spec='${libname}${release}${major}$shared_ext' + shlibpath_overrides_runpath=yes + shlibpath_var=DYLD_LIBRARY_PATH + shrext_cmds='`test .$module = .yes && echo .so || echo .dylib`' + + sys_lib_dlsearch_path_spec='/usr/local/lib /lib /usr/lib' + ;; + +dgux*) + version_type=linux # correct to gnu/linux during the next big refactor + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname$shared_ext' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + ;; + +freebsd* | dragonfly*) + # DragonFly does not have aout. When/if they implement a new + # versioning mechanism, adjust this. + if test -x /usr/bin/objformat; then + objformat=`/usr/bin/objformat` + else + case $host_os in + freebsd[23].*) objformat=aout ;; + *) objformat=elf ;; + esac + fi + version_type=freebsd-$objformat + case $version_type in + freebsd-elf*) + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}' + need_version=no + need_lib_prefix=no + ;; + freebsd-*) + library_names_spec='${libname}${release}${shared_ext}$versuffix $libname${shared_ext}$versuffix' + need_version=yes + ;; + esac + shlibpath_var=LD_LIBRARY_PATH + case $host_os in + freebsd2.*) + shlibpath_overrides_runpath=yes + ;; + freebsd3.[01]* | freebsdelf3.[01]*) + shlibpath_overrides_runpath=yes + hardcode_into_libs=yes + ;; + freebsd3.[2-9]* | freebsdelf3.[2-9]* | \ + freebsd4.[0-5] | freebsdelf4.[0-5] | freebsd4.1.1 | freebsdelf4.1.1) + shlibpath_overrides_runpath=no + hardcode_into_libs=yes + ;; + *) # from 4.6 on, and DragonFly + shlibpath_overrides_runpath=yes + hardcode_into_libs=yes + ;; + esac + ;; + +haiku*) + version_type=linux # correct to gnu/linux during the next big refactor + need_lib_prefix=no + need_version=no + dynamic_linker="$host_os runtime_loader" + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}${major} ${libname}${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LIBRARY_PATH + shlibpath_overrides_runpath=yes + sys_lib_dlsearch_path_spec='/boot/home/config/lib /boot/common/lib /boot/system/lib' + hardcode_into_libs=yes + ;; + +hpux9* | hpux10* | hpux11*) + # Give a soname corresponding to the major version so that dld.sl refuses to + # link against other versions. + version_type=sunos + need_lib_prefix=no + need_version=no + case $host_cpu in + ia64*) + shrext_cmds='.so' + hardcode_into_libs=yes + dynamic_linker="$host_os dld.so" + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes # Unless +noenvvar is specified. + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + if test "X$HPUX_IA64_MODE" = X32; then + sys_lib_search_path_spec="/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib" + else + sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64" + fi + sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec + ;; + hppa*64*) + shrext_cmds='.sl' + hardcode_into_libs=yes + dynamic_linker="$host_os dld.sl" + shlibpath_var=LD_LIBRARY_PATH # How should we handle SHLIB_PATH + shlibpath_overrides_runpath=yes # Unless +noenvvar is specified. + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + sys_lib_search_path_spec="/usr/lib/pa20_64 /usr/ccs/lib/pa20_64" + sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec + ;; + *) + shrext_cmds='.sl' + dynamic_linker="$host_os dld.sl" + shlibpath_var=SHLIB_PATH + shlibpath_overrides_runpath=no # +s is required to enable SHLIB_PATH + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + ;; + esac + # HP-UX runs *really* slowly unless shared libraries are mode 555, ... + postinstall_cmds='chmod 555 $lib' + # or fails outright, so override atomically: + install_override_mode=555 + ;; + +interix[3-9]*) + version_type=linux # correct to gnu/linux during the next big refactor + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + dynamic_linker='Interix 3.x ld.so.1 (PE, like ELF)' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + hardcode_into_libs=yes + ;; + +irix5* | irix6* | nonstopux*) + case $host_os in + nonstopux*) version_type=nonstopux ;; + *) + if test "$lt_cv_prog_gnu_ld" = yes; then + version_type=linux # correct to gnu/linux during the next big refactor + else + version_type=irix + fi ;; + esac + need_lib_prefix=no + need_version=no + soname_spec='${libname}${release}${shared_ext}$major' + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext} $libname${shared_ext}' + case $host_os in + irix5* | nonstopux*) + libsuff= shlibsuff= + ;; + *) + case $LD in # libtool.m4 will add one of these switches to LD + *-32|*"-32 "|*-melf32bsmip|*"-melf32bsmip ") + libsuff= shlibsuff= libmagic=32-bit;; + *-n32|*"-n32 "|*-melf32bmipn32|*"-melf32bmipn32 ") + libsuff=32 shlibsuff=N32 libmagic=N32;; + *-64|*"-64 "|*-melf64bmip|*"-melf64bmip ") + libsuff=64 shlibsuff=64 libmagic=64-bit;; + *) libsuff= shlibsuff= libmagic=never-match;; + esac + ;; + esac + shlibpath_var=LD_LIBRARY${shlibsuff}_PATH + shlibpath_overrides_runpath=no + sys_lib_search_path_spec="/usr/lib${libsuff} /lib${libsuff} /usr/local/lib${libsuff}" + sys_lib_dlsearch_path_spec="/usr/lib${libsuff} /lib${libsuff}" + hardcode_into_libs=yes + ;; + +# No shared lib support for Linux oldld, aout, or coff. +linux*oldld* | linux*aout* | linux*coff*) + dynamic_linker=no + ;; + +# This must be glibc/ELF. +linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*) + version_type=linux # correct to gnu/linux during the next big refactor + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + finish_cmds='PATH="\$PATH:/sbin" ldconfig -n $libdir' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + + # Some binutils ld are patched to set DT_RUNPATH + if ${lt_cv_shlibpath_overrides_runpath+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_shlibpath_overrides_runpath=no + save_LDFLAGS=$LDFLAGS + save_libdir=$libdir + eval "libdir=/foo; wl=\"$lt_prog_compiler_wl_CXX\"; \ + LDFLAGS=\"\$LDFLAGS $hardcode_libdir_flag_spec_CXX\"" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_link "$LINENO"; then : + if ($OBJDUMP -p conftest$ac_exeext) 2>/dev/null | grep "RUNPATH.*$libdir" >/dev/null; then : + lt_cv_shlibpath_overrides_runpath=yes +fi +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext + LDFLAGS=$save_LDFLAGS + libdir=$save_libdir + +fi + + shlibpath_overrides_runpath=$lt_cv_shlibpath_overrides_runpath + + # This implies no fast_install, which is unacceptable. + # Some rework will be needed to allow for fast_install + # before this can be enabled. + hardcode_into_libs=yes + + # Append ld.so.conf contents to the search path + if test -f /etc/ld.so.conf; then + lt_ld_extra=`awk '/^include / { system(sprintf("cd /etc; cat %s 2>/dev/null", \$2)); skip = 1; } { if (!skip) print \$0; skip = 0; }' < /etc/ld.so.conf | $SED -e 's/#.*//;/^[ ]*hwcap[ ]/d;s/[:, ]/ /g;s/=[^=]*$//;s/=[^= ]* / /g;s/"//g;/^$/d' | tr '\n' ' '` + sys_lib_dlsearch_path_spec="/lib /usr/lib $lt_ld_extra" + fi + + # We used to test for /lib/ld.so.1 and disable shared libraries on + # powerpc, because MkLinux only supported shared libraries with the + # GNU dynamic linker. Since this was broken with cross compilers, + # most powerpc-linux boxes support dynamic linking these days and + # people can always --disable-shared, the test was removed, and we + # assume the GNU/Linux dynamic linker is in use. + dynamic_linker='GNU/Linux ld.so' + ;; + +netbsdelf*-gnu) + version_type=linux + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + hardcode_into_libs=yes + dynamic_linker='NetBSD ld.elf_so' + ;; + +netbsd*) + version_type=sunos + need_lib_prefix=no + need_version=no + if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix' + finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir' + dynamic_linker='NetBSD (a.out) ld.so' + else + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + dynamic_linker='NetBSD ld.elf_so' + fi + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + hardcode_into_libs=yes + ;; + +newsos6) + version_type=linux # correct to gnu/linux during the next big refactor + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + ;; + +*nto* | *qnx*) + version_type=qnx + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + hardcode_into_libs=yes + dynamic_linker='ldqnx.so' + ;; + +openbsd*) + version_type=sunos + sys_lib_dlsearch_path_spec="/usr/lib" + need_lib_prefix=no + # Some older versions of OpenBSD (3.3 at least) *do* need versioned libs. + case $host_os in + openbsd3.3 | openbsd3.3.*) need_version=yes ;; + *) need_version=no ;; + esac + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix' + finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir' + shlibpath_var=LD_LIBRARY_PATH + if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then + case $host_os in + openbsd2.[89] | openbsd2.[89].*) + shlibpath_overrides_runpath=no + ;; + *) + shlibpath_overrides_runpath=yes + ;; + esac + else + shlibpath_overrides_runpath=yes + fi + ;; + +os2*) + libname_spec='$name' + shrext_cmds=".dll" + need_lib_prefix=no + library_names_spec='$libname${shared_ext} $libname.a' + dynamic_linker='OS/2 ld.exe' + shlibpath_var=LIBPATH + ;; + +osf3* | osf4* | osf5*) + version_type=osf + need_lib_prefix=no + need_version=no + soname_spec='${libname}${release}${shared_ext}$major' + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + shlibpath_var=LD_LIBRARY_PATH + sys_lib_search_path_spec="/usr/shlib /usr/ccs/lib /usr/lib/cmplrs/cc /usr/lib /usr/local/lib /var/shlib" + sys_lib_dlsearch_path_spec="$sys_lib_search_path_spec" + ;; + +rdos*) + dynamic_linker=no + ;; + +solaris*) + version_type=linux # correct to gnu/linux during the next big refactor + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + hardcode_into_libs=yes + # ldd complains unless libraries are executable + postinstall_cmds='chmod +x $lib' + ;; + +sunos4*) + version_type=sunos + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix' + finish_cmds='PATH="\$PATH:/usr/etc" ldconfig $libdir' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + if test "$with_gnu_ld" = yes; then + need_lib_prefix=no + fi + need_version=yes + ;; + +sysv4 | sysv4.3*) + version_type=linux # correct to gnu/linux during the next big refactor + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + case $host_vendor in + sni) + shlibpath_overrides_runpath=no + need_lib_prefix=no + runpath_var=LD_RUN_PATH + ;; + siemens) + need_lib_prefix=no + ;; + motorola) + need_lib_prefix=no + need_version=no + shlibpath_overrides_runpath=no + sys_lib_search_path_spec='/lib /usr/lib /usr/ccs/lib' + ;; + esac + ;; + +sysv4*MP*) + if test -d /usr/nec ;then + version_type=linux # correct to gnu/linux during the next big refactor + library_names_spec='$libname${shared_ext}.$versuffix $libname${shared_ext}.$major $libname${shared_ext}' + soname_spec='$libname${shared_ext}.$major' + shlibpath_var=LD_LIBRARY_PATH + fi + ;; + +sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*) + version_type=freebsd-elf + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + hardcode_into_libs=yes + if test "$with_gnu_ld" = yes; then + sys_lib_search_path_spec='/usr/local/lib /usr/gnu/lib /usr/ccs/lib /usr/lib /lib' + else + sys_lib_search_path_spec='/usr/ccs/lib /usr/lib' + case $host_os in + sco3.2v5*) + sys_lib_search_path_spec="$sys_lib_search_path_spec /lib" + ;; + esac + fi + sys_lib_dlsearch_path_spec='/usr/lib' + ;; + +tpf*) + # TPF is a cross-target only. Preferred cross-host = GNU/Linux. + version_type=linux # correct to gnu/linux during the next big refactor + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + hardcode_into_libs=yes + ;; + +uts4*) + version_type=linux # correct to gnu/linux during the next big refactor + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + ;; + +*) + dynamic_linker=no + ;; +esac +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $dynamic_linker" >&5 +$as_echo "$dynamic_linker" >&6; } +test "$dynamic_linker" = no && can_build_shared=no + +variables_saved_for_relink="PATH $shlibpath_var $runpath_var" +if test "$GCC" = yes; then + variables_saved_for_relink="$variables_saved_for_relink GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH" +fi + +if test "${lt_cv_sys_lib_search_path_spec+set}" = set; then + sys_lib_search_path_spec="$lt_cv_sys_lib_search_path_spec" +fi +if test "${lt_cv_sys_lib_dlsearch_path_spec+set}" = set; then + sys_lib_dlsearch_path_spec="$lt_cv_sys_lib_dlsearch_path_spec" +fi + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to hardcode library paths into programs" >&5 +$as_echo_n "checking how to hardcode library paths into programs... " >&6; } +hardcode_action_CXX= +if test -n "$hardcode_libdir_flag_spec_CXX" || + test -n "$runpath_var_CXX" || + test "X$hardcode_automatic_CXX" = "Xyes" ; then + + # We can hardcode non-existent directories. + if test "$hardcode_direct_CXX" != no && + # If the only mechanism to avoid hardcoding is shlibpath_var, we + # have to relink, otherwise we might link with an installed library + # when we should be linking with a yet-to-be-installed one + ## test "$_LT_TAGVAR(hardcode_shlibpath_var, CXX)" != no && + test "$hardcode_minus_L_CXX" != no; then + # Linking always hardcodes the temporary library directory. + hardcode_action_CXX=relink + else + # We can link without hardcoding, and we can hardcode nonexisting dirs. + hardcode_action_CXX=immediate + fi +else + # We cannot hardcode anything, or else we can only hardcode existing + # directories. + hardcode_action_CXX=unsupported +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $hardcode_action_CXX" >&5 +$as_echo "$hardcode_action_CXX" >&6; } + +if test "$hardcode_action_CXX" = relink || + test "$inherit_rpath_CXX" = yes; then + # Fast installation is not supported + enable_fast_install=no +elif test "$shlibpath_overrides_runpath" = yes || + test "$enable_shared" = no; then + # Fast installation is not necessary + enable_fast_install=needless +fi + + + + + + + + fi # test -n "$compiler" + + CC=$lt_save_CC + CFLAGS=$lt_save_CFLAGS + LDCXX=$LD + LD=$lt_save_LD + GCC=$lt_save_GCC + with_gnu_ld=$lt_save_with_gnu_ld + lt_cv_path_LDCXX=$lt_cv_path_LD + lt_cv_path_LD=$lt_save_path_LD + lt_cv_prog_gnu_ldcxx=$lt_cv_prog_gnu_ld + lt_cv_prog_gnu_ld=$lt_save_with_gnu_ld +fi # test "$_lt_caught_CXX_error" != yes + +ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu + + +ac_ext=cpp +ac_cpp='$CXXCPP $CPPFLAGS' +ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_cxx_compiler_gnu + + +# Create the libtool executable so that we can use it in further tests. +# +: ${CONFIG_LT=./config.lt} +{ $as_echo "$as_me:${as_lineno-$LINENO}: creating $CONFIG_LT" >&5 +$as_echo "$as_me: creating $CONFIG_LT" >&6;} +as_write_fail=0 +cat >"$CONFIG_LT" <<_ASEOF || as_write_fail=1 +#! $SHELL +# Generated by $as_me. +# Run this file to recreate a libtool stub with the current configuration. +SHELL=\${CONFIG_SHELL-$SHELL} +export SHELL +_ASEOF +cat >>"$CONFIG_LT" <<\_ASEOF || as_write_fail=1 +## -------------------- ## +## M4sh Initialization. ## +## -------------------- ## + +# Be more Bourne compatible +DUALCASE=1; export DUALCASE # for MKS sh +if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then : + emulate sh + NULLCMD=: + # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which + # is contrary to our usage. Disable this feature. + alias -g '${1+"$@"}'='"$@"' + setopt NO_GLOB_SUBST +else + case `(set -o) 2>/dev/null` in #( + *posix*) : + set -o posix ;; #( + *) : + ;; +esac +fi + + +as_nl=' +' +export as_nl +# Printing a long string crashes Solaris 7 /usr/bin/printf. +as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' +as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo +as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo +# Prefer a ksh shell builtin over an external printf program on Solaris, +# but without wasting forks for bash or zsh. +if test -z "$BASH_VERSION$ZSH_VERSION" \ + && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then + as_echo='print -r --' + as_echo_n='print -rn --' +elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then + as_echo='printf %s\n' + as_echo_n='printf %s' +else + if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then + as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"' + as_echo_n='/usr/ucb/echo -n' + else + as_echo_body='eval expr "X$1" : "X\\(.*\\)"' + as_echo_n_body='eval + arg=$1; + case $arg in #( + *"$as_nl"*) + expr "X$arg" : "X\\(.*\\)$as_nl"; + arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;; + esac; + expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl" + ' + export as_echo_n_body + as_echo_n='sh -c $as_echo_n_body as_echo' + fi + export as_echo_body + as_echo='sh -c $as_echo_body as_echo' +fi + +# The user is always right. +if test "${PATH_SEPARATOR+set}" != set; then + PATH_SEPARATOR=: + (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && { + (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 || + PATH_SEPARATOR=';' + } +fi + + +# IFS +# We need space, tab and new line, in precisely that order. Quoting is +# there to prevent editors from complaining about space-tab. +# (If _AS_PATH_WALK were called with IFS unset, it would disable word +# splitting by setting IFS to empty value.) +IFS=" "" $as_nl" + +# Find who we are. Look in the path if we contain no directory separator. +as_myself= +case $0 in #(( + *[\\/]* ) as_myself=$0 ;; + *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break + done +IFS=$as_save_IFS + + ;; +esac +# We did not find ourselves, most probably we were run as `sh COMMAND' +# in which case we are not to be found in the path. +if test "x$as_myself" = x; then + as_myself=$0 +fi +if test ! -f "$as_myself"; then + $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2 + exit 1 +fi + +# Unset variables that we do not need and which cause bugs (e.g. in +# pre-3.0 UWIN ksh). But do not cause bugs in bash 2.01; the "|| exit 1" +# suppresses any "Segmentation fault" message there. '((' could +# trigger a bug in pdksh 5.2.14. +for as_var in BASH_ENV ENV MAIL MAILPATH +do eval test x\${$as_var+set} = xset \ + && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || : +done +PS1='$ ' +PS2='> ' +PS4='+ ' + +# NLS nuisances. +LC_ALL=C +export LC_ALL +LANGUAGE=C +export LANGUAGE + +# CDPATH. +(unset CDPATH) >/dev/null 2>&1 && unset CDPATH + + +# as_fn_error STATUS ERROR [LINENO LOG_FD] +# ---------------------------------------- +# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are +# provided, also output the error to LOG_FD, referencing LINENO. Then exit the +# script with STATUS, using 1 if that was 0. +as_fn_error () +{ + as_status=$1; test $as_status -eq 0 && as_status=1 + if test "$4"; then + as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4 + fi + $as_echo "$as_me: error: $2" >&2 + as_fn_exit $as_status +} # as_fn_error + + +# as_fn_set_status STATUS +# ----------------------- +# Set $? to STATUS, without forking. +as_fn_set_status () +{ + return $1 +} # as_fn_set_status + +# as_fn_exit STATUS +# ----------------- +# Exit the shell with STATUS, even in a "trap 0" or "set -e" context. +as_fn_exit () +{ + set +e + as_fn_set_status $1 + exit $1 +} # as_fn_exit + +# as_fn_unset VAR +# --------------- +# Portably unset VAR. +as_fn_unset () +{ + { eval $1=; unset $1;} +} +as_unset=as_fn_unset +# as_fn_append VAR VALUE +# ---------------------- +# Append the text in VALUE to the end of the definition contained in VAR. Take +# advantage of any shell optimizations that allow amortized linear growth over +# repeated appends, instead of the typical quadratic growth present in naive +# implementations. +if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then : + eval 'as_fn_append () + { + eval $1+=\$2 + }' +else + as_fn_append () + { + eval $1=\$$1\$2 + } +fi # as_fn_append + +# as_fn_arith ARG... +# ------------------ +# Perform arithmetic evaluation on the ARGs, and store the result in the +# global $as_val. Take advantage of shells that can avoid forks. The arguments +# must be portable across $(()) and expr. +if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then : + eval 'as_fn_arith () + { + as_val=$(( $* )) + }' +else + as_fn_arith () + { + as_val=`expr "$@" || test $? -eq 1` + } +fi # as_fn_arith + + +if expr a : '\(a\)' >/dev/null 2>&1 && + test "X`expr 00001 : '.*\(...\)'`" = X001; then + as_expr=expr +else + as_expr=false +fi + +if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then + as_basename=basename +else + as_basename=false +fi + +if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then + as_dirname=dirname +else + as_dirname=false +fi + +as_me=`$as_basename -- "$0" || +$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ + X"$0" : 'X\(//\)$' \| \ + X"$0" : 'X\(/\)' \| . 2>/dev/null || +$as_echo X/"$0" | + sed '/^.*\/\([^/][^/]*\)\/*$/{ + s//\1/ + q + } + /^X\/\(\/\/\)$/{ + s//\1/ + q + } + /^X\/\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q'` + +# Avoid depending upon Character Ranges. +as_cr_letters='abcdefghijklmnopqrstuvwxyz' +as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ' +as_cr_Letters=$as_cr_letters$as_cr_LETTERS +as_cr_digits='0123456789' +as_cr_alnum=$as_cr_Letters$as_cr_digits + +ECHO_C= ECHO_N= ECHO_T= +case `echo -n x` in #((((( +-n*) + case `echo 'xy\c'` in + *c*) ECHO_T=' ';; # ECHO_T is single tab character. + xy) ECHO_C='\c';; + *) echo `echo ksh88 bug on AIX 6.1` > /dev/null + ECHO_T=' ';; + esac;; +*) + ECHO_N='-n';; +esac + +rm -f conf$$ conf$$.exe conf$$.file +if test -d conf$$.dir; then + rm -f conf$$.dir/conf$$.file +else + rm -f conf$$.dir + mkdir conf$$.dir 2>/dev/null +fi +if (echo >conf$$.file) 2>/dev/null; then + if ln -s conf$$.file conf$$ 2>/dev/null; then + as_ln_s='ln -s' + # ... but there are two gotchas: + # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail. + # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable. + # In both cases, we have to default to `cp -pR'. + ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe || + as_ln_s='cp -pR' + elif ln conf$$.file conf$$ 2>/dev/null; then + as_ln_s=ln + else + as_ln_s='cp -pR' + fi +else + as_ln_s='cp -pR' +fi +rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file +rmdir conf$$.dir 2>/dev/null + + +# as_fn_mkdir_p +# ------------- +# Create "$as_dir" as a directory, including parents if necessary. +as_fn_mkdir_p () +{ + + case $as_dir in #( + -*) as_dir=./$as_dir;; + esac + test -d "$as_dir" || eval $as_mkdir_p || { + as_dirs= + while :; do + case $as_dir in #( + *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'( + *) as_qdir=$as_dir;; + esac + as_dirs="'$as_qdir' $as_dirs" + as_dir=`$as_dirname -- "$as_dir" || +$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ + X"$as_dir" : 'X\(//\)[^/]' \| \ + X"$as_dir" : 'X\(//\)$' \| \ + X"$as_dir" : 'X\(/\)' \| . 2>/dev/null || +$as_echo X"$as_dir" | + sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ + s//\1/ + q + } + /^X\(\/\/\)[^/].*/{ + s//\1/ + q + } + /^X\(\/\/\)$/{ + s//\1/ + q + } + /^X\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q'` + test -d "$as_dir" && break + done + test -z "$as_dirs" || eval "mkdir $as_dirs" + } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir" + + +} # as_fn_mkdir_p +if mkdir -p . 2>/dev/null; then + as_mkdir_p='mkdir -p "$as_dir"' +else + test -d ./-p && rmdir ./-p + as_mkdir_p=false +fi + + +# as_fn_executable_p FILE +# ----------------------- +# Test if FILE is an executable regular file. +as_fn_executable_p () +{ + test -f "$1" && test -x "$1" +} # as_fn_executable_p +as_test_x='test -x' +as_executable_p=as_fn_executable_p + +# Sed expression to map a string onto a valid CPP name. +as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'" + +# Sed expression to map a string onto a valid variable name. +as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'" + + +exec 6>&1 +## --------------------------------- ## +## Main body of "$CONFIG_LT" script. ## +## --------------------------------- ## +_ASEOF +test $as_write_fail = 0 && chmod +x "$CONFIG_LT" + +cat >>"$CONFIG_LT" <<\_LTEOF +lt_cl_silent=false +exec 5>>config.log +{ + echo + sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX +## Running $as_me. ## +_ASBOX +} >&5 + +lt_cl_help="\ +\`$as_me' creates a local libtool stub from the current configuration, +for use in further configure time tests before the real libtool is +generated. + +Usage: $0 [OPTIONS] + + -h, --help print this help, then exit + -V, --version print version number, then exit + -q, --quiet do not print progress messages + -d, --debug don't remove temporary files + +Report bugs to ." + +lt_cl_version="\ +libodb config.lt 2.4.0 +configured by $0, generated by GNU Autoconf 2.69. + +Copyright (C) 2011 Free Software Foundation, Inc. +This config.lt script is free software; the Free Software Foundation +gives unlimited permision to copy, distribute and modify it." + +while test $# != 0 +do + case $1 in + --version | --v* | -V ) + echo "$lt_cl_version"; exit 0 ;; + --help | --h* | -h ) + echo "$lt_cl_help"; exit 0 ;; + --debug | --d* | -d ) + debug=: ;; + --quiet | --q* | --silent | --s* | -q ) + lt_cl_silent=: ;; + + -*) as_fn_error $? "unrecognized option: $1 +Try \`$0 --help' for more information." "$LINENO" 5 ;; + + *) as_fn_error $? "unrecognized argument: $1 +Try \`$0 --help' for more information." "$LINENO" 5 ;; + esac + shift +done + +if $lt_cl_silent; then + exec 6>/dev/null +fi +_LTEOF + +cat >>"$CONFIG_LT" <<_LTEOF + + +# The HP-UX ksh and POSIX shell print the target directory to stdout +# if CDPATH is set. +(unset CDPATH) >/dev/null 2>&1 && unset CDPATH + +sed_quote_subst='$sed_quote_subst' +double_quote_subst='$double_quote_subst' +delay_variable_subst='$delay_variable_subst' +macro_version='`$ECHO "$macro_version" | $SED "$delay_single_quote_subst"`' +macro_revision='`$ECHO "$macro_revision" | $SED "$delay_single_quote_subst"`' +AS='`$ECHO "$AS" | $SED "$delay_single_quote_subst"`' +DLLTOOL='`$ECHO "$DLLTOOL" | $SED "$delay_single_quote_subst"`' +OBJDUMP='`$ECHO "$OBJDUMP" | $SED "$delay_single_quote_subst"`' +enable_shared='`$ECHO "$enable_shared" | $SED "$delay_single_quote_subst"`' +enable_static='`$ECHO "$enable_static" | $SED "$delay_single_quote_subst"`' +pic_mode='`$ECHO "$pic_mode" | $SED "$delay_single_quote_subst"`' +enable_fast_install='`$ECHO "$enable_fast_install" | $SED "$delay_single_quote_subst"`' +SHELL='`$ECHO "$SHELL" | $SED "$delay_single_quote_subst"`' +ECHO='`$ECHO "$ECHO" | $SED "$delay_single_quote_subst"`' +PATH_SEPARATOR='`$ECHO "$PATH_SEPARATOR" | $SED "$delay_single_quote_subst"`' +host_alias='`$ECHO "$host_alias" | $SED "$delay_single_quote_subst"`' +host='`$ECHO "$host" | $SED "$delay_single_quote_subst"`' +host_os='`$ECHO "$host_os" | $SED "$delay_single_quote_subst"`' +build_alias='`$ECHO "$build_alias" | $SED "$delay_single_quote_subst"`' +build='`$ECHO "$build" | $SED "$delay_single_quote_subst"`' +build_os='`$ECHO "$build_os" | $SED "$delay_single_quote_subst"`' +SED='`$ECHO "$SED" | $SED "$delay_single_quote_subst"`' +Xsed='`$ECHO "$Xsed" | $SED "$delay_single_quote_subst"`' +GREP='`$ECHO "$GREP" | $SED "$delay_single_quote_subst"`' +EGREP='`$ECHO "$EGREP" | $SED "$delay_single_quote_subst"`' +FGREP='`$ECHO "$FGREP" | $SED "$delay_single_quote_subst"`' +LD='`$ECHO "$LD" | $SED "$delay_single_quote_subst"`' +NM='`$ECHO "$NM" | $SED "$delay_single_quote_subst"`' +LN_S='`$ECHO "$LN_S" | $SED "$delay_single_quote_subst"`' +max_cmd_len='`$ECHO "$max_cmd_len" | $SED "$delay_single_quote_subst"`' +ac_objext='`$ECHO "$ac_objext" | $SED "$delay_single_quote_subst"`' +exeext='`$ECHO "$exeext" | $SED "$delay_single_quote_subst"`' +lt_unset='`$ECHO "$lt_unset" | $SED "$delay_single_quote_subst"`' +lt_SP2NL='`$ECHO "$lt_SP2NL" | $SED "$delay_single_quote_subst"`' +lt_NL2SP='`$ECHO "$lt_NL2SP" | $SED "$delay_single_quote_subst"`' +lt_cv_to_host_file_cmd='`$ECHO "$lt_cv_to_host_file_cmd" | $SED "$delay_single_quote_subst"`' +lt_cv_to_tool_file_cmd='`$ECHO "$lt_cv_to_tool_file_cmd" | $SED "$delay_single_quote_subst"`' +reload_flag='`$ECHO "$reload_flag" | $SED "$delay_single_quote_subst"`' +reload_cmds='`$ECHO "$reload_cmds" | $SED "$delay_single_quote_subst"`' +deplibs_check_method='`$ECHO "$deplibs_check_method" | $SED "$delay_single_quote_subst"`' +file_magic_cmd='`$ECHO "$file_magic_cmd" | $SED "$delay_single_quote_subst"`' +file_magic_glob='`$ECHO "$file_magic_glob" | $SED "$delay_single_quote_subst"`' +want_nocaseglob='`$ECHO "$want_nocaseglob" | $SED "$delay_single_quote_subst"`' +sharedlib_from_linklib_cmd='`$ECHO "$sharedlib_from_linklib_cmd" | $SED "$delay_single_quote_subst"`' +AR='`$ECHO "$AR" | $SED "$delay_single_quote_subst"`' +AR_FLAGS='`$ECHO "$AR_FLAGS" | $SED "$delay_single_quote_subst"`' +archiver_list_spec='`$ECHO "$archiver_list_spec" | $SED "$delay_single_quote_subst"`' +STRIP='`$ECHO "$STRIP" | $SED "$delay_single_quote_subst"`' +RANLIB='`$ECHO "$RANLIB" | $SED "$delay_single_quote_subst"`' +old_postinstall_cmds='`$ECHO "$old_postinstall_cmds" | $SED "$delay_single_quote_subst"`' +old_postuninstall_cmds='`$ECHO "$old_postuninstall_cmds" | $SED "$delay_single_quote_subst"`' +old_archive_cmds='`$ECHO "$old_archive_cmds" | $SED "$delay_single_quote_subst"`' +lock_old_archive_extraction='`$ECHO "$lock_old_archive_extraction" | $SED "$delay_single_quote_subst"`' +CC='`$ECHO "$CC" | $SED "$delay_single_quote_subst"`' +CFLAGS='`$ECHO "$CFLAGS" | $SED "$delay_single_quote_subst"`' +compiler='`$ECHO "$compiler" | $SED "$delay_single_quote_subst"`' +GCC='`$ECHO "$GCC" | $SED "$delay_single_quote_subst"`' +lt_cv_sys_global_symbol_pipe='`$ECHO "$lt_cv_sys_global_symbol_pipe" | $SED "$delay_single_quote_subst"`' +lt_cv_sys_global_symbol_to_cdecl='`$ECHO "$lt_cv_sys_global_symbol_to_cdecl" | $SED "$delay_single_quote_subst"`' +lt_cv_sys_global_symbol_to_c_name_address='`$ECHO "$lt_cv_sys_global_symbol_to_c_name_address" | $SED "$delay_single_quote_subst"`' +lt_cv_sys_global_symbol_to_c_name_address_lib_prefix='`$ECHO "$lt_cv_sys_global_symbol_to_c_name_address_lib_prefix" | $SED "$delay_single_quote_subst"`' +nm_file_list_spec='`$ECHO "$nm_file_list_spec" | $SED "$delay_single_quote_subst"`' +lt_sysroot='`$ECHO "$lt_sysroot" | $SED "$delay_single_quote_subst"`' +objdir='`$ECHO "$objdir" | $SED "$delay_single_quote_subst"`' +MAGIC_CMD='`$ECHO "$MAGIC_CMD" | $SED "$delay_single_quote_subst"`' +lt_prog_compiler_no_builtin_flag='`$ECHO "$lt_prog_compiler_no_builtin_flag" | $SED "$delay_single_quote_subst"`' +lt_prog_compiler_pic='`$ECHO "$lt_prog_compiler_pic" | $SED "$delay_single_quote_subst"`' +lt_prog_compiler_wl='`$ECHO "$lt_prog_compiler_wl" | $SED "$delay_single_quote_subst"`' +lt_prog_compiler_static='`$ECHO "$lt_prog_compiler_static" | $SED "$delay_single_quote_subst"`' +lt_cv_prog_compiler_c_o='`$ECHO "$lt_cv_prog_compiler_c_o" | $SED "$delay_single_quote_subst"`' +need_locks='`$ECHO "$need_locks" | $SED "$delay_single_quote_subst"`' +MANIFEST_TOOL='`$ECHO "$MANIFEST_TOOL" | $SED "$delay_single_quote_subst"`' +DSYMUTIL='`$ECHO "$DSYMUTIL" | $SED "$delay_single_quote_subst"`' +NMEDIT='`$ECHO "$NMEDIT" | $SED "$delay_single_quote_subst"`' +LIPO='`$ECHO "$LIPO" | $SED "$delay_single_quote_subst"`' +OTOOL='`$ECHO "$OTOOL" | $SED "$delay_single_quote_subst"`' +OTOOL64='`$ECHO "$OTOOL64" | $SED "$delay_single_quote_subst"`' +libext='`$ECHO "$libext" | $SED "$delay_single_quote_subst"`' +shrext_cmds='`$ECHO "$shrext_cmds" | $SED "$delay_single_quote_subst"`' +extract_expsyms_cmds='`$ECHO "$extract_expsyms_cmds" | $SED "$delay_single_quote_subst"`' +archive_cmds_need_lc='`$ECHO "$archive_cmds_need_lc" | $SED "$delay_single_quote_subst"`' +enable_shared_with_static_runtimes='`$ECHO "$enable_shared_with_static_runtimes" | $SED "$delay_single_quote_subst"`' +export_dynamic_flag_spec='`$ECHO "$export_dynamic_flag_spec" | $SED "$delay_single_quote_subst"`' +whole_archive_flag_spec='`$ECHO "$whole_archive_flag_spec" | $SED "$delay_single_quote_subst"`' +compiler_needs_object='`$ECHO "$compiler_needs_object" | $SED "$delay_single_quote_subst"`' +old_archive_from_new_cmds='`$ECHO "$old_archive_from_new_cmds" | $SED "$delay_single_quote_subst"`' +old_archive_from_expsyms_cmds='`$ECHO "$old_archive_from_expsyms_cmds" | $SED "$delay_single_quote_subst"`' +archive_cmds='`$ECHO "$archive_cmds" | $SED "$delay_single_quote_subst"`' +archive_expsym_cmds='`$ECHO "$archive_expsym_cmds" | $SED "$delay_single_quote_subst"`' +module_cmds='`$ECHO "$module_cmds" | $SED "$delay_single_quote_subst"`' +module_expsym_cmds='`$ECHO "$module_expsym_cmds" | $SED "$delay_single_quote_subst"`' +with_gnu_ld='`$ECHO "$with_gnu_ld" | $SED "$delay_single_quote_subst"`' +allow_undefined_flag='`$ECHO "$allow_undefined_flag" | $SED "$delay_single_quote_subst"`' +no_undefined_flag='`$ECHO "$no_undefined_flag" | $SED "$delay_single_quote_subst"`' +hardcode_libdir_flag_spec='`$ECHO "$hardcode_libdir_flag_spec" | $SED "$delay_single_quote_subst"`' +hardcode_libdir_separator='`$ECHO "$hardcode_libdir_separator" | $SED "$delay_single_quote_subst"`' +hardcode_direct='`$ECHO "$hardcode_direct" | $SED "$delay_single_quote_subst"`' +hardcode_direct_absolute='`$ECHO "$hardcode_direct_absolute" | $SED "$delay_single_quote_subst"`' +hardcode_minus_L='`$ECHO "$hardcode_minus_L" | $SED "$delay_single_quote_subst"`' +hardcode_shlibpath_var='`$ECHO "$hardcode_shlibpath_var" | $SED "$delay_single_quote_subst"`' +hardcode_automatic='`$ECHO "$hardcode_automatic" | $SED "$delay_single_quote_subst"`' +inherit_rpath='`$ECHO "$inherit_rpath" | $SED "$delay_single_quote_subst"`' +link_all_deplibs='`$ECHO "$link_all_deplibs" | $SED "$delay_single_quote_subst"`' +always_export_symbols='`$ECHO "$always_export_symbols" | $SED "$delay_single_quote_subst"`' +export_symbols_cmds='`$ECHO "$export_symbols_cmds" | $SED "$delay_single_quote_subst"`' +exclude_expsyms='`$ECHO "$exclude_expsyms" | $SED "$delay_single_quote_subst"`' +include_expsyms='`$ECHO "$include_expsyms" | $SED "$delay_single_quote_subst"`' +prelink_cmds='`$ECHO "$prelink_cmds" | $SED "$delay_single_quote_subst"`' +postlink_cmds='`$ECHO "$postlink_cmds" | $SED "$delay_single_quote_subst"`' +file_list_spec='`$ECHO "$file_list_spec" | $SED "$delay_single_quote_subst"`' +variables_saved_for_relink='`$ECHO "$variables_saved_for_relink" | $SED "$delay_single_quote_subst"`' +need_lib_prefix='`$ECHO "$need_lib_prefix" | $SED "$delay_single_quote_subst"`' +need_version='`$ECHO "$need_version" | $SED "$delay_single_quote_subst"`' +version_type='`$ECHO "$version_type" | $SED "$delay_single_quote_subst"`' +runpath_var='`$ECHO "$runpath_var" | $SED "$delay_single_quote_subst"`' +shlibpath_var='`$ECHO "$shlibpath_var" | $SED "$delay_single_quote_subst"`' +shlibpath_overrides_runpath='`$ECHO "$shlibpath_overrides_runpath" | $SED "$delay_single_quote_subst"`' +libname_spec='`$ECHO "$libname_spec" | $SED "$delay_single_quote_subst"`' +library_names_spec='`$ECHO "$library_names_spec" | $SED "$delay_single_quote_subst"`' +soname_spec='`$ECHO "$soname_spec" | $SED "$delay_single_quote_subst"`' +install_override_mode='`$ECHO "$install_override_mode" | $SED "$delay_single_quote_subst"`' +postinstall_cmds='`$ECHO "$postinstall_cmds" | $SED "$delay_single_quote_subst"`' +postuninstall_cmds='`$ECHO "$postuninstall_cmds" | $SED "$delay_single_quote_subst"`' +finish_cmds='`$ECHO "$finish_cmds" | $SED "$delay_single_quote_subst"`' +finish_eval='`$ECHO "$finish_eval" | $SED "$delay_single_quote_subst"`' +hardcode_into_libs='`$ECHO "$hardcode_into_libs" | $SED "$delay_single_quote_subst"`' +sys_lib_search_path_spec='`$ECHO "$sys_lib_search_path_spec" | $SED "$delay_single_quote_subst"`' +sys_lib_dlsearch_path_spec='`$ECHO "$sys_lib_dlsearch_path_spec" | $SED "$delay_single_quote_subst"`' +hardcode_action='`$ECHO "$hardcode_action" | $SED "$delay_single_quote_subst"`' +enable_dlopen='`$ECHO "$enable_dlopen" | $SED "$delay_single_quote_subst"`' +enable_dlopen_self='`$ECHO "$enable_dlopen_self" | $SED "$delay_single_quote_subst"`' +enable_dlopen_self_static='`$ECHO "$enable_dlopen_self_static" | $SED "$delay_single_quote_subst"`' +old_striplib='`$ECHO "$old_striplib" | $SED "$delay_single_quote_subst"`' +striplib='`$ECHO "$striplib" | $SED "$delay_single_quote_subst"`' +compiler_lib_search_dirs='`$ECHO "$compiler_lib_search_dirs" | $SED "$delay_single_quote_subst"`' +predep_objects='`$ECHO "$predep_objects" | $SED "$delay_single_quote_subst"`' +postdep_objects='`$ECHO "$postdep_objects" | $SED "$delay_single_quote_subst"`' +predeps='`$ECHO "$predeps" | $SED "$delay_single_quote_subst"`' +postdeps='`$ECHO "$postdeps" | $SED "$delay_single_quote_subst"`' +compiler_lib_search_path='`$ECHO "$compiler_lib_search_path" | $SED "$delay_single_quote_subst"`' +LD_CXX='`$ECHO "$LD_CXX" | $SED "$delay_single_quote_subst"`' +reload_flag_CXX='`$ECHO "$reload_flag_CXX" | $SED "$delay_single_quote_subst"`' +reload_cmds_CXX='`$ECHO "$reload_cmds_CXX" | $SED "$delay_single_quote_subst"`' +old_archive_cmds_CXX='`$ECHO "$old_archive_cmds_CXX" | $SED "$delay_single_quote_subst"`' +compiler_CXX='`$ECHO "$compiler_CXX" | $SED "$delay_single_quote_subst"`' +GCC_CXX='`$ECHO "$GCC_CXX" | $SED "$delay_single_quote_subst"`' +lt_prog_compiler_no_builtin_flag_CXX='`$ECHO "$lt_prog_compiler_no_builtin_flag_CXX" | $SED "$delay_single_quote_subst"`' +lt_prog_compiler_pic_CXX='`$ECHO "$lt_prog_compiler_pic_CXX" | $SED "$delay_single_quote_subst"`' +lt_prog_compiler_wl_CXX='`$ECHO "$lt_prog_compiler_wl_CXX" | $SED "$delay_single_quote_subst"`' +lt_prog_compiler_static_CXX='`$ECHO "$lt_prog_compiler_static_CXX" | $SED "$delay_single_quote_subst"`' +lt_cv_prog_compiler_c_o_CXX='`$ECHO "$lt_cv_prog_compiler_c_o_CXX" | $SED "$delay_single_quote_subst"`' +archive_cmds_need_lc_CXX='`$ECHO "$archive_cmds_need_lc_CXX" | $SED "$delay_single_quote_subst"`' +enable_shared_with_static_runtimes_CXX='`$ECHO "$enable_shared_with_static_runtimes_CXX" | $SED "$delay_single_quote_subst"`' +export_dynamic_flag_spec_CXX='`$ECHO "$export_dynamic_flag_spec_CXX" | $SED "$delay_single_quote_subst"`' +whole_archive_flag_spec_CXX='`$ECHO "$whole_archive_flag_spec_CXX" | $SED "$delay_single_quote_subst"`' +compiler_needs_object_CXX='`$ECHO "$compiler_needs_object_CXX" | $SED "$delay_single_quote_subst"`' +old_archive_from_new_cmds_CXX='`$ECHO "$old_archive_from_new_cmds_CXX" | $SED "$delay_single_quote_subst"`' +old_archive_from_expsyms_cmds_CXX='`$ECHO "$old_archive_from_expsyms_cmds_CXX" | $SED "$delay_single_quote_subst"`' +archive_cmds_CXX='`$ECHO "$archive_cmds_CXX" | $SED "$delay_single_quote_subst"`' +archive_expsym_cmds_CXX='`$ECHO "$archive_expsym_cmds_CXX" | $SED "$delay_single_quote_subst"`' +module_cmds_CXX='`$ECHO "$module_cmds_CXX" | $SED "$delay_single_quote_subst"`' +module_expsym_cmds_CXX='`$ECHO "$module_expsym_cmds_CXX" | $SED "$delay_single_quote_subst"`' +with_gnu_ld_CXX='`$ECHO "$with_gnu_ld_CXX" | $SED "$delay_single_quote_subst"`' +allow_undefined_flag_CXX='`$ECHO "$allow_undefined_flag_CXX" | $SED "$delay_single_quote_subst"`' +no_undefined_flag_CXX='`$ECHO "$no_undefined_flag_CXX" | $SED "$delay_single_quote_subst"`' +hardcode_libdir_flag_spec_CXX='`$ECHO "$hardcode_libdir_flag_spec_CXX" | $SED "$delay_single_quote_subst"`' +hardcode_libdir_separator_CXX='`$ECHO "$hardcode_libdir_separator_CXX" | $SED "$delay_single_quote_subst"`' +hardcode_direct_CXX='`$ECHO "$hardcode_direct_CXX" | $SED "$delay_single_quote_subst"`' +hardcode_direct_absolute_CXX='`$ECHO "$hardcode_direct_absolute_CXX" | $SED "$delay_single_quote_subst"`' +hardcode_minus_L_CXX='`$ECHO "$hardcode_minus_L_CXX" | $SED "$delay_single_quote_subst"`' +hardcode_shlibpath_var_CXX='`$ECHO "$hardcode_shlibpath_var_CXX" | $SED "$delay_single_quote_subst"`' +hardcode_automatic_CXX='`$ECHO "$hardcode_automatic_CXX" | $SED "$delay_single_quote_subst"`' +inherit_rpath_CXX='`$ECHO "$inherit_rpath_CXX" | $SED "$delay_single_quote_subst"`' +link_all_deplibs_CXX='`$ECHO "$link_all_deplibs_CXX" | $SED "$delay_single_quote_subst"`' +always_export_symbols_CXX='`$ECHO "$always_export_symbols_CXX" | $SED "$delay_single_quote_subst"`' +export_symbols_cmds_CXX='`$ECHO "$export_symbols_cmds_CXX" | $SED "$delay_single_quote_subst"`' +exclude_expsyms_CXX='`$ECHO "$exclude_expsyms_CXX" | $SED "$delay_single_quote_subst"`' +include_expsyms_CXX='`$ECHO "$include_expsyms_CXX" | $SED "$delay_single_quote_subst"`' +prelink_cmds_CXX='`$ECHO "$prelink_cmds_CXX" | $SED "$delay_single_quote_subst"`' +postlink_cmds_CXX='`$ECHO "$postlink_cmds_CXX" | $SED "$delay_single_quote_subst"`' +file_list_spec_CXX='`$ECHO "$file_list_spec_CXX" | $SED "$delay_single_quote_subst"`' +hardcode_action_CXX='`$ECHO "$hardcode_action_CXX" | $SED "$delay_single_quote_subst"`' +compiler_lib_search_dirs_CXX='`$ECHO "$compiler_lib_search_dirs_CXX" | $SED "$delay_single_quote_subst"`' +predep_objects_CXX='`$ECHO "$predep_objects_CXX" | $SED "$delay_single_quote_subst"`' +postdep_objects_CXX='`$ECHO "$postdep_objects_CXX" | $SED "$delay_single_quote_subst"`' +predeps_CXX='`$ECHO "$predeps_CXX" | $SED "$delay_single_quote_subst"`' +postdeps_CXX='`$ECHO "$postdeps_CXX" | $SED "$delay_single_quote_subst"`' +compiler_lib_search_path_CXX='`$ECHO "$compiler_lib_search_path_CXX" | $SED "$delay_single_quote_subst"`' + +LTCC='$LTCC' +LTCFLAGS='$LTCFLAGS' +compiler='$compiler_DEFAULT' + +# A function that is used when there is no print builtin or printf. +func_fallback_echo () +{ + eval 'cat <<_LTECHO_EOF +\$1 +_LTECHO_EOF' +} + +# Quote evaled strings. +for var in AS \ +DLLTOOL \ +OBJDUMP \ +SHELL \ +ECHO \ +PATH_SEPARATOR \ +SED \ +GREP \ +EGREP \ +FGREP \ +LD \ +NM \ +LN_S \ +lt_SP2NL \ +lt_NL2SP \ +reload_flag \ +deplibs_check_method \ +file_magic_cmd \ +file_magic_glob \ +want_nocaseglob \ +sharedlib_from_linklib_cmd \ +AR \ +AR_FLAGS \ +archiver_list_spec \ +STRIP \ +RANLIB \ +CC \ +CFLAGS \ +compiler \ +lt_cv_sys_global_symbol_pipe \ +lt_cv_sys_global_symbol_to_cdecl \ +lt_cv_sys_global_symbol_to_c_name_address \ +lt_cv_sys_global_symbol_to_c_name_address_lib_prefix \ +nm_file_list_spec \ +lt_prog_compiler_no_builtin_flag \ +lt_prog_compiler_pic \ +lt_prog_compiler_wl \ +lt_prog_compiler_static \ +lt_cv_prog_compiler_c_o \ +need_locks \ +MANIFEST_TOOL \ +DSYMUTIL \ +NMEDIT \ +LIPO \ +OTOOL \ +OTOOL64 \ +shrext_cmds \ +export_dynamic_flag_spec \ +whole_archive_flag_spec \ +compiler_needs_object \ +with_gnu_ld \ +allow_undefined_flag \ +no_undefined_flag \ +hardcode_libdir_flag_spec \ +hardcode_libdir_separator \ +exclude_expsyms \ +include_expsyms \ +file_list_spec \ +variables_saved_for_relink \ +libname_spec \ +library_names_spec \ +soname_spec \ +install_override_mode \ +finish_eval \ +old_striplib \ +striplib \ +compiler_lib_search_dirs \ +predep_objects \ +postdep_objects \ +predeps \ +postdeps \ +compiler_lib_search_path \ +LD_CXX \ +reload_flag_CXX \ +compiler_CXX \ +lt_prog_compiler_no_builtin_flag_CXX \ +lt_prog_compiler_pic_CXX \ +lt_prog_compiler_wl_CXX \ +lt_prog_compiler_static_CXX \ +lt_cv_prog_compiler_c_o_CXX \ +export_dynamic_flag_spec_CXX \ +whole_archive_flag_spec_CXX \ +compiler_needs_object_CXX \ +with_gnu_ld_CXX \ +allow_undefined_flag_CXX \ +no_undefined_flag_CXX \ +hardcode_libdir_flag_spec_CXX \ +hardcode_libdir_separator_CXX \ +exclude_expsyms_CXX \ +include_expsyms_CXX \ +file_list_spec_CXX \ +compiler_lib_search_dirs_CXX \ +predep_objects_CXX \ +postdep_objects_CXX \ +predeps_CXX \ +postdeps_CXX \ +compiler_lib_search_path_CXX; do + case \`eval \\\\\$ECHO \\\\""\\\\\$\$var"\\\\"\` in + *[\\\\\\\`\\"\\\$]*) + eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"\\\$\$var\\" | \\\$SED \\"\\\$sed_quote_subst\\"\\\`\\\\\\"" + ;; + *) + eval "lt_\$var=\\\\\\"\\\$\$var\\\\\\"" + ;; + esac +done + +# Double-quote double-evaled strings. +for var in reload_cmds \ +old_postinstall_cmds \ +old_postuninstall_cmds \ +old_archive_cmds \ +extract_expsyms_cmds \ +old_archive_from_new_cmds \ +old_archive_from_expsyms_cmds \ +archive_cmds \ +archive_expsym_cmds \ +module_cmds \ +module_expsym_cmds \ +export_symbols_cmds \ +prelink_cmds \ +postlink_cmds \ +postinstall_cmds \ +postuninstall_cmds \ +finish_cmds \ +sys_lib_search_path_spec \ +sys_lib_dlsearch_path_spec \ +reload_cmds_CXX \ +old_archive_cmds_CXX \ +old_archive_from_new_cmds_CXX \ +old_archive_from_expsyms_cmds_CXX \ +archive_cmds_CXX \ +archive_expsym_cmds_CXX \ +module_cmds_CXX \ +module_expsym_cmds_CXX \ +export_symbols_cmds_CXX \ +prelink_cmds_CXX \ +postlink_cmds_CXX; do + case \`eval \\\\\$ECHO \\\\""\\\\\$\$var"\\\\"\` in + *[\\\\\\\`\\"\\\$]*) + eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"\\\$\$var\\" | \\\$SED -e \\"\\\$double_quote_subst\\" -e \\"\\\$sed_quote_subst\\" -e \\"\\\$delay_variable_subst\\"\\\`\\\\\\"" + ;; + *) + eval "lt_\$var=\\\\\\"\\\$\$var\\\\\\"" + ;; + esac +done + +ac_aux_dir='$ac_aux_dir' +xsi_shell='$xsi_shell' +lt_shell_append='$lt_shell_append' + +# See if we are running on zsh, and set the options which allow our +# commands through without removal of \ escapes INIT. +if test -n "\${ZSH_VERSION+set}" ; then + setopt NO_GLOB_SUBST +fi + + + PACKAGE='$PACKAGE' + VERSION='$VERSION' + TIMESTAMP='$TIMESTAMP' + RM='$RM' + ofile='$ofile' + + + + + +_LTEOF + +cat >>"$CONFIG_LT" <<\_LTEOF +{ $as_echo "$as_me:${as_lineno-$LINENO}: creating $ofile" >&5 +$as_echo "$as_me: creating $ofile" >&6;} + + + # See if we are running on zsh, and set the options which allow our + # commands through without removal of \ escapes. + if test -n "${ZSH_VERSION+set}" ; then + setopt NO_GLOB_SUBST + fi + + cfgfile="${ofile}T" + trap "$RM \"$cfgfile\"; exit 1" 1 2 15 + $RM "$cfgfile" + + cat <<_LT_EOF >> "$cfgfile" +#! $SHELL + +# `$ECHO "$ofile" | sed 's%^.*/%%'` - Provide generalized library-building support services. +# Generated automatically by $as_me ($PACKAGE$TIMESTAMP) $VERSION +# Libtool was configured on host `(hostname || uname -n) 2>/dev/null | sed 1q`: +# NOTE: Changes made to this file will be lost: look at ltmain.sh. +# +# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, +# 2006, 2007, 2008, 2009, 2010, 2011 Free Software +# Foundation, Inc. +# Written by Gordon Matzigkeit, 1996 +# +# This file is part of GNU Libtool. +# +# GNU Libtool is free software; you can redistribute it and/or +# modify it under the terms of the GNU General Public License as +# published by the Free Software Foundation; either version 2 of +# the License, or (at your option) any later version. +# +# As a special exception to the GNU General Public License, +# if you distribute this file as part of a program or library that +# is built using GNU Libtool, you may include this file under the +# same distribution terms that you use for the rest of that program. +# +# GNU Libtool is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with GNU Libtool; see the file COPYING. If not, a copy +# can be downloaded from http://www.gnu.org/licenses/gpl.html, or +# obtained by writing to the Free Software Foundation, Inc., +# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + + +# The names of the tagged configurations supported by this script. +available_tags="CXX " + +# ### BEGIN LIBTOOL CONFIG + +# Which release of libtool.m4 was used? +macro_version=$macro_version +macro_revision=$macro_revision + +# Assembler program. +AS=$lt_AS + +# DLL creation program. +DLLTOOL=$lt_DLLTOOL + +# Object dumper program. +OBJDUMP=$lt_OBJDUMP + +# Whether or not to build shared libraries. +build_libtool_libs=$enable_shared + +# Whether or not to build static libraries. +build_old_libs=$enable_static + +# What type of objects to build. +pic_mode=$pic_mode + +# Whether or not to optimize for fast installation. +fast_install=$enable_fast_install + +# Shell to use when invoking shell scripts. +SHELL=$lt_SHELL + +# An echo program that protects backslashes. +ECHO=$lt_ECHO + +# The PATH separator for the build system. +PATH_SEPARATOR=$lt_PATH_SEPARATOR + +# The host system. +host_alias=$host_alias +host=$host +host_os=$host_os + +# The build system. +build_alias=$build_alias +build=$build +build_os=$build_os + +# A sed program that does not truncate output. +SED=$lt_SED + +# Sed that helps us avoid accidentally triggering echo(1) options like -n. +Xsed="\$SED -e 1s/^X//" + +# A grep program that handles long lines. +GREP=$lt_GREP + +# An ERE matcher. +EGREP=$lt_EGREP + +# A literal string matcher. +FGREP=$lt_FGREP + +# A BSD- or MS-compatible name lister. +NM=$lt_NM + +# Whether we need soft or hard links. +LN_S=$lt_LN_S + +# What is the maximum length of a command? +max_cmd_len=$max_cmd_len + +# Object file suffix (normally "o"). +objext=$ac_objext + +# Executable file suffix (normally ""). +exeext=$exeext + +# whether the shell understands "unset". +lt_unset=$lt_unset + +# turn spaces into newlines. +SP2NL=$lt_lt_SP2NL + +# turn newlines into spaces. +NL2SP=$lt_lt_NL2SP + +# convert \$build file names to \$host format. +to_host_file_cmd=$lt_cv_to_host_file_cmd + +# convert \$build files to toolchain format. +to_tool_file_cmd=$lt_cv_to_tool_file_cmd + +# Method to check whether dependent libraries are shared objects. +deplibs_check_method=$lt_deplibs_check_method + +# Command to use when deplibs_check_method = "file_magic". +file_magic_cmd=$lt_file_magic_cmd + +# How to find potential files when deplibs_check_method = "file_magic". +file_magic_glob=$lt_file_magic_glob + +# Find potential files using nocaseglob when deplibs_check_method = "file_magic". +want_nocaseglob=$lt_want_nocaseglob + +# Command to associate shared and link libraries. +sharedlib_from_linklib_cmd=$lt_sharedlib_from_linklib_cmd + +# The archiver. +AR=$lt_AR + +# Flags to create an archive. +AR_FLAGS=$lt_AR_FLAGS + +# How to feed a file listing to the archiver. +archiver_list_spec=$lt_archiver_list_spec + +# A symbol stripping program. +STRIP=$lt_STRIP + +# Commands used to install an old-style archive. +RANLIB=$lt_RANLIB +old_postinstall_cmds=$lt_old_postinstall_cmds +old_postuninstall_cmds=$lt_old_postuninstall_cmds + +# Whether to use a lock for old archive extraction. +lock_old_archive_extraction=$lock_old_archive_extraction + +# A C compiler. +LTCC=$lt_CC + +# LTCC compiler flags. +LTCFLAGS=$lt_CFLAGS + +# Take the output of nm and produce a listing of raw symbols and C names. +global_symbol_pipe=$lt_lt_cv_sys_global_symbol_pipe + +# Transform the output of nm in a proper C declaration. +global_symbol_to_cdecl=$lt_lt_cv_sys_global_symbol_to_cdecl + +# Transform the output of nm in a C name address pair. +global_symbol_to_c_name_address=$lt_lt_cv_sys_global_symbol_to_c_name_address + +# Transform the output of nm in a C name address pair when lib prefix is needed. +global_symbol_to_c_name_address_lib_prefix=$lt_lt_cv_sys_global_symbol_to_c_name_address_lib_prefix + +# Specify filename containing input files for \$NM. +nm_file_list_spec=$lt_nm_file_list_spec + +# The root where to search for dependent libraries,and in which our libraries should be installed. +lt_sysroot=$lt_sysroot + +# The name of the directory that contains temporary libtool files. +objdir=$objdir + +# Used to examine libraries when file_magic_cmd begins with "file". +MAGIC_CMD=$MAGIC_CMD + +# Must we lock files when doing compilation? +need_locks=$lt_need_locks + +# Manifest tool. +MANIFEST_TOOL=$lt_MANIFEST_TOOL + +# Tool to manipulate archived DWARF debug symbol files on Mac OS X. +DSYMUTIL=$lt_DSYMUTIL + +# Tool to change global to local symbols on Mac OS X. +NMEDIT=$lt_NMEDIT + +# Tool to manipulate fat objects and archives on Mac OS X. +LIPO=$lt_LIPO + +# ldd/readelf like tool for Mach-O binaries on Mac OS X. +OTOOL=$lt_OTOOL + +# ldd/readelf like tool for 64 bit Mach-O binaries on Mac OS X 10.4. +OTOOL64=$lt_OTOOL64 + +# Old archive suffix (normally "a"). +libext=$libext + +# Shared library suffix (normally ".so"). +shrext_cmds=$lt_shrext_cmds + +# The commands to extract the exported symbol list from a shared archive. +extract_expsyms_cmds=$lt_extract_expsyms_cmds + +# Variables whose values should be saved in libtool wrapper scripts and +# restored at link time. +variables_saved_for_relink=$lt_variables_saved_for_relink + +# Do we need the "lib" prefix for modules? +need_lib_prefix=$need_lib_prefix + +# Do we need a version for libraries? +need_version=$need_version + +# Library versioning type. +version_type=$version_type + +# Shared library runtime path variable. +runpath_var=$runpath_var + +# Shared library path variable. +shlibpath_var=$shlibpath_var + +# Is shlibpath searched before the hard-coded library search path? +shlibpath_overrides_runpath=$shlibpath_overrides_runpath + +# Format of library name prefix. +libname_spec=$lt_libname_spec + +# List of archive names. First name is the real one, the rest are links. +# The last name is the one that the linker finds with -lNAME +library_names_spec=$lt_library_names_spec + +# The coded name of the library, if different from the real name. +soname_spec=$lt_soname_spec + +# Permission mode override for installation of shared libraries. +install_override_mode=$lt_install_override_mode + +# Command to use after installation of a shared archive. +postinstall_cmds=$lt_postinstall_cmds + +# Command to use after uninstallation of a shared archive. +postuninstall_cmds=$lt_postuninstall_cmds + +# Commands used to finish a libtool library installation in a directory. +finish_cmds=$lt_finish_cmds + +# As "finish_cmds", except a single script fragment to be evaled but +# not shown. +finish_eval=$lt_finish_eval + +# Whether we should hardcode library paths into libraries. +hardcode_into_libs=$hardcode_into_libs + +# Compile-time system search path for libraries. +sys_lib_search_path_spec=$lt_sys_lib_search_path_spec + +# Run-time system search path for libraries. +sys_lib_dlsearch_path_spec=$lt_sys_lib_dlsearch_path_spec + +# Whether dlopen is supported. +dlopen_support=$enable_dlopen + +# Whether dlopen of programs is supported. +dlopen_self=$enable_dlopen_self + +# Whether dlopen of statically linked programs is supported. +dlopen_self_static=$enable_dlopen_self_static + +# Commands to strip libraries. +old_striplib=$lt_old_striplib +striplib=$lt_striplib + + +# The linker used to build libraries. +LD=$lt_LD + +# How to create reloadable object files. +reload_flag=$lt_reload_flag +reload_cmds=$lt_reload_cmds + +# Commands used to build an old-style archive. +old_archive_cmds=$lt_old_archive_cmds + +# A language specific compiler. +CC=$lt_compiler + +# Is the compiler the GNU compiler? +with_gcc=$GCC + +# Compiler flag to turn off builtin functions. +no_builtin_flag=$lt_lt_prog_compiler_no_builtin_flag + +# Additional compiler flags for building library objects. +pic_flag=$lt_lt_prog_compiler_pic + +# How to pass a linker flag through the compiler. +wl=$lt_lt_prog_compiler_wl + +# Compiler flag to prevent dynamic linking. +link_static_flag=$lt_lt_prog_compiler_static + +# Does compiler simultaneously support -c and -o options? +compiler_c_o=$lt_lt_cv_prog_compiler_c_o + +# Whether or not to add -lc for building shared libraries. +build_libtool_need_lc=$archive_cmds_need_lc + +# Whether or not to disallow shared libs when runtime libs are static. +allow_libtool_libs_with_static_runtimes=$enable_shared_with_static_runtimes + +# Compiler flag to allow reflexive dlopens. +export_dynamic_flag_spec=$lt_export_dynamic_flag_spec + +# Compiler flag to generate shared objects directly from archives. +whole_archive_flag_spec=$lt_whole_archive_flag_spec + +# Whether the compiler copes with passing no objects directly. +compiler_needs_object=$lt_compiler_needs_object + +# Create an old-style archive from a shared archive. +old_archive_from_new_cmds=$lt_old_archive_from_new_cmds + +# Create a temporary old-style archive to link instead of a shared archive. +old_archive_from_expsyms_cmds=$lt_old_archive_from_expsyms_cmds + +# Commands used to build a shared archive. +archive_cmds=$lt_archive_cmds +archive_expsym_cmds=$lt_archive_expsym_cmds + +# Commands used to build a loadable module if different from building +# a shared archive. +module_cmds=$lt_module_cmds +module_expsym_cmds=$lt_module_expsym_cmds + +# Whether we are building with GNU ld or not. +with_gnu_ld=$lt_with_gnu_ld + +# Flag that allows shared libraries with undefined symbols to be built. +allow_undefined_flag=$lt_allow_undefined_flag + +# Flag that enforces no undefined symbols. +no_undefined_flag=$lt_no_undefined_flag + +# Flag to hardcode \$libdir into a binary during linking. +# This must work even if \$libdir does not exist +hardcode_libdir_flag_spec=$lt_hardcode_libdir_flag_spec + +# Whether we need a single "-rpath" flag with a separated argument. +hardcode_libdir_separator=$lt_hardcode_libdir_separator + +# Set to "yes" if using DIR/libNAME\${shared_ext} during linking hardcodes +# DIR into the resulting binary. +hardcode_direct=$hardcode_direct + +# Set to "yes" if using DIR/libNAME\${shared_ext} during linking hardcodes +# DIR into the resulting binary and the resulting library dependency is +# "absolute",i.e impossible to change by setting \${shlibpath_var} if the +# library is relocated. +hardcode_direct_absolute=$hardcode_direct_absolute + +# Set to "yes" if using the -LDIR flag during linking hardcodes DIR +# into the resulting binary. +hardcode_minus_L=$hardcode_minus_L + +# Set to "yes" if using SHLIBPATH_VAR=DIR during linking hardcodes DIR +# into the resulting binary. +hardcode_shlibpath_var=$hardcode_shlibpath_var + +# Set to "yes" if building a shared library automatically hardcodes DIR +# into the library and all subsequent libraries and executables linked +# against it. +hardcode_automatic=$hardcode_automatic + +# Set to yes if linker adds runtime paths of dependent libraries +# to runtime path list. +inherit_rpath=$inherit_rpath + +# Whether libtool must link a program against all its dependency libraries. +link_all_deplibs=$link_all_deplibs + +# Set to "yes" if exported symbols are required. +always_export_symbols=$always_export_symbols + +# The commands to list exported symbols. +export_symbols_cmds=$lt_export_symbols_cmds + +# Symbols that should not be listed in the preloaded symbols. +exclude_expsyms=$lt_exclude_expsyms + +# Symbols that must always be exported. +include_expsyms=$lt_include_expsyms + +# Commands necessary for linking programs (against libraries) with templates. +prelink_cmds=$lt_prelink_cmds + +# Commands necessary for finishing linking programs. +postlink_cmds=$lt_postlink_cmds + +# Specify filename containing input files. +file_list_spec=$lt_file_list_spec + +# How to hardcode a shared library path into an executable. +hardcode_action=$hardcode_action + +# The directories searched by this compiler when creating a shared library. +compiler_lib_search_dirs=$lt_compiler_lib_search_dirs + +# Dependencies to place before and after the objects being linked to +# create a shared library. +predep_objects=$lt_predep_objects +postdep_objects=$lt_postdep_objects +predeps=$lt_predeps +postdeps=$lt_postdeps + +# The library search path used internally by the compiler when linking +# a shared library. +compiler_lib_search_path=$lt_compiler_lib_search_path + +# ### END LIBTOOL CONFIG + +_LT_EOF + + case $host_os in + aix3*) + cat <<\_LT_EOF >> "$cfgfile" +# AIX sometimes has problems with the GCC collect2 program. For some +# reason, if we set the COLLECT_NAMES environment variable, the problems +# vanish in a puff of smoke. +if test "X${COLLECT_NAMES+set}" != Xset; then + COLLECT_NAMES= + export COLLECT_NAMES +fi +_LT_EOF + ;; + esac + + +ltmain="$ac_aux_dir/ltmain.sh" + + + # We use sed instead of cat because bash on DJGPP gets confused if + # if finds mixed CR/LF and LF-only lines. Since sed operates in + # text mode, it properly converts lines to CR/LF. This bash problem + # is reportedly fixed, but why not run on old versions too? + sed '$q' "$ltmain" >> "$cfgfile" \ + || (rm -f "$cfgfile"; exit 1) + + if test x"$xsi_shell" = xyes; then + sed -e '/^func_dirname ()$/,/^} # func_dirname /c\ +func_dirname ()\ +{\ +\ case ${1} in\ +\ */*) func_dirname_result="${1%/*}${2}" ;;\ +\ * ) func_dirname_result="${3}" ;;\ +\ esac\ +} # Extended-shell func_dirname implementation' "$cfgfile" > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") +test 0 -eq $? || _lt_function_replace_fail=: + + + sed -e '/^func_basename ()$/,/^} # func_basename /c\ +func_basename ()\ +{\ +\ func_basename_result="${1##*/}"\ +} # Extended-shell func_basename implementation' "$cfgfile" > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") +test 0 -eq $? || _lt_function_replace_fail=: + + + sed -e '/^func_dirname_and_basename ()$/,/^} # func_dirname_and_basename /c\ +func_dirname_and_basename ()\ +{\ +\ case ${1} in\ +\ */*) func_dirname_result="${1%/*}${2}" ;;\ +\ * ) func_dirname_result="${3}" ;;\ +\ esac\ +\ func_basename_result="${1##*/}"\ +} # Extended-shell func_dirname_and_basename implementation' "$cfgfile" > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") +test 0 -eq $? || _lt_function_replace_fail=: + + + sed -e '/^func_stripname ()$/,/^} # func_stripname /c\ +func_stripname ()\ +{\ +\ # pdksh 5.2.14 does not do ${X%$Y} correctly if both X and Y are\ +\ # positional parameters, so assign one to ordinary parameter first.\ +\ func_stripname_result=${3}\ +\ func_stripname_result=${func_stripname_result#"${1}"}\ +\ func_stripname_result=${func_stripname_result%"${2}"}\ +} # Extended-shell func_stripname implementation' "$cfgfile" > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") +test 0 -eq $? || _lt_function_replace_fail=: + + + sed -e '/^func_split_long_opt ()$/,/^} # func_split_long_opt /c\ +func_split_long_opt ()\ +{\ +\ func_split_long_opt_name=${1%%=*}\ +\ func_split_long_opt_arg=${1#*=}\ +} # Extended-shell func_split_long_opt implementation' "$cfgfile" > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") +test 0 -eq $? || _lt_function_replace_fail=: + + + sed -e '/^func_split_short_opt ()$/,/^} # func_split_short_opt /c\ +func_split_short_opt ()\ +{\ +\ func_split_short_opt_arg=${1#??}\ +\ func_split_short_opt_name=${1%"$func_split_short_opt_arg"}\ +} # Extended-shell func_split_short_opt implementation' "$cfgfile" > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") +test 0 -eq $? || _lt_function_replace_fail=: + + + sed -e '/^func_lo2o ()$/,/^} # func_lo2o /c\ +func_lo2o ()\ +{\ +\ case ${1} in\ +\ *.lo) func_lo2o_result=${1%.lo}.${objext} ;;\ +\ *) func_lo2o_result=${1} ;;\ +\ esac\ +} # Extended-shell func_lo2o implementation' "$cfgfile" > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") +test 0 -eq $? || _lt_function_replace_fail=: + + + sed -e '/^func_xform ()$/,/^} # func_xform /c\ +func_xform ()\ +{\ + func_xform_result=${1%.*}.lo\ +} # Extended-shell func_xform implementation' "$cfgfile" > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") +test 0 -eq $? || _lt_function_replace_fail=: + + + sed -e '/^func_arith ()$/,/^} # func_arith /c\ +func_arith ()\ +{\ + func_arith_result=$(( $* ))\ +} # Extended-shell func_arith implementation' "$cfgfile" > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") +test 0 -eq $? || _lt_function_replace_fail=: + + + sed -e '/^func_len ()$/,/^} # func_len /c\ +func_len ()\ +{\ + func_len_result=${#1}\ +} # Extended-shell func_len implementation' "$cfgfile" > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") +test 0 -eq $? || _lt_function_replace_fail=: + +fi + +if test x"$lt_shell_append" = xyes; then + sed -e '/^func_append ()$/,/^} # func_append /c\ +func_append ()\ +{\ + eval "${1}+=\\${2}"\ +} # Extended-shell func_append implementation' "$cfgfile" > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") +test 0 -eq $? || _lt_function_replace_fail=: + + + sed -e '/^func_append_quoted ()$/,/^} # func_append_quoted /c\ +func_append_quoted ()\ +{\ +\ func_quote_for_eval "${2}"\ +\ eval "${1}+=\\\\ \\$func_quote_for_eval_result"\ +} # Extended-shell func_append_quoted implementation' "$cfgfile" > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") +test 0 -eq $? || _lt_function_replace_fail=: + + + # Save a `func_append' function call where possible by direct use of '+=' + sed -e 's%func_append \([a-zA-Z_]\{1,\}\) "%\1+="%g' $cfgfile > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") + test 0 -eq $? || _lt_function_replace_fail=: +else + # Save a `func_append' function call even when '+=' is not available + sed -e 's%func_append \([a-zA-Z_]\{1,\}\) "%\1="$\1%g' $cfgfile > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") + test 0 -eq $? || _lt_function_replace_fail=: +fi + +if test x"$_lt_function_replace_fail" = x":"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Unable to substitute extended shell functions in $ofile" >&5 +$as_echo "$as_me: WARNING: Unable to substitute extended shell functions in $ofile" >&2;} +fi + + + mv -f "$cfgfile" "$ofile" || + (rm -f "$ofile" && cp "$cfgfile" "$ofile" && rm -f "$cfgfile") + chmod +x "$ofile" + + + cat <<_LT_EOF >> "$ofile" + +# ### BEGIN LIBTOOL TAG CONFIG: CXX + +# The linker used to build libraries. +LD=$lt_LD_CXX + +# How to create reloadable object files. +reload_flag=$lt_reload_flag_CXX +reload_cmds=$lt_reload_cmds_CXX + +# Commands used to build an old-style archive. +old_archive_cmds=$lt_old_archive_cmds_CXX + +# A language specific compiler. +CC=$lt_compiler_CXX + +# Is the compiler the GNU compiler? +with_gcc=$GCC_CXX + +# Compiler flag to turn off builtin functions. +no_builtin_flag=$lt_lt_prog_compiler_no_builtin_flag_CXX + +# Additional compiler flags for building library objects. +pic_flag=$lt_lt_prog_compiler_pic_CXX + +# How to pass a linker flag through the compiler. +wl=$lt_lt_prog_compiler_wl_CXX + +# Compiler flag to prevent dynamic linking. +link_static_flag=$lt_lt_prog_compiler_static_CXX + +# Does compiler simultaneously support -c and -o options? +compiler_c_o=$lt_lt_cv_prog_compiler_c_o_CXX + +# Whether or not to add -lc for building shared libraries. +build_libtool_need_lc=$archive_cmds_need_lc_CXX + +# Whether or not to disallow shared libs when runtime libs are static. +allow_libtool_libs_with_static_runtimes=$enable_shared_with_static_runtimes_CXX + +# Compiler flag to allow reflexive dlopens. +export_dynamic_flag_spec=$lt_export_dynamic_flag_spec_CXX + +# Compiler flag to generate shared objects directly from archives. +whole_archive_flag_spec=$lt_whole_archive_flag_spec_CXX + +# Whether the compiler copes with passing no objects directly. +compiler_needs_object=$lt_compiler_needs_object_CXX + +# Create an old-style archive from a shared archive. +old_archive_from_new_cmds=$lt_old_archive_from_new_cmds_CXX + +# Create a temporary old-style archive to link instead of a shared archive. +old_archive_from_expsyms_cmds=$lt_old_archive_from_expsyms_cmds_CXX + +# Commands used to build a shared archive. +archive_cmds=$lt_archive_cmds_CXX +archive_expsym_cmds=$lt_archive_expsym_cmds_CXX + +# Commands used to build a loadable module if different from building +# a shared archive. +module_cmds=$lt_module_cmds_CXX +module_expsym_cmds=$lt_module_expsym_cmds_CXX + +# Whether we are building with GNU ld or not. +with_gnu_ld=$lt_with_gnu_ld_CXX + +# Flag that allows shared libraries with undefined symbols to be built. +allow_undefined_flag=$lt_allow_undefined_flag_CXX + +# Flag that enforces no undefined symbols. +no_undefined_flag=$lt_no_undefined_flag_CXX + +# Flag to hardcode \$libdir into a binary during linking. +# This must work even if \$libdir does not exist +hardcode_libdir_flag_spec=$lt_hardcode_libdir_flag_spec_CXX + +# Whether we need a single "-rpath" flag with a separated argument. +hardcode_libdir_separator=$lt_hardcode_libdir_separator_CXX + +# Set to "yes" if using DIR/libNAME\${shared_ext} during linking hardcodes +# DIR into the resulting binary. +hardcode_direct=$hardcode_direct_CXX + +# Set to "yes" if using DIR/libNAME\${shared_ext} during linking hardcodes +# DIR into the resulting binary and the resulting library dependency is +# "absolute",i.e impossible to change by setting \${shlibpath_var} if the +# library is relocated. +hardcode_direct_absolute=$hardcode_direct_absolute_CXX + +# Set to "yes" if using the -LDIR flag during linking hardcodes DIR +# into the resulting binary. +hardcode_minus_L=$hardcode_minus_L_CXX + +# Set to "yes" if using SHLIBPATH_VAR=DIR during linking hardcodes DIR +# into the resulting binary. +hardcode_shlibpath_var=$hardcode_shlibpath_var_CXX + +# Set to "yes" if building a shared library automatically hardcodes DIR +# into the library and all subsequent libraries and executables linked +# against it. +hardcode_automatic=$hardcode_automatic_CXX + +# Set to yes if linker adds runtime paths of dependent libraries +# to runtime path list. +inherit_rpath=$inherit_rpath_CXX + +# Whether libtool must link a program against all its dependency libraries. +link_all_deplibs=$link_all_deplibs_CXX + +# Set to "yes" if exported symbols are required. +always_export_symbols=$always_export_symbols_CXX + +# The commands to list exported symbols. +export_symbols_cmds=$lt_export_symbols_cmds_CXX + +# Symbols that should not be listed in the preloaded symbols. +exclude_expsyms=$lt_exclude_expsyms_CXX + +# Symbols that must always be exported. +include_expsyms=$lt_include_expsyms_CXX + +# Commands necessary for linking programs (against libraries) with templates. +prelink_cmds=$lt_prelink_cmds_CXX + +# Commands necessary for finishing linking programs. +postlink_cmds=$lt_postlink_cmds_CXX + +# Specify filename containing input files. +file_list_spec=$lt_file_list_spec_CXX + +# How to hardcode a shared library path into an executable. +hardcode_action=$hardcode_action_CXX + +# The directories searched by this compiler when creating a shared library. +compiler_lib_search_dirs=$lt_compiler_lib_search_dirs_CXX + +# Dependencies to place before and after the objects being linked to +# create a shared library. +predep_objects=$lt_predep_objects_CXX +postdep_objects=$lt_postdep_objects_CXX +predeps=$lt_predeps_CXX +postdeps=$lt_postdeps_CXX + +# The library search path used internally by the compiler when linking +# a shared library. +compiler_lib_search_path=$lt_compiler_lib_search_path_CXX + +# ### END LIBTOOL TAG CONFIG: CXX +_LT_EOF + + +as_fn_exit 0 +_LTEOF +chmod +x "$CONFIG_LT" + +# configure is writing to config.log, but config.lt does its own redirection, +# appending to config.log, which fails on DOS, as config.log is still kept +# open by configure. Here we exec the FD to /dev/null, effectively closing +# config.log, so it can be properly (re)opened and appended to by config.lt. +lt_cl_success=: +test "$silent" = yes && + lt_config_lt_args="$lt_config_lt_args --quiet" +exec 5>/dev/null +$SHELL "$CONFIG_LT" $lt_config_lt_args || lt_cl_success=false +exec 5>>config.log +$lt_cl_success || as_fn_exit 1 + + +# Check for Windows. +# +win32=no +case $host_os in + windows* | mingw*) + win32=yes + ;; +esac + + if test x$win32 = xyes; then + ODB_WIN32_TRUE= + ODB_WIN32_FALSE='#' +else + ODB_WIN32_TRUE='#' + ODB_WIN32_FALSE= +fi + + +# Check for threads. +# + + +threads_thread_keyword=no + +# Check whether --enable-threads was given. +if test "${enable_threads+set}" = set; then : + enableval=$enable_threads; if test x"$enableval" = xno; then : + threads=none +else + threads=check +fi +else + threads=check +fi + + +# If thread support is not disabled by the user, figure out what we can use. +# +if test x$threads = xcheck; then + case $host_os in + windows* | mingw*) + case $host_os in + mingw*) + CXXFLAGS="$CXXFLAGS -mthreads" + ;; + esac + + # Newer versions of GCC can be configured to use either Win32 or POSIX + # threads. It appears that -mthreads should be used in both cases but + # if the model is POSIX then GCC will also link -lpthread by default. + # Use that fact to test which model we have. + # + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +int +main () +{ +pthread_create(0,0,0,0); + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_link "$LINENO"; then : + threads=posix +else + threads=win32 +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext + ;; + *) + + + +ac_ext=cpp +ac_cpp='$CXXCPP $CPPFLAGS' +ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_cxx_compiler_gnu + +acx_pthread_ok=no + +# We used to check for pthread.h first, but this fails if pthread.h +# requires special compiler flags (e.g. on True64 or Sequent). +# It gets checked for in the link test anyway. + +# First of all, check if the user has set any of the PTHREAD_LIBS, +# etcetera environment variables, and if threads linking works using +# them: +if test x"$PTHREAD_LIBS$PTHREAD_CXXFLAGS" != x; then + save_CXXFLAGS="$CXXFLAGS" + CXXFLAGS="$CXXFLAGS $PTHREAD_CXXFLAGS" + save_LIBS="$LIBS" + LIBS="$PTHREAD_LIBS $LIBS" + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for pthread_join in LIBS=$PTHREAD_LIBS with CXXFLAGS=$PTHREAD_CXXFLAGS" >&5 +$as_echo_n "checking for pthread_join in LIBS=$PTHREAD_LIBS with CXXFLAGS=$PTHREAD_CXXFLAGS... " >&6; } + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char pthread_join (); +int +main () +{ +return pthread_join (); + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_link "$LINENO"; then : + acx_pthread_ok=yes +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $acx_pthread_ok" >&5 +$as_echo "$acx_pthread_ok" >&6; } + if test x"$acx_pthread_ok" = xno; then + PTHREAD_LIBS="" + PTHREAD_CXXFLAGS="" + fi + LIBS="$save_LIBS" + CXXFLAGS="$save_CXXFLAGS" +fi + +# We must check for the threads library under a number of different +# names; the ordering is very important because some systems +# (e.g. DEC) have both -lpthread and -lpthreads, where one of the +# libraries is broken (non-POSIX). + +# Create a list of thread flags to try. Items starting with a "-" are +# C compiler flags, and other items are library names, except for "none" +# which indicates that we try without any flags at all, and "pthread-config" +# which is a program returning the flags for the Pth emulation library. + +# CS: On GNU/Linux with gcc both -pthread and -lpthread are valid. +# However, libtool links libraries with -nostdlib which results in +# -pthread being stripped from the linker command line. To resolve +# this we move pthread from after -mthreads to after pthreads. +# +acx_pthread_flags="pthreads pthread none -Kthread -kthread lthread -pthread -pthreads -mthreads --thread-safe -mt pthread-config" + +# The ordering *is* (sometimes) important. Some notes on the +# individual items follow: + +# pthreads: AIX (must check this before -lpthread) +# none: in case threads are in libc; should be tried before -Kthread and +# other compiler flags to prevent continual compiler warnings +# -Kthread: Sequent (threads in libc, but -Kthread needed for pthread.h) +# -kthread: FreeBSD kernel threads (preferred to -pthread since SMP-able) +# lthread: LinuxThreads port on FreeBSD (also preferred to -pthread) +# -pthread: Linux/gcc (kernel threads), BSD/gcc (userland threads) +# -pthreads: Solaris/gcc +# -mthreads: Mingw32/gcc, Lynx/gcc +# -mt: Sun Workshop C (may only link SunOS threads [-lthread], but it +# doesn't hurt to check since this sometimes defines pthreads too; +# also defines -D_REENTRANT) +# ... -mt is also the pthreads flag for HP/aCC +# pthread: Linux, etcetera +# --thread-safe: KAI C++ +# pthread-config: use pthread-config program (for GNU Pth library) + +case "${host_cpu}-${host_os}" in + *solaris*) + + # On Solaris (at least, for some versions), libc contains stubbed + # (non-functional) versions of the pthreads routines, so link-based + # tests will erroneously succeed. (We need to link with -pthreads/-mt/ + # -lpthread.) (The stubs are missing pthread_cleanup_push, or rather + # a function called by this macro, so we could check for that, but + # who knows whether they'll stub that too in a future libc.) So, + # we'll just look for -pthreads and -lpthread first: + + # CS: Move -mt to the front of the list; Sun CC will use -mt, + # gcc will use -pthreads. + # + acx_pthread_flags="-mt -pthreads pthread -pthread $acx_pthread_flags" + ;; +esac + +if test x"$acx_pthread_ok" = xno; then +for flag in $acx_pthread_flags; do + + case $flag in + none) + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether pthreads work without any flags" >&5 +$as_echo_n "checking whether pthreads work without any flags... " >&6; } + ;; + + -*) + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether pthreads work with $flag" >&5 +$as_echo_n "checking whether pthreads work with $flag... " >&6; } + PTHREAD_CXXFLAGS="$flag" + ;; + + pthread-config) + # Extract the first word of "pthread-config", so it can be a program name with args. +set dummy pthread-config; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_acx_pthread_config+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$acx_pthread_config"; then + ac_cv_prog_acx_pthread_config="$acx_pthread_config" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_acx_pthread_config="yes" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + test -z "$ac_cv_prog_acx_pthread_config" && ac_cv_prog_acx_pthread_config="no" +fi +fi +acx_pthread_config=$ac_cv_prog_acx_pthread_config +if test -n "$acx_pthread_config"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $acx_pthread_config" >&5 +$as_echo "$acx_pthread_config" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + if test x"$acx_pthread_config" = xno; then continue; fi + PTHREAD_CXXFLAGS="`pthread-config --cflags`" + PTHREAD_LIBS="`pthread-config --ldflags` `pthread-config --libs`" + ;; + + *) + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for the pthreads library -l$flag" >&5 +$as_echo_n "checking for the pthreads library -l$flag... " >&6; } + PTHREAD_LIBS="-l$flag" + ;; + esac + + save_LIBS="$LIBS" + save_CXXFLAGS="$CXXFLAGS" + LIBS="$PTHREAD_LIBS $LIBS" + CXXFLAGS="$CXXFLAGS $PTHREAD_CXXFLAGS" + + # Check for various functions. We must include pthread.h, + # since some functions may be macros. (On the Sequent, we + # need a special flag -Kthread to make this header compile.) + # We check for pthread_join because it is in -lpthread on IRIX + # while pthread_create is in libc. We check for pthread_attr_init + # due to DEC craziness with -lpthreads. We check for + # pthread_cleanup_push because it is one of the few pthread + # functions on Solaris that doesn't have a non-functional libc stub. + # We try pthread_create on general principles. + # + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +int +main () +{ +pthread_t th; pthread_join(th, 0); + pthread_attr_init(0); pthread_cleanup_push(0, 0); + pthread_create(0,0,0,0); pthread_cleanup_pop(0); + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_link "$LINENO"; then : + acx_pthread_ok=yes +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext + + LIBS="$save_LIBS" + CXXFLAGS="$save_CXXFLAGS" + + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $acx_pthread_ok" >&5 +$as_echo "$acx_pthread_ok" >&6; } + if test "x$acx_pthread_ok" = xyes; then + break; + fi + + PTHREAD_LIBS="" + PTHREAD_CXXFLAGS="" +done +fi + +# Various other checks: +if test "x$acx_pthread_ok" = xyes; then + save_LIBS="$LIBS" + LIBS="$PTHREAD_LIBS $LIBS" + save_CXXFLAGS="$CXXFLAGS" + CXXFLAGS="$CXXFLAGS $PTHREAD_CXXFLAGS" + + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking if more special flags are required for pthreads" >&5 +$as_echo_n "checking if more special flags are required for pthreads... " >&6; } + flag=no + case "${host_cpu}-${host_os}" in + *-aix* | *-freebsd* | *-darwin*) flag="-D_THREAD_SAFE";; + # CS: Add _REENTRANT in Linux to emulate -pthread. + # + *-linux* | *solaris* | *-osf* | *-hpux*) flag="-D_REENTRANT";; + esac + { $as_echo "$as_me:${as_lineno-$LINENO}: result: ${flag}" >&5 +$as_echo "${flag}" >&6; } + if test "x$flag" != xno; then + PTHREAD_CXXFLAGS="$flag $PTHREAD_CXXFLAGS" + fi + + LIBS="$save_LIBS" + CXXFLAGS="$save_CXXFLAGS" + + +else + PTHREAD_CXX="$CXX" +fi + + + + + +# Finally, execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND: +if test x"$acx_pthread_ok" = xyes; then + +$as_echo "#define HAVE_PTHREAD 1" >>confdefs.h + + : +else + acx_pthread_ok=no + +fi +ac_ext=cpp +ac_cpp='$CXXCPP $CPPFLAGS' +ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_cxx_compiler_gnu + + + + if test x$acx_pthread_ok = xyes; then + threads=posix + LIBS="$LIBS $PTHREAD_LIBS" + CXXFLAGS="$CXXFLAGS $PTHREAD_CXXFLAGS" + + # Check if we can use the __thread keyword. + # + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for __thread keyword" >&5 +$as_echo_n "checking for __thread keyword... " >&6; } + + + +ac_ext=cpp +ac_cpp='$CXXCPP $CPPFLAGS' +ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_cxx_compiler_gnu + + +if test -d .libs; then + delete_libs_dir=no +else + delete_libs_dir=yes +fi + +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + + + __thread int tls_var; + + int + main () + { + tls_var = 0; + } + +_ACEOF +if ac_fn_cxx_try_compile "$LINENO"; then : + + ac_try='./libtool --tag=CXX --mode=link $CXX -no-install $CXXFLAGS $LDFLAGS -o conftest conftest.$OBJEXT $LIBS >&5' + if { { case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_try") 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then + libtool_link_ok=yes + else + libtool_link_ok=no + fi + +else + + libtool_link_ok=no + +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext + +if test x"$delete_libs_dir" = xyes; then + rm -rf .libs +fi + +if test x"$libtool_link_ok" = xyes; then +threads_thread_keyword=yes +: +else + +: +fi + +ac_ext=cpp +ac_cpp='$CXXCPP $CPPFLAGS' +ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_cxx_compiler_gnu + + + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $threads_thread_keyword" >&5 +$as_echo "$threads_thread_keyword" >&6; } + fi + ;; + esac +fi + +if test x$threads = xcheck; then + as_fn_error $? "thread support not available; use --disable-threads to force single-threaded mode" "$LINENO" 5 +fi + + + if test x$threads = xnone; then + ODB_THREADS_NONE_TRUE= + ODB_THREADS_NONE_FALSE='#' +else + ODB_THREADS_NONE_TRUE='#' + ODB_THREADS_NONE_FALSE= +fi + + if test x$threads = xwin32; then + ODB_THREADS_WIN32_TRUE= + ODB_THREADS_WIN32_FALSE='#' +else + ODB_THREADS_WIN32_TRUE='#' + ODB_THREADS_WIN32_FALSE= +fi + + if test x$threads = xposix; then + ODB_THREADS_POSIX_TRUE= + ODB_THREADS_POSIX_FALSE='#' +else + ODB_THREADS_POSIX_TRUE='#' + ODB_THREADS_POSIX_FALSE= +fi + + +if test x$threads = xnone; then : + +$as_echo "#define ODB_THREADS_NONE 1" >>confdefs.h + +fi +if test x$threads = xwin32; then : + +$as_echo "#define ODB_THREADS_WIN32 1" >>confdefs.h + +fi +if test x$threads = xposix; then : + +$as_echo "#define ODB_THREADS_POSIX 1" >>confdefs.h + +fi + +if test x$threads_thread_keyword = xyes; then : + +$as_echo "#define ODB_THREADS_TLS_KEYWORD 1" >>confdefs.h + +fi + +# Define LIBODB_STATIC_LIB if we are build static library on certain platforms. +# + +if test x$enable_shared = xno; then + case $host_os in + mingw*) + +$as_echo "#define LIBODB_STATIC_LIB 1" >>confdefs.h + + ;; + esac +fi + + +# Allow the user to specify the pkgconfig directory. +# + + +# Check whether --with-pkgconfigdir was given. +if test "${with_pkgconfigdir+set}" = set; then : + withval=$with_pkgconfigdir; pkgconfigdir=${withval} +else + pkgconfigdir='${libdir}/pkgconfig' +fi + + + + +# Check if we should disable rpath. +# + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to use rpath" >&5 +$as_echo_n "checking whether to use rpath... " >&6; } +# Check whether --enable-rpath was given. +if test "${enable_rpath+set}" = set; then : + enableval=$enable_rpath; libtool_rpath="$enable_rpath" +else + libtool_rpath="yes" +fi + +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $libtool_rpath" >&5 +$as_echo "$libtool_rpath" >&6; } + +# Patch libtool to not use rpath if requested. +# +ac_config_commands="$ac_config_commands libtool-rpath-patch" + + + +# Output. +# +ac_config_headers="$ac_config_headers odb/config.h odb/details/config.h" + +ac_config_files="$ac_config_files libodb.pc Makefile odb/Makefile" + +cat >confcache <<\_ACEOF +# This file is a shell script that caches the results of configure +# tests run on this system so they can be shared between configure +# scripts and configure runs, see configure's option --config-cache. +# It is not useful on other systems. If it contains results you don't +# want to keep, you may remove or edit it. +# +# config.status only pays attention to the cache file if you give it +# the --recheck option to rerun configure. +# +# `ac_cv_env_foo' variables (set or unset) will be overridden when +# loading this file, other *unset* `ac_cv_foo' will be assigned the +# following values. + +_ACEOF + +# The following way of writing the cache mishandles newlines in values, +# but we know of no workaround that is simple, portable, and efficient. +# So, we kill variables containing newlines. +# Ultrix sh set writes to stderr and can't be redirected directly, +# and sets the high bit in the cache file unless we assign to the vars. +( + for ac_var in `(set) 2>&1 | sed -n 's/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'`; do + eval ac_val=\$$ac_var + case $ac_val in #( + *${as_nl}*) + case $ac_var in #( + *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5 +$as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;; + esac + case $ac_var in #( + _ | IFS | as_nl) ;; #( + BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #( + *) { eval $ac_var=; unset $ac_var;} ;; + esac ;; + esac + done + + (set) 2>&1 | + case $as_nl`(ac_space=' '; set) 2>&1` in #( + *${as_nl}ac_space=\ *) + # `set' does not quote correctly, so add quotes: double-quote + # substitution turns \\\\ into \\, and sed turns \\ into \. + sed -n \ + "s/'/'\\\\''/g; + s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p" + ;; #( + *) + # `set' quotes correctly as required by POSIX, so do not add quotes. + sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p" + ;; + esac | + sort +) | + sed ' + /^ac_cv_env_/b end + t clear + :clear + s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/ + t end + s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/ + :end' >>confcache +if diff "$cache_file" confcache >/dev/null 2>&1; then :; else + if test -w "$cache_file"; then + if test "x$cache_file" != "x/dev/null"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: updating cache $cache_file" >&5 +$as_echo "$as_me: updating cache $cache_file" >&6;} + if test ! -f "$cache_file" || test -h "$cache_file"; then + cat confcache >"$cache_file" + else + case $cache_file in #( + */* | ?:*) + mv -f confcache "$cache_file"$$ && + mv -f "$cache_file"$$ "$cache_file" ;; #( + *) + mv -f confcache "$cache_file" ;; + esac + fi + fi + else + { $as_echo "$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file" >&5 +$as_echo "$as_me: not updating unwritable cache $cache_file" >&6;} + fi +fi +rm -f confcache + +test "x$prefix" = xNONE && prefix=$ac_default_prefix +# Let make expand exec_prefix. +test "x$exec_prefix" = xNONE && exec_prefix='${prefix}' + +DEFS=-DHAVE_CONFIG_H + +ac_libobjs= +ac_ltlibobjs= +U= +for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue + # 1. Remove the extension, and $U if already installed. + ac_script='s/\$U\././;s/\.o$//;s/\.obj$//' + ac_i=`$as_echo "$ac_i" | sed "$ac_script"` + # 2. Prepend LIBOBJDIR. When used with automake>=1.10 LIBOBJDIR + # will be set to the directory where LIBOBJS objects are built. + as_fn_append ac_libobjs " \${LIBOBJDIR}$ac_i\$U.$ac_objext" + as_fn_append ac_ltlibobjs " \${LIBOBJDIR}$ac_i"'$U.lo' +done +LIBOBJS=$ac_libobjs + +LTLIBOBJS=$ac_ltlibobjs + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking that generated files are newer than configure" >&5 +$as_echo_n "checking that generated files are newer than configure... " >&6; } + if test -n "$am_sleep_pid"; then + # Hide warnings about reused PIDs. + wait $am_sleep_pid 2>/dev/null + fi + { $as_echo "$as_me:${as_lineno-$LINENO}: result: done" >&5 +$as_echo "done" >&6; } + if test -n "$EXEEXT"; then + am__EXEEXT_TRUE= + am__EXEEXT_FALSE='#' +else + am__EXEEXT_TRUE='#' + am__EXEEXT_FALSE= +fi + +if test -z "${AMDEP_TRUE}" && test -z "${AMDEP_FALSE}"; then + as_fn_error $? "conditional \"AMDEP\" was never defined. +Usually this means the macro was only invoked conditionally." "$LINENO" 5 +fi +if test -z "${am__fastdepCC_TRUE}" && test -z "${am__fastdepCC_FALSE}"; then + as_fn_error $? "conditional \"am__fastdepCC\" was never defined. +Usually this means the macro was only invoked conditionally." "$LINENO" 5 +fi +if test -z "${am__fastdepCXX_TRUE}" && test -z "${am__fastdepCXX_FALSE}"; then + as_fn_error $? "conditional \"am__fastdepCXX\" was never defined. +Usually this means the macro was only invoked conditionally." "$LINENO" 5 +fi +if test -z "${ODB_WIN32_TRUE}" && test -z "${ODB_WIN32_FALSE}"; then + as_fn_error $? "conditional \"ODB_WIN32\" was never defined. +Usually this means the macro was only invoked conditionally." "$LINENO" 5 +fi +if test -z "${ODB_THREADS_NONE_TRUE}" && test -z "${ODB_THREADS_NONE_FALSE}"; then + as_fn_error $? "conditional \"ODB_THREADS_NONE\" was never defined. +Usually this means the macro was only invoked conditionally." "$LINENO" 5 +fi +if test -z "${ODB_THREADS_WIN32_TRUE}" && test -z "${ODB_THREADS_WIN32_FALSE}"; then + as_fn_error $? "conditional \"ODB_THREADS_WIN32\" was never defined. +Usually this means the macro was only invoked conditionally." "$LINENO" 5 +fi +if test -z "${ODB_THREADS_POSIX_TRUE}" && test -z "${ODB_THREADS_POSIX_FALSE}"; then + as_fn_error $? "conditional \"ODB_THREADS_POSIX\" was never defined. +Usually this means the macro was only invoked conditionally." "$LINENO" 5 +fi + +: "${CONFIG_STATUS=./config.status}" +ac_write_fail=0 +ac_clean_files_save=$ac_clean_files +ac_clean_files="$ac_clean_files $CONFIG_STATUS" +{ $as_echo "$as_me:${as_lineno-$LINENO}: creating $CONFIG_STATUS" >&5 +$as_echo "$as_me: creating $CONFIG_STATUS" >&6;} +as_write_fail=0 +cat >$CONFIG_STATUS <<_ASEOF || as_write_fail=1 +#! $SHELL +# Generated by $as_me. +# Run this file to recreate the current configuration. +# Compiler output produced by configure, useful for debugging +# configure, is in config.log if it exists. + +debug=false +ac_cs_recheck=false +ac_cs_silent=false + +SHELL=\${CONFIG_SHELL-$SHELL} +export SHELL +_ASEOF +cat >>$CONFIG_STATUS <<\_ASEOF || as_write_fail=1 +## -------------------- ## +## M4sh Initialization. ## +## -------------------- ## + +# Be more Bourne compatible +DUALCASE=1; export DUALCASE # for MKS sh +if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then : + emulate sh + NULLCMD=: + # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which + # is contrary to our usage. Disable this feature. + alias -g '${1+"$@"}'='"$@"' + setopt NO_GLOB_SUBST +else + case `(set -o) 2>/dev/null` in #( + *posix*) : + set -o posix ;; #( + *) : + ;; +esac +fi + + +as_nl=' +' +export as_nl +# Printing a long string crashes Solaris 7 /usr/bin/printf. +as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' +as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo +as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo +# Prefer a ksh shell builtin over an external printf program on Solaris, +# but without wasting forks for bash or zsh. +if test -z "$BASH_VERSION$ZSH_VERSION" \ + && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then + as_echo='print -r --' + as_echo_n='print -rn --' +elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then + as_echo='printf %s\n' + as_echo_n='printf %s' +else + if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then + as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"' + as_echo_n='/usr/ucb/echo -n' + else + as_echo_body='eval expr "X$1" : "X\\(.*\\)"' + as_echo_n_body='eval + arg=$1; + case $arg in #( + *"$as_nl"*) + expr "X$arg" : "X\\(.*\\)$as_nl"; + arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;; + esac; + expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl" + ' + export as_echo_n_body + as_echo_n='sh -c $as_echo_n_body as_echo' + fi + export as_echo_body + as_echo='sh -c $as_echo_body as_echo' +fi + +# The user is always right. +if test "${PATH_SEPARATOR+set}" != set; then + PATH_SEPARATOR=: + (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && { + (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 || + PATH_SEPARATOR=';' + } +fi + + +# IFS +# We need space, tab and new line, in precisely that order. Quoting is +# there to prevent editors from complaining about space-tab. +# (If _AS_PATH_WALK were called with IFS unset, it would disable word +# splitting by setting IFS to empty value.) +IFS=" "" $as_nl" + +# Find who we are. Look in the path if we contain no directory separator. +as_myself= +case $0 in #(( + *[\\/]* ) as_myself=$0 ;; + *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break + done +IFS=$as_save_IFS + + ;; +esac +# We did not find ourselves, most probably we were run as `sh COMMAND' +# in which case we are not to be found in the path. +if test "x$as_myself" = x; then + as_myself=$0 +fi +if test ! -f "$as_myself"; then + $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2 + exit 1 +fi + +# Unset variables that we do not need and which cause bugs (e.g. in +# pre-3.0 UWIN ksh). But do not cause bugs in bash 2.01; the "|| exit 1" +# suppresses any "Segmentation fault" message there. '((' could +# trigger a bug in pdksh 5.2.14. +for as_var in BASH_ENV ENV MAIL MAILPATH +do eval test x\${$as_var+set} = xset \ + && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || : +done +PS1='$ ' +PS2='> ' +PS4='+ ' + +# NLS nuisances. +LC_ALL=C +export LC_ALL +LANGUAGE=C +export LANGUAGE + +# CDPATH. +(unset CDPATH) >/dev/null 2>&1 && unset CDPATH + + +# as_fn_error STATUS ERROR [LINENO LOG_FD] +# ---------------------------------------- +# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are +# provided, also output the error to LOG_FD, referencing LINENO. Then exit the +# script with STATUS, using 1 if that was 0. +as_fn_error () +{ + as_status=$1; test $as_status -eq 0 && as_status=1 + if test "$4"; then + as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4 + fi + $as_echo "$as_me: error: $2" >&2 + as_fn_exit $as_status +} # as_fn_error + + +# as_fn_set_status STATUS +# ----------------------- +# Set $? to STATUS, without forking. +as_fn_set_status () +{ + return $1 +} # as_fn_set_status + +# as_fn_exit STATUS +# ----------------- +# Exit the shell with STATUS, even in a "trap 0" or "set -e" context. +as_fn_exit () +{ + set +e + as_fn_set_status $1 + exit $1 +} # as_fn_exit + +# as_fn_unset VAR +# --------------- +# Portably unset VAR. +as_fn_unset () +{ + { eval $1=; unset $1;} +} +as_unset=as_fn_unset +# as_fn_append VAR VALUE +# ---------------------- +# Append the text in VALUE to the end of the definition contained in VAR. Take +# advantage of any shell optimizations that allow amortized linear growth over +# repeated appends, instead of the typical quadratic growth present in naive +# implementations. +if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then : + eval 'as_fn_append () + { + eval $1+=\$2 + }' +else + as_fn_append () + { + eval $1=\$$1\$2 + } +fi # as_fn_append + +# as_fn_arith ARG... +# ------------------ +# Perform arithmetic evaluation on the ARGs, and store the result in the +# global $as_val. Take advantage of shells that can avoid forks. The arguments +# must be portable across $(()) and expr. +if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then : + eval 'as_fn_arith () + { + as_val=$(( $* )) + }' +else + as_fn_arith () + { + as_val=`expr "$@" || test $? -eq 1` + } +fi # as_fn_arith + + +if expr a : '\(a\)' >/dev/null 2>&1 && + test "X`expr 00001 : '.*\(...\)'`" = X001; then + as_expr=expr +else + as_expr=false +fi + +if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then + as_basename=basename +else + as_basename=false +fi + +if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then + as_dirname=dirname +else + as_dirname=false +fi + +as_me=`$as_basename -- "$0" || +$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ + X"$0" : 'X\(//\)$' \| \ + X"$0" : 'X\(/\)' \| . 2>/dev/null || +$as_echo X/"$0" | + sed '/^.*\/\([^/][^/]*\)\/*$/{ + s//\1/ + q + } + /^X\/\(\/\/\)$/{ + s//\1/ + q + } + /^X\/\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q'` + +# Avoid depending upon Character Ranges. +as_cr_letters='abcdefghijklmnopqrstuvwxyz' +as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ' +as_cr_Letters=$as_cr_letters$as_cr_LETTERS +as_cr_digits='0123456789' +as_cr_alnum=$as_cr_Letters$as_cr_digits + +ECHO_C= ECHO_N= ECHO_T= +case `echo -n x` in #((((( +-n*) + case `echo 'xy\c'` in + *c*) ECHO_T=' ';; # ECHO_T is single tab character. + xy) ECHO_C='\c';; + *) echo `echo ksh88 bug on AIX 6.1` > /dev/null + ECHO_T=' ';; + esac;; +*) + ECHO_N='-n';; +esac + +rm -f conf$$ conf$$.exe conf$$.file +if test -d conf$$.dir; then + rm -f conf$$.dir/conf$$.file +else + rm -f conf$$.dir + mkdir conf$$.dir 2>/dev/null +fi +if (echo >conf$$.file) 2>/dev/null; then + if ln -s conf$$.file conf$$ 2>/dev/null; then + as_ln_s='ln -s' + # ... but there are two gotchas: + # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail. + # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable. + # In both cases, we have to default to `cp -pR'. + ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe || + as_ln_s='cp -pR' + elif ln conf$$.file conf$$ 2>/dev/null; then + as_ln_s=ln + else + as_ln_s='cp -pR' + fi +else + as_ln_s='cp -pR' +fi +rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file +rmdir conf$$.dir 2>/dev/null + + +# as_fn_mkdir_p +# ------------- +# Create "$as_dir" as a directory, including parents if necessary. +as_fn_mkdir_p () +{ + + case $as_dir in #( + -*) as_dir=./$as_dir;; + esac + test -d "$as_dir" || eval $as_mkdir_p || { + as_dirs= + while :; do + case $as_dir in #( + *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'( + *) as_qdir=$as_dir;; + esac + as_dirs="'$as_qdir' $as_dirs" + as_dir=`$as_dirname -- "$as_dir" || +$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ + X"$as_dir" : 'X\(//\)[^/]' \| \ + X"$as_dir" : 'X\(//\)$' \| \ + X"$as_dir" : 'X\(/\)' \| . 2>/dev/null || +$as_echo X"$as_dir" | + sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ + s//\1/ + q + } + /^X\(\/\/\)[^/].*/{ + s//\1/ + q + } + /^X\(\/\/\)$/{ + s//\1/ + q + } + /^X\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q'` + test -d "$as_dir" && break + done + test -z "$as_dirs" || eval "mkdir $as_dirs" + } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir" + + +} # as_fn_mkdir_p +if mkdir -p . 2>/dev/null; then + as_mkdir_p='mkdir -p "$as_dir"' +else + test -d ./-p && rmdir ./-p + as_mkdir_p=false +fi + + +# as_fn_executable_p FILE +# ----------------------- +# Test if FILE is an executable regular file. +as_fn_executable_p () +{ + test -f "$1" && test -x "$1" +} # as_fn_executable_p +as_test_x='test -x' +as_executable_p=as_fn_executable_p + +# Sed expression to map a string onto a valid CPP name. +as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'" + +# Sed expression to map a string onto a valid variable name. +as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'" + + +exec 6>&1 +## ----------------------------------- ## +## Main body of $CONFIG_STATUS script. ## +## ----------------------------------- ## +_ASEOF +test $as_write_fail = 0 && chmod +x $CONFIG_STATUS || ac_write_fail=1 + +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +# Save the log message, to keep $0 and so on meaningful, and to +# report actual input values of CONFIG_FILES etc. instead of their +# values after options handling. +ac_log=" +This file was extended by libodb $as_me 2.4.0, which was +generated by GNU Autoconf 2.69. Invocation command line was + + CONFIG_FILES = $CONFIG_FILES + CONFIG_HEADERS = $CONFIG_HEADERS + CONFIG_LINKS = $CONFIG_LINKS + CONFIG_COMMANDS = $CONFIG_COMMANDS + $ $0 $@ + +on `(hostname || uname -n) 2>/dev/null | sed 1q` +" + +_ACEOF + +case $ac_config_files in *" +"*) set x $ac_config_files; shift; ac_config_files=$*;; +esac + +case $ac_config_headers in *" +"*) set x $ac_config_headers; shift; ac_config_headers=$*;; +esac + + +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +# Files that config.status was made for. +config_files="$ac_config_files" +config_headers="$ac_config_headers" +config_commands="$ac_config_commands" + +_ACEOF + +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +ac_cs_usage="\ +\`$as_me' instantiates files and other configuration actions +from templates according to the current configuration. Unless the files +and actions are specified as TAGs, all are instantiated by default. + +Usage: $0 [OPTION]... [TAG]... + + -h, --help print this help, then exit + -V, --version print version number and configuration settings, then exit + --config print configuration, then exit + -q, --quiet, --silent + do not print progress messages + -d, --debug don't remove temporary files + --recheck update $as_me by reconfiguring in the same conditions + --file=FILE[:TEMPLATE] + instantiate the configuration file FILE + --header=FILE[:TEMPLATE] + instantiate the configuration header FILE + +Configuration files: +$config_files + +Configuration headers: +$config_headers + +Configuration commands: +$config_commands + +Report bugs to ." + +_ACEOF +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`" +ac_cs_version="\\ +libodb config.status 2.4.0 +configured by $0, generated by GNU Autoconf 2.69, + with options \\"\$ac_cs_config\\" + +Copyright (C) 2012 Free Software Foundation, Inc. +This config.status script is free software; the Free Software Foundation +gives unlimited permission to copy, distribute and modify it." + +ac_pwd='$ac_pwd' +srcdir='$srcdir' +INSTALL='$INSTALL' +MKDIR_P='$MKDIR_P' +AWK='$AWK' +test -n "\$AWK" || AWK=awk +_ACEOF + +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +# The default lists apply if the user does not specify any file. +ac_need_defaults=: +while test $# != 0 +do + case $1 in + --*=?*) + ac_option=`expr "X$1" : 'X\([^=]*\)='` + ac_optarg=`expr "X$1" : 'X[^=]*=\(.*\)'` + ac_shift=: + ;; + --*=) + ac_option=`expr "X$1" : 'X\([^=]*\)='` + ac_optarg= + ac_shift=: + ;; + *) + ac_option=$1 + ac_optarg=$2 + ac_shift=shift + ;; + esac + + case $ac_option in + # Handling of the options. + -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r) + ac_cs_recheck=: ;; + --version | --versio | --versi | --vers | --ver | --ve | --v | -V ) + $as_echo "$ac_cs_version"; exit ;; + --config | --confi | --conf | --con | --co | --c ) + $as_echo "$ac_cs_config"; exit ;; + --debug | --debu | --deb | --de | --d | -d ) + debug=: ;; + --file | --fil | --fi | --f ) + $ac_shift + case $ac_optarg in + *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;; + '') as_fn_error $? "missing file argument" ;; + esac + as_fn_append CONFIG_FILES " '$ac_optarg'" + ac_need_defaults=false;; + --header | --heade | --head | --hea ) + $ac_shift + case $ac_optarg in + *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;; + esac + as_fn_append CONFIG_HEADERS " '$ac_optarg'" + ac_need_defaults=false;; + --he | --h) + # Conflict between --help and --header + as_fn_error $? "ambiguous option: \`$1' +Try \`$0 --help' for more information.";; + --help | --hel | -h ) + $as_echo "$ac_cs_usage"; exit ;; + -q | -quiet | --quiet | --quie | --qui | --qu | --q \ + | -silent | --silent | --silen | --sile | --sil | --si | --s) + ac_cs_silent=: ;; + + # This is an error. + -*) as_fn_error $? "unrecognized option: \`$1' +Try \`$0 --help' for more information." ;; + + *) as_fn_append ac_config_targets " $1" + ac_need_defaults=false ;; + + esac + shift +done + +ac_configure_extra_args= + +if $ac_cs_silent; then + exec 6>/dev/null + ac_configure_extra_args="$ac_configure_extra_args --silent" +fi + +_ACEOF +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +if \$ac_cs_recheck; then + set X $SHELL '$0' $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion + shift + \$as_echo "running CONFIG_SHELL=$SHELL \$*" >&6 + CONFIG_SHELL='$SHELL' + export CONFIG_SHELL + exec "\$@" +fi + +_ACEOF +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +exec 5>>config.log +{ + echo + sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX +## Running $as_me. ## +_ASBOX + $as_echo "$ac_log" +} >&5 + +_ACEOF +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +# +# INIT-COMMANDS +# +AMDEP_TRUE="$AMDEP_TRUE" ac_aux_dir="$ac_aux_dir" + + +# The HP-UX ksh and POSIX shell print the target directory to stdout +# if CDPATH is set. +(unset CDPATH) >/dev/null 2>&1 && unset CDPATH + +sed_quote_subst='$sed_quote_subst' +double_quote_subst='$double_quote_subst' +delay_variable_subst='$delay_variable_subst' +macro_version='`$ECHO "$macro_version" | $SED "$delay_single_quote_subst"`' +macro_revision='`$ECHO "$macro_revision" | $SED "$delay_single_quote_subst"`' +AS='`$ECHO "$AS" | $SED "$delay_single_quote_subst"`' +DLLTOOL='`$ECHO "$DLLTOOL" | $SED "$delay_single_quote_subst"`' +OBJDUMP='`$ECHO "$OBJDUMP" | $SED "$delay_single_quote_subst"`' +enable_shared='`$ECHO "$enable_shared" | $SED "$delay_single_quote_subst"`' +enable_static='`$ECHO "$enable_static" | $SED "$delay_single_quote_subst"`' +pic_mode='`$ECHO "$pic_mode" | $SED "$delay_single_quote_subst"`' +enable_fast_install='`$ECHO "$enable_fast_install" | $SED "$delay_single_quote_subst"`' +SHELL='`$ECHO "$SHELL" | $SED "$delay_single_quote_subst"`' +ECHO='`$ECHO "$ECHO" | $SED "$delay_single_quote_subst"`' +PATH_SEPARATOR='`$ECHO "$PATH_SEPARATOR" | $SED "$delay_single_quote_subst"`' +host_alias='`$ECHO "$host_alias" | $SED "$delay_single_quote_subst"`' +host='`$ECHO "$host" | $SED "$delay_single_quote_subst"`' +host_os='`$ECHO "$host_os" | $SED "$delay_single_quote_subst"`' +build_alias='`$ECHO "$build_alias" | $SED "$delay_single_quote_subst"`' +build='`$ECHO "$build" | $SED "$delay_single_quote_subst"`' +build_os='`$ECHO "$build_os" | $SED "$delay_single_quote_subst"`' +SED='`$ECHO "$SED" | $SED "$delay_single_quote_subst"`' +Xsed='`$ECHO "$Xsed" | $SED "$delay_single_quote_subst"`' +GREP='`$ECHO "$GREP" | $SED "$delay_single_quote_subst"`' +EGREP='`$ECHO "$EGREP" | $SED "$delay_single_quote_subst"`' +FGREP='`$ECHO "$FGREP" | $SED "$delay_single_quote_subst"`' +LD='`$ECHO "$LD" | $SED "$delay_single_quote_subst"`' +NM='`$ECHO "$NM" | $SED "$delay_single_quote_subst"`' +LN_S='`$ECHO "$LN_S" | $SED "$delay_single_quote_subst"`' +max_cmd_len='`$ECHO "$max_cmd_len" | $SED "$delay_single_quote_subst"`' +ac_objext='`$ECHO "$ac_objext" | $SED "$delay_single_quote_subst"`' +exeext='`$ECHO "$exeext" | $SED "$delay_single_quote_subst"`' +lt_unset='`$ECHO "$lt_unset" | $SED "$delay_single_quote_subst"`' +lt_SP2NL='`$ECHO "$lt_SP2NL" | $SED "$delay_single_quote_subst"`' +lt_NL2SP='`$ECHO "$lt_NL2SP" | $SED "$delay_single_quote_subst"`' +lt_cv_to_host_file_cmd='`$ECHO "$lt_cv_to_host_file_cmd" | $SED "$delay_single_quote_subst"`' +lt_cv_to_tool_file_cmd='`$ECHO "$lt_cv_to_tool_file_cmd" | $SED "$delay_single_quote_subst"`' +reload_flag='`$ECHO "$reload_flag" | $SED "$delay_single_quote_subst"`' +reload_cmds='`$ECHO "$reload_cmds" | $SED "$delay_single_quote_subst"`' +deplibs_check_method='`$ECHO "$deplibs_check_method" | $SED "$delay_single_quote_subst"`' +file_magic_cmd='`$ECHO "$file_magic_cmd" | $SED "$delay_single_quote_subst"`' +file_magic_glob='`$ECHO "$file_magic_glob" | $SED "$delay_single_quote_subst"`' +want_nocaseglob='`$ECHO "$want_nocaseglob" | $SED "$delay_single_quote_subst"`' +sharedlib_from_linklib_cmd='`$ECHO "$sharedlib_from_linklib_cmd" | $SED "$delay_single_quote_subst"`' +AR='`$ECHO "$AR" | $SED "$delay_single_quote_subst"`' +AR_FLAGS='`$ECHO "$AR_FLAGS" | $SED "$delay_single_quote_subst"`' +archiver_list_spec='`$ECHO "$archiver_list_spec" | $SED "$delay_single_quote_subst"`' +STRIP='`$ECHO "$STRIP" | $SED "$delay_single_quote_subst"`' +RANLIB='`$ECHO "$RANLIB" | $SED "$delay_single_quote_subst"`' +old_postinstall_cmds='`$ECHO "$old_postinstall_cmds" | $SED "$delay_single_quote_subst"`' +old_postuninstall_cmds='`$ECHO "$old_postuninstall_cmds" | $SED "$delay_single_quote_subst"`' +old_archive_cmds='`$ECHO "$old_archive_cmds" | $SED "$delay_single_quote_subst"`' +lock_old_archive_extraction='`$ECHO "$lock_old_archive_extraction" | $SED "$delay_single_quote_subst"`' +CC='`$ECHO "$CC" | $SED "$delay_single_quote_subst"`' +CFLAGS='`$ECHO "$CFLAGS" | $SED "$delay_single_quote_subst"`' +compiler='`$ECHO "$compiler" | $SED "$delay_single_quote_subst"`' +GCC='`$ECHO "$GCC" | $SED "$delay_single_quote_subst"`' +lt_cv_sys_global_symbol_pipe='`$ECHO "$lt_cv_sys_global_symbol_pipe" | $SED "$delay_single_quote_subst"`' +lt_cv_sys_global_symbol_to_cdecl='`$ECHO "$lt_cv_sys_global_symbol_to_cdecl" | $SED "$delay_single_quote_subst"`' +lt_cv_sys_global_symbol_to_c_name_address='`$ECHO "$lt_cv_sys_global_symbol_to_c_name_address" | $SED "$delay_single_quote_subst"`' +lt_cv_sys_global_symbol_to_c_name_address_lib_prefix='`$ECHO "$lt_cv_sys_global_symbol_to_c_name_address_lib_prefix" | $SED "$delay_single_quote_subst"`' +nm_file_list_spec='`$ECHO "$nm_file_list_spec" | $SED "$delay_single_quote_subst"`' +lt_sysroot='`$ECHO "$lt_sysroot" | $SED "$delay_single_quote_subst"`' +objdir='`$ECHO "$objdir" | $SED "$delay_single_quote_subst"`' +MAGIC_CMD='`$ECHO "$MAGIC_CMD" | $SED "$delay_single_quote_subst"`' +lt_prog_compiler_no_builtin_flag='`$ECHO "$lt_prog_compiler_no_builtin_flag" | $SED "$delay_single_quote_subst"`' +lt_prog_compiler_pic='`$ECHO "$lt_prog_compiler_pic" | $SED "$delay_single_quote_subst"`' +lt_prog_compiler_wl='`$ECHO "$lt_prog_compiler_wl" | $SED "$delay_single_quote_subst"`' +lt_prog_compiler_static='`$ECHO "$lt_prog_compiler_static" | $SED "$delay_single_quote_subst"`' +lt_cv_prog_compiler_c_o='`$ECHO "$lt_cv_prog_compiler_c_o" | $SED "$delay_single_quote_subst"`' +need_locks='`$ECHO "$need_locks" | $SED "$delay_single_quote_subst"`' +MANIFEST_TOOL='`$ECHO "$MANIFEST_TOOL" | $SED "$delay_single_quote_subst"`' +DSYMUTIL='`$ECHO "$DSYMUTIL" | $SED "$delay_single_quote_subst"`' +NMEDIT='`$ECHO "$NMEDIT" | $SED "$delay_single_quote_subst"`' +LIPO='`$ECHO "$LIPO" | $SED "$delay_single_quote_subst"`' +OTOOL='`$ECHO "$OTOOL" | $SED "$delay_single_quote_subst"`' +OTOOL64='`$ECHO "$OTOOL64" | $SED "$delay_single_quote_subst"`' +libext='`$ECHO "$libext" | $SED "$delay_single_quote_subst"`' +shrext_cmds='`$ECHO "$shrext_cmds" | $SED "$delay_single_quote_subst"`' +extract_expsyms_cmds='`$ECHO "$extract_expsyms_cmds" | $SED "$delay_single_quote_subst"`' +archive_cmds_need_lc='`$ECHO "$archive_cmds_need_lc" | $SED "$delay_single_quote_subst"`' +enable_shared_with_static_runtimes='`$ECHO "$enable_shared_with_static_runtimes" | $SED "$delay_single_quote_subst"`' +export_dynamic_flag_spec='`$ECHO "$export_dynamic_flag_spec" | $SED "$delay_single_quote_subst"`' +whole_archive_flag_spec='`$ECHO "$whole_archive_flag_spec" | $SED "$delay_single_quote_subst"`' +compiler_needs_object='`$ECHO "$compiler_needs_object" | $SED "$delay_single_quote_subst"`' +old_archive_from_new_cmds='`$ECHO "$old_archive_from_new_cmds" | $SED "$delay_single_quote_subst"`' +old_archive_from_expsyms_cmds='`$ECHO "$old_archive_from_expsyms_cmds" | $SED "$delay_single_quote_subst"`' +archive_cmds='`$ECHO "$archive_cmds" | $SED "$delay_single_quote_subst"`' +archive_expsym_cmds='`$ECHO "$archive_expsym_cmds" | $SED "$delay_single_quote_subst"`' +module_cmds='`$ECHO "$module_cmds" | $SED "$delay_single_quote_subst"`' +module_expsym_cmds='`$ECHO "$module_expsym_cmds" | $SED "$delay_single_quote_subst"`' +with_gnu_ld='`$ECHO "$with_gnu_ld" | $SED "$delay_single_quote_subst"`' +allow_undefined_flag='`$ECHO "$allow_undefined_flag" | $SED "$delay_single_quote_subst"`' +no_undefined_flag='`$ECHO "$no_undefined_flag" | $SED "$delay_single_quote_subst"`' +hardcode_libdir_flag_spec='`$ECHO "$hardcode_libdir_flag_spec" | $SED "$delay_single_quote_subst"`' +hardcode_libdir_separator='`$ECHO "$hardcode_libdir_separator" | $SED "$delay_single_quote_subst"`' +hardcode_direct='`$ECHO "$hardcode_direct" | $SED "$delay_single_quote_subst"`' +hardcode_direct_absolute='`$ECHO "$hardcode_direct_absolute" | $SED "$delay_single_quote_subst"`' +hardcode_minus_L='`$ECHO "$hardcode_minus_L" | $SED "$delay_single_quote_subst"`' +hardcode_shlibpath_var='`$ECHO "$hardcode_shlibpath_var" | $SED "$delay_single_quote_subst"`' +hardcode_automatic='`$ECHO "$hardcode_automatic" | $SED "$delay_single_quote_subst"`' +inherit_rpath='`$ECHO "$inherit_rpath" | $SED "$delay_single_quote_subst"`' +link_all_deplibs='`$ECHO "$link_all_deplibs" | $SED "$delay_single_quote_subst"`' +always_export_symbols='`$ECHO "$always_export_symbols" | $SED "$delay_single_quote_subst"`' +export_symbols_cmds='`$ECHO "$export_symbols_cmds" | $SED "$delay_single_quote_subst"`' +exclude_expsyms='`$ECHO "$exclude_expsyms" | $SED "$delay_single_quote_subst"`' +include_expsyms='`$ECHO "$include_expsyms" | $SED "$delay_single_quote_subst"`' +prelink_cmds='`$ECHO "$prelink_cmds" | $SED "$delay_single_quote_subst"`' +postlink_cmds='`$ECHO "$postlink_cmds" | $SED "$delay_single_quote_subst"`' +file_list_spec='`$ECHO "$file_list_spec" | $SED "$delay_single_quote_subst"`' +variables_saved_for_relink='`$ECHO "$variables_saved_for_relink" | $SED "$delay_single_quote_subst"`' +need_lib_prefix='`$ECHO "$need_lib_prefix" | $SED "$delay_single_quote_subst"`' +need_version='`$ECHO "$need_version" | $SED "$delay_single_quote_subst"`' +version_type='`$ECHO "$version_type" | $SED "$delay_single_quote_subst"`' +runpath_var='`$ECHO "$runpath_var" | $SED "$delay_single_quote_subst"`' +shlibpath_var='`$ECHO "$shlibpath_var" | $SED "$delay_single_quote_subst"`' +shlibpath_overrides_runpath='`$ECHO "$shlibpath_overrides_runpath" | $SED "$delay_single_quote_subst"`' +libname_spec='`$ECHO "$libname_spec" | $SED "$delay_single_quote_subst"`' +library_names_spec='`$ECHO "$library_names_spec" | $SED "$delay_single_quote_subst"`' +soname_spec='`$ECHO "$soname_spec" | $SED "$delay_single_quote_subst"`' +install_override_mode='`$ECHO "$install_override_mode" | $SED "$delay_single_quote_subst"`' +postinstall_cmds='`$ECHO "$postinstall_cmds" | $SED "$delay_single_quote_subst"`' +postuninstall_cmds='`$ECHO "$postuninstall_cmds" | $SED "$delay_single_quote_subst"`' +finish_cmds='`$ECHO "$finish_cmds" | $SED "$delay_single_quote_subst"`' +finish_eval='`$ECHO "$finish_eval" | $SED "$delay_single_quote_subst"`' +hardcode_into_libs='`$ECHO "$hardcode_into_libs" | $SED "$delay_single_quote_subst"`' +sys_lib_search_path_spec='`$ECHO "$sys_lib_search_path_spec" | $SED "$delay_single_quote_subst"`' +sys_lib_dlsearch_path_spec='`$ECHO "$sys_lib_dlsearch_path_spec" | $SED "$delay_single_quote_subst"`' +hardcode_action='`$ECHO "$hardcode_action" | $SED "$delay_single_quote_subst"`' +enable_dlopen='`$ECHO "$enable_dlopen" | $SED "$delay_single_quote_subst"`' +enable_dlopen_self='`$ECHO "$enable_dlopen_self" | $SED "$delay_single_quote_subst"`' +enable_dlopen_self_static='`$ECHO "$enable_dlopen_self_static" | $SED "$delay_single_quote_subst"`' +old_striplib='`$ECHO "$old_striplib" | $SED "$delay_single_quote_subst"`' +striplib='`$ECHO "$striplib" | $SED "$delay_single_quote_subst"`' +compiler_lib_search_dirs='`$ECHO "$compiler_lib_search_dirs" | $SED "$delay_single_quote_subst"`' +predep_objects='`$ECHO "$predep_objects" | $SED "$delay_single_quote_subst"`' +postdep_objects='`$ECHO "$postdep_objects" | $SED "$delay_single_quote_subst"`' +predeps='`$ECHO "$predeps" | $SED "$delay_single_quote_subst"`' +postdeps='`$ECHO "$postdeps" | $SED "$delay_single_quote_subst"`' +compiler_lib_search_path='`$ECHO "$compiler_lib_search_path" | $SED "$delay_single_quote_subst"`' +LD_CXX='`$ECHO "$LD_CXX" | $SED "$delay_single_quote_subst"`' +reload_flag_CXX='`$ECHO "$reload_flag_CXX" | $SED "$delay_single_quote_subst"`' +reload_cmds_CXX='`$ECHO "$reload_cmds_CXX" | $SED "$delay_single_quote_subst"`' +old_archive_cmds_CXX='`$ECHO "$old_archive_cmds_CXX" | $SED "$delay_single_quote_subst"`' +compiler_CXX='`$ECHO "$compiler_CXX" | $SED "$delay_single_quote_subst"`' +GCC_CXX='`$ECHO "$GCC_CXX" | $SED "$delay_single_quote_subst"`' +lt_prog_compiler_no_builtin_flag_CXX='`$ECHO "$lt_prog_compiler_no_builtin_flag_CXX" | $SED "$delay_single_quote_subst"`' +lt_prog_compiler_pic_CXX='`$ECHO "$lt_prog_compiler_pic_CXX" | $SED "$delay_single_quote_subst"`' +lt_prog_compiler_wl_CXX='`$ECHO "$lt_prog_compiler_wl_CXX" | $SED "$delay_single_quote_subst"`' +lt_prog_compiler_static_CXX='`$ECHO "$lt_prog_compiler_static_CXX" | $SED "$delay_single_quote_subst"`' +lt_cv_prog_compiler_c_o_CXX='`$ECHO "$lt_cv_prog_compiler_c_o_CXX" | $SED "$delay_single_quote_subst"`' +archive_cmds_need_lc_CXX='`$ECHO "$archive_cmds_need_lc_CXX" | $SED "$delay_single_quote_subst"`' +enable_shared_with_static_runtimes_CXX='`$ECHO "$enable_shared_with_static_runtimes_CXX" | $SED "$delay_single_quote_subst"`' +export_dynamic_flag_spec_CXX='`$ECHO "$export_dynamic_flag_spec_CXX" | $SED "$delay_single_quote_subst"`' +whole_archive_flag_spec_CXX='`$ECHO "$whole_archive_flag_spec_CXX" | $SED "$delay_single_quote_subst"`' +compiler_needs_object_CXX='`$ECHO "$compiler_needs_object_CXX" | $SED "$delay_single_quote_subst"`' +old_archive_from_new_cmds_CXX='`$ECHO "$old_archive_from_new_cmds_CXX" | $SED "$delay_single_quote_subst"`' +old_archive_from_expsyms_cmds_CXX='`$ECHO "$old_archive_from_expsyms_cmds_CXX" | $SED "$delay_single_quote_subst"`' +archive_cmds_CXX='`$ECHO "$archive_cmds_CXX" | $SED "$delay_single_quote_subst"`' +archive_expsym_cmds_CXX='`$ECHO "$archive_expsym_cmds_CXX" | $SED "$delay_single_quote_subst"`' +module_cmds_CXX='`$ECHO "$module_cmds_CXX" | $SED "$delay_single_quote_subst"`' +module_expsym_cmds_CXX='`$ECHO "$module_expsym_cmds_CXX" | $SED "$delay_single_quote_subst"`' +with_gnu_ld_CXX='`$ECHO "$with_gnu_ld_CXX" | $SED "$delay_single_quote_subst"`' +allow_undefined_flag_CXX='`$ECHO "$allow_undefined_flag_CXX" | $SED "$delay_single_quote_subst"`' +no_undefined_flag_CXX='`$ECHO "$no_undefined_flag_CXX" | $SED "$delay_single_quote_subst"`' +hardcode_libdir_flag_spec_CXX='`$ECHO "$hardcode_libdir_flag_spec_CXX" | $SED "$delay_single_quote_subst"`' +hardcode_libdir_separator_CXX='`$ECHO "$hardcode_libdir_separator_CXX" | $SED "$delay_single_quote_subst"`' +hardcode_direct_CXX='`$ECHO "$hardcode_direct_CXX" | $SED "$delay_single_quote_subst"`' +hardcode_direct_absolute_CXX='`$ECHO "$hardcode_direct_absolute_CXX" | $SED "$delay_single_quote_subst"`' +hardcode_minus_L_CXX='`$ECHO "$hardcode_minus_L_CXX" | $SED "$delay_single_quote_subst"`' +hardcode_shlibpath_var_CXX='`$ECHO "$hardcode_shlibpath_var_CXX" | $SED "$delay_single_quote_subst"`' +hardcode_automatic_CXX='`$ECHO "$hardcode_automatic_CXX" | $SED "$delay_single_quote_subst"`' +inherit_rpath_CXX='`$ECHO "$inherit_rpath_CXX" | $SED "$delay_single_quote_subst"`' +link_all_deplibs_CXX='`$ECHO "$link_all_deplibs_CXX" | $SED "$delay_single_quote_subst"`' +always_export_symbols_CXX='`$ECHO "$always_export_symbols_CXX" | $SED "$delay_single_quote_subst"`' +export_symbols_cmds_CXX='`$ECHO "$export_symbols_cmds_CXX" | $SED "$delay_single_quote_subst"`' +exclude_expsyms_CXX='`$ECHO "$exclude_expsyms_CXX" | $SED "$delay_single_quote_subst"`' +include_expsyms_CXX='`$ECHO "$include_expsyms_CXX" | $SED "$delay_single_quote_subst"`' +prelink_cmds_CXX='`$ECHO "$prelink_cmds_CXX" | $SED "$delay_single_quote_subst"`' +postlink_cmds_CXX='`$ECHO "$postlink_cmds_CXX" | $SED "$delay_single_quote_subst"`' +file_list_spec_CXX='`$ECHO "$file_list_spec_CXX" | $SED "$delay_single_quote_subst"`' +hardcode_action_CXX='`$ECHO "$hardcode_action_CXX" | $SED "$delay_single_quote_subst"`' +compiler_lib_search_dirs_CXX='`$ECHO "$compiler_lib_search_dirs_CXX" | $SED "$delay_single_quote_subst"`' +predep_objects_CXX='`$ECHO "$predep_objects_CXX" | $SED "$delay_single_quote_subst"`' +postdep_objects_CXX='`$ECHO "$postdep_objects_CXX" | $SED "$delay_single_quote_subst"`' +predeps_CXX='`$ECHO "$predeps_CXX" | $SED "$delay_single_quote_subst"`' +postdeps_CXX='`$ECHO "$postdeps_CXX" | $SED "$delay_single_quote_subst"`' +compiler_lib_search_path_CXX='`$ECHO "$compiler_lib_search_path_CXX" | $SED "$delay_single_quote_subst"`' + +LTCC='$LTCC' +LTCFLAGS='$LTCFLAGS' +compiler='$compiler_DEFAULT' + +# A function that is used when there is no print builtin or printf. +func_fallback_echo () +{ + eval 'cat <<_LTECHO_EOF +\$1 +_LTECHO_EOF' +} + +# Quote evaled strings. +for var in AS \ +DLLTOOL \ +OBJDUMP \ +SHELL \ +ECHO \ +PATH_SEPARATOR \ +SED \ +GREP \ +EGREP \ +FGREP \ +LD \ +NM \ +LN_S \ +lt_SP2NL \ +lt_NL2SP \ +reload_flag \ +deplibs_check_method \ +file_magic_cmd \ +file_magic_glob \ +want_nocaseglob \ +sharedlib_from_linklib_cmd \ +AR \ +AR_FLAGS \ +archiver_list_spec \ +STRIP \ +RANLIB \ +CC \ +CFLAGS \ +compiler \ +lt_cv_sys_global_symbol_pipe \ +lt_cv_sys_global_symbol_to_cdecl \ +lt_cv_sys_global_symbol_to_c_name_address \ +lt_cv_sys_global_symbol_to_c_name_address_lib_prefix \ +nm_file_list_spec \ +lt_prog_compiler_no_builtin_flag \ +lt_prog_compiler_pic \ +lt_prog_compiler_wl \ +lt_prog_compiler_static \ +lt_cv_prog_compiler_c_o \ +need_locks \ +MANIFEST_TOOL \ +DSYMUTIL \ +NMEDIT \ +LIPO \ +OTOOL \ +OTOOL64 \ +shrext_cmds \ +export_dynamic_flag_spec \ +whole_archive_flag_spec \ +compiler_needs_object \ +with_gnu_ld \ +allow_undefined_flag \ +no_undefined_flag \ +hardcode_libdir_flag_spec \ +hardcode_libdir_separator \ +exclude_expsyms \ +include_expsyms \ +file_list_spec \ +variables_saved_for_relink \ +libname_spec \ +library_names_spec \ +soname_spec \ +install_override_mode \ +finish_eval \ +old_striplib \ +striplib \ +compiler_lib_search_dirs \ +predep_objects \ +postdep_objects \ +predeps \ +postdeps \ +compiler_lib_search_path \ +LD_CXX \ +reload_flag_CXX \ +compiler_CXX \ +lt_prog_compiler_no_builtin_flag_CXX \ +lt_prog_compiler_pic_CXX \ +lt_prog_compiler_wl_CXX \ +lt_prog_compiler_static_CXX \ +lt_cv_prog_compiler_c_o_CXX \ +export_dynamic_flag_spec_CXX \ +whole_archive_flag_spec_CXX \ +compiler_needs_object_CXX \ +with_gnu_ld_CXX \ +allow_undefined_flag_CXX \ +no_undefined_flag_CXX \ +hardcode_libdir_flag_spec_CXX \ +hardcode_libdir_separator_CXX \ +exclude_expsyms_CXX \ +include_expsyms_CXX \ +file_list_spec_CXX \ +compiler_lib_search_dirs_CXX \ +predep_objects_CXX \ +postdep_objects_CXX \ +predeps_CXX \ +postdeps_CXX \ +compiler_lib_search_path_CXX; do + case \`eval \\\\\$ECHO \\\\""\\\\\$\$var"\\\\"\` in + *[\\\\\\\`\\"\\\$]*) + eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"\\\$\$var\\" | \\\$SED \\"\\\$sed_quote_subst\\"\\\`\\\\\\"" + ;; + *) + eval "lt_\$var=\\\\\\"\\\$\$var\\\\\\"" + ;; + esac +done + +# Double-quote double-evaled strings. +for var in reload_cmds \ +old_postinstall_cmds \ +old_postuninstall_cmds \ +old_archive_cmds \ +extract_expsyms_cmds \ +old_archive_from_new_cmds \ +old_archive_from_expsyms_cmds \ +archive_cmds \ +archive_expsym_cmds \ +module_cmds \ +module_expsym_cmds \ +export_symbols_cmds \ +prelink_cmds \ +postlink_cmds \ +postinstall_cmds \ +postuninstall_cmds \ +finish_cmds \ +sys_lib_search_path_spec \ +sys_lib_dlsearch_path_spec \ +reload_cmds_CXX \ +old_archive_cmds_CXX \ +old_archive_from_new_cmds_CXX \ +old_archive_from_expsyms_cmds_CXX \ +archive_cmds_CXX \ +archive_expsym_cmds_CXX \ +module_cmds_CXX \ +module_expsym_cmds_CXX \ +export_symbols_cmds_CXX \ +prelink_cmds_CXX \ +postlink_cmds_CXX; do + case \`eval \\\\\$ECHO \\\\""\\\\\$\$var"\\\\"\` in + *[\\\\\\\`\\"\\\$]*) + eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"\\\$\$var\\" | \\\$SED -e \\"\\\$double_quote_subst\\" -e \\"\\\$sed_quote_subst\\" -e \\"\\\$delay_variable_subst\\"\\\`\\\\\\"" + ;; + *) + eval "lt_\$var=\\\\\\"\\\$\$var\\\\\\"" + ;; + esac +done + +ac_aux_dir='$ac_aux_dir' +xsi_shell='$xsi_shell' +lt_shell_append='$lt_shell_append' + +# See if we are running on zsh, and set the options which allow our +# commands through without removal of \ escapes INIT. +if test -n "\${ZSH_VERSION+set}" ; then + setopt NO_GLOB_SUBST +fi + + + PACKAGE='$PACKAGE' + VERSION='$VERSION' + TIMESTAMP='$TIMESTAMP' + RM='$RM' + ofile='$ofile' + + + +ac_aux_dir='$ac_aux_dir' + + +libtool_use_rpath=$libtool_rpath + +_ACEOF + +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 + +# Handling of arguments. +for ac_config_target in $ac_config_targets +do + case $ac_config_target in + "depfiles") CONFIG_COMMANDS="$CONFIG_COMMANDS depfiles" ;; + "libtool") CONFIG_COMMANDS="$CONFIG_COMMANDS libtool" ;; + "libtool-rpath-patch") CONFIG_COMMANDS="$CONFIG_COMMANDS libtool-rpath-patch" ;; + "odb/config.h") CONFIG_HEADERS="$CONFIG_HEADERS odb/config.h" ;; + "odb/details/config.h") CONFIG_HEADERS="$CONFIG_HEADERS odb/details/config.h" ;; + "libodb.pc") CONFIG_FILES="$CONFIG_FILES libodb.pc" ;; + "Makefile") CONFIG_FILES="$CONFIG_FILES Makefile" ;; + "odb/Makefile") CONFIG_FILES="$CONFIG_FILES odb/Makefile" ;; + + *) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5;; + esac +done + + +# If the user did not use the arguments to specify the items to instantiate, +# then the envvar interface is used. Set only those that are not. +# We use the long form for the default assignment because of an extremely +# bizarre bug on SunOS 4.1.3. +if $ac_need_defaults; then + test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files + test "${CONFIG_HEADERS+set}" = set || CONFIG_HEADERS=$config_headers + test "${CONFIG_COMMANDS+set}" = set || CONFIG_COMMANDS=$config_commands +fi + +# Have a temporary directory for convenience. Make it in the build tree +# simply because there is no reason against having it here, and in addition, +# creating and moving files from /tmp can sometimes cause problems. +# Hook for its removal unless debugging. +# Note that there is a small window in which the directory will not be cleaned: +# after its creation but before its name has been assigned to `$tmp'. +$debug || +{ + tmp= ac_tmp= + trap 'exit_status=$? + : "${ac_tmp:=$tmp}" + { test ! -d "$ac_tmp" || rm -fr "$ac_tmp"; } && exit $exit_status +' 0 + trap 'as_fn_exit 1' 1 2 13 15 +} +# Create a (secure) tmp directory for tmp files. + +{ + tmp=`(umask 077 && mktemp -d "./confXXXXXX") 2>/dev/null` && + test -d "$tmp" +} || +{ + tmp=./conf$$-$RANDOM + (umask 077 && mkdir "$tmp") +} || as_fn_error $? "cannot create a temporary directory in ." "$LINENO" 5 +ac_tmp=$tmp + +# Set up the scripts for CONFIG_FILES section. +# No need to generate them if there are no CONFIG_FILES. +# This happens for instance with `./config.status config.h'. +if test -n "$CONFIG_FILES"; then + + +ac_cr=`echo X | tr X '\015'` +# On cygwin, bash can eat \r inside `` if the user requested igncr. +# But we know of no other shell where ac_cr would be empty at this +# point, so we can use a bashism as a fallback. +if test "x$ac_cr" = x; then + eval ac_cr=\$\'\\r\' +fi +ac_cs_awk_cr=`$AWK 'BEGIN { print "a\rb" }' /dev/null` +if test "$ac_cs_awk_cr" = "a${ac_cr}b"; then + ac_cs_awk_cr='\\r' +else + ac_cs_awk_cr=$ac_cr +fi + +echo 'BEGIN {' >"$ac_tmp/subs1.awk" && +_ACEOF + + +{ + echo "cat >conf$$subs.awk <<_ACEOF" && + echo "$ac_subst_vars" | sed 's/.*/&!$&$ac_delim/' && + echo "_ACEOF" +} >conf$$subs.sh || + as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5 +ac_delim_num=`echo "$ac_subst_vars" | grep -c '^'` +ac_delim='%!_!# ' +for ac_last_try in false false false false false :; do + . ./conf$$subs.sh || + as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5 + + ac_delim_n=`sed -n "s/.*$ac_delim\$/X/p" conf$$subs.awk | grep -c X` + if test $ac_delim_n = $ac_delim_num; then + break + elif $ac_last_try; then + as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5 + else + ac_delim="$ac_delim!$ac_delim _$ac_delim!! " + fi +done +rm -f conf$$subs.sh + +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +cat >>"\$ac_tmp/subs1.awk" <<\\_ACAWK && +_ACEOF +sed -n ' +h +s/^/S["/; s/!.*/"]=/ +p +g +s/^[^!]*!// +:repl +t repl +s/'"$ac_delim"'$// +t delim +:nl +h +s/\(.\{148\}\)..*/\1/ +t more1 +s/["\\]/\\&/g; s/^/"/; s/$/\\n"\\/ +p +n +b repl +:more1 +s/["\\]/\\&/g; s/^/"/; s/$/"\\/ +p +g +s/.\{148\}// +t nl +:delim +h +s/\(.\{148\}\)..*/\1/ +t more2 +s/["\\]/\\&/g; s/^/"/; s/$/"/ +p +b +:more2 +s/["\\]/\\&/g; s/^/"/; s/$/"\\/ +p +g +s/.\{148\}// +t delim +' >$CONFIG_STATUS || ac_write_fail=1 +rm -f conf$$subs.awk +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +_ACAWK +cat >>"\$ac_tmp/subs1.awk" <<_ACAWK && + for (key in S) S_is_set[key] = 1 + FS = "" + +} +{ + line = $ 0 + nfields = split(line, field, "@") + substed = 0 + len = length(field[1]) + for (i = 2; i < nfields; i++) { + key = field[i] + keylen = length(key) + if (S_is_set[key]) { + value = S[key] + line = substr(line, 1, len) "" value "" substr(line, len + keylen + 3) + len += length(value) + length(field[++i]) + substed = 1 + } else + len += 1 + keylen + } + + print line +} + +_ACAWK +_ACEOF +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +if sed "s/$ac_cr//" < /dev/null > /dev/null 2>&1; then + sed "s/$ac_cr\$//; s/$ac_cr/$ac_cs_awk_cr/g" +else + cat +fi < "$ac_tmp/subs1.awk" > "$ac_tmp/subs.awk" \ + || as_fn_error $? "could not setup config files machinery" "$LINENO" 5 +_ACEOF + +# VPATH may cause trouble with some makes, so we remove sole $(srcdir), +# ${srcdir} and @srcdir@ entries from VPATH if srcdir is ".", strip leading and +# trailing colons and then remove the whole line if VPATH becomes empty +# (actually we leave an empty line to preserve line numbers). +if test "x$srcdir" = x.; then + ac_vpsub='/^[ ]*VPATH[ ]*=[ ]*/{ +h +s/// +s/^/:/ +s/[ ]*$/:/ +s/:\$(srcdir):/:/g +s/:\${srcdir}:/:/g +s/:@srcdir@:/:/g +s/^:*// +s/:*$// +x +s/\(=[ ]*\).*/\1/ +G +s/\n// +s/^[^=]*=[ ]*$// +}' +fi + +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +fi # test -n "$CONFIG_FILES" + +# Set up the scripts for CONFIG_HEADERS section. +# No need to generate them if there are no CONFIG_HEADERS. +# This happens for instance with `./config.status Makefile'. +if test -n "$CONFIG_HEADERS"; then +cat >"$ac_tmp/defines.awk" <<\_ACAWK || +BEGIN { +_ACEOF + +# Transform confdefs.h into an awk script `defines.awk', embedded as +# here-document in config.status, that substitutes the proper values into +# config.h.in to produce config.h. + +# Create a delimiter string that does not exist in confdefs.h, to ease +# handling of long lines. +ac_delim='%!_!# ' +for ac_last_try in false false :; do + ac_tt=`sed -n "/$ac_delim/p" confdefs.h` + if test -z "$ac_tt"; then + break + elif $ac_last_try; then + as_fn_error $? "could not make $CONFIG_HEADERS" "$LINENO" 5 + else + ac_delim="$ac_delim!$ac_delim _$ac_delim!! " + fi +done + +# For the awk script, D is an array of macro values keyed by name, +# likewise P contains macro parameters if any. Preserve backslash +# newline sequences. + +ac_word_re=[_$as_cr_Letters][_$as_cr_alnum]* +sed -n ' +s/.\{148\}/&'"$ac_delim"'/g +t rset +:rset +s/^[ ]*#[ ]*define[ ][ ]*/ / +t def +d +:def +s/\\$// +t bsnl +s/["\\]/\\&/g +s/^ \('"$ac_word_re"'\)\(([^()]*)\)[ ]*\(.*\)/P["\1"]="\2"\ +D["\1"]=" \3"/p +s/^ \('"$ac_word_re"'\)[ ]*\(.*\)/D["\1"]=" \2"/p +d +:bsnl +s/["\\]/\\&/g +s/^ \('"$ac_word_re"'\)\(([^()]*)\)[ ]*\(.*\)/P["\1"]="\2"\ +D["\1"]=" \3\\\\\\n"\\/p +t cont +s/^ \('"$ac_word_re"'\)[ ]*\(.*\)/D["\1"]=" \2\\\\\\n"\\/p +t cont +d +:cont +n +s/.\{148\}/&'"$ac_delim"'/g +t clear +:clear +s/\\$// +t bsnlc +s/["\\]/\\&/g; s/^/"/; s/$/"/p +d +:bsnlc +s/["\\]/\\&/g; s/^/"/; s/$/\\\\\\n"\\/p +b cont +' >$CONFIG_STATUS || ac_write_fail=1 + +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 + for (key in D) D_is_set[key] = 1 + FS = "" +} +/^[\t ]*#[\t ]*(define|undef)[\t ]+$ac_word_re([\t (]|\$)/ { + line = \$ 0 + split(line, arg, " ") + if (arg[1] == "#") { + defundef = arg[2] + mac1 = arg[3] + } else { + defundef = substr(arg[1], 2) + mac1 = arg[2] + } + split(mac1, mac2, "(") #) + macro = mac2[1] + prefix = substr(line, 1, index(line, defundef) - 1) + if (D_is_set[macro]) { + # Preserve the white space surrounding the "#". + print prefix "define", macro P[macro] D[macro] + next + } else { + # Replace #undef with comments. This is necessary, for example, + # in the case of _POSIX_SOURCE, which is predefined and required + # on some systems where configure will not decide to define it. + if (defundef == "undef") { + print "/*", prefix defundef, macro, "*/" + next + } + } +} +{ print } +_ACAWK +_ACEOF +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 + as_fn_error $? "could not setup config headers machinery" "$LINENO" 5 +fi # test -n "$CONFIG_HEADERS" + + +eval set X " :F $CONFIG_FILES :H $CONFIG_HEADERS :C $CONFIG_COMMANDS" +shift +for ac_tag +do + case $ac_tag in + :[FHLC]) ac_mode=$ac_tag; continue;; + esac + case $ac_mode$ac_tag in + :[FHL]*:*);; + :L* | :C*:*) as_fn_error $? "invalid tag \`$ac_tag'" "$LINENO" 5;; + :[FH]-) ac_tag=-:-;; + :[FH]*) ac_tag=$ac_tag:$ac_tag.in;; + esac + ac_save_IFS=$IFS + IFS=: + set x $ac_tag + IFS=$ac_save_IFS + shift + ac_file=$1 + shift + + case $ac_mode in + :L) ac_source=$1;; + :[FH]) + ac_file_inputs= + for ac_f + do + case $ac_f in + -) ac_f="$ac_tmp/stdin";; + *) # Look for the file first in the build tree, then in the source tree + # (if the path is not absolute). The absolute path cannot be DOS-style, + # because $ac_f cannot contain `:'. + test -f "$ac_f" || + case $ac_f in + [\\/$]*) false;; + *) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";; + esac || + as_fn_error 1 "cannot find input file: \`$ac_f'" "$LINENO" 5;; + esac + case $ac_f in *\'*) ac_f=`$as_echo "$ac_f" | sed "s/'/'\\\\\\\\''/g"`;; esac + as_fn_append ac_file_inputs " '$ac_f'" + done + + # Let's still pretend it is `configure' which instantiates (i.e., don't + # use $as_me), people would be surprised to read: + # /* config.h. Generated by config.status. */ + configure_input='Generated from '` + $as_echo "$*" | sed 's|^[^:]*/||;s|:[^:]*/|, |g' + `' by configure.' + if test x"$ac_file" != x-; then + configure_input="$ac_file. $configure_input" + { $as_echo "$as_me:${as_lineno-$LINENO}: creating $ac_file" >&5 +$as_echo "$as_me: creating $ac_file" >&6;} + fi + # Neutralize special characters interpreted by sed in replacement strings. + case $configure_input in #( + *\&* | *\|* | *\\* ) + ac_sed_conf_input=`$as_echo "$configure_input" | + sed 's/[\\\\&|]/\\\\&/g'`;; #( + *) ac_sed_conf_input=$configure_input;; + esac + + case $ac_tag in + *:-:* | *:-) cat >"$ac_tmp/stdin" \ + || as_fn_error $? "could not create $ac_file" "$LINENO" 5 ;; + esac + ;; + esac + + ac_dir=`$as_dirname -- "$ac_file" || +$as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ + X"$ac_file" : 'X\(//\)[^/]' \| \ + X"$ac_file" : 'X\(//\)$' \| \ + X"$ac_file" : 'X\(/\)' \| . 2>/dev/null || +$as_echo X"$ac_file" | + sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ + s//\1/ + q + } + /^X\(\/\/\)[^/].*/{ + s//\1/ + q + } + /^X\(\/\/\)$/{ + s//\1/ + q + } + /^X\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q'` + as_dir="$ac_dir"; as_fn_mkdir_p + ac_builddir=. + +case "$ac_dir" in +.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;; +*) + ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'` + # A ".." for each directory in $ac_dir_suffix. + ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'` + case $ac_top_builddir_sub in + "") ac_top_builddir_sub=. ac_top_build_prefix= ;; + *) ac_top_build_prefix=$ac_top_builddir_sub/ ;; + esac ;; +esac +ac_abs_top_builddir=$ac_pwd +ac_abs_builddir=$ac_pwd$ac_dir_suffix +# for backward compatibility: +ac_top_builddir=$ac_top_build_prefix + +case $srcdir in + .) # We are building in place. + ac_srcdir=. + ac_top_srcdir=$ac_top_builddir_sub + ac_abs_top_srcdir=$ac_pwd ;; + [\\/]* | ?:[\\/]* ) # Absolute name. + ac_srcdir=$srcdir$ac_dir_suffix; + ac_top_srcdir=$srcdir + ac_abs_top_srcdir=$srcdir ;; + *) # Relative name. + ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix + ac_top_srcdir=$ac_top_build_prefix$srcdir + ac_abs_top_srcdir=$ac_pwd/$srcdir ;; +esac +ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix + + + case $ac_mode in + :F) + # + # CONFIG_FILE + # + + case $INSTALL in + [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;; + *) ac_INSTALL=$ac_top_build_prefix$INSTALL ;; + esac + ac_MKDIR_P=$MKDIR_P + case $MKDIR_P in + [\\/$]* | ?:[\\/]* ) ;; + */*) ac_MKDIR_P=$ac_top_build_prefix$MKDIR_P ;; + esac +_ACEOF + +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +# If the template does not know about datarootdir, expand it. +# FIXME: This hack should be removed a few years after 2.60. +ac_datarootdir_hack=; ac_datarootdir_seen= +ac_sed_dataroot=' +/datarootdir/ { + p + q +} +/@datadir@/p +/@docdir@/p +/@infodir@/p +/@localedir@/p +/@mandir@/p' +case `eval "sed -n \"\$ac_sed_dataroot\" $ac_file_inputs"` in +*datarootdir*) ac_datarootdir_seen=yes;; +*@datadir@*|*@docdir@*|*@infodir@*|*@localedir@*|*@mandir@*) + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5 +$as_echo "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;} +_ACEOF +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 + ac_datarootdir_hack=' + s&@datadir@&$datadir&g + s&@docdir@&$docdir&g + s&@infodir@&$infodir&g + s&@localedir@&$localedir&g + s&@mandir@&$mandir&g + s&\\\${datarootdir}&$datarootdir&g' ;; +esac +_ACEOF + +# Neutralize VPATH when `$srcdir' = `.'. +# Shell code in configure.ac might set extrasub. +# FIXME: do we really want to maintain this feature? +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +ac_sed_extra="$ac_vpsub +$extrasub +_ACEOF +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +:t +/@[a-zA-Z_][a-zA-Z_0-9]*@/!b +s|@configure_input@|$ac_sed_conf_input|;t t +s&@top_builddir@&$ac_top_builddir_sub&;t t +s&@top_build_prefix@&$ac_top_build_prefix&;t t +s&@srcdir@&$ac_srcdir&;t t +s&@abs_srcdir@&$ac_abs_srcdir&;t t +s&@top_srcdir@&$ac_top_srcdir&;t t +s&@abs_top_srcdir@&$ac_abs_top_srcdir&;t t +s&@builddir@&$ac_builddir&;t t +s&@abs_builddir@&$ac_abs_builddir&;t t +s&@abs_top_builddir@&$ac_abs_top_builddir&;t t +s&@INSTALL@&$ac_INSTALL&;t t +s&@MKDIR_P@&$ac_MKDIR_P&;t t +$ac_datarootdir_hack +" +eval sed \"\$ac_sed_extra\" "$ac_file_inputs" | $AWK -f "$ac_tmp/subs.awk" \ + >$ac_tmp/out || as_fn_error $? "could not create $ac_file" "$LINENO" 5 + +test -z "$ac_datarootdir_hack$ac_datarootdir_seen" && + { ac_out=`sed -n '/\${datarootdir}/p' "$ac_tmp/out"`; test -n "$ac_out"; } && + { ac_out=`sed -n '/^[ ]*datarootdir[ ]*:*=/p' \ + "$ac_tmp/out"`; test -z "$ac_out"; } && + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file contains a reference to the variable \`datarootdir' +which seems to be undefined. Please make sure it is defined" >&5 +$as_echo "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir' +which seems to be undefined. Please make sure it is defined" >&2;} + + rm -f "$ac_tmp/stdin" + case $ac_file in + -) cat "$ac_tmp/out" && rm -f "$ac_tmp/out";; + *) rm -f "$ac_file" && mv "$ac_tmp/out" "$ac_file";; + esac \ + || as_fn_error $? "could not create $ac_file" "$LINENO" 5 + ;; + :H) + # + # CONFIG_HEADER + # + if test x"$ac_file" != x-; then + { + $as_echo "/* $configure_input */" \ + && eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs" + } >"$ac_tmp/config.h" \ + || as_fn_error $? "could not create $ac_file" "$LINENO" 5 + if diff "$ac_file" "$ac_tmp/config.h" >/dev/null 2>&1; then + { $as_echo "$as_me:${as_lineno-$LINENO}: $ac_file is unchanged" >&5 +$as_echo "$as_me: $ac_file is unchanged" >&6;} + else + rm -f "$ac_file" + mv "$ac_tmp/config.h" "$ac_file" \ + || as_fn_error $? "could not create $ac_file" "$LINENO" 5 + fi + else + $as_echo "/* $configure_input */" \ + && eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs" \ + || as_fn_error $? "could not create -" "$LINENO" 5 + fi +# Compute "$ac_file"'s index in $config_headers. +_am_arg="$ac_file" +_am_stamp_count=1 +for _am_header in $config_headers :; do + case $_am_header in + $_am_arg | $_am_arg:* ) + break ;; + * ) + _am_stamp_count=`expr $_am_stamp_count + 1` ;; + esac +done +echo "timestamp for $_am_arg" >`$as_dirname -- "$_am_arg" || +$as_expr X"$_am_arg" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ + X"$_am_arg" : 'X\(//\)[^/]' \| \ + X"$_am_arg" : 'X\(//\)$' \| \ + X"$_am_arg" : 'X\(/\)' \| . 2>/dev/null || +$as_echo X"$_am_arg" | + sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ + s//\1/ + q + } + /^X\(\/\/\)[^/].*/{ + s//\1/ + q + } + /^X\(\/\/\)$/{ + s//\1/ + q + } + /^X\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q'`/stamp-h$_am_stamp_count + ;; + + :C) { $as_echo "$as_me:${as_lineno-$LINENO}: executing $ac_file commands" >&5 +$as_echo "$as_me: executing $ac_file commands" >&6;} + ;; + esac + + + case $ac_file$ac_mode in + "depfiles":C) test x"$AMDEP_TRUE" != x"" || { + # Autoconf 2.62 quotes --file arguments for eval, but not when files + # are listed without --file. Let's play safe and only enable the eval + # if we detect the quoting. + case $CONFIG_FILES in + *\'*) eval set x "$CONFIG_FILES" ;; + *) set x $CONFIG_FILES ;; + esac + shift + for mf + do + # Strip MF so we end up with the name of the file. + mf=`echo "$mf" | sed -e 's/:.*$//'` + # Check whether this is an Automake generated Makefile or not. + # We used to match only the files named 'Makefile.in', but + # some people rename them; so instead we look at the file content. + # Grep'ing the first line is not enough: some people post-process + # each Makefile.in and add a new line on top of each file to say so. + # Grep'ing the whole file is not good either: AIX grep has a line + # limit of 2048, but all sed's we know have understand at least 4000. + if sed -n 's,^#.*generated by automake.*,X,p' "$mf" | grep X >/dev/null 2>&1; then + dirpart=`$as_dirname -- "$mf" || +$as_expr X"$mf" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ + X"$mf" : 'X\(//\)[^/]' \| \ + X"$mf" : 'X\(//\)$' \| \ + X"$mf" : 'X\(/\)' \| . 2>/dev/null || +$as_echo X"$mf" | + sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ + s//\1/ + q + } + /^X\(\/\/\)[^/].*/{ + s//\1/ + q + } + /^X\(\/\/\)$/{ + s//\1/ + q + } + /^X\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q'` + else + continue + fi + # Extract the definition of DEPDIR, am__include, and am__quote + # from the Makefile without running 'make'. + DEPDIR=`sed -n 's/^DEPDIR = //p' < "$mf"` + test -z "$DEPDIR" && continue + am__include=`sed -n 's/^am__include = //p' < "$mf"` + test -z "am__include" && continue + am__quote=`sed -n 's/^am__quote = //p' < "$mf"` + # Find all dependency output files, they are included files with + # $(DEPDIR) in their names. We invoke sed twice because it is the + # simplest approach to changing $(DEPDIR) to its actual value in the + # expansion. + for file in `sed -n " + s/^$am__include $am__quote\(.*(DEPDIR).*\)$am__quote"'$/\1/p' <"$mf" | \ + sed -e 's/\$(DEPDIR)/'"$DEPDIR"'/g'`; do + # Make sure the directory exists. + test -f "$dirpart/$file" && continue + fdir=`$as_dirname -- "$file" || +$as_expr X"$file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ + X"$file" : 'X\(//\)[^/]' \| \ + X"$file" : 'X\(//\)$' \| \ + X"$file" : 'X\(/\)' \| . 2>/dev/null || +$as_echo X"$file" | + sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ + s//\1/ + q + } + /^X\(\/\/\)[^/].*/{ + s//\1/ + q + } + /^X\(\/\/\)$/{ + s//\1/ + q + } + /^X\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q'` + as_dir=$dirpart/$fdir; as_fn_mkdir_p + # echo "creating $dirpart/$file" + echo '# dummy' > "$dirpart/$file" + done + done +} + ;; + "libtool":C) + + # See if we are running on zsh, and set the options which allow our + # commands through without removal of \ escapes. + if test -n "${ZSH_VERSION+set}" ; then + setopt NO_GLOB_SUBST + fi + + cfgfile="${ofile}T" + trap "$RM \"$cfgfile\"; exit 1" 1 2 15 + $RM "$cfgfile" + + cat <<_LT_EOF >> "$cfgfile" +#! $SHELL + +# `$ECHO "$ofile" | sed 's%^.*/%%'` - Provide generalized library-building support services. +# Generated automatically by $as_me ($PACKAGE$TIMESTAMP) $VERSION +# Libtool was configured on host `(hostname || uname -n) 2>/dev/null | sed 1q`: +# NOTE: Changes made to this file will be lost: look at ltmain.sh. +# +# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, +# 2006, 2007, 2008, 2009, 2010, 2011 Free Software +# Foundation, Inc. +# Written by Gordon Matzigkeit, 1996 +# +# This file is part of GNU Libtool. +# +# GNU Libtool is free software; you can redistribute it and/or +# modify it under the terms of the GNU General Public License as +# published by the Free Software Foundation; either version 2 of +# the License, or (at your option) any later version. +# +# As a special exception to the GNU General Public License, +# if you distribute this file as part of a program or library that +# is built using GNU Libtool, you may include this file under the +# same distribution terms that you use for the rest of that program. +# +# GNU Libtool is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with GNU Libtool; see the file COPYING. If not, a copy +# can be downloaded from http://www.gnu.org/licenses/gpl.html, or +# obtained by writing to the Free Software Foundation, Inc., +# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + + +# The names of the tagged configurations supported by this script. +available_tags="CXX " + +# ### BEGIN LIBTOOL CONFIG + +# Which release of libtool.m4 was used? +macro_version=$macro_version +macro_revision=$macro_revision + +# Assembler program. +AS=$lt_AS + +# DLL creation program. +DLLTOOL=$lt_DLLTOOL + +# Object dumper program. +OBJDUMP=$lt_OBJDUMP + +# Whether or not to build shared libraries. +build_libtool_libs=$enable_shared + +# Whether or not to build static libraries. +build_old_libs=$enable_static + +# What type of objects to build. +pic_mode=$pic_mode + +# Whether or not to optimize for fast installation. +fast_install=$enable_fast_install + +# Shell to use when invoking shell scripts. +SHELL=$lt_SHELL + +# An echo program that protects backslashes. +ECHO=$lt_ECHO + +# The PATH separator for the build system. +PATH_SEPARATOR=$lt_PATH_SEPARATOR + +# The host system. +host_alias=$host_alias +host=$host +host_os=$host_os + +# The build system. +build_alias=$build_alias +build=$build +build_os=$build_os + +# A sed program that does not truncate output. +SED=$lt_SED + +# Sed that helps us avoid accidentally triggering echo(1) options like -n. +Xsed="\$SED -e 1s/^X//" + +# A grep program that handles long lines. +GREP=$lt_GREP + +# An ERE matcher. +EGREP=$lt_EGREP + +# A literal string matcher. +FGREP=$lt_FGREP + +# A BSD- or MS-compatible name lister. +NM=$lt_NM + +# Whether we need soft or hard links. +LN_S=$lt_LN_S + +# What is the maximum length of a command? +max_cmd_len=$max_cmd_len + +# Object file suffix (normally "o"). +objext=$ac_objext + +# Executable file suffix (normally ""). +exeext=$exeext + +# whether the shell understands "unset". +lt_unset=$lt_unset + +# turn spaces into newlines. +SP2NL=$lt_lt_SP2NL + +# turn newlines into spaces. +NL2SP=$lt_lt_NL2SP + +# convert \$build file names to \$host format. +to_host_file_cmd=$lt_cv_to_host_file_cmd + +# convert \$build files to toolchain format. +to_tool_file_cmd=$lt_cv_to_tool_file_cmd + +# Method to check whether dependent libraries are shared objects. +deplibs_check_method=$lt_deplibs_check_method + +# Command to use when deplibs_check_method = "file_magic". +file_magic_cmd=$lt_file_magic_cmd + +# How to find potential files when deplibs_check_method = "file_magic". +file_magic_glob=$lt_file_magic_glob + +# Find potential files using nocaseglob when deplibs_check_method = "file_magic". +want_nocaseglob=$lt_want_nocaseglob + +# Command to associate shared and link libraries. +sharedlib_from_linklib_cmd=$lt_sharedlib_from_linklib_cmd + +# The archiver. +AR=$lt_AR + +# Flags to create an archive. +AR_FLAGS=$lt_AR_FLAGS + +# How to feed a file listing to the archiver. +archiver_list_spec=$lt_archiver_list_spec + +# A symbol stripping program. +STRIP=$lt_STRIP + +# Commands used to install an old-style archive. +RANLIB=$lt_RANLIB +old_postinstall_cmds=$lt_old_postinstall_cmds +old_postuninstall_cmds=$lt_old_postuninstall_cmds + +# Whether to use a lock for old archive extraction. +lock_old_archive_extraction=$lock_old_archive_extraction + +# A C compiler. +LTCC=$lt_CC + +# LTCC compiler flags. +LTCFLAGS=$lt_CFLAGS + +# Take the output of nm and produce a listing of raw symbols and C names. +global_symbol_pipe=$lt_lt_cv_sys_global_symbol_pipe + +# Transform the output of nm in a proper C declaration. +global_symbol_to_cdecl=$lt_lt_cv_sys_global_symbol_to_cdecl + +# Transform the output of nm in a C name address pair. +global_symbol_to_c_name_address=$lt_lt_cv_sys_global_symbol_to_c_name_address + +# Transform the output of nm in a C name address pair when lib prefix is needed. +global_symbol_to_c_name_address_lib_prefix=$lt_lt_cv_sys_global_symbol_to_c_name_address_lib_prefix + +# Specify filename containing input files for \$NM. +nm_file_list_spec=$lt_nm_file_list_spec + +# The root where to search for dependent libraries,and in which our libraries should be installed. +lt_sysroot=$lt_sysroot + +# The name of the directory that contains temporary libtool files. +objdir=$objdir + +# Used to examine libraries when file_magic_cmd begins with "file". +MAGIC_CMD=$MAGIC_CMD + +# Must we lock files when doing compilation? +need_locks=$lt_need_locks + +# Manifest tool. +MANIFEST_TOOL=$lt_MANIFEST_TOOL + +# Tool to manipulate archived DWARF debug symbol files on Mac OS X. +DSYMUTIL=$lt_DSYMUTIL + +# Tool to change global to local symbols on Mac OS X. +NMEDIT=$lt_NMEDIT + +# Tool to manipulate fat objects and archives on Mac OS X. +LIPO=$lt_LIPO + +# ldd/readelf like tool for Mach-O binaries on Mac OS X. +OTOOL=$lt_OTOOL + +# ldd/readelf like tool for 64 bit Mach-O binaries on Mac OS X 10.4. +OTOOL64=$lt_OTOOL64 + +# Old archive suffix (normally "a"). +libext=$libext + +# Shared library suffix (normally ".so"). +shrext_cmds=$lt_shrext_cmds + +# The commands to extract the exported symbol list from a shared archive. +extract_expsyms_cmds=$lt_extract_expsyms_cmds + +# Variables whose values should be saved in libtool wrapper scripts and +# restored at link time. +variables_saved_for_relink=$lt_variables_saved_for_relink + +# Do we need the "lib" prefix for modules? +need_lib_prefix=$need_lib_prefix + +# Do we need a version for libraries? +need_version=$need_version + +# Library versioning type. +version_type=$version_type + +# Shared library runtime path variable. +runpath_var=$runpath_var + +# Shared library path variable. +shlibpath_var=$shlibpath_var + +# Is shlibpath searched before the hard-coded library search path? +shlibpath_overrides_runpath=$shlibpath_overrides_runpath + +# Format of library name prefix. +libname_spec=$lt_libname_spec + +# List of archive names. First name is the real one, the rest are links. +# The last name is the one that the linker finds with -lNAME +library_names_spec=$lt_library_names_spec + +# The coded name of the library, if different from the real name. +soname_spec=$lt_soname_spec + +# Permission mode override for installation of shared libraries. +install_override_mode=$lt_install_override_mode + +# Command to use after installation of a shared archive. +postinstall_cmds=$lt_postinstall_cmds + +# Command to use after uninstallation of a shared archive. +postuninstall_cmds=$lt_postuninstall_cmds + +# Commands used to finish a libtool library installation in a directory. +finish_cmds=$lt_finish_cmds + +# As "finish_cmds", except a single script fragment to be evaled but +# not shown. +finish_eval=$lt_finish_eval + +# Whether we should hardcode library paths into libraries. +hardcode_into_libs=$hardcode_into_libs + +# Compile-time system search path for libraries. +sys_lib_search_path_spec=$lt_sys_lib_search_path_spec + +# Run-time system search path for libraries. +sys_lib_dlsearch_path_spec=$lt_sys_lib_dlsearch_path_spec + +# Whether dlopen is supported. +dlopen_support=$enable_dlopen + +# Whether dlopen of programs is supported. +dlopen_self=$enable_dlopen_self + +# Whether dlopen of statically linked programs is supported. +dlopen_self_static=$enable_dlopen_self_static + +# Commands to strip libraries. +old_striplib=$lt_old_striplib +striplib=$lt_striplib + + +# The linker used to build libraries. +LD=$lt_LD + +# How to create reloadable object files. +reload_flag=$lt_reload_flag +reload_cmds=$lt_reload_cmds + +# Commands used to build an old-style archive. +old_archive_cmds=$lt_old_archive_cmds + +# A language specific compiler. +CC=$lt_compiler + +# Is the compiler the GNU compiler? +with_gcc=$GCC + +# Compiler flag to turn off builtin functions. +no_builtin_flag=$lt_lt_prog_compiler_no_builtin_flag + +# Additional compiler flags for building library objects. +pic_flag=$lt_lt_prog_compiler_pic + +# How to pass a linker flag through the compiler. +wl=$lt_lt_prog_compiler_wl + +# Compiler flag to prevent dynamic linking. +link_static_flag=$lt_lt_prog_compiler_static + +# Does compiler simultaneously support -c and -o options? +compiler_c_o=$lt_lt_cv_prog_compiler_c_o + +# Whether or not to add -lc for building shared libraries. +build_libtool_need_lc=$archive_cmds_need_lc + +# Whether or not to disallow shared libs when runtime libs are static. +allow_libtool_libs_with_static_runtimes=$enable_shared_with_static_runtimes + +# Compiler flag to allow reflexive dlopens. +export_dynamic_flag_spec=$lt_export_dynamic_flag_spec + +# Compiler flag to generate shared objects directly from archives. +whole_archive_flag_spec=$lt_whole_archive_flag_spec + +# Whether the compiler copes with passing no objects directly. +compiler_needs_object=$lt_compiler_needs_object + +# Create an old-style archive from a shared archive. +old_archive_from_new_cmds=$lt_old_archive_from_new_cmds + +# Create a temporary old-style archive to link instead of a shared archive. +old_archive_from_expsyms_cmds=$lt_old_archive_from_expsyms_cmds + +# Commands used to build a shared archive. +archive_cmds=$lt_archive_cmds +archive_expsym_cmds=$lt_archive_expsym_cmds + +# Commands used to build a loadable module if different from building +# a shared archive. +module_cmds=$lt_module_cmds +module_expsym_cmds=$lt_module_expsym_cmds + +# Whether we are building with GNU ld or not. +with_gnu_ld=$lt_with_gnu_ld + +# Flag that allows shared libraries with undefined symbols to be built. +allow_undefined_flag=$lt_allow_undefined_flag + +# Flag that enforces no undefined symbols. +no_undefined_flag=$lt_no_undefined_flag + +# Flag to hardcode \$libdir into a binary during linking. +# This must work even if \$libdir does not exist +hardcode_libdir_flag_spec=$lt_hardcode_libdir_flag_spec + +# Whether we need a single "-rpath" flag with a separated argument. +hardcode_libdir_separator=$lt_hardcode_libdir_separator + +# Set to "yes" if using DIR/libNAME\${shared_ext} during linking hardcodes +# DIR into the resulting binary. +hardcode_direct=$hardcode_direct + +# Set to "yes" if using DIR/libNAME\${shared_ext} during linking hardcodes +# DIR into the resulting binary and the resulting library dependency is +# "absolute",i.e impossible to change by setting \${shlibpath_var} if the +# library is relocated. +hardcode_direct_absolute=$hardcode_direct_absolute + +# Set to "yes" if using the -LDIR flag during linking hardcodes DIR +# into the resulting binary. +hardcode_minus_L=$hardcode_minus_L + +# Set to "yes" if using SHLIBPATH_VAR=DIR during linking hardcodes DIR +# into the resulting binary. +hardcode_shlibpath_var=$hardcode_shlibpath_var + +# Set to "yes" if building a shared library automatically hardcodes DIR +# into the library and all subsequent libraries and executables linked +# against it. +hardcode_automatic=$hardcode_automatic + +# Set to yes if linker adds runtime paths of dependent libraries +# to runtime path list. +inherit_rpath=$inherit_rpath + +# Whether libtool must link a program against all its dependency libraries. +link_all_deplibs=$link_all_deplibs + +# Set to "yes" if exported symbols are required. +always_export_symbols=$always_export_symbols + +# The commands to list exported symbols. +export_symbols_cmds=$lt_export_symbols_cmds + +# Symbols that should not be listed in the preloaded symbols. +exclude_expsyms=$lt_exclude_expsyms + +# Symbols that must always be exported. +include_expsyms=$lt_include_expsyms + +# Commands necessary for linking programs (against libraries) with templates. +prelink_cmds=$lt_prelink_cmds + +# Commands necessary for finishing linking programs. +postlink_cmds=$lt_postlink_cmds + +# Specify filename containing input files. +file_list_spec=$lt_file_list_spec + +# How to hardcode a shared library path into an executable. +hardcode_action=$hardcode_action + +# The directories searched by this compiler when creating a shared library. +compiler_lib_search_dirs=$lt_compiler_lib_search_dirs + +# Dependencies to place before and after the objects being linked to +# create a shared library. +predep_objects=$lt_predep_objects +postdep_objects=$lt_postdep_objects +predeps=$lt_predeps +postdeps=$lt_postdeps + +# The library search path used internally by the compiler when linking +# a shared library. +compiler_lib_search_path=$lt_compiler_lib_search_path + +# ### END LIBTOOL CONFIG + +_LT_EOF + + case $host_os in + aix3*) + cat <<\_LT_EOF >> "$cfgfile" +# AIX sometimes has problems with the GCC collect2 program. For some +# reason, if we set the COLLECT_NAMES environment variable, the problems +# vanish in a puff of smoke. +if test "X${COLLECT_NAMES+set}" != Xset; then + COLLECT_NAMES= + export COLLECT_NAMES +fi +_LT_EOF + ;; + esac + + +ltmain="$ac_aux_dir/ltmain.sh" + + + # We use sed instead of cat because bash on DJGPP gets confused if + # if finds mixed CR/LF and LF-only lines. Since sed operates in + # text mode, it properly converts lines to CR/LF. This bash problem + # is reportedly fixed, but why not run on old versions too? + sed '$q' "$ltmain" >> "$cfgfile" \ + || (rm -f "$cfgfile"; exit 1) + + if test x"$xsi_shell" = xyes; then + sed -e '/^func_dirname ()$/,/^} # func_dirname /c\ +func_dirname ()\ +{\ +\ case ${1} in\ +\ */*) func_dirname_result="${1%/*}${2}" ;;\ +\ * ) func_dirname_result="${3}" ;;\ +\ esac\ +} # Extended-shell func_dirname implementation' "$cfgfile" > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") +test 0 -eq $? || _lt_function_replace_fail=: + + + sed -e '/^func_basename ()$/,/^} # func_basename /c\ +func_basename ()\ +{\ +\ func_basename_result="${1##*/}"\ +} # Extended-shell func_basename implementation' "$cfgfile" > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") +test 0 -eq $? || _lt_function_replace_fail=: + + + sed -e '/^func_dirname_and_basename ()$/,/^} # func_dirname_and_basename /c\ +func_dirname_and_basename ()\ +{\ +\ case ${1} in\ +\ */*) func_dirname_result="${1%/*}${2}" ;;\ +\ * ) func_dirname_result="${3}" ;;\ +\ esac\ +\ func_basename_result="${1##*/}"\ +} # Extended-shell func_dirname_and_basename implementation' "$cfgfile" > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") +test 0 -eq $? || _lt_function_replace_fail=: + + + sed -e '/^func_stripname ()$/,/^} # func_stripname /c\ +func_stripname ()\ +{\ +\ # pdksh 5.2.14 does not do ${X%$Y} correctly if both X and Y are\ +\ # positional parameters, so assign one to ordinary parameter first.\ +\ func_stripname_result=${3}\ +\ func_stripname_result=${func_stripname_result#"${1}"}\ +\ func_stripname_result=${func_stripname_result%"${2}"}\ +} # Extended-shell func_stripname implementation' "$cfgfile" > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") +test 0 -eq $? || _lt_function_replace_fail=: + + + sed -e '/^func_split_long_opt ()$/,/^} # func_split_long_opt /c\ +func_split_long_opt ()\ +{\ +\ func_split_long_opt_name=${1%%=*}\ +\ func_split_long_opt_arg=${1#*=}\ +} # Extended-shell func_split_long_opt implementation' "$cfgfile" > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") +test 0 -eq $? || _lt_function_replace_fail=: + + + sed -e '/^func_split_short_opt ()$/,/^} # func_split_short_opt /c\ +func_split_short_opt ()\ +{\ +\ func_split_short_opt_arg=${1#??}\ +\ func_split_short_opt_name=${1%"$func_split_short_opt_arg"}\ +} # Extended-shell func_split_short_opt implementation' "$cfgfile" > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") +test 0 -eq $? || _lt_function_replace_fail=: + + + sed -e '/^func_lo2o ()$/,/^} # func_lo2o /c\ +func_lo2o ()\ +{\ +\ case ${1} in\ +\ *.lo) func_lo2o_result=${1%.lo}.${objext} ;;\ +\ *) func_lo2o_result=${1} ;;\ +\ esac\ +} # Extended-shell func_lo2o implementation' "$cfgfile" > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") +test 0 -eq $? || _lt_function_replace_fail=: + + + sed -e '/^func_xform ()$/,/^} # func_xform /c\ +func_xform ()\ +{\ + func_xform_result=${1%.*}.lo\ +} # Extended-shell func_xform implementation' "$cfgfile" > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") +test 0 -eq $? || _lt_function_replace_fail=: + + + sed -e '/^func_arith ()$/,/^} # func_arith /c\ +func_arith ()\ +{\ + func_arith_result=$(( $* ))\ +} # Extended-shell func_arith implementation' "$cfgfile" > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") +test 0 -eq $? || _lt_function_replace_fail=: + + + sed -e '/^func_len ()$/,/^} # func_len /c\ +func_len ()\ +{\ + func_len_result=${#1}\ +} # Extended-shell func_len implementation' "$cfgfile" > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") +test 0 -eq $? || _lt_function_replace_fail=: + +fi + +if test x"$lt_shell_append" = xyes; then + sed -e '/^func_append ()$/,/^} # func_append /c\ +func_append ()\ +{\ + eval "${1}+=\\${2}"\ +} # Extended-shell func_append implementation' "$cfgfile" > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") +test 0 -eq $? || _lt_function_replace_fail=: + + + sed -e '/^func_append_quoted ()$/,/^} # func_append_quoted /c\ +func_append_quoted ()\ +{\ +\ func_quote_for_eval "${2}"\ +\ eval "${1}+=\\\\ \\$func_quote_for_eval_result"\ +} # Extended-shell func_append_quoted implementation' "$cfgfile" > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") +test 0 -eq $? || _lt_function_replace_fail=: + + + # Save a `func_append' function call where possible by direct use of '+=' + sed -e 's%func_append \([a-zA-Z_]\{1,\}\) "%\1+="%g' $cfgfile > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") + test 0 -eq $? || _lt_function_replace_fail=: +else + # Save a `func_append' function call even when '+=' is not available + sed -e 's%func_append \([a-zA-Z_]\{1,\}\) "%\1="$\1%g' $cfgfile > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") + test 0 -eq $? || _lt_function_replace_fail=: +fi + +if test x"$_lt_function_replace_fail" = x":"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Unable to substitute extended shell functions in $ofile" >&5 +$as_echo "$as_me: WARNING: Unable to substitute extended shell functions in $ofile" >&2;} +fi + + + mv -f "$cfgfile" "$ofile" || + (rm -f "$ofile" && cp "$cfgfile" "$ofile" && rm -f "$cfgfile") + chmod +x "$ofile" + + + cat <<_LT_EOF >> "$ofile" + +# ### BEGIN LIBTOOL TAG CONFIG: CXX + +# The linker used to build libraries. +LD=$lt_LD_CXX + +# How to create reloadable object files. +reload_flag=$lt_reload_flag_CXX +reload_cmds=$lt_reload_cmds_CXX + +# Commands used to build an old-style archive. +old_archive_cmds=$lt_old_archive_cmds_CXX + +# A language specific compiler. +CC=$lt_compiler_CXX + +# Is the compiler the GNU compiler? +with_gcc=$GCC_CXX + +# Compiler flag to turn off builtin functions. +no_builtin_flag=$lt_lt_prog_compiler_no_builtin_flag_CXX + +# Additional compiler flags for building library objects. +pic_flag=$lt_lt_prog_compiler_pic_CXX + +# How to pass a linker flag through the compiler. +wl=$lt_lt_prog_compiler_wl_CXX + +# Compiler flag to prevent dynamic linking. +link_static_flag=$lt_lt_prog_compiler_static_CXX + +# Does compiler simultaneously support -c and -o options? +compiler_c_o=$lt_lt_cv_prog_compiler_c_o_CXX + +# Whether or not to add -lc for building shared libraries. +build_libtool_need_lc=$archive_cmds_need_lc_CXX + +# Whether or not to disallow shared libs when runtime libs are static. +allow_libtool_libs_with_static_runtimes=$enable_shared_with_static_runtimes_CXX + +# Compiler flag to allow reflexive dlopens. +export_dynamic_flag_spec=$lt_export_dynamic_flag_spec_CXX + +# Compiler flag to generate shared objects directly from archives. +whole_archive_flag_spec=$lt_whole_archive_flag_spec_CXX + +# Whether the compiler copes with passing no objects directly. +compiler_needs_object=$lt_compiler_needs_object_CXX + +# Create an old-style archive from a shared archive. +old_archive_from_new_cmds=$lt_old_archive_from_new_cmds_CXX + +# Create a temporary old-style archive to link instead of a shared archive. +old_archive_from_expsyms_cmds=$lt_old_archive_from_expsyms_cmds_CXX + +# Commands used to build a shared archive. +archive_cmds=$lt_archive_cmds_CXX +archive_expsym_cmds=$lt_archive_expsym_cmds_CXX + +# Commands used to build a loadable module if different from building +# a shared archive. +module_cmds=$lt_module_cmds_CXX +module_expsym_cmds=$lt_module_expsym_cmds_CXX + +# Whether we are building with GNU ld or not. +with_gnu_ld=$lt_with_gnu_ld_CXX + +# Flag that allows shared libraries with undefined symbols to be built. +allow_undefined_flag=$lt_allow_undefined_flag_CXX + +# Flag that enforces no undefined symbols. +no_undefined_flag=$lt_no_undefined_flag_CXX + +# Flag to hardcode \$libdir into a binary during linking. +# This must work even if \$libdir does not exist +hardcode_libdir_flag_spec=$lt_hardcode_libdir_flag_spec_CXX + +# Whether we need a single "-rpath" flag with a separated argument. +hardcode_libdir_separator=$lt_hardcode_libdir_separator_CXX + +# Set to "yes" if using DIR/libNAME\${shared_ext} during linking hardcodes +# DIR into the resulting binary. +hardcode_direct=$hardcode_direct_CXX + +# Set to "yes" if using DIR/libNAME\${shared_ext} during linking hardcodes +# DIR into the resulting binary and the resulting library dependency is +# "absolute",i.e impossible to change by setting \${shlibpath_var} if the +# library is relocated. +hardcode_direct_absolute=$hardcode_direct_absolute_CXX + +# Set to "yes" if using the -LDIR flag during linking hardcodes DIR +# into the resulting binary. +hardcode_minus_L=$hardcode_minus_L_CXX + +# Set to "yes" if using SHLIBPATH_VAR=DIR during linking hardcodes DIR +# into the resulting binary. +hardcode_shlibpath_var=$hardcode_shlibpath_var_CXX + +# Set to "yes" if building a shared library automatically hardcodes DIR +# into the library and all subsequent libraries and executables linked +# against it. +hardcode_automatic=$hardcode_automatic_CXX + +# Set to yes if linker adds runtime paths of dependent libraries +# to runtime path list. +inherit_rpath=$inherit_rpath_CXX + +# Whether libtool must link a program against all its dependency libraries. +link_all_deplibs=$link_all_deplibs_CXX + +# Set to "yes" if exported symbols are required. +always_export_symbols=$always_export_symbols_CXX + +# The commands to list exported symbols. +export_symbols_cmds=$lt_export_symbols_cmds_CXX + +# Symbols that should not be listed in the preloaded symbols. +exclude_expsyms=$lt_exclude_expsyms_CXX + +# Symbols that must always be exported. +include_expsyms=$lt_include_expsyms_CXX + +# Commands necessary for linking programs (against libraries) with templates. +prelink_cmds=$lt_prelink_cmds_CXX + +# Commands necessary for finishing linking programs. +postlink_cmds=$lt_postlink_cmds_CXX + +# Specify filename containing input files. +file_list_spec=$lt_file_list_spec_CXX + +# How to hardcode a shared library path into an executable. +hardcode_action=$hardcode_action_CXX + +# The directories searched by this compiler when creating a shared library. +compiler_lib_search_dirs=$lt_compiler_lib_search_dirs_CXX + +# Dependencies to place before and after the objects being linked to +# create a shared library. +predep_objects=$lt_predep_objects_CXX +postdep_objects=$lt_postdep_objects_CXX +predeps=$lt_predeps_CXX +postdeps=$lt_postdeps_CXX + +# The library search path used internally by the compiler when linking +# a shared library. +compiler_lib_search_path=$lt_compiler_lib_search_path_CXX + +# ### END LIBTOOL TAG CONFIG: CXX +_LT_EOF + + ;; + "libtool-rpath-patch":C) if test "$libtool_use_rpath" = "no"; then + sed < libtool > libtool-2 's/^hardcode_libdir_flag_spec.*$'/'hardcode_libdir_flag_spec=" -D__LIBTOOL_NO_RPATH__ "/' + mv libtool-2 libtool + chmod 755 libtool + fi ;; + + esac +done # for ac_tag + + +as_fn_exit 0 +_ACEOF +ac_clean_files=$ac_clean_files_save + +test $ac_write_fail = 0 || + as_fn_error $? "write failure creating $CONFIG_STATUS" "$LINENO" 5 + + +# configure is writing to config.log, and then calls config.status. +# config.status does its own redirection, appending to config.log. +# Unfortunately, on DOS this fails, as config.log is still kept open +# by configure, so config.status won't be able to write to it; its +# output is simply discarded. So we exec the FD to /dev/null, +# effectively closing config.log, so it can be properly (re)opened and +# appended to by config.status. When coming back to configure, we +# need to make the FD available again. +if test "$no_create" != yes; then + ac_cs_success=: + ac_config_status_args= + test "$silent" = yes && + ac_config_status_args="$ac_config_status_args --quiet" + exec 5>/dev/null + $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false + exec 5>>config.log + # Use ||, not &&, to avoid exiting from the if with $? = 1, which + # would make configure fail if this is the last instruction. + $ac_cs_success || as_fn_exit 1 +fi +if test -n "$ac_unrecognized_opts" && test "$enable_option_checking" != no; then + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5 +$as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2;} +fi + diff --git a/third-party/odb/libodb-2.4.0/configure.ac b/third-party/odb/libodb-2.4.0/configure.ac new file mode 100755 index 0000000..92727b7 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/configure.ac @@ -0,0 +1,68 @@ +# file : configure.ac +# copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +# license : GNU GPL v2; see accompanying LICENSE file + +AC_PREREQ(2.60) +AC_INIT([libodb], [2.4.0], [odb-users@codesynthesis.com]) +AC_CONFIG_AUX_DIR([config]) +AC_CONFIG_MACRO_DIR([m4]) +AC_CONFIG_SRCDIR([odb/version.hxx]) + +AM_INIT_AUTOMAKE([-Wall -Werror foreign nostdinc subdir-objects dist-bzip2 dist-zip tar-ustar]) +m4_ifdef([AM_PROG_AR], [AM_PROG_AR]) # Required by automake 1.12. + +LT_INIT([win32-dll]) + +AC_CANONICAL_HOST + +# Check for C++ compiler and use it to compile the tests. +# +AC_PROG_CXX +AC_LANG(C++) + +# Create the libtool executable so that we can use it in further tests. +# +LT_OUTPUT + +# Check for Windows. +# +win32=no +case $host_os in + windows* | mingw*) + win32=yes + ;; +esac + +AM_CONDITIONAL([ODB_WIN32], [test x$win32 = xyes]) + +# Check for threads. +# +THREADS + +AM_CONDITIONAL([ODB_THREADS_NONE], [test x$threads = xnone]) +AM_CONDITIONAL([ODB_THREADS_WIN32], [test x$threads = xwin32]) +AM_CONDITIONAL([ODB_THREADS_POSIX], [test x$threads = xposix]) + +AS_IF([test x$threads = xnone], AC_DEFINE([ODB_THREADS_NONE], [1], [Have no threads.])) +AS_IF([test x$threads = xwin32], AC_DEFINE([ODB_THREADS_WIN32], [1], [Have Win32 threads.])) +AS_IF([test x$threads = xposix], AC_DEFINE([ODB_THREADS_POSIX], [1], [Have POSIX threads.])) + +AS_IF([test x$threads_thread_keyword = xyes], AC_DEFINE([ODB_THREADS_TLS_KEYWORD], [1], [Have __thread keyword.])) + +# Define LIBODB_STATIC_LIB if we are build static library on certain platforms. +# +STATIC_LIB([LIBODB_STATIC_LIB], [Static library interface.]) + +# Allow the user to specify the pkgconfig directory. +# +PKGCONFIG + +# Check if we should disable rpath. +# +DISABLE_RPATH + +# Output. +# +AC_CONFIG_HEADERS([odb/config.h odb/details/config.h]) +AC_CONFIG_FILES([libodb.pc Makefile odb/Makefile]) +AC_OUTPUT diff --git a/third-party/odb/libodb-2.4.0/libodb-vc10.sln b/third-party/odb/libodb-2.4.0/libodb-vc10.sln new file mode 100755 index 0000000..0a9c5dd --- /dev/null +++ b/third-party/odb/libodb-2.4.0/libodb-vc10.sln @@ -0,0 +1,26 @@ + +Microsoft Visual Studio Solution File, Format Version 11.00 +# Visual Studio 2010 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libodb", "odb\libodb-vc10.vcxproj", "{1C53C543-8038-4C8A-8AB1-65E74FD7DE2E}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Win32 = Debug|Win32 + Debug|x64 = Debug|x64 + Release|Win32 = Release|Win32 + Release|x64 = Release|x64 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {1C53C543-8038-4C8A-8AB1-65E74FD7DE2E}.Debug|Win32.ActiveCfg = Debug|Win32 + {1C53C543-8038-4C8A-8AB1-65E74FD7DE2E}.Debug|Win32.Build.0 = Debug|Win32 + {1C53C543-8038-4C8A-8AB1-65E74FD7DE2E}.Debug|x64.ActiveCfg = Debug|x64 + {1C53C543-8038-4C8A-8AB1-65E74FD7DE2E}.Debug|x64.Build.0 = Debug|x64 + {1C53C543-8038-4C8A-8AB1-65E74FD7DE2E}.Release|Win32.ActiveCfg = Release|Win32 + {1C53C543-8038-4C8A-8AB1-65E74FD7DE2E}.Release|Win32.Build.0 = Release|Win32 + {1C53C543-8038-4C8A-8AB1-65E74FD7DE2E}.Release|x64.ActiveCfg = Release|x64 + {1C53C543-8038-4C8A-8AB1-65E74FD7DE2E}.Release|x64.Build.0 = Release|x64 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/third-party/odb/libodb-2.4.0/libodb-vc11.sln b/third-party/odb/libodb-2.4.0/libodb-vc11.sln new file mode 100755 index 0000000..6368225 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/libodb-vc11.sln @@ -0,0 +1,26 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio 2012 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libodb", "odb\libodb-vc11.vcxproj", "{1C53C543-8038-4C8A-8AB1-65E74FD7DE2E}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Win32 = Debug|Win32 + Debug|x64 = Debug|x64 + Release|Win32 = Release|Win32 + Release|x64 = Release|x64 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {1C53C543-8038-4C8A-8AB1-65E74FD7DE2E}.Debug|Win32.ActiveCfg = Debug|Win32 + {1C53C543-8038-4C8A-8AB1-65E74FD7DE2E}.Debug|Win32.Build.0 = Debug|Win32 + {1C53C543-8038-4C8A-8AB1-65E74FD7DE2E}.Debug|x64.ActiveCfg = Debug|x64 + {1C53C543-8038-4C8A-8AB1-65E74FD7DE2E}.Debug|x64.Build.0 = Debug|x64 + {1C53C543-8038-4C8A-8AB1-65E74FD7DE2E}.Release|Win32.ActiveCfg = Release|Win32 + {1C53C543-8038-4C8A-8AB1-65E74FD7DE2E}.Release|Win32.Build.0 = Release|Win32 + {1C53C543-8038-4C8A-8AB1-65E74FD7DE2E}.Release|x64.ActiveCfg = Release|x64 + {1C53C543-8038-4C8A-8AB1-65E74FD7DE2E}.Release|x64.Build.0 = Release|x64 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/third-party/odb/libodb-2.4.0/libodb-vc12.sln b/third-party/odb/libodb-2.4.0/libodb-vc12.sln new file mode 100755 index 0000000..862f9c9 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/libodb-vc12.sln @@ -0,0 +1,28 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio 2013 +VisualStudioVersion = 12.0.21005.1 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libodb", "odb\libodb-vc12.vcxproj", "{1C53C543-8038-4C8A-8AB1-65E74FD7DE2E}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Win32 = Debug|Win32 + Debug|x64 = Debug|x64 + Release|Win32 = Release|Win32 + Release|x64 = Release|x64 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {1C53C543-8038-4C8A-8AB1-65E74FD7DE2E}.Debug|Win32.ActiveCfg = Debug|Win32 + {1C53C543-8038-4C8A-8AB1-65E74FD7DE2E}.Debug|Win32.Build.0 = Debug|Win32 + {1C53C543-8038-4C8A-8AB1-65E74FD7DE2E}.Debug|x64.ActiveCfg = Debug|x64 + {1C53C543-8038-4C8A-8AB1-65E74FD7DE2E}.Debug|x64.Build.0 = Debug|x64 + {1C53C543-8038-4C8A-8AB1-65E74FD7DE2E}.Release|Win32.ActiveCfg = Release|Win32 + {1C53C543-8038-4C8A-8AB1-65E74FD7DE2E}.Release|Win32.Build.0 = Release|Win32 + {1C53C543-8038-4C8A-8AB1-65E74FD7DE2E}.Release|x64.ActiveCfg = Release|x64 + {1C53C543-8038-4C8A-8AB1-65E74FD7DE2E}.Release|x64.Build.0 = Release|x64 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/third-party/odb/libodb-2.4.0/libodb-vc8.sln b/third-party/odb/libodb-2.4.0/libodb-vc8.sln new file mode 100755 index 0000000..d6e2b1c --- /dev/null +++ b/third-party/odb/libodb-2.4.0/libodb-vc8.sln @@ -0,0 +1,26 @@ + +Microsoft Visual Studio Solution File, Format Version 9.00 +# Visual Studio 2005 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libodb", "odb\libodb-vc8.vcproj", "{513E5721-D318-46B0-8CFB-054042DF87A7}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Win32 = Debug|Win32 + Debug|x64 = Debug|x64 + Release|Win32 = Release|Win32 + Release|x64 = Release|x64 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {513E5721-D318-46B0-8CFB-054042DF87A7}.Debug|Win32.ActiveCfg = Debug|Win32 + {513E5721-D318-46B0-8CFB-054042DF87A7}.Debug|Win32.Build.0 = Debug|Win32 + {513E5721-D318-46B0-8CFB-054042DF87A7}.Debug|x64.ActiveCfg = Debug|x64 + {513E5721-D318-46B0-8CFB-054042DF87A7}.Debug|x64.Build.0 = Debug|x64 + {513E5721-D318-46B0-8CFB-054042DF87A7}.Release|Win32.ActiveCfg = Release|Win32 + {513E5721-D318-46B0-8CFB-054042DF87A7}.Release|Win32.Build.0 = Release|Win32 + {513E5721-D318-46B0-8CFB-054042DF87A7}.Release|x64.ActiveCfg = Release|x64 + {513E5721-D318-46B0-8CFB-054042DF87A7}.Release|x64.Build.0 = Release|x64 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/third-party/odb/libodb-2.4.0/libodb-vc9.sln b/third-party/odb/libodb-2.4.0/libodb-vc9.sln new file mode 100755 index 0000000..2ca5e34 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/libodb-vc9.sln @@ -0,0 +1,26 @@ + +Microsoft Visual Studio Solution File, Format Version 10.00 +# Visual Studio 2008 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libodb", "odb\libodb-vc9.vcproj", "{513E5721-D318-46B0-8CFB-054042DF87A7}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Win32 = Debug|Win32 + Debug|x64 = Debug|x64 + Release|Win32 = Release|Win32 + Release|x64 = Release|x64 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {513E5721-D318-46B0-8CFB-054042DF87A7}.Debug|Win32.ActiveCfg = Debug|Win32 + {513E5721-D318-46B0-8CFB-054042DF87A7}.Debug|Win32.Build.0 = Debug|Win32 + {513E5721-D318-46B0-8CFB-054042DF87A7}.Debug|x64.ActiveCfg = Debug|x64 + {513E5721-D318-46B0-8CFB-054042DF87A7}.Debug|x64.Build.0 = Debug|x64 + {513E5721-D318-46B0-8CFB-054042DF87A7}.Release|Win32.ActiveCfg = Release|Win32 + {513E5721-D318-46B0-8CFB-054042DF87A7}.Release|Win32.Build.0 = Release|Win32 + {513E5721-D318-46B0-8CFB-054042DF87A7}.Release|x64.ActiveCfg = Release|x64 + {513E5721-D318-46B0-8CFB-054042DF87A7}.Release|x64.Build.0 = Release|x64 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/third-party/odb/libodb-2.4.0/libodb.pc.in b/third-party/odb/libodb-2.4.0/libodb.pc.in new file mode 100755 index 0000000..a46a5b3 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/libodb.pc.in @@ -0,0 +1,15 @@ +# file : libodb.pc.in +# copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +# license : GNU GPL v2; see accompanying LICENSE file + +prefix=@prefix@ +exec_prefix=@exec_prefix@ +libdir=@libdir@ +includedir=@includedir@ + +Name: libodb +Description: Object-relational mapping (ORM) system for C++, common runtime library +URL: http://www.codesynthesis.com/products/odb/ +Version: @VERSION@ +Libs: -L${libdir} -lodb +Cflags: -I${includedir} diff --git a/third-party/odb/libodb-2.4.0/m4/acx-pthread.m4 b/third-party/odb/libodb-2.4.0/m4/acx-pthread.m4 new file mode 100755 index 0000000..204b32d --- /dev/null +++ b/third-party/odb/libodb-2.4.0/m4/acx-pthread.m4 @@ -0,0 +1,259 @@ +dnl +dnl NOTE: This file was modified. See the comments starting with 'CS:' +dnl for more information. In particular, it was changed to use C++ +dnl instead of C. +dnl +dnl @synopsis ACX_PTHREAD([ACTION-IF-FOUND[, ACTION-IF-NOT-FOUND]]) +dnl +dnl @summary figure out how to build C++ programs using POSIX threads +dnl +dnl This macro figures out how to build C++ programs using POSIX threads. +dnl It sets the PTHREAD_LIBS output variable to the threads library and +dnl linker flags, and the PTHREAD_CXXFLAGS output variable to any special +dnl C++ compiler flags that are needed. (The user can also force certain +dnl compiler flags/libs to be tested by setting these environment +dnl variables.) +dnl +dnl Also sets PTHREAD_CXX to any special C++ compiler that is needed for +dnl multi-threaded programs (defaults to the value of CXX otherwise). +dnl (This is necessary on AIX to use the special xlC_r compiler alias.) +dnl +dnl NOTE: You are assumed to not only compile your program with these +dnl flags, but also link it with them as well. e.g. you should link +dnl with $PTHREAD_CXX $CXXFLAGS $PTHREAD_CXXFLAGS $LDFLAGS ... $PTHREAD_LIBS +dnl $LIBS +dnl +dnl If you are only building threads programs, you may wish to use +dnl these variables in your default LIBS, CXXFLAGS, and CXX: +dnl +dnl LIBS="$PTHREAD_LIBS $LIBS" +dnl CXXFLAGS="$CXXFLAGS $PTHREAD_CXXFLAGS" +dnl CXX="$PTHREAD_CXX" +dnl +dnl In addition, if the PTHREAD_CREATE_JOINABLE thread-attribute +dnl constant has a nonstandard name, defines PTHREAD_CREATE_JOINABLE to +dnl that name (e.g. PTHREAD_CREATE_UNDETACHED on AIX). +dnl +dnl ACTION-IF-FOUND is a list of shell commands to run if a threads +dnl library is found, and ACTION-IF-NOT-FOUND is a list of commands to +dnl run it if it is not found. If ACTION-IF-FOUND is not specified, the +dnl default action will define HAVE_PTHREAD. +dnl +dnl Please let the authors know if this macro fails on any platform, or +dnl if you have any other suggestions or comments. This macro was based +dnl on work by SGJ on autoconf scripts for FFTW (www.fftw.org) (with +dnl help from M. Frigo), as well as ac_pthread and hb_pthread macros +dnl posted by Alejandro Forero Cuervo to the autoconf macro repository. +dnl We are also grateful for the helpful feedback of numerous users. +dnl +dnl @category InstalledPackages +dnl @author Steven G. Johnson +dnl @version 2006-05-29 +dnl @license GPLWithACException + +AC_DEFUN([ACX_PTHREAD], [ +AC_REQUIRE([AC_CANONICAL_HOST]) +AC_LANG_SAVE +AC_LANG(C++) +acx_pthread_ok=no + +# We used to check for pthread.h first, but this fails if pthread.h +# requires special compiler flags (e.g. on True64 or Sequent). +# It gets checked for in the link test anyway. + +# First of all, check if the user has set any of the PTHREAD_LIBS, +# etcetera environment variables, and if threads linking works using +# them: +if test x"$PTHREAD_LIBS$PTHREAD_CXXFLAGS" != x; then + save_CXXFLAGS="$CXXFLAGS" + CXXFLAGS="$CXXFLAGS $PTHREAD_CXXFLAGS" + save_LIBS="$LIBS" + LIBS="$PTHREAD_LIBS $LIBS" + AC_MSG_CHECKING([for pthread_join in LIBS=$PTHREAD_LIBS with CXXFLAGS=$PTHREAD_CXXFLAGS]) + AC_TRY_LINK_FUNC(pthread_join, acx_pthread_ok=yes) + AC_MSG_RESULT($acx_pthread_ok) + if test x"$acx_pthread_ok" = xno; then + PTHREAD_LIBS="" + PTHREAD_CXXFLAGS="" + fi + LIBS="$save_LIBS" + CXXFLAGS="$save_CXXFLAGS" +fi + +# We must check for the threads library under a number of different +# names; the ordering is very important because some systems +# (e.g. DEC) have both -lpthread and -lpthreads, where one of the +# libraries is broken (non-POSIX). + +# Create a list of thread flags to try. Items starting with a "-" are +# C compiler flags, and other items are library names, except for "none" +# which indicates that we try without any flags at all, and "pthread-config" +# which is a program returning the flags for the Pth emulation library. + +# CS: On GNU/Linux with gcc both -pthread and -lpthread are valid. +# However, libtool links libraries with -nostdlib which results in +# -pthread being stripped from the linker command line. To resolve +# this we move pthread from after -mthreads to after pthreads. +# +acx_pthread_flags="pthreads pthread none -Kthread -kthread lthread -pthread -pthreads -mthreads --thread-safe -mt pthread-config" + +# The ordering *is* (sometimes) important. Some notes on the +# individual items follow: + +# pthreads: AIX (must check this before -lpthread) +# none: in case threads are in libc; should be tried before -Kthread and +# other compiler flags to prevent continual compiler warnings +# -Kthread: Sequent (threads in libc, but -Kthread needed for pthread.h) +# -kthread: FreeBSD kernel threads (preferred to -pthread since SMP-able) +# lthread: LinuxThreads port on FreeBSD (also preferred to -pthread) +# -pthread: Linux/gcc (kernel threads), BSD/gcc (userland threads) +# -pthreads: Solaris/gcc +# -mthreads: Mingw32/gcc, Lynx/gcc +# -mt: Sun Workshop C (may only link SunOS threads [-lthread], but it +# doesn't hurt to check since this sometimes defines pthreads too; +# also defines -D_REENTRANT) +# ... -mt is also the pthreads flag for HP/aCC +# pthread: Linux, etcetera +# --thread-safe: KAI C++ +# pthread-config: use pthread-config program (for GNU Pth library) + +case "${host_cpu}-${host_os}" in + *solaris*) + + # On Solaris (at least, for some versions), libc contains stubbed + # (non-functional) versions of the pthreads routines, so link-based + # tests will erroneously succeed. (We need to link with -pthreads/-mt/ + # -lpthread.) (The stubs are missing pthread_cleanup_push, or rather + # a function called by this macro, so we could check for that, but + # who knows whether they'll stub that too in a future libc.) So, + # we'll just look for -pthreads and -lpthread first: + + # CS: Move -mt to the front of the list; Sun CC will use -mt, + # gcc will use -pthreads. + # + acx_pthread_flags="-mt -pthreads pthread -pthread $acx_pthread_flags" + ;; +esac + +if test x"$acx_pthread_ok" = xno; then +for flag in $acx_pthread_flags; do + + case $flag in + none) + AC_MSG_CHECKING([whether pthreads work without any flags]) + ;; + + -*) + AC_MSG_CHECKING([whether pthreads work with $flag]) + PTHREAD_CXXFLAGS="$flag" + ;; + + pthread-config) + AC_CHECK_PROG(acx_pthread_config, pthread-config, yes, no) + if test x"$acx_pthread_config" = xno; then continue; fi + PTHREAD_CXXFLAGS="`pthread-config --cflags`" + PTHREAD_LIBS="`pthread-config --ldflags` `pthread-config --libs`" + ;; + + *) + AC_MSG_CHECKING([for the pthreads library -l$flag]) + PTHREAD_LIBS="-l$flag" + ;; + esac + + save_LIBS="$LIBS" + save_CXXFLAGS="$CXXFLAGS" + LIBS="$PTHREAD_LIBS $LIBS" + CXXFLAGS="$CXXFLAGS $PTHREAD_CXXFLAGS" + + # Check for various functions. We must include pthread.h, + # since some functions may be macros. (On the Sequent, we + # need a special flag -Kthread to make this header compile.) + # We check for pthread_join because it is in -lpthread on IRIX + # while pthread_create is in libc. We check for pthread_attr_init + # due to DEC craziness with -lpthreads. We check for + # pthread_cleanup_push because it is one of the few pthread + # functions on Solaris that doesn't have a non-functional libc stub. + # We try pthread_create on general principles. + # + AC_TRY_LINK([#include ], + [pthread_t th; pthread_join(th, 0); + pthread_attr_init(0); pthread_cleanup_push(0, 0); + pthread_create(0,0,0,0); pthread_cleanup_pop(0);], + [acx_pthread_ok=yes]) + + LIBS="$save_LIBS" + CXXFLAGS="$save_CXXFLAGS" + + AC_MSG_RESULT($acx_pthread_ok) + if test "x$acx_pthread_ok" = xyes; then + break; + fi + + PTHREAD_LIBS="" + PTHREAD_CXXFLAGS="" +done +fi + +# Various other checks: +if test "x$acx_pthread_ok" = xyes; then + save_LIBS="$LIBS" + LIBS="$PTHREAD_LIBS $LIBS" + save_CXXFLAGS="$CXXFLAGS" + CXXFLAGS="$CXXFLAGS $PTHREAD_CXXFLAGS" + +dnl # Detect AIX lossage: JOINABLE attribute is called UNDETACHED. +dnl AC_MSG_CHECKING([for joinable pthread attribute]) +dnl attr_name=unknown +dnl for attr in PTHREAD_CREATE_JOINABLE PTHREAD_CREATE_UNDETACHED; do +dnl AC_TRY_LINK([#include ], [int attr=$attr; return attr;], +dnl [attr_name=$attr; break]) +dnl done +dnl AC_MSG_RESULT($attr_name) +dnl if test "$attr_name" != PTHREAD_CREATE_JOINABLE; then +dnl AC_DEFINE_UNQUOTED(PTHREAD_CREATE_JOINABLE, $attr_name, +dnl [Define to necessary symbol if this constant +dnl uses a non-standard name on your system.]) +dnl fi + + AC_MSG_CHECKING([if more special flags are required for pthreads]) + flag=no + case "${host_cpu}-${host_os}" in + *-aix* | *-freebsd* | *-darwin*) flag="-D_THREAD_SAFE";; + # CS: Add _REENTRANT in Linux to emulate -pthread. + # + *-linux* | *solaris* | *-osf* | *-hpux*) flag="-D_REENTRANT";; + esac + AC_MSG_RESULT(${flag}) + if test "x$flag" != xno; then + PTHREAD_CXXFLAGS="$flag $PTHREAD_CXXFLAGS" + fi + + LIBS="$save_LIBS" + CXXFLAGS="$save_CXXFLAGS" + +dnl # More AIX lossage: must compile with xlC_r +dnl if test x"$GXX" != xyes; then +dnl AC_CHECK_PROGS(PTHREAD_CXX, xlC_r, ${CXX}) +dnl else +dnl PTHREAD_CXX=$CXX +dnl fi + +else + PTHREAD_CXX="$CXX" +fi + +AC_SUBST(PTHREAD_LIBS) +AC_SUBST(PTHREAD_CXXFLAGS) +AC_SUBST(PTHREAD_CXX) + +# Finally, execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND: +if test x"$acx_pthread_ok" = xyes; then + ifelse([$1],,AC_DEFINE(HAVE_PTHREAD,1,[Define if you have POSIX threads libraries and header files.]),[$1]) + : +else + acx_pthread_ok=no + $2 +fi +AC_LANG_RESTORE +])dnl ACX_PTHREAD diff --git a/third-party/odb/libodb-2.4.0/m4/disable-rpath.m4 b/third-party/odb/libodb-2.4.0/m4/disable-rpath.m4 new file mode 100755 index 0000000..bf31ddc --- /dev/null +++ b/third-party/odb/libodb-2.4.0/m4/disable-rpath.m4 @@ -0,0 +1,25 @@ +dnl file : m4/disable-rpath.m4 +dnl copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +dnl license : GNU GPL v2; see accompanying LICENSE file +dnl +AC_DEFUN([DISABLE_RPATH],[ + +AC_MSG_CHECKING([whether to use rpath]) +AC_ARG_ENABLE( + [rpath], + [AC_HELP_STRING([--disable-rpath], [patch libtool to not use rpath])], + [libtool_rpath="$enable_rpath"], + [libtool_rpath="yes"]) +AC_MSG_RESULT($libtool_rpath) + +# Patch libtool to not use rpath if requested. +# +AC_CONFIG_COMMANDS( + [libtool-rpath-patch], + [if test "$libtool_use_rpath" = "no"; then + sed < libtool > libtool-2 's/^hardcode_libdir_flag_spec.*$'/'hardcode_libdir_flag_spec=" -D__LIBTOOL_NO_RPATH__ "/' + mv libtool-2 libtool + chmod 755 libtool + fi], + [libtool_use_rpath=$libtool_rpath]) +])dnl diff --git a/third-party/odb/libodb-2.4.0/m4/libtool-link.m4 b/third-party/odb/libodb-2.4.0/m4/libtool-link.m4 new file mode 100755 index 0000000..6b04b63 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/m4/libtool-link.m4 @@ -0,0 +1,46 @@ +dnl file : m4/libtool-link.m4 +dnl copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +dnl license : GNU GPL v2; see accompanying LICENSE file +dnl +dnl +dnl CXX_LIBTOOL_LINK_IFELSE (input, [action-if-true], [action-if-false]) +dnl +dnl Similar to AC_LINK_IFELSE except it uses libtool to perform the +dnl linking and it does this using the C++ compiler. +dnl +AC_DEFUN([CXX_LIBTOOL_LINK_IFELSE],[ +AC_LANG_SAVE +AC_LANG(C++) + +if test -d .libs; then + delete_libs_dir=no +else + delete_libs_dir=yes +fi + +AC_COMPILE_IFELSE([$1], +[ + ac_try='./libtool --tag=CXX --mode=link $CXX -no-install $CXXFLAGS $LDFLAGS -o conftest conftest.$OBJEXT $LIBS >&AS_MESSAGE_LOG_FD' + if _AC_DO_VAR(ac_try); then + libtool_link_ok=yes + else + libtool_link_ok=no + fi +], +[ + libtool_link_ok=no +]) + +if test x"$delete_libs_dir" = xyes; then + rm -rf .libs +fi + +if test x"$libtool_link_ok" = xyes; then +[$2] +: +else +[$3] +: +fi + +AC_LANG_RESTORE])dnl diff --git a/third-party/odb/libodb-2.4.0/m4/libtool.m4 b/third-party/odb/libodb-2.4.0/m4/libtool.m4 new file mode 100755 index 0000000..02b4bbe --- /dev/null +++ b/third-party/odb/libodb-2.4.0/m4/libtool.m4 @@ -0,0 +1,7991 @@ +# libtool.m4 - Configure libtool for the host system. -*-Autoconf-*- +# +# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, +# 2006, 2007, 2008, 2009, 2010, 2011 Free Software +# Foundation, Inc. +# Written by Gordon Matzigkeit, 1996 +# +# This file is free software; the Free Software Foundation gives +# unlimited permission to copy and/or distribute it, with or without +# modifications, as long as this notice is preserved. + +m4_define([_LT_COPYING], [dnl +# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, +# 2006, 2007, 2008, 2009, 2010, 2011 Free Software +# Foundation, Inc. +# Written by Gordon Matzigkeit, 1996 +# +# This file is part of GNU Libtool. +# +# GNU Libtool is free software; you can redistribute it and/or +# modify it under the terms of the GNU General Public License as +# published by the Free Software Foundation; either version 2 of +# the License, or (at your option) any later version. +# +# As a special exception to the GNU General Public License, +# if you distribute this file as part of a program or library that +# is built using GNU Libtool, you may include this file under the +# same distribution terms that you use for the rest of that program. +# +# GNU Libtool is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with GNU Libtool; see the file COPYING. If not, a copy +# can be downloaded from http://www.gnu.org/licenses/gpl.html, or +# obtained by writing to the Free Software Foundation, Inc., +# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +]) + +# serial 57 LT_INIT + + +# LT_PREREQ(VERSION) +# ------------------ +# Complain and exit if this libtool version is less that VERSION. +m4_defun([LT_PREREQ], +[m4_if(m4_version_compare(m4_defn([LT_PACKAGE_VERSION]), [$1]), -1, + [m4_default([$3], + [m4_fatal([Libtool version $1 or higher is required], + 63)])], + [$2])]) + + +# _LT_CHECK_BUILDDIR +# ------------------ +# Complain if the absolute build directory name contains unusual characters +m4_defun([_LT_CHECK_BUILDDIR], +[case `pwd` in + *\ * | *\ *) + AC_MSG_WARN([Libtool does not cope well with whitespace in `pwd`]) ;; +esac +]) + + +# LT_INIT([OPTIONS]) +# ------------------ +AC_DEFUN([LT_INIT], +[AC_PREREQ([2.58])dnl We use AC_INCLUDES_DEFAULT +AC_REQUIRE([AC_CONFIG_AUX_DIR_DEFAULT])dnl +AC_BEFORE([$0], [LT_LANG])dnl +AC_BEFORE([$0], [LT_OUTPUT])dnl +AC_BEFORE([$0], [LTDL_INIT])dnl +m4_require([_LT_CHECK_BUILDDIR])dnl + +dnl Autoconf doesn't catch unexpanded LT_ macros by default: +m4_pattern_forbid([^_?LT_[A-Z_]+$])dnl +m4_pattern_allow([^(_LT_EOF|LT_DLGLOBAL|LT_DLLAZY_OR_NOW|LT_MULTI_MODULE)$])dnl +dnl aclocal doesn't pull ltoptions.m4, ltsugar.m4, or ltversion.m4 +dnl unless we require an AC_DEFUNed macro: +AC_REQUIRE([LTOPTIONS_VERSION])dnl +AC_REQUIRE([LTSUGAR_VERSION])dnl +AC_REQUIRE([LTVERSION_VERSION])dnl +AC_REQUIRE([LTOBSOLETE_VERSION])dnl +m4_require([_LT_PROG_LTMAIN])dnl + +_LT_SHELL_INIT([SHELL=${CONFIG_SHELL-/bin/sh}]) + +dnl Parse OPTIONS +_LT_SET_OPTIONS([$0], [$1]) + +# This can be used to rebuild libtool when needed +LIBTOOL_DEPS="$ltmain" + +# Always use our own libtool. +LIBTOOL='$(SHELL) $(top_builddir)/libtool' +AC_SUBST(LIBTOOL)dnl + +_LT_SETUP + +# Only expand once: +m4_define([LT_INIT]) +])# LT_INIT + +# Old names: +AU_ALIAS([AC_PROG_LIBTOOL], [LT_INIT]) +AU_ALIAS([AM_PROG_LIBTOOL], [LT_INIT]) +dnl aclocal-1.4 backwards compatibility: +dnl AC_DEFUN([AC_PROG_LIBTOOL], []) +dnl AC_DEFUN([AM_PROG_LIBTOOL], []) + + +# _LT_CC_BASENAME(CC) +# ------------------- +# Calculate cc_basename. Skip known compiler wrappers and cross-prefix. +m4_defun([_LT_CC_BASENAME], +[for cc_temp in $1""; do + case $cc_temp in + compile | *[[\\/]]compile | ccache | *[[\\/]]ccache ) ;; + distcc | *[[\\/]]distcc | purify | *[[\\/]]purify ) ;; + \-*) ;; + *) break;; + esac +done +cc_basename=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"` +]) + + +# _LT_FILEUTILS_DEFAULTS +# ---------------------- +# It is okay to use these file commands and assume they have been set +# sensibly after `m4_require([_LT_FILEUTILS_DEFAULTS])'. +m4_defun([_LT_FILEUTILS_DEFAULTS], +[: ${CP="cp -f"} +: ${MV="mv -f"} +: ${RM="rm -f"} +])# _LT_FILEUTILS_DEFAULTS + + +# _LT_SETUP +# --------- +m4_defun([_LT_SETUP], +[AC_REQUIRE([AC_CANONICAL_HOST])dnl +AC_REQUIRE([AC_CANONICAL_BUILD])dnl +AC_REQUIRE([_LT_PREPARE_SED_QUOTE_VARS])dnl +AC_REQUIRE([_LT_PROG_ECHO_BACKSLASH])dnl + +_LT_DECL([], [PATH_SEPARATOR], [1], [The PATH separator for the build system])dnl +dnl +_LT_DECL([], [host_alias], [0], [The host system])dnl +_LT_DECL([], [host], [0])dnl +_LT_DECL([], [host_os], [0])dnl +dnl +_LT_DECL([], [build_alias], [0], [The build system])dnl +_LT_DECL([], [build], [0])dnl +_LT_DECL([], [build_os], [0])dnl +dnl +AC_REQUIRE([AC_PROG_CC])dnl +AC_REQUIRE([LT_PATH_LD])dnl +AC_REQUIRE([LT_PATH_NM])dnl +dnl +AC_REQUIRE([AC_PROG_LN_S])dnl +test -z "$LN_S" && LN_S="ln -s" +_LT_DECL([], [LN_S], [1], [Whether we need soft or hard links])dnl +dnl +AC_REQUIRE([LT_CMD_MAX_LEN])dnl +_LT_DECL([objext], [ac_objext], [0], [Object file suffix (normally "o")])dnl +_LT_DECL([], [exeext], [0], [Executable file suffix (normally "")])dnl +dnl +m4_require([_LT_FILEUTILS_DEFAULTS])dnl +m4_require([_LT_CHECK_SHELL_FEATURES])dnl +m4_require([_LT_PATH_CONVERSION_FUNCTIONS])dnl +m4_require([_LT_CMD_RELOAD])dnl +m4_require([_LT_CHECK_MAGIC_METHOD])dnl +m4_require([_LT_CHECK_SHAREDLIB_FROM_LINKLIB])dnl +m4_require([_LT_CMD_OLD_ARCHIVE])dnl +m4_require([_LT_CMD_GLOBAL_SYMBOLS])dnl +m4_require([_LT_WITH_SYSROOT])dnl + +_LT_CONFIG_LIBTOOL_INIT([ +# See if we are running on zsh, and set the options which allow our +# commands through without removal of \ escapes INIT. +if test -n "\${ZSH_VERSION+set}" ; then + setopt NO_GLOB_SUBST +fi +]) +if test -n "${ZSH_VERSION+set}" ; then + setopt NO_GLOB_SUBST +fi + +_LT_CHECK_OBJDIR + +m4_require([_LT_TAG_COMPILER])dnl + +case $host_os in +aix3*) + # AIX sometimes has problems with the GCC collect2 program. For some + # reason, if we set the COLLECT_NAMES environment variable, the problems + # vanish in a puff of smoke. + if test "X${COLLECT_NAMES+set}" != Xset; then + COLLECT_NAMES= + export COLLECT_NAMES + fi + ;; +esac + +# Global variables: +ofile=libtool +can_build_shared=yes + +# All known linkers require a `.a' archive for static linking (except MSVC, +# which needs '.lib'). +libext=a + +with_gnu_ld="$lt_cv_prog_gnu_ld" + +old_CC="$CC" +old_CFLAGS="$CFLAGS" + +# Set sane defaults for various variables +test -z "$CC" && CC=cc +test -z "$LTCC" && LTCC=$CC +test -z "$LTCFLAGS" && LTCFLAGS=$CFLAGS +test -z "$LD" && LD=ld +test -z "$ac_objext" && ac_objext=o + +_LT_CC_BASENAME([$compiler]) + +# Only perform the check for file, if the check method requires it +test -z "$MAGIC_CMD" && MAGIC_CMD=file +case $deplibs_check_method in +file_magic*) + if test "$file_magic_cmd" = '$MAGIC_CMD'; then + _LT_PATH_MAGIC + fi + ;; +esac + +# Use C for the default configuration in the libtool script +LT_SUPPORTED_TAG([CC]) +_LT_LANG_C_CONFIG +_LT_LANG_DEFAULT_CONFIG +_LT_CONFIG_COMMANDS +])# _LT_SETUP + + +# _LT_PREPARE_SED_QUOTE_VARS +# -------------------------- +# Define a few sed substitution that help us do robust quoting. +m4_defun([_LT_PREPARE_SED_QUOTE_VARS], +[# Backslashify metacharacters that are still active within +# double-quoted strings. +sed_quote_subst='s/\([["`$\\]]\)/\\\1/g' + +# Same as above, but do not quote variable references. +double_quote_subst='s/\([["`\\]]\)/\\\1/g' + +# Sed substitution to delay expansion of an escaped shell variable in a +# double_quote_subst'ed string. +delay_variable_subst='s/\\\\\\\\\\\$/\\\\\\$/g' + +# Sed substitution to delay expansion of an escaped single quote. +delay_single_quote_subst='s/'\''/'\'\\\\\\\'\''/g' + +# Sed substitution to avoid accidental globbing in evaled expressions +no_glob_subst='s/\*/\\\*/g' +]) + +# _LT_PROG_LTMAIN +# --------------- +# Note that this code is called both from `configure', and `config.status' +# now that we use AC_CONFIG_COMMANDS to generate libtool. Notably, +# `config.status' has no value for ac_aux_dir unless we are using Automake, +# so we pass a copy along to make sure it has a sensible value anyway. +m4_defun([_LT_PROG_LTMAIN], +[m4_ifdef([AC_REQUIRE_AUX_FILE], [AC_REQUIRE_AUX_FILE([ltmain.sh])])dnl +_LT_CONFIG_LIBTOOL_INIT([ac_aux_dir='$ac_aux_dir']) +ltmain="$ac_aux_dir/ltmain.sh" +])# _LT_PROG_LTMAIN + + +## ------------------------------------- ## +## Accumulate code for creating libtool. ## +## ------------------------------------- ## + +# So that we can recreate a full libtool script including additional +# tags, we accumulate the chunks of code to send to AC_CONFIG_COMMANDS +# in macros and then make a single call at the end using the `libtool' +# label. + + +# _LT_CONFIG_LIBTOOL_INIT([INIT-COMMANDS]) +# ---------------------------------------- +# Register INIT-COMMANDS to be passed to AC_CONFIG_COMMANDS later. +m4_define([_LT_CONFIG_LIBTOOL_INIT], +[m4_ifval([$1], + [m4_append([_LT_OUTPUT_LIBTOOL_INIT], + [$1 +])])]) + +# Initialize. +m4_define([_LT_OUTPUT_LIBTOOL_INIT]) + + +# _LT_CONFIG_LIBTOOL([COMMANDS]) +# ------------------------------ +# Register COMMANDS to be passed to AC_CONFIG_COMMANDS later. +m4_define([_LT_CONFIG_LIBTOOL], +[m4_ifval([$1], + [m4_append([_LT_OUTPUT_LIBTOOL_COMMANDS], + [$1 +])])]) + +# Initialize. +m4_define([_LT_OUTPUT_LIBTOOL_COMMANDS]) + + +# _LT_CONFIG_SAVE_COMMANDS([COMMANDS], [INIT_COMMANDS]) +# ----------------------------------------------------- +m4_defun([_LT_CONFIG_SAVE_COMMANDS], +[_LT_CONFIG_LIBTOOL([$1]) +_LT_CONFIG_LIBTOOL_INIT([$2]) +]) + + +# _LT_FORMAT_COMMENT([COMMENT]) +# ----------------------------- +# Add leading comment marks to the start of each line, and a trailing +# full-stop to the whole comment if one is not present already. +m4_define([_LT_FORMAT_COMMENT], +[m4_ifval([$1], [ +m4_bpatsubst([m4_bpatsubst([$1], [^ *], [# ])], + [['`$\]], [\\\&])]m4_bmatch([$1], [[!?.]$], [], [.]) +)]) + + + +## ------------------------ ## +## FIXME: Eliminate VARNAME ## +## ------------------------ ## + + +# _LT_DECL([CONFIGNAME], VARNAME, VALUE, [DESCRIPTION], [IS-TAGGED?]) +# ------------------------------------------------------------------- +# CONFIGNAME is the name given to the value in the libtool script. +# VARNAME is the (base) name used in the configure script. +# VALUE may be 0, 1 or 2 for a computed quote escaped value based on +# VARNAME. Any other value will be used directly. +m4_define([_LT_DECL], +[lt_if_append_uniq([lt_decl_varnames], [$2], [, ], + [lt_dict_add_subkey([lt_decl_dict], [$2], [libtool_name], + [m4_ifval([$1], [$1], [$2])]) + lt_dict_add_subkey([lt_decl_dict], [$2], [value], [$3]) + m4_ifval([$4], + [lt_dict_add_subkey([lt_decl_dict], [$2], [description], [$4])]) + lt_dict_add_subkey([lt_decl_dict], [$2], + [tagged?], [m4_ifval([$5], [yes], [no])])]) +]) + + +# _LT_TAGDECL([CONFIGNAME], VARNAME, VALUE, [DESCRIPTION]) +# -------------------------------------------------------- +m4_define([_LT_TAGDECL], [_LT_DECL([$1], [$2], [$3], [$4], [yes])]) + + +# lt_decl_tag_varnames([SEPARATOR], [VARNAME1...]) +# ------------------------------------------------ +m4_define([lt_decl_tag_varnames], +[_lt_decl_filter([tagged?], [yes], $@)]) + + +# _lt_decl_filter(SUBKEY, VALUE, [SEPARATOR], [VARNAME1..]) +# --------------------------------------------------------- +m4_define([_lt_decl_filter], +[m4_case([$#], + [0], [m4_fatal([$0: too few arguments: $#])], + [1], [m4_fatal([$0: too few arguments: $#: $1])], + [2], [lt_dict_filter([lt_decl_dict], [$1], [$2], [], lt_decl_varnames)], + [3], [lt_dict_filter([lt_decl_dict], [$1], [$2], [$3], lt_decl_varnames)], + [lt_dict_filter([lt_decl_dict], $@)])[]dnl +]) + + +# lt_decl_quote_varnames([SEPARATOR], [VARNAME1...]) +# -------------------------------------------------- +m4_define([lt_decl_quote_varnames], +[_lt_decl_filter([value], [1], $@)]) + + +# lt_decl_dquote_varnames([SEPARATOR], [VARNAME1...]) +# --------------------------------------------------- +m4_define([lt_decl_dquote_varnames], +[_lt_decl_filter([value], [2], $@)]) + + +# lt_decl_varnames_tagged([SEPARATOR], [VARNAME1...]) +# --------------------------------------------------- +m4_define([lt_decl_varnames_tagged], +[m4_assert([$# <= 2])dnl +_$0(m4_quote(m4_default([$1], [[, ]])), + m4_ifval([$2], [[$2]], [m4_dquote(lt_decl_tag_varnames)]), + m4_split(m4_normalize(m4_quote(_LT_TAGS)), [ ]))]) +m4_define([_lt_decl_varnames_tagged], +[m4_ifval([$3], [lt_combine([$1], [$2], [_], $3)])]) + + +# lt_decl_all_varnames([SEPARATOR], [VARNAME1...]) +# ------------------------------------------------ +m4_define([lt_decl_all_varnames], +[_$0(m4_quote(m4_default([$1], [[, ]])), + m4_if([$2], [], + m4_quote(lt_decl_varnames), + m4_quote(m4_shift($@))))[]dnl +]) +m4_define([_lt_decl_all_varnames], +[lt_join($@, lt_decl_varnames_tagged([$1], + lt_decl_tag_varnames([[, ]], m4_shift($@))))dnl +]) + + +# _LT_CONFIG_STATUS_DECLARE([VARNAME]) +# ------------------------------------ +# Quote a variable value, and forward it to `config.status' so that its +# declaration there will have the same value as in `configure'. VARNAME +# must have a single quote delimited value for this to work. +m4_define([_LT_CONFIG_STATUS_DECLARE], +[$1='`$ECHO "$][$1" | $SED "$delay_single_quote_subst"`']) + + +# _LT_CONFIG_STATUS_DECLARATIONS +# ------------------------------ +# We delimit libtool config variables with single quotes, so when +# we write them to config.status, we have to be sure to quote all +# embedded single quotes properly. In configure, this macro expands +# each variable declared with _LT_DECL (and _LT_TAGDECL) into: +# +# ='`$ECHO "$" | $SED "$delay_single_quote_subst"`' +m4_defun([_LT_CONFIG_STATUS_DECLARATIONS], +[m4_foreach([_lt_var], m4_quote(lt_decl_all_varnames), + [m4_n([_LT_CONFIG_STATUS_DECLARE(_lt_var)])])]) + + +# _LT_LIBTOOL_TAGS +# ---------------- +# Output comment and list of tags supported by the script +m4_defun([_LT_LIBTOOL_TAGS], +[_LT_FORMAT_COMMENT([The names of the tagged configurations supported by this script])dnl +available_tags="_LT_TAGS"dnl +]) + + +# _LT_LIBTOOL_DECLARE(VARNAME, [TAG]) +# ----------------------------------- +# Extract the dictionary values for VARNAME (optionally with TAG) and +# expand to a commented shell variable setting: +# +# # Some comment about what VAR is for. +# visible_name=$lt_internal_name +m4_define([_LT_LIBTOOL_DECLARE], +[_LT_FORMAT_COMMENT(m4_quote(lt_dict_fetch([lt_decl_dict], [$1], + [description])))[]dnl +m4_pushdef([_libtool_name], + m4_quote(lt_dict_fetch([lt_decl_dict], [$1], [libtool_name])))[]dnl +m4_case(m4_quote(lt_dict_fetch([lt_decl_dict], [$1], [value])), + [0], [_libtool_name=[$]$1], + [1], [_libtool_name=$lt_[]$1], + [2], [_libtool_name=$lt_[]$1], + [_libtool_name=lt_dict_fetch([lt_decl_dict], [$1], [value])])[]dnl +m4_ifval([$2], [_$2])[]m4_popdef([_libtool_name])[]dnl +]) + + +# _LT_LIBTOOL_CONFIG_VARS +# ----------------------- +# Produce commented declarations of non-tagged libtool config variables +# suitable for insertion in the LIBTOOL CONFIG section of the `libtool' +# script. Tagged libtool config variables (even for the LIBTOOL CONFIG +# section) are produced by _LT_LIBTOOL_TAG_VARS. +m4_defun([_LT_LIBTOOL_CONFIG_VARS], +[m4_foreach([_lt_var], + m4_quote(_lt_decl_filter([tagged?], [no], [], lt_decl_varnames)), + [m4_n([_LT_LIBTOOL_DECLARE(_lt_var)])])]) + + +# _LT_LIBTOOL_TAG_VARS(TAG) +# ------------------------- +m4_define([_LT_LIBTOOL_TAG_VARS], +[m4_foreach([_lt_var], m4_quote(lt_decl_tag_varnames), + [m4_n([_LT_LIBTOOL_DECLARE(_lt_var, [$1])])])]) + + +# _LT_TAGVAR(VARNAME, [TAGNAME]) +# ------------------------------ +m4_define([_LT_TAGVAR], [m4_ifval([$2], [$1_$2], [$1])]) + + +# _LT_CONFIG_COMMANDS +# ------------------- +# Send accumulated output to $CONFIG_STATUS. Thanks to the lists of +# variables for single and double quote escaping we saved from calls +# to _LT_DECL, we can put quote escaped variables declarations +# into `config.status', and then the shell code to quote escape them in +# for loops in `config.status'. Finally, any additional code accumulated +# from calls to _LT_CONFIG_LIBTOOL_INIT is expanded. +m4_defun([_LT_CONFIG_COMMANDS], +[AC_PROVIDE_IFELSE([LT_OUTPUT], + dnl If the libtool generation code has been placed in $CONFIG_LT, + dnl instead of duplicating it all over again into config.status, + dnl then we will have config.status run $CONFIG_LT later, so it + dnl needs to know what name is stored there: + [AC_CONFIG_COMMANDS([libtool], + [$SHELL $CONFIG_LT || AS_EXIT(1)], [CONFIG_LT='$CONFIG_LT'])], + dnl If the libtool generation code is destined for config.status, + dnl expand the accumulated commands and init code now: + [AC_CONFIG_COMMANDS([libtool], + [_LT_OUTPUT_LIBTOOL_COMMANDS], [_LT_OUTPUT_LIBTOOL_COMMANDS_INIT])]) +])#_LT_CONFIG_COMMANDS + + +# Initialize. +m4_define([_LT_OUTPUT_LIBTOOL_COMMANDS_INIT], +[ + +# The HP-UX ksh and POSIX shell print the target directory to stdout +# if CDPATH is set. +(unset CDPATH) >/dev/null 2>&1 && unset CDPATH + +sed_quote_subst='$sed_quote_subst' +double_quote_subst='$double_quote_subst' +delay_variable_subst='$delay_variable_subst' +_LT_CONFIG_STATUS_DECLARATIONS +LTCC='$LTCC' +LTCFLAGS='$LTCFLAGS' +compiler='$compiler_DEFAULT' + +# A function that is used when there is no print builtin or printf. +func_fallback_echo () +{ + eval 'cat <<_LTECHO_EOF +\$[]1 +_LTECHO_EOF' +} + +# Quote evaled strings. +for var in lt_decl_all_varnames([[ \ +]], lt_decl_quote_varnames); do + case \`eval \\\\\$ECHO \\\\""\\\\\$\$var"\\\\"\` in + *[[\\\\\\\`\\"\\\$]]*) + eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"\\\$\$var\\" | \\\$SED \\"\\\$sed_quote_subst\\"\\\`\\\\\\"" + ;; + *) + eval "lt_\$var=\\\\\\"\\\$\$var\\\\\\"" + ;; + esac +done + +# Double-quote double-evaled strings. +for var in lt_decl_all_varnames([[ \ +]], lt_decl_dquote_varnames); do + case \`eval \\\\\$ECHO \\\\""\\\\\$\$var"\\\\"\` in + *[[\\\\\\\`\\"\\\$]]*) + eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"\\\$\$var\\" | \\\$SED -e \\"\\\$double_quote_subst\\" -e \\"\\\$sed_quote_subst\\" -e \\"\\\$delay_variable_subst\\"\\\`\\\\\\"" + ;; + *) + eval "lt_\$var=\\\\\\"\\\$\$var\\\\\\"" + ;; + esac +done + +_LT_OUTPUT_LIBTOOL_INIT +]) + +# _LT_GENERATED_FILE_INIT(FILE, [COMMENT]) +# ------------------------------------ +# Generate a child script FILE with all initialization necessary to +# reuse the environment learned by the parent script, and make the +# file executable. If COMMENT is supplied, it is inserted after the +# `#!' sequence but before initialization text begins. After this +# macro, additional text can be appended to FILE to form the body of +# the child script. The macro ends with non-zero status if the +# file could not be fully written (such as if the disk is full). +m4_ifdef([AS_INIT_GENERATED], +[m4_defun([_LT_GENERATED_FILE_INIT],[AS_INIT_GENERATED($@)])], +[m4_defun([_LT_GENERATED_FILE_INIT], +[m4_require([AS_PREPARE])]dnl +[m4_pushdef([AS_MESSAGE_LOG_FD])]dnl +[lt_write_fail=0 +cat >$1 <<_ASEOF || lt_write_fail=1 +#! $SHELL +# Generated by $as_me. +$2 +SHELL=\${CONFIG_SHELL-$SHELL} +export SHELL +_ASEOF +cat >>$1 <<\_ASEOF || lt_write_fail=1 +AS_SHELL_SANITIZE +_AS_PREPARE +exec AS_MESSAGE_FD>&1 +_ASEOF +test $lt_write_fail = 0 && chmod +x $1[]dnl +m4_popdef([AS_MESSAGE_LOG_FD])])])# _LT_GENERATED_FILE_INIT + +# LT_OUTPUT +# --------- +# This macro allows early generation of the libtool script (before +# AC_OUTPUT is called), incase it is used in configure for compilation +# tests. +AC_DEFUN([LT_OUTPUT], +[: ${CONFIG_LT=./config.lt} +AC_MSG_NOTICE([creating $CONFIG_LT]) +_LT_GENERATED_FILE_INIT(["$CONFIG_LT"], +[# Run this file to recreate a libtool stub with the current configuration.]) + +cat >>"$CONFIG_LT" <<\_LTEOF +lt_cl_silent=false +exec AS_MESSAGE_LOG_FD>>config.log +{ + echo + AS_BOX([Running $as_me.]) +} >&AS_MESSAGE_LOG_FD + +lt_cl_help="\ +\`$as_me' creates a local libtool stub from the current configuration, +for use in further configure time tests before the real libtool is +generated. + +Usage: $[0] [[OPTIONS]] + + -h, --help print this help, then exit + -V, --version print version number, then exit + -q, --quiet do not print progress messages + -d, --debug don't remove temporary files + +Report bugs to ." + +lt_cl_version="\ +m4_ifset([AC_PACKAGE_NAME], [AC_PACKAGE_NAME ])config.lt[]dnl +m4_ifset([AC_PACKAGE_VERSION], [ AC_PACKAGE_VERSION]) +configured by $[0], generated by m4_PACKAGE_STRING. + +Copyright (C) 2011 Free Software Foundation, Inc. +This config.lt script is free software; the Free Software Foundation +gives unlimited permision to copy, distribute and modify it." + +while test $[#] != 0 +do + case $[1] in + --version | --v* | -V ) + echo "$lt_cl_version"; exit 0 ;; + --help | --h* | -h ) + echo "$lt_cl_help"; exit 0 ;; + --debug | --d* | -d ) + debug=: ;; + --quiet | --q* | --silent | --s* | -q ) + lt_cl_silent=: ;; + + -*) AC_MSG_ERROR([unrecognized option: $[1] +Try \`$[0] --help' for more information.]) ;; + + *) AC_MSG_ERROR([unrecognized argument: $[1] +Try \`$[0] --help' for more information.]) ;; + esac + shift +done + +if $lt_cl_silent; then + exec AS_MESSAGE_FD>/dev/null +fi +_LTEOF + +cat >>"$CONFIG_LT" <<_LTEOF +_LT_OUTPUT_LIBTOOL_COMMANDS_INIT +_LTEOF + +cat >>"$CONFIG_LT" <<\_LTEOF +AC_MSG_NOTICE([creating $ofile]) +_LT_OUTPUT_LIBTOOL_COMMANDS +AS_EXIT(0) +_LTEOF +chmod +x "$CONFIG_LT" + +# configure is writing to config.log, but config.lt does its own redirection, +# appending to config.log, which fails on DOS, as config.log is still kept +# open by configure. Here we exec the FD to /dev/null, effectively closing +# config.log, so it can be properly (re)opened and appended to by config.lt. +lt_cl_success=: +test "$silent" = yes && + lt_config_lt_args="$lt_config_lt_args --quiet" +exec AS_MESSAGE_LOG_FD>/dev/null +$SHELL "$CONFIG_LT" $lt_config_lt_args || lt_cl_success=false +exec AS_MESSAGE_LOG_FD>>config.log +$lt_cl_success || AS_EXIT(1) +])# LT_OUTPUT + + +# _LT_CONFIG(TAG) +# --------------- +# If TAG is the built-in tag, create an initial libtool script with a +# default configuration from the untagged config vars. Otherwise add code +# to config.status for appending the configuration named by TAG from the +# matching tagged config vars. +m4_defun([_LT_CONFIG], +[m4_require([_LT_FILEUTILS_DEFAULTS])dnl +_LT_CONFIG_SAVE_COMMANDS([ + m4_define([_LT_TAG], m4_if([$1], [], [C], [$1]))dnl + m4_if(_LT_TAG, [C], [ + # See if we are running on zsh, and set the options which allow our + # commands through without removal of \ escapes. + if test -n "${ZSH_VERSION+set}" ; then + setopt NO_GLOB_SUBST + fi + + cfgfile="${ofile}T" + trap "$RM \"$cfgfile\"; exit 1" 1 2 15 + $RM "$cfgfile" + + cat <<_LT_EOF >> "$cfgfile" +#! $SHELL + +# `$ECHO "$ofile" | sed 's%^.*/%%'` - Provide generalized library-building support services. +# Generated automatically by $as_me ($PACKAGE$TIMESTAMP) $VERSION +# Libtool was configured on host `(hostname || uname -n) 2>/dev/null | sed 1q`: +# NOTE: Changes made to this file will be lost: look at ltmain.sh. +# +_LT_COPYING +_LT_LIBTOOL_TAGS + +# ### BEGIN LIBTOOL CONFIG +_LT_LIBTOOL_CONFIG_VARS +_LT_LIBTOOL_TAG_VARS +# ### END LIBTOOL CONFIG + +_LT_EOF + + case $host_os in + aix3*) + cat <<\_LT_EOF >> "$cfgfile" +# AIX sometimes has problems with the GCC collect2 program. For some +# reason, if we set the COLLECT_NAMES environment variable, the problems +# vanish in a puff of smoke. +if test "X${COLLECT_NAMES+set}" != Xset; then + COLLECT_NAMES= + export COLLECT_NAMES +fi +_LT_EOF + ;; + esac + + _LT_PROG_LTMAIN + + # We use sed instead of cat because bash on DJGPP gets confused if + # if finds mixed CR/LF and LF-only lines. Since sed operates in + # text mode, it properly converts lines to CR/LF. This bash problem + # is reportedly fixed, but why not run on old versions too? + sed '$q' "$ltmain" >> "$cfgfile" \ + || (rm -f "$cfgfile"; exit 1) + + _LT_PROG_REPLACE_SHELLFNS + + mv -f "$cfgfile" "$ofile" || + (rm -f "$ofile" && cp "$cfgfile" "$ofile" && rm -f "$cfgfile") + chmod +x "$ofile" +], +[cat <<_LT_EOF >> "$ofile" + +dnl Unfortunately we have to use $1 here, since _LT_TAG is not expanded +dnl in a comment (ie after a #). +# ### BEGIN LIBTOOL TAG CONFIG: $1 +_LT_LIBTOOL_TAG_VARS(_LT_TAG) +# ### END LIBTOOL TAG CONFIG: $1 +_LT_EOF +])dnl /m4_if +], +[m4_if([$1], [], [ + PACKAGE='$PACKAGE' + VERSION='$VERSION' + TIMESTAMP='$TIMESTAMP' + RM='$RM' + ofile='$ofile'], []) +])dnl /_LT_CONFIG_SAVE_COMMANDS +])# _LT_CONFIG + + +# LT_SUPPORTED_TAG(TAG) +# --------------------- +# Trace this macro to discover what tags are supported by the libtool +# --tag option, using: +# autoconf --trace 'LT_SUPPORTED_TAG:$1' +AC_DEFUN([LT_SUPPORTED_TAG], []) + + +# C support is built-in for now +m4_define([_LT_LANG_C_enabled], []) +m4_define([_LT_TAGS], []) + + +# LT_LANG(LANG) +# ------------- +# Enable libtool support for the given language if not already enabled. +AC_DEFUN([LT_LANG], +[AC_BEFORE([$0], [LT_OUTPUT])dnl +m4_case([$1], + [C], [_LT_LANG(C)], + [C++], [_LT_LANG(CXX)], + [Go], [_LT_LANG(GO)], + [Java], [_LT_LANG(GCJ)], + [Fortran 77], [_LT_LANG(F77)], + [Fortran], [_LT_LANG(FC)], + [Windows Resource], [_LT_LANG(RC)], + [m4_ifdef([_LT_LANG_]$1[_CONFIG], + [_LT_LANG($1)], + [m4_fatal([$0: unsupported language: "$1"])])])dnl +])# LT_LANG + + +# _LT_LANG(LANGNAME) +# ------------------ +m4_defun([_LT_LANG], +[m4_ifdef([_LT_LANG_]$1[_enabled], [], + [LT_SUPPORTED_TAG([$1])dnl + m4_append([_LT_TAGS], [$1 ])dnl + m4_define([_LT_LANG_]$1[_enabled], [])dnl + _LT_LANG_$1_CONFIG($1)])dnl +])# _LT_LANG + + +m4_ifndef([AC_PROG_GO], [ +############################################################ +# NOTE: This macro has been submitted for inclusion into # +# GNU Autoconf as AC_PROG_GO. When it is available in # +# a released version of Autoconf we should remove this # +# macro and use it instead. # +############################################################ +m4_defun([AC_PROG_GO], +[AC_LANG_PUSH(Go)dnl +AC_ARG_VAR([GOC], [Go compiler command])dnl +AC_ARG_VAR([GOFLAGS], [Go compiler flags])dnl +_AC_ARG_VAR_LDFLAGS()dnl +AC_CHECK_TOOL(GOC, gccgo) +if test -z "$GOC"; then + if test -n "$ac_tool_prefix"; then + AC_CHECK_PROG(GOC, [${ac_tool_prefix}gccgo], [${ac_tool_prefix}gccgo]) + fi +fi +if test -z "$GOC"; then + AC_CHECK_PROG(GOC, gccgo, gccgo, false) +fi +])#m4_defun +])#m4_ifndef + + +# _LT_LANG_DEFAULT_CONFIG +# ----------------------- +m4_defun([_LT_LANG_DEFAULT_CONFIG], +[AC_PROVIDE_IFELSE([AC_PROG_CXX], + [LT_LANG(CXX)], + [m4_define([AC_PROG_CXX], defn([AC_PROG_CXX])[LT_LANG(CXX)])]) + +AC_PROVIDE_IFELSE([AC_PROG_F77], + [LT_LANG(F77)], + [m4_define([AC_PROG_F77], defn([AC_PROG_F77])[LT_LANG(F77)])]) + +AC_PROVIDE_IFELSE([AC_PROG_FC], + [LT_LANG(FC)], + [m4_define([AC_PROG_FC], defn([AC_PROG_FC])[LT_LANG(FC)])]) + +dnl The call to [A][M_PROG_GCJ] is quoted like that to stop aclocal +dnl pulling things in needlessly. +AC_PROVIDE_IFELSE([AC_PROG_GCJ], + [LT_LANG(GCJ)], + [AC_PROVIDE_IFELSE([A][M_PROG_GCJ], + [LT_LANG(GCJ)], + [AC_PROVIDE_IFELSE([LT_PROG_GCJ], + [LT_LANG(GCJ)], + [m4_ifdef([AC_PROG_GCJ], + [m4_define([AC_PROG_GCJ], defn([AC_PROG_GCJ])[LT_LANG(GCJ)])]) + m4_ifdef([A][M_PROG_GCJ], + [m4_define([A][M_PROG_GCJ], defn([A][M_PROG_GCJ])[LT_LANG(GCJ)])]) + m4_ifdef([LT_PROG_GCJ], + [m4_define([LT_PROG_GCJ], defn([LT_PROG_GCJ])[LT_LANG(GCJ)])])])])]) + +AC_PROVIDE_IFELSE([AC_PROG_GO], + [LT_LANG(GO)], + [m4_define([AC_PROG_GO], defn([AC_PROG_GO])[LT_LANG(GO)])]) + +AC_PROVIDE_IFELSE([LT_PROG_RC], + [LT_LANG(RC)], + [m4_define([LT_PROG_RC], defn([LT_PROG_RC])[LT_LANG(RC)])]) +])# _LT_LANG_DEFAULT_CONFIG + +# Obsolete macros: +AU_DEFUN([AC_LIBTOOL_CXX], [LT_LANG(C++)]) +AU_DEFUN([AC_LIBTOOL_F77], [LT_LANG(Fortran 77)]) +AU_DEFUN([AC_LIBTOOL_FC], [LT_LANG(Fortran)]) +AU_DEFUN([AC_LIBTOOL_GCJ], [LT_LANG(Java)]) +AU_DEFUN([AC_LIBTOOL_RC], [LT_LANG(Windows Resource)]) +dnl aclocal-1.4 backwards compatibility: +dnl AC_DEFUN([AC_LIBTOOL_CXX], []) +dnl AC_DEFUN([AC_LIBTOOL_F77], []) +dnl AC_DEFUN([AC_LIBTOOL_FC], []) +dnl AC_DEFUN([AC_LIBTOOL_GCJ], []) +dnl AC_DEFUN([AC_LIBTOOL_RC], []) + + +# _LT_TAG_COMPILER +# ---------------- +m4_defun([_LT_TAG_COMPILER], +[AC_REQUIRE([AC_PROG_CC])dnl + +_LT_DECL([LTCC], [CC], [1], [A C compiler])dnl +_LT_DECL([LTCFLAGS], [CFLAGS], [1], [LTCC compiler flags])dnl +_LT_TAGDECL([CC], [compiler], [1], [A language specific compiler])dnl +_LT_TAGDECL([with_gcc], [GCC], [0], [Is the compiler the GNU compiler?])dnl + +# If no C compiler was specified, use CC. +LTCC=${LTCC-"$CC"} + +# If no C compiler flags were specified, use CFLAGS. +LTCFLAGS=${LTCFLAGS-"$CFLAGS"} + +# Allow CC to be a program name with arguments. +compiler=$CC +])# _LT_TAG_COMPILER + + +# _LT_COMPILER_BOILERPLATE +# ------------------------ +# Check for compiler boilerplate output or warnings with +# the simple compiler test code. +m4_defun([_LT_COMPILER_BOILERPLATE], +[m4_require([_LT_DECL_SED])dnl +ac_outfile=conftest.$ac_objext +echo "$lt_simple_compile_test_code" >conftest.$ac_ext +eval "$ac_compile" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err +_lt_compiler_boilerplate=`cat conftest.err` +$RM conftest* +])# _LT_COMPILER_BOILERPLATE + + +# _LT_LINKER_BOILERPLATE +# ---------------------- +# Check for linker boilerplate output or warnings with +# the simple link test code. +m4_defun([_LT_LINKER_BOILERPLATE], +[m4_require([_LT_DECL_SED])dnl +ac_outfile=conftest.$ac_objext +echo "$lt_simple_link_test_code" >conftest.$ac_ext +eval "$ac_link" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err +_lt_linker_boilerplate=`cat conftest.err` +$RM -r conftest* +])# _LT_LINKER_BOILERPLATE + +# _LT_REQUIRED_DARWIN_CHECKS +# ------------------------- +m4_defun_once([_LT_REQUIRED_DARWIN_CHECKS],[ + case $host_os in + rhapsody* | darwin*) + AC_CHECK_TOOL([DSYMUTIL], [dsymutil], [:]) + AC_CHECK_TOOL([NMEDIT], [nmedit], [:]) + AC_CHECK_TOOL([LIPO], [lipo], [:]) + AC_CHECK_TOOL([OTOOL], [otool], [:]) + AC_CHECK_TOOL([OTOOL64], [otool64], [:]) + _LT_DECL([], [DSYMUTIL], [1], + [Tool to manipulate archived DWARF debug symbol files on Mac OS X]) + _LT_DECL([], [NMEDIT], [1], + [Tool to change global to local symbols on Mac OS X]) + _LT_DECL([], [LIPO], [1], + [Tool to manipulate fat objects and archives on Mac OS X]) + _LT_DECL([], [OTOOL], [1], + [ldd/readelf like tool for Mach-O binaries on Mac OS X]) + _LT_DECL([], [OTOOL64], [1], + [ldd/readelf like tool for 64 bit Mach-O binaries on Mac OS X 10.4]) + + AC_CACHE_CHECK([for -single_module linker flag],[lt_cv_apple_cc_single_mod], + [lt_cv_apple_cc_single_mod=no + if test -z "${LT_MULTI_MODULE}"; then + # By default we will add the -single_module flag. You can override + # by either setting the environment variable LT_MULTI_MODULE + # non-empty at configure time, or by adding -multi_module to the + # link flags. + rm -rf libconftest.dylib* + echo "int foo(void){return 1;}" > conftest.c + echo "$LTCC $LTCFLAGS $LDFLAGS -o libconftest.dylib \ +-dynamiclib -Wl,-single_module conftest.c" >&AS_MESSAGE_LOG_FD + $LTCC $LTCFLAGS $LDFLAGS -o libconftest.dylib \ + -dynamiclib -Wl,-single_module conftest.c 2>conftest.err + _lt_result=$? + # If there is a non-empty error log, and "single_module" + # appears in it, assume the flag caused a linker warning + if test -s conftest.err && $GREP single_module conftest.err; then + cat conftest.err >&AS_MESSAGE_LOG_FD + # Otherwise, if the output was created with a 0 exit code from + # the compiler, it worked. + elif test -f libconftest.dylib && test $_lt_result -eq 0; then + lt_cv_apple_cc_single_mod=yes + else + cat conftest.err >&AS_MESSAGE_LOG_FD + fi + rm -rf libconftest.dylib* + rm -f conftest.* + fi]) + + AC_CACHE_CHECK([for -exported_symbols_list linker flag], + [lt_cv_ld_exported_symbols_list], + [lt_cv_ld_exported_symbols_list=no + save_LDFLAGS=$LDFLAGS + echo "_main" > conftest.sym + LDFLAGS="$LDFLAGS -Wl,-exported_symbols_list,conftest.sym" + AC_LINK_IFELSE([AC_LANG_PROGRAM([],[])], + [lt_cv_ld_exported_symbols_list=yes], + [lt_cv_ld_exported_symbols_list=no]) + LDFLAGS="$save_LDFLAGS" + ]) + + AC_CACHE_CHECK([for -force_load linker flag],[lt_cv_ld_force_load], + [lt_cv_ld_force_load=no + cat > conftest.c << _LT_EOF +int forced_loaded() { return 2;} +_LT_EOF + echo "$LTCC $LTCFLAGS -c -o conftest.o conftest.c" >&AS_MESSAGE_LOG_FD + $LTCC $LTCFLAGS -c -o conftest.o conftest.c 2>&AS_MESSAGE_LOG_FD + echo "$AR cru libconftest.a conftest.o" >&AS_MESSAGE_LOG_FD + $AR cru libconftest.a conftest.o 2>&AS_MESSAGE_LOG_FD + echo "$RANLIB libconftest.a" >&AS_MESSAGE_LOG_FD + $RANLIB libconftest.a 2>&AS_MESSAGE_LOG_FD + cat > conftest.c << _LT_EOF +int main() { return 0;} +_LT_EOF + echo "$LTCC $LTCFLAGS $LDFLAGS -o conftest conftest.c -Wl,-force_load,./libconftest.a" >&AS_MESSAGE_LOG_FD + $LTCC $LTCFLAGS $LDFLAGS -o conftest conftest.c -Wl,-force_load,./libconftest.a 2>conftest.err + _lt_result=$? + if test -s conftest.err && $GREP force_load conftest.err; then + cat conftest.err >&AS_MESSAGE_LOG_FD + elif test -f conftest && test $_lt_result -eq 0 && $GREP forced_load conftest >/dev/null 2>&1 ; then + lt_cv_ld_force_load=yes + else + cat conftest.err >&AS_MESSAGE_LOG_FD + fi + rm -f conftest.err libconftest.a conftest conftest.c + rm -rf conftest.dSYM + ]) + case $host_os in + rhapsody* | darwin1.[[012]]) + _lt_dar_allow_undefined='${wl}-undefined ${wl}suppress' ;; + darwin1.*) + _lt_dar_allow_undefined='${wl}-flat_namespace ${wl}-undefined ${wl}suppress' ;; + darwin*) # darwin 5.x on + # if running on 10.5 or later, the deployment target defaults + # to the OS version, if on x86, and 10.4, the deployment + # target defaults to 10.4. Don't you love it? + case ${MACOSX_DEPLOYMENT_TARGET-10.0},$host in + 10.0,*86*-darwin8*|10.0,*-darwin[[91]]*) + _lt_dar_allow_undefined='${wl}-undefined ${wl}dynamic_lookup' ;; + 10.[[012]]*) + _lt_dar_allow_undefined='${wl}-flat_namespace ${wl}-undefined ${wl}suppress' ;; + 10.*) + _lt_dar_allow_undefined='${wl}-undefined ${wl}dynamic_lookup' ;; + esac + ;; + esac + if test "$lt_cv_apple_cc_single_mod" = "yes"; then + _lt_dar_single_mod='$single_module' + fi + if test "$lt_cv_ld_exported_symbols_list" = "yes"; then + _lt_dar_export_syms=' ${wl}-exported_symbols_list,$output_objdir/${libname}-symbols.expsym' + else + _lt_dar_export_syms='~$NMEDIT -s $output_objdir/${libname}-symbols.expsym ${lib}' + fi + if test "$DSYMUTIL" != ":" && test "$lt_cv_ld_force_load" = "no"; then + _lt_dsymutil='~$DSYMUTIL $lib || :' + else + _lt_dsymutil= + fi + ;; + esac +]) + + +# _LT_DARWIN_LINKER_FEATURES([TAG]) +# --------------------------------- +# Checks for linker and compiler features on darwin +m4_defun([_LT_DARWIN_LINKER_FEATURES], +[ + m4_require([_LT_REQUIRED_DARWIN_CHECKS]) + _LT_TAGVAR(archive_cmds_need_lc, $1)=no + _LT_TAGVAR(hardcode_direct, $1)=no + _LT_TAGVAR(hardcode_automatic, $1)=yes + _LT_TAGVAR(hardcode_shlibpath_var, $1)=unsupported + if test "$lt_cv_ld_force_load" = "yes"; then + _LT_TAGVAR(whole_archive_flag_spec, $1)='`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience ${wl}-force_load,$conv\"; done; func_echo_all \"$new_convenience\"`' + m4_case([$1], [F77], [_LT_TAGVAR(compiler_needs_object, $1)=yes], + [FC], [_LT_TAGVAR(compiler_needs_object, $1)=yes]) + else + _LT_TAGVAR(whole_archive_flag_spec, $1)='' + fi + _LT_TAGVAR(link_all_deplibs, $1)=yes + _LT_TAGVAR(allow_undefined_flag, $1)="$_lt_dar_allow_undefined" + case $cc_basename in + ifort*) _lt_dar_can_shared=yes ;; + *) _lt_dar_can_shared=$GCC ;; + esac + if test "$_lt_dar_can_shared" = "yes"; then + output_verbose_link_cmd=func_echo_all + _LT_TAGVAR(archive_cmds, $1)="\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring $_lt_dar_single_mod${_lt_dsymutil}" + _LT_TAGVAR(module_cmds, $1)="\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags${_lt_dsymutil}" + _LT_TAGVAR(archive_expsym_cmds, $1)="sed 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring ${_lt_dar_single_mod}${_lt_dar_export_syms}${_lt_dsymutil}" + _LT_TAGVAR(module_expsym_cmds, $1)="sed -e 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags${_lt_dar_export_syms}${_lt_dsymutil}" + m4_if([$1], [CXX], +[ if test "$lt_cv_apple_cc_single_mod" != "yes"; then + _LT_TAGVAR(archive_cmds, $1)="\$CC -r -keep_private_externs -nostdlib -o \${lib}-master.o \$libobjs~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \${lib}-master.o \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring${_lt_dsymutil}" + _LT_TAGVAR(archive_expsym_cmds, $1)="sed 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC -r -keep_private_externs -nostdlib -o \${lib}-master.o \$libobjs~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \${lib}-master.o \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring${_lt_dar_export_syms}${_lt_dsymutil}" + fi +],[]) + else + _LT_TAGVAR(ld_shlibs, $1)=no + fi +]) + +# _LT_SYS_MODULE_PATH_AIX([TAGNAME]) +# ---------------------------------- +# Links a minimal program and checks the executable +# for the system default hardcoded library path. In most cases, +# this is /usr/lib:/lib, but when the MPI compilers are used +# the location of the communication and MPI libs are included too. +# If we don't find anything, use the default library path according +# to the aix ld manual. +# Store the results from the different compilers for each TAGNAME. +# Allow to override them for all tags through lt_cv_aix_libpath. +m4_defun([_LT_SYS_MODULE_PATH_AIX], +[m4_require([_LT_DECL_SED])dnl +if test "${lt_cv_aix_libpath+set}" = set; then + aix_libpath=$lt_cv_aix_libpath +else + AC_CACHE_VAL([_LT_TAGVAR([lt_cv_aix_libpath_], [$1])], + [AC_LINK_IFELSE([AC_LANG_PROGRAM],[ + lt_aix_libpath_sed='[ + /Import File Strings/,/^$/ { + /^0/ { + s/^0 *\([^ ]*\) *$/\1/ + p + } + }]' + _LT_TAGVAR([lt_cv_aix_libpath_], [$1])=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"` + # Check for a 64-bit object if we didn't find anything. + if test -z "$_LT_TAGVAR([lt_cv_aix_libpath_], [$1])"; then + _LT_TAGVAR([lt_cv_aix_libpath_], [$1])=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"` + fi],[]) + if test -z "$_LT_TAGVAR([lt_cv_aix_libpath_], [$1])"; then + _LT_TAGVAR([lt_cv_aix_libpath_], [$1])="/usr/lib:/lib" + fi + ]) + aix_libpath=$_LT_TAGVAR([lt_cv_aix_libpath_], [$1]) +fi +])# _LT_SYS_MODULE_PATH_AIX + + +# _LT_SHELL_INIT(ARG) +# ------------------- +m4_define([_LT_SHELL_INIT], +[m4_divert_text([M4SH-INIT], [$1 +])])# _LT_SHELL_INIT + + + +# _LT_PROG_ECHO_BACKSLASH +# ----------------------- +# Find how we can fake an echo command that does not interpret backslash. +# In particular, with Autoconf 2.60 or later we add some code to the start +# of the generated configure script which will find a shell with a builtin +# printf (which we can use as an echo command). +m4_defun([_LT_PROG_ECHO_BACKSLASH], +[ECHO='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' +ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO +ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO$ECHO + +AC_MSG_CHECKING([how to print strings]) +# Test print first, because it will be a builtin if present. +if test "X`( print -r -- -n ) 2>/dev/null`" = X-n && \ + test "X`print -r -- $ECHO 2>/dev/null`" = "X$ECHO"; then + ECHO='print -r --' +elif test "X`printf %s $ECHO 2>/dev/null`" = "X$ECHO"; then + ECHO='printf %s\n' +else + # Use this function as a fallback that always works. + func_fallback_echo () + { + eval 'cat <<_LTECHO_EOF +$[]1 +_LTECHO_EOF' + } + ECHO='func_fallback_echo' +fi + +# func_echo_all arg... +# Invoke $ECHO with all args, space-separated. +func_echo_all () +{ + $ECHO "$*" +} + +case "$ECHO" in + printf*) AC_MSG_RESULT([printf]) ;; + print*) AC_MSG_RESULT([print -r]) ;; + *) AC_MSG_RESULT([cat]) ;; +esac + +m4_ifdef([_AS_DETECT_SUGGESTED], +[_AS_DETECT_SUGGESTED([ + test -n "${ZSH_VERSION+set}${BASH_VERSION+set}" || ( + ECHO='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' + ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO + ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO$ECHO + PATH=/empty FPATH=/empty; export PATH FPATH + test "X`printf %s $ECHO`" = "X$ECHO" \ + || test "X`print -r -- $ECHO`" = "X$ECHO" )])]) + +_LT_DECL([], [SHELL], [1], [Shell to use when invoking shell scripts]) +_LT_DECL([], [ECHO], [1], [An echo program that protects backslashes]) +])# _LT_PROG_ECHO_BACKSLASH + + +# _LT_WITH_SYSROOT +# ---------------- +AC_DEFUN([_LT_WITH_SYSROOT], +[AC_MSG_CHECKING([for sysroot]) +AC_ARG_WITH([sysroot], +[ --with-sysroot[=DIR] Search for dependent libraries within DIR + (or the compiler's sysroot if not specified).], +[], [with_sysroot=no]) + +dnl lt_sysroot will always be passed unquoted. We quote it here +dnl in case the user passed a directory name. +lt_sysroot= +case ${with_sysroot} in #( + yes) + if test "$GCC" = yes; then + lt_sysroot=`$CC --print-sysroot 2>/dev/null` + fi + ;; #( + /*) + lt_sysroot=`echo "$with_sysroot" | sed -e "$sed_quote_subst"` + ;; #( + no|'') + ;; #( + *) + AC_MSG_RESULT([${with_sysroot}]) + AC_MSG_ERROR([The sysroot must be an absolute path.]) + ;; +esac + + AC_MSG_RESULT([${lt_sysroot:-no}]) +_LT_DECL([], [lt_sysroot], [0], [The root where to search for ]dnl +[dependent libraries, and in which our libraries should be installed.])]) + +# _LT_ENABLE_LOCK +# --------------- +m4_defun([_LT_ENABLE_LOCK], +[AC_ARG_ENABLE([libtool-lock], + [AS_HELP_STRING([--disable-libtool-lock], + [avoid locking (might break parallel builds)])]) +test "x$enable_libtool_lock" != xno && enable_libtool_lock=yes + +# Some flags need to be propagated to the compiler or linker for good +# libtool support. +case $host in +ia64-*-hpux*) + # Find out which ABI we are using. + echo 'int i;' > conftest.$ac_ext + if AC_TRY_EVAL(ac_compile); then + case `/usr/bin/file conftest.$ac_objext` in + *ELF-32*) + HPUX_IA64_MODE="32" + ;; + *ELF-64*) + HPUX_IA64_MODE="64" + ;; + esac + fi + rm -rf conftest* + ;; +*-*-irix6*) + # Find out which ABI we are using. + echo '[#]line '$LINENO' "configure"' > conftest.$ac_ext + if AC_TRY_EVAL(ac_compile); then + if test "$lt_cv_prog_gnu_ld" = yes; then + case `/usr/bin/file conftest.$ac_objext` in + *32-bit*) + LD="${LD-ld} -melf32bsmip" + ;; + *N32*) + LD="${LD-ld} -melf32bmipn32" + ;; + *64-bit*) + LD="${LD-ld} -melf64bmip" + ;; + esac + else + case `/usr/bin/file conftest.$ac_objext` in + *32-bit*) + LD="${LD-ld} -32" + ;; + *N32*) + LD="${LD-ld} -n32" + ;; + *64-bit*) + LD="${LD-ld} -64" + ;; + esac + fi + fi + rm -rf conftest* + ;; + +x86_64-*kfreebsd*-gnu|x86_64-*linux*|ppc*-*linux*|powerpc*-*linux*| \ +s390*-*linux*|s390*-*tpf*|sparc*-*linux*) + # Find out which ABI we are using. + echo 'int i;' > conftest.$ac_ext + if AC_TRY_EVAL(ac_compile); then + case `/usr/bin/file conftest.o` in + *32-bit*) + case $host in + x86_64-*kfreebsd*-gnu) + LD="${LD-ld} -m elf_i386_fbsd" + ;; + x86_64-*linux*) + case `/usr/bin/file conftest.o` in + *x86-64*) + LD="${LD-ld} -m elf32_x86_64" + ;; + *) + LD="${LD-ld} -m elf_i386" + ;; + esac + ;; + ppc64-*linux*|powerpc64-*linux*) + LD="${LD-ld} -m elf32ppclinux" + ;; + s390x-*linux*) + LD="${LD-ld} -m elf_s390" + ;; + sparc64-*linux*) + LD="${LD-ld} -m elf32_sparc" + ;; + esac + ;; + *64-bit*) + case $host in + x86_64-*kfreebsd*-gnu) + LD="${LD-ld} -m elf_x86_64_fbsd" + ;; + x86_64-*linux*) + LD="${LD-ld} -m elf_x86_64" + ;; + ppc*-*linux*|powerpc*-*linux*) + LD="${LD-ld} -m elf64ppc" + ;; + s390*-*linux*|s390*-*tpf*) + LD="${LD-ld} -m elf64_s390" + ;; + sparc*-*linux*) + LD="${LD-ld} -m elf64_sparc" + ;; + esac + ;; + esac + fi + rm -rf conftest* + ;; + +*-*-sco3.2v5*) + # On SCO OpenServer 5, we need -belf to get full-featured binaries. + SAVE_CFLAGS="$CFLAGS" + CFLAGS="$CFLAGS -belf" + AC_CACHE_CHECK([whether the C compiler needs -belf], lt_cv_cc_needs_belf, + [AC_LANG_PUSH(C) + AC_LINK_IFELSE([AC_LANG_PROGRAM([[]],[[]])],[lt_cv_cc_needs_belf=yes],[lt_cv_cc_needs_belf=no]) + AC_LANG_POP]) + if test x"$lt_cv_cc_needs_belf" != x"yes"; then + # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf + CFLAGS="$SAVE_CFLAGS" + fi + ;; +*-*solaris*) + # Find out which ABI we are using. + echo 'int i;' > conftest.$ac_ext + if AC_TRY_EVAL(ac_compile); then + case `/usr/bin/file conftest.o` in + *64-bit*) + case $lt_cv_prog_gnu_ld in + yes*) + case $host in + i?86-*-solaris*) + LD="${LD-ld} -m elf_x86_64" + ;; + sparc*-*-solaris*) + LD="${LD-ld} -m elf64_sparc" + ;; + esac + # GNU ld 2.21 introduced _sol2 emulations. Use them if available. + if ${LD-ld} -V | grep _sol2 >/dev/null 2>&1; then + LD="${LD-ld}_sol2" + fi + ;; + *) + if ${LD-ld} -64 -r -o conftest2.o conftest.o >/dev/null 2>&1; then + LD="${LD-ld} -64" + fi + ;; + esac + ;; + esac + fi + rm -rf conftest* + ;; +esac + +need_locks="$enable_libtool_lock" +])# _LT_ENABLE_LOCK + + +# _LT_PROG_AR +# ----------- +m4_defun([_LT_PROG_AR], +[AC_CHECK_TOOLS(AR, [ar], false) +: ${AR=ar} +: ${AR_FLAGS=cru} +_LT_DECL([], [AR], [1], [The archiver]) +_LT_DECL([], [AR_FLAGS], [1], [Flags to create an archive]) + +AC_CACHE_CHECK([for archiver @FILE support], [lt_cv_ar_at_file], + [lt_cv_ar_at_file=no + AC_COMPILE_IFELSE([AC_LANG_PROGRAM], + [echo conftest.$ac_objext > conftest.lst + lt_ar_try='$AR $AR_FLAGS libconftest.a @conftest.lst >&AS_MESSAGE_LOG_FD' + AC_TRY_EVAL([lt_ar_try]) + if test "$ac_status" -eq 0; then + # Ensure the archiver fails upon bogus file names. + rm -f conftest.$ac_objext libconftest.a + AC_TRY_EVAL([lt_ar_try]) + if test "$ac_status" -ne 0; then + lt_cv_ar_at_file=@ + fi + fi + rm -f conftest.* libconftest.a + ]) + ]) + +if test "x$lt_cv_ar_at_file" = xno; then + archiver_list_spec= +else + archiver_list_spec=$lt_cv_ar_at_file +fi +_LT_DECL([], [archiver_list_spec], [1], + [How to feed a file listing to the archiver]) +])# _LT_PROG_AR + + +# _LT_CMD_OLD_ARCHIVE +# ------------------- +m4_defun([_LT_CMD_OLD_ARCHIVE], +[_LT_PROG_AR + +AC_CHECK_TOOL(STRIP, strip, :) +test -z "$STRIP" && STRIP=: +_LT_DECL([], [STRIP], [1], [A symbol stripping program]) + +AC_CHECK_TOOL(RANLIB, ranlib, :) +test -z "$RANLIB" && RANLIB=: +_LT_DECL([], [RANLIB], [1], + [Commands used to install an old-style archive]) + +# Determine commands to create old-style static archives. +old_archive_cmds='$AR $AR_FLAGS $oldlib$oldobjs' +old_postinstall_cmds='chmod 644 $oldlib' +old_postuninstall_cmds= + +if test -n "$RANLIB"; then + case $host_os in + openbsd*) + old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB -t \$tool_oldlib" + ;; + *) + old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB \$tool_oldlib" + ;; + esac + old_archive_cmds="$old_archive_cmds~\$RANLIB \$tool_oldlib" +fi + +case $host_os in + darwin*) + lock_old_archive_extraction=yes ;; + *) + lock_old_archive_extraction=no ;; +esac +_LT_DECL([], [old_postinstall_cmds], [2]) +_LT_DECL([], [old_postuninstall_cmds], [2]) +_LT_TAGDECL([], [old_archive_cmds], [2], + [Commands used to build an old-style archive]) +_LT_DECL([], [lock_old_archive_extraction], [0], + [Whether to use a lock for old archive extraction]) +])# _LT_CMD_OLD_ARCHIVE + + +# _LT_COMPILER_OPTION(MESSAGE, VARIABLE-NAME, FLAGS, +# [OUTPUT-FILE], [ACTION-SUCCESS], [ACTION-FAILURE]) +# ---------------------------------------------------------------- +# Check whether the given compiler option works +AC_DEFUN([_LT_COMPILER_OPTION], +[m4_require([_LT_FILEUTILS_DEFAULTS])dnl +m4_require([_LT_DECL_SED])dnl +AC_CACHE_CHECK([$1], [$2], + [$2=no + m4_if([$4], , [ac_outfile=conftest.$ac_objext], [ac_outfile=$4]) + echo "$lt_simple_compile_test_code" > conftest.$ac_ext + lt_compiler_flag="$3" + # Insert the option either (1) after the last *FLAGS variable, or + # (2) before a word containing "conftest.", or (3) at the end. + # Note that $ac_compile itself does not contain backslashes and begins + # with a dollar sign (not a hyphen), so the echo should work correctly. + # The option is referenced via a variable to avoid confusing sed. + lt_compile=`echo "$ac_compile" | $SED \ + -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \ + -e 's: [[^ ]]*conftest\.: $lt_compiler_flag&:; t' \ + -e 's:$: $lt_compiler_flag:'` + (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&AS_MESSAGE_LOG_FD) + (eval "$lt_compile" 2>conftest.err) + ac_status=$? + cat conftest.err >&AS_MESSAGE_LOG_FD + echo "$as_me:$LINENO: \$? = $ac_status" >&AS_MESSAGE_LOG_FD + if (exit $ac_status) && test -s "$ac_outfile"; then + # The compiler can only warn and ignore the option if not recognized + # So say no if there are warnings other than the usual output. + $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' >conftest.exp + $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2 + if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then + $2=yes + fi + fi + $RM conftest* +]) + +if test x"[$]$2" = xyes; then + m4_if([$5], , :, [$5]) +else + m4_if([$6], , :, [$6]) +fi +])# _LT_COMPILER_OPTION + +# Old name: +AU_ALIAS([AC_LIBTOOL_COMPILER_OPTION], [_LT_COMPILER_OPTION]) +dnl aclocal-1.4 backwards compatibility: +dnl AC_DEFUN([AC_LIBTOOL_COMPILER_OPTION], []) + + +# _LT_LINKER_OPTION(MESSAGE, VARIABLE-NAME, FLAGS, +# [ACTION-SUCCESS], [ACTION-FAILURE]) +# ---------------------------------------------------- +# Check whether the given linker option works +AC_DEFUN([_LT_LINKER_OPTION], +[m4_require([_LT_FILEUTILS_DEFAULTS])dnl +m4_require([_LT_DECL_SED])dnl +AC_CACHE_CHECK([$1], [$2], + [$2=no + save_LDFLAGS="$LDFLAGS" + LDFLAGS="$LDFLAGS $3" + echo "$lt_simple_link_test_code" > conftest.$ac_ext + if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then + # The linker can only warn and ignore the option if not recognized + # So say no if there are warnings + if test -s conftest.err; then + # Append any errors to the config.log. + cat conftest.err 1>&AS_MESSAGE_LOG_FD + $ECHO "$_lt_linker_boilerplate" | $SED '/^$/d' > conftest.exp + $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2 + if diff conftest.exp conftest.er2 >/dev/null; then + $2=yes + fi + else + $2=yes + fi + fi + $RM -r conftest* + LDFLAGS="$save_LDFLAGS" +]) + +if test x"[$]$2" = xyes; then + m4_if([$4], , :, [$4]) +else + m4_if([$5], , :, [$5]) +fi +])# _LT_LINKER_OPTION + +# Old name: +AU_ALIAS([AC_LIBTOOL_LINKER_OPTION], [_LT_LINKER_OPTION]) +dnl aclocal-1.4 backwards compatibility: +dnl AC_DEFUN([AC_LIBTOOL_LINKER_OPTION], []) + + +# LT_CMD_MAX_LEN +#--------------- +AC_DEFUN([LT_CMD_MAX_LEN], +[AC_REQUIRE([AC_CANONICAL_HOST])dnl +# find the maximum length of command line arguments +AC_MSG_CHECKING([the maximum length of command line arguments]) +AC_CACHE_VAL([lt_cv_sys_max_cmd_len], [dnl + i=0 + teststring="ABCD" + + case $build_os in + msdosdjgpp*) + # On DJGPP, this test can blow up pretty badly due to problems in libc + # (any single argument exceeding 2000 bytes causes a buffer overrun + # during glob expansion). Even if it were fixed, the result of this + # check would be larger than it should be. + lt_cv_sys_max_cmd_len=12288; # 12K is about right + ;; + + gnu*) + # Under GNU Hurd, this test is not required because there is + # no limit to the length of command line arguments. + # Libtool will interpret -1 as no limit whatsoever + lt_cv_sys_max_cmd_len=-1; + ;; + + cygwin* | mingw* | cegcc*) + # On Win9x/ME, this test blows up -- it succeeds, but takes + # about 5 minutes as the teststring grows exponentially. + # Worse, since 9x/ME are not pre-emptively multitasking, + # you end up with a "frozen" computer, even though with patience + # the test eventually succeeds (with a max line length of 256k). + # Instead, let's just punt: use the minimum linelength reported by + # all of the supported platforms: 8192 (on NT/2K/XP). + lt_cv_sys_max_cmd_len=8192; + ;; + + mint*) + # On MiNT this can take a long time and run out of memory. + lt_cv_sys_max_cmd_len=8192; + ;; + + amigaos*) + # On AmigaOS with pdksh, this test takes hours, literally. + # So we just punt and use a minimum line length of 8192. + lt_cv_sys_max_cmd_len=8192; + ;; + + netbsd* | freebsd* | openbsd* | darwin* | dragonfly*) + # This has been around since 386BSD, at least. Likely further. + if test -x /sbin/sysctl; then + lt_cv_sys_max_cmd_len=`/sbin/sysctl -n kern.argmax` + elif test -x /usr/sbin/sysctl; then + lt_cv_sys_max_cmd_len=`/usr/sbin/sysctl -n kern.argmax` + else + lt_cv_sys_max_cmd_len=65536 # usable default for all BSDs + fi + # And add a safety zone + lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4` + lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3` + ;; + + interix*) + # We know the value 262144 and hardcode it with a safety zone (like BSD) + lt_cv_sys_max_cmd_len=196608 + ;; + + os2*) + # The test takes a long time on OS/2. + lt_cv_sys_max_cmd_len=8192 + ;; + + osf*) + # Dr. Hans Ekkehard Plesser reports seeing a kernel panic running configure + # due to this test when exec_disable_arg_limit is 1 on Tru64. It is not + # nice to cause kernel panics so lets avoid the loop below. + # First set a reasonable default. + lt_cv_sys_max_cmd_len=16384 + # + if test -x /sbin/sysconfig; then + case `/sbin/sysconfig -q proc exec_disable_arg_limit` in + *1*) lt_cv_sys_max_cmd_len=-1 ;; + esac + fi + ;; + sco3.2v5*) + lt_cv_sys_max_cmd_len=102400 + ;; + sysv5* | sco5v6* | sysv4.2uw2*) + kargmax=`grep ARG_MAX /etc/conf/cf.d/stune 2>/dev/null` + if test -n "$kargmax"; then + lt_cv_sys_max_cmd_len=`echo $kargmax | sed 's/.*[[ ]]//'` + else + lt_cv_sys_max_cmd_len=32768 + fi + ;; + *) + lt_cv_sys_max_cmd_len=`(getconf ARG_MAX) 2> /dev/null` + if test -n "$lt_cv_sys_max_cmd_len" && \ + test undefined != "$lt_cv_sys_max_cmd_len"; then + lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4` + lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3` + else + # Make teststring a little bigger before we do anything with it. + # a 1K string should be a reasonable start. + for i in 1 2 3 4 5 6 7 8 ; do + teststring=$teststring$teststring + done + SHELL=${SHELL-${CONFIG_SHELL-/bin/sh}} + # If test is not a shell built-in, we'll probably end up computing a + # maximum length that is only half of the actual maximum length, but + # we can't tell. + while { test "X"`env echo "$teststring$teststring" 2>/dev/null` \ + = "X$teststring$teststring"; } >/dev/null 2>&1 && + test $i != 17 # 1/2 MB should be enough + do + i=`expr $i + 1` + teststring=$teststring$teststring + done + # Only check the string length outside the loop. + lt_cv_sys_max_cmd_len=`expr "X$teststring" : ".*" 2>&1` + teststring= + # Add a significant safety factor because C++ compilers can tack on + # massive amounts of additional arguments before passing them to the + # linker. It appears as though 1/2 is a usable value. + lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 2` + fi + ;; + esac +]) +if test -n $lt_cv_sys_max_cmd_len ; then + AC_MSG_RESULT($lt_cv_sys_max_cmd_len) +else + AC_MSG_RESULT(none) +fi +max_cmd_len=$lt_cv_sys_max_cmd_len +_LT_DECL([], [max_cmd_len], [0], + [What is the maximum length of a command?]) +])# LT_CMD_MAX_LEN + +# Old name: +AU_ALIAS([AC_LIBTOOL_SYS_MAX_CMD_LEN], [LT_CMD_MAX_LEN]) +dnl aclocal-1.4 backwards compatibility: +dnl AC_DEFUN([AC_LIBTOOL_SYS_MAX_CMD_LEN], []) + + +# _LT_HEADER_DLFCN +# ---------------- +m4_defun([_LT_HEADER_DLFCN], +[AC_CHECK_HEADERS([dlfcn.h], [], [], [AC_INCLUDES_DEFAULT])dnl +])# _LT_HEADER_DLFCN + + +# _LT_TRY_DLOPEN_SELF (ACTION-IF-TRUE, ACTION-IF-TRUE-W-USCORE, +# ACTION-IF-FALSE, ACTION-IF-CROSS-COMPILING) +# ---------------------------------------------------------------- +m4_defun([_LT_TRY_DLOPEN_SELF], +[m4_require([_LT_HEADER_DLFCN])dnl +if test "$cross_compiling" = yes; then : + [$4] +else + lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2 + lt_status=$lt_dlunknown + cat > conftest.$ac_ext <<_LT_EOF +[#line $LINENO "configure" +#include "confdefs.h" + +#if HAVE_DLFCN_H +#include +#endif + +#include + +#ifdef RTLD_GLOBAL +# define LT_DLGLOBAL RTLD_GLOBAL +#else +# ifdef DL_GLOBAL +# define LT_DLGLOBAL DL_GLOBAL +# else +# define LT_DLGLOBAL 0 +# endif +#endif + +/* We may have to define LT_DLLAZY_OR_NOW in the command line if we + find out it does not work in some platform. */ +#ifndef LT_DLLAZY_OR_NOW +# ifdef RTLD_LAZY +# define LT_DLLAZY_OR_NOW RTLD_LAZY +# else +# ifdef DL_LAZY +# define LT_DLLAZY_OR_NOW DL_LAZY +# else +# ifdef RTLD_NOW +# define LT_DLLAZY_OR_NOW RTLD_NOW +# else +# ifdef DL_NOW +# define LT_DLLAZY_OR_NOW DL_NOW +# else +# define LT_DLLAZY_OR_NOW 0 +# endif +# endif +# endif +# endif +#endif + +/* When -fvisbility=hidden is used, assume the code has been annotated + correspondingly for the symbols needed. */ +#if defined(__GNUC__) && (((__GNUC__ == 3) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 3)) +int fnord () __attribute__((visibility("default"))); +#endif + +int fnord () { return 42; } +int main () +{ + void *self = dlopen (0, LT_DLGLOBAL|LT_DLLAZY_OR_NOW); + int status = $lt_dlunknown; + + if (self) + { + if (dlsym (self,"fnord")) status = $lt_dlno_uscore; + else + { + if (dlsym( self,"_fnord")) status = $lt_dlneed_uscore; + else puts (dlerror ()); + } + /* dlclose (self); */ + } + else + puts (dlerror ()); + + return status; +}] +_LT_EOF + if AC_TRY_EVAL(ac_link) && test -s conftest${ac_exeext} 2>/dev/null; then + (./conftest; exit; ) >&AS_MESSAGE_LOG_FD 2>/dev/null + lt_status=$? + case x$lt_status in + x$lt_dlno_uscore) $1 ;; + x$lt_dlneed_uscore) $2 ;; + x$lt_dlunknown|x*) $3 ;; + esac + else : + # compilation failed + $3 + fi +fi +rm -fr conftest* +])# _LT_TRY_DLOPEN_SELF + + +# LT_SYS_DLOPEN_SELF +# ------------------ +AC_DEFUN([LT_SYS_DLOPEN_SELF], +[m4_require([_LT_HEADER_DLFCN])dnl +if test "x$enable_dlopen" != xyes; then + enable_dlopen=unknown + enable_dlopen_self=unknown + enable_dlopen_self_static=unknown +else + lt_cv_dlopen=no + lt_cv_dlopen_libs= + + case $host_os in + beos*) + lt_cv_dlopen="load_add_on" + lt_cv_dlopen_libs= + lt_cv_dlopen_self=yes + ;; + + mingw* | pw32* | cegcc*) + lt_cv_dlopen="LoadLibrary" + lt_cv_dlopen_libs= + ;; + + cygwin*) + lt_cv_dlopen="dlopen" + lt_cv_dlopen_libs= + ;; + + darwin*) + # if libdl is installed we need to link against it + AC_CHECK_LIB([dl], [dlopen], + [lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl"],[ + lt_cv_dlopen="dyld" + lt_cv_dlopen_libs= + lt_cv_dlopen_self=yes + ]) + ;; + + *) + AC_CHECK_FUNC([shl_load], + [lt_cv_dlopen="shl_load"], + [AC_CHECK_LIB([dld], [shl_load], + [lt_cv_dlopen="shl_load" lt_cv_dlopen_libs="-ldld"], + [AC_CHECK_FUNC([dlopen], + [lt_cv_dlopen="dlopen"], + [AC_CHECK_LIB([dl], [dlopen], + [lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl"], + [AC_CHECK_LIB([svld], [dlopen], + [lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-lsvld"], + [AC_CHECK_LIB([dld], [dld_link], + [lt_cv_dlopen="dld_link" lt_cv_dlopen_libs="-ldld"]) + ]) + ]) + ]) + ]) + ]) + ;; + esac + + if test "x$lt_cv_dlopen" != xno; then + enable_dlopen=yes + else + enable_dlopen=no + fi + + case $lt_cv_dlopen in + dlopen) + save_CPPFLAGS="$CPPFLAGS" + test "x$ac_cv_header_dlfcn_h" = xyes && CPPFLAGS="$CPPFLAGS -DHAVE_DLFCN_H" + + save_LDFLAGS="$LDFLAGS" + wl=$lt_prog_compiler_wl eval LDFLAGS=\"\$LDFLAGS $export_dynamic_flag_spec\" + + save_LIBS="$LIBS" + LIBS="$lt_cv_dlopen_libs $LIBS" + + AC_CACHE_CHECK([whether a program can dlopen itself], + lt_cv_dlopen_self, [dnl + _LT_TRY_DLOPEN_SELF( + lt_cv_dlopen_self=yes, lt_cv_dlopen_self=yes, + lt_cv_dlopen_self=no, lt_cv_dlopen_self=cross) + ]) + + if test "x$lt_cv_dlopen_self" = xyes; then + wl=$lt_prog_compiler_wl eval LDFLAGS=\"\$LDFLAGS $lt_prog_compiler_static\" + AC_CACHE_CHECK([whether a statically linked program can dlopen itself], + lt_cv_dlopen_self_static, [dnl + _LT_TRY_DLOPEN_SELF( + lt_cv_dlopen_self_static=yes, lt_cv_dlopen_self_static=yes, + lt_cv_dlopen_self_static=no, lt_cv_dlopen_self_static=cross) + ]) + fi + + CPPFLAGS="$save_CPPFLAGS" + LDFLAGS="$save_LDFLAGS" + LIBS="$save_LIBS" + ;; + esac + + case $lt_cv_dlopen_self in + yes|no) enable_dlopen_self=$lt_cv_dlopen_self ;; + *) enable_dlopen_self=unknown ;; + esac + + case $lt_cv_dlopen_self_static in + yes|no) enable_dlopen_self_static=$lt_cv_dlopen_self_static ;; + *) enable_dlopen_self_static=unknown ;; + esac +fi +_LT_DECL([dlopen_support], [enable_dlopen], [0], + [Whether dlopen is supported]) +_LT_DECL([dlopen_self], [enable_dlopen_self], [0], + [Whether dlopen of programs is supported]) +_LT_DECL([dlopen_self_static], [enable_dlopen_self_static], [0], + [Whether dlopen of statically linked programs is supported]) +])# LT_SYS_DLOPEN_SELF + +# Old name: +AU_ALIAS([AC_LIBTOOL_DLOPEN_SELF], [LT_SYS_DLOPEN_SELF]) +dnl aclocal-1.4 backwards compatibility: +dnl AC_DEFUN([AC_LIBTOOL_DLOPEN_SELF], []) + + +# _LT_COMPILER_C_O([TAGNAME]) +# --------------------------- +# Check to see if options -c and -o are simultaneously supported by compiler. +# This macro does not hard code the compiler like AC_PROG_CC_C_O. +m4_defun([_LT_COMPILER_C_O], +[m4_require([_LT_DECL_SED])dnl +m4_require([_LT_FILEUTILS_DEFAULTS])dnl +m4_require([_LT_TAG_COMPILER])dnl +AC_CACHE_CHECK([if $compiler supports -c -o file.$ac_objext], + [_LT_TAGVAR(lt_cv_prog_compiler_c_o, $1)], + [_LT_TAGVAR(lt_cv_prog_compiler_c_o, $1)=no + $RM -r conftest 2>/dev/null + mkdir conftest + cd conftest + mkdir out + echo "$lt_simple_compile_test_code" > conftest.$ac_ext + + lt_compiler_flag="-o out/conftest2.$ac_objext" + # Insert the option either (1) after the last *FLAGS variable, or + # (2) before a word containing "conftest.", or (3) at the end. + # Note that $ac_compile itself does not contain backslashes and begins + # with a dollar sign (not a hyphen), so the echo should work correctly. + lt_compile=`echo "$ac_compile" | $SED \ + -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \ + -e 's: [[^ ]]*conftest\.: $lt_compiler_flag&:; t' \ + -e 's:$: $lt_compiler_flag:'` + (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&AS_MESSAGE_LOG_FD) + (eval "$lt_compile" 2>out/conftest.err) + ac_status=$? + cat out/conftest.err >&AS_MESSAGE_LOG_FD + echo "$as_me:$LINENO: \$? = $ac_status" >&AS_MESSAGE_LOG_FD + if (exit $ac_status) && test -s out/conftest2.$ac_objext + then + # The compiler can only warn and ignore the option if not recognized + # So say no if there are warnings + $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' > out/conftest.exp + $SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2 + if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then + _LT_TAGVAR(lt_cv_prog_compiler_c_o, $1)=yes + fi + fi + chmod u+w . 2>&AS_MESSAGE_LOG_FD + $RM conftest* + # SGI C++ compiler will create directory out/ii_files/ for + # template instantiation + test -d out/ii_files && $RM out/ii_files/* && rmdir out/ii_files + $RM out/* && rmdir out + cd .. + $RM -r conftest + $RM conftest* +]) +_LT_TAGDECL([compiler_c_o], [lt_cv_prog_compiler_c_o], [1], + [Does compiler simultaneously support -c and -o options?]) +])# _LT_COMPILER_C_O + + +# _LT_COMPILER_FILE_LOCKS([TAGNAME]) +# ---------------------------------- +# Check to see if we can do hard links to lock some files if needed +m4_defun([_LT_COMPILER_FILE_LOCKS], +[m4_require([_LT_ENABLE_LOCK])dnl +m4_require([_LT_FILEUTILS_DEFAULTS])dnl +_LT_COMPILER_C_O([$1]) + +hard_links="nottested" +if test "$_LT_TAGVAR(lt_cv_prog_compiler_c_o, $1)" = no && test "$need_locks" != no; then + # do not overwrite the value of need_locks provided by the user + AC_MSG_CHECKING([if we can lock with hard links]) + hard_links=yes + $RM conftest* + ln conftest.a conftest.b 2>/dev/null && hard_links=no + touch conftest.a + ln conftest.a conftest.b 2>&5 || hard_links=no + ln conftest.a conftest.b 2>/dev/null && hard_links=no + AC_MSG_RESULT([$hard_links]) + if test "$hard_links" = no; then + AC_MSG_WARN([`$CC' does not support `-c -o', so `make -j' may be unsafe]) + need_locks=warn + fi +else + need_locks=no +fi +_LT_DECL([], [need_locks], [1], [Must we lock files when doing compilation?]) +])# _LT_COMPILER_FILE_LOCKS + + +# _LT_CHECK_OBJDIR +# ---------------- +m4_defun([_LT_CHECK_OBJDIR], +[AC_CACHE_CHECK([for objdir], [lt_cv_objdir], +[rm -f .libs 2>/dev/null +mkdir .libs 2>/dev/null +if test -d .libs; then + lt_cv_objdir=.libs +else + # MS-DOS does not allow filenames that begin with a dot. + lt_cv_objdir=_libs +fi +rmdir .libs 2>/dev/null]) +objdir=$lt_cv_objdir +_LT_DECL([], [objdir], [0], + [The name of the directory that contains temporary libtool files])dnl +m4_pattern_allow([LT_OBJDIR])dnl +AC_DEFINE_UNQUOTED(LT_OBJDIR, "$lt_cv_objdir/", + [Define to the sub-directory in which libtool stores uninstalled libraries.]) +])# _LT_CHECK_OBJDIR + + +# _LT_LINKER_HARDCODE_LIBPATH([TAGNAME]) +# -------------------------------------- +# Check hardcoding attributes. +m4_defun([_LT_LINKER_HARDCODE_LIBPATH], +[AC_MSG_CHECKING([how to hardcode library paths into programs]) +_LT_TAGVAR(hardcode_action, $1)= +if test -n "$_LT_TAGVAR(hardcode_libdir_flag_spec, $1)" || + test -n "$_LT_TAGVAR(runpath_var, $1)" || + test "X$_LT_TAGVAR(hardcode_automatic, $1)" = "Xyes" ; then + + # We can hardcode non-existent directories. + if test "$_LT_TAGVAR(hardcode_direct, $1)" != no && + # If the only mechanism to avoid hardcoding is shlibpath_var, we + # have to relink, otherwise we might link with an installed library + # when we should be linking with a yet-to-be-installed one + ## test "$_LT_TAGVAR(hardcode_shlibpath_var, $1)" != no && + test "$_LT_TAGVAR(hardcode_minus_L, $1)" != no; then + # Linking always hardcodes the temporary library directory. + _LT_TAGVAR(hardcode_action, $1)=relink + else + # We can link without hardcoding, and we can hardcode nonexisting dirs. + _LT_TAGVAR(hardcode_action, $1)=immediate + fi +else + # We cannot hardcode anything, or else we can only hardcode existing + # directories. + _LT_TAGVAR(hardcode_action, $1)=unsupported +fi +AC_MSG_RESULT([$_LT_TAGVAR(hardcode_action, $1)]) + +if test "$_LT_TAGVAR(hardcode_action, $1)" = relink || + test "$_LT_TAGVAR(inherit_rpath, $1)" = yes; then + # Fast installation is not supported + enable_fast_install=no +elif test "$shlibpath_overrides_runpath" = yes || + test "$enable_shared" = no; then + # Fast installation is not necessary + enable_fast_install=needless +fi +_LT_TAGDECL([], [hardcode_action], [0], + [How to hardcode a shared library path into an executable]) +])# _LT_LINKER_HARDCODE_LIBPATH + + +# _LT_CMD_STRIPLIB +# ---------------- +m4_defun([_LT_CMD_STRIPLIB], +[m4_require([_LT_DECL_EGREP]) +striplib= +old_striplib= +AC_MSG_CHECKING([whether stripping libraries is possible]) +if test -n "$STRIP" && $STRIP -V 2>&1 | $GREP "GNU strip" >/dev/null; then + test -z "$old_striplib" && old_striplib="$STRIP --strip-debug" + test -z "$striplib" && striplib="$STRIP --strip-unneeded" + AC_MSG_RESULT([yes]) +else +# FIXME - insert some real tests, host_os isn't really good enough + case $host_os in + darwin*) + if test -n "$STRIP" ; then + striplib="$STRIP -x" + old_striplib="$STRIP -S" + AC_MSG_RESULT([yes]) + else + AC_MSG_RESULT([no]) + fi + ;; + *) + AC_MSG_RESULT([no]) + ;; + esac +fi +_LT_DECL([], [old_striplib], [1], [Commands to strip libraries]) +_LT_DECL([], [striplib], [1]) +])# _LT_CMD_STRIPLIB + + +# _LT_SYS_DYNAMIC_LINKER([TAG]) +# ----------------------------- +# PORTME Fill in your ld.so characteristics +m4_defun([_LT_SYS_DYNAMIC_LINKER], +[AC_REQUIRE([AC_CANONICAL_HOST])dnl +m4_require([_LT_DECL_EGREP])dnl +m4_require([_LT_FILEUTILS_DEFAULTS])dnl +m4_require([_LT_DECL_OBJDUMP])dnl +m4_require([_LT_DECL_SED])dnl +m4_require([_LT_CHECK_SHELL_FEATURES])dnl +AC_MSG_CHECKING([dynamic linker characteristics]) +m4_if([$1], + [], [ +if test "$GCC" = yes; then + case $host_os in + darwin*) lt_awk_arg="/^libraries:/,/LR/" ;; + *) lt_awk_arg="/^libraries:/" ;; + esac + case $host_os in + mingw* | cegcc*) lt_sed_strip_eq="s,=\([[A-Za-z]]:\),\1,g" ;; + *) lt_sed_strip_eq="s,=/,/,g" ;; + esac + lt_search_path_spec=`$CC -print-search-dirs | awk $lt_awk_arg | $SED -e "s/^libraries://" -e $lt_sed_strip_eq` + case $lt_search_path_spec in + *\;*) + # if the path contains ";" then we assume it to be the separator + # otherwise default to the standard path separator (i.e. ":") - it is + # assumed that no part of a normal pathname contains ";" but that should + # okay in the real world where ";" in dirpaths is itself problematic. + lt_search_path_spec=`$ECHO "$lt_search_path_spec" | $SED 's/;/ /g'` + ;; + *) + lt_search_path_spec=`$ECHO "$lt_search_path_spec" | $SED "s/$PATH_SEPARATOR/ /g"` + ;; + esac + # Ok, now we have the path, separated by spaces, we can step through it + # and add multilib dir if necessary. + lt_tmp_lt_search_path_spec= + lt_multi_os_dir=`$CC $CPPFLAGS $CFLAGS $LDFLAGS -print-multi-os-directory 2>/dev/null` + for lt_sys_path in $lt_search_path_spec; do + if test -d "$lt_sys_path/$lt_multi_os_dir"; then + lt_tmp_lt_search_path_spec="$lt_tmp_lt_search_path_spec $lt_sys_path/$lt_multi_os_dir" + else + test -d "$lt_sys_path" && \ + lt_tmp_lt_search_path_spec="$lt_tmp_lt_search_path_spec $lt_sys_path" + fi + done + lt_search_path_spec=`$ECHO "$lt_tmp_lt_search_path_spec" | awk ' +BEGIN {RS=" "; FS="/|\n";} { + lt_foo=""; + lt_count=0; + for (lt_i = NF; lt_i > 0; lt_i--) { + if ($lt_i != "" && $lt_i != ".") { + if ($lt_i == "..") { + lt_count++; + } else { + if (lt_count == 0) { + lt_foo="/" $lt_i lt_foo; + } else { + lt_count--; + } + } + } + } + if (lt_foo != "") { lt_freq[[lt_foo]]++; } + if (lt_freq[[lt_foo]] == 1) { print lt_foo; } +}'` + # AWK program above erroneously prepends '/' to C:/dos/paths + # for these hosts. + case $host_os in + mingw* | cegcc*) lt_search_path_spec=`$ECHO "$lt_search_path_spec" |\ + $SED 's,/\([[A-Za-z]]:\),\1,g'` ;; + esac + sys_lib_search_path_spec=`$ECHO "$lt_search_path_spec" | $lt_NL2SP` +else + sys_lib_search_path_spec="/lib /usr/lib /usr/local/lib" +fi]) +library_names_spec= +libname_spec='lib$name' +soname_spec= +shrext_cmds=".so" +postinstall_cmds= +postuninstall_cmds= +finish_cmds= +finish_eval= +shlibpath_var= +shlibpath_overrides_runpath=unknown +version_type=none +dynamic_linker="$host_os ld.so" +sys_lib_dlsearch_path_spec="/lib /usr/lib" +need_lib_prefix=unknown +hardcode_into_libs=no + +# when you set need_version to no, make sure it does not cause -set_version +# flags to be left without arguments +need_version=unknown + +case $host_os in +aix3*) + version_type=linux # correct to gnu/linux during the next big refactor + library_names_spec='${libname}${release}${shared_ext}$versuffix $libname.a' + shlibpath_var=LIBPATH + + # AIX 3 has no versioning support, so we append a major version to the name. + soname_spec='${libname}${release}${shared_ext}$major' + ;; + +aix[[4-9]]*) + version_type=linux # correct to gnu/linux during the next big refactor + need_lib_prefix=no + need_version=no + hardcode_into_libs=yes + if test "$host_cpu" = ia64; then + # AIX 5 supports IA64 + library_names_spec='${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext}$versuffix $libname${shared_ext}' + shlibpath_var=LD_LIBRARY_PATH + else + # With GCC up to 2.95.x, collect2 would create an import file + # for dependence libraries. The import file would start with + # the line `#! .'. This would cause the generated library to + # depend on `.', always an invalid library. This was fixed in + # development snapshots of GCC prior to 3.0. + case $host_os in + aix4 | aix4.[[01]] | aix4.[[01]].*) + if { echo '#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 97)' + echo ' yes ' + echo '#endif'; } | ${CC} -E - | $GREP yes > /dev/null; then + : + else + can_build_shared=no + fi + ;; + esac + # AIX (on Power*) has no versioning support, so currently we can not hardcode correct + # soname into executable. Probably we can add versioning support to + # collect2, so additional links can be useful in future. + if test "$aix_use_runtimelinking" = yes; then + # If using run time linking (on AIX 4.2 or later) use lib.so + # instead of lib.a to let people know that these are not + # typical AIX shared libraries. + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + else + # We preserve .a as extension for shared libraries through AIX4.2 + # and later when we are not doing run time linking. + library_names_spec='${libname}${release}.a $libname.a' + soname_spec='${libname}${release}${shared_ext}$major' + fi + shlibpath_var=LIBPATH + fi + ;; + +amigaos*) + case $host_cpu in + powerpc) + # Since July 2007 AmigaOS4 officially supports .so libraries. + # When compiling the executable, add -use-dynld -Lsobjs: to the compileline. + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + ;; + m68k) + library_names_spec='$libname.ixlibrary $libname.a' + # Create ${libname}_ixlibrary.a entries in /sys/libs. + finish_eval='for lib in `ls $libdir/*.ixlibrary 2>/dev/null`; do libname=`func_echo_all "$lib" | $SED '\''s%^.*/\([[^/]]*\)\.ixlibrary$%\1%'\''`; test $RM /sys/libs/${libname}_ixlibrary.a; $show "cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a"; cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a || exit 1; done' + ;; + esac + ;; + +beos*) + library_names_spec='${libname}${shared_ext}' + dynamic_linker="$host_os ld.so" + shlibpath_var=LIBRARY_PATH + ;; + +bsdi[[45]]*) + version_type=linux # correct to gnu/linux during the next big refactor + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + finish_cmds='PATH="\$PATH:/sbin" ldconfig $libdir' + shlibpath_var=LD_LIBRARY_PATH + sys_lib_search_path_spec="/shlib /usr/lib /usr/X11/lib /usr/contrib/lib /lib /usr/local/lib" + sys_lib_dlsearch_path_spec="/shlib /usr/lib /usr/local/lib" + # the default ld.so.conf also contains /usr/contrib/lib and + # /usr/X11R6/lib (/usr/X11 is a link to /usr/X11R6), but let us allow + # libtool to hard-code these into programs + ;; + +cygwin* | mingw* | pw32* | cegcc*) + version_type=windows + shrext_cmds=".dll" + need_version=no + need_lib_prefix=no + + case $GCC,$cc_basename in + yes,*) + # gcc + library_names_spec='$libname.dll.a' + # DLL is installed to $(libdir)/../bin by postinstall_cmds + postinstall_cmds='base_file=`basename \${file}`~ + dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i; echo \$dlname'\''`~ + dldir=$destdir/`dirname \$dlpath`~ + test -d \$dldir || mkdir -p \$dldir~ + $install_prog $dir/$dlname \$dldir/$dlname~ + chmod a+x \$dldir/$dlname~ + if test -n '\''$stripme'\'' && test -n '\''$striplib'\''; then + eval '\''$striplib \$dldir/$dlname'\'' || exit \$?; + fi' + postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~ + dlpath=$dir/\$dldll~ + $RM \$dlpath' + shlibpath_overrides_runpath=yes + + case $host_os in + cygwin*) + # Cygwin DLLs use 'cyg' prefix rather than 'lib' + soname_spec='`echo ${libname} | sed -e 's/^lib/cyg/'``echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext}' +m4_if([$1], [],[ + sys_lib_search_path_spec="$sys_lib_search_path_spec /usr/lib/w32api"]) + ;; + mingw* | cegcc*) + # MinGW DLLs use traditional 'lib' prefix + soname_spec='${libname}`echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext}' + ;; + pw32*) + # pw32 DLLs use 'pw' prefix rather than 'lib' + library_names_spec='`echo ${libname} | sed -e 's/^lib/pw/'``echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext}' + ;; + esac + dynamic_linker='Win32 ld.exe' + ;; + + *,cl*) + # Native MSVC + libname_spec='$name' + soname_spec='${libname}`echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext}' + library_names_spec='${libname}.dll.lib' + + case $build_os in + mingw*) + sys_lib_search_path_spec= + lt_save_ifs=$IFS + IFS=';' + for lt_path in $LIB + do + IFS=$lt_save_ifs + # Let DOS variable expansion print the short 8.3 style file name. + lt_path=`cd "$lt_path" 2>/dev/null && cmd //C "for %i in (".") do @echo %~si"` + sys_lib_search_path_spec="$sys_lib_search_path_spec $lt_path" + done + IFS=$lt_save_ifs + # Convert to MSYS style. + sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | sed -e 's|\\\\|/|g' -e 's| \\([[a-zA-Z]]\\):| /\\1|g' -e 's|^ ||'` + ;; + cygwin*) + # Convert to unix form, then to dos form, then back to unix form + # but this time dos style (no spaces!) so that the unix form looks + # like /cygdrive/c/PROGRA~1:/cygdr... + sys_lib_search_path_spec=`cygpath --path --unix "$LIB"` + sys_lib_search_path_spec=`cygpath --path --dos "$sys_lib_search_path_spec" 2>/dev/null` + sys_lib_search_path_spec=`cygpath --path --unix "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"` + ;; + *) + sys_lib_search_path_spec="$LIB" + if $ECHO "$sys_lib_search_path_spec" | [$GREP ';[c-zC-Z]:/' >/dev/null]; then + # It is most probably a Windows format PATH. + sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'` + else + sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"` + fi + # FIXME: find the short name or the path components, as spaces are + # common. (e.g. "Program Files" -> "PROGRA~1") + ;; + esac + + # DLL is installed to $(libdir)/../bin by postinstall_cmds + postinstall_cmds='base_file=`basename \${file}`~ + dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i; echo \$dlname'\''`~ + dldir=$destdir/`dirname \$dlpath`~ + test -d \$dldir || mkdir -p \$dldir~ + $install_prog $dir/$dlname \$dldir/$dlname' + postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~ + dlpath=$dir/\$dldll~ + $RM \$dlpath' + shlibpath_overrides_runpath=yes + dynamic_linker='Win32 link.exe' + ;; + + *) + # Assume MSVC wrapper + library_names_spec='${libname}`echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext} $libname.lib' + dynamic_linker='Win32 ld.exe' + ;; + esac + # FIXME: first we should search . and the directory the executable is in + shlibpath_var=PATH + ;; + +darwin* | rhapsody*) + dynamic_linker="$host_os dyld" + version_type=darwin + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${major}$shared_ext ${libname}$shared_ext' + soname_spec='${libname}${release}${major}$shared_ext' + shlibpath_overrides_runpath=yes + shlibpath_var=DYLD_LIBRARY_PATH + shrext_cmds='`test .$module = .yes && echo .so || echo .dylib`' +m4_if([$1], [],[ + sys_lib_search_path_spec="$sys_lib_search_path_spec /usr/local/lib"]) + sys_lib_dlsearch_path_spec='/usr/local/lib /lib /usr/lib' + ;; + +dgux*) + version_type=linux # correct to gnu/linux during the next big refactor + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname$shared_ext' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + ;; + +freebsd* | dragonfly*) + # DragonFly does not have aout. When/if they implement a new + # versioning mechanism, adjust this. + if test -x /usr/bin/objformat; then + objformat=`/usr/bin/objformat` + else + case $host_os in + freebsd[[23]].*) objformat=aout ;; + *) objformat=elf ;; + esac + fi + version_type=freebsd-$objformat + case $version_type in + freebsd-elf*) + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}' + need_version=no + need_lib_prefix=no + ;; + freebsd-*) + library_names_spec='${libname}${release}${shared_ext}$versuffix $libname${shared_ext}$versuffix' + need_version=yes + ;; + esac + shlibpath_var=LD_LIBRARY_PATH + case $host_os in + freebsd2.*) + shlibpath_overrides_runpath=yes + ;; + freebsd3.[[01]]* | freebsdelf3.[[01]]*) + shlibpath_overrides_runpath=yes + hardcode_into_libs=yes + ;; + freebsd3.[[2-9]]* | freebsdelf3.[[2-9]]* | \ + freebsd4.[[0-5]] | freebsdelf4.[[0-5]] | freebsd4.1.1 | freebsdelf4.1.1) + shlibpath_overrides_runpath=no + hardcode_into_libs=yes + ;; + *) # from 4.6 on, and DragonFly + shlibpath_overrides_runpath=yes + hardcode_into_libs=yes + ;; + esac + ;; + +haiku*) + version_type=linux # correct to gnu/linux during the next big refactor + need_lib_prefix=no + need_version=no + dynamic_linker="$host_os runtime_loader" + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}${major} ${libname}${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LIBRARY_PATH + shlibpath_overrides_runpath=yes + sys_lib_dlsearch_path_spec='/boot/home/config/lib /boot/common/lib /boot/system/lib' + hardcode_into_libs=yes + ;; + +hpux9* | hpux10* | hpux11*) + # Give a soname corresponding to the major version so that dld.sl refuses to + # link against other versions. + version_type=sunos + need_lib_prefix=no + need_version=no + case $host_cpu in + ia64*) + shrext_cmds='.so' + hardcode_into_libs=yes + dynamic_linker="$host_os dld.so" + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes # Unless +noenvvar is specified. + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + if test "X$HPUX_IA64_MODE" = X32; then + sys_lib_search_path_spec="/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib" + else + sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64" + fi + sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec + ;; + hppa*64*) + shrext_cmds='.sl' + hardcode_into_libs=yes + dynamic_linker="$host_os dld.sl" + shlibpath_var=LD_LIBRARY_PATH # How should we handle SHLIB_PATH + shlibpath_overrides_runpath=yes # Unless +noenvvar is specified. + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + sys_lib_search_path_spec="/usr/lib/pa20_64 /usr/ccs/lib/pa20_64" + sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec + ;; + *) + shrext_cmds='.sl' + dynamic_linker="$host_os dld.sl" + shlibpath_var=SHLIB_PATH + shlibpath_overrides_runpath=no # +s is required to enable SHLIB_PATH + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + ;; + esac + # HP-UX runs *really* slowly unless shared libraries are mode 555, ... + postinstall_cmds='chmod 555 $lib' + # or fails outright, so override atomically: + install_override_mode=555 + ;; + +interix[[3-9]]*) + version_type=linux # correct to gnu/linux during the next big refactor + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + dynamic_linker='Interix 3.x ld.so.1 (PE, like ELF)' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + hardcode_into_libs=yes + ;; + +irix5* | irix6* | nonstopux*) + case $host_os in + nonstopux*) version_type=nonstopux ;; + *) + if test "$lt_cv_prog_gnu_ld" = yes; then + version_type=linux # correct to gnu/linux during the next big refactor + else + version_type=irix + fi ;; + esac + need_lib_prefix=no + need_version=no + soname_spec='${libname}${release}${shared_ext}$major' + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext} $libname${shared_ext}' + case $host_os in + irix5* | nonstopux*) + libsuff= shlibsuff= + ;; + *) + case $LD in # libtool.m4 will add one of these switches to LD + *-32|*"-32 "|*-melf32bsmip|*"-melf32bsmip ") + libsuff= shlibsuff= libmagic=32-bit;; + *-n32|*"-n32 "|*-melf32bmipn32|*"-melf32bmipn32 ") + libsuff=32 shlibsuff=N32 libmagic=N32;; + *-64|*"-64 "|*-melf64bmip|*"-melf64bmip ") + libsuff=64 shlibsuff=64 libmagic=64-bit;; + *) libsuff= shlibsuff= libmagic=never-match;; + esac + ;; + esac + shlibpath_var=LD_LIBRARY${shlibsuff}_PATH + shlibpath_overrides_runpath=no + sys_lib_search_path_spec="/usr/lib${libsuff} /lib${libsuff} /usr/local/lib${libsuff}" + sys_lib_dlsearch_path_spec="/usr/lib${libsuff} /lib${libsuff}" + hardcode_into_libs=yes + ;; + +# No shared lib support for Linux oldld, aout, or coff. +linux*oldld* | linux*aout* | linux*coff*) + dynamic_linker=no + ;; + +# This must be glibc/ELF. +linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*) + version_type=linux # correct to gnu/linux during the next big refactor + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + finish_cmds='PATH="\$PATH:/sbin" ldconfig -n $libdir' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + + # Some binutils ld are patched to set DT_RUNPATH + AC_CACHE_VAL([lt_cv_shlibpath_overrides_runpath], + [lt_cv_shlibpath_overrides_runpath=no + save_LDFLAGS=$LDFLAGS + save_libdir=$libdir + eval "libdir=/foo; wl=\"$_LT_TAGVAR(lt_prog_compiler_wl, $1)\"; \ + LDFLAGS=\"\$LDFLAGS $_LT_TAGVAR(hardcode_libdir_flag_spec, $1)\"" + AC_LINK_IFELSE([AC_LANG_PROGRAM([],[])], + [AS_IF([ ($OBJDUMP -p conftest$ac_exeext) 2>/dev/null | grep "RUNPATH.*$libdir" >/dev/null], + [lt_cv_shlibpath_overrides_runpath=yes])]) + LDFLAGS=$save_LDFLAGS + libdir=$save_libdir + ]) + shlibpath_overrides_runpath=$lt_cv_shlibpath_overrides_runpath + + # This implies no fast_install, which is unacceptable. + # Some rework will be needed to allow for fast_install + # before this can be enabled. + hardcode_into_libs=yes + + # Append ld.so.conf contents to the search path + if test -f /etc/ld.so.conf; then + lt_ld_extra=`awk '/^include / { system(sprintf("cd /etc; cat %s 2>/dev/null", \[$]2)); skip = 1; } { if (!skip) print \[$]0; skip = 0; }' < /etc/ld.so.conf | $SED -e 's/#.*//;/^[ ]*hwcap[ ]/d;s/[:, ]/ /g;s/=[^=]*$//;s/=[^= ]* / /g;s/"//g;/^$/d' | tr '\n' ' '` + sys_lib_dlsearch_path_spec="/lib /usr/lib $lt_ld_extra" + fi + + # We used to test for /lib/ld.so.1 and disable shared libraries on + # powerpc, because MkLinux only supported shared libraries with the + # GNU dynamic linker. Since this was broken with cross compilers, + # most powerpc-linux boxes support dynamic linking these days and + # people can always --disable-shared, the test was removed, and we + # assume the GNU/Linux dynamic linker is in use. + dynamic_linker='GNU/Linux ld.so' + ;; + +netbsdelf*-gnu) + version_type=linux + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + hardcode_into_libs=yes + dynamic_linker='NetBSD ld.elf_so' + ;; + +netbsd*) + version_type=sunos + need_lib_prefix=no + need_version=no + if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix' + finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir' + dynamic_linker='NetBSD (a.out) ld.so' + else + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + dynamic_linker='NetBSD ld.elf_so' + fi + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + hardcode_into_libs=yes + ;; + +newsos6) + version_type=linux # correct to gnu/linux during the next big refactor + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + ;; + +*nto* | *qnx*) + version_type=qnx + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + hardcode_into_libs=yes + dynamic_linker='ldqnx.so' + ;; + +openbsd*) + version_type=sunos + sys_lib_dlsearch_path_spec="/usr/lib" + need_lib_prefix=no + # Some older versions of OpenBSD (3.3 at least) *do* need versioned libs. + case $host_os in + openbsd3.3 | openbsd3.3.*) need_version=yes ;; + *) need_version=no ;; + esac + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix' + finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir' + shlibpath_var=LD_LIBRARY_PATH + if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then + case $host_os in + openbsd2.[[89]] | openbsd2.[[89]].*) + shlibpath_overrides_runpath=no + ;; + *) + shlibpath_overrides_runpath=yes + ;; + esac + else + shlibpath_overrides_runpath=yes + fi + ;; + +os2*) + libname_spec='$name' + shrext_cmds=".dll" + need_lib_prefix=no + library_names_spec='$libname${shared_ext} $libname.a' + dynamic_linker='OS/2 ld.exe' + shlibpath_var=LIBPATH + ;; + +osf3* | osf4* | osf5*) + version_type=osf + need_lib_prefix=no + need_version=no + soname_spec='${libname}${release}${shared_ext}$major' + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + shlibpath_var=LD_LIBRARY_PATH + sys_lib_search_path_spec="/usr/shlib /usr/ccs/lib /usr/lib/cmplrs/cc /usr/lib /usr/local/lib /var/shlib" + sys_lib_dlsearch_path_spec="$sys_lib_search_path_spec" + ;; + +rdos*) + dynamic_linker=no + ;; + +solaris*) + version_type=linux # correct to gnu/linux during the next big refactor + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + hardcode_into_libs=yes + # ldd complains unless libraries are executable + postinstall_cmds='chmod +x $lib' + ;; + +sunos4*) + version_type=sunos + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix' + finish_cmds='PATH="\$PATH:/usr/etc" ldconfig $libdir' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + if test "$with_gnu_ld" = yes; then + need_lib_prefix=no + fi + need_version=yes + ;; + +sysv4 | sysv4.3*) + version_type=linux # correct to gnu/linux during the next big refactor + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + case $host_vendor in + sni) + shlibpath_overrides_runpath=no + need_lib_prefix=no + runpath_var=LD_RUN_PATH + ;; + siemens) + need_lib_prefix=no + ;; + motorola) + need_lib_prefix=no + need_version=no + shlibpath_overrides_runpath=no + sys_lib_search_path_spec='/lib /usr/lib /usr/ccs/lib' + ;; + esac + ;; + +sysv4*MP*) + if test -d /usr/nec ;then + version_type=linux # correct to gnu/linux during the next big refactor + library_names_spec='$libname${shared_ext}.$versuffix $libname${shared_ext}.$major $libname${shared_ext}' + soname_spec='$libname${shared_ext}.$major' + shlibpath_var=LD_LIBRARY_PATH + fi + ;; + +sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*) + version_type=freebsd-elf + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + hardcode_into_libs=yes + if test "$with_gnu_ld" = yes; then + sys_lib_search_path_spec='/usr/local/lib /usr/gnu/lib /usr/ccs/lib /usr/lib /lib' + else + sys_lib_search_path_spec='/usr/ccs/lib /usr/lib' + case $host_os in + sco3.2v5*) + sys_lib_search_path_spec="$sys_lib_search_path_spec /lib" + ;; + esac + fi + sys_lib_dlsearch_path_spec='/usr/lib' + ;; + +tpf*) + # TPF is a cross-target only. Preferred cross-host = GNU/Linux. + version_type=linux # correct to gnu/linux during the next big refactor + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + hardcode_into_libs=yes + ;; + +uts4*) + version_type=linux # correct to gnu/linux during the next big refactor + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + ;; + +*) + dynamic_linker=no + ;; +esac +AC_MSG_RESULT([$dynamic_linker]) +test "$dynamic_linker" = no && can_build_shared=no + +variables_saved_for_relink="PATH $shlibpath_var $runpath_var" +if test "$GCC" = yes; then + variables_saved_for_relink="$variables_saved_for_relink GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH" +fi + +if test "${lt_cv_sys_lib_search_path_spec+set}" = set; then + sys_lib_search_path_spec="$lt_cv_sys_lib_search_path_spec" +fi +if test "${lt_cv_sys_lib_dlsearch_path_spec+set}" = set; then + sys_lib_dlsearch_path_spec="$lt_cv_sys_lib_dlsearch_path_spec" +fi + +_LT_DECL([], [variables_saved_for_relink], [1], + [Variables whose values should be saved in libtool wrapper scripts and + restored at link time]) +_LT_DECL([], [need_lib_prefix], [0], + [Do we need the "lib" prefix for modules?]) +_LT_DECL([], [need_version], [0], [Do we need a version for libraries?]) +_LT_DECL([], [version_type], [0], [Library versioning type]) +_LT_DECL([], [runpath_var], [0], [Shared library runtime path variable]) +_LT_DECL([], [shlibpath_var], [0],[Shared library path variable]) +_LT_DECL([], [shlibpath_overrides_runpath], [0], + [Is shlibpath searched before the hard-coded library search path?]) +_LT_DECL([], [libname_spec], [1], [Format of library name prefix]) +_LT_DECL([], [library_names_spec], [1], + [[List of archive names. First name is the real one, the rest are links. + The last name is the one that the linker finds with -lNAME]]) +_LT_DECL([], [soname_spec], [1], + [[The coded name of the library, if different from the real name]]) +_LT_DECL([], [install_override_mode], [1], + [Permission mode override for installation of shared libraries]) +_LT_DECL([], [postinstall_cmds], [2], + [Command to use after installation of a shared archive]) +_LT_DECL([], [postuninstall_cmds], [2], + [Command to use after uninstallation of a shared archive]) +_LT_DECL([], [finish_cmds], [2], + [Commands used to finish a libtool library installation in a directory]) +_LT_DECL([], [finish_eval], [1], + [[As "finish_cmds", except a single script fragment to be evaled but + not shown]]) +_LT_DECL([], [hardcode_into_libs], [0], + [Whether we should hardcode library paths into libraries]) +_LT_DECL([], [sys_lib_search_path_spec], [2], + [Compile-time system search path for libraries]) +_LT_DECL([], [sys_lib_dlsearch_path_spec], [2], + [Run-time system search path for libraries]) +])# _LT_SYS_DYNAMIC_LINKER + + +# _LT_PATH_TOOL_PREFIX(TOOL) +# -------------------------- +# find a file program which can recognize shared library +AC_DEFUN([_LT_PATH_TOOL_PREFIX], +[m4_require([_LT_DECL_EGREP])dnl +AC_MSG_CHECKING([for $1]) +AC_CACHE_VAL(lt_cv_path_MAGIC_CMD, +[case $MAGIC_CMD in +[[\\/*] | ?:[\\/]*]) + lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path. + ;; +*) + lt_save_MAGIC_CMD="$MAGIC_CMD" + lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR +dnl $ac_dummy forces splitting on constant user-supplied paths. +dnl POSIX.2 word splitting is done only on the output of word expansions, +dnl not every word. This closes a longstanding sh security hole. + ac_dummy="m4_if([$2], , $PATH, [$2])" + for ac_dir in $ac_dummy; do + IFS="$lt_save_ifs" + test -z "$ac_dir" && ac_dir=. + if test -f $ac_dir/$1; then + lt_cv_path_MAGIC_CMD="$ac_dir/$1" + if test -n "$file_magic_test_file"; then + case $deplibs_check_method in + "file_magic "*) + file_magic_regex=`expr "$deplibs_check_method" : "file_magic \(.*\)"` + MAGIC_CMD="$lt_cv_path_MAGIC_CMD" + if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null | + $EGREP "$file_magic_regex" > /dev/null; then + : + else + cat <<_LT_EOF 1>&2 + +*** Warning: the command libtool uses to detect shared libraries, +*** $file_magic_cmd, produces output that libtool cannot recognize. +*** The result is that libtool may fail to recognize shared libraries +*** as such. This will affect the creation of libtool libraries that +*** depend on shared libraries, but programs linked with such libtool +*** libraries will work regardless of this problem. Nevertheless, you +*** may want to report the problem to your system manager and/or to +*** bug-libtool@gnu.org + +_LT_EOF + fi ;; + esac + fi + break + fi + done + IFS="$lt_save_ifs" + MAGIC_CMD="$lt_save_MAGIC_CMD" + ;; +esac]) +MAGIC_CMD="$lt_cv_path_MAGIC_CMD" +if test -n "$MAGIC_CMD"; then + AC_MSG_RESULT($MAGIC_CMD) +else + AC_MSG_RESULT(no) +fi +_LT_DECL([], [MAGIC_CMD], [0], + [Used to examine libraries when file_magic_cmd begins with "file"])dnl +])# _LT_PATH_TOOL_PREFIX + +# Old name: +AU_ALIAS([AC_PATH_TOOL_PREFIX], [_LT_PATH_TOOL_PREFIX]) +dnl aclocal-1.4 backwards compatibility: +dnl AC_DEFUN([AC_PATH_TOOL_PREFIX], []) + + +# _LT_PATH_MAGIC +# -------------- +# find a file program which can recognize a shared library +m4_defun([_LT_PATH_MAGIC], +[_LT_PATH_TOOL_PREFIX(${ac_tool_prefix}file, /usr/bin$PATH_SEPARATOR$PATH) +if test -z "$lt_cv_path_MAGIC_CMD"; then + if test -n "$ac_tool_prefix"; then + _LT_PATH_TOOL_PREFIX(file, /usr/bin$PATH_SEPARATOR$PATH) + else + MAGIC_CMD=: + fi +fi +])# _LT_PATH_MAGIC + + +# LT_PATH_LD +# ---------- +# find the pathname to the GNU or non-GNU linker +AC_DEFUN([LT_PATH_LD], +[AC_REQUIRE([AC_PROG_CC])dnl +AC_REQUIRE([AC_CANONICAL_HOST])dnl +AC_REQUIRE([AC_CANONICAL_BUILD])dnl +m4_require([_LT_DECL_SED])dnl +m4_require([_LT_DECL_EGREP])dnl +m4_require([_LT_PROG_ECHO_BACKSLASH])dnl + +AC_ARG_WITH([gnu-ld], + [AS_HELP_STRING([--with-gnu-ld], + [assume the C compiler uses GNU ld @<:@default=no@:>@])], + [test "$withval" = no || with_gnu_ld=yes], + [with_gnu_ld=no])dnl + +ac_prog=ld +if test "$GCC" = yes; then + # Check if gcc -print-prog-name=ld gives a path. + AC_MSG_CHECKING([for ld used by $CC]) + case $host in + *-*-mingw*) + # gcc leaves a trailing carriage return which upsets mingw + ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;; + *) + ac_prog=`($CC -print-prog-name=ld) 2>&5` ;; + esac + case $ac_prog in + # Accept absolute paths. + [[\\/]]* | ?:[[\\/]]*) + re_direlt='/[[^/]][[^/]]*/\.\./' + # Canonicalize the pathname of ld + ac_prog=`$ECHO "$ac_prog"| $SED 's%\\\\%/%g'` + while $ECHO "$ac_prog" | $GREP "$re_direlt" > /dev/null 2>&1; do + ac_prog=`$ECHO $ac_prog| $SED "s%$re_direlt%/%"` + done + test -z "$LD" && LD="$ac_prog" + ;; + "") + # If it fails, then pretend we aren't using GCC. + ac_prog=ld + ;; + *) + # If it is relative, then search for the first ld in PATH. + with_gnu_ld=unknown + ;; + esac +elif test "$with_gnu_ld" = yes; then + AC_MSG_CHECKING([for GNU ld]) +else + AC_MSG_CHECKING([for non-GNU ld]) +fi +AC_CACHE_VAL(lt_cv_path_LD, +[if test -z "$LD"; then + lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR + for ac_dir in $PATH; do + IFS="$lt_save_ifs" + test -z "$ac_dir" && ac_dir=. + if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then + lt_cv_path_LD="$ac_dir/$ac_prog" + # Check to see if the program is GNU ld. I'd rather use --version, + # but apparently some variants of GNU ld only accept -v. + # Break only if it was the GNU/non-GNU ld that we prefer. + case `"$lt_cv_path_LD" -v 2>&1 &1 /dev/null 2>&1; then + lt_cv_deplibs_check_method='file_magic ^x86 archive import|^x86 DLL' + lt_cv_file_magic_cmd='func_win32_libid' + else + # Keep this pattern in sync with the one in func_win32_libid. + lt_cv_deplibs_check_method='file_magic file format (pei*-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)' + lt_cv_file_magic_cmd='$OBJDUMP -f' + fi + ;; + +cegcc*) + # use the weaker test based on 'objdump'. See mingw*. + lt_cv_deplibs_check_method='file_magic file format pe-arm-.*little(.*architecture: arm)?' + lt_cv_file_magic_cmd='$OBJDUMP -f' + ;; + +darwin* | rhapsody*) + lt_cv_deplibs_check_method=pass_all + ;; + +freebsd* | dragonfly*) + if echo __ELF__ | $CC -E - | $GREP __ELF__ > /dev/null; then + case $host_cpu in + i*86 ) + # Not sure whether the presence of OpenBSD here was a mistake. + # Let's accept both of them until this is cleared up. + lt_cv_deplibs_check_method='file_magic (FreeBSD|OpenBSD|DragonFly)/i[[3-9]]86 (compact )?demand paged shared library' + lt_cv_file_magic_cmd=/usr/bin/file + lt_cv_file_magic_test_file=`echo /usr/lib/libc.so.*` + ;; + esac + else + lt_cv_deplibs_check_method=pass_all + fi + ;; + +haiku*) + lt_cv_deplibs_check_method=pass_all + ;; + +hpux10.20* | hpux11*) + lt_cv_file_magic_cmd=/usr/bin/file + case $host_cpu in + ia64*) + lt_cv_deplibs_check_method='file_magic (s[[0-9]][[0-9]][[0-9]]|ELF-[[0-9]][[0-9]]) shared object file - IA64' + lt_cv_file_magic_test_file=/usr/lib/hpux32/libc.so + ;; + hppa*64*) + [lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|ELF[ -][0-9][0-9])(-bit)?( [LM]SB)? shared object( file)?[, -]* PA-RISC [0-9]\.[0-9]'] + lt_cv_file_magic_test_file=/usr/lib/pa20_64/libc.sl + ;; + *) + lt_cv_deplibs_check_method='file_magic (s[[0-9]][[0-9]][[0-9]]|PA-RISC[[0-9]]\.[[0-9]]) shared library' + lt_cv_file_magic_test_file=/usr/lib/libc.sl + ;; + esac + ;; + +interix[[3-9]]*) + # PIC code is broken on Interix 3.x, that's why |\.a not |_pic\.a here + lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so|\.a)$' + ;; + +irix5* | irix6* | nonstopux*) + case $LD in + *-32|*"-32 ") libmagic=32-bit;; + *-n32|*"-n32 ") libmagic=N32;; + *-64|*"-64 ") libmagic=64-bit;; + *) libmagic=never-match;; + esac + lt_cv_deplibs_check_method=pass_all + ;; + +# This must be glibc/ELF. +linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*) + lt_cv_deplibs_check_method=pass_all + ;; + +netbsd* | netbsdelf*-gnu) + if echo __ELF__ | $CC -E - | $GREP __ELF__ > /dev/null; then + lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so\.[[0-9]]+\.[[0-9]]+|_pic\.a)$' + else + lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so|_pic\.a)$' + fi + ;; + +newos6*) + lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[ML]]SB (executable|dynamic lib)' + lt_cv_file_magic_cmd=/usr/bin/file + lt_cv_file_magic_test_file=/usr/lib/libnls.so + ;; + +*nto* | *qnx*) + lt_cv_deplibs_check_method=pass_all + ;; + +openbsd*) + if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then + lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so\.[[0-9]]+\.[[0-9]]+|\.so|_pic\.a)$' + else + lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so\.[[0-9]]+\.[[0-9]]+|_pic\.a)$' + fi + ;; + +osf3* | osf4* | osf5*) + lt_cv_deplibs_check_method=pass_all + ;; + +rdos*) + lt_cv_deplibs_check_method=pass_all + ;; + +solaris*) + lt_cv_deplibs_check_method=pass_all + ;; + +sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*) + lt_cv_deplibs_check_method=pass_all + ;; + +sysv4 | sysv4.3*) + case $host_vendor in + motorola) + lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[ML]]SB (shared object|dynamic lib) M[[0-9]][[0-9]]* Version [[0-9]]' + lt_cv_file_magic_test_file=`echo /usr/lib/libc.so*` + ;; + ncr) + lt_cv_deplibs_check_method=pass_all + ;; + sequent) + lt_cv_file_magic_cmd='/bin/file' + lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[LM]]SB (shared object|dynamic lib )' + ;; + sni) + lt_cv_file_magic_cmd='/bin/file' + lt_cv_deplibs_check_method="file_magic ELF [[0-9]][[0-9]]*-bit [[LM]]SB dynamic lib" + lt_cv_file_magic_test_file=/lib/libc.so + ;; + siemens) + lt_cv_deplibs_check_method=pass_all + ;; + pc) + lt_cv_deplibs_check_method=pass_all + ;; + esac + ;; + +tpf*) + lt_cv_deplibs_check_method=pass_all + ;; +esac +]) + +file_magic_glob= +want_nocaseglob=no +if test "$build" = "$host"; then + case $host_os in + mingw* | pw32*) + if ( shopt | grep nocaseglob ) >/dev/null 2>&1; then + want_nocaseglob=yes + else + file_magic_glob=`echo aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ | $SED -e "s/\(..\)/s\/[[\1]]\/[[\1]]\/g;/g"` + fi + ;; + esac +fi + +file_magic_cmd=$lt_cv_file_magic_cmd +deplibs_check_method=$lt_cv_deplibs_check_method +test -z "$deplibs_check_method" && deplibs_check_method=unknown + +_LT_DECL([], [deplibs_check_method], [1], + [Method to check whether dependent libraries are shared objects]) +_LT_DECL([], [file_magic_cmd], [1], + [Command to use when deplibs_check_method = "file_magic"]) +_LT_DECL([], [file_magic_glob], [1], + [How to find potential files when deplibs_check_method = "file_magic"]) +_LT_DECL([], [want_nocaseglob], [1], + [Find potential files using nocaseglob when deplibs_check_method = "file_magic"]) +])# _LT_CHECK_MAGIC_METHOD + + +# LT_PATH_NM +# ---------- +# find the pathname to a BSD- or MS-compatible name lister +AC_DEFUN([LT_PATH_NM], +[AC_REQUIRE([AC_PROG_CC])dnl +AC_CACHE_CHECK([for BSD- or MS-compatible name lister (nm)], lt_cv_path_NM, +[if test -n "$NM"; then + # Let the user override the test. + lt_cv_path_NM="$NM" +else + lt_nm_to_check="${ac_tool_prefix}nm" + if test -n "$ac_tool_prefix" && test "$build" = "$host"; then + lt_nm_to_check="$lt_nm_to_check nm" + fi + for lt_tmp_nm in $lt_nm_to_check; do + lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR + for ac_dir in $PATH /usr/ccs/bin/elf /usr/ccs/bin /usr/ucb /bin; do + IFS="$lt_save_ifs" + test -z "$ac_dir" && ac_dir=. + tmp_nm="$ac_dir/$lt_tmp_nm" + if test -f "$tmp_nm" || test -f "$tmp_nm$ac_exeext" ; then + # Check to see if the nm accepts a BSD-compat flag. + # Adding the `sed 1q' prevents false positives on HP-UX, which says: + # nm: unknown option "B" ignored + # Tru64's nm complains that /dev/null is an invalid object file + case `"$tmp_nm" -B /dev/null 2>&1 | sed '1q'` in + */dev/null* | *'Invalid file or object type'*) + lt_cv_path_NM="$tmp_nm -B" + break + ;; + *) + case `"$tmp_nm" -p /dev/null 2>&1 | sed '1q'` in + */dev/null*) + lt_cv_path_NM="$tmp_nm -p" + break + ;; + *) + lt_cv_path_NM=${lt_cv_path_NM="$tmp_nm"} # keep the first match, but + continue # so that we can try to find one that supports BSD flags + ;; + esac + ;; + esac + fi + done + IFS="$lt_save_ifs" + done + : ${lt_cv_path_NM=no} +fi]) +if test "$lt_cv_path_NM" != "no"; then + NM="$lt_cv_path_NM" +else + # Didn't find any BSD compatible name lister, look for dumpbin. + if test -n "$DUMPBIN"; then : + # Let the user override the test. + else + AC_CHECK_TOOLS(DUMPBIN, [dumpbin "link -dump"], :) + case `$DUMPBIN -symbols /dev/null 2>&1 | sed '1q'` in + *COFF*) + DUMPBIN="$DUMPBIN -symbols" + ;; + *) + DUMPBIN=: + ;; + esac + fi + AC_SUBST([DUMPBIN]) + if test "$DUMPBIN" != ":"; then + NM="$DUMPBIN" + fi +fi +test -z "$NM" && NM=nm +AC_SUBST([NM]) +_LT_DECL([], [NM], [1], [A BSD- or MS-compatible name lister])dnl + +AC_CACHE_CHECK([the name lister ($NM) interface], [lt_cv_nm_interface], + [lt_cv_nm_interface="BSD nm" + echo "int some_variable = 0;" > conftest.$ac_ext + (eval echo "\"\$as_me:$LINENO: $ac_compile\"" >&AS_MESSAGE_LOG_FD) + (eval "$ac_compile" 2>conftest.err) + cat conftest.err >&AS_MESSAGE_LOG_FD + (eval echo "\"\$as_me:$LINENO: $NM \\\"conftest.$ac_objext\\\"\"" >&AS_MESSAGE_LOG_FD) + (eval "$NM \"conftest.$ac_objext\"" 2>conftest.err > conftest.out) + cat conftest.err >&AS_MESSAGE_LOG_FD + (eval echo "\"\$as_me:$LINENO: output\"" >&AS_MESSAGE_LOG_FD) + cat conftest.out >&AS_MESSAGE_LOG_FD + if $GREP 'External.*some_variable' conftest.out > /dev/null; then + lt_cv_nm_interface="MS dumpbin" + fi + rm -f conftest*]) +])# LT_PATH_NM + +# Old names: +AU_ALIAS([AM_PROG_NM], [LT_PATH_NM]) +AU_ALIAS([AC_PROG_NM], [LT_PATH_NM]) +dnl aclocal-1.4 backwards compatibility: +dnl AC_DEFUN([AM_PROG_NM], []) +dnl AC_DEFUN([AC_PROG_NM], []) + +# _LT_CHECK_SHAREDLIB_FROM_LINKLIB +# -------------------------------- +# how to determine the name of the shared library +# associated with a specific link library. +# -- PORTME fill in with the dynamic library characteristics +m4_defun([_LT_CHECK_SHAREDLIB_FROM_LINKLIB], +[m4_require([_LT_DECL_EGREP]) +m4_require([_LT_DECL_OBJDUMP]) +m4_require([_LT_DECL_DLLTOOL]) +AC_CACHE_CHECK([how to associate runtime and link libraries], +lt_cv_sharedlib_from_linklib_cmd, +[lt_cv_sharedlib_from_linklib_cmd='unknown' + +case $host_os in +cygwin* | mingw* | pw32* | cegcc*) + # two different shell functions defined in ltmain.sh + # decide which to use based on capabilities of $DLLTOOL + case `$DLLTOOL --help 2>&1` in + *--identify-strict*) + lt_cv_sharedlib_from_linklib_cmd=func_cygming_dll_for_implib + ;; + *) + lt_cv_sharedlib_from_linklib_cmd=func_cygming_dll_for_implib_fallback + ;; + esac + ;; +*) + # fallback: assume linklib IS sharedlib + lt_cv_sharedlib_from_linklib_cmd="$ECHO" + ;; +esac +]) +sharedlib_from_linklib_cmd=$lt_cv_sharedlib_from_linklib_cmd +test -z "$sharedlib_from_linklib_cmd" && sharedlib_from_linklib_cmd=$ECHO + +_LT_DECL([], [sharedlib_from_linklib_cmd], [1], + [Command to associate shared and link libraries]) +])# _LT_CHECK_SHAREDLIB_FROM_LINKLIB + + +# _LT_PATH_MANIFEST_TOOL +# ---------------------- +# locate the manifest tool +m4_defun([_LT_PATH_MANIFEST_TOOL], +[AC_CHECK_TOOL(MANIFEST_TOOL, mt, :) +test -z "$MANIFEST_TOOL" && MANIFEST_TOOL=mt +AC_CACHE_CHECK([if $MANIFEST_TOOL is a manifest tool], [lt_cv_path_mainfest_tool], + [lt_cv_path_mainfest_tool=no + echo "$as_me:$LINENO: $MANIFEST_TOOL '-?'" >&AS_MESSAGE_LOG_FD + $MANIFEST_TOOL '-?' 2>conftest.err > conftest.out + cat conftest.err >&AS_MESSAGE_LOG_FD + if $GREP 'Manifest Tool' conftest.out > /dev/null; then + lt_cv_path_mainfest_tool=yes + fi + rm -f conftest*]) +if test "x$lt_cv_path_mainfest_tool" != xyes; then + MANIFEST_TOOL=: +fi +_LT_DECL([], [MANIFEST_TOOL], [1], [Manifest tool])dnl +])# _LT_PATH_MANIFEST_TOOL + + +# LT_LIB_M +# -------- +# check for math library +AC_DEFUN([LT_LIB_M], +[AC_REQUIRE([AC_CANONICAL_HOST])dnl +LIBM= +case $host in +*-*-beos* | *-*-cegcc* | *-*-cygwin* | *-*-haiku* | *-*-pw32* | *-*-darwin*) + # These system don't have libm, or don't need it + ;; +*-ncr-sysv4.3*) + AC_CHECK_LIB(mw, _mwvalidcheckl, LIBM="-lmw") + AC_CHECK_LIB(m, cos, LIBM="$LIBM -lm") + ;; +*) + AC_CHECK_LIB(m, cos, LIBM="-lm") + ;; +esac +AC_SUBST([LIBM]) +])# LT_LIB_M + +# Old name: +AU_ALIAS([AC_CHECK_LIBM], [LT_LIB_M]) +dnl aclocal-1.4 backwards compatibility: +dnl AC_DEFUN([AC_CHECK_LIBM], []) + + +# _LT_COMPILER_NO_RTTI([TAGNAME]) +# ------------------------------- +m4_defun([_LT_COMPILER_NO_RTTI], +[m4_require([_LT_TAG_COMPILER])dnl + +_LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)= + +if test "$GCC" = yes; then + case $cc_basename in + nvcc*) + _LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=' -Xcompiler -fno-builtin' ;; + *) + _LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=' -fno-builtin' ;; + esac + + _LT_COMPILER_OPTION([if $compiler supports -fno-rtti -fno-exceptions], + lt_cv_prog_compiler_rtti_exceptions, + [-fno-rtti -fno-exceptions], [], + [_LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)="$_LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1) -fno-rtti -fno-exceptions"]) +fi +_LT_TAGDECL([no_builtin_flag], [lt_prog_compiler_no_builtin_flag], [1], + [Compiler flag to turn off builtin functions]) +])# _LT_COMPILER_NO_RTTI + + +# _LT_CMD_GLOBAL_SYMBOLS +# ---------------------- +m4_defun([_LT_CMD_GLOBAL_SYMBOLS], +[AC_REQUIRE([AC_CANONICAL_HOST])dnl +AC_REQUIRE([AC_PROG_CC])dnl +AC_REQUIRE([AC_PROG_AWK])dnl +AC_REQUIRE([LT_PATH_NM])dnl +AC_REQUIRE([LT_PATH_LD])dnl +m4_require([_LT_DECL_SED])dnl +m4_require([_LT_DECL_EGREP])dnl +m4_require([_LT_TAG_COMPILER])dnl + +# Check for command to grab the raw symbol name followed by C symbol from nm. +AC_MSG_CHECKING([command to parse $NM output from $compiler object]) +AC_CACHE_VAL([lt_cv_sys_global_symbol_pipe], +[ +# These are sane defaults that work on at least a few old systems. +# [They come from Ultrix. What could be older than Ultrix?!! ;)] + +# Character class describing NM global symbol codes. +symcode='[[BCDEGRST]]' + +# Regexp to match symbols that can be accessed directly from C. +sympat='\([[_A-Za-z]][[_A-Za-z0-9]]*\)' + +# Define system-specific variables. +case $host_os in +aix*) + symcode='[[BCDT]]' + ;; +cygwin* | mingw* | pw32* | cegcc*) + symcode='[[ABCDGISTW]]' + ;; +hpux*) + if test "$host_cpu" = ia64; then + symcode='[[ABCDEGRST]]' + fi + ;; +irix* | nonstopux*) + symcode='[[BCDEGRST]]' + ;; +osf*) + symcode='[[BCDEGQRST]]' + ;; +solaris*) + symcode='[[BDRT]]' + ;; +sco3.2v5*) + symcode='[[DT]]' + ;; +sysv4.2uw2*) + symcode='[[DT]]' + ;; +sysv5* | sco5v6* | unixware* | OpenUNIX*) + symcode='[[ABDT]]' + ;; +sysv4) + symcode='[[DFNSTU]]' + ;; +esac + +# If we're using GNU nm, then use its standard symbol codes. +case `$NM -V 2>&1` in +*GNU* | *'with BFD'*) + symcode='[[ABCDGIRSTW]]' ;; +esac + +# Transform an extracted symbol line into a proper C declaration. +# Some systems (esp. on ia64) link data and code symbols differently, +# so use this general approach. +lt_cv_sys_global_symbol_to_cdecl="sed -n -e 's/^T .* \(.*\)$/extern int \1();/p' -e 's/^$symcode* .* \(.*\)$/extern char \1;/p'" + +# Transform an extracted symbol line into symbol name and symbol address +lt_cv_sys_global_symbol_to_c_name_address="sed -n -e 's/^: \([[^ ]]*\)[[ ]]*$/ {\\\"\1\\\", (void *) 0},/p' -e 's/^$symcode* \([[^ ]]*\) \([[^ ]]*\)$/ {\"\2\", (void *) \&\2},/p'" +lt_cv_sys_global_symbol_to_c_name_address_lib_prefix="sed -n -e 's/^: \([[^ ]]*\)[[ ]]*$/ {\\\"\1\\\", (void *) 0},/p' -e 's/^$symcode* \([[^ ]]*\) \(lib[[^ ]]*\)$/ {\"\2\", (void *) \&\2},/p' -e 's/^$symcode* \([[^ ]]*\) \([[^ ]]*\)$/ {\"lib\2\", (void *) \&\2},/p'" + +# Handle CRLF in mingw tool chain +opt_cr= +case $build_os in +mingw*) + opt_cr=`$ECHO 'x\{0,1\}' | tr x '\015'` # option cr in regexp + ;; +esac + +# Try without a prefix underscore, then with it. +for ac_symprfx in "" "_"; do + + # Transform symcode, sympat, and symprfx into a raw symbol and a C symbol. + symxfrm="\\1 $ac_symprfx\\2 \\2" + + # Write the raw and C identifiers. + if test "$lt_cv_nm_interface" = "MS dumpbin"; then + # Fake it for dumpbin and say T for any non-static function + # and D for any global variable. + # Also find C++ and __fastcall symbols from MSVC++, + # which start with @ or ?. + lt_cv_sys_global_symbol_pipe="$AWK ['"\ +" {last_section=section; section=\$ 3};"\ +" /^COFF SYMBOL TABLE/{for(i in hide) delete hide[i]};"\ +" /Section length .*#relocs.*(pick any)/{hide[last_section]=1};"\ +" \$ 0!~/External *\|/{next};"\ +" / 0+ UNDEF /{next}; / UNDEF \([^|]\)*()/{next};"\ +" {if(hide[section]) next};"\ +" {f=0}; \$ 0~/\(\).*\|/{f=1}; {printf f ? \"T \" : \"D \"};"\ +" {split(\$ 0, a, /\||\r/); split(a[2], s)};"\ +" s[1]~/^[@?]/{print s[1], s[1]; next};"\ +" s[1]~prfx {split(s[1],t,\"@\"); print t[1], substr(t[1],length(prfx))}"\ +" ' prfx=^$ac_symprfx]" + else + lt_cv_sys_global_symbol_pipe="sed -n -e 's/^.*[[ ]]\($symcode$symcode*\)[[ ]][[ ]]*$ac_symprfx$sympat$opt_cr$/$symxfrm/p'" + fi + lt_cv_sys_global_symbol_pipe="$lt_cv_sys_global_symbol_pipe | sed '/ __gnu_lto/d'" + + # Check to see that the pipe works correctly. + pipe_works=no + + rm -f conftest* + cat > conftest.$ac_ext <<_LT_EOF +#ifdef __cplusplus +extern "C" { +#endif +char nm_test_var; +void nm_test_func(void); +void nm_test_func(void){} +#ifdef __cplusplus +} +#endif +int main(){nm_test_var='a';nm_test_func();return(0);} +_LT_EOF + + if AC_TRY_EVAL(ac_compile); then + # Now try to grab the symbols. + nlist=conftest.nm + if AC_TRY_EVAL(NM conftest.$ac_objext \| "$lt_cv_sys_global_symbol_pipe" \> $nlist) && test -s "$nlist"; then + # Try sorting and uniquifying the output. + if sort "$nlist" | uniq > "$nlist"T; then + mv -f "$nlist"T "$nlist" + else + rm -f "$nlist"T + fi + + # Make sure that we snagged all the symbols we need. + if $GREP ' nm_test_var$' "$nlist" >/dev/null; then + if $GREP ' nm_test_func$' "$nlist" >/dev/null; then + cat <<_LT_EOF > conftest.$ac_ext +/* Keep this code in sync between libtool.m4, ltmain, lt_system.h, and tests. */ +#if defined(_WIN32) || defined(__CYGWIN__) || defined(_WIN32_WCE) +/* DATA imports from DLLs on WIN32 con't be const, because runtime + relocations are performed -- see ld's documentation on pseudo-relocs. */ +# define LT@&t@_DLSYM_CONST +#elif defined(__osf__) +/* This system does not cope well with relocations in const data. */ +# define LT@&t@_DLSYM_CONST +#else +# define LT@&t@_DLSYM_CONST const +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +_LT_EOF + # Now generate the symbol file. + eval "$lt_cv_sys_global_symbol_to_cdecl"' < "$nlist" | $GREP -v main >> conftest.$ac_ext' + + cat <<_LT_EOF >> conftest.$ac_ext + +/* The mapping between symbol names and symbols. */ +LT@&t@_DLSYM_CONST struct { + const char *name; + void *address; +} +lt__PROGRAM__LTX_preloaded_symbols[[]] = +{ + { "@PROGRAM@", (void *) 0 }, +_LT_EOF + $SED "s/^$symcode$symcode* \(.*\) \(.*\)$/ {\"\2\", (void *) \&\2},/" < "$nlist" | $GREP -v main >> conftest.$ac_ext + cat <<\_LT_EOF >> conftest.$ac_ext + {0, (void *) 0} +}; + +/* This works around a problem in FreeBSD linker */ +#ifdef FREEBSD_WORKAROUND +static const void *lt_preloaded_setup() { + return lt__PROGRAM__LTX_preloaded_symbols; +} +#endif + +#ifdef __cplusplus +} +#endif +_LT_EOF + # Now try linking the two files. + mv conftest.$ac_objext conftstm.$ac_objext + lt_globsym_save_LIBS=$LIBS + lt_globsym_save_CFLAGS=$CFLAGS + LIBS="conftstm.$ac_objext" + CFLAGS="$CFLAGS$_LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)" + if AC_TRY_EVAL(ac_link) && test -s conftest${ac_exeext}; then + pipe_works=yes + fi + LIBS=$lt_globsym_save_LIBS + CFLAGS=$lt_globsym_save_CFLAGS + else + echo "cannot find nm_test_func in $nlist" >&AS_MESSAGE_LOG_FD + fi + else + echo "cannot find nm_test_var in $nlist" >&AS_MESSAGE_LOG_FD + fi + else + echo "cannot run $lt_cv_sys_global_symbol_pipe" >&AS_MESSAGE_LOG_FD + fi + else + echo "$progname: failed program was:" >&AS_MESSAGE_LOG_FD + cat conftest.$ac_ext >&5 + fi + rm -rf conftest* conftst* + + # Do not use the global_symbol_pipe unless it works. + if test "$pipe_works" = yes; then + break + else + lt_cv_sys_global_symbol_pipe= + fi +done +]) +if test -z "$lt_cv_sys_global_symbol_pipe"; then + lt_cv_sys_global_symbol_to_cdecl= +fi +if test -z "$lt_cv_sys_global_symbol_pipe$lt_cv_sys_global_symbol_to_cdecl"; then + AC_MSG_RESULT(failed) +else + AC_MSG_RESULT(ok) +fi + +# Response file support. +if test "$lt_cv_nm_interface" = "MS dumpbin"; then + nm_file_list_spec='@' +elif $NM --help 2>/dev/null | grep '[[@]]FILE' >/dev/null; then + nm_file_list_spec='@' +fi + +_LT_DECL([global_symbol_pipe], [lt_cv_sys_global_symbol_pipe], [1], + [Take the output of nm and produce a listing of raw symbols and C names]) +_LT_DECL([global_symbol_to_cdecl], [lt_cv_sys_global_symbol_to_cdecl], [1], + [Transform the output of nm in a proper C declaration]) +_LT_DECL([global_symbol_to_c_name_address], + [lt_cv_sys_global_symbol_to_c_name_address], [1], + [Transform the output of nm in a C name address pair]) +_LT_DECL([global_symbol_to_c_name_address_lib_prefix], + [lt_cv_sys_global_symbol_to_c_name_address_lib_prefix], [1], + [Transform the output of nm in a C name address pair when lib prefix is needed]) +_LT_DECL([], [nm_file_list_spec], [1], + [Specify filename containing input files for $NM]) +]) # _LT_CMD_GLOBAL_SYMBOLS + + +# _LT_COMPILER_PIC([TAGNAME]) +# --------------------------- +m4_defun([_LT_COMPILER_PIC], +[m4_require([_LT_TAG_COMPILER])dnl +_LT_TAGVAR(lt_prog_compiler_wl, $1)= +_LT_TAGVAR(lt_prog_compiler_pic, $1)= +_LT_TAGVAR(lt_prog_compiler_static, $1)= + +m4_if([$1], [CXX], [ + # C++ specific cases for pic, static, wl, etc. + if test "$GXX" = yes; then + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-static' + + case $host_os in + aix*) + # All AIX code is PIC. + if test "$host_cpu" = ia64; then + # AIX 5 now supports IA64 processor + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + fi + ;; + + amigaos*) + case $host_cpu in + powerpc) + # see comment about AmigaOS4 .so support + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' + ;; + m68k) + # FIXME: we need at least 68020 code to build shared libraries, but + # adding the `-m68020' flag to GCC prevents building anything better, + # like `-m68040'. + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-m68020 -resident32 -malways-restore-a4' + ;; + esac + ;; + + beos* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*) + # PIC is the default for these OSes. + ;; + mingw* | cygwin* | os2* | pw32* | cegcc*) + # This hack is so that the source file can tell whether it is being + # built for inclusion in a dll (and should export symbols for example). + # Although the cygwin gcc ignores -fPIC, still need this for old-style + # (--disable-auto-import) libraries + m4_if([$1], [GCJ], [], + [_LT_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT']) + ;; + darwin* | rhapsody*) + # PIC is the default on this platform + # Common symbols not allowed in MH_DYLIB files + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fno-common' + ;; + *djgpp*) + # DJGPP does not support shared libraries at all + _LT_TAGVAR(lt_prog_compiler_pic, $1)= + ;; + haiku*) + # PIC is the default for Haiku. + # The "-static" flag exists, but is broken. + _LT_TAGVAR(lt_prog_compiler_static, $1)= + ;; + interix[[3-9]]*) + # Interix 3.x gcc -fpic/-fPIC options generate broken code. + # Instead, we relocate shared libraries at runtime. + ;; + sysv4*MP*) + if test -d /usr/nec; then + _LT_TAGVAR(lt_prog_compiler_pic, $1)=-Kconform_pic + fi + ;; + hpux*) + # PIC is the default for 64-bit PA HP-UX, but not for 32-bit + # PA HP-UX. On IA64 HP-UX, PIC is the default but the pic flag + # sets the default TLS model and affects inlining. + case $host_cpu in + hppa*64*) + ;; + *) + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' + ;; + esac + ;; + *qnx* | *nto*) + # QNX uses GNU C++, but need to define -shared option too, otherwise + # it will coredump. + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC -shared' + ;; + *) + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' + ;; + esac + else + case $host_os in + aix[[4-9]]*) + # All AIX code is PIC. + if test "$host_cpu" = ia64; then + # AIX 5 now supports IA64 processor + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + else + _LT_TAGVAR(lt_prog_compiler_static, $1)='-bnso -bI:/lib/syscalls.exp' + fi + ;; + chorus*) + case $cc_basename in + cxch68*) + # Green Hills C++ Compiler + # _LT_TAGVAR(lt_prog_compiler_static, $1)="--no_auto_instantiation -u __main -u __premain -u _abort -r $COOL_DIR/lib/libOrb.a $MVME_DIR/lib/CC/libC.a $MVME_DIR/lib/classix/libcx.s.a" + ;; + esac + ;; + mingw* | cygwin* | os2* | pw32* | cegcc*) + # This hack is so that the source file can tell whether it is being + # built for inclusion in a dll (and should export symbols for example). + m4_if([$1], [GCJ], [], + [_LT_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT']) + ;; + dgux*) + case $cc_basename in + ec++*) + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' + ;; + ghcx*) + # Green Hills C++ Compiler + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-pic' + ;; + *) + ;; + esac + ;; + freebsd* | dragonfly*) + # FreeBSD uses GNU C++ + ;; + hpux9* | hpux10* | hpux11*) + case $cc_basename in + CC*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_static, $1)='${wl}-a ${wl}archive' + if test "$host_cpu" != ia64; then + _LT_TAGVAR(lt_prog_compiler_pic, $1)='+Z' + fi + ;; + aCC*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_static, $1)='${wl}-a ${wl}archive' + case $host_cpu in + hppa*64*|ia64*) + # +Z the default + ;; + *) + _LT_TAGVAR(lt_prog_compiler_pic, $1)='+Z' + ;; + esac + ;; + *) + ;; + esac + ;; + interix*) + # This is c89, which is MS Visual C++ (no shared libs) + # Anyone wants to do a port? + ;; + irix5* | irix6* | nonstopux*) + case $cc_basename in + CC*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared' + # CC pic flag -KPIC is the default. + ;; + *) + ;; + esac + ;; + linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*) + case $cc_basename in + KCC*) + # KAI C++ Compiler + _LT_TAGVAR(lt_prog_compiler_wl, $1)='--backend -Wl,' + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' + ;; + ecpc* ) + # old Intel C++ for x86_64 which still supported -KPIC. + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-static' + ;; + icpc* ) + # Intel C++, used to be incompatible with GCC. + # ICC 10 doesn't accept -KPIC any more. + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-static' + ;; + pgCC* | pgcpp*) + # Portland Group C++ compiler + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fpic' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + ;; + cxx*) + # Compaq C++ + # Make sure the PIC flag is empty. It appears that all Alpha + # Linux and Compaq Tru64 Unix objects are PIC. + _LT_TAGVAR(lt_prog_compiler_pic, $1)= + _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared' + ;; + xlc* | xlC* | bgxl[[cC]]* | mpixl[[cC]]*) + # IBM XL 8.0, 9.0 on PPC and BlueGene + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-qpic' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-qstaticlink' + ;; + *) + case `$CC -V 2>&1 | sed 5q` in + *Sun\ C*) + # Sun C++ 5.9 + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld ' + ;; + esac + ;; + esac + ;; + lynxos*) + ;; + m88k*) + ;; + mvs*) + case $cc_basename in + cxx*) + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-W c,exportall' + ;; + *) + ;; + esac + ;; + netbsd* | netbsdelf*-gnu) + ;; + *qnx* | *nto*) + # QNX uses GNU C++, but need to define -shared option too, otherwise + # it will coredump. + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC -shared' + ;; + osf3* | osf4* | osf5*) + case $cc_basename in + KCC*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='--backend -Wl,' + ;; + RCC*) + # Rational C++ 2.4.1 + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-pic' + ;; + cxx*) + # Digital/Compaq C++ + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + # Make sure the PIC flag is empty. It appears that all Alpha + # Linux and Compaq Tru64 Unix objects are PIC. + _LT_TAGVAR(lt_prog_compiler_pic, $1)= + _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared' + ;; + *) + ;; + esac + ;; + psos*) + ;; + solaris*) + case $cc_basename in + CC* | sunCC*) + # Sun C++ 4.2, 5.x and Centerline C++ + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld ' + ;; + gcx*) + # Green Hills C++ Compiler + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-PIC' + ;; + *) + ;; + esac + ;; + sunos4*) + case $cc_basename in + CC*) + # Sun C++ 4.x + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-pic' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + ;; + lcc*) + # Lucid + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-pic' + ;; + *) + ;; + esac + ;; + sysv5* | unixware* | sco3.2v5* | sco5v6* | OpenUNIX*) + case $cc_basename in + CC*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + ;; + esac + ;; + tandem*) + case $cc_basename in + NCC*) + # NonStop-UX NCC 3.20 + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' + ;; + *) + ;; + esac + ;; + vxworks*) + ;; + *) + _LT_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no + ;; + esac + fi +], +[ + if test "$GCC" = yes; then + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-static' + + case $host_os in + aix*) + # All AIX code is PIC. + if test "$host_cpu" = ia64; then + # AIX 5 now supports IA64 processor + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + fi + ;; + + amigaos*) + case $host_cpu in + powerpc) + # see comment about AmigaOS4 .so support + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' + ;; + m68k) + # FIXME: we need at least 68020 code to build shared libraries, but + # adding the `-m68020' flag to GCC prevents building anything better, + # like `-m68040'. + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-m68020 -resident32 -malways-restore-a4' + ;; + esac + ;; + + beos* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*) + # PIC is the default for these OSes. + ;; + + mingw* | cygwin* | pw32* | os2* | cegcc*) + # This hack is so that the source file can tell whether it is being + # built for inclusion in a dll (and should export symbols for example). + # Although the cygwin gcc ignores -fPIC, still need this for old-style + # (--disable-auto-import) libraries + m4_if([$1], [GCJ], [], + [_LT_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT']) + ;; + + darwin* | rhapsody*) + # PIC is the default on this platform + # Common symbols not allowed in MH_DYLIB files + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fno-common' + ;; + + haiku*) + # PIC is the default for Haiku. + # The "-static" flag exists, but is broken. + _LT_TAGVAR(lt_prog_compiler_static, $1)= + ;; + + hpux*) + # PIC is the default for 64-bit PA HP-UX, but not for 32-bit + # PA HP-UX. On IA64 HP-UX, PIC is the default but the pic flag + # sets the default TLS model and affects inlining. + case $host_cpu in + hppa*64*) + # +Z the default + ;; + *) + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' + ;; + esac + ;; + + interix[[3-9]]*) + # Interix 3.x gcc -fpic/-fPIC options generate broken code. + # Instead, we relocate shared libraries at runtime. + ;; + + msdosdjgpp*) + # Just because we use GCC doesn't mean we suddenly get shared libraries + # on systems that don't support them. + _LT_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no + enable_shared=no + ;; + + *nto* | *qnx*) + # QNX uses GNU C++, but need to define -shared option too, otherwise + # it will coredump. + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC -shared' + ;; + + sysv4*MP*) + if test -d /usr/nec; then + _LT_TAGVAR(lt_prog_compiler_pic, $1)=-Kconform_pic + fi + ;; + + *) + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' + ;; + esac + + case $cc_basename in + nvcc*) # Cuda Compiler Driver 2.2 + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Xlinker ' + if test -n "$_LT_TAGVAR(lt_prog_compiler_pic, $1)"; then + _LT_TAGVAR(lt_prog_compiler_pic, $1)="-Xcompiler $_LT_TAGVAR(lt_prog_compiler_pic, $1)" + fi + ;; + esac + else + # PORTME Check for flag to pass linker flags through the system compiler. + case $host_os in + aix*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + if test "$host_cpu" = ia64; then + # AIX 5 now supports IA64 processor + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + else + _LT_TAGVAR(lt_prog_compiler_static, $1)='-bnso -bI:/lib/syscalls.exp' + fi + ;; + + mingw* | cygwin* | pw32* | os2* | cegcc*) + # This hack is so that the source file can tell whether it is being + # built for inclusion in a dll (and should export symbols for example). + m4_if([$1], [GCJ], [], + [_LT_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT']) + ;; + + hpux9* | hpux10* | hpux11*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but + # not for PA HP-UX. + case $host_cpu in + hppa*64*|ia64*) + # +Z the default + ;; + *) + _LT_TAGVAR(lt_prog_compiler_pic, $1)='+Z' + ;; + esac + # Is there a better lt_prog_compiler_static that works with the bundled CC? + _LT_TAGVAR(lt_prog_compiler_static, $1)='${wl}-a ${wl}archive' + ;; + + irix5* | irix6* | nonstopux*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + # PIC (with -KPIC) is the default. + _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared' + ;; + + linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*) + case $cc_basename in + # old Intel for x86_64 which still supported -KPIC. + ecc*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-static' + ;; + # icc used to be incompatible with GCC. + # ICC 10 doesn't accept -KPIC any more. + icc* | ifort*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-static' + ;; + # Lahey Fortran 8.1. + lf95*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_pic, $1)='--shared' + _LT_TAGVAR(lt_prog_compiler_static, $1)='--static' + ;; + nagfor*) + # NAG Fortran compiler + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,-Wl,,' + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-PIC' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + ;; + pgcc* | pgf77* | pgf90* | pgf95* | pgfortran*) + # Portland Group compilers (*not* the Pentium gcc compiler, + # which looks to be a dead project) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fpic' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + ;; + ccc*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + # All Alpha code is PIC. + _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared' + ;; + xl* | bgxl* | bgf* | mpixl*) + # IBM XL C 8.0/Fortran 10.1, 11.1 on PPC and BlueGene + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-qpic' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-qstaticlink' + ;; + *) + case `$CC -V 2>&1 | sed 5q` in + *Sun\ Ceres\ Fortran* | *Sun*Fortran*\ [[1-7]].* | *Sun*Fortran*\ 8.[[0-3]]*) + # Sun Fortran 8.3 passes all unrecognized flags to the linker + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + _LT_TAGVAR(lt_prog_compiler_wl, $1)='' + ;; + *Sun\ F* | *Sun*Fortran*) + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld ' + ;; + *Sun\ C*) + # Sun C 5.9 + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + ;; + *Intel*\ [[CF]]*Compiler*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-static' + ;; + *Portland\ Group*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fpic' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + ;; + esac + ;; + esac + ;; + + newsos6) + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + ;; + + *nto* | *qnx*) + # QNX uses GNU C++, but need to define -shared option too, otherwise + # it will coredump. + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC -shared' + ;; + + osf3* | osf4* | osf5*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + # All OSF/1 code is PIC. + _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared' + ;; + + rdos*) + _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared' + ;; + + solaris*) + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + case $cc_basename in + f77* | f90* | f95* | sunf77* | sunf90* | sunf95*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld ';; + *) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,';; + esac + ;; + + sunos4*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld ' + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-PIC' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + ;; + + sysv4 | sysv4.2uw2* | sysv4.3*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + ;; + + sysv4*MP*) + if test -d /usr/nec ;then + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-Kconform_pic' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + fi + ;; + + sysv5* | unixware* | sco3.2v5* | sco5v6* | OpenUNIX*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + ;; + + unicos*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no + ;; + + uts4*) + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-pic' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + ;; + + *) + _LT_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no + ;; + esac + fi +]) +case $host_os in + # For platforms which do not support PIC, -DPIC is meaningless: + *djgpp*) + _LT_TAGVAR(lt_prog_compiler_pic, $1)= + ;; + *) + _LT_TAGVAR(lt_prog_compiler_pic, $1)="$_LT_TAGVAR(lt_prog_compiler_pic, $1)@&t@m4_if([$1],[],[ -DPIC],[m4_if([$1],[CXX],[ -DPIC],[])])" + ;; +esac + +AC_CACHE_CHECK([for $compiler option to produce PIC], + [_LT_TAGVAR(lt_cv_prog_compiler_pic, $1)], + [_LT_TAGVAR(lt_cv_prog_compiler_pic, $1)=$_LT_TAGVAR(lt_prog_compiler_pic, $1)]) +_LT_TAGVAR(lt_prog_compiler_pic, $1)=$_LT_TAGVAR(lt_cv_prog_compiler_pic, $1) + +# +# Check to make sure the PIC flag actually works. +# +if test -n "$_LT_TAGVAR(lt_prog_compiler_pic, $1)"; then + _LT_COMPILER_OPTION([if $compiler PIC flag $_LT_TAGVAR(lt_prog_compiler_pic, $1) works], + [_LT_TAGVAR(lt_cv_prog_compiler_pic_works, $1)], + [$_LT_TAGVAR(lt_prog_compiler_pic, $1)@&t@m4_if([$1],[],[ -DPIC],[m4_if([$1],[CXX],[ -DPIC],[])])], [], + [case $_LT_TAGVAR(lt_prog_compiler_pic, $1) in + "" | " "*) ;; + *) _LT_TAGVAR(lt_prog_compiler_pic, $1)=" $_LT_TAGVAR(lt_prog_compiler_pic, $1)" ;; + esac], + [_LT_TAGVAR(lt_prog_compiler_pic, $1)= + _LT_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no]) +fi +_LT_TAGDECL([pic_flag], [lt_prog_compiler_pic], [1], + [Additional compiler flags for building library objects]) + +_LT_TAGDECL([wl], [lt_prog_compiler_wl], [1], + [How to pass a linker flag through the compiler]) +# +# Check to make sure the static flag actually works. +# +wl=$_LT_TAGVAR(lt_prog_compiler_wl, $1) eval lt_tmp_static_flag=\"$_LT_TAGVAR(lt_prog_compiler_static, $1)\" +_LT_LINKER_OPTION([if $compiler static flag $lt_tmp_static_flag works], + _LT_TAGVAR(lt_cv_prog_compiler_static_works, $1), + $lt_tmp_static_flag, + [], + [_LT_TAGVAR(lt_prog_compiler_static, $1)=]) +_LT_TAGDECL([link_static_flag], [lt_prog_compiler_static], [1], + [Compiler flag to prevent dynamic linking]) +])# _LT_COMPILER_PIC + + +# _LT_LINKER_SHLIBS([TAGNAME]) +# ---------------------------- +# See if the linker supports building shared libraries. +m4_defun([_LT_LINKER_SHLIBS], +[AC_REQUIRE([LT_PATH_LD])dnl +AC_REQUIRE([LT_PATH_NM])dnl +m4_require([_LT_PATH_MANIFEST_TOOL])dnl +m4_require([_LT_FILEUTILS_DEFAULTS])dnl +m4_require([_LT_DECL_EGREP])dnl +m4_require([_LT_DECL_SED])dnl +m4_require([_LT_CMD_GLOBAL_SYMBOLS])dnl +m4_require([_LT_TAG_COMPILER])dnl +AC_MSG_CHECKING([whether the $compiler linker ($LD) supports shared libraries]) +m4_if([$1], [CXX], [ + _LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols' + _LT_TAGVAR(exclude_expsyms, $1)=['_GLOBAL_OFFSET_TABLE_|_GLOBAL__F[ID]_.*'] + case $host_os in + aix[[4-9]]*) + # If we're using GNU nm, then we don't want the "-C" option. + # -C means demangle to AIX nm, but means don't demangle with GNU nm + # Also, AIX nm treats weak defined symbols like other global defined + # symbols, whereas GNU nm marks them as "W". + if $NM -V 2>&1 | $GREP 'GNU' > /dev/null; then + _LT_TAGVAR(export_symbols_cmds, $1)='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W")) && ([substr](\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols' + else + _LT_TAGVAR(export_symbols_cmds, $1)='$NM -BCpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B")) && ([substr](\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols' + fi + ;; + pw32*) + _LT_TAGVAR(export_symbols_cmds, $1)="$ltdll_cmds" + ;; + cygwin* | mingw* | cegcc*) + case $cc_basename in + cl*) + _LT_TAGVAR(exclude_expsyms, $1)='_NULL_IMPORT_DESCRIPTOR|_IMPORT_DESCRIPTOR_.*' + ;; + *) + _LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[[BCDGRS]][[ ]]/s/.*[[ ]]\([[^ ]]*\)/\1 DATA/;s/^.*[[ ]]__nm__\([[^ ]]*\)[[ ]][[^ ]]*/\1 DATA/;/^I[[ ]]/d;/^[[AITW]][[ ]]/s/.* //'\'' | sort | uniq > $export_symbols' + _LT_TAGVAR(exclude_expsyms, $1)=['[_]+GLOBAL_OFFSET_TABLE_|[_]+GLOBAL__[FID]_.*|[_]+head_[A-Za-z0-9_]+_dll|[A-Za-z0-9_]+_dll_iname'] + ;; + esac + ;; + linux* | k*bsd*-gnu | gnu*) + _LT_TAGVAR(link_all_deplibs, $1)=no + ;; + *) + _LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols' + ;; + esac +], [ + runpath_var= + _LT_TAGVAR(allow_undefined_flag, $1)= + _LT_TAGVAR(always_export_symbols, $1)=no + _LT_TAGVAR(archive_cmds, $1)= + _LT_TAGVAR(archive_expsym_cmds, $1)= + _LT_TAGVAR(compiler_needs_object, $1)=no + _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=no + _LT_TAGVAR(export_dynamic_flag_spec, $1)= + _LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols' + _LT_TAGVAR(hardcode_automatic, $1)=no + _LT_TAGVAR(hardcode_direct, $1)=no + _LT_TAGVAR(hardcode_direct_absolute, $1)=no + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)= + _LT_TAGVAR(hardcode_libdir_separator, $1)= + _LT_TAGVAR(hardcode_minus_L, $1)=no + _LT_TAGVAR(hardcode_shlibpath_var, $1)=unsupported + _LT_TAGVAR(inherit_rpath, $1)=no + _LT_TAGVAR(link_all_deplibs, $1)=unknown + _LT_TAGVAR(module_cmds, $1)= + _LT_TAGVAR(module_expsym_cmds, $1)= + _LT_TAGVAR(old_archive_from_new_cmds, $1)= + _LT_TAGVAR(old_archive_from_expsyms_cmds, $1)= + _LT_TAGVAR(thread_safe_flag_spec, $1)= + _LT_TAGVAR(whole_archive_flag_spec, $1)= + # include_expsyms should be a list of space-separated symbols to be *always* + # included in the symbol list + _LT_TAGVAR(include_expsyms, $1)= + # exclude_expsyms can be an extended regexp of symbols to exclude + # it will be wrapped by ` (' and `)$', so one must not match beginning or + # end of line. Example: `a|bc|.*d.*' will exclude the symbols `a' and `bc', + # as well as any symbol that contains `d'. + _LT_TAGVAR(exclude_expsyms, $1)=['_GLOBAL_OFFSET_TABLE_|_GLOBAL__F[ID]_.*'] + # Although _GLOBAL_OFFSET_TABLE_ is a valid symbol C name, most a.out + # platforms (ab)use it in PIC code, but their linkers get confused if + # the symbol is explicitly referenced. Since portable code cannot + # rely on this symbol name, it's probably fine to never include it in + # preloaded symbol tables. + # Exclude shared library initialization/finalization symbols. +dnl Note also adjust exclude_expsyms for C++ above. + extract_expsyms_cmds= + + case $host_os in + cygwin* | mingw* | pw32* | cegcc*) + # FIXME: the MSVC++ port hasn't been tested in a loooong time + # When not using gcc, we currently assume that we are using + # Microsoft Visual C++. + if test "$GCC" != yes; then + with_gnu_ld=no + fi + ;; + interix*) + # we just hope/assume this is gcc and not c89 (= MSVC++) + with_gnu_ld=yes + ;; + openbsd*) + with_gnu_ld=no + ;; + linux* | k*bsd*-gnu | gnu*) + _LT_TAGVAR(link_all_deplibs, $1)=no + ;; + esac + + _LT_TAGVAR(ld_shlibs, $1)=yes + + # On some targets, GNU ld is compatible enough with the native linker + # that we're better off using the native interface for both. + lt_use_gnu_ld_interface=no + if test "$with_gnu_ld" = yes; then + case $host_os in + aix*) + # The AIX port of GNU ld has always aspired to compatibility + # with the native linker. However, as the warning in the GNU ld + # block says, versions before 2.19.5* couldn't really create working + # shared libraries, regardless of the interface used. + case `$LD -v 2>&1` in + *\ \(GNU\ Binutils\)\ 2.19.5*) ;; + *\ \(GNU\ Binutils\)\ 2.[[2-9]]*) ;; + *\ \(GNU\ Binutils\)\ [[3-9]]*) ;; + *) + lt_use_gnu_ld_interface=yes + ;; + esac + ;; + *) + lt_use_gnu_ld_interface=yes + ;; + esac + fi + + if test "$lt_use_gnu_ld_interface" = yes; then + # If archive_cmds runs LD, not CC, wlarc should be empty + wlarc='${wl}' + + # Set some defaults for GNU ld with shared library support. These + # are reset later if shared libraries are not supported. Putting them + # here allows them to be overridden if necessary. + runpath_var=LD_RUN_PATH + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' + _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic' + # ancient GNU ld didn't support --whole-archive et. al. + if $LD --help 2>&1 | $GREP 'no-whole-archive' > /dev/null; then + _LT_TAGVAR(whole_archive_flag_spec, $1)="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive' + else + _LT_TAGVAR(whole_archive_flag_spec, $1)= + fi + supports_anon_versioning=no + case `$LD -v 2>&1` in + *GNU\ gold*) supports_anon_versioning=yes ;; + *\ [[01]].* | *\ 2.[[0-9]].* | *\ 2.10.*) ;; # catch versions < 2.11 + *\ 2.11.93.0.2\ *) supports_anon_versioning=yes ;; # RH7.3 ... + *\ 2.11.92.0.12\ *) supports_anon_versioning=yes ;; # Mandrake 8.2 ... + *\ 2.11.*) ;; # other 2.11 versions + *) supports_anon_versioning=yes ;; + esac + + # See if GNU ld supports shared libraries. + case $host_os in + aix[[3-9]]*) + # On AIX/PPC, the GNU linker is very broken + if test "$host_cpu" != ia64; then + _LT_TAGVAR(ld_shlibs, $1)=no + cat <<_LT_EOF 1>&2 + +*** Warning: the GNU linker, at least up to release 2.19, is reported +*** to be unable to reliably create shared libraries on AIX. +*** Therefore, libtool is disabling shared libraries support. If you +*** really care for shared libraries, you may want to install binutils +*** 2.20 or above, or modify your PATH so that a non-GNU linker is found. +*** You will then need to restart the configuration process. + +_LT_EOF + fi + ;; + + amigaos*) + case $host_cpu in + powerpc) + # see comment about AmigaOS4 .so support + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='' + ;; + m68k) + _LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/a2ixlibrary.data~$ECHO "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$ECHO "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$ECHO "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$ECHO "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' + _LT_TAGVAR(hardcode_minus_L, $1)=yes + ;; + esac + ;; + + beos*) + if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then + _LT_TAGVAR(allow_undefined_flag, $1)=unsupported + # Joseph Beckenbach says some releases of gcc + # support --undefined. This deserves some investigation. FIXME + _LT_TAGVAR(archive_cmds, $1)='$CC -nostart $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + else + _LT_TAGVAR(ld_shlibs, $1)=no + fi + ;; + + cygwin* | mingw* | pw32* | cegcc*) + # _LT_TAGVAR(hardcode_libdir_flag_spec, $1) is actually meaningless, + # as there is no search path for DLLs. + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' + _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-all-symbols' + _LT_TAGVAR(allow_undefined_flag, $1)=unsupported + _LT_TAGVAR(always_export_symbols, $1)=no + _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes + _LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[[BCDGRS]][[ ]]/s/.*[[ ]]\([[^ ]]*\)/\1 DATA/;s/^.*[[ ]]__nm__\([[^ ]]*\)[[ ]][[^ ]]*/\1 DATA/;/^I[[ ]]/d;/^[[AITW]][[ ]]/s/.* //'\'' | sort | uniq > $export_symbols' + _LT_TAGVAR(exclude_expsyms, $1)=['[_]+GLOBAL_OFFSET_TABLE_|[_]+GLOBAL__[FID]_.*|[_]+head_[A-Za-z0-9_]+_dll|[A-Za-z0-9_]+_dll_iname'] + + if $LD --help 2>&1 | $GREP 'auto-import' > /dev/null; then + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib' + # If the export-symbols file already is a .def file (1st line + # is EXPORTS), use it as is; otherwise, prepend... + _LT_TAGVAR(archive_expsym_cmds, $1)='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then + cp $export_symbols $output_objdir/$soname.def; + else + echo EXPORTS > $output_objdir/$soname.def; + cat $export_symbols >> $output_objdir/$soname.def; + fi~ + $CC -shared $output_objdir/$soname.def $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib' + else + _LT_TAGVAR(ld_shlibs, $1)=no + fi + ;; + + haiku*) + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + _LT_TAGVAR(link_all_deplibs, $1)=yes + ;; + + interix[[3-9]]*) + _LT_TAGVAR(hardcode_direct, $1)=no + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir' + _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E' + # Hack: On Interix 3.x, we cannot compile PIC because of a broken gcc. + # Instead, shared libraries are loaded at an image base (0x10000000 by + # default) and relocated if they conflict, which is a slow very memory + # consuming and fragmenting process. To avoid this, we pick a random, + # 256 KiB-aligned image base between 0x50000000 and 0x6FFC0000 at link + # time. Moving up from 0x10000000 also allows more sbrk(2) space. + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='sed "s,^,_," $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--retain-symbols-file,$output_objdir/$soname.expsym ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib' + ;; + + gnu* | linux* | tpf* | k*bsd*-gnu | kopensolaris*-gnu) + tmp_diet=no + if test "$host_os" = linux-dietlibc; then + case $cc_basename in + diet\ *) tmp_diet=yes;; # linux-dietlibc with static linking (!diet-dyn) + esac + fi + if $LD --help 2>&1 | $EGREP ': supported targets:.* elf' > /dev/null \ + && test "$tmp_diet" = no + then + tmp_addflag=' $pic_flag' + tmp_sharedflag='-shared' + case $cc_basename,$host_cpu in + pgcc*) # Portland Group C compiler + _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive' + tmp_addflag=' $pic_flag' + ;; + pgf77* | pgf90* | pgf95* | pgfortran*) + # Portland Group f77 and f90 compilers + _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive' + tmp_addflag=' $pic_flag -Mnomain' ;; + ecc*,ia64* | icc*,ia64*) # Intel C compiler on ia64 + tmp_addflag=' -i_dynamic' ;; + efc*,ia64* | ifort*,ia64*) # Intel Fortran compiler on ia64 + tmp_addflag=' -i_dynamic -nofor_main' ;; + ifc* | ifort*) # Intel Fortran compiler + tmp_addflag=' -nofor_main' ;; + lf95*) # Lahey Fortran 8.1 + _LT_TAGVAR(whole_archive_flag_spec, $1)= + tmp_sharedflag='--shared' ;; + xl[[cC]]* | bgxl[[cC]]* | mpixl[[cC]]*) # IBM XL C 8.0 on PPC (deal with xlf below) + tmp_sharedflag='-qmkshrobj' + tmp_addflag= ;; + nvcc*) # Cuda Compiler Driver 2.2 + _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive' + _LT_TAGVAR(compiler_needs_object, $1)=yes + ;; + esac + case `$CC -V 2>&1 | sed 5q` in + *Sun\ C*) # Sun C 5.9 + _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`new_convenience=; for conv in $convenience\"\"; do test -z \"$conv\" || new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive' + _LT_TAGVAR(compiler_needs_object, $1)=yes + tmp_sharedflag='-G' ;; + *Sun\ F*) # Sun Fortran 8.3 + tmp_sharedflag='-G' ;; + esac + _LT_TAGVAR(archive_cmds, $1)='$CC '"$tmp_sharedflag""$tmp_addflag"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + + if test "x$supports_anon_versioning" = xyes; then + _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $output_objdir/$libname.ver~ + cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~ + echo "local: *; };" >> $output_objdir/$libname.ver~ + $CC '"$tmp_sharedflag""$tmp_addflag"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-version-script ${wl}$output_objdir/$libname.ver -o $lib' + fi + + case $cc_basename in + xlf* | bgf* | bgxlf* | mpixlf*) + # IBM XL Fortran 10.1 on PPC cannot create shared libs itself + _LT_TAGVAR(whole_archive_flag_spec, $1)='--whole-archive$convenience --no-whole-archive' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' + _LT_TAGVAR(archive_cmds, $1)='$LD -shared $libobjs $deplibs $linker_flags -soname $soname -o $lib' + if test "x$supports_anon_versioning" = xyes; then + _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $output_objdir/$libname.ver~ + cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~ + echo "local: *; };" >> $output_objdir/$libname.ver~ + $LD -shared $libobjs $deplibs $linker_flags -soname $soname -version-script $output_objdir/$libname.ver -o $lib' + fi + ;; + esac + else + _LT_TAGVAR(ld_shlibs, $1)=no + fi + ;; + + netbsd* | netbsdelf*-gnu) + if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then + _LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable $libobjs $deplibs $linker_flags -o $lib' + wlarc= + else + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + fi + ;; + + solaris*) + if $LD -v 2>&1 | $GREP 'BFD 2\.8' > /dev/null; then + _LT_TAGVAR(ld_shlibs, $1)=no + cat <<_LT_EOF 1>&2 + +*** Warning: The releases 2.8.* of the GNU linker cannot reliably +*** create shared libraries on Solaris systems. Therefore, libtool +*** is disabling shared libraries support. We urge you to upgrade GNU +*** binutils to release 2.9.1 or newer. Another option is to modify +*** your PATH or compiler configuration so that the native linker is +*** used, and then restart. + +_LT_EOF + elif $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + else + _LT_TAGVAR(ld_shlibs, $1)=no + fi + ;; + + sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX*) + case `$LD -v 2>&1` in + *\ [[01]].* | *\ 2.[[0-9]].* | *\ 2.1[[0-5]].*) + _LT_TAGVAR(ld_shlibs, $1)=no + cat <<_LT_EOF 1>&2 + +*** Warning: Releases of the GNU linker prior to 2.16.91.0.3 can not +*** reliably create shared libraries on SCO systems. Therefore, libtool +*** is disabling shared libraries support. We urge you to upgrade GNU +*** binutils to release 2.16.91.0.3 or newer. Another option is to modify +*** your PATH or compiler configuration so that the native linker is +*** used, and then restart. + +_LT_EOF + ;; + *) + # For security reasons, it is highly recommended that you always + # use absolute paths for naming shared libraries, and exclude the + # DT_RUNPATH tag from executables and libraries. But doing so + # requires that you compile everything twice, which is a pain. + if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + else + _LT_TAGVAR(ld_shlibs, $1)=no + fi + ;; + esac + ;; + + sunos4*) + _LT_TAGVAR(archive_cmds, $1)='$LD -assert pure-text -Bshareable -o $lib $libobjs $deplibs $linker_flags' + wlarc= + _LT_TAGVAR(hardcode_direct, $1)=yes + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + ;; + + *) + if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + else + _LT_TAGVAR(ld_shlibs, $1)=no + fi + ;; + esac + + if test "$_LT_TAGVAR(ld_shlibs, $1)" = no; then + runpath_var= + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)= + _LT_TAGVAR(export_dynamic_flag_spec, $1)= + _LT_TAGVAR(whole_archive_flag_spec, $1)= + fi + else + # PORTME fill in a description of your system's linker (not GNU ld) + case $host_os in + aix3*) + _LT_TAGVAR(allow_undefined_flag, $1)=unsupported + _LT_TAGVAR(always_export_symbols, $1)=yes + _LT_TAGVAR(archive_expsym_cmds, $1)='$LD -o $output_objdir/$soname $libobjs $deplibs $linker_flags -bE:$export_symbols -T512 -H512 -bM:SRE~$AR $AR_FLAGS $lib $output_objdir/$soname' + # Note: this linker hardcodes the directories in LIBPATH if there + # are no directories specified by -L. + _LT_TAGVAR(hardcode_minus_L, $1)=yes + if test "$GCC" = yes && test -z "$lt_prog_compiler_static"; then + # Neither direct hardcoding nor static linking is supported with a + # broken collect2. + _LT_TAGVAR(hardcode_direct, $1)=unsupported + fi + ;; + + aix[[4-9]]*) + if test "$host_cpu" = ia64; then + # On IA64, the linker does run time linking by default, so we don't + # have to do anything special. + aix_use_runtimelinking=no + exp_sym_flag='-Bexport' + no_entry_flag="" + else + # If we're using GNU nm, then we don't want the "-C" option. + # -C means demangle to AIX nm, but means don't demangle with GNU nm + # Also, AIX nm treats weak defined symbols like other global + # defined symbols, whereas GNU nm marks them as "W". + if $NM -V 2>&1 | $GREP 'GNU' > /dev/null; then + _LT_TAGVAR(export_symbols_cmds, $1)='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W")) && ([substr](\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols' + else + _LT_TAGVAR(export_symbols_cmds, $1)='$NM -BCpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B")) && ([substr](\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols' + fi + aix_use_runtimelinking=no + + # Test if we are trying to use run time linking or normal + # AIX style linking. If -brtl is somewhere in LDFLAGS, we + # need to do runtime linking. + case $host_os in aix4.[[23]]|aix4.[[23]].*|aix[[5-9]]*) + for ld_flag in $LDFLAGS; do + if (test $ld_flag = "-brtl" || test $ld_flag = "-Wl,-brtl"); then + aix_use_runtimelinking=yes + break + fi + done + ;; + esac + + exp_sym_flag='-bexport' + no_entry_flag='-bnoentry' + fi + + # When large executables or shared objects are built, AIX ld can + # have problems creating the table of contents. If linking a library + # or program results in "error TOC overflow" add -mminimal-toc to + # CXXFLAGS/CFLAGS for g++/gcc. In the cases where that is not + # enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS. + + _LT_TAGVAR(archive_cmds, $1)='' + _LT_TAGVAR(hardcode_direct, $1)=yes + _LT_TAGVAR(hardcode_direct_absolute, $1)=yes + _LT_TAGVAR(hardcode_libdir_separator, $1)=':' + _LT_TAGVAR(link_all_deplibs, $1)=yes + _LT_TAGVAR(file_list_spec, $1)='${wl}-f,' + + if test "$GCC" = yes; then + case $host_os in aix4.[[012]]|aix4.[[012]].*) + # We only want to do this on AIX 4.2 and lower, the check + # below for broken collect2 doesn't work under 4.3+ + collect2name=`${CC} -print-prog-name=collect2` + if test -f "$collect2name" && + strings "$collect2name" | $GREP resolve_lib_name >/dev/null + then + # We have reworked collect2 + : + else + # We have old collect2 + _LT_TAGVAR(hardcode_direct, $1)=unsupported + # It fails to find uninstalled libraries when the uninstalled + # path is not listed in the libpath. Setting hardcode_minus_L + # to unsupported forces relinking + _LT_TAGVAR(hardcode_minus_L, $1)=yes + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' + _LT_TAGVAR(hardcode_libdir_separator, $1)= + fi + ;; + esac + shared_flag='-shared' + if test "$aix_use_runtimelinking" = yes; then + shared_flag="$shared_flag "'${wl}-G' + fi + _LT_TAGVAR(link_all_deplibs, $1)=no + else + # not using gcc + if test "$host_cpu" = ia64; then + # VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release + # chokes on -Wl,-G. The following line is correct: + shared_flag='-G' + else + if test "$aix_use_runtimelinking" = yes; then + shared_flag='${wl}-G' + else + shared_flag='${wl}-bM:SRE' + fi + fi + fi + + _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-bexpall' + # It seems that -bexpall does not export symbols beginning with + # underscore (_), so it is better to generate a list of symbols to export. + _LT_TAGVAR(always_export_symbols, $1)=yes + if test "$aix_use_runtimelinking" = yes; then + # Warning - without using the other runtime loading flags (-brtl), + # -berok will link without error, but may produce a broken library. + _LT_TAGVAR(allow_undefined_flag, $1)='-berok' + # Determine the default libpath from the value encoded in an + # empty executable. + _LT_SYS_MODULE_PATH_AIX([$1]) + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-blibpath:$libdir:'"$aix_libpath" + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then func_echo_all "${wl}${allow_undefined_flag}"; else :; fi` '"\${wl}$exp_sym_flag:\$export_symbols $shared_flag" + else + if test "$host_cpu" = ia64; then + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R $libdir:/usr/lib:/lib' + _LT_TAGVAR(allow_undefined_flag, $1)="-z nodefs" + _LT_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$exp_sym_flag:\$export_symbols" + else + # Determine the default libpath from the value encoded in an + # empty executable. + _LT_SYS_MODULE_PATH_AIX([$1]) + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-blibpath:$libdir:'"$aix_libpath" + # Warning - without using the other run time loading flags, + # -berok will link without error, but may produce a broken library. + _LT_TAGVAR(no_undefined_flag, $1)=' ${wl}-bernotok' + _LT_TAGVAR(allow_undefined_flag, $1)=' ${wl}-berok' + if test "$with_gnu_ld" = yes; then + # We only use this code for GNU lds that support --whole-archive. + _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive$convenience ${wl}--no-whole-archive' + else + # Exported symbols can be pulled into shared objects from archives + _LT_TAGVAR(whole_archive_flag_spec, $1)='$convenience' + fi + _LT_TAGVAR(archive_cmds_need_lc, $1)=yes + # This is similar to how AIX traditionally builds its shared libraries. + _LT_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs ${wl}-bnoentry $compiler_flags ${wl}-bE:$export_symbols${allow_undefined_flag}~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$soname' + fi + fi + ;; + + amigaos*) + case $host_cpu in + powerpc) + # see comment about AmigaOS4 .so support + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='' + ;; + m68k) + _LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/a2ixlibrary.data~$ECHO "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$ECHO "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$ECHO "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$ECHO "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' + _LT_TAGVAR(hardcode_minus_L, $1)=yes + ;; + esac + ;; + + bsdi[[45]]*) + _LT_TAGVAR(export_dynamic_flag_spec, $1)=-rdynamic + ;; + + cygwin* | mingw* | pw32* | cegcc*) + # When not using gcc, we currently assume that we are using + # Microsoft Visual C++. + # hardcode_libdir_flag_spec is actually meaningless, as there is + # no search path for DLLs. + case $cc_basename in + cl*) + # Native MSVC + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)=' ' + _LT_TAGVAR(allow_undefined_flag, $1)=unsupported + _LT_TAGVAR(always_export_symbols, $1)=yes + _LT_TAGVAR(file_list_spec, $1)='@' + # Tell ltmain to make .lib files, not .a files. + libext=lib + # Tell ltmain to make .dll files, not .so files. + shrext_cmds=".dll" + # FIXME: Setting linknames here is a bad hack. + _LT_TAGVAR(archive_cmds, $1)='$CC -o $output_objdir/$soname $libobjs $compiler_flags $deplibs -Wl,-dll~linknames=' + _LT_TAGVAR(archive_expsym_cmds, $1)='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then + sed -n -e 's/\\\\\\\(.*\\\\\\\)/-link\\\ -EXPORT:\\\\\\\1/' -e '1\\\!p' < $export_symbols > $output_objdir/$soname.exp; + else + sed -e 's/\\\\\\\(.*\\\\\\\)/-link\\\ -EXPORT:\\\\\\\1/' < $export_symbols > $output_objdir/$soname.exp; + fi~ + $CC -o $tool_output_objdir$soname $libobjs $compiler_flags $deplibs "@$tool_output_objdir$soname.exp" -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~ + linknames=' + # The linker will not automatically build a static lib if we build a DLL. + # _LT_TAGVAR(old_archive_from_new_cmds, $1)='true' + _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes + _LT_TAGVAR(exclude_expsyms, $1)='_NULL_IMPORT_DESCRIPTOR|_IMPORT_DESCRIPTOR_.*' + _LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[[BCDGRS]][[ ]]/s/.*[[ ]]\([[^ ]]*\)/\1,DATA/'\'' | $SED -e '\''/^[[AITW]][[ ]]/s/.*[[ ]]//'\'' | sort | uniq > $export_symbols' + # Don't use ranlib + _LT_TAGVAR(old_postinstall_cmds, $1)='chmod 644 $oldlib' + _LT_TAGVAR(postlink_cmds, $1)='lt_outputfile="@OUTPUT@"~ + lt_tool_outputfile="@TOOL_OUTPUT@"~ + case $lt_outputfile in + *.exe|*.EXE) ;; + *) + lt_outputfile="$lt_outputfile.exe" + lt_tool_outputfile="$lt_tool_outputfile.exe" + ;; + esac~ + if test "$MANIFEST_TOOL" != ":" && test -f "$lt_outputfile.manifest"; then + $MANIFEST_TOOL -manifest "$lt_tool_outputfile.manifest" -outputresource:"$lt_tool_outputfile" || exit 1; + $RM "$lt_outputfile.manifest"; + fi' + ;; + *) + # Assume MSVC wrapper + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)=' ' + _LT_TAGVAR(allow_undefined_flag, $1)=unsupported + # Tell ltmain to make .lib files, not .a files. + libext=lib + # Tell ltmain to make .dll files, not .so files. + shrext_cmds=".dll" + # FIXME: Setting linknames here is a bad hack. + _LT_TAGVAR(archive_cmds, $1)='$CC -o $lib $libobjs $compiler_flags `func_echo_all "$deplibs" | $SED '\''s/ -lc$//'\''` -link -dll~linknames=' + # The linker will automatically build a .lib file if we build a DLL. + _LT_TAGVAR(old_archive_from_new_cmds, $1)='true' + # FIXME: Should let the user specify the lib program. + _LT_TAGVAR(old_archive_cmds, $1)='lib -OUT:$oldlib$oldobjs$old_deplibs' + _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes + ;; + esac + ;; + + darwin* | rhapsody*) + _LT_DARWIN_LINKER_FEATURES($1) + ;; + + dgux*) + _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + ;; + + # FreeBSD 2.2.[012] allows us to include c++rt0.o to get C++ constructor + # support. Future versions do this automatically, but an explicit c++rt0.o + # does not break anything, and helps significantly (at the cost of a little + # extra space). + freebsd2.2*) + _LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags /usr/lib/c++rt0.o' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir' + _LT_TAGVAR(hardcode_direct, $1)=yes + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + ;; + + # Unfortunately, older versions of FreeBSD 2 do not have this feature. + freebsd2.*) + _LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags' + _LT_TAGVAR(hardcode_direct, $1)=yes + _LT_TAGVAR(hardcode_minus_L, $1)=yes + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + ;; + + # FreeBSD 3 and greater uses gcc -shared to do shared libraries. + freebsd* | dragonfly*) + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir' + _LT_TAGVAR(hardcode_direct, $1)=yes + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + ;; + + hpux9*) + if test "$GCC" = yes; then + _LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/$soname~$CC -shared $pic_flag ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $libobjs $deplibs $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib' + else + _LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/$soname~$LD -b +b $install_libdir -o $output_objdir/$soname $libobjs $deplibs $linker_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib' + fi + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir' + _LT_TAGVAR(hardcode_libdir_separator, $1)=: + _LT_TAGVAR(hardcode_direct, $1)=yes + + # hardcode_minus_L: Not really in the search PATH, + # but as the default location of the library. + _LT_TAGVAR(hardcode_minus_L, $1)=yes + _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E' + ;; + + hpux10*) + if test "$GCC" = yes && test "$with_gnu_ld" = no; then + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags' + else + _LT_TAGVAR(archive_cmds, $1)='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags' + fi + if test "$with_gnu_ld" = no; then + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir' + _LT_TAGVAR(hardcode_libdir_separator, $1)=: + _LT_TAGVAR(hardcode_direct, $1)=yes + _LT_TAGVAR(hardcode_direct_absolute, $1)=yes + _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E' + # hardcode_minus_L: Not really in the search PATH, + # but as the default location of the library. + _LT_TAGVAR(hardcode_minus_L, $1)=yes + fi + ;; + + hpux11*) + if test "$GCC" = yes && test "$with_gnu_ld" = no; then + case $host_cpu in + hppa*64*) + _LT_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}+h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags' + ;; + ia64*) + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags' + ;; + *) + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags' + ;; + esac + else + case $host_cpu in + hppa*64*) + _LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags' + ;; + ia64*) + _LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags' + ;; + *) + m4_if($1, [], [ + # Older versions of the 11.00 compiler do not understand -b yet + # (HP92453-01 A.11.01.20 doesn't, HP92453-01 B.11.X.35175-35176.GP does) + _LT_LINKER_OPTION([if $CC understands -b], + _LT_TAGVAR(lt_cv_prog_compiler__b, $1), [-b], + [_LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'], + [_LT_TAGVAR(archive_cmds, $1)='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags'])], + [_LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags']) + ;; + esac + fi + if test "$with_gnu_ld" = no; then + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir' + _LT_TAGVAR(hardcode_libdir_separator, $1)=: + + case $host_cpu in + hppa*64*|ia64*) + _LT_TAGVAR(hardcode_direct, $1)=no + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + ;; + *) + _LT_TAGVAR(hardcode_direct, $1)=yes + _LT_TAGVAR(hardcode_direct_absolute, $1)=yes + _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E' + + # hardcode_minus_L: Not really in the search PATH, + # but as the default location of the library. + _LT_TAGVAR(hardcode_minus_L, $1)=yes + ;; + esac + fi + ;; + + irix5* | irix6* | nonstopux*) + if test "$GCC" = yes; then + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' + # Try to use the -exported_symbol ld option, if it does not + # work, assume that -exports_file does not work either and + # implicitly export all symbols. + # This should be the same for all languages, so no per-tag cache variable. + AC_CACHE_CHECK([whether the $host_os linker accepts -exported_symbol], + [lt_cv_irix_exported_symbol], + [save_LDFLAGS="$LDFLAGS" + LDFLAGS="$LDFLAGS -shared ${wl}-exported_symbol ${wl}foo ${wl}-update_registry ${wl}/dev/null" + AC_LINK_IFELSE( + [AC_LANG_SOURCE( + [AC_LANG_CASE([C], [[int foo (void) { return 0; }]], + [C++], [[int foo (void) { return 0; }]], + [Fortran 77], [[ + subroutine foo + end]], + [Fortran], [[ + subroutine foo + end]])])], + [lt_cv_irix_exported_symbol=yes], + [lt_cv_irix_exported_symbol=no]) + LDFLAGS="$save_LDFLAGS"]) + if test "$lt_cv_irix_exported_symbol" = yes; then + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations ${wl}-exports_file ${wl}$export_symbols -o $lib' + fi + else + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -exports_file $export_symbols -o $lib' + fi + _LT_TAGVAR(archive_cmds_need_lc, $1)='no' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' + _LT_TAGVAR(hardcode_libdir_separator, $1)=: + _LT_TAGVAR(inherit_rpath, $1)=yes + _LT_TAGVAR(link_all_deplibs, $1)=yes + ;; + + netbsd* | netbsdelf*-gnu) + if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then + _LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags' # a.out + else + _LT_TAGVAR(archive_cmds, $1)='$LD -shared -o $lib $libobjs $deplibs $linker_flags' # ELF + fi + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir' + _LT_TAGVAR(hardcode_direct, $1)=yes + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + ;; + + newsos6) + _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + _LT_TAGVAR(hardcode_direct, $1)=yes + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' + _LT_TAGVAR(hardcode_libdir_separator, $1)=: + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + ;; + + *nto* | *qnx*) + ;; + + openbsd*) + if test -f /usr/libexec/ld.so; then + _LT_TAGVAR(hardcode_direct, $1)=yes + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + _LT_TAGVAR(hardcode_direct_absolute, $1)=yes + if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags ${wl}-retain-symbols-file,$export_symbols' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir' + _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E' + else + case $host_os in + openbsd[[01]].* | openbsd2.[[0-7]] | openbsd2.[[0-7]].*) + _LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir' + ;; + *) + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir' + ;; + esac + fi + else + _LT_TAGVAR(ld_shlibs, $1)=no + fi + ;; + + os2*) + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' + _LT_TAGVAR(hardcode_minus_L, $1)=yes + _LT_TAGVAR(allow_undefined_flag, $1)=unsupported + _LT_TAGVAR(archive_cmds, $1)='$ECHO "LIBRARY $libname INITINSTANCE" > $output_objdir/$libname.def~$ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~echo DATA >> $output_objdir/$libname.def~echo " SINGLE NONSHARED" >> $output_objdir/$libname.def~echo EXPORTS >> $output_objdir/$libname.def~emxexp $libobjs >> $output_objdir/$libname.def~$CC -Zdll -Zcrtdll -o $lib $libobjs $deplibs $compiler_flags $output_objdir/$libname.def' + _LT_TAGVAR(old_archive_from_new_cmds, $1)='emximp -o $output_objdir/$libname.a $output_objdir/$libname.def' + ;; + + osf3*) + if test "$GCC" = yes; then + _LT_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*' + _LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' + else + _LT_TAGVAR(allow_undefined_flag, $1)=' -expect_unresolved \*' + _LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib' + fi + _LT_TAGVAR(archive_cmds_need_lc, $1)='no' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' + _LT_TAGVAR(hardcode_libdir_separator, $1)=: + ;; + + osf4* | osf5*) # as osf3* with the addition of -msym flag + if test "$GCC" = yes; then + _LT_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*' + _LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $pic_flag $libobjs $deplibs $compiler_flags ${wl}-msym ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' + else + _LT_TAGVAR(allow_undefined_flag, $1)=' -expect_unresolved \*' + _LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags -msym -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done; printf "%s\\n" "-hidden">> $lib.exp~ + $CC -shared${allow_undefined_flag} ${wl}-input ${wl}$lib.exp $compiler_flags $libobjs $deplibs -soname $soname `test -n "$verstring" && $ECHO "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib~$RM $lib.exp' + + # Both c and cxx compiler support -rpath directly + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-rpath $libdir' + fi + _LT_TAGVAR(archive_cmds_need_lc, $1)='no' + _LT_TAGVAR(hardcode_libdir_separator, $1)=: + ;; + + solaris*) + _LT_TAGVAR(no_undefined_flag, $1)=' -z defs' + if test "$GCC" = yes; then + wlarc='${wl}' + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag ${wl}-z ${wl}text ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags' + _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~ + $CC -shared $pic_flag ${wl}-z ${wl}text ${wl}-M ${wl}$lib.exp ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags~$RM $lib.exp' + else + case `$CC -V 2>&1` in + *"Compilers 5.0"*) + wlarc='' + _LT_TAGVAR(archive_cmds, $1)='$LD -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $linker_flags' + _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~ + $LD -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $linker_flags~$RM $lib.exp' + ;; + *) + wlarc='${wl}' + _LT_TAGVAR(archive_cmds, $1)='$CC -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $compiler_flags' + _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~ + $CC -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $compiler_flags~$RM $lib.exp' + ;; + esac + fi + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir' + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + case $host_os in + solaris2.[[0-5]] | solaris2.[[0-5]].*) ;; + *) + # The compiler driver will combine and reorder linker options, + # but understands `-z linker_flag'. GCC discards it without `$wl', + # but is careful enough not to reorder. + # Supported since Solaris 2.6 (maybe 2.5.1?) + if test "$GCC" = yes; then + _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}-z ${wl}allextract$convenience ${wl}-z ${wl}defaultextract' + else + _LT_TAGVAR(whole_archive_flag_spec, $1)='-z allextract$convenience -z defaultextract' + fi + ;; + esac + _LT_TAGVAR(link_all_deplibs, $1)=yes + ;; + + sunos4*) + if test "x$host_vendor" = xsequent; then + # Use $CC to link under sequent, because it throws in some extra .o + # files that make .init and .fini sections work. + _LT_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h $soname -o $lib $libobjs $deplibs $compiler_flags' + else + _LT_TAGVAR(archive_cmds, $1)='$LD -assert pure-text -Bstatic -o $lib $libobjs $deplibs $linker_flags' + fi + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' + _LT_TAGVAR(hardcode_direct, $1)=yes + _LT_TAGVAR(hardcode_minus_L, $1)=yes + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + ;; + + sysv4) + case $host_vendor in + sni) + _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + _LT_TAGVAR(hardcode_direct, $1)=yes # is this really true??? + ;; + siemens) + ## LD is ld it makes a PLAMLIB + ## CC just makes a GrossModule. + _LT_TAGVAR(archive_cmds, $1)='$LD -G -o $lib $libobjs $deplibs $linker_flags' + _LT_TAGVAR(reload_cmds, $1)='$CC -r -o $output$reload_objs' + _LT_TAGVAR(hardcode_direct, $1)=no + ;; + motorola) + _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + _LT_TAGVAR(hardcode_direct, $1)=no #Motorola manual says yes, but my tests say they lie + ;; + esac + runpath_var='LD_RUN_PATH' + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + ;; + + sysv4.3*) + _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + _LT_TAGVAR(export_dynamic_flag_spec, $1)='-Bexport' + ;; + + sysv4*MP*) + if test -d /usr/nec; then + _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + runpath_var=LD_RUN_PATH + hardcode_runpath_var=yes + _LT_TAGVAR(ld_shlibs, $1)=yes + fi + ;; + + sysv4*uw2* | sysv5OpenUNIX* | sysv5UnixWare7.[[01]].[[10]]* | unixware7* | sco3.2v5.0.[[024]]*) + _LT_TAGVAR(no_undefined_flag, $1)='${wl}-z,text' + _LT_TAGVAR(archive_cmds_need_lc, $1)=no + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + runpath_var='LD_RUN_PATH' + + if test "$GCC" = yes; then + _LT_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + else + _LT_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + fi + ;; + + sysv5* | sco3.2v5* | sco5v6*) + # Note: We can NOT use -z defs as we might desire, because we do not + # link with -lc, and that would cause any symbols used from libc to + # always be unresolved, which means just about no library would + # ever link correctly. If we're not using GNU ld we use -z text + # though, which does catch some bad symbols but isn't as heavy-handed + # as -z defs. + _LT_TAGVAR(no_undefined_flag, $1)='${wl}-z,text' + _LT_TAGVAR(allow_undefined_flag, $1)='${wl}-z,nodefs' + _LT_TAGVAR(archive_cmds_need_lc, $1)=no + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R,$libdir' + _LT_TAGVAR(hardcode_libdir_separator, $1)=':' + _LT_TAGVAR(link_all_deplibs, $1)=yes + _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-Bexport' + runpath_var='LD_RUN_PATH' + + if test "$GCC" = yes; then + _LT_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + else + _LT_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + fi + ;; + + uts4*) + _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + ;; + + *) + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + esac + + if test x$host_vendor = xsni; then + case $host in + sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*) + _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-Blargedynsym' + ;; + esac + fi + fi +]) +AC_MSG_RESULT([$_LT_TAGVAR(ld_shlibs, $1)]) +test "$_LT_TAGVAR(ld_shlibs, $1)" = no && can_build_shared=no + +_LT_TAGVAR(with_gnu_ld, $1)=$with_gnu_ld + +_LT_DECL([], [libext], [0], [Old archive suffix (normally "a")])dnl +_LT_DECL([], [shrext_cmds], [1], [Shared library suffix (normally ".so")])dnl +_LT_DECL([], [extract_expsyms_cmds], [2], + [The commands to extract the exported symbol list from a shared archive]) + +# +# Do we need to explicitly link libc? +# +case "x$_LT_TAGVAR(archive_cmds_need_lc, $1)" in +x|xyes) + # Assume -lc should be added + _LT_TAGVAR(archive_cmds_need_lc, $1)=yes + + if test "$enable_shared" = yes && test "$GCC" = yes; then + case $_LT_TAGVAR(archive_cmds, $1) in + *'~'*) + # FIXME: we may have to deal with multi-command sequences. + ;; + '$CC '*) + # Test whether the compiler implicitly links with -lc since on some + # systems, -lgcc has to come before -lc. If gcc already passes -lc + # to ld, don't add -lc before -lgcc. + AC_CACHE_CHECK([whether -lc should be explicitly linked in], + [lt_cv_]_LT_TAGVAR(archive_cmds_need_lc, $1), + [$RM conftest* + echo "$lt_simple_compile_test_code" > conftest.$ac_ext + + if AC_TRY_EVAL(ac_compile) 2>conftest.err; then + soname=conftest + lib=conftest + libobjs=conftest.$ac_objext + deplibs= + wl=$_LT_TAGVAR(lt_prog_compiler_wl, $1) + pic_flag=$_LT_TAGVAR(lt_prog_compiler_pic, $1) + compiler_flags=-v + linker_flags=-v + verstring= + output_objdir=. + libname=conftest + lt_save_allow_undefined_flag=$_LT_TAGVAR(allow_undefined_flag, $1) + _LT_TAGVAR(allow_undefined_flag, $1)= + if AC_TRY_EVAL(_LT_TAGVAR(archive_cmds, $1) 2\>\&1 \| $GREP \" -lc \" \>/dev/null 2\>\&1) + then + lt_cv_[]_LT_TAGVAR(archive_cmds_need_lc, $1)=no + else + lt_cv_[]_LT_TAGVAR(archive_cmds_need_lc, $1)=yes + fi + _LT_TAGVAR(allow_undefined_flag, $1)=$lt_save_allow_undefined_flag + else + cat conftest.err 1>&5 + fi + $RM conftest* + ]) + _LT_TAGVAR(archive_cmds_need_lc, $1)=$lt_cv_[]_LT_TAGVAR(archive_cmds_need_lc, $1) + ;; + esac + fi + ;; +esac + +_LT_TAGDECL([build_libtool_need_lc], [archive_cmds_need_lc], [0], + [Whether or not to add -lc for building shared libraries]) +_LT_TAGDECL([allow_libtool_libs_with_static_runtimes], + [enable_shared_with_static_runtimes], [0], + [Whether or not to disallow shared libs when runtime libs are static]) +_LT_TAGDECL([], [export_dynamic_flag_spec], [1], + [Compiler flag to allow reflexive dlopens]) +_LT_TAGDECL([], [whole_archive_flag_spec], [1], + [Compiler flag to generate shared objects directly from archives]) +_LT_TAGDECL([], [compiler_needs_object], [1], + [Whether the compiler copes with passing no objects directly]) +_LT_TAGDECL([], [old_archive_from_new_cmds], [2], + [Create an old-style archive from a shared archive]) +_LT_TAGDECL([], [old_archive_from_expsyms_cmds], [2], + [Create a temporary old-style archive to link instead of a shared archive]) +_LT_TAGDECL([], [archive_cmds], [2], [Commands used to build a shared archive]) +_LT_TAGDECL([], [archive_expsym_cmds], [2]) +_LT_TAGDECL([], [module_cmds], [2], + [Commands used to build a loadable module if different from building + a shared archive.]) +_LT_TAGDECL([], [module_expsym_cmds], [2]) +_LT_TAGDECL([], [with_gnu_ld], [1], + [Whether we are building with GNU ld or not]) +_LT_TAGDECL([], [allow_undefined_flag], [1], + [Flag that allows shared libraries with undefined symbols to be built]) +_LT_TAGDECL([], [no_undefined_flag], [1], + [Flag that enforces no undefined symbols]) +_LT_TAGDECL([], [hardcode_libdir_flag_spec], [1], + [Flag to hardcode $libdir into a binary during linking. + This must work even if $libdir does not exist]) +_LT_TAGDECL([], [hardcode_libdir_separator], [1], + [Whether we need a single "-rpath" flag with a separated argument]) +_LT_TAGDECL([], [hardcode_direct], [0], + [Set to "yes" if using DIR/libNAME${shared_ext} during linking hardcodes + DIR into the resulting binary]) +_LT_TAGDECL([], [hardcode_direct_absolute], [0], + [Set to "yes" if using DIR/libNAME${shared_ext} during linking hardcodes + DIR into the resulting binary and the resulting library dependency is + "absolute", i.e impossible to change by setting ${shlibpath_var} if the + library is relocated]) +_LT_TAGDECL([], [hardcode_minus_L], [0], + [Set to "yes" if using the -LDIR flag during linking hardcodes DIR + into the resulting binary]) +_LT_TAGDECL([], [hardcode_shlibpath_var], [0], + [Set to "yes" if using SHLIBPATH_VAR=DIR during linking hardcodes DIR + into the resulting binary]) +_LT_TAGDECL([], [hardcode_automatic], [0], + [Set to "yes" if building a shared library automatically hardcodes DIR + into the library and all subsequent libraries and executables linked + against it]) +_LT_TAGDECL([], [inherit_rpath], [0], + [Set to yes if linker adds runtime paths of dependent libraries + to runtime path list]) +_LT_TAGDECL([], [link_all_deplibs], [0], + [Whether libtool must link a program against all its dependency libraries]) +_LT_TAGDECL([], [always_export_symbols], [0], + [Set to "yes" if exported symbols are required]) +_LT_TAGDECL([], [export_symbols_cmds], [2], + [The commands to list exported symbols]) +_LT_TAGDECL([], [exclude_expsyms], [1], + [Symbols that should not be listed in the preloaded symbols]) +_LT_TAGDECL([], [include_expsyms], [1], + [Symbols that must always be exported]) +_LT_TAGDECL([], [prelink_cmds], [2], + [Commands necessary for linking programs (against libraries) with templates]) +_LT_TAGDECL([], [postlink_cmds], [2], + [Commands necessary for finishing linking programs]) +_LT_TAGDECL([], [file_list_spec], [1], + [Specify filename containing input files]) +dnl FIXME: Not yet implemented +dnl _LT_TAGDECL([], [thread_safe_flag_spec], [1], +dnl [Compiler flag to generate thread safe objects]) +])# _LT_LINKER_SHLIBS + + +# _LT_LANG_C_CONFIG([TAG]) +# ------------------------ +# Ensure that the configuration variables for a C compiler are suitably +# defined. These variables are subsequently used by _LT_CONFIG to write +# the compiler configuration to `libtool'. +m4_defun([_LT_LANG_C_CONFIG], +[m4_require([_LT_DECL_EGREP])dnl +lt_save_CC="$CC" +AC_LANG_PUSH(C) + +# Source file extension for C test sources. +ac_ext=c + +# Object file extension for compiled C test sources. +objext=o +_LT_TAGVAR(objext, $1)=$objext + +# Code to be used in simple compile tests +lt_simple_compile_test_code="int some_variable = 0;" + +# Code to be used in simple link tests +lt_simple_link_test_code='int main(){return(0);}' + +_LT_TAG_COMPILER +# Save the default compiler, since it gets overwritten when the other +# tags are being tested, and _LT_TAGVAR(compiler, []) is a NOP. +compiler_DEFAULT=$CC + +# save warnings/boilerplate of simple test code +_LT_COMPILER_BOILERPLATE +_LT_LINKER_BOILERPLATE + +## CAVEAT EMPTOR: +## There is no encapsulation within the following macros, do not change +## the running order or otherwise move them around unless you know exactly +## what you are doing... +if test -n "$compiler"; then + _LT_COMPILER_NO_RTTI($1) + _LT_COMPILER_PIC($1) + _LT_COMPILER_C_O($1) + _LT_COMPILER_FILE_LOCKS($1) + _LT_LINKER_SHLIBS($1) + _LT_SYS_DYNAMIC_LINKER($1) + _LT_LINKER_HARDCODE_LIBPATH($1) + LT_SYS_DLOPEN_SELF + _LT_CMD_STRIPLIB + + # Report which library types will actually be built + AC_MSG_CHECKING([if libtool supports shared libraries]) + AC_MSG_RESULT([$can_build_shared]) + + AC_MSG_CHECKING([whether to build shared libraries]) + test "$can_build_shared" = "no" && enable_shared=no + + # On AIX, shared libraries and static libraries use the same namespace, and + # are all built from PIC. + case $host_os in + aix3*) + test "$enable_shared" = yes && enable_static=no + if test -n "$RANLIB"; then + archive_cmds="$archive_cmds~\$RANLIB \$lib" + postinstall_cmds='$RANLIB $lib' + fi + ;; + + aix[[4-9]]*) + if test "$host_cpu" != ia64 && test "$aix_use_runtimelinking" = no ; then + test "$enable_shared" = yes && enable_static=no + fi + ;; + esac + AC_MSG_RESULT([$enable_shared]) + + AC_MSG_CHECKING([whether to build static libraries]) + # Make sure either enable_shared or enable_static is yes. + test "$enable_shared" = yes || enable_static=yes + AC_MSG_RESULT([$enable_static]) + + _LT_CONFIG($1) +fi +AC_LANG_POP +CC="$lt_save_CC" +])# _LT_LANG_C_CONFIG + + +# _LT_LANG_CXX_CONFIG([TAG]) +# -------------------------- +# Ensure that the configuration variables for a C++ compiler are suitably +# defined. These variables are subsequently used by _LT_CONFIG to write +# the compiler configuration to `libtool'. +m4_defun([_LT_LANG_CXX_CONFIG], +[m4_require([_LT_FILEUTILS_DEFAULTS])dnl +m4_require([_LT_DECL_EGREP])dnl +m4_require([_LT_PATH_MANIFEST_TOOL])dnl +if test -n "$CXX" && ( test "X$CXX" != "Xno" && + ( (test "X$CXX" = "Xg++" && `g++ -v >/dev/null 2>&1` ) || + (test "X$CXX" != "Xg++"))) ; then + AC_PROG_CXXCPP +else + _lt_caught_CXX_error=yes +fi + +AC_LANG_PUSH(C++) +_LT_TAGVAR(archive_cmds_need_lc, $1)=no +_LT_TAGVAR(allow_undefined_flag, $1)= +_LT_TAGVAR(always_export_symbols, $1)=no +_LT_TAGVAR(archive_expsym_cmds, $1)= +_LT_TAGVAR(compiler_needs_object, $1)=no +_LT_TAGVAR(export_dynamic_flag_spec, $1)= +_LT_TAGVAR(hardcode_direct, $1)=no +_LT_TAGVAR(hardcode_direct_absolute, $1)=no +_LT_TAGVAR(hardcode_libdir_flag_spec, $1)= +_LT_TAGVAR(hardcode_libdir_separator, $1)= +_LT_TAGVAR(hardcode_minus_L, $1)=no +_LT_TAGVAR(hardcode_shlibpath_var, $1)=unsupported +_LT_TAGVAR(hardcode_automatic, $1)=no +_LT_TAGVAR(inherit_rpath, $1)=no +_LT_TAGVAR(module_cmds, $1)= +_LT_TAGVAR(module_expsym_cmds, $1)= +_LT_TAGVAR(link_all_deplibs, $1)=unknown +_LT_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds +_LT_TAGVAR(reload_flag, $1)=$reload_flag +_LT_TAGVAR(reload_cmds, $1)=$reload_cmds +_LT_TAGVAR(no_undefined_flag, $1)= +_LT_TAGVAR(whole_archive_flag_spec, $1)= +_LT_TAGVAR(enable_shared_with_static_runtimes, $1)=no + +# Source file extension for C++ test sources. +ac_ext=cpp + +# Object file extension for compiled C++ test sources. +objext=o +_LT_TAGVAR(objext, $1)=$objext + +# No sense in running all these tests if we already determined that +# the CXX compiler isn't working. Some variables (like enable_shared) +# are currently assumed to apply to all compilers on this platform, +# and will be corrupted by setting them based on a non-working compiler. +if test "$_lt_caught_CXX_error" != yes; then + # Code to be used in simple compile tests + lt_simple_compile_test_code="int some_variable = 0;" + + # Code to be used in simple link tests + lt_simple_link_test_code='int main(int, char *[[]]) { return(0); }' + + # ltmain only uses $CC for tagged configurations so make sure $CC is set. + _LT_TAG_COMPILER + + # save warnings/boilerplate of simple test code + _LT_COMPILER_BOILERPLATE + _LT_LINKER_BOILERPLATE + + # Allow CC to be a program name with arguments. + lt_save_CC=$CC + lt_save_CFLAGS=$CFLAGS + lt_save_LD=$LD + lt_save_GCC=$GCC + GCC=$GXX + lt_save_with_gnu_ld=$with_gnu_ld + lt_save_path_LD=$lt_cv_path_LD + if test -n "${lt_cv_prog_gnu_ldcxx+set}"; then + lt_cv_prog_gnu_ld=$lt_cv_prog_gnu_ldcxx + else + $as_unset lt_cv_prog_gnu_ld + fi + if test -n "${lt_cv_path_LDCXX+set}"; then + lt_cv_path_LD=$lt_cv_path_LDCXX + else + $as_unset lt_cv_path_LD + fi + test -z "${LDCXX+set}" || LD=$LDCXX + CC=${CXX-"c++"} + CFLAGS=$CXXFLAGS + compiler=$CC + _LT_TAGVAR(compiler, $1)=$CC + _LT_CC_BASENAME([$compiler]) + + if test -n "$compiler"; then + # We don't want -fno-exception when compiling C++ code, so set the + # no_builtin_flag separately + if test "$GXX" = yes; then + _LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=' -fno-builtin' + else + _LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)= + fi + + if test "$GXX" = yes; then + # Set up default GNU C++ configuration + + LT_PATH_LD + + # Check if GNU C++ uses GNU ld as the underlying linker, since the + # archiving commands below assume that GNU ld is being used. + if test "$with_gnu_ld" = yes; then + _LT_TAGVAR(archive_cmds, $1)='$CC $pic_flag -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC $pic_flag -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' + _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic' + + # If archive_cmds runs LD, not CC, wlarc should be empty + # XXX I think wlarc can be eliminated in ltcf-cxx, but I need to + # investigate it a little bit more. (MM) + wlarc='${wl}' + + # ancient GNU ld didn't support --whole-archive et. al. + if eval "`$CC -print-prog-name=ld` --help 2>&1" | + $GREP 'no-whole-archive' > /dev/null; then + _LT_TAGVAR(whole_archive_flag_spec, $1)="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive' + else + _LT_TAGVAR(whole_archive_flag_spec, $1)= + fi + else + with_gnu_ld=no + wlarc= + + # A generic and very simple default shared library creation + # command for GNU C++ for the case where it uses the native + # linker, instead of GNU ld. If possible, this setting should + # overridden to take advantage of the native linker features on + # the platform it is being used on. + _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $lib' + fi + + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"' + + else + GXX=no + with_gnu_ld=no + wlarc= + fi + + # PORTME: fill in a description of your system's C++ link characteristics + AC_MSG_CHECKING([whether the $compiler linker ($LD) supports shared libraries]) + _LT_TAGVAR(ld_shlibs, $1)=yes + case $host_os in + aix3*) + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + aix[[4-9]]*) + if test "$host_cpu" = ia64; then + # On IA64, the linker does run time linking by default, so we don't + # have to do anything special. + aix_use_runtimelinking=no + exp_sym_flag='-Bexport' + no_entry_flag="" + else + aix_use_runtimelinking=no + + # Test if we are trying to use run time linking or normal + # AIX style linking. If -brtl is somewhere in LDFLAGS, we + # need to do runtime linking. + case $host_os in aix4.[[23]]|aix4.[[23]].*|aix[[5-9]]*) + for ld_flag in $LDFLAGS; do + case $ld_flag in + *-brtl*) + aix_use_runtimelinking=yes + break + ;; + esac + done + ;; + esac + + exp_sym_flag='-bexport' + no_entry_flag='-bnoentry' + fi + + # When large executables or shared objects are built, AIX ld can + # have problems creating the table of contents. If linking a library + # or program results in "error TOC overflow" add -mminimal-toc to + # CXXFLAGS/CFLAGS for g++/gcc. In the cases where that is not + # enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS. + + _LT_TAGVAR(archive_cmds, $1)='' + _LT_TAGVAR(hardcode_direct, $1)=yes + _LT_TAGVAR(hardcode_direct_absolute, $1)=yes + _LT_TAGVAR(hardcode_libdir_separator, $1)=':' + _LT_TAGVAR(link_all_deplibs, $1)=yes + _LT_TAGVAR(file_list_spec, $1)='${wl}-f,' + + if test "$GXX" = yes; then + case $host_os in aix4.[[012]]|aix4.[[012]].*) + # We only want to do this on AIX 4.2 and lower, the check + # below for broken collect2 doesn't work under 4.3+ + collect2name=`${CC} -print-prog-name=collect2` + if test -f "$collect2name" && + strings "$collect2name" | $GREP resolve_lib_name >/dev/null + then + # We have reworked collect2 + : + else + # We have old collect2 + _LT_TAGVAR(hardcode_direct, $1)=unsupported + # It fails to find uninstalled libraries when the uninstalled + # path is not listed in the libpath. Setting hardcode_minus_L + # to unsupported forces relinking + _LT_TAGVAR(hardcode_minus_L, $1)=yes + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' + _LT_TAGVAR(hardcode_libdir_separator, $1)= + fi + esac + shared_flag='-shared' + if test "$aix_use_runtimelinking" = yes; then + shared_flag="$shared_flag "'${wl}-G' + fi + else + # not using gcc + if test "$host_cpu" = ia64; then + # VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release + # chokes on -Wl,-G. The following line is correct: + shared_flag='-G' + else + if test "$aix_use_runtimelinking" = yes; then + shared_flag='${wl}-G' + else + shared_flag='${wl}-bM:SRE' + fi + fi + fi + + _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-bexpall' + # It seems that -bexpall does not export symbols beginning with + # underscore (_), so it is better to generate a list of symbols to + # export. + _LT_TAGVAR(always_export_symbols, $1)=yes + if test "$aix_use_runtimelinking" = yes; then + # Warning - without using the other runtime loading flags (-brtl), + # -berok will link without error, but may produce a broken library. + _LT_TAGVAR(allow_undefined_flag, $1)='-berok' + # Determine the default libpath from the value encoded in an empty + # executable. + _LT_SYS_MODULE_PATH_AIX([$1]) + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-blibpath:$libdir:'"$aix_libpath" + + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then func_echo_all "${wl}${allow_undefined_flag}"; else :; fi` '"\${wl}$exp_sym_flag:\$export_symbols $shared_flag" + else + if test "$host_cpu" = ia64; then + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R $libdir:/usr/lib:/lib' + _LT_TAGVAR(allow_undefined_flag, $1)="-z nodefs" + _LT_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$exp_sym_flag:\$export_symbols" + else + # Determine the default libpath from the value encoded in an + # empty executable. + _LT_SYS_MODULE_PATH_AIX([$1]) + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-blibpath:$libdir:'"$aix_libpath" + # Warning - without using the other run time loading flags, + # -berok will link without error, but may produce a broken library. + _LT_TAGVAR(no_undefined_flag, $1)=' ${wl}-bernotok' + _LT_TAGVAR(allow_undefined_flag, $1)=' ${wl}-berok' + if test "$with_gnu_ld" = yes; then + # We only use this code for GNU lds that support --whole-archive. + _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive$convenience ${wl}--no-whole-archive' + else + # Exported symbols can be pulled into shared objects from archives + _LT_TAGVAR(whole_archive_flag_spec, $1)='$convenience' + fi + _LT_TAGVAR(archive_cmds_need_lc, $1)=yes + # This is similar to how AIX traditionally builds its shared + # libraries. + _LT_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs ${wl}-bnoentry $compiler_flags ${wl}-bE:$export_symbols${allow_undefined_flag}~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$soname' + fi + fi + ;; + + beos*) + if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then + _LT_TAGVAR(allow_undefined_flag, $1)=unsupported + # Joseph Beckenbach says some releases of gcc + # support --undefined. This deserves some investigation. FIXME + _LT_TAGVAR(archive_cmds, $1)='$CC -nostart $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + else + _LT_TAGVAR(ld_shlibs, $1)=no + fi + ;; + + chorus*) + case $cc_basename in + *) + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + esac + ;; + + cygwin* | mingw* | pw32* | cegcc*) + case $GXX,$cc_basename in + ,cl* | no,cl*) + # Native MSVC + # hardcode_libdir_flag_spec is actually meaningless, as there is + # no search path for DLLs. + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)=' ' + _LT_TAGVAR(allow_undefined_flag, $1)=unsupported + _LT_TAGVAR(always_export_symbols, $1)=yes + _LT_TAGVAR(file_list_spec, $1)='@' + # Tell ltmain to make .lib files, not .a files. + libext=lib + # Tell ltmain to make .dll files, not .so files. + shrext_cmds=".dll" + # FIXME: Setting linknames here is a bad hack. + _LT_TAGVAR(archive_cmds, $1)='$CC -o $output_objdir/$soname $libobjs $compiler_flags $deplibs -Wl,-dll~linknames=' + _LT_TAGVAR(archive_expsym_cmds, $1)='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then + $SED -n -e 's/\\\\\\\(.*\\\\\\\)/-link\\\ -EXPORT:\\\\\\\1/' -e '1\\\!p' < $export_symbols > $output_objdir/$soname.exp; + else + $SED -e 's/\\\\\\\(.*\\\\\\\)/-link\\\ -EXPORT:\\\\\\\1/' < $export_symbols > $output_objdir/$soname.exp; + fi~ + $CC -o $tool_output_objdir$soname $libobjs $compiler_flags $deplibs "@$tool_output_objdir$soname.exp" -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~ + linknames=' + # The linker will not automatically build a static lib if we build a DLL. + # _LT_TAGVAR(old_archive_from_new_cmds, $1)='true' + _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes + # Don't use ranlib + _LT_TAGVAR(old_postinstall_cmds, $1)='chmod 644 $oldlib' + _LT_TAGVAR(postlink_cmds, $1)='lt_outputfile="@OUTPUT@"~ + lt_tool_outputfile="@TOOL_OUTPUT@"~ + case $lt_outputfile in + *.exe|*.EXE) ;; + *) + lt_outputfile="$lt_outputfile.exe" + lt_tool_outputfile="$lt_tool_outputfile.exe" + ;; + esac~ + func_to_tool_file "$lt_outputfile"~ + if test "$MANIFEST_TOOL" != ":" && test -f "$lt_outputfile.manifest"; then + $MANIFEST_TOOL -manifest "$lt_tool_outputfile.manifest" -outputresource:"$lt_tool_outputfile" || exit 1; + $RM "$lt_outputfile.manifest"; + fi' + ;; + *) + # g++ + # _LT_TAGVAR(hardcode_libdir_flag_spec, $1) is actually meaningless, + # as there is no search path for DLLs. + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' + _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-all-symbols' + _LT_TAGVAR(allow_undefined_flag, $1)=unsupported + _LT_TAGVAR(always_export_symbols, $1)=no + _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes + + if $LD --help 2>&1 | $GREP 'auto-import' > /dev/null; then + _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib' + # If the export-symbols file already is a .def file (1st line + # is EXPORTS), use it as is; otherwise, prepend... + _LT_TAGVAR(archive_expsym_cmds, $1)='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then + cp $export_symbols $output_objdir/$soname.def; + else + echo EXPORTS > $output_objdir/$soname.def; + cat $export_symbols >> $output_objdir/$soname.def; + fi~ + $CC -shared -nostdlib $output_objdir/$soname.def $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib' + else + _LT_TAGVAR(ld_shlibs, $1)=no + fi + ;; + esac + ;; + darwin* | rhapsody*) + _LT_DARWIN_LINKER_FEATURES($1) + ;; + + dgux*) + case $cc_basename in + ec++*) + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + ghcx*) + # Green Hills C++ Compiler + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + *) + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + esac + ;; + + freebsd2.*) + # C++ shared libraries reported to be fairly broken before + # switch to ELF + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + + freebsd-elf*) + _LT_TAGVAR(archive_cmds_need_lc, $1)=no + ;; + + freebsd* | dragonfly*) + # FreeBSD 3 and later use GNU C++ and GNU ld with standard ELF + # conventions + _LT_TAGVAR(ld_shlibs, $1)=yes + ;; + + haiku*) + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + _LT_TAGVAR(link_all_deplibs, $1)=yes + ;; + + hpux9*) + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir' + _LT_TAGVAR(hardcode_libdir_separator, $1)=: + _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E' + _LT_TAGVAR(hardcode_direct, $1)=yes + _LT_TAGVAR(hardcode_minus_L, $1)=yes # Not in the search PATH, + # but as the default + # location of the library. + + case $cc_basename in + CC*) + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + aCC*) + _LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/$soname~$CC -b ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib' + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + # + # There doesn't appear to be a way to prevent this compiler from + # explicitly linking system object files so we need to strip them + # from the output so that they don't get included in the library + # dependencies. + output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | $EGREP "\-L"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"' + ;; + *) + if test "$GXX" = yes; then + _LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/$soname~$CC -shared -nostdlib $pic_flag ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib' + else + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + fi + ;; + esac + ;; + + hpux10*|hpux11*) + if test $with_gnu_ld = no; then + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir' + _LT_TAGVAR(hardcode_libdir_separator, $1)=: + + case $host_cpu in + hppa*64*|ia64*) + ;; + *) + _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E' + ;; + esac + fi + case $host_cpu in + hppa*64*|ia64*) + _LT_TAGVAR(hardcode_direct, $1)=no + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + ;; + *) + _LT_TAGVAR(hardcode_direct, $1)=yes + _LT_TAGVAR(hardcode_direct_absolute, $1)=yes + _LT_TAGVAR(hardcode_minus_L, $1)=yes # Not in the search PATH, + # but as the default + # location of the library. + ;; + esac + + case $cc_basename in + CC*) + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + aCC*) + case $host_cpu in + hppa*64*) + _LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' + ;; + ia64*) + _LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' + ;; + *) + _LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' + ;; + esac + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + # + # There doesn't appear to be a way to prevent this compiler from + # explicitly linking system object files so we need to strip them + # from the output so that they don't get included in the library + # dependencies. + output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | $GREP "\-L"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"' + ;; + *) + if test "$GXX" = yes; then + if test $with_gnu_ld = no; then + case $host_cpu in + hppa*64*) + _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib -fPIC ${wl}+h ${wl}$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' + ;; + ia64*) + _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $pic_flag ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' + ;; + *) + _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $pic_flag ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' + ;; + esac + fi + else + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + fi + ;; + esac + ;; + + interix[[3-9]]*) + _LT_TAGVAR(hardcode_direct, $1)=no + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir' + _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E' + # Hack: On Interix 3.x, we cannot compile PIC because of a broken gcc. + # Instead, shared libraries are loaded at an image base (0x10000000 by + # default) and relocated if they conflict, which is a slow very memory + # consuming and fragmenting process. To avoid this, we pick a random, + # 256 KiB-aligned image base between 0x50000000 and 0x6FFC0000 at link + # time. Moving up from 0x10000000 also allows more sbrk(2) space. + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='sed "s,^,_," $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--retain-symbols-file,$output_objdir/$soname.expsym ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib' + ;; + irix5* | irix6*) + case $cc_basename in + CC*) + # SGI C++ + _LT_TAGVAR(archive_cmds, $1)='$CC -shared -all -multigot $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib' + + # Archives containing C++ object files must be created using + # "CC -ar", where "CC" is the IRIX C++ compiler. This is + # necessary to make sure instantiated templates are included + # in the archive. + _LT_TAGVAR(old_archive_cmds, $1)='$CC -ar -WR,-u -o $oldlib $oldobjs' + ;; + *) + if test "$GXX" = yes; then + if test "$with_gnu_ld" = no; then + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' + else + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` -o $lib' + fi + fi + _LT_TAGVAR(link_all_deplibs, $1)=yes + ;; + esac + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' + _LT_TAGVAR(hardcode_libdir_separator, $1)=: + _LT_TAGVAR(inherit_rpath, $1)=yes + ;; + + linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*) + case $cc_basename in + KCC*) + # Kuck and Associates, Inc. (KAI) C++ Compiler + + # KCC will only create a shared library if the output file + # ends with ".so" (or ".sl" for HP-UX), so rename the library + # to its proper name (with version) after linking. + _LT_TAGVAR(archive_cmds, $1)='tempext=`echo $shared_ext | $SED -e '\''s/\([[^()0-9A-Za-z{}]]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='tempext=`echo $shared_ext | $SED -e '\''s/\([[^()0-9A-Za-z{}]]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib ${wl}-retain-symbols-file,$export_symbols; mv \$templib $lib' + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + # + # There doesn't appear to be a way to prevent this compiler from + # explicitly linking system object files so we need to strip them + # from the output so that they don't get included in the library + # dependencies. + output_verbose_link_cmd='templist=`$CC $CFLAGS -v conftest.$objext -o libconftest$shared_ext 2>&1 | $GREP "ld"`; rm -f libconftest$shared_ext; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"' + + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir' + _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic' + + # Archives containing C++ object files must be created using + # "CC -Bstatic", where "CC" is the KAI C++ compiler. + _LT_TAGVAR(old_archive_cmds, $1)='$CC -Bstatic -o $oldlib $oldobjs' + ;; + icpc* | ecpc* ) + # Intel C++ + with_gnu_ld=yes + # version 8.0 and above of icpc choke on multiply defined symbols + # if we add $predep_objects and $postdep_objects, however 7.1 and + # earlier do not add the objects themselves. + case `$CC -V 2>&1` in + *"Version 7."*) + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + ;; + *) # Version 8.0 or newer + tmp_idyn= + case $host_cpu in + ia64*) tmp_idyn=' -i_dynamic';; + esac + _LT_TAGVAR(archive_cmds, $1)='$CC -shared'"$tmp_idyn"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared'"$tmp_idyn"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + ;; + esac + _LT_TAGVAR(archive_cmds_need_lc, $1)=no + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir' + _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic' + _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive$convenience ${wl}--no-whole-archive' + ;; + pgCC* | pgcpp*) + # Portland Group C++ compiler + case `$CC -V` in + *pgCC\ [[1-5]].* | *pgcpp\ [[1-5]].*) + _LT_TAGVAR(prelink_cmds, $1)='tpldir=Template.dir~ + rm -rf $tpldir~ + $CC --prelink_objects --instantiation_dir $tpldir $objs $libobjs $compile_deplibs~ + compile_command="$compile_command `find $tpldir -name \*.o | sort | $NL2SP`"' + _LT_TAGVAR(old_archive_cmds, $1)='tpldir=Template.dir~ + rm -rf $tpldir~ + $CC --prelink_objects --instantiation_dir $tpldir $oldobjs$old_deplibs~ + $AR $AR_FLAGS $oldlib$oldobjs$old_deplibs `find $tpldir -name \*.o | sort | $NL2SP`~ + $RANLIB $oldlib' + _LT_TAGVAR(archive_cmds, $1)='tpldir=Template.dir~ + rm -rf $tpldir~ + $CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~ + $CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | sort | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='tpldir=Template.dir~ + rm -rf $tpldir~ + $CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~ + $CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | sort | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname ${wl}-retain-symbols-file ${wl}$export_symbols -o $lib' + ;; + *) # Version 6 and above use weak symbols + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname ${wl}-retain-symbols-file ${wl}$export_symbols -o $lib' + ;; + esac + + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}--rpath ${wl}$libdir' + _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic' + _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive' + ;; + cxx*) + # Compaq C++ + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib ${wl}-retain-symbols-file $wl$export_symbols' + + runpath_var=LD_RUN_PATH + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-rpath $libdir' + _LT_TAGVAR(hardcode_libdir_separator, $1)=: + + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + # + # There doesn't appear to be a way to prevent this compiler from + # explicitly linking system object files so we need to strip them + # from the output so that they don't get included in the library + # dependencies. + output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "ld"`; templist=`func_echo_all "$templist" | $SED "s/\(^.*ld.*\)\( .*ld .*$\)/\1/"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "X$list" | $Xsed' + ;; + xl* | mpixl* | bgxl*) + # IBM XL 8.0 on PPC, with GNU ld + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' + _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic' + _LT_TAGVAR(archive_cmds, $1)='$CC -qmkshrobj $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + if test "x$supports_anon_versioning" = xyes; then + _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $output_objdir/$libname.ver~ + cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~ + echo "local: *; };" >> $output_objdir/$libname.ver~ + $CC -qmkshrobj $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-version-script ${wl}$output_objdir/$libname.ver -o $lib' + fi + ;; + *) + case `$CC -V 2>&1 | sed 5q` in + *Sun\ C*) + # Sun C++ 5.9 + _LT_TAGVAR(no_undefined_flag, $1)=' -zdefs' + _LT_TAGVAR(archive_cmds, $1)='$CC -G${allow_undefined_flag} -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G${allow_undefined_flag} -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-retain-symbols-file ${wl}$export_symbols' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir' + _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`new_convenience=; for conv in $convenience\"\"; do test -z \"$conv\" || new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive' + _LT_TAGVAR(compiler_needs_object, $1)=yes + + # Not sure whether something based on + # $CC $CFLAGS -v conftest.$objext -o libconftest$shared_ext 2>&1 + # would be better. + output_verbose_link_cmd='func_echo_all' + + # Archives containing C++ object files must be created using + # "CC -xar", where "CC" is the Sun C++ compiler. This is + # necessary to make sure instantiated templates are included + # in the archive. + _LT_TAGVAR(old_archive_cmds, $1)='$CC -xar -o $oldlib $oldobjs' + ;; + esac + ;; + esac + ;; + + lynxos*) + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + + m88k*) + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + + mvs*) + case $cc_basename in + cxx*) + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + *) + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + esac + ;; + + netbsd*) + if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then + _LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $predep_objects $libobjs $deplibs $postdep_objects $linker_flags' + wlarc= + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir' + _LT_TAGVAR(hardcode_direct, $1)=yes + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + fi + # Workaround some broken pre-1.5 toolchains + output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP conftest.$objext | $SED -e "s:-lgcc -lc -lgcc::"' + ;; + + *nto* | *qnx*) + _LT_TAGVAR(ld_shlibs, $1)=yes + ;; + + openbsd2*) + # C++ shared libraries are fairly broken + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + + openbsd*) + if test -f /usr/libexec/ld.so; then + _LT_TAGVAR(hardcode_direct, $1)=yes + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + _LT_TAGVAR(hardcode_direct_absolute, $1)=yes + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $lib' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir' + if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-retain-symbols-file,$export_symbols -o $lib' + _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E' + _LT_TAGVAR(whole_archive_flag_spec, $1)="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive' + fi + output_verbose_link_cmd=func_echo_all + else + _LT_TAGVAR(ld_shlibs, $1)=no + fi + ;; + + osf3* | osf4* | osf5*) + case $cc_basename in + KCC*) + # Kuck and Associates, Inc. (KAI) C++ Compiler + + # KCC will only create a shared library if the output file + # ends with ".so" (or ".sl" for HP-UX), so rename the library + # to its proper name (with version) after linking. + _LT_TAGVAR(archive_cmds, $1)='tempext=`echo $shared_ext | $SED -e '\''s/\([[^()0-9A-Za-z{}]]\)/\\\\\1/g'\''`; templib=`echo "$lib" | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib' + + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir' + _LT_TAGVAR(hardcode_libdir_separator, $1)=: + + # Archives containing C++ object files must be created using + # the KAI C++ compiler. + case $host in + osf3*) _LT_TAGVAR(old_archive_cmds, $1)='$CC -Bstatic -o $oldlib $oldobjs' ;; + *) _LT_TAGVAR(old_archive_cmds, $1)='$CC -o $oldlib $oldobjs' ;; + esac + ;; + RCC*) + # Rational C++ 2.4.1 + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + cxx*) + case $host in + osf3*) + _LT_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*' + _LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $soname `test -n "$verstring" && func_echo_all "${wl}-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' + ;; + *) + _LT_TAGVAR(allow_undefined_flag, $1)=' -expect_unresolved \*' + _LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done~ + echo "-hidden">> $lib.exp~ + $CC -shared$allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname ${wl}-input ${wl}$lib.exp `test -n "$verstring" && $ECHO "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib~ + $RM $lib.exp' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-rpath $libdir' + ;; + esac + + _LT_TAGVAR(hardcode_libdir_separator, $1)=: + + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + # + # There doesn't appear to be a way to prevent this compiler from + # explicitly linking system object files so we need to strip them + # from the output so that they don't get included in the library + # dependencies. + output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "ld" | $GREP -v "ld:"`; templist=`func_echo_all "$templist" | $SED "s/\(^.*ld.*\)\( .*ld.*$\)/\1/"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"' + ;; + *) + if test "$GXX" = yes && test "$with_gnu_ld" = no; then + _LT_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*' + case $host in + osf3*) + _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib ${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' + ;; + *) + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -nostdlib ${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-msym ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' + ;; + esac + + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' + _LT_TAGVAR(hardcode_libdir_separator, $1)=: + + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"' + + else + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + fi + ;; + esac + ;; + + psos*) + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + + sunos4*) + case $cc_basename in + CC*) + # Sun C++ 4.x + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + lcc*) + # Lucid + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + *) + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + esac + ;; + + solaris*) + case $cc_basename in + CC* | sunCC*) + # Sun C++ 4.2, 5.x and Centerline C++ + _LT_TAGVAR(archive_cmds_need_lc,$1)=yes + _LT_TAGVAR(no_undefined_flag, $1)=' -zdefs' + _LT_TAGVAR(archive_cmds, $1)='$CC -G${allow_undefined_flag} -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' + _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~ + $CC -G${allow_undefined_flag} ${wl}-M ${wl}$lib.exp -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp' + + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir' + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + case $host_os in + solaris2.[[0-5]] | solaris2.[[0-5]].*) ;; + *) + # The compiler driver will combine and reorder linker options, + # but understands `-z linker_flag'. + # Supported since Solaris 2.6 (maybe 2.5.1?) + _LT_TAGVAR(whole_archive_flag_spec, $1)='-z allextract$convenience -z defaultextract' + ;; + esac + _LT_TAGVAR(link_all_deplibs, $1)=yes + + output_verbose_link_cmd='func_echo_all' + + # Archives containing C++ object files must be created using + # "CC -xar", where "CC" is the Sun C++ compiler. This is + # necessary to make sure instantiated templates are included + # in the archive. + _LT_TAGVAR(old_archive_cmds, $1)='$CC -xar -o $oldlib $oldobjs' + ;; + gcx*) + # Green Hills C++ Compiler + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib' + + # The C++ compiler must be used to create the archive. + _LT_TAGVAR(old_archive_cmds, $1)='$CC $LDFLAGS -archive -o $oldlib $oldobjs' + ;; + *) + # GNU C++ compiler with Solaris linker + if test "$GXX" = yes && test "$with_gnu_ld" = no; then + _LT_TAGVAR(no_undefined_flag, $1)=' ${wl}-z ${wl}defs' + if $CC --version | $GREP -v '^2\.7' > /dev/null; then + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -nostdlib $LDFLAGS $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~ + $CC -shared $pic_flag -nostdlib ${wl}-M $wl$lib.exp -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp' + + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"' + else + # g++ 2.7 appears to require `-G' NOT `-shared' on this + # platform. + _LT_TAGVAR(archive_cmds, $1)='$CC -G -nostdlib $LDFLAGS $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~ + $CC -G -nostdlib ${wl}-M $wl$lib.exp -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp' + + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + output_verbose_link_cmd='$CC -G $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"' + fi + + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R $wl$libdir' + case $host_os in + solaris2.[[0-5]] | solaris2.[[0-5]].*) ;; + *) + _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}-z ${wl}allextract$convenience ${wl}-z ${wl}defaultextract' + ;; + esac + fi + ;; + esac + ;; + + sysv4*uw2* | sysv5OpenUNIX* | sysv5UnixWare7.[[01]].[[10]]* | unixware7* | sco3.2v5.0.[[024]]*) + _LT_TAGVAR(no_undefined_flag, $1)='${wl}-z,text' + _LT_TAGVAR(archive_cmds_need_lc, $1)=no + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + runpath_var='LD_RUN_PATH' + + case $cc_basename in + CC*) + _LT_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + ;; + *) + _LT_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + ;; + esac + ;; + + sysv5* | sco3.2v5* | sco5v6*) + # Note: We can NOT use -z defs as we might desire, because we do not + # link with -lc, and that would cause any symbols used from libc to + # always be unresolved, which means just about no library would + # ever link correctly. If we're not using GNU ld we use -z text + # though, which does catch some bad symbols but isn't as heavy-handed + # as -z defs. + _LT_TAGVAR(no_undefined_flag, $1)='${wl}-z,text' + _LT_TAGVAR(allow_undefined_flag, $1)='${wl}-z,nodefs' + _LT_TAGVAR(archive_cmds_need_lc, $1)=no + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R,$libdir' + _LT_TAGVAR(hardcode_libdir_separator, $1)=':' + _LT_TAGVAR(link_all_deplibs, $1)=yes + _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-Bexport' + runpath_var='LD_RUN_PATH' + + case $cc_basename in + CC*) + _LT_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + _LT_TAGVAR(old_archive_cmds, $1)='$CC -Tprelink_objects $oldobjs~ + '"$_LT_TAGVAR(old_archive_cmds, $1)" + _LT_TAGVAR(reload_cmds, $1)='$CC -Tprelink_objects $reload_objs~ + '"$_LT_TAGVAR(reload_cmds, $1)" + ;; + *) + _LT_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + ;; + esac + ;; + + tandem*) + case $cc_basename in + NCC*) + # NonStop-UX NCC 3.20 + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + *) + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + esac + ;; + + vxworks*) + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + + *) + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + esac + + AC_MSG_RESULT([$_LT_TAGVAR(ld_shlibs, $1)]) + test "$_LT_TAGVAR(ld_shlibs, $1)" = no && can_build_shared=no + + _LT_TAGVAR(GCC, $1)="$GXX" + _LT_TAGVAR(LD, $1)="$LD" + + ## CAVEAT EMPTOR: + ## There is no encapsulation within the following macros, do not change + ## the running order or otherwise move them around unless you know exactly + ## what you are doing... + _LT_SYS_HIDDEN_LIBDEPS($1) + _LT_COMPILER_PIC($1) + _LT_COMPILER_C_O($1) + _LT_COMPILER_FILE_LOCKS($1) + _LT_LINKER_SHLIBS($1) + _LT_SYS_DYNAMIC_LINKER($1) + _LT_LINKER_HARDCODE_LIBPATH($1) + + _LT_CONFIG($1) + fi # test -n "$compiler" + + CC=$lt_save_CC + CFLAGS=$lt_save_CFLAGS + LDCXX=$LD + LD=$lt_save_LD + GCC=$lt_save_GCC + with_gnu_ld=$lt_save_with_gnu_ld + lt_cv_path_LDCXX=$lt_cv_path_LD + lt_cv_path_LD=$lt_save_path_LD + lt_cv_prog_gnu_ldcxx=$lt_cv_prog_gnu_ld + lt_cv_prog_gnu_ld=$lt_save_with_gnu_ld +fi # test "$_lt_caught_CXX_error" != yes + +AC_LANG_POP +])# _LT_LANG_CXX_CONFIG + + +# _LT_FUNC_STRIPNAME_CNF +# ---------------------- +# func_stripname_cnf prefix suffix name +# strip PREFIX and SUFFIX off of NAME. +# PREFIX and SUFFIX must not contain globbing or regex special +# characters, hashes, percent signs, but SUFFIX may contain a leading +# dot (in which case that matches only a dot). +# +# This function is identical to the (non-XSI) version of func_stripname, +# except this one can be used by m4 code that may be executed by configure, +# rather than the libtool script. +m4_defun([_LT_FUNC_STRIPNAME_CNF],[dnl +AC_REQUIRE([_LT_DECL_SED]) +AC_REQUIRE([_LT_PROG_ECHO_BACKSLASH]) +func_stripname_cnf () +{ + case ${2} in + .*) func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%\\\\${2}\$%%"`;; + *) func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%${2}\$%%"`;; + esac +} # func_stripname_cnf +])# _LT_FUNC_STRIPNAME_CNF + +# _LT_SYS_HIDDEN_LIBDEPS([TAGNAME]) +# --------------------------------- +# Figure out "hidden" library dependencies from verbose +# compiler output when linking a shared library. +# Parse the compiler output and extract the necessary +# objects, libraries and library flags. +m4_defun([_LT_SYS_HIDDEN_LIBDEPS], +[m4_require([_LT_FILEUTILS_DEFAULTS])dnl +AC_REQUIRE([_LT_FUNC_STRIPNAME_CNF])dnl +# Dependencies to place before and after the object being linked: +_LT_TAGVAR(predep_objects, $1)= +_LT_TAGVAR(postdep_objects, $1)= +_LT_TAGVAR(predeps, $1)= +_LT_TAGVAR(postdeps, $1)= +_LT_TAGVAR(compiler_lib_search_path, $1)= + +dnl we can't use the lt_simple_compile_test_code here, +dnl because it contains code intended for an executable, +dnl not a library. It's possible we should let each +dnl tag define a new lt_????_link_test_code variable, +dnl but it's only used here... +m4_if([$1], [], [cat > conftest.$ac_ext <<_LT_EOF +int a; +void foo (void) { a = 0; } +_LT_EOF +], [$1], [CXX], [cat > conftest.$ac_ext <<_LT_EOF +class Foo +{ +public: + Foo (void) { a = 0; } +private: + int a; +}; +_LT_EOF +], [$1], [F77], [cat > conftest.$ac_ext <<_LT_EOF + subroutine foo + implicit none + integer*4 a + a=0 + return + end +_LT_EOF +], [$1], [FC], [cat > conftest.$ac_ext <<_LT_EOF + subroutine foo + implicit none + integer a + a=0 + return + end +_LT_EOF +], [$1], [GCJ], [cat > conftest.$ac_ext <<_LT_EOF +public class foo { + private int a; + public void bar (void) { + a = 0; + } +}; +_LT_EOF +], [$1], [GO], [cat > conftest.$ac_ext <<_LT_EOF +package foo +func foo() { +} +_LT_EOF +]) + +_lt_libdeps_save_CFLAGS=$CFLAGS +case "$CC $CFLAGS " in #( +*\ -flto*\ *) CFLAGS="$CFLAGS -fno-lto" ;; +*\ -fwhopr*\ *) CFLAGS="$CFLAGS -fno-whopr" ;; +*\ -fuse-linker-plugin*\ *) CFLAGS="$CFLAGS -fno-use-linker-plugin" ;; +esac + +dnl Parse the compiler output and extract the necessary +dnl objects, libraries and library flags. +if AC_TRY_EVAL(ac_compile); then + # Parse the compiler output and extract the necessary + # objects, libraries and library flags. + + # Sentinel used to keep track of whether or not we are before + # the conftest object file. + pre_test_object_deps_done=no + + for p in `eval "$output_verbose_link_cmd"`; do + case ${prev}${p} in + + -L* | -R* | -l*) + # Some compilers place space between "-{L,R}" and the path. + # Remove the space. + if test $p = "-L" || + test $p = "-R"; then + prev=$p + continue + fi + + # Expand the sysroot to ease extracting the directories later. + if test -z "$prev"; then + case $p in + -L*) func_stripname_cnf '-L' '' "$p"; prev=-L; p=$func_stripname_result ;; + -R*) func_stripname_cnf '-R' '' "$p"; prev=-R; p=$func_stripname_result ;; + -l*) func_stripname_cnf '-l' '' "$p"; prev=-l; p=$func_stripname_result ;; + esac + fi + case $p in + =*) func_stripname_cnf '=' '' "$p"; p=$lt_sysroot$func_stripname_result ;; + esac + if test "$pre_test_object_deps_done" = no; then + case ${prev} in + -L | -R) + # Internal compiler library paths should come after those + # provided the user. The postdeps already come after the + # user supplied libs so there is no need to process them. + if test -z "$_LT_TAGVAR(compiler_lib_search_path, $1)"; then + _LT_TAGVAR(compiler_lib_search_path, $1)="${prev}${p}" + else + _LT_TAGVAR(compiler_lib_search_path, $1)="${_LT_TAGVAR(compiler_lib_search_path, $1)} ${prev}${p}" + fi + ;; + # The "-l" case would never come before the object being + # linked, so don't bother handling this case. + esac + else + if test -z "$_LT_TAGVAR(postdeps, $1)"; then + _LT_TAGVAR(postdeps, $1)="${prev}${p}" + else + _LT_TAGVAR(postdeps, $1)="${_LT_TAGVAR(postdeps, $1)} ${prev}${p}" + fi + fi + prev= + ;; + + *.lto.$objext) ;; # Ignore GCC LTO objects + *.$objext) + # This assumes that the test object file only shows up + # once in the compiler output. + if test "$p" = "conftest.$objext"; then + pre_test_object_deps_done=yes + continue + fi + + if test "$pre_test_object_deps_done" = no; then + if test -z "$_LT_TAGVAR(predep_objects, $1)"; then + _LT_TAGVAR(predep_objects, $1)="$p" + else + _LT_TAGVAR(predep_objects, $1)="$_LT_TAGVAR(predep_objects, $1) $p" + fi + else + if test -z "$_LT_TAGVAR(postdep_objects, $1)"; then + _LT_TAGVAR(postdep_objects, $1)="$p" + else + _LT_TAGVAR(postdep_objects, $1)="$_LT_TAGVAR(postdep_objects, $1) $p" + fi + fi + ;; + + *) ;; # Ignore the rest. + + esac + done + + # Clean up. + rm -f a.out a.exe +else + echo "libtool.m4: error: problem compiling $1 test program" +fi + +$RM -f confest.$objext +CFLAGS=$_lt_libdeps_save_CFLAGS + +# PORTME: override above test on systems where it is broken +m4_if([$1], [CXX], +[case $host_os in +interix[[3-9]]*) + # Interix 3.5 installs completely hosed .la files for C++, so rather than + # hack all around it, let's just trust "g++" to DTRT. + _LT_TAGVAR(predep_objects,$1)= + _LT_TAGVAR(postdep_objects,$1)= + _LT_TAGVAR(postdeps,$1)= + ;; + +linux*) + case `$CC -V 2>&1 | sed 5q` in + *Sun\ C*) + # Sun C++ 5.9 + + # The more standards-conforming stlport4 library is + # incompatible with the Cstd library. Avoid specifying + # it if it's in CXXFLAGS. Ignore libCrun as + # -library=stlport4 depends on it. + case " $CXX $CXXFLAGS " in + *" -library=stlport4 "*) + solaris_use_stlport4=yes + ;; + esac + + if test "$solaris_use_stlport4" != yes; then + _LT_TAGVAR(postdeps,$1)='-library=Cstd -library=Crun' + fi + ;; + esac + ;; + +solaris*) + case $cc_basename in + CC* | sunCC*) + # The more standards-conforming stlport4 library is + # incompatible with the Cstd library. Avoid specifying + # it if it's in CXXFLAGS. Ignore libCrun as + # -library=stlport4 depends on it. + case " $CXX $CXXFLAGS " in + *" -library=stlport4 "*) + solaris_use_stlport4=yes + ;; + esac + + # Adding this requires a known-good setup of shared libraries for + # Sun compiler versions before 5.6, else PIC objects from an old + # archive will be linked into the output, leading to subtle bugs. + if test "$solaris_use_stlport4" != yes; then + _LT_TAGVAR(postdeps,$1)='-library=Cstd -library=Crun' + fi + ;; + esac + ;; +esac +]) + +case " $_LT_TAGVAR(postdeps, $1) " in +*" -lc "*) _LT_TAGVAR(archive_cmds_need_lc, $1)=no ;; +esac + _LT_TAGVAR(compiler_lib_search_dirs, $1)= +if test -n "${_LT_TAGVAR(compiler_lib_search_path, $1)}"; then + _LT_TAGVAR(compiler_lib_search_dirs, $1)=`echo " ${_LT_TAGVAR(compiler_lib_search_path, $1)}" | ${SED} -e 's! -L! !g' -e 's!^ !!'` +fi +_LT_TAGDECL([], [compiler_lib_search_dirs], [1], + [The directories searched by this compiler when creating a shared library]) +_LT_TAGDECL([], [predep_objects], [1], + [Dependencies to place before and after the objects being linked to + create a shared library]) +_LT_TAGDECL([], [postdep_objects], [1]) +_LT_TAGDECL([], [predeps], [1]) +_LT_TAGDECL([], [postdeps], [1]) +_LT_TAGDECL([], [compiler_lib_search_path], [1], + [The library search path used internally by the compiler when linking + a shared library]) +])# _LT_SYS_HIDDEN_LIBDEPS + + +# _LT_LANG_F77_CONFIG([TAG]) +# -------------------------- +# Ensure that the configuration variables for a Fortran 77 compiler are +# suitably defined. These variables are subsequently used by _LT_CONFIG +# to write the compiler configuration to `libtool'. +m4_defun([_LT_LANG_F77_CONFIG], +[AC_LANG_PUSH(Fortran 77) +if test -z "$F77" || test "X$F77" = "Xno"; then + _lt_disable_F77=yes +fi + +_LT_TAGVAR(archive_cmds_need_lc, $1)=no +_LT_TAGVAR(allow_undefined_flag, $1)= +_LT_TAGVAR(always_export_symbols, $1)=no +_LT_TAGVAR(archive_expsym_cmds, $1)= +_LT_TAGVAR(export_dynamic_flag_spec, $1)= +_LT_TAGVAR(hardcode_direct, $1)=no +_LT_TAGVAR(hardcode_direct_absolute, $1)=no +_LT_TAGVAR(hardcode_libdir_flag_spec, $1)= +_LT_TAGVAR(hardcode_libdir_separator, $1)= +_LT_TAGVAR(hardcode_minus_L, $1)=no +_LT_TAGVAR(hardcode_automatic, $1)=no +_LT_TAGVAR(inherit_rpath, $1)=no +_LT_TAGVAR(module_cmds, $1)= +_LT_TAGVAR(module_expsym_cmds, $1)= +_LT_TAGVAR(link_all_deplibs, $1)=unknown +_LT_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds +_LT_TAGVAR(reload_flag, $1)=$reload_flag +_LT_TAGVAR(reload_cmds, $1)=$reload_cmds +_LT_TAGVAR(no_undefined_flag, $1)= +_LT_TAGVAR(whole_archive_flag_spec, $1)= +_LT_TAGVAR(enable_shared_with_static_runtimes, $1)=no + +# Source file extension for f77 test sources. +ac_ext=f + +# Object file extension for compiled f77 test sources. +objext=o +_LT_TAGVAR(objext, $1)=$objext + +# No sense in running all these tests if we already determined that +# the F77 compiler isn't working. Some variables (like enable_shared) +# are currently assumed to apply to all compilers on this platform, +# and will be corrupted by setting them based on a non-working compiler. +if test "$_lt_disable_F77" != yes; then + # Code to be used in simple compile tests + lt_simple_compile_test_code="\ + subroutine t + return + end +" + + # Code to be used in simple link tests + lt_simple_link_test_code="\ + program t + end +" + + # ltmain only uses $CC for tagged configurations so make sure $CC is set. + _LT_TAG_COMPILER + + # save warnings/boilerplate of simple test code + _LT_COMPILER_BOILERPLATE + _LT_LINKER_BOILERPLATE + + # Allow CC to be a program name with arguments. + lt_save_CC="$CC" + lt_save_GCC=$GCC + lt_save_CFLAGS=$CFLAGS + CC=${F77-"f77"} + CFLAGS=$FFLAGS + compiler=$CC + _LT_TAGVAR(compiler, $1)=$CC + _LT_CC_BASENAME([$compiler]) + GCC=$G77 + if test -n "$compiler"; then + AC_MSG_CHECKING([if libtool supports shared libraries]) + AC_MSG_RESULT([$can_build_shared]) + + AC_MSG_CHECKING([whether to build shared libraries]) + test "$can_build_shared" = "no" && enable_shared=no + + # On AIX, shared libraries and static libraries use the same namespace, and + # are all built from PIC. + case $host_os in + aix3*) + test "$enable_shared" = yes && enable_static=no + if test -n "$RANLIB"; then + archive_cmds="$archive_cmds~\$RANLIB \$lib" + postinstall_cmds='$RANLIB $lib' + fi + ;; + aix[[4-9]]*) + if test "$host_cpu" != ia64 && test "$aix_use_runtimelinking" = no ; then + test "$enable_shared" = yes && enable_static=no + fi + ;; + esac + AC_MSG_RESULT([$enable_shared]) + + AC_MSG_CHECKING([whether to build static libraries]) + # Make sure either enable_shared or enable_static is yes. + test "$enable_shared" = yes || enable_static=yes + AC_MSG_RESULT([$enable_static]) + + _LT_TAGVAR(GCC, $1)="$G77" + _LT_TAGVAR(LD, $1)="$LD" + + ## CAVEAT EMPTOR: + ## There is no encapsulation within the following macros, do not change + ## the running order or otherwise move them around unless you know exactly + ## what you are doing... + _LT_COMPILER_PIC($1) + _LT_COMPILER_C_O($1) + _LT_COMPILER_FILE_LOCKS($1) + _LT_LINKER_SHLIBS($1) + _LT_SYS_DYNAMIC_LINKER($1) + _LT_LINKER_HARDCODE_LIBPATH($1) + + _LT_CONFIG($1) + fi # test -n "$compiler" + + GCC=$lt_save_GCC + CC="$lt_save_CC" + CFLAGS="$lt_save_CFLAGS" +fi # test "$_lt_disable_F77" != yes + +AC_LANG_POP +])# _LT_LANG_F77_CONFIG + + +# _LT_LANG_FC_CONFIG([TAG]) +# ------------------------- +# Ensure that the configuration variables for a Fortran compiler are +# suitably defined. These variables are subsequently used by _LT_CONFIG +# to write the compiler configuration to `libtool'. +m4_defun([_LT_LANG_FC_CONFIG], +[AC_LANG_PUSH(Fortran) + +if test -z "$FC" || test "X$FC" = "Xno"; then + _lt_disable_FC=yes +fi + +_LT_TAGVAR(archive_cmds_need_lc, $1)=no +_LT_TAGVAR(allow_undefined_flag, $1)= +_LT_TAGVAR(always_export_symbols, $1)=no +_LT_TAGVAR(archive_expsym_cmds, $1)= +_LT_TAGVAR(export_dynamic_flag_spec, $1)= +_LT_TAGVAR(hardcode_direct, $1)=no +_LT_TAGVAR(hardcode_direct_absolute, $1)=no +_LT_TAGVAR(hardcode_libdir_flag_spec, $1)= +_LT_TAGVAR(hardcode_libdir_separator, $1)= +_LT_TAGVAR(hardcode_minus_L, $1)=no +_LT_TAGVAR(hardcode_automatic, $1)=no +_LT_TAGVAR(inherit_rpath, $1)=no +_LT_TAGVAR(module_cmds, $1)= +_LT_TAGVAR(module_expsym_cmds, $1)= +_LT_TAGVAR(link_all_deplibs, $1)=unknown +_LT_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds +_LT_TAGVAR(reload_flag, $1)=$reload_flag +_LT_TAGVAR(reload_cmds, $1)=$reload_cmds +_LT_TAGVAR(no_undefined_flag, $1)= +_LT_TAGVAR(whole_archive_flag_spec, $1)= +_LT_TAGVAR(enable_shared_with_static_runtimes, $1)=no + +# Source file extension for fc test sources. +ac_ext=${ac_fc_srcext-f} + +# Object file extension for compiled fc test sources. +objext=o +_LT_TAGVAR(objext, $1)=$objext + +# No sense in running all these tests if we already determined that +# the FC compiler isn't working. Some variables (like enable_shared) +# are currently assumed to apply to all compilers on this platform, +# and will be corrupted by setting them based on a non-working compiler. +if test "$_lt_disable_FC" != yes; then + # Code to be used in simple compile tests + lt_simple_compile_test_code="\ + subroutine t + return + end +" + + # Code to be used in simple link tests + lt_simple_link_test_code="\ + program t + end +" + + # ltmain only uses $CC for tagged configurations so make sure $CC is set. + _LT_TAG_COMPILER + + # save warnings/boilerplate of simple test code + _LT_COMPILER_BOILERPLATE + _LT_LINKER_BOILERPLATE + + # Allow CC to be a program name with arguments. + lt_save_CC="$CC" + lt_save_GCC=$GCC + lt_save_CFLAGS=$CFLAGS + CC=${FC-"f95"} + CFLAGS=$FCFLAGS + compiler=$CC + GCC=$ac_cv_fc_compiler_gnu + + _LT_TAGVAR(compiler, $1)=$CC + _LT_CC_BASENAME([$compiler]) + + if test -n "$compiler"; then + AC_MSG_CHECKING([if libtool supports shared libraries]) + AC_MSG_RESULT([$can_build_shared]) + + AC_MSG_CHECKING([whether to build shared libraries]) + test "$can_build_shared" = "no" && enable_shared=no + + # On AIX, shared libraries and static libraries use the same namespace, and + # are all built from PIC. + case $host_os in + aix3*) + test "$enable_shared" = yes && enable_static=no + if test -n "$RANLIB"; then + archive_cmds="$archive_cmds~\$RANLIB \$lib" + postinstall_cmds='$RANLIB $lib' + fi + ;; + aix[[4-9]]*) + if test "$host_cpu" != ia64 && test "$aix_use_runtimelinking" = no ; then + test "$enable_shared" = yes && enable_static=no + fi + ;; + esac + AC_MSG_RESULT([$enable_shared]) + + AC_MSG_CHECKING([whether to build static libraries]) + # Make sure either enable_shared or enable_static is yes. + test "$enable_shared" = yes || enable_static=yes + AC_MSG_RESULT([$enable_static]) + + _LT_TAGVAR(GCC, $1)="$ac_cv_fc_compiler_gnu" + _LT_TAGVAR(LD, $1)="$LD" + + ## CAVEAT EMPTOR: + ## There is no encapsulation within the following macros, do not change + ## the running order or otherwise move them around unless you know exactly + ## what you are doing... + _LT_SYS_HIDDEN_LIBDEPS($1) + _LT_COMPILER_PIC($1) + _LT_COMPILER_C_O($1) + _LT_COMPILER_FILE_LOCKS($1) + _LT_LINKER_SHLIBS($1) + _LT_SYS_DYNAMIC_LINKER($1) + _LT_LINKER_HARDCODE_LIBPATH($1) + + _LT_CONFIG($1) + fi # test -n "$compiler" + + GCC=$lt_save_GCC + CC=$lt_save_CC + CFLAGS=$lt_save_CFLAGS +fi # test "$_lt_disable_FC" != yes + +AC_LANG_POP +])# _LT_LANG_FC_CONFIG + + +# _LT_LANG_GCJ_CONFIG([TAG]) +# -------------------------- +# Ensure that the configuration variables for the GNU Java Compiler compiler +# are suitably defined. These variables are subsequently used by _LT_CONFIG +# to write the compiler configuration to `libtool'. +m4_defun([_LT_LANG_GCJ_CONFIG], +[AC_REQUIRE([LT_PROG_GCJ])dnl +AC_LANG_SAVE + +# Source file extension for Java test sources. +ac_ext=java + +# Object file extension for compiled Java test sources. +objext=o +_LT_TAGVAR(objext, $1)=$objext + +# Code to be used in simple compile tests +lt_simple_compile_test_code="class foo {}" + +# Code to be used in simple link tests +lt_simple_link_test_code='public class conftest { public static void main(String[[]] argv) {}; }' + +# ltmain only uses $CC for tagged configurations so make sure $CC is set. +_LT_TAG_COMPILER + +# save warnings/boilerplate of simple test code +_LT_COMPILER_BOILERPLATE +_LT_LINKER_BOILERPLATE + +# Allow CC to be a program name with arguments. +lt_save_CC=$CC +lt_save_CFLAGS=$CFLAGS +lt_save_GCC=$GCC +GCC=yes +CC=${GCJ-"gcj"} +CFLAGS=$GCJFLAGS +compiler=$CC +_LT_TAGVAR(compiler, $1)=$CC +_LT_TAGVAR(LD, $1)="$LD" +_LT_CC_BASENAME([$compiler]) + +# GCJ did not exist at the time GCC didn't implicitly link libc in. +_LT_TAGVAR(archive_cmds_need_lc, $1)=no + +_LT_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds +_LT_TAGVAR(reload_flag, $1)=$reload_flag +_LT_TAGVAR(reload_cmds, $1)=$reload_cmds + +## CAVEAT EMPTOR: +## There is no encapsulation within the following macros, do not change +## the running order or otherwise move them around unless you know exactly +## what you are doing... +if test -n "$compiler"; then + _LT_COMPILER_NO_RTTI($1) + _LT_COMPILER_PIC($1) + _LT_COMPILER_C_O($1) + _LT_COMPILER_FILE_LOCKS($1) + _LT_LINKER_SHLIBS($1) + _LT_LINKER_HARDCODE_LIBPATH($1) + + _LT_CONFIG($1) +fi + +AC_LANG_RESTORE + +GCC=$lt_save_GCC +CC=$lt_save_CC +CFLAGS=$lt_save_CFLAGS +])# _LT_LANG_GCJ_CONFIG + + +# _LT_LANG_GO_CONFIG([TAG]) +# -------------------------- +# Ensure that the configuration variables for the GNU Go compiler +# are suitably defined. These variables are subsequently used by _LT_CONFIG +# to write the compiler configuration to `libtool'. +m4_defun([_LT_LANG_GO_CONFIG], +[AC_REQUIRE([LT_PROG_GO])dnl +AC_LANG_SAVE + +# Source file extension for Go test sources. +ac_ext=go + +# Object file extension for compiled Go test sources. +objext=o +_LT_TAGVAR(objext, $1)=$objext + +# Code to be used in simple compile tests +lt_simple_compile_test_code="package main; func main() { }" + +# Code to be used in simple link tests +lt_simple_link_test_code='package main; func main() { }' + +# ltmain only uses $CC for tagged configurations so make sure $CC is set. +_LT_TAG_COMPILER + +# save warnings/boilerplate of simple test code +_LT_COMPILER_BOILERPLATE +_LT_LINKER_BOILERPLATE + +# Allow CC to be a program name with arguments. +lt_save_CC=$CC +lt_save_CFLAGS=$CFLAGS +lt_save_GCC=$GCC +GCC=yes +CC=${GOC-"gccgo"} +CFLAGS=$GOFLAGS +compiler=$CC +_LT_TAGVAR(compiler, $1)=$CC +_LT_TAGVAR(LD, $1)="$LD" +_LT_CC_BASENAME([$compiler]) + +# Go did not exist at the time GCC didn't implicitly link libc in. +_LT_TAGVAR(archive_cmds_need_lc, $1)=no + +_LT_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds +_LT_TAGVAR(reload_flag, $1)=$reload_flag +_LT_TAGVAR(reload_cmds, $1)=$reload_cmds + +## CAVEAT EMPTOR: +## There is no encapsulation within the following macros, do not change +## the running order or otherwise move them around unless you know exactly +## what you are doing... +if test -n "$compiler"; then + _LT_COMPILER_NO_RTTI($1) + _LT_COMPILER_PIC($1) + _LT_COMPILER_C_O($1) + _LT_COMPILER_FILE_LOCKS($1) + _LT_LINKER_SHLIBS($1) + _LT_LINKER_HARDCODE_LIBPATH($1) + + _LT_CONFIG($1) +fi + +AC_LANG_RESTORE + +GCC=$lt_save_GCC +CC=$lt_save_CC +CFLAGS=$lt_save_CFLAGS +])# _LT_LANG_GO_CONFIG + + +# _LT_LANG_RC_CONFIG([TAG]) +# ------------------------- +# Ensure that the configuration variables for the Windows resource compiler +# are suitably defined. These variables are subsequently used by _LT_CONFIG +# to write the compiler configuration to `libtool'. +m4_defun([_LT_LANG_RC_CONFIG], +[AC_REQUIRE([LT_PROG_RC])dnl +AC_LANG_SAVE + +# Source file extension for RC test sources. +ac_ext=rc + +# Object file extension for compiled RC test sources. +objext=o +_LT_TAGVAR(objext, $1)=$objext + +# Code to be used in simple compile tests +lt_simple_compile_test_code='sample MENU { MENUITEM "&Soup", 100, CHECKED }' + +# Code to be used in simple link tests +lt_simple_link_test_code="$lt_simple_compile_test_code" + +# ltmain only uses $CC for tagged configurations so make sure $CC is set. +_LT_TAG_COMPILER + +# save warnings/boilerplate of simple test code +_LT_COMPILER_BOILERPLATE +_LT_LINKER_BOILERPLATE + +# Allow CC to be a program name with arguments. +lt_save_CC="$CC" +lt_save_CFLAGS=$CFLAGS +lt_save_GCC=$GCC +GCC= +CC=${RC-"windres"} +CFLAGS= +compiler=$CC +_LT_TAGVAR(compiler, $1)=$CC +_LT_CC_BASENAME([$compiler]) +_LT_TAGVAR(lt_cv_prog_compiler_c_o, $1)=yes + +if test -n "$compiler"; then + : + _LT_CONFIG($1) +fi + +GCC=$lt_save_GCC +AC_LANG_RESTORE +CC=$lt_save_CC +CFLAGS=$lt_save_CFLAGS +])# _LT_LANG_RC_CONFIG + + +# LT_PROG_GCJ +# ----------- +AC_DEFUN([LT_PROG_GCJ], +[m4_ifdef([AC_PROG_GCJ], [AC_PROG_GCJ], + [m4_ifdef([A][M_PROG_GCJ], [A][M_PROG_GCJ], + [AC_CHECK_TOOL(GCJ, gcj,) + test "x${GCJFLAGS+set}" = xset || GCJFLAGS="-g -O2" + AC_SUBST(GCJFLAGS)])])[]dnl +]) + +# Old name: +AU_ALIAS([LT_AC_PROG_GCJ], [LT_PROG_GCJ]) +dnl aclocal-1.4 backwards compatibility: +dnl AC_DEFUN([LT_AC_PROG_GCJ], []) + + +# LT_PROG_GO +# ---------- +AC_DEFUN([LT_PROG_GO], +[AC_CHECK_TOOL(GOC, gccgo,) +]) + + +# LT_PROG_RC +# ---------- +AC_DEFUN([LT_PROG_RC], +[AC_CHECK_TOOL(RC, windres,) +]) + +# Old name: +AU_ALIAS([LT_AC_PROG_RC], [LT_PROG_RC]) +dnl aclocal-1.4 backwards compatibility: +dnl AC_DEFUN([LT_AC_PROG_RC], []) + + +# _LT_DECL_EGREP +# -------------- +# If we don't have a new enough Autoconf to choose the best grep +# available, choose the one first in the user's PATH. +m4_defun([_LT_DECL_EGREP], +[AC_REQUIRE([AC_PROG_EGREP])dnl +AC_REQUIRE([AC_PROG_FGREP])dnl +test -z "$GREP" && GREP=grep +_LT_DECL([], [GREP], [1], [A grep program that handles long lines]) +_LT_DECL([], [EGREP], [1], [An ERE matcher]) +_LT_DECL([], [FGREP], [1], [A literal string matcher]) +dnl Non-bleeding-edge autoconf doesn't subst GREP, so do it here too +AC_SUBST([GREP]) +]) + + +# _LT_DECL_OBJDUMP +# -------------- +# If we don't have a new enough Autoconf to choose the best objdump +# available, choose the one first in the user's PATH. +m4_defun([_LT_DECL_OBJDUMP], +[AC_CHECK_TOOL(OBJDUMP, objdump, false) +test -z "$OBJDUMP" && OBJDUMP=objdump +_LT_DECL([], [OBJDUMP], [1], [An object symbol dumper]) +AC_SUBST([OBJDUMP]) +]) + +# _LT_DECL_DLLTOOL +# ---------------- +# Ensure DLLTOOL variable is set. +m4_defun([_LT_DECL_DLLTOOL], +[AC_CHECK_TOOL(DLLTOOL, dlltool, false) +test -z "$DLLTOOL" && DLLTOOL=dlltool +_LT_DECL([], [DLLTOOL], [1], [DLL creation program]) +AC_SUBST([DLLTOOL]) +]) + +# _LT_DECL_SED +# ------------ +# Check for a fully-functional sed program, that truncates +# as few characters as possible. Prefer GNU sed if found. +m4_defun([_LT_DECL_SED], +[AC_PROG_SED +test -z "$SED" && SED=sed +Xsed="$SED -e 1s/^X//" +_LT_DECL([], [SED], [1], [A sed program that does not truncate output]) +_LT_DECL([], [Xsed], ["\$SED -e 1s/^X//"], + [Sed that helps us avoid accidentally triggering echo(1) options like -n]) +])# _LT_DECL_SED + +m4_ifndef([AC_PROG_SED], [ +############################################################ +# NOTE: This macro has been submitted for inclusion into # +# GNU Autoconf as AC_PROG_SED. When it is available in # +# a released version of Autoconf we should remove this # +# macro and use it instead. # +############################################################ + +m4_defun([AC_PROG_SED], +[AC_MSG_CHECKING([for a sed that does not truncate output]) +AC_CACHE_VAL(lt_cv_path_SED, +[# Loop through the user's path and test for sed and gsed. +# Then use that list of sed's as ones to test for truncation. +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for lt_ac_prog in sed gsed; do + for ac_exec_ext in '' $ac_executable_extensions; do + if $as_executable_p "$as_dir/$lt_ac_prog$ac_exec_ext"; then + lt_ac_sed_list="$lt_ac_sed_list $as_dir/$lt_ac_prog$ac_exec_ext" + fi + done + done +done +IFS=$as_save_IFS +lt_ac_max=0 +lt_ac_count=0 +# Add /usr/xpg4/bin/sed as it is typically found on Solaris +# along with /bin/sed that truncates output. +for lt_ac_sed in $lt_ac_sed_list /usr/xpg4/bin/sed; do + test ! -f $lt_ac_sed && continue + cat /dev/null > conftest.in + lt_ac_count=0 + echo $ECHO_N "0123456789$ECHO_C" >conftest.in + # Check for GNU sed and select it if it is found. + if "$lt_ac_sed" --version 2>&1 < /dev/null | grep 'GNU' > /dev/null; then + lt_cv_path_SED=$lt_ac_sed + break + fi + while true; do + cat conftest.in conftest.in >conftest.tmp + mv conftest.tmp conftest.in + cp conftest.in conftest.nl + echo >>conftest.nl + $lt_ac_sed -e 's/a$//' < conftest.nl >conftest.out || break + cmp -s conftest.out conftest.nl || break + # 10000 chars as input seems more than enough + test $lt_ac_count -gt 10 && break + lt_ac_count=`expr $lt_ac_count + 1` + if test $lt_ac_count -gt $lt_ac_max; then + lt_ac_max=$lt_ac_count + lt_cv_path_SED=$lt_ac_sed + fi + done +done +]) +SED=$lt_cv_path_SED +AC_SUBST([SED]) +AC_MSG_RESULT([$SED]) +])#AC_PROG_SED +])#m4_ifndef + +# Old name: +AU_ALIAS([LT_AC_PROG_SED], [AC_PROG_SED]) +dnl aclocal-1.4 backwards compatibility: +dnl AC_DEFUN([LT_AC_PROG_SED], []) + + +# _LT_CHECK_SHELL_FEATURES +# ------------------------ +# Find out whether the shell is Bourne or XSI compatible, +# or has some other useful features. +m4_defun([_LT_CHECK_SHELL_FEATURES], +[AC_MSG_CHECKING([whether the shell understands some XSI constructs]) +# Try some XSI features +xsi_shell=no +( _lt_dummy="a/b/c" + test "${_lt_dummy##*/},${_lt_dummy%/*},${_lt_dummy#??}"${_lt_dummy%"$_lt_dummy"}, \ + = c,a/b,b/c, \ + && eval 'test $(( 1 + 1 )) -eq 2 \ + && test "${#_lt_dummy}" -eq 5' ) >/dev/null 2>&1 \ + && xsi_shell=yes +AC_MSG_RESULT([$xsi_shell]) +_LT_CONFIG_LIBTOOL_INIT([xsi_shell='$xsi_shell']) + +AC_MSG_CHECKING([whether the shell understands "+="]) +lt_shell_append=no +( foo=bar; set foo baz; eval "$[1]+=\$[2]" && test "$foo" = barbaz ) \ + >/dev/null 2>&1 \ + && lt_shell_append=yes +AC_MSG_RESULT([$lt_shell_append]) +_LT_CONFIG_LIBTOOL_INIT([lt_shell_append='$lt_shell_append']) + +if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then + lt_unset=unset +else + lt_unset=false +fi +_LT_DECL([], [lt_unset], [0], [whether the shell understands "unset"])dnl + +# test EBCDIC or ASCII +case `echo X|tr X '\101'` in + A) # ASCII based system + # \n is not interpreted correctly by Solaris 8 /usr/ucb/tr + lt_SP2NL='tr \040 \012' + lt_NL2SP='tr \015\012 \040\040' + ;; + *) # EBCDIC based system + lt_SP2NL='tr \100 \n' + lt_NL2SP='tr \r\n \100\100' + ;; +esac +_LT_DECL([SP2NL], [lt_SP2NL], [1], [turn spaces into newlines])dnl +_LT_DECL([NL2SP], [lt_NL2SP], [1], [turn newlines into spaces])dnl +])# _LT_CHECK_SHELL_FEATURES + + +# _LT_PROG_FUNCTION_REPLACE (FUNCNAME, REPLACEMENT-BODY) +# ------------------------------------------------------ +# In `$cfgfile', look for function FUNCNAME delimited by `^FUNCNAME ()$' and +# '^} FUNCNAME ', and replace its body with REPLACEMENT-BODY. +m4_defun([_LT_PROG_FUNCTION_REPLACE], +[dnl { +sed -e '/^$1 ()$/,/^} # $1 /c\ +$1 ()\ +{\ +m4_bpatsubsts([$2], [$], [\\], [^\([ ]\)], [\\\1]) +} # Extended-shell $1 implementation' "$cfgfile" > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") +test 0 -eq $? || _lt_function_replace_fail=: +]) + + +# _LT_PROG_REPLACE_SHELLFNS +# ------------------------- +# Replace existing portable implementations of several shell functions with +# equivalent extended shell implementations where those features are available.. +m4_defun([_LT_PROG_REPLACE_SHELLFNS], +[if test x"$xsi_shell" = xyes; then + _LT_PROG_FUNCTION_REPLACE([func_dirname], [dnl + case ${1} in + */*) func_dirname_result="${1%/*}${2}" ;; + * ) func_dirname_result="${3}" ;; + esac]) + + _LT_PROG_FUNCTION_REPLACE([func_basename], [dnl + func_basename_result="${1##*/}"]) + + _LT_PROG_FUNCTION_REPLACE([func_dirname_and_basename], [dnl + case ${1} in + */*) func_dirname_result="${1%/*}${2}" ;; + * ) func_dirname_result="${3}" ;; + esac + func_basename_result="${1##*/}"]) + + _LT_PROG_FUNCTION_REPLACE([func_stripname], [dnl + # pdksh 5.2.14 does not do ${X%$Y} correctly if both X and Y are + # positional parameters, so assign one to ordinary parameter first. + func_stripname_result=${3} + func_stripname_result=${func_stripname_result#"${1}"} + func_stripname_result=${func_stripname_result%"${2}"}]) + + _LT_PROG_FUNCTION_REPLACE([func_split_long_opt], [dnl + func_split_long_opt_name=${1%%=*} + func_split_long_opt_arg=${1#*=}]) + + _LT_PROG_FUNCTION_REPLACE([func_split_short_opt], [dnl + func_split_short_opt_arg=${1#??} + func_split_short_opt_name=${1%"$func_split_short_opt_arg"}]) + + _LT_PROG_FUNCTION_REPLACE([func_lo2o], [dnl + case ${1} in + *.lo) func_lo2o_result=${1%.lo}.${objext} ;; + *) func_lo2o_result=${1} ;; + esac]) + + _LT_PROG_FUNCTION_REPLACE([func_xform], [ func_xform_result=${1%.*}.lo]) + + _LT_PROG_FUNCTION_REPLACE([func_arith], [ func_arith_result=$(( $[*] ))]) + + _LT_PROG_FUNCTION_REPLACE([func_len], [ func_len_result=${#1}]) +fi + +if test x"$lt_shell_append" = xyes; then + _LT_PROG_FUNCTION_REPLACE([func_append], [ eval "${1}+=\\${2}"]) + + _LT_PROG_FUNCTION_REPLACE([func_append_quoted], [dnl + func_quote_for_eval "${2}" +dnl m4 expansion turns \\\\ into \\, and then the shell eval turns that into \ + eval "${1}+=\\\\ \\$func_quote_for_eval_result"]) + + # Save a `func_append' function call where possible by direct use of '+=' + sed -e 's%func_append \([[a-zA-Z_]]\{1,\}\) "%\1+="%g' $cfgfile > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") + test 0 -eq $? || _lt_function_replace_fail=: +else + # Save a `func_append' function call even when '+=' is not available + sed -e 's%func_append \([[a-zA-Z_]]\{1,\}\) "%\1="$\1%g' $cfgfile > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") + test 0 -eq $? || _lt_function_replace_fail=: +fi + +if test x"$_lt_function_replace_fail" = x":"; then + AC_MSG_WARN([Unable to substitute extended shell functions in $ofile]) +fi +]) + +# _LT_PATH_CONVERSION_FUNCTIONS +# ----------------------------- +# Determine which file name conversion functions should be used by +# func_to_host_file (and, implicitly, by func_to_host_path). These are needed +# for certain cross-compile configurations and native mingw. +m4_defun([_LT_PATH_CONVERSION_FUNCTIONS], +[AC_REQUIRE([AC_CANONICAL_HOST])dnl +AC_REQUIRE([AC_CANONICAL_BUILD])dnl +AC_MSG_CHECKING([how to convert $build file names to $host format]) +AC_CACHE_VAL(lt_cv_to_host_file_cmd, +[case $host in + *-*-mingw* ) + case $build in + *-*-mingw* ) # actually msys + lt_cv_to_host_file_cmd=func_convert_file_msys_to_w32 + ;; + *-*-cygwin* ) + lt_cv_to_host_file_cmd=func_convert_file_cygwin_to_w32 + ;; + * ) # otherwise, assume *nix + lt_cv_to_host_file_cmd=func_convert_file_nix_to_w32 + ;; + esac + ;; + *-*-cygwin* ) + case $build in + *-*-mingw* ) # actually msys + lt_cv_to_host_file_cmd=func_convert_file_msys_to_cygwin + ;; + *-*-cygwin* ) + lt_cv_to_host_file_cmd=func_convert_file_noop + ;; + * ) # otherwise, assume *nix + lt_cv_to_host_file_cmd=func_convert_file_nix_to_cygwin + ;; + esac + ;; + * ) # unhandled hosts (and "normal" native builds) + lt_cv_to_host_file_cmd=func_convert_file_noop + ;; +esac +]) +to_host_file_cmd=$lt_cv_to_host_file_cmd +AC_MSG_RESULT([$lt_cv_to_host_file_cmd]) +_LT_DECL([to_host_file_cmd], [lt_cv_to_host_file_cmd], + [0], [convert $build file names to $host format])dnl + +AC_MSG_CHECKING([how to convert $build file names to toolchain format]) +AC_CACHE_VAL(lt_cv_to_tool_file_cmd, +[#assume ordinary cross tools, or native build. +lt_cv_to_tool_file_cmd=func_convert_file_noop +case $host in + *-*-mingw* ) + case $build in + *-*-mingw* ) # actually msys + lt_cv_to_tool_file_cmd=func_convert_file_msys_to_w32 + ;; + esac + ;; +esac +]) +to_tool_file_cmd=$lt_cv_to_tool_file_cmd +AC_MSG_RESULT([$lt_cv_to_tool_file_cmd]) +_LT_DECL([to_tool_file_cmd], [lt_cv_to_tool_file_cmd], + [0], [convert $build files to toolchain format])dnl +])# _LT_PATH_CONVERSION_FUNCTIONS diff --git a/third-party/odb/libodb-2.4.0/m4/ltoptions.m4 b/third-party/odb/libodb-2.4.0/m4/ltoptions.m4 new file mode 100755 index 0000000..5d9acd8 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/m4/ltoptions.m4 @@ -0,0 +1,384 @@ +# Helper functions for option handling. -*- Autoconf -*- +# +# Copyright (C) 2004, 2005, 2007, 2008, 2009 Free Software Foundation, +# Inc. +# Written by Gary V. Vaughan, 2004 +# +# This file is free software; the Free Software Foundation gives +# unlimited permission to copy and/or distribute it, with or without +# modifications, as long as this notice is preserved. + +# serial 7 ltoptions.m4 + +# This is to help aclocal find these macros, as it can't see m4_define. +AC_DEFUN([LTOPTIONS_VERSION], [m4_if([1])]) + + +# _LT_MANGLE_OPTION(MACRO-NAME, OPTION-NAME) +# ------------------------------------------ +m4_define([_LT_MANGLE_OPTION], +[[_LT_OPTION_]m4_bpatsubst($1__$2, [[^a-zA-Z0-9_]], [_])]) + + +# _LT_SET_OPTION(MACRO-NAME, OPTION-NAME) +# --------------------------------------- +# Set option OPTION-NAME for macro MACRO-NAME, and if there is a +# matching handler defined, dispatch to it. Other OPTION-NAMEs are +# saved as a flag. +m4_define([_LT_SET_OPTION], +[m4_define(_LT_MANGLE_OPTION([$1], [$2]))dnl +m4_ifdef(_LT_MANGLE_DEFUN([$1], [$2]), + _LT_MANGLE_DEFUN([$1], [$2]), + [m4_warning([Unknown $1 option `$2'])])[]dnl +]) + + +# _LT_IF_OPTION(MACRO-NAME, OPTION-NAME, IF-SET, [IF-NOT-SET]) +# ------------------------------------------------------------ +# Execute IF-SET if OPTION is set, IF-NOT-SET otherwise. +m4_define([_LT_IF_OPTION], +[m4_ifdef(_LT_MANGLE_OPTION([$1], [$2]), [$3], [$4])]) + + +# _LT_UNLESS_OPTIONS(MACRO-NAME, OPTION-LIST, IF-NOT-SET) +# ------------------------------------------------------- +# Execute IF-NOT-SET unless all options in OPTION-LIST for MACRO-NAME +# are set. +m4_define([_LT_UNLESS_OPTIONS], +[m4_foreach([_LT_Option], m4_split(m4_normalize([$2])), + [m4_ifdef(_LT_MANGLE_OPTION([$1], _LT_Option), + [m4_define([$0_found])])])[]dnl +m4_ifdef([$0_found], [m4_undefine([$0_found])], [$3 +])[]dnl +]) + + +# _LT_SET_OPTIONS(MACRO-NAME, OPTION-LIST) +# ---------------------------------------- +# OPTION-LIST is a space-separated list of Libtool options associated +# with MACRO-NAME. If any OPTION has a matching handler declared with +# LT_OPTION_DEFINE, dispatch to that macro; otherwise complain about +# the unknown option and exit. +m4_defun([_LT_SET_OPTIONS], +[# Set options +m4_foreach([_LT_Option], m4_split(m4_normalize([$2])), + [_LT_SET_OPTION([$1], _LT_Option)]) + +m4_if([$1],[LT_INIT],[ + dnl + dnl Simply set some default values (i.e off) if boolean options were not + dnl specified: + _LT_UNLESS_OPTIONS([LT_INIT], [dlopen], [enable_dlopen=no + ]) + _LT_UNLESS_OPTIONS([LT_INIT], [win32-dll], [enable_win32_dll=no + ]) + dnl + dnl If no reference was made to various pairs of opposing options, then + dnl we run the default mode handler for the pair. For example, if neither + dnl `shared' nor `disable-shared' was passed, we enable building of shared + dnl archives by default: + _LT_UNLESS_OPTIONS([LT_INIT], [shared disable-shared], [_LT_ENABLE_SHARED]) + _LT_UNLESS_OPTIONS([LT_INIT], [static disable-static], [_LT_ENABLE_STATIC]) + _LT_UNLESS_OPTIONS([LT_INIT], [pic-only no-pic], [_LT_WITH_PIC]) + _LT_UNLESS_OPTIONS([LT_INIT], [fast-install disable-fast-install], + [_LT_ENABLE_FAST_INSTALL]) + ]) +])# _LT_SET_OPTIONS + + +## --------------------------------- ## +## Macros to handle LT_INIT options. ## +## --------------------------------- ## + +# _LT_MANGLE_DEFUN(MACRO-NAME, OPTION-NAME) +# ----------------------------------------- +m4_define([_LT_MANGLE_DEFUN], +[[_LT_OPTION_DEFUN_]m4_bpatsubst(m4_toupper([$1__$2]), [[^A-Z0-9_]], [_])]) + + +# LT_OPTION_DEFINE(MACRO-NAME, OPTION-NAME, CODE) +# ----------------------------------------------- +m4_define([LT_OPTION_DEFINE], +[m4_define(_LT_MANGLE_DEFUN([$1], [$2]), [$3])[]dnl +])# LT_OPTION_DEFINE + + +# dlopen +# ------ +LT_OPTION_DEFINE([LT_INIT], [dlopen], [enable_dlopen=yes +]) + +AU_DEFUN([AC_LIBTOOL_DLOPEN], +[_LT_SET_OPTION([LT_INIT], [dlopen]) +AC_DIAGNOSE([obsolete], +[$0: Remove this warning and the call to _LT_SET_OPTION when you +put the `dlopen' option into LT_INIT's first parameter.]) +]) + +dnl aclocal-1.4 backwards compatibility: +dnl AC_DEFUN([AC_LIBTOOL_DLOPEN], []) + + +# win32-dll +# --------- +# Declare package support for building win32 dll's. +LT_OPTION_DEFINE([LT_INIT], [win32-dll], +[enable_win32_dll=yes + +case $host in +*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-cegcc*) + AC_CHECK_TOOL(AS, as, false) + AC_CHECK_TOOL(DLLTOOL, dlltool, false) + AC_CHECK_TOOL(OBJDUMP, objdump, false) + ;; +esac + +test -z "$AS" && AS=as +_LT_DECL([], [AS], [1], [Assembler program])dnl + +test -z "$DLLTOOL" && DLLTOOL=dlltool +_LT_DECL([], [DLLTOOL], [1], [DLL creation program])dnl + +test -z "$OBJDUMP" && OBJDUMP=objdump +_LT_DECL([], [OBJDUMP], [1], [Object dumper program])dnl +])# win32-dll + +AU_DEFUN([AC_LIBTOOL_WIN32_DLL], +[AC_REQUIRE([AC_CANONICAL_HOST])dnl +_LT_SET_OPTION([LT_INIT], [win32-dll]) +AC_DIAGNOSE([obsolete], +[$0: Remove this warning and the call to _LT_SET_OPTION when you +put the `win32-dll' option into LT_INIT's first parameter.]) +]) + +dnl aclocal-1.4 backwards compatibility: +dnl AC_DEFUN([AC_LIBTOOL_WIN32_DLL], []) + + +# _LT_ENABLE_SHARED([DEFAULT]) +# ---------------------------- +# implement the --enable-shared flag, and supports the `shared' and +# `disable-shared' LT_INIT options. +# DEFAULT is either `yes' or `no'. If omitted, it defaults to `yes'. +m4_define([_LT_ENABLE_SHARED], +[m4_define([_LT_ENABLE_SHARED_DEFAULT], [m4_if($1, no, no, yes)])dnl +AC_ARG_ENABLE([shared], + [AS_HELP_STRING([--enable-shared@<:@=PKGS@:>@], + [build shared libraries @<:@default=]_LT_ENABLE_SHARED_DEFAULT[@:>@])], + [p=${PACKAGE-default} + case $enableval in + yes) enable_shared=yes ;; + no) enable_shared=no ;; + *) + enable_shared=no + # Look at the argument we got. We use all the common list separators. + lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR," + for pkg in $enableval; do + IFS="$lt_save_ifs" + if test "X$pkg" = "X$p"; then + enable_shared=yes + fi + done + IFS="$lt_save_ifs" + ;; + esac], + [enable_shared=]_LT_ENABLE_SHARED_DEFAULT) + + _LT_DECL([build_libtool_libs], [enable_shared], [0], + [Whether or not to build shared libraries]) +])# _LT_ENABLE_SHARED + +LT_OPTION_DEFINE([LT_INIT], [shared], [_LT_ENABLE_SHARED([yes])]) +LT_OPTION_DEFINE([LT_INIT], [disable-shared], [_LT_ENABLE_SHARED([no])]) + +# Old names: +AC_DEFUN([AC_ENABLE_SHARED], +[_LT_SET_OPTION([LT_INIT], m4_if([$1], [no], [disable-])[shared]) +]) + +AC_DEFUN([AC_DISABLE_SHARED], +[_LT_SET_OPTION([LT_INIT], [disable-shared]) +]) + +AU_DEFUN([AM_ENABLE_SHARED], [AC_ENABLE_SHARED($@)]) +AU_DEFUN([AM_DISABLE_SHARED], [AC_DISABLE_SHARED($@)]) + +dnl aclocal-1.4 backwards compatibility: +dnl AC_DEFUN([AM_ENABLE_SHARED], []) +dnl AC_DEFUN([AM_DISABLE_SHARED], []) + + + +# _LT_ENABLE_STATIC([DEFAULT]) +# ---------------------------- +# implement the --enable-static flag, and support the `static' and +# `disable-static' LT_INIT options. +# DEFAULT is either `yes' or `no'. If omitted, it defaults to `yes'. +m4_define([_LT_ENABLE_STATIC], +[m4_define([_LT_ENABLE_STATIC_DEFAULT], [m4_if($1, no, no, yes)])dnl +AC_ARG_ENABLE([static], + [AS_HELP_STRING([--enable-static@<:@=PKGS@:>@], + [build static libraries @<:@default=]_LT_ENABLE_STATIC_DEFAULT[@:>@])], + [p=${PACKAGE-default} + case $enableval in + yes) enable_static=yes ;; + no) enable_static=no ;; + *) + enable_static=no + # Look at the argument we got. We use all the common list separators. + lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR," + for pkg in $enableval; do + IFS="$lt_save_ifs" + if test "X$pkg" = "X$p"; then + enable_static=yes + fi + done + IFS="$lt_save_ifs" + ;; + esac], + [enable_static=]_LT_ENABLE_STATIC_DEFAULT) + + _LT_DECL([build_old_libs], [enable_static], [0], + [Whether or not to build static libraries]) +])# _LT_ENABLE_STATIC + +LT_OPTION_DEFINE([LT_INIT], [static], [_LT_ENABLE_STATIC([yes])]) +LT_OPTION_DEFINE([LT_INIT], [disable-static], [_LT_ENABLE_STATIC([no])]) + +# Old names: +AC_DEFUN([AC_ENABLE_STATIC], +[_LT_SET_OPTION([LT_INIT], m4_if([$1], [no], [disable-])[static]) +]) + +AC_DEFUN([AC_DISABLE_STATIC], +[_LT_SET_OPTION([LT_INIT], [disable-static]) +]) + +AU_DEFUN([AM_ENABLE_STATIC], [AC_ENABLE_STATIC($@)]) +AU_DEFUN([AM_DISABLE_STATIC], [AC_DISABLE_STATIC($@)]) + +dnl aclocal-1.4 backwards compatibility: +dnl AC_DEFUN([AM_ENABLE_STATIC], []) +dnl AC_DEFUN([AM_DISABLE_STATIC], []) + + + +# _LT_ENABLE_FAST_INSTALL([DEFAULT]) +# ---------------------------------- +# implement the --enable-fast-install flag, and support the `fast-install' +# and `disable-fast-install' LT_INIT options. +# DEFAULT is either `yes' or `no'. If omitted, it defaults to `yes'. +m4_define([_LT_ENABLE_FAST_INSTALL], +[m4_define([_LT_ENABLE_FAST_INSTALL_DEFAULT], [m4_if($1, no, no, yes)])dnl +AC_ARG_ENABLE([fast-install], + [AS_HELP_STRING([--enable-fast-install@<:@=PKGS@:>@], + [optimize for fast installation @<:@default=]_LT_ENABLE_FAST_INSTALL_DEFAULT[@:>@])], + [p=${PACKAGE-default} + case $enableval in + yes) enable_fast_install=yes ;; + no) enable_fast_install=no ;; + *) + enable_fast_install=no + # Look at the argument we got. We use all the common list separators. + lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR," + for pkg in $enableval; do + IFS="$lt_save_ifs" + if test "X$pkg" = "X$p"; then + enable_fast_install=yes + fi + done + IFS="$lt_save_ifs" + ;; + esac], + [enable_fast_install=]_LT_ENABLE_FAST_INSTALL_DEFAULT) + +_LT_DECL([fast_install], [enable_fast_install], [0], + [Whether or not to optimize for fast installation])dnl +])# _LT_ENABLE_FAST_INSTALL + +LT_OPTION_DEFINE([LT_INIT], [fast-install], [_LT_ENABLE_FAST_INSTALL([yes])]) +LT_OPTION_DEFINE([LT_INIT], [disable-fast-install], [_LT_ENABLE_FAST_INSTALL([no])]) + +# Old names: +AU_DEFUN([AC_ENABLE_FAST_INSTALL], +[_LT_SET_OPTION([LT_INIT], m4_if([$1], [no], [disable-])[fast-install]) +AC_DIAGNOSE([obsolete], +[$0: Remove this warning and the call to _LT_SET_OPTION when you put +the `fast-install' option into LT_INIT's first parameter.]) +]) + +AU_DEFUN([AC_DISABLE_FAST_INSTALL], +[_LT_SET_OPTION([LT_INIT], [disable-fast-install]) +AC_DIAGNOSE([obsolete], +[$0: Remove this warning and the call to _LT_SET_OPTION when you put +the `disable-fast-install' option into LT_INIT's first parameter.]) +]) + +dnl aclocal-1.4 backwards compatibility: +dnl AC_DEFUN([AC_ENABLE_FAST_INSTALL], []) +dnl AC_DEFUN([AM_DISABLE_FAST_INSTALL], []) + + +# _LT_WITH_PIC([MODE]) +# -------------------- +# implement the --with-pic flag, and support the `pic-only' and `no-pic' +# LT_INIT options. +# MODE is either `yes' or `no'. If omitted, it defaults to `both'. +m4_define([_LT_WITH_PIC], +[AC_ARG_WITH([pic], + [AS_HELP_STRING([--with-pic@<:@=PKGS@:>@], + [try to use only PIC/non-PIC objects @<:@default=use both@:>@])], + [lt_p=${PACKAGE-default} + case $withval in + yes|no) pic_mode=$withval ;; + *) + pic_mode=default + # Look at the argument we got. We use all the common list separators. + lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR," + for lt_pkg in $withval; do + IFS="$lt_save_ifs" + if test "X$lt_pkg" = "X$lt_p"; then + pic_mode=yes + fi + done + IFS="$lt_save_ifs" + ;; + esac], + [pic_mode=default]) + +test -z "$pic_mode" && pic_mode=m4_default([$1], [default]) + +_LT_DECL([], [pic_mode], [0], [What type of objects to build])dnl +])# _LT_WITH_PIC + +LT_OPTION_DEFINE([LT_INIT], [pic-only], [_LT_WITH_PIC([yes])]) +LT_OPTION_DEFINE([LT_INIT], [no-pic], [_LT_WITH_PIC([no])]) + +# Old name: +AU_DEFUN([AC_LIBTOOL_PICMODE], +[_LT_SET_OPTION([LT_INIT], [pic-only]) +AC_DIAGNOSE([obsolete], +[$0: Remove this warning and the call to _LT_SET_OPTION when you +put the `pic-only' option into LT_INIT's first parameter.]) +]) + +dnl aclocal-1.4 backwards compatibility: +dnl AC_DEFUN([AC_LIBTOOL_PICMODE], []) + +## ----------------- ## +## LTDL_INIT Options ## +## ----------------- ## + +m4_define([_LTDL_MODE], []) +LT_OPTION_DEFINE([LTDL_INIT], [nonrecursive], + [m4_define([_LTDL_MODE], [nonrecursive])]) +LT_OPTION_DEFINE([LTDL_INIT], [recursive], + [m4_define([_LTDL_MODE], [recursive])]) +LT_OPTION_DEFINE([LTDL_INIT], [subproject], + [m4_define([_LTDL_MODE], [subproject])]) + +m4_define([_LTDL_TYPE], []) +LT_OPTION_DEFINE([LTDL_INIT], [installable], + [m4_define([_LTDL_TYPE], [installable])]) +LT_OPTION_DEFINE([LTDL_INIT], [convenience], + [m4_define([_LTDL_TYPE], [convenience])]) diff --git a/third-party/odb/libodb-2.4.0/m4/ltsugar.m4 b/third-party/odb/libodb-2.4.0/m4/ltsugar.m4 new file mode 100755 index 0000000..9000a05 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/m4/ltsugar.m4 @@ -0,0 +1,123 @@ +# ltsugar.m4 -- libtool m4 base layer. -*-Autoconf-*- +# +# Copyright (C) 2004, 2005, 2007, 2008 Free Software Foundation, Inc. +# Written by Gary V. Vaughan, 2004 +# +# This file is free software; the Free Software Foundation gives +# unlimited permission to copy and/or distribute it, with or without +# modifications, as long as this notice is preserved. + +# serial 6 ltsugar.m4 + +# This is to help aclocal find these macros, as it can't see m4_define. +AC_DEFUN([LTSUGAR_VERSION], [m4_if([0.1])]) + + +# lt_join(SEP, ARG1, [ARG2...]) +# ----------------------------- +# Produce ARG1SEPARG2...SEPARGn, omitting [] arguments and their +# associated separator. +# Needed until we can rely on m4_join from Autoconf 2.62, since all earlier +# versions in m4sugar had bugs. +m4_define([lt_join], +[m4_if([$#], [1], [], + [$#], [2], [[$2]], + [m4_if([$2], [], [], [[$2]_])$0([$1], m4_shift(m4_shift($@)))])]) +m4_define([_lt_join], +[m4_if([$#$2], [2], [], + [m4_if([$2], [], [], [[$1$2]])$0([$1], m4_shift(m4_shift($@)))])]) + + +# lt_car(LIST) +# lt_cdr(LIST) +# ------------ +# Manipulate m4 lists. +# These macros are necessary as long as will still need to support +# Autoconf-2.59 which quotes differently. +m4_define([lt_car], [[$1]]) +m4_define([lt_cdr], +[m4_if([$#], 0, [m4_fatal([$0: cannot be called without arguments])], + [$#], 1, [], + [m4_dquote(m4_shift($@))])]) +m4_define([lt_unquote], $1) + + +# lt_append(MACRO-NAME, STRING, [SEPARATOR]) +# ------------------------------------------ +# Redefine MACRO-NAME to hold its former content plus `SEPARATOR'`STRING'. +# Note that neither SEPARATOR nor STRING are expanded; they are appended +# to MACRO-NAME as is (leaving the expansion for when MACRO-NAME is invoked). +# No SEPARATOR is output if MACRO-NAME was previously undefined (different +# than defined and empty). +# +# This macro is needed until we can rely on Autoconf 2.62, since earlier +# versions of m4sugar mistakenly expanded SEPARATOR but not STRING. +m4_define([lt_append], +[m4_define([$1], + m4_ifdef([$1], [m4_defn([$1])[$3]])[$2])]) + + + +# lt_combine(SEP, PREFIX-LIST, INFIX, SUFFIX1, [SUFFIX2...]) +# ---------------------------------------------------------- +# Produce a SEP delimited list of all paired combinations of elements of +# PREFIX-LIST with SUFFIX1 through SUFFIXn. Each element of the list +# has the form PREFIXmINFIXSUFFIXn. +# Needed until we can rely on m4_combine added in Autoconf 2.62. +m4_define([lt_combine], +[m4_if(m4_eval([$# > 3]), [1], + [m4_pushdef([_Lt_sep], [m4_define([_Lt_sep], m4_defn([lt_car]))])]]dnl +[[m4_foreach([_Lt_prefix], [$2], + [m4_foreach([_Lt_suffix], + ]m4_dquote(m4_dquote(m4_shift(m4_shift(m4_shift($@)))))[, + [_Lt_sep([$1])[]m4_defn([_Lt_prefix])[$3]m4_defn([_Lt_suffix])])])])]) + + +# lt_if_append_uniq(MACRO-NAME, VARNAME, [SEPARATOR], [UNIQ], [NOT-UNIQ]) +# ----------------------------------------------------------------------- +# Iff MACRO-NAME does not yet contain VARNAME, then append it (delimited +# by SEPARATOR if supplied) and expand UNIQ, else NOT-UNIQ. +m4_define([lt_if_append_uniq], +[m4_ifdef([$1], + [m4_if(m4_index([$3]m4_defn([$1])[$3], [$3$2$3]), [-1], + [lt_append([$1], [$2], [$3])$4], + [$5])], + [lt_append([$1], [$2], [$3])$4])]) + + +# lt_dict_add(DICT, KEY, VALUE) +# ----------------------------- +m4_define([lt_dict_add], +[m4_define([$1($2)], [$3])]) + + +# lt_dict_add_subkey(DICT, KEY, SUBKEY, VALUE) +# -------------------------------------------- +m4_define([lt_dict_add_subkey], +[m4_define([$1($2:$3)], [$4])]) + + +# lt_dict_fetch(DICT, KEY, [SUBKEY]) +# ---------------------------------- +m4_define([lt_dict_fetch], +[m4_ifval([$3], + m4_ifdef([$1($2:$3)], [m4_defn([$1($2:$3)])]), + m4_ifdef([$1($2)], [m4_defn([$1($2)])]))]) + + +# lt_if_dict_fetch(DICT, KEY, [SUBKEY], VALUE, IF-TRUE, [IF-FALSE]) +# ----------------------------------------------------------------- +m4_define([lt_if_dict_fetch], +[m4_if(lt_dict_fetch([$1], [$2], [$3]), [$4], + [$5], + [$6])]) + + +# lt_dict_filter(DICT, [SUBKEY], VALUE, [SEPARATOR], KEY, [...]) +# -------------------------------------------------------------- +m4_define([lt_dict_filter], +[m4_if([$5], [], [], + [lt_join(m4_quote(m4_default([$4], [[, ]])), + lt_unquote(m4_split(m4_normalize(m4_foreach(_Lt_key, lt_car([m4_shiftn(4, $@)]), + [lt_if_dict_fetch([$1], _Lt_key, [$2], [$3], [_Lt_key ])])))))])[]dnl +]) diff --git a/third-party/odb/libodb-2.4.0/m4/ltversion.m4 b/third-party/odb/libodb-2.4.0/m4/ltversion.m4 new file mode 100755 index 0000000..07a8602 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/m4/ltversion.m4 @@ -0,0 +1,23 @@ +# ltversion.m4 -- version numbers -*- Autoconf -*- +# +# Copyright (C) 2004 Free Software Foundation, Inc. +# Written by Scott James Remnant, 2004 +# +# This file is free software; the Free Software Foundation gives +# unlimited permission to copy and/or distribute it, with or without +# modifications, as long as this notice is preserved. + +# @configure_input@ + +# serial 3337 ltversion.m4 +# This file is part of GNU Libtool + +m4_define([LT_PACKAGE_VERSION], [2.4.2]) +m4_define([LT_PACKAGE_REVISION], [1.3337]) + +AC_DEFUN([LTVERSION_VERSION], +[macro_version='2.4.2' +macro_revision='1.3337' +_LT_DECL(, macro_version, 0, [Which release of libtool.m4 was used?]) +_LT_DECL(, macro_revision, 0) +]) diff --git a/third-party/odb/libodb-2.4.0/m4/lt~obsolete.m4 b/third-party/odb/libodb-2.4.0/m4/lt~obsolete.m4 new file mode 100755 index 0000000..c573da9 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/m4/lt~obsolete.m4 @@ -0,0 +1,98 @@ +# lt~obsolete.m4 -- aclocal satisfying obsolete definitions. -*-Autoconf-*- +# +# Copyright (C) 2004, 2005, 2007, 2009 Free Software Foundation, Inc. +# Written by Scott James Remnant, 2004. +# +# This file is free software; the Free Software Foundation gives +# unlimited permission to copy and/or distribute it, with or without +# modifications, as long as this notice is preserved. + +# serial 5 lt~obsolete.m4 + +# These exist entirely to fool aclocal when bootstrapping libtool. +# +# In the past libtool.m4 has provided macros via AC_DEFUN (or AU_DEFUN) +# which have later been changed to m4_define as they aren't part of the +# exported API, or moved to Autoconf or Automake where they belong. +# +# The trouble is, aclocal is a bit thick. It'll see the old AC_DEFUN +# in /usr/share/aclocal/libtool.m4 and remember it, then when it sees us +# using a macro with the same name in our local m4/libtool.m4 it'll +# pull the old libtool.m4 in (it doesn't see our shiny new m4_define +# and doesn't know about Autoconf macros at all.) +# +# So we provide this file, which has a silly filename so it's always +# included after everything else. This provides aclocal with the +# AC_DEFUNs it wants, but when m4 processes it, it doesn't do anything +# because those macros already exist, or will be overwritten later. +# We use AC_DEFUN over AU_DEFUN for compatibility with aclocal-1.6. +# +# Anytime we withdraw an AC_DEFUN or AU_DEFUN, remember to add it here. +# Yes, that means every name once taken will need to remain here until +# we give up compatibility with versions before 1.7, at which point +# we need to keep only those names which we still refer to. + +# This is to help aclocal find these macros, as it can't see m4_define. +AC_DEFUN([LTOBSOLETE_VERSION], [m4_if([1])]) + +m4_ifndef([AC_LIBTOOL_LINKER_OPTION], [AC_DEFUN([AC_LIBTOOL_LINKER_OPTION])]) +m4_ifndef([AC_PROG_EGREP], [AC_DEFUN([AC_PROG_EGREP])]) +m4_ifndef([_LT_AC_PROG_ECHO_BACKSLASH], [AC_DEFUN([_LT_AC_PROG_ECHO_BACKSLASH])]) +m4_ifndef([_LT_AC_SHELL_INIT], [AC_DEFUN([_LT_AC_SHELL_INIT])]) +m4_ifndef([_LT_AC_SYS_LIBPATH_AIX], [AC_DEFUN([_LT_AC_SYS_LIBPATH_AIX])]) +m4_ifndef([_LT_PROG_LTMAIN], [AC_DEFUN([_LT_PROG_LTMAIN])]) +m4_ifndef([_LT_AC_TAGVAR], [AC_DEFUN([_LT_AC_TAGVAR])]) +m4_ifndef([AC_LTDL_ENABLE_INSTALL], [AC_DEFUN([AC_LTDL_ENABLE_INSTALL])]) +m4_ifndef([AC_LTDL_PREOPEN], [AC_DEFUN([AC_LTDL_PREOPEN])]) +m4_ifndef([_LT_AC_SYS_COMPILER], [AC_DEFUN([_LT_AC_SYS_COMPILER])]) +m4_ifndef([_LT_AC_LOCK], [AC_DEFUN([_LT_AC_LOCK])]) +m4_ifndef([AC_LIBTOOL_SYS_OLD_ARCHIVE], [AC_DEFUN([AC_LIBTOOL_SYS_OLD_ARCHIVE])]) +m4_ifndef([_LT_AC_TRY_DLOPEN_SELF], [AC_DEFUN([_LT_AC_TRY_DLOPEN_SELF])]) +m4_ifndef([AC_LIBTOOL_PROG_CC_C_O], [AC_DEFUN([AC_LIBTOOL_PROG_CC_C_O])]) +m4_ifndef([AC_LIBTOOL_SYS_HARD_LINK_LOCKS], [AC_DEFUN([AC_LIBTOOL_SYS_HARD_LINK_LOCKS])]) +m4_ifndef([AC_LIBTOOL_OBJDIR], [AC_DEFUN([AC_LIBTOOL_OBJDIR])]) +m4_ifndef([AC_LTDL_OBJDIR], [AC_DEFUN([AC_LTDL_OBJDIR])]) +m4_ifndef([AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH], [AC_DEFUN([AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH])]) +m4_ifndef([AC_LIBTOOL_SYS_LIB_STRIP], [AC_DEFUN([AC_LIBTOOL_SYS_LIB_STRIP])]) +m4_ifndef([AC_PATH_MAGIC], [AC_DEFUN([AC_PATH_MAGIC])]) +m4_ifndef([AC_PROG_LD_GNU], [AC_DEFUN([AC_PROG_LD_GNU])]) +m4_ifndef([AC_PROG_LD_RELOAD_FLAG], [AC_DEFUN([AC_PROG_LD_RELOAD_FLAG])]) +m4_ifndef([AC_DEPLIBS_CHECK_METHOD], [AC_DEFUN([AC_DEPLIBS_CHECK_METHOD])]) +m4_ifndef([AC_LIBTOOL_PROG_COMPILER_NO_RTTI], [AC_DEFUN([AC_LIBTOOL_PROG_COMPILER_NO_RTTI])]) +m4_ifndef([AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE], [AC_DEFUN([AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE])]) +m4_ifndef([AC_LIBTOOL_PROG_COMPILER_PIC], [AC_DEFUN([AC_LIBTOOL_PROG_COMPILER_PIC])]) +m4_ifndef([AC_LIBTOOL_PROG_LD_SHLIBS], [AC_DEFUN([AC_LIBTOOL_PROG_LD_SHLIBS])]) +m4_ifndef([AC_LIBTOOL_POSTDEP_PREDEP], [AC_DEFUN([AC_LIBTOOL_POSTDEP_PREDEP])]) +m4_ifndef([LT_AC_PROG_EGREP], [AC_DEFUN([LT_AC_PROG_EGREP])]) +m4_ifndef([LT_AC_PROG_SED], [AC_DEFUN([LT_AC_PROG_SED])]) +m4_ifndef([_LT_CC_BASENAME], [AC_DEFUN([_LT_CC_BASENAME])]) +m4_ifndef([_LT_COMPILER_BOILERPLATE], [AC_DEFUN([_LT_COMPILER_BOILERPLATE])]) +m4_ifndef([_LT_LINKER_BOILERPLATE], [AC_DEFUN([_LT_LINKER_BOILERPLATE])]) +m4_ifndef([_AC_PROG_LIBTOOL], [AC_DEFUN([_AC_PROG_LIBTOOL])]) +m4_ifndef([AC_LIBTOOL_SETUP], [AC_DEFUN([AC_LIBTOOL_SETUP])]) +m4_ifndef([_LT_AC_CHECK_DLFCN], [AC_DEFUN([_LT_AC_CHECK_DLFCN])]) +m4_ifndef([AC_LIBTOOL_SYS_DYNAMIC_LINKER], [AC_DEFUN([AC_LIBTOOL_SYS_DYNAMIC_LINKER])]) +m4_ifndef([_LT_AC_TAGCONFIG], [AC_DEFUN([_LT_AC_TAGCONFIG])]) +m4_ifndef([AC_DISABLE_FAST_INSTALL], [AC_DEFUN([AC_DISABLE_FAST_INSTALL])]) +m4_ifndef([_LT_AC_LANG_CXX], [AC_DEFUN([_LT_AC_LANG_CXX])]) +m4_ifndef([_LT_AC_LANG_F77], [AC_DEFUN([_LT_AC_LANG_F77])]) +m4_ifndef([_LT_AC_LANG_GCJ], [AC_DEFUN([_LT_AC_LANG_GCJ])]) +m4_ifndef([AC_LIBTOOL_LANG_C_CONFIG], [AC_DEFUN([AC_LIBTOOL_LANG_C_CONFIG])]) +m4_ifndef([_LT_AC_LANG_C_CONFIG], [AC_DEFUN([_LT_AC_LANG_C_CONFIG])]) +m4_ifndef([AC_LIBTOOL_LANG_CXX_CONFIG], [AC_DEFUN([AC_LIBTOOL_LANG_CXX_CONFIG])]) +m4_ifndef([_LT_AC_LANG_CXX_CONFIG], [AC_DEFUN([_LT_AC_LANG_CXX_CONFIG])]) +m4_ifndef([AC_LIBTOOL_LANG_F77_CONFIG], [AC_DEFUN([AC_LIBTOOL_LANG_F77_CONFIG])]) +m4_ifndef([_LT_AC_LANG_F77_CONFIG], [AC_DEFUN([_LT_AC_LANG_F77_CONFIG])]) +m4_ifndef([AC_LIBTOOL_LANG_GCJ_CONFIG], [AC_DEFUN([AC_LIBTOOL_LANG_GCJ_CONFIG])]) +m4_ifndef([_LT_AC_LANG_GCJ_CONFIG], [AC_DEFUN([_LT_AC_LANG_GCJ_CONFIG])]) +m4_ifndef([AC_LIBTOOL_LANG_RC_CONFIG], [AC_DEFUN([AC_LIBTOOL_LANG_RC_CONFIG])]) +m4_ifndef([_LT_AC_LANG_RC_CONFIG], [AC_DEFUN([_LT_AC_LANG_RC_CONFIG])]) +m4_ifndef([AC_LIBTOOL_CONFIG], [AC_DEFUN([AC_LIBTOOL_CONFIG])]) +m4_ifndef([_LT_AC_FILE_LTDLL_C], [AC_DEFUN([_LT_AC_FILE_LTDLL_C])]) +m4_ifndef([_LT_REQUIRED_DARWIN_CHECKS], [AC_DEFUN([_LT_REQUIRED_DARWIN_CHECKS])]) +m4_ifndef([_LT_AC_PROG_CXXCPP], [AC_DEFUN([_LT_AC_PROG_CXXCPP])]) +m4_ifndef([_LT_PREPARE_SED_QUOTE_VARS], [AC_DEFUN([_LT_PREPARE_SED_QUOTE_VARS])]) +m4_ifndef([_LT_PROG_ECHO_BACKSLASH], [AC_DEFUN([_LT_PROG_ECHO_BACKSLASH])]) +m4_ifndef([_LT_PROG_F77], [AC_DEFUN([_LT_PROG_F77])]) +m4_ifndef([_LT_PROG_FC], [AC_DEFUN([_LT_PROG_FC])]) +m4_ifndef([_LT_PROG_CXX], [AC_DEFUN([_LT_PROG_CXX])]) diff --git a/third-party/odb/libodb-2.4.0/m4/pkgconfig.m4 b/third-party/odb/libodb-2.4.0/m4/pkgconfig.m4 new file mode 100755 index 0000000..63a62b5 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/m4/pkgconfig.m4 @@ -0,0 +1,12 @@ +dnl file : m4/pkgconfig.m4 +dnl copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +dnl license : GNU GPL v2; see accompanying LICENSE file +dnl +AC_DEFUN([PKGCONFIG],[ +AC_ARG_WITH( + [pkgconfigdir], + [AC_HELP_STRING([--with-pkgconfigdir=DIR],[location of pkgconfig dir (default is libdir/pkgconfig)])], + [pkgconfigdir=${withval}], + [pkgconfigdir='${libdir}/pkgconfig']) +AC_SUBST([pkgconfigdir]) +])dnl diff --git a/third-party/odb/libodb-2.4.0/m4/static-lib.m4 b/third-party/odb/libodb-2.4.0/m4/static-lib.m4 new file mode 100755 index 0000000..1f49f8f --- /dev/null +++ b/third-party/odb/libodb-2.4.0/m4/static-lib.m4 @@ -0,0 +1,18 @@ +dnl file : m4/static-lib.m4 +dnl copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +dnl license : GNU GPL v2; see accompanying LICENSE file +dnl +dnl STATIC_LIB(MACRO, DESCRIPTION) +dnl +dnl Define MACRO if we are on MinGW and are only building static library. +dnl +AC_DEFUN([STATIC_LIB], +[ +if test x$enable_shared = xno; then + case $host_os in + mingw*) + AC_DEFINE([$1], [1], [$2]) + ;; + esac +fi +])dnl diff --git a/third-party/odb/libodb-2.4.0/m4/threads.m4 b/third-party/odb/libodb-2.4.0/m4/threads.m4 new file mode 100755 index 0000000..f02850f --- /dev/null +++ b/third-party/odb/libodb-2.4.0/m4/threads.m4 @@ -0,0 +1,69 @@ +dnl file : m4/threads.m4 +dnl copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +dnl license : GNU GPL v2; see accompanying LICENSE file +dnl +AC_DEFUN([THREADS],[ + +threads_thread_keyword=no + +AC_ARG_ENABLE( + [threads], + AS_HELP_STRING([--disable-threads], [disable threads (enabled by default)]), + [AS_IF([test x"$enableval" = xno], [threads=none], [threads=check])], + [threads=check]) + +# If thread support is not disabled by the user, figure out what we can use. +# +if test x$threads = xcheck; then + case $host_os in + windows* | mingw*) + case $host_os in + mingw*) + CXXFLAGS="$CXXFLAGS -mthreads" + ;; + esac + + # Newer versions of GCC can be configured to use either Win32 or POSIX + # threads. It appears that -mthreads should be used in both cases but + # if the model is POSIX then GCC will also link -lpthread by default. + # Use that fact to test which model we have. + # + AC_TRY_LINK([#include ], + [pthread_create(0,0,0,0);], + [threads=posix], + [threads=win32]) + ;; + *) + ACX_PTHREAD + + if test x$acx_pthread_ok = xyes; then + threads=posix + LIBS="$LIBS $PTHREAD_LIBS" + CXXFLAGS="$CXXFLAGS $PTHREAD_CXXFLAGS" + + # Check if we can use the __thread keyword. + # + AC_MSG_CHECKING([for __thread keyword]) + + CXX_LIBTOOL_LINK_IFELSE([ + AC_LANG_SOURCE([ + __thread int tls_var; + + int + main () + { + tls_var = 0; + } + ])], + [threads_thread_keyword=yes]) + + AC_MSG_RESULT([$threads_thread_keyword]) + fi + ;; + esac +fi + +if test x$threads = xcheck; then + AC_MSG_ERROR([thread support not available; use --disable-threads to force single-threaded mode]) +fi +])dnl diff --git a/third-party/odb/libodb-2.4.0/odb/Makefile.am b/third-party/odb/libodb-2.4.0/odb/Makefile.am new file mode 100755 index 0000000..a6f5750 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/Makefile.am @@ -0,0 +1,32 @@ +# file : odb/Makefile.am +# copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +# license : GNU GPL v2; see accompanying LICENSE file + +lib_LTLIBRARIES = libodb.la +libodb_la_SOURCES = callback.cxx exceptions.cxx database.cxx vector-impl.cxx connection.cxx lazy-ptr-impl.cxx prepared-query.cxx query-dynamic.cxx result.cxx schema-catalog.cxx section.cxx session.cxx statement.cxx statement-processing.cxx tracer.cxx transaction.cxx details/buffer.cxx details/condition.cxx details/lock.cxx details/mutex.cxx details/shared-ptr/base.cxx + +odbincludedir = $(includedir)/odb +nobase_odbinclude_HEADERS = std-unordered-map-traits.hxx query-dynamic.txx traits.hxx schema-catalog-impl.hxx version.hxx polymorphic-map.hxx result.hxx lazy-ptr-impl.txx schema-catalog.hxx pointer-traits.hxx std-list-traits.hxx compilers/vc/post.hxx compilers/vc/pre.hxx query-dynamic.hxx statement.hxx vector-traits.hxx object-result.hxx std-set-traits.hxx lazy-ptr.hxx vector.hxx prepared-query.hxx exception.hxx vector-impl.ixx vector.ixx std-array-traits.hxx no-op-cache-traits.hxx section.hxx no-id-object-result.txx lazy-ptr-impl.hxx container-traits.hxx view-result.hxx transaction.hxx polymorphic-object-result.txx view-image.hxx connection.ixx connection.txx std-vector-traits.hxx view-result.txx tracer.hxx database.ixx post.hxx schema-version.hxx vector-traits.txx session.ixx forward.hxx polymorphic-map.txx function-table.hxx session.hxx connection.hxx std-unordered-set-traits.hxx details/lock.hxx details/thread.hxx details/shared-ptr-fwd.hxx details/tls.hxx details/wrapper-p.hxx details/shared-ptr/base.txx details/shared-ptr/exception.hxx details/shared-ptr/counter-type.hxx details/shared-ptr/base.ixx details/shared-ptr/base.hxx details/exception.hxx details/type-info.hxx details/function-wrapper.hxx details/function-wrapper.txx details/meta/remove-volatile.hxx details/meta/class-p.hxx details/meta/remove-const.hxx details/meta/static-assert.hxx details/meta/remove-const-volatile.hxx details/meta/polymorphic-p.hxx details/meta/answer.hxx details/meta/remove-pointer.hxx details/condition.hxx details/buffer.hxx details/shared-ptr.hxx details/transfer-ptr.hxx details/mutex.hxx details/c-string.hxx details/export.hxx details/function-wrapper.ixx details/unused.hxx details/config.hxx details/unique-ptr.hxx polymorphic-map.ixx cache-traits.hxx simple-object-result.txx std-map-traits.hxx lazy-pointer-traits.hxx std-forward-list-traits.hxx lazy-ptr-impl.ixx core.hxx simple-object-result.hxx result.txx polymorphic-info.hxx database.txx tr1/pointer-traits.hxx tr1/lazy-ptr.hxx tr1/memory.hxx tr1/lazy-pointer-traits.hxx tr1/lazy-ptr.ixx tr1/wrapper-traits.hxx tr1/lazy-ptr.txx pre.hxx query-dynamic.ixx query.hxx transaction.ixx callback.hxx lazy-ptr.ixx polymorphic-object-result.hxx wrapper-traits.hxx exceptions.hxx nullable.hxx no-id-object-result.hxx session.txx lazy-ptr.txx vector-impl.hxx database.hxx std-deque-traits.hxx statement-processing-common.hxx +nobase_nodist_odbinclude_HEADERS = details/config.h + +EXTRA_DIST = details/config-vc.h libodb-vc8.vcproj libodb-vc9.vcproj libodb-vc10.vcxproj libodb-vc10.vcxproj.filters libodb-vc11.vcxproj libodb-vc11.vcxproj.filters libodb-vc12.vcxproj libodb-vc12.vcxproj.filters + +# At the moment, DllMain() is only necessary if we are using Win32 +# threads. So keep win32_dll_sources in ODB_THREADS_WIN32. +# +if ODB_WIN32 +nobase_odbinclude_HEADERS += details/win32/windows.hxx +endif + +if ODB_THREADS_POSIX +libodb_la_SOURCES += details/posix/exceptions.cxx details/posix/thread.cxx +nobase_odbinclude_HEADERS += details/posix/thread.hxx details/posix/tls.hxx details/posix/condition.hxx details/posix/mutex.ixx details/posix/mutex.hxx details/posix/thread.ixx details/posix/tls.ixx details/posix/tls.txx details/posix/condition.ixx details/posix/exceptions.hxx +endif + +if ODB_THREADS_WIN32 +libodb_la_SOURCES += details/win32/init.cxx details/win32/once.cxx details/win32/tls.cxx details/win32/condition.cxx details/win32/thread.cxx details/win32/exceptions.cxx details/win32/dll.cxx +nobase_odbinclude_HEADERS += details/win32/lock.hxx details/win32/thread.hxx details/win32/once-init.hxx details/win32/tls.hxx details/win32/condition.hxx details/win32/tls-init.hxx details/win32/mutex.ixx details/win32/mutex.hxx details/win32/once.hxx details/win32/once.ixx details/win32/tls.ixx details/win32/tls.txx details/win32/condition.ixx details/win32/init.hxx details/win32/exceptions.hxx +endif + +AM_CPPFLAGS= -I'$(top_builddir)' -I'$(top_srcdir)' -DLIBODB_DYNAMIC_LIB +AM_LDFLAGS = -release 2.4 -no-undefined diff --git a/third-party/odb/libodb-2.4.0/odb/Makefile.in b/third-party/odb/libodb-2.4.0/odb/Makefile.in new file mode 100755 index 0000000..f25133a --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/Makefile.in @@ -0,0 +1,917 @@ +# Makefile.in generated by automake 1.12.6 from Makefile.am. +# @configure_input@ + +# Copyright (C) 1994-2012 Free Software Foundation, Inc. + +# This Makefile.in is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY, to the extent permitted by law; without +# even the implied warranty of MERCHANTABILITY or FITNESS FOR A +# PARTICULAR PURPOSE. + +@SET_MAKE@ + +# file : odb/Makefile.am +# copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +# license : GNU GPL v2; see accompanying LICENSE file + + +VPATH = @srcdir@ +am__make_dryrun = \ + { \ + am__dry=no; \ + case $$MAKEFLAGS in \ + *\\[\ \ ]*) \ + echo 'am--echo: ; @echo "AM" OK' | $(MAKE) -f - 2>/dev/null \ + | grep '^AM OK$$' >/dev/null || am__dry=yes;; \ + *) \ + for am__flg in $$MAKEFLAGS; do \ + case $$am__flg in \ + *=*|--*) ;; \ + *n*) am__dry=yes; break;; \ + esac; \ + done;; \ + esac; \ + test $$am__dry = yes; \ + } +pkgdatadir = $(datadir)/@PACKAGE@ +pkgincludedir = $(includedir)/@PACKAGE@ +pkglibdir = $(libdir)/@PACKAGE@ +pkglibexecdir = $(libexecdir)/@PACKAGE@ +am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd +install_sh_DATA = $(install_sh) -c -m 644 +install_sh_PROGRAM = $(install_sh) -c +install_sh_SCRIPT = $(install_sh) -c +INSTALL_HEADER = $(INSTALL_DATA) +transform = $(program_transform_name) +NORMAL_INSTALL = : +PRE_INSTALL = : +POST_INSTALL = : +NORMAL_UNINSTALL = : +PRE_UNINSTALL = : +POST_UNINSTALL = : +build_triplet = @build@ +host_triplet = @host@ + +# At the moment, DllMain() is only necessary if we are using Win32 +# threads. So keep win32_dll_sources in ODB_THREADS_WIN32. +# +@ODB_WIN32_TRUE@am__append_1 = details/win32/windows.hxx +@ODB_THREADS_POSIX_TRUE@am__append_2 = details/posix/exceptions.cxx details/posix/thread.cxx +@ODB_THREADS_POSIX_TRUE@am__append_3 = details/posix/thread.hxx details/posix/tls.hxx details/posix/condition.hxx details/posix/mutex.ixx details/posix/mutex.hxx details/posix/thread.ixx details/posix/tls.ixx details/posix/tls.txx details/posix/condition.ixx details/posix/exceptions.hxx +@ODB_THREADS_WIN32_TRUE@am__append_4 = details/win32/init.cxx details/win32/once.cxx details/win32/tls.cxx details/win32/condition.cxx details/win32/thread.cxx details/win32/exceptions.cxx details/win32/dll.cxx +@ODB_THREADS_WIN32_TRUE@am__append_5 = details/win32/lock.hxx details/win32/thread.hxx details/win32/once-init.hxx details/win32/tls.hxx details/win32/condition.hxx details/win32/tls-init.hxx details/win32/mutex.ixx details/win32/mutex.hxx details/win32/once.hxx details/win32/once.ixx details/win32/tls.ixx details/win32/tls.txx details/win32/condition.ixx details/win32/init.hxx details/win32/exceptions.hxx +subdir = odb +DIST_COMMON = $(am__nobase_odbinclude_HEADERS_DIST) \ + $(srcdir)/Makefile.am $(srcdir)/Makefile.in \ + $(srcdir)/config.h.in $(top_srcdir)/config/depcomp +ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 +am__aclocal_m4_deps = $(top_srcdir)/m4/acx-pthread.m4 \ + $(top_srcdir)/m4/disable-rpath.m4 \ + $(top_srcdir)/m4/libtool-link.m4 $(top_srcdir)/m4/libtool.m4 \ + $(top_srcdir)/m4/ltoptions.m4 $(top_srcdir)/m4/ltsugar.m4 \ + $(top_srcdir)/m4/ltversion.m4 $(top_srcdir)/m4/lt~obsolete.m4 \ + $(top_srcdir)/m4/pkgconfig.m4 $(top_srcdir)/m4/static-lib.m4 \ + $(top_srcdir)/m4/threads.m4 $(top_srcdir)/configure.ac +am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \ + $(ACLOCAL_M4) +mkinstalldirs = $(install_sh) -d +CONFIG_HEADER = config.h $(top_builddir)/odb/details/config.h +CONFIG_CLEAN_FILES = +CONFIG_CLEAN_VPATH_FILES = +am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`; +am__vpath_adj = case $$p in \ + $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \ + *) f=$$p;; \ + esac; +am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`; +am__install_max = 40 +am__nobase_strip_setup = \ + srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'` +am__nobase_strip = \ + for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||" +am__nobase_list = $(am__nobase_strip_setup); \ + for p in $$list; do echo "$$p $$p"; done | \ + sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \ + $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \ + if (++n[$$2] == $(am__install_max)) \ + { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \ + END { for (dir in files) print dir, files[dir] }' +am__base_list = \ + sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \ + sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g' +am__uninstall_files_from_dir = { \ + test -z "$$files" \ + || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \ + || { echo " ( cd '$$dir' && rm -f" $$files ")"; \ + $(am__cd) "$$dir" && rm -f $$files; }; \ + } +am__installdirs = "$(DESTDIR)$(libdir)" "$(DESTDIR)$(odbincludedir)" \ + "$(DESTDIR)$(odbincludedir)" +LTLIBRARIES = $(lib_LTLIBRARIES) +libodb_la_LIBADD = +am__libodb_la_SOURCES_DIST = callback.cxx exceptions.cxx database.cxx \ + vector-impl.cxx connection.cxx lazy-ptr-impl.cxx \ + prepared-query.cxx query-dynamic.cxx result.cxx \ + schema-catalog.cxx section.cxx session.cxx statement.cxx \ + statement-processing.cxx tracer.cxx transaction.cxx \ + details/buffer.cxx details/condition.cxx details/lock.cxx \ + details/mutex.cxx details/shared-ptr/base.cxx \ + details/posix/exceptions.cxx details/posix/thread.cxx \ + details/win32/init.cxx details/win32/once.cxx \ + details/win32/tls.cxx details/win32/condition.cxx \ + details/win32/thread.cxx details/win32/exceptions.cxx \ + details/win32/dll.cxx +am__dirstamp = $(am__leading_dot)dirstamp +@ODB_THREADS_POSIX_TRUE@am__objects_1 = details/posix/exceptions.lo \ +@ODB_THREADS_POSIX_TRUE@ details/posix/thread.lo +@ODB_THREADS_WIN32_TRUE@am__objects_2 = details/win32/init.lo \ +@ODB_THREADS_WIN32_TRUE@ details/win32/once.lo \ +@ODB_THREADS_WIN32_TRUE@ details/win32/tls.lo \ +@ODB_THREADS_WIN32_TRUE@ details/win32/condition.lo \ +@ODB_THREADS_WIN32_TRUE@ details/win32/thread.lo \ +@ODB_THREADS_WIN32_TRUE@ details/win32/exceptions.lo \ +@ODB_THREADS_WIN32_TRUE@ details/win32/dll.lo +am_libodb_la_OBJECTS = callback.lo exceptions.lo database.lo \ + vector-impl.lo connection.lo lazy-ptr-impl.lo \ + prepared-query.lo query-dynamic.lo result.lo schema-catalog.lo \ + section.lo session.lo statement.lo statement-processing.lo \ + tracer.lo transaction.lo details/buffer.lo \ + details/condition.lo details/lock.lo details/mutex.lo \ + details/shared-ptr/base.lo $(am__objects_1) $(am__objects_2) +libodb_la_OBJECTS = $(am_libodb_la_OBJECTS) +DEFAULT_INCLUDES = +depcomp = $(SHELL) $(top_srcdir)/config/depcomp +am__depfiles_maybe = depfiles +am__mv = mv -f +CXXCOMPILE = $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \ + $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) +LTCXXCOMPILE = $(LIBTOOL) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \ + --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \ + $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) +CXXLD = $(CXX) +CXXLINK = $(LIBTOOL) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \ + --mode=link $(CXXLD) $(AM_CXXFLAGS) $(CXXFLAGS) $(AM_LDFLAGS) \ + $(LDFLAGS) -o $@ +SOURCES = $(libodb_la_SOURCES) +DIST_SOURCES = $(am__libodb_la_SOURCES_DIST) +am__can_run_installinfo = \ + case $$AM_UPDATE_INFO_DIR in \ + n|no|NO) false;; \ + *) (install-info --version) >/dev/null 2>&1;; \ + esac +am__nobase_odbinclude_HEADERS_DIST = std-unordered-map-traits.hxx \ + query-dynamic.txx traits.hxx schema-catalog-impl.hxx \ + version.hxx polymorphic-map.hxx result.hxx lazy-ptr-impl.txx \ + schema-catalog.hxx pointer-traits.hxx std-list-traits.hxx \ + compilers/vc/post.hxx compilers/vc/pre.hxx query-dynamic.hxx \ + statement.hxx vector-traits.hxx object-result.hxx \ + std-set-traits.hxx lazy-ptr.hxx vector.hxx prepared-query.hxx \ + exception.hxx vector-impl.ixx vector.ixx std-array-traits.hxx \ + no-op-cache-traits.hxx section.hxx no-id-object-result.txx \ + lazy-ptr-impl.hxx container-traits.hxx view-result.hxx \ + transaction.hxx polymorphic-object-result.txx view-image.hxx \ + connection.ixx connection.txx std-vector-traits.hxx \ + view-result.txx tracer.hxx database.ixx post.hxx \ + schema-version.hxx vector-traits.txx session.ixx forward.hxx \ + polymorphic-map.txx function-table.hxx session.hxx \ + connection.hxx std-unordered-set-traits.hxx details/lock.hxx \ + details/thread.hxx details/shared-ptr-fwd.hxx details/tls.hxx \ + details/wrapper-p.hxx details/shared-ptr/base.txx \ + details/shared-ptr/exception.hxx \ + details/shared-ptr/counter-type.hxx \ + details/shared-ptr/base.ixx details/shared-ptr/base.hxx \ + details/exception.hxx details/type-info.hxx \ + details/function-wrapper.hxx details/function-wrapper.txx \ + details/meta/remove-volatile.hxx details/meta/class-p.hxx \ + details/meta/remove-const.hxx details/meta/static-assert.hxx \ + details/meta/remove-const-volatile.hxx \ + details/meta/polymorphic-p.hxx details/meta/answer.hxx \ + details/meta/remove-pointer.hxx details/condition.hxx \ + details/buffer.hxx details/shared-ptr.hxx \ + details/transfer-ptr.hxx details/mutex.hxx \ + details/c-string.hxx details/export.hxx \ + details/function-wrapper.ixx details/unused.hxx \ + details/config.hxx details/unique-ptr.hxx polymorphic-map.ixx \ + cache-traits.hxx simple-object-result.txx std-map-traits.hxx \ + lazy-pointer-traits.hxx std-forward-list-traits.hxx \ + lazy-ptr-impl.ixx core.hxx simple-object-result.hxx result.txx \ + polymorphic-info.hxx database.txx tr1/pointer-traits.hxx \ + tr1/lazy-ptr.hxx tr1/memory.hxx tr1/lazy-pointer-traits.hxx \ + tr1/lazy-ptr.ixx tr1/wrapper-traits.hxx tr1/lazy-ptr.txx \ + pre.hxx query-dynamic.ixx query.hxx transaction.ixx \ + callback.hxx lazy-ptr.ixx polymorphic-object-result.hxx \ + wrapper-traits.hxx exceptions.hxx nullable.hxx \ + no-id-object-result.hxx session.txx lazy-ptr.txx \ + vector-impl.hxx database.hxx std-deque-traits.hxx \ + statement-processing-common.hxx details/win32/windows.hxx \ + details/posix/thread.hxx details/posix/tls.hxx \ + details/posix/condition.hxx details/posix/mutex.ixx \ + details/posix/mutex.hxx details/posix/thread.ixx \ + details/posix/tls.ixx details/posix/tls.txx \ + details/posix/condition.ixx details/posix/exceptions.hxx \ + details/win32/lock.hxx details/win32/thread.hxx \ + details/win32/once-init.hxx details/win32/tls.hxx \ + details/win32/condition.hxx details/win32/tls-init.hxx \ + details/win32/mutex.ixx details/win32/mutex.hxx \ + details/win32/once.hxx details/win32/once.ixx \ + details/win32/tls.ixx details/win32/tls.txx \ + details/win32/condition.ixx details/win32/init.hxx \ + details/win32/exceptions.hxx +HEADERS = $(nobase_nodist_odbinclude_HEADERS) \ + $(nobase_odbinclude_HEADERS) +ETAGS = etags +CTAGS = ctags +DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) +ACLOCAL = @ACLOCAL@ +AMTAR = @AMTAR@ +AR = @AR@ +AS = @AS@ +AUTOCONF = @AUTOCONF@ +AUTOHEADER = @AUTOHEADER@ +AUTOMAKE = @AUTOMAKE@ +AWK = @AWK@ +CC = @CC@ +CCDEPMODE = @CCDEPMODE@ +CFLAGS = @CFLAGS@ +CPP = @CPP@ +CPPFLAGS = @CPPFLAGS@ +CXX = @CXX@ +CXXCPP = @CXXCPP@ +CXXDEPMODE = @CXXDEPMODE@ +CXXFLAGS = @CXXFLAGS@ +CYGPATH_W = @CYGPATH_W@ +DEFS = @DEFS@ +DEPDIR = @DEPDIR@ +DLLTOOL = @DLLTOOL@ +DSYMUTIL = @DSYMUTIL@ +DUMPBIN = @DUMPBIN@ +ECHO_C = @ECHO_C@ +ECHO_N = @ECHO_N@ +ECHO_T = @ECHO_T@ +EGREP = @EGREP@ +EXEEXT = @EXEEXT@ +FGREP = @FGREP@ +GREP = @GREP@ +INSTALL = @INSTALL@ +INSTALL_DATA = @INSTALL_DATA@ +INSTALL_PROGRAM = @INSTALL_PROGRAM@ +INSTALL_SCRIPT = @INSTALL_SCRIPT@ +INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@ +LD = @LD@ +LDFLAGS = @LDFLAGS@ +LIBOBJS = @LIBOBJS@ +LIBS = @LIBS@ +LIBTOOL = @LIBTOOL@ +LIPO = @LIPO@ +LN_S = @LN_S@ +LTLIBOBJS = @LTLIBOBJS@ +MAKEINFO = @MAKEINFO@ +MANIFEST_TOOL = @MANIFEST_TOOL@ +MKDIR_P = @MKDIR_P@ +NM = @NM@ +NMEDIT = @NMEDIT@ +OBJDUMP = @OBJDUMP@ +OBJEXT = @OBJEXT@ +OTOOL = @OTOOL@ +OTOOL64 = @OTOOL64@ +PACKAGE = @PACKAGE@ +PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@ +PACKAGE_NAME = @PACKAGE_NAME@ +PACKAGE_STRING = @PACKAGE_STRING@ +PACKAGE_TARNAME = @PACKAGE_TARNAME@ +PACKAGE_URL = @PACKAGE_URL@ +PACKAGE_VERSION = @PACKAGE_VERSION@ +PATH_SEPARATOR = @PATH_SEPARATOR@ +PTHREAD_CXX = @PTHREAD_CXX@ +PTHREAD_CXXFLAGS = @PTHREAD_CXXFLAGS@ +PTHREAD_LIBS = @PTHREAD_LIBS@ +RANLIB = @RANLIB@ +SED = @SED@ +SET_MAKE = @SET_MAKE@ +SHELL = @SHELL@ +STRIP = @STRIP@ +VERSION = @VERSION@ +abs_builddir = @abs_builddir@ +abs_srcdir = @abs_srcdir@ +abs_top_builddir = @abs_top_builddir@ +abs_top_srcdir = @abs_top_srcdir@ +ac_ct_AR = @ac_ct_AR@ +ac_ct_CC = @ac_ct_CC@ +ac_ct_CXX = @ac_ct_CXX@ +ac_ct_DUMPBIN = @ac_ct_DUMPBIN@ +acx_pthread_config = @acx_pthread_config@ +am__include = @am__include@ +am__leading_dot = @am__leading_dot@ +am__quote = @am__quote@ +am__tar = @am__tar@ +am__untar = @am__untar@ +bindir = @bindir@ +build = @build@ +build_alias = @build_alias@ +build_cpu = @build_cpu@ +build_os = @build_os@ +build_vendor = @build_vendor@ +builddir = @builddir@ +datadir = @datadir@ +datarootdir = @datarootdir@ +docdir = @docdir@ +dvidir = @dvidir@ +exec_prefix = @exec_prefix@ +host = @host@ +host_alias = @host_alias@ +host_cpu = @host_cpu@ +host_os = @host_os@ +host_vendor = @host_vendor@ +htmldir = @htmldir@ +includedir = @includedir@ +infodir = @infodir@ +install_sh = @install_sh@ +libdir = @libdir@ +libexecdir = @libexecdir@ +localedir = @localedir@ +localstatedir = @localstatedir@ +mandir = @mandir@ +mkdir_p = @mkdir_p@ +oldincludedir = @oldincludedir@ +pdfdir = @pdfdir@ +pkgconfigdir = @pkgconfigdir@ +prefix = @prefix@ +program_transform_name = @program_transform_name@ +psdir = @psdir@ +sbindir = @sbindir@ +sharedstatedir = @sharedstatedir@ +srcdir = @srcdir@ +sysconfdir = @sysconfdir@ +target_alias = @target_alias@ +top_build_prefix = @top_build_prefix@ +top_builddir = @top_builddir@ +top_srcdir = @top_srcdir@ +lib_LTLIBRARIES = libodb.la +libodb_la_SOURCES = callback.cxx exceptions.cxx database.cxx \ + vector-impl.cxx connection.cxx lazy-ptr-impl.cxx \ + prepared-query.cxx query-dynamic.cxx result.cxx \ + schema-catalog.cxx section.cxx session.cxx statement.cxx \ + statement-processing.cxx tracer.cxx transaction.cxx \ + details/buffer.cxx details/condition.cxx details/lock.cxx \ + details/mutex.cxx details/shared-ptr/base.cxx $(am__append_2) \ + $(am__append_4) +odbincludedir = $(includedir)/odb +nobase_odbinclude_HEADERS = std-unordered-map-traits.hxx \ + query-dynamic.txx traits.hxx schema-catalog-impl.hxx \ + version.hxx polymorphic-map.hxx result.hxx lazy-ptr-impl.txx \ + schema-catalog.hxx pointer-traits.hxx std-list-traits.hxx \ + compilers/vc/post.hxx compilers/vc/pre.hxx query-dynamic.hxx \ + statement.hxx vector-traits.hxx object-result.hxx \ + std-set-traits.hxx lazy-ptr.hxx vector.hxx prepared-query.hxx \ + exception.hxx vector-impl.ixx vector.ixx std-array-traits.hxx \ + no-op-cache-traits.hxx section.hxx no-id-object-result.txx \ + lazy-ptr-impl.hxx container-traits.hxx view-result.hxx \ + transaction.hxx polymorphic-object-result.txx view-image.hxx \ + connection.ixx connection.txx std-vector-traits.hxx \ + view-result.txx tracer.hxx database.ixx post.hxx \ + schema-version.hxx vector-traits.txx session.ixx forward.hxx \ + polymorphic-map.txx function-table.hxx session.hxx \ + connection.hxx std-unordered-set-traits.hxx details/lock.hxx \ + details/thread.hxx details/shared-ptr-fwd.hxx details/tls.hxx \ + details/wrapper-p.hxx details/shared-ptr/base.txx \ + details/shared-ptr/exception.hxx \ + details/shared-ptr/counter-type.hxx \ + details/shared-ptr/base.ixx details/shared-ptr/base.hxx \ + details/exception.hxx details/type-info.hxx \ + details/function-wrapper.hxx details/function-wrapper.txx \ + details/meta/remove-volatile.hxx details/meta/class-p.hxx \ + details/meta/remove-const.hxx details/meta/static-assert.hxx \ + details/meta/remove-const-volatile.hxx \ + details/meta/polymorphic-p.hxx details/meta/answer.hxx \ + details/meta/remove-pointer.hxx details/condition.hxx \ + details/buffer.hxx details/shared-ptr.hxx \ + details/transfer-ptr.hxx details/mutex.hxx \ + details/c-string.hxx details/export.hxx \ + details/function-wrapper.ixx details/unused.hxx \ + details/config.hxx details/unique-ptr.hxx polymorphic-map.ixx \ + cache-traits.hxx simple-object-result.txx std-map-traits.hxx \ + lazy-pointer-traits.hxx std-forward-list-traits.hxx \ + lazy-ptr-impl.ixx core.hxx simple-object-result.hxx result.txx \ + polymorphic-info.hxx database.txx tr1/pointer-traits.hxx \ + tr1/lazy-ptr.hxx tr1/memory.hxx tr1/lazy-pointer-traits.hxx \ + tr1/lazy-ptr.ixx tr1/wrapper-traits.hxx tr1/lazy-ptr.txx \ + pre.hxx query-dynamic.ixx query.hxx transaction.ixx \ + callback.hxx lazy-ptr.ixx polymorphic-object-result.hxx \ + wrapper-traits.hxx exceptions.hxx nullable.hxx \ + no-id-object-result.hxx session.txx lazy-ptr.txx \ + vector-impl.hxx database.hxx std-deque-traits.hxx \ + statement-processing-common.hxx $(am__append_1) \ + $(am__append_3) $(am__append_5) +nobase_nodist_odbinclude_HEADERS = details/config.h +EXTRA_DIST = details/config-vc.h libodb-vc8.vcproj libodb-vc9.vcproj libodb-vc10.vcxproj libodb-vc10.vcxproj.filters libodb-vc11.vcxproj libodb-vc11.vcxproj.filters libodb-vc12.vcxproj libodb-vc12.vcxproj.filters +AM_CPPFLAGS = -I'$(top_builddir)' -I'$(top_srcdir)' -DLIBODB_DYNAMIC_LIB +AM_LDFLAGS = -release 2.4 -no-undefined +all: config.h + $(MAKE) $(AM_MAKEFLAGS) all-am + +.SUFFIXES: +.SUFFIXES: .cxx .lo .o .obj +$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps) + @for dep in $?; do \ + case '$(am__configure_deps)' in \ + *$$dep*) \ + ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \ + && { if test -f $@; then exit 0; else break; fi; }; \ + exit 1;; \ + esac; \ + done; \ + echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign odb/Makefile'; \ + $(am__cd) $(top_srcdir) && \ + $(AUTOMAKE) --foreign odb/Makefile +.PRECIOUS: Makefile +Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status + @case '$?' in \ + *config.status*) \ + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \ + *) \ + echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \ + cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \ + esac; + +$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh + +$(top_srcdir)/configure: $(am__configure_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(ACLOCAL_M4): $(am__aclocal_m4_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(am__aclocal_m4_deps): + +config.h: stamp-h1 + @if test ! -f $@; then rm -f stamp-h1; else :; fi + @if test ! -f $@; then $(MAKE) $(AM_MAKEFLAGS) stamp-h1; else :; fi + +stamp-h1: $(srcdir)/config.h.in $(top_builddir)/config.status + @rm -f stamp-h1 + cd $(top_builddir) && $(SHELL) ./config.status odb/config.h +$(srcdir)/config.h.in: $(am__configure_deps) + ($(am__cd) $(top_srcdir) && $(AUTOHEADER)) + rm -f stamp-h1 + touch $@ + +distclean-hdr: + -rm -f config.h stamp-h1 +install-libLTLIBRARIES: $(lib_LTLIBRARIES) + @$(NORMAL_INSTALL) + @list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \ + list2=; for p in $$list; do \ + if test -f $$p; then \ + list2="$$list2 $$p"; \ + else :; fi; \ + done; \ + test -z "$$list2" || { \ + echo " $(MKDIR_P) '$(DESTDIR)$(libdir)'"; \ + $(MKDIR_P) "$(DESTDIR)$(libdir)" || exit 1; \ + echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 '$(DESTDIR)$(libdir)'"; \ + $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 "$(DESTDIR)$(libdir)"; \ + } + +uninstall-libLTLIBRARIES: + @$(NORMAL_UNINSTALL) + @list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \ + for p in $$list; do \ + $(am__strip_dir) \ + echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f '$(DESTDIR)$(libdir)/$$f'"; \ + $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f "$(DESTDIR)$(libdir)/$$f"; \ + done + +clean-libLTLIBRARIES: + -test -z "$(lib_LTLIBRARIES)" || rm -f $(lib_LTLIBRARIES) + @list='$(lib_LTLIBRARIES)'; \ + locs=`for p in $$list; do echo $$p; done | \ + sed 's|^[^/]*$$|.|; s|/[^/]*$$||; s|$$|/so_locations|' | \ + sort -u`; \ + test -z "$$locs" || { \ + echo rm -f $${locs}; \ + rm -f $${locs}; \ + } +details/$(am__dirstamp): + @$(MKDIR_P) details + @: > details/$(am__dirstamp) +details/$(DEPDIR)/$(am__dirstamp): + @$(MKDIR_P) details/$(DEPDIR) + @: > details/$(DEPDIR)/$(am__dirstamp) +details/buffer.lo: details/$(am__dirstamp) \ + details/$(DEPDIR)/$(am__dirstamp) +details/condition.lo: details/$(am__dirstamp) \ + details/$(DEPDIR)/$(am__dirstamp) +details/lock.lo: details/$(am__dirstamp) \ + details/$(DEPDIR)/$(am__dirstamp) +details/mutex.lo: details/$(am__dirstamp) \ + details/$(DEPDIR)/$(am__dirstamp) +details/shared-ptr/$(am__dirstamp): + @$(MKDIR_P) details/shared-ptr + @: > details/shared-ptr/$(am__dirstamp) +details/shared-ptr/$(DEPDIR)/$(am__dirstamp): + @$(MKDIR_P) details/shared-ptr/$(DEPDIR) + @: > details/shared-ptr/$(DEPDIR)/$(am__dirstamp) +details/shared-ptr/base.lo: details/shared-ptr/$(am__dirstamp) \ + details/shared-ptr/$(DEPDIR)/$(am__dirstamp) +details/posix/$(am__dirstamp): + @$(MKDIR_P) details/posix + @: > details/posix/$(am__dirstamp) +details/posix/$(DEPDIR)/$(am__dirstamp): + @$(MKDIR_P) details/posix/$(DEPDIR) + @: > details/posix/$(DEPDIR)/$(am__dirstamp) +details/posix/exceptions.lo: details/posix/$(am__dirstamp) \ + details/posix/$(DEPDIR)/$(am__dirstamp) +details/posix/thread.lo: details/posix/$(am__dirstamp) \ + details/posix/$(DEPDIR)/$(am__dirstamp) +details/win32/$(am__dirstamp): + @$(MKDIR_P) details/win32 + @: > details/win32/$(am__dirstamp) +details/win32/$(DEPDIR)/$(am__dirstamp): + @$(MKDIR_P) details/win32/$(DEPDIR) + @: > details/win32/$(DEPDIR)/$(am__dirstamp) +details/win32/init.lo: details/win32/$(am__dirstamp) \ + details/win32/$(DEPDIR)/$(am__dirstamp) +details/win32/once.lo: details/win32/$(am__dirstamp) \ + details/win32/$(DEPDIR)/$(am__dirstamp) +details/win32/tls.lo: details/win32/$(am__dirstamp) \ + details/win32/$(DEPDIR)/$(am__dirstamp) +details/win32/condition.lo: details/win32/$(am__dirstamp) \ + details/win32/$(DEPDIR)/$(am__dirstamp) +details/win32/thread.lo: details/win32/$(am__dirstamp) \ + details/win32/$(DEPDIR)/$(am__dirstamp) +details/win32/exceptions.lo: details/win32/$(am__dirstamp) \ + details/win32/$(DEPDIR)/$(am__dirstamp) +details/win32/dll.lo: details/win32/$(am__dirstamp) \ + details/win32/$(DEPDIR)/$(am__dirstamp) +libodb.la: $(libodb_la_OBJECTS) $(libodb_la_DEPENDENCIES) $(EXTRA_libodb_la_DEPENDENCIES) + $(CXXLINK) -rpath $(libdir) $(libodb_la_OBJECTS) $(libodb_la_LIBADD) $(LIBS) + +mostlyclean-compile: + -rm -f *.$(OBJEXT) + -rm -f details/*.$(OBJEXT) + -rm -f details/*.lo + -rm -f details/posix/*.$(OBJEXT) + -rm -f details/posix/*.lo + -rm -f details/shared-ptr/*.$(OBJEXT) + -rm -f details/shared-ptr/*.lo + -rm -f details/win32/*.$(OBJEXT) + -rm -f details/win32/*.lo + +distclean-compile: + -rm -f *.tab.c + +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/callback.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/connection.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/database.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/exceptions.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/lazy-ptr-impl.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/prepared-query.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/query-dynamic.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/result.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/schema-catalog.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/section.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/session.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/statement-processing.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/statement.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/tracer.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/transaction.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/vector-impl.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@details/$(DEPDIR)/buffer.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@details/$(DEPDIR)/condition.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@details/$(DEPDIR)/lock.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@details/$(DEPDIR)/mutex.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@details/posix/$(DEPDIR)/exceptions.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@details/posix/$(DEPDIR)/thread.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@details/shared-ptr/$(DEPDIR)/base.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@details/win32/$(DEPDIR)/condition.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@details/win32/$(DEPDIR)/dll.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@details/win32/$(DEPDIR)/exceptions.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@details/win32/$(DEPDIR)/init.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@details/win32/$(DEPDIR)/once.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@details/win32/$(DEPDIR)/thread.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@details/win32/$(DEPDIR)/tls.Plo@am__quote@ + +.cxx.o: +@am__fastdepCXX_TRUE@ depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.o$$||'`;\ +@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\ +@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(CXXCOMPILE) -c -o $@ $< + +.cxx.obj: +@am__fastdepCXX_TRUE@ depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.obj$$||'`;\ +@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\ +@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'` + +.cxx.lo: +@am__fastdepCXX_TRUE@ depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.lo$$||'`;\ +@am__fastdepCXX_TRUE@ $(LTCXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\ +@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Plo +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(LTCXXCOMPILE) -c -o $@ $< + +mostlyclean-libtool: + -rm -f *.lo + +clean-libtool: + -rm -rf .libs _libs + -rm -rf details/.libs details/_libs + -rm -rf details/posix/.libs details/posix/_libs + -rm -rf details/shared-ptr/.libs details/shared-ptr/_libs + -rm -rf details/win32/.libs details/win32/_libs +install-nobase_nodist_odbincludeHEADERS: $(nobase_nodist_odbinclude_HEADERS) + @$(NORMAL_INSTALL) + @list='$(nobase_nodist_odbinclude_HEADERS)'; test -n "$(odbincludedir)" || list=; \ + if test -n "$$list"; then \ + echo " $(MKDIR_P) '$(DESTDIR)$(odbincludedir)'"; \ + $(MKDIR_P) "$(DESTDIR)$(odbincludedir)" || exit 1; \ + fi; \ + $(am__nobase_list) | while read dir files; do \ + xfiles=; for file in $$files; do \ + if test -f "$$file"; then xfiles="$$xfiles $$file"; \ + else xfiles="$$xfiles $(srcdir)/$$file"; fi; done; \ + test -z "$$xfiles" || { \ + test "x$$dir" = x. || { \ + echo " $(MKDIR_P) '$(DESTDIR)$(odbincludedir)/$$dir'"; \ + $(MKDIR_P) "$(DESTDIR)$(odbincludedir)/$$dir"; }; \ + echo " $(INSTALL_HEADER) $$xfiles '$(DESTDIR)$(odbincludedir)/$$dir'"; \ + $(INSTALL_HEADER) $$xfiles "$(DESTDIR)$(odbincludedir)/$$dir" || exit $$?; }; \ + done + +uninstall-nobase_nodist_odbincludeHEADERS: + @$(NORMAL_UNINSTALL) + @list='$(nobase_nodist_odbinclude_HEADERS)'; test -n "$(odbincludedir)" || list=; \ + $(am__nobase_strip_setup); files=`$(am__nobase_strip)`; \ + dir='$(DESTDIR)$(odbincludedir)'; $(am__uninstall_files_from_dir) +install-nobase_odbincludeHEADERS: $(nobase_odbinclude_HEADERS) + @$(NORMAL_INSTALL) + @list='$(nobase_odbinclude_HEADERS)'; test -n "$(odbincludedir)" || list=; \ + if test -n "$$list"; then \ + echo " $(MKDIR_P) '$(DESTDIR)$(odbincludedir)'"; \ + $(MKDIR_P) "$(DESTDIR)$(odbincludedir)" || exit 1; \ + fi; \ + $(am__nobase_list) | while read dir files; do \ + xfiles=; for file in $$files; do \ + if test -f "$$file"; then xfiles="$$xfiles $$file"; \ + else xfiles="$$xfiles $(srcdir)/$$file"; fi; done; \ + test -z "$$xfiles" || { \ + test "x$$dir" = x. || { \ + echo " $(MKDIR_P) '$(DESTDIR)$(odbincludedir)/$$dir'"; \ + $(MKDIR_P) "$(DESTDIR)$(odbincludedir)/$$dir"; }; \ + echo " $(INSTALL_HEADER) $$xfiles '$(DESTDIR)$(odbincludedir)/$$dir'"; \ + $(INSTALL_HEADER) $$xfiles "$(DESTDIR)$(odbincludedir)/$$dir" || exit $$?; }; \ + done + +uninstall-nobase_odbincludeHEADERS: + @$(NORMAL_UNINSTALL) + @list='$(nobase_odbinclude_HEADERS)'; test -n "$(odbincludedir)" || list=; \ + $(am__nobase_strip_setup); files=`$(am__nobase_strip)`; \ + dir='$(DESTDIR)$(odbincludedir)'; $(am__uninstall_files_from_dir) + +ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES) + list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | \ + $(AWK) '{ files[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in files) print i; }; }'`; \ + mkid -fID $$unique +tags: TAGS + +TAGS: $(HEADERS) $(SOURCES) config.h.in $(TAGS_DEPENDENCIES) \ + $(TAGS_FILES) $(LISP) + set x; \ + here=`pwd`; \ + list='$(SOURCES) $(HEADERS) config.h.in $(LISP) $(TAGS_FILES)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | \ + $(AWK) '{ files[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in files) print i; }; }'`; \ + shift; \ + if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \ + test -n "$$unique" || unique=$$empty_fix; \ + if test $$# -gt 0; then \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + "$$@" $$unique; \ + else \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + $$unique; \ + fi; \ + fi +ctags: CTAGS +CTAGS: $(HEADERS) $(SOURCES) config.h.in $(TAGS_DEPENDENCIES) \ + $(TAGS_FILES) $(LISP) + list='$(SOURCES) $(HEADERS) config.h.in $(LISP) $(TAGS_FILES)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | \ + $(AWK) '{ files[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in files) print i; }; }'`; \ + test -z "$(CTAGS_ARGS)$$unique" \ + || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \ + $$unique + +GTAGS: + here=`$(am__cd) $(top_builddir) && pwd` \ + && $(am__cd) $(top_srcdir) \ + && gtags -i $(GTAGS_ARGS) "$$here" + +cscopelist: $(HEADERS) $(SOURCES) $(LISP) + list='$(SOURCES) $(HEADERS) $(LISP)'; \ + case "$(srcdir)" in \ + [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \ + *) sdir=$(subdir)/$(srcdir) ;; \ + esac; \ + for i in $$list; do \ + if test -f "$$i"; then \ + echo "$(subdir)/$$i"; \ + else \ + echo "$$sdir/$$i"; \ + fi; \ + done >> $(top_builddir)/cscope.files + +distclean-tags: + -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags + +distdir: $(DISTFILES) + @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + list='$(DISTFILES)'; \ + dist_files=`for file in $$list; do echo $$file; done | \ + sed -e "s|^$$srcdirstrip/||;t" \ + -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \ + case $$dist_files in \ + */*) $(MKDIR_P) `echo "$$dist_files" | \ + sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \ + sort -u` ;; \ + esac; \ + for file in $$dist_files; do \ + if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \ + if test -d $$d/$$file; then \ + dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \ + if test -d "$(distdir)/$$file"; then \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \ + cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \ + else \ + test -f "$(distdir)/$$file" \ + || cp -p $$d/$$file "$(distdir)/$$file" \ + || exit 1; \ + fi; \ + done +check-am: all-am +check: check-am +all-am: Makefile $(LTLIBRARIES) $(HEADERS) config.h +installdirs: + for dir in "$(DESTDIR)$(libdir)" "$(DESTDIR)$(odbincludedir)" "$(DESTDIR)$(odbincludedir)"; do \ + test -z "$$dir" || $(MKDIR_P) "$$dir"; \ + done +install: install-am +install-exec: install-exec-am +install-data: install-data-am +uninstall: uninstall-am + +install-am: all-am + @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am + +installcheck: installcheck-am +install-strip: + if test -z '$(STRIP)'; then \ + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + install; \ + else \ + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \ + fi +mostlyclean-generic: + +clean-generic: + +distclean-generic: + -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES) + -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES) + -rm -f details/$(DEPDIR)/$(am__dirstamp) + -rm -f details/$(am__dirstamp) + -rm -f details/posix/$(DEPDIR)/$(am__dirstamp) + -rm -f details/posix/$(am__dirstamp) + -rm -f details/shared-ptr/$(DEPDIR)/$(am__dirstamp) + -rm -f details/shared-ptr/$(am__dirstamp) + -rm -f details/win32/$(DEPDIR)/$(am__dirstamp) + -rm -f details/win32/$(am__dirstamp) + +maintainer-clean-generic: + @echo "This command is intended for maintainers to use" + @echo "it deletes files that may require special tools to rebuild." +clean: clean-am + +clean-am: clean-generic clean-libLTLIBRARIES clean-libtool \ + mostlyclean-am + +distclean: distclean-am + -rm -rf ./$(DEPDIR) details/$(DEPDIR) details/posix/$(DEPDIR) details/shared-ptr/$(DEPDIR) details/win32/$(DEPDIR) + -rm -f Makefile +distclean-am: clean-am distclean-compile distclean-generic \ + distclean-hdr distclean-tags + +dvi: dvi-am + +dvi-am: + +html: html-am + +html-am: + +info: info-am + +info-am: + +install-data-am: install-nobase_nodist_odbincludeHEADERS \ + install-nobase_odbincludeHEADERS + +install-dvi: install-dvi-am + +install-dvi-am: + +install-exec-am: install-libLTLIBRARIES + +install-html: install-html-am + +install-html-am: + +install-info: install-info-am + +install-info-am: + +install-man: + +install-pdf: install-pdf-am + +install-pdf-am: + +install-ps: install-ps-am + +install-ps-am: + +installcheck-am: + +maintainer-clean: maintainer-clean-am + -rm -rf ./$(DEPDIR) details/$(DEPDIR) details/posix/$(DEPDIR) details/shared-ptr/$(DEPDIR) details/win32/$(DEPDIR) + -rm -f Makefile +maintainer-clean-am: distclean-am maintainer-clean-generic + +mostlyclean: mostlyclean-am + +mostlyclean-am: mostlyclean-compile mostlyclean-generic \ + mostlyclean-libtool + +pdf: pdf-am + +pdf-am: + +ps: ps-am + +ps-am: + +uninstall-am: uninstall-libLTLIBRARIES \ + uninstall-nobase_nodist_odbincludeHEADERS \ + uninstall-nobase_odbincludeHEADERS + +.MAKE: all install-am install-strip + +.PHONY: CTAGS GTAGS all all-am check check-am clean clean-generic \ + clean-libLTLIBRARIES clean-libtool cscopelist ctags distclean \ + distclean-compile distclean-generic distclean-hdr \ + distclean-libtool distclean-tags distdir dvi dvi-am html \ + html-am info info-am install install-am install-data \ + install-data-am install-dvi install-dvi-am install-exec \ + install-exec-am install-html install-html-am install-info \ + install-info-am install-libLTLIBRARIES install-man \ + install-nobase_nodist_odbincludeHEADERS \ + install-nobase_odbincludeHEADERS install-pdf install-pdf-am \ + install-ps install-ps-am install-strip installcheck \ + installcheck-am installdirs maintainer-clean \ + maintainer-clean-generic mostlyclean mostlyclean-compile \ + mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \ + tags uninstall uninstall-am uninstall-libLTLIBRARIES \ + uninstall-nobase_nodist_odbincludeHEADERS \ + uninstall-nobase_odbincludeHEADERS + + +# Tell versions [3.59,3.63) of GNU make to not export all variables. +# Otherwise a system limit (for SysV at least) may be exceeded. +.NOEXPORT: diff --git a/third-party/odb/libodb-2.4.0/odb/cache-traits.hxx b/third-party/odb/libodb-2.4.0/odb/cache-traits.hxx new file mode 100755 index 0000000..0a0bf4b --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/cache-traits.hxx @@ -0,0 +1,183 @@ +// file : odb/cache-traits.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_CACHE_TRAITS_HXX +#define ODB_CACHE_TRAITS_HXX + +#include + +#include +#include +#include +#include +#include + +namespace odb +{ + // pointer_cache_traits + // + // Caching traits for objects passed by pointer. P should be the canonical + // pointer (non-const). + // + template + struct pointer_cache_traits_impl + { + typedef P pointer_type; + typedef S session_type; + typedef odb::pointer_traits pointer_traits; + typedef typename pointer_traits::element_type object_type; + typedef typename object_traits::id_type id_type; + typedef typename session_type::template cache_position + position_type; + + struct insert_guard + { + insert_guard () {} + insert_guard (const position_type& pos): pos_ (pos) {} + ~insert_guard () {session_type::_cache_erase (pos_);} + + const position_type& + position () const {return pos_;} + + void + release () {pos_ = position_type ();} + + // Note: doesn't call erase() on the old position (assumes empty). + // + void + reset (const position_type& pos) {pos_ = pos;} + + private: + position_type pos_; + }; + + // Cache management. + // + // We need the insert() overload with explicit id to handle self- + // references. In such cases the object is not yet loaded and the + // id member does not contain the correct id. + // + // Qualify the database type to resolve a phony ambiguity in VC 10. + // + static position_type + insert (odb::database& db, const id_type& id, const pointer_type& p) + { + return session_type::template _cache_insert (db, id, p); + } + + static position_type + insert (odb::database& db, const pointer_type& p) + { + const id_type& id ( + object_traits::id ( + pointer_traits::get_ref (p))); + + return session_type::template _cache_insert (db, id, p); + } + + static pointer_type + find (odb::database& db, const id_type& id) + { + return session_type::template _cache_find (db, id); + } + + static void + erase (const position_type& p) + { + session_type::template _cache_erase (p); + } + + // Notifications. + // + static void + persist (const position_type& p) + { + session_type::template _cache_persist (p); + } + + static void + load (const position_type& p) + { + session_type::template _cache_load (p); + } + + static void + update (odb::database& db, const object_type& obj) + { + session_type::template _cache_update (db, obj); + } + + static void + erase (odb::database& db, const id_type& id) + { + session_type::template _cache_erase (db, id); + } + }; + + // Unique pointers don't work with the object cache. + // + template + struct pointer_cache_traits_impl: + no_op_pointer_cache_traits

{}; + + template + struct pointer_cache_traits: + pointer_cache_traits_impl::kind> {}; + + // reference_cache_traits + // + // Caching traits for objects passed by reference. T should be the + // canonical object type (non-const). Only if the object pointer + // kind is raw do we add the object to the session. + // + template + struct reference_cache_traits_impl: no_op_reference_cache_traits {}; + + template + struct reference_cache_traits_impl + { + typedef T object_type; + typedef typename object_traits::pointer_type pointer_type; + typedef typename object_traits::id_type id_type; + + typedef pointer_cache_traits pointer_traits; + typedef typename pointer_traits::position_type position_type; + typedef typename pointer_traits::insert_guard insert_guard; + + static position_type + insert (odb::database& db, const id_type& id, object_type& obj) + { + pointer_type p (&obj); + return pointer_traits::insert (db, id, p); + } + + static position_type + insert (odb::database& db, object_type& obj) + { + pointer_type p (&obj); + return pointer_traits::insert (db, p); + } + + static void + persist (const position_type& p) + { + pointer_traits::persist (p); + } + + static void + load (const position_type& p) + { + pointer_traits::load (p); + } + }; + + template + struct reference_cache_traits: + reference_cache_traits_impl< + T, S, pointer_traits::pointer_type>::kind> {}; +} + +#include + +#endif // ODB_CACHE_TRAITS_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/callback.cxx b/third-party/odb/libodb-2.4.0/odb/callback.cxx new file mode 100755 index 0000000..3f4b26c --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/callback.cxx @@ -0,0 +1,11 @@ +// file : odb/callback.cxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include + +namespace odb +{ + // This otherwise unnecessary file is here to allow instantiation + // of inline functions for exporting. +} diff --git a/third-party/odb/libodb-2.4.0/odb/callback.hxx b/third-party/odb/libodb-2.4.0/odb/callback.hxx new file mode 100755 index 0000000..603af55 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/callback.hxx @@ -0,0 +1,44 @@ +// file : odb/callback.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_CALLBACK_HXX +#define ODB_CALLBACK_HXX + +#include + +#include // odb::core +#include + +namespace odb +{ + struct LIBODB_EXPORT callback_event + { + enum value + { + pre_persist, + post_persist, + pre_load, + post_load, + pre_update, + post_update, + pre_erase, + post_erase + }; + + callback_event (value v): v_ (v) {} + operator value () const {return v_;} + + private: + value v_; + }; + + namespace common + { + using odb::callback_event; + } +} + +#include + +#endif // ODB_CALLBACK_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/compilers/vc/post.hxx b/third-party/odb/libodb-2.4.0/odb/compilers/vc/post.hxx new file mode 100755 index 0000000..442f282 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/compilers/vc/post.hxx @@ -0,0 +1,5 @@ +// file : odb/compilers/vc/post.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#pragma warning (pop) diff --git a/third-party/odb/libodb-2.4.0/odb/compilers/vc/pre.hxx b/third-party/odb/libodb-2.4.0/odb/compilers/vc/pre.hxx new file mode 100755 index 0000000..a94676f --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/compilers/vc/pre.hxx @@ -0,0 +1,20 @@ +// file : odb/compilers/vc/pre.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +// Push warning state. +// +#pragma warning (push, 3) + +// Disabled warnings. +// +#pragma warning (disable:4068) // unknown pragma +#pragma warning (disable:4251) // needs to have DLL-interface +#pragma warning (disable:4290) // exception specification ignored +#pragma warning (disable:4355) // passing 'this' to a member +#pragma warning (disable:4800) // forcing value to bool +#pragma warning (disable:4231) // non-standard extension (extern template) + +// Elevated warnings. +// +#pragma warning (2:4239) // standard doesn't allow this conversion diff --git a/third-party/odb/libodb-2.4.0/odb/config.h.in b/third-party/odb/libodb-2.4.0/odb/config.h.in new file mode 100755 index 0000000..00b9d27 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/config.h.in @@ -0,0 +1,80 @@ +/* odb/config.h.in. Generated from configure.ac by autoheader. */ + +/* Define to 1 if you have the header file. */ +#undef HAVE_DLFCN_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_INTTYPES_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_MEMORY_H + +/* Define if you have POSIX threads libraries and header files. */ +#undef HAVE_PTHREAD + +/* Define to 1 if you have the header file. */ +#undef HAVE_STDINT_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_STDLIB_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_STRINGS_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_STRING_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_SYS_STAT_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_SYS_TYPES_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_UNISTD_H + +/* Static library interface. */ +#undef LIBODB_STATIC_LIB + +/* Define to the sub-directory in which libtool stores uninstalled libraries. + */ +#undef LT_OBJDIR + +/* Have no threads. */ +#undef ODB_THREADS_NONE + +/* Have POSIX threads. */ +#undef ODB_THREADS_POSIX + +/* Have __thread keyword. */ +#undef ODB_THREADS_TLS_KEYWORD + +/* Have Win32 threads. */ +#undef ODB_THREADS_WIN32 + +/* Name of package */ +#undef PACKAGE + +/* Define to the address where bug reports for this package should be sent. */ +#undef PACKAGE_BUGREPORT + +/* Define to the full name of this package. */ +#undef PACKAGE_NAME + +/* Define to the full name and version of this package. */ +#undef PACKAGE_STRING + +/* Define to the one symbol short name of this package. */ +#undef PACKAGE_TARNAME + +/* Define to the home page for this package. */ +#undef PACKAGE_URL + +/* Define to the version of this package. */ +#undef PACKAGE_VERSION + +/* Define to 1 if you have the ANSI C header files. */ +#undef STDC_HEADERS + +/* Version number of package */ +#undef VERSION diff --git a/third-party/odb/libodb-2.4.0/odb/connection.cxx b/third-party/odb/libodb-2.4.0/odb/connection.cxx new file mode 100755 index 0000000..87f76d3 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/connection.cxx @@ -0,0 +1,124 @@ +// file : odb/connection.cxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include +#include +#include +#include +#include // prepared_* + +using namespace std; + +namespace odb +{ + connection:: + ~connection () + { + assert (prepared_queries_ == 0); + assert (prepared_map_.empty ()); + } + + void connection:: + clear_prepared_map () + { + for (prepared_map_type::iterator i (prepared_map_.begin ()), + e (prepared_map_.end ()); i != e; ++i) + { + if (i->second.params != 0) + i->second.params_deleter (i->second.params); + } + + prepared_map_.clear (); + } + + void connection:: + recycle () + { + while (prepared_queries_ != 0) + { + prepared_queries_->stmt.reset (); + prepared_queries_->list_remove (); + } + } + + void connection:: + invalidate_results () + { + while (results_ != 0) + { + results_->invalidate (); + results_->list_remove (); + } + } + + void connection:: + cache_query_ (prepared_query_impl* pq, + const type_info& ti, + void* params, + const type_info* params_info, + void (*params_deleter) (void*)) + { + pair r ( + prepared_map_.insert ( + prepared_map_type::value_type (pq->name, prepared_entry_type ()))); + + if (!r.second) + throw prepared_already_cached (pq->name); + + prepared_entry_type& e (r.first->second); + + // Mark this prepared query as cached , get its ref count to 1 + // (prepared_query instances now reference this impl object), + // and remove it from the invalidation list. + // + pq->cached = true; + + while (pq->_ref_count () > 1) + pq->_dec_ref (); + + pq->list_remove (); + + e.prep_query.reset (pq); + e.type_info = &ti; + e.params = params; + e.params_info = params_info; + e.params_deleter = params_deleter; + } + + prepared_query_impl* connection:: + lookup_query_ (const char* name, + const type_info& ti, + void** params, + const type_info* params_info) const + { + prepared_map_type::const_iterator i (prepared_map_.find (name)); + + if (i == prepared_map_.end ()) + { + // Use a factory, if there is one. + // + if (database_.call_query_factory (name, + const_cast (*this))) + i = prepared_map_.find (name); + } + + if (i == prepared_map_.end ()) + return 0; + + // Make sure the types match. + // + if (*i->second.type_info != ti) + throw prepared_type_mismatch (name); + + if (params != 0) + { + if (*i->second.params_info != *params_info) + throw prepared_type_mismatch (name); + + *params = i->second.params; + } + + return i->second.prep_query.get (); + } +} diff --git a/third-party/odb/libodb-2.4.0/odb/connection.hxx b/third-party/odb/libodb-2.4.0/odb/connection.hxx new file mode 100755 index 0000000..20cb285 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/connection.hxx @@ -0,0 +1,213 @@ +// file : odb/connection.hxx +// copyright : Copyright (c) 2005-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_CONNECTION_HXX +#define ODB_CONNECTION_HXX + +#include + +#include +#include +#include // std::auto_ptr, std::unique_ptr +#include // std::size_t +#include + +#include +#include +#include +#include + +#include // ODB_CXX11 +#include +#include +#include + +namespace odb +{ + class transaction_impl; + + class connection; + typedef details::shared_ptr connection_ptr; + + class LIBODB_EXPORT connection: public details::shared_base + { + public: + typedef odb::database database_type; + + database_type& + database (); + + // Transactions. + // + public: + virtual transaction_impl* + begin () = 0; + + // Native database statement execution. Note that unlike the + // versions in the database class, these can be executed + // without a transaction. + // + public: + unsigned long long + execute (const char* statement); + + unsigned long long + execute (const std::string& statement); + + virtual unsigned long long + execute (const char* statement, std::size_t length) = 0; + + // Query preparation. + // + public: + template + prepared_query + prepare_query (const char* name, const char*); + + template + prepared_query + prepare_query (const char* name, const std::string&); + + template + prepared_query + prepare_query (const char* name, const query&); + + template + void + cache_query (const prepared_query&); + + template + void + cache_query (const prepared_query&, std::auto_ptr

params); + +#ifdef ODB_CXX11 + template + void + cache_query (const prepared_query&, std::unique_ptr

params); +#endif + + template + prepared_query + lookup_query (const char* name) const; + + template + prepared_query + lookup_query (const char* name, P*& params) const; + + // SQL statement tracing. + // + public: + typedef odb::tracer tracer_type; + + void + tracer (tracer_type&); + + void + tracer (tracer_type*); + + tracer_type* + tracer () const; + + public: + // Store the transaction-spacific tracer in the connection. If we + // were to store it in the transaction, then in order to check if + // it was set, we would need to get the transaction instance using + // the current() API. But that requires a TLS lookup, which can be + // slow. + // + tracer_type* + transaction_tracer () const; + + public: + virtual + ~connection (); + + // Recycle the connection to be used by another thread. This call + // invalidates uncached prepared queries. + // + void + recycle (); + + protected: + connection (database_type&); + + template ::kind> + struct query_; + + virtual void + cache_query_ (prepared_query_impl* pq, + const std::type_info& ti, + void* params, + const std::type_info* params_info, + void (*params_deleter) (void*)); + + prepared_query_impl* + lookup_query_ (const char* name, + const std::type_info& ti, + void** params, // out + const std::type_info* params_info) const; + + template + static void + params_deleter (void*); + + private: + connection (const connection&); + connection& operator= (const connection&); + + // Prepared query cache. + // + protected: + struct prepared_entry_type + { + details::shared_ptr prep_query; + const std::type_info* type_info; + void* params; + const std::type_info* params_info; + void (*params_deleter) (void*); + }; + + typedef + std::map + prepared_map_type; + + prepared_map_type prepared_map_; + + void + clear_prepared_map (); + + protected: + database_type& database_; + tracer_type* tracer_; + + // Active query result list. + // + protected: + friend class result_impl; + result_impl* results_; + + void + invalidate_results (); + + // Prepared but uncached query list (cached ones are stored in + // prepared_map_). + // + protected: + friend class prepared_query_impl; + prepared_query_impl* prepared_queries_; + + protected: + friend class transaction; + tracer_type* transaction_tracer_; + }; +} + +#include +#include + +#include + +#endif // ODB_CONNECTION_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/connection.ixx b/third-party/odb/libodb-2.4.0/odb/connection.ixx new file mode 100755 index 0000000..573134d --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/connection.ixx @@ -0,0 +1,132 @@ +// file : odb/connection.ixx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include // std::string +#include + +namespace odb +{ + inline connection:: + connection (database_type& database) + : database_ (database), + tracer_ (0), + results_ (0), + prepared_queries_ (0), + transaction_tracer_ (0) + { + } + + inline connection::database_type& connection:: + database () + { + return database_; + } + + inline unsigned long long connection:: + execute (const char* st) + { + return execute (st, std::strlen (st)); + } + + inline unsigned long long connection:: + execute (const std::string& st) + { + return execute (st.c_str (), st.size ()); + } + + template + inline prepared_query connection:: + prepare_query (const char* n, const char* q) + { + return prepare_query (n, query (q)); + } + + template + inline prepared_query connection:: + prepare_query (const char* n, const std::string& q) + { + return prepare_query (n, query (q)); + } + + template + inline prepared_query connection:: + prepare_query (const char* n, const query& q) + { + return query_::call (*this, n, q); + } + + template + inline void connection:: + cache_query (const prepared_query& pq) + { + assert (pq); + cache_query_ (pq.impl_, typeid (T), 0, 0, 0); + } + + template + inline void connection:: + cache_query (const prepared_query& pq, std::auto_ptr

params) + { + assert (pq); + assert (params.get () != 0); + cache_query_ ( + pq.impl_, typeid (T), params.get (), &typeid (P), ¶ms_deleter

); + params.release (); + } + +#ifdef ODB_CXX11 + template + inline void connection:: + cache_query (const prepared_query& pq, std::unique_ptr

params) + { + assert (pq); + assert (params); + cache_query_ ( + pq.impl_, typeid (T), params.get (), &typeid (P), ¶ms_deleter

); + params.release (); + } +#endif + + template + inline prepared_query connection:: + lookup_query (const char* name) const + { + return prepared_query (lookup_query_ (name, typeid (T), 0, 0)); + } + + template + inline prepared_query connection:: + lookup_query (const char* name, P*& params) const + { + return prepared_query ( + lookup_query_ (name, + typeid (T), + reinterpret_cast (¶ms), + &typeid (P))); + } + + inline void connection:: + tracer (tracer_type& t) + { + tracer_ = &t; + } + + inline void connection:: + tracer (tracer_type* t) + { + tracer_ = t; + } + + inline connection::tracer_type* connection:: + tracer () const + { + return tracer_; + } + + inline connection::tracer_type* connection:: + transaction_tracer () const + { + return transaction_tracer_; + } +} diff --git a/third-party/odb/libodb-2.4.0/odb/connection.txx b/third-party/odb/libodb-2.4.0/odb/connection.txx new file mode 100755 index 0000000..77ddc3c --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/connection.txx @@ -0,0 +1,45 @@ +// file : odb/connection.txx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +namespace odb +{ + template + struct connection::query_ + { + template + static prepared_query + call (connection& c, const char* n, const Q& q) + { + // C++ compiler complaining there is no prepare_query()? Perhaps + // you forgot to specify --generate-prepared when compiling your + // persistent classes. + // + return prepared_query ( + object_traits_impl::prepare_query (c, n, q)); + } + }; + + template + struct connection::query_ + { + template + static prepared_query + call (connection& c, const char* n, const Q& q) + { + // C++ compiler complaining there is no prepare_query()? Perhaps + // you forgot to specify --generate-prepared when compiling your + // views. + // + return prepared_query ( + view_traits_impl::prepare_query (c, n, q)); + } + }; + + template + void connection:: + params_deleter (void* p) + { + delete static_cast (p); + } +} diff --git a/third-party/odb/libodb-2.4.0/odb/container-traits.hxx b/third-party/odb/libodb-2.4.0/odb/container-traits.hxx new file mode 100755 index 0000000..0705ac0 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/container-traits.hxx @@ -0,0 +1,220 @@ +// file : odb/container-traits.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_CONTAINER_TRAITS_HXX +#define ODB_CONTAINER_TRAITS_HXX + +#include + +#include +#include // ODB_CXX11 + +namespace odb +{ + // Keep this enum synchronized with the one in odb/odb/context.hxx. + // + enum container_kind + { + ck_ordered, + ck_set, + ck_multiset, + ck_map, + ck_multimap + }; + + // + // Container API provided by the generated code. + // + + // Ordered containers. + // + template + struct ordered_functions + { + typedef I index_type; + typedef V value_type; + + // Return true if the order is preserved in the database. If the + // order is not preserved, then the index argument in the functions + // below is not used. + // + bool + ordered () const + { + return ordered_; + } + + void + insert (I index, const V& value) const + { + insert_ (index, value, data_); + } + + bool + select (I& next_index, V& next_value) const + { + return select_ (next_index, next_value, data_); + } + + void + delete_ () const + { + delete__ (data_); + } + + // Implementation details. + // + public: + ordered_functions (void* data): data_ (data) {} + + public: + void* data_; + bool ordered_; + + void (*insert_) (I, const V&, void*); + bool (*select_) (I&, V&, void*); + void (*delete__) (void*); + }; + + template + struct smart_ordered_functions + { + typedef I index_type; + typedef V value_type; + + void + insert (I index, const V& value) const + { + insert_ (index, value, data_); + } + + bool + select (I& next_index, V& next_value) const + { + return select_ (next_index, next_value, data_); + } + + void + update (I index, const V& value) const + { + update_ (index, value, data_); + } + + // Delete all the elements starting with the specified index. To + // delete everything, pass 0. + // + void + delete_ (I start_index) const + { + delete__ (start_index, data_); + } + + // Implementation details. + // + public: + smart_ordered_functions (void* data) : data_ (data) {} + + public: + void* data_; + + void (*insert_) (I, const V&, void*); + bool (*select_) (I&, V&, void*); + void (*update_) (I, const V&, void*); + void (*delete__) (I, void*); + }; + + // Set/multiset containers. + // + template + struct set_functions + { + typedef V value_type; + + void + insert (const V& value) const + { + insert_ (value, data_); + } + + bool + select (V& next_value) const + { + return select_ (next_value, data_); + } + + void + delete_ () const + { + delete__ (data_); + } + + // Implementation details. + // + public: + set_functions (void* data): data_ (data) {} + + public: + void* data_; + + void (*insert_) (const V&, void*); + bool (*select_) (V&, void*); + void (*delete__) (void*); + }; + + // Map/multimap containers. + // + template + struct map_functions + { + typedef K key_type; + typedef V value_type; + + void + insert (const K& key, const V& value) const + { + insert_ (key, value, data_); + } + + bool + select (K& next_key, V& next_value) const + { + return select_ (next_key, next_value, data_); + } + + void + delete_ () const + { + delete__ (data_); + } + + // Implementation details. + // + public: + map_functions (void* data): data_ (data) {} + + public: + void* data_; + + void (*insert_) (const K&, const V&, void*); + bool (*select_) (K&, V&, void*); + void (*delete__) (void*); + }; +} + +#include + +#include +#include +#include +#include +#include + +#ifdef ODB_CXX11 +# include +# include +# include +# include +#endif + +#endif // ODB_CONTAINER_TRAITS_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/core.hxx b/third-party/odb/libodb-2.4.0/odb/core.hxx new file mode 100755 index 0000000..8615f48 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/core.hxx @@ -0,0 +1,21 @@ +// file : odb/core.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_CORE_HXX +#define ODB_CORE_HXX + +#include + +#ifdef ODB_COMPILER +# define PRAGMA_DB_IMPL(x) _Pragma (#x) +# define PRAGMA_DB(x) PRAGMA_DB_IMPL (db x) +#else +# define PRAGMA_DB(x) +#endif + +#include + +#include + +#endif // ODB_CORE_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/database.cxx b/third-party/odb/libodb-2.4.0/odb/database.cxx new file mode 100755 index 0000000..2ce15b2 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/database.cxx @@ -0,0 +1,84 @@ +// file : odb/database.cxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include + +#include + +using namespace std; + +namespace odb +{ + using details::lock; + + database:: + ~database () + { + } + + unsigned long long database:: + execute (const char* st, std::size_t n) + { + connection_type& c (transaction::current ().connection ()); + return c.execute (st, n); + } + + const database::schema_version_migration_type& database:: + schema_version_migration (const string& name) const + { + lock l (mutex_); // Prevents concurrent loading. + + schema_version_map::const_iterator i (schema_version_map_.find (name)); + return i != schema_version_map_.end () && i->second.version != 0 + ? i->second + : load_schema_version (name); + } + + void database:: + schema_version_migration (const schema_version_migration_type& svm, + const string& name) + { + // Note: no lock, not thread-safe. + + schema_version_info& svi (schema_version_map_[name]); + if (svi.version != svm.version || svi.migration != svm.migration) + { + svi.version = svm.version; + svi.migration = svm.migration; + schema_version_seq_++; + } + } + + bool database:: + call_query_factory (const char* name, connection_type& c) const + { + query_factory_map::const_iterator i (query_factory_map_.find (name)); + + if (i == query_factory_map_.end ()) + i = query_factory_map_.find (""); // Wildcard factory. + + if (i == query_factory_map_.end ()) + return false; + + const query_factory_wrapper& fw (i->second); + if (fw.std_function == 0) + fw.function (name, c); + else + { + typedef void (*caller) (const void*, const char*, connection_type&); + reinterpret_cast (fw.function) (fw.std_function, name, c); + } + + return true; + } + + void database:: + query_factory (const char* name, query_factory_wrapper w) + { + if (w) + query_factory_map_[name] = w; // Destructive copy assignment (move). + else + query_factory_map_.erase (name); + } +} diff --git a/third-party/odb/libodb-2.4.0/odb/database.hxx b/third-party/odb/libodb-2.4.0/odb/database.hxx new file mode 100755 index 0000000..1c44745 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/database.hxx @@ -0,0 +1,636 @@ +// file : odb/database.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_DATABASE_HXX +#define ODB_DATABASE_HXX + +#include + +#include // ODB_CXX11 + +#include +#include +#include // std::auto_ptr, std::unique_ptr +#include // std::size_t + +#ifdef ODB_CXX11 +# include // std::move +# include // std::function +# include // std::enable_if, std::is_convertible +#endif + +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +namespace odb +{ + class transaction_impl; + + class LIBODB_EXPORT database + { + public: + virtual + ~database (); + + // Object persistence API. + // + public: + // Make the object persistent. + // + template + typename object_traits::id_type + persist (T& object); + + template + typename object_traits::id_type + persist (const T& object); + + template + typename object_traits::id_type + persist (T* obj_ptr); + + template class P> + typename object_traits::id_type + persist (const P& obj_ptr); + + template class P> + typename object_traits::id_type + persist (const P& obj_ptr); + + template class P> + typename object_traits::id_type + persist (P& obj_ptr); + + template class P> + typename object_traits::id_type + persist (P& obj_ptr); + + template + typename object_traits::id_type + persist (const typename object_traits::pointer_type& obj_ptr); + + // Bulk persist. Can be a range of references or pointers (including + // smart pointers) to objects. + // + template + void + persist (I begin, I end, bool continue_failed = true); + + // Load an object. Throw object_not_persistent if not found. + // + template + typename object_traits::pointer_type + load (const typename object_traits::id_type& id); + + template + void + load (const typename object_traits::id_type& id, T& object); + + // Load (or reload, if it is already loaded) a section of an object. + // + template + void + load (T& object, section&); + + // Reload an object. + // + template + void + reload (T& object); + + template + void + reload (T* obj_ptr); + + template class P> + void + reload (const P& obj_ptr); + + template class P> + void + reload (const P& obj_ptr); + + template class P> + void + reload (P& obj_ptr); + + template class P> + void + reload (P& obj_ptr); + + template + void + reload (const typename object_traits::pointer_type& obj_ptr); + + // Loan an object if found. Return NULL/false if not found. + // + template + typename object_traits::pointer_type + find (const typename object_traits::id_type& id); + + template + bool + find (const typename object_traits::id_type& id, T& object); + + // Update the state of a modified objects. + // + template + void + update (T& object); + + template + void + update (T* obj_ptr); + + template class P> + void + update (const P& obj_ptr); + + template class P> + void + update (const P& obj_ptr); + + template class P> + void + update (P& obj_ptr); + + template class P> + void + update (P& obj_ptr); + + template + void + update (const typename object_traits::pointer_type& obj_ptr); + + // Bulk update. Can be a range of references or pointers (including + // smart pointers) to objects. + // + template + void + update (I begin, I end, bool continue_failed = true); + + // Update a section of an object. Throws section_not_loaded exception + // if section is not loaded. Note also that this function does not + // clear the changed flag if it is set. + // + template + void + update (const T& object, const section&); + + // Make the object transient. Throw object_not_persistent if not + // found. + // + template + void + erase (const typename object_traits::id_type& id); + + template + void + erase (T& object); + + template + void + erase (T* obj_ptr); + + template class P> + void + erase (const P& obj_ptr); + + template class P> + void + erase (const P& obj_ptr); + + template class P> + void + erase (P& obj_ptr); + + template class P> + void + erase (P& obj_ptr); + + template + void + erase (const typename object_traits::pointer_type& obj_ptr); + + // Bulk erase. + // + template + void + erase (I id_begin, I id_end, bool continue_failed = true); + + // Can be a range of references or pointers (including smart pointers) + // to objects. + // + template + void + erase (I obj_begin, I obj_end, bool continue_failed = true); + + // Erase multiple objects matching a query predicate. + // + template + unsigned long long + erase_query (); + + template + unsigned long long + erase_query (const char*); + + template + unsigned long long + erase_query (const std::string&); + + template + unsigned long long + erase_query (const odb::query&); + + // Query API. + // + template + result + query (bool cache = true); + + template + result + query (const char*, bool cache = true); + + template + result + query (const std::string&, bool cache = true); + + template + result + query (const odb::query&, bool cache = true); + + // Query one API. + // + template + typename object_traits::pointer_type + query_one (); + + template + bool + query_one (T& object); + + template + T + query_value (); + + template + typename object_traits::pointer_type + query_one (const char*); + + template + bool + query_one (const char*, T& object); + + template + T + query_value (const char*); + + template + typename object_traits::pointer_type + query_one (const std::string&); + + template + bool + query_one (const std::string&, T& object); + + template + T + query_value (const std::string&); + + template + typename object_traits::pointer_type + query_one (const odb::query&); + + template + bool + query_one (const odb::query&, T& object); + + template + T + query_value (const odb::query&); + + // Query preparation. + // + template + prepared_query + prepare_query (const char* name, const char*); + + template + prepared_query + prepare_query (const char* name, const std::string&); + + template + prepared_query + prepare_query (const char* name, const odb::query&); + + template + void + cache_query (const prepared_query&); + + template + void + cache_query (const prepared_query&, std::auto_ptr

params); + +#ifdef ODB_CXX11 + template + void + cache_query (const prepared_query&, std::unique_ptr

params); +#endif + + template + prepared_query + lookup_query (const char* name) const; + + template + prepared_query + lookup_query (const char* name, P*& params) const; + + // Prepared query factory. + // + public: + typedef odb::connection connection_type; + + typedef void query_factory_type (const char* name, connection_type&); + typedef query_factory_type* query_factory_ptr; + typedef details::function_wrapper< + query_factory_type> query_factory_wrapper; + +#ifndef ODB_CXX11 + void + query_factory (const char* name, query_factory_ptr); +#else + template + typename std::enable_if< + std::is_convertible< + F, std::function>::value, void>::type + query_factory (const char* name, F f) + { + query_factory (name, query_factory_wrapper (std::move (f))); + } +#endif + + bool + call_query_factory (const char* name, connection_type&) const; + + private: + void + query_factory (const char* name, query_factory_wrapper); + + // Native database statement execution. + // + public: + unsigned long long + execute (const char* statement); + + unsigned long long + execute (const std::string& statement); + + unsigned long long + execute (const char* statement, std::size_t length); + + // Transactions. + // + public: + virtual transaction_impl* + begin () = 0; + + // Connections. + // + public: + connection_ptr + connection (); + + // SQL statement tracing. + // + public: + typedef odb::tracer tracer_type; + + void + tracer (tracer_type&); + + void + tracer (tracer_type*); + + tracer_type* + tracer () const; + + // Database schema version. + // + public: + typedef odb::schema_version schema_version_type; + typedef odb::schema_version_migration schema_version_migration_type; + + schema_version_type + schema_version (const std::string& schema_name = "") const; + + bool + schema_migration (const std::string& schema_name = "") const; + + // Note that there is code that relies on the returned reference + // being valid until the version is changed or the database instance + // is destroyed. + // + const schema_version_migration_type& + schema_version_migration (const std::string& schema_name = "") const; + + // Set schema version and migration state manually. + // + // Note that the modifier API is not thread-safe. That is, you should + // not modify the schema version while other threads may be accessing + // or modifying the same information. + // + void + schema_version_migration (schema_version_type, + bool migration, + const std::string& schema_name = ""); + + void + schema_version_migration (const schema_version_migration_type&, + const std::string& schema_name = ""); + + // Set default schema version table for all the schema names. The table + // name should already be quoted if necessary. + // + void + schema_version_table (const std::string& table_name); + + // Set schema version table for a specific schema. + // + void + schema_version_table (const std::string& table_name, + const std::string& schema_name); + + // Schema version sequence number. It is incremented every time the + // schema version or migration flag is changed and can be used to + // detect overall version changes. The starting value is 1. + // + unsigned int + schema_version_sequence () const; + + protected: + struct schema_version_info: schema_version_migration_type + { + std::string version_table; + }; + + virtual const schema_version_info& + load_schema_version (const std::string& schema_name) const = 0; + + private: + const schema_version_info& + schema_version_migration_ (const std::string& schema_name) const; + + // Database id. + // + public: + database_id + id () const; + + protected: + database (database_id); + + private: + database (const database&); + database& operator= (const database&); + + protected: + virtual connection_type* + connection_ () = 0; + + protected: + template + typename object_traits::id_type + persist_ (T&); + + template + typename object_traits::id_type + persist_ (const typename object_traits::pointer_type&); + + template + void + persist_ (I, I, bool); + + template + void + persist_ (I, I, bool, details::meta::no ptr); + + template + void + persist_ (I, I, bool, details::meta::yes ptr); + + template + typename object_traits::pointer_type + load_ (const typename object_traits::id_type&); + + template + void + load_ (const typename object_traits::id_type&, T&); + + template + void + load_ (T&, section&); + + template + void + reload_ (T&); + + template + typename object_traits::pointer_type + find_ (const typename object_traits::id_type&); + + template + bool + find_ (const typename object_traits::id_type&, T&); + + template + void + update_ (T&); + + template + void + update_ (const typename object_traits::pointer_type&); + + template + void + update_ (I, I, bool); + + template + void + update_ (const T&, const section&); + + template + void + erase_ (const typename object_traits::id_type&); + + template + void + erase_ (T&); + + template + void + erase_ (const typename object_traits::pointer_type&); + + template + void + erase_id_ (I, I, bool); + + template + void + erase_object_ (I, I, bool); + + template + typename object_traits::pointer_type + query_one_ (const Q&); + + template + bool + query_one_ (const Q&, T&); + + template + T + query_value_ (const Q&); + + template ::kind> + struct query_; + + protected: + typedef + std::map + query_factory_map; + + typedef std::map schema_version_map; + + database_id id_; + tracer_type* tracer_; + query_factory_map query_factory_map_; + + mutable details::mutex mutex_; + mutable schema_version_map schema_version_map_; + std::string schema_version_table_; + unsigned int schema_version_seq_; + }; +} + +#include +#include + +#include + +#endif // ODB_DATABASE_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/database.ixx b/third-party/odb/libodb-2.4.0/odb/database.ixx new file mode 100755 index 0000000..2b32c63 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/database.ixx @@ -0,0 +1,877 @@ +// file : odb/database.ixx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include // std::strlen() +#include // std::move +#include + +#include +#include + +namespace odb +{ + template + struct object_pointer_traits + { + typedef details::meta::no result_type; + typedef T object_type; + static const T& get_ref (const T& x) {return x;} + }; + + template + struct object_pointer_traits + { + typedef details::meta::yes result_type; + typedef T object_type; + static const T& get_ref (const T* p) {return *p;} + }; + + template + struct object_pointer_traits + { + typedef details::meta::yes result_type; + typedef T object_type; + static const T& get_ref (const T* p) {return *p;} + }; + + template class P> + struct object_pointer_traits > + { + typedef details::meta::yes result_type; + typedef T object_type; + static const T& get_ref (const P& p) { + return pointer_traits >::get_ref (p);} + }; + + template class P> + struct object_pointer_traits > + { + typedef details::meta::yes result_type; + typedef T object_type; + static const T& get_ref (const P& p) { + return pointer_traits >::get_ref (p);} + }; + + template class P> + struct object_pointer_traits > + { + typedef details::meta::yes result_type; + typedef T object_type; + static const T& get_ref (const P& p) { + return pointer_traits >::get_ref (p);} + }; + + template class P> + struct object_pointer_traits > + { + typedef details::meta::yes result_type; + typedef T object_type; + static const T& get_ref (const P& p) { + return pointer_traits >::get_ref (p);} + }; + + inline database:: + database (database_id id) + : id_ (id), tracer_ (0), schema_version_seq_ (1) + { + } + + inline database_id database:: + id () const + { + return id_; + } + + inline database::schema_version_type database:: + schema_version (const std::string& name) const + { + return schema_version_migration (name).version; + } + + inline bool database:: + schema_migration (const std::string& name) const + { + return schema_version_migration (name).migration; + } + + inline void database:: + schema_version_migration (schema_version_type v, + bool m, + const std::string& name) + { + schema_version_migration (schema_version_migration_type (v, m), name); + } + + inline void database:: + schema_version_table (const std::string& tname) + { + schema_version_table_ = tname; + } + + inline void database:: + schema_version_table (const std::string& tname, const std::string& sname) + { + schema_version_map_[sname].version_table = tname; + } + + inline unsigned int database:: + schema_version_sequence () const + { + return schema_version_seq_; + } + + inline connection_ptr database:: + connection () + { + return connection_ptr (connection_ ()); + } + +#ifndef ODB_CXX11 + inline void database:: + query_factory (const char* name, query_factory_ptr f) + { + query_factory (name, query_factory_wrapper (f)); + } +#endif + + inline void database:: + tracer (tracer_type& t) + { + tracer_ = &t; + } + + inline void database:: + tracer (tracer_type* t) + { + tracer_ = t; + } + + inline database::tracer_type* database:: + tracer () const + { + return tracer_; + } + + template + inline typename object_traits::id_type database:: + persist (T& obj) + { + return persist_ (obj); + } + + template + inline typename object_traits::id_type database:: + persist (const T& obj) + { + return persist_ (obj); + } + + template + inline typename object_traits::id_type database:: + persist (T* p) + { + typedef typename object_traits::pointer_type object_pointer; + + // The passed pointer should be the same or implicit-convertible + // to the object pointer. This way we make sure the object pointer + // does not assume ownership of the passed object. + // + const object_pointer& pobj (p); + + return persist_ (pobj); + } + + template class P> + inline typename object_traits::id_type database:: + persist (const P& p) + { + typedef typename object_traits::pointer_type object_pointer; + + // The passed pointer should be the same or implicit-convertible + // to the object pointer. This way we make sure the object pointer + // does not assume ownership of the passed object. + // + const object_pointer& pobj (p); + + return persist_ (pobj); + } + + template class P> + inline typename object_traits::id_type database:: + persist (const P& p) + { + typedef typename object_traits::pointer_type object_pointer; + + // The passed pointer should be the same or implicit-convertible + // to the object pointer. This way we make sure the object pointer + // does not assume ownership of the passed object. + // + const object_pointer& pobj (p); + + return persist_ (pobj); + } + + template class P> + inline typename object_traits::id_type database:: + persist (P& p) + { + const P& cr (p); + return persist (cr); + } + + template class P> + inline typename object_traits::id_type database:: + persist (P& p) + { + const P& cr (p); + return persist (cr); + } + + template + inline typename object_traits::id_type database:: + persist (const typename object_traits::pointer_type& pobj) + { + return persist_ (pobj); + } + + template + inline void database:: + persist (I b, I e, bool cont) + { + persist_ (b, e, cont); + } + + template + inline typename object_traits::pointer_type database:: + load (const typename object_traits::id_type& id) + { + return load_ (id); + } + + template + inline void database:: + load (const typename object_traits::id_type& id, T& obj) + { + return load_ (id, obj); + } + + template + inline void database:: + load (T& obj, section& s) + { + return load_ (obj, s); + } + + template + inline typename object_traits::pointer_type database:: + find (const typename object_traits::id_type& id) + { + return find_ (id); + } + + template + inline bool database:: + find (const typename object_traits::id_type& id, T& obj) + { + return find_ (id, obj); + } + + template + inline void database:: + reload (T& obj) + { + reload_ (obj); + } + + template + inline void database:: + reload (T* p) + { + reload (*p); + } + + template class P> + inline void database:: + reload (const P& p) + { + reload (odb::pointer_traits< P >::get_ref (p)); + } + + template class P> + inline void database:: + reload (const P& p) + { + reload (odb::pointer_traits< P >::get_ref (p)); + } + + template class P> + inline void database:: + reload (P& p) + { + reload (odb::pointer_traits< P >::get_ref (p)); + } + + template class P> + inline void database:: + reload (P& p) + { + reload (odb::pointer_traits< P >::get_ref (p)); + } + + template + inline void database:: + reload (const typename object_traits::pointer_type& pobj) + { + typedef typename object_traits::pointer_type pointer_type; + + reload (odb::pointer_traits::get_ref (pobj)); + } + + template + inline void database:: + update (T& obj) + { + update_ (obj); + } + + template + inline void database:: + update (T* p) + { + typedef typename object_traits::pointer_type object_pointer; + + // The passed pointer should be the same or implicit-convertible + // to the object pointer. This way we make sure the object pointer + // does not assume ownership of the passed object. + // + const object_pointer& pobj (p); + + update_ (pobj); + } + + template class P> + inline void database:: + update (const P& p) + { + typedef typename object_traits::pointer_type object_pointer; + + // The passed pointer should be the same or implicit-convertible + // to the object pointer. This way we make sure the object pointer + // does not assume ownership of the passed object. + // + const object_pointer& pobj (p); + + update_ (pobj); + } + + template class P> + inline void database:: + update (const P& p) + { + typedef typename object_traits::pointer_type object_pointer; + + // The passed pointer should be the same or implicit-convertible + // to the object pointer. This way we make sure the object pointer + // does not assume ownership of the passed object. + // + const object_pointer& pobj (p); + + update_ (pobj); + } + + template class P> + inline void database:: + update (P& p) + { + const P& cr (p); + update (cr); + } + + template class P> + inline void database:: + update (P& p) + { + const P& cr (p); + update (cr); + } + + template + inline void database:: + update (const typename object_traits::pointer_type& pobj) + { + update_ (pobj); + } + + template + inline void database:: + update (I b, I e, bool cont) + { + update_ (b, e, cont); + } + + template + inline void database:: + update (const T& obj, const section& s) + { + update_ (obj, s); + } + + template + inline void database:: + erase (const typename object_traits::id_type& id) + { + return erase_ (id); + } + + template + inline void database:: + erase (T& obj) + { + return erase_ (obj); + } + + template + inline void database:: + erase (T* p) + { + typedef typename object_traits::pointer_type object_pointer; + + // The passed pointer should be the same or implicit-convertible + // to the object pointer. This way we make sure the object pointer + // does not assume ownership of the passed object. + // + const object_pointer& pobj (p); + + erase_ (pobj); + } + + template class P> + inline void database:: + erase (const P& p) + { + typedef typename object_traits::pointer_type object_pointer; + + // The passed pointer should be the same or implicit-convertible + // to the object pointer. This way we make sure the object pointer + // does not assume ownership of the passed object. + // + const object_pointer& pobj (p); + + erase_ (pobj); + } + + template class P> + inline void database:: + erase (const P& p) + { + typedef typename object_traits::pointer_type object_pointer; + + // The passed pointer should be the same or implicit-convertible + // to the object pointer. This way we make sure the object pointer + // does not assume ownership of the passed object. + // + const object_pointer& pobj (p); + + erase_ (pobj); + } + + template class P> + inline void database:: + erase (P& p) + { + const P& cr (p); + erase (cr); + } + + template class P> + inline void database:: + erase (P& p) + { + const P& cr (p); + erase (cr); + } + + template + inline void database:: + erase (const typename object_traits::pointer_type& pobj) + { + erase_ (pobj); + } + + template + inline void database:: + erase (I idb, I ide, bool cont) + { + erase_id_ (idb, ide, cont); + } + + template + inline void database:: + erase (I ob, I oe, bool cont) + { + erase_object_ (ob, oe, cont); + } + + template + inline unsigned long long database:: + erase_query () + { + // T is always object_type. + // + return erase_query (odb::query ()); + } + + template + inline unsigned long long database:: + erase_query (const char* q) + { + // T is always object_type. + // + return erase_query (odb::query (q)); + } + + template + inline unsigned long long database:: + erase_query (const std::string& q) + { + // T is always object_type. + // + return erase_query (odb::query (q)); + } + + template + inline unsigned long long database:: + erase_query (const odb::query& q) + { + // T is always object_type. + // + return object_traits_impl::erase_query (*this, q); + } + + template + inline result database:: + query (bool cache) + { + return query (odb::query (), cache); + } + + template + inline result database:: + query (const char* q, bool cache) + { + return query (odb::query (q), cache); + } + + template + inline result database:: + query (const std::string& q, bool cache) + { + return query (odb::query (q), cache); + } + + template + inline typename object_traits::pointer_type database:: + query_one () + { + return query_one (odb::query ()); + } + + template + inline bool database:: + query_one (T& o) + { + return query_one (odb::query (), o); + } + + template + inline T database:: + query_value () + { + return query_value (odb::query ()); + } + + template + inline typename object_traits::pointer_type database:: + query_one (const char* q) + { + return query_one (odb::query (q)); + } + + template + inline bool database:: + query_one (const char* q, T& o) + { + return query_one (odb::query (q), o); + } + + template + inline T database:: + query_value (const char* q) + { + return query_value (odb::query (q)); + } + + template + inline typename object_traits::pointer_type database:: + query_one (const std::string& q) + { + return query_one (odb::query (q)); + } + + template + inline bool database:: + query_one (const std::string& q, T& o) + { + return query_one (odb::query (q), o); + } + + template + inline T database:: + query_value (const std::string& q) + { + return query_value (odb::query (q)); + } + + template + inline bool database:: + query_one (const odb::query& q, T& o) + { + return query_one_ (q, o); + } + + template + inline typename object_traits::pointer_type database:: + query_one (const odb::query& q) + { + return query_one_ (q); + } + + template + inline T database:: + query_value (const odb::query& q) + { + return query_value_ (q); + } + + template + inline prepared_query database:: + prepare_query (const char* n, const char* q) + { + return prepare_query (n, odb::query (q)); + } + + template + inline prepared_query database:: + prepare_query (const char* n, const std::string& q) + { + return prepare_query (n, odb::query (q)); + } + + template + inline prepared_query database:: + prepare_query (const char* n, const odb::query& q) + { + connection_type& c (transaction::current ().connection ()); + return c.prepare_query (n, q); + } + + template + inline void database:: + cache_query (const prepared_query& pq) + { + connection_type& c (transaction::current ().connection ()); + c.cache_query (pq); + } + + template + inline void database:: + cache_query (const prepared_query& pq, std::auto_ptr

params) + { + connection_type& c (transaction::current ().connection ()); + c.cache_query (pq, params); + } + +#ifdef ODB_CXX11 + template + inline void database:: + cache_query (const prepared_query& pq, std::unique_ptr

params) + { + connection_type& c (transaction::current ().connection ()); + c.cache_query (pq, std::move (params)); + } +#endif + + template + inline prepared_query database:: + lookup_query (const char* name) const + { + connection_type& c (transaction::current ().connection ()); + return c.lookup_query (name); + } + + template + inline prepared_query database:: + lookup_query (const char* name, P*& params) const + { + connection_type& c (transaction::current ().connection ()); + return c.lookup_query (name, params); + } + + // Implementations (i.e., the *_() functions). + // + template + inline void database:: + persist_ (I b, I e, bool cont) + { + // Sun CC with non-standard STL does not have iterator_traits. + // +#ifndef _RWSTD_NO_CLASS_PARTIAL_SPEC + typedef typename std::iterator_traits::value_type value_type; +#else + // Assume iterator is just a pointer. + // + typedef typename object_pointer_traits::object_type value_type; +#endif + + typedef object_pointer_traits opt; + + persist_ ( + b, e, cont, typename opt::result_type ()); + } + + template + inline typename object_traits::pointer_type database:: + find_ (const typename object_traits::id_type& id) + { + // T is always object_type. + // + + // Compiler error pointing here? Perhaps the object doesn't have the + // default constructor? + // + return object_traits_impl::find (*this, id); + } + + template + inline bool database:: + find_ (const typename object_traits::id_type& id, T& obj) + { + // T is always object_type. + // + return object_traits_impl::find (*this, id, obj); + } + + template + inline void database:: + update_ (T& obj) + { + // T can be const T while object_type will always be T. + // + typedef typename object_traits::object_type object_type; + + // Compiler error pointing here? Perhaps the object is readonly or + // doesn't have an object id? Such objects cannot be updated. + // + object_traits_impl::update (*this, obj); + } + + template + inline void database:: + update_ (const typename object_traits::pointer_type& pobj) + { + // T can be const T while object_type will always be T. + // + typedef typename object_traits::object_type object_type; + typedef typename object_traits::pointer_type pointer_type; + + T& obj (pointer_traits::get_ref (pobj)); + + // Compiler error pointing here? Perhaps the object is readonly or + // doesn't have an object id? Such objects cannot be updated. + // + object_traits_impl::update (*this, obj); + } + + template + inline void database:: + erase_ (const typename object_traits::id_type& id) + { + // T is always object_type. + // + object_traits_impl::erase (*this, id); + } + + template + inline void database:: + erase_ (T& obj) + { + // T can be const T while object_type will always be T. + // + typedef typename object_traits::object_type object_type; + + object_traits_impl::erase (*this, obj); + } + + template + inline void database:: + erase_ (const typename object_traits::pointer_type& pobj) + { + typedef typename object_traits::pointer_type pointer_type; + + erase_ (pointer_traits::get_ref (pobj)); + } + + template + inline typename object_traits::pointer_type database:: + query_one_ (const Q& q) + { + result r (query_::call (*this, q)); + + // We still have to cache the result since loading the object + // may result in loading of it's related objects and that would + // invalidate the result even for just getting the 'end' status. + // + r.cache (); + + return r.one (); + } + + template + inline bool database:: + query_one_ (const Q& q, T& o) + { + result r (query_::call (*this, q)); + r.cache (); // See above. + return r.one (o); + } + + template + inline T database:: + query_value_ (const Q& q) + { + result r (query_::call (*this, q)); + r.cache (); // See above. + + // Compiler error pointing here? The object must be default-constructible + // in order to use the return-by-value API. + // + T o; + r.value (o); + return o; + } + + // execute() + // + inline unsigned long long database:: + execute (const char* statement) + { + return execute (statement, std::strlen (statement)); + } + + inline unsigned long long database:: + execute (const std::string& statement) + { + return execute (statement.c_str (), statement.size ()); + } +} diff --git a/third-party/odb/libodb-2.4.0/odb/database.txx b/third-party/odb/libodb-2.4.0/odb/database.txx new file mode 100755 index 0000000..387b282 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/database.txx @@ -0,0 +1,492 @@ +// file : odb/database.txx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include +#include +#include +#include + +namespace odb +{ + template + result database:: + query (const odb::query& q, bool cache) + { + // T is always object_type. We also don't need to check for transaction + // here; object_traits::query () does this. + // + result r (query_::call (*this, q)); + + if (cache) + r.cache (); + + return r; + } + + // Implementations (i.e., the *_() functions). + // + template + typename object_traits::id_type database:: + persist_ (T& obj) + { + // T can be const T while object_type will always be T. + // + typedef typename object_traits::object_type object_type; + typedef object_traits_impl object_traits; + + object_traits::persist (*this, obj); + + typename object_traits::reference_cache_traits::position_type p ( + object_traits::reference_cache_traits::insert ( + *this, reference_cache_type::convert (obj))); + + object_traits::reference_cache_traits::persist (p); + + return object_traits::id (obj); + } + + template + typename object_traits::id_type database:: + persist_ (const typename object_traits::pointer_type& pobj) + { + // T can be const T while object_type will always be T. + // + typedef typename object_traits::object_type object_type; + typedef typename object_traits::pointer_type pointer_type; + + typedef object_traits_impl object_traits; + + T& obj (pointer_traits::get_ref (pobj)); + object_traits::persist (*this, obj); + + // Get the canonical object pointer and insert it into object cache. + // + typename object_traits::pointer_cache_traits::position_type p ( + object_traits::pointer_cache_traits::insert ( + *this, pointer_cache_type::convert (pobj))); + + object_traits::pointer_cache_traits::persist (p); + + return object_traits::id (obj); + } + + template ::auto_id> struct persist_type; + template struct persist_type {typedef T type;}; + template struct persist_type {typedef const T type;}; + + template + void database:: + persist_ (I b, I e, bool cont, details::meta::no /*ptr*/) + { + // T can be const T while object_type will always be T. + // + typedef typename object_traits::object_type object_type; + typedef object_traits_impl object_traits; + + multiple_exceptions mex (typeid (object_already_persistent)); + try + { + while (b != e && (cont || mex.empty ())) + { + std::size_t n (0); + T* a[object_traits::batch]; // T instead of persist_type for cache. + + for (; b != e && n < object_traits::batch; ++n) + { + // Compiler error pointing here? Perhaps the passed range is + // of const objects? + // + typename persist_type::type* p (&(*b++)); + + a[n] = const_cast (p); + } + + // Compiler error pointing here? Perhaps the object or the + // database does not support bulk operations? + // + object_traits::persist ( + *this, + const_cast::type**> (a), + n, + mex); + + if (mex.fatal ()) + break; + + for (std::size_t i (0); i < n; ++i) + { + if (mex[i] != 0) // Don't cache objects that have failed. + continue; + + mex.current (i); // Set position in case the below code throws. + + typename object_traits::reference_cache_traits::position_type p ( + object_traits::reference_cache_traits::insert ( + *this, reference_cache_type::convert (*a[i]))); + + object_traits::reference_cache_traits::persist (p); + } + + mex.delta (n); + } + } + catch (const odb::exception& ex) + { + mex.insert (ex, true); + } + + if (!mex.empty ()) + { + mex.prepare (); + throw mex; + } + } + + template + struct pointer_copy + { + const P* ref; + P copy; + + void assign (const P& p) {ref = &p;} + template void assign (const P1& p1) + { + // The passed pointer should be the same or implicit-convertible + // to the object pointer. This way we make sure the object pointer + // does not assume ownership of the passed object. + // + const P& p (p1); + + copy = p; + ref = © + } + }; + + template + void database:: + persist_ (I b, I e, bool cont, details::meta::yes /*ptr*/) + { + // T can be const T while object_type will always be T. + // + typedef typename object_traits::object_type object_type; + typedef typename object_traits::pointer_type pointer_type; + + typedef object_traits_impl object_traits; + + multiple_exceptions mex (typeid (object_already_persistent)); + try + { + while (b != e && (cont || mex.empty ())) + { + std::size_t n (0); + typename persist_type::type* a[object_traits::batch]; + pointer_copy p[object_traits::batch]; + + for (; b != e && n < object_traits::batch; ++n) + { + p[n].assign (*b++); + a[n] = &pointer_traits::get_ref (*p[n].ref); + } + + // Compiler error pointing here? Perhaps the object or the + // database does not support bulk operations? + // + object_traits::persist (*this, a, n, mex); + + if (mex.fatal ()) + break; + + for (std::size_t i (0); i < n; ++i) + { + if (mex[i] != 0) // Don't cache objects that have failed. + continue; + + mex.current (i); // Set position in case the below code throws. + + // Get the canonical object pointer and insert it into object cache. + // + typename object_traits::pointer_cache_traits::position_type pos ( + object_traits::pointer_cache_traits::insert ( + *this, pointer_cache_type::convert (*p[i].ref))); + + object_traits::pointer_cache_traits::persist (pos); + } + + mex.delta (n); + } + } + catch (const odb::exception& ex) + { + mex.insert (ex, true); + } + + if (!mex.empty ()) + { + mex.prepare (); + throw mex; + } + } + + template + typename object_traits::pointer_type database:: + load_ (const typename object_traits::id_type& id) + { + // T is always object_type. + // + typedef typename object_traits::pointer_type pointer_type; + + pointer_type r (find_ (id)); + + if (pointer_traits::null_ptr (r)) + throw object_not_persistent (); + + return r; + } + + template + void database:: + load_ (const typename object_traits::id_type& id, T& obj) + { + if (!find_ (id, obj)) + throw object_not_persistent (); + } + + template + void database:: + load_ (T& obj, section& s) + { + connection_type& c (transaction::current ().connection ()); + + // T is always object_type. + // + if (object_traits_impl::load (c, obj, s)) + s.reset (true, false); // Loaded, unchanged. + else + throw section_not_in_object (); + } + + template + void database:: + reload_ (T& obj) + { + // T should be object_type (cannot be const). We also don't need to + // check for transaction here; object_traits::reload () does this. + // + if (!object_traits_impl::reload (*this, obj)) + throw object_not_persistent (); + } + + template + void database:: + update_ (I b, I e, bool cont) + { + // Sun CC with non-standard STL does not have iterator_traits. + // +#ifndef _RWSTD_NO_CLASS_PARTIAL_SPEC + typedef typename std::iterator_traits::value_type value_type; +#else + // Assume iterator is just a pointer. + // + typedef typename object_pointer_traits::object_type value_type; +#endif + + // object_pointer_traits::object_type can be const. + // + typedef object_pointer_traits opt; + + typedef + typename object_traits::object_type + object_type; + + typedef object_traits_impl object_traits; + + multiple_exceptions mex ( + object_traits::managed_optimistic_column_count == 0 + ? typeid (object_not_persistent) + : typeid (object_changed)); + + try + { + while (b != e && (cont || mex.empty ())) + { + std::size_t n (0); + const object_type* a[object_traits::batch]; + + for (; b != e && n < object_traits::batch; ++n) + a[n] = &opt::get_ref (*b++); + + // Compiler error pointing here? Perhaps the object or the + // database does not support bulk operations? + // + object_traits::update (*this, a, n, mex); + + if (mex.fatal ()) + break; + + mex.delta (n); + } + } + catch (const odb::exception& ex) + { + mex.insert (ex, true); + } + + if (!mex.empty ()) + { + mex.prepare (); + throw mex; + } + } + + template + void database:: + update_ (const T& obj, const section& s) + { + if (!s.loaded ()) + throw section_not_loaded (); + + transaction& t (transaction::current ()); + + // T is always object_type. + // + if (object_traits_impl::update (t.connection (), obj, s)) + { + if (s.changed ()) + s.reset (true, false, &t); // Clear the change flag. + } + else + throw section_not_in_object (); + } + + template + void database:: + erase_id_ (I b, I e, bool cont) + { + // T is explicitly specified by the caller, so assume it is object type. + // + typedef T object_type; + typedef object_traits_impl object_traits; + typedef typename object_traits::id_type id_type; + + multiple_exceptions mex (typeid (object_not_persistent)); + try + { + while (b != e && (cont || mex.empty ())) + { + std::size_t n (0); + const id_type* a[object_traits::batch]; + + for (; b != e && n < object_traits::batch; ++n) + // Compiler error pointing here? Perhaps the object id type + // and the range element type don't match? + // + a[n] = &(*b++); + + // Compiler error pointing here? Perhaps the object or the + // database does not support bulk operations? + // + object_traits::erase (*this, a, n, mex); + + if (mex.fatal ()) + break; + + mex.delta (n); + } + } + catch (const odb::exception& ex) + { + mex.insert (ex, true); + } + + if (!mex.empty ()) + { + mex.prepare (); + throw mex; + } + } + + template + void database:: + erase_object_ (I b, I e, bool cont) + { + // Sun CC with non-standard STL does not have iterator_traits. + // +#ifndef _RWSTD_NO_CLASS_PARTIAL_SPEC + typedef typename std::iterator_traits::value_type value_type; +#else + // Assume iterator is just a pointer. + // + typedef typename object_pointer_traits::object_type value_type; +#endif + + // object_pointer_traits::object_type can be const. + // + typedef object_pointer_traits opt; + + typedef + typename object_traits::object_type + object_type; + + typedef object_traits_impl object_traits; + + multiple_exceptions mex ( + object_traits::managed_optimistic_column_count == 0 + ? typeid (object_not_persistent) + : typeid (object_changed)); + + try + { + while (b != e && (cont || mex.empty ())) + { + std::size_t n (0); + const object_type* a[object_traits::batch]; + + for (; b != e && n < object_traits::batch; ++n) + a[n] = &opt::get_ref (*b++); + + // Compiler error pointing here? Perhaps the object or the + // database does not support bulk operations? + // + object_traits::erase (*this, a, n, mex); + + if (mex.fatal ()) + break; + + mex.delta (n); + } + } + catch (const odb::exception& ex) + { + mex.insert (ex, true); + } + + if (!mex.empty ()) + { + mex.prepare (); + throw mex; + } + } + + template + struct database::query_ + { + template + static result + call (database& db, const Q& q) + { + return object_traits_impl::query (db, q); + } + }; + + template + struct database::query_ + { + template + static result + call (database& db, const Q& q) + { + return view_traits_impl::query (db, q); + } + }; +} diff --git a/third-party/odb/libodb-2.4.0/odb/details/buffer.cxx b/third-party/odb/libodb-2.4.0/odb/details/buffer.cxx new file mode 100755 index 0000000..030d846 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/details/buffer.cxx @@ -0,0 +1,36 @@ +// file : odb/details/buffer.cxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include // std::memcpy + +#include + +using namespace std; + +namespace odb +{ + namespace details + { + void basic_buffer_base:: + capacity (size_t c, size_t data_size) + { + if (c > capacity_) + { + size_t n (capacity_ * 2 > c ? capacity_ * 2 : c); + void* d (operator new (n)); + + if (data_ != 0) + { + if (data_size != 0) + memcpy (d, data_, data_size); + + operator delete (data_); + } + + data_ = d; + capacity_ = n; + } + } + } +} diff --git a/third-party/odb/libodb-2.4.0/odb/details/buffer.hxx b/third-party/odb/libodb-2.4.0/odb/details/buffer.hxx new file mode 100755 index 0000000..d444710 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/details/buffer.hxx @@ -0,0 +1,77 @@ +// file : odb/details/buffer.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_BUFFER_DETAILS_HXX +#define ODB_BUFFER_DETAILS_HXX + +#include + +#include +#include // std::size_t + +#include + +namespace odb +{ + namespace details + { + class LIBODB_EXPORT basic_buffer_base + { + public: + ~basic_buffer_base () + { + if (data_ != 0) + operator delete (data_); + } + + basic_buffer_base (std::size_t capacity) + : capacity_ (capacity) + { + data_ = capacity_ == 0 ? 0 : operator new (capacity_); + } + + std::size_t + capacity () const + { + return capacity_; + } + + void + capacity (std::size_t, std::size_t data_size = 0); + + protected: + void* data_; + std::size_t capacity_; + }; + + template + class basic_buffer: public basic_buffer_base + { + public: + basic_buffer (std::size_t capacity = 256) + : basic_buffer_base (capacity) + { + } + + T* + data () + { + return static_cast (data_); + } + + const T* + data () const + { + return static_cast (data_); + } + }; + + typedef basic_buffer buffer; + typedef basic_buffer ubuffer; + } +} + +#include + +#endif // ODB_BUFFER_DETAILS_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/details/c-string.hxx b/third-party/odb/libodb-2.4.0/odb/details/c-string.hxx new file mode 100755 index 0000000..c4739a4 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/details/c-string.hxx @@ -0,0 +1,31 @@ +// file : odb/details/c-string.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_DETAILS_C_STRING_HXX +#define ODB_DETAILS_C_STRING_HXX + +#include + +#include + +#include + +namespace odb +{ + namespace details + { + struct LIBODB_EXPORT c_string_comparator + { + bool + operator() (const char* x, const char* y) const + { + return std::strcmp (x, y) < 0; + } + }; + } +} + +#include + +#endif // ODB_DETAILS_C_STRING_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/details/condition.cxx b/third-party/odb/libodb-2.4.0/odb/details/condition.cxx new file mode 100755 index 0000000..39d68d5 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/details/condition.cxx @@ -0,0 +1,14 @@ +// file : odb/details/condition.cxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include + +namespace odb +{ + namespace details + { + // This otherwise unnecessary file is here to allow instantiation + // of inline functions for exporting. + } +} diff --git a/third-party/odb/libodb-2.4.0/odb/details/condition.hxx b/third-party/odb/libodb-2.4.0/odb/details/condition.hxx new file mode 100755 index 0000000..cf22a70 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/details/condition.hxx @@ -0,0 +1,48 @@ +// file : odb/details/condition.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_DETAILS_CONDITION_HXX +#define ODB_DETAILS_CONDITION_HXX + +#include + +#include +#include + +#ifdef ODB_THREADS_NONE + +namespace odb +{ + namespace details + { + class mutex; + class LIBODB_EXPORT condition + { + public: + condition (mutex&) {} + + void + signal () {} + + void + wait () {} + + private: + condition (const condition&); + condition& operator= (const condition&); + }; + } +} + +#elif defined(ODB_THREADS_POSIX) +#include +#elif defined(ODB_THREADS_WIN32) +#include +#else +# error unknown threading model +#endif + +#include + +#endif // ODB_DETAILS_CONDITION_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/details/config-vc.h b/third-party/odb/libodb-2.4.0/odb/details/config-vc.h new file mode 100755 index 0000000..a7f8c95 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/details/config-vc.h @@ -0,0 +1,31 @@ +/* file : odb/details/config-vc.h + * copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC + * license : GNU GPL v2; see accompanying LICENSE file + */ + +/* Configuration file for Windows/VC++. */ + +#ifndef ODB_DETAILS_CONFIG_VC_H +#define ODB_DETAILS_CONFIG_VC_H + +#define ODB_THREADS_WIN32 +#define ODB_THREADS_TLS_DECLSPEC + +/* VC++10 and later have C++11 always enabled. + */ +#if _MSC_VER >= 1600 +# define ODB_CXX11 +# define ODB_CXX11_NULLPTR +# if _MSC_VER >= 1700 +# define ODB_CXX11_ENUM +# if _MSC_VER >= 1800 +# define ODB_CXX11_DELETED_FUNCTION +# define ODB_CXX11_EXPLICIT_CONVERSION_OPERATOR +# define ODB_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGUMENT +# define ODB_CXX11_VARIADIC_TEMPLATE +# define ODB_CXX11_INITIALIZER_LIST +# endif +# endif +#endif + +#endif /* ODB_DETAILS_CONFIG_VC_H */ diff --git a/third-party/odb/libodb-2.4.0/odb/details/config.h.in b/third-party/odb/libodb-2.4.0/odb/details/config.h.in new file mode 100755 index 0000000..883a075 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/details/config.h.in @@ -0,0 +1,19 @@ +/* file : odb/details/config.h.in + * copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC + * license : GNU GPL v2; see accompanying LICENSE file + */ + +/* This file is automatically processed by configure. */ + +#ifndef ODB_DETAILS_CONFIG_H +#define ODB_DETAILS_CONFIG_H + +#undef ODB_THREADS_NONE +#undef ODB_THREADS_POSIX +#undef ODB_THREADS_WIN32 +#undef ODB_THREADS_TLS_KEYWORD +#undef ODB_THREADS_TLS_DECLSPEC + +#undef LIBODB_STATIC_LIB + +#endif /* ODB_DETAILS_CONFIG_H */ diff --git a/third-party/odb/libodb-2.4.0/odb/details/config.hxx b/third-party/odb/libodb-2.4.0/odb/details/config.hxx new file mode 100755 index 0000000..c8f6239 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/details/config.hxx @@ -0,0 +1,51 @@ +// file : odb/details/config.hxx +// copyright : Copyright (c) 2005-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_DETAILS_CONFIG_HXX +#define ODB_DETAILS_CONFIG_HXX + +// no pre + +#ifdef _MSC_VER +# include +#elif defined(ODB_COMPILER) +# define ODB_THREADS_NONE +# define LIBODB_STATIC_LIB +# if defined(__GXX_EXPERIMENTAL_CXX0X__) || __cplusplus >= 201103L +# define ODB_CXX11 +# if (__GNUC__ == 4 && __GNUC_MINOR__ >= 6) || __GNUC__ > 4 +# define ODB_CXX11_NULLPTR +# endif +# define ODB_CXX11_DELETED_FUNCTION +# define ODB_CXX11_EXPLICIT_CONVERSION_OPERATOR +# define ODB_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGUMENT +# define ODB_CXX11_VARIADIC_TEMPLATE +# define ODB_CXX11_INITIALIZER_LIST +# endif +#else +# include +# if defined(__GXX_EXPERIMENTAL_CXX0X__) || __cplusplus >= 201103L +# define ODB_CXX11 +# ifdef __GNUC__ +# if (__GNUC__ == 4 && __GNUC_MINOR__ >= 6) || __GNUC__ > 4 +# define ODB_CXX11_NULLPTR +# endif +# else +# define ODB_CXX11_NULLPTR +# endif +# define ODB_CXX11_DELETED_FUNCTION +# define ODB_CXX11_EXPLICIT_CONVERSION_OPERATOR +# define ODB_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGUMENT +# define ODB_CXX11_VARIADIC_TEMPLATE +# define ODB_CXX11_INITIALIZER_LIST +// GCC supports strongly typed enums from 4.4 (forward -- 4.6), +// Clang -- 2.9 (3.1). +// +# define ODB_CXX11_ENUM +# endif +#endif + +// no post + +#endif // ODB_DETAILS_CONFIG_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/details/exception.hxx b/third-party/odb/libodb-2.4.0/odb/details/exception.hxx new file mode 100755 index 0000000..6838801 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/details/exception.hxx @@ -0,0 +1,26 @@ +// file : odb/details/exception.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_DETAILS_EXCEPTION_HXX +#define ODB_DETAILS_EXCEPTION_HXX + +#include + +#include + +#include + +namespace odb +{ + namespace details + { + struct LIBODB_EXPORT exception: odb::exception + { + }; + } +} + +#include + +#endif // ODB_DETAILS_EXCEPTION_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/details/export.hxx b/third-party/odb/libodb-2.4.0/odb/details/export.hxx new file mode 100755 index 0000000..8b36cae --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/details/export.hxx @@ -0,0 +1,40 @@ +// file : odb/details/export.hxx +// copyright : Copyright (c) 2005-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_DETAILS_EXPORT_HXX +#define ODB_DETAILS_EXPORT_HXX + +#include + +#include + +#ifdef LIBODB_STATIC_LIB +# define LIBODB_EXPORT +#else +# ifdef _WIN32 +# ifdef _MSC_VER +# ifdef LIBODB_DYNAMIC_LIB +# define LIBODB_EXPORT __declspec(dllexport) +# else +# define LIBODB_EXPORT __declspec(dllimport) +# endif +# else +# ifdef LIBODB_DYNAMIC_LIB +# ifdef DLL_EXPORT +# define LIBODB_EXPORT __declspec(dllexport) +# else +# define LIBODB_EXPORT +# endif +# else +# define LIBODB_EXPORT __declspec(dllimport) +# endif +# endif +# else +# define LIBODB_EXPORT +# endif +#endif + +#include + +#endif // ODB_DETAILS_EXPORT_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/details/function-wrapper.hxx b/third-party/odb/libodb-2.4.0/odb/details/function-wrapper.hxx new file mode 100755 index 0000000..5615fca --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/details/function-wrapper.hxx @@ -0,0 +1,83 @@ +// file : odb/details/function-wrapper.hxx +// copyright : Copyright (c) 2009-2014 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_DETAILS_FUNCTION_WRAPPER_HXX +#define ODB_DETAILS_FUNCTION_WRAPPER_HXX + +#include + +#include // ODB_CXX11 + +#ifdef ODB_CXX11 +# include // std::function +# include // std::enable_if, std::is_convertible +#endif + +namespace odb +{ + namespace details + { + // Low-level 'callable object' wrapper similar to std::function but + // that works in both C++98 and 11. In particular, the call site can + // be compiled in C++98 and the registration site in C++11 and it + // will work. + // + template + struct function_wrapper + { + ~function_wrapper (); + + explicit + function_wrapper (F* = 0); + +#ifdef ODB_CXX11 + typedef typename std::function std_function_type; + + // This overload accepts lambdas and std::functions, but when the + // argument is convertible to F*, then we disable it in favor of the + // other overload (above), which is more efficient. + // + // Subtlety alert: if you're thinking of changing this to accept a + // std::function argument, stop. That creates an overload ambiguity + // when the actual parameter is a lambda, which is convertible to either + // std::function or F*. + // + template + function_wrapper(F1, + typename std::enable_if< + !std::is_convertible::value>::type* = 0); +#endif + + // Destructive copy construction and assignment (aka move). These + // should really only be called by containers when they need to + // reallocate the underlying buffer and move the elements. + // + function_wrapper (const function_wrapper&); + function_wrapper& + operator= (const function_wrapper&); + + void swap (function_wrapper&); + + // Conversion to bool. + // + public: + typedef void (function_wrapper::*bool_convertible) (); + void true_value () {} + + operator bool_convertible () const; + + public: + F* function; + void (*deleter) (const void*); + const void* std_function; + }; + } +} + +#include +#include + +#include + +#endif // ODB_DETAILS_FUNCTION_WRAPPER_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/details/function-wrapper.ixx b/third-party/odb/libodb-2.4.0/odb/details/function-wrapper.ixx new file mode 100755 index 0000000..58ede04 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/details/function-wrapper.ixx @@ -0,0 +1,47 @@ +// file : odb/details/function-wrapper.ixx +// copyright : Copyright (c) 2009-2014 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +namespace odb +{ + namespace details + { + template + inline function_wrapper:: + ~function_wrapper () + { + if (deleter != 0) + deleter (std_function); + } + + template + inline function_wrapper:: + function_wrapper (F* f) + : function (f), deleter (0), std_function (0) + { + } + + template + inline function_wrapper:: + function_wrapper (const function_wrapper& x) + : function (0), deleter (0), std_function (0) + { + swap (const_cast&> (x)); + } + + template + inline function_wrapper& function_wrapper:: + operator= (const function_wrapper& x) + { + swap (const_cast&> (x)); + return *this; + } + + template + inline function_wrapper:: + operator bool_convertible () const + { + return function != 0 ? &function_wrapper::true_value : 0; + } + } +} diff --git a/third-party/odb/libodb-2.4.0/odb/details/function-wrapper.txx b/third-party/odb/libodb-2.4.0/odb/details/function-wrapper.txx new file mode 100755 index 0000000..70dcb0f --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/details/function-wrapper.txx @@ -0,0 +1,87 @@ +// file : odb/details/function-wrapper.txx +// copyright : Copyright (c) 2009-2014 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include // std::swap, std::move + +namespace odb +{ + namespace details + { +#ifdef ODB_CXX11 + template + struct caller_impl; + +#ifdef ODB_CXX11_VARIADIC_TEMPLATE + template + struct caller_impl + { + static R + function (const void* f, A... a) + { + return (*static_cast*> (f)) (a...); + } + }; +#else + template + struct caller_impl + { + static R + function (const void* f, A1 a1) + { + return (*static_cast*> (f)) (a1); + } + }; + + template + struct caller_impl + { + static R + function (const void* f, A1 a1, A2 a2) + { + return (*static_cast*> (f)) (a1, a2); + } + }; +#endif + + template + void + deleter_impl (const void* f) + { + delete static_cast*> (f); + } + + template + template + function_wrapper:: + function_wrapper ( + F1 f, + typename std::enable_if::value>::type*) + { + std_function_type sf (std::move (f)); + + if (F* const* const f = sf.template target ()) + { + function = *f; + deleter = 0; + std_function = 0; + } + else + { + function = reinterpret_cast (&caller_impl::function); + deleter = &deleter_impl; + std_function = new std_function_type (std::move (sf)); + } + } +#endif + + template + void function_wrapper:: + swap (function_wrapper& x) + { + std::swap (function, x.function); + std::swap (deleter, x.deleter); + std::swap (std_function, x.std_function); + } + } +} diff --git a/third-party/odb/libodb-2.4.0/odb/details/lock.cxx b/third-party/odb/libodb-2.4.0/odb/details/lock.cxx new file mode 100755 index 0000000..2895604 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/details/lock.cxx @@ -0,0 +1,14 @@ +// file : odb/details/lock.cxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include + +namespace odb +{ + namespace details + { + // This otherwise unnecessary file is here to allow instantiation + // of inline functions for exporting. + } +} diff --git a/third-party/odb/libodb-2.4.0/odb/details/lock.hxx b/third-party/odb/libodb-2.4.0/odb/details/lock.hxx new file mode 100755 index 0000000..26ab4a8 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/details/lock.hxx @@ -0,0 +1,49 @@ +// file : odb/details/lock.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_DETAILS_LOCK_HXX +#define ODB_DETAILS_LOCK_HXX + +#include + +#include +#include + +namespace odb +{ + namespace details + { + struct LIBODB_EXPORT lock + { + lock (mutex& m) + : mutex_ (&m) + { + mutex_->lock (); + } + + ~lock () + { + if (mutex_ != 0) + mutex_->unlock (); + } + + void + unlock () + { + if (mutex_ != 0) + { + mutex_->unlock (); + mutex_ = 0; + } + } + + private: + mutex* mutex_; + }; + } +} + +#include + +#endif // ODB_DETAILS_LOCK_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/details/meta/answer.hxx b/third-party/odb/libodb-2.4.0/odb/details/meta/answer.hxx new file mode 100755 index 0000000..50c1d9b --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/details/meta/answer.hxx @@ -0,0 +1,31 @@ +// file : odb/details/meta/answer.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_DETAILS_META_ANSWER_HXX +#define ODB_DETAILS_META_ANSWER_HXX + +#include + +namespace odb +{ + namespace details + { + namespace meta + { + struct yes + { + char filling; + }; + + struct no + { + char filling[2]; + }; + } + } +} + +#include + +#endif // ODB_DETAILS_META_ANSWER_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/details/meta/class-p.hxx b/third-party/odb/libodb-2.4.0/odb/details/meta/class-p.hxx new file mode 100755 index 0000000..97583d6 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/details/meta/class-p.hxx @@ -0,0 +1,35 @@ +// file : odb/details/meta/class-p.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_DETAILS_META_CLASS_HXX +#define ODB_DETAILS_META_CLASS_HXX + +#include + +#include + +namespace odb +{ + namespace details + { + namespace meta + { + // g++ cannot have these inside class_p. + // + template no class_p_test (...); + template yes class_p_test (void (X::*) ()); + + template + struct class_p + { + static const bool result = + sizeof (class_p_test (0)) == sizeof (yes); + }; + } + } +} + +#include + +#endif // ODB_DETAILS_META_CLASS_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/details/meta/polymorphic-p.hxx b/third-party/odb/libodb-2.4.0/odb/details/meta/polymorphic-p.hxx new file mode 100755 index 0000000..bd90fc2 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/details/meta/polymorphic-p.hxx @@ -0,0 +1,57 @@ +// file : odb/details/meta/polymorphic-p.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_DETAILS_META_POLYMORPHIC_HXX +#define ODB_DETAILS_META_POLYMORPHIC_HXX + +#include + +#include +#include + +namespace odb +{ + namespace details + { + namespace meta + { + template + struct polymorphic_p + { + typedef typename remove_const_volatile::result X; + + template + struct impl + { + static const bool result = false; + }; + + template + struct impl + { + struct t1: Y + { + t1 (); + }; + + struct t2: Y + { + t2 (); + + virtual + ~t2 () throw (); + }; + + static const bool result = sizeof (t1) == sizeof (t2); + }; + + static const bool result = impl::result>::result; + }; + } + } +} + +#include + +#endif // ODB_DETAILS_META_POLYMORPHIC_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/details/meta/remove-const-volatile.hxx b/third-party/odb/libodb-2.4.0/odb/details/meta/remove-const-volatile.hxx new file mode 100755 index 0000000..653219b --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/details/meta/remove-const-volatile.hxx @@ -0,0 +1,32 @@ +// file : odb/details/meta/remove-const-volatile.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_DETAILS_META_REMOVE_CONST_VOLATILE_HXX +#define ODB_DETAILS_META_REMOVE_CONST_VOLATILE_HXX + +#include + +#include +#include + +namespace odb +{ + namespace details + { + namespace meta + { + template + struct remove_const_volatile + { + typedef + typename remove_volatile::result>::result + result; + }; + } + } +} + +#include + +#endif // ODB_DETAILS_META_REMOVE_CONST_VOLATILE_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/details/meta/remove-const.hxx b/third-party/odb/libodb-2.4.0/odb/details/meta/remove-const.hxx new file mode 100755 index 0000000..d73b751 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/details/meta/remove-const.hxx @@ -0,0 +1,33 @@ +// file : odb/details/meta/remove-const.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_DETAILS_META_REMOVE_CONST_HXX +#define ODB_DETAILS_META_REMOVE_CONST_HXX + +#include + +namespace odb +{ + namespace details + { + namespace meta + { + template + struct remove_const + { + typedef X result; + }; + + template + struct remove_const + { + typedef X result; + }; + } + } +} + +#include + +#endif // ODB_DETAILS_META_REMOVE_CONST_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/details/meta/remove-pointer.hxx b/third-party/odb/libodb-2.4.0/odb/details/meta/remove-pointer.hxx new file mode 100755 index 0000000..19917bb --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/details/meta/remove-pointer.hxx @@ -0,0 +1,33 @@ +// file : odb/details/meta/remove-pointer.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_DETAILS_META_REMOVE_POINTER_HXX +#define ODB_DETAILS_META_REMOVE_POINTER_HXX + +#include + +namespace odb +{ + namespace details + { + namespace meta + { + template + struct remove_pointer + { + typedef X result; + }; + + template + struct remove_pointer + { + typedef X result; + }; + } + } +} + +#include + +#endif // ODB_DETAILS_META_REMOVE_POINTER_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/details/meta/remove-volatile.hxx b/third-party/odb/libodb-2.4.0/odb/details/meta/remove-volatile.hxx new file mode 100755 index 0000000..6acd948 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/details/meta/remove-volatile.hxx @@ -0,0 +1,33 @@ +// file : odb/details/meta/remove-volatile.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_DETAILS_META_REMOVE_VOLATILE_HXX +#define ODB_DETAILS_META_REMOVE_VOLATILE_HXX + +#include + +namespace odb +{ + namespace details + { + namespace meta + { + template + struct remove_volatile + { + typedef X result; + }; + + template + struct remove_volatile + { + typedef X result; + }; + } + } +} + +#include + +#endif // ODB_DETAILS_META_REMOVE_VOLATILE_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/details/meta/static-assert.hxx b/third-party/odb/libodb-2.4.0/odb/details/meta/static-assert.hxx new file mode 100755 index 0000000..8728e7b --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/details/meta/static-assert.hxx @@ -0,0 +1,33 @@ +// file : odb/details/meta/static-assert.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_DETAILS_META_STATIC_ASSERT_HXX +#define ODB_DETAILS_META_STATIC_ASSERT_HXX + +#include + +#include // ODB_CXX11 + +#ifndef ODB_CXX11 + +namespace odb +{ + namespace details + { + namespace meta + { + template + struct static_assert_test; + + template <> + struct static_assert_test {}; + } + } +} + +#endif + +#include + +#endif // ODB_DETAILS_META_STATIC_ASSERT_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/details/mutex.cxx b/third-party/odb/libodb-2.4.0/odb/details/mutex.cxx new file mode 100755 index 0000000..3302c92 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/details/mutex.cxx @@ -0,0 +1,14 @@ +// file : odb/details/mutex.cxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include + +namespace odb +{ + namespace details + { + // This otherwise unnecessary file is here to allow instantiation + // of inline functions for exporting. + } +} diff --git a/third-party/odb/libodb-2.4.0/odb/details/mutex.hxx b/third-party/odb/libodb-2.4.0/odb/details/mutex.hxx new file mode 100755 index 0000000..6bdfd21 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/details/mutex.hxx @@ -0,0 +1,47 @@ +// file : odb/details/mutex.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_DETAILS_MUTEX_HXX +#define ODB_DETAILS_MUTEX_HXX + +#include + +#include +#include + +#ifdef ODB_THREADS_NONE + +namespace odb +{ + namespace details + { + class LIBODB_EXPORT mutex + { + public: + mutex () {} + + void + lock () {} + + void + unlock () {} + + private: + mutex (const mutex&); + mutex& operator= (const mutex&); + }; + } +} + +#elif defined(ODB_THREADS_POSIX) +#include +#elif defined(ODB_THREADS_WIN32) +#include +#else +# error unknown threading model +#endif + +#include + +#endif // ODB_DETAILS_MUTEX_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/details/posix/condition.hxx b/third-party/odb/libodb-2.4.0/odb/details/posix/condition.hxx new file mode 100755 index 0000000..6a86741 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/details/posix/condition.hxx @@ -0,0 +1,46 @@ +// file : odb/details/posix/condition.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_DETAILS_POSIX_CONDITION_HXX +#define ODB_DETAILS_POSIX_CONDITION_HXX + +#include + +#include + +#include +#include + +namespace odb +{ + namespace details + { + class LIBODB_EXPORT condition + { + public: + ~condition (); + condition (mutex&); + + void + signal (); + + void + wait (); + + private: + condition (const condition&); + condition& operator= (const condition&); + + private: + mutex& mutex_; + pthread_cond_t cond_; + }; + } +} + +#include + +#include + +#endif // ODB_DETAILS_POSIX_CONDITION_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/details/posix/condition.ixx b/third-party/odb/libodb-2.4.0/odb/details/posix/condition.ixx new file mode 100755 index 0000000..9ebd60e --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/details/posix/condition.ixx @@ -0,0 +1,39 @@ +// file : odb/details/posix/condition.ixx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include + +namespace odb +{ + namespace details + { + inline condition:: + ~condition () + { + pthread_cond_destroy (&cond_); + } + + inline condition:: + condition (mutex& mutex) + : mutex_ (mutex) + { + if (int e = pthread_cond_init (&cond_, 0)) + throw posix_exception (e); + } + + inline void condition:: + signal () + { + if (int e = pthread_cond_signal (&cond_)) + throw posix_exception (e); + } + + inline void condition:: + wait () + { + if (int e = pthread_cond_wait (&cond_, &mutex_.mutex_)) + throw posix_exception (e); + } + } +} diff --git a/third-party/odb/libodb-2.4.0/odb/details/posix/exceptions.cxx b/third-party/odb/libodb-2.4.0/odb/details/posix/exceptions.cxx new file mode 100755 index 0000000..0ed0aa3 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/details/posix/exceptions.cxx @@ -0,0 +1,23 @@ +// file : odb/details/posix/exceptions.cxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include + +namespace odb +{ + namespace details + { + const char* posix_exception:: + what () const throw () + { + return "POSIX API error"; + } + + posix_exception* posix_exception:: + clone () const + { + return new posix_exception (*this); + } + } +} diff --git a/third-party/odb/libodb-2.4.0/odb/details/posix/exceptions.hxx b/third-party/odb/libodb-2.4.0/odb/details/posix/exceptions.hxx new file mode 100755 index 0000000..dd78313 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/details/posix/exceptions.hxx @@ -0,0 +1,38 @@ +// file : odb/details/posix/exceptions.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_DETAILS_POSIX_EXCEPTIONS_HXX +#define ODB_DETAILS_POSIX_EXCEPTIONS_HXX + +#include + +#include +#include + +namespace odb +{ + namespace details + { + struct LIBODB_EXPORT posix_exception: details::exception + { + posix_exception (int code) : code_ (code) {} + + int + code () const {return code_;} + + virtual const char* + what () const throw (); + + virtual posix_exception* + clone () const; + + private: + int code_; + }; + } +} + +#include + +#endif // ODB_DETAILS_POSIX_EXCEPTIONS_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/details/posix/mutex.hxx b/third-party/odb/libodb-2.4.0/odb/details/posix/mutex.hxx new file mode 100755 index 0000000..62bd3cf --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/details/posix/mutex.hxx @@ -0,0 +1,45 @@ +// file : odb/details/posix/mutex.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_DETAILS_POSIX_MUTEX_HXX +#define ODB_DETAILS_POSIX_MUTEX_HXX + +#include + +#include + +#include + +namespace odb +{ + namespace details + { + class LIBODB_EXPORT mutex + { + public: + ~mutex (); + mutex (); + + void + lock (); + + void + unlock (); + + private: + mutex (const mutex&); + mutex& operator= (const mutex&); + + private: + friend class condition; + pthread_mutex_t mutex_; + }; + } +} + +#include + +#include + +#endif // ODB_DETAILS_POSIX_MUTEX_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/details/posix/mutex.ixx b/third-party/odb/libodb-2.4.0/odb/details/posix/mutex.ixx new file mode 100755 index 0000000..50e3013 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/details/posix/mutex.ixx @@ -0,0 +1,38 @@ +// file : odb/details/posix/mutex.ixx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include + +namespace odb +{ + namespace details + { + inline mutex:: + ~mutex () + { + pthread_mutex_destroy (&mutex_); + } + + inline mutex:: + mutex () + { + if (int e = pthread_mutex_init (&mutex_, 0)) + throw posix_exception (e); + } + + inline void mutex:: + lock () + { + if (int e = pthread_mutex_lock (&mutex_)) + throw posix_exception (e); + } + + inline void mutex:: + unlock () + { + if (int e = pthread_mutex_unlock (&mutex_)) + throw posix_exception (e); + } + } +} diff --git a/third-party/odb/libodb-2.4.0/odb/details/posix/thread.cxx b/third-party/odb/libodb-2.4.0/odb/details/posix/thread.cxx new file mode 100755 index 0000000..ef0702b --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/details/posix/thread.cxx @@ -0,0 +1,45 @@ +// file : odb/details/posix/thread.cxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include +#include +#include + +typedef void* (*thread_func) (void*); + +struct thread_data +{ + thread_func func; + void* arg; +}; + +extern "C" void* +odb_thread_thunk (void* arg) +{ + thread_data* data (static_cast (arg)); + thread_func func = data->func; + arg = data->arg; + delete data; + return func (arg); +} + +namespace odb +{ + namespace details + { + thread:: + thread (void* (*func) (void*), void* arg) + : detached_ (false) + { + unique_ptr data (new thread_data); + data->func = func; + data->arg = arg; + + if (int e = pthread_create (&id_, 0, &odb_thread_thunk, data.get ())) + throw posix_exception (e); + + data.release (); // Thread thunk will free this. + } + } +} diff --git a/third-party/odb/libodb-2.4.0/odb/details/posix/thread.hxx b/third-party/odb/libodb-2.4.0/odb/details/posix/thread.hxx new file mode 100755 index 0000000..21d4f7b --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/details/posix/thread.hxx @@ -0,0 +1,42 @@ +// file : odb/details/posix/thread.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_DETAILS_POSIX_THREAD_HXX +#define ODB_DETAILS_POSIX_THREAD_HXX + +#include + +#include + +#include + +namespace odb +{ + namespace details + { + class LIBODB_EXPORT thread + { + public: + ~thread (); + thread (void* (*thread_func) (void*), void* arg = 0); + + void* + join (); + + private: + thread (const thread&); + thread& operator= (const thread&); + + private: + bool detached_; + pthread_t id_; + }; + } +} + +#include + +#include + +#endif // ODB_DETAILS_POSIX_THREAD_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/details/posix/thread.ixx b/third-party/odb/libodb-2.4.0/odb/details/posix/thread.ixx new file mode 100755 index 0000000..43fc45c --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/details/posix/thread.ixx @@ -0,0 +1,33 @@ +// file : odb/details/posix/thread.ixx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include + +namespace odb +{ + namespace details + { + inline thread:: + ~thread () + { + if (!detached_) + { + if (int e = pthread_detach (id_)) + throw posix_exception (e); + } + } + + inline void* thread:: + join () + { + void* r; + + if (int e = pthread_join (id_, &r)) + throw posix_exception (e); + + detached_ = true; + return r; + } + } +} diff --git a/third-party/odb/libodb-2.4.0/odb/details/posix/tls.hxx b/third-party/odb/libodb-2.4.0/odb/details/posix/tls.hxx new file mode 100755 index 0000000..9c32605 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/details/posix/tls.hxx @@ -0,0 +1,107 @@ +// file : odb/details/posix/tls.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_DETAILS_POSIX_TLS_HXX +#define ODB_DETAILS_POSIX_TLS_HXX + +#include + +#include + +namespace odb +{ + namespace details + { + template + class tls + { + public: + tls (); + + T& + get () const; + + void + free (); + + private: + tls (const tls&); + tls& operator= (const tls&); + + private: + static void + key_init (); + + static void + destructor (void*); + + private: + static int error_; + static pthread_once_t once_; + static pthread_key_t key_; + }; + + template + class tls + { + public: + tls (); + + T* + get () const; + + void + set (T* p); + + private: + tls (const tls&); + tls& operator= (const tls&); + + private: + static void + key_init (); + + private: + static int error_; + static pthread_once_t once_; + static pthread_key_t key_; + }; + + template + inline T& + tls_get (const tls& t) + { + return t.get (); + } + + template + inline void + tls_free (tls& t) + { + t.free (); + } + + template + inline T* + tls_get (const tls& t) + { + return t.get (); + } + + template + inline void + tls_set (tls& t, T1* p1) + { + T* p (p1); + t.set (p); + } + } +} + +#include +#include + +#include + +#endif // ODB_DETAILS_POSIX_TLS_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/details/posix/tls.ixx b/third-party/odb/libodb-2.4.0/odb/details/posix/tls.ixx new file mode 100755 index 0000000..87c8161 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/details/posix/tls.ixx @@ -0,0 +1,21 @@ +// file : odb/details/posix/tls.ixx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +namespace odb +{ + namespace details + { + template + inline tls:: + tls () + { + } + + template + inline tls:: + tls () + { + } + } +} diff --git a/third-party/odb/libodb-2.4.0/odb/details/posix/tls.txx b/third-party/odb/libodb-2.4.0/odb/details/posix/tls.txx new file mode 100755 index 0000000..1384761 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/details/posix/tls.txx @@ -0,0 +1,122 @@ +// file : odb/details/posix/tls.txx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include +#include + +namespace odb +{ + namespace details + { + // tls + // + + template + int tls::error_ = 0; + + template + pthread_once_t tls::once_ = PTHREAD_ONCE_INIT; + + template + pthread_key_t tls::key_; + + template + T& tls:: + get () const + { + int e (pthread_once (&once_, key_init)); + + if (e != 0 || error_ != 0) + throw posix_exception (e ? e : error_); + + if (void* v = pthread_getspecific (key_)) + return *static_cast (v); + + unique_ptr p (new T); + + if ((e = pthread_setspecific (key_, p.get ()))) + throw posix_exception (e); + + T& r (*p); + p.release (); + return r; + } + + template + void tls:: + free () + { + int e (pthread_once (&once_, key_init)); + + if (e != 0 || error_ != 0) + throw posix_exception (e ? e : error_); + + if (void* v = pthread_getspecific (key_)) + { + if ((e = pthread_setspecific (key_, 0))) + throw posix_exception (e); + + delete static_cast (v); + } + } + + template + void tls:: + key_init () + { + error_ = pthread_key_create (&key_, destructor); + } + + template + void tls:: + destructor (void* v) + { + delete static_cast (v); + } + + // tls + // + + template + int tls::error_ = 0; + + template + pthread_once_t tls::once_ = PTHREAD_ONCE_INIT; + + template + pthread_key_t tls::key_; + + template + T* tls:: + get () const + { + int e (pthread_once (&once_, key_init)); + + if (e != 0 || error_ != 0) + throw posix_exception (e ? e : error_); + + return static_cast (pthread_getspecific (key_)); + } + + template + void tls:: + set (T* p) + { + int e (pthread_once (&once_, key_init)); + + if (e != 0 || error_ != 0) + throw posix_exception (e ? e : error_); + + if ((e = pthread_setspecific (key_, p))) + throw posix_exception (e); + } + + template + void tls:: + key_init () + { + error_ = pthread_key_create (&key_, 0); + } + } +} diff --git a/third-party/odb/libodb-2.4.0/odb/details/shared-ptr-fwd.hxx b/third-party/odb/libodb-2.4.0/odb/details/shared-ptr-fwd.hxx new file mode 100755 index 0000000..9f7d197 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/details/shared-ptr-fwd.hxx @@ -0,0 +1,25 @@ +// file : odb/details/shared-ptr-fwd.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_DETAILS_SHARED_PTR_FWD_HXX +#define ODB_DETAILS_SHARED_PTR_FWD_HXX + +#include + +#include + +namespace odb +{ + namespace details + { + template + class shared_ptr; + + class shared_base; + } +} + +#include + +#endif // ODB_DETAILS_SHARED_PTR_FWD_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/details/shared-ptr.hxx b/third-party/odb/libodb-2.4.0/odb/details/shared-ptr.hxx new file mode 100755 index 0000000..2bb8efc --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/details/shared-ptr.hxx @@ -0,0 +1,167 @@ +// file : odb/details/shared-ptr.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_DETAILS_SHARED_PTR_HXX +#define ODB_DETAILS_SHARED_PTR_HXX + +#include + +#include +#include +#include + +namespace odb +{ + namespace details + { + template + class shared_ptr: bits::counter_ops::r, X> + { + typedef bits::counter_ops::r, X> base; + + public: + ~shared_ptr () + { + if (x_ != 0) + base::dec (x_); + } + + explicit + shared_ptr (X* x = 0) + : base (x), x_ (x) + { + } + + shared_ptr (const shared_ptr& x) + : base (x), x_ (x.x_) + { + if (x_ != 0) + base::inc (x_); + } + + template + shared_ptr (const shared_ptr& x) + : base (x), x_ (x.x_) + { + if (x_ != 0) + base::inc (x_); + } + + shared_ptr& + operator= (const shared_ptr& x) + { + if (x_ != x.x_) + { + if (x_ != 0) + base::dec (x_); + + static_cast (*this) = x; + x_ = x.x_; + + if (x_ != 0) + base::inc (x_); + } + + return *this; + } + + template + shared_ptr& + operator= (const shared_ptr& x) + { + if (x_ != x.x_) + { + if (x_ != 0) + base::dec (x_); + + static_cast (*this) = x; + x_ = x.x_; + + if (x_ != 0) + base::inc (x_); + } + + return *this; + } + + public: + X* + operator-> () const + { + return x_; + } + + X& + operator* () const + { + return *x_; + } + + // Conversion to bool. + // + typedef void (shared_ptr::*boolean_convertible)(); + void true_value () {} + + operator boolean_convertible () const + { + return x_ ? &shared_ptr::true_value : 0; + } + + public: + X* + get () const + { + return x_; + } + + X* + release () + { + X* r (x_); + x_ = 0; + return r; + } + + void + reset (X* x = 0) + { + if (x_ != 0) + base::dec (x_); + + base::reset (x); + x_ = x; + } + + std::size_t + count () const + { + return x_ != 0 ? base::count (x_) : 0; + } + + private: + template + friend class shared_ptr; + + X* x_; + }; + + template + inline bool + operator== (const shared_ptr& x, const shared_ptr& y) + { + return x.get () == y.get (); + } + + template + inline bool + operator!= (const shared_ptr& x, const shared_ptr& y) + { + return x.get () != y.get (); + } + } +} + +#include + +#endif // ODB_DETAILS_SHARED_PTR_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/details/shared-ptr/base.cxx b/third-party/odb/libodb-2.4.0/odb/details/shared-ptr/base.cxx new file mode 100755 index 0000000..b95797b --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/details/shared-ptr/base.cxx @@ -0,0 +1,91 @@ +// file : odb/details/shared-ptr/base.cxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include +#include + +using std::size_t; + +namespace odb +{ + namespace details + { + share shared = share (1); + share exclusive = share (2); + + const char* not_shared:: + what () const throw () + { + return "object is not shared"; + } + + not_shared* not_shared:: + clone () const + { + return new not_shared (*this); + } + + bool shared_base:: + _dec_ref_callback () + { + bool r (--counter_ == 0); + + if (r) + r = callback_->zero_counter (callback_->arg); + + return r; + } + + namespace bits + { + size_t* locator_common:: + counter (void* x) + { + size_t* p (static_cast (x)); + + if (*(--p) != 0xDEADBEEF) + throw not_shared (); + + return --p; + } + } + } +} + +void* +operator new (size_t n, odb::details::share s) throw (std::bad_alloc) +{ + if (s == odb::details::shared) + { + // Here we need to make sure we don't break the alignment of the + // returned block. For that we need to know the maximum alignment + // of this platform. Twice the pointer size is a good guess for + // most platforms. + // + size_t* p = static_cast (operator new (n + 2 * sizeof (size_t))); + *p++ = 1; // Initial count. + *p++ = 0xDEADBEEF; // Signature. + return p; + } + else + return operator new (n); + +} + +void +operator delete (void* p, odb::details::share s) throw () +{ + // This version of operator delete is only called when the c-tor + // fails. In this case there is no object and we can just free the + // memory. + // + if (s == odb::details::shared) + { + size_t* sp = static_cast (p); + sp -= 2; + operator delete (sp); + } + else + operator delete (p); +} diff --git a/third-party/odb/libodb-2.4.0/odb/details/shared-ptr/base.hxx b/third-party/odb/libodb-2.4.0/odb/details/shared-ptr/base.hxx new file mode 100755 index 0000000..4a38945 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/details/shared-ptr/base.hxx @@ -0,0 +1,113 @@ +// file : odb/details/shared-ptr/base.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_DETAILS_SHARED_PTR_BASE_HXX +#define ODB_DETAILS_SHARED_PTR_BASE_HXX + +#include + +#include +#include // std::size_t + +#include +#include + +namespace odb +{ + namespace details + { + struct LIBODB_EXPORT share + { + explicit + share (char id); + + bool + operator== (share) const; + + private: + char id_; + }; + + extern LIBODB_EXPORT share shared; + extern LIBODB_EXPORT share exclusive; + } +} + +LIBODB_EXPORT void* +operator new (std::size_t, odb::details::share) throw (std::bad_alloc); + +LIBODB_EXPORT void +operator delete (void*, odb::details::share) throw (); + +namespace odb +{ + namespace details + { + class LIBODB_EXPORT shared_base + { + public: + shared_base (); + shared_base (const shared_base&); + shared_base& + operator= (const shared_base&); + + void + _inc_ref (); + + bool + _dec_ref (); + + std::size_t + _ref_count () const; + + void* + operator new (std::size_t) throw (std::bad_alloc); + + void* + operator new (std::size_t, share) throw (std::bad_alloc); + + void + operator delete (void*, share) throw (); + + void + operator delete (void*) throw (); + + struct refcount_callback + { + void* arg; + + // Return true if the object should be deleted, false otherwise. + // + bool (*zero_counter) (void*); + }; + + private: + bool + _dec_ref_callback (); + + protected: + std::size_t counter_; + refcount_callback* callback_; + }; + + template + inline X* + inc_ref (X*); + + template + inline void + dec_ref (X*); + + template + inline std::size_t + ref_count (const X*); + } +} + +#include +#include + +#include + +#endif // ODB_DETAILS_SHARED_PTR_BASE_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/details/shared-ptr/base.ixx b/third-party/odb/libodb-2.4.0/odb/details/shared-ptr/base.ixx new file mode 100755 index 0000000..9bf7c94 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/details/shared-ptr/base.ixx @@ -0,0 +1,90 @@ +// file : odb/details/shared-ptr/base.ixx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +namespace odb +{ + namespace details + { + // share + // + + inline share:: + share (char id) + : id_ (id) + { + } + + inline bool share:: + operator== (share x) const + { + return id_ == x.id_; + } + + // shared_base + // + + inline shared_base:: + shared_base () + : counter_ (1), callback_ (0) + { + } + + inline shared_base:: + shared_base (const shared_base&) + : counter_ (1), callback_ (0) + { + } + + inline shared_base& shared_base:: + operator= (const shared_base&) + { + return *this; + } + + inline void shared_base:: + _inc_ref () + { + counter_++; + } + + inline bool shared_base:: + _dec_ref () + { + if (callback_ == 0) + return --counter_ == 0; + else + return _dec_ref_callback (); + } + + inline std::size_t shared_base:: + _ref_count () const + { + return counter_; + } + + inline void* shared_base:: + operator new (std::size_t n) throw (std::bad_alloc) + { + return ::operator new (n); + } + + inline void* shared_base:: + operator new (std::size_t n, share) throw (std::bad_alloc) + { + return ::operator new (n); + } + + inline void shared_base:: + operator delete (void* p, share) throw () + { + ::operator delete (p); + } + + inline void shared_base:: + operator delete (void* p) throw () + { + ::operator delete (p); + } + } +} diff --git a/third-party/odb/libodb-2.4.0/odb/details/shared-ptr/base.txx b/third-party/odb/libodb-2.4.0/odb/details/shared-ptr/base.txx new file mode 100755 index 0000000..d018c88 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/details/shared-ptr/base.txx @@ -0,0 +1,199 @@ +// file : odb/details/shared-ptr/base.txx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include +#include + +namespace odb +{ + namespace details + { + namespace bits + { + // Support for locating the counter in the memory block. + // + struct LIBODB_EXPORT locator_common + { + static std::size_t* + counter (void*); + }; + + template ::result> + struct locator; + + template + struct locator: locator_common + { + static std::size_t* + counter (X* x) + { + return locator_common::counter (x); + } + }; + + template + struct locator: locator_common + { + static std::size_t* + counter (X* x) + { + return locator_common::counter (dynamic_cast (x)); + } + }; + + template + std::size_t* + counter (const X* p) + { + return bits::locator::counter (const_cast (p)); + } + + // Counter type and operations. + // + meta::no test (...); + meta::yes test (shared_base*); + + template (0)))> + struct counter_type; + + template + struct counter_type + { + typedef typename details::counter_type::counter r; + }; + + template + struct counter_type + { + typedef shared_base r; + }; + + template + struct counter_ops; + + template + struct counter_ops + { + counter_ops (const X* p) : counter_ (p ? bits::counter (p) : 0) {} + counter_ops (const counter_ops& x) : counter_ (x.counter_) {} + + template + counter_ops (const counter_ops& x) : counter_ (x.counter_) {} + + counter_ops& + operator= (const counter_ops& x) + { + counter_ = x.counter_; + return *this; + } + + template + counter_ops& + operator= (const counter_ops& x) + { + counter_ = x.counter_; + return *this; + } + + void + reset (const X* p) + { + counter_ = p ? bits::counter (p) : 0; + } + + void + inc (X*) + { + (*counter_)++; + } + + void + dec (X* p) + { + if (--(*counter_) == 0) + { + p->~X (); + + // Counter is the top of the memory block. + // + operator delete (counter_); + } + } + + std::size_t + count (const X*) const + { + return *counter_; + } + + std::size_t* counter_; + }; + + template + struct counter_ops + { + counter_ops (const Y*) {} + counter_ops (const counter_ops&) {} + + template + counter_ops (const counter_ops&) {} + + counter_ops& + operator= (const counter_ops&) + { + return *this; + } + + template + counter_ops& + operator= (const counter_ops&) + { + return *this; + } + + void + reset (const Y*) {} + + void + inc (shared_base* p) {p->_inc_ref ();} + + void + dec (Y* p) + { + if (static_cast (p)->_dec_ref ()) + delete p; + } + + std::size_t + count (const shared_base* p) const {return p->_ref_count ();} + }; + } + + template + inline X* + inc_ref (X* p) + { + bits::counter_ops::r, X> c (p); + c.inc (p); + return p; + } + + template + inline void + dec_ref (X* p) + { + bits::counter_ops::r, X> c (p); + c.dec (p); + } + + template + inline std::size_t + ref_count (const X* p) + { + bits::counter_ops::r, X> c (p); + return c.count (p); + } + } +} diff --git a/third-party/odb/libodb-2.4.0/odb/details/shared-ptr/counter-type.hxx b/third-party/odb/libodb-2.4.0/odb/details/shared-ptr/counter-type.hxx new file mode 100755 index 0000000..41b85a2 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/details/shared-ptr/counter-type.hxx @@ -0,0 +1,24 @@ +// file : odb/details/shared-ptr/counter-type.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_DETAILS_SHARED_PTR_COUNTER_TYPE_HXX +#define ODB_DETAILS_SHARED_PTR_COUNTER_TYPE_HXX + +#include + +namespace odb +{ + namespace details + { + template + struct counter_type + { + typedef X counter; + }; + } +} + +#include + +#endif // ODB_DETAILS_SHARED_PTR_COUNTER_TYPE_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/details/shared-ptr/exception.hxx b/third-party/odb/libodb-2.4.0/odb/details/shared-ptr/exception.hxx new file mode 100755 index 0000000..99ed069 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/details/shared-ptr/exception.hxx @@ -0,0 +1,30 @@ +// file : odb/details/shared-ptr/exception.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_DETAILS_SHARED_PTR_EXCEPTION_HXX +#define ODB_DETAILS_SHARED_PTR_EXCEPTION_HXX + +#include + +#include +#include + +namespace odb +{ + namespace details + { + struct LIBODB_EXPORT not_shared: exception + { + virtual const char* + what () const throw (); + + virtual not_shared* + clone () const; + }; + } +} + +#include + +#endif // ODB_DETAILS_SHARED_PTR_EXCEPTION_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/details/thread.hxx b/third-party/odb/libodb-2.4.0/odb/details/thread.hxx new file mode 100755 index 0000000..858263d --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/details/thread.hxx @@ -0,0 +1,24 @@ +// file : odb/details/thread.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_DETAILS_THREAD_HXX +#define ODB_DETAILS_THREAD_HXX + +#include + +#include + +#ifdef ODB_THREADS_NONE +# error no thread support available +#elif defined(ODB_THREADS_POSIX) +#include +#elif defined(ODB_THREADS_WIN32) +#include +#else +# error unknown threading model +#endif + +#include + +#endif // ODB_DETAILS_THREAD_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/details/tls.hxx b/third-party/odb/libodb-2.4.0/odb/details/tls.hxx new file mode 100755 index 0000000..684823a --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/details/tls.hxx @@ -0,0 +1,122 @@ +// file : odb/details/tls.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_DETAILS_TLS_HXX +#define ODB_DETAILS_TLS_HXX + +#include + +#include + +#ifdef ODB_THREADS_NONE + +# define ODB_TLS_POINTER(type) type* +# define ODB_TLS_OBJECT(type) type + +namespace odb +{ + namespace details + { + template + inline T& + tls_get (T& x) + { + return x; + } + + // If early destructions is possible, destroy the object and free + // any allocated resources. + // + template + inline void + tls_free (T& x) + { + } + + template + inline T* + tls_get (T* p) + { + return p; + } + + template + inline void + tls_set (T*& rp, T1* p) + { + rp = p; + } + } +} + +#elif defined(ODB_THREADS_POSIX) + +# include + +# ifdef ODB_THREADS_TLS_KEYWORD +# define ODB_TLS_POINTER(type) __thread type* + +namespace odb +{ + namespace details + { + template + inline T* + tls_get (T* p) + { + return p; + } + + template + inline void + tls_set (T*& rp, T1* p) + { + rp = p; + } + } +} + +# else +# define ODB_TLS_POINTER(type) tls +# endif +# define ODB_TLS_OBJECT(type) tls + +#elif defined(ODB_THREADS_WIN32) + +# include + +# ifdef ODB_THREADS_TLS_DECLSPEC +# define ODB_TLS_POINTER(type) __declspec(thread) type* + +namespace odb +{ + namespace details + { + template + inline T* + tls_get (T* p) + { + return p; + } + + template + inline void + tls_set (T*& rp, T1* p) + { + rp = p; + } + } +} + +# else +# define ODB_TLS_POINTER(type) tls +# endif +# define ODB_TLS_OBJECT(type) tls +#else +# error unknown threading model +#endif + +#include + +#endif // ODB_DETAILS_TLS_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/details/transfer-ptr.hxx b/third-party/odb/libodb-2.4.0/odb/details/transfer-ptr.hxx new file mode 100755 index 0000000..2e40e29 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/details/transfer-ptr.hxx @@ -0,0 +1,56 @@ +// file : odb/details/transfer-ptr.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_DETAILS_TRANSFER_PTR_HXX +#define ODB_DETAILS_TRANSFER_PTR_HXX + +#include + +#include // std::auto_ptr, std::unique_ptr + +#include // ODB_CXX11 + +namespace odb +{ + namespace details + { + template + class transfer_ptr + { + public: + typedef T element_type; + + transfer_ptr (): p_ (0) {} + + template + transfer_ptr (std::auto_ptr p): p_ (p.release ()) {} + +#ifdef ODB_CXX11 +#ifdef ODB_CXX11_NULLPTR + transfer_ptr (std::nullptr_t): p_ (0) {} +#endif + + template + transfer_ptr (std::unique_ptr&& p): p_ (p.release ()) {} +#endif + + ~transfer_ptr () {delete p_;} + + T* + transfer () + { + T* r (p_); + p_ = 0; + return r; + } + + private: + T* p_; + }; + } +} + +#include + +#endif // ODB_DETAILS_TRANSFER_PTR_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/details/type-info.hxx b/third-party/odb/libodb-2.4.0/odb/details/type-info.hxx new file mode 100755 index 0000000..96d2cc8 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/details/type-info.hxx @@ -0,0 +1,39 @@ +// file : odb/details/type-info.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_DETAILS_TYPE_INFO_HXX +#define ODB_DETAILS_TYPE_INFO_HXX + +#include + +#include + +#include + +namespace odb +{ + namespace details + { + struct LIBODB_EXPORT type_info_comparator + { + bool + operator() (const std::type_info* x, const std::type_info* y) const + { + // XL C++ on AIX has buggy type_info::before() in that + // it returns true for two different type_info objects + // that happened to be for the same type. + // +#if defined(__xlC__) && defined(_AIX) + return *x != *y && x->before (*y); +#else + return x->before (*y); +#endif + } + }; + } +} + +#include + +#endif // ODB_DETAILS_TYPE_INFO_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/details/unique-ptr.hxx b/third-party/odb/libodb-2.4.0/odb/details/unique-ptr.hxx new file mode 100755 index 0000000..35f4d68 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/details/unique-ptr.hxx @@ -0,0 +1,80 @@ +// file : odb/details/unique-ptr.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_DETAILS_UNIQUE_PTR_HXX +#define ODB_DETAILS_UNIQUE_PTR_HXX + +#include + +namespace odb +{ + namespace details + { + template + class unique_ptr + { + public: + typedef T element_type; + + explicit unique_ptr (T* p = 0): p_ (p) {} + ~unique_ptr () {delete p_;} + + private: + unique_ptr (const unique_ptr&); + unique_ptr& operator= (const unique_ptr&); + + public: + T* + operator-> () const {return p_;} + + T& + operator* () const {return *p_;} + + typedef T* unique_ptr::*unspecified_bool_type; + operator unspecified_bool_type () const + { + return p_ != 0 ? &unique_ptr::p_ : 0; + } + + T* + get () const {return p_;} + + void + reset (T* p = 0) + { + delete p_; + p_ = p; + } + + T* + release () + { + T* r (p_); + p_ = 0; + return r; + } + + private: + T* p_; + }; + + template + inline bool + operator== (const unique_ptr& a, const unique_ptr& b) + { + return a.get () == b.get (); + } + + template + inline bool + operator!= (const unique_ptr& a, const unique_ptr& b) + { + return a.get () != b.get (); + } + } +} + +#include + +#endif // ODB_DETAILS_UNIQUE_PTR_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/details/unused.hxx b/third-party/odb/libodb-2.4.0/odb/details/unused.hxx new file mode 100755 index 0000000..8d3af30 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/details/unused.hxx @@ -0,0 +1,22 @@ +// file : odb/details/unused.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_UNUSED_DETAILS_HXX +#define ODB_UNUSED_DETAILS_HXX + +#include + +// VC++ doesn't like the (void)x expression if x is a reference to +// an incomplete type. On the other hand, GCC warns that (void*)&x +// doesn't have any effect. +// +#ifdef _MSC_VER +# define ODB_POTENTIALLY_UNUSED(x) (void*)&x +#else +# define ODB_POTENTIALLY_UNUSED(x) (void)x +#endif + +#include + +#endif // ODB_UNUSED_DETAILS_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/details/win32/condition.cxx b/third-party/odb/libodb-2.4.0/odb/details/win32/condition.cxx new file mode 100755 index 0000000..6e22823 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/details/win32/condition.cxx @@ -0,0 +1,55 @@ +// file : odb/details/win32/condition.cxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include +#include +#include + +namespace odb +{ + namespace details + { + void condition:: + signal () + { + mutex_.lock (); + + if (waiters_ > signals_) + { + if (signals_++ == 0) + { + if (SetEvent (event_) == 0) + throw win32_exception (); + } + } + + mutex_.unlock (); + } + + void condition:: + wait () + { + // When we enter this functions the mutex is locked. When we + // return from this function the mutex must be locked. + // + waiters_++; + mutex_.unlock (); + + if (WaitForSingleObject (event_, INFINITE) != 0) + throw win32_exception (); + + mutex_.lock (); + waiters_--; + signals_--; + + if (signals_ > 0) + { + // Wake up the next thread. + // + if (SetEvent (event_) == 0) + throw win32_exception (); + } + } + } +} diff --git a/third-party/odb/libodb-2.4.0/odb/details/win32/condition.hxx b/third-party/odb/libodb-2.4.0/odb/details/win32/condition.hxx new file mode 100755 index 0000000..56eebf6 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/details/win32/condition.hxx @@ -0,0 +1,51 @@ +// file : odb/details/win32/condition.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_DETAILS_WIN32_CONDITION_HXX +#define ODB_DETAILS_WIN32_CONDITION_HXX + +#include + +#include + +#include // std::size_t + +#include +#include + +namespace odb +{ + namespace details + { + class LIBODB_EXPORT condition + { + public: + ~condition (); + condition (mutex&); + + void + signal (); + + void + wait (); + + private: + condition (const condition&); + condition& operator= (const condition&); + + private: + mutex& mutex_; + HANDLE event_; + + std::size_t waiters_; + std::size_t signals_; + }; + } +} + +#include + +#include + +#endif // ODB_DETAILS_WIN32_CONDITION_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/details/win32/condition.ixx b/third-party/odb/libodb-2.4.0/odb/details/win32/condition.ixx new file mode 100755 index 0000000..82da22b --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/details/win32/condition.ixx @@ -0,0 +1,31 @@ +// file : odb/details/win32/condition.ixx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include + +namespace odb +{ + namespace details + { + inline condition:: + ~condition () + { + CloseHandle (event_); + } + + inline condition:: + condition (mutex& mutex) + : mutex_ (mutex), waiters_ (0), signals_ (0) + { + // Auto-reset event. Releases one waiting thread and automatically + // resets the event state. If no threads are waiting the event + // remains signalled. + // + event_ = CreateEvent (0, false, false, 0); + + if (event_ == 0) + throw win32_exception (); + } + } +} diff --git a/third-party/odb/libodb-2.4.0/odb/details/win32/dll.cxx b/third-party/odb/libodb-2.4.0/odb/details/win32/dll.cxx new file mode 100755 index 0000000..096df54 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/details/win32/dll.cxx @@ -0,0 +1,52 @@ +// file : odb/details/win32/dll.cxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +// If we are building a static library from VC++ (LIBODB_STATIC_LIB) or +// a static library from automake (!DLL_EXPORT), then omit DllMain. +// + +#if (defined(_MSC_VER) && defined(LIBODB_DYNAMIC_LIB)) || \ + (!defined(_MSC_VER) && defined(DLL_EXPORT)) + +#include +#include + +using namespace odb::details; + +extern "C" BOOL WINAPI +DllMain (HINSTANCE, DWORD reason, LPVOID reserved) +{ + switch (reason) + { + case DLL_PROCESS_ATTACH: + { + process_start (); + thread_start (); + break; + } + + case DLL_THREAD_ATTACH: + { + thread_start (); + break; + } + + case DLL_THREAD_DETACH: + { + thread_end (); + break; + } + + case DLL_PROCESS_DETACH: + { + thread_end (); + process_end (reserved == NULL); + break; + } + } + + return 1; +} + +#endif diff --git a/third-party/odb/libodb-2.4.0/odb/details/win32/exceptions.cxx b/third-party/odb/libodb-2.4.0/odb/details/win32/exceptions.cxx new file mode 100755 index 0000000..0e52348 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/details/win32/exceptions.cxx @@ -0,0 +1,23 @@ +// file : odb/details/win32/exceptions.cxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include + +namespace odb +{ + namespace details + { + const char* win32_exception:: + what () const throw () + { + return "Win32 API error"; + } + + win32_exception* win32_exception:: + clone () const + { + return new win32_exception (*this); + } + } +} diff --git a/third-party/odb/libodb-2.4.0/odb/details/win32/exceptions.hxx b/third-party/odb/libodb-2.4.0/odb/details/win32/exceptions.hxx new file mode 100755 index 0000000..7303bb7 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/details/win32/exceptions.hxx @@ -0,0 +1,40 @@ +// file : odb/details/win32/exceptions.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_DETAILS_WIN32_EXCEPTIONS_HXX +#define ODB_DETAILS_WIN32_EXCEPTIONS_HXX + +#include + +#include +#include +#include + +namespace odb +{ + namespace details + { + struct LIBODB_EXPORT win32_exception: details::exception + { + win32_exception () : code_ (GetLastError ()) {} + win32_exception (DWORD code) : code_ (code) {} + + DWORD + code () const {return code_;} + + virtual const char* + what () const throw (); + + virtual win32_exception* + clone () const; + + private: + DWORD code_; + }; + } +} + +#include + +#endif // ODB_DETAILS_WIN32_EXCEPTIONS_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/details/win32/init.cxx b/third-party/odb/libodb-2.4.0/odb/details/win32/init.cxx new file mode 100755 index 0000000..9051aa6 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/details/win32/init.cxx @@ -0,0 +1,42 @@ +// file : odb/details/win32/init.cxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include +#include +#include + +namespace odb +{ + namespace details + { + void + process_start () + { + // The order is important. + // + once_process_start (); + tls_process_start (); + } + + void + process_end (bool safe) + { + // The order is important. + // + tls_process_end (safe); + once_process_end (safe); + } + + void + thread_start () + { + } + + void + thread_end () + { + tls_thread_end (); + } + } +} diff --git a/third-party/odb/libodb-2.4.0/odb/details/win32/init.hxx b/third-party/odb/libodb-2.4.0/odb/details/win32/init.hxx new file mode 100755 index 0000000..49615d1 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/details/win32/init.hxx @@ -0,0 +1,37 @@ +// file : odb/details/win32/init.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_DETAILS_WIN32_INIT_HXX +#define ODB_DETAILS_WIN32_INIT_HXX + +#include + +namespace odb +{ + namespace details + { + void + process_start (); + + // The safe parameter indicates whether it is safe to free heap objects. + // If the process is terminated by a call to ExitProcess(), some threads + // might have been killed leaving things in inconsistent state. + // + void + process_end (bool safe = true); + + void + thread_start (); + + // This function may be called even for thread for which thread_start() + // hasn't been called. + // + void + thread_end (); + } +} + +#include + +#endif // ODB_DETAILS_WIN32_INIT_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/details/win32/lock.hxx b/third-party/odb/libodb-2.4.0/odb/details/win32/lock.hxx new file mode 100755 index 0000000..3522a89 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/details/win32/lock.hxx @@ -0,0 +1,50 @@ +// file : odb/details/win32/lock.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_DETAILS_WIN32_LOCK_HXX +#define ODB_DETAILS_WIN32_LOCK_HXX + +#include + +#include + +namespace odb +{ + namespace details + { + // Critical section lock. Not exported; for internal use only. + // + struct win32_lock + { + win32_lock (CRITICAL_SECTION& cs) + : cs_ (&cs) + { + EnterCriticalSection (cs_); + } + + ~win32_lock () + { + if (cs_ != 0) + LeaveCriticalSection (cs_); + } + + void + unlock () + { + if (cs_ != 0) + { + LeaveCriticalSection (cs_); + cs_ = 0; + } + } + + private: + CRITICAL_SECTION* cs_; + }; + } +} + +#include + +#endif // ODB_DETAILS_WIN32_LOCK_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/details/win32/mutex.hxx b/third-party/odb/libodb-2.4.0/odb/details/win32/mutex.hxx new file mode 100755 index 0000000..8b298e3 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/details/win32/mutex.hxx @@ -0,0 +1,44 @@ +// file : odb/details/win32/mutex.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_DETAILS_WIN32_MUTEX_HXX +#define ODB_DETAILS_WIN32_MUTEX_HXX + +#include + +#include +#include + +namespace odb +{ + namespace details + { + class LIBODB_EXPORT mutex + { + public: + ~mutex (); + mutex (); + + void + lock (); + + void + unlock (); + + private: + mutex (const mutex&); + mutex& operator= (const mutex&); + + private: + friend class condition; + CRITICAL_SECTION cs_; + }; + } +} + +#include + +#include + +#endif // ODB_DETAILS_WIN32_MUTEX_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/details/win32/mutex.ixx b/third-party/odb/libodb-2.4.0/odb/details/win32/mutex.ixx new file mode 100755 index 0000000..2c94bdb --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/details/win32/mutex.ixx @@ -0,0 +1,33 @@ +// file : odb/details/win32/mutex.ixx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +namespace odb +{ + namespace details + { + inline mutex:: + ~mutex () + { + DeleteCriticalSection (&cs_); + } + + inline mutex:: + mutex () + { + InitializeCriticalSection (&cs_); + } + + inline void mutex:: + lock () + { + EnterCriticalSection (&cs_); + } + + inline void mutex:: + unlock () + { + LeaveCriticalSection (&cs_); + } + } +} diff --git a/third-party/odb/libodb-2.4.0/odb/details/win32/once-init.hxx b/third-party/odb/libodb-2.4.0/odb/details/win32/once-init.hxx new file mode 100755 index 0000000..8514fc8 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/details/win32/once-init.hxx @@ -0,0 +1,24 @@ +// file : odb/details/win32/once-init.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_DETAILS_WIN32_ONCE_INIT_HXX +#define ODB_DETAILS_WIN32_ONCE_INIT_HXX + +#include + +namespace odb +{ + namespace details + { + void + once_process_start (); + + void + once_process_end (bool safe); + } +} + +#include + +#endif // ODB_DETAILS_WIN32_ONCE_INIT_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/details/win32/once.cxx b/third-party/odb/libodb-2.4.0/odb/details/win32/once.cxx new file mode 100755 index 0000000..2f0b8cd --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/details/win32/once.cxx @@ -0,0 +1,27 @@ +// file : odb/details/win32/once.cxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include +#include +#include + +namespace odb +{ + namespace details + { + CRITICAL_SECTION win32_once_cs_; + + void + once_process_start () + { + InitializeCriticalSection (&win32_once_cs_); + } + + void + once_process_end (bool) + { + DeleteCriticalSection (&win32_once_cs_); + } + } +} diff --git a/third-party/odb/libodb-2.4.0/odb/details/win32/once.hxx b/third-party/odb/libodb-2.4.0/odb/details/win32/once.hxx new file mode 100755 index 0000000..88ddf3b --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/details/win32/once.hxx @@ -0,0 +1,51 @@ +// file : odb/details/win32/once.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_DETAILS_WIN32_ONCE_HXX +#define ODB_DETAILS_WIN32_ONCE_HXX + +#include + +#include +#include + +namespace odb +{ + namespace details + { + class LIBODB_EXPORT once + { + public: + once (); + + void + call (void (*func) ()); + + private: + once (const once&); + once& operator= (const once&); + + private: + bool called_; + }; + + // Low-level, POSIX-like API that can be used safely during static + // initialization (that is, win32_once() can be called during static + // initialization) provided once_process_start() has been called. + // + typedef unsigned int win32_once_t; + const win32_once_t WIN32_ONCE_INIT = 0; + + LIBODB_EXPORT void + win32_once (win32_once_t&, void (*func) ()); + + extern LIBODB_EXPORT CRITICAL_SECTION win32_once_cs_; + } +} + +#include + +#include + +#endif // ODB_DETAILS_WIN32_ONCE_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/details/win32/once.ixx b/third-party/odb/libodb-2.4.0/odb/details/win32/once.ixx new file mode 100755 index 0000000..a67cc4a --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/details/win32/once.ixx @@ -0,0 +1,43 @@ +// file : odb/details/win32/once.ixx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include + +namespace odb +{ + namespace details + { + inline void + win32_once (win32_once_t& o, void (*func) ()) + { + win32_lock l (win32_once_cs_); + + if (o == 0) + { + o = 1; + l.unlock (); + func (); + } + } + + inline once:: + once () + : called_ (false) + { + } + + inline void once:: + call (void (*func) ()) + { + win32_lock l (win32_once_cs_); + + if (!called_) + { + called_ = true; + l.unlock (); + func (); + } + } + } +} diff --git a/third-party/odb/libodb-2.4.0/odb/details/win32/thread.cxx b/third-party/odb/libodb-2.4.0/odb/details/win32/thread.cxx new file mode 100755 index 0000000..9865d6a --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/details/win32/thread.cxx @@ -0,0 +1,89 @@ +// file : odb/details/win32/thread.cxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include +#include // _beginthreadex, _endthreadex + +#include +#include +#include + +unsigned int __stdcall +odb_thread_thunk (void* arg) +{ + odb::details::thread::thread_thunk (arg); + _endthreadex (0); + return 0; +} + +namespace odb +{ + namespace details + { + void thread:: + thread_thunk (void* arg) + { + data* d (static_cast (arg)); + d->ret = d->func (d->arg); + d->mutex.lock (); + unsigned char count = --d->count; + d->mutex.unlock (); + + if (count == 0) + delete d; + } + + thread:: + ~thread () + { + if (handle_ != 0) + { + CloseHandle (handle_); + + // Win32 mutex implementation does not throw. + // + data_->mutex.lock (); + unsigned char count = --data_->count; + data_->mutex.unlock (); + + if (count == 0) + delete data_; + } + } + + thread:: + thread (void* (*func) (void*), void* arg) + { + unique_ptr d (new data); + d->func = func; + d->arg = arg; + d->count = 2; // One for the thread and one for us. + + handle_ = (HANDLE)_beginthreadex ( + 0, 0, &odb_thread_thunk, d.get (), 0, 0); + + if (handle_ == 0) + throw win32_exception (); + + data_ = d.release (); + } + + void* thread:: + join () + { + void* r; + + if (WaitForSingleObject (handle_, INFINITE) != 0) + throw win32_exception (); + + r = data_->ret; + + CloseHandle (handle_); + delete data_; + handle_ = 0; + data_ = 0; + return r; + } + } +} diff --git a/third-party/odb/libodb-2.4.0/odb/details/win32/thread.hxx b/third-party/odb/libodb-2.4.0/odb/details/win32/thread.hxx new file mode 100755 index 0000000..cc16589 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/details/win32/thread.hxx @@ -0,0 +1,60 @@ +// file : odb/details/win32/thread.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_DETAILS_WIN32_THREAD_HXX +#define ODB_DETAILS_WIN32_THREAD_HXX + +#include + +#include +#include +#include + +namespace odb +{ + namespace details + { + class LIBODB_EXPORT thread + { + public: + ~thread (); + thread (void* (*thread_func) (void*), void* arg = 0); + + void* + join (); + + private: + thread (const thread&); + thread& operator= (const thread&); + + private: + typedef void* (*thread_func) (void*); + + struct data + { + thread_func func; + void* arg; + void* ret; + + // Thread-safe reference counter. + // + details::mutex mutex; + unsigned char count; + }; + + + public: + static void + thread_thunk (void*); + + private: + HANDLE handle_; + data* data_; + }; + } +} + +#include + +#endif // ODB_DETAILS_WIN32_THREAD_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/details/win32/tls-init.hxx b/third-party/odb/libodb-2.4.0/odb/details/win32/tls-init.hxx new file mode 100755 index 0000000..290a6d0 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/details/win32/tls-init.hxx @@ -0,0 +1,27 @@ +// file : odb/details/win32/tls-init.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_DETAILS_WIN32_TLS_INIT_HXX +#define ODB_DETAILS_WIN32_TLS_INIT_HXX + +#include + +namespace odb +{ + namespace details + { + void + tls_process_start (); + + void + tls_process_end (bool safe); + + void + tls_thread_end (); + } +} + +#include + +#endif // ODB_DETAILS_WIN32_TLS_INIT_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/details/win32/tls.cxx b/third-party/odb/libodb-2.4.0/odb/details/win32/tls.cxx new file mode 100755 index 0000000..cd08d3a --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/details/win32/tls.cxx @@ -0,0 +1,246 @@ +// file : odb/details/win32/tls.cxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include +#include // ERROR_INVALID_INDEX + +#include +#include // std::size_t + +#include +#include +#include +#include + +#ifdef _MSC_VER +# pragma warning (disable:4200) // zero-sized array in struct +#endif + +using namespace std; + +namespace odb +{ + namespace details + { + typedef void (*dtor_func) (void*); + + struct entry + { + void* value; + dtor_func dtor; + }; + + struct thread_data + { + size_t size; + size_t capacity; + entry entries[0]; + }; + + struct process_data + { + size_t size; + size_t capacity; + dtor_func dtors[0]; + }; + + static DWORD index_ = TLS_OUT_OF_INDEXES; + static CRITICAL_SECTION cs_; + static process_data* proc_data_; + + const size_t init_capacity = 4; + + void + tls_process_start () + { + index_ = TlsAlloc (); + + if (index_ == TLS_OUT_OF_INDEXES) + throw win32_exception (); + + InitializeCriticalSection (&cs_); + + process_data* pd ( + static_cast ( + operator new ( + sizeof (process_data) + sizeof (dtor_func) * init_capacity))); + + pd->size = 0; + pd->capacity = init_capacity; + memset (pd->dtors, 0, sizeof (dtor_func) * init_capacity); + + proc_data_ = pd; + } + + void + tls_process_end (bool) + { + operator delete (proc_data_); + DeleteCriticalSection (&cs_); + + if (index_ != TLS_OUT_OF_INDEXES) + { + if (!TlsFree (index_)) + throw win32_exception (); + } + } + + void + tls_thread_end () + { + if (thread_data* d = static_cast (TlsGetValue (index_))) + { + // Call destructors. Implement the pthread semantics in that the + // destructors are called until all the values become 0. + // + for (bool pass (true); pass;) + { + pass = false; + + for (size_t i (0); i < d->size; ++i) + { + if (d->entries[i].dtor != 0 && d->entries[i].value != 0) + { + pass = true; + void* tmp (d->entries[i].value); + d->entries[i].value = 0; + d->entries[i].dtor (tmp); + } + } + } + + operator delete (d); + } + } + + // + // tls_common + // + + std::size_t tls_common:: + _allocate (dtor_func dtor) + { + win32_lock l (cs_); + + size_t n (proc_data_->size); + size_t c (proc_data_->capacity); + + if (n == c) + { + c *= 2; + + // Try to do "atomic" switch-over so that proc_data_ always points + // to memory that can be freed even if this thread is killed in the + // middle. + // + process_data* pd ( + static_cast ( + operator new (sizeof (process_data) + sizeof (dtor_func) * c))); + + memcpy (pd->dtors, proc_data_->dtors, n * sizeof (dtor_func)); + memset (pd->dtors + n, 0, sizeof (dtor_func) * (c - n)); + + pd->size = n; + pd->capacity = c; + + process_data* old (proc_data_); + proc_data_ = pd; + operator delete (old); + } + + proc_data_->dtors[n] = dtor; + return proc_data_->size++; + } + + void* tls_common:: + _get (std::size_t key) + { + if (thread_data* d = static_cast (TlsGetValue (index_))) + { + if (key < d->size) + return d->entries[key].value; + } + + // Check if this key is valid. + // + win32_lock l (cs_); + + if (key < proc_data_->size) + return 0; + + throw win32_exception (ERROR_INVALID_INDEX); + } + + void tls_common:: + _set (std::size_t key, void* value) + { + thread_data* d (static_cast (TlsGetValue (index_))); + + if (d != 0 && key < d->capacity) + { + if (key >= d->size) + { + // Check if this key is valid. If so then we need to copy + // dtors for new slots. + // + win32_lock l (cs_); + + size_t n (proc_data_->size); + + if (key >= n) + throw win32_exception (ERROR_INVALID_INDEX); + + for (size_t i (d->size); i < n; ++i) + d->entries[i].dtor = proc_data_->dtors[i]; + + d->size = n; + } + + d->entries[key].value = value; + } + else + { + // Check if this key is valid. If so then we need to (re)-allocate + // our storage. + // + win32_lock l (cs_); + + size_t n (proc_data_->size); + + if (key >= n) + throw win32_exception (ERROR_INVALID_INDEX); + + size_t c (proc_data_->capacity); + + thread_data* nd ( + static_cast ( + operator new (sizeof (thread_data) + sizeof (entry) * c))); + + size_t on (d == 0 ? 0 : d->size); + + // Copy over the data. + // + if (on != 0) + memcpy (nd->entries, d->entries, sizeof (entry) * on); + + // Zero out the rest. + // + memset (nd->entries + on, 0, sizeof (entry) * (c - on)); + + // Assign destructors to new slots [on, n). + // + for (size_t i (on); i < n; ++i) + nd->entries[i].dtor = proc_data_->dtors[i]; + + nd->size = n; + nd->capacity = c; + + operator delete (d); + TlsSetValue (index_, nd); + + nd->entries[key].value = value; + } + } + } +} diff --git a/third-party/odb/libodb-2.4.0/odb/details/win32/tls.hxx b/third-party/odb/libodb-2.4.0/odb/details/win32/tls.hxx new file mode 100755 index 0000000..2e474e1 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/details/win32/tls.hxx @@ -0,0 +1,121 @@ +// file : odb/details/win32/tls.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_DETAILS_WIN32_TLS_HXX +#define ODB_DETAILS_WIN32_TLS_HXX + +#include + +#include // std::size_t + +#include +#include + +namespace odb +{ + namespace details + { + class LIBODB_EXPORT tls_common + { + public: + static std::size_t + _allocate (void (*dtor) (void*)); + + static void* + _get (std::size_t key); + + static void + _set (std::size_t key, void* value); + }; + + template + class tls: protected tls_common + { + public: + tls (); + + T& + get () const; + + void + free (); + + private: + tls (const tls&); + tls& operator= (const tls&); + + private: + static void + key_init (); + + static void + destructor (void*); + + private: + static win32_once_t once_; + static std::size_t key_; + }; + + template + class tls: protected tls_common + { + public: + tls (); + + T* + get () const; + + void + set (T* p); + + private: + tls (const tls&); + tls& operator= (const tls&); + + private: + static void + key_init (); + + private: + static win32_once_t once_; + static std::size_t key_; + }; + + template + inline T& + tls_get (const tls& t) + { + return t.get (); + } + + template + inline void + tls_free (tls& t) + { + t.free (); + } + + template + inline T* + tls_get (const tls& t) + { + return t.get (); + } + + template + inline void + tls_set (tls& t, T1* p1) + { + T* p (p1); + t.set (p); + } + } +} + +#include +#include + +#include + +#endif // ODB_DETAILS_WIN32_TLS_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/details/win32/tls.ixx b/third-party/odb/libodb-2.4.0/odb/details/win32/tls.ixx new file mode 100755 index 0000000..b38c84f --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/details/win32/tls.ixx @@ -0,0 +1,21 @@ +// file : odb/details/win32/tls.ixx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +namespace odb +{ + namespace details + { + template + inline tls:: + tls () + { + } + + template + inline tls:: + tls () + { + } + } +} diff --git a/third-party/odb/libodb-2.4.0/odb/details/win32/tls.txx b/third-party/odb/libodb-2.4.0/odb/details/win32/tls.txx new file mode 100755 index 0000000..4044c48 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/details/win32/tls.txx @@ -0,0 +1,95 @@ +// file : odb/details/win32/tls.txx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include +#include + +namespace odb +{ + namespace details + { + // tls + // + template + win32_once_t tls::once_= WIN32_ONCE_INIT; + + template + size_t tls::key_; + + template + T& tls:: + get () const + { + win32_once (once_, key_init); + + if (void* v = _get (key_)) + return *static_cast (v); + + unique_ptr p (new T); + _set (key_, p.get ()); + + T& r (*p); + p.release (); + return r; + } + + template + void tls:: + free () + { + win32_once (once_, key_init); + + if (void* v = _get (key_)) + { + _set (key_, 0); + delete static_cast (v); + } + } + + template + void tls:: + key_init () + { + key_ = _allocate (destructor); + } + + template + void tls:: + destructor (void* v) + { + delete static_cast (v); + } + + // tls + // + template + win32_once_t tls::once_ = WIN32_ONCE_INIT; + + template + size_t tls::key_; + + template + T* tls:: + get () const + { + win32_once (once_, key_init); + return static_cast (_get (key_)); + } + + template + void tls:: + set (T* p) + { + win32_once (once_, key_init); + _set (key_, p); + } + + template + void tls:: + key_init () + { + key_ = _allocate (0); + } + } +} diff --git a/third-party/odb/libodb-2.4.0/odb/details/win32/windows.hxx b/third-party/odb/libodb-2.4.0/odb/details/win32/windows.hxx new file mode 100755 index 0000000..23ff0fc --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/details/win32/windows.hxx @@ -0,0 +1,34 @@ +// file : odb/details/win32/windows.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_DETAILS_WIN32_WINDOWS_HXX +#define ODB_DETAILS_WIN32_WINDOWS_HXX + +#include + +// Try to include so that it doesn't mess other things up. +// +#ifndef WIN32_LEAN_AND_MEAN +# define WIN32_LEAN_AND_MEAN +# ifndef NOMINMAX // No min and max macros. +# define NOMINMAX +# include +# undef NOMINMAX +# else +# include +# endif +# undef WIN32_LEAN_AND_MEAN +#else +# ifndef NOMINMAX +# define NOMINMAX +# include +# undef NOMINMAX +# else +# include +# endif +#endif + +#include + +#endif // ODB_DETAILS_WIN32_WINDOWS_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/details/wrapper-p.hxx b/third-party/odb/libodb-2.4.0/odb/details/wrapper-p.hxx new file mode 100755 index 0000000..c560430 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/details/wrapper-p.hxx @@ -0,0 +1,39 @@ +// file : odb/details/wrapper-p.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_DETAILS_WRAPPER_P_HXX +#define ODB_DETAILS_WRAPPER_P_HXX + +#include + +#include + +#include + +namespace odb +{ + namespace details + { + // GCC doesn't like these to be inside wrapper_p. + // + template + meta::no + wrapper_p_test (...); + + template + meta::yes + wrapper_p_test (typename wrapper_traits::wrapped_type*); + + template + struct wrapper_p + { + static const bool r = + sizeof (wrapper_p_test (0)) == sizeof (meta::yes); + }; + } +} + +#include + +#endif // ODB_DETAILS_WRAPPER_P_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/exception.hxx b/third-party/odb/libodb-2.4.0/odb/exception.hxx new file mode 100755 index 0000000..3a0b809 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/exception.hxx @@ -0,0 +1,36 @@ +// file : odb/exception.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_EXCEPTION_HXX +#define ODB_EXCEPTION_HXX + +#include + +#include + +#include // odb::core + +#include +#include + +namespace odb +{ + struct LIBODB_EXPORT exception: std::exception, details::shared_base + { + virtual const char* + what () const throw () = 0; + + virtual exception* + clone () const = 0; + }; + + namespace common + { + using odb::exception; + } +} + +#include + +#endif // ODB_EXCEPTION_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/exceptions.cxx b/third-party/odb/libodb-2.4.0/odb/exceptions.cxx new file mode 100755 index 0000000..ebbc543 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/exceptions.cxx @@ -0,0 +1,431 @@ +// file : odb/exceptions.cxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include // std::strlen +#include +#include + +#include + +using namespace std; + +namespace odb +{ + const char* null_pointer:: + what () const throw () + { + return "NULL pointer"; + } + + null_pointer* null_pointer:: + clone () const + { + return new null_pointer (*this); + } + + const char* already_in_transaction:: + what () const throw () + { + return "transaction already in progress in this thread"; + } + + already_in_transaction* already_in_transaction:: + clone () const + { + return new already_in_transaction (*this); + } + + const char* not_in_transaction:: + what () const throw () + { + return "operation can only be performed in transaction"; + } + + not_in_transaction* not_in_transaction:: + clone () const + { + return new not_in_transaction (*this); + } + + const char* transaction_already_finalized:: + what () const throw () + { + return "transaction already committed or rolled back"; + } + + transaction_already_finalized* transaction_already_finalized:: + clone () const + { + return new transaction_already_finalized (*this); + } + + const char* already_in_session:: + what () const throw () + { + return "session already in effect in this thread"; + } + + already_in_session* already_in_session:: + clone () const + { + return new already_in_session (*this); + } + + const char* not_in_session:: + what () const throw () + { + return "session not in effect in this thread"; + } + + not_in_session* not_in_session:: + clone () const + { + return new not_in_session (*this); + } + + const char* session_required:: + what () const throw () + { + return "session required to load this object relationship"; + } + + session_required* session_required:: + clone () const + { + return new session_required (*this); + } + + const char* deadlock:: + what () const throw () + { + return "transaction aborted due to deadlock"; + } + + deadlock* deadlock:: + clone () const + { + return new deadlock (*this); + } + + const char* connection_lost:: + what () const throw () + { + return "connection to database lost"; + } + + connection_lost* connection_lost:: + clone () const + { + return new connection_lost (*this); + } + + const char* timeout:: + what () const throw () + { + return "database operation timeout"; + } + + timeout* timeout:: + clone () const + { + return new timeout (*this); + } + + const char* object_not_persistent:: + what () const throw () + { + return "object not persistent"; + } + + object_not_persistent* object_not_persistent:: + clone () const + { + return new object_not_persistent (*this); + } + + const char* object_already_persistent:: + what () const throw () + { + return "object already persistent"; + } + + object_already_persistent* object_already_persistent:: + clone () const + { + return new object_already_persistent (*this); + } + + const char* object_changed:: + what () const throw () + { + return "object changed concurrently"; + } + + object_changed* object_changed:: + clone () const + { + return new object_changed (*this); + } + + const char* result_not_cached:: + what () const throw () + { + return "query result is not cached"; + } + + result_not_cached* result_not_cached:: + clone () const + { + return new result_not_cached (*this); + } + + const char* abstract_class:: + what () const throw () + { + return "database operation on instance of abstract class"; + } + + abstract_class* abstract_class:: + clone () const + { + return new abstract_class (*this); + } + + const char* no_type_info:: + what () const throw () + { + return "no type information"; + } + + no_type_info* no_type_info:: + clone () const + { + return new no_type_info (*this); + } + + prepared_already_cached:: + prepared_already_cached (const char* name) + : name_ (name) + { + what_ = "prepared query '"; + what_ += name; + what_ += "' is already cached"; + } + + prepared_already_cached:: + ~prepared_already_cached () throw () + { + } + + const char* prepared_already_cached:: + what () const throw () + { + return what_.c_str (); + } + + prepared_already_cached* prepared_already_cached:: + clone () const + { + return new prepared_already_cached (*this); + } + + prepared_type_mismatch:: + prepared_type_mismatch (const char* name) + : name_ (name) + { + what_ = "type mismatch while looking up prepared query '"; + what_ += name; + what_ += "'"; + } + + prepared_type_mismatch:: + ~prepared_type_mismatch () throw () + { + } + + const char* prepared_type_mismatch:: + what () const throw () + { + return what_.c_str (); + } + + prepared_type_mismatch* prepared_type_mismatch:: + clone () const + { + return new prepared_type_mismatch (*this); + } + + unknown_schema:: + unknown_schema (const string& name) + : name_ (name) + { + what_ = "unknown database schema '"; + what_ += name; + what_ += "'"; + } + + unknown_schema:: + ~unknown_schema () throw () + { + } + + const char* unknown_schema:: + what () const throw () + { + return what_.c_str (); + } + + unknown_schema* unknown_schema:: + clone () const + { + return new unknown_schema (*this); + } + + unknown_schema_version:: + unknown_schema_version (schema_version v) + : version_ (v) + { + ostringstream os; + os << v; + what_ = "unknown database schema version "; + what_ += os.str (); + } + + unknown_schema_version:: + ~unknown_schema_version () throw () + { + } + + const char* unknown_schema_version:: + what () const throw () + { + return what_.c_str (); + } + + unknown_schema_version* unknown_schema_version:: + clone () const + { + return new unknown_schema_version (*this); + } + + const char* section_not_loaded:: + what () const throw () + { + return "section is not loaded"; + } + + section_not_loaded* section_not_loaded:: + clone () const + { + return new section_not_loaded (*this); + } + + const char* section_not_in_object:: + what () const throw () + { + return "section instance is not part of an object (section was copied?)"; + } + + section_not_in_object* section_not_in_object:: + clone () const + { + return new section_not_in_object (*this); + } + + // multiple_exceptions + // + multiple_exceptions:: + ~multiple_exceptions () throw () {} + + void multiple_exceptions:: + insert (size_t p, bool maybe, const odb::exception& e, bool fatal) + { + details::shared_ptr pe; + + if (common_exception_ti_ != typeid (e)) + pe.reset (e.clone ()); + else + { + if (common_exception_ == 0) + common_exception_.reset (e.clone ()); + + pe = common_exception_; + } + + set_.insert (value_type (delta_ + p, maybe, pe)); + fatal_ = fatal_ || fatal; + } + + const multiple_exceptions::value_type* multiple_exceptions:: + lookup (size_t p) const + { + p += delta_; // Called while populating multiple_exceptions. + + iterator i (set_.find (value_type (p))); + return i == set_.end () ? 0 : &*i; + } + + void multiple_exceptions:: + prepare () + { + current_ = 0; + delta_ = 0; + common_exception_.reset (); + + ostringstream os; + os << "multiple exceptions, " + << attempted_ << " element" << (attempted_ != 1 ? "s" : "") << + " attempted, " + << failed () << " failed" + << (fatal_ ? ", fatal" : "") << ":"; + + for (iterator i (begin ()); i != end ();) + { + size_t p (i->position ()); + const odb::exception& e (i->exception ()); + + os << '\n'; + + if (!i->maybe ()) + { + os << '[' << p << ']'; + ++i; + } + else + { + // In this case we will normally have a large number of maybe + // failures in a row (usually the whole batch). So let's try + // to represent them all as a single range. + // + size_t n (0); + for (++i; i != end () && i->maybe (); ++i) + { + assert (&e == &i->exception ()); // The same common exception. + n++; + } + + if (n == 0) + os << '[' << p << ']'; + else + os << '[' << p << '-' << (p + n) << "] (some)"; + } + + os << ' ' << e.what (); + } + + what_ = os.str (); + } + + const char* multiple_exceptions:: + what () const throw () + { + return what_.c_str (); + } + + multiple_exceptions* multiple_exceptions:: + clone () const + { + return new multiple_exceptions (*this); + } +} diff --git a/third-party/odb/libodb-2.4.0/odb/exceptions.hxx b/third-party/odb/libodb-2.4.0/odb/exceptions.hxx new file mode 100755 index 0000000..b836291 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/exceptions.hxx @@ -0,0 +1,523 @@ +// file : odb/exceptions.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_EXCEPTIONS_HXX +#define ODB_EXCEPTIONS_HXX + +#include + +#include +#include +#include // std::size_t +#include + +#include // schema_version, odb::core +#include + +#include +#include + +namespace odb +{ + struct LIBODB_EXPORT null_pointer: odb::exception + { + virtual const char* + what () const throw (); + + virtual null_pointer* + clone () const; + }; + + // Transaction exceptions. + // + struct LIBODB_EXPORT already_in_transaction: odb::exception + { + virtual const char* + what () const throw (); + + virtual already_in_transaction* + clone () const; + }; + + struct LIBODB_EXPORT not_in_transaction: odb::exception + { + virtual const char* + what () const throw (); + + virtual not_in_transaction* + clone () const; + }; + + struct LIBODB_EXPORT transaction_already_finalized: odb::exception + { + virtual const char* + what () const throw (); + + virtual transaction_already_finalized* + clone () const; + }; + + // Session exceptions. + // + struct LIBODB_EXPORT already_in_session: odb::exception + { + virtual const char* + what () const throw (); + + virtual already_in_session* + clone () const; + }; + + struct LIBODB_EXPORT not_in_session: odb::exception + { + virtual const char* + what () const throw (); + + virtual not_in_session* + clone () const; + }; + + struct LIBODB_EXPORT session_required: odb::exception + { + virtual const char* + what () const throw (); + + virtual session_required* + clone () const; + }; + + // Database operations exceptions. + // + struct LIBODB_EXPORT recoverable: odb::exception + { + // Abstract. + }; + + struct LIBODB_EXPORT connection_lost: recoverable + { + virtual const char* + what () const throw (); + + virtual connection_lost* + clone () const; + }; + + struct LIBODB_EXPORT timeout: recoverable + { + virtual const char* + what () const throw (); + + virtual timeout* + clone () const; + }; + + struct LIBODB_EXPORT deadlock: recoverable + { + virtual const char* + what () const throw (); + + virtual deadlock* + clone () const; + }; + + struct LIBODB_EXPORT object_not_persistent: odb::exception + { + virtual const char* + what () const throw (); + + virtual object_not_persistent* + clone () const; + }; + + struct LIBODB_EXPORT object_already_persistent: odb::exception + { + virtual const char* + what () const throw (); + + virtual object_already_persistent* + clone () const; + }; + + struct LIBODB_EXPORT object_changed: odb::exception + { + virtual const char* + what () const throw (); + + virtual object_changed* + clone () const; + }; + + struct LIBODB_EXPORT result_not_cached: odb::exception + { + virtual const char* + what () const throw (); + + virtual result_not_cached* + clone () const; + }; + + struct LIBODB_EXPORT database_exception: odb::exception + { + // Abstract. + }; + + // Polymorphism support exceptions. + // + struct LIBODB_EXPORT abstract_class: odb::exception + { + virtual const char* + what () const throw (); + + virtual abstract_class* + clone () const; + }; + + struct LIBODB_EXPORT no_type_info: odb::exception + { + virtual const char* + what () const throw (); + + virtual no_type_info* + clone () const; + }; + + // Prepared query support exceptions. + // + struct LIBODB_EXPORT prepared_already_cached: odb::exception + { + prepared_already_cached (const char* name); + ~prepared_already_cached () throw (); + + const char* + name () const + { + return name_; + } + + virtual const char* + what () const throw (); + + virtual prepared_already_cached* + clone () const; + + private: + const char* name_; + std::string what_; + }; + + struct LIBODB_EXPORT prepared_type_mismatch: odb::exception + { + prepared_type_mismatch (const char* name); + ~prepared_type_mismatch () throw (); + + const char* + name () const {return name_;} + + virtual const char* + what () const throw (); + + virtual prepared_type_mismatch* + clone () const; + + private: + const char* name_; + std::string what_; + }; + + // Schema catalog exceptions. + // + struct LIBODB_EXPORT unknown_schema: odb::exception + { + unknown_schema (const std::string& name); + ~unknown_schema () throw (); + + const std::string& + name () const {return name_;} + + virtual const char* + what () const throw (); + + virtual unknown_schema* + clone () const; + + private: + std::string name_; + std::string what_; + }; + + struct LIBODB_EXPORT unknown_schema_version: odb::exception + { + unknown_schema_version (schema_version); + ~unknown_schema_version () throw (); + + schema_version + version () const {return version_;} + + virtual const char* + what () const throw (); + + virtual unknown_schema_version* + clone () const; + + private: + schema_version version_; + std::string what_; + }; + + // Section exceptions. + // + struct LIBODB_EXPORT section_not_loaded: odb::exception + { + virtual const char* + what () const throw (); + + virtual section_not_loaded* + clone () const; + }; + + struct LIBODB_EXPORT section_not_in_object: odb::exception + { + virtual const char* + what () const throw (); + + virtual section_not_in_object* + clone () const; + }; + + // Bulk operation exceptions. + // + struct LIBODB_EXPORT multiple_exceptions: odb::exception + { + struct LIBODB_EXPORT value_type + { + std::size_t + position () const {return p_;} + + // If true, then this means that some positions in the batch have + // triggered the exception but it is not possible, due to the + // limitations of the underlying database API, to discern exactly + // which ones. As a result, all the positions in the batch are + // marked as "maybe failed". + // + bool + maybe () const {return m_;} + + const odb::exception& + exception () const {return *e_;} + + // Implementation details. + // + public: + value_type (std::size_t p, + bool maybe, + details::shared_ptr e) + : m_ (maybe), p_ (p), e_ (e) {} + + value_type (std::size_t p): p_ (p) {} // "Key" for set lookup. + + private: + bool m_; + std::size_t p_; + details::shared_ptr e_; + }; + + struct LIBODB_EXPORT comparator_type + { + bool + operator() (const value_type& x, const value_type& y) const + { + return x.position () < y.position (); + } + }; + + typedef std::set set_type; + + // Iteration. + // + public: + typedef set_type::const_iterator iterator; + typedef set_type::const_iterator const_iterator; // For pedantic types. + + iterator + begin () const {return set_.begin ();} + + iterator + end () const {return set_.end ();} + + // Lookup. + // + public: + // Return NULL if the element at this position has no exception. Note + // that the returned value is value_type* and not odb::exception* in + // order to provide access to maybe(); see value_type::maybe() for + // details. + // + const value_type* + operator[] (std::size_t p) const + { + return set_.empty () ? 0 : lookup (p); + } + + // Severity, failed and attempt counts. + // + public: + // Return the number of elements for which the operation has been + // attempted. + // + std::size_t + attempted () const {return attempted_;} + + // Return the number of positions for which the operation has failed. + // Note that this count includes the maybe failed positions. + // + std::size_t + failed () const {return set_.size ();} + + // If fatal() returns true, then (some of) the exceptions were fatal. + // In this case, even for elements that were processed but did not + // cause the exception, no attempts were made to complete the bulk + // operation and the transaction must be aborted. + // + // If fatal() returns false, then the operation on the elements that + // don't have an exception has succeeded. The application can try to + // correct the errors and re-attempt the operation on the elements + // that did cause an exception. In either case, the transaction can + // be committed. + // + bool + fatal () const {return fatal_;} + + // Normally you shouldn't need to do this explicitly but you can + // "upgrade" an exception to fatal, for example, for specific + // database error codes. + // + void + fatal (bool f) {fatal_ = fatal_ || f;} + + // odb::exception interface. + // + public: + virtual const char* + what () const throw (); + + virtual multiple_exceptions* + clone () const; + + // Direct set access. + // + public: + const set_type& + set () const {return set_;} + + // Implementation details. + // + public: + ~multiple_exceptions () throw (); + + // All instances of the common exception must be equal since we are + // going to create and share just one. + // + multiple_exceptions (const std::type_info& common_exception_ti) + : common_exception_ti_ (common_exception_ti), + fatal_ (false), + delta_ (0), + current_ (0) {} + + // Set the attempted count as (delta + n). + // + void + attempted (std::size_t n) {attempted_ = delta_ + n;} + + // Increment the position of the current batch. Also resets the + // current position in the batch. + // + void + delta (std::size_t d) {delta_ += d; current_ = 0;} + + // Current position in the batch. + // + std::size_t + current () const {return current_;} + + void + current (std::size_t c) {current_ = c;} + + void + insert (std::size_t p, + bool maybe, + const odb::exception& e, + bool fatal = false); + + void + insert (std::size_t p, const odb::exception& e, bool fatal = false) + { + insert (p, false, e, fatal); + } + + void + insert (const odb::exception& e, bool fatal = false) + { + insert (current_, e, fatal); + } + + bool + empty () const {return set_.empty ();} + + void + prepare (); + + private: + const value_type* + lookup (std::size_t p) const; + + private: + const std::type_info& common_exception_ti_; + details::shared_ptr common_exception_; + + set_type set_; + bool fatal_; + std::size_t attempted_; + std::size_t delta_; // Position of the batch. + std::size_t current_; // Position in the batch. + std::string what_; + }; + + namespace common + { + using odb::null_pointer; + + using odb::already_in_transaction; + using odb::not_in_transaction; + using odb::transaction_already_finalized; + + using odb::already_in_session; + using odb::not_in_session; + using odb::session_required; + + using odb::recoverable; + using odb::deadlock; + using odb::connection_lost; + using odb::timeout; + using odb::object_not_persistent; + using odb::object_already_persistent; + using odb::object_changed; + using odb::result_not_cached; + using odb::database_exception; + + using odb::abstract_class; + using odb::no_type_info; + + using odb::unknown_schema; + using odb::unknown_schema_version; + + using odb::section_not_loaded; + using odb::section_not_in_object; + + using odb::multiple_exceptions; + } +} + +#include + +#endif // ODB_EXCEPTIONS_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/forward.hxx b/third-party/odb/libodb-2.4.0/odb/forward.hxx new file mode 100755 index 0000000..8cb0dbf --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/forward.hxx @@ -0,0 +1,177 @@ +// file : odb/forward.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_FORWARD_HXX +#define ODB_FORWARD_HXX + +#include + +#include // std::size_t + +#include +#include + +namespace odb +{ + // Common and core namespaces. The idea is that you can use the + // using directive to get database-independent (common) names or + // all core names (core). + // + namespace common {} + + namespace core + { + using namespace common; + } + + // + // + typedef unsigned long long schema_version; + struct schema_version_migration; + + class database; + class connection; + typedef details::shared_ptr connection_ptr; + class transaction; + class statement; + class session; + class section; + + namespace common + { + using odb::schema_version; + using odb::schema_version_migration; + using odb::session; + using odb::section; + } + + namespace core + { + using odb::database; + using odb::connection; + using odb::connection_ptr; + using odb::transaction; + using odb::statement; + } + + // Tracing. + // + class tracer; // Not in core. + extern LIBODB_EXPORT tracer& stderr_tracer; + extern LIBODB_EXPORT tracer& stderr_full_tracer; + + namespace common + { + using odb::stderr_tracer; + } + + // Implementation details. + // + + // Keep real databases first since their enumerators are used as array + // indexes. + // + enum database_id + { + id_mysql, + id_sqlite, + id_pgsql, + id_oracle, + id_mssql, + id_common + }; + + // Number of real databases (i.e., excluding default) in the database_id + // enum. + // + const std::size_t database_count = id_common; + + // Traits. + // + class access + { + public: + template + class object_traits; + + template + class object_traits_impl; + + template + class object_factory; + + template + class view_traits; + + template + class view_traits_impl; + + template + class view_factory; + + template + class pointer_factory; + + template + class composite_value_traits; + + template + class container_traits; + }; + + template + struct object_traits; + + template + struct object_traits_impl; + + template + struct view_traits; + + template + struct view_traits_impl; + + // Cache traits. + // + template struct no_id_pointer_cache_traits; + template struct no_op_pointer_cache_traits; + template struct pointer_cache_traits; + template struct no_id_reference_cache_traits; + template struct no_op_reference_cache_traits; + template struct reference_cache_traits; + + // + // + class query_base; + + template + struct query_column; + + // + // + class result_impl; + class prepared_query_impl; + + // + // + struct multiple_exceptions; + + // Polymorphism support. + // + template + struct polymorphic_map; + + namespace details + { + template <> + struct counter_type + { + typedef shared_base counter; + }; + } +} + +#include + +#endif // ODB_FORWARD_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/function-table.hxx b/third-party/odb/libodb-2.4.0/odb/function-table.hxx new file mode 100755 index 0000000..d290db8 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/function-table.hxx @@ -0,0 +1,51 @@ +// file : odb/function-table.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_FUNCTION_TABLE_HXX +#define ODB_FUNCTION_TABLE_HXX + +#include + +#include + +namespace odb +{ + template + struct object_function_table_entry + { + typedef access::object_traits_impl common_traits; + + object_function_table_entry ( + const typename common_traits::function_table_type* t) + { + common_traits::function_table[DB] = t; + } + + ~object_function_table_entry () + { + common_traits::function_table[DB] = 0; + } + }; + + template + struct view_function_table_entry + { + typedef access::view_traits_impl common_traits; + + view_function_table_entry ( + const typename common_traits::function_table_type* t) + { + common_traits::function_table[DB] = t; + } + + ~view_function_table_entry () + { + common_traits::function_table[DB] = 0; + } + }; +} + +#include + +#endif // ODB_FUNCTION_TABLE_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/lazy-pointer-traits.hxx b/third-party/odb/libodb-2.4.0/odb/lazy-pointer-traits.hxx new file mode 100755 index 0000000..12e0a08 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/lazy-pointer-traits.hxx @@ -0,0 +1,140 @@ +// file : odb/lazy-pointer-traits.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_LAZY_POINTER_TRAITS_HXX +#define ODB_LAZY_POINTER_TRAITS_HXX + +#include + +#include +#include +#include // ODB_CXX11 + +namespace odb +{ + template + class pointer_traits< lazy_ptr > + { + public: + static const pointer_kind kind = pk_raw; + static const bool lazy = true; + + typedef T element_type; + typedef lazy_ptr pointer_type; + typedef element_type* eager_pointer_type; + + static bool + null_ptr (const pointer_type& p) + { + return !p; + } + + template + static typename object_traits::id_type + object_id (const pointer_type& p) + { + return p.template object_id (); + } + }; + + template + class pointer_traits< lazy_auto_ptr > + { + public: + static const pointer_kind kind = pk_unique; + static const bool lazy = true; + + typedef T element_type; + typedef lazy_auto_ptr pointer_type; + typedef std::auto_ptr eager_pointer_type; + + static bool + null_ptr (const pointer_type& p) + { + return !p; + } + + template + static typename object_traits::id_type + object_id (const pointer_type& p) + { + return p.template object_id (); + } + }; + +#ifdef ODB_CXX11 + template + class pointer_traits> + { + public: + static const pointer_kind kind = pk_unique; + static const bool lazy = true; + + typedef T element_type; + typedef lazy_unique_ptr pointer_type; + typedef std::unique_ptr eager_pointer_type; + + static bool + null_ptr (const pointer_type& p) + { + return !p; + } + + template + static typename object_traits::id_type + object_id (const pointer_type& p) + { + return p.template object_id (); + } + }; + + template + class pointer_traits> + { + public: + static const pointer_kind kind = pk_shared; + static const bool lazy = true; + + typedef T element_type; + typedef lazy_shared_ptr pointer_type; + typedef std::shared_ptr eager_pointer_type; + + static bool + null_ptr (const pointer_type& p) + { + return !p; + } + + template + static typename object_traits::id_type + object_id (const pointer_type& p) + { + return p.template object_id (); + } + }; + + template + class pointer_traits> + { + public: + static const pointer_kind kind = pk_weak; + static const bool lazy = true; + + typedef T element_type; + typedef lazy_weak_ptr pointer_type; + typedef lazy_shared_ptr strong_pointer_type; + typedef std::weak_ptr eager_pointer_type; + + static strong_pointer_type + lock (const pointer_type& p) + { + return p.lock (); + } + }; +#endif // ODB_CXX11 +} + +#include + +#endif // ODB_LAZY_POINTER_TRAITS_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/lazy-ptr-impl.cxx b/third-party/odb/libodb-2.4.0/odb/lazy-ptr-impl.cxx new file mode 100755 index 0000000..7d7a3a0 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/lazy-ptr-impl.cxx @@ -0,0 +1,11 @@ +// file : odb/lazy-ptr-impl.cxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include + +namespace odb +{ + // This otherwise unnecessary file is here to allow instantiation + // of inline functions for exporting. +} diff --git a/third-party/odb/libodb-2.4.0/odb/lazy-ptr-impl.hxx b/third-party/odb/libodb-2.4.0/odb/lazy-ptr-impl.hxx new file mode 100755 index 0000000..6f03eff --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/lazy-ptr-impl.hxx @@ -0,0 +1,190 @@ +// file : odb/lazy-ptr-impl.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_LAZY_PTR_IMPL_HXX +#define ODB_LAZY_PTR_IMPL_HXX + +#include + +#include // std::move + +#include // odb::database +#include + +#include // ODB_CXX11 +#include + +namespace odb +{ + struct LIBODB_EXPORT lazy_ptr_impl_ref + { + void* id_; + database* db_; + void* loader_; + void (*free_) (void*); + void* (*copy_) (const void*); + }; + + class LIBODB_EXPORT lazy_ptr_base + { + public: + typedef odb::database database_type; + + ~lazy_ptr_base (); + lazy_ptr_base (); + lazy_ptr_base (const lazy_ptr_base&); + lazy_ptr_base (const lazy_ptr_impl_ref&); + + lazy_ptr_base& + operator= (const lazy_ptr_base&); + + lazy_ptr_base& + operator= (const lazy_ptr_impl_ref&); + + // C++11 support. + // + public: +#ifdef ODB_CXX11 + lazy_ptr_base (lazy_ptr_base&&); + + lazy_ptr_base& + operator= (lazy_ptr_base&&); +#endif + + public: + // Reset both the id and database. + // + void + reset (); + + // Reset the id. + // + void + reset_id (); + + void + swap (lazy_ptr_base&); + + database_type* + database () const; + + typedef void* lazy_ptr_base::*unspecified_bool_type; + operator unspecified_bool_type () const + { + return db_ != 0 ? &lazy_ptr_base::id_ : 0; + } + + operator lazy_ptr_impl_ref (); + + protected: + typedef void (*free_func) (void*); + typedef void* (*copy_func) (const void*); + + // Makes a copy of id. + // + void + reset_ (database_type*, + void* loader, + const void* id, + free_func, copy_func); + + template + static void + free (void*); + + template + static void* + copy (const void*); + + template + static typename object_traits::pointer_type + loader (database_type&, const typename object_traits::id_type&); + + protected: + void* id_; + database_type* db_; + void* loader_; + + private: + free_func free_; + copy_func copy_; + }; + + template + class lazy_ptr_impl: public lazy_ptr_base + { + public: + lazy_ptr_impl (); + + template + lazy_ptr_impl (DB&, const ID&); + + lazy_ptr_impl (const lazy_ptr_impl&); + + template + lazy_ptr_impl (const lazy_ptr_impl&); + + lazy_ptr_impl (const lazy_ptr_impl_ref&); + + lazy_ptr_impl& + operator= (const lazy_ptr_impl&); + + template + lazy_ptr_impl& + operator= (const lazy_ptr_impl&); + + lazy_ptr_impl& + operator= (const lazy_ptr_impl_ref&); + + // C++11 support. + // + public: +#ifdef ODB_CXX11 + lazy_ptr_impl (lazy_ptr_impl&&); + + template + lazy_ptr_impl (lazy_ptr_impl&&); + + lazy_ptr_impl& + operator= (lazy_ptr_impl&&); + + template + lazy_ptr_impl& + operator= (lazy_ptr_impl&&); +#endif + + public: + using lazy_ptr_base::reset; + using lazy_ptr_base::reset_id; + + template + void + reset (DB&, const ID&); + + // Reset the id and set the database to the new value. + // + template + void + reset_db (DB&); + + template + void + reset_id (const ID&); + + template + typename object_traits::pointer_type + load (bool reset_id); + + template + typename object_traits::id_type + object_id () const; + }; +} + +#include +#include + +#include + +#endif // ODB_LAZY_PTR_IMPL_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/lazy-ptr-impl.ixx b/third-party/odb/libodb-2.4.0/odb/lazy-ptr-impl.ixx new file mode 100755 index 0000000..769281b --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/lazy-ptr-impl.ixx @@ -0,0 +1,398 @@ +// file : odb/lazy-ptr-impl.ixx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +namespace odb +{ + // + // lazy_ptr_base + // + + inline lazy_ptr_base:: + lazy_ptr_base () + : id_ (0), db_ (0), loader_ (0) + { + } + + inline lazy_ptr_base:: + lazy_ptr_base (const lazy_ptr_base& r) + : id_ (0), db_ (r.db_), loader_ (r.loader_), + free_ (r.free_), copy_ (r.copy_) + { + if (r.id_) + id_ = copy_ (r.id_); + } + + inline lazy_ptr_base:: + lazy_ptr_base (const lazy_ptr_impl_ref& r) + : id_ (r.id_), db_ (r.db_), loader_ (r.loader_), + free_ (r.free_), copy_ (r.copy_) + { + } + +#ifdef ODB_CXX11 + inline lazy_ptr_base:: + lazy_ptr_base (lazy_ptr_base&& r) + : id_ (r.id_), db_ (r.db_), loader_ (r.loader_), + free_ (r.free_), copy_ (r.copy_) + { + r.id_ = 0; + } +#endif + + inline void lazy_ptr_base:: + reset_id () + { + if (id_) + free_ (id_); + + id_ = 0; + } + + inline void lazy_ptr_base:: + reset_ (database_type* db, + void* loader, + const void* id, + free_func free, + copy_func copy) + { + void* idc (id ? copy (id) : 0); + + if (id_) + free_ (id_); + + free_ = free; + copy_ = copy; + + id_ = idc; + db_ = db; + loader_ = loader; + } + + inline void lazy_ptr_base:: + reset () + { + reset_id (); + db_ = 0; + loader_ = 0; + } + +#ifdef ODB_CXX11 + inline lazy_ptr_base& lazy_ptr_base:: + operator= (lazy_ptr_base&& r) + { + if (id_ != r.id_) + { + reset_id (); + id_ = r.id_; + db_ = r.db_; + loader_ = r.loader_; + free_ = r.free_; + copy_ = r.copy_; + + r.id_ = 0; + } + + return *this; + } +#endif + + inline lazy_ptr_base& lazy_ptr_base:: + operator= (const lazy_ptr_base& r) + { + if (id_ != r.id_) + reset_ (r.db_, r.loader_, r.id_, r.free_, r.copy_); + else + { + db_ = r.db_; + loader_ = r.loader_; + } + + return *this; + } + + inline lazy_ptr_base& lazy_ptr_base:: + operator= (const lazy_ptr_impl_ref& r) + { + if (id_ != r.id_) + { + reset_id (); + id_ = r.id_; + free_ = r.free_; + copy_ = r.copy_; + } + + db_ = r.db_; + loader_ = r.loader_; + return *this; + } + + inline lazy_ptr_base:: + ~lazy_ptr_base () + { + if (id_) + free_ (id_); + } + + inline void lazy_ptr_base:: + swap (lazy_ptr_base& r) + { + void* id (id_); + database_type* db (db_); + void* l (loader_); + free_func f (free_); + copy_func c (copy_); + + id_ = r.id_; + db_ = r.db_; + loader_ = r.loader_; + free_ = r.free_; + copy_ = r.copy_; + + r.id_ = id; + r.db_ = db; + r.loader_ = l; + r.free_ = f; + r.copy_ = c; + } + + inline lazy_ptr_base::database_type* lazy_ptr_base:: + database () const + { + return db_; + } + + inline lazy_ptr_base:: + operator lazy_ptr_impl_ref () + { + lazy_ptr_impl_ref r; + r.id_ = id_; + r.db_ = db_; + r.loader_ = loader_; + r.free_ = free_; + r.copy_ = copy_; + id_ = 0; + db_ = 0; + loader_ = 0; + return r; + } + + // + // lazy_ptr_impl + // + + template + inline lazy_ptr_impl:: + lazy_ptr_impl () + { + } + + template + template + inline lazy_ptr_impl:: + lazy_ptr_impl (DB& db, const ID& id) + { + typedef typename object_traits::id_type id_type; + typedef typename object_traits::pointer_type pointer_type; + typedef pointer_type (*loader_type) (database_type&, const id_type&); + + // Make sure that ID and T's object id types are the same + // (or implicit-convertible). If you get a compile error + // pointing here, then you most likely used a wrong object + // id argument in the constructor call. + // + const id_type& r (id); + + // Compiler error pointing here? Perhaps db is not an + // odb::::database instance? + // + database_type& bdb (db); + + // For some reason GCC needs this statically-typed pointer in + // order to instantiate the functions. + // + loader_type ldr (&loader); + + reset_ (&bdb, + reinterpret_cast (ldr), + &r, + &free, + ©); + } + + template + inline lazy_ptr_impl:: + lazy_ptr_impl (const lazy_ptr_impl& r) + : lazy_ptr_base (r) + { + } + + template + template + inline lazy_ptr_impl:: + lazy_ptr_impl (const lazy_ptr_impl& r) + : lazy_ptr_base (r) + { + } + + template + inline lazy_ptr_impl:: + lazy_ptr_impl (const lazy_ptr_impl_ref& r) + : lazy_ptr_base (r) + { + } + + template + inline lazy_ptr_impl& lazy_ptr_impl:: + operator= (const lazy_ptr_impl& r) + { + lazy_ptr_base& b (*this); + b = r; + return *this; + } + + template + template + inline lazy_ptr_impl& lazy_ptr_impl:: + operator= (const lazy_ptr_impl& r) + { + lazy_ptr_base& b (*this); + b = r; + return *this; + } + + template + inline lazy_ptr_impl& lazy_ptr_impl:: + operator= (const lazy_ptr_impl_ref& r) + { + lazy_ptr_base& b (*this); + b = r; + return *this; + } + +#ifdef ODB_CXX11 + template + inline lazy_ptr_impl:: + lazy_ptr_impl (lazy_ptr_impl&& r) + : lazy_ptr_base (std::move (r)) + { + } + + template + template + inline lazy_ptr_impl:: + lazy_ptr_impl (lazy_ptr_impl&& r) + : lazy_ptr_base (std::move (r)) + { + } + + template + inline lazy_ptr_impl& lazy_ptr_impl:: + operator= (lazy_ptr_impl&& r) + { + lazy_ptr_base& b (*this); + b = std::move (r); + return *this; + } + + template + template + inline lazy_ptr_impl& lazy_ptr_impl:: + operator= (lazy_ptr_impl&& r) + { + lazy_ptr_base& b (*this); + b = std::move (r); + return *this; + } +#endif + + template + template + inline void lazy_ptr_impl:: + reset (DB& db, const ID& id) + { + typedef typename object_traits::id_type id_type; + typedef typename object_traits::pointer_type pointer_type; + typedef pointer_type (*loader_type) (database_type&, const id_type&); + + // Make sure that ID and T's object id types are the same + // (or implicit-convertible). If you get a compile error + // pointing here, then you most likely used a wrong object + // id argument in the constructor call. + // + const id_type& r (id); + + // Compiler error pointing here? Perhaps db is not an + // odb::::database instance? + // + database_type& bdb (db); + + // For some reason GCC needs this statically-typed pointer in + // order to instantiate the functions. + // + loader_type ldr (&loader); + + reset_ (&bdb, + reinterpret_cast (ldr), + &r, + &free, + ©); + } + + template + template + inline void lazy_ptr_impl:: + reset_db (DB& db) + { + typedef typename object_traits::id_type id_type; + typedef typename object_traits::pointer_type pointer_type; + typedef pointer_type (*loader_type) (database_type&, const id_type&); + + reset_id (); + + // Compiler error pointing here? Perhaps db is not an + // odb::::database instance? + // + db_ = &db; + + // For some reason GCC needs this statically-typed pointer in + // order to instantiate the functions. + // + loader_type ldr (&loader); + loader_ = reinterpret_cast (ldr); + } + + template + template + inline void lazy_ptr_impl:: + reset_id (const ID& id) + { + typedef typename object_traits::id_type id_type; + + // Make sure that ID and T's object id types are the same + // (or implicit-convertible). If you get a compile error + // pointing here, then you most likely used a wrong object + // id argument in the constructor call. + // + const id_type& r (id); + + reset_ (db_, loader_, &r, &free, ©); + } + + template + template + inline typename object_traits::id_type lazy_ptr_impl:: + object_id () const + { + typedef typename object_traits::id_type id_type; + const id_type& id (*static_cast (id_)); + + // Make sure that O' and T's object id types are the same + // (or implicit-convertible). If you get a compile error + // pointing here, then you most likely used a wrong type + // as a template argument in the object_id() call. + // + const typename object_traits::id_type& r (id); + return r; + } +} diff --git a/third-party/odb/libodb-2.4.0/odb/lazy-ptr-impl.txx b/third-party/odb/libodb-2.4.0/odb/lazy-ptr-impl.txx new file mode 100755 index 0000000..9163c33 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/lazy-ptr-impl.txx @@ -0,0 +1,59 @@ +// file : odb/lazy-ptr-impl.txx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include + +namespace odb +{ + // + // lazy_ptr_base + // + + template + void lazy_ptr_base:: + free (void* p) + { + delete static_cast (p); + } + + template + void* lazy_ptr_base:: + copy (const void* p) + { + return new T (*static_cast (p)); + } + + template + typename object_traits::pointer_type lazy_ptr_base:: + loader (database_type& db, const typename object_traits::id_type& id) + { + return static_cast (db).template load (id); + } + + // + // lazy_ptr_impl + // + + template + template + inline typename object_traits::pointer_type lazy_ptr_impl:: + load (bool reset) + { + typedef typename object_traits::id_type id_type; + typedef typename object_traits::pointer_type pointer_type; + typedef pointer_type (*loader_type) (database_type&, const id_type&); + + loader_type loader (reinterpret_cast (loader_)); + const id_type& id (*static_cast (id_)); + pointer_type p (loader (*db_, id)); + + if (reset) + reset_id (); + + // If you get a compile error pointing here, then you most likely + // used a wrong type as a template argument in the load() call. + // + return p; + } +} diff --git a/third-party/odb/libodb-2.4.0/odb/lazy-ptr.hxx b/third-party/odb/libodb-2.4.0/odb/lazy-ptr.hxx new file mode 100755 index 0000000..5e099aa --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/lazy-ptr.hxx @@ -0,0 +1,675 @@ +// file : odb/lazy-ptr.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_LAZY_PTR_HXX +#define ODB_LAZY_PTR_HXX + +#include + +#include // std::auto_ptr, std::shared_ptr/weak_ptr +#include // std::move + +#include // odb::core, odb::database +#include +#include +#include // ODB_CXX11 + +namespace odb +{ + // Raw pointer lazy version. + // + template + class lazy_ptr + { + // Pointer interface. + // + public: + typedef T element_type; + + lazy_ptr (); + template lazy_ptr (Y*); + + lazy_ptr (const lazy_ptr&); + template lazy_ptr (const lazy_ptr&); + + lazy_ptr& operator= (const lazy_ptr&); + template lazy_ptr& operator= (Y*); + template lazy_ptr& operator= (const lazy_ptr&); + + void swap (lazy_ptr&); + void reset (); + template void reset (Y*); + + T& operator* () const; + T* operator-> () const; + T* get () const; + + typedef T* lazy_ptr::*unspecified_bool_type; + operator unspecified_bool_type () const + { + return (p_ || i_) ? &lazy_ptr::p_ : 0; + } + + // Lazy loading interface. + // + public: + typedef odb::database database_type; + + // NULL loaded() + // + // true true NULL pointer to transient object + // false true valid pointer to persistent object + // true false unloaded pointer to persistent object + // false false valid pointer to transient object + // + bool loaded () const; + + T* load () const; + + // Unload the pointer. For transient objects this function is + // equivalent to reset(). + // + void unload () const; + + // Get the underlying eager pointer. If this is an unloaded pointer + // to a persistent object, then the returned pointer will be NULL. + // + T* get_eager () const; + + template lazy_ptr (DB&, const ID&); + template lazy_ptr (DB&, Y*); + + template void reset (DB&, const ID&); + template void reset (DB&, Y*); + +#ifdef ODB_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGUMENT + template +#else + template +#endif + typename object_traits::id_type object_id () const; + + database_type& database () const; + + // Helpers. + // + public: + template bool equal (const lazy_ptr&) const; + + private: + template friend class lazy_ptr; + + mutable T* p_; + mutable lazy_ptr_impl i_; + }; + + // operator< and operator<< are not provided. + // + template + bool operator== (const lazy_ptr&, const lazy_ptr&); + + template + bool operator!= (const lazy_ptr&, const lazy_ptr&); + + template void swap (lazy_ptr&, lazy_ptr&); + + // std::auto_ptr lazy version. + // + template + struct lazy_auto_ptr_ref + { + explicit lazy_auto_ptr_ref (T*, const lazy_ptr_impl_ref&); + + T* p_; + lazy_ptr_impl_ref i_; + }; + + template + class lazy_auto_ptr + { + // Standard auto_ptr interface. + // + public: + typedef T element_type; + + explicit lazy_auto_ptr (T* = 0); + lazy_auto_ptr (lazy_auto_ptr&); + template lazy_auto_ptr (lazy_auto_ptr&); + + lazy_auto_ptr& operator= (lazy_auto_ptr&); + template lazy_auto_ptr& operator= (lazy_auto_ptr&); + + T& operator* () const; + T* operator-> () const; + T* get () const; + T* release (); + void reset (T* = 0); + + lazy_auto_ptr (const lazy_auto_ptr_ref&); + lazy_auto_ptr& operator= (const lazy_auto_ptr_ref&); + template operator lazy_auto_ptr_ref (); + template operator lazy_auto_ptr (); + + // Extension: conversion to bool. + // + public: + typedef std::auto_ptr lazy_auto_ptr::*unspecified_bool_type; + operator unspecified_bool_type () const + { + return (p_.get () != 0 || i_) ? &lazy_auto_ptr::p_ : 0; + } + + // Initialization/assignment from auto_ptr. + // + public: + template lazy_auto_ptr (std::auto_ptr&); + lazy_auto_ptr (std::auto_ptr_ref); + + template lazy_auto_ptr& operator= (std::auto_ptr&); + lazy_auto_ptr& operator= (std::auto_ptr_ref); + + // Lazy loading interface. + // + public: + typedef odb::database database_type; + + // NULL loaded() + // + // true true NULL pointer to transient object + // false true valid pointer to persistent object + // true false unloaded pointer to persistent object + // false false valid pointer to transient object + // + bool loaded () const; + + std::auto_ptr& load () const; + + // Unload the pointer. For transient objects this function is + // equivalent to reset(). + // + void unload () const; + + // Get the underlying eager pointer. If this is an unloaded pointer + // to a persistent object, then the returned pointer will be NULL. + // + std::auto_ptr& get_eager () const; + + template lazy_auto_ptr (DB&, const ID&); + template lazy_auto_ptr (DB&, T*); + template lazy_auto_ptr (DB&, std::auto_ptr&); + + template void reset (DB&, const ID&); + template void reset (DB&, T*); + template void reset (DB&, std::auto_ptr&); + +#ifdef ODB_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGUMENT + template +#else + template +#endif + typename object_traits::id_type object_id () const; + + database_type& database () const; + + private: + template friend class lazy_auto_ptr; + + // Note that it is possible to have a situation where p_ is NULL, + // i_.id is NULL and i_.db is not NULL. This will happen if the + // auto_ptr reference returned by load() is transferred to another + // pointer or reset. + // + mutable std::auto_ptr p_; + mutable lazy_ptr_impl i_; + }; + +#ifdef ODB_CXX11 + + // C++11 std::unique_ptr lazy version. + // + template > + class lazy_unique_ptr + { + // Standard lazy_unique_ptr interface. + // + public: + typedef T* pointer; // For now assume it is T*. + typedef T element_type; + typedef D deleter_type; + + /*constexpr*/ lazy_unique_ptr () /*noexcept*/; +#ifdef ODB_CXX11_NULLPTR + /*constexpr*/ lazy_unique_ptr (std::nullptr_t) /*noexcept*/; +#endif + explicit lazy_unique_ptr (pointer) /*noexcept*/; + + // For now assume D is non-reference. + // + lazy_unique_ptr (pointer, const deleter_type&) /*noexcept*/; + lazy_unique_ptr (pointer, deleter_type&&) /*noexcept*/; + + lazy_unique_ptr (lazy_unique_ptr&&) /*noexcept*/; + template lazy_unique_ptr (lazy_unique_ptr&&) /*noexcept*/; + template lazy_unique_ptr (std::auto_ptr&&) /*noexcept*/; + +#ifdef ODB_CXX11_NULLPTR + lazy_unique_ptr& operator= (std::nullptr_t) /*noexcept*/; +#endif + lazy_unique_ptr& operator= (lazy_unique_ptr&&) /*noexcept*/; + template lazy_unique_ptr& operator= (lazy_unique_ptr&&) /*noexcept*/; + + T& operator* () const; + pointer operator-> () const /*noexcept*/; + pointer get () const /*noexcept*/; +#ifdef ODB_CXX11_EXPLICIT_CONVERSION_OPERATOR + explicit operator bool() const /*noexcept*/; +#else + typedef std::unique_ptr lazy_unique_ptr::*unspecified_bool_type; + operator unspecified_bool_type () const + { + return (p_ || i_) ? &lazy_unique_ptr::p_ : 0; + } +#endif + + pointer release () /*noexcept*/; + void reset (pointer = pointer ()) /*noexcept*/; + void swap (lazy_unique_ptr&) /*noexcept*/; + + deleter_type& get_deleter () /*noexcept*/; + const deleter_type& get_deleter () const /*noexcept*/; + +#ifdef ODB_CXX11_DELETED_FUNCTION + lazy_unique_ptr (const lazy_unique_ptr&) = delete; + lazy_unique_ptr& operator= (const lazy_unique_ptr&) = delete; +#else + private: + lazy_unique_ptr (const lazy_unique_ptr&); + lazy_unique_ptr& operator= (const lazy_unique_ptr&); +#endif + + // Initialization/assignment from unique_ptr. + // + public: + template lazy_unique_ptr (std::unique_ptr&&) /*noexcept*/; + template lazy_unique_ptr& operator= (std::unique_ptr&&) /*noexcept*/; + + // Lazy loading interface. + // + public: + typedef odb::database database_type; + + // NULL loaded() + // + // true true NULL pointer to transient object + // false true valid pointer to persistent object + // true false unloaded pointer to persistent object + // false false valid pointer to transient object + // + bool loaded () const; + + std::unique_ptr& load () const; + + // Unload the pointer. For transient objects this function is + // equivalent to reset(). + // + void unload () const; + + // Get the underlying eager pointer. If this is an unloaded pointer + // to a persistent object, then the returned pointer will be NULL. + // + std::unique_ptr& get_eager () const; + + template lazy_unique_ptr (DB&, const ID&); + template lazy_unique_ptr (DB&, pointer); + template lazy_unique_ptr (DB&, pointer, const deleter_type&); + template lazy_unique_ptr (DB&, pointer, deleter_type&&); + template lazy_unique_ptr (DB&, std::unique_ptr&&); + template lazy_unique_ptr (DB&, std::auto_ptr&&); + + template void reset (DB&, const ID&); + template void reset (DB&, pointer); + template void reset (DB&, std::unique_ptr&&); + template void reset (DB&, std::auto_ptr&&); + +#ifdef ODB_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGUMENT + template +#else + template +#endif + typename object_traits::id_type object_id () const; + + database_type& database () const; + + // Helpers. + // + public: + template bool equal (const lazy_unique_ptr&) const; + + private: + template friend class lazy_unique_ptr; + + // Note that it is possible to have a situation where p_ is NULL, + // i_.id is NULL and i_.db is not NULL. This will happen if the + // unique_ptr reference returned by load() is transferred to + // another pointer or reset. + // + mutable std::unique_ptr p_; + mutable lazy_ptr_impl i_; + }; + + template void swap (lazy_unique_ptr&, lazy_unique_ptr&) /*noexcept*/; + + // operator< and operator<< are not provided. + // + template + bool operator== (const lazy_unique_ptr&, const lazy_unique_ptr&); + + template + bool operator!= (const lazy_unique_ptr&, const lazy_unique_ptr&); + +#ifdef ODB_CXX11_NULLPTR + template + bool operator== (const lazy_unique_ptr&, std::nullptr_t) /*noexcept*/; + + template + bool operator== (std::nullptr_t, const lazy_unique_ptr&) /*noexcept*/; + + template + bool operator!= (const lazy_unique_ptr&, std::nullptr_t) /*noexcept*/; + + template + bool operator!= (std::nullptr_t, const lazy_unique_ptr&) /*noexcept*/; +#endif + + // C++11 std::shared_ptr lazy version. + // + template + class lazy_weak_ptr; + + template + class lazy_shared_ptr + { + // The standard shared_ptr interface. + // + public: + typedef T element_type; + + /*constexpr*/ lazy_shared_ptr () /*noexcept*/; +#ifdef ODB_CXX11_NULLPTR + /*constexpr*/ lazy_shared_ptr (std::nullptr_t) /*noexcept*/; +#endif + template explicit lazy_shared_ptr (Y*); + template lazy_shared_ptr (Y*, D); + template lazy_shared_ptr (Y*, D, A); +#ifdef ODB_CXX11_NULLPTR + template lazy_shared_ptr (std::nullptr_t, D); + template lazy_shared_ptr (std::nullptr_t, D, A); +#endif + template lazy_shared_ptr (const lazy_shared_ptr&, T*) /*noexcept*/; + + lazy_shared_ptr (const lazy_shared_ptr&) /*noexcept*/; + template lazy_shared_ptr (const lazy_shared_ptr&) /*noexcept*/; + lazy_shared_ptr (lazy_shared_ptr&&) /*noexcept*/; + template lazy_shared_ptr (lazy_shared_ptr&&) /*noexcept*/; + template explicit lazy_shared_ptr (const lazy_weak_ptr&); + template explicit lazy_shared_ptr (std::auto_ptr&&); + template lazy_shared_ptr (std::unique_ptr&&); + + ~lazy_shared_ptr (); + + lazy_shared_ptr& operator= (const lazy_shared_ptr&) /*noexcept*/; + template lazy_shared_ptr& operator= (const lazy_shared_ptr&) /*noexcept*/; + lazy_shared_ptr& operator= (lazy_shared_ptr&&) /*noexcept*/; + template lazy_shared_ptr& operator= (lazy_shared_ptr&&) /*noexcept*/; + template lazy_shared_ptr& operator= (std::auto_ptr&&); + template lazy_shared_ptr& operator= (std::unique_ptr&&); + + void swap (lazy_shared_ptr&) /*noexcept*/; + void reset () /*noexcept*/; + template void reset (Y*); + template void reset (Y*, D); + template void reset (Y*, D, A); + + T* get () const /*noexcept*/; + T& operator* () const /*noexcept*/; + T* operator-> () const /*noexcept*/; + long use_count () const /*noexcept*/; + bool unique () const /*noexcept*/; +#ifdef ODB_CXX11_EXPLICIT_CONVERSION_OPERATOR + explicit operator bool () const /*noexcept*/; +#else + typedef std::shared_ptr lazy_shared_ptr::*unspecified_bool_type; + operator unspecified_bool_type () const + { + return (p_ || i_) ? &lazy_shared_ptr::p_ : 0; + } +#endif + + // owner_before () is not provded. + + // Initialization/assignment from shared_ptr and weak_ptr. + // + public: + template lazy_shared_ptr (const std::shared_ptr&); + template lazy_shared_ptr (std::shared_ptr&&); + template explicit lazy_shared_ptr (const std::weak_ptr&); + + template lazy_shared_ptr& operator= (const std::shared_ptr&); + template lazy_shared_ptr& operator= (std::shared_ptr&&); + + // Lazy loading interface. + // + public: + typedef odb::database database_type; + + // NULL loaded() + // + // true true NULL pointer to transient object + // false true valid pointer to persistent object + // true false unloaded pointer to persistent object + // false false valid pointer to transient object + // + bool loaded () const; + + std::shared_ptr load () const; + + // Unload the pointer. For transient objects this function is + // equivalent to reset(). + // + void unload () const; + + // Get the underlying eager pointer. If this is an unloaded pointer + // to a persistent object, then the returned pointer will be NULL. + // + std::shared_ptr get_eager () const; + + template lazy_shared_ptr (DB&, const ID&); + template lazy_shared_ptr (DB&, Y*); + template lazy_shared_ptr (DB&, Y*, D); + template lazy_shared_ptr (DB&, Y*, D, A); + template lazy_shared_ptr (DB&, std::auto_ptr&&); + template lazy_shared_ptr (DB&, const std::shared_ptr&); + template lazy_shared_ptr (DB&, std::shared_ptr&&); + template lazy_shared_ptr (DB&, const std::weak_ptr&); + + template void reset (DB&, const ID&); + template void reset (DB&, Y*); + template void reset (DB&, Y*, D); + template void reset (DB&, Y*, D, A); + template void reset (DB&, std::auto_ptr&&); + template void reset (DB&, const std::shared_ptr&); + template void reset (DB&, std::shared_ptr&&); + +#ifdef ODB_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGUMENT + template +#else + template +#endif + typename object_traits::id_type object_id () const; + + database_type& database () const; + + // Helpers. + // + public: + template bool equal (const lazy_shared_ptr&) const; + + private: + template friend class lazy_shared_ptr; + template friend class lazy_weak_ptr; + + mutable std::shared_ptr p_; + mutable lazy_ptr_impl i_; + }; + + template void swap (lazy_shared_ptr&, lazy_shared_ptr&) /*noexcept*/; + + template + D* get_deleter (const lazy_shared_ptr&) /*noexcept*/; + + // operator< and operator<< are not provided. + // + template + bool operator== (const lazy_shared_ptr&, const lazy_shared_ptr&) /*noexcept*/; + + template + bool operator!= (const lazy_shared_ptr&, const lazy_shared_ptr&) /*noexcept*/; + +#ifdef ODB_CXX11_NULLPTR + template + bool operator== (const lazy_shared_ptr&, std::nullptr_t) /*noexcept*/; + + template + bool operator== (std::nullptr_t, const lazy_shared_ptr&) /*noexcept*/; + + template + bool operator!= (const lazy_shared_ptr&, std::nullptr_t) /*noexcept*/; + + template + bool operator!= (std::nullptr_t, const lazy_shared_ptr&) /*noexcept*/; +#endif + + // C++11 std::weak_ptr lazy version. + // + template + class lazy_weak_ptr + { + // The standard weak_ptr interface. + // + public: + typedef T element_type; + + /*constexpr*/ lazy_weak_ptr () /*noexcept*/; + template lazy_weak_ptr (const lazy_shared_ptr&) /*noexcept*/; + lazy_weak_ptr (const lazy_weak_ptr&) /*noexcept*/; + template lazy_weak_ptr (const lazy_weak_ptr&) /*noexcept*/; + + ~lazy_weak_ptr (); + + lazy_weak_ptr& operator= (const lazy_weak_ptr&) /*noexcept*/; + template lazy_weak_ptr& operator= (const lazy_weak_ptr&) /*noexcept*/; + template lazy_weak_ptr& operator= (const lazy_shared_ptr&) /*noexcept*/; + + void swap (lazy_weak_ptr&) /*noexcept*/; + void reset () /*noexcept*/; + + long use_count () const /*noexcept*/; + bool expired () const /*noexcept*/; + + lazy_shared_ptr lock () const /*noexcept*/; + + // owner_before () is not provded. + + // Initialization/assignment from shared_ptr and weak_ptr. + // + public: + template lazy_weak_ptr (const std::weak_ptr&); + template lazy_weak_ptr (const std::shared_ptr&); + + template lazy_weak_ptr& operator= (const std::weak_ptr&); + template lazy_weak_ptr& operator= (const std::shared_ptr&); + + // Lazy loading interface. + // + public: + typedef odb::database database_type; + + // expired() loaded() + // + // true true expired pointer to transient object + // false true valid pointer to persistent object + // true false expired pointer to persistent object + // false false valid pointer to transient object + // + bool loaded () const; + + // Performs both lock and load. + // + std::shared_ptr load () const; + + // Unload the pointer. For transient objects this function is + // equivalent to reset(). + // + void unload () const; + + // Get the underlying eager pointer. If this is an unloaded pointer + // to a persistent object, then the returned pointer will be NULL. + // + std::weak_ptr get_eager () const; + + template lazy_weak_ptr (DB&, const ID&); + template lazy_weak_ptr (DB&, const std::shared_ptr&); + template lazy_weak_ptr (DB&, const std::weak_ptr&); + + template void reset (DB&, const ID&); + template void reset (DB&, const std::shared_ptr&); + template void reset (DB&, const std::weak_ptr&); + + // The object_id() function can only be called when the object is + // persistent, or: expired() XOR loaded() (can use != for XOR). + // +#ifdef ODB_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGUMENT + template +#else + template +#endif + typename object_traits::id_type object_id () const; + + database_type& database () const; + + private: + template friend class lazy_shared_ptr; + template friend class lazy_weak_ptr; + + mutable std::weak_ptr p_; + mutable lazy_ptr_impl i_; + }; + + // operator< is not provided. + // + template void swap (lazy_weak_ptr&, lazy_weak_ptr&); + +#endif // ODB_CXX11 + + namespace common + { + using odb::lazy_ptr; + using odb::lazy_auto_ptr; + +#ifdef ODB_CXX11 + using odb::lazy_unique_ptr; + using odb::lazy_shared_ptr; + using odb::lazy_weak_ptr; +#endif + } +} + +#include +#include + +#include + +#include + +#endif // ODB_LAZY_PTR_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/lazy-ptr.ixx b/third-party/odb/libodb-2.4.0/odb/lazy-ptr.ixx new file mode 100755 index 0000000..ccfcd47 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/lazy-ptr.ixx @@ -0,0 +1,1673 @@ +// file : odb/lazy-ptr.ixx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +namespace odb +{ + // + // lazy_ptr + // + + template + inline lazy_ptr:: + lazy_ptr (): p_ (0) {} + + template + template + inline lazy_ptr:: + lazy_ptr (Y* p): p_ (p) {} + + template + inline lazy_ptr:: + lazy_ptr (const lazy_ptr& r): p_ (r.p_), i_ (r.i_) {} + + template + template + inline lazy_ptr:: + lazy_ptr (const lazy_ptr& r): p_ (r.p_), i_ (r.i_) {} + + template + inline lazy_ptr& lazy_ptr:: + operator= (const lazy_ptr& r) + { + p_ = r.p_; + i_ = r.i_; + return *this; + } + + template + template + inline lazy_ptr& lazy_ptr:: + operator= (Y* r) + { + p_ = r; + i_.reset (); + return *this; + } + + template + template + inline lazy_ptr& lazy_ptr:: + operator= (const lazy_ptr& r) + { + p_ = r.p_; + i_ = r.i_; + return *this; + } + + template + inline void lazy_ptr:: + swap (lazy_ptr& b) + { + T* p (p_); + p_ = b.p_; + b.p_ = p; + i_.swap (b.i_); + } + + template + inline void lazy_ptr:: + reset () + { + p_ = 0; + i_.reset (); + } + + template + template + inline void lazy_ptr:: + reset (Y* p) + { + p_ = p; + i_.reset (); + } + + template + inline T& lazy_ptr:: + operator* () const + { + return *p_; + } + + template + inline T* lazy_ptr:: + operator-> () const + { + return p_; + } + + template + inline T* lazy_ptr:: + get () const + { + return p_; + } + + template + inline bool lazy_ptr:: + loaded () const + { + bool i (i_); + return (p_ == 0) != i; // !p_ XOR i + } + + template + inline T* lazy_ptr:: + load () const + { + if (p_ == 0 && i_) + p_ = i_.template load (true); // Reset id. + + return p_; + } + + template + inline void lazy_ptr:: + unload () const + { + typedef typename object_traits::object_type object_type; + + if (p_) + { + if (i_.database () != 0) + i_.reset_id (object_traits::id (*p_)); + + p_ = 0; + } + } + + template + inline T* lazy_ptr:: + get_eager () const + { + return p_; + } + + template + template + inline lazy_ptr:: + lazy_ptr (DB& db, const ID& id): p_ (0), i_ (db, id) {} + + template + template + inline lazy_ptr:: + lazy_ptr (DB& db, Y* r) + : p_ (r) + { + if (p_) + i_.reset_db (db); + } + + template + template + inline void lazy_ptr:: + reset (DB& db, const ID& id) + { + p_ = 0; + i_.reset (db, id); + } + + template + template + inline void lazy_ptr:: + reset (DB& db, Y* r) + { + p_ = r; + + if (p_) + i_.reset_db (db); + else + i_.reset (); + } + + template + template + inline typename object_traits::id_type lazy_ptr:: + object_id () const + { + typedef typename object_traits::object_type object_type; + + return p_ + ? object_traits::id (*p_) + : i_.template object_id (); + } + + template + inline typename lazy_ptr::database_type& lazy_ptr:: + database () const + { + return *i_.database (); + } + + template + inline bool + operator== (const lazy_ptr& a, const lazy_ptr& b) + { + return a.equal (b); + } + + template + inline bool + operator!= (const lazy_ptr& a, const lazy_ptr& b) + { + return !a.equal (b); + } + + template + inline void + swap (lazy_ptr& a, lazy_ptr& b) + { + a.swap (b); + } + + // + // lazy_auto_ptr_ref + // + + template + inline lazy_auto_ptr_ref:: + lazy_auto_ptr_ref (T* p, const lazy_ptr_impl_ref& i): p_ (p), i_ (i) {} + + // + // lazy_auto_ptr + // + + template + inline lazy_auto_ptr:: + lazy_auto_ptr (T* p): p_ (p) {} + + template + inline lazy_auto_ptr:: + lazy_auto_ptr (lazy_auto_ptr& r) + : p_ (r.p_), i_ (static_cast (r.i_)) + { + } + + template + template + inline lazy_auto_ptr:: + lazy_auto_ptr (lazy_auto_ptr& r) + : p_ (r.p_), i_ (static_cast (r.i_)) + { + } + + template + inline lazy_auto_ptr& lazy_auto_ptr:: + operator= (lazy_auto_ptr& r) + { + p_ = r.p_; + i_ = static_cast (r.i_); + return *this; + } + + template + template + inline lazy_auto_ptr& lazy_auto_ptr:: + operator= (lazy_auto_ptr& r) + { + p_ = r.p_; + i_ = static_cast (r.i_); + return *this; + } + + template + inline T& lazy_auto_ptr:: + operator* () const + { + return *p_; + } + + template + inline T* lazy_auto_ptr:: + operator-> () const + { + return p_.operator-> (); + } + + template + inline T* lazy_auto_ptr:: + get () const + { + return p_.get (); + } + + template + inline T* lazy_auto_ptr:: + release () + { + i_.reset (); + return p_.release (); + } + + template + inline void lazy_auto_ptr:: + reset (T* p) + { + i_.reset (); + p_.reset (p); + } + + template + inline lazy_auto_ptr:: + lazy_auto_ptr (const lazy_auto_ptr_ref& r): p_ (r.p_), i_ (r.i_) {} + + template + inline lazy_auto_ptr& lazy_auto_ptr:: + operator= (const lazy_auto_ptr_ref& r) + { + if (p_.get () != r.p_) + p_.reset (r.p_); + + i_ = r.i_; + return *this; + } + + template + template + inline lazy_auto_ptr:: + operator lazy_auto_ptr_ref () + { + return lazy_auto_ptr_ref (p_.release (), i_); + } + + template + template + inline lazy_auto_ptr:: + operator lazy_auto_ptr () + { + return lazy_auto_ptr (*this); + } + + template + template + inline lazy_auto_ptr:: + lazy_auto_ptr (std::auto_ptr& r): p_ (r) {} + + template + inline lazy_auto_ptr:: + lazy_auto_ptr (std::auto_ptr_ref r): p_ (r) {} + + template + template + inline lazy_auto_ptr& lazy_auto_ptr:: + operator= (std::auto_ptr& r) + { + p_ = r; + i_.reset (); + return *this; + } + + template + inline lazy_auto_ptr& lazy_auto_ptr:: + operator= (std::auto_ptr_ref r) + { + p_ = r; + i_.reset (); + return *this; + } + + template + inline bool lazy_auto_ptr:: + loaded () const + { + bool i (i_); + return (p_.get () == 0) != i; // XOR + } + + template + inline std::auto_ptr& lazy_auto_ptr:: + load () const + { + if (p_.get () == 0 && i_) + { + std::auto_ptr tmp (i_.template load (true)); // Reset id. + p_ = tmp; + } + + return p_; + } + + template + inline void lazy_auto_ptr:: + unload () const + { + typedef typename object_traits::object_type object_type; + + if (p_.get () != 0) + { + if (i_.database () != 0) + i_.reset_id (object_traits::id (*p_)); + + p_.reset (); + } + } + + template + inline std::auto_ptr& lazy_auto_ptr:: + get_eager () const + { + return p_; + } + + template + template + inline lazy_auto_ptr:: + lazy_auto_ptr (DB& db, const ID& id): i_ (db, id) {} + + template + template + inline lazy_auto_ptr:: + lazy_auto_ptr (DB& db, T* p) + : p_ (p) + { + if (p) + i_.reset_db (db); + } + + template + template + inline lazy_auto_ptr:: + lazy_auto_ptr (DB& db, std::auto_ptr& p) + : p_ (p) + { + if (p_.get () != 0) + i_.reset_db (db); + } + + template + template + inline void lazy_auto_ptr:: + reset (DB& db, const ID& id) + { + p_.reset (); + i_.reset (db, id); + } + + template + template + inline void lazy_auto_ptr:: + reset (DB& db, T* p) + { + p_.reset (p); + + if (p) + i_.reset_db (db); + else + i_.reset (); + } + + template + template + inline void lazy_auto_ptr:: + reset (DB& db, std::auto_ptr& p) + { + p_ = p; + + if (p_.get () != 0) + i_.reset_db (db); + else + i_.reset (); + } + + template + template + inline typename object_traits::id_type lazy_auto_ptr:: + object_id () const + { + typedef typename object_traits::object_type object_type; + + return p_.get () != 0 + ? object_traits::id (*p_) + : i_.template object_id (); + } + + template + inline typename lazy_auto_ptr::database_type& lazy_auto_ptr:: + database () const + { + return *i_.database (); + } + +#ifdef ODB_CXX11 + + // + // lazy_unique_ptr + // + + template + lazy_unique_ptr:: + lazy_unique_ptr () {} + +#ifdef ODB_CXX11_NULLPTR + template + lazy_unique_ptr:: + lazy_unique_ptr (std::nullptr_t) {} +#endif + + template + lazy_unique_ptr:: + lazy_unique_ptr (pointer p): p_ (p) {} + + template + lazy_unique_ptr:: + lazy_unique_ptr (pointer p, const deleter_type& d): p_ (p, d) {} + + template + lazy_unique_ptr:: + lazy_unique_ptr (pointer p, deleter_type&& d): p_ (p, std::move (d)) {} + + template + lazy_unique_ptr:: + lazy_unique_ptr (lazy_unique_ptr&& r) + : p_ (std::move (r.p_)), i_ (std::move (r.i_)) {} + + template + template + lazy_unique_ptr:: + lazy_unique_ptr (lazy_unique_ptr&& r) + : p_ (std::move (r.p_)), i_ (std::move (r.i_)) {} + + template + template + lazy_unique_ptr:: + lazy_unique_ptr (std::auto_ptr&& r): p_ (std::move (r)) {} + +#ifdef ODB_CXX11_NULLPTR + template + lazy_unique_ptr& lazy_unique_ptr:: + operator= (std::nullptr_t) + { + reset (); + return *this; + } +#endif + + template + lazy_unique_ptr& lazy_unique_ptr:: + operator= (lazy_unique_ptr&& r) + { + p_ = std::move (r.p_); + i_ = std::move (r.i_); + return *this; + } + + template + template + lazy_unique_ptr& lazy_unique_ptr:: + operator= (lazy_unique_ptr&& r) + { + p_ = std::move (r.p_); + i_ = std::move (r.i_); + return *this; + } + + template + T& lazy_unique_ptr:: + operator* () const + { + return *p_; + } + + template + typename lazy_unique_ptr::pointer lazy_unique_ptr:: + operator-> () const + { + return p_.operator-> (); + } + + template + typename lazy_unique_ptr::pointer lazy_unique_ptr:: + get () const + { + return p_.get (); + } + +#ifdef ODB_CXX11_EXPLICIT_CONVERSION_OPERATOR + template + lazy_unique_ptr:: + operator bool() const + { + return p_ || i_; + } +#endif + + template + typename lazy_unique_ptr::pointer lazy_unique_ptr:: + release () + { + i_.reset (); + return p_.release (); + } + + template + void lazy_unique_ptr:: + reset (pointer p) + { + p_.reset (p); + i_.reset (); + } + + template + void lazy_unique_ptr:: + swap (lazy_unique_ptr& b) + { + p_.swap (b.p_); + i_.swap (b.i_); + } + + template + typename lazy_unique_ptr::deleter_type& lazy_unique_ptr:: + get_deleter () + { + return p_.get_deleter (); + } + + template + const typename lazy_unique_ptr::deleter_type& lazy_unique_ptr:: + get_deleter () const + { + return p_.get_deleter (); + } + + template + template + inline lazy_unique_ptr:: + lazy_unique_ptr (std::unique_ptr&& p) + : p_ (std::move (p)) + { + } + + template + template + inline lazy_unique_ptr& lazy_unique_ptr:: + operator= (std::unique_ptr&& p) + { + p_ = std::move (p); + i_.reset (); + return *this; + } + + template + inline bool lazy_unique_ptr:: + loaded () const + { + bool i (i_); + return !p_ != i; // !p_ XOR i_ + } + + template + inline std::unique_ptr& lazy_unique_ptr:: + load () const + { + if (!p_ && i_) + p_ = std::unique_ptr (i_.template load (true)); // Reset id. + + return p_; + } + + template + inline void lazy_unique_ptr:: + unload () const + { + typedef typename object_traits::object_type object_type; + + if (p_) + { + if (i_.database () != 0) + i_.reset_id (object_traits::id (*p_)); + + p_.reset (); + } + } + + template + inline std::unique_ptr& lazy_unique_ptr:: + get_eager () const + { + return p_; + } + + template + template + inline lazy_unique_ptr:: + lazy_unique_ptr (DB& db, const ID& id): i_ (db, id) {} + + template + template + inline lazy_unique_ptr:: + lazy_unique_ptr (DB& db, T* p) + : p_ (p) + { + if (p_) + i_.reset_db (db); + } + + template + template + inline lazy_unique_ptr:: + lazy_unique_ptr (DB& db, T* p, const deleter_type& d) + : p_ (p, d) + { + if (p_) + i_.reset_db (db); + } + + template + template + inline lazy_unique_ptr:: + lazy_unique_ptr (DB& db, T* p, deleter_type&& d) + : p_ (p, std::move (d)) + { + if (p_) + i_.reset_db (db); + } + + template + template + inline lazy_unique_ptr:: + lazy_unique_ptr (DB& db, std::unique_ptr&& p) + : p_ (std::move (p)) + { + if (p_) + i_.reset_db (db); + } + + template + template + inline lazy_unique_ptr:: + lazy_unique_ptr (DB& db, std::auto_ptr&& p) + : p_ (std::move (p)) + { + if (p_) + i_.reset_db (db); + } + + template + template + inline void lazy_unique_ptr:: + reset (DB& db, const ID& id) + { + p_.reset (); + i_.reset (db, id); + } + + template + template + inline void lazy_unique_ptr:: + reset (DB& db, T* p) + { + p_.reset (p); + + if (p) + i_.reset_db (db); + else + i_.reset (); + } + + template + template + inline void lazy_unique_ptr:: + reset (DB& db, std::unique_ptr&& p) + { + p_ = std::move (p); + + if (p_) + i_.reset_db (db); + else + i_.reset (); + } + + template + template + inline void lazy_unique_ptr:: + reset (DB& db, std::auto_ptr&& p) + { + p_ = std::unique_ptr (std::move (p)); + + if (p_) + i_.reset_db (db); + else + i_.reset (); + } + + template + template + inline typename object_traits::id_type lazy_unique_ptr:: + object_id () const + { + typedef typename object_traits::object_type object_type; + + return p_ + ? object_traits::id (*p_) + : i_.template object_id (); + } + + template + inline typename lazy_unique_ptr::database_type& lazy_unique_ptr:: + database () const + { + return *i_.database (); + } + + template + inline void + swap (lazy_unique_ptr& a, lazy_unique_ptr& b) + { + a.swap (b); + } + + template + inline bool + operator== (const lazy_unique_ptr& a, + const lazy_unique_ptr& b) + { + return a.equal (b); + } + + template + inline bool + operator!= (const lazy_unique_ptr& a, + const lazy_unique_ptr& b) + { + return !a.equal (b); + } + +#ifdef ODB_CXX11_NULLPTR + template + inline bool + operator== (const lazy_unique_ptr& a, std::nullptr_t) + { + return !a; + } + + template + inline bool + operator== (std::nullptr_t, const lazy_unique_ptr& b) + { + return !b; + } + + template + inline bool + operator!= (const lazy_unique_ptr& a, std::nullptr_t) + { + return a; + } + + template + inline bool + operator!= (std::nullptr_t, const lazy_unique_ptr& b) + { + return b; + } +#endif + + // + // lazy_shared_ptr + // + + template + inline lazy_shared_ptr:: + lazy_shared_ptr () {} + +#ifdef ODB_CXX11_NULLPTR + template + inline lazy_shared_ptr:: + lazy_shared_ptr (std::nullptr_t) {} +#endif + + template + template + inline lazy_shared_ptr:: + lazy_shared_ptr (Y* p): p_ (p) {} + + template + template + inline lazy_shared_ptr:: + lazy_shared_ptr (Y* p, D d): p_ (p, d) {} + + template + template + inline lazy_shared_ptr:: + lazy_shared_ptr (Y* p, D d, A a): p_ (p, d, a) {} + +#ifdef ODB_CXX11_NULLPTR + template + template + inline lazy_shared_ptr:: + lazy_shared_ptr (std::nullptr_t p, D d): p_ (p, d) {} + + template + template + inline lazy_shared_ptr:: + lazy_shared_ptr (std::nullptr_t p, D d, A a): p_ (p, d, a) {} +#endif + + template + template + inline lazy_shared_ptr:: + lazy_shared_ptr (const lazy_shared_ptr& r, T* p) + // r.p_ has to be loaded + : p_ (r.p_, p) {} + + template + inline lazy_shared_ptr:: + lazy_shared_ptr (const lazy_shared_ptr& r): p_ (r.p_), i_ (r.i_) {} + + template + template + inline lazy_shared_ptr:: + lazy_shared_ptr (const lazy_shared_ptr& r): p_ (r.p_), i_ (r.i_) {} + + template + inline lazy_shared_ptr:: + lazy_shared_ptr (lazy_shared_ptr&& r) + : p_ (std::move (r.p_)), i_ (std::move (r.i_)) {} + + template + template + inline lazy_shared_ptr:: + lazy_shared_ptr (lazy_shared_ptr&& r) + : p_ (std::move (r.p_)), i_ (std::move (r.i_)) {} + + template + template + inline lazy_shared_ptr:: + lazy_shared_ptr (const lazy_weak_ptr& r): i_ (r.i_) + { + // If the pointer has expired but can be re-loaded, then don't throw. + // + p_ = r.lock (); + + if (!p_ && !i_) + throw std::bad_weak_ptr (); + } + + template + template + inline lazy_shared_ptr:: + lazy_shared_ptr (std::auto_ptr&& r): p_ (std::move (r)) {} + + template + template + inline lazy_shared_ptr:: + lazy_shared_ptr (std::unique_ptr&& r): p_ (std::move (r)) {} + + template + inline lazy_shared_ptr:: + ~lazy_shared_ptr () {} + + template + inline lazy_shared_ptr& lazy_shared_ptr:: + operator= (const lazy_shared_ptr& r) + { + p_ = r.p_; + i_ = r.i_; + return *this; + } + + template + template + inline lazy_shared_ptr& lazy_shared_ptr:: + operator= (const lazy_shared_ptr& r) + { + p_ = r.p_; + i_ = r.i_; + return *this; + } + + template + inline lazy_shared_ptr& lazy_shared_ptr:: + operator= (lazy_shared_ptr&& r) + { + p_ = std::move (r.p_); + i_ = std::move (r.i_); + return *this; + } + + template + template + inline lazy_shared_ptr& lazy_shared_ptr:: + operator= (lazy_shared_ptr&& r) + { + p_ = std::move (r.p_); + i_ = std::move (r.i_); + return *this; + } + + template + template + inline lazy_shared_ptr& lazy_shared_ptr:: + operator= (std::auto_ptr&& r) + { + p_ = std::move (r); + i_.reset (); + return *this; + } + + template + template + inline lazy_shared_ptr& lazy_shared_ptr:: + operator= (std::unique_ptr&& r) + { + p_ = std::move (r); + i_.reset (); + return *this; + } + + template + inline void lazy_shared_ptr:: + swap (lazy_shared_ptr& b) + { + p_.swap (b.p_); + i_.swap (b.i_); + } + + template + inline void lazy_shared_ptr:: + reset () + { + p_.reset (); + i_.reset (); + } + + template + template + inline void lazy_shared_ptr:: + reset (Y* p) + { + p_.reset (p); + i_.reset (); + } + + template + template + inline void lazy_shared_ptr:: + reset (Y* p, D d) + { + p_.reset (p, d); + i_.reset (); + } + + template + template + inline void lazy_shared_ptr:: + reset (Y* p, D d, A a) + { + p_.reset (p, d, a); + i_.reset (); + } + + template + inline T& lazy_shared_ptr:: + operator* () const + { + return *p_; + } + + template + inline T* lazy_shared_ptr:: + operator-> () const + { + return p_.operator-> (); + } + + template + inline T* lazy_shared_ptr:: + get () const + { + return p_.get (); + } + + template + inline bool lazy_shared_ptr:: + unique () const + { + return p_.unique (); + } + + template + inline long lazy_shared_ptr:: + use_count () const + { + return p_.use_count (); + } + +#ifdef ODB_CXX11_EXPLICIT_CONVERSION_OPERATOR + template + inline lazy_shared_ptr:: + operator bool () const + { + return p_ || i_; + } +#endif + + template + template + inline lazy_shared_ptr:: + lazy_shared_ptr (const std::shared_ptr& r): p_ (r) {} + + template + template + inline lazy_shared_ptr:: + lazy_shared_ptr (std::shared_ptr&& r): p_ (std::move (r)) {} + + template + template + inline lazy_shared_ptr:: + lazy_shared_ptr (const std::weak_ptr& r): p_ (r) {} + + template + template + inline lazy_shared_ptr& lazy_shared_ptr:: + operator= (const std::shared_ptr& r) + { + p_ = r; + i_.reset (); + return *this; + } + + template + template + inline lazy_shared_ptr& lazy_shared_ptr:: + operator= (std::shared_ptr&& r) + { + p_ = std::move (r); + i_.reset (); + return *this; + } + + template + inline bool lazy_shared_ptr:: + loaded () const + { + bool i (i_); + return !p_ != i; // !p_ XOR i_ + } + + template + inline std::shared_ptr lazy_shared_ptr:: + load () const + { + if (!p_ && i_) + p_ = i_.template load (true); // Reset id. + + return p_; + } + + template + inline void lazy_shared_ptr:: + unload () const + { + typedef typename object_traits::object_type object_type; + + if (p_) + { + if (i_.database () != 0) + i_.reset_id (object_traits::id (*p_)); + + p_.reset (); + } + } + + template + inline std::shared_ptr lazy_shared_ptr:: + get_eager () const + { + return p_; + } + + template + template + inline lazy_shared_ptr:: + lazy_shared_ptr (DB& db, const ID& id): i_ (db, id) {} + + template + template + inline lazy_shared_ptr:: + lazy_shared_ptr (DB& db, Y* p) + : p_ (p) + { + if (p_) + i_.reset_db (db); + } + + template + template + inline lazy_shared_ptr:: + lazy_shared_ptr (DB& db, Y* p, D d) + : p_ (p, d) + { + if (p_) + i_.reset_db (db); + } + + template + template + inline lazy_shared_ptr:: + lazy_shared_ptr (DB& db, Y* p, D d, A a) + : p_ (p, d, a) + { + if (p_) + i_.reset_db (db); + } + + template + template + inline lazy_shared_ptr:: + lazy_shared_ptr (DB& db, std::auto_ptr&& r) + : p_ (std::move (r)) + { + if (p_) + i_.reset_db (db); + } + + template + template + inline lazy_shared_ptr:: + lazy_shared_ptr (DB& db, const std::shared_ptr& r) + : p_ (r) + { + if (p_) + i_.reset_db (db); + } + + template + template + inline lazy_shared_ptr:: + lazy_shared_ptr (DB& db, std::shared_ptr&& r) + : p_ (std::move (r)) + { + if (p_) + i_.reset_db (db); + } + + template + template + inline lazy_shared_ptr:: + lazy_shared_ptr (DB& db, const std::weak_ptr& r) + : p_ (r) + { + if (p_) + i_.reset_db (db); + } + + template + template + inline void lazy_shared_ptr:: + reset (DB& db, const ID& id) + { + p_.reset (); + i_.reset (db, id); + } + + template + template + inline void lazy_shared_ptr:: + reset (DB& db, Y* p) + { + p_.reset (p); + + if (p_) + i_.reset_db (db); + else + i_.reset (); + } + + template + template + inline void lazy_shared_ptr:: + reset (DB& db, Y* p, D d) + { + p_.reset (p, d); + + if (p_) + i_.reset_db (db); + else + i_.reset (); + } + + template + template + inline void lazy_shared_ptr:: + reset (DB& db, Y* p, D d, A a) + { + p_.reset (p, d, a); + + if (p_) + i_.reset_db (db); + else + i_.reset (); + } + + template + template + inline void lazy_shared_ptr:: + reset (DB& db, std::auto_ptr&& r) + { + p_ = std::move (r); + + if (p_) + i_.reset_db (db); + else + i_.reset (); + } + + template + template + inline void lazy_shared_ptr:: + reset (DB& db, const std::shared_ptr& r) + { + p_ = r; + + if (p_) + i_.reset_db (db); + else + i_.reset (); + } + + template + template + inline void lazy_shared_ptr:: + reset (DB& db, std::shared_ptr&& r) + { + p_ = std::move (r); + + if (p_) + i_.reset_db (db); + else + i_.reset (); + } + + template + template + inline typename object_traits::id_type lazy_shared_ptr:: + object_id () const + { + typedef typename object_traits::object_type object_type; + + return p_ + ? object_traits::id (*p_) + : i_.template object_id (); + } + + template + inline typename lazy_shared_ptr::database_type& lazy_shared_ptr:: + database () const + { + return *i_.database (); + } + + template + inline bool + operator== (const lazy_shared_ptr& a, const lazy_shared_ptr& b) + { + return a.equal (b); + } + + template + inline bool + operator!= (const lazy_shared_ptr& a, const lazy_shared_ptr& b) + { + return !a.equal (b); + } + +#ifdef ODB_CXX11_NULLPTR + template + inline bool + operator== (const lazy_shared_ptr& p, std::nullptr_t) + { + return !p; + } + + template + inline bool + operator== (std::nullptr_t, const lazy_shared_ptr& p) + { + return !p; + } + + template + inline bool + operator!= (const lazy_shared_ptr& p, std::nullptr_t) + { + return p; + } + + template + inline bool + operator!= (std::nullptr_t, const lazy_shared_ptr& p) + { + return p; + } +#endif + + template + inline void + swap (lazy_shared_ptr& a, lazy_shared_ptr& b) + { + a.swap (b); + } + + template + inline D* + get_deleter (const lazy_shared_ptr& p) + { + return std::get_deleter (p.p_); + } + + // + // lazy_weak_ptr + // + + template + inline lazy_weak_ptr:: + lazy_weak_ptr () {} + + template + template + inline lazy_weak_ptr:: + lazy_weak_ptr (const lazy_shared_ptr& r): p_ (r.p_), i_ (r.i_) {} + + template + inline lazy_weak_ptr:: + lazy_weak_ptr (const lazy_weak_ptr& r): p_ (r.p_), i_ (r.i_) {} + + template + template + inline lazy_weak_ptr:: + lazy_weak_ptr (const lazy_weak_ptr& r): p_ (r.p_), i_ (r.i_) {} + + template + inline lazy_weak_ptr:: + ~lazy_weak_ptr () {} + + template + inline lazy_weak_ptr& lazy_weak_ptr:: + operator= (const lazy_weak_ptr& r) + { + p_ = r.p_; + i_ = r.i_; + return *this; + } + + template + template + inline lazy_weak_ptr& lazy_weak_ptr:: + operator= (const lazy_weak_ptr& r) + { + p_ = r.p_; + i_ = r.i_; + return *this; + } + + template + template + inline lazy_weak_ptr& lazy_weak_ptr:: + operator= (const lazy_shared_ptr& r) + { + p_ = r.p_; + i_ = r.i_; + return *this; + } + + template + inline void lazy_weak_ptr:: + swap (lazy_weak_ptr& r) + { + p_.swap (r.p_); + i_.swap (r.i_); + } + + template + inline void lazy_weak_ptr:: + reset () + { + p_.reset (); + i_.reset (); + } + + template + inline long lazy_weak_ptr:: + use_count () const + { + return p_.use_count (); + } + + template + inline bool lazy_weak_ptr:: + expired () const + { + return p_.expired (); + } + + template + template + inline lazy_weak_ptr:: + lazy_weak_ptr (const std::weak_ptr& r): p_ (r) {} + + template + template + inline lazy_weak_ptr:: + lazy_weak_ptr (const std::shared_ptr& r): p_ (r) {} + + template + template + inline lazy_weak_ptr& lazy_weak_ptr:: + operator= (const std::weak_ptr& r) + { + p_ = r; + i_.reset (); + return *this; + } + + template + template + inline lazy_weak_ptr& lazy_weak_ptr:: + operator= (const std::shared_ptr& r) + { + p_ = r; + i_.reset (); + return *this; + } + + template + inline bool lazy_weak_ptr:: + loaded () const + { + bool i (i_); + return expired () != i; // expired () XOR i_ + } + + template + inline std::shared_ptr lazy_weak_ptr:: + load () const + { + std::shared_ptr r (p_.lock ()); + + if (!r && i_) + { + r = i_.template load (false); // Keep id. + p_ = r; + } + + return r; + } + + template + inline void lazy_weak_ptr:: + unload () const + { + // With weak pointer we always keep i_ up to date. + // + p_.reset (); + } + + template + inline std::weak_ptr lazy_weak_ptr:: + get_eager () const + { + return p_; + } + + template + template + inline lazy_weak_ptr:: + lazy_weak_ptr (DB& db, const ID& id): i_ (db, id) {} + + template + template + inline lazy_weak_ptr:: + lazy_weak_ptr (DB& db, const std::shared_ptr& r) + : p_ (r) + { + typedef typename object_traits::object_type object_type; + + if (r) + i_.reset (db, object_traits::id (*r)); + } + + template + template + inline lazy_weak_ptr:: + lazy_weak_ptr (DB& db, const std::weak_ptr& r) + : p_ (r) + { + typedef typename object_traits::object_type object_type; + + std::shared_ptr sp (p_.lock ()); + + if (sp) + i_.reset (db, object_traits::id (*sp)); + } + + template + template + inline void lazy_weak_ptr:: + reset (DB& db, const ID& id) + { + p_.reset (); + i_.reset (db, id); + } + + template + template + inline void lazy_weak_ptr:: + reset (DB& db, const std::shared_ptr& r) + { + typedef typename object_traits::object_type object_type; + + p_ = r; + + if (r) + i_.reset (db, object_traits::id (*r)); + else + i_.reset (); + } + + template + template + inline void lazy_weak_ptr:: + reset (DB& db, const std::weak_ptr& r) + { + typedef typename object_traits::object_type object_type; + + p_ = r; + std::shared_ptr sp (p_.lock ()); + + if (sp) + i_.reset (db, object_traits::id (*sp)); + else + i_.reset (); + } + + template + template + inline typename object_traits::id_type lazy_weak_ptr:: + object_id () const + { + typedef typename object_traits::object_type object_type; + + std::shared_ptr sp (p_.lock ()); + return sp + ? object_traits::id (*sp) + : i_.template object_id (); + } + + template + inline typename lazy_weak_ptr::database_type& lazy_weak_ptr:: + database () const + { + return *i_.database (); + } + + template + inline void + swap (lazy_weak_ptr& a, lazy_weak_ptr& b) + { + a.swap (b); + } + +#endif // ODB_CXX11 + +} diff --git a/third-party/odb/libodb-2.4.0/odb/lazy-ptr.txx b/third-party/odb/libodb-2.4.0/odb/lazy-ptr.txx new file mode 100755 index 0000000..81065c3 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/lazy-ptr.txx @@ -0,0 +1,143 @@ +// file : odb/lazy-ptr.txx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +namespace odb +{ + // + // lazy_ptr + // + + template + template + bool lazy_ptr:: + equal (const lazy_ptr& r) const + { + bool t1 ((p_ == 0) == loaded ()); + bool t2 ((r.p_ == 0) == r.loaded ()); + + // If both are transient, then compare the underlying pointers. + // + if (t1 && t2) + return p_ == r.p_; + + // If one is transient and the other is persistent, then compare + // the underlying pointers but only if they are non NULL. Note + // that an unloaded persistent object is always unequal to a + // transient object. + // + if (t1 || t2) + return p_ == r.p_ && p_ != 0; + + // If both objects are persistent, then we compare databases and + // object ids. + // + typedef typename object_traits::object_type object_type1; + typedef typename object_traits::object_type object_type2; + + return i_.database () == r.i_.database () && + object_id () == r.template object_id (); + } + +#ifdef ODB_CXX11 + + // + // lazy_unique_ptr + // + + template + template + bool lazy_unique_ptr:: + equal (const lazy_unique_ptr& r) const + { + bool t1 (!p_ == loaded ()); + bool t2 (!r.p_ == r.loaded ()); + + // If both are transient, then compare the underlying pointers. + // + if (t1 && t2) + return p_ == r.p_; + + // If one is transient and the other is persistent, then compare + // the underlying pointers but only if they are non NULL. Note + // that an unloaded persistent object is always unequal to a + // transient object. + // + if (t1 || t2) + return p_ == r.p_ && p_; + + // If both objects are persistent, then we compare databases and + // object ids. + // + typedef typename object_traits::object_type object_type1; + typedef typename object_traits::object_type object_type2; + + return i_.database () == r.i_.database () && + object_id () == r.template object_id (); + } + + // + // lazy_shared_ptr + // + + template + template + bool lazy_shared_ptr:: + equal (const lazy_shared_ptr& r) const + { + bool t1 (!p_ == loaded ()); + bool t2 (!r.p_ == r.loaded ()); + + // If both are transient, then compare the underlying pointers. + // + if (t1 && t2) + return p_ == r.p_; + + // If one is transient and the other is persistent, then compare + // the underlying pointers but only if they are non NULL. Note + // that an unloaded persistent object is always unequal to a + // transient object. + // + if (t1 || t2) + return p_ == r.p_ && p_; + + // If both objects are persistent, then we compare databases and + // object ids. + // + typedef typename object_traits::object_type object_type1; + typedef typename object_traits::object_type object_type2; + + return i_.database () == r.i_.database () && + object_id () == r.template object_id (); + } + + // + // lazy_weak_ptr + // + + template + lazy_shared_ptr lazy_weak_ptr:: + lock () const + { + std::shared_ptr sp (p_.lock ()); + + if (sp) + { + if (database_type* db = i_.database ()) + return lazy_shared_ptr (*db, sp); + else + return lazy_shared_ptr (sp); + } + else + { + if (i_) + return lazy_shared_ptr ( + *i_.database (), i_.template object_id ()); + else + return lazy_shared_ptr (); + } + } + +#endif // ODB_CXX11 + +} diff --git a/third-party/odb/libodb-2.4.0/odb/libodb-vc10.vcxproj b/third-party/odb/libodb-2.4.0/odb/libodb-vc10.vcxproj new file mode 100755 index 0000000..240321a --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/libodb-vc10.vcxproj @@ -0,0 +1,380 @@ + + + + + Debug + Win32 + + + Debug + x64 + + + Release + Win32 + + + Release + x64 + + + + {1C53C543-8038-4C8A-8AB1-65E74FD7DE2E} + Win32Proj + libodb + + + + DynamicLibrary + true + Unicode + + + DynamicLibrary + true + Unicode + + + DynamicLibrary + false + true + Unicode + + + DynamicLibrary + false + true + Unicode + + + + + + + + + + + + + + + + + + + true + ..\bin\ + odb-d-2.4-vc10 + + + true + ..\bin64\ + odb-d-2.4-vc10 + + + false + ..\bin\ + odb-2.4-vc10 + + + false + ..\bin64\ + odb-2.4-vc10 + + + + + + Level3 + Disabled + WIN32;_DEBUG;_WINDOWS;_USRDLL;LIBODB_DYNAMIC_LIB;%(PreprocessorDefinitions) + .. + 4355;4800;4290;4251;%(DisableSpecificWarnings) + + + Windows + true + $(TargetPath) + ..\lib\odb-d.lib + + + + + + + Level3 + Disabled + WIN32;_DEBUG;_WINDOWS;_USRDLL;LIBODB_DYNAMIC_LIB;%(PreprocessorDefinitions) + .. + 4355;4800;4290;4251;%(DisableSpecificWarnings) + + + Windows + true + $(TargetPath) + ..\lib64\odb-d.lib + + + + + Level3 + + + MaxSpeed + true + true + WIN32;NDEBUG;_WINDOWS;_USRDLL;LIBODB_DYNAMIC_LIB;%(PreprocessorDefinitions) + .. + 4355;4800;4290;4251;%(DisableSpecificWarnings) + + + Windows + true + true + true + $(TargetPath) + ..\lib\odb.lib + + + + + Level3 + + + MaxSpeed + true + true + WIN32;NDEBUG;_WINDOWS;_USRDLL;LIBODB_DYNAMIC_LIB;%(PreprocessorDefinitions) + .. + 4355;4800;4290;4251;%(DisableSpecificWarnings) + + + Windows + true + true + true + $(TargetPath) + ..\lib64\odb.lib + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + $(IntDir)\details\ + $(IntDir)\details\ + $(IntDir)\details\ + $(IntDir)\details\ + + + $(IntDir)\details\ + $(IntDir)\details\ + $(IntDir)\details\ + $(IntDir)\details\ + + + $(IntDir)\details\ + $(IntDir)\details\ + $(IntDir)\details\ + $(IntDir)\details\ + + + $(IntDir)\details\ + $(IntDir)\details\ + $(IntDir)\details\ + $(IntDir)\details\ + + + $(IntDir)\details\shared-ptr\ + $(IntDir)\details\shared-ptr\ + $(IntDir)\details\shared-ptr\ + $(IntDir)\details\shared-ptr\ + + + + $(IntDir)\details\win32\ + $(IntDir)\details\win32\ + $(IntDir)\details\win32\ + $(IntDir)\details\win32\ + + + $(IntDir)\details\win32\ + $(IntDir)\details\win32\ + $(IntDir)\details\win32\ + $(IntDir)\details\win32\ + + + $(IntDir)\details\win32\ + $(IntDir)\details\win32\ + $(IntDir)\details\win32\ + $(IntDir)\details\win32\ + + + $(IntDir)\details\win32\ + $(IntDir)\details\win32\ + $(IntDir)\details\win32\ + $(IntDir)\details\win32\ + + + $(IntDir)\details\win32\ + $(IntDir)\details\win32\ + $(IntDir)\details\win32\ + $(IntDir)\details\win32\ + + + $(IntDir)\details\win32\ + $(IntDir)\details\win32\ + $(IntDir)\details\win32\ + $(IntDir)\details\win32\ + + + + $(IntDir)\details\win32\ + $(IntDir)\details\win32\ + $(IntDir)\details\win32\ + $(IntDir)\details\win32\ + + + + + + diff --git a/third-party/odb/libodb-2.4.0/odb/libodb-vc10.vcxproj.filters b/third-party/odb/libodb-2.4.0/odb/libodb-vc10.vcxproj.filters new file mode 100755 index 0000000..f72ae2f --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/libodb-vc10.vcxproj.filters @@ -0,0 +1,461 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cxx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hxx;ixx;txx + + + + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + diff --git a/third-party/odb/libodb-2.4.0/odb/libodb-vc11.vcxproj b/third-party/odb/libodb-2.4.0/odb/libodb-vc11.vcxproj new file mode 100755 index 0000000..ef3eeea --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/libodb-vc11.vcxproj @@ -0,0 +1,384 @@ + + + + + Debug + Win32 + + + Debug + x64 + + + Release + Win32 + + + Release + x64 + + + + {1C53C543-8038-4C8A-8AB1-65E74FD7DE2E} + Win32Proj + libodb + + + + DynamicLibrary + true + v110 + Unicode + + + DynamicLibrary + true + v110 + Unicode + + + DynamicLibrary + false + v110 + true + Unicode + + + DynamicLibrary + false + v110 + true + Unicode + + + + + + + + + + + + + + + + + + + true + ..\bin\ + odb-d-2.4-vc11 + + + true + ..\bin64\ + odb-d-2.4-vc11 + + + false + ..\bin\ + odb-2.4-vc11 + + + false + ..\bin64\ + odb-2.4-vc11 + + + + + + Level3 + Disabled + WIN32;_DEBUG;_WINDOWS;_USRDLL;LIBODB_DYNAMIC_LIB;%(PreprocessorDefinitions) + .. + 4355;4800;4290;4251;%(DisableSpecificWarnings) + + + Windows + true + $(TargetPath) + ..\lib\odb-d.lib + + + + + + + Level3 + Disabled + WIN32;_DEBUG;_WINDOWS;_USRDLL;LIBODB_DYNAMIC_LIB;%(PreprocessorDefinitions) + .. + 4355;4800;4290;4251;%(DisableSpecificWarnings) + + + Windows + true + $(TargetPath) + ..\lib64\odb-d.lib + + + + + Level3 + + + MaxSpeed + true + true + WIN32;NDEBUG;_WINDOWS;_USRDLL;LIBODB_DYNAMIC_LIB;%(PreprocessorDefinitions) + .. + 4355;4800;4290;4251;%(DisableSpecificWarnings) + + + Windows + true + true + true + $(TargetPath) + ..\lib\odb.lib + + + + + Level3 + + + MaxSpeed + true + true + WIN32;NDEBUG;_WINDOWS;_USRDLL;LIBODB_DYNAMIC_LIB;%(PreprocessorDefinitions) + .. + 4355;4800;4290;4251;%(DisableSpecificWarnings) + + + Windows + true + true + true + $(TargetPath) + ..\lib64\odb.lib + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + $(IntDir)\details\ + $(IntDir)\details\ + $(IntDir)\details\ + $(IntDir)\details\ + + + $(IntDir)\details\ + $(IntDir)\details\ + $(IntDir)\details\ + $(IntDir)\details\ + + + $(IntDir)\details\ + $(IntDir)\details\ + $(IntDir)\details\ + $(IntDir)\details\ + + + $(IntDir)\details\ + $(IntDir)\details\ + $(IntDir)\details\ + $(IntDir)\details\ + + + $(IntDir)\details\shared-ptr\ + $(IntDir)\details\shared-ptr\ + $(IntDir)\details\shared-ptr\ + $(IntDir)\details\shared-ptr\ + + + + $(IntDir)\details\win32\ + $(IntDir)\details\win32\ + $(IntDir)\details\win32\ + $(IntDir)\details\win32\ + + + $(IntDir)\details\win32\ + $(IntDir)\details\win32\ + $(IntDir)\details\win32\ + $(IntDir)\details\win32\ + + + $(IntDir)\details\win32\ + $(IntDir)\details\win32\ + $(IntDir)\details\win32\ + $(IntDir)\details\win32\ + + + $(IntDir)\details\win32\ + $(IntDir)\details\win32\ + $(IntDir)\details\win32\ + $(IntDir)\details\win32\ + + + $(IntDir)\details\win32\ + $(IntDir)\details\win32\ + $(IntDir)\details\win32\ + $(IntDir)\details\win32\ + + + $(IntDir)\details\win32\ + $(IntDir)\details\win32\ + $(IntDir)\details\win32\ + $(IntDir)\details\win32\ + + + + $(IntDir)\details\win32\ + $(IntDir)\details\win32\ + $(IntDir)\details\win32\ + $(IntDir)\details\win32\ + + + + + + diff --git a/third-party/odb/libodb-2.4.0/odb/libodb-vc11.vcxproj.filters b/third-party/odb/libodb-2.4.0/odb/libodb-vc11.vcxproj.filters new file mode 100755 index 0000000..f72ae2f --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/libodb-vc11.vcxproj.filters @@ -0,0 +1,461 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cxx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hxx;ixx;txx + + + + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + diff --git a/third-party/odb/libodb-2.4.0/odb/libodb-vc12.vcxproj b/third-party/odb/libodb-2.4.0/odb/libodb-vc12.vcxproj new file mode 100755 index 0000000..1c79e51 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/libodb-vc12.vcxproj @@ -0,0 +1,388 @@ + + + + + Debug + Win32 + + + Debug + x64 + + + Release + Win32 + + + Release + x64 + + + + {1C53C543-8038-4C8A-8AB1-65E74FD7DE2E} + Win32Proj + libodb + + + + DynamicLibrary + true + v120 + Unicode + + + DynamicLibrary + true + v120 + Unicode + + + DynamicLibrary + false + v120 + true + Unicode + + + DynamicLibrary + false + v120 + true + Unicode + + + + + + + + + + + + + + + + + + + true + ..\bin\ + odb-d-2.4-vc12 + + + true + ..\bin64\ + odb-d-2.4-vc12 + + + false + ..\bin\ + odb-2.4-vc12 + + + false + ..\bin64\ + odb-2.4-vc12 + + + + + + Level3 + Disabled + WIN32;_DEBUG;_WINDOWS;_USRDLL;LIBODB_DYNAMIC_LIB;%(PreprocessorDefinitions) + .. + 4355;4800;4290;4251;%(DisableSpecificWarnings) + true + + + Windows + true + $(TargetPath) + ..\lib\odb-d.lib + + + + + + + Level3 + Disabled + WIN32;_DEBUG;_WINDOWS;_USRDLL;LIBODB_DYNAMIC_LIB;%(PreprocessorDefinitions) + .. + 4355;4800;4290;4251;%(DisableSpecificWarnings) + true + + + Windows + true + $(TargetPath) + ..\lib64\odb-d.lib + + + + + Level3 + + + MaxSpeed + true + true + WIN32;NDEBUG;_WINDOWS;_USRDLL;LIBODB_DYNAMIC_LIB;%(PreprocessorDefinitions) + .. + 4355;4800;4290;4251;%(DisableSpecificWarnings) + true + + + Windows + true + true + true + $(TargetPath) + ..\lib\odb.lib + + + + + Level3 + + + MaxSpeed + true + true + WIN32;NDEBUG;_WINDOWS;_USRDLL;LIBODB_DYNAMIC_LIB;%(PreprocessorDefinitions) + .. + 4355;4800;4290;4251;%(DisableSpecificWarnings) + true + + + Windows + true + true + true + $(TargetPath) + ..\lib64\odb.lib + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + $(IntDir)\details\ + $(IntDir)\details\ + $(IntDir)\details\ + $(IntDir)\details\ + + + $(IntDir)\details\ + $(IntDir)\details\ + $(IntDir)\details\ + $(IntDir)\details\ + + + $(IntDir)\details\ + $(IntDir)\details\ + $(IntDir)\details\ + $(IntDir)\details\ + + + $(IntDir)\details\ + $(IntDir)\details\ + $(IntDir)\details\ + $(IntDir)\details\ + + + $(IntDir)\details\shared-ptr\ + $(IntDir)\details\shared-ptr\ + $(IntDir)\details\shared-ptr\ + $(IntDir)\details\shared-ptr\ + + + + $(IntDir)\details\win32\ + $(IntDir)\details\win32\ + $(IntDir)\details\win32\ + $(IntDir)\details\win32\ + + + $(IntDir)\details\win32\ + $(IntDir)\details\win32\ + $(IntDir)\details\win32\ + $(IntDir)\details\win32\ + + + $(IntDir)\details\win32\ + $(IntDir)\details\win32\ + $(IntDir)\details\win32\ + $(IntDir)\details\win32\ + + + $(IntDir)\details\win32\ + $(IntDir)\details\win32\ + $(IntDir)\details\win32\ + $(IntDir)\details\win32\ + + + $(IntDir)\details\win32\ + $(IntDir)\details\win32\ + $(IntDir)\details\win32\ + $(IntDir)\details\win32\ + + + $(IntDir)\details\win32\ + $(IntDir)\details\win32\ + $(IntDir)\details\win32\ + $(IntDir)\details\win32\ + + + + $(IntDir)\details\win32\ + $(IntDir)\details\win32\ + $(IntDir)\details\win32\ + $(IntDir)\details\win32\ + + + + + + diff --git a/third-party/odb/libodb-2.4.0/odb/libodb-vc12.vcxproj.filters b/third-party/odb/libodb-2.4.0/odb/libodb-vc12.vcxproj.filters new file mode 100755 index 0000000..f72ae2f --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/libodb-vc12.vcxproj.filters @@ -0,0 +1,461 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cxx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hxx;ixx;txx + + + + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + diff --git a/third-party/odb/libodb-2.4.0/odb/libodb-vc8.vcproj b/third-party/odb/libodb-2.4.0/odb/libodb-vc8.vcproj new file mode 100755 index 0000000..c331af7 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/libodb-vc8.vcproj @@ -0,0 +1,1327 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/third-party/odb/libodb-2.4.0/odb/libodb-vc9.vcproj b/third-party/odb/libodb-2.4.0/odb/libodb-vc9.vcproj new file mode 100755 index 0000000..ed00dfe --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/libodb-vc9.vcproj @@ -0,0 +1,1334 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/third-party/odb/libodb-2.4.0/odb/no-id-object-result.hxx b/third-party/odb/libodb-2.4.0/odb/no-id-object-result.hxx new file mode 100755 index 0000000..a663f41 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/no-id-object-result.hxx @@ -0,0 +1,177 @@ +// file : odb/no-id-object-result.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_NO_ID_OBJECT_RESULT_HXX +#define ODB_NO_ID_OBJECT_RESULT_HXX + +#include + +#include // std::size_t +#include // std::move + +#include +#include +#include +#include +#include + +#include // ODB_CXX11 + +namespace odb +{ + // Implementation for objects without object id (always non-polymorphic). + // + template + class no_id_object_result_impl: public result_impl + { + protected: + // In result_impl, T is always non-const and the same as object_type. + // + typedef T object_type; + typedef odb::object_traits object_traits; + + typedef typename object_traits::pointer_type pointer_type; + typedef odb::pointer_traits pointer_traits; + + friend class result; + friend class result; + friend class result_iterator; + friend class result_iterator; + friend class object_result_iterator; + friend class object_result_iterator; + + protected: + no_id_object_result_impl (odb::connection& conn) + : result_impl (conn), begin_ (true), end_ (false), current_ () + { + } + + // To make this work with all kinds of pointers (raw, std::auto_ptr, + // shared), we need to make sure we don't make any copies of the + // pointer on the return path. + // + pointer_type& + current () + { + if (pointer_traits::null_ptr (current_) && !end_) + load (); + + return current_; + } + + void + release () + { + current_ = pointer_type (); + guard_.release (); + } + + void + begin () + { + if (begin_) + { + next (); + begin_ = false; + } + } + + bool + end () const + { + return end_; + } + + protected: + virtual void + load (object_type&) = 0; + + virtual void + next () = 0; + + virtual void + cache () = 0; + + virtual std::size_t + size () = 0; + + protected: +#ifdef ODB_CXX11 + void + current (pointer_type& p) + { + current_ = std::move (p); + guard_.reset (current_); + } + + void + current (pointer_type&& p) + { + current (p); + } +#else + void + current (pointer_type p) + { + current_ = p; + guard_.reset (current_); + } +#endif + + bool begin_; + bool end_; + + private: + void + load (); + + private: + pointer_type current_; + typename pointer_traits::guard guard_; + }; + + template + class object_result_iterator + { + public: + // T can be const T while object_type is always non-const. + // + typedef typename object_traits::object_type object_type; + + typedef no_id_object_result_impl result_impl_type; + + public: + object_result_iterator (result_impl_type* res) + : res_ (res) + { + } + + public: + typename object_traits::pointer_type + load () + { + typename object_traits::pointer_type r (res_->current ()); + res_->release (); + return r; + } + + void + load (object_type& obj) + { + // Objects without ids are not stored in session cache. + // + if (!res_->end ()) + res_->load (obj); + } + + protected: + result_impl_type* res_; + }; +} + +#include + +#include + +#endif // ODB_NO_ID_OBJECT_RESULT_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/no-id-object-result.txx b/third-party/odb/libodb-2.4.0/odb/no-id-object-result.txx new file mode 100755 index 0000000..d50c536 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/no-id-object-result.txx @@ -0,0 +1,22 @@ +// file : odb/no-id-object-result.txx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +namespace odb +{ + // + // object_result_impl + // + + template + void no_id_object_result_impl:: + load () + { + // Objects without ids are not stored in session cache. + // + pointer_type p (object_traits::create ()); + object_type& obj (pointer_traits::get_ref (p)); + current (p); + load (obj); + } +} diff --git a/third-party/odb/libodb-2.4.0/odb/no-op-cache-traits.hxx b/third-party/odb/libodb-2.4.0/odb/no-op-cache-traits.hxx new file mode 100755 index 0000000..e0bdccf --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/no-op-cache-traits.hxx @@ -0,0 +1,237 @@ +// file : odb/no-op-cache-traits.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_NO_OP_CACHE_TRAITS_HXX +#define ODB_NO_OP_CACHE_TRAITS_HXX + +#include + +#include +#include +#include + +namespace odb +{ + // pointer_cache_type + // + // Used to convert an object pointer to the canonical form (non-const), + // suitable for insertion into the cache. + // + template ::element_type, + typename O = typename object_traits::object_type, + pointer_kind pk = pointer_traits

::kind> + struct pointer_cache_type + { + typedef typename object_traits::pointer_type pointer_type; + + static pointer_type + convert (const P& p) + { + return pointer_traits

::const_pointer_cast (p); + } + }; + + template + struct pointer_cache_type + { + // If element_type and object_type are the same, then it is already + // the canonical pointer. + // + static const P& + convert (const P& p) {return p;} + }; + + template + struct pointer_cache_type + { + // If the pointer is unique, then casting it can transfer ownership. + // In this case we return NULL void*, which will be ignored down the + // chain. + // + static void* + convert (const P&) {return 0;} + }; + + template + struct pointer_cache_type + { + static void* + convert (const P&) {return 0;} + }; + + // reference_cache_type + // + // Used to convert an object reference to the canonical form (non-const), + // suitable for insertion into the cache. + // + template ::object_type> + struct reference_cache_type + { + static O& + convert (T& r) + { + return const_cast (r); + } + }; + + template + struct reference_cache_type + { + // If the types are the same, then it is already the canonical form. + // + static T& + convert (T& r) {return r;} + }; + + // pointer_cache_traits + // + // Caching traits for objects passed by pointer. P should be the canonical + // pointer (non-const). + // + template + struct no_op_pointer_cache_traits + { + typedef P pointer_type; + typedef typename pointer_traits::element_type object_type; + typedef typename object_traits::id_type id_type; + struct position_type {}; + + struct insert_guard + { + insert_guard () {} + insert_guard (const position_type&) {} + + position_type + position () const {return position_type ();} + + void + release () {} + + void + reset (const position_type&) {} + }; + + // Cache management. + // + static position_type + insert (odb::database&, const id_type&, const pointer_type&) + { + return position_type (); + } + + static position_type + insert (odb::database&, const pointer_type&) {return position_type ();} + + // Special signature for unique pointers. + // + static position_type + insert (odb::database&, void*) {return position_type ();} + + static pointer_type + find (odb::database&, const id_type&) {return pointer_type ();} + + static void + erase (const position_type&) {} + + // Notifications. + // + static void + persist (const position_type&) {} + + static void + load (const position_type&) {} + + static void + update (odb::database&, const object_type&) {} + + static void + erase (odb::database&, const id_type&) {} + }; + + template + struct no_id_pointer_cache_traits + { + typedef P pointer_type; + struct position_type {}; + + static position_type + insert (odb::database&, const pointer_type&) {return position_type ();} + + // Special signature for unique pointers. + // + static position_type + insert (odb::database&, void*) {return position_type ();} + + static void + persist (const position_type&) {} + + static void + load (const position_type&) {} + }; + + // reference_cache_traits + // + // Caching traits for objects passed by reference. T should be the + // canonical object type (non-const). + // + template + struct no_op_reference_cache_traits + { + typedef T object_type; + typedef typename object_traits::id_type id_type; + struct position_type {}; + + struct insert_guard + { + insert_guard () {} + insert_guard (const position_type&) {} + + position_type + position () const {return position_type ();} + + void + release () {} + + void + reset () {} + }; + + static position_type + insert (odb::database&, const id_type&, object_type&) + { + return position_type (); + } + + static position_type + insert (odb::database&, object_type&) {return position_type ();} + + static void + persist (const position_type&) {} + + static void + load (const position_type&) {} + }; + + template + struct no_id_reference_cache_traits + { + typedef T object_type; + struct position_type {}; + + static position_type + insert (odb::database&, object_type&) {return position_type ();} + + static void + persist (const position_type&) {} + + static void + load (const position_type&) {} + }; +} + +#include + +#endif // ODB_NO_OP_CACHE_TRAITS_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/nullable.hxx b/third-party/odb/libodb-2.4.0/odb/nullable.hxx new file mode 100755 index 0000000..ccfe01b --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/nullable.hxx @@ -0,0 +1,197 @@ +// file : odb/nullable.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_NULLABLE_HXX +#define ODB_NULLABLE_HXX + +#include + +#include // odb::core + +namespace odb +{ + template + class nullable + { + public: + typedef T value_type; + + nullable (); + nullable (const T&); + nullable (const nullable&); + template explicit nullable (const nullable&); + + nullable& operator= (const T&); + nullable& operator= (const nullable&); + template nullable& operator= (const nullable&); + + void swap (nullable&); + + bool null () const; + + T& get (); + const T& get () const; + + T* operator-> (); + const T* operator-> () const; + + T& operator* (); + const T& operator* () const; + + typedef void (nullable::*bool_convertible) (); + operator bool_convertible () const + { + return null_ ? 0 : &nullable::true_value; + } + + void reset (); + + private: + void true_value () {}; + + T value_; + bool null_; + }; + + namespace common + { + using odb::nullable; + } + + template + inline nullable:: + nullable () + : null_ (true) + { + } + + template + inline nullable:: + nullable (const T& v) + : value_ (v), null_ (false) + { + } + + template + inline nullable:: + nullable (const nullable& y) + : value_ (y.value_), null_ (y.null_) + { + } + + template + template + inline nullable:: + nullable (const nullable& y) + : value_ (y.value_), null_ (y.null_) + { + } + + template + inline nullable& nullable:: + operator= (const T& v) + { + value_ = v; + null_ = false; + return *this; + } + + template + inline nullable& nullable:: + operator= (const nullable& y) + { + if (this != &y) + { + value_ = y.value_; + null_ = y.null_; + } + + return *this; + } + + template + template + inline nullable& nullable:: + operator= (const nullable& y) + { + value_ = y.value_; + null_ = y.null_; + return *this; + } + + template + inline void nullable:: + swap (nullable& y) + { + T v (value_); + bool n (null_); + + value_ = y.value_; + null_ = y.null_; + + y.value_ = v; + y.null_ = n; + } + + template + inline bool nullable:: + null () const + { + return null_; + } + + template + inline T& nullable:: + get () + { + return value_; + } + + template + inline const T& nullable:: + get () const + { + return value_; + } + + template + inline T* nullable:: + operator-> () + { + return null_ ? 0 : &value_; + } + + template + inline const T* nullable:: + operator-> () const + { + return null_ ? 0 : &value_; + } + + template + inline T& nullable:: + operator* () + { + return value_; + } + + template + inline const T& nullable:: + operator* () const + { + return value_; + } + + template + inline void nullable:: + reset () + { + value_ = T (); + null_ = true; + } +} + +#include + +#endif // ODB_NULLABLE_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/object-result.hxx b/third-party/odb/libodb-2.4.0/odb/object-result.hxx new file mode 100755 index 0000000..69c5b67 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/object-result.hxx @@ -0,0 +1,165 @@ +// file : odb/object-result.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_OBJECT_RESULT_HXX +#define ODB_OBJECT_RESULT_HXX + +#include + +#include // std::ptrdiff_t +#include // iterator categories + +#include +#include +#include +#include + +namespace odb +{ + // + // object_result_impl + // + template + class object_result_impl; + + template + class polymorphic_object_result_impl; + + template + class no_id_object_result_impl; + + // + // object_result_impl_selector + // + template ::id_type, + bool polymorphic = object_traits::polymorphic> + struct object_result_impl_selector; + + template + struct object_result_impl_selector + { + typedef object_result_impl type; + }; + + template + struct object_result_impl_selector + { + typedef polymorphic_object_result_impl type; + }; + + template + struct object_result_impl_selector + { + typedef no_id_object_result_impl type; + }; + + // + // result_iterator + // + + template + class object_result_iterator; + + template + class result_iterator: public object_result_iterator< + T, + typename object_traits::id_type, + object_traits::polymorphic> + { + public: + typedef T value_type; + typedef value_type& reference; + typedef value_type* pointer; + typedef std::ptrdiff_t difference_type; + typedef std::input_iterator_tag iterator_category; + + // T can be const T while object_type is always non-const. + // + typedef + object_result_iterator::id_type, + object_traits::polymorphic> base_type; + + public: + explicit + result_iterator (typename base_type::result_impl_type* res = 0) + : base_type (res) + { + } + + // Input iterator requirements. + // + public: + reference + operator* () const + { + return pointer_traits::get_ref (this->res_->current ()); + } + + // Our value_type is already a pointer so return it instead of + // a pointer to it (operator-> will just have to go one deeper + // in the latter case). + // + pointer + operator-> () const + { + return pointer_traits::get_ptr (this->res_->current ()); + } + + result_iterator& + operator++ () + { + this->res_->next (); + return *this; + } + + result_iterator + operator++ (int) + { + // All non-end iterators for a result object move together. + // + this->res_->next (); + return *this; + } + + public: + bool + equal (result_iterator j) const + { + return (this->res_ ? this->res_->end () : true) == + (j.res_ ? j.res_->end () : true); + } + + private: + // Use unrestricted pointer traits since that's what is returned by + // result_impl. + // + typedef + odb::pointer_traits< + typename object_traits< + typename base_type::object_type>::pointer_type> + pointer_traits; + }; + + // + // + template + class result_base + { + public: + typedef typename object_traits::pointer_type value_type; + + // T can be const T while object_type is always non-const. + // + typedef typename object_traits::object_type object_type; + typedef + typename object_result_impl_selector::type + result_impl_type; + }; +} + +#include + +#endif // ODB_OBJECT_RESULT_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/pointer-traits.hxx b/third-party/odb/libodb-2.4.0/odb/pointer-traits.hxx new file mode 100755 index 0000000..dc10205 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/pointer-traits.hxx @@ -0,0 +1,404 @@ +// file : odb/pointer-traits.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_POINTER_TRAITS_HXX +#define ODB_POINTER_TRAITS_HXX + +#include + +#include // operators new/delete +#include // std::auto_ptr, std::unique_ptr, std::shared_ptr/weak_ptr +#include // std::size_t + +#include // ODB_CXX11 +#include + +namespace odb +{ + enum pointer_kind + { + pk_raw, // Raw pointer or equivalent (i.e., unmanaged). + pk_unique, // Smart pointer that doesn't support sharing. + pk_shared, // Smart pointer that supports sharing. + pk_weak // Weak counterpart for shared pointer. + }; + + template + class pointer_traits; + + // + // Standard pointer guards. + // + + // Raw pointer guard. + // + template + class raw_ptr_guard + { + public: + ~raw_ptr_guard () {delete p_;} + raw_ptr_guard (): p_ (0) {} + + explicit + raw_ptr_guard (P p): p_ (p) {} + + void + release () {p_ = 0;} + + void + reset (P p = 0) {delete p_; p_ = p;} + + private: + P p_; + }; + + // No-op pointer guard for smart pointers. + // + template + class smart_ptr_guard + { + public: + smart_ptr_guard () {} + + explicit + smart_ptr_guard (const P&) {} + + void + release () {} + + void + reset () {} + + void + reset (const P&) {} + }; + + // Specialization for raw pointers. + // + template + class pointer_traits + { + public: + static const pointer_kind kind = pk_raw; + static const bool lazy = false; + + typedef T element_type; + typedef T* pointer_type; + typedef const T* const_pointer_type; + typedef typename odb::details::meta::remove_const::result* + unrestricted_pointer_type; + typedef raw_ptr_guard guard; + + // Return raw pointer to the pointed-to element, including NULL. + // + static element_type* + get_ptr (pointer_type p) + { + return p; + } + + // Return reference to the pointed-to element. + // + static element_type& + get_ref (pointer_type p) + { + return *p; + } + + // Return true if the pointer is NULL. + // + static bool + null_ptr (pointer_type p) + { + return p == 0; + } + + // Casts. + // + static unrestricted_pointer_type + const_pointer_cast (pointer_type p) + { + return const_cast (p); + } + + template + static T1* + static_pointer_cast (pointer_type p) + { + return static_cast (p); + } + + template + static T1* + dynamic_pointer_cast (pointer_type p) + { + return dynamic_cast (p); + } + + public: + // Allocate memory for an element that will be managed by this + // pointer. + // + static void* + allocate (std::size_t n) + { + return operator new (n); + } + + // Free memory allocated for an element. This functions is only + // called if the constructor of the element being created fails. + // Otherwise, the pointer (or guard) is used to delete the object + // and free the memory. This behavior is identical to the one + // used by operator delete overloading. + // + static void + free (void* p) + { + operator delete (p); + } + }; + + // Specialization for std::auto_ptr. + // + template + class pointer_traits< std::auto_ptr > + { + public: + static const pointer_kind kind = pk_unique; + static const bool lazy = false; + + typedef T element_type; + typedef std::auto_ptr pointer_type; + typedef std::auto_ptr const_pointer_type; + typedef smart_ptr_guard guard; + + static element_type* + get_ptr (const pointer_type& p) + { + return p.get (); + } + + static element_type& + get_ref (const pointer_type& p) + { + return *p; + } + + static bool + null_ptr (const pointer_type& p) + { + return p.get () == 0; + } + + // const_pointer_cast() is not provided. + // + + // Note: transfers ownership. + // + template + static std::auto_ptr + static_pointer_cast (pointer_type& p) + { + return std::auto_ptr (static_cast (p.release ())); + } + + // Note: transfers ownership if successful. + // + template + static std::auto_ptr + dynamic_pointer_cast (pointer_type& p) + { + T1* p1 (dynamic_cast (p.get ())); + + if (p1 != 0) + p.release (); + + return std::auto_ptr (p1); + } + + public: + static void* + allocate (std::size_t n) + { + return operator new (n); + } + + static void + free (void* p) + { + operator delete (p); + } + }; + +#ifdef ODB_CXX11 + + // Specialization for C++11 std::unique_ptr. + // + template + class pointer_traits> + { + public: + static const pointer_kind kind = pk_unique; + static const bool lazy = false; + + typedef T element_type; + typedef std::unique_ptr pointer_type; + typedef std::unique_ptr const_pointer_type; + typedef smart_ptr_guard guard; + + static element_type* + get_ptr (const pointer_type& p) + { + return p.get (); + } + + static element_type& + get_ref (const pointer_type& p) + { + return *p; + } + + static bool + null_ptr (const pointer_type& p) + { + return !p; + } + + // const_pointer_cast() is not provided. + // + + // Note: transfers ownership. + // + template + static std::unique_ptr + static_pointer_cast (pointer_type& p) + { + return std::unique_ptr (static_cast (p.release ())); + } + + // Note: transfers ownership if successful. + // + template + static std::unique_ptr + dynamic_pointer_cast (pointer_type& p) + { + T1* p1 (dynamic_cast (p.get ())); + + if (p1 != 0) + p.release (); + + return std::unique_ptr (p1); + } + + public: + static void* + allocate (std::size_t n) + { + return operator new (n); + } + + static void + free (void* p) + { + operator delete (p); + } + }; + + // Specialization for C++11 std::shared_ptr. + // + template + class pointer_traits> + { + public: + static const pointer_kind kind = pk_shared; + static const bool lazy = false; + + typedef T element_type; + typedef std::shared_ptr pointer_type; + typedef std::shared_ptr const_pointer_type; + typedef typename odb::details::meta::remove_const::result + unrestricted_element_type; + typedef std::shared_ptr + unrestricted_pointer_type; + typedef smart_ptr_guard guard; + + static element_type* + get_ptr (const pointer_type& p) + { + return p.get (); + } + + static element_type& + get_ref (const pointer_type& p) + { + return *p; + } + + static bool + null_ptr (const pointer_type& p) + { + return !p; + } + + static unrestricted_pointer_type + const_pointer_cast (const pointer_type& p) + { + return std::const_pointer_cast (p); + } + + template + static std::shared_ptr + static_pointer_cast (const pointer_type& p) + { + return std::static_pointer_cast (p); + } + + template + static std::shared_ptr + dynamic_pointer_cast (const pointer_type& p) + { + return std::dynamic_pointer_cast (p); + } + + public: + static void* + allocate (std::size_t n) + { + return operator new (n); + } + + static void + free (void* p) + { + operator delete (p); + } + }; + + // Specialization for C++11 std::weak_ptr. + // + template + class pointer_traits> + { + public: + static const pointer_kind kind = pk_weak; + static const bool lazy = false; + + typedef T element_type; + typedef std::weak_ptr pointer_type; + typedef std::shared_ptr strong_pointer_type; + + static strong_pointer_type + lock (const pointer_type& p) + { + return p.lock (); + } + }; + +#endif // ODB_CXX11 + +} + +#include + +#endif // ODB_POINTER_TRAITS_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/polymorphic-info.hxx b/third-party/odb/libodb-2.4.0/odb/polymorphic-info.hxx new file mode 100755 index 0000000..33a6d3d --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/polymorphic-info.hxx @@ -0,0 +1,189 @@ +// file : odb/polymorphic-info.hxx +// copyright : Copyright (c) 2005-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_POLYMORPHIC_INFO_HXX +#define ODB_POLYMORPHIC_INFO_HXX + +#include + +#include // std::size_t +#include + +#include // database, connection +#include +#include + +namespace odb +{ + template + struct polymorphic_abstract_info + { + typedef void (*section_load) (odb::connection&, R&, bool top); + typedef void (*section_update) (odb::connection&, const R&); + + struct section_functions + { + section_load load; + section_update update; + }; + + struct section_list + { + std::size_t count; + const section_functions* functions; + }; + + public: + polymorphic_abstract_info (const std::type_info& t, + const polymorphic_abstract_info* b, + const section_list* s) + : type (t), base (b), sections (s) {} + + bool + derived (const polymorphic_abstract_info& b) const + { + for (const polymorphic_abstract_info* p (base); p != 0; p = p->base) + if (&b == p) + return true; + + return false; + } + + // Find the "most overridden" section functions. + // + section_load + find_section_load (std::size_t index) const + { + for (const polymorphic_abstract_info* b (this); b != 0; b = b->base) + if (b->sections != 0 && + index < b->sections->count && + b->sections->functions[index].load != 0) + return b->sections->functions[index].load; + + return 0; + } + + section_update + find_section_update (std::size_t index) const + { + for (const polymorphic_abstract_info* b (this); b != 0; b = b->base) + if (b->sections != 0 && + index < b->sections->count && + b->sections->functions[index].update != 0) + return b->sections->functions[index].update; + + return 0; + } + + bool + final_section_update (const polymorphic_abstract_info& i, + std::size_t index) const + { + return i.sections != 0 && + index < i.sections->count && + i.sections->functions[index].update != 0 && + i.sections->functions[index].update == find_section_update (index); + } + + public: + const std::type_info& type; + const polymorphic_abstract_info* base; + + // Sections. + // + // There could be "concrete" (i.e., not overridden) section in an + // abstract class. Which means the section table has to be in + // abstract_info. + // + const section_list* sections; + }; + + template + struct polymorphic_concrete_info: polymorphic_abstract_info + { + // Have to use access::object_traits directly because of VC10. + // + typedef R root_type; + typedef access::object_traits root_traits; + typedef typename root_traits::id_type id_type; + typedef typename root_traits::pointer_type pointer_type; + typedef typename root_traits::discriminator_type discriminator_type; + + typedef typename polymorphic_abstract_info::section_list section_list; + + enum call_type + { + call_callback, // arg points to callback event. + call_persist, // arg is not used. + call_update, // arg is not used. + call_find, // arg points to object id. + call_reload, // arg is not used. + call_load, // arg points to depth. + call_erase // arg points to object id. + }; + + typedef pointer_type (*create_function) (); + typedef bool (*dispatch_function) ( + call_type, odb::database&, const root_type*, const void* arg); + typedef void (*delayed_loader_function) ( + odb::database&, + const id_type&, + root_type&, + const schema_version_migration*); + + public: + polymorphic_concrete_info (const std::type_info& t, + const polymorphic_abstract_info* b, + const section_list* s, + const discriminator_type& d, + create_function cf, + dispatch_function df, + delayed_loader_function dlf) + : polymorphic_abstract_info (t, b, s), + discriminator (d), + create (cf), dispatch (df), delayed_loader (dlf) + { + } + + public: + discriminator_type discriminator; + create_function create; + dispatch_function dispatch; + delayed_loader_function delayed_loader; + }; + + // Register concrete type T in the root's map. + // + template + struct polymorphic_entry + { + typedef T object_type; + typedef object_traits_impl object_traits; + typedef typename object_traits::root_type root_type; + + polymorphic_entry (); + ~polymorphic_entry (); + }; + + // Helper functions that either return the concrete info or NULL + // depending on what kind of info we pass (used in query support). + // + template + inline const polymorphic_concrete_info* + polymorphic_info (const polymorphic_concrete_info& i) + { + return &i; + } + + template + inline const polymorphic_concrete_info* + polymorphic_info (const polymorphic_abstract_info&) + { + return 0; + } +} + +#include + +#endif // ODB_POLYMORPHIC_INFO_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/polymorphic-map.hxx b/third-party/odb/libodb-2.4.0/odb/polymorphic-map.hxx new file mode 100755 index 0000000..6192402 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/polymorphic-map.hxx @@ -0,0 +1,277 @@ +// file : odb/polymorphic-map.hxx +// copyright : Copyright (c) 2005-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_POLYMORPHIC_MAP_HXX +#define ODB_POLYMORPHIC_MAP_HXX + +#include + +#include +#include // std::move +#include // std::size_t +#include +#include + +#include + +#include // ODB_CXX11 +#include + +#include + +namespace odb +{ + template + struct polymorphic_map + { + typedef R root_type; + typedef polymorphic_concrete_info info_type; + typedef typename info_type::discriminator_type discriminator_type; + + polymorphic_map (): ref_count_ (1) {} + + const info_type& + find (const std::type_info& t) const; + + const info_type& + find (const discriminator_type& d) const; + + public: + typedef + std::map // VC bug. + type_map; + + struct discriminator_comparator + { + bool + operator() (const discriminator_type* x, + const discriminator_type* y) const + { + return *x < *y; + } + }; + + typedef + std::map + discriminator_map; + + public: + std::size_t ref_count_; + type_map type_map_; + discriminator_map discriminator_map_; + }; + + template + struct polymorphic_entry_impl + { + typedef R root_type; + typedef object_traits_impl root_traits; + typedef polymorphic_concrete_info info_type; + + static void + insert (const info_type&); + + static void + erase (const info_type&); + }; + + template + typename object_traits::root_type>::pointer_type + create_impl () + { + typedef object_traits derived_traits; + typedef object_traits root_traits; + + typedef typename derived_traits::pointer_type derived_pointer_type; + typedef typename root_traits::pointer_type root_pointer_type; + + derived_pointer_type p ( + access::object_factory::create ()); + + // Implicit downcast. + // +#ifdef ODB_CXX11 + root_pointer_type r (std::move (p)); +#else + root_pointer_type r (p); +#endif + return r; + } + + template + struct dispatch_load + { + static void + call (database& db, T& obj, std::size_t d) + { + object_traits_impl::load_ (db, obj, d); + } + }; + + template + struct dispatch_load + { + static void + call (database&, R&, std::size_t) + { + assert (false); + } + }; + + template + struct dispatch_persist + { + static void + call (database& db, const T& obj) + { + // Top-level call, no dynamic type checking. + // + object_traits_impl::persist (db, obj, true, false); + } + }; + + template + struct dispatch_persist + { + static void + call (database& db, const T& obj) + { + // Top-level call, no dynamic type checking. + // + object_traits_impl::persist ( + db, const_cast (obj), true, false); + } + }; + + template + bool + dispatch_impl ( + typename polymorphic_concrete_info< + typename object_traits::root_type>::call_type c, + database& db, + const typename object_traits::root_type* pobj, + const void* arg) + { + typedef object_traits_impl derived_traits; + typedef typename derived_traits::root_type root_type; + typedef object_traits_impl root_traits; + typedef typename root_traits::id_type id_type; + typedef polymorphic_concrete_info info_type; + + bool r (false); + + switch (c) + { + case info_type::call_callback: + { + derived_traits::callback ( + db, + *const_cast (static_cast (pobj)), + *static_cast (arg)); + break; + } + case info_type::call_persist: + { + dispatch_persist::call ( + db, + *static_cast (pobj)); + break; + } + case info_type::call_update: + { + derived_traits::update ( + db, + *static_cast (pobj), + true, // Top-level call. + false); // No dynamic type checking. + break; + } + case info_type::call_find: + { + r = derived_traits::find ( + db, + *static_cast (arg), + *const_cast (static_cast (pobj)), + false); // No dynamic type checking. + break; + } + case info_type::call_reload: + { + r = derived_traits::reload ( + db, + *const_cast (static_cast (pobj)), + false); // No dynamic type checking. + break; + } + case info_type::call_load: + { + dispatch_load::call ( + db, + *const_cast (static_cast (pobj)), + *static_cast (arg)); + break; + } + case info_type::call_erase: + { + if (pobj != 0) + derived_traits::erase ( + db, + *static_cast (pobj), + true, // Top-level call. + false); // No dynamic type checking. + else + derived_traits::erase ( + db, + *static_cast (arg), + true, // Top-level call. + false); // No dynamic type checking. + break; + } + } + + return r; + } + + template + void + section_load_impl (odb::connection& conn, + typename object_traits::root_type& obj, + bool top) + { + typedef object_traits_impl derived_traits; + typedef typename derived_traits::statements_type statements_type; + typedef typename statements_type::connection_type connection_type; + + connection_type& c (static_cast (conn)); + statements_type& sts (c.statement_cache ().template find_object ()); + + ST::load (sts.extra_statement_cache (), static_cast (obj), top); + } + + template + void + section_update_impl (odb::connection& conn, + const typename object_traits::root_type& obj) + { + typedef object_traits_impl derived_traits; + typedef typename derived_traits::statements_type statements_type; + typedef typename statements_type::connection_type connection_type; + + connection_type& c (static_cast (conn)); + statements_type& sts (c.statement_cache ().template find_object ()); + + ST::update (sts.extra_statement_cache (), static_cast (obj)); + } +} + +#include +#include + +#include + +#endif // ODB_POLYMORPHIC_MAP_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/polymorphic-map.ixx b/third-party/odb/libodb-2.4.0/odb/polymorphic-map.ixx new file mode 100755 index 0000000..5322c6b --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/polymorphic-map.ixx @@ -0,0 +1,20 @@ +// file : odb/polymorphic-map.ixx +// copyright : Copyright (c) 2005-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +namespace odb +{ + template + inline polymorphic_entry:: + polymorphic_entry () + { + polymorphic_entry_impl::insert (object_traits::info); + } + + template + inline polymorphic_entry:: + ~polymorphic_entry () + { + polymorphic_entry_impl::erase (object_traits::info); + } +} diff --git a/third-party/odb/libodb-2.4.0/odb/polymorphic-map.txx b/third-party/odb/libodb-2.4.0/odb/polymorphic-map.txx new file mode 100755 index 0000000..5c95351 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/polymorphic-map.txx @@ -0,0 +1,76 @@ +// file : odb/polymorphic-map.txx +// copyright : Copyright (c) 2005-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include // no_type_info + +namespace odb +{ + // + // polymorphic_map + // + + template + const typename polymorphic_map::info_type& polymorphic_map:: + find (const std::type_info& t) const + { + typename type_map::const_iterator i (type_map_.find (&t)); + + if (i != type_map_.end ()) + return *i->second; + else + throw no_type_info (); + } + + template + const typename polymorphic_map::info_type& polymorphic_map:: + find (const discriminator_type& d) const + { + typename discriminator_map::const_iterator i ( + discriminator_map_.find (&d)); + + if (i != discriminator_map_.end ()) + return *i->second; + else + throw no_type_info (); + } + + // + // polymorphic_entry_impl + // + + template + void polymorphic_entry_impl:: + insert (const info_type& i) + { + // VC10 cannot grok constructor call syntax here. + // + polymorphic_map*& pm = root_traits::map; + + if (pm == 0) + pm = new polymorphic_map; + else + pm->ref_count_++; + + pm->type_map_[&i.type] = &i; + pm->discriminator_map_[&i.discriminator] = &i; + } + + template + void polymorphic_entry_impl:: + erase (const info_type& i) + { + // VC10 cannot grok constructor call syntax here. + // + polymorphic_map*& pm = root_traits::map; + + pm->discriminator_map_.erase (&i.discriminator); + pm->type_map_.erase (&i.type); + + if (--pm->ref_count_ == 0) + { + delete pm; + pm = 0; + } + } +} diff --git a/third-party/odb/libodb-2.4.0/odb/polymorphic-object-result.hxx b/third-party/odb/libodb-2.4.0/odb/polymorphic-object-result.hxx new file mode 100755 index 0000000..2adeaa3 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/polymorphic-object-result.hxx @@ -0,0 +1,219 @@ +// file : odb/polymorphic-object-result.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_POLYMORPHIC_OBJECT_RESULT_HXX +#define ODB_POLYMORPHIC_OBJECT_RESULT_HXX + +#include + +#include // std::size_t +#include // std::move + +#include +#include +#include +#include +#include + +#include // ODB_CXX11 + +namespace odb +{ + // Implementation for polymorphic objects with object id. + // + template + class polymorphic_object_result_impl: public result_impl + { + protected: + // In result_impl, T is always non-const and the same as object_type. + // + typedef T object_type; + typedef odb::object_traits object_traits; + typedef typename object_traits::id_type id_type; + + typedef typename object_traits::pointer_type pointer_type; + typedef odb::pointer_traits pointer_traits; + + typedef typename object_traits::root_type root_type; + typedef odb::object_traits root_traits; + typedef typename root_traits::discriminator_type discriminator_type; + + friend class result; + friend class result; + friend class result_iterator; + friend class result_iterator; + friend class object_result_iterator; + friend class object_result_iterator; + + protected: + polymorphic_object_result_impl (odb::connection& conn) + : result_impl (conn), begin_ (true), end_ (false), current_ () + { + } + + // To make this work with all kinds of pointers (raw, std::auto_ptr, + // shared), we need to make sure we don't make any copies of the + // pointer on the return path. + // + pointer_type& + current () + { + if (pointer_traits::null_ptr (current_) && !end_) + load (); + + return current_; + } + + void + release () + { + current_ = pointer_type (); + guard_.release (); + } + + void + begin () + { + if (begin_) + { + next (); + begin_ = false; + } + } + + bool + end () const + { + return end_; + } + + protected: + // The fetch argument is a hint to the implementation. If it is + // false then it means load_id() was already called (and presumably + // fetched the data into the object image) and the object image + // is still valid (so the implementation doesn't need to fetch + // the data again). + // + // The load() signature differs from the non-polymorphic cases in + // that we pass a pointer to object instead of a reference. The + // object is only passed if the user requests loading into an + // existing instance. Otherwise, we pass NULL and load() is + // responsible for creating the object of a correct dynamic + // type and managing the object cache insertion. + // + virtual void + load (object_type*, bool fetch = true) = 0; + + virtual id_type + load_id () = 0; + + virtual discriminator_type + load_discriminator () = 0; + + virtual void + next () = 0; + + virtual void + cache () = 0; + + virtual std::size_t + size () = 0; + + protected: +#ifdef ODB_CXX11 + void + current (pointer_type& p, bool guard = true) + { + current_ = std::move (p); + + if (guard) + guard_.reset (current_); + else + guard_.reset (); + } + + void + current (pointer_type&& p, bool guard = true) + { + current (p, guard); + } +#else + void + current (pointer_type p, bool guard = true) + { + current_ = p; + + if (guard) + guard_.reset (current_); + else + guard_.reset (); + } +#endif + + bool begin_; + bool end_; + + private: + void + load (); + + private: + pointer_type current_; + typename pointer_traits::guard guard_; + }; + + template + class object_result_iterator + { + public: + // T can be const T while object_type is always non-const. + // + typedef typename object_traits::object_type object_type; + typedef typename object_traits::id_type id_type; + typedef typename object_traits::root_type root_type; + typedef typename object_traits::discriminator_type + discriminator_type; + + typedef polymorphic_object_result_impl result_impl_type; + + public: + object_result_iterator (result_impl_type* res) + : res_ (res) + { + } + + public: + typename object_traits::pointer_type + load () + { + typename object_traits::pointer_type r (res_->current ()); + res_->release (); + return r; + } + + void + load (object_type&); + + id_type + id () + { + return res_->load_id (); + } + + discriminator_type + discriminator () + { + return res_->load_discriminator (); + } + + protected: + result_impl_type* res_; + }; +} + +#include + +#include + +#endif // ODB_POLYMORPHIC_OBJECT_RESULT_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/polymorphic-object-result.txx b/third-party/odb/libodb-2.4.0/odb/polymorphic-object-result.txx new file mode 100755 index 0000000..e008452 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/polymorphic-object-result.txx @@ -0,0 +1,71 @@ +// file : odb/polymorphic-object-result.txx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include + +namespace odb +{ + // + // polymorphic_object_result_impl + // + + template + void polymorphic_object_result_impl:: + load () + { + typedef typename root_traits::pointer_type root_pointer_type; + typedef typename root_traits::pointer_traits root_pointer_traits; + + // First check the session. + // + const id_type& id (load_id ()); + + root_pointer_type rp ( + object_traits::pointer_cache_traits::find (this->db_, id)); + + if (!root_pointer_traits::null_ptr (rp)) + { + // Check if the types match. + // + pointer_type p ( + root_pointer_traits::template dynamic_pointer_cast< + object_type> (rp)); + + if (!pointer_traits::null_ptr (p)) + current (p, false); // Pointer from cache should not be guarded. + else + // We have an object in session that has a different type + // compared to the one in the database. + // + throw object_not_persistent (); // @@ type_mismatch? + } + else + // load() is responsible for creating the object of a correct + // dynamic type and for object cache insertion. + // + load (0, false); + } + + // + // object_result_iterator + // + + template + void object_result_iterator:: + load (object_type& obj) + { + if (res_->end ()) + return; + + typedef odb::object_traits object_traits; + + typename object_traits::reference_cache_traits::position_type p ( + object_traits::reference_cache_traits::insert ( + res_->db_, res_->load_id (), obj)); + typename object_traits::reference_cache_traits::insert_guard ig (p); + res_->load (&obj, false); + object_traits::reference_cache_traits::load (p); + ig.release (); + } +} diff --git a/third-party/odb/libodb-2.4.0/odb/post.hxx b/third-party/odb/libodb-2.4.0/odb/post.hxx new file mode 100755 index 0000000..fe6e342 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/post.hxx @@ -0,0 +1,7 @@ +// file : odb/post.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifdef _MSC_VER +# include +#endif diff --git a/third-party/odb/libodb-2.4.0/odb/pre.hxx b/third-party/odb/libodb-2.4.0/odb/pre.hxx new file mode 100755 index 0000000..2245c78 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/pre.hxx @@ -0,0 +1,7 @@ +// file : odb/pre.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifdef _MSC_VER +# include +#endif diff --git a/third-party/odb/libodb-2.4.0/odb/prepared-query.cxx b/third-party/odb/libodb-2.4.0/odb/prepared-query.cxx new file mode 100755 index 0000000..7674d5c --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/prepared-query.cxx @@ -0,0 +1,41 @@ +// file : odb/prepared-query.cxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include +#include + +namespace odb +{ + prepared_query_impl:: + ~prepared_query_impl () + { + if (next_ != this) + list_remove (); + } + + prepared_query_impl:: + prepared_query_impl (connection& c) + : cached (false), conn (c), prev_ (0), next_ (this) + { + // Add to the list. + // + next_ = conn.prepared_queries_; + conn.prepared_queries_ = this; + + if (next_ != 0) + next_->prev_ = this; + } + + void prepared_query_impl:: + list_remove () + { + (prev_ == 0 ? conn.prepared_queries_ : prev_->next_) = next_; + + if (next_ != 0) + next_->prev_ = prev_; + + prev_ = 0; + next_ = this; + } +} diff --git a/third-party/odb/libodb-2.4.0/odb/prepared-query.hxx b/third-party/odb/libodb-2.4.0/odb/prepared-query.hxx new file mode 100755 index 0000000..cf58815 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/prepared-query.hxx @@ -0,0 +1,196 @@ +// file : odb/prepared-query.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_PREPARED_QUERY_HXX +#define ODB_PREPARED_QUERY_HXX + +#include + +#include // odb::core +#include +#include +#include + +#include +#include + +namespace odb +{ + class LIBODB_EXPORT prepared_query_impl: public details::shared_base + { + public: + virtual + ~prepared_query_impl (); + + prepared_query_impl (connection&); + + bool cached; + connection& conn; + const char* name; + details::shared_ptr stmt; + details::shared_ptr (*execute) (prepared_query_impl&); + + private: + prepared_query_impl (const prepared_query_impl&); + prepared_query_impl& operator= (const prepared_query_impl&); + + // Doubly-linked list of results. + // + // prev_ == 0 means we are the first element. + // next_ == 0 means we are the last element. + // next_ == this means we are not on the list. + // + protected: + friend class connection; + + void + list_remove (); + + prepared_query_impl* prev_; + prepared_query_impl* next_; + }; + + template + struct prepared_query + { + // Cached version. + // + explicit + prepared_query (prepared_query_impl* impl = 0): impl_ (impl) {} + + // Uncached version. + // + explicit + prepared_query (const details::shared_ptr& impl) + : impl_ (impl.get ()) + { + impl_->_inc_ref (); + } + + result + execute (bool cache = true) + { + typedef + typename result_base::kind>::result_impl_type + derived_type; + + details::shared_ptr ri (impl_->execute (*impl_)); + result r ( + details::shared_ptr ( + static_cast (ri.release ()))); + + if (cache) + r.cache (); + + return r; + } + + typename object_traits::pointer_type + execute_one () + { + return execute (false).one (); + } + + bool + execute_one (T& object) + { + return execute (false).one (object); + } + + T + execute_value () + { + // Compiler error pointing here? The object must be default- + // constructible in order to use the return-by-value API. + // + T o; + execute (false).value (o); + return o; + } + + const char* + name () const + { + return impl_->name; + } + + typedef odb::statement statement_type; + + statement_type& + statement () const + { + return *impl_->stmt; + } + + typedef prepared_query_impl* prepared_query::*unspecified_bool_type; + operator unspecified_bool_type () const + { + return impl_ ? &prepared_query::impl_ : 0; + } + + public: + ~prepared_query () + { + if (impl_ != 0 && !impl_->cached && impl_->_dec_ref ()) + delete impl_; + } + + prepared_query (const prepared_query& x) + : impl_ (x.impl_) + { + if (!impl_->cached) + impl_->_inc_ref (); + } + + prepared_query& + operator= (const prepared_query& x) + { + if (impl_ != x.impl_) + { + if (impl_ != 0 && !impl_->cached && impl_->_dec_ref ()) + delete impl_; + + impl_ = x.impl_; + + if (!impl_->cached) + impl_->_inc_ref (); + } + + return *this; + } + + private: + // Ideally, we would just use shared_ptr to manage the impl object. + // However, there is a problem if the prepared query is cached on + // the connection and the connection is released early when the + // transaction is committed or rolled back. In this case, the + // prepared_query object might still be around pointing to impl. If + // this connection and the prepared query are then used by another + // thread while we release the impl object, then we have a race + // condition. + // + // To work around this problem we will simply "reference" the impl + // object without counting if the prepared query is cached. For + // transition from pointer to reference, see cache_query_() in + // connection.cxx. + // + // You may also observe that in order to know whether this is a + // cached prepared query or not, we have to read the cached data + // member in the impl object. This does not cause a race because, + // unlike the reference count, this member is immutable once set + // to true. + // + friend class connection; + prepared_query_impl* impl_; + }; + + namespace common + { + using odb::prepared_query; + } +} + +#include + +#endif // ODB_PREPARED_QUERY_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/query-dynamic.cxx b/third-party/odb/libodb-2.4.0/odb/query-dynamic.cxx new file mode 100755 index 0000000..8511897 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/query-dynamic.cxx @@ -0,0 +1,201 @@ +// file : odb/query-dynamic.cxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include + +using namespace std; + +namespace odb +{ + // query_param + // + query_param:: + ~query_param () + { + } + + // query_base + // + void query_base:: + clear () + { + for (clause_type::iterator i (clause_.begin ()); i != clause_.end (); ++i) + { + if (i->kind == clause_part::kind_param_val || + i->kind == clause_part::kind_param_ref) + { + query_param* qp (reinterpret_cast (i->data)); + + if (qp != 0 && qp->_dec_ref ()) + delete qp; + } + } + + clause_.clear (); + strings_.clear (); + } + + void query_base:: + append (const string& native) + { + strings_.push_back (native); + clause_.push_back (clause_part ()); + clause_.back ().kind = clause_part::kind_native; + clause_.back ().data = strings_.size () - 1; + } + + void query_base:: + append (const query_base& x) + { + size_t i (clause_.size ()), delta (i); + size_t n (i + x.clause_.size ()); + clause_.resize (n); + + for (size_t j (0); i < n; ++i, ++j) + { + const clause_part& s (x.clause_[j]); + clause_part& d (clause_[i]); + + d = s; + + // We need to increment the param references, update pointers + // to strings and update argument positions. + // + switch (s.kind) + { + case clause_part::kind_param_val: + case clause_part::kind_param_ref: + { + reinterpret_cast (d.data)->_inc_ref (); + break; + } + case clause_part::kind_native: + { + strings_.push_back (x.strings_[s.data]); + d.data = strings_.size () - 1; + break; + } + case clause_part::op_add: + + case clause_part::op_and: + case clause_part::op_or: + + case clause_part::op_eq: + case clause_part::op_ne: + case clause_part::op_lt: + case clause_part::op_gt: + case clause_part::op_le: + case clause_part::op_ge: + { + d.data += delta; + break; + } + // Do not use default here to remember to handle new op codes. + // + case clause_part::kind_column: + case clause_part::kind_true: + case clause_part::kind_false: + case clause_part::op_not: + case clause_part::op_null: + case clause_part::op_not_null: + case clause_part::op_in: + case clause_part::op_like: + case clause_part::op_like_escape: + break; + } + } + } + + void query_base:: + append_ref (const void* ref, const native_column_info* c) + { + clause_.push_back (clause_part ()); + clause_part& p (clause_.back ()); + + p.kind = clause_part::kind_param_ref; + p.data = 0; // In case new below throws. + p.native_info = c; + + p.data = reinterpret_cast ( + new (details::shared) query_param (ref)); + } + + query_base& query_base:: + operator+= (const std::string& native) + { + if (!native.empty ()) + { + size_t p (clause_.size ()); + append (native); + + if (p != 0) + append (clause_part::op_add, p - 1); + } + + return *this; + } + + query_base& query_base:: + operator+= (const query_base& x) + { + if (!x.empty ()) + { + size_t p (clause_.size ()); + append (x); + + if (p != 0) + append (clause_part::op_add, p - 1); + } + + return *this; + } + + query_base + operator&& (const query_base& x, const query_base& y) + { + // Optimize cases where one or both sides are constant truth. + // + bool xt (x.const_true ()), yt (y.const_true ()); + + if (xt && yt) + return x; + + if (xt || x.empty ()) + return y; + + if (yt || y.empty ()) + return x; + + query_base r (x); + r.append (y); + r.append (query_base::clause_part::op_and, x.clause ().size () - 1); + return r; + } + + query_base + operator|| (const query_base& x, const query_base& y) + { + if (x.empty ()) + return y; + + if (y.empty ()) + return x; + + query_base r (x); + r.append (y); + r.append (query_base::clause_part::op_or, x.clause ().size () - 1); + return r; + } + + query_base + operator! (const query_base& x) + { + if (x.empty ()) + return x; + + query_base r (x); + r.append (query_base::clause_part::op_not, 0); + return r; + } +} diff --git a/third-party/odb/libodb-2.4.0/odb/query-dynamic.hxx b/third-party/odb/libodb-2.4.0/odb/query-dynamic.hxx new file mode 100755 index 0000000..97ab67f --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/query-dynamic.hxx @@ -0,0 +1,1068 @@ +// file : odb/query-dynamic.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_QUERY_DYNAMIC_HXX +#define ODB_QUERY_DYNAMIC_HXX + +#include + +#include +#include +#include // std::size_t + +#include +#include + +#include +#include + +namespace odb +{ + struct native_column_info; + + template + struct val_bind + { + typedef const T& type; + + explicit + val_bind (type v): val (v) {} + + type val; + }; + + // Passing arrays by value in dynamic queries is not supported. + // Pass by reference instead. + // + template + struct val_bind; + + template + struct ref_bind + { + typedef const T& type; + + explicit + ref_bind (type r): ref (r) {} + + const void* + ptr () const {return &ref;} + + type ref; + }; + + template + struct ref_bind + { + typedef const T* type; + + explicit + ref_bind (type r): ref (r) {} + + // Allow implicit conversion from decayed ref_bind's. + // + ref_bind (ref_bind r): ref (r.ref) {} + ref_bind (ref_bind r): ref (r.ref) {} + + const void* + ptr () const {return ref;} + + type ref; + }; + + // + // + struct LIBODB_EXPORT query_param: details::shared_base + { + virtual ~query_param (); + query_param (const void* v): value (v) {} + + const void* value; + }; + + // For by-value parameters we have to make a copy since the original + // can be gone by the time we translate to native query. + // + template + struct val_query_param: query_param + { + val_query_param (const T& v): query_param (©), copy (v) {} + + T copy; + }; + + // + // + class LIBODB_EXPORT query_base + { + public: + // Internally the query clause is stored in a Reverse Polish Notation- + // like representation which also allows us to traverse it as a syntax + // tree. + // + // Let's keep this class POD so that std::vector can do more + // efficient copying, etc. + // + struct clause_part + { + // Note that the order of enumerators is important (used as indexes). + // + enum kind_type + { + kind_column, // native_info points to the native_column_info array. + + kind_param_val, // data points to query_param while native_info points + kind_param_ref, // to the native_column_info array. + + kind_native, // data is the index in the strings vector. + + kind_true, // true literal. + kind_false, // false literal. + + // Operators. + // + // For binary operators, data is the index of the last element + // belonging to the left hand side sub-expression. + // + op_add, // + (concatenation of two sub-expressions) + + op_and, // && + op_or, // || + op_not, // ! + + op_null, // is_null () + op_not_null, // is_not_null () + + op_in, // in(), data is the number of arguments + op_like, // like(pattern) + op_like_escape, // like(pattern, escape) + + op_eq, // == + op_ne, // != + op_lt, // < + op_gt, // > + op_le, // <= + op_ge // >= + }; + + kind_type kind; + std::size_t data; + const native_column_info* native_info; + }; + + public: + ~query_base () + { + clear (); + } + + query_base () {} + + // True or false literal. + // + explicit + query_base (bool v) + { + append (v ? clause_part::kind_true : clause_part::kind_false, 0); + } + + explicit + query_base (const char* native) + { + append (native); + } + + explicit + query_base (const std::string& native) + { + append (native); + } + + query_base (const query_column&); + + query_base (const query_base& x) + { + append (x); + } + + query_base& + operator= (const query_base& x) + { + if (this != &x) + { + clear (); + append (x); + } + + return *this; + } + + public: + template + static val_bind + _val (const T& x) + { + return val_bind (x); + } + + template + static ref_bind + _ref (const T& x) + { + return ref_bind (x); + } + + // Some compilers (notably VC++), when deducing const T& from const + // array do not strip const from the array type. As a result, in the + // above signatures we get, for example, T = const char[4] instead + // of T = char[4], which is what we want. So to "fix" such compilers, + // we will have to provide the following specialization of the above + // _ref() function (we don't need _val() since we don't support passing + // arrays by value; see val_bind definition). + // + template + static ref_bind + _ref (const T (&x) [N]) + { + return ref_bind (x); + } + + public: + query_base& + operator+= (const query_base&); + + query_base& + operator+= (const std::string& native); + + public: + bool + empty () const + { + return clause_.empty (); + } + + bool + const_true () const + { + return clause_.size () == 1 && + clause_.front ().kind == clause_part::kind_true; + } + + // Implementation details. + // + public: + explicit + query_base (const native_column_info* c) + { + append (c); + } + + // Native. + // + void + append (const std::string&); + + // Query fragment. + // + void + append (const query_base&); + + // Operator. + // + void + append (clause_part::kind_type k, std::size_t data) + { + clause_.push_back (clause_part ()); + clause_.back ().kind = k; + clause_.back ().data = data; + } + + // Column. + // + void + append (const native_column_info* c) + { + clause_.push_back (clause_part ()); + clause_.back ().kind = clause_part::kind_column; + clause_.back ().native_info = c; + } + + // Parameter. + // + void + append_ref (const void* ref, const native_column_info*); + + template + void + append_val (const T& val, const native_column_info*); + + void + clear (); + + public: + typedef std::vector clause_type; + typedef std::vector strings_type; + + const clause_type& + clause () const + { + return clause_; + } + + const strings_type& + strings () const + { + return strings_; + } + + private: + clause_type clause_; + strings_type strings_; + }; + + inline query_base + operator+ (const query_base& x, const query_base& y) + { + query_base r (x); + r += y; + return r; + } + + inline query_base + operator+ (const query_base& q, const std::string& s) + { + query_base r (q); + r += s; + return r; + } + + inline query_base + operator+ (const std::string& s, const query_base& q) + { + query_base r (s); + r += q; + return r; + } + + LIBODB_EXPORT query_base + operator&& (const query_base&, const query_base&); + + LIBODB_EXPORT query_base + operator|| (const query_base&, const query_base&); + + LIBODB_EXPORT query_base + operator! (const query_base&); + + // + // + struct native_column_info + { + const void* column; + void* param_factory; + }; + + template + const T& + type_instance (); + + // This class template has to remain POD since we rely on it being + // 0-initialized before any dynamic initialization takes place in + // any other translation unit. + // + template + struct query_column + { + // Array of pointers to database-specific columns. It will be + // automatically zero-initialized since query_column instances + // are always static. + // + native_column_info native_info[database_count]; + + // is_null, is_not_null + // + public: + query_base + is_null () const + { + query_base q (native_info); + q.append (query_base::clause_part::op_null, 0); + return q; + } + + query_base + is_not_null () const + { + query_base q (native_info); + q.append (query_base::clause_part::op_not_null, 0); + return q; + } + + // in + // + public: + query_base + in (const T&, const T&) const; + + query_base + in (const T&, const T&, const T&) const; + + query_base + in (const T&, const T&, const T&, const T&) const; + + query_base + in (const T&, const T&, const T&, const T&, const T&) const; + + template + query_base + in_range (I begin, I end) const; + + // like + // + public: + query_base + like (const T& pattern) const + { + return like (val_bind (pattern)); + } + + query_base + like (val_bind pattern) const; + + template + query_base + like (val_bind pattern) const + { + return like (val_bind (T (pattern.val))); + } + + query_base + like (ref_bind pattern) const; + + query_base + like (const T& pattern, const T& escape) const + { + return like (val_bind (pattern), escape); + } + + query_base + like (val_bind pattern, const T& escape) const; + + template + query_base + like (val_bind pattern, const T& escape) const + { + return like (val_bind (T (pattern.val)), escape); + } + + query_base + like (ref_bind pattern, const T& escape) const; + + // == + // + public: + query_base + equal (val_bind v) const + { + query_base q (native_info); + q.append_val (v.val, native_info); + q.append (query_base::clause_part::op_eq, 0); + return q; + } + + query_base + equal (ref_bind r) const + { + query_base q (native_info); + q.append_ref (r.ptr (), native_info); + q.append (query_base::clause_part::op_eq, 0); + return q; + } + + friend query_base + operator== (const query_column& c, const T& v) + { + return c.equal (val_bind (v)); + } + + friend query_base + operator== (const T& v, const query_column& c) + { + return c.equal (val_bind (v)); + } + + friend query_base + operator== (const query_column& c, val_bind v) + { + return c.equal (v); + } + + friend query_base + operator== (val_bind v, const query_column& c) + { + return c.equal (v); + } + + template + friend query_base + operator== (const query_column& c, val_bind v) + { + return c.equal (val_bind (T (v.val))); + } + + template + friend query_base + operator== (val_bind v, const query_column& c) + { + return c.equal (val_bind (T (v.val))); + } + + friend query_base + operator== (const query_column& c, ref_bind r) + { + return c.equal (r); + } + + friend query_base + operator== (ref_bind r, const query_column& c) + { + return c.equal (r); + } + + // != + // + public: + query_base + unequal (val_bind v) const + { + query_base q (native_info); + q.append_val (v.val, native_info); + q.append (query_base::clause_part::op_ne, 0); + return q; + } + + query_base + unequal (ref_bind r) const + { + query_base q (native_info); + q.append_ref (r.ptr (), native_info); + q.append (query_base::clause_part::op_ne, 0); + return q; + } + + friend query_base + operator!= (const query_column& c, const T& v) + { + return c.unequal (val_bind (v)); + } + + friend query_base + operator!= (const T& v, const query_column& c) + { + return c.unequal (val_bind (v)); + } + + friend query_base + operator!= (const query_column& c, val_bind v) + { + return c.unequal (v); + } + + friend query_base + operator!= (val_bind v, const query_column& c) + { + return c.unequal (v); + } + + template + friend query_base + operator!= (const query_column& c, val_bind v) + { + return c.unequal (val_bind (T (v.val))); + } + + template + friend query_base + operator!= (val_bind v, const query_column& c) + { + return c.unequal (val_bind (T (v.val))); + } + + friend query_base + operator!= (const query_column& c, ref_bind r) + { + return c.unequal (r); + } + + friend query_base + operator!= (ref_bind r, const query_column& c) + { + return c.unequal (r); + } + + // < + // + public: + query_base + less (val_bind v) const + { + query_base q (native_info); + q.append_val (v.val, native_info); + q.append (query_base::clause_part::op_lt, 0); + return q; + } + + query_base + less (ref_bind r) const + { + query_base q (native_info); + q.append_ref (r.ptr (), native_info); + q.append (query_base::clause_part::op_lt, 0); + return q; + } + + friend query_base + operator< (const query_column& c, const T& v) + { + return c.less (val_bind (v)); + } + + friend query_base + operator< (const T& v, const query_column& c) + { + return c.greater (val_bind (v)); + } + + friend query_base + operator< (const query_column& c, val_bind v) + { + return c.less (v); + } + + friend query_base + operator< (val_bind v, const query_column& c) + { + return c.greater (v); + } + + template + friend query_base + operator< (const query_column& c, val_bind v) + { + return c.less (val_bind (T (v.val))); + } + + template + friend query_base + operator< (val_bind v, const query_column& c) + { + return c.greater (val_bind (T (v.val))); + } + + friend query_base + operator< (const query_column& c, ref_bind r) + { + return c.less (r); + } + + friend query_base + operator< (ref_bind r, const query_column& c) + { + return c.greater (r); + } + + // > + // + public: + query_base + greater (val_bind v) const + { + query_base q (native_info); + q.append_val (v.val, native_info); + q.append (query_base::clause_part::op_gt, 0); + return q; + } + + query_base + greater (ref_bind r) const + { + query_base q (native_info); + q.append_ref (r.ptr (), native_info); + q.append (query_base::clause_part::op_gt, 0); + return q; + } + + friend query_base + operator> (const query_column& c, const T& v) + { + return c.greater (val_bind (v)); + } + + friend query_base + operator> (const T& v, const query_column& c) + { + return c.less (val_bind (v)); + } + + friend query_base + operator> (const query_column& c, val_bind v) + { + return c.greater (v); + } + + friend query_base + operator> (val_bind v, const query_column& c) + { + return c.less (v); + } + + template + friend query_base + operator> (const query_column& c, val_bind v) + { + return c.greater (val_bind (T (v.val))); + } + + template + friend query_base + operator> (val_bind v, const query_column& c) + { + return c.less (val_bind (T (v.val))); + } + + friend query_base + operator> (const query_column& c, ref_bind r) + { + return c.greater (r); + } + + friend query_base + operator> (ref_bind r, const query_column& c) + { + return c.less (r); + } + + // <= + // + public: + query_base + less_equal (val_bind v) const + { + query_base q (native_info); + q.append_val (v.val, native_info); + q.append (query_base::clause_part::op_le, 0); + return q; + } + + query_base + less_equal (ref_bind r) const + { + query_base q (native_info); + q.append_ref (r.ptr (), native_info); + q.append (query_base::clause_part::op_le, 0); + return q; + } + + friend query_base + operator<= (const query_column& c, const T& v) + { + return c.less_equal (val_bind (v)); + } + + friend query_base + operator<= (const T& v, const query_column& c) + { + return c.greater_equal (val_bind (v)); + } + + friend query_base + operator<= (const query_column& c, val_bind v) + { + return c.less_equal (v); + } + + friend query_base + operator<= (val_bind v, const query_column& c) + { + return c.greater_equal (v); + } + + template + friend query_base + operator<= (const query_column& c, val_bind v) + { + return c.less_equal (val_bind (T (v.val))); + } + + template + friend query_base + operator<= (val_bind v, const query_column& c) + { + return c.greater_equal (val_bind (T (v.val))); + } + + friend query_base + operator<= (const query_column& c, ref_bind r) + { + return c.less_equal (r); + } + + friend query_base + operator<= (ref_bind r, const query_column& c) + { + return c.greater_equal (r); + } + + // >= + // + public: + query_base + greater_equal (val_bind v) const + { + query_base q (native_info); + q.append_val (v.val, native_info); + q.append (query_base::clause_part::op_ge, 0); + return q; + } + + query_base + greater_equal (ref_bind r) const + { + query_base q (native_info); + q.append_ref (r.ptr (), native_info); + q.append (query_base::clause_part::op_ge, 0); + return q; + } + + friend query_base + operator>= (const query_column& c, const T& v) + { + return c.greater_equal (val_bind (v)); + } + + friend query_base + operator>= (const T& v, const query_column& c) + { + return c.less_equal (val_bind (v)); + } + + friend query_base + operator>= (const query_column& c, val_bind v) + { + return c.greater_equal (v); + } + + friend query_base + operator>= (val_bind v, const query_column& c) + { + return c.less_equal (v); + } + + template + friend query_base + operator>= (const query_column& c, val_bind v) + { + return c.greater_equal (val_bind (T (v.val))); + } + + template + friend query_base + operator>= (val_bind v, const query_column& c) + { + return c.less_equal (val_bind (T (v.val))); + } + + friend query_base + operator>= (const query_column& c, ref_bind r) + { + return c.greater_equal (r); + } + + friend query_base + operator>= (ref_bind r, const query_column& c) + { + return c.less_equal (r); + } + + // Column comparison. + // + public: + template + query_base + operator== (const query_column& c) const + { + // We can compare columns only if we can compare their C++ types. + // + (void) (sizeof (type_instance () == type_instance ())); + + query_base q (native_info); + q.append (c.native_info); + q.append (query_base::clause_part::op_eq, 0); + return q; + } + + template + query_base + operator!= (const query_column& c) const + { + // We can compare columns only if we can compare their C++ types. + // + (void) (sizeof (type_instance () != type_instance ())); + + query_base q (native_info); + q.append (c.native_info); + q.append (query_base::clause_part::op_ne, 0); + return q; + } + + template + query_base + operator< (const query_column& c) const + { + // We can compare columns only if we can compare their C++ types. + // + (void) (sizeof (type_instance () < type_instance ())); + + query_base q (native_info); + q.append (c.native_info); + q.append (query_base::clause_part::op_lt, 0); + return q; + } + + template + query_base + operator> (const query_column& c) const + { + // We can compare columns only if we can compare their C++ types. + // + (void) (sizeof (type_instance () > type_instance ())); + + query_base q (native_info); + q.append (c.native_info); + q.append (query_base::clause_part::op_gt, 0); + return q; + } + + template + query_base + operator<= (const query_column& c) const + { + // We can compare columns only if we can compare their C++ types. + // + (void) (sizeof (type_instance () <= type_instance ())); + + query_base q (native_info); + q.append (c.native_info); + q.append (query_base::clause_part::op_le, 0); + return q; + } + + template + query_base + operator>= (const query_column& c) const + { + // We can compare columns only if we can compare their C++ types. + // + (void) (sizeof (type_instance () >= type_instance ())); + + query_base q (native_info); + q.append (c.native_info); + q.append (query_base::clause_part::op_ge, 0); + return q; + } + }; + + // Provide operator+() for using columns to construct native + // query fragments (e.g., ORDER BY). + // + template + inline query_base + operator+ (const query_column& c, const std::string& s) + { + query_base q (c.native_info); + q.append (s); + q.append (query_base::clause_part::op_add, 0); + return q; + } + + template + inline query_base + operator+ (const std::string& s, const query_column& c) + { + query_base q (s); + q.append (c.native_info); + q.append (query_base::clause_part::op_add, 0); + return q; + } + + template + inline query_base + operator+ (const query_column& c, const query_base& q) + { + query_base r (c.native_info); + r.append (q); + r.append (query_base::clause_part::op_add, 0); + return r; + } + + template + inline query_base + operator+ (const query_base& q, const query_column& c) + { + query_base r (q); + r.append (c.native_info); + r.append (query_base::clause_part::op_add, q.clause ().size () - 1); + return r; + } + + // + // + template + class query: public query_base, + public query_selector::columns_type + { + public: + // We don't define any typedefs here since they may clash with + // column names defined by our base type. + // + + query () + { + } + + explicit + query (bool v) + : query_base (v) + { + } + + explicit + query (const char* q) + : query_base (q) + { + } + + explicit + query (const std::string& q) + : query_base (q) + { + } + + query (const query_base& q) + : query_base (q) + { + } + + query (const query_column& qc) + : query_base (qc) + { + } + }; +} + +#include +#include + +#include + +#endif // ODB_QUERY_DYNAMIC_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/query-dynamic.ixx b/third-party/odb/libodb-2.4.0/odb/query-dynamic.ixx new file mode 100755 index 0000000..9686ba4 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/query-dynamic.ixx @@ -0,0 +1,19 @@ +// file : odb/query-dynamic.ixx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +namespace odb +{ + // query_base + // + inline query_base:: + query_base (const query_column& c) + { + // Some databases provide the IS TRUE operator. However, we cannot + // use it since the column type might now be SQL boolean type. + // + append (c.native_info); + append_val (true, c.native_info); + append (query_base::clause_part::op_eq, 0); + } +} diff --git a/third-party/odb/libodb-2.4.0/odb/query-dynamic.txx b/third-party/odb/libodb-2.4.0/odb/query-dynamic.txx new file mode 100755 index 0000000..bc40d4b --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/query-dynamic.txx @@ -0,0 +1,140 @@ +// file : odb/query-dynamic.txx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +namespace odb +{ + // + // query_base + // + + template + void query_base:: + append_val (const T& val, const native_column_info* c) + { + clause_.push_back (clause_part ()); + clause_part& p (clause_.back ()); + + p.kind = clause_part::kind_param_val; + p.data = 0; // In case new below throws. + p.native_info = c; + + query_param* qp (new (details::shared) val_query_param (val)); + p.data = reinterpret_cast (qp); + } + + // + // query_column + // + + // in + // + template + query_base query_column:: + in (const T& v1, const T& v2) const + { + query_base q (native_info); + q.append_val (v1, native_info); + q.append_val (v2, native_info); + q.append (query_base::clause_part::op_in, 2); + return q; + } + + template + query_base query_column:: + in (const T& v1, const T& v2, const T& v3) const + { + query_base q (native_info); + q.append_val (v1, native_info); + q.append_val (v2, native_info); + q.append_val (v3, native_info); + q.append (query_base::clause_part::op_in, 3); + return q; + } + + template + query_base query_column:: + in (const T& v1, const T& v2, const T& v3, const T& v4) const + { + query_base q (native_info); + q.append_val (v1, native_info); + q.append_val (v2, native_info); + q.append_val (v3, native_info); + q.append_val (v4, native_info); + q.append (query_base::clause_part::op_in, 4); + return q; + } + + template + query_base query_column:: + in (const T& v1, const T& v2, const T& v3, const T& v4, const T& v5) const + { + query_base q (native_info); + q.append_val (v1, native_info); + q.append_val (v2, native_info); + q.append_val (v3, native_info); + q.append_val (v4, native_info); + q.append_val (v5, native_info); + q.append (query_base::clause_part::op_in, 5); + return q; + } + + template + template + query_base query_column:: + in_range (I i, I end) const + { + query_base q (native_info); + + std::size_t n (0); + for (; i != end; ++i, ++n) + q.append_val (*i, native_info); // Force implicit conversion. + + q.append (query_base::clause_part::op_in, n); + return q; + } + + // like + // + template + query_base query_column:: + like (val_bind p) const + { + query_base q (native_info); + q.append_val (p.val, native_info); + q.append (query_base::clause_part::op_like, 0); + return q; + } + + template + query_base query_column:: + like (ref_bind p) const + { + query_base q (native_info); + q.append_ref (p.ptr (), native_info); + q.append (query_base::clause_part::op_like, 0); + return q; + } + + template + query_base query_column:: + like (val_bind p, const T& e) const + { + query_base q (native_info); + q.append_val (p.val, native_info); + q.append_val (e, native_info); + q.append (query_base::clause_part::op_like_escape, 0); + return q; + } + + template + query_base query_column:: + like (ref_bind p, const T& e) const + { + query_base q (native_info); + q.append_ref (p.ptr (), native_info); + q.append_val (e, native_info); + q.append (query_base::clause_part::op_like_escape, 0); + return q; + } +} diff --git a/third-party/odb/libodb-2.4.0/odb/query.hxx b/third-party/odb/libodb-2.4.0/odb/query.hxx new file mode 100755 index 0000000..6f1a430 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/query.hxx @@ -0,0 +1,120 @@ +// file : odb/query.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_QUERY_HXX +#define ODB_QUERY_HXX + +#include + +#include +#include + +namespace odb +{ + // Table alias for type T and tag Tag. + // + // The alias_traits interface consists of two things: the table_name + // static variable containing the name and, in case of a derived type + // in a polymorphic hierarchy, the base_traits typedef. Note that the + // same interface is exposed by object_traits, which is used when + // we need straight tables instead of aliases. + // + // + template + struct alias_traits; + + template + struct query_columns_base; + + template + struct query_columns; + + template + struct pointer_query_columns; + + // Object pointer syntax wrapper. + // + template + struct query_pointer + { + query_pointer () + { + // For some reason GCC needs this dummy c-tor if we make a static + // data member of this type const. + } + + T* + operator-> () const + { + return 0; // All members in T are static. + } + }; + + // Query parameter decay traits. + // + template + struct decay_traits + { + typedef const T& type; + + static type + instance (); + }; + + template + struct decay_traits + { + typedef const T* type; + + // Use the pointer comparability as a proxy for data comparability. + // Note that it is stricter than using element comparability (i.e., + // one can compare int to char but not int* to char*). + // + static type + instance (); + }; + + // VC9 cannot handle certain cases of non-type arguments with default + // values in template functions (e.g., database::query()). As a result, + // we have to use the impl trick below instead of simply having kind + // as a second template argument with a default value. + // + template + struct query_selector_impl; + + template + struct query_selector_impl + { + typedef typename object_traits_impl::query_base_type base_type; + + typedef + query_columns > + columns_type; + }; + + template + struct query_selector_impl + { + typedef typename view_traits_impl::query_base_type base_type; + typedef typename view_traits_impl::query_columns columns_type; + }; + + template + struct query_selector: query_selector_impl::kind> + { + }; + + template ::base_type> + class query; + + namespace core + { + using odb::query; + } +} + +#include + +#endif // ODB_QUERY_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/result.cxx b/third-party/odb/libodb-2.4.0/odb/result.cxx new file mode 100755 index 0000000..6aa46bc --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/result.cxx @@ -0,0 +1,41 @@ +// file : odb/result.cxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include +#include + +namespace odb +{ + result_impl:: + ~result_impl () + { + if (next_ != this) + list_remove (); + } + + result_impl:: + result_impl (connection& c) + : db_ (c.database ()), conn_ (c), prev_ (0), next_ (this) + { + // Add to the list. + // + next_ = conn_.results_; + conn_.results_ = this; + + if (next_ != 0) + next_->prev_ = this; + } + + void result_impl:: + list_remove () + { + (prev_ == 0 ? conn_.results_ : prev_->next_) = next_; + + if (next_ != 0) + next_->prev_ = prev_; + + prev_ = 0; + next_ = this; + } +} diff --git a/third-party/odb/libodb-2.4.0/odb/result.hxx b/third-party/odb/libodb-2.4.0/odb/result.hxx new file mode 100755 index 0000000..c40f984 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/result.hxx @@ -0,0 +1,246 @@ +// file : odb/result.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_RESULT_HXX +#define ODB_RESULT_HXX + +#include + +#include // std::ptrdiff_t, std::size_t + +#include // odb::core +#include + +#include +#include + +namespace odb +{ + class LIBODB_EXPORT result_impl: public details::shared_base + { + public: + virtual + ~result_impl (); + + virtual void + invalidate () = 0; + + protected: + result_impl (connection&); + + protected: + database& db_; + connection& conn_; + + // Doubly-linked list of results. + // + // prev_ == 0 means we are the first element. + // next_ == 0 means we are the last element. + // next_ == this means we are not on the list. + // + protected: + friend class connection; + + void + list_remove (); + + result_impl* prev_; + result_impl* next_; + }; + + template + class result_base; + + template ::kind> + class result_iterator; + + // Input iterator requirements. + // + template + inline bool + operator== (result_iterator i, result_iterator j) + { + return i.equal (j); + } + + template + inline bool + operator!= (result_iterator i, result_iterator j) + { + return !i.equal (j); + } + + template + class result: result_base::kind> + { + public: + static const class_kind kind = class_traits::kind; + + typedef result_base base; + + typedef typename base::value_type value_type; + typedef value_type* pointer; + typedef const value_type* const_pointer; + typedef value_type& reference; + typedef const value_type& const_reference; + + typedef result_iterator iterator; + + typedef std::size_t size_type; + typedef std::ptrdiff_t difference_type; + + typedef typename base::result_impl_type result_impl_type; + + public: + result () + { + } + + explicit + result (details::shared_ptr impl) + : impl_ (impl) + { + } + + // Copying or assignment of a result instance leads to one instance + // being an alias for another. Think of copying a result as copying + // a file handle -- the file you access through either of them is + // still the same. + // + public: + result (const result& r) + : impl_ (r.impl_) + { + } + + result& + operator= (const result& r) + { + if (impl_ != r.impl_) + impl_ = r.impl_; + + return *this; + } + + // Conversion from result to result. + // + template + result (const result& r) + // + // If you get a compiler error pointing to the line below saying + // that the impl_ member is inaccessible, then you are most likely + // trying to perform an illegal result conversion, for example, + // from result to result. + // + : impl_ (r.impl_) + { + } + + template + result& + operator= (const result& r) + { + // If you get a compiler error pointing to the line below saying + // that the impl_ member is inaccessible, then you are most likely + // trying to perform an illegal result conversion, for example, + // from result to result. + // + if (impl_ != r.impl_) + impl_ = r.impl_; + + return *this; + } + + void + swap (result& r) + { + // @@ add swap() to shared_ptr. + // + details::shared_ptr p (impl_); + impl_ = r.impl_; + r.impl_ = p; + } + + public: + iterator + begin () + { + if (impl_) + impl_->begin (); + + return iterator (impl_.get ()); + } + + iterator + end () + { + return iterator (); + } + + // Cache the result instead of fetching the data from the database + // one row at a time. This is necessary if you plan on performing + // database operations while iterating over the result. + // + public: + void + cache () + { + if (impl_) + impl_->cache (); + } + + public: + bool + empty () const + { + if (impl_ == 0) + return true; + + impl_->begin (); + return impl_->end (); + } + + // Size is only known in cached results. + // + size_type + size () const + { + return impl_ ? impl_->size () : 0; + } + + // query_one() and query_value() implementation details. + // + public: + typename object_traits::pointer_type + one (); + + bool + one (T&); + + // We cannot return by value here since result can be instantiated + // for an abstract type (polymorphic abstract base) and it seems + // the signature must be valid to the point being able to call the + // necessary constructors. + // + void + value (T&); + + private: + friend class result; + + details::shared_ptr impl_; + }; + + namespace common + { + using odb::result; + using odb::result_iterator; + } +} + +#include + +#include + +#endif // ODB_RESULT_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/result.txx b/third-party/odb/libodb-2.4.0/odb/result.txx new file mode 100755 index 0000000..da6da3e --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/result.txx @@ -0,0 +1,52 @@ +// file : odb/result.txx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include + +namespace odb +{ + template + typename object_traits::pointer_type result:: + one () + { + typedef typename object_traits::pointer_type pointer_type; + + iterator i (begin ()); + + if (i != end ()) + { + pointer_type o (i.load ()); + assert (++i == end ()); // More than one element in query_one() result. + return o; + } + + return pointer_type (); + } + + template + bool result:: + one (T& o) + { + iterator i (begin ()); + + if (i != end ()) + { + i.load (o); + assert (++i == end ()); // More than one element in query_one() result. + return true; + } + + return false; + } + + template + void result:: + value (T& o) + { + iterator i (begin ()); + assert (i != end ()); // Zero elements in query_value() result. + i.load (o); + assert (++i == end ()); // More than one element in query_value() result. + } +} diff --git a/third-party/odb/libodb-2.4.0/odb/schema-catalog-impl.hxx b/third-party/odb/libodb-2.4.0/odb/schema-catalog-impl.hxx new file mode 100755 index 0000000..38ed4cd --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/schema-catalog-impl.hxx @@ -0,0 +1,55 @@ +// file : odb/schema-catalog-impl.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_SCHEMA_CATALOG_IMPL_HXX +#define ODB_SCHEMA_CATALOG_IMPL_HXX + +#include + +#include + +#include // schema_version + +#include + +namespace odb +{ + struct schema_catalog_impl; + + // Translation unit initializer. + // + struct LIBODB_EXPORT schema_catalog_init + { + static schema_catalog_impl* catalog; + static std::size_t count; + + schema_catalog_init (); + ~schema_catalog_init (); + }; + + static const schema_catalog_init schema_catalog_init_; + + // Catalog entry registration. + // + struct LIBODB_EXPORT schema_catalog_create_entry + { + schema_catalog_create_entry ( + database_id, + const char* name, + bool (*create_function) (database&, unsigned short pass, bool drop)); + }; + + struct LIBODB_EXPORT schema_catalog_migrate_entry + { + schema_catalog_migrate_entry ( + database_id, + const char* name, + schema_version, + bool (*migrate_function) (database&, unsigned short pass, bool pre)); + }; +} + +#include + +#endif // ODB_SCHEMA_CATALOG_IMPL_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/schema-catalog.cxx b/third-party/odb/libodb-2.4.0/odb/schema-catalog.cxx new file mode 100755 index 0000000..cd49413 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/schema-catalog.cxx @@ -0,0 +1,385 @@ +// file : odb/schema-catalog.cxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include +#include +#include + +#include +#include +#include + +using namespace std; + +namespace odb +{ + // Schema. + // + typedef bool (*create_function) (database&, unsigned short pass, bool drop); + typedef bool (*migrate_function) (database&, unsigned short pass, bool pre); + + typedef pair key; + typedef vector create_functions; + typedef vector migrate_functions; + typedef map version_map; + + struct schema_functions + { + create_functions create; + version_map migrate; + }; + typedef map schema_map; + + // Data. Normally the code would be database-independent, though there + // could be database-specific migration steps. + // + typedef pair data_key; + + struct data_function + { + typedef schema_catalog::data_migration_function_wrapper + function_wrapper_type; + + data_function () {} + data_function (database_id i, function_wrapper_type m) + : id (i), migrate (m) {} + + database_id id; + function_wrapper_type migrate; + }; + typedef vector data_functions; + typedef map data_map; + + struct schema_catalog_impl + { + schema_map schema; + data_map data; + }; + + // Static initialization. + // + schema_catalog_impl* schema_catalog_init::catalog = 0; + size_t schema_catalog_init::count = 0; + + struct schema_catalog_init_extra + { + bool initialized; + + schema_catalog_init_extra (): initialized (false) {} + ~schema_catalog_init_extra () + { + if (initialized && --schema_catalog_init::count == 0) + delete schema_catalog_init::catalog; + } + }; + + static schema_catalog_init_extra schema_catalog_init_extra_; + + bool schema_catalog:: + exists (database_id id, const string& name) + { + const schema_catalog_impl& c (*schema_catalog_init::catalog); + return c.schema.find (key (id, name)) != c.schema.end (); + } + + void schema_catalog:: + create_schema (database& db, const string& name, bool drop) + { + const schema_catalog_impl& c (*schema_catalog_init::catalog); + schema_map::const_iterator i (c.schema.find (key (db.id (), name))); + + if (i == c.schema.end ()) + throw unknown_schema (name); + + const create_functions& fs (i->second.create); + + if (drop) + drop_schema (db, name); + + // Run the passes until we ran them all or all the functions + // return false, which means no more passes necessary. + // + for (unsigned short pass (1); pass < 3; ++pass) + { + bool done (true); + + for (create_functions::const_iterator j (fs.begin ()), e (fs.end ()); + j != e; ++j) + { + if ((*j) (db, pass, false)) + done = false; + } + + if (done) + break; + } + } + + void schema_catalog:: + drop_schema (database& db, const string& name) + { + const schema_catalog_impl& c (*schema_catalog_init::catalog); + schema_map::const_iterator i (c.schema.find (key (db.id (), name))); + + if (i == c.schema.end ()) + throw unknown_schema (name); + + const create_functions& fs (i->second.create); + + // Run the passes until we ran them all or all the functions + // return false, which means no more passes necessary. + // + for (unsigned short pass (1); pass < 3; ++pass) + { + bool done (true); + + for (create_functions::const_iterator j (fs.begin ()), e (fs.end ()); + j != e; ++j) + { + if ((*j) (db, pass, true)) + done = false; + } + + if (done) + break; + } + } + + void schema_catalog:: + migrate_schema_impl (database& db, + schema_version v, + const string& name, + migrate_mode m) + { + const schema_catalog_impl& c (*schema_catalog_init::catalog); + schema_map::const_iterator i (c.schema.find (key (db.id (), name))); + + if (i == c.schema.end ()) + throw unknown_schema (name); + + const version_map& vm (i->second.migrate); + version_map::const_iterator j (vm.find (v)); + + if (j == vm.end ()) + throw unknown_schema_version (v); + + const migrate_functions& fs (j->second); + + // Run the passes until we ran them all or all the functions + // return false, which means no more passes necessary. + // + for (bool pre (m != migrate_post);; pre = false) + { + for (unsigned short pass (1); pass < 3; ++pass) + { + bool done (true); + + for (migrate_functions::const_iterator i (fs.begin ()), e (fs.end ()); + i != e; ++i) + { + if ((*i) (db, pass, pre)) + done = false; + } + + if (done) + break; + } + + if (!pre || m != migrate_both) + break; + } + + // Update the schema version on the database instance. + // + db.schema_version_migration (v, m == migrate_pre, name); + } + + size_t schema_catalog:: + migrate_data (database& db, schema_version v, const string& name) + { + if (v == 0) + { + if (!db.schema_migration ()) + return 0; + + v = db.schema_version (); + } + + const schema_catalog_impl& c (*schema_catalog_init::catalog); + data_map::const_iterator i (c.data.find (data_key (name, v))); + + if (i == c.data.end ()) + return 0; // No data migration for this schema/version. + + size_t r (0); + + const data_functions& df (i->second); + for (data_functions::const_iterator i (df.begin ()), e (df.end ()); + i != e; ++i) + { + if (i->id == id_common || i->id == db.id ()) + { + const data_migration_function_wrapper &m = i->migrate; + + if (m.std_function == 0) + m.function (db); + else + { + typedef void (*caller) (const void*, database&); + reinterpret_cast (m.function) (m.std_function, db); + } + r++; + } + } + + return r; + } + + void schema_catalog:: + data_migration_function (database_id id, + schema_version v, + data_migration_function_wrapper f, + const string& name) + { + // This function can be called from a static initializer in which + // case the catalog might not have yet been created. + // + if (schema_catalog_init::count == 0) + { + schema_catalog_init::catalog = new schema_catalog_impl; + ++schema_catalog_init::count; + schema_catalog_init_extra_.initialized = true; + } + + schema_catalog_impl& c (*schema_catalog_init::catalog); + c.data[data_key (name, v)].push_back (data_function (id, f)); + } + + void schema_catalog:: + migrate (database& db, schema_version v, const string& name) + { + schema_version cur (current_version (db, name)); + + if (v == 0) + v = cur; + else if (v > cur) + throw unknown_schema_version (v); + + schema_version i (db.schema_version (name)); + + // If there is no schema, then "migrate" by creating it. + // + if (i == 0) + { + // Schema creation can only "migrate" straight to current. + // + if (v != cur) + throw unknown_schema_version (v); + + create_schema (db, name, false); + return; + } + + for (i = next_version (db, i, name); + i <= v; + i = next_version (db, i, name)) + { + migrate_schema_pre (db, i, name); + migrate_data (db, i, name); + migrate_schema_post (db, i, name); + } + } + + schema_version schema_catalog:: + base_version (database_id id, const string& name) + { + const schema_catalog_impl& c (*schema_catalog_init::catalog); + schema_map::const_iterator i (c.schema.find (key (id, name))); + + if (i == c.schema.end ()) + throw unknown_schema (name); + + const version_map& vm (i->second.migrate); + assert (!vm.empty ()); + return vm.begin ()->first; + } + + schema_version schema_catalog:: + current_version (database_id id, const string& name) + { + const schema_catalog_impl& c (*schema_catalog_init::catalog); + schema_map::const_iterator i (c.schema.find (key (id, name))); + + if (i == c.schema.end ()) + throw unknown_schema (name); + + const version_map& vm (i->second.migrate); + assert (!vm.empty ()); + return vm.rbegin ()->first; + } + + schema_version schema_catalog:: + next_version (database_id id, schema_version v, const string& name) + { + const schema_catalog_impl& sc (*schema_catalog_init::catalog); + schema_map::const_iterator i (sc.schema.find (key (id, name))); + + if (i == sc.schema.end ()) + throw unknown_schema (name); + + const version_map& vm (i->second.migrate); // Cannot be empty. + + schema_version b (vm.begin ()->first); + schema_version c (vm.rbegin ()->first); + + if (v == 0) + return c; // "Migration" to the current via schema creation. + else if (v < b) + throw unknown_schema_version (v); // Unsupported migration. + + version_map::const_iterator j (vm.upper_bound (v)); + return j != vm.end () ? j->first : c + 1; + } + + // schema_catalog_init + // + schema_catalog_init:: + schema_catalog_init () + { + if (count == 0) + catalog = new schema_catalog_impl; + + ++count; + } + + schema_catalog_init:: + ~schema_catalog_init () + { + if (--count == 0) + delete catalog; + } + + // schema_catalog_create_entry + // + schema_catalog_create_entry:: + schema_catalog_create_entry (database_id id, + const char* name, + create_function cf) + { + schema_catalog_impl& c (*schema_catalog_init::catalog); + c.schema[key(id, name)].create.push_back (cf); + } + + // schema_catalog_migrate_entry + // + schema_catalog_migrate_entry:: + schema_catalog_migrate_entry (database_id id, + const char* name, + schema_version v, + migrate_function mf) + { + schema_catalog_impl& c (*schema_catalog_init::catalog); + c.schema[key(id, name)].migrate[v].push_back (mf); + } +} diff --git a/third-party/odb/libodb-2.4.0/odb/schema-catalog.hxx b/third-party/odb/libodb-2.4.0/odb/schema-catalog.hxx new file mode 100755 index 0000000..c9e2d0e --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/schema-catalog.hxx @@ -0,0 +1,393 @@ +// file : odb/schema-catalog.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_SCHEMA_CATALOG_HXX +#define ODB_SCHEMA_CATALOG_HXX + +#include + +#include // ODB_CXX11 + +#include +#include // std::size_t + +#ifdef ODB_CXX11 +# include // std::move +# include // std::function +# include // std::enable_if, std::is_convertible +#endif + +#include // schema_version, odb::core +#include + +#include +#include +#include + +namespace odb +{ + class LIBODB_EXPORT schema_catalog + { + public: + // Schema creation. + // + static void + create_schema (database&, const std::string& name = "", bool drop = true); + + static void + drop_schema (database&, const std::string& name = ""); + + // Schema migration. + // + public: + static void + migrate_schema_pre (database& db, + schema_version v, + const std::string& name = "") + { + migrate_schema_impl (db, v, name, migrate_pre); + } + + static void + migrate_schema_post (database& db, + schema_version v, + const std::string& name = "") + { + migrate_schema_impl (db, v, name, migrate_post); + } + + static void + migrate_schema (database& db, + schema_version v, + const std::string& name = "") + { + migrate_schema_impl (db, v, name, migrate_both); + } + + // Data migration. + // + public: + // If version is 0, then use the current database version and also + // check whether we are in migration. Returns the number of calls made. + // + static std::size_t + migrate_data (database&, + schema_version = 0, + const std::string& name = ""); + + typedef void data_migration_function_type (database&); + typedef data_migration_function_type* data_migration_function_ptr; + + typedef details::function_wrapper + data_migration_function_wrapper; + + // The following three variants of the registration functions make + // sure that the version is greater that the base model version. + // This helps with identifying and removing data migration function + // that are no longer required. + // + // Data migration functions are called in the order of registration. + // +#ifndef ODB_CXX11 + template + static void + data_migration_function (data_migration_function_ptr f, + const std::string& name = "") + { + data_migration_function (id_common, f, name); + } + +#else + template + static typename std::enable_if< + std::is_convertible< + F, std::function>::value, void>::type + data_migration_function (F f, const std::string& name = "") + { + data_migration_function (id_common, std::move (f), name); + } +#endif + + // Database-specific data migration. + // +#ifndef ODB_CXX11 + template + static void + data_migration_function (database& db, + data_migration_function_ptr f, + const std::string& name = "") + { + data_migration_function (db.id (), f, name); + } +#else + template + static typename std::enable_if< + std::is_convertible< + F, std::function>::value, void>::type + data_migration_function (database& db, F f, const std::string& name = "") + { + data_migration_function (db.id (), std::move (f), name); + } +#endif + +#ifndef ODB_CXX11 + template + static void + data_migration_function (database_id id, + data_migration_function_ptr f, + const std::string& name = "") + { + // If the data migration version is below the base model version + // then it will never be called. + // + + // Poor man's static_assert. + // + typedef details::meta::static_assert_test<(v > base || base == 0)> + data_migration_function_is_no_longer_necessary; + + char sa [sizeof (data_migration_function_is_no_longer_necessary)]; + ODB_POTENTIALLY_UNUSED (sa); + + data_migration_function (id, v, f, name); + } +#else + template + static typename std::enable_if< + std::is_convertible< + F, std::function>::value, void>::type + data_migration_function (database_id id, F f, const std::string& name = "") + { + // If the data migration version is below the base model version + // then it will never be called. + // + static_assert (v > base || base == 0, + "data migration function is no longer necessary"); + + data_migration_function (id, v, std::move (f), name); + } +#endif + + // The same as above but take the version as an argument and do + // not check whether it is greater than the base model version. + // +#ifndef ODB_CXX11 + static void + data_migration_function (schema_version v, + data_migration_function_ptr f, + const std::string& name = "") + { + data_migration_function (id_common, v, f, name); + } +#else + template + static typename std::enable_if< + std::is_convertible< + F, std::function>::value, void>::type + data_migration_function (schema_version v, + F f, + const std::string& name = "") + { + data_migration_function (id_common, v, std::move (f), name); + } +#endif + +#ifndef ODB_CXX11 + static void + data_migration_function (database& db, + schema_version v, + data_migration_function_ptr f, + const std::string& name = "") + { + data_migration_function (db.id (), v, f, name); + } +#else + template + static typename std::enable_if< + std::is_convertible< + F, std::function>::value, void>::type + data_migration_function (database& db, + schema_version v, + F f, + const std::string& name = "") + { + data_migration_function (db.id (), v, std::move (f), name); + } +#endif + +#ifndef ODB_CXX11 + static void + data_migration_function (database_id i, + schema_version v, + data_migration_function_ptr f, + const std::string& name = "") + { + data_migration_function (i, + v, + data_migration_function_wrapper (f), + name); + } +#else + template + static typename std::enable_if< + std::is_convertible< + F, std::function>::value, void>::type + data_migration_function (database_id i, + schema_version v, + F f, + const std::string& name = "") + { + data_migration_function ( + i, + v, + data_migration_function_wrapper (std::move (f)), + name); + } +#endif + + private: + static void + data_migration_function (database_id, + schema_version, + data_migration_function_wrapper, + const std::string& name); + + // Combined schema and data migration. + // + public: + // Migrate both schema and data to the specified version. If version + // is not specified, then migrate to the current model version. + // + static void + migrate (database&, schema_version = 0, const std::string& name = ""); + + // Schema version information. + // + public: + // Return the base model version. + // + static schema_version + base_version (const database& db, const std::string& name = "") + { + return base_version (db.id (), name); + } + + static schema_version + base_version (database_id, const std::string& name = ""); + + // Return the current model version. + // + static schema_version + current_version (const database& db, const std::string& name = "") + { + return current_version (db.id (), name); + } + + static schema_version + current_version (database_id, const std::string& name = ""); + + // Return current model version + 1 (that is, one past current) if + // the passed version is equal to or greater than current. If the + // version is not specified, then use the current database version. + // + static schema_version + next_version (const database& db, + schema_version v = 0, + const std::string& name = "") + { + return next_version (db.id (), v == 0 ? db.schema_version () : v, name); + } + + static schema_version + next_version (database_id, + schema_version, + const std::string& name = ""); + + // Schema existence. + // + public: + // Test for presence of a schema with a specific name. + // + static bool + exists (const database& db, const std::string& name = "") + { + return exists (db.id (), name); + } + + static bool + exists (database_id, const std::string& name = ""); + + private: + enum migrate_mode + { + migrate_pre, + migrate_post, + migrate_both + }; + + static void + migrate_schema_impl (database&, + schema_version, + const std::string& name, + migrate_mode); + }; + + // Static data migration function registration. + // + template + struct data_migration_entry + { + typedef schema_catalog::data_migration_function_type function_type; + +#ifndef ODB_CXX11 + data_migration_entry (function_type* f, const std::string& name = "") + { + schema_catalog::data_migration_function (f, name); + } +#else + template + data_migration_entry (F f, + const std::string& name = "", + typename std::enable_if>::value> + ::type* = 0) + { + schema_catalog::data_migration_function (std::move (f), name); + } +#endif + +#ifndef ODB_CXX11 + data_migration_entry (database_id id, + function_type *f, + const std::string& name = "") + { + schema_catalog::data_migration_function (id, v, f, name); + } +#else + template + data_migration_entry (database_id id, + F f, + const std::string& name = "", + typename std::enable_if>::value> + ::type* = 0) + { + schema_catalog::data_migration_function (id, + v, + std::move (f), + name); + } +#endif + }; + + namespace common + { + using odb::schema_catalog; + using odb::data_migration_entry; + } +} + +#include + +#endif // ODB_SCHEMA_CATALOG_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/schema-version.hxx b/third-party/odb/libodb-2.4.0/odb/schema-version.hxx new file mode 100755 index 0000000..f58692f --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/schema-version.hxx @@ -0,0 +1,73 @@ +// file : odb/schema-version.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_SCHEMA_VERSION_HXX +#define ODB_SCHEMA_VERSION_HXX + +#include + +#include // schema_version +#include + +namespace odb +{ + struct LIBODB_EXPORT schema_version_migration + { + schema_version_migration (schema_version v = 0, bool m = false) + : version (v), migration (m) {} + + schema_version version; + bool migration; + }; + + // Version ordering is as follows: {1,f} < {2,t} < {2,f} < {3,t} + // + inline bool + operator== (const schema_version_migration& x, + const schema_version_migration& y) + { + return x.version == y.version && x.migration == y.migration; + } + + inline bool + operator!= (const schema_version_migration& x, + const schema_version_migration& y) + { + return !(x == y); + } + + inline bool + operator< (const schema_version_migration& x, + const schema_version_migration& y) + { + return x.version < y.version || + (x.version == y.version && x.migration && !y.migration); + } + + inline bool + operator> (const schema_version_migration& x, + const schema_version_migration& y) + { + return x.version > y.version || + (x.version == y.version && !x.migration && y.migration); + } + + inline bool + operator<= (const schema_version_migration& x, + const schema_version_migration& y) + { + return !(x > y); + } + + inline bool + operator>= (const schema_version_migration& x, + const schema_version_migration& y) + { + return !(x < y); + } +} + +#include + +#endif // ODB_SCHEMA_VERSION_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/section.cxx b/third-party/odb/libodb-2.4.0/odb/section.cxx new file mode 100755 index 0000000..80bfc91 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/section.cxx @@ -0,0 +1,28 @@ +// file : odb/section.cxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include + +namespace odb +{ + void section:: + disarm () + { + transaction& t (transaction::current ()); + t.callback_unregister (this); + state_.armed = 0; + } + + void section:: + transacion_callback (unsigned short event, void* key, unsigned long long) + { + section& s (*static_cast (key)); + + if (event == transaction::event_rollback && s.state_.restore) + s.state_.changed = 1; + + s.state_.armed = 0; + s.state_.restore = 0; + } +} diff --git a/third-party/odb/libodb-2.4.0/odb/section.hxx b/third-party/odb/libodb-2.4.0/odb/section.hxx new file mode 100755 index 0000000..990dd32 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/section.hxx @@ -0,0 +1,114 @@ +// file : odb/section.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_SECTION_HXX +#define ODB_SECTION_HXX + +#include + +#include +#include + +namespace odb +{ + class LIBODB_EXPORT section + { + public: + // Load state. + // + bool + loaded () const {return state_.loaded;} + + // Mark a loaded section as not loaded. This, for example, can be + // useful if you don't want the section to be reloaded during the + // object reload. + // + void + unload () + { + state_.loaded = 0; + state_.changed = 0; + state_.restore = 0; + } + + // Change state. + // + bool + changed () const {return state_.changed;} + + // Mark the section as changed. + // + void + change () + { + state_.changed = 1; + state_.restore = 0; + } + + // User data. 4 bits of custom state. + // + unsigned char + user_data () const {return state_.user;} + + void + user_data (unsigned char u) {state_.user = u;} + + public: + section () + { + state_.loaded = 0; + state_.changed = 0; + state_.armed = 0; + state_.restore = 0; + } + + ~section () + { + if (state_.armed) + disarm (); + } + + // Implementation details. + // + public: + // Arm the callback and set the restore flag if transaction is not NULL. + // + void + reset (bool l = false, bool c = false, transaction* t = 0) const + { + state_.loaded = l; + state_.changed = c; + + if (t != 0 && !state_.armed) + { + t->callback_register (&transacion_callback, + const_cast (this)); + state_.armed = 1; + } + + state_.restore = (t != 0); + } + + private: + void + disarm (); + + static void + transacion_callback (unsigned short, void* key, unsigned long long); + + private: + mutable struct + { + unsigned char loaded : 1; + unsigned char changed : 1; + unsigned char armed : 1; // Transaction callback is armed. + unsigned char restore: 1; // Restore changed flag on rollback. + unsigned char user : 4; // User data. + } state_; + }; +} + +#include + +#endif // ODB_SECTION_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/session.cxx b/third-party/odb/libodb-2.4.0/odb/session.cxx new file mode 100755 index 0000000..ed2e93a --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/session.cxx @@ -0,0 +1,67 @@ +// file : odb/session.cxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include +#include + +#include + +namespace odb +{ + using namespace details; + + static ODB_TLS_POINTER (session) current_session; + + session:: + session (bool make_current) + { + if (make_current) + { + if (has_current ()) + throw already_in_session (); + + current_pointer (this); + } + } + + session:: + ~session () + { + // If we are the current thread's session, reset it. + // + if (current_pointer () == this) + reset_current (); + } + + session* session:: + current_pointer () + { + return tls_get (current_session); + } + + void session:: + current_pointer (session* s) + { + tls_set (current_session, s); + } + + session& session:: + current () + { + session* cur (tls_get (current_session)); + + if (cur == 0) + throw not_in_session (); + + return *cur; + } + + // + // object_map_base + // + session::object_map_base:: + ~object_map_base () + { + } +} diff --git a/third-party/odb/libodb-2.4.0/odb/session.hxx b/third-party/odb/libodb-2.4.0/odb/session.hxx new file mode 100755 index 0000000..377de81 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/session.hxx @@ -0,0 +1,212 @@ +// file : odb/session.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_SESSION_HXX +#define ODB_SESSION_HXX + +#include + +#include +#include + +#include +#include + +#include +#include + +#include + +namespace odb +{ + class LIBODB_EXPORT session + { + public: + typedef odb::database database_type; + + // If the make_current argument is true, then set the current thread's + // session to this session. If another session is already in effect, + // throw the already_in_session exception. + // + session (bool make_current = true); + + // Reset the current thread's session if it is this session. + // + ~session (); + + // Current session. + // + public: + // Return true if there is a session in effect in the current + // thread. + // + static bool + has_current () {return current_pointer () != 0;} + + // Get current thread's session. Throw if no session is in effect. + // + static session& + current (); + + // Set current thread's session. + // + static void + current (session& s) {current_pointer (&s);} + + // Revert to the no session in effect state for the current thread. + // + static void + reset_current () {current_pointer (0);} + + // Pointer versions. + // + static session* + current_pointer (); + + static void + current_pointer (session*); + + // Copying or assignment of sessions is not supported. + // + private: + session (const session&); + session& operator= (const session&); + + public: + struct LIBODB_EXPORT object_map_base: details::shared_base + { + virtual + ~object_map_base (); + }; + + template + struct object_map: object_map_base, + std::map::id_type, + typename object_traits::pointer_type> + { + }; + + // Object cache. + // + public: + // Position in the cache of the inserted element. + // + template + struct cache_position; + + template + cache_position + cache_insert (database_type&, + const typename object_traits::id_type&, + const typename object_traits::pointer_type&); + + template + typename object_traits::pointer_type + cache_find (database_type&, + const typename object_traits::id_type&) const; + + template + void + cache_erase (const cache_position&); + + template + void + cache_erase (database_type&, const typename object_traits::id_type&); + + // Low-level object cache access (iteration, etc). + // + public: + typedef std::map, + details::type_info_comparator> type_map; + + typedef std::map database_map; + + database_map& + map () {return db_map_;} + + const database_map& + map () const {return db_map_;} + + // Static cache API as expected by the rest of ODB. + // + public: + // Position in the cache of the inserted element. The requirements + // for this class template are: default and copy-constructible as + // well as copy-assignable. The default constructor creates an + // empty/NULL position. + // + template + struct cache_position + { + typedef object_map map; + typedef typename map::iterator iterator; + + cache_position (): map_ (0) {} + cache_position (map& m, const iterator& p): map_ (&m), pos_ (p) {} + + cache_position& + operator= (const cache_position& p) + { + // It might not be ok to use an uninitialized iterator on the rhs. + // + if (p.map_ != 0) + pos_ = p.pos_; + map_ = p.map_; + return *this; + } + + map* map_; + iterator pos_; + }; + + // The following cache management functions are all static to + // allow for a custom notion of a current session. The erase() + // function is called to remove the object if the operation + // that caused it to be inserted (e.g., load) failed. + // + template + static cache_position + _cache_insert (database_type&, + const typename object_traits::id_type&, + const typename object_traits::pointer_type&); + + template + static typename object_traits::pointer_type + _cache_find (database_type&, const typename object_traits::id_type&); + + template + static void + _cache_erase (const cache_position&); + + // Notifications. These are called after per-object callbacks for + // post_{persist, load, update, erase} events. + // + template + static void + _cache_persist (const cache_position&) {} + + template + static void + _cache_load (const cache_position&) {} + + template + static void + _cache_update (database_type&, const T&) {} + + template + static void + _cache_erase (database_type&, const typename object_traits::id_type&); + + protected: + database_map db_map_; + }; +} + +#include +#include + +#include + +#endif // ODB_SESSION_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/session.ixx b/third-party/odb/libodb-2.4.0/odb/session.ixx new file mode 100755 index 0000000..9451c9c --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/session.ixx @@ -0,0 +1,61 @@ +// file : odb/session.ixx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include + +namespace odb +{ + template + inline void session:: + cache_erase (const cache_position& p) + { + // @@ Empty maps are not cleaned up by this version of erase. + // + if (p.map_ != 0) + p.map_->erase (p.pos_); + } + + template + inline typename session::cache_position session:: + _cache_insert (database_type& db, + const typename object_traits::id_type& id, + const typename object_traits::pointer_type& obj) + { + if (session* s = current_pointer ()) + return s->cache_insert (db, id, obj); + else + return cache_position (); + } + + template + inline typename object_traits::pointer_type session:: + _cache_find (database_type& db, const typename object_traits::id_type& id) + { + typedef typename object_traits::pointer_type pointer_type; + + if (const session* s = current_pointer ()) + return s->cache_find (db, id); + else + return pointer_type (); + } + + template + inline void session:: + _cache_erase (const cache_position& p) + { + // @@ Empty maps are not cleaned up by this version of erase. + // + if (p.map_ != 0) + p.map_->erase (p.pos_); + } + + template + inline void session:: + _cache_erase (database_type& db, + const typename object_traits::id_type& id) + { + if (session* s = current_pointer ()) + s->cache_erase (db, id); + } +} diff --git a/third-party/odb/libodb-2.4.0/odb/session.txx b/third-party/odb/libodb-2.4.0/odb/session.txx new file mode 100755 index 0000000..2b2ccaa --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/session.txx @@ -0,0 +1,91 @@ +// file : odb/session.txx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +namespace odb +{ + template + typename session::cache_position session:: + cache_insert (database_type& db, + const typename object_traits::id_type& id, + const typename object_traits::pointer_type& obj) + { + type_map& tm (db_map_[&db]); + details::shared_ptr& pom (tm[&typeid (T)]); + + if (!pom) + pom.reset (new (details::shared) object_map); + + object_map& om (static_cast&> (*pom)); + + typename object_map::value_type vt (id, obj); + std::pair::iterator, bool> r (om.insert (vt)); + + // In what situation may we possibly attempt to reinsert the object? + // For example, when the user loads the same object in two different + // instances (i.e., load into a pre-allocated object). In this case + // we should probably update our entries accordingly. + // + if (!r.second) + r.first->second = obj; + + return cache_position (om, r.first); + } + + template + typename object_traits::pointer_type session:: + cache_find (database_type& db, + const typename object_traits::id_type& id) const + { + typedef typename object_traits::pointer_type pointer_type; + + database_map::const_iterator di (db_map_.find (&db)); + + if (di == db_map_.end ()) + return pointer_type (); + + const type_map& tm (di->second); + type_map::const_iterator ti (tm.find (&typeid (T))); + + if (ti == tm.end ()) + return pointer_type (); + + const object_map& om (static_cast&> (*ti->second)); + typename object_map::const_iterator oi (om.find (id)); + + if (oi == om.end ()) + return pointer_type (); + + return oi->second; + } + + template + void session:: + cache_erase (database_type& db, const typename object_traits::id_type& id) + { + database_map::iterator di (db_map_.find (&db)); + + if (di == db_map_.end ()) + return; + + type_map& tm (di->second); + type_map::iterator ti (tm.find (&typeid (T))); + + if (ti == tm.end ()) + return; + + object_map& om (static_cast&> (*ti->second)); + typename object_map::iterator oi (om.find (id)); + + if (oi == om.end ()) + return; + + om.erase (oi); + + if (om.empty ()) + tm.erase (ti); + + if (tm.empty ()) + db_map_.erase (di); + } +} diff --git a/third-party/odb/libodb-2.4.0/odb/simple-object-result.hxx b/third-party/odb/libodb-2.4.0/odb/simple-object-result.hxx new file mode 100755 index 0000000..925896e --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/simple-object-result.hxx @@ -0,0 +1,196 @@ +// file : odb/simple-object-result.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_SIMPLE_OBJECT_RESULT_HXX +#define ODB_SIMPLE_OBJECT_RESULT_HXX + +#include + +#include // std::size_t +#include // std::move + +#include +#include +#include +#include +#include + +#include // ODB_CXX11 + +namespace odb +{ + // Implementation for non-polymorphic objects with object id. + // + template + class object_result_impl: public result_impl + { + protected: + // In result_impl, T is always non-const and the same as object_type. + // + typedef T object_type; + typedef odb::object_traits object_traits; + typedef typename object_traits::id_type id_type; + + typedef typename object_traits::pointer_type pointer_type; + typedef odb::pointer_traits pointer_traits; + + friend class result; + friend class result; + friend class result_iterator; + friend class result_iterator; + friend class object_result_iterator; + friend class object_result_iterator; + + protected: + object_result_impl (odb::connection& conn) + : result_impl (conn), begin_ (true), end_ (false), current_ () + { + } + + // To make this work with all kinds of pointers (raw, std::auto_ptr, + // shared), we need to make sure we don't make any copies of the + // pointer on the return path. + // + pointer_type& + current () + { + if (pointer_traits::null_ptr (current_) && !end_) + load (); + + return current_; + } + + void + release () + { + current_ = pointer_type (); + guard_.release (); + } + + void + begin () + { + if (begin_) + { + next (); + begin_ = false; + } + } + + bool + end () const + { + return end_; + } + + protected: + // The fetch argument is a hint to the implementation. If it is + // false then it means load_id() was already called (and presumably + // fetched the data into the object image) and the object image + // is still valid (so the implementation doesn't need to fetch + // the data again). + // + virtual void + load (object_type&, bool fetch = true) = 0; + + virtual id_type + load_id () = 0; + + virtual void + next () = 0; + + virtual void + cache () = 0; + + virtual std::size_t + size () = 0; + + protected: +#ifdef ODB_CXX11 + void + current (pointer_type& p, bool guard = true) + { + current_ = std::move (p); + + if (guard) + guard_.reset (current_); + else + guard_.reset (); + } + + void + current (pointer_type&& p, bool guard = true) + { + current (p, guard); + } +#else + void + current (pointer_type p, bool guard = true) + { + current_ = p; + + if (guard) + guard_.reset (current_); + else + guard_.reset (); + } +#endif + + bool begin_; + bool end_; + + private: + void + load (); + + private: + pointer_type current_; + typename pointer_traits::guard guard_; + }; + + template + class object_result_iterator + { + public: + // T can be const T while object_type is always non-const. + // + typedef typename object_traits::object_type object_type; + typedef typename object_traits::id_type id_type; + + typedef object_result_impl result_impl_type; + + public: + object_result_iterator (result_impl_type* res) + : res_ (res) + { + } + + public: + typename object_traits::pointer_type + load () + { + typename object_traits::pointer_type r (res_->current ()); + res_->release (); + return r; + } + + void + load (object_type&); + + id_type + id () + { + return res_->load_id (); + } + + protected: + result_impl_type* res_; + }; +} + +#include + +#include + +#endif // ODB_SIMPLE_OBJECT_RESULT_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/simple-object-result.txx b/third-party/odb/libodb-2.4.0/odb/simple-object-result.txx new file mode 100755 index 0000000..b4c2ed3 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/simple-object-result.txx @@ -0,0 +1,59 @@ +// file : odb/simple-object-result.txx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +namespace odb +{ + // + // object_result_impl + // + + template + void object_result_impl:: + load () + { + // First check the session. + // + const id_type& id (load_id ()); + + pointer_type p (object_traits::pointer_cache_traits::find (db_, id)); + + if (!pointer_traits::null_ptr (p)) + current (p, false); // Pointer from cache should not be guarded. + else + { + p = object_traits::create (); + + typename object_traits::pointer_cache_traits::insert_guard ig ( + object_traits::pointer_cache_traits::insert (db_, id, p)); + + object_type& obj (pointer_traits::get_ref (p)); + current (p); + load (obj, false); + object_traits::pointer_cache_traits::load (ig.position ()); + ig.release (); + } + } + + // + // object_result_iterator + // + + template + void object_result_iterator:: + load (object_type& obj) + { + if (res_->end ()) + return; + + typedef odb::object_traits object_traits; + + typename object_traits::reference_cache_traits::position_type p ( + object_traits::reference_cache_traits::insert ( + res_->db_, res_->load_id (), obj)); + typename object_traits::reference_cache_traits::insert_guard ig (p); + res_->load (obj, false); + object_traits::reference_cache_traits::load (p); + ig.release (); + } +} diff --git a/third-party/odb/libodb-2.4.0/odb/statement-processing-common.hxx b/third-party/odb/libodb-2.4.0/odb/statement-processing-common.hxx new file mode 100755 index 0000000..2f987c6 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/statement-processing-common.hxx @@ -0,0 +1,215 @@ +// file : odb/statement-processingc-common.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_STATEMENT_PROCESSING_COMMON_HXX +#define ODB_STATEMENT_PROCESSING_COMMON_HXX + +#include + +//#define LIBODB_DEBUG_STATEMENT_PROCESSING 1 +//#define LIBODB_TRACE_STATEMENT_PROCESSING 1 + +#include +#include // std::size_t + +namespace odb +{ + typedef std::char_traits traits; + + static inline const char* + find (const char* b, const char* e, char c) + { + return traits::find (b, e - b, c); + } + + static inline const char* + rfind (const char* b, const char* e, char c) + { + for (--e; b != e; --e) + if (*e == c) + return e; + + return 0; + } + + static inline const char* + find (const char* b, const char* e, const char* s, std::size_t n) + { + for (; b != e; ++b) + { + if (*b == *s && + static_cast (e - b) >= n && + traits::compare (b, s, n) == 0) + return b; + } + + return 0; + } + + // Iterate over INSERT column/value list, UPDATE SET expression list, + // or SELECT column/join list. + // + // for (const char* b (columns_begin), *e (begin (b, end)); + // e != 0; + // next (b, e, end)) + // { + // // b points to the beginning of the value (i.e., one past '('). + // // e points one past the end of the value (i.e., to ',', ')', or '\n'). + // } + // + // // b points one past the last value. + // + static inline const char* + paren_begin (const char*& b, const char* end) + { + // Note that the list may not end with '\n'. + + b++; // Skip '('. + const char* e (find (b, end, '\n')); + return (e != 0 ? e : end) - 1; // Skip ',' or ')'. + } + + static inline void + paren_next (const char*& b, const char*& e, const char* end) + { + if (*e == ',') + { + b = e + 2; // Skip past '\n'. + e = find (b, end, '\n'); + e = (e != 0 ? e : end) - 1; // Skip ',' or ')'. + } + else + { + b = (e + 1 != end ? e + 2 : end); // Skip past '\n'. + e = 0; + } + } + + static inline const char* + comma_begin (const char* b, const char* end) + { + // Note that the list may not end with '\n'. + + const char* e (find (b, end, '\n')); + return e != 0 ? e - (*(e - 1) == ',' ? 1 : 0) : end; // Skip ','. + } + + static inline void + comma_next (const char*& b, const char*& e, const char* end) + { + if (*e == ',') + { + b = e + 2; // Skip past '\n'. + e = find (b, end, '\n'); + e = (e != 0 ? e - (*(e - 1) == ',' ? 1 : 0) : end); // Skip ','. + } + else + { + b = (e != end ? e + 1 : end); // Skip past '\n'. + e = 0; + } + } + + // Only allows A-Z and spaces before prefix (e.g., JOIN in LEFT OUTER JOIN). + // + static inline bool + fuzzy_prefix (const char* b, + const char* end, + const char* prefix, + std::size_t prefix_size) + { + for (; b != end; ++b) + { + char c (*b); + + if ((c < 'A' || c > 'Z') && c != ' ') + break; + + if (c == *prefix && + static_cast (end - b) > prefix_size && + traits::compare (b, prefix, prefix_size) == 0) + return true; + } + + return false; + } + + static inline const char* + newline_begin (const char* b, const char* end) + { + // Note that the list may not end with '\n'. + + const char* e (find (b, end, '\n')); + return e != 0 ? e : end; + } + + static inline void + newline_next (const char*& b, + const char*& e, + const char* end, + const char* prefix, + std::size_t prefix_size, + bool prefix_fuzzy = false) + { + if (e != end) + e++; // Skip past '\n'. + + b = e; + + // Do we have another element? + // + if (static_cast (end - b) > prefix_size && + (prefix_fuzzy + ? fuzzy_prefix (b, end, prefix, prefix_size) + : traits::compare (b, prefix, prefix_size) == 0)) + { + e = find (b, end, '\n'); + if (e == 0) + e = end; + } + else + e = 0; + } + + // Note that end must point to the beginning of the list. + // + static inline const char* + newline_rbegin (const char* e, const char* end) + { + const char* b (rfind (end, e - 1, '\n')); + return b != 0 ? b + 1 : end; // Skip past '\n'. + } + + static inline void + newline_rnext (const char*& b, const char*& e, const char* end) + { + if (b != end) + { + e = b - 1; // Skip to previous '\n'. + b = rfind (end, e - 1, '\n'); + b = (b != 0 ? b + 1 : end); // Skip past '\n'. + } + else + { + e = end - 1; // One before the first element. + b = 0; + } + } + + // Fast path: just remove the "structure". + // + static inline void + process_fast (const char* s, std::string& r) + { + r = s; + for (std::size_t i (r.find ('\n')); + i != std::string::npos; + i = r.find ('\n', i)) + r[i++] = ' '; + } +} + +#include + +#endif // ODB_STATEMENT_PROCESSING_COMMON_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/statement-processing.cxx b/third-party/odb/libodb-2.4.0/odb/statement-processing.cxx new file mode 100755 index 0000000..e6ad96b --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/statement-processing.cxx @@ -0,0 +1,679 @@ +// file : odb/statement-processing.cxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include + +#include + +#ifdef LIBODB_TRACE_STATEMENT_PROCESSING +# include +#endif + +#include + +using namespace std; + +namespace odb +{ + typedef const void* const* bind_type; + + static inline const void* + bind_at (size_t i, bind_type bind, size_t bind_skip) + { + const char* b (reinterpret_cast (bind)); + return *reinterpret_cast (b + i * bind_skip); + } + + void statement:: + process_insert (const char* s, + bind_type bind, + size_t bind_size, + size_t bind_skip, + char param_symbol, + string& r) + { +#ifndef LIBODB_DEBUG_STATEMENT_PROCESSING + assert (bind_size != 0); // Cannot be versioned. +#endif + + bool fast (true); // Fast case (if all present). + for (size_t i (0); i != bind_size && fast; ++i) + { + if (bind_at (i, bind, bind_skip) == 0) + fast = false; + } + + // Fast path: just remove the "structure". + // +#ifndef LIBODB_DEBUG_STATEMENT_PROCESSING + if (fast) + { + process_fast (s, r); + return; + } +#endif + + // Scan the statement and store the positions of various parts. + // + size_t n (traits::length (s)); + const char* e (s + n); + + // Header. + // + const char* p (find (s, e, '\n')); + assert (p != 0); + size_t header_size (p - s); + p++; + + // Column list. + // + const char* columns_begin (0); + if (*p == '(') + { + columns_begin = p; + + // Find the end of the column list. + // + for (const char* ce (paren_begin (p, e)); ce != 0; paren_next (p, ce, e)) + ; + } + + // OUTPUT + // + const char* output_begin (0); + size_t output_size (0); + if (e - p > 7 && traits::compare (p, "OUTPUT ", 7) == 0) + { + output_begin = p; + p += 7; + p = find (p, e, '\n'); + assert (p != 0); + output_size = p - output_begin; + p++; + } + + // VALUES or DEFAULT VALUES + // + bool empty (true); // DEFAULT VALUES case (if none present). + const char* values_begin (0); + if (e - p > 7 && traits::compare (p, "VALUES\n", 7) == 0) + { + p += 7; + values_begin = p; + + size_t bi (0); + for (const char* ve (paren_begin (p, e)); ve != 0; paren_next (p, ve, e)) + { + // We cannot be empty if we have a non-parameterized value, e.g., + // INSERT ... VALUES(1,?). We also cannot be empty if this value + // is present in the bind array. + // + if (find (p, ve, param_symbol) == 0 || + bind_at (bi++, bind, bind_skip) != 0) + empty = false; + } + } + else + { + // Must be DEFAULT VALUES. + // + assert (traits::compare (p, "DEFAULT VALUES", 14) == 0); + p += 14; + + if (*p == '\n') + p++; + } + + // Trailer. + // + const char* trailer_begin (0); + size_t trailer_size (0); + if (e - p != 0) + { + trailer_begin = p; + trailer_size = e - p; + } + + // Empty case. + // + if (empty) + { + r.reserve (header_size + + (output_size == 0 ? 0 : output_size + 1) + + 15 + // For " DEFAULT VALUES" + (trailer_size == 0 ? 0 : trailer_size + 1)); + + r.assign (s, header_size); + + if (output_size != 0) + { + r += ' '; + r.append (output_begin, output_size); + } + + r += " DEFAULT VALUES"; + + if (trailer_size != 0) + { + r += ' '; + r.append (trailer_begin, trailer_size); + } + +#ifdef LIBODB_TRACE_STATEMENT_PROCESSING + if (r.size () != n) + cerr << endl + << "old: '" << s << "'" << endl << endl + << "new: '" << r << "'" << endl << endl; +#endif + + return; + } + + // Assume the same size as the original. It can only shrink, and in + // most cases only slightly. So this is a good approximation. + // + r.reserve (n); + r.assign (s, header_size); + + // Column list. + // + { + r += ' '; + + size_t i (0), bi (0); + + for (const char *c (columns_begin), *ce (paren_begin (c, e)), + *v (values_begin), *ve (paren_begin (v, e)); + ce != 0; paren_next (c, ce, e), paren_next (v, ve, e)) + { + // See if the value contains the parameter symbol and, if so, + // whether it is present in the bind array. + // + if (find (v, ve, param_symbol) != 0 && + bind_at (bi++, bind, bind_skip) == 0) + continue; + + // Append the column. + // + if (i++ == 0) + r += '('; + else + r += ", "; // Add the space for consistency with the fast path. + + r.append (c, ce - c); + } + + r += ')'; + } + + // OUTPUT + // + if (output_size != 0) + { + r += ' '; + r.append (output_begin, output_size); + } + + // Value list. + // + { + r += " VALUES "; + + size_t i (0), bi (0); + + for (const char* v (values_begin), *ve (paren_begin (v, e)); + ve != 0; paren_next (v, ve, e)) + { + // See if the value contains the parameter symbol and, if so, + // whether it is present in the bind array. + // + if (find (v, ve, param_symbol) != 0 && + bind_at (bi++, bind, bind_skip) == 0) + continue; + + // Append the value. + // + if (i++ == 0) + r += '('; + else + r += ", "; // Add the space for consistency with the fast path. + + r.append (v, ve - v); + } + + r += ')'; + } + + // Trailer. + // + if (trailer_size != 0) + { + r += ' '; + r.append (trailer_begin, trailer_size); + } + +#ifdef LIBODB_TRACE_STATEMENT_PROCESSING + if (r.size () != n) + cerr << endl + << "old: '" << s << "'" << endl << endl + << "new: '" << r << "'" << endl << endl; +#endif + } + + void statement:: + process_update (const char* s, + bind_type bind, + size_t bind_size, + size_t bind_skip, + char param_symbol, + string& r) + { + bool fast (true); // Fast case (if all present). + for (size_t i (0); i != bind_size && fast; ++i) + { + if (bind_at (i, bind, bind_skip) == 0) + fast = false; + } + + // Fast path: just remove the "structure". + // +#ifndef LIBODB_DEBUG_STATEMENT_PROCESSING + if (fast) + { + process_fast (s, r); + return; + } +#endif + + // Scan the statement and store the positions of various parts. + // + size_t n (traits::length (s)); + const char* e (s + n); + + // Header. + // + const char* p (find (s, e, '\n')); + assert (p != 0); + size_t header_size (p - s); + p++; + + // SET + // + bool empty (true); // Empty SET case. + const char* set_begin (0); + if (e - p > 4 && traits::compare (p, "SET\n", 4) == 0) + { + p += 4; + set_begin = p; + + // Scan the SET list. + // + size_t bi (0); + for (const char* pe (comma_begin (p, e)); pe != 0; comma_next (p, pe, e)) + { + if (empty) + { + // We cannot be empty if we have a non-parameterized set expression, + // e.g., UPDATE ... SET ver=ver+1 ... We also cannot be empty if + // this expression is present in the bind array. + // + if (find (p, pe, param_symbol) == 0 || + bind_at (bi++, bind, bind_skip) != 0) + empty = false; + } + } + } + + // Empty case. + // + if (empty) + { + r.clear (); + +#ifdef LIBODB_TRACE_STATEMENT_PROCESSING + if (n != 0) + cerr << endl + << "old: '" << s << "'" << endl << endl + << "new: '" << r << "'" << endl << endl; +#endif + + return; + } + + // Trailer. + // + const char* trailer_begin (0); + size_t trailer_size (0); + if (e - p != 0) + { + trailer_begin = p; + trailer_size = e - p; + } + + // Assume the same size as the original. It can only shrink, and in + // most cases only slightly. So this is a good approximation. + // + r.reserve (n); + r.assign (s, header_size); + + // SET list. + // + { + r += " SET "; + + size_t i (0), bi (0); + + for (const char* p (set_begin), *pe (comma_begin (p, e)); + pe != 0; comma_next (p, pe, e)) + { + // See if the value contains the parameter symbol and, if so, + // whether it is present in the bind array. + // + if (find (p, pe, param_symbol) != 0 && + bind_at (bi++, bind, bind_skip) == 0) + continue; + + // Append the expression. + // + if (i++ != 0) + r += ", "; // Add the space for consistency with the fast path. + + r.append (p, pe - p); + } + } + + // Trailer. + // + if (trailer_size != 0) + { + r += ' '; + r.append (trailer_begin, trailer_size); + } + +#ifdef LIBODB_TRACE_STATEMENT_PROCESSING + if (r.size () != n) + cerr << endl + << "old: '" << s << "'" << endl << endl + << "new: '" << r << "'" << endl << endl; +#endif + } + + void statement:: + process_select (const char* s, + bind_type bind, + size_t bind_size, + size_t bind_skip, + char quote_open, + char quote_close, +#ifndef LIBODB_DEBUG_STATEMENT_PROCESSING + bool optimize, +#else + bool, +#endif + string& r, + bool as) + { + bool empty (true); // Empty case (if none present). + bool fast (true); // Fast case (if all present). + for (size_t i (0); i != bind_size && (empty || fast); ++i) + { + if (bind_at (i, bind, bind_skip) != 0) + empty = false; + else + fast = false; + } + + // Empty. + // + if (empty) + { + r.clear (); + +#ifdef LIBODB_TRACE_STATEMENT_PROCESSING + if (*s != '\0') + cerr << endl + << "old: '" << s << "'" << endl << endl + << "new: '" << r << "'" << endl << endl; +#endif + return; + } + + // Fast path: just remove the "structure". + // +#ifndef LIBODB_DEBUG_STATEMENT_PROCESSING + if (fast && !optimize) + { + process_fast (s, r); + return; + } +#endif + + // Scan the statement and store the positions of various parts. + // + size_t n (traits::length (s)); + const char* e (s + n); + + // Header. + // + const char* p (find (s, e, '\n')); + assert (p != 0); + size_t header_size (p - s); + p++; + + // Column list. + // + const char* columns_begin (p); + for (const char* ce (comma_begin (p, e)); ce != 0; comma_next (p, ce, e)) + ; + + // FROM. + assert (traits::compare (p, "FROM ", 5) == 0); + const char* from_begin (p); + p = find (p, e, '\n'); // May not end with '\n'. + if (p == 0) + p = e; + size_t from_size (p - from_begin); + if (p != e) + p++; + + // JOIN list. + // + const char* joins_begin (0), *joins_end (0); + if (e - p > 5 && fuzzy_prefix (p, e, "JOIN ", 5)) + { + joins_begin = p; + + // Find the end of the JOIN list. + // + for (const char* je (newline_begin (p, e)); + je != 0; newline_next (p, je, e, "JOIN ", 5, true)) + ; + + joins_end = (p != e ? p - 1 : p); + } + +#ifndef LIBODB_DEBUG_STATEMENT_PROCESSING + if (fast && joins_begin == 0) + { + // No JOINs to optimize so can still take the fast path. + // + process_fast (s, r); + return; + } +#endif + + // Trailer (WHERE, ORDER BY, etc). + // + const char* trailer_begin (0); + size_t trailer_size (0); + if (e - p != 0) + { + trailer_begin = p; + trailer_size = e - p; + } + + // Assume the same size as the original. It can only shrink, and in + // most cases only slightly. So this is a good approximation. + // + r.reserve (n); + r.assign (s, header_size); + + // Column list. + // + { + r += ' '; + + size_t i (0), bi (0); + + for (const char *c (columns_begin), *ce (comma_begin (c, e)); + ce != 0; comma_next (c, ce, e)) + { + // See if the column is present in the bind array. + // + if (bind_at (bi++, bind, bind_skip) == 0) + continue; + + // Append the column. + // + if (i++ != 0) + r += ", "; // Add the space for consistency with the fast path. + + r.append (c, ce - c); + } + } + + // From. + // + r += ' '; + r.append (from_begin, from_size); + + // JOIN list, pass 1. + // + size_t join_pos (0); + if (joins_begin != 0) + { + // Fill in the JOIN "area" with spaces. + // + r.resize (r.size () + joins_end - joins_begin + 1, ' '); + join_pos = r.size () + 1; // End of the last JOIN. + } + + // Trailer. + // + if (trailer_size != 0) + { + r += ' '; + r.append (trailer_begin, trailer_size); + } + + // JOIN list, pass 2. + // + if (joins_begin != 0) + { + // Splice the JOINs into the pre-allocated area. + // + for (const char* je (joins_end), *j (newline_rbegin (je, joins_begin)); + j != 0; newline_rnext (j, je, joins_begin)) + { + size_t n (je - j); + + // Get the alias or, if none used, the table name. + // + p = find (j, je, "JOIN ", 5) + 5; // Skip past "JOIN ". + const char* table_begin (p); + p = find (p, je, ' '); // End of the table name. + const char* table_end (p); + p++; // Skip space. + + // We may or may not have the AS keyword. + // + const char* alias_begin (0); + size_t alias_size (0); + + if (p != je && // Not the end. + (je - p < 4 || traits::compare (p, "ON ", 3) != 0)) + { + // Something other than "ON ", so got to be an alias. + // + if (as) + p += 3; + + alias_begin = p; + p = find (p, je, ' '); // There might be no ON (CROSS JOIN). + alias_size = (p != 0 ? p : je) - alias_begin; + } + else + { + // Just the table. + // + alias_begin = table_begin; + alias_size = table_end - alias_begin; + } + + // The alias must be quoted. + // + assert (*alias_begin == quote_open && + *(alias_begin + alias_size - 1) == quote_close); + + // We now need to see if the alias is used in either the SELECT + // list, the WHERE conditions, or the ON condition of any of the + // JOINs that we have already processed and decided to keep. + // + // Instead of re-parsing the whole thing again, we are going to + // take a shortcut and simply search for the alias in the statement + // we have constructed so far (that's why we have added the + // trailer before filling in the JOINs). To make it more robust, + // we are going to do a few extra sanity checks, specifically, + // that the alias is a top level identifier and is followed by + // only a single identifer (column). This will catch cases like + // [s].[t].[c] where [s] is also used as an alias or LEFT JOIN [t] + // where [t] is also used as an alias in another JOIN. + // + bool found (false); + for (size_t p (r.find (alias_begin, 0, alias_size)); + p != string::npos; + p = r.find (alias_begin, p + alias_size, alias_size)) + { + size_t e (p + alias_size); + + // If we are not a top-level qualifier or not a bottom-level, + // then we are done (3 is for at least "[a]"). + // + if ((p != 0 && r[p - 1] == '.') || + (e + 3 >= r.size () || (r[e] != '.' || r[e + 1] != quote_open))) + continue; + + // The only way to distinguish the [a].[c] from FROM [a].[c] or + // JOIN [a].[c] is by checking the prefix. + // + if ((p > 5 && r.compare (p - 5, 5, "FROM ") == 0) || + (p > 5 && r.compare (p - 5, 5, "JOIN ") == 0)) + continue; + + // Check that we are followed by a single identifier. + // + e = r.find (quote_close, e + 2); + if (e == string::npos || (e + 1 != r.size () && r[e + 1] == '.')) + continue; + + found = true; + break; + } + + join_pos -= n + 1; // Extra one for space. + if (found) + r.replace (join_pos, n, j, n); + else + r.erase (join_pos - 1, n + 1); // Extra one for space. + } + } + +#ifdef LIBODB_TRACE_STATEMENT_PROCESSING + if (r.size () != n) + cerr << endl + << "old: '" << s << "'" << endl << endl + << "new: '" << r << "'" << endl << endl; +#endif + } +} diff --git a/third-party/odb/libodb-2.4.0/odb/statement.cxx b/third-party/odb/libodb-2.4.0/odb/statement.cxx new file mode 100755 index 0000000..117b3f1 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/statement.cxx @@ -0,0 +1,13 @@ +// file : odb/statement.cxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include + +namespace odb +{ + statement:: + ~statement () + { + } +} diff --git a/third-party/odb/libodb-2.4.0/odb/statement.hxx b/third-party/odb/libodb-2.4.0/odb/statement.hxx new file mode 100755 index 0000000..6ad458c --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/statement.hxx @@ -0,0 +1,106 @@ +// file : odb/statement.hxx +// copyright : Copyright (c) 2005-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_STATEMENT_HXX +#define ODB_STATEMENT_HXX + +#include + +#include +#include // std::size_t + +#include // connection + +#include +#include + +namespace odb +{ + class LIBODB_EXPORT statement: public details::shared_base + { + private: + statement (const statement&); + statement& operator= (const statement&); + + public: + typedef odb::connection connection_type; + + virtual const char* + text () const = 0; + + virtual connection_type& + connection () = 0; + + virtual + ~statement () = 0; + + protected: + statement () {} + + // Statement processing. Kept public only for testing. + // + public: + // Expected statement structure: + // + // INSERT INTO table\n + // [(a,\n + // b)\n] + // [OUTPUT ...\n] + // [VALUES\n + // ($1,\n + // $2)[\n]] + // [DEFAULT VALUES[\n]] + // [RETURNING ...] + // [; SELECT ...] + // + static void + process_insert (const char* statement, + const void* const* bind, // Array of bind buffer pointers. + std::size_t bind_size, // Number of bind elements. + std::size_t bind_skip, // Offset to the next bind. + char param_symbol, // $, ?, :, etc. + std::string& result); + + // Expected statement structure: + // + // UPDATE table\n + // SET\n + // a=$1,\n + // b=$2[\n] + // [OUTPUT ...] + // [WHERE ...] + // + static void + process_update (const char* statement, + const void* const* bind, // Array of bind buffer pointers. + std::size_t bind_size, // Number of bind elements. + std::size_t bind_skip, // Offset to the next bind. + char param_symbol, // $, ?, :, etc. + std::string& result); + + // Expected statement structure: + // + // SELECT\n + // [schema.]table.a,\n + // alias.b\n + // FROM [schema.]table[\n] + // [{A-Z }* JOIN [schema.]table [AS alias][ ON ...][\n]]* + // [WHERE ...] + // + static void + process_select (const char* statement, + const void* const* bind, // Array of bind buffer pointers. + std::size_t bind_size, // Number of bind elements. + std::size_t bind_skip, // Offset to the next bind. + char quote_open, // Identifier opening quote. + char quote_close, // Identifier closing quote. + bool optimize, // Remove unused JOINs. + std::string& result, + bool as = true); // JOINs use AS keyword. + }; +} + +#include + +#endif // ODB_STATEMENT_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/std-array-traits.hxx b/third-party/odb/libodb-2.4.0/odb/std-array-traits.hxx new file mode 100755 index 0000000..f51b163 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/std-array-traits.hxx @@ -0,0 +1,73 @@ +// file : odb/std-array-traits.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_STD_ARRAY_TRAITS_HXX +#define ODB_STD_ARRAY_TRAITS_HXX + +#include + +#include +#include // std::size_t +#include + +#include + +namespace odb +{ + template + class access::container_traits> + { + public: + static const container_kind kind = ck_ordered; + static const bool smart = false; + + typedef std::array container_type; + + typedef V value_type; + typedef typename container_type::size_type index_type; + + typedef ordered_functions functions; + + public: + static void + persist (const container_type& c, const functions& f) + { + for (index_type i (0); i < N; ++i) + f.insert (i, c[i]); + } + + static void + load (container_type& c, bool more, const functions& f) + { + index_type i (0); + + for (; more && i < N; ++i) + { + index_type dummy; + more = f.select (dummy, c[i]); + } + + assert (!more && i == N); + } + + static void + update (const container_type& c, const functions& f) + { + f.delete_ (); + + for (index_type i (0); i < N; ++i) + f.insert (i, c[i]); + } + + static void + erase (const functions& f) + { + f.delete_ (); + } + }; +} + +#include + +#endif // ODB_STD_ARRAY_TRAITS_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/std-deque-traits.hxx b/third-party/odb/libodb-2.4.0/odb/std-deque-traits.hxx new file mode 100755 index 0000000..7f0ab94 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/std-deque-traits.hxx @@ -0,0 +1,70 @@ +// file : odb/std-deque-traits.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_STD_DEQUE_TRAITS_HXX +#define ODB_STD_DEQUE_TRAITS_HXX + +#include + +#include + +#include + +namespace odb +{ + template + class access::container_traits > + { + public: + static const container_kind kind = ck_ordered; + static const bool smart = false; + + typedef std::deque container_type; + + typedef V value_type; + typedef typename container_type::size_type index_type; + + typedef ordered_functions functions; + + public: + static void + persist (const container_type& c, const functions& f) + { + for (index_type i (0), n (c.size ()); i < n; ++i) + f.insert (i, c[i]); + } + + static void + load (container_type& c, bool more, const functions& f) + { + c.clear (); + + while (more) + { + index_type dummy; + c.push_back (value_type ()); + more = f.select (dummy, c.back ()); + } + } + + static void + update (const container_type& c, const functions& f) + { + f.delete_ (); + + for (index_type i (0), n (c.size ()); i < n; ++i) + f.insert (i, c[i]); + } + + static void + erase (const functions& f) + { + f.delete_ (); + } + }; +} + +#include + +#endif // ODB_STD_DEQUE_TRAITS_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/std-forward-list-traits.hxx b/third-party/odb/libodb-2.4.0/odb/std-forward-list-traits.hxx new file mode 100755 index 0000000..232a7c6 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/std-forward-list-traits.hxx @@ -0,0 +1,74 @@ +// file : odb/std-forward-list-traits.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_STD_FORWARD_LIST_TRAITS_HXX +#define ODB_STD_FORWARD_LIST_TRAITS_HXX + +#include + +#include + +#include + +namespace odb +{ + template + class access::container_traits> + { + public: + static const container_kind kind = ck_ordered; + static const bool smart = false; + + typedef std::forward_list container_type; + + typedef V value_type; + typedef typename container_type::size_type index_type; + + typedef ordered_functions functions; + + public: + static void + persist (const container_type& c, const functions& f) + { + index_type i (0); + for (typename container_type::const_iterator j (c.begin ()), + e (c.end ()); j != e; ++j) + f.insert (i++, *j); + } + + static void + load (container_type& c, bool more, const functions& f) + { + c.clear (); + + for (typename container_type::iterator i (c.before_begin ()); more; ) + { + index_type dummy; + i = c.insert_after (i, value_type ()); + more = f.select (dummy, *i); + } + } + + static void + update (const container_type& c, const functions& f) + { + f.delete_ (); + + index_type i (0); + for (typename container_type::const_iterator j (c.begin ()), + e (c.end ()); j != e; ++j) + f.insert (i++, *j); + } + + static void + erase (const functions& f) + { + f.delete_ (); + } + }; +} + +#include + +#endif // ODB_STD_FORWARD_LIST_TRAITS_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/std-list-traits.hxx b/third-party/odb/libodb-2.4.0/odb/std-list-traits.hxx new file mode 100755 index 0000000..8ffbde2 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/std-list-traits.hxx @@ -0,0 +1,74 @@ +// file : odb/std-list-traits.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_STD_LIST_TRAITS_HXX +#define ODB_STD_LIST_TRAITS_HXX + +#include + +#include + +#include + +namespace odb +{ + template + class access::container_traits > + { + public: + static const container_kind kind = ck_ordered; + static const bool smart = false; + + typedef std::list container_type; + + typedef V value_type; + typedef typename container_type::size_type index_type; + + typedef ordered_functions functions; + + public: + static void + persist (const container_type& c, const functions& f) + { + index_type i (0); + for (typename container_type::const_iterator j (c.begin ()), + e (c.end ()); j != e; ++j) + f.insert (i++, *j); + } + + static void + load (container_type& c, bool more, const functions& f) + { + c.clear (); + + while (more) + { + index_type dummy; + c.push_back (value_type ()); + more = f.select (dummy, c.back ()); + } + } + + static void + update (const container_type& c, const functions& f) + { + f.delete_ (); + + index_type i (0); + for (typename container_type::const_iterator j (c.begin ()), + e (c.end ()); j != e; ++j) + f.insert (i++, *j); + } + + static void + erase (const functions& f) + { + f.delete_ (); + } + }; +} + +#include + +#endif // ODB_STD_LIST_TRAITS_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/std-map-traits.hxx b/third-party/odb/libodb-2.4.0/odb/std-map-traits.hxx new file mode 100755 index 0000000..a09ccf3 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/std-map-traits.hxx @@ -0,0 +1,143 @@ +// file : odb/std-map-traits.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_STD_MAP_TRAITS_HXX +#define ODB_STD_MAP_TRAITS_HXX + +#include + +#include +#include // std::move + +#include +#include // ODB_CXX11 + +namespace odb +{ + template + class access::container_traits > + { + public: + static const container_kind kind = ck_map; + static const bool smart = false; + + typedef std::map container_type; + + typedef K key_type; + typedef V value_type; + typedef typename container_type::value_type pair_type; + + typedef map_functions functions; + + public: + static void + persist (const container_type& c, const functions& f) + { + for (typename container_type::const_iterator i (c.begin ()), + e (c.end ()); i != e; ++i) + f.insert (i->first, i->second); + } + + static void + load (container_type& c, bool more, const functions& f) + { + c.clear (); + + while (more) + { + key_type k; + value_type v; + more = f.select (k, v); +#ifdef ODB_CXX11 + c.insert (pair_type (std::move (k), std::move (v))); +#else + c.insert (pair_type (k, v)); +#endif + } + } + + static void + update (const container_type& c, const functions& f) + { + f.delete_ (); + + for (typename container_type::const_iterator i (c.begin ()), + e (c.end ()); i != e; ++i) + f.insert (i->first, i->second); + } + + static void + erase (const functions& f) + { + f.delete_ (); + } + }; + + // C++03 does not guarantee insertion order of equal values but C++11 + // changes that. The current implementation in the generated code does + // not guarantee this either. + // + template + class access::container_traits > + { + public: + static const container_kind kind = ck_multimap; + static const bool smart = false; + + typedef std::multimap container_type; + + typedef K key_type; + typedef V value_type; + typedef typename container_type::value_type pair_type; + + typedef map_functions functions; + + public: + static void + persist (const container_type& c, const functions& f) + { + for (typename container_type::const_iterator i (c.begin ()), + e (c.end ()); i != e; ++i) + f.insert (i->first, i->second); + } + + static void + load (container_type& c, bool more, const functions& f) + { + c.clear (); + + while (more) + { + key_type k; + value_type v; + more = f.select (k, v); +#ifdef ODB_CXX11 + c.insert (pair_type (std::move (k), std::move (v))); +#else + c.insert (pair_type (k, v)); +#endif + } + } + + static void + update (const container_type& c, const functions& f) + { + f.delete_ (); + + for (typename container_type::const_iterator i (c.begin ()), + e (c.end ()); i != e; ++i) + f.insert (i->first, i->second); + } + + static void + erase (const functions& f) + { + f.delete_ (); + } + }; +} + +#include + +#endif // ODB_STD_MAP_TRAITS_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/std-set-traits.hxx b/third-party/odb/libodb-2.4.0/odb/std-set-traits.hxx new file mode 100755 index 0000000..671cf25 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/std-set-traits.hxx @@ -0,0 +1,135 @@ +// file : odb/std-set-traits.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_STD_SET_TRAITS_HXX +#define ODB_STD_SET_TRAITS_HXX + +#include + +#include +#include // std::move + +#include +#include // ODB_CXX11 + +namespace odb +{ + template + class access::container_traits > + { + public: + static const container_kind kind = ck_set; + static const bool smart = false; + + typedef std::set container_type; + typedef V value_type; + + typedef set_functions functions; + + public: + static void + persist (const container_type& c, const functions& f) + { + for (typename container_type::const_iterator i (c.begin ()), + e (c.end ()); i != e; ++i) + f.insert (*i); + } + + static void + load (container_type& c, bool more, const functions& f) + { + c.clear (); + + while (more) + { + value_type v; + more = f.select (v); +#ifdef ODB_CXX11 + c.insert (std::move (v)); +#else + c.insert (v); +#endif + } + } + + static void + update (const container_type& c, const functions& f) + { + f.delete_ (); + + for (typename container_type::const_iterator i (c.begin ()), + e (c.end ()); i != e; ++i) + f.insert (*i); + } + + static void + erase (const functions& f) + { + f.delete_ (); + } + }; + + // C++03 does not guarantee insertion order of equal values but C++11 + // changes that. The current implementation in the generated code does + // not guarantee this either. + // + template + class access::container_traits > + { + public: + static const container_kind kind = ck_multiset; + static const bool smart = false; + + typedef std::multiset container_type; + typedef V value_type; + + typedef set_functions functions; + + public: + static void + persist (const container_type& c, const functions& f) + { + for (typename container_type::const_iterator i (c.begin ()), + e (c.end ()); i != e; ++i) + f.insert (*i); + } + + static void + load (container_type& c, bool more, const functions& f) + { + c.clear (); + + while (more) + { + value_type v; + more = f.select (v); +#ifdef ODB_CXX11 + c.insert (std::move (v)); +#else + c.insert (v); +#endif + } + } + + static void + update (const container_type& c, const functions& f) + { + f.delete_ (); + + for (typename container_type::const_iterator i (c.begin ()), + e (c.end ()); i != e; ++i) + f.insert (*i); + } + + static void + erase (const functions& f) + { + f.delete_ (); + } + }; +} + +#include + +#endif // ODB_STD_SET_TRAITS_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/std-unordered-map-traits.hxx b/third-party/odb/libodb-2.4.0/odb/std-unordered-map-traits.hxx new file mode 100755 index 0000000..5f86b4f --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/std-unordered-map-traits.hxx @@ -0,0 +1,134 @@ +// file : odb/std-unordered-map-traits.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_STD_UNORDERED_MAP_TRAITS_HXX +#define ODB_STD_UNORDERED_MAP_TRAITS_HXX + +#include + +#include // std::move +#include + +#include + +namespace odb +{ + template + class access::container_traits> + { + public: + static const container_kind kind = ck_map; + static const bool smart = false; + + typedef std::unordered_map container_type; + + typedef K key_type; + typedef V value_type; + typedef typename container_type::value_type pair_type; + + typedef map_functions functions; + + public: + static void + persist (const container_type& c, const functions& f) + { + for (typename container_type::const_iterator i (c.begin ()), + e (c.end ()); i != e; ++i) + f.insert (i->first, i->second); + } + + static void + load (container_type& c, bool more, const functions& f) + { + c.clear (); + + while (more) + { + key_type k; + value_type v; + more = f.select (k, v); + c.insert (pair_type (std::move (k), std::move (v))); + } + } + + static void + update (const container_type& c, const functions& f) + { + f.delete_ (); + + for (typename container_type::const_iterator i (c.begin ()), + e (c.end ()); i != e; ++i) + f.insert (i->first, i->second); + } + + static void + erase (const functions& f) + { + f.delete_ (); + } + }; + + // @@ Does multimap preserve insertion order of equal elements? The + // current implementation in the generated code does not guarantee + // this. + // + template + class access::container_traits> + { + public: + static const container_kind kind = ck_multimap; + static const bool smart = false; + + typedef std::unordered_multimap container_type; + + typedef K key_type; + typedef V value_type; + typedef typename container_type::value_type pair_type; + + typedef map_functions functions; + + public: + static void + persist (const container_type& c, const functions& f) + { + for (typename container_type::const_iterator i (c.begin ()), + e (c.end ()); i != e; ++i) + f.insert (i->first, i->second); + } + + static void + load (container_type& c, bool more, const functions& f) + { + c.clear (); + + while (more) + { + key_type k; + value_type v; + more = f.select (k, v); + c.insert (pair_type (std::move (k), std::move (v))); + } + } + + static void + update (const container_type& c, const functions& f) + { + f.delete_ (); + + for (typename container_type::const_iterator i (c.begin ()), + e (c.end ()); i != e; ++i) + f.insert (i->first, i->second); + } + + static void + erase (const functions& f) + { + f.delete_ (); + } + }; +} + +#include + +#endif // ODB_STD_UNORDERED_MAP_TRAITS_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/std-unordered-set-traits.hxx b/third-party/odb/libodb-2.4.0/odb/std-unordered-set-traits.hxx new file mode 100755 index 0000000..15fd88d --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/std-unordered-set-traits.hxx @@ -0,0 +1,126 @@ +// file : odb/std-unordered-set-traits.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_STD_UNORDERED_SET_TRAITS_HXX +#define ODB_STD_UNORDERED_SET_TRAITS_HXX + +#include + +#include // std::move +#include + +#include + +namespace odb +{ + template + class access::container_traits> + { + public: + static const container_kind kind = ck_set; + static const bool smart = false; + + typedef std::unordered_set container_type; + typedef V value_type; + + typedef set_functions functions; + + public: + static void + persist (const container_type& c, const functions& f) + { + for (typename container_type::const_iterator i (c.begin ()), + e (c.end ()); i != e; ++i) + f.insert (*i); + } + + static void + load (container_type& c, bool more, const functions& f) + { + c.clear (); + + while (more) + { + value_type v; + more = f.select (v); + c.insert (std::move (v)); + } + } + + static void + update (const container_type& c, const functions& f) + { + f.delete_ (); + + for (typename container_type::const_iterator i (c.begin ()), + e (c.end ()); i != e; ++i) + f.insert (*i); + } + + static void + erase (const functions& f) + { + f.delete_ (); + } + }; + + // @@ Does multiset preserve insertion order of equal elements? The + // current implementation in the generated code does not guarantee + // this. + // + template + class access::container_traits> + { + public: + static const container_kind kind = ck_multiset; + static const bool smart = false; + + typedef std::unordered_multiset container_type; + typedef V value_type; + + typedef set_functions functions; + + public: + static void + persist (const container_type& c, const functions& f) + { + for (typename container_type::const_iterator i (c.begin ()), + e (c.end ()); i != e; ++i) + f.insert (*i); + } + + static void + load (container_type& c, bool more, const functions& f) + { + c.clear (); + + while (more) + { + value_type v; + more = f.select (v); + c.insert (std::move (v)); + } + } + + static void + update (const container_type& c, const functions& f) + { + f.delete_ (); + + for (typename container_type::const_iterator i (c.begin ()), + e (c.end ()); i != e; ++i) + f.insert (*i); + } + + static void + erase (const functions& f) + { + f.delete_ (); + } + }; +} + +#include + +#endif // ODB_STD_UNORDERED_SET_TRAITS_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/std-vector-traits.hxx b/third-party/odb/libodb-2.4.0/odb/std-vector-traits.hxx new file mode 100755 index 0000000..e967b09 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/std-vector-traits.hxx @@ -0,0 +1,70 @@ +// file : odb/std-vector-traits.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_STD_VECTOR_TRAITS_HXX +#define ODB_STD_VECTOR_TRAITS_HXX + +#include + +#include + +#include + +namespace odb +{ + template + class access::container_traits > + { + public: + static const container_kind kind = ck_ordered; + static const bool smart = false; + + typedef std::vector container_type; + + typedef V value_type; + typedef typename container_type::size_type index_type; + + typedef ordered_functions functions; + + public: + static void + persist (const container_type& c, const functions& f) + { + for (index_type i (0), n (c.size ()); i < n; ++i) + f.insert (i, c[i]); + } + + static void + load (container_type& c, bool more, const functions& f) + { + c.clear (); + + while (more) + { + index_type dummy; + c.push_back (value_type ()); + more = f.select (dummy, c.back ()); + } + } + + static void + update (const container_type& c, const functions& f) + { + f.delete_ (); + + for (index_type i (0), n (c.size ()); i < n; ++i) + f.insert (i, c[i]); + } + + static void + erase (const functions& f) + { + f.delete_ (); + } + }; +} + +#include + +#endif // ODB_STD_VECTOR_TRAITS_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/tr1/lazy-pointer-traits.hxx b/third-party/odb/libodb-2.4.0/odb/tr1/lazy-pointer-traits.hxx new file mode 100755 index 0000000..b2f31ed --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/tr1/lazy-pointer-traits.hxx @@ -0,0 +1,62 @@ +// file : odb/tr1/lazy-pointer-traits.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_TR1_LAZY_POINTER_TRAITS_HXX +#define ODB_TR1_LAZY_POINTER_TRAITS_HXX + +#include + +#include +#include + +namespace odb +{ + template + class pointer_traits > + { + public: + static const pointer_kind kind = pk_shared; + static const bool lazy = true; + + typedef T element_type; + typedef tr1::lazy_shared_ptr pointer_type; + typedef std::tr1::shared_ptr eager_pointer_type; + + static bool + null_ptr (const pointer_type& p) + { + return !p; + } + + template + static typename object_traits::id_type + object_id (const pointer_type& p) + { + return p.template object_id (); + } + }; + + template + class pointer_traits > + { + public: + static const pointer_kind kind = pk_weak; + static const bool lazy = true; + + typedef T element_type; + typedef tr1::lazy_weak_ptr pointer_type; + typedef tr1::lazy_shared_ptr strong_pointer_type; + typedef std::tr1::weak_ptr eager_pointer_type; + + static strong_pointer_type + lock (const pointer_type& p) + { + return p.lock (); + } + }; +} + +#include + +#endif // ODB_TR1_LAZY_POINTER_TRAITS_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/tr1/lazy-ptr.hxx b/third-party/odb/libodb-2.4.0/odb/tr1/lazy-ptr.hxx new file mode 100755 index 0000000..4579090 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/tr1/lazy-ptr.hxx @@ -0,0 +1,261 @@ +// file : odb/tr1/lazy-ptr.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_TR1_LAZY_PTR_HXX +#define ODB_TR1_LAZY_PTR_HXX + +#include + +// +// This header assumes that the necessary TR1 header has already +// been included. +// + +#include // std::auto_ptr + +#include // odb::database +#include +#include +#include // ODB_CXX11 + +namespace odb +{ + namespace tr1 + { + template + class lazy_weak_ptr; + + // + // + template + class lazy_shared_ptr + { + // The standard shared_ptr interface. + // + public: + typedef T element_type; + + lazy_shared_ptr (); + template explicit lazy_shared_ptr (Y*); + template lazy_shared_ptr (Y*, D); + + lazy_shared_ptr (const lazy_shared_ptr&); + template lazy_shared_ptr (const lazy_shared_ptr&); + template explicit lazy_shared_ptr (const lazy_weak_ptr&); + template explicit lazy_shared_ptr (std::auto_ptr&); + + ~lazy_shared_ptr (); + + lazy_shared_ptr& operator= (const lazy_shared_ptr&); + template lazy_shared_ptr& operator= (const lazy_shared_ptr&); + template lazy_shared_ptr& operator= (std::auto_ptr&); + + void swap (lazy_shared_ptr&); + void reset (); + template void reset (Y*); + template void reset (Y*, D); + + T& operator* () const; + T* operator-> () const; + T* get () const; + + bool unique () const; + long use_count () const; + + typedef std::tr1::shared_ptr lazy_shared_ptr::*unspecified_bool_type; + operator unspecified_bool_type () const + { + return (p_ || i_) ? &lazy_shared_ptr::p_ : 0; + } + + // Initialization/assignment from shared_ptr and weak_ptr. + // + public: + template lazy_shared_ptr (const std::tr1::shared_ptr&); + template explicit lazy_shared_ptr (const std::tr1::weak_ptr&); + + template lazy_shared_ptr& operator= (const std::tr1::shared_ptr&); + + // Lazy loading interface. + // + public: + typedef odb::database database_type; + + // NULL loaded() + // + // true true NULL pointer to transient object + // false true valid pointer to persistent object + // true false unloaded pointer to persistent object + // false false valid pointer to transient object + // + bool loaded () const; + + std::tr1::shared_ptr load () const; + + // Unload the pointer. For transient objects this function is + // equivalent to reset(). + // + void unload () const; + + // Get the underlying eager pointer. If this is an unloaded pointer + // to a persistent object, then the returned pointer will be NULL. + // + std::tr1::shared_ptr get_eager () const; + + template lazy_shared_ptr (DB&, const ID&); + template lazy_shared_ptr (DB&, Y*); + template lazy_shared_ptr (DB&, Y*, D); + template lazy_shared_ptr (DB&, std::auto_ptr&); + template lazy_shared_ptr (DB&, const std::tr1::shared_ptr&); + template lazy_shared_ptr (DB&, const std::tr1::weak_ptr&); + + template void reset (DB&, const ID&); + template void reset (DB&, Y*); + template void reset (DB&, Y*, D); + template void reset (DB&, std::auto_ptr&); + template void reset (DB&, const std::tr1::shared_ptr&); + +#ifdef ODB_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGUMENT + template +#else + template +#endif + typename object_traits::id_type object_id () const; + + database_type& database () const; + + // Helpers. + // + public: + template bool equal (const lazy_shared_ptr&) const; + + private: + template friend class lazy_shared_ptr; + template friend class lazy_weak_ptr; + + mutable std::tr1::shared_ptr p_; + mutable lazy_ptr_impl i_; + }; + + // operator< and operator<< are not provided. + // + template + bool operator== (const lazy_shared_ptr&, const lazy_shared_ptr&); + + template + bool operator!= (const lazy_shared_ptr&, const lazy_shared_ptr&); + + template void swap (lazy_shared_ptr&, lazy_shared_ptr&); + + template + D* get_deleter (const lazy_shared_ptr&); + + // + // + template + class lazy_weak_ptr + { + // The standard weak_ptr interface. + // + public: + typedef T element_type; + + lazy_weak_ptr (); + template lazy_weak_ptr (const lazy_shared_ptr&); + lazy_weak_ptr (const lazy_weak_ptr&); + template lazy_weak_ptr (const lazy_weak_ptr&); + + ~lazy_weak_ptr (); + + lazy_weak_ptr& operator= (const lazy_weak_ptr&); + template lazy_weak_ptr& operator= (const lazy_weak_ptr&); + template lazy_weak_ptr& operator= (const lazy_shared_ptr&); + + void swap (lazy_weak_ptr&); + void reset (); + + long use_count () const; + bool expired () const; + + lazy_shared_ptr lock () const; + + // Initialization/assignment from shared_ptr and weak_ptr. + // + public: + template lazy_weak_ptr (const std::tr1::weak_ptr&); + template lazy_weak_ptr (const std::tr1::shared_ptr&); + + template lazy_weak_ptr& operator= (const std::tr1::weak_ptr&); + template lazy_weak_ptr& operator= (const std::tr1::shared_ptr&); + + // Lazy loading interface. + // + public: + typedef odb::database database_type; + + // expired() loaded() + // + // true true expired pointer to transient object + // false true valid pointer to persistent object + // true false expired pointer to persistent object + // false false valid pointer to transient object + // + bool loaded () const; + + // Performs both lock and load. + // + std::tr1::shared_ptr load () const; + + // Unload the pointer. For transient objects this function is + // equivalent to reset(). + // + void unload () const; + + // Get the underlying eager pointer. If this is an unloaded pointer + // to a persistent object, then the returned pointer will be NULL. + // + std::tr1::weak_ptr get_eager () const; + + template lazy_weak_ptr (DB&, const ID&); + template lazy_weak_ptr (DB&, const std::tr1::shared_ptr&); + template lazy_weak_ptr (DB&, const std::tr1::weak_ptr&); + + template void reset (DB&, const ID&); + template void reset (DB&, const std::tr1::shared_ptr&); + template void reset (DB&, const std::tr1::weak_ptr&); + + // The object_id() function can only be called when the object is + // persistent, or: expired() XOR loaded() (can use != for XOR). + // +#ifdef ODB_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGUMENT + template +#else + template +#endif + typename object_traits::id_type object_id () const; + + database_type& database () const; + + private: + template friend class lazy_shared_ptr; + template friend class lazy_weak_ptr; + + mutable std::tr1::weak_ptr p_; + mutable lazy_ptr_impl i_; + }; + + // operator< is not provided. + // + template void swap (lazy_weak_ptr&, lazy_weak_ptr&); + } +} + +#include +#include + +#include + +#include + +#endif // ODB_TR1_LAZY_PTR_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/tr1/lazy-ptr.ixx b/third-party/odb/libodb-2.4.0/odb/tr1/lazy-ptr.ixx new file mode 100755 index 0000000..45386bd --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/tr1/lazy-ptr.ixx @@ -0,0 +1,632 @@ +// file : odb/tr1/lazy-ptr.ixx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +namespace odb +{ + namespace tr1 + { + // + // lazy_shared_ptr + // + + template + inline lazy_shared_ptr:: + lazy_shared_ptr () {} + + template + template + inline lazy_shared_ptr:: + lazy_shared_ptr (Y* p): p_ (p) {} + + template + template + inline lazy_shared_ptr:: + lazy_shared_ptr (Y* p, D d): p_ (p, d) {} + + template + inline lazy_shared_ptr:: + lazy_shared_ptr (const lazy_shared_ptr& r): p_ (r.p_), i_ (r.i_) {} + + template + template + inline lazy_shared_ptr:: + lazy_shared_ptr (const lazy_shared_ptr& r): p_ (r.p_), i_ (r.i_) {} + + template + template + inline lazy_shared_ptr:: + lazy_shared_ptr (const lazy_weak_ptr& r): i_ (r.i_) + { + // If the pointer has expired but can be re-loaded, then don't throw. + // + p_ = r.lock (); + + if (!p_ && !i_) + throw std::tr1::bad_weak_ptr (); + } + + template + template + inline lazy_shared_ptr:: + lazy_shared_ptr (std::auto_ptr& r): p_ (r) {} + + template + inline lazy_shared_ptr:: + ~lazy_shared_ptr () {} + + template + inline lazy_shared_ptr& lazy_shared_ptr:: + operator= (const lazy_shared_ptr& r) + { + p_ = r.p_; + i_ = r.i_; + return *this; + } + + template + template + inline lazy_shared_ptr& lazy_shared_ptr:: + operator= (const lazy_shared_ptr& r) + { + p_ = r.p_; + i_ = r.i_; + return *this; + } + + template + template + inline lazy_shared_ptr& lazy_shared_ptr:: + operator= (std::auto_ptr& r) + { + p_ = r; + i_.reset (); + return *this; + } + + template + inline void lazy_shared_ptr:: + swap (lazy_shared_ptr& b) + { + p_.swap (b.p_); + i_.swap (b.i_); + } + + template + inline void lazy_shared_ptr:: + reset () + { + p_.reset (); + i_.reset (); + } + + template + template + inline void lazy_shared_ptr:: + reset (Y* p) + { + p_.reset (p); + i_.reset (); + } + + template + template + inline void lazy_shared_ptr:: + reset (Y* p, D d) + { + p_.reset (p, d); + i_.reset (); + } + + template + inline T& lazy_shared_ptr:: + operator* () const + { + return *p_; + } + + template + inline T* lazy_shared_ptr:: + operator-> () const + { + return p_.operator-> (); + } + + template + inline T* lazy_shared_ptr:: + get () const + { + return p_.get (); + } + + template + inline bool lazy_shared_ptr:: + unique () const + { + return p_.unique (); + } + + template + inline long lazy_shared_ptr:: + use_count () const + { + return p_.use_count (); + } + + template + template + inline lazy_shared_ptr:: + lazy_shared_ptr (const std::tr1::shared_ptr& r): p_ (r) {} + + template + template + inline lazy_shared_ptr:: + lazy_shared_ptr (const std::tr1::weak_ptr& r): p_ (r) {} + + template + template + inline lazy_shared_ptr& lazy_shared_ptr:: + operator= (const std::tr1::shared_ptr& r) + { + p_ = r; + i_.reset (); + return *this; + } + + template + inline bool lazy_shared_ptr:: + loaded () const + { + bool i (i_); + return !p_ != i; // !p_ XOR i_ + } + + template + inline std::tr1::shared_ptr lazy_shared_ptr:: + load () const + { + if (!p_ && i_) + p_ = i_.template load (true); // Reset id. + + return p_; + } + + template + inline void lazy_shared_ptr:: + unload () const + { + typedef typename object_traits::object_type object_type; + + if (p_) + { + if (i_.database () != 0) + i_.reset_id (object_traits::id (*p_)); + + p_.reset (); + } + } + + template + inline std::tr1::shared_ptr lazy_shared_ptr:: + get_eager () const + { + return p_; + } + + template + template + inline lazy_shared_ptr:: + lazy_shared_ptr (DB& db, const ID& id): i_ (db, id) {} + + template + template + inline lazy_shared_ptr:: + lazy_shared_ptr (DB& db, Y* p) + : p_ (p) + { + if (p_) + i_.reset_db (db); + } + + template + template + inline lazy_shared_ptr:: + lazy_shared_ptr (DB& db, Y* p, D d) + : p_ (p, d) + { + if (p_) + i_.reset_db (db); + } + + template + template + inline lazy_shared_ptr:: + lazy_shared_ptr (DB& db, std::auto_ptr& r) + : p_ (r) + { + if (p_) + i_.reset_db (db); + } + + template + template + inline lazy_shared_ptr:: + lazy_shared_ptr (DB& db, const std::tr1::shared_ptr& r) + : p_ (r) + { + if (p_) + i_.reset_db (db); + } + + template + template + inline lazy_shared_ptr:: + lazy_shared_ptr (DB& db, const std::tr1::weak_ptr& r) + : p_ (r) + { + if (p_) + i_.reset_db (db); + } + + template + template + inline void lazy_shared_ptr:: + reset (DB& db, const ID& id) + { + p_.reset (); + i_.reset (db, id); + } + + template + template + inline void lazy_shared_ptr:: + reset (DB& db, Y* p) + { + p_.reset (p); + + if (p_) + i_.reset_db (db); + else + i_.reset (); + } + + template + template + inline void lazy_shared_ptr:: + reset (DB& db, Y* p, D d) + { + p_.reset (p, d); + + if (p_) + i_.reset_db (db); + else + i_.reset (); + } + + template + template + inline void lazy_shared_ptr:: + reset (DB& db, std::auto_ptr& r) + { + p_ = r; + + if (p_) + i_.reset_db (db); + else + i_.reset (); + } + + template + template + inline void lazy_shared_ptr:: + reset (DB& db, const std::tr1::shared_ptr& r) + { + p_ = r; + + if (p_) + i_.reset_db (db); + else + i_.reset (); + } + + template + template + inline typename object_traits::id_type lazy_shared_ptr:: + object_id () const + { + typedef typename object_traits::object_type object_type; + + return p_ + ? object_traits::id (*p_) + : i_.template object_id (); + } + + template + inline typename lazy_shared_ptr::database_type& lazy_shared_ptr:: + database () const + { + return *i_.database (); + } + + template + inline bool + operator== (const lazy_shared_ptr& a, const lazy_shared_ptr& b) + { + return a.equal (b); + } + + template + inline bool + operator!= (const lazy_shared_ptr& a, const lazy_shared_ptr& b) + { + return !a.equal (b); + } + + template + inline void + swap (lazy_shared_ptr& a, lazy_shared_ptr& b) + { + a.swap (b); + } + + template + inline D* + get_deleter (const lazy_shared_ptr& p) + { + return std::tr1::get_deleter (p.p_); + } + + + // + // lazy_weak_ptr + // + + template + inline lazy_weak_ptr:: + lazy_weak_ptr () {} + + template + template + inline lazy_weak_ptr:: + lazy_weak_ptr (const lazy_shared_ptr& r): p_ (r.p_), i_ (r.i_) {} + + template + inline lazy_weak_ptr:: + lazy_weak_ptr (const lazy_weak_ptr& r): p_ (r.p_), i_ (r.i_) {} + + template + template + inline lazy_weak_ptr:: + lazy_weak_ptr (const lazy_weak_ptr& r): p_ (r.p_), i_ (r.i_) {} + + template + inline lazy_weak_ptr:: + ~lazy_weak_ptr () {} + + template + inline lazy_weak_ptr& lazy_weak_ptr:: + operator= (const lazy_weak_ptr& r) + { + p_ = r.p_; + i_ = r.i_; + return *this; + } + + template + template + inline lazy_weak_ptr& lazy_weak_ptr:: + operator= (const lazy_weak_ptr& r) + { + p_ = r.p_; + i_ = r.i_; + return *this; + } + + template + template + inline lazy_weak_ptr& lazy_weak_ptr:: + operator= (const lazy_shared_ptr& r) + { + p_ = r.p_; + i_ = r.i_; + return *this; + } + + template + inline void lazy_weak_ptr:: + swap (lazy_weak_ptr& r) + { + p_.swap (r.p_); + i_.swap (r.i_); + } + + template + inline void lazy_weak_ptr:: + reset () + { + p_.reset (); + i_.reset (); + } + + template + inline long lazy_weak_ptr:: + use_count () const + { + return p_.use_count (); + } + + template + inline bool lazy_weak_ptr:: + expired () const + { + return p_.expired (); + } + + template + template + inline lazy_weak_ptr:: + lazy_weak_ptr (const std::tr1::weak_ptr& r): p_ (r) {} + + template + template + inline lazy_weak_ptr:: + lazy_weak_ptr (const std::tr1::shared_ptr& r): p_ (r) {} + + template + template + inline lazy_weak_ptr& lazy_weak_ptr:: + operator= (const std::tr1::weak_ptr& r) + { + p_ = r; + i_.reset (); + return *this; + } + + template + template + inline lazy_weak_ptr& lazy_weak_ptr:: + operator= (const std::tr1::shared_ptr& r) + { + p_ = r; + i_.reset (); + return *this; + } + + template + inline bool lazy_weak_ptr:: + loaded () const + { + bool i (i_); + return expired () != i; // expired () XOR i_ + } + + template + inline std::tr1::shared_ptr lazy_weak_ptr:: + load () const + { + std::tr1::shared_ptr r (p_.lock ()); + + if (!r && i_) + { + r = i_.template load (false); // Keep id. + p_ = r; + } + + return r; + } + + template + inline void lazy_weak_ptr:: + unload () const + { + // With weak pointer we always keep i_ up to date. + // + p_.reset (); + } + + template + inline std::tr1::weak_ptr lazy_weak_ptr:: + get_eager () const + { + return p_; + } + + template + template + inline lazy_weak_ptr:: + lazy_weak_ptr (DB& db, const ID& id): i_ (db, id) {} + + template + template + inline lazy_weak_ptr:: + lazy_weak_ptr (DB& db, const std::tr1::shared_ptr& r) + : p_ (r) + { + typedef typename object_traits::object_type object_type; + + if (r) + i_.reset (db, object_traits::id (*r)); + } + + template + template + inline lazy_weak_ptr:: + lazy_weak_ptr (DB& db, const std::tr1::weak_ptr& r) + : p_ (r) + { + typedef typename object_traits::object_type object_type; + + std::tr1::shared_ptr sp (p_.lock ()); + + if (sp) + i_.reset (db, object_traits::id (*sp)); + } + + template + template + inline void lazy_weak_ptr:: + reset (DB& db, const ID& id) + { + p_.reset (); + i_.reset (db, id); + } + + template + template + inline void lazy_weak_ptr:: + reset (DB& db, const std::tr1::shared_ptr& r) + { + typedef typename object_traits::object_type object_type; + + p_ = r; + + if (r) + i_.reset (db, object_traits::id (*r)); + else + i_.reset (); + } + + template + template + inline void lazy_weak_ptr:: + reset (DB& db, const std::tr1::weak_ptr& r) + { + typedef typename object_traits::object_type object_type; + + p_ = r; + std::tr1::shared_ptr sp (p_.lock ()); + + if (sp) + i_.reset (db, object_traits::id (*sp)); + else + i_.reset (); + } + + template + template + inline typename object_traits::id_type lazy_weak_ptr:: + object_id () const + { + typedef typename object_traits::object_type object_type; + + std::tr1::shared_ptr sp (p_.lock ()); + return sp + ? object_traits::id (*sp) + : i_.template object_id (); + } + + template + inline typename lazy_weak_ptr::database_type& lazy_weak_ptr:: + database () const + { + return *i_.database (); + } + + template + inline void + swap (lazy_weak_ptr& a, lazy_weak_ptr& b) + { + a.swap (b); + } + } +} diff --git a/third-party/odb/libodb-2.4.0/odb/tr1/lazy-ptr.txx b/third-party/odb/libodb-2.4.0/odb/tr1/lazy-ptr.txx new file mode 100755 index 0000000..1f39aec --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/tr1/lazy-ptr.txx @@ -0,0 +1,71 @@ +// file : odb/tr1/lazy-ptr.txx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +namespace odb +{ + namespace tr1 + { + // + // lazy_shared_ptr + // + + template + template + bool lazy_shared_ptr:: + equal (const lazy_shared_ptr& r) const + { + bool t1 (!p_ == loaded ()); + bool t2 (!r.p_ == r.loaded ()); + + // If both are transient, then compare the underlying pointers. + // + if (t1 && t2) + return p_ == r.p_; + + // If one is transient and the other is persistent, then compare + // the underlying pointers but only if they are non NULL. Note + // that an unloaded persistent object is always unequal to a + // transient object. + // + if (t1 || t2) + return p_ == r.p_ && p_; + + // If both objects are persistent, then we compare databases and + // object ids. + // + typedef typename object_traits::object_type object_type1; + typedef typename object_traits::object_type object_type2; + + return i_.database () == r.i_.database () && + object_id () == r.template object_id (); + } + + // + // lazy_weak_ptr + // + + template + lazy_shared_ptr lazy_weak_ptr:: + lock () const + { + std::tr1::shared_ptr sp (p_.lock ()); + + if (sp) + { + if (database_type* db = i_.database ()) + return lazy_shared_ptr (*db, sp); + else + return lazy_shared_ptr (sp); + } + else + { + if (i_) + return lazy_shared_ptr ( + *i_.database (), i_.template object_id ()); + else + return lazy_shared_ptr (); + } + } + } +} diff --git a/third-party/odb/libodb-2.4.0/odb/tr1/memory.hxx b/third-party/odb/libodb-2.4.0/odb/tr1/memory.hxx new file mode 100755 index 0000000..c78c694 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/tr1/memory.hxx @@ -0,0 +1,38 @@ +// file : odb/tr1/memory.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_TR1_MEMORY_HXX +#define ODB_TR1_MEMORY_HXX + +// +// Try to include TR1 in a compiler-specific manner. Fall back +// on the Boost TR1 implementation if the compiler does not support TR1. +// + +#include // __GLIBCXX__, _HAS_TR1 + +// GNU C++ or Intel C++ using libstd++. +// +#if defined (__GNUC__) && __GNUC__ >= 4 && defined (__GLIBCXX__) +# include +// +// IBM XL C++. +// +#elif defined (__xlC__) && __xlC__ >= 0x0900 +# define __IBMCPP_TR1__ +# include +// +// VC++ or Intel C++ using VC++ standard library. +// +#elif defined (_MSC_VER) && \ + (_MSC_VER == 1500 && defined (_HAS_TR1) || _MSC_VER > 1500) +# include +// +// Boost fall-back. +// +#else +# include +#endif + +#endif // ODB_TR1_MEMORY_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/tr1/pointer-traits.hxx b/third-party/odb/libodb-2.4.0/odb/tr1/pointer-traits.hxx new file mode 100755 index 0000000..3b7e2a5 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/tr1/pointer-traits.hxx @@ -0,0 +1,122 @@ +// file : odb/tr1/pointer-traits.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_TR1_POINTER_TRAITS_HXX +#define ODB_TR1_POINTER_TRAITS_HXX + +#include + +#include // ODB_CXX11 + +// In VC++ std::shared_ptr and std::tr1::shared_ptr is the same class +// template. One is just a using-declaration for the other. +// +#if !(defined(ODB_CXX11) && defined(_MSC_VER)) + +// +// This header assumes that the necessary TR1 header has already +// been included. +// + +#include +#include + +namespace odb +{ + // Specialization for std::tr1::shared_ptr. + // + template + class pointer_traits > + { + public: + static const pointer_kind kind = pk_shared; + static const bool lazy = false; + + typedef T element_type; + typedef std::tr1::shared_ptr pointer_type; + typedef std::tr1::shared_ptr const_pointer_type; + typedef typename odb::details::meta::remove_const::result + unrestricted_element_type; + typedef std::tr1::shared_ptr + unrestricted_pointer_type; + typedef smart_ptr_guard guard; + + static element_type* + get_ptr (const pointer_type& p) + { + return p.get (); + } + + static element_type& + get_ref (const pointer_type& p) + { + return *p; + } + + static bool + null_ptr (const pointer_type& p) + { + return !p; + } + + static unrestricted_pointer_type + const_pointer_cast (const pointer_type& p) + { + return std::tr1::const_pointer_cast (p); + } + + template + static std::tr1::shared_ptr + static_pointer_cast (const pointer_type& p) + { + return std::tr1::static_pointer_cast (p); + } + + template + static std::tr1::shared_ptr + dynamic_pointer_cast (const pointer_type& p) + { + return std::tr1::dynamic_pointer_cast (p); + } + + public: + static void* + allocate (std::size_t n) + { + return operator new (n); + } + + static void + free (void* p) + { + operator delete (p); + } + }; + + // Specialization for std::tr1::weak_ptr. + // + template + class pointer_traits > + { + public: + static const pointer_kind kind = pk_weak; + static const bool lazy = false; + + typedef T element_type; + typedef std::tr1::weak_ptr pointer_type; + typedef std::tr1::shared_ptr strong_pointer_type; + + static strong_pointer_type + lock (const pointer_type& p) + { + return p.lock (); + } + }; +} + +#endif // !(ODB_CXX11 && _MSC_VER) + +#include + +#endif // ODB_TR1_POINTER_TRAITS_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/tr1/wrapper-traits.hxx b/third-party/odb/libodb-2.4.0/odb/tr1/wrapper-traits.hxx new file mode 100755 index 0000000..15bbe7e --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/tr1/wrapper-traits.hxx @@ -0,0 +1,77 @@ +// file : odb/tr1/wrapper-traits.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_TR1_WRAPPER_TRAITS_HXX +#define ODB_TR1_WRAPPER_TRAITS_HXX + +#include + +#include // ODB_CXX11 + +// In VC++ std::shared_ptr and std::tr1::shared_ptr is the same class +// template. One is just a using-declaration for the other. +// +#if !(defined(ODB_CXX11) && defined(_MSC_VER)) + +// +// This header assumes that the necessary TR1 header has already +// been included. +// + +#include + +namespace odb +{ + // Specialization for std::tr1::shared_ptr. + // + template + class wrapper_traits< std::tr1::shared_ptr > + { + public: + typedef T wrapped_type; + typedef std::tr1::shared_ptr wrapper_type; + + // T can be const. + // + typedef + typename odb::details::meta::remove_const::result + unrestricted_wrapped_type; + + static const bool null_handler = true; + static const bool null_default = false; + + static bool + get_null (const wrapper_type& p) + { + return !p; + } + + static void + set_null (wrapper_type& p) + { + p.reset (); + } + + static const wrapped_type& + get_ref (const wrapper_type& p) + { + return *p; + } + + static unrestricted_wrapped_type& + set_ref (wrapper_type& p) + { + if (!p) + p.reset (new unrestricted_wrapped_type); + + return const_cast (*p); + } + }; +} + +#endif // !(ODB_CXX11 && _MSC_VER) + +#include + +#endif // ODB_TR1_WRAPPER_TRAITS_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/tracer.cxx b/third-party/odb/libodb-2.4.0/odb/tracer.cxx new file mode 100755 index 0000000..09a2a2b --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/tracer.cxx @@ -0,0 +1,96 @@ +// file : odb/tracer.cxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include + +#include +#include + +using namespace std; + +namespace odb +{ + // + // tracer + // + + tracer:: + ~tracer () + { + } + + void tracer:: + prepare (connection&, const statement&) + { + } + + void tracer:: + execute (connection& c, const statement& s) + { + execute (c, s.text ()); + } + + void tracer:: + deallocate (connection&, const statement&) + { + } + + // + // stderr_tracer + // + + class stderr_tracer_type: public tracer + { + public: + stderr_tracer_type (bool full): full_ (full) {} + + virtual void + prepare (connection&, const statement&); + + virtual void + execute (connection&, const char* statement); + + virtual void + deallocate (connection&, const statement&); + + // Override the other version to get rid of a Sun CC warning. + // + virtual void + execute (connection&, const statement&); + + private: + bool full_; + }; + + void stderr_tracer_type:: + prepare (connection&, const statement& s) + { + if (full_) + cerr << "PREPARE " << s.text () << endl; + } + + void stderr_tracer_type:: + execute (connection&, const char* s) + { + cerr << s << endl; + } + + void stderr_tracer_type:: + deallocate (connection&, const statement& s) + { + if (full_) + cerr << "DEALLOCATE " << s.text () << endl; + } + + void stderr_tracer_type:: + execute (connection& c, const statement& s) + { + execute (c, s.text ()); + } + + static stderr_tracer_type stderr_tracer_ (false); + static stderr_tracer_type stderr_full_tracer_ (true); + tracer& stderr_tracer = stderr_tracer_; + tracer& stderr_full_tracer = stderr_full_tracer_; +} diff --git a/third-party/odb/libodb-2.4.0/odb/tracer.hxx b/third-party/odb/libodb-2.4.0/odb/tracer.hxx new file mode 100755 index 0000000..c5a6621 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/tracer.hxx @@ -0,0 +1,37 @@ +// file : odb/tracer.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_TRACER_HXX +#define ODB_TRACER_HXX + +#include + +#include +#include + +namespace odb +{ + class LIBODB_EXPORT tracer + { + public: + virtual + ~tracer (); + + virtual void + prepare (connection&, const statement&); + + virtual void + execute (connection&, const statement&); + + virtual void + execute (connection&, const char* statement) = 0; + + virtual void + deallocate (connection&, const statement&); + }; +} + +#include + +#endif // ODB_TRACER_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/traits.hxx b/third-party/odb/libodb-2.4.0/odb/traits.hxx new file mode 100755 index 0000000..210e63d --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/traits.hxx @@ -0,0 +1,306 @@ +// file : odb/traits.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_TRAITS_HXX +#define ODB_TRAITS_HXX + +#include + +#include +#include + +namespace odb +{ + // Fallback dummy for non-persistent classes. It is necessary to allow + // the C++ compiler to instantiate persist(), etc., signatures in class + // database when T is a pointer (raw, smart). The overloads that use + // these dummy would never actually be selected by the compiler. + // + template + class access::object_traits + { + // If a C++ compiler issues an error pointing to this class and saying + // that it is missing some declaration, then you are most likely trying + // to perform a database operation on a C++ type that is not a persistent + // object. Or you forgot to include the corresponding -odb.hxx file. + // + public: + struct id_type {}; + typedef T object_type; + typedef T* pointer_type; + + static const bool polymorphic = false; + }; + + template + class access::object_factory + { + public: + typedef T object_type; + typedef P pointer_type; + + static P + create () + { + // By default use pointer-specific construction. + // + return pointer_factory::create (); + } + }; + + template + class access::view_factory + { + public: + typedef T view_type; + typedef P pointer_type; + + static P + create () + { + // By default use pointer-specific construction. + // + return pointer_factory::create (); + } + }; + + template + class access::pointer_factory + { + public: + typedef T value_type; + typedef P pointer_type; + + static P + create () + { + void* v (pointer_traits

::allocate (sizeof (T))); + mem_guard g (v); + P p (new (v) T); + g.release (); + return p; + } + + private: + struct mem_guard + { + mem_guard (void* p): p_ (p) {} + ~mem_guard () {if (p_) pointer_traits

::free (p_);} + void release () {p_ = 0;} + void* p_; + }; + }; + + // + // class_traits + // + enum class_kind + { + class_object, + class_view, + class_other + }; + + template + struct class_traits + { + static const class_kind kind = class_other; + }; + + template + struct class_traits + { + static const class_kind kind = class_traits::kind; + }; + + // + // object_traits + // + + template + // + // If a C++ compiler issues an error pointing to this struct and + // saying that it is incomplete, then you are most likely trying to + // perform a database operation on a C++ type that is not a persistent + // object. Or you forgot to include the corresponding -odb.hxx file. + // + struct object_traits: + access::object_traits, + access::object_factory::pointer_type> + { + typedef + odb::pointer_traits::pointer_type> + pointer_traits; + + typedef typename access::object_traits::object_type object_type; + typedef typename access::object_traits::pointer_type pointer_type; + typedef typename pointer_traits::const_pointer_type const_pointer_type; + }; + + // Specialization for const objects. It only defines the id, object, + // pointer, and const_pointer types with pointer and const_pointer + // being the same. The idea is to only use this specialization in the + // interfaces, with the implementations detecting this situation and + // using the non-const object_traits version. + // + template + struct object_traits + { + private: + typedef + odb::pointer_traits::pointer_type> + pointer_traits; + + public: + typedef typename access::object_traits::id_type id_type; + typedef typename access::object_traits::object_type object_type; + typedef typename pointer_traits::const_pointer_type const_pointer_type; + typedef const_pointer_type pointer_type; + + static const bool polymorphic = access::object_traits::polymorphic; + }; + + // Specialization for section to allow instantiation of all the load() + // signature. + // + template <> + struct object_traits

{}; + + template + // + // If a C++ compiler issues an error pointing to this struct and + // saying that it is incomplete, then you are most likely trying to + // perform a database operation on a C++ type that is not a persistent + // object. Or you forgot to include the corresponding -odb.hxx file. + // + struct object_traits_impl: + access::object_traits_impl, + access::object_factory::pointer_type> + { + typedef + odb::pointer_traits::pointer_type> + pointer_traits; + + typedef typename access::object_traits::object_type object_type; + typedef typename access::object_traits::pointer_type pointer_type; + typedef typename pointer_traits::const_pointer_type const_pointer_type; + }; + + // + // view_traits + // + + template + // + // If a C++ compiler issues an error pointing to this struct and + // saying that it is incomplete, then you are most likely trying to + // perform a database operation on a C++ type that is not a view + // Or you forgot to include the corresponding -odb.hxx file. + // + struct view_traits: + access::view_traits, + access::view_factory::pointer_type> + { + typedef + odb::pointer_traits::pointer_type> + pointer_traits; + + typedef typename access::view_traits::view_type view_type; + typedef typename access::view_traits::pointer_type pointer_type; + }; + + // Specialization for const views. It only defines the view, pointer, + // and const_pointer types with pointer and const_pointer being the + // same. Similar to objects, the idea is to only use this specialization + // in the interfaces, with the implementations detecting this situation + // and using the non-const view_traits version. + // + template + struct view_traits + { + private: + typedef + odb::pointer_traits::pointer_type> + pointer_traits; + + public: + typedef typename access::view_traits::view_type view_type; + typedef typename pointer_traits::const_pointer_type const_pointer_type; + typedef const_pointer_type pointer_type; + }; + + template + // + // If a C++ compiler issues an error pointing to this struct and + // saying that it is incomplete, then you are most likely trying to + // perform a database operation on a C++ type that is not a view + // Or you forgot to include the corresponding -odb.hxx file. + // + struct view_traits_impl: + access::view_traits_impl, + access::view_factory::pointer_type> + { + typedef + odb::pointer_traits::pointer_type> + pointer_traits; + + typedef typename access::view_traits::view_type view_type; + typedef typename access::view_traits::pointer_type pointer_type; + }; + + // + // composite_value_traits + // + + template + struct composite_value_traits: access::composite_value_traits + { + }; + + // + // Get root image from a polymorphic image chain. + // + + template + struct root_image_impl + { + typedef root_image_impl base_type; + typedef typename base_type::image_type image_type; + + static image_type& + get (typename T::image_type& i) {return base_type::get (*i.base);} + }; + + template + struct root_image_impl + { + typedef typename T::image_type image_type; + + static image_type& + get (image_type& i) {return i;} + }; + + template + struct root_image + { + typedef root_image_impl impl_type; + typedef typename impl_type::image_type image_type; + + static image_type& + get (typename T::image_type& i) {return impl_type::get (i);} + }; + + template + struct root_image + { + typedef typename T::image_type image_type; + + static image_type& + get (image_type& i) {return i;} + }; +} + +#include + +#endif // ODB_TRAITS_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/transaction.cxx b/third-party/odb/libodb-2.4.0/odb/transaction.cxx new file mode 100755 index 0000000..300496f --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/transaction.cxx @@ -0,0 +1,335 @@ +// file : odb/transaction.cxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include +#include + +#include + +using namespace std; + +namespace odb +{ + using namespace details; + + // + // transaction + // + + static ODB_TLS_POINTER (transaction) current_transaction; + + transaction:: + ~transaction () + { + if (!finalized_) + try {rollback ();} catch (...) {} + } + + void transaction:: + reset (transaction_impl* impl, bool make_current) + { + details::unique_ptr i (impl); + + if (!finalized_) + rollback (); + + impl_.reset (i.release ()); + + if (make_current && tls_get (current_transaction) != 0) + throw already_in_transaction (); + + impl_->start (); + finalized_ = false; + + if (make_current) + tls_set (current_transaction, this); + } + + bool transaction:: + has_current () + { + return tls_get (current_transaction) != 0; + } + + transaction& transaction:: + current () + { + transaction* cur (tls_get (current_transaction)); + + if (cur == 0) + throw not_in_transaction (); + + return *cur; + } + + void transaction:: + current (transaction& t) + { + tls_set (current_transaction, &t); + } + + void transaction:: + reset_current () + { + transaction* t (0); + tls_set (current_transaction, t); + } + + struct rollback_guard + { + rollback_guard (transaction& t): t_ (&t) {} + ~rollback_guard () + {if (t_ != 0) t_->callback_call (transaction::event_rollback);} + void release () {t_ = 0;} + private: + transaction* t_; + }; + + void transaction:: + commit () + { + if (finalized_) + throw transaction_already_finalized (); + + finalized_ = true; + rollback_guard rg (*this); + + impl_->connection ().transaction_tracer_ = 0; + + if (tls_get (current_transaction) == this) + { + transaction* t (0); + tls_set (current_transaction, t); + } + + impl_->commit (); + rg.release (); + + if (callback_count_ != 0) + callback_call (event_commit); + } + + void transaction:: + rollback () + { + if (finalized_) + throw transaction_already_finalized (); + + finalized_ = true; + rollback_guard rg (*this); + + impl_->connection ().transaction_tracer_ = 0; + + if (tls_get (current_transaction) == this) + { + transaction* t (0); + tls_set (current_transaction, t); + } + + impl_->rollback (); + rg.release (); + + if (callback_count_ != 0) + callback_call (event_rollback); + } + + void transaction:: + callback_call (unsigned short event) + { + size_t stack_count (callback_count_ < stack_callback_count + ? callback_count_ : stack_callback_count); + size_t dyn_count (callback_count_ - stack_count); + + // We need to be careful with the situation where a callback + // throws and we neither call the rest of the callbacks nor + // reset their states. To make sure this doesn't happen, we + // do a first pass and reset all the states. + // + for (size_t i (0); i < stack_count; ++i) + { + callback_data& d (stack_callbacks_[i]); + if (d.event != 0 && d.state != 0) + *d.state = 0; + } + + for (size_t i (0); i < dyn_count; ++i) + { + callback_data& d (dyn_callbacks_[i]); + if (d.event != 0 && d.state != 0) + *d.state = 0; + } + + // Now do the actual calls. + // + for (size_t i (0); i < stack_count; ++i) + { + callback_data& d (stack_callbacks_[i]); + if (d.event & event) + d.func (event, d.key, d.data); + } + + for (size_t i (0); i < dyn_count; ++i) + { + callback_data& d (dyn_callbacks_[i]); + if (d.event & event) + d.func (event, d.key, d.data); + } + + // Clean things up in case this instance is going to be reused. + // + if (dyn_count != 0) + dyn_callbacks_.clear (); + + free_callback_ = max_callback_count; + callback_count_ = 0; + } + + void transaction:: + callback_register (callback_type func, + void* key, + unsigned short event, + unsigned long long data, + transaction** state) + { + callback_data* s; + + // If we have a free slot, use it. + // + if (free_callback_ != max_callback_count) + { + s = (free_callback_ < stack_callback_count) + ? stack_callbacks_ + free_callback_ + : &dyn_callbacks_[free_callback_ - stack_callback_count]; + + free_callback_ = reinterpret_cast (s->key); + } + // If we have space in the stack, grab that. + // + else if (callback_count_ < stack_callback_count) + { + s = stack_callbacks_ + callback_count_; + callback_count_++; + } + // Otherwise use the dynamic storage. + // + else + { + dyn_callbacks_.push_back (callback_data ()); + s = &dyn_callbacks_.back (); + callback_count_++; + } + + s->func = func; + s->key = key; + s->event = event; + s->data = data; + s->state = state; + } + + size_t transaction:: + callback_find (void* key) + { + if (callback_count_ == 0) + return 0; + + size_t stack_count; + + // See if this is the last slot registered. This will be a fast path if, + // for example, things are going to be unregistered from destructors. + // + if (callback_count_ <= stack_callback_count) + { + if (stack_callbacks_[callback_count_ - 1].key == key) + return callback_count_ - 1; + + stack_count = callback_count_; + } + else + { + if (dyn_callbacks_.back ().key == key) + return callback_count_ - 1; + + stack_count = stack_callback_count; + } + + // Otherwise do a linear search. + // + for (size_t i (0); i < stack_count; ++i) + if (stack_callbacks_[i].key == key) + return i; + + for (size_t i (0), dyn_count (callback_count_ - stack_count); + i < dyn_count; ++i) + if (dyn_callbacks_[i].key == key) + return i + stack_callback_count; + + return callback_count_; + } + + void transaction:: + callback_unregister (void* key) + { + size_t i (callback_find (key)); + + // It is ok for this function not to find the key. + // + if (i == callback_count_) + return; + + // See if this is the last slot registered. + // + if (i == callback_count_ - 1) + { + if (i >= stack_callback_count) + dyn_callbacks_.pop_back (); + + callback_count_--; + } + else + { + callback_data& d ( + i < stack_callback_count + ? stack_callbacks_[i] + : dyn_callbacks_[i - stack_callback_count]); + + // Add to the free list. + // + d.event = 0; + d.key = reinterpret_cast (free_callback_); + free_callback_ = i; + } + } + + void transaction:: + callback_update (void* key, + unsigned short event, + unsigned long long data, + transaction** state) + { + size_t i (callback_find (key)); + + // It is ok for this function not to find the key. + // + if (i == callback_count_) + return; + + callback_data& d ( + i < stack_callback_count + ? stack_callbacks_[i] + : dyn_callbacks_[i - stack_callback_count]); + + d.event = event; + d.data = data; + d.state = state; + } + + // + // transaction_impl + // + + transaction_impl:: + ~transaction_impl () + { + } +} diff --git a/third-party/odb/libodb-2.4.0/odb/transaction.hxx b/third-party/odb/libodb-2.4.0/odb/transaction.hxx new file mode 100755 index 0000000..34ddd66 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/transaction.hxx @@ -0,0 +1,267 @@ +// file : odb/transaction.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_TRANSACTION_HXX +#define ODB_TRANSACTION_HXX + +#include + +#include +#include // std::size_t + +#include + +#include +#include + +namespace odb +{ + class transaction_impl; + + class LIBODB_EXPORT transaction + { + public: + typedef odb::database database_type; + typedef odb::connection connection_type; + + // If the second argument is false, then this transaction is not made + // the current transaction of the thread. + // + explicit + transaction (transaction_impl*, bool make_current = true); + + // Create a finalized transaction instance which can later be initialized + // with reset(). + // + transaction (); + + // Unless the transaction has already been finalized (explicitly + // committed or rolled back), the destructor will roll it back. + // + ~transaction (); + + // Unless the current transaction has already been finalized (explicitly + // committed or rolled back), reset will roll it back. If the second + // argument is false, then this transaction is not made the current + // transaction of the thread. + // + void + reset (transaction_impl*, bool make_current = true); + + void + commit (); + + void + rollback (); + + // Return the database this transaction is on. + // + database_type& + database (); + + // Return the connection this transaction is on. + // + connection_type& + connection (); + + bool + finalized () const {return finalized_;} + + public: + // Return true if there is a transaction in effect. + // + static bool + has_current (); + + // Return current transaction or throw if there is no transaction + // in effect. + // + static transaction& + current (); + + // Set the current thread's transaction. + // + static void + current (transaction&); + + // Revert to the no transaction in effect state for the current thread. + // + static void + reset_current (); + + // SQL statement tracing. + // + public: + typedef odb::tracer tracer_type; + + void + tracer (tracer_type&); + + void + tracer (tracer_type*); + + tracer_type* + tracer () const; + + // Post-commit/rollback callbacks. + // + public: + static const unsigned short event_commit = 0x01; + static const unsigned short event_rollback = 0x02; + static const unsigned short event_all = event_commit | event_rollback; + + typedef void (*callback_type) ( + unsigned short event, void* key, unsigned long long data); + + // Register a post-commit/rollback callback. The data argument + // can be used to store any user data that does not exceed 8 + // bytes and doesn't require alignment greater than unsigned + // long long, such as an old value that needs to be restored + // in case of a rollback. + // + // The state argument can be used to indicate to the caller + // that the callback has been unregistered because the + // transaction has terminated. In this case the transaction + // resets the passed pointer to 0. + // + // Note that the order in which the callbacks are called is + // unspecified. + // + void + callback_register (callback_type, + void* key, + unsigned short event = event_all, + unsigned long long data = 0, + transaction** state = 0); + + // Unregister a post-commit/rollback callback. Note that this is a + // potentially slow operation. You also don't need to unregister + // a callback that has been called or auto-reset using the state + // argument passed to register(). This function does nothing if + // the key is not found. + // + void + callback_unregister (void* key); + + // Update the event, data, and state values for a callback. Note + // that just like unregister(), this is a potentially slow operation. + // + void + callback_update (void* key, + unsigned short event, + unsigned long long data = 0, + transaction** state = 0); + + public: + transaction_impl& + implementation (); + + // Copying or assignment of transactions is not supported. + // + private: + transaction (const transaction&); + transaction& operator= (const transaction&); + + protected: + friend struct rollback_guard; + + std::size_t + callback_find (void* key); + + void + callback_call (unsigned short event); + + protected: + bool finalized_; + details::unique_ptr impl_; + + // Callbacks. + // + struct callback_data + { + unsigned short event; + callback_type func; + void* key; + unsigned long long data; + transaction** state; + }; + + // Slots for the first 20 callback are pre-allocated on the stack. + // For the rest they are allocated dynamically as needed. + // + // Note, if you change stack_callback_count, make sure you also + // update the common/transaction/callback test accordingly. + // + static const std::size_t stack_callback_count = 20; + static const std::size_t max_callback_count = ~(std::size_t (0)); + + callback_data stack_callbacks_[stack_callback_count]; + std::vector dyn_callbacks_; + + // When a callback is unregistered, the free slot from the stack is + // added to the linked list of free slots which is organized by + // re-using the key data member to store the slot's index (we cannot + // store a pointer because std::vector may move slots on expansion). + // The value equal to max_callback_count indicates no free slots are + // available. + // + std::size_t free_callback_; + + // Total number of used slots, both registered and in the free list. + // + std::size_t callback_count_; + }; + + class LIBODB_EXPORT transaction_impl + { + public: + typedef odb::database database_type; + typedef odb::connection connection_type; + + virtual + ~transaction_impl (); + + virtual void + start () = 0; + + virtual void + commit () = 0; + + virtual void + rollback () = 0; + + database_type& + database () + { + return database_; + } + + connection_type& + connection () + { + return *connection_; + } + + protected: + transaction_impl (database_type& db) + : database_ (db), connection_ (0) + { + } + + transaction_impl (database_type& db, connection_type& c) + : database_ (db), connection_ (&c) + { + } + + protected: + database_type& database_; + connection_type* connection_; + }; +} + +#include + +#include + +#endif // ODB_TRANSACTION_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/transaction.ixx b/third-party/odb/libodb-2.4.0/odb/transaction.ixx new file mode 100755 index 0000000..0e03b2d --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/transaction.ixx @@ -0,0 +1,66 @@ +// file : odb/transaction.ixx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include + +namespace odb +{ + inline transaction:: + transaction () + : finalized_ (true), + impl_ (0), + free_callback_ (max_callback_count), + callback_count_ (0) + { + } + + inline transaction:: + transaction (transaction_impl* impl, bool make_current) + : finalized_ (true), + impl_ (0), + free_callback_ (max_callback_count), + callback_count_ (0) + { + reset (impl, make_current); + } + + inline transaction::database_type& transaction:: + database () + { + return impl_->database (); + } + + inline transaction::connection_type& transaction:: + connection () + { + return impl_->connection (); + } + + inline transaction_impl& transaction:: + implementation () + { + return *impl_; + } + + // The transaction-specific tracer is stored in the connection. See + // the connection class for the reason. + // + inline void transaction:: + tracer (tracer_type& t) + { + impl_->connection ().transaction_tracer_ = &t; + } + + inline void transaction:: + tracer (tracer_type* t) + { + impl_->connection ().transaction_tracer_ = t; + } + + inline transaction::tracer_type* transaction:: + tracer () const + { + return impl_->connection ().transaction_tracer_; + } +} diff --git a/third-party/odb/libodb-2.4.0/odb/vector-impl.cxx b/third-party/odb/libodb-2.4.0/odb/vector-impl.cxx new file mode 100755 index 0000000..e2c4fd7 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/vector-impl.cxx @@ -0,0 +1,209 @@ +// file : odb/vector-impl.cxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include + +#include // std::memcpy, std::memset +#include // std::swap + +using namespace std; + +namespace odb +{ + // vector_impl + // + const unsigned char vector_impl::mask_[4] = {0x3, 0xC, 0x30, 0xC0}; + const unsigned char vector_impl::shift_[4] = {0, 2, 4, 6}; + + vector_impl:: + vector_impl (const vector_impl& x) + : state_ (x.state_), size_ (0), tail_ (0), capacity_ (0), data_ (0) + { + // Copy the data over if we are tracking. + // + if (state_ == state_tracking && x.size_ != 0) + { + realloc (x.size_ < 1024 ? 1024 : x.size_); + memcpy (data_, x.data_, x.size_ / 4 + (x.size_ % 4 == 0 ? 0 : 1)); + size_ = x.size_; + tail_ = x.tail_; + } + } + + void vector_impl:: + realloc (size_t n) + { + // The new capacity can be less or greater than the old one, but + // it cannot be less than size. + // + size_t b (n / 4 + (n % 4 == 0 ? 0 : 1)); + + if (b != capacity_ * 4) + { + unsigned char* d (static_cast (operator new (b))); + + if (size_ != 0) + memcpy (d, data_, size_ / 4 + (size_ % 4 == 0 ? 0 : 1)); + + if (data_ != 0) + operator delete (data_); + + data_ = d; + capacity_ = b * 4; + } + } + + void vector_impl:: + shrink_to_fit () + { + if (size_ != capacity_) + { + if (size_ != 0) + realloc (size_); + else + { + operator delete (data_); + data_ = 0; + capacity_ = 0; + } + } + } + + void vector_impl:: + start (size_t n) + { + if (n != 0) + { + if (capacity_ < n) + { + size_ = 0; + realloc (n < 1024 ? 1024 : n); + } + + memset (data_, 0, n / 4 + (n % 4 == 0 ? 0 : 1)); + } + + state_ = state_tracking; + size_ = tail_ = n; + } + + void vector_impl:: + push_back (size_t n) + { + for (; n != 0; --n) + { + size_t i (tail_); + + element_state_type s; + if (i != size_) + // We have an erased element we can reuse. + // + s = state_updated; + else + { + if (size_ == capacity_) + { + size_t c (capacity_ == 0 ? 1024 : capacity_ * 2); + if (c < size_ + n) + c = size_ + n; + realloc (c); + } + + s = state_inserted; + size_++; + } + + set (i, s); + tail_++; + } + } + + void vector_impl:: + pop_back (size_t n) + { + for (; n != 0; --n) + { + size_t i (tail_ - 1); + + if (state (i) != state_inserted) + set (i, state_erased); + else + size_--; // tail_ == size_ + + tail_--; + } + } + + void vector_impl:: + insert (size_t i, size_t n) + { + for (; i != tail_; ++i) + if (state (i) != state_inserted) + set (i, state_updated); + + push_back (n); + } + + void vector_impl:: + erase (size_t i, size_t n) + { + pop_back (n); + + for (; i != tail_; ++i) + if (state (i) != state_inserted) + set (i, state_updated); + } + + void vector_impl:: + clear () + { + // The idea is to drop any inserted elements from the back and + // set everything else to erased. + // + if (tail_ == size_) + { + while (size_ != 0 && state (size_ - 1) == state_inserted) + size_--; + + tail_ = size_; + } + + if (tail_ != 0) + memset (data_, 0xFF, tail_ / 4 + (tail_ % 4 == 0 ? 0 : 1)); + + tail_ = 0; + } + + // vector_base + // + void vector_base:: + rollback (unsigned short, void* key, unsigned long long) + { + // Mark as changed. + // + static_cast (key)->impl_.change (); + } + + void vector_base:: + swap_tran (vector_base& x) + { + // If either instance is armed, then we need to update the + // callback registration. + // + transaction* t (x.tran_); + if (tran_ != 0) + { + tran_->callback_unregister (this); + x._arm (*tran_); + } + + if (t != 0) + { + t->callback_unregister (&x); + _arm (*t); + } + + std::swap (tran_, x.tran_); + } +} diff --git a/third-party/odb/libodb-2.4.0/odb/vector-impl.hxx b/third-party/odb/libodb-2.4.0/odb/vector-impl.hxx new file mode 100755 index 0000000..55b3103 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/vector-impl.hxx @@ -0,0 +1,222 @@ +// file : odb/vector-impl.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_VECTOR_IMPL_HXX +#define ODB_VECTOR_IMPL_HXX + +#include +#include // ODB_CXX11 + +#include +#include // std::size_t + +#include +#include + +namespace odb +{ + // Change tracking vector implementation details. + // + class LIBODB_EXPORT vector_impl + { + public: + enum element_state_type + { + state_unchanged, + state_inserted, + state_updated, + state_erased + }; + + enum container_state_type + { + state_tracking, + state_not_tracking, + state_changed // Container has changed but individual changes + // were not tracked. + }; + + vector_impl (); + ~vector_impl (); + + // The copy constructor will copy the state. The idea is that the + // copy keeps tracking changes, just like the original. + // + vector_impl (const vector_impl&); + +#ifdef ODB_CXX11 + vector_impl (vector_impl&&); +#endif + + void + swap (vector_impl& x); + + // Allocate enough memory to store the specified number of + // elements. + // + void + reserve (std::size_t); + + // Reduce capacity to size. + // + void + shrink_to_fit (); + + // Capacity (each entry takes 2 bits). + // + std::size_t + capacity () const; + + // (Re)start tracking changes for a vector with n elements. + // + void + start (std::size_t); + + // Stop tracking changes. + // + void + stop (); + + // Mark the container as changed without tracking the changes. + // This state is useful as a fallback mechnism for situations + // where the change information has been discarded (e.g., after + // its state has been updated in the database) but the container + // should remain changed (e.g., after the transaction is rolled + // back). + // + void + change (); + + // Get the state of the container. + // + container_state_type + state () const; + + // Shortcut for state() == state_tracking. + // + bool + tracking () const; + + // Note that the returned size can be greater than the actual, + // parallel vector size. In this case the difference is the + // erased elements at the back. + // + std::size_t + size () const; + + // Get the change state of the specified element. + // + element_state_type + state (std::size_t) const; + + // Change notifications. + // + void + push_back (std::size_t n = 1); + + void + pop_back (std::size_t n = 1); + + void + insert (std::size_t, std::size_t n = 1); + + void + erase (std::size_t, std::size_t n = 1); + + void + modify (std::size_t, std::size_t n = 1); + + void + clear (); + + void + assign (std::size_t n); + + void + resize (std::size_t n); + + private: + // Assignment does not make sense (it is changing of the content). + // + vector_impl& operator= (const vector_impl&); + + private: + void + realloc (std::size_t); + + void + set (std::size_t, element_state_type); + + static const unsigned char mask_[4]; + static const unsigned char shift_[4]; + + container_state_type state_; + + // Size, tail, and capacity are in 2-bit blocks. Size is the number + // of elements we have in data. Tail is the position of the first + // erased element at the back. If there are no erased elements, then + // tail is equal size. Capacity is the number of elements we can + // store in data. + // + std::size_t size_; + std::size_t tail_; + std::size_t capacity_; + unsigned char* data_; + }; + + // Base class that provides a change tracking interface and + // handles the rollback callback. The only function that's + // missing is _start() which needs to know the number of + // elements currently in the vector. + // + class LIBODB_EXPORT vector_base + { + public: + void + _stop () const; + + bool + _tracking () const; + + void + _arm (transaction& t) const; + + vector_impl& + _impl () const {return impl_;} + + private: + // Assignment is changing of the content. + // + vector_base& operator= (const vector_base&); + + protected: + ~vector_base (); + vector_base (); + vector_base (const vector_base&); + +#ifdef ODB_CXX11 + vector_base (vector_base&&); +#endif + + void + swap (vector_base&); + + static void + rollback (unsigned short, void* key, unsigned long long); + + private: + void + swap_tran (vector_base&); + + protected: + mutable vector_impl impl_; + mutable transaction* tran_; + }; +} + +#include + +#include + +#endif // ODB_VECTOR_IMPL_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/vector-impl.ixx b/third-party/odb/libodb-2.4.0/odb/vector-impl.ixx new file mode 100755 index 0000000..4865dd2 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/vector-impl.ixx @@ -0,0 +1,204 @@ +// file : odb/vector-impl.ixx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifdef ODB_CXX11 +# include // std::swap, std::move +#else +# include // std::swap +#endif + +namespace odb +{ + // vector_impl + // + inline vector_impl:: + vector_impl () + : state_ (state_not_tracking), + size_ (0), tail_ (0), capacity_ (0), data_ (0) + { + } + +#ifdef ODB_CXX11 + inline vector_impl:: + vector_impl (vector_impl&& x) + : state_ (state_not_tracking), + size_ (0), tail_ (0), capacity_ (0), data_ (0) + { + swap (x); + } +#endif + + inline vector_impl:: + ~vector_impl () + { + if (data_ != 0) + operator delete (data_); + } + + inline void vector_impl:: + swap (vector_impl& x) + { + std::swap (state_, x.state_); + std::swap (size_, x.size_); + std::swap (tail_, x.tail_); + std::swap (capacity_, x.capacity_); + std::swap (data_, x.data_); + } + + inline void vector_impl:: + reserve (std::size_t n) + { + if (n > capacity_) + realloc (n); + } + + inline void vector_impl:: + stop () + { + state_ = state_not_tracking; + size_ = tail_ = 0; + } + + inline void vector_impl:: + change () + { + state_ = state_changed; + size_ = tail_ = 0; + } + + inline vector_impl::container_state_type vector_impl:: + state () const + { + return state_; + } + + inline bool vector_impl:: + tracking () const + { + return state_ == state_tracking; + } + + inline std::size_t vector_impl:: + size () const + { + return size_; + } + + inline std::size_t vector_impl:: + capacity () const + { + return capacity_; + } + + inline vector_impl::element_state_type vector_impl:: + state (std::size_t i) const + { + std::size_t r (i % 4); + unsigned char v (data_[i / 4]); + return static_cast ((v & mask_[r]) >> shift_[r]); + } + + inline void vector_impl:: + set (std::size_t i, element_state_type s) + { + std::size_t r (i % 4); + i /= 4; + unsigned char v (static_cast (s)); + v <<= shift_[r]; + data_[i] = (data_[i] & ~mask_[r]) | v; + } + + inline void vector_impl:: + modify (std::size_t i, std::size_t n) + { + for (; n != 0; --n, ++i) + if (state (i) != state_inserted) + set (i, state_updated); + } + + inline void vector_impl:: + assign (std::size_t n) + { + if (tail_ != 0) + clear (); + + push_back (n); + } + + inline void vector_impl:: + resize (size_t n) + { + if (n < tail_) + pop_back (tail_ - n); + else if (n > tail_) + push_back (n - tail_); + } + + // vector_base + // + inline vector_base:: + ~vector_base () + { + if (tran_ != 0) + tran_->callback_unregister (this); + } + + inline vector_base:: + vector_base (): tran_ (0) {} + + inline vector_base:: + vector_base (const vector_base& x) + : impl_ (x.impl_), tran_ (0) + { + // If the original is armed, then arm ourselves as well. + // + if (x.tran_ != 0) + _arm (*x.tran_); + } + + inline void vector_base:: + swap (vector_base& x) + { + impl_.swap (x.impl_); + + if (tran_ != 0 || x.tran_ != 0) + swap_tran (x); + } + +#ifdef ODB_CXX11 + inline vector_base:: + vector_base (vector_base&& x) + : impl_ (std::move (x.impl_)), tran_ (0) + { + if (x.tran_ != 0) + { + x.tran_->callback_unregister (&x); + _arm (*x.tran_); + } + } +#endif + + inline void vector_base:: + _stop () const + { + impl_.stop (); + } + + inline bool vector_base:: + _tracking () const + { + return impl_.tracking (); + } + + inline void vector_base:: + _arm (transaction& t) const + { + tran_ = &t; + t.callback_register (&rollback, + const_cast (this), + transaction::event_rollback, + 0, + &tran_); + } +} diff --git a/third-party/odb/libodb-2.4.0/odb/vector-traits.hxx b/third-party/odb/libodb-2.4.0/odb/vector-traits.hxx new file mode 100755 index 0000000..eae2c5b --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/vector-traits.hxx @@ -0,0 +1,107 @@ +// file : odb/vector-traits.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_VECTOR_TRAITS_HXX +#define ODB_VECTOR_TRAITS_HXX + +#include + +#include +#include +#include +#include + +namespace odb +{ + template + class access::container_traits > + { + public: + static const container_kind kind = ck_ordered; + static const bool smart = true; + + typedef vector container_type; + + typedef V value_type; + typedef typename container_type::size_type index_type; + + typedef smart_ordered_functions functions; + typedef ordered_functions dumb_functions; + + public: + static void + persist (const container_type& c, const functions& f) + { + for (index_type i (0), n (c.size ()); i < n; ++i) + f.insert (i, c[i]); + + // Now that this container is persistent, start tracking changes. + // + c._start (); + } + + static void + load (container_type& c, bool more, const functions& f) + { + // Stop tracking changes. + // + c._stop (); + + // Load. + // + c.clear (); + while (more) + { + index_type dummy; + c.push_back (value_type ()); + more = f.select (dummy, c.modify_back ()); + } + + // Start tracking changes. + // + c._start (); + } + + static bool + changed (const container_type&); + + static void + update (const container_type&, const functions&); + + static void + erase (const container_type* c, const functions& f) + { + f.delete_ (0); + + // Stop tracking changes. + // + if (c != 0) + c->_stop (); + } + + // Version of load() for dumb functions. Used to support + // inverse members of the container type. The implementation + // is identical to the smart one except we don't turn off/on + // change tracking. + // + static void + load (container_type& c, bool more, const dumb_functions& f) + { + c.clear (); + + while (more) + { + index_type dummy; + c.push_back (value_type ()); + more = f.select (dummy, c.modify_back ()); + } + } + }; +} + +#include + +#include + +#endif // ODB_VECTOR_TRAITS_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/vector-traits.txx b/third-party/odb/libodb-2.4.0/odb/vector-traits.txx new file mode 100755 index 0000000..ac38a79 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/vector-traits.txx @@ -0,0 +1,101 @@ +// file : odb/vector-traits.txx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +namespace odb +{ + template + bool access::container_traits >:: + changed (const container_type& c) + { + // Because modifications can cancel each other (e.g., push and pop), + // it is tricky to keep track of whether there are any changes in + // the container. Instead, we are just going to examine each element + // just like update(). + // + + // We should either be tracking or summarily changed. + // + if (c._tracking ()) + { + const vector_impl& impl (c._impl ()); + + for (std::size_t i (0), n (impl.size ()); i < n; ++i) + { + if (impl.state (i) != vector_impl::state_unchanged) + return true; + } + } + else + return true; + + return false; + } + + template + void access::container_traits >:: + update (const container_type& c, const functions& f) + { + bool u (false); // Updated flag. + + if (c._tracking ()) + { + const vector_impl& impl (c._impl ()); + + for (std::size_t i (0), n (impl.size ()); i < n; ++i) + { + vector_impl::element_state_type s (impl.state (i)); + + switch (s) + { + case vector_impl::state_unchanged: + { + break; + } + case vector_impl::state_inserted: + { + f.insert (i, c[static_cast (i)]); + u = u || true; + break; + } + case vector_impl::state_updated: + { + f.update (i, c[static_cast (i)]); + u = u || true; + break; + } + case vector_impl::state_erased: + { + f.delete_ (i); // Delete from i onwards. + u = u || true; + break; + } + } + + // We delete all trailing elements in one go. + // + if (s == vector_impl::state_erased) + break; + } + } + else + { + // Fall back to delete all/insert all. + // + f.delete_ (0); + + for (index_type i (0), n (c.size ()); i < n; ++i) + f.insert (i, c[i]); + + u = true; + } + + // Arm the rollback callback and (re)start change tracking. + // + if (u) + { + c._arm (transaction::current ()); + c._start (); + } + } +} diff --git a/third-party/odb/libodb-2.4.0/odb/vector.hxx b/third-party/odb/libodb-2.4.0/odb/vector.hxx new file mode 100755 index 0000000..d277c84 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/vector.hxx @@ -0,0 +1,630 @@ +// file : odb/vector.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_VECTOR_HXX +#define ODB_VECTOR_HXX + +#include +#include // ODB_CXX11 + +#include +#include +#include // std::ptrdiff_t + +#ifdef ODB_CXX11 +# include // std::move, std::forward +# ifdef ODB_CXX11_INITIALIZER_LIST +# include +# endif +#endif + +#include + +// Because both std::vector and odb::vector are called 'vector' (who +// cares about namespace qualifications, right?), Sun CC complains +// with a bogus "Ambiguous partial specialization" error. A really +// hideous workaround for this bug is to to add a dummy third template +// argument (with a default value). +// +#ifdef __SUNPRO_CC +# define LIBODB_VECTOR_ARG_DEFAULT ,int = 0 +# define LIBODB_VECTOR_ARG_DECL ,int DUMMY +# define LIBODB_VECTOR_ARG_USE ,DUMMY +#else +# define LIBODB_VECTOR_ARG_DEFAULT +# define LIBODB_VECTOR_ARG_DECL +# define LIBODB_VECTOR_ARG_USE +#endif + +namespace odb +{ + // An std::vector-like container that keeps track of changes. + // + // Note that the style and order of definitions is as appears + // in the standard. + // + template + class vector_iterator; + + template LIBODB_VECTOR_ARG_DEFAULT> + class vector: public vector_base + { + public: + typedef std::vector base_vector_type; + typedef typename base_vector_type::iterator base_iterator_type; + typedef typename base_vector_type::reverse_iterator + base_reverse_iterator_type; + // types: + // + typedef typename base_vector_type::reference reference; + typedef typename base_vector_type::const_reference const_reference; + typedef vector_iterator iterator; + typedef typename base_vector_type::const_iterator const_iterator; + typedef typename base_vector_type::size_type size_type; + typedef typename base_vector_type::difference_type difference_type; + typedef T value_type; + typedef A allocator_type; + typedef typename base_vector_type::pointer pointer; + typedef typename base_vector_type::const_pointer const_pointer; + // No non-const reverse iterator support for Sun CC with non-standard STL. + // +#ifndef _RWSTD_NO_CLASS_PARTIAL_SPEC + typedef vector_iterator + reverse_iterator; +#endif + typedef typename base_vector_type::const_reverse_iterator + const_reverse_iterator; + // construct/copy/destroy: + // + explicit vector(const A& a = A()): v_ (a) {} + explicit vector(size_type n): v_ (n) {} // C++11 + vector(size_type n, const T& v, const A& a = A()): v_ (n, v, a) {} + template + vector(I f, I l, const A& a = A()) : v_ (f, l, a) {} + vector(const vector& x): vector_base (x), v_ (x.v_) {} + // ~vector() {} + vector& operator=(const vector&); + template + void assign(I f, I l); + void assign(size_type n, const T& u); + allocator_type get_allocator() const /*noexcept*/ + {return v_.get_allocator ();} + +#ifdef ODB_CXX11 + vector(vector&& x): vector_base (std::move (x)), v_ (std::move (x.v_)) {} + vector(const vector& x, const A& a): vector_base (x), v_ (x.v_, a) {} + vector(vector&& x, const A& a) + : vector_base (std::move (x)), v_ (std::move (x.v_), a) {} + vector& operator=(vector&&); +#ifdef ODB_CXX11_INITIALIZER_LIST + vector(std::initializer_list il, const A& a = A()): v_ (il, a) {} + vector& operator=(std::initializer_list); + void assign(std::initializer_list); +#endif +#endif + + // iterators: (all /*noexcept*/) + // + iterator begin() {return iterator (this, v_.begin ());} + iterator end() {return iterator (this, v_.end ());} + const_iterator begin() const {return v_.begin ();} + const_iterator end() const {return v_.end ();} +#ifndef _RWSTD_NO_CLASS_PARTIAL_SPEC + reverse_iterator rbegin() {return reverse_iterator (this, v_.rbegin ());} + reverse_iterator rend() {return reverse_iterator (this, v_.rend ());} +#endif + const_reverse_iterator rbegin() const {return v_.rbegin ();} + const_reverse_iterator rend() const {return v_.rend ();} + + // Return standard vector iterators. The begin() functions mark all + // the elements as modified. + // + base_iterator_type mbegin (); + base_iterator_type mend () {return v_.end ();} + base_reverse_iterator_type mrbegin (); + base_reverse_iterator_type mrend () {return v_.rend ();} + +#ifdef ODB_CXX11 + const_iterator cbegin() const {return v_.cbegin ();} + const_iterator cend() const {return v_.cend ();} + const_reverse_iterator crbegin() const {return v_.crbegin ();} + const_reverse_iterator crend() const {return v_.crend ();} +#endif + + // capacity: + // + size_type size() const /*noexcept*/ {return v_.size ();} + size_type max_size() const /*noexcept*/ {return v_.max_size ();} + void resize(size_type); // C++11 + void resize(size_type, const T&); + size_type capacity() const /*noexcept*/ {return v_.capacity ();} + bool empty() const /*noexcept*/ {return v_.empty ();} + void reserve(size_type); + +#ifdef ODB_CXX11 + void shrink_to_fit(); +#endif + + // element access: + // + //reference operator[](size_type n); + reference modify(size_type n); + const_reference operator[](size_type n) const {return v_[n];} + //reference at(size_type n); + reference modify_at(size_type n); + const_reference at(size_type n) const {return v_.at (n);} + //reference front(); + reference modify_front(); + const_reference front() const {return v_.front ();} + //reference back(); + reference modify_back(); + const_reference back() const {return v_.back ();} + + // data access: + // +#ifdef ODB_CXX11 + //T* data() noexcept; + T* modify_data() /*noexcept*/; + const T* data() const /*noexcept*/ {return v_.data ();} +#endif + + // modifiers: + // + void push_back(const T& x); + void pop_back(); + iterator insert(iterator position, const T& x); + void insert(iterator position, size_type n, const T& x); + template + void insert(iterator position, I first, I last); + iterator erase(iterator position); + iterator erase(iterator first, iterator last); + void swap(vector&); + void clear() /*noexcept*/; + +#ifdef ODB_CXX11 + // In C++11 all modifiers use const_iterator instead of iterator + // to represent position. However, some standard libraries (notably + // GCC's) still use iterator and so we will do that as well, for now. + // + void push_back(T&& x); + iterator insert(iterator position, T&& x); + +#ifdef ODB_CXX11_VARIADIC_TEMPLATE + template + void emplace_back(Args&&... args); + template + iterator emplace(iterator position, Args&&... args); +#endif +#endif + + // Interfacing with the base vector. + // + vector (const base_vector_type& x): v_ (x) {} + vector& operator= (const base_vector_type&); + operator const base_vector_type& () const {return v_;} + base_vector_type& base () {return v_;} + const base_vector_type& base () const {return v_;} + +#ifdef ODB_CXX11 + vector (base_vector_type&& x): v_ (std::move (x)) {} + vector& operator= (base_vector_type&&); +#endif + + // Change tracking (the rest comes from vector_base). + // + public: + void + _start () const {impl_.start (v_.size ());} + + private: + base_vector_type v_; + }; + + namespace core + { + using odb::vector; + } + + template + inline bool operator==(const vector& x, + const vector& y) + {return x.base () == y.base ();} + + template + inline bool operator==(const vector& x, + const std::vector& y) + {return x.base () == y;} + + template + inline bool operator==(const std::vector& x, + const vector& y) + {return x == y.base ();} + + template + inline bool operator< (const vector& x, + const vector& y) + {return x.base () < y.base ();} + + template + inline bool operator<(const vector& x, + const std::vector& y) + {return x.base () < y;} + + template + inline bool operator<(const std::vector& x, + const vector& y) + {return x < y.base ();} + + template + inline bool operator!=(const vector& x, + const vector& y) + {return x.base () != y.base ();} + + template + inline bool operator!=(const vector& x, + const std::vector& y) + {return x.base () != y;} + + template + inline bool operator!=(const std::vector& x, + const vector& y) + {return x != y.base ();} + + template + inline bool operator> (const vector& x, + const vector& y) + {return x.base () > y.base ();} + + template + inline bool operator>=(const vector& x, + const vector& y) + {return x.base () >= y.base ();} + + template + inline bool operator>=(const vector& x, + const std::vector& y) + {return x.base () >= y;} + + template + inline bool operator>=(const std::vector& x, + const vector& y) + {return x >= y.base ();} + + template + inline bool operator<=(const vector& x, + const vector& y) + {return x.base () <= y.base ();} + + template + inline bool operator<=(const vector& x, + const std::vector& y) + {return x.base () <= y;} + + template + inline bool operator<=(const std::vector& x, + const vector& y) + {return x <= y.base ();} + + template + class vector_iterator + { + public: + typedef V vector_type; + typedef I base_iterator_type; + typedef typename vector_type::const_iterator const_iterator_type; + + // Sun CC with non-standard STL does not have iterator_traits. + // +#ifndef _RWSTD_NO_CLASS_PARTIAL_SPEC + typedef std::iterator_traits base_iterator_traits; + + typedef typename base_iterator_traits::value_type value_type; + typedef typename base_iterator_traits::difference_type difference_type; + typedef typename base_iterator_traits::pointer pointer; + typedef typename base_iterator_traits::reference reference; + typedef typename base_iterator_traits::iterator_category iterator_category; +#else + // Base iterator is just a pointer. + // + typedef typename vector_type::value_type value_type; + typedef typename vector_type::pointer pointer; + typedef typename vector_type::reference reference; + typedef std::random_access_iterator_tag iterator_category; + typedef std::ptrdiff_t difference_type; +#endif + + typedef typename vector_type::size_type size_type; + typedef typename vector_type::const_reference const_reference; + typedef typename vector_type::const_pointer const_pointer; + + vector_iterator (): v_ (0), i_ () {} + vector_iterator (vector_type* v, const base_iterator_type& i) + : v_ (v), i_ (i) {} + operator const_iterator_type () const {return i_;} + base_iterator_type base () const {return i_;} + vector_type* vector () const {return v_;} + + // Note: const_{reference,pointer}. + // + const_reference operator* () const {return *i_;} + const_pointer operator-> () const {return i_.operator -> ();} + const_reference operator[] (difference_type n) const {return i_[n];} + + // Modifiers. + // + // Buggy Sun CC cannot have them out of class. + // + reference modify () const + { + if (v_->_tracking ()) + v_->_impl ().modify ( + static_cast (i_ - v_->base ().begin ())); + return *i_; + } + + reference modify (difference_type n) const + { + if (v_->_tracking ()) + v_->_impl ().modify ( + static_cast (i_ - v_->base ().begin () + n)); + return i_[n]; + } + + vector_iterator& operator++ () {++i_; return *this;} + vector_iterator operator++ (int) {return vector_iterator (v_, i_++);} + vector_iterator& operator-- () {--i_; return *this;} + vector_iterator operator-- (int) {return vector_iterator (v_, i_--);} + + vector_iterator operator+ (difference_type n) const + {return vector_iterator (v_, i_ + n);} + vector_iterator& operator+= (difference_type n) {i_ += n; return *this;} + vector_iterator operator- (difference_type n) const + {return vector_iterator (v_, i_ - n);} + vector_iterator& operator-= (difference_type n) {i_ -= n; return *this;} + + // Implementation details. + // + public: + base_iterator_type _base () const {return i_;} // Same as base (). + + private: + vector_type* v_; + base_iterator_type i_; + }; + +#ifndef _RWSTD_NO_CLASS_PARTIAL_SPEC + template + class vector_iterator > + { + public: + typedef V vector_type; + typedef std::reverse_iterator base_iterator_type; + typedef typename vector_type::const_reverse_iterator const_iterator_type; + typedef std::iterator_traits base_iterator_traits; + + typedef typename vector_type::iterator iterator_type; + typedef typename base_iterator_traits::value_type value_type; + typedef typename base_iterator_traits::difference_type difference_type; + typedef typename base_iterator_traits::pointer pointer; + typedef typename base_iterator_traits::reference reference; + typedef typename base_iterator_traits::iterator_category iterator_category; + + typedef typename vector_type::size_type size_type; + typedef typename vector_type::const_reference const_reference; + typedef typename vector_type::const_pointer const_pointer; + + vector_iterator (): v_ (0), i_ () {} + explicit vector_iterator (const iterator_type& i) + : v_ (i.vector ()), i_ (i.base ()) {} + vector_iterator (vector_type* v, const base_iterator_type& i) + : v_ (v), i_ (i) {} + operator const_iterator_type () const {return i_;} + iterator_type base () const {return iterator_type (v_, i_.base ());} + base_iterator_type rbase () const {return i_;} + vector_type* vector () const {return v_;} + + // Note: const_{reference,pointer}. + // + const_reference operator* () const {return *i_;} + const_pointer operator-> () const {return i_.operator -> ();} + const_reference operator[] (difference_type n) const {return i_[n];} + + // Modifiers. + // + reference modify () const + { + if (v_->_tracking ()) + v_->_impl ().modify ( + static_cast (v_->base ().rend () - i_ - 1)); + return *i_; + } + + reference modify (difference_type n) const + { + if (v_->_tracking ()) + // Note: going in the opposite direction. + v_->_impl ().modify ( + static_cast (v_->base ().rend () - i_ - 1 - n)); + return i_[n]; + } + + vector_iterator& operator++ () {++i_; return *this;} + vector_iterator operator++ (int) {return vector_iterator (v_, i_++);} + vector_iterator& operator-- () {--i_; return *this;} + vector_iterator operator-- (int) {return vector_iterator (v_, i_--);} + + vector_iterator operator+ (difference_type n) const + {return vector_iterator (v_, i_ + n);} + vector_iterator& operator+= (difference_type n) {i_ += n; return *this;} + vector_iterator operator- (difference_type n) const + {return vector_iterator (v_, i_ - n);} + vector_iterator& operator-= (difference_type n) {i_ -= n; return *this;} + + // Implementation details. + // + public: + base_iterator_type _base () const {return i_;} // Same as rbase(). + + private: + vector_type* v_; + base_iterator_type i_; + }; +#endif // _RWSTD_NO_CLASS_PARTIAL_SPEC + + // operator== + // + template + inline bool + operator== (const vector_iterator& x, const vector_iterator& y) + {return x._base () == y._base ();} + + template + inline bool + operator== (const vector_iterator& x, + const typename vector_iterator::const_iterator_type& y) + {return x._base () == y;} + + template + inline bool + operator== (const typename vector_iterator::const_iterator_type& x, + const vector_iterator& y) + {return x == y._base ();} + + // operator< + // + template + inline bool + operator< (const vector_iterator& x, const vector_iterator& y) + {return x._base () < y._base ();} + + template + inline bool + operator< (const vector_iterator& x, + const typename vector_iterator::const_iterator_type& y) + {return x._base () < y;} + + template + inline bool + operator< (const typename vector_iterator::const_iterator_type& x, + const vector_iterator& y) + {return x < y._base ();} + + // operator!= + // + template + inline bool + operator!= (const vector_iterator& x, const vector_iterator& y) + {return x._base () != y._base ();} + + template + inline bool + operator!= (const vector_iterator& x, + const typename vector_iterator::const_iterator_type& y) + {return x._base () != y;} + + template + inline bool + operator!= (const typename vector_iterator::const_iterator_type& x, + const vector_iterator& y) + {return x != y._base ();} + + // operator> + // + template + inline bool + operator> (const vector_iterator& x, const vector_iterator& y) + {return x._base () > y._base ();} + + template + inline bool + operator> (const vector_iterator& x, + const typename vector_iterator::const_iterator_type& y) + {return x._base () > y;} + + template + inline bool + operator> (const typename vector_iterator::const_iterator_type& x, + const vector_iterator& y) + {return x > y._base ();} + + // operator>= + // + template + inline bool + operator>= (const vector_iterator& x, const vector_iterator& y) + {return x._base () >= y._base ();} + + template + inline bool + operator>= (const vector_iterator& x, + const typename vector_iterator::const_iterator_type& y) + {return x._base () >= y;} + + template + inline bool + operator>= (const typename vector_iterator::const_iterator_type& x, + const vector_iterator& y) + {return x >= y._base ();} + + // operator<= + // + template + inline bool + operator<= (const vector_iterator& x, const vector_iterator& y) + {return x._base () <= y._base ();} + + template + inline bool + operator<= (const vector_iterator& x, + const typename vector_iterator::const_iterator_type& y) + {return x._base () <= y;} + + template + inline bool + operator<= (const typename vector_iterator::const_iterator_type& x, + const vector_iterator& y) + {return x <= y._base ();} + + // operator- + // + template + inline typename vector_iterator::difference_type + operator-(const vector_iterator& x, const vector_iterator& y) + {return x._base () - y._base ();} + + template + inline typename vector_iterator::difference_type + operator-(const vector_iterator& x, + const typename vector_iterator::const_iterator_type& y) + {return x._base () - y;} + + template + inline typename vector_iterator::difference_type + operator-(const typename vector_iterator::const_iterator_type& x, + const vector_iterator& y) + {return x - y._base ();} + + // operator+ + // + template + inline vector_iterator + operator+(typename vector_iterator::difference_type n, + const vector_iterator& x) + {return vector_iterator (x.vector (), n + x._base ());} +} + +namespace std +{ + template + inline void swap(odb::vector& x, + odb::vector& y) {x.swap (y);} +} + +#include + +#include + +#include + +#endif // ODB_VECTOR_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/vector.ixx b/third-party/odb/libodb-2.4.0/odb/vector.ixx new file mode 100755 index 0000000..81049e4 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/vector.ixx @@ -0,0 +1,360 @@ +// file : odb/vector.ixx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +namespace odb +{ + // construct/copy/destroy: + // + template + inline vector& + vector:: + operator= (const vector& x) + { + v_ = x.v_; + if (_tracking ()) + impl_.assign (v_.size ()); + return *this; + } + + template + template + inline void vector:: + assign (I f, I l) + { + v_.assign (f, l); + if (_tracking ()) + impl_.assign (v_.size ()); + } + + template + inline void vector:: + assign (size_type n, const T& u) + { + v_.assign (n, u); + if (_tracking ()) + impl_.assign (n); + } + +#ifdef ODB_CXX11 + template + inline vector& + vector:: + operator=(vector&& x) + { + v_ = std::move (x.v_); + if (_tracking ()) + impl_.assign (v_.size ()); + return *this; + } + +#ifdef ODB_CXX11_INITIALIZER_LIST + template + inline vector& + vector:: + operator= (std::initializer_list il) + { + v_ = il; + if (_tracking ()) + impl_.assign (v_.size ()); + return *this; + } + + template + inline void vector:: + assign (std::initializer_list il) + { + v_.assign (il); + if (_tracking ()) + impl_.assign (v_.size ()); + } +#endif +#endif + + // iterators: + // + template + inline typename vector::base_iterator_type + vector:: + mbegin () + { + if (_tracking ()) + impl_.modify (0, v_.size ()); + return v_.begin (); + } + + template + inline + typename vector::base_reverse_iterator_type + vector:: + mrbegin () + { + if (_tracking ()) + impl_.modify (0, v_.size ()); + return v_.rbegin (); + } + + // capacity: + // + template + inline void vector:: + resize (size_type n) + { + v_.resize (n); + if (_tracking ()) + impl_.resize (n); + } + + template + inline void vector:: + resize (size_type n, const T& c) + { + v_.resize (n, c); + if (_tracking ()) + impl_.resize (n); + } + + template + inline void vector:: + reserve (size_type n) + { + v_.reserve (n); + if (_tracking ()) + impl_.reserve (n); + } + +#ifdef ODB_CXX11 + template + inline void vector:: + shrink_to_fit () + { + v_.shrink_to_fit (); + impl_.shrink_to_fit (); + } +#endif + + // element access: + // + template + inline typename vector::reference + vector:: + modify (size_type n) + { + reference r (v_[n]); + if (_tracking ()) + impl_.modify (n); + return r; + } + + template + inline typename vector::reference + vector:: + modify_at (size_type n) + { + reference r (v_.at (n)); + if (_tracking ()) + impl_.modify (n); + return r; + } + + template + inline typename vector::reference + vector:: + modify_front () + { + reference r (v_.front ()); + if (_tracking ()) + impl_.modify (0); + return r; + } + + template + inline typename vector::reference + vector:: + modify_back () + { + reference r (v_.back ()); + if (_tracking ()) + impl_.modify (v_.size () - 1); + return r; + } + +#ifdef ODB_CXX11 + template + inline T* vector:: + modify_data() /*noexcept*/ + { + if (_tracking ()) + impl_.modify (0, v_.size ()); + return v_.data (); + } +#endif + + // modifiers: + // + template + inline void vector:: + push_back (const T& x) + { + v_.push_back (x); + if (_tracking ()) + impl_.push_back (); + } + + template + inline void vector:: + pop_back () + { + v_.pop_back (); + if (_tracking ()) + impl_.pop_back (); + } + + template + inline typename vector::iterator + vector:: + insert (iterator p, const T& x) + { + if (_tracking ()) + impl_.insert (static_cast (p.base () - v_.begin ())); + return iterator (this, v_.insert (p.base (), x)); + } + + template + inline void vector:: + insert (iterator p, size_type n, const T& x) + { + if (_tracking ()) + impl_.insert (static_cast (p.base () - v_.begin ()), n); + v_.insert (p.base (), n, x); + } + + template + template + inline void vector:: + insert (iterator p, I f, I l) + { + size_type i, n; + if (_tracking ()) + { + i = static_cast (p.base () - v_.begin ()); + n = v_.size (); + } + + v_.insert (p.base (), f, l); + + if (_tracking ()) + impl_.insert (i, v_.size () - n); + } + + template + inline typename vector::iterator + vector:: + erase (iterator p) + { + if (_tracking ()) + impl_.erase (static_cast (p.base () - v_.begin ())); + return iterator (this, v_.erase (p.base ())); + } + + template + inline typename vector::iterator + vector:: + erase (iterator f, iterator l) + { + if (_tracking ()) + impl_.erase (static_cast (f.base () - v_.begin ()), + static_cast (l - f)); + return iterator (this, v_.erase (f.base (), l.base ())); + } + + template + inline void vector:: + swap (vector& x) + { + v_.swap (x.v_); + vector_base::swap (x); + } + + template + inline void vector:: + clear () + { + v_.clear (); + if (_tracking ()) + impl_.clear (); + } + +#ifdef ODB_CXX11 + template + inline void vector:: + push_back(T&& x) + { + v_.push_back (std::move (x)); + if (_tracking ()) + impl_.push_back (); + } + + template + inline typename vector::iterator + vector:: + insert (iterator p, T&& x) + { + base_iterator_type r (v_.insert (p.base (), std::move (x))); + if (_tracking ()) + impl_.insert (static_cast (r - v_.begin ())); + return iterator (this, r); + } + +#ifdef ODB_CXX11_VARIADIC_TEMPLATE + template + template + inline void vector:: + emplace_back (Args&&... args) + { + v_.push_back (std::forward (args)...); + if (_tracking ()) + impl_.push_back (); + } + + template + template + inline typename vector::iterator + vector:: + emplace (iterator p, Args&&... args) + { + base_iterator_type r ( + v_.emplace (p.base (), std::forward (args)...)); + if (_tracking ()) + impl_.insert (static_cast (r - v_.begin ())); + return iterator (this, r); + } +#endif +#endif + + // Interfacing with base vector. + // + template + inline vector& + vector:: + operator= (const base_vector_type& x) + { + v_ = x; + if (_tracking ()) + impl_.assign (v_.size ()); + return *this; + } + +#ifdef ODB_CXX11 + template + inline vector& + vector:: + operator= (base_vector_type&& x) + { + v_ = std::move (x); + if (_tracking ()) + impl_.assign (v_.size ()); + return *this; + } +#endif +} diff --git a/third-party/odb/libodb-2.4.0/odb/version.hxx b/third-party/odb/libodb-2.4.0/odb/version.hxx new file mode 100755 index 0000000..3a675e7 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/version.hxx @@ -0,0 +1,39 @@ +// file : odb/version.hxx +// copyright : Copyright (c) 2005-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_VERSION_HXX +#define ODB_VERSION_HXX + +#include + +// Version format is AABBCCDD where +// +// AA - major version number +// BB - minor version number +// CC - bugfix version number +// DD - alpha / beta (DD + 50) version number +// +// When DD is not 00, 1 is subtracted from AABBCC. For example: +// +// Version AABBCCDD +// 2.0.0 02000000 +// 2.1.0 02010000 +// 2.1.1 02010100 +// 2.2.0.a1 02019901 +// 3.0.0.b2 02999952 +// + +// ODB interface version: minor, major, and alpha/beta versions. +// +#define ODB_VERSION 20400 +#define ODB_VERSION_STR "2.4" + +// libodb version: interface version plus the bugfix version. +// +#define LIBODB_VERSION 2040000 +#define LIBODB_VERSION_STR "2.4.0" + +#include + +#endif // ODB_VERSION_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/view-image.hxx b/third-party/odb/libodb-2.4.0/odb/view-image.hxx new file mode 100755 index 0000000..099924d --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/view-image.hxx @@ -0,0 +1,37 @@ +// file : odb/view-image.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_VIEW_IMAGE_HXX +#define ODB_VIEW_IMAGE_HXX + +#include + +#include +#include + +namespace odb +{ + // Helper to create a complete image chain for a polymorphic + // object hierarchy. + // + template + struct view_object_image: object_traits_impl::image_type + { + view_object_image () {this->base = &base_;} + + private: + // Data member names in the generated image_type never end with + // an underscore, so this name shouldn't clash. + // + view_object_image::base_type, R, DB> + base_; + }; + + template + struct view_object_image: object_traits_impl::image_type {}; +} + +#include + +#endif // ODB_VIEW_IMAGE_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/view-result.hxx b/third-party/odb/libodb-2.4.0/odb/view-result.hxx new file mode 100755 index 0000000..6dc43d0 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/view-result.hxx @@ -0,0 +1,226 @@ +// file : odb/view-result.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_VIEW_RESULT_HXX +#define ODB_VIEW_RESULT_HXX + +#include + +#include // std::ptrdiff_t, std::size_t +#include // iterator categories +#include // std::move + +#include +#include +#include +#include + +#include // ODB_CXX11 + +namespace odb +{ + template + class view_result_impl: public result_impl + { + protected: + friend class result; + friend class result; + friend class result_iterator; + friend class result_iterator; + + // In result_impl, T is always non-const and the same as view_type. + // + typedef T view_type; + typedef odb::view_traits view_traits; + + typedef typename view_traits::pointer_type pointer_type; + typedef odb::pointer_traits pointer_traits; + + view_result_impl (odb::connection& conn) + : result_impl (conn), begin_ (true), end_ (false), current_ () + { + } + + // To make this work with all kinds of pointers (raw, std::auto_ptr, + // shared), we need to make sure we don't make any copies of the + // pointer on the return path. + // + pointer_type& + current (); + + void + release () + { + current_ = pointer_type (); + guard_.release (); + } + + void + begin () + { + if (begin_) + { + next (); + begin_ = false; + } + } + + bool + end () const + { + return end_; + } + + protected: + virtual void + load (view_type&) = 0; + + virtual void + next () = 0; + + virtual void + cache () = 0; + + virtual std::size_t + size () = 0; + + protected: +#ifdef ODB_CXX11 + void + current (pointer_type& p) + { + current_ = std::move (p); + guard_.reset (current_); + } + + void + current (pointer_type&& p) + { + current (p); + } +#else + void + current (pointer_type p) + { + current_ = p; + guard_.reset (current_); + } +#endif + + bool begin_; + bool end_; + + private: + pointer_type current_; + typename pointer_traits::guard guard_; + }; + + template + class result_iterator + { + public: + typedef T value_type; + typedef value_type& reference; + typedef value_type* pointer; + typedef std::ptrdiff_t difference_type; + typedef std::input_iterator_tag iterator_category; + + // T can be const T while view_type is always non-const. + // + typedef typename view_traits::view_type view_type; + + typedef view_result_impl result_impl_type; + + public: + explicit + result_iterator (result_impl_type* res = 0) + : res_ (res) + { + } + + // Input iterator requirements. + // + public: + reference + operator* () const + { + return pointer_traits::get_ref (res_->current ()); + } + + // Our value_type is already a pointer so return it instead of + // a pointer to it (operator-> will just have to go one deeper + // in the latter case). + // + pointer + operator-> () const + { + return pointer_traits::get_ptr (res_->current ()); + } + + result_iterator& + operator++ () + { + res_->next (); + return *this; + } + + result_iterator + operator++ (int) + { + // All non-end iterators for a result object move together. + // + res_->next (); + return *this; + } + + public: + typename view_traits::pointer_type + load () + { + typename view_traits::pointer_type r (res_->current ()); + res_->release (); + return r; + } + + void + load (view_type&); + + public: + bool + equal (result_iterator j) const + { + return (res_ ? res_->end () : true) == (j.res_ ? j.res_->end () : true); + } + + private: + // Use unrestricted pointer traits since that's what is returned by + // result_impl. + // + typedef + odb::pointer_traits::pointer_type> + pointer_traits; + + result_impl_type* res_; + }; + + // + // + template + class result_base + { + public: + typedef typename view_traits::pointer_type value_type; + + // T can be const T while view_type is always non-const. + // + typedef typename view_traits::view_type view_type; + typedef view_result_impl result_impl_type; + }; +} + +#include + +#include + +#endif // ODB_VIEW_RESULT_HXX diff --git a/third-party/odb/libodb-2.4.0/odb/view-result.txx b/third-party/odb/libodb-2.4.0/odb/view-result.txx new file mode 100755 index 0000000..f6c2d24 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/view-result.txx @@ -0,0 +1,40 @@ +// file : odb/view-result.txx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +namespace odb +{ + // + // view_result_impl + // + + template + typename view_result_impl::pointer_type& + view_result_impl:: + current () + { + if (pointer_traits::null_ptr (current_) && !end_) + { + pointer_type p (view_traits::create ()); + view_type& view (pointer_traits::get_ref (p)); + current (p); + load (view); + } + + return current_; + } + + // + // result_iterator + // + + template + void result_iterator:: + load (view_type& view) + { + if (res_->end ()) + return; + + res_->load (view); + } +} diff --git a/third-party/odb/libodb-2.4.0/odb/wrapper-traits.hxx b/third-party/odb/libodb-2.4.0/odb/wrapper-traits.hxx new file mode 100755 index 0000000..47b6701 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/odb/wrapper-traits.hxx @@ -0,0 +1,275 @@ +// file : odb/wrapper-traits.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_WRAPPER_TRAITS_HXX +#define ODB_WRAPPER_TRAITS_HXX + +#include + +#include // std::auto_ptr, std::unique_ptr, std::shared_ptr/weak_ptr + +#include + +#include // ODB_CXX11 +#include + +namespace odb +{ + template + class wrapper_traits; + + // Sample specialization for raw pointers. It is not enabled by default + // since it makes many assumptions that may not always hold true (such + // as that instances are allocated with new and freed with delete). + // This makes it too dangerous to be enabled unconditionally. If you + // need this functionality, you can copy the below code into your + // application. Also consider changing it to only specialize for + // specific types instead of for any pointer (it will almost always + // do the wrong thing for char*). + // +#if 0 + template + class wrapper_traits + { + public: + typedef T wrapped_type; + typedef T* wrapper_type; + + // T can be const. + // + typedef + typename details::meta::remove_const::result + unrestricted_wrapped_type; + + static const bool null_handler = true; + static const bool null_default = false; + + static bool + get_null (const wrapper_type& p) + { + return p == 0; + } + + static void + set_null (wrapper_type& p) + { + delete p; + p = 0; + } + + static const wrapped_type& + get_ref (const wrapper_type& p) + { + return *p; + } + + static unrestricted_wrapped_type& + set_ref (wrapper_type& p) + { + if (p == 0) + p = new unrestricted_wrapped_type; + + return const_cast (*p); + } + }; +#endif + + // Specialization for std::auto_ptr. + // + template + class wrapper_traits< std::auto_ptr > + { + public: + // T can be const. + // + typedef T wrapped_type; + typedef std::auto_ptr wrapper_type; + + // T can be const. + // + typedef + typename odb::details::meta::remove_const::result + unrestricted_wrapped_type; + + static const bool null_handler = true; + static const bool null_default = false; + + static bool + get_null (const wrapper_type& p) + { + return p.get () == 0; + } + + static void + set_null (wrapper_type& p) + { + p.reset (); + } + + static const wrapped_type& + get_ref (const wrapper_type& p) + { + return *p; + } + + static unrestricted_wrapped_type& + set_ref (wrapper_type& p) + { + if (p.get () == 0) + p.reset (new unrestricted_wrapped_type ()); + + return const_cast (*p); + } + }; + +#ifdef ODB_CXX11 + + // Specialization for C++11 std::unique_ptr. + // + template + class wrapper_traits> + { + public: + // T can be const. + // + typedef T wrapped_type; + typedef std::unique_ptr wrapper_type; + + // T can be const. + // + typedef + typename odb::details::meta::remove_const::result + unrestricted_wrapped_type; + + static const bool null_handler = true; + static const bool null_default = false; + + static bool + get_null (const wrapper_type& p) + { + return !p; + } + + static void + set_null (wrapper_type& p) + { + p.reset (); + } + + static const wrapped_type& + get_ref (const wrapper_type& p) + { + return *p; + } + + static unrestricted_wrapped_type& + set_ref (wrapper_type& p) + { + if (!p) + p.reset (new unrestricted_wrapped_type ()); + + return const_cast (*p); + } + }; + + // Specialization for C++11 std::shared_ptr. + // + template + class wrapper_traits> + { + public: + typedef T wrapped_type; + typedef std::shared_ptr wrapper_type; + + // T can be const. + // + typedef + typename odb::details::meta::remove_const::result + unrestricted_wrapped_type; + + static const bool null_handler = true; + static const bool null_default = false; + + static bool + get_null (const wrapper_type& p) + { + return !p; + } + + static void + set_null (wrapper_type& p) + { + p.reset (); + } + + static const wrapped_type& + get_ref (const wrapper_type& p) + { + return *p; + } + + static unrestricted_wrapped_type& + set_ref (wrapper_type& p) + { + if (!p) + p.reset (new unrestricted_wrapped_type); + + return const_cast (*p); + } + }; + +#endif // ODB_CXX11 + + // Specialization for odb::nullable. + // + template + class wrapper_traits< nullable > + { + public: + // T can be const. + // + typedef T wrapped_type; + typedef nullable wrapper_type; + + // T can be const. + // + typedef + typename odb::details::meta::remove_const::result + unrestricted_wrapped_type; + + static const bool null_handler = true; + static const bool null_default = true; + + static bool + get_null (const wrapper_type& n) + { + return n.null (); + } + + static void + set_null (wrapper_type& n) + { + n.reset (); + } + + static const wrapped_type& + get_ref (const wrapper_type& n) + { + return *n; + } + + static unrestricted_wrapped_type& + set_ref (wrapper_type& n) + { + if (n.null ()) + n = unrestricted_wrapped_type (); + + return const_cast (*n); + } + }; +} + +#include + +#endif // ODB_WRAPPER_TRAITS_HXX diff --git a/third-party/odb/libodb-2.4.0/version b/third-party/odb/libodb-2.4.0/version new file mode 100755 index 0000000..197c4d5 --- /dev/null +++ b/third-party/odb/libodb-2.4.0/version @@ -0,0 +1 @@ +2.4.0 diff --git a/third-party/odb/libodb-sqlite-2.4.0/GPLv2 b/third-party/odb/libodb-sqlite-2.4.0/GPLv2 new file mode 100755 index 0000000..3912109 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/GPLv2 @@ -0,0 +1,340 @@ + GNU GENERAL PUBLIC LICENSE + Version 2, June 1991 + + Copyright (C) 1989, 1991 Free Software Foundation, Inc. + 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +License is intended to guarantee your freedom to share and change free +software--to make sure the software is free for all its users. This +General Public License applies to most of the Free Software +Foundation's software and to any other program whose authors commit to +using it. (Some other Free Software Foundation software is covered by +the GNU Library General Public License instead.) You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +this service if you wish), that you receive source code or can get it +if you want it, that you can change the software or use pieces of it +in new free programs; and that you know you can do these things. + + To protect your rights, we need to make restrictions that forbid +anyone to deny you these rights or to ask you to surrender the rights. +These restrictions translate to certain responsibilities for you if you +distribute copies of the software, or if you modify it. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must give the recipients all the rights that +you have. You must make sure that they, too, receive or can get the +source code. And you must show them these terms so they know their +rights. + + We protect your rights with two steps: (1) copyright the software, and +(2) offer you this license which gives you legal permission to copy, +distribute and/or modify the software. + + Also, for each author's protection and ours, we want to make certain +that everyone understands that there is no warranty for this free +software. If the software is modified by someone else and passed on, we +want its recipients to know that what they have is not the original, so +that any problems introduced by others will not reflect on the original +authors' reputations. + + Finally, any free program is threatened constantly by software +patents. We wish to avoid the danger that redistributors of a free +program will individually obtain patent licenses, in effect making the +program proprietary. To prevent this, we have made it clear that any +patent must be licensed for everyone's free use or not licensed at all. + + The precise terms and conditions for copying, distribution and +modification follow. + + GNU GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License applies to any program or other work which contains +a notice placed by the copyright holder saying it may be distributed +under the terms of this General Public License. The "Program", below, +refers to any such program or work, and a "work based on the Program" +means either the Program or any derivative work under copyright law: +that is to say, a work containing the Program or a portion of it, +either verbatim or with modifications and/or translated into another +language. (Hereinafter, translation is included without limitation in +the term "modification".) Each licensee is addressed as "you". + +Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running the Program is not restricted, and the output from the Program +is covered only if its contents constitute a work based on the +Program (independent of having been made by running the Program). +Whether that is true depends on what the Program does. + + 1. You may copy and distribute verbatim copies of the Program's +source code as you receive it, in any medium, provided that you +conspicuously and appropriately publish on each copy an appropriate +copyright notice and disclaimer of warranty; keep intact all the +notices that refer to this License and to the absence of any warranty; +and give any other recipients of the Program a copy of this License +along with the Program. + +You may charge a fee for the physical act of transferring a copy, and +you may at your option offer warranty protection in exchange for a fee. + + 2. You may modify your copy or copies of the Program or any portion +of it, thus forming a work based on the Program, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) You must cause the modified files to carry prominent notices + stating that you changed the files and the date of any change. + + b) You must cause any work that you distribute or publish, that in + whole or in part contains or is derived from the Program or any + part thereof, to be licensed as a whole at no charge to all third + parties under the terms of this License. + + c) If the modified program normally reads commands interactively + when run, you must cause it, when started running for such + interactive use in the most ordinary way, to print or display an + announcement including an appropriate copyright notice and a + notice that there is no warranty (or else, saying that you provide + a warranty) and that users may redistribute the program under + these conditions, and telling the user how to view a copy of this + License. (Exception: if the Program itself is interactive but + does not normally print such an announcement, your work based on + the Program is not required to print an announcement.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Program, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Program, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Program. + +In addition, mere aggregation of another work not based on the Program +with the Program (or with a work based on the Program) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may copy and distribute the Program (or a work based on it, +under Section 2) in object code or executable form under the terms of +Sections 1 and 2 above provided that you also do one of the following: + + a) Accompany it with the complete corresponding machine-readable + source code, which must be distributed under the terms of Sections + 1 and 2 above on a medium customarily used for software interchange; or, + + b) Accompany it with a written offer, valid for at least three + years, to give any third party, for a charge no more than your + cost of physically performing source distribution, a complete + machine-readable copy of the corresponding source code, to be + distributed under the terms of Sections 1 and 2 above on a medium + customarily used for software interchange; or, + + c) Accompany it with the information you received as to the offer + to distribute corresponding source code. (This alternative is + allowed only for noncommercial distribution and only if you + received the program in object code or executable form with such + an offer, in accord with Subsection b above.) + +The source code for a work means the preferred form of the work for +making modifications to it. For an executable work, complete source +code means all the source code for all modules it contains, plus any +associated interface definition files, plus the scripts used to +control compilation and installation of the executable. However, as a +special exception, the source code distributed need not include +anything that is normally distributed (in either source or binary +form) with the major components (compiler, kernel, and so on) of the +operating system on which the executable runs, unless that component +itself accompanies the executable. + +If distribution of executable or object code is made by offering +access to copy from a designated place, then offering equivalent +access to copy the source code from the same place counts as +distribution of the source code, even though third parties are not +compelled to copy the source along with the object code. + + 4. You may not copy, modify, sublicense, or distribute the Program +except as expressly provided under this License. Any attempt +otherwise to copy, modify, sublicense or distribute the Program is +void, and will automatically terminate your rights under this License. +However, parties who have received copies, or rights, from you under +this License will not have their licenses terminated so long as such +parties remain in full compliance. + + 5. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Program or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Program (or any work based on the +Program), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Program or works based on it. + + 6. Each time you redistribute the Program (or any work based on the +Program), the recipient automatically receives a license from the +original licensor to copy, distribute or modify the Program subject to +these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties to +this License. + + 7. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Program at all. For example, if a patent +license would not permit royalty-free redistribution of the Program by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Program. + +If any portion of this section is held invalid or unenforceable under +any particular circumstance, the balance of the section is intended to +apply and the section as a whole is intended to apply in other +circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system, which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 8. If the distribution and/or use of the Program is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Program under this License +may add an explicit geographical distribution limitation excluding +those countries, so that distribution is permitted only in or among +countries not thus excluded. In such case, this License incorporates +the limitation as if written in the body of this License. + + 9. The Free Software Foundation may publish revised and/or new versions +of the General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + +Each version is given a distinguishing version number. If the Program +specifies a version number of this License which applies to it and "any +later version", you have the option of following the terms and conditions +either of that version or of any later version published by the Free +Software Foundation. If the Program does not specify a version number of +this License, you may choose any version ever published by the Free Software +Foundation. + + 10. If you wish to incorporate parts of the Program into other free +programs whose distribution conditions are different, write to the author +to ask for permission. For software which is copyrighted by the Free +Software Foundation, write to the Free Software Foundation; we sometimes +make exceptions for this. Our decision will be guided by the two goals +of preserving the free status of all derivatives of our free software and +of promoting the sharing and reuse of software generally. + + NO WARRANTY + + 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY +FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN +OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES +PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED +OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS +TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE +PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, +REPAIR OR CORRECTION. + + 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR +REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, +INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING +OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED +TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY +YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER +PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE +POSSIBILITY OF SUCH DAMAGES. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + + +Also add information on how to contact you by electronic and paper mail. + +If the program is interactive, make it output a short notice like this +when it starts in an interactive mode: + + Gnomovision version 69, Copyright (C) year name of author + Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, the commands you use may +be called something other than `show w' and `show c'; they could even be +mouse-clicks or menu items--whatever suits your program. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the program, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the program + `Gnomovision' (which makes passes at compilers) written by James Hacker. + + , 1 April 1989 + Ty Coon, President of Vice + +This General Public License does not permit incorporating your program into +proprietary programs. If your program is a subroutine library, you may +consider it more useful to permit linking proprietary applications with the +library. If this is what you want to do, use the GNU Library General +Public License instead of this License. diff --git a/third-party/odb/libodb-sqlite-2.4.0/INSTALL b/third-party/odb/libodb-sqlite-2.4.0/INSTALL new file mode 100755 index 0000000..2a55ef1 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/INSTALL @@ -0,0 +1,116 @@ +Prerequisites +============= + + - libodb http://www.codesynthesis.com/products/odb/ + - libsqlite3 http://www.sqlite.org + +If you plan to access an SQLite database from multiple threads, then +you will need SQLite version 3.5.0 or later built with the unlock +notify feature (SQLITE_ENABLE_UNLOCK_NOTIFY) enabled. + + +Building on UNIX +================ + +The following build instructions are for the Linux/UNIX/Mac OS X +operating systems as well as for Cygwin and MinGW on Windows. + +The standard autotools-based build system is used on these platforms. +After unpacking the source code archive, change to the libodb-sqlite +package directory (referred to as libodb-sqlite/ from now on) and run +the configure script: + +./configure + +To see the available configuration options run configure with --help: + +./configure --help + +The configure script expects the libodb and libsqlite3 headers and +libraries to be installed in a directory where the C++ compiler +and linker will search for them by default (normally /usr and +/usr/local). If these libraries are installed in other directories, +you can use the CPPFLAGS and LDFLAGS configure variables to specify +their locations, for example: + +./configure CPPFLAGS=-I/opt/libodb/include LDFLAGS=-L/opt/libodb/lib + +If libodb is not installed and you would like to use its build +directory instead, you can use the --with-libodb configure option +to specify its location, for example: + +./configure --with-libodb=/tmp/libodb + +As another example, the following configure command only builds shared +libraries, uses the specified C++ compiler, and compiles with optimization +and without debug information: + +./configure --disable-static CXX=g++-4.5 CXXFLAGS=-O3 + +Once configuration is complete, run make to build libodb-sqlite: + +make + +Once the build is completed successfully, you can install the libodb-sqlite +headers and libraries using the install target (you may need to do this +step as root depending on the installation directory): + +make install + + +Building on Windows +=================== + +The following build instructions are for Windows using Microsoft Visual +Studio. If you would like to build libodb-sqlite with GCC either using +Cygwin or MinGW, refer to the "Building on UNIX" section above. + +The standard Visual Studio project and solution files are used on this +platform. The provided project files expect the libodb and sqlite +header and import library directories to be in the VC++ Directories +Include and Library search lists. For libodb, see the INSTALL file in +the package directory for more information on how to setup the VC++ +Directories. + +The SQLite binary distribution for Windows contains only a 32-bit DLL +and it is built without unlock notify support. The provided libodb- +sqlite project files assume the unlock notify feature is available (you +can change this by manually removing the LIBODB_SQLITE_HAVE_UNLOCK_NOTIFY +macro from the project's "Preprocessor Definitions" settings). The SQLite +source distribution for Windows lacks Visual Studio project/solution files. + +To rectify this situation, the libodb-sqlite distribution includes, in the +etc\sqlite\ directory, Visual Studio 8, 9, 10, and 11 project/solution files +for building 32 and 64-bit SQLite libraries with unlock notify support. +Refer to the accompanying README file for information on how to build the +libraries and configure VC++ Directories to automatically locate them. + +To build libodb-sqlite, unpack the source code archive and open the +libodb-sqlite-vc.sln file located in the libodb-sqlite package +directory (referred to as libodb-sqlite\ from now on). Here is the +version of Visual Studio that you are using. Once the solution is open, +select the desired build configuration (Debug or Release) and platform +(Win32 or x64) and build the solution. + +The resulting 32-bit DLLs and import libraries are placed into the +libodb-sqlite\bin\ and libodb-sqlite\lib\ directories, respectively. +Similarly, the 64-bit DLLs and import libraries are placed into +libodb-sqlite\bin64\ and libodb-sqlite\lib64\. The Release versions of +the import libraries are named odb-sqlite.lib and the Debug versions +are named odb-sqlite-d.lib. + +To configure Visual Studio to automatically locate the libodb-sqlite +headers, DLLs, and import libraries, add the following paths to your +VC++ Directories: + +Win32: + + Include: ...\libodb-sqlite + Library: ...\libodb-sqlite\lib + Executable: ...\libodb-sqlite\bin + +x64: + + Include: ...\libodb-sqlite + Library: ...\libodb-sqlite\lib64 + Executable: ...\libodb-sqlite\bin64 diff --git a/third-party/odb/libodb-sqlite-2.4.0/LICENSE b/third-party/odb/libodb-sqlite-2.4.0/LICENSE new file mode 100755 index 0000000..612c66c --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/LICENSE @@ -0,0 +1,18 @@ +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License version 2 as +published by the Free Software Foundation. + +For more information on ODB licensing as well as for answers to +some of the common licensing questions, visit the ODB License +page: + +http://www.codesynthesis.com/products/odb/license.xhtml + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for details. + +You should have received a copy of the GNU General Public License +along with this program; if not, write to the Free Software +Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA diff --git a/third-party/odb/libodb-sqlite-2.4.0/Makefile.am b/third-party/odb/libodb-sqlite-2.4.0/Makefile.am new file mode 100755 index 0000000..111f619 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/Makefile.am @@ -0,0 +1,11 @@ +# file : Makefile.am +# copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +# license : GNU GPL v2; see accompanying LICENSE file + +SUBDIRS = odb/sqlite +dist_doc_DATA = GPLv2 LICENSE README NEWS version +EXTRA_DIST = INSTALL libodb-sqlite-vc8.sln libodb-sqlite-vc9.sln libodb-sqlite-vc10.sln libodb-sqlite-vc11.sln libodb-sqlite-vc12.sln etc/sqlite/sqlite3-vc9.sln etc/sqlite/sqlite3-vc9.vcproj etc/sqlite/sqlite3-vc8.sln etc/sqlite/sqlite3-vc11.vcxproj.filters etc/sqlite/sqlite3-vc8.vcproj etc/sqlite/sqlite3-vc12.vcxproj.filters etc/sqlite/sqlite3-vc11.vcxproj etc/sqlite/sqlite3-vc10.vcxproj.filters etc/sqlite/sqlite3-vc12.vcxproj etc/sqlite/sqlite3-vc10.sln etc/sqlite/sqlite3-vc10.vcxproj etc/sqlite/sqlite3-vc12.sln etc/sqlite/sqlite3-vc11.sln etc/sqlite/README bootstrap +ACLOCAL_AMFLAGS = -I m4 + +pkgconfigdir = @pkgconfigdir@ +pkgconfig_DATA= libodb-sqlite.pc diff --git a/third-party/odb/libodb-sqlite-2.4.0/Makefile.in b/third-party/odb/libodb-sqlite-2.4.0/Makefile.in new file mode 100755 index 0000000..f8a2a49 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/Makefile.in @@ -0,0 +1,860 @@ +# Makefile.in generated by automake 1.12.6 from Makefile.am. +# @configure_input@ + +# Copyright (C) 1994-2012 Free Software Foundation, Inc. + +# This Makefile.in is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY, to the extent permitted by law; without +# even the implied warranty of MERCHANTABILITY or FITNESS FOR A +# PARTICULAR PURPOSE. + +@SET_MAKE@ + +# file : Makefile.am +# copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +# license : GNU GPL v2; see accompanying LICENSE file + +VPATH = @srcdir@ +am__make_dryrun = \ + { \ + am__dry=no; \ + case $$MAKEFLAGS in \ + *\\[\ \ ]*) \ + echo 'am--echo: ; @echo "AM" OK' | $(MAKE) -f - 2>/dev/null \ + | grep '^AM OK$$' >/dev/null || am__dry=yes;; \ + *) \ + for am__flg in $$MAKEFLAGS; do \ + case $$am__flg in \ + *=*|--*) ;; \ + *n*) am__dry=yes; break;; \ + esac; \ + done;; \ + esac; \ + test $$am__dry = yes; \ + } +pkgdatadir = $(datadir)/@PACKAGE@ +pkgincludedir = $(includedir)/@PACKAGE@ +pkglibdir = $(libdir)/@PACKAGE@ +pkglibexecdir = $(libexecdir)/@PACKAGE@ +am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd +install_sh_DATA = $(install_sh) -c -m 644 +install_sh_PROGRAM = $(install_sh) -c +install_sh_SCRIPT = $(install_sh) -c +INSTALL_HEADER = $(INSTALL_DATA) +transform = $(program_transform_name) +NORMAL_INSTALL = : +PRE_INSTALL = : +POST_INSTALL = : +NORMAL_UNINSTALL = : +PRE_UNINSTALL = : +POST_UNINSTALL = : +build_triplet = @build@ +host_triplet = @host@ +subdir = . +DIST_COMMON = README $(am__configure_deps) $(dist_doc_DATA) \ + $(srcdir)/Makefile.am $(srcdir)/Makefile.in \ + $(srcdir)/libodb-sqlite.pc.in $(top_srcdir)/config/ar-lib \ + $(top_srcdir)/config/config.guess \ + $(top_srcdir)/config/config.sub \ + $(top_srcdir)/config/install-sh $(top_srcdir)/config/ltmain.sh \ + $(top_srcdir)/config/missing $(top_srcdir)/configure \ + $(top_srcdir)/odb/sqlite/details/config.h.in INSTALL NEWS \ + config/ar-lib config/config.guess config/config.sub \ + config/install-sh config/ltmain.sh config/missing +ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 +am__aclocal_m4_deps = $(top_srcdir)/m4/acx-pthread.m4 \ + $(top_srcdir)/m4/disable-rpath.m4 $(top_srcdir)/m4/libodb.m4 \ + $(top_srcdir)/m4/libsqlite.m4 $(top_srcdir)/m4/libtool-link.m4 \ + $(top_srcdir)/m4/libtool.m4 $(top_srcdir)/m4/ltoptions.m4 \ + $(top_srcdir)/m4/ltsugar.m4 $(top_srcdir)/m4/ltversion.m4 \ + $(top_srcdir)/m4/lt~obsolete.m4 $(top_srcdir)/m4/pkgconfig.m4 \ + $(top_srcdir)/m4/static-lib.m4 $(top_srcdir)/m4/threads.m4 \ + $(top_srcdir)/configure.ac +am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \ + $(ACLOCAL_M4) +am__CONFIG_DISTCLEAN_FILES = config.status config.cache config.log \ + configure.lineno config.status.lineno +mkinstalldirs = $(install_sh) -d +CONFIG_HEADER = $(top_builddir)/odb/sqlite/config.h \ + $(top_builddir)/odb/sqlite/details/config.h +CONFIG_CLEAN_FILES = libodb-sqlite.pc +CONFIG_CLEAN_VPATH_FILES = +SOURCES = +DIST_SOURCES = +RECURSIVE_TARGETS = all-recursive check-recursive dvi-recursive \ + html-recursive info-recursive install-data-recursive \ + install-dvi-recursive install-exec-recursive \ + install-html-recursive install-info-recursive \ + install-pdf-recursive install-ps-recursive install-recursive \ + installcheck-recursive installdirs-recursive pdf-recursive \ + ps-recursive uninstall-recursive +am__can_run_installinfo = \ + case $$AM_UPDATE_INFO_DIR in \ + n|no|NO) false;; \ + *) (install-info --version) >/dev/null 2>&1;; \ + esac +am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`; +am__vpath_adj = case $$p in \ + $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \ + *) f=$$p;; \ + esac; +am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`; +am__install_max = 40 +am__nobase_strip_setup = \ + srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'` +am__nobase_strip = \ + for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||" +am__nobase_list = $(am__nobase_strip_setup); \ + for p in $$list; do echo "$$p $$p"; done | \ + sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \ + $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \ + if (++n[$$2] == $(am__install_max)) \ + { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \ + END { for (dir in files) print dir, files[dir] }' +am__base_list = \ + sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \ + sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g' +am__uninstall_files_from_dir = { \ + test -z "$$files" \ + || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \ + || { echo " ( cd '$$dir' && rm -f" $$files ")"; \ + $(am__cd) "$$dir" && rm -f $$files; }; \ + } +am__installdirs = "$(DESTDIR)$(docdir)" "$(DESTDIR)$(pkgconfigdir)" +DATA = $(dist_doc_DATA) $(pkgconfig_DATA) +RECURSIVE_CLEAN_TARGETS = mostlyclean-recursive clean-recursive \ + distclean-recursive maintainer-clean-recursive +AM_RECURSIVE_TARGETS = $(RECURSIVE_TARGETS:-recursive=) \ + $(RECURSIVE_CLEAN_TARGETS:-recursive=) tags TAGS ctags CTAGS \ + cscope distdir dist dist-all distcheck +ETAGS = etags +CTAGS = ctags +CSCOPE = cscope +DIST_SUBDIRS = $(SUBDIRS) +DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) +distdir = $(PACKAGE)-$(VERSION) +top_distdir = $(distdir) +am__remove_distdir = \ + if test -d "$(distdir)"; then \ + find "$(distdir)" -type d ! -perm -200 -exec chmod u+w {} ';' \ + && rm -rf "$(distdir)" \ + || { sleep 5 && rm -rf "$(distdir)"; }; \ + else :; fi +am__post_remove_distdir = $(am__remove_distdir) +am__relativize = \ + dir0=`pwd`; \ + sed_first='s,^\([^/]*\)/.*$$,\1,'; \ + sed_rest='s,^[^/]*/*,,'; \ + sed_last='s,^.*/\([^/]*\)$$,\1,'; \ + sed_butlast='s,/*[^/]*$$,,'; \ + while test -n "$$dir1"; do \ + first=`echo "$$dir1" | sed -e "$$sed_first"`; \ + if test "$$first" != "."; then \ + if test "$$first" = ".."; then \ + dir2=`echo "$$dir0" | sed -e "$$sed_last"`/"$$dir2"; \ + dir0=`echo "$$dir0" | sed -e "$$sed_butlast"`; \ + else \ + first2=`echo "$$dir2" | sed -e "$$sed_first"`; \ + if test "$$first2" = "$$first"; then \ + dir2=`echo "$$dir2" | sed -e "$$sed_rest"`; \ + else \ + dir2="../$$dir2"; \ + fi; \ + dir0="$$dir0"/"$$first"; \ + fi; \ + fi; \ + dir1=`echo "$$dir1" | sed -e "$$sed_rest"`; \ + done; \ + reldir="$$dir2" +DIST_ARCHIVES = $(distdir).tar.gz $(distdir).tar.bz2 $(distdir).zip +GZIP_ENV = --best +DIST_TARGETS = dist-bzip2 dist-gzip dist-zip +distuninstallcheck_listfiles = find . -type f -print +am__distuninstallcheck_listfiles = $(distuninstallcheck_listfiles) \ + | sed 's|^\./|$(prefix)/|' | grep -v '$(infodir)/dir$$' +distcleancheck_listfiles = find . -type f -print +ACLOCAL = @ACLOCAL@ +AMTAR = @AMTAR@ +AR = @AR@ +AS = @AS@ +AUTOCONF = @AUTOCONF@ +AUTOHEADER = @AUTOHEADER@ +AUTOMAKE = @AUTOMAKE@ +AWK = @AWK@ +CC = @CC@ +CCDEPMODE = @CCDEPMODE@ +CFLAGS = @CFLAGS@ +CPP = @CPP@ +CPPFLAGS = @CPPFLAGS@ +CXX = @CXX@ +CXXCPP = @CXXCPP@ +CXXDEPMODE = @CXXDEPMODE@ +CXXFLAGS = @CXXFLAGS@ +CYGPATH_W = @CYGPATH_W@ +DEFS = @DEFS@ +DEPDIR = @DEPDIR@ +DLLTOOL = @DLLTOOL@ +DSYMUTIL = @DSYMUTIL@ +DUMPBIN = @DUMPBIN@ +ECHO_C = @ECHO_C@ +ECHO_N = @ECHO_N@ +ECHO_T = @ECHO_T@ +EGREP = @EGREP@ +EXEEXT = @EXEEXT@ +FGREP = @FGREP@ +GREP = @GREP@ +INSTALL = @INSTALL@ +INSTALL_DATA = @INSTALL_DATA@ +INSTALL_PROGRAM = @INSTALL_PROGRAM@ +INSTALL_SCRIPT = @INSTALL_SCRIPT@ +INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@ +LD = @LD@ +LDFLAGS = @LDFLAGS@ +LIBOBJS = @LIBOBJS@ +LIBS = @LIBS@ +LIBTOOL = @LIBTOOL@ +LIPO = @LIPO@ +LN_S = @LN_S@ +LTLIBOBJS = @LTLIBOBJS@ +MAKEINFO = @MAKEINFO@ +MANIFEST_TOOL = @MANIFEST_TOOL@ +MKDIR_P = @MKDIR_P@ +NM = @NM@ +NMEDIT = @NMEDIT@ +OBJDUMP = @OBJDUMP@ +OBJEXT = @OBJEXT@ +OTOOL = @OTOOL@ +OTOOL64 = @OTOOL64@ +PACKAGE = @PACKAGE@ +PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@ +PACKAGE_NAME = @PACKAGE_NAME@ +PACKAGE_STRING = @PACKAGE_STRING@ +PACKAGE_TARNAME = @PACKAGE_TARNAME@ +PACKAGE_URL = @PACKAGE_URL@ +PACKAGE_VERSION = @PACKAGE_VERSION@ +PATH_SEPARATOR = @PATH_SEPARATOR@ +PTHREAD_CXX = @PTHREAD_CXX@ +PTHREAD_CXXFLAGS = @PTHREAD_CXXFLAGS@ +PTHREAD_LIBS = @PTHREAD_LIBS@ +RANLIB = @RANLIB@ +SED = @SED@ +SET_MAKE = @SET_MAKE@ +SHELL = @SHELL@ +STRIP = @STRIP@ +VERSION = @VERSION@ +abs_builddir = @abs_builddir@ +abs_srcdir = @abs_srcdir@ +abs_top_builddir = @abs_top_builddir@ +abs_top_srcdir = @abs_top_srcdir@ +ac_ct_AR = @ac_ct_AR@ +ac_ct_CC = @ac_ct_CC@ +ac_ct_CXX = @ac_ct_CXX@ +ac_ct_DUMPBIN = @ac_ct_DUMPBIN@ +acx_pthread_config = @acx_pthread_config@ +am__include = @am__include@ +am__leading_dot = @am__leading_dot@ +am__quote = @am__quote@ +am__tar = @am__tar@ +am__untar = @am__untar@ +bindir = @bindir@ +build = @build@ +build_alias = @build_alias@ +build_cpu = @build_cpu@ +build_os = @build_os@ +build_vendor = @build_vendor@ +builddir = @builddir@ +datadir = @datadir@ +datarootdir = @datarootdir@ +docdir = @docdir@ +dvidir = @dvidir@ +exec_prefix = @exec_prefix@ +host = @host@ +host_alias = @host_alias@ +host_cpu = @host_cpu@ +host_os = @host_os@ +host_vendor = @host_vendor@ +htmldir = @htmldir@ +includedir = @includedir@ +infodir = @infodir@ +install_sh = @install_sh@ +libdir = @libdir@ +libexecdir = @libexecdir@ +localedir = @localedir@ +localstatedir = @localstatedir@ +mandir = @mandir@ +mkdir_p = @mkdir_p@ +oldincludedir = @oldincludedir@ +pdfdir = @pdfdir@ +pkgconfigdir = @pkgconfigdir@ +prefix = @prefix@ +program_transform_name = @program_transform_name@ +psdir = @psdir@ +sbindir = @sbindir@ +sharedstatedir = @sharedstatedir@ +srcdir = @srcdir@ +sysconfdir = @sysconfdir@ +target_alias = @target_alias@ +top_build_prefix = @top_build_prefix@ +top_builddir = @top_builddir@ +top_srcdir = @top_srcdir@ +SUBDIRS = odb/sqlite +dist_doc_DATA = GPLv2 LICENSE README NEWS version +EXTRA_DIST = INSTALL libodb-sqlite-vc8.sln libodb-sqlite-vc9.sln libodb-sqlite-vc10.sln libodb-sqlite-vc11.sln libodb-sqlite-vc12.sln etc/sqlite/sqlite3-vc9.sln etc/sqlite/sqlite3-vc9.vcproj etc/sqlite/sqlite3-vc8.sln etc/sqlite/sqlite3-vc11.vcxproj.filters etc/sqlite/sqlite3-vc8.vcproj etc/sqlite/sqlite3-vc12.vcxproj.filters etc/sqlite/sqlite3-vc11.vcxproj etc/sqlite/sqlite3-vc10.vcxproj.filters etc/sqlite/sqlite3-vc12.vcxproj etc/sqlite/sqlite3-vc10.sln etc/sqlite/sqlite3-vc10.vcxproj etc/sqlite/sqlite3-vc12.sln etc/sqlite/sqlite3-vc11.sln etc/sqlite/README bootstrap +ACLOCAL_AMFLAGS = -I m4 +pkgconfig_DATA = libodb-sqlite.pc +all: all-recursive + +.SUFFIXES: +am--refresh: Makefile + @: +$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps) + @for dep in $?; do \ + case '$(am__configure_deps)' in \ + *$$dep*) \ + echo ' cd $(srcdir) && $(AUTOMAKE) --foreign'; \ + $(am__cd) $(srcdir) && $(AUTOMAKE) --foreign \ + && exit 0; \ + exit 1;; \ + esac; \ + done; \ + echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign Makefile'; \ + $(am__cd) $(top_srcdir) && \ + $(AUTOMAKE) --foreign Makefile +.PRECIOUS: Makefile +Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status + @case '$?' in \ + *config.status*) \ + echo ' $(SHELL) ./config.status'; \ + $(SHELL) ./config.status;; \ + *) \ + echo ' cd $(top_builddir) && $(SHELL) ./config.status $@ $(am__depfiles_maybe)'; \ + cd $(top_builddir) && $(SHELL) ./config.status $@ $(am__depfiles_maybe);; \ + esac; + +$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) + $(SHELL) ./config.status --recheck + +$(top_srcdir)/configure: $(am__configure_deps) + $(am__cd) $(srcdir) && $(AUTOCONF) +$(ACLOCAL_M4): $(am__aclocal_m4_deps) + $(am__cd) $(srcdir) && $(ACLOCAL) $(ACLOCAL_AMFLAGS) +$(am__aclocal_m4_deps): + +odb/sqlite/details/config.h: odb/sqlite/details/stamp-h2 + @if test ! -f $@; then rm -f odb/sqlite/details/stamp-h2; else :; fi + @if test ! -f $@; then $(MAKE) $(AM_MAKEFLAGS) odb/sqlite/details/stamp-h2; else :; fi + +odb/sqlite/details/stamp-h2: $(top_srcdir)/odb/sqlite/details/config.h.in $(top_builddir)/config.status + @rm -f odb/sqlite/details/stamp-h2 + cd $(top_builddir) && $(SHELL) ./config.status odb/sqlite/details/config.h + +distclean-hdr: + -rm -f odb/sqlite/details/config.h odb/sqlite/details/stamp-h2 +libodb-sqlite.pc: $(top_builddir)/config.status $(srcdir)/libodb-sqlite.pc.in + cd $(top_builddir) && $(SHELL) ./config.status $@ + +mostlyclean-libtool: + -rm -f *.lo + +clean-libtool: + -rm -rf .libs _libs + +distclean-libtool: + -rm -f libtool config.lt +install-dist_docDATA: $(dist_doc_DATA) + @$(NORMAL_INSTALL) + @list='$(dist_doc_DATA)'; test -n "$(docdir)" || list=; \ + if test -n "$$list"; then \ + echo " $(MKDIR_P) '$(DESTDIR)$(docdir)'"; \ + $(MKDIR_P) "$(DESTDIR)$(docdir)" || exit 1; \ + fi; \ + for p in $$list; do \ + if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \ + echo "$$d$$p"; \ + done | $(am__base_list) | \ + while read files; do \ + echo " $(INSTALL_DATA) $$files '$(DESTDIR)$(docdir)'"; \ + $(INSTALL_DATA) $$files "$(DESTDIR)$(docdir)" || exit $$?; \ + done + +uninstall-dist_docDATA: + @$(NORMAL_UNINSTALL) + @list='$(dist_doc_DATA)'; test -n "$(docdir)" || list=; \ + files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \ + dir='$(DESTDIR)$(docdir)'; $(am__uninstall_files_from_dir) +install-pkgconfigDATA: $(pkgconfig_DATA) + @$(NORMAL_INSTALL) + @list='$(pkgconfig_DATA)'; test -n "$(pkgconfigdir)" || list=; \ + if test -n "$$list"; then \ + echo " $(MKDIR_P) '$(DESTDIR)$(pkgconfigdir)'"; \ + $(MKDIR_P) "$(DESTDIR)$(pkgconfigdir)" || exit 1; \ + fi; \ + for p in $$list; do \ + if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \ + echo "$$d$$p"; \ + done | $(am__base_list) | \ + while read files; do \ + echo " $(INSTALL_DATA) $$files '$(DESTDIR)$(pkgconfigdir)'"; \ + $(INSTALL_DATA) $$files "$(DESTDIR)$(pkgconfigdir)" || exit $$?; \ + done + +uninstall-pkgconfigDATA: + @$(NORMAL_UNINSTALL) + @list='$(pkgconfig_DATA)'; test -n "$(pkgconfigdir)" || list=; \ + files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \ + dir='$(DESTDIR)$(pkgconfigdir)'; $(am__uninstall_files_from_dir) + +# This directory's subdirectories are mostly independent; you can cd +# into them and run 'make' without going through this Makefile. +# To change the values of 'make' variables: instead of editing Makefiles, +# (1) if the variable is set in 'config.status', edit 'config.status' +# (which will cause the Makefiles to be regenerated when you run 'make'); +# (2) otherwise, pass the desired values on the 'make' command line. +$(RECURSIVE_TARGETS) $(RECURSIVE_CLEAN_TARGETS): + @fail= failcom='exit 1'; \ + for f in x $$MAKEFLAGS; do \ + case $$f in \ + *=* | --[!k]*);; \ + *k*) failcom='fail=yes';; \ + esac; \ + done; \ + dot_seen=no; \ + target=`echo $@ | sed s/-recursive//`; \ + case "$@" in \ + distclean-* | maintainer-clean-*) list='$(DIST_SUBDIRS)' ;; \ + *) list='$(SUBDIRS)' ;; \ + esac; \ + for subdir in $$list; do \ + echo "Making $$target in $$subdir"; \ + if test "$$subdir" = "."; then \ + dot_seen=yes; \ + local_target="$$target-am"; \ + else \ + local_target="$$target"; \ + fi; \ + ($(am__cd) $$subdir && $(MAKE) $(AM_MAKEFLAGS) $$local_target) \ + || eval $$failcom; \ + done; \ + if test "$$dot_seen" = "no"; then \ + $(MAKE) $(AM_MAKEFLAGS) "$$target-am" || exit 1; \ + fi; test -z "$$fail" +tags-recursive: + list='$(SUBDIRS)'; for subdir in $$list; do \ + test "$$subdir" = . || ($(am__cd) $$subdir && $(MAKE) $(AM_MAKEFLAGS) tags); \ + done +ctags-recursive: + list='$(SUBDIRS)'; for subdir in $$list; do \ + test "$$subdir" = . || ($(am__cd) $$subdir && $(MAKE) $(AM_MAKEFLAGS) ctags); \ + done +cscopelist-recursive: + list='$(SUBDIRS)'; for subdir in $$list; do \ + test "$$subdir" = . || ($(am__cd) $$subdir && $(MAKE) $(AM_MAKEFLAGS) cscopelist); \ + done + +ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES) + list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | \ + $(AWK) '{ files[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in files) print i; }; }'`; \ + mkid -fID $$unique +tags: TAGS + +TAGS: tags-recursive $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \ + $(TAGS_FILES) $(LISP) + set x; \ + here=`pwd`; \ + if ($(ETAGS) --etags-include --version) >/dev/null 2>&1; then \ + include_option=--etags-include; \ + empty_fix=.; \ + else \ + include_option=--include; \ + empty_fix=; \ + fi; \ + list='$(SUBDIRS)'; for subdir in $$list; do \ + if test "$$subdir" = .; then :; else \ + test ! -f $$subdir/TAGS || \ + set "$$@" "$$include_option=$$here/$$subdir/TAGS"; \ + fi; \ + done; \ + list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | \ + $(AWK) '{ files[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in files) print i; }; }'`; \ + shift; \ + if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \ + test -n "$$unique" || unique=$$empty_fix; \ + if test $$# -gt 0; then \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + "$$@" $$unique; \ + else \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + $$unique; \ + fi; \ + fi +ctags: CTAGS +CTAGS: ctags-recursive $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \ + $(TAGS_FILES) $(LISP) + list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | \ + $(AWK) '{ files[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in files) print i; }; }'`; \ + test -z "$(CTAGS_ARGS)$$unique" \ + || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \ + $$unique + +GTAGS: + here=`$(am__cd) $(top_builddir) && pwd` \ + && $(am__cd) $(top_srcdir) \ + && gtags -i $(GTAGS_ARGS) "$$here" + +cscope: cscope.files + test ! -s cscope.files \ + || $(CSCOPE) -b -q $(AM_CSCOPEFLAGS) $(CSCOPEFLAGS) -i cscope.files $(CSCOPE_ARGS) + +clean-cscope: + -rm -f cscope.files + +cscope.files: clean-cscope cscopelist-recursive cscopelist + +cscopelist: cscopelist-recursive $(HEADERS) $(SOURCES) $(LISP) + list='$(SOURCES) $(HEADERS) $(LISP)'; \ + case "$(srcdir)" in \ + [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \ + *) sdir=$(subdir)/$(srcdir) ;; \ + esac; \ + for i in $$list; do \ + if test -f "$$i"; then \ + echo "$(subdir)/$$i"; \ + else \ + echo "$$sdir/$$i"; \ + fi; \ + done >> $(top_builddir)/cscope.files + +distclean-tags: + -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags + -rm -f cscope.out cscope.in.out cscope.po.out cscope.files + +distdir: $(DISTFILES) + $(am__remove_distdir) + test -d "$(distdir)" || mkdir "$(distdir)" + @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + list='$(DISTFILES)'; \ + dist_files=`for file in $$list; do echo $$file; done | \ + sed -e "s|^$$srcdirstrip/||;t" \ + -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \ + case $$dist_files in \ + */*) $(MKDIR_P) `echo "$$dist_files" | \ + sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \ + sort -u` ;; \ + esac; \ + for file in $$dist_files; do \ + if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \ + if test -d $$d/$$file; then \ + dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \ + if test -d "$(distdir)/$$file"; then \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \ + cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \ + else \ + test -f "$(distdir)/$$file" \ + || cp -p $$d/$$file "$(distdir)/$$file" \ + || exit 1; \ + fi; \ + done + @list='$(DIST_SUBDIRS)'; for subdir in $$list; do \ + if test "$$subdir" = .; then :; else \ + $(am__make_dryrun) \ + || test -d "$(distdir)/$$subdir" \ + || $(MKDIR_P) "$(distdir)/$$subdir" \ + || exit 1; \ + dir1=$$subdir; dir2="$(distdir)/$$subdir"; \ + $(am__relativize); \ + new_distdir=$$reldir; \ + dir1=$$subdir; dir2="$(top_distdir)"; \ + $(am__relativize); \ + new_top_distdir=$$reldir; \ + echo " (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) top_distdir="$$new_top_distdir" distdir="$$new_distdir" \\"; \ + echo " am__remove_distdir=: am__skip_length_check=: am__skip_mode_fix=: distdir)"; \ + ($(am__cd) $$subdir && \ + $(MAKE) $(AM_MAKEFLAGS) \ + top_distdir="$$new_top_distdir" \ + distdir="$$new_distdir" \ + am__remove_distdir=: \ + am__skip_length_check=: \ + am__skip_mode_fix=: \ + distdir) \ + || exit 1; \ + fi; \ + done + -test -n "$(am__skip_mode_fix)" \ + || find "$(distdir)" -type d ! -perm -755 \ + -exec chmod u+rwx,go+rx {} \; -o \ + ! -type d ! -perm -444 -links 1 -exec chmod a+r {} \; -o \ + ! -type d ! -perm -400 -exec chmod a+r {} \; -o \ + ! -type d ! -perm -444 -exec $(install_sh) -c -m a+r {} {} \; \ + || chmod -R a+r "$(distdir)" +dist-gzip: distdir + tardir=$(distdir) && $(am__tar) | GZIP=$(GZIP_ENV) gzip -c >$(distdir).tar.gz + $(am__post_remove_distdir) +dist-bzip2: distdir + tardir=$(distdir) && $(am__tar) | BZIP2=$${BZIP2--9} bzip2 -c >$(distdir).tar.bz2 + $(am__post_remove_distdir) + +dist-lzip: distdir + tardir=$(distdir) && $(am__tar) | lzip -c $${LZIP_OPT--9} >$(distdir).tar.lz + $(am__post_remove_distdir) + +dist-xz: distdir + tardir=$(distdir) && $(am__tar) | XZ_OPT=$${XZ_OPT--e} xz -c >$(distdir).tar.xz + $(am__post_remove_distdir) + +dist-tarZ: distdir + tardir=$(distdir) && $(am__tar) | compress -c >$(distdir).tar.Z + $(am__post_remove_distdir) + +dist-shar: distdir + shar $(distdir) | GZIP=$(GZIP_ENV) gzip -c >$(distdir).shar.gz + $(am__post_remove_distdir) +dist-zip: distdir + -rm -f $(distdir).zip + zip -rq $(distdir).zip $(distdir) + $(am__post_remove_distdir) + +dist dist-all: + $(MAKE) $(AM_MAKEFLAGS) $(DIST_TARGETS) am__post_remove_distdir='@:' + $(am__post_remove_distdir) + +# This target untars the dist file and tries a VPATH configuration. Then +# it guarantees that the distribution is self-contained by making another +# tarfile. +distcheck: dist + case '$(DIST_ARCHIVES)' in \ + *.tar.gz*) \ + GZIP=$(GZIP_ENV) gzip -dc $(distdir).tar.gz | $(am__untar) ;;\ + *.tar.bz2*) \ + bzip2 -dc $(distdir).tar.bz2 | $(am__untar) ;;\ + *.tar.lz*) \ + lzip -dc $(distdir).tar.lz | $(am__untar) ;;\ + *.tar.xz*) \ + xz -dc $(distdir).tar.xz | $(am__untar) ;;\ + *.tar.Z*) \ + uncompress -c $(distdir).tar.Z | $(am__untar) ;;\ + *.shar.gz*) \ + GZIP=$(GZIP_ENV) gzip -dc $(distdir).shar.gz | unshar ;;\ + *.zip*) \ + unzip $(distdir).zip ;;\ + esac + chmod -R a-w $(distdir) + chmod u+w $(distdir) + mkdir $(distdir)/_build $(distdir)/_inst + chmod a-w $(distdir) + test -d $(distdir)/_build || exit 0; \ + dc_install_base=`$(am__cd) $(distdir)/_inst && pwd | sed -e 's,^[^:\\/]:[\\/],/,'` \ + && dc_destdir="$${TMPDIR-/tmp}/am-dc-$$$$/" \ + && am__cwd=`pwd` \ + && $(am__cd) $(distdir)/_build \ + && ../configure --srcdir=.. --prefix="$$dc_install_base" \ + $(AM_DISTCHECK_CONFIGURE_FLAGS) \ + $(DISTCHECK_CONFIGURE_FLAGS) \ + && $(MAKE) $(AM_MAKEFLAGS) \ + && $(MAKE) $(AM_MAKEFLAGS) dvi \ + && $(MAKE) $(AM_MAKEFLAGS) check \ + && $(MAKE) $(AM_MAKEFLAGS) install \ + && $(MAKE) $(AM_MAKEFLAGS) installcheck \ + && $(MAKE) $(AM_MAKEFLAGS) uninstall \ + && $(MAKE) $(AM_MAKEFLAGS) distuninstallcheck_dir="$$dc_install_base" \ + distuninstallcheck \ + && chmod -R a-w "$$dc_install_base" \ + && ({ \ + (cd ../.. && umask 077 && mkdir "$$dc_destdir") \ + && $(MAKE) $(AM_MAKEFLAGS) DESTDIR="$$dc_destdir" install \ + && $(MAKE) $(AM_MAKEFLAGS) DESTDIR="$$dc_destdir" uninstall \ + && $(MAKE) $(AM_MAKEFLAGS) DESTDIR="$$dc_destdir" \ + distuninstallcheck_dir="$$dc_destdir" distuninstallcheck; \ + } || { rm -rf "$$dc_destdir"; exit 1; }) \ + && rm -rf "$$dc_destdir" \ + && $(MAKE) $(AM_MAKEFLAGS) dist \ + && rm -rf $(DIST_ARCHIVES) \ + && $(MAKE) $(AM_MAKEFLAGS) distcleancheck \ + && cd "$$am__cwd" \ + || exit 1 + $(am__post_remove_distdir) + @(echo "$(distdir) archives ready for distribution: "; \ + list='$(DIST_ARCHIVES)'; for i in $$list; do echo $$i; done) | \ + sed -e 1h -e 1s/./=/g -e 1p -e 1x -e '$$p' -e '$$x' +distuninstallcheck: + @test -n '$(distuninstallcheck_dir)' || { \ + echo 'ERROR: trying to run $@ with an empty' \ + '$$(distuninstallcheck_dir)' >&2; \ + exit 1; \ + }; \ + $(am__cd) '$(distuninstallcheck_dir)' || { \ + echo 'ERROR: cannot chdir into $(distuninstallcheck_dir)' >&2; \ + exit 1; \ + }; \ + test `$(am__distuninstallcheck_listfiles) | wc -l` -eq 0 \ + || { echo "ERROR: files left after uninstall:" ; \ + if test -n "$(DESTDIR)"; then \ + echo " (check DESTDIR support)"; \ + fi ; \ + $(distuninstallcheck_listfiles) ; \ + exit 1; } >&2 +distcleancheck: distclean + @if test '$(srcdir)' = . ; then \ + echo "ERROR: distcleancheck can only run from a VPATH build" ; \ + exit 1 ; \ + fi + @test `$(distcleancheck_listfiles) | wc -l` -eq 0 \ + || { echo "ERROR: files left in build directory after distclean:" ; \ + $(distcleancheck_listfiles) ; \ + exit 1; } >&2 +check-am: all-am +check: check-recursive +all-am: Makefile $(DATA) +installdirs: installdirs-recursive +installdirs-am: + for dir in "$(DESTDIR)$(docdir)" "$(DESTDIR)$(pkgconfigdir)"; do \ + test -z "$$dir" || $(MKDIR_P) "$$dir"; \ + done +install: install-recursive +install-exec: install-exec-recursive +install-data: install-data-recursive +uninstall: uninstall-recursive + +install-am: all-am + @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am + +installcheck: installcheck-recursive +install-strip: + if test -z '$(STRIP)'; then \ + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + install; \ + else \ + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \ + fi +mostlyclean-generic: + +clean-generic: + +distclean-generic: + -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES) + -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES) + +maintainer-clean-generic: + @echo "This command is intended for maintainers to use" + @echo "it deletes files that may require special tools to rebuild." +clean: clean-recursive + +clean-am: clean-generic clean-libtool mostlyclean-am + +distclean: distclean-recursive + -rm -f $(am__CONFIG_DISTCLEAN_FILES) + -rm -f Makefile +distclean-am: clean-am distclean-generic distclean-hdr \ + distclean-libtool distclean-tags + +dvi: dvi-recursive + +dvi-am: + +html: html-recursive + +html-am: + +info: info-recursive + +info-am: + +install-data-am: install-dist_docDATA install-pkgconfigDATA + +install-dvi: install-dvi-recursive + +install-dvi-am: + +install-exec-am: + +install-html: install-html-recursive + +install-html-am: + +install-info: install-info-recursive + +install-info-am: + +install-man: + +install-pdf: install-pdf-recursive + +install-pdf-am: + +install-ps: install-ps-recursive + +install-ps-am: + +installcheck-am: + +maintainer-clean: maintainer-clean-recursive + -rm -f $(am__CONFIG_DISTCLEAN_FILES) + -rm -rf $(top_srcdir)/autom4te.cache + -rm -f Makefile +maintainer-clean-am: distclean-am maintainer-clean-generic + +mostlyclean: mostlyclean-recursive + +mostlyclean-am: mostlyclean-generic mostlyclean-libtool + +pdf: pdf-recursive + +pdf-am: + +ps: ps-recursive + +ps-am: + +uninstall-am: uninstall-dist_docDATA uninstall-pkgconfigDATA + +.MAKE: $(RECURSIVE_CLEAN_TARGETS) $(RECURSIVE_TARGETS) \ + cscopelist-recursive ctags-recursive install-am install-strip \ + tags-recursive + +.PHONY: $(RECURSIVE_CLEAN_TARGETS) $(RECURSIVE_TARGETS) CTAGS GTAGS \ + all all-am am--refresh check check-am clean clean-cscope \ + clean-generic clean-libtool cscope cscopelist \ + cscopelist-recursive ctags ctags-recursive dist dist-all \ + dist-bzip2 dist-gzip dist-lzip dist-shar dist-tarZ dist-xz \ + dist-zip distcheck distclean distclean-generic distclean-hdr \ + distclean-libtool distclean-tags distcleancheck distdir \ + distuninstallcheck dvi dvi-am html html-am info info-am \ + install install-am install-data install-data-am \ + install-dist_docDATA install-dvi install-dvi-am install-exec \ + install-exec-am install-html install-html-am install-info \ + install-info-am install-man install-pdf install-pdf-am \ + install-pkgconfigDATA install-ps install-ps-am install-strip \ + installcheck installcheck-am installdirs installdirs-am \ + maintainer-clean maintainer-clean-generic mostlyclean \ + mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \ + tags tags-recursive uninstall uninstall-am \ + uninstall-dist_docDATA uninstall-pkgconfigDATA + + +# Tell versions [3.59,3.63) of GNU make to not export all variables. +# Otherwise a system limit (for SysV at least) may be exceeded. +.NOEXPORT: diff --git a/third-party/odb/libodb-sqlite-2.4.0/NEWS b/third-party/odb/libodb-sqlite-2.4.0/NEWS new file mode 100755 index 0000000..72d0f8b --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/NEWS @@ -0,0 +1 @@ +See the common NEWS file in the ODB compiler package. diff --git a/third-party/odb/libodb-sqlite-2.4.0/README b/third-party/odb/libodb-sqlite-2.4.0/README new file mode 100755 index 0000000..ffd4049 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/README @@ -0,0 +1,20 @@ +ODB is an object-relational mapping (ORM) system for C++. It provides +tools, APIs, and library support that allow you to persist C++ objects +to a relational database (RDBMS) without having to deal with tables, +columns, or SQL and without manually writing any of the mapping code. +For more information see: + +http://www.codesynthesis.com/products/odb/ + +This package contains the SQLite ODB runtime library. Every application +that includes code generated for the SQLite database will need to link +to this library. + +See the NEWS file for the user-visible changes from the previous release. + +See the LICENSE file for distribution conditions. + +See the INSTALL file for prerequisites and installation instructions. + +Send questions, bug reports, or any other feedback to the +odb-users@codesynthesis.com mailing list. diff --git a/third-party/odb/libodb-sqlite-2.4.0/aclocal.m4 b/third-party/odb/libodb-sqlite-2.4.0/aclocal.m4 new file mode 100755 index 0000000..eba1cdd --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/aclocal.m4 @@ -0,0 +1,1033 @@ +# generated automatically by aclocal 1.12.6 -*- Autoconf -*- + +# Copyright (C) 1996-2012 Free Software Foundation, Inc. + +# This file is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY, to the extent permitted by law; without +# even the implied warranty of MERCHANTABILITY or FITNESS FOR A +# PARTICULAR PURPOSE. + +m4_ifndef([AC_AUTOCONF_VERSION], + [m4_copy([m4_PACKAGE_VERSION], [AC_AUTOCONF_VERSION])])dnl +m4_if(m4_defn([AC_AUTOCONF_VERSION]), [2.69],, +[m4_warning([this file was generated for autoconf 2.69. +You have another version of autoconf. It may work, but is not guaranteed to. +If you have problems, you may need to regenerate the build system entirely. +To do so, use the procedure documented by the package, typically 'autoreconf'.])]) + +# Copyright (C) 2002-2012 Free Software Foundation, Inc. +# +# This file is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# AM_AUTOMAKE_VERSION(VERSION) +# ---------------------------- +# Automake X.Y traces this macro to ensure aclocal.m4 has been +# generated from the m4 files accompanying Automake X.Y. +# (This private macro should not be called outside this file.) +AC_DEFUN([AM_AUTOMAKE_VERSION], +[am__api_version='1.12' +dnl Some users find AM_AUTOMAKE_VERSION and mistake it for a way to +dnl require some minimum version. Point them to the right macro. +m4_if([$1], [1.12.6], [], + [AC_FATAL([Do not call $0, use AM_INIT_AUTOMAKE([$1]).])])dnl +]) + +# _AM_AUTOCONF_VERSION(VERSION) +# ----------------------------- +# aclocal traces this macro to find the Autoconf version. +# This is a private macro too. Using m4_define simplifies +# the logic in aclocal, which can simply ignore this definition. +m4_define([_AM_AUTOCONF_VERSION], []) + +# AM_SET_CURRENT_AUTOMAKE_VERSION +# ------------------------------- +# Call AM_AUTOMAKE_VERSION and AM_AUTOMAKE_VERSION so they can be traced. +# This function is AC_REQUIREd by AM_INIT_AUTOMAKE. +AC_DEFUN([AM_SET_CURRENT_AUTOMAKE_VERSION], +[AM_AUTOMAKE_VERSION([1.12.6])dnl +m4_ifndef([AC_AUTOCONF_VERSION], + [m4_copy([m4_PACKAGE_VERSION], [AC_AUTOCONF_VERSION])])dnl +_AM_AUTOCONF_VERSION(m4_defn([AC_AUTOCONF_VERSION]))]) + +# Copyright (C) 2011-2012 Free Software Foundation, Inc. +# +# This file is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# AM_PROG_AR([ACT-IF-FAIL]) +# ------------------------- +# Try to determine the archiver interface, and trigger the ar-lib wrapper +# if it is needed. If the detection of archiver interface fails, run +# ACT-IF-FAIL (default is to abort configure with a proper error message). +AC_DEFUN([AM_PROG_AR], +[AC_BEFORE([$0], [LT_INIT])dnl +AC_BEFORE([$0], [AC_PROG_LIBTOOL])dnl +AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl +AC_REQUIRE_AUX_FILE([ar-lib])dnl +AC_CHECK_TOOLS([AR], [ar lib "link -lib"], [false]) +: ${AR=ar} + +AC_CACHE_CHECK([the archiver ($AR) interface], [am_cv_ar_interface], + [am_cv_ar_interface=ar + AC_COMPILE_IFELSE([AC_LANG_SOURCE([[int some_variable = 0;]])], + [am_ar_try='$AR cru libconftest.a conftest.$ac_objext >&AS_MESSAGE_LOG_FD' + AC_TRY_EVAL([am_ar_try]) + if test "$ac_status" -eq 0; then + am_cv_ar_interface=ar + else + am_ar_try='$AR -NOLOGO -OUT:conftest.lib conftest.$ac_objext >&AS_MESSAGE_LOG_FD' + AC_TRY_EVAL([am_ar_try]) + if test "$ac_status" -eq 0; then + am_cv_ar_interface=lib + else + am_cv_ar_interface=unknown + fi + fi + rm -f conftest.lib libconftest.a + ]) + ]) + +case $am_cv_ar_interface in +ar) + ;; +lib) + # Microsoft lib, so override with the ar-lib wrapper script. + # FIXME: It is wrong to rewrite AR. + # But if we don't then we get into trouble of one sort or another. + # A longer-term fix would be to have automake use am__AR in this case, + # and then we could set am__AR="$am_aux_dir/ar-lib \$(AR)" or something + # similar. + AR="$am_aux_dir/ar-lib $AR" + ;; +unknown) + m4_default([$1], + [AC_MSG_ERROR([could not determine $AR interface])]) + ;; +esac +AC_SUBST([AR])dnl +]) + +# AM_AUX_DIR_EXPAND -*- Autoconf -*- + +# Copyright (C) 2001-2012 Free Software Foundation, Inc. +# +# This file is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# For projects using AC_CONFIG_AUX_DIR([foo]), Autoconf sets +# $ac_aux_dir to '$srcdir/foo'. In other projects, it is set to +# '$srcdir', '$srcdir/..', or '$srcdir/../..'. +# +# Of course, Automake must honor this variable whenever it calls a +# tool from the auxiliary directory. The problem is that $srcdir (and +# therefore $ac_aux_dir as well) can be either absolute or relative, +# depending on how configure is run. This is pretty annoying, since +# it makes $ac_aux_dir quite unusable in subdirectories: in the top +# source directory, any form will work fine, but in subdirectories a +# relative path needs to be adjusted first. +# +# $ac_aux_dir/missing +# fails when called from a subdirectory if $ac_aux_dir is relative +# $top_srcdir/$ac_aux_dir/missing +# fails if $ac_aux_dir is absolute, +# fails when called from a subdirectory in a VPATH build with +# a relative $ac_aux_dir +# +# The reason of the latter failure is that $top_srcdir and $ac_aux_dir +# are both prefixed by $srcdir. In an in-source build this is usually +# harmless because $srcdir is '.', but things will broke when you +# start a VPATH build or use an absolute $srcdir. +# +# So we could use something similar to $top_srcdir/$ac_aux_dir/missing, +# iff we strip the leading $srcdir from $ac_aux_dir. That would be: +# am_aux_dir='\$(top_srcdir)/'`expr "$ac_aux_dir" : "$srcdir//*\(.*\)"` +# and then we would define $MISSING as +# MISSING="\${SHELL} $am_aux_dir/missing" +# This will work as long as MISSING is not called from configure, because +# unfortunately $(top_srcdir) has no meaning in configure. +# However there are other variables, like CC, which are often used in +# configure, and could therefore not use this "fixed" $ac_aux_dir. +# +# Another solution, used here, is to always expand $ac_aux_dir to an +# absolute PATH. The drawback is that using absolute paths prevent a +# configured tree to be moved without reconfiguration. + +AC_DEFUN([AM_AUX_DIR_EXPAND], +[dnl Rely on autoconf to set up CDPATH properly. +AC_PREREQ([2.50])dnl +# expand $ac_aux_dir to an absolute path +am_aux_dir=`cd $ac_aux_dir && pwd` +]) + +# AM_CONDITIONAL -*- Autoconf -*- + +# Copyright (C) 1997-2012 Free Software Foundation, Inc. +# +# This file is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# AM_CONDITIONAL(NAME, SHELL-CONDITION) +# ------------------------------------- +# Define a conditional. +AC_DEFUN([AM_CONDITIONAL], +[AC_PREREQ([2.52])dnl + m4_if([$1], [TRUE], [AC_FATAL([$0: invalid condition: $1])], + [$1], [FALSE], [AC_FATAL([$0: invalid condition: $1])])dnl +AC_SUBST([$1_TRUE])dnl +AC_SUBST([$1_FALSE])dnl +_AM_SUBST_NOTMAKE([$1_TRUE])dnl +_AM_SUBST_NOTMAKE([$1_FALSE])dnl +m4_define([_AM_COND_VALUE_$1], [$2])dnl +if $2; then + $1_TRUE= + $1_FALSE='#' +else + $1_TRUE='#' + $1_FALSE= +fi +AC_CONFIG_COMMANDS_PRE( +[if test -z "${$1_TRUE}" && test -z "${$1_FALSE}"; then + AC_MSG_ERROR([[conditional "$1" was never defined. +Usually this means the macro was only invoked conditionally.]]) +fi])]) + +# Copyright (C) 1999-2012 Free Software Foundation, Inc. +# +# This file is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + + +# There are a few dirty hacks below to avoid letting 'AC_PROG_CC' be +# written in clear, in which case automake, when reading aclocal.m4, +# will think it sees a *use*, and therefore will trigger all it's +# C support machinery. Also note that it means that autoscan, seeing +# CC etc. in the Makefile, will ask for an AC_PROG_CC use... + + +# _AM_DEPENDENCIES(NAME) +# ---------------------- +# See how the compiler implements dependency checking. +# NAME is "CC", "CXX", "OBJC", "OBJCXX", "UPC", or "GJC". +# We try a few techniques and use that to set a single cache variable. +# +# We don't AC_REQUIRE the corresponding AC_PROG_CC since the latter was +# modified to invoke _AM_DEPENDENCIES(CC); we would have a circular +# dependency, and given that the user is not expected to run this macro, +# just rely on AC_PROG_CC. +AC_DEFUN([_AM_DEPENDENCIES], +[AC_REQUIRE([AM_SET_DEPDIR])dnl +AC_REQUIRE([AM_OUTPUT_DEPENDENCY_COMMANDS])dnl +AC_REQUIRE([AM_MAKE_INCLUDE])dnl +AC_REQUIRE([AM_DEP_TRACK])dnl + +m4_if([$1], [CC], [depcc="$CC" am_compiler_list=], + [$1], [CXX], [depcc="$CXX" am_compiler_list=], + [$1], [OBJC], [depcc="$OBJC" am_compiler_list='gcc3 gcc'], + [$1], [OBJCXX], [depcc="$OBJCXX" am_compiler_list='gcc3 gcc'], + [$1], [UPC], [depcc="$UPC" am_compiler_list=], + [$1], [GCJ], [depcc="$GCJ" am_compiler_list='gcc3 gcc'], + [depcc="$$1" am_compiler_list=]) + +AC_CACHE_CHECK([dependency style of $depcc], + [am_cv_$1_dependencies_compiler_type], +[if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then + # We make a subdir and do the tests there. Otherwise we can end up + # making bogus files that we don't know about and never remove. For + # instance it was reported that on HP-UX the gcc test will end up + # making a dummy file named 'D' -- because '-MD' means "put the output + # in D". + rm -rf conftest.dir + mkdir conftest.dir + # Copy depcomp to subdir because otherwise we won't find it if we're + # using a relative directory. + cp "$am_depcomp" conftest.dir + cd conftest.dir + # We will build objects and dependencies in a subdirectory because + # it helps to detect inapplicable dependency modes. For instance + # both Tru64's cc and ICC support -MD to output dependencies as a + # side effect of compilation, but ICC will put the dependencies in + # the current directory while Tru64 will put them in the object + # directory. + mkdir sub + + am_cv_$1_dependencies_compiler_type=none + if test "$am_compiler_list" = ""; then + am_compiler_list=`sed -n ['s/^#*\([a-zA-Z0-9]*\))$/\1/p'] < ./depcomp` + fi + am__universal=false + m4_case([$1], [CC], + [case " $depcc " in #( + *\ -arch\ *\ -arch\ *) am__universal=true ;; + esac], + [CXX], + [case " $depcc " in #( + *\ -arch\ *\ -arch\ *) am__universal=true ;; + esac]) + + for depmode in $am_compiler_list; do + # Setup a source with many dependencies, because some compilers + # like to wrap large dependency lists on column 80 (with \), and + # we should not choose a depcomp mode which is confused by this. + # + # We need to recreate these files for each test, as the compiler may + # overwrite some of them when testing with obscure command lines. + # This happens at least with the AIX C compiler. + : > sub/conftest.c + for i in 1 2 3 4 5 6; do + echo '#include "conftst'$i'.h"' >> sub/conftest.c + # Using ": > sub/conftst$i.h" creates only sub/conftst1.h with + # Solaris 10 /bin/sh. + echo '/* dummy */' > sub/conftst$i.h + done + echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf + + # We check with '-c' and '-o' for the sake of the "dashmstdout" + # mode. It turns out that the SunPro C++ compiler does not properly + # handle '-M -o', and we need to detect this. Also, some Intel + # versions had trouble with output in subdirs. + am__obj=sub/conftest.${OBJEXT-o} + am__minus_obj="-o $am__obj" + case $depmode in + gcc) + # This depmode causes a compiler race in universal mode. + test "$am__universal" = false || continue + ;; + nosideeffect) + # After this tag, mechanisms are not by side-effect, so they'll + # only be used when explicitly requested. + if test "x$enable_dependency_tracking" = xyes; then + continue + else + break + fi + ;; + msvc7 | msvc7msys | msvisualcpp | msvcmsys) + # This compiler won't grok '-c -o', but also, the minuso test has + # not run yet. These depmodes are late enough in the game, and + # so weak that their functioning should not be impacted. + am__obj=conftest.${OBJEXT-o} + am__minus_obj= + ;; + none) break ;; + esac + if depmode=$depmode \ + source=sub/conftest.c object=$am__obj \ + depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \ + $SHELL ./depcomp $depcc -c $am__minus_obj sub/conftest.c \ + >/dev/null 2>conftest.err && + grep sub/conftst1.h sub/conftest.Po > /dev/null 2>&1 && + grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 && + grep $am__obj sub/conftest.Po > /dev/null 2>&1 && + ${MAKE-make} -s -f confmf > /dev/null 2>&1; then + # icc doesn't choke on unknown options, it will just issue warnings + # or remarks (even with -Werror). So we grep stderr for any message + # that says an option was ignored or not supported. + # When given -MP, icc 7.0 and 7.1 complain thusly: + # icc: Command line warning: ignoring option '-M'; no argument required + # The diagnosis changed in icc 8.0: + # icc: Command line remark: option '-MP' not supported + if (grep 'ignoring option' conftest.err || + grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else + am_cv_$1_dependencies_compiler_type=$depmode + break + fi + fi + done + + cd .. + rm -rf conftest.dir +else + am_cv_$1_dependencies_compiler_type=none +fi +]) +AC_SUBST([$1DEPMODE], [depmode=$am_cv_$1_dependencies_compiler_type]) +AM_CONDITIONAL([am__fastdep$1], [ + test "x$enable_dependency_tracking" != xno \ + && test "$am_cv_$1_dependencies_compiler_type" = gcc3]) +]) + + +# AM_SET_DEPDIR +# ------------- +# Choose a directory name for dependency files. +# This macro is AC_REQUIREd in _AM_DEPENDENCIES. +AC_DEFUN([AM_SET_DEPDIR], +[AC_REQUIRE([AM_SET_LEADING_DOT])dnl +AC_SUBST([DEPDIR], ["${am__leading_dot}deps"])dnl +]) + + +# AM_DEP_TRACK +# ------------ +AC_DEFUN([AM_DEP_TRACK], +[AC_ARG_ENABLE([dependency-tracking], [dnl +AS_HELP_STRING( + [--enable-dependency-tracking], + [do not reject slow dependency extractors]) +AS_HELP_STRING( + [--disable-dependency-tracking], + [speeds up one-time build])]) +if test "x$enable_dependency_tracking" != xno; then + am_depcomp="$ac_aux_dir/depcomp" + AMDEPBACKSLASH='\' + am__nodep='_no' +fi +AM_CONDITIONAL([AMDEP], [test "x$enable_dependency_tracking" != xno]) +AC_SUBST([AMDEPBACKSLASH])dnl +_AM_SUBST_NOTMAKE([AMDEPBACKSLASH])dnl +AC_SUBST([am__nodep])dnl +_AM_SUBST_NOTMAKE([am__nodep])dnl +]) + +# Generate code to set up dependency tracking. -*- Autoconf -*- + +# Copyright (C) 1999-2012 Free Software Foundation, Inc. +# +# This file is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + + +# _AM_OUTPUT_DEPENDENCY_COMMANDS +# ------------------------------ +AC_DEFUN([_AM_OUTPUT_DEPENDENCY_COMMANDS], +[{ + # Autoconf 2.62 quotes --file arguments for eval, but not when files + # are listed without --file. Let's play safe and only enable the eval + # if we detect the quoting. + case $CONFIG_FILES in + *\'*) eval set x "$CONFIG_FILES" ;; + *) set x $CONFIG_FILES ;; + esac + shift + for mf + do + # Strip MF so we end up with the name of the file. + mf=`echo "$mf" | sed -e 's/:.*$//'` + # Check whether this is an Automake generated Makefile or not. + # We used to match only the files named 'Makefile.in', but + # some people rename them; so instead we look at the file content. + # Grep'ing the first line is not enough: some people post-process + # each Makefile.in and add a new line on top of each file to say so. + # Grep'ing the whole file is not good either: AIX grep has a line + # limit of 2048, but all sed's we know have understand at least 4000. + if sed -n 's,^#.*generated by automake.*,X,p' "$mf" | grep X >/dev/null 2>&1; then + dirpart=`AS_DIRNAME("$mf")` + else + continue + fi + # Extract the definition of DEPDIR, am__include, and am__quote + # from the Makefile without running 'make'. + DEPDIR=`sed -n 's/^DEPDIR = //p' < "$mf"` + test -z "$DEPDIR" && continue + am__include=`sed -n 's/^am__include = //p' < "$mf"` + test -z "am__include" && continue + am__quote=`sed -n 's/^am__quote = //p' < "$mf"` + # Find all dependency output files, they are included files with + # $(DEPDIR) in their names. We invoke sed twice because it is the + # simplest approach to changing $(DEPDIR) to its actual value in the + # expansion. + for file in `sed -n " + s/^$am__include $am__quote\(.*(DEPDIR).*\)$am__quote"'$/\1/p' <"$mf" | \ + sed -e 's/\$(DEPDIR)/'"$DEPDIR"'/g'`; do + # Make sure the directory exists. + test -f "$dirpart/$file" && continue + fdir=`AS_DIRNAME(["$file"])` + AS_MKDIR_P([$dirpart/$fdir]) + # echo "creating $dirpart/$file" + echo '# dummy' > "$dirpart/$file" + done + done +} +])# _AM_OUTPUT_DEPENDENCY_COMMANDS + + +# AM_OUTPUT_DEPENDENCY_COMMANDS +# ----------------------------- +# This macro should only be invoked once -- use via AC_REQUIRE. +# +# This code is only required when automatic dependency tracking +# is enabled. FIXME. This creates each '.P' file that we will +# need in order to bootstrap the dependency handling code. +AC_DEFUN([AM_OUTPUT_DEPENDENCY_COMMANDS], +[AC_CONFIG_COMMANDS([depfiles], + [test x"$AMDEP_TRUE" != x"" || _AM_OUTPUT_DEPENDENCY_COMMANDS], + [AMDEP_TRUE="$AMDEP_TRUE" ac_aux_dir="$ac_aux_dir"]) +]) + +# Do all the work for Automake. -*- Autoconf -*- + +# Copyright (C) 1996-2012 Free Software Foundation, Inc. +# +# This file is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# This macro actually does too much. Some checks are only needed if +# your package does certain things. But this isn't really a big deal. + +# AM_INIT_AUTOMAKE(PACKAGE, VERSION, [NO-DEFINE]) +# AM_INIT_AUTOMAKE([OPTIONS]) +# ----------------------------------------------- +# The call with PACKAGE and VERSION arguments is the old style +# call (pre autoconf-2.50), which is being phased out. PACKAGE +# and VERSION should now be passed to AC_INIT and removed from +# the call to AM_INIT_AUTOMAKE. +# We support both call styles for the transition. After +# the next Automake release, Autoconf can make the AC_INIT +# arguments mandatory, and then we can depend on a new Autoconf +# release and drop the old call support. +AC_DEFUN([AM_INIT_AUTOMAKE], +[AC_PREREQ([2.62])dnl +dnl Autoconf wants to disallow AM_ names. We explicitly allow +dnl the ones we care about. +m4_pattern_allow([^AM_[A-Z]+FLAGS$])dnl +AC_REQUIRE([AM_SET_CURRENT_AUTOMAKE_VERSION])dnl +AC_REQUIRE([AC_PROG_INSTALL])dnl +if test "`cd $srcdir && pwd`" != "`pwd`"; then + # Use -I$(srcdir) only when $(srcdir) != ., so that make's output + # is not polluted with repeated "-I." + AC_SUBST([am__isrc], [' -I$(srcdir)'])_AM_SUBST_NOTMAKE([am__isrc])dnl + # test to see if srcdir already configured + if test -f $srcdir/config.status; then + AC_MSG_ERROR([source directory already configured; run "make distclean" there first]) + fi +fi + +# test whether we have cygpath +if test -z "$CYGPATH_W"; then + if (cygpath --version) >/dev/null 2>/dev/null; then + CYGPATH_W='cygpath -w' + else + CYGPATH_W=echo + fi +fi +AC_SUBST([CYGPATH_W]) + +# Define the identity of the package. +dnl Distinguish between old-style and new-style calls. +m4_ifval([$2], +[AC_DIAGNOSE([obsolete], +[$0: two- and three-arguments forms are deprecated. For more info, see: +http://www.gnu.org/software/automake/manual/automake.html#Modernize-AM_INIT_AUTOMAKE-invocation]) +m4_ifval([$3], [_AM_SET_OPTION([no-define])])dnl + AC_SUBST([PACKAGE], [$1])dnl + AC_SUBST([VERSION], [$2])], +[_AM_SET_OPTIONS([$1])dnl +dnl Diagnose old-style AC_INIT with new-style AM_AUTOMAKE_INIT. +m4_if( + m4_ifdef([AC_PACKAGE_NAME], [ok]):m4_ifdef([AC_PACKAGE_VERSION], [ok]), + [ok:ok],, + [m4_fatal([AC_INIT should be called with package and version arguments])])dnl + AC_SUBST([PACKAGE], ['AC_PACKAGE_TARNAME'])dnl + AC_SUBST([VERSION], ['AC_PACKAGE_VERSION'])])dnl + +_AM_IF_OPTION([no-define],, +[AC_DEFINE_UNQUOTED([PACKAGE], ["$PACKAGE"], [Name of package]) + AC_DEFINE_UNQUOTED([VERSION], ["$VERSION"], [Version number of package])])dnl + +# Some tools Automake needs. +AC_REQUIRE([AM_SANITY_CHECK])dnl +AC_REQUIRE([AC_ARG_PROGRAM])dnl +AM_MISSING_PROG([ACLOCAL], [aclocal-${am__api_version}]) +AM_MISSING_PROG([AUTOCONF], [autoconf]) +AM_MISSING_PROG([AUTOMAKE], [automake-${am__api_version}]) +AM_MISSING_PROG([AUTOHEADER], [autoheader]) +AM_MISSING_PROG([MAKEINFO], [makeinfo]) +AC_REQUIRE([AM_PROG_INSTALL_SH])dnl +AC_REQUIRE([AM_PROG_INSTALL_STRIP])dnl +AC_REQUIRE([AC_PROG_MKDIR_P])dnl +# For better backward compatibility. To be removed once Automake 1.9.x +# dies out for good. For more background, see: +# +# +AC_SUBST([mkdir_p], ['$(MKDIR_P)']) +# We need awk for the "check" target. The system "awk" is bad on +# some platforms. +AC_REQUIRE([AC_PROG_AWK])dnl +AC_REQUIRE([AC_PROG_MAKE_SET])dnl +AC_REQUIRE([AM_SET_LEADING_DOT])dnl +_AM_IF_OPTION([tar-ustar], [_AM_PROG_TAR([ustar])], + [_AM_IF_OPTION([tar-pax], [_AM_PROG_TAR([pax])], + [_AM_PROG_TAR([v7])])]) +_AM_IF_OPTION([no-dependencies],, +[AC_PROVIDE_IFELSE([AC_PROG_CC], + [_AM_DEPENDENCIES([CC])], + [m4_define([AC_PROG_CC], + m4_defn([AC_PROG_CC])[_AM_DEPENDENCIES([CC])])])dnl +AC_PROVIDE_IFELSE([AC_PROG_CXX], + [_AM_DEPENDENCIES([CXX])], + [m4_define([AC_PROG_CXX], + m4_defn([AC_PROG_CXX])[_AM_DEPENDENCIES([CXX])])])dnl +AC_PROVIDE_IFELSE([AC_PROG_OBJC], + [_AM_DEPENDENCIES([OBJC])], + [m4_define([AC_PROG_OBJC], + m4_defn([AC_PROG_OBJC])[_AM_DEPENDENCIES([OBJC])])])dnl +dnl Support for Objective C++ was only introduced in Autoconf 2.65, +dnl but we still cater to Autoconf 2.62. +m4_ifdef([AC_PROG_OBJCXX], +[AC_PROVIDE_IFELSE([AC_PROG_OBJCXX], + [_AM_DEPENDENCIES([OBJCXX])], + [m4_define([AC_PROG_OBJCXX], + m4_defn([AC_PROG_OBJCXX])[_AM_DEPENDENCIES([OBJCXX])])])])dnl +]) +_AM_IF_OPTION([silent-rules], [AC_REQUIRE([AM_SILENT_RULES])])dnl +dnl The 'parallel-tests' driver may need to know about EXEEXT, so add the +dnl 'am__EXEEXT' conditional if _AM_COMPILER_EXEEXT was seen. This macro +dnl is hooked onto _AC_COMPILER_EXEEXT early, see below. +AC_CONFIG_COMMANDS_PRE(dnl +[m4_provide_if([_AM_COMPILER_EXEEXT], + [AM_CONDITIONAL([am__EXEEXT], [test -n "$EXEEXT"])])])dnl +]) + +dnl Hook into '_AC_COMPILER_EXEEXT' early to learn its expansion. Do not +dnl add the conditional right here, as _AC_COMPILER_EXEEXT may be further +dnl mangled by Autoconf and run in a shell conditional statement. +m4_define([_AC_COMPILER_EXEEXT], +m4_defn([_AC_COMPILER_EXEEXT])[m4_provide([_AM_COMPILER_EXEEXT])]) + + +# When config.status generates a header, we must update the stamp-h file. +# This file resides in the same directory as the config header +# that is generated. The stamp files are numbered to have different names. + +# Autoconf calls _AC_AM_CONFIG_HEADER_HOOK (when defined) in the +# loop where config.status creates the headers, so we can generate +# our stamp files there. +AC_DEFUN([_AC_AM_CONFIG_HEADER_HOOK], +[# Compute $1's index in $config_headers. +_am_arg=$1 +_am_stamp_count=1 +for _am_header in $config_headers :; do + case $_am_header in + $_am_arg | $_am_arg:* ) + break ;; + * ) + _am_stamp_count=`expr $_am_stamp_count + 1` ;; + esac +done +echo "timestamp for $_am_arg" >`AS_DIRNAME(["$_am_arg"])`/stamp-h[]$_am_stamp_count]) + +# Copyright (C) 2001-2012 Free Software Foundation, Inc. +# +# This file is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# AM_PROG_INSTALL_SH +# ------------------ +# Define $install_sh. +AC_DEFUN([AM_PROG_INSTALL_SH], +[AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl +if test x"${install_sh}" != xset; then + case $am_aux_dir in + *\ * | *\ *) + install_sh="\${SHELL} '$am_aux_dir/install-sh'" ;; + *) + install_sh="\${SHELL} $am_aux_dir/install-sh" + esac +fi +AC_SUBST([install_sh])]) + +# Copyright (C) 2003-2012 Free Software Foundation, Inc. +# +# This file is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# Check whether the underlying file-system supports filenames +# with a leading dot. For instance MS-DOS doesn't. +AC_DEFUN([AM_SET_LEADING_DOT], +[rm -rf .tst 2>/dev/null +mkdir .tst 2>/dev/null +if test -d .tst; then + am__leading_dot=. +else + am__leading_dot=_ +fi +rmdir .tst 2>/dev/null +AC_SUBST([am__leading_dot])]) + +# Check to see how 'make' treats includes. -*- Autoconf -*- + +# Copyright (C) 2001-2012 Free Software Foundation, Inc. +# +# This file is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# AM_MAKE_INCLUDE() +# ----------------- +# Check to see how make treats includes. +AC_DEFUN([AM_MAKE_INCLUDE], +[am_make=${MAKE-make} +cat > confinc << 'END' +am__doit: + @echo this is the am__doit target +.PHONY: am__doit +END +# If we don't find an include directive, just comment out the code. +AC_MSG_CHECKING([for style of include used by $am_make]) +am__include="#" +am__quote= +_am_result=none +# First try GNU make style include. +echo "include confinc" > confmf +# Ignore all kinds of additional output from 'make'. +case `$am_make -s -f confmf 2> /dev/null` in #( +*the\ am__doit\ target*) + am__include=include + am__quote= + _am_result=GNU + ;; +esac +# Now try BSD make style include. +if test "$am__include" = "#"; then + echo '.include "confinc"' > confmf + case `$am_make -s -f confmf 2> /dev/null` in #( + *the\ am__doit\ target*) + am__include=.include + am__quote="\"" + _am_result=BSD + ;; + esac +fi +AC_SUBST([am__include]) +AC_SUBST([am__quote]) +AC_MSG_RESULT([$_am_result]) +rm -f confinc confmf +]) + +# Fake the existence of programs that GNU maintainers use. -*- Autoconf -*- + +# Copyright (C) 1997-2012 Free Software Foundation, Inc. +# +# This file is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# AM_MISSING_PROG(NAME, PROGRAM) +# ------------------------------ +AC_DEFUN([AM_MISSING_PROG], +[AC_REQUIRE([AM_MISSING_HAS_RUN]) +$1=${$1-"${am_missing_run}$2"} +AC_SUBST($1)]) + +# AM_MISSING_HAS_RUN +# ------------------ +# Define MISSING if not defined so far and test if it supports --run. +# If it does, set am_missing_run to use it, otherwise, to nothing. +AC_DEFUN([AM_MISSING_HAS_RUN], +[AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl +AC_REQUIRE_AUX_FILE([missing])dnl +if test x"${MISSING+set}" != xset; then + case $am_aux_dir in + *\ * | *\ *) + MISSING="\${SHELL} \"$am_aux_dir/missing\"" ;; + *) + MISSING="\${SHELL} $am_aux_dir/missing" ;; + esac +fi +# Use eval to expand $SHELL +if eval "$MISSING --run true"; then + am_missing_run="$MISSING --run " +else + am_missing_run= + AC_MSG_WARN(['missing' script is too old or missing]) +fi +]) + +# Helper functions for option handling. -*- Autoconf -*- + +# Copyright (C) 2001-2012 Free Software Foundation, Inc. +# +# This file is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# _AM_MANGLE_OPTION(NAME) +# ----------------------- +AC_DEFUN([_AM_MANGLE_OPTION], +[[_AM_OPTION_]m4_bpatsubst($1, [[^a-zA-Z0-9_]], [_])]) + +# _AM_SET_OPTION(NAME) +# -------------------- +# Set option NAME. Presently that only means defining a flag for this option. +AC_DEFUN([_AM_SET_OPTION], +[m4_define(_AM_MANGLE_OPTION([$1]), [1])]) + +# _AM_SET_OPTIONS(OPTIONS) +# ------------------------ +# OPTIONS is a space-separated list of Automake options. +AC_DEFUN([_AM_SET_OPTIONS], +[m4_foreach_w([_AM_Option], [$1], [_AM_SET_OPTION(_AM_Option)])]) + +# _AM_IF_OPTION(OPTION, IF-SET, [IF-NOT-SET]) +# ------------------------------------------- +# Execute IF-SET if OPTION is set, IF-NOT-SET otherwise. +AC_DEFUN([_AM_IF_OPTION], +[m4_ifset(_AM_MANGLE_OPTION([$1]), [$2], [$3])]) + +# Copyright (C) 2001-2012 Free Software Foundation, Inc. +# +# This file is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# AM_RUN_LOG(COMMAND) +# ------------------- +# Run COMMAND, save the exit status in ac_status, and log it. +# (This has been adapted from Autoconf's _AC_RUN_LOG macro.) +AC_DEFUN([AM_RUN_LOG], +[{ echo "$as_me:$LINENO: $1" >&AS_MESSAGE_LOG_FD + ($1) >&AS_MESSAGE_LOG_FD 2>&AS_MESSAGE_LOG_FD + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&AS_MESSAGE_LOG_FD + (exit $ac_status); }]) + +# Check to make sure that the build environment is sane. -*- Autoconf -*- + +# Copyright (C) 1996-2012 Free Software Foundation, Inc. +# +# This file is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# AM_SANITY_CHECK +# --------------- +AC_DEFUN([AM_SANITY_CHECK], +[AC_MSG_CHECKING([whether build environment is sane]) +# Reject unsafe characters in $srcdir or the absolute working directory +# name. Accept space and tab only in the latter. +am_lf=' +' +case `pwd` in + *[[\\\"\#\$\&\'\`$am_lf]]*) + AC_MSG_ERROR([unsafe absolute working directory name]);; +esac +case $srcdir in + *[[\\\"\#\$\&\'\`$am_lf\ \ ]]*) + AC_MSG_ERROR([unsafe srcdir value: '$srcdir']);; +esac + +# Do 'set' in a subshell so we don't clobber the current shell's +# arguments. Must try -L first in case configure is actually a +# symlink; some systems play weird games with the mod time of symlinks +# (eg FreeBSD returns the mod time of the symlink's containing +# directory). +if ( + am_has_slept=no + for am_try in 1 2; do + echo "timestamp, slept: $am_has_slept" > conftest.file + set X `ls -Lt "$srcdir/configure" conftest.file 2> /dev/null` + if test "$[*]" = "X"; then + # -L didn't work. + set X `ls -t "$srcdir/configure" conftest.file` + fi + if test "$[*]" != "X $srcdir/configure conftest.file" \ + && test "$[*]" != "X conftest.file $srcdir/configure"; then + + # If neither matched, then we have a broken ls. This can happen + # if, for instance, CONFIG_SHELL is bash and it inherits a + # broken ls alias from the environment. This has actually + # happened. Such a system could not be considered "sane". + AC_MSG_ERROR([ls -t appears to fail. Make sure there is not a broken + alias in your environment]) + fi + if test "$[2]" = conftest.file || test $am_try -eq 2; then + break + fi + # Just in case. + sleep 1 + am_has_slept=yes + done + test "$[2]" = conftest.file + ) +then + # Ok. + : +else + AC_MSG_ERROR([newly created file is older than distributed files! +Check your system clock]) +fi +AC_MSG_RESULT([yes]) +# If we didn't sleep, we still need to ensure time stamps of config.status and +# generated files are strictly newer. +am_sleep_pid= +if grep 'slept: no' conftest.file >/dev/null 2>&1; then + ( sleep 1 ) & + am_sleep_pid=$! +fi +AC_CONFIG_COMMANDS_PRE( + [AC_MSG_CHECKING([that generated files are newer than configure]) + if test -n "$am_sleep_pid"; then + # Hide warnings about reused PIDs. + wait $am_sleep_pid 2>/dev/null + fi + AC_MSG_RESULT([done])]) +rm -f conftest.file +]) + +# Copyright (C) 2001-2012 Free Software Foundation, Inc. +# +# This file is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# AM_PROG_INSTALL_STRIP +# --------------------- +# One issue with vendor 'install' (even GNU) is that you can't +# specify the program used to strip binaries. This is especially +# annoying in cross-compiling environments, where the build's strip +# is unlikely to handle the host's binaries. +# Fortunately install-sh will honor a STRIPPROG variable, so we +# always use install-sh in "make install-strip", and initialize +# STRIPPROG with the value of the STRIP variable (set by the user). +AC_DEFUN([AM_PROG_INSTALL_STRIP], +[AC_REQUIRE([AM_PROG_INSTALL_SH])dnl +# Installed binaries are usually stripped using 'strip' when the user +# run "make install-strip". However 'strip' might not be the right +# tool to use in cross-compilation environments, therefore Automake +# will honor the 'STRIP' environment variable to overrule this program. +dnl Don't test for $cross_compiling = yes, because it might be 'maybe'. +if test "$cross_compiling" != no; then + AC_CHECK_TOOL([STRIP], [strip], :) +fi +INSTALL_STRIP_PROGRAM="\$(install_sh) -c -s" +AC_SUBST([INSTALL_STRIP_PROGRAM])]) + +# Copyright (C) 2006-2012 Free Software Foundation, Inc. +# +# This file is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# _AM_SUBST_NOTMAKE(VARIABLE) +# --------------------------- +# Prevent Automake from outputting VARIABLE = @VARIABLE@ in Makefile.in. +# This macro is traced by Automake. +AC_DEFUN([_AM_SUBST_NOTMAKE]) + +# AM_SUBST_NOTMAKE(VARIABLE) +# -------------------------- +# Public sister of _AM_SUBST_NOTMAKE. +AC_DEFUN([AM_SUBST_NOTMAKE], [_AM_SUBST_NOTMAKE($@)]) + +# Check how to create a tarball. -*- Autoconf -*- + +# Copyright (C) 2004-2012 Free Software Foundation, Inc. +# +# This file is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# _AM_PROG_TAR(FORMAT) +# -------------------- +# Check how to create a tarball in format FORMAT. +# FORMAT should be one of 'v7', 'ustar', or 'pax'. +# +# Substitute a variable $(am__tar) that is a command +# writing to stdout a FORMAT-tarball containing the directory +# $tardir. +# tardir=directory && $(am__tar) > result.tar +# +# Substitute a variable $(am__untar) that extract such +# a tarball read from stdin. +# $(am__untar) < result.tar +AC_DEFUN([_AM_PROG_TAR], +[# Always define AMTAR for backward compatibility. Yes, it's still used +# in the wild :-( We should find a proper way to deprecate it ... +AC_SUBST([AMTAR], ['$${TAR-tar}']) +m4_if([$1], [v7], + [am__tar='$${TAR-tar} chof - "$$tardir"' am__untar='$${TAR-tar} xf -'], + [m4_case([$1], [ustar],, [pax],, + [m4_fatal([Unknown tar format])]) +AC_MSG_CHECKING([how to create a $1 tar archive]) +# Loop over all known methods to create a tar archive until one works. +_am_tools='gnutar m4_if([$1], [ustar], [plaintar]) pax cpio none' +_am_tools=${am_cv_prog_tar_$1-$_am_tools} +# Do not fold the above two line into one, because Tru64 sh and +# Solaris sh will not grok spaces in the rhs of '-'. +for _am_tool in $_am_tools +do + case $_am_tool in + gnutar) + for _am_tar in tar gnutar gtar; + do + AM_RUN_LOG([$_am_tar --version]) && break + done + am__tar="$_am_tar --format=m4_if([$1], [pax], [posix], [$1]) -chf - "'"$$tardir"' + am__tar_="$_am_tar --format=m4_if([$1], [pax], [posix], [$1]) -chf - "'"$tardir"' + am__untar="$_am_tar -xf -" + ;; + plaintar) + # Must skip GNU tar: if it does not support --format= it doesn't create + # ustar tarball either. + (tar --version) >/dev/null 2>&1 && continue + am__tar='tar chf - "$$tardir"' + am__tar_='tar chf - "$tardir"' + am__untar='tar xf -' + ;; + pax) + am__tar='pax -L -x $1 -w "$$tardir"' + am__tar_='pax -L -x $1 -w "$tardir"' + am__untar='pax -r' + ;; + cpio) + am__tar='find "$$tardir" -print | cpio -o -H $1 -L' + am__tar_='find "$tardir" -print | cpio -o -H $1 -L' + am__untar='cpio -i -H $1 -d' + ;; + none) + am__tar=false + am__tar_=false + am__untar=false + ;; + esac + + # If the value was cached, stop now. We just wanted to have am__tar + # and am__untar set. + test -n "${am_cv_prog_tar_$1}" && break + + # tar/untar a dummy directory, and stop if the command works + rm -rf conftest.dir + mkdir conftest.dir + echo GrepMe > conftest.dir/file + AM_RUN_LOG([tardir=conftest.dir && eval $am__tar_ >conftest.tar]) + rm -rf conftest.dir + if test -s conftest.tar; then + AM_RUN_LOG([$am__untar /dev/null 2>&1 && break + fi +done +rm -rf conftest.dir + +AC_CACHE_VAL([am_cv_prog_tar_$1], [am_cv_prog_tar_$1=$_am_tool]) +AC_MSG_RESULT([$am_cv_prog_tar_$1])]) +AC_SUBST([am__tar]) +AC_SUBST([am__untar]) +]) # _AM_PROG_TAR + +m4_include([m4/acx-pthread.m4]) +m4_include([m4/disable-rpath.m4]) +m4_include([m4/libodb.m4]) +m4_include([m4/libsqlite.m4]) +m4_include([m4/libtool-link.m4]) +m4_include([m4/libtool.m4]) +m4_include([m4/ltoptions.m4]) +m4_include([m4/ltsugar.m4]) +m4_include([m4/ltversion.m4]) +m4_include([m4/lt~obsolete.m4]) +m4_include([m4/pkgconfig.m4]) +m4_include([m4/static-lib.m4]) +m4_include([m4/threads.m4]) diff --git a/third-party/odb/libodb-sqlite-2.4.0/bootstrap b/third-party/odb/libodb-sqlite-2.4.0/bootstrap new file mode 100755 index 0000000..8953df9 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/bootstrap @@ -0,0 +1,17 @@ +#! /bin/sh + +# file : bootstrap +# copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +# license : GNU GPL v2; see accompanying LICENSE file + +# +# Bootstrap the automake build system. +# + +rm -f config.cache + +if test ! -d m4; then + mkdir m4 +fi + +autoreconf --install diff --git a/third-party/odb/libodb-sqlite-2.4.0/config.log b/third-party/odb/libodb-sqlite-2.4.0/config.log new file mode 100755 index 0000000..4813681 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/config.log @@ -0,0 +1,994 @@ +This file contains any messages produced by compilers while +running configure, to aid debugging if configure makes a mistake. + +It was created by libodb-sqlite configure 2.4.0, which was +generated by GNU Autoconf 2.69. Invocation command line was + + $ ./configure + +## --------- ## +## Platform. ## +## --------- ## + +hostname = matthiasPC +uname -m = x86_64 +uname -r = 3.17.1-52.g5c4d099-desktop +uname -s = Linux +uname -v = #1 SMP PREEMPT Sat Oct 18 23:36:23 UTC 2014 (5c4d099) + +/usr/bin/uname -p = x86_64 +/bin/uname -X = unknown + +/bin/arch = x86_64 +/usr/bin/arch -k = unknown +/usr/convex/getsysinfo = unknown +/usr/bin/hostinfo = unknown +/bin/machine = unknown +/usr/bin/oslevel = unknown +/bin/universe = unknown + +PATH: /sbin/ +PATH: /home/matthias/bin/ +PATH: /opt/globus/bin/ +PATH: /home/matthias/bin/ec2-api-tools/bin/ +PATH: /home/matthias/Development/Android/android-sdk-linux/tools +PATH: /home/matthias/Development/Android/android-sdk-linux/platform-tools +PATH: /sbin/ +PATH: /home/matthias/bin/ +PATH: /opt/globus/bin/ +PATH: /home/matthias/bin/ec2-api-tools/bin/ +PATH: /home/matthias/Development/Android/android-sdk-linux/tools +PATH: /home/matthias/Development/Android/android-sdk-linux/platform-tools +PATH: /usr/lib64/mpi/gcc/openmpi/bin +PATH: /home/matthias/bin +PATH: /usr/local/bin +PATH: /usr/bin +PATH: /bin +PATH: /usr/bin/X11 +PATH: /usr/X11R6/bin +PATH: /usr/games +PATH: /opt/kde3/bin +PATH: /usr/lib/mit/bin +PATH: . + + +## ----------- ## +## Core tests. ## +## ----------- ## + +configure:2161: loading site script /usr/share/site/x86_64-unknown-linux-gnu +| #!/bin/sh +| # Site script for configure. It is resourced via $CONFIG_SITE environment varaible. +| +| # If user did not specify libdir, guess the correct target: +| # Use lib64 for 64 bit bi-arch targets, keep the default for the rest. +| if test "$libdir" = '${exec_prefix}/lib' ; then +| +| ac_config_site_64bit_host=NONE +| +| case "$host" in +| "" ) +| # User did not specify host target. +| # The native platform x86_64 is a bi-arch platform. +| # Try to detect cross-compilation to inferior architecture. +| +| # We are trying to guess 32-bit target compilation. It's not as easy as +| # it sounds, as there is possible several intermediate combinations. +| ac_config_site_cross_to_32bit_host=NONE +| +| # User defined -m32 in CFLAGS or CXXFLAGS: +| # (It's sufficient for 32-bit, but alone may cause mis-behavior of some checks.) +| case "$CFLAGS" in +| *-m32*) +| ac_config_site_cross_to_32bit_host=YES +| ;; +| esac +| case "$CXXFLAGS" in +| *-m32*) +| ac_config_site_cross_to_32bit_host=YES +| ;; +| esac +| +| # Running with linux32: +| # (Changes detected platform, but not the toolchain target.) +| case "`/bin/uname -i`" in +| x86_64 | ppc64 | s390x ) +| ;; +| * ) +| ac_config_site_cross_to_32bit_host=YES +| ;; +| esac +| +| if test "x$ac_config_site_cross_to_32bit_host" = xNONE; then +| ac_config_site_64bit_host=YES +| fi +| +| ;; +| *x86_64* | *ppc64* | *s390x* ) +| ac_config_site_64bit_host=YES +| ;; +| esac +| +| if test "x$ac_config_site_64bit_host" = xYES; then +| libdir='${exec_prefix}/lib64' +| fi +| fi +| +| # If user did not specify libexecdir, set the correct target: +| # Nor FHS nor openSUSE allow prefix/libexec. Let's default to prefix/lib. +| +| if test "$libexecdir" = '${exec_prefix}/libexec' ; then +| libexecdir='${exec_prefix}/lib' +| fi +| +| # Continue with the standard behavior of configure defined in AC_SITE_LOAD: +| if test "x$prefix" != xNONE; then +| ac_site_file1=$prefix/share/config.site +| ac_site_file2=$prefix/etc/config.site +| else +| ac_site_file1=$ac_default_prefix/share/config.site +| ac_site_file2=$ac_default_prefix/etc/config.site +| fi +| for ac_site_file in "$ac_site_file1" "$ac_site_file2" +| do +| test "x$ac_site_file" = xNONE && continue +| if test /dev/null != "$ac_site_file" && test -r "$ac_site_file"; then +| { $as_echo "/usr/share/site/x86_64-unknown-linux-gnu:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5 +| $as_echo "/usr/share/site/x86_64-unknown-linux-gnu: loading site script $ac_site_file" >&6;} +| sed 's/^/| /' "$ac_site_file" >&5 +| . "$ac_site_file" \ +| || { { $as_echo "/usr/share/site/x86_64-unknown-linux-gnu:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 +| $as_echo "/usr/share/site/x86_64-unknown-linux-gnu: error: in \`$ac_pwd':" >&2;} +| as_fn_error $? "failed to load site script $ac_site_file +| See \`config.log' for more details" "$LINENO" 5; } +| fi +| done +configure:2305: checking for a BSD-compatible install +configure:2373: result: /usr/bin/install -c +configure:2384: checking whether build environment is sane +configure:2439: result: yes +configure:2590: checking for a thread-safe mkdir -p +configure:2629: result: /usr/bin/mkdir -p +configure:2636: checking for gawk +configure:2652: found /usr/bin/gawk +configure:2663: result: gawk +configure:2674: checking whether make sets $(MAKE) +configure:2696: result: yes +configure:2777: checking how to create a ustar tar archive +configure:2790: tar --version +tar (GNU tar) 1.26 +Copyright (C) 2011 Free Software Foundation, Inc. +License GPLv3+: GNU GPL version 3 or later . +This is free software: you are free to change and redistribute it. +There is NO WARRANTY, to the extent permitted by law. + +Written by John Gilmore and Jay Fenlason. +configure:2793: $? = 0 +configure:2833: tardir=conftest.dir && eval tar --format=ustar -chf - "$tardir" >conftest.tar +configure:2836: $? = 0 +configure:2840: tar -xf - &5 +gcc (SUSE Linux) 4.8.1 20130909 [gcc-4_8-branch revision 202388] +Copyright (C) 2013 Free Software Foundation, Inc. +This is free software; see the source for copying conditions. There is NO +warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + +configure:3250: $? = 0 +configure:3239: gcc -v >&5 +Using built-in specs. +COLLECT_GCC=gcc +COLLECT_LTO_WRAPPER=/usr/lib64/gcc/x86_64-suse-linux/4.8/lto-wrapper +Target: x86_64-suse-linux +Configured with: ../configure --prefix=/usr --infodir=/usr/share/info --mandir=/usr/share/man --libdir=/usr/lib64 --libexecdir=/usr/lib64 --enable-languages=c,c++,objc,fortran,obj-c++,java,ada --enable-checking=release --with-gxx-include-dir=/usr/include/c++/4.8 --enable-ssp --disable-libssp --disable-plugin --with-bugurl=http://bugs.opensuse.org/ --with-pkgversion='SUSE Linux' --disable-libgcj --disable-libmudflap --with-slibdir=/lib64 --with-system-zlib --enable-__cxa_atexit --enable-libstdcxx-allocator=new --disable-libstdcxx-pch --enable-version-specific-runtime-libs --enable-linker-build-id --program-suffix=-4.8 --enable-linux-futex --without-system-libunwind --with-arch-32=i586 --with-tune=generic --build=x86_64-suse-linux +Thread model: posix +gcc version 4.8.1 20130909 [gcc-4_8-branch revision 202388] (SUSE Linux) +configure:3250: $? = 0 +configure:3239: gcc -V >&5 +gcc: error: unrecognized command line option '-V' +gcc: fatal error: no input files +compilation terminated. +configure:3250: $? = 1 +configure:3239: gcc -qversion >&5 +gcc: error: unrecognized command line option '-qversion' +gcc: fatal error: no input files +compilation terminated. +configure:3250: $? = 1 +configure:3270: checking whether the C compiler works +configure:3292: gcc -I/home/matthias/tmp/libodb/sqlite3/include -L/home/matthias/tmp/libodb/build/sqlite3 -ldl conftest.c >&5 +configure:3296: $? = 0 +configure:3344: result: yes +configure:3347: checking for C compiler default output file name +configure:3349: result: a.out +configure:3355: checking for suffix of executables +configure:3362: gcc -o conftest -I/home/matthias/tmp/libodb/sqlite3/include -L/home/matthias/tmp/libodb/build/sqlite3 -ldl conftest.c >&5 +configure:3366: $? = 0 +configure:3388: result: +configure:3410: checking whether we are cross compiling +configure:3418: gcc -o conftest -I/home/matthias/tmp/libodb/sqlite3/include -L/home/matthias/tmp/libodb/build/sqlite3 -ldl conftest.c >&5 +configure:3422: $? = 0 +configure:3429: ./conftest +configure:3433: $? = 0 +configure:3448: result: no +configure:3453: checking for suffix of object files +configure:3475: gcc -c -I/home/matthias/tmp/libodb/sqlite3/include conftest.c >&5 +configure:3479: $? = 0 +configure:3500: result: o +configure:3504: checking whether we are using the GNU C compiler +configure:3523: gcc -c -I/home/matthias/tmp/libodb/sqlite3/include conftest.c >&5 +configure:3523: $? = 0 +configure:3532: result: yes +configure:3541: checking whether gcc accepts -g +configure:3561: gcc -c -g -I/home/matthias/tmp/libodb/sqlite3/include conftest.c >&5 +configure:3561: $? = 0 +configure:3602: result: yes +configure:3619: checking for gcc option to accept ISO C89 +configure:3682: gcc -c -g -O2 -I/home/matthias/tmp/libodb/sqlite3/include conftest.c >&5 +configure:3682: $? = 0 +configure:3695: result: none needed +configure:3717: checking dependency style of gcc +configure:3828: result: gcc3 +configure:3893: checking for ar +configure:3909: found /usr/bin/ar +configure:3920: result: ar +configure:3946: checking the archiver (ar) interface +configure:3956: gcc -c -g -O2 -I/home/matthias/tmp/libodb/sqlite3/include conftest.c >&5 +configure:3956: $? = 0 +configure:3958: ar cru libconftest.a conftest.o >&5 +configure:3961: $? = 0 +configure:3984: result: ar +configure:4034: checking build system type +configure:4048: result: x86_64-unknown-linux-gnu +configure:4068: checking host system type +configure:4081: result: x86_64-unknown-linux-gnu +configure:4122: checking how to print strings +configure:4149: result: printf +configure:4170: checking for a sed that does not truncate output +configure:4234: result: /usr/bin/sed +configure:4252: checking for grep that handles long lines and -e +configure:4310: result: /usr/bin/grep +configure:4315: checking for egrep +configure:4377: result: /usr/bin/grep -E +configure:4382: checking for fgrep +configure:4444: result: /usr/bin/grep -F +configure:4479: checking for ld used by gcc +configure:4546: result: /usr/x86_64-suse-linux/bin/ld +configure:4553: checking if the linker (/usr/x86_64-suse-linux/bin/ld) is GNU ld +configure:4568: result: yes +configure:4580: checking for BSD- or MS-compatible name lister (nm) +configure:4629: result: /usr/bin/nm -B +configure:4759: checking the name lister (/usr/bin/nm -B) interface +configure:4766: gcc -c -g -O2 -I/home/matthias/tmp/libodb/sqlite3/include conftest.c >&5 +configure:4769: /usr/bin/nm -B "conftest.o" +configure:4772: output +0000000000000000 B some_variable +configure:4779: result: BSD nm +configure:4782: checking whether ln -s works +configure:4786: result: yes +configure:4794: checking the maximum length of command line arguments +configure:4925: result: 1572864 +configure:4942: checking whether the shell understands some XSI constructs +configure:4952: result: yes +configure:4956: checking whether the shell understands "+=" +configure:4962: result: yes +configure:4997: checking how to convert x86_64-unknown-linux-gnu file names to x86_64-unknown-linux-gnu format +configure:5037: result: func_convert_file_noop +configure:5044: checking how to convert x86_64-unknown-linux-gnu file names to toolchain format +configure:5064: result: func_convert_file_noop +configure:5071: checking for /usr/x86_64-suse-linux/bin/ld option to reload object files +configure:5078: result: -r +configure:5152: checking for objdump +configure:5168: found /usr/bin/objdump +configure:5179: result: objdump +configure:5208: checking how to recognize dependent libraries +configure:5406: result: pass_all +configure:5491: checking for dlltool +configure:5521: result: no +configure:5548: checking how to associate runtime and link libraries +configure:5575: result: printf %s\n +configure:5699: checking for archiver @FILE support +configure:5716: gcc -c -g -O2 -I/home/matthias/tmp/libodb/sqlite3/include conftest.c >&5 +configure:5716: $? = 0 +configure:5719: ar cru libconftest.a @conftest.lst >&5 +configure:5722: $? = 0 +configure:5727: ar cru libconftest.a @conftest.lst >&5 +ar: conftest.o: No such file or directory +configure:5730: $? = 1 +configure:5742: result: @ +configure:5800: checking for strip +configure:5816: found /usr/bin/strip +configure:5827: result: strip +configure:5899: checking for ranlib +configure:5915: found /usr/bin/ranlib +configure:5926: result: ranlib +configure:6028: checking command to parse /usr/bin/nm -B output from gcc object +configure:6148: gcc -c -g -O2 -I/home/matthias/tmp/libodb/sqlite3/include conftest.c >&5 +configure:6151: $? = 0 +configure:6155: /usr/bin/nm -B conftest.o \| sed -n -e 's/^.*[ ]\([ABCDGIRSTW][ABCDGIRSTW]*\)[ ][ ]*\([_A-Za-z][_A-Za-z0-9]*\)$/\1 \2 \2/p' | sed '/ __gnu_lto/d' \> conftest.nm +configure:6158: $? = 0 +configure:6224: gcc -o conftest -g -O2 -I/home/matthias/tmp/libodb/sqlite3/include -L/home/matthias/tmp/libodb/build/sqlite3 -ldl conftest.c conftstm.o >&5 +configure:6227: $? = 0 +configure:6265: result: ok +configure:6302: checking for sysroot +configure:6332: result: no +configure:6409: gcc -c -g -O2 -I/home/matthias/tmp/libodb/sqlite3/include conftest.c >&5 +configure:6412: $? = 0 +configure:6595: checking for mt +configure:6611: found /usr/bin/mt +configure:6622: result: mt +configure:6645: checking if mt is a manifest tool +configure:6651: mt '-?' +configure:6659: result: no +configure:7301: checking how to run the C preprocessor +configure:7332: gcc -E -I/home/matthias/tmp/libodb/sqlite3/include conftest.c +configure:7332: $? = 0 +configure:7346: gcc -E -I/home/matthias/tmp/libodb/sqlite3/include conftest.c +conftest.c:11:28: fatal error: ac_nonexistent.h: No such file or directory + #include + ^ +compilation terminated. +configure:7346: $? = 1 +configure: failed program was: +| /* confdefs.h */ +| #define PACKAGE_NAME "libodb-sqlite" +| #define PACKAGE_TARNAME "libodb-sqlite" +| #define PACKAGE_VERSION "2.4.0" +| #define PACKAGE_STRING "libodb-sqlite 2.4.0" +| #define PACKAGE_BUGREPORT "odb-users@codesynthesis.com" +| #define PACKAGE_URL "" +| #define PACKAGE "libodb-sqlite" +| #define VERSION "2.4.0" +| /* end confdefs.h. */ +| #include +configure:7371: result: gcc -E +configure:7391: gcc -E -I/home/matthias/tmp/libodb/sqlite3/include conftest.c +configure:7391: $? = 0 +configure:7405: gcc -E -I/home/matthias/tmp/libodb/sqlite3/include conftest.c +conftest.c:11:28: fatal error: ac_nonexistent.h: No such file or directory + #include + ^ +compilation terminated. +configure:7405: $? = 1 +configure: failed program was: +| /* confdefs.h */ +| #define PACKAGE_NAME "libodb-sqlite" +| #define PACKAGE_TARNAME "libodb-sqlite" +| #define PACKAGE_VERSION "2.4.0" +| #define PACKAGE_STRING "libodb-sqlite 2.4.0" +| #define PACKAGE_BUGREPORT "odb-users@codesynthesis.com" +| #define PACKAGE_URL "" +| #define PACKAGE "libodb-sqlite" +| #define VERSION "2.4.0" +| /* end confdefs.h. */ +| #include +configure:7434: checking for ANSI C header files +configure:7454: gcc -c -g -O2 -I/home/matthias/tmp/libodb/sqlite3/include conftest.c >&5 +configure:7454: $? = 0 +configure:7527: gcc -o conftest -g -O2 -I/home/matthias/tmp/libodb/sqlite3/include -L/home/matthias/tmp/libodb/build/sqlite3 -ldl conftest.c >&5 +configure:7527: $? = 0 +configure:7527: ./conftest +configure:7527: $? = 0 +configure:7538: result: yes +configure:7551: checking for sys/types.h +configure:7551: gcc -c -g -O2 -I/home/matthias/tmp/libodb/sqlite3/include conftest.c >&5 +configure:7551: $? = 0 +configure:7551: result: yes +configure:7551: checking for sys/stat.h +configure:7551: gcc -c -g -O2 -I/home/matthias/tmp/libodb/sqlite3/include conftest.c >&5 +configure:7551: $? = 0 +configure:7551: result: yes +configure:7551: checking for stdlib.h +configure:7551: gcc -c -g -O2 -I/home/matthias/tmp/libodb/sqlite3/include conftest.c >&5 +configure:7551: $? = 0 +configure:7551: result: yes +configure:7551: checking for string.h +configure:7551: gcc -c -g -O2 -I/home/matthias/tmp/libodb/sqlite3/include conftest.c >&5 +configure:7551: $? = 0 +configure:7551: result: yes +configure:7551: checking for memory.h +configure:7551: gcc -c -g -O2 -I/home/matthias/tmp/libodb/sqlite3/include conftest.c >&5 +configure:7551: $? = 0 +configure:7551: result: yes +configure:7551: checking for strings.h +configure:7551: gcc -c -g -O2 -I/home/matthias/tmp/libodb/sqlite3/include conftest.c >&5 +configure:7551: $? = 0 +configure:7551: result: yes +configure:7551: checking for inttypes.h +configure:7551: gcc -c -g -O2 -I/home/matthias/tmp/libodb/sqlite3/include conftest.c >&5 +configure:7551: $? = 0 +configure:7551: result: yes +configure:7551: checking for stdint.h +configure:7551: gcc -c -g -O2 -I/home/matthias/tmp/libodb/sqlite3/include conftest.c >&5 +configure:7551: $? = 0 +configure:7551: result: yes +configure:7551: checking for unistd.h +configure:7551: gcc -c -g -O2 -I/home/matthias/tmp/libodb/sqlite3/include conftest.c >&5 +configure:7551: $? = 0 +configure:7551: result: yes +configure:7565: checking for dlfcn.h +configure:7565: gcc -c -g -O2 -I/home/matthias/tmp/libodb/sqlite3/include conftest.c >&5 +configure:7565: $? = 0 +configure:7565: result: yes +configure:8069: checking for objdir +configure:8084: result: .libs +configure:8355: checking if gcc supports -fno-rtti -fno-exceptions +configure:8373: gcc -c -g -O2 -I/home/matthias/tmp/libodb/sqlite3/include -fno-rtti -fno-exceptions conftest.c >&5 +cc1: warning: command line option '-fno-rtti' is valid for C++/ObjC++ but not for C [enabled by default] +configure:8377: $? = 0 +configure:8390: result: no +configure:8717: checking for gcc option to produce PIC +configure:8724: result: -fPIC -DPIC +configure:8732: checking if gcc PIC flag -fPIC -DPIC works +configure:8750: gcc -c -g -O2 -I/home/matthias/tmp/libodb/sqlite3/include -fPIC -DPIC -DPIC conftest.c >&5 +configure:8754: $? = 0 +configure:8767: result: yes +configure:8796: checking if gcc static flag -static works +configure:8824: result: no +configure:8839: checking if gcc supports -c -o file.o +configure:8860: gcc -c -g -O2 -I/home/matthias/tmp/libodb/sqlite3/include -o out/conftest2.o conftest.c >&5 +configure:8864: $? = 0 +configure:8886: result: yes +configure:8894: checking if gcc supports -c -o file.o +configure:8941: result: yes +configure:8974: checking whether the gcc linker (/usr/x86_64-suse-linux/bin/ld -m elf_x86_64) supports shared libraries +configure:10131: result: yes +configure:10168: checking whether -lc should be explicitly linked in +configure:10176: gcc -c -g -O2 -I/home/matthias/tmp/libodb/sqlite3/include conftest.c >&5 +configure:10179: $? = 0 +configure:10194: gcc -shared -fPIC -DPIC conftest.o -v -Wl,-soname -Wl,conftest -o conftest 2\>\&1 \| /usr/bin/grep -lc \>/dev/null 2\>\&1 +configure:10197: $? = 0 +configure:10211: result: no +configure:10371: checking dynamic linker characteristics +configure:10871: gcc -o conftest -g -O2 -I/home/matthias/tmp/libodb/sqlite3/include -L/home/matthias/tmp/libodb/build/sqlite3 -ldl -Wl,-rpath -Wl,/foo conftest.c >&5 +configure:10871: $? = 0 +configure:11105: result: GNU/Linux ld.so +configure:11212: checking how to hardcode library paths into programs +configure:11237: result: immediate +configure:11777: checking whether stripping libraries is possible +configure:11782: result: yes +configure:11817: checking if libtool supports shared libraries +configure:11819: result: yes +configure:11822: checking whether to build shared libraries +configure:11843: result: yes +configure:11846: checking whether to build static libraries +configure:11850: result: yes +configure:11950: checking for g++ +configure:11966: found /usr/bin/g++ +configure:11977: result: g++ +configure:12004: checking for C++ compiler version +configure:12013: g++ --version >&5 +g++ (SUSE Linux) 4.8.1 20130909 [gcc-4_8-branch revision 202388] +Copyright (C) 2013 Free Software Foundation, Inc. +This is free software; see the source for copying conditions. There is NO +warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + +configure:12024: $? = 0 +configure:12013: g++ -v >&5 +Using built-in specs. +COLLECT_GCC=g++ +COLLECT_LTO_WRAPPER=/usr/lib64/gcc/x86_64-suse-linux/4.8/lto-wrapper +Target: x86_64-suse-linux +Configured with: ../configure --prefix=/usr --infodir=/usr/share/info --mandir=/usr/share/man --libdir=/usr/lib64 --libexecdir=/usr/lib64 --enable-languages=c,c++,objc,fortran,obj-c++,java,ada --enable-checking=release --with-gxx-include-dir=/usr/include/c++/4.8 --enable-ssp --disable-libssp --disable-plugin --with-bugurl=http://bugs.opensuse.org/ --with-pkgversion='SUSE Linux' --disable-libgcj --disable-libmudflap --with-slibdir=/lib64 --with-system-zlib --enable-__cxa_atexit --enable-libstdcxx-allocator=new --disable-libstdcxx-pch --enable-version-specific-runtime-libs --enable-linker-build-id --program-suffix=-4.8 --enable-linux-futex --without-system-libunwind --with-arch-32=i586 --with-tune=generic --build=x86_64-suse-linux +Thread model: posix +gcc version 4.8.1 20130909 [gcc-4_8-branch revision 202388] (SUSE Linux) +configure:12024: $? = 0 +configure:12013: g++ -V >&5 +g++: error: unrecognized command line option '-V' +g++: fatal error: no input files +compilation terminated. +configure:12024: $? = 1 +configure:12013: g++ -qversion >&5 +g++: error: unrecognized command line option '-qversion' +g++: fatal error: no input files +compilation terminated. +configure:12024: $? = 1 +configure:12028: checking whether we are using the GNU C++ compiler +configure:12047: g++ -c -I/home/matthias/tmp/libodb/sqlite3/include conftest.cpp >&5 +configure:12047: $? = 0 +configure:12056: result: yes +configure:12065: checking whether g++ accepts -g +configure:12085: g++ -c -g -I/home/matthias/tmp/libodb/sqlite3/include conftest.cpp >&5 +configure:12085: $? = 0 +configure:12126: result: yes +configure:12151: checking dependency style of g++ +configure:12262: result: gcc3 +configure:12295: checking how to run the C++ preprocessor +configure:12322: g++ -E -I/home/matthias/tmp/libodb/sqlite3/include conftest.cpp +configure:12322: $? = 0 +configure:12336: g++ -E -I/home/matthias/tmp/libodb/sqlite3/include conftest.cpp +conftest.cpp:23:28: fatal error: ac_nonexistent.h: No such file or directory + #include + ^ +compilation terminated. +configure:12336: $? = 1 +configure: failed program was: +| /* confdefs.h */ +| #define PACKAGE_NAME "libodb-sqlite" +| #define PACKAGE_TARNAME "libodb-sqlite" +| #define PACKAGE_VERSION "2.4.0" +| #define PACKAGE_STRING "libodb-sqlite 2.4.0" +| #define PACKAGE_BUGREPORT "odb-users@codesynthesis.com" +| #define PACKAGE_URL "" +| #define PACKAGE "libodb-sqlite" +| #define VERSION "2.4.0" +| #define STDC_HEADERS 1 +| #define HAVE_SYS_TYPES_H 1 +| #define HAVE_SYS_STAT_H 1 +| #define HAVE_STDLIB_H 1 +| #define HAVE_STRING_H 1 +| #define HAVE_MEMORY_H 1 +| #define HAVE_STRINGS_H 1 +| #define HAVE_INTTYPES_H 1 +| #define HAVE_STDINT_H 1 +| #define HAVE_UNISTD_H 1 +| #define HAVE_DLFCN_H 1 +| #define LT_OBJDIR ".libs/" +| /* end confdefs.h. */ +| #include +configure:12361: result: g++ -E +configure:12381: g++ -E -I/home/matthias/tmp/libodb/sqlite3/include conftest.cpp +configure:12381: $? = 0 +configure:12395: g++ -E -I/home/matthias/tmp/libodb/sqlite3/include conftest.cpp +conftest.cpp:23:28: fatal error: ac_nonexistent.h: No such file or directory + #include + ^ +compilation terminated. +configure:12395: $? = 1 +configure: failed program was: +| /* confdefs.h */ +| #define PACKAGE_NAME "libodb-sqlite" +| #define PACKAGE_TARNAME "libodb-sqlite" +| #define PACKAGE_VERSION "2.4.0" +| #define PACKAGE_STRING "libodb-sqlite 2.4.0" +| #define PACKAGE_BUGREPORT "odb-users@codesynthesis.com" +| #define PACKAGE_URL "" +| #define PACKAGE "libodb-sqlite" +| #define VERSION "2.4.0" +| #define STDC_HEADERS 1 +| #define HAVE_SYS_TYPES_H 1 +| #define HAVE_SYS_STAT_H 1 +| #define HAVE_STDLIB_H 1 +| #define HAVE_STRING_H 1 +| #define HAVE_MEMORY_H 1 +| #define HAVE_STRINGS_H 1 +| #define HAVE_INTTYPES_H 1 +| #define HAVE_STDINT_H 1 +| #define HAVE_UNISTD_H 1 +| #define HAVE_DLFCN_H 1 +| #define LT_OBJDIR ".libs/" +| /* end confdefs.h. */ +| #include +configure:12564: checking for ld used by g++ +configure:12631: result: /usr/x86_64-suse-linux/bin/ld -m elf_x86_64 +configure:12638: checking if the linker (/usr/x86_64-suse-linux/bin/ld -m elf_x86_64) is GNU ld +configure:12653: result: yes +configure:12708: checking whether the g++ linker (/usr/x86_64-suse-linux/bin/ld -m elf_x86_64) supports shared libraries +configure:13710: result: yes +configure:13746: g++ -c -g -O2 -I/home/matthias/tmp/libodb/sqlite3/include conftest.cpp >&5 +configure:13749: $? = 0 +configure:14269: checking for g++ option to produce PIC +configure:14276: result: -fPIC -DPIC +configure:14284: checking if g++ PIC flag -fPIC -DPIC works +configure:14302: g++ -c -g -O2 -I/home/matthias/tmp/libodb/sqlite3/include -fPIC -DPIC -DPIC conftest.cpp >&5 +configure:14306: $? = 0 +configure:14319: result: yes +configure:14342: checking if g++ static flag -static works +configure:14370: result: no +configure:14382: checking if g++ supports -c -o file.o +configure:14403: g++ -c -g -O2 -I/home/matthias/tmp/libodb/sqlite3/include -o out/conftest2.o conftest.cpp >&5 +configure:14407: $? = 0 +configure:14429: result: yes +configure:14434: checking if g++ supports -c -o file.o +configure:14481: result: yes +configure:14511: checking whether the g++ linker (/usr/x86_64-suse-linux/bin/ld -m elf_x86_64) supports shared libraries +configure:14550: result: yes +configure:14691: checking dynamic linker characteristics +configure:15359: result: GNU/Linux ld.so +configure:15412: checking how to hardcode library paths into programs +configure:15437: result: immediate +configure:15487: creating ./config.lt + +## ------------------ ## +## Running config.lt. ## +## ------------------ ## +config.lt:682: creating libtool +configure:17352: checking for the pthreads library -lpthreads +configure:17386: g++ -o conftest -g -O2 -I/home/matthias/tmp/libodb/sqlite3/include -L/home/matthias/tmp/libodb/build/sqlite3 -ldl conftest.cpp -lpthreads >&5 +/usr/lib64/gcc/x86_64-suse-linux/4.8/../../../../x86_64-suse-linux/bin/ld: cannot find -lpthreads +collect2: error: ld returned 1 exit status +configure:17386: $? = 1 +configure: failed program was: +| /* confdefs.h */ +| #define PACKAGE_NAME "libodb-sqlite" +| #define PACKAGE_TARNAME "libodb-sqlite" +| #define PACKAGE_VERSION "2.4.0" +| #define PACKAGE_STRING "libodb-sqlite 2.4.0" +| #define PACKAGE_BUGREPORT "odb-users@codesynthesis.com" +| #define PACKAGE_URL "" +| #define PACKAGE "libodb-sqlite" +| #define VERSION "2.4.0" +| #define STDC_HEADERS 1 +| #define HAVE_SYS_TYPES_H 1 +| #define HAVE_SYS_STAT_H 1 +| #define HAVE_STDLIB_H 1 +| #define HAVE_STRING_H 1 +| #define HAVE_MEMORY_H 1 +| #define HAVE_STRINGS_H 1 +| #define HAVE_INTTYPES_H 1 +| #define HAVE_STDINT_H 1 +| #define HAVE_UNISTD_H 1 +| #define HAVE_DLFCN_H 1 +| #define LT_OBJDIR ".libs/" +| /* end confdefs.h. */ +| #include +| int +| main () +| { +| pthread_t th; pthread_join(th, 0); +| pthread_attr_init(0); pthread_cleanup_push(0, 0); +| pthread_create(0,0,0,0); pthread_cleanup_pop(0); +| ; +| return 0; +| } +configure:17395: result: no +configure:17352: checking for the pthreads library -lpthread +configure:17386: g++ -o conftest -g -O2 -I/home/matthias/tmp/libodb/sqlite3/include -L/home/matthias/tmp/libodb/build/sqlite3 -ldl conftest.cpp -lpthread >&5 +configure:17386: $? = 0 +configure:17395: result: yes +configure:17414: checking if more special flags are required for pthreads +configure:17423: result: -D_REENTRANT +configure:17466: checking for __thread keyword +configure:17497: g++ -c -g -O2 -D_REENTRANT -I/home/matthias/tmp/libodb/sqlite3/include conftest.cpp >&5 +configure:17497: $? = 0 +configure:17504: ./libtool --tag=CXX --mode=link g++ -no-install -g -O2 -D_REENTRANT -L/home/matthias/tmp/libodb/build/sqlite3 -ldl -o conftest conftest.o -lpthread >&5 +libtool: link: g++ -g -O2 -D_REENTRANT -o conftest conftest.o -L/home/matthias/tmp/libodb/build/sqlite3 -ldl -lpthread +configure:17508: $? = 0 +configure:17541: result: yes +configure:17559: checking for libsqlite3 +configure:17598: g++ -c -g -O2 -D_REENTRANT -I/home/matthias/tmp/libodb/sqlite3/include conftest.cpp >&5 +configure:17598: $? = 0 +configure:17605: ./libtool --tag=CXX --mode=link g++ -no-install -g -O2 -D_REENTRANT -L/home/matthias/tmp/libodb/build/sqlite3 -ldl -o conftest conftest.o -lsqlite3 -lpthread >&5 +libtool: link: g++ -g -O2 -D_REENTRANT -o conftest conftest.o -L/home/matthias/tmp/libodb/build/sqlite3 -ldl -lsqlite3 -lpthread +configure:17609: $? = 0 +configure:17680: g++ -c -g -O2 -D_REENTRANT -I/home/matthias/tmp/libodb/sqlite3/include conftest.cpp >&5 +configure:17680: $? = 0 +configure:17687: ./libtool --tag=CXX --mode=link g++ -no-install -g -O2 -D_REENTRANT -L/home/matthias/tmp/libodb/build/sqlite3 -ldl -o conftest conftest.o -lsqlite3 -lpthread >&5 +libtool: link: g++ -g -O2 -D_REENTRANT -o conftest conftest.o -L/home/matthias/tmp/libodb/build/sqlite3 -ldl -lsqlite3 -lpthread +conftest.o: In function `main': +/home/matthias/tmp/libodb/libodb-sqlite-2.4.0/conftest.cpp:32: undefined reference to `sqlite3_unlock_notify' +collect2: error: ld returned 1 exit status +configure:17691: $? = 1 +configure:17728: result: yes +configure:17745: WARNING: libsqlite3 is built without sqlite3_unlock_notify support; multi-threaded support will be limited +configure:17763: checking for libodb +configure:17837: g++ -c -g -O2 -D_REENTRANT -I/home/matthias/tmp/libodb/sqlite3/include conftest.cpp >&5 +conftest.cpp:26:29: fatal error: odb/exception.hxx: No such file or directory + #include + ^ +compilation terminated. +configure:17837: $? = 1 +configure: failed program was: +| /* confdefs.h */ +| #define PACKAGE_NAME "libodb-sqlite" +| #define PACKAGE_TARNAME "libodb-sqlite" +| #define PACKAGE_VERSION "2.4.0" +| #define PACKAGE_STRING "libodb-sqlite 2.4.0" +| #define PACKAGE_BUGREPORT "odb-users@codesynthesis.com" +| #define PACKAGE_URL "" +| #define PACKAGE "libodb-sqlite" +| #define VERSION "2.4.0" +| #define STDC_HEADERS 1 +| #define HAVE_SYS_TYPES_H 1 +| #define HAVE_SYS_STAT_H 1 +| #define HAVE_STDLIB_H 1 +| #define HAVE_STRING_H 1 +| #define HAVE_MEMORY_H 1 +| #define HAVE_STRINGS_H 1 +| #define HAVE_INTTYPES_H 1 +| #define HAVE_STDINT_H 1 +| #define HAVE_UNISTD_H 1 +| #define HAVE_DLFCN_H 1 +| #define LT_OBJDIR ".libs/" +| #define HAVE_PTHREAD 1 +| /* end confdefs.h. */ +| +| +| #include +| +| void +| f () +| { +| } +| +| const char* +| g () +| { +| try +| { +| f (); +| } +| catch (const odb::exception& e) +| { +| return e.what (); +| } +| return 0; +| } +| +| int +| main () +| { +| const char* m (g ()); +| return m != 0; +| } +| +configure:17895: result: no +configure:17897: error: libodb is not found; consider using --with-libodb=DIR + +## ---------------- ## +## Cache variables. ## +## ---------------- ## + +ac_cv_build=x86_64-unknown-linux-gnu +ac_cv_c_compiler_gnu=yes +ac_cv_cxx_compiler_gnu=yes +ac_cv_env_CCC_set= +ac_cv_env_CCC_value= +ac_cv_env_CC_set= +ac_cv_env_CC_value= +ac_cv_env_CFLAGS_set= +ac_cv_env_CFLAGS_value= +ac_cv_env_CPPFLAGS_set=set +ac_cv_env_CPPFLAGS_value=-I/home/matthias/tmp/libodb/sqlite3/include +ac_cv_env_CPP_set= +ac_cv_env_CPP_value= +ac_cv_env_CXXCPP_set= +ac_cv_env_CXXCPP_value= +ac_cv_env_CXXFLAGS_set= +ac_cv_env_CXXFLAGS_value= +ac_cv_env_CXX_set= +ac_cv_env_CXX_value= +ac_cv_env_LDFLAGS_set=set +ac_cv_env_LDFLAGS_value='-L/home/matthias/tmp/libodb/build/sqlite3 -ldl' +ac_cv_env_LIBS_set= +ac_cv_env_LIBS_value= +ac_cv_env_build_alias_set= +ac_cv_env_build_alias_value= +ac_cv_env_host_alias_set= +ac_cv_env_host_alias_value= +ac_cv_env_target_alias_set= +ac_cv_env_target_alias_value= +ac_cv_header_dlfcn_h=yes +ac_cv_header_inttypes_h=yes +ac_cv_header_memory_h=yes +ac_cv_header_stdc=yes +ac_cv_header_stdint_h=yes +ac_cv_header_stdlib_h=yes +ac_cv_header_string_h=yes +ac_cv_header_strings_h=yes +ac_cv_header_sys_stat_h=yes +ac_cv_header_sys_types_h=yes +ac_cv_header_unistd_h=yes +ac_cv_host=x86_64-unknown-linux-gnu +ac_cv_objext=o +ac_cv_path_EGREP='/usr/bin/grep -E' +ac_cv_path_FGREP='/usr/bin/grep -F' +ac_cv_path_GREP=/usr/bin/grep +ac_cv_path_SED=/usr/bin/sed +ac_cv_path_install='/usr/bin/install -c' +ac_cv_path_mkdir=/usr/bin/mkdir +ac_cv_prog_AWK=gawk +ac_cv_prog_CPP='gcc -E' +ac_cv_prog_CXXCPP='g++ -E' +ac_cv_prog_ac_ct_AR=ar +ac_cv_prog_ac_ct_CC=gcc +ac_cv_prog_ac_ct_CXX=g++ +ac_cv_prog_ac_ct_MANIFEST_TOOL=mt +ac_cv_prog_ac_ct_OBJDUMP=objdump +ac_cv_prog_ac_ct_RANLIB=ranlib +ac_cv_prog_ac_ct_STRIP=strip +ac_cv_prog_cc_c89= +ac_cv_prog_cc_g=yes +ac_cv_prog_cxx_g=yes +ac_cv_prog_make_make_set=yes +am_cv_CC_dependencies_compiler_type=gcc3 +am_cv_CXX_dependencies_compiler_type=gcc3 +am_cv_ar_interface=ar +am_cv_prog_tar_ustar=gnutar +lt_cv_ar_at_file=@ +lt_cv_archive_cmds_need_lc=no +lt_cv_deplibs_check_method=pass_all +lt_cv_file_magic_cmd='$MAGIC_CMD' +lt_cv_file_magic_test_file= +lt_cv_ld_reload_flag=-r +lt_cv_nm_interface='BSD nm' +lt_cv_objdir=.libs +lt_cv_path_LD=/usr/x86_64-suse-linux/bin/ld +lt_cv_path_LDCXX='/usr/x86_64-suse-linux/bin/ld -m elf_x86_64' +lt_cv_path_NM='/usr/bin/nm -B' +lt_cv_path_mainfest_tool=no +lt_cv_prog_compiler_c_o=yes +lt_cv_prog_compiler_c_o_CXX=yes +lt_cv_prog_compiler_pic='-fPIC -DPIC' +lt_cv_prog_compiler_pic_CXX='-fPIC -DPIC' +lt_cv_prog_compiler_pic_works=yes +lt_cv_prog_compiler_pic_works_CXX=yes +lt_cv_prog_compiler_rtti_exceptions=no +lt_cv_prog_compiler_static_works=no +lt_cv_prog_compiler_static_works_CXX=no +lt_cv_prog_gnu_ld=yes +lt_cv_prog_gnu_ldcxx=yes +lt_cv_sharedlib_from_linklib_cmd='printf %s\n' +lt_cv_shlibpath_overrides_runpath=yes +lt_cv_sys_global_symbol_pipe='sed -n -e '\''s/^.*[ ]\([ABCDGIRSTW][ABCDGIRSTW]*\)[ ][ ]*\([_A-Za-z][_A-Za-z0-9]*\)$/\1 \2 \2/p'\'' | sed '\''/ __gnu_lto/d'\''' +lt_cv_sys_global_symbol_to_c_name_address='sed -n -e '\''s/^: \([^ ]*\)[ ]*$/ {\"\1\", (void *) 0},/p'\'' -e '\''s/^[ABCDGIRSTW]* \([^ ]*\) \([^ ]*\)$/ {"\2", (void *) \&\2},/p'\''' +lt_cv_sys_global_symbol_to_c_name_address_lib_prefix='sed -n -e '\''s/^: \([^ ]*\)[ ]*$/ {\"\1\", (void *) 0},/p'\'' -e '\''s/^[ABCDGIRSTW]* \([^ ]*\) \(lib[^ ]*\)$/ {"\2", (void *) \&\2},/p'\'' -e '\''s/^[ABCDGIRSTW]* \([^ ]*\) \([^ ]*\)$/ {"lib\2", (void *) \&\2},/p'\''' +lt_cv_sys_global_symbol_to_cdecl='sed -n -e '\''s/^T .* \(.*\)$/extern int \1();/p'\'' -e '\''s/^[ABCDGIRSTW]* .* \(.*\)$/extern char \1;/p'\''' +lt_cv_sys_max_cmd_len=1572864 +lt_cv_to_host_file_cmd=func_convert_file_noop +lt_cv_to_tool_file_cmd=func_convert_file_noop + +## ----------------- ## +## Output variables. ## +## ----------------- ## + +ACLOCAL='${SHELL} /home/matthias/tmp/libodb/libodb-sqlite-2.4.0/config/missing --run aclocal-1.12' +AMDEPBACKSLASH='\' +AMDEP_FALSE='#' +AMDEP_TRUE='' +AMTAR='$${TAR-tar}' +AR='ar' +AS='as' +AUTOCONF='${SHELL} /home/matthias/tmp/libodb/libodb-sqlite-2.4.0/config/missing --run autoconf' +AUTOHEADER='${SHELL} /home/matthias/tmp/libodb/libodb-sqlite-2.4.0/config/missing --run autoheader' +AUTOMAKE='${SHELL} /home/matthias/tmp/libodb/libodb-sqlite-2.4.0/config/missing --run automake-1.12' +AWK='gawk' +CC='gcc' +CCDEPMODE='depmode=gcc3' +CFLAGS='-g -O2' +CPP='gcc -E' +CPPFLAGS='-I/home/matthias/tmp/libodb/sqlite3/include' +CXX='g++' +CXXCPP='g++ -E' +CXXDEPMODE='depmode=gcc3' +CXXFLAGS='-g -O2 -D_REENTRANT ' +CYGPATH_W='echo' +DEFS='' +DEPDIR='.deps' +DLLTOOL='false' +DSYMUTIL='' +DUMPBIN='' +ECHO_C='' +ECHO_N='-n' +ECHO_T='' +EGREP='/usr/bin/grep -E' +EXEEXT='' +FGREP='/usr/bin/grep -F' +GREP='/usr/bin/grep' +INSTALL_DATA='${INSTALL} -m 644' +INSTALL_PROGRAM='${INSTALL}' +INSTALL_SCRIPT='${INSTALL}' +INSTALL_STRIP_PROGRAM='$(install_sh) -c -s' +LD='/usr/x86_64-suse-linux/bin/ld -m elf_x86_64' +LDFLAGS='-L/home/matthias/tmp/libodb/build/sqlite3 -ldl' +LIBOBJS='' +LIBS='-lsqlite3 -lpthread' +LIBTOOL='$(SHELL) $(top_builddir)/libtool' +LIPO='' +LN_S='ln -s' +LTLIBOBJS='' +MAKEINFO='${SHELL} /home/matthias/tmp/libodb/libodb-sqlite-2.4.0/config/missing --run makeinfo' +MANIFEST_TOOL=':' +MKDIR_P='/usr/bin/mkdir -p' +NM='/usr/bin/nm -B' +NMEDIT='' +OBJDUMP='objdump' +OBJEXT='o' +OTOOL64='' +OTOOL='' +PACKAGE='libodb-sqlite' +PACKAGE_BUGREPORT='odb-users@codesynthesis.com' +PACKAGE_NAME='libodb-sqlite' +PACKAGE_STRING='libodb-sqlite 2.4.0' +PACKAGE_TARNAME='libodb-sqlite' +PACKAGE_URL='' +PACKAGE_VERSION='2.4.0' +PATH_SEPARATOR=':' +PTHREAD_CXX='' +PTHREAD_CXXFLAGS='-D_REENTRANT ' +PTHREAD_LIBS='-lpthread' +RANLIB='ranlib' +SED='/usr/bin/sed' +SET_MAKE='' +SHELL='/bin/sh' +STRIP='strip' +VERSION='2.4.0' +ac_ct_AR='ar' +ac_ct_CC='gcc' +ac_ct_CXX='g++' +ac_ct_DUMPBIN='' +acx_pthread_config='' +am__EXEEXT_FALSE='' +am__EXEEXT_TRUE='' +am__fastdepCC_FALSE='#' +am__fastdepCC_TRUE='' +am__fastdepCXX_FALSE='#' +am__fastdepCXX_TRUE='' +am__include='include' +am__isrc='' +am__leading_dot='.' +am__nodep='_no' +am__quote='' +am__tar='tar --format=ustar -chf - "$$tardir"' +am__untar='tar -xf -' +bindir='${exec_prefix}/bin' +build='x86_64-unknown-linux-gnu' +build_alias='' +build_cpu='x86_64' +build_os='linux-gnu' +build_vendor='unknown' +datadir='${datarootdir}' +datarootdir='${prefix}/share' +docdir='${datarootdir}/doc/${PACKAGE_TARNAME}' +dvidir='${docdir}' +exec_prefix='NONE' +host='x86_64-unknown-linux-gnu' +host_alias='' +host_cpu='x86_64' +host_os='linux-gnu' +host_vendor='unknown' +htmldir='${docdir}' +includedir='${prefix}/include' +infodir='${datarootdir}/info' +install_sh='${SHELL} /home/matthias/tmp/libodb/libodb-sqlite-2.4.0/config/install-sh' +libdir='${exec_prefix}/lib64' +libexecdir='${exec_prefix}/lib' +localedir='${datarootdir}/locale' +localstatedir='${prefix}/var' +mandir='${datarootdir}/man' +mkdir_p='$(MKDIR_P)' +oldincludedir='/usr/include' +pdfdir='${docdir}' +pkgconfigdir='' +prefix='NONE' +program_transform_name='s,x,x,' +psdir='${docdir}' +sbindir='${exec_prefix}/sbin' +sharedstatedir='${prefix}/com' +sysconfdir='${prefix}/etc' +target_alias='' + +## ----------- ## +## confdefs.h. ## +## ----------- ## + +/* confdefs.h */ +#define PACKAGE_NAME "libodb-sqlite" +#define PACKAGE_TARNAME "libodb-sqlite" +#define PACKAGE_VERSION "2.4.0" +#define PACKAGE_STRING "libodb-sqlite 2.4.0" +#define PACKAGE_BUGREPORT "odb-users@codesynthesis.com" +#define PACKAGE_URL "" +#define PACKAGE "libodb-sqlite" +#define VERSION "2.4.0" +#define STDC_HEADERS 1 +#define HAVE_SYS_TYPES_H 1 +#define HAVE_SYS_STAT_H 1 +#define HAVE_STDLIB_H 1 +#define HAVE_STRING_H 1 +#define HAVE_MEMORY_H 1 +#define HAVE_STRINGS_H 1 +#define HAVE_INTTYPES_H 1 +#define HAVE_STDINT_H 1 +#define HAVE_UNISTD_H 1 +#define HAVE_DLFCN_H 1 +#define LT_OBJDIR ".libs/" +#define HAVE_PTHREAD 1 + +configure: exit 1 diff --git a/third-party/odb/libodb-sqlite-2.4.0/config.lt b/third-party/odb/libodb-sqlite-2.4.0/config.lt new file mode 100755 index 0000000..918383c --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/config.lt @@ -0,0 +1,1484 @@ +#! /bin/sh +# Generated by configure. +# Run this file to recreate a libtool stub with the current configuration. +SHELL=${CONFIG_SHELL-/bin/sh} +export SHELL +## -------------------- ## +## M4sh Initialization. ## +## -------------------- ## + +# Be more Bourne compatible +DUALCASE=1; export DUALCASE # for MKS sh +if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then : + emulate sh + NULLCMD=: + # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which + # is contrary to our usage. Disable this feature. + alias -g '${1+"$@"}'='"$@"' + setopt NO_GLOB_SUBST +else + case `(set -o) 2>/dev/null` in #( + *posix*) : + set -o posix ;; #( + *) : + ;; +esac +fi + + +as_nl=' +' +export as_nl +# Printing a long string crashes Solaris 7 /usr/bin/printf. +as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' +as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo +as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo +# Prefer a ksh shell builtin over an external printf program on Solaris, +# but without wasting forks for bash or zsh. +if test -z "$BASH_VERSION$ZSH_VERSION" \ + && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then + as_echo='print -r --' + as_echo_n='print -rn --' +elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then + as_echo='printf %s\n' + as_echo_n='printf %s' +else + if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then + as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"' + as_echo_n='/usr/ucb/echo -n' + else + as_echo_body='eval expr "X$1" : "X\\(.*\\)"' + as_echo_n_body='eval + arg=$1; + case $arg in #( + *"$as_nl"*) + expr "X$arg" : "X\\(.*\\)$as_nl"; + arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;; + esac; + expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl" + ' + export as_echo_n_body + as_echo_n='sh -c $as_echo_n_body as_echo' + fi + export as_echo_body + as_echo='sh -c $as_echo_body as_echo' +fi + +# The user is always right. +if test "${PATH_SEPARATOR+set}" != set; then + PATH_SEPARATOR=: + (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && { + (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 || + PATH_SEPARATOR=';' + } +fi + + +# IFS +# We need space, tab and new line, in precisely that order. Quoting is +# there to prevent editors from complaining about space-tab. +# (If _AS_PATH_WALK were called with IFS unset, it would disable word +# splitting by setting IFS to empty value.) +IFS=" "" $as_nl" + +# Find who we are. Look in the path if we contain no directory separator. +as_myself= +case $0 in #(( + *[\\/]* ) as_myself=$0 ;; + *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break + done +IFS=$as_save_IFS + + ;; +esac +# We did not find ourselves, most probably we were run as `sh COMMAND' +# in which case we are not to be found in the path. +if test "x$as_myself" = x; then + as_myself=$0 +fi +if test ! -f "$as_myself"; then + $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2 + exit 1 +fi + +# Unset variables that we do not need and which cause bugs (e.g. in +# pre-3.0 UWIN ksh). But do not cause bugs in bash 2.01; the "|| exit 1" +# suppresses any "Segmentation fault" message there. '((' could +# trigger a bug in pdksh 5.2.14. +for as_var in BASH_ENV ENV MAIL MAILPATH +do eval test x\${$as_var+set} = xset \ + && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || : +done +PS1='$ ' +PS2='> ' +PS4='+ ' + +# NLS nuisances. +LC_ALL=C +export LC_ALL +LANGUAGE=C +export LANGUAGE + +# CDPATH. +(unset CDPATH) >/dev/null 2>&1 && unset CDPATH + + +# as_fn_error STATUS ERROR [LINENO LOG_FD] +# ---------------------------------------- +# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are +# provided, also output the error to LOG_FD, referencing LINENO. Then exit the +# script with STATUS, using 1 if that was 0. +as_fn_error () +{ + as_status=$1; test $as_status -eq 0 && as_status=1 + if test "$4"; then + as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4 + fi + $as_echo "$as_me: error: $2" >&2 + as_fn_exit $as_status +} # as_fn_error + + +# as_fn_set_status STATUS +# ----------------------- +# Set $? to STATUS, without forking. +as_fn_set_status () +{ + return $1 +} # as_fn_set_status + +# as_fn_exit STATUS +# ----------------- +# Exit the shell with STATUS, even in a "trap 0" or "set -e" context. +as_fn_exit () +{ + set +e + as_fn_set_status $1 + exit $1 +} # as_fn_exit + +# as_fn_unset VAR +# --------------- +# Portably unset VAR. +as_fn_unset () +{ + { eval $1=; unset $1;} +} +as_unset=as_fn_unset +# as_fn_append VAR VALUE +# ---------------------- +# Append the text in VALUE to the end of the definition contained in VAR. Take +# advantage of any shell optimizations that allow amortized linear growth over +# repeated appends, instead of the typical quadratic growth present in naive +# implementations. +if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then : + eval 'as_fn_append () + { + eval $1+=\$2 + }' +else + as_fn_append () + { + eval $1=\$$1\$2 + } +fi # as_fn_append + +# as_fn_arith ARG... +# ------------------ +# Perform arithmetic evaluation on the ARGs, and store the result in the +# global $as_val. Take advantage of shells that can avoid forks. The arguments +# must be portable across $(()) and expr. +if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then : + eval 'as_fn_arith () + { + as_val=$(( $* )) + }' +else + as_fn_arith () + { + as_val=`expr "$@" || test $? -eq 1` + } +fi # as_fn_arith + + +if expr a : '\(a\)' >/dev/null 2>&1 && + test "X`expr 00001 : '.*\(...\)'`" = X001; then + as_expr=expr +else + as_expr=false +fi + +if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then + as_basename=basename +else + as_basename=false +fi + +if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then + as_dirname=dirname +else + as_dirname=false +fi + +as_me=`$as_basename -- "$0" || +$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ + X"$0" : 'X\(//\)$' \| \ + X"$0" : 'X\(/\)' \| . 2>/dev/null || +$as_echo X/"$0" | + sed '/^.*\/\([^/][^/]*\)\/*$/{ + s//\1/ + q + } + /^X\/\(\/\/\)$/{ + s//\1/ + q + } + /^X\/\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q'` + +# Avoid depending upon Character Ranges. +as_cr_letters='abcdefghijklmnopqrstuvwxyz' +as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ' +as_cr_Letters=$as_cr_letters$as_cr_LETTERS +as_cr_digits='0123456789' +as_cr_alnum=$as_cr_Letters$as_cr_digits + +ECHO_C= ECHO_N= ECHO_T= +case `echo -n x` in #((((( +-n*) + case `echo 'xy\c'` in + *c*) ECHO_T=' ';; # ECHO_T is single tab character. + xy) ECHO_C='\c';; + *) echo `echo ksh88 bug on AIX 6.1` > /dev/null + ECHO_T=' ';; + esac;; +*) + ECHO_N='-n';; +esac + +rm -f conf$$ conf$$.exe conf$$.file +if test -d conf$$.dir; then + rm -f conf$$.dir/conf$$.file +else + rm -f conf$$.dir + mkdir conf$$.dir 2>/dev/null +fi +if (echo >conf$$.file) 2>/dev/null; then + if ln -s conf$$.file conf$$ 2>/dev/null; then + as_ln_s='ln -s' + # ... but there are two gotchas: + # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail. + # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable. + # In both cases, we have to default to `cp -pR'. + ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe || + as_ln_s='cp -pR' + elif ln conf$$.file conf$$ 2>/dev/null; then + as_ln_s=ln + else + as_ln_s='cp -pR' + fi +else + as_ln_s='cp -pR' +fi +rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file +rmdir conf$$.dir 2>/dev/null + + +# as_fn_mkdir_p +# ------------- +# Create "$as_dir" as a directory, including parents if necessary. +as_fn_mkdir_p () +{ + + case $as_dir in #( + -*) as_dir=./$as_dir;; + esac + test -d "$as_dir" || eval $as_mkdir_p || { + as_dirs= + while :; do + case $as_dir in #( + *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'( + *) as_qdir=$as_dir;; + esac + as_dirs="'$as_qdir' $as_dirs" + as_dir=`$as_dirname -- "$as_dir" || +$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ + X"$as_dir" : 'X\(//\)[^/]' \| \ + X"$as_dir" : 'X\(//\)$' \| \ + X"$as_dir" : 'X\(/\)' \| . 2>/dev/null || +$as_echo X"$as_dir" | + sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ + s//\1/ + q + } + /^X\(\/\/\)[^/].*/{ + s//\1/ + q + } + /^X\(\/\/\)$/{ + s//\1/ + q + } + /^X\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q'` + test -d "$as_dir" && break + done + test -z "$as_dirs" || eval "mkdir $as_dirs" + } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir" + + +} # as_fn_mkdir_p +if mkdir -p . 2>/dev/null; then + as_mkdir_p='mkdir -p "$as_dir"' +else + test -d ./-p && rmdir ./-p + as_mkdir_p=false +fi + + +# as_fn_executable_p FILE +# ----------------------- +# Test if FILE is an executable regular file. +as_fn_executable_p () +{ + test -f "$1" && test -x "$1" +} # as_fn_executable_p +as_test_x='test -x' +as_executable_p=as_fn_executable_p + +# Sed expression to map a string onto a valid CPP name. +as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'" + +# Sed expression to map a string onto a valid variable name. +as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'" + + +exec 6>&1 +## --------------------------------- ## +## Main body of "$CONFIG_LT" script. ## +## --------------------------------- ## +lt_cl_silent=false +exec 5>>config.log +{ + echo + sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX +## Running $as_me. ## +_ASBOX +} >&5 + +lt_cl_help="\ +\`$as_me' creates a local libtool stub from the current configuration, +for use in further configure time tests before the real libtool is +generated. + +Usage: $0 [OPTIONS] + + -h, --help print this help, then exit + -V, --version print version number, then exit + -q, --quiet do not print progress messages + -d, --debug don't remove temporary files + +Report bugs to ." + +lt_cl_version="\ +libodb-sqlite config.lt 2.4.0 +configured by $0, generated by GNU Autoconf 2.69. + +Copyright (C) 2011 Free Software Foundation, Inc. +This config.lt script is free software; the Free Software Foundation +gives unlimited permision to copy, distribute and modify it." + +while test $# != 0 +do + case $1 in + --version | --v* | -V ) + echo "$lt_cl_version"; exit 0 ;; + --help | --h* | -h ) + echo "$lt_cl_help"; exit 0 ;; + --debug | --d* | -d ) + debug=: ;; + --quiet | --q* | --silent | --s* | -q ) + lt_cl_silent=: ;; + + -*) as_fn_error $? "unrecognized option: $1 +Try \`$0 --help' for more information." "$LINENO" 5 ;; + + *) as_fn_error $? "unrecognized argument: $1 +Try \`$0 --help' for more information." "$LINENO" 5 ;; + esac + shift +done + +if $lt_cl_silent; then + exec 6>/dev/null +fi + + +# The HP-UX ksh and POSIX shell print the target directory to stdout +# if CDPATH is set. +(unset CDPATH) >/dev/null 2>&1 && unset CDPATH + +sed_quote_subst='s/\(["`$\\]\)/\\\1/g' +double_quote_subst='s/\(["`\\]\)/\\\1/g' +delay_variable_subst='s/\\\\\\\\\\\$/\\\\\\$/g' +macro_version='2.4.2' +macro_revision='1.3337' +AS='as' +DLLTOOL='false' +OBJDUMP='objdump' +enable_shared='yes' +enable_static='yes' +pic_mode='default' +enable_fast_install='needless' +SHELL='/bin/sh' +ECHO='printf %s\n' +PATH_SEPARATOR=':' +host_alias='' +host='x86_64-unknown-linux-gnu' +host_os='linux-gnu' +build_alias='' +build='x86_64-unknown-linux-gnu' +build_os='linux-gnu' +SED='/usr/bin/sed' +Xsed='/usr/bin/sed -e 1s/^X//' +GREP='/usr/bin/grep' +EGREP='/usr/bin/grep -E' +FGREP='/usr/bin/grep -F' +LD='/usr/x86_64-suse-linux/bin/ld -m elf_x86_64' +NM='/usr/bin/nm -B' +LN_S='ln -s' +max_cmd_len='1572864' +ac_objext='o' +exeext='' +lt_unset='unset' +lt_SP2NL='tr \040 \012' +lt_NL2SP='tr \015\012 \040\040' +lt_cv_to_host_file_cmd='func_convert_file_noop' +lt_cv_to_tool_file_cmd='func_convert_file_noop' +reload_flag=' -r' +reload_cmds='$LD$reload_flag -o $output$reload_objs' +deplibs_check_method='pass_all' +file_magic_cmd='$MAGIC_CMD' +file_magic_glob='' +want_nocaseglob='no' +sharedlib_from_linklib_cmd='printf %s\n' +AR='ar' +AR_FLAGS='cru' +archiver_list_spec='@' +STRIP='strip' +RANLIB='ranlib' +old_postinstall_cmds='chmod 644 $oldlib~$RANLIB $tool_oldlib' +old_postuninstall_cmds='' +old_archive_cmds='$AR $AR_FLAGS $oldlib$oldobjs~$RANLIB $tool_oldlib' +lock_old_archive_extraction='no' +CC='gcc' +CFLAGS='-g -O2' +compiler='g++' +GCC='yes' +lt_cv_sys_global_symbol_pipe='sed -n -e '\''s/^.*[ ]\([ABCDGIRSTW][ABCDGIRSTW]*\)[ ][ ]*\([_A-Za-z][_A-Za-z0-9]*\)$/\1 \2 \2/p'\'' | sed '\''/ __gnu_lto/d'\''' +lt_cv_sys_global_symbol_to_cdecl='sed -n -e '\''s/^T .* \(.*\)$/extern int \1();/p'\'' -e '\''s/^[ABCDGIRSTW]* .* \(.*\)$/extern char \1;/p'\''' +lt_cv_sys_global_symbol_to_c_name_address='sed -n -e '\''s/^: \([^ ]*\)[ ]*$/ {\"\1\", (void *) 0},/p'\'' -e '\''s/^[ABCDGIRSTW]* \([^ ]*\) \([^ ]*\)$/ {"\2", (void *) \&\2},/p'\''' +lt_cv_sys_global_symbol_to_c_name_address_lib_prefix='sed -n -e '\''s/^: \([^ ]*\)[ ]*$/ {\"\1\", (void *) 0},/p'\'' -e '\''s/^[ABCDGIRSTW]* \([^ ]*\) \(lib[^ ]*\)$/ {"\2", (void *) \&\2},/p'\'' -e '\''s/^[ABCDGIRSTW]* \([^ ]*\) \([^ ]*\)$/ {"lib\2", (void *) \&\2},/p'\''' +nm_file_list_spec='@' +lt_sysroot='' +objdir='.libs' +MAGIC_CMD='file' +lt_prog_compiler_no_builtin_flag=' -fno-builtin' +lt_prog_compiler_pic=' -fPIC -DPIC' +lt_prog_compiler_wl='-Wl,' +lt_prog_compiler_static='' +lt_cv_prog_compiler_c_o='yes' +need_locks='no' +MANIFEST_TOOL=':' +DSYMUTIL='' +NMEDIT='' +LIPO='' +OTOOL='' +OTOOL64='' +libext='a' +shrext_cmds='.so' +extract_expsyms_cmds='' +archive_cmds_need_lc='no' +enable_shared_with_static_runtimes='no' +export_dynamic_flag_spec='${wl}--export-dynamic' +whole_archive_flag_spec='${wl}--whole-archive$convenience ${wl}--no-whole-archive' +compiler_needs_object='no' +old_archive_from_new_cmds='' +old_archive_from_expsyms_cmds='' +archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' +archive_expsym_cmds='echo "{ global:" > $output_objdir/$libname.ver~ + cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~ + echo "local: *; };" >> $output_objdir/$libname.ver~ + $CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-version-script ${wl}$output_objdir/$libname.ver -o $lib' +module_cmds='' +module_expsym_cmds='' +with_gnu_ld='yes' +allow_undefined_flag='' +no_undefined_flag='' +hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir' +hardcode_libdir_separator='' +hardcode_direct='no' +hardcode_direct_absolute='no' +hardcode_minus_L='no' +hardcode_shlibpath_var='unsupported' +hardcode_automatic='no' +inherit_rpath='no' +link_all_deplibs='no' +always_export_symbols='no' +export_symbols_cmds='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols' +exclude_expsyms='_GLOBAL_OFFSET_TABLE_|_GLOBAL__F[ID]_.*' +include_expsyms='' +prelink_cmds='' +postlink_cmds='' +file_list_spec='' +variables_saved_for_relink='PATH LD_LIBRARY_PATH LD_RUN_PATH GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH' +need_lib_prefix='no' +need_version='no' +version_type='linux' +runpath_var='LD_RUN_PATH' +shlibpath_var='LD_LIBRARY_PATH' +shlibpath_overrides_runpath='yes' +libname_spec='lib$name' +library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' +soname_spec='${libname}${release}${shared_ext}$major' +install_override_mode='' +postinstall_cmds='' +postuninstall_cmds='' +finish_cmds='PATH="\$PATH:/sbin" ldconfig -n $libdir' +finish_eval='' +hardcode_into_libs='yes' +sys_lib_search_path_spec='/usr/lib64/gcc/x86_64-suse-linux/4.8 /usr/lib64 /lib64 /usr/x86_64-suse-linux/lib ' +sys_lib_dlsearch_path_spec='/lib /usr/lib /usr/local/lib64 /usr/local/lib /usr/lib64/R/lib /usr/lib64/apper /usr/lib64/xorg/modules /usr/lib64/graphviz /usr/lib64/graphviz/sharp /usr/lib64/graphviz/java /usr/lib64/graphviz/perl /usr/lib64/graphviz/php /usr/lib64/graphviz/ocaml /usr/lib64/graphviz/python /usr/lib64/graphviz/lua /usr/lib64/graphviz/tcl /usr/lib64/graphviz/guile /usr/lib64/graphviz/ruby /opt/kde3/lib64 /opt/kde3/lib /usr/lib64/octave/3.8.2 ' +hardcode_action='immediate' +enable_dlopen='unknown' +enable_dlopen_self='unknown' +enable_dlopen_self_static='unknown' +old_striplib='strip --strip-debug' +striplib='strip --strip-unneeded' +compiler_lib_search_dirs='' +predep_objects='' +postdep_objects='' +predeps='' +postdeps='' +compiler_lib_search_path='' +LD_CXX='/usr/x86_64-suse-linux/bin/ld -m elf_x86_64' +reload_flag_CXX=' -r' +reload_cmds_CXX='$LD$reload_flag -o $output$reload_objs' +old_archive_cmds_CXX='$AR $AR_FLAGS $oldlib$oldobjs~$RANLIB $tool_oldlib' +compiler_CXX='g++' +GCC_CXX='yes' +lt_prog_compiler_no_builtin_flag_CXX=' -fno-builtin' +lt_prog_compiler_pic_CXX=' -fPIC -DPIC' +lt_prog_compiler_wl_CXX='-Wl,' +lt_prog_compiler_static_CXX='' +lt_cv_prog_compiler_c_o_CXX='yes' +archive_cmds_need_lc_CXX='no' +enable_shared_with_static_runtimes_CXX='no' +export_dynamic_flag_spec_CXX='${wl}--export-dynamic' +whole_archive_flag_spec_CXX='${wl}--whole-archive$convenience ${wl}--no-whole-archive' +compiler_needs_object_CXX='no' +old_archive_from_new_cmds_CXX='' +old_archive_from_expsyms_cmds_CXX='' +archive_cmds_CXX='$CC $pic_flag -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib' +archive_expsym_cmds_CXX='$CC $pic_flag -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' +module_cmds_CXX='' +module_expsym_cmds_CXX='' +with_gnu_ld_CXX='yes' +allow_undefined_flag_CXX='' +no_undefined_flag_CXX='' +hardcode_libdir_flag_spec_CXX='${wl}-rpath ${wl}$libdir' +hardcode_libdir_separator_CXX='' +hardcode_direct_CXX='no' +hardcode_direct_absolute_CXX='no' +hardcode_minus_L_CXX='no' +hardcode_shlibpath_var_CXX='unsupported' +hardcode_automatic_CXX='no' +inherit_rpath_CXX='no' +link_all_deplibs_CXX='no' +always_export_symbols_CXX='no' +export_symbols_cmds_CXX='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols' +exclude_expsyms_CXX='_GLOBAL_OFFSET_TABLE_|_GLOBAL__F[ID]_.*' +include_expsyms_CXX='' +prelink_cmds_CXX='' +postlink_cmds_CXX='' +file_list_spec_CXX='' +hardcode_action_CXX='immediate' +compiler_lib_search_dirs_CXX='/usr/lib64/gcc/x86_64-suse-linux/4.8 /usr/lib64/gcc/x86_64-suse-linux/4.8/../../../../lib64 /lib/../lib64 /usr/lib/../lib64 /usr/lib64/gcc/x86_64-suse-linux/4.8/../../../../x86_64-suse-linux/lib /usr/lib64/gcc/x86_64-suse-linux/4.8/../../..' +predep_objects_CXX='/usr/lib64/gcc/x86_64-suse-linux/4.8/../../../../lib64/crti.o /usr/lib64/gcc/x86_64-suse-linux/4.8/crtbeginS.o' +postdep_objects_CXX='/usr/lib64/gcc/x86_64-suse-linux/4.8/crtendS.o /usr/lib64/gcc/x86_64-suse-linux/4.8/../../../../lib64/crtn.o' +predeps_CXX='' +postdeps_CXX='-lstdc++ -lm -lgcc_s -lc -lgcc_s' +compiler_lib_search_path_CXX='-L/usr/lib64/gcc/x86_64-suse-linux/4.8 -L/usr/lib64/gcc/x86_64-suse-linux/4.8/../../../../lib64 -L/lib/../lib64 -L/usr/lib/../lib64 -L/usr/lib64/gcc/x86_64-suse-linux/4.8/../../../../x86_64-suse-linux/lib -L/usr/lib64/gcc/x86_64-suse-linux/4.8/../../..' + +LTCC='gcc' +LTCFLAGS='-g -O2' +compiler='gcc' + +# A function that is used when there is no print builtin or printf. +func_fallback_echo () +{ + eval 'cat <<_LTECHO_EOF +$1 +_LTECHO_EOF' +} + +# Quote evaled strings. +for var in AS DLLTOOL OBJDUMP SHELL ECHO PATH_SEPARATOR SED GREP EGREP FGREP LD NM LN_S lt_SP2NL lt_NL2SP reload_flag deplibs_check_method file_magic_cmd file_magic_glob want_nocaseglob sharedlib_from_linklib_cmd AR AR_FLAGS archiver_list_spec STRIP RANLIB CC CFLAGS compiler lt_cv_sys_global_symbol_pipe lt_cv_sys_global_symbol_to_cdecl lt_cv_sys_global_symbol_to_c_name_address lt_cv_sys_global_symbol_to_c_name_address_lib_prefix nm_file_list_spec lt_prog_compiler_no_builtin_flag lt_prog_compiler_pic lt_prog_compiler_wl lt_prog_compiler_static lt_cv_prog_compiler_c_o need_locks MANIFEST_TOOL DSYMUTIL NMEDIT LIPO OTOOL OTOOL64 shrext_cmds export_dynamic_flag_spec whole_archive_flag_spec compiler_needs_object with_gnu_ld allow_undefined_flag no_undefined_flag hardcode_libdir_flag_spec hardcode_libdir_separator exclude_expsyms include_expsyms file_list_spec variables_saved_for_relink libname_spec library_names_spec soname_spec install_override_mode finish_eval old_striplib striplib compiler_lib_search_dirs predep_objects postdep_objects predeps postdeps compiler_lib_search_path LD_CXX reload_flag_CXX compiler_CXX lt_prog_compiler_no_builtin_flag_CXX lt_prog_compiler_pic_CXX lt_prog_compiler_wl_CXX lt_prog_compiler_static_CXX lt_cv_prog_compiler_c_o_CXX export_dynamic_flag_spec_CXX whole_archive_flag_spec_CXX compiler_needs_object_CXX with_gnu_ld_CXX allow_undefined_flag_CXX no_undefined_flag_CXX hardcode_libdir_flag_spec_CXX hardcode_libdir_separator_CXX exclude_expsyms_CXX include_expsyms_CXX file_list_spec_CXX compiler_lib_search_dirs_CXX predep_objects_CXX postdep_objects_CXX predeps_CXX postdeps_CXX compiler_lib_search_path_CXX; do + case `eval \\$ECHO \\""\\$$var"\\"` in + *[\\\`\"\$]*) + eval "lt_$var=\\\"\`\$ECHO \"\$$var\" | \$SED \"\$sed_quote_subst\"\`\\\"" + ;; + *) + eval "lt_$var=\\\"\$$var\\\"" + ;; + esac +done + +# Double-quote double-evaled strings. +for var in reload_cmds old_postinstall_cmds old_postuninstall_cmds old_archive_cmds extract_expsyms_cmds old_archive_from_new_cmds old_archive_from_expsyms_cmds archive_cmds archive_expsym_cmds module_cmds module_expsym_cmds export_symbols_cmds prelink_cmds postlink_cmds postinstall_cmds postuninstall_cmds finish_cmds sys_lib_search_path_spec sys_lib_dlsearch_path_spec reload_cmds_CXX old_archive_cmds_CXX old_archive_from_new_cmds_CXX old_archive_from_expsyms_cmds_CXX archive_cmds_CXX archive_expsym_cmds_CXX module_cmds_CXX module_expsym_cmds_CXX export_symbols_cmds_CXX prelink_cmds_CXX postlink_cmds_CXX; do + case `eval \\$ECHO \\""\\$$var"\\"` in + *[\\\`\"\$]*) + eval "lt_$var=\\\"\`\$ECHO \"\$$var\" | \$SED -e \"\$double_quote_subst\" -e \"\$sed_quote_subst\" -e \"\$delay_variable_subst\"\`\\\"" + ;; + *) + eval "lt_$var=\\\"\$$var\\\"" + ;; + esac +done + +ac_aux_dir='config' +xsi_shell='yes' +lt_shell_append='yes' + +# See if we are running on zsh, and set the options which allow our +# commands through without removal of \ escapes INIT. +if test -n "${ZSH_VERSION+set}" ; then + setopt NO_GLOB_SUBST +fi + + + PACKAGE='libodb-sqlite' + VERSION='2.4.0' + TIMESTAMP='' + RM='rm -f' + ofile='libtool' + + + + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: creating $ofile" >&5 +$as_echo "$as_me: creating $ofile" >&6;} + + + # See if we are running on zsh, and set the options which allow our + # commands through without removal of \ escapes. + if test -n "${ZSH_VERSION+set}" ; then + setopt NO_GLOB_SUBST + fi + + cfgfile="${ofile}T" + trap "$RM \"$cfgfile\"; exit 1" 1 2 15 + $RM "$cfgfile" + + cat <<_LT_EOF >> "$cfgfile" +#! $SHELL + +# `$ECHO "$ofile" | sed 's%^.*/%%'` - Provide generalized library-building support services. +# Generated automatically by $as_me ($PACKAGE$TIMESTAMP) $VERSION +# Libtool was configured on host `(hostname || uname -n) 2>/dev/null | sed 1q`: +# NOTE: Changes made to this file will be lost: look at ltmain.sh. +# +# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, +# 2006, 2007, 2008, 2009, 2010, 2011 Free Software +# Foundation, Inc. +# Written by Gordon Matzigkeit, 1996 +# +# This file is part of GNU Libtool. +# +# GNU Libtool is free software; you can redistribute it and/or +# modify it under the terms of the GNU General Public License as +# published by the Free Software Foundation; either version 2 of +# the License, or (at your option) any later version. +# +# As a special exception to the GNU General Public License, +# if you distribute this file as part of a program or library that +# is built using GNU Libtool, you may include this file under the +# same distribution terms that you use for the rest of that program. +# +# GNU Libtool is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with GNU Libtool; see the file COPYING. If not, a copy +# can be downloaded from http://www.gnu.org/licenses/gpl.html, or +# obtained by writing to the Free Software Foundation, Inc., +# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + + +# The names of the tagged configurations supported by this script. +available_tags="CXX " + +# ### BEGIN LIBTOOL CONFIG + +# Which release of libtool.m4 was used? +macro_version=$macro_version +macro_revision=$macro_revision + +# Assembler program. +AS=$lt_AS + +# DLL creation program. +DLLTOOL=$lt_DLLTOOL + +# Object dumper program. +OBJDUMP=$lt_OBJDUMP + +# Whether or not to build shared libraries. +build_libtool_libs=$enable_shared + +# Whether or not to build static libraries. +build_old_libs=$enable_static + +# What type of objects to build. +pic_mode=$pic_mode + +# Whether or not to optimize for fast installation. +fast_install=$enable_fast_install + +# Shell to use when invoking shell scripts. +SHELL=$lt_SHELL + +# An echo program that protects backslashes. +ECHO=$lt_ECHO + +# The PATH separator for the build system. +PATH_SEPARATOR=$lt_PATH_SEPARATOR + +# The host system. +host_alias=$host_alias +host=$host +host_os=$host_os + +# The build system. +build_alias=$build_alias +build=$build +build_os=$build_os + +# A sed program that does not truncate output. +SED=$lt_SED + +# Sed that helps us avoid accidentally triggering echo(1) options like -n. +Xsed="\$SED -e 1s/^X//" + +# A grep program that handles long lines. +GREP=$lt_GREP + +# An ERE matcher. +EGREP=$lt_EGREP + +# A literal string matcher. +FGREP=$lt_FGREP + +# A BSD- or MS-compatible name lister. +NM=$lt_NM + +# Whether we need soft or hard links. +LN_S=$lt_LN_S + +# What is the maximum length of a command? +max_cmd_len=$max_cmd_len + +# Object file suffix (normally "o"). +objext=$ac_objext + +# Executable file suffix (normally ""). +exeext=$exeext + +# whether the shell understands "unset". +lt_unset=$lt_unset + +# turn spaces into newlines. +SP2NL=$lt_lt_SP2NL + +# turn newlines into spaces. +NL2SP=$lt_lt_NL2SP + +# convert \$build file names to \$host format. +to_host_file_cmd=$lt_cv_to_host_file_cmd + +# convert \$build files to toolchain format. +to_tool_file_cmd=$lt_cv_to_tool_file_cmd + +# Method to check whether dependent libraries are shared objects. +deplibs_check_method=$lt_deplibs_check_method + +# Command to use when deplibs_check_method = "file_magic". +file_magic_cmd=$lt_file_magic_cmd + +# How to find potential files when deplibs_check_method = "file_magic". +file_magic_glob=$lt_file_magic_glob + +# Find potential files using nocaseglob when deplibs_check_method = "file_magic". +want_nocaseglob=$lt_want_nocaseglob + +# Command to associate shared and link libraries. +sharedlib_from_linklib_cmd=$lt_sharedlib_from_linklib_cmd + +# The archiver. +AR=$lt_AR + +# Flags to create an archive. +AR_FLAGS=$lt_AR_FLAGS + +# How to feed a file listing to the archiver. +archiver_list_spec=$lt_archiver_list_spec + +# A symbol stripping program. +STRIP=$lt_STRIP + +# Commands used to install an old-style archive. +RANLIB=$lt_RANLIB +old_postinstall_cmds=$lt_old_postinstall_cmds +old_postuninstall_cmds=$lt_old_postuninstall_cmds + +# Whether to use a lock for old archive extraction. +lock_old_archive_extraction=$lock_old_archive_extraction + +# A C compiler. +LTCC=$lt_CC + +# LTCC compiler flags. +LTCFLAGS=$lt_CFLAGS + +# Take the output of nm and produce a listing of raw symbols and C names. +global_symbol_pipe=$lt_lt_cv_sys_global_symbol_pipe + +# Transform the output of nm in a proper C declaration. +global_symbol_to_cdecl=$lt_lt_cv_sys_global_symbol_to_cdecl + +# Transform the output of nm in a C name address pair. +global_symbol_to_c_name_address=$lt_lt_cv_sys_global_symbol_to_c_name_address + +# Transform the output of nm in a C name address pair when lib prefix is needed. +global_symbol_to_c_name_address_lib_prefix=$lt_lt_cv_sys_global_symbol_to_c_name_address_lib_prefix + +# Specify filename containing input files for \$NM. +nm_file_list_spec=$lt_nm_file_list_spec + +# The root where to search for dependent libraries,and in which our libraries should be installed. +lt_sysroot=$lt_sysroot + +# The name of the directory that contains temporary libtool files. +objdir=$objdir + +# Used to examine libraries when file_magic_cmd begins with "file". +MAGIC_CMD=$MAGIC_CMD + +# Must we lock files when doing compilation? +need_locks=$lt_need_locks + +# Manifest tool. +MANIFEST_TOOL=$lt_MANIFEST_TOOL + +# Tool to manipulate archived DWARF debug symbol files on Mac OS X. +DSYMUTIL=$lt_DSYMUTIL + +# Tool to change global to local symbols on Mac OS X. +NMEDIT=$lt_NMEDIT + +# Tool to manipulate fat objects and archives on Mac OS X. +LIPO=$lt_LIPO + +# ldd/readelf like tool for Mach-O binaries on Mac OS X. +OTOOL=$lt_OTOOL + +# ldd/readelf like tool for 64 bit Mach-O binaries on Mac OS X 10.4. +OTOOL64=$lt_OTOOL64 + +# Old archive suffix (normally "a"). +libext=$libext + +# Shared library suffix (normally ".so"). +shrext_cmds=$lt_shrext_cmds + +# The commands to extract the exported symbol list from a shared archive. +extract_expsyms_cmds=$lt_extract_expsyms_cmds + +# Variables whose values should be saved in libtool wrapper scripts and +# restored at link time. +variables_saved_for_relink=$lt_variables_saved_for_relink + +# Do we need the "lib" prefix for modules? +need_lib_prefix=$need_lib_prefix + +# Do we need a version for libraries? +need_version=$need_version + +# Library versioning type. +version_type=$version_type + +# Shared library runtime path variable. +runpath_var=$runpath_var + +# Shared library path variable. +shlibpath_var=$shlibpath_var + +# Is shlibpath searched before the hard-coded library search path? +shlibpath_overrides_runpath=$shlibpath_overrides_runpath + +# Format of library name prefix. +libname_spec=$lt_libname_spec + +# List of archive names. First name is the real one, the rest are links. +# The last name is the one that the linker finds with -lNAME +library_names_spec=$lt_library_names_spec + +# The coded name of the library, if different from the real name. +soname_spec=$lt_soname_spec + +# Permission mode override for installation of shared libraries. +install_override_mode=$lt_install_override_mode + +# Command to use after installation of a shared archive. +postinstall_cmds=$lt_postinstall_cmds + +# Command to use after uninstallation of a shared archive. +postuninstall_cmds=$lt_postuninstall_cmds + +# Commands used to finish a libtool library installation in a directory. +finish_cmds=$lt_finish_cmds + +# As "finish_cmds", except a single script fragment to be evaled but +# not shown. +finish_eval=$lt_finish_eval + +# Whether we should hardcode library paths into libraries. +hardcode_into_libs=$hardcode_into_libs + +# Compile-time system search path for libraries. +sys_lib_search_path_spec=$lt_sys_lib_search_path_spec + +# Run-time system search path for libraries. +sys_lib_dlsearch_path_spec=$lt_sys_lib_dlsearch_path_spec + +# Whether dlopen is supported. +dlopen_support=$enable_dlopen + +# Whether dlopen of programs is supported. +dlopen_self=$enable_dlopen_self + +# Whether dlopen of statically linked programs is supported. +dlopen_self_static=$enable_dlopen_self_static + +# Commands to strip libraries. +old_striplib=$lt_old_striplib +striplib=$lt_striplib + + +# The linker used to build libraries. +LD=$lt_LD + +# How to create reloadable object files. +reload_flag=$lt_reload_flag +reload_cmds=$lt_reload_cmds + +# Commands used to build an old-style archive. +old_archive_cmds=$lt_old_archive_cmds + +# A language specific compiler. +CC=$lt_compiler + +# Is the compiler the GNU compiler? +with_gcc=$GCC + +# Compiler flag to turn off builtin functions. +no_builtin_flag=$lt_lt_prog_compiler_no_builtin_flag + +# Additional compiler flags for building library objects. +pic_flag=$lt_lt_prog_compiler_pic + +# How to pass a linker flag through the compiler. +wl=$lt_lt_prog_compiler_wl + +# Compiler flag to prevent dynamic linking. +link_static_flag=$lt_lt_prog_compiler_static + +# Does compiler simultaneously support -c and -o options? +compiler_c_o=$lt_lt_cv_prog_compiler_c_o + +# Whether or not to add -lc for building shared libraries. +build_libtool_need_lc=$archive_cmds_need_lc + +# Whether or not to disallow shared libs when runtime libs are static. +allow_libtool_libs_with_static_runtimes=$enable_shared_with_static_runtimes + +# Compiler flag to allow reflexive dlopens. +export_dynamic_flag_spec=$lt_export_dynamic_flag_spec + +# Compiler flag to generate shared objects directly from archives. +whole_archive_flag_spec=$lt_whole_archive_flag_spec + +# Whether the compiler copes with passing no objects directly. +compiler_needs_object=$lt_compiler_needs_object + +# Create an old-style archive from a shared archive. +old_archive_from_new_cmds=$lt_old_archive_from_new_cmds + +# Create a temporary old-style archive to link instead of a shared archive. +old_archive_from_expsyms_cmds=$lt_old_archive_from_expsyms_cmds + +# Commands used to build a shared archive. +archive_cmds=$lt_archive_cmds +archive_expsym_cmds=$lt_archive_expsym_cmds + +# Commands used to build a loadable module if different from building +# a shared archive. +module_cmds=$lt_module_cmds +module_expsym_cmds=$lt_module_expsym_cmds + +# Whether we are building with GNU ld or not. +with_gnu_ld=$lt_with_gnu_ld + +# Flag that allows shared libraries with undefined symbols to be built. +allow_undefined_flag=$lt_allow_undefined_flag + +# Flag that enforces no undefined symbols. +no_undefined_flag=$lt_no_undefined_flag + +# Flag to hardcode \$libdir into a binary during linking. +# This must work even if \$libdir does not exist +hardcode_libdir_flag_spec=$lt_hardcode_libdir_flag_spec + +# Whether we need a single "-rpath" flag with a separated argument. +hardcode_libdir_separator=$lt_hardcode_libdir_separator + +# Set to "yes" if using DIR/libNAME\${shared_ext} during linking hardcodes +# DIR into the resulting binary. +hardcode_direct=$hardcode_direct + +# Set to "yes" if using DIR/libNAME\${shared_ext} during linking hardcodes +# DIR into the resulting binary and the resulting library dependency is +# "absolute",i.e impossible to change by setting \${shlibpath_var} if the +# library is relocated. +hardcode_direct_absolute=$hardcode_direct_absolute + +# Set to "yes" if using the -LDIR flag during linking hardcodes DIR +# into the resulting binary. +hardcode_minus_L=$hardcode_minus_L + +# Set to "yes" if using SHLIBPATH_VAR=DIR during linking hardcodes DIR +# into the resulting binary. +hardcode_shlibpath_var=$hardcode_shlibpath_var + +# Set to "yes" if building a shared library automatically hardcodes DIR +# into the library and all subsequent libraries and executables linked +# against it. +hardcode_automatic=$hardcode_automatic + +# Set to yes if linker adds runtime paths of dependent libraries +# to runtime path list. +inherit_rpath=$inherit_rpath + +# Whether libtool must link a program against all its dependency libraries. +link_all_deplibs=$link_all_deplibs + +# Set to "yes" if exported symbols are required. +always_export_symbols=$always_export_symbols + +# The commands to list exported symbols. +export_symbols_cmds=$lt_export_symbols_cmds + +# Symbols that should not be listed in the preloaded symbols. +exclude_expsyms=$lt_exclude_expsyms + +# Symbols that must always be exported. +include_expsyms=$lt_include_expsyms + +# Commands necessary for linking programs (against libraries) with templates. +prelink_cmds=$lt_prelink_cmds + +# Commands necessary for finishing linking programs. +postlink_cmds=$lt_postlink_cmds + +# Specify filename containing input files. +file_list_spec=$lt_file_list_spec + +# How to hardcode a shared library path into an executable. +hardcode_action=$hardcode_action + +# The directories searched by this compiler when creating a shared library. +compiler_lib_search_dirs=$lt_compiler_lib_search_dirs + +# Dependencies to place before and after the objects being linked to +# create a shared library. +predep_objects=$lt_predep_objects +postdep_objects=$lt_postdep_objects +predeps=$lt_predeps +postdeps=$lt_postdeps + +# The library search path used internally by the compiler when linking +# a shared library. +compiler_lib_search_path=$lt_compiler_lib_search_path + +# ### END LIBTOOL CONFIG + +_LT_EOF + + case $host_os in + aix3*) + cat <<\_LT_EOF >> "$cfgfile" +# AIX sometimes has problems with the GCC collect2 program. For some +# reason, if we set the COLLECT_NAMES environment variable, the problems +# vanish in a puff of smoke. +if test "X${COLLECT_NAMES+set}" != Xset; then + COLLECT_NAMES= + export COLLECT_NAMES +fi +_LT_EOF + ;; + esac + + +ltmain="$ac_aux_dir/ltmain.sh" + + + # We use sed instead of cat because bash on DJGPP gets confused if + # if finds mixed CR/LF and LF-only lines. Since sed operates in + # text mode, it properly converts lines to CR/LF. This bash problem + # is reportedly fixed, but why not run on old versions too? + sed '$q' "$ltmain" >> "$cfgfile" \ + || (rm -f "$cfgfile"; exit 1) + + if test x"$xsi_shell" = xyes; then + sed -e '/^func_dirname ()$/,/^} # func_dirname /c\ +func_dirname ()\ +{\ +\ case ${1} in\ +\ */*) func_dirname_result="${1%/*}${2}" ;;\ +\ * ) func_dirname_result="${3}" ;;\ +\ esac\ +} # Extended-shell func_dirname implementation' "$cfgfile" > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") +test 0 -eq $? || _lt_function_replace_fail=: + + + sed -e '/^func_basename ()$/,/^} # func_basename /c\ +func_basename ()\ +{\ +\ func_basename_result="${1##*/}"\ +} # Extended-shell func_basename implementation' "$cfgfile" > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") +test 0 -eq $? || _lt_function_replace_fail=: + + + sed -e '/^func_dirname_and_basename ()$/,/^} # func_dirname_and_basename /c\ +func_dirname_and_basename ()\ +{\ +\ case ${1} in\ +\ */*) func_dirname_result="${1%/*}${2}" ;;\ +\ * ) func_dirname_result="${3}" ;;\ +\ esac\ +\ func_basename_result="${1##*/}"\ +} # Extended-shell func_dirname_and_basename implementation' "$cfgfile" > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") +test 0 -eq $? || _lt_function_replace_fail=: + + + sed -e '/^func_stripname ()$/,/^} # func_stripname /c\ +func_stripname ()\ +{\ +\ # pdksh 5.2.14 does not do ${X%$Y} correctly if both X and Y are\ +\ # positional parameters, so assign one to ordinary parameter first.\ +\ func_stripname_result=${3}\ +\ func_stripname_result=${func_stripname_result#"${1}"}\ +\ func_stripname_result=${func_stripname_result%"${2}"}\ +} # Extended-shell func_stripname implementation' "$cfgfile" > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") +test 0 -eq $? || _lt_function_replace_fail=: + + + sed -e '/^func_split_long_opt ()$/,/^} # func_split_long_opt /c\ +func_split_long_opt ()\ +{\ +\ func_split_long_opt_name=${1%%=*}\ +\ func_split_long_opt_arg=${1#*=}\ +} # Extended-shell func_split_long_opt implementation' "$cfgfile" > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") +test 0 -eq $? || _lt_function_replace_fail=: + + + sed -e '/^func_split_short_opt ()$/,/^} # func_split_short_opt /c\ +func_split_short_opt ()\ +{\ +\ func_split_short_opt_arg=${1#??}\ +\ func_split_short_opt_name=${1%"$func_split_short_opt_arg"}\ +} # Extended-shell func_split_short_opt implementation' "$cfgfile" > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") +test 0 -eq $? || _lt_function_replace_fail=: + + + sed -e '/^func_lo2o ()$/,/^} # func_lo2o /c\ +func_lo2o ()\ +{\ +\ case ${1} in\ +\ *.lo) func_lo2o_result=${1%.lo}.${objext} ;;\ +\ *) func_lo2o_result=${1} ;;\ +\ esac\ +} # Extended-shell func_lo2o implementation' "$cfgfile" > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") +test 0 -eq $? || _lt_function_replace_fail=: + + + sed -e '/^func_xform ()$/,/^} # func_xform /c\ +func_xform ()\ +{\ + func_xform_result=${1%.*}.lo\ +} # Extended-shell func_xform implementation' "$cfgfile" > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") +test 0 -eq $? || _lt_function_replace_fail=: + + + sed -e '/^func_arith ()$/,/^} # func_arith /c\ +func_arith ()\ +{\ + func_arith_result=$(( $* ))\ +} # Extended-shell func_arith implementation' "$cfgfile" > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") +test 0 -eq $? || _lt_function_replace_fail=: + + + sed -e '/^func_len ()$/,/^} # func_len /c\ +func_len ()\ +{\ + func_len_result=${#1}\ +} # Extended-shell func_len implementation' "$cfgfile" > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") +test 0 -eq $? || _lt_function_replace_fail=: + +fi + +if test x"$lt_shell_append" = xyes; then + sed -e '/^func_append ()$/,/^} # func_append /c\ +func_append ()\ +{\ + eval "${1}+=\\${2}"\ +} # Extended-shell func_append implementation' "$cfgfile" > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") +test 0 -eq $? || _lt_function_replace_fail=: + + + sed -e '/^func_append_quoted ()$/,/^} # func_append_quoted /c\ +func_append_quoted ()\ +{\ +\ func_quote_for_eval "${2}"\ +\ eval "${1}+=\\\\ \\$func_quote_for_eval_result"\ +} # Extended-shell func_append_quoted implementation' "$cfgfile" > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") +test 0 -eq $? || _lt_function_replace_fail=: + + + # Save a `func_append' function call where possible by direct use of '+=' + sed -e 's%func_append \([a-zA-Z_]\{1,\}\) "%\1+="%g' $cfgfile > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") + test 0 -eq $? || _lt_function_replace_fail=: +else + # Save a `func_append' function call even when '+=' is not available + sed -e 's%func_append \([a-zA-Z_]\{1,\}\) "%\1="$\1%g' $cfgfile > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") + test 0 -eq $? || _lt_function_replace_fail=: +fi + +if test x"$_lt_function_replace_fail" = x":"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Unable to substitute extended shell functions in $ofile" >&5 +$as_echo "$as_me: WARNING: Unable to substitute extended shell functions in $ofile" >&2;} +fi + + + mv -f "$cfgfile" "$ofile" || + (rm -f "$ofile" && cp "$cfgfile" "$ofile" && rm -f "$cfgfile") + chmod +x "$ofile" + + + cat <<_LT_EOF >> "$ofile" + +# ### BEGIN LIBTOOL TAG CONFIG: CXX + +# The linker used to build libraries. +LD=$lt_LD_CXX + +# How to create reloadable object files. +reload_flag=$lt_reload_flag_CXX +reload_cmds=$lt_reload_cmds_CXX + +# Commands used to build an old-style archive. +old_archive_cmds=$lt_old_archive_cmds_CXX + +# A language specific compiler. +CC=$lt_compiler_CXX + +# Is the compiler the GNU compiler? +with_gcc=$GCC_CXX + +# Compiler flag to turn off builtin functions. +no_builtin_flag=$lt_lt_prog_compiler_no_builtin_flag_CXX + +# Additional compiler flags for building library objects. +pic_flag=$lt_lt_prog_compiler_pic_CXX + +# How to pass a linker flag through the compiler. +wl=$lt_lt_prog_compiler_wl_CXX + +# Compiler flag to prevent dynamic linking. +link_static_flag=$lt_lt_prog_compiler_static_CXX + +# Does compiler simultaneously support -c and -o options? +compiler_c_o=$lt_lt_cv_prog_compiler_c_o_CXX + +# Whether or not to add -lc for building shared libraries. +build_libtool_need_lc=$archive_cmds_need_lc_CXX + +# Whether or not to disallow shared libs when runtime libs are static. +allow_libtool_libs_with_static_runtimes=$enable_shared_with_static_runtimes_CXX + +# Compiler flag to allow reflexive dlopens. +export_dynamic_flag_spec=$lt_export_dynamic_flag_spec_CXX + +# Compiler flag to generate shared objects directly from archives. +whole_archive_flag_spec=$lt_whole_archive_flag_spec_CXX + +# Whether the compiler copes with passing no objects directly. +compiler_needs_object=$lt_compiler_needs_object_CXX + +# Create an old-style archive from a shared archive. +old_archive_from_new_cmds=$lt_old_archive_from_new_cmds_CXX + +# Create a temporary old-style archive to link instead of a shared archive. +old_archive_from_expsyms_cmds=$lt_old_archive_from_expsyms_cmds_CXX + +# Commands used to build a shared archive. +archive_cmds=$lt_archive_cmds_CXX +archive_expsym_cmds=$lt_archive_expsym_cmds_CXX + +# Commands used to build a loadable module if different from building +# a shared archive. +module_cmds=$lt_module_cmds_CXX +module_expsym_cmds=$lt_module_expsym_cmds_CXX + +# Whether we are building with GNU ld or not. +with_gnu_ld=$lt_with_gnu_ld_CXX + +# Flag that allows shared libraries with undefined symbols to be built. +allow_undefined_flag=$lt_allow_undefined_flag_CXX + +# Flag that enforces no undefined symbols. +no_undefined_flag=$lt_no_undefined_flag_CXX + +# Flag to hardcode \$libdir into a binary during linking. +# This must work even if \$libdir does not exist +hardcode_libdir_flag_spec=$lt_hardcode_libdir_flag_spec_CXX + +# Whether we need a single "-rpath" flag with a separated argument. +hardcode_libdir_separator=$lt_hardcode_libdir_separator_CXX + +# Set to "yes" if using DIR/libNAME\${shared_ext} during linking hardcodes +# DIR into the resulting binary. +hardcode_direct=$hardcode_direct_CXX + +# Set to "yes" if using DIR/libNAME\${shared_ext} during linking hardcodes +# DIR into the resulting binary and the resulting library dependency is +# "absolute",i.e impossible to change by setting \${shlibpath_var} if the +# library is relocated. +hardcode_direct_absolute=$hardcode_direct_absolute_CXX + +# Set to "yes" if using the -LDIR flag during linking hardcodes DIR +# into the resulting binary. +hardcode_minus_L=$hardcode_minus_L_CXX + +# Set to "yes" if using SHLIBPATH_VAR=DIR during linking hardcodes DIR +# into the resulting binary. +hardcode_shlibpath_var=$hardcode_shlibpath_var_CXX + +# Set to "yes" if building a shared library automatically hardcodes DIR +# into the library and all subsequent libraries and executables linked +# against it. +hardcode_automatic=$hardcode_automatic_CXX + +# Set to yes if linker adds runtime paths of dependent libraries +# to runtime path list. +inherit_rpath=$inherit_rpath_CXX + +# Whether libtool must link a program against all its dependency libraries. +link_all_deplibs=$link_all_deplibs_CXX + +# Set to "yes" if exported symbols are required. +always_export_symbols=$always_export_symbols_CXX + +# The commands to list exported symbols. +export_symbols_cmds=$lt_export_symbols_cmds_CXX + +# Symbols that should not be listed in the preloaded symbols. +exclude_expsyms=$lt_exclude_expsyms_CXX + +# Symbols that must always be exported. +include_expsyms=$lt_include_expsyms_CXX + +# Commands necessary for linking programs (against libraries) with templates. +prelink_cmds=$lt_prelink_cmds_CXX + +# Commands necessary for finishing linking programs. +postlink_cmds=$lt_postlink_cmds_CXX + +# Specify filename containing input files. +file_list_spec=$lt_file_list_spec_CXX + +# How to hardcode a shared library path into an executable. +hardcode_action=$hardcode_action_CXX + +# The directories searched by this compiler when creating a shared library. +compiler_lib_search_dirs=$lt_compiler_lib_search_dirs_CXX + +# Dependencies to place before and after the objects being linked to +# create a shared library. +predep_objects=$lt_predep_objects_CXX +postdep_objects=$lt_postdep_objects_CXX +predeps=$lt_predeps_CXX +postdeps=$lt_postdeps_CXX + +# The library search path used internally by the compiler when linking +# a shared library. +compiler_lib_search_path=$lt_compiler_lib_search_path_CXX + +# ### END LIBTOOL TAG CONFIG: CXX +_LT_EOF + + +as_fn_exit 0 diff --git a/third-party/odb/libodb-sqlite-2.4.0/config/ar-lib b/third-party/odb/libodb-sqlite-2.4.0/config/ar-lib new file mode 100755 index 0000000..67f5f36 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/config/ar-lib @@ -0,0 +1,270 @@ +#! /bin/sh +# Wrapper for Microsoft lib.exe + +me=ar-lib +scriptversion=2012-03-01.08; # UTC + +# Copyright (C) 2010-2012 Free Software Foundation, Inc. +# Written by Peter Rosin . +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2, or (at your option) +# any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + +# As a special exception to the GNU General Public License, if you +# distribute this file as part of a program that contains a +# configuration script generated by Autoconf, you may include it under +# the same distribution terms that you use for the rest of that program. + +# This file is maintained in Automake, please report +# bugs to or send patches to +# . + + +# func_error message +func_error () +{ + echo "$me: $1" 1>&2 + exit 1 +} + +file_conv= + +# func_file_conv build_file +# Convert a $build file to $host form and store it in $file +# Currently only supports Windows hosts. +func_file_conv () +{ + file=$1 + case $file in + / | /[!/]*) # absolute file, and not a UNC file + if test -z "$file_conv"; then + # lazily determine how to convert abs files + case `uname -s` in + MINGW*) + file_conv=mingw + ;; + CYGWIN*) + file_conv=cygwin + ;; + *) + file_conv=wine + ;; + esac + fi + case $file_conv in + mingw) + file=`cmd //C echo "$file " | sed -e 's/"\(.*\) " *$/\1/'` + ;; + cygwin) + file=`cygpath -m "$file" || echo "$file"` + ;; + wine) + file=`winepath -w "$file" || echo "$file"` + ;; + esac + ;; + esac +} + +# func_at_file at_file operation archive +# Iterate over all members in AT_FILE performing OPERATION on ARCHIVE +# for each of them. +# When interpreting the content of the @FILE, do NOT use func_file_conv, +# since the user would need to supply preconverted file names to +# binutils ar, at least for MinGW. +func_at_file () +{ + operation=$2 + archive=$3 + at_file_contents=`cat "$1"` + eval set x "$at_file_contents" + shift + + for member + do + $AR -NOLOGO $operation:"$member" "$archive" || exit $? + done +} + +case $1 in + '') + func_error "no command. Try '$0 --help' for more information." + ;; + -h | --h*) + cat <. +# +# As a special exception to the GNU General Public License, if you +# distribute this file as part of a program that contains a +# configuration script generated by Autoconf, you may include it under +# the same distribution terms that you use for the rest of that +# program. This Exception is an additional permission under section 7 +# of the GNU General Public License, version 3 ("GPLv3"). +# +# Originally written by Per Bothner. +# +# You can get the latest version of this script from: +# http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.guess;hb=HEAD +# +# Please send patches with a ChangeLog entry to config-patches@gnu.org. + + +me=`echo "$0" | sed -e 's,.*/,,'` + +usage="\ +Usage: $0 [OPTION] + +Output the configuration name of the system \`$me' is run on. + +Operation modes: + -h, --help print this help, then exit + -t, --time-stamp print date of last modification, then exit + -v, --version print version number, then exit + +Report bugs and patches to ." + +version="\ +GNU config.guess ($timestamp) + +Originally written by Per Bothner. +Copyright 1992-2014 Free Software Foundation, Inc. + +This is free software; see the source for copying conditions. There is NO +warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE." + +help=" +Try \`$me --help' for more information." + +# Parse command line +while test $# -gt 0 ; do + case $1 in + --time-stamp | --time* | -t ) + echo "$timestamp" ; exit ;; + --version | -v ) + echo "$version" ; exit ;; + --help | --h* | -h ) + echo "$usage"; exit ;; + -- ) # Stop option processing + shift; break ;; + - ) # Use stdin as input. + break ;; + -* ) + echo "$me: invalid option $1$help" >&2 + exit 1 ;; + * ) + break ;; + esac +done + +if test $# != 0; then + echo "$me: too many arguments$help" >&2 + exit 1 +fi + +trap 'exit 1' 1 2 15 + +# CC_FOR_BUILD -- compiler used by this script. Note that the use of a +# compiler to aid in system detection is discouraged as it requires +# temporary files to be created and, as you can see below, it is a +# headache to deal with in a portable fashion. + +# Historically, `CC_FOR_BUILD' used to be named `HOST_CC'. We still +# use `HOST_CC' if defined, but it is deprecated. + +# Portable tmp directory creation inspired by the Autoconf team. + +set_cc_for_build=' +trap "exitcode=\$?; (rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null) && exit \$exitcode" 0 ; +trap "rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null; exit 1" 1 2 13 15 ; +: ${TMPDIR=/tmp} ; + { tmp=`(umask 077 && mktemp -d "$TMPDIR/cgXXXXXX") 2>/dev/null` && test -n "$tmp" && test -d "$tmp" ; } || + { test -n "$RANDOM" && tmp=$TMPDIR/cg$$-$RANDOM && (umask 077 && mkdir $tmp) ; } || + { tmp=$TMPDIR/cg-$$ && (umask 077 && mkdir $tmp) && echo "Warning: creating insecure temp directory" >&2 ; } || + { echo "$me: cannot create a temporary directory in $TMPDIR" >&2 ; exit 1 ; } ; +dummy=$tmp/dummy ; +tmpfiles="$dummy.c $dummy.o $dummy.rel $dummy" ; +case $CC_FOR_BUILD,$HOST_CC,$CC in + ,,) echo "int x;" > $dummy.c ; + for c in cc gcc c89 c99 ; do + if ($c -c -o $dummy.o $dummy.c) >/dev/null 2>&1 ; then + CC_FOR_BUILD="$c"; break ; + fi ; + done ; + if test x"$CC_FOR_BUILD" = x ; then + CC_FOR_BUILD=no_compiler_found ; + fi + ;; + ,,*) CC_FOR_BUILD=$CC ;; + ,*,*) CC_FOR_BUILD=$HOST_CC ;; +esac ; set_cc_for_build= ;' + +# This is needed to find uname on a Pyramid OSx when run in the BSD universe. +# (ghazi@noc.rutgers.edu 1994-08-24) +if (test -f /.attbin/uname) >/dev/null 2>&1 ; then + PATH=$PATH:/.attbin ; export PATH +fi + +UNAME_MACHINE=`(uname -m) 2>/dev/null` || UNAME_MACHINE=unknown +UNAME_RELEASE=`(uname -r) 2>/dev/null` || UNAME_RELEASE=unknown +UNAME_SYSTEM=`(uname -s) 2>/dev/null` || UNAME_SYSTEM=unknown +UNAME_VERSION=`(uname -v) 2>/dev/null` || UNAME_VERSION=unknown + +case "${UNAME_SYSTEM}" in +Linux|GNU|GNU/*) + # If the system lacks a compiler, then just pick glibc. + # We could probably try harder. + LIBC=gnu + + eval $set_cc_for_build + cat <<-EOF > $dummy.c + #include + #if defined(__UCLIBC__) + LIBC=uclibc + #elif defined(__dietlibc__) + LIBC=dietlibc + #else + LIBC=gnu + #endif + EOF + eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null | grep '^LIBC' | sed 's, ,,g'` + ;; +esac + +# Note: order is significant - the case branches are not exclusive. + +case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in + *:NetBSD:*:*) + # NetBSD (nbsd) targets should (where applicable) match one or + # more of the tuples: *-*-netbsdelf*, *-*-netbsdaout*, + # *-*-netbsdecoff* and *-*-netbsd*. For targets that recently + # switched to ELF, *-*-netbsd* would select the old + # object file format. This provides both forward + # compatibility and a consistent mechanism for selecting the + # object file format. + # + # Note: NetBSD doesn't particularly care about the vendor + # portion of the name. We always set it to "unknown". + sysctl="sysctl -n hw.machine_arch" + UNAME_MACHINE_ARCH=`(/sbin/$sysctl 2>/dev/null || \ + /usr/sbin/$sysctl 2>/dev/null || echo unknown)` + case "${UNAME_MACHINE_ARCH}" in + armeb) machine=armeb-unknown ;; + arm*) machine=arm-unknown ;; + sh3el) machine=shl-unknown ;; + sh3eb) machine=sh-unknown ;; + sh5el) machine=sh5le-unknown ;; + *) machine=${UNAME_MACHINE_ARCH}-unknown ;; + esac + # The Operating System including object format, if it has switched + # to ELF recently, or will in the future. + case "${UNAME_MACHINE_ARCH}" in + arm*|i386|m68k|ns32k|sh3*|sparc|vax) + eval $set_cc_for_build + if echo __ELF__ | $CC_FOR_BUILD -E - 2>/dev/null \ + | grep -q __ELF__ + then + # Once all utilities can be ECOFF (netbsdecoff) or a.out (netbsdaout). + # Return netbsd for either. FIX? + os=netbsd + else + os=netbsdelf + fi + ;; + *) + os=netbsd + ;; + esac + # The OS release + # Debian GNU/NetBSD machines have a different userland, and + # thus, need a distinct triplet. However, they do not need + # kernel version information, so it can be replaced with a + # suitable tag, in the style of linux-gnu. + case "${UNAME_VERSION}" in + Debian*) + release='-gnu' + ;; + *) + release=`echo ${UNAME_RELEASE}|sed -e 's/[-_].*/\./'` + ;; + esac + # Since CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM: + # contains redundant information, the shorter form: + # CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM is used. + echo "${machine}-${os}${release}" + exit ;; + *:Bitrig:*:*) + UNAME_MACHINE_ARCH=`arch | sed 's/Bitrig.//'` + echo ${UNAME_MACHINE_ARCH}-unknown-bitrig${UNAME_RELEASE} + exit ;; + *:OpenBSD:*:*) + UNAME_MACHINE_ARCH=`arch | sed 's/OpenBSD.//'` + echo ${UNAME_MACHINE_ARCH}-unknown-openbsd${UNAME_RELEASE} + exit ;; + *:ekkoBSD:*:*) + echo ${UNAME_MACHINE}-unknown-ekkobsd${UNAME_RELEASE} + exit ;; + *:SolidBSD:*:*) + echo ${UNAME_MACHINE}-unknown-solidbsd${UNAME_RELEASE} + exit ;; + macppc:MirBSD:*:*) + echo powerpc-unknown-mirbsd${UNAME_RELEASE} + exit ;; + *:MirBSD:*:*) + echo ${UNAME_MACHINE}-unknown-mirbsd${UNAME_RELEASE} + exit ;; + alpha:OSF1:*:*) + case $UNAME_RELEASE in + *4.0) + UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $3}'` + ;; + *5.*) + UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $4}'` + ;; + esac + # According to Compaq, /usr/sbin/psrinfo has been available on + # OSF/1 and Tru64 systems produced since 1995. I hope that + # covers most systems running today. This code pipes the CPU + # types through head -n 1, so we only detect the type of CPU 0. + ALPHA_CPU_TYPE=`/usr/sbin/psrinfo -v | sed -n -e 's/^ The alpha \(.*\) processor.*$/\1/p' | head -n 1` + case "$ALPHA_CPU_TYPE" in + "EV4 (21064)") + UNAME_MACHINE="alpha" ;; + "EV4.5 (21064)") + UNAME_MACHINE="alpha" ;; + "LCA4 (21066/21068)") + UNAME_MACHINE="alpha" ;; + "EV5 (21164)") + UNAME_MACHINE="alphaev5" ;; + "EV5.6 (21164A)") + UNAME_MACHINE="alphaev56" ;; + "EV5.6 (21164PC)") + UNAME_MACHINE="alphapca56" ;; + "EV5.7 (21164PC)") + UNAME_MACHINE="alphapca57" ;; + "EV6 (21264)") + UNAME_MACHINE="alphaev6" ;; + "EV6.7 (21264A)") + UNAME_MACHINE="alphaev67" ;; + "EV6.8CB (21264C)") + UNAME_MACHINE="alphaev68" ;; + "EV6.8AL (21264B)") + UNAME_MACHINE="alphaev68" ;; + "EV6.8CX (21264D)") + UNAME_MACHINE="alphaev68" ;; + "EV6.9A (21264/EV69A)") + UNAME_MACHINE="alphaev69" ;; + "EV7 (21364)") + UNAME_MACHINE="alphaev7" ;; + "EV7.9 (21364A)") + UNAME_MACHINE="alphaev79" ;; + esac + # A Pn.n version is a patched version. + # A Vn.n version is a released version. + # A Tn.n version is a released field test version. + # A Xn.n version is an unreleased experimental baselevel. + # 1.2 uses "1.2" for uname -r. + echo ${UNAME_MACHINE}-dec-osf`echo ${UNAME_RELEASE} | sed -e 's/^[PVTX]//' | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` + # Reset EXIT trap before exiting to avoid spurious non-zero exit code. + exitcode=$? + trap '' 0 + exit $exitcode ;; + Alpha\ *:Windows_NT*:*) + # How do we know it's Interix rather than the generic POSIX subsystem? + # Should we change UNAME_MACHINE based on the output of uname instead + # of the specific Alpha model? + echo alpha-pc-interix + exit ;; + 21064:Windows_NT:50:3) + echo alpha-dec-winnt3.5 + exit ;; + Amiga*:UNIX_System_V:4.0:*) + echo m68k-unknown-sysv4 + exit ;; + *:[Aa]miga[Oo][Ss]:*:*) + echo ${UNAME_MACHINE}-unknown-amigaos + exit ;; + *:[Mm]orph[Oo][Ss]:*:*) + echo ${UNAME_MACHINE}-unknown-morphos + exit ;; + *:OS/390:*:*) + echo i370-ibm-openedition + exit ;; + *:z/VM:*:*) + echo s390-ibm-zvmoe + exit ;; + *:OS400:*:*) + echo powerpc-ibm-os400 + exit ;; + arm:RISC*:1.[012]*:*|arm:riscix:1.[012]*:*) + echo arm-acorn-riscix${UNAME_RELEASE} + exit ;; + arm*:riscos:*:*|arm*:RISCOS:*:*) + echo arm-unknown-riscos + exit ;; + SR2?01:HI-UX/MPP:*:* | SR8000:HI-UX/MPP:*:*) + echo hppa1.1-hitachi-hiuxmpp + exit ;; + Pyramid*:OSx*:*:* | MIS*:OSx*:*:* | MIS*:SMP_DC-OSx*:*:*) + # akee@wpdis03.wpafb.af.mil (Earle F. Ake) contributed MIS and NILE. + if test "`(/bin/universe) 2>/dev/null`" = att ; then + echo pyramid-pyramid-sysv3 + else + echo pyramid-pyramid-bsd + fi + exit ;; + NILE*:*:*:dcosx) + echo pyramid-pyramid-svr4 + exit ;; + DRS?6000:unix:4.0:6*) + echo sparc-icl-nx6 + exit ;; + DRS?6000:UNIX_SV:4.2*:7* | DRS?6000:isis:4.2*:7*) + case `/usr/bin/uname -p` in + sparc) echo sparc-icl-nx7; exit ;; + esac ;; + s390x:SunOS:*:*) + echo ${UNAME_MACHINE}-ibm-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` + exit ;; + sun4H:SunOS:5.*:*) + echo sparc-hal-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` + exit ;; + sun4*:SunOS:5.*:* | tadpole*:SunOS:5.*:*) + echo sparc-sun-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` + exit ;; + i86pc:AuroraUX:5.*:* | i86xen:AuroraUX:5.*:*) + echo i386-pc-auroraux${UNAME_RELEASE} + exit ;; + i86pc:SunOS:5.*:* | i86xen:SunOS:5.*:*) + eval $set_cc_for_build + SUN_ARCH="i386" + # If there is a compiler, see if it is configured for 64-bit objects. + # Note that the Sun cc does not turn __LP64__ into 1 like gcc does. + # This test works for both compilers. + if [ "$CC_FOR_BUILD" != 'no_compiler_found' ]; then + if (echo '#ifdef __amd64'; echo IS_64BIT_ARCH; echo '#endif') | \ + (CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) | \ + grep IS_64BIT_ARCH >/dev/null + then + SUN_ARCH="x86_64" + fi + fi + echo ${SUN_ARCH}-pc-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` + exit ;; + sun4*:SunOS:6*:*) + # According to config.sub, this is the proper way to canonicalize + # SunOS6. Hard to guess exactly what SunOS6 will be like, but + # it's likely to be more like Solaris than SunOS4. + echo sparc-sun-solaris3`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` + exit ;; + sun4*:SunOS:*:*) + case "`/usr/bin/arch -k`" in + Series*|S4*) + UNAME_RELEASE=`uname -v` + ;; + esac + # Japanese Language versions have a version number like `4.1.3-JL'. + echo sparc-sun-sunos`echo ${UNAME_RELEASE}|sed -e 's/-/_/'` + exit ;; + sun3*:SunOS:*:*) + echo m68k-sun-sunos${UNAME_RELEASE} + exit ;; + sun*:*:4.2BSD:*) + UNAME_RELEASE=`(sed 1q /etc/motd | awk '{print substr($5,1,3)}') 2>/dev/null` + test "x${UNAME_RELEASE}" = "x" && UNAME_RELEASE=3 + case "`/bin/arch`" in + sun3) + echo m68k-sun-sunos${UNAME_RELEASE} + ;; + sun4) + echo sparc-sun-sunos${UNAME_RELEASE} + ;; + esac + exit ;; + aushp:SunOS:*:*) + echo sparc-auspex-sunos${UNAME_RELEASE} + exit ;; + # The situation for MiNT is a little confusing. The machine name + # can be virtually everything (everything which is not + # "atarist" or "atariste" at least should have a processor + # > m68000). The system name ranges from "MiNT" over "FreeMiNT" + # to the lowercase version "mint" (or "freemint"). Finally + # the system name "TOS" denotes a system which is actually not + # MiNT. But MiNT is downward compatible to TOS, so this should + # be no problem. + atarist[e]:*MiNT:*:* | atarist[e]:*mint:*:* | atarist[e]:*TOS:*:*) + echo m68k-atari-mint${UNAME_RELEASE} + exit ;; + atari*:*MiNT:*:* | atari*:*mint:*:* | atarist[e]:*TOS:*:*) + echo m68k-atari-mint${UNAME_RELEASE} + exit ;; + *falcon*:*MiNT:*:* | *falcon*:*mint:*:* | *falcon*:*TOS:*:*) + echo m68k-atari-mint${UNAME_RELEASE} + exit ;; + milan*:*MiNT:*:* | milan*:*mint:*:* | *milan*:*TOS:*:*) + echo m68k-milan-mint${UNAME_RELEASE} + exit ;; + hades*:*MiNT:*:* | hades*:*mint:*:* | *hades*:*TOS:*:*) + echo m68k-hades-mint${UNAME_RELEASE} + exit ;; + *:*MiNT:*:* | *:*mint:*:* | *:*TOS:*:*) + echo m68k-unknown-mint${UNAME_RELEASE} + exit ;; + m68k:machten:*:*) + echo m68k-apple-machten${UNAME_RELEASE} + exit ;; + powerpc:machten:*:*) + echo powerpc-apple-machten${UNAME_RELEASE} + exit ;; + RISC*:Mach:*:*) + echo mips-dec-mach_bsd4.3 + exit ;; + RISC*:ULTRIX:*:*) + echo mips-dec-ultrix${UNAME_RELEASE} + exit ;; + VAX*:ULTRIX*:*:*) + echo vax-dec-ultrix${UNAME_RELEASE} + exit ;; + 2020:CLIX:*:* | 2430:CLIX:*:*) + echo clipper-intergraph-clix${UNAME_RELEASE} + exit ;; + mips:*:*:UMIPS | mips:*:*:RISCos) + eval $set_cc_for_build + sed 's/^ //' << EOF >$dummy.c +#ifdef __cplusplus +#include /* for printf() prototype */ + int main (int argc, char *argv[]) { +#else + int main (argc, argv) int argc; char *argv[]; { +#endif + #if defined (host_mips) && defined (MIPSEB) + #if defined (SYSTYPE_SYSV) + printf ("mips-mips-riscos%ssysv\n", argv[1]); exit (0); + #endif + #if defined (SYSTYPE_SVR4) + printf ("mips-mips-riscos%ssvr4\n", argv[1]); exit (0); + #endif + #if defined (SYSTYPE_BSD43) || defined(SYSTYPE_BSD) + printf ("mips-mips-riscos%sbsd\n", argv[1]); exit (0); + #endif + #endif + exit (-1); + } +EOF + $CC_FOR_BUILD -o $dummy $dummy.c && + dummyarg=`echo "${UNAME_RELEASE}" | sed -n 's/\([0-9]*\).*/\1/p'` && + SYSTEM_NAME=`$dummy $dummyarg` && + { echo "$SYSTEM_NAME"; exit; } + echo mips-mips-riscos${UNAME_RELEASE} + exit ;; + Motorola:PowerMAX_OS:*:*) + echo powerpc-motorola-powermax + exit ;; + Motorola:*:4.3:PL8-*) + echo powerpc-harris-powermax + exit ;; + Night_Hawk:*:*:PowerMAX_OS | Synergy:PowerMAX_OS:*:*) + echo powerpc-harris-powermax + exit ;; + Night_Hawk:Power_UNIX:*:*) + echo powerpc-harris-powerunix + exit ;; + m88k:CX/UX:7*:*) + echo m88k-harris-cxux7 + exit ;; + m88k:*:4*:R4*) + echo m88k-motorola-sysv4 + exit ;; + m88k:*:3*:R3*) + echo m88k-motorola-sysv3 + exit ;; + AViiON:dgux:*:*) + # DG/UX returns AViiON for all architectures + UNAME_PROCESSOR=`/usr/bin/uname -p` + if [ $UNAME_PROCESSOR = mc88100 ] || [ $UNAME_PROCESSOR = mc88110 ] + then + if [ ${TARGET_BINARY_INTERFACE}x = m88kdguxelfx ] || \ + [ ${TARGET_BINARY_INTERFACE}x = x ] + then + echo m88k-dg-dgux${UNAME_RELEASE} + else + echo m88k-dg-dguxbcs${UNAME_RELEASE} + fi + else + echo i586-dg-dgux${UNAME_RELEASE} + fi + exit ;; + M88*:DolphinOS:*:*) # DolphinOS (SVR3) + echo m88k-dolphin-sysv3 + exit ;; + M88*:*:R3*:*) + # Delta 88k system running SVR3 + echo m88k-motorola-sysv3 + exit ;; + XD88*:*:*:*) # Tektronix XD88 system running UTekV (SVR3) + echo m88k-tektronix-sysv3 + exit ;; + Tek43[0-9][0-9]:UTek:*:*) # Tektronix 4300 system running UTek (BSD) + echo m68k-tektronix-bsd + exit ;; + *:IRIX*:*:*) + echo mips-sgi-irix`echo ${UNAME_RELEASE}|sed -e 's/-/_/g'` + exit ;; + ????????:AIX?:[12].1:2) # AIX 2.2.1 or AIX 2.1.1 is RT/PC AIX. + echo romp-ibm-aix # uname -m gives an 8 hex-code CPU id + exit ;; # Note that: echo "'`uname -s`'" gives 'AIX ' + i*86:AIX:*:*) + echo i386-ibm-aix + exit ;; + ia64:AIX:*:*) + if [ -x /usr/bin/oslevel ] ; then + IBM_REV=`/usr/bin/oslevel` + else + IBM_REV=${UNAME_VERSION}.${UNAME_RELEASE} + fi + echo ${UNAME_MACHINE}-ibm-aix${IBM_REV} + exit ;; + *:AIX:2:3) + if grep bos325 /usr/include/stdio.h >/dev/null 2>&1; then + eval $set_cc_for_build + sed 's/^ //' << EOF >$dummy.c + #include + + main() + { + if (!__power_pc()) + exit(1); + puts("powerpc-ibm-aix3.2.5"); + exit(0); + } +EOF + if $CC_FOR_BUILD -o $dummy $dummy.c && SYSTEM_NAME=`$dummy` + then + echo "$SYSTEM_NAME" + else + echo rs6000-ibm-aix3.2.5 + fi + elif grep bos324 /usr/include/stdio.h >/dev/null 2>&1; then + echo rs6000-ibm-aix3.2.4 + else + echo rs6000-ibm-aix3.2 + fi + exit ;; + *:AIX:*:[4567]) + IBM_CPU_ID=`/usr/sbin/lsdev -C -c processor -S available | sed 1q | awk '{ print $1 }'` + if /usr/sbin/lsattr -El ${IBM_CPU_ID} | grep ' POWER' >/dev/null 2>&1; then + IBM_ARCH=rs6000 + else + IBM_ARCH=powerpc + fi + if [ -x /usr/bin/oslevel ] ; then + IBM_REV=`/usr/bin/oslevel` + else + IBM_REV=${UNAME_VERSION}.${UNAME_RELEASE} + fi + echo ${IBM_ARCH}-ibm-aix${IBM_REV} + exit ;; + *:AIX:*:*) + echo rs6000-ibm-aix + exit ;; + ibmrt:4.4BSD:*|romp-ibm:BSD:*) + echo romp-ibm-bsd4.4 + exit ;; + ibmrt:*BSD:*|romp-ibm:BSD:*) # covers RT/PC BSD and + echo romp-ibm-bsd${UNAME_RELEASE} # 4.3 with uname added to + exit ;; # report: romp-ibm BSD 4.3 + *:BOSX:*:*) + echo rs6000-bull-bosx + exit ;; + DPX/2?00:B.O.S.:*:*) + echo m68k-bull-sysv3 + exit ;; + 9000/[34]??:4.3bsd:1.*:*) + echo m68k-hp-bsd + exit ;; + hp300:4.4BSD:*:* | 9000/[34]??:4.3bsd:2.*:*) + echo m68k-hp-bsd4.4 + exit ;; + 9000/[34678]??:HP-UX:*:*) + HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/[^.]*.[0B]*//'` + case "${UNAME_MACHINE}" in + 9000/31? ) HP_ARCH=m68000 ;; + 9000/[34]?? ) HP_ARCH=m68k ;; + 9000/[678][0-9][0-9]) + if [ -x /usr/bin/getconf ]; then + sc_cpu_version=`/usr/bin/getconf SC_CPU_VERSION 2>/dev/null` + sc_kernel_bits=`/usr/bin/getconf SC_KERNEL_BITS 2>/dev/null` + case "${sc_cpu_version}" in + 523) HP_ARCH="hppa1.0" ;; # CPU_PA_RISC1_0 + 528) HP_ARCH="hppa1.1" ;; # CPU_PA_RISC1_1 + 532) # CPU_PA_RISC2_0 + case "${sc_kernel_bits}" in + 32) HP_ARCH="hppa2.0n" ;; + 64) HP_ARCH="hppa2.0w" ;; + '') HP_ARCH="hppa2.0" ;; # HP-UX 10.20 + esac ;; + esac + fi + if [ "${HP_ARCH}" = "" ]; then + eval $set_cc_for_build + sed 's/^ //' << EOF >$dummy.c + + #define _HPUX_SOURCE + #include + #include + + int main () + { + #if defined(_SC_KERNEL_BITS) + long bits = sysconf(_SC_KERNEL_BITS); + #endif + long cpu = sysconf (_SC_CPU_VERSION); + + switch (cpu) + { + case CPU_PA_RISC1_0: puts ("hppa1.0"); break; + case CPU_PA_RISC1_1: puts ("hppa1.1"); break; + case CPU_PA_RISC2_0: + #if defined(_SC_KERNEL_BITS) + switch (bits) + { + case 64: puts ("hppa2.0w"); break; + case 32: puts ("hppa2.0n"); break; + default: puts ("hppa2.0"); break; + } break; + #else /* !defined(_SC_KERNEL_BITS) */ + puts ("hppa2.0"); break; + #endif + default: puts ("hppa1.0"); break; + } + exit (0); + } +EOF + (CCOPTS= $CC_FOR_BUILD -o $dummy $dummy.c 2>/dev/null) && HP_ARCH=`$dummy` + test -z "$HP_ARCH" && HP_ARCH=hppa + fi ;; + esac + if [ ${HP_ARCH} = "hppa2.0w" ] + then + eval $set_cc_for_build + + # hppa2.0w-hp-hpux* has a 64-bit kernel and a compiler generating + # 32-bit code. hppa64-hp-hpux* has the same kernel and a compiler + # generating 64-bit code. GNU and HP use different nomenclature: + # + # $ CC_FOR_BUILD=cc ./config.guess + # => hppa2.0w-hp-hpux11.23 + # $ CC_FOR_BUILD="cc +DA2.0w" ./config.guess + # => hppa64-hp-hpux11.23 + + if echo __LP64__ | (CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) | + grep -q __LP64__ + then + HP_ARCH="hppa2.0w" + else + HP_ARCH="hppa64" + fi + fi + echo ${HP_ARCH}-hp-hpux${HPUX_REV} + exit ;; + ia64:HP-UX:*:*) + HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/[^.]*.[0B]*//'` + echo ia64-hp-hpux${HPUX_REV} + exit ;; + 3050*:HI-UX:*:*) + eval $set_cc_for_build + sed 's/^ //' << EOF >$dummy.c + #include + int + main () + { + long cpu = sysconf (_SC_CPU_VERSION); + /* The order matters, because CPU_IS_HP_MC68K erroneously returns + true for CPU_PA_RISC1_0. CPU_IS_PA_RISC returns correct + results, however. */ + if (CPU_IS_PA_RISC (cpu)) + { + switch (cpu) + { + case CPU_PA_RISC1_0: puts ("hppa1.0-hitachi-hiuxwe2"); break; + case CPU_PA_RISC1_1: puts ("hppa1.1-hitachi-hiuxwe2"); break; + case CPU_PA_RISC2_0: puts ("hppa2.0-hitachi-hiuxwe2"); break; + default: puts ("hppa-hitachi-hiuxwe2"); break; + } + } + else if (CPU_IS_HP_MC68K (cpu)) + puts ("m68k-hitachi-hiuxwe2"); + else puts ("unknown-hitachi-hiuxwe2"); + exit (0); + } +EOF + $CC_FOR_BUILD -o $dummy $dummy.c && SYSTEM_NAME=`$dummy` && + { echo "$SYSTEM_NAME"; exit; } + echo unknown-hitachi-hiuxwe2 + exit ;; + 9000/7??:4.3bsd:*:* | 9000/8?[79]:4.3bsd:*:* ) + echo hppa1.1-hp-bsd + exit ;; + 9000/8??:4.3bsd:*:*) + echo hppa1.0-hp-bsd + exit ;; + *9??*:MPE/iX:*:* | *3000*:MPE/iX:*:*) + echo hppa1.0-hp-mpeix + exit ;; + hp7??:OSF1:*:* | hp8?[79]:OSF1:*:* ) + echo hppa1.1-hp-osf + exit ;; + hp8??:OSF1:*:*) + echo hppa1.0-hp-osf + exit ;; + i*86:OSF1:*:*) + if [ -x /usr/sbin/sysversion ] ; then + echo ${UNAME_MACHINE}-unknown-osf1mk + else + echo ${UNAME_MACHINE}-unknown-osf1 + fi + exit ;; + parisc*:Lites*:*:*) + echo hppa1.1-hp-lites + exit ;; + C1*:ConvexOS:*:* | convex:ConvexOS:C1*:*) + echo c1-convex-bsd + exit ;; + C2*:ConvexOS:*:* | convex:ConvexOS:C2*:*) + if getsysinfo -f scalar_acc + then echo c32-convex-bsd + else echo c2-convex-bsd + fi + exit ;; + C34*:ConvexOS:*:* | convex:ConvexOS:C34*:*) + echo c34-convex-bsd + exit ;; + C38*:ConvexOS:*:* | convex:ConvexOS:C38*:*) + echo c38-convex-bsd + exit ;; + C4*:ConvexOS:*:* | convex:ConvexOS:C4*:*) + echo c4-convex-bsd + exit ;; + CRAY*Y-MP:*:*:*) + echo ymp-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' + exit ;; + CRAY*[A-Z]90:*:*:*) + echo ${UNAME_MACHINE}-cray-unicos${UNAME_RELEASE} \ + | sed -e 's/CRAY.*\([A-Z]90\)/\1/' \ + -e y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/ \ + -e 's/\.[^.]*$/.X/' + exit ;; + CRAY*TS:*:*:*) + echo t90-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' + exit ;; + CRAY*T3E:*:*:*) + echo alphaev5-cray-unicosmk${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' + exit ;; + CRAY*SV1:*:*:*) + echo sv1-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' + exit ;; + *:UNICOS/mp:*:*) + echo craynv-cray-unicosmp${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' + exit ;; + F30[01]:UNIX_System_V:*:* | F700:UNIX_System_V:*:*) + FUJITSU_PROC=`uname -m | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` + FUJITSU_SYS=`uname -p | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/\///'` + FUJITSU_REL=`echo ${UNAME_RELEASE} | sed -e 's/ /_/'` + echo "${FUJITSU_PROC}-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}" + exit ;; + 5000:UNIX_System_V:4.*:*) + FUJITSU_SYS=`uname -p | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/\///'` + FUJITSU_REL=`echo ${UNAME_RELEASE} | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/ /_/'` + echo "sparc-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}" + exit ;; + i*86:BSD/386:*:* | i*86:BSD/OS:*:* | *:Ascend\ Embedded/OS:*:*) + echo ${UNAME_MACHINE}-pc-bsdi${UNAME_RELEASE} + exit ;; + sparc*:BSD/OS:*:*) + echo sparc-unknown-bsdi${UNAME_RELEASE} + exit ;; + *:BSD/OS:*:*) + echo ${UNAME_MACHINE}-unknown-bsdi${UNAME_RELEASE} + exit ;; + *:FreeBSD:*:*) + UNAME_PROCESSOR=`/usr/bin/uname -p` + case ${UNAME_PROCESSOR} in + amd64) + echo x86_64-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;; + *) + echo ${UNAME_PROCESSOR}-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;; + esac + exit ;; + i*:CYGWIN*:*) + echo ${UNAME_MACHINE}-pc-cygwin + exit ;; + *:MINGW64*:*) + echo ${UNAME_MACHINE}-pc-mingw64 + exit ;; + *:MINGW*:*) + echo ${UNAME_MACHINE}-pc-mingw32 + exit ;; + *:MSYS*:*) + echo ${UNAME_MACHINE}-pc-msys + exit ;; + i*:windows32*:*) + # uname -m includes "-pc" on this system. + echo ${UNAME_MACHINE}-mingw32 + exit ;; + i*:PW*:*) + echo ${UNAME_MACHINE}-pc-pw32 + exit ;; + *:Interix*:*) + case ${UNAME_MACHINE} in + x86) + echo i586-pc-interix${UNAME_RELEASE} + exit ;; + authenticamd | genuineintel | EM64T) + echo x86_64-unknown-interix${UNAME_RELEASE} + exit ;; + IA64) + echo ia64-unknown-interix${UNAME_RELEASE} + exit ;; + esac ;; + [345]86:Windows_95:* | [345]86:Windows_98:* | [345]86:Windows_NT:*) + echo i${UNAME_MACHINE}-pc-mks + exit ;; + 8664:Windows_NT:*) + echo x86_64-pc-mks + exit ;; + i*:Windows_NT*:* | Pentium*:Windows_NT*:*) + # How do we know it's Interix rather than the generic POSIX subsystem? + # It also conflicts with pre-2.0 versions of AT&T UWIN. Should we + # UNAME_MACHINE based on the output of uname instead of i386? + echo i586-pc-interix + exit ;; + i*:UWIN*:*) + echo ${UNAME_MACHINE}-pc-uwin + exit ;; + amd64:CYGWIN*:*:* | x86_64:CYGWIN*:*:*) + echo x86_64-unknown-cygwin + exit ;; + p*:CYGWIN*:*) + echo powerpcle-unknown-cygwin + exit ;; + prep*:SunOS:5.*:*) + echo powerpcle-unknown-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` + exit ;; + *:GNU:*:*) + # the GNU system + echo `echo ${UNAME_MACHINE}|sed -e 's,[-/].*$,,'`-unknown-${LIBC}`echo ${UNAME_RELEASE}|sed -e 's,/.*$,,'` + exit ;; + *:GNU/*:*:*) + # other systems with GNU libc and userland + echo ${UNAME_MACHINE}-unknown-`echo ${UNAME_SYSTEM} | sed 's,^[^/]*/,,' | tr '[A-Z]' '[a-z]'``echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'`-${LIBC} + exit ;; + i*86:Minix:*:*) + echo ${UNAME_MACHINE}-pc-minix + exit ;; + aarch64:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-${LIBC} + exit ;; + aarch64_be:Linux:*:*) + UNAME_MACHINE=aarch64_be + echo ${UNAME_MACHINE}-unknown-linux-${LIBC} + exit ;; + alpha:Linux:*:*) + case `sed -n '/^cpu model/s/^.*: \(.*\)/\1/p' < /proc/cpuinfo` in + EV5) UNAME_MACHINE=alphaev5 ;; + EV56) UNAME_MACHINE=alphaev56 ;; + PCA56) UNAME_MACHINE=alphapca56 ;; + PCA57) UNAME_MACHINE=alphapca56 ;; + EV6) UNAME_MACHINE=alphaev6 ;; + EV67) UNAME_MACHINE=alphaev67 ;; + EV68*) UNAME_MACHINE=alphaev68 ;; + esac + objdump --private-headers /bin/sh | grep -q ld.so.1 + if test "$?" = 0 ; then LIBC="gnulibc1" ; fi + echo ${UNAME_MACHINE}-unknown-linux-${LIBC} + exit ;; + arc:Linux:*:* | arceb:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-${LIBC} + exit ;; + arm*:Linux:*:*) + eval $set_cc_for_build + if echo __ARM_EABI__ | $CC_FOR_BUILD -E - 2>/dev/null \ + | grep -q __ARM_EABI__ + then + echo ${UNAME_MACHINE}-unknown-linux-${LIBC} + else + if echo __ARM_PCS_VFP | $CC_FOR_BUILD -E - 2>/dev/null \ + | grep -q __ARM_PCS_VFP + then + echo ${UNAME_MACHINE}-unknown-linux-${LIBC}eabi + else + echo ${UNAME_MACHINE}-unknown-linux-${LIBC}eabihf + fi + fi + exit ;; + avr32*:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-${LIBC} + exit ;; + cris:Linux:*:*) + echo ${UNAME_MACHINE}-axis-linux-${LIBC} + exit ;; + crisv32:Linux:*:*) + echo ${UNAME_MACHINE}-axis-linux-${LIBC} + exit ;; + frv:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-${LIBC} + exit ;; + hexagon:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-${LIBC} + exit ;; + i*86:Linux:*:*) + echo ${UNAME_MACHINE}-pc-linux-${LIBC} + exit ;; + ia64:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-${LIBC} + exit ;; + m32r*:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-${LIBC} + exit ;; + m68*:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-${LIBC} + exit ;; + mips:Linux:*:* | mips64:Linux:*:*) + eval $set_cc_for_build + sed 's/^ //' << EOF >$dummy.c + #undef CPU + #undef ${UNAME_MACHINE} + #undef ${UNAME_MACHINE}el + #if defined(__MIPSEL__) || defined(__MIPSEL) || defined(_MIPSEL) || defined(MIPSEL) + CPU=${UNAME_MACHINE}el + #else + #if defined(__MIPSEB__) || defined(__MIPSEB) || defined(_MIPSEB) || defined(MIPSEB) + CPU=${UNAME_MACHINE} + #else + CPU= + #endif + #endif +EOF + eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null | grep '^CPU'` + test x"${CPU}" != x && { echo "${CPU}-unknown-linux-${LIBC}"; exit; } + ;; + openrisc*:Linux:*:*) + echo or1k-unknown-linux-${LIBC} + exit ;; + or32:Linux:*:* | or1k*:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-${LIBC} + exit ;; + padre:Linux:*:*) + echo sparc-unknown-linux-${LIBC} + exit ;; + parisc64:Linux:*:* | hppa64:Linux:*:*) + echo hppa64-unknown-linux-${LIBC} + exit ;; + parisc:Linux:*:* | hppa:Linux:*:*) + # Look for CPU level + case `grep '^cpu[^a-z]*:' /proc/cpuinfo 2>/dev/null | cut -d' ' -f2` in + PA7*) echo hppa1.1-unknown-linux-${LIBC} ;; + PA8*) echo hppa2.0-unknown-linux-${LIBC} ;; + *) echo hppa-unknown-linux-${LIBC} ;; + esac + exit ;; + ppc64:Linux:*:*) + echo powerpc64-unknown-linux-${LIBC} + exit ;; + ppc:Linux:*:*) + echo powerpc-unknown-linux-${LIBC} + exit ;; + ppc64le:Linux:*:*) + echo powerpc64le-unknown-linux-${LIBC} + exit ;; + ppcle:Linux:*:*) + echo powerpcle-unknown-linux-${LIBC} + exit ;; + s390:Linux:*:* | s390x:Linux:*:*) + echo ${UNAME_MACHINE}-ibm-linux-${LIBC} + exit ;; + sh64*:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-${LIBC} + exit ;; + sh*:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-${LIBC} + exit ;; + sparc:Linux:*:* | sparc64:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-${LIBC} + exit ;; + tile*:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-${LIBC} + exit ;; + vax:Linux:*:*) + echo ${UNAME_MACHINE}-dec-linux-${LIBC} + exit ;; + x86_64:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-${LIBC} + exit ;; + xtensa*:Linux:*:*) + echo ${UNAME_MACHINE}-unknown-linux-${LIBC} + exit ;; + i*86:DYNIX/ptx:4*:*) + # ptx 4.0 does uname -s correctly, with DYNIX/ptx in there. + # earlier versions are messed up and put the nodename in both + # sysname and nodename. + echo i386-sequent-sysv4 + exit ;; + i*86:UNIX_SV:4.2MP:2.*) + # Unixware is an offshoot of SVR4, but it has its own version + # number series starting with 2... + # I am not positive that other SVR4 systems won't match this, + # I just have to hope. -- rms. + # Use sysv4.2uw... so that sysv4* matches it. + echo ${UNAME_MACHINE}-pc-sysv4.2uw${UNAME_VERSION} + exit ;; + i*86:OS/2:*:*) + # If we were able to find `uname', then EMX Unix compatibility + # is probably installed. + echo ${UNAME_MACHINE}-pc-os2-emx + exit ;; + i*86:XTS-300:*:STOP) + echo ${UNAME_MACHINE}-unknown-stop + exit ;; + i*86:atheos:*:*) + echo ${UNAME_MACHINE}-unknown-atheos + exit ;; + i*86:syllable:*:*) + echo ${UNAME_MACHINE}-pc-syllable + exit ;; + i*86:LynxOS:2.*:* | i*86:LynxOS:3.[01]*:* | i*86:LynxOS:4.[02]*:*) + echo i386-unknown-lynxos${UNAME_RELEASE} + exit ;; + i*86:*DOS:*:*) + echo ${UNAME_MACHINE}-pc-msdosdjgpp + exit ;; + i*86:*:4.*:* | i*86:SYSTEM_V:4.*:*) + UNAME_REL=`echo ${UNAME_RELEASE} | sed 's/\/MP$//'` + if grep Novell /usr/include/link.h >/dev/null 2>/dev/null; then + echo ${UNAME_MACHINE}-univel-sysv${UNAME_REL} + else + echo ${UNAME_MACHINE}-pc-sysv${UNAME_REL} + fi + exit ;; + i*86:*:5:[678]*) + # UnixWare 7.x, OpenUNIX and OpenServer 6. + case `/bin/uname -X | grep "^Machine"` in + *486*) UNAME_MACHINE=i486 ;; + *Pentium) UNAME_MACHINE=i586 ;; + *Pent*|*Celeron) UNAME_MACHINE=i686 ;; + esac + echo ${UNAME_MACHINE}-unknown-sysv${UNAME_RELEASE}${UNAME_SYSTEM}${UNAME_VERSION} + exit ;; + i*86:*:3.2:*) + if test -f /usr/options/cb.name; then + UNAME_REL=`sed -n 's/.*Version //p' /dev/null >/dev/null ; then + UNAME_REL=`(/bin/uname -X|grep Release|sed -e 's/.*= //')` + (/bin/uname -X|grep i80486 >/dev/null) && UNAME_MACHINE=i486 + (/bin/uname -X|grep '^Machine.*Pentium' >/dev/null) \ + && UNAME_MACHINE=i586 + (/bin/uname -X|grep '^Machine.*Pent *II' >/dev/null) \ + && UNAME_MACHINE=i686 + (/bin/uname -X|grep '^Machine.*Pentium Pro' >/dev/null) \ + && UNAME_MACHINE=i686 + echo ${UNAME_MACHINE}-pc-sco$UNAME_REL + else + echo ${UNAME_MACHINE}-pc-sysv32 + fi + exit ;; + pc:*:*:*) + # Left here for compatibility: + # uname -m prints for DJGPP always 'pc', but it prints nothing about + # the processor, so we play safe by assuming i586. + # Note: whatever this is, it MUST be the same as what config.sub + # prints for the "djgpp" host, or else GDB configury will decide that + # this is a cross-build. + echo i586-pc-msdosdjgpp + exit ;; + Intel:Mach:3*:*) + echo i386-pc-mach3 + exit ;; + paragon:*:*:*) + echo i860-intel-osf1 + exit ;; + i860:*:4.*:*) # i860-SVR4 + if grep Stardent /usr/include/sys/uadmin.h >/dev/null 2>&1 ; then + echo i860-stardent-sysv${UNAME_RELEASE} # Stardent Vistra i860-SVR4 + else # Add other i860-SVR4 vendors below as they are discovered. + echo i860-unknown-sysv${UNAME_RELEASE} # Unknown i860-SVR4 + fi + exit ;; + mini*:CTIX:SYS*5:*) + # "miniframe" + echo m68010-convergent-sysv + exit ;; + mc68k:UNIX:SYSTEM5:3.51m) + echo m68k-convergent-sysv + exit ;; + M680?0:D-NIX:5.3:*) + echo m68k-diab-dnix + exit ;; + M68*:*:R3V[5678]*:*) + test -r /sysV68 && { echo 'm68k-motorola-sysv'; exit; } ;; + 3[345]??:*:4.0:3.0 | 3[34]??A:*:4.0:3.0 | 3[34]??,*:*:4.0:3.0 | 3[34]??/*:*:4.0:3.0 | 4400:*:4.0:3.0 | 4850:*:4.0:3.0 | SKA40:*:4.0:3.0 | SDS2:*:4.0:3.0 | SHG2:*:4.0:3.0 | S7501*:*:4.0:3.0) + OS_REL='' + test -r /etc/.relid \ + && OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid` + /bin/uname -p 2>/dev/null | grep 86 >/dev/null \ + && { echo i486-ncr-sysv4.3${OS_REL}; exit; } + /bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \ + && { echo i586-ncr-sysv4.3${OS_REL}; exit; } ;; + 3[34]??:*:4.0:* | 3[34]??,*:*:4.0:*) + /bin/uname -p 2>/dev/null | grep 86 >/dev/null \ + && { echo i486-ncr-sysv4; exit; } ;; + NCR*:*:4.2:* | MPRAS*:*:4.2:*) + OS_REL='.3' + test -r /etc/.relid \ + && OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid` + /bin/uname -p 2>/dev/null | grep 86 >/dev/null \ + && { echo i486-ncr-sysv4.3${OS_REL}; exit; } + /bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \ + && { echo i586-ncr-sysv4.3${OS_REL}; exit; } + /bin/uname -p 2>/dev/null | /bin/grep pteron >/dev/null \ + && { echo i586-ncr-sysv4.3${OS_REL}; exit; } ;; + m68*:LynxOS:2.*:* | m68*:LynxOS:3.0*:*) + echo m68k-unknown-lynxos${UNAME_RELEASE} + exit ;; + mc68030:UNIX_System_V:4.*:*) + echo m68k-atari-sysv4 + exit ;; + TSUNAMI:LynxOS:2.*:*) + echo sparc-unknown-lynxos${UNAME_RELEASE} + exit ;; + rs6000:LynxOS:2.*:*) + echo rs6000-unknown-lynxos${UNAME_RELEASE} + exit ;; + PowerPC:LynxOS:2.*:* | PowerPC:LynxOS:3.[01]*:* | PowerPC:LynxOS:4.[02]*:*) + echo powerpc-unknown-lynxos${UNAME_RELEASE} + exit ;; + SM[BE]S:UNIX_SV:*:*) + echo mips-dde-sysv${UNAME_RELEASE} + exit ;; + RM*:ReliantUNIX-*:*:*) + echo mips-sni-sysv4 + exit ;; + RM*:SINIX-*:*:*) + echo mips-sni-sysv4 + exit ;; + *:SINIX-*:*:*) + if uname -p 2>/dev/null >/dev/null ; then + UNAME_MACHINE=`(uname -p) 2>/dev/null` + echo ${UNAME_MACHINE}-sni-sysv4 + else + echo ns32k-sni-sysv + fi + exit ;; + PENTIUM:*:4.0*:*) # Unisys `ClearPath HMP IX 4000' SVR4/MP effort + # says + echo i586-unisys-sysv4 + exit ;; + *:UNIX_System_V:4*:FTX*) + # From Gerald Hewes . + # How about differentiating between stratus architectures? -djm + echo hppa1.1-stratus-sysv4 + exit ;; + *:*:*:FTX*) + # From seanf@swdc.stratus.com. + echo i860-stratus-sysv4 + exit ;; + i*86:VOS:*:*) + # From Paul.Green@stratus.com. + echo ${UNAME_MACHINE}-stratus-vos + exit ;; + *:VOS:*:*) + # From Paul.Green@stratus.com. + echo hppa1.1-stratus-vos + exit ;; + mc68*:A/UX:*:*) + echo m68k-apple-aux${UNAME_RELEASE} + exit ;; + news*:NEWS-OS:6*:*) + echo mips-sony-newsos6 + exit ;; + R[34]000:*System_V*:*:* | R4000:UNIX_SYSV:*:* | R*000:UNIX_SV:*:*) + if [ -d /usr/nec ]; then + echo mips-nec-sysv${UNAME_RELEASE} + else + echo mips-unknown-sysv${UNAME_RELEASE} + fi + exit ;; + BeBox:BeOS:*:*) # BeOS running on hardware made by Be, PPC only. + echo powerpc-be-beos + exit ;; + BeMac:BeOS:*:*) # BeOS running on Mac or Mac clone, PPC only. + echo powerpc-apple-beos + exit ;; + BePC:BeOS:*:*) # BeOS running on Intel PC compatible. + echo i586-pc-beos + exit ;; + BePC:Haiku:*:*) # Haiku running on Intel PC compatible. + echo i586-pc-haiku + exit ;; + x86_64:Haiku:*:*) + echo x86_64-unknown-haiku + exit ;; + SX-4:SUPER-UX:*:*) + echo sx4-nec-superux${UNAME_RELEASE} + exit ;; + SX-5:SUPER-UX:*:*) + echo sx5-nec-superux${UNAME_RELEASE} + exit ;; + SX-6:SUPER-UX:*:*) + echo sx6-nec-superux${UNAME_RELEASE} + exit ;; + SX-7:SUPER-UX:*:*) + echo sx7-nec-superux${UNAME_RELEASE} + exit ;; + SX-8:SUPER-UX:*:*) + echo sx8-nec-superux${UNAME_RELEASE} + exit ;; + SX-8R:SUPER-UX:*:*) + echo sx8r-nec-superux${UNAME_RELEASE} + exit ;; + Power*:Rhapsody:*:*) + echo powerpc-apple-rhapsody${UNAME_RELEASE} + exit ;; + *:Rhapsody:*:*) + echo ${UNAME_MACHINE}-apple-rhapsody${UNAME_RELEASE} + exit ;; + *:Darwin:*:*) + UNAME_PROCESSOR=`uname -p` || UNAME_PROCESSOR=unknown + eval $set_cc_for_build + if test "$UNAME_PROCESSOR" = unknown ; then + UNAME_PROCESSOR=powerpc + fi + if test `echo "$UNAME_RELEASE" | sed -e 's/\..*//'` -le 10 ; then + if [ "$CC_FOR_BUILD" != 'no_compiler_found' ]; then + if (echo '#ifdef __LP64__'; echo IS_64BIT_ARCH; echo '#endif') | \ + (CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) | \ + grep IS_64BIT_ARCH >/dev/null + then + case $UNAME_PROCESSOR in + i386) UNAME_PROCESSOR=x86_64 ;; + powerpc) UNAME_PROCESSOR=powerpc64 ;; + esac + fi + fi + elif test "$UNAME_PROCESSOR" = i386 ; then + # Avoid executing cc on OS X 10.9, as it ships with a stub + # that puts up a graphical alert prompting to install + # developer tools. Any system running Mac OS X 10.7 or + # later (Darwin 11 and later) is required to have a 64-bit + # processor. This is not true of the ARM version of Darwin + # that Apple uses in portable devices. + UNAME_PROCESSOR=x86_64 + fi + echo ${UNAME_PROCESSOR}-apple-darwin${UNAME_RELEASE} + exit ;; + *:procnto*:*:* | *:QNX:[0123456789]*:*) + UNAME_PROCESSOR=`uname -p` + if test "$UNAME_PROCESSOR" = "x86"; then + UNAME_PROCESSOR=i386 + UNAME_MACHINE=pc + fi + echo ${UNAME_PROCESSOR}-${UNAME_MACHINE}-nto-qnx${UNAME_RELEASE} + exit ;; + *:QNX:*:4*) + echo i386-pc-qnx + exit ;; + NEO-?:NONSTOP_KERNEL:*:*) + echo neo-tandem-nsk${UNAME_RELEASE} + exit ;; + NSE-*:NONSTOP_KERNEL:*:*) + echo nse-tandem-nsk${UNAME_RELEASE} + exit ;; + NSR-?:NONSTOP_KERNEL:*:*) + echo nsr-tandem-nsk${UNAME_RELEASE} + exit ;; + *:NonStop-UX:*:*) + echo mips-compaq-nonstopux + exit ;; + BS2000:POSIX*:*:*) + echo bs2000-siemens-sysv + exit ;; + DS/*:UNIX_System_V:*:*) + echo ${UNAME_MACHINE}-${UNAME_SYSTEM}-${UNAME_RELEASE} + exit ;; + *:Plan9:*:*) + # "uname -m" is not consistent, so use $cputype instead. 386 + # is converted to i386 for consistency with other x86 + # operating systems. + if test "$cputype" = "386"; then + UNAME_MACHINE=i386 + else + UNAME_MACHINE="$cputype" + fi + echo ${UNAME_MACHINE}-unknown-plan9 + exit ;; + *:TOPS-10:*:*) + echo pdp10-unknown-tops10 + exit ;; + *:TENEX:*:*) + echo pdp10-unknown-tenex + exit ;; + KS10:TOPS-20:*:* | KL10:TOPS-20:*:* | TYPE4:TOPS-20:*:*) + echo pdp10-dec-tops20 + exit ;; + XKL-1:TOPS-20:*:* | TYPE5:TOPS-20:*:*) + echo pdp10-xkl-tops20 + exit ;; + *:TOPS-20:*:*) + echo pdp10-unknown-tops20 + exit ;; + *:ITS:*:*) + echo pdp10-unknown-its + exit ;; + SEI:*:*:SEIUX) + echo mips-sei-seiux${UNAME_RELEASE} + exit ;; + *:DragonFly:*:*) + echo ${UNAME_MACHINE}-unknown-dragonfly`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` + exit ;; + *:*VMS:*:*) + UNAME_MACHINE=`(uname -p) 2>/dev/null` + case "${UNAME_MACHINE}" in + A*) echo alpha-dec-vms ; exit ;; + I*) echo ia64-dec-vms ; exit ;; + V*) echo vax-dec-vms ; exit ;; + esac ;; + *:XENIX:*:SysV) + echo i386-pc-xenix + exit ;; + i*86:skyos:*:*) + echo ${UNAME_MACHINE}-pc-skyos`echo ${UNAME_RELEASE}` | sed -e 's/ .*$//' + exit ;; + i*86:rdos:*:*) + echo ${UNAME_MACHINE}-pc-rdos + exit ;; + i*86:AROS:*:*) + echo ${UNAME_MACHINE}-pc-aros + exit ;; + x86_64:VMkernel:*:*) + echo ${UNAME_MACHINE}-unknown-esx + exit ;; +esac + +cat >&2 < in order to provide the needed +information to handle your system. + +config.guess timestamp = $timestamp + +uname -m = `(uname -m) 2>/dev/null || echo unknown` +uname -r = `(uname -r) 2>/dev/null || echo unknown` +uname -s = `(uname -s) 2>/dev/null || echo unknown` +uname -v = `(uname -v) 2>/dev/null || echo unknown` + +/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null` +/bin/uname -X = `(/bin/uname -X) 2>/dev/null` + +hostinfo = `(hostinfo) 2>/dev/null` +/bin/universe = `(/bin/universe) 2>/dev/null` +/usr/bin/arch -k = `(/usr/bin/arch -k) 2>/dev/null` +/bin/arch = `(/bin/arch) 2>/dev/null` +/usr/bin/oslevel = `(/usr/bin/oslevel) 2>/dev/null` +/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null` + +UNAME_MACHINE = ${UNAME_MACHINE} +UNAME_RELEASE = ${UNAME_RELEASE} +UNAME_SYSTEM = ${UNAME_SYSTEM} +UNAME_VERSION = ${UNAME_VERSION} +EOF + +exit 1 + +# Local variables: +# eval: (add-hook 'write-file-hooks 'time-stamp) +# time-stamp-start: "timestamp='" +# time-stamp-format: "%:y-%02m-%02d" +# time-stamp-end: "'" +# End: diff --git a/third-party/odb/libodb-sqlite-2.4.0/config/config.sub b/third-party/odb/libodb-sqlite-2.4.0/config/config.sub new file mode 100755 index 0000000..bba4efb --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/config/config.sub @@ -0,0 +1,1799 @@ +#! /bin/sh +# Configuration validation subroutine script. +# Copyright 1992-2014 Free Software Foundation, Inc. + +timestamp='2014-09-11' + +# This file is free software; you can redistribute it and/or modify it +# under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, see . +# +# As a special exception to the GNU General Public License, if you +# distribute this file as part of a program that contains a +# configuration script generated by Autoconf, you may include it under +# the same distribution terms that you use for the rest of that +# program. This Exception is an additional permission under section 7 +# of the GNU General Public License, version 3 ("GPLv3"). + + +# Please send patches with a ChangeLog entry to config-patches@gnu.org. +# +# Configuration subroutine to validate and canonicalize a configuration type. +# Supply the specified configuration type as an argument. +# If it is invalid, we print an error message on stderr and exit with code 1. +# Otherwise, we print the canonical config type on stdout and succeed. + +# You can get the latest version of this script from: +# http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.sub;hb=HEAD + +# This file is supposed to be the same for all GNU packages +# and recognize all the CPU types, system types and aliases +# that are meaningful with *any* GNU software. +# Each package is responsible for reporting which valid configurations +# it does not support. The user should be able to distinguish +# a failure to support a valid configuration from a meaningless +# configuration. + +# The goal of this file is to map all the various variations of a given +# machine specification into a single specification in the form: +# CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM +# or in some cases, the newer four-part form: +# CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM +# It is wrong to echo any other type of specification. + +me=`echo "$0" | sed -e 's,.*/,,'` + +usage="\ +Usage: $0 [OPTION] CPU-MFR-OPSYS + $0 [OPTION] ALIAS + +Canonicalize a configuration name. + +Operation modes: + -h, --help print this help, then exit + -t, --time-stamp print date of last modification, then exit + -v, --version print version number, then exit + +Report bugs and patches to ." + +version="\ +GNU config.sub ($timestamp) + +Copyright 1992-2014 Free Software Foundation, Inc. + +This is free software; see the source for copying conditions. There is NO +warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE." + +help=" +Try \`$me --help' for more information." + +# Parse command line +while test $# -gt 0 ; do + case $1 in + --time-stamp | --time* | -t ) + echo "$timestamp" ; exit ;; + --version | -v ) + echo "$version" ; exit ;; + --help | --h* | -h ) + echo "$usage"; exit ;; + -- ) # Stop option processing + shift; break ;; + - ) # Use stdin as input. + break ;; + -* ) + echo "$me: invalid option $1$help" + exit 1 ;; + + *local*) + # First pass through any local machine types. + echo $1 + exit ;; + + * ) + break ;; + esac +done + +case $# in + 0) echo "$me: missing argument$help" >&2 + exit 1;; + 1) ;; + *) echo "$me: too many arguments$help" >&2 + exit 1;; +esac + +# Separate what the user gave into CPU-COMPANY and OS or KERNEL-OS (if any). +# Here we must recognize all the valid KERNEL-OS combinations. +maybe_os=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\2/'` +case $maybe_os in + nto-qnx* | linux-gnu* | linux-android* | linux-dietlibc | linux-newlib* | \ + linux-musl* | linux-uclibc* | uclinux-uclibc* | uclinux-gnu* | kfreebsd*-gnu* | \ + knetbsd*-gnu* | netbsd*-gnu* | \ + kopensolaris*-gnu* | \ + storm-chaos* | os2-emx* | rtmk-nova*) + os=-$maybe_os + basic_machine=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\1/'` + ;; + android-linux) + os=-linux-android + basic_machine=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\1/'`-unknown + ;; + *) + basic_machine=`echo $1 | sed 's/-[^-]*$//'` + if [ $basic_machine != $1 ] + then os=`echo $1 | sed 's/.*-/-/'` + else os=; fi + ;; +esac + +### Let's recognize common machines as not being operating systems so +### that things like config.sub decstation-3100 work. We also +### recognize some manufacturers as not being operating systems, so we +### can provide default operating systems below. +case $os in + -sun*os*) + # Prevent following clause from handling this invalid input. + ;; + -dec* | -mips* | -sequent* | -encore* | -pc532* | -sgi* | -sony* | \ + -att* | -7300* | -3300* | -delta* | -motorola* | -sun[234]* | \ + -unicom* | -ibm* | -next | -hp | -isi* | -apollo | -altos* | \ + -convergent* | -ncr* | -news | -32* | -3600* | -3100* | -hitachi* |\ + -c[123]* | -convex* | -sun | -crds | -omron* | -dg | -ultra | -tti* | \ + -harris | -dolphin | -highlevel | -gould | -cbm | -ns | -masscomp | \ + -apple | -axis | -knuth | -cray | -microblaze*) + os= + basic_machine=$1 + ;; + -bluegene*) + os=-cnk + ;; + -sim | -cisco | -oki | -wec | -winbond) + os= + basic_machine=$1 + ;; + -scout) + ;; + -wrs) + os=-vxworks + basic_machine=$1 + ;; + -chorusos*) + os=-chorusos + basic_machine=$1 + ;; + -chorusrdb) + os=-chorusrdb + basic_machine=$1 + ;; + -hiux*) + os=-hiuxwe2 + ;; + -sco6) + os=-sco5v6 + basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` + ;; + -sco5) + os=-sco3.2v5 + basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` + ;; + -sco4) + os=-sco3.2v4 + basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` + ;; + -sco3.2.[4-9]*) + os=`echo $os | sed -e 's/sco3.2./sco3.2v/'` + basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` + ;; + -sco3.2v[4-9]*) + # Don't forget version if it is 3.2v4 or newer. + basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` + ;; + -sco5v6*) + # Don't forget version if it is 3.2v4 or newer. + basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` + ;; + -sco*) + os=-sco3.2v2 + basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` + ;; + -udk*) + basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` + ;; + -isc) + os=-isc2.2 + basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` + ;; + -clix*) + basic_machine=clipper-intergraph + ;; + -isc*) + basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` + ;; + -lynx*178) + os=-lynxos178 + ;; + -lynx*5) + os=-lynxos5 + ;; + -lynx*) + os=-lynxos + ;; + -ptx*) + basic_machine=`echo $1 | sed -e 's/86-.*/86-sequent/'` + ;; + -windowsnt*) + os=`echo $os | sed -e 's/windowsnt/winnt/'` + ;; + -psos*) + os=-psos + ;; + -mint | -mint[0-9]*) + basic_machine=m68k-atari + os=-mint + ;; +esac + +# Decode aliases for certain CPU-COMPANY combinations. +case $basic_machine in + # Recognize the basic CPU types without company name. + # Some are omitted here because they have special meanings below. + 1750a | 580 \ + | a29k \ + | aarch64 | aarch64_be \ + | alpha | alphaev[4-8] | alphaev56 | alphaev6[78] | alphapca5[67] \ + | alpha64 | alpha64ev[4-8] | alpha64ev56 | alpha64ev6[78] | alpha64pca5[67] \ + | am33_2.0 \ + | arc | arceb \ + | arm | arm[bl]e | arme[lb] | armv[2-8] | armv[3-8][lb] | armv7[arm] \ + | avr | avr32 \ + | be32 | be64 \ + | bfin \ + | c4x | c8051 | clipper \ + | d10v | d30v | dlx | dsp16xx \ + | epiphany \ + | fido | fr30 | frv \ + | h8300 | h8500 | hppa | hppa1.[01] | hppa2.0 | hppa2.0[nw] | hppa64 \ + | hexagon \ + | i370 | i860 | i960 | ia64 \ + | ip2k | iq2000 \ + | k1om \ + | le32 | le64 \ + | lm32 \ + | m32c | m32r | m32rle | m68000 | m68k | m88k \ + | maxq | mb | microblaze | microblazeel | mcore | mep | metag \ + | mips | mipsbe | mipseb | mipsel | mipsle \ + | mips16 \ + | mips64 | mips64el \ + | mips64octeon | mips64octeonel \ + | mips64orion | mips64orionel \ + | mips64r5900 | mips64r5900el \ + | mips64vr | mips64vrel \ + | mips64vr4100 | mips64vr4100el \ + | mips64vr4300 | mips64vr4300el \ + | mips64vr5000 | mips64vr5000el \ + | mips64vr5900 | mips64vr5900el \ + | mipsisa32 | mipsisa32el \ + | mipsisa32r2 | mipsisa32r2el \ + | mipsisa32r6 | mipsisa32r6el \ + | mipsisa64 | mipsisa64el \ + | mipsisa64r2 | mipsisa64r2el \ + | mipsisa64r6 | mipsisa64r6el \ + | mipsisa64sb1 | mipsisa64sb1el \ + | mipsisa64sr71k | mipsisa64sr71kel \ + | mipsr5900 | mipsr5900el \ + | mipstx39 | mipstx39el \ + | mn10200 | mn10300 \ + | moxie \ + | mt \ + | msp430 \ + | nds32 | nds32le | nds32be \ + | nios | nios2 | nios2eb | nios2el \ + | ns16k | ns32k \ + | open8 | or1k | or1knd | or32 \ + | pdp10 | pdp11 | pj | pjl \ + | powerpc | powerpc64 | powerpc64le | powerpcle \ + | pyramid \ + | riscv32 | riscv64 \ + | rl78 | rx \ + | score \ + | sh | sh[1234] | sh[24]a | sh[24]aeb | sh[23]e | sh[34]eb | sheb | shbe | shle | sh[1234]le | sh3ele \ + | sh64 | sh64le \ + | sparc | sparc64 | sparc64b | sparc64v | sparc86x | sparclet | sparclite \ + | sparcv8 | sparcv9 | sparcv9b | sparcv9v \ + | spu \ + | tahoe | tic4x | tic54x | tic55x | tic6x | tic80 | tron \ + | ubicom32 \ + | v850 | v850e | v850e1 | v850e2 | v850es | v850e2v3 \ + | we32k \ + | x86 | xc16x | xstormy16 | xtensa \ + | z8k | z80) + basic_machine=$basic_machine-unknown + ;; + c54x) + basic_machine=tic54x-unknown + ;; + c55x) + basic_machine=tic55x-unknown + ;; + c6x) + basic_machine=tic6x-unknown + ;; + m6811 | m68hc11 | m6812 | m68hc12 | m68hcs12x | nvptx | picochip) + basic_machine=$basic_machine-unknown + os=-none + ;; + m88110 | m680[12346]0 | m683?2 | m68360 | m5200 | v70 | w65 | z8k) + ;; + ms1) + basic_machine=mt-unknown + ;; + + strongarm | thumb | xscale) + basic_machine=arm-unknown + ;; + xgate) + basic_machine=$basic_machine-unknown + os=-none + ;; + xscaleeb) + basic_machine=armeb-unknown + ;; + + xscaleel) + basic_machine=armel-unknown + ;; + + # We use `pc' rather than `unknown' + # because (1) that's what they normally are, and + # (2) the word "unknown" tends to confuse beginning users. + i*86 | x86_64) + basic_machine=$basic_machine-pc + ;; + # Object if more than one company name word. + *-*-*) + echo Invalid configuration \`$1\': machine \`$basic_machine\' not recognized 1>&2 + exit 1 + ;; + # Recognize the basic CPU types with company name. + 580-* \ + | a29k-* \ + | aarch64-* | aarch64_be-* \ + | alpha-* | alphaev[4-8]-* | alphaev56-* | alphaev6[78]-* \ + | alpha64-* | alpha64ev[4-8]-* | alpha64ev56-* | alpha64ev6[78]-* \ + | alphapca5[67]-* | alpha64pca5[67]-* | arc-* | arceb-* \ + | arm-* | armbe-* | armle-* | armeb-* | armv*-* \ + | avr-* | avr32-* \ + | be32-* | be64-* \ + | bfin-* | bs2000-* \ + | c[123]* | c30-* | [cjt]90-* | c4x-* \ + | c8051-* | clipper-* | craynv-* | cydra-* \ + | d10v-* | d30v-* | dlx-* \ + | elxsi-* \ + | f30[01]-* | f700-* | fido-* | fr30-* | frv-* | fx80-* \ + | h8300-* | h8500-* \ + | hppa-* | hppa1.[01]-* | hppa2.0-* | hppa2.0[nw]-* | hppa64-* \ + | hexagon-* \ + | i*86-* | i860-* | i960-* | ia64-* \ + | ip2k-* | iq2000-* \ + | k1om-* \ + | le32-* | le64-* \ + | lm32-* \ + | m32c-* | m32r-* | m32rle-* \ + | m68000-* | m680[012346]0-* | m68360-* | m683?2-* | m68k-* \ + | m88110-* | m88k-* | maxq-* | mcore-* | metag-* \ + | microblaze-* | microblazeel-* \ + | mips-* | mipsbe-* | mipseb-* | mipsel-* | mipsle-* \ + | mips16-* \ + | mips64-* | mips64el-* \ + | mips64octeon-* | mips64octeonel-* \ + | mips64orion-* | mips64orionel-* \ + | mips64r5900-* | mips64r5900el-* \ + | mips64vr-* | mips64vrel-* \ + | mips64vr4100-* | mips64vr4100el-* \ + | mips64vr4300-* | mips64vr4300el-* \ + | mips64vr5000-* | mips64vr5000el-* \ + | mips64vr5900-* | mips64vr5900el-* \ + | mipsisa32-* | mipsisa32el-* \ + | mipsisa32r2-* | mipsisa32r2el-* \ + | mipsisa32r6-* | mipsisa32r6el-* \ + | mipsisa64-* | mipsisa64el-* \ + | mipsisa64r2-* | mipsisa64r2el-* \ + | mipsisa64r6-* | mipsisa64r6el-* \ + | mipsisa64sb1-* | mipsisa64sb1el-* \ + | mipsisa64sr71k-* | mipsisa64sr71kel-* \ + | mipsr5900-* | mipsr5900el-* \ + | mipstx39-* | mipstx39el-* \ + | mmix-* \ + | mt-* \ + | msp430-* \ + | nds32-* | nds32le-* | nds32be-* \ + | nios-* | nios2-* | nios2eb-* | nios2el-* \ + | none-* | np1-* | ns16k-* | ns32k-* \ + | open8-* \ + | or1k*-* \ + | orion-* \ + | pdp10-* | pdp11-* | pj-* | pjl-* | pn-* | power-* \ + | powerpc-* | powerpc64-* | powerpc64le-* | powerpcle-* \ + | pyramid-* \ + | rl78-* | romp-* | rs6000-* | rx-* \ + | sh-* | sh[1234]-* | sh[24]a-* | sh[24]aeb-* | sh[23]e-* | sh[34]eb-* | sheb-* | shbe-* \ + | shle-* | sh[1234]le-* | sh3ele-* | sh64-* | sh64le-* \ + | sparc-* | sparc64-* | sparc64b-* | sparc64v-* | sparc86x-* | sparclet-* \ + | sparclite-* \ + | sparcv8-* | sparcv9-* | sparcv9b-* | sparcv9v-* | sv1-* | sx?-* \ + | tahoe-* \ + | tic30-* | tic4x-* | tic54x-* | tic55x-* | tic6x-* | tic80-* \ + | tile*-* \ + | tron-* \ + | ubicom32-* \ + | v850-* | v850e-* | v850e1-* | v850es-* | v850e2-* | v850e2v3-* \ + | vax-* \ + | we32k-* \ + | x86-* | x86_64-* | xc16x-* | xps100-* \ + | xstormy16-* | xtensa*-* \ + | ymp-* \ + | z8k-* | z80-*) + ;; + # Recognize the basic CPU types without company name, with glob match. + xtensa*) + basic_machine=$basic_machine-unknown + ;; + # Recognize the various machine names and aliases which stand + # for a CPU type and a company and sometimes even an OS. + 386bsd) + basic_machine=i386-unknown + os=-bsd + ;; + 3b1 | 7300 | 7300-att | att-7300 | pc7300 | safari | unixpc) + basic_machine=m68000-att + ;; + 3b*) + basic_machine=we32k-att + ;; + a29khif) + basic_machine=a29k-amd + os=-udi + ;; + abacus) + basic_machine=abacus-unknown + ;; + adobe68k) + basic_machine=m68010-adobe + os=-scout + ;; + alliant | fx80) + basic_machine=fx80-alliant + ;; + altos | altos3068) + basic_machine=m68k-altos + ;; + am29k) + basic_machine=a29k-none + os=-bsd + ;; + amd64) + basic_machine=x86_64-pc + ;; + amd64-*) + basic_machine=x86_64-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; + amdahl) + basic_machine=580-amdahl + os=-sysv + ;; + amiga | amiga-*) + basic_machine=m68k-unknown + ;; + amigaos | amigados) + basic_machine=m68k-unknown + os=-amigaos + ;; + amigaunix | amix) + basic_machine=m68k-unknown + os=-sysv4 + ;; + apollo68) + basic_machine=m68k-apollo + os=-sysv + ;; + apollo68bsd) + basic_machine=m68k-apollo + os=-bsd + ;; + aros) + basic_machine=i386-pc + os=-aros + ;; + aux) + basic_machine=m68k-apple + os=-aux + ;; + balance) + basic_machine=ns32k-sequent + os=-dynix + ;; + blackfin) + basic_machine=bfin-unknown + os=-linux + ;; + blackfin-*) + basic_machine=bfin-`echo $basic_machine | sed 's/^[^-]*-//'` + os=-linux + ;; + bluegene*) + basic_machine=powerpc-ibm + os=-cnk + ;; + c54x-*) + basic_machine=tic54x-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; + c55x-*) + basic_machine=tic55x-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; + c6x-*) + basic_machine=tic6x-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; + c90) + basic_machine=c90-cray + os=-unicos + ;; + cegcc) + basic_machine=arm-unknown + os=-cegcc + ;; + convex-c1) + basic_machine=c1-convex + os=-bsd + ;; + convex-c2) + basic_machine=c2-convex + os=-bsd + ;; + convex-c32) + basic_machine=c32-convex + os=-bsd + ;; + convex-c34) + basic_machine=c34-convex + os=-bsd + ;; + convex-c38) + basic_machine=c38-convex + os=-bsd + ;; + cray | j90) + basic_machine=j90-cray + os=-unicos + ;; + craynv) + basic_machine=craynv-cray + os=-unicosmp + ;; + cr16 | cr16-*) + basic_machine=cr16-unknown + os=-elf + ;; + crds | unos) + basic_machine=m68k-crds + ;; + crisv32 | crisv32-* | etraxfs*) + basic_machine=crisv32-axis + ;; + cris | cris-* | etrax*) + basic_machine=cris-axis + ;; + crx) + basic_machine=crx-unknown + os=-elf + ;; + da30 | da30-*) + basic_machine=m68k-da30 + ;; + decstation | decstation-3100 | pmax | pmax-* | pmin | dec3100 | decstatn) + basic_machine=mips-dec + ;; + decsystem10* | dec10*) + basic_machine=pdp10-dec + os=-tops10 + ;; + decsystem20* | dec20*) + basic_machine=pdp10-dec + os=-tops20 + ;; + delta | 3300 | motorola-3300 | motorola-delta \ + | 3300-motorola | delta-motorola) + basic_machine=m68k-motorola + ;; + delta88) + basic_machine=m88k-motorola + os=-sysv3 + ;; + dicos) + basic_machine=i686-pc + os=-dicos + ;; + djgpp) + basic_machine=i586-pc + os=-msdosdjgpp + ;; + dpx20 | dpx20-*) + basic_machine=rs6000-bull + os=-bosx + ;; + dpx2* | dpx2*-bull) + basic_machine=m68k-bull + os=-sysv3 + ;; + ebmon29k) + basic_machine=a29k-amd + os=-ebmon + ;; + elxsi) + basic_machine=elxsi-elxsi + os=-bsd + ;; + encore | umax | mmax) + basic_machine=ns32k-encore + ;; + es1800 | OSE68k | ose68k | ose | OSE) + basic_machine=m68k-ericsson + os=-ose + ;; + fx2800) + basic_machine=i860-alliant + ;; + genix) + basic_machine=ns32k-ns + ;; + gmicro) + basic_machine=tron-gmicro + os=-sysv + ;; + go32) + basic_machine=i386-pc + os=-go32 + ;; + h3050r* | hiux*) + basic_machine=hppa1.1-hitachi + os=-hiuxwe2 + ;; + h8300hms) + basic_machine=h8300-hitachi + os=-hms + ;; + h8300xray) + basic_machine=h8300-hitachi + os=-xray + ;; + h8500hms) + basic_machine=h8500-hitachi + os=-hms + ;; + harris) + basic_machine=m88k-harris + os=-sysv3 + ;; + hp300-*) + basic_machine=m68k-hp + ;; + hp300bsd) + basic_machine=m68k-hp + os=-bsd + ;; + hp300hpux) + basic_machine=m68k-hp + os=-hpux + ;; + hp3k9[0-9][0-9] | hp9[0-9][0-9]) + basic_machine=hppa1.0-hp + ;; + hp9k2[0-9][0-9] | hp9k31[0-9]) + basic_machine=m68000-hp + ;; + hp9k3[2-9][0-9]) + basic_machine=m68k-hp + ;; + hp9k6[0-9][0-9] | hp6[0-9][0-9]) + basic_machine=hppa1.0-hp + ;; + hp9k7[0-79][0-9] | hp7[0-79][0-9]) + basic_machine=hppa1.1-hp + ;; + hp9k78[0-9] | hp78[0-9]) + # FIXME: really hppa2.0-hp + basic_machine=hppa1.1-hp + ;; + hp9k8[67]1 | hp8[67]1 | hp9k80[24] | hp80[24] | hp9k8[78]9 | hp8[78]9 | hp9k893 | hp893) + # FIXME: really hppa2.0-hp + basic_machine=hppa1.1-hp + ;; + hp9k8[0-9][13679] | hp8[0-9][13679]) + basic_machine=hppa1.1-hp + ;; + hp9k8[0-9][0-9] | hp8[0-9][0-9]) + basic_machine=hppa1.0-hp + ;; + hppa-next) + os=-nextstep3 + ;; + hppaosf) + basic_machine=hppa1.1-hp + os=-osf + ;; + hppro) + basic_machine=hppa1.1-hp + os=-proelf + ;; + i370-ibm* | ibm*) + basic_machine=i370-ibm + ;; + i*86v32) + basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'` + os=-sysv32 + ;; + i*86v4*) + basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'` + os=-sysv4 + ;; + i*86v) + basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'` + os=-sysv + ;; + i*86sol2) + basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'` + os=-solaris2 + ;; + i386mach) + basic_machine=i386-mach + os=-mach + ;; + i386-vsta | vsta) + basic_machine=i386-unknown + os=-vsta + ;; + iris | iris4d) + basic_machine=mips-sgi + case $os in + -irix*) + ;; + *) + os=-irix4 + ;; + esac + ;; + isi68 | isi) + basic_machine=m68k-isi + os=-sysv + ;; + m68knommu) + basic_machine=m68k-unknown + os=-linux + ;; + m68knommu-*) + basic_machine=m68k-`echo $basic_machine | sed 's/^[^-]*-//'` + os=-linux + ;; + m88k-omron*) + basic_machine=m88k-omron + ;; + magnum | m3230) + basic_machine=mips-mips + os=-sysv + ;; + merlin) + basic_machine=ns32k-utek + os=-sysv + ;; + microblaze*) + basic_machine=microblaze-xilinx + ;; + mingw64) + basic_machine=x86_64-pc + os=-mingw64 + ;; + mingw32) + basic_machine=i686-pc + os=-mingw32 + ;; + mingw32ce) + basic_machine=arm-unknown + os=-mingw32ce + ;; + miniframe) + basic_machine=m68000-convergent + ;; + *mint | -mint[0-9]* | *MiNT | *MiNT[0-9]*) + basic_machine=m68k-atari + os=-mint + ;; + mips3*-*) + basic_machine=`echo $basic_machine | sed -e 's/mips3/mips64/'` + ;; + mips3*) + basic_machine=`echo $basic_machine | sed -e 's/mips3/mips64/'`-unknown + ;; + monitor) + basic_machine=m68k-rom68k + os=-coff + ;; + morphos) + basic_machine=powerpc-unknown + os=-morphos + ;; + moxiebox) + basic_machine=moxie-unknown + os=-moxiebox + ;; + msdos) + basic_machine=i386-pc + os=-msdos + ;; + ms1-*) + basic_machine=`echo $basic_machine | sed -e 's/ms1-/mt-/'` + ;; + msys) + basic_machine=i686-pc + os=-msys + ;; + mvs) + basic_machine=i370-ibm + os=-mvs + ;; + nacl) + basic_machine=le32-unknown + os=-nacl + ;; + ncr3000) + basic_machine=i486-ncr + os=-sysv4 + ;; + netbsd386) + basic_machine=i386-unknown + os=-netbsd + ;; + netwinder) + basic_machine=armv4l-rebel + os=-linux + ;; + news | news700 | news800 | news900) + basic_machine=m68k-sony + os=-newsos + ;; + news1000) + basic_machine=m68030-sony + os=-newsos + ;; + news-3600 | risc-news) + basic_machine=mips-sony + os=-newsos + ;; + necv70) + basic_machine=v70-nec + os=-sysv + ;; + next | m*-next ) + basic_machine=m68k-next + case $os in + -nextstep* ) + ;; + -ns2*) + os=-nextstep2 + ;; + *) + os=-nextstep3 + ;; + esac + ;; + nh3000) + basic_machine=m68k-harris + os=-cxux + ;; + nh[45]000) + basic_machine=m88k-harris + os=-cxux + ;; + nindy960) + basic_machine=i960-intel + os=-nindy + ;; + mon960) + basic_machine=i960-intel + os=-mon960 + ;; + nonstopux) + basic_machine=mips-compaq + os=-nonstopux + ;; + np1) + basic_machine=np1-gould + ;; + neo-tandem) + basic_machine=neo-tandem + ;; + nse-tandem) + basic_machine=nse-tandem + ;; + nsr-tandem) + basic_machine=nsr-tandem + ;; + op50n-* | op60c-*) + basic_machine=hppa1.1-oki + os=-proelf + ;; + openrisc | openrisc-*) + basic_machine=or32-unknown + ;; + os400) + basic_machine=powerpc-ibm + os=-os400 + ;; + OSE68000 | ose68000) + basic_machine=m68000-ericsson + os=-ose + ;; + os68k) + basic_machine=m68k-none + os=-os68k + ;; + pa-hitachi) + basic_machine=hppa1.1-hitachi + os=-hiuxwe2 + ;; + paragon) + basic_machine=i860-intel + os=-osf + ;; + parisc) + basic_machine=hppa-unknown + os=-linux + ;; + parisc-*) + basic_machine=hppa-`echo $basic_machine | sed 's/^[^-]*-//'` + os=-linux + ;; + pbd) + basic_machine=sparc-tti + ;; + pbb) + basic_machine=m68k-tti + ;; + pc532 | pc532-*) + basic_machine=ns32k-pc532 + ;; + pc98) + basic_machine=i386-pc + ;; + pc98-*) + basic_machine=i386-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; + pentium | p5 | k5 | k6 | nexgen | viac3) + basic_machine=i586-pc + ;; + pentiumpro | p6 | 6x86 | athlon | athlon_*) + basic_machine=i686-pc + ;; + pentiumii | pentium2 | pentiumiii | pentium3) + basic_machine=i686-pc + ;; + pentium4) + basic_machine=i786-pc + ;; + pentium-* | p5-* | k5-* | k6-* | nexgen-* | viac3-*) + basic_machine=i586-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; + pentiumpro-* | p6-* | 6x86-* | athlon-*) + basic_machine=i686-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; + pentiumii-* | pentium2-* | pentiumiii-* | pentium3-*) + basic_machine=i686-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; + pentium4-*) + basic_machine=i786-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; + pn) + basic_machine=pn-gould + ;; + power) basic_machine=power-ibm + ;; + ppc | ppcbe) basic_machine=powerpc-unknown + ;; + ppc-* | ppcbe-*) + basic_machine=powerpc-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; + ppcle | powerpclittle | ppc-le | powerpc-little) + basic_machine=powerpcle-unknown + ;; + ppcle-* | powerpclittle-*) + basic_machine=powerpcle-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; + ppc64) basic_machine=powerpc64-unknown + ;; + ppc64-*) basic_machine=powerpc64-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; + ppc64le | powerpc64little | ppc64-le | powerpc64-little) + basic_machine=powerpc64le-unknown + ;; + ppc64le-* | powerpc64little-*) + basic_machine=powerpc64le-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; + ps2) + basic_machine=i386-ibm + ;; + pw32) + basic_machine=i586-unknown + os=-pw32 + ;; + rdos | rdos64) + basic_machine=x86_64-pc + os=-rdos + ;; + rdos32) + basic_machine=i386-pc + os=-rdos + ;; + rom68k) + basic_machine=m68k-rom68k + os=-coff + ;; + rm[46]00) + basic_machine=mips-siemens + ;; + rtpc | rtpc-*) + basic_machine=romp-ibm + ;; + s390 | s390-*) + basic_machine=s390-ibm + ;; + s390x | s390x-*) + basic_machine=s390x-ibm + ;; + sa29200) + basic_machine=a29k-amd + os=-udi + ;; + sb1) + basic_machine=mipsisa64sb1-unknown + ;; + sb1el) + basic_machine=mipsisa64sb1el-unknown + ;; + sde) + basic_machine=mipsisa32-sde + os=-elf + ;; + sei) + basic_machine=mips-sei + os=-seiux + ;; + sequent) + basic_machine=i386-sequent + ;; + sh) + basic_machine=sh-hitachi + os=-hms + ;; + sh5el) + basic_machine=sh5le-unknown + ;; + sh64) + basic_machine=sh64-unknown + ;; + sparclite-wrs | simso-wrs) + basic_machine=sparclite-wrs + os=-vxworks + ;; + sps7) + basic_machine=m68k-bull + os=-sysv2 + ;; + spur) + basic_machine=spur-unknown + ;; + st2000) + basic_machine=m68k-tandem + ;; + stratus) + basic_machine=i860-stratus + os=-sysv4 + ;; + strongarm-* | thumb-*) + basic_machine=arm-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; + sun2) + basic_machine=m68000-sun + ;; + sun2os3) + basic_machine=m68000-sun + os=-sunos3 + ;; + sun2os4) + basic_machine=m68000-sun + os=-sunos4 + ;; + sun3os3) + basic_machine=m68k-sun + os=-sunos3 + ;; + sun3os4) + basic_machine=m68k-sun + os=-sunos4 + ;; + sun4os3) + basic_machine=sparc-sun + os=-sunos3 + ;; + sun4os4) + basic_machine=sparc-sun + os=-sunos4 + ;; + sun4sol2) + basic_machine=sparc-sun + os=-solaris2 + ;; + sun3 | sun3-*) + basic_machine=m68k-sun + ;; + sun4) + basic_machine=sparc-sun + ;; + sun386 | sun386i | roadrunner) + basic_machine=i386-sun + ;; + sv1) + basic_machine=sv1-cray + os=-unicos + ;; + symmetry) + basic_machine=i386-sequent + os=-dynix + ;; + t3e) + basic_machine=alphaev5-cray + os=-unicos + ;; + t90) + basic_machine=t90-cray + os=-unicos + ;; + tile*) + basic_machine=$basic_machine-unknown + os=-linux-gnu + ;; + tx39) + basic_machine=mipstx39-unknown + ;; + tx39el) + basic_machine=mipstx39el-unknown + ;; + toad1) + basic_machine=pdp10-xkl + os=-tops20 + ;; + tower | tower-32) + basic_machine=m68k-ncr + ;; + tpf) + basic_machine=s390x-ibm + os=-tpf + ;; + udi29k) + basic_machine=a29k-amd + os=-udi + ;; + ultra3) + basic_machine=a29k-nyu + os=-sym1 + ;; + v810 | necv810) + basic_machine=v810-nec + os=-none + ;; + vaxv) + basic_machine=vax-dec + os=-sysv + ;; + vms) + basic_machine=vax-dec + os=-vms + ;; + vpp*|vx|vx-*) + basic_machine=f301-fujitsu + ;; + vxworks960) + basic_machine=i960-wrs + os=-vxworks + ;; + vxworks68) + basic_machine=m68k-wrs + os=-vxworks + ;; + vxworks29k) + basic_machine=a29k-wrs + os=-vxworks + ;; + w65*) + basic_machine=w65-wdc + os=-none + ;; + w89k-*) + basic_machine=hppa1.1-winbond + os=-proelf + ;; + xbox) + basic_machine=i686-pc + os=-mingw32 + ;; + xps | xps100) + basic_machine=xps100-honeywell + ;; + xscale-* | xscalee[bl]-*) + basic_machine=`echo $basic_machine | sed 's/^xscale/arm/'` + ;; + ymp) + basic_machine=ymp-cray + os=-unicos + ;; + z8k-*-coff) + basic_machine=z8k-unknown + os=-sim + ;; + z80-*-coff) + basic_machine=z80-unknown + os=-sim + ;; + none) + basic_machine=none-none + os=-none + ;; + +# Here we handle the default manufacturer of certain CPU types. It is in +# some cases the only manufacturer, in others, it is the most popular. + w89k) + basic_machine=hppa1.1-winbond + ;; + op50n) + basic_machine=hppa1.1-oki + ;; + op60c) + basic_machine=hppa1.1-oki + ;; + romp) + basic_machine=romp-ibm + ;; + mmix) + basic_machine=mmix-knuth + ;; + rs6000) + basic_machine=rs6000-ibm + ;; + vax) + basic_machine=vax-dec + ;; + pdp10) + # there are many clones, so DEC is not a safe bet + basic_machine=pdp10-unknown + ;; + pdp11) + basic_machine=pdp11-dec + ;; + we32k) + basic_machine=we32k-att + ;; + sh[1234] | sh[24]a | sh[24]aeb | sh[34]eb | sh[1234]le | sh[23]ele) + basic_machine=sh-unknown + ;; + sparc | sparcv8 | sparcv9 | sparcv9b | sparcv9v) + basic_machine=sparc-sun + ;; + cydra) + basic_machine=cydra-cydrome + ;; + orion) + basic_machine=orion-highlevel + ;; + orion105) + basic_machine=clipper-highlevel + ;; + mac | mpw | mac-mpw) + basic_machine=m68k-apple + ;; + pmac | pmac-mpw) + basic_machine=powerpc-apple + ;; + *-unknown) + # Make sure to match an already-canonicalized machine name. + ;; + *) + echo Invalid configuration \`$1\': machine \`$basic_machine\' not recognized 1>&2 + exit 1 + ;; +esac + +# Here we canonicalize certain aliases for manufacturers. +case $basic_machine in + *-digital*) + basic_machine=`echo $basic_machine | sed 's/digital.*/dec/'` + ;; + *-commodore*) + basic_machine=`echo $basic_machine | sed 's/commodore.*/cbm/'` + ;; + *) + ;; +esac + +# Decode manufacturer-specific aliases for certain operating systems. + +if [ x"$os" != x"" ] +then +case $os in + # First match some system type aliases + # that might get confused with valid system types. + # -solaris* is a basic system type, with this one exception. + -auroraux) + os=-auroraux + ;; + -solaris1 | -solaris1.*) + os=`echo $os | sed -e 's|solaris1|sunos4|'` + ;; + -solaris) + os=-solaris2 + ;; + -svr4*) + os=-sysv4 + ;; + -unixware*) + os=-sysv4.2uw + ;; + -gnu/linux*) + os=`echo $os | sed -e 's|gnu/linux|linux-gnu|'` + ;; + # First accept the basic system types. + # The portable systems comes first. + # Each alternative MUST END IN A *, to match a version number. + # -sysv* is not here because it comes later, after sysvr4. + -gnu* | -bsd* | -mach* | -minix* | -genix* | -ultrix* | -irix* \ + | -*vms* | -sco* | -esix* | -isc* | -aix* | -cnk* | -sunos | -sunos[34]*\ + | -hpux* | -unos* | -osf* | -luna* | -dgux* | -auroraux* | -solaris* \ + | -sym* | -kopensolaris* | -plan9* \ + | -amigaos* | -amigados* | -msdos* | -newsos* | -unicos* | -aof* \ + | -aos* | -aros* \ + | -nindy* | -vxsim* | -vxworks* | -ebmon* | -hms* | -mvs* \ + | -clix* | -riscos* | -uniplus* | -iris* | -rtu* | -xenix* \ + | -hiux* | -386bsd* | -knetbsd* | -mirbsd* | -netbsd* \ + | -bitrig* | -openbsd* | -solidbsd* \ + | -ekkobsd* | -kfreebsd* | -freebsd* | -riscix* | -lynxos* \ + | -bosx* | -nextstep* | -cxux* | -aout* | -elf* | -oabi* \ + | -ptx* | -coff* | -ecoff* | -winnt* | -domain* | -vsta* \ + | -udi* | -eabi* | -lites* | -ieee* | -go32* | -aux* \ + | -chorusos* | -chorusrdb* | -cegcc* \ + | -cygwin* | -msys* | -pe* | -psos* | -moss* | -proelf* | -rtems* \ + | -mingw32* | -mingw64* | -linux-gnu* | -linux-android* \ + | -linux-newlib* | -linux-musl* | -linux-uclibc* \ + | -uxpv* | -beos* | -mpeix* | -udk* | -moxiebox* \ + | -interix* | -uwin* | -mks* | -rhapsody* | -darwin* | -opened* \ + | -openstep* | -oskit* | -conix* | -pw32* | -nonstopux* \ + | -storm-chaos* | -tops10* | -tenex* | -tops20* | -its* \ + | -os2* | -vos* | -palmos* | -uclinux* | -nucleus* \ + | -morphos* | -superux* | -rtmk* | -rtmk-nova* | -windiss* \ + | -powermax* | -dnix* | -nx6 | -nx7 | -sei* | -dragonfly* \ + | -skyos* | -haiku* | -rdos* | -toppers* | -drops* | -es* | -tirtos*) + # Remember, each alternative MUST END IN *, to match a version number. + ;; + -qnx*) + case $basic_machine in + x86-* | i*86-*) + ;; + *) + os=-nto$os + ;; + esac + ;; + -nto-qnx*) + ;; + -nto*) + os=`echo $os | sed -e 's|nto|nto-qnx|'` + ;; + -sim | -es1800* | -hms* | -xray | -os68k* | -none* | -v88r* \ + | -windows* | -osx | -abug | -netware* | -os9* | -beos* | -haiku* \ + | -macos* | -mpw* | -magic* | -mmixware* | -mon960* | -lnews*) + ;; + -mac*) + os=`echo $os | sed -e 's|mac|macos|'` + ;; + -linux-dietlibc) + os=-linux-dietlibc + ;; + -linux*) + os=`echo $os | sed -e 's|linux|linux-gnu|'` + ;; + -sunos5*) + os=`echo $os | sed -e 's|sunos5|solaris2|'` + ;; + -sunos6*) + os=`echo $os | sed -e 's|sunos6|solaris3|'` + ;; + -opened*) + os=-openedition + ;; + -os400*) + os=-os400 + ;; + -wince*) + os=-wince + ;; + -osfrose*) + os=-osfrose + ;; + -osf*) + os=-osf + ;; + -utek*) + os=-bsd + ;; + -dynix*) + os=-bsd + ;; + -acis*) + os=-aos + ;; + -atheos*) + os=-atheos + ;; + -syllable*) + os=-syllable + ;; + -386bsd) + os=-bsd + ;; + -ctix* | -uts*) + os=-sysv + ;; + -nova*) + os=-rtmk-nova + ;; + -ns2 ) + os=-nextstep2 + ;; + -nsk*) + os=-nsk + ;; + # Preserve the version number of sinix5. + -sinix5.*) + os=`echo $os | sed -e 's|sinix|sysv|'` + ;; + -sinix*) + os=-sysv4 + ;; + -tpf*) + os=-tpf + ;; + -triton*) + os=-sysv3 + ;; + -oss*) + os=-sysv3 + ;; + -svr4) + os=-sysv4 + ;; + -svr3) + os=-sysv3 + ;; + -sysvr4) + os=-sysv4 + ;; + # This must come after -sysvr4. + -sysv*) + ;; + -ose*) + os=-ose + ;; + -es1800*) + os=-ose + ;; + -xenix) + os=-xenix + ;; + -*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*) + os=-mint + ;; + -aros*) + os=-aros + ;; + -zvmoe) + os=-zvmoe + ;; + -dicos*) + os=-dicos + ;; + -nacl*) + ;; + -none) + ;; + *) + # Get rid of the `-' at the beginning of $os. + os=`echo $os | sed 's/[^-]*-//'` + echo Invalid configuration \`$1\': system \`$os\' not recognized 1>&2 + exit 1 + ;; +esac +else + +# Here we handle the default operating systems that come with various machines. +# The value should be what the vendor currently ships out the door with their +# machine or put another way, the most popular os provided with the machine. + +# Note that if you're going to try to match "-MANUFACTURER" here (say, +# "-sun"), then you have to tell the case statement up towards the top +# that MANUFACTURER isn't an operating system. Otherwise, code above +# will signal an error saying that MANUFACTURER isn't an operating +# system, and we'll never get to this point. + +case $basic_machine in + score-*) + os=-elf + ;; + spu-*) + os=-elf + ;; + *-acorn) + os=-riscix1.2 + ;; + arm*-rebel) + os=-linux + ;; + arm*-semi) + os=-aout + ;; + c4x-* | tic4x-*) + os=-coff + ;; + c8051-*) + os=-elf + ;; + hexagon-*) + os=-elf + ;; + tic54x-*) + os=-coff + ;; + tic55x-*) + os=-coff + ;; + tic6x-*) + os=-coff + ;; + # This must come before the *-dec entry. + pdp10-*) + os=-tops20 + ;; + pdp11-*) + os=-none + ;; + *-dec | vax-*) + os=-ultrix4.2 + ;; + m68*-apollo) + os=-domain + ;; + i386-sun) + os=-sunos4.0.2 + ;; + m68000-sun) + os=-sunos3 + ;; + m68*-cisco) + os=-aout + ;; + mep-*) + os=-elf + ;; + mips*-cisco) + os=-elf + ;; + mips*-*) + os=-elf + ;; + or32-*) + os=-coff + ;; + *-tti) # must be before sparc entry or we get the wrong os. + os=-sysv3 + ;; + sparc-* | *-sun) + os=-sunos4.1.1 + ;; + *-be) + os=-beos + ;; + *-haiku) + os=-haiku + ;; + *-ibm) + os=-aix + ;; + *-knuth) + os=-mmixware + ;; + *-wec) + os=-proelf + ;; + *-winbond) + os=-proelf + ;; + *-oki) + os=-proelf + ;; + *-hp) + os=-hpux + ;; + *-hitachi) + os=-hiux + ;; + i860-* | *-att | *-ncr | *-altos | *-motorola | *-convergent) + os=-sysv + ;; + *-cbm) + os=-amigaos + ;; + *-dg) + os=-dgux + ;; + *-dolphin) + os=-sysv3 + ;; + m68k-ccur) + os=-rtu + ;; + m88k-omron*) + os=-luna + ;; + *-next ) + os=-nextstep + ;; + *-sequent) + os=-ptx + ;; + *-crds) + os=-unos + ;; + *-ns) + os=-genix + ;; + i370-*) + os=-mvs + ;; + *-next) + os=-nextstep3 + ;; + *-gould) + os=-sysv + ;; + *-highlevel) + os=-bsd + ;; + *-encore) + os=-bsd + ;; + *-sgi) + os=-irix + ;; + *-siemens) + os=-sysv4 + ;; + *-masscomp) + os=-rtu + ;; + f30[01]-fujitsu | f700-fujitsu) + os=-uxpv + ;; + *-rom68k) + os=-coff + ;; + *-*bug) + os=-coff + ;; + *-apple) + os=-macos + ;; + *-atari*) + os=-mint + ;; + *) + os=-none + ;; +esac +fi + +# Here we handle the case where we know the os, and the CPU type, but not the +# manufacturer. We pick the logical manufacturer. +vendor=unknown +case $basic_machine in + *-unknown) + case $os in + -riscix*) + vendor=acorn + ;; + -sunos*) + vendor=sun + ;; + -cnk*|-aix*) + vendor=ibm + ;; + -beos*) + vendor=be + ;; + -hpux*) + vendor=hp + ;; + -mpeix*) + vendor=hp + ;; + -hiux*) + vendor=hitachi + ;; + -unos*) + vendor=crds + ;; + -dgux*) + vendor=dg + ;; + -luna*) + vendor=omron + ;; + -genix*) + vendor=ns + ;; + -mvs* | -opened*) + vendor=ibm + ;; + -os400*) + vendor=ibm + ;; + -ptx*) + vendor=sequent + ;; + -tpf*) + vendor=ibm + ;; + -vxsim* | -vxworks* | -windiss*) + vendor=wrs + ;; + -aux*) + vendor=apple + ;; + -hms*) + vendor=hitachi + ;; + -mpw* | -macos*) + vendor=apple + ;; + -*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*) + vendor=atari + ;; + -vos*) + vendor=stratus + ;; + esac + basic_machine=`echo $basic_machine | sed "s/unknown/$vendor/"` + ;; +esac + +echo $basic_machine$os +exit + +# Local variables: +# eval: (add-hook 'write-file-hooks 'time-stamp) +# time-stamp-start: "timestamp='" +# time-stamp-format: "%:y-%02m-%02d" +# time-stamp-end: "'" +# End: diff --git a/third-party/odb/libodb-sqlite-2.4.0/config/depcomp b/third-party/odb/libodb-sqlite-2.4.0/config/depcomp new file mode 100755 index 0000000..e1f51f4 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/config/depcomp @@ -0,0 +1,787 @@ +#! /bin/sh +# depcomp - compile a program generating dependencies as side-effects + +scriptversion=2012-07-12.20; # UTC + +# Copyright (C) 1999-2012 Free Software Foundation, Inc. + +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2, or (at your option) +# any later version. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + +# As a special exception to the GNU General Public License, if you +# distribute this file as part of a program that contains a +# configuration script generated by Autoconf, you may include it under +# the same distribution terms that you use for the rest of that program. + +# Originally written by Alexandre Oliva . + +case $1 in + '') + echo "$0: No command. Try '$0 --help' for more information." 1>&2 + exit 1; + ;; + -h | --h*) + cat <<\EOF +Usage: depcomp [--help] [--version] PROGRAM [ARGS] + +Run PROGRAMS ARGS to compile a file, generating dependencies +as side-effects. + +Environment variables: + depmode Dependency tracking mode. + source Source file read by 'PROGRAMS ARGS'. + object Object file output by 'PROGRAMS ARGS'. + DEPDIR directory where to store dependencies. + depfile Dependency file to output. + tmpdepfile Temporary file to use when outputting dependencies. + libtool Whether libtool is used (yes/no). + +Report bugs to . +EOF + exit $? + ;; + -v | --v*) + echo "depcomp $scriptversion" + exit $? + ;; +esac + +# A tabulation character. +tab=' ' +# A newline character. +nl=' +' + +if test -z "$depmode" || test -z "$source" || test -z "$object"; then + echo "depcomp: Variables source, object and depmode must be set" 1>&2 + exit 1 +fi + +# Dependencies for sub/bar.o or sub/bar.obj go into sub/.deps/bar.Po. +depfile=${depfile-`echo "$object" | + sed 's|[^\\/]*$|'${DEPDIR-.deps}'/&|;s|\.\([^.]*\)$|.P\1|;s|Pobj$|Po|'`} +tmpdepfile=${tmpdepfile-`echo "$depfile" | sed 's/\.\([^.]*\)$/.T\1/'`} + +rm -f "$tmpdepfile" + +# Avoid interferences from the environment. +gccflag= dashmflag= + +# Some modes work just like other modes, but use different flags. We +# parameterize here, but still list the modes in the big case below, +# to make depend.m4 easier to write. Note that we *cannot* use a case +# here, because this file can only contain one case statement. +if test "$depmode" = hp; then + # HP compiler uses -M and no extra arg. + gccflag=-M + depmode=gcc +fi + +if test "$depmode" = dashXmstdout; then + # This is just like dashmstdout with a different argument. + dashmflag=-xM + depmode=dashmstdout +fi + +cygpath_u="cygpath -u -f -" +if test "$depmode" = msvcmsys; then + # This is just like msvisualcpp but w/o cygpath translation. + # Just convert the backslash-escaped backslashes to single forward + # slashes to satisfy depend.m4 + cygpath_u='sed s,\\\\,/,g' + depmode=msvisualcpp +fi + +if test "$depmode" = msvc7msys; then + # This is just like msvc7 but w/o cygpath translation. + # Just convert the backslash-escaped backslashes to single forward + # slashes to satisfy depend.m4 + cygpath_u='sed s,\\\\,/,g' + depmode=msvc7 +fi + +if test "$depmode" = xlc; then + # IBM C/C++ Compilers xlc/xlC can output gcc-like dependency information. + gccflag=-qmakedep=gcc,-MF + depmode=gcc +fi + +case "$depmode" in +gcc3) +## gcc 3 implements dependency tracking that does exactly what +## we want. Yay! Note: for some reason libtool 1.4 doesn't like +## it if -MD -MP comes after the -MF stuff. Hmm. +## Unfortunately, FreeBSD c89 acceptance of flags depends upon +## the command line argument order; so add the flags where they +## appear in depend2.am. Note that the slowdown incurred here +## affects only configure: in makefiles, %FASTDEP% shortcuts this. + for arg + do + case $arg in + -c) set fnord "$@" -MT "$object" -MD -MP -MF "$tmpdepfile" "$arg" ;; + *) set fnord "$@" "$arg" ;; + esac + shift # fnord + shift # $arg + done + "$@" + stat=$? + if test $stat -eq 0; then : + else + rm -f "$tmpdepfile" + exit $stat + fi + mv "$tmpdepfile" "$depfile" + ;; + +gcc) +## Note that this doesn't just cater to obsosete pre-3.x GCC compilers. +## but also to in-use compilers like IMB xlc/xlC and the HP C compiler. +## (see the conditional assignment to $gccflag above). +## There are various ways to get dependency output from gcc. Here's +## why we pick this rather obscure method: +## - Don't want to use -MD because we'd like the dependencies to end +## up in a subdir. Having to rename by hand is ugly. +## (We might end up doing this anyway to support other compilers.) +## - The DEPENDENCIES_OUTPUT environment variable makes gcc act like +## -MM, not -M (despite what the docs say). Also, it might not be +## supported by the other compilers which use the 'gcc' depmode. +## - Using -M directly means running the compiler twice (even worse +## than renaming). + if test -z "$gccflag"; then + gccflag=-MD, + fi + "$@" -Wp,"$gccflag$tmpdepfile" + stat=$? + if test $stat -eq 0; then : + else + rm -f "$tmpdepfile" + exit $stat + fi + rm -f "$depfile" + echo "$object : \\" > "$depfile" + alpha=ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz +## The second -e expression handles DOS-style file names with drive letters. + sed -e 's/^[^:]*: / /' \ + -e 's/^['$alpha']:\/[^:]*: / /' < "$tmpdepfile" >> "$depfile" +## This next piece of magic avoids the "deleted header file" problem. +## The problem is that when a header file which appears in a .P file +## is deleted, the dependency causes make to die (because there is +## typically no way to rebuild the header). We avoid this by adding +## dummy dependencies for each header file. Too bad gcc doesn't do +## this for us directly. + tr ' ' "$nl" < "$tmpdepfile" | +## Some versions of gcc put a space before the ':'. On the theory +## that the space means something, we add a space to the output as +## well. hp depmode also adds that space, but also prefixes the VPATH +## to the object. Take care to not repeat it in the output. +## Some versions of the HPUX 10.20 sed can't process this invocation +## correctly. Breaking it into two sed invocations is a workaround. + sed -e 's/^\\$//' -e '/^$/d' -e "s|.*$object$||" -e '/:$/d' \ + | sed -e 's/$/ :/' >> "$depfile" + rm -f "$tmpdepfile" + ;; + +hp) + # This case exists only to let depend.m4 do its work. It works by + # looking at the text of this script. This case will never be run, + # since it is checked for above. + exit 1 + ;; + +sgi) + if test "$libtool" = yes; then + "$@" "-Wp,-MDupdate,$tmpdepfile" + else + "$@" -MDupdate "$tmpdepfile" + fi + stat=$? + if test $stat -eq 0; then : + else + rm -f "$tmpdepfile" + exit $stat + fi + rm -f "$depfile" + + if test -f "$tmpdepfile"; then # yes, the sourcefile depend on other files + echo "$object : \\" > "$depfile" + + # Clip off the initial element (the dependent). Don't try to be + # clever and replace this with sed code, as IRIX sed won't handle + # lines with more than a fixed number of characters (4096 in + # IRIX 6.2 sed, 8192 in IRIX 6.5). We also remove comment lines; + # the IRIX cc adds comments like '#:fec' to the end of the + # dependency line. + tr ' ' "$nl" < "$tmpdepfile" \ + | sed -e 's/^.*\.o://' -e 's/#.*$//' -e '/^$/ d' | \ + tr "$nl" ' ' >> "$depfile" + echo >> "$depfile" + + # The second pass generates a dummy entry for each header file. + tr ' ' "$nl" < "$tmpdepfile" \ + | sed -e 's/^.*\.o://' -e 's/#.*$//' -e '/^$/ d' -e 's/$/:/' \ + >> "$depfile" + else + # The sourcefile does not contain any dependencies, so just + # store a dummy comment line, to avoid errors with the Makefile + # "include basename.Plo" scheme. + echo "#dummy" > "$depfile" + fi + rm -f "$tmpdepfile" + ;; + +xlc) + # This case exists only to let depend.m4 do its work. It works by + # looking at the text of this script. This case will never be run, + # since it is checked for above. + exit 1 + ;; + +aix) + # The C for AIX Compiler uses -M and outputs the dependencies + # in a .u file. In older versions, this file always lives in the + # current directory. Also, the AIX compiler puts '$object:' at the + # start of each line; $object doesn't have directory information. + # Version 6 uses the directory in both cases. + dir=`echo "$object" | sed -e 's|/[^/]*$|/|'` + test "x$dir" = "x$object" && dir= + base=`echo "$object" | sed -e 's|^.*/||' -e 's/\.o$//' -e 's/\.lo$//'` + if test "$libtool" = yes; then + tmpdepfile1=$dir$base.u + tmpdepfile2=$base.u + tmpdepfile3=$dir.libs/$base.u + "$@" -Wc,-M + else + tmpdepfile1=$dir$base.u + tmpdepfile2=$dir$base.u + tmpdepfile3=$dir$base.u + "$@" -M + fi + stat=$? + + if test $stat -eq 0; then : + else + rm -f "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3" + exit $stat + fi + + for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3" + do + test -f "$tmpdepfile" && break + done + if test -f "$tmpdepfile"; then + # Each line is of the form 'foo.o: dependent.h'. + # Do two passes, one to just change these to + # '$object: dependent.h' and one to simply 'dependent.h:'. + sed -e "s,^.*\.[a-z]*:,$object:," < "$tmpdepfile" > "$depfile" + sed -e 's,^.*\.[a-z]*:['"$tab"' ]*,,' -e 's,$,:,' < "$tmpdepfile" >> "$depfile" + else + # The sourcefile does not contain any dependencies, so just + # store a dummy comment line, to avoid errors with the Makefile + # "include basename.Plo" scheme. + echo "#dummy" > "$depfile" + fi + rm -f "$tmpdepfile" + ;; + +icc) + # Intel's C compiler anf tcc (Tiny C Compiler) understand '-MD -MF file'. + # However on + # $CC -MD -MF foo.d -c -o sub/foo.o sub/foo.c + # ICC 7.0 will fill foo.d with something like + # foo.o: sub/foo.c + # foo.o: sub/foo.h + # which is wrong. We want + # sub/foo.o: sub/foo.c + # sub/foo.o: sub/foo.h + # sub/foo.c: + # sub/foo.h: + # ICC 7.1 will output + # foo.o: sub/foo.c sub/foo.h + # and will wrap long lines using '\': + # foo.o: sub/foo.c ... \ + # sub/foo.h ... \ + # ... + # tcc 0.9.26 (FIXME still under development at the moment of writing) + # will emit a similar output, but also prepend the continuation lines + # with horizontal tabulation characters. + "$@" -MD -MF "$tmpdepfile" + stat=$? + if test $stat -eq 0; then : + else + rm -f "$tmpdepfile" + exit $stat + fi + rm -f "$depfile" + # Each line is of the form 'foo.o: dependent.h', + # or 'foo.o: dep1.h dep2.h \', or ' dep3.h dep4.h \'. + # Do two passes, one to just change these to + # '$object: dependent.h' and one to simply 'dependent.h:'. + sed -e "s/^[ $tab][ $tab]*/ /" -e "s,^[^:]*:,$object :," \ + < "$tmpdepfile" > "$depfile" + sed ' + s/[ '"$tab"'][ '"$tab"']*/ /g + s/^ *// + s/ *\\*$// + s/^[^:]*: *// + /^$/d + /:$/d + s/$/ :/ + ' < "$tmpdepfile" >> "$depfile" + rm -f "$tmpdepfile" + ;; + +## The order of this option in the case statement is important, since the +## shell code in configure will try each of these formats in the order +## listed in this file. A plain '-MD' option would be understood by many +## compilers, so we must ensure this comes after the gcc and icc options. +pgcc) + # Portland's C compiler understands '-MD'. + # Will always output deps to 'file.d' where file is the root name of the + # source file under compilation, even if file resides in a subdirectory. + # The object file name does not affect the name of the '.d' file. + # pgcc 10.2 will output + # foo.o: sub/foo.c sub/foo.h + # and will wrap long lines using '\' : + # foo.o: sub/foo.c ... \ + # sub/foo.h ... \ + # ... + dir=`echo "$object" | sed -e 's|/[^/]*$|/|'` + test "x$dir" = "x$object" && dir= + # Use the source, not the object, to determine the base name, since + # that's sadly what pgcc will do too. + base=`echo "$source" | sed -e 's|^.*/||' -e 's/\.[-_a-zA-Z0-9]*$//'` + tmpdepfile="$base.d" + + # For projects that build the same source file twice into different object + # files, the pgcc approach of using the *source* file root name can cause + # problems in parallel builds. Use a locking strategy to avoid stomping on + # the same $tmpdepfile. + lockdir="$base.d-lock" + trap "echo '$0: caught signal, cleaning up...' >&2; rm -rf $lockdir" 1 2 13 15 + numtries=100 + i=$numtries + while test $i -gt 0 ; do + # mkdir is a portable test-and-set. + if mkdir $lockdir 2>/dev/null; then + # This process acquired the lock. + "$@" -MD + stat=$? + # Release the lock. + rm -rf $lockdir + break + else + ## the lock is being held by a different process, + ## wait until the winning process is done or we timeout + while test -d $lockdir && test $i -gt 0; do + sleep 1 + i=`expr $i - 1` + done + fi + i=`expr $i - 1` + done + trap - 1 2 13 15 + if test $i -le 0; then + echo "$0: failed to acquire lock after $numtries attempts" >&2 + echo "$0: check lockdir '$lockdir'" >&2 + exit 1 + fi + + if test $stat -ne 0; then + rm -f "$tmpdepfile" + exit $stat + fi + rm -f "$depfile" + # Each line is of the form `foo.o: dependent.h', + # or `foo.o: dep1.h dep2.h \', or ` dep3.h dep4.h \'. + # Do two passes, one to just change these to + # `$object: dependent.h' and one to simply `dependent.h:'. + sed "s,^[^:]*:,$object :," < "$tmpdepfile" > "$depfile" + # Some versions of the HPUX 10.20 sed can't process this invocation + # correctly. Breaking it into two sed invocations is a workaround. + sed 's,^[^:]*: \(.*\)$,\1,;s/^\\$//;/^$/d;/:$/d' < "$tmpdepfile" | + sed -e 's/$/ :/' >> "$depfile" + rm -f "$tmpdepfile" + ;; + +hp2) + # The "hp" stanza above does not work with aCC (C++) and HP's ia64 + # compilers, which have integrated preprocessors. The correct option + # to use with these is +Maked; it writes dependencies to a file named + # 'foo.d', which lands next to the object file, wherever that + # happens to be. + # Much of this is similar to the tru64 case; see comments there. + dir=`echo "$object" | sed -e 's|/[^/]*$|/|'` + test "x$dir" = "x$object" && dir= + base=`echo "$object" | sed -e 's|^.*/||' -e 's/\.o$//' -e 's/\.lo$//'` + if test "$libtool" = yes; then + tmpdepfile1=$dir$base.d + tmpdepfile2=$dir.libs/$base.d + "$@" -Wc,+Maked + else + tmpdepfile1=$dir$base.d + tmpdepfile2=$dir$base.d + "$@" +Maked + fi + stat=$? + if test $stat -eq 0; then : + else + rm -f "$tmpdepfile1" "$tmpdepfile2" + exit $stat + fi + + for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2" + do + test -f "$tmpdepfile" && break + done + if test -f "$tmpdepfile"; then + sed -e "s,^.*\.[a-z]*:,$object:," "$tmpdepfile" > "$depfile" + # Add 'dependent.h:' lines. + sed -ne '2,${ + s/^ *// + s/ \\*$// + s/$/:/ + p + }' "$tmpdepfile" >> "$depfile" + else + echo "#dummy" > "$depfile" + fi + rm -f "$tmpdepfile" "$tmpdepfile2" + ;; + +tru64) + # The Tru64 compiler uses -MD to generate dependencies as a side + # effect. 'cc -MD -o foo.o ...' puts the dependencies into 'foo.o.d'. + # At least on Alpha/Redhat 6.1, Compaq CCC V6.2-504 seems to put + # dependencies in 'foo.d' instead, so we check for that too. + # Subdirectories are respected. + dir=`echo "$object" | sed -e 's|/[^/]*$|/|'` + test "x$dir" = "x$object" && dir= + base=`echo "$object" | sed -e 's|^.*/||' -e 's/\.o$//' -e 's/\.lo$//'` + + if test "$libtool" = yes; then + # With Tru64 cc, shared objects can also be used to make a + # static library. This mechanism is used in libtool 1.4 series to + # handle both shared and static libraries in a single compilation. + # With libtool 1.4, dependencies were output in $dir.libs/$base.lo.d. + # + # With libtool 1.5 this exception was removed, and libtool now + # generates 2 separate objects for the 2 libraries. These two + # compilations output dependencies in $dir.libs/$base.o.d and + # in $dir$base.o.d. We have to check for both files, because + # one of the two compilations can be disabled. We should prefer + # $dir$base.o.d over $dir.libs/$base.o.d because the latter is + # automatically cleaned when .libs/ is deleted, while ignoring + # the former would cause a distcleancheck panic. + tmpdepfile1=$dir.libs/$base.lo.d # libtool 1.4 + tmpdepfile2=$dir$base.o.d # libtool 1.5 + tmpdepfile3=$dir.libs/$base.o.d # libtool 1.5 + tmpdepfile4=$dir.libs/$base.d # Compaq CCC V6.2-504 + "$@" -Wc,-MD + else + tmpdepfile1=$dir$base.o.d + tmpdepfile2=$dir$base.d + tmpdepfile3=$dir$base.d + tmpdepfile4=$dir$base.d + "$@" -MD + fi + + stat=$? + if test $stat -eq 0; then : + else + rm -f "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3" "$tmpdepfile4" + exit $stat + fi + + for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3" "$tmpdepfile4" + do + test -f "$tmpdepfile" && break + done + if test -f "$tmpdepfile"; then + sed -e "s,^.*\.[a-z]*:,$object:," < "$tmpdepfile" > "$depfile" + sed -e 's,^.*\.[a-z]*:['"$tab"' ]*,,' -e 's,$,:,' < "$tmpdepfile" >> "$depfile" + else + echo "#dummy" > "$depfile" + fi + rm -f "$tmpdepfile" + ;; + +msvc7) + if test "$libtool" = yes; then + showIncludes=-Wc,-showIncludes + else + showIncludes=-showIncludes + fi + "$@" $showIncludes > "$tmpdepfile" + stat=$? + grep -v '^Note: including file: ' "$tmpdepfile" + if test "$stat" = 0; then : + else + rm -f "$tmpdepfile" + exit $stat + fi + rm -f "$depfile" + echo "$object : \\" > "$depfile" + # The first sed program below extracts the file names and escapes + # backslashes for cygpath. The second sed program outputs the file + # name when reading, but also accumulates all include files in the + # hold buffer in order to output them again at the end. This only + # works with sed implementations that can handle large buffers. + sed < "$tmpdepfile" -n ' +/^Note: including file: *\(.*\)/ { + s//\1/ + s/\\/\\\\/g + p +}' | $cygpath_u | sort -u | sed -n ' +s/ /\\ /g +s/\(.*\)/'"$tab"'\1 \\/p +s/.\(.*\) \\/\1:/ +H +$ { + s/.*/'"$tab"'/ + G + p +}' >> "$depfile" + rm -f "$tmpdepfile" + ;; + +msvc7msys) + # This case exists only to let depend.m4 do its work. It works by + # looking at the text of this script. This case will never be run, + # since it is checked for above. + exit 1 + ;; + +#nosideeffect) + # This comment above is used by automake to tell side-effect + # dependency tracking mechanisms from slower ones. + +dashmstdout) + # Important note: in order to support this mode, a compiler *must* + # always write the preprocessed file to stdout, regardless of -o. + "$@" || exit $? + + # Remove the call to Libtool. + if test "$libtool" = yes; then + while test "X$1" != 'X--mode=compile'; do + shift + done + shift + fi + + # Remove '-o $object'. + IFS=" " + for arg + do + case $arg in + -o) + shift + ;; + $object) + shift + ;; + *) + set fnord "$@" "$arg" + shift # fnord + shift # $arg + ;; + esac + done + + test -z "$dashmflag" && dashmflag=-M + # Require at least two characters before searching for ':' + # in the target name. This is to cope with DOS-style filenames: + # a dependency such as 'c:/foo/bar' could be seen as target 'c' otherwise. + "$@" $dashmflag | + sed 's:^['"$tab"' ]*[^:'"$tab"' ][^:][^:]*\:['"$tab"' ]*:'"$object"'\: :' > "$tmpdepfile" + rm -f "$depfile" + cat < "$tmpdepfile" > "$depfile" + tr ' ' "$nl" < "$tmpdepfile" | \ +## Some versions of the HPUX 10.20 sed can't process this invocation +## correctly. Breaking it into two sed invocations is a workaround. + sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' | sed -e 's/$/ :/' >> "$depfile" + rm -f "$tmpdepfile" + ;; + +dashXmstdout) + # This case only exists to satisfy depend.m4. It is never actually + # run, as this mode is specially recognized in the preamble. + exit 1 + ;; + +makedepend) + "$@" || exit $? + # Remove any Libtool call + if test "$libtool" = yes; then + while test "X$1" != 'X--mode=compile'; do + shift + done + shift + fi + # X makedepend + shift + cleared=no eat=no + for arg + do + case $cleared in + no) + set ""; shift + cleared=yes ;; + esac + if test $eat = yes; then + eat=no + continue + fi + case "$arg" in + -D*|-I*) + set fnord "$@" "$arg"; shift ;; + # Strip any option that makedepend may not understand. Remove + # the object too, otherwise makedepend will parse it as a source file. + -arch) + eat=yes ;; + -*|$object) + ;; + *) + set fnord "$@" "$arg"; shift ;; + esac + done + obj_suffix=`echo "$object" | sed 's/^.*\././'` + touch "$tmpdepfile" + ${MAKEDEPEND-makedepend} -o"$obj_suffix" -f"$tmpdepfile" "$@" + rm -f "$depfile" + # makedepend may prepend the VPATH from the source file name to the object. + # No need to regex-escape $object, excess matching of '.' is harmless. + sed "s|^.*\($object *:\)|\1|" "$tmpdepfile" > "$depfile" + sed '1,2d' "$tmpdepfile" | tr ' ' "$nl" | \ +## Some versions of the HPUX 10.20 sed can't process this invocation +## correctly. Breaking it into two sed invocations is a workaround. + sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' | sed -e 's/$/ :/' >> "$depfile" + rm -f "$tmpdepfile" "$tmpdepfile".bak + ;; + +cpp) + # Important note: in order to support this mode, a compiler *must* + # always write the preprocessed file to stdout. + "$@" || exit $? + + # Remove the call to Libtool. + if test "$libtool" = yes; then + while test "X$1" != 'X--mode=compile'; do + shift + done + shift + fi + + # Remove '-o $object'. + IFS=" " + for arg + do + case $arg in + -o) + shift + ;; + $object) + shift + ;; + *) + set fnord "$@" "$arg" + shift # fnord + shift # $arg + ;; + esac + done + + "$@" -E | + sed -n -e '/^# [0-9][0-9]* "\([^"]*\)".*/ s:: \1 \\:p' \ + -e '/^#line [0-9][0-9]* "\([^"]*\)".*/ s:: \1 \\:p' | + sed '$ s: \\$::' > "$tmpdepfile" + rm -f "$depfile" + echo "$object : \\" > "$depfile" + cat < "$tmpdepfile" >> "$depfile" + sed < "$tmpdepfile" '/^$/d;s/^ //;s/ \\$//;s/$/ :/' >> "$depfile" + rm -f "$tmpdepfile" + ;; + +msvisualcpp) + # Important note: in order to support this mode, a compiler *must* + # always write the preprocessed file to stdout. + "$@" || exit $? + + # Remove the call to Libtool. + if test "$libtool" = yes; then + while test "X$1" != 'X--mode=compile'; do + shift + done + shift + fi + + IFS=" " + for arg + do + case "$arg" in + -o) + shift + ;; + $object) + shift + ;; + "-Gm"|"/Gm"|"-Gi"|"/Gi"|"-ZI"|"/ZI") + set fnord "$@" + shift + shift + ;; + *) + set fnord "$@" "$arg" + shift + shift + ;; + esac + done + "$@" -E 2>/dev/null | + sed -n '/^#line [0-9][0-9]* "\([^"]*\)"/ s::\1:p' | $cygpath_u | sort -u > "$tmpdepfile" + rm -f "$depfile" + echo "$object : \\" > "$depfile" + sed < "$tmpdepfile" -n -e 's% %\\ %g' -e '/^\(.*\)$/ s::'"$tab"'\1 \\:p' >> "$depfile" + echo "$tab" >> "$depfile" + sed < "$tmpdepfile" -n -e 's% %\\ %g' -e '/^\(.*\)$/ s::\1\::p' >> "$depfile" + rm -f "$tmpdepfile" + ;; + +msvcmsys) + # This case exists only to let depend.m4 do its work. It works by + # looking at the text of this script. This case will never be run, + # since it is checked for above. + exit 1 + ;; + +none) + exec "$@" + ;; + +*) + echo "Unknown depmode $depmode" 1>&2 + exit 1 + ;; +esac + +exit 0 + +# Local Variables: +# mode: shell-script +# sh-indentation: 2 +# eval: (add-hook 'write-file-hooks 'time-stamp) +# time-stamp-start: "scriptversion=" +# time-stamp-format: "%:y-%02m-%02d.%02H" +# time-stamp-time-zone: "UTC" +# time-stamp-end: "; # UTC" +# End: diff --git a/third-party/odb/libodb-sqlite-2.4.0/config/install-sh b/third-party/odb/libodb-sqlite-2.4.0/config/install-sh new file mode 100755 index 0000000..377bb86 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/config/install-sh @@ -0,0 +1,527 @@ +#!/bin/sh +# install - install a program, script, or datafile + +scriptversion=2011-11-20.07; # UTC + +# This originates from X11R5 (mit/util/scripts/install.sh), which was +# later released in X11R6 (xc/config/util/install.sh) with the +# following copyright and license. +# +# Copyright (C) 1994 X Consortium +# +# 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 +# X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +# AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNEC- +# TION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +# +# Except as contained in this notice, the name of the X Consortium shall not +# be used in advertising or otherwise to promote the sale, use or other deal- +# ings in this Software without prior written authorization from the X Consor- +# tium. +# +# +# FSF changes to this file are in the public domain. +# +# Calling this script install-sh is preferred over install.sh, to prevent +# 'make' implicit rules from creating a file called install from it +# when there is no Makefile. +# +# This script is compatible with the BSD install script, but was written +# from scratch. + +nl=' +' +IFS=" "" $nl" + +# set DOITPROG to echo to test this script + +# Don't use :- since 4.3BSD and earlier shells don't like it. +doit=${DOITPROG-} +if test -z "$doit"; then + doit_exec=exec +else + doit_exec=$doit +fi + +# Put in absolute file names if you don't have them in your path; +# or use environment vars. + +chgrpprog=${CHGRPPROG-chgrp} +chmodprog=${CHMODPROG-chmod} +chownprog=${CHOWNPROG-chown} +cmpprog=${CMPPROG-cmp} +cpprog=${CPPROG-cp} +mkdirprog=${MKDIRPROG-mkdir} +mvprog=${MVPROG-mv} +rmprog=${RMPROG-rm} +stripprog=${STRIPPROG-strip} + +posix_glob='?' +initialize_posix_glob=' + test "$posix_glob" != "?" || { + if (set -f) 2>/dev/null; then + posix_glob= + else + posix_glob=: + fi + } +' + +posix_mkdir= + +# Desired mode of installed file. +mode=0755 + +chgrpcmd= +chmodcmd=$chmodprog +chowncmd= +mvcmd=$mvprog +rmcmd="$rmprog -f" +stripcmd= + +src= +dst= +dir_arg= +dst_arg= + +copy_on_change=false +no_target_directory= + +usage="\ +Usage: $0 [OPTION]... [-T] SRCFILE DSTFILE + or: $0 [OPTION]... SRCFILES... DIRECTORY + or: $0 [OPTION]... -t DIRECTORY SRCFILES... + or: $0 [OPTION]... -d DIRECTORIES... + +In the 1st form, copy SRCFILE to DSTFILE. +In the 2nd and 3rd, copy all SRCFILES to DIRECTORY. +In the 4th, create DIRECTORIES. + +Options: + --help display this help and exit. + --version display version info and exit. + + -c (ignored) + -C install only if different (preserve the last data modification time) + -d create directories instead of installing files. + -g GROUP $chgrpprog installed files to GROUP. + -m MODE $chmodprog installed files to MODE. + -o USER $chownprog installed files to USER. + -s $stripprog installed files. + -t DIRECTORY install into DIRECTORY. + -T report an error if DSTFILE is a directory. + +Environment variables override the default commands: + CHGRPPROG CHMODPROG CHOWNPROG CMPPROG CPPROG MKDIRPROG MVPROG + RMPROG STRIPPROG +" + +while test $# -ne 0; do + case $1 in + -c) ;; + + -C) copy_on_change=true;; + + -d) dir_arg=true;; + + -g) chgrpcmd="$chgrpprog $2" + shift;; + + --help) echo "$usage"; exit $?;; + + -m) mode=$2 + case $mode in + *' '* | *' '* | *' +'* | *'*'* | *'?'* | *'['*) + echo "$0: invalid mode: $mode" >&2 + exit 1;; + esac + shift;; + + -o) chowncmd="$chownprog $2" + shift;; + + -s) stripcmd=$stripprog;; + + -t) dst_arg=$2 + # Protect names problematic for 'test' and other utilities. + case $dst_arg in + -* | [=\(\)!]) dst_arg=./$dst_arg;; + esac + shift;; + + -T) no_target_directory=true;; + + --version) echo "$0 $scriptversion"; exit $?;; + + --) shift + break;; + + -*) echo "$0: invalid option: $1" >&2 + exit 1;; + + *) break;; + esac + shift +done + +if test $# -ne 0 && test -z "$dir_arg$dst_arg"; then + # When -d is used, all remaining arguments are directories to create. + # When -t is used, the destination is already specified. + # Otherwise, the last argument is the destination. Remove it from $@. + for arg + do + if test -n "$dst_arg"; then + # $@ is not empty: it contains at least $arg. + set fnord "$@" "$dst_arg" + shift # fnord + fi + shift # arg + dst_arg=$arg + # Protect names problematic for 'test' and other utilities. + case $dst_arg in + -* | [=\(\)!]) dst_arg=./$dst_arg;; + esac + done +fi + +if test $# -eq 0; then + if test -z "$dir_arg"; then + echo "$0: no input file specified." >&2 + exit 1 + fi + # It's OK to call 'install-sh -d' without argument. + # This can happen when creating conditional directories. + exit 0 +fi + +if test -z "$dir_arg"; then + do_exit='(exit $ret); exit $ret' + trap "ret=129; $do_exit" 1 + trap "ret=130; $do_exit" 2 + trap "ret=141; $do_exit" 13 + trap "ret=143; $do_exit" 15 + + # Set umask so as not to create temps with too-generous modes. + # However, 'strip' requires both read and write access to temps. + case $mode in + # Optimize common cases. + *644) cp_umask=133;; + *755) cp_umask=22;; + + *[0-7]) + if test -z "$stripcmd"; then + u_plus_rw= + else + u_plus_rw='% 200' + fi + cp_umask=`expr '(' 777 - $mode % 1000 ')' $u_plus_rw`;; + *) + if test -z "$stripcmd"; then + u_plus_rw= + else + u_plus_rw=,u+rw + fi + cp_umask=$mode$u_plus_rw;; + esac +fi + +for src +do + # Protect names problematic for 'test' and other utilities. + case $src in + -* | [=\(\)!]) src=./$src;; + esac + + if test -n "$dir_arg"; then + dst=$src + dstdir=$dst + test -d "$dstdir" + dstdir_status=$? + else + + # Waiting for this to be detected by the "$cpprog $src $dsttmp" command + # might cause directories to be created, which would be especially bad + # if $src (and thus $dsttmp) contains '*'. + if test ! -f "$src" && test ! -d "$src"; then + echo "$0: $src does not exist." >&2 + exit 1 + fi + + if test -z "$dst_arg"; then + echo "$0: no destination specified." >&2 + exit 1 + fi + dst=$dst_arg + + # If destination is a directory, append the input filename; won't work + # if double slashes aren't ignored. + if test -d "$dst"; then + if test -n "$no_target_directory"; then + echo "$0: $dst_arg: Is a directory" >&2 + exit 1 + fi + dstdir=$dst + dst=$dstdir/`basename "$src"` + dstdir_status=0 + else + # Prefer dirname, but fall back on a substitute if dirname fails. + dstdir=` + (dirname "$dst") 2>/dev/null || + expr X"$dst" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ + X"$dst" : 'X\(//\)[^/]' \| \ + X"$dst" : 'X\(//\)$' \| \ + X"$dst" : 'X\(/\)' \| . 2>/dev/null || + echo X"$dst" | + sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ + s//\1/ + q + } + /^X\(\/\/\)[^/].*/{ + s//\1/ + q + } + /^X\(\/\/\)$/{ + s//\1/ + q + } + /^X\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q' + ` + + test -d "$dstdir" + dstdir_status=$? + fi + fi + + obsolete_mkdir_used=false + + if test $dstdir_status != 0; then + case $posix_mkdir in + '') + # Create intermediate dirs using mode 755 as modified by the umask. + # This is like FreeBSD 'install' as of 1997-10-28. + umask=`umask` + case $stripcmd.$umask in + # Optimize common cases. + *[2367][2367]) mkdir_umask=$umask;; + .*0[02][02] | .[02][02] | .[02]) mkdir_umask=22;; + + *[0-7]) + mkdir_umask=`expr $umask + 22 \ + - $umask % 100 % 40 + $umask % 20 \ + - $umask % 10 % 4 + $umask % 2 + `;; + *) mkdir_umask=$umask,go-w;; + esac + + # With -d, create the new directory with the user-specified mode. + # Otherwise, rely on $mkdir_umask. + if test -n "$dir_arg"; then + mkdir_mode=-m$mode + else + mkdir_mode= + fi + + posix_mkdir=false + case $umask in + *[123567][0-7][0-7]) + # POSIX mkdir -p sets u+wx bits regardless of umask, which + # is incompatible with FreeBSD 'install' when (umask & 300) != 0. + ;; + *) + tmpdir=${TMPDIR-/tmp}/ins$RANDOM-$$ + trap 'ret=$?; rmdir "$tmpdir/d" "$tmpdir" 2>/dev/null; exit $ret' 0 + + if (umask $mkdir_umask && + exec $mkdirprog $mkdir_mode -p -- "$tmpdir/d") >/dev/null 2>&1 + then + if test -z "$dir_arg" || { + # Check for POSIX incompatibilities with -m. + # HP-UX 11.23 and IRIX 6.5 mkdir -m -p sets group- or + # other-writable bit of parent directory when it shouldn't. + # FreeBSD 6.1 mkdir -m -p sets mode of existing directory. + ls_ld_tmpdir=`ls -ld "$tmpdir"` + case $ls_ld_tmpdir in + d????-?r-*) different_mode=700;; + d????-?--*) different_mode=755;; + *) false;; + esac && + $mkdirprog -m$different_mode -p -- "$tmpdir" && { + ls_ld_tmpdir_1=`ls -ld "$tmpdir"` + test "$ls_ld_tmpdir" = "$ls_ld_tmpdir_1" + } + } + then posix_mkdir=: + fi + rmdir "$tmpdir/d" "$tmpdir" + else + # Remove any dirs left behind by ancient mkdir implementations. + rmdir ./$mkdir_mode ./-p ./-- 2>/dev/null + fi + trap '' 0;; + esac;; + esac + + if + $posix_mkdir && ( + umask $mkdir_umask && + $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir" + ) + then : + else + + # The umask is ridiculous, or mkdir does not conform to POSIX, + # or it failed possibly due to a race condition. Create the + # directory the slow way, step by step, checking for races as we go. + + case $dstdir in + /*) prefix='/';; + [-=\(\)!]*) prefix='./';; + *) prefix='';; + esac + + eval "$initialize_posix_glob" + + oIFS=$IFS + IFS=/ + $posix_glob set -f + set fnord $dstdir + shift + $posix_glob set +f + IFS=$oIFS + + prefixes= + + for d + do + test X"$d" = X && continue + + prefix=$prefix$d + if test -d "$prefix"; then + prefixes= + else + if $posix_mkdir; then + (umask=$mkdir_umask && + $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir") && break + # Don't fail if two instances are running concurrently. + test -d "$prefix" || exit 1 + else + case $prefix in + *\'*) qprefix=`echo "$prefix" | sed "s/'/'\\\\\\\\''/g"`;; + *) qprefix=$prefix;; + esac + prefixes="$prefixes '$qprefix'" + fi + fi + prefix=$prefix/ + done + + if test -n "$prefixes"; then + # Don't fail if two instances are running concurrently. + (umask $mkdir_umask && + eval "\$doit_exec \$mkdirprog $prefixes") || + test -d "$dstdir" || exit 1 + obsolete_mkdir_used=true + fi + fi + fi + + if test -n "$dir_arg"; then + { test -z "$chowncmd" || $doit $chowncmd "$dst"; } && + { test -z "$chgrpcmd" || $doit $chgrpcmd "$dst"; } && + { test "$obsolete_mkdir_used$chowncmd$chgrpcmd" = false || + test -z "$chmodcmd" || $doit $chmodcmd $mode "$dst"; } || exit 1 + else + + # Make a couple of temp file names in the proper directory. + dsttmp=$dstdir/_inst.$$_ + rmtmp=$dstdir/_rm.$$_ + + # Trap to clean up those temp files at exit. + trap 'ret=$?; rm -f "$dsttmp" "$rmtmp" && exit $ret' 0 + + # Copy the file name to the temp name. + (umask $cp_umask && $doit_exec $cpprog "$src" "$dsttmp") && + + # and set any options; do chmod last to preserve setuid bits. + # + # If any of these fail, we abort the whole thing. If we want to + # ignore errors from any of these, just make sure not to ignore + # errors from the above "$doit $cpprog $src $dsttmp" command. + # + { test -z "$chowncmd" || $doit $chowncmd "$dsttmp"; } && + { test -z "$chgrpcmd" || $doit $chgrpcmd "$dsttmp"; } && + { test -z "$stripcmd" || $doit $stripcmd "$dsttmp"; } && + { test -z "$chmodcmd" || $doit $chmodcmd $mode "$dsttmp"; } && + + # If -C, don't bother to copy if it wouldn't change the file. + if $copy_on_change && + old=`LC_ALL=C ls -dlL "$dst" 2>/dev/null` && + new=`LC_ALL=C ls -dlL "$dsttmp" 2>/dev/null` && + + eval "$initialize_posix_glob" && + $posix_glob set -f && + set X $old && old=:$2:$4:$5:$6 && + set X $new && new=:$2:$4:$5:$6 && + $posix_glob set +f && + + test "$old" = "$new" && + $cmpprog "$dst" "$dsttmp" >/dev/null 2>&1 + then + rm -f "$dsttmp" + else + # Rename the file to the real destination. + $doit $mvcmd -f "$dsttmp" "$dst" 2>/dev/null || + + # The rename failed, perhaps because mv can't rename something else + # to itself, or perhaps because mv is so ancient that it does not + # support -f. + { + # Now remove or move aside any old file at destination location. + # We try this two ways since rm can't unlink itself on some + # systems and the destination file might be busy for other + # reasons. In this case, the final cleanup might fail but the new + # file should still install successfully. + { + test ! -f "$dst" || + $doit $rmcmd -f "$dst" 2>/dev/null || + { $doit $mvcmd -f "$dst" "$rmtmp" 2>/dev/null && + { $doit $rmcmd -f "$rmtmp" 2>/dev/null; :; } + } || + { echo "$0: cannot unlink or rename $dst" >&2 + (exit 1); exit 1 + } + } && + + # Now rename the file to the real destination. + $doit $mvcmd "$dsttmp" "$dst" + } + fi || exit 1 + + trap '' 0 + fi +done + +# Local variables: +# eval: (add-hook 'write-file-hooks 'time-stamp) +# time-stamp-start: "scriptversion=" +# time-stamp-format: "%:y-%02m-%02d.%02H" +# time-stamp-time-zone: "UTC" +# time-stamp-end: "; # UTC" +# End: diff --git a/third-party/odb/libodb-sqlite-2.4.0/config/ltmain.sh b/third-party/odb/libodb-sqlite-2.4.0/config/ltmain.sh new file mode 100755 index 0000000..499e473 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/config/ltmain.sh @@ -0,0 +1,9661 @@ + +# libtool (GNU libtool) 2.4.2 +# Written by Gordon Matzigkeit , 1996 + +# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006, +# 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc. +# This is free software; see the source for copying conditions. There is NO +# warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + +# GNU Libtool is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. +# +# As a special exception to the GNU General Public License, +# if you distribute this file as part of a program or library that +# is built using GNU Libtool, you may include this file under the +# same distribution terms that you use for the rest of that program. +# +# GNU Libtool is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with GNU Libtool; see the file COPYING. If not, a copy +# can be downloaded from http://www.gnu.org/licenses/gpl.html, +# or obtained by writing to the Free Software Foundation, Inc., +# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + +# Usage: $progname [OPTION]... [MODE-ARG]... +# +# Provide generalized library-building support services. +# +# --config show all configuration variables +# --debug enable verbose shell tracing +# -n, --dry-run display commands without modifying any files +# --features display basic configuration information and exit +# --mode=MODE use operation mode MODE +# --preserve-dup-deps don't remove duplicate dependency libraries +# --quiet, --silent don't print informational messages +# --no-quiet, --no-silent +# print informational messages (default) +# --no-warn don't display warning messages +# --tag=TAG use configuration variables from tag TAG +# -v, --verbose print more informational messages than default +# --no-verbose don't print the extra informational messages +# --version print version information +# -h, --help, --help-all print short, long, or detailed help message +# +# MODE must be one of the following: +# +# clean remove files from the build directory +# compile compile a source file into a libtool object +# execute automatically set library path, then run a program +# finish complete the installation of libtool libraries +# install install libraries or executables +# link create a library or an executable +# uninstall remove libraries from an installed directory +# +# MODE-ARGS vary depending on the MODE. When passed as first option, +# `--mode=MODE' may be abbreviated as `MODE' or a unique abbreviation of that. +# Try `$progname --help --mode=MODE' for a more detailed description of MODE. +# +# When reporting a bug, please describe a test case to reproduce it and +# include the following information: +# +# host-triplet: $host +# shell: $SHELL +# compiler: $LTCC +# compiler flags: $LTCFLAGS +# linker: $LD (gnu? $with_gnu_ld) +# $progname: (GNU libtool) 2.4.2 Debian-2.4.2-1.2 +# automake: $automake_version +# autoconf: $autoconf_version +# +# Report bugs to . +# GNU libtool home page: . +# General help using GNU software: . + +PROGRAM=libtool +PACKAGE=libtool +VERSION="2.4.2 Debian-2.4.2-1.2" +TIMESTAMP="" +package_revision=1.3337 + +# Be Bourne compatible +if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then + emulate sh + NULLCMD=: + # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which + # is contrary to our usage. Disable this feature. + alias -g '${1+"$@"}'='"$@"' + setopt NO_GLOB_SUBST +else + case `(set -o) 2>/dev/null` in *posix*) set -o posix;; esac +fi +BIN_SH=xpg4; export BIN_SH # for Tru64 +DUALCASE=1; export DUALCASE # for MKS sh + +# A function that is used when there is no print builtin or printf. +func_fallback_echo () +{ + eval 'cat <<_LTECHO_EOF +$1 +_LTECHO_EOF' +} + +# NLS nuisances: We save the old values to restore during execute mode. +lt_user_locale= +lt_safe_locale= +for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES +do + eval "if test \"\${$lt_var+set}\" = set; then + save_$lt_var=\$$lt_var + $lt_var=C + export $lt_var + lt_user_locale=\"$lt_var=\\\$save_\$lt_var; \$lt_user_locale\" + lt_safe_locale=\"$lt_var=C; \$lt_safe_locale\" + fi" +done +LC_ALL=C +LANGUAGE=C +export LANGUAGE LC_ALL + +$lt_unset CDPATH + + +# Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh +# is ksh but when the shell is invoked as "sh" and the current value of +# the _XPG environment variable is not equal to 1 (one), the special +# positional parameter $0, within a function call, is the name of the +# function. +progpath="$0" + + + +: ${CP="cp -f"} +test "${ECHO+set}" = set || ECHO=${as_echo-'printf %s\n'} +: ${MAKE="make"} +: ${MKDIR="mkdir"} +: ${MV="mv -f"} +: ${RM="rm -f"} +: ${SHELL="${CONFIG_SHELL-/bin/sh}"} +: ${Xsed="$SED -e 1s/^X//"} + +# Global variables: +EXIT_SUCCESS=0 +EXIT_FAILURE=1 +EXIT_MISMATCH=63 # $? = 63 is used to indicate version mismatch to missing. +EXIT_SKIP=77 # $? = 77 is used to indicate a skipped test to automake. + +exit_status=$EXIT_SUCCESS + +# Make sure IFS has a sensible default +lt_nl=' +' +IFS=" $lt_nl" + +dirname="s,/[^/]*$,," +basename="s,^.*/,," + +# func_dirname file append nondir_replacement +# Compute the dirname of FILE. If nonempty, add APPEND to the result, +# otherwise set result to NONDIR_REPLACEMENT. +func_dirname () +{ + func_dirname_result=`$ECHO "${1}" | $SED "$dirname"` + if test "X$func_dirname_result" = "X${1}"; then + func_dirname_result="${3}" + else + func_dirname_result="$func_dirname_result${2}" + fi +} # func_dirname may be replaced by extended shell implementation + + +# func_basename file +func_basename () +{ + func_basename_result=`$ECHO "${1}" | $SED "$basename"` +} # func_basename may be replaced by extended shell implementation + + +# func_dirname_and_basename file append nondir_replacement +# perform func_basename and func_dirname in a single function +# call: +# dirname: Compute the dirname of FILE. If nonempty, +# add APPEND to the result, otherwise set result +# to NONDIR_REPLACEMENT. +# value returned in "$func_dirname_result" +# basename: Compute filename of FILE. +# value retuned in "$func_basename_result" +# Implementation must be kept synchronized with func_dirname +# and func_basename. For efficiency, we do not delegate to +# those functions but instead duplicate the functionality here. +func_dirname_and_basename () +{ + # Extract subdirectory from the argument. + func_dirname_result=`$ECHO "${1}" | $SED -e "$dirname"` + if test "X$func_dirname_result" = "X${1}"; then + func_dirname_result="${3}" + else + func_dirname_result="$func_dirname_result${2}" + fi + func_basename_result=`$ECHO "${1}" | $SED -e "$basename"` +} # func_dirname_and_basename may be replaced by extended shell implementation + + +# func_stripname prefix suffix name +# strip PREFIX and SUFFIX off of NAME. +# PREFIX and SUFFIX must not contain globbing or regex special +# characters, hashes, percent signs, but SUFFIX may contain a leading +# dot (in which case that matches only a dot). +# func_strip_suffix prefix name +func_stripname () +{ + case ${2} in + .*) func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%\\\\${2}\$%%"`;; + *) func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%${2}\$%%"`;; + esac +} # func_stripname may be replaced by extended shell implementation + + +# These SED scripts presuppose an absolute path with a trailing slash. +pathcar='s,^/\([^/]*\).*$,\1,' +pathcdr='s,^/[^/]*,,' +removedotparts=':dotsl + s@/\./@/@g + t dotsl + s,/\.$,/,' +collapseslashes='s@/\{1,\}@/@g' +finalslash='s,/*$,/,' + +# func_normal_abspath PATH +# Remove doubled-up and trailing slashes, "." path components, +# and cancel out any ".." path components in PATH after making +# it an absolute path. +# value returned in "$func_normal_abspath_result" +func_normal_abspath () +{ + # Start from root dir and reassemble the path. + func_normal_abspath_result= + func_normal_abspath_tpath=$1 + func_normal_abspath_altnamespace= + case $func_normal_abspath_tpath in + "") + # Empty path, that just means $cwd. + func_stripname '' '/' "`pwd`" + func_normal_abspath_result=$func_stripname_result + return + ;; + # The next three entries are used to spot a run of precisely + # two leading slashes without using negated character classes; + # we take advantage of case's first-match behaviour. + ///*) + # Unusual form of absolute path, do nothing. + ;; + //*) + # Not necessarily an ordinary path; POSIX reserves leading '//' + # and for example Cygwin uses it to access remote file shares + # over CIFS/SMB, so we conserve a leading double slash if found. + func_normal_abspath_altnamespace=/ + ;; + /*) + # Absolute path, do nothing. + ;; + *) + # Relative path, prepend $cwd. + func_normal_abspath_tpath=`pwd`/$func_normal_abspath_tpath + ;; + esac + # Cancel out all the simple stuff to save iterations. We also want + # the path to end with a slash for ease of parsing, so make sure + # there is one (and only one) here. + func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \ + -e "$removedotparts" -e "$collapseslashes" -e "$finalslash"` + while :; do + # Processed it all yet? + if test "$func_normal_abspath_tpath" = / ; then + # If we ascended to the root using ".." the result may be empty now. + if test -z "$func_normal_abspath_result" ; then + func_normal_abspath_result=/ + fi + break + fi + func_normal_abspath_tcomponent=`$ECHO "$func_normal_abspath_tpath" | $SED \ + -e "$pathcar"` + func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \ + -e "$pathcdr"` + # Figure out what to do with it + case $func_normal_abspath_tcomponent in + "") + # Trailing empty path component, ignore it. + ;; + ..) + # Parent dir; strip last assembled component from result. + func_dirname "$func_normal_abspath_result" + func_normal_abspath_result=$func_dirname_result + ;; + *) + # Actual path component, append it. + func_normal_abspath_result=$func_normal_abspath_result/$func_normal_abspath_tcomponent + ;; + esac + done + # Restore leading double-slash if one was found on entry. + func_normal_abspath_result=$func_normal_abspath_altnamespace$func_normal_abspath_result +} + +# func_relative_path SRCDIR DSTDIR +# generates a relative path from SRCDIR to DSTDIR, with a trailing +# slash if non-empty, suitable for immediately appending a filename +# without needing to append a separator. +# value returned in "$func_relative_path_result" +func_relative_path () +{ + func_relative_path_result= + func_normal_abspath "$1" + func_relative_path_tlibdir=$func_normal_abspath_result + func_normal_abspath "$2" + func_relative_path_tbindir=$func_normal_abspath_result + + # Ascend the tree starting from libdir + while :; do + # check if we have found a prefix of bindir + case $func_relative_path_tbindir in + $func_relative_path_tlibdir) + # found an exact match + func_relative_path_tcancelled= + break + ;; + $func_relative_path_tlibdir*) + # found a matching prefix + func_stripname "$func_relative_path_tlibdir" '' "$func_relative_path_tbindir" + func_relative_path_tcancelled=$func_stripname_result + if test -z "$func_relative_path_result"; then + func_relative_path_result=. + fi + break + ;; + *) + func_dirname $func_relative_path_tlibdir + func_relative_path_tlibdir=${func_dirname_result} + if test "x$func_relative_path_tlibdir" = x ; then + # Have to descend all the way to the root! + func_relative_path_result=../$func_relative_path_result + func_relative_path_tcancelled=$func_relative_path_tbindir + break + fi + func_relative_path_result=../$func_relative_path_result + ;; + esac + done + + # Now calculate path; take care to avoid doubling-up slashes. + func_stripname '' '/' "$func_relative_path_result" + func_relative_path_result=$func_stripname_result + func_stripname '/' '/' "$func_relative_path_tcancelled" + if test "x$func_stripname_result" != x ; then + func_relative_path_result=${func_relative_path_result}/${func_stripname_result} + fi + + # Normalisation. If bindir is libdir, return empty string, + # else relative path ending with a slash; either way, target + # file name can be directly appended. + if test ! -z "$func_relative_path_result"; then + func_stripname './' '' "$func_relative_path_result/" + func_relative_path_result=$func_stripname_result + fi +} + +# The name of this program: +func_dirname_and_basename "$progpath" +progname=$func_basename_result + +# Make sure we have an absolute path for reexecution: +case $progpath in + [\\/]*|[A-Za-z]:\\*) ;; + *[\\/]*) + progdir=$func_dirname_result + progdir=`cd "$progdir" && pwd` + progpath="$progdir/$progname" + ;; + *) + save_IFS="$IFS" + IFS=${PATH_SEPARATOR-:} + for progdir in $PATH; do + IFS="$save_IFS" + test -x "$progdir/$progname" && break + done + IFS="$save_IFS" + test -n "$progdir" || progdir=`pwd` + progpath="$progdir/$progname" + ;; +esac + +# Sed substitution that helps us do robust quoting. It backslashifies +# metacharacters that are still active within double-quoted strings. +Xsed="${SED}"' -e 1s/^X//' +sed_quote_subst='s/\([`"$\\]\)/\\\1/g' + +# Same as above, but do not quote variable references. +double_quote_subst='s/\(["`\\]\)/\\\1/g' + +# Sed substitution that turns a string into a regex matching for the +# string literally. +sed_make_literal_regex='s,[].[^$\\*\/],\\&,g' + +# Sed substitution that converts a w32 file name or path +# which contains forward slashes, into one that contains +# (escaped) backslashes. A very naive implementation. +lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g' + +# Re-`\' parameter expansions in output of double_quote_subst that were +# `\'-ed in input to the same. If an odd number of `\' preceded a '$' +# in input to double_quote_subst, that '$' was protected from expansion. +# Since each input `\' is now two `\'s, look for any number of runs of +# four `\'s followed by two `\'s and then a '$'. `\' that '$'. +bs='\\' +bs2='\\\\' +bs4='\\\\\\\\' +dollar='\$' +sed_double_backslash="\ + s/$bs4/&\\ +/g + s/^$bs2$dollar/$bs&/ + s/\\([^$bs]\\)$bs2$dollar/\\1$bs2$bs$dollar/g + s/\n//g" + +# Standard options: +opt_dry_run=false +opt_help=false +opt_quiet=false +opt_verbose=false +opt_warning=: + +# func_echo arg... +# Echo program name prefixed message, along with the current mode +# name if it has been set yet. +func_echo () +{ + $ECHO "$progname: ${opt_mode+$opt_mode: }$*" +} + +# func_verbose arg... +# Echo program name prefixed message in verbose mode only. +func_verbose () +{ + $opt_verbose && func_echo ${1+"$@"} + + # A bug in bash halts the script if the last line of a function + # fails when set -e is in force, so we need another command to + # work around that: + : +} + +# func_echo_all arg... +# Invoke $ECHO with all args, space-separated. +func_echo_all () +{ + $ECHO "$*" +} + +# func_error arg... +# Echo program name prefixed message to standard error. +func_error () +{ + $ECHO "$progname: ${opt_mode+$opt_mode: }"${1+"$@"} 1>&2 +} + +# func_warning arg... +# Echo program name prefixed warning message to standard error. +func_warning () +{ + $opt_warning && $ECHO "$progname: ${opt_mode+$opt_mode: }warning: "${1+"$@"} 1>&2 + + # bash bug again: + : +} + +# func_fatal_error arg... +# Echo program name prefixed message to standard error, and exit. +func_fatal_error () +{ + func_error ${1+"$@"} + exit $EXIT_FAILURE +} + +# func_fatal_help arg... +# Echo program name prefixed message to standard error, followed by +# a help hint, and exit. +func_fatal_help () +{ + func_error ${1+"$@"} + func_fatal_error "$help" +} +help="Try \`$progname --help' for more information." ## default + + +# func_grep expression filename +# Check whether EXPRESSION matches any line of FILENAME, without output. +func_grep () +{ + $GREP "$1" "$2" >/dev/null 2>&1 +} + + +# func_mkdir_p directory-path +# Make sure the entire path to DIRECTORY-PATH is available. +func_mkdir_p () +{ + my_directory_path="$1" + my_dir_list= + + if test -n "$my_directory_path" && test "$opt_dry_run" != ":"; then + + # Protect directory names starting with `-' + case $my_directory_path in + -*) my_directory_path="./$my_directory_path" ;; + esac + + # While some portion of DIR does not yet exist... + while test ! -d "$my_directory_path"; do + # ...make a list in topmost first order. Use a colon delimited + # list incase some portion of path contains whitespace. + my_dir_list="$my_directory_path:$my_dir_list" + + # If the last portion added has no slash in it, the list is done + case $my_directory_path in */*) ;; *) break ;; esac + + # ...otherwise throw away the child directory and loop + my_directory_path=`$ECHO "$my_directory_path" | $SED -e "$dirname"` + done + my_dir_list=`$ECHO "$my_dir_list" | $SED 's,:*$,,'` + + save_mkdir_p_IFS="$IFS"; IFS=':' + for my_dir in $my_dir_list; do + IFS="$save_mkdir_p_IFS" + # mkdir can fail with a `File exist' error if two processes + # try to create one of the directories concurrently. Don't + # stop in that case! + $MKDIR "$my_dir" 2>/dev/null || : + done + IFS="$save_mkdir_p_IFS" + + # Bail out if we (or some other process) failed to create a directory. + test -d "$my_directory_path" || \ + func_fatal_error "Failed to create \`$1'" + fi +} + + +# func_mktempdir [string] +# Make a temporary directory that won't clash with other running +# libtool processes, and avoids race conditions if possible. If +# given, STRING is the basename for that directory. +func_mktempdir () +{ + my_template="${TMPDIR-/tmp}/${1-$progname}" + + if test "$opt_dry_run" = ":"; then + # Return a directory name, but don't create it in dry-run mode + my_tmpdir="${my_template}-$$" + else + + # If mktemp works, use that first and foremost + my_tmpdir=`mktemp -d "${my_template}-XXXXXXXX" 2>/dev/null` + + if test ! -d "$my_tmpdir"; then + # Failing that, at least try and use $RANDOM to avoid a race + my_tmpdir="${my_template}-${RANDOM-0}$$" + + save_mktempdir_umask=`umask` + umask 0077 + $MKDIR "$my_tmpdir" + umask $save_mktempdir_umask + fi + + # If we're not in dry-run mode, bomb out on failure + test -d "$my_tmpdir" || \ + func_fatal_error "cannot create temporary directory \`$my_tmpdir'" + fi + + $ECHO "$my_tmpdir" +} + + +# func_quote_for_eval arg +# Aesthetically quote ARG to be evaled later. +# This function returns two values: FUNC_QUOTE_FOR_EVAL_RESULT +# is double-quoted, suitable for a subsequent eval, whereas +# FUNC_QUOTE_FOR_EVAL_UNQUOTED_RESULT has merely all characters +# which are still active within double quotes backslashified. +func_quote_for_eval () +{ + case $1 in + *[\\\`\"\$]*) + func_quote_for_eval_unquoted_result=`$ECHO "$1" | $SED "$sed_quote_subst"` ;; + *) + func_quote_for_eval_unquoted_result="$1" ;; + esac + + case $func_quote_for_eval_unquoted_result in + # Double-quote args containing shell metacharacters to delay + # word splitting, command substitution and and variable + # expansion for a subsequent eval. + # Many Bourne shells cannot handle close brackets correctly + # in scan sets, so we specify it separately. + *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"") + func_quote_for_eval_result="\"$func_quote_for_eval_unquoted_result\"" + ;; + *) + func_quote_for_eval_result="$func_quote_for_eval_unquoted_result" + esac +} + + +# func_quote_for_expand arg +# Aesthetically quote ARG to be evaled later; same as above, +# but do not quote variable references. +func_quote_for_expand () +{ + case $1 in + *[\\\`\"]*) + my_arg=`$ECHO "$1" | $SED \ + -e "$double_quote_subst" -e "$sed_double_backslash"` ;; + *) + my_arg="$1" ;; + esac + + case $my_arg in + # Double-quote args containing shell metacharacters to delay + # word splitting and command substitution for a subsequent eval. + # Many Bourne shells cannot handle close brackets correctly + # in scan sets, so we specify it separately. + *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"") + my_arg="\"$my_arg\"" + ;; + esac + + func_quote_for_expand_result="$my_arg" +} + + +# func_show_eval cmd [fail_exp] +# Unless opt_silent is true, then output CMD. Then, if opt_dryrun is +# not true, evaluate CMD. If the evaluation of CMD fails, and FAIL_EXP +# is given, then evaluate it. +func_show_eval () +{ + my_cmd="$1" + my_fail_exp="${2-:}" + + ${opt_silent-false} || { + func_quote_for_expand "$my_cmd" + eval "func_echo $func_quote_for_expand_result" + } + + if ${opt_dry_run-false}; then :; else + eval "$my_cmd" + my_status=$? + if test "$my_status" -eq 0; then :; else + eval "(exit $my_status); $my_fail_exp" + fi + fi +} + + +# func_show_eval_locale cmd [fail_exp] +# Unless opt_silent is true, then output CMD. Then, if opt_dryrun is +# not true, evaluate CMD. If the evaluation of CMD fails, and FAIL_EXP +# is given, then evaluate it. Use the saved locale for evaluation. +func_show_eval_locale () +{ + my_cmd="$1" + my_fail_exp="${2-:}" + + ${opt_silent-false} || { + func_quote_for_expand "$my_cmd" + eval "func_echo $func_quote_for_expand_result" + } + + if ${opt_dry_run-false}; then :; else + eval "$lt_user_locale + $my_cmd" + my_status=$? + eval "$lt_safe_locale" + if test "$my_status" -eq 0; then :; else + eval "(exit $my_status); $my_fail_exp" + fi + fi +} + +# func_tr_sh +# Turn $1 into a string suitable for a shell variable name. +# Result is stored in $func_tr_sh_result. All characters +# not in the set a-zA-Z0-9_ are replaced with '_'. Further, +# if $1 begins with a digit, a '_' is prepended as well. +func_tr_sh () +{ + case $1 in + [0-9]* | *[!a-zA-Z0-9_]*) + func_tr_sh_result=`$ECHO "$1" | $SED 's/^\([0-9]\)/_\1/; s/[^a-zA-Z0-9_]/_/g'` + ;; + * ) + func_tr_sh_result=$1 + ;; + esac +} + + +# func_version +# Echo version message to standard output and exit. +func_version () +{ + $opt_debug + + $SED -n '/(C)/!b go + :more + /\./!{ + N + s/\n# / / + b more + } + :go + /^# '$PROGRAM' (GNU /,/# warranty; / { + s/^# // + s/^# *$// + s/\((C)\)[ 0-9,-]*\( [1-9][0-9]*\)/\1\2/ + p + }' < "$progpath" + exit $? +} + +# func_usage +# Echo short help message to standard output and exit. +func_usage () +{ + $opt_debug + + $SED -n '/^# Usage:/,/^# *.*--help/ { + s/^# // + s/^# *$// + s/\$progname/'$progname'/ + p + }' < "$progpath" + echo + $ECHO "run \`$progname --help | more' for full usage" + exit $? +} + +# func_help [NOEXIT] +# Echo long help message to standard output and exit, +# unless 'noexit' is passed as argument. +func_help () +{ + $opt_debug + + $SED -n '/^# Usage:/,/# Report bugs to/ { + :print + s/^# // + s/^# *$// + s*\$progname*'$progname'* + s*\$host*'"$host"'* + s*\$SHELL*'"$SHELL"'* + s*\$LTCC*'"$LTCC"'* + s*\$LTCFLAGS*'"$LTCFLAGS"'* + s*\$LD*'"$LD"'* + s/\$with_gnu_ld/'"$with_gnu_ld"'/ + s/\$automake_version/'"`(${AUTOMAKE-automake} --version) 2>/dev/null |$SED 1q`"'/ + s/\$autoconf_version/'"`(${AUTOCONF-autoconf} --version) 2>/dev/null |$SED 1q`"'/ + p + d + } + /^# .* home page:/b print + /^# General help using/b print + ' < "$progpath" + ret=$? + if test -z "$1"; then + exit $ret + fi +} + +# func_missing_arg argname +# Echo program name prefixed message to standard error and set global +# exit_cmd. +func_missing_arg () +{ + $opt_debug + + func_error "missing argument for $1." + exit_cmd=exit +} + + +# func_split_short_opt shortopt +# Set func_split_short_opt_name and func_split_short_opt_arg shell +# variables after splitting SHORTOPT after the 2nd character. +func_split_short_opt () +{ + my_sed_short_opt='1s/^\(..\).*$/\1/;q' + my_sed_short_rest='1s/^..\(.*\)$/\1/;q' + + func_split_short_opt_name=`$ECHO "$1" | $SED "$my_sed_short_opt"` + func_split_short_opt_arg=`$ECHO "$1" | $SED "$my_sed_short_rest"` +} # func_split_short_opt may be replaced by extended shell implementation + + +# func_split_long_opt longopt +# Set func_split_long_opt_name and func_split_long_opt_arg shell +# variables after splitting LONGOPT at the `=' sign. +func_split_long_opt () +{ + my_sed_long_opt='1s/^\(--[^=]*\)=.*/\1/;q' + my_sed_long_arg='1s/^--[^=]*=//' + + func_split_long_opt_name=`$ECHO "$1" | $SED "$my_sed_long_opt"` + func_split_long_opt_arg=`$ECHO "$1" | $SED "$my_sed_long_arg"` +} # func_split_long_opt may be replaced by extended shell implementation + +exit_cmd=: + + + + + +magic="%%%MAGIC variable%%%" +magic_exe="%%%MAGIC EXE variable%%%" + +# Global variables. +nonopt= +preserve_args= +lo2o="s/\\.lo\$/.${objext}/" +o2lo="s/\\.${objext}\$/.lo/" +extracted_archives= +extracted_serial=0 + +# If this variable is set in any of the actions, the command in it +# will be execed at the end. This prevents here-documents from being +# left over by shells. +exec_cmd= + +# func_append var value +# Append VALUE to the end of shell variable VAR. +func_append () +{ + eval "${1}=\$${1}\${2}" +} # func_append may be replaced by extended shell implementation + +# func_append_quoted var value +# Quote VALUE and append to the end of shell variable VAR, separated +# by a space. +func_append_quoted () +{ + func_quote_for_eval "${2}" + eval "${1}=\$${1}\\ \$func_quote_for_eval_result" +} # func_append_quoted may be replaced by extended shell implementation + + +# func_arith arithmetic-term... +func_arith () +{ + func_arith_result=`expr "${@}"` +} # func_arith may be replaced by extended shell implementation + + +# func_len string +# STRING may not start with a hyphen. +func_len () +{ + func_len_result=`expr "${1}" : ".*" 2>/dev/null || echo $max_cmd_len` +} # func_len may be replaced by extended shell implementation + + +# func_lo2o object +func_lo2o () +{ + func_lo2o_result=`$ECHO "${1}" | $SED "$lo2o"` +} # func_lo2o may be replaced by extended shell implementation + + +# func_xform libobj-or-source +func_xform () +{ + func_xform_result=`$ECHO "${1}" | $SED 's/\.[^.]*$/.lo/'` +} # func_xform may be replaced by extended shell implementation + + +# func_fatal_configuration arg... +# Echo program name prefixed message to standard error, followed by +# a configuration failure hint, and exit. +func_fatal_configuration () +{ + func_error ${1+"$@"} + func_error "See the $PACKAGE documentation for more information." + func_fatal_error "Fatal configuration error." +} + + +# func_config +# Display the configuration for all the tags in this script. +func_config () +{ + re_begincf='^# ### BEGIN LIBTOOL' + re_endcf='^# ### END LIBTOOL' + + # Default configuration. + $SED "1,/$re_begincf CONFIG/d;/$re_endcf CONFIG/,\$d" < "$progpath" + + # Now print the configurations for the tags. + for tagname in $taglist; do + $SED -n "/$re_begincf TAG CONFIG: $tagname\$/,/$re_endcf TAG CONFIG: $tagname\$/p" < "$progpath" + done + + exit $? +} + +# func_features +# Display the features supported by this script. +func_features () +{ + echo "host: $host" + if test "$build_libtool_libs" = yes; then + echo "enable shared libraries" + else + echo "disable shared libraries" + fi + if test "$build_old_libs" = yes; then + echo "enable static libraries" + else + echo "disable static libraries" + fi + + exit $? +} + +# func_enable_tag tagname +# Verify that TAGNAME is valid, and either flag an error and exit, or +# enable the TAGNAME tag. We also add TAGNAME to the global $taglist +# variable here. +func_enable_tag () +{ + # Global variable: + tagname="$1" + + re_begincf="^# ### BEGIN LIBTOOL TAG CONFIG: $tagname\$" + re_endcf="^# ### END LIBTOOL TAG CONFIG: $tagname\$" + sed_extractcf="/$re_begincf/,/$re_endcf/p" + + # Validate tagname. + case $tagname in + *[!-_A-Za-z0-9,/]*) + func_fatal_error "invalid tag name: $tagname" + ;; + esac + + # Don't test for the "default" C tag, as we know it's + # there but not specially marked. + case $tagname in + CC) ;; + *) + if $GREP "$re_begincf" "$progpath" >/dev/null 2>&1; then + taglist="$taglist $tagname" + + # Evaluate the configuration. Be careful to quote the path + # and the sed script, to avoid splitting on whitespace, but + # also don't use non-portable quotes within backquotes within + # quotes we have to do it in 2 steps: + extractedcf=`$SED -n -e "$sed_extractcf" < "$progpath"` + eval "$extractedcf" + else + func_error "ignoring unknown tag $tagname" + fi + ;; + esac +} + +# func_check_version_match +# Ensure that we are using m4 macros, and libtool script from the same +# release of libtool. +func_check_version_match () +{ + if test "$package_revision" != "$macro_revision"; then + if test "$VERSION" != "$macro_version"; then + if test -z "$macro_version"; then + cat >&2 <<_LT_EOF +$progname: Version mismatch error. This is $PACKAGE $VERSION, but the +$progname: definition of this LT_INIT comes from an older release. +$progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION +$progname: and run autoconf again. +_LT_EOF + else + cat >&2 <<_LT_EOF +$progname: Version mismatch error. This is $PACKAGE $VERSION, but the +$progname: definition of this LT_INIT comes from $PACKAGE $macro_version. +$progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION +$progname: and run autoconf again. +_LT_EOF + fi + else + cat >&2 <<_LT_EOF +$progname: Version mismatch error. This is $PACKAGE $VERSION, revision $package_revision, +$progname: but the definition of this LT_INIT comes from revision $macro_revision. +$progname: You should recreate aclocal.m4 with macros from revision $package_revision +$progname: of $PACKAGE $VERSION and run autoconf again. +_LT_EOF + fi + + exit $EXIT_MISMATCH + fi +} + + +# Shorthand for --mode=foo, only valid as the first argument +case $1 in +clean|clea|cle|cl) + shift; set dummy --mode clean ${1+"$@"}; shift + ;; +compile|compil|compi|comp|com|co|c) + shift; set dummy --mode compile ${1+"$@"}; shift + ;; +execute|execut|execu|exec|exe|ex|e) + shift; set dummy --mode execute ${1+"$@"}; shift + ;; +finish|finis|fini|fin|fi|f) + shift; set dummy --mode finish ${1+"$@"}; shift + ;; +install|instal|insta|inst|ins|in|i) + shift; set dummy --mode install ${1+"$@"}; shift + ;; +link|lin|li|l) + shift; set dummy --mode link ${1+"$@"}; shift + ;; +uninstall|uninstal|uninsta|uninst|unins|unin|uni|un|u) + shift; set dummy --mode uninstall ${1+"$@"}; shift + ;; +esac + + + +# Option defaults: +opt_debug=: +opt_dry_run=false +opt_config=false +opt_preserve_dup_deps=false +opt_features=false +opt_finish=false +opt_help=false +opt_help_all=false +opt_silent=: +opt_warning=: +opt_verbose=: +opt_silent=false +opt_verbose=false + + +# Parse options once, thoroughly. This comes as soon as possible in the +# script to make things like `--version' happen as quickly as we can. +{ + # this just eases exit handling + while test $# -gt 0; do + opt="$1" + shift + case $opt in + --debug|-x) opt_debug='set -x' + func_echo "enabling shell trace mode" + $opt_debug + ;; + --dry-run|--dryrun|-n) + opt_dry_run=: + ;; + --config) + opt_config=: +func_config + ;; + --dlopen|-dlopen) + optarg="$1" + opt_dlopen="${opt_dlopen+$opt_dlopen +}$optarg" + shift + ;; + --preserve-dup-deps) + opt_preserve_dup_deps=: + ;; + --features) + opt_features=: +func_features + ;; + --finish) + opt_finish=: +set dummy --mode finish ${1+"$@"}; shift + ;; + --help) + opt_help=: + ;; + --help-all) + opt_help_all=: +opt_help=': help-all' + ;; + --mode) + test $# = 0 && func_missing_arg $opt && break + optarg="$1" + opt_mode="$optarg" +case $optarg in + # Valid mode arguments: + clean|compile|execute|finish|install|link|relink|uninstall) ;; + + # Catch anything else as an error + *) func_error "invalid argument for $opt" + exit_cmd=exit + break + ;; +esac + shift + ;; + --no-silent|--no-quiet) + opt_silent=false +func_append preserve_args " $opt" + ;; + --no-warning|--no-warn) + opt_warning=false +func_append preserve_args " $opt" + ;; + --no-verbose) + opt_verbose=false +func_append preserve_args " $opt" + ;; + --silent|--quiet) + opt_silent=: +func_append preserve_args " $opt" + opt_verbose=false + ;; + --verbose|-v) + opt_verbose=: +func_append preserve_args " $opt" +opt_silent=false + ;; + --tag) + test $# = 0 && func_missing_arg $opt && break + optarg="$1" + opt_tag="$optarg" +func_append preserve_args " $opt $optarg" +func_enable_tag "$optarg" + shift + ;; + + -\?|-h) func_usage ;; + --help) func_help ;; + --version) func_version ;; + + # Separate optargs to long options: + --*=*) + func_split_long_opt "$opt" + set dummy "$func_split_long_opt_name" "$func_split_long_opt_arg" ${1+"$@"} + shift + ;; + + # Separate non-argument short options: + -\?*|-h*|-n*|-v*) + func_split_short_opt "$opt" + set dummy "$func_split_short_opt_name" "-$func_split_short_opt_arg" ${1+"$@"} + shift + ;; + + --) break ;; + -*) func_fatal_help "unrecognized option \`$opt'" ;; + *) set dummy "$opt" ${1+"$@"}; shift; break ;; + esac + done + + # Validate options: + + # save first non-option argument + if test "$#" -gt 0; then + nonopt="$opt" + shift + fi + + # preserve --debug + test "$opt_debug" = : || func_append preserve_args " --debug" + + case $host in + *cygwin* | *mingw* | *pw32* | *cegcc*) + # don't eliminate duplications in $postdeps and $predeps + opt_duplicate_compiler_generated_deps=: + ;; + *) + opt_duplicate_compiler_generated_deps=$opt_preserve_dup_deps + ;; + esac + + $opt_help || { + # Sanity checks first: + func_check_version_match + + if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then + func_fatal_configuration "not configured to build any kind of library" + fi + + # Darwin sucks + eval std_shrext=\"$shrext_cmds\" + + # Only execute mode is allowed to have -dlopen flags. + if test -n "$opt_dlopen" && test "$opt_mode" != execute; then + func_error "unrecognized option \`-dlopen'" + $ECHO "$help" 1>&2 + exit $EXIT_FAILURE + fi + + # Change the help message to a mode-specific one. + generic_help="$help" + help="Try \`$progname --help --mode=$opt_mode' for more information." + } + + + # Bail if the options were screwed + $exit_cmd $EXIT_FAILURE +} + + + + +## ----------- ## +## Main. ## +## ----------- ## + +# func_lalib_p file +# True iff FILE is a libtool `.la' library or `.lo' object file. +# This function is only a basic sanity check; it will hardly flush out +# determined imposters. +func_lalib_p () +{ + test -f "$1" && + $SED -e 4q "$1" 2>/dev/null \ + | $GREP "^# Generated by .*$PACKAGE" > /dev/null 2>&1 +} + +# func_lalib_unsafe_p file +# True iff FILE is a libtool `.la' library or `.lo' object file. +# This function implements the same check as func_lalib_p without +# resorting to external programs. To this end, it redirects stdin and +# closes it afterwards, without saving the original file descriptor. +# As a safety measure, use it only where a negative result would be +# fatal anyway. Works if `file' does not exist. +func_lalib_unsafe_p () +{ + lalib_p=no + if test -f "$1" && test -r "$1" && exec 5<&0 <"$1"; then + for lalib_p_l in 1 2 3 4 + do + read lalib_p_line + case "$lalib_p_line" in + \#\ Generated\ by\ *$PACKAGE* ) lalib_p=yes; break;; + esac + done + exec 0<&5 5<&- + fi + test "$lalib_p" = yes +} + +# func_ltwrapper_script_p file +# True iff FILE is a libtool wrapper script +# This function is only a basic sanity check; it will hardly flush out +# determined imposters. +func_ltwrapper_script_p () +{ + func_lalib_p "$1" +} + +# func_ltwrapper_executable_p file +# True iff FILE is a libtool wrapper executable +# This function is only a basic sanity check; it will hardly flush out +# determined imposters. +func_ltwrapper_executable_p () +{ + func_ltwrapper_exec_suffix= + case $1 in + *.exe) ;; + *) func_ltwrapper_exec_suffix=.exe ;; + esac + $GREP "$magic_exe" "$1$func_ltwrapper_exec_suffix" >/dev/null 2>&1 +} + +# func_ltwrapper_scriptname file +# Assumes file is an ltwrapper_executable +# uses $file to determine the appropriate filename for a +# temporary ltwrapper_script. +func_ltwrapper_scriptname () +{ + func_dirname_and_basename "$1" "" "." + func_stripname '' '.exe' "$func_basename_result" + func_ltwrapper_scriptname_result="$func_dirname_result/$objdir/${func_stripname_result}_ltshwrapper" +} + +# func_ltwrapper_p file +# True iff FILE is a libtool wrapper script or wrapper executable +# This function is only a basic sanity check; it will hardly flush out +# determined imposters. +func_ltwrapper_p () +{ + func_ltwrapper_script_p "$1" || func_ltwrapper_executable_p "$1" +} + + +# func_execute_cmds commands fail_cmd +# Execute tilde-delimited COMMANDS. +# If FAIL_CMD is given, eval that upon failure. +# FAIL_CMD may read-access the current command in variable CMD! +func_execute_cmds () +{ + $opt_debug + save_ifs=$IFS; IFS='~' + for cmd in $1; do + IFS=$save_ifs + eval cmd=\"$cmd\" + func_show_eval "$cmd" "${2-:}" + done + IFS=$save_ifs +} + + +# func_source file +# Source FILE, adding directory component if necessary. +# Note that it is not necessary on cygwin/mingw to append a dot to +# FILE even if both FILE and FILE.exe exist: automatic-append-.exe +# behavior happens only for exec(3), not for open(2)! Also, sourcing +# `FILE.' does not work on cygwin managed mounts. +func_source () +{ + $opt_debug + case $1 in + */* | *\\*) . "$1" ;; + *) . "./$1" ;; + esac +} + + +# func_resolve_sysroot PATH +# Replace a leading = in PATH with a sysroot. Store the result into +# func_resolve_sysroot_result +func_resolve_sysroot () +{ + func_resolve_sysroot_result=$1 + case $func_resolve_sysroot_result in + =*) + func_stripname '=' '' "$func_resolve_sysroot_result" + func_resolve_sysroot_result=$lt_sysroot$func_stripname_result + ;; + esac +} + +# func_replace_sysroot PATH +# If PATH begins with the sysroot, replace it with = and +# store the result into func_replace_sysroot_result. +func_replace_sysroot () +{ + case "$lt_sysroot:$1" in + ?*:"$lt_sysroot"*) + func_stripname "$lt_sysroot" '' "$1" + func_replace_sysroot_result="=$func_stripname_result" + ;; + *) + # Including no sysroot. + func_replace_sysroot_result=$1 + ;; + esac +} + +# func_infer_tag arg +# Infer tagged configuration to use if any are available and +# if one wasn't chosen via the "--tag" command line option. +# Only attempt this if the compiler in the base compile +# command doesn't match the default compiler. +# arg is usually of the form 'gcc ...' +func_infer_tag () +{ + $opt_debug + if test -n "$available_tags" && test -z "$tagname"; then + CC_quoted= + for arg in $CC; do + func_append_quoted CC_quoted "$arg" + done + CC_expanded=`func_echo_all $CC` + CC_quoted_expanded=`func_echo_all $CC_quoted` + case $@ in + # Blanks in the command may have been stripped by the calling shell, + # but not from the CC environment variable when configure was run. + " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \ + " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*) ;; + # Blanks at the start of $base_compile will cause this to fail + # if we don't check for them as well. + *) + for z in $available_tags; do + if $GREP "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then + # Evaluate the configuration. + eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`" + CC_quoted= + for arg in $CC; do + # Double-quote args containing other shell metacharacters. + func_append_quoted CC_quoted "$arg" + done + CC_expanded=`func_echo_all $CC` + CC_quoted_expanded=`func_echo_all $CC_quoted` + case "$@ " in + " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \ + " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*) + # The compiler in the base compile command matches + # the one in the tagged configuration. + # Assume this is the tagged configuration we want. + tagname=$z + break + ;; + esac + fi + done + # If $tagname still isn't set, then no tagged configuration + # was found and let the user know that the "--tag" command + # line option must be used. + if test -z "$tagname"; then + func_echo "unable to infer tagged configuration" + func_fatal_error "specify a tag with \`--tag'" +# else +# func_verbose "using $tagname tagged configuration" + fi + ;; + esac + fi +} + + + +# func_write_libtool_object output_name pic_name nonpic_name +# Create a libtool object file (analogous to a ".la" file), +# but don't create it if we're doing a dry run. +func_write_libtool_object () +{ + write_libobj=${1} + if test "$build_libtool_libs" = yes; then + write_lobj=\'${2}\' + else + write_lobj=none + fi + + if test "$build_old_libs" = yes; then + write_oldobj=\'${3}\' + else + write_oldobj=none + fi + + $opt_dry_run || { + cat >${write_libobj}T </dev/null` + if test "$?" -eq 0 && test -n "${func_convert_core_file_wine_to_w32_tmp}"; then + func_convert_core_file_wine_to_w32_result=`$ECHO "$func_convert_core_file_wine_to_w32_tmp" | + $SED -e "$lt_sed_naive_backslashify"` + else + func_convert_core_file_wine_to_w32_result= + fi + fi +} +# end: func_convert_core_file_wine_to_w32 + + +# func_convert_core_path_wine_to_w32 ARG +# Helper function used by path conversion functions when $build is *nix, and +# $host is mingw, cygwin, or some other w32 environment. Relies on a correctly +# configured wine environment available, with the winepath program in $build's +# $PATH. Assumes ARG has no leading or trailing path separator characters. +# +# ARG is path to be converted from $build format to win32. +# Result is available in $func_convert_core_path_wine_to_w32_result. +# Unconvertible file (directory) names in ARG are skipped; if no directory names +# are convertible, then the result may be empty. +func_convert_core_path_wine_to_w32 () +{ + $opt_debug + # unfortunately, winepath doesn't convert paths, only file names + func_convert_core_path_wine_to_w32_result="" + if test -n "$1"; then + oldIFS=$IFS + IFS=: + for func_convert_core_path_wine_to_w32_f in $1; do + IFS=$oldIFS + func_convert_core_file_wine_to_w32 "$func_convert_core_path_wine_to_w32_f" + if test -n "$func_convert_core_file_wine_to_w32_result" ; then + if test -z "$func_convert_core_path_wine_to_w32_result"; then + func_convert_core_path_wine_to_w32_result="$func_convert_core_file_wine_to_w32_result" + else + func_append func_convert_core_path_wine_to_w32_result ";$func_convert_core_file_wine_to_w32_result" + fi + fi + done + IFS=$oldIFS + fi +} +# end: func_convert_core_path_wine_to_w32 + + +# func_cygpath ARGS... +# Wrapper around calling the cygpath program via LT_CYGPATH. This is used when +# when (1) $build is *nix and Cygwin is hosted via a wine environment; or (2) +# $build is MSYS and $host is Cygwin, or (3) $build is Cygwin. In case (1) or +# (2), returns the Cygwin file name or path in func_cygpath_result (input +# file name or path is assumed to be in w32 format, as previously converted +# from $build's *nix or MSYS format). In case (3), returns the w32 file name +# or path in func_cygpath_result (input file name or path is assumed to be in +# Cygwin format). Returns an empty string on error. +# +# ARGS are passed to cygpath, with the last one being the file name or path to +# be converted. +# +# Specify the absolute *nix (or w32) name to cygpath in the LT_CYGPATH +# environment variable; do not put it in $PATH. +func_cygpath () +{ + $opt_debug + if test -n "$LT_CYGPATH" && test -f "$LT_CYGPATH"; then + func_cygpath_result=`$LT_CYGPATH "$@" 2>/dev/null` + if test "$?" -ne 0; then + # on failure, ensure result is empty + func_cygpath_result= + fi + else + func_cygpath_result= + func_error "LT_CYGPATH is empty or specifies non-existent file: \`$LT_CYGPATH'" + fi +} +#end: func_cygpath + + +# func_convert_core_msys_to_w32 ARG +# Convert file name or path ARG from MSYS format to w32 format. Return +# result in func_convert_core_msys_to_w32_result. +func_convert_core_msys_to_w32 () +{ + $opt_debug + # awkward: cmd appends spaces to result + func_convert_core_msys_to_w32_result=`( cmd //c echo "$1" ) 2>/dev/null | + $SED -e 's/[ ]*$//' -e "$lt_sed_naive_backslashify"` +} +#end: func_convert_core_msys_to_w32 + + +# func_convert_file_check ARG1 ARG2 +# Verify that ARG1 (a file name in $build format) was converted to $host +# format in ARG2. Otherwise, emit an error message, but continue (resetting +# func_to_host_file_result to ARG1). +func_convert_file_check () +{ + $opt_debug + if test -z "$2" && test -n "$1" ; then + func_error "Could not determine host file name corresponding to" + func_error " \`$1'" + func_error "Continuing, but uninstalled executables may not work." + # Fallback: + func_to_host_file_result="$1" + fi +} +# end func_convert_file_check + + +# func_convert_path_check FROM_PATHSEP TO_PATHSEP FROM_PATH TO_PATH +# Verify that FROM_PATH (a path in $build format) was converted to $host +# format in TO_PATH. Otherwise, emit an error message, but continue, resetting +# func_to_host_file_result to a simplistic fallback value (see below). +func_convert_path_check () +{ + $opt_debug + if test -z "$4" && test -n "$3"; then + func_error "Could not determine the host path corresponding to" + func_error " \`$3'" + func_error "Continuing, but uninstalled executables may not work." + # Fallback. This is a deliberately simplistic "conversion" and + # should not be "improved". See libtool.info. + if test "x$1" != "x$2"; then + lt_replace_pathsep_chars="s|$1|$2|g" + func_to_host_path_result=`echo "$3" | + $SED -e "$lt_replace_pathsep_chars"` + else + func_to_host_path_result="$3" + fi + fi +} +# end func_convert_path_check + + +# func_convert_path_front_back_pathsep FRONTPAT BACKPAT REPL ORIG +# Modifies func_to_host_path_result by prepending REPL if ORIG matches FRONTPAT +# and appending REPL if ORIG matches BACKPAT. +func_convert_path_front_back_pathsep () +{ + $opt_debug + case $4 in + $1 ) func_to_host_path_result="$3$func_to_host_path_result" + ;; + esac + case $4 in + $2 ) func_append func_to_host_path_result "$3" + ;; + esac +} +# end func_convert_path_front_back_pathsep + + +################################################## +# $build to $host FILE NAME CONVERSION FUNCTIONS # +################################################## +# invoked via `$to_host_file_cmd ARG' +# +# In each case, ARG is the path to be converted from $build to $host format. +# Result will be available in $func_to_host_file_result. + + +# func_to_host_file ARG +# Converts the file name ARG from $build format to $host format. Return result +# in func_to_host_file_result. +func_to_host_file () +{ + $opt_debug + $to_host_file_cmd "$1" +} +# end func_to_host_file + + +# func_to_tool_file ARG LAZY +# converts the file name ARG from $build format to toolchain format. Return +# result in func_to_tool_file_result. If the conversion in use is listed +# in (the comma separated) LAZY, no conversion takes place. +func_to_tool_file () +{ + $opt_debug + case ,$2, in + *,"$to_tool_file_cmd",*) + func_to_tool_file_result=$1 + ;; + *) + $to_tool_file_cmd "$1" + func_to_tool_file_result=$func_to_host_file_result + ;; + esac +} +# end func_to_tool_file + + +# func_convert_file_noop ARG +# Copy ARG to func_to_host_file_result. +func_convert_file_noop () +{ + func_to_host_file_result="$1" +} +# end func_convert_file_noop + + +# func_convert_file_msys_to_w32 ARG +# Convert file name ARG from (mingw) MSYS to (mingw) w32 format; automatic +# conversion to w32 is not available inside the cwrapper. Returns result in +# func_to_host_file_result. +func_convert_file_msys_to_w32 () +{ + $opt_debug + func_to_host_file_result="$1" + if test -n "$1"; then + func_convert_core_msys_to_w32 "$1" + func_to_host_file_result="$func_convert_core_msys_to_w32_result" + fi + func_convert_file_check "$1" "$func_to_host_file_result" +} +# end func_convert_file_msys_to_w32 + + +# func_convert_file_cygwin_to_w32 ARG +# Convert file name ARG from Cygwin to w32 format. Returns result in +# func_to_host_file_result. +func_convert_file_cygwin_to_w32 () +{ + $opt_debug + func_to_host_file_result="$1" + if test -n "$1"; then + # because $build is cygwin, we call "the" cygpath in $PATH; no need to use + # LT_CYGPATH in this case. + func_to_host_file_result=`cygpath -m "$1"` + fi + func_convert_file_check "$1" "$func_to_host_file_result" +} +# end func_convert_file_cygwin_to_w32 + + +# func_convert_file_nix_to_w32 ARG +# Convert file name ARG from *nix to w32 format. Requires a wine environment +# and a working winepath. Returns result in func_to_host_file_result. +func_convert_file_nix_to_w32 () +{ + $opt_debug + func_to_host_file_result="$1" + if test -n "$1"; then + func_convert_core_file_wine_to_w32 "$1" + func_to_host_file_result="$func_convert_core_file_wine_to_w32_result" + fi + func_convert_file_check "$1" "$func_to_host_file_result" +} +# end func_convert_file_nix_to_w32 + + +# func_convert_file_msys_to_cygwin ARG +# Convert file name ARG from MSYS to Cygwin format. Requires LT_CYGPATH set. +# Returns result in func_to_host_file_result. +func_convert_file_msys_to_cygwin () +{ + $opt_debug + func_to_host_file_result="$1" + if test -n "$1"; then + func_convert_core_msys_to_w32 "$1" + func_cygpath -u "$func_convert_core_msys_to_w32_result" + func_to_host_file_result="$func_cygpath_result" + fi + func_convert_file_check "$1" "$func_to_host_file_result" +} +# end func_convert_file_msys_to_cygwin + + +# func_convert_file_nix_to_cygwin ARG +# Convert file name ARG from *nix to Cygwin format. Requires Cygwin installed +# in a wine environment, working winepath, and LT_CYGPATH set. Returns result +# in func_to_host_file_result. +func_convert_file_nix_to_cygwin () +{ + $opt_debug + func_to_host_file_result="$1" + if test -n "$1"; then + # convert from *nix to w32, then use cygpath to convert from w32 to cygwin. + func_convert_core_file_wine_to_w32 "$1" + func_cygpath -u "$func_convert_core_file_wine_to_w32_result" + func_to_host_file_result="$func_cygpath_result" + fi + func_convert_file_check "$1" "$func_to_host_file_result" +} +# end func_convert_file_nix_to_cygwin + + +############################################# +# $build to $host PATH CONVERSION FUNCTIONS # +############################################# +# invoked via `$to_host_path_cmd ARG' +# +# In each case, ARG is the path to be converted from $build to $host format. +# The result will be available in $func_to_host_path_result. +# +# Path separators are also converted from $build format to $host format. If +# ARG begins or ends with a path separator character, it is preserved (but +# converted to $host format) on output. +# +# All path conversion functions are named using the following convention: +# file name conversion function : func_convert_file_X_to_Y () +# path conversion function : func_convert_path_X_to_Y () +# where, for any given $build/$host combination the 'X_to_Y' value is the +# same. If conversion functions are added for new $build/$host combinations, +# the two new functions must follow this pattern, or func_init_to_host_path_cmd +# will break. + + +# func_init_to_host_path_cmd +# Ensures that function "pointer" variable $to_host_path_cmd is set to the +# appropriate value, based on the value of $to_host_file_cmd. +to_host_path_cmd= +func_init_to_host_path_cmd () +{ + $opt_debug + if test -z "$to_host_path_cmd"; then + func_stripname 'func_convert_file_' '' "$to_host_file_cmd" + to_host_path_cmd="func_convert_path_${func_stripname_result}" + fi +} + + +# func_to_host_path ARG +# Converts the path ARG from $build format to $host format. Return result +# in func_to_host_path_result. +func_to_host_path () +{ + $opt_debug + func_init_to_host_path_cmd + $to_host_path_cmd "$1" +} +# end func_to_host_path + + +# func_convert_path_noop ARG +# Copy ARG to func_to_host_path_result. +func_convert_path_noop () +{ + func_to_host_path_result="$1" +} +# end func_convert_path_noop + + +# func_convert_path_msys_to_w32 ARG +# Convert path ARG from (mingw) MSYS to (mingw) w32 format; automatic +# conversion to w32 is not available inside the cwrapper. Returns result in +# func_to_host_path_result. +func_convert_path_msys_to_w32 () +{ + $opt_debug + func_to_host_path_result="$1" + if test -n "$1"; then + # Remove leading and trailing path separator characters from ARG. MSYS + # behavior is inconsistent here; cygpath turns them into '.;' and ';.'; + # and winepath ignores them completely. + func_stripname : : "$1" + func_to_host_path_tmp1=$func_stripname_result + func_convert_core_msys_to_w32 "$func_to_host_path_tmp1" + func_to_host_path_result="$func_convert_core_msys_to_w32_result" + func_convert_path_check : ";" \ + "$func_to_host_path_tmp1" "$func_to_host_path_result" + func_convert_path_front_back_pathsep ":*" "*:" ";" "$1" + fi +} +# end func_convert_path_msys_to_w32 + + +# func_convert_path_cygwin_to_w32 ARG +# Convert path ARG from Cygwin to w32 format. Returns result in +# func_to_host_file_result. +func_convert_path_cygwin_to_w32 () +{ + $opt_debug + func_to_host_path_result="$1" + if test -n "$1"; then + # See func_convert_path_msys_to_w32: + func_stripname : : "$1" + func_to_host_path_tmp1=$func_stripname_result + func_to_host_path_result=`cygpath -m -p "$func_to_host_path_tmp1"` + func_convert_path_check : ";" \ + "$func_to_host_path_tmp1" "$func_to_host_path_result" + func_convert_path_front_back_pathsep ":*" "*:" ";" "$1" + fi +} +# end func_convert_path_cygwin_to_w32 + + +# func_convert_path_nix_to_w32 ARG +# Convert path ARG from *nix to w32 format. Requires a wine environment and +# a working winepath. Returns result in func_to_host_file_result. +func_convert_path_nix_to_w32 () +{ + $opt_debug + func_to_host_path_result="$1" + if test -n "$1"; then + # See func_convert_path_msys_to_w32: + func_stripname : : "$1" + func_to_host_path_tmp1=$func_stripname_result + func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1" + func_to_host_path_result="$func_convert_core_path_wine_to_w32_result" + func_convert_path_check : ";" \ + "$func_to_host_path_tmp1" "$func_to_host_path_result" + func_convert_path_front_back_pathsep ":*" "*:" ";" "$1" + fi +} +# end func_convert_path_nix_to_w32 + + +# func_convert_path_msys_to_cygwin ARG +# Convert path ARG from MSYS to Cygwin format. Requires LT_CYGPATH set. +# Returns result in func_to_host_file_result. +func_convert_path_msys_to_cygwin () +{ + $opt_debug + func_to_host_path_result="$1" + if test -n "$1"; then + # See func_convert_path_msys_to_w32: + func_stripname : : "$1" + func_to_host_path_tmp1=$func_stripname_result + func_convert_core_msys_to_w32 "$func_to_host_path_tmp1" + func_cygpath -u -p "$func_convert_core_msys_to_w32_result" + func_to_host_path_result="$func_cygpath_result" + func_convert_path_check : : \ + "$func_to_host_path_tmp1" "$func_to_host_path_result" + func_convert_path_front_back_pathsep ":*" "*:" : "$1" + fi +} +# end func_convert_path_msys_to_cygwin + + +# func_convert_path_nix_to_cygwin ARG +# Convert path ARG from *nix to Cygwin format. Requires Cygwin installed in a +# a wine environment, working winepath, and LT_CYGPATH set. Returns result in +# func_to_host_file_result. +func_convert_path_nix_to_cygwin () +{ + $opt_debug + func_to_host_path_result="$1" + if test -n "$1"; then + # Remove leading and trailing path separator characters from + # ARG. msys behavior is inconsistent here, cygpath turns them + # into '.;' and ';.', and winepath ignores them completely. + func_stripname : : "$1" + func_to_host_path_tmp1=$func_stripname_result + func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1" + func_cygpath -u -p "$func_convert_core_path_wine_to_w32_result" + func_to_host_path_result="$func_cygpath_result" + func_convert_path_check : : \ + "$func_to_host_path_tmp1" "$func_to_host_path_result" + func_convert_path_front_back_pathsep ":*" "*:" : "$1" + fi +} +# end func_convert_path_nix_to_cygwin + + +# func_mode_compile arg... +func_mode_compile () +{ + $opt_debug + # Get the compilation command and the source file. + base_compile= + srcfile="$nonopt" # always keep a non-empty value in "srcfile" + suppress_opt=yes + suppress_output= + arg_mode=normal + libobj= + later= + pie_flag= + + for arg + do + case $arg_mode in + arg ) + # do not "continue". Instead, add this to base_compile + lastarg="$arg" + arg_mode=normal + ;; + + target ) + libobj="$arg" + arg_mode=normal + continue + ;; + + normal ) + # Accept any command-line options. + case $arg in + -o) + test -n "$libobj" && \ + func_fatal_error "you cannot specify \`-o' more than once" + arg_mode=target + continue + ;; + + -pie | -fpie | -fPIE) + func_append pie_flag " $arg" + continue + ;; + + -shared | -static | -prefer-pic | -prefer-non-pic) + func_append later " $arg" + continue + ;; + + -no-suppress) + suppress_opt=no + continue + ;; + + -Xcompiler) + arg_mode=arg # the next one goes into the "base_compile" arg list + continue # The current "srcfile" will either be retained or + ;; # replaced later. I would guess that would be a bug. + + -Wc,*) + func_stripname '-Wc,' '' "$arg" + args=$func_stripname_result + lastarg= + save_ifs="$IFS"; IFS=',' + for arg in $args; do + IFS="$save_ifs" + func_append_quoted lastarg "$arg" + done + IFS="$save_ifs" + func_stripname ' ' '' "$lastarg" + lastarg=$func_stripname_result + + # Add the arguments to base_compile. + func_append base_compile " $lastarg" + continue + ;; + + *) + # Accept the current argument as the source file. + # The previous "srcfile" becomes the current argument. + # + lastarg="$srcfile" + srcfile="$arg" + ;; + esac # case $arg + ;; + esac # case $arg_mode + + # Aesthetically quote the previous argument. + func_append_quoted base_compile "$lastarg" + done # for arg + + case $arg_mode in + arg) + func_fatal_error "you must specify an argument for -Xcompile" + ;; + target) + func_fatal_error "you must specify a target with \`-o'" + ;; + *) + # Get the name of the library object. + test -z "$libobj" && { + func_basename "$srcfile" + libobj="$func_basename_result" + } + ;; + esac + + # Recognize several different file suffixes. + # If the user specifies -o file.o, it is replaced with file.lo + case $libobj in + *.[cCFSifmso] | \ + *.ada | *.adb | *.ads | *.asm | \ + *.c++ | *.cc | *.ii | *.class | *.cpp | *.cxx | \ + *.[fF][09]? | *.for | *.java | *.go | *.obj | *.sx | *.cu | *.cup) + func_xform "$libobj" + libobj=$func_xform_result + ;; + esac + + case $libobj in + *.lo) func_lo2o "$libobj"; obj=$func_lo2o_result ;; + *) + func_fatal_error "cannot determine name of library object from \`$libobj'" + ;; + esac + + func_infer_tag $base_compile + + for arg in $later; do + case $arg in + -shared) + test "$build_libtool_libs" != yes && \ + func_fatal_configuration "can not build a shared library" + build_old_libs=no + continue + ;; + + -static) + build_libtool_libs=no + build_old_libs=yes + continue + ;; + + -prefer-pic) + pic_mode=yes + continue + ;; + + -prefer-non-pic) + pic_mode=no + continue + ;; + esac + done + + func_quote_for_eval "$libobj" + test "X$libobj" != "X$func_quote_for_eval_result" \ + && $ECHO "X$libobj" | $GREP '[]~#^*{};<>?"'"'"' &()|`$[]' \ + && func_warning "libobj name \`$libobj' may not contain shell special characters." + func_dirname_and_basename "$obj" "/" "" + objname="$func_basename_result" + xdir="$func_dirname_result" + lobj=${xdir}$objdir/$objname + + test -z "$base_compile" && \ + func_fatal_help "you must specify a compilation command" + + # Delete any leftover library objects. + if test "$build_old_libs" = yes; then + removelist="$obj $lobj $libobj ${libobj}T" + else + removelist="$lobj $libobj ${libobj}T" + fi + + # On Cygwin there's no "real" PIC flag so we must build both object types + case $host_os in + cygwin* | mingw* | pw32* | os2* | cegcc*) + pic_mode=default + ;; + esac + if test "$pic_mode" = no && test "$deplibs_check_method" != pass_all; then + # non-PIC code in shared libraries is not supported + pic_mode=default + fi + + # Calculate the filename of the output object if compiler does + # not support -o with -c + if test "$compiler_c_o" = no; then + output_obj=`$ECHO "$srcfile" | $SED 's%^.*/%%; s%\.[^.]*$%%'`.${objext} + lockfile="$output_obj.lock" + else + output_obj= + need_locks=no + lockfile= + fi + + # Lock this critical section if it is needed + # We use this script file to make the link, it avoids creating a new file + if test "$need_locks" = yes; then + until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do + func_echo "Waiting for $lockfile to be removed" + sleep 2 + done + elif test "$need_locks" = warn; then + if test -f "$lockfile"; then + $ECHO "\ +*** ERROR, $lockfile exists and contains: +`cat $lockfile 2>/dev/null` + +This indicates that another process is trying to use the same +temporary object file, and libtool could not work around it because +your compiler does not support \`-c' and \`-o' together. If you +repeat this compilation, it may succeed, by chance, but you had better +avoid parallel builds (make -j) in this platform, or get a better +compiler." + + $opt_dry_run || $RM $removelist + exit $EXIT_FAILURE + fi + func_append removelist " $output_obj" + $ECHO "$srcfile" > "$lockfile" + fi + + $opt_dry_run || $RM $removelist + func_append removelist " $lockfile" + trap '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE' 1 2 15 + + func_to_tool_file "$srcfile" func_convert_file_msys_to_w32 + srcfile=$func_to_tool_file_result + func_quote_for_eval "$srcfile" + qsrcfile=$func_quote_for_eval_result + + # Only build a PIC object if we are building libtool libraries. + if test "$build_libtool_libs" = yes; then + # Without this assignment, base_compile gets emptied. + fbsd_hideous_sh_bug=$base_compile + + if test "$pic_mode" != no; then + command="$base_compile $qsrcfile $pic_flag" + else + # Don't build PIC code + command="$base_compile $qsrcfile" + fi + + func_mkdir_p "$xdir$objdir" + + if test -z "$output_obj"; then + # Place PIC objects in $objdir + func_append command " -o $lobj" + fi + + func_show_eval_locale "$command" \ + 'test -n "$output_obj" && $RM $removelist; exit $EXIT_FAILURE' + + if test "$need_locks" = warn && + test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then + $ECHO "\ +*** ERROR, $lockfile contains: +`cat $lockfile 2>/dev/null` + +but it should contain: +$srcfile + +This indicates that another process is trying to use the same +temporary object file, and libtool could not work around it because +your compiler does not support \`-c' and \`-o' together. If you +repeat this compilation, it may succeed, by chance, but you had better +avoid parallel builds (make -j) in this platform, or get a better +compiler." + + $opt_dry_run || $RM $removelist + exit $EXIT_FAILURE + fi + + # Just move the object if needed, then go on to compile the next one + if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then + func_show_eval '$MV "$output_obj" "$lobj"' \ + 'error=$?; $opt_dry_run || $RM $removelist; exit $error' + fi + + # Allow error messages only from the first compilation. + if test "$suppress_opt" = yes; then + suppress_output=' >/dev/null 2>&1' + fi + fi + + # Only build a position-dependent object if we build old libraries. + if test "$build_old_libs" = yes; then + if test "$pic_mode" != yes; then + # Don't build PIC code + command="$base_compile $qsrcfile$pie_flag" + else + command="$base_compile $qsrcfile $pic_flag" + fi + if test "$compiler_c_o" = yes; then + func_append command " -o $obj" + fi + + # Suppress compiler output if we already did a PIC compilation. + func_append command "$suppress_output" + func_show_eval_locale "$command" \ + '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE' + + if test "$need_locks" = warn && + test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then + $ECHO "\ +*** ERROR, $lockfile contains: +`cat $lockfile 2>/dev/null` + +but it should contain: +$srcfile + +This indicates that another process is trying to use the same +temporary object file, and libtool could not work around it because +your compiler does not support \`-c' and \`-o' together. If you +repeat this compilation, it may succeed, by chance, but you had better +avoid parallel builds (make -j) in this platform, or get a better +compiler." + + $opt_dry_run || $RM $removelist + exit $EXIT_FAILURE + fi + + # Just move the object if needed + if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then + func_show_eval '$MV "$output_obj" "$obj"' \ + 'error=$?; $opt_dry_run || $RM $removelist; exit $error' + fi + fi + + $opt_dry_run || { + func_write_libtool_object "$libobj" "$objdir/$objname" "$objname" + + # Unlock the critical section if it was locked + if test "$need_locks" != no; then + removelist=$lockfile + $RM "$lockfile" + fi + } + + exit $EXIT_SUCCESS +} + +$opt_help || { + test "$opt_mode" = compile && func_mode_compile ${1+"$@"} +} + +func_mode_help () +{ + # We need to display help for each of the modes. + case $opt_mode in + "") + # Generic help is extracted from the usage comments + # at the start of this file. + func_help + ;; + + clean) + $ECHO \ +"Usage: $progname [OPTION]... --mode=clean RM [RM-OPTION]... FILE... + +Remove files from the build directory. + +RM is the name of the program to use to delete files associated with each FILE +(typically \`/bin/rm'). RM-OPTIONS are options (such as \`-f') to be passed +to RM. + +If FILE is a libtool library, object or program, all the files associated +with it are deleted. Otherwise, only FILE itself is deleted using RM." + ;; + + compile) + $ECHO \ +"Usage: $progname [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE + +Compile a source file into a libtool library object. + +This mode accepts the following additional options: + + -o OUTPUT-FILE set the output file name to OUTPUT-FILE + -no-suppress do not suppress compiler output for multiple passes + -prefer-pic try to build PIC objects only + -prefer-non-pic try to build non-PIC objects only + -shared do not build a \`.o' file suitable for static linking + -static only build a \`.o' file suitable for static linking + -Wc,FLAG pass FLAG directly to the compiler + +COMPILE-COMMAND is a command to be used in creating a \`standard' object file +from the given SOURCEFILE. + +The output file name is determined by removing the directory component from +SOURCEFILE, then substituting the C source code suffix \`.c' with the +library object suffix, \`.lo'." + ;; + + execute) + $ECHO \ +"Usage: $progname [OPTION]... --mode=execute COMMAND [ARGS]... + +Automatically set library path, then run a program. + +This mode accepts the following additional options: + + -dlopen FILE add the directory containing FILE to the library path + +This mode sets the library path environment variable according to \`-dlopen' +flags. + +If any of the ARGS are libtool executable wrappers, then they are translated +into their corresponding uninstalled binary, and any of their required library +directories are added to the library path. + +Then, COMMAND is executed, with ARGS as arguments." + ;; + + finish) + $ECHO \ +"Usage: $progname [OPTION]... --mode=finish [LIBDIR]... + +Complete the installation of libtool libraries. + +Each LIBDIR is a directory that contains libtool libraries. + +The commands that this mode executes may require superuser privileges. Use +the \`--dry-run' option if you just want to see what would be executed." + ;; + + install) + $ECHO \ +"Usage: $progname [OPTION]... --mode=install INSTALL-COMMAND... + +Install executables or libraries. + +INSTALL-COMMAND is the installation command. The first component should be +either the \`install' or \`cp' program. + +The following components of INSTALL-COMMAND are treated specially: + + -inst-prefix-dir PREFIX-DIR Use PREFIX-DIR as a staging area for installation + +The rest of the components are interpreted as arguments to that command (only +BSD-compatible install options are recognized)." + ;; + + link) + $ECHO \ +"Usage: $progname [OPTION]... --mode=link LINK-COMMAND... + +Link object files or libraries together to form another library, or to +create an executable program. + +LINK-COMMAND is a command using the C compiler that you would use to create +a program from several object files. + +The following components of LINK-COMMAND are treated specially: + + -all-static do not do any dynamic linking at all + -avoid-version do not add a version suffix if possible + -bindir BINDIR specify path to binaries directory (for systems where + libraries must be found in the PATH setting at runtime) + -dlopen FILE \`-dlpreopen' FILE if it cannot be dlopened at runtime + -dlpreopen FILE link in FILE and add its symbols to lt_preloaded_symbols + -export-dynamic allow symbols from OUTPUT-FILE to be resolved with dlsym(3) + -export-symbols SYMFILE + try to export only the symbols listed in SYMFILE + -export-symbols-regex REGEX + try to export only the symbols matching REGEX + -LLIBDIR search LIBDIR for required installed libraries + -lNAME OUTPUT-FILE requires the installed library libNAME + -module build a library that can dlopened + -no-fast-install disable the fast-install mode + -no-install link a not-installable executable + -no-undefined declare that a library does not refer to external symbols + -o OUTPUT-FILE create OUTPUT-FILE from the specified objects + -objectlist FILE Use a list of object files found in FILE to specify objects + -precious-files-regex REGEX + don't remove output files matching REGEX + -release RELEASE specify package release information + -rpath LIBDIR the created library will eventually be installed in LIBDIR + -R[ ]LIBDIR add LIBDIR to the runtime path of programs and libraries + -shared only do dynamic linking of libtool libraries + -shrext SUFFIX override the standard shared library file extension + -static do not do any dynamic linking of uninstalled libtool libraries + -static-libtool-libs + do not do any dynamic linking of libtool libraries + -version-info CURRENT[:REVISION[:AGE]] + specify library version info [each variable defaults to 0] + -weak LIBNAME declare that the target provides the LIBNAME interface + -Wc,FLAG + -Xcompiler FLAG pass linker-specific FLAG directly to the compiler + -Wl,FLAG + -Xlinker FLAG pass linker-specific FLAG directly to the linker + -XCClinker FLAG pass link-specific FLAG to the compiler driver (CC) + +All other options (arguments beginning with \`-') are ignored. + +Every other argument is treated as a filename. Files ending in \`.la' are +treated as uninstalled libtool libraries, other files are standard or library +object files. + +If the OUTPUT-FILE ends in \`.la', then a libtool library is created, +only library objects (\`.lo' files) may be specified, and \`-rpath' is +required, except when creating a convenience library. + +If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created +using \`ar' and \`ranlib', or on Windows using \`lib'. + +If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file +is created, otherwise an executable program is created." + ;; + + uninstall) + $ECHO \ +"Usage: $progname [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE... + +Remove libraries from an installation directory. + +RM is the name of the program to use to delete files associated with each FILE +(typically \`/bin/rm'). RM-OPTIONS are options (such as \`-f') to be passed +to RM. + +If FILE is a libtool library, all the files associated with it are deleted. +Otherwise, only FILE itself is deleted using RM." + ;; + + *) + func_fatal_help "invalid operation mode \`$opt_mode'" + ;; + esac + + echo + $ECHO "Try \`$progname --help' for more information about other modes." +} + +# Now that we've collected a possible --mode arg, show help if necessary +if $opt_help; then + if test "$opt_help" = :; then + func_mode_help + else + { + func_help noexit + for opt_mode in compile link execute install finish uninstall clean; do + func_mode_help + done + } | sed -n '1p; 2,$s/^Usage:/ or: /p' + { + func_help noexit + for opt_mode in compile link execute install finish uninstall clean; do + echo + func_mode_help + done + } | + sed '1d + /^When reporting/,/^Report/{ + H + d + } + $x + /information about other modes/d + /more detailed .*MODE/d + s/^Usage:.*--mode=\([^ ]*\) .*/Description of \1 mode:/' + fi + exit $? +fi + + +# func_mode_execute arg... +func_mode_execute () +{ + $opt_debug + # The first argument is the command name. + cmd="$nonopt" + test -z "$cmd" && \ + func_fatal_help "you must specify a COMMAND" + + # Handle -dlopen flags immediately. + for file in $opt_dlopen; do + test -f "$file" \ + || func_fatal_help "\`$file' is not a file" + + dir= + case $file in + *.la) + func_resolve_sysroot "$file" + file=$func_resolve_sysroot_result + + # Check to see that this really is a libtool archive. + func_lalib_unsafe_p "$file" \ + || func_fatal_help "\`$lib' is not a valid libtool archive" + + # Read the libtool library. + dlname= + library_names= + func_source "$file" + + # Skip this library if it cannot be dlopened. + if test -z "$dlname"; then + # Warn if it was a shared library. + test -n "$library_names" && \ + func_warning "\`$file' was not linked with \`-export-dynamic'" + continue + fi + + func_dirname "$file" "" "." + dir="$func_dirname_result" + + if test -f "$dir/$objdir/$dlname"; then + func_append dir "/$objdir" + else + if test ! -f "$dir/$dlname"; then + func_fatal_error "cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'" + fi + fi + ;; + + *.lo) + # Just add the directory containing the .lo file. + func_dirname "$file" "" "." + dir="$func_dirname_result" + ;; + + *) + func_warning "\`-dlopen' is ignored for non-libtool libraries and objects" + continue + ;; + esac + + # Get the absolute pathname. + absdir=`cd "$dir" && pwd` + test -n "$absdir" && dir="$absdir" + + # Now add the directory to shlibpath_var. + if eval "test -z \"\$$shlibpath_var\""; then + eval "$shlibpath_var=\"\$dir\"" + else + eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\"" + fi + done + + # This variable tells wrapper scripts just to set shlibpath_var + # rather than running their programs. + libtool_execute_magic="$magic" + + # Check if any of the arguments is a wrapper script. + args= + for file + do + case $file in + -* | *.la | *.lo ) ;; + *) + # Do a test to see if this is really a libtool program. + if func_ltwrapper_script_p "$file"; then + func_source "$file" + # Transform arg to wrapped name. + file="$progdir/$program" + elif func_ltwrapper_executable_p "$file"; then + func_ltwrapper_scriptname "$file" + func_source "$func_ltwrapper_scriptname_result" + # Transform arg to wrapped name. + file="$progdir/$program" + fi + ;; + esac + # Quote arguments (to preserve shell metacharacters). + func_append_quoted args "$file" + done + + if test "X$opt_dry_run" = Xfalse; then + if test -n "$shlibpath_var"; then + # Export the shlibpath_var. + eval "export $shlibpath_var" + fi + + # Restore saved environment variables + for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES + do + eval "if test \"\${save_$lt_var+set}\" = set; then + $lt_var=\$save_$lt_var; export $lt_var + else + $lt_unset $lt_var + fi" + done + + # Now prepare to actually exec the command. + exec_cmd="\$cmd$args" + else + # Display what would be done. + if test -n "$shlibpath_var"; then + eval "\$ECHO \"\$shlibpath_var=\$$shlibpath_var\"" + echo "export $shlibpath_var" + fi + $ECHO "$cmd$args" + exit $EXIT_SUCCESS + fi +} + +test "$opt_mode" = execute && func_mode_execute ${1+"$@"} + + +# func_mode_finish arg... +func_mode_finish () +{ + $opt_debug + libs= + libdirs= + admincmds= + + for opt in "$nonopt" ${1+"$@"} + do + if test -d "$opt"; then + func_append libdirs " $opt" + + elif test -f "$opt"; then + if func_lalib_unsafe_p "$opt"; then + func_append libs " $opt" + else + func_warning "\`$opt' is not a valid libtool archive" + fi + + else + func_fatal_error "invalid argument \`$opt'" + fi + done + + if test -n "$libs"; then + if test -n "$lt_sysroot"; then + sysroot_regex=`$ECHO "$lt_sysroot" | $SED "$sed_make_literal_regex"` + sysroot_cmd="s/\([ ']\)$sysroot_regex/\1/g;" + else + sysroot_cmd= + fi + + # Remove sysroot references + if $opt_dry_run; then + for lib in $libs; do + echo "removing references to $lt_sysroot and \`=' prefixes from $lib" + done + else + tmpdir=`func_mktempdir` + for lib in $libs; do + sed -e "${sysroot_cmd} s/\([ ']-[LR]\)=/\1/g; s/\([ ']\)=/\1/g" $lib \ + > $tmpdir/tmp-la + mv -f $tmpdir/tmp-la $lib + done + ${RM}r "$tmpdir" + fi + fi + + if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then + for libdir in $libdirs; do + if test -n "$finish_cmds"; then + # Do each command in the finish commands. + func_execute_cmds "$finish_cmds" 'admincmds="$admincmds +'"$cmd"'"' + fi + if test -n "$finish_eval"; then + # Do the single finish_eval. + eval cmds=\"$finish_eval\" + $opt_dry_run || eval "$cmds" || func_append admincmds " + $cmds" + fi + done + fi + + # Exit here if they wanted silent mode. + $opt_silent && exit $EXIT_SUCCESS + + if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then + echo "----------------------------------------------------------------------" + echo "Libraries have been installed in:" + for libdir in $libdirs; do + $ECHO " $libdir" + done + echo + echo "If you ever happen to want to link against installed libraries" + echo "in a given directory, LIBDIR, you must either use libtool, and" + echo "specify the full pathname of the library, or use the \`-LLIBDIR'" + echo "flag during linking and do at least one of the following:" + if test -n "$shlibpath_var"; then + echo " - add LIBDIR to the \`$shlibpath_var' environment variable" + echo " during execution" + fi + if test -n "$runpath_var"; then + echo " - add LIBDIR to the \`$runpath_var' environment variable" + echo " during linking" + fi + if test -n "$hardcode_libdir_flag_spec"; then + libdir=LIBDIR + eval flag=\"$hardcode_libdir_flag_spec\" + + $ECHO " - use the \`$flag' linker flag" + fi + if test -n "$admincmds"; then + $ECHO " - have your system administrator run these commands:$admincmds" + fi + if test -f /etc/ld.so.conf; then + echo " - have your system administrator add LIBDIR to \`/etc/ld.so.conf'" + fi + echo + + echo "See any operating system documentation about shared libraries for" + case $host in + solaris2.[6789]|solaris2.1[0-9]) + echo "more information, such as the ld(1), crle(1) and ld.so(8) manual" + echo "pages." + ;; + *) + echo "more information, such as the ld(1) and ld.so(8) manual pages." + ;; + esac + echo "----------------------------------------------------------------------" + fi + exit $EXIT_SUCCESS +} + +test "$opt_mode" = finish && func_mode_finish ${1+"$@"} + + +# func_mode_install arg... +func_mode_install () +{ + $opt_debug + # There may be an optional sh(1) argument at the beginning of + # install_prog (especially on Windows NT). + if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh || + # Allow the use of GNU shtool's install command. + case $nonopt in *shtool*) :;; *) false;; esac; then + # Aesthetically quote it. + func_quote_for_eval "$nonopt" + install_prog="$func_quote_for_eval_result " + arg=$1 + shift + else + install_prog= + arg=$nonopt + fi + + # The real first argument should be the name of the installation program. + # Aesthetically quote it. + func_quote_for_eval "$arg" + func_append install_prog "$func_quote_for_eval_result" + install_shared_prog=$install_prog + case " $install_prog " in + *[\\\ /]cp\ *) install_cp=: ;; + *) install_cp=false ;; + esac + + # We need to accept at least all the BSD install flags. + dest= + files= + opts= + prev= + install_type= + isdir=no + stripme= + no_mode=: + for arg + do + arg2= + if test -n "$dest"; then + func_append files " $dest" + dest=$arg + continue + fi + + case $arg in + -d) isdir=yes ;; + -f) + if $install_cp; then :; else + prev=$arg + fi + ;; + -g | -m | -o) + prev=$arg + ;; + -s) + stripme=" -s" + continue + ;; + -*) + ;; + *) + # If the previous option needed an argument, then skip it. + if test -n "$prev"; then + if test "x$prev" = x-m && test -n "$install_override_mode"; then + arg2=$install_override_mode + no_mode=false + fi + prev= + else + dest=$arg + continue + fi + ;; + esac + + # Aesthetically quote the argument. + func_quote_for_eval "$arg" + func_append install_prog " $func_quote_for_eval_result" + if test -n "$arg2"; then + func_quote_for_eval "$arg2" + fi + func_append install_shared_prog " $func_quote_for_eval_result" + done + + test -z "$install_prog" && \ + func_fatal_help "you must specify an install program" + + test -n "$prev" && \ + func_fatal_help "the \`$prev' option requires an argument" + + if test -n "$install_override_mode" && $no_mode; then + if $install_cp; then :; else + func_quote_for_eval "$install_override_mode" + func_append install_shared_prog " -m $func_quote_for_eval_result" + fi + fi + + if test -z "$files"; then + if test -z "$dest"; then + func_fatal_help "no file or destination specified" + else + func_fatal_help "you must specify a destination" + fi + fi + + # Strip any trailing slash from the destination. + func_stripname '' '/' "$dest" + dest=$func_stripname_result + + # Check to see that the destination is a directory. + test -d "$dest" && isdir=yes + if test "$isdir" = yes; then + destdir="$dest" + destname= + else + func_dirname_and_basename "$dest" "" "." + destdir="$func_dirname_result" + destname="$func_basename_result" + + # Not a directory, so check to see that there is only one file specified. + set dummy $files; shift + test "$#" -gt 1 && \ + func_fatal_help "\`$dest' is not a directory" + fi + case $destdir in + [\\/]* | [A-Za-z]:[\\/]*) ;; + *) + for file in $files; do + case $file in + *.lo) ;; + *) + func_fatal_help "\`$destdir' must be an absolute directory name" + ;; + esac + done + ;; + esac + + # This variable tells wrapper scripts just to set variables rather + # than running their programs. + libtool_install_magic="$magic" + + staticlibs= + future_libdirs= + current_libdirs= + for file in $files; do + + # Do each installation. + case $file in + *.$libext) + # Do the static libraries later. + func_append staticlibs " $file" + ;; + + *.la) + func_resolve_sysroot "$file" + file=$func_resolve_sysroot_result + + # Check to see that this really is a libtool archive. + func_lalib_unsafe_p "$file" \ + || func_fatal_help "\`$file' is not a valid libtool archive" + + library_names= + old_library= + relink_command= + func_source "$file" + + # Add the libdir to current_libdirs if it is the destination. + if test "X$destdir" = "X$libdir"; then + case "$current_libdirs " in + *" $libdir "*) ;; + *) func_append current_libdirs " $libdir" ;; + esac + else + # Note the libdir as a future libdir. + case "$future_libdirs " in + *" $libdir "*) ;; + *) func_append future_libdirs " $libdir" ;; + esac + fi + + func_dirname "$file" "/" "" + dir="$func_dirname_result" + func_append dir "$objdir" + + if test -n "$relink_command"; then + # Determine the prefix the user has applied to our future dir. + inst_prefix_dir=`$ECHO "$destdir" | $SED -e "s%$libdir\$%%"` + + # Don't allow the user to place us outside of our expected + # location b/c this prevents finding dependent libraries that + # are installed to the same prefix. + # At present, this check doesn't affect windows .dll's that + # are installed into $libdir/../bin (currently, that works fine) + # but it's something to keep an eye on. + test "$inst_prefix_dir" = "$destdir" && \ + func_fatal_error "error: cannot install \`$file' to a directory not ending in $libdir" + + if test -n "$inst_prefix_dir"; then + # Stick the inst_prefix_dir data into the link command. + relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"` + else + relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%%"` + fi + + func_warning "relinking \`$file'" + func_show_eval "$relink_command" \ + 'func_fatal_error "error: relink \`$file'\'' with the above command before installing it"' + fi + + # See the names of the shared library. + set dummy $library_names; shift + if test -n "$1"; then + realname="$1" + shift + + srcname="$realname" + test -n "$relink_command" && srcname="$realname"T + + # Install the shared library and build the symlinks. + func_show_eval "$install_shared_prog $dir/$srcname $destdir/$realname" \ + 'exit $?' + tstripme="$stripme" + case $host_os in + cygwin* | mingw* | pw32* | cegcc*) + case $realname in + *.dll.a) + tstripme="" + ;; + esac + ;; + esac + if test -n "$tstripme" && test -n "$striplib"; then + func_show_eval "$striplib $destdir/$realname" 'exit $?' + fi + + if test "$#" -gt 0; then + # Delete the old symlinks, and create new ones. + # Try `ln -sf' first, because the `ln' binary might depend on + # the symlink we replace! Solaris /bin/ln does not understand -f, + # so we also need to try rm && ln -s. + for linkname + do + test "$linkname" != "$realname" \ + && func_show_eval "(cd $destdir && { $LN_S -f $realname $linkname || { $RM $linkname && $LN_S $realname $linkname; }; })" + done + fi + + # Do each command in the postinstall commands. + lib="$destdir/$realname" + func_execute_cmds "$postinstall_cmds" 'exit $?' + fi + + # Install the pseudo-library for information purposes. + func_basename "$file" + name="$func_basename_result" + instname="$dir/$name"i + func_show_eval "$install_prog $instname $destdir/$name" 'exit $?' + + # Maybe install the static library, too. + test -n "$old_library" && func_append staticlibs " $dir/$old_library" + ;; + + *.lo) + # Install (i.e. copy) a libtool object. + + # Figure out destination file name, if it wasn't already specified. + if test -n "$destname"; then + destfile="$destdir/$destname" + else + func_basename "$file" + destfile="$func_basename_result" + destfile="$destdir/$destfile" + fi + + # Deduce the name of the destination old-style object file. + case $destfile in + *.lo) + func_lo2o "$destfile" + staticdest=$func_lo2o_result + ;; + *.$objext) + staticdest="$destfile" + destfile= + ;; + *) + func_fatal_help "cannot copy a libtool object to \`$destfile'" + ;; + esac + + # Install the libtool object if requested. + test -n "$destfile" && \ + func_show_eval "$install_prog $file $destfile" 'exit $?' + + # Install the old object if enabled. + if test "$build_old_libs" = yes; then + # Deduce the name of the old-style object file. + func_lo2o "$file" + staticobj=$func_lo2o_result + func_show_eval "$install_prog \$staticobj \$staticdest" 'exit $?' + fi + exit $EXIT_SUCCESS + ;; + + *) + # Figure out destination file name, if it wasn't already specified. + if test -n "$destname"; then + destfile="$destdir/$destname" + else + func_basename "$file" + destfile="$func_basename_result" + destfile="$destdir/$destfile" + fi + + # If the file is missing, and there is a .exe on the end, strip it + # because it is most likely a libtool script we actually want to + # install + stripped_ext="" + case $file in + *.exe) + if test ! -f "$file"; then + func_stripname '' '.exe' "$file" + file=$func_stripname_result + stripped_ext=".exe" + fi + ;; + esac + + # Do a test to see if this is really a libtool program. + case $host in + *cygwin* | *mingw*) + if func_ltwrapper_executable_p "$file"; then + func_ltwrapper_scriptname "$file" + wrapper=$func_ltwrapper_scriptname_result + else + func_stripname '' '.exe' "$file" + wrapper=$func_stripname_result + fi + ;; + *) + wrapper=$file + ;; + esac + if func_ltwrapper_script_p "$wrapper"; then + notinst_deplibs= + relink_command= + + func_source "$wrapper" + + # Check the variables that should have been set. + test -z "$generated_by_libtool_version" && \ + func_fatal_error "invalid libtool wrapper script \`$wrapper'" + + finalize=yes + for lib in $notinst_deplibs; do + # Check to see that each library is installed. + libdir= + if test -f "$lib"; then + func_source "$lib" + fi + libfile="$libdir/"`$ECHO "$lib" | $SED 's%^.*/%%g'` ### testsuite: skip nested quoting test + if test -n "$libdir" && test ! -f "$libfile"; then + func_warning "\`$lib' has not been installed in \`$libdir'" + finalize=no + fi + done + + relink_command= + func_source "$wrapper" + + outputname= + if test "$fast_install" = no && test -n "$relink_command"; then + $opt_dry_run || { + if test "$finalize" = yes; then + tmpdir=`func_mktempdir` + func_basename "$file$stripped_ext" + file="$func_basename_result" + outputname="$tmpdir/$file" + # Replace the output file specification. + relink_command=`$ECHO "$relink_command" | $SED 's%@OUTPUT@%'"$outputname"'%g'` + + $opt_silent || { + func_quote_for_expand "$relink_command" + eval "func_echo $func_quote_for_expand_result" + } + if eval "$relink_command"; then : + else + func_error "error: relink \`$file' with the above command before installing it" + $opt_dry_run || ${RM}r "$tmpdir" + continue + fi + file="$outputname" + else + func_warning "cannot relink \`$file'" + fi + } + else + # Install the binary that we compiled earlier. + file=`$ECHO "$file$stripped_ext" | $SED "s%\([^/]*\)$%$objdir/\1%"` + fi + fi + + # remove .exe since cygwin /usr/bin/install will append another + # one anyway + case $install_prog,$host in + */usr/bin/install*,*cygwin*) + case $file:$destfile in + *.exe:*.exe) + # this is ok + ;; + *.exe:*) + destfile=$destfile.exe + ;; + *:*.exe) + func_stripname '' '.exe' "$destfile" + destfile=$func_stripname_result + ;; + esac + ;; + esac + func_show_eval "$install_prog\$stripme \$file \$destfile" 'exit $?' + $opt_dry_run || if test -n "$outputname"; then + ${RM}r "$tmpdir" + fi + ;; + esac + done + + for file in $staticlibs; do + func_basename "$file" + name="$func_basename_result" + + # Set up the ranlib parameters. + oldlib="$destdir/$name" + func_to_tool_file "$oldlib" func_convert_file_msys_to_w32 + tool_oldlib=$func_to_tool_file_result + + func_show_eval "$install_prog \$file \$oldlib" 'exit $?' + + if test -n "$stripme" && test -n "$old_striplib"; then + func_show_eval "$old_striplib $tool_oldlib" 'exit $?' + fi + + # Do each command in the postinstall commands. + func_execute_cmds "$old_postinstall_cmds" 'exit $?' + done + + test -n "$future_libdirs" && \ + func_warning "remember to run \`$progname --finish$future_libdirs'" + + if test -n "$current_libdirs"; then + # Maybe just do a dry run. + $opt_dry_run && current_libdirs=" -n$current_libdirs" + exec_cmd='$SHELL $progpath $preserve_args --finish$current_libdirs' + else + exit $EXIT_SUCCESS + fi +} + +test "$opt_mode" = install && func_mode_install ${1+"$@"} + + +# func_generate_dlsyms outputname originator pic_p +# Extract symbols from dlprefiles and create ${outputname}S.o with +# a dlpreopen symbol table. +func_generate_dlsyms () +{ + $opt_debug + my_outputname="$1" + my_originator="$2" + my_pic_p="${3-no}" + my_prefix=`$ECHO "$my_originator" | sed 's%[^a-zA-Z0-9]%_%g'` + my_dlsyms= + + if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then + if test -n "$NM" && test -n "$global_symbol_pipe"; then + my_dlsyms="${my_outputname}S.c" + else + func_error "not configured to extract global symbols from dlpreopened files" + fi + fi + + if test -n "$my_dlsyms"; then + case $my_dlsyms in + "") ;; + *.c) + # Discover the nlist of each of the dlfiles. + nlist="$output_objdir/${my_outputname}.nm" + + func_show_eval "$RM $nlist ${nlist}S ${nlist}T" + + # Parse the name list into a source file. + func_verbose "creating $output_objdir/$my_dlsyms" + + $opt_dry_run || $ECHO > "$output_objdir/$my_dlsyms" "\ +/* $my_dlsyms - symbol resolution table for \`$my_outputname' dlsym emulation. */ +/* Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION */ + +#ifdef __cplusplus +extern \"C\" { +#endif + +#if defined(__GNUC__) && (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 4)) || (__GNUC__ > 4)) +#pragma GCC diagnostic ignored \"-Wstrict-prototypes\" +#endif + +/* Keep this code in sync between libtool.m4, ltmain, lt_system.h, and tests. */ +#if defined(_WIN32) || defined(__CYGWIN__) || defined(_WIN32_WCE) +/* DATA imports from DLLs on WIN32 con't be const, because runtime + relocations are performed -- see ld's documentation on pseudo-relocs. */ +# define LT_DLSYM_CONST +#elif defined(__osf__) +/* This system does not cope well with relocations in const data. */ +# define LT_DLSYM_CONST +#else +# define LT_DLSYM_CONST const +#endif + +/* External symbol declarations for the compiler. */\ +" + + if test "$dlself" = yes; then + func_verbose "generating symbol list for \`$output'" + + $opt_dry_run || echo ': @PROGRAM@ ' > "$nlist" + + # Add our own program objects to the symbol list. + progfiles=`$ECHO "$objs$old_deplibs" | $SP2NL | $SED "$lo2o" | $NL2SP` + for progfile in $progfiles; do + func_to_tool_file "$progfile" func_convert_file_msys_to_w32 + func_verbose "extracting global C symbols from \`$func_to_tool_file_result'" + $opt_dry_run || eval "$NM $func_to_tool_file_result | $global_symbol_pipe >> '$nlist'" + done + + if test -n "$exclude_expsyms"; then + $opt_dry_run || { + eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T' + eval '$MV "$nlist"T "$nlist"' + } + fi + + if test -n "$export_symbols_regex"; then + $opt_dry_run || { + eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T' + eval '$MV "$nlist"T "$nlist"' + } + fi + + # Prepare the list of exported symbols + if test -z "$export_symbols"; then + export_symbols="$output_objdir/$outputname.exp" + $opt_dry_run || { + $RM $export_symbols + eval "${SED} -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"' + case $host in + *cygwin* | *mingw* | *cegcc* ) + eval "echo EXPORTS "'> "$output_objdir/$outputname.def"' + eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"' + ;; + esac + } + else + $opt_dry_run || { + eval "${SED} -e 's/\([].[*^$]\)/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"' + eval '$GREP -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T' + eval '$MV "$nlist"T "$nlist"' + case $host in + *cygwin* | *mingw* | *cegcc* ) + eval "echo EXPORTS "'> "$output_objdir/$outputname.def"' + eval 'cat "$nlist" >> "$output_objdir/$outputname.def"' + ;; + esac + } + fi + fi + + for dlprefile in $dlprefiles; do + func_verbose "extracting global C symbols from \`$dlprefile'" + func_basename "$dlprefile" + name="$func_basename_result" + case $host in + *cygwin* | *mingw* | *cegcc* ) + # if an import library, we need to obtain dlname + if func_win32_import_lib_p "$dlprefile"; then + func_tr_sh "$dlprefile" + eval "curr_lafile=\$libfile_$func_tr_sh_result" + dlprefile_dlbasename="" + if test -n "$curr_lafile" && func_lalib_p "$curr_lafile"; then + # Use subshell, to avoid clobbering current variable values + dlprefile_dlname=`source "$curr_lafile" && echo "$dlname"` + if test -n "$dlprefile_dlname" ; then + func_basename "$dlprefile_dlname" + dlprefile_dlbasename="$func_basename_result" + else + # no lafile. user explicitly requested -dlpreopen . + $sharedlib_from_linklib_cmd "$dlprefile" + dlprefile_dlbasename=$sharedlib_from_linklib_result + fi + fi + $opt_dry_run || { + if test -n "$dlprefile_dlbasename" ; then + eval '$ECHO ": $dlprefile_dlbasename" >> "$nlist"' + else + func_warning "Could not compute DLL name from $name" + eval '$ECHO ": $name " >> "$nlist"' + fi + func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32 + eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe | + $SED -e '/I __imp/d' -e 's/I __nm_/D /;s/_nm__//' >> '$nlist'" + } + else # not an import lib + $opt_dry_run || { + eval '$ECHO ": $name " >> "$nlist"' + func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32 + eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'" + } + fi + ;; + *) + $opt_dry_run || { + eval '$ECHO ": $name " >> "$nlist"' + func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32 + eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'" + } + ;; + esac + done + + $opt_dry_run || { + # Make sure we have at least an empty file. + test -f "$nlist" || : > "$nlist" + + if test -n "$exclude_expsyms"; then + $EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T + $MV "$nlist"T "$nlist" + fi + + # Try sorting and uniquifying the output. + if $GREP -v "^: " < "$nlist" | + if sort -k 3 /dev/null 2>&1; then + sort -k 3 + else + sort +2 + fi | + uniq > "$nlist"S; then + : + else + $GREP -v "^: " < "$nlist" > "$nlist"S + fi + + if test -f "$nlist"S; then + eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$my_dlsyms"' + else + echo '/* NONE */' >> "$output_objdir/$my_dlsyms" + fi + + echo >> "$output_objdir/$my_dlsyms" "\ + +/* The mapping between symbol names and symbols. */ +typedef struct { + const char *name; + void *address; +} lt_dlsymlist; +extern LT_DLSYM_CONST lt_dlsymlist +lt_${my_prefix}_LTX_preloaded_symbols[]; +LT_DLSYM_CONST lt_dlsymlist +lt_${my_prefix}_LTX_preloaded_symbols[] = +{\ + { \"$my_originator\", (void *) 0 }," + + case $need_lib_prefix in + no) + eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$my_dlsyms" + ;; + *) + eval "$global_symbol_to_c_name_address_lib_prefix" < "$nlist" >> "$output_objdir/$my_dlsyms" + ;; + esac + echo >> "$output_objdir/$my_dlsyms" "\ + {0, (void *) 0} +}; + +/* This works around a problem in FreeBSD linker */ +#ifdef FREEBSD_WORKAROUND +static const void *lt_preloaded_setup() { + return lt_${my_prefix}_LTX_preloaded_symbols; +} +#endif + +#ifdef __cplusplus +} +#endif\ +" + } # !$opt_dry_run + + pic_flag_for_symtable= + case "$compile_command " in + *" -static "*) ;; + *) + case $host in + # compiling the symbol table file with pic_flag works around + # a FreeBSD bug that causes programs to crash when -lm is + # linked before any other PIC object. But we must not use + # pic_flag when linking with -static. The problem exists in + # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1. + *-*-freebsd2.*|*-*-freebsd3.0*|*-*-freebsdelf3.0*) + pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND" ;; + *-*-hpux*) + pic_flag_for_symtable=" $pic_flag" ;; + *) + if test "X$my_pic_p" != Xno; then + pic_flag_for_symtable=" $pic_flag" + fi + ;; + esac + ;; + esac + symtab_cflags= + for arg in $LTCFLAGS; do + case $arg in + -pie | -fpie | -fPIE) ;; + *) func_append symtab_cflags " $arg" ;; + esac + done + + # Now compile the dynamic symbol file. + func_show_eval '(cd $output_objdir && $LTCC$symtab_cflags -c$no_builtin_flag$pic_flag_for_symtable "$my_dlsyms")' 'exit $?' + + # Clean up the generated files. + func_show_eval '$RM "$output_objdir/$my_dlsyms" "$nlist" "${nlist}S" "${nlist}T"' + + # Transform the symbol file into the correct name. + symfileobj="$output_objdir/${my_outputname}S.$objext" + case $host in + *cygwin* | *mingw* | *cegcc* ) + if test -f "$output_objdir/$my_outputname.def"; then + compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"` + finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"` + else + compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"` + finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"` + fi + ;; + *) + compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"` + finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"` + ;; + esac + ;; + *) + func_fatal_error "unknown suffix for \`$my_dlsyms'" + ;; + esac + else + # We keep going just in case the user didn't refer to + # lt_preloaded_symbols. The linker will fail if global_symbol_pipe + # really was required. + + # Nullify the symbol file. + compile_command=`$ECHO "$compile_command" | $SED "s% @SYMFILE@%%"` + finalize_command=`$ECHO "$finalize_command" | $SED "s% @SYMFILE@%%"` + fi +} + +# func_win32_libid arg +# return the library type of file 'arg' +# +# Need a lot of goo to handle *both* DLLs and import libs +# Has to be a shell function in order to 'eat' the argument +# that is supplied when $file_magic_command is called. +# Despite the name, also deal with 64 bit binaries. +func_win32_libid () +{ + $opt_debug + win32_libid_type="unknown" + win32_fileres=`file -L $1 2>/dev/null` + case $win32_fileres in + *ar\ archive\ import\ library*) # definitely import + win32_libid_type="x86 archive import" + ;; + *ar\ archive*) # could be an import, or static + # Keep the egrep pattern in sync with the one in _LT_CHECK_MAGIC_METHOD. + if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null | + $EGREP 'file format (pei*-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)' >/dev/null; then + func_to_tool_file "$1" func_convert_file_msys_to_w32 + win32_nmres=`eval $NM -f posix -A \"$func_to_tool_file_result\" | + $SED -n -e ' + 1,100{ + / I /{ + s,.*,import, + p + q + } + }'` + case $win32_nmres in + import*) win32_libid_type="x86 archive import";; + *) win32_libid_type="x86 archive static";; + esac + fi + ;; + *DLL*) + win32_libid_type="x86 DLL" + ;; + *executable*) # but shell scripts are "executable" too... + case $win32_fileres in + *MS\ Windows\ PE\ Intel*) + win32_libid_type="x86 DLL" + ;; + esac + ;; + esac + $ECHO "$win32_libid_type" +} + +# func_cygming_dll_for_implib ARG +# +# Platform-specific function to extract the +# name of the DLL associated with the specified +# import library ARG. +# Invoked by eval'ing the libtool variable +# $sharedlib_from_linklib_cmd +# Result is available in the variable +# $sharedlib_from_linklib_result +func_cygming_dll_for_implib () +{ + $opt_debug + sharedlib_from_linklib_result=`$DLLTOOL --identify-strict --identify "$1"` +} + +# func_cygming_dll_for_implib_fallback_core SECTION_NAME LIBNAMEs +# +# The is the core of a fallback implementation of a +# platform-specific function to extract the name of the +# DLL associated with the specified import library LIBNAME. +# +# SECTION_NAME is either .idata$6 or .idata$7, depending +# on the platform and compiler that created the implib. +# +# Echos the name of the DLL associated with the +# specified import library. +func_cygming_dll_for_implib_fallback_core () +{ + $opt_debug + match_literal=`$ECHO "$1" | $SED "$sed_make_literal_regex"` + $OBJDUMP -s --section "$1" "$2" 2>/dev/null | + $SED '/^Contents of section '"$match_literal"':/{ + # Place marker at beginning of archive member dllname section + s/.*/====MARK====/ + p + d + } + # These lines can sometimes be longer than 43 characters, but + # are always uninteresting + /:[ ]*file format pe[i]\{,1\}-/d + /^In archive [^:]*:/d + # Ensure marker is printed + /^====MARK====/p + # Remove all lines with less than 43 characters + /^.\{43\}/!d + # From remaining lines, remove first 43 characters + s/^.\{43\}//' | + $SED -n ' + # Join marker and all lines until next marker into a single line + /^====MARK====/ b para + H + $ b para + b + :para + x + s/\n//g + # Remove the marker + s/^====MARK====// + # Remove trailing dots and whitespace + s/[\. \t]*$// + # Print + /./p' | + # we now have a list, one entry per line, of the stringified + # contents of the appropriate section of all members of the + # archive which possess that section. Heuristic: eliminate + # all those which have a first or second character that is + # a '.' (that is, objdump's representation of an unprintable + # character.) This should work for all archives with less than + # 0x302f exports -- but will fail for DLLs whose name actually + # begins with a literal '.' or a single character followed by + # a '.'. + # + # Of those that remain, print the first one. + $SED -e '/^\./d;/^.\./d;q' +} + +# func_cygming_gnu_implib_p ARG +# This predicate returns with zero status (TRUE) if +# ARG is a GNU/binutils-style import library. Returns +# with nonzero status (FALSE) otherwise. +func_cygming_gnu_implib_p () +{ + $opt_debug + func_to_tool_file "$1" func_convert_file_msys_to_w32 + func_cygming_gnu_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $EGREP ' (_head_[A-Za-z0-9_]+_[ad]l*|[A-Za-z0-9_]+_[ad]l*_iname)$'` + test -n "$func_cygming_gnu_implib_tmp" +} + +# func_cygming_ms_implib_p ARG +# This predicate returns with zero status (TRUE) if +# ARG is an MS-style import library. Returns +# with nonzero status (FALSE) otherwise. +func_cygming_ms_implib_p () +{ + $opt_debug + func_to_tool_file "$1" func_convert_file_msys_to_w32 + func_cygming_ms_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $GREP '_NULL_IMPORT_DESCRIPTOR'` + test -n "$func_cygming_ms_implib_tmp" +} + +# func_cygming_dll_for_implib_fallback ARG +# Platform-specific function to extract the +# name of the DLL associated with the specified +# import library ARG. +# +# This fallback implementation is for use when $DLLTOOL +# does not support the --identify-strict option. +# Invoked by eval'ing the libtool variable +# $sharedlib_from_linklib_cmd +# Result is available in the variable +# $sharedlib_from_linklib_result +func_cygming_dll_for_implib_fallback () +{ + $opt_debug + if func_cygming_gnu_implib_p "$1" ; then + # binutils import library + sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$7' "$1"` + elif func_cygming_ms_implib_p "$1" ; then + # ms-generated import library + sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$6' "$1"` + else + # unknown + sharedlib_from_linklib_result="" + fi +} + + +# func_extract_an_archive dir oldlib +func_extract_an_archive () +{ + $opt_debug + f_ex_an_ar_dir="$1"; shift + f_ex_an_ar_oldlib="$1" + if test "$lock_old_archive_extraction" = yes; then + lockfile=$f_ex_an_ar_oldlib.lock + until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do + func_echo "Waiting for $lockfile to be removed" + sleep 2 + done + fi + func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" \ + 'stat=$?; rm -f "$lockfile"; exit $stat' + if test "$lock_old_archive_extraction" = yes; then + $opt_dry_run || rm -f "$lockfile" + fi + if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then + : + else + func_fatal_error "object name conflicts in archive: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib" + fi +} + + +# func_extract_archives gentop oldlib ... +func_extract_archives () +{ + $opt_debug + my_gentop="$1"; shift + my_oldlibs=${1+"$@"} + my_oldobjs="" + my_xlib="" + my_xabs="" + my_xdir="" + + for my_xlib in $my_oldlibs; do + # Extract the objects. + case $my_xlib in + [\\/]* | [A-Za-z]:[\\/]*) my_xabs="$my_xlib" ;; + *) my_xabs=`pwd`"/$my_xlib" ;; + esac + func_basename "$my_xlib" + my_xlib="$func_basename_result" + my_xlib_u=$my_xlib + while :; do + case " $extracted_archives " in + *" $my_xlib_u "*) + func_arith $extracted_serial + 1 + extracted_serial=$func_arith_result + my_xlib_u=lt$extracted_serial-$my_xlib ;; + *) break ;; + esac + done + extracted_archives="$extracted_archives $my_xlib_u" + my_xdir="$my_gentop/$my_xlib_u" + + func_mkdir_p "$my_xdir" + + case $host in + *-darwin*) + func_verbose "Extracting $my_xabs" + # Do not bother doing anything if just a dry run + $opt_dry_run || { + darwin_orig_dir=`pwd` + cd $my_xdir || exit $? + darwin_archive=$my_xabs + darwin_curdir=`pwd` + darwin_base_archive=`basename "$darwin_archive"` + darwin_arches=`$LIPO -info "$darwin_archive" 2>/dev/null | $GREP Architectures 2>/dev/null || true` + if test -n "$darwin_arches"; then + darwin_arches=`$ECHO "$darwin_arches" | $SED -e 's/.*are://'` + darwin_arch= + func_verbose "$darwin_base_archive has multiple architectures $darwin_arches" + for darwin_arch in $darwin_arches ; do + func_mkdir_p "unfat-$$/${darwin_base_archive}-${darwin_arch}" + $LIPO -thin $darwin_arch -output "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" "${darwin_archive}" + cd "unfat-$$/${darwin_base_archive}-${darwin_arch}" + func_extract_an_archive "`pwd`" "${darwin_base_archive}" + cd "$darwin_curdir" + $RM "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" + done # $darwin_arches + ## Okay now we've a bunch of thin objects, gotta fatten them up :) + darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print | $SED -e "$basename" | sort -u` + darwin_file= + darwin_files= + for darwin_file in $darwin_filelist; do + darwin_files=`find unfat-$$ -name $darwin_file -print | sort | $NL2SP` + $LIPO -create -output "$darwin_file" $darwin_files + done # $darwin_filelist + $RM -rf unfat-$$ + cd "$darwin_orig_dir" + else + cd $darwin_orig_dir + func_extract_an_archive "$my_xdir" "$my_xabs" + fi # $darwin_arches + } # !$opt_dry_run + ;; + *) + func_extract_an_archive "$my_xdir" "$my_xabs" + ;; + esac + my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | sort | $NL2SP` + done + + func_extract_archives_result="$my_oldobjs" +} + + +# func_emit_wrapper [arg=no] +# +# Emit a libtool wrapper script on stdout. +# Don't directly open a file because we may want to +# incorporate the script contents within a cygwin/mingw +# wrapper executable. Must ONLY be called from within +# func_mode_link because it depends on a number of variables +# set therein. +# +# ARG is the value that the WRAPPER_SCRIPT_BELONGS_IN_OBJDIR +# variable will take. If 'yes', then the emitted script +# will assume that the directory in which it is stored is +# the $objdir directory. This is a cygwin/mingw-specific +# behavior. +func_emit_wrapper () +{ + func_emit_wrapper_arg1=${1-no} + + $ECHO "\ +#! $SHELL + +# $output - temporary wrapper script for $objdir/$outputname +# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION +# +# The $output program cannot be directly executed until all the libtool +# libraries that it depends on are installed. +# +# This wrapper script should never be moved out of the build directory. +# If it is, it will not operate correctly. + +# Sed substitution that helps us do robust quoting. It backslashifies +# metacharacters that are still active within double-quoted strings. +sed_quote_subst='$sed_quote_subst' + +# Be Bourne compatible +if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then + emulate sh + NULLCMD=: + # Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which + # is contrary to our usage. Disable this feature. + alias -g '\${1+\"\$@\"}'='\"\$@\"' + setopt NO_GLOB_SUBST +else + case \`(set -o) 2>/dev/null\` in *posix*) set -o posix;; esac +fi +BIN_SH=xpg4; export BIN_SH # for Tru64 +DUALCASE=1; export DUALCASE # for MKS sh + +# The HP-UX ksh and POSIX shell print the target directory to stdout +# if CDPATH is set. +(unset CDPATH) >/dev/null 2>&1 && unset CDPATH + +relink_command=\"$relink_command\" + +# This environment variable determines our operation mode. +if test \"\$libtool_install_magic\" = \"$magic\"; then + # install mode needs the following variables: + generated_by_libtool_version='$macro_version' + notinst_deplibs='$notinst_deplibs' +else + # When we are sourced in execute mode, \$file and \$ECHO are already set. + if test \"\$libtool_execute_magic\" != \"$magic\"; then + file=\"\$0\"" + + qECHO=`$ECHO "$ECHO" | $SED "$sed_quote_subst"` + $ECHO "\ + +# A function that is used when there is no print builtin or printf. +func_fallback_echo () +{ + eval 'cat <<_LTECHO_EOF +\$1 +_LTECHO_EOF' +} + ECHO=\"$qECHO\" + fi + +# Very basic option parsing. These options are (a) specific to +# the libtool wrapper, (b) are identical between the wrapper +# /script/ and the wrapper /executable/ which is used only on +# windows platforms, and (c) all begin with the string "--lt-" +# (application programs are unlikely to have options which match +# this pattern). +# +# There are only two supported options: --lt-debug and +# --lt-dump-script. There is, deliberately, no --lt-help. +# +# The first argument to this parsing function should be the +# script's $0 value, followed by "$@". +lt_option_debug= +func_parse_lt_options () +{ + lt_script_arg0=\$0 + shift + for lt_opt + do + case \"\$lt_opt\" in + --lt-debug) lt_option_debug=1 ;; + --lt-dump-script) + lt_dump_D=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%/[^/]*$%%'\` + test \"X\$lt_dump_D\" = \"X\$lt_script_arg0\" && lt_dump_D=. + lt_dump_F=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%^.*/%%'\` + cat \"\$lt_dump_D/\$lt_dump_F\" + exit 0 + ;; + --lt-*) + \$ECHO \"Unrecognized --lt- option: '\$lt_opt'\" 1>&2 + exit 1 + ;; + esac + done + + # Print the debug banner immediately: + if test -n \"\$lt_option_debug\"; then + echo \"${outputname}:${output}:\${LINENO}: libtool wrapper (GNU $PACKAGE$TIMESTAMP) $VERSION\" 1>&2 + fi +} + +# Used when --lt-debug. Prints its arguments to stdout +# (redirection is the responsibility of the caller) +func_lt_dump_args () +{ + lt_dump_args_N=1; + for lt_arg + do + \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[\$lt_dump_args_N]: \$lt_arg\" + lt_dump_args_N=\`expr \$lt_dump_args_N + 1\` + done +} + +# Core function for launching the target application +func_exec_program_core () +{ +" + case $host in + # Backslashes separate directories on plain windows + *-*-mingw | *-*-os2* | *-cegcc*) + $ECHO "\ + if test -n \"\$lt_option_debug\"; then + \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[0]: \$progdir\\\\\$program\" 1>&2 + func_lt_dump_args \${1+\"\$@\"} 1>&2 + fi + exec \"\$progdir\\\\\$program\" \${1+\"\$@\"} +" + ;; + + *) + $ECHO "\ + if test -n \"\$lt_option_debug\"; then + \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[0]: \$progdir/\$program\" 1>&2 + func_lt_dump_args \${1+\"\$@\"} 1>&2 + fi + exec \"\$progdir/\$program\" \${1+\"\$@\"} +" + ;; + esac + $ECHO "\ + \$ECHO \"\$0: cannot exec \$program \$*\" 1>&2 + exit 1 +} + +# A function to encapsulate launching the target application +# Strips options in the --lt-* namespace from \$@ and +# launches target application with the remaining arguments. +func_exec_program () +{ + case \" \$* \" in + *\\ --lt-*) + for lt_wr_arg + do + case \$lt_wr_arg in + --lt-*) ;; + *) set x \"\$@\" \"\$lt_wr_arg\"; shift;; + esac + shift + done ;; + esac + func_exec_program_core \${1+\"\$@\"} +} + + # Parse options + func_parse_lt_options \"\$0\" \${1+\"\$@\"} + + # Find the directory that this script lives in. + thisdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*$%%'\` + test \"x\$thisdir\" = \"x\$file\" && thisdir=. + + # Follow symbolic links until we get to the real thisdir. + file=\`ls -ld \"\$file\" | $SED -n 's/.*-> //p'\` + while test -n \"\$file\"; do + destdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*\$%%'\` + + # If there was a directory component, then change thisdir. + if test \"x\$destdir\" != \"x\$file\"; then + case \"\$destdir\" in + [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;; + *) thisdir=\"\$thisdir/\$destdir\" ;; + esac + fi + + file=\`\$ECHO \"\$file\" | $SED 's%^.*/%%'\` + file=\`ls -ld \"\$thisdir/\$file\" | $SED -n 's/.*-> //p'\` + done + + # Usually 'no', except on cygwin/mingw when embedded into + # the cwrapper. + WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_arg1 + if test \"\$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\" = \"yes\"; then + # special case for '.' + if test \"\$thisdir\" = \".\"; then + thisdir=\`pwd\` + fi + # remove .libs from thisdir + case \"\$thisdir\" in + *[\\\\/]$objdir ) thisdir=\`\$ECHO \"\$thisdir\" | $SED 's%[\\\\/][^\\\\/]*$%%'\` ;; + $objdir ) thisdir=. ;; + esac + fi + + # Try to get the absolute directory name. + absdir=\`cd \"\$thisdir\" && pwd\` + test -n \"\$absdir\" && thisdir=\"\$absdir\" +" + + if test "$fast_install" = yes; then + $ECHO "\ + program=lt-'$outputname'$exeext + progdir=\"\$thisdir/$objdir\" + + if test ! -f \"\$progdir/\$program\" || + { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\ + test \"X\$file\" != \"X\$progdir/\$program\"; }; then + + file=\"\$\$-\$program\" + + if test ! -d \"\$progdir\"; then + $MKDIR \"\$progdir\" + else + $RM \"\$progdir/\$file\" + fi" + + $ECHO "\ + + # relink executable if necessary + if test -n \"\$relink_command\"; then + if relink_command_output=\`eval \$relink_command 2>&1\`; then : + else + $ECHO \"\$relink_command_output\" >&2 + $RM \"\$progdir/\$file\" + exit 1 + fi + fi + + $MV \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null || + { $RM \"\$progdir/\$program\"; + $MV \"\$progdir/\$file\" \"\$progdir/\$program\"; } + $RM \"\$progdir/\$file\" + fi" + else + $ECHO "\ + program='$outputname' + progdir=\"\$thisdir/$objdir\" +" + fi + + $ECHO "\ + + if test -f \"\$progdir/\$program\"; then" + + # fixup the dll searchpath if we need to. + # + # Fix the DLL searchpath if we need to. Do this before prepending + # to shlibpath, because on Windows, both are PATH and uninstalled + # libraries must come first. + if test -n "$dllsearchpath"; then + $ECHO "\ + # Add the dll search path components to the executable PATH + PATH=$dllsearchpath:\$PATH +" + fi + + # Export our shlibpath_var if we have one. + if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then + $ECHO "\ + # Add our own library path to $shlibpath_var + $shlibpath_var=\"$temp_rpath\$$shlibpath_var\" + + # Some systems cannot cope with colon-terminated $shlibpath_var + # The second colon is a workaround for a bug in BeOS R4 sed + $shlibpath_var=\`\$ECHO \"\$$shlibpath_var\" | $SED 's/::*\$//'\` + + export $shlibpath_var +" + fi + + $ECHO "\ + if test \"\$libtool_execute_magic\" != \"$magic\"; then + # Run the actual program with our arguments. + func_exec_program \${1+\"\$@\"} + fi + else + # The program doesn't exist. + \$ECHO \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2 + \$ECHO \"This script is just a wrapper for \$program.\" 1>&2 + \$ECHO \"See the $PACKAGE documentation for more information.\" 1>&2 + exit 1 + fi +fi\ +" +} + + +# func_emit_cwrapperexe_src +# emit the source code for a wrapper executable on stdout +# Must ONLY be called from within func_mode_link because +# it depends on a number of variable set therein. +func_emit_cwrapperexe_src () +{ + cat < +#include +#ifdef _MSC_VER +# include +# include +# include +#else +# include +# include +# ifdef __CYGWIN__ +# include +# endif +#endif +#include +#include +#include +#include +#include +#include +#include +#include + +/* declarations of non-ANSI functions */ +#if defined(__MINGW32__) +# ifdef __STRICT_ANSI__ +int _putenv (const char *); +# endif +#elif defined(__CYGWIN__) +# ifdef __STRICT_ANSI__ +char *realpath (const char *, char *); +int putenv (char *); +int setenv (const char *, const char *, int); +# endif +/* #elif defined (other platforms) ... */ +#endif + +/* portability defines, excluding path handling macros */ +#if defined(_MSC_VER) +# define setmode _setmode +# define stat _stat +# define chmod _chmod +# define getcwd _getcwd +# define putenv _putenv +# define S_IXUSR _S_IEXEC +# ifndef _INTPTR_T_DEFINED +# define _INTPTR_T_DEFINED +# define intptr_t int +# endif +#elif defined(__MINGW32__) +# define setmode _setmode +# define stat _stat +# define chmod _chmod +# define getcwd _getcwd +# define putenv _putenv +#elif defined(__CYGWIN__) +# define HAVE_SETENV +# define FOPEN_WB "wb" +/* #elif defined (other platforms) ... */ +#endif + +#if defined(PATH_MAX) +# define LT_PATHMAX PATH_MAX +#elif defined(MAXPATHLEN) +# define LT_PATHMAX MAXPATHLEN +#else +# define LT_PATHMAX 1024 +#endif + +#ifndef S_IXOTH +# define S_IXOTH 0 +#endif +#ifndef S_IXGRP +# define S_IXGRP 0 +#endif + +/* path handling portability macros */ +#ifndef DIR_SEPARATOR +# define DIR_SEPARATOR '/' +# define PATH_SEPARATOR ':' +#endif + +#if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \ + defined (__OS2__) +# define HAVE_DOS_BASED_FILE_SYSTEM +# define FOPEN_WB "wb" +# ifndef DIR_SEPARATOR_2 +# define DIR_SEPARATOR_2 '\\' +# endif +# ifndef PATH_SEPARATOR_2 +# define PATH_SEPARATOR_2 ';' +# endif +#endif + +#ifndef DIR_SEPARATOR_2 +# define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR) +#else /* DIR_SEPARATOR_2 */ +# define IS_DIR_SEPARATOR(ch) \ + (((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2)) +#endif /* DIR_SEPARATOR_2 */ + +#ifndef PATH_SEPARATOR_2 +# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR) +#else /* PATH_SEPARATOR_2 */ +# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2) +#endif /* PATH_SEPARATOR_2 */ + +#ifndef FOPEN_WB +# define FOPEN_WB "w" +#endif +#ifndef _O_BINARY +# define _O_BINARY 0 +#endif + +#define XMALLOC(type, num) ((type *) xmalloc ((num) * sizeof(type))) +#define XFREE(stale) do { \ + if (stale) { free ((void *) stale); stale = 0; } \ +} while (0) + +#if defined(LT_DEBUGWRAPPER) +static int lt_debug = 1; +#else +static int lt_debug = 0; +#endif + +const char *program_name = "libtool-wrapper"; /* in case xstrdup fails */ + +void *xmalloc (size_t num); +char *xstrdup (const char *string); +const char *base_name (const char *name); +char *find_executable (const char *wrapper); +char *chase_symlinks (const char *pathspec); +int make_executable (const char *path); +int check_executable (const char *path); +char *strendzap (char *str, const char *pat); +void lt_debugprintf (const char *file, int line, const char *fmt, ...); +void lt_fatal (const char *file, int line, const char *message, ...); +static const char *nonnull (const char *s); +static const char *nonempty (const char *s); +void lt_setenv (const char *name, const char *value); +char *lt_extend_str (const char *orig_value, const char *add, int to_end); +void lt_update_exe_path (const char *name, const char *value); +void lt_update_lib_path (const char *name, const char *value); +char **prepare_spawn (char **argv); +void lt_dump_script (FILE *f); +EOF + + cat <= 0) + && (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH))) + return 1; + else + return 0; +} + +int +make_executable (const char *path) +{ + int rval = 0; + struct stat st; + + lt_debugprintf (__FILE__, __LINE__, "(make_executable): %s\n", + nonempty (path)); + if ((!path) || (!*path)) + return 0; + + if (stat (path, &st) >= 0) + { + rval = chmod (path, st.st_mode | S_IXOTH | S_IXGRP | S_IXUSR); + } + return rval; +} + +/* Searches for the full path of the wrapper. Returns + newly allocated full path name if found, NULL otherwise + Does not chase symlinks, even on platforms that support them. +*/ +char * +find_executable (const char *wrapper) +{ + int has_slash = 0; + const char *p; + const char *p_next; + /* static buffer for getcwd */ + char tmp[LT_PATHMAX + 1]; + int tmp_len; + char *concat_name; + + lt_debugprintf (__FILE__, __LINE__, "(find_executable): %s\n", + nonempty (wrapper)); + + if ((wrapper == NULL) || (*wrapper == '\0')) + return NULL; + + /* Absolute path? */ +#if defined (HAVE_DOS_BASED_FILE_SYSTEM) + if (isalpha ((unsigned char) wrapper[0]) && wrapper[1] == ':') + { + concat_name = xstrdup (wrapper); + if (check_executable (concat_name)) + return concat_name; + XFREE (concat_name); + } + else + { +#endif + if (IS_DIR_SEPARATOR (wrapper[0])) + { + concat_name = xstrdup (wrapper); + if (check_executable (concat_name)) + return concat_name; + XFREE (concat_name); + } +#if defined (HAVE_DOS_BASED_FILE_SYSTEM) + } +#endif + + for (p = wrapper; *p; p++) + if (*p == '/') + { + has_slash = 1; + break; + } + if (!has_slash) + { + /* no slashes; search PATH */ + const char *path = getenv ("PATH"); + if (path != NULL) + { + for (p = path; *p; p = p_next) + { + const char *q; + size_t p_len; + for (q = p; *q; q++) + if (IS_PATH_SEPARATOR (*q)) + break; + p_len = q - p; + p_next = (*q == '\0' ? q : q + 1); + if (p_len == 0) + { + /* empty path: current directory */ + if (getcwd (tmp, LT_PATHMAX) == NULL) + lt_fatal (__FILE__, __LINE__, "getcwd failed: %s", + nonnull (strerror (errno))); + tmp_len = strlen (tmp); + concat_name = + XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1); + memcpy (concat_name, tmp, tmp_len); + concat_name[tmp_len] = '/'; + strcpy (concat_name + tmp_len + 1, wrapper); + } + else + { + concat_name = + XMALLOC (char, p_len + 1 + strlen (wrapper) + 1); + memcpy (concat_name, p, p_len); + concat_name[p_len] = '/'; + strcpy (concat_name + p_len + 1, wrapper); + } + if (check_executable (concat_name)) + return concat_name; + XFREE (concat_name); + } + } + /* not found in PATH; assume curdir */ + } + /* Relative path | not found in path: prepend cwd */ + if (getcwd (tmp, LT_PATHMAX) == NULL) + lt_fatal (__FILE__, __LINE__, "getcwd failed: %s", + nonnull (strerror (errno))); + tmp_len = strlen (tmp); + concat_name = XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1); + memcpy (concat_name, tmp, tmp_len); + concat_name[tmp_len] = '/'; + strcpy (concat_name + tmp_len + 1, wrapper); + + if (check_executable (concat_name)) + return concat_name; + XFREE (concat_name); + return NULL; +} + +char * +chase_symlinks (const char *pathspec) +{ +#ifndef S_ISLNK + return xstrdup (pathspec); +#else + char buf[LT_PATHMAX]; + struct stat s; + char *tmp_pathspec = xstrdup (pathspec); + char *p; + int has_symlinks = 0; + while (strlen (tmp_pathspec) && !has_symlinks) + { + lt_debugprintf (__FILE__, __LINE__, + "checking path component for symlinks: %s\n", + tmp_pathspec); + if (lstat (tmp_pathspec, &s) == 0) + { + if (S_ISLNK (s.st_mode) != 0) + { + has_symlinks = 1; + break; + } + + /* search backwards for last DIR_SEPARATOR */ + p = tmp_pathspec + strlen (tmp_pathspec) - 1; + while ((p > tmp_pathspec) && (!IS_DIR_SEPARATOR (*p))) + p--; + if ((p == tmp_pathspec) && (!IS_DIR_SEPARATOR (*p))) + { + /* no more DIR_SEPARATORS left */ + break; + } + *p = '\0'; + } + else + { + lt_fatal (__FILE__, __LINE__, + "error accessing file \"%s\": %s", + tmp_pathspec, nonnull (strerror (errno))); + } + } + XFREE (tmp_pathspec); + + if (!has_symlinks) + { + return xstrdup (pathspec); + } + + tmp_pathspec = realpath (pathspec, buf); + if (tmp_pathspec == 0) + { + lt_fatal (__FILE__, __LINE__, + "could not follow symlinks for %s", pathspec); + } + return xstrdup (tmp_pathspec); +#endif +} + +char * +strendzap (char *str, const char *pat) +{ + size_t len, patlen; + + assert (str != NULL); + assert (pat != NULL); + + len = strlen (str); + patlen = strlen (pat); + + if (patlen <= len) + { + str += len - patlen; + if (strcmp (str, pat) == 0) + *str = '\0'; + } + return str; +} + +void +lt_debugprintf (const char *file, int line, const char *fmt, ...) +{ + va_list args; + if (lt_debug) + { + (void) fprintf (stderr, "%s:%s:%d: ", program_name, file, line); + va_start (args, fmt); + (void) vfprintf (stderr, fmt, args); + va_end (args); + } +} + +static void +lt_error_core (int exit_status, const char *file, + int line, const char *mode, + const char *message, va_list ap) +{ + fprintf (stderr, "%s:%s:%d: %s: ", program_name, file, line, mode); + vfprintf (stderr, message, ap); + fprintf (stderr, ".\n"); + + if (exit_status >= 0) + exit (exit_status); +} + +void +lt_fatal (const char *file, int line, const char *message, ...) +{ + va_list ap; + va_start (ap, message); + lt_error_core (EXIT_FAILURE, file, line, "FATAL", message, ap); + va_end (ap); +} + +static const char * +nonnull (const char *s) +{ + return s ? s : "(null)"; +} + +static const char * +nonempty (const char *s) +{ + return (s && !*s) ? "(empty)" : nonnull (s); +} + +void +lt_setenv (const char *name, const char *value) +{ + lt_debugprintf (__FILE__, __LINE__, + "(lt_setenv) setting '%s' to '%s'\n", + nonnull (name), nonnull (value)); + { +#ifdef HAVE_SETENV + /* always make a copy, for consistency with !HAVE_SETENV */ + char *str = xstrdup (value); + setenv (name, str, 1); +#else + int len = strlen (name) + 1 + strlen (value) + 1; + char *str = XMALLOC (char, len); + sprintf (str, "%s=%s", name, value); + if (putenv (str) != EXIT_SUCCESS) + { + XFREE (str); + } +#endif + } +} + +char * +lt_extend_str (const char *orig_value, const char *add, int to_end) +{ + char *new_value; + if (orig_value && *orig_value) + { + int orig_value_len = strlen (orig_value); + int add_len = strlen (add); + new_value = XMALLOC (char, add_len + orig_value_len + 1); + if (to_end) + { + strcpy (new_value, orig_value); + strcpy (new_value + orig_value_len, add); + } + else + { + strcpy (new_value, add); + strcpy (new_value + add_len, orig_value); + } + } + else + { + new_value = xstrdup (add); + } + return new_value; +} + +void +lt_update_exe_path (const char *name, const char *value) +{ + lt_debugprintf (__FILE__, __LINE__, + "(lt_update_exe_path) modifying '%s' by prepending '%s'\n", + nonnull (name), nonnull (value)); + + if (name && *name && value && *value) + { + char *new_value = lt_extend_str (getenv (name), value, 0); + /* some systems can't cope with a ':'-terminated path #' */ + int len = strlen (new_value); + while (((len = strlen (new_value)) > 0) && IS_PATH_SEPARATOR (new_value[len-1])) + { + new_value[len-1] = '\0'; + } + lt_setenv (name, new_value); + XFREE (new_value); + } +} + +void +lt_update_lib_path (const char *name, const char *value) +{ + lt_debugprintf (__FILE__, __LINE__, + "(lt_update_lib_path) modifying '%s' by prepending '%s'\n", + nonnull (name), nonnull (value)); + + if (name && *name && value && *value) + { + char *new_value = lt_extend_str (getenv (name), value, 0); + lt_setenv (name, new_value); + XFREE (new_value); + } +} + +EOF + case $host_os in + mingw*) + cat <<"EOF" + +/* Prepares an argument vector before calling spawn(). + Note that spawn() does not by itself call the command interpreter + (getenv ("COMSPEC") != NULL ? getenv ("COMSPEC") : + ({ OSVERSIONINFO v; v.dwOSVersionInfoSize = sizeof(OSVERSIONINFO); + GetVersionEx(&v); + v.dwPlatformId == VER_PLATFORM_WIN32_NT; + }) ? "cmd.exe" : "command.com"). + Instead it simply concatenates the arguments, separated by ' ', and calls + CreateProcess(). We must quote the arguments since Win32 CreateProcess() + interprets characters like ' ', '\t', '\\', '"' (but not '<' and '>') in a + special way: + - Space and tab are interpreted as delimiters. They are not treated as + delimiters if they are surrounded by double quotes: "...". + - Unescaped double quotes are removed from the input. Their only effect is + that within double quotes, space and tab are treated like normal + characters. + - Backslashes not followed by double quotes are not special. + - But 2*n+1 backslashes followed by a double quote become + n backslashes followed by a double quote (n >= 0): + \" -> " + \\\" -> \" + \\\\\" -> \\" + */ +#define SHELL_SPECIAL_CHARS "\"\\ \001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037" +#define SHELL_SPACE_CHARS " \001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037" +char ** +prepare_spawn (char **argv) +{ + size_t argc; + char **new_argv; + size_t i; + + /* Count number of arguments. */ + for (argc = 0; argv[argc] != NULL; argc++) + ; + + /* Allocate new argument vector. */ + new_argv = XMALLOC (char *, argc + 1); + + /* Put quoted arguments into the new argument vector. */ + for (i = 0; i < argc; i++) + { + const char *string = argv[i]; + + if (string[0] == '\0') + new_argv[i] = xstrdup ("\"\""); + else if (strpbrk (string, SHELL_SPECIAL_CHARS) != NULL) + { + int quote_around = (strpbrk (string, SHELL_SPACE_CHARS) != NULL); + size_t length; + unsigned int backslashes; + const char *s; + char *quoted_string; + char *p; + + length = 0; + backslashes = 0; + if (quote_around) + length++; + for (s = string; *s != '\0'; s++) + { + char c = *s; + if (c == '"') + length += backslashes + 1; + length++; + if (c == '\\') + backslashes++; + else + backslashes = 0; + } + if (quote_around) + length += backslashes + 1; + + quoted_string = XMALLOC (char, length + 1); + + p = quoted_string; + backslashes = 0; + if (quote_around) + *p++ = '"'; + for (s = string; *s != '\0'; s++) + { + char c = *s; + if (c == '"') + { + unsigned int j; + for (j = backslashes + 1; j > 0; j--) + *p++ = '\\'; + } + *p++ = c; + if (c == '\\') + backslashes++; + else + backslashes = 0; + } + if (quote_around) + { + unsigned int j; + for (j = backslashes; j > 0; j--) + *p++ = '\\'; + *p++ = '"'; + } + *p = '\0'; + + new_argv[i] = quoted_string; + } + else + new_argv[i] = (char *) string; + } + new_argv[argc] = NULL; + + return new_argv; +} +EOF + ;; + esac + + cat <<"EOF" +void lt_dump_script (FILE* f) +{ +EOF + func_emit_wrapper yes | + $SED -n -e ' +s/^\(.\{79\}\)\(..*\)/\1\ +\2/ +h +s/\([\\"]\)/\\\1/g +s/$/\\n/ +s/\([^\n]*\).*/ fputs ("\1", f);/p +g +D' + cat <<"EOF" +} +EOF +} +# end: func_emit_cwrapperexe_src + +# func_win32_import_lib_p ARG +# True if ARG is an import lib, as indicated by $file_magic_cmd +func_win32_import_lib_p () +{ + $opt_debug + case `eval $file_magic_cmd \"\$1\" 2>/dev/null | $SED -e 10q` in + *import*) : ;; + *) false ;; + esac +} + +# func_mode_link arg... +func_mode_link () +{ + $opt_debug + case $host in + *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*) + # It is impossible to link a dll without this setting, and + # we shouldn't force the makefile maintainer to figure out + # which system we are compiling for in order to pass an extra + # flag for every libtool invocation. + # allow_undefined=no + + # FIXME: Unfortunately, there are problems with the above when trying + # to make a dll which has undefined symbols, in which case not + # even a static library is built. For now, we need to specify + # -no-undefined on the libtool link line when we can be certain + # that all symbols are satisfied, otherwise we get a static library. + allow_undefined=yes + ;; + *) + allow_undefined=yes + ;; + esac + libtool_args=$nonopt + base_compile="$nonopt $@" + compile_command=$nonopt + finalize_command=$nonopt + + compile_rpath= + finalize_rpath= + compile_shlibpath= + finalize_shlibpath= + convenience= + old_convenience= + deplibs= + old_deplibs= + compiler_flags= + linker_flags= + dllsearchpath= + lib_search_path=`pwd` + inst_prefix_dir= + new_inherited_linker_flags= + + avoid_version=no + bindir= + dlfiles= + dlprefiles= + dlself=no + export_dynamic=no + export_symbols= + export_symbols_regex= + generated= + libobjs= + ltlibs= + module=no + no_install=no + objs= + non_pic_objects= + precious_files_regex= + prefer_static_libs=no + preload=no + prev= + prevarg= + release= + rpath= + xrpath= + perm_rpath= + temp_rpath= + thread_safe=no + vinfo= + vinfo_number=no + weak_libs= + single_module="${wl}-single_module" + func_infer_tag $base_compile + + # We need to know -static, to get the right output filenames. + for arg + do + case $arg in + -shared) + test "$build_libtool_libs" != yes && \ + func_fatal_configuration "can not build a shared library" + build_old_libs=no + break + ;; + -all-static | -static | -static-libtool-libs) + case $arg in + -all-static) + if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then + func_warning "complete static linking is impossible in this configuration" + fi + if test -n "$link_static_flag"; then + dlopen_self=$dlopen_self_static + fi + prefer_static_libs=yes + ;; + -static) + if test -z "$pic_flag" && test -n "$link_static_flag"; then + dlopen_self=$dlopen_self_static + fi + prefer_static_libs=built + ;; + -static-libtool-libs) + if test -z "$pic_flag" && test -n "$link_static_flag"; then + dlopen_self=$dlopen_self_static + fi + prefer_static_libs=yes + ;; + esac + build_libtool_libs=no + build_old_libs=yes + break + ;; + esac + done + + # See if our shared archives depend on static archives. + test -n "$old_archive_from_new_cmds" && build_old_libs=yes + + # Go through the arguments, transforming them on the way. + while test "$#" -gt 0; do + arg="$1" + shift + func_quote_for_eval "$arg" + qarg=$func_quote_for_eval_unquoted_result + func_append libtool_args " $func_quote_for_eval_result" + + # If the previous option needs an argument, assign it. + if test -n "$prev"; then + case $prev in + output) + func_append compile_command " @OUTPUT@" + func_append finalize_command " @OUTPUT@" + ;; + esac + + case $prev in + bindir) + bindir="$arg" + prev= + continue + ;; + dlfiles|dlprefiles) + if test "$preload" = no; then + # Add the symbol object into the linking commands. + func_append compile_command " @SYMFILE@" + func_append finalize_command " @SYMFILE@" + preload=yes + fi + case $arg in + *.la | *.lo) ;; # We handle these cases below. + force) + if test "$dlself" = no; then + dlself=needless + export_dynamic=yes + fi + prev= + continue + ;; + self) + if test "$prev" = dlprefiles; then + dlself=yes + elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then + dlself=yes + else + dlself=needless + export_dynamic=yes + fi + prev= + continue + ;; + *) + if test "$prev" = dlfiles; then + func_append dlfiles " $arg" + else + func_append dlprefiles " $arg" + fi + prev= + continue + ;; + esac + ;; + expsyms) + export_symbols="$arg" + test -f "$arg" \ + || func_fatal_error "symbol file \`$arg' does not exist" + prev= + continue + ;; + expsyms_regex) + export_symbols_regex="$arg" + prev= + continue + ;; + framework) + case $host in + *-*-darwin*) + case "$deplibs " in + *" $qarg.ltframework "*) ;; + *) func_append deplibs " $qarg.ltframework" # this is fixed later + ;; + esac + ;; + esac + prev= + continue + ;; + inst_prefix) + inst_prefix_dir="$arg" + prev= + continue + ;; + objectlist) + if test -f "$arg"; then + save_arg=$arg + moreargs= + for fil in `cat "$save_arg"` + do +# func_append moreargs " $fil" + arg=$fil + # A libtool-controlled object. + + # Check to see that this really is a libtool object. + if func_lalib_unsafe_p "$arg"; then + pic_object= + non_pic_object= + + # Read the .lo file + func_source "$arg" + + if test -z "$pic_object" || + test -z "$non_pic_object" || + test "$pic_object" = none && + test "$non_pic_object" = none; then + func_fatal_error "cannot find name of object for \`$arg'" + fi + + # Extract subdirectory from the argument. + func_dirname "$arg" "/" "" + xdir="$func_dirname_result" + + if test "$pic_object" != none; then + # Prepend the subdirectory the object is found in. + pic_object="$xdir$pic_object" + + if test "$prev" = dlfiles; then + if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then + func_append dlfiles " $pic_object" + prev= + continue + else + # If libtool objects are unsupported, then we need to preload. + prev=dlprefiles + fi + fi + + # CHECK ME: I think I busted this. -Ossama + if test "$prev" = dlprefiles; then + # Preload the old-style object. + func_append dlprefiles " $pic_object" + prev= + fi + + # A PIC object. + func_append libobjs " $pic_object" + arg="$pic_object" + fi + + # Non-PIC object. + if test "$non_pic_object" != none; then + # Prepend the subdirectory the object is found in. + non_pic_object="$xdir$non_pic_object" + + # A standard non-PIC object + func_append non_pic_objects " $non_pic_object" + if test -z "$pic_object" || test "$pic_object" = none ; then + arg="$non_pic_object" + fi + else + # If the PIC object exists, use it instead. + # $xdir was prepended to $pic_object above. + non_pic_object="$pic_object" + func_append non_pic_objects " $non_pic_object" + fi + else + # Only an error if not doing a dry-run. + if $opt_dry_run; then + # Extract subdirectory from the argument. + func_dirname "$arg" "/" "" + xdir="$func_dirname_result" + + func_lo2o "$arg" + pic_object=$xdir$objdir/$func_lo2o_result + non_pic_object=$xdir$func_lo2o_result + func_append libobjs " $pic_object" + func_append non_pic_objects " $non_pic_object" + else + func_fatal_error "\`$arg' is not a valid libtool object" + fi + fi + done + else + func_fatal_error "link input file \`$arg' does not exist" + fi + arg=$save_arg + prev= + continue + ;; + precious_regex) + precious_files_regex="$arg" + prev= + continue + ;; + release) + release="-$arg" + prev= + continue + ;; + rpath | xrpath) + # We need an absolute path. + case $arg in + [\\/]* | [A-Za-z]:[\\/]*) ;; + *) + func_fatal_error "only absolute run-paths are allowed" + ;; + esac + if test "$prev" = rpath; then + case "$rpath " in + *" $arg "*) ;; + *) func_append rpath " $arg" ;; + esac + else + case "$xrpath " in + *" $arg "*) ;; + *) func_append xrpath " $arg" ;; + esac + fi + prev= + continue + ;; + shrext) + shrext_cmds="$arg" + prev= + continue + ;; + weak) + func_append weak_libs " $arg" + prev= + continue + ;; + xcclinker) + func_append linker_flags " $qarg" + func_append compiler_flags " $qarg" + prev= + func_append compile_command " $qarg" + func_append finalize_command " $qarg" + continue + ;; + xcompiler) + func_append compiler_flags " $qarg" + prev= + func_append compile_command " $qarg" + func_append finalize_command " $qarg" + continue + ;; + xlinker) + func_append linker_flags " $qarg" + func_append compiler_flags " $wl$qarg" + prev= + func_append compile_command " $wl$qarg" + func_append finalize_command " $wl$qarg" + continue + ;; + *) + eval "$prev=\"\$arg\"" + prev= + continue + ;; + esac + fi # test -n "$prev" + + prevarg="$arg" + + case $arg in + -all-static) + if test -n "$link_static_flag"; then + # See comment for -static flag below, for more details. + func_append compile_command " $link_static_flag" + func_append finalize_command " $link_static_flag" + fi + continue + ;; + + -allow-undefined) + # FIXME: remove this flag sometime in the future. + func_fatal_error "\`-allow-undefined' must not be used because it is the default" + ;; + + -avoid-version) + avoid_version=yes + continue + ;; + + -bindir) + prev=bindir + continue + ;; + + -dlopen) + prev=dlfiles + continue + ;; + + -dlpreopen) + prev=dlprefiles + continue + ;; + + -export-dynamic) + export_dynamic=yes + continue + ;; + + -export-symbols | -export-symbols-regex) + if test -n "$export_symbols" || test -n "$export_symbols_regex"; then + func_fatal_error "more than one -exported-symbols argument is not allowed" + fi + if test "X$arg" = "X-export-symbols"; then + prev=expsyms + else + prev=expsyms_regex + fi + continue + ;; + + -framework) + prev=framework + continue + ;; + + -inst-prefix-dir) + prev=inst_prefix + continue + ;; + + # The native IRIX linker understands -LANG:*, -LIST:* and -LNO:* + # so, if we see these flags be careful not to treat them like -L + -L[A-Z][A-Z]*:*) + case $with_gcc/$host in + no/*-*-irix* | /*-*-irix*) + func_append compile_command " $arg" + func_append finalize_command " $arg" + ;; + esac + continue + ;; + + -L*) + func_stripname "-L" '' "$arg" + if test -z "$func_stripname_result"; then + if test "$#" -gt 0; then + func_fatal_error "require no space between \`-L' and \`$1'" + else + func_fatal_error "need path for \`-L' option" + fi + fi + func_resolve_sysroot "$func_stripname_result" + dir=$func_resolve_sysroot_result + # We need an absolute path. + case $dir in + [\\/]* | [A-Za-z]:[\\/]*) ;; + *) + absdir=`cd "$dir" && pwd` + test -z "$absdir" && \ + func_fatal_error "cannot determine absolute directory name of \`$dir'" + dir="$absdir" + ;; + esac + case "$deplibs " in + *" -L$dir "* | *" $arg "*) + # Will only happen for absolute or sysroot arguments + ;; + *) + # Preserve sysroot, but never include relative directories + case $dir in + [\\/]* | [A-Za-z]:[\\/]* | =*) func_append deplibs " $arg" ;; + *) func_append deplibs " -L$dir" ;; + esac + func_append lib_search_path " $dir" + ;; + esac + case $host in + *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*) + testbindir=`$ECHO "$dir" | $SED 's*/lib$*/bin*'` + case :$dllsearchpath: in + *":$dir:"*) ;; + ::) dllsearchpath=$dir;; + *) func_append dllsearchpath ":$dir";; + esac + case :$dllsearchpath: in + *":$testbindir:"*) ;; + ::) dllsearchpath=$testbindir;; + *) func_append dllsearchpath ":$testbindir";; + esac + ;; + esac + continue + ;; + + -l*) + if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then + case $host in + *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos* | *-cegcc* | *-*-haiku*) + # These systems don't actually have a C or math library (as such) + continue + ;; + *-*-os2*) + # These systems don't actually have a C library (as such) + test "X$arg" = "X-lc" && continue + ;; + *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*) + # Do not include libc due to us having libc/libc_r. + test "X$arg" = "X-lc" && continue + ;; + *-*-rhapsody* | *-*-darwin1.[012]) + # Rhapsody C and math libraries are in the System framework + func_append deplibs " System.ltframework" + continue + ;; + *-*-sco3.2v5* | *-*-sco5v6*) + # Causes problems with __ctype + test "X$arg" = "X-lc" && continue + ;; + *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*) + # Compiler inserts libc in the correct place for threads to work + test "X$arg" = "X-lc" && continue + ;; + esac + elif test "X$arg" = "X-lc_r"; then + case $host in + *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*) + # Do not include libc_r directly, use -pthread flag. + continue + ;; + esac + fi + func_append deplibs " $arg" + continue + ;; + + -module) + module=yes + continue + ;; + + # Tru64 UNIX uses -model [arg] to determine the layout of C++ + # classes, name mangling, and exception handling. + # Darwin uses the -arch flag to determine output architecture. + -model|-arch|-isysroot|--sysroot) + func_append compiler_flags " $arg" + func_append compile_command " $arg" + func_append finalize_command " $arg" + prev=xcompiler + continue + ;; + + -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe \ + |-threads|-fopenmp|-openmp|-mp|-xopenmp|-omp|-qsmp=*) + func_append compiler_flags " $arg" + func_append compile_command " $arg" + func_append finalize_command " $arg" + case "$new_inherited_linker_flags " in + *" $arg "*) ;; + * ) func_append new_inherited_linker_flags " $arg" ;; + esac + continue + ;; + + -multi_module) + single_module="${wl}-multi_module" + continue + ;; + + -no-fast-install) + fast_install=no + continue + ;; + + -no-install) + case $host in + *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-darwin* | *-cegcc*) + # The PATH hackery in wrapper scripts is required on Windows + # and Darwin in order for the loader to find any dlls it needs. + func_warning "\`-no-install' is ignored for $host" + func_warning "assuming \`-no-fast-install' instead" + fast_install=no + ;; + *) no_install=yes ;; + esac + continue + ;; + + -no-undefined) + allow_undefined=no + continue + ;; + + -objectlist) + prev=objectlist + continue + ;; + + -o) prev=output ;; + + -precious-files-regex) + prev=precious_regex + continue + ;; + + -release) + prev=release + continue + ;; + + -rpath) + prev=rpath + continue + ;; + + -R) + prev=xrpath + continue + ;; + + -R*) + func_stripname '-R' '' "$arg" + dir=$func_stripname_result + # We need an absolute path. + case $dir in + [\\/]* | [A-Za-z]:[\\/]*) ;; + =*) + func_stripname '=' '' "$dir" + dir=$lt_sysroot$func_stripname_result + ;; + *) + func_fatal_error "only absolute run-paths are allowed" + ;; + esac + case "$xrpath " in + *" $dir "*) ;; + *) func_append xrpath " $dir" ;; + esac + continue + ;; + + -shared) + # The effects of -shared are defined in a previous loop. + continue + ;; + + -shrext) + prev=shrext + continue + ;; + + -static | -static-libtool-libs) + # The effects of -static are defined in a previous loop. + # We used to do the same as -all-static on platforms that + # didn't have a PIC flag, but the assumption that the effects + # would be equivalent was wrong. It would break on at least + # Digital Unix and AIX. + continue + ;; + + -thread-safe) + thread_safe=yes + continue + ;; + + -version-info) + prev=vinfo + continue + ;; + + -version-number) + prev=vinfo + vinfo_number=yes + continue + ;; + + -weak) + prev=weak + continue + ;; + + -Wc,*) + func_stripname '-Wc,' '' "$arg" + args=$func_stripname_result + arg= + save_ifs="$IFS"; IFS=',' + for flag in $args; do + IFS="$save_ifs" + func_quote_for_eval "$flag" + func_append arg " $func_quote_for_eval_result" + func_append compiler_flags " $func_quote_for_eval_result" + done + IFS="$save_ifs" + func_stripname ' ' '' "$arg" + arg=$func_stripname_result + ;; + + -Wl,*) + func_stripname '-Wl,' '' "$arg" + args=$func_stripname_result + arg= + save_ifs="$IFS"; IFS=',' + for flag in $args; do + IFS="$save_ifs" + func_quote_for_eval "$flag" + func_append arg " $wl$func_quote_for_eval_result" + func_append compiler_flags " $wl$func_quote_for_eval_result" + func_append linker_flags " $func_quote_for_eval_result" + done + IFS="$save_ifs" + func_stripname ' ' '' "$arg" + arg=$func_stripname_result + ;; + + -Xcompiler) + prev=xcompiler + continue + ;; + + -Xlinker) + prev=xlinker + continue + ;; + + -XCClinker) + prev=xcclinker + continue + ;; + + # -msg_* for osf cc + -msg_*) + func_quote_for_eval "$arg" + arg="$func_quote_for_eval_result" + ;; + + # Flags to be passed through unchanged, with rationale: + # -64, -mips[0-9] enable 64-bit mode for the SGI compiler + # -r[0-9][0-9]* specify processor for the SGI compiler + # -xarch=*, -xtarget=* enable 64-bit mode for the Sun compiler + # +DA*, +DD* enable 64-bit mode for the HP compiler + # -q* compiler args for the IBM compiler + # -m*, -t[45]*, -txscale* architecture-specific flags for GCC + # -F/path path to uninstalled frameworks, gcc on darwin + # -p, -pg, --coverage, -fprofile-* profiling flags for GCC + # @file GCC response files + # -tp=* Portland pgcc target processor selection + # --sysroot=* for sysroot support + # -O*, -flto*, -fwhopr*, -fuse-linker-plugin GCC link-time optimization + -64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \ + -t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*|-tp=*|--sysroot=*| \ + -O*|-flto*|-fwhopr*|-fuse-linker-plugin) + func_quote_for_eval "$arg" + arg="$func_quote_for_eval_result" + func_append compile_command " $arg" + func_append finalize_command " $arg" + func_append compiler_flags " $arg" + continue + ;; + + # Some other compiler flag. + -* | +*) + func_quote_for_eval "$arg" + arg="$func_quote_for_eval_result" + ;; + + *.$objext) + # A standard object. + func_append objs " $arg" + ;; + + *.lo) + # A libtool-controlled object. + + # Check to see that this really is a libtool object. + if func_lalib_unsafe_p "$arg"; then + pic_object= + non_pic_object= + + # Read the .lo file + func_source "$arg" + + if test -z "$pic_object" || + test -z "$non_pic_object" || + test "$pic_object" = none && + test "$non_pic_object" = none; then + func_fatal_error "cannot find name of object for \`$arg'" + fi + + # Extract subdirectory from the argument. + func_dirname "$arg" "/" "" + xdir="$func_dirname_result" + + if test "$pic_object" != none; then + # Prepend the subdirectory the object is found in. + pic_object="$xdir$pic_object" + + if test "$prev" = dlfiles; then + if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then + func_append dlfiles " $pic_object" + prev= + continue + else + # If libtool objects are unsupported, then we need to preload. + prev=dlprefiles + fi + fi + + # CHECK ME: I think I busted this. -Ossama + if test "$prev" = dlprefiles; then + # Preload the old-style object. + func_append dlprefiles " $pic_object" + prev= + fi + + # A PIC object. + func_append libobjs " $pic_object" + arg="$pic_object" + fi + + # Non-PIC object. + if test "$non_pic_object" != none; then + # Prepend the subdirectory the object is found in. + non_pic_object="$xdir$non_pic_object" + + # A standard non-PIC object + func_append non_pic_objects " $non_pic_object" + if test -z "$pic_object" || test "$pic_object" = none ; then + arg="$non_pic_object" + fi + else + # If the PIC object exists, use it instead. + # $xdir was prepended to $pic_object above. + non_pic_object="$pic_object" + func_append non_pic_objects " $non_pic_object" + fi + else + # Only an error if not doing a dry-run. + if $opt_dry_run; then + # Extract subdirectory from the argument. + func_dirname "$arg" "/" "" + xdir="$func_dirname_result" + + func_lo2o "$arg" + pic_object=$xdir$objdir/$func_lo2o_result + non_pic_object=$xdir$func_lo2o_result + func_append libobjs " $pic_object" + func_append non_pic_objects " $non_pic_object" + else + func_fatal_error "\`$arg' is not a valid libtool object" + fi + fi + ;; + + *.$libext) + # An archive. + func_append deplibs " $arg" + func_append old_deplibs " $arg" + continue + ;; + + *.la) + # A libtool-controlled library. + + func_resolve_sysroot "$arg" + if test "$prev" = dlfiles; then + # This library was specified with -dlopen. + func_append dlfiles " $func_resolve_sysroot_result" + prev= + elif test "$prev" = dlprefiles; then + # The library was specified with -dlpreopen. + func_append dlprefiles " $func_resolve_sysroot_result" + prev= + else + func_append deplibs " $func_resolve_sysroot_result" + fi + continue + ;; + + # Some other compiler argument. + *) + # Unknown arguments in both finalize_command and compile_command need + # to be aesthetically quoted because they are evaled later. + func_quote_for_eval "$arg" + arg="$func_quote_for_eval_result" + ;; + esac # arg + + # Now actually substitute the argument into the commands. + if test -n "$arg"; then + func_append compile_command " $arg" + func_append finalize_command " $arg" + fi + done # argument parsing loop + + test -n "$prev" && \ + func_fatal_help "the \`$prevarg' option requires an argument" + + if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then + eval arg=\"$export_dynamic_flag_spec\" + func_append compile_command " $arg" + func_append finalize_command " $arg" + fi + + oldlibs= + # calculate the name of the file, without its directory + func_basename "$output" + outputname="$func_basename_result" + libobjs_save="$libobjs" + + if test -n "$shlibpath_var"; then + # get the directories listed in $shlibpath_var + eval shlib_search_path=\`\$ECHO \"\${$shlibpath_var}\" \| \$SED \'s/:/ /g\'\` + else + shlib_search_path= + fi + eval sys_lib_search_path=\"$sys_lib_search_path_spec\" + eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\" + + func_dirname "$output" "/" "" + output_objdir="$func_dirname_result$objdir" + func_to_tool_file "$output_objdir/" + tool_output_objdir=$func_to_tool_file_result + # Create the object directory. + func_mkdir_p "$output_objdir" + + # Determine the type of output + case $output in + "") + func_fatal_help "you must specify an output file" + ;; + *.$libext) linkmode=oldlib ;; + *.lo | *.$objext) linkmode=obj ;; + *.la) linkmode=lib ;; + *) linkmode=prog ;; # Anything else should be a program. + esac + + specialdeplibs= + + libs= + # Find all interdependent deplibs by searching for libraries + # that are linked more than once (e.g. -la -lb -la) + for deplib in $deplibs; do + if $opt_preserve_dup_deps ; then + case "$libs " in + *" $deplib "*) func_append specialdeplibs " $deplib" ;; + esac + fi + func_append libs " $deplib" + done + + if test "$linkmode" = lib; then + libs="$predeps $libs $compiler_lib_search_path $postdeps" + + # Compute libraries that are listed more than once in $predeps + # $postdeps and mark them as special (i.e., whose duplicates are + # not to be eliminated). + pre_post_deps= + if $opt_duplicate_compiler_generated_deps; then + for pre_post_dep in $predeps $postdeps; do + case "$pre_post_deps " in + *" $pre_post_dep "*) func_append specialdeplibs " $pre_post_deps" ;; + esac + func_append pre_post_deps " $pre_post_dep" + done + fi + pre_post_deps= + fi + + deplibs= + newdependency_libs= + newlib_search_path= + need_relink=no # whether we're linking any uninstalled libtool libraries + notinst_deplibs= # not-installed libtool libraries + notinst_path= # paths that contain not-installed libtool libraries + + case $linkmode in + lib) + passes="conv dlpreopen link" + for file in $dlfiles $dlprefiles; do + case $file in + *.la) ;; + *) + func_fatal_help "libraries can \`-dlopen' only libtool libraries: $file" + ;; + esac + done + ;; + prog) + compile_deplibs= + finalize_deplibs= + alldeplibs=no + newdlfiles= + newdlprefiles= + passes="conv scan dlopen dlpreopen link" + ;; + *) passes="conv" + ;; + esac + + for pass in $passes; do + # The preopen pass in lib mode reverses $deplibs; put it back here + # so that -L comes before libs that need it for instance... + if test "$linkmode,$pass" = "lib,link"; then + ## FIXME: Find the place where the list is rebuilt in the wrong + ## order, and fix it there properly + tmp_deplibs= + for deplib in $deplibs; do + tmp_deplibs="$deplib $tmp_deplibs" + done + deplibs="$tmp_deplibs" + fi + + if test "$linkmode,$pass" = "lib,link" || + test "$linkmode,$pass" = "prog,scan"; then + libs="$deplibs" + deplibs= + fi + if test "$linkmode" = prog; then + case $pass in + dlopen) libs="$dlfiles" ;; + dlpreopen) libs="$dlprefiles" ;; + link) + libs="$deplibs %DEPLIBS%" + test "X$link_all_deplibs" != Xno && libs="$libs $dependency_libs" + ;; + esac + fi + if test "$linkmode,$pass" = "lib,dlpreopen"; then + # Collect and forward deplibs of preopened libtool libs + for lib in $dlprefiles; do + # Ignore non-libtool-libs + dependency_libs= + func_resolve_sysroot "$lib" + case $lib in + *.la) func_source "$func_resolve_sysroot_result" ;; + esac + + # Collect preopened libtool deplibs, except any this library + # has declared as weak libs + for deplib in $dependency_libs; do + func_basename "$deplib" + deplib_base=$func_basename_result + case " $weak_libs " in + *" $deplib_base "*) ;; + *) func_append deplibs " $deplib" ;; + esac + done + done + libs="$dlprefiles" + fi + if test "$pass" = dlopen; then + # Collect dlpreopened libraries + save_deplibs="$deplibs" + deplibs= + fi + + for deplib in $libs; do + lib= + found=no + case $deplib in + -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe \ + |-threads|-fopenmp|-openmp|-mp|-xopenmp|-omp|-qsmp=*) + if test "$linkmode,$pass" = "prog,link"; then + compile_deplibs="$deplib $compile_deplibs" + finalize_deplibs="$deplib $finalize_deplibs" + else + func_append compiler_flags " $deplib" + if test "$linkmode" = lib ; then + case "$new_inherited_linker_flags " in + *" $deplib "*) ;; + * ) func_append new_inherited_linker_flags " $deplib" ;; + esac + fi + fi + continue + ;; + -l*) + if test "$linkmode" != lib && test "$linkmode" != prog; then + func_warning "\`-l' is ignored for archives/objects" + continue + fi + func_stripname '-l' '' "$deplib" + name=$func_stripname_result + if test "$linkmode" = lib; then + searchdirs="$newlib_search_path $lib_search_path $compiler_lib_search_dirs $sys_lib_search_path $shlib_search_path" + else + searchdirs="$newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path" + fi + for searchdir in $searchdirs; do + for search_ext in .la $std_shrext .so .a; do + # Search the libtool library + lib="$searchdir/lib${name}${search_ext}" + if test -f "$lib"; then + if test "$search_ext" = ".la"; then + found=yes + else + found=no + fi + break 2 + fi + done + done + if test "$found" != yes; then + # deplib doesn't seem to be a libtool library + if test "$linkmode,$pass" = "prog,link"; then + compile_deplibs="$deplib $compile_deplibs" + finalize_deplibs="$deplib $finalize_deplibs" + else + deplibs="$deplib $deplibs" + test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs" + fi + continue + else # deplib is a libtool library + # If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib, + # We need to do some special things here, and not later. + if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then + case " $predeps $postdeps " in + *" $deplib "*) + if func_lalib_p "$lib"; then + library_names= + old_library= + func_source "$lib" + for l in $old_library $library_names; do + ll="$l" + done + if test "X$ll" = "X$old_library" ; then # only static version available + found=no + func_dirname "$lib" "" "." + ladir="$func_dirname_result" + lib=$ladir/$old_library + if test "$linkmode,$pass" = "prog,link"; then + compile_deplibs="$deplib $compile_deplibs" + finalize_deplibs="$deplib $finalize_deplibs" + else + deplibs="$deplib $deplibs" + test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs" + fi + continue + fi + fi + ;; + *) ;; + esac + fi + fi + ;; # -l + *.ltframework) + if test "$linkmode,$pass" = "prog,link"; then + compile_deplibs="$deplib $compile_deplibs" + finalize_deplibs="$deplib $finalize_deplibs" + else + deplibs="$deplib $deplibs" + if test "$linkmode" = lib ; then + case "$new_inherited_linker_flags " in + *" $deplib "*) ;; + * ) func_append new_inherited_linker_flags " $deplib" ;; + esac + fi + fi + continue + ;; + -L*) + case $linkmode in + lib) + deplibs="$deplib $deplibs" + test "$pass" = conv && continue + newdependency_libs="$deplib $newdependency_libs" + func_stripname '-L' '' "$deplib" + func_resolve_sysroot "$func_stripname_result" + func_append newlib_search_path " $func_resolve_sysroot_result" + ;; + prog) + if test "$pass" = conv; then + deplibs="$deplib $deplibs" + continue + fi + if test "$pass" = scan; then + deplibs="$deplib $deplibs" + else + compile_deplibs="$deplib $compile_deplibs" + finalize_deplibs="$deplib $finalize_deplibs" + fi + func_stripname '-L' '' "$deplib" + func_resolve_sysroot "$func_stripname_result" + func_append newlib_search_path " $func_resolve_sysroot_result" + ;; + *) + func_warning "\`-L' is ignored for archives/objects" + ;; + esac # linkmode + continue + ;; # -L + -R*) + if test "$pass" = link; then + func_stripname '-R' '' "$deplib" + func_resolve_sysroot "$func_stripname_result" + dir=$func_resolve_sysroot_result + # Make sure the xrpath contains only unique directories. + case "$xrpath " in + *" $dir "*) ;; + *) func_append xrpath " $dir" ;; + esac + fi + deplibs="$deplib $deplibs" + continue + ;; + *.la) + func_resolve_sysroot "$deplib" + lib=$func_resolve_sysroot_result + ;; + *.$libext) + if test "$pass" = conv; then + deplibs="$deplib $deplibs" + continue + fi + case $linkmode in + lib) + # Linking convenience modules into shared libraries is allowed, + # but linking other static libraries is non-portable. + case " $dlpreconveniencelibs " in + *" $deplib "*) ;; + *) + valid_a_lib=no + case $deplibs_check_method in + match_pattern*) + set dummy $deplibs_check_method; shift + match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"` + if eval "\$ECHO \"$deplib\"" 2>/dev/null | $SED 10q \ + | $EGREP "$match_pattern_regex" > /dev/null; then + valid_a_lib=yes + fi + ;; + pass_all) + valid_a_lib=yes + ;; + esac + if test "$valid_a_lib" != yes; then + echo + $ECHO "*** Warning: Trying to link with static lib archive $deplib." + echo "*** I have the capability to make that library automatically link in when" + echo "*** you link to this library. But I can only do this if you have a" + echo "*** shared version of the library, which you do not appear to have" + echo "*** because the file extensions .$libext of this argument makes me believe" + echo "*** that it is just a static archive that I should not use here." + else + echo + $ECHO "*** Warning: Linking the shared library $output against the" + $ECHO "*** static library $deplib is not portable!" + deplibs="$deplib $deplibs" + fi + ;; + esac + continue + ;; + prog) + if test "$pass" != link; then + deplibs="$deplib $deplibs" + else + compile_deplibs="$deplib $compile_deplibs" + finalize_deplibs="$deplib $finalize_deplibs" + fi + continue + ;; + esac # linkmode + ;; # *.$libext + *.lo | *.$objext) + if test "$pass" = conv; then + deplibs="$deplib $deplibs" + elif test "$linkmode" = prog; then + if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then + # If there is no dlopen support or we're linking statically, + # we need to preload. + func_append newdlprefiles " $deplib" + compile_deplibs="$deplib $compile_deplibs" + finalize_deplibs="$deplib $finalize_deplibs" + else + func_append newdlfiles " $deplib" + fi + fi + continue + ;; + %DEPLIBS%) + alldeplibs=yes + continue + ;; + esac # case $deplib + + if test "$found" = yes || test -f "$lib"; then : + else + func_fatal_error "cannot find the library \`$lib' or unhandled argument \`$deplib'" + fi + + # Check to see that this really is a libtool archive. + func_lalib_unsafe_p "$lib" \ + || func_fatal_error "\`$lib' is not a valid libtool archive" + + func_dirname "$lib" "" "." + ladir="$func_dirname_result" + + dlname= + dlopen= + dlpreopen= + libdir= + library_names= + old_library= + inherited_linker_flags= + # If the library was installed with an old release of libtool, + # it will not redefine variables installed, or shouldnotlink + installed=yes + shouldnotlink=no + avoidtemprpath= + + + # Read the .la file + func_source "$lib" + + # Convert "-framework foo" to "foo.ltframework" + if test -n "$inherited_linker_flags"; then + tmp_inherited_linker_flags=`$ECHO "$inherited_linker_flags" | $SED 's/-framework \([^ $]*\)/\1.ltframework/g'` + for tmp_inherited_linker_flag in $tmp_inherited_linker_flags; do + case " $new_inherited_linker_flags " in + *" $tmp_inherited_linker_flag "*) ;; + *) func_append new_inherited_linker_flags " $tmp_inherited_linker_flag";; + esac + done + fi + dependency_libs=`$ECHO " $dependency_libs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'` + if test "$linkmode,$pass" = "lib,link" || + test "$linkmode,$pass" = "prog,scan" || + { test "$linkmode" != prog && test "$linkmode" != lib; }; then + test -n "$dlopen" && func_append dlfiles " $dlopen" + test -n "$dlpreopen" && func_append dlprefiles " $dlpreopen" + fi + + if test "$pass" = conv; then + # Only check for convenience libraries + deplibs="$lib $deplibs" + if test -z "$libdir"; then + if test -z "$old_library"; then + func_fatal_error "cannot find name of link library for \`$lib'" + fi + # It is a libtool convenience library, so add in its objects. + func_append convenience " $ladir/$objdir/$old_library" + func_append old_convenience " $ladir/$objdir/$old_library" + tmp_libs= + for deplib in $dependency_libs; do + deplibs="$deplib $deplibs" + if $opt_preserve_dup_deps ; then + case "$tmp_libs " in + *" $deplib "*) func_append specialdeplibs " $deplib" ;; + esac + fi + func_append tmp_libs " $deplib" + done + elif test "$linkmode" != prog && test "$linkmode" != lib; then + func_fatal_error "\`$lib' is not a convenience library" + fi + continue + fi # $pass = conv + + + # Get the name of the library we link against. + linklib= + if test -n "$old_library" && + { test "$prefer_static_libs" = yes || + test "$prefer_static_libs,$installed" = "built,no"; }; then + linklib=$old_library + else + for l in $old_library $library_names; do + linklib="$l" + done + fi + if test -z "$linklib"; then + func_fatal_error "cannot find name of link library for \`$lib'" + fi + + # This library was specified with -dlopen. + if test "$pass" = dlopen; then + if test -z "$libdir"; then + func_fatal_error "cannot -dlopen a convenience library: \`$lib'" + fi + if test -z "$dlname" || + test "$dlopen_support" != yes || + test "$build_libtool_libs" = no; then + # If there is no dlname, no dlopen support or we're linking + # statically, we need to preload. We also need to preload any + # dependent libraries so libltdl's deplib preloader doesn't + # bomb out in the load deplibs phase. + func_append dlprefiles " $lib $dependency_libs" + else + func_append newdlfiles " $lib" + fi + continue + fi # $pass = dlopen + + # We need an absolute path. + case $ladir in + [\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;; + *) + abs_ladir=`cd "$ladir" && pwd` + if test -z "$abs_ladir"; then + func_warning "cannot determine absolute directory name of \`$ladir'" + func_warning "passing it literally to the linker, although it might fail" + abs_ladir="$ladir" + fi + ;; + esac + func_basename "$lib" + laname="$func_basename_result" + + # Find the relevant object directory and library name. + if test "X$installed" = Xyes; then + if test ! -f "$lt_sysroot$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then + func_warning "library \`$lib' was moved." + dir="$ladir" + absdir="$abs_ladir" + libdir="$abs_ladir" + else + dir="$lt_sysroot$libdir" + absdir="$lt_sysroot$libdir" + fi + test "X$hardcode_automatic" = Xyes && avoidtemprpath=yes + else + if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then + dir="$ladir" + absdir="$abs_ladir" + # Remove this search path later + func_append notinst_path " $abs_ladir" + else + dir="$ladir/$objdir" + absdir="$abs_ladir/$objdir" + # Remove this search path later + func_append notinst_path " $abs_ladir" + fi + fi # $installed = yes + func_stripname 'lib' '.la' "$laname" + name=$func_stripname_result + + # This library was specified with -dlpreopen. + if test "$pass" = dlpreopen; then + if test -z "$libdir" && test "$linkmode" = prog; then + func_fatal_error "only libraries may -dlpreopen a convenience library: \`$lib'" + fi + case "$host" in + # special handling for platforms with PE-DLLs. + *cygwin* | *mingw* | *cegcc* ) + # Linker will automatically link against shared library if both + # static and shared are present. Therefore, ensure we extract + # symbols from the import library if a shared library is present + # (otherwise, the dlopen module name will be incorrect). We do + # this by putting the import library name into $newdlprefiles. + # We recover the dlopen module name by 'saving' the la file + # name in a special purpose variable, and (later) extracting the + # dlname from the la file. + if test -n "$dlname"; then + func_tr_sh "$dir/$linklib" + eval "libfile_$func_tr_sh_result=\$abs_ladir/\$laname" + func_append newdlprefiles " $dir/$linklib" + else + func_append newdlprefiles " $dir/$old_library" + # Keep a list of preopened convenience libraries to check + # that they are being used correctly in the link pass. + test -z "$libdir" && \ + func_append dlpreconveniencelibs " $dir/$old_library" + fi + ;; + * ) + # Prefer using a static library (so that no silly _DYNAMIC symbols + # are required to link). + if test -n "$old_library"; then + func_append newdlprefiles " $dir/$old_library" + # Keep a list of preopened convenience libraries to check + # that they are being used correctly in the link pass. + test -z "$libdir" && \ + func_append dlpreconveniencelibs " $dir/$old_library" + # Otherwise, use the dlname, so that lt_dlopen finds it. + elif test -n "$dlname"; then + func_append newdlprefiles " $dir/$dlname" + else + func_append newdlprefiles " $dir/$linklib" + fi + ;; + esac + fi # $pass = dlpreopen + + if test -z "$libdir"; then + # Link the convenience library + if test "$linkmode" = lib; then + deplibs="$dir/$old_library $deplibs" + elif test "$linkmode,$pass" = "prog,link"; then + compile_deplibs="$dir/$old_library $compile_deplibs" + finalize_deplibs="$dir/$old_library $finalize_deplibs" + else + deplibs="$lib $deplibs" # used for prog,scan pass + fi + continue + fi + + + if test "$linkmode" = prog && test "$pass" != link; then + func_append newlib_search_path " $ladir" + deplibs="$lib $deplibs" + + linkalldeplibs=no + if test "$link_all_deplibs" != no || test -z "$library_names" || + test "$build_libtool_libs" = no; then + linkalldeplibs=yes + fi + + tmp_libs= + for deplib in $dependency_libs; do + case $deplib in + -L*) func_stripname '-L' '' "$deplib" + func_resolve_sysroot "$func_stripname_result" + func_append newlib_search_path " $func_resolve_sysroot_result" + ;; + esac + # Need to link against all dependency_libs? + if test "$linkalldeplibs" = yes; then + deplibs="$deplib $deplibs" + else + # Need to hardcode shared library paths + # or/and link against static libraries + newdependency_libs="$deplib $newdependency_libs" + fi + if $opt_preserve_dup_deps ; then + case "$tmp_libs " in + *" $deplib "*) func_append specialdeplibs " $deplib" ;; + esac + fi + func_append tmp_libs " $deplib" + done # for deplib + continue + fi # $linkmode = prog... + + if test "$linkmode,$pass" = "prog,link"; then + if test -n "$library_names" && + { { test "$prefer_static_libs" = no || + test "$prefer_static_libs,$installed" = "built,yes"; } || + test -z "$old_library"; }; then + # We need to hardcode the library path + if test -n "$shlibpath_var" && test -z "$avoidtemprpath" ; then + # Make sure the rpath contains only unique directories. + case "$temp_rpath:" in + *"$absdir:"*) ;; + *) func_append temp_rpath "$absdir:" ;; + esac + fi + + # Hardcode the library path. + # Skip directories that are in the system default run-time + # search path. + case " $sys_lib_dlsearch_path " in + *" $absdir "*) ;; + *) + case "$compile_rpath " in + *" $absdir "*) ;; + *) func_append compile_rpath " $absdir" ;; + esac + ;; + esac + case " $sys_lib_dlsearch_path " in + *" $libdir "*) ;; + *) + case "$finalize_rpath " in + *" $libdir "*) ;; + *) func_append finalize_rpath " $libdir" ;; + esac + ;; + esac + fi # $linkmode,$pass = prog,link... + + if test "$alldeplibs" = yes && + { test "$deplibs_check_method" = pass_all || + { test "$build_libtool_libs" = yes && + test -n "$library_names"; }; }; then + # We only need to search for static libraries + continue + fi + fi + + link_static=no # Whether the deplib will be linked statically + use_static_libs=$prefer_static_libs + if test "$use_static_libs" = built && test "$installed" = yes; then + use_static_libs=no + fi + if test -n "$library_names" && + { test "$use_static_libs" = no || test -z "$old_library"; }; then + case $host in + *cygwin* | *mingw* | *cegcc*) + # No point in relinking DLLs because paths are not encoded + func_append notinst_deplibs " $lib" + need_relink=no + ;; + *) + if test "$installed" = no; then + func_append notinst_deplibs " $lib" + need_relink=yes + fi + ;; + esac + # This is a shared library + + # Warn about portability, can't link against -module's on some + # systems (darwin). Don't bleat about dlopened modules though! + dlopenmodule="" + for dlpremoduletest in $dlprefiles; do + if test "X$dlpremoduletest" = "X$lib"; then + dlopenmodule="$dlpremoduletest" + break + fi + done + if test -z "$dlopenmodule" && test "$shouldnotlink" = yes && test "$pass" = link; then + echo + if test "$linkmode" = prog; then + $ECHO "*** Warning: Linking the executable $output against the loadable module" + else + $ECHO "*** Warning: Linking the shared library $output against the loadable module" + fi + $ECHO "*** $linklib is not portable!" + fi + if test "$linkmode" = lib && + test "$hardcode_into_libs" = yes; then + # Hardcode the library path. + # Skip directories that are in the system default run-time + # search path. + case " $sys_lib_dlsearch_path " in + *" $absdir "*) ;; + *) + case "$compile_rpath " in + *" $absdir "*) ;; + *) func_append compile_rpath " $absdir" ;; + esac + ;; + esac + case " $sys_lib_dlsearch_path " in + *" $libdir "*) ;; + *) + case "$finalize_rpath " in + *" $libdir "*) ;; + *) func_append finalize_rpath " $libdir" ;; + esac + ;; + esac + fi + + if test -n "$old_archive_from_expsyms_cmds"; then + # figure out the soname + set dummy $library_names + shift + realname="$1" + shift + libname=`eval "\\$ECHO \"$libname_spec\""` + # use dlname if we got it. it's perfectly good, no? + if test -n "$dlname"; then + soname="$dlname" + elif test -n "$soname_spec"; then + # bleh windows + case $host in + *cygwin* | mingw* | *cegcc*) + func_arith $current - $age + major=$func_arith_result + versuffix="-$major" + ;; + esac + eval soname=\"$soname_spec\" + else + soname="$realname" + fi + + # Make a new name for the extract_expsyms_cmds to use + soroot="$soname" + func_basename "$soroot" + soname="$func_basename_result" + func_stripname 'lib' '.dll' "$soname" + newlib=libimp-$func_stripname_result.a + + # If the library has no export list, then create one now + if test -f "$output_objdir/$soname-def"; then : + else + func_verbose "extracting exported symbol list from \`$soname'" + func_execute_cmds "$extract_expsyms_cmds" 'exit $?' + fi + + # Create $newlib + if test -f "$output_objdir/$newlib"; then :; else + func_verbose "generating import library for \`$soname'" + func_execute_cmds "$old_archive_from_expsyms_cmds" 'exit $?' + fi + # make sure the library variables are pointing to the new library + dir=$output_objdir + linklib=$newlib + fi # test -n "$old_archive_from_expsyms_cmds" + + if test "$linkmode" = prog || test "$opt_mode" != relink; then + add_shlibpath= + add_dir= + add= + lib_linked=yes + case $hardcode_action in + immediate | unsupported) + if test "$hardcode_direct" = no; then + add="$dir/$linklib" + case $host in + *-*-sco3.2v5.0.[024]*) add_dir="-L$dir" ;; + *-*-sysv4*uw2*) add_dir="-L$dir" ;; + *-*-sysv5OpenUNIX* | *-*-sysv5UnixWare7.[01].[10]* | \ + *-*-unixware7*) add_dir="-L$dir" ;; + *-*-darwin* ) + # if the lib is a (non-dlopened) module then we can not + # link against it, someone is ignoring the earlier warnings + if /usr/bin/file -L $add 2> /dev/null | + $GREP ": [^:]* bundle" >/dev/null ; then + if test "X$dlopenmodule" != "X$lib"; then + $ECHO "*** Warning: lib $linklib is a module, not a shared library" + if test -z "$old_library" ; then + echo + echo "*** And there doesn't seem to be a static archive available" + echo "*** The link will probably fail, sorry" + else + add="$dir/$old_library" + fi + elif test -n "$old_library"; then + add="$dir/$old_library" + fi + fi + esac + elif test "$hardcode_minus_L" = no; then + case $host in + *-*-sunos*) add_shlibpath="$dir" ;; + esac + add_dir="-L$dir" + add="-l$name" + elif test "$hardcode_shlibpath_var" = no; then + add_shlibpath="$dir" + add="-l$name" + else + lib_linked=no + fi + ;; + relink) + if test "$hardcode_direct" = yes && + test "$hardcode_direct_absolute" = no; then + add="$dir/$linklib" + elif test "$hardcode_minus_L" = yes; then + add_dir="-L$absdir" + # Try looking first in the location we're being installed to. + if test -n "$inst_prefix_dir"; then + case $libdir in + [\\/]*) + func_append add_dir " -L$inst_prefix_dir$libdir" + ;; + esac + fi + add="-l$name" + elif test "$hardcode_shlibpath_var" = yes; then + add_shlibpath="$dir" + add="-l$name" + else + lib_linked=no + fi + ;; + *) lib_linked=no ;; + esac + + if test "$lib_linked" != yes; then + func_fatal_configuration "unsupported hardcode properties" + fi + + if test -n "$add_shlibpath"; then + case :$compile_shlibpath: in + *":$add_shlibpath:"*) ;; + *) func_append compile_shlibpath "$add_shlibpath:" ;; + esac + fi + if test "$linkmode" = prog; then + test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs" + test -n "$add" && compile_deplibs="$add $compile_deplibs" + else + test -n "$add_dir" && deplibs="$add_dir $deplibs" + test -n "$add" && deplibs="$add $deplibs" + if test "$hardcode_direct" != yes && + test "$hardcode_minus_L" != yes && + test "$hardcode_shlibpath_var" = yes; then + case :$finalize_shlibpath: in + *":$libdir:"*) ;; + *) func_append finalize_shlibpath "$libdir:" ;; + esac + fi + fi + fi + + if test "$linkmode" = prog || test "$opt_mode" = relink; then + add_shlibpath= + add_dir= + add= + # Finalize command for both is simple: just hardcode it. + if test "$hardcode_direct" = yes && + test "$hardcode_direct_absolute" = no; then + add="$libdir/$linklib" + elif test "$hardcode_minus_L" = yes; then + add_dir="-L$libdir" + add="-l$name" + elif test "$hardcode_shlibpath_var" = yes; then + case :$finalize_shlibpath: in + *":$libdir:"*) ;; + *) func_append finalize_shlibpath "$libdir:" ;; + esac + add="-l$name" + elif test "$hardcode_automatic" = yes; then + if test -n "$inst_prefix_dir" && + test -f "$inst_prefix_dir$libdir/$linklib" ; then + add="$inst_prefix_dir$libdir/$linklib" + else + add="$libdir/$linklib" + fi + else + # We cannot seem to hardcode it, guess we'll fake it. + add_dir="-L$libdir" + # Try looking first in the location we're being installed to. + if test -n "$inst_prefix_dir"; then + case $libdir in + [\\/]*) + func_append add_dir " -L$inst_prefix_dir$libdir" + ;; + esac + fi + add="-l$name" + fi + + if test "$linkmode" = prog; then + test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs" + test -n "$add" && finalize_deplibs="$add $finalize_deplibs" + else + test -n "$add_dir" && deplibs="$add_dir $deplibs" + test -n "$add" && deplibs="$add $deplibs" + fi + fi + elif test "$linkmode" = prog; then + # Here we assume that one of hardcode_direct or hardcode_minus_L + # is not unsupported. This is valid on all known static and + # shared platforms. + if test "$hardcode_direct" != unsupported; then + test -n "$old_library" && linklib="$old_library" + compile_deplibs="$dir/$linklib $compile_deplibs" + finalize_deplibs="$dir/$linklib $finalize_deplibs" + else + compile_deplibs="-l$name -L$dir $compile_deplibs" + finalize_deplibs="-l$name -L$dir $finalize_deplibs" + fi + elif test "$build_libtool_libs" = yes; then + # Not a shared library + if test "$deplibs_check_method" != pass_all; then + # We're trying link a shared library against a static one + # but the system doesn't support it. + + # Just print a warning and add the library to dependency_libs so + # that the program can be linked against the static library. + echo + $ECHO "*** Warning: This system can not link to static lib archive $lib." + echo "*** I have the capability to make that library automatically link in when" + echo "*** you link to this library. But I can only do this if you have a" + echo "*** shared version of the library, which you do not appear to have." + if test "$module" = yes; then + echo "*** But as you try to build a module library, libtool will still create " + echo "*** a static module, that should work as long as the dlopening application" + echo "*** is linked with the -dlopen flag to resolve symbols at runtime." + if test -z "$global_symbol_pipe"; then + echo + echo "*** However, this would only work if libtool was able to extract symbol" + echo "*** lists from a program, using \`nm' or equivalent, but libtool could" + echo "*** not find such a program. So, this module is probably useless." + echo "*** \`nm' from GNU binutils and a full rebuild may help." + fi + if test "$build_old_libs" = no; then + build_libtool_libs=module + build_old_libs=yes + else + build_libtool_libs=no + fi + fi + else + deplibs="$dir/$old_library $deplibs" + link_static=yes + fi + fi # link shared/static library? + + if test "$linkmode" = lib; then + if test -n "$dependency_libs" && + { test "$hardcode_into_libs" != yes || + test "$build_old_libs" = yes || + test "$link_static" = yes; }; then + # Extract -R from dependency_libs + temp_deplibs= + for libdir in $dependency_libs; do + case $libdir in + -R*) func_stripname '-R' '' "$libdir" + temp_xrpath=$func_stripname_result + case " $xrpath " in + *" $temp_xrpath "*) ;; + *) func_append xrpath " $temp_xrpath";; + esac;; + *) func_append temp_deplibs " $libdir";; + esac + done + dependency_libs="$temp_deplibs" + fi + + func_append newlib_search_path " $absdir" + # Link against this library + test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs" + # ... and its dependency_libs + tmp_libs= + for deplib in $dependency_libs; do + newdependency_libs="$deplib $newdependency_libs" + case $deplib in + -L*) func_stripname '-L' '' "$deplib" + func_resolve_sysroot "$func_stripname_result";; + *) func_resolve_sysroot "$deplib" ;; + esac + if $opt_preserve_dup_deps ; then + case "$tmp_libs " in + *" $func_resolve_sysroot_result "*) + func_append specialdeplibs " $func_resolve_sysroot_result" ;; + esac + fi + func_append tmp_libs " $func_resolve_sysroot_result" + done + + if test "$link_all_deplibs" != no; then + # Add the search paths of all dependency libraries + for deplib in $dependency_libs; do + path= + case $deplib in + -L*) path="$deplib" ;; + *.la) + func_resolve_sysroot "$deplib" + deplib=$func_resolve_sysroot_result + func_dirname "$deplib" "" "." + dir=$func_dirname_result + # We need an absolute path. + case $dir in + [\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;; + *) + absdir=`cd "$dir" && pwd` + if test -z "$absdir"; then + func_warning "cannot determine absolute directory name of \`$dir'" + absdir="$dir" + fi + ;; + esac + if $GREP "^installed=no" $deplib > /dev/null; then + case $host in + *-*-darwin*) + depdepl= + eval deplibrary_names=`${SED} -n -e 's/^library_names=\(.*\)$/\1/p' $deplib` + if test -n "$deplibrary_names" ; then + for tmp in $deplibrary_names ; do + depdepl=$tmp + done + if test -f "$absdir/$objdir/$depdepl" ; then + depdepl="$absdir/$objdir/$depdepl" + darwin_install_name=`${OTOOL} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'` + if test -z "$darwin_install_name"; then + darwin_install_name=`${OTOOL64} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'` + fi + func_append compiler_flags " ${wl}-dylib_file ${wl}${darwin_install_name}:${depdepl}" + func_append linker_flags " -dylib_file ${darwin_install_name}:${depdepl}" + path= + fi + fi + ;; + *) + path="-L$absdir/$objdir" + ;; + esac + else + eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib` + test -z "$libdir" && \ + func_fatal_error "\`$deplib' is not a valid libtool archive" + test "$absdir" != "$libdir" && \ + func_warning "\`$deplib' seems to be moved" + + path="-L$absdir" + fi + ;; + esac + case " $deplibs " in + *" $path "*) ;; + *) deplibs="$path $deplibs" ;; + esac + done + fi # link_all_deplibs != no + fi # linkmode = lib + done # for deplib in $libs + if test "$pass" = link; then + if test "$linkmode" = "prog"; then + compile_deplibs="$new_inherited_linker_flags $compile_deplibs" + finalize_deplibs="$new_inherited_linker_flags $finalize_deplibs" + else + compiler_flags="$compiler_flags "`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'` + fi + fi + dependency_libs="$newdependency_libs" + if test "$pass" = dlpreopen; then + # Link the dlpreopened libraries before other libraries + for deplib in $save_deplibs; do + deplibs="$deplib $deplibs" + done + fi + if test "$pass" != dlopen; then + if test "$pass" != conv; then + # Make sure lib_search_path contains only unique directories. + lib_search_path= + for dir in $newlib_search_path; do + case "$lib_search_path " in + *" $dir "*) ;; + *) func_append lib_search_path " $dir" ;; + esac + done + newlib_search_path= + fi + + if test "$linkmode,$pass" != "prog,link"; then + vars="deplibs" + else + vars="compile_deplibs finalize_deplibs" + fi + for var in $vars dependency_libs; do + # Add libraries to $var in reverse order + eval tmp_libs=\"\$$var\" + new_libs= + for deplib in $tmp_libs; do + # FIXME: Pedantically, this is the right thing to do, so + # that some nasty dependency loop isn't accidentally + # broken: + #new_libs="$deplib $new_libs" + # Pragmatically, this seems to cause very few problems in + # practice: + case $deplib in + -L*) new_libs="$deplib $new_libs" ;; + -R*) ;; + *) + # And here is the reason: when a library appears more + # than once as an explicit dependence of a library, or + # is implicitly linked in more than once by the + # compiler, it is considered special, and multiple + # occurrences thereof are not removed. Compare this + # with having the same library being listed as a + # dependency of multiple other libraries: in this case, + # we know (pedantically, we assume) the library does not + # need to be listed more than once, so we keep only the + # last copy. This is not always right, but it is rare + # enough that we require users that really mean to play + # such unportable linking tricks to link the library + # using -Wl,-lname, so that libtool does not consider it + # for duplicate removal. + case " $specialdeplibs " in + *" $deplib "*) new_libs="$deplib $new_libs" ;; + *) + case " $new_libs " in + *" $deplib "*) ;; + *) new_libs="$deplib $new_libs" ;; + esac + ;; + esac + ;; + esac + done + tmp_libs= + for deplib in $new_libs; do + case $deplib in + -L*) + case " $tmp_libs " in + *" $deplib "*) ;; + *) func_append tmp_libs " $deplib" ;; + esac + ;; + *) func_append tmp_libs " $deplib" ;; + esac + done + eval $var=\"$tmp_libs\" + done # for var + fi + # Last step: remove runtime libs from dependency_libs + # (they stay in deplibs) + tmp_libs= + for i in $dependency_libs ; do + case " $predeps $postdeps $compiler_lib_search_path " in + *" $i "*) + i="" + ;; + esac + if test -n "$i" ; then + func_append tmp_libs " $i" + fi + done + dependency_libs=$tmp_libs + done # for pass + if test "$linkmode" = prog; then + dlfiles="$newdlfiles" + fi + if test "$linkmode" = prog || test "$linkmode" = lib; then + dlprefiles="$newdlprefiles" + fi + + case $linkmode in + oldlib) + if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then + func_warning "\`-dlopen' is ignored for archives" + fi + + case " $deplibs" in + *\ -l* | *\ -L*) + func_warning "\`-l' and \`-L' are ignored for archives" ;; + esac + + test -n "$rpath" && \ + func_warning "\`-rpath' is ignored for archives" + + test -n "$xrpath" && \ + func_warning "\`-R' is ignored for archives" + + test -n "$vinfo" && \ + func_warning "\`-version-info/-version-number' is ignored for archives" + + test -n "$release" && \ + func_warning "\`-release' is ignored for archives" + + test -n "$export_symbols$export_symbols_regex" && \ + func_warning "\`-export-symbols' is ignored for archives" + + # Now set the variables for building old libraries. + build_libtool_libs=no + oldlibs="$output" + func_append objs "$old_deplibs" + ;; + + lib) + # Make sure we only generate libraries of the form `libNAME.la'. + case $outputname in + lib*) + func_stripname 'lib' '.la' "$outputname" + name=$func_stripname_result + eval shared_ext=\"$shrext_cmds\" + eval libname=\"$libname_spec\" + ;; + *) + test "$module" = no && \ + func_fatal_help "libtool library \`$output' must begin with \`lib'" + + if test "$need_lib_prefix" != no; then + # Add the "lib" prefix for modules if required + func_stripname '' '.la' "$outputname" + name=$func_stripname_result + eval shared_ext=\"$shrext_cmds\" + eval libname=\"$libname_spec\" + else + func_stripname '' '.la' "$outputname" + libname=$func_stripname_result + fi + ;; + esac + + if test -n "$objs"; then + if test "$deplibs_check_method" != pass_all; then + func_fatal_error "cannot build libtool library \`$output' from non-libtool objects on this host:$objs" + else + echo + $ECHO "*** Warning: Linking the shared library $output against the non-libtool" + $ECHO "*** objects $objs is not portable!" + func_append libobjs " $objs" + fi + fi + + test "$dlself" != no && \ + func_warning "\`-dlopen self' is ignored for libtool libraries" + + set dummy $rpath + shift + test "$#" -gt 1 && \ + func_warning "ignoring multiple \`-rpath's for a libtool library" + + install_libdir="$1" + + oldlibs= + if test -z "$rpath"; then + if test "$build_libtool_libs" = yes; then + # Building a libtool convenience library. + # Some compilers have problems with a `.al' extension so + # convenience libraries should have the same extension an + # archive normally would. + oldlibs="$output_objdir/$libname.$libext $oldlibs" + build_libtool_libs=convenience + build_old_libs=yes + fi + + test -n "$vinfo" && \ + func_warning "\`-version-info/-version-number' is ignored for convenience libraries" + + test -n "$release" && \ + func_warning "\`-release' is ignored for convenience libraries" + else + + # Parse the version information argument. + save_ifs="$IFS"; IFS=':' + set dummy $vinfo 0 0 0 + shift + IFS="$save_ifs" + + test -n "$7" && \ + func_fatal_help "too many parameters to \`-version-info'" + + # convert absolute version numbers to libtool ages + # this retains compatibility with .la files and attempts + # to make the code below a bit more comprehensible + + case $vinfo_number in + yes) + number_major="$1" + number_minor="$2" + number_revision="$3" + # + # There are really only two kinds -- those that + # use the current revision as the major version + # and those that subtract age and use age as + # a minor version. But, then there is irix + # which has an extra 1 added just for fun + # + case $version_type in + # correct linux to gnu/linux during the next big refactor + darwin|linux|osf|windows|none) + func_arith $number_major + $number_minor + current=$func_arith_result + age="$number_minor" + revision="$number_revision" + ;; + freebsd-aout|freebsd-elf|qnx|sunos) + current="$number_major" + revision="$number_minor" + age="0" + ;; + irix|nonstopux) + func_arith $number_major + $number_minor + current=$func_arith_result + age="$number_minor" + revision="$number_minor" + lt_irix_increment=no + ;; + *) + func_fatal_configuration "$modename: unknown library version type \`$version_type'" + ;; + esac + ;; + no) + current="$1" + revision="$2" + age="$3" + ;; + esac + + # Check that each of the things are valid numbers. + case $current in + 0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;; + *) + func_error "CURRENT \`$current' must be a nonnegative integer" + func_fatal_error "\`$vinfo' is not valid version information" + ;; + esac + + case $revision in + 0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;; + *) + func_error "REVISION \`$revision' must be a nonnegative integer" + func_fatal_error "\`$vinfo' is not valid version information" + ;; + esac + + case $age in + 0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;; + *) + func_error "AGE \`$age' must be a nonnegative integer" + func_fatal_error "\`$vinfo' is not valid version information" + ;; + esac + + if test "$age" -gt "$current"; then + func_error "AGE \`$age' is greater than the current interface number \`$current'" + func_fatal_error "\`$vinfo' is not valid version information" + fi + + # Calculate the version variables. + major= + versuffix= + verstring= + case $version_type in + none) ;; + + darwin) + # Like Linux, but with the current version available in + # verstring for coding it into the library header + func_arith $current - $age + major=.$func_arith_result + versuffix="$major.$age.$revision" + # Darwin ld doesn't like 0 for these options... + func_arith $current + 1 + minor_current=$func_arith_result + xlcverstring="${wl}-compatibility_version ${wl}$minor_current ${wl}-current_version ${wl}$minor_current.$revision" + verstring="-compatibility_version $minor_current -current_version $minor_current.$revision" + ;; + + freebsd-aout) + major=".$current" + versuffix=".$current.$revision"; + ;; + + freebsd-elf) + major=".$current" + versuffix=".$current" + ;; + + irix | nonstopux) + if test "X$lt_irix_increment" = "Xno"; then + func_arith $current - $age + else + func_arith $current - $age + 1 + fi + major=$func_arith_result + + case $version_type in + nonstopux) verstring_prefix=nonstopux ;; + *) verstring_prefix=sgi ;; + esac + verstring="$verstring_prefix$major.$revision" + + # Add in all the interfaces that we are compatible with. + loop=$revision + while test "$loop" -ne 0; do + func_arith $revision - $loop + iface=$func_arith_result + func_arith $loop - 1 + loop=$func_arith_result + verstring="$verstring_prefix$major.$iface:$verstring" + done + + # Before this point, $major must not contain `.'. + major=.$major + versuffix="$major.$revision" + ;; + + linux) # correct to gnu/linux during the next big refactor + func_arith $current - $age + major=.$func_arith_result + versuffix="$major.$age.$revision" + ;; + + osf) + func_arith $current - $age + major=.$func_arith_result + versuffix=".$current.$age.$revision" + verstring="$current.$age.$revision" + + # Add in all the interfaces that we are compatible with. + loop=$age + while test "$loop" -ne 0; do + func_arith $current - $loop + iface=$func_arith_result + func_arith $loop - 1 + loop=$func_arith_result + verstring="$verstring:${iface}.0" + done + + # Make executables depend on our current version. + func_append verstring ":${current}.0" + ;; + + qnx) + major=".$current" + versuffix=".$current" + ;; + + sunos) + major=".$current" + versuffix=".$current.$revision" + ;; + + windows) + # Use '-' rather than '.', since we only want one + # extension on DOS 8.3 filesystems. + func_arith $current - $age + major=$func_arith_result + versuffix="-$major" + ;; + + *) + func_fatal_configuration "unknown library version type \`$version_type'" + ;; + esac + + # Clear the version info if we defaulted, and they specified a release. + if test -z "$vinfo" && test -n "$release"; then + major= + case $version_type in + darwin) + # we can't check for "0.0" in archive_cmds due to quoting + # problems, so we reset it completely + verstring= + ;; + *) + verstring="0.0" + ;; + esac + if test "$need_version" = no; then + versuffix= + else + versuffix=".0.0" + fi + fi + + # Remove version info from name if versioning should be avoided + if test "$avoid_version" = yes && test "$need_version" = no; then + major= + versuffix= + verstring="" + fi + + # Check to see if the archive will have undefined symbols. + if test "$allow_undefined" = yes; then + if test "$allow_undefined_flag" = unsupported; then + func_warning "undefined symbols not allowed in $host shared libraries" + build_libtool_libs=no + build_old_libs=yes + fi + else + # Don't allow undefined symbols. + allow_undefined_flag="$no_undefined_flag" + fi + + fi + + func_generate_dlsyms "$libname" "$libname" "yes" + func_append libobjs " $symfileobj" + test "X$libobjs" = "X " && libobjs= + + if test "$opt_mode" != relink; then + # Remove our outputs, but don't remove object files since they + # may have been created when compiling PIC objects. + removelist= + tempremovelist=`$ECHO "$output_objdir/*"` + for p in $tempremovelist; do + case $p in + *.$objext | *.gcno) + ;; + $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*) + if test "X$precious_files_regex" != "X"; then + if $ECHO "$p" | $EGREP -e "$precious_files_regex" >/dev/null 2>&1 + then + continue + fi + fi + func_append removelist " $p" + ;; + *) ;; + esac + done + test -n "$removelist" && \ + func_show_eval "${RM}r \$removelist" + fi + + # Now set the variables for building old libraries. + if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then + func_append oldlibs " $output_objdir/$libname.$libext" + + # Transform .lo files to .o files. + oldobjs="$objs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; $lo2o" | $NL2SP` + fi + + # Eliminate all temporary directories. + #for path in $notinst_path; do + # lib_search_path=`$ECHO "$lib_search_path " | $SED "s% $path % %g"` + # deplibs=`$ECHO "$deplibs " | $SED "s% -L$path % %g"` + # dependency_libs=`$ECHO "$dependency_libs " | $SED "s% -L$path % %g"` + #done + + if test -n "$xrpath"; then + # If the user specified any rpath flags, then add them. + temp_xrpath= + for libdir in $xrpath; do + func_replace_sysroot "$libdir" + func_append temp_xrpath " -R$func_replace_sysroot_result" + case "$finalize_rpath " in + *" $libdir "*) ;; + *) func_append finalize_rpath " $libdir" ;; + esac + done + if test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then + dependency_libs="$temp_xrpath $dependency_libs" + fi + fi + + # Make sure dlfiles contains only unique files that won't be dlpreopened + old_dlfiles="$dlfiles" + dlfiles= + for lib in $old_dlfiles; do + case " $dlprefiles $dlfiles " in + *" $lib "*) ;; + *) func_append dlfiles " $lib" ;; + esac + done + + # Make sure dlprefiles contains only unique files + old_dlprefiles="$dlprefiles" + dlprefiles= + for lib in $old_dlprefiles; do + case "$dlprefiles " in + *" $lib "*) ;; + *) func_append dlprefiles " $lib" ;; + esac + done + + if test "$build_libtool_libs" = yes; then + if test -n "$rpath"; then + case $host in + *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos* | *-cegcc* | *-*-haiku*) + # these systems don't actually have a c library (as such)! + ;; + *-*-rhapsody* | *-*-darwin1.[012]) + # Rhapsody C library is in the System framework + func_append deplibs " System.ltframework" + ;; + *-*-netbsd*) + # Don't link with libc until the a.out ld.so is fixed. + ;; + *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*) + # Do not include libc due to us having libc/libc_r. + ;; + *-*-sco3.2v5* | *-*-sco5v6*) + # Causes problems with __ctype + ;; + *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*) + # Compiler inserts libc in the correct place for threads to work + ;; + *) + # Add libc to deplibs on all other systems if necessary. + if test "$build_libtool_need_lc" = "yes"; then + func_append deplibs " -lc" + fi + ;; + esac + fi + + # Transform deplibs into only deplibs that can be linked in shared. + name_save=$name + libname_save=$libname + release_save=$release + versuffix_save=$versuffix + major_save=$major + # I'm not sure if I'm treating the release correctly. I think + # release should show up in the -l (ie -lgmp5) so we don't want to + # add it in twice. Is that correct? + release="" + versuffix="" + major="" + newdeplibs= + droppeddeps=no + case $deplibs_check_method in + pass_all) + # Don't check for shared/static. Everything works. + # This might be a little naive. We might want to check + # whether the library exists or not. But this is on + # osf3 & osf4 and I'm not really sure... Just + # implementing what was already the behavior. + newdeplibs=$deplibs + ;; + test_compile) + # This code stresses the "libraries are programs" paradigm to its + # limits. Maybe even breaks it. We compile a program, linking it + # against the deplibs as a proxy for the library. Then we can check + # whether they linked in statically or dynamically with ldd. + $opt_dry_run || $RM conftest.c + cat > conftest.c </dev/null` + $nocaseglob + else + potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null` + fi + for potent_lib in $potential_libs; do + # Follow soft links. + if ls -lLd "$potent_lib" 2>/dev/null | + $GREP " -> " >/dev/null; then + continue + fi + # The statement above tries to avoid entering an + # endless loop below, in case of cyclic links. + # We might still enter an endless loop, since a link + # loop can be closed while we follow links, + # but so what? + potlib="$potent_lib" + while test -h "$potlib" 2>/dev/null; do + potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'` + case $potliblink in + [\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";; + *) potlib=`$ECHO "$potlib" | $SED 's,[^/]*$,,'`"$potliblink";; + esac + done + if eval $file_magic_cmd \"\$potlib\" 2>/dev/null | + $SED -e 10q | + $EGREP "$file_magic_regex" > /dev/null; then + func_append newdeplibs " $a_deplib" + a_deplib="" + break 2 + fi + done + done + fi + if test -n "$a_deplib" ; then + droppeddeps=yes + echo + $ECHO "*** Warning: linker path does not have real file for library $a_deplib." + echo "*** I have the capability to make that library automatically link in when" + echo "*** you link to this library. But I can only do this if you have a" + echo "*** shared version of the library, which you do not appear to have" + echo "*** because I did check the linker path looking for a file starting" + if test -z "$potlib" ; then + $ECHO "*** with $libname but no candidates were found. (...for file magic test)" + else + $ECHO "*** with $libname and none of the candidates passed a file format test" + $ECHO "*** using a file magic. Last file checked: $potlib" + fi + fi + ;; + *) + # Add a -L argument. + func_append newdeplibs " $a_deplib" + ;; + esac + done # Gone through all deplibs. + ;; + match_pattern*) + set dummy $deplibs_check_method; shift + match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"` + for a_deplib in $deplibs; do + case $a_deplib in + -l*) + func_stripname -l '' "$a_deplib" + name=$func_stripname_result + if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then + case " $predeps $postdeps " in + *" $a_deplib "*) + func_append newdeplibs " $a_deplib" + a_deplib="" + ;; + esac + fi + if test -n "$a_deplib" ; then + libname=`eval "\\$ECHO \"$libname_spec\""` + for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do + potential_libs=`ls $i/$libname[.-]* 2>/dev/null` + for potent_lib in $potential_libs; do + potlib="$potent_lib" # see symlink-check above in file_magic test + if eval "\$ECHO \"$potent_lib\"" 2>/dev/null | $SED 10q | \ + $EGREP "$match_pattern_regex" > /dev/null; then + func_append newdeplibs " $a_deplib" + a_deplib="" + break 2 + fi + done + done + fi + if test -n "$a_deplib" ; then + droppeddeps=yes + echo + $ECHO "*** Warning: linker path does not have real file for library $a_deplib." + echo "*** I have the capability to make that library automatically link in when" + echo "*** you link to this library. But I can only do this if you have a" + echo "*** shared version of the library, which you do not appear to have" + echo "*** because I did check the linker path looking for a file starting" + if test -z "$potlib" ; then + $ECHO "*** with $libname but no candidates were found. (...for regex pattern test)" + else + $ECHO "*** with $libname and none of the candidates passed a file format test" + $ECHO "*** using a regex pattern. Last file checked: $potlib" + fi + fi + ;; + *) + # Add a -L argument. + func_append newdeplibs " $a_deplib" + ;; + esac + done # Gone through all deplibs. + ;; + none | unknown | *) + newdeplibs="" + tmp_deplibs=`$ECHO " $deplibs" | $SED 's/ -lc$//; s/ -[LR][^ ]*//g'` + if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then + for i in $predeps $postdeps ; do + # can't use Xsed below, because $i might contain '/' + tmp_deplibs=`$ECHO " $tmp_deplibs" | $SED "s,$i,,"` + done + fi + case $tmp_deplibs in + *[!\ \ ]*) + echo + if test "X$deplibs_check_method" = "Xnone"; then + echo "*** Warning: inter-library dependencies are not supported in this platform." + else + echo "*** Warning: inter-library dependencies are not known to be supported." + fi + echo "*** All declared inter-library dependencies are being dropped." + droppeddeps=yes + ;; + esac + ;; + esac + versuffix=$versuffix_save + major=$major_save + release=$release_save + libname=$libname_save + name=$name_save + + case $host in + *-*-rhapsody* | *-*-darwin1.[012]) + # On Rhapsody replace the C library with the System framework + newdeplibs=`$ECHO " $newdeplibs" | $SED 's/ -lc / System.ltframework /'` + ;; + esac + + if test "$droppeddeps" = yes; then + if test "$module" = yes; then + echo + echo "*** Warning: libtool could not satisfy all declared inter-library" + $ECHO "*** dependencies of module $libname. Therefore, libtool will create" + echo "*** a static module, that should work as long as the dlopening" + echo "*** application is linked with the -dlopen flag." + if test -z "$global_symbol_pipe"; then + echo + echo "*** However, this would only work if libtool was able to extract symbol" + echo "*** lists from a program, using \`nm' or equivalent, but libtool could" + echo "*** not find such a program. So, this module is probably useless." + echo "*** \`nm' from GNU binutils and a full rebuild may help." + fi + if test "$build_old_libs" = no; then + oldlibs="$output_objdir/$libname.$libext" + build_libtool_libs=module + build_old_libs=yes + else + build_libtool_libs=no + fi + else + echo "*** The inter-library dependencies that have been dropped here will be" + echo "*** automatically added whenever a program is linked with this library" + echo "*** or is declared to -dlopen it." + + if test "$allow_undefined" = no; then + echo + echo "*** Since this library must not contain undefined symbols," + echo "*** because either the platform does not support them or" + echo "*** it was explicitly requested with -no-undefined," + echo "*** libtool will only create a static version of it." + if test "$build_old_libs" = no; then + oldlibs="$output_objdir/$libname.$libext" + build_libtool_libs=module + build_old_libs=yes + else + build_libtool_libs=no + fi + fi + fi + fi + # Done checking deplibs! + deplibs=$newdeplibs + fi + # Time to change all our "foo.ltframework" stuff back to "-framework foo" + case $host in + *-*-darwin*) + newdeplibs=`$ECHO " $newdeplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'` + new_inherited_linker_flags=`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'` + deplibs=`$ECHO " $deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'` + ;; + esac + + # move library search paths that coincide with paths to not yet + # installed libraries to the beginning of the library search list + new_libs= + for path in $notinst_path; do + case " $new_libs " in + *" -L$path/$objdir "*) ;; + *) + case " $deplibs " in + *" -L$path/$objdir "*) + func_append new_libs " -L$path/$objdir" ;; + esac + ;; + esac + done + for deplib in $deplibs; do + case $deplib in + -L*) + case " $new_libs " in + *" $deplib "*) ;; + *) func_append new_libs " $deplib" ;; + esac + ;; + *) func_append new_libs " $deplib" ;; + esac + done + deplibs="$new_libs" + + # All the library-specific variables (install_libdir is set above). + library_names= + old_library= + dlname= + + # Test again, we may have decided not to build it any more + if test "$build_libtool_libs" = yes; then + # Remove ${wl} instances when linking with ld. + # FIXME: should test the right _cmds variable. + case $archive_cmds in + *\$LD\ *) wl= ;; + esac + if test "$hardcode_into_libs" = yes; then + # Hardcode the library paths + hardcode_libdirs= + dep_rpath= + rpath="$finalize_rpath" + test "$opt_mode" != relink && rpath="$compile_rpath$rpath" + for libdir in $rpath; do + if test -n "$hardcode_libdir_flag_spec"; then + if test -n "$hardcode_libdir_separator"; then + func_replace_sysroot "$libdir" + libdir=$func_replace_sysroot_result + if test -z "$hardcode_libdirs"; then + hardcode_libdirs="$libdir" + else + # Just accumulate the unique libdirs. + case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in + *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*) + ;; + *) + func_append hardcode_libdirs "$hardcode_libdir_separator$libdir" + ;; + esac + fi + else + eval flag=\"$hardcode_libdir_flag_spec\" + func_append dep_rpath " $flag" + fi + elif test -n "$runpath_var"; then + case "$perm_rpath " in + *" $libdir "*) ;; + *) func_append perm_rpath " $libdir" ;; + esac + fi + done + # Substitute the hardcoded libdirs into the rpath. + if test -n "$hardcode_libdir_separator" && + test -n "$hardcode_libdirs"; then + libdir="$hardcode_libdirs" + eval "dep_rpath=\"$hardcode_libdir_flag_spec\"" + fi + if test -n "$runpath_var" && test -n "$perm_rpath"; then + # We should set the runpath_var. + rpath= + for dir in $perm_rpath; do + func_append rpath "$dir:" + done + eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var" + fi + test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs" + fi + + shlibpath="$finalize_shlibpath" + test "$opt_mode" != relink && shlibpath="$compile_shlibpath$shlibpath" + if test -n "$shlibpath"; then + eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var" + fi + + # Get the real and link names of the library. + eval shared_ext=\"$shrext_cmds\" + eval library_names=\"$library_names_spec\" + set dummy $library_names + shift + realname="$1" + shift + + if test -n "$soname_spec"; then + eval soname=\"$soname_spec\" + else + soname="$realname" + fi + if test -z "$dlname"; then + dlname=$soname + fi + + lib="$output_objdir/$realname" + linknames= + for link + do + func_append linknames " $link" + done + + # Use standard objects if they are pic + test -z "$pic_flag" && libobjs=`$ECHO "$libobjs" | $SP2NL | $SED "$lo2o" | $NL2SP` + test "X$libobjs" = "X " && libobjs= + + delfiles= + if test -n "$export_symbols" && test -n "$include_expsyms"; then + $opt_dry_run || cp "$export_symbols" "$output_objdir/$libname.uexp" + export_symbols="$output_objdir/$libname.uexp" + func_append delfiles " $export_symbols" + fi + + orig_export_symbols= + case $host_os in + cygwin* | mingw* | cegcc*) + if test -n "$export_symbols" && test -z "$export_symbols_regex"; then + # exporting using user supplied symfile + if test "x`$SED 1q $export_symbols`" != xEXPORTS; then + # and it's NOT already a .def file. Must figure out + # which of the given symbols are data symbols and tag + # them as such. So, trigger use of export_symbols_cmds. + # export_symbols gets reassigned inside the "prepare + # the list of exported symbols" if statement, so the + # include_expsyms logic still works. + orig_export_symbols="$export_symbols" + export_symbols= + always_export_symbols=yes + fi + fi + ;; + esac + + # Prepare the list of exported symbols + if test -z "$export_symbols"; then + if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then + func_verbose "generating symbol list for \`$libname.la'" + export_symbols="$output_objdir/$libname.exp" + $opt_dry_run || $RM $export_symbols + cmds=$export_symbols_cmds + save_ifs="$IFS"; IFS='~' + for cmd1 in $cmds; do + IFS="$save_ifs" + # Take the normal branch if the nm_file_list_spec branch + # doesn't work or if tool conversion is not needed. + case $nm_file_list_spec~$to_tool_file_cmd in + *~func_convert_file_noop | *~func_convert_file_msys_to_w32 | ~*) + try_normal_branch=yes + eval cmd=\"$cmd1\" + func_len " $cmd" + len=$func_len_result + ;; + *) + try_normal_branch=no + ;; + esac + if test "$try_normal_branch" = yes \ + && { test "$len" -lt "$max_cmd_len" \ + || test "$max_cmd_len" -le -1; } + then + func_show_eval "$cmd" 'exit $?' + skipped_export=false + elif test -n "$nm_file_list_spec"; then + func_basename "$output" + output_la=$func_basename_result + save_libobjs=$libobjs + save_output=$output + output=${output_objdir}/${output_la}.nm + func_to_tool_file "$output" + libobjs=$nm_file_list_spec$func_to_tool_file_result + func_append delfiles " $output" + func_verbose "creating $NM input file list: $output" + for obj in $save_libobjs; do + func_to_tool_file "$obj" + $ECHO "$func_to_tool_file_result" + done > "$output" + eval cmd=\"$cmd1\" + func_show_eval "$cmd" 'exit $?' + output=$save_output + libobjs=$save_libobjs + skipped_export=false + else + # The command line is too long to execute in one step. + func_verbose "using reloadable object file for export list..." + skipped_export=: + # Break out early, otherwise skipped_export may be + # set to false by a later but shorter cmd. + break + fi + done + IFS="$save_ifs" + if test -n "$export_symbols_regex" && test "X$skipped_export" != "X:"; then + func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"' + func_show_eval '$MV "${export_symbols}T" "$export_symbols"' + fi + fi + fi + + if test -n "$export_symbols" && test -n "$include_expsyms"; then + tmp_export_symbols="$export_symbols" + test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols" + $opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"' + fi + + if test "X$skipped_export" != "X:" && test -n "$orig_export_symbols"; then + # The given exports_symbols file has to be filtered, so filter it. + func_verbose "filter symbol list for \`$libname.la' to tag DATA exports" + # FIXME: $output_objdir/$libname.filter potentially contains lots of + # 's' commands which not all seds can handle. GNU sed should be fine + # though. Also, the filter scales superlinearly with the number of + # global variables. join(1) would be nice here, but unfortunately + # isn't a blessed tool. + $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter + func_append delfiles " $export_symbols $output_objdir/$libname.filter" + export_symbols=$output_objdir/$libname.def + $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols + fi + + tmp_deplibs= + for test_deplib in $deplibs; do + case " $convenience " in + *" $test_deplib "*) ;; + *) + func_append tmp_deplibs " $test_deplib" + ;; + esac + done + deplibs="$tmp_deplibs" + + if test -n "$convenience"; then + if test -n "$whole_archive_flag_spec" && + test "$compiler_needs_object" = yes && + test -z "$libobjs"; then + # extract the archives, so we have objects to list. + # TODO: could optimize this to just extract one archive. + whole_archive_flag_spec= + fi + if test -n "$whole_archive_flag_spec"; then + save_libobjs=$libobjs + eval libobjs=\"\$libobjs $whole_archive_flag_spec\" + test "X$libobjs" = "X " && libobjs= + else + gentop="$output_objdir/${outputname}x" + func_append generated " $gentop" + + func_extract_archives $gentop $convenience + func_append libobjs " $func_extract_archives_result" + test "X$libobjs" = "X " && libobjs= + fi + fi + + if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then + eval flag=\"$thread_safe_flag_spec\" + func_append linker_flags " $flag" + fi + + # Make a backup of the uninstalled library when relinking + if test "$opt_mode" = relink; then + $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}U && $MV $realname ${realname}U)' || exit $? + fi + + # Do each of the archive commands. + if test "$module" = yes && test -n "$module_cmds" ; then + if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then + eval test_cmds=\"$module_expsym_cmds\" + cmds=$module_expsym_cmds + else + eval test_cmds=\"$module_cmds\" + cmds=$module_cmds + fi + else + if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then + eval test_cmds=\"$archive_expsym_cmds\" + cmds=$archive_expsym_cmds + else + eval test_cmds=\"$archive_cmds\" + cmds=$archive_cmds + fi + fi + + if test "X$skipped_export" != "X:" && + func_len " $test_cmds" && + len=$func_len_result && + test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then + : + else + # The command line is too long to link in one step, link piecewise + # or, if using GNU ld and skipped_export is not :, use a linker + # script. + + # Save the value of $output and $libobjs because we want to + # use them later. If we have whole_archive_flag_spec, we + # want to use save_libobjs as it was before + # whole_archive_flag_spec was expanded, because we can't + # assume the linker understands whole_archive_flag_spec. + # This may have to be revisited, in case too many + # convenience libraries get linked in and end up exceeding + # the spec. + if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then + save_libobjs=$libobjs + fi + save_output=$output + func_basename "$output" + output_la=$func_basename_result + + # Clear the reloadable object creation command queue and + # initialize k to one. + test_cmds= + concat_cmds= + objlist= + last_robj= + k=1 + + if test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "$with_gnu_ld" = yes; then + output=${output_objdir}/${output_la}.lnkscript + func_verbose "creating GNU ld script: $output" + echo 'INPUT (' > $output + for obj in $save_libobjs + do + func_to_tool_file "$obj" + $ECHO "$func_to_tool_file_result" >> $output + done + echo ')' >> $output + func_append delfiles " $output" + func_to_tool_file "$output" + output=$func_to_tool_file_result + elif test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "X$file_list_spec" != X; then + output=${output_objdir}/${output_la}.lnk + func_verbose "creating linker input file list: $output" + : > $output + set x $save_libobjs + shift + firstobj= + if test "$compiler_needs_object" = yes; then + firstobj="$1 " + shift + fi + for obj + do + func_to_tool_file "$obj" + $ECHO "$func_to_tool_file_result" >> $output + done + func_append delfiles " $output" + func_to_tool_file "$output" + output=$firstobj\"$file_list_spec$func_to_tool_file_result\" + else + if test -n "$save_libobjs"; then + func_verbose "creating reloadable object files..." + output=$output_objdir/$output_la-${k}.$objext + eval test_cmds=\"$reload_cmds\" + func_len " $test_cmds" + len0=$func_len_result + len=$len0 + + # Loop over the list of objects to be linked. + for obj in $save_libobjs + do + func_len " $obj" + func_arith $len + $func_len_result + len=$func_arith_result + if test "X$objlist" = X || + test "$len" -lt "$max_cmd_len"; then + func_append objlist " $obj" + else + # The command $test_cmds is almost too long, add a + # command to the queue. + if test "$k" -eq 1 ; then + # The first file doesn't have a previous command to add. + reload_objs=$objlist + eval concat_cmds=\"$reload_cmds\" + else + # All subsequent reloadable object files will link in + # the last one created. + reload_objs="$objlist $last_robj" + eval concat_cmds=\"\$concat_cmds~$reload_cmds~\$RM $last_robj\" + fi + last_robj=$output_objdir/$output_la-${k}.$objext + func_arith $k + 1 + k=$func_arith_result + output=$output_objdir/$output_la-${k}.$objext + objlist=" $obj" + func_len " $last_robj" + func_arith $len0 + $func_len_result + len=$func_arith_result + fi + done + # Handle the remaining objects by creating one last + # reloadable object file. All subsequent reloadable object + # files will link in the last one created. + test -z "$concat_cmds" || concat_cmds=$concat_cmds~ + reload_objs="$objlist $last_robj" + eval concat_cmds=\"\${concat_cmds}$reload_cmds\" + if test -n "$last_robj"; then + eval concat_cmds=\"\${concat_cmds}~\$RM $last_robj\" + fi + func_append delfiles " $output" + + else + output= + fi + + if ${skipped_export-false}; then + func_verbose "generating symbol list for \`$libname.la'" + export_symbols="$output_objdir/$libname.exp" + $opt_dry_run || $RM $export_symbols + libobjs=$output + # Append the command to create the export file. + test -z "$concat_cmds" || concat_cmds=$concat_cmds~ + eval concat_cmds=\"\$concat_cmds$export_symbols_cmds\" + if test -n "$last_robj"; then + eval concat_cmds=\"\$concat_cmds~\$RM $last_robj\" + fi + fi + + test -n "$save_libobjs" && + func_verbose "creating a temporary reloadable object file: $output" + + # Loop through the commands generated above and execute them. + save_ifs="$IFS"; IFS='~' + for cmd in $concat_cmds; do + IFS="$save_ifs" + $opt_silent || { + func_quote_for_expand "$cmd" + eval "func_echo $func_quote_for_expand_result" + } + $opt_dry_run || eval "$cmd" || { + lt_exit=$? + + # Restore the uninstalled library and exit + if test "$opt_mode" = relink; then + ( cd "$output_objdir" && \ + $RM "${realname}T" && \ + $MV "${realname}U" "$realname" ) + fi + + exit $lt_exit + } + done + IFS="$save_ifs" + + if test -n "$export_symbols_regex" && ${skipped_export-false}; then + func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"' + func_show_eval '$MV "${export_symbols}T" "$export_symbols"' + fi + fi + + if ${skipped_export-false}; then + if test -n "$export_symbols" && test -n "$include_expsyms"; then + tmp_export_symbols="$export_symbols" + test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols" + $opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"' + fi + + if test -n "$orig_export_symbols"; then + # The given exports_symbols file has to be filtered, so filter it. + func_verbose "filter symbol list for \`$libname.la' to tag DATA exports" + # FIXME: $output_objdir/$libname.filter potentially contains lots of + # 's' commands which not all seds can handle. GNU sed should be fine + # though. Also, the filter scales superlinearly with the number of + # global variables. join(1) would be nice here, but unfortunately + # isn't a blessed tool. + $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter + func_append delfiles " $export_symbols $output_objdir/$libname.filter" + export_symbols=$output_objdir/$libname.def + $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols + fi + fi + + libobjs=$output + # Restore the value of output. + output=$save_output + + if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then + eval libobjs=\"\$libobjs $whole_archive_flag_spec\" + test "X$libobjs" = "X " && libobjs= + fi + # Expand the library linking commands again to reset the + # value of $libobjs for piecewise linking. + + # Do each of the archive commands. + if test "$module" = yes && test -n "$module_cmds" ; then + if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then + cmds=$module_expsym_cmds + else + cmds=$module_cmds + fi + else + if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then + cmds=$archive_expsym_cmds + else + cmds=$archive_cmds + fi + fi + fi + + if test -n "$delfiles"; then + # Append the command to remove temporary files to $cmds. + eval cmds=\"\$cmds~\$RM $delfiles\" + fi + + # Add any objects from preloaded convenience libraries + if test -n "$dlprefiles"; then + gentop="$output_objdir/${outputname}x" + func_append generated " $gentop" + + func_extract_archives $gentop $dlprefiles + func_append libobjs " $func_extract_archives_result" + test "X$libobjs" = "X " && libobjs= + fi + + save_ifs="$IFS"; IFS='~' + for cmd in $cmds; do + IFS="$save_ifs" + eval cmd=\"$cmd\" + $opt_silent || { + func_quote_for_expand "$cmd" + eval "func_echo $func_quote_for_expand_result" + } + $opt_dry_run || eval "$cmd" || { + lt_exit=$? + + # Restore the uninstalled library and exit + if test "$opt_mode" = relink; then + ( cd "$output_objdir" && \ + $RM "${realname}T" && \ + $MV "${realname}U" "$realname" ) + fi + + exit $lt_exit + } + done + IFS="$save_ifs" + + # Restore the uninstalled library and exit + if test "$opt_mode" = relink; then + $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}T && $MV $realname ${realname}T && $MV ${realname}U $realname)' || exit $? + + if test -n "$convenience"; then + if test -z "$whole_archive_flag_spec"; then + func_show_eval '${RM}r "$gentop"' + fi + fi + + exit $EXIT_SUCCESS + fi + + # Create links to the real library. + for linkname in $linknames; do + if test "$realname" != "$linkname"; then + func_show_eval '(cd "$output_objdir" && $RM "$linkname" && $LN_S "$realname" "$linkname")' 'exit $?' + fi + done + + # If -module or -export-dynamic was specified, set the dlname. + if test "$module" = yes || test "$export_dynamic" = yes; then + # On all known operating systems, these are identical. + dlname="$soname" + fi + fi + ;; + + obj) + if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then + func_warning "\`-dlopen' is ignored for objects" + fi + + case " $deplibs" in + *\ -l* | *\ -L*) + func_warning "\`-l' and \`-L' are ignored for objects" ;; + esac + + test -n "$rpath" && \ + func_warning "\`-rpath' is ignored for objects" + + test -n "$xrpath" && \ + func_warning "\`-R' is ignored for objects" + + test -n "$vinfo" && \ + func_warning "\`-version-info' is ignored for objects" + + test -n "$release" && \ + func_warning "\`-release' is ignored for objects" + + case $output in + *.lo) + test -n "$objs$old_deplibs" && \ + func_fatal_error "cannot build library object \`$output' from non-libtool objects" + + libobj=$output + func_lo2o "$libobj" + obj=$func_lo2o_result + ;; + *) + libobj= + obj="$output" + ;; + esac + + # Delete the old objects. + $opt_dry_run || $RM $obj $libobj + + # Objects from convenience libraries. This assumes + # single-version convenience libraries. Whenever we create + # different ones for PIC/non-PIC, this we'll have to duplicate + # the extraction. + reload_conv_objs= + gentop= + # reload_cmds runs $LD directly, so let us get rid of + # -Wl from whole_archive_flag_spec and hope we can get by with + # turning comma into space.. + wl= + + if test -n "$convenience"; then + if test -n "$whole_archive_flag_spec"; then + eval tmp_whole_archive_flags=\"$whole_archive_flag_spec\" + reload_conv_objs=$reload_objs\ `$ECHO "$tmp_whole_archive_flags" | $SED 's|,| |g'` + else + gentop="$output_objdir/${obj}x" + func_append generated " $gentop" + + func_extract_archives $gentop $convenience + reload_conv_objs="$reload_objs $func_extract_archives_result" + fi + fi + + # If we're not building shared, we need to use non_pic_objs + test "$build_libtool_libs" != yes && libobjs="$non_pic_objects" + + # Create the old-style object. + reload_objs="$objs$old_deplibs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; /\.lib$/d; $lo2o" | $NL2SP`" $reload_conv_objs" ### testsuite: skip nested quoting test + + output="$obj" + func_execute_cmds "$reload_cmds" 'exit $?' + + # Exit if we aren't doing a library object file. + if test -z "$libobj"; then + if test -n "$gentop"; then + func_show_eval '${RM}r "$gentop"' + fi + + exit $EXIT_SUCCESS + fi + + if test "$build_libtool_libs" != yes; then + if test -n "$gentop"; then + func_show_eval '${RM}r "$gentop"' + fi + + # Create an invalid libtool object if no PIC, so that we don't + # accidentally link it into a program. + # $show "echo timestamp > $libobj" + # $opt_dry_run || eval "echo timestamp > $libobj" || exit $? + exit $EXIT_SUCCESS + fi + + if test -n "$pic_flag" || test "$pic_mode" != default; then + # Only do commands if we really have different PIC objects. + reload_objs="$libobjs $reload_conv_objs" + output="$libobj" + func_execute_cmds "$reload_cmds" 'exit $?' + fi + + if test -n "$gentop"; then + func_show_eval '${RM}r "$gentop"' + fi + + exit $EXIT_SUCCESS + ;; + + prog) + case $host in + *cygwin*) func_stripname '' '.exe' "$output" + output=$func_stripname_result.exe;; + esac + test -n "$vinfo" && \ + func_warning "\`-version-info' is ignored for programs" + + test -n "$release" && \ + func_warning "\`-release' is ignored for programs" + + test "$preload" = yes \ + && test "$dlopen_support" = unknown \ + && test "$dlopen_self" = unknown \ + && test "$dlopen_self_static" = unknown && \ + func_warning "\`LT_INIT([dlopen])' not used. Assuming no dlopen support." + + case $host in + *-*-rhapsody* | *-*-darwin1.[012]) + # On Rhapsody replace the C library is the System framework + compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's/ -lc / System.ltframework /'` + finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's/ -lc / System.ltframework /'` + ;; + esac + + case $host in + *-*-darwin*) + # Don't allow lazy linking, it breaks C++ global constructors + # But is supposedly fixed on 10.4 or later (yay!). + if test "$tagname" = CXX ; then + case ${MACOSX_DEPLOYMENT_TARGET-10.0} in + 10.[0123]) + func_append compile_command " ${wl}-bind_at_load" + func_append finalize_command " ${wl}-bind_at_load" + ;; + esac + fi + # Time to change all our "foo.ltframework" stuff back to "-framework foo" + compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'` + finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'` + ;; + esac + + + # move library search paths that coincide with paths to not yet + # installed libraries to the beginning of the library search list + new_libs= + for path in $notinst_path; do + case " $new_libs " in + *" -L$path/$objdir "*) ;; + *) + case " $compile_deplibs " in + *" -L$path/$objdir "*) + func_append new_libs " -L$path/$objdir" ;; + esac + ;; + esac + done + for deplib in $compile_deplibs; do + case $deplib in + -L*) + case " $new_libs " in + *" $deplib "*) ;; + *) func_append new_libs " $deplib" ;; + esac + ;; + *) func_append new_libs " $deplib" ;; + esac + done + compile_deplibs="$new_libs" + + + func_append compile_command " $compile_deplibs" + func_append finalize_command " $finalize_deplibs" + + if test -n "$rpath$xrpath"; then + # If the user specified any rpath flags, then add them. + for libdir in $rpath $xrpath; do + # This is the magic to use -rpath. + case "$finalize_rpath " in + *" $libdir "*) ;; + *) func_append finalize_rpath " $libdir" ;; + esac + done + fi + + # Now hardcode the library paths + rpath= + hardcode_libdirs= + for libdir in $compile_rpath $finalize_rpath; do + if test -n "$hardcode_libdir_flag_spec"; then + if test -n "$hardcode_libdir_separator"; then + if test -z "$hardcode_libdirs"; then + hardcode_libdirs="$libdir" + else + # Just accumulate the unique libdirs. + case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in + *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*) + ;; + *) + func_append hardcode_libdirs "$hardcode_libdir_separator$libdir" + ;; + esac + fi + else + eval flag=\"$hardcode_libdir_flag_spec\" + func_append rpath " $flag" + fi + elif test -n "$runpath_var"; then + case "$perm_rpath " in + *" $libdir "*) ;; + *) func_append perm_rpath " $libdir" ;; + esac + fi + case $host in + *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*) + testbindir=`${ECHO} "$libdir" | ${SED} -e 's*/lib$*/bin*'` + case :$dllsearchpath: in + *":$libdir:"*) ;; + ::) dllsearchpath=$libdir;; + *) func_append dllsearchpath ":$libdir";; + esac + case :$dllsearchpath: in + *":$testbindir:"*) ;; + ::) dllsearchpath=$testbindir;; + *) func_append dllsearchpath ":$testbindir";; + esac + ;; + esac + done + # Substitute the hardcoded libdirs into the rpath. + if test -n "$hardcode_libdir_separator" && + test -n "$hardcode_libdirs"; then + libdir="$hardcode_libdirs" + eval rpath=\" $hardcode_libdir_flag_spec\" + fi + compile_rpath="$rpath" + + rpath= + hardcode_libdirs= + for libdir in $finalize_rpath; do + if test -n "$hardcode_libdir_flag_spec"; then + if test -n "$hardcode_libdir_separator"; then + if test -z "$hardcode_libdirs"; then + hardcode_libdirs="$libdir" + else + # Just accumulate the unique libdirs. + case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in + *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*) + ;; + *) + func_append hardcode_libdirs "$hardcode_libdir_separator$libdir" + ;; + esac + fi + else + eval flag=\"$hardcode_libdir_flag_spec\" + func_append rpath " $flag" + fi + elif test -n "$runpath_var"; then + case "$finalize_perm_rpath " in + *" $libdir "*) ;; + *) func_append finalize_perm_rpath " $libdir" ;; + esac + fi + done + # Substitute the hardcoded libdirs into the rpath. + if test -n "$hardcode_libdir_separator" && + test -n "$hardcode_libdirs"; then + libdir="$hardcode_libdirs" + eval rpath=\" $hardcode_libdir_flag_spec\" + fi + finalize_rpath="$rpath" + + if test -n "$libobjs" && test "$build_old_libs" = yes; then + # Transform all the library objects into standard objects. + compile_command=`$ECHO "$compile_command" | $SP2NL | $SED "$lo2o" | $NL2SP` + finalize_command=`$ECHO "$finalize_command" | $SP2NL | $SED "$lo2o" | $NL2SP` + fi + + func_generate_dlsyms "$outputname" "@PROGRAM@" "no" + + # template prelinking step + if test -n "$prelink_cmds"; then + func_execute_cmds "$prelink_cmds" 'exit $?' + fi + + wrappers_required=yes + case $host in + *cegcc* | *mingw32ce*) + # Disable wrappers for cegcc and mingw32ce hosts, we are cross compiling anyway. + wrappers_required=no + ;; + *cygwin* | *mingw* ) + if test "$build_libtool_libs" != yes; then + wrappers_required=no + fi + ;; + *) + if test "$need_relink" = no || test "$build_libtool_libs" != yes; then + wrappers_required=no + fi + ;; + esac + if test "$wrappers_required" = no; then + # Replace the output file specification. + compile_command=`$ECHO "$compile_command" | $SED 's%@OUTPUT@%'"$output"'%g'` + link_command="$compile_command$compile_rpath" + + # We have no uninstalled library dependencies, so finalize right now. + exit_status=0 + func_show_eval "$link_command" 'exit_status=$?' + + if test -n "$postlink_cmds"; then + func_to_tool_file "$output" + postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'` + func_execute_cmds "$postlink_cmds" 'exit $?' + fi + + # Delete the generated files. + if test -f "$output_objdir/${outputname}S.${objext}"; then + func_show_eval '$RM "$output_objdir/${outputname}S.${objext}"' + fi + + exit $exit_status + fi + + if test -n "$compile_shlibpath$finalize_shlibpath"; then + compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command" + fi + if test -n "$finalize_shlibpath"; then + finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command" + fi + + compile_var= + finalize_var= + if test -n "$runpath_var"; then + if test -n "$perm_rpath"; then + # We should set the runpath_var. + rpath= + for dir in $perm_rpath; do + func_append rpath "$dir:" + done + compile_var="$runpath_var=\"$rpath\$$runpath_var\" " + fi + if test -n "$finalize_perm_rpath"; then + # We should set the runpath_var. + rpath= + for dir in $finalize_perm_rpath; do + func_append rpath "$dir:" + done + finalize_var="$runpath_var=\"$rpath\$$runpath_var\" " + fi + fi + + if test "$no_install" = yes; then + # We don't need to create a wrapper script. + link_command="$compile_var$compile_command$compile_rpath" + # Replace the output file specification. + link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output"'%g'` + # Delete the old output file. + $opt_dry_run || $RM $output + # Link the executable and exit + func_show_eval "$link_command" 'exit $?' + + if test -n "$postlink_cmds"; then + func_to_tool_file "$output" + postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'` + func_execute_cmds "$postlink_cmds" 'exit $?' + fi + + exit $EXIT_SUCCESS + fi + + if test "$hardcode_action" = relink; then + # Fast installation is not supported + link_command="$compile_var$compile_command$compile_rpath" + relink_command="$finalize_var$finalize_command$finalize_rpath" + + func_warning "this platform does not like uninstalled shared libraries" + func_warning "\`$output' will be relinked during installation" + else + if test "$fast_install" != no; then + link_command="$finalize_var$compile_command$finalize_rpath" + if test "$fast_install" = yes; then + relink_command=`$ECHO "$compile_var$compile_command$compile_rpath" | $SED 's%@OUTPUT@%\$progdir/\$file%g'` + else + # fast_install is set to needless + relink_command= + fi + else + link_command="$compile_var$compile_command$compile_rpath" + relink_command="$finalize_var$finalize_command$finalize_rpath" + fi + fi + + # Replace the output file specification. + link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'` + + # Delete the old output files. + $opt_dry_run || $RM $output $output_objdir/$outputname $output_objdir/lt-$outputname + + func_show_eval "$link_command" 'exit $?' + + if test -n "$postlink_cmds"; then + func_to_tool_file "$output_objdir/$outputname" + postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'` + func_execute_cmds "$postlink_cmds" 'exit $?' + fi + + # Now create the wrapper script. + func_verbose "creating $output" + + # Quote the relink command for shipping. + if test -n "$relink_command"; then + # Preserve any variables that may affect compiler behavior + for var in $variables_saved_for_relink; do + if eval test -z \"\${$var+set}\"; then + relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command" + elif eval var_value=\$$var; test -z "$var_value"; then + relink_command="$var=; export $var; $relink_command" + else + func_quote_for_eval "$var_value" + relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command" + fi + done + relink_command="(cd `pwd`; $relink_command)" + relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"` + fi + + # Only actually do things if not in dry run mode. + $opt_dry_run || { + # win32 will think the script is a binary if it has + # a .exe suffix, so we strip it off here. + case $output in + *.exe) func_stripname '' '.exe' "$output" + output=$func_stripname_result ;; + esac + # test for cygwin because mv fails w/o .exe extensions + case $host in + *cygwin*) + exeext=.exe + func_stripname '' '.exe' "$outputname" + outputname=$func_stripname_result ;; + *) exeext= ;; + esac + case $host in + *cygwin* | *mingw* ) + func_dirname_and_basename "$output" "" "." + output_name=$func_basename_result + output_path=$func_dirname_result + cwrappersource="$output_path/$objdir/lt-$output_name.c" + cwrapper="$output_path/$output_name.exe" + $RM $cwrappersource $cwrapper + trap "$RM $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15 + + func_emit_cwrapperexe_src > $cwrappersource + + # The wrapper executable is built using the $host compiler, + # because it contains $host paths and files. If cross- + # compiling, it, like the target executable, must be + # executed on the $host or under an emulation environment. + $opt_dry_run || { + $LTCC $LTCFLAGS -o $cwrapper $cwrappersource + $STRIP $cwrapper + } + + # Now, create the wrapper script for func_source use: + func_ltwrapper_scriptname $cwrapper + $RM $func_ltwrapper_scriptname_result + trap "$RM $func_ltwrapper_scriptname_result; exit $EXIT_FAILURE" 1 2 15 + $opt_dry_run || { + # note: this script will not be executed, so do not chmod. + if test "x$build" = "x$host" ; then + $cwrapper --lt-dump-script > $func_ltwrapper_scriptname_result + else + func_emit_wrapper no > $func_ltwrapper_scriptname_result + fi + } + ;; + * ) + $RM $output + trap "$RM $output; exit $EXIT_FAILURE" 1 2 15 + + func_emit_wrapper no > $output + chmod +x $output + ;; + esac + } + exit $EXIT_SUCCESS + ;; + esac + + # See if we need to build an old-fashioned archive. + for oldlib in $oldlibs; do + + if test "$build_libtool_libs" = convenience; then + oldobjs="$libobjs_save $symfileobj" + addlibs="$convenience" + build_libtool_libs=no + else + if test "$build_libtool_libs" = module; then + oldobjs="$libobjs_save" + build_libtool_libs=no + else + oldobjs="$old_deplibs $non_pic_objects" + if test "$preload" = yes && test -f "$symfileobj"; then + func_append oldobjs " $symfileobj" + fi + fi + addlibs="$old_convenience" + fi + + if test -n "$addlibs"; then + gentop="$output_objdir/${outputname}x" + func_append generated " $gentop" + + func_extract_archives $gentop $addlibs + func_append oldobjs " $func_extract_archives_result" + fi + + # Do each command in the archive commands. + if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then + cmds=$old_archive_from_new_cmds + else + + # Add any objects from preloaded convenience libraries + if test -n "$dlprefiles"; then + gentop="$output_objdir/${outputname}x" + func_append generated " $gentop" + + func_extract_archives $gentop $dlprefiles + func_append oldobjs " $func_extract_archives_result" + fi + + # POSIX demands no paths to be encoded in archives. We have + # to avoid creating archives with duplicate basenames if we + # might have to extract them afterwards, e.g., when creating a + # static archive out of a convenience library, or when linking + # the entirety of a libtool archive into another (currently + # not supported by libtool). + if (for obj in $oldobjs + do + func_basename "$obj" + $ECHO "$func_basename_result" + done | sort | sort -uc >/dev/null 2>&1); then + : + else + echo "copying selected object files to avoid basename conflicts..." + gentop="$output_objdir/${outputname}x" + func_append generated " $gentop" + func_mkdir_p "$gentop" + save_oldobjs=$oldobjs + oldobjs= + counter=1 + for obj in $save_oldobjs + do + func_basename "$obj" + objbase="$func_basename_result" + case " $oldobjs " in + " ") oldobjs=$obj ;; + *[\ /]"$objbase "*) + while :; do + # Make sure we don't pick an alternate name that also + # overlaps. + newobj=lt$counter-$objbase + func_arith $counter + 1 + counter=$func_arith_result + case " $oldobjs " in + *[\ /]"$newobj "*) ;; + *) if test ! -f "$gentop/$newobj"; then break; fi ;; + esac + done + func_show_eval "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj" + func_append oldobjs " $gentop/$newobj" + ;; + *) func_append oldobjs " $obj" ;; + esac + done + fi + func_to_tool_file "$oldlib" func_convert_file_msys_to_w32 + tool_oldlib=$func_to_tool_file_result + eval cmds=\"$old_archive_cmds\" + + func_len " $cmds" + len=$func_len_result + if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then + cmds=$old_archive_cmds + elif test -n "$archiver_list_spec"; then + func_verbose "using command file archive linking..." + for obj in $oldobjs + do + func_to_tool_file "$obj" + $ECHO "$func_to_tool_file_result" + done > $output_objdir/$libname.libcmd + func_to_tool_file "$output_objdir/$libname.libcmd" + oldobjs=" $archiver_list_spec$func_to_tool_file_result" + cmds=$old_archive_cmds + else + # the command line is too long to link in one step, link in parts + func_verbose "using piecewise archive linking..." + save_RANLIB=$RANLIB + RANLIB=: + objlist= + concat_cmds= + save_oldobjs=$oldobjs + oldobjs= + # Is there a better way of finding the last object in the list? + for obj in $save_oldobjs + do + last_oldobj=$obj + done + eval test_cmds=\"$old_archive_cmds\" + func_len " $test_cmds" + len0=$func_len_result + len=$len0 + for obj in $save_oldobjs + do + func_len " $obj" + func_arith $len + $func_len_result + len=$func_arith_result + func_append objlist " $obj" + if test "$len" -lt "$max_cmd_len"; then + : + else + # the above command should be used before it gets too long + oldobjs=$objlist + if test "$obj" = "$last_oldobj" ; then + RANLIB=$save_RANLIB + fi + test -z "$concat_cmds" || concat_cmds=$concat_cmds~ + eval concat_cmds=\"\${concat_cmds}$old_archive_cmds\" + objlist= + len=$len0 + fi + done + RANLIB=$save_RANLIB + oldobjs=$objlist + if test "X$oldobjs" = "X" ; then + eval cmds=\"\$concat_cmds\" + else + eval cmds=\"\$concat_cmds~\$old_archive_cmds\" + fi + fi + fi + func_execute_cmds "$cmds" 'exit $?' + done + + test -n "$generated" && \ + func_show_eval "${RM}r$generated" + + # Now create the libtool archive. + case $output in + *.la) + old_library= + test "$build_old_libs" = yes && old_library="$libname.$libext" + func_verbose "creating $output" + + # Preserve any variables that may affect compiler behavior + for var in $variables_saved_for_relink; do + if eval test -z \"\${$var+set}\"; then + relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command" + elif eval var_value=\$$var; test -z "$var_value"; then + relink_command="$var=; export $var; $relink_command" + else + func_quote_for_eval "$var_value" + relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command" + fi + done + # Quote the link command for shipping. + relink_command="(cd `pwd`; $SHELL $progpath $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)" + relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"` + if test "$hardcode_automatic" = yes ; then + relink_command= + fi + + # Only create the output if not a dry run. + $opt_dry_run || { + for installed in no yes; do + if test "$installed" = yes; then + if test -z "$install_libdir"; then + break + fi + output="$output_objdir/$outputname"i + # Replace all uninstalled libtool libraries with the installed ones + newdependency_libs= + for deplib in $dependency_libs; do + case $deplib in + *.la) + func_basename "$deplib" + name="$func_basename_result" + func_resolve_sysroot "$deplib" + eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $func_resolve_sysroot_result` + test -z "$libdir" && \ + func_fatal_error "\`$deplib' is not a valid libtool archive" + func_append newdependency_libs " ${lt_sysroot:+=}$libdir/$name" + ;; + -L*) + func_stripname -L '' "$deplib" + func_replace_sysroot "$func_stripname_result" + func_append newdependency_libs " -L$func_replace_sysroot_result" + ;; + -R*) + func_stripname -R '' "$deplib" + func_replace_sysroot "$func_stripname_result" + func_append newdependency_libs " -R$func_replace_sysroot_result" + ;; + *) func_append newdependency_libs " $deplib" ;; + esac + done + dependency_libs="$newdependency_libs" + newdlfiles= + + for lib in $dlfiles; do + case $lib in + *.la) + func_basename "$lib" + name="$func_basename_result" + eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib` + test -z "$libdir" && \ + func_fatal_error "\`$lib' is not a valid libtool archive" + func_append newdlfiles " ${lt_sysroot:+=}$libdir/$name" + ;; + *) func_append newdlfiles " $lib" ;; + esac + done + dlfiles="$newdlfiles" + newdlprefiles= + for lib in $dlprefiles; do + case $lib in + *.la) + # Only pass preopened files to the pseudo-archive (for + # eventual linking with the app. that links it) if we + # didn't already link the preopened objects directly into + # the library: + func_basename "$lib" + name="$func_basename_result" + eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib` + test -z "$libdir" && \ + func_fatal_error "\`$lib' is not a valid libtool archive" + func_append newdlprefiles " ${lt_sysroot:+=}$libdir/$name" + ;; + esac + done + dlprefiles="$newdlprefiles" + else + newdlfiles= + for lib in $dlfiles; do + case $lib in + [\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;; + *) abs=`pwd`"/$lib" ;; + esac + func_append newdlfiles " $abs" + done + dlfiles="$newdlfiles" + newdlprefiles= + for lib in $dlprefiles; do + case $lib in + [\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;; + *) abs=`pwd`"/$lib" ;; + esac + func_append newdlprefiles " $abs" + done + dlprefiles="$newdlprefiles" + fi + $RM $output + # place dlname in correct position for cygwin + # In fact, it would be nice if we could use this code for all target + # systems that can't hard-code library paths into their executables + # and that have no shared library path variable independent of PATH, + # but it turns out we can't easily determine that from inspecting + # libtool variables, so we have to hard-code the OSs to which it + # applies here; at the moment, that means platforms that use the PE + # object format with DLL files. See the long comment at the top of + # tests/bindir.at for full details. + tdlname=$dlname + case $host,$output,$installed,$module,$dlname in + *cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll | *cegcc*,*lai,yes,no,*.dll) + # If a -bindir argument was supplied, place the dll there. + if test "x$bindir" != x ; + then + func_relative_path "$install_libdir" "$bindir" + tdlname=$func_relative_path_result$dlname + else + # Otherwise fall back on heuristic. + tdlname=../bin/$dlname + fi + ;; + esac + $ECHO > $output "\ +# $outputname - a libtool library file +# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION +# +# Please DO NOT delete this file! +# It is necessary for linking the library. + +# The name that we can dlopen(3). +dlname='$tdlname' + +# Names of this library. +library_names='$library_names' + +# The name of the static archive. +old_library='$old_library' + +# Linker flags that can not go in dependency_libs. +inherited_linker_flags='$new_inherited_linker_flags' + +# Libraries that this one depends upon. +dependency_libs='$dependency_libs' + +# Names of additional weak libraries provided by this library +weak_library_names='$weak_libs' + +# Version information for $libname. +current=$current +age=$age +revision=$revision + +# Is this an already installed library? +installed=$installed + +# Should we warn about portability when linking against -modules? +shouldnotlink=$module + +# Files to dlopen/dlpreopen +dlopen='$dlfiles' +dlpreopen='$dlprefiles' + +# Directory that this library needs to be installed in: +libdir='$install_libdir'" + if test "$installed" = no && test "$need_relink" = yes; then + $ECHO >> $output "\ +relink_command=\"$relink_command\"" + fi + done + } + + # Do a symbolic link so that the libtool archive can be found in + # LD_LIBRARY_PATH before the program is installed. + func_show_eval '( cd "$output_objdir" && $RM "$outputname" && $LN_S "../$outputname" "$outputname" )' 'exit $?' + ;; + esac + exit $EXIT_SUCCESS +} + +{ test "$opt_mode" = link || test "$opt_mode" = relink; } && + func_mode_link ${1+"$@"} + + +# func_mode_uninstall arg... +func_mode_uninstall () +{ + $opt_debug + RM="$nonopt" + files= + rmforce= + exit_status=0 + + # This variable tells wrapper scripts just to set variables rather + # than running their programs. + libtool_install_magic="$magic" + + for arg + do + case $arg in + -f) func_append RM " $arg"; rmforce=yes ;; + -*) func_append RM " $arg" ;; + *) func_append files " $arg" ;; + esac + done + + test -z "$RM" && \ + func_fatal_help "you must specify an RM program" + + rmdirs= + + for file in $files; do + func_dirname "$file" "" "." + dir="$func_dirname_result" + if test "X$dir" = X.; then + odir="$objdir" + else + odir="$dir/$objdir" + fi + func_basename "$file" + name="$func_basename_result" + test "$opt_mode" = uninstall && odir="$dir" + + # Remember odir for removal later, being careful to avoid duplicates + if test "$opt_mode" = clean; then + case " $rmdirs " in + *" $odir "*) ;; + *) func_append rmdirs " $odir" ;; + esac + fi + + # Don't error if the file doesn't exist and rm -f was used. + if { test -L "$file"; } >/dev/null 2>&1 || + { test -h "$file"; } >/dev/null 2>&1 || + test -f "$file"; then + : + elif test -d "$file"; then + exit_status=1 + continue + elif test "$rmforce" = yes; then + continue + fi + + rmfiles="$file" + + case $name in + *.la) + # Possibly a libtool archive, so verify it. + if func_lalib_p "$file"; then + func_source $dir/$name + + # Delete the libtool libraries and symlinks. + for n in $library_names; do + func_append rmfiles " $odir/$n" + done + test -n "$old_library" && func_append rmfiles " $odir/$old_library" + + case "$opt_mode" in + clean) + case " $library_names " in + *" $dlname "*) ;; + *) test -n "$dlname" && func_append rmfiles " $odir/$dlname" ;; + esac + test -n "$libdir" && func_append rmfiles " $odir/$name $odir/${name}i" + ;; + uninstall) + if test -n "$library_names"; then + # Do each command in the postuninstall commands. + func_execute_cmds "$postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1' + fi + + if test -n "$old_library"; then + # Do each command in the old_postuninstall commands. + func_execute_cmds "$old_postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1' + fi + # FIXME: should reinstall the best remaining shared library. + ;; + esac + fi + ;; + + *.lo) + # Possibly a libtool object, so verify it. + if func_lalib_p "$file"; then + + # Read the .lo file + func_source $dir/$name + + # Add PIC object to the list of files to remove. + if test -n "$pic_object" && + test "$pic_object" != none; then + func_append rmfiles " $dir/$pic_object" + fi + + # Add non-PIC object to the list of files to remove. + if test -n "$non_pic_object" && + test "$non_pic_object" != none; then + func_append rmfiles " $dir/$non_pic_object" + fi + fi + ;; + + *) + if test "$opt_mode" = clean ; then + noexename=$name + case $file in + *.exe) + func_stripname '' '.exe' "$file" + file=$func_stripname_result + func_stripname '' '.exe' "$name" + noexename=$func_stripname_result + # $file with .exe has already been added to rmfiles, + # add $file without .exe + func_append rmfiles " $file" + ;; + esac + # Do a test to see if this is a libtool program. + if func_ltwrapper_p "$file"; then + if func_ltwrapper_executable_p "$file"; then + func_ltwrapper_scriptname "$file" + relink_command= + func_source $func_ltwrapper_scriptname_result + func_append rmfiles " $func_ltwrapper_scriptname_result" + else + relink_command= + func_source $dir/$noexename + fi + + # note $name still contains .exe if it was in $file originally + # as does the version of $file that was added into $rmfiles + func_append rmfiles " $odir/$name $odir/${name}S.${objext}" + if test "$fast_install" = yes && test -n "$relink_command"; then + func_append rmfiles " $odir/lt-$name" + fi + if test "X$noexename" != "X$name" ; then + func_append rmfiles " $odir/lt-${noexename}.c" + fi + fi + fi + ;; + esac + func_show_eval "$RM $rmfiles" 'exit_status=1' + done + + # Try to remove the ${objdir}s in the directories where we deleted files + for dir in $rmdirs; do + if test -d "$dir"; then + func_show_eval "rmdir $dir >/dev/null 2>&1" + fi + done + + exit $exit_status +} + +{ test "$opt_mode" = uninstall || test "$opt_mode" = clean; } && + func_mode_uninstall ${1+"$@"} + +test -z "$opt_mode" && { + help="$generic_help" + func_fatal_help "you must specify a MODE" +} + +test -z "$exec_cmd" && \ + func_fatal_help "invalid operation mode \`$opt_mode'" + +if test -n "$exec_cmd"; then + eval exec "$exec_cmd" + exit $EXIT_FAILURE +fi + +exit $exit_status + + +# The TAGs below are defined such that we never get into a situation +# in which we disable both kinds of libraries. Given conflicting +# choices, we go for a static library, that is the most portable, +# since we can't tell whether shared libraries were disabled because +# the user asked for that or because the platform doesn't support +# them. This is particularly important on AIX, because we don't +# support having both static and shared libraries enabled at the same +# time on that platform, so we default to a shared-only configuration. +# If a disable-shared tag is given, we'll fallback to a static-only +# configuration. But we'll never go from static-only to shared-only. + +# ### BEGIN LIBTOOL TAG CONFIG: disable-shared +build_libtool_libs=no +build_old_libs=yes +# ### END LIBTOOL TAG CONFIG: disable-shared + +# ### BEGIN LIBTOOL TAG CONFIG: disable-static +build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac` +# ### END LIBTOOL TAG CONFIG: disable-static + +# Local Variables: +# mode:shell-script +# sh-indentation:2 +# End: +# vi:sw=2 + diff --git a/third-party/odb/libodb-sqlite-2.4.0/config/missing b/third-party/odb/libodb-sqlite-2.4.0/config/missing new file mode 100755 index 0000000..9a55648 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/config/missing @@ -0,0 +1,330 @@ +#! /bin/sh +# Common stub for a few missing GNU programs while installing. + +scriptversion=2012-01-06.18; # UTC + +# Copyright (C) 1996-2012 Free Software Foundation, Inc. +# Originally by Fran,cois Pinard , 1996. + +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2, or (at your option) +# any later version. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + +# As a special exception to the GNU General Public License, if you +# distribute this file as part of a program that contains a +# configuration script generated by Autoconf, you may include it under +# the same distribution terms that you use for the rest of that program. + +if test $# -eq 0; then + echo 1>&2 "Try '$0 --help' for more information" + exit 1 +fi + +run=: +sed_output='s/.* --output[ =]\([^ ]*\).*/\1/p' +sed_minuso='s/.* -o \([^ ]*\).*/\1/p' + +# In the cases where this matters, 'missing' is being run in the +# srcdir already. +if test -f configure.ac; then + configure_ac=configure.ac +else + configure_ac=configure.in +fi + +msg="missing on your system" + +case $1 in +--run) + # Try to run requested program, and just exit if it succeeds. + run= + shift + "$@" && exit 0 + # Exit code 63 means version mismatch. This often happens + # when the user try to use an ancient version of a tool on + # a file that requires a minimum version. In this case we + # we should proceed has if the program had been absent, or + # if --run hadn't been passed. + if test $? = 63; then + run=: + msg="probably too old" + fi + ;; + + -h|--h|--he|--hel|--help) + echo "\ +$0 [OPTION]... PROGRAM [ARGUMENT]... + +Handle 'PROGRAM [ARGUMENT]...' for when PROGRAM is missing, or return an +error status if there is no known handling for PROGRAM. + +Options: + -h, --help display this help and exit + -v, --version output version information and exit + --run try to run the given command, and emulate it if it fails + +Supported PROGRAM values: + aclocal touch file 'aclocal.m4' + autoconf touch file 'configure' + autoheader touch file 'config.h.in' + autom4te touch the output file, or create a stub one + automake touch all 'Makefile.in' files + bison create 'y.tab.[ch]', if possible, from existing .[ch] + flex create 'lex.yy.c', if possible, from existing .c + help2man touch the output file + lex create 'lex.yy.c', if possible, from existing .c + makeinfo touch the output file + yacc create 'y.tab.[ch]', if possible, from existing .[ch] + +Version suffixes to PROGRAM as well as the prefixes 'gnu-', 'gnu', and +'g' are ignored when checking the name. + +Send bug reports to ." + exit $? + ;; + + -v|--v|--ve|--ver|--vers|--versi|--versio|--version) + echo "missing $scriptversion (GNU Automake)" + exit $? + ;; + + -*) + echo 1>&2 "$0: Unknown '$1' option" + echo 1>&2 "Try '$0 --help' for more information" + exit 1 + ;; + +esac + +# normalize program name to check for. +program=`echo "$1" | sed ' + s/^gnu-//; t + s/^gnu//; t + s/^g//; t'` + +# Now exit if we have it, but it failed. Also exit now if we +# don't have it and --version was passed (most likely to detect +# the program). This is about non-GNU programs, so use $1 not +# $program. +case $1 in + lex*|yacc*) + # Not GNU programs, they don't have --version. + ;; + + *) + if test -z "$run" && ($1 --version) > /dev/null 2>&1; then + # We have it, but it failed. + exit 1 + elif test "x$2" = "x--version" || test "x$2" = "x--help"; then + # Could not run --version or --help. This is probably someone + # running '$TOOL --version' or '$TOOL --help' to check whether + # $TOOL exists and not knowing $TOOL uses missing. + exit 1 + fi + ;; +esac + +# If it does not exist, or fails to run (possibly an outdated version), +# try to emulate it. +case $program in + aclocal*) + echo 1>&2 "\ +WARNING: '$1' is $msg. You should only need it if + you modified 'acinclude.m4' or '${configure_ac}'. You might want + to install the Automake and Perl packages. Grab them from + any GNU archive site." + touch aclocal.m4 + ;; + + autoconf*) + echo 1>&2 "\ +WARNING: '$1' is $msg. You should only need it if + you modified '${configure_ac}'. You might want to install the + Autoconf and GNU m4 packages. Grab them from any GNU + archive site." + touch configure + ;; + + autoheader*) + echo 1>&2 "\ +WARNING: '$1' is $msg. You should only need it if + you modified 'acconfig.h' or '${configure_ac}'. You might want + to install the Autoconf and GNU m4 packages. Grab them + from any GNU archive site." + files=`sed -n 's/^[ ]*A[CM]_CONFIG_HEADER(\([^)]*\)).*/\1/p' ${configure_ac}` + test -z "$files" && files="config.h" + touch_files= + for f in $files; do + case $f in + *:*) touch_files="$touch_files "`echo "$f" | + sed -e 's/^[^:]*://' -e 's/:.*//'`;; + *) touch_files="$touch_files $f.in";; + esac + done + touch $touch_files + ;; + + automake*) + echo 1>&2 "\ +WARNING: '$1' is $msg. You should only need it if + you modified 'Makefile.am', 'acinclude.m4' or '${configure_ac}'. + You might want to install the Automake and Perl packages. + Grab them from any GNU archive site." + find . -type f -name Makefile.am -print | + sed 's/\.am$/.in/' | + while read f; do touch "$f"; done + ;; + + autom4te*) + echo 1>&2 "\ +WARNING: '$1' is needed, but is $msg. + You might have modified some files without having the + proper tools for further handling them. + You can get '$1' as part of Autoconf from any GNU + archive site." + + file=`echo "$*" | sed -n "$sed_output"` + test -z "$file" && file=`echo "$*" | sed -n "$sed_minuso"` + if test -f "$file"; then + touch $file + else + test -z "$file" || exec >$file + echo "#! /bin/sh" + echo "# Created by GNU Automake missing as a replacement of" + echo "# $ $@" + echo "exit 0" + chmod +x $file + exit 1 + fi + ;; + + bison*|yacc*) + echo 1>&2 "\ +WARNING: '$1' $msg. You should only need it if + you modified a '.y' file. You may need the Bison package + in order for those modifications to take effect. You can get + Bison from any GNU archive site." + rm -f y.tab.c y.tab.h + if test $# -ne 1; then + eval LASTARG=\${$#} + case $LASTARG in + *.y) + SRCFILE=`echo "$LASTARG" | sed 's/y$/c/'` + if test -f "$SRCFILE"; then + cp "$SRCFILE" y.tab.c + fi + SRCFILE=`echo "$LASTARG" | sed 's/y$/h/'` + if test -f "$SRCFILE"; then + cp "$SRCFILE" y.tab.h + fi + ;; + esac + fi + if test ! -f y.tab.h; then + echo >y.tab.h + fi + if test ! -f y.tab.c; then + echo 'main() { return 0; }' >y.tab.c + fi + ;; + + lex*|flex*) + echo 1>&2 "\ +WARNING: '$1' is $msg. You should only need it if + you modified a '.l' file. You may need the Flex package + in order for those modifications to take effect. You can get + Flex from any GNU archive site." + rm -f lex.yy.c + if test $# -ne 1; then + eval LASTARG=\${$#} + case $LASTARG in + *.l) + SRCFILE=`echo "$LASTARG" | sed 's/l$/c/'` + if test -f "$SRCFILE"; then + cp "$SRCFILE" lex.yy.c + fi + ;; + esac + fi + if test ! -f lex.yy.c; then + echo 'main() { return 0; }' >lex.yy.c + fi + ;; + + help2man*) + echo 1>&2 "\ +WARNING: '$1' is $msg. You should only need it if + you modified a dependency of a manual page. You may need the + Help2man package in order for those modifications to take + effect. You can get Help2man from any GNU archive site." + + file=`echo "$*" | sed -n "$sed_output"` + test -z "$file" && file=`echo "$*" | sed -n "$sed_minuso"` + if test -f "$file"; then + touch $file + else + test -z "$file" || exec >$file + echo ".ab help2man is required to generate this page" + exit $? + fi + ;; + + makeinfo*) + echo 1>&2 "\ +WARNING: '$1' is $msg. You should only need it if + you modified a '.texi' or '.texinfo' file, or any other file + indirectly affecting the aspect of the manual. The spurious + call might also be the consequence of using a buggy 'make' (AIX, + DU, IRIX). You might want to install the Texinfo package or + the GNU make package. Grab either from any GNU archive site." + # The file to touch is that specified with -o ... + file=`echo "$*" | sed -n "$sed_output"` + test -z "$file" && file=`echo "$*" | sed -n "$sed_minuso"` + if test -z "$file"; then + # ... or it is the one specified with @setfilename ... + infile=`echo "$*" | sed 's/.* \([^ ]*\) *$/\1/'` + file=`sed -n ' + /^@setfilename/{ + s/.* \([^ ]*\) *$/\1/ + p + q + }' $infile` + # ... or it is derived from the source name (dir/f.texi becomes f.info) + test -z "$file" && file=`echo "$infile" | sed 's,.*/,,;s,.[^.]*$,,'`.info + fi + # If the file does not exist, the user really needs makeinfo; + # let's fail without touching anything. + test -f $file || exit 1 + touch $file + ;; + + *) + echo 1>&2 "\ +WARNING: '$1' is needed, and is $msg. + You might have modified some files without having the + proper tools for further handling them. Check the 'README' file, + it often tells you about the needed prerequisites for installing + this package. You may also peek at any GNU archive site, in case + some other package would contain this missing '$1' program." + exit 1 + ;; +esac + +exit 0 + +# Local variables: +# eval: (add-hook 'write-file-hooks 'time-stamp) +# time-stamp-start: "scriptversion=" +# time-stamp-format: "%:y-%02m-%02d.%02H" +# time-stamp-time-zone: "UTC" +# time-stamp-end: "; # UTC" +# End: diff --git a/third-party/odb/libodb-sqlite-2.4.0/configure b/third-party/odb/libodb-sqlite-2.4.0/configure new file mode 100755 index 0000000..5890bba --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/configure @@ -0,0 +1,20604 @@ +#! /bin/sh +# Guess values for system-dependent variables and create Makefiles. +# Generated by GNU Autoconf 2.69 for libodb-sqlite 2.4.0. +# +# Report bugs to . +# +# +# Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc. +# +# +# This configure script is free software; the Free Software Foundation +# gives unlimited permission to copy, distribute and modify it. +## -------------------- ## +## M4sh Initialization. ## +## -------------------- ## + +# Be more Bourne compatible +DUALCASE=1; export DUALCASE # for MKS sh +if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then : + emulate sh + NULLCMD=: + # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which + # is contrary to our usage. Disable this feature. + alias -g '${1+"$@"}'='"$@"' + setopt NO_GLOB_SUBST +else + case `(set -o) 2>/dev/null` in #( + *posix*) : + set -o posix ;; #( + *) : + ;; +esac +fi + + +as_nl=' +' +export as_nl +# Printing a long string crashes Solaris 7 /usr/bin/printf. +as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' +as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo +as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo +# Prefer a ksh shell builtin over an external printf program on Solaris, +# but without wasting forks for bash or zsh. +if test -z "$BASH_VERSION$ZSH_VERSION" \ + && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then + as_echo='print -r --' + as_echo_n='print -rn --' +elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then + as_echo='printf %s\n' + as_echo_n='printf %s' +else + if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then + as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"' + as_echo_n='/usr/ucb/echo -n' + else + as_echo_body='eval expr "X$1" : "X\\(.*\\)"' + as_echo_n_body='eval + arg=$1; + case $arg in #( + *"$as_nl"*) + expr "X$arg" : "X\\(.*\\)$as_nl"; + arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;; + esac; + expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl" + ' + export as_echo_n_body + as_echo_n='sh -c $as_echo_n_body as_echo' + fi + export as_echo_body + as_echo='sh -c $as_echo_body as_echo' +fi + +# The user is always right. +if test "${PATH_SEPARATOR+set}" != set; then + PATH_SEPARATOR=: + (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && { + (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 || + PATH_SEPARATOR=';' + } +fi + + +# IFS +# We need space, tab and new line, in precisely that order. Quoting is +# there to prevent editors from complaining about space-tab. +# (If _AS_PATH_WALK were called with IFS unset, it would disable word +# splitting by setting IFS to empty value.) +IFS=" "" $as_nl" + +# Find who we are. Look in the path if we contain no directory separator. +as_myself= +case $0 in #(( + *[\\/]* ) as_myself=$0 ;; + *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break + done +IFS=$as_save_IFS + + ;; +esac +# We did not find ourselves, most probably we were run as `sh COMMAND' +# in which case we are not to be found in the path. +if test "x$as_myself" = x; then + as_myself=$0 +fi +if test ! -f "$as_myself"; then + $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2 + exit 1 +fi + +# Unset variables that we do not need and which cause bugs (e.g. in +# pre-3.0 UWIN ksh). But do not cause bugs in bash 2.01; the "|| exit 1" +# suppresses any "Segmentation fault" message there. '((' could +# trigger a bug in pdksh 5.2.14. +for as_var in BASH_ENV ENV MAIL MAILPATH +do eval test x\${$as_var+set} = xset \ + && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || : +done +PS1='$ ' +PS2='> ' +PS4='+ ' + +# NLS nuisances. +LC_ALL=C +export LC_ALL +LANGUAGE=C +export LANGUAGE + +# CDPATH. +(unset CDPATH) >/dev/null 2>&1 && unset CDPATH + +# Use a proper internal environment variable to ensure we don't fall + # into an infinite loop, continuously re-executing ourselves. + if test x"${_as_can_reexec}" != xno && test "x$CONFIG_SHELL" != x; then + _as_can_reexec=no; export _as_can_reexec; + # We cannot yet assume a decent shell, so we have to provide a +# neutralization value for shells without unset; and this also +# works around shells that cannot unset nonexistent variables. +# Preserve -v and -x to the replacement shell. +BASH_ENV=/dev/null +ENV=/dev/null +(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV +case $- in # (((( + *v*x* | *x*v* ) as_opts=-vx ;; + *v* ) as_opts=-v ;; + *x* ) as_opts=-x ;; + * ) as_opts= ;; +esac +exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"} +# Admittedly, this is quite paranoid, since all the known shells bail +# out after a failed `exec'. +$as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2 +as_fn_exit 255 + fi + # We don't want this to propagate to other subprocesses. + { _as_can_reexec=; unset _as_can_reexec;} +if test "x$CONFIG_SHELL" = x; then + as_bourne_compatible="if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then : + emulate sh + NULLCMD=: + # Pre-4.2 versions of Zsh do word splitting on \${1+\"\$@\"}, which + # is contrary to our usage. Disable this feature. + alias -g '\${1+\"\$@\"}'='\"\$@\"' + setopt NO_GLOB_SUBST +else + case \`(set -o) 2>/dev/null\` in #( + *posix*) : + set -o posix ;; #( + *) : + ;; +esac +fi +" + as_required="as_fn_return () { (exit \$1); } +as_fn_success () { as_fn_return 0; } +as_fn_failure () { as_fn_return 1; } +as_fn_ret_success () { return 0; } +as_fn_ret_failure () { return 1; } + +exitcode=0 +as_fn_success || { exitcode=1; echo as_fn_success failed.; } +as_fn_failure && { exitcode=1; echo as_fn_failure succeeded.; } +as_fn_ret_success || { exitcode=1; echo as_fn_ret_success failed.; } +as_fn_ret_failure && { exitcode=1; echo as_fn_ret_failure succeeded.; } +if ( set x; as_fn_ret_success y && test x = \"\$1\" ); then : + +else + exitcode=1; echo positional parameters were not saved. +fi +test x\$exitcode = x0 || exit 1 +test -x / || exit 1" + as_suggested=" as_lineno_1=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_1a=\$LINENO + as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO + eval 'test \"x\$as_lineno_1'\$as_run'\" != \"x\$as_lineno_2'\$as_run'\" && + test \"x\`expr \$as_lineno_1'\$as_run' + 1\`\" = \"x\$as_lineno_2'\$as_run'\"' || exit 1 + + test -n \"\${ZSH_VERSION+set}\${BASH_VERSION+set}\" || ( + ECHO='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' + ECHO=\$ECHO\$ECHO\$ECHO\$ECHO\$ECHO + ECHO=\$ECHO\$ECHO\$ECHO\$ECHO\$ECHO\$ECHO + PATH=/empty FPATH=/empty; export PATH FPATH + test \"X\`printf %s \$ECHO\`\" = \"X\$ECHO\" \\ + || test \"X\`print -r -- \$ECHO\`\" = \"X\$ECHO\" ) || exit 1 +test \$(( 1 + 1 )) = 2 || exit 1" + if (eval "$as_required") 2>/dev/null; then : + as_have_required=yes +else + as_have_required=no +fi + if test x$as_have_required = xyes && (eval "$as_suggested") 2>/dev/null; then : + +else + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +as_found=false +for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + as_found=: + case $as_dir in #( + /*) + for as_base in sh bash ksh sh5; do + # Try only shells that exist, to save several forks. + as_shell=$as_dir/$as_base + if { test -f "$as_shell" || test -f "$as_shell.exe"; } && + { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$as_shell"; } 2>/dev/null; then : + CONFIG_SHELL=$as_shell as_have_required=yes + if { $as_echo "$as_bourne_compatible""$as_suggested" | as_run=a "$as_shell"; } 2>/dev/null; then : + break 2 +fi +fi + done;; + esac + as_found=false +done +$as_found || { if { test -f "$SHELL" || test -f "$SHELL.exe"; } && + { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$SHELL"; } 2>/dev/null; then : + CONFIG_SHELL=$SHELL as_have_required=yes +fi; } +IFS=$as_save_IFS + + + if test "x$CONFIG_SHELL" != x; then : + export CONFIG_SHELL + # We cannot yet assume a decent shell, so we have to provide a +# neutralization value for shells without unset; and this also +# works around shells that cannot unset nonexistent variables. +# Preserve -v and -x to the replacement shell. +BASH_ENV=/dev/null +ENV=/dev/null +(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV +case $- in # (((( + *v*x* | *x*v* ) as_opts=-vx ;; + *v* ) as_opts=-v ;; + *x* ) as_opts=-x ;; + * ) as_opts= ;; +esac +exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"} +# Admittedly, this is quite paranoid, since all the known shells bail +# out after a failed `exec'. +$as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2 +exit 255 +fi + + if test x$as_have_required = xno; then : + $as_echo "$0: This script requires a shell more modern than all" + $as_echo "$0: the shells that I found on your system." + if test x${ZSH_VERSION+set} = xset ; then + $as_echo "$0: In particular, zsh $ZSH_VERSION has bugs and should" + $as_echo "$0: be upgraded to zsh 4.3.4 or later." + else + $as_echo "$0: Please tell bug-autoconf@gnu.org and +$0: odb-users@codesynthesis.com about your system, +$0: including any error possibly output before this +$0: message. Then install a modern shell, or manually run +$0: the script under such a shell if you do have one." + fi + exit 1 +fi +fi +fi +SHELL=${CONFIG_SHELL-/bin/sh} +export SHELL +# Unset more variables known to interfere with behavior of common tools. +CLICOLOR_FORCE= GREP_OPTIONS= +unset CLICOLOR_FORCE GREP_OPTIONS + +## --------------------- ## +## M4sh Shell Functions. ## +## --------------------- ## +# as_fn_unset VAR +# --------------- +# Portably unset VAR. +as_fn_unset () +{ + { eval $1=; unset $1;} +} +as_unset=as_fn_unset + +# as_fn_set_status STATUS +# ----------------------- +# Set $? to STATUS, without forking. +as_fn_set_status () +{ + return $1 +} # as_fn_set_status + +# as_fn_exit STATUS +# ----------------- +# Exit the shell with STATUS, even in a "trap 0" or "set -e" context. +as_fn_exit () +{ + set +e + as_fn_set_status $1 + exit $1 +} # as_fn_exit + +# as_fn_mkdir_p +# ------------- +# Create "$as_dir" as a directory, including parents if necessary. +as_fn_mkdir_p () +{ + + case $as_dir in #( + -*) as_dir=./$as_dir;; + esac + test -d "$as_dir" || eval $as_mkdir_p || { + as_dirs= + while :; do + case $as_dir in #( + *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'( + *) as_qdir=$as_dir;; + esac + as_dirs="'$as_qdir' $as_dirs" + as_dir=`$as_dirname -- "$as_dir" || +$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ + X"$as_dir" : 'X\(//\)[^/]' \| \ + X"$as_dir" : 'X\(//\)$' \| \ + X"$as_dir" : 'X\(/\)' \| . 2>/dev/null || +$as_echo X"$as_dir" | + sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ + s//\1/ + q + } + /^X\(\/\/\)[^/].*/{ + s//\1/ + q + } + /^X\(\/\/\)$/{ + s//\1/ + q + } + /^X\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q'` + test -d "$as_dir" && break + done + test -z "$as_dirs" || eval "mkdir $as_dirs" + } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir" + + +} # as_fn_mkdir_p + +# as_fn_executable_p FILE +# ----------------------- +# Test if FILE is an executable regular file. +as_fn_executable_p () +{ + test -f "$1" && test -x "$1" +} # as_fn_executable_p +# as_fn_append VAR VALUE +# ---------------------- +# Append the text in VALUE to the end of the definition contained in VAR. Take +# advantage of any shell optimizations that allow amortized linear growth over +# repeated appends, instead of the typical quadratic growth present in naive +# implementations. +if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then : + eval 'as_fn_append () + { + eval $1+=\$2 + }' +else + as_fn_append () + { + eval $1=\$$1\$2 + } +fi # as_fn_append + +# as_fn_arith ARG... +# ------------------ +# Perform arithmetic evaluation on the ARGs, and store the result in the +# global $as_val. Take advantage of shells that can avoid forks. The arguments +# must be portable across $(()) and expr. +if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then : + eval 'as_fn_arith () + { + as_val=$(( $* )) + }' +else + as_fn_arith () + { + as_val=`expr "$@" || test $? -eq 1` + } +fi # as_fn_arith + + +# as_fn_error STATUS ERROR [LINENO LOG_FD] +# ---------------------------------------- +# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are +# provided, also output the error to LOG_FD, referencing LINENO. Then exit the +# script with STATUS, using 1 if that was 0. +as_fn_error () +{ + as_status=$1; test $as_status -eq 0 && as_status=1 + if test "$4"; then + as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4 + fi + $as_echo "$as_me: error: $2" >&2 + as_fn_exit $as_status +} # as_fn_error + +if expr a : '\(a\)' >/dev/null 2>&1 && + test "X`expr 00001 : '.*\(...\)'`" = X001; then + as_expr=expr +else + as_expr=false +fi + +if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then + as_basename=basename +else + as_basename=false +fi + +if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then + as_dirname=dirname +else + as_dirname=false +fi + +as_me=`$as_basename -- "$0" || +$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ + X"$0" : 'X\(//\)$' \| \ + X"$0" : 'X\(/\)' \| . 2>/dev/null || +$as_echo X/"$0" | + sed '/^.*\/\([^/][^/]*\)\/*$/{ + s//\1/ + q + } + /^X\/\(\/\/\)$/{ + s//\1/ + q + } + /^X\/\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q'` + +# Avoid depending upon Character Ranges. +as_cr_letters='abcdefghijklmnopqrstuvwxyz' +as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ' +as_cr_Letters=$as_cr_letters$as_cr_LETTERS +as_cr_digits='0123456789' +as_cr_alnum=$as_cr_Letters$as_cr_digits + + + as_lineno_1=$LINENO as_lineno_1a=$LINENO + as_lineno_2=$LINENO as_lineno_2a=$LINENO + eval 'test "x$as_lineno_1'$as_run'" != "x$as_lineno_2'$as_run'" && + test "x`expr $as_lineno_1'$as_run' + 1`" = "x$as_lineno_2'$as_run'"' || { + # Blame Lee E. McMahon (1931-1989) for sed's syntax. :-) + sed -n ' + p + /[$]LINENO/= + ' <$as_myself | + sed ' + s/[$]LINENO.*/&-/ + t lineno + b + :lineno + N + :loop + s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/ + t loop + s/-\n.*// + ' >$as_me.lineno && + chmod +x "$as_me.lineno" || + { $as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; } + + # If we had to re-execute with $CONFIG_SHELL, we're ensured to have + # already done that, so ensure we don't try to do so again and fall + # in an infinite loop. This has already happened in practice. + _as_can_reexec=no; export _as_can_reexec + # Don't try to exec as it changes $[0], causing all sort of problems + # (the dirname of $[0] is not the place where we might find the + # original and so on. Autoconf is especially sensitive to this). + . "./$as_me.lineno" + # Exit status is that of the last command. + exit +} + +ECHO_C= ECHO_N= ECHO_T= +case `echo -n x` in #((((( +-n*) + case `echo 'xy\c'` in + *c*) ECHO_T=' ';; # ECHO_T is single tab character. + xy) ECHO_C='\c';; + *) echo `echo ksh88 bug on AIX 6.1` > /dev/null + ECHO_T=' ';; + esac;; +*) + ECHO_N='-n';; +esac + +rm -f conf$$ conf$$.exe conf$$.file +if test -d conf$$.dir; then + rm -f conf$$.dir/conf$$.file +else + rm -f conf$$.dir + mkdir conf$$.dir 2>/dev/null +fi +if (echo >conf$$.file) 2>/dev/null; then + if ln -s conf$$.file conf$$ 2>/dev/null; then + as_ln_s='ln -s' + # ... but there are two gotchas: + # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail. + # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable. + # In both cases, we have to default to `cp -pR'. + ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe || + as_ln_s='cp -pR' + elif ln conf$$.file conf$$ 2>/dev/null; then + as_ln_s=ln + else + as_ln_s='cp -pR' + fi +else + as_ln_s='cp -pR' +fi +rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file +rmdir conf$$.dir 2>/dev/null + +if mkdir -p . 2>/dev/null; then + as_mkdir_p='mkdir -p "$as_dir"' +else + test -d ./-p && rmdir ./-p + as_mkdir_p=false +fi + +as_test_x='test -x' +as_executable_p=as_fn_executable_p + +# Sed expression to map a string onto a valid CPP name. +as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'" + +# Sed expression to map a string onto a valid variable name. +as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'" + +SHELL=${CONFIG_SHELL-/bin/sh} + + +test -n "$DJDIR" || exec 7<&0 &1 + +# Name of the host. +# hostname on some systems (SVR3.2, old GNU/Linux) returns a bogus exit status, +# so uname gets run too. +ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q` + +# +# Initializations. +# +ac_default_prefix=/usr/local +ac_clean_files= +ac_config_libobj_dir=. +LIBOBJS= +cross_compiling=no +subdirs= +MFLAGS= +MAKEFLAGS= + +# Identity of this package. +PACKAGE_NAME='libodb-sqlite' +PACKAGE_TARNAME='libodb-sqlite' +PACKAGE_VERSION='2.4.0' +PACKAGE_STRING='libodb-sqlite 2.4.0' +PACKAGE_BUGREPORT='odb-users@codesynthesis.com' +PACKAGE_URL='' + +ac_unique_file="odb/sqlite/version.hxx" +# Factoring default headers for most tests. +ac_includes_default="\ +#include +#ifdef HAVE_SYS_TYPES_H +# include +#endif +#ifdef HAVE_SYS_STAT_H +# include +#endif +#ifdef STDC_HEADERS +# include +# include +#else +# ifdef HAVE_STDLIB_H +# include +# endif +#endif +#ifdef HAVE_STRING_H +# if !defined STDC_HEADERS && defined HAVE_MEMORY_H +# include +# endif +# include +#endif +#ifdef HAVE_STRINGS_H +# include +#endif +#ifdef HAVE_INTTYPES_H +# include +#endif +#ifdef HAVE_STDINT_H +# include +#endif +#ifdef HAVE_UNISTD_H +# include +#endif" + +ac_subst_vars='am__EXEEXT_FALSE +am__EXEEXT_TRUE +LTLIBOBJS +LIBOBJS +pkgconfigdir +PTHREAD_CXX +PTHREAD_CXXFLAGS +PTHREAD_LIBS +acx_pthread_config +CXXCPP +am__fastdepCXX_FALSE +am__fastdepCXX_TRUE +CXXDEPMODE +ac_ct_CXX +CXXFLAGS +CXX +CPP +OTOOL64 +OTOOL +LIPO +NMEDIT +DSYMUTIL +MANIFEST_TOOL +RANLIB +LN_S +NM +ac_ct_DUMPBIN +DUMPBIN +LD +FGREP +EGREP +GREP +SED +host_os +host_vendor +host_cpu +host +build_os +build_vendor +build_cpu +build +LIBTOOL +OBJDUMP +DLLTOOL +AS +am__fastdepCC_FALSE +am__fastdepCC_TRUE +CCDEPMODE +am__nodep +AMDEPBACKSLASH +AMDEP_FALSE +AMDEP_TRUE +am__quote +am__include +DEPDIR +OBJEXT +EXEEXT +ac_ct_CC +CPPFLAGS +LDFLAGS +CFLAGS +CC +ac_ct_AR +AR +am__untar +am__tar +AMTAR +am__leading_dot +SET_MAKE +AWK +mkdir_p +MKDIR_P +INSTALL_STRIP_PROGRAM +STRIP +install_sh +MAKEINFO +AUTOHEADER +AUTOMAKE +AUTOCONF +ACLOCAL +VERSION +PACKAGE +CYGPATH_W +am__isrc +INSTALL_DATA +INSTALL_SCRIPT +INSTALL_PROGRAM +target_alias +host_alias +build_alias +LIBS +ECHO_T +ECHO_N +ECHO_C +DEFS +mandir +localedir +libdir +psdir +pdfdir +dvidir +htmldir +infodir +docdir +oldincludedir +includedir +localstatedir +sharedstatedir +sysconfdir +datadir +datarootdir +libexecdir +sbindir +bindir +program_transform_name +prefix +exec_prefix +PACKAGE_URL +PACKAGE_BUGREPORT +PACKAGE_STRING +PACKAGE_VERSION +PACKAGE_TARNAME +PACKAGE_NAME +PATH_SEPARATOR +SHELL' +ac_subst_files='' +ac_user_opts=' +enable_option_checking +enable_dependency_tracking +enable_shared +enable_static +with_pic +enable_fast_install +with_gnu_ld +with_sysroot +enable_libtool_lock +enable_threads +with_libodb +with_pkgconfigdir +enable_rpath +' + ac_precious_vars='build_alias +host_alias +target_alias +CC +CFLAGS +LDFLAGS +LIBS +CPPFLAGS +CPP +CXX +CXXFLAGS +CCC +CXXCPP' + + +# Initialize some variables set by options. +ac_init_help= +ac_init_version=false +ac_unrecognized_opts= +ac_unrecognized_sep= +# The variables have the same names as the options, with +# dashes changed to underlines. +cache_file=/dev/null +exec_prefix=NONE +no_create= +no_recursion= +prefix=NONE +program_prefix=NONE +program_suffix=NONE +program_transform_name=s,x,x, +silent= +site= +srcdir= +verbose= +x_includes=NONE +x_libraries=NONE + +# Installation directory options. +# These are left unexpanded so users can "make install exec_prefix=/foo" +# and all the variables that are supposed to be based on exec_prefix +# by default will actually change. +# Use braces instead of parens because sh, perl, etc. also accept them. +# (The list follows the same order as the GNU Coding Standards.) +bindir='${exec_prefix}/bin' +sbindir='${exec_prefix}/sbin' +libexecdir='${exec_prefix}/libexec' +datarootdir='${prefix}/share' +datadir='${datarootdir}' +sysconfdir='${prefix}/etc' +sharedstatedir='${prefix}/com' +localstatedir='${prefix}/var' +includedir='${prefix}/include' +oldincludedir='/usr/include' +docdir='${datarootdir}/doc/${PACKAGE_TARNAME}' +infodir='${datarootdir}/info' +htmldir='${docdir}' +dvidir='${docdir}' +pdfdir='${docdir}' +psdir='${docdir}' +libdir='${exec_prefix}/lib' +localedir='${datarootdir}/locale' +mandir='${datarootdir}/man' + +ac_prev= +ac_dashdash= +for ac_option +do + # If the previous option needs an argument, assign it. + if test -n "$ac_prev"; then + eval $ac_prev=\$ac_option + ac_prev= + continue + fi + + case $ac_option in + *=?*) ac_optarg=`expr "X$ac_option" : '[^=]*=\(.*\)'` ;; + *=) ac_optarg= ;; + *) ac_optarg=yes ;; + esac + + # Accept the important Cygnus configure options, so we can diagnose typos. + + case $ac_dashdash$ac_option in + --) + ac_dashdash=yes ;; + + -bindir | --bindir | --bindi | --bind | --bin | --bi) + ac_prev=bindir ;; + -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*) + bindir=$ac_optarg ;; + + -build | --build | --buil | --bui | --bu) + ac_prev=build_alias ;; + -build=* | --build=* | --buil=* | --bui=* | --bu=*) + build_alias=$ac_optarg ;; + + -cache-file | --cache-file | --cache-fil | --cache-fi \ + | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c) + ac_prev=cache_file ;; + -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \ + | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*) + cache_file=$ac_optarg ;; + + --config-cache | -C) + cache_file=config.cache ;; + + -datadir | --datadir | --datadi | --datad) + ac_prev=datadir ;; + -datadir=* | --datadir=* | --datadi=* | --datad=*) + datadir=$ac_optarg ;; + + -datarootdir | --datarootdir | --datarootdi | --datarootd | --dataroot \ + | --dataroo | --dataro | --datar) + ac_prev=datarootdir ;; + -datarootdir=* | --datarootdir=* | --datarootdi=* | --datarootd=* \ + | --dataroot=* | --dataroo=* | --dataro=* | --datar=*) + datarootdir=$ac_optarg ;; + + -disable-* | --disable-*) + ac_useropt=`expr "x$ac_option" : 'x-*disable-\(.*\)'` + # Reject names that are not valid shell variable names. + expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && + as_fn_error $? "invalid feature name: $ac_useropt" + ac_useropt_orig=$ac_useropt + ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` + case $ac_user_opts in + *" +"enable_$ac_useropt" +"*) ;; + *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--disable-$ac_useropt_orig" + ac_unrecognized_sep=', ';; + esac + eval enable_$ac_useropt=no ;; + + -docdir | --docdir | --docdi | --doc | --do) + ac_prev=docdir ;; + -docdir=* | --docdir=* | --docdi=* | --doc=* | --do=*) + docdir=$ac_optarg ;; + + -dvidir | --dvidir | --dvidi | --dvid | --dvi | --dv) + ac_prev=dvidir ;; + -dvidir=* | --dvidir=* | --dvidi=* | --dvid=* | --dvi=* | --dv=*) + dvidir=$ac_optarg ;; + + -enable-* | --enable-*) + ac_useropt=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'` + # Reject names that are not valid shell variable names. + expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && + as_fn_error $? "invalid feature name: $ac_useropt" + ac_useropt_orig=$ac_useropt + ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` + case $ac_user_opts in + *" +"enable_$ac_useropt" +"*) ;; + *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--enable-$ac_useropt_orig" + ac_unrecognized_sep=', ';; + esac + eval enable_$ac_useropt=\$ac_optarg ;; + + -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \ + | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \ + | --exec | --exe | --ex) + ac_prev=exec_prefix ;; + -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \ + | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \ + | --exec=* | --exe=* | --ex=*) + exec_prefix=$ac_optarg ;; + + -gas | --gas | --ga | --g) + # Obsolete; use --with-gas. + with_gas=yes ;; + + -help | --help | --hel | --he | -h) + ac_init_help=long ;; + -help=r* | --help=r* | --hel=r* | --he=r* | -hr*) + ac_init_help=recursive ;; + -help=s* | --help=s* | --hel=s* | --he=s* | -hs*) + ac_init_help=short ;; + + -host | --host | --hos | --ho) + ac_prev=host_alias ;; + -host=* | --host=* | --hos=* | --ho=*) + host_alias=$ac_optarg ;; + + -htmldir | --htmldir | --htmldi | --htmld | --html | --htm | --ht) + ac_prev=htmldir ;; + -htmldir=* | --htmldir=* | --htmldi=* | --htmld=* | --html=* | --htm=* \ + | --ht=*) + htmldir=$ac_optarg ;; + + -includedir | --includedir | --includedi | --included | --include \ + | --includ | --inclu | --incl | --inc) + ac_prev=includedir ;; + -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \ + | --includ=* | --inclu=* | --incl=* | --inc=*) + includedir=$ac_optarg ;; + + -infodir | --infodir | --infodi | --infod | --info | --inf) + ac_prev=infodir ;; + -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*) + infodir=$ac_optarg ;; + + -libdir | --libdir | --libdi | --libd) + ac_prev=libdir ;; + -libdir=* | --libdir=* | --libdi=* | --libd=*) + libdir=$ac_optarg ;; + + -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \ + | --libexe | --libex | --libe) + ac_prev=libexecdir ;; + -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \ + | --libexe=* | --libex=* | --libe=*) + libexecdir=$ac_optarg ;; + + -localedir | --localedir | --localedi | --localed | --locale) + ac_prev=localedir ;; + -localedir=* | --localedir=* | --localedi=* | --localed=* | --locale=*) + localedir=$ac_optarg ;; + + -localstatedir | --localstatedir | --localstatedi | --localstated \ + | --localstate | --localstat | --localsta | --localst | --locals) + ac_prev=localstatedir ;; + -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \ + | --localstate=* | --localstat=* | --localsta=* | --localst=* | --locals=*) + localstatedir=$ac_optarg ;; + + -mandir | --mandir | --mandi | --mand | --man | --ma | --m) + ac_prev=mandir ;; + -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*) + mandir=$ac_optarg ;; + + -nfp | --nfp | --nf) + # Obsolete; use --without-fp. + with_fp=no ;; + + -no-create | --no-create | --no-creat | --no-crea | --no-cre \ + | --no-cr | --no-c | -n) + no_create=yes ;; + + -no-recursion | --no-recursion | --no-recursio | --no-recursi \ + | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r) + no_recursion=yes ;; + + -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \ + | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \ + | --oldin | --oldi | --old | --ol | --o) + ac_prev=oldincludedir ;; + -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \ + | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \ + | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*) + oldincludedir=$ac_optarg ;; + + -prefix | --prefix | --prefi | --pref | --pre | --pr | --p) + ac_prev=prefix ;; + -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*) + prefix=$ac_optarg ;; + + -program-prefix | --program-prefix | --program-prefi | --program-pref \ + | --program-pre | --program-pr | --program-p) + ac_prev=program_prefix ;; + -program-prefix=* | --program-prefix=* | --program-prefi=* \ + | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*) + program_prefix=$ac_optarg ;; + + -program-suffix | --program-suffix | --program-suffi | --program-suff \ + | --program-suf | --program-su | --program-s) + ac_prev=program_suffix ;; + -program-suffix=* | --program-suffix=* | --program-suffi=* \ + | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*) + program_suffix=$ac_optarg ;; + + -program-transform-name | --program-transform-name \ + | --program-transform-nam | --program-transform-na \ + | --program-transform-n | --program-transform- \ + | --program-transform | --program-transfor \ + | --program-transfo | --program-transf \ + | --program-trans | --program-tran \ + | --progr-tra | --program-tr | --program-t) + ac_prev=program_transform_name ;; + -program-transform-name=* | --program-transform-name=* \ + | --program-transform-nam=* | --program-transform-na=* \ + | --program-transform-n=* | --program-transform-=* \ + | --program-transform=* | --program-transfor=* \ + | --program-transfo=* | --program-transf=* \ + | --program-trans=* | --program-tran=* \ + | --progr-tra=* | --program-tr=* | --program-t=*) + program_transform_name=$ac_optarg ;; + + -pdfdir | --pdfdir | --pdfdi | --pdfd | --pdf | --pd) + ac_prev=pdfdir ;; + -pdfdir=* | --pdfdir=* | --pdfdi=* | --pdfd=* | --pdf=* | --pd=*) + pdfdir=$ac_optarg ;; + + -psdir | --psdir | --psdi | --psd | --ps) + ac_prev=psdir ;; + -psdir=* | --psdir=* | --psdi=* | --psd=* | --ps=*) + psdir=$ac_optarg ;; + + -q | -quiet | --quiet | --quie | --qui | --qu | --q \ + | -silent | --silent | --silen | --sile | --sil) + silent=yes ;; + + -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb) + ac_prev=sbindir ;; + -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \ + | --sbi=* | --sb=*) + sbindir=$ac_optarg ;; + + -sharedstatedir | --sharedstatedir | --sharedstatedi \ + | --sharedstated | --sharedstate | --sharedstat | --sharedsta \ + | --sharedst | --shareds | --shared | --share | --shar \ + | --sha | --sh) + ac_prev=sharedstatedir ;; + -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \ + | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \ + | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \ + | --sha=* | --sh=*) + sharedstatedir=$ac_optarg ;; + + -site | --site | --sit) + ac_prev=site ;; + -site=* | --site=* | --sit=*) + site=$ac_optarg ;; + + -srcdir | --srcdir | --srcdi | --srcd | --src | --sr) + ac_prev=srcdir ;; + -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*) + srcdir=$ac_optarg ;; + + -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \ + | --syscon | --sysco | --sysc | --sys | --sy) + ac_prev=sysconfdir ;; + -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \ + | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*) + sysconfdir=$ac_optarg ;; + + -target | --target | --targe | --targ | --tar | --ta | --t) + ac_prev=target_alias ;; + -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*) + target_alias=$ac_optarg ;; + + -v | -verbose | --verbose | --verbos | --verbo | --verb) + verbose=yes ;; + + -version | --version | --versio | --versi | --vers | -V) + ac_init_version=: ;; + + -with-* | --with-*) + ac_useropt=`expr "x$ac_option" : 'x-*with-\([^=]*\)'` + # Reject names that are not valid shell variable names. + expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && + as_fn_error $? "invalid package name: $ac_useropt" + ac_useropt_orig=$ac_useropt + ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` + case $ac_user_opts in + *" +"with_$ac_useropt" +"*) ;; + *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--with-$ac_useropt_orig" + ac_unrecognized_sep=', ';; + esac + eval with_$ac_useropt=\$ac_optarg ;; + + -without-* | --without-*) + ac_useropt=`expr "x$ac_option" : 'x-*without-\(.*\)'` + # Reject names that are not valid shell variable names. + expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && + as_fn_error $? "invalid package name: $ac_useropt" + ac_useropt_orig=$ac_useropt + ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` + case $ac_user_opts in + *" +"with_$ac_useropt" +"*) ;; + *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--without-$ac_useropt_orig" + ac_unrecognized_sep=', ';; + esac + eval with_$ac_useropt=no ;; + + --x) + # Obsolete; use --with-x. + with_x=yes ;; + + -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \ + | --x-incl | --x-inc | --x-in | --x-i) + ac_prev=x_includes ;; + -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \ + | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*) + x_includes=$ac_optarg ;; + + -x-libraries | --x-libraries | --x-librarie | --x-librari \ + | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l) + ac_prev=x_libraries ;; + -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \ + | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*) + x_libraries=$ac_optarg ;; + + -*) as_fn_error $? "unrecognized option: \`$ac_option' +Try \`$0 --help' for more information" + ;; + + *=*) + ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='` + # Reject names that are not valid shell variable names. + case $ac_envvar in #( + '' | [0-9]* | *[!_$as_cr_alnum]* ) + as_fn_error $? "invalid variable name: \`$ac_envvar'" ;; + esac + eval $ac_envvar=\$ac_optarg + export $ac_envvar ;; + + *) + # FIXME: should be removed in autoconf 3.0. + $as_echo "$as_me: WARNING: you should use --build, --host, --target" >&2 + expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null && + $as_echo "$as_me: WARNING: invalid host type: $ac_option" >&2 + : "${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}" + ;; + + esac +done + +if test -n "$ac_prev"; then + ac_option=--`echo $ac_prev | sed 's/_/-/g'` + as_fn_error $? "missing argument to $ac_option" +fi + +if test -n "$ac_unrecognized_opts"; then + case $enable_option_checking in + no) ;; + fatal) as_fn_error $? "unrecognized options: $ac_unrecognized_opts" ;; + *) $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;; + esac +fi + +# Check all directory arguments for consistency. +for ac_var in exec_prefix prefix bindir sbindir libexecdir datarootdir \ + datadir sysconfdir sharedstatedir localstatedir includedir \ + oldincludedir docdir infodir htmldir dvidir pdfdir psdir \ + libdir localedir mandir +do + eval ac_val=\$$ac_var + # Remove trailing slashes. + case $ac_val in + */ ) + ac_val=`expr "X$ac_val" : 'X\(.*[^/]\)' \| "X$ac_val" : 'X\(.*\)'` + eval $ac_var=\$ac_val;; + esac + # Be sure to have absolute directory names. + case $ac_val in + [\\/$]* | ?:[\\/]* ) continue;; + NONE | '' ) case $ac_var in *prefix ) continue;; esac;; + esac + as_fn_error $? "expected an absolute directory name for --$ac_var: $ac_val" +done + +# There might be people who depend on the old broken behavior: `$host' +# used to hold the argument of --host etc. +# FIXME: To remove some day. +build=$build_alias +host=$host_alias +target=$target_alias + +# FIXME: To remove some day. +if test "x$host_alias" != x; then + if test "x$build_alias" = x; then + cross_compiling=maybe + elif test "x$build_alias" != "x$host_alias"; then + cross_compiling=yes + fi +fi + +ac_tool_prefix= +test -n "$host_alias" && ac_tool_prefix=$host_alias- + +test "$silent" = yes && exec 6>/dev/null + + +ac_pwd=`pwd` && test -n "$ac_pwd" && +ac_ls_di=`ls -di .` && +ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` || + as_fn_error $? "working directory cannot be determined" +test "X$ac_ls_di" = "X$ac_pwd_ls_di" || + as_fn_error $? "pwd does not report name of working directory" + + +# Find the source files, if location was not specified. +if test -z "$srcdir"; then + ac_srcdir_defaulted=yes + # Try the directory containing this script, then the parent directory. + ac_confdir=`$as_dirname -- "$as_myself" || +$as_expr X"$as_myself" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ + X"$as_myself" : 'X\(//\)[^/]' \| \ + X"$as_myself" : 'X\(//\)$' \| \ + X"$as_myself" : 'X\(/\)' \| . 2>/dev/null || +$as_echo X"$as_myself" | + sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ + s//\1/ + q + } + /^X\(\/\/\)[^/].*/{ + s//\1/ + q + } + /^X\(\/\/\)$/{ + s//\1/ + q + } + /^X\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q'` + srcdir=$ac_confdir + if test ! -r "$srcdir/$ac_unique_file"; then + srcdir=.. + fi +else + ac_srcdir_defaulted=no +fi +if test ! -r "$srcdir/$ac_unique_file"; then + test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .." + as_fn_error $? "cannot find sources ($ac_unique_file) in $srcdir" +fi +ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work" +ac_abs_confdir=`( + cd "$srcdir" && test -r "./$ac_unique_file" || as_fn_error $? "$ac_msg" + pwd)` +# When building in place, set srcdir=. +if test "$ac_abs_confdir" = "$ac_pwd"; then + srcdir=. +fi +# Remove unnecessary trailing slashes from srcdir. +# Double slashes in file names in object file debugging info +# mess up M-x gdb in Emacs. +case $srcdir in +*/) srcdir=`expr "X$srcdir" : 'X\(.*[^/]\)' \| "X$srcdir" : 'X\(.*\)'`;; +esac +for ac_var in $ac_precious_vars; do + eval ac_env_${ac_var}_set=\${${ac_var}+set} + eval ac_env_${ac_var}_value=\$${ac_var} + eval ac_cv_env_${ac_var}_set=\${${ac_var}+set} + eval ac_cv_env_${ac_var}_value=\$${ac_var} +done + +# +# Report the --help message. +# +if test "$ac_init_help" = "long"; then + # Omit some internal or obsolete options to make the list less imposing. + # This message is too long to be a string in the A/UX 3.1 sh. + cat <<_ACEOF +\`configure' configures libodb-sqlite 2.4.0 to adapt to many kinds of systems. + +Usage: $0 [OPTION]... [VAR=VALUE]... + +To assign environment variables (e.g., CC, CFLAGS...), specify them as +VAR=VALUE. See below for descriptions of some of the useful variables. + +Defaults for the options are specified in brackets. + +Configuration: + -h, --help display this help and exit + --help=short display options specific to this package + --help=recursive display the short help of all the included packages + -V, --version display version information and exit + -q, --quiet, --silent do not print \`checking ...' messages + --cache-file=FILE cache test results in FILE [disabled] + -C, --config-cache alias for \`--cache-file=config.cache' + -n, --no-create do not create output files + --srcdir=DIR find the sources in DIR [configure dir or \`..'] + +Installation directories: + --prefix=PREFIX install architecture-independent files in PREFIX + [$ac_default_prefix] + --exec-prefix=EPREFIX install architecture-dependent files in EPREFIX + [PREFIX] + +By default, \`make install' will install all the files in +\`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc. You can specify +an installation prefix other than \`$ac_default_prefix' using \`--prefix', +for instance \`--prefix=\$HOME'. + +For better control, use the options below. + +Fine tuning of the installation directories: + --bindir=DIR user executables [EPREFIX/bin] + --sbindir=DIR system admin executables [EPREFIX/sbin] + --libexecdir=DIR program executables [EPREFIX/libexec] + --sysconfdir=DIR read-only single-machine data [PREFIX/etc] + --sharedstatedir=DIR modifiable architecture-independent data [PREFIX/com] + --localstatedir=DIR modifiable single-machine data [PREFIX/var] + --libdir=DIR object code libraries [EPREFIX/lib] + --includedir=DIR C header files [PREFIX/include] + --oldincludedir=DIR C header files for non-gcc [/usr/include] + --datarootdir=DIR read-only arch.-independent data root [PREFIX/share] + --datadir=DIR read-only architecture-independent data [DATAROOTDIR] + --infodir=DIR info documentation [DATAROOTDIR/info] + --localedir=DIR locale-dependent data [DATAROOTDIR/locale] + --mandir=DIR man documentation [DATAROOTDIR/man] + --docdir=DIR documentation root [DATAROOTDIR/doc/libodb-sqlite] + --htmldir=DIR html documentation [DOCDIR] + --dvidir=DIR dvi documentation [DOCDIR] + --pdfdir=DIR pdf documentation [DOCDIR] + --psdir=DIR ps documentation [DOCDIR] +_ACEOF + + cat <<\_ACEOF + +Program names: + --program-prefix=PREFIX prepend PREFIX to installed program names + --program-suffix=SUFFIX append SUFFIX to installed program names + --program-transform-name=PROGRAM run sed PROGRAM on installed program names + +System types: + --build=BUILD configure for building on BUILD [guessed] + --host=HOST cross-compile to build programs to run on HOST [BUILD] +_ACEOF +fi + +if test -n "$ac_init_help"; then + case $ac_init_help in + short | recursive ) echo "Configuration of libodb-sqlite 2.4.0:";; + esac + cat <<\_ACEOF + +Optional Features: + --disable-option-checking ignore unrecognized --enable/--with options + --disable-FEATURE do not include FEATURE (same as --enable-FEATURE=no) + --enable-FEATURE[=ARG] include FEATURE [ARG=yes] + --enable-dependency-tracking + do not reject slow dependency extractors + --disable-dependency-tracking + speeds up one-time build + --enable-shared[=PKGS] build shared libraries [default=yes] + --enable-static[=PKGS] build static libraries [default=yes] + --enable-fast-install[=PKGS] + optimize for fast installation [default=yes] + --disable-libtool-lock avoid locking (might break parallel builds) + --disable-threads disable threads (enabled by default) + --disable-rpath patch libtool to not use rpath + +Optional Packages: + --with-PACKAGE[=ARG] use PACKAGE [ARG=yes] + --without-PACKAGE do not use PACKAGE (same as --with-PACKAGE=no) + --with-pic[=PKGS] try to use only PIC/non-PIC objects [default=use + both] + --with-gnu-ld assume the C compiler uses GNU ld [default=no] + --with-sysroot=DIR Search for dependent libraries within DIR + (or the compiler's sysroot if not specified). + --with-libodb=DIR location of libodb build directory + --with-pkgconfigdir=DIR location of pkgconfig dir (default is + libdir/pkgconfig) + +Some influential environment variables: + CC C compiler command + CFLAGS C compiler flags + LDFLAGS linker flags, e.g. -L if you have libraries in a + nonstandard directory + LIBS libraries to pass to the linker, e.g. -l + CPPFLAGS (Objective) C/C++ preprocessor flags, e.g. -I if + you have headers in a nonstandard directory + CPP C preprocessor + CXX C++ compiler command + CXXFLAGS C++ compiler flags + CXXCPP C++ preprocessor + +Use these variables to override the choices made by `configure' or to help +it to find libraries and programs with nonstandard names/locations. + +Report bugs to . +_ACEOF +ac_status=$? +fi + +if test "$ac_init_help" = "recursive"; then + # If there are subdirs, report their specific --help. + for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue + test -d "$ac_dir" || + { cd "$srcdir" && ac_pwd=`pwd` && srcdir=. && test -d "$ac_dir"; } || + continue + ac_builddir=. + +case "$ac_dir" in +.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;; +*) + ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'` + # A ".." for each directory in $ac_dir_suffix. + ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'` + case $ac_top_builddir_sub in + "") ac_top_builddir_sub=. ac_top_build_prefix= ;; + *) ac_top_build_prefix=$ac_top_builddir_sub/ ;; + esac ;; +esac +ac_abs_top_builddir=$ac_pwd +ac_abs_builddir=$ac_pwd$ac_dir_suffix +# for backward compatibility: +ac_top_builddir=$ac_top_build_prefix + +case $srcdir in + .) # We are building in place. + ac_srcdir=. + ac_top_srcdir=$ac_top_builddir_sub + ac_abs_top_srcdir=$ac_pwd ;; + [\\/]* | ?:[\\/]* ) # Absolute name. + ac_srcdir=$srcdir$ac_dir_suffix; + ac_top_srcdir=$srcdir + ac_abs_top_srcdir=$srcdir ;; + *) # Relative name. + ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix + ac_top_srcdir=$ac_top_build_prefix$srcdir + ac_abs_top_srcdir=$ac_pwd/$srcdir ;; +esac +ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix + + cd "$ac_dir" || { ac_status=$?; continue; } + # Check for guested configure. + if test -f "$ac_srcdir/configure.gnu"; then + echo && + $SHELL "$ac_srcdir/configure.gnu" --help=recursive + elif test -f "$ac_srcdir/configure"; then + echo && + $SHELL "$ac_srcdir/configure" --help=recursive + else + $as_echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2 + fi || ac_status=$? + cd "$ac_pwd" || { ac_status=$?; break; } + done +fi + +test -n "$ac_init_help" && exit $ac_status +if $ac_init_version; then + cat <<\_ACEOF +libodb-sqlite configure 2.4.0 +generated by GNU Autoconf 2.69 + +Copyright (C) 2012 Free Software Foundation, Inc. +This configure script is free software; the Free Software Foundation +gives unlimited permission to copy, distribute and modify it. +_ACEOF + exit +fi + +## ------------------------ ## +## Autoconf initialization. ## +## ------------------------ ## + +# ac_fn_c_try_compile LINENO +# -------------------------- +# Try to compile conftest.$ac_ext, and return whether this succeeded. +ac_fn_c_try_compile () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + rm -f conftest.$ac_objext + if { { ac_try="$ac_compile" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_compile") 2>conftest.err + ac_status=$? + if test -s conftest.err; then + grep -v '^ *+' conftest.err >conftest.er1 + cat conftest.er1 >&5 + mv -f conftest.er1 conftest.err + fi + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } && { + test -z "$ac_c_werror_flag" || + test ! -s conftest.err + } && test -s conftest.$ac_objext; then : + ac_retval=0 +else + $as_echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_retval=1 +fi + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno + as_fn_set_status $ac_retval + +} # ac_fn_c_try_compile + +# ac_fn_c_try_link LINENO +# ----------------------- +# Try to link conftest.$ac_ext, and return whether this succeeded. +ac_fn_c_try_link () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + rm -f conftest.$ac_objext conftest$ac_exeext + if { { ac_try="$ac_link" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_link") 2>conftest.err + ac_status=$? + if test -s conftest.err; then + grep -v '^ *+' conftest.err >conftest.er1 + cat conftest.er1 >&5 + mv -f conftest.er1 conftest.err + fi + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } && { + test -z "$ac_c_werror_flag" || + test ! -s conftest.err + } && test -s conftest$ac_exeext && { + test "$cross_compiling" = yes || + test -x conftest$ac_exeext + }; then : + ac_retval=0 +else + $as_echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_retval=1 +fi + # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information + # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would + # interfere with the next link command; also delete a directory that is + # left behind by Apple's compiler. We do this before executing the actions. + rm -rf conftest.dSYM conftest_ipa8_conftest.oo + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno + as_fn_set_status $ac_retval + +} # ac_fn_c_try_link + +# ac_fn_c_check_header_compile LINENO HEADER VAR INCLUDES +# ------------------------------------------------------- +# Tests whether HEADER exists and can be compiled using the include files in +# INCLUDES, setting the cache variable VAR accordingly. +ac_fn_c_check_header_compile () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 +$as_echo_n "checking for $2... " >&6; } +if eval \${$3+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +$4 +#include <$2> +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + eval "$3=yes" +else + eval "$3=no" +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +fi +eval ac_res=\$$3 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 +$as_echo "$ac_res" >&6; } + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno + +} # ac_fn_c_check_header_compile + +# ac_fn_c_try_cpp LINENO +# ---------------------- +# Try to preprocess conftest.$ac_ext, and return whether this succeeded. +ac_fn_c_try_cpp () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + if { { ac_try="$ac_cpp conftest.$ac_ext" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err + ac_status=$? + if test -s conftest.err; then + grep -v '^ *+' conftest.err >conftest.er1 + cat conftest.er1 >&5 + mv -f conftest.er1 conftest.err + fi + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } > conftest.i && { + test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" || + test ! -s conftest.err + }; then : + ac_retval=0 +else + $as_echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_retval=1 +fi + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno + as_fn_set_status $ac_retval + +} # ac_fn_c_try_cpp + +# ac_fn_c_try_run LINENO +# ---------------------- +# Try to link conftest.$ac_ext, and return whether this succeeded. Assumes +# that executables *can* be run. +ac_fn_c_try_run () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + if { { ac_try="$ac_link" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_link") 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } && { ac_try='./conftest$ac_exeext' + { { case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_try") 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; }; then : + ac_retval=0 +else + $as_echo "$as_me: program exited with status $ac_status" >&5 + $as_echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_retval=$ac_status +fi + rm -rf conftest.dSYM conftest_ipa8_conftest.oo + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno + as_fn_set_status $ac_retval + +} # ac_fn_c_try_run + +# ac_fn_c_check_func LINENO FUNC VAR +# ---------------------------------- +# Tests whether FUNC exists, setting the cache variable VAR accordingly +ac_fn_c_check_func () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 +$as_echo_n "checking for $2... " >&6; } +if eval \${$3+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +/* Define $2 to an innocuous variant, in case declares $2. + For example, HP-UX 11i declares gettimeofday. */ +#define $2 innocuous_$2 + +/* System header to define __stub macros and hopefully few prototypes, + which can conflict with char $2 (); below. + Prefer to if __STDC__ is defined, since + exists even on freestanding compilers. */ + +#ifdef __STDC__ +# include +#else +# include +#endif + +#undef $2 + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char $2 (); +/* The GNU C library defines this for functions which it implements + to always fail with ENOSYS. Some functions are actually named + something starting with __ and the normal name is an alias. */ +#if defined __stub_$2 || defined __stub___$2 +choke me +#endif + +int +main () +{ +return $2 (); + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + eval "$3=yes" +else + eval "$3=no" +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +fi +eval ac_res=\$$3 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 +$as_echo "$ac_res" >&6; } + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno + +} # ac_fn_c_check_func + +# ac_fn_cxx_try_compile LINENO +# ---------------------------- +# Try to compile conftest.$ac_ext, and return whether this succeeded. +ac_fn_cxx_try_compile () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + rm -f conftest.$ac_objext + if { { ac_try="$ac_compile" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_compile") 2>conftest.err + ac_status=$? + if test -s conftest.err; then + grep -v '^ *+' conftest.err >conftest.er1 + cat conftest.er1 >&5 + mv -f conftest.er1 conftest.err + fi + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } && { + test -z "$ac_cxx_werror_flag" || + test ! -s conftest.err + } && test -s conftest.$ac_objext; then : + ac_retval=0 +else + $as_echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_retval=1 +fi + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno + as_fn_set_status $ac_retval + +} # ac_fn_cxx_try_compile + +# ac_fn_cxx_try_cpp LINENO +# ------------------------ +# Try to preprocess conftest.$ac_ext, and return whether this succeeded. +ac_fn_cxx_try_cpp () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + if { { ac_try="$ac_cpp conftest.$ac_ext" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err + ac_status=$? + if test -s conftest.err; then + grep -v '^ *+' conftest.err >conftest.er1 + cat conftest.er1 >&5 + mv -f conftest.er1 conftest.err + fi + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } > conftest.i && { + test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" || + test ! -s conftest.err + }; then : + ac_retval=0 +else + $as_echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_retval=1 +fi + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno + as_fn_set_status $ac_retval + +} # ac_fn_cxx_try_cpp + +# ac_fn_cxx_try_link LINENO +# ------------------------- +# Try to link conftest.$ac_ext, and return whether this succeeded. +ac_fn_cxx_try_link () +{ + as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + rm -f conftest.$ac_objext conftest$ac_exeext + if { { ac_try="$ac_link" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_link") 2>conftest.err + ac_status=$? + if test -s conftest.err; then + grep -v '^ *+' conftest.err >conftest.er1 + cat conftest.er1 >&5 + mv -f conftest.er1 conftest.err + fi + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } && { + test -z "$ac_cxx_werror_flag" || + test ! -s conftest.err + } && test -s conftest$ac_exeext && { + test "$cross_compiling" = yes || + test -x conftest$ac_exeext + }; then : + ac_retval=0 +else + $as_echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_retval=1 +fi + # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information + # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would + # interfere with the next link command; also delete a directory that is + # left behind by Apple's compiler. We do this before executing the actions. + rm -rf conftest.dSYM conftest_ipa8_conftest.oo + eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno + as_fn_set_status $ac_retval + +} # ac_fn_cxx_try_link +cat >config.log <<_ACEOF +This file contains any messages produced by compilers while +running configure, to aid debugging if configure makes a mistake. + +It was created by libodb-sqlite $as_me 2.4.0, which was +generated by GNU Autoconf 2.69. Invocation command line was + + $ $0 $@ + +_ACEOF +exec 5>>config.log +{ +cat <<_ASUNAME +## --------- ## +## Platform. ## +## --------- ## + +hostname = `(hostname || uname -n) 2>/dev/null | sed 1q` +uname -m = `(uname -m) 2>/dev/null || echo unknown` +uname -r = `(uname -r) 2>/dev/null || echo unknown` +uname -s = `(uname -s) 2>/dev/null || echo unknown` +uname -v = `(uname -v) 2>/dev/null || echo unknown` + +/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown` +/bin/uname -X = `(/bin/uname -X) 2>/dev/null || echo unknown` + +/bin/arch = `(/bin/arch) 2>/dev/null || echo unknown` +/usr/bin/arch -k = `(/usr/bin/arch -k) 2>/dev/null || echo unknown` +/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown` +/usr/bin/hostinfo = `(/usr/bin/hostinfo) 2>/dev/null || echo unknown` +/bin/machine = `(/bin/machine) 2>/dev/null || echo unknown` +/usr/bin/oslevel = `(/usr/bin/oslevel) 2>/dev/null || echo unknown` +/bin/universe = `(/bin/universe) 2>/dev/null || echo unknown` + +_ASUNAME + +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + $as_echo "PATH: $as_dir" + done +IFS=$as_save_IFS + +} >&5 + +cat >&5 <<_ACEOF + + +## ----------- ## +## Core tests. ## +## ----------- ## + +_ACEOF + + +# Keep a trace of the command line. +# Strip out --no-create and --no-recursion so they do not pile up. +# Strip out --silent because we don't want to record it for future runs. +# Also quote any args containing shell meta-characters. +# Make two passes to allow for proper duplicate-argument suppression. +ac_configure_args= +ac_configure_args0= +ac_configure_args1= +ac_must_keep_next=false +for ac_pass in 1 2 +do + for ac_arg + do + case $ac_arg in + -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;; + -q | -quiet | --quiet | --quie | --qui | --qu | --q \ + | -silent | --silent | --silen | --sile | --sil) + continue ;; + *\'*) + ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;; + esac + case $ac_pass in + 1) as_fn_append ac_configure_args0 " '$ac_arg'" ;; + 2) + as_fn_append ac_configure_args1 " '$ac_arg'" + if test $ac_must_keep_next = true; then + ac_must_keep_next=false # Got value, back to normal. + else + case $ac_arg in + *=* | --config-cache | -C | -disable-* | --disable-* \ + | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \ + | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \ + | -with-* | --with-* | -without-* | --without-* | --x) + case "$ac_configure_args0 " in + "$ac_configure_args1"*" '$ac_arg' "* ) continue ;; + esac + ;; + -* ) ac_must_keep_next=true ;; + esac + fi + as_fn_append ac_configure_args " '$ac_arg'" + ;; + esac + done +done +{ ac_configure_args0=; unset ac_configure_args0;} +{ ac_configure_args1=; unset ac_configure_args1;} + +# When interrupted or exit'd, cleanup temporary files, and complete +# config.log. We remove comments because anyway the quotes in there +# would cause problems or look ugly. +# WARNING: Use '\'' to represent an apostrophe within the trap. +# WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug. +trap 'exit_status=$? + # Save into config.log some information that might help in debugging. + { + echo + + $as_echo "## ---------------- ## +## Cache variables. ## +## ---------------- ##" + echo + # The following way of writing the cache mishandles newlines in values, +( + for ac_var in `(set) 2>&1 | sed -n '\''s/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'\''`; do + eval ac_val=\$$ac_var + case $ac_val in #( + *${as_nl}*) + case $ac_var in #( + *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5 +$as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;; + esac + case $ac_var in #( + _ | IFS | as_nl) ;; #( + BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #( + *) { eval $ac_var=; unset $ac_var;} ;; + esac ;; + esac + done + (set) 2>&1 | + case $as_nl`(ac_space='\'' '\''; set) 2>&1` in #( + *${as_nl}ac_space=\ *) + sed -n \ + "s/'\''/'\''\\\\'\'''\''/g; + s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\''\\2'\''/p" + ;; #( + *) + sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p" + ;; + esac | + sort +) + echo + + $as_echo "## ----------------- ## +## Output variables. ## +## ----------------- ##" + echo + for ac_var in $ac_subst_vars + do + eval ac_val=\$$ac_var + case $ac_val in + *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;; + esac + $as_echo "$ac_var='\''$ac_val'\''" + done | sort + echo + + if test -n "$ac_subst_files"; then + $as_echo "## ------------------- ## +## File substitutions. ## +## ------------------- ##" + echo + for ac_var in $ac_subst_files + do + eval ac_val=\$$ac_var + case $ac_val in + *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;; + esac + $as_echo "$ac_var='\''$ac_val'\''" + done | sort + echo + fi + + if test -s confdefs.h; then + $as_echo "## ----------- ## +## confdefs.h. ## +## ----------- ##" + echo + cat confdefs.h + echo + fi + test "$ac_signal" != 0 && + $as_echo "$as_me: caught signal $ac_signal" + $as_echo "$as_me: exit $exit_status" + } >&5 + rm -f core *.core core.conftest.* && + rm -f -r conftest* confdefs* conf$$* $ac_clean_files && + exit $exit_status +' 0 +for ac_signal in 1 2 13 15; do + trap 'ac_signal='$ac_signal'; as_fn_exit 1' $ac_signal +done +ac_signal=0 + +# confdefs.h avoids OS command line length limits that DEFS can exceed. +rm -f -r conftest* confdefs.h + +$as_echo "/* confdefs.h */" > confdefs.h + +# Predefined preprocessor variables. + +cat >>confdefs.h <<_ACEOF +#define PACKAGE_NAME "$PACKAGE_NAME" +_ACEOF + +cat >>confdefs.h <<_ACEOF +#define PACKAGE_TARNAME "$PACKAGE_TARNAME" +_ACEOF + +cat >>confdefs.h <<_ACEOF +#define PACKAGE_VERSION "$PACKAGE_VERSION" +_ACEOF + +cat >>confdefs.h <<_ACEOF +#define PACKAGE_STRING "$PACKAGE_STRING" +_ACEOF + +cat >>confdefs.h <<_ACEOF +#define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT" +_ACEOF + +cat >>confdefs.h <<_ACEOF +#define PACKAGE_URL "$PACKAGE_URL" +_ACEOF + + +# Let the site file select an alternate cache file if it wants to. +# Prefer an explicitly selected file to automatically selected ones. +ac_site_file1=NONE +ac_site_file2=NONE +if test -n "$CONFIG_SITE"; then + # We do not want a PATH search for config.site. + case $CONFIG_SITE in #(( + -*) ac_site_file1=./$CONFIG_SITE;; + */*) ac_site_file1=$CONFIG_SITE;; + *) ac_site_file1=./$CONFIG_SITE;; + esac +elif test "x$prefix" != xNONE; then + ac_site_file1=$prefix/share/config.site + ac_site_file2=$prefix/etc/config.site +else + ac_site_file1=$ac_default_prefix/share/config.site + ac_site_file2=$ac_default_prefix/etc/config.site +fi +for ac_site_file in "$ac_site_file1" "$ac_site_file2" +do + test "x$ac_site_file" = xNONE && continue + if test /dev/null != "$ac_site_file" && test -r "$ac_site_file"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5 +$as_echo "$as_me: loading site script $ac_site_file" >&6;} + sed 's/^/| /' "$ac_site_file" >&5 + . "$ac_site_file" \ + || { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 +$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} +as_fn_error $? "failed to load site script $ac_site_file +See \`config.log' for more details" "$LINENO" 5; } + fi +done + +if test -r "$cache_file"; then + # Some versions of bash will fail to source /dev/null (special files + # actually), so we avoid doing that. DJGPP emulates it as a regular file. + if test /dev/null != "$cache_file" && test -f "$cache_file"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5 +$as_echo "$as_me: loading cache $cache_file" >&6;} + case $cache_file in + [\\/]* | ?:[\\/]* ) . "$cache_file";; + *) . "./$cache_file";; + esac + fi +else + { $as_echo "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5 +$as_echo "$as_me: creating cache $cache_file" >&6;} + >$cache_file +fi + +# Check that the precious variables saved in the cache have kept the same +# value. +ac_cache_corrupted=false +for ac_var in $ac_precious_vars; do + eval ac_old_set=\$ac_cv_env_${ac_var}_set + eval ac_new_set=\$ac_env_${ac_var}_set + eval ac_old_val=\$ac_cv_env_${ac_var}_value + eval ac_new_val=\$ac_env_${ac_var}_value + case $ac_old_set,$ac_new_set in + set,) + { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5 +$as_echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;} + ac_cache_corrupted=: ;; + ,set) + { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was not set in the previous run" >&5 +$as_echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;} + ac_cache_corrupted=: ;; + ,);; + *) + if test "x$ac_old_val" != "x$ac_new_val"; then + # differences in whitespace do not lead to failure. + ac_old_val_w=`echo x $ac_old_val` + ac_new_val_w=`echo x $ac_new_val` + if test "$ac_old_val_w" != "$ac_new_val_w"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' has changed since the previous run:" >&5 +$as_echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;} + ac_cache_corrupted=: + else + { $as_echo "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5 +$as_echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;} + eval $ac_var=\$ac_old_val + fi + { $as_echo "$as_me:${as_lineno-$LINENO}: former value: \`$ac_old_val'" >&5 +$as_echo "$as_me: former value: \`$ac_old_val'" >&2;} + { $as_echo "$as_me:${as_lineno-$LINENO}: current value: \`$ac_new_val'" >&5 +$as_echo "$as_me: current value: \`$ac_new_val'" >&2;} + fi;; + esac + # Pass precious variables to config.status. + if test "$ac_new_set" = set; then + case $ac_new_val in + *\'*) ac_arg=$ac_var=`$as_echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;; + *) ac_arg=$ac_var=$ac_new_val ;; + esac + case " $ac_configure_args " in + *" '$ac_arg' "*) ;; # Avoid dups. Use of quotes ensures accuracy. + *) as_fn_append ac_configure_args " '$ac_arg'" ;; + esac + fi +done +if $ac_cache_corrupted; then + { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 +$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} + { $as_echo "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5 +$as_echo "$as_me: error: changes in the environment can compromise the build" >&2;} + as_fn_error $? "run \`make distclean' and/or \`rm $cache_file' and start over" "$LINENO" 5 +fi +## -------------------- ## +## Main body of script. ## +## -------------------- ## + +ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu + + +ac_aux_dir= +for ac_dir in config "$srcdir"/config; do + if test -f "$ac_dir/install-sh"; then + ac_aux_dir=$ac_dir + ac_install_sh="$ac_aux_dir/install-sh -c" + break + elif test -f "$ac_dir/install.sh"; then + ac_aux_dir=$ac_dir + ac_install_sh="$ac_aux_dir/install.sh -c" + break + elif test -f "$ac_dir/shtool"; then + ac_aux_dir=$ac_dir + ac_install_sh="$ac_aux_dir/shtool install -c" + break + fi +done +if test -z "$ac_aux_dir"; then + as_fn_error $? "cannot find install-sh, install.sh, or shtool in config \"$srcdir\"/config" "$LINENO" 5 +fi + +# These three variables are undocumented and unsupported, +# and are intended to be withdrawn in a future Autoconf release. +# They can cause serious problems if a builder's source tree is in a directory +# whose full name contains unusual characters. +ac_config_guess="$SHELL $ac_aux_dir/config.guess" # Please don't use this var. +ac_config_sub="$SHELL $ac_aux_dir/config.sub" # Please don't use this var. +ac_configure="$SHELL $ac_aux_dir/configure" # Please don't use this var. + + + + + +am__api_version='1.12' + +# Find a good install program. We prefer a C program (faster), +# so one script is as good as another. But avoid the broken or +# incompatible versions: +# SysV /etc/install, /usr/sbin/install +# SunOS /usr/etc/install +# IRIX /sbin/install +# AIX /bin/install +# AmigaOS /C/install, which installs bootblocks on floppy discs +# AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag +# AFS /usr/afsws/bin/install, which mishandles nonexistent args +# SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff" +# OS/2's system install, which has a completely different semantic +# ./install, which can be erroneously created by make from ./install.sh. +# Reject install programs that cannot install multiple files. +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for a BSD-compatible install" >&5 +$as_echo_n "checking for a BSD-compatible install... " >&6; } +if test -z "$INSTALL"; then +if ${ac_cv_path_install+:} false; then : + $as_echo_n "(cached) " >&6 +else + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + # Account for people who put trailing slashes in PATH elements. +case $as_dir/ in #(( + ./ | .// | /[cC]/* | \ + /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \ + ?:[\\/]os2[\\/]install[\\/]* | ?:[\\/]OS2[\\/]INSTALL[\\/]* | \ + /usr/ucb/* ) ;; + *) + # OSF1 and SCO ODT 3.0 have their own names for install. + # Don't use installbsd from OSF since it installs stuff as root + # by default. + for ac_prog in ginstall scoinst install; do + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then + if test $ac_prog = install && + grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then + # AIX install. It has an incompatible calling convention. + : + elif test $ac_prog = install && + grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then + # program-specific install script used by HP pwplus--don't use. + : + else + rm -rf conftest.one conftest.two conftest.dir + echo one > conftest.one + echo two > conftest.two + mkdir conftest.dir + if "$as_dir/$ac_prog$ac_exec_ext" -c conftest.one conftest.two "`pwd`/conftest.dir" && + test -s conftest.one && test -s conftest.two && + test -s conftest.dir/conftest.one && + test -s conftest.dir/conftest.two + then + ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c" + break 3 + fi + fi + fi + done + done + ;; +esac + + done +IFS=$as_save_IFS + +rm -rf conftest.one conftest.two conftest.dir + +fi + if test "${ac_cv_path_install+set}" = set; then + INSTALL=$ac_cv_path_install + else + # As a last resort, use the slow shell script. Don't cache a + # value for INSTALL within a source directory, because that will + # break other packages using the cache if that directory is + # removed, or if the value is a relative name. + INSTALL=$ac_install_sh + fi +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $INSTALL" >&5 +$as_echo "$INSTALL" >&6; } + +# Use test -z because SunOS4 sh mishandles braces in ${var-val}. +# It thinks the first close brace ends the variable substitution. +test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}' + +test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}' + +test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644' + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether build environment is sane" >&5 +$as_echo_n "checking whether build environment is sane... " >&6; } +# Reject unsafe characters in $srcdir or the absolute working directory +# name. Accept space and tab only in the latter. +am_lf=' +' +case `pwd` in + *[\\\"\#\$\&\'\`$am_lf]*) + as_fn_error $? "unsafe absolute working directory name" "$LINENO" 5;; +esac +case $srcdir in + *[\\\"\#\$\&\'\`$am_lf\ \ ]*) + as_fn_error $? "unsafe srcdir value: '$srcdir'" "$LINENO" 5;; +esac + +# Do 'set' in a subshell so we don't clobber the current shell's +# arguments. Must try -L first in case configure is actually a +# symlink; some systems play weird games with the mod time of symlinks +# (eg FreeBSD returns the mod time of the symlink's containing +# directory). +if ( + am_has_slept=no + for am_try in 1 2; do + echo "timestamp, slept: $am_has_slept" > conftest.file + set X `ls -Lt "$srcdir/configure" conftest.file 2> /dev/null` + if test "$*" = "X"; then + # -L didn't work. + set X `ls -t "$srcdir/configure" conftest.file` + fi + if test "$*" != "X $srcdir/configure conftest.file" \ + && test "$*" != "X conftest.file $srcdir/configure"; then + + # If neither matched, then we have a broken ls. This can happen + # if, for instance, CONFIG_SHELL is bash and it inherits a + # broken ls alias from the environment. This has actually + # happened. Such a system could not be considered "sane". + as_fn_error $? "ls -t appears to fail. Make sure there is not a broken + alias in your environment" "$LINENO" 5 + fi + if test "$2" = conftest.file || test $am_try -eq 2; then + break + fi + # Just in case. + sleep 1 + am_has_slept=yes + done + test "$2" = conftest.file + ) +then + # Ok. + : +else + as_fn_error $? "newly created file is older than distributed files! +Check your system clock" "$LINENO" 5 +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +$as_echo "yes" >&6; } +# If we didn't sleep, we still need to ensure time stamps of config.status and +# generated files are strictly newer. +am_sleep_pid= +if grep 'slept: no' conftest.file >/dev/null 2>&1; then + ( sleep 1 ) & + am_sleep_pid=$! +fi + +rm -f conftest.file + +test "$program_prefix" != NONE && + program_transform_name="s&^&$program_prefix&;$program_transform_name" +# Use a double $ so make ignores it. +test "$program_suffix" != NONE && + program_transform_name="s&\$&$program_suffix&;$program_transform_name" +# Double any \ or $. +# By default was `s,x,x', remove it if useless. +ac_script='s/[\\$]/&&/g;s/;s,x,x,$//' +program_transform_name=`$as_echo "$program_transform_name" | sed "$ac_script"` + +# expand $ac_aux_dir to an absolute path +am_aux_dir=`cd $ac_aux_dir && pwd` + +if test x"${MISSING+set}" != xset; then + case $am_aux_dir in + *\ * | *\ *) + MISSING="\${SHELL} \"$am_aux_dir/missing\"" ;; + *) + MISSING="\${SHELL} $am_aux_dir/missing" ;; + esac +fi +# Use eval to expand $SHELL +if eval "$MISSING --run true"; then + am_missing_run="$MISSING --run " +else + am_missing_run= + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: 'missing' script is too old or missing" >&5 +$as_echo "$as_me: WARNING: 'missing' script is too old or missing" >&2;} +fi + +if test x"${install_sh}" != xset; then + case $am_aux_dir in + *\ * | *\ *) + install_sh="\${SHELL} '$am_aux_dir/install-sh'" ;; + *) + install_sh="\${SHELL} $am_aux_dir/install-sh" + esac +fi + +# Installed binaries are usually stripped using 'strip' when the user +# run "make install-strip". However 'strip' might not be the right +# tool to use in cross-compilation environments, therefore Automake +# will honor the 'STRIP' environment variable to overrule this program. +if test "$cross_compiling" != no; then + if test -n "$ac_tool_prefix"; then + # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args. +set dummy ${ac_tool_prefix}strip; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_STRIP+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$STRIP"; then + ac_cv_prog_STRIP="$STRIP" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_STRIP="${ac_tool_prefix}strip" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +STRIP=$ac_cv_prog_STRIP +if test -n "$STRIP"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5 +$as_echo "$STRIP" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test -z "$ac_cv_prog_STRIP"; then + ac_ct_STRIP=$STRIP + # Extract the first word of "strip", so it can be a program name with args. +set dummy strip; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_ac_ct_STRIP+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_STRIP"; then + ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_STRIP="strip" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP +if test -n "$ac_ct_STRIP"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_STRIP" >&5 +$as_echo "$ac_ct_STRIP" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + if test "x$ac_ct_STRIP" = x; then + STRIP=":" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + STRIP=$ac_ct_STRIP + fi +else + STRIP="$ac_cv_prog_STRIP" +fi + +fi +INSTALL_STRIP_PROGRAM="\$(install_sh) -c -s" + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for a thread-safe mkdir -p" >&5 +$as_echo_n "checking for a thread-safe mkdir -p... " >&6; } +if test -z "$MKDIR_P"; then + if ${ac_cv_path_mkdir+:} false; then : + $as_echo_n "(cached) " >&6 +else + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH$PATH_SEPARATOR/opt/sfw/bin +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_prog in mkdir gmkdir; do + for ac_exec_ext in '' $ac_executable_extensions; do + as_fn_executable_p "$as_dir/$ac_prog$ac_exec_ext" || continue + case `"$as_dir/$ac_prog$ac_exec_ext" --version 2>&1` in #( + 'mkdir (GNU coreutils) '* | \ + 'mkdir (coreutils) '* | \ + 'mkdir (fileutils) '4.1*) + ac_cv_path_mkdir=$as_dir/$ac_prog$ac_exec_ext + break 3;; + esac + done + done + done +IFS=$as_save_IFS + +fi + + test -d ./--version && rmdir ./--version + if test "${ac_cv_path_mkdir+set}" = set; then + MKDIR_P="$ac_cv_path_mkdir -p" + else + # As a last resort, use the slow shell script. Don't cache a + # value for MKDIR_P within a source directory, because that will + # break other packages using the cache if that directory is + # removed, or if the value is a relative name. + MKDIR_P="$ac_install_sh -d" + fi +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR_P" >&5 +$as_echo "$MKDIR_P" >&6; } + +for ac_prog in gawk mawk nawk awk +do + # Extract the first word of "$ac_prog", so it can be a program name with args. +set dummy $ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_AWK+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$AWK"; then + ac_cv_prog_AWK="$AWK" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_AWK="$ac_prog" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +AWK=$ac_cv_prog_AWK +if test -n "$AWK"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5 +$as_echo "$AWK" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$AWK" && break +done + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${MAKE-make} sets \$(MAKE)" >&5 +$as_echo_n "checking whether ${MAKE-make} sets \$(MAKE)... " >&6; } +set x ${MAKE-make} +ac_make=`$as_echo "$2" | sed 's/+/p/g; s/[^a-zA-Z0-9_]/_/g'` +if eval \${ac_cv_prog_make_${ac_make}_set+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat >conftest.make <<\_ACEOF +SHELL = /bin/sh +all: + @echo '@@@%%%=$(MAKE)=@@@%%%' +_ACEOF +# GNU make sometimes prints "make[1]: Entering ...", which would confuse us. +case `${MAKE-make} -f conftest.make 2>/dev/null` in + *@@@%%%=?*=@@@%%%*) + eval ac_cv_prog_make_${ac_make}_set=yes;; + *) + eval ac_cv_prog_make_${ac_make}_set=no;; +esac +rm -f conftest.make +fi +if eval test \$ac_cv_prog_make_${ac_make}_set = yes; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +$as_echo "yes" >&6; } + SET_MAKE= +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } + SET_MAKE="MAKE=${MAKE-make}" +fi + +rm -rf .tst 2>/dev/null +mkdir .tst 2>/dev/null +if test -d .tst; then + am__leading_dot=. +else + am__leading_dot=_ +fi +rmdir .tst 2>/dev/null + +if test "`cd $srcdir && pwd`" != "`pwd`"; then + # Use -I$(srcdir) only when $(srcdir) != ., so that make's output + # is not polluted with repeated "-I." + am__isrc=' -I$(srcdir)' + # test to see if srcdir already configured + if test -f $srcdir/config.status; then + as_fn_error $? "source directory already configured; run \"make distclean\" there first" "$LINENO" 5 + fi +fi + +# test whether we have cygpath +if test -z "$CYGPATH_W"; then + if (cygpath --version) >/dev/null 2>/dev/null; then + CYGPATH_W='cygpath -w' + else + CYGPATH_W=echo + fi +fi + + +# Define the identity of the package. + PACKAGE='libodb-sqlite' + VERSION='2.4.0' + + +cat >>confdefs.h <<_ACEOF +#define PACKAGE "$PACKAGE" +_ACEOF + + +cat >>confdefs.h <<_ACEOF +#define VERSION "$VERSION" +_ACEOF + +# Some tools Automake needs. + +ACLOCAL=${ACLOCAL-"${am_missing_run}aclocal-${am__api_version}"} + + +AUTOCONF=${AUTOCONF-"${am_missing_run}autoconf"} + + +AUTOMAKE=${AUTOMAKE-"${am_missing_run}automake-${am__api_version}"} + + +AUTOHEADER=${AUTOHEADER-"${am_missing_run}autoheader"} + + +MAKEINFO=${MAKEINFO-"${am_missing_run}makeinfo"} + +# For better backward compatibility. To be removed once Automake 1.9.x +# dies out for good. For more background, see: +# +# +mkdir_p='$(MKDIR_P)' + +# We need awk for the "check" target. The system "awk" is bad on +# some platforms. +# Always define AMTAR for backward compatibility. Yes, it's still used +# in the wild :-( We should find a proper way to deprecate it ... +AMTAR='$${TAR-tar}' + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to create a ustar tar archive" >&5 +$as_echo_n "checking how to create a ustar tar archive... " >&6; } +# Loop over all known methods to create a tar archive until one works. +_am_tools='gnutar plaintar pax cpio none' +_am_tools=${am_cv_prog_tar_ustar-$_am_tools} +# Do not fold the above two line into one, because Tru64 sh and +# Solaris sh will not grok spaces in the rhs of '-'. +for _am_tool in $_am_tools +do + case $_am_tool in + gnutar) + for _am_tar in tar gnutar gtar; + do + { echo "$as_me:$LINENO: $_am_tar --version" >&5 + ($_am_tar --version) >&5 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && break + done + am__tar="$_am_tar --format=ustar -chf - "'"$$tardir"' + am__tar_="$_am_tar --format=ustar -chf - "'"$tardir"' + am__untar="$_am_tar -xf -" + ;; + plaintar) + # Must skip GNU tar: if it does not support --format= it doesn't create + # ustar tarball either. + (tar --version) >/dev/null 2>&1 && continue + am__tar='tar chf - "$$tardir"' + am__tar_='tar chf - "$tardir"' + am__untar='tar xf -' + ;; + pax) + am__tar='pax -L -x ustar -w "$$tardir"' + am__tar_='pax -L -x ustar -w "$tardir"' + am__untar='pax -r' + ;; + cpio) + am__tar='find "$$tardir" -print | cpio -o -H ustar -L' + am__tar_='find "$tardir" -print | cpio -o -H ustar -L' + am__untar='cpio -i -H ustar -d' + ;; + none) + am__tar=false + am__tar_=false + am__untar=false + ;; + esac + + # If the value was cached, stop now. We just wanted to have am__tar + # and am__untar set. + test -n "${am_cv_prog_tar_ustar}" && break + + # tar/untar a dummy directory, and stop if the command works + rm -rf conftest.dir + mkdir conftest.dir + echo GrepMe > conftest.dir/file + { echo "$as_me:$LINENO: tardir=conftest.dir && eval $am__tar_ >conftest.tar" >&5 + (tardir=conftest.dir && eval $am__tar_ >conftest.tar) >&5 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } + rm -rf conftest.dir + if test -s conftest.tar; then + { echo "$as_me:$LINENO: $am__untar &5 + ($am__untar &5 2>&5 + ac_status=$? + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } + grep GrepMe conftest.dir/file >/dev/null 2>&1 && break + fi +done +rm -rf conftest.dir + +if ${am_cv_prog_tar_ustar+:} false; then : + $as_echo_n "(cached) " >&6 +else + am_cv_prog_tar_ustar=$_am_tool +fi + +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_prog_tar_ustar" >&5 +$as_echo "$am_cv_prog_tar_ustar" >&6; } + + + + + +DEPDIR="${am__leading_dot}deps" + +ac_config_commands="$ac_config_commands depfiles" + + +am_make=${MAKE-make} +cat > confinc << 'END' +am__doit: + @echo this is the am__doit target +.PHONY: am__doit +END +# If we don't find an include directive, just comment out the code. +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for style of include used by $am_make" >&5 +$as_echo_n "checking for style of include used by $am_make... " >&6; } +am__include="#" +am__quote= +_am_result=none +# First try GNU make style include. +echo "include confinc" > confmf +# Ignore all kinds of additional output from 'make'. +case `$am_make -s -f confmf 2> /dev/null` in #( +*the\ am__doit\ target*) + am__include=include + am__quote= + _am_result=GNU + ;; +esac +# Now try BSD make style include. +if test "$am__include" = "#"; then + echo '.include "confinc"' > confmf + case `$am_make -s -f confmf 2> /dev/null` in #( + *the\ am__doit\ target*) + am__include=.include + am__quote="\"" + _am_result=BSD + ;; + esac +fi + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $_am_result" >&5 +$as_echo "$_am_result" >&6; } +rm -f confinc confmf + +# Check whether --enable-dependency-tracking was given. +if test "${enable_dependency_tracking+set}" = set; then : + enableval=$enable_dependency_tracking; +fi + +if test "x$enable_dependency_tracking" != xno; then + am_depcomp="$ac_aux_dir/depcomp" + AMDEPBACKSLASH='\' + am__nodep='_no' +fi + if test "x$enable_dependency_tracking" != xno; then + AMDEP_TRUE= + AMDEP_FALSE='#' +else + AMDEP_TRUE='#' + AMDEP_FALSE= +fi + + +ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu +if test -n "$ac_tool_prefix"; then + # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args. +set dummy ${ac_tool_prefix}gcc; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_CC+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$CC"; then + ac_cv_prog_CC="$CC" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_CC="${ac_tool_prefix}gcc" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +CC=$ac_cv_prog_CC +if test -n "$CC"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 +$as_echo "$CC" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test -z "$ac_cv_prog_CC"; then + ac_ct_CC=$CC + # Extract the first word of "gcc", so it can be a program name with args. +set dummy gcc; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_ac_ct_CC+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_CC"; then + ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_CC="gcc" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_CC=$ac_cv_prog_ac_ct_CC +if test -n "$ac_ct_CC"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5 +$as_echo "$ac_ct_CC" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + if test "x$ac_ct_CC" = x; then + CC="" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + CC=$ac_ct_CC + fi +else + CC="$ac_cv_prog_CC" +fi + +if test -z "$CC"; then + if test -n "$ac_tool_prefix"; then + # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args. +set dummy ${ac_tool_prefix}cc; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_CC+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$CC"; then + ac_cv_prog_CC="$CC" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_CC="${ac_tool_prefix}cc" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +CC=$ac_cv_prog_CC +if test -n "$CC"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 +$as_echo "$CC" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + fi +fi +if test -z "$CC"; then + # Extract the first word of "cc", so it can be a program name with args. +set dummy cc; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_CC+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$CC"; then + ac_cv_prog_CC="$CC" # Let the user override the test. +else + ac_prog_rejected=no +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then + ac_prog_rejected=yes + continue + fi + ac_cv_prog_CC="cc" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +if test $ac_prog_rejected = yes; then + # We found a bogon in the path, so make sure we never use it. + set dummy $ac_cv_prog_CC + shift + if test $# != 0; then + # We chose a different compiler from the bogus one. + # However, it has the same basename, so the bogon will be chosen + # first if we set CC to just the basename; use the full file name. + shift + ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@" + fi +fi +fi +fi +CC=$ac_cv_prog_CC +if test -n "$CC"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 +$as_echo "$CC" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test -z "$CC"; then + if test -n "$ac_tool_prefix"; then + for ac_prog in cl.exe + do + # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args. +set dummy $ac_tool_prefix$ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_CC+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$CC"; then + ac_cv_prog_CC="$CC" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_CC="$ac_tool_prefix$ac_prog" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +CC=$ac_cv_prog_CC +if test -n "$CC"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 +$as_echo "$CC" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$CC" && break + done +fi +if test -z "$CC"; then + ac_ct_CC=$CC + for ac_prog in cl.exe +do + # Extract the first word of "$ac_prog", so it can be a program name with args. +set dummy $ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_ac_ct_CC+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_CC"; then + ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_CC="$ac_prog" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_CC=$ac_cv_prog_ac_ct_CC +if test -n "$ac_ct_CC"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5 +$as_echo "$ac_ct_CC" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$ac_ct_CC" && break +done + + if test "x$ac_ct_CC" = x; then + CC="" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + CC=$ac_ct_CC + fi +fi + +fi + + +test -z "$CC" && { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 +$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} +as_fn_error $? "no acceptable C compiler found in \$PATH +See \`config.log' for more details" "$LINENO" 5; } + +# Provide some information about the compiler. +$as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5 +set X $ac_compile +ac_compiler=$2 +for ac_option in --version -v -V -qversion; do + { { ac_try="$ac_compiler $ac_option >&5" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_compiler $ac_option >&5") 2>conftest.err + ac_status=$? + if test -s conftest.err; then + sed '10a\ +... rest of stderr output deleted ... + 10q' conftest.err >conftest.er1 + cat conftest.er1 >&5 + fi + rm -f conftest.er1 conftest.err + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } +done + +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +ac_clean_files_save=$ac_clean_files +ac_clean_files="$ac_clean_files a.out a.out.dSYM a.exe b.out" +# Try to create an executable without -o first, disregard a.out. +# It will help us diagnose broken compilers, and finding out an intuition +# of exeext. +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C compiler works" >&5 +$as_echo_n "checking whether the C compiler works... " >&6; } +ac_link_default=`$as_echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'` + +# The possible output files: +ac_files="a.out conftest.exe conftest a.exe a_out.exe b.out conftest.*" + +ac_rmfiles= +for ac_file in $ac_files +do + case $ac_file in + *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;; + * ) ac_rmfiles="$ac_rmfiles $ac_file";; + esac +done +rm -f $ac_rmfiles + +if { { ac_try="$ac_link_default" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_link_default") 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then : + # Autoconf-2.13 could set the ac_cv_exeext variable to `no'. +# So ignore a value of `no', otherwise this would lead to `EXEEXT = no' +# in a Makefile. We should not override ac_cv_exeext if it was cached, +# so that the user can short-circuit this test for compilers unknown to +# Autoconf. +for ac_file in $ac_files '' +do + test -f "$ac_file" || continue + case $ac_file in + *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) + ;; + [ab].out ) + # We found the default executable, but exeext='' is most + # certainly right. + break;; + *.* ) + if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no; + then :; else + ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'` + fi + # We set ac_cv_exeext here because the later test for it is not + # safe: cross compilers may not add the suffix if given an `-o' + # argument, so we may need to know it at that point already. + # Even if this section looks crufty: it has the advantage of + # actually working. + break;; + * ) + break;; + esac +done +test "$ac_cv_exeext" = no && ac_cv_exeext= + +else + ac_file='' +fi +if test -z "$ac_file"; then : + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +$as_echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 +$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} +as_fn_error 77 "C compiler cannot create executables +See \`config.log' for more details" "$LINENO" 5; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +$as_echo "yes" >&6; } +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler default output file name" >&5 +$as_echo_n "checking for C compiler default output file name... " >&6; } +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_file" >&5 +$as_echo "$ac_file" >&6; } +ac_exeext=$ac_cv_exeext + +rm -f -r a.out a.out.dSYM a.exe conftest$ac_cv_exeext b.out +ac_clean_files=$ac_clean_files_save +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of executables" >&5 +$as_echo_n "checking for suffix of executables... " >&6; } +if { { ac_try="$ac_link" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_link") 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then : + # If both `conftest.exe' and `conftest' are `present' (well, observable) +# catch `conftest.exe'. For instance with Cygwin, `ls conftest' will +# work properly (i.e., refer to `conftest.exe'), while it won't with +# `rm'. +for ac_file in conftest.exe conftest conftest.*; do + test -f "$ac_file" || continue + case $ac_file in + *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;; + *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'` + break;; + * ) break;; + esac +done +else + { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 +$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} +as_fn_error $? "cannot compute suffix of executables: cannot compile and link +See \`config.log' for more details" "$LINENO" 5; } +fi +rm -f conftest conftest$ac_cv_exeext +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5 +$as_echo "$ac_cv_exeext" >&6; } + +rm -f conftest.$ac_ext +EXEEXT=$ac_cv_exeext +ac_exeext=$EXEEXT +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +int +main () +{ +FILE *f = fopen ("conftest.out", "w"); + return ferror (f) || fclose (f) != 0; + + ; + return 0; +} +_ACEOF +ac_clean_files="$ac_clean_files conftest.out" +# Check that the compiler produces executables we can run. If not, either +# the compiler is broken, or we cross compile. +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are cross compiling" >&5 +$as_echo_n "checking whether we are cross compiling... " >&6; } +if test "$cross_compiling" != yes; then + { { ac_try="$ac_link" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_link") 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } + if { ac_try='./conftest$ac_cv_exeext' + { { case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_try") 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; }; then + cross_compiling=no + else + if test "$cross_compiling" = maybe; then + cross_compiling=yes + else + { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 +$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} +as_fn_error $? "cannot run C compiled programs. +If you meant to cross compile, use \`--host'. +See \`config.log' for more details" "$LINENO" 5; } + fi + fi +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $cross_compiling" >&5 +$as_echo "$cross_compiling" >&6; } + +rm -f conftest.$ac_ext conftest$ac_cv_exeext conftest.out +ac_clean_files=$ac_clean_files_save +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5 +$as_echo_n "checking for suffix of object files... " >&6; } +if ${ac_cv_objext+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +rm -f conftest.o conftest.obj +if { { ac_try="$ac_compile" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_compile") 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then : + for ac_file in conftest.o conftest.obj conftest.*; do + test -f "$ac_file" || continue; + case $ac_file in + *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM ) ;; + *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'` + break;; + esac +done +else + $as_echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + +{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 +$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} +as_fn_error $? "cannot compute suffix of object files: cannot compile +See \`config.log' for more details" "$LINENO" 5; } +fi +rm -f conftest.$ac_cv_objext conftest.$ac_ext +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objext" >&5 +$as_echo "$ac_cv_objext" >&6; } +OBJEXT=$ac_cv_objext +ac_objext=$OBJEXT +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C compiler" >&5 +$as_echo_n "checking whether we are using the GNU C compiler... " >&6; } +if ${ac_cv_c_compiler_gnu+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ +#ifndef __GNUC__ + choke me +#endif + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + ac_compiler_gnu=yes +else + ac_compiler_gnu=no +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +ac_cv_c_compiler_gnu=$ac_compiler_gnu + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5 +$as_echo "$ac_cv_c_compiler_gnu" >&6; } +if test $ac_compiler_gnu = yes; then + GCC=yes +else + GCC= +fi +ac_test_CFLAGS=${CFLAGS+set} +ac_save_CFLAGS=$CFLAGS +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5 +$as_echo_n "checking whether $CC accepts -g... " >&6; } +if ${ac_cv_prog_cc_g+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_save_c_werror_flag=$ac_c_werror_flag + ac_c_werror_flag=yes + ac_cv_prog_cc_g=no + CFLAGS="-g" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + ac_cv_prog_cc_g=yes +else + CFLAGS="" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + +else + ac_c_werror_flag=$ac_save_c_werror_flag + CFLAGS="-g" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + ac_cv_prog_cc_g=yes +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext + ac_c_werror_flag=$ac_save_c_werror_flag +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5 +$as_echo "$ac_cv_prog_cc_g" >&6; } +if test "$ac_test_CFLAGS" = set; then + CFLAGS=$ac_save_CFLAGS +elif test $ac_cv_prog_cc_g = yes; then + if test "$GCC" = yes; then + CFLAGS="-g -O2" + else + CFLAGS="-g" + fi +else + if test "$GCC" = yes; then + CFLAGS="-O2" + else + CFLAGS= + fi +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C89" >&5 +$as_echo_n "checking for $CC option to accept ISO C89... " >&6; } +if ${ac_cv_prog_cc_c89+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_cv_prog_cc_c89=no +ac_save_CC=$CC +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +#include +struct stat; +/* Most of the following tests are stolen from RCS 5.7's src/conf.sh. */ +struct buf { int x; }; +FILE * (*rcsopen) (struct buf *, struct stat *, int); +static char *e (p, i) + char **p; + int i; +{ + return p[i]; +} +static char *f (char * (*g) (char **, int), char **p, ...) +{ + char *s; + va_list v; + va_start (v,p); + s = g (p, va_arg (v,int)); + va_end (v); + return s; +} + +/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default. It has + function prototypes and stuff, but not '\xHH' hex character constants. + These don't provoke an error unfortunately, instead are silently treated + as 'x'. The following induces an error, until -std is added to get + proper ANSI mode. Curiously '\x00'!='x' always comes out true, for an + array size at least. It's necessary to write '\x00'==0 to get something + that's true only with -std. */ +int osf4_cc_array ['\x00' == 0 ? 1 : -1]; + +/* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters + inside strings and character constants. */ +#define FOO(x) 'x' +int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1]; + +int test (int i, double x); +struct s1 {int (*f) (int a);}; +struct s2 {int (*f) (double a);}; +int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int); +int argc; +char **argv; +int +main () +{ +return f (e, argv, 0) != argv[0] || f (e, argv, 1) != argv[1]; + ; + return 0; +} +_ACEOF +for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \ + -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__" +do + CC="$ac_save_CC $ac_arg" + if ac_fn_c_try_compile "$LINENO"; then : + ac_cv_prog_cc_c89=$ac_arg +fi +rm -f core conftest.err conftest.$ac_objext + test "x$ac_cv_prog_cc_c89" != "xno" && break +done +rm -f conftest.$ac_ext +CC=$ac_save_CC + +fi +# AC_CACHE_VAL +case "x$ac_cv_prog_cc_c89" in + x) + { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5 +$as_echo "none needed" >&6; } ;; + xno) + { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5 +$as_echo "unsupported" >&6; } ;; + *) + CC="$CC $ac_cv_prog_cc_c89" + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5 +$as_echo "$ac_cv_prog_cc_c89" >&6; } ;; +esac +if test "x$ac_cv_prog_cc_c89" != xno; then : + +fi + +ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu + +depcc="$CC" am_compiler_list= + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking dependency style of $depcc" >&5 +$as_echo_n "checking dependency style of $depcc... " >&6; } +if ${am_cv_CC_dependencies_compiler_type+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then + # We make a subdir and do the tests there. Otherwise we can end up + # making bogus files that we don't know about and never remove. For + # instance it was reported that on HP-UX the gcc test will end up + # making a dummy file named 'D' -- because '-MD' means "put the output + # in D". + rm -rf conftest.dir + mkdir conftest.dir + # Copy depcomp to subdir because otherwise we won't find it if we're + # using a relative directory. + cp "$am_depcomp" conftest.dir + cd conftest.dir + # We will build objects and dependencies in a subdirectory because + # it helps to detect inapplicable dependency modes. For instance + # both Tru64's cc and ICC support -MD to output dependencies as a + # side effect of compilation, but ICC will put the dependencies in + # the current directory while Tru64 will put them in the object + # directory. + mkdir sub + + am_cv_CC_dependencies_compiler_type=none + if test "$am_compiler_list" = ""; then + am_compiler_list=`sed -n 's/^#*\([a-zA-Z0-9]*\))$/\1/p' < ./depcomp` + fi + am__universal=false + case " $depcc " in #( + *\ -arch\ *\ -arch\ *) am__universal=true ;; + esac + + for depmode in $am_compiler_list; do + # Setup a source with many dependencies, because some compilers + # like to wrap large dependency lists on column 80 (with \), and + # we should not choose a depcomp mode which is confused by this. + # + # We need to recreate these files for each test, as the compiler may + # overwrite some of them when testing with obscure command lines. + # This happens at least with the AIX C compiler. + : > sub/conftest.c + for i in 1 2 3 4 5 6; do + echo '#include "conftst'$i'.h"' >> sub/conftest.c + # Using ": > sub/conftst$i.h" creates only sub/conftst1.h with + # Solaris 10 /bin/sh. + echo '/* dummy */' > sub/conftst$i.h + done + echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf + + # We check with '-c' and '-o' for the sake of the "dashmstdout" + # mode. It turns out that the SunPro C++ compiler does not properly + # handle '-M -o', and we need to detect this. Also, some Intel + # versions had trouble with output in subdirs. + am__obj=sub/conftest.${OBJEXT-o} + am__minus_obj="-o $am__obj" + case $depmode in + gcc) + # This depmode causes a compiler race in universal mode. + test "$am__universal" = false || continue + ;; + nosideeffect) + # After this tag, mechanisms are not by side-effect, so they'll + # only be used when explicitly requested. + if test "x$enable_dependency_tracking" = xyes; then + continue + else + break + fi + ;; + msvc7 | msvc7msys | msvisualcpp | msvcmsys) + # This compiler won't grok '-c -o', but also, the minuso test has + # not run yet. These depmodes are late enough in the game, and + # so weak that their functioning should not be impacted. + am__obj=conftest.${OBJEXT-o} + am__minus_obj= + ;; + none) break ;; + esac + if depmode=$depmode \ + source=sub/conftest.c object=$am__obj \ + depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \ + $SHELL ./depcomp $depcc -c $am__minus_obj sub/conftest.c \ + >/dev/null 2>conftest.err && + grep sub/conftst1.h sub/conftest.Po > /dev/null 2>&1 && + grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 && + grep $am__obj sub/conftest.Po > /dev/null 2>&1 && + ${MAKE-make} -s -f confmf > /dev/null 2>&1; then + # icc doesn't choke on unknown options, it will just issue warnings + # or remarks (even with -Werror). So we grep stderr for any message + # that says an option was ignored or not supported. + # When given -MP, icc 7.0 and 7.1 complain thusly: + # icc: Command line warning: ignoring option '-M'; no argument required + # The diagnosis changed in icc 8.0: + # icc: Command line remark: option '-MP' not supported + if (grep 'ignoring option' conftest.err || + grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else + am_cv_CC_dependencies_compiler_type=$depmode + break + fi + fi + done + + cd .. + rm -rf conftest.dir +else + am_cv_CC_dependencies_compiler_type=none +fi + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_CC_dependencies_compiler_type" >&5 +$as_echo "$am_cv_CC_dependencies_compiler_type" >&6; } +CCDEPMODE=depmode=$am_cv_CC_dependencies_compiler_type + + if + test "x$enable_dependency_tracking" != xno \ + && test "$am_cv_CC_dependencies_compiler_type" = gcc3; then + am__fastdepCC_TRUE= + am__fastdepCC_FALSE='#' +else + am__fastdepCC_TRUE='#' + am__fastdepCC_FALSE= +fi + + + +if test -n "$ac_tool_prefix"; then + for ac_prog in ar lib "link -lib" + do + # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args. +set dummy $ac_tool_prefix$ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_AR+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$AR"; then + ac_cv_prog_AR="$AR" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_AR="$ac_tool_prefix$ac_prog" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +AR=$ac_cv_prog_AR +if test -n "$AR"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AR" >&5 +$as_echo "$AR" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$AR" && break + done +fi +if test -z "$AR"; then + ac_ct_AR=$AR + for ac_prog in ar lib "link -lib" +do + # Extract the first word of "$ac_prog", so it can be a program name with args. +set dummy $ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_ac_ct_AR+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_AR"; then + ac_cv_prog_ac_ct_AR="$ac_ct_AR" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_AR="$ac_prog" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_AR=$ac_cv_prog_ac_ct_AR +if test -n "$ac_ct_AR"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_AR" >&5 +$as_echo "$ac_ct_AR" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$ac_ct_AR" && break +done + + if test "x$ac_ct_AR" = x; then + AR="false" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + AR=$ac_ct_AR + fi +fi + +: ${AR=ar} + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking the archiver ($AR) interface" >&5 +$as_echo_n "checking the archiver ($AR) interface... " >&6; } +if ${am_cv_ar_interface+:} false; then : + $as_echo_n "(cached) " >&6 +else + am_cv_ar_interface=ar + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +int some_variable = 0; +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + am_ar_try='$AR cru libconftest.a conftest.$ac_objext >&5' + { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$am_ar_try\""; } >&5 + (eval $am_ar_try) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } + if test "$ac_status" -eq 0; then + am_cv_ar_interface=ar + else + am_ar_try='$AR -NOLOGO -OUT:conftest.lib conftest.$ac_objext >&5' + { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$am_ar_try\""; } >&5 + (eval $am_ar_try) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } + if test "$ac_status" -eq 0; then + am_cv_ar_interface=lib + else + am_cv_ar_interface=unknown + fi + fi + rm -f conftest.lib libconftest.a + +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_ar_interface" >&5 +$as_echo "$am_cv_ar_interface" >&6; } + +case $am_cv_ar_interface in +ar) + ;; +lib) + # Microsoft lib, so override with the ar-lib wrapper script. + # FIXME: It is wrong to rewrite AR. + # But if we don't then we get into trouble of one sort or another. + # A longer-term fix would be to have automake use am__AR in this case, + # and then we could set am__AR="$am_aux_dir/ar-lib \$(AR)" or something + # similar. + AR="$am_aux_dir/ar-lib $AR" + ;; +unknown) + as_fn_error $? "could not determine $AR interface" "$LINENO" 5 + ;; +esac + # Required by automake 1.12. + +case `pwd` in + *\ * | *\ *) + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Libtool does not cope well with whitespace in \`pwd\`" >&5 +$as_echo "$as_me: WARNING: Libtool does not cope well with whitespace in \`pwd\`" >&2;} ;; +esac + + + +macro_version='2.4.2' +macro_revision='1.3337' + + + + + + + + + + + + + +ltmain="$ac_aux_dir/ltmain.sh" + +# Make sure we can run config.sub. +$SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 || + as_fn_error $? "cannot run $SHELL $ac_aux_dir/config.sub" "$LINENO" 5 + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking build system type" >&5 +$as_echo_n "checking build system type... " >&6; } +if ${ac_cv_build+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_build_alias=$build_alias +test "x$ac_build_alias" = x && + ac_build_alias=`$SHELL "$ac_aux_dir/config.guess"` +test "x$ac_build_alias" = x && + as_fn_error $? "cannot guess build type; you must specify one" "$LINENO" 5 +ac_cv_build=`$SHELL "$ac_aux_dir/config.sub" $ac_build_alias` || + as_fn_error $? "$SHELL $ac_aux_dir/config.sub $ac_build_alias failed" "$LINENO" 5 + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5 +$as_echo "$ac_cv_build" >&6; } +case $ac_cv_build in +*-*-*) ;; +*) as_fn_error $? "invalid value of canonical build" "$LINENO" 5;; +esac +build=$ac_cv_build +ac_save_IFS=$IFS; IFS='-' +set x $ac_cv_build +shift +build_cpu=$1 +build_vendor=$2 +shift; shift +# Remember, the first character of IFS is used to create $*, +# except with old shells: +build_os=$* +IFS=$ac_save_IFS +case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking host system type" >&5 +$as_echo_n "checking host system type... " >&6; } +if ${ac_cv_host+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test "x$host_alias" = x; then + ac_cv_host=$ac_cv_build +else + ac_cv_host=`$SHELL "$ac_aux_dir/config.sub" $host_alias` || + as_fn_error $? "$SHELL $ac_aux_dir/config.sub $host_alias failed" "$LINENO" 5 +fi + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5 +$as_echo "$ac_cv_host" >&6; } +case $ac_cv_host in +*-*-*) ;; +*) as_fn_error $? "invalid value of canonical host" "$LINENO" 5;; +esac +host=$ac_cv_host +ac_save_IFS=$IFS; IFS='-' +set x $ac_cv_host +shift +host_cpu=$1 +host_vendor=$2 +shift; shift +# Remember, the first character of IFS is used to create $*, +# except with old shells: +host_os=$* +IFS=$ac_save_IFS +case $host_os in *\ *) host_os=`echo "$host_os" | sed 's/ /-/g'`;; esac + + +# Backslashify metacharacters that are still active within +# double-quoted strings. +sed_quote_subst='s/\(["`$\\]\)/\\\1/g' + +# Same as above, but do not quote variable references. +double_quote_subst='s/\(["`\\]\)/\\\1/g' + +# Sed substitution to delay expansion of an escaped shell variable in a +# double_quote_subst'ed string. +delay_variable_subst='s/\\\\\\\\\\\$/\\\\\\$/g' + +# Sed substitution to delay expansion of an escaped single quote. +delay_single_quote_subst='s/'\''/'\'\\\\\\\'\''/g' + +# Sed substitution to avoid accidental globbing in evaled expressions +no_glob_subst='s/\*/\\\*/g' + +ECHO='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' +ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO +ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO$ECHO + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to print strings" >&5 +$as_echo_n "checking how to print strings... " >&6; } +# Test print first, because it will be a builtin if present. +if test "X`( print -r -- -n ) 2>/dev/null`" = X-n && \ + test "X`print -r -- $ECHO 2>/dev/null`" = "X$ECHO"; then + ECHO='print -r --' +elif test "X`printf %s $ECHO 2>/dev/null`" = "X$ECHO"; then + ECHO='printf %s\n' +else + # Use this function as a fallback that always works. + func_fallback_echo () + { + eval 'cat <<_LTECHO_EOF +$1 +_LTECHO_EOF' + } + ECHO='func_fallback_echo' +fi + +# func_echo_all arg... +# Invoke $ECHO with all args, space-separated. +func_echo_all () +{ + $ECHO "" +} + +case "$ECHO" in + printf*) { $as_echo "$as_me:${as_lineno-$LINENO}: result: printf" >&5 +$as_echo "printf" >&6; } ;; + print*) { $as_echo "$as_me:${as_lineno-$LINENO}: result: print -r" >&5 +$as_echo "print -r" >&6; } ;; + *) { $as_echo "$as_me:${as_lineno-$LINENO}: result: cat" >&5 +$as_echo "cat" >&6; } ;; +esac + + + + + + + + + + + + + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5 +$as_echo_n "checking for a sed that does not truncate output... " >&6; } +if ${ac_cv_path_SED+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/ + for ac_i in 1 2 3 4 5 6 7; do + ac_script="$ac_script$as_nl$ac_script" + done + echo "$ac_script" 2>/dev/null | sed 99q >conftest.sed + { ac_script=; unset ac_script;} + if test -z "$SED"; then + ac_path_SED_found=false + # Loop through the user's path and test for each of PROGNAME-LIST + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_prog in sed gsed; do + for ac_exec_ext in '' $ac_executable_extensions; do + ac_path_SED="$as_dir/$ac_prog$ac_exec_ext" + as_fn_executable_p "$ac_path_SED" || continue +# Check for GNU ac_path_SED and select it if it is found. + # Check for GNU $ac_path_SED +case `"$ac_path_SED" --version 2>&1` in +*GNU*) + ac_cv_path_SED="$ac_path_SED" ac_path_SED_found=:;; +*) + ac_count=0 + $as_echo_n 0123456789 >"conftest.in" + while : + do + cat "conftest.in" "conftest.in" >"conftest.tmp" + mv "conftest.tmp" "conftest.in" + cp "conftest.in" "conftest.nl" + $as_echo '' >> "conftest.nl" + "$ac_path_SED" -f conftest.sed < "conftest.nl" >"conftest.out" 2>/dev/null || break + diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break + as_fn_arith $ac_count + 1 && ac_count=$as_val + if test $ac_count -gt ${ac_path_SED_max-0}; then + # Best one so far, save it but keep looking for a better one + ac_cv_path_SED="$ac_path_SED" + ac_path_SED_max=$ac_count + fi + # 10*(2^10) chars as input seems more than enough + test $ac_count -gt 10 && break + done + rm -f conftest.in conftest.tmp conftest.nl conftest.out;; +esac + + $ac_path_SED_found && break 3 + done + done + done +IFS=$as_save_IFS + if test -z "$ac_cv_path_SED"; then + as_fn_error $? "no acceptable sed could be found in \$PATH" "$LINENO" 5 + fi +else + ac_cv_path_SED=$SED +fi + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5 +$as_echo "$ac_cv_path_SED" >&6; } + SED="$ac_cv_path_SED" + rm -f conftest.sed + +test -z "$SED" && SED=sed +Xsed="$SED -e 1s/^X//" + + + + + + + + + + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5 +$as_echo_n "checking for grep that handles long lines and -e... " >&6; } +if ${ac_cv_path_GREP+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -z "$GREP"; then + ac_path_GREP_found=false + # Loop through the user's path and test for each of PROGNAME-LIST + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_prog in grep ggrep; do + for ac_exec_ext in '' $ac_executable_extensions; do + ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext" + as_fn_executable_p "$ac_path_GREP" || continue +# Check for GNU ac_path_GREP and select it if it is found. + # Check for GNU $ac_path_GREP +case `"$ac_path_GREP" --version 2>&1` in +*GNU*) + ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;; +*) + ac_count=0 + $as_echo_n 0123456789 >"conftest.in" + while : + do + cat "conftest.in" "conftest.in" >"conftest.tmp" + mv "conftest.tmp" "conftest.in" + cp "conftest.in" "conftest.nl" + $as_echo 'GREP' >> "conftest.nl" + "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break + diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break + as_fn_arith $ac_count + 1 && ac_count=$as_val + if test $ac_count -gt ${ac_path_GREP_max-0}; then + # Best one so far, save it but keep looking for a better one + ac_cv_path_GREP="$ac_path_GREP" + ac_path_GREP_max=$ac_count + fi + # 10*(2^10) chars as input seems more than enough + test $ac_count -gt 10 && break + done + rm -f conftest.in conftest.tmp conftest.nl conftest.out;; +esac + + $ac_path_GREP_found && break 3 + done + done + done +IFS=$as_save_IFS + if test -z "$ac_cv_path_GREP"; then + as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5 + fi +else + ac_cv_path_GREP=$GREP +fi + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5 +$as_echo "$ac_cv_path_GREP" >&6; } + GREP="$ac_cv_path_GREP" + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5 +$as_echo_n "checking for egrep... " >&6; } +if ${ac_cv_path_EGREP+:} false; then : + $as_echo_n "(cached) " >&6 +else + if echo a | $GREP -E '(a|b)' >/dev/null 2>&1 + then ac_cv_path_EGREP="$GREP -E" + else + if test -z "$EGREP"; then + ac_path_EGREP_found=false + # Loop through the user's path and test for each of PROGNAME-LIST + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_prog in egrep; do + for ac_exec_ext in '' $ac_executable_extensions; do + ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext" + as_fn_executable_p "$ac_path_EGREP" || continue +# Check for GNU ac_path_EGREP and select it if it is found. + # Check for GNU $ac_path_EGREP +case `"$ac_path_EGREP" --version 2>&1` in +*GNU*) + ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;; +*) + ac_count=0 + $as_echo_n 0123456789 >"conftest.in" + while : + do + cat "conftest.in" "conftest.in" >"conftest.tmp" + mv "conftest.tmp" "conftest.in" + cp "conftest.in" "conftest.nl" + $as_echo 'EGREP' >> "conftest.nl" + "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break + diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break + as_fn_arith $ac_count + 1 && ac_count=$as_val + if test $ac_count -gt ${ac_path_EGREP_max-0}; then + # Best one so far, save it but keep looking for a better one + ac_cv_path_EGREP="$ac_path_EGREP" + ac_path_EGREP_max=$ac_count + fi + # 10*(2^10) chars as input seems more than enough + test $ac_count -gt 10 && break + done + rm -f conftest.in conftest.tmp conftest.nl conftest.out;; +esac + + $ac_path_EGREP_found && break 3 + done + done + done +IFS=$as_save_IFS + if test -z "$ac_cv_path_EGREP"; then + as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5 + fi +else + ac_cv_path_EGREP=$EGREP +fi + + fi +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5 +$as_echo "$ac_cv_path_EGREP" >&6; } + EGREP="$ac_cv_path_EGREP" + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for fgrep" >&5 +$as_echo_n "checking for fgrep... " >&6; } +if ${ac_cv_path_FGREP+:} false; then : + $as_echo_n "(cached) " >&6 +else + if echo 'ab*c' | $GREP -F 'ab*c' >/dev/null 2>&1 + then ac_cv_path_FGREP="$GREP -F" + else + if test -z "$FGREP"; then + ac_path_FGREP_found=false + # Loop through the user's path and test for each of PROGNAME-LIST + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_prog in fgrep; do + for ac_exec_ext in '' $ac_executable_extensions; do + ac_path_FGREP="$as_dir/$ac_prog$ac_exec_ext" + as_fn_executable_p "$ac_path_FGREP" || continue +# Check for GNU ac_path_FGREP and select it if it is found. + # Check for GNU $ac_path_FGREP +case `"$ac_path_FGREP" --version 2>&1` in +*GNU*) + ac_cv_path_FGREP="$ac_path_FGREP" ac_path_FGREP_found=:;; +*) + ac_count=0 + $as_echo_n 0123456789 >"conftest.in" + while : + do + cat "conftest.in" "conftest.in" >"conftest.tmp" + mv "conftest.tmp" "conftest.in" + cp "conftest.in" "conftest.nl" + $as_echo 'FGREP' >> "conftest.nl" + "$ac_path_FGREP" FGREP < "conftest.nl" >"conftest.out" 2>/dev/null || break + diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break + as_fn_arith $ac_count + 1 && ac_count=$as_val + if test $ac_count -gt ${ac_path_FGREP_max-0}; then + # Best one so far, save it but keep looking for a better one + ac_cv_path_FGREP="$ac_path_FGREP" + ac_path_FGREP_max=$ac_count + fi + # 10*(2^10) chars as input seems more than enough + test $ac_count -gt 10 && break + done + rm -f conftest.in conftest.tmp conftest.nl conftest.out;; +esac + + $ac_path_FGREP_found && break 3 + done + done + done +IFS=$as_save_IFS + if test -z "$ac_cv_path_FGREP"; then + as_fn_error $? "no acceptable fgrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5 + fi +else + ac_cv_path_FGREP=$FGREP +fi + + fi +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_FGREP" >&5 +$as_echo "$ac_cv_path_FGREP" >&6; } + FGREP="$ac_cv_path_FGREP" + + +test -z "$GREP" && GREP=grep + + + + + + + + + + + + + + + + + + + +# Check whether --with-gnu-ld was given. +if test "${with_gnu_ld+set}" = set; then : + withval=$with_gnu_ld; test "$withval" = no || with_gnu_ld=yes +else + with_gnu_ld=no +fi + +ac_prog=ld +if test "$GCC" = yes; then + # Check if gcc -print-prog-name=ld gives a path. + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ld used by $CC" >&5 +$as_echo_n "checking for ld used by $CC... " >&6; } + case $host in + *-*-mingw*) + # gcc leaves a trailing carriage return which upsets mingw + ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;; + *) + ac_prog=`($CC -print-prog-name=ld) 2>&5` ;; + esac + case $ac_prog in + # Accept absolute paths. + [\\/]* | ?:[\\/]*) + re_direlt='/[^/][^/]*/\.\./' + # Canonicalize the pathname of ld + ac_prog=`$ECHO "$ac_prog"| $SED 's%\\\\%/%g'` + while $ECHO "$ac_prog" | $GREP "$re_direlt" > /dev/null 2>&1; do + ac_prog=`$ECHO $ac_prog| $SED "s%$re_direlt%/%"` + done + test -z "$LD" && LD="$ac_prog" + ;; + "") + # If it fails, then pretend we aren't using GCC. + ac_prog=ld + ;; + *) + # If it is relative, then search for the first ld in PATH. + with_gnu_ld=unknown + ;; + esac +elif test "$with_gnu_ld" = yes; then + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GNU ld" >&5 +$as_echo_n "checking for GNU ld... " >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for non-GNU ld" >&5 +$as_echo_n "checking for non-GNU ld... " >&6; } +fi +if ${lt_cv_path_LD+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -z "$LD"; then + lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR + for ac_dir in $PATH; do + IFS="$lt_save_ifs" + test -z "$ac_dir" && ac_dir=. + if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then + lt_cv_path_LD="$ac_dir/$ac_prog" + # Check to see if the program is GNU ld. I'd rather use --version, + # but apparently some variants of GNU ld only accept -v. + # Break only if it was the GNU/non-GNU ld that we prefer. + case `"$lt_cv_path_LD" -v 2>&1 &5 +$as_echo "$LD" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi +test -z "$LD" && as_fn_error $? "no acceptable ld found in \$PATH" "$LINENO" 5 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if the linker ($LD) is GNU ld" >&5 +$as_echo_n "checking if the linker ($LD) is GNU ld... " >&6; } +if ${lt_cv_prog_gnu_ld+:} false; then : + $as_echo_n "(cached) " >&6 +else + # I'd rather use --version here, but apparently some GNU lds only accept -v. +case `$LD -v 2>&1 &5 +$as_echo "$lt_cv_prog_gnu_ld" >&6; } +with_gnu_ld=$lt_cv_prog_gnu_ld + + + + + + + + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for BSD- or MS-compatible name lister (nm)" >&5 +$as_echo_n "checking for BSD- or MS-compatible name lister (nm)... " >&6; } +if ${lt_cv_path_NM+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$NM"; then + # Let the user override the test. + lt_cv_path_NM="$NM" +else + lt_nm_to_check="${ac_tool_prefix}nm" + if test -n "$ac_tool_prefix" && test "$build" = "$host"; then + lt_nm_to_check="$lt_nm_to_check nm" + fi + for lt_tmp_nm in $lt_nm_to_check; do + lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR + for ac_dir in $PATH /usr/ccs/bin/elf /usr/ccs/bin /usr/ucb /bin; do + IFS="$lt_save_ifs" + test -z "$ac_dir" && ac_dir=. + tmp_nm="$ac_dir/$lt_tmp_nm" + if test -f "$tmp_nm" || test -f "$tmp_nm$ac_exeext" ; then + # Check to see if the nm accepts a BSD-compat flag. + # Adding the `sed 1q' prevents false positives on HP-UX, which says: + # nm: unknown option "B" ignored + # Tru64's nm complains that /dev/null is an invalid object file + case `"$tmp_nm" -B /dev/null 2>&1 | sed '1q'` in + */dev/null* | *'Invalid file or object type'*) + lt_cv_path_NM="$tmp_nm -B" + break + ;; + *) + case `"$tmp_nm" -p /dev/null 2>&1 | sed '1q'` in + */dev/null*) + lt_cv_path_NM="$tmp_nm -p" + break + ;; + *) + lt_cv_path_NM=${lt_cv_path_NM="$tmp_nm"} # keep the first match, but + continue # so that we can try to find one that supports BSD flags + ;; + esac + ;; + esac + fi + done + IFS="$lt_save_ifs" + done + : ${lt_cv_path_NM=no} +fi +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_path_NM" >&5 +$as_echo "$lt_cv_path_NM" >&6; } +if test "$lt_cv_path_NM" != "no"; then + NM="$lt_cv_path_NM" +else + # Didn't find any BSD compatible name lister, look for dumpbin. + if test -n "$DUMPBIN"; then : + # Let the user override the test. + else + if test -n "$ac_tool_prefix"; then + for ac_prog in dumpbin "link -dump" + do + # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args. +set dummy $ac_tool_prefix$ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_DUMPBIN+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$DUMPBIN"; then + ac_cv_prog_DUMPBIN="$DUMPBIN" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_DUMPBIN="$ac_tool_prefix$ac_prog" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +DUMPBIN=$ac_cv_prog_DUMPBIN +if test -n "$DUMPBIN"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DUMPBIN" >&5 +$as_echo "$DUMPBIN" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$DUMPBIN" && break + done +fi +if test -z "$DUMPBIN"; then + ac_ct_DUMPBIN=$DUMPBIN + for ac_prog in dumpbin "link -dump" +do + # Extract the first word of "$ac_prog", so it can be a program name with args. +set dummy $ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_ac_ct_DUMPBIN+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_DUMPBIN"; then + ac_cv_prog_ac_ct_DUMPBIN="$ac_ct_DUMPBIN" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_DUMPBIN="$ac_prog" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_DUMPBIN=$ac_cv_prog_ac_ct_DUMPBIN +if test -n "$ac_ct_DUMPBIN"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DUMPBIN" >&5 +$as_echo "$ac_ct_DUMPBIN" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$ac_ct_DUMPBIN" && break +done + + if test "x$ac_ct_DUMPBIN" = x; then + DUMPBIN=":" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + DUMPBIN=$ac_ct_DUMPBIN + fi +fi + + case `$DUMPBIN -symbols /dev/null 2>&1 | sed '1q'` in + *COFF*) + DUMPBIN="$DUMPBIN -symbols" + ;; + *) + DUMPBIN=: + ;; + esac + fi + + if test "$DUMPBIN" != ":"; then + NM="$DUMPBIN" + fi +fi +test -z "$NM" && NM=nm + + + + + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking the name lister ($NM) interface" >&5 +$as_echo_n "checking the name lister ($NM) interface... " >&6; } +if ${lt_cv_nm_interface+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_nm_interface="BSD nm" + echo "int some_variable = 0;" > conftest.$ac_ext + (eval echo "\"\$as_me:$LINENO: $ac_compile\"" >&5) + (eval "$ac_compile" 2>conftest.err) + cat conftest.err >&5 + (eval echo "\"\$as_me:$LINENO: $NM \\\"conftest.$ac_objext\\\"\"" >&5) + (eval "$NM \"conftest.$ac_objext\"" 2>conftest.err > conftest.out) + cat conftest.err >&5 + (eval echo "\"\$as_me:$LINENO: output\"" >&5) + cat conftest.out >&5 + if $GREP 'External.*some_variable' conftest.out > /dev/null; then + lt_cv_nm_interface="MS dumpbin" + fi + rm -f conftest* +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_nm_interface" >&5 +$as_echo "$lt_cv_nm_interface" >&6; } + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ln -s works" >&5 +$as_echo_n "checking whether ln -s works... " >&6; } +LN_S=$as_ln_s +if test "$LN_S" = "ln -s"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +$as_echo "yes" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no, using $LN_S" >&5 +$as_echo "no, using $LN_S" >&6; } +fi + +# find the maximum length of command line arguments +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking the maximum length of command line arguments" >&5 +$as_echo_n "checking the maximum length of command line arguments... " >&6; } +if ${lt_cv_sys_max_cmd_len+:} false; then : + $as_echo_n "(cached) " >&6 +else + i=0 + teststring="ABCD" + + case $build_os in + msdosdjgpp*) + # On DJGPP, this test can blow up pretty badly due to problems in libc + # (any single argument exceeding 2000 bytes causes a buffer overrun + # during glob expansion). Even if it were fixed, the result of this + # check would be larger than it should be. + lt_cv_sys_max_cmd_len=12288; # 12K is about right + ;; + + gnu*) + # Under GNU Hurd, this test is not required because there is + # no limit to the length of command line arguments. + # Libtool will interpret -1 as no limit whatsoever + lt_cv_sys_max_cmd_len=-1; + ;; + + cygwin* | mingw* | cegcc*) + # On Win9x/ME, this test blows up -- it succeeds, but takes + # about 5 minutes as the teststring grows exponentially. + # Worse, since 9x/ME are not pre-emptively multitasking, + # you end up with a "frozen" computer, even though with patience + # the test eventually succeeds (with a max line length of 256k). + # Instead, let's just punt: use the minimum linelength reported by + # all of the supported platforms: 8192 (on NT/2K/XP). + lt_cv_sys_max_cmd_len=8192; + ;; + + mint*) + # On MiNT this can take a long time and run out of memory. + lt_cv_sys_max_cmd_len=8192; + ;; + + amigaos*) + # On AmigaOS with pdksh, this test takes hours, literally. + # So we just punt and use a minimum line length of 8192. + lt_cv_sys_max_cmd_len=8192; + ;; + + netbsd* | freebsd* | openbsd* | darwin* | dragonfly*) + # This has been around since 386BSD, at least. Likely further. + if test -x /sbin/sysctl; then + lt_cv_sys_max_cmd_len=`/sbin/sysctl -n kern.argmax` + elif test -x /usr/sbin/sysctl; then + lt_cv_sys_max_cmd_len=`/usr/sbin/sysctl -n kern.argmax` + else + lt_cv_sys_max_cmd_len=65536 # usable default for all BSDs + fi + # And add a safety zone + lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4` + lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3` + ;; + + interix*) + # We know the value 262144 and hardcode it with a safety zone (like BSD) + lt_cv_sys_max_cmd_len=196608 + ;; + + os2*) + # The test takes a long time on OS/2. + lt_cv_sys_max_cmd_len=8192 + ;; + + osf*) + # Dr. Hans Ekkehard Plesser reports seeing a kernel panic running configure + # due to this test when exec_disable_arg_limit is 1 on Tru64. It is not + # nice to cause kernel panics so lets avoid the loop below. + # First set a reasonable default. + lt_cv_sys_max_cmd_len=16384 + # + if test -x /sbin/sysconfig; then + case `/sbin/sysconfig -q proc exec_disable_arg_limit` in + *1*) lt_cv_sys_max_cmd_len=-1 ;; + esac + fi + ;; + sco3.2v5*) + lt_cv_sys_max_cmd_len=102400 + ;; + sysv5* | sco5v6* | sysv4.2uw2*) + kargmax=`grep ARG_MAX /etc/conf/cf.d/stune 2>/dev/null` + if test -n "$kargmax"; then + lt_cv_sys_max_cmd_len=`echo $kargmax | sed 's/.*[ ]//'` + else + lt_cv_sys_max_cmd_len=32768 + fi + ;; + *) + lt_cv_sys_max_cmd_len=`(getconf ARG_MAX) 2> /dev/null` + if test -n "$lt_cv_sys_max_cmd_len" && \ + test undefined != "$lt_cv_sys_max_cmd_len"; then + lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4` + lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3` + else + # Make teststring a little bigger before we do anything with it. + # a 1K string should be a reasonable start. + for i in 1 2 3 4 5 6 7 8 ; do + teststring=$teststring$teststring + done + SHELL=${SHELL-${CONFIG_SHELL-/bin/sh}} + # If test is not a shell built-in, we'll probably end up computing a + # maximum length that is only half of the actual maximum length, but + # we can't tell. + while { test "X"`env echo "$teststring$teststring" 2>/dev/null` \ + = "X$teststring$teststring"; } >/dev/null 2>&1 && + test $i != 17 # 1/2 MB should be enough + do + i=`expr $i + 1` + teststring=$teststring$teststring + done + # Only check the string length outside the loop. + lt_cv_sys_max_cmd_len=`expr "X$teststring" : ".*" 2>&1` + teststring= + # Add a significant safety factor because C++ compilers can tack on + # massive amounts of additional arguments before passing them to the + # linker. It appears as though 1/2 is a usable value. + lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 2` + fi + ;; + esac + +fi + +if test -n $lt_cv_sys_max_cmd_len ; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_sys_max_cmd_len" >&5 +$as_echo "$lt_cv_sys_max_cmd_len" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: none" >&5 +$as_echo "none" >&6; } +fi +max_cmd_len=$lt_cv_sys_max_cmd_len + + + + + + +: ${CP="cp -f"} +: ${MV="mv -f"} +: ${RM="rm -f"} + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the shell understands some XSI constructs" >&5 +$as_echo_n "checking whether the shell understands some XSI constructs... " >&6; } +# Try some XSI features +xsi_shell=no +( _lt_dummy="a/b/c" + test "${_lt_dummy##*/},${_lt_dummy%/*},${_lt_dummy#??}"${_lt_dummy%"$_lt_dummy"}, \ + = c,a/b,b/c, \ + && eval 'test $(( 1 + 1 )) -eq 2 \ + && test "${#_lt_dummy}" -eq 5' ) >/dev/null 2>&1 \ + && xsi_shell=yes +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $xsi_shell" >&5 +$as_echo "$xsi_shell" >&6; } + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the shell understands \"+=\"" >&5 +$as_echo_n "checking whether the shell understands \"+=\"... " >&6; } +lt_shell_append=no +( foo=bar; set foo baz; eval "$1+=\$2" && test "$foo" = barbaz ) \ + >/dev/null 2>&1 \ + && lt_shell_append=yes +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_shell_append" >&5 +$as_echo "$lt_shell_append" >&6; } + + +if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then + lt_unset=unset +else + lt_unset=false +fi + + + + + +# test EBCDIC or ASCII +case `echo X|tr X '\101'` in + A) # ASCII based system + # \n is not interpreted correctly by Solaris 8 /usr/ucb/tr + lt_SP2NL='tr \040 \012' + lt_NL2SP='tr \015\012 \040\040' + ;; + *) # EBCDIC based system + lt_SP2NL='tr \100 \n' + lt_NL2SP='tr \r\n \100\100' + ;; +esac + + + + + + + + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to convert $build file names to $host format" >&5 +$as_echo_n "checking how to convert $build file names to $host format... " >&6; } +if ${lt_cv_to_host_file_cmd+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $host in + *-*-mingw* ) + case $build in + *-*-mingw* ) # actually msys + lt_cv_to_host_file_cmd=func_convert_file_msys_to_w32 + ;; + *-*-cygwin* ) + lt_cv_to_host_file_cmd=func_convert_file_cygwin_to_w32 + ;; + * ) # otherwise, assume *nix + lt_cv_to_host_file_cmd=func_convert_file_nix_to_w32 + ;; + esac + ;; + *-*-cygwin* ) + case $build in + *-*-mingw* ) # actually msys + lt_cv_to_host_file_cmd=func_convert_file_msys_to_cygwin + ;; + *-*-cygwin* ) + lt_cv_to_host_file_cmd=func_convert_file_noop + ;; + * ) # otherwise, assume *nix + lt_cv_to_host_file_cmd=func_convert_file_nix_to_cygwin + ;; + esac + ;; + * ) # unhandled hosts (and "normal" native builds) + lt_cv_to_host_file_cmd=func_convert_file_noop + ;; +esac + +fi + +to_host_file_cmd=$lt_cv_to_host_file_cmd +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_to_host_file_cmd" >&5 +$as_echo "$lt_cv_to_host_file_cmd" >&6; } + + + + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to convert $build file names to toolchain format" >&5 +$as_echo_n "checking how to convert $build file names to toolchain format... " >&6; } +if ${lt_cv_to_tool_file_cmd+:} false; then : + $as_echo_n "(cached) " >&6 +else + #assume ordinary cross tools, or native build. +lt_cv_to_tool_file_cmd=func_convert_file_noop +case $host in + *-*-mingw* ) + case $build in + *-*-mingw* ) # actually msys + lt_cv_to_tool_file_cmd=func_convert_file_msys_to_w32 + ;; + esac + ;; +esac + +fi + +to_tool_file_cmd=$lt_cv_to_tool_file_cmd +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_to_tool_file_cmd" >&5 +$as_echo "$lt_cv_to_tool_file_cmd" >&6; } + + + + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $LD option to reload object files" >&5 +$as_echo_n "checking for $LD option to reload object files... " >&6; } +if ${lt_cv_ld_reload_flag+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_ld_reload_flag='-r' +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ld_reload_flag" >&5 +$as_echo "$lt_cv_ld_reload_flag" >&6; } +reload_flag=$lt_cv_ld_reload_flag +case $reload_flag in +"" | " "*) ;; +*) reload_flag=" $reload_flag" ;; +esac +reload_cmds='$LD$reload_flag -o $output$reload_objs' +case $host_os in + cygwin* | mingw* | pw32* | cegcc*) + if test "$GCC" != yes; then + reload_cmds=false + fi + ;; + darwin*) + if test "$GCC" = yes; then + reload_cmds='$LTCC $LTCFLAGS -nostdlib ${wl}-r -o $output$reload_objs' + else + reload_cmds='$LD$reload_flag -o $output$reload_objs' + fi + ;; +esac + + + + + + + + + +if test -n "$ac_tool_prefix"; then + # Extract the first word of "${ac_tool_prefix}objdump", so it can be a program name with args. +set dummy ${ac_tool_prefix}objdump; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_OBJDUMP+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$OBJDUMP"; then + ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_OBJDUMP="${ac_tool_prefix}objdump" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +OBJDUMP=$ac_cv_prog_OBJDUMP +if test -n "$OBJDUMP"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OBJDUMP" >&5 +$as_echo "$OBJDUMP" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test -z "$ac_cv_prog_OBJDUMP"; then + ac_ct_OBJDUMP=$OBJDUMP + # Extract the first word of "objdump", so it can be a program name with args. +set dummy objdump; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_ac_ct_OBJDUMP+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_OBJDUMP"; then + ac_cv_prog_ac_ct_OBJDUMP="$ac_ct_OBJDUMP" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_OBJDUMP="objdump" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_OBJDUMP=$ac_cv_prog_ac_ct_OBJDUMP +if test -n "$ac_ct_OBJDUMP"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OBJDUMP" >&5 +$as_echo "$ac_ct_OBJDUMP" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + if test "x$ac_ct_OBJDUMP" = x; then + OBJDUMP="false" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + OBJDUMP=$ac_ct_OBJDUMP + fi +else + OBJDUMP="$ac_cv_prog_OBJDUMP" +fi + +test -z "$OBJDUMP" && OBJDUMP=objdump + + + + + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to recognize dependent libraries" >&5 +$as_echo_n "checking how to recognize dependent libraries... " >&6; } +if ${lt_cv_deplibs_check_method+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_file_magic_cmd='$MAGIC_CMD' +lt_cv_file_magic_test_file= +lt_cv_deplibs_check_method='unknown' +# Need to set the preceding variable on all platforms that support +# interlibrary dependencies. +# 'none' -- dependencies not supported. +# `unknown' -- same as none, but documents that we really don't know. +# 'pass_all' -- all dependencies passed with no checks. +# 'test_compile' -- check by making test program. +# 'file_magic [[regex]]' -- check by looking for files in library path +# which responds to the $file_magic_cmd with a given extended regex. +# If you have `file' or equivalent on your system and you're not sure +# whether `pass_all' will *always* work, you probably want this one. + +case $host_os in +aix[4-9]*) + lt_cv_deplibs_check_method=pass_all + ;; + +beos*) + lt_cv_deplibs_check_method=pass_all + ;; + +bsdi[45]*) + lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (shared object|dynamic lib)' + lt_cv_file_magic_cmd='/usr/bin/file -L' + lt_cv_file_magic_test_file=/shlib/libc.so + ;; + +cygwin*) + # func_win32_libid is a shell function defined in ltmain.sh + lt_cv_deplibs_check_method='file_magic ^x86 archive import|^x86 DLL' + lt_cv_file_magic_cmd='func_win32_libid' + ;; + +mingw* | pw32*) + # Base MSYS/MinGW do not provide the 'file' command needed by + # func_win32_libid shell function, so use a weaker test based on 'objdump', + # unless we find 'file', for example because we are cross-compiling. + # func_win32_libid assumes BSD nm, so disallow it if using MS dumpbin. + if ( test "$lt_cv_nm_interface" = "BSD nm" && file / ) >/dev/null 2>&1; then + lt_cv_deplibs_check_method='file_magic ^x86 archive import|^x86 DLL' + lt_cv_file_magic_cmd='func_win32_libid' + else + # Keep this pattern in sync with the one in func_win32_libid. + lt_cv_deplibs_check_method='file_magic file format (pei*-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)' + lt_cv_file_magic_cmd='$OBJDUMP -f' + fi + ;; + +cegcc*) + # use the weaker test based on 'objdump'. See mingw*. + lt_cv_deplibs_check_method='file_magic file format pe-arm-.*little(.*architecture: arm)?' + lt_cv_file_magic_cmd='$OBJDUMP -f' + ;; + +darwin* | rhapsody*) + lt_cv_deplibs_check_method=pass_all + ;; + +freebsd* | dragonfly*) + if echo __ELF__ | $CC -E - | $GREP __ELF__ > /dev/null; then + case $host_cpu in + i*86 ) + # Not sure whether the presence of OpenBSD here was a mistake. + # Let's accept both of them until this is cleared up. + lt_cv_deplibs_check_method='file_magic (FreeBSD|OpenBSD|DragonFly)/i[3-9]86 (compact )?demand paged shared library' + lt_cv_file_magic_cmd=/usr/bin/file + lt_cv_file_magic_test_file=`echo /usr/lib/libc.so.*` + ;; + esac + else + lt_cv_deplibs_check_method=pass_all + fi + ;; + +haiku*) + lt_cv_deplibs_check_method=pass_all + ;; + +hpux10.20* | hpux11*) + lt_cv_file_magic_cmd=/usr/bin/file + case $host_cpu in + ia64*) + lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|ELF-[0-9][0-9]) shared object file - IA64' + lt_cv_file_magic_test_file=/usr/lib/hpux32/libc.so + ;; + hppa*64*) + lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|ELF[ -][0-9][0-9])(-bit)?( [LM]SB)? shared object( file)?[, -]* PA-RISC [0-9]\.[0-9]' + lt_cv_file_magic_test_file=/usr/lib/pa20_64/libc.sl + ;; + *) + lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|PA-RISC[0-9]\.[0-9]) shared library' + lt_cv_file_magic_test_file=/usr/lib/libc.sl + ;; + esac + ;; + +interix[3-9]*) + # PIC code is broken on Interix 3.x, that's why |\.a not |_pic\.a here + lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so|\.a)$' + ;; + +irix5* | irix6* | nonstopux*) + case $LD in + *-32|*"-32 ") libmagic=32-bit;; + *-n32|*"-n32 ") libmagic=N32;; + *-64|*"-64 ") libmagic=64-bit;; + *) libmagic=never-match;; + esac + lt_cv_deplibs_check_method=pass_all + ;; + +# This must be glibc/ELF. +linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*) + lt_cv_deplibs_check_method=pass_all + ;; + +netbsd* | netbsdelf*-gnu) + if echo __ELF__ | $CC -E - | $GREP __ELF__ > /dev/null; then + lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so\.[0-9]+\.[0-9]+|_pic\.a)$' + else + lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so|_pic\.a)$' + fi + ;; + +newos6*) + lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (executable|dynamic lib)' + lt_cv_file_magic_cmd=/usr/bin/file + lt_cv_file_magic_test_file=/usr/lib/libnls.so + ;; + +*nto* | *qnx*) + lt_cv_deplibs_check_method=pass_all + ;; + +openbsd*) + if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then + lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so\.[0-9]+\.[0-9]+|\.so|_pic\.a)$' + else + lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so\.[0-9]+\.[0-9]+|_pic\.a)$' + fi + ;; + +osf3* | osf4* | osf5*) + lt_cv_deplibs_check_method=pass_all + ;; + +rdos*) + lt_cv_deplibs_check_method=pass_all + ;; + +solaris*) + lt_cv_deplibs_check_method=pass_all + ;; + +sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*) + lt_cv_deplibs_check_method=pass_all + ;; + +sysv4 | sysv4.3*) + case $host_vendor in + motorola) + lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (shared object|dynamic lib) M[0-9][0-9]* Version [0-9]' + lt_cv_file_magic_test_file=`echo /usr/lib/libc.so*` + ;; + ncr) + lt_cv_deplibs_check_method=pass_all + ;; + sequent) + lt_cv_file_magic_cmd='/bin/file' + lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [LM]SB (shared object|dynamic lib )' + ;; + sni) + lt_cv_file_magic_cmd='/bin/file' + lt_cv_deplibs_check_method="file_magic ELF [0-9][0-9]*-bit [LM]SB dynamic lib" + lt_cv_file_magic_test_file=/lib/libc.so + ;; + siemens) + lt_cv_deplibs_check_method=pass_all + ;; + pc) + lt_cv_deplibs_check_method=pass_all + ;; + esac + ;; + +tpf*) + lt_cv_deplibs_check_method=pass_all + ;; +esac + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_deplibs_check_method" >&5 +$as_echo "$lt_cv_deplibs_check_method" >&6; } + +file_magic_glob= +want_nocaseglob=no +if test "$build" = "$host"; then + case $host_os in + mingw* | pw32*) + if ( shopt | grep nocaseglob ) >/dev/null 2>&1; then + want_nocaseglob=yes + else + file_magic_glob=`echo aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ | $SED -e "s/\(..\)/s\/[\1]\/[\1]\/g;/g"` + fi + ;; + esac +fi + +file_magic_cmd=$lt_cv_file_magic_cmd +deplibs_check_method=$lt_cv_deplibs_check_method +test -z "$deplibs_check_method" && deplibs_check_method=unknown + + + + + + + + + + + + + + + + + + + + + + +if test -n "$ac_tool_prefix"; then + # Extract the first word of "${ac_tool_prefix}dlltool", so it can be a program name with args. +set dummy ${ac_tool_prefix}dlltool; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_DLLTOOL+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$DLLTOOL"; then + ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_DLLTOOL="${ac_tool_prefix}dlltool" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +DLLTOOL=$ac_cv_prog_DLLTOOL +if test -n "$DLLTOOL"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DLLTOOL" >&5 +$as_echo "$DLLTOOL" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test -z "$ac_cv_prog_DLLTOOL"; then + ac_ct_DLLTOOL=$DLLTOOL + # Extract the first word of "dlltool", so it can be a program name with args. +set dummy dlltool; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_ac_ct_DLLTOOL+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_DLLTOOL"; then + ac_cv_prog_ac_ct_DLLTOOL="$ac_ct_DLLTOOL" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_DLLTOOL="dlltool" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_DLLTOOL=$ac_cv_prog_ac_ct_DLLTOOL +if test -n "$ac_ct_DLLTOOL"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DLLTOOL" >&5 +$as_echo "$ac_ct_DLLTOOL" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + if test "x$ac_ct_DLLTOOL" = x; then + DLLTOOL="false" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + DLLTOOL=$ac_ct_DLLTOOL + fi +else + DLLTOOL="$ac_cv_prog_DLLTOOL" +fi + +test -z "$DLLTOOL" && DLLTOOL=dlltool + + + + + + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to associate runtime and link libraries" >&5 +$as_echo_n "checking how to associate runtime and link libraries... " >&6; } +if ${lt_cv_sharedlib_from_linklib_cmd+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_sharedlib_from_linklib_cmd='unknown' + +case $host_os in +cygwin* | mingw* | pw32* | cegcc*) + # two different shell functions defined in ltmain.sh + # decide which to use based on capabilities of $DLLTOOL + case `$DLLTOOL --help 2>&1` in + *--identify-strict*) + lt_cv_sharedlib_from_linklib_cmd=func_cygming_dll_for_implib + ;; + *) + lt_cv_sharedlib_from_linklib_cmd=func_cygming_dll_for_implib_fallback + ;; + esac + ;; +*) + # fallback: assume linklib IS sharedlib + lt_cv_sharedlib_from_linklib_cmd="$ECHO" + ;; +esac + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_sharedlib_from_linklib_cmd" >&5 +$as_echo "$lt_cv_sharedlib_from_linklib_cmd" >&6; } +sharedlib_from_linklib_cmd=$lt_cv_sharedlib_from_linklib_cmd +test -z "$sharedlib_from_linklib_cmd" && sharedlib_from_linklib_cmd=$ECHO + + + + + + + +if test -n "$ac_tool_prefix"; then + for ac_prog in ar + do + # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args. +set dummy $ac_tool_prefix$ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_AR+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$AR"; then + ac_cv_prog_AR="$AR" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_AR="$ac_tool_prefix$ac_prog" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +AR=$ac_cv_prog_AR +if test -n "$AR"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AR" >&5 +$as_echo "$AR" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$AR" && break + done +fi +if test -z "$AR"; then + ac_ct_AR=$AR + for ac_prog in ar +do + # Extract the first word of "$ac_prog", so it can be a program name with args. +set dummy $ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_ac_ct_AR+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_AR"; then + ac_cv_prog_ac_ct_AR="$ac_ct_AR" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_AR="$ac_prog" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_AR=$ac_cv_prog_ac_ct_AR +if test -n "$ac_ct_AR"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_AR" >&5 +$as_echo "$ac_ct_AR" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$ac_ct_AR" && break +done + + if test "x$ac_ct_AR" = x; then + AR="false" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + AR=$ac_ct_AR + fi +fi + +: ${AR=ar} +: ${AR_FLAGS=cru} + + + + + + + + + + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for archiver @FILE support" >&5 +$as_echo_n "checking for archiver @FILE support... " >&6; } +if ${lt_cv_ar_at_file+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_ar_at_file=no + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + echo conftest.$ac_objext > conftest.lst + lt_ar_try='$AR $AR_FLAGS libconftest.a @conftest.lst >&5' + { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$lt_ar_try\""; } >&5 + (eval $lt_ar_try) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } + if test "$ac_status" -eq 0; then + # Ensure the archiver fails upon bogus file names. + rm -f conftest.$ac_objext libconftest.a + { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$lt_ar_try\""; } >&5 + (eval $lt_ar_try) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } + if test "$ac_status" -ne 0; then + lt_cv_ar_at_file=@ + fi + fi + rm -f conftest.* libconftest.a + +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ar_at_file" >&5 +$as_echo "$lt_cv_ar_at_file" >&6; } + +if test "x$lt_cv_ar_at_file" = xno; then + archiver_list_spec= +else + archiver_list_spec=$lt_cv_ar_at_file +fi + + + + + + + +if test -n "$ac_tool_prefix"; then + # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args. +set dummy ${ac_tool_prefix}strip; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_STRIP+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$STRIP"; then + ac_cv_prog_STRIP="$STRIP" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_STRIP="${ac_tool_prefix}strip" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +STRIP=$ac_cv_prog_STRIP +if test -n "$STRIP"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5 +$as_echo "$STRIP" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test -z "$ac_cv_prog_STRIP"; then + ac_ct_STRIP=$STRIP + # Extract the first word of "strip", so it can be a program name with args. +set dummy strip; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_ac_ct_STRIP+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_STRIP"; then + ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_STRIP="strip" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP +if test -n "$ac_ct_STRIP"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_STRIP" >&5 +$as_echo "$ac_ct_STRIP" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + if test "x$ac_ct_STRIP" = x; then + STRIP=":" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + STRIP=$ac_ct_STRIP + fi +else + STRIP="$ac_cv_prog_STRIP" +fi + +test -z "$STRIP" && STRIP=: + + + + + + +if test -n "$ac_tool_prefix"; then + # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args. +set dummy ${ac_tool_prefix}ranlib; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_RANLIB+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$RANLIB"; then + ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +RANLIB=$ac_cv_prog_RANLIB +if test -n "$RANLIB"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RANLIB" >&5 +$as_echo "$RANLIB" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test -z "$ac_cv_prog_RANLIB"; then + ac_ct_RANLIB=$RANLIB + # Extract the first word of "ranlib", so it can be a program name with args. +set dummy ranlib; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_ac_ct_RANLIB+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_RANLIB"; then + ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_RANLIB="ranlib" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB +if test -n "$ac_ct_RANLIB"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_RANLIB" >&5 +$as_echo "$ac_ct_RANLIB" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + if test "x$ac_ct_RANLIB" = x; then + RANLIB=":" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + RANLIB=$ac_ct_RANLIB + fi +else + RANLIB="$ac_cv_prog_RANLIB" +fi + +test -z "$RANLIB" && RANLIB=: + + + + + + +# Determine commands to create old-style static archives. +old_archive_cmds='$AR $AR_FLAGS $oldlib$oldobjs' +old_postinstall_cmds='chmod 644 $oldlib' +old_postuninstall_cmds= + +if test -n "$RANLIB"; then + case $host_os in + openbsd*) + old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB -t \$tool_oldlib" + ;; + *) + old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB \$tool_oldlib" + ;; + esac + old_archive_cmds="$old_archive_cmds~\$RANLIB \$tool_oldlib" +fi + +case $host_os in + darwin*) + lock_old_archive_extraction=yes ;; + *) + lock_old_archive_extraction=no ;; +esac + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +# If no C compiler was specified, use CC. +LTCC=${LTCC-"$CC"} + +# If no C compiler flags were specified, use CFLAGS. +LTCFLAGS=${LTCFLAGS-"$CFLAGS"} + +# Allow CC to be a program name with arguments. +compiler=$CC + + +# Check for command to grab the raw symbol name followed by C symbol from nm. +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking command to parse $NM output from $compiler object" >&5 +$as_echo_n "checking command to parse $NM output from $compiler object... " >&6; } +if ${lt_cv_sys_global_symbol_pipe+:} false; then : + $as_echo_n "(cached) " >&6 +else + +# These are sane defaults that work on at least a few old systems. +# [They come from Ultrix. What could be older than Ultrix?!! ;)] + +# Character class describing NM global symbol codes. +symcode='[BCDEGRST]' + +# Regexp to match symbols that can be accessed directly from C. +sympat='\([_A-Za-z][_A-Za-z0-9]*\)' + +# Define system-specific variables. +case $host_os in +aix*) + symcode='[BCDT]' + ;; +cygwin* | mingw* | pw32* | cegcc*) + symcode='[ABCDGISTW]' + ;; +hpux*) + if test "$host_cpu" = ia64; then + symcode='[ABCDEGRST]' + fi + ;; +irix* | nonstopux*) + symcode='[BCDEGRST]' + ;; +osf*) + symcode='[BCDEGQRST]' + ;; +solaris*) + symcode='[BDRT]' + ;; +sco3.2v5*) + symcode='[DT]' + ;; +sysv4.2uw2*) + symcode='[DT]' + ;; +sysv5* | sco5v6* | unixware* | OpenUNIX*) + symcode='[ABDT]' + ;; +sysv4) + symcode='[DFNSTU]' + ;; +esac + +# If we're using GNU nm, then use its standard symbol codes. +case `$NM -V 2>&1` in +*GNU* | *'with BFD'*) + symcode='[ABCDGIRSTW]' ;; +esac + +# Transform an extracted symbol line into a proper C declaration. +# Some systems (esp. on ia64) link data and code symbols differently, +# so use this general approach. +lt_cv_sys_global_symbol_to_cdecl="sed -n -e 's/^T .* \(.*\)$/extern int \1();/p' -e 's/^$symcode* .* \(.*\)$/extern char \1;/p'" + +# Transform an extracted symbol line into symbol name and symbol address +lt_cv_sys_global_symbol_to_c_name_address="sed -n -e 's/^: \([^ ]*\)[ ]*$/ {\\\"\1\\\", (void *) 0},/p' -e 's/^$symcode* \([^ ]*\) \([^ ]*\)$/ {\"\2\", (void *) \&\2},/p'" +lt_cv_sys_global_symbol_to_c_name_address_lib_prefix="sed -n -e 's/^: \([^ ]*\)[ ]*$/ {\\\"\1\\\", (void *) 0},/p' -e 's/^$symcode* \([^ ]*\) \(lib[^ ]*\)$/ {\"\2\", (void *) \&\2},/p' -e 's/^$symcode* \([^ ]*\) \([^ ]*\)$/ {\"lib\2\", (void *) \&\2},/p'" + +# Handle CRLF in mingw tool chain +opt_cr= +case $build_os in +mingw*) + opt_cr=`$ECHO 'x\{0,1\}' | tr x '\015'` # option cr in regexp + ;; +esac + +# Try without a prefix underscore, then with it. +for ac_symprfx in "" "_"; do + + # Transform symcode, sympat, and symprfx into a raw symbol and a C symbol. + symxfrm="\\1 $ac_symprfx\\2 \\2" + + # Write the raw and C identifiers. + if test "$lt_cv_nm_interface" = "MS dumpbin"; then + # Fake it for dumpbin and say T for any non-static function + # and D for any global variable. + # Also find C++ and __fastcall symbols from MSVC++, + # which start with @ or ?. + lt_cv_sys_global_symbol_pipe="$AWK '"\ +" {last_section=section; section=\$ 3};"\ +" /^COFF SYMBOL TABLE/{for(i in hide) delete hide[i]};"\ +" /Section length .*#relocs.*(pick any)/{hide[last_section]=1};"\ +" \$ 0!~/External *\|/{next};"\ +" / 0+ UNDEF /{next}; / UNDEF \([^|]\)*()/{next};"\ +" {if(hide[section]) next};"\ +" {f=0}; \$ 0~/\(\).*\|/{f=1}; {printf f ? \"T \" : \"D \"};"\ +" {split(\$ 0, a, /\||\r/); split(a[2], s)};"\ +" s[1]~/^[@?]/{print s[1], s[1]; next};"\ +" s[1]~prfx {split(s[1],t,\"@\"); print t[1], substr(t[1],length(prfx))}"\ +" ' prfx=^$ac_symprfx" + else + lt_cv_sys_global_symbol_pipe="sed -n -e 's/^.*[ ]\($symcode$symcode*\)[ ][ ]*$ac_symprfx$sympat$opt_cr$/$symxfrm/p'" + fi + lt_cv_sys_global_symbol_pipe="$lt_cv_sys_global_symbol_pipe | sed '/ __gnu_lto/d'" + + # Check to see that the pipe works correctly. + pipe_works=no + + rm -f conftest* + cat > conftest.$ac_ext <<_LT_EOF +#ifdef __cplusplus +extern "C" { +#endif +char nm_test_var; +void nm_test_func(void); +void nm_test_func(void){} +#ifdef __cplusplus +} +#endif +int main(){nm_test_var='a';nm_test_func();return(0);} +_LT_EOF + + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 + (eval $ac_compile) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then + # Now try to grab the symbols. + nlist=conftest.nm + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$NM conftest.$ac_objext \| "$lt_cv_sys_global_symbol_pipe" \> $nlist\""; } >&5 + (eval $NM conftest.$ac_objext \| "$lt_cv_sys_global_symbol_pipe" \> $nlist) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } && test -s "$nlist"; then + # Try sorting and uniquifying the output. + if sort "$nlist" | uniq > "$nlist"T; then + mv -f "$nlist"T "$nlist" + else + rm -f "$nlist"T + fi + + # Make sure that we snagged all the symbols we need. + if $GREP ' nm_test_var$' "$nlist" >/dev/null; then + if $GREP ' nm_test_func$' "$nlist" >/dev/null; then + cat <<_LT_EOF > conftest.$ac_ext +/* Keep this code in sync between libtool.m4, ltmain, lt_system.h, and tests. */ +#if defined(_WIN32) || defined(__CYGWIN__) || defined(_WIN32_WCE) +/* DATA imports from DLLs on WIN32 con't be const, because runtime + relocations are performed -- see ld's documentation on pseudo-relocs. */ +# define LT_DLSYM_CONST +#elif defined(__osf__) +/* This system does not cope well with relocations in const data. */ +# define LT_DLSYM_CONST +#else +# define LT_DLSYM_CONST const +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +_LT_EOF + # Now generate the symbol file. + eval "$lt_cv_sys_global_symbol_to_cdecl"' < "$nlist" | $GREP -v main >> conftest.$ac_ext' + + cat <<_LT_EOF >> conftest.$ac_ext + +/* The mapping between symbol names and symbols. */ +LT_DLSYM_CONST struct { + const char *name; + void *address; +} +lt__PROGRAM__LTX_preloaded_symbols[] = +{ + { "@PROGRAM@", (void *) 0 }, +_LT_EOF + $SED "s/^$symcode$symcode* \(.*\) \(.*\)$/ {\"\2\", (void *) \&\2},/" < "$nlist" | $GREP -v main >> conftest.$ac_ext + cat <<\_LT_EOF >> conftest.$ac_ext + {0, (void *) 0} +}; + +/* This works around a problem in FreeBSD linker */ +#ifdef FREEBSD_WORKAROUND +static const void *lt_preloaded_setup() { + return lt__PROGRAM__LTX_preloaded_symbols; +} +#endif + +#ifdef __cplusplus +} +#endif +_LT_EOF + # Now try linking the two files. + mv conftest.$ac_objext conftstm.$ac_objext + lt_globsym_save_LIBS=$LIBS + lt_globsym_save_CFLAGS=$CFLAGS + LIBS="conftstm.$ac_objext" + CFLAGS="$CFLAGS$lt_prog_compiler_no_builtin_flag" + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5 + (eval $ac_link) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } && test -s conftest${ac_exeext}; then + pipe_works=yes + fi + LIBS=$lt_globsym_save_LIBS + CFLAGS=$lt_globsym_save_CFLAGS + else + echo "cannot find nm_test_func in $nlist" >&5 + fi + else + echo "cannot find nm_test_var in $nlist" >&5 + fi + else + echo "cannot run $lt_cv_sys_global_symbol_pipe" >&5 + fi + else + echo "$progname: failed program was:" >&5 + cat conftest.$ac_ext >&5 + fi + rm -rf conftest* conftst* + + # Do not use the global_symbol_pipe unless it works. + if test "$pipe_works" = yes; then + break + else + lt_cv_sys_global_symbol_pipe= + fi +done + +fi + +if test -z "$lt_cv_sys_global_symbol_pipe"; then + lt_cv_sys_global_symbol_to_cdecl= +fi +if test -z "$lt_cv_sys_global_symbol_pipe$lt_cv_sys_global_symbol_to_cdecl"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: failed" >&5 +$as_echo "failed" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5 +$as_echo "ok" >&6; } +fi + +# Response file support. +if test "$lt_cv_nm_interface" = "MS dumpbin"; then + nm_file_list_spec='@' +elif $NM --help 2>/dev/null | grep '[@]FILE' >/dev/null; then + nm_file_list_spec='@' +fi + + + + + + + + + + + + + + + + + + + + + + + + + + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for sysroot" >&5 +$as_echo_n "checking for sysroot... " >&6; } + +# Check whether --with-sysroot was given. +if test "${with_sysroot+set}" = set; then : + withval=$with_sysroot; +else + with_sysroot=no +fi + + +lt_sysroot= +case ${with_sysroot} in #( + yes) + if test "$GCC" = yes; then + lt_sysroot=`$CC --print-sysroot 2>/dev/null` + fi + ;; #( + /*) + lt_sysroot=`echo "$with_sysroot" | sed -e "$sed_quote_subst"` + ;; #( + no|'') + ;; #( + *) + { $as_echo "$as_me:${as_lineno-$LINENO}: result: ${with_sysroot}" >&5 +$as_echo "${with_sysroot}" >&6; } + as_fn_error $? "The sysroot must be an absolute path." "$LINENO" 5 + ;; +esac + + { $as_echo "$as_me:${as_lineno-$LINENO}: result: ${lt_sysroot:-no}" >&5 +$as_echo "${lt_sysroot:-no}" >&6; } + + + + + +# Check whether --enable-libtool-lock was given. +if test "${enable_libtool_lock+set}" = set; then : + enableval=$enable_libtool_lock; +fi + +test "x$enable_libtool_lock" != xno && enable_libtool_lock=yes + +# Some flags need to be propagated to the compiler or linker for good +# libtool support. +case $host in +ia64-*-hpux*) + # Find out which ABI we are using. + echo 'int i;' > conftest.$ac_ext + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 + (eval $ac_compile) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then + case `/usr/bin/file conftest.$ac_objext` in + *ELF-32*) + HPUX_IA64_MODE="32" + ;; + *ELF-64*) + HPUX_IA64_MODE="64" + ;; + esac + fi + rm -rf conftest* + ;; +*-*-irix6*) + # Find out which ABI we are using. + echo '#line '$LINENO' "configure"' > conftest.$ac_ext + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 + (eval $ac_compile) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then + if test "$lt_cv_prog_gnu_ld" = yes; then + case `/usr/bin/file conftest.$ac_objext` in + *32-bit*) + LD="${LD-ld} -melf32bsmip" + ;; + *N32*) + LD="${LD-ld} -melf32bmipn32" + ;; + *64-bit*) + LD="${LD-ld} -melf64bmip" + ;; + esac + else + case `/usr/bin/file conftest.$ac_objext` in + *32-bit*) + LD="${LD-ld} -32" + ;; + *N32*) + LD="${LD-ld} -n32" + ;; + *64-bit*) + LD="${LD-ld} -64" + ;; + esac + fi + fi + rm -rf conftest* + ;; + +x86_64-*kfreebsd*-gnu|x86_64-*linux*|ppc*-*linux*|powerpc*-*linux*| \ +s390*-*linux*|s390*-*tpf*|sparc*-*linux*) + # Find out which ABI we are using. + echo 'int i;' > conftest.$ac_ext + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 + (eval $ac_compile) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then + case `/usr/bin/file conftest.o` in + *32-bit*) + case $host in + x86_64-*kfreebsd*-gnu) + LD="${LD-ld} -m elf_i386_fbsd" + ;; + x86_64-*linux*) + case `/usr/bin/file conftest.o` in + *x86-64*) + LD="${LD-ld} -m elf32_x86_64" + ;; + *) + LD="${LD-ld} -m elf_i386" + ;; + esac + ;; + ppc64-*linux*|powerpc64-*linux*) + LD="${LD-ld} -m elf32ppclinux" + ;; + s390x-*linux*) + LD="${LD-ld} -m elf_s390" + ;; + sparc64-*linux*) + LD="${LD-ld} -m elf32_sparc" + ;; + esac + ;; + *64-bit*) + case $host in + x86_64-*kfreebsd*-gnu) + LD="${LD-ld} -m elf_x86_64_fbsd" + ;; + x86_64-*linux*) + LD="${LD-ld} -m elf_x86_64" + ;; + ppc*-*linux*|powerpc*-*linux*) + LD="${LD-ld} -m elf64ppc" + ;; + s390*-*linux*|s390*-*tpf*) + LD="${LD-ld} -m elf64_s390" + ;; + sparc*-*linux*) + LD="${LD-ld} -m elf64_sparc" + ;; + esac + ;; + esac + fi + rm -rf conftest* + ;; + +*-*-sco3.2v5*) + # On SCO OpenServer 5, we need -belf to get full-featured binaries. + SAVE_CFLAGS="$CFLAGS" + CFLAGS="$CFLAGS -belf" + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C compiler needs -belf" >&5 +$as_echo_n "checking whether the C compiler needs -belf... " >&6; } +if ${lt_cv_cc_needs_belf+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu + + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + lt_cv_cc_needs_belf=yes +else + lt_cv_cc_needs_belf=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext + ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_cc_needs_belf" >&5 +$as_echo "$lt_cv_cc_needs_belf" >&6; } + if test x"$lt_cv_cc_needs_belf" != x"yes"; then + # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf + CFLAGS="$SAVE_CFLAGS" + fi + ;; +*-*solaris*) + # Find out which ABI we are using. + echo 'int i;' > conftest.$ac_ext + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 + (eval $ac_compile) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then + case `/usr/bin/file conftest.o` in + *64-bit*) + case $lt_cv_prog_gnu_ld in + yes*) + case $host in + i?86-*-solaris*) + LD="${LD-ld} -m elf_x86_64" + ;; + sparc*-*-solaris*) + LD="${LD-ld} -m elf64_sparc" + ;; + esac + # GNU ld 2.21 introduced _sol2 emulations. Use them if available. + if ${LD-ld} -V | grep _sol2 >/dev/null 2>&1; then + LD="${LD-ld}_sol2" + fi + ;; + *) + if ${LD-ld} -64 -r -o conftest2.o conftest.o >/dev/null 2>&1; then + LD="${LD-ld} -64" + fi + ;; + esac + ;; + esac + fi + rm -rf conftest* + ;; +esac + +need_locks="$enable_libtool_lock" + +if test -n "$ac_tool_prefix"; then + # Extract the first word of "${ac_tool_prefix}mt", so it can be a program name with args. +set dummy ${ac_tool_prefix}mt; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_MANIFEST_TOOL+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$MANIFEST_TOOL"; then + ac_cv_prog_MANIFEST_TOOL="$MANIFEST_TOOL" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_MANIFEST_TOOL="${ac_tool_prefix}mt" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +MANIFEST_TOOL=$ac_cv_prog_MANIFEST_TOOL +if test -n "$MANIFEST_TOOL"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MANIFEST_TOOL" >&5 +$as_echo "$MANIFEST_TOOL" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test -z "$ac_cv_prog_MANIFEST_TOOL"; then + ac_ct_MANIFEST_TOOL=$MANIFEST_TOOL + # Extract the first word of "mt", so it can be a program name with args. +set dummy mt; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_ac_ct_MANIFEST_TOOL+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_MANIFEST_TOOL"; then + ac_cv_prog_ac_ct_MANIFEST_TOOL="$ac_ct_MANIFEST_TOOL" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_MANIFEST_TOOL="mt" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_MANIFEST_TOOL=$ac_cv_prog_ac_ct_MANIFEST_TOOL +if test -n "$ac_ct_MANIFEST_TOOL"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_MANIFEST_TOOL" >&5 +$as_echo "$ac_ct_MANIFEST_TOOL" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + if test "x$ac_ct_MANIFEST_TOOL" = x; then + MANIFEST_TOOL=":" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + MANIFEST_TOOL=$ac_ct_MANIFEST_TOOL + fi +else + MANIFEST_TOOL="$ac_cv_prog_MANIFEST_TOOL" +fi + +test -z "$MANIFEST_TOOL" && MANIFEST_TOOL=mt +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if $MANIFEST_TOOL is a manifest tool" >&5 +$as_echo_n "checking if $MANIFEST_TOOL is a manifest tool... " >&6; } +if ${lt_cv_path_mainfest_tool+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_path_mainfest_tool=no + echo "$as_me:$LINENO: $MANIFEST_TOOL '-?'" >&5 + $MANIFEST_TOOL '-?' 2>conftest.err > conftest.out + cat conftest.err >&5 + if $GREP 'Manifest Tool' conftest.out > /dev/null; then + lt_cv_path_mainfest_tool=yes + fi + rm -f conftest* +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_path_mainfest_tool" >&5 +$as_echo "$lt_cv_path_mainfest_tool" >&6; } +if test "x$lt_cv_path_mainfest_tool" != xyes; then + MANIFEST_TOOL=: +fi + + + + + + + case $host_os in + rhapsody* | darwin*) + if test -n "$ac_tool_prefix"; then + # Extract the first word of "${ac_tool_prefix}dsymutil", so it can be a program name with args. +set dummy ${ac_tool_prefix}dsymutil; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_DSYMUTIL+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$DSYMUTIL"; then + ac_cv_prog_DSYMUTIL="$DSYMUTIL" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_DSYMUTIL="${ac_tool_prefix}dsymutil" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +DSYMUTIL=$ac_cv_prog_DSYMUTIL +if test -n "$DSYMUTIL"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5 +$as_echo "$DSYMUTIL" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test -z "$ac_cv_prog_DSYMUTIL"; then + ac_ct_DSYMUTIL=$DSYMUTIL + # Extract the first word of "dsymutil", so it can be a program name with args. +set dummy dsymutil; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_ac_ct_DSYMUTIL+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_DSYMUTIL"; then + ac_cv_prog_ac_ct_DSYMUTIL="$ac_ct_DSYMUTIL" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_DSYMUTIL="dsymutil" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_DSYMUTIL=$ac_cv_prog_ac_ct_DSYMUTIL +if test -n "$ac_ct_DSYMUTIL"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DSYMUTIL" >&5 +$as_echo "$ac_ct_DSYMUTIL" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + if test "x$ac_ct_DSYMUTIL" = x; then + DSYMUTIL=":" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + DSYMUTIL=$ac_ct_DSYMUTIL + fi +else + DSYMUTIL="$ac_cv_prog_DSYMUTIL" +fi + + if test -n "$ac_tool_prefix"; then + # Extract the first word of "${ac_tool_prefix}nmedit", so it can be a program name with args. +set dummy ${ac_tool_prefix}nmedit; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_NMEDIT+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$NMEDIT"; then + ac_cv_prog_NMEDIT="$NMEDIT" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_NMEDIT="${ac_tool_prefix}nmedit" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +NMEDIT=$ac_cv_prog_NMEDIT +if test -n "$NMEDIT"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NMEDIT" >&5 +$as_echo "$NMEDIT" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test -z "$ac_cv_prog_NMEDIT"; then + ac_ct_NMEDIT=$NMEDIT + # Extract the first word of "nmedit", so it can be a program name with args. +set dummy nmedit; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_ac_ct_NMEDIT+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_NMEDIT"; then + ac_cv_prog_ac_ct_NMEDIT="$ac_ct_NMEDIT" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_NMEDIT="nmedit" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_NMEDIT=$ac_cv_prog_ac_ct_NMEDIT +if test -n "$ac_ct_NMEDIT"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_NMEDIT" >&5 +$as_echo "$ac_ct_NMEDIT" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + if test "x$ac_ct_NMEDIT" = x; then + NMEDIT=":" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + NMEDIT=$ac_ct_NMEDIT + fi +else + NMEDIT="$ac_cv_prog_NMEDIT" +fi + + if test -n "$ac_tool_prefix"; then + # Extract the first word of "${ac_tool_prefix}lipo", so it can be a program name with args. +set dummy ${ac_tool_prefix}lipo; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_LIPO+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$LIPO"; then + ac_cv_prog_LIPO="$LIPO" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_LIPO="${ac_tool_prefix}lipo" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +LIPO=$ac_cv_prog_LIPO +if test -n "$LIPO"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LIPO" >&5 +$as_echo "$LIPO" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test -z "$ac_cv_prog_LIPO"; then + ac_ct_LIPO=$LIPO + # Extract the first word of "lipo", so it can be a program name with args. +set dummy lipo; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_ac_ct_LIPO+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_LIPO"; then + ac_cv_prog_ac_ct_LIPO="$ac_ct_LIPO" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_LIPO="lipo" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_LIPO=$ac_cv_prog_ac_ct_LIPO +if test -n "$ac_ct_LIPO"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_LIPO" >&5 +$as_echo "$ac_ct_LIPO" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + if test "x$ac_ct_LIPO" = x; then + LIPO=":" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + LIPO=$ac_ct_LIPO + fi +else + LIPO="$ac_cv_prog_LIPO" +fi + + if test -n "$ac_tool_prefix"; then + # Extract the first word of "${ac_tool_prefix}otool", so it can be a program name with args. +set dummy ${ac_tool_prefix}otool; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_OTOOL+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$OTOOL"; then + ac_cv_prog_OTOOL="$OTOOL" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_OTOOL="${ac_tool_prefix}otool" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +OTOOL=$ac_cv_prog_OTOOL +if test -n "$OTOOL"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OTOOL" >&5 +$as_echo "$OTOOL" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test -z "$ac_cv_prog_OTOOL"; then + ac_ct_OTOOL=$OTOOL + # Extract the first word of "otool", so it can be a program name with args. +set dummy otool; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_ac_ct_OTOOL+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_OTOOL"; then + ac_cv_prog_ac_ct_OTOOL="$ac_ct_OTOOL" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_OTOOL="otool" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_OTOOL=$ac_cv_prog_ac_ct_OTOOL +if test -n "$ac_ct_OTOOL"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OTOOL" >&5 +$as_echo "$ac_ct_OTOOL" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + if test "x$ac_ct_OTOOL" = x; then + OTOOL=":" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + OTOOL=$ac_ct_OTOOL + fi +else + OTOOL="$ac_cv_prog_OTOOL" +fi + + if test -n "$ac_tool_prefix"; then + # Extract the first word of "${ac_tool_prefix}otool64", so it can be a program name with args. +set dummy ${ac_tool_prefix}otool64; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_OTOOL64+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$OTOOL64"; then + ac_cv_prog_OTOOL64="$OTOOL64" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_OTOOL64="${ac_tool_prefix}otool64" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +OTOOL64=$ac_cv_prog_OTOOL64 +if test -n "$OTOOL64"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OTOOL64" >&5 +$as_echo "$OTOOL64" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test -z "$ac_cv_prog_OTOOL64"; then + ac_ct_OTOOL64=$OTOOL64 + # Extract the first word of "otool64", so it can be a program name with args. +set dummy otool64; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_ac_ct_OTOOL64+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_OTOOL64"; then + ac_cv_prog_ac_ct_OTOOL64="$ac_ct_OTOOL64" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_OTOOL64="otool64" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_OTOOL64=$ac_cv_prog_ac_ct_OTOOL64 +if test -n "$ac_ct_OTOOL64"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OTOOL64" >&5 +$as_echo "$ac_ct_OTOOL64" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + if test "x$ac_ct_OTOOL64" = x; then + OTOOL64=":" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + OTOOL64=$ac_ct_OTOOL64 + fi +else + OTOOL64="$ac_cv_prog_OTOOL64" +fi + + + + + + + + + + + + + + + + + + + + + + + + + + + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for -single_module linker flag" >&5 +$as_echo_n "checking for -single_module linker flag... " >&6; } +if ${lt_cv_apple_cc_single_mod+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_apple_cc_single_mod=no + if test -z "${LT_MULTI_MODULE}"; then + # By default we will add the -single_module flag. You can override + # by either setting the environment variable LT_MULTI_MODULE + # non-empty at configure time, or by adding -multi_module to the + # link flags. + rm -rf libconftest.dylib* + echo "int foo(void){return 1;}" > conftest.c + echo "$LTCC $LTCFLAGS $LDFLAGS -o libconftest.dylib \ +-dynamiclib -Wl,-single_module conftest.c" >&5 + $LTCC $LTCFLAGS $LDFLAGS -o libconftest.dylib \ + -dynamiclib -Wl,-single_module conftest.c 2>conftest.err + _lt_result=$? + # If there is a non-empty error log, and "single_module" + # appears in it, assume the flag caused a linker warning + if test -s conftest.err && $GREP single_module conftest.err; then + cat conftest.err >&5 + # Otherwise, if the output was created with a 0 exit code from + # the compiler, it worked. + elif test -f libconftest.dylib && test $_lt_result -eq 0; then + lt_cv_apple_cc_single_mod=yes + else + cat conftest.err >&5 + fi + rm -rf libconftest.dylib* + rm -f conftest.* + fi +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_apple_cc_single_mod" >&5 +$as_echo "$lt_cv_apple_cc_single_mod" >&6; } + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for -exported_symbols_list linker flag" >&5 +$as_echo_n "checking for -exported_symbols_list linker flag... " >&6; } +if ${lt_cv_ld_exported_symbols_list+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_ld_exported_symbols_list=no + save_LDFLAGS=$LDFLAGS + echo "_main" > conftest.sym + LDFLAGS="$LDFLAGS -Wl,-exported_symbols_list,conftest.sym" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + lt_cv_ld_exported_symbols_list=yes +else + lt_cv_ld_exported_symbols_list=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext + LDFLAGS="$save_LDFLAGS" + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ld_exported_symbols_list" >&5 +$as_echo "$lt_cv_ld_exported_symbols_list" >&6; } + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for -force_load linker flag" >&5 +$as_echo_n "checking for -force_load linker flag... " >&6; } +if ${lt_cv_ld_force_load+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_ld_force_load=no + cat > conftest.c << _LT_EOF +int forced_loaded() { return 2;} +_LT_EOF + echo "$LTCC $LTCFLAGS -c -o conftest.o conftest.c" >&5 + $LTCC $LTCFLAGS -c -o conftest.o conftest.c 2>&5 + echo "$AR cru libconftest.a conftest.o" >&5 + $AR cru libconftest.a conftest.o 2>&5 + echo "$RANLIB libconftest.a" >&5 + $RANLIB libconftest.a 2>&5 + cat > conftest.c << _LT_EOF +int main() { return 0;} +_LT_EOF + echo "$LTCC $LTCFLAGS $LDFLAGS -o conftest conftest.c -Wl,-force_load,./libconftest.a" >&5 + $LTCC $LTCFLAGS $LDFLAGS -o conftest conftest.c -Wl,-force_load,./libconftest.a 2>conftest.err + _lt_result=$? + if test -s conftest.err && $GREP force_load conftest.err; then + cat conftest.err >&5 + elif test -f conftest && test $_lt_result -eq 0 && $GREP forced_load conftest >/dev/null 2>&1 ; then + lt_cv_ld_force_load=yes + else + cat conftest.err >&5 + fi + rm -f conftest.err libconftest.a conftest conftest.c + rm -rf conftest.dSYM + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ld_force_load" >&5 +$as_echo "$lt_cv_ld_force_load" >&6; } + case $host_os in + rhapsody* | darwin1.[012]) + _lt_dar_allow_undefined='${wl}-undefined ${wl}suppress' ;; + darwin1.*) + _lt_dar_allow_undefined='${wl}-flat_namespace ${wl}-undefined ${wl}suppress' ;; + darwin*) # darwin 5.x on + # if running on 10.5 or later, the deployment target defaults + # to the OS version, if on x86, and 10.4, the deployment + # target defaults to 10.4. Don't you love it? + case ${MACOSX_DEPLOYMENT_TARGET-10.0},$host in + 10.0,*86*-darwin8*|10.0,*-darwin[91]*) + _lt_dar_allow_undefined='${wl}-undefined ${wl}dynamic_lookup' ;; + 10.[012]*) + _lt_dar_allow_undefined='${wl}-flat_namespace ${wl}-undefined ${wl}suppress' ;; + 10.*) + _lt_dar_allow_undefined='${wl}-undefined ${wl}dynamic_lookup' ;; + esac + ;; + esac + if test "$lt_cv_apple_cc_single_mod" = "yes"; then + _lt_dar_single_mod='$single_module' + fi + if test "$lt_cv_ld_exported_symbols_list" = "yes"; then + _lt_dar_export_syms=' ${wl}-exported_symbols_list,$output_objdir/${libname}-symbols.expsym' + else + _lt_dar_export_syms='~$NMEDIT -s $output_objdir/${libname}-symbols.expsym ${lib}' + fi + if test "$DSYMUTIL" != ":" && test "$lt_cv_ld_force_load" = "no"; then + _lt_dsymutil='~$DSYMUTIL $lib || :' + else + _lt_dsymutil= + fi + ;; + esac + +ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor" >&5 +$as_echo_n "checking how to run the C preprocessor... " >&6; } +# On Suns, sometimes $CPP names a directory. +if test -n "$CPP" && test -d "$CPP"; then + CPP= +fi +if test -z "$CPP"; then + if ${ac_cv_prog_CPP+:} false; then : + $as_echo_n "(cached) " >&6 +else + # Double quotes because CPP needs to be expanded + for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp" + do + ac_preproc_ok=false +for ac_c_preproc_warn_flag in '' yes +do + # Use a header file that comes with gcc, so configuring glibc + # with a fresh cross-compiler works. + # Prefer to if __STDC__ is defined, since + # exists even on freestanding compilers. + # On the NeXT, cc -E runs the code through the compiler's parser, + # not just through cpp. "Syntax error" is here to catch this case. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#ifdef __STDC__ +# include +#else +# include +#endif + Syntax error +_ACEOF +if ac_fn_c_try_cpp "$LINENO"; then : + +else + # Broken: fails on valid input. +continue +fi +rm -f conftest.err conftest.i conftest.$ac_ext + + # OK, works on sane cases. Now check whether nonexistent headers + # can be detected and how. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +_ACEOF +if ac_fn_c_try_cpp "$LINENO"; then : + # Broken: success on invalid input. +continue +else + # Passes both tests. +ac_preproc_ok=: +break +fi +rm -f conftest.err conftest.i conftest.$ac_ext + +done +# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. +rm -f conftest.i conftest.err conftest.$ac_ext +if $ac_preproc_ok; then : + break +fi + + done + ac_cv_prog_CPP=$CPP + +fi + CPP=$ac_cv_prog_CPP +else + ac_cv_prog_CPP=$CPP +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPP" >&5 +$as_echo "$CPP" >&6; } +ac_preproc_ok=false +for ac_c_preproc_warn_flag in '' yes +do + # Use a header file that comes with gcc, so configuring glibc + # with a fresh cross-compiler works. + # Prefer to if __STDC__ is defined, since + # exists even on freestanding compilers. + # On the NeXT, cc -E runs the code through the compiler's parser, + # not just through cpp. "Syntax error" is here to catch this case. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#ifdef __STDC__ +# include +#else +# include +#endif + Syntax error +_ACEOF +if ac_fn_c_try_cpp "$LINENO"; then : + +else + # Broken: fails on valid input. +continue +fi +rm -f conftest.err conftest.i conftest.$ac_ext + + # OK, works on sane cases. Now check whether nonexistent headers + # can be detected and how. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +_ACEOF +if ac_fn_c_try_cpp "$LINENO"; then : + # Broken: success on invalid input. +continue +else + # Passes both tests. +ac_preproc_ok=: +break +fi +rm -f conftest.err conftest.i conftest.$ac_ext + +done +# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. +rm -f conftest.i conftest.err conftest.$ac_ext +if $ac_preproc_ok; then : + +else + { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 +$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} +as_fn_error $? "C preprocessor \"$CPP\" fails sanity check +See \`config.log' for more details" "$LINENO" 5; } +fi + +ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for ANSI C header files" >&5 +$as_echo_n "checking for ANSI C header files... " >&6; } +if ${ac_cv_header_stdc+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +#include +#include +#include + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_compile "$LINENO"; then : + ac_cv_header_stdc=yes +else + ac_cv_header_stdc=no +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext + +if test $ac_cv_header_stdc = yes; then + # SunOS 4.x string.h does not declare mem*, contrary to ANSI. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include + +_ACEOF +if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | + $EGREP "memchr" >/dev/null 2>&1; then : + +else + ac_cv_header_stdc=no +fi +rm -f conftest* + +fi + +if test $ac_cv_header_stdc = yes; then + # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include + +_ACEOF +if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | + $EGREP "free" >/dev/null 2>&1; then : + +else + ac_cv_header_stdc=no +fi +rm -f conftest* + +fi + +if test $ac_cv_header_stdc = yes; then + # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi. + if test "$cross_compiling" = yes; then : + : +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +#include +#if ((' ' & 0x0FF) == 0x020) +# define ISLOWER(c) ('a' <= (c) && (c) <= 'z') +# define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c)) +#else +# define ISLOWER(c) \ + (('a' <= (c) && (c) <= 'i') \ + || ('j' <= (c) && (c) <= 'r') \ + || ('s' <= (c) && (c) <= 'z')) +# define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c)) +#endif + +#define XOR(e, f) (((e) && !(f)) || (!(e) && (f))) +int +main () +{ + int i; + for (i = 0; i < 256; i++) + if (XOR (islower (i), ISLOWER (i)) + || toupper (i) != TOUPPER (i)) + return 2; + return 0; +} +_ACEOF +if ac_fn_c_try_run "$LINENO"; then : + +else + ac_cv_header_stdc=no +fi +rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ + conftest.$ac_objext conftest.beam conftest.$ac_ext +fi + +fi +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdc" >&5 +$as_echo "$ac_cv_header_stdc" >&6; } +if test $ac_cv_header_stdc = yes; then + +$as_echo "#define STDC_HEADERS 1" >>confdefs.h + +fi + +# On IRIX 5.3, sys/types and inttypes.h are conflicting. +for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \ + inttypes.h stdint.h unistd.h +do : + as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh` +ac_fn_c_check_header_compile "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default +" +if eval test \"x\$"$as_ac_Header"\" = x"yes"; then : + cat >>confdefs.h <<_ACEOF +#define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1 +_ACEOF + +fi + +done + + +for ac_header in dlfcn.h +do : + ac_fn_c_check_header_compile "$LINENO" "dlfcn.h" "ac_cv_header_dlfcn_h" "$ac_includes_default +" +if test "x$ac_cv_header_dlfcn_h" = xyes; then : + cat >>confdefs.h <<_ACEOF +#define HAVE_DLFCN_H 1 +_ACEOF + +fi + +done + + + + + +# Set options +enable_win32_dll=yes + +case $host in +*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-cegcc*) + if test -n "$ac_tool_prefix"; then + # Extract the first word of "${ac_tool_prefix}as", so it can be a program name with args. +set dummy ${ac_tool_prefix}as; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_AS+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$AS"; then + ac_cv_prog_AS="$AS" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_AS="${ac_tool_prefix}as" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +AS=$ac_cv_prog_AS +if test -n "$AS"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AS" >&5 +$as_echo "$AS" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test -z "$ac_cv_prog_AS"; then + ac_ct_AS=$AS + # Extract the first word of "as", so it can be a program name with args. +set dummy as; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_ac_ct_AS+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_AS"; then + ac_cv_prog_ac_ct_AS="$ac_ct_AS" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_AS="as" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_AS=$ac_cv_prog_ac_ct_AS +if test -n "$ac_ct_AS"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_AS" >&5 +$as_echo "$ac_ct_AS" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + if test "x$ac_ct_AS" = x; then + AS="false" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + AS=$ac_ct_AS + fi +else + AS="$ac_cv_prog_AS" +fi + + if test -n "$ac_tool_prefix"; then + # Extract the first word of "${ac_tool_prefix}dlltool", so it can be a program name with args. +set dummy ${ac_tool_prefix}dlltool; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_DLLTOOL+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$DLLTOOL"; then + ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_DLLTOOL="${ac_tool_prefix}dlltool" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +DLLTOOL=$ac_cv_prog_DLLTOOL +if test -n "$DLLTOOL"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DLLTOOL" >&5 +$as_echo "$DLLTOOL" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test -z "$ac_cv_prog_DLLTOOL"; then + ac_ct_DLLTOOL=$DLLTOOL + # Extract the first word of "dlltool", so it can be a program name with args. +set dummy dlltool; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_ac_ct_DLLTOOL+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_DLLTOOL"; then + ac_cv_prog_ac_ct_DLLTOOL="$ac_ct_DLLTOOL" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_DLLTOOL="dlltool" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_DLLTOOL=$ac_cv_prog_ac_ct_DLLTOOL +if test -n "$ac_ct_DLLTOOL"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DLLTOOL" >&5 +$as_echo "$ac_ct_DLLTOOL" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + if test "x$ac_ct_DLLTOOL" = x; then + DLLTOOL="false" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + DLLTOOL=$ac_ct_DLLTOOL + fi +else + DLLTOOL="$ac_cv_prog_DLLTOOL" +fi + + if test -n "$ac_tool_prefix"; then + # Extract the first word of "${ac_tool_prefix}objdump", so it can be a program name with args. +set dummy ${ac_tool_prefix}objdump; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_OBJDUMP+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$OBJDUMP"; then + ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_OBJDUMP="${ac_tool_prefix}objdump" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +OBJDUMP=$ac_cv_prog_OBJDUMP +if test -n "$OBJDUMP"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OBJDUMP" >&5 +$as_echo "$OBJDUMP" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + +fi +if test -z "$ac_cv_prog_OBJDUMP"; then + ac_ct_OBJDUMP=$OBJDUMP + # Extract the first word of "objdump", so it can be a program name with args. +set dummy objdump; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_ac_ct_OBJDUMP+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_OBJDUMP"; then + ac_cv_prog_ac_ct_OBJDUMP="$ac_ct_OBJDUMP" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_OBJDUMP="objdump" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_OBJDUMP=$ac_cv_prog_ac_ct_OBJDUMP +if test -n "$ac_ct_OBJDUMP"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OBJDUMP" >&5 +$as_echo "$ac_ct_OBJDUMP" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + if test "x$ac_ct_OBJDUMP" = x; then + OBJDUMP="false" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + OBJDUMP=$ac_ct_OBJDUMP + fi +else + OBJDUMP="$ac_cv_prog_OBJDUMP" +fi + + ;; +esac + +test -z "$AS" && AS=as + + + + + +test -z "$DLLTOOL" && DLLTOOL=dlltool + + + + + +test -z "$OBJDUMP" && OBJDUMP=objdump + + + + + + + + enable_dlopen=no + + + + # Check whether --enable-shared was given. +if test "${enable_shared+set}" = set; then : + enableval=$enable_shared; p=${PACKAGE-default} + case $enableval in + yes) enable_shared=yes ;; + no) enable_shared=no ;; + *) + enable_shared=no + # Look at the argument we got. We use all the common list separators. + lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR," + for pkg in $enableval; do + IFS="$lt_save_ifs" + if test "X$pkg" = "X$p"; then + enable_shared=yes + fi + done + IFS="$lt_save_ifs" + ;; + esac +else + enable_shared=yes +fi + + + + + + + + + + # Check whether --enable-static was given. +if test "${enable_static+set}" = set; then : + enableval=$enable_static; p=${PACKAGE-default} + case $enableval in + yes) enable_static=yes ;; + no) enable_static=no ;; + *) + enable_static=no + # Look at the argument we got. We use all the common list separators. + lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR," + for pkg in $enableval; do + IFS="$lt_save_ifs" + if test "X$pkg" = "X$p"; then + enable_static=yes + fi + done + IFS="$lt_save_ifs" + ;; + esac +else + enable_static=yes +fi + + + + + + + + + + +# Check whether --with-pic was given. +if test "${with_pic+set}" = set; then : + withval=$with_pic; lt_p=${PACKAGE-default} + case $withval in + yes|no) pic_mode=$withval ;; + *) + pic_mode=default + # Look at the argument we got. We use all the common list separators. + lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR," + for lt_pkg in $withval; do + IFS="$lt_save_ifs" + if test "X$lt_pkg" = "X$lt_p"; then + pic_mode=yes + fi + done + IFS="$lt_save_ifs" + ;; + esac +else + pic_mode=default +fi + + +test -z "$pic_mode" && pic_mode=default + + + + + + + + # Check whether --enable-fast-install was given. +if test "${enable_fast_install+set}" = set; then : + enableval=$enable_fast_install; p=${PACKAGE-default} + case $enableval in + yes) enable_fast_install=yes ;; + no) enable_fast_install=no ;; + *) + enable_fast_install=no + # Look at the argument we got. We use all the common list separators. + lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR," + for pkg in $enableval; do + IFS="$lt_save_ifs" + if test "X$pkg" = "X$p"; then + enable_fast_install=yes + fi + done + IFS="$lt_save_ifs" + ;; + esac +else + enable_fast_install=yes +fi + + + + + + + + + + + +# This can be used to rebuild libtool when needed +LIBTOOL_DEPS="$ltmain" + +# Always use our own libtool. +LIBTOOL='$(SHELL) $(top_builddir)/libtool' + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +test -z "$LN_S" && LN_S="ln -s" + + + + + + + + + + + + + + +if test -n "${ZSH_VERSION+set}" ; then + setopt NO_GLOB_SUBST +fi + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for objdir" >&5 +$as_echo_n "checking for objdir... " >&6; } +if ${lt_cv_objdir+:} false; then : + $as_echo_n "(cached) " >&6 +else + rm -f .libs 2>/dev/null +mkdir .libs 2>/dev/null +if test -d .libs; then + lt_cv_objdir=.libs +else + # MS-DOS does not allow filenames that begin with a dot. + lt_cv_objdir=_libs +fi +rmdir .libs 2>/dev/null +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_objdir" >&5 +$as_echo "$lt_cv_objdir" >&6; } +objdir=$lt_cv_objdir + + + + + +cat >>confdefs.h <<_ACEOF +#define LT_OBJDIR "$lt_cv_objdir/" +_ACEOF + + + + +case $host_os in +aix3*) + # AIX sometimes has problems with the GCC collect2 program. For some + # reason, if we set the COLLECT_NAMES environment variable, the problems + # vanish in a puff of smoke. + if test "X${COLLECT_NAMES+set}" != Xset; then + COLLECT_NAMES= + export COLLECT_NAMES + fi + ;; +esac + +# Global variables: +ofile=libtool +can_build_shared=yes + +# All known linkers require a `.a' archive for static linking (except MSVC, +# which needs '.lib'). +libext=a + +with_gnu_ld="$lt_cv_prog_gnu_ld" + +old_CC="$CC" +old_CFLAGS="$CFLAGS" + +# Set sane defaults for various variables +test -z "$CC" && CC=cc +test -z "$LTCC" && LTCC=$CC +test -z "$LTCFLAGS" && LTCFLAGS=$CFLAGS +test -z "$LD" && LD=ld +test -z "$ac_objext" && ac_objext=o + +for cc_temp in $compiler""; do + case $cc_temp in + compile | *[\\/]compile | ccache | *[\\/]ccache ) ;; + distcc | *[\\/]distcc | purify | *[\\/]purify ) ;; + \-*) ;; + *) break;; + esac +done +cc_basename=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"` + + +# Only perform the check for file, if the check method requires it +test -z "$MAGIC_CMD" && MAGIC_CMD=file +case $deplibs_check_method in +file_magic*) + if test "$file_magic_cmd" = '$MAGIC_CMD'; then + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ${ac_tool_prefix}file" >&5 +$as_echo_n "checking for ${ac_tool_prefix}file... " >&6; } +if ${lt_cv_path_MAGIC_CMD+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $MAGIC_CMD in +[\\/*] | ?:[\\/]*) + lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path. + ;; +*) + lt_save_MAGIC_CMD="$MAGIC_CMD" + lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR + ac_dummy="/usr/bin$PATH_SEPARATOR$PATH" + for ac_dir in $ac_dummy; do + IFS="$lt_save_ifs" + test -z "$ac_dir" && ac_dir=. + if test -f $ac_dir/${ac_tool_prefix}file; then + lt_cv_path_MAGIC_CMD="$ac_dir/${ac_tool_prefix}file" + if test -n "$file_magic_test_file"; then + case $deplibs_check_method in + "file_magic "*) + file_magic_regex=`expr "$deplibs_check_method" : "file_magic \(.*\)"` + MAGIC_CMD="$lt_cv_path_MAGIC_CMD" + if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null | + $EGREP "$file_magic_regex" > /dev/null; then + : + else + cat <<_LT_EOF 1>&2 + +*** Warning: the command libtool uses to detect shared libraries, +*** $file_magic_cmd, produces output that libtool cannot recognize. +*** The result is that libtool may fail to recognize shared libraries +*** as such. This will affect the creation of libtool libraries that +*** depend on shared libraries, but programs linked with such libtool +*** libraries will work regardless of this problem. Nevertheless, you +*** may want to report the problem to your system manager and/or to +*** bug-libtool@gnu.org + +_LT_EOF + fi ;; + esac + fi + break + fi + done + IFS="$lt_save_ifs" + MAGIC_CMD="$lt_save_MAGIC_CMD" + ;; +esac +fi + +MAGIC_CMD="$lt_cv_path_MAGIC_CMD" +if test -n "$MAGIC_CMD"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MAGIC_CMD" >&5 +$as_echo "$MAGIC_CMD" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + + + +if test -z "$lt_cv_path_MAGIC_CMD"; then + if test -n "$ac_tool_prefix"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for file" >&5 +$as_echo_n "checking for file... " >&6; } +if ${lt_cv_path_MAGIC_CMD+:} false; then : + $as_echo_n "(cached) " >&6 +else + case $MAGIC_CMD in +[\\/*] | ?:[\\/]*) + lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path. + ;; +*) + lt_save_MAGIC_CMD="$MAGIC_CMD" + lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR + ac_dummy="/usr/bin$PATH_SEPARATOR$PATH" + for ac_dir in $ac_dummy; do + IFS="$lt_save_ifs" + test -z "$ac_dir" && ac_dir=. + if test -f $ac_dir/file; then + lt_cv_path_MAGIC_CMD="$ac_dir/file" + if test -n "$file_magic_test_file"; then + case $deplibs_check_method in + "file_magic "*) + file_magic_regex=`expr "$deplibs_check_method" : "file_magic \(.*\)"` + MAGIC_CMD="$lt_cv_path_MAGIC_CMD" + if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null | + $EGREP "$file_magic_regex" > /dev/null; then + : + else + cat <<_LT_EOF 1>&2 + +*** Warning: the command libtool uses to detect shared libraries, +*** $file_magic_cmd, produces output that libtool cannot recognize. +*** The result is that libtool may fail to recognize shared libraries +*** as such. This will affect the creation of libtool libraries that +*** depend on shared libraries, but programs linked with such libtool +*** libraries will work regardless of this problem. Nevertheless, you +*** may want to report the problem to your system manager and/or to +*** bug-libtool@gnu.org + +_LT_EOF + fi ;; + esac + fi + break + fi + done + IFS="$lt_save_ifs" + MAGIC_CMD="$lt_save_MAGIC_CMD" + ;; +esac +fi + +MAGIC_CMD="$lt_cv_path_MAGIC_CMD" +if test -n "$MAGIC_CMD"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MAGIC_CMD" >&5 +$as_echo "$MAGIC_CMD" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + else + MAGIC_CMD=: + fi +fi + + fi + ;; +esac + +# Use C for the default configuration in the libtool script + +lt_save_CC="$CC" +ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu + + +# Source file extension for C test sources. +ac_ext=c + +# Object file extension for compiled C test sources. +objext=o +objext=$objext + +# Code to be used in simple compile tests +lt_simple_compile_test_code="int some_variable = 0;" + +# Code to be used in simple link tests +lt_simple_link_test_code='int main(){return(0);}' + + + + + + + +# If no C compiler was specified, use CC. +LTCC=${LTCC-"$CC"} + +# If no C compiler flags were specified, use CFLAGS. +LTCFLAGS=${LTCFLAGS-"$CFLAGS"} + +# Allow CC to be a program name with arguments. +compiler=$CC + +# Save the default compiler, since it gets overwritten when the other +# tags are being tested, and _LT_TAGVAR(compiler, []) is a NOP. +compiler_DEFAULT=$CC + +# save warnings/boilerplate of simple test code +ac_outfile=conftest.$ac_objext +echo "$lt_simple_compile_test_code" >conftest.$ac_ext +eval "$ac_compile" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err +_lt_compiler_boilerplate=`cat conftest.err` +$RM conftest* + +ac_outfile=conftest.$ac_objext +echo "$lt_simple_link_test_code" >conftest.$ac_ext +eval "$ac_link" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err +_lt_linker_boilerplate=`cat conftest.err` +$RM -r conftest* + + +## CAVEAT EMPTOR: +## There is no encapsulation within the following macros, do not change +## the running order or otherwise move them around unless you know exactly +## what you are doing... +if test -n "$compiler"; then + +lt_prog_compiler_no_builtin_flag= + +if test "$GCC" = yes; then + case $cc_basename in + nvcc*) + lt_prog_compiler_no_builtin_flag=' -Xcompiler -fno-builtin' ;; + *) + lt_prog_compiler_no_builtin_flag=' -fno-builtin' ;; + esac + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -fno-rtti -fno-exceptions" >&5 +$as_echo_n "checking if $compiler supports -fno-rtti -fno-exceptions... " >&6; } +if ${lt_cv_prog_compiler_rtti_exceptions+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_prog_compiler_rtti_exceptions=no + ac_outfile=conftest.$ac_objext + echo "$lt_simple_compile_test_code" > conftest.$ac_ext + lt_compiler_flag="-fno-rtti -fno-exceptions" + # Insert the option either (1) after the last *FLAGS variable, or + # (2) before a word containing "conftest.", or (3) at the end. + # Note that $ac_compile itself does not contain backslashes and begins + # with a dollar sign (not a hyphen), so the echo should work correctly. + # The option is referenced via a variable to avoid confusing sed. + lt_compile=`echo "$ac_compile" | $SED \ + -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \ + -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \ + -e 's:$: $lt_compiler_flag:'` + (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&5) + (eval "$lt_compile" 2>conftest.err) + ac_status=$? + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + if (exit $ac_status) && test -s "$ac_outfile"; then + # The compiler can only warn and ignore the option if not recognized + # So say no if there are warnings other than the usual output. + $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' >conftest.exp + $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2 + if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then + lt_cv_prog_compiler_rtti_exceptions=yes + fi + fi + $RM conftest* + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_rtti_exceptions" >&5 +$as_echo "$lt_cv_prog_compiler_rtti_exceptions" >&6; } + +if test x"$lt_cv_prog_compiler_rtti_exceptions" = xyes; then + lt_prog_compiler_no_builtin_flag="$lt_prog_compiler_no_builtin_flag -fno-rtti -fno-exceptions" +else + : +fi + +fi + + + + + + + lt_prog_compiler_wl= +lt_prog_compiler_pic= +lt_prog_compiler_static= + + + if test "$GCC" = yes; then + lt_prog_compiler_wl='-Wl,' + lt_prog_compiler_static='-static' + + case $host_os in + aix*) + # All AIX code is PIC. + if test "$host_cpu" = ia64; then + # AIX 5 now supports IA64 processor + lt_prog_compiler_static='-Bstatic' + fi + ;; + + amigaos*) + case $host_cpu in + powerpc) + # see comment about AmigaOS4 .so support + lt_prog_compiler_pic='-fPIC' + ;; + m68k) + # FIXME: we need at least 68020 code to build shared libraries, but + # adding the `-m68020' flag to GCC prevents building anything better, + # like `-m68040'. + lt_prog_compiler_pic='-m68020 -resident32 -malways-restore-a4' + ;; + esac + ;; + + beos* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*) + # PIC is the default for these OSes. + ;; + + mingw* | cygwin* | pw32* | os2* | cegcc*) + # This hack is so that the source file can tell whether it is being + # built for inclusion in a dll (and should export symbols for example). + # Although the cygwin gcc ignores -fPIC, still need this for old-style + # (--disable-auto-import) libraries + lt_prog_compiler_pic='-DDLL_EXPORT' + ;; + + darwin* | rhapsody*) + # PIC is the default on this platform + # Common symbols not allowed in MH_DYLIB files + lt_prog_compiler_pic='-fno-common' + ;; + + haiku*) + # PIC is the default for Haiku. + # The "-static" flag exists, but is broken. + lt_prog_compiler_static= + ;; + + hpux*) + # PIC is the default for 64-bit PA HP-UX, but not for 32-bit + # PA HP-UX. On IA64 HP-UX, PIC is the default but the pic flag + # sets the default TLS model and affects inlining. + case $host_cpu in + hppa*64*) + # +Z the default + ;; + *) + lt_prog_compiler_pic='-fPIC' + ;; + esac + ;; + + interix[3-9]*) + # Interix 3.x gcc -fpic/-fPIC options generate broken code. + # Instead, we relocate shared libraries at runtime. + ;; + + msdosdjgpp*) + # Just because we use GCC doesn't mean we suddenly get shared libraries + # on systems that don't support them. + lt_prog_compiler_can_build_shared=no + enable_shared=no + ;; + + *nto* | *qnx*) + # QNX uses GNU C++, but need to define -shared option too, otherwise + # it will coredump. + lt_prog_compiler_pic='-fPIC -shared' + ;; + + sysv4*MP*) + if test -d /usr/nec; then + lt_prog_compiler_pic=-Kconform_pic + fi + ;; + + *) + lt_prog_compiler_pic='-fPIC' + ;; + esac + + case $cc_basename in + nvcc*) # Cuda Compiler Driver 2.2 + lt_prog_compiler_wl='-Xlinker ' + if test -n "$lt_prog_compiler_pic"; then + lt_prog_compiler_pic="-Xcompiler $lt_prog_compiler_pic" + fi + ;; + esac + else + # PORTME Check for flag to pass linker flags through the system compiler. + case $host_os in + aix*) + lt_prog_compiler_wl='-Wl,' + if test "$host_cpu" = ia64; then + # AIX 5 now supports IA64 processor + lt_prog_compiler_static='-Bstatic' + else + lt_prog_compiler_static='-bnso -bI:/lib/syscalls.exp' + fi + ;; + + mingw* | cygwin* | pw32* | os2* | cegcc*) + # This hack is so that the source file can tell whether it is being + # built for inclusion in a dll (and should export symbols for example). + lt_prog_compiler_pic='-DDLL_EXPORT' + ;; + + hpux9* | hpux10* | hpux11*) + lt_prog_compiler_wl='-Wl,' + # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but + # not for PA HP-UX. + case $host_cpu in + hppa*64*|ia64*) + # +Z the default + ;; + *) + lt_prog_compiler_pic='+Z' + ;; + esac + # Is there a better lt_prog_compiler_static that works with the bundled CC? + lt_prog_compiler_static='${wl}-a ${wl}archive' + ;; + + irix5* | irix6* | nonstopux*) + lt_prog_compiler_wl='-Wl,' + # PIC (with -KPIC) is the default. + lt_prog_compiler_static='-non_shared' + ;; + + linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*) + case $cc_basename in + # old Intel for x86_64 which still supported -KPIC. + ecc*) + lt_prog_compiler_wl='-Wl,' + lt_prog_compiler_pic='-KPIC' + lt_prog_compiler_static='-static' + ;; + # icc used to be incompatible with GCC. + # ICC 10 doesn't accept -KPIC any more. + icc* | ifort*) + lt_prog_compiler_wl='-Wl,' + lt_prog_compiler_pic='-fPIC' + lt_prog_compiler_static='-static' + ;; + # Lahey Fortran 8.1. + lf95*) + lt_prog_compiler_wl='-Wl,' + lt_prog_compiler_pic='--shared' + lt_prog_compiler_static='--static' + ;; + nagfor*) + # NAG Fortran compiler + lt_prog_compiler_wl='-Wl,-Wl,,' + lt_prog_compiler_pic='-PIC' + lt_prog_compiler_static='-Bstatic' + ;; + pgcc* | pgf77* | pgf90* | pgf95* | pgfortran*) + # Portland Group compilers (*not* the Pentium gcc compiler, + # which looks to be a dead project) + lt_prog_compiler_wl='-Wl,' + lt_prog_compiler_pic='-fpic' + lt_prog_compiler_static='-Bstatic' + ;; + ccc*) + lt_prog_compiler_wl='-Wl,' + # All Alpha code is PIC. + lt_prog_compiler_static='-non_shared' + ;; + xl* | bgxl* | bgf* | mpixl*) + # IBM XL C 8.0/Fortran 10.1, 11.1 on PPC and BlueGene + lt_prog_compiler_wl='-Wl,' + lt_prog_compiler_pic='-qpic' + lt_prog_compiler_static='-qstaticlink' + ;; + *) + case `$CC -V 2>&1 | sed 5q` in + *Sun\ Ceres\ Fortran* | *Sun*Fortran*\ [1-7].* | *Sun*Fortran*\ 8.[0-3]*) + # Sun Fortran 8.3 passes all unrecognized flags to the linker + lt_prog_compiler_pic='-KPIC' + lt_prog_compiler_static='-Bstatic' + lt_prog_compiler_wl='' + ;; + *Sun\ F* | *Sun*Fortran*) + lt_prog_compiler_pic='-KPIC' + lt_prog_compiler_static='-Bstatic' + lt_prog_compiler_wl='-Qoption ld ' + ;; + *Sun\ C*) + # Sun C 5.9 + lt_prog_compiler_pic='-KPIC' + lt_prog_compiler_static='-Bstatic' + lt_prog_compiler_wl='-Wl,' + ;; + *Intel*\ [CF]*Compiler*) + lt_prog_compiler_wl='-Wl,' + lt_prog_compiler_pic='-fPIC' + lt_prog_compiler_static='-static' + ;; + *Portland\ Group*) + lt_prog_compiler_wl='-Wl,' + lt_prog_compiler_pic='-fpic' + lt_prog_compiler_static='-Bstatic' + ;; + esac + ;; + esac + ;; + + newsos6) + lt_prog_compiler_pic='-KPIC' + lt_prog_compiler_static='-Bstatic' + ;; + + *nto* | *qnx*) + # QNX uses GNU C++, but need to define -shared option too, otherwise + # it will coredump. + lt_prog_compiler_pic='-fPIC -shared' + ;; + + osf3* | osf4* | osf5*) + lt_prog_compiler_wl='-Wl,' + # All OSF/1 code is PIC. + lt_prog_compiler_static='-non_shared' + ;; + + rdos*) + lt_prog_compiler_static='-non_shared' + ;; + + solaris*) + lt_prog_compiler_pic='-KPIC' + lt_prog_compiler_static='-Bstatic' + case $cc_basename in + f77* | f90* | f95* | sunf77* | sunf90* | sunf95*) + lt_prog_compiler_wl='-Qoption ld ';; + *) + lt_prog_compiler_wl='-Wl,';; + esac + ;; + + sunos4*) + lt_prog_compiler_wl='-Qoption ld ' + lt_prog_compiler_pic='-PIC' + lt_prog_compiler_static='-Bstatic' + ;; + + sysv4 | sysv4.2uw2* | sysv4.3*) + lt_prog_compiler_wl='-Wl,' + lt_prog_compiler_pic='-KPIC' + lt_prog_compiler_static='-Bstatic' + ;; + + sysv4*MP*) + if test -d /usr/nec ;then + lt_prog_compiler_pic='-Kconform_pic' + lt_prog_compiler_static='-Bstatic' + fi + ;; + + sysv5* | unixware* | sco3.2v5* | sco5v6* | OpenUNIX*) + lt_prog_compiler_wl='-Wl,' + lt_prog_compiler_pic='-KPIC' + lt_prog_compiler_static='-Bstatic' + ;; + + unicos*) + lt_prog_compiler_wl='-Wl,' + lt_prog_compiler_can_build_shared=no + ;; + + uts4*) + lt_prog_compiler_pic='-pic' + lt_prog_compiler_static='-Bstatic' + ;; + + *) + lt_prog_compiler_can_build_shared=no + ;; + esac + fi + +case $host_os in + # For platforms which do not support PIC, -DPIC is meaningless: + *djgpp*) + lt_prog_compiler_pic= + ;; + *) + lt_prog_compiler_pic="$lt_prog_compiler_pic -DPIC" + ;; +esac + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $compiler option to produce PIC" >&5 +$as_echo_n "checking for $compiler option to produce PIC... " >&6; } +if ${lt_cv_prog_compiler_pic+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_prog_compiler_pic=$lt_prog_compiler_pic +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic" >&5 +$as_echo "$lt_cv_prog_compiler_pic" >&6; } +lt_prog_compiler_pic=$lt_cv_prog_compiler_pic + +# +# Check to make sure the PIC flag actually works. +# +if test -n "$lt_prog_compiler_pic"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler PIC flag $lt_prog_compiler_pic works" >&5 +$as_echo_n "checking if $compiler PIC flag $lt_prog_compiler_pic works... " >&6; } +if ${lt_cv_prog_compiler_pic_works+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_prog_compiler_pic_works=no + ac_outfile=conftest.$ac_objext + echo "$lt_simple_compile_test_code" > conftest.$ac_ext + lt_compiler_flag="$lt_prog_compiler_pic -DPIC" + # Insert the option either (1) after the last *FLAGS variable, or + # (2) before a word containing "conftest.", or (3) at the end. + # Note that $ac_compile itself does not contain backslashes and begins + # with a dollar sign (not a hyphen), so the echo should work correctly. + # The option is referenced via a variable to avoid confusing sed. + lt_compile=`echo "$ac_compile" | $SED \ + -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \ + -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \ + -e 's:$: $lt_compiler_flag:'` + (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&5) + (eval "$lt_compile" 2>conftest.err) + ac_status=$? + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + if (exit $ac_status) && test -s "$ac_outfile"; then + # The compiler can only warn and ignore the option if not recognized + # So say no if there are warnings other than the usual output. + $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' >conftest.exp + $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2 + if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then + lt_cv_prog_compiler_pic_works=yes + fi + fi + $RM conftest* + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic_works" >&5 +$as_echo "$lt_cv_prog_compiler_pic_works" >&6; } + +if test x"$lt_cv_prog_compiler_pic_works" = xyes; then + case $lt_prog_compiler_pic in + "" | " "*) ;; + *) lt_prog_compiler_pic=" $lt_prog_compiler_pic" ;; + esac +else + lt_prog_compiler_pic= + lt_prog_compiler_can_build_shared=no +fi + +fi + + + + + + + + + + + +# +# Check to make sure the static flag actually works. +# +wl=$lt_prog_compiler_wl eval lt_tmp_static_flag=\"$lt_prog_compiler_static\" +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler static flag $lt_tmp_static_flag works" >&5 +$as_echo_n "checking if $compiler static flag $lt_tmp_static_flag works... " >&6; } +if ${lt_cv_prog_compiler_static_works+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_prog_compiler_static_works=no + save_LDFLAGS="$LDFLAGS" + LDFLAGS="$LDFLAGS $lt_tmp_static_flag" + echo "$lt_simple_link_test_code" > conftest.$ac_ext + if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then + # The linker can only warn and ignore the option if not recognized + # So say no if there are warnings + if test -s conftest.err; then + # Append any errors to the config.log. + cat conftest.err 1>&5 + $ECHO "$_lt_linker_boilerplate" | $SED '/^$/d' > conftest.exp + $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2 + if diff conftest.exp conftest.er2 >/dev/null; then + lt_cv_prog_compiler_static_works=yes + fi + else + lt_cv_prog_compiler_static_works=yes + fi + fi + $RM -r conftest* + LDFLAGS="$save_LDFLAGS" + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_static_works" >&5 +$as_echo "$lt_cv_prog_compiler_static_works" >&6; } + +if test x"$lt_cv_prog_compiler_static_works" = xyes; then + : +else + lt_prog_compiler_static= +fi + + + + + + + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -c -o file.$ac_objext" >&5 +$as_echo_n "checking if $compiler supports -c -o file.$ac_objext... " >&6; } +if ${lt_cv_prog_compiler_c_o+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_prog_compiler_c_o=no + $RM -r conftest 2>/dev/null + mkdir conftest + cd conftest + mkdir out + echo "$lt_simple_compile_test_code" > conftest.$ac_ext + + lt_compiler_flag="-o out/conftest2.$ac_objext" + # Insert the option either (1) after the last *FLAGS variable, or + # (2) before a word containing "conftest.", or (3) at the end. + # Note that $ac_compile itself does not contain backslashes and begins + # with a dollar sign (not a hyphen), so the echo should work correctly. + lt_compile=`echo "$ac_compile" | $SED \ + -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \ + -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \ + -e 's:$: $lt_compiler_flag:'` + (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&5) + (eval "$lt_compile" 2>out/conftest.err) + ac_status=$? + cat out/conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + if (exit $ac_status) && test -s out/conftest2.$ac_objext + then + # The compiler can only warn and ignore the option if not recognized + # So say no if there are warnings + $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' > out/conftest.exp + $SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2 + if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then + lt_cv_prog_compiler_c_o=yes + fi + fi + chmod u+w . 2>&5 + $RM conftest* + # SGI C++ compiler will create directory out/ii_files/ for + # template instantiation + test -d out/ii_files && $RM out/ii_files/* && rmdir out/ii_files + $RM out/* && rmdir out + cd .. + $RM -r conftest + $RM conftest* + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o" >&5 +$as_echo "$lt_cv_prog_compiler_c_o" >&6; } + + + + + + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -c -o file.$ac_objext" >&5 +$as_echo_n "checking if $compiler supports -c -o file.$ac_objext... " >&6; } +if ${lt_cv_prog_compiler_c_o+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_prog_compiler_c_o=no + $RM -r conftest 2>/dev/null + mkdir conftest + cd conftest + mkdir out + echo "$lt_simple_compile_test_code" > conftest.$ac_ext + + lt_compiler_flag="-o out/conftest2.$ac_objext" + # Insert the option either (1) after the last *FLAGS variable, or + # (2) before a word containing "conftest.", or (3) at the end. + # Note that $ac_compile itself does not contain backslashes and begins + # with a dollar sign (not a hyphen), so the echo should work correctly. + lt_compile=`echo "$ac_compile" | $SED \ + -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \ + -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \ + -e 's:$: $lt_compiler_flag:'` + (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&5) + (eval "$lt_compile" 2>out/conftest.err) + ac_status=$? + cat out/conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + if (exit $ac_status) && test -s out/conftest2.$ac_objext + then + # The compiler can only warn and ignore the option if not recognized + # So say no if there are warnings + $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' > out/conftest.exp + $SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2 + if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then + lt_cv_prog_compiler_c_o=yes + fi + fi + chmod u+w . 2>&5 + $RM conftest* + # SGI C++ compiler will create directory out/ii_files/ for + # template instantiation + test -d out/ii_files && $RM out/ii_files/* && rmdir out/ii_files + $RM out/* && rmdir out + cd .. + $RM -r conftest + $RM conftest* + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o" >&5 +$as_echo "$lt_cv_prog_compiler_c_o" >&6; } + + + + +hard_links="nottested" +if test "$lt_cv_prog_compiler_c_o" = no && test "$need_locks" != no; then + # do not overwrite the value of need_locks provided by the user + { $as_echo "$as_me:${as_lineno-$LINENO}: checking if we can lock with hard links" >&5 +$as_echo_n "checking if we can lock with hard links... " >&6; } + hard_links=yes + $RM conftest* + ln conftest.a conftest.b 2>/dev/null && hard_links=no + touch conftest.a + ln conftest.a conftest.b 2>&5 || hard_links=no + ln conftest.a conftest.b 2>/dev/null && hard_links=no + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $hard_links" >&5 +$as_echo "$hard_links" >&6; } + if test "$hard_links" = no; then + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&5 +$as_echo "$as_me: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&2;} + need_locks=warn + fi +else + need_locks=no +fi + + + + + + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the $compiler linker ($LD) supports shared libraries" >&5 +$as_echo_n "checking whether the $compiler linker ($LD) supports shared libraries... " >&6; } + + runpath_var= + allow_undefined_flag= + always_export_symbols=no + archive_cmds= + archive_expsym_cmds= + compiler_needs_object=no + enable_shared_with_static_runtimes=no + export_dynamic_flag_spec= + export_symbols_cmds='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols' + hardcode_automatic=no + hardcode_direct=no + hardcode_direct_absolute=no + hardcode_libdir_flag_spec= + hardcode_libdir_separator= + hardcode_minus_L=no + hardcode_shlibpath_var=unsupported + inherit_rpath=no + link_all_deplibs=unknown + module_cmds= + module_expsym_cmds= + old_archive_from_new_cmds= + old_archive_from_expsyms_cmds= + thread_safe_flag_spec= + whole_archive_flag_spec= + # include_expsyms should be a list of space-separated symbols to be *always* + # included in the symbol list + include_expsyms= + # exclude_expsyms can be an extended regexp of symbols to exclude + # it will be wrapped by ` (' and `)$', so one must not match beginning or + # end of line. Example: `a|bc|.*d.*' will exclude the symbols `a' and `bc', + # as well as any symbol that contains `d'. + exclude_expsyms='_GLOBAL_OFFSET_TABLE_|_GLOBAL__F[ID]_.*' + # Although _GLOBAL_OFFSET_TABLE_ is a valid symbol C name, most a.out + # platforms (ab)use it in PIC code, but their linkers get confused if + # the symbol is explicitly referenced. Since portable code cannot + # rely on this symbol name, it's probably fine to never include it in + # preloaded symbol tables. + # Exclude shared library initialization/finalization symbols. + extract_expsyms_cmds= + + case $host_os in + cygwin* | mingw* | pw32* | cegcc*) + # FIXME: the MSVC++ port hasn't been tested in a loooong time + # When not using gcc, we currently assume that we are using + # Microsoft Visual C++. + if test "$GCC" != yes; then + with_gnu_ld=no + fi + ;; + interix*) + # we just hope/assume this is gcc and not c89 (= MSVC++) + with_gnu_ld=yes + ;; + openbsd*) + with_gnu_ld=no + ;; + linux* | k*bsd*-gnu | gnu*) + link_all_deplibs=no + ;; + esac + + ld_shlibs=yes + + # On some targets, GNU ld is compatible enough with the native linker + # that we're better off using the native interface for both. + lt_use_gnu_ld_interface=no + if test "$with_gnu_ld" = yes; then + case $host_os in + aix*) + # The AIX port of GNU ld has always aspired to compatibility + # with the native linker. However, as the warning in the GNU ld + # block says, versions before 2.19.5* couldn't really create working + # shared libraries, regardless of the interface used. + case `$LD -v 2>&1` in + *\ \(GNU\ Binutils\)\ 2.19.5*) ;; + *\ \(GNU\ Binutils\)\ 2.[2-9]*) ;; + *\ \(GNU\ Binutils\)\ [3-9]*) ;; + *) + lt_use_gnu_ld_interface=yes + ;; + esac + ;; + *) + lt_use_gnu_ld_interface=yes + ;; + esac + fi + + if test "$lt_use_gnu_ld_interface" = yes; then + # If archive_cmds runs LD, not CC, wlarc should be empty + wlarc='${wl}' + + # Set some defaults for GNU ld with shared library support. These + # are reset later if shared libraries are not supported. Putting them + # here allows them to be overridden if necessary. + runpath_var=LD_RUN_PATH + hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir' + export_dynamic_flag_spec='${wl}--export-dynamic' + # ancient GNU ld didn't support --whole-archive et. al. + if $LD --help 2>&1 | $GREP 'no-whole-archive' > /dev/null; then + whole_archive_flag_spec="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive' + else + whole_archive_flag_spec= + fi + supports_anon_versioning=no + case `$LD -v 2>&1` in + *GNU\ gold*) supports_anon_versioning=yes ;; + *\ [01].* | *\ 2.[0-9].* | *\ 2.10.*) ;; # catch versions < 2.11 + *\ 2.11.93.0.2\ *) supports_anon_versioning=yes ;; # RH7.3 ... + *\ 2.11.92.0.12\ *) supports_anon_versioning=yes ;; # Mandrake 8.2 ... + *\ 2.11.*) ;; # other 2.11 versions + *) supports_anon_versioning=yes ;; + esac + + # See if GNU ld supports shared libraries. + case $host_os in + aix[3-9]*) + # On AIX/PPC, the GNU linker is very broken + if test "$host_cpu" != ia64; then + ld_shlibs=no + cat <<_LT_EOF 1>&2 + +*** Warning: the GNU linker, at least up to release 2.19, is reported +*** to be unable to reliably create shared libraries on AIX. +*** Therefore, libtool is disabling shared libraries support. If you +*** really care for shared libraries, you may want to install binutils +*** 2.20 or above, or modify your PATH so that a non-GNU linker is found. +*** You will then need to restart the configuration process. + +_LT_EOF + fi + ;; + + amigaos*) + case $host_cpu in + powerpc) + # see comment about AmigaOS4 .so support + archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + archive_expsym_cmds='' + ;; + m68k) + archive_cmds='$RM $output_objdir/a2ixlibrary.data~$ECHO "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$ECHO "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$ECHO "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$ECHO "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)' + hardcode_libdir_flag_spec='-L$libdir' + hardcode_minus_L=yes + ;; + esac + ;; + + beos*) + if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then + allow_undefined_flag=unsupported + # Joseph Beckenbach says some releases of gcc + # support --undefined. This deserves some investigation. FIXME + archive_cmds='$CC -nostart $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + else + ld_shlibs=no + fi + ;; + + cygwin* | mingw* | pw32* | cegcc*) + # _LT_TAGVAR(hardcode_libdir_flag_spec, ) is actually meaningless, + # as there is no search path for DLLs. + hardcode_libdir_flag_spec='-L$libdir' + export_dynamic_flag_spec='${wl}--export-all-symbols' + allow_undefined_flag=unsupported + always_export_symbols=no + enable_shared_with_static_runtimes=yes + export_symbols_cmds='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[BCDGRS][ ]/s/.*[ ]\([^ ]*\)/\1 DATA/;s/^.*[ ]__nm__\([^ ]*\)[ ][^ ]*/\1 DATA/;/^I[ ]/d;/^[AITW][ ]/s/.* //'\'' | sort | uniq > $export_symbols' + exclude_expsyms='[_]+GLOBAL_OFFSET_TABLE_|[_]+GLOBAL__[FID]_.*|[_]+head_[A-Za-z0-9_]+_dll|[A-Za-z0-9_]+_dll_iname' + + if $LD --help 2>&1 | $GREP 'auto-import' > /dev/null; then + archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib' + # If the export-symbols file already is a .def file (1st line + # is EXPORTS), use it as is; otherwise, prepend... + archive_expsym_cmds='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then + cp $export_symbols $output_objdir/$soname.def; + else + echo EXPORTS > $output_objdir/$soname.def; + cat $export_symbols >> $output_objdir/$soname.def; + fi~ + $CC -shared $output_objdir/$soname.def $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib' + else + ld_shlibs=no + fi + ;; + + haiku*) + archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + link_all_deplibs=yes + ;; + + interix[3-9]*) + hardcode_direct=no + hardcode_shlibpath_var=no + hardcode_libdir_flag_spec='${wl}-rpath,$libdir' + export_dynamic_flag_spec='${wl}-E' + # Hack: On Interix 3.x, we cannot compile PIC because of a broken gcc. + # Instead, shared libraries are loaded at an image base (0x10000000 by + # default) and relocated if they conflict, which is a slow very memory + # consuming and fragmenting process. To avoid this, we pick a random, + # 256 KiB-aligned image base between 0x50000000 and 0x6FFC0000 at link + # time. Moving up from 0x10000000 also allows more sbrk(2) space. + archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib' + archive_expsym_cmds='sed "s,^,_," $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--retain-symbols-file,$output_objdir/$soname.expsym ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib' + ;; + + gnu* | linux* | tpf* | k*bsd*-gnu | kopensolaris*-gnu) + tmp_diet=no + if test "$host_os" = linux-dietlibc; then + case $cc_basename in + diet\ *) tmp_diet=yes;; # linux-dietlibc with static linking (!diet-dyn) + esac + fi + if $LD --help 2>&1 | $EGREP ': supported targets:.* elf' > /dev/null \ + && test "$tmp_diet" = no + then + tmp_addflag=' $pic_flag' + tmp_sharedflag='-shared' + case $cc_basename,$host_cpu in + pgcc*) # Portland Group C compiler + whole_archive_flag_spec='${wl}--whole-archive`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive' + tmp_addflag=' $pic_flag' + ;; + pgf77* | pgf90* | pgf95* | pgfortran*) + # Portland Group f77 and f90 compilers + whole_archive_flag_spec='${wl}--whole-archive`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive' + tmp_addflag=' $pic_flag -Mnomain' ;; + ecc*,ia64* | icc*,ia64*) # Intel C compiler on ia64 + tmp_addflag=' -i_dynamic' ;; + efc*,ia64* | ifort*,ia64*) # Intel Fortran compiler on ia64 + tmp_addflag=' -i_dynamic -nofor_main' ;; + ifc* | ifort*) # Intel Fortran compiler + tmp_addflag=' -nofor_main' ;; + lf95*) # Lahey Fortran 8.1 + whole_archive_flag_spec= + tmp_sharedflag='--shared' ;; + xl[cC]* | bgxl[cC]* | mpixl[cC]*) # IBM XL C 8.0 on PPC (deal with xlf below) + tmp_sharedflag='-qmkshrobj' + tmp_addflag= ;; + nvcc*) # Cuda Compiler Driver 2.2 + whole_archive_flag_spec='${wl}--whole-archive`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive' + compiler_needs_object=yes + ;; + esac + case `$CC -V 2>&1 | sed 5q` in + *Sun\ C*) # Sun C 5.9 + whole_archive_flag_spec='${wl}--whole-archive`new_convenience=; for conv in $convenience\"\"; do test -z \"$conv\" || new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive' + compiler_needs_object=yes + tmp_sharedflag='-G' ;; + *Sun\ F*) # Sun Fortran 8.3 + tmp_sharedflag='-G' ;; + esac + archive_cmds='$CC '"$tmp_sharedflag""$tmp_addflag"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + + if test "x$supports_anon_versioning" = xyes; then + archive_expsym_cmds='echo "{ global:" > $output_objdir/$libname.ver~ + cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~ + echo "local: *; };" >> $output_objdir/$libname.ver~ + $CC '"$tmp_sharedflag""$tmp_addflag"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-version-script ${wl}$output_objdir/$libname.ver -o $lib' + fi + + case $cc_basename in + xlf* | bgf* | bgxlf* | mpixlf*) + # IBM XL Fortran 10.1 on PPC cannot create shared libs itself + whole_archive_flag_spec='--whole-archive$convenience --no-whole-archive' + hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir' + archive_cmds='$LD -shared $libobjs $deplibs $linker_flags -soname $soname -o $lib' + if test "x$supports_anon_versioning" = xyes; then + archive_expsym_cmds='echo "{ global:" > $output_objdir/$libname.ver~ + cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~ + echo "local: *; };" >> $output_objdir/$libname.ver~ + $LD -shared $libobjs $deplibs $linker_flags -soname $soname -version-script $output_objdir/$libname.ver -o $lib' + fi + ;; + esac + else + ld_shlibs=no + fi + ;; + + netbsd* | netbsdelf*-gnu) + if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then + archive_cmds='$LD -Bshareable $libobjs $deplibs $linker_flags -o $lib' + wlarc= + else + archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + archive_expsym_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + fi + ;; + + solaris*) + if $LD -v 2>&1 | $GREP 'BFD 2\.8' > /dev/null; then + ld_shlibs=no + cat <<_LT_EOF 1>&2 + +*** Warning: The releases 2.8.* of the GNU linker cannot reliably +*** create shared libraries on Solaris systems. Therefore, libtool +*** is disabling shared libraries support. We urge you to upgrade GNU +*** binutils to release 2.9.1 or newer. Another option is to modify +*** your PATH or compiler configuration so that the native linker is +*** used, and then restart. + +_LT_EOF + elif $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then + archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + archive_expsym_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + else + ld_shlibs=no + fi + ;; + + sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX*) + case `$LD -v 2>&1` in + *\ [01].* | *\ 2.[0-9].* | *\ 2.1[0-5].*) + ld_shlibs=no + cat <<_LT_EOF 1>&2 + +*** Warning: Releases of the GNU linker prior to 2.16.91.0.3 can not +*** reliably create shared libraries on SCO systems. Therefore, libtool +*** is disabling shared libraries support. We urge you to upgrade GNU +*** binutils to release 2.16.91.0.3 or newer. Another option is to modify +*** your PATH or compiler configuration so that the native linker is +*** used, and then restart. + +_LT_EOF + ;; + *) + # For security reasons, it is highly recommended that you always + # use absolute paths for naming shared libraries, and exclude the + # DT_RUNPATH tag from executables and libraries. But doing so + # requires that you compile everything twice, which is a pain. + if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then + hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir' + archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + archive_expsym_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + else + ld_shlibs=no + fi + ;; + esac + ;; + + sunos4*) + archive_cmds='$LD -assert pure-text -Bshareable -o $lib $libobjs $deplibs $linker_flags' + wlarc= + hardcode_direct=yes + hardcode_shlibpath_var=no + ;; + + *) + if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then + archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + archive_expsym_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + else + ld_shlibs=no + fi + ;; + esac + + if test "$ld_shlibs" = no; then + runpath_var= + hardcode_libdir_flag_spec= + export_dynamic_flag_spec= + whole_archive_flag_spec= + fi + else + # PORTME fill in a description of your system's linker (not GNU ld) + case $host_os in + aix3*) + allow_undefined_flag=unsupported + always_export_symbols=yes + archive_expsym_cmds='$LD -o $output_objdir/$soname $libobjs $deplibs $linker_flags -bE:$export_symbols -T512 -H512 -bM:SRE~$AR $AR_FLAGS $lib $output_objdir/$soname' + # Note: this linker hardcodes the directories in LIBPATH if there + # are no directories specified by -L. + hardcode_minus_L=yes + if test "$GCC" = yes && test -z "$lt_prog_compiler_static"; then + # Neither direct hardcoding nor static linking is supported with a + # broken collect2. + hardcode_direct=unsupported + fi + ;; + + aix[4-9]*) + if test "$host_cpu" = ia64; then + # On IA64, the linker does run time linking by default, so we don't + # have to do anything special. + aix_use_runtimelinking=no + exp_sym_flag='-Bexport' + no_entry_flag="" + else + # If we're using GNU nm, then we don't want the "-C" option. + # -C means demangle to AIX nm, but means don't demangle with GNU nm + # Also, AIX nm treats weak defined symbols like other global + # defined symbols, whereas GNU nm marks them as "W". + if $NM -V 2>&1 | $GREP 'GNU' > /dev/null; then + export_symbols_cmds='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W")) && (substr(\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols' + else + export_symbols_cmds='$NM -BCpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B")) && (substr(\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols' + fi + aix_use_runtimelinking=no + + # Test if we are trying to use run time linking or normal + # AIX style linking. If -brtl is somewhere in LDFLAGS, we + # need to do runtime linking. + case $host_os in aix4.[23]|aix4.[23].*|aix[5-9]*) + for ld_flag in $LDFLAGS; do + if (test $ld_flag = "-brtl" || test $ld_flag = "-Wl,-brtl"); then + aix_use_runtimelinking=yes + break + fi + done + ;; + esac + + exp_sym_flag='-bexport' + no_entry_flag='-bnoentry' + fi + + # When large executables or shared objects are built, AIX ld can + # have problems creating the table of contents. If linking a library + # or program results in "error TOC overflow" add -mminimal-toc to + # CXXFLAGS/CFLAGS for g++/gcc. In the cases where that is not + # enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS. + + archive_cmds='' + hardcode_direct=yes + hardcode_direct_absolute=yes + hardcode_libdir_separator=':' + link_all_deplibs=yes + file_list_spec='${wl}-f,' + + if test "$GCC" = yes; then + case $host_os in aix4.[012]|aix4.[012].*) + # We only want to do this on AIX 4.2 and lower, the check + # below for broken collect2 doesn't work under 4.3+ + collect2name=`${CC} -print-prog-name=collect2` + if test -f "$collect2name" && + strings "$collect2name" | $GREP resolve_lib_name >/dev/null + then + # We have reworked collect2 + : + else + # We have old collect2 + hardcode_direct=unsupported + # It fails to find uninstalled libraries when the uninstalled + # path is not listed in the libpath. Setting hardcode_minus_L + # to unsupported forces relinking + hardcode_minus_L=yes + hardcode_libdir_flag_spec='-L$libdir' + hardcode_libdir_separator= + fi + ;; + esac + shared_flag='-shared' + if test "$aix_use_runtimelinking" = yes; then + shared_flag="$shared_flag "'${wl}-G' + fi + link_all_deplibs=no + else + # not using gcc + if test "$host_cpu" = ia64; then + # VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release + # chokes on -Wl,-G. The following line is correct: + shared_flag='-G' + else + if test "$aix_use_runtimelinking" = yes; then + shared_flag='${wl}-G' + else + shared_flag='${wl}-bM:SRE' + fi + fi + fi + + export_dynamic_flag_spec='${wl}-bexpall' + # It seems that -bexpall does not export symbols beginning with + # underscore (_), so it is better to generate a list of symbols to export. + always_export_symbols=yes + if test "$aix_use_runtimelinking" = yes; then + # Warning - without using the other runtime loading flags (-brtl), + # -berok will link without error, but may produce a broken library. + allow_undefined_flag='-berok' + # Determine the default libpath from the value encoded in an + # empty executable. + if test "${lt_cv_aix_libpath+set}" = set; then + aix_libpath=$lt_cv_aix_libpath +else + if ${lt_cv_aix_libpath_+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + + lt_aix_libpath_sed=' + /Import File Strings/,/^$/ { + /^0/ { + s/^0 *\([^ ]*\) *$/\1/ + p + } + }' + lt_cv_aix_libpath_=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"` + # Check for a 64-bit object if we didn't find anything. + if test -z "$lt_cv_aix_libpath_"; then + lt_cv_aix_libpath_=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"` + fi +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext + if test -z "$lt_cv_aix_libpath_"; then + lt_cv_aix_libpath_="/usr/lib:/lib" + fi + +fi + + aix_libpath=$lt_cv_aix_libpath_ +fi + + hardcode_libdir_flag_spec='${wl}-blibpath:$libdir:'"$aix_libpath" + archive_expsym_cmds='$CC -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then func_echo_all "${wl}${allow_undefined_flag}"; else :; fi` '"\${wl}$exp_sym_flag:\$export_symbols $shared_flag" + else + if test "$host_cpu" = ia64; then + hardcode_libdir_flag_spec='${wl}-R $libdir:/usr/lib:/lib' + allow_undefined_flag="-z nodefs" + archive_expsym_cmds="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$exp_sym_flag:\$export_symbols" + else + # Determine the default libpath from the value encoded in an + # empty executable. + if test "${lt_cv_aix_libpath+set}" = set; then + aix_libpath=$lt_cv_aix_libpath +else + if ${lt_cv_aix_libpath_+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + + lt_aix_libpath_sed=' + /Import File Strings/,/^$/ { + /^0/ { + s/^0 *\([^ ]*\) *$/\1/ + p + } + }' + lt_cv_aix_libpath_=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"` + # Check for a 64-bit object if we didn't find anything. + if test -z "$lt_cv_aix_libpath_"; then + lt_cv_aix_libpath_=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"` + fi +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext + if test -z "$lt_cv_aix_libpath_"; then + lt_cv_aix_libpath_="/usr/lib:/lib" + fi + +fi + + aix_libpath=$lt_cv_aix_libpath_ +fi + + hardcode_libdir_flag_spec='${wl}-blibpath:$libdir:'"$aix_libpath" + # Warning - without using the other run time loading flags, + # -berok will link without error, but may produce a broken library. + no_undefined_flag=' ${wl}-bernotok' + allow_undefined_flag=' ${wl}-berok' + if test "$with_gnu_ld" = yes; then + # We only use this code for GNU lds that support --whole-archive. + whole_archive_flag_spec='${wl}--whole-archive$convenience ${wl}--no-whole-archive' + else + # Exported symbols can be pulled into shared objects from archives + whole_archive_flag_spec='$convenience' + fi + archive_cmds_need_lc=yes + # This is similar to how AIX traditionally builds its shared libraries. + archive_expsym_cmds="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs ${wl}-bnoentry $compiler_flags ${wl}-bE:$export_symbols${allow_undefined_flag}~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$soname' + fi + fi + ;; + + amigaos*) + case $host_cpu in + powerpc) + # see comment about AmigaOS4 .so support + archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + archive_expsym_cmds='' + ;; + m68k) + archive_cmds='$RM $output_objdir/a2ixlibrary.data~$ECHO "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$ECHO "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$ECHO "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$ECHO "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)' + hardcode_libdir_flag_spec='-L$libdir' + hardcode_minus_L=yes + ;; + esac + ;; + + bsdi[45]*) + export_dynamic_flag_spec=-rdynamic + ;; + + cygwin* | mingw* | pw32* | cegcc*) + # When not using gcc, we currently assume that we are using + # Microsoft Visual C++. + # hardcode_libdir_flag_spec is actually meaningless, as there is + # no search path for DLLs. + case $cc_basename in + cl*) + # Native MSVC + hardcode_libdir_flag_spec=' ' + allow_undefined_flag=unsupported + always_export_symbols=yes + file_list_spec='@' + # Tell ltmain to make .lib files, not .a files. + libext=lib + # Tell ltmain to make .dll files, not .so files. + shrext_cmds=".dll" + # FIXME: Setting linknames here is a bad hack. + archive_cmds='$CC -o $output_objdir/$soname $libobjs $compiler_flags $deplibs -Wl,-dll~linknames=' + archive_expsym_cmds='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then + sed -n -e 's/\\\\\\\(.*\\\\\\\)/-link\\\ -EXPORT:\\\\\\\1/' -e '1\\\!p' < $export_symbols > $output_objdir/$soname.exp; + else + sed -e 's/\\\\\\\(.*\\\\\\\)/-link\\\ -EXPORT:\\\\\\\1/' < $export_symbols > $output_objdir/$soname.exp; + fi~ + $CC -o $tool_output_objdir$soname $libobjs $compiler_flags $deplibs "@$tool_output_objdir$soname.exp" -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~ + linknames=' + # The linker will not automatically build a static lib if we build a DLL. + # _LT_TAGVAR(old_archive_from_new_cmds, )='true' + enable_shared_with_static_runtimes=yes + exclude_expsyms='_NULL_IMPORT_DESCRIPTOR|_IMPORT_DESCRIPTOR_.*' + export_symbols_cmds='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[BCDGRS][ ]/s/.*[ ]\([^ ]*\)/\1,DATA/'\'' | $SED -e '\''/^[AITW][ ]/s/.*[ ]//'\'' | sort | uniq > $export_symbols' + # Don't use ranlib + old_postinstall_cmds='chmod 644 $oldlib' + postlink_cmds='lt_outputfile="@OUTPUT@"~ + lt_tool_outputfile="@TOOL_OUTPUT@"~ + case $lt_outputfile in + *.exe|*.EXE) ;; + *) + lt_outputfile="$lt_outputfile.exe" + lt_tool_outputfile="$lt_tool_outputfile.exe" + ;; + esac~ + if test "$MANIFEST_TOOL" != ":" && test -f "$lt_outputfile.manifest"; then + $MANIFEST_TOOL -manifest "$lt_tool_outputfile.manifest" -outputresource:"$lt_tool_outputfile" || exit 1; + $RM "$lt_outputfile.manifest"; + fi' + ;; + *) + # Assume MSVC wrapper + hardcode_libdir_flag_spec=' ' + allow_undefined_flag=unsupported + # Tell ltmain to make .lib files, not .a files. + libext=lib + # Tell ltmain to make .dll files, not .so files. + shrext_cmds=".dll" + # FIXME: Setting linknames here is a bad hack. + archive_cmds='$CC -o $lib $libobjs $compiler_flags `func_echo_all "$deplibs" | $SED '\''s/ -lc$//'\''` -link -dll~linknames=' + # The linker will automatically build a .lib file if we build a DLL. + old_archive_from_new_cmds='true' + # FIXME: Should let the user specify the lib program. + old_archive_cmds='lib -OUT:$oldlib$oldobjs$old_deplibs' + enable_shared_with_static_runtimes=yes + ;; + esac + ;; + + darwin* | rhapsody*) + + + archive_cmds_need_lc=no + hardcode_direct=no + hardcode_automatic=yes + hardcode_shlibpath_var=unsupported + if test "$lt_cv_ld_force_load" = "yes"; then + whole_archive_flag_spec='`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience ${wl}-force_load,$conv\"; done; func_echo_all \"$new_convenience\"`' + + else + whole_archive_flag_spec='' + fi + link_all_deplibs=yes + allow_undefined_flag="$_lt_dar_allow_undefined" + case $cc_basename in + ifort*) _lt_dar_can_shared=yes ;; + *) _lt_dar_can_shared=$GCC ;; + esac + if test "$_lt_dar_can_shared" = "yes"; then + output_verbose_link_cmd=func_echo_all + archive_cmds="\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring $_lt_dar_single_mod${_lt_dsymutil}" + module_cmds="\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags${_lt_dsymutil}" + archive_expsym_cmds="sed 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring ${_lt_dar_single_mod}${_lt_dar_export_syms}${_lt_dsymutil}" + module_expsym_cmds="sed -e 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags${_lt_dar_export_syms}${_lt_dsymutil}" + + else + ld_shlibs=no + fi + + ;; + + dgux*) + archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + hardcode_libdir_flag_spec='-L$libdir' + hardcode_shlibpath_var=no + ;; + + # FreeBSD 2.2.[012] allows us to include c++rt0.o to get C++ constructor + # support. Future versions do this automatically, but an explicit c++rt0.o + # does not break anything, and helps significantly (at the cost of a little + # extra space). + freebsd2.2*) + archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags /usr/lib/c++rt0.o' + hardcode_libdir_flag_spec='-R$libdir' + hardcode_direct=yes + hardcode_shlibpath_var=no + ;; + + # Unfortunately, older versions of FreeBSD 2 do not have this feature. + freebsd2.*) + archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags' + hardcode_direct=yes + hardcode_minus_L=yes + hardcode_shlibpath_var=no + ;; + + # FreeBSD 3 and greater uses gcc -shared to do shared libraries. + freebsd* | dragonfly*) + archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags' + hardcode_libdir_flag_spec='-R$libdir' + hardcode_direct=yes + hardcode_shlibpath_var=no + ;; + + hpux9*) + if test "$GCC" = yes; then + archive_cmds='$RM $output_objdir/$soname~$CC -shared $pic_flag ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $libobjs $deplibs $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib' + else + archive_cmds='$RM $output_objdir/$soname~$LD -b +b $install_libdir -o $output_objdir/$soname $libobjs $deplibs $linker_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib' + fi + hardcode_libdir_flag_spec='${wl}+b ${wl}$libdir' + hardcode_libdir_separator=: + hardcode_direct=yes + + # hardcode_minus_L: Not really in the search PATH, + # but as the default location of the library. + hardcode_minus_L=yes + export_dynamic_flag_spec='${wl}-E' + ;; + + hpux10*) + if test "$GCC" = yes && test "$with_gnu_ld" = no; then + archive_cmds='$CC -shared $pic_flag ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags' + else + archive_cmds='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags' + fi + if test "$with_gnu_ld" = no; then + hardcode_libdir_flag_spec='${wl}+b ${wl}$libdir' + hardcode_libdir_separator=: + hardcode_direct=yes + hardcode_direct_absolute=yes + export_dynamic_flag_spec='${wl}-E' + # hardcode_minus_L: Not really in the search PATH, + # but as the default location of the library. + hardcode_minus_L=yes + fi + ;; + + hpux11*) + if test "$GCC" = yes && test "$with_gnu_ld" = no; then + case $host_cpu in + hppa*64*) + archive_cmds='$CC -shared ${wl}+h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags' + ;; + ia64*) + archive_cmds='$CC -shared $pic_flag ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags' + ;; + *) + archive_cmds='$CC -shared $pic_flag ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags' + ;; + esac + else + case $host_cpu in + hppa*64*) + archive_cmds='$CC -b ${wl}+h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags' + ;; + ia64*) + archive_cmds='$CC -b ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags' + ;; + *) + + # Older versions of the 11.00 compiler do not understand -b yet + # (HP92453-01 A.11.01.20 doesn't, HP92453-01 B.11.X.35175-35176.GP does) + { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC understands -b" >&5 +$as_echo_n "checking if $CC understands -b... " >&6; } +if ${lt_cv_prog_compiler__b+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_prog_compiler__b=no + save_LDFLAGS="$LDFLAGS" + LDFLAGS="$LDFLAGS -b" + echo "$lt_simple_link_test_code" > conftest.$ac_ext + if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then + # The linker can only warn and ignore the option if not recognized + # So say no if there are warnings + if test -s conftest.err; then + # Append any errors to the config.log. + cat conftest.err 1>&5 + $ECHO "$_lt_linker_boilerplate" | $SED '/^$/d' > conftest.exp + $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2 + if diff conftest.exp conftest.er2 >/dev/null; then + lt_cv_prog_compiler__b=yes + fi + else + lt_cv_prog_compiler__b=yes + fi + fi + $RM -r conftest* + LDFLAGS="$save_LDFLAGS" + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler__b" >&5 +$as_echo "$lt_cv_prog_compiler__b" >&6; } + +if test x"$lt_cv_prog_compiler__b" = xyes; then + archive_cmds='$CC -b ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags' +else + archive_cmds='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags' +fi + + ;; + esac + fi + if test "$with_gnu_ld" = no; then + hardcode_libdir_flag_spec='${wl}+b ${wl}$libdir' + hardcode_libdir_separator=: + + case $host_cpu in + hppa*64*|ia64*) + hardcode_direct=no + hardcode_shlibpath_var=no + ;; + *) + hardcode_direct=yes + hardcode_direct_absolute=yes + export_dynamic_flag_spec='${wl}-E' + + # hardcode_minus_L: Not really in the search PATH, + # but as the default location of the library. + hardcode_minus_L=yes + ;; + esac + fi + ;; + + irix5* | irix6* | nonstopux*) + if test "$GCC" = yes; then + archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' + # Try to use the -exported_symbol ld option, if it does not + # work, assume that -exports_file does not work either and + # implicitly export all symbols. + # This should be the same for all languages, so no per-tag cache variable. + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the $host_os linker accepts -exported_symbol" >&5 +$as_echo_n "checking whether the $host_os linker accepts -exported_symbol... " >&6; } +if ${lt_cv_irix_exported_symbol+:} false; then : + $as_echo_n "(cached) " >&6 +else + save_LDFLAGS="$LDFLAGS" + LDFLAGS="$LDFLAGS -shared ${wl}-exported_symbol ${wl}foo ${wl}-update_registry ${wl}/dev/null" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +int foo (void) { return 0; } +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + lt_cv_irix_exported_symbol=yes +else + lt_cv_irix_exported_symbol=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext + LDFLAGS="$save_LDFLAGS" +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_irix_exported_symbol" >&5 +$as_echo "$lt_cv_irix_exported_symbol" >&6; } + if test "$lt_cv_irix_exported_symbol" = yes; then + archive_expsym_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations ${wl}-exports_file ${wl}$export_symbols -o $lib' + fi + else + archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib' + archive_expsym_cmds='$CC -shared $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -exports_file $export_symbols -o $lib' + fi + archive_cmds_need_lc='no' + hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir' + hardcode_libdir_separator=: + inherit_rpath=yes + link_all_deplibs=yes + ;; + + netbsd* | netbsdelf*-gnu) + if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then + archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags' # a.out + else + archive_cmds='$LD -shared -o $lib $libobjs $deplibs $linker_flags' # ELF + fi + hardcode_libdir_flag_spec='-R$libdir' + hardcode_direct=yes + hardcode_shlibpath_var=no + ;; + + newsos6) + archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + hardcode_direct=yes + hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir' + hardcode_libdir_separator=: + hardcode_shlibpath_var=no + ;; + + *nto* | *qnx*) + ;; + + openbsd*) + if test -f /usr/libexec/ld.so; then + hardcode_direct=yes + hardcode_shlibpath_var=no + hardcode_direct_absolute=yes + if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then + archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags' + archive_expsym_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags ${wl}-retain-symbols-file,$export_symbols' + hardcode_libdir_flag_spec='${wl}-rpath,$libdir' + export_dynamic_flag_spec='${wl}-E' + else + case $host_os in + openbsd[01].* | openbsd2.[0-7] | openbsd2.[0-7].*) + archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags' + hardcode_libdir_flag_spec='-R$libdir' + ;; + *) + archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags' + hardcode_libdir_flag_spec='${wl}-rpath,$libdir' + ;; + esac + fi + else + ld_shlibs=no + fi + ;; + + os2*) + hardcode_libdir_flag_spec='-L$libdir' + hardcode_minus_L=yes + allow_undefined_flag=unsupported + archive_cmds='$ECHO "LIBRARY $libname INITINSTANCE" > $output_objdir/$libname.def~$ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~echo DATA >> $output_objdir/$libname.def~echo " SINGLE NONSHARED" >> $output_objdir/$libname.def~echo EXPORTS >> $output_objdir/$libname.def~emxexp $libobjs >> $output_objdir/$libname.def~$CC -Zdll -Zcrtdll -o $lib $libobjs $deplibs $compiler_flags $output_objdir/$libname.def' + old_archive_from_new_cmds='emximp -o $output_objdir/$libname.a $output_objdir/$libname.def' + ;; + + osf3*) + if test "$GCC" = yes; then + allow_undefined_flag=' ${wl}-expect_unresolved ${wl}\*' + archive_cmds='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' + else + allow_undefined_flag=' -expect_unresolved \*' + archive_cmds='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib' + fi + archive_cmds_need_lc='no' + hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir' + hardcode_libdir_separator=: + ;; + + osf4* | osf5*) # as osf3* with the addition of -msym flag + if test "$GCC" = yes; then + allow_undefined_flag=' ${wl}-expect_unresolved ${wl}\*' + archive_cmds='$CC -shared${allow_undefined_flag} $pic_flag $libobjs $deplibs $compiler_flags ${wl}-msym ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' + hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir' + else + allow_undefined_flag=' -expect_unresolved \*' + archive_cmds='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags -msym -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib' + archive_expsym_cmds='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done; printf "%s\\n" "-hidden">> $lib.exp~ + $CC -shared${allow_undefined_flag} ${wl}-input ${wl}$lib.exp $compiler_flags $libobjs $deplibs -soname $soname `test -n "$verstring" && $ECHO "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib~$RM $lib.exp' + + # Both c and cxx compiler support -rpath directly + hardcode_libdir_flag_spec='-rpath $libdir' + fi + archive_cmds_need_lc='no' + hardcode_libdir_separator=: + ;; + + solaris*) + no_undefined_flag=' -z defs' + if test "$GCC" = yes; then + wlarc='${wl}' + archive_cmds='$CC -shared $pic_flag ${wl}-z ${wl}text ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags' + archive_expsym_cmds='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~ + $CC -shared $pic_flag ${wl}-z ${wl}text ${wl}-M ${wl}$lib.exp ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags~$RM $lib.exp' + else + case `$CC -V 2>&1` in + *"Compilers 5.0"*) + wlarc='' + archive_cmds='$LD -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $linker_flags' + archive_expsym_cmds='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~ + $LD -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $linker_flags~$RM $lib.exp' + ;; + *) + wlarc='${wl}' + archive_cmds='$CC -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $compiler_flags' + archive_expsym_cmds='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~ + $CC -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $compiler_flags~$RM $lib.exp' + ;; + esac + fi + hardcode_libdir_flag_spec='-R$libdir' + hardcode_shlibpath_var=no + case $host_os in + solaris2.[0-5] | solaris2.[0-5].*) ;; + *) + # The compiler driver will combine and reorder linker options, + # but understands `-z linker_flag'. GCC discards it without `$wl', + # but is careful enough not to reorder. + # Supported since Solaris 2.6 (maybe 2.5.1?) + if test "$GCC" = yes; then + whole_archive_flag_spec='${wl}-z ${wl}allextract$convenience ${wl}-z ${wl}defaultextract' + else + whole_archive_flag_spec='-z allextract$convenience -z defaultextract' + fi + ;; + esac + link_all_deplibs=yes + ;; + + sunos4*) + if test "x$host_vendor" = xsequent; then + # Use $CC to link under sequent, because it throws in some extra .o + # files that make .init and .fini sections work. + archive_cmds='$CC -G ${wl}-h $soname -o $lib $libobjs $deplibs $compiler_flags' + else + archive_cmds='$LD -assert pure-text -Bstatic -o $lib $libobjs $deplibs $linker_flags' + fi + hardcode_libdir_flag_spec='-L$libdir' + hardcode_direct=yes + hardcode_minus_L=yes + hardcode_shlibpath_var=no + ;; + + sysv4) + case $host_vendor in + sni) + archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + hardcode_direct=yes # is this really true??? + ;; + siemens) + ## LD is ld it makes a PLAMLIB + ## CC just makes a GrossModule. + archive_cmds='$LD -G -o $lib $libobjs $deplibs $linker_flags' + reload_cmds='$CC -r -o $output$reload_objs' + hardcode_direct=no + ;; + motorola) + archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + hardcode_direct=no #Motorola manual says yes, but my tests say they lie + ;; + esac + runpath_var='LD_RUN_PATH' + hardcode_shlibpath_var=no + ;; + + sysv4.3*) + archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + hardcode_shlibpath_var=no + export_dynamic_flag_spec='-Bexport' + ;; + + sysv4*MP*) + if test -d /usr/nec; then + archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + hardcode_shlibpath_var=no + runpath_var=LD_RUN_PATH + hardcode_runpath_var=yes + ld_shlibs=yes + fi + ;; + + sysv4*uw2* | sysv5OpenUNIX* | sysv5UnixWare7.[01].[10]* | unixware7* | sco3.2v5.0.[024]*) + no_undefined_flag='${wl}-z,text' + archive_cmds_need_lc=no + hardcode_shlibpath_var=no + runpath_var='LD_RUN_PATH' + + if test "$GCC" = yes; then + archive_cmds='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + archive_expsym_cmds='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + else + archive_cmds='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + archive_expsym_cmds='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + fi + ;; + + sysv5* | sco3.2v5* | sco5v6*) + # Note: We can NOT use -z defs as we might desire, because we do not + # link with -lc, and that would cause any symbols used from libc to + # always be unresolved, which means just about no library would + # ever link correctly. If we're not using GNU ld we use -z text + # though, which does catch some bad symbols but isn't as heavy-handed + # as -z defs. + no_undefined_flag='${wl}-z,text' + allow_undefined_flag='${wl}-z,nodefs' + archive_cmds_need_lc=no + hardcode_shlibpath_var=no + hardcode_libdir_flag_spec='${wl}-R,$libdir' + hardcode_libdir_separator=':' + link_all_deplibs=yes + export_dynamic_flag_spec='${wl}-Bexport' + runpath_var='LD_RUN_PATH' + + if test "$GCC" = yes; then + archive_cmds='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + archive_expsym_cmds='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + else + archive_cmds='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + archive_expsym_cmds='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + fi + ;; + + uts4*) + archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + hardcode_libdir_flag_spec='-L$libdir' + hardcode_shlibpath_var=no + ;; + + *) + ld_shlibs=no + ;; + esac + + if test x$host_vendor = xsni; then + case $host in + sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*) + export_dynamic_flag_spec='${wl}-Blargedynsym' + ;; + esac + fi + fi + +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ld_shlibs" >&5 +$as_echo "$ld_shlibs" >&6; } +test "$ld_shlibs" = no && can_build_shared=no + +with_gnu_ld=$with_gnu_ld + + + + + + + + + + + + + + + +# +# Do we need to explicitly link libc? +# +case "x$archive_cmds_need_lc" in +x|xyes) + # Assume -lc should be added + archive_cmds_need_lc=yes + + if test "$enable_shared" = yes && test "$GCC" = yes; then + case $archive_cmds in + *'~'*) + # FIXME: we may have to deal with multi-command sequences. + ;; + '$CC '*) + # Test whether the compiler implicitly links with -lc since on some + # systems, -lgcc has to come before -lc. If gcc already passes -lc + # to ld, don't add -lc before -lgcc. + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether -lc should be explicitly linked in" >&5 +$as_echo_n "checking whether -lc should be explicitly linked in... " >&6; } +if ${lt_cv_archive_cmds_need_lc+:} false; then : + $as_echo_n "(cached) " >&6 +else + $RM conftest* + echo "$lt_simple_compile_test_code" > conftest.$ac_ext + + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 + (eval $ac_compile) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } 2>conftest.err; then + soname=conftest + lib=conftest + libobjs=conftest.$ac_objext + deplibs= + wl=$lt_prog_compiler_wl + pic_flag=$lt_prog_compiler_pic + compiler_flags=-v + linker_flags=-v + verstring= + output_objdir=. + libname=conftest + lt_save_allow_undefined_flag=$allow_undefined_flag + allow_undefined_flag= + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$archive_cmds 2\>\&1 \| $GREP \" -lc \" \>/dev/null 2\>\&1\""; } >&5 + (eval $archive_cmds 2\>\&1 \| $GREP \" -lc \" \>/dev/null 2\>\&1) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } + then + lt_cv_archive_cmds_need_lc=no + else + lt_cv_archive_cmds_need_lc=yes + fi + allow_undefined_flag=$lt_save_allow_undefined_flag + else + cat conftest.err 1>&5 + fi + $RM conftest* + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_archive_cmds_need_lc" >&5 +$as_echo "$lt_cv_archive_cmds_need_lc" >&6; } + archive_cmds_need_lc=$lt_cv_archive_cmds_need_lc + ;; + esac + fi + ;; +esac + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking dynamic linker characteristics" >&5 +$as_echo_n "checking dynamic linker characteristics... " >&6; } + +if test "$GCC" = yes; then + case $host_os in + darwin*) lt_awk_arg="/^libraries:/,/LR/" ;; + *) lt_awk_arg="/^libraries:/" ;; + esac + case $host_os in + mingw* | cegcc*) lt_sed_strip_eq="s,=\([A-Za-z]:\),\1,g" ;; + *) lt_sed_strip_eq="s,=/,/,g" ;; + esac + lt_search_path_spec=`$CC -print-search-dirs | awk $lt_awk_arg | $SED -e "s/^libraries://" -e $lt_sed_strip_eq` + case $lt_search_path_spec in + *\;*) + # if the path contains ";" then we assume it to be the separator + # otherwise default to the standard path separator (i.e. ":") - it is + # assumed that no part of a normal pathname contains ";" but that should + # okay in the real world where ";" in dirpaths is itself problematic. + lt_search_path_spec=`$ECHO "$lt_search_path_spec" | $SED 's/;/ /g'` + ;; + *) + lt_search_path_spec=`$ECHO "$lt_search_path_spec" | $SED "s/$PATH_SEPARATOR/ /g"` + ;; + esac + # Ok, now we have the path, separated by spaces, we can step through it + # and add multilib dir if necessary. + lt_tmp_lt_search_path_spec= + lt_multi_os_dir=`$CC $CPPFLAGS $CFLAGS $LDFLAGS -print-multi-os-directory 2>/dev/null` + for lt_sys_path in $lt_search_path_spec; do + if test -d "$lt_sys_path/$lt_multi_os_dir"; then + lt_tmp_lt_search_path_spec="$lt_tmp_lt_search_path_spec $lt_sys_path/$lt_multi_os_dir" + else + test -d "$lt_sys_path" && \ + lt_tmp_lt_search_path_spec="$lt_tmp_lt_search_path_spec $lt_sys_path" + fi + done + lt_search_path_spec=`$ECHO "$lt_tmp_lt_search_path_spec" | awk ' +BEGIN {RS=" "; FS="/|\n";} { + lt_foo=""; + lt_count=0; + for (lt_i = NF; lt_i > 0; lt_i--) { + if ($lt_i != "" && $lt_i != ".") { + if ($lt_i == "..") { + lt_count++; + } else { + if (lt_count == 0) { + lt_foo="/" $lt_i lt_foo; + } else { + lt_count--; + } + } + } + } + if (lt_foo != "") { lt_freq[lt_foo]++; } + if (lt_freq[lt_foo] == 1) { print lt_foo; } +}'` + # AWK program above erroneously prepends '/' to C:/dos/paths + # for these hosts. + case $host_os in + mingw* | cegcc*) lt_search_path_spec=`$ECHO "$lt_search_path_spec" |\ + $SED 's,/\([A-Za-z]:\),\1,g'` ;; + esac + sys_lib_search_path_spec=`$ECHO "$lt_search_path_spec" | $lt_NL2SP` +else + sys_lib_search_path_spec="/lib /usr/lib /usr/local/lib" +fi +library_names_spec= +libname_spec='lib$name' +soname_spec= +shrext_cmds=".so" +postinstall_cmds= +postuninstall_cmds= +finish_cmds= +finish_eval= +shlibpath_var= +shlibpath_overrides_runpath=unknown +version_type=none +dynamic_linker="$host_os ld.so" +sys_lib_dlsearch_path_spec="/lib /usr/lib" +need_lib_prefix=unknown +hardcode_into_libs=no + +# when you set need_version to no, make sure it does not cause -set_version +# flags to be left without arguments +need_version=unknown + +case $host_os in +aix3*) + version_type=linux # correct to gnu/linux during the next big refactor + library_names_spec='${libname}${release}${shared_ext}$versuffix $libname.a' + shlibpath_var=LIBPATH + + # AIX 3 has no versioning support, so we append a major version to the name. + soname_spec='${libname}${release}${shared_ext}$major' + ;; + +aix[4-9]*) + version_type=linux # correct to gnu/linux during the next big refactor + need_lib_prefix=no + need_version=no + hardcode_into_libs=yes + if test "$host_cpu" = ia64; then + # AIX 5 supports IA64 + library_names_spec='${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext}$versuffix $libname${shared_ext}' + shlibpath_var=LD_LIBRARY_PATH + else + # With GCC up to 2.95.x, collect2 would create an import file + # for dependence libraries. The import file would start with + # the line `#! .'. This would cause the generated library to + # depend on `.', always an invalid library. This was fixed in + # development snapshots of GCC prior to 3.0. + case $host_os in + aix4 | aix4.[01] | aix4.[01].*) + if { echo '#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 97)' + echo ' yes ' + echo '#endif'; } | ${CC} -E - | $GREP yes > /dev/null; then + : + else + can_build_shared=no + fi + ;; + esac + # AIX (on Power*) has no versioning support, so currently we can not hardcode correct + # soname into executable. Probably we can add versioning support to + # collect2, so additional links can be useful in future. + if test "$aix_use_runtimelinking" = yes; then + # If using run time linking (on AIX 4.2 or later) use lib.so + # instead of lib.a to let people know that these are not + # typical AIX shared libraries. + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + else + # We preserve .a as extension for shared libraries through AIX4.2 + # and later when we are not doing run time linking. + library_names_spec='${libname}${release}.a $libname.a' + soname_spec='${libname}${release}${shared_ext}$major' + fi + shlibpath_var=LIBPATH + fi + ;; + +amigaos*) + case $host_cpu in + powerpc) + # Since July 2007 AmigaOS4 officially supports .so libraries. + # When compiling the executable, add -use-dynld -Lsobjs: to the compileline. + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + ;; + m68k) + library_names_spec='$libname.ixlibrary $libname.a' + # Create ${libname}_ixlibrary.a entries in /sys/libs. + finish_eval='for lib in `ls $libdir/*.ixlibrary 2>/dev/null`; do libname=`func_echo_all "$lib" | $SED '\''s%^.*/\([^/]*\)\.ixlibrary$%\1%'\''`; test $RM /sys/libs/${libname}_ixlibrary.a; $show "cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a"; cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a || exit 1; done' + ;; + esac + ;; + +beos*) + library_names_spec='${libname}${shared_ext}' + dynamic_linker="$host_os ld.so" + shlibpath_var=LIBRARY_PATH + ;; + +bsdi[45]*) + version_type=linux # correct to gnu/linux during the next big refactor + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + finish_cmds='PATH="\$PATH:/sbin" ldconfig $libdir' + shlibpath_var=LD_LIBRARY_PATH + sys_lib_search_path_spec="/shlib /usr/lib /usr/X11/lib /usr/contrib/lib /lib /usr/local/lib" + sys_lib_dlsearch_path_spec="/shlib /usr/lib /usr/local/lib" + # the default ld.so.conf also contains /usr/contrib/lib and + # /usr/X11R6/lib (/usr/X11 is a link to /usr/X11R6), but let us allow + # libtool to hard-code these into programs + ;; + +cygwin* | mingw* | pw32* | cegcc*) + version_type=windows + shrext_cmds=".dll" + need_version=no + need_lib_prefix=no + + case $GCC,$cc_basename in + yes,*) + # gcc + library_names_spec='$libname.dll.a' + # DLL is installed to $(libdir)/../bin by postinstall_cmds + postinstall_cmds='base_file=`basename \${file}`~ + dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i; echo \$dlname'\''`~ + dldir=$destdir/`dirname \$dlpath`~ + test -d \$dldir || mkdir -p \$dldir~ + $install_prog $dir/$dlname \$dldir/$dlname~ + chmod a+x \$dldir/$dlname~ + if test -n '\''$stripme'\'' && test -n '\''$striplib'\''; then + eval '\''$striplib \$dldir/$dlname'\'' || exit \$?; + fi' + postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~ + dlpath=$dir/\$dldll~ + $RM \$dlpath' + shlibpath_overrides_runpath=yes + + case $host_os in + cygwin*) + # Cygwin DLLs use 'cyg' prefix rather than 'lib' + soname_spec='`echo ${libname} | sed -e 's/^lib/cyg/'``echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}' + + sys_lib_search_path_spec="$sys_lib_search_path_spec /usr/lib/w32api" + ;; + mingw* | cegcc*) + # MinGW DLLs use traditional 'lib' prefix + soname_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}' + ;; + pw32*) + # pw32 DLLs use 'pw' prefix rather than 'lib' + library_names_spec='`echo ${libname} | sed -e 's/^lib/pw/'``echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}' + ;; + esac + dynamic_linker='Win32 ld.exe' + ;; + + *,cl*) + # Native MSVC + libname_spec='$name' + soname_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}' + library_names_spec='${libname}.dll.lib' + + case $build_os in + mingw*) + sys_lib_search_path_spec= + lt_save_ifs=$IFS + IFS=';' + for lt_path in $LIB + do + IFS=$lt_save_ifs + # Let DOS variable expansion print the short 8.3 style file name. + lt_path=`cd "$lt_path" 2>/dev/null && cmd //C "for %i in (".") do @echo %~si"` + sys_lib_search_path_spec="$sys_lib_search_path_spec $lt_path" + done + IFS=$lt_save_ifs + # Convert to MSYS style. + sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | sed -e 's|\\\\|/|g' -e 's| \\([a-zA-Z]\\):| /\\1|g' -e 's|^ ||'` + ;; + cygwin*) + # Convert to unix form, then to dos form, then back to unix form + # but this time dos style (no spaces!) so that the unix form looks + # like /cygdrive/c/PROGRA~1:/cygdr... + sys_lib_search_path_spec=`cygpath --path --unix "$LIB"` + sys_lib_search_path_spec=`cygpath --path --dos "$sys_lib_search_path_spec" 2>/dev/null` + sys_lib_search_path_spec=`cygpath --path --unix "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"` + ;; + *) + sys_lib_search_path_spec="$LIB" + if $ECHO "$sys_lib_search_path_spec" | $GREP ';[c-zC-Z]:/' >/dev/null; then + # It is most probably a Windows format PATH. + sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'` + else + sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"` + fi + # FIXME: find the short name or the path components, as spaces are + # common. (e.g. "Program Files" -> "PROGRA~1") + ;; + esac + + # DLL is installed to $(libdir)/../bin by postinstall_cmds + postinstall_cmds='base_file=`basename \${file}`~ + dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i; echo \$dlname'\''`~ + dldir=$destdir/`dirname \$dlpath`~ + test -d \$dldir || mkdir -p \$dldir~ + $install_prog $dir/$dlname \$dldir/$dlname' + postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~ + dlpath=$dir/\$dldll~ + $RM \$dlpath' + shlibpath_overrides_runpath=yes + dynamic_linker='Win32 link.exe' + ;; + + *) + # Assume MSVC wrapper + library_names_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext} $libname.lib' + dynamic_linker='Win32 ld.exe' + ;; + esac + # FIXME: first we should search . and the directory the executable is in + shlibpath_var=PATH + ;; + +darwin* | rhapsody*) + dynamic_linker="$host_os dyld" + version_type=darwin + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${major}$shared_ext ${libname}$shared_ext' + soname_spec='${libname}${release}${major}$shared_ext' + shlibpath_overrides_runpath=yes + shlibpath_var=DYLD_LIBRARY_PATH + shrext_cmds='`test .$module = .yes && echo .so || echo .dylib`' + + sys_lib_search_path_spec="$sys_lib_search_path_spec /usr/local/lib" + sys_lib_dlsearch_path_spec='/usr/local/lib /lib /usr/lib' + ;; + +dgux*) + version_type=linux # correct to gnu/linux during the next big refactor + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname$shared_ext' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + ;; + +freebsd* | dragonfly*) + # DragonFly does not have aout. When/if they implement a new + # versioning mechanism, adjust this. + if test -x /usr/bin/objformat; then + objformat=`/usr/bin/objformat` + else + case $host_os in + freebsd[23].*) objformat=aout ;; + *) objformat=elf ;; + esac + fi + version_type=freebsd-$objformat + case $version_type in + freebsd-elf*) + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}' + need_version=no + need_lib_prefix=no + ;; + freebsd-*) + library_names_spec='${libname}${release}${shared_ext}$versuffix $libname${shared_ext}$versuffix' + need_version=yes + ;; + esac + shlibpath_var=LD_LIBRARY_PATH + case $host_os in + freebsd2.*) + shlibpath_overrides_runpath=yes + ;; + freebsd3.[01]* | freebsdelf3.[01]*) + shlibpath_overrides_runpath=yes + hardcode_into_libs=yes + ;; + freebsd3.[2-9]* | freebsdelf3.[2-9]* | \ + freebsd4.[0-5] | freebsdelf4.[0-5] | freebsd4.1.1 | freebsdelf4.1.1) + shlibpath_overrides_runpath=no + hardcode_into_libs=yes + ;; + *) # from 4.6 on, and DragonFly + shlibpath_overrides_runpath=yes + hardcode_into_libs=yes + ;; + esac + ;; + +haiku*) + version_type=linux # correct to gnu/linux during the next big refactor + need_lib_prefix=no + need_version=no + dynamic_linker="$host_os runtime_loader" + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}${major} ${libname}${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LIBRARY_PATH + shlibpath_overrides_runpath=yes + sys_lib_dlsearch_path_spec='/boot/home/config/lib /boot/common/lib /boot/system/lib' + hardcode_into_libs=yes + ;; + +hpux9* | hpux10* | hpux11*) + # Give a soname corresponding to the major version so that dld.sl refuses to + # link against other versions. + version_type=sunos + need_lib_prefix=no + need_version=no + case $host_cpu in + ia64*) + shrext_cmds='.so' + hardcode_into_libs=yes + dynamic_linker="$host_os dld.so" + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes # Unless +noenvvar is specified. + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + if test "X$HPUX_IA64_MODE" = X32; then + sys_lib_search_path_spec="/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib" + else + sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64" + fi + sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec + ;; + hppa*64*) + shrext_cmds='.sl' + hardcode_into_libs=yes + dynamic_linker="$host_os dld.sl" + shlibpath_var=LD_LIBRARY_PATH # How should we handle SHLIB_PATH + shlibpath_overrides_runpath=yes # Unless +noenvvar is specified. + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + sys_lib_search_path_spec="/usr/lib/pa20_64 /usr/ccs/lib/pa20_64" + sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec + ;; + *) + shrext_cmds='.sl' + dynamic_linker="$host_os dld.sl" + shlibpath_var=SHLIB_PATH + shlibpath_overrides_runpath=no # +s is required to enable SHLIB_PATH + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + ;; + esac + # HP-UX runs *really* slowly unless shared libraries are mode 555, ... + postinstall_cmds='chmod 555 $lib' + # or fails outright, so override atomically: + install_override_mode=555 + ;; + +interix[3-9]*) + version_type=linux # correct to gnu/linux during the next big refactor + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + dynamic_linker='Interix 3.x ld.so.1 (PE, like ELF)' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + hardcode_into_libs=yes + ;; + +irix5* | irix6* | nonstopux*) + case $host_os in + nonstopux*) version_type=nonstopux ;; + *) + if test "$lt_cv_prog_gnu_ld" = yes; then + version_type=linux # correct to gnu/linux during the next big refactor + else + version_type=irix + fi ;; + esac + need_lib_prefix=no + need_version=no + soname_spec='${libname}${release}${shared_ext}$major' + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext} $libname${shared_ext}' + case $host_os in + irix5* | nonstopux*) + libsuff= shlibsuff= + ;; + *) + case $LD in # libtool.m4 will add one of these switches to LD + *-32|*"-32 "|*-melf32bsmip|*"-melf32bsmip ") + libsuff= shlibsuff= libmagic=32-bit;; + *-n32|*"-n32 "|*-melf32bmipn32|*"-melf32bmipn32 ") + libsuff=32 shlibsuff=N32 libmagic=N32;; + *-64|*"-64 "|*-melf64bmip|*"-melf64bmip ") + libsuff=64 shlibsuff=64 libmagic=64-bit;; + *) libsuff= shlibsuff= libmagic=never-match;; + esac + ;; + esac + shlibpath_var=LD_LIBRARY${shlibsuff}_PATH + shlibpath_overrides_runpath=no + sys_lib_search_path_spec="/usr/lib${libsuff} /lib${libsuff} /usr/local/lib${libsuff}" + sys_lib_dlsearch_path_spec="/usr/lib${libsuff} /lib${libsuff}" + hardcode_into_libs=yes + ;; + +# No shared lib support for Linux oldld, aout, or coff. +linux*oldld* | linux*aout* | linux*coff*) + dynamic_linker=no + ;; + +# This must be glibc/ELF. +linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*) + version_type=linux # correct to gnu/linux during the next big refactor + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + finish_cmds='PATH="\$PATH:/sbin" ldconfig -n $libdir' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + + # Some binutils ld are patched to set DT_RUNPATH + if ${lt_cv_shlibpath_overrides_runpath+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_shlibpath_overrides_runpath=no + save_LDFLAGS=$LDFLAGS + save_libdir=$libdir + eval "libdir=/foo; wl=\"$lt_prog_compiler_wl\"; \ + LDFLAGS=\"\$LDFLAGS $hardcode_libdir_flag_spec\"" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + if ($OBJDUMP -p conftest$ac_exeext) 2>/dev/null | grep "RUNPATH.*$libdir" >/dev/null; then : + lt_cv_shlibpath_overrides_runpath=yes +fi +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext + LDFLAGS=$save_LDFLAGS + libdir=$save_libdir + +fi + + shlibpath_overrides_runpath=$lt_cv_shlibpath_overrides_runpath + + # This implies no fast_install, which is unacceptable. + # Some rework will be needed to allow for fast_install + # before this can be enabled. + hardcode_into_libs=yes + + # Append ld.so.conf contents to the search path + if test -f /etc/ld.so.conf; then + lt_ld_extra=`awk '/^include / { system(sprintf("cd /etc; cat %s 2>/dev/null", \$2)); skip = 1; } { if (!skip) print \$0; skip = 0; }' < /etc/ld.so.conf | $SED -e 's/#.*//;/^[ ]*hwcap[ ]/d;s/[:, ]/ /g;s/=[^=]*$//;s/=[^= ]* / /g;s/"//g;/^$/d' | tr '\n' ' '` + sys_lib_dlsearch_path_spec="/lib /usr/lib $lt_ld_extra" + fi + + # We used to test for /lib/ld.so.1 and disable shared libraries on + # powerpc, because MkLinux only supported shared libraries with the + # GNU dynamic linker. Since this was broken with cross compilers, + # most powerpc-linux boxes support dynamic linking these days and + # people can always --disable-shared, the test was removed, and we + # assume the GNU/Linux dynamic linker is in use. + dynamic_linker='GNU/Linux ld.so' + ;; + +netbsdelf*-gnu) + version_type=linux + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + hardcode_into_libs=yes + dynamic_linker='NetBSD ld.elf_so' + ;; + +netbsd*) + version_type=sunos + need_lib_prefix=no + need_version=no + if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix' + finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir' + dynamic_linker='NetBSD (a.out) ld.so' + else + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + dynamic_linker='NetBSD ld.elf_so' + fi + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + hardcode_into_libs=yes + ;; + +newsos6) + version_type=linux # correct to gnu/linux during the next big refactor + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + ;; + +*nto* | *qnx*) + version_type=qnx + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + hardcode_into_libs=yes + dynamic_linker='ldqnx.so' + ;; + +openbsd*) + version_type=sunos + sys_lib_dlsearch_path_spec="/usr/lib" + need_lib_prefix=no + # Some older versions of OpenBSD (3.3 at least) *do* need versioned libs. + case $host_os in + openbsd3.3 | openbsd3.3.*) need_version=yes ;; + *) need_version=no ;; + esac + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix' + finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir' + shlibpath_var=LD_LIBRARY_PATH + if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then + case $host_os in + openbsd2.[89] | openbsd2.[89].*) + shlibpath_overrides_runpath=no + ;; + *) + shlibpath_overrides_runpath=yes + ;; + esac + else + shlibpath_overrides_runpath=yes + fi + ;; + +os2*) + libname_spec='$name' + shrext_cmds=".dll" + need_lib_prefix=no + library_names_spec='$libname${shared_ext} $libname.a' + dynamic_linker='OS/2 ld.exe' + shlibpath_var=LIBPATH + ;; + +osf3* | osf4* | osf5*) + version_type=osf + need_lib_prefix=no + need_version=no + soname_spec='${libname}${release}${shared_ext}$major' + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + shlibpath_var=LD_LIBRARY_PATH + sys_lib_search_path_spec="/usr/shlib /usr/ccs/lib /usr/lib/cmplrs/cc /usr/lib /usr/local/lib /var/shlib" + sys_lib_dlsearch_path_spec="$sys_lib_search_path_spec" + ;; + +rdos*) + dynamic_linker=no + ;; + +solaris*) + version_type=linux # correct to gnu/linux during the next big refactor + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + hardcode_into_libs=yes + # ldd complains unless libraries are executable + postinstall_cmds='chmod +x $lib' + ;; + +sunos4*) + version_type=sunos + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix' + finish_cmds='PATH="\$PATH:/usr/etc" ldconfig $libdir' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + if test "$with_gnu_ld" = yes; then + need_lib_prefix=no + fi + need_version=yes + ;; + +sysv4 | sysv4.3*) + version_type=linux # correct to gnu/linux during the next big refactor + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + case $host_vendor in + sni) + shlibpath_overrides_runpath=no + need_lib_prefix=no + runpath_var=LD_RUN_PATH + ;; + siemens) + need_lib_prefix=no + ;; + motorola) + need_lib_prefix=no + need_version=no + shlibpath_overrides_runpath=no + sys_lib_search_path_spec='/lib /usr/lib /usr/ccs/lib' + ;; + esac + ;; + +sysv4*MP*) + if test -d /usr/nec ;then + version_type=linux # correct to gnu/linux during the next big refactor + library_names_spec='$libname${shared_ext}.$versuffix $libname${shared_ext}.$major $libname${shared_ext}' + soname_spec='$libname${shared_ext}.$major' + shlibpath_var=LD_LIBRARY_PATH + fi + ;; + +sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*) + version_type=freebsd-elf + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + hardcode_into_libs=yes + if test "$with_gnu_ld" = yes; then + sys_lib_search_path_spec='/usr/local/lib /usr/gnu/lib /usr/ccs/lib /usr/lib /lib' + else + sys_lib_search_path_spec='/usr/ccs/lib /usr/lib' + case $host_os in + sco3.2v5*) + sys_lib_search_path_spec="$sys_lib_search_path_spec /lib" + ;; + esac + fi + sys_lib_dlsearch_path_spec='/usr/lib' + ;; + +tpf*) + # TPF is a cross-target only. Preferred cross-host = GNU/Linux. + version_type=linux # correct to gnu/linux during the next big refactor + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + hardcode_into_libs=yes + ;; + +uts4*) + version_type=linux # correct to gnu/linux during the next big refactor + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + ;; + +*) + dynamic_linker=no + ;; +esac +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $dynamic_linker" >&5 +$as_echo "$dynamic_linker" >&6; } +test "$dynamic_linker" = no && can_build_shared=no + +variables_saved_for_relink="PATH $shlibpath_var $runpath_var" +if test "$GCC" = yes; then + variables_saved_for_relink="$variables_saved_for_relink GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH" +fi + +if test "${lt_cv_sys_lib_search_path_spec+set}" = set; then + sys_lib_search_path_spec="$lt_cv_sys_lib_search_path_spec" +fi +if test "${lt_cv_sys_lib_dlsearch_path_spec+set}" = set; then + sys_lib_dlsearch_path_spec="$lt_cv_sys_lib_dlsearch_path_spec" +fi + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to hardcode library paths into programs" >&5 +$as_echo_n "checking how to hardcode library paths into programs... " >&6; } +hardcode_action= +if test -n "$hardcode_libdir_flag_spec" || + test -n "$runpath_var" || + test "X$hardcode_automatic" = "Xyes" ; then + + # We can hardcode non-existent directories. + if test "$hardcode_direct" != no && + # If the only mechanism to avoid hardcoding is shlibpath_var, we + # have to relink, otherwise we might link with an installed library + # when we should be linking with a yet-to-be-installed one + ## test "$_LT_TAGVAR(hardcode_shlibpath_var, )" != no && + test "$hardcode_minus_L" != no; then + # Linking always hardcodes the temporary library directory. + hardcode_action=relink + else + # We can link without hardcoding, and we can hardcode nonexisting dirs. + hardcode_action=immediate + fi +else + # We cannot hardcode anything, or else we can only hardcode existing + # directories. + hardcode_action=unsupported +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $hardcode_action" >&5 +$as_echo "$hardcode_action" >&6; } + +if test "$hardcode_action" = relink || + test "$inherit_rpath" = yes; then + # Fast installation is not supported + enable_fast_install=no +elif test "$shlibpath_overrides_runpath" = yes || + test "$enable_shared" = no; then + # Fast installation is not necessary + enable_fast_install=needless +fi + + + + + + + if test "x$enable_dlopen" != xyes; then + enable_dlopen=unknown + enable_dlopen_self=unknown + enable_dlopen_self_static=unknown +else + lt_cv_dlopen=no + lt_cv_dlopen_libs= + + case $host_os in + beos*) + lt_cv_dlopen="load_add_on" + lt_cv_dlopen_libs= + lt_cv_dlopen_self=yes + ;; + + mingw* | pw32* | cegcc*) + lt_cv_dlopen="LoadLibrary" + lt_cv_dlopen_libs= + ;; + + cygwin*) + lt_cv_dlopen="dlopen" + lt_cv_dlopen_libs= + ;; + + darwin*) + # if libdl is installed we need to link against it + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5 +$as_echo_n "checking for dlopen in -ldl... " >&6; } +if ${ac_cv_lib_dl_dlopen+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-ldl $LIBS" +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char dlopen (); +int +main () +{ +return dlopen (); + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + ac_cv_lib_dl_dlopen=yes +else + ac_cv_lib_dl_dlopen=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5 +$as_echo "$ac_cv_lib_dl_dlopen" >&6; } +if test "x$ac_cv_lib_dl_dlopen" = xyes; then : + lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl" +else + + lt_cv_dlopen="dyld" + lt_cv_dlopen_libs= + lt_cv_dlopen_self=yes + +fi + + ;; + + *) + ac_fn_c_check_func "$LINENO" "shl_load" "ac_cv_func_shl_load" +if test "x$ac_cv_func_shl_load" = xyes; then : + lt_cv_dlopen="shl_load" +else + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for shl_load in -ldld" >&5 +$as_echo_n "checking for shl_load in -ldld... " >&6; } +if ${ac_cv_lib_dld_shl_load+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-ldld $LIBS" +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char shl_load (); +int +main () +{ +return shl_load (); + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + ac_cv_lib_dld_shl_load=yes +else + ac_cv_lib_dld_shl_load=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dld_shl_load" >&5 +$as_echo "$ac_cv_lib_dld_shl_load" >&6; } +if test "x$ac_cv_lib_dld_shl_load" = xyes; then : + lt_cv_dlopen="shl_load" lt_cv_dlopen_libs="-ldld" +else + ac_fn_c_check_func "$LINENO" "dlopen" "ac_cv_func_dlopen" +if test "x$ac_cv_func_dlopen" = xyes; then : + lt_cv_dlopen="dlopen" +else + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5 +$as_echo_n "checking for dlopen in -ldl... " >&6; } +if ${ac_cv_lib_dl_dlopen+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-ldl $LIBS" +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char dlopen (); +int +main () +{ +return dlopen (); + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + ac_cv_lib_dl_dlopen=yes +else + ac_cv_lib_dl_dlopen=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5 +$as_echo "$ac_cv_lib_dl_dlopen" >&6; } +if test "x$ac_cv_lib_dl_dlopen" = xyes; then : + lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl" +else + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -lsvld" >&5 +$as_echo_n "checking for dlopen in -lsvld... " >&6; } +if ${ac_cv_lib_svld_dlopen+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-lsvld $LIBS" +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char dlopen (); +int +main () +{ +return dlopen (); + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + ac_cv_lib_svld_dlopen=yes +else + ac_cv_lib_svld_dlopen=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_svld_dlopen" >&5 +$as_echo "$ac_cv_lib_svld_dlopen" >&6; } +if test "x$ac_cv_lib_svld_dlopen" = xyes; then : + lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-lsvld" +else + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dld_link in -ldld" >&5 +$as_echo_n "checking for dld_link in -ldld... " >&6; } +if ${ac_cv_lib_dld_dld_link+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-ldld $LIBS" +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char dld_link (); +int +main () +{ +return dld_link (); + ; + return 0; +} +_ACEOF +if ac_fn_c_try_link "$LINENO"; then : + ac_cv_lib_dld_dld_link=yes +else + ac_cv_lib_dld_dld_link=no +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dld_dld_link" >&5 +$as_echo "$ac_cv_lib_dld_dld_link" >&6; } +if test "x$ac_cv_lib_dld_dld_link" = xyes; then : + lt_cv_dlopen="dld_link" lt_cv_dlopen_libs="-ldld" +fi + + +fi + + +fi + + +fi + + +fi + + +fi + + ;; + esac + + if test "x$lt_cv_dlopen" != xno; then + enable_dlopen=yes + else + enable_dlopen=no + fi + + case $lt_cv_dlopen in + dlopen) + save_CPPFLAGS="$CPPFLAGS" + test "x$ac_cv_header_dlfcn_h" = xyes && CPPFLAGS="$CPPFLAGS -DHAVE_DLFCN_H" + + save_LDFLAGS="$LDFLAGS" + wl=$lt_prog_compiler_wl eval LDFLAGS=\"\$LDFLAGS $export_dynamic_flag_spec\" + + save_LIBS="$LIBS" + LIBS="$lt_cv_dlopen_libs $LIBS" + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether a program can dlopen itself" >&5 +$as_echo_n "checking whether a program can dlopen itself... " >&6; } +if ${lt_cv_dlopen_self+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test "$cross_compiling" = yes; then : + lt_cv_dlopen_self=cross +else + lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2 + lt_status=$lt_dlunknown + cat > conftest.$ac_ext <<_LT_EOF +#line $LINENO "configure" +#include "confdefs.h" + +#if HAVE_DLFCN_H +#include +#endif + +#include + +#ifdef RTLD_GLOBAL +# define LT_DLGLOBAL RTLD_GLOBAL +#else +# ifdef DL_GLOBAL +# define LT_DLGLOBAL DL_GLOBAL +# else +# define LT_DLGLOBAL 0 +# endif +#endif + +/* We may have to define LT_DLLAZY_OR_NOW in the command line if we + find out it does not work in some platform. */ +#ifndef LT_DLLAZY_OR_NOW +# ifdef RTLD_LAZY +# define LT_DLLAZY_OR_NOW RTLD_LAZY +# else +# ifdef DL_LAZY +# define LT_DLLAZY_OR_NOW DL_LAZY +# else +# ifdef RTLD_NOW +# define LT_DLLAZY_OR_NOW RTLD_NOW +# else +# ifdef DL_NOW +# define LT_DLLAZY_OR_NOW DL_NOW +# else +# define LT_DLLAZY_OR_NOW 0 +# endif +# endif +# endif +# endif +#endif + +/* When -fvisbility=hidden is used, assume the code has been annotated + correspondingly for the symbols needed. */ +#if defined(__GNUC__) && (((__GNUC__ == 3) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 3)) +int fnord () __attribute__((visibility("default"))); +#endif + +int fnord () { return 42; } +int main () +{ + void *self = dlopen (0, LT_DLGLOBAL|LT_DLLAZY_OR_NOW); + int status = $lt_dlunknown; + + if (self) + { + if (dlsym (self,"fnord")) status = $lt_dlno_uscore; + else + { + if (dlsym( self,"_fnord")) status = $lt_dlneed_uscore; + else puts (dlerror ()); + } + /* dlclose (self); */ + } + else + puts (dlerror ()); + + return status; +} +_LT_EOF + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5 + (eval $ac_link) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } && test -s conftest${ac_exeext} 2>/dev/null; then + (./conftest; exit; ) >&5 2>/dev/null + lt_status=$? + case x$lt_status in + x$lt_dlno_uscore) lt_cv_dlopen_self=yes ;; + x$lt_dlneed_uscore) lt_cv_dlopen_self=yes ;; + x$lt_dlunknown|x*) lt_cv_dlopen_self=no ;; + esac + else : + # compilation failed + lt_cv_dlopen_self=no + fi +fi +rm -fr conftest* + + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_dlopen_self" >&5 +$as_echo "$lt_cv_dlopen_self" >&6; } + + if test "x$lt_cv_dlopen_self" = xyes; then + wl=$lt_prog_compiler_wl eval LDFLAGS=\"\$LDFLAGS $lt_prog_compiler_static\" + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether a statically linked program can dlopen itself" >&5 +$as_echo_n "checking whether a statically linked program can dlopen itself... " >&6; } +if ${lt_cv_dlopen_self_static+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test "$cross_compiling" = yes; then : + lt_cv_dlopen_self_static=cross +else + lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2 + lt_status=$lt_dlunknown + cat > conftest.$ac_ext <<_LT_EOF +#line $LINENO "configure" +#include "confdefs.h" + +#if HAVE_DLFCN_H +#include +#endif + +#include + +#ifdef RTLD_GLOBAL +# define LT_DLGLOBAL RTLD_GLOBAL +#else +# ifdef DL_GLOBAL +# define LT_DLGLOBAL DL_GLOBAL +# else +# define LT_DLGLOBAL 0 +# endif +#endif + +/* We may have to define LT_DLLAZY_OR_NOW in the command line if we + find out it does not work in some platform. */ +#ifndef LT_DLLAZY_OR_NOW +# ifdef RTLD_LAZY +# define LT_DLLAZY_OR_NOW RTLD_LAZY +# else +# ifdef DL_LAZY +# define LT_DLLAZY_OR_NOW DL_LAZY +# else +# ifdef RTLD_NOW +# define LT_DLLAZY_OR_NOW RTLD_NOW +# else +# ifdef DL_NOW +# define LT_DLLAZY_OR_NOW DL_NOW +# else +# define LT_DLLAZY_OR_NOW 0 +# endif +# endif +# endif +# endif +#endif + +/* When -fvisbility=hidden is used, assume the code has been annotated + correspondingly for the symbols needed. */ +#if defined(__GNUC__) && (((__GNUC__ == 3) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 3)) +int fnord () __attribute__((visibility("default"))); +#endif + +int fnord () { return 42; } +int main () +{ + void *self = dlopen (0, LT_DLGLOBAL|LT_DLLAZY_OR_NOW); + int status = $lt_dlunknown; + + if (self) + { + if (dlsym (self,"fnord")) status = $lt_dlno_uscore; + else + { + if (dlsym( self,"_fnord")) status = $lt_dlneed_uscore; + else puts (dlerror ()); + } + /* dlclose (self); */ + } + else + puts (dlerror ()); + + return status; +} +_LT_EOF + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5 + (eval $ac_link) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } && test -s conftest${ac_exeext} 2>/dev/null; then + (./conftest; exit; ) >&5 2>/dev/null + lt_status=$? + case x$lt_status in + x$lt_dlno_uscore) lt_cv_dlopen_self_static=yes ;; + x$lt_dlneed_uscore) lt_cv_dlopen_self_static=yes ;; + x$lt_dlunknown|x*) lt_cv_dlopen_self_static=no ;; + esac + else : + # compilation failed + lt_cv_dlopen_self_static=no + fi +fi +rm -fr conftest* + + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_dlopen_self_static" >&5 +$as_echo "$lt_cv_dlopen_self_static" >&6; } + fi + + CPPFLAGS="$save_CPPFLAGS" + LDFLAGS="$save_LDFLAGS" + LIBS="$save_LIBS" + ;; + esac + + case $lt_cv_dlopen_self in + yes|no) enable_dlopen_self=$lt_cv_dlopen_self ;; + *) enable_dlopen_self=unknown ;; + esac + + case $lt_cv_dlopen_self_static in + yes|no) enable_dlopen_self_static=$lt_cv_dlopen_self_static ;; + *) enable_dlopen_self_static=unknown ;; + esac +fi + + + + + + + + + + + + + + + + + +striplib= +old_striplib= +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether stripping libraries is possible" >&5 +$as_echo_n "checking whether stripping libraries is possible... " >&6; } +if test -n "$STRIP" && $STRIP -V 2>&1 | $GREP "GNU strip" >/dev/null; then + test -z "$old_striplib" && old_striplib="$STRIP --strip-debug" + test -z "$striplib" && striplib="$STRIP --strip-unneeded" + { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +$as_echo "yes" >&6; } +else +# FIXME - insert some real tests, host_os isn't really good enough + case $host_os in + darwin*) + if test -n "$STRIP" ; then + striplib="$STRIP -x" + old_striplib="$STRIP -S" + { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +$as_echo "yes" >&6; } + else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } + fi + ;; + *) + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } + ;; + esac +fi + + + + + + + + + + + + + # Report which library types will actually be built + { $as_echo "$as_me:${as_lineno-$LINENO}: checking if libtool supports shared libraries" >&5 +$as_echo_n "checking if libtool supports shared libraries... " >&6; } + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $can_build_shared" >&5 +$as_echo "$can_build_shared" >&6; } + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to build shared libraries" >&5 +$as_echo_n "checking whether to build shared libraries... " >&6; } + test "$can_build_shared" = "no" && enable_shared=no + + # On AIX, shared libraries and static libraries use the same namespace, and + # are all built from PIC. + case $host_os in + aix3*) + test "$enable_shared" = yes && enable_static=no + if test -n "$RANLIB"; then + archive_cmds="$archive_cmds~\$RANLIB \$lib" + postinstall_cmds='$RANLIB $lib' + fi + ;; + + aix[4-9]*) + if test "$host_cpu" != ia64 && test "$aix_use_runtimelinking" = no ; then + test "$enable_shared" = yes && enable_static=no + fi + ;; + esac + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $enable_shared" >&5 +$as_echo "$enable_shared" >&6; } + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to build static libraries" >&5 +$as_echo_n "checking whether to build static libraries... " >&6; } + # Make sure either enable_shared or enable_static is yes. + test "$enable_shared" = yes || enable_static=yes + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $enable_static" >&5 +$as_echo "$enable_static" >&6; } + + + + +fi +ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu + +CC="$lt_save_CC" + + + + + + + + + + + + + + + + ac_config_commands="$ac_config_commands libtool" + + + + +# Only expand once: + + + + + +# Check for C++ compiler and use it to compile the tests. +# +ac_ext=cpp +ac_cpp='$CXXCPP $CPPFLAGS' +ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_cxx_compiler_gnu +if test -z "$CXX"; then + if test -n "$CCC"; then + CXX=$CCC + else + if test -n "$ac_tool_prefix"; then + for ac_prog in g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC + do + # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args. +set dummy $ac_tool_prefix$ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_CXX+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$CXX"; then + ac_cv_prog_CXX="$CXX" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_CXX="$ac_tool_prefix$ac_prog" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +CXX=$ac_cv_prog_CXX +if test -n "$CXX"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXX" >&5 +$as_echo "$CXX" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$CXX" && break + done +fi +if test -z "$CXX"; then + ac_ct_CXX=$CXX + for ac_prog in g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC +do + # Extract the first word of "$ac_prog", so it can be a program name with args. +set dummy $ac_prog; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_ac_ct_CXX+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$ac_ct_CXX"; then + ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_ac_ct_CXX="$ac_prog" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + +fi +fi +ac_ct_CXX=$ac_cv_prog_ac_ct_CXX +if test -n "$ac_ct_CXX"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CXX" >&5 +$as_echo "$ac_ct_CXX" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + test -n "$ac_ct_CXX" && break +done + + if test "x$ac_ct_CXX" = x; then + CXX="g++" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 +$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} +ac_tool_warned=yes ;; +esac + CXX=$ac_ct_CXX + fi +fi + + fi +fi +# Provide some information about the compiler. +$as_echo "$as_me:${as_lineno-$LINENO}: checking for C++ compiler version" >&5 +set X $ac_compile +ac_compiler=$2 +for ac_option in --version -v -V -qversion; do + { { ac_try="$ac_compiler $ac_option >&5" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_compiler $ac_option >&5") 2>conftest.err + ac_status=$? + if test -s conftest.err; then + sed '10a\ +... rest of stderr output deleted ... + 10q' conftest.err >conftest.er1 + cat conftest.er1 >&5 + fi + rm -f conftest.er1 conftest.err + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } +done + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C++ compiler" >&5 +$as_echo_n "checking whether we are using the GNU C++ compiler... " >&6; } +if ${ac_cv_cxx_compiler_gnu+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ +#ifndef __GNUC__ + choke me +#endif + + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_compile "$LINENO"; then : + ac_compiler_gnu=yes +else + ac_compiler_gnu=no +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +ac_cv_cxx_compiler_gnu=$ac_compiler_gnu + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_cxx_compiler_gnu" >&5 +$as_echo "$ac_cv_cxx_compiler_gnu" >&6; } +if test $ac_compiler_gnu = yes; then + GXX=yes +else + GXX= +fi +ac_test_CXXFLAGS=${CXXFLAGS+set} +ac_save_CXXFLAGS=$CXXFLAGS +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CXX accepts -g" >&5 +$as_echo_n "checking whether $CXX accepts -g... " >&6; } +if ${ac_cv_prog_cxx_g+:} false; then : + $as_echo_n "(cached) " >&6 +else + ac_save_cxx_werror_flag=$ac_cxx_werror_flag + ac_cxx_werror_flag=yes + ac_cv_prog_cxx_g=no + CXXFLAGS="-g" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_compile "$LINENO"; then : + ac_cv_prog_cxx_g=yes +else + CXXFLAGS="" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_compile "$LINENO"; then : + +else + ac_cxx_werror_flag=$ac_save_cxx_werror_flag + CXXFLAGS="-g" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_compile "$LINENO"; then : + ac_cv_prog_cxx_g=yes +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext + ac_cxx_werror_flag=$ac_save_cxx_werror_flag +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cxx_g" >&5 +$as_echo "$ac_cv_prog_cxx_g" >&6; } +if test "$ac_test_CXXFLAGS" = set; then + CXXFLAGS=$ac_save_CXXFLAGS +elif test $ac_cv_prog_cxx_g = yes; then + if test "$GXX" = yes; then + CXXFLAGS="-g -O2" + else + CXXFLAGS="-g" + fi +else + if test "$GXX" = yes; then + CXXFLAGS="-O2" + else + CXXFLAGS= + fi +fi +ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu + +depcc="$CXX" am_compiler_list= + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking dependency style of $depcc" >&5 +$as_echo_n "checking dependency style of $depcc... " >&6; } +if ${am_cv_CXX_dependencies_compiler_type+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then + # We make a subdir and do the tests there. Otherwise we can end up + # making bogus files that we don't know about and never remove. For + # instance it was reported that on HP-UX the gcc test will end up + # making a dummy file named 'D' -- because '-MD' means "put the output + # in D". + rm -rf conftest.dir + mkdir conftest.dir + # Copy depcomp to subdir because otherwise we won't find it if we're + # using a relative directory. + cp "$am_depcomp" conftest.dir + cd conftest.dir + # We will build objects and dependencies in a subdirectory because + # it helps to detect inapplicable dependency modes. For instance + # both Tru64's cc and ICC support -MD to output dependencies as a + # side effect of compilation, but ICC will put the dependencies in + # the current directory while Tru64 will put them in the object + # directory. + mkdir sub + + am_cv_CXX_dependencies_compiler_type=none + if test "$am_compiler_list" = ""; then + am_compiler_list=`sed -n 's/^#*\([a-zA-Z0-9]*\))$/\1/p' < ./depcomp` + fi + am__universal=false + case " $depcc " in #( + *\ -arch\ *\ -arch\ *) am__universal=true ;; + esac + + for depmode in $am_compiler_list; do + # Setup a source with many dependencies, because some compilers + # like to wrap large dependency lists on column 80 (with \), and + # we should not choose a depcomp mode which is confused by this. + # + # We need to recreate these files for each test, as the compiler may + # overwrite some of them when testing with obscure command lines. + # This happens at least with the AIX C compiler. + : > sub/conftest.c + for i in 1 2 3 4 5 6; do + echo '#include "conftst'$i'.h"' >> sub/conftest.c + # Using ": > sub/conftst$i.h" creates only sub/conftst1.h with + # Solaris 10 /bin/sh. + echo '/* dummy */' > sub/conftst$i.h + done + echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf + + # We check with '-c' and '-o' for the sake of the "dashmstdout" + # mode. It turns out that the SunPro C++ compiler does not properly + # handle '-M -o', and we need to detect this. Also, some Intel + # versions had trouble with output in subdirs. + am__obj=sub/conftest.${OBJEXT-o} + am__minus_obj="-o $am__obj" + case $depmode in + gcc) + # This depmode causes a compiler race in universal mode. + test "$am__universal" = false || continue + ;; + nosideeffect) + # After this tag, mechanisms are not by side-effect, so they'll + # only be used when explicitly requested. + if test "x$enable_dependency_tracking" = xyes; then + continue + else + break + fi + ;; + msvc7 | msvc7msys | msvisualcpp | msvcmsys) + # This compiler won't grok '-c -o', but also, the minuso test has + # not run yet. These depmodes are late enough in the game, and + # so weak that their functioning should not be impacted. + am__obj=conftest.${OBJEXT-o} + am__minus_obj= + ;; + none) break ;; + esac + if depmode=$depmode \ + source=sub/conftest.c object=$am__obj \ + depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \ + $SHELL ./depcomp $depcc -c $am__minus_obj sub/conftest.c \ + >/dev/null 2>conftest.err && + grep sub/conftst1.h sub/conftest.Po > /dev/null 2>&1 && + grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 && + grep $am__obj sub/conftest.Po > /dev/null 2>&1 && + ${MAKE-make} -s -f confmf > /dev/null 2>&1; then + # icc doesn't choke on unknown options, it will just issue warnings + # or remarks (even with -Werror). So we grep stderr for any message + # that says an option was ignored or not supported. + # When given -MP, icc 7.0 and 7.1 complain thusly: + # icc: Command line warning: ignoring option '-M'; no argument required + # The diagnosis changed in icc 8.0: + # icc: Command line remark: option '-MP' not supported + if (grep 'ignoring option' conftest.err || + grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else + am_cv_CXX_dependencies_compiler_type=$depmode + break + fi + fi + done + + cd .. + rm -rf conftest.dir +else + am_cv_CXX_dependencies_compiler_type=none +fi + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_CXX_dependencies_compiler_type" >&5 +$as_echo "$am_cv_CXX_dependencies_compiler_type" >&6; } +CXXDEPMODE=depmode=$am_cv_CXX_dependencies_compiler_type + + if + test "x$enable_dependency_tracking" != xno \ + && test "$am_cv_CXX_dependencies_compiler_type" = gcc3; then + am__fastdepCXX_TRUE= + am__fastdepCXX_FALSE='#' +else + am__fastdepCXX_TRUE='#' + am__fastdepCXX_FALSE= +fi + + + + +func_stripname_cnf () +{ + case ${2} in + .*) func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%\\\\${2}\$%%"`;; + *) func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%${2}\$%%"`;; + esac +} # func_stripname_cnf + + if test -n "$CXX" && ( test "X$CXX" != "Xno" && + ( (test "X$CXX" = "Xg++" && `g++ -v >/dev/null 2>&1` ) || + (test "X$CXX" != "Xg++"))) ; then + ac_ext=cpp +ac_cpp='$CXXCPP $CPPFLAGS' +ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_cxx_compiler_gnu +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C++ preprocessor" >&5 +$as_echo_n "checking how to run the C++ preprocessor... " >&6; } +if test -z "$CXXCPP"; then + if ${ac_cv_prog_CXXCPP+:} false; then : + $as_echo_n "(cached) " >&6 +else + # Double quotes because CXXCPP needs to be expanded + for CXXCPP in "$CXX -E" "/lib/cpp" + do + ac_preproc_ok=false +for ac_cxx_preproc_warn_flag in '' yes +do + # Use a header file that comes with gcc, so configuring glibc + # with a fresh cross-compiler works. + # Prefer to if __STDC__ is defined, since + # exists even on freestanding compilers. + # On the NeXT, cc -E runs the code through the compiler's parser, + # not just through cpp. "Syntax error" is here to catch this case. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#ifdef __STDC__ +# include +#else +# include +#endif + Syntax error +_ACEOF +if ac_fn_cxx_try_cpp "$LINENO"; then : + +else + # Broken: fails on valid input. +continue +fi +rm -f conftest.err conftest.i conftest.$ac_ext + + # OK, works on sane cases. Now check whether nonexistent headers + # can be detected and how. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +_ACEOF +if ac_fn_cxx_try_cpp "$LINENO"; then : + # Broken: success on invalid input. +continue +else + # Passes both tests. +ac_preproc_ok=: +break +fi +rm -f conftest.err conftest.i conftest.$ac_ext + +done +# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. +rm -f conftest.i conftest.err conftest.$ac_ext +if $ac_preproc_ok; then : + break +fi + + done + ac_cv_prog_CXXCPP=$CXXCPP + +fi + CXXCPP=$ac_cv_prog_CXXCPP +else + ac_cv_prog_CXXCPP=$CXXCPP +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXXCPP" >&5 +$as_echo "$CXXCPP" >&6; } +ac_preproc_ok=false +for ac_cxx_preproc_warn_flag in '' yes +do + # Use a header file that comes with gcc, so configuring glibc + # with a fresh cross-compiler works. + # Prefer to if __STDC__ is defined, since + # exists even on freestanding compilers. + # On the NeXT, cc -E runs the code through the compiler's parser, + # not just through cpp. "Syntax error" is here to catch this case. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#ifdef __STDC__ +# include +#else +# include +#endif + Syntax error +_ACEOF +if ac_fn_cxx_try_cpp "$LINENO"; then : + +else + # Broken: fails on valid input. +continue +fi +rm -f conftest.err conftest.i conftest.$ac_ext + + # OK, works on sane cases. Now check whether nonexistent headers + # can be detected and how. + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +_ACEOF +if ac_fn_cxx_try_cpp "$LINENO"; then : + # Broken: success on invalid input. +continue +else + # Passes both tests. +ac_preproc_ok=: +break +fi +rm -f conftest.err conftest.i conftest.$ac_ext + +done +# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. +rm -f conftest.i conftest.err conftest.$ac_ext +if $ac_preproc_ok; then : + +else + { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 +$as_echo "$as_me: error: in \`$ac_pwd':" >&2;} +as_fn_error $? "C++ preprocessor \"$CXXCPP\" fails sanity check +See \`config.log' for more details" "$LINENO" 5; } +fi + +ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu + +else + _lt_caught_CXX_error=yes +fi + +ac_ext=cpp +ac_cpp='$CXXCPP $CPPFLAGS' +ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_cxx_compiler_gnu + +archive_cmds_need_lc_CXX=no +allow_undefined_flag_CXX= +always_export_symbols_CXX=no +archive_expsym_cmds_CXX= +compiler_needs_object_CXX=no +export_dynamic_flag_spec_CXX= +hardcode_direct_CXX=no +hardcode_direct_absolute_CXX=no +hardcode_libdir_flag_spec_CXX= +hardcode_libdir_separator_CXX= +hardcode_minus_L_CXX=no +hardcode_shlibpath_var_CXX=unsupported +hardcode_automatic_CXX=no +inherit_rpath_CXX=no +module_cmds_CXX= +module_expsym_cmds_CXX= +link_all_deplibs_CXX=unknown +old_archive_cmds_CXX=$old_archive_cmds +reload_flag_CXX=$reload_flag +reload_cmds_CXX=$reload_cmds +no_undefined_flag_CXX= +whole_archive_flag_spec_CXX= +enable_shared_with_static_runtimes_CXX=no + +# Source file extension for C++ test sources. +ac_ext=cpp + +# Object file extension for compiled C++ test sources. +objext=o +objext_CXX=$objext + +# No sense in running all these tests if we already determined that +# the CXX compiler isn't working. Some variables (like enable_shared) +# are currently assumed to apply to all compilers on this platform, +# and will be corrupted by setting them based on a non-working compiler. +if test "$_lt_caught_CXX_error" != yes; then + # Code to be used in simple compile tests + lt_simple_compile_test_code="int some_variable = 0;" + + # Code to be used in simple link tests + lt_simple_link_test_code='int main(int, char *[]) { return(0); }' + + # ltmain only uses $CC for tagged configurations so make sure $CC is set. + + + + + + +# If no C compiler was specified, use CC. +LTCC=${LTCC-"$CC"} + +# If no C compiler flags were specified, use CFLAGS. +LTCFLAGS=${LTCFLAGS-"$CFLAGS"} + +# Allow CC to be a program name with arguments. +compiler=$CC + + + # save warnings/boilerplate of simple test code + ac_outfile=conftest.$ac_objext +echo "$lt_simple_compile_test_code" >conftest.$ac_ext +eval "$ac_compile" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err +_lt_compiler_boilerplate=`cat conftest.err` +$RM conftest* + + ac_outfile=conftest.$ac_objext +echo "$lt_simple_link_test_code" >conftest.$ac_ext +eval "$ac_link" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err +_lt_linker_boilerplate=`cat conftest.err` +$RM -r conftest* + + + # Allow CC to be a program name with arguments. + lt_save_CC=$CC + lt_save_CFLAGS=$CFLAGS + lt_save_LD=$LD + lt_save_GCC=$GCC + GCC=$GXX + lt_save_with_gnu_ld=$with_gnu_ld + lt_save_path_LD=$lt_cv_path_LD + if test -n "${lt_cv_prog_gnu_ldcxx+set}"; then + lt_cv_prog_gnu_ld=$lt_cv_prog_gnu_ldcxx + else + $as_unset lt_cv_prog_gnu_ld + fi + if test -n "${lt_cv_path_LDCXX+set}"; then + lt_cv_path_LD=$lt_cv_path_LDCXX + else + $as_unset lt_cv_path_LD + fi + test -z "${LDCXX+set}" || LD=$LDCXX + CC=${CXX-"c++"} + CFLAGS=$CXXFLAGS + compiler=$CC + compiler_CXX=$CC + for cc_temp in $compiler""; do + case $cc_temp in + compile | *[\\/]compile | ccache | *[\\/]ccache ) ;; + distcc | *[\\/]distcc | purify | *[\\/]purify ) ;; + \-*) ;; + *) break;; + esac +done +cc_basename=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"` + + + if test -n "$compiler"; then + # We don't want -fno-exception when compiling C++ code, so set the + # no_builtin_flag separately + if test "$GXX" = yes; then + lt_prog_compiler_no_builtin_flag_CXX=' -fno-builtin' + else + lt_prog_compiler_no_builtin_flag_CXX= + fi + + if test "$GXX" = yes; then + # Set up default GNU C++ configuration + + + +# Check whether --with-gnu-ld was given. +if test "${with_gnu_ld+set}" = set; then : + withval=$with_gnu_ld; test "$withval" = no || with_gnu_ld=yes +else + with_gnu_ld=no +fi + +ac_prog=ld +if test "$GCC" = yes; then + # Check if gcc -print-prog-name=ld gives a path. + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ld used by $CC" >&5 +$as_echo_n "checking for ld used by $CC... " >&6; } + case $host in + *-*-mingw*) + # gcc leaves a trailing carriage return which upsets mingw + ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;; + *) + ac_prog=`($CC -print-prog-name=ld) 2>&5` ;; + esac + case $ac_prog in + # Accept absolute paths. + [\\/]* | ?:[\\/]*) + re_direlt='/[^/][^/]*/\.\./' + # Canonicalize the pathname of ld + ac_prog=`$ECHO "$ac_prog"| $SED 's%\\\\%/%g'` + while $ECHO "$ac_prog" | $GREP "$re_direlt" > /dev/null 2>&1; do + ac_prog=`$ECHO $ac_prog| $SED "s%$re_direlt%/%"` + done + test -z "$LD" && LD="$ac_prog" + ;; + "") + # If it fails, then pretend we aren't using GCC. + ac_prog=ld + ;; + *) + # If it is relative, then search for the first ld in PATH. + with_gnu_ld=unknown + ;; + esac +elif test "$with_gnu_ld" = yes; then + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GNU ld" >&5 +$as_echo_n "checking for GNU ld... " >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for non-GNU ld" >&5 +$as_echo_n "checking for non-GNU ld... " >&6; } +fi +if ${lt_cv_path_LD+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -z "$LD"; then + lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR + for ac_dir in $PATH; do + IFS="$lt_save_ifs" + test -z "$ac_dir" && ac_dir=. + if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then + lt_cv_path_LD="$ac_dir/$ac_prog" + # Check to see if the program is GNU ld. I'd rather use --version, + # but apparently some variants of GNU ld only accept -v. + # Break only if it was the GNU/non-GNU ld that we prefer. + case `"$lt_cv_path_LD" -v 2>&1 &5 +$as_echo "$LD" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi +test -z "$LD" && as_fn_error $? "no acceptable ld found in \$PATH" "$LINENO" 5 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if the linker ($LD) is GNU ld" >&5 +$as_echo_n "checking if the linker ($LD) is GNU ld... " >&6; } +if ${lt_cv_prog_gnu_ld+:} false; then : + $as_echo_n "(cached) " >&6 +else + # I'd rather use --version here, but apparently some GNU lds only accept -v. +case `$LD -v 2>&1 &5 +$as_echo "$lt_cv_prog_gnu_ld" >&6; } +with_gnu_ld=$lt_cv_prog_gnu_ld + + + + + + + + # Check if GNU C++ uses GNU ld as the underlying linker, since the + # archiving commands below assume that GNU ld is being used. + if test "$with_gnu_ld" = yes; then + archive_cmds_CXX='$CC $pic_flag -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib' + archive_expsym_cmds_CXX='$CC $pic_flag -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + + hardcode_libdir_flag_spec_CXX='${wl}-rpath ${wl}$libdir' + export_dynamic_flag_spec_CXX='${wl}--export-dynamic' + + # If archive_cmds runs LD, not CC, wlarc should be empty + # XXX I think wlarc can be eliminated in ltcf-cxx, but I need to + # investigate it a little bit more. (MM) + wlarc='${wl}' + + # ancient GNU ld didn't support --whole-archive et. al. + if eval "`$CC -print-prog-name=ld` --help 2>&1" | + $GREP 'no-whole-archive' > /dev/null; then + whole_archive_flag_spec_CXX="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive' + else + whole_archive_flag_spec_CXX= + fi + else + with_gnu_ld=no + wlarc= + + # A generic and very simple default shared library creation + # command for GNU C++ for the case where it uses the native + # linker, instead of GNU ld. If possible, this setting should + # overridden to take advantage of the native linker features on + # the platform it is being used on. + archive_cmds_CXX='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $lib' + fi + + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"' + + else + GXX=no + with_gnu_ld=no + wlarc= + fi + + # PORTME: fill in a description of your system's C++ link characteristics + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the $compiler linker ($LD) supports shared libraries" >&5 +$as_echo_n "checking whether the $compiler linker ($LD) supports shared libraries... " >&6; } + ld_shlibs_CXX=yes + case $host_os in + aix3*) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + aix[4-9]*) + if test "$host_cpu" = ia64; then + # On IA64, the linker does run time linking by default, so we don't + # have to do anything special. + aix_use_runtimelinking=no + exp_sym_flag='-Bexport' + no_entry_flag="" + else + aix_use_runtimelinking=no + + # Test if we are trying to use run time linking or normal + # AIX style linking. If -brtl is somewhere in LDFLAGS, we + # need to do runtime linking. + case $host_os in aix4.[23]|aix4.[23].*|aix[5-9]*) + for ld_flag in $LDFLAGS; do + case $ld_flag in + *-brtl*) + aix_use_runtimelinking=yes + break + ;; + esac + done + ;; + esac + + exp_sym_flag='-bexport' + no_entry_flag='-bnoentry' + fi + + # When large executables or shared objects are built, AIX ld can + # have problems creating the table of contents. If linking a library + # or program results in "error TOC overflow" add -mminimal-toc to + # CXXFLAGS/CFLAGS for g++/gcc. In the cases where that is not + # enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS. + + archive_cmds_CXX='' + hardcode_direct_CXX=yes + hardcode_direct_absolute_CXX=yes + hardcode_libdir_separator_CXX=':' + link_all_deplibs_CXX=yes + file_list_spec_CXX='${wl}-f,' + + if test "$GXX" = yes; then + case $host_os in aix4.[012]|aix4.[012].*) + # We only want to do this on AIX 4.2 and lower, the check + # below for broken collect2 doesn't work under 4.3+ + collect2name=`${CC} -print-prog-name=collect2` + if test -f "$collect2name" && + strings "$collect2name" | $GREP resolve_lib_name >/dev/null + then + # We have reworked collect2 + : + else + # We have old collect2 + hardcode_direct_CXX=unsupported + # It fails to find uninstalled libraries when the uninstalled + # path is not listed in the libpath. Setting hardcode_minus_L + # to unsupported forces relinking + hardcode_minus_L_CXX=yes + hardcode_libdir_flag_spec_CXX='-L$libdir' + hardcode_libdir_separator_CXX= + fi + esac + shared_flag='-shared' + if test "$aix_use_runtimelinking" = yes; then + shared_flag="$shared_flag "'${wl}-G' + fi + else + # not using gcc + if test "$host_cpu" = ia64; then + # VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release + # chokes on -Wl,-G. The following line is correct: + shared_flag='-G' + else + if test "$aix_use_runtimelinking" = yes; then + shared_flag='${wl}-G' + else + shared_flag='${wl}-bM:SRE' + fi + fi + fi + + export_dynamic_flag_spec_CXX='${wl}-bexpall' + # It seems that -bexpall does not export symbols beginning with + # underscore (_), so it is better to generate a list of symbols to + # export. + always_export_symbols_CXX=yes + if test "$aix_use_runtimelinking" = yes; then + # Warning - without using the other runtime loading flags (-brtl), + # -berok will link without error, but may produce a broken library. + allow_undefined_flag_CXX='-berok' + # Determine the default libpath from the value encoded in an empty + # executable. + if test "${lt_cv_aix_libpath+set}" = set; then + aix_libpath=$lt_cv_aix_libpath +else + if ${lt_cv_aix_libpath__CXX+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_link "$LINENO"; then : + + lt_aix_libpath_sed=' + /Import File Strings/,/^$/ { + /^0/ { + s/^0 *\([^ ]*\) *$/\1/ + p + } + }' + lt_cv_aix_libpath__CXX=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"` + # Check for a 64-bit object if we didn't find anything. + if test -z "$lt_cv_aix_libpath__CXX"; then + lt_cv_aix_libpath__CXX=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"` + fi +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext + if test -z "$lt_cv_aix_libpath__CXX"; then + lt_cv_aix_libpath__CXX="/usr/lib:/lib" + fi + +fi + + aix_libpath=$lt_cv_aix_libpath__CXX +fi + + hardcode_libdir_flag_spec_CXX='${wl}-blibpath:$libdir:'"$aix_libpath" + + archive_expsym_cmds_CXX='$CC -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then func_echo_all "${wl}${allow_undefined_flag}"; else :; fi` '"\${wl}$exp_sym_flag:\$export_symbols $shared_flag" + else + if test "$host_cpu" = ia64; then + hardcode_libdir_flag_spec_CXX='${wl}-R $libdir:/usr/lib:/lib' + allow_undefined_flag_CXX="-z nodefs" + archive_expsym_cmds_CXX="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$exp_sym_flag:\$export_symbols" + else + # Determine the default libpath from the value encoded in an + # empty executable. + if test "${lt_cv_aix_libpath+set}" = set; then + aix_libpath=$lt_cv_aix_libpath +else + if ${lt_cv_aix_libpath__CXX+:} false; then : + $as_echo_n "(cached) " >&6 +else + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_link "$LINENO"; then : + + lt_aix_libpath_sed=' + /Import File Strings/,/^$/ { + /^0/ { + s/^0 *\([^ ]*\) *$/\1/ + p + } + }' + lt_cv_aix_libpath__CXX=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"` + # Check for a 64-bit object if we didn't find anything. + if test -z "$lt_cv_aix_libpath__CXX"; then + lt_cv_aix_libpath__CXX=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"` + fi +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext + if test -z "$lt_cv_aix_libpath__CXX"; then + lt_cv_aix_libpath__CXX="/usr/lib:/lib" + fi + +fi + + aix_libpath=$lt_cv_aix_libpath__CXX +fi + + hardcode_libdir_flag_spec_CXX='${wl}-blibpath:$libdir:'"$aix_libpath" + # Warning - without using the other run time loading flags, + # -berok will link without error, but may produce a broken library. + no_undefined_flag_CXX=' ${wl}-bernotok' + allow_undefined_flag_CXX=' ${wl}-berok' + if test "$with_gnu_ld" = yes; then + # We only use this code for GNU lds that support --whole-archive. + whole_archive_flag_spec_CXX='${wl}--whole-archive$convenience ${wl}--no-whole-archive' + else + # Exported symbols can be pulled into shared objects from archives + whole_archive_flag_spec_CXX='$convenience' + fi + archive_cmds_need_lc_CXX=yes + # This is similar to how AIX traditionally builds its shared + # libraries. + archive_expsym_cmds_CXX="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs ${wl}-bnoentry $compiler_flags ${wl}-bE:$export_symbols${allow_undefined_flag}~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$soname' + fi + fi + ;; + + beos*) + if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then + allow_undefined_flag_CXX=unsupported + # Joseph Beckenbach says some releases of gcc + # support --undefined. This deserves some investigation. FIXME + archive_cmds_CXX='$CC -nostart $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + else + ld_shlibs_CXX=no + fi + ;; + + chorus*) + case $cc_basename in + *) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + esac + ;; + + cygwin* | mingw* | pw32* | cegcc*) + case $GXX,$cc_basename in + ,cl* | no,cl*) + # Native MSVC + # hardcode_libdir_flag_spec is actually meaningless, as there is + # no search path for DLLs. + hardcode_libdir_flag_spec_CXX=' ' + allow_undefined_flag_CXX=unsupported + always_export_symbols_CXX=yes + file_list_spec_CXX='@' + # Tell ltmain to make .lib files, not .a files. + libext=lib + # Tell ltmain to make .dll files, not .so files. + shrext_cmds=".dll" + # FIXME: Setting linknames here is a bad hack. + archive_cmds_CXX='$CC -o $output_objdir/$soname $libobjs $compiler_flags $deplibs -Wl,-dll~linknames=' + archive_expsym_cmds_CXX='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then + $SED -n -e 's/\\\\\\\(.*\\\\\\\)/-link\\\ -EXPORT:\\\\\\\1/' -e '1\\\!p' < $export_symbols > $output_objdir/$soname.exp; + else + $SED -e 's/\\\\\\\(.*\\\\\\\)/-link\\\ -EXPORT:\\\\\\\1/' < $export_symbols > $output_objdir/$soname.exp; + fi~ + $CC -o $tool_output_objdir$soname $libobjs $compiler_flags $deplibs "@$tool_output_objdir$soname.exp" -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~ + linknames=' + # The linker will not automatically build a static lib if we build a DLL. + # _LT_TAGVAR(old_archive_from_new_cmds, CXX)='true' + enable_shared_with_static_runtimes_CXX=yes + # Don't use ranlib + old_postinstall_cmds_CXX='chmod 644 $oldlib' + postlink_cmds_CXX='lt_outputfile="@OUTPUT@"~ + lt_tool_outputfile="@TOOL_OUTPUT@"~ + case $lt_outputfile in + *.exe|*.EXE) ;; + *) + lt_outputfile="$lt_outputfile.exe" + lt_tool_outputfile="$lt_tool_outputfile.exe" + ;; + esac~ + func_to_tool_file "$lt_outputfile"~ + if test "$MANIFEST_TOOL" != ":" && test -f "$lt_outputfile.manifest"; then + $MANIFEST_TOOL -manifest "$lt_tool_outputfile.manifest" -outputresource:"$lt_tool_outputfile" || exit 1; + $RM "$lt_outputfile.manifest"; + fi' + ;; + *) + # g++ + # _LT_TAGVAR(hardcode_libdir_flag_spec, CXX) is actually meaningless, + # as there is no search path for DLLs. + hardcode_libdir_flag_spec_CXX='-L$libdir' + export_dynamic_flag_spec_CXX='${wl}--export-all-symbols' + allow_undefined_flag_CXX=unsupported + always_export_symbols_CXX=no + enable_shared_with_static_runtimes_CXX=yes + + if $LD --help 2>&1 | $GREP 'auto-import' > /dev/null; then + archive_cmds_CXX='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib' + # If the export-symbols file already is a .def file (1st line + # is EXPORTS), use it as is; otherwise, prepend... + archive_expsym_cmds_CXX='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then + cp $export_symbols $output_objdir/$soname.def; + else + echo EXPORTS > $output_objdir/$soname.def; + cat $export_symbols >> $output_objdir/$soname.def; + fi~ + $CC -shared -nostdlib $output_objdir/$soname.def $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib' + else + ld_shlibs_CXX=no + fi + ;; + esac + ;; + darwin* | rhapsody*) + + + archive_cmds_need_lc_CXX=no + hardcode_direct_CXX=no + hardcode_automatic_CXX=yes + hardcode_shlibpath_var_CXX=unsupported + if test "$lt_cv_ld_force_load" = "yes"; then + whole_archive_flag_spec_CXX='`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience ${wl}-force_load,$conv\"; done; func_echo_all \"$new_convenience\"`' + + else + whole_archive_flag_spec_CXX='' + fi + link_all_deplibs_CXX=yes + allow_undefined_flag_CXX="$_lt_dar_allow_undefined" + case $cc_basename in + ifort*) _lt_dar_can_shared=yes ;; + *) _lt_dar_can_shared=$GCC ;; + esac + if test "$_lt_dar_can_shared" = "yes"; then + output_verbose_link_cmd=func_echo_all + archive_cmds_CXX="\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring $_lt_dar_single_mod${_lt_dsymutil}" + module_cmds_CXX="\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags${_lt_dsymutil}" + archive_expsym_cmds_CXX="sed 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring ${_lt_dar_single_mod}${_lt_dar_export_syms}${_lt_dsymutil}" + module_expsym_cmds_CXX="sed -e 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags${_lt_dar_export_syms}${_lt_dsymutil}" + if test "$lt_cv_apple_cc_single_mod" != "yes"; then + archive_cmds_CXX="\$CC -r -keep_private_externs -nostdlib -o \${lib}-master.o \$libobjs~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \${lib}-master.o \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring${_lt_dsymutil}" + archive_expsym_cmds_CXX="sed 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC -r -keep_private_externs -nostdlib -o \${lib}-master.o \$libobjs~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \${lib}-master.o \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring${_lt_dar_export_syms}${_lt_dsymutil}" + fi + + else + ld_shlibs_CXX=no + fi + + ;; + + dgux*) + case $cc_basename in + ec++*) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + ghcx*) + # Green Hills C++ Compiler + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + *) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + esac + ;; + + freebsd2.*) + # C++ shared libraries reported to be fairly broken before + # switch to ELF + ld_shlibs_CXX=no + ;; + + freebsd-elf*) + archive_cmds_need_lc_CXX=no + ;; + + freebsd* | dragonfly*) + # FreeBSD 3 and later use GNU C++ and GNU ld with standard ELF + # conventions + ld_shlibs_CXX=yes + ;; + + haiku*) + archive_cmds_CXX='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + link_all_deplibs_CXX=yes + ;; + + hpux9*) + hardcode_libdir_flag_spec_CXX='${wl}+b ${wl}$libdir' + hardcode_libdir_separator_CXX=: + export_dynamic_flag_spec_CXX='${wl}-E' + hardcode_direct_CXX=yes + hardcode_minus_L_CXX=yes # Not in the search PATH, + # but as the default + # location of the library. + + case $cc_basename in + CC*) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + aCC*) + archive_cmds_CXX='$RM $output_objdir/$soname~$CC -b ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib' + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + # + # There doesn't appear to be a way to prevent this compiler from + # explicitly linking system object files so we need to strip them + # from the output so that they don't get included in the library + # dependencies. + output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | $EGREP "\-L"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"' + ;; + *) + if test "$GXX" = yes; then + archive_cmds_CXX='$RM $output_objdir/$soname~$CC -shared -nostdlib $pic_flag ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib' + else + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + fi + ;; + esac + ;; + + hpux10*|hpux11*) + if test $with_gnu_ld = no; then + hardcode_libdir_flag_spec_CXX='${wl}+b ${wl}$libdir' + hardcode_libdir_separator_CXX=: + + case $host_cpu in + hppa*64*|ia64*) + ;; + *) + export_dynamic_flag_spec_CXX='${wl}-E' + ;; + esac + fi + case $host_cpu in + hppa*64*|ia64*) + hardcode_direct_CXX=no + hardcode_shlibpath_var_CXX=no + ;; + *) + hardcode_direct_CXX=yes + hardcode_direct_absolute_CXX=yes + hardcode_minus_L_CXX=yes # Not in the search PATH, + # but as the default + # location of the library. + ;; + esac + + case $cc_basename in + CC*) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + aCC*) + case $host_cpu in + hppa*64*) + archive_cmds_CXX='$CC -b ${wl}+h ${wl}$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' + ;; + ia64*) + archive_cmds_CXX='$CC -b ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' + ;; + *) + archive_cmds_CXX='$CC -b ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' + ;; + esac + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + # + # There doesn't appear to be a way to prevent this compiler from + # explicitly linking system object files so we need to strip them + # from the output so that they don't get included in the library + # dependencies. + output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | $GREP "\-L"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"' + ;; + *) + if test "$GXX" = yes; then + if test $with_gnu_ld = no; then + case $host_cpu in + hppa*64*) + archive_cmds_CXX='$CC -shared -nostdlib -fPIC ${wl}+h ${wl}$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' + ;; + ia64*) + archive_cmds_CXX='$CC -shared -nostdlib $pic_flag ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' + ;; + *) + archive_cmds_CXX='$CC -shared -nostdlib $pic_flag ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' + ;; + esac + fi + else + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + fi + ;; + esac + ;; + + interix[3-9]*) + hardcode_direct_CXX=no + hardcode_shlibpath_var_CXX=no + hardcode_libdir_flag_spec_CXX='${wl}-rpath,$libdir' + export_dynamic_flag_spec_CXX='${wl}-E' + # Hack: On Interix 3.x, we cannot compile PIC because of a broken gcc. + # Instead, shared libraries are loaded at an image base (0x10000000 by + # default) and relocated if they conflict, which is a slow very memory + # consuming and fragmenting process. To avoid this, we pick a random, + # 256 KiB-aligned image base between 0x50000000 and 0x6FFC0000 at link + # time. Moving up from 0x10000000 also allows more sbrk(2) space. + archive_cmds_CXX='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib' + archive_expsym_cmds_CXX='sed "s,^,_," $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--retain-symbols-file,$output_objdir/$soname.expsym ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib' + ;; + irix5* | irix6*) + case $cc_basename in + CC*) + # SGI C++ + archive_cmds_CXX='$CC -shared -all -multigot $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib' + + # Archives containing C++ object files must be created using + # "CC -ar", where "CC" is the IRIX C++ compiler. This is + # necessary to make sure instantiated templates are included + # in the archive. + old_archive_cmds_CXX='$CC -ar -WR,-u -o $oldlib $oldobjs' + ;; + *) + if test "$GXX" = yes; then + if test "$with_gnu_ld" = no; then + archive_cmds_CXX='$CC -shared $pic_flag -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' + else + archive_cmds_CXX='$CC -shared $pic_flag -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` -o $lib' + fi + fi + link_all_deplibs_CXX=yes + ;; + esac + hardcode_libdir_flag_spec_CXX='${wl}-rpath ${wl}$libdir' + hardcode_libdir_separator_CXX=: + inherit_rpath_CXX=yes + ;; + + linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*) + case $cc_basename in + KCC*) + # Kuck and Associates, Inc. (KAI) C++ Compiler + + # KCC will only create a shared library if the output file + # ends with ".so" (or ".sl" for HP-UX), so rename the library + # to its proper name (with version) after linking. + archive_cmds_CXX='tempext=`echo $shared_ext | $SED -e '\''s/\([^()0-9A-Za-z{}]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib' + archive_expsym_cmds_CXX='tempext=`echo $shared_ext | $SED -e '\''s/\([^()0-9A-Za-z{}]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib ${wl}-retain-symbols-file,$export_symbols; mv \$templib $lib' + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + # + # There doesn't appear to be a way to prevent this compiler from + # explicitly linking system object files so we need to strip them + # from the output so that they don't get included in the library + # dependencies. + output_verbose_link_cmd='templist=`$CC $CFLAGS -v conftest.$objext -o libconftest$shared_ext 2>&1 | $GREP "ld"`; rm -f libconftest$shared_ext; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"' + + hardcode_libdir_flag_spec_CXX='${wl}-rpath,$libdir' + export_dynamic_flag_spec_CXX='${wl}--export-dynamic' + + # Archives containing C++ object files must be created using + # "CC -Bstatic", where "CC" is the KAI C++ compiler. + old_archive_cmds_CXX='$CC -Bstatic -o $oldlib $oldobjs' + ;; + icpc* | ecpc* ) + # Intel C++ + with_gnu_ld=yes + # version 8.0 and above of icpc choke on multiply defined symbols + # if we add $predep_objects and $postdep_objects, however 7.1 and + # earlier do not add the objects themselves. + case `$CC -V 2>&1` in + *"Version 7."*) + archive_cmds_CXX='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib' + archive_expsym_cmds_CXX='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + ;; + *) # Version 8.0 or newer + tmp_idyn= + case $host_cpu in + ia64*) tmp_idyn=' -i_dynamic';; + esac + archive_cmds_CXX='$CC -shared'"$tmp_idyn"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + archive_expsym_cmds_CXX='$CC -shared'"$tmp_idyn"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + ;; + esac + archive_cmds_need_lc_CXX=no + hardcode_libdir_flag_spec_CXX='${wl}-rpath,$libdir' + export_dynamic_flag_spec_CXX='${wl}--export-dynamic' + whole_archive_flag_spec_CXX='${wl}--whole-archive$convenience ${wl}--no-whole-archive' + ;; + pgCC* | pgcpp*) + # Portland Group C++ compiler + case `$CC -V` in + *pgCC\ [1-5].* | *pgcpp\ [1-5].*) + prelink_cmds_CXX='tpldir=Template.dir~ + rm -rf $tpldir~ + $CC --prelink_objects --instantiation_dir $tpldir $objs $libobjs $compile_deplibs~ + compile_command="$compile_command `find $tpldir -name \*.o | sort | $NL2SP`"' + old_archive_cmds_CXX='tpldir=Template.dir~ + rm -rf $tpldir~ + $CC --prelink_objects --instantiation_dir $tpldir $oldobjs$old_deplibs~ + $AR $AR_FLAGS $oldlib$oldobjs$old_deplibs `find $tpldir -name \*.o | sort | $NL2SP`~ + $RANLIB $oldlib' + archive_cmds_CXX='tpldir=Template.dir~ + rm -rf $tpldir~ + $CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~ + $CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | sort | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib' + archive_expsym_cmds_CXX='tpldir=Template.dir~ + rm -rf $tpldir~ + $CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~ + $CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | sort | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname ${wl}-retain-symbols-file ${wl}$export_symbols -o $lib' + ;; + *) # Version 6 and above use weak symbols + archive_cmds_CXX='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib' + archive_expsym_cmds_CXX='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname ${wl}-retain-symbols-file ${wl}$export_symbols -o $lib' + ;; + esac + + hardcode_libdir_flag_spec_CXX='${wl}--rpath ${wl}$libdir' + export_dynamic_flag_spec_CXX='${wl}--export-dynamic' + whole_archive_flag_spec_CXX='${wl}--whole-archive`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive' + ;; + cxx*) + # Compaq C++ + archive_cmds_CXX='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib' + archive_expsym_cmds_CXX='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib ${wl}-retain-symbols-file $wl$export_symbols' + + runpath_var=LD_RUN_PATH + hardcode_libdir_flag_spec_CXX='-rpath $libdir' + hardcode_libdir_separator_CXX=: + + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + # + # There doesn't appear to be a way to prevent this compiler from + # explicitly linking system object files so we need to strip them + # from the output so that they don't get included in the library + # dependencies. + output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "ld"`; templist=`func_echo_all "$templist" | $SED "s/\(^.*ld.*\)\( .*ld .*$\)/\1/"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "X$list" | $Xsed' + ;; + xl* | mpixl* | bgxl*) + # IBM XL 8.0 on PPC, with GNU ld + hardcode_libdir_flag_spec_CXX='${wl}-rpath ${wl}$libdir' + export_dynamic_flag_spec_CXX='${wl}--export-dynamic' + archive_cmds_CXX='$CC -qmkshrobj $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + if test "x$supports_anon_versioning" = xyes; then + archive_expsym_cmds_CXX='echo "{ global:" > $output_objdir/$libname.ver~ + cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~ + echo "local: *; };" >> $output_objdir/$libname.ver~ + $CC -qmkshrobj $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-version-script ${wl}$output_objdir/$libname.ver -o $lib' + fi + ;; + *) + case `$CC -V 2>&1 | sed 5q` in + *Sun\ C*) + # Sun C++ 5.9 + no_undefined_flag_CXX=' -zdefs' + archive_cmds_CXX='$CC -G${allow_undefined_flag} -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' + archive_expsym_cmds_CXX='$CC -G${allow_undefined_flag} -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-retain-symbols-file ${wl}$export_symbols' + hardcode_libdir_flag_spec_CXX='-R$libdir' + whole_archive_flag_spec_CXX='${wl}--whole-archive`new_convenience=; for conv in $convenience\"\"; do test -z \"$conv\" || new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive' + compiler_needs_object_CXX=yes + + # Not sure whether something based on + # $CC $CFLAGS -v conftest.$objext -o libconftest$shared_ext 2>&1 + # would be better. + output_verbose_link_cmd='func_echo_all' + + # Archives containing C++ object files must be created using + # "CC -xar", where "CC" is the Sun C++ compiler. This is + # necessary to make sure instantiated templates are included + # in the archive. + old_archive_cmds_CXX='$CC -xar -o $oldlib $oldobjs' + ;; + esac + ;; + esac + ;; + + lynxos*) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + + m88k*) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + + mvs*) + case $cc_basename in + cxx*) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + *) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + esac + ;; + + netbsd*) + if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then + archive_cmds_CXX='$LD -Bshareable -o $lib $predep_objects $libobjs $deplibs $postdep_objects $linker_flags' + wlarc= + hardcode_libdir_flag_spec_CXX='-R$libdir' + hardcode_direct_CXX=yes + hardcode_shlibpath_var_CXX=no + fi + # Workaround some broken pre-1.5 toolchains + output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP conftest.$objext | $SED -e "s:-lgcc -lc -lgcc::"' + ;; + + *nto* | *qnx*) + ld_shlibs_CXX=yes + ;; + + openbsd2*) + # C++ shared libraries are fairly broken + ld_shlibs_CXX=no + ;; + + openbsd*) + if test -f /usr/libexec/ld.so; then + hardcode_direct_CXX=yes + hardcode_shlibpath_var_CXX=no + hardcode_direct_absolute_CXX=yes + archive_cmds_CXX='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $lib' + hardcode_libdir_flag_spec_CXX='${wl}-rpath,$libdir' + if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then + archive_expsym_cmds_CXX='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-retain-symbols-file,$export_symbols -o $lib' + export_dynamic_flag_spec_CXX='${wl}-E' + whole_archive_flag_spec_CXX="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive' + fi + output_verbose_link_cmd=func_echo_all + else + ld_shlibs_CXX=no + fi + ;; + + osf3* | osf4* | osf5*) + case $cc_basename in + KCC*) + # Kuck and Associates, Inc. (KAI) C++ Compiler + + # KCC will only create a shared library if the output file + # ends with ".so" (or ".sl" for HP-UX), so rename the library + # to its proper name (with version) after linking. + archive_cmds_CXX='tempext=`echo $shared_ext | $SED -e '\''s/\([^()0-9A-Za-z{}]\)/\\\\\1/g'\''`; templib=`echo "$lib" | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib' + + hardcode_libdir_flag_spec_CXX='${wl}-rpath,$libdir' + hardcode_libdir_separator_CXX=: + + # Archives containing C++ object files must be created using + # the KAI C++ compiler. + case $host in + osf3*) old_archive_cmds_CXX='$CC -Bstatic -o $oldlib $oldobjs' ;; + *) old_archive_cmds_CXX='$CC -o $oldlib $oldobjs' ;; + esac + ;; + RCC*) + # Rational C++ 2.4.1 + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + cxx*) + case $host in + osf3*) + allow_undefined_flag_CXX=' ${wl}-expect_unresolved ${wl}\*' + archive_cmds_CXX='$CC -shared${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $soname `test -n "$verstring" && func_echo_all "${wl}-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib' + hardcode_libdir_flag_spec_CXX='${wl}-rpath ${wl}$libdir' + ;; + *) + allow_undefined_flag_CXX=' -expect_unresolved \*' + archive_cmds_CXX='$CC -shared${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib' + archive_expsym_cmds_CXX='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done~ + echo "-hidden">> $lib.exp~ + $CC -shared$allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname ${wl}-input ${wl}$lib.exp `test -n "$verstring" && $ECHO "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib~ + $RM $lib.exp' + hardcode_libdir_flag_spec_CXX='-rpath $libdir' + ;; + esac + + hardcode_libdir_separator_CXX=: + + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + # + # There doesn't appear to be a way to prevent this compiler from + # explicitly linking system object files so we need to strip them + # from the output so that they don't get included in the library + # dependencies. + output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "ld" | $GREP -v "ld:"`; templist=`func_echo_all "$templist" | $SED "s/\(^.*ld.*\)\( .*ld.*$\)/\1/"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"' + ;; + *) + if test "$GXX" = yes && test "$with_gnu_ld" = no; then + allow_undefined_flag_CXX=' ${wl}-expect_unresolved ${wl}\*' + case $host in + osf3*) + archive_cmds_CXX='$CC -shared -nostdlib ${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' + ;; + *) + archive_cmds_CXX='$CC -shared $pic_flag -nostdlib ${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-msym ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' + ;; + esac + + hardcode_libdir_flag_spec_CXX='${wl}-rpath ${wl}$libdir' + hardcode_libdir_separator_CXX=: + + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"' + + else + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + fi + ;; + esac + ;; + + psos*) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + + sunos4*) + case $cc_basename in + CC*) + # Sun C++ 4.x + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + lcc*) + # Lucid + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + *) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + esac + ;; + + solaris*) + case $cc_basename in + CC* | sunCC*) + # Sun C++ 4.2, 5.x and Centerline C++ + archive_cmds_need_lc_CXX=yes + no_undefined_flag_CXX=' -zdefs' + archive_cmds_CXX='$CC -G${allow_undefined_flag} -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' + archive_expsym_cmds_CXX='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~ + $CC -G${allow_undefined_flag} ${wl}-M ${wl}$lib.exp -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp' + + hardcode_libdir_flag_spec_CXX='-R$libdir' + hardcode_shlibpath_var_CXX=no + case $host_os in + solaris2.[0-5] | solaris2.[0-5].*) ;; + *) + # The compiler driver will combine and reorder linker options, + # but understands `-z linker_flag'. + # Supported since Solaris 2.6 (maybe 2.5.1?) + whole_archive_flag_spec_CXX='-z allextract$convenience -z defaultextract' + ;; + esac + link_all_deplibs_CXX=yes + + output_verbose_link_cmd='func_echo_all' + + # Archives containing C++ object files must be created using + # "CC -xar", where "CC" is the Sun C++ compiler. This is + # necessary to make sure instantiated templates are included + # in the archive. + old_archive_cmds_CXX='$CC -xar -o $oldlib $oldobjs' + ;; + gcx*) + # Green Hills C++ Compiler + archive_cmds_CXX='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib' + + # The C++ compiler must be used to create the archive. + old_archive_cmds_CXX='$CC $LDFLAGS -archive -o $oldlib $oldobjs' + ;; + *) + # GNU C++ compiler with Solaris linker + if test "$GXX" = yes && test "$with_gnu_ld" = no; then + no_undefined_flag_CXX=' ${wl}-z ${wl}defs' + if $CC --version | $GREP -v '^2\.7' > /dev/null; then + archive_cmds_CXX='$CC -shared $pic_flag -nostdlib $LDFLAGS $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib' + archive_expsym_cmds_CXX='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~ + $CC -shared $pic_flag -nostdlib ${wl}-M $wl$lib.exp -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp' + + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"' + else + # g++ 2.7 appears to require `-G' NOT `-shared' on this + # platform. + archive_cmds_CXX='$CC -G -nostdlib $LDFLAGS $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib' + archive_expsym_cmds_CXX='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~ + $CC -G -nostdlib ${wl}-M $wl$lib.exp -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp' + + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + output_verbose_link_cmd='$CC -G $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"' + fi + + hardcode_libdir_flag_spec_CXX='${wl}-R $wl$libdir' + case $host_os in + solaris2.[0-5] | solaris2.[0-5].*) ;; + *) + whole_archive_flag_spec_CXX='${wl}-z ${wl}allextract$convenience ${wl}-z ${wl}defaultextract' + ;; + esac + fi + ;; + esac + ;; + + sysv4*uw2* | sysv5OpenUNIX* | sysv5UnixWare7.[01].[10]* | unixware7* | sco3.2v5.0.[024]*) + no_undefined_flag_CXX='${wl}-z,text' + archive_cmds_need_lc_CXX=no + hardcode_shlibpath_var_CXX=no + runpath_var='LD_RUN_PATH' + + case $cc_basename in + CC*) + archive_cmds_CXX='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + archive_expsym_cmds_CXX='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + ;; + *) + archive_cmds_CXX='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + archive_expsym_cmds_CXX='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + ;; + esac + ;; + + sysv5* | sco3.2v5* | sco5v6*) + # Note: We can NOT use -z defs as we might desire, because we do not + # link with -lc, and that would cause any symbols used from libc to + # always be unresolved, which means just about no library would + # ever link correctly. If we're not using GNU ld we use -z text + # though, which does catch some bad symbols but isn't as heavy-handed + # as -z defs. + no_undefined_flag_CXX='${wl}-z,text' + allow_undefined_flag_CXX='${wl}-z,nodefs' + archive_cmds_need_lc_CXX=no + hardcode_shlibpath_var_CXX=no + hardcode_libdir_flag_spec_CXX='${wl}-R,$libdir' + hardcode_libdir_separator_CXX=':' + link_all_deplibs_CXX=yes + export_dynamic_flag_spec_CXX='${wl}-Bexport' + runpath_var='LD_RUN_PATH' + + case $cc_basename in + CC*) + archive_cmds_CXX='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + archive_expsym_cmds_CXX='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + old_archive_cmds_CXX='$CC -Tprelink_objects $oldobjs~ + '"$old_archive_cmds_CXX" + reload_cmds_CXX='$CC -Tprelink_objects $reload_objs~ + '"$reload_cmds_CXX" + ;; + *) + archive_cmds_CXX='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + archive_expsym_cmds_CXX='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + ;; + esac + ;; + + tandem*) + case $cc_basename in + NCC*) + # NonStop-UX NCC 3.20 + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + *) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + esac + ;; + + vxworks*) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + + *) + # FIXME: insert proper C++ library support + ld_shlibs_CXX=no + ;; + esac + + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ld_shlibs_CXX" >&5 +$as_echo "$ld_shlibs_CXX" >&6; } + test "$ld_shlibs_CXX" = no && can_build_shared=no + + GCC_CXX="$GXX" + LD_CXX="$LD" + + ## CAVEAT EMPTOR: + ## There is no encapsulation within the following macros, do not change + ## the running order or otherwise move them around unless you know exactly + ## what you are doing... + # Dependencies to place before and after the object being linked: +predep_objects_CXX= +postdep_objects_CXX= +predeps_CXX= +postdeps_CXX= +compiler_lib_search_path_CXX= + +cat > conftest.$ac_ext <<_LT_EOF +class Foo +{ +public: + Foo (void) { a = 0; } +private: + int a; +}; +_LT_EOF + + +_lt_libdeps_save_CFLAGS=$CFLAGS +case "$CC $CFLAGS " in #( +*\ -flto*\ *) CFLAGS="$CFLAGS -fno-lto" ;; +*\ -fwhopr*\ *) CFLAGS="$CFLAGS -fno-whopr" ;; +*\ -fuse-linker-plugin*\ *) CFLAGS="$CFLAGS -fno-use-linker-plugin" ;; +esac + +if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 + (eval $ac_compile) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then + # Parse the compiler output and extract the necessary + # objects, libraries and library flags. + + # Sentinel used to keep track of whether or not we are before + # the conftest object file. + pre_test_object_deps_done=no + + for p in `eval "$output_verbose_link_cmd"`; do + case ${prev}${p} in + + -L* | -R* | -l*) + # Some compilers place space between "-{L,R}" and the path. + # Remove the space. + if test $p = "-L" || + test $p = "-R"; then + prev=$p + continue + fi + + # Expand the sysroot to ease extracting the directories later. + if test -z "$prev"; then + case $p in + -L*) func_stripname_cnf '-L' '' "$p"; prev=-L; p=$func_stripname_result ;; + -R*) func_stripname_cnf '-R' '' "$p"; prev=-R; p=$func_stripname_result ;; + -l*) func_stripname_cnf '-l' '' "$p"; prev=-l; p=$func_stripname_result ;; + esac + fi + case $p in + =*) func_stripname_cnf '=' '' "$p"; p=$lt_sysroot$func_stripname_result ;; + esac + if test "$pre_test_object_deps_done" = no; then + case ${prev} in + -L | -R) + # Internal compiler library paths should come after those + # provided the user. The postdeps already come after the + # user supplied libs so there is no need to process them. + if test -z "$compiler_lib_search_path_CXX"; then + compiler_lib_search_path_CXX="${prev}${p}" + else + compiler_lib_search_path_CXX="${compiler_lib_search_path_CXX} ${prev}${p}" + fi + ;; + # The "-l" case would never come before the object being + # linked, so don't bother handling this case. + esac + else + if test -z "$postdeps_CXX"; then + postdeps_CXX="${prev}${p}" + else + postdeps_CXX="${postdeps_CXX} ${prev}${p}" + fi + fi + prev= + ;; + + *.lto.$objext) ;; # Ignore GCC LTO objects + *.$objext) + # This assumes that the test object file only shows up + # once in the compiler output. + if test "$p" = "conftest.$objext"; then + pre_test_object_deps_done=yes + continue + fi + + if test "$pre_test_object_deps_done" = no; then + if test -z "$predep_objects_CXX"; then + predep_objects_CXX="$p" + else + predep_objects_CXX="$predep_objects_CXX $p" + fi + else + if test -z "$postdep_objects_CXX"; then + postdep_objects_CXX="$p" + else + postdep_objects_CXX="$postdep_objects_CXX $p" + fi + fi + ;; + + *) ;; # Ignore the rest. + + esac + done + + # Clean up. + rm -f a.out a.exe +else + echo "libtool.m4: error: problem compiling CXX test program" +fi + +$RM -f confest.$objext +CFLAGS=$_lt_libdeps_save_CFLAGS + +# PORTME: override above test on systems where it is broken +case $host_os in +interix[3-9]*) + # Interix 3.5 installs completely hosed .la files for C++, so rather than + # hack all around it, let's just trust "g++" to DTRT. + predep_objects_CXX= + postdep_objects_CXX= + postdeps_CXX= + ;; + +linux*) + case `$CC -V 2>&1 | sed 5q` in + *Sun\ C*) + # Sun C++ 5.9 + + # The more standards-conforming stlport4 library is + # incompatible with the Cstd library. Avoid specifying + # it if it's in CXXFLAGS. Ignore libCrun as + # -library=stlport4 depends on it. + case " $CXX $CXXFLAGS " in + *" -library=stlport4 "*) + solaris_use_stlport4=yes + ;; + esac + + if test "$solaris_use_stlport4" != yes; then + postdeps_CXX='-library=Cstd -library=Crun' + fi + ;; + esac + ;; + +solaris*) + case $cc_basename in + CC* | sunCC*) + # The more standards-conforming stlport4 library is + # incompatible with the Cstd library. Avoid specifying + # it if it's in CXXFLAGS. Ignore libCrun as + # -library=stlport4 depends on it. + case " $CXX $CXXFLAGS " in + *" -library=stlport4 "*) + solaris_use_stlport4=yes + ;; + esac + + # Adding this requires a known-good setup of shared libraries for + # Sun compiler versions before 5.6, else PIC objects from an old + # archive will be linked into the output, leading to subtle bugs. + if test "$solaris_use_stlport4" != yes; then + postdeps_CXX='-library=Cstd -library=Crun' + fi + ;; + esac + ;; +esac + + +case " $postdeps_CXX " in +*" -lc "*) archive_cmds_need_lc_CXX=no ;; +esac + compiler_lib_search_dirs_CXX= +if test -n "${compiler_lib_search_path_CXX}"; then + compiler_lib_search_dirs_CXX=`echo " ${compiler_lib_search_path_CXX}" | ${SED} -e 's! -L! !g' -e 's!^ !!'` +fi + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + lt_prog_compiler_wl_CXX= +lt_prog_compiler_pic_CXX= +lt_prog_compiler_static_CXX= + + + # C++ specific cases for pic, static, wl, etc. + if test "$GXX" = yes; then + lt_prog_compiler_wl_CXX='-Wl,' + lt_prog_compiler_static_CXX='-static' + + case $host_os in + aix*) + # All AIX code is PIC. + if test "$host_cpu" = ia64; then + # AIX 5 now supports IA64 processor + lt_prog_compiler_static_CXX='-Bstatic' + fi + ;; + + amigaos*) + case $host_cpu in + powerpc) + # see comment about AmigaOS4 .so support + lt_prog_compiler_pic_CXX='-fPIC' + ;; + m68k) + # FIXME: we need at least 68020 code to build shared libraries, but + # adding the `-m68020' flag to GCC prevents building anything better, + # like `-m68040'. + lt_prog_compiler_pic_CXX='-m68020 -resident32 -malways-restore-a4' + ;; + esac + ;; + + beos* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*) + # PIC is the default for these OSes. + ;; + mingw* | cygwin* | os2* | pw32* | cegcc*) + # This hack is so that the source file can tell whether it is being + # built for inclusion in a dll (and should export symbols for example). + # Although the cygwin gcc ignores -fPIC, still need this for old-style + # (--disable-auto-import) libraries + lt_prog_compiler_pic_CXX='-DDLL_EXPORT' + ;; + darwin* | rhapsody*) + # PIC is the default on this platform + # Common symbols not allowed in MH_DYLIB files + lt_prog_compiler_pic_CXX='-fno-common' + ;; + *djgpp*) + # DJGPP does not support shared libraries at all + lt_prog_compiler_pic_CXX= + ;; + haiku*) + # PIC is the default for Haiku. + # The "-static" flag exists, but is broken. + lt_prog_compiler_static_CXX= + ;; + interix[3-9]*) + # Interix 3.x gcc -fpic/-fPIC options generate broken code. + # Instead, we relocate shared libraries at runtime. + ;; + sysv4*MP*) + if test -d /usr/nec; then + lt_prog_compiler_pic_CXX=-Kconform_pic + fi + ;; + hpux*) + # PIC is the default for 64-bit PA HP-UX, but not for 32-bit + # PA HP-UX. On IA64 HP-UX, PIC is the default but the pic flag + # sets the default TLS model and affects inlining. + case $host_cpu in + hppa*64*) + ;; + *) + lt_prog_compiler_pic_CXX='-fPIC' + ;; + esac + ;; + *qnx* | *nto*) + # QNX uses GNU C++, but need to define -shared option too, otherwise + # it will coredump. + lt_prog_compiler_pic_CXX='-fPIC -shared' + ;; + *) + lt_prog_compiler_pic_CXX='-fPIC' + ;; + esac + else + case $host_os in + aix[4-9]*) + # All AIX code is PIC. + if test "$host_cpu" = ia64; then + # AIX 5 now supports IA64 processor + lt_prog_compiler_static_CXX='-Bstatic' + else + lt_prog_compiler_static_CXX='-bnso -bI:/lib/syscalls.exp' + fi + ;; + chorus*) + case $cc_basename in + cxch68*) + # Green Hills C++ Compiler + # _LT_TAGVAR(lt_prog_compiler_static, CXX)="--no_auto_instantiation -u __main -u __premain -u _abort -r $COOL_DIR/lib/libOrb.a $MVME_DIR/lib/CC/libC.a $MVME_DIR/lib/classix/libcx.s.a" + ;; + esac + ;; + mingw* | cygwin* | os2* | pw32* | cegcc*) + # This hack is so that the source file can tell whether it is being + # built for inclusion in a dll (and should export symbols for example). + lt_prog_compiler_pic_CXX='-DDLL_EXPORT' + ;; + dgux*) + case $cc_basename in + ec++*) + lt_prog_compiler_pic_CXX='-KPIC' + ;; + ghcx*) + # Green Hills C++ Compiler + lt_prog_compiler_pic_CXX='-pic' + ;; + *) + ;; + esac + ;; + freebsd* | dragonfly*) + # FreeBSD uses GNU C++ + ;; + hpux9* | hpux10* | hpux11*) + case $cc_basename in + CC*) + lt_prog_compiler_wl_CXX='-Wl,' + lt_prog_compiler_static_CXX='${wl}-a ${wl}archive' + if test "$host_cpu" != ia64; then + lt_prog_compiler_pic_CXX='+Z' + fi + ;; + aCC*) + lt_prog_compiler_wl_CXX='-Wl,' + lt_prog_compiler_static_CXX='${wl}-a ${wl}archive' + case $host_cpu in + hppa*64*|ia64*) + # +Z the default + ;; + *) + lt_prog_compiler_pic_CXX='+Z' + ;; + esac + ;; + *) + ;; + esac + ;; + interix*) + # This is c89, which is MS Visual C++ (no shared libs) + # Anyone wants to do a port? + ;; + irix5* | irix6* | nonstopux*) + case $cc_basename in + CC*) + lt_prog_compiler_wl_CXX='-Wl,' + lt_prog_compiler_static_CXX='-non_shared' + # CC pic flag -KPIC is the default. + ;; + *) + ;; + esac + ;; + linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*) + case $cc_basename in + KCC*) + # KAI C++ Compiler + lt_prog_compiler_wl_CXX='--backend -Wl,' + lt_prog_compiler_pic_CXX='-fPIC' + ;; + ecpc* ) + # old Intel C++ for x86_64 which still supported -KPIC. + lt_prog_compiler_wl_CXX='-Wl,' + lt_prog_compiler_pic_CXX='-KPIC' + lt_prog_compiler_static_CXX='-static' + ;; + icpc* ) + # Intel C++, used to be incompatible with GCC. + # ICC 10 doesn't accept -KPIC any more. + lt_prog_compiler_wl_CXX='-Wl,' + lt_prog_compiler_pic_CXX='-fPIC' + lt_prog_compiler_static_CXX='-static' + ;; + pgCC* | pgcpp*) + # Portland Group C++ compiler + lt_prog_compiler_wl_CXX='-Wl,' + lt_prog_compiler_pic_CXX='-fpic' + lt_prog_compiler_static_CXX='-Bstatic' + ;; + cxx*) + # Compaq C++ + # Make sure the PIC flag is empty. It appears that all Alpha + # Linux and Compaq Tru64 Unix objects are PIC. + lt_prog_compiler_pic_CXX= + lt_prog_compiler_static_CXX='-non_shared' + ;; + xlc* | xlC* | bgxl[cC]* | mpixl[cC]*) + # IBM XL 8.0, 9.0 on PPC and BlueGene + lt_prog_compiler_wl_CXX='-Wl,' + lt_prog_compiler_pic_CXX='-qpic' + lt_prog_compiler_static_CXX='-qstaticlink' + ;; + *) + case `$CC -V 2>&1 | sed 5q` in + *Sun\ C*) + # Sun C++ 5.9 + lt_prog_compiler_pic_CXX='-KPIC' + lt_prog_compiler_static_CXX='-Bstatic' + lt_prog_compiler_wl_CXX='-Qoption ld ' + ;; + esac + ;; + esac + ;; + lynxos*) + ;; + m88k*) + ;; + mvs*) + case $cc_basename in + cxx*) + lt_prog_compiler_pic_CXX='-W c,exportall' + ;; + *) + ;; + esac + ;; + netbsd* | netbsdelf*-gnu) + ;; + *qnx* | *nto*) + # QNX uses GNU C++, but need to define -shared option too, otherwise + # it will coredump. + lt_prog_compiler_pic_CXX='-fPIC -shared' + ;; + osf3* | osf4* | osf5*) + case $cc_basename in + KCC*) + lt_prog_compiler_wl_CXX='--backend -Wl,' + ;; + RCC*) + # Rational C++ 2.4.1 + lt_prog_compiler_pic_CXX='-pic' + ;; + cxx*) + # Digital/Compaq C++ + lt_prog_compiler_wl_CXX='-Wl,' + # Make sure the PIC flag is empty. It appears that all Alpha + # Linux and Compaq Tru64 Unix objects are PIC. + lt_prog_compiler_pic_CXX= + lt_prog_compiler_static_CXX='-non_shared' + ;; + *) + ;; + esac + ;; + psos*) + ;; + solaris*) + case $cc_basename in + CC* | sunCC*) + # Sun C++ 4.2, 5.x and Centerline C++ + lt_prog_compiler_pic_CXX='-KPIC' + lt_prog_compiler_static_CXX='-Bstatic' + lt_prog_compiler_wl_CXX='-Qoption ld ' + ;; + gcx*) + # Green Hills C++ Compiler + lt_prog_compiler_pic_CXX='-PIC' + ;; + *) + ;; + esac + ;; + sunos4*) + case $cc_basename in + CC*) + # Sun C++ 4.x + lt_prog_compiler_pic_CXX='-pic' + lt_prog_compiler_static_CXX='-Bstatic' + ;; + lcc*) + # Lucid + lt_prog_compiler_pic_CXX='-pic' + ;; + *) + ;; + esac + ;; + sysv5* | unixware* | sco3.2v5* | sco5v6* | OpenUNIX*) + case $cc_basename in + CC*) + lt_prog_compiler_wl_CXX='-Wl,' + lt_prog_compiler_pic_CXX='-KPIC' + lt_prog_compiler_static_CXX='-Bstatic' + ;; + esac + ;; + tandem*) + case $cc_basename in + NCC*) + # NonStop-UX NCC 3.20 + lt_prog_compiler_pic_CXX='-KPIC' + ;; + *) + ;; + esac + ;; + vxworks*) + ;; + *) + lt_prog_compiler_can_build_shared_CXX=no + ;; + esac + fi + +case $host_os in + # For platforms which do not support PIC, -DPIC is meaningless: + *djgpp*) + lt_prog_compiler_pic_CXX= + ;; + *) + lt_prog_compiler_pic_CXX="$lt_prog_compiler_pic_CXX -DPIC" + ;; +esac + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $compiler option to produce PIC" >&5 +$as_echo_n "checking for $compiler option to produce PIC... " >&6; } +if ${lt_cv_prog_compiler_pic_CXX+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_prog_compiler_pic_CXX=$lt_prog_compiler_pic_CXX +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic_CXX" >&5 +$as_echo "$lt_cv_prog_compiler_pic_CXX" >&6; } +lt_prog_compiler_pic_CXX=$lt_cv_prog_compiler_pic_CXX + +# +# Check to make sure the PIC flag actually works. +# +if test -n "$lt_prog_compiler_pic_CXX"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler PIC flag $lt_prog_compiler_pic_CXX works" >&5 +$as_echo_n "checking if $compiler PIC flag $lt_prog_compiler_pic_CXX works... " >&6; } +if ${lt_cv_prog_compiler_pic_works_CXX+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_prog_compiler_pic_works_CXX=no + ac_outfile=conftest.$ac_objext + echo "$lt_simple_compile_test_code" > conftest.$ac_ext + lt_compiler_flag="$lt_prog_compiler_pic_CXX -DPIC" + # Insert the option either (1) after the last *FLAGS variable, or + # (2) before a word containing "conftest.", or (3) at the end. + # Note that $ac_compile itself does not contain backslashes and begins + # with a dollar sign (not a hyphen), so the echo should work correctly. + # The option is referenced via a variable to avoid confusing sed. + lt_compile=`echo "$ac_compile" | $SED \ + -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \ + -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \ + -e 's:$: $lt_compiler_flag:'` + (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&5) + (eval "$lt_compile" 2>conftest.err) + ac_status=$? + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + if (exit $ac_status) && test -s "$ac_outfile"; then + # The compiler can only warn and ignore the option if not recognized + # So say no if there are warnings other than the usual output. + $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' >conftest.exp + $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2 + if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then + lt_cv_prog_compiler_pic_works_CXX=yes + fi + fi + $RM conftest* + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic_works_CXX" >&5 +$as_echo "$lt_cv_prog_compiler_pic_works_CXX" >&6; } + +if test x"$lt_cv_prog_compiler_pic_works_CXX" = xyes; then + case $lt_prog_compiler_pic_CXX in + "" | " "*) ;; + *) lt_prog_compiler_pic_CXX=" $lt_prog_compiler_pic_CXX" ;; + esac +else + lt_prog_compiler_pic_CXX= + lt_prog_compiler_can_build_shared_CXX=no +fi + +fi + + + + + +# +# Check to make sure the static flag actually works. +# +wl=$lt_prog_compiler_wl_CXX eval lt_tmp_static_flag=\"$lt_prog_compiler_static_CXX\" +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler static flag $lt_tmp_static_flag works" >&5 +$as_echo_n "checking if $compiler static flag $lt_tmp_static_flag works... " >&6; } +if ${lt_cv_prog_compiler_static_works_CXX+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_prog_compiler_static_works_CXX=no + save_LDFLAGS="$LDFLAGS" + LDFLAGS="$LDFLAGS $lt_tmp_static_flag" + echo "$lt_simple_link_test_code" > conftest.$ac_ext + if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then + # The linker can only warn and ignore the option if not recognized + # So say no if there are warnings + if test -s conftest.err; then + # Append any errors to the config.log. + cat conftest.err 1>&5 + $ECHO "$_lt_linker_boilerplate" | $SED '/^$/d' > conftest.exp + $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2 + if diff conftest.exp conftest.er2 >/dev/null; then + lt_cv_prog_compiler_static_works_CXX=yes + fi + else + lt_cv_prog_compiler_static_works_CXX=yes + fi + fi + $RM -r conftest* + LDFLAGS="$save_LDFLAGS" + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_static_works_CXX" >&5 +$as_echo "$lt_cv_prog_compiler_static_works_CXX" >&6; } + +if test x"$lt_cv_prog_compiler_static_works_CXX" = xyes; then + : +else + lt_prog_compiler_static_CXX= +fi + + + + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -c -o file.$ac_objext" >&5 +$as_echo_n "checking if $compiler supports -c -o file.$ac_objext... " >&6; } +if ${lt_cv_prog_compiler_c_o_CXX+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_prog_compiler_c_o_CXX=no + $RM -r conftest 2>/dev/null + mkdir conftest + cd conftest + mkdir out + echo "$lt_simple_compile_test_code" > conftest.$ac_ext + + lt_compiler_flag="-o out/conftest2.$ac_objext" + # Insert the option either (1) after the last *FLAGS variable, or + # (2) before a word containing "conftest.", or (3) at the end. + # Note that $ac_compile itself does not contain backslashes and begins + # with a dollar sign (not a hyphen), so the echo should work correctly. + lt_compile=`echo "$ac_compile" | $SED \ + -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \ + -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \ + -e 's:$: $lt_compiler_flag:'` + (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&5) + (eval "$lt_compile" 2>out/conftest.err) + ac_status=$? + cat out/conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + if (exit $ac_status) && test -s out/conftest2.$ac_objext + then + # The compiler can only warn and ignore the option if not recognized + # So say no if there are warnings + $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' > out/conftest.exp + $SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2 + if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then + lt_cv_prog_compiler_c_o_CXX=yes + fi + fi + chmod u+w . 2>&5 + $RM conftest* + # SGI C++ compiler will create directory out/ii_files/ for + # template instantiation + test -d out/ii_files && $RM out/ii_files/* && rmdir out/ii_files + $RM out/* && rmdir out + cd .. + $RM -r conftest + $RM conftest* + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o_CXX" >&5 +$as_echo "$lt_cv_prog_compiler_c_o_CXX" >&6; } + + + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -c -o file.$ac_objext" >&5 +$as_echo_n "checking if $compiler supports -c -o file.$ac_objext... " >&6; } +if ${lt_cv_prog_compiler_c_o_CXX+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_prog_compiler_c_o_CXX=no + $RM -r conftest 2>/dev/null + mkdir conftest + cd conftest + mkdir out + echo "$lt_simple_compile_test_code" > conftest.$ac_ext + + lt_compiler_flag="-o out/conftest2.$ac_objext" + # Insert the option either (1) after the last *FLAGS variable, or + # (2) before a word containing "conftest.", or (3) at the end. + # Note that $ac_compile itself does not contain backslashes and begins + # with a dollar sign (not a hyphen), so the echo should work correctly. + lt_compile=`echo "$ac_compile" | $SED \ + -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \ + -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \ + -e 's:$: $lt_compiler_flag:'` + (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&5) + (eval "$lt_compile" 2>out/conftest.err) + ac_status=$? + cat out/conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + if (exit $ac_status) && test -s out/conftest2.$ac_objext + then + # The compiler can only warn and ignore the option if not recognized + # So say no if there are warnings + $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' > out/conftest.exp + $SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2 + if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then + lt_cv_prog_compiler_c_o_CXX=yes + fi + fi + chmod u+w . 2>&5 + $RM conftest* + # SGI C++ compiler will create directory out/ii_files/ for + # template instantiation + test -d out/ii_files && $RM out/ii_files/* && rmdir out/ii_files + $RM out/* && rmdir out + cd .. + $RM -r conftest + $RM conftest* + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o_CXX" >&5 +$as_echo "$lt_cv_prog_compiler_c_o_CXX" >&6; } + + + + +hard_links="nottested" +if test "$lt_cv_prog_compiler_c_o_CXX" = no && test "$need_locks" != no; then + # do not overwrite the value of need_locks provided by the user + { $as_echo "$as_me:${as_lineno-$LINENO}: checking if we can lock with hard links" >&5 +$as_echo_n "checking if we can lock with hard links... " >&6; } + hard_links=yes + $RM conftest* + ln conftest.a conftest.b 2>/dev/null && hard_links=no + touch conftest.a + ln conftest.a conftest.b 2>&5 || hard_links=no + ln conftest.a conftest.b 2>/dev/null && hard_links=no + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $hard_links" >&5 +$as_echo "$hard_links" >&6; } + if test "$hard_links" = no; then + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&5 +$as_echo "$as_me: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&2;} + need_locks=warn + fi +else + need_locks=no +fi + + + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the $compiler linker ($LD) supports shared libraries" >&5 +$as_echo_n "checking whether the $compiler linker ($LD) supports shared libraries... " >&6; } + + export_symbols_cmds_CXX='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols' + exclude_expsyms_CXX='_GLOBAL_OFFSET_TABLE_|_GLOBAL__F[ID]_.*' + case $host_os in + aix[4-9]*) + # If we're using GNU nm, then we don't want the "-C" option. + # -C means demangle to AIX nm, but means don't demangle with GNU nm + # Also, AIX nm treats weak defined symbols like other global defined + # symbols, whereas GNU nm marks them as "W". + if $NM -V 2>&1 | $GREP 'GNU' > /dev/null; then + export_symbols_cmds_CXX='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W")) && (substr(\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols' + else + export_symbols_cmds_CXX='$NM -BCpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B")) && (substr(\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols' + fi + ;; + pw32*) + export_symbols_cmds_CXX="$ltdll_cmds" + ;; + cygwin* | mingw* | cegcc*) + case $cc_basename in + cl*) + exclude_expsyms_CXX='_NULL_IMPORT_DESCRIPTOR|_IMPORT_DESCRIPTOR_.*' + ;; + *) + export_symbols_cmds_CXX='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[BCDGRS][ ]/s/.*[ ]\([^ ]*\)/\1 DATA/;s/^.*[ ]__nm__\([^ ]*\)[ ][^ ]*/\1 DATA/;/^I[ ]/d;/^[AITW][ ]/s/.* //'\'' | sort | uniq > $export_symbols' + exclude_expsyms_CXX='[_]+GLOBAL_OFFSET_TABLE_|[_]+GLOBAL__[FID]_.*|[_]+head_[A-Za-z0-9_]+_dll|[A-Za-z0-9_]+_dll_iname' + ;; + esac + ;; + linux* | k*bsd*-gnu | gnu*) + link_all_deplibs_CXX=no + ;; + *) + export_symbols_cmds_CXX='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols' + ;; + esac + +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ld_shlibs_CXX" >&5 +$as_echo "$ld_shlibs_CXX" >&6; } +test "$ld_shlibs_CXX" = no && can_build_shared=no + +with_gnu_ld_CXX=$with_gnu_ld + + + + + + +# +# Do we need to explicitly link libc? +# +case "x$archive_cmds_need_lc_CXX" in +x|xyes) + # Assume -lc should be added + archive_cmds_need_lc_CXX=yes + + if test "$enable_shared" = yes && test "$GCC" = yes; then + case $archive_cmds_CXX in + *'~'*) + # FIXME: we may have to deal with multi-command sequences. + ;; + '$CC '*) + # Test whether the compiler implicitly links with -lc since on some + # systems, -lgcc has to come before -lc. If gcc already passes -lc + # to ld, don't add -lc before -lgcc. + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether -lc should be explicitly linked in" >&5 +$as_echo_n "checking whether -lc should be explicitly linked in... " >&6; } +if ${lt_cv_archive_cmds_need_lc_CXX+:} false; then : + $as_echo_n "(cached) " >&6 +else + $RM conftest* + echo "$lt_simple_compile_test_code" > conftest.$ac_ext + + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 + (eval $ac_compile) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } 2>conftest.err; then + soname=conftest + lib=conftest + libobjs=conftest.$ac_objext + deplibs= + wl=$lt_prog_compiler_wl_CXX + pic_flag=$lt_prog_compiler_pic_CXX + compiler_flags=-v + linker_flags=-v + verstring= + output_objdir=. + libname=conftest + lt_save_allow_undefined_flag=$allow_undefined_flag_CXX + allow_undefined_flag_CXX= + if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$archive_cmds_CXX 2\>\&1 \| $GREP \" -lc \" \>/dev/null 2\>\&1\""; } >&5 + (eval $archive_cmds_CXX 2\>\&1 \| $GREP \" -lc \" \>/dev/null 2\>\&1) 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; } + then + lt_cv_archive_cmds_need_lc_CXX=no + else + lt_cv_archive_cmds_need_lc_CXX=yes + fi + allow_undefined_flag_CXX=$lt_save_allow_undefined_flag + else + cat conftest.err 1>&5 + fi + $RM conftest* + +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_archive_cmds_need_lc_CXX" >&5 +$as_echo "$lt_cv_archive_cmds_need_lc_CXX" >&6; } + archive_cmds_need_lc_CXX=$lt_cv_archive_cmds_need_lc_CXX + ;; + esac + fi + ;; +esac + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking dynamic linker characteristics" >&5 +$as_echo_n "checking dynamic linker characteristics... " >&6; } + +library_names_spec= +libname_spec='lib$name' +soname_spec= +shrext_cmds=".so" +postinstall_cmds= +postuninstall_cmds= +finish_cmds= +finish_eval= +shlibpath_var= +shlibpath_overrides_runpath=unknown +version_type=none +dynamic_linker="$host_os ld.so" +sys_lib_dlsearch_path_spec="/lib /usr/lib" +need_lib_prefix=unknown +hardcode_into_libs=no + +# when you set need_version to no, make sure it does not cause -set_version +# flags to be left without arguments +need_version=unknown + +case $host_os in +aix3*) + version_type=linux # correct to gnu/linux during the next big refactor + library_names_spec='${libname}${release}${shared_ext}$versuffix $libname.a' + shlibpath_var=LIBPATH + + # AIX 3 has no versioning support, so we append a major version to the name. + soname_spec='${libname}${release}${shared_ext}$major' + ;; + +aix[4-9]*) + version_type=linux # correct to gnu/linux during the next big refactor + need_lib_prefix=no + need_version=no + hardcode_into_libs=yes + if test "$host_cpu" = ia64; then + # AIX 5 supports IA64 + library_names_spec='${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext}$versuffix $libname${shared_ext}' + shlibpath_var=LD_LIBRARY_PATH + else + # With GCC up to 2.95.x, collect2 would create an import file + # for dependence libraries. The import file would start with + # the line `#! .'. This would cause the generated library to + # depend on `.', always an invalid library. This was fixed in + # development snapshots of GCC prior to 3.0. + case $host_os in + aix4 | aix4.[01] | aix4.[01].*) + if { echo '#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 97)' + echo ' yes ' + echo '#endif'; } | ${CC} -E - | $GREP yes > /dev/null; then + : + else + can_build_shared=no + fi + ;; + esac + # AIX (on Power*) has no versioning support, so currently we can not hardcode correct + # soname into executable. Probably we can add versioning support to + # collect2, so additional links can be useful in future. + if test "$aix_use_runtimelinking" = yes; then + # If using run time linking (on AIX 4.2 or later) use lib.so + # instead of lib.a to let people know that these are not + # typical AIX shared libraries. + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + else + # We preserve .a as extension for shared libraries through AIX4.2 + # and later when we are not doing run time linking. + library_names_spec='${libname}${release}.a $libname.a' + soname_spec='${libname}${release}${shared_ext}$major' + fi + shlibpath_var=LIBPATH + fi + ;; + +amigaos*) + case $host_cpu in + powerpc) + # Since July 2007 AmigaOS4 officially supports .so libraries. + # When compiling the executable, add -use-dynld -Lsobjs: to the compileline. + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + ;; + m68k) + library_names_spec='$libname.ixlibrary $libname.a' + # Create ${libname}_ixlibrary.a entries in /sys/libs. + finish_eval='for lib in `ls $libdir/*.ixlibrary 2>/dev/null`; do libname=`func_echo_all "$lib" | $SED '\''s%^.*/\([^/]*\)\.ixlibrary$%\1%'\''`; test $RM /sys/libs/${libname}_ixlibrary.a; $show "cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a"; cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a || exit 1; done' + ;; + esac + ;; + +beos*) + library_names_spec='${libname}${shared_ext}' + dynamic_linker="$host_os ld.so" + shlibpath_var=LIBRARY_PATH + ;; + +bsdi[45]*) + version_type=linux # correct to gnu/linux during the next big refactor + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + finish_cmds='PATH="\$PATH:/sbin" ldconfig $libdir' + shlibpath_var=LD_LIBRARY_PATH + sys_lib_search_path_spec="/shlib /usr/lib /usr/X11/lib /usr/contrib/lib /lib /usr/local/lib" + sys_lib_dlsearch_path_spec="/shlib /usr/lib /usr/local/lib" + # the default ld.so.conf also contains /usr/contrib/lib and + # /usr/X11R6/lib (/usr/X11 is a link to /usr/X11R6), but let us allow + # libtool to hard-code these into programs + ;; + +cygwin* | mingw* | pw32* | cegcc*) + version_type=windows + shrext_cmds=".dll" + need_version=no + need_lib_prefix=no + + case $GCC,$cc_basename in + yes,*) + # gcc + library_names_spec='$libname.dll.a' + # DLL is installed to $(libdir)/../bin by postinstall_cmds + postinstall_cmds='base_file=`basename \${file}`~ + dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i; echo \$dlname'\''`~ + dldir=$destdir/`dirname \$dlpath`~ + test -d \$dldir || mkdir -p \$dldir~ + $install_prog $dir/$dlname \$dldir/$dlname~ + chmod a+x \$dldir/$dlname~ + if test -n '\''$stripme'\'' && test -n '\''$striplib'\''; then + eval '\''$striplib \$dldir/$dlname'\'' || exit \$?; + fi' + postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~ + dlpath=$dir/\$dldll~ + $RM \$dlpath' + shlibpath_overrides_runpath=yes + + case $host_os in + cygwin*) + # Cygwin DLLs use 'cyg' prefix rather than 'lib' + soname_spec='`echo ${libname} | sed -e 's/^lib/cyg/'``echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}' + + ;; + mingw* | cegcc*) + # MinGW DLLs use traditional 'lib' prefix + soname_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}' + ;; + pw32*) + # pw32 DLLs use 'pw' prefix rather than 'lib' + library_names_spec='`echo ${libname} | sed -e 's/^lib/pw/'``echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}' + ;; + esac + dynamic_linker='Win32 ld.exe' + ;; + + *,cl*) + # Native MSVC + libname_spec='$name' + soname_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}' + library_names_spec='${libname}.dll.lib' + + case $build_os in + mingw*) + sys_lib_search_path_spec= + lt_save_ifs=$IFS + IFS=';' + for lt_path in $LIB + do + IFS=$lt_save_ifs + # Let DOS variable expansion print the short 8.3 style file name. + lt_path=`cd "$lt_path" 2>/dev/null && cmd //C "for %i in (".") do @echo %~si"` + sys_lib_search_path_spec="$sys_lib_search_path_spec $lt_path" + done + IFS=$lt_save_ifs + # Convert to MSYS style. + sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | sed -e 's|\\\\|/|g' -e 's| \\([a-zA-Z]\\):| /\\1|g' -e 's|^ ||'` + ;; + cygwin*) + # Convert to unix form, then to dos form, then back to unix form + # but this time dos style (no spaces!) so that the unix form looks + # like /cygdrive/c/PROGRA~1:/cygdr... + sys_lib_search_path_spec=`cygpath --path --unix "$LIB"` + sys_lib_search_path_spec=`cygpath --path --dos "$sys_lib_search_path_spec" 2>/dev/null` + sys_lib_search_path_spec=`cygpath --path --unix "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"` + ;; + *) + sys_lib_search_path_spec="$LIB" + if $ECHO "$sys_lib_search_path_spec" | $GREP ';[c-zC-Z]:/' >/dev/null; then + # It is most probably a Windows format PATH. + sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'` + else + sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"` + fi + # FIXME: find the short name or the path components, as spaces are + # common. (e.g. "Program Files" -> "PROGRA~1") + ;; + esac + + # DLL is installed to $(libdir)/../bin by postinstall_cmds + postinstall_cmds='base_file=`basename \${file}`~ + dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i; echo \$dlname'\''`~ + dldir=$destdir/`dirname \$dlpath`~ + test -d \$dldir || mkdir -p \$dldir~ + $install_prog $dir/$dlname \$dldir/$dlname' + postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~ + dlpath=$dir/\$dldll~ + $RM \$dlpath' + shlibpath_overrides_runpath=yes + dynamic_linker='Win32 link.exe' + ;; + + *) + # Assume MSVC wrapper + library_names_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext} $libname.lib' + dynamic_linker='Win32 ld.exe' + ;; + esac + # FIXME: first we should search . and the directory the executable is in + shlibpath_var=PATH + ;; + +darwin* | rhapsody*) + dynamic_linker="$host_os dyld" + version_type=darwin + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${major}$shared_ext ${libname}$shared_ext' + soname_spec='${libname}${release}${major}$shared_ext' + shlibpath_overrides_runpath=yes + shlibpath_var=DYLD_LIBRARY_PATH + shrext_cmds='`test .$module = .yes && echo .so || echo .dylib`' + + sys_lib_dlsearch_path_spec='/usr/local/lib /lib /usr/lib' + ;; + +dgux*) + version_type=linux # correct to gnu/linux during the next big refactor + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname$shared_ext' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + ;; + +freebsd* | dragonfly*) + # DragonFly does not have aout. When/if they implement a new + # versioning mechanism, adjust this. + if test -x /usr/bin/objformat; then + objformat=`/usr/bin/objformat` + else + case $host_os in + freebsd[23].*) objformat=aout ;; + *) objformat=elf ;; + esac + fi + version_type=freebsd-$objformat + case $version_type in + freebsd-elf*) + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}' + need_version=no + need_lib_prefix=no + ;; + freebsd-*) + library_names_spec='${libname}${release}${shared_ext}$versuffix $libname${shared_ext}$versuffix' + need_version=yes + ;; + esac + shlibpath_var=LD_LIBRARY_PATH + case $host_os in + freebsd2.*) + shlibpath_overrides_runpath=yes + ;; + freebsd3.[01]* | freebsdelf3.[01]*) + shlibpath_overrides_runpath=yes + hardcode_into_libs=yes + ;; + freebsd3.[2-9]* | freebsdelf3.[2-9]* | \ + freebsd4.[0-5] | freebsdelf4.[0-5] | freebsd4.1.1 | freebsdelf4.1.1) + shlibpath_overrides_runpath=no + hardcode_into_libs=yes + ;; + *) # from 4.6 on, and DragonFly + shlibpath_overrides_runpath=yes + hardcode_into_libs=yes + ;; + esac + ;; + +haiku*) + version_type=linux # correct to gnu/linux during the next big refactor + need_lib_prefix=no + need_version=no + dynamic_linker="$host_os runtime_loader" + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}${major} ${libname}${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LIBRARY_PATH + shlibpath_overrides_runpath=yes + sys_lib_dlsearch_path_spec='/boot/home/config/lib /boot/common/lib /boot/system/lib' + hardcode_into_libs=yes + ;; + +hpux9* | hpux10* | hpux11*) + # Give a soname corresponding to the major version so that dld.sl refuses to + # link against other versions. + version_type=sunos + need_lib_prefix=no + need_version=no + case $host_cpu in + ia64*) + shrext_cmds='.so' + hardcode_into_libs=yes + dynamic_linker="$host_os dld.so" + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes # Unless +noenvvar is specified. + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + if test "X$HPUX_IA64_MODE" = X32; then + sys_lib_search_path_spec="/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib" + else + sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64" + fi + sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec + ;; + hppa*64*) + shrext_cmds='.sl' + hardcode_into_libs=yes + dynamic_linker="$host_os dld.sl" + shlibpath_var=LD_LIBRARY_PATH # How should we handle SHLIB_PATH + shlibpath_overrides_runpath=yes # Unless +noenvvar is specified. + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + sys_lib_search_path_spec="/usr/lib/pa20_64 /usr/ccs/lib/pa20_64" + sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec + ;; + *) + shrext_cmds='.sl' + dynamic_linker="$host_os dld.sl" + shlibpath_var=SHLIB_PATH + shlibpath_overrides_runpath=no # +s is required to enable SHLIB_PATH + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + ;; + esac + # HP-UX runs *really* slowly unless shared libraries are mode 555, ... + postinstall_cmds='chmod 555 $lib' + # or fails outright, so override atomically: + install_override_mode=555 + ;; + +interix[3-9]*) + version_type=linux # correct to gnu/linux during the next big refactor + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + dynamic_linker='Interix 3.x ld.so.1 (PE, like ELF)' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + hardcode_into_libs=yes + ;; + +irix5* | irix6* | nonstopux*) + case $host_os in + nonstopux*) version_type=nonstopux ;; + *) + if test "$lt_cv_prog_gnu_ld" = yes; then + version_type=linux # correct to gnu/linux during the next big refactor + else + version_type=irix + fi ;; + esac + need_lib_prefix=no + need_version=no + soname_spec='${libname}${release}${shared_ext}$major' + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext} $libname${shared_ext}' + case $host_os in + irix5* | nonstopux*) + libsuff= shlibsuff= + ;; + *) + case $LD in # libtool.m4 will add one of these switches to LD + *-32|*"-32 "|*-melf32bsmip|*"-melf32bsmip ") + libsuff= shlibsuff= libmagic=32-bit;; + *-n32|*"-n32 "|*-melf32bmipn32|*"-melf32bmipn32 ") + libsuff=32 shlibsuff=N32 libmagic=N32;; + *-64|*"-64 "|*-melf64bmip|*"-melf64bmip ") + libsuff=64 shlibsuff=64 libmagic=64-bit;; + *) libsuff= shlibsuff= libmagic=never-match;; + esac + ;; + esac + shlibpath_var=LD_LIBRARY${shlibsuff}_PATH + shlibpath_overrides_runpath=no + sys_lib_search_path_spec="/usr/lib${libsuff} /lib${libsuff} /usr/local/lib${libsuff}" + sys_lib_dlsearch_path_spec="/usr/lib${libsuff} /lib${libsuff}" + hardcode_into_libs=yes + ;; + +# No shared lib support for Linux oldld, aout, or coff. +linux*oldld* | linux*aout* | linux*coff*) + dynamic_linker=no + ;; + +# This must be glibc/ELF. +linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*) + version_type=linux # correct to gnu/linux during the next big refactor + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + finish_cmds='PATH="\$PATH:/sbin" ldconfig -n $libdir' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + + # Some binutils ld are patched to set DT_RUNPATH + if ${lt_cv_shlibpath_overrides_runpath+:} false; then : + $as_echo_n "(cached) " >&6 +else + lt_cv_shlibpath_overrides_runpath=no + save_LDFLAGS=$LDFLAGS + save_libdir=$libdir + eval "libdir=/foo; wl=\"$lt_prog_compiler_wl_CXX\"; \ + LDFLAGS=\"\$LDFLAGS $hardcode_libdir_flag_spec_CXX\"" + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +int +main () +{ + + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_link "$LINENO"; then : + if ($OBJDUMP -p conftest$ac_exeext) 2>/dev/null | grep "RUNPATH.*$libdir" >/dev/null; then : + lt_cv_shlibpath_overrides_runpath=yes +fi +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext + LDFLAGS=$save_LDFLAGS + libdir=$save_libdir + +fi + + shlibpath_overrides_runpath=$lt_cv_shlibpath_overrides_runpath + + # This implies no fast_install, which is unacceptable. + # Some rework will be needed to allow for fast_install + # before this can be enabled. + hardcode_into_libs=yes + + # Append ld.so.conf contents to the search path + if test -f /etc/ld.so.conf; then + lt_ld_extra=`awk '/^include / { system(sprintf("cd /etc; cat %s 2>/dev/null", \$2)); skip = 1; } { if (!skip) print \$0; skip = 0; }' < /etc/ld.so.conf | $SED -e 's/#.*//;/^[ ]*hwcap[ ]/d;s/[:, ]/ /g;s/=[^=]*$//;s/=[^= ]* / /g;s/"//g;/^$/d' | tr '\n' ' '` + sys_lib_dlsearch_path_spec="/lib /usr/lib $lt_ld_extra" + fi + + # We used to test for /lib/ld.so.1 and disable shared libraries on + # powerpc, because MkLinux only supported shared libraries with the + # GNU dynamic linker. Since this was broken with cross compilers, + # most powerpc-linux boxes support dynamic linking these days and + # people can always --disable-shared, the test was removed, and we + # assume the GNU/Linux dynamic linker is in use. + dynamic_linker='GNU/Linux ld.so' + ;; + +netbsdelf*-gnu) + version_type=linux + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + hardcode_into_libs=yes + dynamic_linker='NetBSD ld.elf_so' + ;; + +netbsd*) + version_type=sunos + need_lib_prefix=no + need_version=no + if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix' + finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir' + dynamic_linker='NetBSD (a.out) ld.so' + else + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + dynamic_linker='NetBSD ld.elf_so' + fi + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + hardcode_into_libs=yes + ;; + +newsos6) + version_type=linux # correct to gnu/linux during the next big refactor + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + ;; + +*nto* | *qnx*) + version_type=qnx + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + hardcode_into_libs=yes + dynamic_linker='ldqnx.so' + ;; + +openbsd*) + version_type=sunos + sys_lib_dlsearch_path_spec="/usr/lib" + need_lib_prefix=no + # Some older versions of OpenBSD (3.3 at least) *do* need versioned libs. + case $host_os in + openbsd3.3 | openbsd3.3.*) need_version=yes ;; + *) need_version=no ;; + esac + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix' + finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir' + shlibpath_var=LD_LIBRARY_PATH + if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then + case $host_os in + openbsd2.[89] | openbsd2.[89].*) + shlibpath_overrides_runpath=no + ;; + *) + shlibpath_overrides_runpath=yes + ;; + esac + else + shlibpath_overrides_runpath=yes + fi + ;; + +os2*) + libname_spec='$name' + shrext_cmds=".dll" + need_lib_prefix=no + library_names_spec='$libname${shared_ext} $libname.a' + dynamic_linker='OS/2 ld.exe' + shlibpath_var=LIBPATH + ;; + +osf3* | osf4* | osf5*) + version_type=osf + need_lib_prefix=no + need_version=no + soname_spec='${libname}${release}${shared_ext}$major' + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + shlibpath_var=LD_LIBRARY_PATH + sys_lib_search_path_spec="/usr/shlib /usr/ccs/lib /usr/lib/cmplrs/cc /usr/lib /usr/local/lib /var/shlib" + sys_lib_dlsearch_path_spec="$sys_lib_search_path_spec" + ;; + +rdos*) + dynamic_linker=no + ;; + +solaris*) + version_type=linux # correct to gnu/linux during the next big refactor + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + hardcode_into_libs=yes + # ldd complains unless libraries are executable + postinstall_cmds='chmod +x $lib' + ;; + +sunos4*) + version_type=sunos + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix' + finish_cmds='PATH="\$PATH:/usr/etc" ldconfig $libdir' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + if test "$with_gnu_ld" = yes; then + need_lib_prefix=no + fi + need_version=yes + ;; + +sysv4 | sysv4.3*) + version_type=linux # correct to gnu/linux during the next big refactor + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + case $host_vendor in + sni) + shlibpath_overrides_runpath=no + need_lib_prefix=no + runpath_var=LD_RUN_PATH + ;; + siemens) + need_lib_prefix=no + ;; + motorola) + need_lib_prefix=no + need_version=no + shlibpath_overrides_runpath=no + sys_lib_search_path_spec='/lib /usr/lib /usr/ccs/lib' + ;; + esac + ;; + +sysv4*MP*) + if test -d /usr/nec ;then + version_type=linux # correct to gnu/linux during the next big refactor + library_names_spec='$libname${shared_ext}.$versuffix $libname${shared_ext}.$major $libname${shared_ext}' + soname_spec='$libname${shared_ext}.$major' + shlibpath_var=LD_LIBRARY_PATH + fi + ;; + +sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*) + version_type=freebsd-elf + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + hardcode_into_libs=yes + if test "$with_gnu_ld" = yes; then + sys_lib_search_path_spec='/usr/local/lib /usr/gnu/lib /usr/ccs/lib /usr/lib /lib' + else + sys_lib_search_path_spec='/usr/ccs/lib /usr/lib' + case $host_os in + sco3.2v5*) + sys_lib_search_path_spec="$sys_lib_search_path_spec /lib" + ;; + esac + fi + sys_lib_dlsearch_path_spec='/usr/lib' + ;; + +tpf*) + # TPF is a cross-target only. Preferred cross-host = GNU/Linux. + version_type=linux # correct to gnu/linux during the next big refactor + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + hardcode_into_libs=yes + ;; + +uts4*) + version_type=linux # correct to gnu/linux during the next big refactor + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + ;; + +*) + dynamic_linker=no + ;; +esac +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $dynamic_linker" >&5 +$as_echo "$dynamic_linker" >&6; } +test "$dynamic_linker" = no && can_build_shared=no + +variables_saved_for_relink="PATH $shlibpath_var $runpath_var" +if test "$GCC" = yes; then + variables_saved_for_relink="$variables_saved_for_relink GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH" +fi + +if test "${lt_cv_sys_lib_search_path_spec+set}" = set; then + sys_lib_search_path_spec="$lt_cv_sys_lib_search_path_spec" +fi +if test "${lt_cv_sys_lib_dlsearch_path_spec+set}" = set; then + sys_lib_dlsearch_path_spec="$lt_cv_sys_lib_dlsearch_path_spec" +fi + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to hardcode library paths into programs" >&5 +$as_echo_n "checking how to hardcode library paths into programs... " >&6; } +hardcode_action_CXX= +if test -n "$hardcode_libdir_flag_spec_CXX" || + test -n "$runpath_var_CXX" || + test "X$hardcode_automatic_CXX" = "Xyes" ; then + + # We can hardcode non-existent directories. + if test "$hardcode_direct_CXX" != no && + # If the only mechanism to avoid hardcoding is shlibpath_var, we + # have to relink, otherwise we might link with an installed library + # when we should be linking with a yet-to-be-installed one + ## test "$_LT_TAGVAR(hardcode_shlibpath_var, CXX)" != no && + test "$hardcode_minus_L_CXX" != no; then + # Linking always hardcodes the temporary library directory. + hardcode_action_CXX=relink + else + # We can link without hardcoding, and we can hardcode nonexisting dirs. + hardcode_action_CXX=immediate + fi +else + # We cannot hardcode anything, or else we can only hardcode existing + # directories. + hardcode_action_CXX=unsupported +fi +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $hardcode_action_CXX" >&5 +$as_echo "$hardcode_action_CXX" >&6; } + +if test "$hardcode_action_CXX" = relink || + test "$inherit_rpath_CXX" = yes; then + # Fast installation is not supported + enable_fast_install=no +elif test "$shlibpath_overrides_runpath" = yes || + test "$enable_shared" = no; then + # Fast installation is not necessary + enable_fast_install=needless +fi + + + + + + + + fi # test -n "$compiler" + + CC=$lt_save_CC + CFLAGS=$lt_save_CFLAGS + LDCXX=$LD + LD=$lt_save_LD + GCC=$lt_save_GCC + with_gnu_ld=$lt_save_with_gnu_ld + lt_cv_path_LDCXX=$lt_cv_path_LD + lt_cv_path_LD=$lt_save_path_LD + lt_cv_prog_gnu_ldcxx=$lt_cv_prog_gnu_ld + lt_cv_prog_gnu_ld=$lt_save_with_gnu_ld +fi # test "$_lt_caught_CXX_error" != yes + +ac_ext=c +ac_cpp='$CPP $CPPFLAGS' +ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_c_compiler_gnu + + +ac_ext=cpp +ac_cpp='$CXXCPP $CPPFLAGS' +ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_cxx_compiler_gnu + + +# Create the libtool executable so that we can use it in further tests. +# +: ${CONFIG_LT=./config.lt} +{ $as_echo "$as_me:${as_lineno-$LINENO}: creating $CONFIG_LT" >&5 +$as_echo "$as_me: creating $CONFIG_LT" >&6;} +as_write_fail=0 +cat >"$CONFIG_LT" <<_ASEOF || as_write_fail=1 +#! $SHELL +# Generated by $as_me. +# Run this file to recreate a libtool stub with the current configuration. +SHELL=\${CONFIG_SHELL-$SHELL} +export SHELL +_ASEOF +cat >>"$CONFIG_LT" <<\_ASEOF || as_write_fail=1 +## -------------------- ## +## M4sh Initialization. ## +## -------------------- ## + +# Be more Bourne compatible +DUALCASE=1; export DUALCASE # for MKS sh +if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then : + emulate sh + NULLCMD=: + # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which + # is contrary to our usage. Disable this feature. + alias -g '${1+"$@"}'='"$@"' + setopt NO_GLOB_SUBST +else + case `(set -o) 2>/dev/null` in #( + *posix*) : + set -o posix ;; #( + *) : + ;; +esac +fi + + +as_nl=' +' +export as_nl +# Printing a long string crashes Solaris 7 /usr/bin/printf. +as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' +as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo +as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo +# Prefer a ksh shell builtin over an external printf program on Solaris, +# but without wasting forks for bash or zsh. +if test -z "$BASH_VERSION$ZSH_VERSION" \ + && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then + as_echo='print -r --' + as_echo_n='print -rn --' +elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then + as_echo='printf %s\n' + as_echo_n='printf %s' +else + if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then + as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"' + as_echo_n='/usr/ucb/echo -n' + else + as_echo_body='eval expr "X$1" : "X\\(.*\\)"' + as_echo_n_body='eval + arg=$1; + case $arg in #( + *"$as_nl"*) + expr "X$arg" : "X\\(.*\\)$as_nl"; + arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;; + esac; + expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl" + ' + export as_echo_n_body + as_echo_n='sh -c $as_echo_n_body as_echo' + fi + export as_echo_body + as_echo='sh -c $as_echo_body as_echo' +fi + +# The user is always right. +if test "${PATH_SEPARATOR+set}" != set; then + PATH_SEPARATOR=: + (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && { + (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 || + PATH_SEPARATOR=';' + } +fi + + +# IFS +# We need space, tab and new line, in precisely that order. Quoting is +# there to prevent editors from complaining about space-tab. +# (If _AS_PATH_WALK were called with IFS unset, it would disable word +# splitting by setting IFS to empty value.) +IFS=" "" $as_nl" + +# Find who we are. Look in the path if we contain no directory separator. +as_myself= +case $0 in #(( + *[\\/]* ) as_myself=$0 ;; + *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break + done +IFS=$as_save_IFS + + ;; +esac +# We did not find ourselves, most probably we were run as `sh COMMAND' +# in which case we are not to be found in the path. +if test "x$as_myself" = x; then + as_myself=$0 +fi +if test ! -f "$as_myself"; then + $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2 + exit 1 +fi + +# Unset variables that we do not need and which cause bugs (e.g. in +# pre-3.0 UWIN ksh). But do not cause bugs in bash 2.01; the "|| exit 1" +# suppresses any "Segmentation fault" message there. '((' could +# trigger a bug in pdksh 5.2.14. +for as_var in BASH_ENV ENV MAIL MAILPATH +do eval test x\${$as_var+set} = xset \ + && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || : +done +PS1='$ ' +PS2='> ' +PS4='+ ' + +# NLS nuisances. +LC_ALL=C +export LC_ALL +LANGUAGE=C +export LANGUAGE + +# CDPATH. +(unset CDPATH) >/dev/null 2>&1 && unset CDPATH + + +# as_fn_error STATUS ERROR [LINENO LOG_FD] +# ---------------------------------------- +# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are +# provided, also output the error to LOG_FD, referencing LINENO. Then exit the +# script with STATUS, using 1 if that was 0. +as_fn_error () +{ + as_status=$1; test $as_status -eq 0 && as_status=1 + if test "$4"; then + as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4 + fi + $as_echo "$as_me: error: $2" >&2 + as_fn_exit $as_status +} # as_fn_error + + +# as_fn_set_status STATUS +# ----------------------- +# Set $? to STATUS, without forking. +as_fn_set_status () +{ + return $1 +} # as_fn_set_status + +# as_fn_exit STATUS +# ----------------- +# Exit the shell with STATUS, even in a "trap 0" or "set -e" context. +as_fn_exit () +{ + set +e + as_fn_set_status $1 + exit $1 +} # as_fn_exit + +# as_fn_unset VAR +# --------------- +# Portably unset VAR. +as_fn_unset () +{ + { eval $1=; unset $1;} +} +as_unset=as_fn_unset +# as_fn_append VAR VALUE +# ---------------------- +# Append the text in VALUE to the end of the definition contained in VAR. Take +# advantage of any shell optimizations that allow amortized linear growth over +# repeated appends, instead of the typical quadratic growth present in naive +# implementations. +if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then : + eval 'as_fn_append () + { + eval $1+=\$2 + }' +else + as_fn_append () + { + eval $1=\$$1\$2 + } +fi # as_fn_append + +# as_fn_arith ARG... +# ------------------ +# Perform arithmetic evaluation on the ARGs, and store the result in the +# global $as_val. Take advantage of shells that can avoid forks. The arguments +# must be portable across $(()) and expr. +if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then : + eval 'as_fn_arith () + { + as_val=$(( $* )) + }' +else + as_fn_arith () + { + as_val=`expr "$@" || test $? -eq 1` + } +fi # as_fn_arith + + +if expr a : '\(a\)' >/dev/null 2>&1 && + test "X`expr 00001 : '.*\(...\)'`" = X001; then + as_expr=expr +else + as_expr=false +fi + +if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then + as_basename=basename +else + as_basename=false +fi + +if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then + as_dirname=dirname +else + as_dirname=false +fi + +as_me=`$as_basename -- "$0" || +$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ + X"$0" : 'X\(//\)$' \| \ + X"$0" : 'X\(/\)' \| . 2>/dev/null || +$as_echo X/"$0" | + sed '/^.*\/\([^/][^/]*\)\/*$/{ + s//\1/ + q + } + /^X\/\(\/\/\)$/{ + s//\1/ + q + } + /^X\/\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q'` + +# Avoid depending upon Character Ranges. +as_cr_letters='abcdefghijklmnopqrstuvwxyz' +as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ' +as_cr_Letters=$as_cr_letters$as_cr_LETTERS +as_cr_digits='0123456789' +as_cr_alnum=$as_cr_Letters$as_cr_digits + +ECHO_C= ECHO_N= ECHO_T= +case `echo -n x` in #((((( +-n*) + case `echo 'xy\c'` in + *c*) ECHO_T=' ';; # ECHO_T is single tab character. + xy) ECHO_C='\c';; + *) echo `echo ksh88 bug on AIX 6.1` > /dev/null + ECHO_T=' ';; + esac;; +*) + ECHO_N='-n';; +esac + +rm -f conf$$ conf$$.exe conf$$.file +if test -d conf$$.dir; then + rm -f conf$$.dir/conf$$.file +else + rm -f conf$$.dir + mkdir conf$$.dir 2>/dev/null +fi +if (echo >conf$$.file) 2>/dev/null; then + if ln -s conf$$.file conf$$ 2>/dev/null; then + as_ln_s='ln -s' + # ... but there are two gotchas: + # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail. + # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable. + # In both cases, we have to default to `cp -pR'. + ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe || + as_ln_s='cp -pR' + elif ln conf$$.file conf$$ 2>/dev/null; then + as_ln_s=ln + else + as_ln_s='cp -pR' + fi +else + as_ln_s='cp -pR' +fi +rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file +rmdir conf$$.dir 2>/dev/null + + +# as_fn_mkdir_p +# ------------- +# Create "$as_dir" as a directory, including parents if necessary. +as_fn_mkdir_p () +{ + + case $as_dir in #( + -*) as_dir=./$as_dir;; + esac + test -d "$as_dir" || eval $as_mkdir_p || { + as_dirs= + while :; do + case $as_dir in #( + *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'( + *) as_qdir=$as_dir;; + esac + as_dirs="'$as_qdir' $as_dirs" + as_dir=`$as_dirname -- "$as_dir" || +$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ + X"$as_dir" : 'X\(//\)[^/]' \| \ + X"$as_dir" : 'X\(//\)$' \| \ + X"$as_dir" : 'X\(/\)' \| . 2>/dev/null || +$as_echo X"$as_dir" | + sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ + s//\1/ + q + } + /^X\(\/\/\)[^/].*/{ + s//\1/ + q + } + /^X\(\/\/\)$/{ + s//\1/ + q + } + /^X\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q'` + test -d "$as_dir" && break + done + test -z "$as_dirs" || eval "mkdir $as_dirs" + } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir" + + +} # as_fn_mkdir_p +if mkdir -p . 2>/dev/null; then + as_mkdir_p='mkdir -p "$as_dir"' +else + test -d ./-p && rmdir ./-p + as_mkdir_p=false +fi + + +# as_fn_executable_p FILE +# ----------------------- +# Test if FILE is an executable regular file. +as_fn_executable_p () +{ + test -f "$1" && test -x "$1" +} # as_fn_executable_p +as_test_x='test -x' +as_executable_p=as_fn_executable_p + +# Sed expression to map a string onto a valid CPP name. +as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'" + +# Sed expression to map a string onto a valid variable name. +as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'" + + +exec 6>&1 +## --------------------------------- ## +## Main body of "$CONFIG_LT" script. ## +## --------------------------------- ## +_ASEOF +test $as_write_fail = 0 && chmod +x "$CONFIG_LT" + +cat >>"$CONFIG_LT" <<\_LTEOF +lt_cl_silent=false +exec 5>>config.log +{ + echo + sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX +## Running $as_me. ## +_ASBOX +} >&5 + +lt_cl_help="\ +\`$as_me' creates a local libtool stub from the current configuration, +for use in further configure time tests before the real libtool is +generated. + +Usage: $0 [OPTIONS] + + -h, --help print this help, then exit + -V, --version print version number, then exit + -q, --quiet do not print progress messages + -d, --debug don't remove temporary files + +Report bugs to ." + +lt_cl_version="\ +libodb-sqlite config.lt 2.4.0 +configured by $0, generated by GNU Autoconf 2.69. + +Copyright (C) 2011 Free Software Foundation, Inc. +This config.lt script is free software; the Free Software Foundation +gives unlimited permision to copy, distribute and modify it." + +while test $# != 0 +do + case $1 in + --version | --v* | -V ) + echo "$lt_cl_version"; exit 0 ;; + --help | --h* | -h ) + echo "$lt_cl_help"; exit 0 ;; + --debug | --d* | -d ) + debug=: ;; + --quiet | --q* | --silent | --s* | -q ) + lt_cl_silent=: ;; + + -*) as_fn_error $? "unrecognized option: $1 +Try \`$0 --help' for more information." "$LINENO" 5 ;; + + *) as_fn_error $? "unrecognized argument: $1 +Try \`$0 --help' for more information." "$LINENO" 5 ;; + esac + shift +done + +if $lt_cl_silent; then + exec 6>/dev/null +fi +_LTEOF + +cat >>"$CONFIG_LT" <<_LTEOF + + +# The HP-UX ksh and POSIX shell print the target directory to stdout +# if CDPATH is set. +(unset CDPATH) >/dev/null 2>&1 && unset CDPATH + +sed_quote_subst='$sed_quote_subst' +double_quote_subst='$double_quote_subst' +delay_variable_subst='$delay_variable_subst' +macro_version='`$ECHO "$macro_version" | $SED "$delay_single_quote_subst"`' +macro_revision='`$ECHO "$macro_revision" | $SED "$delay_single_quote_subst"`' +AS='`$ECHO "$AS" | $SED "$delay_single_quote_subst"`' +DLLTOOL='`$ECHO "$DLLTOOL" | $SED "$delay_single_quote_subst"`' +OBJDUMP='`$ECHO "$OBJDUMP" | $SED "$delay_single_quote_subst"`' +enable_shared='`$ECHO "$enable_shared" | $SED "$delay_single_quote_subst"`' +enable_static='`$ECHO "$enable_static" | $SED "$delay_single_quote_subst"`' +pic_mode='`$ECHO "$pic_mode" | $SED "$delay_single_quote_subst"`' +enable_fast_install='`$ECHO "$enable_fast_install" | $SED "$delay_single_quote_subst"`' +SHELL='`$ECHO "$SHELL" | $SED "$delay_single_quote_subst"`' +ECHO='`$ECHO "$ECHO" | $SED "$delay_single_quote_subst"`' +PATH_SEPARATOR='`$ECHO "$PATH_SEPARATOR" | $SED "$delay_single_quote_subst"`' +host_alias='`$ECHO "$host_alias" | $SED "$delay_single_quote_subst"`' +host='`$ECHO "$host" | $SED "$delay_single_quote_subst"`' +host_os='`$ECHO "$host_os" | $SED "$delay_single_quote_subst"`' +build_alias='`$ECHO "$build_alias" | $SED "$delay_single_quote_subst"`' +build='`$ECHO "$build" | $SED "$delay_single_quote_subst"`' +build_os='`$ECHO "$build_os" | $SED "$delay_single_quote_subst"`' +SED='`$ECHO "$SED" | $SED "$delay_single_quote_subst"`' +Xsed='`$ECHO "$Xsed" | $SED "$delay_single_quote_subst"`' +GREP='`$ECHO "$GREP" | $SED "$delay_single_quote_subst"`' +EGREP='`$ECHO "$EGREP" | $SED "$delay_single_quote_subst"`' +FGREP='`$ECHO "$FGREP" | $SED "$delay_single_quote_subst"`' +LD='`$ECHO "$LD" | $SED "$delay_single_quote_subst"`' +NM='`$ECHO "$NM" | $SED "$delay_single_quote_subst"`' +LN_S='`$ECHO "$LN_S" | $SED "$delay_single_quote_subst"`' +max_cmd_len='`$ECHO "$max_cmd_len" | $SED "$delay_single_quote_subst"`' +ac_objext='`$ECHO "$ac_objext" | $SED "$delay_single_quote_subst"`' +exeext='`$ECHO "$exeext" | $SED "$delay_single_quote_subst"`' +lt_unset='`$ECHO "$lt_unset" | $SED "$delay_single_quote_subst"`' +lt_SP2NL='`$ECHO "$lt_SP2NL" | $SED "$delay_single_quote_subst"`' +lt_NL2SP='`$ECHO "$lt_NL2SP" | $SED "$delay_single_quote_subst"`' +lt_cv_to_host_file_cmd='`$ECHO "$lt_cv_to_host_file_cmd" | $SED "$delay_single_quote_subst"`' +lt_cv_to_tool_file_cmd='`$ECHO "$lt_cv_to_tool_file_cmd" | $SED "$delay_single_quote_subst"`' +reload_flag='`$ECHO "$reload_flag" | $SED "$delay_single_quote_subst"`' +reload_cmds='`$ECHO "$reload_cmds" | $SED "$delay_single_quote_subst"`' +deplibs_check_method='`$ECHO "$deplibs_check_method" | $SED "$delay_single_quote_subst"`' +file_magic_cmd='`$ECHO "$file_magic_cmd" | $SED "$delay_single_quote_subst"`' +file_magic_glob='`$ECHO "$file_magic_glob" | $SED "$delay_single_quote_subst"`' +want_nocaseglob='`$ECHO "$want_nocaseglob" | $SED "$delay_single_quote_subst"`' +sharedlib_from_linklib_cmd='`$ECHO "$sharedlib_from_linklib_cmd" | $SED "$delay_single_quote_subst"`' +AR='`$ECHO "$AR" | $SED "$delay_single_quote_subst"`' +AR_FLAGS='`$ECHO "$AR_FLAGS" | $SED "$delay_single_quote_subst"`' +archiver_list_spec='`$ECHO "$archiver_list_spec" | $SED "$delay_single_quote_subst"`' +STRIP='`$ECHO "$STRIP" | $SED "$delay_single_quote_subst"`' +RANLIB='`$ECHO "$RANLIB" | $SED "$delay_single_quote_subst"`' +old_postinstall_cmds='`$ECHO "$old_postinstall_cmds" | $SED "$delay_single_quote_subst"`' +old_postuninstall_cmds='`$ECHO "$old_postuninstall_cmds" | $SED "$delay_single_quote_subst"`' +old_archive_cmds='`$ECHO "$old_archive_cmds" | $SED "$delay_single_quote_subst"`' +lock_old_archive_extraction='`$ECHO "$lock_old_archive_extraction" | $SED "$delay_single_quote_subst"`' +CC='`$ECHO "$CC" | $SED "$delay_single_quote_subst"`' +CFLAGS='`$ECHO "$CFLAGS" | $SED "$delay_single_quote_subst"`' +compiler='`$ECHO "$compiler" | $SED "$delay_single_quote_subst"`' +GCC='`$ECHO "$GCC" | $SED "$delay_single_quote_subst"`' +lt_cv_sys_global_symbol_pipe='`$ECHO "$lt_cv_sys_global_symbol_pipe" | $SED "$delay_single_quote_subst"`' +lt_cv_sys_global_symbol_to_cdecl='`$ECHO "$lt_cv_sys_global_symbol_to_cdecl" | $SED "$delay_single_quote_subst"`' +lt_cv_sys_global_symbol_to_c_name_address='`$ECHO "$lt_cv_sys_global_symbol_to_c_name_address" | $SED "$delay_single_quote_subst"`' +lt_cv_sys_global_symbol_to_c_name_address_lib_prefix='`$ECHO "$lt_cv_sys_global_symbol_to_c_name_address_lib_prefix" | $SED "$delay_single_quote_subst"`' +nm_file_list_spec='`$ECHO "$nm_file_list_spec" | $SED "$delay_single_quote_subst"`' +lt_sysroot='`$ECHO "$lt_sysroot" | $SED "$delay_single_quote_subst"`' +objdir='`$ECHO "$objdir" | $SED "$delay_single_quote_subst"`' +MAGIC_CMD='`$ECHO "$MAGIC_CMD" | $SED "$delay_single_quote_subst"`' +lt_prog_compiler_no_builtin_flag='`$ECHO "$lt_prog_compiler_no_builtin_flag" | $SED "$delay_single_quote_subst"`' +lt_prog_compiler_pic='`$ECHO "$lt_prog_compiler_pic" | $SED "$delay_single_quote_subst"`' +lt_prog_compiler_wl='`$ECHO "$lt_prog_compiler_wl" | $SED "$delay_single_quote_subst"`' +lt_prog_compiler_static='`$ECHO "$lt_prog_compiler_static" | $SED "$delay_single_quote_subst"`' +lt_cv_prog_compiler_c_o='`$ECHO "$lt_cv_prog_compiler_c_o" | $SED "$delay_single_quote_subst"`' +need_locks='`$ECHO "$need_locks" | $SED "$delay_single_quote_subst"`' +MANIFEST_TOOL='`$ECHO "$MANIFEST_TOOL" | $SED "$delay_single_quote_subst"`' +DSYMUTIL='`$ECHO "$DSYMUTIL" | $SED "$delay_single_quote_subst"`' +NMEDIT='`$ECHO "$NMEDIT" | $SED "$delay_single_quote_subst"`' +LIPO='`$ECHO "$LIPO" | $SED "$delay_single_quote_subst"`' +OTOOL='`$ECHO "$OTOOL" | $SED "$delay_single_quote_subst"`' +OTOOL64='`$ECHO "$OTOOL64" | $SED "$delay_single_quote_subst"`' +libext='`$ECHO "$libext" | $SED "$delay_single_quote_subst"`' +shrext_cmds='`$ECHO "$shrext_cmds" | $SED "$delay_single_quote_subst"`' +extract_expsyms_cmds='`$ECHO "$extract_expsyms_cmds" | $SED "$delay_single_quote_subst"`' +archive_cmds_need_lc='`$ECHO "$archive_cmds_need_lc" | $SED "$delay_single_quote_subst"`' +enable_shared_with_static_runtimes='`$ECHO "$enable_shared_with_static_runtimes" | $SED "$delay_single_quote_subst"`' +export_dynamic_flag_spec='`$ECHO "$export_dynamic_flag_spec" | $SED "$delay_single_quote_subst"`' +whole_archive_flag_spec='`$ECHO "$whole_archive_flag_spec" | $SED "$delay_single_quote_subst"`' +compiler_needs_object='`$ECHO "$compiler_needs_object" | $SED "$delay_single_quote_subst"`' +old_archive_from_new_cmds='`$ECHO "$old_archive_from_new_cmds" | $SED "$delay_single_quote_subst"`' +old_archive_from_expsyms_cmds='`$ECHO "$old_archive_from_expsyms_cmds" | $SED "$delay_single_quote_subst"`' +archive_cmds='`$ECHO "$archive_cmds" | $SED "$delay_single_quote_subst"`' +archive_expsym_cmds='`$ECHO "$archive_expsym_cmds" | $SED "$delay_single_quote_subst"`' +module_cmds='`$ECHO "$module_cmds" | $SED "$delay_single_quote_subst"`' +module_expsym_cmds='`$ECHO "$module_expsym_cmds" | $SED "$delay_single_quote_subst"`' +with_gnu_ld='`$ECHO "$with_gnu_ld" | $SED "$delay_single_quote_subst"`' +allow_undefined_flag='`$ECHO "$allow_undefined_flag" | $SED "$delay_single_quote_subst"`' +no_undefined_flag='`$ECHO "$no_undefined_flag" | $SED "$delay_single_quote_subst"`' +hardcode_libdir_flag_spec='`$ECHO "$hardcode_libdir_flag_spec" | $SED "$delay_single_quote_subst"`' +hardcode_libdir_separator='`$ECHO "$hardcode_libdir_separator" | $SED "$delay_single_quote_subst"`' +hardcode_direct='`$ECHO "$hardcode_direct" | $SED "$delay_single_quote_subst"`' +hardcode_direct_absolute='`$ECHO "$hardcode_direct_absolute" | $SED "$delay_single_quote_subst"`' +hardcode_minus_L='`$ECHO "$hardcode_minus_L" | $SED "$delay_single_quote_subst"`' +hardcode_shlibpath_var='`$ECHO "$hardcode_shlibpath_var" | $SED "$delay_single_quote_subst"`' +hardcode_automatic='`$ECHO "$hardcode_automatic" | $SED "$delay_single_quote_subst"`' +inherit_rpath='`$ECHO "$inherit_rpath" | $SED "$delay_single_quote_subst"`' +link_all_deplibs='`$ECHO "$link_all_deplibs" | $SED "$delay_single_quote_subst"`' +always_export_symbols='`$ECHO "$always_export_symbols" | $SED "$delay_single_quote_subst"`' +export_symbols_cmds='`$ECHO "$export_symbols_cmds" | $SED "$delay_single_quote_subst"`' +exclude_expsyms='`$ECHO "$exclude_expsyms" | $SED "$delay_single_quote_subst"`' +include_expsyms='`$ECHO "$include_expsyms" | $SED "$delay_single_quote_subst"`' +prelink_cmds='`$ECHO "$prelink_cmds" | $SED "$delay_single_quote_subst"`' +postlink_cmds='`$ECHO "$postlink_cmds" | $SED "$delay_single_quote_subst"`' +file_list_spec='`$ECHO "$file_list_spec" | $SED "$delay_single_quote_subst"`' +variables_saved_for_relink='`$ECHO "$variables_saved_for_relink" | $SED "$delay_single_quote_subst"`' +need_lib_prefix='`$ECHO "$need_lib_prefix" | $SED "$delay_single_quote_subst"`' +need_version='`$ECHO "$need_version" | $SED "$delay_single_quote_subst"`' +version_type='`$ECHO "$version_type" | $SED "$delay_single_quote_subst"`' +runpath_var='`$ECHO "$runpath_var" | $SED "$delay_single_quote_subst"`' +shlibpath_var='`$ECHO "$shlibpath_var" | $SED "$delay_single_quote_subst"`' +shlibpath_overrides_runpath='`$ECHO "$shlibpath_overrides_runpath" | $SED "$delay_single_quote_subst"`' +libname_spec='`$ECHO "$libname_spec" | $SED "$delay_single_quote_subst"`' +library_names_spec='`$ECHO "$library_names_spec" | $SED "$delay_single_quote_subst"`' +soname_spec='`$ECHO "$soname_spec" | $SED "$delay_single_quote_subst"`' +install_override_mode='`$ECHO "$install_override_mode" | $SED "$delay_single_quote_subst"`' +postinstall_cmds='`$ECHO "$postinstall_cmds" | $SED "$delay_single_quote_subst"`' +postuninstall_cmds='`$ECHO "$postuninstall_cmds" | $SED "$delay_single_quote_subst"`' +finish_cmds='`$ECHO "$finish_cmds" | $SED "$delay_single_quote_subst"`' +finish_eval='`$ECHO "$finish_eval" | $SED "$delay_single_quote_subst"`' +hardcode_into_libs='`$ECHO "$hardcode_into_libs" | $SED "$delay_single_quote_subst"`' +sys_lib_search_path_spec='`$ECHO "$sys_lib_search_path_spec" | $SED "$delay_single_quote_subst"`' +sys_lib_dlsearch_path_spec='`$ECHO "$sys_lib_dlsearch_path_spec" | $SED "$delay_single_quote_subst"`' +hardcode_action='`$ECHO "$hardcode_action" | $SED "$delay_single_quote_subst"`' +enable_dlopen='`$ECHO "$enable_dlopen" | $SED "$delay_single_quote_subst"`' +enable_dlopen_self='`$ECHO "$enable_dlopen_self" | $SED "$delay_single_quote_subst"`' +enable_dlopen_self_static='`$ECHO "$enable_dlopen_self_static" | $SED "$delay_single_quote_subst"`' +old_striplib='`$ECHO "$old_striplib" | $SED "$delay_single_quote_subst"`' +striplib='`$ECHO "$striplib" | $SED "$delay_single_quote_subst"`' +compiler_lib_search_dirs='`$ECHO "$compiler_lib_search_dirs" | $SED "$delay_single_quote_subst"`' +predep_objects='`$ECHO "$predep_objects" | $SED "$delay_single_quote_subst"`' +postdep_objects='`$ECHO "$postdep_objects" | $SED "$delay_single_quote_subst"`' +predeps='`$ECHO "$predeps" | $SED "$delay_single_quote_subst"`' +postdeps='`$ECHO "$postdeps" | $SED "$delay_single_quote_subst"`' +compiler_lib_search_path='`$ECHO "$compiler_lib_search_path" | $SED "$delay_single_quote_subst"`' +LD_CXX='`$ECHO "$LD_CXX" | $SED "$delay_single_quote_subst"`' +reload_flag_CXX='`$ECHO "$reload_flag_CXX" | $SED "$delay_single_quote_subst"`' +reload_cmds_CXX='`$ECHO "$reload_cmds_CXX" | $SED "$delay_single_quote_subst"`' +old_archive_cmds_CXX='`$ECHO "$old_archive_cmds_CXX" | $SED "$delay_single_quote_subst"`' +compiler_CXX='`$ECHO "$compiler_CXX" | $SED "$delay_single_quote_subst"`' +GCC_CXX='`$ECHO "$GCC_CXX" | $SED "$delay_single_quote_subst"`' +lt_prog_compiler_no_builtin_flag_CXX='`$ECHO "$lt_prog_compiler_no_builtin_flag_CXX" | $SED "$delay_single_quote_subst"`' +lt_prog_compiler_pic_CXX='`$ECHO "$lt_prog_compiler_pic_CXX" | $SED "$delay_single_quote_subst"`' +lt_prog_compiler_wl_CXX='`$ECHO "$lt_prog_compiler_wl_CXX" | $SED "$delay_single_quote_subst"`' +lt_prog_compiler_static_CXX='`$ECHO "$lt_prog_compiler_static_CXX" | $SED "$delay_single_quote_subst"`' +lt_cv_prog_compiler_c_o_CXX='`$ECHO "$lt_cv_prog_compiler_c_o_CXX" | $SED "$delay_single_quote_subst"`' +archive_cmds_need_lc_CXX='`$ECHO "$archive_cmds_need_lc_CXX" | $SED "$delay_single_quote_subst"`' +enable_shared_with_static_runtimes_CXX='`$ECHO "$enable_shared_with_static_runtimes_CXX" | $SED "$delay_single_quote_subst"`' +export_dynamic_flag_spec_CXX='`$ECHO "$export_dynamic_flag_spec_CXX" | $SED "$delay_single_quote_subst"`' +whole_archive_flag_spec_CXX='`$ECHO "$whole_archive_flag_spec_CXX" | $SED "$delay_single_quote_subst"`' +compiler_needs_object_CXX='`$ECHO "$compiler_needs_object_CXX" | $SED "$delay_single_quote_subst"`' +old_archive_from_new_cmds_CXX='`$ECHO "$old_archive_from_new_cmds_CXX" | $SED "$delay_single_quote_subst"`' +old_archive_from_expsyms_cmds_CXX='`$ECHO "$old_archive_from_expsyms_cmds_CXX" | $SED "$delay_single_quote_subst"`' +archive_cmds_CXX='`$ECHO "$archive_cmds_CXX" | $SED "$delay_single_quote_subst"`' +archive_expsym_cmds_CXX='`$ECHO "$archive_expsym_cmds_CXX" | $SED "$delay_single_quote_subst"`' +module_cmds_CXX='`$ECHO "$module_cmds_CXX" | $SED "$delay_single_quote_subst"`' +module_expsym_cmds_CXX='`$ECHO "$module_expsym_cmds_CXX" | $SED "$delay_single_quote_subst"`' +with_gnu_ld_CXX='`$ECHO "$with_gnu_ld_CXX" | $SED "$delay_single_quote_subst"`' +allow_undefined_flag_CXX='`$ECHO "$allow_undefined_flag_CXX" | $SED "$delay_single_quote_subst"`' +no_undefined_flag_CXX='`$ECHO "$no_undefined_flag_CXX" | $SED "$delay_single_quote_subst"`' +hardcode_libdir_flag_spec_CXX='`$ECHO "$hardcode_libdir_flag_spec_CXX" | $SED "$delay_single_quote_subst"`' +hardcode_libdir_separator_CXX='`$ECHO "$hardcode_libdir_separator_CXX" | $SED "$delay_single_quote_subst"`' +hardcode_direct_CXX='`$ECHO "$hardcode_direct_CXX" | $SED "$delay_single_quote_subst"`' +hardcode_direct_absolute_CXX='`$ECHO "$hardcode_direct_absolute_CXX" | $SED "$delay_single_quote_subst"`' +hardcode_minus_L_CXX='`$ECHO "$hardcode_minus_L_CXX" | $SED "$delay_single_quote_subst"`' +hardcode_shlibpath_var_CXX='`$ECHO "$hardcode_shlibpath_var_CXX" | $SED "$delay_single_quote_subst"`' +hardcode_automatic_CXX='`$ECHO "$hardcode_automatic_CXX" | $SED "$delay_single_quote_subst"`' +inherit_rpath_CXX='`$ECHO "$inherit_rpath_CXX" | $SED "$delay_single_quote_subst"`' +link_all_deplibs_CXX='`$ECHO "$link_all_deplibs_CXX" | $SED "$delay_single_quote_subst"`' +always_export_symbols_CXX='`$ECHO "$always_export_symbols_CXX" | $SED "$delay_single_quote_subst"`' +export_symbols_cmds_CXX='`$ECHO "$export_symbols_cmds_CXX" | $SED "$delay_single_quote_subst"`' +exclude_expsyms_CXX='`$ECHO "$exclude_expsyms_CXX" | $SED "$delay_single_quote_subst"`' +include_expsyms_CXX='`$ECHO "$include_expsyms_CXX" | $SED "$delay_single_quote_subst"`' +prelink_cmds_CXX='`$ECHO "$prelink_cmds_CXX" | $SED "$delay_single_quote_subst"`' +postlink_cmds_CXX='`$ECHO "$postlink_cmds_CXX" | $SED "$delay_single_quote_subst"`' +file_list_spec_CXX='`$ECHO "$file_list_spec_CXX" | $SED "$delay_single_quote_subst"`' +hardcode_action_CXX='`$ECHO "$hardcode_action_CXX" | $SED "$delay_single_quote_subst"`' +compiler_lib_search_dirs_CXX='`$ECHO "$compiler_lib_search_dirs_CXX" | $SED "$delay_single_quote_subst"`' +predep_objects_CXX='`$ECHO "$predep_objects_CXX" | $SED "$delay_single_quote_subst"`' +postdep_objects_CXX='`$ECHO "$postdep_objects_CXX" | $SED "$delay_single_quote_subst"`' +predeps_CXX='`$ECHO "$predeps_CXX" | $SED "$delay_single_quote_subst"`' +postdeps_CXX='`$ECHO "$postdeps_CXX" | $SED "$delay_single_quote_subst"`' +compiler_lib_search_path_CXX='`$ECHO "$compiler_lib_search_path_CXX" | $SED "$delay_single_quote_subst"`' + +LTCC='$LTCC' +LTCFLAGS='$LTCFLAGS' +compiler='$compiler_DEFAULT' + +# A function that is used when there is no print builtin or printf. +func_fallback_echo () +{ + eval 'cat <<_LTECHO_EOF +\$1 +_LTECHO_EOF' +} + +# Quote evaled strings. +for var in AS \ +DLLTOOL \ +OBJDUMP \ +SHELL \ +ECHO \ +PATH_SEPARATOR \ +SED \ +GREP \ +EGREP \ +FGREP \ +LD \ +NM \ +LN_S \ +lt_SP2NL \ +lt_NL2SP \ +reload_flag \ +deplibs_check_method \ +file_magic_cmd \ +file_magic_glob \ +want_nocaseglob \ +sharedlib_from_linklib_cmd \ +AR \ +AR_FLAGS \ +archiver_list_spec \ +STRIP \ +RANLIB \ +CC \ +CFLAGS \ +compiler \ +lt_cv_sys_global_symbol_pipe \ +lt_cv_sys_global_symbol_to_cdecl \ +lt_cv_sys_global_symbol_to_c_name_address \ +lt_cv_sys_global_symbol_to_c_name_address_lib_prefix \ +nm_file_list_spec \ +lt_prog_compiler_no_builtin_flag \ +lt_prog_compiler_pic \ +lt_prog_compiler_wl \ +lt_prog_compiler_static \ +lt_cv_prog_compiler_c_o \ +need_locks \ +MANIFEST_TOOL \ +DSYMUTIL \ +NMEDIT \ +LIPO \ +OTOOL \ +OTOOL64 \ +shrext_cmds \ +export_dynamic_flag_spec \ +whole_archive_flag_spec \ +compiler_needs_object \ +with_gnu_ld \ +allow_undefined_flag \ +no_undefined_flag \ +hardcode_libdir_flag_spec \ +hardcode_libdir_separator \ +exclude_expsyms \ +include_expsyms \ +file_list_spec \ +variables_saved_for_relink \ +libname_spec \ +library_names_spec \ +soname_spec \ +install_override_mode \ +finish_eval \ +old_striplib \ +striplib \ +compiler_lib_search_dirs \ +predep_objects \ +postdep_objects \ +predeps \ +postdeps \ +compiler_lib_search_path \ +LD_CXX \ +reload_flag_CXX \ +compiler_CXX \ +lt_prog_compiler_no_builtin_flag_CXX \ +lt_prog_compiler_pic_CXX \ +lt_prog_compiler_wl_CXX \ +lt_prog_compiler_static_CXX \ +lt_cv_prog_compiler_c_o_CXX \ +export_dynamic_flag_spec_CXX \ +whole_archive_flag_spec_CXX \ +compiler_needs_object_CXX \ +with_gnu_ld_CXX \ +allow_undefined_flag_CXX \ +no_undefined_flag_CXX \ +hardcode_libdir_flag_spec_CXX \ +hardcode_libdir_separator_CXX \ +exclude_expsyms_CXX \ +include_expsyms_CXX \ +file_list_spec_CXX \ +compiler_lib_search_dirs_CXX \ +predep_objects_CXX \ +postdep_objects_CXX \ +predeps_CXX \ +postdeps_CXX \ +compiler_lib_search_path_CXX; do + case \`eval \\\\\$ECHO \\\\""\\\\\$\$var"\\\\"\` in + *[\\\\\\\`\\"\\\$]*) + eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"\\\$\$var\\" | \\\$SED \\"\\\$sed_quote_subst\\"\\\`\\\\\\"" + ;; + *) + eval "lt_\$var=\\\\\\"\\\$\$var\\\\\\"" + ;; + esac +done + +# Double-quote double-evaled strings. +for var in reload_cmds \ +old_postinstall_cmds \ +old_postuninstall_cmds \ +old_archive_cmds \ +extract_expsyms_cmds \ +old_archive_from_new_cmds \ +old_archive_from_expsyms_cmds \ +archive_cmds \ +archive_expsym_cmds \ +module_cmds \ +module_expsym_cmds \ +export_symbols_cmds \ +prelink_cmds \ +postlink_cmds \ +postinstall_cmds \ +postuninstall_cmds \ +finish_cmds \ +sys_lib_search_path_spec \ +sys_lib_dlsearch_path_spec \ +reload_cmds_CXX \ +old_archive_cmds_CXX \ +old_archive_from_new_cmds_CXX \ +old_archive_from_expsyms_cmds_CXX \ +archive_cmds_CXX \ +archive_expsym_cmds_CXX \ +module_cmds_CXX \ +module_expsym_cmds_CXX \ +export_symbols_cmds_CXX \ +prelink_cmds_CXX \ +postlink_cmds_CXX; do + case \`eval \\\\\$ECHO \\\\""\\\\\$\$var"\\\\"\` in + *[\\\\\\\`\\"\\\$]*) + eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"\\\$\$var\\" | \\\$SED -e \\"\\\$double_quote_subst\\" -e \\"\\\$sed_quote_subst\\" -e \\"\\\$delay_variable_subst\\"\\\`\\\\\\"" + ;; + *) + eval "lt_\$var=\\\\\\"\\\$\$var\\\\\\"" + ;; + esac +done + +ac_aux_dir='$ac_aux_dir' +xsi_shell='$xsi_shell' +lt_shell_append='$lt_shell_append' + +# See if we are running on zsh, and set the options which allow our +# commands through without removal of \ escapes INIT. +if test -n "\${ZSH_VERSION+set}" ; then + setopt NO_GLOB_SUBST +fi + + + PACKAGE='$PACKAGE' + VERSION='$VERSION' + TIMESTAMP='$TIMESTAMP' + RM='$RM' + ofile='$ofile' + + + + + +_LTEOF + +cat >>"$CONFIG_LT" <<\_LTEOF +{ $as_echo "$as_me:${as_lineno-$LINENO}: creating $ofile" >&5 +$as_echo "$as_me: creating $ofile" >&6;} + + + # See if we are running on zsh, and set the options which allow our + # commands through without removal of \ escapes. + if test -n "${ZSH_VERSION+set}" ; then + setopt NO_GLOB_SUBST + fi + + cfgfile="${ofile}T" + trap "$RM \"$cfgfile\"; exit 1" 1 2 15 + $RM "$cfgfile" + + cat <<_LT_EOF >> "$cfgfile" +#! $SHELL + +# `$ECHO "$ofile" | sed 's%^.*/%%'` - Provide generalized library-building support services. +# Generated automatically by $as_me ($PACKAGE$TIMESTAMP) $VERSION +# Libtool was configured on host `(hostname || uname -n) 2>/dev/null | sed 1q`: +# NOTE: Changes made to this file will be lost: look at ltmain.sh. +# +# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, +# 2006, 2007, 2008, 2009, 2010, 2011 Free Software +# Foundation, Inc. +# Written by Gordon Matzigkeit, 1996 +# +# This file is part of GNU Libtool. +# +# GNU Libtool is free software; you can redistribute it and/or +# modify it under the terms of the GNU General Public License as +# published by the Free Software Foundation; either version 2 of +# the License, or (at your option) any later version. +# +# As a special exception to the GNU General Public License, +# if you distribute this file as part of a program or library that +# is built using GNU Libtool, you may include this file under the +# same distribution terms that you use for the rest of that program. +# +# GNU Libtool is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with GNU Libtool; see the file COPYING. If not, a copy +# can be downloaded from http://www.gnu.org/licenses/gpl.html, or +# obtained by writing to the Free Software Foundation, Inc., +# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + + +# The names of the tagged configurations supported by this script. +available_tags="CXX " + +# ### BEGIN LIBTOOL CONFIG + +# Which release of libtool.m4 was used? +macro_version=$macro_version +macro_revision=$macro_revision + +# Assembler program. +AS=$lt_AS + +# DLL creation program. +DLLTOOL=$lt_DLLTOOL + +# Object dumper program. +OBJDUMP=$lt_OBJDUMP + +# Whether or not to build shared libraries. +build_libtool_libs=$enable_shared + +# Whether or not to build static libraries. +build_old_libs=$enable_static + +# What type of objects to build. +pic_mode=$pic_mode + +# Whether or not to optimize for fast installation. +fast_install=$enable_fast_install + +# Shell to use when invoking shell scripts. +SHELL=$lt_SHELL + +# An echo program that protects backslashes. +ECHO=$lt_ECHO + +# The PATH separator for the build system. +PATH_SEPARATOR=$lt_PATH_SEPARATOR + +# The host system. +host_alias=$host_alias +host=$host +host_os=$host_os + +# The build system. +build_alias=$build_alias +build=$build +build_os=$build_os + +# A sed program that does not truncate output. +SED=$lt_SED + +# Sed that helps us avoid accidentally triggering echo(1) options like -n. +Xsed="\$SED -e 1s/^X//" + +# A grep program that handles long lines. +GREP=$lt_GREP + +# An ERE matcher. +EGREP=$lt_EGREP + +# A literal string matcher. +FGREP=$lt_FGREP + +# A BSD- or MS-compatible name lister. +NM=$lt_NM + +# Whether we need soft or hard links. +LN_S=$lt_LN_S + +# What is the maximum length of a command? +max_cmd_len=$max_cmd_len + +# Object file suffix (normally "o"). +objext=$ac_objext + +# Executable file suffix (normally ""). +exeext=$exeext + +# whether the shell understands "unset". +lt_unset=$lt_unset + +# turn spaces into newlines. +SP2NL=$lt_lt_SP2NL + +# turn newlines into spaces. +NL2SP=$lt_lt_NL2SP + +# convert \$build file names to \$host format. +to_host_file_cmd=$lt_cv_to_host_file_cmd + +# convert \$build files to toolchain format. +to_tool_file_cmd=$lt_cv_to_tool_file_cmd + +# Method to check whether dependent libraries are shared objects. +deplibs_check_method=$lt_deplibs_check_method + +# Command to use when deplibs_check_method = "file_magic". +file_magic_cmd=$lt_file_magic_cmd + +# How to find potential files when deplibs_check_method = "file_magic". +file_magic_glob=$lt_file_magic_glob + +# Find potential files using nocaseglob when deplibs_check_method = "file_magic". +want_nocaseglob=$lt_want_nocaseglob + +# Command to associate shared and link libraries. +sharedlib_from_linklib_cmd=$lt_sharedlib_from_linklib_cmd + +# The archiver. +AR=$lt_AR + +# Flags to create an archive. +AR_FLAGS=$lt_AR_FLAGS + +# How to feed a file listing to the archiver. +archiver_list_spec=$lt_archiver_list_spec + +# A symbol stripping program. +STRIP=$lt_STRIP + +# Commands used to install an old-style archive. +RANLIB=$lt_RANLIB +old_postinstall_cmds=$lt_old_postinstall_cmds +old_postuninstall_cmds=$lt_old_postuninstall_cmds + +# Whether to use a lock for old archive extraction. +lock_old_archive_extraction=$lock_old_archive_extraction + +# A C compiler. +LTCC=$lt_CC + +# LTCC compiler flags. +LTCFLAGS=$lt_CFLAGS + +# Take the output of nm and produce a listing of raw symbols and C names. +global_symbol_pipe=$lt_lt_cv_sys_global_symbol_pipe + +# Transform the output of nm in a proper C declaration. +global_symbol_to_cdecl=$lt_lt_cv_sys_global_symbol_to_cdecl + +# Transform the output of nm in a C name address pair. +global_symbol_to_c_name_address=$lt_lt_cv_sys_global_symbol_to_c_name_address + +# Transform the output of nm in a C name address pair when lib prefix is needed. +global_symbol_to_c_name_address_lib_prefix=$lt_lt_cv_sys_global_symbol_to_c_name_address_lib_prefix + +# Specify filename containing input files for \$NM. +nm_file_list_spec=$lt_nm_file_list_spec + +# The root where to search for dependent libraries,and in which our libraries should be installed. +lt_sysroot=$lt_sysroot + +# The name of the directory that contains temporary libtool files. +objdir=$objdir + +# Used to examine libraries when file_magic_cmd begins with "file". +MAGIC_CMD=$MAGIC_CMD + +# Must we lock files when doing compilation? +need_locks=$lt_need_locks + +# Manifest tool. +MANIFEST_TOOL=$lt_MANIFEST_TOOL + +# Tool to manipulate archived DWARF debug symbol files on Mac OS X. +DSYMUTIL=$lt_DSYMUTIL + +# Tool to change global to local symbols on Mac OS X. +NMEDIT=$lt_NMEDIT + +# Tool to manipulate fat objects and archives on Mac OS X. +LIPO=$lt_LIPO + +# ldd/readelf like tool for Mach-O binaries on Mac OS X. +OTOOL=$lt_OTOOL + +# ldd/readelf like tool for 64 bit Mach-O binaries on Mac OS X 10.4. +OTOOL64=$lt_OTOOL64 + +# Old archive suffix (normally "a"). +libext=$libext + +# Shared library suffix (normally ".so"). +shrext_cmds=$lt_shrext_cmds + +# The commands to extract the exported symbol list from a shared archive. +extract_expsyms_cmds=$lt_extract_expsyms_cmds + +# Variables whose values should be saved in libtool wrapper scripts and +# restored at link time. +variables_saved_for_relink=$lt_variables_saved_for_relink + +# Do we need the "lib" prefix for modules? +need_lib_prefix=$need_lib_prefix + +# Do we need a version for libraries? +need_version=$need_version + +# Library versioning type. +version_type=$version_type + +# Shared library runtime path variable. +runpath_var=$runpath_var + +# Shared library path variable. +shlibpath_var=$shlibpath_var + +# Is shlibpath searched before the hard-coded library search path? +shlibpath_overrides_runpath=$shlibpath_overrides_runpath + +# Format of library name prefix. +libname_spec=$lt_libname_spec + +# List of archive names. First name is the real one, the rest are links. +# The last name is the one that the linker finds with -lNAME +library_names_spec=$lt_library_names_spec + +# The coded name of the library, if different from the real name. +soname_spec=$lt_soname_spec + +# Permission mode override for installation of shared libraries. +install_override_mode=$lt_install_override_mode + +# Command to use after installation of a shared archive. +postinstall_cmds=$lt_postinstall_cmds + +# Command to use after uninstallation of a shared archive. +postuninstall_cmds=$lt_postuninstall_cmds + +# Commands used to finish a libtool library installation in a directory. +finish_cmds=$lt_finish_cmds + +# As "finish_cmds", except a single script fragment to be evaled but +# not shown. +finish_eval=$lt_finish_eval + +# Whether we should hardcode library paths into libraries. +hardcode_into_libs=$hardcode_into_libs + +# Compile-time system search path for libraries. +sys_lib_search_path_spec=$lt_sys_lib_search_path_spec + +# Run-time system search path for libraries. +sys_lib_dlsearch_path_spec=$lt_sys_lib_dlsearch_path_spec + +# Whether dlopen is supported. +dlopen_support=$enable_dlopen + +# Whether dlopen of programs is supported. +dlopen_self=$enable_dlopen_self + +# Whether dlopen of statically linked programs is supported. +dlopen_self_static=$enable_dlopen_self_static + +# Commands to strip libraries. +old_striplib=$lt_old_striplib +striplib=$lt_striplib + + +# The linker used to build libraries. +LD=$lt_LD + +# How to create reloadable object files. +reload_flag=$lt_reload_flag +reload_cmds=$lt_reload_cmds + +# Commands used to build an old-style archive. +old_archive_cmds=$lt_old_archive_cmds + +# A language specific compiler. +CC=$lt_compiler + +# Is the compiler the GNU compiler? +with_gcc=$GCC + +# Compiler flag to turn off builtin functions. +no_builtin_flag=$lt_lt_prog_compiler_no_builtin_flag + +# Additional compiler flags for building library objects. +pic_flag=$lt_lt_prog_compiler_pic + +# How to pass a linker flag through the compiler. +wl=$lt_lt_prog_compiler_wl + +# Compiler flag to prevent dynamic linking. +link_static_flag=$lt_lt_prog_compiler_static + +# Does compiler simultaneously support -c and -o options? +compiler_c_o=$lt_lt_cv_prog_compiler_c_o + +# Whether or not to add -lc for building shared libraries. +build_libtool_need_lc=$archive_cmds_need_lc + +# Whether or not to disallow shared libs when runtime libs are static. +allow_libtool_libs_with_static_runtimes=$enable_shared_with_static_runtimes + +# Compiler flag to allow reflexive dlopens. +export_dynamic_flag_spec=$lt_export_dynamic_flag_spec + +# Compiler flag to generate shared objects directly from archives. +whole_archive_flag_spec=$lt_whole_archive_flag_spec + +# Whether the compiler copes with passing no objects directly. +compiler_needs_object=$lt_compiler_needs_object + +# Create an old-style archive from a shared archive. +old_archive_from_new_cmds=$lt_old_archive_from_new_cmds + +# Create a temporary old-style archive to link instead of a shared archive. +old_archive_from_expsyms_cmds=$lt_old_archive_from_expsyms_cmds + +# Commands used to build a shared archive. +archive_cmds=$lt_archive_cmds +archive_expsym_cmds=$lt_archive_expsym_cmds + +# Commands used to build a loadable module if different from building +# a shared archive. +module_cmds=$lt_module_cmds +module_expsym_cmds=$lt_module_expsym_cmds + +# Whether we are building with GNU ld or not. +with_gnu_ld=$lt_with_gnu_ld + +# Flag that allows shared libraries with undefined symbols to be built. +allow_undefined_flag=$lt_allow_undefined_flag + +# Flag that enforces no undefined symbols. +no_undefined_flag=$lt_no_undefined_flag + +# Flag to hardcode \$libdir into a binary during linking. +# This must work even if \$libdir does not exist +hardcode_libdir_flag_spec=$lt_hardcode_libdir_flag_spec + +# Whether we need a single "-rpath" flag with a separated argument. +hardcode_libdir_separator=$lt_hardcode_libdir_separator + +# Set to "yes" if using DIR/libNAME\${shared_ext} during linking hardcodes +# DIR into the resulting binary. +hardcode_direct=$hardcode_direct + +# Set to "yes" if using DIR/libNAME\${shared_ext} during linking hardcodes +# DIR into the resulting binary and the resulting library dependency is +# "absolute",i.e impossible to change by setting \${shlibpath_var} if the +# library is relocated. +hardcode_direct_absolute=$hardcode_direct_absolute + +# Set to "yes" if using the -LDIR flag during linking hardcodes DIR +# into the resulting binary. +hardcode_minus_L=$hardcode_minus_L + +# Set to "yes" if using SHLIBPATH_VAR=DIR during linking hardcodes DIR +# into the resulting binary. +hardcode_shlibpath_var=$hardcode_shlibpath_var + +# Set to "yes" if building a shared library automatically hardcodes DIR +# into the library and all subsequent libraries and executables linked +# against it. +hardcode_automatic=$hardcode_automatic + +# Set to yes if linker adds runtime paths of dependent libraries +# to runtime path list. +inherit_rpath=$inherit_rpath + +# Whether libtool must link a program against all its dependency libraries. +link_all_deplibs=$link_all_deplibs + +# Set to "yes" if exported symbols are required. +always_export_symbols=$always_export_symbols + +# The commands to list exported symbols. +export_symbols_cmds=$lt_export_symbols_cmds + +# Symbols that should not be listed in the preloaded symbols. +exclude_expsyms=$lt_exclude_expsyms + +# Symbols that must always be exported. +include_expsyms=$lt_include_expsyms + +# Commands necessary for linking programs (against libraries) with templates. +prelink_cmds=$lt_prelink_cmds + +# Commands necessary for finishing linking programs. +postlink_cmds=$lt_postlink_cmds + +# Specify filename containing input files. +file_list_spec=$lt_file_list_spec + +# How to hardcode a shared library path into an executable. +hardcode_action=$hardcode_action + +# The directories searched by this compiler when creating a shared library. +compiler_lib_search_dirs=$lt_compiler_lib_search_dirs + +# Dependencies to place before and after the objects being linked to +# create a shared library. +predep_objects=$lt_predep_objects +postdep_objects=$lt_postdep_objects +predeps=$lt_predeps +postdeps=$lt_postdeps + +# The library search path used internally by the compiler when linking +# a shared library. +compiler_lib_search_path=$lt_compiler_lib_search_path + +# ### END LIBTOOL CONFIG + +_LT_EOF + + case $host_os in + aix3*) + cat <<\_LT_EOF >> "$cfgfile" +# AIX sometimes has problems with the GCC collect2 program. For some +# reason, if we set the COLLECT_NAMES environment variable, the problems +# vanish in a puff of smoke. +if test "X${COLLECT_NAMES+set}" != Xset; then + COLLECT_NAMES= + export COLLECT_NAMES +fi +_LT_EOF + ;; + esac + + +ltmain="$ac_aux_dir/ltmain.sh" + + + # We use sed instead of cat because bash on DJGPP gets confused if + # if finds mixed CR/LF and LF-only lines. Since sed operates in + # text mode, it properly converts lines to CR/LF. This bash problem + # is reportedly fixed, but why not run on old versions too? + sed '$q' "$ltmain" >> "$cfgfile" \ + || (rm -f "$cfgfile"; exit 1) + + if test x"$xsi_shell" = xyes; then + sed -e '/^func_dirname ()$/,/^} # func_dirname /c\ +func_dirname ()\ +{\ +\ case ${1} in\ +\ */*) func_dirname_result="${1%/*}${2}" ;;\ +\ * ) func_dirname_result="${3}" ;;\ +\ esac\ +} # Extended-shell func_dirname implementation' "$cfgfile" > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") +test 0 -eq $? || _lt_function_replace_fail=: + + + sed -e '/^func_basename ()$/,/^} # func_basename /c\ +func_basename ()\ +{\ +\ func_basename_result="${1##*/}"\ +} # Extended-shell func_basename implementation' "$cfgfile" > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") +test 0 -eq $? || _lt_function_replace_fail=: + + + sed -e '/^func_dirname_and_basename ()$/,/^} # func_dirname_and_basename /c\ +func_dirname_and_basename ()\ +{\ +\ case ${1} in\ +\ */*) func_dirname_result="${1%/*}${2}" ;;\ +\ * ) func_dirname_result="${3}" ;;\ +\ esac\ +\ func_basename_result="${1##*/}"\ +} # Extended-shell func_dirname_and_basename implementation' "$cfgfile" > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") +test 0 -eq $? || _lt_function_replace_fail=: + + + sed -e '/^func_stripname ()$/,/^} # func_stripname /c\ +func_stripname ()\ +{\ +\ # pdksh 5.2.14 does not do ${X%$Y} correctly if both X and Y are\ +\ # positional parameters, so assign one to ordinary parameter first.\ +\ func_stripname_result=${3}\ +\ func_stripname_result=${func_stripname_result#"${1}"}\ +\ func_stripname_result=${func_stripname_result%"${2}"}\ +} # Extended-shell func_stripname implementation' "$cfgfile" > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") +test 0 -eq $? || _lt_function_replace_fail=: + + + sed -e '/^func_split_long_opt ()$/,/^} # func_split_long_opt /c\ +func_split_long_opt ()\ +{\ +\ func_split_long_opt_name=${1%%=*}\ +\ func_split_long_opt_arg=${1#*=}\ +} # Extended-shell func_split_long_opt implementation' "$cfgfile" > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") +test 0 -eq $? || _lt_function_replace_fail=: + + + sed -e '/^func_split_short_opt ()$/,/^} # func_split_short_opt /c\ +func_split_short_opt ()\ +{\ +\ func_split_short_opt_arg=${1#??}\ +\ func_split_short_opt_name=${1%"$func_split_short_opt_arg"}\ +} # Extended-shell func_split_short_opt implementation' "$cfgfile" > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") +test 0 -eq $? || _lt_function_replace_fail=: + + + sed -e '/^func_lo2o ()$/,/^} # func_lo2o /c\ +func_lo2o ()\ +{\ +\ case ${1} in\ +\ *.lo) func_lo2o_result=${1%.lo}.${objext} ;;\ +\ *) func_lo2o_result=${1} ;;\ +\ esac\ +} # Extended-shell func_lo2o implementation' "$cfgfile" > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") +test 0 -eq $? || _lt_function_replace_fail=: + + + sed -e '/^func_xform ()$/,/^} # func_xform /c\ +func_xform ()\ +{\ + func_xform_result=${1%.*}.lo\ +} # Extended-shell func_xform implementation' "$cfgfile" > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") +test 0 -eq $? || _lt_function_replace_fail=: + + + sed -e '/^func_arith ()$/,/^} # func_arith /c\ +func_arith ()\ +{\ + func_arith_result=$(( $* ))\ +} # Extended-shell func_arith implementation' "$cfgfile" > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") +test 0 -eq $? || _lt_function_replace_fail=: + + + sed -e '/^func_len ()$/,/^} # func_len /c\ +func_len ()\ +{\ + func_len_result=${#1}\ +} # Extended-shell func_len implementation' "$cfgfile" > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") +test 0 -eq $? || _lt_function_replace_fail=: + +fi + +if test x"$lt_shell_append" = xyes; then + sed -e '/^func_append ()$/,/^} # func_append /c\ +func_append ()\ +{\ + eval "${1}+=\\${2}"\ +} # Extended-shell func_append implementation' "$cfgfile" > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") +test 0 -eq $? || _lt_function_replace_fail=: + + + sed -e '/^func_append_quoted ()$/,/^} # func_append_quoted /c\ +func_append_quoted ()\ +{\ +\ func_quote_for_eval "${2}"\ +\ eval "${1}+=\\\\ \\$func_quote_for_eval_result"\ +} # Extended-shell func_append_quoted implementation' "$cfgfile" > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") +test 0 -eq $? || _lt_function_replace_fail=: + + + # Save a `func_append' function call where possible by direct use of '+=' + sed -e 's%func_append \([a-zA-Z_]\{1,\}\) "%\1+="%g' $cfgfile > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") + test 0 -eq $? || _lt_function_replace_fail=: +else + # Save a `func_append' function call even when '+=' is not available + sed -e 's%func_append \([a-zA-Z_]\{1,\}\) "%\1="$\1%g' $cfgfile > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") + test 0 -eq $? || _lt_function_replace_fail=: +fi + +if test x"$_lt_function_replace_fail" = x":"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Unable to substitute extended shell functions in $ofile" >&5 +$as_echo "$as_me: WARNING: Unable to substitute extended shell functions in $ofile" >&2;} +fi + + + mv -f "$cfgfile" "$ofile" || + (rm -f "$ofile" && cp "$cfgfile" "$ofile" && rm -f "$cfgfile") + chmod +x "$ofile" + + + cat <<_LT_EOF >> "$ofile" + +# ### BEGIN LIBTOOL TAG CONFIG: CXX + +# The linker used to build libraries. +LD=$lt_LD_CXX + +# How to create reloadable object files. +reload_flag=$lt_reload_flag_CXX +reload_cmds=$lt_reload_cmds_CXX + +# Commands used to build an old-style archive. +old_archive_cmds=$lt_old_archive_cmds_CXX + +# A language specific compiler. +CC=$lt_compiler_CXX + +# Is the compiler the GNU compiler? +with_gcc=$GCC_CXX + +# Compiler flag to turn off builtin functions. +no_builtin_flag=$lt_lt_prog_compiler_no_builtin_flag_CXX + +# Additional compiler flags for building library objects. +pic_flag=$lt_lt_prog_compiler_pic_CXX + +# How to pass a linker flag through the compiler. +wl=$lt_lt_prog_compiler_wl_CXX + +# Compiler flag to prevent dynamic linking. +link_static_flag=$lt_lt_prog_compiler_static_CXX + +# Does compiler simultaneously support -c and -o options? +compiler_c_o=$lt_lt_cv_prog_compiler_c_o_CXX + +# Whether or not to add -lc for building shared libraries. +build_libtool_need_lc=$archive_cmds_need_lc_CXX + +# Whether or not to disallow shared libs when runtime libs are static. +allow_libtool_libs_with_static_runtimes=$enable_shared_with_static_runtimes_CXX + +# Compiler flag to allow reflexive dlopens. +export_dynamic_flag_spec=$lt_export_dynamic_flag_spec_CXX + +# Compiler flag to generate shared objects directly from archives. +whole_archive_flag_spec=$lt_whole_archive_flag_spec_CXX + +# Whether the compiler copes with passing no objects directly. +compiler_needs_object=$lt_compiler_needs_object_CXX + +# Create an old-style archive from a shared archive. +old_archive_from_new_cmds=$lt_old_archive_from_new_cmds_CXX + +# Create a temporary old-style archive to link instead of a shared archive. +old_archive_from_expsyms_cmds=$lt_old_archive_from_expsyms_cmds_CXX + +# Commands used to build a shared archive. +archive_cmds=$lt_archive_cmds_CXX +archive_expsym_cmds=$lt_archive_expsym_cmds_CXX + +# Commands used to build a loadable module if different from building +# a shared archive. +module_cmds=$lt_module_cmds_CXX +module_expsym_cmds=$lt_module_expsym_cmds_CXX + +# Whether we are building with GNU ld or not. +with_gnu_ld=$lt_with_gnu_ld_CXX + +# Flag that allows shared libraries with undefined symbols to be built. +allow_undefined_flag=$lt_allow_undefined_flag_CXX + +# Flag that enforces no undefined symbols. +no_undefined_flag=$lt_no_undefined_flag_CXX + +# Flag to hardcode \$libdir into a binary during linking. +# This must work even if \$libdir does not exist +hardcode_libdir_flag_spec=$lt_hardcode_libdir_flag_spec_CXX + +# Whether we need a single "-rpath" flag with a separated argument. +hardcode_libdir_separator=$lt_hardcode_libdir_separator_CXX + +# Set to "yes" if using DIR/libNAME\${shared_ext} during linking hardcodes +# DIR into the resulting binary. +hardcode_direct=$hardcode_direct_CXX + +# Set to "yes" if using DIR/libNAME\${shared_ext} during linking hardcodes +# DIR into the resulting binary and the resulting library dependency is +# "absolute",i.e impossible to change by setting \${shlibpath_var} if the +# library is relocated. +hardcode_direct_absolute=$hardcode_direct_absolute_CXX + +# Set to "yes" if using the -LDIR flag during linking hardcodes DIR +# into the resulting binary. +hardcode_minus_L=$hardcode_minus_L_CXX + +# Set to "yes" if using SHLIBPATH_VAR=DIR during linking hardcodes DIR +# into the resulting binary. +hardcode_shlibpath_var=$hardcode_shlibpath_var_CXX + +# Set to "yes" if building a shared library automatically hardcodes DIR +# into the library and all subsequent libraries and executables linked +# against it. +hardcode_automatic=$hardcode_automatic_CXX + +# Set to yes if linker adds runtime paths of dependent libraries +# to runtime path list. +inherit_rpath=$inherit_rpath_CXX + +# Whether libtool must link a program against all its dependency libraries. +link_all_deplibs=$link_all_deplibs_CXX + +# Set to "yes" if exported symbols are required. +always_export_symbols=$always_export_symbols_CXX + +# The commands to list exported symbols. +export_symbols_cmds=$lt_export_symbols_cmds_CXX + +# Symbols that should not be listed in the preloaded symbols. +exclude_expsyms=$lt_exclude_expsyms_CXX + +# Symbols that must always be exported. +include_expsyms=$lt_include_expsyms_CXX + +# Commands necessary for linking programs (against libraries) with templates. +prelink_cmds=$lt_prelink_cmds_CXX + +# Commands necessary for finishing linking programs. +postlink_cmds=$lt_postlink_cmds_CXX + +# Specify filename containing input files. +file_list_spec=$lt_file_list_spec_CXX + +# How to hardcode a shared library path into an executable. +hardcode_action=$hardcode_action_CXX + +# The directories searched by this compiler when creating a shared library. +compiler_lib_search_dirs=$lt_compiler_lib_search_dirs_CXX + +# Dependencies to place before and after the objects being linked to +# create a shared library. +predep_objects=$lt_predep_objects_CXX +postdep_objects=$lt_postdep_objects_CXX +predeps=$lt_predeps_CXX +postdeps=$lt_postdeps_CXX + +# The library search path used internally by the compiler when linking +# a shared library. +compiler_lib_search_path=$lt_compiler_lib_search_path_CXX + +# ### END LIBTOOL TAG CONFIG: CXX +_LT_EOF + + +as_fn_exit 0 +_LTEOF +chmod +x "$CONFIG_LT" + +# configure is writing to config.log, but config.lt does its own redirection, +# appending to config.log, which fails on DOS, as config.log is still kept +# open by configure. Here we exec the FD to /dev/null, effectively closing +# config.log, so it can be properly (re)opened and appended to by config.lt. +lt_cl_success=: +test "$silent" = yes && + lt_config_lt_args="$lt_config_lt_args --quiet" +exec 5>/dev/null +$SHELL "$CONFIG_LT" $lt_config_lt_args || lt_cl_success=false +exec 5>>config.log +$lt_cl_success || as_fn_exit 1 + + +# Check for threads. +# + + +threads_thread_keyword=no + +# Check whether --enable-threads was given. +if test "${enable_threads+set}" = set; then : + enableval=$enable_threads; if test x"$enableval" = xno; then : + threads=none +else + threads=check +fi +else + threads=check +fi + + +# If thread support is not disabled by the user, figure out what we can use. +# +if test x$threads = xcheck; then + case $host_os in + windows* | mingw*) + case $host_os in + mingw*) + CXXFLAGS="$CXXFLAGS -mthreads" + ;; + esac + + # Newer versions of GCC can be configured to use either Win32 or POSIX + # threads. It appears that -mthreads should be used in both cases but + # if the model is POSIX then GCC will also link -lpthread by default. + # Use that fact to test which model we have. + # + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +int +main () +{ +pthread_create(0,0,0,0); + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_link "$LINENO"; then : + threads=posix +else + threads=win32 +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext + ;; + *) + + + +ac_ext=cpp +ac_cpp='$CXXCPP $CPPFLAGS' +ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_cxx_compiler_gnu + +acx_pthread_ok=no + +# We used to check for pthread.h first, but this fails if pthread.h +# requires special compiler flags (e.g. on True64 or Sequent). +# It gets checked for in the link test anyway. + +# First of all, check if the user has set any of the PTHREAD_LIBS, +# etcetera environment variables, and if threads linking works using +# them: +if test x"$PTHREAD_LIBS$PTHREAD_CXXFLAGS" != x; then + save_CXXFLAGS="$CXXFLAGS" + CXXFLAGS="$CXXFLAGS $PTHREAD_CXXFLAGS" + save_LIBS="$LIBS" + LIBS="$PTHREAD_LIBS $LIBS" + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for pthread_join in LIBS=$PTHREAD_LIBS with CXXFLAGS=$PTHREAD_CXXFLAGS" >&5 +$as_echo_n "checking for pthread_join in LIBS=$PTHREAD_LIBS with CXXFLAGS=$PTHREAD_CXXFLAGS... " >&6; } + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char pthread_join (); +int +main () +{ +return pthread_join (); + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_link "$LINENO"; then : + acx_pthread_ok=yes +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $acx_pthread_ok" >&5 +$as_echo "$acx_pthread_ok" >&6; } + if test x"$acx_pthread_ok" = xno; then + PTHREAD_LIBS="" + PTHREAD_CXXFLAGS="" + fi + LIBS="$save_LIBS" + CXXFLAGS="$save_CXXFLAGS" +fi + +# We must check for the threads library under a number of different +# names; the ordering is very important because some systems +# (e.g. DEC) have both -lpthread and -lpthreads, where one of the +# libraries is broken (non-POSIX). + +# Create a list of thread flags to try. Items starting with a "-" are +# C compiler flags, and other items are library names, except for "none" +# which indicates that we try without any flags at all, and "pthread-config" +# which is a program returning the flags for the Pth emulation library. + +# CS: On GNU/Linux with gcc both -pthread and -lpthread are valid. +# However, libtool links libraries with -nostdlib which results in +# -pthread being stripped from the linker command line. To resolve +# this we move pthread from after -mthreads to after pthreads. +# +acx_pthread_flags="pthreads pthread none -Kthread -kthread lthread -pthread -pthreads -mthreads --thread-safe -mt pthread-config" + +# The ordering *is* (sometimes) important. Some notes on the +# individual items follow: + +# pthreads: AIX (must check this before -lpthread) +# none: in case threads are in libc; should be tried before -Kthread and +# other compiler flags to prevent continual compiler warnings +# -Kthread: Sequent (threads in libc, but -Kthread needed for pthread.h) +# -kthread: FreeBSD kernel threads (preferred to -pthread since SMP-able) +# lthread: LinuxThreads port on FreeBSD (also preferred to -pthread) +# -pthread: Linux/gcc (kernel threads), BSD/gcc (userland threads) +# -pthreads: Solaris/gcc +# -mthreads: Mingw32/gcc, Lynx/gcc +# -mt: Sun Workshop C (may only link SunOS threads [-lthread], but it +# doesn't hurt to check since this sometimes defines pthreads too; +# also defines -D_REENTRANT) +# ... -mt is also the pthreads flag for HP/aCC +# pthread: Linux, etcetera +# --thread-safe: KAI C++ +# pthread-config: use pthread-config program (for GNU Pth library) + +case "${host_cpu}-${host_os}" in + *solaris*) + + # On Solaris (at least, for some versions), libc contains stubbed + # (non-functional) versions of the pthreads routines, so link-based + # tests will erroneously succeed. (We need to link with -pthreads/-mt/ + # -lpthread.) (The stubs are missing pthread_cleanup_push, or rather + # a function called by this macro, so we could check for that, but + # who knows whether they'll stub that too in a future libc.) So, + # we'll just look for -pthreads and -lpthread first: + + # CS: Move -mt to the front of the list; Sun CC will use -mt, + # gcc will use -pthreads. + # + acx_pthread_flags="-mt -pthreads pthread -pthread $acx_pthread_flags" + ;; +esac + +if test x"$acx_pthread_ok" = xno; then +for flag in $acx_pthread_flags; do + + case $flag in + none) + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether pthreads work without any flags" >&5 +$as_echo_n "checking whether pthreads work without any flags... " >&6; } + ;; + + -*) + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether pthreads work with $flag" >&5 +$as_echo_n "checking whether pthreads work with $flag... " >&6; } + PTHREAD_CXXFLAGS="$flag" + ;; + + pthread-config) + # Extract the first word of "pthread-config", so it can be a program name with args. +set dummy pthread-config; ac_word=$2 +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 +$as_echo_n "checking for $ac_word... " >&6; } +if ${ac_cv_prog_acx_pthread_config+:} false; then : + $as_echo_n "(cached) " >&6 +else + if test -n "$acx_pthread_config"; then + ac_cv_prog_acx_pthread_config="$acx_pthread_config" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then + ac_cv_prog_acx_pthread_config="yes" + $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done + done +IFS=$as_save_IFS + + test -z "$ac_cv_prog_acx_pthread_config" && ac_cv_prog_acx_pthread_config="no" +fi +fi +acx_pthread_config=$ac_cv_prog_acx_pthread_config +if test -n "$acx_pthread_config"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $acx_pthread_config" >&5 +$as_echo "$acx_pthread_config" >&6; } +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } +fi + + + if test x"$acx_pthread_config" = xno; then continue; fi + PTHREAD_CXXFLAGS="`pthread-config --cflags`" + PTHREAD_LIBS="`pthread-config --ldflags` `pthread-config --libs`" + ;; + + *) + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for the pthreads library -l$flag" >&5 +$as_echo_n "checking for the pthreads library -l$flag... " >&6; } + PTHREAD_LIBS="-l$flag" + ;; + esac + + save_LIBS="$LIBS" + save_CXXFLAGS="$CXXFLAGS" + LIBS="$PTHREAD_LIBS $LIBS" + CXXFLAGS="$CXXFLAGS $PTHREAD_CXXFLAGS" + + # Check for various functions. We must include pthread.h, + # since some functions may be macros. (On the Sequent, we + # need a special flag -Kthread to make this header compile.) + # We check for pthread_join because it is in -lpthread on IRIX + # while pthread_create is in libc. We check for pthread_attr_init + # due to DEC craziness with -lpthreads. We check for + # pthread_cleanup_push because it is one of the few pthread + # functions on Solaris that doesn't have a non-functional libc stub. + # We try pthread_create on general principles. + # + cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ +#include +int +main () +{ +pthread_t th; pthread_join(th, 0); + pthread_attr_init(0); pthread_cleanup_push(0, 0); + pthread_create(0,0,0,0); pthread_cleanup_pop(0); + ; + return 0; +} +_ACEOF +if ac_fn_cxx_try_link "$LINENO"; then : + acx_pthread_ok=yes +fi +rm -f core conftest.err conftest.$ac_objext \ + conftest$ac_exeext conftest.$ac_ext + + LIBS="$save_LIBS" + CXXFLAGS="$save_CXXFLAGS" + + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $acx_pthread_ok" >&5 +$as_echo "$acx_pthread_ok" >&6; } + if test "x$acx_pthread_ok" = xyes; then + break; + fi + + PTHREAD_LIBS="" + PTHREAD_CXXFLAGS="" +done +fi + +# Various other checks: +if test "x$acx_pthread_ok" = xyes; then + save_LIBS="$LIBS" + LIBS="$PTHREAD_LIBS $LIBS" + save_CXXFLAGS="$CXXFLAGS" + CXXFLAGS="$CXXFLAGS $PTHREAD_CXXFLAGS" + + + { $as_echo "$as_me:${as_lineno-$LINENO}: checking if more special flags are required for pthreads" >&5 +$as_echo_n "checking if more special flags are required for pthreads... " >&6; } + flag=no + case "${host_cpu}-${host_os}" in + *-aix* | *-freebsd* | *-darwin*) flag="-D_THREAD_SAFE";; + # CS: Add _REENTRANT in Linux to emulate -pthread. + # + *-linux* | *solaris* | *-osf* | *-hpux*) flag="-D_REENTRANT";; + esac + { $as_echo "$as_me:${as_lineno-$LINENO}: result: ${flag}" >&5 +$as_echo "${flag}" >&6; } + if test "x$flag" != xno; then + PTHREAD_CXXFLAGS="$flag $PTHREAD_CXXFLAGS" + fi + + LIBS="$save_LIBS" + CXXFLAGS="$save_CXXFLAGS" + + +else + PTHREAD_CXX="$CXX" +fi + + + + + +# Finally, execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND: +if test x"$acx_pthread_ok" = xyes; then + +$as_echo "#define HAVE_PTHREAD 1" >>confdefs.h + + : +else + acx_pthread_ok=no + +fi +ac_ext=cpp +ac_cpp='$CXXCPP $CPPFLAGS' +ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_cxx_compiler_gnu + + + + if test x$acx_pthread_ok = xyes; then + threads=posix + LIBS="$LIBS $PTHREAD_LIBS" + CXXFLAGS="$CXXFLAGS $PTHREAD_CXXFLAGS" + + # Check if we can use the __thread keyword. + # + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for __thread keyword" >&5 +$as_echo_n "checking for __thread keyword... " >&6; } + + + +ac_ext=cpp +ac_cpp='$CXXCPP $CPPFLAGS' +ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_cxx_compiler_gnu + + +if test -d .libs; then + delete_libs_dir=no +else + delete_libs_dir=yes +fi + +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + + + __thread int tls_var; + + int + main () + { + tls_var = 0; + } + +_ACEOF +if ac_fn_cxx_try_compile "$LINENO"; then : + + ac_try='./libtool --tag=CXX --mode=link $CXX -no-install $CXXFLAGS $LDFLAGS -o conftest conftest.$OBJEXT $LIBS >&5' + if { { case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_try") 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then + libtool_link_ok=yes + else + libtool_link_ok=no + fi + +else + + libtool_link_ok=no + +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext + +if test x"$delete_libs_dir" = xyes; then + rm -rf .libs +fi + +if test x"$libtool_link_ok" = xyes; then +threads_thread_keyword=yes +: +else + +: +fi + +ac_ext=cpp +ac_cpp='$CXXCPP $CPPFLAGS' +ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_cxx_compiler_gnu + + + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $threads_thread_keyword" >&5 +$as_echo "$threads_thread_keyword" >&6; } + fi + ;; + esac +fi + +if test x$threads = xcheck; then + as_fn_error $? "thread support not available; use --disable-threads to force single-threaded mode" "$LINENO" 5 +fi + + +# Check for libsqlite. +# + +libsqlite_found=no +libsqlite_unlock_notify=no + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for libsqlite3" >&5 +$as_echo_n "checking for libsqlite3... " >&6; } + +save_LIBS="$LIBS" +LIBS="-lsqlite3 $LIBS" + + + +ac_ext=cpp +ac_cpp='$CXXCPP $CPPFLAGS' +ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_cxx_compiler_gnu + + +if test -d .libs; then + delete_libs_dir=no +else + delete_libs_dir=yes +fi + +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + + +#include + +int +main () +{ + sqlite3* handle; + sqlite3_open ("", &handle); + sqlite3_stmt* stmt; + sqlite3_prepare (handle, "", 0, &stmt, 0); + sqlite3_finalize (stmt); + sqlite3_close (handle); +} + +_ACEOF +if ac_fn_cxx_try_compile "$LINENO"; then : + + ac_try='./libtool --tag=CXX --mode=link $CXX -no-install $CXXFLAGS $LDFLAGS -o conftest conftest.$OBJEXT $LIBS >&5' + if { { case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_try") 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then + libtool_link_ok=yes + else + libtool_link_ok=no + fi + +else + + libtool_link_ok=no + +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext + +if test x"$delete_libs_dir" = xyes; then + rm -rf .libs +fi + +if test x"$libtool_link_ok" = xyes; then + +libsqlite_found=yes + +: +else + +: +fi + +ac_ext=cpp +ac_cpp='$CXXCPP $CPPFLAGS' +ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_cxx_compiler_gnu + + +if test x"$libsqlite_found" = xno; then + LIBS="$save_LIBS" +fi + +# Check for unlock_notify. +# +if test x"$libsqlite_found" = xyes; then + + +ac_ext=cpp +ac_cpp='$CXXCPP $CPPFLAGS' +ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_cxx_compiler_gnu + + +if test -d .libs; then + delete_libs_dir=no +else + delete_libs_dir=yes +fi + +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + + +#include + +int +main () +{ + sqlite3* handle (0); + sqlite3_unlock_notify (handle, 0, 0); +} + +_ACEOF +if ac_fn_cxx_try_compile "$LINENO"; then : + + ac_try='./libtool --tag=CXX --mode=link $CXX -no-install $CXXFLAGS $LDFLAGS -o conftest conftest.$OBJEXT $LIBS >&5' + if { { case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_try") 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then + libtool_link_ok=yes + else + libtool_link_ok=no + fi + +else + + libtool_link_ok=no + +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext + +if test x"$delete_libs_dir" = xyes; then + rm -rf .libs +fi + +if test x"$libtool_link_ok" = xyes; then + +libsqlite_unlock_notify=yes + +: +else + +: +fi + +ac_ext=cpp +ac_cpp='$CXXCPP $CPPFLAGS' +ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_cxx_compiler_gnu + +fi + +if test x"$libsqlite_found" = xyes; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +$as_echo "yes" >&6; } + +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } + as_fn_error $? "libsqlite3 is not found; consider using CPPFLAGS/LDFLAGS to specify its location" "$LINENO" 5 +fi + + +if test x$libsqlite_unlock_notify = xyes; then : + +$as_echo "#define LIBODB_SQLITE_HAVE_UNLOCK_NOTIFY 1" >>confdefs.h + +fi + +if test x$threads != xnone -a x$libsqlite_unlock_notify = xno; then : + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: libsqlite3 is built without sqlite3_unlock_notify support; multi-threaded support will be limited" >&5 +$as_echo "$as_me: WARNING: libsqlite3 is built without sqlite3_unlock_notify support; multi-threaded support will be limited" >&2;} +fi + +# Check for libodb. +# + +libodb_found=no + + +# Check whether --with-libodb was given. +if test "${with_libodb+set}" = set; then : + withval=$with_libodb; libodb_dir=${withval} +else + libodb_dir= +fi + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for libodb" >&5 +$as_echo_n "checking for libodb... " >&6; } + +# If libodb_dir was given, add the necessary preprocessor and linker flags. +# +if test x"$libodb_dir" != x; then + save_CPPFLAGS="$CPPFLAGS" + save_LDFLAGS="$LDFLAGS" + + case $ac_pwd in #(( +.) abs_libodb_dir=$libodb_dir;; +*) + case $libodb_dir in #((( + .) abs_libodb_dir=$ac_pwd;; + [\\/]* | ?:[\\/]* ) abs_libodb_dir=$libodb_dir;; + *) abs_libodb_dir=$ac_pwd/$libodb_dir;; + esac;; +esac + + CPPFLAGS="$CPPFLAGS -I$abs_libodb_dir" + LDFLAGS="$LDFLAGS -L$abs_libodb_dir/odb" +fi + +save_LIBS="$LIBS" +LIBS="-lodb $LIBS" + + + +ac_ext=cpp +ac_cpp='$CXXCPP $CPPFLAGS' +ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_cxx_compiler_gnu + + +if test -d .libs; then + delete_libs_dir=no +else + delete_libs_dir=yes +fi + +cat confdefs.h - <<_ACEOF >conftest.$ac_ext +/* end confdefs.h. */ + + +#include + +void +f () +{ +} + +const char* +g () +{ + try + { + f (); + } + catch (const odb::exception& e) + { + return e.what (); + } + return 0; +} + +int +main () +{ + const char* m (g ()); + return m != 0; +} + +_ACEOF +if ac_fn_cxx_try_compile "$LINENO"; then : + + ac_try='./libtool --tag=CXX --mode=link $CXX -no-install $CXXFLAGS $LDFLAGS -o conftest conftest.$OBJEXT $LIBS >&5' + if { { case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" +$as_echo "$ac_try_echo"; } >&5 + (eval "$ac_try") 2>&5 + ac_status=$? + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 + test $ac_status = 0; }; then + libtool_link_ok=yes + else + libtool_link_ok=no + fi + +else + + libtool_link_ok=no + +fi +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext + +if test x"$delete_libs_dir" = xyes; then + rm -rf .libs +fi + +if test x"$libtool_link_ok" = xyes; then +libodb_found=yes +: +else + +: +fi + +ac_ext=cpp +ac_cpp='$CXXCPP $CPPFLAGS' +ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5' +ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' +ac_compiler_gnu=$ac_cv_cxx_compiler_gnu + + +if test x"$libodb_found" = xno; then + LIBS="$save_LIBS" + + if test x"$libodb_dir" != x; then + CPPFLAGS="$save_CPPFLAGS" + LDFLAGS="$save_LDFLAGS" + fi +fi + +if test x"$libodb_found" = xyes; then + { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +$as_echo "yes" >&6; } + +else + { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 +$as_echo "no" >&6; } + as_fn_error $? "libodb is not found; consider using --with-libodb=DIR" "$LINENO" 5 +fi + + +# Define LIBODB_SQLITE_STATIC_LIB if we are build static library on certain +# platforms. +# + +if test x$enable_shared = xno; then + case $host_os in + mingw*) + +$as_echo "#define LIBODB_SQLITE_STATIC_LIB 1" >>confdefs.h + + ;; + esac +fi + + +# Allow the user to specify the pkgconfig directory. +# + + +# Check whether --with-pkgconfigdir was given. +if test "${with_pkgconfigdir+set}" = set; then : + withval=$with_pkgconfigdir; pkgconfigdir=${withval} +else + pkgconfigdir='${libdir}/pkgconfig' +fi + + + + +# Check if we should disable rpath. +# + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to use rpath" >&5 +$as_echo_n "checking whether to use rpath... " >&6; } +# Check whether --enable-rpath was given. +if test "${enable_rpath+set}" = set; then : + enableval=$enable_rpath; libtool_rpath="$enable_rpath" +else + libtool_rpath="yes" +fi + +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $libtool_rpath" >&5 +$as_echo "$libtool_rpath" >&6; } + +# Patch libtool to not use rpath if requested. +# +ac_config_commands="$ac_config_commands libtool-rpath-patch" + + + +# Output. +# +ac_config_headers="$ac_config_headers odb/sqlite/config.h odb/sqlite/details/config.h" + +ac_config_files="$ac_config_files libodb-sqlite.pc Makefile odb/sqlite/Makefile" + +cat >confcache <<\_ACEOF +# This file is a shell script that caches the results of configure +# tests run on this system so they can be shared between configure +# scripts and configure runs, see configure's option --config-cache. +# It is not useful on other systems. If it contains results you don't +# want to keep, you may remove or edit it. +# +# config.status only pays attention to the cache file if you give it +# the --recheck option to rerun configure. +# +# `ac_cv_env_foo' variables (set or unset) will be overridden when +# loading this file, other *unset* `ac_cv_foo' will be assigned the +# following values. + +_ACEOF + +# The following way of writing the cache mishandles newlines in values, +# but we know of no workaround that is simple, portable, and efficient. +# So, we kill variables containing newlines. +# Ultrix sh set writes to stderr and can't be redirected directly, +# and sets the high bit in the cache file unless we assign to the vars. +( + for ac_var in `(set) 2>&1 | sed -n 's/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'`; do + eval ac_val=\$$ac_var + case $ac_val in #( + *${as_nl}*) + case $ac_var in #( + *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5 +$as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;; + esac + case $ac_var in #( + _ | IFS | as_nl) ;; #( + BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #( + *) { eval $ac_var=; unset $ac_var;} ;; + esac ;; + esac + done + + (set) 2>&1 | + case $as_nl`(ac_space=' '; set) 2>&1` in #( + *${as_nl}ac_space=\ *) + # `set' does not quote correctly, so add quotes: double-quote + # substitution turns \\\\ into \\, and sed turns \\ into \. + sed -n \ + "s/'/'\\\\''/g; + s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p" + ;; #( + *) + # `set' quotes correctly as required by POSIX, so do not add quotes. + sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p" + ;; + esac | + sort +) | + sed ' + /^ac_cv_env_/b end + t clear + :clear + s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/ + t end + s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/ + :end' >>confcache +if diff "$cache_file" confcache >/dev/null 2>&1; then :; else + if test -w "$cache_file"; then + if test "x$cache_file" != "x/dev/null"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: updating cache $cache_file" >&5 +$as_echo "$as_me: updating cache $cache_file" >&6;} + if test ! -f "$cache_file" || test -h "$cache_file"; then + cat confcache >"$cache_file" + else + case $cache_file in #( + */* | ?:*) + mv -f confcache "$cache_file"$$ && + mv -f "$cache_file"$$ "$cache_file" ;; #( + *) + mv -f confcache "$cache_file" ;; + esac + fi + fi + else + { $as_echo "$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file" >&5 +$as_echo "$as_me: not updating unwritable cache $cache_file" >&6;} + fi +fi +rm -f confcache + +test "x$prefix" = xNONE && prefix=$ac_default_prefix +# Let make expand exec_prefix. +test "x$exec_prefix" = xNONE && exec_prefix='${prefix}' + +DEFS=-DHAVE_CONFIG_H + +ac_libobjs= +ac_ltlibobjs= +U= +for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue + # 1. Remove the extension, and $U if already installed. + ac_script='s/\$U\././;s/\.o$//;s/\.obj$//' + ac_i=`$as_echo "$ac_i" | sed "$ac_script"` + # 2. Prepend LIBOBJDIR. When used with automake>=1.10 LIBOBJDIR + # will be set to the directory where LIBOBJS objects are built. + as_fn_append ac_libobjs " \${LIBOBJDIR}$ac_i\$U.$ac_objext" + as_fn_append ac_ltlibobjs " \${LIBOBJDIR}$ac_i"'$U.lo' +done +LIBOBJS=$ac_libobjs + +LTLIBOBJS=$ac_ltlibobjs + + +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking that generated files are newer than configure" >&5 +$as_echo_n "checking that generated files are newer than configure... " >&6; } + if test -n "$am_sleep_pid"; then + # Hide warnings about reused PIDs. + wait $am_sleep_pid 2>/dev/null + fi + { $as_echo "$as_me:${as_lineno-$LINENO}: result: done" >&5 +$as_echo "done" >&6; } + if test -n "$EXEEXT"; then + am__EXEEXT_TRUE= + am__EXEEXT_FALSE='#' +else + am__EXEEXT_TRUE='#' + am__EXEEXT_FALSE= +fi + +if test -z "${AMDEP_TRUE}" && test -z "${AMDEP_FALSE}"; then + as_fn_error $? "conditional \"AMDEP\" was never defined. +Usually this means the macro was only invoked conditionally." "$LINENO" 5 +fi +if test -z "${am__fastdepCC_TRUE}" && test -z "${am__fastdepCC_FALSE}"; then + as_fn_error $? "conditional \"am__fastdepCC\" was never defined. +Usually this means the macro was only invoked conditionally." "$LINENO" 5 +fi +if test -z "${am__fastdepCXX_TRUE}" && test -z "${am__fastdepCXX_FALSE}"; then + as_fn_error $? "conditional \"am__fastdepCXX\" was never defined. +Usually this means the macro was only invoked conditionally." "$LINENO" 5 +fi + +: "${CONFIG_STATUS=./config.status}" +ac_write_fail=0 +ac_clean_files_save=$ac_clean_files +ac_clean_files="$ac_clean_files $CONFIG_STATUS" +{ $as_echo "$as_me:${as_lineno-$LINENO}: creating $CONFIG_STATUS" >&5 +$as_echo "$as_me: creating $CONFIG_STATUS" >&6;} +as_write_fail=0 +cat >$CONFIG_STATUS <<_ASEOF || as_write_fail=1 +#! $SHELL +# Generated by $as_me. +# Run this file to recreate the current configuration. +# Compiler output produced by configure, useful for debugging +# configure, is in config.log if it exists. + +debug=false +ac_cs_recheck=false +ac_cs_silent=false + +SHELL=\${CONFIG_SHELL-$SHELL} +export SHELL +_ASEOF +cat >>$CONFIG_STATUS <<\_ASEOF || as_write_fail=1 +## -------------------- ## +## M4sh Initialization. ## +## -------------------- ## + +# Be more Bourne compatible +DUALCASE=1; export DUALCASE # for MKS sh +if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then : + emulate sh + NULLCMD=: + # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which + # is contrary to our usage. Disable this feature. + alias -g '${1+"$@"}'='"$@"' + setopt NO_GLOB_SUBST +else + case `(set -o) 2>/dev/null` in #( + *posix*) : + set -o posix ;; #( + *) : + ;; +esac +fi + + +as_nl=' +' +export as_nl +# Printing a long string crashes Solaris 7 /usr/bin/printf. +as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' +as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo +as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo +# Prefer a ksh shell builtin over an external printf program on Solaris, +# but without wasting forks for bash or zsh. +if test -z "$BASH_VERSION$ZSH_VERSION" \ + && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then + as_echo='print -r --' + as_echo_n='print -rn --' +elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then + as_echo='printf %s\n' + as_echo_n='printf %s' +else + if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then + as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"' + as_echo_n='/usr/ucb/echo -n' + else + as_echo_body='eval expr "X$1" : "X\\(.*\\)"' + as_echo_n_body='eval + arg=$1; + case $arg in #( + *"$as_nl"*) + expr "X$arg" : "X\\(.*\\)$as_nl"; + arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;; + esac; + expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl" + ' + export as_echo_n_body + as_echo_n='sh -c $as_echo_n_body as_echo' + fi + export as_echo_body + as_echo='sh -c $as_echo_body as_echo' +fi + +# The user is always right. +if test "${PATH_SEPARATOR+set}" != set; then + PATH_SEPARATOR=: + (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && { + (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 || + PATH_SEPARATOR=';' + } +fi + + +# IFS +# We need space, tab and new line, in precisely that order. Quoting is +# there to prevent editors from complaining about space-tab. +# (If _AS_PATH_WALK were called with IFS unset, it would disable word +# splitting by setting IFS to empty value.) +IFS=" "" $as_nl" + +# Find who we are. Look in the path if we contain no directory separator. +as_myself= +case $0 in #(( + *[\\/]* ) as_myself=$0 ;; + *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break + done +IFS=$as_save_IFS + + ;; +esac +# We did not find ourselves, most probably we were run as `sh COMMAND' +# in which case we are not to be found in the path. +if test "x$as_myself" = x; then + as_myself=$0 +fi +if test ! -f "$as_myself"; then + $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2 + exit 1 +fi + +# Unset variables that we do not need and which cause bugs (e.g. in +# pre-3.0 UWIN ksh). But do not cause bugs in bash 2.01; the "|| exit 1" +# suppresses any "Segmentation fault" message there. '((' could +# trigger a bug in pdksh 5.2.14. +for as_var in BASH_ENV ENV MAIL MAILPATH +do eval test x\${$as_var+set} = xset \ + && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || : +done +PS1='$ ' +PS2='> ' +PS4='+ ' + +# NLS nuisances. +LC_ALL=C +export LC_ALL +LANGUAGE=C +export LANGUAGE + +# CDPATH. +(unset CDPATH) >/dev/null 2>&1 && unset CDPATH + + +# as_fn_error STATUS ERROR [LINENO LOG_FD] +# ---------------------------------------- +# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are +# provided, also output the error to LOG_FD, referencing LINENO. Then exit the +# script with STATUS, using 1 if that was 0. +as_fn_error () +{ + as_status=$1; test $as_status -eq 0 && as_status=1 + if test "$4"; then + as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack + $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4 + fi + $as_echo "$as_me: error: $2" >&2 + as_fn_exit $as_status +} # as_fn_error + + +# as_fn_set_status STATUS +# ----------------------- +# Set $? to STATUS, without forking. +as_fn_set_status () +{ + return $1 +} # as_fn_set_status + +# as_fn_exit STATUS +# ----------------- +# Exit the shell with STATUS, even in a "trap 0" or "set -e" context. +as_fn_exit () +{ + set +e + as_fn_set_status $1 + exit $1 +} # as_fn_exit + +# as_fn_unset VAR +# --------------- +# Portably unset VAR. +as_fn_unset () +{ + { eval $1=; unset $1;} +} +as_unset=as_fn_unset +# as_fn_append VAR VALUE +# ---------------------- +# Append the text in VALUE to the end of the definition contained in VAR. Take +# advantage of any shell optimizations that allow amortized linear growth over +# repeated appends, instead of the typical quadratic growth present in naive +# implementations. +if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then : + eval 'as_fn_append () + { + eval $1+=\$2 + }' +else + as_fn_append () + { + eval $1=\$$1\$2 + } +fi # as_fn_append + +# as_fn_arith ARG... +# ------------------ +# Perform arithmetic evaluation on the ARGs, and store the result in the +# global $as_val. Take advantage of shells that can avoid forks. The arguments +# must be portable across $(()) and expr. +if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then : + eval 'as_fn_arith () + { + as_val=$(( $* )) + }' +else + as_fn_arith () + { + as_val=`expr "$@" || test $? -eq 1` + } +fi # as_fn_arith + + +if expr a : '\(a\)' >/dev/null 2>&1 && + test "X`expr 00001 : '.*\(...\)'`" = X001; then + as_expr=expr +else + as_expr=false +fi + +if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then + as_basename=basename +else + as_basename=false +fi + +if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then + as_dirname=dirname +else + as_dirname=false +fi + +as_me=`$as_basename -- "$0" || +$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ + X"$0" : 'X\(//\)$' \| \ + X"$0" : 'X\(/\)' \| . 2>/dev/null || +$as_echo X/"$0" | + sed '/^.*\/\([^/][^/]*\)\/*$/{ + s//\1/ + q + } + /^X\/\(\/\/\)$/{ + s//\1/ + q + } + /^X\/\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q'` + +# Avoid depending upon Character Ranges. +as_cr_letters='abcdefghijklmnopqrstuvwxyz' +as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ' +as_cr_Letters=$as_cr_letters$as_cr_LETTERS +as_cr_digits='0123456789' +as_cr_alnum=$as_cr_Letters$as_cr_digits + +ECHO_C= ECHO_N= ECHO_T= +case `echo -n x` in #((((( +-n*) + case `echo 'xy\c'` in + *c*) ECHO_T=' ';; # ECHO_T is single tab character. + xy) ECHO_C='\c';; + *) echo `echo ksh88 bug on AIX 6.1` > /dev/null + ECHO_T=' ';; + esac;; +*) + ECHO_N='-n';; +esac + +rm -f conf$$ conf$$.exe conf$$.file +if test -d conf$$.dir; then + rm -f conf$$.dir/conf$$.file +else + rm -f conf$$.dir + mkdir conf$$.dir 2>/dev/null +fi +if (echo >conf$$.file) 2>/dev/null; then + if ln -s conf$$.file conf$$ 2>/dev/null; then + as_ln_s='ln -s' + # ... but there are two gotchas: + # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail. + # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable. + # In both cases, we have to default to `cp -pR'. + ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe || + as_ln_s='cp -pR' + elif ln conf$$.file conf$$ 2>/dev/null; then + as_ln_s=ln + else + as_ln_s='cp -pR' + fi +else + as_ln_s='cp -pR' +fi +rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file +rmdir conf$$.dir 2>/dev/null + + +# as_fn_mkdir_p +# ------------- +# Create "$as_dir" as a directory, including parents if necessary. +as_fn_mkdir_p () +{ + + case $as_dir in #( + -*) as_dir=./$as_dir;; + esac + test -d "$as_dir" || eval $as_mkdir_p || { + as_dirs= + while :; do + case $as_dir in #( + *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'( + *) as_qdir=$as_dir;; + esac + as_dirs="'$as_qdir' $as_dirs" + as_dir=`$as_dirname -- "$as_dir" || +$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ + X"$as_dir" : 'X\(//\)[^/]' \| \ + X"$as_dir" : 'X\(//\)$' \| \ + X"$as_dir" : 'X\(/\)' \| . 2>/dev/null || +$as_echo X"$as_dir" | + sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ + s//\1/ + q + } + /^X\(\/\/\)[^/].*/{ + s//\1/ + q + } + /^X\(\/\/\)$/{ + s//\1/ + q + } + /^X\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q'` + test -d "$as_dir" && break + done + test -z "$as_dirs" || eval "mkdir $as_dirs" + } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir" + + +} # as_fn_mkdir_p +if mkdir -p . 2>/dev/null; then + as_mkdir_p='mkdir -p "$as_dir"' +else + test -d ./-p && rmdir ./-p + as_mkdir_p=false +fi + + +# as_fn_executable_p FILE +# ----------------------- +# Test if FILE is an executable regular file. +as_fn_executable_p () +{ + test -f "$1" && test -x "$1" +} # as_fn_executable_p +as_test_x='test -x' +as_executable_p=as_fn_executable_p + +# Sed expression to map a string onto a valid CPP name. +as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'" + +# Sed expression to map a string onto a valid variable name. +as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'" + + +exec 6>&1 +## ----------------------------------- ## +## Main body of $CONFIG_STATUS script. ## +## ----------------------------------- ## +_ASEOF +test $as_write_fail = 0 && chmod +x $CONFIG_STATUS || ac_write_fail=1 + +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +# Save the log message, to keep $0 and so on meaningful, and to +# report actual input values of CONFIG_FILES etc. instead of their +# values after options handling. +ac_log=" +This file was extended by libodb-sqlite $as_me 2.4.0, which was +generated by GNU Autoconf 2.69. Invocation command line was + + CONFIG_FILES = $CONFIG_FILES + CONFIG_HEADERS = $CONFIG_HEADERS + CONFIG_LINKS = $CONFIG_LINKS + CONFIG_COMMANDS = $CONFIG_COMMANDS + $ $0 $@ + +on `(hostname || uname -n) 2>/dev/null | sed 1q` +" + +_ACEOF + +case $ac_config_files in *" +"*) set x $ac_config_files; shift; ac_config_files=$*;; +esac + +case $ac_config_headers in *" +"*) set x $ac_config_headers; shift; ac_config_headers=$*;; +esac + + +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +# Files that config.status was made for. +config_files="$ac_config_files" +config_headers="$ac_config_headers" +config_commands="$ac_config_commands" + +_ACEOF + +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +ac_cs_usage="\ +\`$as_me' instantiates files and other configuration actions +from templates according to the current configuration. Unless the files +and actions are specified as TAGs, all are instantiated by default. + +Usage: $0 [OPTION]... [TAG]... + + -h, --help print this help, then exit + -V, --version print version number and configuration settings, then exit + --config print configuration, then exit + -q, --quiet, --silent + do not print progress messages + -d, --debug don't remove temporary files + --recheck update $as_me by reconfiguring in the same conditions + --file=FILE[:TEMPLATE] + instantiate the configuration file FILE + --header=FILE[:TEMPLATE] + instantiate the configuration header FILE + +Configuration files: +$config_files + +Configuration headers: +$config_headers + +Configuration commands: +$config_commands + +Report bugs to ." + +_ACEOF +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`" +ac_cs_version="\\ +libodb-sqlite config.status 2.4.0 +configured by $0, generated by GNU Autoconf 2.69, + with options \\"\$ac_cs_config\\" + +Copyright (C) 2012 Free Software Foundation, Inc. +This config.status script is free software; the Free Software Foundation +gives unlimited permission to copy, distribute and modify it." + +ac_pwd='$ac_pwd' +srcdir='$srcdir' +INSTALL='$INSTALL' +MKDIR_P='$MKDIR_P' +AWK='$AWK' +test -n "\$AWK" || AWK=awk +_ACEOF + +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +# The default lists apply if the user does not specify any file. +ac_need_defaults=: +while test $# != 0 +do + case $1 in + --*=?*) + ac_option=`expr "X$1" : 'X\([^=]*\)='` + ac_optarg=`expr "X$1" : 'X[^=]*=\(.*\)'` + ac_shift=: + ;; + --*=) + ac_option=`expr "X$1" : 'X\([^=]*\)='` + ac_optarg= + ac_shift=: + ;; + *) + ac_option=$1 + ac_optarg=$2 + ac_shift=shift + ;; + esac + + case $ac_option in + # Handling of the options. + -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r) + ac_cs_recheck=: ;; + --version | --versio | --versi | --vers | --ver | --ve | --v | -V ) + $as_echo "$ac_cs_version"; exit ;; + --config | --confi | --conf | --con | --co | --c ) + $as_echo "$ac_cs_config"; exit ;; + --debug | --debu | --deb | --de | --d | -d ) + debug=: ;; + --file | --fil | --fi | --f ) + $ac_shift + case $ac_optarg in + *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;; + '') as_fn_error $? "missing file argument" ;; + esac + as_fn_append CONFIG_FILES " '$ac_optarg'" + ac_need_defaults=false;; + --header | --heade | --head | --hea ) + $ac_shift + case $ac_optarg in + *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;; + esac + as_fn_append CONFIG_HEADERS " '$ac_optarg'" + ac_need_defaults=false;; + --he | --h) + # Conflict between --help and --header + as_fn_error $? "ambiguous option: \`$1' +Try \`$0 --help' for more information.";; + --help | --hel | -h ) + $as_echo "$ac_cs_usage"; exit ;; + -q | -quiet | --quiet | --quie | --qui | --qu | --q \ + | -silent | --silent | --silen | --sile | --sil | --si | --s) + ac_cs_silent=: ;; + + # This is an error. + -*) as_fn_error $? "unrecognized option: \`$1' +Try \`$0 --help' for more information." ;; + + *) as_fn_append ac_config_targets " $1" + ac_need_defaults=false ;; + + esac + shift +done + +ac_configure_extra_args= + +if $ac_cs_silent; then + exec 6>/dev/null + ac_configure_extra_args="$ac_configure_extra_args --silent" +fi + +_ACEOF +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +if \$ac_cs_recheck; then + set X $SHELL '$0' $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion + shift + \$as_echo "running CONFIG_SHELL=$SHELL \$*" >&6 + CONFIG_SHELL='$SHELL' + export CONFIG_SHELL + exec "\$@" +fi + +_ACEOF +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +exec 5>>config.log +{ + echo + sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX +## Running $as_me. ## +_ASBOX + $as_echo "$ac_log" +} >&5 + +_ACEOF +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +# +# INIT-COMMANDS +# +AMDEP_TRUE="$AMDEP_TRUE" ac_aux_dir="$ac_aux_dir" + + +# The HP-UX ksh and POSIX shell print the target directory to stdout +# if CDPATH is set. +(unset CDPATH) >/dev/null 2>&1 && unset CDPATH + +sed_quote_subst='$sed_quote_subst' +double_quote_subst='$double_quote_subst' +delay_variable_subst='$delay_variable_subst' +macro_version='`$ECHO "$macro_version" | $SED "$delay_single_quote_subst"`' +macro_revision='`$ECHO "$macro_revision" | $SED "$delay_single_quote_subst"`' +AS='`$ECHO "$AS" | $SED "$delay_single_quote_subst"`' +DLLTOOL='`$ECHO "$DLLTOOL" | $SED "$delay_single_quote_subst"`' +OBJDUMP='`$ECHO "$OBJDUMP" | $SED "$delay_single_quote_subst"`' +enable_shared='`$ECHO "$enable_shared" | $SED "$delay_single_quote_subst"`' +enable_static='`$ECHO "$enable_static" | $SED "$delay_single_quote_subst"`' +pic_mode='`$ECHO "$pic_mode" | $SED "$delay_single_quote_subst"`' +enable_fast_install='`$ECHO "$enable_fast_install" | $SED "$delay_single_quote_subst"`' +SHELL='`$ECHO "$SHELL" | $SED "$delay_single_quote_subst"`' +ECHO='`$ECHO "$ECHO" | $SED "$delay_single_quote_subst"`' +PATH_SEPARATOR='`$ECHO "$PATH_SEPARATOR" | $SED "$delay_single_quote_subst"`' +host_alias='`$ECHO "$host_alias" | $SED "$delay_single_quote_subst"`' +host='`$ECHO "$host" | $SED "$delay_single_quote_subst"`' +host_os='`$ECHO "$host_os" | $SED "$delay_single_quote_subst"`' +build_alias='`$ECHO "$build_alias" | $SED "$delay_single_quote_subst"`' +build='`$ECHO "$build" | $SED "$delay_single_quote_subst"`' +build_os='`$ECHO "$build_os" | $SED "$delay_single_quote_subst"`' +SED='`$ECHO "$SED" | $SED "$delay_single_quote_subst"`' +Xsed='`$ECHO "$Xsed" | $SED "$delay_single_quote_subst"`' +GREP='`$ECHO "$GREP" | $SED "$delay_single_quote_subst"`' +EGREP='`$ECHO "$EGREP" | $SED "$delay_single_quote_subst"`' +FGREP='`$ECHO "$FGREP" | $SED "$delay_single_quote_subst"`' +LD='`$ECHO "$LD" | $SED "$delay_single_quote_subst"`' +NM='`$ECHO "$NM" | $SED "$delay_single_quote_subst"`' +LN_S='`$ECHO "$LN_S" | $SED "$delay_single_quote_subst"`' +max_cmd_len='`$ECHO "$max_cmd_len" | $SED "$delay_single_quote_subst"`' +ac_objext='`$ECHO "$ac_objext" | $SED "$delay_single_quote_subst"`' +exeext='`$ECHO "$exeext" | $SED "$delay_single_quote_subst"`' +lt_unset='`$ECHO "$lt_unset" | $SED "$delay_single_quote_subst"`' +lt_SP2NL='`$ECHO "$lt_SP2NL" | $SED "$delay_single_quote_subst"`' +lt_NL2SP='`$ECHO "$lt_NL2SP" | $SED "$delay_single_quote_subst"`' +lt_cv_to_host_file_cmd='`$ECHO "$lt_cv_to_host_file_cmd" | $SED "$delay_single_quote_subst"`' +lt_cv_to_tool_file_cmd='`$ECHO "$lt_cv_to_tool_file_cmd" | $SED "$delay_single_quote_subst"`' +reload_flag='`$ECHO "$reload_flag" | $SED "$delay_single_quote_subst"`' +reload_cmds='`$ECHO "$reload_cmds" | $SED "$delay_single_quote_subst"`' +deplibs_check_method='`$ECHO "$deplibs_check_method" | $SED "$delay_single_quote_subst"`' +file_magic_cmd='`$ECHO "$file_magic_cmd" | $SED "$delay_single_quote_subst"`' +file_magic_glob='`$ECHO "$file_magic_glob" | $SED "$delay_single_quote_subst"`' +want_nocaseglob='`$ECHO "$want_nocaseglob" | $SED "$delay_single_quote_subst"`' +sharedlib_from_linklib_cmd='`$ECHO "$sharedlib_from_linklib_cmd" | $SED "$delay_single_quote_subst"`' +AR='`$ECHO "$AR" | $SED "$delay_single_quote_subst"`' +AR_FLAGS='`$ECHO "$AR_FLAGS" | $SED "$delay_single_quote_subst"`' +archiver_list_spec='`$ECHO "$archiver_list_spec" | $SED "$delay_single_quote_subst"`' +STRIP='`$ECHO "$STRIP" | $SED "$delay_single_quote_subst"`' +RANLIB='`$ECHO "$RANLIB" | $SED "$delay_single_quote_subst"`' +old_postinstall_cmds='`$ECHO "$old_postinstall_cmds" | $SED "$delay_single_quote_subst"`' +old_postuninstall_cmds='`$ECHO "$old_postuninstall_cmds" | $SED "$delay_single_quote_subst"`' +old_archive_cmds='`$ECHO "$old_archive_cmds" | $SED "$delay_single_quote_subst"`' +lock_old_archive_extraction='`$ECHO "$lock_old_archive_extraction" | $SED "$delay_single_quote_subst"`' +CC='`$ECHO "$CC" | $SED "$delay_single_quote_subst"`' +CFLAGS='`$ECHO "$CFLAGS" | $SED "$delay_single_quote_subst"`' +compiler='`$ECHO "$compiler" | $SED "$delay_single_quote_subst"`' +GCC='`$ECHO "$GCC" | $SED "$delay_single_quote_subst"`' +lt_cv_sys_global_symbol_pipe='`$ECHO "$lt_cv_sys_global_symbol_pipe" | $SED "$delay_single_quote_subst"`' +lt_cv_sys_global_symbol_to_cdecl='`$ECHO "$lt_cv_sys_global_symbol_to_cdecl" | $SED "$delay_single_quote_subst"`' +lt_cv_sys_global_symbol_to_c_name_address='`$ECHO "$lt_cv_sys_global_symbol_to_c_name_address" | $SED "$delay_single_quote_subst"`' +lt_cv_sys_global_symbol_to_c_name_address_lib_prefix='`$ECHO "$lt_cv_sys_global_symbol_to_c_name_address_lib_prefix" | $SED "$delay_single_quote_subst"`' +nm_file_list_spec='`$ECHO "$nm_file_list_spec" | $SED "$delay_single_quote_subst"`' +lt_sysroot='`$ECHO "$lt_sysroot" | $SED "$delay_single_quote_subst"`' +objdir='`$ECHO "$objdir" | $SED "$delay_single_quote_subst"`' +MAGIC_CMD='`$ECHO "$MAGIC_CMD" | $SED "$delay_single_quote_subst"`' +lt_prog_compiler_no_builtin_flag='`$ECHO "$lt_prog_compiler_no_builtin_flag" | $SED "$delay_single_quote_subst"`' +lt_prog_compiler_pic='`$ECHO "$lt_prog_compiler_pic" | $SED "$delay_single_quote_subst"`' +lt_prog_compiler_wl='`$ECHO "$lt_prog_compiler_wl" | $SED "$delay_single_quote_subst"`' +lt_prog_compiler_static='`$ECHO "$lt_prog_compiler_static" | $SED "$delay_single_quote_subst"`' +lt_cv_prog_compiler_c_o='`$ECHO "$lt_cv_prog_compiler_c_o" | $SED "$delay_single_quote_subst"`' +need_locks='`$ECHO "$need_locks" | $SED "$delay_single_quote_subst"`' +MANIFEST_TOOL='`$ECHO "$MANIFEST_TOOL" | $SED "$delay_single_quote_subst"`' +DSYMUTIL='`$ECHO "$DSYMUTIL" | $SED "$delay_single_quote_subst"`' +NMEDIT='`$ECHO "$NMEDIT" | $SED "$delay_single_quote_subst"`' +LIPO='`$ECHO "$LIPO" | $SED "$delay_single_quote_subst"`' +OTOOL='`$ECHO "$OTOOL" | $SED "$delay_single_quote_subst"`' +OTOOL64='`$ECHO "$OTOOL64" | $SED "$delay_single_quote_subst"`' +libext='`$ECHO "$libext" | $SED "$delay_single_quote_subst"`' +shrext_cmds='`$ECHO "$shrext_cmds" | $SED "$delay_single_quote_subst"`' +extract_expsyms_cmds='`$ECHO "$extract_expsyms_cmds" | $SED "$delay_single_quote_subst"`' +archive_cmds_need_lc='`$ECHO "$archive_cmds_need_lc" | $SED "$delay_single_quote_subst"`' +enable_shared_with_static_runtimes='`$ECHO "$enable_shared_with_static_runtimes" | $SED "$delay_single_quote_subst"`' +export_dynamic_flag_spec='`$ECHO "$export_dynamic_flag_spec" | $SED "$delay_single_quote_subst"`' +whole_archive_flag_spec='`$ECHO "$whole_archive_flag_spec" | $SED "$delay_single_quote_subst"`' +compiler_needs_object='`$ECHO "$compiler_needs_object" | $SED "$delay_single_quote_subst"`' +old_archive_from_new_cmds='`$ECHO "$old_archive_from_new_cmds" | $SED "$delay_single_quote_subst"`' +old_archive_from_expsyms_cmds='`$ECHO "$old_archive_from_expsyms_cmds" | $SED "$delay_single_quote_subst"`' +archive_cmds='`$ECHO "$archive_cmds" | $SED "$delay_single_quote_subst"`' +archive_expsym_cmds='`$ECHO "$archive_expsym_cmds" | $SED "$delay_single_quote_subst"`' +module_cmds='`$ECHO "$module_cmds" | $SED "$delay_single_quote_subst"`' +module_expsym_cmds='`$ECHO "$module_expsym_cmds" | $SED "$delay_single_quote_subst"`' +with_gnu_ld='`$ECHO "$with_gnu_ld" | $SED "$delay_single_quote_subst"`' +allow_undefined_flag='`$ECHO "$allow_undefined_flag" | $SED "$delay_single_quote_subst"`' +no_undefined_flag='`$ECHO "$no_undefined_flag" | $SED "$delay_single_quote_subst"`' +hardcode_libdir_flag_spec='`$ECHO "$hardcode_libdir_flag_spec" | $SED "$delay_single_quote_subst"`' +hardcode_libdir_separator='`$ECHO "$hardcode_libdir_separator" | $SED "$delay_single_quote_subst"`' +hardcode_direct='`$ECHO "$hardcode_direct" | $SED "$delay_single_quote_subst"`' +hardcode_direct_absolute='`$ECHO "$hardcode_direct_absolute" | $SED "$delay_single_quote_subst"`' +hardcode_minus_L='`$ECHO "$hardcode_minus_L" | $SED "$delay_single_quote_subst"`' +hardcode_shlibpath_var='`$ECHO "$hardcode_shlibpath_var" | $SED "$delay_single_quote_subst"`' +hardcode_automatic='`$ECHO "$hardcode_automatic" | $SED "$delay_single_quote_subst"`' +inherit_rpath='`$ECHO "$inherit_rpath" | $SED "$delay_single_quote_subst"`' +link_all_deplibs='`$ECHO "$link_all_deplibs" | $SED "$delay_single_quote_subst"`' +always_export_symbols='`$ECHO "$always_export_symbols" | $SED "$delay_single_quote_subst"`' +export_symbols_cmds='`$ECHO "$export_symbols_cmds" | $SED "$delay_single_quote_subst"`' +exclude_expsyms='`$ECHO "$exclude_expsyms" | $SED "$delay_single_quote_subst"`' +include_expsyms='`$ECHO "$include_expsyms" | $SED "$delay_single_quote_subst"`' +prelink_cmds='`$ECHO "$prelink_cmds" | $SED "$delay_single_quote_subst"`' +postlink_cmds='`$ECHO "$postlink_cmds" | $SED "$delay_single_quote_subst"`' +file_list_spec='`$ECHO "$file_list_spec" | $SED "$delay_single_quote_subst"`' +variables_saved_for_relink='`$ECHO "$variables_saved_for_relink" | $SED "$delay_single_quote_subst"`' +need_lib_prefix='`$ECHO "$need_lib_prefix" | $SED "$delay_single_quote_subst"`' +need_version='`$ECHO "$need_version" | $SED "$delay_single_quote_subst"`' +version_type='`$ECHO "$version_type" | $SED "$delay_single_quote_subst"`' +runpath_var='`$ECHO "$runpath_var" | $SED "$delay_single_quote_subst"`' +shlibpath_var='`$ECHO "$shlibpath_var" | $SED "$delay_single_quote_subst"`' +shlibpath_overrides_runpath='`$ECHO "$shlibpath_overrides_runpath" | $SED "$delay_single_quote_subst"`' +libname_spec='`$ECHO "$libname_spec" | $SED "$delay_single_quote_subst"`' +library_names_spec='`$ECHO "$library_names_spec" | $SED "$delay_single_quote_subst"`' +soname_spec='`$ECHO "$soname_spec" | $SED "$delay_single_quote_subst"`' +install_override_mode='`$ECHO "$install_override_mode" | $SED "$delay_single_quote_subst"`' +postinstall_cmds='`$ECHO "$postinstall_cmds" | $SED "$delay_single_quote_subst"`' +postuninstall_cmds='`$ECHO "$postuninstall_cmds" | $SED "$delay_single_quote_subst"`' +finish_cmds='`$ECHO "$finish_cmds" | $SED "$delay_single_quote_subst"`' +finish_eval='`$ECHO "$finish_eval" | $SED "$delay_single_quote_subst"`' +hardcode_into_libs='`$ECHO "$hardcode_into_libs" | $SED "$delay_single_quote_subst"`' +sys_lib_search_path_spec='`$ECHO "$sys_lib_search_path_spec" | $SED "$delay_single_quote_subst"`' +sys_lib_dlsearch_path_spec='`$ECHO "$sys_lib_dlsearch_path_spec" | $SED "$delay_single_quote_subst"`' +hardcode_action='`$ECHO "$hardcode_action" | $SED "$delay_single_quote_subst"`' +enable_dlopen='`$ECHO "$enable_dlopen" | $SED "$delay_single_quote_subst"`' +enable_dlopen_self='`$ECHO "$enable_dlopen_self" | $SED "$delay_single_quote_subst"`' +enable_dlopen_self_static='`$ECHO "$enable_dlopen_self_static" | $SED "$delay_single_quote_subst"`' +old_striplib='`$ECHO "$old_striplib" | $SED "$delay_single_quote_subst"`' +striplib='`$ECHO "$striplib" | $SED "$delay_single_quote_subst"`' +compiler_lib_search_dirs='`$ECHO "$compiler_lib_search_dirs" | $SED "$delay_single_quote_subst"`' +predep_objects='`$ECHO "$predep_objects" | $SED "$delay_single_quote_subst"`' +postdep_objects='`$ECHO "$postdep_objects" | $SED "$delay_single_quote_subst"`' +predeps='`$ECHO "$predeps" | $SED "$delay_single_quote_subst"`' +postdeps='`$ECHO "$postdeps" | $SED "$delay_single_quote_subst"`' +compiler_lib_search_path='`$ECHO "$compiler_lib_search_path" | $SED "$delay_single_quote_subst"`' +LD_CXX='`$ECHO "$LD_CXX" | $SED "$delay_single_quote_subst"`' +reload_flag_CXX='`$ECHO "$reload_flag_CXX" | $SED "$delay_single_quote_subst"`' +reload_cmds_CXX='`$ECHO "$reload_cmds_CXX" | $SED "$delay_single_quote_subst"`' +old_archive_cmds_CXX='`$ECHO "$old_archive_cmds_CXX" | $SED "$delay_single_quote_subst"`' +compiler_CXX='`$ECHO "$compiler_CXX" | $SED "$delay_single_quote_subst"`' +GCC_CXX='`$ECHO "$GCC_CXX" | $SED "$delay_single_quote_subst"`' +lt_prog_compiler_no_builtin_flag_CXX='`$ECHO "$lt_prog_compiler_no_builtin_flag_CXX" | $SED "$delay_single_quote_subst"`' +lt_prog_compiler_pic_CXX='`$ECHO "$lt_prog_compiler_pic_CXX" | $SED "$delay_single_quote_subst"`' +lt_prog_compiler_wl_CXX='`$ECHO "$lt_prog_compiler_wl_CXX" | $SED "$delay_single_quote_subst"`' +lt_prog_compiler_static_CXX='`$ECHO "$lt_prog_compiler_static_CXX" | $SED "$delay_single_quote_subst"`' +lt_cv_prog_compiler_c_o_CXX='`$ECHO "$lt_cv_prog_compiler_c_o_CXX" | $SED "$delay_single_quote_subst"`' +archive_cmds_need_lc_CXX='`$ECHO "$archive_cmds_need_lc_CXX" | $SED "$delay_single_quote_subst"`' +enable_shared_with_static_runtimes_CXX='`$ECHO "$enable_shared_with_static_runtimes_CXX" | $SED "$delay_single_quote_subst"`' +export_dynamic_flag_spec_CXX='`$ECHO "$export_dynamic_flag_spec_CXX" | $SED "$delay_single_quote_subst"`' +whole_archive_flag_spec_CXX='`$ECHO "$whole_archive_flag_spec_CXX" | $SED "$delay_single_quote_subst"`' +compiler_needs_object_CXX='`$ECHO "$compiler_needs_object_CXX" | $SED "$delay_single_quote_subst"`' +old_archive_from_new_cmds_CXX='`$ECHO "$old_archive_from_new_cmds_CXX" | $SED "$delay_single_quote_subst"`' +old_archive_from_expsyms_cmds_CXX='`$ECHO "$old_archive_from_expsyms_cmds_CXX" | $SED "$delay_single_quote_subst"`' +archive_cmds_CXX='`$ECHO "$archive_cmds_CXX" | $SED "$delay_single_quote_subst"`' +archive_expsym_cmds_CXX='`$ECHO "$archive_expsym_cmds_CXX" | $SED "$delay_single_quote_subst"`' +module_cmds_CXX='`$ECHO "$module_cmds_CXX" | $SED "$delay_single_quote_subst"`' +module_expsym_cmds_CXX='`$ECHO "$module_expsym_cmds_CXX" | $SED "$delay_single_quote_subst"`' +with_gnu_ld_CXX='`$ECHO "$with_gnu_ld_CXX" | $SED "$delay_single_quote_subst"`' +allow_undefined_flag_CXX='`$ECHO "$allow_undefined_flag_CXX" | $SED "$delay_single_quote_subst"`' +no_undefined_flag_CXX='`$ECHO "$no_undefined_flag_CXX" | $SED "$delay_single_quote_subst"`' +hardcode_libdir_flag_spec_CXX='`$ECHO "$hardcode_libdir_flag_spec_CXX" | $SED "$delay_single_quote_subst"`' +hardcode_libdir_separator_CXX='`$ECHO "$hardcode_libdir_separator_CXX" | $SED "$delay_single_quote_subst"`' +hardcode_direct_CXX='`$ECHO "$hardcode_direct_CXX" | $SED "$delay_single_quote_subst"`' +hardcode_direct_absolute_CXX='`$ECHO "$hardcode_direct_absolute_CXX" | $SED "$delay_single_quote_subst"`' +hardcode_minus_L_CXX='`$ECHO "$hardcode_minus_L_CXX" | $SED "$delay_single_quote_subst"`' +hardcode_shlibpath_var_CXX='`$ECHO "$hardcode_shlibpath_var_CXX" | $SED "$delay_single_quote_subst"`' +hardcode_automatic_CXX='`$ECHO "$hardcode_automatic_CXX" | $SED "$delay_single_quote_subst"`' +inherit_rpath_CXX='`$ECHO "$inherit_rpath_CXX" | $SED "$delay_single_quote_subst"`' +link_all_deplibs_CXX='`$ECHO "$link_all_deplibs_CXX" | $SED "$delay_single_quote_subst"`' +always_export_symbols_CXX='`$ECHO "$always_export_symbols_CXX" | $SED "$delay_single_quote_subst"`' +export_symbols_cmds_CXX='`$ECHO "$export_symbols_cmds_CXX" | $SED "$delay_single_quote_subst"`' +exclude_expsyms_CXX='`$ECHO "$exclude_expsyms_CXX" | $SED "$delay_single_quote_subst"`' +include_expsyms_CXX='`$ECHO "$include_expsyms_CXX" | $SED "$delay_single_quote_subst"`' +prelink_cmds_CXX='`$ECHO "$prelink_cmds_CXX" | $SED "$delay_single_quote_subst"`' +postlink_cmds_CXX='`$ECHO "$postlink_cmds_CXX" | $SED "$delay_single_quote_subst"`' +file_list_spec_CXX='`$ECHO "$file_list_spec_CXX" | $SED "$delay_single_quote_subst"`' +hardcode_action_CXX='`$ECHO "$hardcode_action_CXX" | $SED "$delay_single_quote_subst"`' +compiler_lib_search_dirs_CXX='`$ECHO "$compiler_lib_search_dirs_CXX" | $SED "$delay_single_quote_subst"`' +predep_objects_CXX='`$ECHO "$predep_objects_CXX" | $SED "$delay_single_quote_subst"`' +postdep_objects_CXX='`$ECHO "$postdep_objects_CXX" | $SED "$delay_single_quote_subst"`' +predeps_CXX='`$ECHO "$predeps_CXX" | $SED "$delay_single_quote_subst"`' +postdeps_CXX='`$ECHO "$postdeps_CXX" | $SED "$delay_single_quote_subst"`' +compiler_lib_search_path_CXX='`$ECHO "$compiler_lib_search_path_CXX" | $SED "$delay_single_quote_subst"`' + +LTCC='$LTCC' +LTCFLAGS='$LTCFLAGS' +compiler='$compiler_DEFAULT' + +# A function that is used when there is no print builtin or printf. +func_fallback_echo () +{ + eval 'cat <<_LTECHO_EOF +\$1 +_LTECHO_EOF' +} + +# Quote evaled strings. +for var in AS \ +DLLTOOL \ +OBJDUMP \ +SHELL \ +ECHO \ +PATH_SEPARATOR \ +SED \ +GREP \ +EGREP \ +FGREP \ +LD \ +NM \ +LN_S \ +lt_SP2NL \ +lt_NL2SP \ +reload_flag \ +deplibs_check_method \ +file_magic_cmd \ +file_magic_glob \ +want_nocaseglob \ +sharedlib_from_linklib_cmd \ +AR \ +AR_FLAGS \ +archiver_list_spec \ +STRIP \ +RANLIB \ +CC \ +CFLAGS \ +compiler \ +lt_cv_sys_global_symbol_pipe \ +lt_cv_sys_global_symbol_to_cdecl \ +lt_cv_sys_global_symbol_to_c_name_address \ +lt_cv_sys_global_symbol_to_c_name_address_lib_prefix \ +nm_file_list_spec \ +lt_prog_compiler_no_builtin_flag \ +lt_prog_compiler_pic \ +lt_prog_compiler_wl \ +lt_prog_compiler_static \ +lt_cv_prog_compiler_c_o \ +need_locks \ +MANIFEST_TOOL \ +DSYMUTIL \ +NMEDIT \ +LIPO \ +OTOOL \ +OTOOL64 \ +shrext_cmds \ +export_dynamic_flag_spec \ +whole_archive_flag_spec \ +compiler_needs_object \ +with_gnu_ld \ +allow_undefined_flag \ +no_undefined_flag \ +hardcode_libdir_flag_spec \ +hardcode_libdir_separator \ +exclude_expsyms \ +include_expsyms \ +file_list_spec \ +variables_saved_for_relink \ +libname_spec \ +library_names_spec \ +soname_spec \ +install_override_mode \ +finish_eval \ +old_striplib \ +striplib \ +compiler_lib_search_dirs \ +predep_objects \ +postdep_objects \ +predeps \ +postdeps \ +compiler_lib_search_path \ +LD_CXX \ +reload_flag_CXX \ +compiler_CXX \ +lt_prog_compiler_no_builtin_flag_CXX \ +lt_prog_compiler_pic_CXX \ +lt_prog_compiler_wl_CXX \ +lt_prog_compiler_static_CXX \ +lt_cv_prog_compiler_c_o_CXX \ +export_dynamic_flag_spec_CXX \ +whole_archive_flag_spec_CXX \ +compiler_needs_object_CXX \ +with_gnu_ld_CXX \ +allow_undefined_flag_CXX \ +no_undefined_flag_CXX \ +hardcode_libdir_flag_spec_CXX \ +hardcode_libdir_separator_CXX \ +exclude_expsyms_CXX \ +include_expsyms_CXX \ +file_list_spec_CXX \ +compiler_lib_search_dirs_CXX \ +predep_objects_CXX \ +postdep_objects_CXX \ +predeps_CXX \ +postdeps_CXX \ +compiler_lib_search_path_CXX; do + case \`eval \\\\\$ECHO \\\\""\\\\\$\$var"\\\\"\` in + *[\\\\\\\`\\"\\\$]*) + eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"\\\$\$var\\" | \\\$SED \\"\\\$sed_quote_subst\\"\\\`\\\\\\"" + ;; + *) + eval "lt_\$var=\\\\\\"\\\$\$var\\\\\\"" + ;; + esac +done + +# Double-quote double-evaled strings. +for var in reload_cmds \ +old_postinstall_cmds \ +old_postuninstall_cmds \ +old_archive_cmds \ +extract_expsyms_cmds \ +old_archive_from_new_cmds \ +old_archive_from_expsyms_cmds \ +archive_cmds \ +archive_expsym_cmds \ +module_cmds \ +module_expsym_cmds \ +export_symbols_cmds \ +prelink_cmds \ +postlink_cmds \ +postinstall_cmds \ +postuninstall_cmds \ +finish_cmds \ +sys_lib_search_path_spec \ +sys_lib_dlsearch_path_spec \ +reload_cmds_CXX \ +old_archive_cmds_CXX \ +old_archive_from_new_cmds_CXX \ +old_archive_from_expsyms_cmds_CXX \ +archive_cmds_CXX \ +archive_expsym_cmds_CXX \ +module_cmds_CXX \ +module_expsym_cmds_CXX \ +export_symbols_cmds_CXX \ +prelink_cmds_CXX \ +postlink_cmds_CXX; do + case \`eval \\\\\$ECHO \\\\""\\\\\$\$var"\\\\"\` in + *[\\\\\\\`\\"\\\$]*) + eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"\\\$\$var\\" | \\\$SED -e \\"\\\$double_quote_subst\\" -e \\"\\\$sed_quote_subst\\" -e \\"\\\$delay_variable_subst\\"\\\`\\\\\\"" + ;; + *) + eval "lt_\$var=\\\\\\"\\\$\$var\\\\\\"" + ;; + esac +done + +ac_aux_dir='$ac_aux_dir' +xsi_shell='$xsi_shell' +lt_shell_append='$lt_shell_append' + +# See if we are running on zsh, and set the options which allow our +# commands through without removal of \ escapes INIT. +if test -n "\${ZSH_VERSION+set}" ; then + setopt NO_GLOB_SUBST +fi + + + PACKAGE='$PACKAGE' + VERSION='$VERSION' + TIMESTAMP='$TIMESTAMP' + RM='$RM' + ofile='$ofile' + + + +ac_aux_dir='$ac_aux_dir' + + +libtool_use_rpath=$libtool_rpath + +_ACEOF + +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 + +# Handling of arguments. +for ac_config_target in $ac_config_targets +do + case $ac_config_target in + "depfiles") CONFIG_COMMANDS="$CONFIG_COMMANDS depfiles" ;; + "libtool") CONFIG_COMMANDS="$CONFIG_COMMANDS libtool" ;; + "libtool-rpath-patch") CONFIG_COMMANDS="$CONFIG_COMMANDS libtool-rpath-patch" ;; + "odb/sqlite/config.h") CONFIG_HEADERS="$CONFIG_HEADERS odb/sqlite/config.h" ;; + "odb/sqlite/details/config.h") CONFIG_HEADERS="$CONFIG_HEADERS odb/sqlite/details/config.h" ;; + "libodb-sqlite.pc") CONFIG_FILES="$CONFIG_FILES libodb-sqlite.pc" ;; + "Makefile") CONFIG_FILES="$CONFIG_FILES Makefile" ;; + "odb/sqlite/Makefile") CONFIG_FILES="$CONFIG_FILES odb/sqlite/Makefile" ;; + + *) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5;; + esac +done + + +# If the user did not use the arguments to specify the items to instantiate, +# then the envvar interface is used. Set only those that are not. +# We use the long form for the default assignment because of an extremely +# bizarre bug on SunOS 4.1.3. +if $ac_need_defaults; then + test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files + test "${CONFIG_HEADERS+set}" = set || CONFIG_HEADERS=$config_headers + test "${CONFIG_COMMANDS+set}" = set || CONFIG_COMMANDS=$config_commands +fi + +# Have a temporary directory for convenience. Make it in the build tree +# simply because there is no reason against having it here, and in addition, +# creating and moving files from /tmp can sometimes cause problems. +# Hook for its removal unless debugging. +# Note that there is a small window in which the directory will not be cleaned: +# after its creation but before its name has been assigned to `$tmp'. +$debug || +{ + tmp= ac_tmp= + trap 'exit_status=$? + : "${ac_tmp:=$tmp}" + { test ! -d "$ac_tmp" || rm -fr "$ac_tmp"; } && exit $exit_status +' 0 + trap 'as_fn_exit 1' 1 2 13 15 +} +# Create a (secure) tmp directory for tmp files. + +{ + tmp=`(umask 077 && mktemp -d "./confXXXXXX") 2>/dev/null` && + test -d "$tmp" +} || +{ + tmp=./conf$$-$RANDOM + (umask 077 && mkdir "$tmp") +} || as_fn_error $? "cannot create a temporary directory in ." "$LINENO" 5 +ac_tmp=$tmp + +# Set up the scripts for CONFIG_FILES section. +# No need to generate them if there are no CONFIG_FILES. +# This happens for instance with `./config.status config.h'. +if test -n "$CONFIG_FILES"; then + + +ac_cr=`echo X | tr X '\015'` +# On cygwin, bash can eat \r inside `` if the user requested igncr. +# But we know of no other shell where ac_cr would be empty at this +# point, so we can use a bashism as a fallback. +if test "x$ac_cr" = x; then + eval ac_cr=\$\'\\r\' +fi +ac_cs_awk_cr=`$AWK 'BEGIN { print "a\rb" }' /dev/null` +if test "$ac_cs_awk_cr" = "a${ac_cr}b"; then + ac_cs_awk_cr='\\r' +else + ac_cs_awk_cr=$ac_cr +fi + +echo 'BEGIN {' >"$ac_tmp/subs1.awk" && +_ACEOF + + +{ + echo "cat >conf$$subs.awk <<_ACEOF" && + echo "$ac_subst_vars" | sed 's/.*/&!$&$ac_delim/' && + echo "_ACEOF" +} >conf$$subs.sh || + as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5 +ac_delim_num=`echo "$ac_subst_vars" | grep -c '^'` +ac_delim='%!_!# ' +for ac_last_try in false false false false false :; do + . ./conf$$subs.sh || + as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5 + + ac_delim_n=`sed -n "s/.*$ac_delim\$/X/p" conf$$subs.awk | grep -c X` + if test $ac_delim_n = $ac_delim_num; then + break + elif $ac_last_try; then + as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5 + else + ac_delim="$ac_delim!$ac_delim _$ac_delim!! " + fi +done +rm -f conf$$subs.sh + +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +cat >>"\$ac_tmp/subs1.awk" <<\\_ACAWK && +_ACEOF +sed -n ' +h +s/^/S["/; s/!.*/"]=/ +p +g +s/^[^!]*!// +:repl +t repl +s/'"$ac_delim"'$// +t delim +:nl +h +s/\(.\{148\}\)..*/\1/ +t more1 +s/["\\]/\\&/g; s/^/"/; s/$/\\n"\\/ +p +n +b repl +:more1 +s/["\\]/\\&/g; s/^/"/; s/$/"\\/ +p +g +s/.\{148\}// +t nl +:delim +h +s/\(.\{148\}\)..*/\1/ +t more2 +s/["\\]/\\&/g; s/^/"/; s/$/"/ +p +b +:more2 +s/["\\]/\\&/g; s/^/"/; s/$/"\\/ +p +g +s/.\{148\}// +t delim +' >$CONFIG_STATUS || ac_write_fail=1 +rm -f conf$$subs.awk +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +_ACAWK +cat >>"\$ac_tmp/subs1.awk" <<_ACAWK && + for (key in S) S_is_set[key] = 1 + FS = "" + +} +{ + line = $ 0 + nfields = split(line, field, "@") + substed = 0 + len = length(field[1]) + for (i = 2; i < nfields; i++) { + key = field[i] + keylen = length(key) + if (S_is_set[key]) { + value = S[key] + line = substr(line, 1, len) "" value "" substr(line, len + keylen + 3) + len += length(value) + length(field[++i]) + substed = 1 + } else + len += 1 + keylen + } + + print line +} + +_ACAWK +_ACEOF +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +if sed "s/$ac_cr//" < /dev/null > /dev/null 2>&1; then + sed "s/$ac_cr\$//; s/$ac_cr/$ac_cs_awk_cr/g" +else + cat +fi < "$ac_tmp/subs1.awk" > "$ac_tmp/subs.awk" \ + || as_fn_error $? "could not setup config files machinery" "$LINENO" 5 +_ACEOF + +# VPATH may cause trouble with some makes, so we remove sole $(srcdir), +# ${srcdir} and @srcdir@ entries from VPATH if srcdir is ".", strip leading and +# trailing colons and then remove the whole line if VPATH becomes empty +# (actually we leave an empty line to preserve line numbers). +if test "x$srcdir" = x.; then + ac_vpsub='/^[ ]*VPATH[ ]*=[ ]*/{ +h +s/// +s/^/:/ +s/[ ]*$/:/ +s/:\$(srcdir):/:/g +s/:\${srcdir}:/:/g +s/:@srcdir@:/:/g +s/^:*// +s/:*$// +x +s/\(=[ ]*\).*/\1/ +G +s/\n// +s/^[^=]*=[ ]*$// +}' +fi + +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +fi # test -n "$CONFIG_FILES" + +# Set up the scripts for CONFIG_HEADERS section. +# No need to generate them if there are no CONFIG_HEADERS. +# This happens for instance with `./config.status Makefile'. +if test -n "$CONFIG_HEADERS"; then +cat >"$ac_tmp/defines.awk" <<\_ACAWK || +BEGIN { +_ACEOF + +# Transform confdefs.h into an awk script `defines.awk', embedded as +# here-document in config.status, that substitutes the proper values into +# config.h.in to produce config.h. + +# Create a delimiter string that does not exist in confdefs.h, to ease +# handling of long lines. +ac_delim='%!_!# ' +for ac_last_try in false false :; do + ac_tt=`sed -n "/$ac_delim/p" confdefs.h` + if test -z "$ac_tt"; then + break + elif $ac_last_try; then + as_fn_error $? "could not make $CONFIG_HEADERS" "$LINENO" 5 + else + ac_delim="$ac_delim!$ac_delim _$ac_delim!! " + fi +done + +# For the awk script, D is an array of macro values keyed by name, +# likewise P contains macro parameters if any. Preserve backslash +# newline sequences. + +ac_word_re=[_$as_cr_Letters][_$as_cr_alnum]* +sed -n ' +s/.\{148\}/&'"$ac_delim"'/g +t rset +:rset +s/^[ ]*#[ ]*define[ ][ ]*/ / +t def +d +:def +s/\\$// +t bsnl +s/["\\]/\\&/g +s/^ \('"$ac_word_re"'\)\(([^()]*)\)[ ]*\(.*\)/P["\1"]="\2"\ +D["\1"]=" \3"/p +s/^ \('"$ac_word_re"'\)[ ]*\(.*\)/D["\1"]=" \2"/p +d +:bsnl +s/["\\]/\\&/g +s/^ \('"$ac_word_re"'\)\(([^()]*)\)[ ]*\(.*\)/P["\1"]="\2"\ +D["\1"]=" \3\\\\\\n"\\/p +t cont +s/^ \('"$ac_word_re"'\)[ ]*\(.*\)/D["\1"]=" \2\\\\\\n"\\/p +t cont +d +:cont +n +s/.\{148\}/&'"$ac_delim"'/g +t clear +:clear +s/\\$// +t bsnlc +s/["\\]/\\&/g; s/^/"/; s/$/"/p +d +:bsnlc +s/["\\]/\\&/g; s/^/"/; s/$/\\\\\\n"\\/p +b cont +' >$CONFIG_STATUS || ac_write_fail=1 + +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 + for (key in D) D_is_set[key] = 1 + FS = "" +} +/^[\t ]*#[\t ]*(define|undef)[\t ]+$ac_word_re([\t (]|\$)/ { + line = \$ 0 + split(line, arg, " ") + if (arg[1] == "#") { + defundef = arg[2] + mac1 = arg[3] + } else { + defundef = substr(arg[1], 2) + mac1 = arg[2] + } + split(mac1, mac2, "(") #) + macro = mac2[1] + prefix = substr(line, 1, index(line, defundef) - 1) + if (D_is_set[macro]) { + # Preserve the white space surrounding the "#". + print prefix "define", macro P[macro] D[macro] + next + } else { + # Replace #undef with comments. This is necessary, for example, + # in the case of _POSIX_SOURCE, which is predefined and required + # on some systems where configure will not decide to define it. + if (defundef == "undef") { + print "/*", prefix defundef, macro, "*/" + next + } + } +} +{ print } +_ACAWK +_ACEOF +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 + as_fn_error $? "could not setup config headers machinery" "$LINENO" 5 +fi # test -n "$CONFIG_HEADERS" + + +eval set X " :F $CONFIG_FILES :H $CONFIG_HEADERS :C $CONFIG_COMMANDS" +shift +for ac_tag +do + case $ac_tag in + :[FHLC]) ac_mode=$ac_tag; continue;; + esac + case $ac_mode$ac_tag in + :[FHL]*:*);; + :L* | :C*:*) as_fn_error $? "invalid tag \`$ac_tag'" "$LINENO" 5;; + :[FH]-) ac_tag=-:-;; + :[FH]*) ac_tag=$ac_tag:$ac_tag.in;; + esac + ac_save_IFS=$IFS + IFS=: + set x $ac_tag + IFS=$ac_save_IFS + shift + ac_file=$1 + shift + + case $ac_mode in + :L) ac_source=$1;; + :[FH]) + ac_file_inputs= + for ac_f + do + case $ac_f in + -) ac_f="$ac_tmp/stdin";; + *) # Look for the file first in the build tree, then in the source tree + # (if the path is not absolute). The absolute path cannot be DOS-style, + # because $ac_f cannot contain `:'. + test -f "$ac_f" || + case $ac_f in + [\\/$]*) false;; + *) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";; + esac || + as_fn_error 1 "cannot find input file: \`$ac_f'" "$LINENO" 5;; + esac + case $ac_f in *\'*) ac_f=`$as_echo "$ac_f" | sed "s/'/'\\\\\\\\''/g"`;; esac + as_fn_append ac_file_inputs " '$ac_f'" + done + + # Let's still pretend it is `configure' which instantiates (i.e., don't + # use $as_me), people would be surprised to read: + # /* config.h. Generated by config.status. */ + configure_input='Generated from '` + $as_echo "$*" | sed 's|^[^:]*/||;s|:[^:]*/|, |g' + `' by configure.' + if test x"$ac_file" != x-; then + configure_input="$ac_file. $configure_input" + { $as_echo "$as_me:${as_lineno-$LINENO}: creating $ac_file" >&5 +$as_echo "$as_me: creating $ac_file" >&6;} + fi + # Neutralize special characters interpreted by sed in replacement strings. + case $configure_input in #( + *\&* | *\|* | *\\* ) + ac_sed_conf_input=`$as_echo "$configure_input" | + sed 's/[\\\\&|]/\\\\&/g'`;; #( + *) ac_sed_conf_input=$configure_input;; + esac + + case $ac_tag in + *:-:* | *:-) cat >"$ac_tmp/stdin" \ + || as_fn_error $? "could not create $ac_file" "$LINENO" 5 ;; + esac + ;; + esac + + ac_dir=`$as_dirname -- "$ac_file" || +$as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ + X"$ac_file" : 'X\(//\)[^/]' \| \ + X"$ac_file" : 'X\(//\)$' \| \ + X"$ac_file" : 'X\(/\)' \| . 2>/dev/null || +$as_echo X"$ac_file" | + sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ + s//\1/ + q + } + /^X\(\/\/\)[^/].*/{ + s//\1/ + q + } + /^X\(\/\/\)$/{ + s//\1/ + q + } + /^X\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q'` + as_dir="$ac_dir"; as_fn_mkdir_p + ac_builddir=. + +case "$ac_dir" in +.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;; +*) + ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'` + # A ".." for each directory in $ac_dir_suffix. + ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'` + case $ac_top_builddir_sub in + "") ac_top_builddir_sub=. ac_top_build_prefix= ;; + *) ac_top_build_prefix=$ac_top_builddir_sub/ ;; + esac ;; +esac +ac_abs_top_builddir=$ac_pwd +ac_abs_builddir=$ac_pwd$ac_dir_suffix +# for backward compatibility: +ac_top_builddir=$ac_top_build_prefix + +case $srcdir in + .) # We are building in place. + ac_srcdir=. + ac_top_srcdir=$ac_top_builddir_sub + ac_abs_top_srcdir=$ac_pwd ;; + [\\/]* | ?:[\\/]* ) # Absolute name. + ac_srcdir=$srcdir$ac_dir_suffix; + ac_top_srcdir=$srcdir + ac_abs_top_srcdir=$srcdir ;; + *) # Relative name. + ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix + ac_top_srcdir=$ac_top_build_prefix$srcdir + ac_abs_top_srcdir=$ac_pwd/$srcdir ;; +esac +ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix + + + case $ac_mode in + :F) + # + # CONFIG_FILE + # + + case $INSTALL in + [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;; + *) ac_INSTALL=$ac_top_build_prefix$INSTALL ;; + esac + ac_MKDIR_P=$MKDIR_P + case $MKDIR_P in + [\\/$]* | ?:[\\/]* ) ;; + */*) ac_MKDIR_P=$ac_top_build_prefix$MKDIR_P ;; + esac +_ACEOF + +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +# If the template does not know about datarootdir, expand it. +# FIXME: This hack should be removed a few years after 2.60. +ac_datarootdir_hack=; ac_datarootdir_seen= +ac_sed_dataroot=' +/datarootdir/ { + p + q +} +/@datadir@/p +/@docdir@/p +/@infodir@/p +/@localedir@/p +/@mandir@/p' +case `eval "sed -n \"\$ac_sed_dataroot\" $ac_file_inputs"` in +*datarootdir*) ac_datarootdir_seen=yes;; +*@datadir@*|*@docdir@*|*@infodir@*|*@localedir@*|*@mandir@*) + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5 +$as_echo "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;} +_ACEOF +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 + ac_datarootdir_hack=' + s&@datadir@&$datadir&g + s&@docdir@&$docdir&g + s&@infodir@&$infodir&g + s&@localedir@&$localedir&g + s&@mandir@&$mandir&g + s&\\\${datarootdir}&$datarootdir&g' ;; +esac +_ACEOF + +# Neutralize VPATH when `$srcdir' = `.'. +# Shell code in configure.ac might set extrasub. +# FIXME: do we really want to maintain this feature? +cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 +ac_sed_extra="$ac_vpsub +$extrasub +_ACEOF +cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 +:t +/@[a-zA-Z_][a-zA-Z_0-9]*@/!b +s|@configure_input@|$ac_sed_conf_input|;t t +s&@top_builddir@&$ac_top_builddir_sub&;t t +s&@top_build_prefix@&$ac_top_build_prefix&;t t +s&@srcdir@&$ac_srcdir&;t t +s&@abs_srcdir@&$ac_abs_srcdir&;t t +s&@top_srcdir@&$ac_top_srcdir&;t t +s&@abs_top_srcdir@&$ac_abs_top_srcdir&;t t +s&@builddir@&$ac_builddir&;t t +s&@abs_builddir@&$ac_abs_builddir&;t t +s&@abs_top_builddir@&$ac_abs_top_builddir&;t t +s&@INSTALL@&$ac_INSTALL&;t t +s&@MKDIR_P@&$ac_MKDIR_P&;t t +$ac_datarootdir_hack +" +eval sed \"\$ac_sed_extra\" "$ac_file_inputs" | $AWK -f "$ac_tmp/subs.awk" \ + >$ac_tmp/out || as_fn_error $? "could not create $ac_file" "$LINENO" 5 + +test -z "$ac_datarootdir_hack$ac_datarootdir_seen" && + { ac_out=`sed -n '/\${datarootdir}/p' "$ac_tmp/out"`; test -n "$ac_out"; } && + { ac_out=`sed -n '/^[ ]*datarootdir[ ]*:*=/p' \ + "$ac_tmp/out"`; test -z "$ac_out"; } && + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file contains a reference to the variable \`datarootdir' +which seems to be undefined. Please make sure it is defined" >&5 +$as_echo "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir' +which seems to be undefined. Please make sure it is defined" >&2;} + + rm -f "$ac_tmp/stdin" + case $ac_file in + -) cat "$ac_tmp/out" && rm -f "$ac_tmp/out";; + *) rm -f "$ac_file" && mv "$ac_tmp/out" "$ac_file";; + esac \ + || as_fn_error $? "could not create $ac_file" "$LINENO" 5 + ;; + :H) + # + # CONFIG_HEADER + # + if test x"$ac_file" != x-; then + { + $as_echo "/* $configure_input */" \ + && eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs" + } >"$ac_tmp/config.h" \ + || as_fn_error $? "could not create $ac_file" "$LINENO" 5 + if diff "$ac_file" "$ac_tmp/config.h" >/dev/null 2>&1; then + { $as_echo "$as_me:${as_lineno-$LINENO}: $ac_file is unchanged" >&5 +$as_echo "$as_me: $ac_file is unchanged" >&6;} + else + rm -f "$ac_file" + mv "$ac_tmp/config.h" "$ac_file" \ + || as_fn_error $? "could not create $ac_file" "$LINENO" 5 + fi + else + $as_echo "/* $configure_input */" \ + && eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs" \ + || as_fn_error $? "could not create -" "$LINENO" 5 + fi +# Compute "$ac_file"'s index in $config_headers. +_am_arg="$ac_file" +_am_stamp_count=1 +for _am_header in $config_headers :; do + case $_am_header in + $_am_arg | $_am_arg:* ) + break ;; + * ) + _am_stamp_count=`expr $_am_stamp_count + 1` ;; + esac +done +echo "timestamp for $_am_arg" >`$as_dirname -- "$_am_arg" || +$as_expr X"$_am_arg" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ + X"$_am_arg" : 'X\(//\)[^/]' \| \ + X"$_am_arg" : 'X\(//\)$' \| \ + X"$_am_arg" : 'X\(/\)' \| . 2>/dev/null || +$as_echo X"$_am_arg" | + sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ + s//\1/ + q + } + /^X\(\/\/\)[^/].*/{ + s//\1/ + q + } + /^X\(\/\/\)$/{ + s//\1/ + q + } + /^X\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q'`/stamp-h$_am_stamp_count + ;; + + :C) { $as_echo "$as_me:${as_lineno-$LINENO}: executing $ac_file commands" >&5 +$as_echo "$as_me: executing $ac_file commands" >&6;} + ;; + esac + + + case $ac_file$ac_mode in + "depfiles":C) test x"$AMDEP_TRUE" != x"" || { + # Autoconf 2.62 quotes --file arguments for eval, but not when files + # are listed without --file. Let's play safe and only enable the eval + # if we detect the quoting. + case $CONFIG_FILES in + *\'*) eval set x "$CONFIG_FILES" ;; + *) set x $CONFIG_FILES ;; + esac + shift + for mf + do + # Strip MF so we end up with the name of the file. + mf=`echo "$mf" | sed -e 's/:.*$//'` + # Check whether this is an Automake generated Makefile or not. + # We used to match only the files named 'Makefile.in', but + # some people rename them; so instead we look at the file content. + # Grep'ing the first line is not enough: some people post-process + # each Makefile.in and add a new line on top of each file to say so. + # Grep'ing the whole file is not good either: AIX grep has a line + # limit of 2048, but all sed's we know have understand at least 4000. + if sed -n 's,^#.*generated by automake.*,X,p' "$mf" | grep X >/dev/null 2>&1; then + dirpart=`$as_dirname -- "$mf" || +$as_expr X"$mf" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ + X"$mf" : 'X\(//\)[^/]' \| \ + X"$mf" : 'X\(//\)$' \| \ + X"$mf" : 'X\(/\)' \| . 2>/dev/null || +$as_echo X"$mf" | + sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ + s//\1/ + q + } + /^X\(\/\/\)[^/].*/{ + s//\1/ + q + } + /^X\(\/\/\)$/{ + s//\1/ + q + } + /^X\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q'` + else + continue + fi + # Extract the definition of DEPDIR, am__include, and am__quote + # from the Makefile without running 'make'. + DEPDIR=`sed -n 's/^DEPDIR = //p' < "$mf"` + test -z "$DEPDIR" && continue + am__include=`sed -n 's/^am__include = //p' < "$mf"` + test -z "am__include" && continue + am__quote=`sed -n 's/^am__quote = //p' < "$mf"` + # Find all dependency output files, they are included files with + # $(DEPDIR) in their names. We invoke sed twice because it is the + # simplest approach to changing $(DEPDIR) to its actual value in the + # expansion. + for file in `sed -n " + s/^$am__include $am__quote\(.*(DEPDIR).*\)$am__quote"'$/\1/p' <"$mf" | \ + sed -e 's/\$(DEPDIR)/'"$DEPDIR"'/g'`; do + # Make sure the directory exists. + test -f "$dirpart/$file" && continue + fdir=`$as_dirname -- "$file" || +$as_expr X"$file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ + X"$file" : 'X\(//\)[^/]' \| \ + X"$file" : 'X\(//\)$' \| \ + X"$file" : 'X\(/\)' \| . 2>/dev/null || +$as_echo X"$file" | + sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ + s//\1/ + q + } + /^X\(\/\/\)[^/].*/{ + s//\1/ + q + } + /^X\(\/\/\)$/{ + s//\1/ + q + } + /^X\(\/\).*/{ + s//\1/ + q + } + s/.*/./; q'` + as_dir=$dirpart/$fdir; as_fn_mkdir_p + # echo "creating $dirpart/$file" + echo '# dummy' > "$dirpart/$file" + done + done +} + ;; + "libtool":C) + + # See if we are running on zsh, and set the options which allow our + # commands through without removal of \ escapes. + if test -n "${ZSH_VERSION+set}" ; then + setopt NO_GLOB_SUBST + fi + + cfgfile="${ofile}T" + trap "$RM \"$cfgfile\"; exit 1" 1 2 15 + $RM "$cfgfile" + + cat <<_LT_EOF >> "$cfgfile" +#! $SHELL + +# `$ECHO "$ofile" | sed 's%^.*/%%'` - Provide generalized library-building support services. +# Generated automatically by $as_me ($PACKAGE$TIMESTAMP) $VERSION +# Libtool was configured on host `(hostname || uname -n) 2>/dev/null | sed 1q`: +# NOTE: Changes made to this file will be lost: look at ltmain.sh. +# +# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, +# 2006, 2007, 2008, 2009, 2010, 2011 Free Software +# Foundation, Inc. +# Written by Gordon Matzigkeit, 1996 +# +# This file is part of GNU Libtool. +# +# GNU Libtool is free software; you can redistribute it and/or +# modify it under the terms of the GNU General Public License as +# published by the Free Software Foundation; either version 2 of +# the License, or (at your option) any later version. +# +# As a special exception to the GNU General Public License, +# if you distribute this file as part of a program or library that +# is built using GNU Libtool, you may include this file under the +# same distribution terms that you use for the rest of that program. +# +# GNU Libtool is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with GNU Libtool; see the file COPYING. If not, a copy +# can be downloaded from http://www.gnu.org/licenses/gpl.html, or +# obtained by writing to the Free Software Foundation, Inc., +# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + + +# The names of the tagged configurations supported by this script. +available_tags="CXX " + +# ### BEGIN LIBTOOL CONFIG + +# Which release of libtool.m4 was used? +macro_version=$macro_version +macro_revision=$macro_revision + +# Assembler program. +AS=$lt_AS + +# DLL creation program. +DLLTOOL=$lt_DLLTOOL + +# Object dumper program. +OBJDUMP=$lt_OBJDUMP + +# Whether or not to build shared libraries. +build_libtool_libs=$enable_shared + +# Whether or not to build static libraries. +build_old_libs=$enable_static + +# What type of objects to build. +pic_mode=$pic_mode + +# Whether or not to optimize for fast installation. +fast_install=$enable_fast_install + +# Shell to use when invoking shell scripts. +SHELL=$lt_SHELL + +# An echo program that protects backslashes. +ECHO=$lt_ECHO + +# The PATH separator for the build system. +PATH_SEPARATOR=$lt_PATH_SEPARATOR + +# The host system. +host_alias=$host_alias +host=$host +host_os=$host_os + +# The build system. +build_alias=$build_alias +build=$build +build_os=$build_os + +# A sed program that does not truncate output. +SED=$lt_SED + +# Sed that helps us avoid accidentally triggering echo(1) options like -n. +Xsed="\$SED -e 1s/^X//" + +# A grep program that handles long lines. +GREP=$lt_GREP + +# An ERE matcher. +EGREP=$lt_EGREP + +# A literal string matcher. +FGREP=$lt_FGREP + +# A BSD- or MS-compatible name lister. +NM=$lt_NM + +# Whether we need soft or hard links. +LN_S=$lt_LN_S + +# What is the maximum length of a command? +max_cmd_len=$max_cmd_len + +# Object file suffix (normally "o"). +objext=$ac_objext + +# Executable file suffix (normally ""). +exeext=$exeext + +# whether the shell understands "unset". +lt_unset=$lt_unset + +# turn spaces into newlines. +SP2NL=$lt_lt_SP2NL + +# turn newlines into spaces. +NL2SP=$lt_lt_NL2SP + +# convert \$build file names to \$host format. +to_host_file_cmd=$lt_cv_to_host_file_cmd + +# convert \$build files to toolchain format. +to_tool_file_cmd=$lt_cv_to_tool_file_cmd + +# Method to check whether dependent libraries are shared objects. +deplibs_check_method=$lt_deplibs_check_method + +# Command to use when deplibs_check_method = "file_magic". +file_magic_cmd=$lt_file_magic_cmd + +# How to find potential files when deplibs_check_method = "file_magic". +file_magic_glob=$lt_file_magic_glob + +# Find potential files using nocaseglob when deplibs_check_method = "file_magic". +want_nocaseglob=$lt_want_nocaseglob + +# Command to associate shared and link libraries. +sharedlib_from_linklib_cmd=$lt_sharedlib_from_linklib_cmd + +# The archiver. +AR=$lt_AR + +# Flags to create an archive. +AR_FLAGS=$lt_AR_FLAGS + +# How to feed a file listing to the archiver. +archiver_list_spec=$lt_archiver_list_spec + +# A symbol stripping program. +STRIP=$lt_STRIP + +# Commands used to install an old-style archive. +RANLIB=$lt_RANLIB +old_postinstall_cmds=$lt_old_postinstall_cmds +old_postuninstall_cmds=$lt_old_postuninstall_cmds + +# Whether to use a lock for old archive extraction. +lock_old_archive_extraction=$lock_old_archive_extraction + +# A C compiler. +LTCC=$lt_CC + +# LTCC compiler flags. +LTCFLAGS=$lt_CFLAGS + +# Take the output of nm and produce a listing of raw symbols and C names. +global_symbol_pipe=$lt_lt_cv_sys_global_symbol_pipe + +# Transform the output of nm in a proper C declaration. +global_symbol_to_cdecl=$lt_lt_cv_sys_global_symbol_to_cdecl + +# Transform the output of nm in a C name address pair. +global_symbol_to_c_name_address=$lt_lt_cv_sys_global_symbol_to_c_name_address + +# Transform the output of nm in a C name address pair when lib prefix is needed. +global_symbol_to_c_name_address_lib_prefix=$lt_lt_cv_sys_global_symbol_to_c_name_address_lib_prefix + +# Specify filename containing input files for \$NM. +nm_file_list_spec=$lt_nm_file_list_spec + +# The root where to search for dependent libraries,and in which our libraries should be installed. +lt_sysroot=$lt_sysroot + +# The name of the directory that contains temporary libtool files. +objdir=$objdir + +# Used to examine libraries when file_magic_cmd begins with "file". +MAGIC_CMD=$MAGIC_CMD + +# Must we lock files when doing compilation? +need_locks=$lt_need_locks + +# Manifest tool. +MANIFEST_TOOL=$lt_MANIFEST_TOOL + +# Tool to manipulate archived DWARF debug symbol files on Mac OS X. +DSYMUTIL=$lt_DSYMUTIL + +# Tool to change global to local symbols on Mac OS X. +NMEDIT=$lt_NMEDIT + +# Tool to manipulate fat objects and archives on Mac OS X. +LIPO=$lt_LIPO + +# ldd/readelf like tool for Mach-O binaries on Mac OS X. +OTOOL=$lt_OTOOL + +# ldd/readelf like tool for 64 bit Mach-O binaries on Mac OS X 10.4. +OTOOL64=$lt_OTOOL64 + +# Old archive suffix (normally "a"). +libext=$libext + +# Shared library suffix (normally ".so"). +shrext_cmds=$lt_shrext_cmds + +# The commands to extract the exported symbol list from a shared archive. +extract_expsyms_cmds=$lt_extract_expsyms_cmds + +# Variables whose values should be saved in libtool wrapper scripts and +# restored at link time. +variables_saved_for_relink=$lt_variables_saved_for_relink + +# Do we need the "lib" prefix for modules? +need_lib_prefix=$need_lib_prefix + +# Do we need a version for libraries? +need_version=$need_version + +# Library versioning type. +version_type=$version_type + +# Shared library runtime path variable. +runpath_var=$runpath_var + +# Shared library path variable. +shlibpath_var=$shlibpath_var + +# Is shlibpath searched before the hard-coded library search path? +shlibpath_overrides_runpath=$shlibpath_overrides_runpath + +# Format of library name prefix. +libname_spec=$lt_libname_spec + +# List of archive names. First name is the real one, the rest are links. +# The last name is the one that the linker finds with -lNAME +library_names_spec=$lt_library_names_spec + +# The coded name of the library, if different from the real name. +soname_spec=$lt_soname_spec + +# Permission mode override for installation of shared libraries. +install_override_mode=$lt_install_override_mode + +# Command to use after installation of a shared archive. +postinstall_cmds=$lt_postinstall_cmds + +# Command to use after uninstallation of a shared archive. +postuninstall_cmds=$lt_postuninstall_cmds + +# Commands used to finish a libtool library installation in a directory. +finish_cmds=$lt_finish_cmds + +# As "finish_cmds", except a single script fragment to be evaled but +# not shown. +finish_eval=$lt_finish_eval + +# Whether we should hardcode library paths into libraries. +hardcode_into_libs=$hardcode_into_libs + +# Compile-time system search path for libraries. +sys_lib_search_path_spec=$lt_sys_lib_search_path_spec + +# Run-time system search path for libraries. +sys_lib_dlsearch_path_spec=$lt_sys_lib_dlsearch_path_spec + +# Whether dlopen is supported. +dlopen_support=$enable_dlopen + +# Whether dlopen of programs is supported. +dlopen_self=$enable_dlopen_self + +# Whether dlopen of statically linked programs is supported. +dlopen_self_static=$enable_dlopen_self_static + +# Commands to strip libraries. +old_striplib=$lt_old_striplib +striplib=$lt_striplib + + +# The linker used to build libraries. +LD=$lt_LD + +# How to create reloadable object files. +reload_flag=$lt_reload_flag +reload_cmds=$lt_reload_cmds + +# Commands used to build an old-style archive. +old_archive_cmds=$lt_old_archive_cmds + +# A language specific compiler. +CC=$lt_compiler + +# Is the compiler the GNU compiler? +with_gcc=$GCC + +# Compiler flag to turn off builtin functions. +no_builtin_flag=$lt_lt_prog_compiler_no_builtin_flag + +# Additional compiler flags for building library objects. +pic_flag=$lt_lt_prog_compiler_pic + +# How to pass a linker flag through the compiler. +wl=$lt_lt_prog_compiler_wl + +# Compiler flag to prevent dynamic linking. +link_static_flag=$lt_lt_prog_compiler_static + +# Does compiler simultaneously support -c and -o options? +compiler_c_o=$lt_lt_cv_prog_compiler_c_o + +# Whether or not to add -lc for building shared libraries. +build_libtool_need_lc=$archive_cmds_need_lc + +# Whether or not to disallow shared libs when runtime libs are static. +allow_libtool_libs_with_static_runtimes=$enable_shared_with_static_runtimes + +# Compiler flag to allow reflexive dlopens. +export_dynamic_flag_spec=$lt_export_dynamic_flag_spec + +# Compiler flag to generate shared objects directly from archives. +whole_archive_flag_spec=$lt_whole_archive_flag_spec + +# Whether the compiler copes with passing no objects directly. +compiler_needs_object=$lt_compiler_needs_object + +# Create an old-style archive from a shared archive. +old_archive_from_new_cmds=$lt_old_archive_from_new_cmds + +# Create a temporary old-style archive to link instead of a shared archive. +old_archive_from_expsyms_cmds=$lt_old_archive_from_expsyms_cmds + +# Commands used to build a shared archive. +archive_cmds=$lt_archive_cmds +archive_expsym_cmds=$lt_archive_expsym_cmds + +# Commands used to build a loadable module if different from building +# a shared archive. +module_cmds=$lt_module_cmds +module_expsym_cmds=$lt_module_expsym_cmds + +# Whether we are building with GNU ld or not. +with_gnu_ld=$lt_with_gnu_ld + +# Flag that allows shared libraries with undefined symbols to be built. +allow_undefined_flag=$lt_allow_undefined_flag + +# Flag that enforces no undefined symbols. +no_undefined_flag=$lt_no_undefined_flag + +# Flag to hardcode \$libdir into a binary during linking. +# This must work even if \$libdir does not exist +hardcode_libdir_flag_spec=$lt_hardcode_libdir_flag_spec + +# Whether we need a single "-rpath" flag with a separated argument. +hardcode_libdir_separator=$lt_hardcode_libdir_separator + +# Set to "yes" if using DIR/libNAME\${shared_ext} during linking hardcodes +# DIR into the resulting binary. +hardcode_direct=$hardcode_direct + +# Set to "yes" if using DIR/libNAME\${shared_ext} during linking hardcodes +# DIR into the resulting binary and the resulting library dependency is +# "absolute",i.e impossible to change by setting \${shlibpath_var} if the +# library is relocated. +hardcode_direct_absolute=$hardcode_direct_absolute + +# Set to "yes" if using the -LDIR flag during linking hardcodes DIR +# into the resulting binary. +hardcode_minus_L=$hardcode_minus_L + +# Set to "yes" if using SHLIBPATH_VAR=DIR during linking hardcodes DIR +# into the resulting binary. +hardcode_shlibpath_var=$hardcode_shlibpath_var + +# Set to "yes" if building a shared library automatically hardcodes DIR +# into the library and all subsequent libraries and executables linked +# against it. +hardcode_automatic=$hardcode_automatic + +# Set to yes if linker adds runtime paths of dependent libraries +# to runtime path list. +inherit_rpath=$inherit_rpath + +# Whether libtool must link a program against all its dependency libraries. +link_all_deplibs=$link_all_deplibs + +# Set to "yes" if exported symbols are required. +always_export_symbols=$always_export_symbols + +# The commands to list exported symbols. +export_symbols_cmds=$lt_export_symbols_cmds + +# Symbols that should not be listed in the preloaded symbols. +exclude_expsyms=$lt_exclude_expsyms + +# Symbols that must always be exported. +include_expsyms=$lt_include_expsyms + +# Commands necessary for linking programs (against libraries) with templates. +prelink_cmds=$lt_prelink_cmds + +# Commands necessary for finishing linking programs. +postlink_cmds=$lt_postlink_cmds + +# Specify filename containing input files. +file_list_spec=$lt_file_list_spec + +# How to hardcode a shared library path into an executable. +hardcode_action=$hardcode_action + +# The directories searched by this compiler when creating a shared library. +compiler_lib_search_dirs=$lt_compiler_lib_search_dirs + +# Dependencies to place before and after the objects being linked to +# create a shared library. +predep_objects=$lt_predep_objects +postdep_objects=$lt_postdep_objects +predeps=$lt_predeps +postdeps=$lt_postdeps + +# The library search path used internally by the compiler when linking +# a shared library. +compiler_lib_search_path=$lt_compiler_lib_search_path + +# ### END LIBTOOL CONFIG + +_LT_EOF + + case $host_os in + aix3*) + cat <<\_LT_EOF >> "$cfgfile" +# AIX sometimes has problems with the GCC collect2 program. For some +# reason, if we set the COLLECT_NAMES environment variable, the problems +# vanish in a puff of smoke. +if test "X${COLLECT_NAMES+set}" != Xset; then + COLLECT_NAMES= + export COLLECT_NAMES +fi +_LT_EOF + ;; + esac + + +ltmain="$ac_aux_dir/ltmain.sh" + + + # We use sed instead of cat because bash on DJGPP gets confused if + # if finds mixed CR/LF and LF-only lines. Since sed operates in + # text mode, it properly converts lines to CR/LF. This bash problem + # is reportedly fixed, but why not run on old versions too? + sed '$q' "$ltmain" >> "$cfgfile" \ + || (rm -f "$cfgfile"; exit 1) + + if test x"$xsi_shell" = xyes; then + sed -e '/^func_dirname ()$/,/^} # func_dirname /c\ +func_dirname ()\ +{\ +\ case ${1} in\ +\ */*) func_dirname_result="${1%/*}${2}" ;;\ +\ * ) func_dirname_result="${3}" ;;\ +\ esac\ +} # Extended-shell func_dirname implementation' "$cfgfile" > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") +test 0 -eq $? || _lt_function_replace_fail=: + + + sed -e '/^func_basename ()$/,/^} # func_basename /c\ +func_basename ()\ +{\ +\ func_basename_result="${1##*/}"\ +} # Extended-shell func_basename implementation' "$cfgfile" > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") +test 0 -eq $? || _lt_function_replace_fail=: + + + sed -e '/^func_dirname_and_basename ()$/,/^} # func_dirname_and_basename /c\ +func_dirname_and_basename ()\ +{\ +\ case ${1} in\ +\ */*) func_dirname_result="${1%/*}${2}" ;;\ +\ * ) func_dirname_result="${3}" ;;\ +\ esac\ +\ func_basename_result="${1##*/}"\ +} # Extended-shell func_dirname_and_basename implementation' "$cfgfile" > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") +test 0 -eq $? || _lt_function_replace_fail=: + + + sed -e '/^func_stripname ()$/,/^} # func_stripname /c\ +func_stripname ()\ +{\ +\ # pdksh 5.2.14 does not do ${X%$Y} correctly if both X and Y are\ +\ # positional parameters, so assign one to ordinary parameter first.\ +\ func_stripname_result=${3}\ +\ func_stripname_result=${func_stripname_result#"${1}"}\ +\ func_stripname_result=${func_stripname_result%"${2}"}\ +} # Extended-shell func_stripname implementation' "$cfgfile" > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") +test 0 -eq $? || _lt_function_replace_fail=: + + + sed -e '/^func_split_long_opt ()$/,/^} # func_split_long_opt /c\ +func_split_long_opt ()\ +{\ +\ func_split_long_opt_name=${1%%=*}\ +\ func_split_long_opt_arg=${1#*=}\ +} # Extended-shell func_split_long_opt implementation' "$cfgfile" > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") +test 0 -eq $? || _lt_function_replace_fail=: + + + sed -e '/^func_split_short_opt ()$/,/^} # func_split_short_opt /c\ +func_split_short_opt ()\ +{\ +\ func_split_short_opt_arg=${1#??}\ +\ func_split_short_opt_name=${1%"$func_split_short_opt_arg"}\ +} # Extended-shell func_split_short_opt implementation' "$cfgfile" > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") +test 0 -eq $? || _lt_function_replace_fail=: + + + sed -e '/^func_lo2o ()$/,/^} # func_lo2o /c\ +func_lo2o ()\ +{\ +\ case ${1} in\ +\ *.lo) func_lo2o_result=${1%.lo}.${objext} ;;\ +\ *) func_lo2o_result=${1} ;;\ +\ esac\ +} # Extended-shell func_lo2o implementation' "$cfgfile" > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") +test 0 -eq $? || _lt_function_replace_fail=: + + + sed -e '/^func_xform ()$/,/^} # func_xform /c\ +func_xform ()\ +{\ + func_xform_result=${1%.*}.lo\ +} # Extended-shell func_xform implementation' "$cfgfile" > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") +test 0 -eq $? || _lt_function_replace_fail=: + + + sed -e '/^func_arith ()$/,/^} # func_arith /c\ +func_arith ()\ +{\ + func_arith_result=$(( $* ))\ +} # Extended-shell func_arith implementation' "$cfgfile" > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") +test 0 -eq $? || _lt_function_replace_fail=: + + + sed -e '/^func_len ()$/,/^} # func_len /c\ +func_len ()\ +{\ + func_len_result=${#1}\ +} # Extended-shell func_len implementation' "$cfgfile" > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") +test 0 -eq $? || _lt_function_replace_fail=: + +fi + +if test x"$lt_shell_append" = xyes; then + sed -e '/^func_append ()$/,/^} # func_append /c\ +func_append ()\ +{\ + eval "${1}+=\\${2}"\ +} # Extended-shell func_append implementation' "$cfgfile" > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") +test 0 -eq $? || _lt_function_replace_fail=: + + + sed -e '/^func_append_quoted ()$/,/^} # func_append_quoted /c\ +func_append_quoted ()\ +{\ +\ func_quote_for_eval "${2}"\ +\ eval "${1}+=\\\\ \\$func_quote_for_eval_result"\ +} # Extended-shell func_append_quoted implementation' "$cfgfile" > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") +test 0 -eq $? || _lt_function_replace_fail=: + + + # Save a `func_append' function call where possible by direct use of '+=' + sed -e 's%func_append \([a-zA-Z_]\{1,\}\) "%\1+="%g' $cfgfile > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") + test 0 -eq $? || _lt_function_replace_fail=: +else + # Save a `func_append' function call even when '+=' is not available + sed -e 's%func_append \([a-zA-Z_]\{1,\}\) "%\1="$\1%g' $cfgfile > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") + test 0 -eq $? || _lt_function_replace_fail=: +fi + +if test x"$_lt_function_replace_fail" = x":"; then + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Unable to substitute extended shell functions in $ofile" >&5 +$as_echo "$as_me: WARNING: Unable to substitute extended shell functions in $ofile" >&2;} +fi + + + mv -f "$cfgfile" "$ofile" || + (rm -f "$ofile" && cp "$cfgfile" "$ofile" && rm -f "$cfgfile") + chmod +x "$ofile" + + + cat <<_LT_EOF >> "$ofile" + +# ### BEGIN LIBTOOL TAG CONFIG: CXX + +# The linker used to build libraries. +LD=$lt_LD_CXX + +# How to create reloadable object files. +reload_flag=$lt_reload_flag_CXX +reload_cmds=$lt_reload_cmds_CXX + +# Commands used to build an old-style archive. +old_archive_cmds=$lt_old_archive_cmds_CXX + +# A language specific compiler. +CC=$lt_compiler_CXX + +# Is the compiler the GNU compiler? +with_gcc=$GCC_CXX + +# Compiler flag to turn off builtin functions. +no_builtin_flag=$lt_lt_prog_compiler_no_builtin_flag_CXX + +# Additional compiler flags for building library objects. +pic_flag=$lt_lt_prog_compiler_pic_CXX + +# How to pass a linker flag through the compiler. +wl=$lt_lt_prog_compiler_wl_CXX + +# Compiler flag to prevent dynamic linking. +link_static_flag=$lt_lt_prog_compiler_static_CXX + +# Does compiler simultaneously support -c and -o options? +compiler_c_o=$lt_lt_cv_prog_compiler_c_o_CXX + +# Whether or not to add -lc for building shared libraries. +build_libtool_need_lc=$archive_cmds_need_lc_CXX + +# Whether or not to disallow shared libs when runtime libs are static. +allow_libtool_libs_with_static_runtimes=$enable_shared_with_static_runtimes_CXX + +# Compiler flag to allow reflexive dlopens. +export_dynamic_flag_spec=$lt_export_dynamic_flag_spec_CXX + +# Compiler flag to generate shared objects directly from archives. +whole_archive_flag_spec=$lt_whole_archive_flag_spec_CXX + +# Whether the compiler copes with passing no objects directly. +compiler_needs_object=$lt_compiler_needs_object_CXX + +# Create an old-style archive from a shared archive. +old_archive_from_new_cmds=$lt_old_archive_from_new_cmds_CXX + +# Create a temporary old-style archive to link instead of a shared archive. +old_archive_from_expsyms_cmds=$lt_old_archive_from_expsyms_cmds_CXX + +# Commands used to build a shared archive. +archive_cmds=$lt_archive_cmds_CXX +archive_expsym_cmds=$lt_archive_expsym_cmds_CXX + +# Commands used to build a loadable module if different from building +# a shared archive. +module_cmds=$lt_module_cmds_CXX +module_expsym_cmds=$lt_module_expsym_cmds_CXX + +# Whether we are building with GNU ld or not. +with_gnu_ld=$lt_with_gnu_ld_CXX + +# Flag that allows shared libraries with undefined symbols to be built. +allow_undefined_flag=$lt_allow_undefined_flag_CXX + +# Flag that enforces no undefined symbols. +no_undefined_flag=$lt_no_undefined_flag_CXX + +# Flag to hardcode \$libdir into a binary during linking. +# This must work even if \$libdir does not exist +hardcode_libdir_flag_spec=$lt_hardcode_libdir_flag_spec_CXX + +# Whether we need a single "-rpath" flag with a separated argument. +hardcode_libdir_separator=$lt_hardcode_libdir_separator_CXX + +# Set to "yes" if using DIR/libNAME\${shared_ext} during linking hardcodes +# DIR into the resulting binary. +hardcode_direct=$hardcode_direct_CXX + +# Set to "yes" if using DIR/libNAME\${shared_ext} during linking hardcodes +# DIR into the resulting binary and the resulting library dependency is +# "absolute",i.e impossible to change by setting \${shlibpath_var} if the +# library is relocated. +hardcode_direct_absolute=$hardcode_direct_absolute_CXX + +# Set to "yes" if using the -LDIR flag during linking hardcodes DIR +# into the resulting binary. +hardcode_minus_L=$hardcode_minus_L_CXX + +# Set to "yes" if using SHLIBPATH_VAR=DIR during linking hardcodes DIR +# into the resulting binary. +hardcode_shlibpath_var=$hardcode_shlibpath_var_CXX + +# Set to "yes" if building a shared library automatically hardcodes DIR +# into the library and all subsequent libraries and executables linked +# against it. +hardcode_automatic=$hardcode_automatic_CXX + +# Set to yes if linker adds runtime paths of dependent libraries +# to runtime path list. +inherit_rpath=$inherit_rpath_CXX + +# Whether libtool must link a program against all its dependency libraries. +link_all_deplibs=$link_all_deplibs_CXX + +# Set to "yes" if exported symbols are required. +always_export_symbols=$always_export_symbols_CXX + +# The commands to list exported symbols. +export_symbols_cmds=$lt_export_symbols_cmds_CXX + +# Symbols that should not be listed in the preloaded symbols. +exclude_expsyms=$lt_exclude_expsyms_CXX + +# Symbols that must always be exported. +include_expsyms=$lt_include_expsyms_CXX + +# Commands necessary for linking programs (against libraries) with templates. +prelink_cmds=$lt_prelink_cmds_CXX + +# Commands necessary for finishing linking programs. +postlink_cmds=$lt_postlink_cmds_CXX + +# Specify filename containing input files. +file_list_spec=$lt_file_list_spec_CXX + +# How to hardcode a shared library path into an executable. +hardcode_action=$hardcode_action_CXX + +# The directories searched by this compiler when creating a shared library. +compiler_lib_search_dirs=$lt_compiler_lib_search_dirs_CXX + +# Dependencies to place before and after the objects being linked to +# create a shared library. +predep_objects=$lt_predep_objects_CXX +postdep_objects=$lt_postdep_objects_CXX +predeps=$lt_predeps_CXX +postdeps=$lt_postdeps_CXX + +# The library search path used internally by the compiler when linking +# a shared library. +compiler_lib_search_path=$lt_compiler_lib_search_path_CXX + +# ### END LIBTOOL TAG CONFIG: CXX +_LT_EOF + + ;; + "libtool-rpath-patch":C) if test "$libtool_use_rpath" = "no"; then + sed < libtool > libtool-2 's/^hardcode_libdir_flag_spec.*$'/'hardcode_libdir_flag_spec=" -D__LIBTOOL_NO_RPATH__ "/' + mv libtool-2 libtool + chmod 755 libtool + fi ;; + + esac +done # for ac_tag + + +as_fn_exit 0 +_ACEOF +ac_clean_files=$ac_clean_files_save + +test $ac_write_fail = 0 || + as_fn_error $? "write failure creating $CONFIG_STATUS" "$LINENO" 5 + + +# configure is writing to config.log, and then calls config.status. +# config.status does its own redirection, appending to config.log. +# Unfortunately, on DOS this fails, as config.log is still kept open +# by configure, so config.status won't be able to write to it; its +# output is simply discarded. So we exec the FD to /dev/null, +# effectively closing config.log, so it can be properly (re)opened and +# appended to by config.status. When coming back to configure, we +# need to make the FD available again. +if test "$no_create" != yes; then + ac_cs_success=: + ac_config_status_args= + test "$silent" = yes && + ac_config_status_args="$ac_config_status_args --quiet" + exec 5>/dev/null + $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false + exec 5>>config.log + # Use ||, not &&, to avoid exiting from the if with $? = 1, which + # would make configure fail if this is the last instruction. + $ac_cs_success || as_fn_exit 1 +fi +if test -n "$ac_unrecognized_opts" && test "$enable_option_checking" != no; then + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5 +$as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2;} +fi + diff --git a/third-party/odb/libodb-sqlite-2.4.0/configure.ac b/third-party/odb/libodb-sqlite-2.4.0/configure.ac new file mode 100755 index 0000000..c5997fa --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/configure.ac @@ -0,0 +1,64 @@ +# file : configure.ac +# copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +# license : GNU GPL v2; see accompanying LICENSE file + +AC_PREREQ(2.60) +AC_INIT([libodb-sqlite], [2.4.0], [odb-users@codesynthesis.com]) +AC_CONFIG_AUX_DIR([config]) +AC_CONFIG_MACRO_DIR([m4]) +AC_CONFIG_SRCDIR([odb/sqlite/version.hxx]) + +AM_INIT_AUTOMAKE([-Wall -Werror foreign nostdinc subdir-objects dist-bzip2 dist-zip tar-ustar]) +m4_ifdef([AM_PROG_AR], [AM_PROG_AR]) # Required by automake 1.12. + +LT_INIT([win32-dll]) + +AC_CANONICAL_HOST + +# Check for C++ compiler and use it to compile the tests. +# +AC_PROG_CXX +AC_LANG(C++) + +# Create the libtool executable so that we can use it in further tests. +# +LT_OUTPUT + +# Check for threads. +# +THREADS + +# Check for libsqlite. +# +LIBSQLITE( + [], + [AC_MSG_ERROR([libsqlite3 is not found; consider using CPPFLAGS/LDFLAGS to specify its location])]) + +AS_IF([test x$libsqlite_unlock_notify = xyes], +AC_DEFINE([LIBODB_SQLITE_HAVE_UNLOCK_NOTIFY], [1], [Have sqlite3_unlock_notify.])) + +AS_IF([test x$threads != xnone -a x$libsqlite_unlock_notify = xno], +AC_MSG_WARN([libsqlite3 is built without sqlite3_unlock_notify support; multi-threaded support will be limited])) + +# Check for libodb. +# +LIBODB([],[AC_MSG_ERROR([libodb is not found; consider using --with-libodb=DIR])]) + +# Define LIBODB_SQLITE_STATIC_LIB if we are build static library on certain +# platforms. +# +STATIC_LIB([LIBODB_SQLITE_STATIC_LIB], [Static library interface.]) + +# Allow the user to specify the pkgconfig directory. +# +PKGCONFIG + +# Check if we should disable rpath. +# +DISABLE_RPATH + +# Output. +# +AC_CONFIG_HEADERS([odb/sqlite/config.h odb/sqlite/details/config.h]) +AC_CONFIG_FILES([libodb-sqlite.pc Makefile odb/sqlite/Makefile]) +AC_OUTPUT diff --git a/third-party/odb/libodb-sqlite-2.4.0/etc/sqlite/README b/third-party/odb/libodb-sqlite-2.4.0/etc/sqlite/README new file mode 100755 index 0000000..0d493f0 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/etc/sqlite/README @@ -0,0 +1,30 @@ +This directory contains project/solution files for building SQLite libraries +with Microsoft Visual Studio versions 8, 9, 10, 11, and 12. + +To build SQLite, you will need to download two SQLite packages: sqlite- +amalgamation and sqlite-dll. Copy the sqlite3.c and sqlite3.h files from the +first package and the sqlite3.def file from the second package into the +directory with the project/solution files. Then open the solution and build +the desired configurations (Debug/Release) and platforms (Win32/x64). + +The resulting 32-bit DLLs and import libraries are placed into the bin\ and +lib\ sub-directories, respectively. Similarly, the 64-bit DLLs and import +libraries are placed into bin64\ and lib64\. The Release versions of the +import libraries are named sqlite3.lib and the Debug versions are named +sqlite3-d.lib. + +To configure Visual Studio to automatically locate the SQLite header, DLLs, +and import libraries, add the following paths to your VC++ Directories (below +sqlite refers to the build directory): + +Win32: + + Include: ...\sqlite + Library: ...\sqlite\lib + Executable: ...\sqlite\bin + +x64: + + Include: ...\sqlite + Library: ...\sqlite\lib64 + Executable: ...\sqlite\bin64 diff --git a/third-party/odb/libodb-sqlite-2.4.0/etc/sqlite/sqlite3-vc10.sln b/third-party/odb/libodb-sqlite-2.4.0/etc/sqlite/sqlite3-vc10.sln new file mode 100755 index 0000000..c9c0922 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/etc/sqlite/sqlite3-vc10.sln @@ -0,0 +1,26 @@ + +Microsoft Visual Studio Solution File, Format Version 11.00 +# Visual Studio 2010 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "sqlite3", "sqlite3-vc10.vcxproj", "{3409C5BB-974C-44FC-A9DB-2176837E9035}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Win32 = Debug|Win32 + Debug|x64 = Debug|x64 + Release|Win32 = Release|Win32 + Release|x64 = Release|x64 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {3409C5BB-974C-44FC-A9DB-2176837E9035}.Debug|Win32.ActiveCfg = Debug|Win32 + {3409C5BB-974C-44FC-A9DB-2176837E9035}.Debug|Win32.Build.0 = Debug|Win32 + {3409C5BB-974C-44FC-A9DB-2176837E9035}.Debug|x64.ActiveCfg = Debug|x64 + {3409C5BB-974C-44FC-A9DB-2176837E9035}.Debug|x64.Build.0 = Debug|x64 + {3409C5BB-974C-44FC-A9DB-2176837E9035}.Release|Win32.ActiveCfg = Release|Win32 + {3409C5BB-974C-44FC-A9DB-2176837E9035}.Release|Win32.Build.0 = Release|Win32 + {3409C5BB-974C-44FC-A9DB-2176837E9035}.Release|x64.ActiveCfg = Release|x64 + {3409C5BB-974C-44FC-A9DB-2176837E9035}.Release|x64.Build.0 = Release|x64 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/third-party/odb/libodb-sqlite-2.4.0/etc/sqlite/sqlite3-vc10.vcxproj b/third-party/odb/libodb-sqlite-2.4.0/etc/sqlite/sqlite3-vc10.vcxproj new file mode 100755 index 0000000..8d2ba96 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/etc/sqlite/sqlite3-vc10.vcxproj @@ -0,0 +1,170 @@ + + + + + Debug + Win32 + + + Debug + x64 + + + Release + Win32 + + + Release + x64 + + + + {3409C5BB-974C-44FC-A9DB-2176837E9035} + Win32Proj + sqlite3 + + + + DynamicLibrary + true + Unicode + + + DynamicLibrary + true + Unicode + + + DynamicLibrary + false + true + Unicode + + + DynamicLibrary + false + true + Unicode + + + + + + + + + + + + + + + + + + + true + bin\ + sqlite3-d + + + true + bin64\ + sqlite3-d + + + false + bin\ + sqlite3 + + + false + bin64\ + sqlite3 + + + + + + Level3 + Disabled + WIN32;_DEBUG;_WINDOWS;_USRDLL;SQLITE_OS_WIN=1;SQLITE_THREADSAFE=1;SQLITE_ENABLE_FTS3=1;SQLITE_ENABLE_RTREE=1;SQLITE_ENABLE_COLUMN_METADATA=1;SQLITE_ENABLE_UNLOCK_NOTIFY=1;%(PreprocessorDefinitions) + + + Windows + true + $(TargetPath) + lib\sqlite3-d.lib + sqlite3.def + /EXPORT:sqlite3_unlock_notify %(AdditionalOptions) + + + + + + + Level3 + Disabled + WIN32;_DEBUG;_WINDOWS;_USRDLL;SQLITE_OS_WIN=1;SQLITE_THREADSAFE=1;SQLITE_ENABLE_FTS3=1;SQLITE_ENABLE_RTREE=1;SQLITE_ENABLE_COLUMN_METADATA=1;SQLITE_ENABLE_UNLOCK_NOTIFY=1;%(PreprocessorDefinitions) + + + Windows + true + $(TargetPath) + lib64\sqlite3-d.lib + sqlite3.def + /EXPORT:sqlite3_unlock_notify %(AdditionalOptions) + + + + + Level3 + + + MaxSpeed + true + true + WIN32;NDEBUG;_WINDOWS;_USRDLL;SQLITE_OS_WIN=1;SQLITE_THREADSAFE=1;SQLITE_ENABLE_FTS3=1;SQLITE_ENABLE_RTREE=1;SQLITE_ENABLE_COLUMN_METADATA=1;SQLITE_ENABLE_UNLOCK_NOTIFY=1;%(PreprocessorDefinitions) + + + Windows + true + true + true + $(TargetPath) + lib\sqlite3.lib + sqlite3.def + /EXPORT:sqlite3_unlock_notify %(AdditionalOptions) + + + + + Level3 + + + MaxSpeed + true + true + WIN32;NDEBUG;_WINDOWS;_USRDLL;SQLITE_OS_WIN=1;SQLITE_THREADSAFE=1;SQLITE_ENABLE_FTS3=1;SQLITE_ENABLE_RTREE=1;SQLITE_ENABLE_COLUMN_METADATA=1;SQLITE_ENABLE_UNLOCK_NOTIFY=1;%(PreprocessorDefinitions) + + + Windows + true + true + true + $(TargetPath) + lib64\sqlite3.lib + sqlite3.def + /EXPORT:sqlite3_unlock_notify %(AdditionalOptions) + + + + + + + + + + + + diff --git a/third-party/odb/libodb-sqlite-2.4.0/etc/sqlite/sqlite3-vc10.vcxproj.filters b/third-party/odb/libodb-sqlite-2.4.0/etc/sqlite/sqlite3-vc10.vcxproj.filters new file mode 100755 index 0000000..13685a4 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/etc/sqlite/sqlite3-vc10.vcxproj.filters @@ -0,0 +1,23 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hpp;hxx;hm;inl;inc;xsd + + + + + Source Files + + + + + Header Files + + + \ No newline at end of file diff --git a/third-party/odb/libodb-sqlite-2.4.0/etc/sqlite/sqlite3-vc11.sln b/third-party/odb/libodb-sqlite-2.4.0/etc/sqlite/sqlite3-vc11.sln new file mode 100755 index 0000000..89ed59f --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/etc/sqlite/sqlite3-vc11.sln @@ -0,0 +1,26 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio 2012 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "sqlite3", "sqlite3-vc11.vcxproj", "{3409C5BB-974C-44FC-A9DB-2176837E9035}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Win32 = Debug|Win32 + Debug|x64 = Debug|x64 + Release|Win32 = Release|Win32 + Release|x64 = Release|x64 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {3409C5BB-974C-44FC-A9DB-2176837E9035}.Debug|Win32.ActiveCfg = Debug|Win32 + {3409C5BB-974C-44FC-A9DB-2176837E9035}.Debug|Win32.Build.0 = Debug|Win32 + {3409C5BB-974C-44FC-A9DB-2176837E9035}.Debug|x64.ActiveCfg = Debug|x64 + {3409C5BB-974C-44FC-A9DB-2176837E9035}.Debug|x64.Build.0 = Debug|x64 + {3409C5BB-974C-44FC-A9DB-2176837E9035}.Release|Win32.ActiveCfg = Release|Win32 + {3409C5BB-974C-44FC-A9DB-2176837E9035}.Release|Win32.Build.0 = Release|Win32 + {3409C5BB-974C-44FC-A9DB-2176837E9035}.Release|x64.ActiveCfg = Release|x64 + {3409C5BB-974C-44FC-A9DB-2176837E9035}.Release|x64.Build.0 = Release|x64 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/third-party/odb/libodb-sqlite-2.4.0/etc/sqlite/sqlite3-vc11.vcxproj b/third-party/odb/libodb-sqlite-2.4.0/etc/sqlite/sqlite3-vc11.vcxproj new file mode 100755 index 0000000..9174372 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/etc/sqlite/sqlite3-vc11.vcxproj @@ -0,0 +1,174 @@ + + + + + Debug + Win32 + + + Debug + x64 + + + Release + Win32 + + + Release + x64 + + + + {3409C5BB-974C-44FC-A9DB-2176837E9035} + Win32Proj + sqlite3 + + + + DynamicLibrary + true + v110 + Unicode + + + DynamicLibrary + true + v110 + Unicode + + + DynamicLibrary + false + v110 + true + Unicode + + + DynamicLibrary + false + v110 + true + Unicode + + + + + + + + + + + + + + + + + + + true + bin\ + sqlite3-d + + + true + bin64\ + sqlite3-d + + + false + bin\ + sqlite3 + + + false + bin64\ + sqlite3 + + + + + + Level3 + Disabled + WIN32;_DEBUG;_WINDOWS;_USRDLL;SQLITE_OS_WIN=1;SQLITE_THREADSAFE=1;SQLITE_ENABLE_FTS3=1;SQLITE_ENABLE_RTREE=1;SQLITE_ENABLE_COLUMN_METADATA=1;SQLITE_ENABLE_UNLOCK_NOTIFY=1;%(PreprocessorDefinitions) + + + Windows + true + $(TargetPath) + lib\sqlite3-d.lib + sqlite3.def + /EXPORT:sqlite3_unlock_notify %(AdditionalOptions) + + + + + + + Level3 + Disabled + WIN32;_DEBUG;_WINDOWS;_USRDLL;SQLITE_OS_WIN=1;SQLITE_THREADSAFE=1;SQLITE_ENABLE_FTS3=1;SQLITE_ENABLE_RTREE=1;SQLITE_ENABLE_COLUMN_METADATA=1;SQLITE_ENABLE_UNLOCK_NOTIFY=1;%(PreprocessorDefinitions) + + + Windows + true + $(TargetPath) + lib64\sqlite3-d.lib + sqlite3.def + /EXPORT:sqlite3_unlock_notify %(AdditionalOptions) + + + + + Level3 + + + MaxSpeed + true + true + WIN32;NDEBUG;_WINDOWS;_USRDLL;SQLITE_OS_WIN=1;SQLITE_THREADSAFE=1;SQLITE_ENABLE_FTS3=1;SQLITE_ENABLE_RTREE=1;SQLITE_ENABLE_COLUMN_METADATA=1;SQLITE_ENABLE_UNLOCK_NOTIFY=1;%(PreprocessorDefinitions) + + + Windows + true + true + true + $(TargetPath) + lib\sqlite3.lib + sqlite3.def + /EXPORT:sqlite3_unlock_notify %(AdditionalOptions) + + + + + Level3 + + + MaxSpeed + true + true + WIN32;NDEBUG;_WINDOWS;_USRDLL;SQLITE_OS_WIN=1;SQLITE_THREADSAFE=1;SQLITE_ENABLE_FTS3=1;SQLITE_ENABLE_RTREE=1;SQLITE_ENABLE_COLUMN_METADATA=1;SQLITE_ENABLE_UNLOCK_NOTIFY=1;%(PreprocessorDefinitions) + + + Windows + true + true + true + $(TargetPath) + lib64\sqlite3.lib + sqlite3.def + /EXPORT:sqlite3_unlock_notify %(AdditionalOptions) + + + + + + + + + + + + diff --git a/third-party/odb/libodb-sqlite-2.4.0/etc/sqlite/sqlite3-vc11.vcxproj.filters b/third-party/odb/libodb-sqlite-2.4.0/etc/sqlite/sqlite3-vc11.vcxproj.filters new file mode 100755 index 0000000..13685a4 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/etc/sqlite/sqlite3-vc11.vcxproj.filters @@ -0,0 +1,23 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hpp;hxx;hm;inl;inc;xsd + + + + + Source Files + + + + + Header Files + + + \ No newline at end of file diff --git a/third-party/odb/libodb-sqlite-2.4.0/etc/sqlite/sqlite3-vc12.sln b/third-party/odb/libodb-sqlite-2.4.0/etc/sqlite/sqlite3-vc12.sln new file mode 100755 index 0000000..6d901fb --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/etc/sqlite/sqlite3-vc12.sln @@ -0,0 +1,28 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio 2013 +VisualStudioVersion = 12.0.21005.1 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "sqlite3", "sqlite3-vc12.vcxproj", "{3409C5BB-974C-44FC-A9DB-2176837E9035}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Win32 = Debug|Win32 + Debug|x64 = Debug|x64 + Release|Win32 = Release|Win32 + Release|x64 = Release|x64 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {3409C5BB-974C-44FC-A9DB-2176837E9035}.Debug|Win32.ActiveCfg = Debug|Win32 + {3409C5BB-974C-44FC-A9DB-2176837E9035}.Debug|Win32.Build.0 = Debug|Win32 + {3409C5BB-974C-44FC-A9DB-2176837E9035}.Debug|x64.ActiveCfg = Debug|x64 + {3409C5BB-974C-44FC-A9DB-2176837E9035}.Debug|x64.Build.0 = Debug|x64 + {3409C5BB-974C-44FC-A9DB-2176837E9035}.Release|Win32.ActiveCfg = Release|Win32 + {3409C5BB-974C-44FC-A9DB-2176837E9035}.Release|Win32.Build.0 = Release|Win32 + {3409C5BB-974C-44FC-A9DB-2176837E9035}.Release|x64.ActiveCfg = Release|x64 + {3409C5BB-974C-44FC-A9DB-2176837E9035}.Release|x64.Build.0 = Release|x64 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/third-party/odb/libodb-sqlite-2.4.0/etc/sqlite/sqlite3-vc12.vcxproj b/third-party/odb/libodb-sqlite-2.4.0/etc/sqlite/sqlite3-vc12.vcxproj new file mode 100755 index 0000000..79dac0f --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/etc/sqlite/sqlite3-vc12.vcxproj @@ -0,0 +1,178 @@ + + + + + Debug + Win32 + + + Debug + x64 + + + Release + Win32 + + + Release + x64 + + + + {3409C5BB-974C-44FC-A9DB-2176837E9035} + Win32Proj + sqlite3 + + + + DynamicLibrary + true + v120 + Unicode + + + DynamicLibrary + true + v120 + Unicode + + + DynamicLibrary + false + v120 + true + Unicode + + + DynamicLibrary + false + v120 + true + Unicode + + + + + + + + + + + + + + + + + + + true + bin\ + sqlite3-d + + + true + bin64\ + sqlite3-d + + + false + bin\ + sqlite3 + + + false + bin64\ + sqlite3 + + + + + + Level3 + Disabled + WIN32;_DEBUG;_WINDOWS;_USRDLL;SQLITE_OS_WIN=1;SQLITE_THREADSAFE=1;SQLITE_ENABLE_FTS3=1;SQLITE_ENABLE_RTREE=1;SQLITE_ENABLE_COLUMN_METADATA=1;SQLITE_ENABLE_UNLOCK_NOTIFY=1;%(PreprocessorDefinitions) + true + + + Windows + true + $(TargetPath) + lib\sqlite3-d.lib + sqlite3.def + /EXPORT:sqlite3_unlock_notify %(AdditionalOptions) + + + + + + + Level3 + Disabled + WIN32;_DEBUG;_WINDOWS;_USRDLL;SQLITE_OS_WIN=1;SQLITE_THREADSAFE=1;SQLITE_ENABLE_FTS3=1;SQLITE_ENABLE_RTREE=1;SQLITE_ENABLE_COLUMN_METADATA=1;SQLITE_ENABLE_UNLOCK_NOTIFY=1;%(PreprocessorDefinitions) + true + + + Windows + true + $(TargetPath) + lib64\sqlite3-d.lib + sqlite3.def + /EXPORT:sqlite3_unlock_notify %(AdditionalOptions) + + + + + Level3 + + + MaxSpeed + true + true + WIN32;NDEBUG;_WINDOWS;_USRDLL;SQLITE_OS_WIN=1;SQLITE_THREADSAFE=1;SQLITE_ENABLE_FTS3=1;SQLITE_ENABLE_RTREE=1;SQLITE_ENABLE_COLUMN_METADATA=1;SQLITE_ENABLE_UNLOCK_NOTIFY=1;%(PreprocessorDefinitions) + true + + + Windows + true + true + true + $(TargetPath) + lib\sqlite3.lib + sqlite3.def + /EXPORT:sqlite3_unlock_notify %(AdditionalOptions) + + + + + Level3 + + + MaxSpeed + true + true + WIN32;NDEBUG;_WINDOWS;_USRDLL;SQLITE_OS_WIN=1;SQLITE_THREADSAFE=1;SQLITE_ENABLE_FTS3=1;SQLITE_ENABLE_RTREE=1;SQLITE_ENABLE_COLUMN_METADATA=1;SQLITE_ENABLE_UNLOCK_NOTIFY=1;%(PreprocessorDefinitions) + true + + + Windows + true + true + true + $(TargetPath) + lib64\sqlite3.lib + sqlite3.def + /EXPORT:sqlite3_unlock_notify %(AdditionalOptions) + + + + + + + + + + + + diff --git a/third-party/odb/libodb-sqlite-2.4.0/etc/sqlite/sqlite3-vc12.vcxproj.filters b/third-party/odb/libodb-sqlite-2.4.0/etc/sqlite/sqlite3-vc12.vcxproj.filters new file mode 100755 index 0000000..13685a4 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/etc/sqlite/sqlite3-vc12.vcxproj.filters @@ -0,0 +1,23 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hpp;hxx;hm;inl;inc;xsd + + + + + Source Files + + + + + Header Files + + + \ No newline at end of file diff --git a/third-party/odb/libodb-sqlite-2.4.0/etc/sqlite/sqlite3-vc8.sln b/third-party/odb/libodb-sqlite-2.4.0/etc/sqlite/sqlite3-vc8.sln new file mode 100755 index 0000000..e5ed1d0 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/etc/sqlite/sqlite3-vc8.sln @@ -0,0 +1,26 @@ + +Microsoft Visual Studio Solution File, Format Version 9.00 +# Visual Studio 2005 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "sqlite3", "sqlite3-vc8.vcproj", "{6AAE1E22-4BE0-4CB4-A94E-B908167D88C2}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Win32 = Debug|Win32 + Debug|x64 = Debug|x64 + Release|Win32 = Release|Win32 + Release|x64 = Release|x64 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {6AAE1E22-4BE0-4CB4-A94E-B908167D88C2}.Debug|Win32.ActiveCfg = Debug|Win32 + {6AAE1E22-4BE0-4CB4-A94E-B908167D88C2}.Debug|Win32.Build.0 = Debug|Win32 + {6AAE1E22-4BE0-4CB4-A94E-B908167D88C2}.Debug|x64.ActiveCfg = Debug|x64 + {6AAE1E22-4BE0-4CB4-A94E-B908167D88C2}.Debug|x64.Build.0 = Debug|x64 + {6AAE1E22-4BE0-4CB4-A94E-B908167D88C2}.Release|Win32.ActiveCfg = Release|Win32 + {6AAE1E22-4BE0-4CB4-A94E-B908167D88C2}.Release|Win32.Build.0 = Release|Win32 + {6AAE1E22-4BE0-4CB4-A94E-B908167D88C2}.Release|x64.ActiveCfg = Release|x64 + {6AAE1E22-4BE0-4CB4-A94E-B908167D88C2}.Release|x64.Build.0 = Release|x64 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/third-party/odb/libodb-sqlite-2.4.0/etc/sqlite/sqlite3-vc8.vcproj b/third-party/odb/libodb-sqlite-2.4.0/etc/sqlite/sqlite3-vc8.vcproj new file mode 100755 index 0000000..8e1e552 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/etc/sqlite/sqlite3-vc8.vcproj @@ -0,0 +1,360 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/third-party/odb/libodb-sqlite-2.4.0/etc/sqlite/sqlite3-vc9.sln b/third-party/odb/libodb-sqlite-2.4.0/etc/sqlite/sqlite3-vc9.sln new file mode 100755 index 0000000..4206336 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/etc/sqlite/sqlite3-vc9.sln @@ -0,0 +1,26 @@ + +Microsoft Visual Studio Solution File, Format Version 10.00 +# Visual Studio 2008 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "sqlite3", "sqlite3-vc9.vcproj", "{6AAE1E22-4BE0-4CB4-A94E-B908167D88C2}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Win32 = Debug|Win32 + Debug|x64 = Debug|x64 + Release|Win32 = Release|Win32 + Release|x64 = Release|x64 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {6AAE1E22-4BE0-4CB4-A94E-B908167D88C2}.Debug|Win32.ActiveCfg = Debug|Win32 + {6AAE1E22-4BE0-4CB4-A94E-B908167D88C2}.Debug|Win32.Build.0 = Debug|Win32 + {6AAE1E22-4BE0-4CB4-A94E-B908167D88C2}.Debug|x64.ActiveCfg = Debug|x64 + {6AAE1E22-4BE0-4CB4-A94E-B908167D88C2}.Debug|x64.Build.0 = Debug|x64 + {6AAE1E22-4BE0-4CB4-A94E-B908167D88C2}.Release|Win32.ActiveCfg = Release|Win32 + {6AAE1E22-4BE0-4CB4-A94E-B908167D88C2}.Release|Win32.Build.0 = Release|Win32 + {6AAE1E22-4BE0-4CB4-A94E-B908167D88C2}.Release|x64.ActiveCfg = Release|x64 + {6AAE1E22-4BE0-4CB4-A94E-B908167D88C2}.Release|x64.Build.0 = Release|x64 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/third-party/odb/libodb-sqlite-2.4.0/etc/sqlite/sqlite3-vc9.vcproj b/third-party/odb/libodb-sqlite-2.4.0/etc/sqlite/sqlite3-vc9.vcproj new file mode 100755 index 0000000..9a698b7 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/etc/sqlite/sqlite3-vc9.vcproj @@ -0,0 +1,367 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/third-party/odb/libodb-sqlite-2.4.0/libodb-sqlite-vc10.sln b/third-party/odb/libodb-sqlite-2.4.0/libodb-sqlite-vc10.sln new file mode 100755 index 0000000..cef2f8a --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/libodb-sqlite-vc10.sln @@ -0,0 +1,26 @@ + +Microsoft Visual Studio Solution File, Format Version 11.00 +# Visual Studio 2010 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libodb-sqlite", "odb\sqlite\libodb-sqlite-vc10.vcxproj", "{BE62AFC4-4624-4CDA-A7CD-E9451D34AB6E}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Win32 = Debug|Win32 + Debug|x64 = Debug|x64 + Release|Win32 = Release|Win32 + Release|x64 = Release|x64 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {BE62AFC4-4624-4CDA-A7CD-E9451D34AB6E}.Debug|Win32.ActiveCfg = Debug|Win32 + {BE62AFC4-4624-4CDA-A7CD-E9451D34AB6E}.Debug|Win32.Build.0 = Debug|Win32 + {BE62AFC4-4624-4CDA-A7CD-E9451D34AB6E}.Debug|x64.ActiveCfg = Debug|x64 + {BE62AFC4-4624-4CDA-A7CD-E9451D34AB6E}.Debug|x64.Build.0 = Debug|x64 + {BE62AFC4-4624-4CDA-A7CD-E9451D34AB6E}.Release|Win32.ActiveCfg = Release|Win32 + {BE62AFC4-4624-4CDA-A7CD-E9451D34AB6E}.Release|Win32.Build.0 = Release|Win32 + {BE62AFC4-4624-4CDA-A7CD-E9451D34AB6E}.Release|x64.ActiveCfg = Release|x64 + {BE62AFC4-4624-4CDA-A7CD-E9451D34AB6E}.Release|x64.Build.0 = Release|x64 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/third-party/odb/libodb-sqlite-2.4.0/libodb-sqlite-vc11.sln b/third-party/odb/libodb-sqlite-2.4.0/libodb-sqlite-vc11.sln new file mode 100755 index 0000000..0ca7868 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/libodb-sqlite-vc11.sln @@ -0,0 +1,26 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio 2012 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libodb-sqlite", "odb\sqlite\libodb-sqlite-vc11.vcxproj", "{BE62AFC4-4624-4CDA-A7CD-E9451D34AB6E}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Win32 = Debug|Win32 + Debug|x64 = Debug|x64 + Release|Win32 = Release|Win32 + Release|x64 = Release|x64 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {BE62AFC4-4624-4CDA-A7CD-E9451D34AB6E}.Debug|Win32.ActiveCfg = Debug|Win32 + {BE62AFC4-4624-4CDA-A7CD-E9451D34AB6E}.Debug|Win32.Build.0 = Debug|Win32 + {BE62AFC4-4624-4CDA-A7CD-E9451D34AB6E}.Debug|x64.ActiveCfg = Debug|x64 + {BE62AFC4-4624-4CDA-A7CD-E9451D34AB6E}.Debug|x64.Build.0 = Debug|x64 + {BE62AFC4-4624-4CDA-A7CD-E9451D34AB6E}.Release|Win32.ActiveCfg = Release|Win32 + {BE62AFC4-4624-4CDA-A7CD-E9451D34AB6E}.Release|Win32.Build.0 = Release|Win32 + {BE62AFC4-4624-4CDA-A7CD-E9451D34AB6E}.Release|x64.ActiveCfg = Release|x64 + {BE62AFC4-4624-4CDA-A7CD-E9451D34AB6E}.Release|x64.Build.0 = Release|x64 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/third-party/odb/libodb-sqlite-2.4.0/libodb-sqlite-vc12.sln b/third-party/odb/libodb-sqlite-2.4.0/libodb-sqlite-vc12.sln new file mode 100755 index 0000000..878e1e2 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/libodb-sqlite-vc12.sln @@ -0,0 +1,28 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio 2013 +VisualStudioVersion = 12.0.21005.1 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libodb-sqlite", "odb\sqlite\libodb-sqlite-vc12.vcxproj", "{BE62AFC4-4624-4CDA-A7CD-E9451D34AB6E}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Win32 = Debug|Win32 + Debug|x64 = Debug|x64 + Release|Win32 = Release|Win32 + Release|x64 = Release|x64 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {BE62AFC4-4624-4CDA-A7CD-E9451D34AB6E}.Debug|Win32.ActiveCfg = Debug|Win32 + {BE62AFC4-4624-4CDA-A7CD-E9451D34AB6E}.Debug|Win32.Build.0 = Debug|Win32 + {BE62AFC4-4624-4CDA-A7CD-E9451D34AB6E}.Debug|x64.ActiveCfg = Debug|x64 + {BE62AFC4-4624-4CDA-A7CD-E9451D34AB6E}.Debug|x64.Build.0 = Debug|x64 + {BE62AFC4-4624-4CDA-A7CD-E9451D34AB6E}.Release|Win32.ActiveCfg = Release|Win32 + {BE62AFC4-4624-4CDA-A7CD-E9451D34AB6E}.Release|Win32.Build.0 = Release|Win32 + {BE62AFC4-4624-4CDA-A7CD-E9451D34AB6E}.Release|x64.ActiveCfg = Release|x64 + {BE62AFC4-4624-4CDA-A7CD-E9451D34AB6E}.Release|x64.Build.0 = Release|x64 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/third-party/odb/libodb-sqlite-2.4.0/libodb-sqlite-vc8.sln b/third-party/odb/libodb-sqlite-2.4.0/libodb-sqlite-vc8.sln new file mode 100755 index 0000000..94d3f87 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/libodb-sqlite-vc8.sln @@ -0,0 +1,26 @@ + +Microsoft Visual Studio Solution File, Format Version 9.00 +# Visual Studio 2005 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libodb-sqlite", "odb\sqlite\libodb-sqlite-vc8.vcproj", "{E4055842-E6F1-4305-9FD2-EF70A92290C9}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Win32 = Debug|Win32 + Debug|x64 = Debug|x64 + Release|Win32 = Release|Win32 + Release|x64 = Release|x64 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {E4055842-E6F1-4305-9FD2-EF70A92290C9}.Debug|Win32.ActiveCfg = Debug|Win32 + {E4055842-E6F1-4305-9FD2-EF70A92290C9}.Debug|Win32.Build.0 = Debug|Win32 + {E4055842-E6F1-4305-9FD2-EF70A92290C9}.Debug|x64.ActiveCfg = Debug|x64 + {E4055842-E6F1-4305-9FD2-EF70A92290C9}.Debug|x64.Build.0 = Debug|x64 + {E4055842-E6F1-4305-9FD2-EF70A92290C9}.Release|Win32.ActiveCfg = Release|Win32 + {E4055842-E6F1-4305-9FD2-EF70A92290C9}.Release|Win32.Build.0 = Release|Win32 + {E4055842-E6F1-4305-9FD2-EF70A92290C9}.Release|x64.ActiveCfg = Release|x64 + {E4055842-E6F1-4305-9FD2-EF70A92290C9}.Release|x64.Build.0 = Release|x64 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/third-party/odb/libodb-sqlite-2.4.0/libodb-sqlite-vc9.sln b/third-party/odb/libodb-sqlite-2.4.0/libodb-sqlite-vc9.sln new file mode 100755 index 0000000..15f4ac0 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/libodb-sqlite-vc9.sln @@ -0,0 +1,26 @@ + +Microsoft Visual Studio Solution File, Format Version 10.00 +# Visual Studio 2008 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libodb-sqlite", "odb\sqlite\libodb-sqlite-vc9.vcproj", "{E4055842-E6F1-4305-9FD2-EF70A92290C9}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Win32 = Debug|Win32 + Debug|x64 = Debug|x64 + Release|Win32 = Release|Win32 + Release|x64 = Release|x64 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {E4055842-E6F1-4305-9FD2-EF70A92290C9}.Debug|Win32.ActiveCfg = Debug|Win32 + {E4055842-E6F1-4305-9FD2-EF70A92290C9}.Debug|Win32.Build.0 = Debug|Win32 + {E4055842-E6F1-4305-9FD2-EF70A92290C9}.Debug|x64.ActiveCfg = Debug|x64 + {E4055842-E6F1-4305-9FD2-EF70A92290C9}.Debug|x64.Build.0 = Debug|x64 + {E4055842-E6F1-4305-9FD2-EF70A92290C9}.Release|Win32.ActiveCfg = Release|Win32 + {E4055842-E6F1-4305-9FD2-EF70A92290C9}.Release|Win32.Build.0 = Release|Win32 + {E4055842-E6F1-4305-9FD2-EF70A92290C9}.Release|x64.ActiveCfg = Release|x64 + {E4055842-E6F1-4305-9FD2-EF70A92290C9}.Release|x64.Build.0 = Release|x64 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/third-party/odb/libodb-sqlite-2.4.0/libodb-sqlite.pc.in b/third-party/odb/libodb-sqlite-2.4.0/libodb-sqlite.pc.in new file mode 100755 index 0000000..0f92918 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/libodb-sqlite.pc.in @@ -0,0 +1,15 @@ +# file : libodb-sqlite.pc.in +# copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +# license : GNU GPL v2; see accompanying LICENSE file + +prefix=@prefix@ +exec_prefix=@exec_prefix@ +libdir=@libdir@ +includedir=@includedir@ + +Name: libodb-sqlite +Description: Object-relational mapping (ORM) system for C++, SQLite runtime library +URL: http://www.codesynthesis.com/products/odb/ +Version: @VERSION@ +Libs: -L${libdir} -lodb-sqlite +Cflags: -I${includedir} diff --git a/third-party/odb/libodb-sqlite-2.4.0/libtool b/third-party/odb/libodb-sqlite-2.4.0/libtool new file mode 100755 index 0000000..e6e2d0d --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/libtool @@ -0,0 +1,10249 @@ +#! /bin/sh + +# libtool - Provide generalized library-building support services. +# Generated automatically by config.lt (libodb-sqlite) 2.4.0 +# Libtool was configured on host matthiasPC: +# NOTE: Changes made to this file will be lost: look at ltmain.sh. +# +# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, +# 2006, 2007, 2008, 2009, 2010, 2011 Free Software +# Foundation, Inc. +# Written by Gordon Matzigkeit, 1996 +# +# This file is part of GNU Libtool. +# +# GNU Libtool is free software; you can redistribute it and/or +# modify it under the terms of the GNU General Public License as +# published by the Free Software Foundation; either version 2 of +# the License, or (at your option) any later version. +# +# As a special exception to the GNU General Public License, +# if you distribute this file as part of a program or library that +# is built using GNU Libtool, you may include this file under the +# same distribution terms that you use for the rest of that program. +# +# GNU Libtool is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with GNU Libtool; see the file COPYING. If not, a copy +# can be downloaded from http://www.gnu.org/licenses/gpl.html, or +# obtained by writing to the Free Software Foundation, Inc., +# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + + +# The names of the tagged configurations supported by this script. +available_tags="CXX " + +# ### BEGIN LIBTOOL CONFIG + +# Which release of libtool.m4 was used? +macro_version=2.4.2 +macro_revision=1.3337 + +# Assembler program. +AS="as" + +# DLL creation program. +DLLTOOL="false" + +# Object dumper program. +OBJDUMP="objdump" + +# Whether or not to build shared libraries. +build_libtool_libs=yes + +# Whether or not to build static libraries. +build_old_libs=yes + +# What type of objects to build. +pic_mode=default + +# Whether or not to optimize for fast installation. +fast_install=needless + +# Shell to use when invoking shell scripts. +SHELL="/bin/sh" + +# An echo program that protects backslashes. +ECHO="printf %s\\n" + +# The PATH separator for the build system. +PATH_SEPARATOR=":" + +# The host system. +host_alias= +host=x86_64-unknown-linux-gnu +host_os=linux-gnu + +# The build system. +build_alias= +build=x86_64-unknown-linux-gnu +build_os=linux-gnu + +# A sed program that does not truncate output. +SED="/usr/bin/sed" + +# Sed that helps us avoid accidentally triggering echo(1) options like -n. +Xsed="$SED -e 1s/^X//" + +# A grep program that handles long lines. +GREP="/usr/bin/grep" + +# An ERE matcher. +EGREP="/usr/bin/grep -E" + +# A literal string matcher. +FGREP="/usr/bin/grep -F" + +# A BSD- or MS-compatible name lister. +NM="/usr/bin/nm -B" + +# Whether we need soft or hard links. +LN_S="ln -s" + +# What is the maximum length of a command? +max_cmd_len=1572864 + +# Object file suffix (normally "o"). +objext=o + +# Executable file suffix (normally ""). +exeext= + +# whether the shell understands "unset". +lt_unset=unset + +# turn spaces into newlines. +SP2NL="tr \\040 \\012" + +# turn newlines into spaces. +NL2SP="tr \\015\\012 \\040\\040" + +# convert $build file names to $host format. +to_host_file_cmd=func_convert_file_noop + +# convert $build files to toolchain format. +to_tool_file_cmd=func_convert_file_noop + +# Method to check whether dependent libraries are shared objects. +deplibs_check_method="pass_all" + +# Command to use when deplibs_check_method = "file_magic". +file_magic_cmd="\$MAGIC_CMD" + +# How to find potential files when deplibs_check_method = "file_magic". +file_magic_glob="" + +# Find potential files using nocaseglob when deplibs_check_method = "file_magic". +want_nocaseglob="no" + +# Command to associate shared and link libraries. +sharedlib_from_linklib_cmd="printf %s\\n" + +# The archiver. +AR="ar" + +# Flags to create an archive. +AR_FLAGS="cru" + +# How to feed a file listing to the archiver. +archiver_list_spec="@" + +# A symbol stripping program. +STRIP="strip" + +# Commands used to install an old-style archive. +RANLIB="ranlib" +old_postinstall_cmds="chmod 644 \$oldlib~\$RANLIB \$tool_oldlib" +old_postuninstall_cmds="" + +# Whether to use a lock for old archive extraction. +lock_old_archive_extraction=no + +# A C compiler. +LTCC="gcc" + +# LTCC compiler flags. +LTCFLAGS="-g -O2" + +# Take the output of nm and produce a listing of raw symbols and C names. +global_symbol_pipe="sed -n -e 's/^.*[ ]\\([ABCDGIRSTW][ABCDGIRSTW]*\\)[ ][ ]*\\([_A-Za-z][_A-Za-z0-9]*\\)\$/\\1 \\2 \\2/p' | sed '/ __gnu_lto/d'" + +# Transform the output of nm in a proper C declaration. +global_symbol_to_cdecl="sed -n -e 's/^T .* \\(.*\\)\$/extern int \\1();/p' -e 's/^[ABCDGIRSTW]* .* \\(.*\\)\$/extern char \\1;/p'" + +# Transform the output of nm in a C name address pair. +global_symbol_to_c_name_address="sed -n -e 's/^: \\([^ ]*\\)[ ]*\$/ {\\\"\\1\\\", (void *) 0},/p' -e 's/^[ABCDGIRSTW]* \\([^ ]*\\) \\([^ ]*\\)\$/ {\"\\2\", (void *) \\&\\2},/p'" + +# Transform the output of nm in a C name address pair when lib prefix is needed. +global_symbol_to_c_name_address_lib_prefix="sed -n -e 's/^: \\([^ ]*\\)[ ]*\$/ {\\\"\\1\\\", (void *) 0},/p' -e 's/^[ABCDGIRSTW]* \\([^ ]*\\) \\(lib[^ ]*\\)\$/ {\"\\2\", (void *) \\&\\2},/p' -e 's/^[ABCDGIRSTW]* \\([^ ]*\\) \\([^ ]*\\)\$/ {\"lib\\2\", (void *) \\&\\2},/p'" + +# Specify filename containing input files for $NM. +nm_file_list_spec="@" + +# The root where to search for dependent libraries,and in which our libraries should be installed. +lt_sysroot= + +# The name of the directory that contains temporary libtool files. +objdir=.libs + +# Used to examine libraries when file_magic_cmd begins with "file". +MAGIC_CMD=file + +# Must we lock files when doing compilation? +need_locks="no" + +# Manifest tool. +MANIFEST_TOOL=":" + +# Tool to manipulate archived DWARF debug symbol files on Mac OS X. +DSYMUTIL="" + +# Tool to change global to local symbols on Mac OS X. +NMEDIT="" + +# Tool to manipulate fat objects and archives on Mac OS X. +LIPO="" + +# ldd/readelf like tool for Mach-O binaries on Mac OS X. +OTOOL="" + +# ldd/readelf like tool for 64 bit Mach-O binaries on Mac OS X 10.4. +OTOOL64="" + +# Old archive suffix (normally "a"). +libext=a + +# Shared library suffix (normally ".so"). +shrext_cmds=".so" + +# The commands to extract the exported symbol list from a shared archive. +extract_expsyms_cmds="" + +# Variables whose values should be saved in libtool wrapper scripts and +# restored at link time. +variables_saved_for_relink="PATH LD_LIBRARY_PATH LD_RUN_PATH GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH" + +# Do we need the "lib" prefix for modules? +need_lib_prefix=no + +# Do we need a version for libraries? +need_version=no + +# Library versioning type. +version_type=linux + +# Shared library runtime path variable. +runpath_var=LD_RUN_PATH + +# Shared library path variable. +shlibpath_var=LD_LIBRARY_PATH + +# Is shlibpath searched before the hard-coded library search path? +shlibpath_overrides_runpath=yes + +# Format of library name prefix. +libname_spec="lib\$name" + +# List of archive names. First name is the real one, the rest are links. +# The last name is the one that the linker finds with -lNAME +library_names_spec="\${libname}\${release}\${shared_ext}\$versuffix \${libname}\${release}\${shared_ext}\$major \$libname\${shared_ext}" + +# The coded name of the library, if different from the real name. +soname_spec="\${libname}\${release}\${shared_ext}\$major" + +# Permission mode override for installation of shared libraries. +install_override_mode="" + +# Command to use after installation of a shared archive. +postinstall_cmds="" + +# Command to use after uninstallation of a shared archive. +postuninstall_cmds="" + +# Commands used to finish a libtool library installation in a directory. +finish_cmds="PATH=\\\"\\\$PATH:/sbin\\\" ldconfig -n \$libdir" + +# As "finish_cmds", except a single script fragment to be evaled but +# not shown. +finish_eval="" + +# Whether we should hardcode library paths into libraries. +hardcode_into_libs=yes + +# Compile-time system search path for libraries. +sys_lib_search_path_spec="/usr/lib64/gcc/x86_64-suse-linux/4.8 /usr/lib64 /lib64 /usr/x86_64-suse-linux/lib " + +# Run-time system search path for libraries. +sys_lib_dlsearch_path_spec="/lib /usr/lib /usr/local/lib64 /usr/local/lib /usr/lib64/R/lib /usr/lib64/apper /usr/lib64/xorg/modules /usr/lib64/graphviz /usr/lib64/graphviz/sharp /usr/lib64/graphviz/java /usr/lib64/graphviz/perl /usr/lib64/graphviz/php /usr/lib64/graphviz/ocaml /usr/lib64/graphviz/python /usr/lib64/graphviz/lua /usr/lib64/graphviz/tcl /usr/lib64/graphviz/guile /usr/lib64/graphviz/ruby /opt/kde3/lib64 /opt/kde3/lib /usr/lib64/octave/3.8.2 " + +# Whether dlopen is supported. +dlopen_support=unknown + +# Whether dlopen of programs is supported. +dlopen_self=unknown + +# Whether dlopen of statically linked programs is supported. +dlopen_self_static=unknown + +# Commands to strip libraries. +old_striplib="strip --strip-debug" +striplib="strip --strip-unneeded" + + +# The linker used to build libraries. +LD="/usr/x86_64-suse-linux/bin/ld -m elf_x86_64" + +# How to create reloadable object files. +reload_flag=" -r" +reload_cmds="\$LD\$reload_flag -o \$output\$reload_objs" + +# Commands used to build an old-style archive. +old_archive_cmds="\$AR \$AR_FLAGS \$oldlib\$oldobjs~\$RANLIB \$tool_oldlib" + +# A language specific compiler. +CC="gcc" + +# Is the compiler the GNU compiler? +with_gcc=yes + +# Compiler flag to turn off builtin functions. +no_builtin_flag=" -fno-builtin" + +# Additional compiler flags for building library objects. +pic_flag=" -fPIC -DPIC" + +# How to pass a linker flag through the compiler. +wl="-Wl," + +# Compiler flag to prevent dynamic linking. +link_static_flag="" + +# Does compiler simultaneously support -c and -o options? +compiler_c_o="yes" + +# Whether or not to add -lc for building shared libraries. +build_libtool_need_lc=no + +# Whether or not to disallow shared libs when runtime libs are static. +allow_libtool_libs_with_static_runtimes=no + +# Compiler flag to allow reflexive dlopens. +export_dynamic_flag_spec="\${wl}--export-dynamic" + +# Compiler flag to generate shared objects directly from archives. +whole_archive_flag_spec="\${wl}--whole-archive\$convenience \${wl}--no-whole-archive" + +# Whether the compiler copes with passing no objects directly. +compiler_needs_object="no" + +# Create an old-style archive from a shared archive. +old_archive_from_new_cmds="" + +# Create a temporary old-style archive to link instead of a shared archive. +old_archive_from_expsyms_cmds="" + +# Commands used to build a shared archive. +archive_cmds="\$CC -shared \$pic_flag \$libobjs \$deplibs \$compiler_flags \${wl}-soname \$wl\$soname -o \$lib" +archive_expsym_cmds="echo \\\"{ global:\\\" > \$output_objdir/\$libname.ver~ + cat \$export_symbols | sed -e \\\"s/\\\\(.*\\\\)/\\\\1;/\\\" >> \$output_objdir/\$libname.ver~ + echo \\\"local: *; };\\\" >> \$output_objdir/\$libname.ver~ + \$CC -shared \$pic_flag \$libobjs \$deplibs \$compiler_flags \${wl}-soname \$wl\$soname \${wl}-version-script \${wl}\$output_objdir/\$libname.ver -o \$lib" + +# Commands used to build a loadable module if different from building +# a shared archive. +module_cmds="" +module_expsym_cmds="" + +# Whether we are building with GNU ld or not. +with_gnu_ld="yes" + +# Flag that allows shared libraries with undefined symbols to be built. +allow_undefined_flag="" + +# Flag that enforces no undefined symbols. +no_undefined_flag="" + +# Flag to hardcode $libdir into a binary during linking. +# This must work even if $libdir does not exist +hardcode_libdir_flag_spec="\${wl}-rpath \${wl}\$libdir" + +# Whether we need a single "-rpath" flag with a separated argument. +hardcode_libdir_separator="" + +# Set to "yes" if using DIR/libNAME${shared_ext} during linking hardcodes +# DIR into the resulting binary. +hardcode_direct=no + +# Set to "yes" if using DIR/libNAME${shared_ext} during linking hardcodes +# DIR into the resulting binary and the resulting library dependency is +# "absolute",i.e impossible to change by setting ${shlibpath_var} if the +# library is relocated. +hardcode_direct_absolute=no + +# Set to "yes" if using the -LDIR flag during linking hardcodes DIR +# into the resulting binary. +hardcode_minus_L=no + +# Set to "yes" if using SHLIBPATH_VAR=DIR during linking hardcodes DIR +# into the resulting binary. +hardcode_shlibpath_var=unsupported + +# Set to "yes" if building a shared library automatically hardcodes DIR +# into the library and all subsequent libraries and executables linked +# against it. +hardcode_automatic=no + +# Set to yes if linker adds runtime paths of dependent libraries +# to runtime path list. +inherit_rpath=no + +# Whether libtool must link a program against all its dependency libraries. +link_all_deplibs=no + +# Set to "yes" if exported symbols are required. +always_export_symbols=no + +# The commands to list exported symbols. +export_symbols_cmds="\$NM \$libobjs \$convenience | \$global_symbol_pipe | \$SED 's/.* //' | sort | uniq > \$export_symbols" + +# Symbols that should not be listed in the preloaded symbols. +exclude_expsyms="_GLOBAL_OFFSET_TABLE_|_GLOBAL__F[ID]_.*" + +# Symbols that must always be exported. +include_expsyms="" + +# Commands necessary for linking programs (against libraries) with templates. +prelink_cmds="" + +# Commands necessary for finishing linking programs. +postlink_cmds="" + +# Specify filename containing input files. +file_list_spec="" + +# How to hardcode a shared library path into an executable. +hardcode_action=immediate + +# The directories searched by this compiler when creating a shared library. +compiler_lib_search_dirs="" + +# Dependencies to place before and after the objects being linked to +# create a shared library. +predep_objects="" +postdep_objects="" +predeps="" +postdeps="" + +# The library search path used internally by the compiler when linking +# a shared library. +compiler_lib_search_path="" + +# ### END LIBTOOL CONFIG + + +# libtool (GNU libtool) 2.4.2 +# Written by Gordon Matzigkeit , 1996 + +# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006, +# 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc. +# This is free software; see the source for copying conditions. There is NO +# warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + +# GNU Libtool is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. +# +# As a special exception to the GNU General Public License, +# if you distribute this file as part of a program or library that +# is built using GNU Libtool, you may include this file under the +# same distribution terms that you use for the rest of that program. +# +# GNU Libtool is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with GNU Libtool; see the file COPYING. If not, a copy +# can be downloaded from http://www.gnu.org/licenses/gpl.html, +# or obtained by writing to the Free Software Foundation, Inc., +# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + +# Usage: $progname [OPTION]... [MODE-ARG]... +# +# Provide generalized library-building support services. +# +# --config show all configuration variables +# --debug enable verbose shell tracing +# -n, --dry-run display commands without modifying any files +# --features display basic configuration information and exit +# --mode=MODE use operation mode MODE +# --preserve-dup-deps don't remove duplicate dependency libraries +# --quiet, --silent don't print informational messages +# --no-quiet, --no-silent +# print informational messages (default) +# --no-warn don't display warning messages +# --tag=TAG use configuration variables from tag TAG +# -v, --verbose print more informational messages than default +# --no-verbose don't print the extra informational messages +# --version print version information +# -h, --help, --help-all print short, long, or detailed help message +# +# MODE must be one of the following: +# +# clean remove files from the build directory +# compile compile a source file into a libtool object +# execute automatically set library path, then run a program +# finish complete the installation of libtool libraries +# install install libraries or executables +# link create a library or an executable +# uninstall remove libraries from an installed directory +# +# MODE-ARGS vary depending on the MODE. When passed as first option, +# `--mode=MODE' may be abbreviated as `MODE' or a unique abbreviation of that. +# Try `$progname --help --mode=MODE' for a more detailed description of MODE. +# +# When reporting a bug, please describe a test case to reproduce it and +# include the following information: +# +# host-triplet: $host +# shell: $SHELL +# compiler: $LTCC +# compiler flags: $LTCFLAGS +# linker: $LD (gnu? $with_gnu_ld) +# $progname: (GNU libtool) 2.4.2 Debian-2.4.2-1.2 +# automake: $automake_version +# autoconf: $autoconf_version +# +# Report bugs to . +# GNU libtool home page: . +# General help using GNU software: . + +PROGRAM=libtool +PACKAGE=libtool +VERSION="2.4.2 Debian-2.4.2-1.2" +TIMESTAMP="" +package_revision=1.3337 + +# Be Bourne compatible +if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then + emulate sh + NULLCMD=: + # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which + # is contrary to our usage. Disable this feature. + alias -g '${1+"$@"}'='"$@"' + setopt NO_GLOB_SUBST +else + case `(set -o) 2>/dev/null` in *posix*) set -o posix;; esac +fi +BIN_SH=xpg4; export BIN_SH # for Tru64 +DUALCASE=1; export DUALCASE # for MKS sh + +# A function that is used when there is no print builtin or printf. +func_fallback_echo () +{ + eval 'cat <<_LTECHO_EOF +$1 +_LTECHO_EOF' +} + +# NLS nuisances: We save the old values to restore during execute mode. +lt_user_locale= +lt_safe_locale= +for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES +do + eval "if test \"\${$lt_var+set}\" = set; then + save_$lt_var=\$$lt_var + $lt_var=C + export $lt_var + lt_user_locale=\"$lt_var=\\\$save_\$lt_var; \$lt_user_locale\" + lt_safe_locale=\"$lt_var=C; \$lt_safe_locale\" + fi" +done +LC_ALL=C +LANGUAGE=C +export LANGUAGE LC_ALL + +$lt_unset CDPATH + + +# Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh +# is ksh but when the shell is invoked as "sh" and the current value of +# the _XPG environment variable is not equal to 1 (one), the special +# positional parameter $0, within a function call, is the name of the +# function. +progpath="$0" + + + +: ${CP="cp -f"} +test "${ECHO+set}" = set || ECHO=${as_echo-'printf %s\n'} +: ${MAKE="make"} +: ${MKDIR="mkdir"} +: ${MV="mv -f"} +: ${RM="rm -f"} +: ${SHELL="${CONFIG_SHELL-/bin/sh}"} +: ${Xsed="$SED -e 1s/^X//"} + +# Global variables: +EXIT_SUCCESS=0 +EXIT_FAILURE=1 +EXIT_MISMATCH=63 # $? = 63 is used to indicate version mismatch to missing. +EXIT_SKIP=77 # $? = 77 is used to indicate a skipped test to automake. + +exit_status=$EXIT_SUCCESS + +# Make sure IFS has a sensible default +lt_nl=' +' +IFS=" $lt_nl" + +dirname="s,/[^/]*$,," +basename="s,^.*/,," + +# func_dirname file append nondir_replacement +# Compute the dirname of FILE. If nonempty, add APPEND to the result, +# otherwise set result to NONDIR_REPLACEMENT. +func_dirname () +{ + case ${1} in + */*) func_dirname_result="${1%/*}${2}" ;; + * ) func_dirname_result="${3}" ;; + esac +} # Extended-shell func_dirname implementation + + +# func_basename file +func_basename () +{ + func_basename_result="${1##*/}" +} # Extended-shell func_basename implementation + + +# func_dirname_and_basename file append nondir_replacement +# perform func_basename and func_dirname in a single function +# call: +# dirname: Compute the dirname of FILE. If nonempty, +# add APPEND to the result, otherwise set result +# to NONDIR_REPLACEMENT. +# value returned in "$func_dirname_result" +# basename: Compute filename of FILE. +# value retuned in "$func_basename_result" +# Implementation must be kept synchronized with func_dirname +# and func_basename. For efficiency, we do not delegate to +# those functions but instead duplicate the functionality here. +func_dirname_and_basename () +{ + case ${1} in + */*) func_dirname_result="${1%/*}${2}" ;; + * ) func_dirname_result="${3}" ;; + esac + func_basename_result="${1##*/}" +} # Extended-shell func_dirname_and_basename implementation + + +# func_stripname prefix suffix name +# strip PREFIX and SUFFIX off of NAME. +# PREFIX and SUFFIX must not contain globbing or regex special +# characters, hashes, percent signs, but SUFFIX may contain a leading +# dot (in which case that matches only a dot). +# func_strip_suffix prefix name +func_stripname () +{ + # pdksh 5.2.14 does not do ${X%$Y} correctly if both X and Y are + # positional parameters, so assign one to ordinary parameter first. + func_stripname_result=${3} + func_stripname_result=${func_stripname_result#"${1}"} + func_stripname_result=${func_stripname_result%"${2}"} +} # Extended-shell func_stripname implementation + + +# These SED scripts presuppose an absolute path with a trailing slash. +pathcar='s,^/\([^/]*\).*$,\1,' +pathcdr='s,^/[^/]*,,' +removedotparts=':dotsl + s@/\./@/@g + t dotsl + s,/\.$,/,' +collapseslashes='s@/\{1,\}@/@g' +finalslash='s,/*$,/,' + +# func_normal_abspath PATH +# Remove doubled-up and trailing slashes, "." path components, +# and cancel out any ".." path components in PATH after making +# it an absolute path. +# value returned in "$func_normal_abspath_result" +func_normal_abspath () +{ + # Start from root dir and reassemble the path. + func_normal_abspath_result= + func_normal_abspath_tpath=$1 + func_normal_abspath_altnamespace= + case $func_normal_abspath_tpath in + "") + # Empty path, that just means $cwd. + func_stripname '' '/' "`pwd`" + func_normal_abspath_result=$func_stripname_result + return + ;; + # The next three entries are used to spot a run of precisely + # two leading slashes without using negated character classes; + # we take advantage of case's first-match behaviour. + ///*) + # Unusual form of absolute path, do nothing. + ;; + //*) + # Not necessarily an ordinary path; POSIX reserves leading '//' + # and for example Cygwin uses it to access remote file shares + # over CIFS/SMB, so we conserve a leading double slash if found. + func_normal_abspath_altnamespace=/ + ;; + /*) + # Absolute path, do nothing. + ;; + *) + # Relative path, prepend $cwd. + func_normal_abspath_tpath=`pwd`/$func_normal_abspath_tpath + ;; + esac + # Cancel out all the simple stuff to save iterations. We also want + # the path to end with a slash for ease of parsing, so make sure + # there is one (and only one) here. + func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \ + -e "$removedotparts" -e "$collapseslashes" -e "$finalslash"` + while :; do + # Processed it all yet? + if test "$func_normal_abspath_tpath" = / ; then + # If we ascended to the root using ".." the result may be empty now. + if test -z "$func_normal_abspath_result" ; then + func_normal_abspath_result=/ + fi + break + fi + func_normal_abspath_tcomponent=`$ECHO "$func_normal_abspath_tpath" | $SED \ + -e "$pathcar"` + func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \ + -e "$pathcdr"` + # Figure out what to do with it + case $func_normal_abspath_tcomponent in + "") + # Trailing empty path component, ignore it. + ;; + ..) + # Parent dir; strip last assembled component from result. + func_dirname "$func_normal_abspath_result" + func_normal_abspath_result=$func_dirname_result + ;; + *) + # Actual path component, append it. + func_normal_abspath_result=$func_normal_abspath_result/$func_normal_abspath_tcomponent + ;; + esac + done + # Restore leading double-slash if one was found on entry. + func_normal_abspath_result=$func_normal_abspath_altnamespace$func_normal_abspath_result +} + +# func_relative_path SRCDIR DSTDIR +# generates a relative path from SRCDIR to DSTDIR, with a trailing +# slash if non-empty, suitable for immediately appending a filename +# without needing to append a separator. +# value returned in "$func_relative_path_result" +func_relative_path () +{ + func_relative_path_result= + func_normal_abspath "$1" + func_relative_path_tlibdir=$func_normal_abspath_result + func_normal_abspath "$2" + func_relative_path_tbindir=$func_normal_abspath_result + + # Ascend the tree starting from libdir + while :; do + # check if we have found a prefix of bindir + case $func_relative_path_tbindir in + $func_relative_path_tlibdir) + # found an exact match + func_relative_path_tcancelled= + break + ;; + $func_relative_path_tlibdir*) + # found a matching prefix + func_stripname "$func_relative_path_tlibdir" '' "$func_relative_path_tbindir" + func_relative_path_tcancelled=$func_stripname_result + if test -z "$func_relative_path_result"; then + func_relative_path_result=. + fi + break + ;; + *) + func_dirname $func_relative_path_tlibdir + func_relative_path_tlibdir=${func_dirname_result} + if test "x$func_relative_path_tlibdir" = x ; then + # Have to descend all the way to the root! + func_relative_path_result=../$func_relative_path_result + func_relative_path_tcancelled=$func_relative_path_tbindir + break + fi + func_relative_path_result=../$func_relative_path_result + ;; + esac + done + + # Now calculate path; take care to avoid doubling-up slashes. + func_stripname '' '/' "$func_relative_path_result" + func_relative_path_result=$func_stripname_result + func_stripname '/' '/' "$func_relative_path_tcancelled" + if test "x$func_stripname_result" != x ; then + func_relative_path_result=${func_relative_path_result}/${func_stripname_result} + fi + + # Normalisation. If bindir is libdir, return empty string, + # else relative path ending with a slash; either way, target + # file name can be directly appended. + if test ! -z "$func_relative_path_result"; then + func_stripname './' '' "$func_relative_path_result/" + func_relative_path_result=$func_stripname_result + fi +} + +# The name of this program: +func_dirname_and_basename "$progpath" +progname=$func_basename_result + +# Make sure we have an absolute path for reexecution: +case $progpath in + [\\/]*|[A-Za-z]:\\*) ;; + *[\\/]*) + progdir=$func_dirname_result + progdir=`cd "$progdir" && pwd` + progpath="$progdir/$progname" + ;; + *) + save_IFS="$IFS" + IFS=${PATH_SEPARATOR-:} + for progdir in $PATH; do + IFS="$save_IFS" + test -x "$progdir/$progname" && break + done + IFS="$save_IFS" + test -n "$progdir" || progdir=`pwd` + progpath="$progdir/$progname" + ;; +esac + +# Sed substitution that helps us do robust quoting. It backslashifies +# metacharacters that are still active within double-quoted strings. +Xsed="${SED}"' -e 1s/^X//' +sed_quote_subst='s/\([`"$\\]\)/\\\1/g' + +# Same as above, but do not quote variable references. +double_quote_subst='s/\(["`\\]\)/\\\1/g' + +# Sed substitution that turns a string into a regex matching for the +# string literally. +sed_make_literal_regex='s,[].[^$\\*\/],\\&,g' + +# Sed substitution that converts a w32 file name or path +# which contains forward slashes, into one that contains +# (escaped) backslashes. A very naive implementation. +lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g' + +# Re-`\' parameter expansions in output of double_quote_subst that were +# `\'-ed in input to the same. If an odd number of `\' preceded a '$' +# in input to double_quote_subst, that '$' was protected from expansion. +# Since each input `\' is now two `\'s, look for any number of runs of +# four `\'s followed by two `\'s and then a '$'. `\' that '$'. +bs='\\' +bs2='\\\\' +bs4='\\\\\\\\' +dollar='\$' +sed_double_backslash="\ + s/$bs4/&\\ +/g + s/^$bs2$dollar/$bs&/ + s/\\([^$bs]\\)$bs2$dollar/\\1$bs2$bs$dollar/g + s/\n//g" + +# Standard options: +opt_dry_run=false +opt_help=false +opt_quiet=false +opt_verbose=false +opt_warning=: + +# func_echo arg... +# Echo program name prefixed message, along with the current mode +# name if it has been set yet. +func_echo () +{ + $ECHO "$progname: ${opt_mode+$opt_mode: }$*" +} + +# func_verbose arg... +# Echo program name prefixed message in verbose mode only. +func_verbose () +{ + $opt_verbose && func_echo ${1+"$@"} + + # A bug in bash halts the script if the last line of a function + # fails when set -e is in force, so we need another command to + # work around that: + : +} + +# func_echo_all arg... +# Invoke $ECHO with all args, space-separated. +func_echo_all () +{ + $ECHO "$*" +} + +# func_error arg... +# Echo program name prefixed message to standard error. +func_error () +{ + $ECHO "$progname: ${opt_mode+$opt_mode: }"${1+"$@"} 1>&2 +} + +# func_warning arg... +# Echo program name prefixed warning message to standard error. +func_warning () +{ + $opt_warning && $ECHO "$progname: ${opt_mode+$opt_mode: }warning: "${1+"$@"} 1>&2 + + # bash bug again: + : +} + +# func_fatal_error arg... +# Echo program name prefixed message to standard error, and exit. +func_fatal_error () +{ + func_error ${1+"$@"} + exit $EXIT_FAILURE +} + +# func_fatal_help arg... +# Echo program name prefixed message to standard error, followed by +# a help hint, and exit. +func_fatal_help () +{ + func_error ${1+"$@"} + func_fatal_error "$help" +} +help="Try \`$progname --help' for more information." ## default + + +# func_grep expression filename +# Check whether EXPRESSION matches any line of FILENAME, without output. +func_grep () +{ + $GREP "$1" "$2" >/dev/null 2>&1 +} + + +# func_mkdir_p directory-path +# Make sure the entire path to DIRECTORY-PATH is available. +func_mkdir_p () +{ + my_directory_path="$1" + my_dir_list= + + if test -n "$my_directory_path" && test "$opt_dry_run" != ":"; then + + # Protect directory names starting with `-' + case $my_directory_path in + -*) my_directory_path="./$my_directory_path" ;; + esac + + # While some portion of DIR does not yet exist... + while test ! -d "$my_directory_path"; do + # ...make a list in topmost first order. Use a colon delimited + # list incase some portion of path contains whitespace. + my_dir_list="$my_directory_path:$my_dir_list" + + # If the last portion added has no slash in it, the list is done + case $my_directory_path in */*) ;; *) break ;; esac + + # ...otherwise throw away the child directory and loop + my_directory_path=`$ECHO "$my_directory_path" | $SED -e "$dirname"` + done + my_dir_list=`$ECHO "$my_dir_list" | $SED 's,:*$,,'` + + save_mkdir_p_IFS="$IFS"; IFS=':' + for my_dir in $my_dir_list; do + IFS="$save_mkdir_p_IFS" + # mkdir can fail with a `File exist' error if two processes + # try to create one of the directories concurrently. Don't + # stop in that case! + $MKDIR "$my_dir" 2>/dev/null || : + done + IFS="$save_mkdir_p_IFS" + + # Bail out if we (or some other process) failed to create a directory. + test -d "$my_directory_path" || \ + func_fatal_error "Failed to create \`$1'" + fi +} + + +# func_mktempdir [string] +# Make a temporary directory that won't clash with other running +# libtool processes, and avoids race conditions if possible. If +# given, STRING is the basename for that directory. +func_mktempdir () +{ + my_template="${TMPDIR-/tmp}/${1-$progname}" + + if test "$opt_dry_run" = ":"; then + # Return a directory name, but don't create it in dry-run mode + my_tmpdir="${my_template}-$$" + else + + # If mktemp works, use that first and foremost + my_tmpdir=`mktemp -d "${my_template}-XXXXXXXX" 2>/dev/null` + + if test ! -d "$my_tmpdir"; then + # Failing that, at least try and use $RANDOM to avoid a race + my_tmpdir="${my_template}-${RANDOM-0}$$" + + save_mktempdir_umask=`umask` + umask 0077 + $MKDIR "$my_tmpdir" + umask $save_mktempdir_umask + fi + + # If we're not in dry-run mode, bomb out on failure + test -d "$my_tmpdir" || \ + func_fatal_error "cannot create temporary directory \`$my_tmpdir'" + fi + + $ECHO "$my_tmpdir" +} + + +# func_quote_for_eval arg +# Aesthetically quote ARG to be evaled later. +# This function returns two values: FUNC_QUOTE_FOR_EVAL_RESULT +# is double-quoted, suitable for a subsequent eval, whereas +# FUNC_QUOTE_FOR_EVAL_UNQUOTED_RESULT has merely all characters +# which are still active within double quotes backslashified. +func_quote_for_eval () +{ + case $1 in + *[\\\`\"\$]*) + func_quote_for_eval_unquoted_result=`$ECHO "$1" | $SED "$sed_quote_subst"` ;; + *) + func_quote_for_eval_unquoted_result="$1" ;; + esac + + case $func_quote_for_eval_unquoted_result in + # Double-quote args containing shell metacharacters to delay + # word splitting, command substitution and and variable + # expansion for a subsequent eval. + # Many Bourne shells cannot handle close brackets correctly + # in scan sets, so we specify it separately. + *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"") + func_quote_for_eval_result="\"$func_quote_for_eval_unquoted_result\"" + ;; + *) + func_quote_for_eval_result="$func_quote_for_eval_unquoted_result" + esac +} + + +# func_quote_for_expand arg +# Aesthetically quote ARG to be evaled later; same as above, +# but do not quote variable references. +func_quote_for_expand () +{ + case $1 in + *[\\\`\"]*) + my_arg=`$ECHO "$1" | $SED \ + -e "$double_quote_subst" -e "$sed_double_backslash"` ;; + *) + my_arg="$1" ;; + esac + + case $my_arg in + # Double-quote args containing shell metacharacters to delay + # word splitting and command substitution for a subsequent eval. + # Many Bourne shells cannot handle close brackets correctly + # in scan sets, so we specify it separately. + *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"") + my_arg="\"$my_arg\"" + ;; + esac + + func_quote_for_expand_result="$my_arg" +} + + +# func_show_eval cmd [fail_exp] +# Unless opt_silent is true, then output CMD. Then, if opt_dryrun is +# not true, evaluate CMD. If the evaluation of CMD fails, and FAIL_EXP +# is given, then evaluate it. +func_show_eval () +{ + my_cmd="$1" + my_fail_exp="${2-:}" + + ${opt_silent-false} || { + func_quote_for_expand "$my_cmd" + eval "func_echo $func_quote_for_expand_result" + } + + if ${opt_dry_run-false}; then :; else + eval "$my_cmd" + my_status=$? + if test "$my_status" -eq 0; then :; else + eval "(exit $my_status); $my_fail_exp" + fi + fi +} + + +# func_show_eval_locale cmd [fail_exp] +# Unless opt_silent is true, then output CMD. Then, if opt_dryrun is +# not true, evaluate CMD. If the evaluation of CMD fails, and FAIL_EXP +# is given, then evaluate it. Use the saved locale for evaluation. +func_show_eval_locale () +{ + my_cmd="$1" + my_fail_exp="${2-:}" + + ${opt_silent-false} || { + func_quote_for_expand "$my_cmd" + eval "func_echo $func_quote_for_expand_result" + } + + if ${opt_dry_run-false}; then :; else + eval "$lt_user_locale + $my_cmd" + my_status=$? + eval "$lt_safe_locale" + if test "$my_status" -eq 0; then :; else + eval "(exit $my_status); $my_fail_exp" + fi + fi +} + +# func_tr_sh +# Turn $1 into a string suitable for a shell variable name. +# Result is stored in $func_tr_sh_result. All characters +# not in the set a-zA-Z0-9_ are replaced with '_'. Further, +# if $1 begins with a digit, a '_' is prepended as well. +func_tr_sh () +{ + case $1 in + [0-9]* | *[!a-zA-Z0-9_]*) + func_tr_sh_result=`$ECHO "$1" | $SED 's/^\([0-9]\)/_\1/; s/[^a-zA-Z0-9_]/_/g'` + ;; + * ) + func_tr_sh_result=$1 + ;; + esac +} + + +# func_version +# Echo version message to standard output and exit. +func_version () +{ + $opt_debug + + $SED -n '/(C)/!b go + :more + /\./!{ + N + s/\n# / / + b more + } + :go + /^# '$PROGRAM' (GNU /,/# warranty; / { + s/^# // + s/^# *$// + s/\((C)\)[ 0-9,-]*\( [1-9][0-9]*\)/\1\2/ + p + }' < "$progpath" + exit $? +} + +# func_usage +# Echo short help message to standard output and exit. +func_usage () +{ + $opt_debug + + $SED -n '/^# Usage:/,/^# *.*--help/ { + s/^# // + s/^# *$// + s/\$progname/'$progname'/ + p + }' < "$progpath" + echo + $ECHO "run \`$progname --help | more' for full usage" + exit $? +} + +# func_help [NOEXIT] +# Echo long help message to standard output and exit, +# unless 'noexit' is passed as argument. +func_help () +{ + $opt_debug + + $SED -n '/^# Usage:/,/# Report bugs to/ { + :print + s/^# // + s/^# *$// + s*\$progname*'$progname'* + s*\$host*'"$host"'* + s*\$SHELL*'"$SHELL"'* + s*\$LTCC*'"$LTCC"'* + s*\$LTCFLAGS*'"$LTCFLAGS"'* + s*\$LD*'"$LD"'* + s/\$with_gnu_ld/'"$with_gnu_ld"'/ + s/\$automake_version/'"`(${AUTOMAKE-automake} --version) 2>/dev/null |$SED 1q`"'/ + s/\$autoconf_version/'"`(${AUTOCONF-autoconf} --version) 2>/dev/null |$SED 1q`"'/ + p + d + } + /^# .* home page:/b print + /^# General help using/b print + ' < "$progpath" + ret=$? + if test -z "$1"; then + exit $ret + fi +} + +# func_missing_arg argname +# Echo program name prefixed message to standard error and set global +# exit_cmd. +func_missing_arg () +{ + $opt_debug + + func_error "missing argument for $1." + exit_cmd=exit +} + + +# func_split_short_opt shortopt +# Set func_split_short_opt_name and func_split_short_opt_arg shell +# variables after splitting SHORTOPT after the 2nd character. +func_split_short_opt () +{ + func_split_short_opt_arg=${1#??} + func_split_short_opt_name=${1%"$func_split_short_opt_arg"} +} # Extended-shell func_split_short_opt implementation + + +# func_split_long_opt longopt +# Set func_split_long_opt_name and func_split_long_opt_arg shell +# variables after splitting LONGOPT at the `=' sign. +func_split_long_opt () +{ + func_split_long_opt_name=${1%%=*} + func_split_long_opt_arg=${1#*=} +} # Extended-shell func_split_long_opt implementation + +exit_cmd=: + + + + + +magic="%%%MAGIC variable%%%" +magic_exe="%%%MAGIC EXE variable%%%" + +# Global variables. +nonopt= +preserve_args= +lo2o="s/\\.lo\$/.${objext}/" +o2lo="s/\\.${objext}\$/.lo/" +extracted_archives= +extracted_serial=0 + +# If this variable is set in any of the actions, the command in it +# will be execed at the end. This prevents here-documents from being +# left over by shells. +exec_cmd= + +# func_append var value +# Append VALUE to the end of shell variable VAR. +func_append () +{ + eval "${1}+=\${2}" +} # Extended-shell func_append implementation + +# func_append_quoted var value +# Quote VALUE and append to the end of shell variable VAR, separated +# by a space. +func_append_quoted () +{ + func_quote_for_eval "${2}" + eval "${1}+=\\ \$func_quote_for_eval_result" +} # Extended-shell func_append_quoted implementation + + +# func_arith arithmetic-term... +func_arith () +{ + func_arith_result=$(( $* )) +} # Extended-shell func_arith implementation + + +# func_len string +# STRING may not start with a hyphen. +func_len () +{ + func_len_result=${#1} +} # Extended-shell func_len implementation + + +# func_lo2o object +func_lo2o () +{ + case ${1} in + *.lo) func_lo2o_result=${1%.lo}.${objext} ;; + *) func_lo2o_result=${1} ;; + esac +} # Extended-shell func_lo2o implementation + + +# func_xform libobj-or-source +func_xform () +{ + func_xform_result=${1%.*}.lo +} # Extended-shell func_xform implementation + + +# func_fatal_configuration arg... +# Echo program name prefixed message to standard error, followed by +# a configuration failure hint, and exit. +func_fatal_configuration () +{ + func_error ${1+"$@"} + func_error "See the $PACKAGE documentation for more information." + func_fatal_error "Fatal configuration error." +} + + +# func_config +# Display the configuration for all the tags in this script. +func_config () +{ + re_begincf='^# ### BEGIN LIBTOOL' + re_endcf='^# ### END LIBTOOL' + + # Default configuration. + $SED "1,/$re_begincf CONFIG/d;/$re_endcf CONFIG/,\$d" < "$progpath" + + # Now print the configurations for the tags. + for tagname in $taglist; do + $SED -n "/$re_begincf TAG CONFIG: $tagname\$/,/$re_endcf TAG CONFIG: $tagname\$/p" < "$progpath" + done + + exit $? +} + +# func_features +# Display the features supported by this script. +func_features () +{ + echo "host: $host" + if test "$build_libtool_libs" = yes; then + echo "enable shared libraries" + else + echo "disable shared libraries" + fi + if test "$build_old_libs" = yes; then + echo "enable static libraries" + else + echo "disable static libraries" + fi + + exit $? +} + +# func_enable_tag tagname +# Verify that TAGNAME is valid, and either flag an error and exit, or +# enable the TAGNAME tag. We also add TAGNAME to the global $taglist +# variable here. +func_enable_tag () +{ + # Global variable: + tagname="$1" + + re_begincf="^# ### BEGIN LIBTOOL TAG CONFIG: $tagname\$" + re_endcf="^# ### END LIBTOOL TAG CONFIG: $tagname\$" + sed_extractcf="/$re_begincf/,/$re_endcf/p" + + # Validate tagname. + case $tagname in + *[!-_A-Za-z0-9,/]*) + func_fatal_error "invalid tag name: $tagname" + ;; + esac + + # Don't test for the "default" C tag, as we know it's + # there but not specially marked. + case $tagname in + CC) ;; + *) + if $GREP "$re_begincf" "$progpath" >/dev/null 2>&1; then + taglist="$taglist $tagname" + + # Evaluate the configuration. Be careful to quote the path + # and the sed script, to avoid splitting on whitespace, but + # also don't use non-portable quotes within backquotes within + # quotes we have to do it in 2 steps: + extractedcf=`$SED -n -e "$sed_extractcf" < "$progpath"` + eval "$extractedcf" + else + func_error "ignoring unknown tag $tagname" + fi + ;; + esac +} + +# func_check_version_match +# Ensure that we are using m4 macros, and libtool script from the same +# release of libtool. +func_check_version_match () +{ + if test "$package_revision" != "$macro_revision"; then + if test "$VERSION" != "$macro_version"; then + if test -z "$macro_version"; then + cat >&2 <<_LT_EOF +$progname: Version mismatch error. This is $PACKAGE $VERSION, but the +$progname: definition of this LT_INIT comes from an older release. +$progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION +$progname: and run autoconf again. +_LT_EOF + else + cat >&2 <<_LT_EOF +$progname: Version mismatch error. This is $PACKAGE $VERSION, but the +$progname: definition of this LT_INIT comes from $PACKAGE $macro_version. +$progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION +$progname: and run autoconf again. +_LT_EOF + fi + else + cat >&2 <<_LT_EOF +$progname: Version mismatch error. This is $PACKAGE $VERSION, revision $package_revision, +$progname: but the definition of this LT_INIT comes from revision $macro_revision. +$progname: You should recreate aclocal.m4 with macros from revision $package_revision +$progname: of $PACKAGE $VERSION and run autoconf again. +_LT_EOF + fi + + exit $EXIT_MISMATCH + fi +} + + +# Shorthand for --mode=foo, only valid as the first argument +case $1 in +clean|clea|cle|cl) + shift; set dummy --mode clean ${1+"$@"}; shift + ;; +compile|compil|compi|comp|com|co|c) + shift; set dummy --mode compile ${1+"$@"}; shift + ;; +execute|execut|execu|exec|exe|ex|e) + shift; set dummy --mode execute ${1+"$@"}; shift + ;; +finish|finis|fini|fin|fi|f) + shift; set dummy --mode finish ${1+"$@"}; shift + ;; +install|instal|insta|inst|ins|in|i) + shift; set dummy --mode install ${1+"$@"}; shift + ;; +link|lin|li|l) + shift; set dummy --mode link ${1+"$@"}; shift + ;; +uninstall|uninstal|uninsta|uninst|unins|unin|uni|un|u) + shift; set dummy --mode uninstall ${1+"$@"}; shift + ;; +esac + + + +# Option defaults: +opt_debug=: +opt_dry_run=false +opt_config=false +opt_preserve_dup_deps=false +opt_features=false +opt_finish=false +opt_help=false +opt_help_all=false +opt_silent=: +opt_warning=: +opt_verbose=: +opt_silent=false +opt_verbose=false + + +# Parse options once, thoroughly. This comes as soon as possible in the +# script to make things like `--version' happen as quickly as we can. +{ + # this just eases exit handling + while test $# -gt 0; do + opt="$1" + shift + case $opt in + --debug|-x) opt_debug='set -x' + func_echo "enabling shell trace mode" + $opt_debug + ;; + --dry-run|--dryrun|-n) + opt_dry_run=: + ;; + --config) + opt_config=: +func_config + ;; + --dlopen|-dlopen) + optarg="$1" + opt_dlopen="${opt_dlopen+$opt_dlopen +}$optarg" + shift + ;; + --preserve-dup-deps) + opt_preserve_dup_deps=: + ;; + --features) + opt_features=: +func_features + ;; + --finish) + opt_finish=: +set dummy --mode finish ${1+"$@"}; shift + ;; + --help) + opt_help=: + ;; + --help-all) + opt_help_all=: +opt_help=': help-all' + ;; + --mode) + test $# = 0 && func_missing_arg $opt && break + optarg="$1" + opt_mode="$optarg" +case $optarg in + # Valid mode arguments: + clean|compile|execute|finish|install|link|relink|uninstall) ;; + + # Catch anything else as an error + *) func_error "invalid argument for $opt" + exit_cmd=exit + break + ;; +esac + shift + ;; + --no-silent|--no-quiet) + opt_silent=false +preserve_args+=" $opt" + ;; + --no-warning|--no-warn) + opt_warning=false +preserve_args+=" $opt" + ;; + --no-verbose) + opt_verbose=false +preserve_args+=" $opt" + ;; + --silent|--quiet) + opt_silent=: +preserve_args+=" $opt" + opt_verbose=false + ;; + --verbose|-v) + opt_verbose=: +preserve_args+=" $opt" +opt_silent=false + ;; + --tag) + test $# = 0 && func_missing_arg $opt && break + optarg="$1" + opt_tag="$optarg" +preserve_args+=" $opt $optarg" +func_enable_tag "$optarg" + shift + ;; + + -\?|-h) func_usage ;; + --help) func_help ;; + --version) func_version ;; + + # Separate optargs to long options: + --*=*) + func_split_long_opt "$opt" + set dummy "$func_split_long_opt_name" "$func_split_long_opt_arg" ${1+"$@"} + shift + ;; + + # Separate non-argument short options: + -\?*|-h*|-n*|-v*) + func_split_short_opt "$opt" + set dummy "$func_split_short_opt_name" "-$func_split_short_opt_arg" ${1+"$@"} + shift + ;; + + --) break ;; + -*) func_fatal_help "unrecognized option \`$opt'" ;; + *) set dummy "$opt" ${1+"$@"}; shift; break ;; + esac + done + + # Validate options: + + # save first non-option argument + if test "$#" -gt 0; then + nonopt="$opt" + shift + fi + + # preserve --debug + test "$opt_debug" = : || preserve_args+=" --debug" + + case $host in + *cygwin* | *mingw* | *pw32* | *cegcc*) + # don't eliminate duplications in $postdeps and $predeps + opt_duplicate_compiler_generated_deps=: + ;; + *) + opt_duplicate_compiler_generated_deps=$opt_preserve_dup_deps + ;; + esac + + $opt_help || { + # Sanity checks first: + func_check_version_match + + if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then + func_fatal_configuration "not configured to build any kind of library" + fi + + # Darwin sucks + eval std_shrext=\"$shrext_cmds\" + + # Only execute mode is allowed to have -dlopen flags. + if test -n "$opt_dlopen" && test "$opt_mode" != execute; then + func_error "unrecognized option \`-dlopen'" + $ECHO "$help" 1>&2 + exit $EXIT_FAILURE + fi + + # Change the help message to a mode-specific one. + generic_help="$help" + help="Try \`$progname --help --mode=$opt_mode' for more information." + } + + + # Bail if the options were screwed + $exit_cmd $EXIT_FAILURE +} + + + + +## ----------- ## +## Main. ## +## ----------- ## + +# func_lalib_p file +# True iff FILE is a libtool `.la' library or `.lo' object file. +# This function is only a basic sanity check; it will hardly flush out +# determined imposters. +func_lalib_p () +{ + test -f "$1" && + $SED -e 4q "$1" 2>/dev/null \ + | $GREP "^# Generated by .*$PACKAGE" > /dev/null 2>&1 +} + +# func_lalib_unsafe_p file +# True iff FILE is a libtool `.la' library or `.lo' object file. +# This function implements the same check as func_lalib_p without +# resorting to external programs. To this end, it redirects stdin and +# closes it afterwards, without saving the original file descriptor. +# As a safety measure, use it only where a negative result would be +# fatal anyway. Works if `file' does not exist. +func_lalib_unsafe_p () +{ + lalib_p=no + if test -f "$1" && test -r "$1" && exec 5<&0 <"$1"; then + for lalib_p_l in 1 2 3 4 + do + read lalib_p_line + case "$lalib_p_line" in + \#\ Generated\ by\ *$PACKAGE* ) lalib_p=yes; break;; + esac + done + exec 0<&5 5<&- + fi + test "$lalib_p" = yes +} + +# func_ltwrapper_script_p file +# True iff FILE is a libtool wrapper script +# This function is only a basic sanity check; it will hardly flush out +# determined imposters. +func_ltwrapper_script_p () +{ + func_lalib_p "$1" +} + +# func_ltwrapper_executable_p file +# True iff FILE is a libtool wrapper executable +# This function is only a basic sanity check; it will hardly flush out +# determined imposters. +func_ltwrapper_executable_p () +{ + func_ltwrapper_exec_suffix= + case $1 in + *.exe) ;; + *) func_ltwrapper_exec_suffix=.exe ;; + esac + $GREP "$magic_exe" "$1$func_ltwrapper_exec_suffix" >/dev/null 2>&1 +} + +# func_ltwrapper_scriptname file +# Assumes file is an ltwrapper_executable +# uses $file to determine the appropriate filename for a +# temporary ltwrapper_script. +func_ltwrapper_scriptname () +{ + func_dirname_and_basename "$1" "" "." + func_stripname '' '.exe' "$func_basename_result" + func_ltwrapper_scriptname_result="$func_dirname_result/$objdir/${func_stripname_result}_ltshwrapper" +} + +# func_ltwrapper_p file +# True iff FILE is a libtool wrapper script or wrapper executable +# This function is only a basic sanity check; it will hardly flush out +# determined imposters. +func_ltwrapper_p () +{ + func_ltwrapper_script_p "$1" || func_ltwrapper_executable_p "$1" +} + + +# func_execute_cmds commands fail_cmd +# Execute tilde-delimited COMMANDS. +# If FAIL_CMD is given, eval that upon failure. +# FAIL_CMD may read-access the current command in variable CMD! +func_execute_cmds () +{ + $opt_debug + save_ifs=$IFS; IFS='~' + for cmd in $1; do + IFS=$save_ifs + eval cmd=\"$cmd\" + func_show_eval "$cmd" "${2-:}" + done + IFS=$save_ifs +} + + +# func_source file +# Source FILE, adding directory component if necessary. +# Note that it is not necessary on cygwin/mingw to append a dot to +# FILE even if both FILE and FILE.exe exist: automatic-append-.exe +# behavior happens only for exec(3), not for open(2)! Also, sourcing +# `FILE.' does not work on cygwin managed mounts. +func_source () +{ + $opt_debug + case $1 in + */* | *\\*) . "$1" ;; + *) . "./$1" ;; + esac +} + + +# func_resolve_sysroot PATH +# Replace a leading = in PATH with a sysroot. Store the result into +# func_resolve_sysroot_result +func_resolve_sysroot () +{ + func_resolve_sysroot_result=$1 + case $func_resolve_sysroot_result in + =*) + func_stripname '=' '' "$func_resolve_sysroot_result" + func_resolve_sysroot_result=$lt_sysroot$func_stripname_result + ;; + esac +} + +# func_replace_sysroot PATH +# If PATH begins with the sysroot, replace it with = and +# store the result into func_replace_sysroot_result. +func_replace_sysroot () +{ + case "$lt_sysroot:$1" in + ?*:"$lt_sysroot"*) + func_stripname "$lt_sysroot" '' "$1" + func_replace_sysroot_result="=$func_stripname_result" + ;; + *) + # Including no sysroot. + func_replace_sysroot_result=$1 + ;; + esac +} + +# func_infer_tag arg +# Infer tagged configuration to use if any are available and +# if one wasn't chosen via the "--tag" command line option. +# Only attempt this if the compiler in the base compile +# command doesn't match the default compiler. +# arg is usually of the form 'gcc ...' +func_infer_tag () +{ + $opt_debug + if test -n "$available_tags" && test -z "$tagname"; then + CC_quoted= + for arg in $CC; do + func_append_quoted CC_quoted "$arg" + done + CC_expanded=`func_echo_all $CC` + CC_quoted_expanded=`func_echo_all $CC_quoted` + case $@ in + # Blanks in the command may have been stripped by the calling shell, + # but not from the CC environment variable when configure was run. + " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \ + " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*) ;; + # Blanks at the start of $base_compile will cause this to fail + # if we don't check for them as well. + *) + for z in $available_tags; do + if $GREP "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then + # Evaluate the configuration. + eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`" + CC_quoted= + for arg in $CC; do + # Double-quote args containing other shell metacharacters. + func_append_quoted CC_quoted "$arg" + done + CC_expanded=`func_echo_all $CC` + CC_quoted_expanded=`func_echo_all $CC_quoted` + case "$@ " in + " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \ + " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*) + # The compiler in the base compile command matches + # the one in the tagged configuration. + # Assume this is the tagged configuration we want. + tagname=$z + break + ;; + esac + fi + done + # If $tagname still isn't set, then no tagged configuration + # was found and let the user know that the "--tag" command + # line option must be used. + if test -z "$tagname"; then + func_echo "unable to infer tagged configuration" + func_fatal_error "specify a tag with \`--tag'" +# else +# func_verbose "using $tagname tagged configuration" + fi + ;; + esac + fi +} + + + +# func_write_libtool_object output_name pic_name nonpic_name +# Create a libtool object file (analogous to a ".la" file), +# but don't create it if we're doing a dry run. +func_write_libtool_object () +{ + write_libobj=${1} + if test "$build_libtool_libs" = yes; then + write_lobj=\'${2}\' + else + write_lobj=none + fi + + if test "$build_old_libs" = yes; then + write_oldobj=\'${3}\' + else + write_oldobj=none + fi + + $opt_dry_run || { + cat >${write_libobj}T </dev/null` + if test "$?" -eq 0 && test -n "${func_convert_core_file_wine_to_w32_tmp}"; then + func_convert_core_file_wine_to_w32_result=`$ECHO "$func_convert_core_file_wine_to_w32_tmp" | + $SED -e "$lt_sed_naive_backslashify"` + else + func_convert_core_file_wine_to_w32_result= + fi + fi +} +# end: func_convert_core_file_wine_to_w32 + + +# func_convert_core_path_wine_to_w32 ARG +# Helper function used by path conversion functions when $build is *nix, and +# $host is mingw, cygwin, or some other w32 environment. Relies on a correctly +# configured wine environment available, with the winepath program in $build's +# $PATH. Assumes ARG has no leading or trailing path separator characters. +# +# ARG is path to be converted from $build format to win32. +# Result is available in $func_convert_core_path_wine_to_w32_result. +# Unconvertible file (directory) names in ARG are skipped; if no directory names +# are convertible, then the result may be empty. +func_convert_core_path_wine_to_w32 () +{ + $opt_debug + # unfortunately, winepath doesn't convert paths, only file names + func_convert_core_path_wine_to_w32_result="" + if test -n "$1"; then + oldIFS=$IFS + IFS=: + for func_convert_core_path_wine_to_w32_f in $1; do + IFS=$oldIFS + func_convert_core_file_wine_to_w32 "$func_convert_core_path_wine_to_w32_f" + if test -n "$func_convert_core_file_wine_to_w32_result" ; then + if test -z "$func_convert_core_path_wine_to_w32_result"; then + func_convert_core_path_wine_to_w32_result="$func_convert_core_file_wine_to_w32_result" + else + func_append func_convert_core_path_wine_to_w32_result ";$func_convert_core_file_wine_to_w32_result" + fi + fi + done + IFS=$oldIFS + fi +} +# end: func_convert_core_path_wine_to_w32 + + +# func_cygpath ARGS... +# Wrapper around calling the cygpath program via LT_CYGPATH. This is used when +# when (1) $build is *nix and Cygwin is hosted via a wine environment; or (2) +# $build is MSYS and $host is Cygwin, or (3) $build is Cygwin. In case (1) or +# (2), returns the Cygwin file name or path in func_cygpath_result (input +# file name or path is assumed to be in w32 format, as previously converted +# from $build's *nix or MSYS format). In case (3), returns the w32 file name +# or path in func_cygpath_result (input file name or path is assumed to be in +# Cygwin format). Returns an empty string on error. +# +# ARGS are passed to cygpath, with the last one being the file name or path to +# be converted. +# +# Specify the absolute *nix (or w32) name to cygpath in the LT_CYGPATH +# environment variable; do not put it in $PATH. +func_cygpath () +{ + $opt_debug + if test -n "$LT_CYGPATH" && test -f "$LT_CYGPATH"; then + func_cygpath_result=`$LT_CYGPATH "$@" 2>/dev/null` + if test "$?" -ne 0; then + # on failure, ensure result is empty + func_cygpath_result= + fi + else + func_cygpath_result= + func_error "LT_CYGPATH is empty or specifies non-existent file: \`$LT_CYGPATH'" + fi +} +#end: func_cygpath + + +# func_convert_core_msys_to_w32 ARG +# Convert file name or path ARG from MSYS format to w32 format. Return +# result in func_convert_core_msys_to_w32_result. +func_convert_core_msys_to_w32 () +{ + $opt_debug + # awkward: cmd appends spaces to result + func_convert_core_msys_to_w32_result=`( cmd //c echo "$1" ) 2>/dev/null | + $SED -e 's/[ ]*$//' -e "$lt_sed_naive_backslashify"` +} +#end: func_convert_core_msys_to_w32 + + +# func_convert_file_check ARG1 ARG2 +# Verify that ARG1 (a file name in $build format) was converted to $host +# format in ARG2. Otherwise, emit an error message, but continue (resetting +# func_to_host_file_result to ARG1). +func_convert_file_check () +{ + $opt_debug + if test -z "$2" && test -n "$1" ; then + func_error "Could not determine host file name corresponding to" + func_error " \`$1'" + func_error "Continuing, but uninstalled executables may not work." + # Fallback: + func_to_host_file_result="$1" + fi +} +# end func_convert_file_check + + +# func_convert_path_check FROM_PATHSEP TO_PATHSEP FROM_PATH TO_PATH +# Verify that FROM_PATH (a path in $build format) was converted to $host +# format in TO_PATH. Otherwise, emit an error message, but continue, resetting +# func_to_host_file_result to a simplistic fallback value (see below). +func_convert_path_check () +{ + $opt_debug + if test -z "$4" && test -n "$3"; then + func_error "Could not determine the host path corresponding to" + func_error " \`$3'" + func_error "Continuing, but uninstalled executables may not work." + # Fallback. This is a deliberately simplistic "conversion" and + # should not be "improved". See libtool.info. + if test "x$1" != "x$2"; then + lt_replace_pathsep_chars="s|$1|$2|g" + func_to_host_path_result=`echo "$3" | + $SED -e "$lt_replace_pathsep_chars"` + else + func_to_host_path_result="$3" + fi + fi +} +# end func_convert_path_check + + +# func_convert_path_front_back_pathsep FRONTPAT BACKPAT REPL ORIG +# Modifies func_to_host_path_result by prepending REPL if ORIG matches FRONTPAT +# and appending REPL if ORIG matches BACKPAT. +func_convert_path_front_back_pathsep () +{ + $opt_debug + case $4 in + $1 ) func_to_host_path_result="$3$func_to_host_path_result" + ;; + esac + case $4 in + $2 ) func_to_host_path_result+="$3" + ;; + esac +} +# end func_convert_path_front_back_pathsep + + +################################################## +# $build to $host FILE NAME CONVERSION FUNCTIONS # +################################################## +# invoked via `$to_host_file_cmd ARG' +# +# In each case, ARG is the path to be converted from $build to $host format. +# Result will be available in $func_to_host_file_result. + + +# func_to_host_file ARG +# Converts the file name ARG from $build format to $host format. Return result +# in func_to_host_file_result. +func_to_host_file () +{ + $opt_debug + $to_host_file_cmd "$1" +} +# end func_to_host_file + + +# func_to_tool_file ARG LAZY +# converts the file name ARG from $build format to toolchain format. Return +# result in func_to_tool_file_result. If the conversion in use is listed +# in (the comma separated) LAZY, no conversion takes place. +func_to_tool_file () +{ + $opt_debug + case ,$2, in + *,"$to_tool_file_cmd",*) + func_to_tool_file_result=$1 + ;; + *) + $to_tool_file_cmd "$1" + func_to_tool_file_result=$func_to_host_file_result + ;; + esac +} +# end func_to_tool_file + + +# func_convert_file_noop ARG +# Copy ARG to func_to_host_file_result. +func_convert_file_noop () +{ + func_to_host_file_result="$1" +} +# end func_convert_file_noop + + +# func_convert_file_msys_to_w32 ARG +# Convert file name ARG from (mingw) MSYS to (mingw) w32 format; automatic +# conversion to w32 is not available inside the cwrapper. Returns result in +# func_to_host_file_result. +func_convert_file_msys_to_w32 () +{ + $opt_debug + func_to_host_file_result="$1" + if test -n "$1"; then + func_convert_core_msys_to_w32 "$1" + func_to_host_file_result="$func_convert_core_msys_to_w32_result" + fi + func_convert_file_check "$1" "$func_to_host_file_result" +} +# end func_convert_file_msys_to_w32 + + +# func_convert_file_cygwin_to_w32 ARG +# Convert file name ARG from Cygwin to w32 format. Returns result in +# func_to_host_file_result. +func_convert_file_cygwin_to_w32 () +{ + $opt_debug + func_to_host_file_result="$1" + if test -n "$1"; then + # because $build is cygwin, we call "the" cygpath in $PATH; no need to use + # LT_CYGPATH in this case. + func_to_host_file_result=`cygpath -m "$1"` + fi + func_convert_file_check "$1" "$func_to_host_file_result" +} +# end func_convert_file_cygwin_to_w32 + + +# func_convert_file_nix_to_w32 ARG +# Convert file name ARG from *nix to w32 format. Requires a wine environment +# and a working winepath. Returns result in func_to_host_file_result. +func_convert_file_nix_to_w32 () +{ + $opt_debug + func_to_host_file_result="$1" + if test -n "$1"; then + func_convert_core_file_wine_to_w32 "$1" + func_to_host_file_result="$func_convert_core_file_wine_to_w32_result" + fi + func_convert_file_check "$1" "$func_to_host_file_result" +} +# end func_convert_file_nix_to_w32 + + +# func_convert_file_msys_to_cygwin ARG +# Convert file name ARG from MSYS to Cygwin format. Requires LT_CYGPATH set. +# Returns result in func_to_host_file_result. +func_convert_file_msys_to_cygwin () +{ + $opt_debug + func_to_host_file_result="$1" + if test -n "$1"; then + func_convert_core_msys_to_w32 "$1" + func_cygpath -u "$func_convert_core_msys_to_w32_result" + func_to_host_file_result="$func_cygpath_result" + fi + func_convert_file_check "$1" "$func_to_host_file_result" +} +# end func_convert_file_msys_to_cygwin + + +# func_convert_file_nix_to_cygwin ARG +# Convert file name ARG from *nix to Cygwin format. Requires Cygwin installed +# in a wine environment, working winepath, and LT_CYGPATH set. Returns result +# in func_to_host_file_result. +func_convert_file_nix_to_cygwin () +{ + $opt_debug + func_to_host_file_result="$1" + if test -n "$1"; then + # convert from *nix to w32, then use cygpath to convert from w32 to cygwin. + func_convert_core_file_wine_to_w32 "$1" + func_cygpath -u "$func_convert_core_file_wine_to_w32_result" + func_to_host_file_result="$func_cygpath_result" + fi + func_convert_file_check "$1" "$func_to_host_file_result" +} +# end func_convert_file_nix_to_cygwin + + +############################################# +# $build to $host PATH CONVERSION FUNCTIONS # +############################################# +# invoked via `$to_host_path_cmd ARG' +# +# In each case, ARG is the path to be converted from $build to $host format. +# The result will be available in $func_to_host_path_result. +# +# Path separators are also converted from $build format to $host format. If +# ARG begins or ends with a path separator character, it is preserved (but +# converted to $host format) on output. +# +# All path conversion functions are named using the following convention: +# file name conversion function : func_convert_file_X_to_Y () +# path conversion function : func_convert_path_X_to_Y () +# where, for any given $build/$host combination the 'X_to_Y' value is the +# same. If conversion functions are added for new $build/$host combinations, +# the two new functions must follow this pattern, or func_init_to_host_path_cmd +# will break. + + +# func_init_to_host_path_cmd +# Ensures that function "pointer" variable $to_host_path_cmd is set to the +# appropriate value, based on the value of $to_host_file_cmd. +to_host_path_cmd= +func_init_to_host_path_cmd () +{ + $opt_debug + if test -z "$to_host_path_cmd"; then + func_stripname 'func_convert_file_' '' "$to_host_file_cmd" + to_host_path_cmd="func_convert_path_${func_stripname_result}" + fi +} + + +# func_to_host_path ARG +# Converts the path ARG from $build format to $host format. Return result +# in func_to_host_path_result. +func_to_host_path () +{ + $opt_debug + func_init_to_host_path_cmd + $to_host_path_cmd "$1" +} +# end func_to_host_path + + +# func_convert_path_noop ARG +# Copy ARG to func_to_host_path_result. +func_convert_path_noop () +{ + func_to_host_path_result="$1" +} +# end func_convert_path_noop + + +# func_convert_path_msys_to_w32 ARG +# Convert path ARG from (mingw) MSYS to (mingw) w32 format; automatic +# conversion to w32 is not available inside the cwrapper. Returns result in +# func_to_host_path_result. +func_convert_path_msys_to_w32 () +{ + $opt_debug + func_to_host_path_result="$1" + if test -n "$1"; then + # Remove leading and trailing path separator characters from ARG. MSYS + # behavior is inconsistent here; cygpath turns them into '.;' and ';.'; + # and winepath ignores them completely. + func_stripname : : "$1" + func_to_host_path_tmp1=$func_stripname_result + func_convert_core_msys_to_w32 "$func_to_host_path_tmp1" + func_to_host_path_result="$func_convert_core_msys_to_w32_result" + func_convert_path_check : ";" \ + "$func_to_host_path_tmp1" "$func_to_host_path_result" + func_convert_path_front_back_pathsep ":*" "*:" ";" "$1" + fi +} +# end func_convert_path_msys_to_w32 + + +# func_convert_path_cygwin_to_w32 ARG +# Convert path ARG from Cygwin to w32 format. Returns result in +# func_to_host_file_result. +func_convert_path_cygwin_to_w32 () +{ + $opt_debug + func_to_host_path_result="$1" + if test -n "$1"; then + # See func_convert_path_msys_to_w32: + func_stripname : : "$1" + func_to_host_path_tmp1=$func_stripname_result + func_to_host_path_result=`cygpath -m -p "$func_to_host_path_tmp1"` + func_convert_path_check : ";" \ + "$func_to_host_path_tmp1" "$func_to_host_path_result" + func_convert_path_front_back_pathsep ":*" "*:" ";" "$1" + fi +} +# end func_convert_path_cygwin_to_w32 + + +# func_convert_path_nix_to_w32 ARG +# Convert path ARG from *nix to w32 format. Requires a wine environment and +# a working winepath. Returns result in func_to_host_file_result. +func_convert_path_nix_to_w32 () +{ + $opt_debug + func_to_host_path_result="$1" + if test -n "$1"; then + # See func_convert_path_msys_to_w32: + func_stripname : : "$1" + func_to_host_path_tmp1=$func_stripname_result + func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1" + func_to_host_path_result="$func_convert_core_path_wine_to_w32_result" + func_convert_path_check : ";" \ + "$func_to_host_path_tmp1" "$func_to_host_path_result" + func_convert_path_front_back_pathsep ":*" "*:" ";" "$1" + fi +} +# end func_convert_path_nix_to_w32 + + +# func_convert_path_msys_to_cygwin ARG +# Convert path ARG from MSYS to Cygwin format. Requires LT_CYGPATH set. +# Returns result in func_to_host_file_result. +func_convert_path_msys_to_cygwin () +{ + $opt_debug + func_to_host_path_result="$1" + if test -n "$1"; then + # See func_convert_path_msys_to_w32: + func_stripname : : "$1" + func_to_host_path_tmp1=$func_stripname_result + func_convert_core_msys_to_w32 "$func_to_host_path_tmp1" + func_cygpath -u -p "$func_convert_core_msys_to_w32_result" + func_to_host_path_result="$func_cygpath_result" + func_convert_path_check : : \ + "$func_to_host_path_tmp1" "$func_to_host_path_result" + func_convert_path_front_back_pathsep ":*" "*:" : "$1" + fi +} +# end func_convert_path_msys_to_cygwin + + +# func_convert_path_nix_to_cygwin ARG +# Convert path ARG from *nix to Cygwin format. Requires Cygwin installed in a +# a wine environment, working winepath, and LT_CYGPATH set. Returns result in +# func_to_host_file_result. +func_convert_path_nix_to_cygwin () +{ + $opt_debug + func_to_host_path_result="$1" + if test -n "$1"; then + # Remove leading and trailing path separator characters from + # ARG. msys behavior is inconsistent here, cygpath turns them + # into '.;' and ';.', and winepath ignores them completely. + func_stripname : : "$1" + func_to_host_path_tmp1=$func_stripname_result + func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1" + func_cygpath -u -p "$func_convert_core_path_wine_to_w32_result" + func_to_host_path_result="$func_cygpath_result" + func_convert_path_check : : \ + "$func_to_host_path_tmp1" "$func_to_host_path_result" + func_convert_path_front_back_pathsep ":*" "*:" : "$1" + fi +} +# end func_convert_path_nix_to_cygwin + + +# func_mode_compile arg... +func_mode_compile () +{ + $opt_debug + # Get the compilation command and the source file. + base_compile= + srcfile="$nonopt" # always keep a non-empty value in "srcfile" + suppress_opt=yes + suppress_output= + arg_mode=normal + libobj= + later= + pie_flag= + + for arg + do + case $arg_mode in + arg ) + # do not "continue". Instead, add this to base_compile + lastarg="$arg" + arg_mode=normal + ;; + + target ) + libobj="$arg" + arg_mode=normal + continue + ;; + + normal ) + # Accept any command-line options. + case $arg in + -o) + test -n "$libobj" && \ + func_fatal_error "you cannot specify \`-o' more than once" + arg_mode=target + continue + ;; + + -pie | -fpie | -fPIE) + pie_flag+=" $arg" + continue + ;; + + -shared | -static | -prefer-pic | -prefer-non-pic) + later+=" $arg" + continue + ;; + + -no-suppress) + suppress_opt=no + continue + ;; + + -Xcompiler) + arg_mode=arg # the next one goes into the "base_compile" arg list + continue # The current "srcfile" will either be retained or + ;; # replaced later. I would guess that would be a bug. + + -Wc,*) + func_stripname '-Wc,' '' "$arg" + args=$func_stripname_result + lastarg= + save_ifs="$IFS"; IFS=',' + for arg in $args; do + IFS="$save_ifs" + func_append_quoted lastarg "$arg" + done + IFS="$save_ifs" + func_stripname ' ' '' "$lastarg" + lastarg=$func_stripname_result + + # Add the arguments to base_compile. + base_compile+=" $lastarg" + continue + ;; + + *) + # Accept the current argument as the source file. + # The previous "srcfile" becomes the current argument. + # + lastarg="$srcfile" + srcfile="$arg" + ;; + esac # case $arg + ;; + esac # case $arg_mode + + # Aesthetically quote the previous argument. + func_append_quoted base_compile "$lastarg" + done # for arg + + case $arg_mode in + arg) + func_fatal_error "you must specify an argument for -Xcompile" + ;; + target) + func_fatal_error "you must specify a target with \`-o'" + ;; + *) + # Get the name of the library object. + test -z "$libobj" && { + func_basename "$srcfile" + libobj="$func_basename_result" + } + ;; + esac + + # Recognize several different file suffixes. + # If the user specifies -o file.o, it is replaced with file.lo + case $libobj in + *.[cCFSifmso] | \ + *.ada | *.adb | *.ads | *.asm | \ + *.c++ | *.cc | *.ii | *.class | *.cpp | *.cxx | \ + *.[fF][09]? | *.for | *.java | *.go | *.obj | *.sx | *.cu | *.cup) + func_xform "$libobj" + libobj=$func_xform_result + ;; + esac + + case $libobj in + *.lo) func_lo2o "$libobj"; obj=$func_lo2o_result ;; + *) + func_fatal_error "cannot determine name of library object from \`$libobj'" + ;; + esac + + func_infer_tag $base_compile + + for arg in $later; do + case $arg in + -shared) + test "$build_libtool_libs" != yes && \ + func_fatal_configuration "can not build a shared library" + build_old_libs=no + continue + ;; + + -static) + build_libtool_libs=no + build_old_libs=yes + continue + ;; + + -prefer-pic) + pic_mode=yes + continue + ;; + + -prefer-non-pic) + pic_mode=no + continue + ;; + esac + done + + func_quote_for_eval "$libobj" + test "X$libobj" != "X$func_quote_for_eval_result" \ + && $ECHO "X$libobj" | $GREP '[]~#^*{};<>?"'"'"' &()|`$[]' \ + && func_warning "libobj name \`$libobj' may not contain shell special characters." + func_dirname_and_basename "$obj" "/" "" + objname="$func_basename_result" + xdir="$func_dirname_result" + lobj=${xdir}$objdir/$objname + + test -z "$base_compile" && \ + func_fatal_help "you must specify a compilation command" + + # Delete any leftover library objects. + if test "$build_old_libs" = yes; then + removelist="$obj $lobj $libobj ${libobj}T" + else + removelist="$lobj $libobj ${libobj}T" + fi + + # On Cygwin there's no "real" PIC flag so we must build both object types + case $host_os in + cygwin* | mingw* | pw32* | os2* | cegcc*) + pic_mode=default + ;; + esac + if test "$pic_mode" = no && test "$deplibs_check_method" != pass_all; then + # non-PIC code in shared libraries is not supported + pic_mode=default + fi + + # Calculate the filename of the output object if compiler does + # not support -o with -c + if test "$compiler_c_o" = no; then + output_obj=`$ECHO "$srcfile" | $SED 's%^.*/%%; s%\.[^.]*$%%'`.${objext} + lockfile="$output_obj.lock" + else + output_obj= + need_locks=no + lockfile= + fi + + # Lock this critical section if it is needed + # We use this script file to make the link, it avoids creating a new file + if test "$need_locks" = yes; then + until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do + func_echo "Waiting for $lockfile to be removed" + sleep 2 + done + elif test "$need_locks" = warn; then + if test -f "$lockfile"; then + $ECHO "\ +*** ERROR, $lockfile exists and contains: +`cat $lockfile 2>/dev/null` + +This indicates that another process is trying to use the same +temporary object file, and libtool could not work around it because +your compiler does not support \`-c' and \`-o' together. If you +repeat this compilation, it may succeed, by chance, but you had better +avoid parallel builds (make -j) in this platform, or get a better +compiler." + + $opt_dry_run || $RM $removelist + exit $EXIT_FAILURE + fi + removelist+=" $output_obj" + $ECHO "$srcfile" > "$lockfile" + fi + + $opt_dry_run || $RM $removelist + removelist+=" $lockfile" + trap '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE' 1 2 15 + + func_to_tool_file "$srcfile" func_convert_file_msys_to_w32 + srcfile=$func_to_tool_file_result + func_quote_for_eval "$srcfile" + qsrcfile=$func_quote_for_eval_result + + # Only build a PIC object if we are building libtool libraries. + if test "$build_libtool_libs" = yes; then + # Without this assignment, base_compile gets emptied. + fbsd_hideous_sh_bug=$base_compile + + if test "$pic_mode" != no; then + command="$base_compile $qsrcfile $pic_flag" + else + # Don't build PIC code + command="$base_compile $qsrcfile" + fi + + func_mkdir_p "$xdir$objdir" + + if test -z "$output_obj"; then + # Place PIC objects in $objdir + command+=" -o $lobj" + fi + + func_show_eval_locale "$command" \ + 'test -n "$output_obj" && $RM $removelist; exit $EXIT_FAILURE' + + if test "$need_locks" = warn && + test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then + $ECHO "\ +*** ERROR, $lockfile contains: +`cat $lockfile 2>/dev/null` + +but it should contain: +$srcfile + +This indicates that another process is trying to use the same +temporary object file, and libtool could not work around it because +your compiler does not support \`-c' and \`-o' together. If you +repeat this compilation, it may succeed, by chance, but you had better +avoid parallel builds (make -j) in this platform, or get a better +compiler." + + $opt_dry_run || $RM $removelist + exit $EXIT_FAILURE + fi + + # Just move the object if needed, then go on to compile the next one + if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then + func_show_eval '$MV "$output_obj" "$lobj"' \ + 'error=$?; $opt_dry_run || $RM $removelist; exit $error' + fi + + # Allow error messages only from the first compilation. + if test "$suppress_opt" = yes; then + suppress_output=' >/dev/null 2>&1' + fi + fi + + # Only build a position-dependent object if we build old libraries. + if test "$build_old_libs" = yes; then + if test "$pic_mode" != yes; then + # Don't build PIC code + command="$base_compile $qsrcfile$pie_flag" + else + command="$base_compile $qsrcfile $pic_flag" + fi + if test "$compiler_c_o" = yes; then + command+=" -o $obj" + fi + + # Suppress compiler output if we already did a PIC compilation. + command+="$suppress_output" + func_show_eval_locale "$command" \ + '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE' + + if test "$need_locks" = warn && + test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then + $ECHO "\ +*** ERROR, $lockfile contains: +`cat $lockfile 2>/dev/null` + +but it should contain: +$srcfile + +This indicates that another process is trying to use the same +temporary object file, and libtool could not work around it because +your compiler does not support \`-c' and \`-o' together. If you +repeat this compilation, it may succeed, by chance, but you had better +avoid parallel builds (make -j) in this platform, or get a better +compiler." + + $opt_dry_run || $RM $removelist + exit $EXIT_FAILURE + fi + + # Just move the object if needed + if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then + func_show_eval '$MV "$output_obj" "$obj"' \ + 'error=$?; $opt_dry_run || $RM $removelist; exit $error' + fi + fi + + $opt_dry_run || { + func_write_libtool_object "$libobj" "$objdir/$objname" "$objname" + + # Unlock the critical section if it was locked + if test "$need_locks" != no; then + removelist=$lockfile + $RM "$lockfile" + fi + } + + exit $EXIT_SUCCESS +} + +$opt_help || { + test "$opt_mode" = compile && func_mode_compile ${1+"$@"} +} + +func_mode_help () +{ + # We need to display help for each of the modes. + case $opt_mode in + "") + # Generic help is extracted from the usage comments + # at the start of this file. + func_help + ;; + + clean) + $ECHO \ +"Usage: $progname [OPTION]... --mode=clean RM [RM-OPTION]... FILE... + +Remove files from the build directory. + +RM is the name of the program to use to delete files associated with each FILE +(typically \`/bin/rm'). RM-OPTIONS are options (such as \`-f') to be passed +to RM. + +If FILE is a libtool library, object or program, all the files associated +with it are deleted. Otherwise, only FILE itself is deleted using RM." + ;; + + compile) + $ECHO \ +"Usage: $progname [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE + +Compile a source file into a libtool library object. + +This mode accepts the following additional options: + + -o OUTPUT-FILE set the output file name to OUTPUT-FILE + -no-suppress do not suppress compiler output for multiple passes + -prefer-pic try to build PIC objects only + -prefer-non-pic try to build non-PIC objects only + -shared do not build a \`.o' file suitable for static linking + -static only build a \`.o' file suitable for static linking + -Wc,FLAG pass FLAG directly to the compiler + +COMPILE-COMMAND is a command to be used in creating a \`standard' object file +from the given SOURCEFILE. + +The output file name is determined by removing the directory component from +SOURCEFILE, then substituting the C source code suffix \`.c' with the +library object suffix, \`.lo'." + ;; + + execute) + $ECHO \ +"Usage: $progname [OPTION]... --mode=execute COMMAND [ARGS]... + +Automatically set library path, then run a program. + +This mode accepts the following additional options: + + -dlopen FILE add the directory containing FILE to the library path + +This mode sets the library path environment variable according to \`-dlopen' +flags. + +If any of the ARGS are libtool executable wrappers, then they are translated +into their corresponding uninstalled binary, and any of their required library +directories are added to the library path. + +Then, COMMAND is executed, with ARGS as arguments." + ;; + + finish) + $ECHO \ +"Usage: $progname [OPTION]... --mode=finish [LIBDIR]... + +Complete the installation of libtool libraries. + +Each LIBDIR is a directory that contains libtool libraries. + +The commands that this mode executes may require superuser privileges. Use +the \`--dry-run' option if you just want to see what would be executed." + ;; + + install) + $ECHO \ +"Usage: $progname [OPTION]... --mode=install INSTALL-COMMAND... + +Install executables or libraries. + +INSTALL-COMMAND is the installation command. The first component should be +either the \`install' or \`cp' program. + +The following components of INSTALL-COMMAND are treated specially: + + -inst-prefix-dir PREFIX-DIR Use PREFIX-DIR as a staging area for installation + +The rest of the components are interpreted as arguments to that command (only +BSD-compatible install options are recognized)." + ;; + + link) + $ECHO \ +"Usage: $progname [OPTION]... --mode=link LINK-COMMAND... + +Link object files or libraries together to form another library, or to +create an executable program. + +LINK-COMMAND is a command using the C compiler that you would use to create +a program from several object files. + +The following components of LINK-COMMAND are treated specially: + + -all-static do not do any dynamic linking at all + -avoid-version do not add a version suffix if possible + -bindir BINDIR specify path to binaries directory (for systems where + libraries must be found in the PATH setting at runtime) + -dlopen FILE \`-dlpreopen' FILE if it cannot be dlopened at runtime + -dlpreopen FILE link in FILE and add its symbols to lt_preloaded_symbols + -export-dynamic allow symbols from OUTPUT-FILE to be resolved with dlsym(3) + -export-symbols SYMFILE + try to export only the symbols listed in SYMFILE + -export-symbols-regex REGEX + try to export only the symbols matching REGEX + -LLIBDIR search LIBDIR for required installed libraries + -lNAME OUTPUT-FILE requires the installed library libNAME + -module build a library that can dlopened + -no-fast-install disable the fast-install mode + -no-install link a not-installable executable + -no-undefined declare that a library does not refer to external symbols + -o OUTPUT-FILE create OUTPUT-FILE from the specified objects + -objectlist FILE Use a list of object files found in FILE to specify objects + -precious-files-regex REGEX + don't remove output files matching REGEX + -release RELEASE specify package release information + -rpath LIBDIR the created library will eventually be installed in LIBDIR + -R[ ]LIBDIR add LIBDIR to the runtime path of programs and libraries + -shared only do dynamic linking of libtool libraries + -shrext SUFFIX override the standard shared library file extension + -static do not do any dynamic linking of uninstalled libtool libraries + -static-libtool-libs + do not do any dynamic linking of libtool libraries + -version-info CURRENT[:REVISION[:AGE]] + specify library version info [each variable defaults to 0] + -weak LIBNAME declare that the target provides the LIBNAME interface + -Wc,FLAG + -Xcompiler FLAG pass linker-specific FLAG directly to the compiler + -Wl,FLAG + -Xlinker FLAG pass linker-specific FLAG directly to the linker + -XCClinker FLAG pass link-specific FLAG to the compiler driver (CC) + +All other options (arguments beginning with \`-') are ignored. + +Every other argument is treated as a filename. Files ending in \`.la' are +treated as uninstalled libtool libraries, other files are standard or library +object files. + +If the OUTPUT-FILE ends in \`.la', then a libtool library is created, +only library objects (\`.lo' files) may be specified, and \`-rpath' is +required, except when creating a convenience library. + +If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created +using \`ar' and \`ranlib', or on Windows using \`lib'. + +If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file +is created, otherwise an executable program is created." + ;; + + uninstall) + $ECHO \ +"Usage: $progname [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE... + +Remove libraries from an installation directory. + +RM is the name of the program to use to delete files associated with each FILE +(typically \`/bin/rm'). RM-OPTIONS are options (such as \`-f') to be passed +to RM. + +If FILE is a libtool library, all the files associated with it are deleted. +Otherwise, only FILE itself is deleted using RM." + ;; + + *) + func_fatal_help "invalid operation mode \`$opt_mode'" + ;; + esac + + echo + $ECHO "Try \`$progname --help' for more information about other modes." +} + +# Now that we've collected a possible --mode arg, show help if necessary +if $opt_help; then + if test "$opt_help" = :; then + func_mode_help + else + { + func_help noexit + for opt_mode in compile link execute install finish uninstall clean; do + func_mode_help + done + } | sed -n '1p; 2,$s/^Usage:/ or: /p' + { + func_help noexit + for opt_mode in compile link execute install finish uninstall clean; do + echo + func_mode_help + done + } | + sed '1d + /^When reporting/,/^Report/{ + H + d + } + $x + /information about other modes/d + /more detailed .*MODE/d + s/^Usage:.*--mode=\([^ ]*\) .*/Description of \1 mode:/' + fi + exit $? +fi + + +# func_mode_execute arg... +func_mode_execute () +{ + $opt_debug + # The first argument is the command name. + cmd="$nonopt" + test -z "$cmd" && \ + func_fatal_help "you must specify a COMMAND" + + # Handle -dlopen flags immediately. + for file in $opt_dlopen; do + test -f "$file" \ + || func_fatal_help "\`$file' is not a file" + + dir= + case $file in + *.la) + func_resolve_sysroot "$file" + file=$func_resolve_sysroot_result + + # Check to see that this really is a libtool archive. + func_lalib_unsafe_p "$file" \ + || func_fatal_help "\`$lib' is not a valid libtool archive" + + # Read the libtool library. + dlname= + library_names= + func_source "$file" + + # Skip this library if it cannot be dlopened. + if test -z "$dlname"; then + # Warn if it was a shared library. + test -n "$library_names" && \ + func_warning "\`$file' was not linked with \`-export-dynamic'" + continue + fi + + func_dirname "$file" "" "." + dir="$func_dirname_result" + + if test -f "$dir/$objdir/$dlname"; then + dir+="/$objdir" + else + if test ! -f "$dir/$dlname"; then + func_fatal_error "cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'" + fi + fi + ;; + + *.lo) + # Just add the directory containing the .lo file. + func_dirname "$file" "" "." + dir="$func_dirname_result" + ;; + + *) + func_warning "\`-dlopen' is ignored for non-libtool libraries and objects" + continue + ;; + esac + + # Get the absolute pathname. + absdir=`cd "$dir" && pwd` + test -n "$absdir" && dir="$absdir" + + # Now add the directory to shlibpath_var. + if eval "test -z \"\$$shlibpath_var\""; then + eval "$shlibpath_var=\"\$dir\"" + else + eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\"" + fi + done + + # This variable tells wrapper scripts just to set shlibpath_var + # rather than running their programs. + libtool_execute_magic="$magic" + + # Check if any of the arguments is a wrapper script. + args= + for file + do + case $file in + -* | *.la | *.lo ) ;; + *) + # Do a test to see if this is really a libtool program. + if func_ltwrapper_script_p "$file"; then + func_source "$file" + # Transform arg to wrapped name. + file="$progdir/$program" + elif func_ltwrapper_executable_p "$file"; then + func_ltwrapper_scriptname "$file" + func_source "$func_ltwrapper_scriptname_result" + # Transform arg to wrapped name. + file="$progdir/$program" + fi + ;; + esac + # Quote arguments (to preserve shell metacharacters). + func_append_quoted args "$file" + done + + if test "X$opt_dry_run" = Xfalse; then + if test -n "$shlibpath_var"; then + # Export the shlibpath_var. + eval "export $shlibpath_var" + fi + + # Restore saved environment variables + for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES + do + eval "if test \"\${save_$lt_var+set}\" = set; then + $lt_var=\$save_$lt_var; export $lt_var + else + $lt_unset $lt_var + fi" + done + + # Now prepare to actually exec the command. + exec_cmd="\$cmd$args" + else + # Display what would be done. + if test -n "$shlibpath_var"; then + eval "\$ECHO \"\$shlibpath_var=\$$shlibpath_var\"" + echo "export $shlibpath_var" + fi + $ECHO "$cmd$args" + exit $EXIT_SUCCESS + fi +} + +test "$opt_mode" = execute && func_mode_execute ${1+"$@"} + + +# func_mode_finish arg... +func_mode_finish () +{ + $opt_debug + libs= + libdirs= + admincmds= + + for opt in "$nonopt" ${1+"$@"} + do + if test -d "$opt"; then + libdirs+=" $opt" + + elif test -f "$opt"; then + if func_lalib_unsafe_p "$opt"; then + libs+=" $opt" + else + func_warning "\`$opt' is not a valid libtool archive" + fi + + else + func_fatal_error "invalid argument \`$opt'" + fi + done + + if test -n "$libs"; then + if test -n "$lt_sysroot"; then + sysroot_regex=`$ECHO "$lt_sysroot" | $SED "$sed_make_literal_regex"` + sysroot_cmd="s/\([ ']\)$sysroot_regex/\1/g;" + else + sysroot_cmd= + fi + + # Remove sysroot references + if $opt_dry_run; then + for lib in $libs; do + echo "removing references to $lt_sysroot and \`=' prefixes from $lib" + done + else + tmpdir=`func_mktempdir` + for lib in $libs; do + sed -e "${sysroot_cmd} s/\([ ']-[LR]\)=/\1/g; s/\([ ']\)=/\1/g" $lib \ + > $tmpdir/tmp-la + mv -f $tmpdir/tmp-la $lib + done + ${RM}r "$tmpdir" + fi + fi + + if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then + for libdir in $libdirs; do + if test -n "$finish_cmds"; then + # Do each command in the finish commands. + func_execute_cmds "$finish_cmds" 'admincmds="$admincmds +'"$cmd"'"' + fi + if test -n "$finish_eval"; then + # Do the single finish_eval. + eval cmds=\"$finish_eval\" + $opt_dry_run || eval "$cmds" || admincmds+=" + $cmds" + fi + done + fi + + # Exit here if they wanted silent mode. + $opt_silent && exit $EXIT_SUCCESS + + if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then + echo "----------------------------------------------------------------------" + echo "Libraries have been installed in:" + for libdir in $libdirs; do + $ECHO " $libdir" + done + echo + echo "If you ever happen to want to link against installed libraries" + echo "in a given directory, LIBDIR, you must either use libtool, and" + echo "specify the full pathname of the library, or use the \`-LLIBDIR'" + echo "flag during linking and do at least one of the following:" + if test -n "$shlibpath_var"; then + echo " - add LIBDIR to the \`$shlibpath_var' environment variable" + echo " during execution" + fi + if test -n "$runpath_var"; then + echo " - add LIBDIR to the \`$runpath_var' environment variable" + echo " during linking" + fi + if test -n "$hardcode_libdir_flag_spec"; then + libdir=LIBDIR + eval flag=\"$hardcode_libdir_flag_spec\" + + $ECHO " - use the \`$flag' linker flag" + fi + if test -n "$admincmds"; then + $ECHO " - have your system administrator run these commands:$admincmds" + fi + if test -f /etc/ld.so.conf; then + echo " - have your system administrator add LIBDIR to \`/etc/ld.so.conf'" + fi + echo + + echo "See any operating system documentation about shared libraries for" + case $host in + solaris2.[6789]|solaris2.1[0-9]) + echo "more information, such as the ld(1), crle(1) and ld.so(8) manual" + echo "pages." + ;; + *) + echo "more information, such as the ld(1) and ld.so(8) manual pages." + ;; + esac + echo "----------------------------------------------------------------------" + fi + exit $EXIT_SUCCESS +} + +test "$opt_mode" = finish && func_mode_finish ${1+"$@"} + + +# func_mode_install arg... +func_mode_install () +{ + $opt_debug + # There may be an optional sh(1) argument at the beginning of + # install_prog (especially on Windows NT). + if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh || + # Allow the use of GNU shtool's install command. + case $nonopt in *shtool*) :;; *) false;; esac; then + # Aesthetically quote it. + func_quote_for_eval "$nonopt" + install_prog="$func_quote_for_eval_result " + arg=$1 + shift + else + install_prog= + arg=$nonopt + fi + + # The real first argument should be the name of the installation program. + # Aesthetically quote it. + func_quote_for_eval "$arg" + install_prog+="$func_quote_for_eval_result" + install_shared_prog=$install_prog + case " $install_prog " in + *[\\\ /]cp\ *) install_cp=: ;; + *) install_cp=false ;; + esac + + # We need to accept at least all the BSD install flags. + dest= + files= + opts= + prev= + install_type= + isdir=no + stripme= + no_mode=: + for arg + do + arg2= + if test -n "$dest"; then + files+=" $dest" + dest=$arg + continue + fi + + case $arg in + -d) isdir=yes ;; + -f) + if $install_cp; then :; else + prev=$arg + fi + ;; + -g | -m | -o) + prev=$arg + ;; + -s) + stripme=" -s" + continue + ;; + -*) + ;; + *) + # If the previous option needed an argument, then skip it. + if test -n "$prev"; then + if test "x$prev" = x-m && test -n "$install_override_mode"; then + arg2=$install_override_mode + no_mode=false + fi + prev= + else + dest=$arg + continue + fi + ;; + esac + + # Aesthetically quote the argument. + func_quote_for_eval "$arg" + install_prog+=" $func_quote_for_eval_result" + if test -n "$arg2"; then + func_quote_for_eval "$arg2" + fi + install_shared_prog+=" $func_quote_for_eval_result" + done + + test -z "$install_prog" && \ + func_fatal_help "you must specify an install program" + + test -n "$prev" && \ + func_fatal_help "the \`$prev' option requires an argument" + + if test -n "$install_override_mode" && $no_mode; then + if $install_cp; then :; else + func_quote_for_eval "$install_override_mode" + install_shared_prog+=" -m $func_quote_for_eval_result" + fi + fi + + if test -z "$files"; then + if test -z "$dest"; then + func_fatal_help "no file or destination specified" + else + func_fatal_help "you must specify a destination" + fi + fi + + # Strip any trailing slash from the destination. + func_stripname '' '/' "$dest" + dest=$func_stripname_result + + # Check to see that the destination is a directory. + test -d "$dest" && isdir=yes + if test "$isdir" = yes; then + destdir="$dest" + destname= + else + func_dirname_and_basename "$dest" "" "." + destdir="$func_dirname_result" + destname="$func_basename_result" + + # Not a directory, so check to see that there is only one file specified. + set dummy $files; shift + test "$#" -gt 1 && \ + func_fatal_help "\`$dest' is not a directory" + fi + case $destdir in + [\\/]* | [A-Za-z]:[\\/]*) ;; + *) + for file in $files; do + case $file in + *.lo) ;; + *) + func_fatal_help "\`$destdir' must be an absolute directory name" + ;; + esac + done + ;; + esac + + # This variable tells wrapper scripts just to set variables rather + # than running their programs. + libtool_install_magic="$magic" + + staticlibs= + future_libdirs= + current_libdirs= + for file in $files; do + + # Do each installation. + case $file in + *.$libext) + # Do the static libraries later. + staticlibs+=" $file" + ;; + + *.la) + func_resolve_sysroot "$file" + file=$func_resolve_sysroot_result + + # Check to see that this really is a libtool archive. + func_lalib_unsafe_p "$file" \ + || func_fatal_help "\`$file' is not a valid libtool archive" + + library_names= + old_library= + relink_command= + func_source "$file" + + # Add the libdir to current_libdirs if it is the destination. + if test "X$destdir" = "X$libdir"; then + case "$current_libdirs " in + *" $libdir "*) ;; + *) current_libdirs+=" $libdir" ;; + esac + else + # Note the libdir as a future libdir. + case "$future_libdirs " in + *" $libdir "*) ;; + *) future_libdirs+=" $libdir" ;; + esac + fi + + func_dirname "$file" "/" "" + dir="$func_dirname_result" + dir+="$objdir" + + if test -n "$relink_command"; then + # Determine the prefix the user has applied to our future dir. + inst_prefix_dir=`$ECHO "$destdir" | $SED -e "s%$libdir\$%%"` + + # Don't allow the user to place us outside of our expected + # location b/c this prevents finding dependent libraries that + # are installed to the same prefix. + # At present, this check doesn't affect windows .dll's that + # are installed into $libdir/../bin (currently, that works fine) + # but it's something to keep an eye on. + test "$inst_prefix_dir" = "$destdir" && \ + func_fatal_error "error: cannot install \`$file' to a directory not ending in $libdir" + + if test -n "$inst_prefix_dir"; then + # Stick the inst_prefix_dir data into the link command. + relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"` + else + relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%%"` + fi + + func_warning "relinking \`$file'" + func_show_eval "$relink_command" \ + 'func_fatal_error "error: relink \`$file'\'' with the above command before installing it"' + fi + + # See the names of the shared library. + set dummy $library_names; shift + if test -n "$1"; then + realname="$1" + shift + + srcname="$realname" + test -n "$relink_command" && srcname="$realname"T + + # Install the shared library and build the symlinks. + func_show_eval "$install_shared_prog $dir/$srcname $destdir/$realname" \ + 'exit $?' + tstripme="$stripme" + case $host_os in + cygwin* | mingw* | pw32* | cegcc*) + case $realname in + *.dll.a) + tstripme="" + ;; + esac + ;; + esac + if test -n "$tstripme" && test -n "$striplib"; then + func_show_eval "$striplib $destdir/$realname" 'exit $?' + fi + + if test "$#" -gt 0; then + # Delete the old symlinks, and create new ones. + # Try `ln -sf' first, because the `ln' binary might depend on + # the symlink we replace! Solaris /bin/ln does not understand -f, + # so we also need to try rm && ln -s. + for linkname + do + test "$linkname" != "$realname" \ + && func_show_eval "(cd $destdir && { $LN_S -f $realname $linkname || { $RM $linkname && $LN_S $realname $linkname; }; })" + done + fi + + # Do each command in the postinstall commands. + lib="$destdir/$realname" + func_execute_cmds "$postinstall_cmds" 'exit $?' + fi + + # Install the pseudo-library for information purposes. + func_basename "$file" + name="$func_basename_result" + instname="$dir/$name"i + func_show_eval "$install_prog $instname $destdir/$name" 'exit $?' + + # Maybe install the static library, too. + test -n "$old_library" && staticlibs+=" $dir/$old_library" + ;; + + *.lo) + # Install (i.e. copy) a libtool object. + + # Figure out destination file name, if it wasn't already specified. + if test -n "$destname"; then + destfile="$destdir/$destname" + else + func_basename "$file" + destfile="$func_basename_result" + destfile="$destdir/$destfile" + fi + + # Deduce the name of the destination old-style object file. + case $destfile in + *.lo) + func_lo2o "$destfile" + staticdest=$func_lo2o_result + ;; + *.$objext) + staticdest="$destfile" + destfile= + ;; + *) + func_fatal_help "cannot copy a libtool object to \`$destfile'" + ;; + esac + + # Install the libtool object if requested. + test -n "$destfile" && \ + func_show_eval "$install_prog $file $destfile" 'exit $?' + + # Install the old object if enabled. + if test "$build_old_libs" = yes; then + # Deduce the name of the old-style object file. + func_lo2o "$file" + staticobj=$func_lo2o_result + func_show_eval "$install_prog \$staticobj \$staticdest" 'exit $?' + fi + exit $EXIT_SUCCESS + ;; + + *) + # Figure out destination file name, if it wasn't already specified. + if test -n "$destname"; then + destfile="$destdir/$destname" + else + func_basename "$file" + destfile="$func_basename_result" + destfile="$destdir/$destfile" + fi + + # If the file is missing, and there is a .exe on the end, strip it + # because it is most likely a libtool script we actually want to + # install + stripped_ext="" + case $file in + *.exe) + if test ! -f "$file"; then + func_stripname '' '.exe' "$file" + file=$func_stripname_result + stripped_ext=".exe" + fi + ;; + esac + + # Do a test to see if this is really a libtool program. + case $host in + *cygwin* | *mingw*) + if func_ltwrapper_executable_p "$file"; then + func_ltwrapper_scriptname "$file" + wrapper=$func_ltwrapper_scriptname_result + else + func_stripname '' '.exe' "$file" + wrapper=$func_stripname_result + fi + ;; + *) + wrapper=$file + ;; + esac + if func_ltwrapper_script_p "$wrapper"; then + notinst_deplibs= + relink_command= + + func_source "$wrapper" + + # Check the variables that should have been set. + test -z "$generated_by_libtool_version" && \ + func_fatal_error "invalid libtool wrapper script \`$wrapper'" + + finalize=yes + for lib in $notinst_deplibs; do + # Check to see that each library is installed. + libdir= + if test -f "$lib"; then + func_source "$lib" + fi + libfile="$libdir/"`$ECHO "$lib" | $SED 's%^.*/%%g'` ### testsuite: skip nested quoting test + if test -n "$libdir" && test ! -f "$libfile"; then + func_warning "\`$lib' has not been installed in \`$libdir'" + finalize=no + fi + done + + relink_command= + func_source "$wrapper" + + outputname= + if test "$fast_install" = no && test -n "$relink_command"; then + $opt_dry_run || { + if test "$finalize" = yes; then + tmpdir=`func_mktempdir` + func_basename "$file$stripped_ext" + file="$func_basename_result" + outputname="$tmpdir/$file" + # Replace the output file specification. + relink_command=`$ECHO "$relink_command" | $SED 's%@OUTPUT@%'"$outputname"'%g'` + + $opt_silent || { + func_quote_for_expand "$relink_command" + eval "func_echo $func_quote_for_expand_result" + } + if eval "$relink_command"; then : + else + func_error "error: relink \`$file' with the above command before installing it" + $opt_dry_run || ${RM}r "$tmpdir" + continue + fi + file="$outputname" + else + func_warning "cannot relink \`$file'" + fi + } + else + # Install the binary that we compiled earlier. + file=`$ECHO "$file$stripped_ext" | $SED "s%\([^/]*\)$%$objdir/\1%"` + fi + fi + + # remove .exe since cygwin /usr/bin/install will append another + # one anyway + case $install_prog,$host in + */usr/bin/install*,*cygwin*) + case $file:$destfile in + *.exe:*.exe) + # this is ok + ;; + *.exe:*) + destfile=$destfile.exe + ;; + *:*.exe) + func_stripname '' '.exe' "$destfile" + destfile=$func_stripname_result + ;; + esac + ;; + esac + func_show_eval "$install_prog\$stripme \$file \$destfile" 'exit $?' + $opt_dry_run || if test -n "$outputname"; then + ${RM}r "$tmpdir" + fi + ;; + esac + done + + for file in $staticlibs; do + func_basename "$file" + name="$func_basename_result" + + # Set up the ranlib parameters. + oldlib="$destdir/$name" + func_to_tool_file "$oldlib" func_convert_file_msys_to_w32 + tool_oldlib=$func_to_tool_file_result + + func_show_eval "$install_prog \$file \$oldlib" 'exit $?' + + if test -n "$stripme" && test -n "$old_striplib"; then + func_show_eval "$old_striplib $tool_oldlib" 'exit $?' + fi + + # Do each command in the postinstall commands. + func_execute_cmds "$old_postinstall_cmds" 'exit $?' + done + + test -n "$future_libdirs" && \ + func_warning "remember to run \`$progname --finish$future_libdirs'" + + if test -n "$current_libdirs"; then + # Maybe just do a dry run. + $opt_dry_run && current_libdirs=" -n$current_libdirs" + exec_cmd='$SHELL $progpath $preserve_args --finish$current_libdirs' + else + exit $EXIT_SUCCESS + fi +} + +test "$opt_mode" = install && func_mode_install ${1+"$@"} + + +# func_generate_dlsyms outputname originator pic_p +# Extract symbols from dlprefiles and create ${outputname}S.o with +# a dlpreopen symbol table. +func_generate_dlsyms () +{ + $opt_debug + my_outputname="$1" + my_originator="$2" + my_pic_p="${3-no}" + my_prefix=`$ECHO "$my_originator" | sed 's%[^a-zA-Z0-9]%_%g'` + my_dlsyms= + + if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then + if test -n "$NM" && test -n "$global_symbol_pipe"; then + my_dlsyms="${my_outputname}S.c" + else + func_error "not configured to extract global symbols from dlpreopened files" + fi + fi + + if test -n "$my_dlsyms"; then + case $my_dlsyms in + "") ;; + *.c) + # Discover the nlist of each of the dlfiles. + nlist="$output_objdir/${my_outputname}.nm" + + func_show_eval "$RM $nlist ${nlist}S ${nlist}T" + + # Parse the name list into a source file. + func_verbose "creating $output_objdir/$my_dlsyms" + + $opt_dry_run || $ECHO > "$output_objdir/$my_dlsyms" "\ +/* $my_dlsyms - symbol resolution table for \`$my_outputname' dlsym emulation. */ +/* Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION */ + +#ifdef __cplusplus +extern \"C\" { +#endif + +#if defined(__GNUC__) && (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 4)) || (__GNUC__ > 4)) +#pragma GCC diagnostic ignored \"-Wstrict-prototypes\" +#endif + +/* Keep this code in sync between libtool.m4, ltmain, lt_system.h, and tests. */ +#if defined(_WIN32) || defined(__CYGWIN__) || defined(_WIN32_WCE) +/* DATA imports from DLLs on WIN32 con't be const, because runtime + relocations are performed -- see ld's documentation on pseudo-relocs. */ +# define LT_DLSYM_CONST +#elif defined(__osf__) +/* This system does not cope well with relocations in const data. */ +# define LT_DLSYM_CONST +#else +# define LT_DLSYM_CONST const +#endif + +/* External symbol declarations for the compiler. */\ +" + + if test "$dlself" = yes; then + func_verbose "generating symbol list for \`$output'" + + $opt_dry_run || echo ': @PROGRAM@ ' > "$nlist" + + # Add our own program objects to the symbol list. + progfiles=`$ECHO "$objs$old_deplibs" | $SP2NL | $SED "$lo2o" | $NL2SP` + for progfile in $progfiles; do + func_to_tool_file "$progfile" func_convert_file_msys_to_w32 + func_verbose "extracting global C symbols from \`$func_to_tool_file_result'" + $opt_dry_run || eval "$NM $func_to_tool_file_result | $global_symbol_pipe >> '$nlist'" + done + + if test -n "$exclude_expsyms"; then + $opt_dry_run || { + eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T' + eval '$MV "$nlist"T "$nlist"' + } + fi + + if test -n "$export_symbols_regex"; then + $opt_dry_run || { + eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T' + eval '$MV "$nlist"T "$nlist"' + } + fi + + # Prepare the list of exported symbols + if test -z "$export_symbols"; then + export_symbols="$output_objdir/$outputname.exp" + $opt_dry_run || { + $RM $export_symbols + eval "${SED} -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"' + case $host in + *cygwin* | *mingw* | *cegcc* ) + eval "echo EXPORTS "'> "$output_objdir/$outputname.def"' + eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"' + ;; + esac + } + else + $opt_dry_run || { + eval "${SED} -e 's/\([].[*^$]\)/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"' + eval '$GREP -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T' + eval '$MV "$nlist"T "$nlist"' + case $host in + *cygwin* | *mingw* | *cegcc* ) + eval "echo EXPORTS "'> "$output_objdir/$outputname.def"' + eval 'cat "$nlist" >> "$output_objdir/$outputname.def"' + ;; + esac + } + fi + fi + + for dlprefile in $dlprefiles; do + func_verbose "extracting global C symbols from \`$dlprefile'" + func_basename "$dlprefile" + name="$func_basename_result" + case $host in + *cygwin* | *mingw* | *cegcc* ) + # if an import library, we need to obtain dlname + if func_win32_import_lib_p "$dlprefile"; then + func_tr_sh "$dlprefile" + eval "curr_lafile=\$libfile_$func_tr_sh_result" + dlprefile_dlbasename="" + if test -n "$curr_lafile" && func_lalib_p "$curr_lafile"; then + # Use subshell, to avoid clobbering current variable values + dlprefile_dlname=`source "$curr_lafile" && echo "$dlname"` + if test -n "$dlprefile_dlname" ; then + func_basename "$dlprefile_dlname" + dlprefile_dlbasename="$func_basename_result" + else + # no lafile. user explicitly requested -dlpreopen . + $sharedlib_from_linklib_cmd "$dlprefile" + dlprefile_dlbasename=$sharedlib_from_linklib_result + fi + fi + $opt_dry_run || { + if test -n "$dlprefile_dlbasename" ; then + eval '$ECHO ": $dlprefile_dlbasename" >> "$nlist"' + else + func_warning "Could not compute DLL name from $name" + eval '$ECHO ": $name " >> "$nlist"' + fi + func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32 + eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe | + $SED -e '/I __imp/d' -e 's/I __nm_/D /;s/_nm__//' >> '$nlist'" + } + else # not an import lib + $opt_dry_run || { + eval '$ECHO ": $name " >> "$nlist"' + func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32 + eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'" + } + fi + ;; + *) + $opt_dry_run || { + eval '$ECHO ": $name " >> "$nlist"' + func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32 + eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'" + } + ;; + esac + done + + $opt_dry_run || { + # Make sure we have at least an empty file. + test -f "$nlist" || : > "$nlist" + + if test -n "$exclude_expsyms"; then + $EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T + $MV "$nlist"T "$nlist" + fi + + # Try sorting and uniquifying the output. + if $GREP -v "^: " < "$nlist" | + if sort -k 3 /dev/null 2>&1; then + sort -k 3 + else + sort +2 + fi | + uniq > "$nlist"S; then + : + else + $GREP -v "^: " < "$nlist" > "$nlist"S + fi + + if test -f "$nlist"S; then + eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$my_dlsyms"' + else + echo '/* NONE */' >> "$output_objdir/$my_dlsyms" + fi + + echo >> "$output_objdir/$my_dlsyms" "\ + +/* The mapping between symbol names and symbols. */ +typedef struct { + const char *name; + void *address; +} lt_dlsymlist; +extern LT_DLSYM_CONST lt_dlsymlist +lt_${my_prefix}_LTX_preloaded_symbols[]; +LT_DLSYM_CONST lt_dlsymlist +lt_${my_prefix}_LTX_preloaded_symbols[] = +{\ + { \"$my_originator\", (void *) 0 }," + + case $need_lib_prefix in + no) + eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$my_dlsyms" + ;; + *) + eval "$global_symbol_to_c_name_address_lib_prefix" < "$nlist" >> "$output_objdir/$my_dlsyms" + ;; + esac + echo >> "$output_objdir/$my_dlsyms" "\ + {0, (void *) 0} +}; + +/* This works around a problem in FreeBSD linker */ +#ifdef FREEBSD_WORKAROUND +static const void *lt_preloaded_setup() { + return lt_${my_prefix}_LTX_preloaded_symbols; +} +#endif + +#ifdef __cplusplus +} +#endif\ +" + } # !$opt_dry_run + + pic_flag_for_symtable= + case "$compile_command " in + *" -static "*) ;; + *) + case $host in + # compiling the symbol table file with pic_flag works around + # a FreeBSD bug that causes programs to crash when -lm is + # linked before any other PIC object. But we must not use + # pic_flag when linking with -static. The problem exists in + # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1. + *-*-freebsd2.*|*-*-freebsd3.0*|*-*-freebsdelf3.0*) + pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND" ;; + *-*-hpux*) + pic_flag_for_symtable=" $pic_flag" ;; + *) + if test "X$my_pic_p" != Xno; then + pic_flag_for_symtable=" $pic_flag" + fi + ;; + esac + ;; + esac + symtab_cflags= + for arg in $LTCFLAGS; do + case $arg in + -pie | -fpie | -fPIE) ;; + *) symtab_cflags+=" $arg" ;; + esac + done + + # Now compile the dynamic symbol file. + func_show_eval '(cd $output_objdir && $LTCC$symtab_cflags -c$no_builtin_flag$pic_flag_for_symtable "$my_dlsyms")' 'exit $?' + + # Clean up the generated files. + func_show_eval '$RM "$output_objdir/$my_dlsyms" "$nlist" "${nlist}S" "${nlist}T"' + + # Transform the symbol file into the correct name. + symfileobj="$output_objdir/${my_outputname}S.$objext" + case $host in + *cygwin* | *mingw* | *cegcc* ) + if test -f "$output_objdir/$my_outputname.def"; then + compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"` + finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"` + else + compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"` + finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"` + fi + ;; + *) + compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"` + finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"` + ;; + esac + ;; + *) + func_fatal_error "unknown suffix for \`$my_dlsyms'" + ;; + esac + else + # We keep going just in case the user didn't refer to + # lt_preloaded_symbols. The linker will fail if global_symbol_pipe + # really was required. + + # Nullify the symbol file. + compile_command=`$ECHO "$compile_command" | $SED "s% @SYMFILE@%%"` + finalize_command=`$ECHO "$finalize_command" | $SED "s% @SYMFILE@%%"` + fi +} + +# func_win32_libid arg +# return the library type of file 'arg' +# +# Need a lot of goo to handle *both* DLLs and import libs +# Has to be a shell function in order to 'eat' the argument +# that is supplied when $file_magic_command is called. +# Despite the name, also deal with 64 bit binaries. +func_win32_libid () +{ + $opt_debug + win32_libid_type="unknown" + win32_fileres=`file -L $1 2>/dev/null` + case $win32_fileres in + *ar\ archive\ import\ library*) # definitely import + win32_libid_type="x86 archive import" + ;; + *ar\ archive*) # could be an import, or static + # Keep the egrep pattern in sync with the one in _LT_CHECK_MAGIC_METHOD. + if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null | + $EGREP 'file format (pei*-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)' >/dev/null; then + func_to_tool_file "$1" func_convert_file_msys_to_w32 + win32_nmres=`eval $NM -f posix -A \"$func_to_tool_file_result\" | + $SED -n -e ' + 1,100{ + / I /{ + s,.*,import, + p + q + } + }'` + case $win32_nmres in + import*) win32_libid_type="x86 archive import";; + *) win32_libid_type="x86 archive static";; + esac + fi + ;; + *DLL*) + win32_libid_type="x86 DLL" + ;; + *executable*) # but shell scripts are "executable" too... + case $win32_fileres in + *MS\ Windows\ PE\ Intel*) + win32_libid_type="x86 DLL" + ;; + esac + ;; + esac + $ECHO "$win32_libid_type" +} + +# func_cygming_dll_for_implib ARG +# +# Platform-specific function to extract the +# name of the DLL associated with the specified +# import library ARG. +# Invoked by eval'ing the libtool variable +# $sharedlib_from_linklib_cmd +# Result is available in the variable +# $sharedlib_from_linklib_result +func_cygming_dll_for_implib () +{ + $opt_debug + sharedlib_from_linklib_result=`$DLLTOOL --identify-strict --identify "$1"` +} + +# func_cygming_dll_for_implib_fallback_core SECTION_NAME LIBNAMEs +# +# The is the core of a fallback implementation of a +# platform-specific function to extract the name of the +# DLL associated with the specified import library LIBNAME. +# +# SECTION_NAME is either .idata$6 or .idata$7, depending +# on the platform and compiler that created the implib. +# +# Echos the name of the DLL associated with the +# specified import library. +func_cygming_dll_for_implib_fallback_core () +{ + $opt_debug + match_literal=`$ECHO "$1" | $SED "$sed_make_literal_regex"` + $OBJDUMP -s --section "$1" "$2" 2>/dev/null | + $SED '/^Contents of section '"$match_literal"':/{ + # Place marker at beginning of archive member dllname section + s/.*/====MARK====/ + p + d + } + # These lines can sometimes be longer than 43 characters, but + # are always uninteresting + /:[ ]*file format pe[i]\{,1\}-/d + /^In archive [^:]*:/d + # Ensure marker is printed + /^====MARK====/p + # Remove all lines with less than 43 characters + /^.\{43\}/!d + # From remaining lines, remove first 43 characters + s/^.\{43\}//' | + $SED -n ' + # Join marker and all lines until next marker into a single line + /^====MARK====/ b para + H + $ b para + b + :para + x + s/\n//g + # Remove the marker + s/^====MARK====// + # Remove trailing dots and whitespace + s/[\. \t]*$// + # Print + /./p' | + # we now have a list, one entry per line, of the stringified + # contents of the appropriate section of all members of the + # archive which possess that section. Heuristic: eliminate + # all those which have a first or second character that is + # a '.' (that is, objdump's representation of an unprintable + # character.) This should work for all archives with less than + # 0x302f exports -- but will fail for DLLs whose name actually + # begins with a literal '.' or a single character followed by + # a '.'. + # + # Of those that remain, print the first one. + $SED -e '/^\./d;/^.\./d;q' +} + +# func_cygming_gnu_implib_p ARG +# This predicate returns with zero status (TRUE) if +# ARG is a GNU/binutils-style import library. Returns +# with nonzero status (FALSE) otherwise. +func_cygming_gnu_implib_p () +{ + $opt_debug + func_to_tool_file "$1" func_convert_file_msys_to_w32 + func_cygming_gnu_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $EGREP ' (_head_[A-Za-z0-9_]+_[ad]l*|[A-Za-z0-9_]+_[ad]l*_iname)$'` + test -n "$func_cygming_gnu_implib_tmp" +} + +# func_cygming_ms_implib_p ARG +# This predicate returns with zero status (TRUE) if +# ARG is an MS-style import library. Returns +# with nonzero status (FALSE) otherwise. +func_cygming_ms_implib_p () +{ + $opt_debug + func_to_tool_file "$1" func_convert_file_msys_to_w32 + func_cygming_ms_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $GREP '_NULL_IMPORT_DESCRIPTOR'` + test -n "$func_cygming_ms_implib_tmp" +} + +# func_cygming_dll_for_implib_fallback ARG +# Platform-specific function to extract the +# name of the DLL associated with the specified +# import library ARG. +# +# This fallback implementation is for use when $DLLTOOL +# does not support the --identify-strict option. +# Invoked by eval'ing the libtool variable +# $sharedlib_from_linklib_cmd +# Result is available in the variable +# $sharedlib_from_linklib_result +func_cygming_dll_for_implib_fallback () +{ + $opt_debug + if func_cygming_gnu_implib_p "$1" ; then + # binutils import library + sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$7' "$1"` + elif func_cygming_ms_implib_p "$1" ; then + # ms-generated import library + sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$6' "$1"` + else + # unknown + sharedlib_from_linklib_result="" + fi +} + + +# func_extract_an_archive dir oldlib +func_extract_an_archive () +{ + $opt_debug + f_ex_an_ar_dir="$1"; shift + f_ex_an_ar_oldlib="$1" + if test "$lock_old_archive_extraction" = yes; then + lockfile=$f_ex_an_ar_oldlib.lock + until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do + func_echo "Waiting for $lockfile to be removed" + sleep 2 + done + fi + func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" \ + 'stat=$?; rm -f "$lockfile"; exit $stat' + if test "$lock_old_archive_extraction" = yes; then + $opt_dry_run || rm -f "$lockfile" + fi + if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then + : + else + func_fatal_error "object name conflicts in archive: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib" + fi +} + + +# func_extract_archives gentop oldlib ... +func_extract_archives () +{ + $opt_debug + my_gentop="$1"; shift + my_oldlibs=${1+"$@"} + my_oldobjs="" + my_xlib="" + my_xabs="" + my_xdir="" + + for my_xlib in $my_oldlibs; do + # Extract the objects. + case $my_xlib in + [\\/]* | [A-Za-z]:[\\/]*) my_xabs="$my_xlib" ;; + *) my_xabs=`pwd`"/$my_xlib" ;; + esac + func_basename "$my_xlib" + my_xlib="$func_basename_result" + my_xlib_u=$my_xlib + while :; do + case " $extracted_archives " in + *" $my_xlib_u "*) + func_arith $extracted_serial + 1 + extracted_serial=$func_arith_result + my_xlib_u=lt$extracted_serial-$my_xlib ;; + *) break ;; + esac + done + extracted_archives="$extracted_archives $my_xlib_u" + my_xdir="$my_gentop/$my_xlib_u" + + func_mkdir_p "$my_xdir" + + case $host in + *-darwin*) + func_verbose "Extracting $my_xabs" + # Do not bother doing anything if just a dry run + $opt_dry_run || { + darwin_orig_dir=`pwd` + cd $my_xdir || exit $? + darwin_archive=$my_xabs + darwin_curdir=`pwd` + darwin_base_archive=`basename "$darwin_archive"` + darwin_arches=`$LIPO -info "$darwin_archive" 2>/dev/null | $GREP Architectures 2>/dev/null || true` + if test -n "$darwin_arches"; then + darwin_arches=`$ECHO "$darwin_arches" | $SED -e 's/.*are://'` + darwin_arch= + func_verbose "$darwin_base_archive has multiple architectures $darwin_arches" + for darwin_arch in $darwin_arches ; do + func_mkdir_p "unfat-$$/${darwin_base_archive}-${darwin_arch}" + $LIPO -thin $darwin_arch -output "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" "${darwin_archive}" + cd "unfat-$$/${darwin_base_archive}-${darwin_arch}" + func_extract_an_archive "`pwd`" "${darwin_base_archive}" + cd "$darwin_curdir" + $RM "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" + done # $darwin_arches + ## Okay now we've a bunch of thin objects, gotta fatten them up :) + darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print | $SED -e "$basename" | sort -u` + darwin_file= + darwin_files= + for darwin_file in $darwin_filelist; do + darwin_files=`find unfat-$$ -name $darwin_file -print | sort | $NL2SP` + $LIPO -create -output "$darwin_file" $darwin_files + done # $darwin_filelist + $RM -rf unfat-$$ + cd "$darwin_orig_dir" + else + cd $darwin_orig_dir + func_extract_an_archive "$my_xdir" "$my_xabs" + fi # $darwin_arches + } # !$opt_dry_run + ;; + *) + func_extract_an_archive "$my_xdir" "$my_xabs" + ;; + esac + my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | sort | $NL2SP` + done + + func_extract_archives_result="$my_oldobjs" +} + + +# func_emit_wrapper [arg=no] +# +# Emit a libtool wrapper script on stdout. +# Don't directly open a file because we may want to +# incorporate the script contents within a cygwin/mingw +# wrapper executable. Must ONLY be called from within +# func_mode_link because it depends on a number of variables +# set therein. +# +# ARG is the value that the WRAPPER_SCRIPT_BELONGS_IN_OBJDIR +# variable will take. If 'yes', then the emitted script +# will assume that the directory in which it is stored is +# the $objdir directory. This is a cygwin/mingw-specific +# behavior. +func_emit_wrapper () +{ + func_emit_wrapper_arg1=${1-no} + + $ECHO "\ +#! $SHELL + +# $output - temporary wrapper script for $objdir/$outputname +# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION +# +# The $output program cannot be directly executed until all the libtool +# libraries that it depends on are installed. +# +# This wrapper script should never be moved out of the build directory. +# If it is, it will not operate correctly. + +# Sed substitution that helps us do robust quoting. It backslashifies +# metacharacters that are still active within double-quoted strings. +sed_quote_subst='$sed_quote_subst' + +# Be Bourne compatible +if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then + emulate sh + NULLCMD=: + # Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which + # is contrary to our usage. Disable this feature. + alias -g '\${1+\"\$@\"}'='\"\$@\"' + setopt NO_GLOB_SUBST +else + case \`(set -o) 2>/dev/null\` in *posix*) set -o posix;; esac +fi +BIN_SH=xpg4; export BIN_SH # for Tru64 +DUALCASE=1; export DUALCASE # for MKS sh + +# The HP-UX ksh and POSIX shell print the target directory to stdout +# if CDPATH is set. +(unset CDPATH) >/dev/null 2>&1 && unset CDPATH + +relink_command=\"$relink_command\" + +# This environment variable determines our operation mode. +if test \"\$libtool_install_magic\" = \"$magic\"; then + # install mode needs the following variables: + generated_by_libtool_version='$macro_version' + notinst_deplibs='$notinst_deplibs' +else + # When we are sourced in execute mode, \$file and \$ECHO are already set. + if test \"\$libtool_execute_magic\" != \"$magic\"; then + file=\"\$0\"" + + qECHO=`$ECHO "$ECHO" | $SED "$sed_quote_subst"` + $ECHO "\ + +# A function that is used when there is no print builtin or printf. +func_fallback_echo () +{ + eval 'cat <<_LTECHO_EOF +\$1 +_LTECHO_EOF' +} + ECHO=\"$qECHO\" + fi + +# Very basic option parsing. These options are (a) specific to +# the libtool wrapper, (b) are identical between the wrapper +# /script/ and the wrapper /executable/ which is used only on +# windows platforms, and (c) all begin with the string "--lt-" +# (application programs are unlikely to have options which match +# this pattern). +# +# There are only two supported options: --lt-debug and +# --lt-dump-script. There is, deliberately, no --lt-help. +# +# The first argument to this parsing function should be the +# script's $0 value, followed by "$@". +lt_option_debug= +func_parse_lt_options () +{ + lt_script_arg0=\$0 + shift + for lt_opt + do + case \"\$lt_opt\" in + --lt-debug) lt_option_debug=1 ;; + --lt-dump-script) + lt_dump_D=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%/[^/]*$%%'\` + test \"X\$lt_dump_D\" = \"X\$lt_script_arg0\" && lt_dump_D=. + lt_dump_F=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%^.*/%%'\` + cat \"\$lt_dump_D/\$lt_dump_F\" + exit 0 + ;; + --lt-*) + \$ECHO \"Unrecognized --lt- option: '\$lt_opt'\" 1>&2 + exit 1 + ;; + esac + done + + # Print the debug banner immediately: + if test -n \"\$lt_option_debug\"; then + echo \"${outputname}:${output}:\${LINENO}: libtool wrapper (GNU $PACKAGE$TIMESTAMP) $VERSION\" 1>&2 + fi +} + +# Used when --lt-debug. Prints its arguments to stdout +# (redirection is the responsibility of the caller) +func_lt_dump_args () +{ + lt_dump_args_N=1; + for lt_arg + do + \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[\$lt_dump_args_N]: \$lt_arg\" + lt_dump_args_N=\`expr \$lt_dump_args_N + 1\` + done +} + +# Core function for launching the target application +func_exec_program_core () +{ +" + case $host in + # Backslashes separate directories on plain windows + *-*-mingw | *-*-os2* | *-cegcc*) + $ECHO "\ + if test -n \"\$lt_option_debug\"; then + \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[0]: \$progdir\\\\\$program\" 1>&2 + func_lt_dump_args \${1+\"\$@\"} 1>&2 + fi + exec \"\$progdir\\\\\$program\" \${1+\"\$@\"} +" + ;; + + *) + $ECHO "\ + if test -n \"\$lt_option_debug\"; then + \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[0]: \$progdir/\$program\" 1>&2 + func_lt_dump_args \${1+\"\$@\"} 1>&2 + fi + exec \"\$progdir/\$program\" \${1+\"\$@\"} +" + ;; + esac + $ECHO "\ + \$ECHO \"\$0: cannot exec \$program \$*\" 1>&2 + exit 1 +} + +# A function to encapsulate launching the target application +# Strips options in the --lt-* namespace from \$@ and +# launches target application with the remaining arguments. +func_exec_program () +{ + case \" \$* \" in + *\\ --lt-*) + for lt_wr_arg + do + case \$lt_wr_arg in + --lt-*) ;; + *) set x \"\$@\" \"\$lt_wr_arg\"; shift;; + esac + shift + done ;; + esac + func_exec_program_core \${1+\"\$@\"} +} + + # Parse options + func_parse_lt_options \"\$0\" \${1+\"\$@\"} + + # Find the directory that this script lives in. + thisdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*$%%'\` + test \"x\$thisdir\" = \"x\$file\" && thisdir=. + + # Follow symbolic links until we get to the real thisdir. + file=\`ls -ld \"\$file\" | $SED -n 's/.*-> //p'\` + while test -n \"\$file\"; do + destdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*\$%%'\` + + # If there was a directory component, then change thisdir. + if test \"x\$destdir\" != \"x\$file\"; then + case \"\$destdir\" in + [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;; + *) thisdir=\"\$thisdir/\$destdir\" ;; + esac + fi + + file=\`\$ECHO \"\$file\" | $SED 's%^.*/%%'\` + file=\`ls -ld \"\$thisdir/\$file\" | $SED -n 's/.*-> //p'\` + done + + # Usually 'no', except on cygwin/mingw when embedded into + # the cwrapper. + WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_arg1 + if test \"\$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\" = \"yes\"; then + # special case for '.' + if test \"\$thisdir\" = \".\"; then + thisdir=\`pwd\` + fi + # remove .libs from thisdir + case \"\$thisdir\" in + *[\\\\/]$objdir ) thisdir=\`\$ECHO \"\$thisdir\" | $SED 's%[\\\\/][^\\\\/]*$%%'\` ;; + $objdir ) thisdir=. ;; + esac + fi + + # Try to get the absolute directory name. + absdir=\`cd \"\$thisdir\" && pwd\` + test -n \"\$absdir\" && thisdir=\"\$absdir\" +" + + if test "$fast_install" = yes; then + $ECHO "\ + program=lt-'$outputname'$exeext + progdir=\"\$thisdir/$objdir\" + + if test ! -f \"\$progdir/\$program\" || + { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\ + test \"X\$file\" != \"X\$progdir/\$program\"; }; then + + file=\"\$\$-\$program\" + + if test ! -d \"\$progdir\"; then + $MKDIR \"\$progdir\" + else + $RM \"\$progdir/\$file\" + fi" + + $ECHO "\ + + # relink executable if necessary + if test -n \"\$relink_command\"; then + if relink_command_output=\`eval \$relink_command 2>&1\`; then : + else + $ECHO \"\$relink_command_output\" >&2 + $RM \"\$progdir/\$file\" + exit 1 + fi + fi + + $MV \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null || + { $RM \"\$progdir/\$program\"; + $MV \"\$progdir/\$file\" \"\$progdir/\$program\"; } + $RM \"\$progdir/\$file\" + fi" + else + $ECHO "\ + program='$outputname' + progdir=\"\$thisdir/$objdir\" +" + fi + + $ECHO "\ + + if test -f \"\$progdir/\$program\"; then" + + # fixup the dll searchpath if we need to. + # + # Fix the DLL searchpath if we need to. Do this before prepending + # to shlibpath, because on Windows, both are PATH and uninstalled + # libraries must come first. + if test -n "$dllsearchpath"; then + $ECHO "\ + # Add the dll search path components to the executable PATH + PATH=$dllsearchpath:\$PATH +" + fi + + # Export our shlibpath_var if we have one. + if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then + $ECHO "\ + # Add our own library path to $shlibpath_var + $shlibpath_var=\"$temp_rpath\$$shlibpath_var\" + + # Some systems cannot cope with colon-terminated $shlibpath_var + # The second colon is a workaround for a bug in BeOS R4 sed + $shlibpath_var=\`\$ECHO \"\$$shlibpath_var\" | $SED 's/::*\$//'\` + + export $shlibpath_var +" + fi + + $ECHO "\ + if test \"\$libtool_execute_magic\" != \"$magic\"; then + # Run the actual program with our arguments. + func_exec_program \${1+\"\$@\"} + fi + else + # The program doesn't exist. + \$ECHO \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2 + \$ECHO \"This script is just a wrapper for \$program.\" 1>&2 + \$ECHO \"See the $PACKAGE documentation for more information.\" 1>&2 + exit 1 + fi +fi\ +" +} + + +# func_emit_cwrapperexe_src +# emit the source code for a wrapper executable on stdout +# Must ONLY be called from within func_mode_link because +# it depends on a number of variable set therein. +func_emit_cwrapperexe_src () +{ + cat < +#include +#ifdef _MSC_VER +# include +# include +# include +#else +# include +# include +# ifdef __CYGWIN__ +# include +# endif +#endif +#include +#include +#include +#include +#include +#include +#include +#include + +/* declarations of non-ANSI functions */ +#if defined(__MINGW32__) +# ifdef __STRICT_ANSI__ +int _putenv (const char *); +# endif +#elif defined(__CYGWIN__) +# ifdef __STRICT_ANSI__ +char *realpath (const char *, char *); +int putenv (char *); +int setenv (const char *, const char *, int); +# endif +/* #elif defined (other platforms) ... */ +#endif + +/* portability defines, excluding path handling macros */ +#if defined(_MSC_VER) +# define setmode _setmode +# define stat _stat +# define chmod _chmod +# define getcwd _getcwd +# define putenv _putenv +# define S_IXUSR _S_IEXEC +# ifndef _INTPTR_T_DEFINED +# define _INTPTR_T_DEFINED +# define intptr_t int +# endif +#elif defined(__MINGW32__) +# define setmode _setmode +# define stat _stat +# define chmod _chmod +# define getcwd _getcwd +# define putenv _putenv +#elif defined(__CYGWIN__) +# define HAVE_SETENV +# define FOPEN_WB "wb" +/* #elif defined (other platforms) ... */ +#endif + +#if defined(PATH_MAX) +# define LT_PATHMAX PATH_MAX +#elif defined(MAXPATHLEN) +# define LT_PATHMAX MAXPATHLEN +#else +# define LT_PATHMAX 1024 +#endif + +#ifndef S_IXOTH +# define S_IXOTH 0 +#endif +#ifndef S_IXGRP +# define S_IXGRP 0 +#endif + +/* path handling portability macros */ +#ifndef DIR_SEPARATOR +# define DIR_SEPARATOR '/' +# define PATH_SEPARATOR ':' +#endif + +#if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \ + defined (__OS2__) +# define HAVE_DOS_BASED_FILE_SYSTEM +# define FOPEN_WB "wb" +# ifndef DIR_SEPARATOR_2 +# define DIR_SEPARATOR_2 '\\' +# endif +# ifndef PATH_SEPARATOR_2 +# define PATH_SEPARATOR_2 ';' +# endif +#endif + +#ifndef DIR_SEPARATOR_2 +# define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR) +#else /* DIR_SEPARATOR_2 */ +# define IS_DIR_SEPARATOR(ch) \ + (((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2)) +#endif /* DIR_SEPARATOR_2 */ + +#ifndef PATH_SEPARATOR_2 +# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR) +#else /* PATH_SEPARATOR_2 */ +# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2) +#endif /* PATH_SEPARATOR_2 */ + +#ifndef FOPEN_WB +# define FOPEN_WB "w" +#endif +#ifndef _O_BINARY +# define _O_BINARY 0 +#endif + +#define XMALLOC(type, num) ((type *) xmalloc ((num) * sizeof(type))) +#define XFREE(stale) do { \ + if (stale) { free ((void *) stale); stale = 0; } \ +} while (0) + +#if defined(LT_DEBUGWRAPPER) +static int lt_debug = 1; +#else +static int lt_debug = 0; +#endif + +const char *program_name = "libtool-wrapper"; /* in case xstrdup fails */ + +void *xmalloc (size_t num); +char *xstrdup (const char *string); +const char *base_name (const char *name); +char *find_executable (const char *wrapper); +char *chase_symlinks (const char *pathspec); +int make_executable (const char *path); +int check_executable (const char *path); +char *strendzap (char *str, const char *pat); +void lt_debugprintf (const char *file, int line, const char *fmt, ...); +void lt_fatal (const char *file, int line, const char *message, ...); +static const char *nonnull (const char *s); +static const char *nonempty (const char *s); +void lt_setenv (const char *name, const char *value); +char *lt_extend_str (const char *orig_value, const char *add, int to_end); +void lt_update_exe_path (const char *name, const char *value); +void lt_update_lib_path (const char *name, const char *value); +char **prepare_spawn (char **argv); +void lt_dump_script (FILE *f); +EOF + + cat <= 0) + && (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH))) + return 1; + else + return 0; +} + +int +make_executable (const char *path) +{ + int rval = 0; + struct stat st; + + lt_debugprintf (__FILE__, __LINE__, "(make_executable): %s\n", + nonempty (path)); + if ((!path) || (!*path)) + return 0; + + if (stat (path, &st) >= 0) + { + rval = chmod (path, st.st_mode | S_IXOTH | S_IXGRP | S_IXUSR); + } + return rval; +} + +/* Searches for the full path of the wrapper. Returns + newly allocated full path name if found, NULL otherwise + Does not chase symlinks, even on platforms that support them. +*/ +char * +find_executable (const char *wrapper) +{ + int has_slash = 0; + const char *p; + const char *p_next; + /* static buffer for getcwd */ + char tmp[LT_PATHMAX + 1]; + int tmp_len; + char *concat_name; + + lt_debugprintf (__FILE__, __LINE__, "(find_executable): %s\n", + nonempty (wrapper)); + + if ((wrapper == NULL) || (*wrapper == '\0')) + return NULL; + + /* Absolute path? */ +#if defined (HAVE_DOS_BASED_FILE_SYSTEM) + if (isalpha ((unsigned char) wrapper[0]) && wrapper[1] == ':') + { + concat_name = xstrdup (wrapper); + if (check_executable (concat_name)) + return concat_name; + XFREE (concat_name); + } + else + { +#endif + if (IS_DIR_SEPARATOR (wrapper[0])) + { + concat_name = xstrdup (wrapper); + if (check_executable (concat_name)) + return concat_name; + XFREE (concat_name); + } +#if defined (HAVE_DOS_BASED_FILE_SYSTEM) + } +#endif + + for (p = wrapper; *p; p++) + if (*p == '/') + { + has_slash = 1; + break; + } + if (!has_slash) + { + /* no slashes; search PATH */ + const char *path = getenv ("PATH"); + if (path != NULL) + { + for (p = path; *p; p = p_next) + { + const char *q; + size_t p_len; + for (q = p; *q; q++) + if (IS_PATH_SEPARATOR (*q)) + break; + p_len = q - p; + p_next = (*q == '\0' ? q : q + 1); + if (p_len == 0) + { + /* empty path: current directory */ + if (getcwd (tmp, LT_PATHMAX) == NULL) + lt_fatal (__FILE__, __LINE__, "getcwd failed: %s", + nonnull (strerror (errno))); + tmp_len = strlen (tmp); + concat_name = + XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1); + memcpy (concat_name, tmp, tmp_len); + concat_name[tmp_len] = '/'; + strcpy (concat_name + tmp_len + 1, wrapper); + } + else + { + concat_name = + XMALLOC (char, p_len + 1 + strlen (wrapper) + 1); + memcpy (concat_name, p, p_len); + concat_name[p_len] = '/'; + strcpy (concat_name + p_len + 1, wrapper); + } + if (check_executable (concat_name)) + return concat_name; + XFREE (concat_name); + } + } + /* not found in PATH; assume curdir */ + } + /* Relative path | not found in path: prepend cwd */ + if (getcwd (tmp, LT_PATHMAX) == NULL) + lt_fatal (__FILE__, __LINE__, "getcwd failed: %s", + nonnull (strerror (errno))); + tmp_len = strlen (tmp); + concat_name = XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1); + memcpy (concat_name, tmp, tmp_len); + concat_name[tmp_len] = '/'; + strcpy (concat_name + tmp_len + 1, wrapper); + + if (check_executable (concat_name)) + return concat_name; + XFREE (concat_name); + return NULL; +} + +char * +chase_symlinks (const char *pathspec) +{ +#ifndef S_ISLNK + return xstrdup (pathspec); +#else + char buf[LT_PATHMAX]; + struct stat s; + char *tmp_pathspec = xstrdup (pathspec); + char *p; + int has_symlinks = 0; + while (strlen (tmp_pathspec) && !has_symlinks) + { + lt_debugprintf (__FILE__, __LINE__, + "checking path component for symlinks: %s\n", + tmp_pathspec); + if (lstat (tmp_pathspec, &s) == 0) + { + if (S_ISLNK (s.st_mode) != 0) + { + has_symlinks = 1; + break; + } + + /* search backwards for last DIR_SEPARATOR */ + p = tmp_pathspec + strlen (tmp_pathspec) - 1; + while ((p > tmp_pathspec) && (!IS_DIR_SEPARATOR (*p))) + p--; + if ((p == tmp_pathspec) && (!IS_DIR_SEPARATOR (*p))) + { + /* no more DIR_SEPARATORS left */ + break; + } + *p = '\0'; + } + else + { + lt_fatal (__FILE__, __LINE__, + "error accessing file \"%s\": %s", + tmp_pathspec, nonnull (strerror (errno))); + } + } + XFREE (tmp_pathspec); + + if (!has_symlinks) + { + return xstrdup (pathspec); + } + + tmp_pathspec = realpath (pathspec, buf); + if (tmp_pathspec == 0) + { + lt_fatal (__FILE__, __LINE__, + "could not follow symlinks for %s", pathspec); + } + return xstrdup (tmp_pathspec); +#endif +} + +char * +strendzap (char *str, const char *pat) +{ + size_t len, patlen; + + assert (str != NULL); + assert (pat != NULL); + + len = strlen (str); + patlen = strlen (pat); + + if (patlen <= len) + { + str += len - patlen; + if (strcmp (str, pat) == 0) + *str = '\0'; + } + return str; +} + +void +lt_debugprintf (const char *file, int line, const char *fmt, ...) +{ + va_list args; + if (lt_debug) + { + (void) fprintf (stderr, "%s:%s:%d: ", program_name, file, line); + va_start (args, fmt); + (void) vfprintf (stderr, fmt, args); + va_end (args); + } +} + +static void +lt_error_core (int exit_status, const char *file, + int line, const char *mode, + const char *message, va_list ap) +{ + fprintf (stderr, "%s:%s:%d: %s: ", program_name, file, line, mode); + vfprintf (stderr, message, ap); + fprintf (stderr, ".\n"); + + if (exit_status >= 0) + exit (exit_status); +} + +void +lt_fatal (const char *file, int line, const char *message, ...) +{ + va_list ap; + va_start (ap, message); + lt_error_core (EXIT_FAILURE, file, line, "FATAL", message, ap); + va_end (ap); +} + +static const char * +nonnull (const char *s) +{ + return s ? s : "(null)"; +} + +static const char * +nonempty (const char *s) +{ + return (s && !*s) ? "(empty)" : nonnull (s); +} + +void +lt_setenv (const char *name, const char *value) +{ + lt_debugprintf (__FILE__, __LINE__, + "(lt_setenv) setting '%s' to '%s'\n", + nonnull (name), nonnull (value)); + { +#ifdef HAVE_SETENV + /* always make a copy, for consistency with !HAVE_SETENV */ + char *str = xstrdup (value); + setenv (name, str, 1); +#else + int len = strlen (name) + 1 + strlen (value) + 1; + char *str = XMALLOC (char, len); + sprintf (str, "%s=%s", name, value); + if (putenv (str) != EXIT_SUCCESS) + { + XFREE (str); + } +#endif + } +} + +char * +lt_extend_str (const char *orig_value, const char *add, int to_end) +{ + char *new_value; + if (orig_value && *orig_value) + { + int orig_value_len = strlen (orig_value); + int add_len = strlen (add); + new_value = XMALLOC (char, add_len + orig_value_len + 1); + if (to_end) + { + strcpy (new_value, orig_value); + strcpy (new_value + orig_value_len, add); + } + else + { + strcpy (new_value, add); + strcpy (new_value + add_len, orig_value); + } + } + else + { + new_value = xstrdup (add); + } + return new_value; +} + +void +lt_update_exe_path (const char *name, const char *value) +{ + lt_debugprintf (__FILE__, __LINE__, + "(lt_update_exe_path) modifying '%s' by prepending '%s'\n", + nonnull (name), nonnull (value)); + + if (name && *name && value && *value) + { + char *new_value = lt_extend_str (getenv (name), value, 0); + /* some systems can't cope with a ':'-terminated path #' */ + int len = strlen (new_value); + while (((len = strlen (new_value)) > 0) && IS_PATH_SEPARATOR (new_value[len-1])) + { + new_value[len-1] = '\0'; + } + lt_setenv (name, new_value); + XFREE (new_value); + } +} + +void +lt_update_lib_path (const char *name, const char *value) +{ + lt_debugprintf (__FILE__, __LINE__, + "(lt_update_lib_path) modifying '%s' by prepending '%s'\n", + nonnull (name), nonnull (value)); + + if (name && *name && value && *value) + { + char *new_value = lt_extend_str (getenv (name), value, 0); + lt_setenv (name, new_value); + XFREE (new_value); + } +} + +EOF + case $host_os in + mingw*) + cat <<"EOF" + +/* Prepares an argument vector before calling spawn(). + Note that spawn() does not by itself call the command interpreter + (getenv ("COMSPEC") != NULL ? getenv ("COMSPEC") : + ({ OSVERSIONINFO v; v.dwOSVersionInfoSize = sizeof(OSVERSIONINFO); + GetVersionEx(&v); + v.dwPlatformId == VER_PLATFORM_WIN32_NT; + }) ? "cmd.exe" : "command.com"). + Instead it simply concatenates the arguments, separated by ' ', and calls + CreateProcess(). We must quote the arguments since Win32 CreateProcess() + interprets characters like ' ', '\t', '\\', '"' (but not '<' and '>') in a + special way: + - Space and tab are interpreted as delimiters. They are not treated as + delimiters if they are surrounded by double quotes: "...". + - Unescaped double quotes are removed from the input. Their only effect is + that within double quotes, space and tab are treated like normal + characters. + - Backslashes not followed by double quotes are not special. + - But 2*n+1 backslashes followed by a double quote become + n backslashes followed by a double quote (n >= 0): + \" -> " + \\\" -> \" + \\\\\" -> \\" + */ +#define SHELL_SPECIAL_CHARS "\"\\ \001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037" +#define SHELL_SPACE_CHARS " \001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037" +char ** +prepare_spawn (char **argv) +{ + size_t argc; + char **new_argv; + size_t i; + + /* Count number of arguments. */ + for (argc = 0; argv[argc] != NULL; argc++) + ; + + /* Allocate new argument vector. */ + new_argv = XMALLOC (char *, argc + 1); + + /* Put quoted arguments into the new argument vector. */ + for (i = 0; i < argc; i++) + { + const char *string = argv[i]; + + if (string[0] == '\0') + new_argv[i] = xstrdup ("\"\""); + else if (strpbrk (string, SHELL_SPECIAL_CHARS) != NULL) + { + int quote_around = (strpbrk (string, SHELL_SPACE_CHARS) != NULL); + size_t length; + unsigned int backslashes; + const char *s; + char *quoted_string; + char *p; + + length = 0; + backslashes = 0; + if (quote_around) + length++; + for (s = string; *s != '\0'; s++) + { + char c = *s; + if (c == '"') + length += backslashes + 1; + length++; + if (c == '\\') + backslashes++; + else + backslashes = 0; + } + if (quote_around) + length += backslashes + 1; + + quoted_string = XMALLOC (char, length + 1); + + p = quoted_string; + backslashes = 0; + if (quote_around) + *p++ = '"'; + for (s = string; *s != '\0'; s++) + { + char c = *s; + if (c == '"') + { + unsigned int j; + for (j = backslashes + 1; j > 0; j--) + *p++ = '\\'; + } + *p++ = c; + if (c == '\\') + backslashes++; + else + backslashes = 0; + } + if (quote_around) + { + unsigned int j; + for (j = backslashes; j > 0; j--) + *p++ = '\\'; + *p++ = '"'; + } + *p = '\0'; + + new_argv[i] = quoted_string; + } + else + new_argv[i] = (char *) string; + } + new_argv[argc] = NULL; + + return new_argv; +} +EOF + ;; + esac + + cat <<"EOF" +void lt_dump_script (FILE* f) +{ +EOF + func_emit_wrapper yes | + $SED -n -e ' +s/^\(.\{79\}\)\(..*\)/\1\ +\2/ +h +s/\([\\"]\)/\\\1/g +s/$/\\n/ +s/\([^\n]*\).*/ fputs ("\1", f);/p +g +D' + cat <<"EOF" +} +EOF +} +# end: func_emit_cwrapperexe_src + +# func_win32_import_lib_p ARG +# True if ARG is an import lib, as indicated by $file_magic_cmd +func_win32_import_lib_p () +{ + $opt_debug + case `eval $file_magic_cmd \"\$1\" 2>/dev/null | $SED -e 10q` in + *import*) : ;; + *) false ;; + esac +} + +# func_mode_link arg... +func_mode_link () +{ + $opt_debug + case $host in + *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*) + # It is impossible to link a dll without this setting, and + # we shouldn't force the makefile maintainer to figure out + # which system we are compiling for in order to pass an extra + # flag for every libtool invocation. + # allow_undefined=no + + # FIXME: Unfortunately, there are problems with the above when trying + # to make a dll which has undefined symbols, in which case not + # even a static library is built. For now, we need to specify + # -no-undefined on the libtool link line when we can be certain + # that all symbols are satisfied, otherwise we get a static library. + allow_undefined=yes + ;; + *) + allow_undefined=yes + ;; + esac + libtool_args=$nonopt + base_compile="$nonopt $@" + compile_command=$nonopt + finalize_command=$nonopt + + compile_rpath= + finalize_rpath= + compile_shlibpath= + finalize_shlibpath= + convenience= + old_convenience= + deplibs= + old_deplibs= + compiler_flags= + linker_flags= + dllsearchpath= + lib_search_path=`pwd` + inst_prefix_dir= + new_inherited_linker_flags= + + avoid_version=no + bindir= + dlfiles= + dlprefiles= + dlself=no + export_dynamic=no + export_symbols= + export_symbols_regex= + generated= + libobjs= + ltlibs= + module=no + no_install=no + objs= + non_pic_objects= + precious_files_regex= + prefer_static_libs=no + preload=no + prev= + prevarg= + release= + rpath= + xrpath= + perm_rpath= + temp_rpath= + thread_safe=no + vinfo= + vinfo_number=no + weak_libs= + single_module="${wl}-single_module" + func_infer_tag $base_compile + + # We need to know -static, to get the right output filenames. + for arg + do + case $arg in + -shared) + test "$build_libtool_libs" != yes && \ + func_fatal_configuration "can not build a shared library" + build_old_libs=no + break + ;; + -all-static | -static | -static-libtool-libs) + case $arg in + -all-static) + if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then + func_warning "complete static linking is impossible in this configuration" + fi + if test -n "$link_static_flag"; then + dlopen_self=$dlopen_self_static + fi + prefer_static_libs=yes + ;; + -static) + if test -z "$pic_flag" && test -n "$link_static_flag"; then + dlopen_self=$dlopen_self_static + fi + prefer_static_libs=built + ;; + -static-libtool-libs) + if test -z "$pic_flag" && test -n "$link_static_flag"; then + dlopen_self=$dlopen_self_static + fi + prefer_static_libs=yes + ;; + esac + build_libtool_libs=no + build_old_libs=yes + break + ;; + esac + done + + # See if our shared archives depend on static archives. + test -n "$old_archive_from_new_cmds" && build_old_libs=yes + + # Go through the arguments, transforming them on the way. + while test "$#" -gt 0; do + arg="$1" + shift + func_quote_for_eval "$arg" + qarg=$func_quote_for_eval_unquoted_result + libtool_args+=" $func_quote_for_eval_result" + + # If the previous option needs an argument, assign it. + if test -n "$prev"; then + case $prev in + output) + compile_command+=" @OUTPUT@" + finalize_command+=" @OUTPUT@" + ;; + esac + + case $prev in + bindir) + bindir="$arg" + prev= + continue + ;; + dlfiles|dlprefiles) + if test "$preload" = no; then + # Add the symbol object into the linking commands. + compile_command+=" @SYMFILE@" + finalize_command+=" @SYMFILE@" + preload=yes + fi + case $arg in + *.la | *.lo) ;; # We handle these cases below. + force) + if test "$dlself" = no; then + dlself=needless + export_dynamic=yes + fi + prev= + continue + ;; + self) + if test "$prev" = dlprefiles; then + dlself=yes + elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then + dlself=yes + else + dlself=needless + export_dynamic=yes + fi + prev= + continue + ;; + *) + if test "$prev" = dlfiles; then + dlfiles+=" $arg" + else + dlprefiles+=" $arg" + fi + prev= + continue + ;; + esac + ;; + expsyms) + export_symbols="$arg" + test -f "$arg" \ + || func_fatal_error "symbol file \`$arg' does not exist" + prev= + continue + ;; + expsyms_regex) + export_symbols_regex="$arg" + prev= + continue + ;; + framework) + case $host in + *-*-darwin*) + case "$deplibs " in + *" $qarg.ltframework "*) ;; + *) deplibs+=" $qarg.ltframework" # this is fixed later + ;; + esac + ;; + esac + prev= + continue + ;; + inst_prefix) + inst_prefix_dir="$arg" + prev= + continue + ;; + objectlist) + if test -f "$arg"; then + save_arg=$arg + moreargs= + for fil in `cat "$save_arg"` + do +# moreargs+=" $fil" + arg=$fil + # A libtool-controlled object. + + # Check to see that this really is a libtool object. + if func_lalib_unsafe_p "$arg"; then + pic_object= + non_pic_object= + + # Read the .lo file + func_source "$arg" + + if test -z "$pic_object" || + test -z "$non_pic_object" || + test "$pic_object" = none && + test "$non_pic_object" = none; then + func_fatal_error "cannot find name of object for \`$arg'" + fi + + # Extract subdirectory from the argument. + func_dirname "$arg" "/" "" + xdir="$func_dirname_result" + + if test "$pic_object" != none; then + # Prepend the subdirectory the object is found in. + pic_object="$xdir$pic_object" + + if test "$prev" = dlfiles; then + if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then + dlfiles+=" $pic_object" + prev= + continue + else + # If libtool objects are unsupported, then we need to preload. + prev=dlprefiles + fi + fi + + # CHECK ME: I think I busted this. -Ossama + if test "$prev" = dlprefiles; then + # Preload the old-style object. + dlprefiles+=" $pic_object" + prev= + fi + + # A PIC object. + libobjs+=" $pic_object" + arg="$pic_object" + fi + + # Non-PIC object. + if test "$non_pic_object" != none; then + # Prepend the subdirectory the object is found in. + non_pic_object="$xdir$non_pic_object" + + # A standard non-PIC object + non_pic_objects+=" $non_pic_object" + if test -z "$pic_object" || test "$pic_object" = none ; then + arg="$non_pic_object" + fi + else + # If the PIC object exists, use it instead. + # $xdir was prepended to $pic_object above. + non_pic_object="$pic_object" + non_pic_objects+=" $non_pic_object" + fi + else + # Only an error if not doing a dry-run. + if $opt_dry_run; then + # Extract subdirectory from the argument. + func_dirname "$arg" "/" "" + xdir="$func_dirname_result" + + func_lo2o "$arg" + pic_object=$xdir$objdir/$func_lo2o_result + non_pic_object=$xdir$func_lo2o_result + libobjs+=" $pic_object" + non_pic_objects+=" $non_pic_object" + else + func_fatal_error "\`$arg' is not a valid libtool object" + fi + fi + done + else + func_fatal_error "link input file \`$arg' does not exist" + fi + arg=$save_arg + prev= + continue + ;; + precious_regex) + precious_files_regex="$arg" + prev= + continue + ;; + release) + release="-$arg" + prev= + continue + ;; + rpath | xrpath) + # We need an absolute path. + case $arg in + [\\/]* | [A-Za-z]:[\\/]*) ;; + *) + func_fatal_error "only absolute run-paths are allowed" + ;; + esac + if test "$prev" = rpath; then + case "$rpath " in + *" $arg "*) ;; + *) rpath+=" $arg" ;; + esac + else + case "$xrpath " in + *" $arg "*) ;; + *) xrpath+=" $arg" ;; + esac + fi + prev= + continue + ;; + shrext) + shrext_cmds="$arg" + prev= + continue + ;; + weak) + weak_libs+=" $arg" + prev= + continue + ;; + xcclinker) + linker_flags+=" $qarg" + compiler_flags+=" $qarg" + prev= + compile_command+=" $qarg" + finalize_command+=" $qarg" + continue + ;; + xcompiler) + compiler_flags+=" $qarg" + prev= + compile_command+=" $qarg" + finalize_command+=" $qarg" + continue + ;; + xlinker) + linker_flags+=" $qarg" + compiler_flags+=" $wl$qarg" + prev= + compile_command+=" $wl$qarg" + finalize_command+=" $wl$qarg" + continue + ;; + *) + eval "$prev=\"\$arg\"" + prev= + continue + ;; + esac + fi # test -n "$prev" + + prevarg="$arg" + + case $arg in + -all-static) + if test -n "$link_static_flag"; then + # See comment for -static flag below, for more details. + compile_command+=" $link_static_flag" + finalize_command+=" $link_static_flag" + fi + continue + ;; + + -allow-undefined) + # FIXME: remove this flag sometime in the future. + func_fatal_error "\`-allow-undefined' must not be used because it is the default" + ;; + + -avoid-version) + avoid_version=yes + continue + ;; + + -bindir) + prev=bindir + continue + ;; + + -dlopen) + prev=dlfiles + continue + ;; + + -dlpreopen) + prev=dlprefiles + continue + ;; + + -export-dynamic) + export_dynamic=yes + continue + ;; + + -export-symbols | -export-symbols-regex) + if test -n "$export_symbols" || test -n "$export_symbols_regex"; then + func_fatal_error "more than one -exported-symbols argument is not allowed" + fi + if test "X$arg" = "X-export-symbols"; then + prev=expsyms + else + prev=expsyms_regex + fi + continue + ;; + + -framework) + prev=framework + continue + ;; + + -inst-prefix-dir) + prev=inst_prefix + continue + ;; + + # The native IRIX linker understands -LANG:*, -LIST:* and -LNO:* + # so, if we see these flags be careful not to treat them like -L + -L[A-Z][A-Z]*:*) + case $with_gcc/$host in + no/*-*-irix* | /*-*-irix*) + compile_command+=" $arg" + finalize_command+=" $arg" + ;; + esac + continue + ;; + + -L*) + func_stripname "-L" '' "$arg" + if test -z "$func_stripname_result"; then + if test "$#" -gt 0; then + func_fatal_error "require no space between \`-L' and \`$1'" + else + func_fatal_error "need path for \`-L' option" + fi + fi + func_resolve_sysroot "$func_stripname_result" + dir=$func_resolve_sysroot_result + # We need an absolute path. + case $dir in + [\\/]* | [A-Za-z]:[\\/]*) ;; + *) + absdir=`cd "$dir" && pwd` + test -z "$absdir" && \ + func_fatal_error "cannot determine absolute directory name of \`$dir'" + dir="$absdir" + ;; + esac + case "$deplibs " in + *" -L$dir "* | *" $arg "*) + # Will only happen for absolute or sysroot arguments + ;; + *) + # Preserve sysroot, but never include relative directories + case $dir in + [\\/]* | [A-Za-z]:[\\/]* | =*) deplibs+=" $arg" ;; + *) deplibs+=" -L$dir" ;; + esac + lib_search_path+=" $dir" + ;; + esac + case $host in + *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*) + testbindir=`$ECHO "$dir" | $SED 's*/lib$*/bin*'` + case :$dllsearchpath: in + *":$dir:"*) ;; + ::) dllsearchpath=$dir;; + *) dllsearchpath+=":$dir";; + esac + case :$dllsearchpath: in + *":$testbindir:"*) ;; + ::) dllsearchpath=$testbindir;; + *) dllsearchpath+=":$testbindir";; + esac + ;; + esac + continue + ;; + + -l*) + if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then + case $host in + *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos* | *-cegcc* | *-*-haiku*) + # These systems don't actually have a C or math library (as such) + continue + ;; + *-*-os2*) + # These systems don't actually have a C library (as such) + test "X$arg" = "X-lc" && continue + ;; + *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*) + # Do not include libc due to us having libc/libc_r. + test "X$arg" = "X-lc" && continue + ;; + *-*-rhapsody* | *-*-darwin1.[012]) + # Rhapsody C and math libraries are in the System framework + deplibs+=" System.ltframework" + continue + ;; + *-*-sco3.2v5* | *-*-sco5v6*) + # Causes problems with __ctype + test "X$arg" = "X-lc" && continue + ;; + *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*) + # Compiler inserts libc in the correct place for threads to work + test "X$arg" = "X-lc" && continue + ;; + esac + elif test "X$arg" = "X-lc_r"; then + case $host in + *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*) + # Do not include libc_r directly, use -pthread flag. + continue + ;; + esac + fi + deplibs+=" $arg" + continue + ;; + + -module) + module=yes + continue + ;; + + # Tru64 UNIX uses -model [arg] to determine the layout of C++ + # classes, name mangling, and exception handling. + # Darwin uses the -arch flag to determine output architecture. + -model|-arch|-isysroot|--sysroot) + compiler_flags+=" $arg" + compile_command+=" $arg" + finalize_command+=" $arg" + prev=xcompiler + continue + ;; + + -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe \ + |-threads|-fopenmp|-openmp|-mp|-xopenmp|-omp|-qsmp=*) + compiler_flags+=" $arg" + compile_command+=" $arg" + finalize_command+=" $arg" + case "$new_inherited_linker_flags " in + *" $arg "*) ;; + * ) new_inherited_linker_flags+=" $arg" ;; + esac + continue + ;; + + -multi_module) + single_module="${wl}-multi_module" + continue + ;; + + -no-fast-install) + fast_install=no + continue + ;; + + -no-install) + case $host in + *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-darwin* | *-cegcc*) + # The PATH hackery in wrapper scripts is required on Windows + # and Darwin in order for the loader to find any dlls it needs. + func_warning "\`-no-install' is ignored for $host" + func_warning "assuming \`-no-fast-install' instead" + fast_install=no + ;; + *) no_install=yes ;; + esac + continue + ;; + + -no-undefined) + allow_undefined=no + continue + ;; + + -objectlist) + prev=objectlist + continue + ;; + + -o) prev=output ;; + + -precious-files-regex) + prev=precious_regex + continue + ;; + + -release) + prev=release + continue + ;; + + -rpath) + prev=rpath + continue + ;; + + -R) + prev=xrpath + continue + ;; + + -R*) + func_stripname '-R' '' "$arg" + dir=$func_stripname_result + # We need an absolute path. + case $dir in + [\\/]* | [A-Za-z]:[\\/]*) ;; + =*) + func_stripname '=' '' "$dir" + dir=$lt_sysroot$func_stripname_result + ;; + *) + func_fatal_error "only absolute run-paths are allowed" + ;; + esac + case "$xrpath " in + *" $dir "*) ;; + *) xrpath+=" $dir" ;; + esac + continue + ;; + + -shared) + # The effects of -shared are defined in a previous loop. + continue + ;; + + -shrext) + prev=shrext + continue + ;; + + -static | -static-libtool-libs) + # The effects of -static are defined in a previous loop. + # We used to do the same as -all-static on platforms that + # didn't have a PIC flag, but the assumption that the effects + # would be equivalent was wrong. It would break on at least + # Digital Unix and AIX. + continue + ;; + + -thread-safe) + thread_safe=yes + continue + ;; + + -version-info) + prev=vinfo + continue + ;; + + -version-number) + prev=vinfo + vinfo_number=yes + continue + ;; + + -weak) + prev=weak + continue + ;; + + -Wc,*) + func_stripname '-Wc,' '' "$arg" + args=$func_stripname_result + arg= + save_ifs="$IFS"; IFS=',' + for flag in $args; do + IFS="$save_ifs" + func_quote_for_eval "$flag" + arg+=" $func_quote_for_eval_result" + compiler_flags+=" $func_quote_for_eval_result" + done + IFS="$save_ifs" + func_stripname ' ' '' "$arg" + arg=$func_stripname_result + ;; + + -Wl,*) + func_stripname '-Wl,' '' "$arg" + args=$func_stripname_result + arg= + save_ifs="$IFS"; IFS=',' + for flag in $args; do + IFS="$save_ifs" + func_quote_for_eval "$flag" + arg+=" $wl$func_quote_for_eval_result" + compiler_flags+=" $wl$func_quote_for_eval_result" + linker_flags+=" $func_quote_for_eval_result" + done + IFS="$save_ifs" + func_stripname ' ' '' "$arg" + arg=$func_stripname_result + ;; + + -Xcompiler) + prev=xcompiler + continue + ;; + + -Xlinker) + prev=xlinker + continue + ;; + + -XCClinker) + prev=xcclinker + continue + ;; + + # -msg_* for osf cc + -msg_*) + func_quote_for_eval "$arg" + arg="$func_quote_for_eval_result" + ;; + + # Flags to be passed through unchanged, with rationale: + # -64, -mips[0-9] enable 64-bit mode for the SGI compiler + # -r[0-9][0-9]* specify processor for the SGI compiler + # -xarch=*, -xtarget=* enable 64-bit mode for the Sun compiler + # +DA*, +DD* enable 64-bit mode for the HP compiler + # -q* compiler args for the IBM compiler + # -m*, -t[45]*, -txscale* architecture-specific flags for GCC + # -F/path path to uninstalled frameworks, gcc on darwin + # -p, -pg, --coverage, -fprofile-* profiling flags for GCC + # @file GCC response files + # -tp=* Portland pgcc target processor selection + # --sysroot=* for sysroot support + # -O*, -flto*, -fwhopr*, -fuse-linker-plugin GCC link-time optimization + -64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \ + -t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*|-tp=*|--sysroot=*| \ + -O*|-flto*|-fwhopr*|-fuse-linker-plugin) + func_quote_for_eval "$arg" + arg="$func_quote_for_eval_result" + compile_command+=" $arg" + finalize_command+=" $arg" + compiler_flags+=" $arg" + continue + ;; + + # Some other compiler flag. + -* | +*) + func_quote_for_eval "$arg" + arg="$func_quote_for_eval_result" + ;; + + *.$objext) + # A standard object. + objs+=" $arg" + ;; + + *.lo) + # A libtool-controlled object. + + # Check to see that this really is a libtool object. + if func_lalib_unsafe_p "$arg"; then + pic_object= + non_pic_object= + + # Read the .lo file + func_source "$arg" + + if test -z "$pic_object" || + test -z "$non_pic_object" || + test "$pic_object" = none && + test "$non_pic_object" = none; then + func_fatal_error "cannot find name of object for \`$arg'" + fi + + # Extract subdirectory from the argument. + func_dirname "$arg" "/" "" + xdir="$func_dirname_result" + + if test "$pic_object" != none; then + # Prepend the subdirectory the object is found in. + pic_object="$xdir$pic_object" + + if test "$prev" = dlfiles; then + if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then + dlfiles+=" $pic_object" + prev= + continue + else + # If libtool objects are unsupported, then we need to preload. + prev=dlprefiles + fi + fi + + # CHECK ME: I think I busted this. -Ossama + if test "$prev" = dlprefiles; then + # Preload the old-style object. + dlprefiles+=" $pic_object" + prev= + fi + + # A PIC object. + libobjs+=" $pic_object" + arg="$pic_object" + fi + + # Non-PIC object. + if test "$non_pic_object" != none; then + # Prepend the subdirectory the object is found in. + non_pic_object="$xdir$non_pic_object" + + # A standard non-PIC object + non_pic_objects+=" $non_pic_object" + if test -z "$pic_object" || test "$pic_object" = none ; then + arg="$non_pic_object" + fi + else + # If the PIC object exists, use it instead. + # $xdir was prepended to $pic_object above. + non_pic_object="$pic_object" + non_pic_objects+=" $non_pic_object" + fi + else + # Only an error if not doing a dry-run. + if $opt_dry_run; then + # Extract subdirectory from the argument. + func_dirname "$arg" "/" "" + xdir="$func_dirname_result" + + func_lo2o "$arg" + pic_object=$xdir$objdir/$func_lo2o_result + non_pic_object=$xdir$func_lo2o_result + libobjs+=" $pic_object" + non_pic_objects+=" $non_pic_object" + else + func_fatal_error "\`$arg' is not a valid libtool object" + fi + fi + ;; + + *.$libext) + # An archive. + deplibs+=" $arg" + old_deplibs+=" $arg" + continue + ;; + + *.la) + # A libtool-controlled library. + + func_resolve_sysroot "$arg" + if test "$prev" = dlfiles; then + # This library was specified with -dlopen. + dlfiles+=" $func_resolve_sysroot_result" + prev= + elif test "$prev" = dlprefiles; then + # The library was specified with -dlpreopen. + dlprefiles+=" $func_resolve_sysroot_result" + prev= + else + deplibs+=" $func_resolve_sysroot_result" + fi + continue + ;; + + # Some other compiler argument. + *) + # Unknown arguments in both finalize_command and compile_command need + # to be aesthetically quoted because they are evaled later. + func_quote_for_eval "$arg" + arg="$func_quote_for_eval_result" + ;; + esac # arg + + # Now actually substitute the argument into the commands. + if test -n "$arg"; then + compile_command+=" $arg" + finalize_command+=" $arg" + fi + done # argument parsing loop + + test -n "$prev" && \ + func_fatal_help "the \`$prevarg' option requires an argument" + + if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then + eval arg=\"$export_dynamic_flag_spec\" + compile_command+=" $arg" + finalize_command+=" $arg" + fi + + oldlibs= + # calculate the name of the file, without its directory + func_basename "$output" + outputname="$func_basename_result" + libobjs_save="$libobjs" + + if test -n "$shlibpath_var"; then + # get the directories listed in $shlibpath_var + eval shlib_search_path=\`\$ECHO \"\${$shlibpath_var}\" \| \$SED \'s/:/ /g\'\` + else + shlib_search_path= + fi + eval sys_lib_search_path=\"$sys_lib_search_path_spec\" + eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\" + + func_dirname "$output" "/" "" + output_objdir="$func_dirname_result$objdir" + func_to_tool_file "$output_objdir/" + tool_output_objdir=$func_to_tool_file_result + # Create the object directory. + func_mkdir_p "$output_objdir" + + # Determine the type of output + case $output in + "") + func_fatal_help "you must specify an output file" + ;; + *.$libext) linkmode=oldlib ;; + *.lo | *.$objext) linkmode=obj ;; + *.la) linkmode=lib ;; + *) linkmode=prog ;; # Anything else should be a program. + esac + + specialdeplibs= + + libs= + # Find all interdependent deplibs by searching for libraries + # that are linked more than once (e.g. -la -lb -la) + for deplib in $deplibs; do + if $opt_preserve_dup_deps ; then + case "$libs " in + *" $deplib "*) specialdeplibs+=" $deplib" ;; + esac + fi + libs+=" $deplib" + done + + if test "$linkmode" = lib; then + libs="$predeps $libs $compiler_lib_search_path $postdeps" + + # Compute libraries that are listed more than once in $predeps + # $postdeps and mark them as special (i.e., whose duplicates are + # not to be eliminated). + pre_post_deps= + if $opt_duplicate_compiler_generated_deps; then + for pre_post_dep in $predeps $postdeps; do + case "$pre_post_deps " in + *" $pre_post_dep "*) specialdeplibs+=" $pre_post_deps" ;; + esac + pre_post_deps+=" $pre_post_dep" + done + fi + pre_post_deps= + fi + + deplibs= + newdependency_libs= + newlib_search_path= + need_relink=no # whether we're linking any uninstalled libtool libraries + notinst_deplibs= # not-installed libtool libraries + notinst_path= # paths that contain not-installed libtool libraries + + case $linkmode in + lib) + passes="conv dlpreopen link" + for file in $dlfiles $dlprefiles; do + case $file in + *.la) ;; + *) + func_fatal_help "libraries can \`-dlopen' only libtool libraries: $file" + ;; + esac + done + ;; + prog) + compile_deplibs= + finalize_deplibs= + alldeplibs=no + newdlfiles= + newdlprefiles= + passes="conv scan dlopen dlpreopen link" + ;; + *) passes="conv" + ;; + esac + + for pass in $passes; do + # The preopen pass in lib mode reverses $deplibs; put it back here + # so that -L comes before libs that need it for instance... + if test "$linkmode,$pass" = "lib,link"; then + ## FIXME: Find the place where the list is rebuilt in the wrong + ## order, and fix it there properly + tmp_deplibs= + for deplib in $deplibs; do + tmp_deplibs="$deplib $tmp_deplibs" + done + deplibs="$tmp_deplibs" + fi + + if test "$linkmode,$pass" = "lib,link" || + test "$linkmode,$pass" = "prog,scan"; then + libs="$deplibs" + deplibs= + fi + if test "$linkmode" = prog; then + case $pass in + dlopen) libs="$dlfiles" ;; + dlpreopen) libs="$dlprefiles" ;; + link) + libs="$deplibs %DEPLIBS%" + test "X$link_all_deplibs" != Xno && libs="$libs $dependency_libs" + ;; + esac + fi + if test "$linkmode,$pass" = "lib,dlpreopen"; then + # Collect and forward deplibs of preopened libtool libs + for lib in $dlprefiles; do + # Ignore non-libtool-libs + dependency_libs= + func_resolve_sysroot "$lib" + case $lib in + *.la) func_source "$func_resolve_sysroot_result" ;; + esac + + # Collect preopened libtool deplibs, except any this library + # has declared as weak libs + for deplib in $dependency_libs; do + func_basename "$deplib" + deplib_base=$func_basename_result + case " $weak_libs " in + *" $deplib_base "*) ;; + *) deplibs+=" $deplib" ;; + esac + done + done + libs="$dlprefiles" + fi + if test "$pass" = dlopen; then + # Collect dlpreopened libraries + save_deplibs="$deplibs" + deplibs= + fi + + for deplib in $libs; do + lib= + found=no + case $deplib in + -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe \ + |-threads|-fopenmp|-openmp|-mp|-xopenmp|-omp|-qsmp=*) + if test "$linkmode,$pass" = "prog,link"; then + compile_deplibs="$deplib $compile_deplibs" + finalize_deplibs="$deplib $finalize_deplibs" + else + compiler_flags+=" $deplib" + if test "$linkmode" = lib ; then + case "$new_inherited_linker_flags " in + *" $deplib "*) ;; + * ) new_inherited_linker_flags+=" $deplib" ;; + esac + fi + fi + continue + ;; + -l*) + if test "$linkmode" != lib && test "$linkmode" != prog; then + func_warning "\`-l' is ignored for archives/objects" + continue + fi + func_stripname '-l' '' "$deplib" + name=$func_stripname_result + if test "$linkmode" = lib; then + searchdirs="$newlib_search_path $lib_search_path $compiler_lib_search_dirs $sys_lib_search_path $shlib_search_path" + else + searchdirs="$newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path" + fi + for searchdir in $searchdirs; do + for search_ext in .la $std_shrext .so .a; do + # Search the libtool library + lib="$searchdir/lib${name}${search_ext}" + if test -f "$lib"; then + if test "$search_ext" = ".la"; then + found=yes + else + found=no + fi + break 2 + fi + done + done + if test "$found" != yes; then + # deplib doesn't seem to be a libtool library + if test "$linkmode,$pass" = "prog,link"; then + compile_deplibs="$deplib $compile_deplibs" + finalize_deplibs="$deplib $finalize_deplibs" + else + deplibs="$deplib $deplibs" + test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs" + fi + continue + else # deplib is a libtool library + # If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib, + # We need to do some special things here, and not later. + if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then + case " $predeps $postdeps " in + *" $deplib "*) + if func_lalib_p "$lib"; then + library_names= + old_library= + func_source "$lib" + for l in $old_library $library_names; do + ll="$l" + done + if test "X$ll" = "X$old_library" ; then # only static version available + found=no + func_dirname "$lib" "" "." + ladir="$func_dirname_result" + lib=$ladir/$old_library + if test "$linkmode,$pass" = "prog,link"; then + compile_deplibs="$deplib $compile_deplibs" + finalize_deplibs="$deplib $finalize_deplibs" + else + deplibs="$deplib $deplibs" + test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs" + fi + continue + fi + fi + ;; + *) ;; + esac + fi + fi + ;; # -l + *.ltframework) + if test "$linkmode,$pass" = "prog,link"; then + compile_deplibs="$deplib $compile_deplibs" + finalize_deplibs="$deplib $finalize_deplibs" + else + deplibs="$deplib $deplibs" + if test "$linkmode" = lib ; then + case "$new_inherited_linker_flags " in + *" $deplib "*) ;; + * ) new_inherited_linker_flags+=" $deplib" ;; + esac + fi + fi + continue + ;; + -L*) + case $linkmode in + lib) + deplibs="$deplib $deplibs" + test "$pass" = conv && continue + newdependency_libs="$deplib $newdependency_libs" + func_stripname '-L' '' "$deplib" + func_resolve_sysroot "$func_stripname_result" + newlib_search_path+=" $func_resolve_sysroot_result" + ;; + prog) + if test "$pass" = conv; then + deplibs="$deplib $deplibs" + continue + fi + if test "$pass" = scan; then + deplibs="$deplib $deplibs" + else + compile_deplibs="$deplib $compile_deplibs" + finalize_deplibs="$deplib $finalize_deplibs" + fi + func_stripname '-L' '' "$deplib" + func_resolve_sysroot "$func_stripname_result" + newlib_search_path+=" $func_resolve_sysroot_result" + ;; + *) + func_warning "\`-L' is ignored for archives/objects" + ;; + esac # linkmode + continue + ;; # -L + -R*) + if test "$pass" = link; then + func_stripname '-R' '' "$deplib" + func_resolve_sysroot "$func_stripname_result" + dir=$func_resolve_sysroot_result + # Make sure the xrpath contains only unique directories. + case "$xrpath " in + *" $dir "*) ;; + *) xrpath+=" $dir" ;; + esac + fi + deplibs="$deplib $deplibs" + continue + ;; + *.la) + func_resolve_sysroot "$deplib" + lib=$func_resolve_sysroot_result + ;; + *.$libext) + if test "$pass" = conv; then + deplibs="$deplib $deplibs" + continue + fi + case $linkmode in + lib) + # Linking convenience modules into shared libraries is allowed, + # but linking other static libraries is non-portable. + case " $dlpreconveniencelibs " in + *" $deplib "*) ;; + *) + valid_a_lib=no + case $deplibs_check_method in + match_pattern*) + set dummy $deplibs_check_method; shift + match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"` + if eval "\$ECHO \"$deplib\"" 2>/dev/null | $SED 10q \ + | $EGREP "$match_pattern_regex" > /dev/null; then + valid_a_lib=yes + fi + ;; + pass_all) + valid_a_lib=yes + ;; + esac + if test "$valid_a_lib" != yes; then + echo + $ECHO "*** Warning: Trying to link with static lib archive $deplib." + echo "*** I have the capability to make that library automatically link in when" + echo "*** you link to this library. But I can only do this if you have a" + echo "*** shared version of the library, which you do not appear to have" + echo "*** because the file extensions .$libext of this argument makes me believe" + echo "*** that it is just a static archive that I should not use here." + else + echo + $ECHO "*** Warning: Linking the shared library $output against the" + $ECHO "*** static library $deplib is not portable!" + deplibs="$deplib $deplibs" + fi + ;; + esac + continue + ;; + prog) + if test "$pass" != link; then + deplibs="$deplib $deplibs" + else + compile_deplibs="$deplib $compile_deplibs" + finalize_deplibs="$deplib $finalize_deplibs" + fi + continue + ;; + esac # linkmode + ;; # *.$libext + *.lo | *.$objext) + if test "$pass" = conv; then + deplibs="$deplib $deplibs" + elif test "$linkmode" = prog; then + if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then + # If there is no dlopen support or we're linking statically, + # we need to preload. + newdlprefiles+=" $deplib" + compile_deplibs="$deplib $compile_deplibs" + finalize_deplibs="$deplib $finalize_deplibs" + else + newdlfiles+=" $deplib" + fi + fi + continue + ;; + %DEPLIBS%) + alldeplibs=yes + continue + ;; + esac # case $deplib + + if test "$found" = yes || test -f "$lib"; then : + else + func_fatal_error "cannot find the library \`$lib' or unhandled argument \`$deplib'" + fi + + # Check to see that this really is a libtool archive. + func_lalib_unsafe_p "$lib" \ + || func_fatal_error "\`$lib' is not a valid libtool archive" + + func_dirname "$lib" "" "." + ladir="$func_dirname_result" + + dlname= + dlopen= + dlpreopen= + libdir= + library_names= + old_library= + inherited_linker_flags= + # If the library was installed with an old release of libtool, + # it will not redefine variables installed, or shouldnotlink + installed=yes + shouldnotlink=no + avoidtemprpath= + + + # Read the .la file + func_source "$lib" + + # Convert "-framework foo" to "foo.ltframework" + if test -n "$inherited_linker_flags"; then + tmp_inherited_linker_flags=`$ECHO "$inherited_linker_flags" | $SED 's/-framework \([^ $]*\)/\1.ltframework/g'` + for tmp_inherited_linker_flag in $tmp_inherited_linker_flags; do + case " $new_inherited_linker_flags " in + *" $tmp_inherited_linker_flag "*) ;; + *) new_inherited_linker_flags+=" $tmp_inherited_linker_flag";; + esac + done + fi + dependency_libs=`$ECHO " $dependency_libs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'` + if test "$linkmode,$pass" = "lib,link" || + test "$linkmode,$pass" = "prog,scan" || + { test "$linkmode" != prog && test "$linkmode" != lib; }; then + test -n "$dlopen" && dlfiles+=" $dlopen" + test -n "$dlpreopen" && dlprefiles+=" $dlpreopen" + fi + + if test "$pass" = conv; then + # Only check for convenience libraries + deplibs="$lib $deplibs" + if test -z "$libdir"; then + if test -z "$old_library"; then + func_fatal_error "cannot find name of link library for \`$lib'" + fi + # It is a libtool convenience library, so add in its objects. + convenience+=" $ladir/$objdir/$old_library" + old_convenience+=" $ladir/$objdir/$old_library" + tmp_libs= + for deplib in $dependency_libs; do + deplibs="$deplib $deplibs" + if $opt_preserve_dup_deps ; then + case "$tmp_libs " in + *" $deplib "*) specialdeplibs+=" $deplib" ;; + esac + fi + tmp_libs+=" $deplib" + done + elif test "$linkmode" != prog && test "$linkmode" != lib; then + func_fatal_error "\`$lib' is not a convenience library" + fi + continue + fi # $pass = conv + + + # Get the name of the library we link against. + linklib= + if test -n "$old_library" && + { test "$prefer_static_libs" = yes || + test "$prefer_static_libs,$installed" = "built,no"; }; then + linklib=$old_library + else + for l in $old_library $library_names; do + linklib="$l" + done + fi + if test -z "$linklib"; then + func_fatal_error "cannot find name of link library for \`$lib'" + fi + + # This library was specified with -dlopen. + if test "$pass" = dlopen; then + if test -z "$libdir"; then + func_fatal_error "cannot -dlopen a convenience library: \`$lib'" + fi + if test -z "$dlname" || + test "$dlopen_support" != yes || + test "$build_libtool_libs" = no; then + # If there is no dlname, no dlopen support or we're linking + # statically, we need to preload. We also need to preload any + # dependent libraries so libltdl's deplib preloader doesn't + # bomb out in the load deplibs phase. + dlprefiles+=" $lib $dependency_libs" + else + newdlfiles+=" $lib" + fi + continue + fi # $pass = dlopen + + # We need an absolute path. + case $ladir in + [\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;; + *) + abs_ladir=`cd "$ladir" && pwd` + if test -z "$abs_ladir"; then + func_warning "cannot determine absolute directory name of \`$ladir'" + func_warning "passing it literally to the linker, although it might fail" + abs_ladir="$ladir" + fi + ;; + esac + func_basename "$lib" + laname="$func_basename_result" + + # Find the relevant object directory and library name. + if test "X$installed" = Xyes; then + if test ! -f "$lt_sysroot$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then + func_warning "library \`$lib' was moved." + dir="$ladir" + absdir="$abs_ladir" + libdir="$abs_ladir" + else + dir="$lt_sysroot$libdir" + absdir="$lt_sysroot$libdir" + fi + test "X$hardcode_automatic" = Xyes && avoidtemprpath=yes + else + if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then + dir="$ladir" + absdir="$abs_ladir" + # Remove this search path later + notinst_path+=" $abs_ladir" + else + dir="$ladir/$objdir" + absdir="$abs_ladir/$objdir" + # Remove this search path later + notinst_path+=" $abs_ladir" + fi + fi # $installed = yes + func_stripname 'lib' '.la' "$laname" + name=$func_stripname_result + + # This library was specified with -dlpreopen. + if test "$pass" = dlpreopen; then + if test -z "$libdir" && test "$linkmode" = prog; then + func_fatal_error "only libraries may -dlpreopen a convenience library: \`$lib'" + fi + case "$host" in + # special handling for platforms with PE-DLLs. + *cygwin* | *mingw* | *cegcc* ) + # Linker will automatically link against shared library if both + # static and shared are present. Therefore, ensure we extract + # symbols from the import library if a shared library is present + # (otherwise, the dlopen module name will be incorrect). We do + # this by putting the import library name into $newdlprefiles. + # We recover the dlopen module name by 'saving' the la file + # name in a special purpose variable, and (later) extracting the + # dlname from the la file. + if test -n "$dlname"; then + func_tr_sh "$dir/$linklib" + eval "libfile_$func_tr_sh_result=\$abs_ladir/\$laname" + newdlprefiles+=" $dir/$linklib" + else + newdlprefiles+=" $dir/$old_library" + # Keep a list of preopened convenience libraries to check + # that they are being used correctly in the link pass. + test -z "$libdir" && \ + dlpreconveniencelibs+=" $dir/$old_library" + fi + ;; + * ) + # Prefer using a static library (so that no silly _DYNAMIC symbols + # are required to link). + if test -n "$old_library"; then + newdlprefiles+=" $dir/$old_library" + # Keep a list of preopened convenience libraries to check + # that they are being used correctly in the link pass. + test -z "$libdir" && \ + dlpreconveniencelibs+=" $dir/$old_library" + # Otherwise, use the dlname, so that lt_dlopen finds it. + elif test -n "$dlname"; then + newdlprefiles+=" $dir/$dlname" + else + newdlprefiles+=" $dir/$linklib" + fi + ;; + esac + fi # $pass = dlpreopen + + if test -z "$libdir"; then + # Link the convenience library + if test "$linkmode" = lib; then + deplibs="$dir/$old_library $deplibs" + elif test "$linkmode,$pass" = "prog,link"; then + compile_deplibs="$dir/$old_library $compile_deplibs" + finalize_deplibs="$dir/$old_library $finalize_deplibs" + else + deplibs="$lib $deplibs" # used for prog,scan pass + fi + continue + fi + + + if test "$linkmode" = prog && test "$pass" != link; then + newlib_search_path+=" $ladir" + deplibs="$lib $deplibs" + + linkalldeplibs=no + if test "$link_all_deplibs" != no || test -z "$library_names" || + test "$build_libtool_libs" = no; then + linkalldeplibs=yes + fi + + tmp_libs= + for deplib in $dependency_libs; do + case $deplib in + -L*) func_stripname '-L' '' "$deplib" + func_resolve_sysroot "$func_stripname_result" + newlib_search_path+=" $func_resolve_sysroot_result" + ;; + esac + # Need to link against all dependency_libs? + if test "$linkalldeplibs" = yes; then + deplibs="$deplib $deplibs" + else + # Need to hardcode shared library paths + # or/and link against static libraries + newdependency_libs="$deplib $newdependency_libs" + fi + if $opt_preserve_dup_deps ; then + case "$tmp_libs " in + *" $deplib "*) specialdeplibs+=" $deplib" ;; + esac + fi + tmp_libs+=" $deplib" + done # for deplib + continue + fi # $linkmode = prog... + + if test "$linkmode,$pass" = "prog,link"; then + if test -n "$library_names" && + { { test "$prefer_static_libs" = no || + test "$prefer_static_libs,$installed" = "built,yes"; } || + test -z "$old_library"; }; then + # We need to hardcode the library path + if test -n "$shlibpath_var" && test -z "$avoidtemprpath" ; then + # Make sure the rpath contains only unique directories. + case "$temp_rpath:" in + *"$absdir:"*) ;; + *) temp_rpath+="$absdir:" ;; + esac + fi + + # Hardcode the library path. + # Skip directories that are in the system default run-time + # search path. + case " $sys_lib_dlsearch_path " in + *" $absdir "*) ;; + *) + case "$compile_rpath " in + *" $absdir "*) ;; + *) compile_rpath+=" $absdir" ;; + esac + ;; + esac + case " $sys_lib_dlsearch_path " in + *" $libdir "*) ;; + *) + case "$finalize_rpath " in + *" $libdir "*) ;; + *) finalize_rpath+=" $libdir" ;; + esac + ;; + esac + fi # $linkmode,$pass = prog,link... + + if test "$alldeplibs" = yes && + { test "$deplibs_check_method" = pass_all || + { test "$build_libtool_libs" = yes && + test -n "$library_names"; }; }; then + # We only need to search for static libraries + continue + fi + fi + + link_static=no # Whether the deplib will be linked statically + use_static_libs=$prefer_static_libs + if test "$use_static_libs" = built && test "$installed" = yes; then + use_static_libs=no + fi + if test -n "$library_names" && + { test "$use_static_libs" = no || test -z "$old_library"; }; then + case $host in + *cygwin* | *mingw* | *cegcc*) + # No point in relinking DLLs because paths are not encoded + notinst_deplibs+=" $lib" + need_relink=no + ;; + *) + if test "$installed" = no; then + notinst_deplibs+=" $lib" + need_relink=yes + fi + ;; + esac + # This is a shared library + + # Warn about portability, can't link against -module's on some + # systems (darwin). Don't bleat about dlopened modules though! + dlopenmodule="" + for dlpremoduletest in $dlprefiles; do + if test "X$dlpremoduletest" = "X$lib"; then + dlopenmodule="$dlpremoduletest" + break + fi + done + if test -z "$dlopenmodule" && test "$shouldnotlink" = yes && test "$pass" = link; then + echo + if test "$linkmode" = prog; then + $ECHO "*** Warning: Linking the executable $output against the loadable module" + else + $ECHO "*** Warning: Linking the shared library $output against the loadable module" + fi + $ECHO "*** $linklib is not portable!" + fi + if test "$linkmode" = lib && + test "$hardcode_into_libs" = yes; then + # Hardcode the library path. + # Skip directories that are in the system default run-time + # search path. + case " $sys_lib_dlsearch_path " in + *" $absdir "*) ;; + *) + case "$compile_rpath " in + *" $absdir "*) ;; + *) compile_rpath+=" $absdir" ;; + esac + ;; + esac + case " $sys_lib_dlsearch_path " in + *" $libdir "*) ;; + *) + case "$finalize_rpath " in + *" $libdir "*) ;; + *) finalize_rpath+=" $libdir" ;; + esac + ;; + esac + fi + + if test -n "$old_archive_from_expsyms_cmds"; then + # figure out the soname + set dummy $library_names + shift + realname="$1" + shift + libname=`eval "\\$ECHO \"$libname_spec\""` + # use dlname if we got it. it's perfectly good, no? + if test -n "$dlname"; then + soname="$dlname" + elif test -n "$soname_spec"; then + # bleh windows + case $host in + *cygwin* | mingw* | *cegcc*) + func_arith $current - $age + major=$func_arith_result + versuffix="-$major" + ;; + esac + eval soname=\"$soname_spec\" + else + soname="$realname" + fi + + # Make a new name for the extract_expsyms_cmds to use + soroot="$soname" + func_basename "$soroot" + soname="$func_basename_result" + func_stripname 'lib' '.dll' "$soname" + newlib=libimp-$func_stripname_result.a + + # If the library has no export list, then create one now + if test -f "$output_objdir/$soname-def"; then : + else + func_verbose "extracting exported symbol list from \`$soname'" + func_execute_cmds "$extract_expsyms_cmds" 'exit $?' + fi + + # Create $newlib + if test -f "$output_objdir/$newlib"; then :; else + func_verbose "generating import library for \`$soname'" + func_execute_cmds "$old_archive_from_expsyms_cmds" 'exit $?' + fi + # make sure the library variables are pointing to the new library + dir=$output_objdir + linklib=$newlib + fi # test -n "$old_archive_from_expsyms_cmds" + + if test "$linkmode" = prog || test "$opt_mode" != relink; then + add_shlibpath= + add_dir= + add= + lib_linked=yes + case $hardcode_action in + immediate | unsupported) + if test "$hardcode_direct" = no; then + add="$dir/$linklib" + case $host in + *-*-sco3.2v5.0.[024]*) add_dir="-L$dir" ;; + *-*-sysv4*uw2*) add_dir="-L$dir" ;; + *-*-sysv5OpenUNIX* | *-*-sysv5UnixWare7.[01].[10]* | \ + *-*-unixware7*) add_dir="-L$dir" ;; + *-*-darwin* ) + # if the lib is a (non-dlopened) module then we can not + # link against it, someone is ignoring the earlier warnings + if /usr/bin/file -L $add 2> /dev/null | + $GREP ": [^:]* bundle" >/dev/null ; then + if test "X$dlopenmodule" != "X$lib"; then + $ECHO "*** Warning: lib $linklib is a module, not a shared library" + if test -z "$old_library" ; then + echo + echo "*** And there doesn't seem to be a static archive available" + echo "*** The link will probably fail, sorry" + else + add="$dir/$old_library" + fi + elif test -n "$old_library"; then + add="$dir/$old_library" + fi + fi + esac + elif test "$hardcode_minus_L" = no; then + case $host in + *-*-sunos*) add_shlibpath="$dir" ;; + esac + add_dir="-L$dir" + add="-l$name" + elif test "$hardcode_shlibpath_var" = no; then + add_shlibpath="$dir" + add="-l$name" + else + lib_linked=no + fi + ;; + relink) + if test "$hardcode_direct" = yes && + test "$hardcode_direct_absolute" = no; then + add="$dir/$linklib" + elif test "$hardcode_minus_L" = yes; then + add_dir="-L$absdir" + # Try looking first in the location we're being installed to. + if test -n "$inst_prefix_dir"; then + case $libdir in + [\\/]*) + add_dir+=" -L$inst_prefix_dir$libdir" + ;; + esac + fi + add="-l$name" + elif test "$hardcode_shlibpath_var" = yes; then + add_shlibpath="$dir" + add="-l$name" + else + lib_linked=no + fi + ;; + *) lib_linked=no ;; + esac + + if test "$lib_linked" != yes; then + func_fatal_configuration "unsupported hardcode properties" + fi + + if test -n "$add_shlibpath"; then + case :$compile_shlibpath: in + *":$add_shlibpath:"*) ;; + *) compile_shlibpath+="$add_shlibpath:" ;; + esac + fi + if test "$linkmode" = prog; then + test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs" + test -n "$add" && compile_deplibs="$add $compile_deplibs" + else + test -n "$add_dir" && deplibs="$add_dir $deplibs" + test -n "$add" && deplibs="$add $deplibs" + if test "$hardcode_direct" != yes && + test "$hardcode_minus_L" != yes && + test "$hardcode_shlibpath_var" = yes; then + case :$finalize_shlibpath: in + *":$libdir:"*) ;; + *) finalize_shlibpath+="$libdir:" ;; + esac + fi + fi + fi + + if test "$linkmode" = prog || test "$opt_mode" = relink; then + add_shlibpath= + add_dir= + add= + # Finalize command for both is simple: just hardcode it. + if test "$hardcode_direct" = yes && + test "$hardcode_direct_absolute" = no; then + add="$libdir/$linklib" + elif test "$hardcode_minus_L" = yes; then + add_dir="-L$libdir" + add="-l$name" + elif test "$hardcode_shlibpath_var" = yes; then + case :$finalize_shlibpath: in + *":$libdir:"*) ;; + *) finalize_shlibpath+="$libdir:" ;; + esac + add="-l$name" + elif test "$hardcode_automatic" = yes; then + if test -n "$inst_prefix_dir" && + test -f "$inst_prefix_dir$libdir/$linklib" ; then + add="$inst_prefix_dir$libdir/$linklib" + else + add="$libdir/$linklib" + fi + else + # We cannot seem to hardcode it, guess we'll fake it. + add_dir="-L$libdir" + # Try looking first in the location we're being installed to. + if test -n "$inst_prefix_dir"; then + case $libdir in + [\\/]*) + add_dir+=" -L$inst_prefix_dir$libdir" + ;; + esac + fi + add="-l$name" + fi + + if test "$linkmode" = prog; then + test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs" + test -n "$add" && finalize_deplibs="$add $finalize_deplibs" + else + test -n "$add_dir" && deplibs="$add_dir $deplibs" + test -n "$add" && deplibs="$add $deplibs" + fi + fi + elif test "$linkmode" = prog; then + # Here we assume that one of hardcode_direct or hardcode_minus_L + # is not unsupported. This is valid on all known static and + # shared platforms. + if test "$hardcode_direct" != unsupported; then + test -n "$old_library" && linklib="$old_library" + compile_deplibs="$dir/$linklib $compile_deplibs" + finalize_deplibs="$dir/$linklib $finalize_deplibs" + else + compile_deplibs="-l$name -L$dir $compile_deplibs" + finalize_deplibs="-l$name -L$dir $finalize_deplibs" + fi + elif test "$build_libtool_libs" = yes; then + # Not a shared library + if test "$deplibs_check_method" != pass_all; then + # We're trying link a shared library against a static one + # but the system doesn't support it. + + # Just print a warning and add the library to dependency_libs so + # that the program can be linked against the static library. + echo + $ECHO "*** Warning: This system can not link to static lib archive $lib." + echo "*** I have the capability to make that library automatically link in when" + echo "*** you link to this library. But I can only do this if you have a" + echo "*** shared version of the library, which you do not appear to have." + if test "$module" = yes; then + echo "*** But as you try to build a module library, libtool will still create " + echo "*** a static module, that should work as long as the dlopening application" + echo "*** is linked with the -dlopen flag to resolve symbols at runtime." + if test -z "$global_symbol_pipe"; then + echo + echo "*** However, this would only work if libtool was able to extract symbol" + echo "*** lists from a program, using \`nm' or equivalent, but libtool could" + echo "*** not find such a program. So, this module is probably useless." + echo "*** \`nm' from GNU binutils and a full rebuild may help." + fi + if test "$build_old_libs" = no; then + build_libtool_libs=module + build_old_libs=yes + else + build_libtool_libs=no + fi + fi + else + deplibs="$dir/$old_library $deplibs" + link_static=yes + fi + fi # link shared/static library? + + if test "$linkmode" = lib; then + if test -n "$dependency_libs" && + { test "$hardcode_into_libs" != yes || + test "$build_old_libs" = yes || + test "$link_static" = yes; }; then + # Extract -R from dependency_libs + temp_deplibs= + for libdir in $dependency_libs; do + case $libdir in + -R*) func_stripname '-R' '' "$libdir" + temp_xrpath=$func_stripname_result + case " $xrpath " in + *" $temp_xrpath "*) ;; + *) xrpath+=" $temp_xrpath";; + esac;; + *) temp_deplibs+=" $libdir";; + esac + done + dependency_libs="$temp_deplibs" + fi + + newlib_search_path+=" $absdir" + # Link against this library + test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs" + # ... and its dependency_libs + tmp_libs= + for deplib in $dependency_libs; do + newdependency_libs="$deplib $newdependency_libs" + case $deplib in + -L*) func_stripname '-L' '' "$deplib" + func_resolve_sysroot "$func_stripname_result";; + *) func_resolve_sysroot "$deplib" ;; + esac + if $opt_preserve_dup_deps ; then + case "$tmp_libs " in + *" $func_resolve_sysroot_result "*) + specialdeplibs+=" $func_resolve_sysroot_result" ;; + esac + fi + tmp_libs+=" $func_resolve_sysroot_result" + done + + if test "$link_all_deplibs" != no; then + # Add the search paths of all dependency libraries + for deplib in $dependency_libs; do + path= + case $deplib in + -L*) path="$deplib" ;; + *.la) + func_resolve_sysroot "$deplib" + deplib=$func_resolve_sysroot_result + func_dirname "$deplib" "" "." + dir=$func_dirname_result + # We need an absolute path. + case $dir in + [\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;; + *) + absdir=`cd "$dir" && pwd` + if test -z "$absdir"; then + func_warning "cannot determine absolute directory name of \`$dir'" + absdir="$dir" + fi + ;; + esac + if $GREP "^installed=no" $deplib > /dev/null; then + case $host in + *-*-darwin*) + depdepl= + eval deplibrary_names=`${SED} -n -e 's/^library_names=\(.*\)$/\1/p' $deplib` + if test -n "$deplibrary_names" ; then + for tmp in $deplibrary_names ; do + depdepl=$tmp + done + if test -f "$absdir/$objdir/$depdepl" ; then + depdepl="$absdir/$objdir/$depdepl" + darwin_install_name=`${OTOOL} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'` + if test -z "$darwin_install_name"; then + darwin_install_name=`${OTOOL64} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'` + fi + compiler_flags+=" ${wl}-dylib_file ${wl}${darwin_install_name}:${depdepl}" + linker_flags+=" -dylib_file ${darwin_install_name}:${depdepl}" + path= + fi + fi + ;; + *) + path="-L$absdir/$objdir" + ;; + esac + else + eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib` + test -z "$libdir" && \ + func_fatal_error "\`$deplib' is not a valid libtool archive" + test "$absdir" != "$libdir" && \ + func_warning "\`$deplib' seems to be moved" + + path="-L$absdir" + fi + ;; + esac + case " $deplibs " in + *" $path "*) ;; + *) deplibs="$path $deplibs" ;; + esac + done + fi # link_all_deplibs != no + fi # linkmode = lib + done # for deplib in $libs + if test "$pass" = link; then + if test "$linkmode" = "prog"; then + compile_deplibs="$new_inherited_linker_flags $compile_deplibs" + finalize_deplibs="$new_inherited_linker_flags $finalize_deplibs" + else + compiler_flags="$compiler_flags "`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'` + fi + fi + dependency_libs="$newdependency_libs" + if test "$pass" = dlpreopen; then + # Link the dlpreopened libraries before other libraries + for deplib in $save_deplibs; do + deplibs="$deplib $deplibs" + done + fi + if test "$pass" != dlopen; then + if test "$pass" != conv; then + # Make sure lib_search_path contains only unique directories. + lib_search_path= + for dir in $newlib_search_path; do + case "$lib_search_path " in + *" $dir "*) ;; + *) lib_search_path+=" $dir" ;; + esac + done + newlib_search_path= + fi + + if test "$linkmode,$pass" != "prog,link"; then + vars="deplibs" + else + vars="compile_deplibs finalize_deplibs" + fi + for var in $vars dependency_libs; do + # Add libraries to $var in reverse order + eval tmp_libs=\"\$$var\" + new_libs= + for deplib in $tmp_libs; do + # FIXME: Pedantically, this is the right thing to do, so + # that some nasty dependency loop isn't accidentally + # broken: + #new_libs="$deplib $new_libs" + # Pragmatically, this seems to cause very few problems in + # practice: + case $deplib in + -L*) new_libs="$deplib $new_libs" ;; + -R*) ;; + *) + # And here is the reason: when a library appears more + # than once as an explicit dependence of a library, or + # is implicitly linked in more than once by the + # compiler, it is considered special, and multiple + # occurrences thereof are not removed. Compare this + # with having the same library being listed as a + # dependency of multiple other libraries: in this case, + # we know (pedantically, we assume) the library does not + # need to be listed more than once, so we keep only the + # last copy. This is not always right, but it is rare + # enough that we require users that really mean to play + # such unportable linking tricks to link the library + # using -Wl,-lname, so that libtool does not consider it + # for duplicate removal. + case " $specialdeplibs " in + *" $deplib "*) new_libs="$deplib $new_libs" ;; + *) + case " $new_libs " in + *" $deplib "*) ;; + *) new_libs="$deplib $new_libs" ;; + esac + ;; + esac + ;; + esac + done + tmp_libs= + for deplib in $new_libs; do + case $deplib in + -L*) + case " $tmp_libs " in + *" $deplib "*) ;; + *) tmp_libs+=" $deplib" ;; + esac + ;; + *) tmp_libs+=" $deplib" ;; + esac + done + eval $var=\"$tmp_libs\" + done # for var + fi + # Last step: remove runtime libs from dependency_libs + # (they stay in deplibs) + tmp_libs= + for i in $dependency_libs ; do + case " $predeps $postdeps $compiler_lib_search_path " in + *" $i "*) + i="" + ;; + esac + if test -n "$i" ; then + tmp_libs+=" $i" + fi + done + dependency_libs=$tmp_libs + done # for pass + if test "$linkmode" = prog; then + dlfiles="$newdlfiles" + fi + if test "$linkmode" = prog || test "$linkmode" = lib; then + dlprefiles="$newdlprefiles" + fi + + case $linkmode in + oldlib) + if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then + func_warning "\`-dlopen' is ignored for archives" + fi + + case " $deplibs" in + *\ -l* | *\ -L*) + func_warning "\`-l' and \`-L' are ignored for archives" ;; + esac + + test -n "$rpath" && \ + func_warning "\`-rpath' is ignored for archives" + + test -n "$xrpath" && \ + func_warning "\`-R' is ignored for archives" + + test -n "$vinfo" && \ + func_warning "\`-version-info/-version-number' is ignored for archives" + + test -n "$release" && \ + func_warning "\`-release' is ignored for archives" + + test -n "$export_symbols$export_symbols_regex" && \ + func_warning "\`-export-symbols' is ignored for archives" + + # Now set the variables for building old libraries. + build_libtool_libs=no + oldlibs="$output" + objs+="$old_deplibs" + ;; + + lib) + # Make sure we only generate libraries of the form `libNAME.la'. + case $outputname in + lib*) + func_stripname 'lib' '.la' "$outputname" + name=$func_stripname_result + eval shared_ext=\"$shrext_cmds\" + eval libname=\"$libname_spec\" + ;; + *) + test "$module" = no && \ + func_fatal_help "libtool library \`$output' must begin with \`lib'" + + if test "$need_lib_prefix" != no; then + # Add the "lib" prefix for modules if required + func_stripname '' '.la' "$outputname" + name=$func_stripname_result + eval shared_ext=\"$shrext_cmds\" + eval libname=\"$libname_spec\" + else + func_stripname '' '.la' "$outputname" + libname=$func_stripname_result + fi + ;; + esac + + if test -n "$objs"; then + if test "$deplibs_check_method" != pass_all; then + func_fatal_error "cannot build libtool library \`$output' from non-libtool objects on this host:$objs" + else + echo + $ECHO "*** Warning: Linking the shared library $output against the non-libtool" + $ECHO "*** objects $objs is not portable!" + libobjs+=" $objs" + fi + fi + + test "$dlself" != no && \ + func_warning "\`-dlopen self' is ignored for libtool libraries" + + set dummy $rpath + shift + test "$#" -gt 1 && \ + func_warning "ignoring multiple \`-rpath's for a libtool library" + + install_libdir="$1" + + oldlibs= + if test -z "$rpath"; then + if test "$build_libtool_libs" = yes; then + # Building a libtool convenience library. + # Some compilers have problems with a `.al' extension so + # convenience libraries should have the same extension an + # archive normally would. + oldlibs="$output_objdir/$libname.$libext $oldlibs" + build_libtool_libs=convenience + build_old_libs=yes + fi + + test -n "$vinfo" && \ + func_warning "\`-version-info/-version-number' is ignored for convenience libraries" + + test -n "$release" && \ + func_warning "\`-release' is ignored for convenience libraries" + else + + # Parse the version information argument. + save_ifs="$IFS"; IFS=':' + set dummy $vinfo 0 0 0 + shift + IFS="$save_ifs" + + test -n "$7" && \ + func_fatal_help "too many parameters to \`-version-info'" + + # convert absolute version numbers to libtool ages + # this retains compatibility with .la files and attempts + # to make the code below a bit more comprehensible + + case $vinfo_number in + yes) + number_major="$1" + number_minor="$2" + number_revision="$3" + # + # There are really only two kinds -- those that + # use the current revision as the major version + # and those that subtract age and use age as + # a minor version. But, then there is irix + # which has an extra 1 added just for fun + # + case $version_type in + # correct linux to gnu/linux during the next big refactor + darwin|linux|osf|windows|none) + func_arith $number_major + $number_minor + current=$func_arith_result + age="$number_minor" + revision="$number_revision" + ;; + freebsd-aout|freebsd-elf|qnx|sunos) + current="$number_major" + revision="$number_minor" + age="0" + ;; + irix|nonstopux) + func_arith $number_major + $number_minor + current=$func_arith_result + age="$number_minor" + revision="$number_minor" + lt_irix_increment=no + ;; + *) + func_fatal_configuration "$modename: unknown library version type \`$version_type'" + ;; + esac + ;; + no) + current="$1" + revision="$2" + age="$3" + ;; + esac + + # Check that each of the things are valid numbers. + case $current in + 0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;; + *) + func_error "CURRENT \`$current' must be a nonnegative integer" + func_fatal_error "\`$vinfo' is not valid version information" + ;; + esac + + case $revision in + 0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;; + *) + func_error "REVISION \`$revision' must be a nonnegative integer" + func_fatal_error "\`$vinfo' is not valid version information" + ;; + esac + + case $age in + 0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;; + *) + func_error "AGE \`$age' must be a nonnegative integer" + func_fatal_error "\`$vinfo' is not valid version information" + ;; + esac + + if test "$age" -gt "$current"; then + func_error "AGE \`$age' is greater than the current interface number \`$current'" + func_fatal_error "\`$vinfo' is not valid version information" + fi + + # Calculate the version variables. + major= + versuffix= + verstring= + case $version_type in + none) ;; + + darwin) + # Like Linux, but with the current version available in + # verstring for coding it into the library header + func_arith $current - $age + major=.$func_arith_result + versuffix="$major.$age.$revision" + # Darwin ld doesn't like 0 for these options... + func_arith $current + 1 + minor_current=$func_arith_result + xlcverstring="${wl}-compatibility_version ${wl}$minor_current ${wl}-current_version ${wl}$minor_current.$revision" + verstring="-compatibility_version $minor_current -current_version $minor_current.$revision" + ;; + + freebsd-aout) + major=".$current" + versuffix=".$current.$revision"; + ;; + + freebsd-elf) + major=".$current" + versuffix=".$current" + ;; + + irix | nonstopux) + if test "X$lt_irix_increment" = "Xno"; then + func_arith $current - $age + else + func_arith $current - $age + 1 + fi + major=$func_arith_result + + case $version_type in + nonstopux) verstring_prefix=nonstopux ;; + *) verstring_prefix=sgi ;; + esac + verstring="$verstring_prefix$major.$revision" + + # Add in all the interfaces that we are compatible with. + loop=$revision + while test "$loop" -ne 0; do + func_arith $revision - $loop + iface=$func_arith_result + func_arith $loop - 1 + loop=$func_arith_result + verstring="$verstring_prefix$major.$iface:$verstring" + done + + # Before this point, $major must not contain `.'. + major=.$major + versuffix="$major.$revision" + ;; + + linux) # correct to gnu/linux during the next big refactor + func_arith $current - $age + major=.$func_arith_result + versuffix="$major.$age.$revision" + ;; + + osf) + func_arith $current - $age + major=.$func_arith_result + versuffix=".$current.$age.$revision" + verstring="$current.$age.$revision" + + # Add in all the interfaces that we are compatible with. + loop=$age + while test "$loop" -ne 0; do + func_arith $current - $loop + iface=$func_arith_result + func_arith $loop - 1 + loop=$func_arith_result + verstring="$verstring:${iface}.0" + done + + # Make executables depend on our current version. + verstring+=":${current}.0" + ;; + + qnx) + major=".$current" + versuffix=".$current" + ;; + + sunos) + major=".$current" + versuffix=".$current.$revision" + ;; + + windows) + # Use '-' rather than '.', since we only want one + # extension on DOS 8.3 filesystems. + func_arith $current - $age + major=$func_arith_result + versuffix="-$major" + ;; + + *) + func_fatal_configuration "unknown library version type \`$version_type'" + ;; + esac + + # Clear the version info if we defaulted, and they specified a release. + if test -z "$vinfo" && test -n "$release"; then + major= + case $version_type in + darwin) + # we can't check for "0.0" in archive_cmds due to quoting + # problems, so we reset it completely + verstring= + ;; + *) + verstring="0.0" + ;; + esac + if test "$need_version" = no; then + versuffix= + else + versuffix=".0.0" + fi + fi + + # Remove version info from name if versioning should be avoided + if test "$avoid_version" = yes && test "$need_version" = no; then + major= + versuffix= + verstring="" + fi + + # Check to see if the archive will have undefined symbols. + if test "$allow_undefined" = yes; then + if test "$allow_undefined_flag" = unsupported; then + func_warning "undefined symbols not allowed in $host shared libraries" + build_libtool_libs=no + build_old_libs=yes + fi + else + # Don't allow undefined symbols. + allow_undefined_flag="$no_undefined_flag" + fi + + fi + + func_generate_dlsyms "$libname" "$libname" "yes" + libobjs+=" $symfileobj" + test "X$libobjs" = "X " && libobjs= + + if test "$opt_mode" != relink; then + # Remove our outputs, but don't remove object files since they + # may have been created when compiling PIC objects. + removelist= + tempremovelist=`$ECHO "$output_objdir/*"` + for p in $tempremovelist; do + case $p in + *.$objext | *.gcno) + ;; + $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*) + if test "X$precious_files_regex" != "X"; then + if $ECHO "$p" | $EGREP -e "$precious_files_regex" >/dev/null 2>&1 + then + continue + fi + fi + removelist+=" $p" + ;; + *) ;; + esac + done + test -n "$removelist" && \ + func_show_eval "${RM}r \$removelist" + fi + + # Now set the variables for building old libraries. + if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then + oldlibs+=" $output_objdir/$libname.$libext" + + # Transform .lo files to .o files. + oldobjs="$objs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; $lo2o" | $NL2SP` + fi + + # Eliminate all temporary directories. + #for path in $notinst_path; do + # lib_search_path=`$ECHO "$lib_search_path " | $SED "s% $path % %g"` + # deplibs=`$ECHO "$deplibs " | $SED "s% -L$path % %g"` + # dependency_libs=`$ECHO "$dependency_libs " | $SED "s% -L$path % %g"` + #done + + if test -n "$xrpath"; then + # If the user specified any rpath flags, then add them. + temp_xrpath= + for libdir in $xrpath; do + func_replace_sysroot "$libdir" + temp_xrpath+=" -R$func_replace_sysroot_result" + case "$finalize_rpath " in + *" $libdir "*) ;; + *) finalize_rpath+=" $libdir" ;; + esac + done + if test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then + dependency_libs="$temp_xrpath $dependency_libs" + fi + fi + + # Make sure dlfiles contains only unique files that won't be dlpreopened + old_dlfiles="$dlfiles" + dlfiles= + for lib in $old_dlfiles; do + case " $dlprefiles $dlfiles " in + *" $lib "*) ;; + *) dlfiles+=" $lib" ;; + esac + done + + # Make sure dlprefiles contains only unique files + old_dlprefiles="$dlprefiles" + dlprefiles= + for lib in $old_dlprefiles; do + case "$dlprefiles " in + *" $lib "*) ;; + *) dlprefiles+=" $lib" ;; + esac + done + + if test "$build_libtool_libs" = yes; then + if test -n "$rpath"; then + case $host in + *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos* | *-cegcc* | *-*-haiku*) + # these systems don't actually have a c library (as such)! + ;; + *-*-rhapsody* | *-*-darwin1.[012]) + # Rhapsody C library is in the System framework + deplibs+=" System.ltframework" + ;; + *-*-netbsd*) + # Don't link with libc until the a.out ld.so is fixed. + ;; + *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*) + # Do not include libc due to us having libc/libc_r. + ;; + *-*-sco3.2v5* | *-*-sco5v6*) + # Causes problems with __ctype + ;; + *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*) + # Compiler inserts libc in the correct place for threads to work + ;; + *) + # Add libc to deplibs on all other systems if necessary. + if test "$build_libtool_need_lc" = "yes"; then + deplibs+=" -lc" + fi + ;; + esac + fi + + # Transform deplibs into only deplibs that can be linked in shared. + name_save=$name + libname_save=$libname + release_save=$release + versuffix_save=$versuffix + major_save=$major + # I'm not sure if I'm treating the release correctly. I think + # release should show up in the -l (ie -lgmp5) so we don't want to + # add it in twice. Is that correct? + release="" + versuffix="" + major="" + newdeplibs= + droppeddeps=no + case $deplibs_check_method in + pass_all) + # Don't check for shared/static. Everything works. + # This might be a little naive. We might want to check + # whether the library exists or not. But this is on + # osf3 & osf4 and I'm not really sure... Just + # implementing what was already the behavior. + newdeplibs=$deplibs + ;; + test_compile) + # This code stresses the "libraries are programs" paradigm to its + # limits. Maybe even breaks it. We compile a program, linking it + # against the deplibs as a proxy for the library. Then we can check + # whether they linked in statically or dynamically with ldd. + $opt_dry_run || $RM conftest.c + cat > conftest.c </dev/null` + $nocaseglob + else + potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null` + fi + for potent_lib in $potential_libs; do + # Follow soft links. + if ls -lLd "$potent_lib" 2>/dev/null | + $GREP " -> " >/dev/null; then + continue + fi + # The statement above tries to avoid entering an + # endless loop below, in case of cyclic links. + # We might still enter an endless loop, since a link + # loop can be closed while we follow links, + # but so what? + potlib="$potent_lib" + while test -h "$potlib" 2>/dev/null; do + potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'` + case $potliblink in + [\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";; + *) potlib=`$ECHO "$potlib" | $SED 's,[^/]*$,,'`"$potliblink";; + esac + done + if eval $file_magic_cmd \"\$potlib\" 2>/dev/null | + $SED -e 10q | + $EGREP "$file_magic_regex" > /dev/null; then + newdeplibs+=" $a_deplib" + a_deplib="" + break 2 + fi + done + done + fi + if test -n "$a_deplib" ; then + droppeddeps=yes + echo + $ECHO "*** Warning: linker path does not have real file for library $a_deplib." + echo "*** I have the capability to make that library automatically link in when" + echo "*** you link to this library. But I can only do this if you have a" + echo "*** shared version of the library, which you do not appear to have" + echo "*** because I did check the linker path looking for a file starting" + if test -z "$potlib" ; then + $ECHO "*** with $libname but no candidates were found. (...for file magic test)" + else + $ECHO "*** with $libname and none of the candidates passed a file format test" + $ECHO "*** using a file magic. Last file checked: $potlib" + fi + fi + ;; + *) + # Add a -L argument. + newdeplibs+=" $a_deplib" + ;; + esac + done # Gone through all deplibs. + ;; + match_pattern*) + set dummy $deplibs_check_method; shift + match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"` + for a_deplib in $deplibs; do + case $a_deplib in + -l*) + func_stripname -l '' "$a_deplib" + name=$func_stripname_result + if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then + case " $predeps $postdeps " in + *" $a_deplib "*) + newdeplibs+=" $a_deplib" + a_deplib="" + ;; + esac + fi + if test -n "$a_deplib" ; then + libname=`eval "\\$ECHO \"$libname_spec\""` + for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do + potential_libs=`ls $i/$libname[.-]* 2>/dev/null` + for potent_lib in $potential_libs; do + potlib="$potent_lib" # see symlink-check above in file_magic test + if eval "\$ECHO \"$potent_lib\"" 2>/dev/null | $SED 10q | \ + $EGREP "$match_pattern_regex" > /dev/null; then + newdeplibs+=" $a_deplib" + a_deplib="" + break 2 + fi + done + done + fi + if test -n "$a_deplib" ; then + droppeddeps=yes + echo + $ECHO "*** Warning: linker path does not have real file for library $a_deplib." + echo "*** I have the capability to make that library automatically link in when" + echo "*** you link to this library. But I can only do this if you have a" + echo "*** shared version of the library, which you do not appear to have" + echo "*** because I did check the linker path looking for a file starting" + if test -z "$potlib" ; then + $ECHO "*** with $libname but no candidates were found. (...for regex pattern test)" + else + $ECHO "*** with $libname and none of the candidates passed a file format test" + $ECHO "*** using a regex pattern. Last file checked: $potlib" + fi + fi + ;; + *) + # Add a -L argument. + newdeplibs+=" $a_deplib" + ;; + esac + done # Gone through all deplibs. + ;; + none | unknown | *) + newdeplibs="" + tmp_deplibs=`$ECHO " $deplibs" | $SED 's/ -lc$//; s/ -[LR][^ ]*//g'` + if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then + for i in $predeps $postdeps ; do + # can't use Xsed below, because $i might contain '/' + tmp_deplibs=`$ECHO " $tmp_deplibs" | $SED "s,$i,,"` + done + fi + case $tmp_deplibs in + *[!\ \ ]*) + echo + if test "X$deplibs_check_method" = "Xnone"; then + echo "*** Warning: inter-library dependencies are not supported in this platform." + else + echo "*** Warning: inter-library dependencies are not known to be supported." + fi + echo "*** All declared inter-library dependencies are being dropped." + droppeddeps=yes + ;; + esac + ;; + esac + versuffix=$versuffix_save + major=$major_save + release=$release_save + libname=$libname_save + name=$name_save + + case $host in + *-*-rhapsody* | *-*-darwin1.[012]) + # On Rhapsody replace the C library with the System framework + newdeplibs=`$ECHO " $newdeplibs" | $SED 's/ -lc / System.ltframework /'` + ;; + esac + + if test "$droppeddeps" = yes; then + if test "$module" = yes; then + echo + echo "*** Warning: libtool could not satisfy all declared inter-library" + $ECHO "*** dependencies of module $libname. Therefore, libtool will create" + echo "*** a static module, that should work as long as the dlopening" + echo "*** application is linked with the -dlopen flag." + if test -z "$global_symbol_pipe"; then + echo + echo "*** However, this would only work if libtool was able to extract symbol" + echo "*** lists from a program, using \`nm' or equivalent, but libtool could" + echo "*** not find such a program. So, this module is probably useless." + echo "*** \`nm' from GNU binutils and a full rebuild may help." + fi + if test "$build_old_libs" = no; then + oldlibs="$output_objdir/$libname.$libext" + build_libtool_libs=module + build_old_libs=yes + else + build_libtool_libs=no + fi + else + echo "*** The inter-library dependencies that have been dropped here will be" + echo "*** automatically added whenever a program is linked with this library" + echo "*** or is declared to -dlopen it." + + if test "$allow_undefined" = no; then + echo + echo "*** Since this library must not contain undefined symbols," + echo "*** because either the platform does not support them or" + echo "*** it was explicitly requested with -no-undefined," + echo "*** libtool will only create a static version of it." + if test "$build_old_libs" = no; then + oldlibs="$output_objdir/$libname.$libext" + build_libtool_libs=module + build_old_libs=yes + else + build_libtool_libs=no + fi + fi + fi + fi + # Done checking deplibs! + deplibs=$newdeplibs + fi + # Time to change all our "foo.ltframework" stuff back to "-framework foo" + case $host in + *-*-darwin*) + newdeplibs=`$ECHO " $newdeplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'` + new_inherited_linker_flags=`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'` + deplibs=`$ECHO " $deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'` + ;; + esac + + # move library search paths that coincide with paths to not yet + # installed libraries to the beginning of the library search list + new_libs= + for path in $notinst_path; do + case " $new_libs " in + *" -L$path/$objdir "*) ;; + *) + case " $deplibs " in + *" -L$path/$objdir "*) + new_libs+=" -L$path/$objdir" ;; + esac + ;; + esac + done + for deplib in $deplibs; do + case $deplib in + -L*) + case " $new_libs " in + *" $deplib "*) ;; + *) new_libs+=" $deplib" ;; + esac + ;; + *) new_libs+=" $deplib" ;; + esac + done + deplibs="$new_libs" + + # All the library-specific variables (install_libdir is set above). + library_names= + old_library= + dlname= + + # Test again, we may have decided not to build it any more + if test "$build_libtool_libs" = yes; then + # Remove ${wl} instances when linking with ld. + # FIXME: should test the right _cmds variable. + case $archive_cmds in + *\$LD\ *) wl= ;; + esac + if test "$hardcode_into_libs" = yes; then + # Hardcode the library paths + hardcode_libdirs= + dep_rpath= + rpath="$finalize_rpath" + test "$opt_mode" != relink && rpath="$compile_rpath$rpath" + for libdir in $rpath; do + if test -n "$hardcode_libdir_flag_spec"; then + if test -n "$hardcode_libdir_separator"; then + func_replace_sysroot "$libdir" + libdir=$func_replace_sysroot_result + if test -z "$hardcode_libdirs"; then + hardcode_libdirs="$libdir" + else + # Just accumulate the unique libdirs. + case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in + *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*) + ;; + *) + hardcode_libdirs+="$hardcode_libdir_separator$libdir" + ;; + esac + fi + else + eval flag=\"$hardcode_libdir_flag_spec\" + dep_rpath+=" $flag" + fi + elif test -n "$runpath_var"; then + case "$perm_rpath " in + *" $libdir "*) ;; + *) perm_rpath+=" $libdir" ;; + esac + fi + done + # Substitute the hardcoded libdirs into the rpath. + if test -n "$hardcode_libdir_separator" && + test -n "$hardcode_libdirs"; then + libdir="$hardcode_libdirs" + eval "dep_rpath=\"$hardcode_libdir_flag_spec\"" + fi + if test -n "$runpath_var" && test -n "$perm_rpath"; then + # We should set the runpath_var. + rpath= + for dir in $perm_rpath; do + rpath+="$dir:" + done + eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var" + fi + test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs" + fi + + shlibpath="$finalize_shlibpath" + test "$opt_mode" != relink && shlibpath="$compile_shlibpath$shlibpath" + if test -n "$shlibpath"; then + eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var" + fi + + # Get the real and link names of the library. + eval shared_ext=\"$shrext_cmds\" + eval library_names=\"$library_names_spec\" + set dummy $library_names + shift + realname="$1" + shift + + if test -n "$soname_spec"; then + eval soname=\"$soname_spec\" + else + soname="$realname" + fi + if test -z "$dlname"; then + dlname=$soname + fi + + lib="$output_objdir/$realname" + linknames= + for link + do + linknames+=" $link" + done + + # Use standard objects if they are pic + test -z "$pic_flag" && libobjs=`$ECHO "$libobjs" | $SP2NL | $SED "$lo2o" | $NL2SP` + test "X$libobjs" = "X " && libobjs= + + delfiles= + if test -n "$export_symbols" && test -n "$include_expsyms"; then + $opt_dry_run || cp "$export_symbols" "$output_objdir/$libname.uexp" + export_symbols="$output_objdir/$libname.uexp" + delfiles+=" $export_symbols" + fi + + orig_export_symbols= + case $host_os in + cygwin* | mingw* | cegcc*) + if test -n "$export_symbols" && test -z "$export_symbols_regex"; then + # exporting using user supplied symfile + if test "x`$SED 1q $export_symbols`" != xEXPORTS; then + # and it's NOT already a .def file. Must figure out + # which of the given symbols are data symbols and tag + # them as such. So, trigger use of export_symbols_cmds. + # export_symbols gets reassigned inside the "prepare + # the list of exported symbols" if statement, so the + # include_expsyms logic still works. + orig_export_symbols="$export_symbols" + export_symbols= + always_export_symbols=yes + fi + fi + ;; + esac + + # Prepare the list of exported symbols + if test -z "$export_symbols"; then + if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then + func_verbose "generating symbol list for \`$libname.la'" + export_symbols="$output_objdir/$libname.exp" + $opt_dry_run || $RM $export_symbols + cmds=$export_symbols_cmds + save_ifs="$IFS"; IFS='~' + for cmd1 in $cmds; do + IFS="$save_ifs" + # Take the normal branch if the nm_file_list_spec branch + # doesn't work or if tool conversion is not needed. + case $nm_file_list_spec~$to_tool_file_cmd in + *~func_convert_file_noop | *~func_convert_file_msys_to_w32 | ~*) + try_normal_branch=yes + eval cmd=\"$cmd1\" + func_len " $cmd" + len=$func_len_result + ;; + *) + try_normal_branch=no + ;; + esac + if test "$try_normal_branch" = yes \ + && { test "$len" -lt "$max_cmd_len" \ + || test "$max_cmd_len" -le -1; } + then + func_show_eval "$cmd" 'exit $?' + skipped_export=false + elif test -n "$nm_file_list_spec"; then + func_basename "$output" + output_la=$func_basename_result + save_libobjs=$libobjs + save_output=$output + output=${output_objdir}/${output_la}.nm + func_to_tool_file "$output" + libobjs=$nm_file_list_spec$func_to_tool_file_result + delfiles+=" $output" + func_verbose "creating $NM input file list: $output" + for obj in $save_libobjs; do + func_to_tool_file "$obj" + $ECHO "$func_to_tool_file_result" + done > "$output" + eval cmd=\"$cmd1\" + func_show_eval "$cmd" 'exit $?' + output=$save_output + libobjs=$save_libobjs + skipped_export=false + else + # The command line is too long to execute in one step. + func_verbose "using reloadable object file for export list..." + skipped_export=: + # Break out early, otherwise skipped_export may be + # set to false by a later but shorter cmd. + break + fi + done + IFS="$save_ifs" + if test -n "$export_symbols_regex" && test "X$skipped_export" != "X:"; then + func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"' + func_show_eval '$MV "${export_symbols}T" "$export_symbols"' + fi + fi + fi + + if test -n "$export_symbols" && test -n "$include_expsyms"; then + tmp_export_symbols="$export_symbols" + test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols" + $opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"' + fi + + if test "X$skipped_export" != "X:" && test -n "$orig_export_symbols"; then + # The given exports_symbols file has to be filtered, so filter it. + func_verbose "filter symbol list for \`$libname.la' to tag DATA exports" + # FIXME: $output_objdir/$libname.filter potentially contains lots of + # 's' commands which not all seds can handle. GNU sed should be fine + # though. Also, the filter scales superlinearly with the number of + # global variables. join(1) would be nice here, but unfortunately + # isn't a blessed tool. + $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter + delfiles+=" $export_symbols $output_objdir/$libname.filter" + export_symbols=$output_objdir/$libname.def + $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols + fi + + tmp_deplibs= + for test_deplib in $deplibs; do + case " $convenience " in + *" $test_deplib "*) ;; + *) + tmp_deplibs+=" $test_deplib" + ;; + esac + done + deplibs="$tmp_deplibs" + + if test -n "$convenience"; then + if test -n "$whole_archive_flag_spec" && + test "$compiler_needs_object" = yes && + test -z "$libobjs"; then + # extract the archives, so we have objects to list. + # TODO: could optimize this to just extract one archive. + whole_archive_flag_spec= + fi + if test -n "$whole_archive_flag_spec"; then + save_libobjs=$libobjs + eval libobjs=\"\$libobjs $whole_archive_flag_spec\" + test "X$libobjs" = "X " && libobjs= + else + gentop="$output_objdir/${outputname}x" + generated+=" $gentop" + + func_extract_archives $gentop $convenience + libobjs+=" $func_extract_archives_result" + test "X$libobjs" = "X " && libobjs= + fi + fi + + if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then + eval flag=\"$thread_safe_flag_spec\" + linker_flags+=" $flag" + fi + + # Make a backup of the uninstalled library when relinking + if test "$opt_mode" = relink; then + $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}U && $MV $realname ${realname}U)' || exit $? + fi + + # Do each of the archive commands. + if test "$module" = yes && test -n "$module_cmds" ; then + if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then + eval test_cmds=\"$module_expsym_cmds\" + cmds=$module_expsym_cmds + else + eval test_cmds=\"$module_cmds\" + cmds=$module_cmds + fi + else + if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then + eval test_cmds=\"$archive_expsym_cmds\" + cmds=$archive_expsym_cmds + else + eval test_cmds=\"$archive_cmds\" + cmds=$archive_cmds + fi + fi + + if test "X$skipped_export" != "X:" && + func_len " $test_cmds" && + len=$func_len_result && + test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then + : + else + # The command line is too long to link in one step, link piecewise + # or, if using GNU ld and skipped_export is not :, use a linker + # script. + + # Save the value of $output and $libobjs because we want to + # use them later. If we have whole_archive_flag_spec, we + # want to use save_libobjs as it was before + # whole_archive_flag_spec was expanded, because we can't + # assume the linker understands whole_archive_flag_spec. + # This may have to be revisited, in case too many + # convenience libraries get linked in and end up exceeding + # the spec. + if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then + save_libobjs=$libobjs + fi + save_output=$output + func_basename "$output" + output_la=$func_basename_result + + # Clear the reloadable object creation command queue and + # initialize k to one. + test_cmds= + concat_cmds= + objlist= + last_robj= + k=1 + + if test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "$with_gnu_ld" = yes; then + output=${output_objdir}/${output_la}.lnkscript + func_verbose "creating GNU ld script: $output" + echo 'INPUT (' > $output + for obj in $save_libobjs + do + func_to_tool_file "$obj" + $ECHO "$func_to_tool_file_result" >> $output + done + echo ')' >> $output + delfiles+=" $output" + func_to_tool_file "$output" + output=$func_to_tool_file_result + elif test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "X$file_list_spec" != X; then + output=${output_objdir}/${output_la}.lnk + func_verbose "creating linker input file list: $output" + : > $output + set x $save_libobjs + shift + firstobj= + if test "$compiler_needs_object" = yes; then + firstobj="$1 " + shift + fi + for obj + do + func_to_tool_file "$obj" + $ECHO "$func_to_tool_file_result" >> $output + done + delfiles+=" $output" + func_to_tool_file "$output" + output=$firstobj\"$file_list_spec$func_to_tool_file_result\" + else + if test -n "$save_libobjs"; then + func_verbose "creating reloadable object files..." + output=$output_objdir/$output_la-${k}.$objext + eval test_cmds=\"$reload_cmds\" + func_len " $test_cmds" + len0=$func_len_result + len=$len0 + + # Loop over the list of objects to be linked. + for obj in $save_libobjs + do + func_len " $obj" + func_arith $len + $func_len_result + len=$func_arith_result + if test "X$objlist" = X || + test "$len" -lt "$max_cmd_len"; then + objlist+=" $obj" + else + # The command $test_cmds is almost too long, add a + # command to the queue. + if test "$k" -eq 1 ; then + # The first file doesn't have a previous command to add. + reload_objs=$objlist + eval concat_cmds=\"$reload_cmds\" + else + # All subsequent reloadable object files will link in + # the last one created. + reload_objs="$objlist $last_robj" + eval concat_cmds=\"\$concat_cmds~$reload_cmds~\$RM $last_robj\" + fi + last_robj=$output_objdir/$output_la-${k}.$objext + func_arith $k + 1 + k=$func_arith_result + output=$output_objdir/$output_la-${k}.$objext + objlist=" $obj" + func_len " $last_robj" + func_arith $len0 + $func_len_result + len=$func_arith_result + fi + done + # Handle the remaining objects by creating one last + # reloadable object file. All subsequent reloadable object + # files will link in the last one created. + test -z "$concat_cmds" || concat_cmds=$concat_cmds~ + reload_objs="$objlist $last_robj" + eval concat_cmds=\"\${concat_cmds}$reload_cmds\" + if test -n "$last_robj"; then + eval concat_cmds=\"\${concat_cmds}~\$RM $last_robj\" + fi + delfiles+=" $output" + + else + output= + fi + + if ${skipped_export-false}; then + func_verbose "generating symbol list for \`$libname.la'" + export_symbols="$output_objdir/$libname.exp" + $opt_dry_run || $RM $export_symbols + libobjs=$output + # Append the command to create the export file. + test -z "$concat_cmds" || concat_cmds=$concat_cmds~ + eval concat_cmds=\"\$concat_cmds$export_symbols_cmds\" + if test -n "$last_robj"; then + eval concat_cmds=\"\$concat_cmds~\$RM $last_robj\" + fi + fi + + test -n "$save_libobjs" && + func_verbose "creating a temporary reloadable object file: $output" + + # Loop through the commands generated above and execute them. + save_ifs="$IFS"; IFS='~' + for cmd in $concat_cmds; do + IFS="$save_ifs" + $opt_silent || { + func_quote_for_expand "$cmd" + eval "func_echo $func_quote_for_expand_result" + } + $opt_dry_run || eval "$cmd" || { + lt_exit=$? + + # Restore the uninstalled library and exit + if test "$opt_mode" = relink; then + ( cd "$output_objdir" && \ + $RM "${realname}T" && \ + $MV "${realname}U" "$realname" ) + fi + + exit $lt_exit + } + done + IFS="$save_ifs" + + if test -n "$export_symbols_regex" && ${skipped_export-false}; then + func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"' + func_show_eval '$MV "${export_symbols}T" "$export_symbols"' + fi + fi + + if ${skipped_export-false}; then + if test -n "$export_symbols" && test -n "$include_expsyms"; then + tmp_export_symbols="$export_symbols" + test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols" + $opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"' + fi + + if test -n "$orig_export_symbols"; then + # The given exports_symbols file has to be filtered, so filter it. + func_verbose "filter symbol list for \`$libname.la' to tag DATA exports" + # FIXME: $output_objdir/$libname.filter potentially contains lots of + # 's' commands which not all seds can handle. GNU sed should be fine + # though. Also, the filter scales superlinearly with the number of + # global variables. join(1) would be nice here, but unfortunately + # isn't a blessed tool. + $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter + delfiles+=" $export_symbols $output_objdir/$libname.filter" + export_symbols=$output_objdir/$libname.def + $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols + fi + fi + + libobjs=$output + # Restore the value of output. + output=$save_output + + if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then + eval libobjs=\"\$libobjs $whole_archive_flag_spec\" + test "X$libobjs" = "X " && libobjs= + fi + # Expand the library linking commands again to reset the + # value of $libobjs for piecewise linking. + + # Do each of the archive commands. + if test "$module" = yes && test -n "$module_cmds" ; then + if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then + cmds=$module_expsym_cmds + else + cmds=$module_cmds + fi + else + if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then + cmds=$archive_expsym_cmds + else + cmds=$archive_cmds + fi + fi + fi + + if test -n "$delfiles"; then + # Append the command to remove temporary files to $cmds. + eval cmds=\"\$cmds~\$RM $delfiles\" + fi + + # Add any objects from preloaded convenience libraries + if test -n "$dlprefiles"; then + gentop="$output_objdir/${outputname}x" + generated+=" $gentop" + + func_extract_archives $gentop $dlprefiles + libobjs+=" $func_extract_archives_result" + test "X$libobjs" = "X " && libobjs= + fi + + save_ifs="$IFS"; IFS='~' + for cmd in $cmds; do + IFS="$save_ifs" + eval cmd=\"$cmd\" + $opt_silent || { + func_quote_for_expand "$cmd" + eval "func_echo $func_quote_for_expand_result" + } + $opt_dry_run || eval "$cmd" || { + lt_exit=$? + + # Restore the uninstalled library and exit + if test "$opt_mode" = relink; then + ( cd "$output_objdir" && \ + $RM "${realname}T" && \ + $MV "${realname}U" "$realname" ) + fi + + exit $lt_exit + } + done + IFS="$save_ifs" + + # Restore the uninstalled library and exit + if test "$opt_mode" = relink; then + $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}T && $MV $realname ${realname}T && $MV ${realname}U $realname)' || exit $? + + if test -n "$convenience"; then + if test -z "$whole_archive_flag_spec"; then + func_show_eval '${RM}r "$gentop"' + fi + fi + + exit $EXIT_SUCCESS + fi + + # Create links to the real library. + for linkname in $linknames; do + if test "$realname" != "$linkname"; then + func_show_eval '(cd "$output_objdir" && $RM "$linkname" && $LN_S "$realname" "$linkname")' 'exit $?' + fi + done + + # If -module or -export-dynamic was specified, set the dlname. + if test "$module" = yes || test "$export_dynamic" = yes; then + # On all known operating systems, these are identical. + dlname="$soname" + fi + fi + ;; + + obj) + if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then + func_warning "\`-dlopen' is ignored for objects" + fi + + case " $deplibs" in + *\ -l* | *\ -L*) + func_warning "\`-l' and \`-L' are ignored for objects" ;; + esac + + test -n "$rpath" && \ + func_warning "\`-rpath' is ignored for objects" + + test -n "$xrpath" && \ + func_warning "\`-R' is ignored for objects" + + test -n "$vinfo" && \ + func_warning "\`-version-info' is ignored for objects" + + test -n "$release" && \ + func_warning "\`-release' is ignored for objects" + + case $output in + *.lo) + test -n "$objs$old_deplibs" && \ + func_fatal_error "cannot build library object \`$output' from non-libtool objects" + + libobj=$output + func_lo2o "$libobj" + obj=$func_lo2o_result + ;; + *) + libobj= + obj="$output" + ;; + esac + + # Delete the old objects. + $opt_dry_run || $RM $obj $libobj + + # Objects from convenience libraries. This assumes + # single-version convenience libraries. Whenever we create + # different ones for PIC/non-PIC, this we'll have to duplicate + # the extraction. + reload_conv_objs= + gentop= + # reload_cmds runs $LD directly, so let us get rid of + # -Wl from whole_archive_flag_spec and hope we can get by with + # turning comma into space.. + wl= + + if test -n "$convenience"; then + if test -n "$whole_archive_flag_spec"; then + eval tmp_whole_archive_flags=\"$whole_archive_flag_spec\" + reload_conv_objs=$reload_objs\ `$ECHO "$tmp_whole_archive_flags" | $SED 's|,| |g'` + else + gentop="$output_objdir/${obj}x" + generated+=" $gentop" + + func_extract_archives $gentop $convenience + reload_conv_objs="$reload_objs $func_extract_archives_result" + fi + fi + + # If we're not building shared, we need to use non_pic_objs + test "$build_libtool_libs" != yes && libobjs="$non_pic_objects" + + # Create the old-style object. + reload_objs="$objs$old_deplibs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; /\.lib$/d; $lo2o" | $NL2SP`" $reload_conv_objs" ### testsuite: skip nested quoting test + + output="$obj" + func_execute_cmds "$reload_cmds" 'exit $?' + + # Exit if we aren't doing a library object file. + if test -z "$libobj"; then + if test -n "$gentop"; then + func_show_eval '${RM}r "$gentop"' + fi + + exit $EXIT_SUCCESS + fi + + if test "$build_libtool_libs" != yes; then + if test -n "$gentop"; then + func_show_eval '${RM}r "$gentop"' + fi + + # Create an invalid libtool object if no PIC, so that we don't + # accidentally link it into a program. + # $show "echo timestamp > $libobj" + # $opt_dry_run || eval "echo timestamp > $libobj" || exit $? + exit $EXIT_SUCCESS + fi + + if test -n "$pic_flag" || test "$pic_mode" != default; then + # Only do commands if we really have different PIC objects. + reload_objs="$libobjs $reload_conv_objs" + output="$libobj" + func_execute_cmds "$reload_cmds" 'exit $?' + fi + + if test -n "$gentop"; then + func_show_eval '${RM}r "$gentop"' + fi + + exit $EXIT_SUCCESS + ;; + + prog) + case $host in + *cygwin*) func_stripname '' '.exe' "$output" + output=$func_stripname_result.exe;; + esac + test -n "$vinfo" && \ + func_warning "\`-version-info' is ignored for programs" + + test -n "$release" && \ + func_warning "\`-release' is ignored for programs" + + test "$preload" = yes \ + && test "$dlopen_support" = unknown \ + && test "$dlopen_self" = unknown \ + && test "$dlopen_self_static" = unknown && \ + func_warning "\`LT_INIT([dlopen])' not used. Assuming no dlopen support." + + case $host in + *-*-rhapsody* | *-*-darwin1.[012]) + # On Rhapsody replace the C library is the System framework + compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's/ -lc / System.ltframework /'` + finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's/ -lc / System.ltframework /'` + ;; + esac + + case $host in + *-*-darwin*) + # Don't allow lazy linking, it breaks C++ global constructors + # But is supposedly fixed on 10.4 or later (yay!). + if test "$tagname" = CXX ; then + case ${MACOSX_DEPLOYMENT_TARGET-10.0} in + 10.[0123]) + compile_command+=" ${wl}-bind_at_load" + finalize_command+=" ${wl}-bind_at_load" + ;; + esac + fi + # Time to change all our "foo.ltframework" stuff back to "-framework foo" + compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'` + finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'` + ;; + esac + + + # move library search paths that coincide with paths to not yet + # installed libraries to the beginning of the library search list + new_libs= + for path in $notinst_path; do + case " $new_libs " in + *" -L$path/$objdir "*) ;; + *) + case " $compile_deplibs " in + *" -L$path/$objdir "*) + new_libs+=" -L$path/$objdir" ;; + esac + ;; + esac + done + for deplib in $compile_deplibs; do + case $deplib in + -L*) + case " $new_libs " in + *" $deplib "*) ;; + *) new_libs+=" $deplib" ;; + esac + ;; + *) new_libs+=" $deplib" ;; + esac + done + compile_deplibs="$new_libs" + + + compile_command+=" $compile_deplibs" + finalize_command+=" $finalize_deplibs" + + if test -n "$rpath$xrpath"; then + # If the user specified any rpath flags, then add them. + for libdir in $rpath $xrpath; do + # This is the magic to use -rpath. + case "$finalize_rpath " in + *" $libdir "*) ;; + *) finalize_rpath+=" $libdir" ;; + esac + done + fi + + # Now hardcode the library paths + rpath= + hardcode_libdirs= + for libdir in $compile_rpath $finalize_rpath; do + if test -n "$hardcode_libdir_flag_spec"; then + if test -n "$hardcode_libdir_separator"; then + if test -z "$hardcode_libdirs"; then + hardcode_libdirs="$libdir" + else + # Just accumulate the unique libdirs. + case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in + *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*) + ;; + *) + hardcode_libdirs+="$hardcode_libdir_separator$libdir" + ;; + esac + fi + else + eval flag=\"$hardcode_libdir_flag_spec\" + rpath+=" $flag" + fi + elif test -n "$runpath_var"; then + case "$perm_rpath " in + *" $libdir "*) ;; + *) perm_rpath+=" $libdir" ;; + esac + fi + case $host in + *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*) + testbindir=`${ECHO} "$libdir" | ${SED} -e 's*/lib$*/bin*'` + case :$dllsearchpath: in + *":$libdir:"*) ;; + ::) dllsearchpath=$libdir;; + *) dllsearchpath+=":$libdir";; + esac + case :$dllsearchpath: in + *":$testbindir:"*) ;; + ::) dllsearchpath=$testbindir;; + *) dllsearchpath+=":$testbindir";; + esac + ;; + esac + done + # Substitute the hardcoded libdirs into the rpath. + if test -n "$hardcode_libdir_separator" && + test -n "$hardcode_libdirs"; then + libdir="$hardcode_libdirs" + eval rpath=\" $hardcode_libdir_flag_spec\" + fi + compile_rpath="$rpath" + + rpath= + hardcode_libdirs= + for libdir in $finalize_rpath; do + if test -n "$hardcode_libdir_flag_spec"; then + if test -n "$hardcode_libdir_separator"; then + if test -z "$hardcode_libdirs"; then + hardcode_libdirs="$libdir" + else + # Just accumulate the unique libdirs. + case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in + *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*) + ;; + *) + hardcode_libdirs+="$hardcode_libdir_separator$libdir" + ;; + esac + fi + else + eval flag=\"$hardcode_libdir_flag_spec\" + rpath+=" $flag" + fi + elif test -n "$runpath_var"; then + case "$finalize_perm_rpath " in + *" $libdir "*) ;; + *) finalize_perm_rpath+=" $libdir" ;; + esac + fi + done + # Substitute the hardcoded libdirs into the rpath. + if test -n "$hardcode_libdir_separator" && + test -n "$hardcode_libdirs"; then + libdir="$hardcode_libdirs" + eval rpath=\" $hardcode_libdir_flag_spec\" + fi + finalize_rpath="$rpath" + + if test -n "$libobjs" && test "$build_old_libs" = yes; then + # Transform all the library objects into standard objects. + compile_command=`$ECHO "$compile_command" | $SP2NL | $SED "$lo2o" | $NL2SP` + finalize_command=`$ECHO "$finalize_command" | $SP2NL | $SED "$lo2o" | $NL2SP` + fi + + func_generate_dlsyms "$outputname" "@PROGRAM@" "no" + + # template prelinking step + if test -n "$prelink_cmds"; then + func_execute_cmds "$prelink_cmds" 'exit $?' + fi + + wrappers_required=yes + case $host in + *cegcc* | *mingw32ce*) + # Disable wrappers for cegcc and mingw32ce hosts, we are cross compiling anyway. + wrappers_required=no + ;; + *cygwin* | *mingw* ) + if test "$build_libtool_libs" != yes; then + wrappers_required=no + fi + ;; + *) + if test "$need_relink" = no || test "$build_libtool_libs" != yes; then + wrappers_required=no + fi + ;; + esac + if test "$wrappers_required" = no; then + # Replace the output file specification. + compile_command=`$ECHO "$compile_command" | $SED 's%@OUTPUT@%'"$output"'%g'` + link_command="$compile_command$compile_rpath" + + # We have no uninstalled library dependencies, so finalize right now. + exit_status=0 + func_show_eval "$link_command" 'exit_status=$?' + + if test -n "$postlink_cmds"; then + func_to_tool_file "$output" + postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'` + func_execute_cmds "$postlink_cmds" 'exit $?' + fi + + # Delete the generated files. + if test -f "$output_objdir/${outputname}S.${objext}"; then + func_show_eval '$RM "$output_objdir/${outputname}S.${objext}"' + fi + + exit $exit_status + fi + + if test -n "$compile_shlibpath$finalize_shlibpath"; then + compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command" + fi + if test -n "$finalize_shlibpath"; then + finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command" + fi + + compile_var= + finalize_var= + if test -n "$runpath_var"; then + if test -n "$perm_rpath"; then + # We should set the runpath_var. + rpath= + for dir in $perm_rpath; do + rpath+="$dir:" + done + compile_var="$runpath_var=\"$rpath\$$runpath_var\" " + fi + if test -n "$finalize_perm_rpath"; then + # We should set the runpath_var. + rpath= + for dir in $finalize_perm_rpath; do + rpath+="$dir:" + done + finalize_var="$runpath_var=\"$rpath\$$runpath_var\" " + fi + fi + + if test "$no_install" = yes; then + # We don't need to create a wrapper script. + link_command="$compile_var$compile_command$compile_rpath" + # Replace the output file specification. + link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output"'%g'` + # Delete the old output file. + $opt_dry_run || $RM $output + # Link the executable and exit + func_show_eval "$link_command" 'exit $?' + + if test -n "$postlink_cmds"; then + func_to_tool_file "$output" + postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'` + func_execute_cmds "$postlink_cmds" 'exit $?' + fi + + exit $EXIT_SUCCESS + fi + + if test "$hardcode_action" = relink; then + # Fast installation is not supported + link_command="$compile_var$compile_command$compile_rpath" + relink_command="$finalize_var$finalize_command$finalize_rpath" + + func_warning "this platform does not like uninstalled shared libraries" + func_warning "\`$output' will be relinked during installation" + else + if test "$fast_install" != no; then + link_command="$finalize_var$compile_command$finalize_rpath" + if test "$fast_install" = yes; then + relink_command=`$ECHO "$compile_var$compile_command$compile_rpath" | $SED 's%@OUTPUT@%\$progdir/\$file%g'` + else + # fast_install is set to needless + relink_command= + fi + else + link_command="$compile_var$compile_command$compile_rpath" + relink_command="$finalize_var$finalize_command$finalize_rpath" + fi + fi + + # Replace the output file specification. + link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'` + + # Delete the old output files. + $opt_dry_run || $RM $output $output_objdir/$outputname $output_objdir/lt-$outputname + + func_show_eval "$link_command" 'exit $?' + + if test -n "$postlink_cmds"; then + func_to_tool_file "$output_objdir/$outputname" + postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'` + func_execute_cmds "$postlink_cmds" 'exit $?' + fi + + # Now create the wrapper script. + func_verbose "creating $output" + + # Quote the relink command for shipping. + if test -n "$relink_command"; then + # Preserve any variables that may affect compiler behavior + for var in $variables_saved_for_relink; do + if eval test -z \"\${$var+set}\"; then + relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command" + elif eval var_value=\$$var; test -z "$var_value"; then + relink_command="$var=; export $var; $relink_command" + else + func_quote_for_eval "$var_value" + relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command" + fi + done + relink_command="(cd `pwd`; $relink_command)" + relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"` + fi + + # Only actually do things if not in dry run mode. + $opt_dry_run || { + # win32 will think the script is a binary if it has + # a .exe suffix, so we strip it off here. + case $output in + *.exe) func_stripname '' '.exe' "$output" + output=$func_stripname_result ;; + esac + # test for cygwin because mv fails w/o .exe extensions + case $host in + *cygwin*) + exeext=.exe + func_stripname '' '.exe' "$outputname" + outputname=$func_stripname_result ;; + *) exeext= ;; + esac + case $host in + *cygwin* | *mingw* ) + func_dirname_and_basename "$output" "" "." + output_name=$func_basename_result + output_path=$func_dirname_result + cwrappersource="$output_path/$objdir/lt-$output_name.c" + cwrapper="$output_path/$output_name.exe" + $RM $cwrappersource $cwrapper + trap "$RM $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15 + + func_emit_cwrapperexe_src > $cwrappersource + + # The wrapper executable is built using the $host compiler, + # because it contains $host paths and files. If cross- + # compiling, it, like the target executable, must be + # executed on the $host or under an emulation environment. + $opt_dry_run || { + $LTCC $LTCFLAGS -o $cwrapper $cwrappersource + $STRIP $cwrapper + } + + # Now, create the wrapper script for func_source use: + func_ltwrapper_scriptname $cwrapper + $RM $func_ltwrapper_scriptname_result + trap "$RM $func_ltwrapper_scriptname_result; exit $EXIT_FAILURE" 1 2 15 + $opt_dry_run || { + # note: this script will not be executed, so do not chmod. + if test "x$build" = "x$host" ; then + $cwrapper --lt-dump-script > $func_ltwrapper_scriptname_result + else + func_emit_wrapper no > $func_ltwrapper_scriptname_result + fi + } + ;; + * ) + $RM $output + trap "$RM $output; exit $EXIT_FAILURE" 1 2 15 + + func_emit_wrapper no > $output + chmod +x $output + ;; + esac + } + exit $EXIT_SUCCESS + ;; + esac + + # See if we need to build an old-fashioned archive. + for oldlib in $oldlibs; do + + if test "$build_libtool_libs" = convenience; then + oldobjs="$libobjs_save $symfileobj" + addlibs="$convenience" + build_libtool_libs=no + else + if test "$build_libtool_libs" = module; then + oldobjs="$libobjs_save" + build_libtool_libs=no + else + oldobjs="$old_deplibs $non_pic_objects" + if test "$preload" = yes && test -f "$symfileobj"; then + oldobjs+=" $symfileobj" + fi + fi + addlibs="$old_convenience" + fi + + if test -n "$addlibs"; then + gentop="$output_objdir/${outputname}x" + generated+=" $gentop" + + func_extract_archives $gentop $addlibs + oldobjs+=" $func_extract_archives_result" + fi + + # Do each command in the archive commands. + if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then + cmds=$old_archive_from_new_cmds + else + + # Add any objects from preloaded convenience libraries + if test -n "$dlprefiles"; then + gentop="$output_objdir/${outputname}x" + generated+=" $gentop" + + func_extract_archives $gentop $dlprefiles + oldobjs+=" $func_extract_archives_result" + fi + + # POSIX demands no paths to be encoded in archives. We have + # to avoid creating archives with duplicate basenames if we + # might have to extract them afterwards, e.g., when creating a + # static archive out of a convenience library, or when linking + # the entirety of a libtool archive into another (currently + # not supported by libtool). + if (for obj in $oldobjs + do + func_basename "$obj" + $ECHO "$func_basename_result" + done | sort | sort -uc >/dev/null 2>&1); then + : + else + echo "copying selected object files to avoid basename conflicts..." + gentop="$output_objdir/${outputname}x" + generated+=" $gentop" + func_mkdir_p "$gentop" + save_oldobjs=$oldobjs + oldobjs= + counter=1 + for obj in $save_oldobjs + do + func_basename "$obj" + objbase="$func_basename_result" + case " $oldobjs " in + " ") oldobjs=$obj ;; + *[\ /]"$objbase "*) + while :; do + # Make sure we don't pick an alternate name that also + # overlaps. + newobj=lt$counter-$objbase + func_arith $counter + 1 + counter=$func_arith_result + case " $oldobjs " in + *[\ /]"$newobj "*) ;; + *) if test ! -f "$gentop/$newobj"; then break; fi ;; + esac + done + func_show_eval "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj" + oldobjs+=" $gentop/$newobj" + ;; + *) oldobjs+=" $obj" ;; + esac + done + fi + func_to_tool_file "$oldlib" func_convert_file_msys_to_w32 + tool_oldlib=$func_to_tool_file_result + eval cmds=\"$old_archive_cmds\" + + func_len " $cmds" + len=$func_len_result + if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then + cmds=$old_archive_cmds + elif test -n "$archiver_list_spec"; then + func_verbose "using command file archive linking..." + for obj in $oldobjs + do + func_to_tool_file "$obj" + $ECHO "$func_to_tool_file_result" + done > $output_objdir/$libname.libcmd + func_to_tool_file "$output_objdir/$libname.libcmd" + oldobjs=" $archiver_list_spec$func_to_tool_file_result" + cmds=$old_archive_cmds + else + # the command line is too long to link in one step, link in parts + func_verbose "using piecewise archive linking..." + save_RANLIB=$RANLIB + RANLIB=: + objlist= + concat_cmds= + save_oldobjs=$oldobjs + oldobjs= + # Is there a better way of finding the last object in the list? + for obj in $save_oldobjs + do + last_oldobj=$obj + done + eval test_cmds=\"$old_archive_cmds\" + func_len " $test_cmds" + len0=$func_len_result + len=$len0 + for obj in $save_oldobjs + do + func_len " $obj" + func_arith $len + $func_len_result + len=$func_arith_result + objlist+=" $obj" + if test "$len" -lt "$max_cmd_len"; then + : + else + # the above command should be used before it gets too long + oldobjs=$objlist + if test "$obj" = "$last_oldobj" ; then + RANLIB=$save_RANLIB + fi + test -z "$concat_cmds" || concat_cmds=$concat_cmds~ + eval concat_cmds=\"\${concat_cmds}$old_archive_cmds\" + objlist= + len=$len0 + fi + done + RANLIB=$save_RANLIB + oldobjs=$objlist + if test "X$oldobjs" = "X" ; then + eval cmds=\"\$concat_cmds\" + else + eval cmds=\"\$concat_cmds~\$old_archive_cmds\" + fi + fi + fi + func_execute_cmds "$cmds" 'exit $?' + done + + test -n "$generated" && \ + func_show_eval "${RM}r$generated" + + # Now create the libtool archive. + case $output in + *.la) + old_library= + test "$build_old_libs" = yes && old_library="$libname.$libext" + func_verbose "creating $output" + + # Preserve any variables that may affect compiler behavior + for var in $variables_saved_for_relink; do + if eval test -z \"\${$var+set}\"; then + relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command" + elif eval var_value=\$$var; test -z "$var_value"; then + relink_command="$var=; export $var; $relink_command" + else + func_quote_for_eval "$var_value" + relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command" + fi + done + # Quote the link command for shipping. + relink_command="(cd `pwd`; $SHELL $progpath $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)" + relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"` + if test "$hardcode_automatic" = yes ; then + relink_command= + fi + + # Only create the output if not a dry run. + $opt_dry_run || { + for installed in no yes; do + if test "$installed" = yes; then + if test -z "$install_libdir"; then + break + fi + output="$output_objdir/$outputname"i + # Replace all uninstalled libtool libraries with the installed ones + newdependency_libs= + for deplib in $dependency_libs; do + case $deplib in + *.la) + func_basename "$deplib" + name="$func_basename_result" + func_resolve_sysroot "$deplib" + eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $func_resolve_sysroot_result` + test -z "$libdir" && \ + func_fatal_error "\`$deplib' is not a valid libtool archive" + newdependency_libs+=" ${lt_sysroot:+=}$libdir/$name" + ;; + -L*) + func_stripname -L '' "$deplib" + func_replace_sysroot "$func_stripname_result" + newdependency_libs+=" -L$func_replace_sysroot_result" + ;; + -R*) + func_stripname -R '' "$deplib" + func_replace_sysroot "$func_stripname_result" + newdependency_libs+=" -R$func_replace_sysroot_result" + ;; + *) newdependency_libs+=" $deplib" ;; + esac + done + dependency_libs="$newdependency_libs" + newdlfiles= + + for lib in $dlfiles; do + case $lib in + *.la) + func_basename "$lib" + name="$func_basename_result" + eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib` + test -z "$libdir" && \ + func_fatal_error "\`$lib' is not a valid libtool archive" + newdlfiles+=" ${lt_sysroot:+=}$libdir/$name" + ;; + *) newdlfiles+=" $lib" ;; + esac + done + dlfiles="$newdlfiles" + newdlprefiles= + for lib in $dlprefiles; do + case $lib in + *.la) + # Only pass preopened files to the pseudo-archive (for + # eventual linking with the app. that links it) if we + # didn't already link the preopened objects directly into + # the library: + func_basename "$lib" + name="$func_basename_result" + eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib` + test -z "$libdir" && \ + func_fatal_error "\`$lib' is not a valid libtool archive" + newdlprefiles+=" ${lt_sysroot:+=}$libdir/$name" + ;; + esac + done + dlprefiles="$newdlprefiles" + else + newdlfiles= + for lib in $dlfiles; do + case $lib in + [\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;; + *) abs=`pwd`"/$lib" ;; + esac + newdlfiles+=" $abs" + done + dlfiles="$newdlfiles" + newdlprefiles= + for lib in $dlprefiles; do + case $lib in + [\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;; + *) abs=`pwd`"/$lib" ;; + esac + newdlprefiles+=" $abs" + done + dlprefiles="$newdlprefiles" + fi + $RM $output + # place dlname in correct position for cygwin + # In fact, it would be nice if we could use this code for all target + # systems that can't hard-code library paths into their executables + # and that have no shared library path variable independent of PATH, + # but it turns out we can't easily determine that from inspecting + # libtool variables, so we have to hard-code the OSs to which it + # applies here; at the moment, that means platforms that use the PE + # object format with DLL files. See the long comment at the top of + # tests/bindir.at for full details. + tdlname=$dlname + case $host,$output,$installed,$module,$dlname in + *cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll | *cegcc*,*lai,yes,no,*.dll) + # If a -bindir argument was supplied, place the dll there. + if test "x$bindir" != x ; + then + func_relative_path "$install_libdir" "$bindir" + tdlname=$func_relative_path_result$dlname + else + # Otherwise fall back on heuristic. + tdlname=../bin/$dlname + fi + ;; + esac + $ECHO > $output "\ +# $outputname - a libtool library file +# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION +# +# Please DO NOT delete this file! +# It is necessary for linking the library. + +# The name that we can dlopen(3). +dlname='$tdlname' + +# Names of this library. +library_names='$library_names' + +# The name of the static archive. +old_library='$old_library' + +# Linker flags that can not go in dependency_libs. +inherited_linker_flags='$new_inherited_linker_flags' + +# Libraries that this one depends upon. +dependency_libs='$dependency_libs' + +# Names of additional weak libraries provided by this library +weak_library_names='$weak_libs' + +# Version information for $libname. +current=$current +age=$age +revision=$revision + +# Is this an already installed library? +installed=$installed + +# Should we warn about portability when linking against -modules? +shouldnotlink=$module + +# Files to dlopen/dlpreopen +dlopen='$dlfiles' +dlpreopen='$dlprefiles' + +# Directory that this library needs to be installed in: +libdir='$install_libdir'" + if test "$installed" = no && test "$need_relink" = yes; then + $ECHO >> $output "\ +relink_command=\"$relink_command\"" + fi + done + } + + # Do a symbolic link so that the libtool archive can be found in + # LD_LIBRARY_PATH before the program is installed. + func_show_eval '( cd "$output_objdir" && $RM "$outputname" && $LN_S "../$outputname" "$outputname" )' 'exit $?' + ;; + esac + exit $EXIT_SUCCESS +} + +{ test "$opt_mode" = link || test "$opt_mode" = relink; } && + func_mode_link ${1+"$@"} + + +# func_mode_uninstall arg... +func_mode_uninstall () +{ + $opt_debug + RM="$nonopt" + files= + rmforce= + exit_status=0 + + # This variable tells wrapper scripts just to set variables rather + # than running their programs. + libtool_install_magic="$magic" + + for arg + do + case $arg in + -f) RM+=" $arg"; rmforce=yes ;; + -*) RM+=" $arg" ;; + *) files+=" $arg" ;; + esac + done + + test -z "$RM" && \ + func_fatal_help "you must specify an RM program" + + rmdirs= + + for file in $files; do + func_dirname "$file" "" "." + dir="$func_dirname_result" + if test "X$dir" = X.; then + odir="$objdir" + else + odir="$dir/$objdir" + fi + func_basename "$file" + name="$func_basename_result" + test "$opt_mode" = uninstall && odir="$dir" + + # Remember odir for removal later, being careful to avoid duplicates + if test "$opt_mode" = clean; then + case " $rmdirs " in + *" $odir "*) ;; + *) rmdirs+=" $odir" ;; + esac + fi + + # Don't error if the file doesn't exist and rm -f was used. + if { test -L "$file"; } >/dev/null 2>&1 || + { test -h "$file"; } >/dev/null 2>&1 || + test -f "$file"; then + : + elif test -d "$file"; then + exit_status=1 + continue + elif test "$rmforce" = yes; then + continue + fi + + rmfiles="$file" + + case $name in + *.la) + # Possibly a libtool archive, so verify it. + if func_lalib_p "$file"; then + func_source $dir/$name + + # Delete the libtool libraries and symlinks. + for n in $library_names; do + rmfiles+=" $odir/$n" + done + test -n "$old_library" && rmfiles+=" $odir/$old_library" + + case "$opt_mode" in + clean) + case " $library_names " in + *" $dlname "*) ;; + *) test -n "$dlname" && rmfiles+=" $odir/$dlname" ;; + esac + test -n "$libdir" && rmfiles+=" $odir/$name $odir/${name}i" + ;; + uninstall) + if test -n "$library_names"; then + # Do each command in the postuninstall commands. + func_execute_cmds "$postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1' + fi + + if test -n "$old_library"; then + # Do each command in the old_postuninstall commands. + func_execute_cmds "$old_postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1' + fi + # FIXME: should reinstall the best remaining shared library. + ;; + esac + fi + ;; + + *.lo) + # Possibly a libtool object, so verify it. + if func_lalib_p "$file"; then + + # Read the .lo file + func_source $dir/$name + + # Add PIC object to the list of files to remove. + if test -n "$pic_object" && + test "$pic_object" != none; then + rmfiles+=" $dir/$pic_object" + fi + + # Add non-PIC object to the list of files to remove. + if test -n "$non_pic_object" && + test "$non_pic_object" != none; then + rmfiles+=" $dir/$non_pic_object" + fi + fi + ;; + + *) + if test "$opt_mode" = clean ; then + noexename=$name + case $file in + *.exe) + func_stripname '' '.exe' "$file" + file=$func_stripname_result + func_stripname '' '.exe' "$name" + noexename=$func_stripname_result + # $file with .exe has already been added to rmfiles, + # add $file without .exe + rmfiles+=" $file" + ;; + esac + # Do a test to see if this is a libtool program. + if func_ltwrapper_p "$file"; then + if func_ltwrapper_executable_p "$file"; then + func_ltwrapper_scriptname "$file" + relink_command= + func_source $func_ltwrapper_scriptname_result + rmfiles+=" $func_ltwrapper_scriptname_result" + else + relink_command= + func_source $dir/$noexename + fi + + # note $name still contains .exe if it was in $file originally + # as does the version of $file that was added into $rmfiles + rmfiles+=" $odir/$name $odir/${name}S.${objext}" + if test "$fast_install" = yes && test -n "$relink_command"; then + rmfiles+=" $odir/lt-$name" + fi + if test "X$noexename" != "X$name" ; then + rmfiles+=" $odir/lt-${noexename}.c" + fi + fi + fi + ;; + esac + func_show_eval "$RM $rmfiles" 'exit_status=1' + done + + # Try to remove the ${objdir}s in the directories where we deleted files + for dir in $rmdirs; do + if test -d "$dir"; then + func_show_eval "rmdir $dir >/dev/null 2>&1" + fi + done + + exit $exit_status +} + +{ test "$opt_mode" = uninstall || test "$opt_mode" = clean; } && + func_mode_uninstall ${1+"$@"} + +test -z "$opt_mode" && { + help="$generic_help" + func_fatal_help "you must specify a MODE" +} + +test -z "$exec_cmd" && \ + func_fatal_help "invalid operation mode \`$opt_mode'" + +if test -n "$exec_cmd"; then + eval exec "$exec_cmd" + exit $EXIT_FAILURE +fi + +exit $exit_status + + +# The TAGs below are defined such that we never get into a situation +# in which we disable both kinds of libraries. Given conflicting +# choices, we go for a static library, that is the most portable, +# since we can't tell whether shared libraries were disabled because +# the user asked for that or because the platform doesn't support +# them. This is particularly important on AIX, because we don't +# support having both static and shared libraries enabled at the same +# time on that platform, so we default to a shared-only configuration. +# If a disable-shared tag is given, we'll fallback to a static-only +# configuration. But we'll never go from static-only to shared-only. + +# ### BEGIN LIBTOOL TAG CONFIG: disable-shared +build_libtool_libs=no +build_old_libs=yes +# ### END LIBTOOL TAG CONFIG: disable-shared + +# ### BEGIN LIBTOOL TAG CONFIG: disable-static +build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac` +# ### END LIBTOOL TAG CONFIG: disable-static + +# Local Variables: +# mode:shell-script +# sh-indentation:2 +# End: +# vi:sw=2 + + +# ### BEGIN LIBTOOL TAG CONFIG: CXX + +# The linker used to build libraries. +LD="/usr/x86_64-suse-linux/bin/ld -m elf_x86_64" + +# How to create reloadable object files. +reload_flag=" -r" +reload_cmds="\$LD\$reload_flag -o \$output\$reload_objs" + +# Commands used to build an old-style archive. +old_archive_cmds="\$AR \$AR_FLAGS \$oldlib\$oldobjs~\$RANLIB \$tool_oldlib" + +# A language specific compiler. +CC="g++" + +# Is the compiler the GNU compiler? +with_gcc=yes + +# Compiler flag to turn off builtin functions. +no_builtin_flag=" -fno-builtin" + +# Additional compiler flags for building library objects. +pic_flag=" -fPIC -DPIC" + +# How to pass a linker flag through the compiler. +wl="-Wl," + +# Compiler flag to prevent dynamic linking. +link_static_flag="" + +# Does compiler simultaneously support -c and -o options? +compiler_c_o="yes" + +# Whether or not to add -lc for building shared libraries. +build_libtool_need_lc=no + +# Whether or not to disallow shared libs when runtime libs are static. +allow_libtool_libs_with_static_runtimes=no + +# Compiler flag to allow reflexive dlopens. +export_dynamic_flag_spec="\${wl}--export-dynamic" + +# Compiler flag to generate shared objects directly from archives. +whole_archive_flag_spec="\${wl}--whole-archive\$convenience \${wl}--no-whole-archive" + +# Whether the compiler copes with passing no objects directly. +compiler_needs_object="no" + +# Create an old-style archive from a shared archive. +old_archive_from_new_cmds="" + +# Create a temporary old-style archive to link instead of a shared archive. +old_archive_from_expsyms_cmds="" + +# Commands used to build a shared archive. +archive_cmds="\$CC \$pic_flag -shared -nostdlib \$predep_objects \$libobjs \$deplibs \$postdep_objects \$compiler_flags \${wl}-soname \$wl\$soname -o \$lib" +archive_expsym_cmds="\$CC \$pic_flag -shared -nostdlib \$predep_objects \$libobjs \$deplibs \$postdep_objects \$compiler_flags \${wl}-soname \$wl\$soname \${wl}-retain-symbols-file \$wl\$export_symbols -o \$lib" + +# Commands used to build a loadable module if different from building +# a shared archive. +module_cmds="" +module_expsym_cmds="" + +# Whether we are building with GNU ld or not. +with_gnu_ld="yes" + +# Flag that allows shared libraries with undefined symbols to be built. +allow_undefined_flag="" + +# Flag that enforces no undefined symbols. +no_undefined_flag="" + +# Flag to hardcode $libdir into a binary during linking. +# This must work even if $libdir does not exist +hardcode_libdir_flag_spec="\${wl}-rpath \${wl}\$libdir" + +# Whether we need a single "-rpath" flag with a separated argument. +hardcode_libdir_separator="" + +# Set to "yes" if using DIR/libNAME${shared_ext} during linking hardcodes +# DIR into the resulting binary. +hardcode_direct=no + +# Set to "yes" if using DIR/libNAME${shared_ext} during linking hardcodes +# DIR into the resulting binary and the resulting library dependency is +# "absolute",i.e impossible to change by setting ${shlibpath_var} if the +# library is relocated. +hardcode_direct_absolute=no + +# Set to "yes" if using the -LDIR flag during linking hardcodes DIR +# into the resulting binary. +hardcode_minus_L=no + +# Set to "yes" if using SHLIBPATH_VAR=DIR during linking hardcodes DIR +# into the resulting binary. +hardcode_shlibpath_var=unsupported + +# Set to "yes" if building a shared library automatically hardcodes DIR +# into the library and all subsequent libraries and executables linked +# against it. +hardcode_automatic=no + +# Set to yes if linker adds runtime paths of dependent libraries +# to runtime path list. +inherit_rpath=no + +# Whether libtool must link a program against all its dependency libraries. +link_all_deplibs=no + +# Set to "yes" if exported symbols are required. +always_export_symbols=no + +# The commands to list exported symbols. +export_symbols_cmds="\$NM \$libobjs \$convenience | \$global_symbol_pipe | \$SED 's/.* //' | sort | uniq > \$export_symbols" + +# Symbols that should not be listed in the preloaded symbols. +exclude_expsyms="_GLOBAL_OFFSET_TABLE_|_GLOBAL__F[ID]_.*" + +# Symbols that must always be exported. +include_expsyms="" + +# Commands necessary for linking programs (against libraries) with templates. +prelink_cmds="" + +# Commands necessary for finishing linking programs. +postlink_cmds="" + +# Specify filename containing input files. +file_list_spec="" + +# How to hardcode a shared library path into an executable. +hardcode_action=immediate + +# The directories searched by this compiler when creating a shared library. +compiler_lib_search_dirs="/usr/lib64/gcc/x86_64-suse-linux/4.8 /usr/lib64/gcc/x86_64-suse-linux/4.8/../../../../lib64 /lib/../lib64 /usr/lib/../lib64 /usr/lib64/gcc/x86_64-suse-linux/4.8/../../../../x86_64-suse-linux/lib /usr/lib64/gcc/x86_64-suse-linux/4.8/../../.." + +# Dependencies to place before and after the objects being linked to +# create a shared library. +predep_objects="/usr/lib64/gcc/x86_64-suse-linux/4.8/../../../../lib64/crti.o /usr/lib64/gcc/x86_64-suse-linux/4.8/crtbeginS.o" +postdep_objects="/usr/lib64/gcc/x86_64-suse-linux/4.8/crtendS.o /usr/lib64/gcc/x86_64-suse-linux/4.8/../../../../lib64/crtn.o" +predeps="" +postdeps="-lstdc++ -lm -lgcc_s -lc -lgcc_s" + +# The library search path used internally by the compiler when linking +# a shared library. +compiler_lib_search_path="-L/usr/lib64/gcc/x86_64-suse-linux/4.8 -L/usr/lib64/gcc/x86_64-suse-linux/4.8/../../../../lib64 -L/lib/../lib64 -L/usr/lib/../lib64 -L/usr/lib64/gcc/x86_64-suse-linux/4.8/../../../../x86_64-suse-linux/lib -L/usr/lib64/gcc/x86_64-suse-linux/4.8/../../.." + +# ### END LIBTOOL TAG CONFIG: CXX diff --git a/third-party/odb/libodb-sqlite-2.4.0/m4/acx-pthread.m4 b/third-party/odb/libodb-sqlite-2.4.0/m4/acx-pthread.m4 new file mode 100755 index 0000000..204b32d --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/m4/acx-pthread.m4 @@ -0,0 +1,259 @@ +dnl +dnl NOTE: This file was modified. See the comments starting with 'CS:' +dnl for more information. In particular, it was changed to use C++ +dnl instead of C. +dnl +dnl @synopsis ACX_PTHREAD([ACTION-IF-FOUND[, ACTION-IF-NOT-FOUND]]) +dnl +dnl @summary figure out how to build C++ programs using POSIX threads +dnl +dnl This macro figures out how to build C++ programs using POSIX threads. +dnl It sets the PTHREAD_LIBS output variable to the threads library and +dnl linker flags, and the PTHREAD_CXXFLAGS output variable to any special +dnl C++ compiler flags that are needed. (The user can also force certain +dnl compiler flags/libs to be tested by setting these environment +dnl variables.) +dnl +dnl Also sets PTHREAD_CXX to any special C++ compiler that is needed for +dnl multi-threaded programs (defaults to the value of CXX otherwise). +dnl (This is necessary on AIX to use the special xlC_r compiler alias.) +dnl +dnl NOTE: You are assumed to not only compile your program with these +dnl flags, but also link it with them as well. e.g. you should link +dnl with $PTHREAD_CXX $CXXFLAGS $PTHREAD_CXXFLAGS $LDFLAGS ... $PTHREAD_LIBS +dnl $LIBS +dnl +dnl If you are only building threads programs, you may wish to use +dnl these variables in your default LIBS, CXXFLAGS, and CXX: +dnl +dnl LIBS="$PTHREAD_LIBS $LIBS" +dnl CXXFLAGS="$CXXFLAGS $PTHREAD_CXXFLAGS" +dnl CXX="$PTHREAD_CXX" +dnl +dnl In addition, if the PTHREAD_CREATE_JOINABLE thread-attribute +dnl constant has a nonstandard name, defines PTHREAD_CREATE_JOINABLE to +dnl that name (e.g. PTHREAD_CREATE_UNDETACHED on AIX). +dnl +dnl ACTION-IF-FOUND is a list of shell commands to run if a threads +dnl library is found, and ACTION-IF-NOT-FOUND is a list of commands to +dnl run it if it is not found. If ACTION-IF-FOUND is not specified, the +dnl default action will define HAVE_PTHREAD. +dnl +dnl Please let the authors know if this macro fails on any platform, or +dnl if you have any other suggestions or comments. This macro was based +dnl on work by SGJ on autoconf scripts for FFTW (www.fftw.org) (with +dnl help from M. Frigo), as well as ac_pthread and hb_pthread macros +dnl posted by Alejandro Forero Cuervo to the autoconf macro repository. +dnl We are also grateful for the helpful feedback of numerous users. +dnl +dnl @category InstalledPackages +dnl @author Steven G. Johnson +dnl @version 2006-05-29 +dnl @license GPLWithACException + +AC_DEFUN([ACX_PTHREAD], [ +AC_REQUIRE([AC_CANONICAL_HOST]) +AC_LANG_SAVE +AC_LANG(C++) +acx_pthread_ok=no + +# We used to check for pthread.h first, but this fails if pthread.h +# requires special compiler flags (e.g. on True64 or Sequent). +# It gets checked for in the link test anyway. + +# First of all, check if the user has set any of the PTHREAD_LIBS, +# etcetera environment variables, and if threads linking works using +# them: +if test x"$PTHREAD_LIBS$PTHREAD_CXXFLAGS" != x; then + save_CXXFLAGS="$CXXFLAGS" + CXXFLAGS="$CXXFLAGS $PTHREAD_CXXFLAGS" + save_LIBS="$LIBS" + LIBS="$PTHREAD_LIBS $LIBS" + AC_MSG_CHECKING([for pthread_join in LIBS=$PTHREAD_LIBS with CXXFLAGS=$PTHREAD_CXXFLAGS]) + AC_TRY_LINK_FUNC(pthread_join, acx_pthread_ok=yes) + AC_MSG_RESULT($acx_pthread_ok) + if test x"$acx_pthread_ok" = xno; then + PTHREAD_LIBS="" + PTHREAD_CXXFLAGS="" + fi + LIBS="$save_LIBS" + CXXFLAGS="$save_CXXFLAGS" +fi + +# We must check for the threads library under a number of different +# names; the ordering is very important because some systems +# (e.g. DEC) have both -lpthread and -lpthreads, where one of the +# libraries is broken (non-POSIX). + +# Create a list of thread flags to try. Items starting with a "-" are +# C compiler flags, and other items are library names, except for "none" +# which indicates that we try without any flags at all, and "pthread-config" +# which is a program returning the flags for the Pth emulation library. + +# CS: On GNU/Linux with gcc both -pthread and -lpthread are valid. +# However, libtool links libraries with -nostdlib which results in +# -pthread being stripped from the linker command line. To resolve +# this we move pthread from after -mthreads to after pthreads. +# +acx_pthread_flags="pthreads pthread none -Kthread -kthread lthread -pthread -pthreads -mthreads --thread-safe -mt pthread-config" + +# The ordering *is* (sometimes) important. Some notes on the +# individual items follow: + +# pthreads: AIX (must check this before -lpthread) +# none: in case threads are in libc; should be tried before -Kthread and +# other compiler flags to prevent continual compiler warnings +# -Kthread: Sequent (threads in libc, but -Kthread needed for pthread.h) +# -kthread: FreeBSD kernel threads (preferred to -pthread since SMP-able) +# lthread: LinuxThreads port on FreeBSD (also preferred to -pthread) +# -pthread: Linux/gcc (kernel threads), BSD/gcc (userland threads) +# -pthreads: Solaris/gcc +# -mthreads: Mingw32/gcc, Lynx/gcc +# -mt: Sun Workshop C (may only link SunOS threads [-lthread], but it +# doesn't hurt to check since this sometimes defines pthreads too; +# also defines -D_REENTRANT) +# ... -mt is also the pthreads flag for HP/aCC +# pthread: Linux, etcetera +# --thread-safe: KAI C++ +# pthread-config: use pthread-config program (for GNU Pth library) + +case "${host_cpu}-${host_os}" in + *solaris*) + + # On Solaris (at least, for some versions), libc contains stubbed + # (non-functional) versions of the pthreads routines, so link-based + # tests will erroneously succeed. (We need to link with -pthreads/-mt/ + # -lpthread.) (The stubs are missing pthread_cleanup_push, or rather + # a function called by this macro, so we could check for that, but + # who knows whether they'll stub that too in a future libc.) So, + # we'll just look for -pthreads and -lpthread first: + + # CS: Move -mt to the front of the list; Sun CC will use -mt, + # gcc will use -pthreads. + # + acx_pthread_flags="-mt -pthreads pthread -pthread $acx_pthread_flags" + ;; +esac + +if test x"$acx_pthread_ok" = xno; then +for flag in $acx_pthread_flags; do + + case $flag in + none) + AC_MSG_CHECKING([whether pthreads work without any flags]) + ;; + + -*) + AC_MSG_CHECKING([whether pthreads work with $flag]) + PTHREAD_CXXFLAGS="$flag" + ;; + + pthread-config) + AC_CHECK_PROG(acx_pthread_config, pthread-config, yes, no) + if test x"$acx_pthread_config" = xno; then continue; fi + PTHREAD_CXXFLAGS="`pthread-config --cflags`" + PTHREAD_LIBS="`pthread-config --ldflags` `pthread-config --libs`" + ;; + + *) + AC_MSG_CHECKING([for the pthreads library -l$flag]) + PTHREAD_LIBS="-l$flag" + ;; + esac + + save_LIBS="$LIBS" + save_CXXFLAGS="$CXXFLAGS" + LIBS="$PTHREAD_LIBS $LIBS" + CXXFLAGS="$CXXFLAGS $PTHREAD_CXXFLAGS" + + # Check for various functions. We must include pthread.h, + # since some functions may be macros. (On the Sequent, we + # need a special flag -Kthread to make this header compile.) + # We check for pthread_join because it is in -lpthread on IRIX + # while pthread_create is in libc. We check for pthread_attr_init + # due to DEC craziness with -lpthreads. We check for + # pthread_cleanup_push because it is one of the few pthread + # functions on Solaris that doesn't have a non-functional libc stub. + # We try pthread_create on general principles. + # + AC_TRY_LINK([#include ], + [pthread_t th; pthread_join(th, 0); + pthread_attr_init(0); pthread_cleanup_push(0, 0); + pthread_create(0,0,0,0); pthread_cleanup_pop(0);], + [acx_pthread_ok=yes]) + + LIBS="$save_LIBS" + CXXFLAGS="$save_CXXFLAGS" + + AC_MSG_RESULT($acx_pthread_ok) + if test "x$acx_pthread_ok" = xyes; then + break; + fi + + PTHREAD_LIBS="" + PTHREAD_CXXFLAGS="" +done +fi + +# Various other checks: +if test "x$acx_pthread_ok" = xyes; then + save_LIBS="$LIBS" + LIBS="$PTHREAD_LIBS $LIBS" + save_CXXFLAGS="$CXXFLAGS" + CXXFLAGS="$CXXFLAGS $PTHREAD_CXXFLAGS" + +dnl # Detect AIX lossage: JOINABLE attribute is called UNDETACHED. +dnl AC_MSG_CHECKING([for joinable pthread attribute]) +dnl attr_name=unknown +dnl for attr in PTHREAD_CREATE_JOINABLE PTHREAD_CREATE_UNDETACHED; do +dnl AC_TRY_LINK([#include ], [int attr=$attr; return attr;], +dnl [attr_name=$attr; break]) +dnl done +dnl AC_MSG_RESULT($attr_name) +dnl if test "$attr_name" != PTHREAD_CREATE_JOINABLE; then +dnl AC_DEFINE_UNQUOTED(PTHREAD_CREATE_JOINABLE, $attr_name, +dnl [Define to necessary symbol if this constant +dnl uses a non-standard name on your system.]) +dnl fi + + AC_MSG_CHECKING([if more special flags are required for pthreads]) + flag=no + case "${host_cpu}-${host_os}" in + *-aix* | *-freebsd* | *-darwin*) flag="-D_THREAD_SAFE";; + # CS: Add _REENTRANT in Linux to emulate -pthread. + # + *-linux* | *solaris* | *-osf* | *-hpux*) flag="-D_REENTRANT";; + esac + AC_MSG_RESULT(${flag}) + if test "x$flag" != xno; then + PTHREAD_CXXFLAGS="$flag $PTHREAD_CXXFLAGS" + fi + + LIBS="$save_LIBS" + CXXFLAGS="$save_CXXFLAGS" + +dnl # More AIX lossage: must compile with xlC_r +dnl if test x"$GXX" != xyes; then +dnl AC_CHECK_PROGS(PTHREAD_CXX, xlC_r, ${CXX}) +dnl else +dnl PTHREAD_CXX=$CXX +dnl fi + +else + PTHREAD_CXX="$CXX" +fi + +AC_SUBST(PTHREAD_LIBS) +AC_SUBST(PTHREAD_CXXFLAGS) +AC_SUBST(PTHREAD_CXX) + +# Finally, execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND: +if test x"$acx_pthread_ok" = xyes; then + ifelse([$1],,AC_DEFINE(HAVE_PTHREAD,1,[Define if you have POSIX threads libraries and header files.]),[$1]) + : +else + acx_pthread_ok=no + $2 +fi +AC_LANG_RESTORE +])dnl ACX_PTHREAD diff --git a/third-party/odb/libodb-sqlite-2.4.0/m4/disable-rpath.m4 b/third-party/odb/libodb-sqlite-2.4.0/m4/disable-rpath.m4 new file mode 100755 index 0000000..bf31ddc --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/m4/disable-rpath.m4 @@ -0,0 +1,25 @@ +dnl file : m4/disable-rpath.m4 +dnl copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +dnl license : GNU GPL v2; see accompanying LICENSE file +dnl +AC_DEFUN([DISABLE_RPATH],[ + +AC_MSG_CHECKING([whether to use rpath]) +AC_ARG_ENABLE( + [rpath], + [AC_HELP_STRING([--disable-rpath], [patch libtool to not use rpath])], + [libtool_rpath="$enable_rpath"], + [libtool_rpath="yes"]) +AC_MSG_RESULT($libtool_rpath) + +# Patch libtool to not use rpath if requested. +# +AC_CONFIG_COMMANDS( + [libtool-rpath-patch], + [if test "$libtool_use_rpath" = "no"; then + sed < libtool > libtool-2 's/^hardcode_libdir_flag_spec.*$'/'hardcode_libdir_flag_spec=" -D__LIBTOOL_NO_RPATH__ "/' + mv libtool-2 libtool + chmod 755 libtool + fi], + [libtool_use_rpath=$libtool_rpath]) +])dnl diff --git a/third-party/odb/libodb-sqlite-2.4.0/m4/libodb.m4 b/third-party/odb/libodb-sqlite-2.4.0/m4/libodb.m4 new file mode 100755 index 0000000..2dd2634 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/m4/libodb.m4 @@ -0,0 +1,82 @@ +dnl file : m4/libodb.m4 +dnl copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +dnl license : GNU GPL v2; see accompanying LICENSE file +dnl +dnl LIBODB([ACTION-IF-FOUND[, ACTION-IF-NOT-FOUND]]) +dnl +dnl +AC_DEFUN([LIBODB], [ +libodb_found=no + +AC_ARG_WITH( + [libodb], + [AC_HELP_STRING([--with-libodb=DIR],[location of libodb build directory])], + [libodb_dir=${withval}], + [libodb_dir=]) + +AC_MSG_CHECKING([for libodb]) + +# If libodb_dir was given, add the necessary preprocessor and linker flags. +# +if test x"$libodb_dir" != x; then + save_CPPFLAGS="$CPPFLAGS" + save_LDFLAGS="$LDFLAGS" + + AS_SET_CATFILE([abs_libodb_dir], [$ac_pwd], [$libodb_dir]) + + CPPFLAGS="$CPPFLAGS -I$abs_libodb_dir" + LDFLAGS="$LDFLAGS -L$abs_libodb_dir/odb" +fi + +save_LIBS="$LIBS" +LIBS="-lodb $LIBS" + +CXX_LIBTOOL_LINK_IFELSE([ +AC_LANG_SOURCE([ +#include + +void +f () +{ +} + +const char* +g () +{ + try + { + f (); + } + catch (const odb::exception& e) + { + return e.what (); + } + return 0; +} + +int +main () +{ + const char* m (g ()); + return m != 0; +} +])], +[libodb_found=yes]) + +if test x"$libodb_found" = xno; then + LIBS="$save_LIBS" + + if test x"$libodb_dir" != x; then + CPPFLAGS="$save_CPPFLAGS" + LDFLAGS="$save_LDFLAGS" + fi +fi + +if test x"$libodb_found" = xyes; then + AC_MSG_RESULT([yes]) + $1 +else + AC_MSG_RESULT([no]) + $2 +fi +])dnl diff --git a/third-party/odb/libodb-sqlite-2.4.0/m4/libsqlite.m4 b/third-party/odb/libodb-sqlite-2.4.0/m4/libsqlite.m4 new file mode 100755 index 0000000..a8fe4f7 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/m4/libsqlite.m4 @@ -0,0 +1,68 @@ +dnl file : m4/libsqlite.m4 +dnl copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +dnl license : GNU GPL v2; see accompanying LICENSE file +dnl +dnl LIBSQLITE([ACTION-IF-FOUND[,ACTION-IF-NOT-FOUND]]) +dnl +dnl Also sets libsqlite_unlock_notify to yes if sqlite3_unlock_notify() +dnl functionality is available. +dnl +AC_DEFUN([LIBSQLITE], [ +libsqlite_found=no +libsqlite_unlock_notify=no + +AC_MSG_CHECKING([for libsqlite3]) + +save_LIBS="$LIBS" +LIBS="-lsqlite3 $LIBS" + +CXX_LIBTOOL_LINK_IFELSE([ +AC_LANG_SOURCE([ +#include + +int +main () +{ + sqlite3* handle; + sqlite3_open ("", &handle); + sqlite3_stmt* stmt; + sqlite3_prepare (handle, "", 0, &stmt, 0); + sqlite3_finalize (stmt); + sqlite3_close (handle); +} +])], +[ +libsqlite_found=yes +]) + +if test x"$libsqlite_found" = xno; then + LIBS="$save_LIBS" +fi + +# Check for unlock_notify. +# +if test x"$libsqlite_found" = xyes; then +CXX_LIBTOOL_LINK_IFELSE([ +AC_LANG_SOURCE([ +#include + +int +main () +{ + sqlite3* handle (0); + sqlite3_unlock_notify (handle, 0, 0); +} +])], +[ +libsqlite_unlock_notify=yes +]) +fi + +if test x"$libsqlite_found" = xyes; then + AC_MSG_RESULT([yes]) + $1 +else + AC_MSG_RESULT([no]) + $2 +fi +])dnl diff --git a/third-party/odb/libodb-sqlite-2.4.0/m4/libtool-link.m4 b/third-party/odb/libodb-sqlite-2.4.0/m4/libtool-link.m4 new file mode 100755 index 0000000..6b04b63 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/m4/libtool-link.m4 @@ -0,0 +1,46 @@ +dnl file : m4/libtool-link.m4 +dnl copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +dnl license : GNU GPL v2; see accompanying LICENSE file +dnl +dnl +dnl CXX_LIBTOOL_LINK_IFELSE (input, [action-if-true], [action-if-false]) +dnl +dnl Similar to AC_LINK_IFELSE except it uses libtool to perform the +dnl linking and it does this using the C++ compiler. +dnl +AC_DEFUN([CXX_LIBTOOL_LINK_IFELSE],[ +AC_LANG_SAVE +AC_LANG(C++) + +if test -d .libs; then + delete_libs_dir=no +else + delete_libs_dir=yes +fi + +AC_COMPILE_IFELSE([$1], +[ + ac_try='./libtool --tag=CXX --mode=link $CXX -no-install $CXXFLAGS $LDFLAGS -o conftest conftest.$OBJEXT $LIBS >&AS_MESSAGE_LOG_FD' + if _AC_DO_VAR(ac_try); then + libtool_link_ok=yes + else + libtool_link_ok=no + fi +], +[ + libtool_link_ok=no +]) + +if test x"$delete_libs_dir" = xyes; then + rm -rf .libs +fi + +if test x"$libtool_link_ok" = xyes; then +[$2] +: +else +[$3] +: +fi + +AC_LANG_RESTORE])dnl diff --git a/third-party/odb/libodb-sqlite-2.4.0/m4/libtool.m4 b/third-party/odb/libodb-sqlite-2.4.0/m4/libtool.m4 new file mode 100755 index 0000000..02b4bbe --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/m4/libtool.m4 @@ -0,0 +1,7991 @@ +# libtool.m4 - Configure libtool for the host system. -*-Autoconf-*- +# +# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, +# 2006, 2007, 2008, 2009, 2010, 2011 Free Software +# Foundation, Inc. +# Written by Gordon Matzigkeit, 1996 +# +# This file is free software; the Free Software Foundation gives +# unlimited permission to copy and/or distribute it, with or without +# modifications, as long as this notice is preserved. + +m4_define([_LT_COPYING], [dnl +# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, +# 2006, 2007, 2008, 2009, 2010, 2011 Free Software +# Foundation, Inc. +# Written by Gordon Matzigkeit, 1996 +# +# This file is part of GNU Libtool. +# +# GNU Libtool is free software; you can redistribute it and/or +# modify it under the terms of the GNU General Public License as +# published by the Free Software Foundation; either version 2 of +# the License, or (at your option) any later version. +# +# As a special exception to the GNU General Public License, +# if you distribute this file as part of a program or library that +# is built using GNU Libtool, you may include this file under the +# same distribution terms that you use for the rest of that program. +# +# GNU Libtool is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with GNU Libtool; see the file COPYING. If not, a copy +# can be downloaded from http://www.gnu.org/licenses/gpl.html, or +# obtained by writing to the Free Software Foundation, Inc., +# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +]) + +# serial 57 LT_INIT + + +# LT_PREREQ(VERSION) +# ------------------ +# Complain and exit if this libtool version is less that VERSION. +m4_defun([LT_PREREQ], +[m4_if(m4_version_compare(m4_defn([LT_PACKAGE_VERSION]), [$1]), -1, + [m4_default([$3], + [m4_fatal([Libtool version $1 or higher is required], + 63)])], + [$2])]) + + +# _LT_CHECK_BUILDDIR +# ------------------ +# Complain if the absolute build directory name contains unusual characters +m4_defun([_LT_CHECK_BUILDDIR], +[case `pwd` in + *\ * | *\ *) + AC_MSG_WARN([Libtool does not cope well with whitespace in `pwd`]) ;; +esac +]) + + +# LT_INIT([OPTIONS]) +# ------------------ +AC_DEFUN([LT_INIT], +[AC_PREREQ([2.58])dnl We use AC_INCLUDES_DEFAULT +AC_REQUIRE([AC_CONFIG_AUX_DIR_DEFAULT])dnl +AC_BEFORE([$0], [LT_LANG])dnl +AC_BEFORE([$0], [LT_OUTPUT])dnl +AC_BEFORE([$0], [LTDL_INIT])dnl +m4_require([_LT_CHECK_BUILDDIR])dnl + +dnl Autoconf doesn't catch unexpanded LT_ macros by default: +m4_pattern_forbid([^_?LT_[A-Z_]+$])dnl +m4_pattern_allow([^(_LT_EOF|LT_DLGLOBAL|LT_DLLAZY_OR_NOW|LT_MULTI_MODULE)$])dnl +dnl aclocal doesn't pull ltoptions.m4, ltsugar.m4, or ltversion.m4 +dnl unless we require an AC_DEFUNed macro: +AC_REQUIRE([LTOPTIONS_VERSION])dnl +AC_REQUIRE([LTSUGAR_VERSION])dnl +AC_REQUIRE([LTVERSION_VERSION])dnl +AC_REQUIRE([LTOBSOLETE_VERSION])dnl +m4_require([_LT_PROG_LTMAIN])dnl + +_LT_SHELL_INIT([SHELL=${CONFIG_SHELL-/bin/sh}]) + +dnl Parse OPTIONS +_LT_SET_OPTIONS([$0], [$1]) + +# This can be used to rebuild libtool when needed +LIBTOOL_DEPS="$ltmain" + +# Always use our own libtool. +LIBTOOL='$(SHELL) $(top_builddir)/libtool' +AC_SUBST(LIBTOOL)dnl + +_LT_SETUP + +# Only expand once: +m4_define([LT_INIT]) +])# LT_INIT + +# Old names: +AU_ALIAS([AC_PROG_LIBTOOL], [LT_INIT]) +AU_ALIAS([AM_PROG_LIBTOOL], [LT_INIT]) +dnl aclocal-1.4 backwards compatibility: +dnl AC_DEFUN([AC_PROG_LIBTOOL], []) +dnl AC_DEFUN([AM_PROG_LIBTOOL], []) + + +# _LT_CC_BASENAME(CC) +# ------------------- +# Calculate cc_basename. Skip known compiler wrappers and cross-prefix. +m4_defun([_LT_CC_BASENAME], +[for cc_temp in $1""; do + case $cc_temp in + compile | *[[\\/]]compile | ccache | *[[\\/]]ccache ) ;; + distcc | *[[\\/]]distcc | purify | *[[\\/]]purify ) ;; + \-*) ;; + *) break;; + esac +done +cc_basename=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"` +]) + + +# _LT_FILEUTILS_DEFAULTS +# ---------------------- +# It is okay to use these file commands and assume they have been set +# sensibly after `m4_require([_LT_FILEUTILS_DEFAULTS])'. +m4_defun([_LT_FILEUTILS_DEFAULTS], +[: ${CP="cp -f"} +: ${MV="mv -f"} +: ${RM="rm -f"} +])# _LT_FILEUTILS_DEFAULTS + + +# _LT_SETUP +# --------- +m4_defun([_LT_SETUP], +[AC_REQUIRE([AC_CANONICAL_HOST])dnl +AC_REQUIRE([AC_CANONICAL_BUILD])dnl +AC_REQUIRE([_LT_PREPARE_SED_QUOTE_VARS])dnl +AC_REQUIRE([_LT_PROG_ECHO_BACKSLASH])dnl + +_LT_DECL([], [PATH_SEPARATOR], [1], [The PATH separator for the build system])dnl +dnl +_LT_DECL([], [host_alias], [0], [The host system])dnl +_LT_DECL([], [host], [0])dnl +_LT_DECL([], [host_os], [0])dnl +dnl +_LT_DECL([], [build_alias], [0], [The build system])dnl +_LT_DECL([], [build], [0])dnl +_LT_DECL([], [build_os], [0])dnl +dnl +AC_REQUIRE([AC_PROG_CC])dnl +AC_REQUIRE([LT_PATH_LD])dnl +AC_REQUIRE([LT_PATH_NM])dnl +dnl +AC_REQUIRE([AC_PROG_LN_S])dnl +test -z "$LN_S" && LN_S="ln -s" +_LT_DECL([], [LN_S], [1], [Whether we need soft or hard links])dnl +dnl +AC_REQUIRE([LT_CMD_MAX_LEN])dnl +_LT_DECL([objext], [ac_objext], [0], [Object file suffix (normally "o")])dnl +_LT_DECL([], [exeext], [0], [Executable file suffix (normally "")])dnl +dnl +m4_require([_LT_FILEUTILS_DEFAULTS])dnl +m4_require([_LT_CHECK_SHELL_FEATURES])dnl +m4_require([_LT_PATH_CONVERSION_FUNCTIONS])dnl +m4_require([_LT_CMD_RELOAD])dnl +m4_require([_LT_CHECK_MAGIC_METHOD])dnl +m4_require([_LT_CHECK_SHAREDLIB_FROM_LINKLIB])dnl +m4_require([_LT_CMD_OLD_ARCHIVE])dnl +m4_require([_LT_CMD_GLOBAL_SYMBOLS])dnl +m4_require([_LT_WITH_SYSROOT])dnl + +_LT_CONFIG_LIBTOOL_INIT([ +# See if we are running on zsh, and set the options which allow our +# commands through without removal of \ escapes INIT. +if test -n "\${ZSH_VERSION+set}" ; then + setopt NO_GLOB_SUBST +fi +]) +if test -n "${ZSH_VERSION+set}" ; then + setopt NO_GLOB_SUBST +fi + +_LT_CHECK_OBJDIR + +m4_require([_LT_TAG_COMPILER])dnl + +case $host_os in +aix3*) + # AIX sometimes has problems with the GCC collect2 program. For some + # reason, if we set the COLLECT_NAMES environment variable, the problems + # vanish in a puff of smoke. + if test "X${COLLECT_NAMES+set}" != Xset; then + COLLECT_NAMES= + export COLLECT_NAMES + fi + ;; +esac + +# Global variables: +ofile=libtool +can_build_shared=yes + +# All known linkers require a `.a' archive for static linking (except MSVC, +# which needs '.lib'). +libext=a + +with_gnu_ld="$lt_cv_prog_gnu_ld" + +old_CC="$CC" +old_CFLAGS="$CFLAGS" + +# Set sane defaults for various variables +test -z "$CC" && CC=cc +test -z "$LTCC" && LTCC=$CC +test -z "$LTCFLAGS" && LTCFLAGS=$CFLAGS +test -z "$LD" && LD=ld +test -z "$ac_objext" && ac_objext=o + +_LT_CC_BASENAME([$compiler]) + +# Only perform the check for file, if the check method requires it +test -z "$MAGIC_CMD" && MAGIC_CMD=file +case $deplibs_check_method in +file_magic*) + if test "$file_magic_cmd" = '$MAGIC_CMD'; then + _LT_PATH_MAGIC + fi + ;; +esac + +# Use C for the default configuration in the libtool script +LT_SUPPORTED_TAG([CC]) +_LT_LANG_C_CONFIG +_LT_LANG_DEFAULT_CONFIG +_LT_CONFIG_COMMANDS +])# _LT_SETUP + + +# _LT_PREPARE_SED_QUOTE_VARS +# -------------------------- +# Define a few sed substitution that help us do robust quoting. +m4_defun([_LT_PREPARE_SED_QUOTE_VARS], +[# Backslashify metacharacters that are still active within +# double-quoted strings. +sed_quote_subst='s/\([["`$\\]]\)/\\\1/g' + +# Same as above, but do not quote variable references. +double_quote_subst='s/\([["`\\]]\)/\\\1/g' + +# Sed substitution to delay expansion of an escaped shell variable in a +# double_quote_subst'ed string. +delay_variable_subst='s/\\\\\\\\\\\$/\\\\\\$/g' + +# Sed substitution to delay expansion of an escaped single quote. +delay_single_quote_subst='s/'\''/'\'\\\\\\\'\''/g' + +# Sed substitution to avoid accidental globbing in evaled expressions +no_glob_subst='s/\*/\\\*/g' +]) + +# _LT_PROG_LTMAIN +# --------------- +# Note that this code is called both from `configure', and `config.status' +# now that we use AC_CONFIG_COMMANDS to generate libtool. Notably, +# `config.status' has no value for ac_aux_dir unless we are using Automake, +# so we pass a copy along to make sure it has a sensible value anyway. +m4_defun([_LT_PROG_LTMAIN], +[m4_ifdef([AC_REQUIRE_AUX_FILE], [AC_REQUIRE_AUX_FILE([ltmain.sh])])dnl +_LT_CONFIG_LIBTOOL_INIT([ac_aux_dir='$ac_aux_dir']) +ltmain="$ac_aux_dir/ltmain.sh" +])# _LT_PROG_LTMAIN + + +## ------------------------------------- ## +## Accumulate code for creating libtool. ## +## ------------------------------------- ## + +# So that we can recreate a full libtool script including additional +# tags, we accumulate the chunks of code to send to AC_CONFIG_COMMANDS +# in macros and then make a single call at the end using the `libtool' +# label. + + +# _LT_CONFIG_LIBTOOL_INIT([INIT-COMMANDS]) +# ---------------------------------------- +# Register INIT-COMMANDS to be passed to AC_CONFIG_COMMANDS later. +m4_define([_LT_CONFIG_LIBTOOL_INIT], +[m4_ifval([$1], + [m4_append([_LT_OUTPUT_LIBTOOL_INIT], + [$1 +])])]) + +# Initialize. +m4_define([_LT_OUTPUT_LIBTOOL_INIT]) + + +# _LT_CONFIG_LIBTOOL([COMMANDS]) +# ------------------------------ +# Register COMMANDS to be passed to AC_CONFIG_COMMANDS later. +m4_define([_LT_CONFIG_LIBTOOL], +[m4_ifval([$1], + [m4_append([_LT_OUTPUT_LIBTOOL_COMMANDS], + [$1 +])])]) + +# Initialize. +m4_define([_LT_OUTPUT_LIBTOOL_COMMANDS]) + + +# _LT_CONFIG_SAVE_COMMANDS([COMMANDS], [INIT_COMMANDS]) +# ----------------------------------------------------- +m4_defun([_LT_CONFIG_SAVE_COMMANDS], +[_LT_CONFIG_LIBTOOL([$1]) +_LT_CONFIG_LIBTOOL_INIT([$2]) +]) + + +# _LT_FORMAT_COMMENT([COMMENT]) +# ----------------------------- +# Add leading comment marks to the start of each line, and a trailing +# full-stop to the whole comment if one is not present already. +m4_define([_LT_FORMAT_COMMENT], +[m4_ifval([$1], [ +m4_bpatsubst([m4_bpatsubst([$1], [^ *], [# ])], + [['`$\]], [\\\&])]m4_bmatch([$1], [[!?.]$], [], [.]) +)]) + + + +## ------------------------ ## +## FIXME: Eliminate VARNAME ## +## ------------------------ ## + + +# _LT_DECL([CONFIGNAME], VARNAME, VALUE, [DESCRIPTION], [IS-TAGGED?]) +# ------------------------------------------------------------------- +# CONFIGNAME is the name given to the value in the libtool script. +# VARNAME is the (base) name used in the configure script. +# VALUE may be 0, 1 or 2 for a computed quote escaped value based on +# VARNAME. Any other value will be used directly. +m4_define([_LT_DECL], +[lt_if_append_uniq([lt_decl_varnames], [$2], [, ], + [lt_dict_add_subkey([lt_decl_dict], [$2], [libtool_name], + [m4_ifval([$1], [$1], [$2])]) + lt_dict_add_subkey([lt_decl_dict], [$2], [value], [$3]) + m4_ifval([$4], + [lt_dict_add_subkey([lt_decl_dict], [$2], [description], [$4])]) + lt_dict_add_subkey([lt_decl_dict], [$2], + [tagged?], [m4_ifval([$5], [yes], [no])])]) +]) + + +# _LT_TAGDECL([CONFIGNAME], VARNAME, VALUE, [DESCRIPTION]) +# -------------------------------------------------------- +m4_define([_LT_TAGDECL], [_LT_DECL([$1], [$2], [$3], [$4], [yes])]) + + +# lt_decl_tag_varnames([SEPARATOR], [VARNAME1...]) +# ------------------------------------------------ +m4_define([lt_decl_tag_varnames], +[_lt_decl_filter([tagged?], [yes], $@)]) + + +# _lt_decl_filter(SUBKEY, VALUE, [SEPARATOR], [VARNAME1..]) +# --------------------------------------------------------- +m4_define([_lt_decl_filter], +[m4_case([$#], + [0], [m4_fatal([$0: too few arguments: $#])], + [1], [m4_fatal([$0: too few arguments: $#: $1])], + [2], [lt_dict_filter([lt_decl_dict], [$1], [$2], [], lt_decl_varnames)], + [3], [lt_dict_filter([lt_decl_dict], [$1], [$2], [$3], lt_decl_varnames)], + [lt_dict_filter([lt_decl_dict], $@)])[]dnl +]) + + +# lt_decl_quote_varnames([SEPARATOR], [VARNAME1...]) +# -------------------------------------------------- +m4_define([lt_decl_quote_varnames], +[_lt_decl_filter([value], [1], $@)]) + + +# lt_decl_dquote_varnames([SEPARATOR], [VARNAME1...]) +# --------------------------------------------------- +m4_define([lt_decl_dquote_varnames], +[_lt_decl_filter([value], [2], $@)]) + + +# lt_decl_varnames_tagged([SEPARATOR], [VARNAME1...]) +# --------------------------------------------------- +m4_define([lt_decl_varnames_tagged], +[m4_assert([$# <= 2])dnl +_$0(m4_quote(m4_default([$1], [[, ]])), + m4_ifval([$2], [[$2]], [m4_dquote(lt_decl_tag_varnames)]), + m4_split(m4_normalize(m4_quote(_LT_TAGS)), [ ]))]) +m4_define([_lt_decl_varnames_tagged], +[m4_ifval([$3], [lt_combine([$1], [$2], [_], $3)])]) + + +# lt_decl_all_varnames([SEPARATOR], [VARNAME1...]) +# ------------------------------------------------ +m4_define([lt_decl_all_varnames], +[_$0(m4_quote(m4_default([$1], [[, ]])), + m4_if([$2], [], + m4_quote(lt_decl_varnames), + m4_quote(m4_shift($@))))[]dnl +]) +m4_define([_lt_decl_all_varnames], +[lt_join($@, lt_decl_varnames_tagged([$1], + lt_decl_tag_varnames([[, ]], m4_shift($@))))dnl +]) + + +# _LT_CONFIG_STATUS_DECLARE([VARNAME]) +# ------------------------------------ +# Quote a variable value, and forward it to `config.status' so that its +# declaration there will have the same value as in `configure'. VARNAME +# must have a single quote delimited value for this to work. +m4_define([_LT_CONFIG_STATUS_DECLARE], +[$1='`$ECHO "$][$1" | $SED "$delay_single_quote_subst"`']) + + +# _LT_CONFIG_STATUS_DECLARATIONS +# ------------------------------ +# We delimit libtool config variables with single quotes, so when +# we write them to config.status, we have to be sure to quote all +# embedded single quotes properly. In configure, this macro expands +# each variable declared with _LT_DECL (and _LT_TAGDECL) into: +# +# ='`$ECHO "$" | $SED "$delay_single_quote_subst"`' +m4_defun([_LT_CONFIG_STATUS_DECLARATIONS], +[m4_foreach([_lt_var], m4_quote(lt_decl_all_varnames), + [m4_n([_LT_CONFIG_STATUS_DECLARE(_lt_var)])])]) + + +# _LT_LIBTOOL_TAGS +# ---------------- +# Output comment and list of tags supported by the script +m4_defun([_LT_LIBTOOL_TAGS], +[_LT_FORMAT_COMMENT([The names of the tagged configurations supported by this script])dnl +available_tags="_LT_TAGS"dnl +]) + + +# _LT_LIBTOOL_DECLARE(VARNAME, [TAG]) +# ----------------------------------- +# Extract the dictionary values for VARNAME (optionally with TAG) and +# expand to a commented shell variable setting: +# +# # Some comment about what VAR is for. +# visible_name=$lt_internal_name +m4_define([_LT_LIBTOOL_DECLARE], +[_LT_FORMAT_COMMENT(m4_quote(lt_dict_fetch([lt_decl_dict], [$1], + [description])))[]dnl +m4_pushdef([_libtool_name], + m4_quote(lt_dict_fetch([lt_decl_dict], [$1], [libtool_name])))[]dnl +m4_case(m4_quote(lt_dict_fetch([lt_decl_dict], [$1], [value])), + [0], [_libtool_name=[$]$1], + [1], [_libtool_name=$lt_[]$1], + [2], [_libtool_name=$lt_[]$1], + [_libtool_name=lt_dict_fetch([lt_decl_dict], [$1], [value])])[]dnl +m4_ifval([$2], [_$2])[]m4_popdef([_libtool_name])[]dnl +]) + + +# _LT_LIBTOOL_CONFIG_VARS +# ----------------------- +# Produce commented declarations of non-tagged libtool config variables +# suitable for insertion in the LIBTOOL CONFIG section of the `libtool' +# script. Tagged libtool config variables (even for the LIBTOOL CONFIG +# section) are produced by _LT_LIBTOOL_TAG_VARS. +m4_defun([_LT_LIBTOOL_CONFIG_VARS], +[m4_foreach([_lt_var], + m4_quote(_lt_decl_filter([tagged?], [no], [], lt_decl_varnames)), + [m4_n([_LT_LIBTOOL_DECLARE(_lt_var)])])]) + + +# _LT_LIBTOOL_TAG_VARS(TAG) +# ------------------------- +m4_define([_LT_LIBTOOL_TAG_VARS], +[m4_foreach([_lt_var], m4_quote(lt_decl_tag_varnames), + [m4_n([_LT_LIBTOOL_DECLARE(_lt_var, [$1])])])]) + + +# _LT_TAGVAR(VARNAME, [TAGNAME]) +# ------------------------------ +m4_define([_LT_TAGVAR], [m4_ifval([$2], [$1_$2], [$1])]) + + +# _LT_CONFIG_COMMANDS +# ------------------- +# Send accumulated output to $CONFIG_STATUS. Thanks to the lists of +# variables for single and double quote escaping we saved from calls +# to _LT_DECL, we can put quote escaped variables declarations +# into `config.status', and then the shell code to quote escape them in +# for loops in `config.status'. Finally, any additional code accumulated +# from calls to _LT_CONFIG_LIBTOOL_INIT is expanded. +m4_defun([_LT_CONFIG_COMMANDS], +[AC_PROVIDE_IFELSE([LT_OUTPUT], + dnl If the libtool generation code has been placed in $CONFIG_LT, + dnl instead of duplicating it all over again into config.status, + dnl then we will have config.status run $CONFIG_LT later, so it + dnl needs to know what name is stored there: + [AC_CONFIG_COMMANDS([libtool], + [$SHELL $CONFIG_LT || AS_EXIT(1)], [CONFIG_LT='$CONFIG_LT'])], + dnl If the libtool generation code is destined for config.status, + dnl expand the accumulated commands and init code now: + [AC_CONFIG_COMMANDS([libtool], + [_LT_OUTPUT_LIBTOOL_COMMANDS], [_LT_OUTPUT_LIBTOOL_COMMANDS_INIT])]) +])#_LT_CONFIG_COMMANDS + + +# Initialize. +m4_define([_LT_OUTPUT_LIBTOOL_COMMANDS_INIT], +[ + +# The HP-UX ksh and POSIX shell print the target directory to stdout +# if CDPATH is set. +(unset CDPATH) >/dev/null 2>&1 && unset CDPATH + +sed_quote_subst='$sed_quote_subst' +double_quote_subst='$double_quote_subst' +delay_variable_subst='$delay_variable_subst' +_LT_CONFIG_STATUS_DECLARATIONS +LTCC='$LTCC' +LTCFLAGS='$LTCFLAGS' +compiler='$compiler_DEFAULT' + +# A function that is used when there is no print builtin or printf. +func_fallback_echo () +{ + eval 'cat <<_LTECHO_EOF +\$[]1 +_LTECHO_EOF' +} + +# Quote evaled strings. +for var in lt_decl_all_varnames([[ \ +]], lt_decl_quote_varnames); do + case \`eval \\\\\$ECHO \\\\""\\\\\$\$var"\\\\"\` in + *[[\\\\\\\`\\"\\\$]]*) + eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"\\\$\$var\\" | \\\$SED \\"\\\$sed_quote_subst\\"\\\`\\\\\\"" + ;; + *) + eval "lt_\$var=\\\\\\"\\\$\$var\\\\\\"" + ;; + esac +done + +# Double-quote double-evaled strings. +for var in lt_decl_all_varnames([[ \ +]], lt_decl_dquote_varnames); do + case \`eval \\\\\$ECHO \\\\""\\\\\$\$var"\\\\"\` in + *[[\\\\\\\`\\"\\\$]]*) + eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"\\\$\$var\\" | \\\$SED -e \\"\\\$double_quote_subst\\" -e \\"\\\$sed_quote_subst\\" -e \\"\\\$delay_variable_subst\\"\\\`\\\\\\"" + ;; + *) + eval "lt_\$var=\\\\\\"\\\$\$var\\\\\\"" + ;; + esac +done + +_LT_OUTPUT_LIBTOOL_INIT +]) + +# _LT_GENERATED_FILE_INIT(FILE, [COMMENT]) +# ------------------------------------ +# Generate a child script FILE with all initialization necessary to +# reuse the environment learned by the parent script, and make the +# file executable. If COMMENT is supplied, it is inserted after the +# `#!' sequence but before initialization text begins. After this +# macro, additional text can be appended to FILE to form the body of +# the child script. The macro ends with non-zero status if the +# file could not be fully written (such as if the disk is full). +m4_ifdef([AS_INIT_GENERATED], +[m4_defun([_LT_GENERATED_FILE_INIT],[AS_INIT_GENERATED($@)])], +[m4_defun([_LT_GENERATED_FILE_INIT], +[m4_require([AS_PREPARE])]dnl +[m4_pushdef([AS_MESSAGE_LOG_FD])]dnl +[lt_write_fail=0 +cat >$1 <<_ASEOF || lt_write_fail=1 +#! $SHELL +# Generated by $as_me. +$2 +SHELL=\${CONFIG_SHELL-$SHELL} +export SHELL +_ASEOF +cat >>$1 <<\_ASEOF || lt_write_fail=1 +AS_SHELL_SANITIZE +_AS_PREPARE +exec AS_MESSAGE_FD>&1 +_ASEOF +test $lt_write_fail = 0 && chmod +x $1[]dnl +m4_popdef([AS_MESSAGE_LOG_FD])])])# _LT_GENERATED_FILE_INIT + +# LT_OUTPUT +# --------- +# This macro allows early generation of the libtool script (before +# AC_OUTPUT is called), incase it is used in configure for compilation +# tests. +AC_DEFUN([LT_OUTPUT], +[: ${CONFIG_LT=./config.lt} +AC_MSG_NOTICE([creating $CONFIG_LT]) +_LT_GENERATED_FILE_INIT(["$CONFIG_LT"], +[# Run this file to recreate a libtool stub with the current configuration.]) + +cat >>"$CONFIG_LT" <<\_LTEOF +lt_cl_silent=false +exec AS_MESSAGE_LOG_FD>>config.log +{ + echo + AS_BOX([Running $as_me.]) +} >&AS_MESSAGE_LOG_FD + +lt_cl_help="\ +\`$as_me' creates a local libtool stub from the current configuration, +for use in further configure time tests before the real libtool is +generated. + +Usage: $[0] [[OPTIONS]] + + -h, --help print this help, then exit + -V, --version print version number, then exit + -q, --quiet do not print progress messages + -d, --debug don't remove temporary files + +Report bugs to ." + +lt_cl_version="\ +m4_ifset([AC_PACKAGE_NAME], [AC_PACKAGE_NAME ])config.lt[]dnl +m4_ifset([AC_PACKAGE_VERSION], [ AC_PACKAGE_VERSION]) +configured by $[0], generated by m4_PACKAGE_STRING. + +Copyright (C) 2011 Free Software Foundation, Inc. +This config.lt script is free software; the Free Software Foundation +gives unlimited permision to copy, distribute and modify it." + +while test $[#] != 0 +do + case $[1] in + --version | --v* | -V ) + echo "$lt_cl_version"; exit 0 ;; + --help | --h* | -h ) + echo "$lt_cl_help"; exit 0 ;; + --debug | --d* | -d ) + debug=: ;; + --quiet | --q* | --silent | --s* | -q ) + lt_cl_silent=: ;; + + -*) AC_MSG_ERROR([unrecognized option: $[1] +Try \`$[0] --help' for more information.]) ;; + + *) AC_MSG_ERROR([unrecognized argument: $[1] +Try \`$[0] --help' for more information.]) ;; + esac + shift +done + +if $lt_cl_silent; then + exec AS_MESSAGE_FD>/dev/null +fi +_LTEOF + +cat >>"$CONFIG_LT" <<_LTEOF +_LT_OUTPUT_LIBTOOL_COMMANDS_INIT +_LTEOF + +cat >>"$CONFIG_LT" <<\_LTEOF +AC_MSG_NOTICE([creating $ofile]) +_LT_OUTPUT_LIBTOOL_COMMANDS +AS_EXIT(0) +_LTEOF +chmod +x "$CONFIG_LT" + +# configure is writing to config.log, but config.lt does its own redirection, +# appending to config.log, which fails on DOS, as config.log is still kept +# open by configure. Here we exec the FD to /dev/null, effectively closing +# config.log, so it can be properly (re)opened and appended to by config.lt. +lt_cl_success=: +test "$silent" = yes && + lt_config_lt_args="$lt_config_lt_args --quiet" +exec AS_MESSAGE_LOG_FD>/dev/null +$SHELL "$CONFIG_LT" $lt_config_lt_args || lt_cl_success=false +exec AS_MESSAGE_LOG_FD>>config.log +$lt_cl_success || AS_EXIT(1) +])# LT_OUTPUT + + +# _LT_CONFIG(TAG) +# --------------- +# If TAG is the built-in tag, create an initial libtool script with a +# default configuration from the untagged config vars. Otherwise add code +# to config.status for appending the configuration named by TAG from the +# matching tagged config vars. +m4_defun([_LT_CONFIG], +[m4_require([_LT_FILEUTILS_DEFAULTS])dnl +_LT_CONFIG_SAVE_COMMANDS([ + m4_define([_LT_TAG], m4_if([$1], [], [C], [$1]))dnl + m4_if(_LT_TAG, [C], [ + # See if we are running on zsh, and set the options which allow our + # commands through without removal of \ escapes. + if test -n "${ZSH_VERSION+set}" ; then + setopt NO_GLOB_SUBST + fi + + cfgfile="${ofile}T" + trap "$RM \"$cfgfile\"; exit 1" 1 2 15 + $RM "$cfgfile" + + cat <<_LT_EOF >> "$cfgfile" +#! $SHELL + +# `$ECHO "$ofile" | sed 's%^.*/%%'` - Provide generalized library-building support services. +# Generated automatically by $as_me ($PACKAGE$TIMESTAMP) $VERSION +# Libtool was configured on host `(hostname || uname -n) 2>/dev/null | sed 1q`: +# NOTE: Changes made to this file will be lost: look at ltmain.sh. +# +_LT_COPYING +_LT_LIBTOOL_TAGS + +# ### BEGIN LIBTOOL CONFIG +_LT_LIBTOOL_CONFIG_VARS +_LT_LIBTOOL_TAG_VARS +# ### END LIBTOOL CONFIG + +_LT_EOF + + case $host_os in + aix3*) + cat <<\_LT_EOF >> "$cfgfile" +# AIX sometimes has problems with the GCC collect2 program. For some +# reason, if we set the COLLECT_NAMES environment variable, the problems +# vanish in a puff of smoke. +if test "X${COLLECT_NAMES+set}" != Xset; then + COLLECT_NAMES= + export COLLECT_NAMES +fi +_LT_EOF + ;; + esac + + _LT_PROG_LTMAIN + + # We use sed instead of cat because bash on DJGPP gets confused if + # if finds mixed CR/LF and LF-only lines. Since sed operates in + # text mode, it properly converts lines to CR/LF. This bash problem + # is reportedly fixed, but why not run on old versions too? + sed '$q' "$ltmain" >> "$cfgfile" \ + || (rm -f "$cfgfile"; exit 1) + + _LT_PROG_REPLACE_SHELLFNS + + mv -f "$cfgfile" "$ofile" || + (rm -f "$ofile" && cp "$cfgfile" "$ofile" && rm -f "$cfgfile") + chmod +x "$ofile" +], +[cat <<_LT_EOF >> "$ofile" + +dnl Unfortunately we have to use $1 here, since _LT_TAG is not expanded +dnl in a comment (ie after a #). +# ### BEGIN LIBTOOL TAG CONFIG: $1 +_LT_LIBTOOL_TAG_VARS(_LT_TAG) +# ### END LIBTOOL TAG CONFIG: $1 +_LT_EOF +])dnl /m4_if +], +[m4_if([$1], [], [ + PACKAGE='$PACKAGE' + VERSION='$VERSION' + TIMESTAMP='$TIMESTAMP' + RM='$RM' + ofile='$ofile'], []) +])dnl /_LT_CONFIG_SAVE_COMMANDS +])# _LT_CONFIG + + +# LT_SUPPORTED_TAG(TAG) +# --------------------- +# Trace this macro to discover what tags are supported by the libtool +# --tag option, using: +# autoconf --trace 'LT_SUPPORTED_TAG:$1' +AC_DEFUN([LT_SUPPORTED_TAG], []) + + +# C support is built-in for now +m4_define([_LT_LANG_C_enabled], []) +m4_define([_LT_TAGS], []) + + +# LT_LANG(LANG) +# ------------- +# Enable libtool support for the given language if not already enabled. +AC_DEFUN([LT_LANG], +[AC_BEFORE([$0], [LT_OUTPUT])dnl +m4_case([$1], + [C], [_LT_LANG(C)], + [C++], [_LT_LANG(CXX)], + [Go], [_LT_LANG(GO)], + [Java], [_LT_LANG(GCJ)], + [Fortran 77], [_LT_LANG(F77)], + [Fortran], [_LT_LANG(FC)], + [Windows Resource], [_LT_LANG(RC)], + [m4_ifdef([_LT_LANG_]$1[_CONFIG], + [_LT_LANG($1)], + [m4_fatal([$0: unsupported language: "$1"])])])dnl +])# LT_LANG + + +# _LT_LANG(LANGNAME) +# ------------------ +m4_defun([_LT_LANG], +[m4_ifdef([_LT_LANG_]$1[_enabled], [], + [LT_SUPPORTED_TAG([$1])dnl + m4_append([_LT_TAGS], [$1 ])dnl + m4_define([_LT_LANG_]$1[_enabled], [])dnl + _LT_LANG_$1_CONFIG($1)])dnl +])# _LT_LANG + + +m4_ifndef([AC_PROG_GO], [ +############################################################ +# NOTE: This macro has been submitted for inclusion into # +# GNU Autoconf as AC_PROG_GO. When it is available in # +# a released version of Autoconf we should remove this # +# macro and use it instead. # +############################################################ +m4_defun([AC_PROG_GO], +[AC_LANG_PUSH(Go)dnl +AC_ARG_VAR([GOC], [Go compiler command])dnl +AC_ARG_VAR([GOFLAGS], [Go compiler flags])dnl +_AC_ARG_VAR_LDFLAGS()dnl +AC_CHECK_TOOL(GOC, gccgo) +if test -z "$GOC"; then + if test -n "$ac_tool_prefix"; then + AC_CHECK_PROG(GOC, [${ac_tool_prefix}gccgo], [${ac_tool_prefix}gccgo]) + fi +fi +if test -z "$GOC"; then + AC_CHECK_PROG(GOC, gccgo, gccgo, false) +fi +])#m4_defun +])#m4_ifndef + + +# _LT_LANG_DEFAULT_CONFIG +# ----------------------- +m4_defun([_LT_LANG_DEFAULT_CONFIG], +[AC_PROVIDE_IFELSE([AC_PROG_CXX], + [LT_LANG(CXX)], + [m4_define([AC_PROG_CXX], defn([AC_PROG_CXX])[LT_LANG(CXX)])]) + +AC_PROVIDE_IFELSE([AC_PROG_F77], + [LT_LANG(F77)], + [m4_define([AC_PROG_F77], defn([AC_PROG_F77])[LT_LANG(F77)])]) + +AC_PROVIDE_IFELSE([AC_PROG_FC], + [LT_LANG(FC)], + [m4_define([AC_PROG_FC], defn([AC_PROG_FC])[LT_LANG(FC)])]) + +dnl The call to [A][M_PROG_GCJ] is quoted like that to stop aclocal +dnl pulling things in needlessly. +AC_PROVIDE_IFELSE([AC_PROG_GCJ], + [LT_LANG(GCJ)], + [AC_PROVIDE_IFELSE([A][M_PROG_GCJ], + [LT_LANG(GCJ)], + [AC_PROVIDE_IFELSE([LT_PROG_GCJ], + [LT_LANG(GCJ)], + [m4_ifdef([AC_PROG_GCJ], + [m4_define([AC_PROG_GCJ], defn([AC_PROG_GCJ])[LT_LANG(GCJ)])]) + m4_ifdef([A][M_PROG_GCJ], + [m4_define([A][M_PROG_GCJ], defn([A][M_PROG_GCJ])[LT_LANG(GCJ)])]) + m4_ifdef([LT_PROG_GCJ], + [m4_define([LT_PROG_GCJ], defn([LT_PROG_GCJ])[LT_LANG(GCJ)])])])])]) + +AC_PROVIDE_IFELSE([AC_PROG_GO], + [LT_LANG(GO)], + [m4_define([AC_PROG_GO], defn([AC_PROG_GO])[LT_LANG(GO)])]) + +AC_PROVIDE_IFELSE([LT_PROG_RC], + [LT_LANG(RC)], + [m4_define([LT_PROG_RC], defn([LT_PROG_RC])[LT_LANG(RC)])]) +])# _LT_LANG_DEFAULT_CONFIG + +# Obsolete macros: +AU_DEFUN([AC_LIBTOOL_CXX], [LT_LANG(C++)]) +AU_DEFUN([AC_LIBTOOL_F77], [LT_LANG(Fortran 77)]) +AU_DEFUN([AC_LIBTOOL_FC], [LT_LANG(Fortran)]) +AU_DEFUN([AC_LIBTOOL_GCJ], [LT_LANG(Java)]) +AU_DEFUN([AC_LIBTOOL_RC], [LT_LANG(Windows Resource)]) +dnl aclocal-1.4 backwards compatibility: +dnl AC_DEFUN([AC_LIBTOOL_CXX], []) +dnl AC_DEFUN([AC_LIBTOOL_F77], []) +dnl AC_DEFUN([AC_LIBTOOL_FC], []) +dnl AC_DEFUN([AC_LIBTOOL_GCJ], []) +dnl AC_DEFUN([AC_LIBTOOL_RC], []) + + +# _LT_TAG_COMPILER +# ---------------- +m4_defun([_LT_TAG_COMPILER], +[AC_REQUIRE([AC_PROG_CC])dnl + +_LT_DECL([LTCC], [CC], [1], [A C compiler])dnl +_LT_DECL([LTCFLAGS], [CFLAGS], [1], [LTCC compiler flags])dnl +_LT_TAGDECL([CC], [compiler], [1], [A language specific compiler])dnl +_LT_TAGDECL([with_gcc], [GCC], [0], [Is the compiler the GNU compiler?])dnl + +# If no C compiler was specified, use CC. +LTCC=${LTCC-"$CC"} + +# If no C compiler flags were specified, use CFLAGS. +LTCFLAGS=${LTCFLAGS-"$CFLAGS"} + +# Allow CC to be a program name with arguments. +compiler=$CC +])# _LT_TAG_COMPILER + + +# _LT_COMPILER_BOILERPLATE +# ------------------------ +# Check for compiler boilerplate output or warnings with +# the simple compiler test code. +m4_defun([_LT_COMPILER_BOILERPLATE], +[m4_require([_LT_DECL_SED])dnl +ac_outfile=conftest.$ac_objext +echo "$lt_simple_compile_test_code" >conftest.$ac_ext +eval "$ac_compile" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err +_lt_compiler_boilerplate=`cat conftest.err` +$RM conftest* +])# _LT_COMPILER_BOILERPLATE + + +# _LT_LINKER_BOILERPLATE +# ---------------------- +# Check for linker boilerplate output or warnings with +# the simple link test code. +m4_defun([_LT_LINKER_BOILERPLATE], +[m4_require([_LT_DECL_SED])dnl +ac_outfile=conftest.$ac_objext +echo "$lt_simple_link_test_code" >conftest.$ac_ext +eval "$ac_link" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err +_lt_linker_boilerplate=`cat conftest.err` +$RM -r conftest* +])# _LT_LINKER_BOILERPLATE + +# _LT_REQUIRED_DARWIN_CHECKS +# ------------------------- +m4_defun_once([_LT_REQUIRED_DARWIN_CHECKS],[ + case $host_os in + rhapsody* | darwin*) + AC_CHECK_TOOL([DSYMUTIL], [dsymutil], [:]) + AC_CHECK_TOOL([NMEDIT], [nmedit], [:]) + AC_CHECK_TOOL([LIPO], [lipo], [:]) + AC_CHECK_TOOL([OTOOL], [otool], [:]) + AC_CHECK_TOOL([OTOOL64], [otool64], [:]) + _LT_DECL([], [DSYMUTIL], [1], + [Tool to manipulate archived DWARF debug symbol files on Mac OS X]) + _LT_DECL([], [NMEDIT], [1], + [Tool to change global to local symbols on Mac OS X]) + _LT_DECL([], [LIPO], [1], + [Tool to manipulate fat objects and archives on Mac OS X]) + _LT_DECL([], [OTOOL], [1], + [ldd/readelf like tool for Mach-O binaries on Mac OS X]) + _LT_DECL([], [OTOOL64], [1], + [ldd/readelf like tool for 64 bit Mach-O binaries on Mac OS X 10.4]) + + AC_CACHE_CHECK([for -single_module linker flag],[lt_cv_apple_cc_single_mod], + [lt_cv_apple_cc_single_mod=no + if test -z "${LT_MULTI_MODULE}"; then + # By default we will add the -single_module flag. You can override + # by either setting the environment variable LT_MULTI_MODULE + # non-empty at configure time, or by adding -multi_module to the + # link flags. + rm -rf libconftest.dylib* + echo "int foo(void){return 1;}" > conftest.c + echo "$LTCC $LTCFLAGS $LDFLAGS -o libconftest.dylib \ +-dynamiclib -Wl,-single_module conftest.c" >&AS_MESSAGE_LOG_FD + $LTCC $LTCFLAGS $LDFLAGS -o libconftest.dylib \ + -dynamiclib -Wl,-single_module conftest.c 2>conftest.err + _lt_result=$? + # If there is a non-empty error log, and "single_module" + # appears in it, assume the flag caused a linker warning + if test -s conftest.err && $GREP single_module conftest.err; then + cat conftest.err >&AS_MESSAGE_LOG_FD + # Otherwise, if the output was created with a 0 exit code from + # the compiler, it worked. + elif test -f libconftest.dylib && test $_lt_result -eq 0; then + lt_cv_apple_cc_single_mod=yes + else + cat conftest.err >&AS_MESSAGE_LOG_FD + fi + rm -rf libconftest.dylib* + rm -f conftest.* + fi]) + + AC_CACHE_CHECK([for -exported_symbols_list linker flag], + [lt_cv_ld_exported_symbols_list], + [lt_cv_ld_exported_symbols_list=no + save_LDFLAGS=$LDFLAGS + echo "_main" > conftest.sym + LDFLAGS="$LDFLAGS -Wl,-exported_symbols_list,conftest.sym" + AC_LINK_IFELSE([AC_LANG_PROGRAM([],[])], + [lt_cv_ld_exported_symbols_list=yes], + [lt_cv_ld_exported_symbols_list=no]) + LDFLAGS="$save_LDFLAGS" + ]) + + AC_CACHE_CHECK([for -force_load linker flag],[lt_cv_ld_force_load], + [lt_cv_ld_force_load=no + cat > conftest.c << _LT_EOF +int forced_loaded() { return 2;} +_LT_EOF + echo "$LTCC $LTCFLAGS -c -o conftest.o conftest.c" >&AS_MESSAGE_LOG_FD + $LTCC $LTCFLAGS -c -o conftest.o conftest.c 2>&AS_MESSAGE_LOG_FD + echo "$AR cru libconftest.a conftest.o" >&AS_MESSAGE_LOG_FD + $AR cru libconftest.a conftest.o 2>&AS_MESSAGE_LOG_FD + echo "$RANLIB libconftest.a" >&AS_MESSAGE_LOG_FD + $RANLIB libconftest.a 2>&AS_MESSAGE_LOG_FD + cat > conftest.c << _LT_EOF +int main() { return 0;} +_LT_EOF + echo "$LTCC $LTCFLAGS $LDFLAGS -o conftest conftest.c -Wl,-force_load,./libconftest.a" >&AS_MESSAGE_LOG_FD + $LTCC $LTCFLAGS $LDFLAGS -o conftest conftest.c -Wl,-force_load,./libconftest.a 2>conftest.err + _lt_result=$? + if test -s conftest.err && $GREP force_load conftest.err; then + cat conftest.err >&AS_MESSAGE_LOG_FD + elif test -f conftest && test $_lt_result -eq 0 && $GREP forced_load conftest >/dev/null 2>&1 ; then + lt_cv_ld_force_load=yes + else + cat conftest.err >&AS_MESSAGE_LOG_FD + fi + rm -f conftest.err libconftest.a conftest conftest.c + rm -rf conftest.dSYM + ]) + case $host_os in + rhapsody* | darwin1.[[012]]) + _lt_dar_allow_undefined='${wl}-undefined ${wl}suppress' ;; + darwin1.*) + _lt_dar_allow_undefined='${wl}-flat_namespace ${wl}-undefined ${wl}suppress' ;; + darwin*) # darwin 5.x on + # if running on 10.5 or later, the deployment target defaults + # to the OS version, if on x86, and 10.4, the deployment + # target defaults to 10.4. Don't you love it? + case ${MACOSX_DEPLOYMENT_TARGET-10.0},$host in + 10.0,*86*-darwin8*|10.0,*-darwin[[91]]*) + _lt_dar_allow_undefined='${wl}-undefined ${wl}dynamic_lookup' ;; + 10.[[012]]*) + _lt_dar_allow_undefined='${wl}-flat_namespace ${wl}-undefined ${wl}suppress' ;; + 10.*) + _lt_dar_allow_undefined='${wl}-undefined ${wl}dynamic_lookup' ;; + esac + ;; + esac + if test "$lt_cv_apple_cc_single_mod" = "yes"; then + _lt_dar_single_mod='$single_module' + fi + if test "$lt_cv_ld_exported_symbols_list" = "yes"; then + _lt_dar_export_syms=' ${wl}-exported_symbols_list,$output_objdir/${libname}-symbols.expsym' + else + _lt_dar_export_syms='~$NMEDIT -s $output_objdir/${libname}-symbols.expsym ${lib}' + fi + if test "$DSYMUTIL" != ":" && test "$lt_cv_ld_force_load" = "no"; then + _lt_dsymutil='~$DSYMUTIL $lib || :' + else + _lt_dsymutil= + fi + ;; + esac +]) + + +# _LT_DARWIN_LINKER_FEATURES([TAG]) +# --------------------------------- +# Checks for linker and compiler features on darwin +m4_defun([_LT_DARWIN_LINKER_FEATURES], +[ + m4_require([_LT_REQUIRED_DARWIN_CHECKS]) + _LT_TAGVAR(archive_cmds_need_lc, $1)=no + _LT_TAGVAR(hardcode_direct, $1)=no + _LT_TAGVAR(hardcode_automatic, $1)=yes + _LT_TAGVAR(hardcode_shlibpath_var, $1)=unsupported + if test "$lt_cv_ld_force_load" = "yes"; then + _LT_TAGVAR(whole_archive_flag_spec, $1)='`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience ${wl}-force_load,$conv\"; done; func_echo_all \"$new_convenience\"`' + m4_case([$1], [F77], [_LT_TAGVAR(compiler_needs_object, $1)=yes], + [FC], [_LT_TAGVAR(compiler_needs_object, $1)=yes]) + else + _LT_TAGVAR(whole_archive_flag_spec, $1)='' + fi + _LT_TAGVAR(link_all_deplibs, $1)=yes + _LT_TAGVAR(allow_undefined_flag, $1)="$_lt_dar_allow_undefined" + case $cc_basename in + ifort*) _lt_dar_can_shared=yes ;; + *) _lt_dar_can_shared=$GCC ;; + esac + if test "$_lt_dar_can_shared" = "yes"; then + output_verbose_link_cmd=func_echo_all + _LT_TAGVAR(archive_cmds, $1)="\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring $_lt_dar_single_mod${_lt_dsymutil}" + _LT_TAGVAR(module_cmds, $1)="\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags${_lt_dsymutil}" + _LT_TAGVAR(archive_expsym_cmds, $1)="sed 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring ${_lt_dar_single_mod}${_lt_dar_export_syms}${_lt_dsymutil}" + _LT_TAGVAR(module_expsym_cmds, $1)="sed -e 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags${_lt_dar_export_syms}${_lt_dsymutil}" + m4_if([$1], [CXX], +[ if test "$lt_cv_apple_cc_single_mod" != "yes"; then + _LT_TAGVAR(archive_cmds, $1)="\$CC -r -keep_private_externs -nostdlib -o \${lib}-master.o \$libobjs~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \${lib}-master.o \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring${_lt_dsymutil}" + _LT_TAGVAR(archive_expsym_cmds, $1)="sed 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC -r -keep_private_externs -nostdlib -o \${lib}-master.o \$libobjs~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \${lib}-master.o \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring${_lt_dar_export_syms}${_lt_dsymutil}" + fi +],[]) + else + _LT_TAGVAR(ld_shlibs, $1)=no + fi +]) + +# _LT_SYS_MODULE_PATH_AIX([TAGNAME]) +# ---------------------------------- +# Links a minimal program and checks the executable +# for the system default hardcoded library path. In most cases, +# this is /usr/lib:/lib, but when the MPI compilers are used +# the location of the communication and MPI libs are included too. +# If we don't find anything, use the default library path according +# to the aix ld manual. +# Store the results from the different compilers for each TAGNAME. +# Allow to override them for all tags through lt_cv_aix_libpath. +m4_defun([_LT_SYS_MODULE_PATH_AIX], +[m4_require([_LT_DECL_SED])dnl +if test "${lt_cv_aix_libpath+set}" = set; then + aix_libpath=$lt_cv_aix_libpath +else + AC_CACHE_VAL([_LT_TAGVAR([lt_cv_aix_libpath_], [$1])], + [AC_LINK_IFELSE([AC_LANG_PROGRAM],[ + lt_aix_libpath_sed='[ + /Import File Strings/,/^$/ { + /^0/ { + s/^0 *\([^ ]*\) *$/\1/ + p + } + }]' + _LT_TAGVAR([lt_cv_aix_libpath_], [$1])=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"` + # Check for a 64-bit object if we didn't find anything. + if test -z "$_LT_TAGVAR([lt_cv_aix_libpath_], [$1])"; then + _LT_TAGVAR([lt_cv_aix_libpath_], [$1])=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"` + fi],[]) + if test -z "$_LT_TAGVAR([lt_cv_aix_libpath_], [$1])"; then + _LT_TAGVAR([lt_cv_aix_libpath_], [$1])="/usr/lib:/lib" + fi + ]) + aix_libpath=$_LT_TAGVAR([lt_cv_aix_libpath_], [$1]) +fi +])# _LT_SYS_MODULE_PATH_AIX + + +# _LT_SHELL_INIT(ARG) +# ------------------- +m4_define([_LT_SHELL_INIT], +[m4_divert_text([M4SH-INIT], [$1 +])])# _LT_SHELL_INIT + + + +# _LT_PROG_ECHO_BACKSLASH +# ----------------------- +# Find how we can fake an echo command that does not interpret backslash. +# In particular, with Autoconf 2.60 or later we add some code to the start +# of the generated configure script which will find a shell with a builtin +# printf (which we can use as an echo command). +m4_defun([_LT_PROG_ECHO_BACKSLASH], +[ECHO='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' +ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO +ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO$ECHO + +AC_MSG_CHECKING([how to print strings]) +# Test print first, because it will be a builtin if present. +if test "X`( print -r -- -n ) 2>/dev/null`" = X-n && \ + test "X`print -r -- $ECHO 2>/dev/null`" = "X$ECHO"; then + ECHO='print -r --' +elif test "X`printf %s $ECHO 2>/dev/null`" = "X$ECHO"; then + ECHO='printf %s\n' +else + # Use this function as a fallback that always works. + func_fallback_echo () + { + eval 'cat <<_LTECHO_EOF +$[]1 +_LTECHO_EOF' + } + ECHO='func_fallback_echo' +fi + +# func_echo_all arg... +# Invoke $ECHO with all args, space-separated. +func_echo_all () +{ + $ECHO "$*" +} + +case "$ECHO" in + printf*) AC_MSG_RESULT([printf]) ;; + print*) AC_MSG_RESULT([print -r]) ;; + *) AC_MSG_RESULT([cat]) ;; +esac + +m4_ifdef([_AS_DETECT_SUGGESTED], +[_AS_DETECT_SUGGESTED([ + test -n "${ZSH_VERSION+set}${BASH_VERSION+set}" || ( + ECHO='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' + ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO + ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO$ECHO + PATH=/empty FPATH=/empty; export PATH FPATH + test "X`printf %s $ECHO`" = "X$ECHO" \ + || test "X`print -r -- $ECHO`" = "X$ECHO" )])]) + +_LT_DECL([], [SHELL], [1], [Shell to use when invoking shell scripts]) +_LT_DECL([], [ECHO], [1], [An echo program that protects backslashes]) +])# _LT_PROG_ECHO_BACKSLASH + + +# _LT_WITH_SYSROOT +# ---------------- +AC_DEFUN([_LT_WITH_SYSROOT], +[AC_MSG_CHECKING([for sysroot]) +AC_ARG_WITH([sysroot], +[ --with-sysroot[=DIR] Search for dependent libraries within DIR + (or the compiler's sysroot if not specified).], +[], [with_sysroot=no]) + +dnl lt_sysroot will always be passed unquoted. We quote it here +dnl in case the user passed a directory name. +lt_sysroot= +case ${with_sysroot} in #( + yes) + if test "$GCC" = yes; then + lt_sysroot=`$CC --print-sysroot 2>/dev/null` + fi + ;; #( + /*) + lt_sysroot=`echo "$with_sysroot" | sed -e "$sed_quote_subst"` + ;; #( + no|'') + ;; #( + *) + AC_MSG_RESULT([${with_sysroot}]) + AC_MSG_ERROR([The sysroot must be an absolute path.]) + ;; +esac + + AC_MSG_RESULT([${lt_sysroot:-no}]) +_LT_DECL([], [lt_sysroot], [0], [The root where to search for ]dnl +[dependent libraries, and in which our libraries should be installed.])]) + +# _LT_ENABLE_LOCK +# --------------- +m4_defun([_LT_ENABLE_LOCK], +[AC_ARG_ENABLE([libtool-lock], + [AS_HELP_STRING([--disable-libtool-lock], + [avoid locking (might break parallel builds)])]) +test "x$enable_libtool_lock" != xno && enable_libtool_lock=yes + +# Some flags need to be propagated to the compiler or linker for good +# libtool support. +case $host in +ia64-*-hpux*) + # Find out which ABI we are using. + echo 'int i;' > conftest.$ac_ext + if AC_TRY_EVAL(ac_compile); then + case `/usr/bin/file conftest.$ac_objext` in + *ELF-32*) + HPUX_IA64_MODE="32" + ;; + *ELF-64*) + HPUX_IA64_MODE="64" + ;; + esac + fi + rm -rf conftest* + ;; +*-*-irix6*) + # Find out which ABI we are using. + echo '[#]line '$LINENO' "configure"' > conftest.$ac_ext + if AC_TRY_EVAL(ac_compile); then + if test "$lt_cv_prog_gnu_ld" = yes; then + case `/usr/bin/file conftest.$ac_objext` in + *32-bit*) + LD="${LD-ld} -melf32bsmip" + ;; + *N32*) + LD="${LD-ld} -melf32bmipn32" + ;; + *64-bit*) + LD="${LD-ld} -melf64bmip" + ;; + esac + else + case `/usr/bin/file conftest.$ac_objext` in + *32-bit*) + LD="${LD-ld} -32" + ;; + *N32*) + LD="${LD-ld} -n32" + ;; + *64-bit*) + LD="${LD-ld} -64" + ;; + esac + fi + fi + rm -rf conftest* + ;; + +x86_64-*kfreebsd*-gnu|x86_64-*linux*|ppc*-*linux*|powerpc*-*linux*| \ +s390*-*linux*|s390*-*tpf*|sparc*-*linux*) + # Find out which ABI we are using. + echo 'int i;' > conftest.$ac_ext + if AC_TRY_EVAL(ac_compile); then + case `/usr/bin/file conftest.o` in + *32-bit*) + case $host in + x86_64-*kfreebsd*-gnu) + LD="${LD-ld} -m elf_i386_fbsd" + ;; + x86_64-*linux*) + case `/usr/bin/file conftest.o` in + *x86-64*) + LD="${LD-ld} -m elf32_x86_64" + ;; + *) + LD="${LD-ld} -m elf_i386" + ;; + esac + ;; + ppc64-*linux*|powerpc64-*linux*) + LD="${LD-ld} -m elf32ppclinux" + ;; + s390x-*linux*) + LD="${LD-ld} -m elf_s390" + ;; + sparc64-*linux*) + LD="${LD-ld} -m elf32_sparc" + ;; + esac + ;; + *64-bit*) + case $host in + x86_64-*kfreebsd*-gnu) + LD="${LD-ld} -m elf_x86_64_fbsd" + ;; + x86_64-*linux*) + LD="${LD-ld} -m elf_x86_64" + ;; + ppc*-*linux*|powerpc*-*linux*) + LD="${LD-ld} -m elf64ppc" + ;; + s390*-*linux*|s390*-*tpf*) + LD="${LD-ld} -m elf64_s390" + ;; + sparc*-*linux*) + LD="${LD-ld} -m elf64_sparc" + ;; + esac + ;; + esac + fi + rm -rf conftest* + ;; + +*-*-sco3.2v5*) + # On SCO OpenServer 5, we need -belf to get full-featured binaries. + SAVE_CFLAGS="$CFLAGS" + CFLAGS="$CFLAGS -belf" + AC_CACHE_CHECK([whether the C compiler needs -belf], lt_cv_cc_needs_belf, + [AC_LANG_PUSH(C) + AC_LINK_IFELSE([AC_LANG_PROGRAM([[]],[[]])],[lt_cv_cc_needs_belf=yes],[lt_cv_cc_needs_belf=no]) + AC_LANG_POP]) + if test x"$lt_cv_cc_needs_belf" != x"yes"; then + # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf + CFLAGS="$SAVE_CFLAGS" + fi + ;; +*-*solaris*) + # Find out which ABI we are using. + echo 'int i;' > conftest.$ac_ext + if AC_TRY_EVAL(ac_compile); then + case `/usr/bin/file conftest.o` in + *64-bit*) + case $lt_cv_prog_gnu_ld in + yes*) + case $host in + i?86-*-solaris*) + LD="${LD-ld} -m elf_x86_64" + ;; + sparc*-*-solaris*) + LD="${LD-ld} -m elf64_sparc" + ;; + esac + # GNU ld 2.21 introduced _sol2 emulations. Use them if available. + if ${LD-ld} -V | grep _sol2 >/dev/null 2>&1; then + LD="${LD-ld}_sol2" + fi + ;; + *) + if ${LD-ld} -64 -r -o conftest2.o conftest.o >/dev/null 2>&1; then + LD="${LD-ld} -64" + fi + ;; + esac + ;; + esac + fi + rm -rf conftest* + ;; +esac + +need_locks="$enable_libtool_lock" +])# _LT_ENABLE_LOCK + + +# _LT_PROG_AR +# ----------- +m4_defun([_LT_PROG_AR], +[AC_CHECK_TOOLS(AR, [ar], false) +: ${AR=ar} +: ${AR_FLAGS=cru} +_LT_DECL([], [AR], [1], [The archiver]) +_LT_DECL([], [AR_FLAGS], [1], [Flags to create an archive]) + +AC_CACHE_CHECK([for archiver @FILE support], [lt_cv_ar_at_file], + [lt_cv_ar_at_file=no + AC_COMPILE_IFELSE([AC_LANG_PROGRAM], + [echo conftest.$ac_objext > conftest.lst + lt_ar_try='$AR $AR_FLAGS libconftest.a @conftest.lst >&AS_MESSAGE_LOG_FD' + AC_TRY_EVAL([lt_ar_try]) + if test "$ac_status" -eq 0; then + # Ensure the archiver fails upon bogus file names. + rm -f conftest.$ac_objext libconftest.a + AC_TRY_EVAL([lt_ar_try]) + if test "$ac_status" -ne 0; then + lt_cv_ar_at_file=@ + fi + fi + rm -f conftest.* libconftest.a + ]) + ]) + +if test "x$lt_cv_ar_at_file" = xno; then + archiver_list_spec= +else + archiver_list_spec=$lt_cv_ar_at_file +fi +_LT_DECL([], [archiver_list_spec], [1], + [How to feed a file listing to the archiver]) +])# _LT_PROG_AR + + +# _LT_CMD_OLD_ARCHIVE +# ------------------- +m4_defun([_LT_CMD_OLD_ARCHIVE], +[_LT_PROG_AR + +AC_CHECK_TOOL(STRIP, strip, :) +test -z "$STRIP" && STRIP=: +_LT_DECL([], [STRIP], [1], [A symbol stripping program]) + +AC_CHECK_TOOL(RANLIB, ranlib, :) +test -z "$RANLIB" && RANLIB=: +_LT_DECL([], [RANLIB], [1], + [Commands used to install an old-style archive]) + +# Determine commands to create old-style static archives. +old_archive_cmds='$AR $AR_FLAGS $oldlib$oldobjs' +old_postinstall_cmds='chmod 644 $oldlib' +old_postuninstall_cmds= + +if test -n "$RANLIB"; then + case $host_os in + openbsd*) + old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB -t \$tool_oldlib" + ;; + *) + old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB \$tool_oldlib" + ;; + esac + old_archive_cmds="$old_archive_cmds~\$RANLIB \$tool_oldlib" +fi + +case $host_os in + darwin*) + lock_old_archive_extraction=yes ;; + *) + lock_old_archive_extraction=no ;; +esac +_LT_DECL([], [old_postinstall_cmds], [2]) +_LT_DECL([], [old_postuninstall_cmds], [2]) +_LT_TAGDECL([], [old_archive_cmds], [2], + [Commands used to build an old-style archive]) +_LT_DECL([], [lock_old_archive_extraction], [0], + [Whether to use a lock for old archive extraction]) +])# _LT_CMD_OLD_ARCHIVE + + +# _LT_COMPILER_OPTION(MESSAGE, VARIABLE-NAME, FLAGS, +# [OUTPUT-FILE], [ACTION-SUCCESS], [ACTION-FAILURE]) +# ---------------------------------------------------------------- +# Check whether the given compiler option works +AC_DEFUN([_LT_COMPILER_OPTION], +[m4_require([_LT_FILEUTILS_DEFAULTS])dnl +m4_require([_LT_DECL_SED])dnl +AC_CACHE_CHECK([$1], [$2], + [$2=no + m4_if([$4], , [ac_outfile=conftest.$ac_objext], [ac_outfile=$4]) + echo "$lt_simple_compile_test_code" > conftest.$ac_ext + lt_compiler_flag="$3" + # Insert the option either (1) after the last *FLAGS variable, or + # (2) before a word containing "conftest.", or (3) at the end. + # Note that $ac_compile itself does not contain backslashes and begins + # with a dollar sign (not a hyphen), so the echo should work correctly. + # The option is referenced via a variable to avoid confusing sed. + lt_compile=`echo "$ac_compile" | $SED \ + -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \ + -e 's: [[^ ]]*conftest\.: $lt_compiler_flag&:; t' \ + -e 's:$: $lt_compiler_flag:'` + (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&AS_MESSAGE_LOG_FD) + (eval "$lt_compile" 2>conftest.err) + ac_status=$? + cat conftest.err >&AS_MESSAGE_LOG_FD + echo "$as_me:$LINENO: \$? = $ac_status" >&AS_MESSAGE_LOG_FD + if (exit $ac_status) && test -s "$ac_outfile"; then + # The compiler can only warn and ignore the option if not recognized + # So say no if there are warnings other than the usual output. + $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' >conftest.exp + $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2 + if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then + $2=yes + fi + fi + $RM conftest* +]) + +if test x"[$]$2" = xyes; then + m4_if([$5], , :, [$5]) +else + m4_if([$6], , :, [$6]) +fi +])# _LT_COMPILER_OPTION + +# Old name: +AU_ALIAS([AC_LIBTOOL_COMPILER_OPTION], [_LT_COMPILER_OPTION]) +dnl aclocal-1.4 backwards compatibility: +dnl AC_DEFUN([AC_LIBTOOL_COMPILER_OPTION], []) + + +# _LT_LINKER_OPTION(MESSAGE, VARIABLE-NAME, FLAGS, +# [ACTION-SUCCESS], [ACTION-FAILURE]) +# ---------------------------------------------------- +# Check whether the given linker option works +AC_DEFUN([_LT_LINKER_OPTION], +[m4_require([_LT_FILEUTILS_DEFAULTS])dnl +m4_require([_LT_DECL_SED])dnl +AC_CACHE_CHECK([$1], [$2], + [$2=no + save_LDFLAGS="$LDFLAGS" + LDFLAGS="$LDFLAGS $3" + echo "$lt_simple_link_test_code" > conftest.$ac_ext + if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then + # The linker can only warn and ignore the option if not recognized + # So say no if there are warnings + if test -s conftest.err; then + # Append any errors to the config.log. + cat conftest.err 1>&AS_MESSAGE_LOG_FD + $ECHO "$_lt_linker_boilerplate" | $SED '/^$/d' > conftest.exp + $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2 + if diff conftest.exp conftest.er2 >/dev/null; then + $2=yes + fi + else + $2=yes + fi + fi + $RM -r conftest* + LDFLAGS="$save_LDFLAGS" +]) + +if test x"[$]$2" = xyes; then + m4_if([$4], , :, [$4]) +else + m4_if([$5], , :, [$5]) +fi +])# _LT_LINKER_OPTION + +# Old name: +AU_ALIAS([AC_LIBTOOL_LINKER_OPTION], [_LT_LINKER_OPTION]) +dnl aclocal-1.4 backwards compatibility: +dnl AC_DEFUN([AC_LIBTOOL_LINKER_OPTION], []) + + +# LT_CMD_MAX_LEN +#--------------- +AC_DEFUN([LT_CMD_MAX_LEN], +[AC_REQUIRE([AC_CANONICAL_HOST])dnl +# find the maximum length of command line arguments +AC_MSG_CHECKING([the maximum length of command line arguments]) +AC_CACHE_VAL([lt_cv_sys_max_cmd_len], [dnl + i=0 + teststring="ABCD" + + case $build_os in + msdosdjgpp*) + # On DJGPP, this test can blow up pretty badly due to problems in libc + # (any single argument exceeding 2000 bytes causes a buffer overrun + # during glob expansion). Even if it were fixed, the result of this + # check would be larger than it should be. + lt_cv_sys_max_cmd_len=12288; # 12K is about right + ;; + + gnu*) + # Under GNU Hurd, this test is not required because there is + # no limit to the length of command line arguments. + # Libtool will interpret -1 as no limit whatsoever + lt_cv_sys_max_cmd_len=-1; + ;; + + cygwin* | mingw* | cegcc*) + # On Win9x/ME, this test blows up -- it succeeds, but takes + # about 5 minutes as the teststring grows exponentially. + # Worse, since 9x/ME are not pre-emptively multitasking, + # you end up with a "frozen" computer, even though with patience + # the test eventually succeeds (with a max line length of 256k). + # Instead, let's just punt: use the minimum linelength reported by + # all of the supported platforms: 8192 (on NT/2K/XP). + lt_cv_sys_max_cmd_len=8192; + ;; + + mint*) + # On MiNT this can take a long time and run out of memory. + lt_cv_sys_max_cmd_len=8192; + ;; + + amigaos*) + # On AmigaOS with pdksh, this test takes hours, literally. + # So we just punt and use a minimum line length of 8192. + lt_cv_sys_max_cmd_len=8192; + ;; + + netbsd* | freebsd* | openbsd* | darwin* | dragonfly*) + # This has been around since 386BSD, at least. Likely further. + if test -x /sbin/sysctl; then + lt_cv_sys_max_cmd_len=`/sbin/sysctl -n kern.argmax` + elif test -x /usr/sbin/sysctl; then + lt_cv_sys_max_cmd_len=`/usr/sbin/sysctl -n kern.argmax` + else + lt_cv_sys_max_cmd_len=65536 # usable default for all BSDs + fi + # And add a safety zone + lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4` + lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3` + ;; + + interix*) + # We know the value 262144 and hardcode it with a safety zone (like BSD) + lt_cv_sys_max_cmd_len=196608 + ;; + + os2*) + # The test takes a long time on OS/2. + lt_cv_sys_max_cmd_len=8192 + ;; + + osf*) + # Dr. Hans Ekkehard Plesser reports seeing a kernel panic running configure + # due to this test when exec_disable_arg_limit is 1 on Tru64. It is not + # nice to cause kernel panics so lets avoid the loop below. + # First set a reasonable default. + lt_cv_sys_max_cmd_len=16384 + # + if test -x /sbin/sysconfig; then + case `/sbin/sysconfig -q proc exec_disable_arg_limit` in + *1*) lt_cv_sys_max_cmd_len=-1 ;; + esac + fi + ;; + sco3.2v5*) + lt_cv_sys_max_cmd_len=102400 + ;; + sysv5* | sco5v6* | sysv4.2uw2*) + kargmax=`grep ARG_MAX /etc/conf/cf.d/stune 2>/dev/null` + if test -n "$kargmax"; then + lt_cv_sys_max_cmd_len=`echo $kargmax | sed 's/.*[[ ]]//'` + else + lt_cv_sys_max_cmd_len=32768 + fi + ;; + *) + lt_cv_sys_max_cmd_len=`(getconf ARG_MAX) 2> /dev/null` + if test -n "$lt_cv_sys_max_cmd_len" && \ + test undefined != "$lt_cv_sys_max_cmd_len"; then + lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4` + lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3` + else + # Make teststring a little bigger before we do anything with it. + # a 1K string should be a reasonable start. + for i in 1 2 3 4 5 6 7 8 ; do + teststring=$teststring$teststring + done + SHELL=${SHELL-${CONFIG_SHELL-/bin/sh}} + # If test is not a shell built-in, we'll probably end up computing a + # maximum length that is only half of the actual maximum length, but + # we can't tell. + while { test "X"`env echo "$teststring$teststring" 2>/dev/null` \ + = "X$teststring$teststring"; } >/dev/null 2>&1 && + test $i != 17 # 1/2 MB should be enough + do + i=`expr $i + 1` + teststring=$teststring$teststring + done + # Only check the string length outside the loop. + lt_cv_sys_max_cmd_len=`expr "X$teststring" : ".*" 2>&1` + teststring= + # Add a significant safety factor because C++ compilers can tack on + # massive amounts of additional arguments before passing them to the + # linker. It appears as though 1/2 is a usable value. + lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 2` + fi + ;; + esac +]) +if test -n $lt_cv_sys_max_cmd_len ; then + AC_MSG_RESULT($lt_cv_sys_max_cmd_len) +else + AC_MSG_RESULT(none) +fi +max_cmd_len=$lt_cv_sys_max_cmd_len +_LT_DECL([], [max_cmd_len], [0], + [What is the maximum length of a command?]) +])# LT_CMD_MAX_LEN + +# Old name: +AU_ALIAS([AC_LIBTOOL_SYS_MAX_CMD_LEN], [LT_CMD_MAX_LEN]) +dnl aclocal-1.4 backwards compatibility: +dnl AC_DEFUN([AC_LIBTOOL_SYS_MAX_CMD_LEN], []) + + +# _LT_HEADER_DLFCN +# ---------------- +m4_defun([_LT_HEADER_DLFCN], +[AC_CHECK_HEADERS([dlfcn.h], [], [], [AC_INCLUDES_DEFAULT])dnl +])# _LT_HEADER_DLFCN + + +# _LT_TRY_DLOPEN_SELF (ACTION-IF-TRUE, ACTION-IF-TRUE-W-USCORE, +# ACTION-IF-FALSE, ACTION-IF-CROSS-COMPILING) +# ---------------------------------------------------------------- +m4_defun([_LT_TRY_DLOPEN_SELF], +[m4_require([_LT_HEADER_DLFCN])dnl +if test "$cross_compiling" = yes; then : + [$4] +else + lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2 + lt_status=$lt_dlunknown + cat > conftest.$ac_ext <<_LT_EOF +[#line $LINENO "configure" +#include "confdefs.h" + +#if HAVE_DLFCN_H +#include +#endif + +#include + +#ifdef RTLD_GLOBAL +# define LT_DLGLOBAL RTLD_GLOBAL +#else +# ifdef DL_GLOBAL +# define LT_DLGLOBAL DL_GLOBAL +# else +# define LT_DLGLOBAL 0 +# endif +#endif + +/* We may have to define LT_DLLAZY_OR_NOW in the command line if we + find out it does not work in some platform. */ +#ifndef LT_DLLAZY_OR_NOW +# ifdef RTLD_LAZY +# define LT_DLLAZY_OR_NOW RTLD_LAZY +# else +# ifdef DL_LAZY +# define LT_DLLAZY_OR_NOW DL_LAZY +# else +# ifdef RTLD_NOW +# define LT_DLLAZY_OR_NOW RTLD_NOW +# else +# ifdef DL_NOW +# define LT_DLLAZY_OR_NOW DL_NOW +# else +# define LT_DLLAZY_OR_NOW 0 +# endif +# endif +# endif +# endif +#endif + +/* When -fvisbility=hidden is used, assume the code has been annotated + correspondingly for the symbols needed. */ +#if defined(__GNUC__) && (((__GNUC__ == 3) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 3)) +int fnord () __attribute__((visibility("default"))); +#endif + +int fnord () { return 42; } +int main () +{ + void *self = dlopen (0, LT_DLGLOBAL|LT_DLLAZY_OR_NOW); + int status = $lt_dlunknown; + + if (self) + { + if (dlsym (self,"fnord")) status = $lt_dlno_uscore; + else + { + if (dlsym( self,"_fnord")) status = $lt_dlneed_uscore; + else puts (dlerror ()); + } + /* dlclose (self); */ + } + else + puts (dlerror ()); + + return status; +}] +_LT_EOF + if AC_TRY_EVAL(ac_link) && test -s conftest${ac_exeext} 2>/dev/null; then + (./conftest; exit; ) >&AS_MESSAGE_LOG_FD 2>/dev/null + lt_status=$? + case x$lt_status in + x$lt_dlno_uscore) $1 ;; + x$lt_dlneed_uscore) $2 ;; + x$lt_dlunknown|x*) $3 ;; + esac + else : + # compilation failed + $3 + fi +fi +rm -fr conftest* +])# _LT_TRY_DLOPEN_SELF + + +# LT_SYS_DLOPEN_SELF +# ------------------ +AC_DEFUN([LT_SYS_DLOPEN_SELF], +[m4_require([_LT_HEADER_DLFCN])dnl +if test "x$enable_dlopen" != xyes; then + enable_dlopen=unknown + enable_dlopen_self=unknown + enable_dlopen_self_static=unknown +else + lt_cv_dlopen=no + lt_cv_dlopen_libs= + + case $host_os in + beos*) + lt_cv_dlopen="load_add_on" + lt_cv_dlopen_libs= + lt_cv_dlopen_self=yes + ;; + + mingw* | pw32* | cegcc*) + lt_cv_dlopen="LoadLibrary" + lt_cv_dlopen_libs= + ;; + + cygwin*) + lt_cv_dlopen="dlopen" + lt_cv_dlopen_libs= + ;; + + darwin*) + # if libdl is installed we need to link against it + AC_CHECK_LIB([dl], [dlopen], + [lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl"],[ + lt_cv_dlopen="dyld" + lt_cv_dlopen_libs= + lt_cv_dlopen_self=yes + ]) + ;; + + *) + AC_CHECK_FUNC([shl_load], + [lt_cv_dlopen="shl_load"], + [AC_CHECK_LIB([dld], [shl_load], + [lt_cv_dlopen="shl_load" lt_cv_dlopen_libs="-ldld"], + [AC_CHECK_FUNC([dlopen], + [lt_cv_dlopen="dlopen"], + [AC_CHECK_LIB([dl], [dlopen], + [lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl"], + [AC_CHECK_LIB([svld], [dlopen], + [lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-lsvld"], + [AC_CHECK_LIB([dld], [dld_link], + [lt_cv_dlopen="dld_link" lt_cv_dlopen_libs="-ldld"]) + ]) + ]) + ]) + ]) + ]) + ;; + esac + + if test "x$lt_cv_dlopen" != xno; then + enable_dlopen=yes + else + enable_dlopen=no + fi + + case $lt_cv_dlopen in + dlopen) + save_CPPFLAGS="$CPPFLAGS" + test "x$ac_cv_header_dlfcn_h" = xyes && CPPFLAGS="$CPPFLAGS -DHAVE_DLFCN_H" + + save_LDFLAGS="$LDFLAGS" + wl=$lt_prog_compiler_wl eval LDFLAGS=\"\$LDFLAGS $export_dynamic_flag_spec\" + + save_LIBS="$LIBS" + LIBS="$lt_cv_dlopen_libs $LIBS" + + AC_CACHE_CHECK([whether a program can dlopen itself], + lt_cv_dlopen_self, [dnl + _LT_TRY_DLOPEN_SELF( + lt_cv_dlopen_self=yes, lt_cv_dlopen_self=yes, + lt_cv_dlopen_self=no, lt_cv_dlopen_self=cross) + ]) + + if test "x$lt_cv_dlopen_self" = xyes; then + wl=$lt_prog_compiler_wl eval LDFLAGS=\"\$LDFLAGS $lt_prog_compiler_static\" + AC_CACHE_CHECK([whether a statically linked program can dlopen itself], + lt_cv_dlopen_self_static, [dnl + _LT_TRY_DLOPEN_SELF( + lt_cv_dlopen_self_static=yes, lt_cv_dlopen_self_static=yes, + lt_cv_dlopen_self_static=no, lt_cv_dlopen_self_static=cross) + ]) + fi + + CPPFLAGS="$save_CPPFLAGS" + LDFLAGS="$save_LDFLAGS" + LIBS="$save_LIBS" + ;; + esac + + case $lt_cv_dlopen_self in + yes|no) enable_dlopen_self=$lt_cv_dlopen_self ;; + *) enable_dlopen_self=unknown ;; + esac + + case $lt_cv_dlopen_self_static in + yes|no) enable_dlopen_self_static=$lt_cv_dlopen_self_static ;; + *) enable_dlopen_self_static=unknown ;; + esac +fi +_LT_DECL([dlopen_support], [enable_dlopen], [0], + [Whether dlopen is supported]) +_LT_DECL([dlopen_self], [enable_dlopen_self], [0], + [Whether dlopen of programs is supported]) +_LT_DECL([dlopen_self_static], [enable_dlopen_self_static], [0], + [Whether dlopen of statically linked programs is supported]) +])# LT_SYS_DLOPEN_SELF + +# Old name: +AU_ALIAS([AC_LIBTOOL_DLOPEN_SELF], [LT_SYS_DLOPEN_SELF]) +dnl aclocal-1.4 backwards compatibility: +dnl AC_DEFUN([AC_LIBTOOL_DLOPEN_SELF], []) + + +# _LT_COMPILER_C_O([TAGNAME]) +# --------------------------- +# Check to see if options -c and -o are simultaneously supported by compiler. +# This macro does not hard code the compiler like AC_PROG_CC_C_O. +m4_defun([_LT_COMPILER_C_O], +[m4_require([_LT_DECL_SED])dnl +m4_require([_LT_FILEUTILS_DEFAULTS])dnl +m4_require([_LT_TAG_COMPILER])dnl +AC_CACHE_CHECK([if $compiler supports -c -o file.$ac_objext], + [_LT_TAGVAR(lt_cv_prog_compiler_c_o, $1)], + [_LT_TAGVAR(lt_cv_prog_compiler_c_o, $1)=no + $RM -r conftest 2>/dev/null + mkdir conftest + cd conftest + mkdir out + echo "$lt_simple_compile_test_code" > conftest.$ac_ext + + lt_compiler_flag="-o out/conftest2.$ac_objext" + # Insert the option either (1) after the last *FLAGS variable, or + # (2) before a word containing "conftest.", or (3) at the end. + # Note that $ac_compile itself does not contain backslashes and begins + # with a dollar sign (not a hyphen), so the echo should work correctly. + lt_compile=`echo "$ac_compile" | $SED \ + -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \ + -e 's: [[^ ]]*conftest\.: $lt_compiler_flag&:; t' \ + -e 's:$: $lt_compiler_flag:'` + (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&AS_MESSAGE_LOG_FD) + (eval "$lt_compile" 2>out/conftest.err) + ac_status=$? + cat out/conftest.err >&AS_MESSAGE_LOG_FD + echo "$as_me:$LINENO: \$? = $ac_status" >&AS_MESSAGE_LOG_FD + if (exit $ac_status) && test -s out/conftest2.$ac_objext + then + # The compiler can only warn and ignore the option if not recognized + # So say no if there are warnings + $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' > out/conftest.exp + $SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2 + if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then + _LT_TAGVAR(lt_cv_prog_compiler_c_o, $1)=yes + fi + fi + chmod u+w . 2>&AS_MESSAGE_LOG_FD + $RM conftest* + # SGI C++ compiler will create directory out/ii_files/ for + # template instantiation + test -d out/ii_files && $RM out/ii_files/* && rmdir out/ii_files + $RM out/* && rmdir out + cd .. + $RM -r conftest + $RM conftest* +]) +_LT_TAGDECL([compiler_c_o], [lt_cv_prog_compiler_c_o], [1], + [Does compiler simultaneously support -c and -o options?]) +])# _LT_COMPILER_C_O + + +# _LT_COMPILER_FILE_LOCKS([TAGNAME]) +# ---------------------------------- +# Check to see if we can do hard links to lock some files if needed +m4_defun([_LT_COMPILER_FILE_LOCKS], +[m4_require([_LT_ENABLE_LOCK])dnl +m4_require([_LT_FILEUTILS_DEFAULTS])dnl +_LT_COMPILER_C_O([$1]) + +hard_links="nottested" +if test "$_LT_TAGVAR(lt_cv_prog_compiler_c_o, $1)" = no && test "$need_locks" != no; then + # do not overwrite the value of need_locks provided by the user + AC_MSG_CHECKING([if we can lock with hard links]) + hard_links=yes + $RM conftest* + ln conftest.a conftest.b 2>/dev/null && hard_links=no + touch conftest.a + ln conftest.a conftest.b 2>&5 || hard_links=no + ln conftest.a conftest.b 2>/dev/null && hard_links=no + AC_MSG_RESULT([$hard_links]) + if test "$hard_links" = no; then + AC_MSG_WARN([`$CC' does not support `-c -o', so `make -j' may be unsafe]) + need_locks=warn + fi +else + need_locks=no +fi +_LT_DECL([], [need_locks], [1], [Must we lock files when doing compilation?]) +])# _LT_COMPILER_FILE_LOCKS + + +# _LT_CHECK_OBJDIR +# ---------------- +m4_defun([_LT_CHECK_OBJDIR], +[AC_CACHE_CHECK([for objdir], [lt_cv_objdir], +[rm -f .libs 2>/dev/null +mkdir .libs 2>/dev/null +if test -d .libs; then + lt_cv_objdir=.libs +else + # MS-DOS does not allow filenames that begin with a dot. + lt_cv_objdir=_libs +fi +rmdir .libs 2>/dev/null]) +objdir=$lt_cv_objdir +_LT_DECL([], [objdir], [0], + [The name of the directory that contains temporary libtool files])dnl +m4_pattern_allow([LT_OBJDIR])dnl +AC_DEFINE_UNQUOTED(LT_OBJDIR, "$lt_cv_objdir/", + [Define to the sub-directory in which libtool stores uninstalled libraries.]) +])# _LT_CHECK_OBJDIR + + +# _LT_LINKER_HARDCODE_LIBPATH([TAGNAME]) +# -------------------------------------- +# Check hardcoding attributes. +m4_defun([_LT_LINKER_HARDCODE_LIBPATH], +[AC_MSG_CHECKING([how to hardcode library paths into programs]) +_LT_TAGVAR(hardcode_action, $1)= +if test -n "$_LT_TAGVAR(hardcode_libdir_flag_spec, $1)" || + test -n "$_LT_TAGVAR(runpath_var, $1)" || + test "X$_LT_TAGVAR(hardcode_automatic, $1)" = "Xyes" ; then + + # We can hardcode non-existent directories. + if test "$_LT_TAGVAR(hardcode_direct, $1)" != no && + # If the only mechanism to avoid hardcoding is shlibpath_var, we + # have to relink, otherwise we might link with an installed library + # when we should be linking with a yet-to-be-installed one + ## test "$_LT_TAGVAR(hardcode_shlibpath_var, $1)" != no && + test "$_LT_TAGVAR(hardcode_minus_L, $1)" != no; then + # Linking always hardcodes the temporary library directory. + _LT_TAGVAR(hardcode_action, $1)=relink + else + # We can link without hardcoding, and we can hardcode nonexisting dirs. + _LT_TAGVAR(hardcode_action, $1)=immediate + fi +else + # We cannot hardcode anything, or else we can only hardcode existing + # directories. + _LT_TAGVAR(hardcode_action, $1)=unsupported +fi +AC_MSG_RESULT([$_LT_TAGVAR(hardcode_action, $1)]) + +if test "$_LT_TAGVAR(hardcode_action, $1)" = relink || + test "$_LT_TAGVAR(inherit_rpath, $1)" = yes; then + # Fast installation is not supported + enable_fast_install=no +elif test "$shlibpath_overrides_runpath" = yes || + test "$enable_shared" = no; then + # Fast installation is not necessary + enable_fast_install=needless +fi +_LT_TAGDECL([], [hardcode_action], [0], + [How to hardcode a shared library path into an executable]) +])# _LT_LINKER_HARDCODE_LIBPATH + + +# _LT_CMD_STRIPLIB +# ---------------- +m4_defun([_LT_CMD_STRIPLIB], +[m4_require([_LT_DECL_EGREP]) +striplib= +old_striplib= +AC_MSG_CHECKING([whether stripping libraries is possible]) +if test -n "$STRIP" && $STRIP -V 2>&1 | $GREP "GNU strip" >/dev/null; then + test -z "$old_striplib" && old_striplib="$STRIP --strip-debug" + test -z "$striplib" && striplib="$STRIP --strip-unneeded" + AC_MSG_RESULT([yes]) +else +# FIXME - insert some real tests, host_os isn't really good enough + case $host_os in + darwin*) + if test -n "$STRIP" ; then + striplib="$STRIP -x" + old_striplib="$STRIP -S" + AC_MSG_RESULT([yes]) + else + AC_MSG_RESULT([no]) + fi + ;; + *) + AC_MSG_RESULT([no]) + ;; + esac +fi +_LT_DECL([], [old_striplib], [1], [Commands to strip libraries]) +_LT_DECL([], [striplib], [1]) +])# _LT_CMD_STRIPLIB + + +# _LT_SYS_DYNAMIC_LINKER([TAG]) +# ----------------------------- +# PORTME Fill in your ld.so characteristics +m4_defun([_LT_SYS_DYNAMIC_LINKER], +[AC_REQUIRE([AC_CANONICAL_HOST])dnl +m4_require([_LT_DECL_EGREP])dnl +m4_require([_LT_FILEUTILS_DEFAULTS])dnl +m4_require([_LT_DECL_OBJDUMP])dnl +m4_require([_LT_DECL_SED])dnl +m4_require([_LT_CHECK_SHELL_FEATURES])dnl +AC_MSG_CHECKING([dynamic linker characteristics]) +m4_if([$1], + [], [ +if test "$GCC" = yes; then + case $host_os in + darwin*) lt_awk_arg="/^libraries:/,/LR/" ;; + *) lt_awk_arg="/^libraries:/" ;; + esac + case $host_os in + mingw* | cegcc*) lt_sed_strip_eq="s,=\([[A-Za-z]]:\),\1,g" ;; + *) lt_sed_strip_eq="s,=/,/,g" ;; + esac + lt_search_path_spec=`$CC -print-search-dirs | awk $lt_awk_arg | $SED -e "s/^libraries://" -e $lt_sed_strip_eq` + case $lt_search_path_spec in + *\;*) + # if the path contains ";" then we assume it to be the separator + # otherwise default to the standard path separator (i.e. ":") - it is + # assumed that no part of a normal pathname contains ";" but that should + # okay in the real world where ";" in dirpaths is itself problematic. + lt_search_path_spec=`$ECHO "$lt_search_path_spec" | $SED 's/;/ /g'` + ;; + *) + lt_search_path_spec=`$ECHO "$lt_search_path_spec" | $SED "s/$PATH_SEPARATOR/ /g"` + ;; + esac + # Ok, now we have the path, separated by spaces, we can step through it + # and add multilib dir if necessary. + lt_tmp_lt_search_path_spec= + lt_multi_os_dir=`$CC $CPPFLAGS $CFLAGS $LDFLAGS -print-multi-os-directory 2>/dev/null` + for lt_sys_path in $lt_search_path_spec; do + if test -d "$lt_sys_path/$lt_multi_os_dir"; then + lt_tmp_lt_search_path_spec="$lt_tmp_lt_search_path_spec $lt_sys_path/$lt_multi_os_dir" + else + test -d "$lt_sys_path" && \ + lt_tmp_lt_search_path_spec="$lt_tmp_lt_search_path_spec $lt_sys_path" + fi + done + lt_search_path_spec=`$ECHO "$lt_tmp_lt_search_path_spec" | awk ' +BEGIN {RS=" "; FS="/|\n";} { + lt_foo=""; + lt_count=0; + for (lt_i = NF; lt_i > 0; lt_i--) { + if ($lt_i != "" && $lt_i != ".") { + if ($lt_i == "..") { + lt_count++; + } else { + if (lt_count == 0) { + lt_foo="/" $lt_i lt_foo; + } else { + lt_count--; + } + } + } + } + if (lt_foo != "") { lt_freq[[lt_foo]]++; } + if (lt_freq[[lt_foo]] == 1) { print lt_foo; } +}'` + # AWK program above erroneously prepends '/' to C:/dos/paths + # for these hosts. + case $host_os in + mingw* | cegcc*) lt_search_path_spec=`$ECHO "$lt_search_path_spec" |\ + $SED 's,/\([[A-Za-z]]:\),\1,g'` ;; + esac + sys_lib_search_path_spec=`$ECHO "$lt_search_path_spec" | $lt_NL2SP` +else + sys_lib_search_path_spec="/lib /usr/lib /usr/local/lib" +fi]) +library_names_spec= +libname_spec='lib$name' +soname_spec= +shrext_cmds=".so" +postinstall_cmds= +postuninstall_cmds= +finish_cmds= +finish_eval= +shlibpath_var= +shlibpath_overrides_runpath=unknown +version_type=none +dynamic_linker="$host_os ld.so" +sys_lib_dlsearch_path_spec="/lib /usr/lib" +need_lib_prefix=unknown +hardcode_into_libs=no + +# when you set need_version to no, make sure it does not cause -set_version +# flags to be left without arguments +need_version=unknown + +case $host_os in +aix3*) + version_type=linux # correct to gnu/linux during the next big refactor + library_names_spec='${libname}${release}${shared_ext}$versuffix $libname.a' + shlibpath_var=LIBPATH + + # AIX 3 has no versioning support, so we append a major version to the name. + soname_spec='${libname}${release}${shared_ext}$major' + ;; + +aix[[4-9]]*) + version_type=linux # correct to gnu/linux during the next big refactor + need_lib_prefix=no + need_version=no + hardcode_into_libs=yes + if test "$host_cpu" = ia64; then + # AIX 5 supports IA64 + library_names_spec='${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext}$versuffix $libname${shared_ext}' + shlibpath_var=LD_LIBRARY_PATH + else + # With GCC up to 2.95.x, collect2 would create an import file + # for dependence libraries. The import file would start with + # the line `#! .'. This would cause the generated library to + # depend on `.', always an invalid library. This was fixed in + # development snapshots of GCC prior to 3.0. + case $host_os in + aix4 | aix4.[[01]] | aix4.[[01]].*) + if { echo '#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 97)' + echo ' yes ' + echo '#endif'; } | ${CC} -E - | $GREP yes > /dev/null; then + : + else + can_build_shared=no + fi + ;; + esac + # AIX (on Power*) has no versioning support, so currently we can not hardcode correct + # soname into executable. Probably we can add versioning support to + # collect2, so additional links can be useful in future. + if test "$aix_use_runtimelinking" = yes; then + # If using run time linking (on AIX 4.2 or later) use lib.so + # instead of lib.a to let people know that these are not + # typical AIX shared libraries. + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + else + # We preserve .a as extension for shared libraries through AIX4.2 + # and later when we are not doing run time linking. + library_names_spec='${libname}${release}.a $libname.a' + soname_spec='${libname}${release}${shared_ext}$major' + fi + shlibpath_var=LIBPATH + fi + ;; + +amigaos*) + case $host_cpu in + powerpc) + # Since July 2007 AmigaOS4 officially supports .so libraries. + # When compiling the executable, add -use-dynld -Lsobjs: to the compileline. + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + ;; + m68k) + library_names_spec='$libname.ixlibrary $libname.a' + # Create ${libname}_ixlibrary.a entries in /sys/libs. + finish_eval='for lib in `ls $libdir/*.ixlibrary 2>/dev/null`; do libname=`func_echo_all "$lib" | $SED '\''s%^.*/\([[^/]]*\)\.ixlibrary$%\1%'\''`; test $RM /sys/libs/${libname}_ixlibrary.a; $show "cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a"; cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a || exit 1; done' + ;; + esac + ;; + +beos*) + library_names_spec='${libname}${shared_ext}' + dynamic_linker="$host_os ld.so" + shlibpath_var=LIBRARY_PATH + ;; + +bsdi[[45]]*) + version_type=linux # correct to gnu/linux during the next big refactor + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + finish_cmds='PATH="\$PATH:/sbin" ldconfig $libdir' + shlibpath_var=LD_LIBRARY_PATH + sys_lib_search_path_spec="/shlib /usr/lib /usr/X11/lib /usr/contrib/lib /lib /usr/local/lib" + sys_lib_dlsearch_path_spec="/shlib /usr/lib /usr/local/lib" + # the default ld.so.conf also contains /usr/contrib/lib and + # /usr/X11R6/lib (/usr/X11 is a link to /usr/X11R6), but let us allow + # libtool to hard-code these into programs + ;; + +cygwin* | mingw* | pw32* | cegcc*) + version_type=windows + shrext_cmds=".dll" + need_version=no + need_lib_prefix=no + + case $GCC,$cc_basename in + yes,*) + # gcc + library_names_spec='$libname.dll.a' + # DLL is installed to $(libdir)/../bin by postinstall_cmds + postinstall_cmds='base_file=`basename \${file}`~ + dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i; echo \$dlname'\''`~ + dldir=$destdir/`dirname \$dlpath`~ + test -d \$dldir || mkdir -p \$dldir~ + $install_prog $dir/$dlname \$dldir/$dlname~ + chmod a+x \$dldir/$dlname~ + if test -n '\''$stripme'\'' && test -n '\''$striplib'\''; then + eval '\''$striplib \$dldir/$dlname'\'' || exit \$?; + fi' + postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~ + dlpath=$dir/\$dldll~ + $RM \$dlpath' + shlibpath_overrides_runpath=yes + + case $host_os in + cygwin*) + # Cygwin DLLs use 'cyg' prefix rather than 'lib' + soname_spec='`echo ${libname} | sed -e 's/^lib/cyg/'``echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext}' +m4_if([$1], [],[ + sys_lib_search_path_spec="$sys_lib_search_path_spec /usr/lib/w32api"]) + ;; + mingw* | cegcc*) + # MinGW DLLs use traditional 'lib' prefix + soname_spec='${libname}`echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext}' + ;; + pw32*) + # pw32 DLLs use 'pw' prefix rather than 'lib' + library_names_spec='`echo ${libname} | sed -e 's/^lib/pw/'``echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext}' + ;; + esac + dynamic_linker='Win32 ld.exe' + ;; + + *,cl*) + # Native MSVC + libname_spec='$name' + soname_spec='${libname}`echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext}' + library_names_spec='${libname}.dll.lib' + + case $build_os in + mingw*) + sys_lib_search_path_spec= + lt_save_ifs=$IFS + IFS=';' + for lt_path in $LIB + do + IFS=$lt_save_ifs + # Let DOS variable expansion print the short 8.3 style file name. + lt_path=`cd "$lt_path" 2>/dev/null && cmd //C "for %i in (".") do @echo %~si"` + sys_lib_search_path_spec="$sys_lib_search_path_spec $lt_path" + done + IFS=$lt_save_ifs + # Convert to MSYS style. + sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | sed -e 's|\\\\|/|g' -e 's| \\([[a-zA-Z]]\\):| /\\1|g' -e 's|^ ||'` + ;; + cygwin*) + # Convert to unix form, then to dos form, then back to unix form + # but this time dos style (no spaces!) so that the unix form looks + # like /cygdrive/c/PROGRA~1:/cygdr... + sys_lib_search_path_spec=`cygpath --path --unix "$LIB"` + sys_lib_search_path_spec=`cygpath --path --dos "$sys_lib_search_path_spec" 2>/dev/null` + sys_lib_search_path_spec=`cygpath --path --unix "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"` + ;; + *) + sys_lib_search_path_spec="$LIB" + if $ECHO "$sys_lib_search_path_spec" | [$GREP ';[c-zC-Z]:/' >/dev/null]; then + # It is most probably a Windows format PATH. + sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'` + else + sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"` + fi + # FIXME: find the short name or the path components, as spaces are + # common. (e.g. "Program Files" -> "PROGRA~1") + ;; + esac + + # DLL is installed to $(libdir)/../bin by postinstall_cmds + postinstall_cmds='base_file=`basename \${file}`~ + dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i; echo \$dlname'\''`~ + dldir=$destdir/`dirname \$dlpath`~ + test -d \$dldir || mkdir -p \$dldir~ + $install_prog $dir/$dlname \$dldir/$dlname' + postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~ + dlpath=$dir/\$dldll~ + $RM \$dlpath' + shlibpath_overrides_runpath=yes + dynamic_linker='Win32 link.exe' + ;; + + *) + # Assume MSVC wrapper + library_names_spec='${libname}`echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext} $libname.lib' + dynamic_linker='Win32 ld.exe' + ;; + esac + # FIXME: first we should search . and the directory the executable is in + shlibpath_var=PATH + ;; + +darwin* | rhapsody*) + dynamic_linker="$host_os dyld" + version_type=darwin + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${major}$shared_ext ${libname}$shared_ext' + soname_spec='${libname}${release}${major}$shared_ext' + shlibpath_overrides_runpath=yes + shlibpath_var=DYLD_LIBRARY_PATH + shrext_cmds='`test .$module = .yes && echo .so || echo .dylib`' +m4_if([$1], [],[ + sys_lib_search_path_spec="$sys_lib_search_path_spec /usr/local/lib"]) + sys_lib_dlsearch_path_spec='/usr/local/lib /lib /usr/lib' + ;; + +dgux*) + version_type=linux # correct to gnu/linux during the next big refactor + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname$shared_ext' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + ;; + +freebsd* | dragonfly*) + # DragonFly does not have aout. When/if they implement a new + # versioning mechanism, adjust this. + if test -x /usr/bin/objformat; then + objformat=`/usr/bin/objformat` + else + case $host_os in + freebsd[[23]].*) objformat=aout ;; + *) objformat=elf ;; + esac + fi + version_type=freebsd-$objformat + case $version_type in + freebsd-elf*) + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}' + need_version=no + need_lib_prefix=no + ;; + freebsd-*) + library_names_spec='${libname}${release}${shared_ext}$versuffix $libname${shared_ext}$versuffix' + need_version=yes + ;; + esac + shlibpath_var=LD_LIBRARY_PATH + case $host_os in + freebsd2.*) + shlibpath_overrides_runpath=yes + ;; + freebsd3.[[01]]* | freebsdelf3.[[01]]*) + shlibpath_overrides_runpath=yes + hardcode_into_libs=yes + ;; + freebsd3.[[2-9]]* | freebsdelf3.[[2-9]]* | \ + freebsd4.[[0-5]] | freebsdelf4.[[0-5]] | freebsd4.1.1 | freebsdelf4.1.1) + shlibpath_overrides_runpath=no + hardcode_into_libs=yes + ;; + *) # from 4.6 on, and DragonFly + shlibpath_overrides_runpath=yes + hardcode_into_libs=yes + ;; + esac + ;; + +haiku*) + version_type=linux # correct to gnu/linux during the next big refactor + need_lib_prefix=no + need_version=no + dynamic_linker="$host_os runtime_loader" + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}${major} ${libname}${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LIBRARY_PATH + shlibpath_overrides_runpath=yes + sys_lib_dlsearch_path_spec='/boot/home/config/lib /boot/common/lib /boot/system/lib' + hardcode_into_libs=yes + ;; + +hpux9* | hpux10* | hpux11*) + # Give a soname corresponding to the major version so that dld.sl refuses to + # link against other versions. + version_type=sunos + need_lib_prefix=no + need_version=no + case $host_cpu in + ia64*) + shrext_cmds='.so' + hardcode_into_libs=yes + dynamic_linker="$host_os dld.so" + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes # Unless +noenvvar is specified. + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + if test "X$HPUX_IA64_MODE" = X32; then + sys_lib_search_path_spec="/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib" + else + sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64" + fi + sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec + ;; + hppa*64*) + shrext_cmds='.sl' + hardcode_into_libs=yes + dynamic_linker="$host_os dld.sl" + shlibpath_var=LD_LIBRARY_PATH # How should we handle SHLIB_PATH + shlibpath_overrides_runpath=yes # Unless +noenvvar is specified. + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + sys_lib_search_path_spec="/usr/lib/pa20_64 /usr/ccs/lib/pa20_64" + sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec + ;; + *) + shrext_cmds='.sl' + dynamic_linker="$host_os dld.sl" + shlibpath_var=SHLIB_PATH + shlibpath_overrides_runpath=no # +s is required to enable SHLIB_PATH + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + ;; + esac + # HP-UX runs *really* slowly unless shared libraries are mode 555, ... + postinstall_cmds='chmod 555 $lib' + # or fails outright, so override atomically: + install_override_mode=555 + ;; + +interix[[3-9]]*) + version_type=linux # correct to gnu/linux during the next big refactor + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + dynamic_linker='Interix 3.x ld.so.1 (PE, like ELF)' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + hardcode_into_libs=yes + ;; + +irix5* | irix6* | nonstopux*) + case $host_os in + nonstopux*) version_type=nonstopux ;; + *) + if test "$lt_cv_prog_gnu_ld" = yes; then + version_type=linux # correct to gnu/linux during the next big refactor + else + version_type=irix + fi ;; + esac + need_lib_prefix=no + need_version=no + soname_spec='${libname}${release}${shared_ext}$major' + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext} $libname${shared_ext}' + case $host_os in + irix5* | nonstopux*) + libsuff= shlibsuff= + ;; + *) + case $LD in # libtool.m4 will add one of these switches to LD + *-32|*"-32 "|*-melf32bsmip|*"-melf32bsmip ") + libsuff= shlibsuff= libmagic=32-bit;; + *-n32|*"-n32 "|*-melf32bmipn32|*"-melf32bmipn32 ") + libsuff=32 shlibsuff=N32 libmagic=N32;; + *-64|*"-64 "|*-melf64bmip|*"-melf64bmip ") + libsuff=64 shlibsuff=64 libmagic=64-bit;; + *) libsuff= shlibsuff= libmagic=never-match;; + esac + ;; + esac + shlibpath_var=LD_LIBRARY${shlibsuff}_PATH + shlibpath_overrides_runpath=no + sys_lib_search_path_spec="/usr/lib${libsuff} /lib${libsuff} /usr/local/lib${libsuff}" + sys_lib_dlsearch_path_spec="/usr/lib${libsuff} /lib${libsuff}" + hardcode_into_libs=yes + ;; + +# No shared lib support for Linux oldld, aout, or coff. +linux*oldld* | linux*aout* | linux*coff*) + dynamic_linker=no + ;; + +# This must be glibc/ELF. +linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*) + version_type=linux # correct to gnu/linux during the next big refactor + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + finish_cmds='PATH="\$PATH:/sbin" ldconfig -n $libdir' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + + # Some binutils ld are patched to set DT_RUNPATH + AC_CACHE_VAL([lt_cv_shlibpath_overrides_runpath], + [lt_cv_shlibpath_overrides_runpath=no + save_LDFLAGS=$LDFLAGS + save_libdir=$libdir + eval "libdir=/foo; wl=\"$_LT_TAGVAR(lt_prog_compiler_wl, $1)\"; \ + LDFLAGS=\"\$LDFLAGS $_LT_TAGVAR(hardcode_libdir_flag_spec, $1)\"" + AC_LINK_IFELSE([AC_LANG_PROGRAM([],[])], + [AS_IF([ ($OBJDUMP -p conftest$ac_exeext) 2>/dev/null | grep "RUNPATH.*$libdir" >/dev/null], + [lt_cv_shlibpath_overrides_runpath=yes])]) + LDFLAGS=$save_LDFLAGS + libdir=$save_libdir + ]) + shlibpath_overrides_runpath=$lt_cv_shlibpath_overrides_runpath + + # This implies no fast_install, which is unacceptable. + # Some rework will be needed to allow for fast_install + # before this can be enabled. + hardcode_into_libs=yes + + # Append ld.so.conf contents to the search path + if test -f /etc/ld.so.conf; then + lt_ld_extra=`awk '/^include / { system(sprintf("cd /etc; cat %s 2>/dev/null", \[$]2)); skip = 1; } { if (!skip) print \[$]0; skip = 0; }' < /etc/ld.so.conf | $SED -e 's/#.*//;/^[ ]*hwcap[ ]/d;s/[:, ]/ /g;s/=[^=]*$//;s/=[^= ]* / /g;s/"//g;/^$/d' | tr '\n' ' '` + sys_lib_dlsearch_path_spec="/lib /usr/lib $lt_ld_extra" + fi + + # We used to test for /lib/ld.so.1 and disable shared libraries on + # powerpc, because MkLinux only supported shared libraries with the + # GNU dynamic linker. Since this was broken with cross compilers, + # most powerpc-linux boxes support dynamic linking these days and + # people can always --disable-shared, the test was removed, and we + # assume the GNU/Linux dynamic linker is in use. + dynamic_linker='GNU/Linux ld.so' + ;; + +netbsdelf*-gnu) + version_type=linux + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + hardcode_into_libs=yes + dynamic_linker='NetBSD ld.elf_so' + ;; + +netbsd*) + version_type=sunos + need_lib_prefix=no + need_version=no + if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix' + finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir' + dynamic_linker='NetBSD (a.out) ld.so' + else + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + dynamic_linker='NetBSD ld.elf_so' + fi + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + hardcode_into_libs=yes + ;; + +newsos6) + version_type=linux # correct to gnu/linux during the next big refactor + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + ;; + +*nto* | *qnx*) + version_type=qnx + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + hardcode_into_libs=yes + dynamic_linker='ldqnx.so' + ;; + +openbsd*) + version_type=sunos + sys_lib_dlsearch_path_spec="/usr/lib" + need_lib_prefix=no + # Some older versions of OpenBSD (3.3 at least) *do* need versioned libs. + case $host_os in + openbsd3.3 | openbsd3.3.*) need_version=yes ;; + *) need_version=no ;; + esac + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix' + finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir' + shlibpath_var=LD_LIBRARY_PATH + if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then + case $host_os in + openbsd2.[[89]] | openbsd2.[[89]].*) + shlibpath_overrides_runpath=no + ;; + *) + shlibpath_overrides_runpath=yes + ;; + esac + else + shlibpath_overrides_runpath=yes + fi + ;; + +os2*) + libname_spec='$name' + shrext_cmds=".dll" + need_lib_prefix=no + library_names_spec='$libname${shared_ext} $libname.a' + dynamic_linker='OS/2 ld.exe' + shlibpath_var=LIBPATH + ;; + +osf3* | osf4* | osf5*) + version_type=osf + need_lib_prefix=no + need_version=no + soname_spec='${libname}${release}${shared_ext}$major' + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + shlibpath_var=LD_LIBRARY_PATH + sys_lib_search_path_spec="/usr/shlib /usr/ccs/lib /usr/lib/cmplrs/cc /usr/lib /usr/local/lib /var/shlib" + sys_lib_dlsearch_path_spec="$sys_lib_search_path_spec" + ;; + +rdos*) + dynamic_linker=no + ;; + +solaris*) + version_type=linux # correct to gnu/linux during the next big refactor + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + hardcode_into_libs=yes + # ldd complains unless libraries are executable + postinstall_cmds='chmod +x $lib' + ;; + +sunos4*) + version_type=sunos + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix' + finish_cmds='PATH="\$PATH:/usr/etc" ldconfig $libdir' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + if test "$with_gnu_ld" = yes; then + need_lib_prefix=no + fi + need_version=yes + ;; + +sysv4 | sysv4.3*) + version_type=linux # correct to gnu/linux during the next big refactor + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + case $host_vendor in + sni) + shlibpath_overrides_runpath=no + need_lib_prefix=no + runpath_var=LD_RUN_PATH + ;; + siemens) + need_lib_prefix=no + ;; + motorola) + need_lib_prefix=no + need_version=no + shlibpath_overrides_runpath=no + sys_lib_search_path_spec='/lib /usr/lib /usr/ccs/lib' + ;; + esac + ;; + +sysv4*MP*) + if test -d /usr/nec ;then + version_type=linux # correct to gnu/linux during the next big refactor + library_names_spec='$libname${shared_ext}.$versuffix $libname${shared_ext}.$major $libname${shared_ext}' + soname_spec='$libname${shared_ext}.$major' + shlibpath_var=LD_LIBRARY_PATH + fi + ;; + +sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*) + version_type=freebsd-elf + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + hardcode_into_libs=yes + if test "$with_gnu_ld" = yes; then + sys_lib_search_path_spec='/usr/local/lib /usr/gnu/lib /usr/ccs/lib /usr/lib /lib' + else + sys_lib_search_path_spec='/usr/ccs/lib /usr/lib' + case $host_os in + sco3.2v5*) + sys_lib_search_path_spec="$sys_lib_search_path_spec /lib" + ;; + esac + fi + sys_lib_dlsearch_path_spec='/usr/lib' + ;; + +tpf*) + # TPF is a cross-target only. Preferred cross-host = GNU/Linux. + version_type=linux # correct to gnu/linux during the next big refactor + need_lib_prefix=no + need_version=no + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + hardcode_into_libs=yes + ;; + +uts4*) + version_type=linux # correct to gnu/linux during the next big refactor + library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}' + soname_spec='${libname}${release}${shared_ext}$major' + shlibpath_var=LD_LIBRARY_PATH + ;; + +*) + dynamic_linker=no + ;; +esac +AC_MSG_RESULT([$dynamic_linker]) +test "$dynamic_linker" = no && can_build_shared=no + +variables_saved_for_relink="PATH $shlibpath_var $runpath_var" +if test "$GCC" = yes; then + variables_saved_for_relink="$variables_saved_for_relink GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH" +fi + +if test "${lt_cv_sys_lib_search_path_spec+set}" = set; then + sys_lib_search_path_spec="$lt_cv_sys_lib_search_path_spec" +fi +if test "${lt_cv_sys_lib_dlsearch_path_spec+set}" = set; then + sys_lib_dlsearch_path_spec="$lt_cv_sys_lib_dlsearch_path_spec" +fi + +_LT_DECL([], [variables_saved_for_relink], [1], + [Variables whose values should be saved in libtool wrapper scripts and + restored at link time]) +_LT_DECL([], [need_lib_prefix], [0], + [Do we need the "lib" prefix for modules?]) +_LT_DECL([], [need_version], [0], [Do we need a version for libraries?]) +_LT_DECL([], [version_type], [0], [Library versioning type]) +_LT_DECL([], [runpath_var], [0], [Shared library runtime path variable]) +_LT_DECL([], [shlibpath_var], [0],[Shared library path variable]) +_LT_DECL([], [shlibpath_overrides_runpath], [0], + [Is shlibpath searched before the hard-coded library search path?]) +_LT_DECL([], [libname_spec], [1], [Format of library name prefix]) +_LT_DECL([], [library_names_spec], [1], + [[List of archive names. First name is the real one, the rest are links. + The last name is the one that the linker finds with -lNAME]]) +_LT_DECL([], [soname_spec], [1], + [[The coded name of the library, if different from the real name]]) +_LT_DECL([], [install_override_mode], [1], + [Permission mode override for installation of shared libraries]) +_LT_DECL([], [postinstall_cmds], [2], + [Command to use after installation of a shared archive]) +_LT_DECL([], [postuninstall_cmds], [2], + [Command to use after uninstallation of a shared archive]) +_LT_DECL([], [finish_cmds], [2], + [Commands used to finish a libtool library installation in a directory]) +_LT_DECL([], [finish_eval], [1], + [[As "finish_cmds", except a single script fragment to be evaled but + not shown]]) +_LT_DECL([], [hardcode_into_libs], [0], + [Whether we should hardcode library paths into libraries]) +_LT_DECL([], [sys_lib_search_path_spec], [2], + [Compile-time system search path for libraries]) +_LT_DECL([], [sys_lib_dlsearch_path_spec], [2], + [Run-time system search path for libraries]) +])# _LT_SYS_DYNAMIC_LINKER + + +# _LT_PATH_TOOL_PREFIX(TOOL) +# -------------------------- +# find a file program which can recognize shared library +AC_DEFUN([_LT_PATH_TOOL_PREFIX], +[m4_require([_LT_DECL_EGREP])dnl +AC_MSG_CHECKING([for $1]) +AC_CACHE_VAL(lt_cv_path_MAGIC_CMD, +[case $MAGIC_CMD in +[[\\/*] | ?:[\\/]*]) + lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path. + ;; +*) + lt_save_MAGIC_CMD="$MAGIC_CMD" + lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR +dnl $ac_dummy forces splitting on constant user-supplied paths. +dnl POSIX.2 word splitting is done only on the output of word expansions, +dnl not every word. This closes a longstanding sh security hole. + ac_dummy="m4_if([$2], , $PATH, [$2])" + for ac_dir in $ac_dummy; do + IFS="$lt_save_ifs" + test -z "$ac_dir" && ac_dir=. + if test -f $ac_dir/$1; then + lt_cv_path_MAGIC_CMD="$ac_dir/$1" + if test -n "$file_magic_test_file"; then + case $deplibs_check_method in + "file_magic "*) + file_magic_regex=`expr "$deplibs_check_method" : "file_magic \(.*\)"` + MAGIC_CMD="$lt_cv_path_MAGIC_CMD" + if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null | + $EGREP "$file_magic_regex" > /dev/null; then + : + else + cat <<_LT_EOF 1>&2 + +*** Warning: the command libtool uses to detect shared libraries, +*** $file_magic_cmd, produces output that libtool cannot recognize. +*** The result is that libtool may fail to recognize shared libraries +*** as such. This will affect the creation of libtool libraries that +*** depend on shared libraries, but programs linked with such libtool +*** libraries will work regardless of this problem. Nevertheless, you +*** may want to report the problem to your system manager and/or to +*** bug-libtool@gnu.org + +_LT_EOF + fi ;; + esac + fi + break + fi + done + IFS="$lt_save_ifs" + MAGIC_CMD="$lt_save_MAGIC_CMD" + ;; +esac]) +MAGIC_CMD="$lt_cv_path_MAGIC_CMD" +if test -n "$MAGIC_CMD"; then + AC_MSG_RESULT($MAGIC_CMD) +else + AC_MSG_RESULT(no) +fi +_LT_DECL([], [MAGIC_CMD], [0], + [Used to examine libraries when file_magic_cmd begins with "file"])dnl +])# _LT_PATH_TOOL_PREFIX + +# Old name: +AU_ALIAS([AC_PATH_TOOL_PREFIX], [_LT_PATH_TOOL_PREFIX]) +dnl aclocal-1.4 backwards compatibility: +dnl AC_DEFUN([AC_PATH_TOOL_PREFIX], []) + + +# _LT_PATH_MAGIC +# -------------- +# find a file program which can recognize a shared library +m4_defun([_LT_PATH_MAGIC], +[_LT_PATH_TOOL_PREFIX(${ac_tool_prefix}file, /usr/bin$PATH_SEPARATOR$PATH) +if test -z "$lt_cv_path_MAGIC_CMD"; then + if test -n "$ac_tool_prefix"; then + _LT_PATH_TOOL_PREFIX(file, /usr/bin$PATH_SEPARATOR$PATH) + else + MAGIC_CMD=: + fi +fi +])# _LT_PATH_MAGIC + + +# LT_PATH_LD +# ---------- +# find the pathname to the GNU or non-GNU linker +AC_DEFUN([LT_PATH_LD], +[AC_REQUIRE([AC_PROG_CC])dnl +AC_REQUIRE([AC_CANONICAL_HOST])dnl +AC_REQUIRE([AC_CANONICAL_BUILD])dnl +m4_require([_LT_DECL_SED])dnl +m4_require([_LT_DECL_EGREP])dnl +m4_require([_LT_PROG_ECHO_BACKSLASH])dnl + +AC_ARG_WITH([gnu-ld], + [AS_HELP_STRING([--with-gnu-ld], + [assume the C compiler uses GNU ld @<:@default=no@:>@])], + [test "$withval" = no || with_gnu_ld=yes], + [with_gnu_ld=no])dnl + +ac_prog=ld +if test "$GCC" = yes; then + # Check if gcc -print-prog-name=ld gives a path. + AC_MSG_CHECKING([for ld used by $CC]) + case $host in + *-*-mingw*) + # gcc leaves a trailing carriage return which upsets mingw + ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;; + *) + ac_prog=`($CC -print-prog-name=ld) 2>&5` ;; + esac + case $ac_prog in + # Accept absolute paths. + [[\\/]]* | ?:[[\\/]]*) + re_direlt='/[[^/]][[^/]]*/\.\./' + # Canonicalize the pathname of ld + ac_prog=`$ECHO "$ac_prog"| $SED 's%\\\\%/%g'` + while $ECHO "$ac_prog" | $GREP "$re_direlt" > /dev/null 2>&1; do + ac_prog=`$ECHO $ac_prog| $SED "s%$re_direlt%/%"` + done + test -z "$LD" && LD="$ac_prog" + ;; + "") + # If it fails, then pretend we aren't using GCC. + ac_prog=ld + ;; + *) + # If it is relative, then search for the first ld in PATH. + with_gnu_ld=unknown + ;; + esac +elif test "$with_gnu_ld" = yes; then + AC_MSG_CHECKING([for GNU ld]) +else + AC_MSG_CHECKING([for non-GNU ld]) +fi +AC_CACHE_VAL(lt_cv_path_LD, +[if test -z "$LD"; then + lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR + for ac_dir in $PATH; do + IFS="$lt_save_ifs" + test -z "$ac_dir" && ac_dir=. + if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then + lt_cv_path_LD="$ac_dir/$ac_prog" + # Check to see if the program is GNU ld. I'd rather use --version, + # but apparently some variants of GNU ld only accept -v. + # Break only if it was the GNU/non-GNU ld that we prefer. + case `"$lt_cv_path_LD" -v 2>&1 &1 /dev/null 2>&1; then + lt_cv_deplibs_check_method='file_magic ^x86 archive import|^x86 DLL' + lt_cv_file_magic_cmd='func_win32_libid' + else + # Keep this pattern in sync with the one in func_win32_libid. + lt_cv_deplibs_check_method='file_magic file format (pei*-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)' + lt_cv_file_magic_cmd='$OBJDUMP -f' + fi + ;; + +cegcc*) + # use the weaker test based on 'objdump'. See mingw*. + lt_cv_deplibs_check_method='file_magic file format pe-arm-.*little(.*architecture: arm)?' + lt_cv_file_magic_cmd='$OBJDUMP -f' + ;; + +darwin* | rhapsody*) + lt_cv_deplibs_check_method=pass_all + ;; + +freebsd* | dragonfly*) + if echo __ELF__ | $CC -E - | $GREP __ELF__ > /dev/null; then + case $host_cpu in + i*86 ) + # Not sure whether the presence of OpenBSD here was a mistake. + # Let's accept both of them until this is cleared up. + lt_cv_deplibs_check_method='file_magic (FreeBSD|OpenBSD|DragonFly)/i[[3-9]]86 (compact )?demand paged shared library' + lt_cv_file_magic_cmd=/usr/bin/file + lt_cv_file_magic_test_file=`echo /usr/lib/libc.so.*` + ;; + esac + else + lt_cv_deplibs_check_method=pass_all + fi + ;; + +haiku*) + lt_cv_deplibs_check_method=pass_all + ;; + +hpux10.20* | hpux11*) + lt_cv_file_magic_cmd=/usr/bin/file + case $host_cpu in + ia64*) + lt_cv_deplibs_check_method='file_magic (s[[0-9]][[0-9]][[0-9]]|ELF-[[0-9]][[0-9]]) shared object file - IA64' + lt_cv_file_magic_test_file=/usr/lib/hpux32/libc.so + ;; + hppa*64*) + [lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|ELF[ -][0-9][0-9])(-bit)?( [LM]SB)? shared object( file)?[, -]* PA-RISC [0-9]\.[0-9]'] + lt_cv_file_magic_test_file=/usr/lib/pa20_64/libc.sl + ;; + *) + lt_cv_deplibs_check_method='file_magic (s[[0-9]][[0-9]][[0-9]]|PA-RISC[[0-9]]\.[[0-9]]) shared library' + lt_cv_file_magic_test_file=/usr/lib/libc.sl + ;; + esac + ;; + +interix[[3-9]]*) + # PIC code is broken on Interix 3.x, that's why |\.a not |_pic\.a here + lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so|\.a)$' + ;; + +irix5* | irix6* | nonstopux*) + case $LD in + *-32|*"-32 ") libmagic=32-bit;; + *-n32|*"-n32 ") libmagic=N32;; + *-64|*"-64 ") libmagic=64-bit;; + *) libmagic=never-match;; + esac + lt_cv_deplibs_check_method=pass_all + ;; + +# This must be glibc/ELF. +linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*) + lt_cv_deplibs_check_method=pass_all + ;; + +netbsd* | netbsdelf*-gnu) + if echo __ELF__ | $CC -E - | $GREP __ELF__ > /dev/null; then + lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so\.[[0-9]]+\.[[0-9]]+|_pic\.a)$' + else + lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so|_pic\.a)$' + fi + ;; + +newos6*) + lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[ML]]SB (executable|dynamic lib)' + lt_cv_file_magic_cmd=/usr/bin/file + lt_cv_file_magic_test_file=/usr/lib/libnls.so + ;; + +*nto* | *qnx*) + lt_cv_deplibs_check_method=pass_all + ;; + +openbsd*) + if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then + lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so\.[[0-9]]+\.[[0-9]]+|\.so|_pic\.a)$' + else + lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so\.[[0-9]]+\.[[0-9]]+|_pic\.a)$' + fi + ;; + +osf3* | osf4* | osf5*) + lt_cv_deplibs_check_method=pass_all + ;; + +rdos*) + lt_cv_deplibs_check_method=pass_all + ;; + +solaris*) + lt_cv_deplibs_check_method=pass_all + ;; + +sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*) + lt_cv_deplibs_check_method=pass_all + ;; + +sysv4 | sysv4.3*) + case $host_vendor in + motorola) + lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[ML]]SB (shared object|dynamic lib) M[[0-9]][[0-9]]* Version [[0-9]]' + lt_cv_file_magic_test_file=`echo /usr/lib/libc.so*` + ;; + ncr) + lt_cv_deplibs_check_method=pass_all + ;; + sequent) + lt_cv_file_magic_cmd='/bin/file' + lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[LM]]SB (shared object|dynamic lib )' + ;; + sni) + lt_cv_file_magic_cmd='/bin/file' + lt_cv_deplibs_check_method="file_magic ELF [[0-9]][[0-9]]*-bit [[LM]]SB dynamic lib" + lt_cv_file_magic_test_file=/lib/libc.so + ;; + siemens) + lt_cv_deplibs_check_method=pass_all + ;; + pc) + lt_cv_deplibs_check_method=pass_all + ;; + esac + ;; + +tpf*) + lt_cv_deplibs_check_method=pass_all + ;; +esac +]) + +file_magic_glob= +want_nocaseglob=no +if test "$build" = "$host"; then + case $host_os in + mingw* | pw32*) + if ( shopt | grep nocaseglob ) >/dev/null 2>&1; then + want_nocaseglob=yes + else + file_magic_glob=`echo aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ | $SED -e "s/\(..\)/s\/[[\1]]\/[[\1]]\/g;/g"` + fi + ;; + esac +fi + +file_magic_cmd=$lt_cv_file_magic_cmd +deplibs_check_method=$lt_cv_deplibs_check_method +test -z "$deplibs_check_method" && deplibs_check_method=unknown + +_LT_DECL([], [deplibs_check_method], [1], + [Method to check whether dependent libraries are shared objects]) +_LT_DECL([], [file_magic_cmd], [1], + [Command to use when deplibs_check_method = "file_magic"]) +_LT_DECL([], [file_magic_glob], [1], + [How to find potential files when deplibs_check_method = "file_magic"]) +_LT_DECL([], [want_nocaseglob], [1], + [Find potential files using nocaseglob when deplibs_check_method = "file_magic"]) +])# _LT_CHECK_MAGIC_METHOD + + +# LT_PATH_NM +# ---------- +# find the pathname to a BSD- or MS-compatible name lister +AC_DEFUN([LT_PATH_NM], +[AC_REQUIRE([AC_PROG_CC])dnl +AC_CACHE_CHECK([for BSD- or MS-compatible name lister (nm)], lt_cv_path_NM, +[if test -n "$NM"; then + # Let the user override the test. + lt_cv_path_NM="$NM" +else + lt_nm_to_check="${ac_tool_prefix}nm" + if test -n "$ac_tool_prefix" && test "$build" = "$host"; then + lt_nm_to_check="$lt_nm_to_check nm" + fi + for lt_tmp_nm in $lt_nm_to_check; do + lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR + for ac_dir in $PATH /usr/ccs/bin/elf /usr/ccs/bin /usr/ucb /bin; do + IFS="$lt_save_ifs" + test -z "$ac_dir" && ac_dir=. + tmp_nm="$ac_dir/$lt_tmp_nm" + if test -f "$tmp_nm" || test -f "$tmp_nm$ac_exeext" ; then + # Check to see if the nm accepts a BSD-compat flag. + # Adding the `sed 1q' prevents false positives on HP-UX, which says: + # nm: unknown option "B" ignored + # Tru64's nm complains that /dev/null is an invalid object file + case `"$tmp_nm" -B /dev/null 2>&1 | sed '1q'` in + */dev/null* | *'Invalid file or object type'*) + lt_cv_path_NM="$tmp_nm -B" + break + ;; + *) + case `"$tmp_nm" -p /dev/null 2>&1 | sed '1q'` in + */dev/null*) + lt_cv_path_NM="$tmp_nm -p" + break + ;; + *) + lt_cv_path_NM=${lt_cv_path_NM="$tmp_nm"} # keep the first match, but + continue # so that we can try to find one that supports BSD flags + ;; + esac + ;; + esac + fi + done + IFS="$lt_save_ifs" + done + : ${lt_cv_path_NM=no} +fi]) +if test "$lt_cv_path_NM" != "no"; then + NM="$lt_cv_path_NM" +else + # Didn't find any BSD compatible name lister, look for dumpbin. + if test -n "$DUMPBIN"; then : + # Let the user override the test. + else + AC_CHECK_TOOLS(DUMPBIN, [dumpbin "link -dump"], :) + case `$DUMPBIN -symbols /dev/null 2>&1 | sed '1q'` in + *COFF*) + DUMPBIN="$DUMPBIN -symbols" + ;; + *) + DUMPBIN=: + ;; + esac + fi + AC_SUBST([DUMPBIN]) + if test "$DUMPBIN" != ":"; then + NM="$DUMPBIN" + fi +fi +test -z "$NM" && NM=nm +AC_SUBST([NM]) +_LT_DECL([], [NM], [1], [A BSD- or MS-compatible name lister])dnl + +AC_CACHE_CHECK([the name lister ($NM) interface], [lt_cv_nm_interface], + [lt_cv_nm_interface="BSD nm" + echo "int some_variable = 0;" > conftest.$ac_ext + (eval echo "\"\$as_me:$LINENO: $ac_compile\"" >&AS_MESSAGE_LOG_FD) + (eval "$ac_compile" 2>conftest.err) + cat conftest.err >&AS_MESSAGE_LOG_FD + (eval echo "\"\$as_me:$LINENO: $NM \\\"conftest.$ac_objext\\\"\"" >&AS_MESSAGE_LOG_FD) + (eval "$NM \"conftest.$ac_objext\"" 2>conftest.err > conftest.out) + cat conftest.err >&AS_MESSAGE_LOG_FD + (eval echo "\"\$as_me:$LINENO: output\"" >&AS_MESSAGE_LOG_FD) + cat conftest.out >&AS_MESSAGE_LOG_FD + if $GREP 'External.*some_variable' conftest.out > /dev/null; then + lt_cv_nm_interface="MS dumpbin" + fi + rm -f conftest*]) +])# LT_PATH_NM + +# Old names: +AU_ALIAS([AM_PROG_NM], [LT_PATH_NM]) +AU_ALIAS([AC_PROG_NM], [LT_PATH_NM]) +dnl aclocal-1.4 backwards compatibility: +dnl AC_DEFUN([AM_PROG_NM], []) +dnl AC_DEFUN([AC_PROG_NM], []) + +# _LT_CHECK_SHAREDLIB_FROM_LINKLIB +# -------------------------------- +# how to determine the name of the shared library +# associated with a specific link library. +# -- PORTME fill in with the dynamic library characteristics +m4_defun([_LT_CHECK_SHAREDLIB_FROM_LINKLIB], +[m4_require([_LT_DECL_EGREP]) +m4_require([_LT_DECL_OBJDUMP]) +m4_require([_LT_DECL_DLLTOOL]) +AC_CACHE_CHECK([how to associate runtime and link libraries], +lt_cv_sharedlib_from_linklib_cmd, +[lt_cv_sharedlib_from_linklib_cmd='unknown' + +case $host_os in +cygwin* | mingw* | pw32* | cegcc*) + # two different shell functions defined in ltmain.sh + # decide which to use based on capabilities of $DLLTOOL + case `$DLLTOOL --help 2>&1` in + *--identify-strict*) + lt_cv_sharedlib_from_linklib_cmd=func_cygming_dll_for_implib + ;; + *) + lt_cv_sharedlib_from_linklib_cmd=func_cygming_dll_for_implib_fallback + ;; + esac + ;; +*) + # fallback: assume linklib IS sharedlib + lt_cv_sharedlib_from_linklib_cmd="$ECHO" + ;; +esac +]) +sharedlib_from_linklib_cmd=$lt_cv_sharedlib_from_linklib_cmd +test -z "$sharedlib_from_linklib_cmd" && sharedlib_from_linklib_cmd=$ECHO + +_LT_DECL([], [sharedlib_from_linklib_cmd], [1], + [Command to associate shared and link libraries]) +])# _LT_CHECK_SHAREDLIB_FROM_LINKLIB + + +# _LT_PATH_MANIFEST_TOOL +# ---------------------- +# locate the manifest tool +m4_defun([_LT_PATH_MANIFEST_TOOL], +[AC_CHECK_TOOL(MANIFEST_TOOL, mt, :) +test -z "$MANIFEST_TOOL" && MANIFEST_TOOL=mt +AC_CACHE_CHECK([if $MANIFEST_TOOL is a manifest tool], [lt_cv_path_mainfest_tool], + [lt_cv_path_mainfest_tool=no + echo "$as_me:$LINENO: $MANIFEST_TOOL '-?'" >&AS_MESSAGE_LOG_FD + $MANIFEST_TOOL '-?' 2>conftest.err > conftest.out + cat conftest.err >&AS_MESSAGE_LOG_FD + if $GREP 'Manifest Tool' conftest.out > /dev/null; then + lt_cv_path_mainfest_tool=yes + fi + rm -f conftest*]) +if test "x$lt_cv_path_mainfest_tool" != xyes; then + MANIFEST_TOOL=: +fi +_LT_DECL([], [MANIFEST_TOOL], [1], [Manifest tool])dnl +])# _LT_PATH_MANIFEST_TOOL + + +# LT_LIB_M +# -------- +# check for math library +AC_DEFUN([LT_LIB_M], +[AC_REQUIRE([AC_CANONICAL_HOST])dnl +LIBM= +case $host in +*-*-beos* | *-*-cegcc* | *-*-cygwin* | *-*-haiku* | *-*-pw32* | *-*-darwin*) + # These system don't have libm, or don't need it + ;; +*-ncr-sysv4.3*) + AC_CHECK_LIB(mw, _mwvalidcheckl, LIBM="-lmw") + AC_CHECK_LIB(m, cos, LIBM="$LIBM -lm") + ;; +*) + AC_CHECK_LIB(m, cos, LIBM="-lm") + ;; +esac +AC_SUBST([LIBM]) +])# LT_LIB_M + +# Old name: +AU_ALIAS([AC_CHECK_LIBM], [LT_LIB_M]) +dnl aclocal-1.4 backwards compatibility: +dnl AC_DEFUN([AC_CHECK_LIBM], []) + + +# _LT_COMPILER_NO_RTTI([TAGNAME]) +# ------------------------------- +m4_defun([_LT_COMPILER_NO_RTTI], +[m4_require([_LT_TAG_COMPILER])dnl + +_LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)= + +if test "$GCC" = yes; then + case $cc_basename in + nvcc*) + _LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=' -Xcompiler -fno-builtin' ;; + *) + _LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=' -fno-builtin' ;; + esac + + _LT_COMPILER_OPTION([if $compiler supports -fno-rtti -fno-exceptions], + lt_cv_prog_compiler_rtti_exceptions, + [-fno-rtti -fno-exceptions], [], + [_LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)="$_LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1) -fno-rtti -fno-exceptions"]) +fi +_LT_TAGDECL([no_builtin_flag], [lt_prog_compiler_no_builtin_flag], [1], + [Compiler flag to turn off builtin functions]) +])# _LT_COMPILER_NO_RTTI + + +# _LT_CMD_GLOBAL_SYMBOLS +# ---------------------- +m4_defun([_LT_CMD_GLOBAL_SYMBOLS], +[AC_REQUIRE([AC_CANONICAL_HOST])dnl +AC_REQUIRE([AC_PROG_CC])dnl +AC_REQUIRE([AC_PROG_AWK])dnl +AC_REQUIRE([LT_PATH_NM])dnl +AC_REQUIRE([LT_PATH_LD])dnl +m4_require([_LT_DECL_SED])dnl +m4_require([_LT_DECL_EGREP])dnl +m4_require([_LT_TAG_COMPILER])dnl + +# Check for command to grab the raw symbol name followed by C symbol from nm. +AC_MSG_CHECKING([command to parse $NM output from $compiler object]) +AC_CACHE_VAL([lt_cv_sys_global_symbol_pipe], +[ +# These are sane defaults that work on at least a few old systems. +# [They come from Ultrix. What could be older than Ultrix?!! ;)] + +# Character class describing NM global symbol codes. +symcode='[[BCDEGRST]]' + +# Regexp to match symbols that can be accessed directly from C. +sympat='\([[_A-Za-z]][[_A-Za-z0-9]]*\)' + +# Define system-specific variables. +case $host_os in +aix*) + symcode='[[BCDT]]' + ;; +cygwin* | mingw* | pw32* | cegcc*) + symcode='[[ABCDGISTW]]' + ;; +hpux*) + if test "$host_cpu" = ia64; then + symcode='[[ABCDEGRST]]' + fi + ;; +irix* | nonstopux*) + symcode='[[BCDEGRST]]' + ;; +osf*) + symcode='[[BCDEGQRST]]' + ;; +solaris*) + symcode='[[BDRT]]' + ;; +sco3.2v5*) + symcode='[[DT]]' + ;; +sysv4.2uw2*) + symcode='[[DT]]' + ;; +sysv5* | sco5v6* | unixware* | OpenUNIX*) + symcode='[[ABDT]]' + ;; +sysv4) + symcode='[[DFNSTU]]' + ;; +esac + +# If we're using GNU nm, then use its standard symbol codes. +case `$NM -V 2>&1` in +*GNU* | *'with BFD'*) + symcode='[[ABCDGIRSTW]]' ;; +esac + +# Transform an extracted symbol line into a proper C declaration. +# Some systems (esp. on ia64) link data and code symbols differently, +# so use this general approach. +lt_cv_sys_global_symbol_to_cdecl="sed -n -e 's/^T .* \(.*\)$/extern int \1();/p' -e 's/^$symcode* .* \(.*\)$/extern char \1;/p'" + +# Transform an extracted symbol line into symbol name and symbol address +lt_cv_sys_global_symbol_to_c_name_address="sed -n -e 's/^: \([[^ ]]*\)[[ ]]*$/ {\\\"\1\\\", (void *) 0},/p' -e 's/^$symcode* \([[^ ]]*\) \([[^ ]]*\)$/ {\"\2\", (void *) \&\2},/p'" +lt_cv_sys_global_symbol_to_c_name_address_lib_prefix="sed -n -e 's/^: \([[^ ]]*\)[[ ]]*$/ {\\\"\1\\\", (void *) 0},/p' -e 's/^$symcode* \([[^ ]]*\) \(lib[[^ ]]*\)$/ {\"\2\", (void *) \&\2},/p' -e 's/^$symcode* \([[^ ]]*\) \([[^ ]]*\)$/ {\"lib\2\", (void *) \&\2},/p'" + +# Handle CRLF in mingw tool chain +opt_cr= +case $build_os in +mingw*) + opt_cr=`$ECHO 'x\{0,1\}' | tr x '\015'` # option cr in regexp + ;; +esac + +# Try without a prefix underscore, then with it. +for ac_symprfx in "" "_"; do + + # Transform symcode, sympat, and symprfx into a raw symbol and a C symbol. + symxfrm="\\1 $ac_symprfx\\2 \\2" + + # Write the raw and C identifiers. + if test "$lt_cv_nm_interface" = "MS dumpbin"; then + # Fake it for dumpbin and say T for any non-static function + # and D for any global variable. + # Also find C++ and __fastcall symbols from MSVC++, + # which start with @ or ?. + lt_cv_sys_global_symbol_pipe="$AWK ['"\ +" {last_section=section; section=\$ 3};"\ +" /^COFF SYMBOL TABLE/{for(i in hide) delete hide[i]};"\ +" /Section length .*#relocs.*(pick any)/{hide[last_section]=1};"\ +" \$ 0!~/External *\|/{next};"\ +" / 0+ UNDEF /{next}; / UNDEF \([^|]\)*()/{next};"\ +" {if(hide[section]) next};"\ +" {f=0}; \$ 0~/\(\).*\|/{f=1}; {printf f ? \"T \" : \"D \"};"\ +" {split(\$ 0, a, /\||\r/); split(a[2], s)};"\ +" s[1]~/^[@?]/{print s[1], s[1]; next};"\ +" s[1]~prfx {split(s[1],t,\"@\"); print t[1], substr(t[1],length(prfx))}"\ +" ' prfx=^$ac_symprfx]" + else + lt_cv_sys_global_symbol_pipe="sed -n -e 's/^.*[[ ]]\($symcode$symcode*\)[[ ]][[ ]]*$ac_symprfx$sympat$opt_cr$/$symxfrm/p'" + fi + lt_cv_sys_global_symbol_pipe="$lt_cv_sys_global_symbol_pipe | sed '/ __gnu_lto/d'" + + # Check to see that the pipe works correctly. + pipe_works=no + + rm -f conftest* + cat > conftest.$ac_ext <<_LT_EOF +#ifdef __cplusplus +extern "C" { +#endif +char nm_test_var; +void nm_test_func(void); +void nm_test_func(void){} +#ifdef __cplusplus +} +#endif +int main(){nm_test_var='a';nm_test_func();return(0);} +_LT_EOF + + if AC_TRY_EVAL(ac_compile); then + # Now try to grab the symbols. + nlist=conftest.nm + if AC_TRY_EVAL(NM conftest.$ac_objext \| "$lt_cv_sys_global_symbol_pipe" \> $nlist) && test -s "$nlist"; then + # Try sorting and uniquifying the output. + if sort "$nlist" | uniq > "$nlist"T; then + mv -f "$nlist"T "$nlist" + else + rm -f "$nlist"T + fi + + # Make sure that we snagged all the symbols we need. + if $GREP ' nm_test_var$' "$nlist" >/dev/null; then + if $GREP ' nm_test_func$' "$nlist" >/dev/null; then + cat <<_LT_EOF > conftest.$ac_ext +/* Keep this code in sync between libtool.m4, ltmain, lt_system.h, and tests. */ +#if defined(_WIN32) || defined(__CYGWIN__) || defined(_WIN32_WCE) +/* DATA imports from DLLs on WIN32 con't be const, because runtime + relocations are performed -- see ld's documentation on pseudo-relocs. */ +# define LT@&t@_DLSYM_CONST +#elif defined(__osf__) +/* This system does not cope well with relocations in const data. */ +# define LT@&t@_DLSYM_CONST +#else +# define LT@&t@_DLSYM_CONST const +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +_LT_EOF + # Now generate the symbol file. + eval "$lt_cv_sys_global_symbol_to_cdecl"' < "$nlist" | $GREP -v main >> conftest.$ac_ext' + + cat <<_LT_EOF >> conftest.$ac_ext + +/* The mapping between symbol names and symbols. */ +LT@&t@_DLSYM_CONST struct { + const char *name; + void *address; +} +lt__PROGRAM__LTX_preloaded_symbols[[]] = +{ + { "@PROGRAM@", (void *) 0 }, +_LT_EOF + $SED "s/^$symcode$symcode* \(.*\) \(.*\)$/ {\"\2\", (void *) \&\2},/" < "$nlist" | $GREP -v main >> conftest.$ac_ext + cat <<\_LT_EOF >> conftest.$ac_ext + {0, (void *) 0} +}; + +/* This works around a problem in FreeBSD linker */ +#ifdef FREEBSD_WORKAROUND +static const void *lt_preloaded_setup() { + return lt__PROGRAM__LTX_preloaded_symbols; +} +#endif + +#ifdef __cplusplus +} +#endif +_LT_EOF + # Now try linking the two files. + mv conftest.$ac_objext conftstm.$ac_objext + lt_globsym_save_LIBS=$LIBS + lt_globsym_save_CFLAGS=$CFLAGS + LIBS="conftstm.$ac_objext" + CFLAGS="$CFLAGS$_LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)" + if AC_TRY_EVAL(ac_link) && test -s conftest${ac_exeext}; then + pipe_works=yes + fi + LIBS=$lt_globsym_save_LIBS + CFLAGS=$lt_globsym_save_CFLAGS + else + echo "cannot find nm_test_func in $nlist" >&AS_MESSAGE_LOG_FD + fi + else + echo "cannot find nm_test_var in $nlist" >&AS_MESSAGE_LOG_FD + fi + else + echo "cannot run $lt_cv_sys_global_symbol_pipe" >&AS_MESSAGE_LOG_FD + fi + else + echo "$progname: failed program was:" >&AS_MESSAGE_LOG_FD + cat conftest.$ac_ext >&5 + fi + rm -rf conftest* conftst* + + # Do not use the global_symbol_pipe unless it works. + if test "$pipe_works" = yes; then + break + else + lt_cv_sys_global_symbol_pipe= + fi +done +]) +if test -z "$lt_cv_sys_global_symbol_pipe"; then + lt_cv_sys_global_symbol_to_cdecl= +fi +if test -z "$lt_cv_sys_global_symbol_pipe$lt_cv_sys_global_symbol_to_cdecl"; then + AC_MSG_RESULT(failed) +else + AC_MSG_RESULT(ok) +fi + +# Response file support. +if test "$lt_cv_nm_interface" = "MS dumpbin"; then + nm_file_list_spec='@' +elif $NM --help 2>/dev/null | grep '[[@]]FILE' >/dev/null; then + nm_file_list_spec='@' +fi + +_LT_DECL([global_symbol_pipe], [lt_cv_sys_global_symbol_pipe], [1], + [Take the output of nm and produce a listing of raw symbols and C names]) +_LT_DECL([global_symbol_to_cdecl], [lt_cv_sys_global_symbol_to_cdecl], [1], + [Transform the output of nm in a proper C declaration]) +_LT_DECL([global_symbol_to_c_name_address], + [lt_cv_sys_global_symbol_to_c_name_address], [1], + [Transform the output of nm in a C name address pair]) +_LT_DECL([global_symbol_to_c_name_address_lib_prefix], + [lt_cv_sys_global_symbol_to_c_name_address_lib_prefix], [1], + [Transform the output of nm in a C name address pair when lib prefix is needed]) +_LT_DECL([], [nm_file_list_spec], [1], + [Specify filename containing input files for $NM]) +]) # _LT_CMD_GLOBAL_SYMBOLS + + +# _LT_COMPILER_PIC([TAGNAME]) +# --------------------------- +m4_defun([_LT_COMPILER_PIC], +[m4_require([_LT_TAG_COMPILER])dnl +_LT_TAGVAR(lt_prog_compiler_wl, $1)= +_LT_TAGVAR(lt_prog_compiler_pic, $1)= +_LT_TAGVAR(lt_prog_compiler_static, $1)= + +m4_if([$1], [CXX], [ + # C++ specific cases for pic, static, wl, etc. + if test "$GXX" = yes; then + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-static' + + case $host_os in + aix*) + # All AIX code is PIC. + if test "$host_cpu" = ia64; then + # AIX 5 now supports IA64 processor + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + fi + ;; + + amigaos*) + case $host_cpu in + powerpc) + # see comment about AmigaOS4 .so support + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' + ;; + m68k) + # FIXME: we need at least 68020 code to build shared libraries, but + # adding the `-m68020' flag to GCC prevents building anything better, + # like `-m68040'. + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-m68020 -resident32 -malways-restore-a4' + ;; + esac + ;; + + beos* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*) + # PIC is the default for these OSes. + ;; + mingw* | cygwin* | os2* | pw32* | cegcc*) + # This hack is so that the source file can tell whether it is being + # built for inclusion in a dll (and should export symbols for example). + # Although the cygwin gcc ignores -fPIC, still need this for old-style + # (--disable-auto-import) libraries + m4_if([$1], [GCJ], [], + [_LT_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT']) + ;; + darwin* | rhapsody*) + # PIC is the default on this platform + # Common symbols not allowed in MH_DYLIB files + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fno-common' + ;; + *djgpp*) + # DJGPP does not support shared libraries at all + _LT_TAGVAR(lt_prog_compiler_pic, $1)= + ;; + haiku*) + # PIC is the default for Haiku. + # The "-static" flag exists, but is broken. + _LT_TAGVAR(lt_prog_compiler_static, $1)= + ;; + interix[[3-9]]*) + # Interix 3.x gcc -fpic/-fPIC options generate broken code. + # Instead, we relocate shared libraries at runtime. + ;; + sysv4*MP*) + if test -d /usr/nec; then + _LT_TAGVAR(lt_prog_compiler_pic, $1)=-Kconform_pic + fi + ;; + hpux*) + # PIC is the default for 64-bit PA HP-UX, but not for 32-bit + # PA HP-UX. On IA64 HP-UX, PIC is the default but the pic flag + # sets the default TLS model and affects inlining. + case $host_cpu in + hppa*64*) + ;; + *) + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' + ;; + esac + ;; + *qnx* | *nto*) + # QNX uses GNU C++, but need to define -shared option too, otherwise + # it will coredump. + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC -shared' + ;; + *) + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' + ;; + esac + else + case $host_os in + aix[[4-9]]*) + # All AIX code is PIC. + if test "$host_cpu" = ia64; then + # AIX 5 now supports IA64 processor + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + else + _LT_TAGVAR(lt_prog_compiler_static, $1)='-bnso -bI:/lib/syscalls.exp' + fi + ;; + chorus*) + case $cc_basename in + cxch68*) + # Green Hills C++ Compiler + # _LT_TAGVAR(lt_prog_compiler_static, $1)="--no_auto_instantiation -u __main -u __premain -u _abort -r $COOL_DIR/lib/libOrb.a $MVME_DIR/lib/CC/libC.a $MVME_DIR/lib/classix/libcx.s.a" + ;; + esac + ;; + mingw* | cygwin* | os2* | pw32* | cegcc*) + # This hack is so that the source file can tell whether it is being + # built for inclusion in a dll (and should export symbols for example). + m4_if([$1], [GCJ], [], + [_LT_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT']) + ;; + dgux*) + case $cc_basename in + ec++*) + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' + ;; + ghcx*) + # Green Hills C++ Compiler + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-pic' + ;; + *) + ;; + esac + ;; + freebsd* | dragonfly*) + # FreeBSD uses GNU C++ + ;; + hpux9* | hpux10* | hpux11*) + case $cc_basename in + CC*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_static, $1)='${wl}-a ${wl}archive' + if test "$host_cpu" != ia64; then + _LT_TAGVAR(lt_prog_compiler_pic, $1)='+Z' + fi + ;; + aCC*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_static, $1)='${wl}-a ${wl}archive' + case $host_cpu in + hppa*64*|ia64*) + # +Z the default + ;; + *) + _LT_TAGVAR(lt_prog_compiler_pic, $1)='+Z' + ;; + esac + ;; + *) + ;; + esac + ;; + interix*) + # This is c89, which is MS Visual C++ (no shared libs) + # Anyone wants to do a port? + ;; + irix5* | irix6* | nonstopux*) + case $cc_basename in + CC*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared' + # CC pic flag -KPIC is the default. + ;; + *) + ;; + esac + ;; + linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*) + case $cc_basename in + KCC*) + # KAI C++ Compiler + _LT_TAGVAR(lt_prog_compiler_wl, $1)='--backend -Wl,' + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' + ;; + ecpc* ) + # old Intel C++ for x86_64 which still supported -KPIC. + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-static' + ;; + icpc* ) + # Intel C++, used to be incompatible with GCC. + # ICC 10 doesn't accept -KPIC any more. + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-static' + ;; + pgCC* | pgcpp*) + # Portland Group C++ compiler + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fpic' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + ;; + cxx*) + # Compaq C++ + # Make sure the PIC flag is empty. It appears that all Alpha + # Linux and Compaq Tru64 Unix objects are PIC. + _LT_TAGVAR(lt_prog_compiler_pic, $1)= + _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared' + ;; + xlc* | xlC* | bgxl[[cC]]* | mpixl[[cC]]*) + # IBM XL 8.0, 9.0 on PPC and BlueGene + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-qpic' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-qstaticlink' + ;; + *) + case `$CC -V 2>&1 | sed 5q` in + *Sun\ C*) + # Sun C++ 5.9 + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld ' + ;; + esac + ;; + esac + ;; + lynxos*) + ;; + m88k*) + ;; + mvs*) + case $cc_basename in + cxx*) + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-W c,exportall' + ;; + *) + ;; + esac + ;; + netbsd* | netbsdelf*-gnu) + ;; + *qnx* | *nto*) + # QNX uses GNU C++, but need to define -shared option too, otherwise + # it will coredump. + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC -shared' + ;; + osf3* | osf4* | osf5*) + case $cc_basename in + KCC*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='--backend -Wl,' + ;; + RCC*) + # Rational C++ 2.4.1 + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-pic' + ;; + cxx*) + # Digital/Compaq C++ + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + # Make sure the PIC flag is empty. It appears that all Alpha + # Linux and Compaq Tru64 Unix objects are PIC. + _LT_TAGVAR(lt_prog_compiler_pic, $1)= + _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared' + ;; + *) + ;; + esac + ;; + psos*) + ;; + solaris*) + case $cc_basename in + CC* | sunCC*) + # Sun C++ 4.2, 5.x and Centerline C++ + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld ' + ;; + gcx*) + # Green Hills C++ Compiler + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-PIC' + ;; + *) + ;; + esac + ;; + sunos4*) + case $cc_basename in + CC*) + # Sun C++ 4.x + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-pic' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + ;; + lcc*) + # Lucid + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-pic' + ;; + *) + ;; + esac + ;; + sysv5* | unixware* | sco3.2v5* | sco5v6* | OpenUNIX*) + case $cc_basename in + CC*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + ;; + esac + ;; + tandem*) + case $cc_basename in + NCC*) + # NonStop-UX NCC 3.20 + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' + ;; + *) + ;; + esac + ;; + vxworks*) + ;; + *) + _LT_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no + ;; + esac + fi +], +[ + if test "$GCC" = yes; then + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-static' + + case $host_os in + aix*) + # All AIX code is PIC. + if test "$host_cpu" = ia64; then + # AIX 5 now supports IA64 processor + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + fi + ;; + + amigaos*) + case $host_cpu in + powerpc) + # see comment about AmigaOS4 .so support + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' + ;; + m68k) + # FIXME: we need at least 68020 code to build shared libraries, but + # adding the `-m68020' flag to GCC prevents building anything better, + # like `-m68040'. + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-m68020 -resident32 -malways-restore-a4' + ;; + esac + ;; + + beos* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*) + # PIC is the default for these OSes. + ;; + + mingw* | cygwin* | pw32* | os2* | cegcc*) + # This hack is so that the source file can tell whether it is being + # built for inclusion in a dll (and should export symbols for example). + # Although the cygwin gcc ignores -fPIC, still need this for old-style + # (--disable-auto-import) libraries + m4_if([$1], [GCJ], [], + [_LT_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT']) + ;; + + darwin* | rhapsody*) + # PIC is the default on this platform + # Common symbols not allowed in MH_DYLIB files + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fno-common' + ;; + + haiku*) + # PIC is the default for Haiku. + # The "-static" flag exists, but is broken. + _LT_TAGVAR(lt_prog_compiler_static, $1)= + ;; + + hpux*) + # PIC is the default for 64-bit PA HP-UX, but not for 32-bit + # PA HP-UX. On IA64 HP-UX, PIC is the default but the pic flag + # sets the default TLS model and affects inlining. + case $host_cpu in + hppa*64*) + # +Z the default + ;; + *) + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' + ;; + esac + ;; + + interix[[3-9]]*) + # Interix 3.x gcc -fpic/-fPIC options generate broken code. + # Instead, we relocate shared libraries at runtime. + ;; + + msdosdjgpp*) + # Just because we use GCC doesn't mean we suddenly get shared libraries + # on systems that don't support them. + _LT_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no + enable_shared=no + ;; + + *nto* | *qnx*) + # QNX uses GNU C++, but need to define -shared option too, otherwise + # it will coredump. + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC -shared' + ;; + + sysv4*MP*) + if test -d /usr/nec; then + _LT_TAGVAR(lt_prog_compiler_pic, $1)=-Kconform_pic + fi + ;; + + *) + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' + ;; + esac + + case $cc_basename in + nvcc*) # Cuda Compiler Driver 2.2 + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Xlinker ' + if test -n "$_LT_TAGVAR(lt_prog_compiler_pic, $1)"; then + _LT_TAGVAR(lt_prog_compiler_pic, $1)="-Xcompiler $_LT_TAGVAR(lt_prog_compiler_pic, $1)" + fi + ;; + esac + else + # PORTME Check for flag to pass linker flags through the system compiler. + case $host_os in + aix*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + if test "$host_cpu" = ia64; then + # AIX 5 now supports IA64 processor + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + else + _LT_TAGVAR(lt_prog_compiler_static, $1)='-bnso -bI:/lib/syscalls.exp' + fi + ;; + + mingw* | cygwin* | pw32* | os2* | cegcc*) + # This hack is so that the source file can tell whether it is being + # built for inclusion in a dll (and should export symbols for example). + m4_if([$1], [GCJ], [], + [_LT_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT']) + ;; + + hpux9* | hpux10* | hpux11*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but + # not for PA HP-UX. + case $host_cpu in + hppa*64*|ia64*) + # +Z the default + ;; + *) + _LT_TAGVAR(lt_prog_compiler_pic, $1)='+Z' + ;; + esac + # Is there a better lt_prog_compiler_static that works with the bundled CC? + _LT_TAGVAR(lt_prog_compiler_static, $1)='${wl}-a ${wl}archive' + ;; + + irix5* | irix6* | nonstopux*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + # PIC (with -KPIC) is the default. + _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared' + ;; + + linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*) + case $cc_basename in + # old Intel for x86_64 which still supported -KPIC. + ecc*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-static' + ;; + # icc used to be incompatible with GCC. + # ICC 10 doesn't accept -KPIC any more. + icc* | ifort*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-static' + ;; + # Lahey Fortran 8.1. + lf95*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_pic, $1)='--shared' + _LT_TAGVAR(lt_prog_compiler_static, $1)='--static' + ;; + nagfor*) + # NAG Fortran compiler + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,-Wl,,' + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-PIC' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + ;; + pgcc* | pgf77* | pgf90* | pgf95* | pgfortran*) + # Portland Group compilers (*not* the Pentium gcc compiler, + # which looks to be a dead project) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fpic' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + ;; + ccc*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + # All Alpha code is PIC. + _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared' + ;; + xl* | bgxl* | bgf* | mpixl*) + # IBM XL C 8.0/Fortran 10.1, 11.1 on PPC and BlueGene + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-qpic' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-qstaticlink' + ;; + *) + case `$CC -V 2>&1 | sed 5q` in + *Sun\ Ceres\ Fortran* | *Sun*Fortran*\ [[1-7]].* | *Sun*Fortran*\ 8.[[0-3]]*) + # Sun Fortran 8.3 passes all unrecognized flags to the linker + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + _LT_TAGVAR(lt_prog_compiler_wl, $1)='' + ;; + *Sun\ F* | *Sun*Fortran*) + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld ' + ;; + *Sun\ C*) + # Sun C 5.9 + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + ;; + *Intel*\ [[CF]]*Compiler*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-static' + ;; + *Portland\ Group*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fpic' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + ;; + esac + ;; + esac + ;; + + newsos6) + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + ;; + + *nto* | *qnx*) + # QNX uses GNU C++, but need to define -shared option too, otherwise + # it will coredump. + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC -shared' + ;; + + osf3* | osf4* | osf5*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + # All OSF/1 code is PIC. + _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared' + ;; + + rdos*) + _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared' + ;; + + solaris*) + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + case $cc_basename in + f77* | f90* | f95* | sunf77* | sunf90* | sunf95*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld ';; + *) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,';; + esac + ;; + + sunos4*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld ' + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-PIC' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + ;; + + sysv4 | sysv4.2uw2* | sysv4.3*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + ;; + + sysv4*MP*) + if test -d /usr/nec ;then + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-Kconform_pic' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + fi + ;; + + sysv5* | unixware* | sco3.2v5* | sco5v6* | OpenUNIX*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + ;; + + unicos*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no + ;; + + uts4*) + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-pic' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + ;; + + *) + _LT_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no + ;; + esac + fi +]) +case $host_os in + # For platforms which do not support PIC, -DPIC is meaningless: + *djgpp*) + _LT_TAGVAR(lt_prog_compiler_pic, $1)= + ;; + *) + _LT_TAGVAR(lt_prog_compiler_pic, $1)="$_LT_TAGVAR(lt_prog_compiler_pic, $1)@&t@m4_if([$1],[],[ -DPIC],[m4_if([$1],[CXX],[ -DPIC],[])])" + ;; +esac + +AC_CACHE_CHECK([for $compiler option to produce PIC], + [_LT_TAGVAR(lt_cv_prog_compiler_pic, $1)], + [_LT_TAGVAR(lt_cv_prog_compiler_pic, $1)=$_LT_TAGVAR(lt_prog_compiler_pic, $1)]) +_LT_TAGVAR(lt_prog_compiler_pic, $1)=$_LT_TAGVAR(lt_cv_prog_compiler_pic, $1) + +# +# Check to make sure the PIC flag actually works. +# +if test -n "$_LT_TAGVAR(lt_prog_compiler_pic, $1)"; then + _LT_COMPILER_OPTION([if $compiler PIC flag $_LT_TAGVAR(lt_prog_compiler_pic, $1) works], + [_LT_TAGVAR(lt_cv_prog_compiler_pic_works, $1)], + [$_LT_TAGVAR(lt_prog_compiler_pic, $1)@&t@m4_if([$1],[],[ -DPIC],[m4_if([$1],[CXX],[ -DPIC],[])])], [], + [case $_LT_TAGVAR(lt_prog_compiler_pic, $1) in + "" | " "*) ;; + *) _LT_TAGVAR(lt_prog_compiler_pic, $1)=" $_LT_TAGVAR(lt_prog_compiler_pic, $1)" ;; + esac], + [_LT_TAGVAR(lt_prog_compiler_pic, $1)= + _LT_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no]) +fi +_LT_TAGDECL([pic_flag], [lt_prog_compiler_pic], [1], + [Additional compiler flags for building library objects]) + +_LT_TAGDECL([wl], [lt_prog_compiler_wl], [1], + [How to pass a linker flag through the compiler]) +# +# Check to make sure the static flag actually works. +# +wl=$_LT_TAGVAR(lt_prog_compiler_wl, $1) eval lt_tmp_static_flag=\"$_LT_TAGVAR(lt_prog_compiler_static, $1)\" +_LT_LINKER_OPTION([if $compiler static flag $lt_tmp_static_flag works], + _LT_TAGVAR(lt_cv_prog_compiler_static_works, $1), + $lt_tmp_static_flag, + [], + [_LT_TAGVAR(lt_prog_compiler_static, $1)=]) +_LT_TAGDECL([link_static_flag], [lt_prog_compiler_static], [1], + [Compiler flag to prevent dynamic linking]) +])# _LT_COMPILER_PIC + + +# _LT_LINKER_SHLIBS([TAGNAME]) +# ---------------------------- +# See if the linker supports building shared libraries. +m4_defun([_LT_LINKER_SHLIBS], +[AC_REQUIRE([LT_PATH_LD])dnl +AC_REQUIRE([LT_PATH_NM])dnl +m4_require([_LT_PATH_MANIFEST_TOOL])dnl +m4_require([_LT_FILEUTILS_DEFAULTS])dnl +m4_require([_LT_DECL_EGREP])dnl +m4_require([_LT_DECL_SED])dnl +m4_require([_LT_CMD_GLOBAL_SYMBOLS])dnl +m4_require([_LT_TAG_COMPILER])dnl +AC_MSG_CHECKING([whether the $compiler linker ($LD) supports shared libraries]) +m4_if([$1], [CXX], [ + _LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols' + _LT_TAGVAR(exclude_expsyms, $1)=['_GLOBAL_OFFSET_TABLE_|_GLOBAL__F[ID]_.*'] + case $host_os in + aix[[4-9]]*) + # If we're using GNU nm, then we don't want the "-C" option. + # -C means demangle to AIX nm, but means don't demangle with GNU nm + # Also, AIX nm treats weak defined symbols like other global defined + # symbols, whereas GNU nm marks them as "W". + if $NM -V 2>&1 | $GREP 'GNU' > /dev/null; then + _LT_TAGVAR(export_symbols_cmds, $1)='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W")) && ([substr](\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols' + else + _LT_TAGVAR(export_symbols_cmds, $1)='$NM -BCpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B")) && ([substr](\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols' + fi + ;; + pw32*) + _LT_TAGVAR(export_symbols_cmds, $1)="$ltdll_cmds" + ;; + cygwin* | mingw* | cegcc*) + case $cc_basename in + cl*) + _LT_TAGVAR(exclude_expsyms, $1)='_NULL_IMPORT_DESCRIPTOR|_IMPORT_DESCRIPTOR_.*' + ;; + *) + _LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[[BCDGRS]][[ ]]/s/.*[[ ]]\([[^ ]]*\)/\1 DATA/;s/^.*[[ ]]__nm__\([[^ ]]*\)[[ ]][[^ ]]*/\1 DATA/;/^I[[ ]]/d;/^[[AITW]][[ ]]/s/.* //'\'' | sort | uniq > $export_symbols' + _LT_TAGVAR(exclude_expsyms, $1)=['[_]+GLOBAL_OFFSET_TABLE_|[_]+GLOBAL__[FID]_.*|[_]+head_[A-Za-z0-9_]+_dll|[A-Za-z0-9_]+_dll_iname'] + ;; + esac + ;; + linux* | k*bsd*-gnu | gnu*) + _LT_TAGVAR(link_all_deplibs, $1)=no + ;; + *) + _LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols' + ;; + esac +], [ + runpath_var= + _LT_TAGVAR(allow_undefined_flag, $1)= + _LT_TAGVAR(always_export_symbols, $1)=no + _LT_TAGVAR(archive_cmds, $1)= + _LT_TAGVAR(archive_expsym_cmds, $1)= + _LT_TAGVAR(compiler_needs_object, $1)=no + _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=no + _LT_TAGVAR(export_dynamic_flag_spec, $1)= + _LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols' + _LT_TAGVAR(hardcode_automatic, $1)=no + _LT_TAGVAR(hardcode_direct, $1)=no + _LT_TAGVAR(hardcode_direct_absolute, $1)=no + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)= + _LT_TAGVAR(hardcode_libdir_separator, $1)= + _LT_TAGVAR(hardcode_minus_L, $1)=no + _LT_TAGVAR(hardcode_shlibpath_var, $1)=unsupported + _LT_TAGVAR(inherit_rpath, $1)=no + _LT_TAGVAR(link_all_deplibs, $1)=unknown + _LT_TAGVAR(module_cmds, $1)= + _LT_TAGVAR(module_expsym_cmds, $1)= + _LT_TAGVAR(old_archive_from_new_cmds, $1)= + _LT_TAGVAR(old_archive_from_expsyms_cmds, $1)= + _LT_TAGVAR(thread_safe_flag_spec, $1)= + _LT_TAGVAR(whole_archive_flag_spec, $1)= + # include_expsyms should be a list of space-separated symbols to be *always* + # included in the symbol list + _LT_TAGVAR(include_expsyms, $1)= + # exclude_expsyms can be an extended regexp of symbols to exclude + # it will be wrapped by ` (' and `)$', so one must not match beginning or + # end of line. Example: `a|bc|.*d.*' will exclude the symbols `a' and `bc', + # as well as any symbol that contains `d'. + _LT_TAGVAR(exclude_expsyms, $1)=['_GLOBAL_OFFSET_TABLE_|_GLOBAL__F[ID]_.*'] + # Although _GLOBAL_OFFSET_TABLE_ is a valid symbol C name, most a.out + # platforms (ab)use it in PIC code, but their linkers get confused if + # the symbol is explicitly referenced. Since portable code cannot + # rely on this symbol name, it's probably fine to never include it in + # preloaded symbol tables. + # Exclude shared library initialization/finalization symbols. +dnl Note also adjust exclude_expsyms for C++ above. + extract_expsyms_cmds= + + case $host_os in + cygwin* | mingw* | pw32* | cegcc*) + # FIXME: the MSVC++ port hasn't been tested in a loooong time + # When not using gcc, we currently assume that we are using + # Microsoft Visual C++. + if test "$GCC" != yes; then + with_gnu_ld=no + fi + ;; + interix*) + # we just hope/assume this is gcc and not c89 (= MSVC++) + with_gnu_ld=yes + ;; + openbsd*) + with_gnu_ld=no + ;; + linux* | k*bsd*-gnu | gnu*) + _LT_TAGVAR(link_all_deplibs, $1)=no + ;; + esac + + _LT_TAGVAR(ld_shlibs, $1)=yes + + # On some targets, GNU ld is compatible enough with the native linker + # that we're better off using the native interface for both. + lt_use_gnu_ld_interface=no + if test "$with_gnu_ld" = yes; then + case $host_os in + aix*) + # The AIX port of GNU ld has always aspired to compatibility + # with the native linker. However, as the warning in the GNU ld + # block says, versions before 2.19.5* couldn't really create working + # shared libraries, regardless of the interface used. + case `$LD -v 2>&1` in + *\ \(GNU\ Binutils\)\ 2.19.5*) ;; + *\ \(GNU\ Binutils\)\ 2.[[2-9]]*) ;; + *\ \(GNU\ Binutils\)\ [[3-9]]*) ;; + *) + lt_use_gnu_ld_interface=yes + ;; + esac + ;; + *) + lt_use_gnu_ld_interface=yes + ;; + esac + fi + + if test "$lt_use_gnu_ld_interface" = yes; then + # If archive_cmds runs LD, not CC, wlarc should be empty + wlarc='${wl}' + + # Set some defaults for GNU ld with shared library support. These + # are reset later if shared libraries are not supported. Putting them + # here allows them to be overridden if necessary. + runpath_var=LD_RUN_PATH + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' + _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic' + # ancient GNU ld didn't support --whole-archive et. al. + if $LD --help 2>&1 | $GREP 'no-whole-archive' > /dev/null; then + _LT_TAGVAR(whole_archive_flag_spec, $1)="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive' + else + _LT_TAGVAR(whole_archive_flag_spec, $1)= + fi + supports_anon_versioning=no + case `$LD -v 2>&1` in + *GNU\ gold*) supports_anon_versioning=yes ;; + *\ [[01]].* | *\ 2.[[0-9]].* | *\ 2.10.*) ;; # catch versions < 2.11 + *\ 2.11.93.0.2\ *) supports_anon_versioning=yes ;; # RH7.3 ... + *\ 2.11.92.0.12\ *) supports_anon_versioning=yes ;; # Mandrake 8.2 ... + *\ 2.11.*) ;; # other 2.11 versions + *) supports_anon_versioning=yes ;; + esac + + # See if GNU ld supports shared libraries. + case $host_os in + aix[[3-9]]*) + # On AIX/PPC, the GNU linker is very broken + if test "$host_cpu" != ia64; then + _LT_TAGVAR(ld_shlibs, $1)=no + cat <<_LT_EOF 1>&2 + +*** Warning: the GNU linker, at least up to release 2.19, is reported +*** to be unable to reliably create shared libraries on AIX. +*** Therefore, libtool is disabling shared libraries support. If you +*** really care for shared libraries, you may want to install binutils +*** 2.20 or above, or modify your PATH so that a non-GNU linker is found. +*** You will then need to restart the configuration process. + +_LT_EOF + fi + ;; + + amigaos*) + case $host_cpu in + powerpc) + # see comment about AmigaOS4 .so support + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='' + ;; + m68k) + _LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/a2ixlibrary.data~$ECHO "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$ECHO "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$ECHO "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$ECHO "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' + _LT_TAGVAR(hardcode_minus_L, $1)=yes + ;; + esac + ;; + + beos*) + if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then + _LT_TAGVAR(allow_undefined_flag, $1)=unsupported + # Joseph Beckenbach says some releases of gcc + # support --undefined. This deserves some investigation. FIXME + _LT_TAGVAR(archive_cmds, $1)='$CC -nostart $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + else + _LT_TAGVAR(ld_shlibs, $1)=no + fi + ;; + + cygwin* | mingw* | pw32* | cegcc*) + # _LT_TAGVAR(hardcode_libdir_flag_spec, $1) is actually meaningless, + # as there is no search path for DLLs. + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' + _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-all-symbols' + _LT_TAGVAR(allow_undefined_flag, $1)=unsupported + _LT_TAGVAR(always_export_symbols, $1)=no + _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes + _LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[[BCDGRS]][[ ]]/s/.*[[ ]]\([[^ ]]*\)/\1 DATA/;s/^.*[[ ]]__nm__\([[^ ]]*\)[[ ]][[^ ]]*/\1 DATA/;/^I[[ ]]/d;/^[[AITW]][[ ]]/s/.* //'\'' | sort | uniq > $export_symbols' + _LT_TAGVAR(exclude_expsyms, $1)=['[_]+GLOBAL_OFFSET_TABLE_|[_]+GLOBAL__[FID]_.*|[_]+head_[A-Za-z0-9_]+_dll|[A-Za-z0-9_]+_dll_iname'] + + if $LD --help 2>&1 | $GREP 'auto-import' > /dev/null; then + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib' + # If the export-symbols file already is a .def file (1st line + # is EXPORTS), use it as is; otherwise, prepend... + _LT_TAGVAR(archive_expsym_cmds, $1)='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then + cp $export_symbols $output_objdir/$soname.def; + else + echo EXPORTS > $output_objdir/$soname.def; + cat $export_symbols >> $output_objdir/$soname.def; + fi~ + $CC -shared $output_objdir/$soname.def $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib' + else + _LT_TAGVAR(ld_shlibs, $1)=no + fi + ;; + + haiku*) + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + _LT_TAGVAR(link_all_deplibs, $1)=yes + ;; + + interix[[3-9]]*) + _LT_TAGVAR(hardcode_direct, $1)=no + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir' + _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E' + # Hack: On Interix 3.x, we cannot compile PIC because of a broken gcc. + # Instead, shared libraries are loaded at an image base (0x10000000 by + # default) and relocated if they conflict, which is a slow very memory + # consuming and fragmenting process. To avoid this, we pick a random, + # 256 KiB-aligned image base between 0x50000000 and 0x6FFC0000 at link + # time. Moving up from 0x10000000 also allows more sbrk(2) space. + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='sed "s,^,_," $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--retain-symbols-file,$output_objdir/$soname.expsym ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib' + ;; + + gnu* | linux* | tpf* | k*bsd*-gnu | kopensolaris*-gnu) + tmp_diet=no + if test "$host_os" = linux-dietlibc; then + case $cc_basename in + diet\ *) tmp_diet=yes;; # linux-dietlibc with static linking (!diet-dyn) + esac + fi + if $LD --help 2>&1 | $EGREP ': supported targets:.* elf' > /dev/null \ + && test "$tmp_diet" = no + then + tmp_addflag=' $pic_flag' + tmp_sharedflag='-shared' + case $cc_basename,$host_cpu in + pgcc*) # Portland Group C compiler + _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive' + tmp_addflag=' $pic_flag' + ;; + pgf77* | pgf90* | pgf95* | pgfortran*) + # Portland Group f77 and f90 compilers + _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive' + tmp_addflag=' $pic_flag -Mnomain' ;; + ecc*,ia64* | icc*,ia64*) # Intel C compiler on ia64 + tmp_addflag=' -i_dynamic' ;; + efc*,ia64* | ifort*,ia64*) # Intel Fortran compiler on ia64 + tmp_addflag=' -i_dynamic -nofor_main' ;; + ifc* | ifort*) # Intel Fortran compiler + tmp_addflag=' -nofor_main' ;; + lf95*) # Lahey Fortran 8.1 + _LT_TAGVAR(whole_archive_flag_spec, $1)= + tmp_sharedflag='--shared' ;; + xl[[cC]]* | bgxl[[cC]]* | mpixl[[cC]]*) # IBM XL C 8.0 on PPC (deal with xlf below) + tmp_sharedflag='-qmkshrobj' + tmp_addflag= ;; + nvcc*) # Cuda Compiler Driver 2.2 + _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive' + _LT_TAGVAR(compiler_needs_object, $1)=yes + ;; + esac + case `$CC -V 2>&1 | sed 5q` in + *Sun\ C*) # Sun C 5.9 + _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`new_convenience=; for conv in $convenience\"\"; do test -z \"$conv\" || new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive' + _LT_TAGVAR(compiler_needs_object, $1)=yes + tmp_sharedflag='-G' ;; + *Sun\ F*) # Sun Fortran 8.3 + tmp_sharedflag='-G' ;; + esac + _LT_TAGVAR(archive_cmds, $1)='$CC '"$tmp_sharedflag""$tmp_addflag"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + + if test "x$supports_anon_versioning" = xyes; then + _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $output_objdir/$libname.ver~ + cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~ + echo "local: *; };" >> $output_objdir/$libname.ver~ + $CC '"$tmp_sharedflag""$tmp_addflag"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-version-script ${wl}$output_objdir/$libname.ver -o $lib' + fi + + case $cc_basename in + xlf* | bgf* | bgxlf* | mpixlf*) + # IBM XL Fortran 10.1 on PPC cannot create shared libs itself + _LT_TAGVAR(whole_archive_flag_spec, $1)='--whole-archive$convenience --no-whole-archive' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' + _LT_TAGVAR(archive_cmds, $1)='$LD -shared $libobjs $deplibs $linker_flags -soname $soname -o $lib' + if test "x$supports_anon_versioning" = xyes; then + _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $output_objdir/$libname.ver~ + cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~ + echo "local: *; };" >> $output_objdir/$libname.ver~ + $LD -shared $libobjs $deplibs $linker_flags -soname $soname -version-script $output_objdir/$libname.ver -o $lib' + fi + ;; + esac + else + _LT_TAGVAR(ld_shlibs, $1)=no + fi + ;; + + netbsd* | netbsdelf*-gnu) + if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then + _LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable $libobjs $deplibs $linker_flags -o $lib' + wlarc= + else + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + fi + ;; + + solaris*) + if $LD -v 2>&1 | $GREP 'BFD 2\.8' > /dev/null; then + _LT_TAGVAR(ld_shlibs, $1)=no + cat <<_LT_EOF 1>&2 + +*** Warning: The releases 2.8.* of the GNU linker cannot reliably +*** create shared libraries on Solaris systems. Therefore, libtool +*** is disabling shared libraries support. We urge you to upgrade GNU +*** binutils to release 2.9.1 or newer. Another option is to modify +*** your PATH or compiler configuration so that the native linker is +*** used, and then restart. + +_LT_EOF + elif $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + else + _LT_TAGVAR(ld_shlibs, $1)=no + fi + ;; + + sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX*) + case `$LD -v 2>&1` in + *\ [[01]].* | *\ 2.[[0-9]].* | *\ 2.1[[0-5]].*) + _LT_TAGVAR(ld_shlibs, $1)=no + cat <<_LT_EOF 1>&2 + +*** Warning: Releases of the GNU linker prior to 2.16.91.0.3 can not +*** reliably create shared libraries on SCO systems. Therefore, libtool +*** is disabling shared libraries support. We urge you to upgrade GNU +*** binutils to release 2.16.91.0.3 or newer. Another option is to modify +*** your PATH or compiler configuration so that the native linker is +*** used, and then restart. + +_LT_EOF + ;; + *) + # For security reasons, it is highly recommended that you always + # use absolute paths for naming shared libraries, and exclude the + # DT_RUNPATH tag from executables and libraries. But doing so + # requires that you compile everything twice, which is a pain. + if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + else + _LT_TAGVAR(ld_shlibs, $1)=no + fi + ;; + esac + ;; + + sunos4*) + _LT_TAGVAR(archive_cmds, $1)='$LD -assert pure-text -Bshareable -o $lib $libobjs $deplibs $linker_flags' + wlarc= + _LT_TAGVAR(hardcode_direct, $1)=yes + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + ;; + + *) + if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + else + _LT_TAGVAR(ld_shlibs, $1)=no + fi + ;; + esac + + if test "$_LT_TAGVAR(ld_shlibs, $1)" = no; then + runpath_var= + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)= + _LT_TAGVAR(export_dynamic_flag_spec, $1)= + _LT_TAGVAR(whole_archive_flag_spec, $1)= + fi + else + # PORTME fill in a description of your system's linker (not GNU ld) + case $host_os in + aix3*) + _LT_TAGVAR(allow_undefined_flag, $1)=unsupported + _LT_TAGVAR(always_export_symbols, $1)=yes + _LT_TAGVAR(archive_expsym_cmds, $1)='$LD -o $output_objdir/$soname $libobjs $deplibs $linker_flags -bE:$export_symbols -T512 -H512 -bM:SRE~$AR $AR_FLAGS $lib $output_objdir/$soname' + # Note: this linker hardcodes the directories in LIBPATH if there + # are no directories specified by -L. + _LT_TAGVAR(hardcode_minus_L, $1)=yes + if test "$GCC" = yes && test -z "$lt_prog_compiler_static"; then + # Neither direct hardcoding nor static linking is supported with a + # broken collect2. + _LT_TAGVAR(hardcode_direct, $1)=unsupported + fi + ;; + + aix[[4-9]]*) + if test "$host_cpu" = ia64; then + # On IA64, the linker does run time linking by default, so we don't + # have to do anything special. + aix_use_runtimelinking=no + exp_sym_flag='-Bexport' + no_entry_flag="" + else + # If we're using GNU nm, then we don't want the "-C" option. + # -C means demangle to AIX nm, but means don't demangle with GNU nm + # Also, AIX nm treats weak defined symbols like other global + # defined symbols, whereas GNU nm marks them as "W". + if $NM -V 2>&1 | $GREP 'GNU' > /dev/null; then + _LT_TAGVAR(export_symbols_cmds, $1)='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W")) && ([substr](\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols' + else + _LT_TAGVAR(export_symbols_cmds, $1)='$NM -BCpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B")) && ([substr](\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols' + fi + aix_use_runtimelinking=no + + # Test if we are trying to use run time linking or normal + # AIX style linking. If -brtl is somewhere in LDFLAGS, we + # need to do runtime linking. + case $host_os in aix4.[[23]]|aix4.[[23]].*|aix[[5-9]]*) + for ld_flag in $LDFLAGS; do + if (test $ld_flag = "-brtl" || test $ld_flag = "-Wl,-brtl"); then + aix_use_runtimelinking=yes + break + fi + done + ;; + esac + + exp_sym_flag='-bexport' + no_entry_flag='-bnoentry' + fi + + # When large executables or shared objects are built, AIX ld can + # have problems creating the table of contents. If linking a library + # or program results in "error TOC overflow" add -mminimal-toc to + # CXXFLAGS/CFLAGS for g++/gcc. In the cases where that is not + # enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS. + + _LT_TAGVAR(archive_cmds, $1)='' + _LT_TAGVAR(hardcode_direct, $1)=yes + _LT_TAGVAR(hardcode_direct_absolute, $1)=yes + _LT_TAGVAR(hardcode_libdir_separator, $1)=':' + _LT_TAGVAR(link_all_deplibs, $1)=yes + _LT_TAGVAR(file_list_spec, $1)='${wl}-f,' + + if test "$GCC" = yes; then + case $host_os in aix4.[[012]]|aix4.[[012]].*) + # We only want to do this on AIX 4.2 and lower, the check + # below for broken collect2 doesn't work under 4.3+ + collect2name=`${CC} -print-prog-name=collect2` + if test -f "$collect2name" && + strings "$collect2name" | $GREP resolve_lib_name >/dev/null + then + # We have reworked collect2 + : + else + # We have old collect2 + _LT_TAGVAR(hardcode_direct, $1)=unsupported + # It fails to find uninstalled libraries when the uninstalled + # path is not listed in the libpath. Setting hardcode_minus_L + # to unsupported forces relinking + _LT_TAGVAR(hardcode_minus_L, $1)=yes + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' + _LT_TAGVAR(hardcode_libdir_separator, $1)= + fi + ;; + esac + shared_flag='-shared' + if test "$aix_use_runtimelinking" = yes; then + shared_flag="$shared_flag "'${wl}-G' + fi + _LT_TAGVAR(link_all_deplibs, $1)=no + else + # not using gcc + if test "$host_cpu" = ia64; then + # VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release + # chokes on -Wl,-G. The following line is correct: + shared_flag='-G' + else + if test "$aix_use_runtimelinking" = yes; then + shared_flag='${wl}-G' + else + shared_flag='${wl}-bM:SRE' + fi + fi + fi + + _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-bexpall' + # It seems that -bexpall does not export symbols beginning with + # underscore (_), so it is better to generate a list of symbols to export. + _LT_TAGVAR(always_export_symbols, $1)=yes + if test "$aix_use_runtimelinking" = yes; then + # Warning - without using the other runtime loading flags (-brtl), + # -berok will link without error, but may produce a broken library. + _LT_TAGVAR(allow_undefined_flag, $1)='-berok' + # Determine the default libpath from the value encoded in an + # empty executable. + _LT_SYS_MODULE_PATH_AIX([$1]) + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-blibpath:$libdir:'"$aix_libpath" + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then func_echo_all "${wl}${allow_undefined_flag}"; else :; fi` '"\${wl}$exp_sym_flag:\$export_symbols $shared_flag" + else + if test "$host_cpu" = ia64; then + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R $libdir:/usr/lib:/lib' + _LT_TAGVAR(allow_undefined_flag, $1)="-z nodefs" + _LT_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$exp_sym_flag:\$export_symbols" + else + # Determine the default libpath from the value encoded in an + # empty executable. + _LT_SYS_MODULE_PATH_AIX([$1]) + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-blibpath:$libdir:'"$aix_libpath" + # Warning - without using the other run time loading flags, + # -berok will link without error, but may produce a broken library. + _LT_TAGVAR(no_undefined_flag, $1)=' ${wl}-bernotok' + _LT_TAGVAR(allow_undefined_flag, $1)=' ${wl}-berok' + if test "$with_gnu_ld" = yes; then + # We only use this code for GNU lds that support --whole-archive. + _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive$convenience ${wl}--no-whole-archive' + else + # Exported symbols can be pulled into shared objects from archives + _LT_TAGVAR(whole_archive_flag_spec, $1)='$convenience' + fi + _LT_TAGVAR(archive_cmds_need_lc, $1)=yes + # This is similar to how AIX traditionally builds its shared libraries. + _LT_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs ${wl}-bnoentry $compiler_flags ${wl}-bE:$export_symbols${allow_undefined_flag}~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$soname' + fi + fi + ;; + + amigaos*) + case $host_cpu in + powerpc) + # see comment about AmigaOS4 .so support + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='' + ;; + m68k) + _LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/a2ixlibrary.data~$ECHO "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$ECHO "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$ECHO "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$ECHO "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' + _LT_TAGVAR(hardcode_minus_L, $1)=yes + ;; + esac + ;; + + bsdi[[45]]*) + _LT_TAGVAR(export_dynamic_flag_spec, $1)=-rdynamic + ;; + + cygwin* | mingw* | pw32* | cegcc*) + # When not using gcc, we currently assume that we are using + # Microsoft Visual C++. + # hardcode_libdir_flag_spec is actually meaningless, as there is + # no search path for DLLs. + case $cc_basename in + cl*) + # Native MSVC + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)=' ' + _LT_TAGVAR(allow_undefined_flag, $1)=unsupported + _LT_TAGVAR(always_export_symbols, $1)=yes + _LT_TAGVAR(file_list_spec, $1)='@' + # Tell ltmain to make .lib files, not .a files. + libext=lib + # Tell ltmain to make .dll files, not .so files. + shrext_cmds=".dll" + # FIXME: Setting linknames here is a bad hack. + _LT_TAGVAR(archive_cmds, $1)='$CC -o $output_objdir/$soname $libobjs $compiler_flags $deplibs -Wl,-dll~linknames=' + _LT_TAGVAR(archive_expsym_cmds, $1)='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then + sed -n -e 's/\\\\\\\(.*\\\\\\\)/-link\\\ -EXPORT:\\\\\\\1/' -e '1\\\!p' < $export_symbols > $output_objdir/$soname.exp; + else + sed -e 's/\\\\\\\(.*\\\\\\\)/-link\\\ -EXPORT:\\\\\\\1/' < $export_symbols > $output_objdir/$soname.exp; + fi~ + $CC -o $tool_output_objdir$soname $libobjs $compiler_flags $deplibs "@$tool_output_objdir$soname.exp" -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~ + linknames=' + # The linker will not automatically build a static lib if we build a DLL. + # _LT_TAGVAR(old_archive_from_new_cmds, $1)='true' + _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes + _LT_TAGVAR(exclude_expsyms, $1)='_NULL_IMPORT_DESCRIPTOR|_IMPORT_DESCRIPTOR_.*' + _LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[[BCDGRS]][[ ]]/s/.*[[ ]]\([[^ ]]*\)/\1,DATA/'\'' | $SED -e '\''/^[[AITW]][[ ]]/s/.*[[ ]]//'\'' | sort | uniq > $export_symbols' + # Don't use ranlib + _LT_TAGVAR(old_postinstall_cmds, $1)='chmod 644 $oldlib' + _LT_TAGVAR(postlink_cmds, $1)='lt_outputfile="@OUTPUT@"~ + lt_tool_outputfile="@TOOL_OUTPUT@"~ + case $lt_outputfile in + *.exe|*.EXE) ;; + *) + lt_outputfile="$lt_outputfile.exe" + lt_tool_outputfile="$lt_tool_outputfile.exe" + ;; + esac~ + if test "$MANIFEST_TOOL" != ":" && test -f "$lt_outputfile.manifest"; then + $MANIFEST_TOOL -manifest "$lt_tool_outputfile.manifest" -outputresource:"$lt_tool_outputfile" || exit 1; + $RM "$lt_outputfile.manifest"; + fi' + ;; + *) + # Assume MSVC wrapper + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)=' ' + _LT_TAGVAR(allow_undefined_flag, $1)=unsupported + # Tell ltmain to make .lib files, not .a files. + libext=lib + # Tell ltmain to make .dll files, not .so files. + shrext_cmds=".dll" + # FIXME: Setting linknames here is a bad hack. + _LT_TAGVAR(archive_cmds, $1)='$CC -o $lib $libobjs $compiler_flags `func_echo_all "$deplibs" | $SED '\''s/ -lc$//'\''` -link -dll~linknames=' + # The linker will automatically build a .lib file if we build a DLL. + _LT_TAGVAR(old_archive_from_new_cmds, $1)='true' + # FIXME: Should let the user specify the lib program. + _LT_TAGVAR(old_archive_cmds, $1)='lib -OUT:$oldlib$oldobjs$old_deplibs' + _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes + ;; + esac + ;; + + darwin* | rhapsody*) + _LT_DARWIN_LINKER_FEATURES($1) + ;; + + dgux*) + _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + ;; + + # FreeBSD 2.2.[012] allows us to include c++rt0.o to get C++ constructor + # support. Future versions do this automatically, but an explicit c++rt0.o + # does not break anything, and helps significantly (at the cost of a little + # extra space). + freebsd2.2*) + _LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags /usr/lib/c++rt0.o' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir' + _LT_TAGVAR(hardcode_direct, $1)=yes + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + ;; + + # Unfortunately, older versions of FreeBSD 2 do not have this feature. + freebsd2.*) + _LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags' + _LT_TAGVAR(hardcode_direct, $1)=yes + _LT_TAGVAR(hardcode_minus_L, $1)=yes + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + ;; + + # FreeBSD 3 and greater uses gcc -shared to do shared libraries. + freebsd* | dragonfly*) + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir' + _LT_TAGVAR(hardcode_direct, $1)=yes + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + ;; + + hpux9*) + if test "$GCC" = yes; then + _LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/$soname~$CC -shared $pic_flag ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $libobjs $deplibs $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib' + else + _LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/$soname~$LD -b +b $install_libdir -o $output_objdir/$soname $libobjs $deplibs $linker_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib' + fi + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir' + _LT_TAGVAR(hardcode_libdir_separator, $1)=: + _LT_TAGVAR(hardcode_direct, $1)=yes + + # hardcode_minus_L: Not really in the search PATH, + # but as the default location of the library. + _LT_TAGVAR(hardcode_minus_L, $1)=yes + _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E' + ;; + + hpux10*) + if test "$GCC" = yes && test "$with_gnu_ld" = no; then + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags' + else + _LT_TAGVAR(archive_cmds, $1)='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags' + fi + if test "$with_gnu_ld" = no; then + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir' + _LT_TAGVAR(hardcode_libdir_separator, $1)=: + _LT_TAGVAR(hardcode_direct, $1)=yes + _LT_TAGVAR(hardcode_direct_absolute, $1)=yes + _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E' + # hardcode_minus_L: Not really in the search PATH, + # but as the default location of the library. + _LT_TAGVAR(hardcode_minus_L, $1)=yes + fi + ;; + + hpux11*) + if test "$GCC" = yes && test "$with_gnu_ld" = no; then + case $host_cpu in + hppa*64*) + _LT_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}+h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags' + ;; + ia64*) + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags' + ;; + *) + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags' + ;; + esac + else + case $host_cpu in + hppa*64*) + _LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags' + ;; + ia64*) + _LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags' + ;; + *) + m4_if($1, [], [ + # Older versions of the 11.00 compiler do not understand -b yet + # (HP92453-01 A.11.01.20 doesn't, HP92453-01 B.11.X.35175-35176.GP does) + _LT_LINKER_OPTION([if $CC understands -b], + _LT_TAGVAR(lt_cv_prog_compiler__b, $1), [-b], + [_LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'], + [_LT_TAGVAR(archive_cmds, $1)='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags'])], + [_LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags']) + ;; + esac + fi + if test "$with_gnu_ld" = no; then + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir' + _LT_TAGVAR(hardcode_libdir_separator, $1)=: + + case $host_cpu in + hppa*64*|ia64*) + _LT_TAGVAR(hardcode_direct, $1)=no + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + ;; + *) + _LT_TAGVAR(hardcode_direct, $1)=yes + _LT_TAGVAR(hardcode_direct_absolute, $1)=yes + _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E' + + # hardcode_minus_L: Not really in the search PATH, + # but as the default location of the library. + _LT_TAGVAR(hardcode_minus_L, $1)=yes + ;; + esac + fi + ;; + + irix5* | irix6* | nonstopux*) + if test "$GCC" = yes; then + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' + # Try to use the -exported_symbol ld option, if it does not + # work, assume that -exports_file does not work either and + # implicitly export all symbols. + # This should be the same for all languages, so no per-tag cache variable. + AC_CACHE_CHECK([whether the $host_os linker accepts -exported_symbol], + [lt_cv_irix_exported_symbol], + [save_LDFLAGS="$LDFLAGS" + LDFLAGS="$LDFLAGS -shared ${wl}-exported_symbol ${wl}foo ${wl}-update_registry ${wl}/dev/null" + AC_LINK_IFELSE( + [AC_LANG_SOURCE( + [AC_LANG_CASE([C], [[int foo (void) { return 0; }]], + [C++], [[int foo (void) { return 0; }]], + [Fortran 77], [[ + subroutine foo + end]], + [Fortran], [[ + subroutine foo + end]])])], + [lt_cv_irix_exported_symbol=yes], + [lt_cv_irix_exported_symbol=no]) + LDFLAGS="$save_LDFLAGS"]) + if test "$lt_cv_irix_exported_symbol" = yes; then + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations ${wl}-exports_file ${wl}$export_symbols -o $lib' + fi + else + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -exports_file $export_symbols -o $lib' + fi + _LT_TAGVAR(archive_cmds_need_lc, $1)='no' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' + _LT_TAGVAR(hardcode_libdir_separator, $1)=: + _LT_TAGVAR(inherit_rpath, $1)=yes + _LT_TAGVAR(link_all_deplibs, $1)=yes + ;; + + netbsd* | netbsdelf*-gnu) + if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then + _LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags' # a.out + else + _LT_TAGVAR(archive_cmds, $1)='$LD -shared -o $lib $libobjs $deplibs $linker_flags' # ELF + fi + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir' + _LT_TAGVAR(hardcode_direct, $1)=yes + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + ;; + + newsos6) + _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + _LT_TAGVAR(hardcode_direct, $1)=yes + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' + _LT_TAGVAR(hardcode_libdir_separator, $1)=: + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + ;; + + *nto* | *qnx*) + ;; + + openbsd*) + if test -f /usr/libexec/ld.so; then + _LT_TAGVAR(hardcode_direct, $1)=yes + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + _LT_TAGVAR(hardcode_direct_absolute, $1)=yes + if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags ${wl}-retain-symbols-file,$export_symbols' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir' + _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E' + else + case $host_os in + openbsd[[01]].* | openbsd2.[[0-7]] | openbsd2.[[0-7]].*) + _LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir' + ;; + *) + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir' + ;; + esac + fi + else + _LT_TAGVAR(ld_shlibs, $1)=no + fi + ;; + + os2*) + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' + _LT_TAGVAR(hardcode_minus_L, $1)=yes + _LT_TAGVAR(allow_undefined_flag, $1)=unsupported + _LT_TAGVAR(archive_cmds, $1)='$ECHO "LIBRARY $libname INITINSTANCE" > $output_objdir/$libname.def~$ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~echo DATA >> $output_objdir/$libname.def~echo " SINGLE NONSHARED" >> $output_objdir/$libname.def~echo EXPORTS >> $output_objdir/$libname.def~emxexp $libobjs >> $output_objdir/$libname.def~$CC -Zdll -Zcrtdll -o $lib $libobjs $deplibs $compiler_flags $output_objdir/$libname.def' + _LT_TAGVAR(old_archive_from_new_cmds, $1)='emximp -o $output_objdir/$libname.a $output_objdir/$libname.def' + ;; + + osf3*) + if test "$GCC" = yes; then + _LT_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*' + _LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' + else + _LT_TAGVAR(allow_undefined_flag, $1)=' -expect_unresolved \*' + _LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib' + fi + _LT_TAGVAR(archive_cmds_need_lc, $1)='no' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' + _LT_TAGVAR(hardcode_libdir_separator, $1)=: + ;; + + osf4* | osf5*) # as osf3* with the addition of -msym flag + if test "$GCC" = yes; then + _LT_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*' + _LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $pic_flag $libobjs $deplibs $compiler_flags ${wl}-msym ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' + else + _LT_TAGVAR(allow_undefined_flag, $1)=' -expect_unresolved \*' + _LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags -msym -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done; printf "%s\\n" "-hidden">> $lib.exp~ + $CC -shared${allow_undefined_flag} ${wl}-input ${wl}$lib.exp $compiler_flags $libobjs $deplibs -soname $soname `test -n "$verstring" && $ECHO "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib~$RM $lib.exp' + + # Both c and cxx compiler support -rpath directly + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-rpath $libdir' + fi + _LT_TAGVAR(archive_cmds_need_lc, $1)='no' + _LT_TAGVAR(hardcode_libdir_separator, $1)=: + ;; + + solaris*) + _LT_TAGVAR(no_undefined_flag, $1)=' -z defs' + if test "$GCC" = yes; then + wlarc='${wl}' + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag ${wl}-z ${wl}text ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags' + _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~ + $CC -shared $pic_flag ${wl}-z ${wl}text ${wl}-M ${wl}$lib.exp ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags~$RM $lib.exp' + else + case `$CC -V 2>&1` in + *"Compilers 5.0"*) + wlarc='' + _LT_TAGVAR(archive_cmds, $1)='$LD -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $linker_flags' + _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~ + $LD -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $linker_flags~$RM $lib.exp' + ;; + *) + wlarc='${wl}' + _LT_TAGVAR(archive_cmds, $1)='$CC -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $compiler_flags' + _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~ + $CC -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $compiler_flags~$RM $lib.exp' + ;; + esac + fi + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir' + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + case $host_os in + solaris2.[[0-5]] | solaris2.[[0-5]].*) ;; + *) + # The compiler driver will combine and reorder linker options, + # but understands `-z linker_flag'. GCC discards it without `$wl', + # but is careful enough not to reorder. + # Supported since Solaris 2.6 (maybe 2.5.1?) + if test "$GCC" = yes; then + _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}-z ${wl}allextract$convenience ${wl}-z ${wl}defaultextract' + else + _LT_TAGVAR(whole_archive_flag_spec, $1)='-z allextract$convenience -z defaultextract' + fi + ;; + esac + _LT_TAGVAR(link_all_deplibs, $1)=yes + ;; + + sunos4*) + if test "x$host_vendor" = xsequent; then + # Use $CC to link under sequent, because it throws in some extra .o + # files that make .init and .fini sections work. + _LT_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h $soname -o $lib $libobjs $deplibs $compiler_flags' + else + _LT_TAGVAR(archive_cmds, $1)='$LD -assert pure-text -Bstatic -o $lib $libobjs $deplibs $linker_flags' + fi + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' + _LT_TAGVAR(hardcode_direct, $1)=yes + _LT_TAGVAR(hardcode_minus_L, $1)=yes + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + ;; + + sysv4) + case $host_vendor in + sni) + _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + _LT_TAGVAR(hardcode_direct, $1)=yes # is this really true??? + ;; + siemens) + ## LD is ld it makes a PLAMLIB + ## CC just makes a GrossModule. + _LT_TAGVAR(archive_cmds, $1)='$LD -G -o $lib $libobjs $deplibs $linker_flags' + _LT_TAGVAR(reload_cmds, $1)='$CC -r -o $output$reload_objs' + _LT_TAGVAR(hardcode_direct, $1)=no + ;; + motorola) + _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + _LT_TAGVAR(hardcode_direct, $1)=no #Motorola manual says yes, but my tests say they lie + ;; + esac + runpath_var='LD_RUN_PATH' + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + ;; + + sysv4.3*) + _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + _LT_TAGVAR(export_dynamic_flag_spec, $1)='-Bexport' + ;; + + sysv4*MP*) + if test -d /usr/nec; then + _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + runpath_var=LD_RUN_PATH + hardcode_runpath_var=yes + _LT_TAGVAR(ld_shlibs, $1)=yes + fi + ;; + + sysv4*uw2* | sysv5OpenUNIX* | sysv5UnixWare7.[[01]].[[10]]* | unixware7* | sco3.2v5.0.[[024]]*) + _LT_TAGVAR(no_undefined_flag, $1)='${wl}-z,text' + _LT_TAGVAR(archive_cmds_need_lc, $1)=no + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + runpath_var='LD_RUN_PATH' + + if test "$GCC" = yes; then + _LT_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + else + _LT_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + fi + ;; + + sysv5* | sco3.2v5* | sco5v6*) + # Note: We can NOT use -z defs as we might desire, because we do not + # link with -lc, and that would cause any symbols used from libc to + # always be unresolved, which means just about no library would + # ever link correctly. If we're not using GNU ld we use -z text + # though, which does catch some bad symbols but isn't as heavy-handed + # as -z defs. + _LT_TAGVAR(no_undefined_flag, $1)='${wl}-z,text' + _LT_TAGVAR(allow_undefined_flag, $1)='${wl}-z,nodefs' + _LT_TAGVAR(archive_cmds_need_lc, $1)=no + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R,$libdir' + _LT_TAGVAR(hardcode_libdir_separator, $1)=':' + _LT_TAGVAR(link_all_deplibs, $1)=yes + _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-Bexport' + runpath_var='LD_RUN_PATH' + + if test "$GCC" = yes; then + _LT_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + else + _LT_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + fi + ;; + + uts4*) + _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + ;; + + *) + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + esac + + if test x$host_vendor = xsni; then + case $host in + sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*) + _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-Blargedynsym' + ;; + esac + fi + fi +]) +AC_MSG_RESULT([$_LT_TAGVAR(ld_shlibs, $1)]) +test "$_LT_TAGVAR(ld_shlibs, $1)" = no && can_build_shared=no + +_LT_TAGVAR(with_gnu_ld, $1)=$with_gnu_ld + +_LT_DECL([], [libext], [0], [Old archive suffix (normally "a")])dnl +_LT_DECL([], [shrext_cmds], [1], [Shared library suffix (normally ".so")])dnl +_LT_DECL([], [extract_expsyms_cmds], [2], + [The commands to extract the exported symbol list from a shared archive]) + +# +# Do we need to explicitly link libc? +# +case "x$_LT_TAGVAR(archive_cmds_need_lc, $1)" in +x|xyes) + # Assume -lc should be added + _LT_TAGVAR(archive_cmds_need_lc, $1)=yes + + if test "$enable_shared" = yes && test "$GCC" = yes; then + case $_LT_TAGVAR(archive_cmds, $1) in + *'~'*) + # FIXME: we may have to deal with multi-command sequences. + ;; + '$CC '*) + # Test whether the compiler implicitly links with -lc since on some + # systems, -lgcc has to come before -lc. If gcc already passes -lc + # to ld, don't add -lc before -lgcc. + AC_CACHE_CHECK([whether -lc should be explicitly linked in], + [lt_cv_]_LT_TAGVAR(archive_cmds_need_lc, $1), + [$RM conftest* + echo "$lt_simple_compile_test_code" > conftest.$ac_ext + + if AC_TRY_EVAL(ac_compile) 2>conftest.err; then + soname=conftest + lib=conftest + libobjs=conftest.$ac_objext + deplibs= + wl=$_LT_TAGVAR(lt_prog_compiler_wl, $1) + pic_flag=$_LT_TAGVAR(lt_prog_compiler_pic, $1) + compiler_flags=-v + linker_flags=-v + verstring= + output_objdir=. + libname=conftest + lt_save_allow_undefined_flag=$_LT_TAGVAR(allow_undefined_flag, $1) + _LT_TAGVAR(allow_undefined_flag, $1)= + if AC_TRY_EVAL(_LT_TAGVAR(archive_cmds, $1) 2\>\&1 \| $GREP \" -lc \" \>/dev/null 2\>\&1) + then + lt_cv_[]_LT_TAGVAR(archive_cmds_need_lc, $1)=no + else + lt_cv_[]_LT_TAGVAR(archive_cmds_need_lc, $1)=yes + fi + _LT_TAGVAR(allow_undefined_flag, $1)=$lt_save_allow_undefined_flag + else + cat conftest.err 1>&5 + fi + $RM conftest* + ]) + _LT_TAGVAR(archive_cmds_need_lc, $1)=$lt_cv_[]_LT_TAGVAR(archive_cmds_need_lc, $1) + ;; + esac + fi + ;; +esac + +_LT_TAGDECL([build_libtool_need_lc], [archive_cmds_need_lc], [0], + [Whether or not to add -lc for building shared libraries]) +_LT_TAGDECL([allow_libtool_libs_with_static_runtimes], + [enable_shared_with_static_runtimes], [0], + [Whether or not to disallow shared libs when runtime libs are static]) +_LT_TAGDECL([], [export_dynamic_flag_spec], [1], + [Compiler flag to allow reflexive dlopens]) +_LT_TAGDECL([], [whole_archive_flag_spec], [1], + [Compiler flag to generate shared objects directly from archives]) +_LT_TAGDECL([], [compiler_needs_object], [1], + [Whether the compiler copes with passing no objects directly]) +_LT_TAGDECL([], [old_archive_from_new_cmds], [2], + [Create an old-style archive from a shared archive]) +_LT_TAGDECL([], [old_archive_from_expsyms_cmds], [2], + [Create a temporary old-style archive to link instead of a shared archive]) +_LT_TAGDECL([], [archive_cmds], [2], [Commands used to build a shared archive]) +_LT_TAGDECL([], [archive_expsym_cmds], [2]) +_LT_TAGDECL([], [module_cmds], [2], + [Commands used to build a loadable module if different from building + a shared archive.]) +_LT_TAGDECL([], [module_expsym_cmds], [2]) +_LT_TAGDECL([], [with_gnu_ld], [1], + [Whether we are building with GNU ld or not]) +_LT_TAGDECL([], [allow_undefined_flag], [1], + [Flag that allows shared libraries with undefined symbols to be built]) +_LT_TAGDECL([], [no_undefined_flag], [1], + [Flag that enforces no undefined symbols]) +_LT_TAGDECL([], [hardcode_libdir_flag_spec], [1], + [Flag to hardcode $libdir into a binary during linking. + This must work even if $libdir does not exist]) +_LT_TAGDECL([], [hardcode_libdir_separator], [1], + [Whether we need a single "-rpath" flag with a separated argument]) +_LT_TAGDECL([], [hardcode_direct], [0], + [Set to "yes" if using DIR/libNAME${shared_ext} during linking hardcodes + DIR into the resulting binary]) +_LT_TAGDECL([], [hardcode_direct_absolute], [0], + [Set to "yes" if using DIR/libNAME${shared_ext} during linking hardcodes + DIR into the resulting binary and the resulting library dependency is + "absolute", i.e impossible to change by setting ${shlibpath_var} if the + library is relocated]) +_LT_TAGDECL([], [hardcode_minus_L], [0], + [Set to "yes" if using the -LDIR flag during linking hardcodes DIR + into the resulting binary]) +_LT_TAGDECL([], [hardcode_shlibpath_var], [0], + [Set to "yes" if using SHLIBPATH_VAR=DIR during linking hardcodes DIR + into the resulting binary]) +_LT_TAGDECL([], [hardcode_automatic], [0], + [Set to "yes" if building a shared library automatically hardcodes DIR + into the library and all subsequent libraries and executables linked + against it]) +_LT_TAGDECL([], [inherit_rpath], [0], + [Set to yes if linker adds runtime paths of dependent libraries + to runtime path list]) +_LT_TAGDECL([], [link_all_deplibs], [0], + [Whether libtool must link a program against all its dependency libraries]) +_LT_TAGDECL([], [always_export_symbols], [0], + [Set to "yes" if exported symbols are required]) +_LT_TAGDECL([], [export_symbols_cmds], [2], + [The commands to list exported symbols]) +_LT_TAGDECL([], [exclude_expsyms], [1], + [Symbols that should not be listed in the preloaded symbols]) +_LT_TAGDECL([], [include_expsyms], [1], + [Symbols that must always be exported]) +_LT_TAGDECL([], [prelink_cmds], [2], + [Commands necessary for linking programs (against libraries) with templates]) +_LT_TAGDECL([], [postlink_cmds], [2], + [Commands necessary for finishing linking programs]) +_LT_TAGDECL([], [file_list_spec], [1], + [Specify filename containing input files]) +dnl FIXME: Not yet implemented +dnl _LT_TAGDECL([], [thread_safe_flag_spec], [1], +dnl [Compiler flag to generate thread safe objects]) +])# _LT_LINKER_SHLIBS + + +# _LT_LANG_C_CONFIG([TAG]) +# ------------------------ +# Ensure that the configuration variables for a C compiler are suitably +# defined. These variables are subsequently used by _LT_CONFIG to write +# the compiler configuration to `libtool'. +m4_defun([_LT_LANG_C_CONFIG], +[m4_require([_LT_DECL_EGREP])dnl +lt_save_CC="$CC" +AC_LANG_PUSH(C) + +# Source file extension for C test sources. +ac_ext=c + +# Object file extension for compiled C test sources. +objext=o +_LT_TAGVAR(objext, $1)=$objext + +# Code to be used in simple compile tests +lt_simple_compile_test_code="int some_variable = 0;" + +# Code to be used in simple link tests +lt_simple_link_test_code='int main(){return(0);}' + +_LT_TAG_COMPILER +# Save the default compiler, since it gets overwritten when the other +# tags are being tested, and _LT_TAGVAR(compiler, []) is a NOP. +compiler_DEFAULT=$CC + +# save warnings/boilerplate of simple test code +_LT_COMPILER_BOILERPLATE +_LT_LINKER_BOILERPLATE + +## CAVEAT EMPTOR: +## There is no encapsulation within the following macros, do not change +## the running order or otherwise move them around unless you know exactly +## what you are doing... +if test -n "$compiler"; then + _LT_COMPILER_NO_RTTI($1) + _LT_COMPILER_PIC($1) + _LT_COMPILER_C_O($1) + _LT_COMPILER_FILE_LOCKS($1) + _LT_LINKER_SHLIBS($1) + _LT_SYS_DYNAMIC_LINKER($1) + _LT_LINKER_HARDCODE_LIBPATH($1) + LT_SYS_DLOPEN_SELF + _LT_CMD_STRIPLIB + + # Report which library types will actually be built + AC_MSG_CHECKING([if libtool supports shared libraries]) + AC_MSG_RESULT([$can_build_shared]) + + AC_MSG_CHECKING([whether to build shared libraries]) + test "$can_build_shared" = "no" && enable_shared=no + + # On AIX, shared libraries and static libraries use the same namespace, and + # are all built from PIC. + case $host_os in + aix3*) + test "$enable_shared" = yes && enable_static=no + if test -n "$RANLIB"; then + archive_cmds="$archive_cmds~\$RANLIB \$lib" + postinstall_cmds='$RANLIB $lib' + fi + ;; + + aix[[4-9]]*) + if test "$host_cpu" != ia64 && test "$aix_use_runtimelinking" = no ; then + test "$enable_shared" = yes && enable_static=no + fi + ;; + esac + AC_MSG_RESULT([$enable_shared]) + + AC_MSG_CHECKING([whether to build static libraries]) + # Make sure either enable_shared or enable_static is yes. + test "$enable_shared" = yes || enable_static=yes + AC_MSG_RESULT([$enable_static]) + + _LT_CONFIG($1) +fi +AC_LANG_POP +CC="$lt_save_CC" +])# _LT_LANG_C_CONFIG + + +# _LT_LANG_CXX_CONFIG([TAG]) +# -------------------------- +# Ensure that the configuration variables for a C++ compiler are suitably +# defined. These variables are subsequently used by _LT_CONFIG to write +# the compiler configuration to `libtool'. +m4_defun([_LT_LANG_CXX_CONFIG], +[m4_require([_LT_FILEUTILS_DEFAULTS])dnl +m4_require([_LT_DECL_EGREP])dnl +m4_require([_LT_PATH_MANIFEST_TOOL])dnl +if test -n "$CXX" && ( test "X$CXX" != "Xno" && + ( (test "X$CXX" = "Xg++" && `g++ -v >/dev/null 2>&1` ) || + (test "X$CXX" != "Xg++"))) ; then + AC_PROG_CXXCPP +else + _lt_caught_CXX_error=yes +fi + +AC_LANG_PUSH(C++) +_LT_TAGVAR(archive_cmds_need_lc, $1)=no +_LT_TAGVAR(allow_undefined_flag, $1)= +_LT_TAGVAR(always_export_symbols, $1)=no +_LT_TAGVAR(archive_expsym_cmds, $1)= +_LT_TAGVAR(compiler_needs_object, $1)=no +_LT_TAGVAR(export_dynamic_flag_spec, $1)= +_LT_TAGVAR(hardcode_direct, $1)=no +_LT_TAGVAR(hardcode_direct_absolute, $1)=no +_LT_TAGVAR(hardcode_libdir_flag_spec, $1)= +_LT_TAGVAR(hardcode_libdir_separator, $1)= +_LT_TAGVAR(hardcode_minus_L, $1)=no +_LT_TAGVAR(hardcode_shlibpath_var, $1)=unsupported +_LT_TAGVAR(hardcode_automatic, $1)=no +_LT_TAGVAR(inherit_rpath, $1)=no +_LT_TAGVAR(module_cmds, $1)= +_LT_TAGVAR(module_expsym_cmds, $1)= +_LT_TAGVAR(link_all_deplibs, $1)=unknown +_LT_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds +_LT_TAGVAR(reload_flag, $1)=$reload_flag +_LT_TAGVAR(reload_cmds, $1)=$reload_cmds +_LT_TAGVAR(no_undefined_flag, $1)= +_LT_TAGVAR(whole_archive_flag_spec, $1)= +_LT_TAGVAR(enable_shared_with_static_runtimes, $1)=no + +# Source file extension for C++ test sources. +ac_ext=cpp + +# Object file extension for compiled C++ test sources. +objext=o +_LT_TAGVAR(objext, $1)=$objext + +# No sense in running all these tests if we already determined that +# the CXX compiler isn't working. Some variables (like enable_shared) +# are currently assumed to apply to all compilers on this platform, +# and will be corrupted by setting them based on a non-working compiler. +if test "$_lt_caught_CXX_error" != yes; then + # Code to be used in simple compile tests + lt_simple_compile_test_code="int some_variable = 0;" + + # Code to be used in simple link tests + lt_simple_link_test_code='int main(int, char *[[]]) { return(0); }' + + # ltmain only uses $CC for tagged configurations so make sure $CC is set. + _LT_TAG_COMPILER + + # save warnings/boilerplate of simple test code + _LT_COMPILER_BOILERPLATE + _LT_LINKER_BOILERPLATE + + # Allow CC to be a program name with arguments. + lt_save_CC=$CC + lt_save_CFLAGS=$CFLAGS + lt_save_LD=$LD + lt_save_GCC=$GCC + GCC=$GXX + lt_save_with_gnu_ld=$with_gnu_ld + lt_save_path_LD=$lt_cv_path_LD + if test -n "${lt_cv_prog_gnu_ldcxx+set}"; then + lt_cv_prog_gnu_ld=$lt_cv_prog_gnu_ldcxx + else + $as_unset lt_cv_prog_gnu_ld + fi + if test -n "${lt_cv_path_LDCXX+set}"; then + lt_cv_path_LD=$lt_cv_path_LDCXX + else + $as_unset lt_cv_path_LD + fi + test -z "${LDCXX+set}" || LD=$LDCXX + CC=${CXX-"c++"} + CFLAGS=$CXXFLAGS + compiler=$CC + _LT_TAGVAR(compiler, $1)=$CC + _LT_CC_BASENAME([$compiler]) + + if test -n "$compiler"; then + # We don't want -fno-exception when compiling C++ code, so set the + # no_builtin_flag separately + if test "$GXX" = yes; then + _LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=' -fno-builtin' + else + _LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)= + fi + + if test "$GXX" = yes; then + # Set up default GNU C++ configuration + + LT_PATH_LD + + # Check if GNU C++ uses GNU ld as the underlying linker, since the + # archiving commands below assume that GNU ld is being used. + if test "$with_gnu_ld" = yes; then + _LT_TAGVAR(archive_cmds, $1)='$CC $pic_flag -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC $pic_flag -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' + _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic' + + # If archive_cmds runs LD, not CC, wlarc should be empty + # XXX I think wlarc can be eliminated in ltcf-cxx, but I need to + # investigate it a little bit more. (MM) + wlarc='${wl}' + + # ancient GNU ld didn't support --whole-archive et. al. + if eval "`$CC -print-prog-name=ld` --help 2>&1" | + $GREP 'no-whole-archive' > /dev/null; then + _LT_TAGVAR(whole_archive_flag_spec, $1)="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive' + else + _LT_TAGVAR(whole_archive_flag_spec, $1)= + fi + else + with_gnu_ld=no + wlarc= + + # A generic and very simple default shared library creation + # command for GNU C++ for the case where it uses the native + # linker, instead of GNU ld. If possible, this setting should + # overridden to take advantage of the native linker features on + # the platform it is being used on. + _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $lib' + fi + + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"' + + else + GXX=no + with_gnu_ld=no + wlarc= + fi + + # PORTME: fill in a description of your system's C++ link characteristics + AC_MSG_CHECKING([whether the $compiler linker ($LD) supports shared libraries]) + _LT_TAGVAR(ld_shlibs, $1)=yes + case $host_os in + aix3*) + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + aix[[4-9]]*) + if test "$host_cpu" = ia64; then + # On IA64, the linker does run time linking by default, so we don't + # have to do anything special. + aix_use_runtimelinking=no + exp_sym_flag='-Bexport' + no_entry_flag="" + else + aix_use_runtimelinking=no + + # Test if we are trying to use run time linking or normal + # AIX style linking. If -brtl is somewhere in LDFLAGS, we + # need to do runtime linking. + case $host_os in aix4.[[23]]|aix4.[[23]].*|aix[[5-9]]*) + for ld_flag in $LDFLAGS; do + case $ld_flag in + *-brtl*) + aix_use_runtimelinking=yes + break + ;; + esac + done + ;; + esac + + exp_sym_flag='-bexport' + no_entry_flag='-bnoentry' + fi + + # When large executables or shared objects are built, AIX ld can + # have problems creating the table of contents. If linking a library + # or program results in "error TOC overflow" add -mminimal-toc to + # CXXFLAGS/CFLAGS for g++/gcc. In the cases where that is not + # enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS. + + _LT_TAGVAR(archive_cmds, $1)='' + _LT_TAGVAR(hardcode_direct, $1)=yes + _LT_TAGVAR(hardcode_direct_absolute, $1)=yes + _LT_TAGVAR(hardcode_libdir_separator, $1)=':' + _LT_TAGVAR(link_all_deplibs, $1)=yes + _LT_TAGVAR(file_list_spec, $1)='${wl}-f,' + + if test "$GXX" = yes; then + case $host_os in aix4.[[012]]|aix4.[[012]].*) + # We only want to do this on AIX 4.2 and lower, the check + # below for broken collect2 doesn't work under 4.3+ + collect2name=`${CC} -print-prog-name=collect2` + if test -f "$collect2name" && + strings "$collect2name" | $GREP resolve_lib_name >/dev/null + then + # We have reworked collect2 + : + else + # We have old collect2 + _LT_TAGVAR(hardcode_direct, $1)=unsupported + # It fails to find uninstalled libraries when the uninstalled + # path is not listed in the libpath. Setting hardcode_minus_L + # to unsupported forces relinking + _LT_TAGVAR(hardcode_minus_L, $1)=yes + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' + _LT_TAGVAR(hardcode_libdir_separator, $1)= + fi + esac + shared_flag='-shared' + if test "$aix_use_runtimelinking" = yes; then + shared_flag="$shared_flag "'${wl}-G' + fi + else + # not using gcc + if test "$host_cpu" = ia64; then + # VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release + # chokes on -Wl,-G. The following line is correct: + shared_flag='-G' + else + if test "$aix_use_runtimelinking" = yes; then + shared_flag='${wl}-G' + else + shared_flag='${wl}-bM:SRE' + fi + fi + fi + + _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-bexpall' + # It seems that -bexpall does not export symbols beginning with + # underscore (_), so it is better to generate a list of symbols to + # export. + _LT_TAGVAR(always_export_symbols, $1)=yes + if test "$aix_use_runtimelinking" = yes; then + # Warning - without using the other runtime loading flags (-brtl), + # -berok will link without error, but may produce a broken library. + _LT_TAGVAR(allow_undefined_flag, $1)='-berok' + # Determine the default libpath from the value encoded in an empty + # executable. + _LT_SYS_MODULE_PATH_AIX([$1]) + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-blibpath:$libdir:'"$aix_libpath" + + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then func_echo_all "${wl}${allow_undefined_flag}"; else :; fi` '"\${wl}$exp_sym_flag:\$export_symbols $shared_flag" + else + if test "$host_cpu" = ia64; then + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R $libdir:/usr/lib:/lib' + _LT_TAGVAR(allow_undefined_flag, $1)="-z nodefs" + _LT_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$exp_sym_flag:\$export_symbols" + else + # Determine the default libpath from the value encoded in an + # empty executable. + _LT_SYS_MODULE_PATH_AIX([$1]) + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-blibpath:$libdir:'"$aix_libpath" + # Warning - without using the other run time loading flags, + # -berok will link without error, but may produce a broken library. + _LT_TAGVAR(no_undefined_flag, $1)=' ${wl}-bernotok' + _LT_TAGVAR(allow_undefined_flag, $1)=' ${wl}-berok' + if test "$with_gnu_ld" = yes; then + # We only use this code for GNU lds that support --whole-archive. + _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive$convenience ${wl}--no-whole-archive' + else + # Exported symbols can be pulled into shared objects from archives + _LT_TAGVAR(whole_archive_flag_spec, $1)='$convenience' + fi + _LT_TAGVAR(archive_cmds_need_lc, $1)=yes + # This is similar to how AIX traditionally builds its shared + # libraries. + _LT_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs ${wl}-bnoentry $compiler_flags ${wl}-bE:$export_symbols${allow_undefined_flag}~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$soname' + fi + fi + ;; + + beos*) + if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then + _LT_TAGVAR(allow_undefined_flag, $1)=unsupported + # Joseph Beckenbach says some releases of gcc + # support --undefined. This deserves some investigation. FIXME + _LT_TAGVAR(archive_cmds, $1)='$CC -nostart $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + else + _LT_TAGVAR(ld_shlibs, $1)=no + fi + ;; + + chorus*) + case $cc_basename in + *) + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + esac + ;; + + cygwin* | mingw* | pw32* | cegcc*) + case $GXX,$cc_basename in + ,cl* | no,cl*) + # Native MSVC + # hardcode_libdir_flag_spec is actually meaningless, as there is + # no search path for DLLs. + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)=' ' + _LT_TAGVAR(allow_undefined_flag, $1)=unsupported + _LT_TAGVAR(always_export_symbols, $1)=yes + _LT_TAGVAR(file_list_spec, $1)='@' + # Tell ltmain to make .lib files, not .a files. + libext=lib + # Tell ltmain to make .dll files, not .so files. + shrext_cmds=".dll" + # FIXME: Setting linknames here is a bad hack. + _LT_TAGVAR(archive_cmds, $1)='$CC -o $output_objdir/$soname $libobjs $compiler_flags $deplibs -Wl,-dll~linknames=' + _LT_TAGVAR(archive_expsym_cmds, $1)='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then + $SED -n -e 's/\\\\\\\(.*\\\\\\\)/-link\\\ -EXPORT:\\\\\\\1/' -e '1\\\!p' < $export_symbols > $output_objdir/$soname.exp; + else + $SED -e 's/\\\\\\\(.*\\\\\\\)/-link\\\ -EXPORT:\\\\\\\1/' < $export_symbols > $output_objdir/$soname.exp; + fi~ + $CC -o $tool_output_objdir$soname $libobjs $compiler_flags $deplibs "@$tool_output_objdir$soname.exp" -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~ + linknames=' + # The linker will not automatically build a static lib if we build a DLL. + # _LT_TAGVAR(old_archive_from_new_cmds, $1)='true' + _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes + # Don't use ranlib + _LT_TAGVAR(old_postinstall_cmds, $1)='chmod 644 $oldlib' + _LT_TAGVAR(postlink_cmds, $1)='lt_outputfile="@OUTPUT@"~ + lt_tool_outputfile="@TOOL_OUTPUT@"~ + case $lt_outputfile in + *.exe|*.EXE) ;; + *) + lt_outputfile="$lt_outputfile.exe" + lt_tool_outputfile="$lt_tool_outputfile.exe" + ;; + esac~ + func_to_tool_file "$lt_outputfile"~ + if test "$MANIFEST_TOOL" != ":" && test -f "$lt_outputfile.manifest"; then + $MANIFEST_TOOL -manifest "$lt_tool_outputfile.manifest" -outputresource:"$lt_tool_outputfile" || exit 1; + $RM "$lt_outputfile.manifest"; + fi' + ;; + *) + # g++ + # _LT_TAGVAR(hardcode_libdir_flag_spec, $1) is actually meaningless, + # as there is no search path for DLLs. + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' + _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-all-symbols' + _LT_TAGVAR(allow_undefined_flag, $1)=unsupported + _LT_TAGVAR(always_export_symbols, $1)=no + _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes + + if $LD --help 2>&1 | $GREP 'auto-import' > /dev/null; then + _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib' + # If the export-symbols file already is a .def file (1st line + # is EXPORTS), use it as is; otherwise, prepend... + _LT_TAGVAR(archive_expsym_cmds, $1)='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then + cp $export_symbols $output_objdir/$soname.def; + else + echo EXPORTS > $output_objdir/$soname.def; + cat $export_symbols >> $output_objdir/$soname.def; + fi~ + $CC -shared -nostdlib $output_objdir/$soname.def $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib' + else + _LT_TAGVAR(ld_shlibs, $1)=no + fi + ;; + esac + ;; + darwin* | rhapsody*) + _LT_DARWIN_LINKER_FEATURES($1) + ;; + + dgux*) + case $cc_basename in + ec++*) + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + ghcx*) + # Green Hills C++ Compiler + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + *) + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + esac + ;; + + freebsd2.*) + # C++ shared libraries reported to be fairly broken before + # switch to ELF + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + + freebsd-elf*) + _LT_TAGVAR(archive_cmds_need_lc, $1)=no + ;; + + freebsd* | dragonfly*) + # FreeBSD 3 and later use GNU C++ and GNU ld with standard ELF + # conventions + _LT_TAGVAR(ld_shlibs, $1)=yes + ;; + + haiku*) + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + _LT_TAGVAR(link_all_deplibs, $1)=yes + ;; + + hpux9*) + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir' + _LT_TAGVAR(hardcode_libdir_separator, $1)=: + _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E' + _LT_TAGVAR(hardcode_direct, $1)=yes + _LT_TAGVAR(hardcode_minus_L, $1)=yes # Not in the search PATH, + # but as the default + # location of the library. + + case $cc_basename in + CC*) + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + aCC*) + _LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/$soname~$CC -b ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib' + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + # + # There doesn't appear to be a way to prevent this compiler from + # explicitly linking system object files so we need to strip them + # from the output so that they don't get included in the library + # dependencies. + output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | $EGREP "\-L"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"' + ;; + *) + if test "$GXX" = yes; then + _LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/$soname~$CC -shared -nostdlib $pic_flag ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib' + else + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + fi + ;; + esac + ;; + + hpux10*|hpux11*) + if test $with_gnu_ld = no; then + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir' + _LT_TAGVAR(hardcode_libdir_separator, $1)=: + + case $host_cpu in + hppa*64*|ia64*) + ;; + *) + _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E' + ;; + esac + fi + case $host_cpu in + hppa*64*|ia64*) + _LT_TAGVAR(hardcode_direct, $1)=no + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + ;; + *) + _LT_TAGVAR(hardcode_direct, $1)=yes + _LT_TAGVAR(hardcode_direct_absolute, $1)=yes + _LT_TAGVAR(hardcode_minus_L, $1)=yes # Not in the search PATH, + # but as the default + # location of the library. + ;; + esac + + case $cc_basename in + CC*) + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + aCC*) + case $host_cpu in + hppa*64*) + _LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' + ;; + ia64*) + _LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' + ;; + *) + _LT_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' + ;; + esac + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + # + # There doesn't appear to be a way to prevent this compiler from + # explicitly linking system object files so we need to strip them + # from the output so that they don't get included in the library + # dependencies. + output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | $GREP "\-L"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"' + ;; + *) + if test "$GXX" = yes; then + if test $with_gnu_ld = no; then + case $host_cpu in + hppa*64*) + _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib -fPIC ${wl}+h ${wl}$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' + ;; + ia64*) + _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $pic_flag ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' + ;; + *) + _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $pic_flag ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' + ;; + esac + fi + else + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + fi + ;; + esac + ;; + + interix[[3-9]]*) + _LT_TAGVAR(hardcode_direct, $1)=no + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir' + _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E' + # Hack: On Interix 3.x, we cannot compile PIC because of a broken gcc. + # Instead, shared libraries are loaded at an image base (0x10000000 by + # default) and relocated if they conflict, which is a slow very memory + # consuming and fragmenting process. To avoid this, we pick a random, + # 256 KiB-aligned image base between 0x50000000 and 0x6FFC0000 at link + # time. Moving up from 0x10000000 also allows more sbrk(2) space. + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='sed "s,^,_," $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--retain-symbols-file,$output_objdir/$soname.expsym ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib' + ;; + irix5* | irix6*) + case $cc_basename in + CC*) + # SGI C++ + _LT_TAGVAR(archive_cmds, $1)='$CC -shared -all -multigot $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib' + + # Archives containing C++ object files must be created using + # "CC -ar", where "CC" is the IRIX C++ compiler. This is + # necessary to make sure instantiated templates are included + # in the archive. + _LT_TAGVAR(old_archive_cmds, $1)='$CC -ar -WR,-u -o $oldlib $oldobjs' + ;; + *) + if test "$GXX" = yes; then + if test "$with_gnu_ld" = no; then + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' + else + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` -o $lib' + fi + fi + _LT_TAGVAR(link_all_deplibs, $1)=yes + ;; + esac + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' + _LT_TAGVAR(hardcode_libdir_separator, $1)=: + _LT_TAGVAR(inherit_rpath, $1)=yes + ;; + + linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*) + case $cc_basename in + KCC*) + # Kuck and Associates, Inc. (KAI) C++ Compiler + + # KCC will only create a shared library if the output file + # ends with ".so" (or ".sl" for HP-UX), so rename the library + # to its proper name (with version) after linking. + _LT_TAGVAR(archive_cmds, $1)='tempext=`echo $shared_ext | $SED -e '\''s/\([[^()0-9A-Za-z{}]]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='tempext=`echo $shared_ext | $SED -e '\''s/\([[^()0-9A-Za-z{}]]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib ${wl}-retain-symbols-file,$export_symbols; mv \$templib $lib' + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + # + # There doesn't appear to be a way to prevent this compiler from + # explicitly linking system object files so we need to strip them + # from the output so that they don't get included in the library + # dependencies. + output_verbose_link_cmd='templist=`$CC $CFLAGS -v conftest.$objext -o libconftest$shared_ext 2>&1 | $GREP "ld"`; rm -f libconftest$shared_ext; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"' + + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir' + _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic' + + # Archives containing C++ object files must be created using + # "CC -Bstatic", where "CC" is the KAI C++ compiler. + _LT_TAGVAR(old_archive_cmds, $1)='$CC -Bstatic -o $oldlib $oldobjs' + ;; + icpc* | ecpc* ) + # Intel C++ + with_gnu_ld=yes + # version 8.0 and above of icpc choke on multiply defined symbols + # if we add $predep_objects and $postdep_objects, however 7.1 and + # earlier do not add the objects themselves. + case `$CC -V 2>&1` in + *"Version 7."*) + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + ;; + *) # Version 8.0 or newer + tmp_idyn= + case $host_cpu in + ia64*) tmp_idyn=' -i_dynamic';; + esac + _LT_TAGVAR(archive_cmds, $1)='$CC -shared'"$tmp_idyn"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared'"$tmp_idyn"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib' + ;; + esac + _LT_TAGVAR(archive_cmds_need_lc, $1)=no + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir' + _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic' + _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive$convenience ${wl}--no-whole-archive' + ;; + pgCC* | pgcpp*) + # Portland Group C++ compiler + case `$CC -V` in + *pgCC\ [[1-5]].* | *pgcpp\ [[1-5]].*) + _LT_TAGVAR(prelink_cmds, $1)='tpldir=Template.dir~ + rm -rf $tpldir~ + $CC --prelink_objects --instantiation_dir $tpldir $objs $libobjs $compile_deplibs~ + compile_command="$compile_command `find $tpldir -name \*.o | sort | $NL2SP`"' + _LT_TAGVAR(old_archive_cmds, $1)='tpldir=Template.dir~ + rm -rf $tpldir~ + $CC --prelink_objects --instantiation_dir $tpldir $oldobjs$old_deplibs~ + $AR $AR_FLAGS $oldlib$oldobjs$old_deplibs `find $tpldir -name \*.o | sort | $NL2SP`~ + $RANLIB $oldlib' + _LT_TAGVAR(archive_cmds, $1)='tpldir=Template.dir~ + rm -rf $tpldir~ + $CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~ + $CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | sort | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='tpldir=Template.dir~ + rm -rf $tpldir~ + $CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~ + $CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | sort | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname ${wl}-retain-symbols-file ${wl}$export_symbols -o $lib' + ;; + *) # Version 6 and above use weak symbols + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname ${wl}-retain-symbols-file ${wl}$export_symbols -o $lib' + ;; + esac + + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}--rpath ${wl}$libdir' + _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic' + _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive' + ;; + cxx*) + # Compaq C++ + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib ${wl}-retain-symbols-file $wl$export_symbols' + + runpath_var=LD_RUN_PATH + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-rpath $libdir' + _LT_TAGVAR(hardcode_libdir_separator, $1)=: + + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + # + # There doesn't appear to be a way to prevent this compiler from + # explicitly linking system object files so we need to strip them + # from the output so that they don't get included in the library + # dependencies. + output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "ld"`; templist=`func_echo_all "$templist" | $SED "s/\(^.*ld.*\)\( .*ld .*$\)/\1/"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "X$list" | $Xsed' + ;; + xl* | mpixl* | bgxl*) + # IBM XL 8.0 on PPC, with GNU ld + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' + _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic' + _LT_TAGVAR(archive_cmds, $1)='$CC -qmkshrobj $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib' + if test "x$supports_anon_versioning" = xyes; then + _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $output_objdir/$libname.ver~ + cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~ + echo "local: *; };" >> $output_objdir/$libname.ver~ + $CC -qmkshrobj $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-version-script ${wl}$output_objdir/$libname.ver -o $lib' + fi + ;; + *) + case `$CC -V 2>&1 | sed 5q` in + *Sun\ C*) + # Sun C++ 5.9 + _LT_TAGVAR(no_undefined_flag, $1)=' -zdefs' + _LT_TAGVAR(archive_cmds, $1)='$CC -G${allow_undefined_flag} -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G${allow_undefined_flag} -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-retain-symbols-file ${wl}$export_symbols' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir' + _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`new_convenience=; for conv in $convenience\"\"; do test -z \"$conv\" || new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` ${wl}--no-whole-archive' + _LT_TAGVAR(compiler_needs_object, $1)=yes + + # Not sure whether something based on + # $CC $CFLAGS -v conftest.$objext -o libconftest$shared_ext 2>&1 + # would be better. + output_verbose_link_cmd='func_echo_all' + + # Archives containing C++ object files must be created using + # "CC -xar", where "CC" is the Sun C++ compiler. This is + # necessary to make sure instantiated templates are included + # in the archive. + _LT_TAGVAR(old_archive_cmds, $1)='$CC -xar -o $oldlib $oldobjs' + ;; + esac + ;; + esac + ;; + + lynxos*) + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + + m88k*) + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + + mvs*) + case $cc_basename in + cxx*) + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + *) + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + esac + ;; + + netbsd*) + if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then + _LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $predep_objects $libobjs $deplibs $postdep_objects $linker_flags' + wlarc= + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir' + _LT_TAGVAR(hardcode_direct, $1)=yes + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + fi + # Workaround some broken pre-1.5 toolchains + output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP conftest.$objext | $SED -e "s:-lgcc -lc -lgcc::"' + ;; + + *nto* | *qnx*) + _LT_TAGVAR(ld_shlibs, $1)=yes + ;; + + openbsd2*) + # C++ shared libraries are fairly broken + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + + openbsd*) + if test -f /usr/libexec/ld.so; then + _LT_TAGVAR(hardcode_direct, $1)=yes + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + _LT_TAGVAR(hardcode_direct_absolute, $1)=yes + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $lib' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir' + if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-retain-symbols-file,$export_symbols -o $lib' + _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E' + _LT_TAGVAR(whole_archive_flag_spec, $1)="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive' + fi + output_verbose_link_cmd=func_echo_all + else + _LT_TAGVAR(ld_shlibs, $1)=no + fi + ;; + + osf3* | osf4* | osf5*) + case $cc_basename in + KCC*) + # Kuck and Associates, Inc. (KAI) C++ Compiler + + # KCC will only create a shared library if the output file + # ends with ".so" (or ".sl" for HP-UX), so rename the library + # to its proper name (with version) after linking. + _LT_TAGVAR(archive_cmds, $1)='tempext=`echo $shared_ext | $SED -e '\''s/\([[^()0-9A-Za-z{}]]\)/\\\\\1/g'\''`; templib=`echo "$lib" | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib' + + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir' + _LT_TAGVAR(hardcode_libdir_separator, $1)=: + + # Archives containing C++ object files must be created using + # the KAI C++ compiler. + case $host in + osf3*) _LT_TAGVAR(old_archive_cmds, $1)='$CC -Bstatic -o $oldlib $oldobjs' ;; + *) _LT_TAGVAR(old_archive_cmds, $1)='$CC -o $oldlib $oldobjs' ;; + esac + ;; + RCC*) + # Rational C++ 2.4.1 + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + cxx*) + case $host in + osf3*) + _LT_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*' + _LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $soname `test -n "$verstring" && func_echo_all "${wl}-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' + ;; + *) + _LT_TAGVAR(allow_undefined_flag, $1)=' -expect_unresolved \*' + _LT_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done~ + echo "-hidden">> $lib.exp~ + $CC -shared$allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname ${wl}-input ${wl}$lib.exp `test -n "$verstring" && $ECHO "-set_version $verstring"` -update_registry ${output_objdir}/so_locations -o $lib~ + $RM $lib.exp' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-rpath $libdir' + ;; + esac + + _LT_TAGVAR(hardcode_libdir_separator, $1)=: + + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + # + # There doesn't appear to be a way to prevent this compiler from + # explicitly linking system object files so we need to strip them + # from the output so that they don't get included in the library + # dependencies. + output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "ld" | $GREP -v "ld:"`; templist=`func_echo_all "$templist" | $SED "s/\(^.*ld.*\)\( .*ld.*$\)/\1/"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"' + ;; + *) + if test "$GXX" = yes && test "$with_gnu_ld" = no; then + _LT_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*' + case $host in + osf3*) + _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib ${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' + ;; + *) + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -nostdlib ${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-msym ${wl}-soname ${wl}$soname `test -n "$verstring" && func_echo_all "${wl}-set_version ${wl}$verstring"` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib' + ;; + esac + + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir' + _LT_TAGVAR(hardcode_libdir_separator, $1)=: + + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"' + + else + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + fi + ;; + esac + ;; + + psos*) + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + + sunos4*) + case $cc_basename in + CC*) + # Sun C++ 4.x + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + lcc*) + # Lucid + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + *) + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + esac + ;; + + solaris*) + case $cc_basename in + CC* | sunCC*) + # Sun C++ 4.2, 5.x and Centerline C++ + _LT_TAGVAR(archive_cmds_need_lc,$1)=yes + _LT_TAGVAR(no_undefined_flag, $1)=' -zdefs' + _LT_TAGVAR(archive_cmds, $1)='$CC -G${allow_undefined_flag} -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' + _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~ + $CC -G${allow_undefined_flag} ${wl}-M ${wl}$lib.exp -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp' + + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir' + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + case $host_os in + solaris2.[[0-5]] | solaris2.[[0-5]].*) ;; + *) + # The compiler driver will combine and reorder linker options, + # but understands `-z linker_flag'. + # Supported since Solaris 2.6 (maybe 2.5.1?) + _LT_TAGVAR(whole_archive_flag_spec, $1)='-z allextract$convenience -z defaultextract' + ;; + esac + _LT_TAGVAR(link_all_deplibs, $1)=yes + + output_verbose_link_cmd='func_echo_all' + + # Archives containing C++ object files must be created using + # "CC -xar", where "CC" is the Sun C++ compiler. This is + # necessary to make sure instantiated templates are included + # in the archive. + _LT_TAGVAR(old_archive_cmds, $1)='$CC -xar -o $oldlib $oldobjs' + ;; + gcx*) + # Green Hills C++ Compiler + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib' + + # The C++ compiler must be used to create the archive. + _LT_TAGVAR(old_archive_cmds, $1)='$CC $LDFLAGS -archive -o $oldlib $oldobjs' + ;; + *) + # GNU C++ compiler with Solaris linker + if test "$GXX" = yes && test "$with_gnu_ld" = no; then + _LT_TAGVAR(no_undefined_flag, $1)=' ${wl}-z ${wl}defs' + if $CC --version | $GREP -v '^2\.7' > /dev/null; then + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -nostdlib $LDFLAGS $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~ + $CC -shared $pic_flag -nostdlib ${wl}-M $wl$lib.exp -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp' + + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"' + else + # g++ 2.7 appears to require `-G' NOT `-shared' on this + # platform. + _LT_TAGVAR(archive_cmds, $1)='$CC -G -nostdlib $LDFLAGS $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~ + $CC -G -nostdlib ${wl}-M $wl$lib.exp -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp' + + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + output_verbose_link_cmd='$CC -G $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"' + fi + + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R $wl$libdir' + case $host_os in + solaris2.[[0-5]] | solaris2.[[0-5]].*) ;; + *) + _LT_TAGVAR(whole_archive_flag_spec, $1)='${wl}-z ${wl}allextract$convenience ${wl}-z ${wl}defaultextract' + ;; + esac + fi + ;; + esac + ;; + + sysv4*uw2* | sysv5OpenUNIX* | sysv5UnixWare7.[[01]].[[10]]* | unixware7* | sco3.2v5.0.[[024]]*) + _LT_TAGVAR(no_undefined_flag, $1)='${wl}-z,text' + _LT_TAGVAR(archive_cmds_need_lc, $1)=no + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + runpath_var='LD_RUN_PATH' + + case $cc_basename in + CC*) + _LT_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + ;; + *) + _LT_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + ;; + esac + ;; + + sysv5* | sco3.2v5* | sco5v6*) + # Note: We can NOT use -z defs as we might desire, because we do not + # link with -lc, and that would cause any symbols used from libc to + # always be unresolved, which means just about no library would + # ever link correctly. If we're not using GNU ld we use -z text + # though, which does catch some bad symbols but isn't as heavy-handed + # as -z defs. + _LT_TAGVAR(no_undefined_flag, $1)='${wl}-z,text' + _LT_TAGVAR(allow_undefined_flag, $1)='${wl}-z,nodefs' + _LT_TAGVAR(archive_cmds_need_lc, $1)=no + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R,$libdir' + _LT_TAGVAR(hardcode_libdir_separator, $1)=':' + _LT_TAGVAR(link_all_deplibs, $1)=yes + _LT_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-Bexport' + runpath_var='LD_RUN_PATH' + + case $cc_basename in + CC*) + _LT_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + _LT_TAGVAR(old_archive_cmds, $1)='$CC -Tprelink_objects $oldobjs~ + '"$_LT_TAGVAR(old_archive_cmds, $1)" + _LT_TAGVAR(reload_cmds, $1)='$CC -Tprelink_objects $reload_objs~ + '"$_LT_TAGVAR(reload_cmds, $1)" + ;; + *) + _LT_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + ;; + esac + ;; + + tandem*) + case $cc_basename in + NCC*) + # NonStop-UX NCC 3.20 + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + *) + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + esac + ;; + + vxworks*) + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + + *) + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + esac + + AC_MSG_RESULT([$_LT_TAGVAR(ld_shlibs, $1)]) + test "$_LT_TAGVAR(ld_shlibs, $1)" = no && can_build_shared=no + + _LT_TAGVAR(GCC, $1)="$GXX" + _LT_TAGVAR(LD, $1)="$LD" + + ## CAVEAT EMPTOR: + ## There is no encapsulation within the following macros, do not change + ## the running order or otherwise move them around unless you know exactly + ## what you are doing... + _LT_SYS_HIDDEN_LIBDEPS($1) + _LT_COMPILER_PIC($1) + _LT_COMPILER_C_O($1) + _LT_COMPILER_FILE_LOCKS($1) + _LT_LINKER_SHLIBS($1) + _LT_SYS_DYNAMIC_LINKER($1) + _LT_LINKER_HARDCODE_LIBPATH($1) + + _LT_CONFIG($1) + fi # test -n "$compiler" + + CC=$lt_save_CC + CFLAGS=$lt_save_CFLAGS + LDCXX=$LD + LD=$lt_save_LD + GCC=$lt_save_GCC + with_gnu_ld=$lt_save_with_gnu_ld + lt_cv_path_LDCXX=$lt_cv_path_LD + lt_cv_path_LD=$lt_save_path_LD + lt_cv_prog_gnu_ldcxx=$lt_cv_prog_gnu_ld + lt_cv_prog_gnu_ld=$lt_save_with_gnu_ld +fi # test "$_lt_caught_CXX_error" != yes + +AC_LANG_POP +])# _LT_LANG_CXX_CONFIG + + +# _LT_FUNC_STRIPNAME_CNF +# ---------------------- +# func_stripname_cnf prefix suffix name +# strip PREFIX and SUFFIX off of NAME. +# PREFIX and SUFFIX must not contain globbing or regex special +# characters, hashes, percent signs, but SUFFIX may contain a leading +# dot (in which case that matches only a dot). +# +# This function is identical to the (non-XSI) version of func_stripname, +# except this one can be used by m4 code that may be executed by configure, +# rather than the libtool script. +m4_defun([_LT_FUNC_STRIPNAME_CNF],[dnl +AC_REQUIRE([_LT_DECL_SED]) +AC_REQUIRE([_LT_PROG_ECHO_BACKSLASH]) +func_stripname_cnf () +{ + case ${2} in + .*) func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%\\\\${2}\$%%"`;; + *) func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%${2}\$%%"`;; + esac +} # func_stripname_cnf +])# _LT_FUNC_STRIPNAME_CNF + +# _LT_SYS_HIDDEN_LIBDEPS([TAGNAME]) +# --------------------------------- +# Figure out "hidden" library dependencies from verbose +# compiler output when linking a shared library. +# Parse the compiler output and extract the necessary +# objects, libraries and library flags. +m4_defun([_LT_SYS_HIDDEN_LIBDEPS], +[m4_require([_LT_FILEUTILS_DEFAULTS])dnl +AC_REQUIRE([_LT_FUNC_STRIPNAME_CNF])dnl +# Dependencies to place before and after the object being linked: +_LT_TAGVAR(predep_objects, $1)= +_LT_TAGVAR(postdep_objects, $1)= +_LT_TAGVAR(predeps, $1)= +_LT_TAGVAR(postdeps, $1)= +_LT_TAGVAR(compiler_lib_search_path, $1)= + +dnl we can't use the lt_simple_compile_test_code here, +dnl because it contains code intended for an executable, +dnl not a library. It's possible we should let each +dnl tag define a new lt_????_link_test_code variable, +dnl but it's only used here... +m4_if([$1], [], [cat > conftest.$ac_ext <<_LT_EOF +int a; +void foo (void) { a = 0; } +_LT_EOF +], [$1], [CXX], [cat > conftest.$ac_ext <<_LT_EOF +class Foo +{ +public: + Foo (void) { a = 0; } +private: + int a; +}; +_LT_EOF +], [$1], [F77], [cat > conftest.$ac_ext <<_LT_EOF + subroutine foo + implicit none + integer*4 a + a=0 + return + end +_LT_EOF +], [$1], [FC], [cat > conftest.$ac_ext <<_LT_EOF + subroutine foo + implicit none + integer a + a=0 + return + end +_LT_EOF +], [$1], [GCJ], [cat > conftest.$ac_ext <<_LT_EOF +public class foo { + private int a; + public void bar (void) { + a = 0; + } +}; +_LT_EOF +], [$1], [GO], [cat > conftest.$ac_ext <<_LT_EOF +package foo +func foo() { +} +_LT_EOF +]) + +_lt_libdeps_save_CFLAGS=$CFLAGS +case "$CC $CFLAGS " in #( +*\ -flto*\ *) CFLAGS="$CFLAGS -fno-lto" ;; +*\ -fwhopr*\ *) CFLAGS="$CFLAGS -fno-whopr" ;; +*\ -fuse-linker-plugin*\ *) CFLAGS="$CFLAGS -fno-use-linker-plugin" ;; +esac + +dnl Parse the compiler output and extract the necessary +dnl objects, libraries and library flags. +if AC_TRY_EVAL(ac_compile); then + # Parse the compiler output and extract the necessary + # objects, libraries and library flags. + + # Sentinel used to keep track of whether or not we are before + # the conftest object file. + pre_test_object_deps_done=no + + for p in `eval "$output_verbose_link_cmd"`; do + case ${prev}${p} in + + -L* | -R* | -l*) + # Some compilers place space between "-{L,R}" and the path. + # Remove the space. + if test $p = "-L" || + test $p = "-R"; then + prev=$p + continue + fi + + # Expand the sysroot to ease extracting the directories later. + if test -z "$prev"; then + case $p in + -L*) func_stripname_cnf '-L' '' "$p"; prev=-L; p=$func_stripname_result ;; + -R*) func_stripname_cnf '-R' '' "$p"; prev=-R; p=$func_stripname_result ;; + -l*) func_stripname_cnf '-l' '' "$p"; prev=-l; p=$func_stripname_result ;; + esac + fi + case $p in + =*) func_stripname_cnf '=' '' "$p"; p=$lt_sysroot$func_stripname_result ;; + esac + if test "$pre_test_object_deps_done" = no; then + case ${prev} in + -L | -R) + # Internal compiler library paths should come after those + # provided the user. The postdeps already come after the + # user supplied libs so there is no need to process them. + if test -z "$_LT_TAGVAR(compiler_lib_search_path, $1)"; then + _LT_TAGVAR(compiler_lib_search_path, $1)="${prev}${p}" + else + _LT_TAGVAR(compiler_lib_search_path, $1)="${_LT_TAGVAR(compiler_lib_search_path, $1)} ${prev}${p}" + fi + ;; + # The "-l" case would never come before the object being + # linked, so don't bother handling this case. + esac + else + if test -z "$_LT_TAGVAR(postdeps, $1)"; then + _LT_TAGVAR(postdeps, $1)="${prev}${p}" + else + _LT_TAGVAR(postdeps, $1)="${_LT_TAGVAR(postdeps, $1)} ${prev}${p}" + fi + fi + prev= + ;; + + *.lto.$objext) ;; # Ignore GCC LTO objects + *.$objext) + # This assumes that the test object file only shows up + # once in the compiler output. + if test "$p" = "conftest.$objext"; then + pre_test_object_deps_done=yes + continue + fi + + if test "$pre_test_object_deps_done" = no; then + if test -z "$_LT_TAGVAR(predep_objects, $1)"; then + _LT_TAGVAR(predep_objects, $1)="$p" + else + _LT_TAGVAR(predep_objects, $1)="$_LT_TAGVAR(predep_objects, $1) $p" + fi + else + if test -z "$_LT_TAGVAR(postdep_objects, $1)"; then + _LT_TAGVAR(postdep_objects, $1)="$p" + else + _LT_TAGVAR(postdep_objects, $1)="$_LT_TAGVAR(postdep_objects, $1) $p" + fi + fi + ;; + + *) ;; # Ignore the rest. + + esac + done + + # Clean up. + rm -f a.out a.exe +else + echo "libtool.m4: error: problem compiling $1 test program" +fi + +$RM -f confest.$objext +CFLAGS=$_lt_libdeps_save_CFLAGS + +# PORTME: override above test on systems where it is broken +m4_if([$1], [CXX], +[case $host_os in +interix[[3-9]]*) + # Interix 3.5 installs completely hosed .la files for C++, so rather than + # hack all around it, let's just trust "g++" to DTRT. + _LT_TAGVAR(predep_objects,$1)= + _LT_TAGVAR(postdep_objects,$1)= + _LT_TAGVAR(postdeps,$1)= + ;; + +linux*) + case `$CC -V 2>&1 | sed 5q` in + *Sun\ C*) + # Sun C++ 5.9 + + # The more standards-conforming stlport4 library is + # incompatible with the Cstd library. Avoid specifying + # it if it's in CXXFLAGS. Ignore libCrun as + # -library=stlport4 depends on it. + case " $CXX $CXXFLAGS " in + *" -library=stlport4 "*) + solaris_use_stlport4=yes + ;; + esac + + if test "$solaris_use_stlport4" != yes; then + _LT_TAGVAR(postdeps,$1)='-library=Cstd -library=Crun' + fi + ;; + esac + ;; + +solaris*) + case $cc_basename in + CC* | sunCC*) + # The more standards-conforming stlport4 library is + # incompatible with the Cstd library. Avoid specifying + # it if it's in CXXFLAGS. Ignore libCrun as + # -library=stlport4 depends on it. + case " $CXX $CXXFLAGS " in + *" -library=stlport4 "*) + solaris_use_stlport4=yes + ;; + esac + + # Adding this requires a known-good setup of shared libraries for + # Sun compiler versions before 5.6, else PIC objects from an old + # archive will be linked into the output, leading to subtle bugs. + if test "$solaris_use_stlport4" != yes; then + _LT_TAGVAR(postdeps,$1)='-library=Cstd -library=Crun' + fi + ;; + esac + ;; +esac +]) + +case " $_LT_TAGVAR(postdeps, $1) " in +*" -lc "*) _LT_TAGVAR(archive_cmds_need_lc, $1)=no ;; +esac + _LT_TAGVAR(compiler_lib_search_dirs, $1)= +if test -n "${_LT_TAGVAR(compiler_lib_search_path, $1)}"; then + _LT_TAGVAR(compiler_lib_search_dirs, $1)=`echo " ${_LT_TAGVAR(compiler_lib_search_path, $1)}" | ${SED} -e 's! -L! !g' -e 's!^ !!'` +fi +_LT_TAGDECL([], [compiler_lib_search_dirs], [1], + [The directories searched by this compiler when creating a shared library]) +_LT_TAGDECL([], [predep_objects], [1], + [Dependencies to place before and after the objects being linked to + create a shared library]) +_LT_TAGDECL([], [postdep_objects], [1]) +_LT_TAGDECL([], [predeps], [1]) +_LT_TAGDECL([], [postdeps], [1]) +_LT_TAGDECL([], [compiler_lib_search_path], [1], + [The library search path used internally by the compiler when linking + a shared library]) +])# _LT_SYS_HIDDEN_LIBDEPS + + +# _LT_LANG_F77_CONFIG([TAG]) +# -------------------------- +# Ensure that the configuration variables for a Fortran 77 compiler are +# suitably defined. These variables are subsequently used by _LT_CONFIG +# to write the compiler configuration to `libtool'. +m4_defun([_LT_LANG_F77_CONFIG], +[AC_LANG_PUSH(Fortran 77) +if test -z "$F77" || test "X$F77" = "Xno"; then + _lt_disable_F77=yes +fi + +_LT_TAGVAR(archive_cmds_need_lc, $1)=no +_LT_TAGVAR(allow_undefined_flag, $1)= +_LT_TAGVAR(always_export_symbols, $1)=no +_LT_TAGVAR(archive_expsym_cmds, $1)= +_LT_TAGVAR(export_dynamic_flag_spec, $1)= +_LT_TAGVAR(hardcode_direct, $1)=no +_LT_TAGVAR(hardcode_direct_absolute, $1)=no +_LT_TAGVAR(hardcode_libdir_flag_spec, $1)= +_LT_TAGVAR(hardcode_libdir_separator, $1)= +_LT_TAGVAR(hardcode_minus_L, $1)=no +_LT_TAGVAR(hardcode_automatic, $1)=no +_LT_TAGVAR(inherit_rpath, $1)=no +_LT_TAGVAR(module_cmds, $1)= +_LT_TAGVAR(module_expsym_cmds, $1)= +_LT_TAGVAR(link_all_deplibs, $1)=unknown +_LT_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds +_LT_TAGVAR(reload_flag, $1)=$reload_flag +_LT_TAGVAR(reload_cmds, $1)=$reload_cmds +_LT_TAGVAR(no_undefined_flag, $1)= +_LT_TAGVAR(whole_archive_flag_spec, $1)= +_LT_TAGVAR(enable_shared_with_static_runtimes, $1)=no + +# Source file extension for f77 test sources. +ac_ext=f + +# Object file extension for compiled f77 test sources. +objext=o +_LT_TAGVAR(objext, $1)=$objext + +# No sense in running all these tests if we already determined that +# the F77 compiler isn't working. Some variables (like enable_shared) +# are currently assumed to apply to all compilers on this platform, +# and will be corrupted by setting them based on a non-working compiler. +if test "$_lt_disable_F77" != yes; then + # Code to be used in simple compile tests + lt_simple_compile_test_code="\ + subroutine t + return + end +" + + # Code to be used in simple link tests + lt_simple_link_test_code="\ + program t + end +" + + # ltmain only uses $CC for tagged configurations so make sure $CC is set. + _LT_TAG_COMPILER + + # save warnings/boilerplate of simple test code + _LT_COMPILER_BOILERPLATE + _LT_LINKER_BOILERPLATE + + # Allow CC to be a program name with arguments. + lt_save_CC="$CC" + lt_save_GCC=$GCC + lt_save_CFLAGS=$CFLAGS + CC=${F77-"f77"} + CFLAGS=$FFLAGS + compiler=$CC + _LT_TAGVAR(compiler, $1)=$CC + _LT_CC_BASENAME([$compiler]) + GCC=$G77 + if test -n "$compiler"; then + AC_MSG_CHECKING([if libtool supports shared libraries]) + AC_MSG_RESULT([$can_build_shared]) + + AC_MSG_CHECKING([whether to build shared libraries]) + test "$can_build_shared" = "no" && enable_shared=no + + # On AIX, shared libraries and static libraries use the same namespace, and + # are all built from PIC. + case $host_os in + aix3*) + test "$enable_shared" = yes && enable_static=no + if test -n "$RANLIB"; then + archive_cmds="$archive_cmds~\$RANLIB \$lib" + postinstall_cmds='$RANLIB $lib' + fi + ;; + aix[[4-9]]*) + if test "$host_cpu" != ia64 && test "$aix_use_runtimelinking" = no ; then + test "$enable_shared" = yes && enable_static=no + fi + ;; + esac + AC_MSG_RESULT([$enable_shared]) + + AC_MSG_CHECKING([whether to build static libraries]) + # Make sure either enable_shared or enable_static is yes. + test "$enable_shared" = yes || enable_static=yes + AC_MSG_RESULT([$enable_static]) + + _LT_TAGVAR(GCC, $1)="$G77" + _LT_TAGVAR(LD, $1)="$LD" + + ## CAVEAT EMPTOR: + ## There is no encapsulation within the following macros, do not change + ## the running order or otherwise move them around unless you know exactly + ## what you are doing... + _LT_COMPILER_PIC($1) + _LT_COMPILER_C_O($1) + _LT_COMPILER_FILE_LOCKS($1) + _LT_LINKER_SHLIBS($1) + _LT_SYS_DYNAMIC_LINKER($1) + _LT_LINKER_HARDCODE_LIBPATH($1) + + _LT_CONFIG($1) + fi # test -n "$compiler" + + GCC=$lt_save_GCC + CC="$lt_save_CC" + CFLAGS="$lt_save_CFLAGS" +fi # test "$_lt_disable_F77" != yes + +AC_LANG_POP +])# _LT_LANG_F77_CONFIG + + +# _LT_LANG_FC_CONFIG([TAG]) +# ------------------------- +# Ensure that the configuration variables for a Fortran compiler are +# suitably defined. These variables are subsequently used by _LT_CONFIG +# to write the compiler configuration to `libtool'. +m4_defun([_LT_LANG_FC_CONFIG], +[AC_LANG_PUSH(Fortran) + +if test -z "$FC" || test "X$FC" = "Xno"; then + _lt_disable_FC=yes +fi + +_LT_TAGVAR(archive_cmds_need_lc, $1)=no +_LT_TAGVAR(allow_undefined_flag, $1)= +_LT_TAGVAR(always_export_symbols, $1)=no +_LT_TAGVAR(archive_expsym_cmds, $1)= +_LT_TAGVAR(export_dynamic_flag_spec, $1)= +_LT_TAGVAR(hardcode_direct, $1)=no +_LT_TAGVAR(hardcode_direct_absolute, $1)=no +_LT_TAGVAR(hardcode_libdir_flag_spec, $1)= +_LT_TAGVAR(hardcode_libdir_separator, $1)= +_LT_TAGVAR(hardcode_minus_L, $1)=no +_LT_TAGVAR(hardcode_automatic, $1)=no +_LT_TAGVAR(inherit_rpath, $1)=no +_LT_TAGVAR(module_cmds, $1)= +_LT_TAGVAR(module_expsym_cmds, $1)= +_LT_TAGVAR(link_all_deplibs, $1)=unknown +_LT_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds +_LT_TAGVAR(reload_flag, $1)=$reload_flag +_LT_TAGVAR(reload_cmds, $1)=$reload_cmds +_LT_TAGVAR(no_undefined_flag, $1)= +_LT_TAGVAR(whole_archive_flag_spec, $1)= +_LT_TAGVAR(enable_shared_with_static_runtimes, $1)=no + +# Source file extension for fc test sources. +ac_ext=${ac_fc_srcext-f} + +# Object file extension for compiled fc test sources. +objext=o +_LT_TAGVAR(objext, $1)=$objext + +# No sense in running all these tests if we already determined that +# the FC compiler isn't working. Some variables (like enable_shared) +# are currently assumed to apply to all compilers on this platform, +# and will be corrupted by setting them based on a non-working compiler. +if test "$_lt_disable_FC" != yes; then + # Code to be used in simple compile tests + lt_simple_compile_test_code="\ + subroutine t + return + end +" + + # Code to be used in simple link tests + lt_simple_link_test_code="\ + program t + end +" + + # ltmain only uses $CC for tagged configurations so make sure $CC is set. + _LT_TAG_COMPILER + + # save warnings/boilerplate of simple test code + _LT_COMPILER_BOILERPLATE + _LT_LINKER_BOILERPLATE + + # Allow CC to be a program name with arguments. + lt_save_CC="$CC" + lt_save_GCC=$GCC + lt_save_CFLAGS=$CFLAGS + CC=${FC-"f95"} + CFLAGS=$FCFLAGS + compiler=$CC + GCC=$ac_cv_fc_compiler_gnu + + _LT_TAGVAR(compiler, $1)=$CC + _LT_CC_BASENAME([$compiler]) + + if test -n "$compiler"; then + AC_MSG_CHECKING([if libtool supports shared libraries]) + AC_MSG_RESULT([$can_build_shared]) + + AC_MSG_CHECKING([whether to build shared libraries]) + test "$can_build_shared" = "no" && enable_shared=no + + # On AIX, shared libraries and static libraries use the same namespace, and + # are all built from PIC. + case $host_os in + aix3*) + test "$enable_shared" = yes && enable_static=no + if test -n "$RANLIB"; then + archive_cmds="$archive_cmds~\$RANLIB \$lib" + postinstall_cmds='$RANLIB $lib' + fi + ;; + aix[[4-9]]*) + if test "$host_cpu" != ia64 && test "$aix_use_runtimelinking" = no ; then + test "$enable_shared" = yes && enable_static=no + fi + ;; + esac + AC_MSG_RESULT([$enable_shared]) + + AC_MSG_CHECKING([whether to build static libraries]) + # Make sure either enable_shared or enable_static is yes. + test "$enable_shared" = yes || enable_static=yes + AC_MSG_RESULT([$enable_static]) + + _LT_TAGVAR(GCC, $1)="$ac_cv_fc_compiler_gnu" + _LT_TAGVAR(LD, $1)="$LD" + + ## CAVEAT EMPTOR: + ## There is no encapsulation within the following macros, do not change + ## the running order or otherwise move them around unless you know exactly + ## what you are doing... + _LT_SYS_HIDDEN_LIBDEPS($1) + _LT_COMPILER_PIC($1) + _LT_COMPILER_C_O($1) + _LT_COMPILER_FILE_LOCKS($1) + _LT_LINKER_SHLIBS($1) + _LT_SYS_DYNAMIC_LINKER($1) + _LT_LINKER_HARDCODE_LIBPATH($1) + + _LT_CONFIG($1) + fi # test -n "$compiler" + + GCC=$lt_save_GCC + CC=$lt_save_CC + CFLAGS=$lt_save_CFLAGS +fi # test "$_lt_disable_FC" != yes + +AC_LANG_POP +])# _LT_LANG_FC_CONFIG + + +# _LT_LANG_GCJ_CONFIG([TAG]) +# -------------------------- +# Ensure that the configuration variables for the GNU Java Compiler compiler +# are suitably defined. These variables are subsequently used by _LT_CONFIG +# to write the compiler configuration to `libtool'. +m4_defun([_LT_LANG_GCJ_CONFIG], +[AC_REQUIRE([LT_PROG_GCJ])dnl +AC_LANG_SAVE + +# Source file extension for Java test sources. +ac_ext=java + +# Object file extension for compiled Java test sources. +objext=o +_LT_TAGVAR(objext, $1)=$objext + +# Code to be used in simple compile tests +lt_simple_compile_test_code="class foo {}" + +# Code to be used in simple link tests +lt_simple_link_test_code='public class conftest { public static void main(String[[]] argv) {}; }' + +# ltmain only uses $CC for tagged configurations so make sure $CC is set. +_LT_TAG_COMPILER + +# save warnings/boilerplate of simple test code +_LT_COMPILER_BOILERPLATE +_LT_LINKER_BOILERPLATE + +# Allow CC to be a program name with arguments. +lt_save_CC=$CC +lt_save_CFLAGS=$CFLAGS +lt_save_GCC=$GCC +GCC=yes +CC=${GCJ-"gcj"} +CFLAGS=$GCJFLAGS +compiler=$CC +_LT_TAGVAR(compiler, $1)=$CC +_LT_TAGVAR(LD, $1)="$LD" +_LT_CC_BASENAME([$compiler]) + +# GCJ did not exist at the time GCC didn't implicitly link libc in. +_LT_TAGVAR(archive_cmds_need_lc, $1)=no + +_LT_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds +_LT_TAGVAR(reload_flag, $1)=$reload_flag +_LT_TAGVAR(reload_cmds, $1)=$reload_cmds + +## CAVEAT EMPTOR: +## There is no encapsulation within the following macros, do not change +## the running order or otherwise move them around unless you know exactly +## what you are doing... +if test -n "$compiler"; then + _LT_COMPILER_NO_RTTI($1) + _LT_COMPILER_PIC($1) + _LT_COMPILER_C_O($1) + _LT_COMPILER_FILE_LOCKS($1) + _LT_LINKER_SHLIBS($1) + _LT_LINKER_HARDCODE_LIBPATH($1) + + _LT_CONFIG($1) +fi + +AC_LANG_RESTORE + +GCC=$lt_save_GCC +CC=$lt_save_CC +CFLAGS=$lt_save_CFLAGS +])# _LT_LANG_GCJ_CONFIG + + +# _LT_LANG_GO_CONFIG([TAG]) +# -------------------------- +# Ensure that the configuration variables for the GNU Go compiler +# are suitably defined. These variables are subsequently used by _LT_CONFIG +# to write the compiler configuration to `libtool'. +m4_defun([_LT_LANG_GO_CONFIG], +[AC_REQUIRE([LT_PROG_GO])dnl +AC_LANG_SAVE + +# Source file extension for Go test sources. +ac_ext=go + +# Object file extension for compiled Go test sources. +objext=o +_LT_TAGVAR(objext, $1)=$objext + +# Code to be used in simple compile tests +lt_simple_compile_test_code="package main; func main() { }" + +# Code to be used in simple link tests +lt_simple_link_test_code='package main; func main() { }' + +# ltmain only uses $CC for tagged configurations so make sure $CC is set. +_LT_TAG_COMPILER + +# save warnings/boilerplate of simple test code +_LT_COMPILER_BOILERPLATE +_LT_LINKER_BOILERPLATE + +# Allow CC to be a program name with arguments. +lt_save_CC=$CC +lt_save_CFLAGS=$CFLAGS +lt_save_GCC=$GCC +GCC=yes +CC=${GOC-"gccgo"} +CFLAGS=$GOFLAGS +compiler=$CC +_LT_TAGVAR(compiler, $1)=$CC +_LT_TAGVAR(LD, $1)="$LD" +_LT_CC_BASENAME([$compiler]) + +# Go did not exist at the time GCC didn't implicitly link libc in. +_LT_TAGVAR(archive_cmds_need_lc, $1)=no + +_LT_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds +_LT_TAGVAR(reload_flag, $1)=$reload_flag +_LT_TAGVAR(reload_cmds, $1)=$reload_cmds + +## CAVEAT EMPTOR: +## There is no encapsulation within the following macros, do not change +## the running order or otherwise move them around unless you know exactly +## what you are doing... +if test -n "$compiler"; then + _LT_COMPILER_NO_RTTI($1) + _LT_COMPILER_PIC($1) + _LT_COMPILER_C_O($1) + _LT_COMPILER_FILE_LOCKS($1) + _LT_LINKER_SHLIBS($1) + _LT_LINKER_HARDCODE_LIBPATH($1) + + _LT_CONFIG($1) +fi + +AC_LANG_RESTORE + +GCC=$lt_save_GCC +CC=$lt_save_CC +CFLAGS=$lt_save_CFLAGS +])# _LT_LANG_GO_CONFIG + + +# _LT_LANG_RC_CONFIG([TAG]) +# ------------------------- +# Ensure that the configuration variables for the Windows resource compiler +# are suitably defined. These variables are subsequently used by _LT_CONFIG +# to write the compiler configuration to `libtool'. +m4_defun([_LT_LANG_RC_CONFIG], +[AC_REQUIRE([LT_PROG_RC])dnl +AC_LANG_SAVE + +# Source file extension for RC test sources. +ac_ext=rc + +# Object file extension for compiled RC test sources. +objext=o +_LT_TAGVAR(objext, $1)=$objext + +# Code to be used in simple compile tests +lt_simple_compile_test_code='sample MENU { MENUITEM "&Soup", 100, CHECKED }' + +# Code to be used in simple link tests +lt_simple_link_test_code="$lt_simple_compile_test_code" + +# ltmain only uses $CC for tagged configurations so make sure $CC is set. +_LT_TAG_COMPILER + +# save warnings/boilerplate of simple test code +_LT_COMPILER_BOILERPLATE +_LT_LINKER_BOILERPLATE + +# Allow CC to be a program name with arguments. +lt_save_CC="$CC" +lt_save_CFLAGS=$CFLAGS +lt_save_GCC=$GCC +GCC= +CC=${RC-"windres"} +CFLAGS= +compiler=$CC +_LT_TAGVAR(compiler, $1)=$CC +_LT_CC_BASENAME([$compiler]) +_LT_TAGVAR(lt_cv_prog_compiler_c_o, $1)=yes + +if test -n "$compiler"; then + : + _LT_CONFIG($1) +fi + +GCC=$lt_save_GCC +AC_LANG_RESTORE +CC=$lt_save_CC +CFLAGS=$lt_save_CFLAGS +])# _LT_LANG_RC_CONFIG + + +# LT_PROG_GCJ +# ----------- +AC_DEFUN([LT_PROG_GCJ], +[m4_ifdef([AC_PROG_GCJ], [AC_PROG_GCJ], + [m4_ifdef([A][M_PROG_GCJ], [A][M_PROG_GCJ], + [AC_CHECK_TOOL(GCJ, gcj,) + test "x${GCJFLAGS+set}" = xset || GCJFLAGS="-g -O2" + AC_SUBST(GCJFLAGS)])])[]dnl +]) + +# Old name: +AU_ALIAS([LT_AC_PROG_GCJ], [LT_PROG_GCJ]) +dnl aclocal-1.4 backwards compatibility: +dnl AC_DEFUN([LT_AC_PROG_GCJ], []) + + +# LT_PROG_GO +# ---------- +AC_DEFUN([LT_PROG_GO], +[AC_CHECK_TOOL(GOC, gccgo,) +]) + + +# LT_PROG_RC +# ---------- +AC_DEFUN([LT_PROG_RC], +[AC_CHECK_TOOL(RC, windres,) +]) + +# Old name: +AU_ALIAS([LT_AC_PROG_RC], [LT_PROG_RC]) +dnl aclocal-1.4 backwards compatibility: +dnl AC_DEFUN([LT_AC_PROG_RC], []) + + +# _LT_DECL_EGREP +# -------------- +# If we don't have a new enough Autoconf to choose the best grep +# available, choose the one first in the user's PATH. +m4_defun([_LT_DECL_EGREP], +[AC_REQUIRE([AC_PROG_EGREP])dnl +AC_REQUIRE([AC_PROG_FGREP])dnl +test -z "$GREP" && GREP=grep +_LT_DECL([], [GREP], [1], [A grep program that handles long lines]) +_LT_DECL([], [EGREP], [1], [An ERE matcher]) +_LT_DECL([], [FGREP], [1], [A literal string matcher]) +dnl Non-bleeding-edge autoconf doesn't subst GREP, so do it here too +AC_SUBST([GREP]) +]) + + +# _LT_DECL_OBJDUMP +# -------------- +# If we don't have a new enough Autoconf to choose the best objdump +# available, choose the one first in the user's PATH. +m4_defun([_LT_DECL_OBJDUMP], +[AC_CHECK_TOOL(OBJDUMP, objdump, false) +test -z "$OBJDUMP" && OBJDUMP=objdump +_LT_DECL([], [OBJDUMP], [1], [An object symbol dumper]) +AC_SUBST([OBJDUMP]) +]) + +# _LT_DECL_DLLTOOL +# ---------------- +# Ensure DLLTOOL variable is set. +m4_defun([_LT_DECL_DLLTOOL], +[AC_CHECK_TOOL(DLLTOOL, dlltool, false) +test -z "$DLLTOOL" && DLLTOOL=dlltool +_LT_DECL([], [DLLTOOL], [1], [DLL creation program]) +AC_SUBST([DLLTOOL]) +]) + +# _LT_DECL_SED +# ------------ +# Check for a fully-functional sed program, that truncates +# as few characters as possible. Prefer GNU sed if found. +m4_defun([_LT_DECL_SED], +[AC_PROG_SED +test -z "$SED" && SED=sed +Xsed="$SED -e 1s/^X//" +_LT_DECL([], [SED], [1], [A sed program that does not truncate output]) +_LT_DECL([], [Xsed], ["\$SED -e 1s/^X//"], + [Sed that helps us avoid accidentally triggering echo(1) options like -n]) +])# _LT_DECL_SED + +m4_ifndef([AC_PROG_SED], [ +############################################################ +# NOTE: This macro has been submitted for inclusion into # +# GNU Autoconf as AC_PROG_SED. When it is available in # +# a released version of Autoconf we should remove this # +# macro and use it instead. # +############################################################ + +m4_defun([AC_PROG_SED], +[AC_MSG_CHECKING([for a sed that does not truncate output]) +AC_CACHE_VAL(lt_cv_path_SED, +[# Loop through the user's path and test for sed and gsed. +# Then use that list of sed's as ones to test for truncation. +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for lt_ac_prog in sed gsed; do + for ac_exec_ext in '' $ac_executable_extensions; do + if $as_executable_p "$as_dir/$lt_ac_prog$ac_exec_ext"; then + lt_ac_sed_list="$lt_ac_sed_list $as_dir/$lt_ac_prog$ac_exec_ext" + fi + done + done +done +IFS=$as_save_IFS +lt_ac_max=0 +lt_ac_count=0 +# Add /usr/xpg4/bin/sed as it is typically found on Solaris +# along with /bin/sed that truncates output. +for lt_ac_sed in $lt_ac_sed_list /usr/xpg4/bin/sed; do + test ! -f $lt_ac_sed && continue + cat /dev/null > conftest.in + lt_ac_count=0 + echo $ECHO_N "0123456789$ECHO_C" >conftest.in + # Check for GNU sed and select it if it is found. + if "$lt_ac_sed" --version 2>&1 < /dev/null | grep 'GNU' > /dev/null; then + lt_cv_path_SED=$lt_ac_sed + break + fi + while true; do + cat conftest.in conftest.in >conftest.tmp + mv conftest.tmp conftest.in + cp conftest.in conftest.nl + echo >>conftest.nl + $lt_ac_sed -e 's/a$//' < conftest.nl >conftest.out || break + cmp -s conftest.out conftest.nl || break + # 10000 chars as input seems more than enough + test $lt_ac_count -gt 10 && break + lt_ac_count=`expr $lt_ac_count + 1` + if test $lt_ac_count -gt $lt_ac_max; then + lt_ac_max=$lt_ac_count + lt_cv_path_SED=$lt_ac_sed + fi + done +done +]) +SED=$lt_cv_path_SED +AC_SUBST([SED]) +AC_MSG_RESULT([$SED]) +])#AC_PROG_SED +])#m4_ifndef + +# Old name: +AU_ALIAS([LT_AC_PROG_SED], [AC_PROG_SED]) +dnl aclocal-1.4 backwards compatibility: +dnl AC_DEFUN([LT_AC_PROG_SED], []) + + +# _LT_CHECK_SHELL_FEATURES +# ------------------------ +# Find out whether the shell is Bourne or XSI compatible, +# or has some other useful features. +m4_defun([_LT_CHECK_SHELL_FEATURES], +[AC_MSG_CHECKING([whether the shell understands some XSI constructs]) +# Try some XSI features +xsi_shell=no +( _lt_dummy="a/b/c" + test "${_lt_dummy##*/},${_lt_dummy%/*},${_lt_dummy#??}"${_lt_dummy%"$_lt_dummy"}, \ + = c,a/b,b/c, \ + && eval 'test $(( 1 + 1 )) -eq 2 \ + && test "${#_lt_dummy}" -eq 5' ) >/dev/null 2>&1 \ + && xsi_shell=yes +AC_MSG_RESULT([$xsi_shell]) +_LT_CONFIG_LIBTOOL_INIT([xsi_shell='$xsi_shell']) + +AC_MSG_CHECKING([whether the shell understands "+="]) +lt_shell_append=no +( foo=bar; set foo baz; eval "$[1]+=\$[2]" && test "$foo" = barbaz ) \ + >/dev/null 2>&1 \ + && lt_shell_append=yes +AC_MSG_RESULT([$lt_shell_append]) +_LT_CONFIG_LIBTOOL_INIT([lt_shell_append='$lt_shell_append']) + +if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then + lt_unset=unset +else + lt_unset=false +fi +_LT_DECL([], [lt_unset], [0], [whether the shell understands "unset"])dnl + +# test EBCDIC or ASCII +case `echo X|tr X '\101'` in + A) # ASCII based system + # \n is not interpreted correctly by Solaris 8 /usr/ucb/tr + lt_SP2NL='tr \040 \012' + lt_NL2SP='tr \015\012 \040\040' + ;; + *) # EBCDIC based system + lt_SP2NL='tr \100 \n' + lt_NL2SP='tr \r\n \100\100' + ;; +esac +_LT_DECL([SP2NL], [lt_SP2NL], [1], [turn spaces into newlines])dnl +_LT_DECL([NL2SP], [lt_NL2SP], [1], [turn newlines into spaces])dnl +])# _LT_CHECK_SHELL_FEATURES + + +# _LT_PROG_FUNCTION_REPLACE (FUNCNAME, REPLACEMENT-BODY) +# ------------------------------------------------------ +# In `$cfgfile', look for function FUNCNAME delimited by `^FUNCNAME ()$' and +# '^} FUNCNAME ', and replace its body with REPLACEMENT-BODY. +m4_defun([_LT_PROG_FUNCTION_REPLACE], +[dnl { +sed -e '/^$1 ()$/,/^} # $1 /c\ +$1 ()\ +{\ +m4_bpatsubsts([$2], [$], [\\], [^\([ ]\)], [\\\1]) +} # Extended-shell $1 implementation' "$cfgfile" > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") +test 0 -eq $? || _lt_function_replace_fail=: +]) + + +# _LT_PROG_REPLACE_SHELLFNS +# ------------------------- +# Replace existing portable implementations of several shell functions with +# equivalent extended shell implementations where those features are available.. +m4_defun([_LT_PROG_REPLACE_SHELLFNS], +[if test x"$xsi_shell" = xyes; then + _LT_PROG_FUNCTION_REPLACE([func_dirname], [dnl + case ${1} in + */*) func_dirname_result="${1%/*}${2}" ;; + * ) func_dirname_result="${3}" ;; + esac]) + + _LT_PROG_FUNCTION_REPLACE([func_basename], [dnl + func_basename_result="${1##*/}"]) + + _LT_PROG_FUNCTION_REPLACE([func_dirname_and_basename], [dnl + case ${1} in + */*) func_dirname_result="${1%/*}${2}" ;; + * ) func_dirname_result="${3}" ;; + esac + func_basename_result="${1##*/}"]) + + _LT_PROG_FUNCTION_REPLACE([func_stripname], [dnl + # pdksh 5.2.14 does not do ${X%$Y} correctly if both X and Y are + # positional parameters, so assign one to ordinary parameter first. + func_stripname_result=${3} + func_stripname_result=${func_stripname_result#"${1}"} + func_stripname_result=${func_stripname_result%"${2}"}]) + + _LT_PROG_FUNCTION_REPLACE([func_split_long_opt], [dnl + func_split_long_opt_name=${1%%=*} + func_split_long_opt_arg=${1#*=}]) + + _LT_PROG_FUNCTION_REPLACE([func_split_short_opt], [dnl + func_split_short_opt_arg=${1#??} + func_split_short_opt_name=${1%"$func_split_short_opt_arg"}]) + + _LT_PROG_FUNCTION_REPLACE([func_lo2o], [dnl + case ${1} in + *.lo) func_lo2o_result=${1%.lo}.${objext} ;; + *) func_lo2o_result=${1} ;; + esac]) + + _LT_PROG_FUNCTION_REPLACE([func_xform], [ func_xform_result=${1%.*}.lo]) + + _LT_PROG_FUNCTION_REPLACE([func_arith], [ func_arith_result=$(( $[*] ))]) + + _LT_PROG_FUNCTION_REPLACE([func_len], [ func_len_result=${#1}]) +fi + +if test x"$lt_shell_append" = xyes; then + _LT_PROG_FUNCTION_REPLACE([func_append], [ eval "${1}+=\\${2}"]) + + _LT_PROG_FUNCTION_REPLACE([func_append_quoted], [dnl + func_quote_for_eval "${2}" +dnl m4 expansion turns \\\\ into \\, and then the shell eval turns that into \ + eval "${1}+=\\\\ \\$func_quote_for_eval_result"]) + + # Save a `func_append' function call where possible by direct use of '+=' + sed -e 's%func_append \([[a-zA-Z_]]\{1,\}\) "%\1+="%g' $cfgfile > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") + test 0 -eq $? || _lt_function_replace_fail=: +else + # Save a `func_append' function call even when '+=' is not available + sed -e 's%func_append \([[a-zA-Z_]]\{1,\}\) "%\1="$\1%g' $cfgfile > $cfgfile.tmp \ + && mv -f "$cfgfile.tmp" "$cfgfile" \ + || (rm -f "$cfgfile" && cp "$cfgfile.tmp" "$cfgfile" && rm -f "$cfgfile.tmp") + test 0 -eq $? || _lt_function_replace_fail=: +fi + +if test x"$_lt_function_replace_fail" = x":"; then + AC_MSG_WARN([Unable to substitute extended shell functions in $ofile]) +fi +]) + +# _LT_PATH_CONVERSION_FUNCTIONS +# ----------------------------- +# Determine which file name conversion functions should be used by +# func_to_host_file (and, implicitly, by func_to_host_path). These are needed +# for certain cross-compile configurations and native mingw. +m4_defun([_LT_PATH_CONVERSION_FUNCTIONS], +[AC_REQUIRE([AC_CANONICAL_HOST])dnl +AC_REQUIRE([AC_CANONICAL_BUILD])dnl +AC_MSG_CHECKING([how to convert $build file names to $host format]) +AC_CACHE_VAL(lt_cv_to_host_file_cmd, +[case $host in + *-*-mingw* ) + case $build in + *-*-mingw* ) # actually msys + lt_cv_to_host_file_cmd=func_convert_file_msys_to_w32 + ;; + *-*-cygwin* ) + lt_cv_to_host_file_cmd=func_convert_file_cygwin_to_w32 + ;; + * ) # otherwise, assume *nix + lt_cv_to_host_file_cmd=func_convert_file_nix_to_w32 + ;; + esac + ;; + *-*-cygwin* ) + case $build in + *-*-mingw* ) # actually msys + lt_cv_to_host_file_cmd=func_convert_file_msys_to_cygwin + ;; + *-*-cygwin* ) + lt_cv_to_host_file_cmd=func_convert_file_noop + ;; + * ) # otherwise, assume *nix + lt_cv_to_host_file_cmd=func_convert_file_nix_to_cygwin + ;; + esac + ;; + * ) # unhandled hosts (and "normal" native builds) + lt_cv_to_host_file_cmd=func_convert_file_noop + ;; +esac +]) +to_host_file_cmd=$lt_cv_to_host_file_cmd +AC_MSG_RESULT([$lt_cv_to_host_file_cmd]) +_LT_DECL([to_host_file_cmd], [lt_cv_to_host_file_cmd], + [0], [convert $build file names to $host format])dnl + +AC_MSG_CHECKING([how to convert $build file names to toolchain format]) +AC_CACHE_VAL(lt_cv_to_tool_file_cmd, +[#assume ordinary cross tools, or native build. +lt_cv_to_tool_file_cmd=func_convert_file_noop +case $host in + *-*-mingw* ) + case $build in + *-*-mingw* ) # actually msys + lt_cv_to_tool_file_cmd=func_convert_file_msys_to_w32 + ;; + esac + ;; +esac +]) +to_tool_file_cmd=$lt_cv_to_tool_file_cmd +AC_MSG_RESULT([$lt_cv_to_tool_file_cmd]) +_LT_DECL([to_tool_file_cmd], [lt_cv_to_tool_file_cmd], + [0], [convert $build files to toolchain format])dnl +])# _LT_PATH_CONVERSION_FUNCTIONS diff --git a/third-party/odb/libodb-sqlite-2.4.0/m4/ltoptions.m4 b/third-party/odb/libodb-sqlite-2.4.0/m4/ltoptions.m4 new file mode 100755 index 0000000..5d9acd8 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/m4/ltoptions.m4 @@ -0,0 +1,384 @@ +# Helper functions for option handling. -*- Autoconf -*- +# +# Copyright (C) 2004, 2005, 2007, 2008, 2009 Free Software Foundation, +# Inc. +# Written by Gary V. Vaughan, 2004 +# +# This file is free software; the Free Software Foundation gives +# unlimited permission to copy and/or distribute it, with or without +# modifications, as long as this notice is preserved. + +# serial 7 ltoptions.m4 + +# This is to help aclocal find these macros, as it can't see m4_define. +AC_DEFUN([LTOPTIONS_VERSION], [m4_if([1])]) + + +# _LT_MANGLE_OPTION(MACRO-NAME, OPTION-NAME) +# ------------------------------------------ +m4_define([_LT_MANGLE_OPTION], +[[_LT_OPTION_]m4_bpatsubst($1__$2, [[^a-zA-Z0-9_]], [_])]) + + +# _LT_SET_OPTION(MACRO-NAME, OPTION-NAME) +# --------------------------------------- +# Set option OPTION-NAME for macro MACRO-NAME, and if there is a +# matching handler defined, dispatch to it. Other OPTION-NAMEs are +# saved as a flag. +m4_define([_LT_SET_OPTION], +[m4_define(_LT_MANGLE_OPTION([$1], [$2]))dnl +m4_ifdef(_LT_MANGLE_DEFUN([$1], [$2]), + _LT_MANGLE_DEFUN([$1], [$2]), + [m4_warning([Unknown $1 option `$2'])])[]dnl +]) + + +# _LT_IF_OPTION(MACRO-NAME, OPTION-NAME, IF-SET, [IF-NOT-SET]) +# ------------------------------------------------------------ +# Execute IF-SET if OPTION is set, IF-NOT-SET otherwise. +m4_define([_LT_IF_OPTION], +[m4_ifdef(_LT_MANGLE_OPTION([$1], [$2]), [$3], [$4])]) + + +# _LT_UNLESS_OPTIONS(MACRO-NAME, OPTION-LIST, IF-NOT-SET) +# ------------------------------------------------------- +# Execute IF-NOT-SET unless all options in OPTION-LIST for MACRO-NAME +# are set. +m4_define([_LT_UNLESS_OPTIONS], +[m4_foreach([_LT_Option], m4_split(m4_normalize([$2])), + [m4_ifdef(_LT_MANGLE_OPTION([$1], _LT_Option), + [m4_define([$0_found])])])[]dnl +m4_ifdef([$0_found], [m4_undefine([$0_found])], [$3 +])[]dnl +]) + + +# _LT_SET_OPTIONS(MACRO-NAME, OPTION-LIST) +# ---------------------------------------- +# OPTION-LIST is a space-separated list of Libtool options associated +# with MACRO-NAME. If any OPTION has a matching handler declared with +# LT_OPTION_DEFINE, dispatch to that macro; otherwise complain about +# the unknown option and exit. +m4_defun([_LT_SET_OPTIONS], +[# Set options +m4_foreach([_LT_Option], m4_split(m4_normalize([$2])), + [_LT_SET_OPTION([$1], _LT_Option)]) + +m4_if([$1],[LT_INIT],[ + dnl + dnl Simply set some default values (i.e off) if boolean options were not + dnl specified: + _LT_UNLESS_OPTIONS([LT_INIT], [dlopen], [enable_dlopen=no + ]) + _LT_UNLESS_OPTIONS([LT_INIT], [win32-dll], [enable_win32_dll=no + ]) + dnl + dnl If no reference was made to various pairs of opposing options, then + dnl we run the default mode handler for the pair. For example, if neither + dnl `shared' nor `disable-shared' was passed, we enable building of shared + dnl archives by default: + _LT_UNLESS_OPTIONS([LT_INIT], [shared disable-shared], [_LT_ENABLE_SHARED]) + _LT_UNLESS_OPTIONS([LT_INIT], [static disable-static], [_LT_ENABLE_STATIC]) + _LT_UNLESS_OPTIONS([LT_INIT], [pic-only no-pic], [_LT_WITH_PIC]) + _LT_UNLESS_OPTIONS([LT_INIT], [fast-install disable-fast-install], + [_LT_ENABLE_FAST_INSTALL]) + ]) +])# _LT_SET_OPTIONS + + +## --------------------------------- ## +## Macros to handle LT_INIT options. ## +## --------------------------------- ## + +# _LT_MANGLE_DEFUN(MACRO-NAME, OPTION-NAME) +# ----------------------------------------- +m4_define([_LT_MANGLE_DEFUN], +[[_LT_OPTION_DEFUN_]m4_bpatsubst(m4_toupper([$1__$2]), [[^A-Z0-9_]], [_])]) + + +# LT_OPTION_DEFINE(MACRO-NAME, OPTION-NAME, CODE) +# ----------------------------------------------- +m4_define([LT_OPTION_DEFINE], +[m4_define(_LT_MANGLE_DEFUN([$1], [$2]), [$3])[]dnl +])# LT_OPTION_DEFINE + + +# dlopen +# ------ +LT_OPTION_DEFINE([LT_INIT], [dlopen], [enable_dlopen=yes +]) + +AU_DEFUN([AC_LIBTOOL_DLOPEN], +[_LT_SET_OPTION([LT_INIT], [dlopen]) +AC_DIAGNOSE([obsolete], +[$0: Remove this warning and the call to _LT_SET_OPTION when you +put the `dlopen' option into LT_INIT's first parameter.]) +]) + +dnl aclocal-1.4 backwards compatibility: +dnl AC_DEFUN([AC_LIBTOOL_DLOPEN], []) + + +# win32-dll +# --------- +# Declare package support for building win32 dll's. +LT_OPTION_DEFINE([LT_INIT], [win32-dll], +[enable_win32_dll=yes + +case $host in +*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-cegcc*) + AC_CHECK_TOOL(AS, as, false) + AC_CHECK_TOOL(DLLTOOL, dlltool, false) + AC_CHECK_TOOL(OBJDUMP, objdump, false) + ;; +esac + +test -z "$AS" && AS=as +_LT_DECL([], [AS], [1], [Assembler program])dnl + +test -z "$DLLTOOL" && DLLTOOL=dlltool +_LT_DECL([], [DLLTOOL], [1], [DLL creation program])dnl + +test -z "$OBJDUMP" && OBJDUMP=objdump +_LT_DECL([], [OBJDUMP], [1], [Object dumper program])dnl +])# win32-dll + +AU_DEFUN([AC_LIBTOOL_WIN32_DLL], +[AC_REQUIRE([AC_CANONICAL_HOST])dnl +_LT_SET_OPTION([LT_INIT], [win32-dll]) +AC_DIAGNOSE([obsolete], +[$0: Remove this warning and the call to _LT_SET_OPTION when you +put the `win32-dll' option into LT_INIT's first parameter.]) +]) + +dnl aclocal-1.4 backwards compatibility: +dnl AC_DEFUN([AC_LIBTOOL_WIN32_DLL], []) + + +# _LT_ENABLE_SHARED([DEFAULT]) +# ---------------------------- +# implement the --enable-shared flag, and supports the `shared' and +# `disable-shared' LT_INIT options. +# DEFAULT is either `yes' or `no'. If omitted, it defaults to `yes'. +m4_define([_LT_ENABLE_SHARED], +[m4_define([_LT_ENABLE_SHARED_DEFAULT], [m4_if($1, no, no, yes)])dnl +AC_ARG_ENABLE([shared], + [AS_HELP_STRING([--enable-shared@<:@=PKGS@:>@], + [build shared libraries @<:@default=]_LT_ENABLE_SHARED_DEFAULT[@:>@])], + [p=${PACKAGE-default} + case $enableval in + yes) enable_shared=yes ;; + no) enable_shared=no ;; + *) + enable_shared=no + # Look at the argument we got. We use all the common list separators. + lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR," + for pkg in $enableval; do + IFS="$lt_save_ifs" + if test "X$pkg" = "X$p"; then + enable_shared=yes + fi + done + IFS="$lt_save_ifs" + ;; + esac], + [enable_shared=]_LT_ENABLE_SHARED_DEFAULT) + + _LT_DECL([build_libtool_libs], [enable_shared], [0], + [Whether or not to build shared libraries]) +])# _LT_ENABLE_SHARED + +LT_OPTION_DEFINE([LT_INIT], [shared], [_LT_ENABLE_SHARED([yes])]) +LT_OPTION_DEFINE([LT_INIT], [disable-shared], [_LT_ENABLE_SHARED([no])]) + +# Old names: +AC_DEFUN([AC_ENABLE_SHARED], +[_LT_SET_OPTION([LT_INIT], m4_if([$1], [no], [disable-])[shared]) +]) + +AC_DEFUN([AC_DISABLE_SHARED], +[_LT_SET_OPTION([LT_INIT], [disable-shared]) +]) + +AU_DEFUN([AM_ENABLE_SHARED], [AC_ENABLE_SHARED($@)]) +AU_DEFUN([AM_DISABLE_SHARED], [AC_DISABLE_SHARED($@)]) + +dnl aclocal-1.4 backwards compatibility: +dnl AC_DEFUN([AM_ENABLE_SHARED], []) +dnl AC_DEFUN([AM_DISABLE_SHARED], []) + + + +# _LT_ENABLE_STATIC([DEFAULT]) +# ---------------------------- +# implement the --enable-static flag, and support the `static' and +# `disable-static' LT_INIT options. +# DEFAULT is either `yes' or `no'. If omitted, it defaults to `yes'. +m4_define([_LT_ENABLE_STATIC], +[m4_define([_LT_ENABLE_STATIC_DEFAULT], [m4_if($1, no, no, yes)])dnl +AC_ARG_ENABLE([static], + [AS_HELP_STRING([--enable-static@<:@=PKGS@:>@], + [build static libraries @<:@default=]_LT_ENABLE_STATIC_DEFAULT[@:>@])], + [p=${PACKAGE-default} + case $enableval in + yes) enable_static=yes ;; + no) enable_static=no ;; + *) + enable_static=no + # Look at the argument we got. We use all the common list separators. + lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR," + for pkg in $enableval; do + IFS="$lt_save_ifs" + if test "X$pkg" = "X$p"; then + enable_static=yes + fi + done + IFS="$lt_save_ifs" + ;; + esac], + [enable_static=]_LT_ENABLE_STATIC_DEFAULT) + + _LT_DECL([build_old_libs], [enable_static], [0], + [Whether or not to build static libraries]) +])# _LT_ENABLE_STATIC + +LT_OPTION_DEFINE([LT_INIT], [static], [_LT_ENABLE_STATIC([yes])]) +LT_OPTION_DEFINE([LT_INIT], [disable-static], [_LT_ENABLE_STATIC([no])]) + +# Old names: +AC_DEFUN([AC_ENABLE_STATIC], +[_LT_SET_OPTION([LT_INIT], m4_if([$1], [no], [disable-])[static]) +]) + +AC_DEFUN([AC_DISABLE_STATIC], +[_LT_SET_OPTION([LT_INIT], [disable-static]) +]) + +AU_DEFUN([AM_ENABLE_STATIC], [AC_ENABLE_STATIC($@)]) +AU_DEFUN([AM_DISABLE_STATIC], [AC_DISABLE_STATIC($@)]) + +dnl aclocal-1.4 backwards compatibility: +dnl AC_DEFUN([AM_ENABLE_STATIC], []) +dnl AC_DEFUN([AM_DISABLE_STATIC], []) + + + +# _LT_ENABLE_FAST_INSTALL([DEFAULT]) +# ---------------------------------- +# implement the --enable-fast-install flag, and support the `fast-install' +# and `disable-fast-install' LT_INIT options. +# DEFAULT is either `yes' or `no'. If omitted, it defaults to `yes'. +m4_define([_LT_ENABLE_FAST_INSTALL], +[m4_define([_LT_ENABLE_FAST_INSTALL_DEFAULT], [m4_if($1, no, no, yes)])dnl +AC_ARG_ENABLE([fast-install], + [AS_HELP_STRING([--enable-fast-install@<:@=PKGS@:>@], + [optimize for fast installation @<:@default=]_LT_ENABLE_FAST_INSTALL_DEFAULT[@:>@])], + [p=${PACKAGE-default} + case $enableval in + yes) enable_fast_install=yes ;; + no) enable_fast_install=no ;; + *) + enable_fast_install=no + # Look at the argument we got. We use all the common list separators. + lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR," + for pkg in $enableval; do + IFS="$lt_save_ifs" + if test "X$pkg" = "X$p"; then + enable_fast_install=yes + fi + done + IFS="$lt_save_ifs" + ;; + esac], + [enable_fast_install=]_LT_ENABLE_FAST_INSTALL_DEFAULT) + +_LT_DECL([fast_install], [enable_fast_install], [0], + [Whether or not to optimize for fast installation])dnl +])# _LT_ENABLE_FAST_INSTALL + +LT_OPTION_DEFINE([LT_INIT], [fast-install], [_LT_ENABLE_FAST_INSTALL([yes])]) +LT_OPTION_DEFINE([LT_INIT], [disable-fast-install], [_LT_ENABLE_FAST_INSTALL([no])]) + +# Old names: +AU_DEFUN([AC_ENABLE_FAST_INSTALL], +[_LT_SET_OPTION([LT_INIT], m4_if([$1], [no], [disable-])[fast-install]) +AC_DIAGNOSE([obsolete], +[$0: Remove this warning and the call to _LT_SET_OPTION when you put +the `fast-install' option into LT_INIT's first parameter.]) +]) + +AU_DEFUN([AC_DISABLE_FAST_INSTALL], +[_LT_SET_OPTION([LT_INIT], [disable-fast-install]) +AC_DIAGNOSE([obsolete], +[$0: Remove this warning and the call to _LT_SET_OPTION when you put +the `disable-fast-install' option into LT_INIT's first parameter.]) +]) + +dnl aclocal-1.4 backwards compatibility: +dnl AC_DEFUN([AC_ENABLE_FAST_INSTALL], []) +dnl AC_DEFUN([AM_DISABLE_FAST_INSTALL], []) + + +# _LT_WITH_PIC([MODE]) +# -------------------- +# implement the --with-pic flag, and support the `pic-only' and `no-pic' +# LT_INIT options. +# MODE is either `yes' or `no'. If omitted, it defaults to `both'. +m4_define([_LT_WITH_PIC], +[AC_ARG_WITH([pic], + [AS_HELP_STRING([--with-pic@<:@=PKGS@:>@], + [try to use only PIC/non-PIC objects @<:@default=use both@:>@])], + [lt_p=${PACKAGE-default} + case $withval in + yes|no) pic_mode=$withval ;; + *) + pic_mode=default + # Look at the argument we got. We use all the common list separators. + lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR," + for lt_pkg in $withval; do + IFS="$lt_save_ifs" + if test "X$lt_pkg" = "X$lt_p"; then + pic_mode=yes + fi + done + IFS="$lt_save_ifs" + ;; + esac], + [pic_mode=default]) + +test -z "$pic_mode" && pic_mode=m4_default([$1], [default]) + +_LT_DECL([], [pic_mode], [0], [What type of objects to build])dnl +])# _LT_WITH_PIC + +LT_OPTION_DEFINE([LT_INIT], [pic-only], [_LT_WITH_PIC([yes])]) +LT_OPTION_DEFINE([LT_INIT], [no-pic], [_LT_WITH_PIC([no])]) + +# Old name: +AU_DEFUN([AC_LIBTOOL_PICMODE], +[_LT_SET_OPTION([LT_INIT], [pic-only]) +AC_DIAGNOSE([obsolete], +[$0: Remove this warning and the call to _LT_SET_OPTION when you +put the `pic-only' option into LT_INIT's first parameter.]) +]) + +dnl aclocal-1.4 backwards compatibility: +dnl AC_DEFUN([AC_LIBTOOL_PICMODE], []) + +## ----------------- ## +## LTDL_INIT Options ## +## ----------------- ## + +m4_define([_LTDL_MODE], []) +LT_OPTION_DEFINE([LTDL_INIT], [nonrecursive], + [m4_define([_LTDL_MODE], [nonrecursive])]) +LT_OPTION_DEFINE([LTDL_INIT], [recursive], + [m4_define([_LTDL_MODE], [recursive])]) +LT_OPTION_DEFINE([LTDL_INIT], [subproject], + [m4_define([_LTDL_MODE], [subproject])]) + +m4_define([_LTDL_TYPE], []) +LT_OPTION_DEFINE([LTDL_INIT], [installable], + [m4_define([_LTDL_TYPE], [installable])]) +LT_OPTION_DEFINE([LTDL_INIT], [convenience], + [m4_define([_LTDL_TYPE], [convenience])]) diff --git a/third-party/odb/libodb-sqlite-2.4.0/m4/ltsugar.m4 b/third-party/odb/libodb-sqlite-2.4.0/m4/ltsugar.m4 new file mode 100755 index 0000000..9000a05 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/m4/ltsugar.m4 @@ -0,0 +1,123 @@ +# ltsugar.m4 -- libtool m4 base layer. -*-Autoconf-*- +# +# Copyright (C) 2004, 2005, 2007, 2008 Free Software Foundation, Inc. +# Written by Gary V. Vaughan, 2004 +# +# This file is free software; the Free Software Foundation gives +# unlimited permission to copy and/or distribute it, with or without +# modifications, as long as this notice is preserved. + +# serial 6 ltsugar.m4 + +# This is to help aclocal find these macros, as it can't see m4_define. +AC_DEFUN([LTSUGAR_VERSION], [m4_if([0.1])]) + + +# lt_join(SEP, ARG1, [ARG2...]) +# ----------------------------- +# Produce ARG1SEPARG2...SEPARGn, omitting [] arguments and their +# associated separator. +# Needed until we can rely on m4_join from Autoconf 2.62, since all earlier +# versions in m4sugar had bugs. +m4_define([lt_join], +[m4_if([$#], [1], [], + [$#], [2], [[$2]], + [m4_if([$2], [], [], [[$2]_])$0([$1], m4_shift(m4_shift($@)))])]) +m4_define([_lt_join], +[m4_if([$#$2], [2], [], + [m4_if([$2], [], [], [[$1$2]])$0([$1], m4_shift(m4_shift($@)))])]) + + +# lt_car(LIST) +# lt_cdr(LIST) +# ------------ +# Manipulate m4 lists. +# These macros are necessary as long as will still need to support +# Autoconf-2.59 which quotes differently. +m4_define([lt_car], [[$1]]) +m4_define([lt_cdr], +[m4_if([$#], 0, [m4_fatal([$0: cannot be called without arguments])], + [$#], 1, [], + [m4_dquote(m4_shift($@))])]) +m4_define([lt_unquote], $1) + + +# lt_append(MACRO-NAME, STRING, [SEPARATOR]) +# ------------------------------------------ +# Redefine MACRO-NAME to hold its former content plus `SEPARATOR'`STRING'. +# Note that neither SEPARATOR nor STRING are expanded; they are appended +# to MACRO-NAME as is (leaving the expansion for when MACRO-NAME is invoked). +# No SEPARATOR is output if MACRO-NAME was previously undefined (different +# than defined and empty). +# +# This macro is needed until we can rely on Autoconf 2.62, since earlier +# versions of m4sugar mistakenly expanded SEPARATOR but not STRING. +m4_define([lt_append], +[m4_define([$1], + m4_ifdef([$1], [m4_defn([$1])[$3]])[$2])]) + + + +# lt_combine(SEP, PREFIX-LIST, INFIX, SUFFIX1, [SUFFIX2...]) +# ---------------------------------------------------------- +# Produce a SEP delimited list of all paired combinations of elements of +# PREFIX-LIST with SUFFIX1 through SUFFIXn. Each element of the list +# has the form PREFIXmINFIXSUFFIXn. +# Needed until we can rely on m4_combine added in Autoconf 2.62. +m4_define([lt_combine], +[m4_if(m4_eval([$# > 3]), [1], + [m4_pushdef([_Lt_sep], [m4_define([_Lt_sep], m4_defn([lt_car]))])]]dnl +[[m4_foreach([_Lt_prefix], [$2], + [m4_foreach([_Lt_suffix], + ]m4_dquote(m4_dquote(m4_shift(m4_shift(m4_shift($@)))))[, + [_Lt_sep([$1])[]m4_defn([_Lt_prefix])[$3]m4_defn([_Lt_suffix])])])])]) + + +# lt_if_append_uniq(MACRO-NAME, VARNAME, [SEPARATOR], [UNIQ], [NOT-UNIQ]) +# ----------------------------------------------------------------------- +# Iff MACRO-NAME does not yet contain VARNAME, then append it (delimited +# by SEPARATOR if supplied) and expand UNIQ, else NOT-UNIQ. +m4_define([lt_if_append_uniq], +[m4_ifdef([$1], + [m4_if(m4_index([$3]m4_defn([$1])[$3], [$3$2$3]), [-1], + [lt_append([$1], [$2], [$3])$4], + [$5])], + [lt_append([$1], [$2], [$3])$4])]) + + +# lt_dict_add(DICT, KEY, VALUE) +# ----------------------------- +m4_define([lt_dict_add], +[m4_define([$1($2)], [$3])]) + + +# lt_dict_add_subkey(DICT, KEY, SUBKEY, VALUE) +# -------------------------------------------- +m4_define([lt_dict_add_subkey], +[m4_define([$1($2:$3)], [$4])]) + + +# lt_dict_fetch(DICT, KEY, [SUBKEY]) +# ---------------------------------- +m4_define([lt_dict_fetch], +[m4_ifval([$3], + m4_ifdef([$1($2:$3)], [m4_defn([$1($2:$3)])]), + m4_ifdef([$1($2)], [m4_defn([$1($2)])]))]) + + +# lt_if_dict_fetch(DICT, KEY, [SUBKEY], VALUE, IF-TRUE, [IF-FALSE]) +# ----------------------------------------------------------------- +m4_define([lt_if_dict_fetch], +[m4_if(lt_dict_fetch([$1], [$2], [$3]), [$4], + [$5], + [$6])]) + + +# lt_dict_filter(DICT, [SUBKEY], VALUE, [SEPARATOR], KEY, [...]) +# -------------------------------------------------------------- +m4_define([lt_dict_filter], +[m4_if([$5], [], [], + [lt_join(m4_quote(m4_default([$4], [[, ]])), + lt_unquote(m4_split(m4_normalize(m4_foreach(_Lt_key, lt_car([m4_shiftn(4, $@)]), + [lt_if_dict_fetch([$1], _Lt_key, [$2], [$3], [_Lt_key ])])))))])[]dnl +]) diff --git a/third-party/odb/libodb-sqlite-2.4.0/m4/ltversion.m4 b/third-party/odb/libodb-sqlite-2.4.0/m4/ltversion.m4 new file mode 100755 index 0000000..07a8602 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/m4/ltversion.m4 @@ -0,0 +1,23 @@ +# ltversion.m4 -- version numbers -*- Autoconf -*- +# +# Copyright (C) 2004 Free Software Foundation, Inc. +# Written by Scott James Remnant, 2004 +# +# This file is free software; the Free Software Foundation gives +# unlimited permission to copy and/or distribute it, with or without +# modifications, as long as this notice is preserved. + +# @configure_input@ + +# serial 3337 ltversion.m4 +# This file is part of GNU Libtool + +m4_define([LT_PACKAGE_VERSION], [2.4.2]) +m4_define([LT_PACKAGE_REVISION], [1.3337]) + +AC_DEFUN([LTVERSION_VERSION], +[macro_version='2.4.2' +macro_revision='1.3337' +_LT_DECL(, macro_version, 0, [Which release of libtool.m4 was used?]) +_LT_DECL(, macro_revision, 0) +]) diff --git a/third-party/odb/libodb-sqlite-2.4.0/m4/lt~obsolete.m4 b/third-party/odb/libodb-sqlite-2.4.0/m4/lt~obsolete.m4 new file mode 100755 index 0000000..c573da9 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/m4/lt~obsolete.m4 @@ -0,0 +1,98 @@ +# lt~obsolete.m4 -- aclocal satisfying obsolete definitions. -*-Autoconf-*- +# +# Copyright (C) 2004, 2005, 2007, 2009 Free Software Foundation, Inc. +# Written by Scott James Remnant, 2004. +# +# This file is free software; the Free Software Foundation gives +# unlimited permission to copy and/or distribute it, with or without +# modifications, as long as this notice is preserved. + +# serial 5 lt~obsolete.m4 + +# These exist entirely to fool aclocal when bootstrapping libtool. +# +# In the past libtool.m4 has provided macros via AC_DEFUN (or AU_DEFUN) +# which have later been changed to m4_define as they aren't part of the +# exported API, or moved to Autoconf or Automake where they belong. +# +# The trouble is, aclocal is a bit thick. It'll see the old AC_DEFUN +# in /usr/share/aclocal/libtool.m4 and remember it, then when it sees us +# using a macro with the same name in our local m4/libtool.m4 it'll +# pull the old libtool.m4 in (it doesn't see our shiny new m4_define +# and doesn't know about Autoconf macros at all.) +# +# So we provide this file, which has a silly filename so it's always +# included after everything else. This provides aclocal with the +# AC_DEFUNs it wants, but when m4 processes it, it doesn't do anything +# because those macros already exist, or will be overwritten later. +# We use AC_DEFUN over AU_DEFUN for compatibility with aclocal-1.6. +# +# Anytime we withdraw an AC_DEFUN or AU_DEFUN, remember to add it here. +# Yes, that means every name once taken will need to remain here until +# we give up compatibility with versions before 1.7, at which point +# we need to keep only those names which we still refer to. + +# This is to help aclocal find these macros, as it can't see m4_define. +AC_DEFUN([LTOBSOLETE_VERSION], [m4_if([1])]) + +m4_ifndef([AC_LIBTOOL_LINKER_OPTION], [AC_DEFUN([AC_LIBTOOL_LINKER_OPTION])]) +m4_ifndef([AC_PROG_EGREP], [AC_DEFUN([AC_PROG_EGREP])]) +m4_ifndef([_LT_AC_PROG_ECHO_BACKSLASH], [AC_DEFUN([_LT_AC_PROG_ECHO_BACKSLASH])]) +m4_ifndef([_LT_AC_SHELL_INIT], [AC_DEFUN([_LT_AC_SHELL_INIT])]) +m4_ifndef([_LT_AC_SYS_LIBPATH_AIX], [AC_DEFUN([_LT_AC_SYS_LIBPATH_AIX])]) +m4_ifndef([_LT_PROG_LTMAIN], [AC_DEFUN([_LT_PROG_LTMAIN])]) +m4_ifndef([_LT_AC_TAGVAR], [AC_DEFUN([_LT_AC_TAGVAR])]) +m4_ifndef([AC_LTDL_ENABLE_INSTALL], [AC_DEFUN([AC_LTDL_ENABLE_INSTALL])]) +m4_ifndef([AC_LTDL_PREOPEN], [AC_DEFUN([AC_LTDL_PREOPEN])]) +m4_ifndef([_LT_AC_SYS_COMPILER], [AC_DEFUN([_LT_AC_SYS_COMPILER])]) +m4_ifndef([_LT_AC_LOCK], [AC_DEFUN([_LT_AC_LOCK])]) +m4_ifndef([AC_LIBTOOL_SYS_OLD_ARCHIVE], [AC_DEFUN([AC_LIBTOOL_SYS_OLD_ARCHIVE])]) +m4_ifndef([_LT_AC_TRY_DLOPEN_SELF], [AC_DEFUN([_LT_AC_TRY_DLOPEN_SELF])]) +m4_ifndef([AC_LIBTOOL_PROG_CC_C_O], [AC_DEFUN([AC_LIBTOOL_PROG_CC_C_O])]) +m4_ifndef([AC_LIBTOOL_SYS_HARD_LINK_LOCKS], [AC_DEFUN([AC_LIBTOOL_SYS_HARD_LINK_LOCKS])]) +m4_ifndef([AC_LIBTOOL_OBJDIR], [AC_DEFUN([AC_LIBTOOL_OBJDIR])]) +m4_ifndef([AC_LTDL_OBJDIR], [AC_DEFUN([AC_LTDL_OBJDIR])]) +m4_ifndef([AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH], [AC_DEFUN([AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH])]) +m4_ifndef([AC_LIBTOOL_SYS_LIB_STRIP], [AC_DEFUN([AC_LIBTOOL_SYS_LIB_STRIP])]) +m4_ifndef([AC_PATH_MAGIC], [AC_DEFUN([AC_PATH_MAGIC])]) +m4_ifndef([AC_PROG_LD_GNU], [AC_DEFUN([AC_PROG_LD_GNU])]) +m4_ifndef([AC_PROG_LD_RELOAD_FLAG], [AC_DEFUN([AC_PROG_LD_RELOAD_FLAG])]) +m4_ifndef([AC_DEPLIBS_CHECK_METHOD], [AC_DEFUN([AC_DEPLIBS_CHECK_METHOD])]) +m4_ifndef([AC_LIBTOOL_PROG_COMPILER_NO_RTTI], [AC_DEFUN([AC_LIBTOOL_PROG_COMPILER_NO_RTTI])]) +m4_ifndef([AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE], [AC_DEFUN([AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE])]) +m4_ifndef([AC_LIBTOOL_PROG_COMPILER_PIC], [AC_DEFUN([AC_LIBTOOL_PROG_COMPILER_PIC])]) +m4_ifndef([AC_LIBTOOL_PROG_LD_SHLIBS], [AC_DEFUN([AC_LIBTOOL_PROG_LD_SHLIBS])]) +m4_ifndef([AC_LIBTOOL_POSTDEP_PREDEP], [AC_DEFUN([AC_LIBTOOL_POSTDEP_PREDEP])]) +m4_ifndef([LT_AC_PROG_EGREP], [AC_DEFUN([LT_AC_PROG_EGREP])]) +m4_ifndef([LT_AC_PROG_SED], [AC_DEFUN([LT_AC_PROG_SED])]) +m4_ifndef([_LT_CC_BASENAME], [AC_DEFUN([_LT_CC_BASENAME])]) +m4_ifndef([_LT_COMPILER_BOILERPLATE], [AC_DEFUN([_LT_COMPILER_BOILERPLATE])]) +m4_ifndef([_LT_LINKER_BOILERPLATE], [AC_DEFUN([_LT_LINKER_BOILERPLATE])]) +m4_ifndef([_AC_PROG_LIBTOOL], [AC_DEFUN([_AC_PROG_LIBTOOL])]) +m4_ifndef([AC_LIBTOOL_SETUP], [AC_DEFUN([AC_LIBTOOL_SETUP])]) +m4_ifndef([_LT_AC_CHECK_DLFCN], [AC_DEFUN([_LT_AC_CHECK_DLFCN])]) +m4_ifndef([AC_LIBTOOL_SYS_DYNAMIC_LINKER], [AC_DEFUN([AC_LIBTOOL_SYS_DYNAMIC_LINKER])]) +m4_ifndef([_LT_AC_TAGCONFIG], [AC_DEFUN([_LT_AC_TAGCONFIG])]) +m4_ifndef([AC_DISABLE_FAST_INSTALL], [AC_DEFUN([AC_DISABLE_FAST_INSTALL])]) +m4_ifndef([_LT_AC_LANG_CXX], [AC_DEFUN([_LT_AC_LANG_CXX])]) +m4_ifndef([_LT_AC_LANG_F77], [AC_DEFUN([_LT_AC_LANG_F77])]) +m4_ifndef([_LT_AC_LANG_GCJ], [AC_DEFUN([_LT_AC_LANG_GCJ])]) +m4_ifndef([AC_LIBTOOL_LANG_C_CONFIG], [AC_DEFUN([AC_LIBTOOL_LANG_C_CONFIG])]) +m4_ifndef([_LT_AC_LANG_C_CONFIG], [AC_DEFUN([_LT_AC_LANG_C_CONFIG])]) +m4_ifndef([AC_LIBTOOL_LANG_CXX_CONFIG], [AC_DEFUN([AC_LIBTOOL_LANG_CXX_CONFIG])]) +m4_ifndef([_LT_AC_LANG_CXX_CONFIG], [AC_DEFUN([_LT_AC_LANG_CXX_CONFIG])]) +m4_ifndef([AC_LIBTOOL_LANG_F77_CONFIG], [AC_DEFUN([AC_LIBTOOL_LANG_F77_CONFIG])]) +m4_ifndef([_LT_AC_LANG_F77_CONFIG], [AC_DEFUN([_LT_AC_LANG_F77_CONFIG])]) +m4_ifndef([AC_LIBTOOL_LANG_GCJ_CONFIG], [AC_DEFUN([AC_LIBTOOL_LANG_GCJ_CONFIG])]) +m4_ifndef([_LT_AC_LANG_GCJ_CONFIG], [AC_DEFUN([_LT_AC_LANG_GCJ_CONFIG])]) +m4_ifndef([AC_LIBTOOL_LANG_RC_CONFIG], [AC_DEFUN([AC_LIBTOOL_LANG_RC_CONFIG])]) +m4_ifndef([_LT_AC_LANG_RC_CONFIG], [AC_DEFUN([_LT_AC_LANG_RC_CONFIG])]) +m4_ifndef([AC_LIBTOOL_CONFIG], [AC_DEFUN([AC_LIBTOOL_CONFIG])]) +m4_ifndef([_LT_AC_FILE_LTDLL_C], [AC_DEFUN([_LT_AC_FILE_LTDLL_C])]) +m4_ifndef([_LT_REQUIRED_DARWIN_CHECKS], [AC_DEFUN([_LT_REQUIRED_DARWIN_CHECKS])]) +m4_ifndef([_LT_AC_PROG_CXXCPP], [AC_DEFUN([_LT_AC_PROG_CXXCPP])]) +m4_ifndef([_LT_PREPARE_SED_QUOTE_VARS], [AC_DEFUN([_LT_PREPARE_SED_QUOTE_VARS])]) +m4_ifndef([_LT_PROG_ECHO_BACKSLASH], [AC_DEFUN([_LT_PROG_ECHO_BACKSLASH])]) +m4_ifndef([_LT_PROG_F77], [AC_DEFUN([_LT_PROG_F77])]) +m4_ifndef([_LT_PROG_FC], [AC_DEFUN([_LT_PROG_FC])]) +m4_ifndef([_LT_PROG_CXX], [AC_DEFUN([_LT_PROG_CXX])]) diff --git a/third-party/odb/libodb-sqlite-2.4.0/m4/pkgconfig.m4 b/third-party/odb/libodb-sqlite-2.4.0/m4/pkgconfig.m4 new file mode 100755 index 0000000..63a62b5 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/m4/pkgconfig.m4 @@ -0,0 +1,12 @@ +dnl file : m4/pkgconfig.m4 +dnl copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +dnl license : GNU GPL v2; see accompanying LICENSE file +dnl +AC_DEFUN([PKGCONFIG],[ +AC_ARG_WITH( + [pkgconfigdir], + [AC_HELP_STRING([--with-pkgconfigdir=DIR],[location of pkgconfig dir (default is libdir/pkgconfig)])], + [pkgconfigdir=${withval}], + [pkgconfigdir='${libdir}/pkgconfig']) +AC_SUBST([pkgconfigdir]) +])dnl diff --git a/third-party/odb/libodb-sqlite-2.4.0/m4/static-lib.m4 b/third-party/odb/libodb-sqlite-2.4.0/m4/static-lib.m4 new file mode 100755 index 0000000..1f49f8f --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/m4/static-lib.m4 @@ -0,0 +1,18 @@ +dnl file : m4/static-lib.m4 +dnl copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +dnl license : GNU GPL v2; see accompanying LICENSE file +dnl +dnl STATIC_LIB(MACRO, DESCRIPTION) +dnl +dnl Define MACRO if we are on MinGW and are only building static library. +dnl +AC_DEFUN([STATIC_LIB], +[ +if test x$enable_shared = xno; then + case $host_os in + mingw*) + AC_DEFINE([$1], [1], [$2]) + ;; + esac +fi +])dnl diff --git a/third-party/odb/libodb-sqlite-2.4.0/m4/threads.m4 b/third-party/odb/libodb-sqlite-2.4.0/m4/threads.m4 new file mode 100755 index 0000000..f02850f --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/m4/threads.m4 @@ -0,0 +1,69 @@ +dnl file : m4/threads.m4 +dnl copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +dnl license : GNU GPL v2; see accompanying LICENSE file +dnl +AC_DEFUN([THREADS],[ + +threads_thread_keyword=no + +AC_ARG_ENABLE( + [threads], + AS_HELP_STRING([--disable-threads], [disable threads (enabled by default)]), + [AS_IF([test x"$enableval" = xno], [threads=none], [threads=check])], + [threads=check]) + +# If thread support is not disabled by the user, figure out what we can use. +# +if test x$threads = xcheck; then + case $host_os in + windows* | mingw*) + case $host_os in + mingw*) + CXXFLAGS="$CXXFLAGS -mthreads" + ;; + esac + + # Newer versions of GCC can be configured to use either Win32 or POSIX + # threads. It appears that -mthreads should be used in both cases but + # if the model is POSIX then GCC will also link -lpthread by default. + # Use that fact to test which model we have. + # + AC_TRY_LINK([#include ], + [pthread_create(0,0,0,0);], + [threads=posix], + [threads=win32]) + ;; + *) + ACX_PTHREAD + + if test x$acx_pthread_ok = xyes; then + threads=posix + LIBS="$LIBS $PTHREAD_LIBS" + CXXFLAGS="$CXXFLAGS $PTHREAD_CXXFLAGS" + + # Check if we can use the __thread keyword. + # + AC_MSG_CHECKING([for __thread keyword]) + + CXX_LIBTOOL_LINK_IFELSE([ + AC_LANG_SOURCE([ + __thread int tls_var; + + int + main () + { + tls_var = 0; + } + ])], + [threads_thread_keyword=yes]) + + AC_MSG_RESULT([$threads_thread_keyword]) + fi + ;; + esac +fi + +if test x$threads = xcheck; then + AC_MSG_ERROR([thread support not available; use --disable-threads to force single-threaded mode]) +fi +])dnl diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/Makefile.am b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/Makefile.am new file mode 100755 index 0000000..7d7ff7b --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/Makefile.am @@ -0,0 +1,15 @@ +# file : odb/sqlite/Makefile.am +# copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +# license : GNU GPL v2; see accompanying LICENSE file + +lib_LTLIBRARIES = libodb-sqlite.la +libodb_sqlite_la_SOURCES = connection.cxx connection-factory.cxx database.cxx error.cxx exceptions.cxx prepared-query.cxx query.cxx query-dynamic.cxx query-const-expr.cxx simple-object-statements.cxx statement.cxx statements-base.cxx statement-cache.cxx tracer.cxx traits.cxx transaction.cxx transaction-impl.cxx details/options.cxx + +odbsqliteincludedir = $(includedir)/odb/sqlite/ +nobase_odbsqliteinclude_HEADERS = auto-handle.hxx binding.hxx connection-factory.hxx connection.hxx connection.ixx container-statements.hxx container-statements.txx database.hxx database.ixx details/config.hxx details/conversion.hxx details/export.hxx details/options.hxx details/options.ixx error.hxx exceptions.hxx forward.hxx no-id-object-result.hxx no-id-object-result.txx no-id-object-statements.hxx no-id-object-statements.txx polymorphic-object-result.hxx polymorphic-object-result.txx polymorphic-object-statements.hxx polymorphic-object-statements.txx prepared-query.hxx query-dynamic.hxx query-dynamic.ixx query-dynamic.txx query.hxx query.ixx query.txx section-statements.hxx section-statements.txx simple-object-result.hxx simple-object-result.txx simple-object-statements.hxx simple-object-statements.ixx simple-object-statements.txx sqlite-types.hxx statement-cache.hxx statement-cache.txx statement.hxx statements-base.hxx tracer.hxx traits-calls.hxx traits.hxx transaction-impl.hxx transaction-impl.ixx transaction.hxx transaction.ixx version.hxx view-result.hxx view-result.txx view-statements.hxx view-statements.txx +nobase_nodist_odbsqliteinclude_HEADERS = details/config.h + +EXTRA_DIST = details/options.cli details/config.h.in libodb-sqlite-vc8.vcproj libodb-sqlite-vc9.vcproj libodb-sqlite-vc10.vcxproj libodb-sqlite-vc10.vcxproj.filters libodb-sqlite-vc11.vcxproj libodb-sqlite-vc11.vcxproj.filters libodb-sqlite-vc12.vcxproj libodb-sqlite-vc12.vcxproj.filters + +AM_CPPFLAGS= -I'$(top_builddir)' -I'$(top_srcdir)' -DLIBODB_SQLITE_DYNAMIC_LIB +AM_LDFLAGS = -release 2.4 -no-undefined diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/Makefile.in b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/Makefile.in new file mode 100755 index 0000000..755e90d --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/Makefile.in @@ -0,0 +1,727 @@ +# Makefile.in generated by automake 1.12.6 from Makefile.am. +# @configure_input@ + +# Copyright (C) 1994-2012 Free Software Foundation, Inc. + +# This Makefile.in is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY, to the extent permitted by law; without +# even the implied warranty of MERCHANTABILITY or FITNESS FOR A +# PARTICULAR PURPOSE. + +@SET_MAKE@ + +# file : odb/sqlite/Makefile.am +# copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +# license : GNU GPL v2; see accompanying LICENSE file + + +VPATH = @srcdir@ +am__make_dryrun = \ + { \ + am__dry=no; \ + case $$MAKEFLAGS in \ + *\\[\ \ ]*) \ + echo 'am--echo: ; @echo "AM" OK' | $(MAKE) -f - 2>/dev/null \ + | grep '^AM OK$$' >/dev/null || am__dry=yes;; \ + *) \ + for am__flg in $$MAKEFLAGS; do \ + case $$am__flg in \ + *=*|--*) ;; \ + *n*) am__dry=yes; break;; \ + esac; \ + done;; \ + esac; \ + test $$am__dry = yes; \ + } +pkgdatadir = $(datadir)/@PACKAGE@ +pkgincludedir = $(includedir)/@PACKAGE@ +pkglibdir = $(libdir)/@PACKAGE@ +pkglibexecdir = $(libexecdir)/@PACKAGE@ +am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd +install_sh_DATA = $(install_sh) -c -m 644 +install_sh_PROGRAM = $(install_sh) -c +install_sh_SCRIPT = $(install_sh) -c +INSTALL_HEADER = $(INSTALL_DATA) +transform = $(program_transform_name) +NORMAL_INSTALL = : +PRE_INSTALL = : +POST_INSTALL = : +NORMAL_UNINSTALL = : +PRE_UNINSTALL = : +POST_UNINSTALL = : +build_triplet = @build@ +host_triplet = @host@ +subdir = odb/sqlite +DIST_COMMON = $(nobase_odbsqliteinclude_HEADERS) $(srcdir)/Makefile.am \ + $(srcdir)/Makefile.in $(srcdir)/config.h.in \ + $(top_srcdir)/config/depcomp +ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 +am__aclocal_m4_deps = $(top_srcdir)/m4/acx-pthread.m4 \ + $(top_srcdir)/m4/disable-rpath.m4 $(top_srcdir)/m4/libodb.m4 \ + $(top_srcdir)/m4/libsqlite.m4 $(top_srcdir)/m4/libtool-link.m4 \ + $(top_srcdir)/m4/libtool.m4 $(top_srcdir)/m4/ltoptions.m4 \ + $(top_srcdir)/m4/ltsugar.m4 $(top_srcdir)/m4/ltversion.m4 \ + $(top_srcdir)/m4/lt~obsolete.m4 $(top_srcdir)/m4/pkgconfig.m4 \ + $(top_srcdir)/m4/static-lib.m4 $(top_srcdir)/m4/threads.m4 \ + $(top_srcdir)/configure.ac +am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \ + $(ACLOCAL_M4) +mkinstalldirs = $(install_sh) -d +CONFIG_HEADER = config.h $(top_builddir)/odb/sqlite/details/config.h +CONFIG_CLEAN_FILES = +CONFIG_CLEAN_VPATH_FILES = +am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`; +am__vpath_adj = case $$p in \ + $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \ + *) f=$$p;; \ + esac; +am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`; +am__install_max = 40 +am__nobase_strip_setup = \ + srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'` +am__nobase_strip = \ + for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||" +am__nobase_list = $(am__nobase_strip_setup); \ + for p in $$list; do echo "$$p $$p"; done | \ + sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \ + $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \ + if (++n[$$2] == $(am__install_max)) \ + { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \ + END { for (dir in files) print dir, files[dir] }' +am__base_list = \ + sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \ + sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g' +am__uninstall_files_from_dir = { \ + test -z "$$files" \ + || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \ + || { echo " ( cd '$$dir' && rm -f" $$files ")"; \ + $(am__cd) "$$dir" && rm -f $$files; }; \ + } +am__installdirs = "$(DESTDIR)$(libdir)" \ + "$(DESTDIR)$(odbsqliteincludedir)" \ + "$(DESTDIR)$(odbsqliteincludedir)" +LTLIBRARIES = $(lib_LTLIBRARIES) +libodb_sqlite_la_LIBADD = +am__dirstamp = $(am__leading_dot)dirstamp +am_libodb_sqlite_la_OBJECTS = connection.lo connection-factory.lo \ + database.lo error.lo exceptions.lo prepared-query.lo query.lo \ + query-dynamic.lo query-const-expr.lo \ + simple-object-statements.lo statement.lo statements-base.lo \ + statement-cache.lo tracer.lo traits.lo transaction.lo \ + transaction-impl.lo details/options.lo +libodb_sqlite_la_OBJECTS = $(am_libodb_sqlite_la_OBJECTS) +DEFAULT_INCLUDES = +depcomp = $(SHELL) $(top_srcdir)/config/depcomp +am__depfiles_maybe = depfiles +am__mv = mv -f +CXXCOMPILE = $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \ + $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) +LTCXXCOMPILE = $(LIBTOOL) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \ + --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \ + $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) +CXXLD = $(CXX) +CXXLINK = $(LIBTOOL) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \ + --mode=link $(CXXLD) $(AM_CXXFLAGS) $(CXXFLAGS) $(AM_LDFLAGS) \ + $(LDFLAGS) -o $@ +SOURCES = $(libodb_sqlite_la_SOURCES) +DIST_SOURCES = $(libodb_sqlite_la_SOURCES) +am__can_run_installinfo = \ + case $$AM_UPDATE_INFO_DIR in \ + n|no|NO) false;; \ + *) (install-info --version) >/dev/null 2>&1;; \ + esac +HEADERS = $(nobase_nodist_odbsqliteinclude_HEADERS) \ + $(nobase_odbsqliteinclude_HEADERS) +ETAGS = etags +CTAGS = ctags +DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) +ACLOCAL = @ACLOCAL@ +AMTAR = @AMTAR@ +AR = @AR@ +AS = @AS@ +AUTOCONF = @AUTOCONF@ +AUTOHEADER = @AUTOHEADER@ +AUTOMAKE = @AUTOMAKE@ +AWK = @AWK@ +CC = @CC@ +CCDEPMODE = @CCDEPMODE@ +CFLAGS = @CFLAGS@ +CPP = @CPP@ +CPPFLAGS = @CPPFLAGS@ +CXX = @CXX@ +CXXCPP = @CXXCPP@ +CXXDEPMODE = @CXXDEPMODE@ +CXXFLAGS = @CXXFLAGS@ +CYGPATH_W = @CYGPATH_W@ +DEFS = @DEFS@ +DEPDIR = @DEPDIR@ +DLLTOOL = @DLLTOOL@ +DSYMUTIL = @DSYMUTIL@ +DUMPBIN = @DUMPBIN@ +ECHO_C = @ECHO_C@ +ECHO_N = @ECHO_N@ +ECHO_T = @ECHO_T@ +EGREP = @EGREP@ +EXEEXT = @EXEEXT@ +FGREP = @FGREP@ +GREP = @GREP@ +INSTALL = @INSTALL@ +INSTALL_DATA = @INSTALL_DATA@ +INSTALL_PROGRAM = @INSTALL_PROGRAM@ +INSTALL_SCRIPT = @INSTALL_SCRIPT@ +INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@ +LD = @LD@ +LDFLAGS = @LDFLAGS@ +LIBOBJS = @LIBOBJS@ +LIBS = @LIBS@ +LIBTOOL = @LIBTOOL@ +LIPO = @LIPO@ +LN_S = @LN_S@ +LTLIBOBJS = @LTLIBOBJS@ +MAKEINFO = @MAKEINFO@ +MANIFEST_TOOL = @MANIFEST_TOOL@ +MKDIR_P = @MKDIR_P@ +NM = @NM@ +NMEDIT = @NMEDIT@ +OBJDUMP = @OBJDUMP@ +OBJEXT = @OBJEXT@ +OTOOL = @OTOOL@ +OTOOL64 = @OTOOL64@ +PACKAGE = @PACKAGE@ +PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@ +PACKAGE_NAME = @PACKAGE_NAME@ +PACKAGE_STRING = @PACKAGE_STRING@ +PACKAGE_TARNAME = @PACKAGE_TARNAME@ +PACKAGE_URL = @PACKAGE_URL@ +PACKAGE_VERSION = @PACKAGE_VERSION@ +PATH_SEPARATOR = @PATH_SEPARATOR@ +PTHREAD_CXX = @PTHREAD_CXX@ +PTHREAD_CXXFLAGS = @PTHREAD_CXXFLAGS@ +PTHREAD_LIBS = @PTHREAD_LIBS@ +RANLIB = @RANLIB@ +SED = @SED@ +SET_MAKE = @SET_MAKE@ +SHELL = @SHELL@ +STRIP = @STRIP@ +VERSION = @VERSION@ +abs_builddir = @abs_builddir@ +abs_srcdir = @abs_srcdir@ +abs_top_builddir = @abs_top_builddir@ +abs_top_srcdir = @abs_top_srcdir@ +ac_ct_AR = @ac_ct_AR@ +ac_ct_CC = @ac_ct_CC@ +ac_ct_CXX = @ac_ct_CXX@ +ac_ct_DUMPBIN = @ac_ct_DUMPBIN@ +acx_pthread_config = @acx_pthread_config@ +am__include = @am__include@ +am__leading_dot = @am__leading_dot@ +am__quote = @am__quote@ +am__tar = @am__tar@ +am__untar = @am__untar@ +bindir = @bindir@ +build = @build@ +build_alias = @build_alias@ +build_cpu = @build_cpu@ +build_os = @build_os@ +build_vendor = @build_vendor@ +builddir = @builddir@ +datadir = @datadir@ +datarootdir = @datarootdir@ +docdir = @docdir@ +dvidir = @dvidir@ +exec_prefix = @exec_prefix@ +host = @host@ +host_alias = @host_alias@ +host_cpu = @host_cpu@ +host_os = @host_os@ +host_vendor = @host_vendor@ +htmldir = @htmldir@ +includedir = @includedir@ +infodir = @infodir@ +install_sh = @install_sh@ +libdir = @libdir@ +libexecdir = @libexecdir@ +localedir = @localedir@ +localstatedir = @localstatedir@ +mandir = @mandir@ +mkdir_p = @mkdir_p@ +oldincludedir = @oldincludedir@ +pdfdir = @pdfdir@ +pkgconfigdir = @pkgconfigdir@ +prefix = @prefix@ +program_transform_name = @program_transform_name@ +psdir = @psdir@ +sbindir = @sbindir@ +sharedstatedir = @sharedstatedir@ +srcdir = @srcdir@ +sysconfdir = @sysconfdir@ +target_alias = @target_alias@ +top_build_prefix = @top_build_prefix@ +top_builddir = @top_builddir@ +top_srcdir = @top_srcdir@ +lib_LTLIBRARIES = libodb-sqlite.la +libodb_sqlite_la_SOURCES = connection.cxx connection-factory.cxx database.cxx error.cxx exceptions.cxx prepared-query.cxx query.cxx query-dynamic.cxx query-const-expr.cxx simple-object-statements.cxx statement.cxx statements-base.cxx statement-cache.cxx tracer.cxx traits.cxx transaction.cxx transaction-impl.cxx details/options.cxx +odbsqliteincludedir = $(includedir)/odb/sqlite/ +nobase_odbsqliteinclude_HEADERS = auto-handle.hxx binding.hxx \ + connection-factory.hxx connection.hxx connection.ixx \ + container-statements.hxx container-statements.txx database.hxx \ + database.ixx details/config.hxx details/conversion.hxx \ + details/export.hxx details/options.hxx details/options.ixx \ + error.hxx exceptions.hxx forward.hxx no-id-object-result.hxx \ + no-id-object-result.txx no-id-object-statements.hxx \ + no-id-object-statements.txx polymorphic-object-result.hxx \ + polymorphic-object-result.txx \ + polymorphic-object-statements.hxx \ + polymorphic-object-statements.txx prepared-query.hxx \ + query-dynamic.hxx query-dynamic.ixx query-dynamic.txx \ + query.hxx query.ixx query.txx section-statements.hxx \ + section-statements.txx simple-object-result.hxx \ + simple-object-result.txx simple-object-statements.hxx \ + simple-object-statements.ixx simple-object-statements.txx \ + sqlite-types.hxx statement-cache.hxx statement-cache.txx \ + statement.hxx statements-base.hxx tracer.hxx traits-calls.hxx \ + traits.hxx transaction-impl.hxx transaction-impl.ixx \ + transaction.hxx transaction.ixx version.hxx view-result.hxx \ + view-result.txx view-statements.hxx view-statements.txx +nobase_nodist_odbsqliteinclude_HEADERS = details/config.h +EXTRA_DIST = details/options.cli details/config.h.in libodb-sqlite-vc8.vcproj libodb-sqlite-vc9.vcproj libodb-sqlite-vc10.vcxproj libodb-sqlite-vc10.vcxproj.filters libodb-sqlite-vc11.vcxproj libodb-sqlite-vc11.vcxproj.filters libodb-sqlite-vc12.vcxproj libodb-sqlite-vc12.vcxproj.filters +AM_CPPFLAGS = -I'$(top_builddir)' -I'$(top_srcdir)' -DLIBODB_SQLITE_DYNAMIC_LIB +AM_LDFLAGS = -release 2.4 -no-undefined +all: config.h + $(MAKE) $(AM_MAKEFLAGS) all-am + +.SUFFIXES: +.SUFFIXES: .cxx .lo .o .obj +$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps) + @for dep in $?; do \ + case '$(am__configure_deps)' in \ + *$$dep*) \ + ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \ + && { if test -f $@; then exit 0; else break; fi; }; \ + exit 1;; \ + esac; \ + done; \ + echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign odb/sqlite/Makefile'; \ + $(am__cd) $(top_srcdir) && \ + $(AUTOMAKE) --foreign odb/sqlite/Makefile +.PRECIOUS: Makefile +Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status + @case '$?' in \ + *config.status*) \ + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \ + *) \ + echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \ + cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \ + esac; + +$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh + +$(top_srcdir)/configure: $(am__configure_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(ACLOCAL_M4): $(am__aclocal_m4_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(am__aclocal_m4_deps): + +config.h: stamp-h1 + @if test ! -f $@; then rm -f stamp-h1; else :; fi + @if test ! -f $@; then $(MAKE) $(AM_MAKEFLAGS) stamp-h1; else :; fi + +stamp-h1: $(srcdir)/config.h.in $(top_builddir)/config.status + @rm -f stamp-h1 + cd $(top_builddir) && $(SHELL) ./config.status odb/sqlite/config.h +$(srcdir)/config.h.in: $(am__configure_deps) + ($(am__cd) $(top_srcdir) && $(AUTOHEADER)) + rm -f stamp-h1 + touch $@ + +distclean-hdr: + -rm -f config.h stamp-h1 +install-libLTLIBRARIES: $(lib_LTLIBRARIES) + @$(NORMAL_INSTALL) + @list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \ + list2=; for p in $$list; do \ + if test -f $$p; then \ + list2="$$list2 $$p"; \ + else :; fi; \ + done; \ + test -z "$$list2" || { \ + echo " $(MKDIR_P) '$(DESTDIR)$(libdir)'"; \ + $(MKDIR_P) "$(DESTDIR)$(libdir)" || exit 1; \ + echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 '$(DESTDIR)$(libdir)'"; \ + $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 "$(DESTDIR)$(libdir)"; \ + } + +uninstall-libLTLIBRARIES: + @$(NORMAL_UNINSTALL) + @list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \ + for p in $$list; do \ + $(am__strip_dir) \ + echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f '$(DESTDIR)$(libdir)/$$f'"; \ + $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f "$(DESTDIR)$(libdir)/$$f"; \ + done + +clean-libLTLIBRARIES: + -test -z "$(lib_LTLIBRARIES)" || rm -f $(lib_LTLIBRARIES) + @list='$(lib_LTLIBRARIES)'; \ + locs=`for p in $$list; do echo $$p; done | \ + sed 's|^[^/]*$$|.|; s|/[^/]*$$||; s|$$|/so_locations|' | \ + sort -u`; \ + test -z "$$locs" || { \ + echo rm -f $${locs}; \ + rm -f $${locs}; \ + } +details/$(am__dirstamp): + @$(MKDIR_P) details + @: > details/$(am__dirstamp) +details/$(DEPDIR)/$(am__dirstamp): + @$(MKDIR_P) details/$(DEPDIR) + @: > details/$(DEPDIR)/$(am__dirstamp) +details/options.lo: details/$(am__dirstamp) \ + details/$(DEPDIR)/$(am__dirstamp) +libodb-sqlite.la: $(libodb_sqlite_la_OBJECTS) $(libodb_sqlite_la_DEPENDENCIES) $(EXTRA_libodb_sqlite_la_DEPENDENCIES) + $(CXXLINK) -rpath $(libdir) $(libodb_sqlite_la_OBJECTS) $(libodb_sqlite_la_LIBADD) $(LIBS) + +mostlyclean-compile: + -rm -f *.$(OBJEXT) + -rm -f details/*.$(OBJEXT) + -rm -f details/*.lo + +distclean-compile: + -rm -f *.tab.c + +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/connection-factory.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/connection.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/database.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/error.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/exceptions.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/prepared-query.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/query-const-expr.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/query-dynamic.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/query.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/simple-object-statements.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/statement-cache.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/statement.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/statements-base.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/tracer.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/traits.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/transaction-impl.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/transaction.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@details/$(DEPDIR)/options.Plo@am__quote@ + +.cxx.o: +@am__fastdepCXX_TRUE@ depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.o$$||'`;\ +@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\ +@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(CXXCOMPILE) -c -o $@ $< + +.cxx.obj: +@am__fastdepCXX_TRUE@ depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.obj$$||'`;\ +@am__fastdepCXX_TRUE@ $(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\ +@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'` + +.cxx.lo: +@am__fastdepCXX_TRUE@ depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.lo$$||'`;\ +@am__fastdepCXX_TRUE@ $(LTCXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\ +@am__fastdepCXX_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Plo +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(LTCXXCOMPILE) -c -o $@ $< + +mostlyclean-libtool: + -rm -f *.lo + +clean-libtool: + -rm -rf .libs _libs + -rm -rf details/.libs details/_libs +install-nobase_nodist_odbsqliteincludeHEADERS: $(nobase_nodist_odbsqliteinclude_HEADERS) + @$(NORMAL_INSTALL) + @list='$(nobase_nodist_odbsqliteinclude_HEADERS)'; test -n "$(odbsqliteincludedir)" || list=; \ + if test -n "$$list"; then \ + echo " $(MKDIR_P) '$(DESTDIR)$(odbsqliteincludedir)'"; \ + $(MKDIR_P) "$(DESTDIR)$(odbsqliteincludedir)" || exit 1; \ + fi; \ + $(am__nobase_list) | while read dir files; do \ + xfiles=; for file in $$files; do \ + if test -f "$$file"; then xfiles="$$xfiles $$file"; \ + else xfiles="$$xfiles $(srcdir)/$$file"; fi; done; \ + test -z "$$xfiles" || { \ + test "x$$dir" = x. || { \ + echo " $(MKDIR_P) '$(DESTDIR)$(odbsqliteincludedir)/$$dir'"; \ + $(MKDIR_P) "$(DESTDIR)$(odbsqliteincludedir)/$$dir"; }; \ + echo " $(INSTALL_HEADER) $$xfiles '$(DESTDIR)$(odbsqliteincludedir)/$$dir'"; \ + $(INSTALL_HEADER) $$xfiles "$(DESTDIR)$(odbsqliteincludedir)/$$dir" || exit $$?; }; \ + done + +uninstall-nobase_nodist_odbsqliteincludeHEADERS: + @$(NORMAL_UNINSTALL) + @list='$(nobase_nodist_odbsqliteinclude_HEADERS)'; test -n "$(odbsqliteincludedir)" || list=; \ + $(am__nobase_strip_setup); files=`$(am__nobase_strip)`; \ + dir='$(DESTDIR)$(odbsqliteincludedir)'; $(am__uninstall_files_from_dir) +install-nobase_odbsqliteincludeHEADERS: $(nobase_odbsqliteinclude_HEADERS) + @$(NORMAL_INSTALL) + @list='$(nobase_odbsqliteinclude_HEADERS)'; test -n "$(odbsqliteincludedir)" || list=; \ + if test -n "$$list"; then \ + echo " $(MKDIR_P) '$(DESTDIR)$(odbsqliteincludedir)'"; \ + $(MKDIR_P) "$(DESTDIR)$(odbsqliteincludedir)" || exit 1; \ + fi; \ + $(am__nobase_list) | while read dir files; do \ + xfiles=; for file in $$files; do \ + if test -f "$$file"; then xfiles="$$xfiles $$file"; \ + else xfiles="$$xfiles $(srcdir)/$$file"; fi; done; \ + test -z "$$xfiles" || { \ + test "x$$dir" = x. || { \ + echo " $(MKDIR_P) '$(DESTDIR)$(odbsqliteincludedir)/$$dir'"; \ + $(MKDIR_P) "$(DESTDIR)$(odbsqliteincludedir)/$$dir"; }; \ + echo " $(INSTALL_HEADER) $$xfiles '$(DESTDIR)$(odbsqliteincludedir)/$$dir'"; \ + $(INSTALL_HEADER) $$xfiles "$(DESTDIR)$(odbsqliteincludedir)/$$dir" || exit $$?; }; \ + done + +uninstall-nobase_odbsqliteincludeHEADERS: + @$(NORMAL_UNINSTALL) + @list='$(nobase_odbsqliteinclude_HEADERS)'; test -n "$(odbsqliteincludedir)" || list=; \ + $(am__nobase_strip_setup); files=`$(am__nobase_strip)`; \ + dir='$(DESTDIR)$(odbsqliteincludedir)'; $(am__uninstall_files_from_dir) + +ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES) + list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | \ + $(AWK) '{ files[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in files) print i; }; }'`; \ + mkid -fID $$unique +tags: TAGS + +TAGS: $(HEADERS) $(SOURCES) config.h.in $(TAGS_DEPENDENCIES) \ + $(TAGS_FILES) $(LISP) + set x; \ + here=`pwd`; \ + list='$(SOURCES) $(HEADERS) config.h.in $(LISP) $(TAGS_FILES)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | \ + $(AWK) '{ files[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in files) print i; }; }'`; \ + shift; \ + if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \ + test -n "$$unique" || unique=$$empty_fix; \ + if test $$# -gt 0; then \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + "$$@" $$unique; \ + else \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + $$unique; \ + fi; \ + fi +ctags: CTAGS +CTAGS: $(HEADERS) $(SOURCES) config.h.in $(TAGS_DEPENDENCIES) \ + $(TAGS_FILES) $(LISP) + list='$(SOURCES) $(HEADERS) config.h.in $(LISP) $(TAGS_FILES)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | \ + $(AWK) '{ files[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in files) print i; }; }'`; \ + test -z "$(CTAGS_ARGS)$$unique" \ + || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \ + $$unique + +GTAGS: + here=`$(am__cd) $(top_builddir) && pwd` \ + && $(am__cd) $(top_srcdir) \ + && gtags -i $(GTAGS_ARGS) "$$here" + +cscopelist: $(HEADERS) $(SOURCES) $(LISP) + list='$(SOURCES) $(HEADERS) $(LISP)'; \ + case "$(srcdir)" in \ + [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \ + *) sdir=$(subdir)/$(srcdir) ;; \ + esac; \ + for i in $$list; do \ + if test -f "$$i"; then \ + echo "$(subdir)/$$i"; \ + else \ + echo "$$sdir/$$i"; \ + fi; \ + done >> $(top_builddir)/cscope.files + +distclean-tags: + -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags + +distdir: $(DISTFILES) + @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + list='$(DISTFILES)'; \ + dist_files=`for file in $$list; do echo $$file; done | \ + sed -e "s|^$$srcdirstrip/||;t" \ + -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \ + case $$dist_files in \ + */*) $(MKDIR_P) `echo "$$dist_files" | \ + sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \ + sort -u` ;; \ + esac; \ + for file in $$dist_files; do \ + if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \ + if test -d $$d/$$file; then \ + dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \ + if test -d "$(distdir)/$$file"; then \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \ + cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \ + else \ + test -f "$(distdir)/$$file" \ + || cp -p $$d/$$file "$(distdir)/$$file" \ + || exit 1; \ + fi; \ + done +check-am: all-am +check: check-am +all-am: Makefile $(LTLIBRARIES) $(HEADERS) config.h +installdirs: + for dir in "$(DESTDIR)$(libdir)" "$(DESTDIR)$(odbsqliteincludedir)" "$(DESTDIR)$(odbsqliteincludedir)"; do \ + test -z "$$dir" || $(MKDIR_P) "$$dir"; \ + done +install: install-am +install-exec: install-exec-am +install-data: install-data-am +uninstall: uninstall-am + +install-am: all-am + @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am + +installcheck: installcheck-am +install-strip: + if test -z '$(STRIP)'; then \ + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + install; \ + else \ + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \ + fi +mostlyclean-generic: + +clean-generic: + +distclean-generic: + -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES) + -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES) + -rm -f details/$(DEPDIR)/$(am__dirstamp) + -rm -f details/$(am__dirstamp) + +maintainer-clean-generic: + @echo "This command is intended for maintainers to use" + @echo "it deletes files that may require special tools to rebuild." +clean: clean-am + +clean-am: clean-generic clean-libLTLIBRARIES clean-libtool \ + mostlyclean-am + +distclean: distclean-am + -rm -rf ./$(DEPDIR) details/$(DEPDIR) + -rm -f Makefile +distclean-am: clean-am distclean-compile distclean-generic \ + distclean-hdr distclean-tags + +dvi: dvi-am + +dvi-am: + +html: html-am + +html-am: + +info: info-am + +info-am: + +install-data-am: install-nobase_nodist_odbsqliteincludeHEADERS \ + install-nobase_odbsqliteincludeHEADERS + +install-dvi: install-dvi-am + +install-dvi-am: + +install-exec-am: install-libLTLIBRARIES + +install-html: install-html-am + +install-html-am: + +install-info: install-info-am + +install-info-am: + +install-man: + +install-pdf: install-pdf-am + +install-pdf-am: + +install-ps: install-ps-am + +install-ps-am: + +installcheck-am: + +maintainer-clean: maintainer-clean-am + -rm -rf ./$(DEPDIR) details/$(DEPDIR) + -rm -f Makefile +maintainer-clean-am: distclean-am maintainer-clean-generic + +mostlyclean: mostlyclean-am + +mostlyclean-am: mostlyclean-compile mostlyclean-generic \ + mostlyclean-libtool + +pdf: pdf-am + +pdf-am: + +ps: ps-am + +ps-am: + +uninstall-am: uninstall-libLTLIBRARIES \ + uninstall-nobase_nodist_odbsqliteincludeHEADERS \ + uninstall-nobase_odbsqliteincludeHEADERS + +.MAKE: all install-am install-strip + +.PHONY: CTAGS GTAGS all all-am check check-am clean clean-generic \ + clean-libLTLIBRARIES clean-libtool cscopelist ctags distclean \ + distclean-compile distclean-generic distclean-hdr \ + distclean-libtool distclean-tags distdir dvi dvi-am html \ + html-am info info-am install install-am install-data \ + install-data-am install-dvi install-dvi-am install-exec \ + install-exec-am install-html install-html-am install-info \ + install-info-am install-libLTLIBRARIES install-man \ + install-nobase_nodist_odbsqliteincludeHEADERS \ + install-nobase_odbsqliteincludeHEADERS install-pdf \ + install-pdf-am install-ps install-ps-am install-strip \ + installcheck installcheck-am installdirs maintainer-clean \ + maintainer-clean-generic mostlyclean mostlyclean-compile \ + mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \ + tags uninstall uninstall-am uninstall-libLTLIBRARIES \ + uninstall-nobase_nodist_odbsqliteincludeHEADERS \ + uninstall-nobase_odbsqliteincludeHEADERS + + +# Tell versions [3.59,3.63) of GNU make to not export all variables. +# Otherwise a system limit (for SysV at least) may be exceeded. +.NOEXPORT: diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/auto-handle.hxx b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/auto-handle.hxx new file mode 100755 index 0000000..3a42099 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/auto-handle.hxx @@ -0,0 +1,102 @@ +// file : odb/sqlite/auto-handle.hxx +// copyright : Copyright (c) 2005-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_SQLITE_AUTO_HANDLE_HXX +#define ODB_SQLITE_AUTO_HANDLE_HXX + +#include + +#include +#include + +#include + +namespace odb +{ + namespace sqlite + { + template + struct handle_traits; + + template <> + struct handle_traits + { + static void + release (sqlite3* h) + { + if (sqlite3_close (h) == SQLITE_BUSY) + { + // Connection has outstanding prepared statements. + // + assert (false); + } + } + }; + + template <> + struct handle_traits + { + static void + release (sqlite3_stmt* h) + { + sqlite3_finalize (h); + } + }; + + template + class auto_handle + { + public: + auto_handle (H* h = 0) + : h_ (h) + { + } + + ~auto_handle () + { + if (h_ != 0) + handle_traits::release (h_); + } + + H* + get () const + { + return h_; + } + + void + reset (H* h = 0) + { + if (h_ != 0) + handle_traits::release (h_); + + h_ = h; + } + + H* + release () + { + H* h (h_); + h_ = 0; + return h; + } + + operator H* () const + { + return h_; + } + + private: + auto_handle (const auto_handle&); + auto_handle& operator= (const auto_handle&); + + private: + H* h_; + }; + } +} + +#include + +#endif // ODB_SQLITE_AUTO_HANDLE_HXX diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/binding.hxx b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/binding.hxx new file mode 100755 index 0000000..f6cef5b --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/binding.hxx @@ -0,0 +1,46 @@ +// file : odb/sqlite/binding.hxx +// copyright : Copyright (c) 2005-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_SQLITE_BINDING_HXX +#define ODB_SQLITE_BINDING_HXX + +#include + +#include // std::size_t + +#include + +#include +#include + +namespace odb +{ + namespace sqlite + { + class LIBODB_SQLITE_EXPORT binding + { + public: + typedef sqlite::bind bind_type; + + binding (): bind (0), count (0), version (0) {} + + binding (bind_type* b, std::size_t n) + : bind (b), count (n), version (0) + { + } + + bind_type* bind; + std::size_t count; + std::size_t version; + + private: + binding (const binding&); + binding& operator= (const binding&); + }; + } +} + +#include + +#endif // ODB_SQLITE_BINDING_HXX diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/config.h.in b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/config.h.in new file mode 100755 index 0000000..689cda1 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/config.h.in @@ -0,0 +1,71 @@ +/* odb/sqlite/config.h.in. Generated from configure.ac by autoheader. */ + +/* Define to 1 if you have the header file. */ +#undef HAVE_DLFCN_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_INTTYPES_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_MEMORY_H + +/* Define if you have POSIX threads libraries and header files. */ +#undef HAVE_PTHREAD + +/* Define to 1 if you have the header file. */ +#undef HAVE_STDINT_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_STDLIB_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_STRINGS_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_STRING_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_SYS_STAT_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_SYS_TYPES_H + +/* Define to 1 if you have the header file. */ +#undef HAVE_UNISTD_H + +/* Have sqlite3_unlock_notify. */ +#undef LIBODB_SQLITE_HAVE_UNLOCK_NOTIFY + +/* Static library interface. */ +#undef LIBODB_SQLITE_STATIC_LIB + +/* Define to the sub-directory in which libtool stores uninstalled libraries. + */ +#undef LT_OBJDIR + +/* Name of package */ +#undef PACKAGE + +/* Define to the address where bug reports for this package should be sent. */ +#undef PACKAGE_BUGREPORT + +/* Define to the full name of this package. */ +#undef PACKAGE_NAME + +/* Define to the full name and version of this package. */ +#undef PACKAGE_STRING + +/* Define to the one symbol short name of this package. */ +#undef PACKAGE_TARNAME + +/* Define to the home page for this package. */ +#undef PACKAGE_URL + +/* Define to the version of this package. */ +#undef PACKAGE_VERSION + +/* Define to 1 if you have the ANSI C header files. */ +#undef STDC_HEADERS + +/* Version number of package */ +#undef VERSION diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/connection-factory.cxx b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/connection-factory.cxx new file mode 100755 index 0000000..c40190a --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/connection-factory.cxx @@ -0,0 +1,268 @@ +// file : odb/sqlite/connection-factory.cxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include + +#include +#include + +#include // LIBODB_SQLITE_HAVE_UNLOCK_NOTIFY + +using namespace std; + +namespace odb +{ + using namespace details; + + namespace sqlite + { + // + // connection_factory + // + + connection_factory:: + ~connection_factory () + { + } + + // + // single_connection_factory + // + + single_connection_factory:: + ~single_connection_factory () + { + // If the connection is currently in use, wait for it to return to + // the factory. + // + lock l (mutex_); + } + + single_connection_factory::single_connection_ptr + single_connection_factory:: + create () + { + return single_connection_ptr (new (shared) single_connection (*db_)); + } + + connection_ptr single_connection_factory:: + connect () + { + mutex_.lock (); + connection_->factory_ = this; + connection_ptr r (connection_); + connection_.reset (); + return r; + } + + void single_connection_factory:: + database (database_type& db) + { + db_ = &db; + connection_ = create (); + } + + bool single_connection_factory:: + release (single_connection* c) + { + c->factory_ = 0; + connection_.reset (inc_ref (c)); + connection_->recycle (); + mutex_.unlock (); + return false; + } + + // + // single_connection_factory::single_connection + // + + single_connection_factory::single_connection:: + single_connection (database_type& db, int extra_flags) + : connection (db, extra_flags), factory_ (0) + { + callback_.arg = this; + callback_.zero_counter = &zero_counter; + shared_base::callback_ = &callback_; + } + + single_connection_factory::single_connection:: + single_connection (database_type& db, sqlite3* handle) + : connection (db, handle), factory_ (0) + { + callback_.arg = this; + callback_.zero_counter = &zero_counter; + shared_base::callback_ = &callback_; + } + + bool single_connection_factory::single_connection:: + zero_counter (void* arg) + { + single_connection* c (static_cast (arg)); + return c->factory_ ? c->factory_->release (c) : true; + } + + // + // new_connection_factory + // + + connection_ptr new_connection_factory:: + connect () + { + return connection_ptr ( + new (shared) connection (*db_, extra_flags_)); + } + + void new_connection_factory:: + database (database_type& db) + { + db_ = &db; + + // Unless explicitly disabled, enable shared cache. + // +#if SQLITE_VERSION_NUMBER >= 3006018 && defined(LIBODB_SQLITE_HAVE_UNLOCK_NOTIFY) + if ((db_->flags () & SQLITE_OPEN_PRIVATECACHE) == 0) + extra_flags_ |= SQLITE_OPEN_SHAREDCACHE; +#endif + } + + // + // connection_pool_factory + // + + connection_pool_factory::pooled_connection_ptr connection_pool_factory:: + create () + { + return pooled_connection_ptr ( + new (shared) pooled_connection (*db_, extra_flags_)); + } + + connection_pool_factory:: + ~connection_pool_factory () + { + // Wait for all the connections currently in use to return to the pool. + // + lock l (mutex_); + while (in_use_ != 0) + { + waiters_++; + cond_.wait (); + waiters_--; + } + } + + connection_ptr connection_pool_factory:: + connect () + { + lock l (mutex_); + + while (true) + { + // See if we have a spare connection. + // + if (connections_.size () != 0) + { + shared_ptr c (connections_.back ()); + connections_.pop_back (); + + c->pool_ = this; + in_use_++; + return c; + } + + // See if we can create a new one. + // + if(max_ == 0 || in_use_ < max_) + { + shared_ptr c (create ()); + c->pool_ = this; + in_use_++; + return c; + } + + // Wait until someone releases a connection. + // + waiters_++; + cond_.wait (); + waiters_--; + } + } + + void connection_pool_factory:: + database (database_type& db) + { + db_ = &db; + + // Unless explicitly disabled, enable shared cache. + // +#if SQLITE_VERSION_NUMBER >= 3006018 && defined(LIBODB_SQLITE_HAVE_UNLOCK_NOTIFY) + if ((db_->flags () & SQLITE_OPEN_PRIVATECACHE) == 0) + extra_flags_ |= SQLITE_OPEN_SHAREDCACHE; +#endif + + if (min_ > 0) + { + connections_.reserve (min_); + + for(size_t i (0); i < min_; ++i) + connections_.push_back (create ()); + } + } + + bool connection_pool_factory:: + release (pooled_connection* c) + { + c->pool_ = 0; + + lock l (mutex_); + + // Determine if we need to keep or free this connection. + // + bool keep (waiters_ != 0 || + min_ == 0 || + (connections_.size () + in_use_ <= min_)); + + in_use_--; + + if (keep) + { + connections_.push_back (pooled_connection_ptr (inc_ref (c))); + connections_.back ()->recycle (); + } + + if (waiters_ != 0) + cond_.signal (); + + return !keep; + } + + // + // connection_pool_factory::pooled_connection + // + + connection_pool_factory::pooled_connection:: + pooled_connection (database_type& db, int extra_flags) + : connection (db, extra_flags), pool_ (0) + { + callback_.arg = this; + callback_.zero_counter = &zero_counter; + shared_base::callback_ = &callback_; + } + + connection_pool_factory::pooled_connection:: + pooled_connection (database_type& db, sqlite3* handle) + : connection (db, handle), pool_ (0) + { + callback_.arg = this; + callback_.zero_counter = &zero_counter; + shared_base::callback_ = &callback_; + } + + bool connection_pool_factory::pooled_connection:: + zero_counter (void* arg) + { + pooled_connection* c (static_cast (arg)); + return c->pool_ ? c->pool_->release (c) : true; + } + } +} diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/connection-factory.hxx b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/connection-factory.hxx new file mode 100755 index 0000000..c0d15ff --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/connection-factory.hxx @@ -0,0 +1,237 @@ +// file : odb/sqlite/connection-factory.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_SQLITE_CONNECTION_FACTORY_HXX +#define ODB_SQLITE_CONNECTION_FACTORY_HXX + +#include + +#include +#include // std::size_t +#include + +#include +#include +#include + +#include +#include +#include +#include + +namespace odb +{ + namespace sqlite + { + class LIBODB_SQLITE_EXPORT connection_factory + { + public: + virtual connection_ptr + connect () = 0; + + public: + typedef sqlite::database database_type; + + virtual void + database (database_type&) = 0; + + virtual + ~connection_factory (); + }; + + // Share a single connection. + // + class LIBODB_SQLITE_EXPORT single_connection_factory: + public connection_factory + { + public: + single_connection_factory (): db_ (0) {} + + virtual connection_ptr + connect (); + + virtual void + database (database_type&); + + virtual + ~single_connection_factory (); + + private: + single_connection_factory (const single_connection_factory&); + single_connection_factory& operator= (const single_connection_factory&); + + protected: + class LIBODB_SQLITE_EXPORT single_connection: public connection + { + public: + single_connection (database_type&, int extra_flags = 0); + single_connection (database_type&, sqlite3*); + + private: + static bool + zero_counter (void*); + + private: + friend class single_connection_factory; + + shared_base::refcount_callback callback_; + + // NULL factory value indicates that the connection is not in use. + // + single_connection_factory* factory_; + }; + + friend class single_connection; + + typedef details::shared_ptr single_connection_ptr; + + // This function is called when the factory needs to create the + // connection. + // + virtual single_connection_ptr + create (); + + protected: + // Return true if the connection should be deleted, false otherwise. + // + bool + release (single_connection*); + + protected: + database_type* db_; + details::mutex mutex_; + single_connection_ptr connection_; + }; + + // Create a new connection every time one is requested. + // + class LIBODB_SQLITE_EXPORT new_connection_factory: + public connection_factory + { + public: + new_connection_factory (): db_ (0), extra_flags_ (0) {} + + virtual connection_ptr + connect (); + + virtual void + database (database_type&); + + private: + new_connection_factory (const new_connection_factory&); + new_connection_factory& operator= (const new_connection_factory&); + + private: + database_type* db_; + int extra_flags_; + }; + + // Pool a number of connections. + // + class LIBODB_SQLITE_EXPORT connection_pool_factory: + public connection_factory + { + public: + // The max_connections argument specifies the maximum number of + // concurrent connections this pool will maintain. If this value + // is 0 then the pool will create a new connection every time all + // of the existing connections are in use. + // + // The min_connections argument specifies the minimum number of + // connections that should be maintained by the pool. If the + // number of connections maintained by the pool exceeds this + // number and there are no active waiters for a new connection, + // then the pool will release the excess connections. If this + // value is 0 then the pool will maintain all the connections + // that were ever created. + // + // The ping argument specifies whether to ping the connection to + // make sure it is still alive before returning it to the caller. + // + connection_pool_factory (std::size_t max_connections = 0, + std::size_t min_connections = 0) + : max_ (max_connections), + min_ (min_connections), + extra_flags_ (0), + in_use_ (0), + waiters_ (0), + db_ (0), + cond_ (mutex_) + { + // max_connections == 0 means unlimited. + // + assert (max_connections == 0 || max_connections >= min_connections); + } + + virtual connection_ptr + connect (); + + virtual void + database (database_type&); + + virtual + ~connection_pool_factory (); + + private: + connection_pool_factory (const connection_pool_factory&); + connection_pool_factory& operator= (const connection_pool_factory&); + + protected: + class LIBODB_SQLITE_EXPORT pooled_connection: public connection + { + public: + pooled_connection (database_type&, int extra_flags = 0); + pooled_connection (database_type&, sqlite3*); + + private: + static bool + zero_counter (void*); + + private: + friend class connection_pool_factory; + + shared_base::refcount_callback callback_; + + // NULL pool value indicates that the connection is not in use. + // + connection_pool_factory* pool_; + }; + + friend class pooled_connection; + + typedef details::shared_ptr pooled_connection_ptr; + typedef std::vector connections; + + // This function is called whenever the pool needs to create a new + // connection. + // + virtual pooled_connection_ptr + create (); + + protected: + // Return true if the connection should be deleted, false otherwise. + // + bool + release (pooled_connection*); + + protected: + const std::size_t max_; + const std::size_t min_; + int extra_flags_; + + std::size_t in_use_; // Number of connections currently in use. + std::size_t waiters_; // Number of threads waiting for a connection. + + database_type* db_; + connections connections_; + + details::mutex mutex_; + details::condition cond_; + }; + } +} + +#include + +#endif // ODB_SQLITE_CONNECTION_FACTORY_HXX diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/connection.cxx b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/connection.cxx new file mode 100755 index 0000000..dd30f1f --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/connection.cxx @@ -0,0 +1,200 @@ +// file : odb/sqlite/connection.cxx +// copyright : Copyright (c) 2005-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include // std::bad_alloc +#include +#include + +#include + +#include +#include +#include +#include +#include +#include +#include +#include // deadlock + +#include // LIBODB_SQLITE_HAVE_UNLOCK_NOTIFY + +using namespace std; + +extern "C" void +odb_sqlite_connection_unlock_callback (void**, int); + +namespace odb +{ + namespace sqlite + { + connection:: + connection (database_type& db, int extra_flags) + : odb::connection (db), + db_ (db), + unlock_cond_ (unlock_mutex_), + statements_ (0) + { + int f (db.flags () | extra_flags); + const string& n (db.name ()); + + // If we are opening a temporary database, then add the create flag. + // + if (n.empty () || n == ":memory:") + f |= SQLITE_OPEN_CREATE; + + // A connection can only be used by a single thread at a time. So + // disable locking in SQLite unless explicitly requested. + // +#if defined(SQLITE_OPEN_NOMUTEX) + if ((f & SQLITE_OPEN_FULLMUTEX) == 0) + f |= SQLITE_OPEN_NOMUTEX; +#endif + + sqlite3* h (0); + + // sqlite3_open_v2() was only addedin SQLite 3.5.0. + // +#if SQLITE_VERSION_NUMBER >= 3005000 + const string& vfs (db.vfs ()); + int e ( + sqlite3_open_v2 ( + n.c_str (), &h, f, (vfs.empty () ? 0 : vfs.c_str ()))); +#else + // Readonly opening not supported in SQLite earlier than 3.5.0. + // + assert ((f & SQLITE_OPEN_READONLY) == 0); + int e (sqlite3_open (n.c_str (), &h)); +#endif + + handle_.reset (h); + + if (e != SQLITE_OK) + { + if (handle_ == 0) + throw bad_alloc (); + + translate_error (e, *this); + } + + init (); + } + + connection:: + connection (database_type& db, sqlite3* handle) + : odb::connection (db), + db_ (db), + handle_ (handle), + unlock_cond_ (unlock_mutex_), + statements_ (0) + { + init (); + } + + void connection:: + init () + { + // Enable/disable foreign key constraints. + // + generic_statement st ( + *this, + db_.foreign_keys () + ? "PRAGMA foreign_keys=ON" + : "PRAGMA foreign_keys=OFF", + db_.foreign_keys () ? 22 : 23); + st.execute (); + + // Create statement cache. + // + statement_cache_.reset (new statement_cache_type (*this)); + } + + connection:: + ~connection () + { + // Destroy prepared query statements before freeing the connections. + // + recycle (); + clear_prepared_map (); + } + + transaction_impl* connection:: + begin () + { + return new transaction_impl ( + connection_ptr (inc_ref (this)), transaction_impl::deferred); + } + + transaction_impl* connection:: + begin_immediate () + { + return new transaction_impl ( + connection_ptr (inc_ref (this)), transaction_impl::immediate); + } + + transaction_impl* connection:: + begin_exclusive () + { + return new transaction_impl ( + connection_ptr (inc_ref (this)), transaction_impl::exclusive); + } + + unsigned long long connection:: + execute (const char* s, std::size_t n) + { + generic_statement st (*this, s, n); + return st.execute (); + } + + inline void + connection_unlock_callback (void** args, int n) + { + for (int i (0); i < n; ++i) + { + connection* c (static_cast (args[i])); + details::lock l (c->unlock_mutex_); + c->unlocked_ = true; + c->unlock_cond_.signal (); + } + } + + void connection:: + wait () + { +#ifdef LIBODB_SQLITE_HAVE_UNLOCK_NOTIFY + unlocked_ = false; + + // unlock_notify() returns SQLITE_OK or SQLITE_LOCKED (deadlock). + // + int e (sqlite3_unlock_notify (handle_, + &odb_sqlite_connection_unlock_callback, + this)); + if (e == SQLITE_LOCKED) + throw deadlock (); + + details::lock l (unlock_mutex_); + + while (!unlocked_) + unlock_cond_.wait (); +#else + translate_error (SQLITE_LOCKED, *this); +#endif + } + + void connection:: + clear () + { + // The current first statement will remove itself from the list + // and make the second statement (if any) the new first. + // + while (statements_ != 0) + statements_->reset (); + } + } +} + +extern "C" void +odb_sqlite_connection_unlock_callback (void** args, int n) +{ + odb::sqlite::connection_unlock_callback (args, n); +} diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/connection.hxx b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/connection.hxx new file mode 100755 index 0000000..8e54388 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/connection.hxx @@ -0,0 +1,182 @@ +// file : odb/sqlite/connection.hxx +// copyright : Copyright (c) 2005-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_SQLITE_CONNECTION_HXX +#define ODB_SQLITE_CONNECTION_HXX + +#include + +#include + +#include + +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +#include + +namespace odb +{ + namespace sqlite + { + class statement_cache; + + class connection; + typedef details::shared_ptr connection_ptr; + + class LIBODB_SQLITE_EXPORT connection: public odb::connection + { + public: + typedef sqlite::statement_cache statement_cache_type; + typedef sqlite::database database_type; + + virtual + ~connection (); + + connection (database_type&, int extra_flags = 0); + connection (database_type&, sqlite3* handle); + + database_type& + database () + { + return db_; + } + + public: + virtual transaction_impl* + begin (); + + transaction_impl* + begin_immediate (); + + transaction_impl* + begin_exclusive (); + + public: + using odb::connection::execute; + + virtual unsigned long long + execute (const char* statement, std::size_t length); + + // Query preparation. + // + public: + template + prepared_query + prepare_query (const char* name, const char*); + + template + prepared_query + prepare_query (const char* name, const std::string&); + + template + prepared_query + prepare_query (const char* name, const sqlite::query_base&); + + template + prepared_query + prepare_query (const char* name, const odb::query_base&); + + // SQL statement tracing. + // + public: + typedef sqlite::tracer tracer_type; + + void + tracer (tracer_type& t) + { + odb::connection::tracer (t); + } + + void + tracer (tracer_type* t) + { + odb::connection::tracer (t); + } + + using odb::connection::tracer; + + public: + sqlite3* + handle () + { + return handle_; + } + + statement_cache_type& + statement_cache () + { + return *statement_cache_; + } + + // Wait for the locks to be released via unlock notification. Can + // be called after getting SQLITE_LOCKED_SHAREDCACHE. + // + void + wait (); + + public: + // Reset active statements. + // + void + clear (); + + private: + connection (const connection&); + connection& operator= (const connection&); + + private: + void + init (); + + private: + // Needed to break the circular connection-database dependency + // (odb::connection has the odb::database member). + // + database_type& db_; + + auto_handle handle_; + + // Keep statement_cache_ after handle_ so that it is destroyed before + // the connection is closed. + // + details::unique_ptr statement_cache_; + + // Unlock notification machinery. + // + private: + bool unlocked_; + details::mutex unlock_mutex_; + details::condition unlock_cond_; + + friend void + connection_unlock_callback (void**, int); + + private: + friend class transaction_impl; // invalidate_results() + + // Linked list of active statements currently associated + // with this connection. + // + private: + friend class statement; + statement* statements_; + }; + } +} + +#include + +#include + +#endif // ODB_SQLITE_CONNECTION_HXX diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/connection.ixx b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/connection.ixx new file mode 100755 index 0000000..e0ed736 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/connection.ixx @@ -0,0 +1,39 @@ +// file : odb/sqlite/connection.ixx +// copyright : Copyright (c) 2005-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +namespace odb +{ + namespace sqlite + { + template + inline prepared_query connection:: + prepare_query (const char* n, const char* q) + { + return prepare_query (n, query (q)); + } + + template + inline prepared_query connection:: + prepare_query (const char* n, const std::string& q) + { + return prepare_query (n, query (q)); + } + + template + inline prepared_query connection:: + prepare_query (const char* n, const sqlite::query_base& q) + { + return query_::call (*this, n, q); + } + + template + inline prepared_query connection:: + prepare_query (const char* n, const odb::query_base& q) + { + // Translate to native query. + // + return prepare_query (n, sqlite::query_base (q)); + } + } +} diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/container-statements.hxx b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/container-statements.hxx new file mode 100755 index 0000000..fb8412d --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/container-statements.hxx @@ -0,0 +1,356 @@ +// file : odb/sqlite/container-statements.hxx +// copyright : Copyright (c) 2005-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_SQLITE_CONTAINER_STATEMENTS_HXX +#define ODB_SQLITE_CONTAINER_STATEMENTS_HXX + +#include + +#include // std::size_t + +#include +#include +#include + +#include +#include +#include +#include + +namespace odb +{ + namespace sqlite + { + class connection; + + // Template argument is the generated abstract container traits type. + // That is, it doesn't need to provide column counts and statements. + // + template + class container_statements + { + public: + typedef T traits; + + typedef typename traits::data_image_type data_image_type; + typedef typename traits::functions_type functions_type; + + typedef sqlite::insert_statement insert_statement_type; + typedef sqlite::select_statement select_statement_type; + typedef sqlite::delete_statement delete_statement_type; + + typedef sqlite::connection connection_type; + + container_statements (connection_type&, binding& id_binding); + + connection_type& + connection () + { + return conn_; + } + + // Functions. + // + functions_type& + functions () + { + return functions_; + } + + // Schema version. + // + const schema_version_migration& + version_migration () const {return *svm_;} + + void + version_migration (const schema_version_migration& svm) {svm_ = &svm;} + + // Id image binding (external). + // + const binding& + id_binding () + { + return id_binding_; + } + + // Data image. The image is split into the id (that comes as a + // binding) and index/key plus value which are in data_image_type. + // The select binding is a subset of the full binding (no id). + // + data_image_type& + data_image () + { + return data_image_; + } + + bind* + data_bind () + { + return insert_image_binding_.bind; + } + + bool + data_binding_test_version () const + { + return data_id_binding_version_ != id_binding_.version || + data_image_version_ != data_image_.version || + insert_image_binding_.version == 0; + } + + void + data_binding_update_version () + { + data_id_binding_version_ = id_binding_.version; + data_image_version_ = data_image_.version; + insert_image_binding_.version++; + select_image_binding_.version++; + } + + bool* + select_image_truncated () + { + return select_image_truncated_; + } + + // + // Statements. + // + + insert_statement_type& + insert_statement () + { + if (insert_ == 0) + insert_.reset ( + new (details::shared) insert_statement_type ( + conn_, + insert_text_, + versioned_, // Process if versioned. + insert_image_binding_, + 0)); + + return *insert_; + } + + select_statement_type& + select_statement () + { + if (select_ == 0) + select_.reset ( + new (details::shared) select_statement_type ( + conn_, + select_text_, + versioned_, // Process if versioned. + false, // Don't optimize. + id_binding_, + select_image_binding_)); + + return *select_; + } + + delete_statement_type& + delete_statement () + { + if (delete_ == 0) + delete_.reset ( + new (details::shared) delete_statement_type ( + conn_, delete_text_, id_binding_)); + + return *delete_; + } + + private: + container_statements (const container_statements&); + container_statements& operator= (const container_statements&); + + protected: + connection_type& conn_; + binding& id_binding_; + + functions_type functions_; + + data_image_type data_image_; + std::size_t data_image_version_; + std::size_t data_id_binding_version_; + + binding insert_image_binding_; + + binding select_image_binding_; + bool* select_image_truncated_; + + const char* insert_text_; + const char* select_text_; + const char* delete_text_; + + bool versioned_; + const schema_version_migration* svm_; + + details::shared_ptr insert_; + details::shared_ptr select_; + details::shared_ptr delete_; + }; + + template + class smart_container_statements: public container_statements + { + public: + typedef T traits; + typedef typename traits::cond_image_type cond_image_type; + + typedef sqlite::update_statement update_statement_type; + typedef sqlite::delete_statement delete_statement_type; + + typedef sqlite::connection connection_type; + + smart_container_statements (connection_type&, binding& id_binding); + + // Condition image. The image is split into the id (that comes as + // a binding) and index/key/value which is in cond_image_type. + // + cond_image_type& + cond_image () + { + return cond_image_; + } + + bind* + cond_bind () + { + return cond_image_binding_.bind; + } + + bool + cond_binding_test_version () const + { + return cond_id_binding_version_ != this->id_binding_.version || + cond_image_version_ != cond_image_.version || + cond_image_binding_.version == 0; + } + + void + cond_binding_update_version () + { + cond_id_binding_version_ = this->id_binding_.version; + cond_image_version_ = cond_image_.version; + cond_image_binding_.version++; + } + + // Update image. The image is split as follows: value comes + // from the data image, id comes as binding, and index/key + // comes from the condition image. + // + bind* + update_bind () + { + return update_image_binding_.bind; + } + + bool + update_binding_test_version () const + { + return update_id_binding_version_ != this->id_binding_.version || + update_cond_image_version_ != cond_image_.version || + update_data_image_version_ != this->data_image_.version || + update_image_binding_.version == 0; + } + + void + update_binding_update_version () + { + update_id_binding_version_ = this->id_binding_.version; + update_cond_image_version_ = cond_image_.version; + update_data_image_version_ = this->data_image_.version; + update_image_binding_.version++; + } + + // + // Statements. + // + + delete_statement_type& + delete_statement () + { + if (this->delete_ == 0) + this->delete_.reset ( + new (details::shared) delete_statement_type ( + this->conn_, + this->delete_text_, + this->cond_image_binding_)); + + return *this->delete_; + } + + update_statement_type& + update_statement () + { + if (update_ == 0) + update_.reset ( + new (details::shared) update_statement_type ( + this->conn_, + update_text_, + this->versioned_, // Process if versioned. + update_image_binding_)); + + return *update_; + } + + protected: + cond_image_type cond_image_; + std::size_t cond_image_version_; + std::size_t cond_id_binding_version_; + binding cond_image_binding_; + + std::size_t update_id_binding_version_; + std::size_t update_cond_image_version_; + std::size_t update_data_image_version_; + binding update_image_binding_; + + const char* update_text_; + + details::shared_ptr update_; + }; + + // Template argument is the generated concrete container traits type. + // + template + class container_statements_impl: public T::statements_type + { + public: + typedef T traits; + typedef typename T::statements_type base; + typedef sqlite::connection connection_type; + + container_statements_impl (connection_type&, binding&); + + private: + container_statements_impl (const container_statements_impl&); + container_statements_impl& operator= (const container_statements_impl&); + + private: + bind data_image_bind_[traits::data_column_count]; + bool select_image_truncated_array_[traits::data_column_count - + traits::id_column_count]; + }; + + template + class smart_container_statements_impl: public container_statements_impl + { + public: + typedef T traits; + typedef sqlite::connection connection_type; + + smart_container_statements_impl (connection_type&, binding&); + + private: + bind cond_image_bind_[traits::cond_column_count]; + bind update_image_bind_[traits::value_column_count + + traits::cond_column_count]; + }; + } +} + +#include + +#include + +#endif // ODB_SQLITE_CONTAINER_STATEMENTS_HXX diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/container-statements.txx b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/container-statements.txx new file mode 100755 index 0000000..6a764c5 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/container-statements.txx @@ -0,0 +1,108 @@ +// file : odb/sqlite/container-statements.txx +// copyright : Copyright (c) 2005-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include // std::size_t +#include // std::memset + +namespace odb +{ + namespace sqlite + { + // container_statements + // + template + container_statements:: + container_statements (connection_type& conn, binding& id) + : conn_ (conn), + id_binding_ (id), + functions_ (this), + insert_image_binding_ (0, 0), // Initialized by impl. + select_image_binding_ (0, 0), // Initialized by impl. + svm_ (0) + { + functions_.insert_ = &traits::insert; + functions_.select_ = &traits::select; + functions_.delete__ = &traits::delete_; + + data_image_.version = 0; + data_image_version_ = 0; + data_id_binding_version_ = 0; + } + + // smart_container_statements + // + template + smart_container_statements:: + smart_container_statements (connection_type& conn, binding& id) + : container_statements (conn, id), + cond_image_binding_ (0, 0), // Initialized by impl. + update_image_binding_ (0, 0) // Initialized by impl. + { + this->functions_.update_ = &traits::update; + + cond_image_.version = 0; + cond_image_version_ = 0; + cond_id_binding_version_ = 0; + + update_id_binding_version_ = 0; + update_cond_image_version_ = 0; + update_data_image_version_ = 0; + } + + // container_statements_impl + // + template + container_statements_impl:: + container_statements_impl (connection_type& conn, binding& id) + : base (conn, id) + { + this->select_image_truncated_ = select_image_truncated_array_; + + this->insert_image_binding_.bind = data_image_bind_; + this->insert_image_binding_.count = traits::data_column_count; + + this->select_image_binding_.bind = data_image_bind_ + + traits::id_column_count; + this->select_image_binding_.count = traits::data_column_count - + traits::id_column_count; + + std::memset (data_image_bind_, 0, sizeof (data_image_bind_)); + std::memset (select_image_truncated_array_, + 0, + sizeof (select_image_truncated_array_)); + + for (std::size_t i (0); + i < traits::data_column_count - traits::id_column_count; + ++i) + data_image_bind_[i + traits::id_column_count].truncated = + select_image_truncated_array_ + i; + + this->insert_text_ = traits::insert_statement; + this->select_text_ = traits::select_statement; + this->delete_text_ = traits::delete_statement; + + this->versioned_ = traits::versioned; + } + + // smart_container_statements_impl + // + template + smart_container_statements_impl:: + smart_container_statements_impl (connection_type& conn, binding& id) + : container_statements_impl (conn, id) + { + this->cond_image_binding_.bind = cond_image_bind_; + this->cond_image_binding_.count = traits::cond_column_count; + + this->update_image_binding_.bind = update_image_bind_; + this->update_image_binding_.count = traits::value_column_count + + traits::cond_column_count; + + std::memset (cond_image_bind_, 0, sizeof (cond_image_bind_)); + std::memset (update_image_bind_, 0, sizeof (update_image_bind_)); + + this->update_text_ = traits::update_statement; + } + } +} diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/database.cxx b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/database.cxx new file mode 100755 index 0000000..60e65b0 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/database.cxx @@ -0,0 +1,278 @@ +// file : odb/sqlite/database.cxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifdef _WIN32 +# include // WideCharToMultiByte +#endif + +#include + +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +#include + +using namespace std; + +namespace odb +{ + namespace sqlite + { + using odb::details::transfer_ptr; + + database:: + ~database () + { + } + + database:: + database (const string& name, + int flags, + bool foreign_keys, + const string& vfs, + transfer_ptr factory) + : odb::database (id_sqlite), + name_ (name), + flags_ (flags), + foreign_keys_ (foreign_keys), + vfs_ (vfs), + factory_ (factory.transfer ()) + { + if (!factory_) + factory_.reset (new connection_pool_factory ()); + + factory_->database (*this); + } + +#ifdef _WIN32 + database:: + database (const wstring& name, + int flags, + bool foreign_keys, + const string& vfs, + transfer_ptr factory) + : odb::database (id_sqlite), + flags_ (flags), + foreign_keys_ (foreign_keys), + vfs_ (vfs), + factory_ (factory.transfer ()) + { + // Convert UTF-16 name to UTF-8 using the WideCharToMultiByte() Win32 + // function. + // + int n ( + WideCharToMultiByte ( + CP_UTF8, + 0, + name.c_str (), + static_cast (name.size ()), + 0, + 0, + 0, + 0)); + + if (n == 0) + throw database_exception ( + SQLITE_CANTOPEN, SQLITE_CANTOPEN, "unable to open database file"); + + // This string is not shared so we are going to modify the underlying + // buffer directly. + // + name_.resize (static_cast (n)); + + n = WideCharToMultiByte ( + CP_UTF8, + 0, + name.c_str (), + static_cast (name.size ()), + const_cast (name_.c_str ()), + n, + 0, + 0); + + if (n == 0) + throw database_exception ( + SQLITE_CANTOPEN, SQLITE_CANTOPEN, "unable to open database file"); + + if (!factory_) + factory_.reset (new connection_pool_factory ()); + + factory_->database (*this); + } +#endif + + database:: + database (int& argc, + char* argv[], + bool erase, + int flags, + bool foreign_keys, + const string& vfs, + transfer_ptr factory) + : odb::database (id_sqlite), + flags_ (flags), + foreign_keys_ (foreign_keys), + vfs_ (vfs), + factory_ (factory.transfer ()) + { + using namespace details; + + try + { + cli::argv_file_scanner scan (argc, argv, "--options-file", erase); + options ops (scan, cli::unknown_mode::skip, cli::unknown_mode::skip); + + name_ = ops.database (); + + if (ops.create ()) + flags_ |= SQLITE_OPEN_CREATE; + + if (ops.read_only ()) + flags_ = (flags_ & ~SQLITE_OPEN_READWRITE) | SQLITE_OPEN_READONLY; + } + catch (const cli::exception& e) + { + ostringstream ostr; + ostr << e; + throw cli_exception (ostr.str ()); + } + + if (!factory_) + factory_.reset (new connection_pool_factory ()); + + factory_->database (*this); + } + + void database:: + print_usage (std::ostream& os) + { + details::options::print_usage (os); + } + + transaction_impl* database:: + begin () + { + return new transaction_impl (*this, transaction_impl::deferred); + } + + transaction_impl* database:: + begin_immediate () + { + return new transaction_impl (*this, transaction_impl::immediate); + } + + transaction_impl* database:: + begin_exclusive () + { + return new transaction_impl (*this, transaction_impl::exclusive); + } + + odb::connection* database:: + connection_ () + { + connection_ptr c (factory_->connect ()); + return c.release (); + } + + const database::schema_version_info& database:: + load_schema_version (const string& name) const + { + schema_version_info& svi (schema_version_map_[name]); + + // Construct the SELECT statement text. + // + string text ("SELECT \"version\", \"migration\" FROM "); + + if (!svi.version_table.empty ()) + text += svi.version_table; // Already quoted. + else if (!schema_version_table_.empty ()) + text += schema_version_table_; // Already quoted. + else + text += "\"schema_version\""; + + text += " WHERE \"name\" = ?"; + + // Bind parameters and results. + // + size_t psize[1] = {name.size ()}; + bind pbind[1] = {{bind::text, + const_cast (name.c_str ()), + &psize[0], + 0, 0, 0}}; + binding param (pbind, 1); + param.version++; + + long long migration; + bool rnull[2]; + bind rbind[2] = {{bind::integer, &svi.version, 0, 0, &rnull[0], 0}, + {bind::integer, &migration, 0, 0, &rnull[1], 0}}; + binding result (rbind, 2); + result.version++; + + // If we are not in transaction, SQLite will start an implicit one + // which suits us just fine. + // + connection_ptr cp; + if (!transaction::has_current ()) + cp = factory_->connect (); + + sqlite::connection& c ( + cp != 0 ? *cp : transaction::current ().connection ()); + + try + { + select_statement st (c, + text, + false, // Don't process. + false, // Don't optimize. + param, + result); + st.execute (); + auto_result ar (st); + + switch (st.fetch ()) + { + case select_statement::success: + { + svi.migration = migration != 0; + assert (st.fetch () == select_statement::no_data); + break; + } + case select_statement::no_data: + { + svi.version = 0; // No schema. + break; + } + case select_statement::truncated: + { + assert (false); + break; + } + } + } + catch (const database_exception& e) + { + // Try to detect the case where there is no version table. SQLite + // doesn't have an extended error code for this so we have to use + // the error text. + // + if (e.error () == SQLITE_ERROR && + e.message ().compare (0, 14, "no such table:") == 0) + svi.version = 0; // No schema. + else + throw; + } + + return svi; + } + } +} diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/database.hxx b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/database.hxx new file mode 100755 index 0000000..906d91b --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/database.hxx @@ -0,0 +1,474 @@ +// file : odb/sqlite/database.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_SQLITE_DATABASE_HXX +#define ODB_SQLITE_DATABASE_HXX + +#include + +#include + +#include +#include // std::auto_ptr, std::unique_ptr +#include // std::ostream + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +#include + +// We use the sqlite3_open_v2() flags in our interface. Define them +// for SQLite earlier that 3.5.0. +// +#if SQLITE_VERSION_NUMBER < 3005000 +# define SQLITE_OPEN_READONLY 0x00000001 +# define SQLITE_OPEN_READWRITE 0x00000002 +# define SQLITE_OPEN_CREATE 0x00000004 +#endif + +namespace odb +{ + namespace sqlite + { + class transaction_impl; + + class LIBODB_SQLITE_EXPORT database: public odb::database + { + public: + database (const std::string& name, + int flags = SQLITE_OPEN_READWRITE, + bool foreign_keys = true, + const std::string& vfs = "", + details::transfer_ptr = + details::transfer_ptr ()); + +#ifdef _WIN32 + database (const std::wstring& name, + int flags = SQLITE_OPEN_READWRITE, + bool foreign_keys = true, + const std::string& vfs = "", + details::transfer_ptr = + details::transfer_ptr ()); +#endif + + // Extract the database parameters from the command line. The + // following options are recognized: + // + // --database + // --create + // --read-only + // --options-file + // + // For more information, see the output of the print_usage() function + // below. If erase is true, the above options are removed from the argv + // array and the argc count is updated accordingly. The command line + // options override the flags passed as an argument. This constructor + // may throw the cli_exception exception. + // + database (int& argc, + char* argv[], + bool erase = false, + int flags = SQLITE_OPEN_READWRITE, + bool foreign_keys = true, + const std::string& vfs = "", + details::transfer_ptr = + details::transfer_ptr ()); + + static void + print_usage (std::ostream&); + + public: + const std::string& + name () const + { + return name_; + } + + int + flags () const + { + return flags_; + } + + bool + foreign_keys () const + { + return foreign_keys_; + } + + const std::string& + vfs () const + { + return vfs_; + } + + // Object persistence API. + // + public: + + // Make the object persistent. + // + template + typename object_traits::id_type + persist (T& object); + + template + typename object_traits::id_type + persist (const T& object); + + template + typename object_traits::id_type + persist (T* obj_ptr); + + template class P> + typename object_traits::id_type + persist (const P& obj_ptr); + + template class P> + typename object_traits::id_type + persist (const P& obj_ptr); + + template class P> + typename object_traits::id_type + persist (P& obj_ptr); + + template class P> + typename object_traits::id_type + persist (P& obj_ptr); + + template + typename object_traits::id_type + persist (const typename object_traits::pointer_type& obj_ptr); + + // Load an object. Throw object_not_persistent if not found. + // + template + typename object_traits::pointer_type + load (const typename object_traits::id_type& id); + + template + void + load (const typename object_traits::id_type& id, T& object); + + // Load (or reload, if it is already loaded) a section of an object. + // + template + void + load (T& object, section&); + + // Reload an object. + // + template + void + reload (T& object); + + template + void + reload (T* obj_ptr); + + template class P> + void + reload (const P& obj_ptr); + + template class P> + void + reload (const P& obj_ptr); + + template class P> + void + reload (P& obj_ptr); + + template class P> + void + reload (P& obj_ptr); + + template + void + reload (const typename object_traits::pointer_type& obj_ptr); + + // Loan an object if found. Return NULL/false if not found. + // + template + typename object_traits::pointer_type + find (const typename object_traits::id_type& id); + + template + bool + find (const typename object_traits::id_type& id, T& object); + + // Update the state of a modified objects. + // + template + void + update (T& object); + + template + void + update (T* obj_ptr); + + template class P> + void + update (const P& obj_ptr); + + template class P> + void + update (const P& obj_ptr); + + template class P> + void + update (P& obj_ptr); + + template class P> + void + update (P& obj_ptr); + + template + void + update (const typename object_traits::pointer_type& obj_ptr); + + // Update a section of an object. Throws the section_not_loaded + // exception if the section is not loaded. Note also that this + // function does not clear the changed flag if it is set. + // + template + void + update (const T& object, const section&); + + // Make the object transient. Throw object_not_persistent if not + // found. + // + template + void + erase (const typename object_traits::id_type& id); + + template + void + erase (T& object); + + template + void + erase (T* obj_ptr); + + template class P> + void + erase (const P& obj_ptr); + + template class P> + void + erase (const P& obj_ptr); + + template class P> + void + erase (P& obj_ptr); + + template class P> + void + erase (P& obj_ptr); + + template + void + erase (const typename object_traits::pointer_type& obj_ptr); + + // Erase multiple objects matching a query predicate. + // + template + unsigned long long + erase_query (); + + template + unsigned long long + erase_query (const char*); + + template + unsigned long long + erase_query (const std::string&); + + template + unsigned long long + erase_query (const sqlite::query_base&); + + template + unsigned long long + erase_query (const odb::query_base&); + + // Query API. + // + template + result + query (); + + template + result + query (const char*); + + template + result + query (const std::string&); + + template + result + query (const sqlite::query_base&); + + template + result + query (const odb::query_base&); + + // Query one API. + // + template + typename object_traits::pointer_type + query_one (); + + template + bool + query_one (T& object); + + template + T + query_value (); + + template + typename object_traits::pointer_type + query_one (const char*); + + template + bool + query_one (const char*, T& object); + + template + T + query_value (const char*); + + template + typename object_traits::pointer_type + query_one (const std::string&); + + template + bool + query_one (const std::string&, T& object); + + template + T + query_value (const std::string&); + + template + typename object_traits::pointer_type + query_one (const sqlite::query_base&); + + template + bool + query_one (const sqlite::query_base&, T& object); + + template + T + query_value (const sqlite::query_base&); + + template + typename object_traits::pointer_type + query_one (const odb::query_base&); + + template + bool + query_one (const odb::query_base&, T& object); + + template + T + query_value (const odb::query_base&); + + // Query preparation. + // + template + prepared_query + prepare_query (const char* name, const char*); + + template + prepared_query + prepare_query (const char* name, const std::string&); + + template + prepared_query + prepare_query (const char* name, const sqlite::query_base&); + + template + prepared_query + prepare_query (const char* name, const odb::query_base&); + + // Transactions. + // + public: + virtual transaction_impl* + begin (); + + transaction_impl* + begin_immediate (); + + transaction_impl* + begin_exclusive (); + + public: + connection_ptr + connection (); + + // SQL statement tracing. + // + public: + typedef sqlite::tracer tracer_type; + + void + tracer (tracer_type& t) + { + odb::database::tracer (t); + } + + void + tracer (tracer_type* t) + { + odb::database::tracer (t); + } + + using odb::database::tracer; + + // Database schema version. + // + protected: + virtual const schema_version_info& + load_schema_version (const std::string& schema_name) const; + + // Database id constant (useful for meta-programming). + // + public: + static const odb::database_id database_id = id_sqlite; + + public: + virtual + ~database (); + + protected: + virtual odb::connection* + connection_ (); + + private: + std::string name_; + int flags_; + bool foreign_keys_; + std::string vfs_; + details::unique_ptr factory_; + }; + } +} + +#include + +#include + +#endif // ODB_SQLITE_DATABASE_HXX diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/database.ixx b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/database.ixx new file mode 100755 index 0000000..becf308 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/database.ixx @@ -0,0 +1,591 @@ +// file : odb/sqlite/database.ixx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include + +namespace odb +{ + namespace sqlite + { + inline connection_ptr database:: + connection () + { + // Go through the virtual connection_() function instead of + // directly to allow overriding. + // + return connection_ptr ( + static_cast (connection_ ())); + } + + template + inline typename object_traits::id_type database:: + persist (T& obj) + { + return persist_ (obj); + } + + template + inline typename object_traits::id_type database:: + persist (const T& obj) + { + return persist_ (obj); + } + + template + inline typename object_traits::id_type database:: + persist (T* p) + { + typedef typename object_traits::pointer_type object_pointer; + + // The passed pointer should be the same or implicit-convertible + // to the object pointer. This way we make sure the object pointer + // does not assume ownership of the passed object. + // + const object_pointer& pobj (p); + + return persist_ (pobj); + } + + template class P> + inline typename object_traits::id_type database:: + persist (const P& p) + { + typedef typename object_traits::pointer_type object_pointer; + + // The passed pointer should be the same or implicit-convertible + // to the object pointer. This way we make sure the object pointer + // does not assume ownership of the passed object. + // + const object_pointer& pobj (p); + + return persist_ (pobj); + } + + template class P> + inline typename object_traits::id_type database:: + persist (const P& p) + { + typedef typename object_traits::pointer_type object_pointer; + + // The passed pointer should be the same or implicit-convertible + // to the object pointer. This way we make sure the object pointer + // does not assume ownership of the passed object. + // + const object_pointer& pobj (p); + + return persist_ (pobj); + } + + template class P> + inline typename object_traits::id_type database:: + persist (P& p) + { + const P& cr (p); + return persist (cr); + } + + template class P> + inline typename object_traits::id_type database:: + persist (P& p) + { + const P& cr (p); + return persist (cr); + } + + template + inline typename object_traits::id_type database:: + persist (const typename object_traits::pointer_type& pobj) + { + return persist_ (pobj); + } + + template + inline typename object_traits::pointer_type database:: + load (const typename object_traits::id_type& id) + { + return load_ (id); + } + + template + inline void database:: + load (const typename object_traits::id_type& id, T& obj) + { + return load_ (id, obj); + } + + template + inline void database:: + load (T& obj, section& s) + { + return load_ (obj, s); + } + + template + inline typename object_traits::pointer_type database:: + find (const typename object_traits::id_type& id) + { + return find_ (id); + } + + template + inline bool database:: + find (const typename object_traits::id_type& id, T& obj) + { + return find_ (id, obj); + } + + template + inline void database:: + reload (T& obj) + { + reload_ (obj); + } + + template + inline void database:: + reload (T* p) + { + reload (*p); + } + + template class P> + inline void database:: + reload (const P& p) + { + reload (odb::pointer_traits< P >::get_ref (p)); + } + + template class P> + inline void database:: + reload (const P& p) + { + reload (odb::pointer_traits< P >::get_ref (p)); + } + + template class P> + inline void database:: + reload (P& p) + { + reload (odb::pointer_traits< P >::get_ref (p)); + } + + template class P> + inline void database:: + reload (P& p) + { + reload (odb::pointer_traits< P >::get_ref (p)); + } + + template + inline void database:: + reload (const typename object_traits::pointer_type& pobj) + { + typedef typename object_traits::pointer_type pointer_type; + + reload (odb::pointer_traits::get_ref (pobj)); + } + + template + inline void database:: + update (T& obj) + { + update_ (obj); + } + + template + inline void database:: + update (T* p) + { + typedef typename object_traits::pointer_type object_pointer; + + // The passed pointer should be the same or implicit-convertible + // to the object pointer. This way we make sure the object pointer + // does not assume ownership of the passed object. + // + const object_pointer& pobj (p); + + update_ (pobj); + } + + template class P> + inline void database:: + update (const P& p) + { + typedef typename object_traits::pointer_type object_pointer; + + // The passed pointer should be the same or implicit-convertible + // to the object pointer. This way we make sure the object pointer + // does not assume ownership of the passed object. + // + const object_pointer& pobj (p); + + update_ (pobj); + } + + template class P> + inline void database:: + update (const P& p) + { + typedef typename object_traits::pointer_type object_pointer; + + // The passed pointer should be the same or implicit-convertible + // to the object pointer. This way we make sure the object pointer + // does not assume ownership of the passed object. + // + const object_pointer& pobj (p); + + update_ (pobj); + } + + template class P> + inline void database:: + update (P& p) + { + const P& cr (p); + update (cr); + } + + template class P> + inline void database:: + update (P& p) + { + const P& cr (p); + update (cr); + } + + template + inline void database:: + update (const typename object_traits::pointer_type& pobj) + { + update_ (pobj); + } + + template + inline void database:: + update (const T& obj, const section& s) + { + update_ (obj, s); + } + + template + inline void database:: + erase (const typename object_traits::id_type& id) + { + return erase_ (id); + } + + template + inline void database:: + erase (T& obj) + { + return erase_ (obj); + } + + template + inline void database:: + erase (T* p) + { + typedef typename object_traits::pointer_type object_pointer; + + // The passed pointer should be the same or implicit-convertible + // to the object pointer. This way we make sure the object pointer + // does not assume ownership of the passed object. + // + const object_pointer& pobj (p); + + erase_ (pobj); + } + + template class P> + inline void database:: + erase (const P& p) + { + typedef typename object_traits::pointer_type object_pointer; + + // The passed pointer should be the same or implicit-convertible + // to the object pointer. This way we make sure the object pointer + // does not assume ownership of the passed object. + // + const object_pointer& pobj (p); + + erase_ (pobj); + } + + template class P> + inline void database:: + erase (const P& p) + { + typedef typename object_traits::pointer_type object_pointer; + + // The passed pointer should be the same or implicit-convertible + // to the object pointer. This way we make sure the object pointer + // does not assume ownership of the passed object. + // + const object_pointer& pobj (p); + + erase_ (pobj); + } + + template class P> + inline void database:: + erase (P& p) + { + const P& cr (p); + erase (cr); + } + + template class P> + inline void database:: + erase (P& p) + { + const P& cr (p); + erase (cr); + } + + template + inline void database:: + erase (const typename object_traits::pointer_type& pobj) + { + erase_ (pobj); + } + + template + inline unsigned long long database:: + erase_query () + { + // T is always object_type. + // + return erase_query (sqlite::query_base ()); + } + + template + inline unsigned long long database:: + erase_query (const char* q) + { + // T is always object_type. + // + return erase_query (sqlite::query_base (q)); + } + + template + inline unsigned long long database:: + erase_query (const std::string& q) + { + // T is always object_type. + // + return erase_query (sqlite::query_base (q)); + } + + template + inline unsigned long long database:: + erase_query (const sqlite::query_base& q) + { + // T is always object_type. + // + return object_traits_impl::erase_query (*this, q); + } + + template + inline unsigned long long database:: + erase_query (const odb::query_base& q) + { + // Translate to native query. + // + return erase_query (sqlite::query_base (q)); + } + + template + inline result database:: + query () + { + return query (sqlite::query_base ()); + } + + template + inline result database:: + query (const char* q) + { + return query (sqlite::query_base (q)); + } + + template + inline result database:: + query (const std::string& q) + { + return query (sqlite::query_base (q)); + } + + template + inline result database:: + query (const sqlite::query_base& q) + { + // T is always object_type. We also don't need to check for transaction + // here; object_traits::query () does this. + // + return query_::call (*this, q); + } + + template + inline result database:: + query (const odb::query_base& q) + { + // Translate to native query. + // + return query (sqlite::query_base (q)); + } + + template + inline typename object_traits::pointer_type database:: + query_one () + { + return query_one (sqlite::query_base ()); + } + + template + inline bool database:: + query_one (T& o) + { + return query_one (sqlite::query_base (), o); + } + + template + inline T database:: + query_value () + { + return query_value (sqlite::query_base ()); + } + + template + inline typename object_traits::pointer_type database:: + query_one (const char* q) + { + return query_one (sqlite::query_base (q)); + } + + template + inline bool database:: + query_one (const char* q, T& o) + { + return query_one (sqlite::query_base (q), o); + } + + template + inline T database:: + query_value (const char* q) + { + return query_value (sqlite::query_base (q)); + } + + template + inline typename object_traits::pointer_type database:: + query_one (const std::string& q) + { + return query_one (sqlite::query_base (q)); + } + + template + inline bool database:: + query_one (const std::string& q, T& o) + { + return query_one (sqlite::query_base (q), o); + } + + template + inline T database:: + query_value (const std::string& q) + { + return query_value (sqlite::query_base (q)); + } + + template + inline typename object_traits::pointer_type database:: + query_one (const sqlite::query_base& q) + { + // T is always object_type. We also don't need to check for transaction + // here; object_traits::query () does this. + // + return query_one_ (q); + } + + template + inline bool database:: + query_one (const sqlite::query_base& q, T& o) + { + // T is always object_type. We also don't need to check for transaction + // here; object_traits::query () does this. + // + return query_one_ (q, o); + } + + template + inline T database:: + query_value (const sqlite::query_base& q) + { + // T is always object_type. We also don't need to check for transaction + // here; object_traits::query () does this. + // + return query_value_ (q); + } + + template + inline typename object_traits::pointer_type database:: + query_one (const odb::query_base& q) + { + // Translate to native query. + // + return query_one (sqlite::query_base (q)); + } + + template + inline bool database:: + query_one (const odb::query_base& q, T& o) + { + // Translate to native query. + // + return query_one (sqlite::query_base (q), o); + } + + template + inline T database:: + query_value (const odb::query_base& q) + { + // Translate to native query. + // + return query_value (sqlite::query_base (q)); + } + + template + inline prepared_query database:: + prepare_query (const char* n, const char* q) + { + return prepare_query (n, sqlite::query_base (q)); + } + + template + inline prepared_query database:: + prepare_query (const char* n, const std::string& q) + { + return prepare_query (n, sqlite::query_base (q)); + } + + template + inline prepared_query database:: + prepare_query (const char* n, const sqlite::query_base& q) + { + // Throws if not in transaction. + // + sqlite::connection& c (transaction::current ().connection ()); + return c.prepare_query (n, q); + } + + template + inline prepared_query database:: + prepare_query (const char* n, const odb::query_base& q) + { + // Translate to native query. + // + return prepare_query (n, sqlite::query_base (q)); + } + } +} diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/details/config.h.in b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/details/config.h.in new file mode 100755 index 0000000..c8158be --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/details/config.h.in @@ -0,0 +1,14 @@ +/* file : odb/sqlite/details/config.h.in + * copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC + * license : GNU GPL v2; see accompanying LICENSE file + */ + +/* This file is automatically processed by configure. */ + +#ifndef ODB_SQLITE_DETAILS_CONFIG_H +#define ODB_SQLITE_DETAILS_CONFIG_H + +#undef LIBODB_SQLITE_STATIC_LIB +#undef LIBODB_SQLITE_HAVE_UNLOCK_NOTIFY + +#endif /* ODB_SQLITE_DETAILS_CONFIG_H */ diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/details/config.hxx b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/details/config.hxx new file mode 100755 index 0000000..5d19aad --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/details/config.hxx @@ -0,0 +1,19 @@ +// file : odb/sqlite/details/config.hxx +// copyright : Copyright (c) 2005-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_SQLITE_DETAILS_CONFIG_HXX +#define ODB_SQLITE_DETAILS_CONFIG_HXX + +// no pre + +#ifdef _MSC_VER +#elif defined(ODB_COMPILER) +# error libodb-sqlite header included in odb-compiled header +#else +# include +#endif + +// no post + +#endif // ODB_SQLITE_DETAILS_CONFIG_HXX diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/details/conversion.hxx b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/details/conversion.hxx new file mode 100755 index 0000000..fb53f66 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/details/conversion.hxx @@ -0,0 +1,59 @@ +// file : odb/sqlite/details/conversion.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_SQLITE_DETAILS_CONVERSION_HXX +#define ODB_SQLITE_DETAILS_CONVERSION_HXX + +#include + +#include + +namespace odb +{ + // @@ Revise this. + // + namespace details {} + + namespace sqlite + { + namespace details + { + using namespace odb::details; + + // Detect whether conversion is specified in type_traits. + // + template + meta::yes + conversion_p_test (typename type_traits::conversion*); + + template + meta::no + conversion_p_test (...); + + template + struct conversion_p + { + static const bool value = + sizeof (conversion_p_test (0)) == sizeof (meta::yes); + }; + + template ::value> + struct conversion; + + template + struct conversion + { + static const char* to () {return type_traits::conversion::to ();} + }; + + template + struct conversion + { + static const char* to () {return 0;} + }; + } + } +} + +#endif // ODB_SQLITE_DETAILS_CONVERSION_HXX diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/details/export.hxx b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/details/export.hxx new file mode 100755 index 0000000..30e9f8b --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/details/export.hxx @@ -0,0 +1,40 @@ +// file : odb/sqlite/details/export.hxx +// copyright : Copyright (c) 2005-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_SQLITE_DETAILS_EXPORT_HXX +#define ODB_SQLITE_DETAILS_EXPORT_HXX + +#include + +#include + +#ifdef LIBODB_SQLITE_STATIC_LIB +# define LIBODB_SQLITE_EXPORT +#else +# ifdef _WIN32 +# ifdef _MSC_VER +# ifdef LIBODB_SQLITE_DYNAMIC_LIB +# define LIBODB_SQLITE_EXPORT __declspec(dllexport) +# else +# define LIBODB_SQLITE_EXPORT __declspec(dllimport) +# endif +# else +# ifdef LIBODB_SQLITE_DYNAMIC_LIB +# ifdef DLL_EXPORT +# define LIBODB_SQLITE_EXPORT __declspec(dllexport) +# else +# define LIBODB_SQLITE_EXPORT +# endif +# else +# define LIBODB_SQLITE_EXPORT __declspec(dllimport) +# endif +# endif +# else +# define LIBODB_SQLITE_EXPORT +# endif +#endif + +#include + +#endif // ODB_SQLITE_DETAILS_EXPORT_HXX diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/details/options.cli b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/details/options.cli new file mode 100755 index 0000000..737a3d1 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/details/options.cli @@ -0,0 +1,47 @@ +// file : odb/sqlite/details/options.cli +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +include ; + +namespace odb +{ + namespace sqlite + { + namespace details + { + class options + { + std::string --database + { + "", + "SQLite database file name. If the database file is not specified + then a private, temporary on-disk database will be created. Use + the \cb{:memory:} special name to create a private, temporary + in-memory database." + }; + + bool --create + { + "Create the SQLite database if it does not already exist. By default + opening the database fails if it does not already exist." + }; + + bool --read-only + { + "Open the SQLite database in read-only mode. By default the database + is opened for reading and writing if possible, or reading only if + the file is write-protected by the operating system." + }; + + std::string --options-file + { + "", + "Read additional options from . Each option appearing on a + separate line optionally followed by space and an option value. + Empty lines and lines starting with \cb{#} are ignored." + }; + }; + } + } +} diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/details/options.cxx b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/details/options.cxx new file mode 100755 index 0000000..7fe8095 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/details/options.cxx @@ -0,0 +1,788 @@ +// This code was generated by CLI, a command line interface +// compiler for C++. +// + +// Begin prologue. +// +// +// End prologue. + +#include "options.hxx" + +#include +#include +#include +#include +#include +#include +#include +#include + +namespace odb +{ + namespace sqlite + { + namespace details + { + namespace cli + { + // unknown_option + // + unknown_option:: + ~unknown_option () throw () + { + } + + void unknown_option:: + print (::std::ostream& os) const + { + os << "unknown option '" << option ().c_str () << "'"; + } + + const char* unknown_option:: + what () const throw () + { + return "unknown option"; + } + + // unknown_argument + // + unknown_argument:: + ~unknown_argument () throw () + { + } + + void unknown_argument:: + print (::std::ostream& os) const + { + os << "unknown argument '" << argument ().c_str () << "'"; + } + + const char* unknown_argument:: + what () const throw () + { + return "unknown argument"; + } + + // missing_value + // + missing_value:: + ~missing_value () throw () + { + } + + void missing_value:: + print (::std::ostream& os) const + { + os << "missing value for option '" << option ().c_str () << "'"; + } + + const char* missing_value:: + what () const throw () + { + return "missing option value"; + } + + // invalid_value + // + invalid_value:: + ~invalid_value () throw () + { + } + + void invalid_value:: + print (::std::ostream& os) const + { + os << "invalid value '" << value ().c_str () << "' for option '" + << option ().c_str () << "'"; + } + + const char* invalid_value:: + what () const throw () + { + return "invalid option value"; + } + + // eos_reached + // + void eos_reached:: + print (::std::ostream& os) const + { + os << what (); + } + + const char* eos_reached:: + what () const throw () + { + return "end of argument stream reached"; + } + + // file_io_failure + // + file_io_failure:: + ~file_io_failure () throw () + { + } + + void file_io_failure:: + print (::std::ostream& os) const + { + os << "unable to open file '" << file ().c_str () << "' or read failure"; + } + + const char* file_io_failure:: + what () const throw () + { + return "unable to open file or read failure"; + } + + // unmatched_quote + // + unmatched_quote:: + ~unmatched_quote () throw () + { + } + + void unmatched_quote:: + print (::std::ostream& os) const + { + os << "unmatched quote in argument '" << argument ().c_str () << "'"; + } + + const char* unmatched_quote:: + what () const throw () + { + return "unmatched quote"; + } + + // scanner + // + scanner:: + ~scanner () + { + } + + // argv_scanner + // + bool argv_scanner:: + more () + { + return i_ < argc_; + } + + const char* argv_scanner:: + peek () + { + if (i_ < argc_) + return argv_[i_]; + else + throw eos_reached (); + } + + const char* argv_scanner:: + next () + { + if (i_ < argc_) + { + const char* r (argv_[i_]); + + if (erase_) + { + for (int i (i_ + 1); i < argc_; ++i) + argv_[i - 1] = argv_[i]; + + --argc_; + argv_[argc_] = 0; + } + else + ++i_; + + return r; + } + else + throw eos_reached (); + } + + void argv_scanner:: + skip () + { + if (i_ < argc_) + ++i_; + else + throw eos_reached (); + } + + // argv_file_scanner + // + bool argv_file_scanner:: + more () + { + if (!args_.empty ()) + return true; + + while (base::more ()) + { + // See if the next argument is the file option. + // + const char* a (base::peek ()); + const option_info* oi; + + if (!skip_ && (oi = find (a))) + { + base::next (); + + if (!base::more ()) + throw missing_value (oi->option); + + if (oi->search_func != 0) + { + std::string f (oi->search_func (base::next (), oi->arg)); + + if (!f.empty ()) + load (f); + } + else + load (base::next ()); + + if (!args_.empty ()) + return true; + } + else + { + if (!skip_) + skip_ = (std::strcmp (a, "--") == 0); + + return true; + } + } + + return false; + } + + const char* argv_file_scanner:: + peek () + { + if (!more ()) + throw eos_reached (); + + return args_.empty () ? base::peek () : args_.front ().c_str (); + } + + const char* argv_file_scanner:: + next () + { + if (!more ()) + throw eos_reached (); + + if (args_.empty ()) + return base::next (); + else + { + hold_.swap (args_.front ()); + args_.pop_front (); + return hold_.c_str (); + } + } + + void argv_file_scanner:: + skip () + { + if (!more ()) + throw eos_reached (); + + if (args_.empty ()) + return base::skip (); + else + args_.pop_front (); + } + + const argv_file_scanner::option_info* argv_file_scanner:: + find (const char* a) const + { + for (std::size_t i (0); i < options_count_; ++i) + if (std::strcmp (a, options_[i].option) == 0) + return &options_[i]; + + return 0; + } + + void argv_file_scanner:: + load (const std::string& file) + { + using namespace std; + + ifstream is (file.c_str ()); + + if (!is.is_open ()) + throw file_io_failure (file); + + while (!is.eof ()) + { + string line; + getline (is, line); + + if (is.fail () && !is.eof ()) + throw file_io_failure (file); + + string::size_type n (line.size ()); + + // Trim the line from leading and trailing whitespaces. + // + if (n != 0) + { + const char* f (line.c_str ()); + const char* l (f + n); + + const char* of (f); + while (f < l && (*f == ' ' || *f == '\t' || *f == '\r')) + ++f; + + --l; + + const char* ol (l); + while (l > f && (*l == ' ' || *l == '\t' || *l == '\r')) + --l; + + if (f != of || l != ol) + line = f <= l ? string (f, l - f + 1) : string (); + } + + // Ignore empty lines, those that start with #. + // + if (line.empty () || line[0] == '#') + continue; + + string::size_type p (line.find (' ')); + + if (p == string::npos) + { + if (!skip_) + skip_ = (line == "--"); + + args_.push_back (line); + } + else + { + string s1 (line, 0, p); + + // Skip leading whitespaces in the argument. + // + n = line.size (); + for (++p; p < n; ++p) + { + char c (line[p]); + + if (c != ' ' && c != '\t' && c != '\r') + break; + } + + string s2 (line, p); + + // If the string is wrapped in quotes, remove them. + // + n = s2.size (); + char cf (s2[0]), cl (s2[n - 1]); + + if (cf == '"' || cf == '\'' || cl == '"' || cl == '\'') + { + if (n == 1 || cf != cl) + throw unmatched_quote (s2); + + s2 = string (s2, 1, n - 2); + } + + const option_info* oi; + if (!skip_ && (oi = find (s1.c_str ()))) + { + if (s2.empty ()) + throw missing_value (oi->option); + + if (oi->search_func != 0) + { + std::string f (oi->search_func (s2.c_str (), oi->arg)); + + if (!f.empty ()) + load (f); + } + else + load (s2); + } + else + { + args_.push_back (s1); + args_.push_back (s2); + } + } + } + } + + template + struct parser + { + static void + parse (X& x, scanner& s) + { + std::string o (s.next ()); + + if (s.more ()) + { + std::string v (s.next ()); + std::istringstream is (v); + if (!(is >> x && is.eof ())) + throw invalid_value (o, v); + } + else + throw missing_value (o); + } + }; + + template <> + struct parser + { + static void + parse (bool& x, scanner& s) + { + s.next (); + x = true; + } + }; + + template <> + struct parser + { + static void + parse (std::string& x, scanner& s) + { + const char* o (s.next ()); + + if (s.more ()) + x = s.next (); + else + throw missing_value (o); + } + }; + + template + struct parser > + { + static void + parse (std::vector& c, scanner& s) + { + X x; + parser::parse (x, s); + c.push_back (x); + } + }; + + template + struct parser > + { + static void + parse (std::set& c, scanner& s) + { + X x; + parser::parse (x, s); + c.insert (x); + } + }; + + template + struct parser > + { + static void + parse (std::map& m, scanner& s) + { + std::string o (s.next ()); + + if (s.more ()) + { + std::string ov (s.next ()); + std::string::size_type p = ov.find ('='); + + if (p == std::string::npos) + { + K k = K (); + + if (!ov.empty ()) + { + std::istringstream ks (ov); + + if (!(ks >> k && ks.eof ())) + throw invalid_value (o, ov); + } + + m[k] = V (); + } + else + { + K k = K (); + V v = V (); + std::string kstr (ov, 0, p); + std::string vstr (ov, p + 1); + + if (!kstr.empty ()) + { + std::istringstream ks (kstr); + + if (!(ks >> k && ks.eof ())) + throw invalid_value (o, ov); + } + + if (!vstr.empty ()) + { + std::istringstream vs (vstr); + + if (!(vs >> v && vs.eof ())) + throw invalid_value (o, ov); + } + + m[k] = v; + } + } + else + throw missing_value (o); + } + }; + + template + void + thunk (X& x, scanner& s) + { + parser::parse (x.*M, s); + } + } + } + } +} + +#include +#include + +namespace odb +{ + namespace sqlite + { + namespace details + { + // options + // + + options:: + options () + : database_ (), + create_ (), + read_only_ (), + options_file_ () + { + } + + options:: + options (int& argc, + char** argv, + bool erase, + ::odb::sqlite::details::cli::unknown_mode opt, + ::odb::sqlite::details::cli::unknown_mode arg) + : database_ (), + create_ (), + read_only_ (), + options_file_ () + { + ::odb::sqlite::details::cli::argv_scanner s (argc, argv, erase); + _parse (s, opt, arg); + } + + options:: + options (int start, + int& argc, + char** argv, + bool erase, + ::odb::sqlite::details::cli::unknown_mode opt, + ::odb::sqlite::details::cli::unknown_mode arg) + : database_ (), + create_ (), + read_only_ (), + options_file_ () + { + ::odb::sqlite::details::cli::argv_scanner s (start, argc, argv, erase); + _parse (s, opt, arg); + } + + options:: + options (int& argc, + char** argv, + int& end, + bool erase, + ::odb::sqlite::details::cli::unknown_mode opt, + ::odb::sqlite::details::cli::unknown_mode arg) + : database_ (), + create_ (), + read_only_ (), + options_file_ () + { + ::odb::sqlite::details::cli::argv_scanner s (argc, argv, erase); + _parse (s, opt, arg); + end = s.end (); + } + + options:: + options (int start, + int& argc, + char** argv, + int& end, + bool erase, + ::odb::sqlite::details::cli::unknown_mode opt, + ::odb::sqlite::details::cli::unknown_mode arg) + : database_ (), + create_ (), + read_only_ (), + options_file_ () + { + ::odb::sqlite::details::cli::argv_scanner s (start, argc, argv, erase); + _parse (s, opt, arg); + end = s.end (); + } + + options:: + options (::odb::sqlite::details::cli::scanner& s, + ::odb::sqlite::details::cli::unknown_mode opt, + ::odb::sqlite::details::cli::unknown_mode arg) + : database_ (), + create_ (), + read_only_ (), + options_file_ () + { + _parse (s, opt, arg); + } + + void options:: + print_usage (::std::ostream& os) + { + os << "--database SQLite database file name. If the database file is not" << ::std::endl + << " specified then a private, temporary on-disk database will" << ::std::endl + << " be created. Use the ':memory:' special name to create a" << ::std::endl + << " private, temporary in-memory database." << ::std::endl; + + os << "--create Create the SQLite database if it does not already exist." << ::std::endl + << " By default opening the database fails if it does not" << ::std::endl + << " already exist." << ::std::endl; + + os << "--read-only Open the SQLite database in read-only mode. By default" << ::std::endl + << " the database is opened for reading and writing if" << ::std::endl + << " possible, or reading only if the file is write-protected" << ::std::endl + << " by the operating system." << ::std::endl; + + os << "--options-file Read additional options from . Each option" << ::std::endl + << " appearing on a separate line optionally followed by space" << ::std::endl + << " and an option value. Empty lines and lines starting with" << ::std::endl + << " '#' are ignored." << ::std::endl; + } + + typedef + std::map + _cli_options_map; + + static _cli_options_map _cli_options_map_; + + struct _cli_options_map_init + { + _cli_options_map_init () + { + _cli_options_map_["--database"] = + &::odb::sqlite::details::cli::thunk< options, std::string, &options::database_ >; + _cli_options_map_["--create"] = + &::odb::sqlite::details::cli::thunk< options, bool, &options::create_ >; + _cli_options_map_["--read-only"] = + &::odb::sqlite::details::cli::thunk< options, bool, &options::read_only_ >; + _cli_options_map_["--options-file"] = + &::odb::sqlite::details::cli::thunk< options, std::string, &options::options_file_ >; + } + }; + + static _cli_options_map_init _cli_options_map_init_; + + bool options:: + _parse (const char* o, ::odb::sqlite::details::cli::scanner& s) + { + _cli_options_map::const_iterator i (_cli_options_map_.find (o)); + + if (i != _cli_options_map_.end ()) + { + (*(i->second)) (*this, s); + return true; + } + + return false; + } + + void options:: + _parse (::odb::sqlite::details::cli::scanner& s, + ::odb::sqlite::details::cli::unknown_mode opt_mode, + ::odb::sqlite::details::cli::unknown_mode arg_mode) + { + bool opt = true; + + while (s.more ()) + { + const char* o = s.peek (); + + if (std::strcmp (o, "--") == 0) + { + s.skip (); + opt = false; + continue; + } + + if (opt && _parse (o, s)); + else if (opt && std::strncmp (o, "-", 1) == 0 && o[1] != '\0') + { + switch (opt_mode) + { + case ::odb::sqlite::details::cli::unknown_mode::skip: + { + s.skip (); + continue; + } + case ::odb::sqlite::details::cli::unknown_mode::stop: + { + break; + } + case ::odb::sqlite::details::cli::unknown_mode::fail: + { + throw ::odb::sqlite::details::cli::unknown_option (o); + } + } + + break; + } + else + { + switch (arg_mode) + { + case ::odb::sqlite::details::cli::unknown_mode::skip: + { + s.skip (); + continue; + } + case ::odb::sqlite::details::cli::unknown_mode::stop: + { + break; + } + case ::odb::sqlite::details::cli::unknown_mode::fail: + { + throw ::odb::sqlite::details::cli::unknown_argument (o); + } + } + + break; + } + } + } + } + } +} + +// Begin epilogue. +// +// +// End epilogue. + diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/details/options.hxx b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/details/options.hxx new file mode 100755 index 0000000..2bc08d1 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/details/options.hxx @@ -0,0 +1,418 @@ +// This code was generated by CLI, a command line interface +// compiler for C++. +// + +#ifndef LIBODB_SQLITE_DETAILS_OPTIONS_HXX +#define LIBODB_SQLITE_DETAILS_OPTIONS_HXX + +// Begin prologue. +// +// +// End prologue. + +#include +#include +#include +#include +#include + +namespace odb +{ + namespace sqlite + { + namespace details + { + namespace cli + { + class unknown_mode + { + public: + enum value + { + skip, + stop, + fail + }; + + unknown_mode (value v); + + operator value () const + { + return v_; + } + + private: + value v_; + }; + + // Exceptions. + // + + class exception: public std::exception + { + public: + virtual void + print (::std::ostream&) const = 0; + }; + + ::std::ostream& + operator<< (::std::ostream&, const exception&); + + class unknown_option: public exception + { + public: + virtual + ~unknown_option () throw (); + + unknown_option (const std::string& option); + + const std::string& + option () const; + + virtual void + print (::std::ostream&) const; + + virtual const char* + what () const throw (); + + private: + std::string option_; + }; + + class unknown_argument: public exception + { + public: + virtual + ~unknown_argument () throw (); + + unknown_argument (const std::string& argument); + + const std::string& + argument () const; + + virtual void + print (::std::ostream&) const; + + virtual const char* + what () const throw (); + + private: + std::string argument_; + }; + + class missing_value: public exception + { + public: + virtual + ~missing_value () throw (); + + missing_value (const std::string& option); + + const std::string& + option () const; + + virtual void + print (::std::ostream&) const; + + virtual const char* + what () const throw (); + + private: + std::string option_; + }; + + class invalid_value: public exception + { + public: + virtual + ~invalid_value () throw (); + + invalid_value (const std::string& option, + const std::string& value); + + const std::string& + option () const; + + const std::string& + value () const; + + virtual void + print (::std::ostream&) const; + + virtual const char* + what () const throw (); + + private: + std::string option_; + std::string value_; + }; + + class eos_reached: public exception + { + public: + virtual void + print (::std::ostream&) const; + + virtual const char* + what () const throw (); + }; + + class file_io_failure: public exception + { + public: + virtual + ~file_io_failure () throw (); + + file_io_failure (const std::string& file); + + const std::string& + file () const; + + virtual void + print (::std::ostream&) const; + + virtual const char* + what () const throw (); + + private: + std::string file_; + }; + + class unmatched_quote: public exception + { + public: + virtual + ~unmatched_quote () throw (); + + unmatched_quote (const std::string& argument); + + const std::string& + argument () const; + + virtual void + print (::std::ostream&) const; + + virtual const char* + what () const throw (); + + private: + std::string argument_; + }; + + class scanner + { + public: + virtual + ~scanner (); + + virtual bool + more () = 0; + + virtual const char* + peek () = 0; + + virtual const char* + next () = 0; + + virtual void + skip () = 0; + }; + + class argv_scanner: public scanner + { + public: + argv_scanner (int& argc, char** argv, bool erase = false); + argv_scanner (int start, int& argc, char** argv, bool erase = false); + + int + end () const; + + virtual bool + more (); + + virtual const char* + peek (); + + virtual const char* + next (); + + virtual void + skip (); + + private: + int i_; + int& argc_; + char** argv_; + bool erase_; + }; + + class argv_file_scanner: public argv_scanner + { + public: + argv_file_scanner (int& argc, + char** argv, + const std::string& option, + bool erase = false); + + argv_file_scanner (int start, + int& argc, + char** argv, + const std::string& option, + bool erase = false); + + struct option_info + { + // If search_func is not NULL, it is called, with the arg + // value as the second argument, to locate the options file. + // If it returns an empty string, then the file is ignored. + // + const char* option; + std::string (*search_func) (const char*, void* arg); + void* arg; + }; + + argv_file_scanner (int& argc, + char** argv, + const option_info* options, + std::size_t options_count, + bool erase = false); + + argv_file_scanner (int start, + int& argc, + char** argv, + const option_info* options, + std::size_t options_count, + bool erase = false); + + virtual bool + more (); + + virtual const char* + peek (); + + virtual const char* + next (); + + virtual void + skip (); + + private: + const option_info* + find (const char*) const; + + void + load (const std::string& file); + + typedef argv_scanner base; + + const std::string option_; + option_info option_info_; + const option_info* options_; + std::size_t options_count_; + + std::string hold_; + std::deque args_; + bool skip_; + }; + + template + struct parser; + } + } + } +} + +#include + +namespace odb +{ + namespace sqlite + { + namespace details + { + class options + { + public: + options (int& argc, + char** argv, + bool erase = false, + ::odb::sqlite::details::cli::unknown_mode option = ::odb::sqlite::details::cli::unknown_mode::fail, + ::odb::sqlite::details::cli::unknown_mode argument = ::odb::sqlite::details::cli::unknown_mode::stop); + + options (int start, + int& argc, + char** argv, + bool erase = false, + ::odb::sqlite::details::cli::unknown_mode option = ::odb::sqlite::details::cli::unknown_mode::fail, + ::odb::sqlite::details::cli::unknown_mode argument = ::odb::sqlite::details::cli::unknown_mode::stop); + + options (int& argc, + char** argv, + int& end, + bool erase = false, + ::odb::sqlite::details::cli::unknown_mode option = ::odb::sqlite::details::cli::unknown_mode::fail, + ::odb::sqlite::details::cli::unknown_mode argument = ::odb::sqlite::details::cli::unknown_mode::stop); + + options (int start, + int& argc, + char** argv, + int& end, + bool erase = false, + ::odb::sqlite::details::cli::unknown_mode option = ::odb::sqlite::details::cli::unknown_mode::fail, + ::odb::sqlite::details::cli::unknown_mode argument = ::odb::sqlite::details::cli::unknown_mode::stop); + + options (::odb::sqlite::details::cli::scanner&, + ::odb::sqlite::details::cli::unknown_mode option = ::odb::sqlite::details::cli::unknown_mode::fail, + ::odb::sqlite::details::cli::unknown_mode argument = ::odb::sqlite::details::cli::unknown_mode::stop); + + options (); + + // Option accessors. + // + const std::string& + database () const; + + const bool& + create () const; + + const bool& + read_only () const; + + const std::string& + options_file () const; + + // Print usage information. + // + static void + print_usage (::std::ostream&); + + // Implementation details. + // + protected: + bool + _parse (const char*, ::odb::sqlite::details::cli::scanner&); + + private: + void + _parse (::odb::sqlite::details::cli::scanner&, + ::odb::sqlite::details::cli::unknown_mode option, + ::odb::sqlite::details::cli::unknown_mode argument); + + public: + std::string database_; + bool create_; + bool read_only_; + std::string options_file_; + }; + } + } +} + +#include "options.ixx" + +// Begin epilogue. +// +// +// End epilogue. + +#endif // LIBODB_SQLITE_DETAILS_OPTIONS_HXX diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/details/options.ixx b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/details/options.ixx new file mode 100755 index 0000000..0d7ac8e --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/details/options.ixx @@ -0,0 +1,249 @@ +// This code was generated by CLI, a command line interface +// compiler for C++. +// + +// Begin prologue. +// +// +// End prologue. + +namespace odb +{ + namespace sqlite + { + namespace details + { + namespace cli + { + // unknown_mode + // + inline unknown_mode:: + unknown_mode (value v) + : v_ (v) + { + } + + // exception + // + inline ::std::ostream& + operator<< (::std::ostream& os, const exception& e) + { + e.print (os); + return os; + } + + // unknown_option + // + inline unknown_option:: + unknown_option (const std::string& option) + : option_ (option) + { + } + + inline const std::string& unknown_option:: + option () const + { + return option_; + } + + // unknown_argument + // + inline unknown_argument:: + unknown_argument (const std::string& argument) + : argument_ (argument) + { + } + + inline const std::string& unknown_argument:: + argument () const + { + return argument_; + } + + // missing_value + // + inline missing_value:: + missing_value (const std::string& option) + : option_ (option) + { + } + + inline const std::string& missing_value:: + option () const + { + return option_; + } + + // invalid_value + // + inline invalid_value:: + invalid_value (const std::string& option, + const std::string& value) + : option_ (option), value_ (value) + { + } + + inline const std::string& invalid_value:: + option () const + { + return option_; + } + + inline const std::string& invalid_value:: + value () const + { + return value_; + } + + // file_io_failure + // + inline file_io_failure:: + file_io_failure (const std::string& file) + : file_ (file) + { + } + + inline const std::string& file_io_failure:: + file () const + { + return file_; + } + + // unmatched_quote + // + inline unmatched_quote:: + unmatched_quote (const std::string& argument) + : argument_ (argument) + { + } + + inline const std::string& unmatched_quote:: + argument () const + { + return argument_; + } + + // argv_scanner + // + inline argv_scanner:: + argv_scanner (int& argc, char** argv, bool erase) + : i_ (1), argc_ (argc), argv_ (argv), erase_ (erase) + { + } + + inline argv_scanner:: + argv_scanner (int start, int& argc, char** argv, bool erase) + : i_ (start), argc_ (argc), argv_ (argv), erase_ (erase) + { + } + + inline int argv_scanner:: + end () const + { + return i_; + } + + // argv_file_scanner + // + inline argv_file_scanner:: + argv_file_scanner (int& argc, + char** argv, + const std::string& option, + bool erase) + : argv_scanner (argc, argv, erase), + option_ (option), + options_ (&option_info_), + options_count_ (1), + skip_ (false) + { + option_info_.option = option_.c_str (); + option_info_.search_func = 0; + } + + inline argv_file_scanner:: + argv_file_scanner (int start, + int& argc, + char** argv, + const std::string& option, + bool erase) + : argv_scanner (start, argc, argv, erase), + option_ (option), + options_ (&option_info_), + options_count_ (1), + skip_ (false) + { + option_info_.option = option_.c_str (); + option_info_.search_func = 0; + } + + inline argv_file_scanner:: + argv_file_scanner (int& argc, + char** argv, + const option_info* options, + std::size_t options_count, + bool erase) + : argv_scanner (argc, argv, erase), + options_ (options), + options_count_ (options_count), + skip_ (false) + { + } + + inline argv_file_scanner:: + argv_file_scanner (int start, + int& argc, + char** argv, + const option_info* options, + std::size_t options_count, + bool erase) + : argv_scanner (start, argc, argv, erase), + options_ (options), + options_count_ (options_count), + skip_ (false) + { + } + } + } + } +} + +namespace odb +{ + namespace sqlite + { + namespace details + { + // options + // + + inline const std::string& options:: + database () const + { + return this->database_; + } + + inline const bool& options:: + create () const + { + return this->create_; + } + + inline const bool& options:: + read_only () const + { + return this->read_only_; + } + + inline const std::string& options:: + options_file () const + { + return this->options_file_; + } + } + } +} + +// Begin epilogue. +// +// +// End epilogue. diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/error.cxx b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/error.cxx new file mode 100755 index 0000000..ce320a1 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/error.cxx @@ -0,0 +1,95 @@ +// file : odb/sqlite/error.cxx +// copyright : Copyright (c) 2005-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include + +#include // std::bad_alloc +#include + +#include +#include + +#include // LIBODB_SQLITE_HAVE_UNLOCK_NOTIFY + +using namespace std; + +namespace odb +{ + namespace sqlite + { + void + translate_error (int e, connection& c) + { + sqlite3* h (c.handle ()); + + // Extended error codes are only available in 3.6.5 and later. + // +#if SQLITE_VERSION_NUMBER >= 3006005 + int ee (sqlite3_extended_errcode (h)); +#else + int ee (0); +#endif + string m; + + switch (e) + { + case SQLITE_NOMEM: + { + throw bad_alloc (); + } + case SQLITE_MISUSE: + { + // In case of SQLITE_MISUSE, error code/message may or may not + // be set. + // + ee = e; + m = "SQLite API misuse"; + break; + } +#ifdef SQLITE_ABORT_ROLLBACK + case SQLITE_ABORT: + { + if (ee == SQLITE_ABORT_ROLLBACK) + throw forced_rollback (); + + break; + } +#endif + case SQLITE_LOCKED: + { +#ifdef LIBODB_SQLITE_HAVE_UNLOCK_NOTIFY + if (ee != SQLITE_LOCKED_SHAREDCACHE) + throw deadlock (); // The DROP TABLE special case. +#endif + // Getting SQLITE_LOCKED_SHAREDCACHE here means we don't have + // the unlock notify support. Translate this to timeout. + // + throw timeout (); + } + case SQLITE_BUSY: + case SQLITE_IOERR: + { +#if SQLITE_VERSION_NUMBER >= 3006005 + if (e != SQLITE_IOERR || ee == SQLITE_IOERR_BLOCKED) + throw timeout (); +#endif + break; + } + default: + break; + } + + if (m.empty ()) + m = sqlite3_errmsg (h); + + // Get rid of a trailing newline if there is one. + // + string::size_type n (m.size ()); + if (n != 0 && m[n - 1] == '\n') + m.resize (n - 1); + + throw database_exception (e, ee, m); + } + } +} diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/error.hxx b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/error.hxx new file mode 100755 index 0000000..3b48d39 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/error.hxx @@ -0,0 +1,28 @@ +// file : odb/sqlite/error.hxx +// copyright : Copyright (c) 2005-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_SQLITE_ERROR_HXX +#define ODB_SQLITE_ERROR_HXX + +#include + +#include +#include + +namespace odb +{ + namespace sqlite + { + class connection; + + // Translate SQLite error and throw an appropriate exception. + // + LIBODB_SQLITE_EXPORT void + translate_error (int error, connection&); + } +} + +#include + +#endif // ODB_SQLITE_ERROR_HXX diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/exceptions.cxx b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/exceptions.cxx new file mode 100755 index 0000000..77436ae --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/exceptions.cxx @@ -0,0 +1,93 @@ +// file : odb/sqlite/exceptions.cxx +// copyright : Copyright (c) 2005-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include + +#include + +using namespace std; + +namespace odb +{ + namespace sqlite + { + // + // forced_rollback + // + + const char* forced_rollback:: + what () const throw () + { + return "transaction is forced to rollback"; + } + + forced_rollback* forced_rollback:: + clone () const + { + return new forced_rollback (*this); + } + + // + // database_exception + // + + database_exception:: + ~database_exception () throw () + { + } + + database_exception:: + database_exception (int e, int ee, const string& m) + : error_ (e), extended_error_ (ee), message_ (m) + { + ostringstream ostr; + ostr << error_; + + if (error_ != extended_error_) + ostr << " (" << extended_error_ << ")"; + + ostr << ": " << message_; + what_ = ostr.str (); + } + + const char* database_exception:: + what () const throw () + { + return what_.c_str (); + } + + database_exception* database_exception:: + clone () const + { + return new database_exception (*this); + } + + // + // cli_exception + // + + cli_exception:: + cli_exception (const std::string& what) + : what_ (what) + { + } + + cli_exception:: + ~cli_exception () throw () + { + } + + const char* cli_exception:: + what () const throw () + { + return what_.c_str (); + } + + cli_exception* cli_exception:: + clone () const + { + return new cli_exception (*this); + } + } +} diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/exceptions.hxx b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/exceptions.hxx new file mode 100755 index 0000000..067abcc --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/exceptions.hxx @@ -0,0 +1,101 @@ +// file : odb/sqlite/exceptions.hxx +// copyright : Copyright (c) 2005-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_SQLITE_EXCEPTIONS_HXX +#define ODB_SQLITE_EXCEPTIONS_HXX + +#include + +#include + +#include + +#include +#include +#include + +namespace odb +{ + namespace sqlite + { + // This exception is thrown if SQLite is forcing the current transaction + // to rollback. This can happen in SQLite 3.7.11 or later if one of the + // connections participating in the shared cache rolls back a transaction. + // See the SQLITE_ABORT_ROLLBACK extended error code for detail on this + // behavior. + // + struct LIBODB_SQLITE_EXPORT forced_rollback: recoverable + { + virtual const char* + what () const throw (); + + virtual forced_rollback* + clone () const; + }; + + struct LIBODB_SQLITE_EXPORT database_exception: odb::database_exception + { + database_exception (int error, + int extended_error, + const std::string& message); + + ~database_exception () throw (); + + int + error () const + { + return error_; + } + + int + extended_error () const + { + return extended_error_; + } + + const std::string& + message () const + { + return message_; + } + + virtual const char* + what () const throw (); + + virtual database_exception* + clone () const; + + private: + int error_; + int extended_error_; + std::string message_; + std::string what_; + }; + + struct LIBODB_SQLITE_EXPORT cli_exception: odb::exception + { + cli_exception (const std::string& what); + ~cli_exception () throw (); + + virtual const char* + what () const throw (); + + virtual cli_exception* + clone () const; + + private: + std::string what_; + }; + + namespace core + { + using sqlite::database_exception; + using sqlite::cli_exception; + } + } +} + +#include + +#endif // ODB_SQLITE_EXCEPTIONS_HXX diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/forward.hxx b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/forward.hxx new file mode 100755 index 0000000..4d9a063 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/forward.hxx @@ -0,0 +1,100 @@ +// file : odb/sqlite/forward.hxx +// copyright : Copyright (c) 2005-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_SQLITE_FORWARD_HXX +#define ODB_SQLITE_FORWARD_HXX + +#include + +#include + +namespace odb +{ + namespace sqlite + { + namespace core + { + using namespace odb::common; + } + + // + // + class database; + class connection; + typedef details::shared_ptr connection_ptr; + class connection_factory; + class statement; + class transaction; + class tracer; + + namespace core + { + using sqlite::database; + using sqlite::connection; + using sqlite::connection_ptr; + using sqlite::transaction; + using sqlite::statement; + } + + // Implementation details. + // + enum statement_kind + { + statement_select, + statement_insert, + statement_update, + statement_delete, + statement_generic + }; + + class binding; + class select_statement; + + template + class object_statements; + + template + class polymorphic_root_object_statements; + + template + class polymorphic_derived_object_statements; + + template + class no_id_object_statements; + + template + class view_statements; + + template + class container_statements; + + template + class smart_container_statements; + + template + class section_statements; + + class query_base; + class query_params; + } + + namespace details + { + template <> + struct counter_type + { + typedef shared_base counter; + }; + + template <> + struct counter_type + { + typedef shared_base counter; + }; + } +} + +#include + +#endif // ODB_SQLITE_FORWARD_HXX diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/libodb-sqlite-vc10.vcxproj b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/libodb-sqlite-vc10.vcxproj new file mode 100755 index 0000000..5cbe977 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/libodb-sqlite-vc10.vcxproj @@ -0,0 +1,253 @@ + + + + + Debug + Win32 + + + Debug + x64 + + + Release + Win32 + + + Release + x64 + + + + {BE62AFC4-4624-4CDA-A7CD-E9451D34AB6E} + Win32Proj + libodb-sqlite + + + + DynamicLibrary + true + Unicode + + + DynamicLibrary + true + Unicode + + + DynamicLibrary + false + true + Unicode + + + DynamicLibrary + false + true + Unicode + + + + + + + + + + + + + + + + + + + true + ..\..\bin\ + odb-sqlite-d-2.4-vc10 + + + true + ..\..\bin64\ + odb-sqlite-d-2.4-vc10 + + + false + ..\..\bin\ + odb-sqlite-2.4-vc10 + + + false + ..\..\bin64\ + odb-sqlite-2.4-vc10 + + + + + + Level3 + Disabled + WIN32;_DEBUG;_WINDOWS;_USRDLL;LIBODB_SQLITE_DYNAMIC_LIB;LIBODB_SQLITE_HAVE_UNLOCK_NOTIFY;%(PreprocessorDefinitions) + ..\.. + 4355;4800;4290;4251;4267;%(DisableSpecificWarnings) + + + odb-d.lib;sqlite3.lib;%(AdditionalDependencies) + Windows + true + $(TargetPath) + ..\..\lib\odb-sqlite-d.lib + + + + + + + Level3 + Disabled + WIN32;_DEBUG;_WINDOWS;_USRDLL;LIBODB_SQLITE_DYNAMIC_LIB;LIBODB_SQLITE_HAVE_UNLOCK_NOTIFY;%(PreprocessorDefinitions) + ..\.. + 4355;4800;4290;4251;4267;%(DisableSpecificWarnings) + + + odb-d.lib;sqlite3.lib;%(AdditionalDependencies) + Windows + true + $(TargetPath) + ..\..\lib64\odb-sqlite-d.lib + + + + + Level3 + + + MaxSpeed + true + true + WIN32;NDEBUG;_WINDOWS;_USRDLL;LIBODB_SQLITE_DYNAMIC_LIB;LIBODB_SQLITE_HAVE_UNLOCK_NOTIFY;%(PreprocessorDefinitions) + ..\.. + 4355;4800;4290;4251;4267;%(DisableSpecificWarnings) + + + odb.lib;sqlite3.lib;%(AdditionalDependencies) + Windows + true + true + true + $(TargetPath) + ..\..\lib\odb-sqlite.lib + + + + + Level3 + + + MaxSpeed + true + true + WIN32;NDEBUG;_WINDOWS;_USRDLL;LIBODB_SQLITE_DYNAMIC_LIB;LIBODB_SQLITE_HAVE_UNLOCK_NOTIFY;%(PreprocessorDefinitions) + ..\.. + 4355;4800;4290;4251;4267;%(DisableSpecificWarnings) + + + odb.lib;sqlite3.lib;%(AdditionalDependencies) + Windows + true + true + true + $(TargetPath) + ..\..\lib64\odb-sqlite.lib + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + $(IntDir)\details\ + $(IntDir)\details\ + $(IntDir)\details\ + $(IntDir)\details\ + + + + + + diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/libodb-sqlite-vc10.vcxproj.filters b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/libodb-sqlite-vc10.vcxproj.filters new file mode 100755 index 0000000..57fb23b --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/libodb-sqlite-vc10.vcxproj.filters @@ -0,0 +1,241 @@ + + + + + {CAE48EC7-E979-4076-ABDB-DF5CFD41D7AB} + cxx + + + {1C70458E-63CA-455F-AFDC-E2F291BD0F2A} + h;hxx;ixx;txx + + + + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/libodb-sqlite-vc11.vcxproj b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/libodb-sqlite-vc11.vcxproj new file mode 100755 index 0000000..02aff26 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/libodb-sqlite-vc11.vcxproj @@ -0,0 +1,257 @@ + + + + + Debug + Win32 + + + Debug + x64 + + + Release + Win32 + + + Release + x64 + + + + {BE62AFC4-4624-4CDA-A7CD-E9451D34AB6E} + Win32Proj + libodb-sqlite + + + + DynamicLibrary + true + v110 + Unicode + + + DynamicLibrary + true + v110 + Unicode + + + DynamicLibrary + false + v110 + true + Unicode + + + DynamicLibrary + false + v110 + true + Unicode + + + + + + + + + + + + + + + + + + + true + ..\..\bin\ + odb-sqlite-d-2.4-vc11 + + + true + ..\..\bin64\ + odb-sqlite-d-2.4-vc11 + + + false + ..\..\bin\ + odb-sqlite-2.4-vc11 + + + false + ..\..\bin64\ + odb-sqlite-2.4-vc11 + + + + + + Level3 + Disabled + WIN32;_DEBUG;_WINDOWS;_USRDLL;LIBODB_SQLITE_DYNAMIC_LIB;LIBODB_SQLITE_HAVE_UNLOCK_NOTIFY;%(PreprocessorDefinitions) + ..\.. + 4355;4800;4290;4251;4267;%(DisableSpecificWarnings) + + + odb-d.lib;sqlite3.lib;%(AdditionalDependencies) + Windows + true + $(TargetPath) + ..\..\lib\odb-sqlite-d.lib + + + + + + + Level3 + Disabled + WIN32;_DEBUG;_WINDOWS;_USRDLL;LIBODB_SQLITE_DYNAMIC_LIB;LIBODB_SQLITE_HAVE_UNLOCK_NOTIFY;%(PreprocessorDefinitions) + ..\.. + 4355;4800;4290;4251;4267;%(DisableSpecificWarnings) + + + odb-d.lib;sqlite3.lib;%(AdditionalDependencies) + Windows + true + $(TargetPath) + ..\..\lib64\odb-sqlite-d.lib + + + + + Level3 + + + MaxSpeed + true + true + WIN32;NDEBUG;_WINDOWS;_USRDLL;LIBODB_SQLITE_DYNAMIC_LIB;LIBODB_SQLITE_HAVE_UNLOCK_NOTIFY;%(PreprocessorDefinitions) + ..\.. + 4355;4800;4290;4251;4267;%(DisableSpecificWarnings) + + + odb.lib;sqlite3.lib;%(AdditionalDependencies) + Windows + true + true + true + $(TargetPath) + ..\..\lib\odb-sqlite.lib + + + + + Level3 + + + MaxSpeed + true + true + WIN32;NDEBUG;_WINDOWS;_USRDLL;LIBODB_SQLITE_DYNAMIC_LIB;LIBODB_SQLITE_HAVE_UNLOCK_NOTIFY;%(PreprocessorDefinitions) + ..\.. + 4355;4800;4290;4251;4267;%(DisableSpecificWarnings) + + + odb.lib;sqlite3.lib;%(AdditionalDependencies) + Windows + true + true + true + $(TargetPath) + ..\..\lib64\odb-sqlite.lib + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + $(IntDir)\details\ + $(IntDir)\details\ + $(IntDir)\details\ + $(IntDir)\details\ + + + + + + diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/libodb-sqlite-vc11.vcxproj.filters b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/libodb-sqlite-vc11.vcxproj.filters new file mode 100755 index 0000000..57fb23b --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/libodb-sqlite-vc11.vcxproj.filters @@ -0,0 +1,241 @@ + + + + + {CAE48EC7-E979-4076-ABDB-DF5CFD41D7AB} + cxx + + + {1C70458E-63CA-455F-AFDC-E2F291BD0F2A} + h;hxx;ixx;txx + + + + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/libodb-sqlite-vc12.vcxproj b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/libodb-sqlite-vc12.vcxproj new file mode 100755 index 0000000..c0e85fd --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/libodb-sqlite-vc12.vcxproj @@ -0,0 +1,261 @@ + + + + + Debug + Win32 + + + Debug + x64 + + + Release + Win32 + + + Release + x64 + + + + {BE62AFC4-4624-4CDA-A7CD-E9451D34AB6E} + Win32Proj + libodb-sqlite + + + + DynamicLibrary + true + v120 + Unicode + + + DynamicLibrary + true + v120 + Unicode + + + DynamicLibrary + false + v120 + true + Unicode + + + DynamicLibrary + false + v120 + true + Unicode + + + + + + + + + + + + + + + + + + + true + ..\..\bin\ + odb-sqlite-d-2.4-vc12 + + + true + ..\..\bin64\ + odb-sqlite-d-2.4-vc12 + + + false + ..\..\bin\ + odb-sqlite-2.4-vc12 + + + false + ..\..\bin64\ + odb-sqlite-2.4-vc12 + + + + + + Level3 + Disabled + WIN32;_DEBUG;_WINDOWS;_USRDLL;LIBODB_SQLITE_DYNAMIC_LIB;LIBODB_SQLITE_HAVE_UNLOCK_NOTIFY;%(PreprocessorDefinitions) + ..\.. + 4355;4800;4290;4251;4267;%(DisableSpecificWarnings) + true + + + odb-d.lib;sqlite3.lib;%(AdditionalDependencies) + Windows + true + $(TargetPath) + ..\..\lib\odb-sqlite-d.lib + + + + + + + Level3 + Disabled + WIN32;_DEBUG;_WINDOWS;_USRDLL;LIBODB_SQLITE_DYNAMIC_LIB;LIBODB_SQLITE_HAVE_UNLOCK_NOTIFY;%(PreprocessorDefinitions) + ..\.. + 4355;4800;4290;4251;4267;%(DisableSpecificWarnings) + true + + + odb-d.lib;sqlite3.lib;%(AdditionalDependencies) + Windows + true + $(TargetPath) + ..\..\lib64\odb-sqlite-d.lib + + + + + Level3 + + + MaxSpeed + true + true + WIN32;NDEBUG;_WINDOWS;_USRDLL;LIBODB_SQLITE_DYNAMIC_LIB;LIBODB_SQLITE_HAVE_UNLOCK_NOTIFY;%(PreprocessorDefinitions) + ..\.. + 4355;4800;4290;4251;4267;%(DisableSpecificWarnings) + true + + + odb.lib;sqlite3.lib;%(AdditionalDependencies) + Windows + true + true + true + $(TargetPath) + ..\..\lib\odb-sqlite.lib + + + + + Level3 + + + MaxSpeed + true + true + WIN32;NDEBUG;_WINDOWS;_USRDLL;LIBODB_SQLITE_DYNAMIC_LIB;LIBODB_SQLITE_HAVE_UNLOCK_NOTIFY;%(PreprocessorDefinitions) + ..\.. + 4355;4800;4290;4251;4267;%(DisableSpecificWarnings) + true + + + odb.lib;sqlite3.lib;%(AdditionalDependencies) + Windows + true + true + true + $(TargetPath) + ..\..\lib64\odb-sqlite.lib + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + $(IntDir)\details\ + $(IntDir)\details\ + $(IntDir)\details\ + $(IntDir)\details\ + + + + + + diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/libodb-sqlite-vc12.vcxproj.filters b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/libodb-sqlite-vc12.vcxproj.filters new file mode 100755 index 0000000..57fb23b --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/libodb-sqlite-vc12.vcxproj.filters @@ -0,0 +1,241 @@ + + + + + {CAE48EC7-E979-4076-ABDB-DF5CFD41D7AB} + cxx + + + {1C70458E-63CA-455F-AFDC-E2F291BD0F2A} + h;hxx;ixx;txx + + + + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/libodb-sqlite-vc8.vcproj b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/libodb-sqlite-vc8.vcproj new file mode 100755 index 0000000..520a20d --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/libodb-sqlite-vc8.vcproj @@ -0,0 +1,680 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/libodb-sqlite-vc9.vcproj b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/libodb-sqlite-vc9.vcproj new file mode 100755 index 0000000..e440893 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/libodb-sqlite-vc9.vcproj @@ -0,0 +1,687 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/no-id-object-result.hxx b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/no-id-object-result.hxx new file mode 100755 index 0000000..0e0df00 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/no-id-object-result.hxx @@ -0,0 +1,81 @@ +// file : odb/sqlite/no-id-object-result.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_SQLITE_NO_ID_OBJECT_RESULT_HXX +#define ODB_SQLITE_NO_ID_OBJECT_RESULT_HXX + +#include + +#include // std::size_t + +#include +#include + +#include + +#include +#include // query_base, query_params +#include +#include + +namespace odb +{ + namespace sqlite + { + template + class no_id_object_result_impl: public odb::no_id_object_result_impl + { + public: + typedef odb::no_id_object_result_impl base_type; + + typedef typename base_type::object_type object_type; + typedef typename base_type::pointer_type pointer_type; + + typedef object_traits_impl object_traits; + typedef typename base_type::pointer_traits pointer_traits; + + typedef typename object_traits::statements_type statements_type; + + virtual + ~no_id_object_result_impl (); + + no_id_object_result_impl (const query_base&, + const details::shared_ptr&, + statements_type&, + const schema_version_migration*); + + virtual void + load (object_type&); + + virtual void + next (); + + virtual void + cache (); + + virtual std::size_t + size (); + + virtual void + invalidate (); + + using base_type::current; + + private: + // We need to hold on to the query parameters because SQLite uses + // the parameter buffers to find each next row. + // + details::shared_ptr params_; + details::shared_ptr statement_; + statements_type& statements_; + object_traits_calls tc_; + }; + } +} + +#include + +#include + +#endif // ODB_SQLITE_NO_ID_OBJECT_RESULT_HXX diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/no-id-object-result.txx b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/no-id-object-result.txx new file mode 100755 index 0000000..87d919b --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/no-id-object-result.txx @@ -0,0 +1,115 @@ +// file : odb/sqlite/no-id-object-result.txx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include +#include // result_not_cached + +#include + +namespace odb +{ + namespace sqlite + { + template + no_id_object_result_impl:: + ~no_id_object_result_impl () + { + if (!this->end_) + statement_->free_result (); + } + + template + void no_id_object_result_impl:: + invalidate () + { + if (!this->end_) + { + statement_->free_result (); + this->end_ = true; + } + + params_.reset (); + statement_.reset (); + } + + template + no_id_object_result_impl:: + no_id_object_result_impl (const query_base& q, + const details::shared_ptr& s, + statements_type& sts, + const schema_version_migration* svm) + : base_type (sts.connection ()), + params_ (q.parameters ()), + statement_ (s), + statements_ (sts), + tc_ (svm) + { + } + + template + void no_id_object_result_impl:: + load (object_type& obj) + { + // The image can grow between calls to load() as a result of other + // statements execution. + // + typename object_traits::image_type& im (statements_.image ()); + + if (im.version != statements_.select_image_version ()) + { + binding& b (statements_.select_image_binding ()); + tc_.bind (b.bind, im, statement_select); + statements_.select_image_version (im.version); + b.version++; + } + + select_statement::result r (statement_->load ()); + + if (r == select_statement::truncated) + { + if (tc_.grow (im, statements_.select_image_truncated ())) + im.version++; + + if (im.version != statements_.select_image_version ()) + { + binding& b (statements_.select_image_binding ()); + tc_.bind (b.bind, im, statement_select); + statements_.select_image_version (im.version); + b.version++; + statement_->reload (); + } + } + + object_traits::callback (this->db_, obj, callback_event::pre_load); + tc_.init (obj, im, &this->db_); + object_traits::callback (this->db_, obj, callback_event::post_load); + } + + template + void no_id_object_result_impl:: + next () + { + this->current (pointer_type ()); + + if (!statement_->next ()) + { + statement_->free_result (); + this->end_ = true; + } + } + + template + void no_id_object_result_impl:: + cache () + { + } + + template + std::size_t no_id_object_result_impl:: + size () + { + throw result_not_cached (); + } + } +} diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/no-id-object-statements.hxx b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/no-id-object-statements.hxx new file mode 100755 index 0000000..4fec8ef --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/no-id-object-statements.hxx @@ -0,0 +1,137 @@ +// file : odb/sqlite/no-id-object-statements.hxx +// copyright : Copyright (c) 2005-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_SQLITE_NO_ID_OBJECT_STATEMENTS_HXX +#define ODB_SQLITE_NO_ID_OBJECT_STATEMENTS_HXX + +#include + +#include // std::size_t + +#include +#include + +#include + +#include +#include +#include +#include +#include +#include + +namespace odb +{ + namespace sqlite + { + // + // Implementation for objects without object id. + // + + template + class no_id_object_statements: public statements_base + { + public: + typedef T object_type; + typedef object_traits_impl object_traits; + typedef typename object_traits::pointer_type pointer_type; + typedef typename object_traits::image_type image_type; + + typedef sqlite::insert_statement insert_statement_type; + + public: + no_id_object_statements (connection_type&); + + virtual + ~no_id_object_statements (); + + // Object image. + // + image_type& + image () {return image_;} + + // Insert binding. + // + std::size_t + insert_image_version () const { return insert_image_version_;} + + void + insert_image_version (std::size_t v) {insert_image_version_ = v;} + + binding& + insert_image_binding () {return insert_image_binding_;} + + // Select binding. + // + std::size_t + select_image_version () const { return select_image_version_;} + + void + select_image_version (std::size_t v) {select_image_version_ = v;} + + binding& + select_image_binding () {return select_image_binding_;} + + bool* + select_image_truncated () {return select_image_truncated_;} + + // Statements. + // + insert_statement_type& + persist_statement () + { + if (persist_ == 0) + { + persist_.reset ( + new (details::shared) insert_statement_type ( + conn_, + object_traits::persist_statement, + object_traits::versioned, // Process if versioned. + insert_image_binding_, + 0)); + } + + return *persist_; + } + + public: + // select = total + // insert = total - inverse; inverse == 0 for object without id + // + static const std::size_t insert_column_count = + object_traits::column_count; + + static const std::size_t select_column_count = + object_traits::column_count; + + private: + no_id_object_statements (const no_id_object_statements&); + no_id_object_statements& operator= (const no_id_object_statements&); + + private: + image_type image_; + + // Select binding. + // + std::size_t select_image_version_; + binding select_image_binding_; + bind select_image_bind_[select_column_count]; + bool select_image_truncated_[select_column_count]; + + // Insert binding. + // + std::size_t insert_image_version_; + binding insert_image_binding_; + bind insert_image_bind_[insert_column_count]; + + details::shared_ptr persist_; + }; + } +} + +#include + +#include + +#endif // ODB_SQLITE_NO_ID_OBJECT_STATEMENTS_HXX diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/no-id-object-statements.txx b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/no-id-object-statements.txx new file mode 100755 index 0000000..287a5d8 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/no-id-object-statements.txx @@ -0,0 +1,37 @@ +// file : odb/sqlite/no-id-object-statements.txx +// copyright : Copyright (c) 2005-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include // std::memset + +namespace odb +{ + namespace sqlite + { + template + no_id_object_statements:: + ~no_id_object_statements () + { + } + + template + no_id_object_statements:: + no_id_object_statements (connection_type& conn) + : statements_base (conn), + select_image_binding_ (select_image_bind_, select_column_count), + insert_image_binding_ (insert_image_bind_, insert_column_count) + { + image_.version = 0; + select_image_version_ = 0; + insert_image_version_ = 0; + + std::memset (insert_image_bind_, 0, sizeof (insert_image_bind_)); + std::memset (select_image_bind_, 0, sizeof (select_image_bind_)); + std::memset ( + select_image_truncated_, 0, sizeof (select_image_truncated_)); + + for (std::size_t i (0); i < select_column_count; ++i) + select_image_bind_[i].truncated = select_image_truncated_ + i; + } + } +} diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/polymorphic-object-result.hxx b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/polymorphic-object-result.hxx new file mode 100755 index 0000000..fa0a3d3 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/polymorphic-object-result.hxx @@ -0,0 +1,99 @@ +// file : odb/sqlite/polymorphic-object-result.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_SQLITE_POLYMORPHIC_OBJECT_RESULT_HXX +#define ODB_SQLITE_POLYMORPHIC_OBJECT_RESULT_HXX + +#include + +#include // std::size_t + +#include +#include + +#include + +#include +#include // query_base, query_params +#include +#include + +namespace odb +{ + namespace sqlite + { + template + class polymorphic_object_result_impl: + public odb::polymorphic_object_result_impl + { + public: + typedef odb::polymorphic_object_result_impl base_type; + + typedef typename base_type::id_type id_type; + typedef typename base_type::object_type object_type; + typedef typename base_type::pointer_type pointer_type; + + typedef object_traits_impl object_traits; + typedef typename base_type::pointer_traits pointer_traits; + + typedef typename base_type::root_type root_type; + typedef typename base_type::discriminator_type discriminator_type; + + typedef object_traits_impl root_traits; + + typedef typename object_traits::statements_type statements_type; + + virtual + ~polymorphic_object_result_impl (); + + polymorphic_object_result_impl ( + const query_base&, + const details::shared_ptr&, + statements_type&, + const schema_version_migration*); + + virtual void + load (object_type*, bool fetch); + + virtual id_type + load_id (); + + virtual discriminator_type + load_discriminator (); + + virtual void + next (); + + virtual void + cache (); + + virtual std::size_t + size (); + + virtual void + invalidate (); + + using base_type::current; + + private: + void + load_image (); + + private: + // We need to hold on to the query parameters because SQLite uses + // the parameter buffers to find each next row. + // + details::shared_ptr params_; + details::shared_ptr statement_; + statements_type& statements_; + object_traits_calls tc_; + }; + } +} + +#include + +#include + +#endif // ODB_SQLITE_POLYMORPHIC_OBJECT_RESULT_HXX diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/polymorphic-object-result.txx b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/polymorphic-object-result.txx new file mode 100755 index 0000000..277aa98 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/polymorphic-object-result.txx @@ -0,0 +1,288 @@ +// file : odb/sqlite/polymorphic-object-result.txx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include + +#include +#include // result_not_cached + +#include + +namespace odb +{ + namespace sqlite + { + template + polymorphic_object_result_impl:: + ~polymorphic_object_result_impl () + { + if (!this->end_) + statement_->free_result (); + } + + template + void polymorphic_object_result_impl:: + invalidate () + { + if (!this->end_) + { + statement_->free_result (); + this->end_ = true; + } + + params_.reset (); + statement_.reset (); + } + + template + polymorphic_object_result_impl:: + polymorphic_object_result_impl ( + const query_base& q, + const details::shared_ptr& s, + statements_type& sts, + const schema_version_migration* svm) + : base_type (sts.connection ()), + params_ (q.parameters ()), + statement_ (s), + statements_ (sts), + tc_ (svm) + { + } + + template + void polymorphic_object_result_impl:: + load (object_type* pobj, bool fetch) + { + if (fetch) + load_image (); + + typename statements_type::root_statements_type& rsts ( + statements_.root_statements ()); + + // This is a top-level call so the statements cannot be locked. + // + assert (!rsts.locked ()); + typename statements_type::auto_lock l (rsts); + + typename object_traits::image_type& i (statements_.image ()); + typename root_traits::image_type& ri (rsts.image ()); + + id_type id (root_traits::id (ri)); + + // Determine this object's dynamic type. + // + typedef typename root_traits::info_type info_type; + discriminator_type d (root_traits::discriminator (ri)); + discriminator_type disc (d); + + // Use the polymorphic_info() helper to get concrete_info if + // object_type is concrete and NULL if it is abstract. + // + const info_type* spi (polymorphic_info (object_traits::info)); + const info_type& pi ( + spi != 0 && spi->discriminator == d + ? *spi + : root_traits::map->find (d)); + + typedef typename root_traits::pointer_type root_pointer_type; + typedef typename root_traits::pointer_traits root_pointer_traits; + + typename object_traits::pointer_cache_traits::insert_guard ig; + + if (pobj == 0) + { + // Need to create a new instance of the dynamic type. + // + root_pointer_type rp (pi.create ()); + pointer_type p ( + root_pointer_traits::template static_pointer_cast (rp)); + + // Insert it as a root pointer (for non-unique pointers, rp should + // still be valid and for unique pointers this is a no-op). + // + ig.reset ( + object_traits::pointer_cache_traits::insert (this->db_, id, rp)); + + pobj = &pointer_traits::get_ref (p); + current (p); + } + else + { + // We are loading into an existing instance. If the static and + // dynamic types differ, then make sure the instance is at least + // of the dynamic type. + // + if (&pi != &object_traits::info) + { + const info_type& dpi (root_traits::map->find (typeid (*pobj))); + + if (&dpi != &pi && dpi.derived (pi)) + throw object_not_persistent (); // @@ type_mismatch ? + } + } + + callback_event ce (callback_event::pre_load); + pi.dispatch (info_type::call_callback, this->db_, pobj, &ce); + + tc_.init (*pobj, i, &this->db_); + + // Initialize the id image and binding and load the rest of the object + // (containers, dynamic part, etc). + // + typename object_traits::id_image_type& idi (statements_.id_image ()); + root_traits::init (idi, id); + + binding& idb (statements_.id_image_binding ()); + if (idi.version != statements_.id_image_version () || idb.version == 0) + { + object_traits::bind (idb.bind, idi); + statements_.id_image_version (idi.version); + idb.version++; + } + + tc_.load_ (statements_, *pobj, false); + + // Load the dynamic part of the object unless static and dynamic + // types are the same. + // + if (&pi != &object_traits::info) + { + std::size_t d (object_traits::depth); + pi.dispatch (info_type::call_load, this->db_, pobj, &d); + }; + + rsts.load_delayed (tc_.version ()); + l.unlock (); + + ce = callback_event::post_load; + pi.dispatch (info_type::call_callback, this->db_, pobj, &ce); + object_traits::pointer_cache_traits::load (ig.position ()); + ig.release (); + } + + template + typename polymorphic_object_result_impl::id_type + polymorphic_object_result_impl:: + load_id () + { + load_image (); + return root_traits::id (statements_.root_statements ().image ()); + } + + template + typename polymorphic_object_result_impl::discriminator_type + polymorphic_object_result_impl:: + load_discriminator () + { + load_image (); + return root_traits::discriminator ( + statements_.root_statements ().image ()); + } + + template + void polymorphic_object_result_impl:: + next () + { + this->current (pointer_type ()); + + if (!statement_->next ()) + { + statement_->free_result (); + this->end_ = true; + } + } + + template + struct polymorphic_image_rebind + { + // Derived type version. + // + typedef object_traits_impl traits; + + static bool + rebind (typename traits::statements_type& sts, + const schema_version_migration* svm) + { + typename traits::image_type& im (sts.image ()); + + if (traits::check_version (sts.select_image_versions (), im)) + { + binding& b (sts.select_image_binding (traits::depth)); + object_traits_calls tc (svm); + tc.bind (b.bind, 0, 0, im, statement_select); + traits::update_version ( + sts.select_image_versions (), im, sts.select_image_bindings ()); + return true; + } + + return false; + } + }; + + template + struct polymorphic_image_rebind + { + // Root type version. + // + typedef object_traits_impl traits; + + static bool + rebind (typename traits::statements_type& sts, + const schema_version_migration* svm) + { + typename traits::image_type& im (sts.image ()); + + if (im.version != sts.select_image_version ()) + { + binding& b (sts.select_image_binding ()); + object_traits_calls tc (svm); + tc.bind (b.bind, im, statement_select); + sts.select_image_version (im.version); + b.version++; + return true; + } + + return false; + } + }; + + template + void polymorphic_object_result_impl:: + load_image () + { + typedef polymorphic_image_rebind image_rebind; + + // The image can grow between calls to load() as a result of other + // statements execution. + // + image_rebind::rebind (statements_, tc_.version ()); + + select_statement::result r (statement_->load ()); + + if (r == select_statement::truncated) + { + typename object_traits::image_type& im (statements_.image ()); + + if (tc_.grow (im, statements_.select_image_truncated ())) + im.version++; + + if (image_rebind::rebind (statements_, tc_.version ())) + statement_->reload (); + } + } + + template + void polymorphic_object_result_impl:: + cache () + { + } + + template + std::size_t polymorphic_object_result_impl:: + size () + { + throw result_not_cached (); + } + } +} diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/polymorphic-object-statements.hxx b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/polymorphic-object-statements.hxx new file mode 100755 index 0000000..53b1e31 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/polymorphic-object-statements.hxx @@ -0,0 +1,480 @@ +// file : odb/sqlite/polymorphic-object-statements.hxx +// copyright : Copyright (c) 2005-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_SQLITE_POLYMORPHIC_OBJECT_STATEMENTS_HXX +#define ODB_SQLITE_POLYMORPHIC_OBJECT_STATEMENTS_HXX + +#include + +#include // std::size_t + +#include +#include + +#include + +#include +#include +#include +#include +#include +#include +#include + +namespace odb +{ + namespace sqlite + { + // + // Implementation for polymorphic objects. + // + + template + class polymorphic_root_object_statements: public object_statements + { + public: + typedef typename object_statements::connection_type connection_type; + typedef typename object_statements::object_traits object_traits; + typedef typename object_statements::id_image_type id_image_type; + + typedef + typename object_traits::discriminator_image_type + discriminator_image_type; + + typedef + typename object_statements::select_statement_type + select_statement_type; + + public: + // Interface compatibility with derived_object_statements. + // + typedef polymorphic_root_object_statements root_statements_type; + + root_statements_type& + root_statements () + { + return *this; + } + + public: + // Discriminator binding. + // + discriminator_image_type& + discriminator_image () {return discriminator_image_;} + + std::size_t + discriminator_image_version () const + {return discriminator_image_version_;} + + void + discriminator_image_version (std::size_t v) + {discriminator_image_version_ = v;} + + binding& + discriminator_image_binding () {return discriminator_image_binding_;} + + bool* + discriminator_image_truncated () {return discriminator_image_truncated_;} + + // Id binding for discriminator retrieval. + // + id_image_type& + discriminator_id_image () {return discriminator_id_image_;} + + std::size_t + discriminator_id_image_version () const + {return discriminator_id_image_version_;} + + void + discriminator_id_image_version (std::size_t v) + {discriminator_id_image_version_ = v;} + + binding& + discriminator_id_image_binding () + {return discriminator_id_image_binding_;} + + // + // + select_statement_type& + find_discriminator_statement () + { + if (find_discriminator_ == 0) + { + find_discriminator_.reset ( + new (details::shared) select_statement_type ( + this->conn_, + object_traits::find_discriminator_statement, + false, // Doesn't need to be processed. + false, // Don't optimize. + discriminator_id_image_binding_, + discriminator_image_binding_)); + } + + return *find_discriminator_; + } + + public: + polymorphic_root_object_statements (connection_type&); + + virtual + ~polymorphic_root_object_statements (); + + // Static "override" (statements type). + // + void + load_delayed (const schema_version_migration* svm) + { + assert (this->locked ()); + + if (!this->delayed_.empty ()) + this->template load_delayed_ ( + svm); + } + + public: + static const std::size_t id_column_count = + object_statements::id_column_count; + + static const std::size_t discriminator_column_count = + object_traits::discriminator_column_count; + + static const std::size_t managed_optimistic_column_count = + object_traits::managed_optimistic_column_count; + + private: + // Discriminator image. + // + discriminator_image_type discriminator_image_; + std::size_t discriminator_image_version_; + binding discriminator_image_binding_; + bind discriminator_image_bind_[discriminator_column_count + + managed_optimistic_column_count]; + bool discriminator_image_truncated_[discriminator_column_count + + managed_optimistic_column_count]; + + // Id image for discriminator retrieval (only used as a parameter). + // + id_image_type discriminator_id_image_; + std::size_t discriminator_id_image_version_; + binding discriminator_id_image_binding_; + bind discriminator_id_image_bind_[id_column_count]; + + details::shared_ptr find_discriminator_; + }; + + template + class polymorphic_derived_object_statements: public statements_base + { + public: + typedef T object_type; + typedef object_traits_impl object_traits; + typedef typename object_traits::id_type id_type; + typedef typename object_traits::pointer_type pointer_type; + typedef typename object_traits::id_image_type id_image_type; + typedef typename object_traits::image_type image_type; + + typedef typename object_traits::root_type root_type; + typedef + polymorphic_root_object_statements + root_statements_type; + + typedef typename object_traits::base_type base_type; + typedef + typename object_traits::base_traits::statements_type + base_statements_type; + + typedef + typename object_traits::extra_statement_cache_type + extra_statement_cache_type; + + typedef sqlite::insert_statement insert_statement_type; + typedef sqlite::select_statement select_statement_type; + typedef sqlite::update_statement update_statement_type; + typedef sqlite::delete_statement delete_statement_type; + + typedef typename root_statements_type::auto_lock auto_lock; + + public: + polymorphic_derived_object_statements (connection_type&); + + virtual + ~polymorphic_derived_object_statements (); + + public: + // Delayed loading. + // + static void + delayed_loader (odb::database&, + const id_type&, + root_type&, + const schema_version_migration*); + + public: + // Root and immediate base statements. + // + root_statements_type& + root_statements () + { + return root_statements_; + } + + base_statements_type& + base_statements () + { + return base_statements_; + } + + public: + // Object image. + // + image_type& + image () + { + return image_; + } + + // Insert binding. + // + std::size_t + insert_image_version () const { return insert_image_version_;} + + void + insert_image_version (std::size_t v) {insert_image_version_ = v;} + + std::size_t + insert_id_binding_version () const { return insert_id_binding_version_;} + + void + insert_id_binding_version (std::size_t v) {insert_id_binding_version_ = v;} + + binding& + insert_image_binding () {return insert_image_binding_;} + + // Update binding. + // + std::size_t + update_image_version () const { return update_image_version_;} + + void + update_image_version (std::size_t v) {update_image_version_ = v;} + + std::size_t + update_id_binding_version () const { return update_id_binding_version_;} + + void + update_id_binding_version (std::size_t v) {update_id_binding_version_ = v;} + + binding& + update_image_binding () {return update_image_binding_;} + + // Select binding. + // + std::size_t* + select_image_versions () { return select_image_versions_;} + + binding* + select_image_bindings () {return select_image_bindings_;} + + binding& + select_image_binding (std::size_t d) + { + return select_image_bindings_[object_traits::depth - d]; + } + + bool* + select_image_truncated () {return select_image_truncated_;} + + // Object id binding (comes from the root statements). + // + id_image_type& + id_image () {return root_statements_.id_image ();} + + std::size_t + id_image_version () const {return root_statements_.id_image_version ();} + + void + id_image_version (std::size_t v) {root_statements_.id_image_version (v);} + + binding& + id_image_binding () {return root_statements_.id_image_binding ();} + + binding& + optimistic_id_image_binding () { + return root_statements_.optimistic_id_image_binding ();} + + // Statements. + // + insert_statement_type& + persist_statement () + { + if (persist_ == 0) + { + persist_.reset ( + new (details::shared) insert_statement_type ( + conn_, + object_traits::persist_statement, + object_traits::versioned, // Process if versioned. + insert_image_binding_, + 0)); + } + + return *persist_; + } + + select_statement_type& + find_statement (std::size_t d) + { + std::size_t i (object_traits::depth - d); + details::shared_ptr& p (find_[i]); + + if (p == 0) + { + p.reset ( + new (details::shared) select_statement_type ( + conn_, + object_traits::find_statements[i], + object_traits::versioned, // Process if versioned. + false, // Don't optimize. + root_statements_.id_image_binding (), + select_image_bindings_[i])); + } + + return *p; + } + + update_statement_type& + update_statement () + { + if (update_ == 0) + { + update_.reset ( + new (details::shared) update_statement_type ( + conn_, + object_traits::update_statement, + object_traits::versioned, // Process if versioned. + update_image_binding_)); + } + + return *update_; + } + + delete_statement_type& + erase_statement () + { + if (erase_ == 0) + { + erase_.reset ( + new (details::shared) delete_statement_type ( + conn_, + object_traits::erase_statement, + root_statements_.id_image_binding ())); + } + + return *erase_; + } + + // Extra (container, section) statement cache. + // + extra_statement_cache_type& + extra_statement_cache () + { + return extra_statement_cache_.get ( + conn_, + image_, + id_image (), + id_image_binding (), + &id_image_binding ()); // Note, not id+version. + } + + public: + // select = total - id - separate_load + base::select + // insert = total - inverse + // update = total - inverse - id - readonly - separate_update + // + static const std::size_t id_column_count = + object_traits::id_column_count; + + static const std::size_t select_column_count = + object_traits::column_count - + id_column_count - + object_traits::separate_load_column_count + + base_statements_type::select_column_count; + + static const std::size_t insert_column_count = + object_traits::column_count - + object_traits::inverse_column_count; + + static const std::size_t update_column_count = insert_column_count - + object_traits::id_column_count - + object_traits::readonly_column_count - + object_traits::separate_update_column_count; + + private: + polymorphic_derived_object_statements ( + const polymorphic_derived_object_statements&); + + polymorphic_derived_object_statements& + operator= (const polymorphic_derived_object_statements&); + + private: + root_statements_type& root_statements_; + base_statements_type& base_statements_; + + extra_statement_cache_ptr extra_statement_cache_; + + image_type image_; + + // Select binding. Here we are have an array of statements/bindings + // one for each depth. In other words, if we have classes root, base, + // and derived, then we have the following array of statements: + // + // [0] d + b + r + // [1] d + b + // [2] d + // + // Also, because we have a chain of images bound to these statements, + // we have an array of versions, one entry for each base plus one for + // our own image. + // + // A poly-abstract class only needs the first statement and in this + // case we have only one entry in the the bindings and statements + // arrays (but not versions; we still have a chain of images). + // + std::size_t select_image_versions_[object_traits::depth]; + binding select_image_bindings_[ + object_traits::abstract ? 1 : object_traits::depth]; + bind select_image_bind_[select_column_count]; + bool select_image_truncated_[select_column_count]; + + // Insert binding. The id binding is copied from the hierarchy root. + // + std::size_t insert_image_version_; + std::size_t insert_id_binding_version_; + binding insert_image_binding_; + bind insert_image_bind_[insert_column_count]; + + // Update binding. The id suffix binding is copied from the hierarchy + // root. + // + std::size_t update_image_version_; + std::size_t update_id_binding_version_; + binding update_image_binding_; + bind update_image_bind_[update_column_count + id_column_count]; + + details::shared_ptr persist_; + details::shared_ptr find_[ + object_traits::abstract ? 1 : object_traits::depth]; + details::shared_ptr update_; + details::shared_ptr erase_; + }; + } +} + +#include + +#include + +#endif // ODB_SQLITE_POLYMORPHIC_OBJECT_STATEMENTS_HXX diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/polymorphic-object-statements.txx b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/polymorphic-object-statements.txx new file mode 100755 index 0000000..0565ae0 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/polymorphic-object-statements.txx @@ -0,0 +1,146 @@ +// file : odb/sqlite/polymorphic-object-statements.txx +// copyright : Copyright (c) 2005-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include // std::memset + +#include +#include + +#include +#include +#include +#include + +namespace odb +{ + namespace sqlite + { + // + // polymorphic_root_object_statements + // + + template + polymorphic_root_object_statements:: + ~polymorphic_root_object_statements () + { + } + + template + polymorphic_root_object_statements:: + polymorphic_root_object_statements (connection_type& conn) + : object_statements (conn), + discriminator_image_binding_ (discriminator_image_bind_, + discriminator_column_count + + managed_optimistic_column_count), + discriminator_id_image_binding_ (discriminator_id_image_bind_, + id_column_count) + { + discriminator_image_.version = 0; + discriminator_id_image_.version = 0; + + discriminator_image_version_ = 0; + discriminator_id_image_version_ = 0; + + std::memset (discriminator_image_bind_, + 0, + sizeof (discriminator_image_bind_)); + std::memset (discriminator_id_image_bind_, + 0, + sizeof (discriminator_id_image_bind_)); + std::memset (discriminator_image_truncated_, + 0, + sizeof (discriminator_image_truncated_)); + + for (std::size_t i (0); + i < discriminator_column_count + managed_optimistic_column_count; + ++i) + { + discriminator_image_bind_[i].truncated = + discriminator_image_truncated_ + i; + } + } + + // + // polymorphic_derived_object_statements + // + + template + polymorphic_derived_object_statements:: + ~polymorphic_derived_object_statements () + { + } + + template + polymorphic_derived_object_statements:: + polymorphic_derived_object_statements (connection_type& conn) + : statements_base (conn), + root_statements_ (conn.statement_cache ().find_object ()), + base_statements_ (conn.statement_cache ().find_object ()), + insert_image_binding_ (insert_image_bind_, insert_column_count), + update_image_binding_ (update_image_bind_, + update_column_count + id_column_count) + { + image_.base = &base_statements_.image (); + image_.version = 0; + + for (std::size_t i (0); i < object_traits::depth; ++i) + select_image_versions_[i] = 0; + + for (std::size_t i (0); + i < (object_traits::abstract ? 1 : object_traits::depth); + ++i) + { + select_image_bindings_[i].bind = select_image_bind_; + select_image_bindings_[i].count = object_traits::find_column_counts[i]; + } + + insert_image_version_ = 0; + insert_id_binding_version_ = 0; + update_image_version_ = 0; + update_id_binding_version_ = 0; + + std::memset (insert_image_bind_, 0, sizeof (insert_image_bind_)); + std::memset (update_image_bind_, 0, sizeof (update_image_bind_)); + std::memset (select_image_bind_, 0, sizeof (select_image_bind_)); + std::memset ( + select_image_truncated_, 0, sizeof (select_image_truncated_)); + + for (std::size_t i (0); i < select_column_count; ++i) + select_image_bind_[i].truncated = select_image_truncated_ + i; + } + + template + void polymorphic_derived_object_statements:: + delayed_loader (odb::database& db, + const id_type& id, + root_type& robj, + const schema_version_migration* svm) + { + connection_type& conn (transaction::current ().connection ()); + polymorphic_derived_object_statements& sts ( + conn.statement_cache ().find_object ()); + root_statements_type& rsts (sts.root_statements ()); + + object_type& obj (static_cast (robj)); + + // The same code as in object_statements::load_delayed_(). + // + object_traits_calls tc (svm); + + if (!tc.find_ (sts, &id)) + throw object_not_persistent (); + + object_traits::callback (db, obj, callback_event::pre_load); + tc.init (obj, sts.image (), &db); + tc.load_ (sts, obj, false); // Load containers, etc. + + rsts.load_delayed (svm); + + { + typename root_statements_type::auto_unlock u (rsts); + object_traits::callback (db, obj, callback_event::post_load); + } + } + } +} diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/prepared-query.cxx b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/prepared-query.cxx new file mode 100755 index 0000000..c204de6 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/prepared-query.cxx @@ -0,0 +1,16 @@ +// file : odb/sqlite/prepared-query.cxx +// copyright : Copyright (c) 2005-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include + +namespace odb +{ + namespace sqlite + { + prepared_query_impl:: + ~prepared_query_impl () + { + } + } +} diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/prepared-query.hxx b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/prepared-query.hxx new file mode 100755 index 0000000..4a63786 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/prepared-query.hxx @@ -0,0 +1,35 @@ +// file : odb/sqlite/prepared-query.hxx +// copyright : Copyright (c) 2005-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_SQLITE_PREPARED_QUERY_HXX +#define ODB_SQLITE_PREPARED_QUERY_HXX + +#include + +#include + +#include +#include + +#include + +namespace odb +{ + namespace sqlite + { + struct LIBODB_SQLITE_EXPORT prepared_query_impl: odb::prepared_query_impl + { + virtual + ~prepared_query_impl (); + + prepared_query_impl (odb::connection& c): odb::prepared_query_impl (c) {} + + sqlite::query_base query; + }; + } +} + +#include + +#endif // ODB_SQLITE_PREPARED_QUERY_HXX diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/query-const-expr.cxx b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/query-const-expr.cxx new file mode 100755 index 0000000..e26fb30 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/query-const-expr.cxx @@ -0,0 +1,15 @@ +// file : odb/sqlite/query-const-expr.cxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include + +namespace odb +{ + namespace sqlite + { + // Sun CC cannot handle this in query.cxx. + // + const query_base query_base::true_expr (true); + } +} diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/query-dynamic.cxx b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/query-dynamic.cxx new file mode 100755 index 0000000..dd89e78 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/query-dynamic.cxx @@ -0,0 +1,152 @@ +// file : odb/sqlite/query-dynamic.cxx +// copyright : Copyright (c) 2005-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include // std::size_t + +#include + +using namespace std; + +namespace odb +{ + namespace sqlite + { + static const char* logic_operators[] = {") AND (", ") OR ("}; + static const char* comp_operators[] = {"=", "!=", "<", ">", "<=", ">="}; + + static void + translate (query_base& q, const odb::query_base& s, size_t p) + { + typedef odb::query_base::clause_part part; + + const part& x (s.clause ()[p]); + + switch (x.kind) + { + case part::kind_column: + { + const query_column_base* c ( + static_cast ( + x.native_info[id_sqlite].column)); + + q.append (c->table (), c->column ()); + break; + } + case part::kind_param_val: + case part::kind_param_ref: + { + const query_column_base* c ( + static_cast ( + x.native_info[id_sqlite].column)); + + query_param_factory f ( + reinterpret_cast ( + x.native_info[id_sqlite].param_factory)); + + const odb::query_param* p ( + reinterpret_cast (x.data)); + + q.append (f (p->value, x.kind == part::kind_param_ref), + c->conversion ()); + break; + } + case part::kind_native: + { + q.append (s.strings ()[x.data]); + break; + } + case part::kind_true: + case part::kind_false: + { + q.append (x.kind == part::kind_true); + break; + } + case part::op_add: + { + translate (q, s, x.data); + translate (q, s, p - 1); + break; + } + case part::op_and: + case part::op_or: + { + q += "("; + translate (q, s, x.data); + q += logic_operators[x.kind - part::op_and]; + translate (q, s, p - 1); + q += ")"; + break; + } + case part::op_not: + { + q += "NOT ("; + translate (q, s, p - 1); + q += ")"; + break; + } + case part::op_null: + case part::op_not_null: + { + translate (q, s, p - 1); + q += (x.kind == part::op_null ? "IS NULL" : "IS NOT NULL"); + break; + } + case part::op_in: + { + size_t b (p - x.data); + + translate (q, s, b - 1); // column + q += "IN ("; + + for (size_t i (b); i != p; ++i) + { + if (i != b) + q += ","; + + translate (q, s, i); + } + + q += ")"; + break; + } + case part::op_like: + { + translate (q, s, p - 2); // column + q += "LIKE"; + translate (q, s, p - 1); // pattern + break; + } + case part::op_like_escape: + { + translate (q, s, p - 3); // column + q += "LIKE"; + translate (q, s, p - 2); // pattern + q += "ESCAPE"; + translate (q, s, p - 1); // escape + break; + } + case part::op_eq: + case part::op_ne: + case part::op_lt: + case part::op_gt: + case part::op_le: + case part::op_ge: + { + translate (q, s, x.data); + q += comp_operators[x.kind - part::op_eq]; + translate (q, s, p - 1); + break; + } + } + } + + query_base:: + query_base (const odb::query_base& q) + : parameters_ (new (details::shared) query_params) + { + if (!q.empty ()) + translate (*this, q, q.clause ().size () - 1); + } + } +} diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/query-dynamic.hxx b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/query-dynamic.hxx new file mode 100755 index 0000000..cb03393 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/query-dynamic.hxx @@ -0,0 +1,33 @@ +// file : odb/sqlite/query-dynamic.hxx +// copyright : Copyright (c) 2005-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_SQLITE_QUERY_DYNAMIC_HXX +#define ODB_SQLITE_QUERY_DYNAMIC_HXX + +#include + +#include +#include + +#include + +namespace odb +{ + namespace sqlite + { + typedef details::shared_ptr (*query_param_factory) ( + const void* val, bool by_ref); + + template + details::shared_ptr + query_param_factory_impl (const void*, bool); + } +} + +#include +#include + +#include + +#endif // ODB_SQLITE_QUERY_DYNAMIC_HXX diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/query-dynamic.ixx b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/query-dynamic.ixx new file mode 100755 index 0000000..b691d7b --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/query-dynamic.ixx @@ -0,0 +1,27 @@ +// file : odb/sqlite/query-dynamic.ixx +// copyright : Copyright (c) 2005-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +namespace odb +{ + namespace sqlite + { + // + // + template + inline query_column:: + query_column (odb::query_column& qc, + const char* table, const char* column, const char* conv) + : query_column_base (table, column, conv) + { + native_column_info& ci (qc.native_info[id_sqlite]); + ci.column = static_cast (this); + + // For some reason GCC needs this statically-typed pointer in + // order to instantiate the functions. + // + query_param_factory f (&query_param_factory_impl); + ci.param_factory = reinterpret_cast (f); + } + } +} diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/query-dynamic.txx b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/query-dynamic.txx new file mode 100755 index 0000000..67af539 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/query-dynamic.txx @@ -0,0 +1,21 @@ +// file : odb/sqlite/query-dynamic.txx +// copyright : Copyright (c) 2005-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +namespace odb +{ + namespace sqlite + { + template + details::shared_ptr + query_param_factory_impl (const void* val, bool by_ref) + { + const T& v (*static_cast (val)); + + return details::shared_ptr ( + by_ref + ? new (details::shared) query_param_impl (ref_bind (v)) + : new (details::shared) query_param_impl (val_bind (v))); + } + } +} diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/query.cxx b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/query.cxx new file mode 100755 index 0000000..a1bc5ac --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/query.cxx @@ -0,0 +1,375 @@ +// file : odb/sqlite/query.cxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include // std::size_t +#include // std::memset + +#include + +using namespace std; + +namespace odb +{ + namespace sqlite + { + // query_param + // + + query_param:: + ~query_param () + { + } + + // query_params + // + + query_params:: + query_params (const query_params& x) + : details::shared_base (x), + params_ (x.params_), bind_ (x.bind_), binding_ (0, 0) + { + // Here and below we want to maintain up to date binding info so + // that the call to binding() below is an immutable operation, + // provided the query does not have any by-reference parameters. + // This way a by-value-only query can be shared between multiple + // threads without the need for synchronization. + // + if (size_t n = bind_.size ()) + { + binding_.bind = &bind_[0]; + binding_.count = n; + binding_.version++; + } + } + + query_params& query_params:: + operator= (const query_params& x) + { + if (this != &x) + { + params_ = x.params_; + bind_ = x.bind_; + + size_t n (bind_.size ()); + binding_.bind = n != 0 ? &bind_[0] : 0; + binding_.count = n; + binding_.version++; + } + + return *this; + } + + query_params& query_params:: + operator+= (const query_params& x) + { + size_t n (bind_.size ()); + + params_.insert (params_.end (), x.params_.begin (), x.params_.end ()); + bind_.insert (bind_.end (), x.bind_.begin (), x.bind_.end ()); + + if (n != bind_.size ()) + { + binding_.bind = &bind_[0]; + binding_.count = bind_.size (); + binding_.version++; + } + + return *this; + } + + void query_params:: + add (details::shared_ptr p) + { + params_.push_back (p); + bind_.push_back (sqlite::bind ()); + binding_.bind = &bind_[0]; + binding_.count = bind_.size (); + binding_.version++; + + sqlite::bind* b (&bind_.back ()); + memset (b, 0, sizeof (sqlite::bind)); + p->bind (b); + } + + void query_params:: + init () + { + bool inc_ver (false); + + for (size_t i (0); i < params_.size (); ++i) + { + query_param& p (*params_[i]); + + if (p.reference ()) + { + if (p.init ()) + { + p.bind (&bind_[i]); + inc_ver = true; + } + } + } + + if (inc_ver) + binding_.version++; + } + + // query_base + // + + query_base:: + query_base (const query_base& q) + : clause_ (q.clause_), + parameters_ (new (details::shared) query_params (*q.parameters_)) + { + } + + query_base& query_base:: + operator= (const query_base& q) + { + if (this != &q) + { + clause_ = q.clause_; + *parameters_ = *q.parameters_; + } + + return *this; + } + + query_base& query_base:: + operator+= (const query_base& q) + { + clause_.insert (clause_.end (), q.clause_.begin (), q.clause_.end ()); + *parameters_ += *q.parameters_; + return *this; + } + + void query_base:: + append (const string& q) + { + if (!clause_.empty () && + clause_.back ().kind == clause_part::kind_native) + { + string& s (clause_.back ().part); + + char first (!q.empty () ? q[0] : ' '); + char last (!s.empty () ? s[s.size () - 1] : ' '); + + // We don't want extra spaces after '(' as well as before ',' + // and ')'. + // + if (last != ' ' && last != '\n' && last != '(' && + first != ' ' && first != '\n' && first != ',' && first != ')') + s += ' '; + + s += q; + } + else + clause_.push_back (clause_part (clause_part::kind_native, q)); + } + + void query_base:: + append (const char* table, const char* column) + { + string s (table); + s += '.'; + s += column; + + clause_.push_back (clause_part (clause_part::kind_column, s)); + } + + void query_base:: + append (details::shared_ptr p, const char* conv) + { + clause_.push_back (clause_part (clause_part::kind_param)); + + if (conv != 0) + clause_.back ().part = conv; + + parameters_->add (p); + } + + static bool + check_prefix (const string& s) + { + string::size_type n; + + // It is easier to compare to upper and lower-case versions + // rather than getting involved with the portable case- + // insensitive string comparison mess. + // + if (s.compare (0, (n = 5), "WHERE") == 0 || + s.compare (0, (n = 5), "where") == 0 || + s.compare (0, (n = 6), "SELECT") == 0 || + s.compare (0, (n = 6), "select") == 0 || + s.compare (0, (n = 8), "ORDER BY") == 0 || + s.compare (0, (n = 8), "order by") == 0 || + s.compare (0, (n = 8), "GROUP BY") == 0 || + s.compare (0, (n = 8), "group by") == 0 || + s.compare (0, (n = 6), "HAVING") == 0 || + s.compare (0, (n = 6), "having") == 0) + { + // It either has to be an exact match, or there should be + // a whitespace following the keyword. + // + if (s.size () == n || s[n] == ' ' || s[n] == '\n' || s[n] =='\t') + return true; + } + + return false; + } + + void query_base:: + optimize () + { + // Remove a single TRUE literal or one that is followe by one of + // the other clauses. This avoids useless WHERE clauses like + // + // WHERE TRUE GROUP BY foo + // + clause_type::iterator i (clause_.begin ()), e (clause_.end ()); + + if (i != e && i->kind == clause_part::kind_bool && i->bool_part) + { + clause_type::iterator j (i + 1); + + if (j == e || + (j->kind == clause_part::kind_native && check_prefix (j->part))) + clause_.erase (i); + } + } + + const char* query_base:: + clause_prefix () const + { + if (!clause_.empty ()) + { + const clause_part& p (clause_.front ()); + + if (p.kind == clause_part::kind_native && check_prefix (p.part)) + return ""; + + return "WHERE "; + } + + return ""; + } + + string query_base:: + clause () const + { + string r; + + for (clause_type::const_iterator i (clause_.begin ()), + end (clause_.end ()); + i != end; + ++i) + { + char last (!r.empty () ? r[r.size () - 1] : ' '); + + switch (i->kind) + { + case clause_part::kind_column: + { + if (last != ' ' && last != '\n' && last != '(') + r += ' '; + + r += i->part; + break; + } + case clause_part::kind_param: + { + if (last != ' ' && last != '\n' && last != '(') + r += ' '; + + // Add the conversion expression, if any. + // + string::size_type p (0); + if (!i->part.empty ()) + { + p = i->part.find ("(?)"); + r.append (i->part, 0, p); + } + + r += '?'; + + if (!i->part.empty ()) + r.append (i->part, p + 3, string::npos); + + break; + } + case clause_part::kind_native: + { + // We don't want extra spaces after '(' as well as before ',' + // and ')'. + // + const string& p (i->part); + char first (!p.empty () ? p[0] : ' '); + + if (last != ' ' && first != '\n' && last != '(' && + first != ' ' && last != '\n' && first != ',' && first != ')') + r += ' '; + + r += p; + break; + } + case clause_part::kind_bool: + { + if (last != ' ' && last != '\n' && last != '(') + r += ' '; + + r += i->bool_part ? "1" : "0"; + break; + } + } + } + + return clause_prefix () + r; + } + + query_base + operator&& (const query_base& x, const query_base& y) + { + // Optimize cases where one or both sides are constant truth. + // + bool xt (x.const_true ()), yt (y.const_true ()); + + if (xt && yt) + return x; + + if (xt) + return y; + + if (yt) + return x; + + query_base r ("("); + r += x; + r += ") AND ("; + r += y; + r += ")"; + return r; + } + + query_base + operator|| (const query_base& x, const query_base& y) + { + query_base r ("("); + r += x; + r += ") OR ("; + r += y; + r += ")"; + return r; + } + + query_base + operator! (const query_base& x) + { + query_base r ("NOT ("); + r += x; + r += ")"; + return r; + } + } +} diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/query.hxx b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/query.hxx new file mode 100755 index 0000000..6d7dd0d --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/query.hxx @@ -0,0 +1,1710 @@ +// file : odb/sqlite/query.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_SQLITE_QUERY_HXX +#define ODB_SQLITE_QUERY_HXX + +#include + +#include +#include +#include // std::size_t + +#include // odb::query_column +#include +#include +#include + +#include +#include +#include +#include +#include + +#include +#include + +namespace odb +{ + namespace sqlite + { + template + struct val_bind + { + typedef const T& type; + + explicit + val_bind (type v): val (v) {} + + type val; + }; + + template + struct val_bind + { + typedef const T* type; + + explicit + val_bind (type v): val (v) {} + + type val; + }; + + template + struct ref_bind + { + typedef const T& type; + + explicit + ref_bind (type r): ref (r) {} + + const void* + ptr () const {return &ref;} + + type ref; + }; + + template + struct ref_bind + { + typedef const T* type; + + explicit + ref_bind (type r): ref (r) {} + + // Allow implicit conversion from decayed ref_bind's. + // + ref_bind (ref_bind r): ref (r.ref) {} + ref_bind (ref_bind r): ref (r.ref) {} + + const void* + ptr () const {return ref;} + + type ref; + }; + + template + struct val_bind_typed: val_bind + { + explicit + val_bind_typed (typename val_bind::type v): val_bind (v) {} + }; + + template + struct ref_bind_typed: ref_bind + { + explicit + ref_bind_typed (typename ref_bind::type r): ref_bind (r) {} + }; + + struct LIBODB_SQLITE_EXPORT query_param: details::shared_base + { + virtual + ~query_param (); + + bool + reference () const + { + return value_ != 0; + } + + virtual bool + init () = 0; + + virtual void + bind (sqlite::bind*) = 0; + + protected: + query_param (const void* value) + : value_ (value) + { + } + + protected: + const void* value_; + }; + + class query_base; + + class LIBODB_SQLITE_EXPORT query_params: public details::shared_base + { + public: + typedef sqlite::binding binding_type; + + void + init (); + + binding_type& + binding () {return binding_;} + + private: + friend class query_base; + + query_params (): binding_ (0, 0) {} + query_params (const query_params&); + + query_params& + operator= (const query_params&); + + query_params& + operator+= (const query_params&); + + void + add (details::shared_ptr); + + private: + typedef std::vector > params; + + params params_; + std::vector bind_; + binding_type binding_; + }; + + // + // + template + struct query_column; + + class LIBODB_SQLITE_EXPORT query_base + { + public: + struct clause_part + { + enum kind_type + { + kind_column, + kind_param, + kind_native, + kind_bool + }; + + clause_part (kind_type k): kind (k) {} + clause_part (kind_type k, const std::string& p): kind (k), part (p) {} + clause_part (bool p): kind (kind_bool), bool_part (p) {} + + kind_type kind; + std::string part; // If kind is param, then part is conversion expr. + bool bool_part; + }; + + query_base () + : parameters_ (new (details::shared) query_params) + { + } + + // True or false literal. + // + explicit + query_base (bool v) + : parameters_ (new (details::shared) query_params) + { + append (v); + } + + explicit + query_base (const char* native) + : parameters_ (new (details::shared) query_params) + { + clause_.push_back (clause_part (clause_part::kind_native, native)); + } + + explicit + query_base (const std::string& native) + : parameters_ (new (details::shared) query_params) + { + clause_.push_back (clause_part (clause_part::kind_native, native)); + } + + query_base (const char* table, const char* column) + : parameters_ (new (details::shared) query_params) + { + append (table, column); + } + + template + explicit + query_base (val_bind v) + : parameters_ (new (details::shared) query_params) + { + *this += v; + } + + template + explicit + query_base (val_bind_typed v) + : parameters_ (new (details::shared) query_params) + { + *this += v; + } + + template + explicit + query_base (ref_bind r) + : parameters_ (new (details::shared) query_params) + { + *this += r; + } + + template + explicit + query_base (ref_bind_typed r) + : parameters_ (new (details::shared) query_params) + { + *this += r; + } + + template + query_base (const query_column&); + + // Translate common query representation to SQLite native. Defined + // in query-dynamic.cxx + // + query_base (const odb::query_base&); + + // Copy c-tor and assignment. + // + query_base (const query_base&); + + query_base& + operator= (const query_base&); + + public: + std::string + clause () const; + + const char* + clause_prefix () const; + + // Initialize the by-reference parameters from bound variables. + // + void + init_parameters () const; + + binding& + parameters_binding () const; + + const details::shared_ptr& + parameters () const; + + public: + bool + empty () const + { + return clause_.empty (); + } + + static const query_base true_expr; + + bool + const_true () const + { + return clause_.size () == 1 && + clause_.front ().kind == clause_part::kind_bool && + clause_.front ().bool_part; + } + + void + optimize (); + + public: + template + static val_bind + _val (const T& x) + { + return val_bind (x); + } + + template + static val_bind_typed + _val (const T& x) + { + return val_bind_typed (x); + } + + template + static ref_bind + _ref (const T& x) + { + return ref_bind (x); + } + + template + static ref_bind_typed + _ref (const T& x) + { + return ref_bind_typed (x); + } + + // Some compilers (notably VC++), when deducing const T& from const + // array do not strip const from the array type. As a result, in the + // above signatures we get, for example, T = const char[4] instead + // of T = char[4], which is what we want. So to "fix" such compilers, + // we will have to provide the following specializations of the above + // functions. + // + template + static val_bind + _val (const T (&x) [N]) + { + return val_bind (x); + } + + template + static val_bind_typed + _val (const T (&x) [N]) + { + return val_bind_typed (x); + } + + template + static ref_bind + _ref (const T (&x) [N]) + { + return ref_bind (x); + } + + template + static ref_bind_typed + _ref (const T (&x) [N]) + { + return ref_bind_typed (x); + } + + public: + query_base& + operator+= (const query_base&); + + query_base& + operator+= (const std::string& q) + { + append (q); + return *this; + } + + template + query_base& + operator+= (val_bind v) + { + append::db_type_id> ( + v, details::conversion::to ()); + return *this; + } + + template + query_base& + operator+= (val_bind_typed v) + { + // We are not using default type_traits so no default conversion + // either. + // + append (v, 0); + return *this; + } + + template + query_base& + operator+= (ref_bind r) + { + append::db_type_id> ( + r, details::conversion::to ()); + return *this; + } + + template + query_base& + operator+= (ref_bind_typed r) + { + // We are not using default type_traits so no default conversion + // either. + // + append (r, 0); + return *this; + } + + // Implementation details. + // + public: + template + void + append (val_bind, const char* conv); + + template + void + append (ref_bind, const char* conv); + + void + append (details::shared_ptr, const char* conv); + + void + append (bool v) + { + clause_.push_back (clause_part (v)); + } + + void + append (const std::string& native); + + void + append (const char* native) // Clashes with append(bool). + { + append (std::string (native)); + } + + void + append (const char* table, const char* column); + + private: + typedef std::vector clause_type; + + clause_type clause_; + details::shared_ptr parameters_; + }; + + inline query_base + operator+ (const query_base& x, const query_base& y) + { + query_base r (x); + r += y; + return r; + } + + template + inline query_base + operator+ (const query_base& q, val_bind b) + { + query_base r (q); + r += b; + return r; + } + + template + inline query_base + operator+ (val_bind b, const query_base& q) + { + query_base r; + r += b; + r += q; + return r; + } + + template + inline query_base + operator+ (const query_base& q, val_bind_typed b) + { + query_base r (q); + r += b; + return r; + } + + template + inline query_base + operator+ (val_bind_typed b, const query_base& q) + { + query_base r; + r += b; + r += q; + return r; + } + + template + inline query_base + operator+ (const query_base& q, ref_bind b) + { + query_base r (q); + r += b; + return r; + } + + template + inline query_base + operator+ (ref_bind b, const query_base& q) + { + query_base r; + r += b; + r += q; + return r; + } + + template + inline query_base + operator+ (const query_base& q, ref_bind_typed b) + { + query_base r (q); + r += b; + return r; + } + + template + inline query_base + operator+ (ref_bind_typed b, const query_base& q) + { + query_base r; + r += b; + r += q; + return r; + } + + inline query_base + operator+ (const query_base& q, const std::string& s) + { + query_base r (q); + r += s; + return r; + } + + inline query_base + operator+ (const std::string& s, const query_base& q) + { + query_base r (s); + r += q; + return r; + } + + template + inline query_base + operator+ (const std::string& s, val_bind b) + { + query_base r (s); + r += b; + return r; + } + + template + inline query_base + operator+ (val_bind b, const std::string& s) + { + query_base r; + r += b; + r += s; + return r; + } + + template + inline query_base + operator+ (const std::string& s, val_bind_typed b) + { + query_base r (s); + r += b; + return r; + } + + template + inline query_base + operator+ (val_bind_typed b, const std::string& s) + { + query_base r; + r += b; + r += s; + return r; + } + + template + inline query_base + operator+ (const std::string& s, ref_bind b) + { + query_base r (s); + r += b; + return r; + } + + template + inline query_base + operator+ (ref_bind b, const std::string& s) + { + query_base r; + r += b; + r += s; + return r; + } + + template + inline query_base + operator+ (const std::string& s, ref_bind_typed b) + { + query_base r (s); + r += b; + return r; + } + + template + inline query_base + operator+ (ref_bind_typed b, const std::string& s) + { + query_base r; + r += b; + r += s; + return r; + } + + LIBODB_SQLITE_EXPORT query_base + operator&& (const query_base&, const query_base&); + + LIBODB_SQLITE_EXPORT query_base + operator|| (const query_base&, const query_base&); + + LIBODB_SQLITE_EXPORT query_base + operator! (const query_base&); + + // query_column + // + struct LIBODB_SQLITE_EXPORT query_column_base + { + // Note that we keep shallow copies of the table, column, and conversion + // expression. The latter can be NULL. + // + query_column_base (const char* table, + const char* column, + const char* conv) + : table_ (table), column_ (column), conversion_ (conv) + { + } + + const char* + table () const + { + return table_; + } + + const char* + column () const + { + return column_; + } + + // Can be NULL. + // + const char* + conversion () const + { + return conversion_; + } + + protected: + const char* table_; + const char* column_; + const char* conversion_; + }; + + template + struct query_column: query_column_base + { + typedef typename decay_traits::type decayed_type; + + // Note that we keep shallow copies of the table, column, and conversion + // expression. The latter can be NULL. + // + query_column (const char* table, const char* column, const char* conv) + : query_column_base (table, column, conv) {} + + // Implementation is in query-dynamic.ixx. + // + query_column (odb::query_column&, + const char* table, const char* column, const char* conv); + + // is_null, is_not_null + // + public: + query_base + is_null () const + { + query_base q (table_, column_); + q += "IS NULL"; + return q; + } + + query_base + is_not_null () const + { + query_base q (table_, column_); + q += "IS NOT NULL"; + return q; + } + + // in + // + public: + query_base + in (decayed_type, decayed_type) const; + + query_base + in (decayed_type, decayed_type, decayed_type) const; + + query_base + in (decayed_type, decayed_type, decayed_type, decayed_type) const; + + query_base + in (decayed_type, decayed_type, decayed_type, decayed_type, + decayed_type) const; + + template + query_base + in_range (I begin, I end) const; + + // like + // + public: + query_base + like (decayed_type pattern) const + { + return like (val_bind (pattern)); + } + + query_base + like (val_bind pattern) const; + + template + query_base + like (val_bind pattern) const + { + return like (val_bind (decayed_type (pattern.val))); + } + + query_base + like (ref_bind pattern) const; + + query_base + like (decayed_type pattern, decayed_type escape) const + { + return like (val_bind (pattern), escape); + } + + query_base + like (val_bind pattern, decayed_type escape) const; + + template + query_base + like (val_bind pattern, decayed_type escape) const + { + return like (val_bind (decayed_type (pattern.val)), escape); + } + + query_base + like (ref_bind pattern, decayed_type escape) const; + + // = + // + public: + query_base + equal (decayed_type v) const + { + return equal (val_bind (v)); + } + + query_base + equal (val_bind v) const + { + query_base q (table_, column_); + q += "="; + q.append (v, conversion_); + return q; + } + + template + query_base + equal (val_bind v) const + { + return equal (val_bind (decayed_type (v.val))); + } + + query_base + equal (ref_bind r) const + { + query_base q (table_, column_); + q += "="; + q.append (r, conversion_); + return q; + } + + friend query_base + operator== (const query_column& c, decayed_type v) + { + return c.equal (v); + } + + friend query_base + operator== (decayed_type v, const query_column& c) + { + return c.equal (v); + } + + friend query_base + operator== (const query_column& c, val_bind v) + { + return c.equal (v); + } + + friend query_base + operator== (val_bind v, const query_column& c) + { + return c.equal (v); + } + + template + friend query_base + operator== (const query_column& c, val_bind v) + { + return c.equal (v); + } + + template + friend query_base + operator== (val_bind v, const query_column& c) + { + return c.equal (v); + } + + friend query_base + operator== (const query_column& c, ref_bind r) + { + return c.equal (r); + } + + friend query_base + operator== (ref_bind r, const query_column& c) + { + return c.equal (r); + } + + // != + // + public: + query_base + unequal (decayed_type v) const + { + return unequal (val_bind (v)); + } + + query_base + unequal (val_bind v) const + { + query_base q (table_, column_); + q += "!="; + q.append (v, conversion_); + return q; + } + + template + query_base + unequal (val_bind v) const + { + return unequal (val_bind (decayed_type (v.val))); + } + + query_base + unequal (ref_bind r) const + { + query_base q (table_, column_); + q += "!="; + q.append (r, conversion_); + return q; + } + + friend query_base + operator!= (const query_column& c, decayed_type v) + { + return c.unequal (v); + } + + friend query_base + operator!= (decayed_type v, const query_column& c) + { + return c.unequal (v); + } + + friend query_base + operator!= (const query_column& c, val_bind v) + { + return c.unequal (v); + } + + friend query_base + operator!= (val_bind v, const query_column& c) + { + return c.unequal (v); + } + + template + friend query_base + operator!= (const query_column& c, val_bind v) + { + return c.unequal (v); + } + + template + friend query_base + operator!= (val_bind v, const query_column& c) + { + return c.unequal (v); + } + + friend query_base + operator!= (const query_column& c, ref_bind r) + { + return c.unequal (r); + } + + friend query_base + operator!= (ref_bind r, const query_column& c) + { + return c.unequal (r); + } + + // < + // + public: + query_base + less (decayed_type v) const + { + return less (val_bind (v)); + } + + query_base + less (val_bind v) const + { + query_base q (table_, column_); + q += "<"; + q.append (v, conversion_); + return q; + } + + template + query_base + less (val_bind v) const + { + return less (val_bind (decayed_type (v.val))); + } + + query_base + less (ref_bind r) const + { + query_base q (table_, column_); + q += "<"; + q.append (r, conversion_); + return q; + } + + friend query_base + operator< (const query_column& c, decayed_type v) + { + return c.less (v); + } + + friend query_base + operator< (decayed_type v, const query_column& c) + { + return c.greater (v); + } + + friend query_base + operator< (const query_column& c, val_bind v) + { + return c.less (v); + } + + friend query_base + operator< (val_bind v, const query_column& c) + { + return c.greater (v); + } + + template + friend query_base + operator< (const query_column& c, val_bind v) + { + return c.less (v); + } + + template + friend query_base + operator< (val_bind v, const query_column& c) + { + return c.greater (v); + } + + friend query_base + operator< (const query_column& c, ref_bind r) + { + return c.less (r); + } + + friend query_base + operator< (ref_bind r, const query_column& c) + { + return c.greater (r); + } + + // > + // + public: + query_base + greater (decayed_type v) const + { + return greater (val_bind (v)); + } + + query_base + greater (val_bind v) const + { + query_base q (table_, column_); + q += ">"; + q.append (v, conversion_); + return q; + } + + template + query_base + greater (val_bind v) const + { + return greater (val_bind (decayed_type (v.val))); + } + + query_base + greater (ref_bind r) const + { + query_base q (table_, column_); + q += ">"; + q.append (r, conversion_); + return q; + } + + friend query_base + operator> (const query_column& c, decayed_type v) + { + return c.greater (v); + } + + friend query_base + operator> (decayed_type v, const query_column& c) + { + return c.less (v); + } + + friend query_base + operator> (const query_column& c, val_bind v) + { + return c.greater (v); + } + + friend query_base + operator> (val_bind v, const query_column& c) + { + return c.less (v); + } + + template + friend query_base + operator> (const query_column& c, val_bind v) + { + return c.greater (v); + } + + template + friend query_base + operator> (val_bind v, const query_column& c) + { + return c.less (v); + } + + friend query_base + operator> (const query_column& c, ref_bind r) + { + return c.greater (r); + } + + friend query_base + operator> (ref_bind r, const query_column& c) + { + return c.less (r); + } + + // <= + // + public: + query_base + less_equal (decayed_type v) const + { + return less_equal (val_bind (v)); + } + + query_base + less_equal (val_bind v) const + { + query_base q (table_, column_); + q += "<="; + q.append (v, conversion_); + return q; + } + + template + query_base + less_equal (val_bind v) const + { + return less_equal (val_bind (decayed_type (v.val))); + } + + query_base + less_equal (ref_bind r) const + { + query_base q (table_, column_); + q += "<="; + q.append (r, conversion_); + return q; + } + + friend query_base + operator<= (const query_column& c, decayed_type v) + { + return c.less_equal (v); + } + + friend query_base + operator<= (decayed_type v, const query_column& c) + { + return c.greater_equal (v); + } + + friend query_base + operator<= (const query_column& c, val_bind v) + { + return c.less_equal (v); + } + + friend query_base + operator<= (val_bind v, const query_column& c) + { + return c.greater_equal (v); + } + + template + friend query_base + operator<= (const query_column& c, val_bind v) + { + return c.less_equal (v); + } + + template + friend query_base + operator<= (val_bind v, const query_column& c) + { + return c.greater_equal (v); + } + + friend query_base + operator<= (const query_column& c, ref_bind r) + { + return c.less_equal (r); + } + + friend query_base + operator<= (ref_bind r, const query_column& c) + { + return c.greater_equal (r); + } + + // >= + // + public: + query_base + greater_equal (decayed_type v) const + { + return greater_equal (val_bind (v)); + } + + query_base + greater_equal (val_bind v) const + { + query_base q (table_, column_); + q += ">="; + q.append (v, conversion_); + return q; + } + + template + query_base + greater_equal (val_bind v) const + { + return greater_equal (val_bind (decayed_type (v.val))); + } + + query_base + greater_equal (ref_bind r) const + { + query_base q (table_, column_); + q += ">="; + q.append (r, conversion_); + return q; + } + + friend query_base + operator>= (const query_column& c, decayed_type v) + { + return c.greater_equal (v); + } + + friend query_base + operator>= (decayed_type v, const query_column& c) + { + return c.less_equal (v); + } + + friend query_base + operator>= (const query_column& c, val_bind v) + { + return c.greater_equal (v); + } + + friend query_base + operator>= (val_bind v, const query_column& c) + { + return c.less_equal (v); + } + + template + friend query_base + operator>= (const query_column& c, val_bind v) + { + return c.greater_equal (v); + } + + template + friend query_base + operator>= (val_bind v, const query_column& c) + { + return c.less_equal (v); + } + + friend query_base + operator>= (const query_column& c, ref_bind r) + { + return c.greater_equal (r); + } + + friend query_base + operator>= (ref_bind r, const query_column& c) + { + return c.less_equal (r); + } + + // Column comparison. + // + public: + template + query_base + operator== (const query_column& c) const + { + // We can compare columns only if we can compare their C++ types. + // + (void) (sizeof (decay_traits::instance () == + decay_traits::instance ())); + + query_base q (table_, column_); + q += "="; + q.append (c.table (), c.column ()); + return q; + } + + template + query_base + operator!= (const query_column& c) const + { + // We can compare columns only if we can compare their C++ types. + // + (void) (sizeof (decay_traits::instance () != + decay_traits::instance ())); + + query_base q (table_, column_); + q += "!="; + q.append (c.table (), c.column ()); + return q; + } + + template + query_base + operator< (const query_column& c) const + { + // We can compare columns only if we can compare their C++ types. + // + (void) (sizeof (decay_traits::instance () < + decay_traits::instance ())); + + query_base q (table_, column_); + q += "<"; + q.append (c.table (), c.column ()); + return q; + } + + template + query_base + operator> (const query_column& c) const + { + // We can compare columns only if we can compare their C++ types. + // + (void) (sizeof (decay_traits::instance () > + decay_traits::instance ())); + + query_base q (table_, column_); + q += ">"; + q.append (c.table (), c.column ()); + return q; + } + + template + query_base + operator<= (const query_column& c) const + { + // We can compare columns only if we can compare their C++ types. + // + (void) (sizeof (decay_traits::instance () <= + decay_traits::instance ())); + + query_base q (table_, column_); + q += "<="; + q.append (c.table (), c.column ()); + return q; + } + + template + query_base + operator>= (const query_column& c) const + { + // We can compare columns only if we can compare their C++ types. + // + (void) (sizeof (decay_traits::instance () >= + decay_traits::instance ())); + + query_base q (table_, column_); + q += ">="; + q.append (c.table (), c.column ()); + return q; + } + }; + + // Provide operator+() for using columns to construct native + // query fragments (e.g., ORDER BY). + // + template + inline query_base + operator+ (const query_column& c, const std::string& s) + { + query_base q (c.table (), c.column ()); + q += s; + return q; + } + + template + inline query_base + operator+ (const std::string& s, const query_column& c) + { + query_base q (s); + q.append (c.table (), c.column ()); + return q; + } + + template + inline query_base + operator+ (const query_column& c, const query_base& q) + { + query_base r (c.table (), c.column ()); + r += q; + return r; + } + + template + inline query_base + operator+ (const query_base& q, const query_column& c) + { + query_base r (q); + r.append (c.table (), c.column ()); + return r; + } + + // + // + template + struct query_param_impl; + + // INTEGER + // + template + struct query_param_impl: query_param + { + query_param_impl (ref_bind r) : query_param (r.ptr ()) {} + query_param_impl (val_bind v) : query_param (0) {init (v.val);} + + virtual bool + init () + { + init (*static_cast (value_)); + return false; + } + + virtual void + bind (sqlite::bind* b) + { + b->type = sqlite::bind::integer; + b->buffer = &image_; + } + + private: + void + init (typename decay_traits::type v) + { + bool is_null (false); // Can't be NULL. + value_traits::set_image (image_, is_null, v); + } + + private: + long long image_; + }; + + // REAL + // + template + struct query_param_impl: query_param + { + query_param_impl (ref_bind r) : query_param (r.ptr ()) {} + query_param_impl (val_bind v) : query_param (0) {init (v.val);} + + virtual bool + init () + { + init (*static_cast (value_)); + return false; + } + + virtual void + bind (sqlite::bind* b) + { + b->type = sqlite::bind::real; + b->buffer = &image_; + } + + private: + void + init (typename decay_traits::type v) + { + bool is_null (false); // Can't be NULL. + value_traits::set_image (image_, is_null, v); + } + + private: + double image_; + }; + + // TEXT + // + template + struct query_param_impl: query_param + { + query_param_impl (ref_bind r) : query_param (r.ptr ()) {} + query_param_impl (val_bind v) : query_param (0) {init (v.val);} + + virtual bool + init () + { + return init (*static_cast (value_)); + } + + virtual void + bind (sqlite::bind* b) + { + b->type = image_traits::bind_value; + b->buffer = buffer_.data (); + b->size = &size_; + } + + private: + bool + init (typename decay_traits::type v) + { + bool is_null (false); // Can't be NULL. + std::size_t cap (buffer_.capacity ()); + value_traits::set_image (buffer_, size_, is_null, v); + return cap != buffer_.capacity (); + } + + private: + details::buffer buffer_; + std::size_t size_; + }; + + // BLOB + // + template + struct query_param_impl: query_param + { + query_param_impl (ref_bind r) : query_param (r.ptr ()) {} + query_param_impl (val_bind v) : query_param (0) {init (v.val);} + + virtual bool + init () + { + return init (*static_cast (value_)); + } + + virtual void + bind (sqlite::bind* b) + { + b->type = sqlite::bind::blob; + b->buffer = buffer_.data (); + b->size = &size_; + } + + private: + bool + init (typename decay_traits::type v) + { + bool is_null (false); // Can't be NULL. + std::size_t cap (buffer_.capacity ()); + value_traits::set_image (buffer_, size_, is_null, v); + return cap != buffer_.capacity (); + } + + private: + details::buffer buffer_; + std::size_t size_; + }; + } +} + +// odb::sqlite::query and odb::query specialization for SQLite. +// +namespace odb +{ + namespace sqlite + { + template + class query: public query_base, + public query_selector::columns_type + { + public: + // We don't define any typedefs here since they may clash with + // column names defined by our base type. + // + + query () + { + } + + explicit + query (bool v) + : query_base (v) + { + } + + explicit + query (const char* q) + : query_base (q) + { + } + + explicit + query (const std::string& q) + : query_base (q) + { + } + + template + explicit + query (val_bind v) + : query_base (v) + { + } + + template + explicit + query (ref_bind r) + : query_base (r) + { + } + + query (const query_base& q) + : query_base (q) + { + } + + template + query (const query_column& qc) + : query_base (qc) + { + } + + query (const odb::query_base& q) + : query_base (q) + { + } + }; + + namespace core + { + using sqlite::query; + } + } + + // Derive odb::query from odb::sqlite::query so that it can be + // implicitly converted in sqlite::database::query() calls. + // + template + class query: public sqlite::query + { + public: + // We don't define any typedefs here since they may clash with + // column names defined by our base type. + // + + query () + { + } + + explicit + query (bool v) + : sqlite::query (v) + { + } + + explicit + query (const char* q) + : sqlite::query (q) + { + } + + explicit + query (const std::string& q) + : sqlite::query (q) + { + } + + template + explicit + query (sqlite::val_bind v) + : sqlite::query (v) + { + } + + template + explicit + query (sqlite::ref_bind r) + : sqlite::query (r) + { + } + + query (const sqlite::query_base& q) + : sqlite::query (q) + { + } + + template + query (const sqlite::query_column& qc) + : sqlite::query (qc) + { + } + }; +} + +#include +#include + +#include + +#endif // ODB_SQLITE_QUERY_HXX diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/query.ixx b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/query.ixx new file mode 100755 index 0000000..70fadec --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/query.ixx @@ -0,0 +1,47 @@ +// file : odb/sqlite/query.ixx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +namespace odb +{ + namespace sqlite + { + inline void query_base:: + init_parameters () const + { + return parameters_->init (); + } + + inline binding& query_base:: + parameters_binding () const + { + return parameters_->binding (); + } + + inline const details::shared_ptr& query_base:: + parameters () const + { + return parameters_; + } + + template + inline void query_base:: + append (val_bind v, const char* conv) + { + append ( + details::shared_ptr ( + new (details::shared) query_param_impl (v)), + conv); + } + + template + inline void query_base:: + append (ref_bind r, const char* conv) + { + append ( + details::shared_ptr ( + new (details::shared) query_param_impl (r)), + conv); + } + } +} diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/query.txx b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/query.txx new file mode 100755 index 0000000..b51b45a --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/query.txx @@ -0,0 +1,164 @@ +// file : odb/sqlite/query.txx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +namespace odb +{ + namespace sqlite + { + // + // query_base + // + + template + query_base:: + query_base (const query_column& c) + : parameters_ (new (details::shared) query_params) + { + // Cannot use IS TRUE here since database type can be a non- + // integral type. + // + append (c.table (), c.column ()); + append ("="); + append (val_bind (true), c.conversion ()); + } + + // + // query_column + // + + // in + // + template + query_base query_column:: + in (decayed_type v1, decayed_type v2) const + { + query_base q (table_, column_); + q += "IN ("; + q.append (val_bind (v1), conversion_); + q += ","; + q.append (val_bind (v2), conversion_); + q += ")"; + return q; + } + + template + query_base query_column:: + in (decayed_type v1, decayed_type v2, decayed_type v3) const + { + query_base q (table_, column_); + q += "IN ("; + q.append (val_bind (v1), conversion_); + q += ","; + q.append (val_bind (v2), conversion_); + q += ","; + q.append (val_bind (v3), conversion_); + q += ")"; + return q; + } + + template + query_base query_column:: + in (decayed_type v1, decayed_type v2, decayed_type v3, + decayed_type v4) const + { + query_base q (table_, column_); + q += "IN ("; + q.append (val_bind (v1), conversion_); + q += ","; + q.append (val_bind (v2), conversion_); + q += ","; + q.append (val_bind (v3), conversion_); + q += ","; + q.append (val_bind (v4), conversion_); + q += ")"; + return q; + } + + template + query_base query_column:: + in (decayed_type v1, decayed_type v2, decayed_type v3, decayed_type v4, + decayed_type v5) const + { + query_base q (table_, column_); + q += "IN ("; + q.append (val_bind (v1), conversion_); + q += ","; + q.append (val_bind (v2), conversion_); + q += ","; + q.append (val_bind (v3), conversion_); + q += ","; + q.append (val_bind (v4), conversion_); + q += ","; + q.append (val_bind (v5), conversion_); + q += ")"; + return q; + } + + template + template + query_base query_column:: + in_range (I begin, I end) const + { + query_base q (table_, column_); + q += "IN ("; + + for (I i (begin); i != end; ++i) + { + if (i != begin) + q += ","; + + q.append (val_bind (*i), conversion_); + } + + q += ")"; + return q; + } + + // like + // + template + query_base query_column:: + like (val_bind p) const + { + query_base q (table_, column_); + q += "LIKE"; + q.append (p, conversion_); + return q; + } + + template + query_base query_column:: + like (ref_bind p) const + { + query_base q (table_, column_); + q += "LIKE"; + q.append (p, conversion_); + return q; + } + + template + query_base query_column:: + like (val_bind p, decayed_type e) const + { + query_base q (table_, column_); + q += "LIKE"; + q.append (p, conversion_); + q += "ESCAPE"; + q.append (val_bind (e), conversion_); + return q; + } + + template + query_base query_column:: + like (ref_bind p, decayed_type e) const + { + query_base q (table_, column_); + q += "LIKE"; + q.append (p, conversion_); + q += "ESCAPE"; + q.append (val_bind (e), conversion_); + return q; + } + } +} diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/section-statements.hxx b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/section-statements.hxx new file mode 100755 index 0000000..40ac4d1 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/section-statements.hxx @@ -0,0 +1,199 @@ +// file : odb/sqlite/section-statements.hxx +// copyright : Copyright (c) 2005-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_SQLITE_SECTION_STATEMENTS_HXX +#define ODB_SQLITE_SECTION_STATEMENTS_HXX + +#include + +#include // std::size_t + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +namespace odb +{ + namespace sqlite + { + class connection; + + // Template argument is the section traits type. + // + template + class section_statements + { + public: + typedef ST traits; + + typedef typename traits::image_type image_type; + typedef typename traits::id_image_type id_image_type; + + typedef sqlite::select_statement select_statement_type; + typedef sqlite::update_statement update_statement_type; + + typedef sqlite::connection connection_type; + + section_statements (connection_type&, + image_type&, id_image_type&, + binding& id, binding& idv); + + connection_type& + connection () {return conn_;} + + const schema_version_migration& + version_migration (const char* name = "") const + { + if (svm_ == 0) + svm_ = &conn_.database ().schema_version_migration (name); + + return *svm_; + } + + image_type& + image () {return image_;} + + const binding& + id_binding () {return id_binding_;} + + // Id and optimistic concurrency version (if any). + // + const binding& + idv_binding () {return idv_binding_;} + + // Select binding. + // + std::size_t + select_image_version () const { return select_image_version_;} + + void + select_image_version (std::size_t v) {select_image_version_ = v;} + + binding& + select_image_binding () {return select_image_binding_;} + + bool* + select_image_truncated () {return select_image_truncated_;} + + // Update binding. + // + std::size_t + update_image_version () const { return update_image_version_;} + + void + update_image_version (std::size_t v) {update_image_version_ = v;} + + std::size_t + update_id_binding_version () const { return update_id_binding_version_;} + + void + update_id_binding_version (std::size_t v) {update_id_binding_version_ = v;} + + binding& + update_image_binding () {return update_image_binding_;} + + // + // Statements. + // + + select_statement_type& + select_statement () + { + if (select_ == 0) + select_.reset ( + new (details::shared) select_statement_type ( + conn_, + traits::select_statement, + traits::versioned, // Process if versioned. + false, // Don't optimize. + id_binding_, + select_image_binding_)); + + return *select_; + } + + update_statement_type& + update_statement () + { + if (update_ == 0) + update_.reset ( + new (details::shared) update_statement_type ( + conn_, + traits::update_statement, + traits::versioned, // Process if versioned. + update_image_binding_)); + + return *update_; + } + + public: + static const std::size_t id_column_count = traits::id_column_count; + static const std::size_t managed_optimistic_load_column_count = + traits::managed_optimistic_load_column_count; + static const std::size_t managed_optimistic_update_column_count = + traits::managed_optimistic_update_column_count; + static const std::size_t select_column_count = traits::load_column_count; + static const std::size_t update_column_count = + traits::update_column_count; + + private: + section_statements (const section_statements&); + section_statements& operator= (const section_statements&); + + protected: + connection_type& conn_; + mutable const schema_version_migration* svm_; + + // These come from object_statements. + // + image_type& image_; + binding& id_binding_; + binding& idv_binding_; + + // Select binding. + // + std::size_t select_image_version_; + + static const std::size_t select_bind_count = + select_column_count != 0 || managed_optimistic_load_column_count != 0 + ? select_column_count + managed_optimistic_load_column_count + : 1; + + binding select_image_binding_; + bind select_image_bind_[select_bind_count]; + bool select_image_truncated_[select_bind_count]; + + // Update binding. + // + std::size_t update_image_version_; + std::size_t update_id_binding_version_; + + static const std::size_t update_bind_count = + update_column_count != 0 || managed_optimistic_update_column_count != 0 + ? update_column_count + id_column_count + + managed_optimistic_update_column_count + : 1; + + binding update_image_binding_; + bind update_image_bind_[update_bind_count]; + + details::shared_ptr select_; + details::shared_ptr update_; + }; + } +} + +#include + +#include + +#endif // ODB_SQLITE_SECTION_STATEMENTS_HXX diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/section-statements.txx b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/section-statements.txx new file mode 100755 index 0000000..3c4d10e --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/section-statements.txx @@ -0,0 +1,41 @@ +// file : odb/sqlite/section-statements.txx +// copyright : Copyright (c) 2005-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include // std::memset + +namespace odb +{ + namespace sqlite + { + template + section_statements:: + section_statements (connection_type& conn, + image_type& im, id_image_type&, + binding& id, binding& idv) + : conn_ (conn), + svm_ (0), + image_ (im), + id_binding_ (id), + idv_binding_ (idv), + select_image_binding_ (select_image_bind_, + select_column_count + + managed_optimistic_load_column_count), + update_image_binding_ (update_image_bind_, + update_column_count + id_column_count + + managed_optimistic_update_column_count) + { + select_image_version_ = 0; + update_image_version_ = 0; + update_id_binding_version_ = 0; + + std::memset (select_image_bind_, 0, sizeof (select_image_bind_)); + std::memset ( + select_image_truncated_, 0, sizeof (select_image_truncated_)); + std::memset (update_image_bind_, 0, sizeof (update_image_bind_)); + + for (std::size_t i (0); i < select_bind_count; ++i) + select_image_bind_[i].truncated = select_image_truncated_ + i; + } + } +} diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/simple-object-result.hxx b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/simple-object-result.hxx new file mode 100755 index 0000000..ec42bf5 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/simple-object-result.hxx @@ -0,0 +1,89 @@ +// file : odb/sqlite/simple-object-result.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_SQLITE_SIMPLE_OBJECT_RESULT_HXX +#define ODB_SQLITE_SIMPLE_OBJECT_RESULT_HXX + +#include + +#include // std::size_t + +#include +#include + +#include + +#include +#include // query_base, query_params +#include +#include + +namespace odb +{ + namespace sqlite + { + template + class object_result_impl: public odb::object_result_impl + { + public: + typedef odb::object_result_impl base_type; + + typedef typename base_type::id_type id_type; + typedef typename base_type::object_type object_type; + typedef typename base_type::pointer_type pointer_type; + + typedef object_traits_impl object_traits; + typedef typename base_type::pointer_traits pointer_traits; + + typedef typename object_traits::statements_type statements_type; + + virtual + ~object_result_impl (); + + object_result_impl (const query_base&, + const details::shared_ptr&, + statements_type&, + const schema_version_migration*); + + virtual void + load (object_type&, bool fetch); + + virtual id_type + load_id (); + + virtual void + next (); + + virtual void + cache (); + + virtual std::size_t + size (); + + virtual void + invalidate (); + + using base_type::current; + + private: + void + load_image (); + + private: + // We need to hold on to the query parameters because SQLite uses + // the parameter buffers to find each next row. + // + details::shared_ptr params_; + details::shared_ptr statement_; + statements_type& statements_; + object_traits_calls tc_; + }; + } +} + +#include + +#include + +#endif // ODB_SQLITE_SIMPLE_OBJECT_RESULT_HXX diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/simple-object-result.txx b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/simple-object-result.txx new file mode 100755 index 0000000..b1563bb --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/simple-object-result.txx @@ -0,0 +1,159 @@ +// file : odb/sqlite/simple-object-result.txx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include + +#include +#include // result_not_cached + +#include + +namespace odb +{ + namespace sqlite + { + template + object_result_impl:: + ~object_result_impl () + { + if (!this->end_) + statement_->free_result (); + } + + template + void object_result_impl:: + invalidate () + { + if (!this->end_) + { + statement_->free_result (); + this->end_ = true; + } + + params_.reset (); + statement_.reset (); + } + + template + object_result_impl:: + object_result_impl (const query_base& q, + const details::shared_ptr& s, + statements_type& sts, + const schema_version_migration* svm) + : base_type (sts.connection ()), + params_ (q.parameters ()), + statement_ (s), + statements_ (sts), + tc_ (svm) + { + } + + template + void object_result_impl:: + load (object_type& obj, bool fetch) + { + if (fetch) + load_image (); + + // This is a top-level call so the statements cannot be locked. + // + assert (!statements_.locked ()); + typename statements_type::auto_lock l (statements_); + + object_traits::callback (this->db_, obj, callback_event::pre_load); + + typename object_traits::image_type& i (statements_.image ()); + tc_.init (obj, i, &this->db_); + + // Initialize the id image and binding and load the rest of the object + // (containers, etc). + // + typename object_traits::id_image_type& idi (statements_.id_image ()); + object_traits::init (idi, object_traits::id (i)); + + binding& idb (statements_.id_image_binding ()); + if (idi.version != statements_.id_image_version () || idb.version == 0) + { + object_traits::bind (idb.bind, idi); + statements_.id_image_version (idi.version); + idb.version++; + } + + tc_.load_ (statements_, obj, false); + statements_.load_delayed (tc_.version ()); + l.unlock (); + object_traits::callback (this->db_, obj, callback_event::post_load); + } + + template + typename object_result_impl::id_type + object_result_impl:: + load_id () + { + load_image (); + return object_traits::id (statements_.image ()); + } + + template + void object_result_impl:: + next () + { + this->current (pointer_type ()); + + if (!statement_->next ()) + { + statement_->free_result (); + this->end_ = true; + } + } + + template + void object_result_impl:: + load_image () + { + // The image can grow between calls to load() as a result of other + // statements execution. + // + typename object_traits::image_type& im (statements_.image ()); + + if (im.version != statements_.select_image_version ()) + { + binding& b (statements_.select_image_binding ()); + tc_.bind (b.bind, im, statement_select); + statements_.select_image_version (im.version); + b.version++; + } + + select_statement::result r (statement_->load ()); + + if (r == select_statement::truncated) + { + if (tc_.grow (im, statements_.select_image_truncated ())) + im.version++; + + if (im.version != statements_.select_image_version ()) + { + binding& b (statements_.select_image_binding ()); + tc_.bind (b.bind, im, statement_select); + statements_.select_image_version (im.version); + b.version++; + statement_->reload (); + } + } + } + + template + void object_result_impl:: + cache () + { + } + + template + std::size_t object_result_impl:: + size () + { + throw result_not_cached (); + } + } +} diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/simple-object-statements.cxx b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/simple-object-statements.cxx new file mode 100755 index 0000000..1bec013 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/simple-object-statements.cxx @@ -0,0 +1,16 @@ +// file : odb/sqlite/simple-object-statements.cxx +// copyright : Copyright (c) 2005-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include + +namespace odb +{ + namespace sqlite + { + object_statements_base:: + ~object_statements_base () + { + } + } +} diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/simple-object-statements.hxx b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/simple-object-statements.hxx new file mode 100755 index 0000000..6ea7f6d --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/simple-object-statements.hxx @@ -0,0 +1,592 @@ +// file : odb/sqlite/simple-object-statements.hxx +// copyright : Copyright (c) 2005-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_SQLITE_SIMPLE_OBJECT_STATEMENTS_HXX +#define ODB_SQLITE_SIMPLE_OBJECT_STATEMENTS_HXX + +#include + +#include +#include +#include // std::size_t + +#include +#include + +#include + +#include +#include +#include +#include +#include +#include + +#include + +namespace odb +{ + namespace sqlite + { + // The extra_statement_cache class is only defined (and used) in + // the generated source file. However, object_statements may be + // referenced from another source file in the case of a polymorphic + // hierarchy (though in this case the extra statement cache is + // not used). As a result, we cannot have a by-value member and + // instead will store a pointer and lazily allocate the cache if + // and when needed. We will also need to store a pointer to the + // deleter function which will be initialized during allocation + // (at that point we know that the cache class is defined). + // + template + struct extra_statement_cache_ptr + { + typedef I image_type; + typedef ID id_image_type; + typedef sqlite::connection connection_type; + + extra_statement_cache_ptr (): p_ (0) {} + ~extra_statement_cache_ptr () + { + if (p_ != 0) + (this->*deleter_) (0, 0, 0, 0, 0); + } + + T& + get (connection_type& c, + image_type& im, id_image_type& idim, + binding& id, binding* idv) + { + if (p_ == 0) + allocate (&c, &im, &idim, &id, (idv != 0 ? idv : &id)); + + return *p_; + } + + private: + void + allocate (connection_type*, + image_type*, id_image_type*, + binding*, binding*); + + private: + T* p_; + void (extra_statement_cache_ptr::*deleter_) ( + connection_type*, image_type*, id_image_type*, binding*, binding*); + }; + + template + void extra_statement_cache_ptr:: + allocate (connection_type* c, + image_type* im, id_image_type* idim, + binding* id, binding* idv) + { + // To reduce object code size, this function acts as both allocator + // and deleter. + // + if (p_ == 0) + { + p_ = new T (*c, *im, *idim, *id, *idv); + deleter_ = &extra_statement_cache_ptr::allocate; + } + else + delete p_; + } + + // + // Implementation for objects with object id. + // + + class LIBODB_SQLITE_EXPORT object_statements_base: public statements_base + { + public: + // Locking. + // + void + lock () + { + assert (!locked_); + locked_ = true; + } + + void + unlock () + { + assert (locked_); + locked_ = false; + } + + bool + locked () const + { + return locked_; + } + + struct auto_unlock + { + // Unlocks the statement on construction and re-locks it on + // destruction. + // + auto_unlock (object_statements_base&); + ~auto_unlock (); + + private: + auto_unlock (const auto_unlock&); + auto_unlock& operator= (const auto_unlock&); + + private: + object_statements_base& s_; + }; + + public: + virtual + ~object_statements_base (); + + protected: + object_statements_base (connection_type& conn) + : statements_base (conn), locked_ (false) + { + } + + protected: + bool locked_; + }; + + template + struct optimistic_data; + + template + struct optimistic_data + { + typedef T object_type; + typedef object_traits_impl object_traits; + + optimistic_data (bind*); + + binding* + id_image_binding () {return &id_image_binding_;} + + // The id + optimistic column binding. + // + binding id_image_binding_; + + details::shared_ptr erase_; + }; + + template + struct optimistic_data + { + optimistic_data (bind*) {} + + binding* + id_image_binding () {return 0;} + }; + + template + class object_statements: public object_statements_base + { + public: + typedef T object_type; + typedef object_traits_impl object_traits; + typedef typename object_traits::id_type id_type; + typedef typename object_traits::pointer_type pointer_type; + typedef typename object_traits::image_type image_type; + typedef typename object_traits::id_image_type id_image_type; + + typedef + typename object_traits::pointer_cache_traits + pointer_cache_traits; + + typedef + typename object_traits::extra_statement_cache_type + extra_statement_cache_type; + + typedef sqlite::insert_statement insert_statement_type; + typedef sqlite::select_statement select_statement_type; + typedef sqlite::update_statement update_statement_type; + typedef sqlite::delete_statement delete_statement_type; + + // Automatic lock. + // + struct auto_lock + { + // Lock the statements unless they are already locked in which + // case subsequent calls to locked() will return false. + // + auto_lock (object_statements&); + + // Unlock the statemens if we are holding the lock and clear + // the delayed loads. This should only happen in case an + // exception is thrown. In normal circumstances, the user + // should call unlock() explicitly. + // + ~auto_lock (); + + // Return true if this auto_lock instance holds the lock. + // + bool + locked () const; + + // Unlock the statemens. + // + void + unlock (); + + private: + auto_lock (const auto_lock&); + auto_lock& operator= (const auto_lock&); + + private: + object_statements& s_; + bool locked_; + }; + + + public: + object_statements (connection_type&); + + virtual + ~object_statements (); + + // Delayed loading. + // + typedef void (*loader_function) (odb::database&, + const id_type&, + object_type&, + const schema_version_migration*); + + void + delay_load (const id_type& id, + object_type& obj, + const typename pointer_cache_traits::position_type& p, + loader_function l = 0) + { + delayed_.push_back (delayed_load (id, obj, p, l)); + } + + void + load_delayed (const schema_version_migration* svm) + { + assert (locked ()); + + if (!delayed_.empty ()) + load_delayed_ (svm); + } + + void + clear_delayed () + { + if (!delayed_.empty ()) + clear_delayed_ (); + } + + // Object image. + // + image_type& + image () {return image_;} + + // Insert binding. + // + std::size_t + insert_image_version () const { return insert_image_version_;} + + void + insert_image_version (std::size_t v) {insert_image_version_ = v;} + + binding& + insert_image_binding () {return insert_image_binding_;} + + // Update binding. + // + std::size_t + update_image_version () const { return update_image_version_;} + + void + update_image_version (std::size_t v) {update_image_version_ = v;} + + std::size_t + update_id_image_version () const { return update_id_image_version_;} + + void + update_id_image_version (std::size_t v) {update_id_image_version_ = v;} + + binding& + update_image_binding () {return update_image_binding_;} + + // Select binding. + // + std::size_t + select_image_version () const { return select_image_version_;} + + void + select_image_version (std::size_t v) {select_image_version_ = v;} + + binding& + select_image_binding () {return select_image_binding_;} + + bool* + select_image_truncated () {return select_image_truncated_;} + + // Object id image and binding. + // + id_image_type& + id_image () {return id_image_;} + + std::size_t + id_image_version () const {return id_image_version_;} + + void + id_image_version (std::size_t v) {id_image_version_ = v;} + + binding& + id_image_binding () {return id_image_binding_;} + + // Optimistic id + managed column image binding. It points to + // the same suffix as id binding and they are always updated + // at the same time. + // + binding& + optimistic_id_image_binding () {return od_.id_image_binding_;} + + // Statements. + // + insert_statement_type& + persist_statement () + { + if (persist_ == 0) + { + persist_.reset ( + new (details::shared) insert_statement_type ( + conn_, + object_traits::persist_statement, + object_traits::versioned, // Process if versioned. + insert_image_binding_, + (object_traits::auto_id ? &id_image_binding_ : 0))); + } + + return *persist_; + } + + select_statement_type& + find_statement () + { + if (find_ == 0) + { + find_.reset ( + new (details::shared) select_statement_type ( + conn_, + object_traits::find_statement, + object_traits::versioned, // Process if versioned. + false, // Don't optimize. + id_image_binding_, + select_image_binding_)); + } + + return *find_; + } + + update_statement_type& + update_statement () + { + if (update_ == 0) + { + update_.reset ( + new (details::shared) update_statement_type ( + conn_, + object_traits::update_statement, + object_traits::versioned, // Process if versioned. + update_image_binding_)); + } + + return *update_; + } + + delete_statement_type& + erase_statement () + { + if (erase_ == 0) + { + erase_.reset ( + new (details::shared) delete_statement_type ( + conn_, + object_traits::erase_statement, + id_image_binding_)); + } + + return *erase_; + } + + delete_statement_type& + optimistic_erase_statement () + { + if (od_.erase_ == 0) + { + od_.erase_.reset ( + new (details::shared) delete_statement_type ( + conn_, + object_traits::optimistic_erase_statement, + od_.id_image_binding_)); + } + + return *od_.erase_; + } + + // Extra (container, section) statement cache. + // + extra_statement_cache_type& + extra_statement_cache () + { + return extra_statement_cache_.get ( + conn_, + image_, id_image_, + id_image_binding_, od_.id_image_binding ()); + } + + public: + // select = total - separate_load + // insert = total - inverse - managed_optimistic + // update = total - inverse - managed_optimistic - id - readonly + // - separate_update + // + static const std::size_t id_column_count = + object_traits::id_column_count; + + static const std::size_t managed_optimistic_column_count = + object_traits::managed_optimistic_column_count; + + static const std::size_t select_column_count = + object_traits::column_count - + object_traits::separate_load_column_count; + + static const std::size_t insert_column_count = + object_traits::column_count - + object_traits::inverse_column_count - + object_traits::managed_optimistic_column_count; + + static const std::size_t update_column_count = + insert_column_count - + id_column_count - + object_traits::readonly_column_count - + object_traits::separate_update_column_count; + + private: + object_statements (const object_statements&); + object_statements& operator= (const object_statements&); + + protected: + template + void + load_delayed_ (const schema_version_migration*); + + void + clear_delayed_ (); + + protected: + template + friend class polymorphic_derived_object_statements; + + extra_statement_cache_ptr extra_statement_cache_; + + image_type image_; + + // Select binding. + // + std::size_t select_image_version_; + binding select_image_binding_; + bind select_image_bind_[select_column_count]; + bool select_image_truncated_[select_column_count]; + + // Insert binding. + // + std::size_t insert_image_version_; + binding insert_image_binding_; + bind insert_image_bind_[insert_column_count]; + + // Update binding. Note that the id suffix is bound to id_image_ + // below instead of image_ which makes this binding effectively + // bound to two images. As a result, we have to track versions + // for both of them. If this object uses optimistic concurrency, + // then the binding for the managed column (version, timestamp, + // etc) comes after the id and the image for such a column is + // stored as part of the id image. + // + std::size_t update_image_version_; + std::size_t update_id_image_version_; + binding update_image_binding_; + bind update_image_bind_[update_column_count + id_column_count + + managed_optimistic_column_count]; + + // Id image binding (only used as a parameter). Uses the suffix in + // the update bind. + // + id_image_type id_image_; + std::size_t id_image_version_; + binding id_image_binding_; + + // Extra data for objects with optimistic concurrency support. + // + optimistic_data od_; + + details::shared_ptr persist_; + details::shared_ptr find_; + details::shared_ptr update_; + details::shared_ptr erase_; + + // Delayed loading. + // + struct delayed_load + { + typedef typename pointer_cache_traits::position_type position_type; + + delayed_load () {} + delayed_load (const id_type& i, + object_type& o, + const position_type& p, + loader_function l) + : id (i), obj (&o), pos (p), loader (l) + { + } + + id_type id; + object_type* obj; + position_type pos; + loader_function loader; + }; + + typedef std::vector delayed_loads; + delayed_loads delayed_; + + // Delayed vectors swap guard. See the load_delayed_() function for + // details. + // + struct swap_guard + { + swap_guard (object_statements& os, delayed_loads& dl) + : os_ (os), dl_ (dl) + { + dl_.swap (os_.delayed_); + } + + ~swap_guard () + { + os_.clear_delayed (); + dl_.swap (os_.delayed_); + } + + private: + object_statements& os_; + delayed_loads& dl_; + }; + }; + } +} + +#include +#include + +#include + +#endif // ODB_SQLITE_SIMPLE_OBJECT_STATEMENTS_HXX diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/simple-object-statements.ixx b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/simple-object-statements.ixx new file mode 100755 index 0000000..5a7407d --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/simple-object-statements.ixx @@ -0,0 +1,69 @@ +// file : odb/sqlite/simple-object-statements.ixx +// copyright : Copyright (c) 2005-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +namespace odb +{ + namespace sqlite + { + // + // auto_unlock + // + inline object_statements_base::auto_unlock:: + auto_unlock (object_statements_base& s) + : s_ (s) + { + s_.unlock (); + } + + inline object_statements_base::auto_unlock:: + ~auto_unlock () + { + s_.lock (); + } + + // + // auto_lock + // + template + inline object_statements::auto_lock:: + auto_lock (object_statements& s) + : s_ (s) + { + if (!s_.locked ()) + { + s_.lock (); + locked_ = true; + } + else + locked_ = false; + } + + template + inline object_statements::auto_lock:: + ~auto_lock () + { + if (locked_) + { + s_.unlock (); + s_.clear_delayed (); + } + } + + template + inline bool object_statements::auto_lock:: + locked () const + { + return locked_; + } + + template + inline void object_statements::auto_lock:: + unlock () + { + assert (locked_); + s_.unlock (); + locked_ = false; + } + } +} diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/simple-object-statements.txx b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/simple-object-statements.txx new file mode 100755 index 0000000..fe46063 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/simple-object-statements.txx @@ -0,0 +1,147 @@ +// file : odb/sqlite/simple-object-statements.txx +// copyright : Copyright (c) 2005-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include // std::memset + +#include +#include + +#include +#include + +namespace odb +{ + namespace sqlite + { + // + // optimistic_data + // + + template + optimistic_data:: + optimistic_data (bind* b) + : id_image_binding_ ( + b, + object_traits::id_column_count + + object_traits::managed_optimistic_column_count) + { + } + + // + // object_statements + // + + template + object_statements:: + ~object_statements () + { + } + + template + object_statements:: + object_statements (connection_type& conn) + : object_statements_base (conn), + select_image_binding_ (select_image_bind_, select_column_count), + insert_image_binding_ (insert_image_bind_, insert_column_count), + update_image_binding_ (update_image_bind_, + update_column_count + id_column_count + + managed_optimistic_column_count), + id_image_binding_ (update_image_bind_ + update_column_count, + id_column_count), + od_ (update_image_bind_ + update_column_count) + { + image_.version = 0; + select_image_version_ = 0; + insert_image_version_ = 0; + update_image_version_ = 0; + update_id_image_version_ = 0; + + id_image_.version = 0; + id_image_version_ = 0; + + std::memset (insert_image_bind_, 0, sizeof (insert_image_bind_)); + std::memset (update_image_bind_, 0, sizeof (update_image_bind_)); + std::memset (select_image_bind_, 0, sizeof (select_image_bind_)); + std::memset ( + select_image_truncated_, 0, sizeof (select_image_truncated_)); + + for (std::size_t i (0); i < select_column_count; ++i) + select_image_bind_[i].truncated = select_image_truncated_ + i; + } + + template + template + void object_statements:: + load_delayed_ (const schema_version_migration* svm) + { + database& db (connection ().database ()); + + delayed_loads dls; + swap_guard sg (*this, dls); + + while (!dls.empty ()) + { + delayed_load l (dls.back ()); + typename pointer_cache_traits::insert_guard ig (l.pos); + dls.pop_back (); + + if (l.loader == 0) + { + object_traits_calls tc (svm); + + if (!tc.find_ (static_cast (*this), &l.id)) + throw object_not_persistent (); + + object_traits::callback (db, *l.obj, callback_event::pre_load); + + // Our calls to init/load below can result in additional delayed + // loads being added to the delayed_ vector. We need to process + // those before we call the post callback. + // + tc.init (*l.obj, image (), &db); + + // Load containers, etc. + // + tc.load_ (static_cast (*this), *l.obj, false); + + if (!delayed_.empty ()) + load_delayed_ (svm); + + // Temporarily unlock the statement for the post_load call so that + // it can load objects of this type recursively. This is safe to do + // because we have completely loaded the current object. Also the + // delayed_ list is clear before the unlock and should be clear on + // re-lock (since a callback can only call public API functions + // which will make sure all the delayed loads are processed before + // returning). + // + { + auto_unlock u (*this); + object_traits::callback (db, *l.obj, callback_event::post_load); + } + } + else + l.loader (db, l.id, *l.obj, svm); + + pointer_cache_traits::load (ig.position ()); + ig.release (); + } + } + + template + void object_statements:: + clear_delayed_ () + { + // Remove the objects from the session cache. + // + for (typename delayed_loads::iterator i (delayed_.begin ()), + e (delayed_.end ()); i != e; ++i) + { + pointer_cache_traits::erase (i->pos); + } + + delayed_.clear (); + } + } +} diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/sqlite-types.hxx b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/sqlite-types.hxx new file mode 100755 index 0000000..38376d9 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/sqlite-types.hxx @@ -0,0 +1,42 @@ +// file : odb/sqlite/sqlite-types.hxx +// copyright : Copyright (c) 2005-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_SQLITE_SQLITE_TYPES_HXX +#define ODB_SQLITE_SQLITE_TYPES_HXX + +#include + +#include // std::size_t + +namespace odb +{ + namespace sqlite + { + // The SQLite parameter/result binding. This data structures is modelled + // after MYSQL_BIND from MySQL. + // + struct bind + { + enum buffer_type + { + integer, // Buffer is long long; size, capacity, truncated are unused. + real, // Buffer is double; size, capacity, truncated are unused. + text, // Buffer is a UTF-8 char array. + text16, // Buffer is a UTF-16 2-byte char array (sizes in bytes). + blob // Buffer is a char array. + }; + + buffer_type type; + void* buffer; + std::size_t* size; + std::size_t capacity; + bool* is_null; + bool* truncated; + }; + } +} + +#include + +#endif // ODB_SQLITE_SQLITE_TYPES_HXX diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/statement-cache.cxx b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/statement-cache.cxx new file mode 100755 index 0000000..8723e42 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/statement-cache.cxx @@ -0,0 +1,40 @@ +// file : odb/sqlite/statement-cache.cxx +// copyright : Copyright (c) 2005-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include + +namespace odb +{ + using namespace details; + + namespace sqlite + { + statement_cache:: + statement_cache (connection& conn) + : conn_ (conn), + version_seq_ (conn.database ().schema_version_sequence ()), + // String lengths below include '\0', as per SQLite manual + // suggestions. + // + begin_ (new (shared) generic_statement (conn_, "BEGIN", 6)), + commit_ (new (shared) generic_statement (conn_, "COMMIT", 7)), + rollback_ (new (shared) generic_statement (conn_, "ROLLBACK", 9)) + { + } + + void statement_cache:: + begin_immediate_statement_ () const + { + begin_immediate_.reset ( + new (shared) generic_statement (conn_, "BEGIN IMMEDIATE", 16)); + } + + void statement_cache:: + begin_exclusive_statement_ () const + { + begin_exclusive_.reset ( + new (shared) generic_statement (conn_, "BEGIN EXCLUSIVE", 16)); + } + } +} diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/statement-cache.hxx b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/statement-cache.hxx new file mode 100755 index 0000000..f9ce7a1 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/statement-cache.hxx @@ -0,0 +1,109 @@ +// file : odb/sqlite/statement-cache.hxx +// copyright : Copyright (c) 2005-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_SQLITE_STATEMENT_CACHE_HXX +#define ODB_SQLITE_STATEMENT_CACHE_HXX + +#include + +#include +#include + +#include +#include + +#include +#include + +#include +#include +#include +#include + +#include + +namespace odb +{ + namespace sqlite + { + class LIBODB_SQLITE_EXPORT statement_cache + { + public: + statement_cache (connection&); + + generic_statement& + begin_statement () const + { + return *begin_; + } + + generic_statement& + begin_immediate_statement () const + { + if (!begin_immediate_) + begin_immediate_statement_ (); + + return *begin_immediate_; + } + + generic_statement& + begin_exclusive_statement () const + { + if (!begin_exclusive_) + begin_exclusive_statement_ (); + + return *begin_exclusive_; + } + + generic_statement& + commit_statement () const + { + return *commit_; + } + + generic_statement& + rollback_statement () const + { + return *rollback_; + } + + template + typename object_traits_impl::statements_type& + find_object (); + + template + view_statements& + find_view (); + + private: + void + begin_immediate_statement_ () const; + + void + begin_exclusive_statement_ () const; + + private: + typedef std::map, + details::type_info_comparator> map; + + connection& conn_; + unsigned int version_seq_; + + details::shared_ptr begin_; + mutable details::shared_ptr begin_immediate_; + mutable details::shared_ptr begin_exclusive_; + details::shared_ptr commit_; + details::shared_ptr rollback_; + + map map_; + }; + } +} + +#include + +#include + +#endif // ODB_SQLITE_STATEMENT_CACHE_HXX diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/statement-cache.txx b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/statement-cache.txx new file mode 100755 index 0000000..9f15a15 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/statement-cache.txx @@ -0,0 +1,61 @@ +// file : odb/sqlite/statement-cache.txx +// copyright : Copyright (c) 2005-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include + +namespace odb +{ + namespace sqlite + { + template + typename object_traits_impl::statements_type& + statement_cache:: + find_object () + { + typedef + typename object_traits_impl::statements_type + statements_type; + + // Clear the cache if the database version has changed. This + // makes sure we don't re-use statements that correspond to + // the old schema. + // + if (version_seq_ != conn_.database ().schema_version_sequence ()) + { + map_.clear (); + version_seq_ = conn_.database ().schema_version_sequence (); + } + + map::iterator i (map_.find (&typeid (T))); + + if (i != map_.end ()) + return static_cast (*i->second); + + details::shared_ptr p ( + new (details::shared) statements_type (conn_)); + + map_.insert (map::value_type (&typeid (T), p)); + return *p; + } + + template + view_statements& statement_cache:: + find_view () + { + // We don't cache any statements for views so no need to clear + // the cache. + + map::iterator i (map_.find (&typeid (T))); + + if (i != map_.end ()) + return static_cast&> (*i->second); + + details::shared_ptr > p ( + new (details::shared) view_statements (conn_)); + + map_.insert (map::value_type (&typeid (T), p)); + return *p; + } + } +} diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/statement.cxx b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/statement.cxx new file mode 100755 index 0000000..3bd5e4c --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/statement.cxx @@ -0,0 +1,846 @@ +// file : odb/sqlite/statement.cxx +// copyright : Copyright (c) 2005-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include +#include // object_not_persistent + +#include +#include +#include +#include + +#include // LIBODB_SQLITE_HAVE_UNLOCK_NOTIFY + +using namespace std; + +namespace odb +{ + namespace sqlite + { + // statement + // + + statement:: + ~statement () + { + if (stmt_ != 0) + { + { + odb::tracer* t; + if ((t = conn_.transaction_tracer ()) || + (t = conn_.tracer ()) || + (t = conn_.database ().tracer ())) + t->deallocate (conn_, *this); + } + + if (next_ != this) + list_remove (); + + stmt_.reset (); + } + } + + void statement:: + init (const char* text, + std::size_t text_size, + statement_kind sk, + const binding* proc, + bool optimize) + { + active_ = false; + prev_ = 0; + next_ = this; + + string tmp; + if (proc != 0) + { + switch (sk) + { + case statement_select: + process_select (text, + &proc->bind->buffer, proc->count, sizeof (bind), + '"', '"', + optimize, + tmp); + break; + case statement_insert: + process_insert (text, + &proc->bind->buffer, proc->count, sizeof (bind), + '?', + tmp); + break; + case statement_update: + process_update (text, + &proc->bind->buffer, proc->count, sizeof (bind), + '?', + tmp); + break; + case statement_delete: + case statement_generic: + assert (false); + } + + text = tmp.c_str (); + text_size = tmp.size (); + } + +#if SQLITE_VERSION_NUMBER < 3005003 + text_.assign (text, text_size); +#endif + + // Empty statement. + // + if (*text == '\0') + return; + + { + odb::tracer* t; + if ((t = conn_.transaction_tracer ()) || + (t = conn_.tracer ()) || + (t = conn_.database ().tracer ())) + { + // Temporarily store the statement text in prev_ so that + // text() which may be called by the tracer can access it. + // +#if SQLITE_VERSION_NUMBER >= 3005003 + prev_ = reinterpret_cast (const_cast (text)); +#endif + t->prepare (conn_, *this); +#if SQLITE_VERSION_NUMBER >= 3005003 + prev_ = 0; +#endif + } + } + + int e; + sqlite3_stmt* stmt (0); + + // sqlite3_prepare_v2() is only available since SQLite 3.3.9 + // but is buggy until 3.3.11. + // +#if SQLITE_VERSION_NUMBER >= 3003011 + while ((e = sqlite3_prepare_v2 (conn_.handle (), + text, + static_cast (text_size), + &stmt, + 0)) == SQLITE_LOCKED) + { + conn_.wait (); + } +#else + e = sqlite3_prepare (conn_.handle (), + text, + static_cast (text_size), + &stmt, + 0); +#endif + + if (e != SQLITE_OK) + translate_error (e, conn_); + + stmt_.reset (stmt); + } + + const char* statement:: + text () const + { + // sqlite3_sql() is only available since 3.5.3. + // +#if SQLITE_VERSION_NUMBER >= 3005003 + if (stmt_ == 0) + // See init() above for details on what's going on here. + // + return prev_ != 0 ? reinterpret_cast (prev_) : ""; + else + return sqlite3_sql (stmt_); +#else + return text_.c_str (); +#endif + } + + void statement:: + bind_param (const bind* p, size_t n) + { + int e (SQLITE_OK); + + // SQLite parameters are counted from 1. + // + for (size_t i (0), j (1); e == SQLITE_OK && i < n; ++i) + { + const bind& b (p[i]); + + if (b.buffer == 0) // Skip NULL entries. + continue; + + int c (static_cast (j++)); + + if (b.is_null != 0 && *b.is_null) + { + e = sqlite3_bind_null (stmt_, c); + continue; + } + + switch (b.type) + { + case bind::integer: + { + long long v (*static_cast (b.buffer)); + + e = sqlite3_bind_int64 (stmt_, + c, + // Prior to 3.5.0, sqlite3_int64 was called sqlite_int64. +#if SQLITE_VERSION_NUMBER >= 3005000 + static_cast (v) +#else + static_cast (v) +#endif + ); + break; + } + case bind::real: + { + double v (*static_cast (b.buffer)); + e = sqlite3_bind_double (stmt_, c, v); + break; + } + case bind::text: + { + e = sqlite3_bind_text (stmt_, + c, + static_cast (b.buffer), + static_cast (*b.size), + SQLITE_STATIC); + break; + } + case bind::text16: + { + e = sqlite3_bind_text16 (stmt_, + c, + b.buffer, + static_cast (*b.size), + SQLITE_STATIC); + break; + } + case bind::blob: + { + e = sqlite3_bind_blob (stmt_, + c, + b.buffer, + static_cast (*b.size), + SQLITE_STATIC); + break; + } + } + } + + if (e != SQLITE_OK) + translate_error (e, conn_); + } + + bool statement:: + bind_result (const bind* p, size_t count, bool truncated) + { + bool r (true); + int col_count (sqlite3_data_count (stmt_)); + + int col (0); + for (size_t i (0); i != count && col != col_count; ++i) + { + const bind& b (p[i]); + + if (b.buffer == 0) // Skip NULL entries. + continue; + + int c (col++); + + if (truncated && (b.truncated == 0 || !*b.truncated)) + continue; + + if (b.truncated != 0) + *b.truncated = false; + + // Check for NULL unless we are reloading a truncated result. + // + if (!truncated) + { + *b.is_null = sqlite3_column_type (stmt_, c) == SQLITE_NULL; + + if (*b.is_null) + continue; + } + + switch (b.type) + { + case bind::integer: + { + *static_cast (b.buffer) = + static_cast (sqlite3_column_int64 (stmt_, c)); + break; + } + case bind::real: + { + *static_cast (b.buffer) = + sqlite3_column_double (stmt_, c); + break; + } + case bind::text: + case bind::text16: + case bind::blob: + { + // SQLite documentation recommends that we first call *_text(), + // *_text16(), or *_blob() function in order to force the type + // conversion, if any. + // + const void* d; + + if (b.type != bind::text16) + { + d = b.type == bind::text + ? sqlite3_column_text (stmt_, c) + : sqlite3_column_blob (stmt_, c); + *b.size = static_cast (sqlite3_column_bytes (stmt_, c)); + } + else + { + d = sqlite3_column_text16 (stmt_, c); + *b.size = static_cast ( + sqlite3_column_bytes16 (stmt_, c)); + } + + if (*b.size > b.capacity) + { + if (b.truncated != 0) + *b.truncated = true; + + r = false; + continue; + } + + memcpy (b.buffer, d, *b.size); + break; + } + } + } + + // Make sure that the number of columns in the result returned by + // the database matches the number that we expect. A common cause + // of this assertion is a native view with a number of data members + // not matching the number of columns in the SELECT-list. + // + assert (col == col_count); + + return r; + } + + // generic_statement + // + + generic_statement:: + generic_statement (connection_type& conn, const string& text) + : statement (conn, + text, statement_generic, + 0, false), + result_set_ (stmt_ ? sqlite3_column_count (stmt_) != 0: false) + { + } + + generic_statement:: + generic_statement (connection_type& conn, const char* text) + : statement (conn, + text, statement_generic, + 0, false), + result_set_ (stmt_ ? sqlite3_column_count (stmt_) != 0: false) + { + } + + generic_statement:: + generic_statement (connection_type& conn, + const char* text, + std::size_t text_size) + : statement (conn, + text, text_size, statement_generic, + 0, false), + result_set_ (stmt_ ? sqlite3_column_count (stmt_) != 0: false) + { + } + + unsigned long long generic_statement:: + execute () + { + if (stmt_ == 0) // Empty statement or comment. + return 0; + + { + odb::tracer* t; + if ((t = conn_.transaction_tracer ()) || + (t = conn_.tracer ()) || + (t = conn_.database ().tracer ())) + t->execute (conn_, *this); + } + + unsigned long long r (0); + + int e; + sqlite3* h (conn_.handle ()); + +#ifdef LIBODB_SQLITE_HAVE_UNLOCK_NOTIFY + // Only the first call to sqlite3_step() can return SQLITE_LOCKED. + // + while ((e = sqlite3_step (stmt_)) == SQLITE_LOCKED) + { + if (sqlite3_extended_errcode (h) != SQLITE_LOCKED_SHAREDCACHE) + break; + + sqlite3_reset (stmt_); + conn_.wait (); + } +#else + e = sqlite3_step (stmt_); +#endif + + for (; e == SQLITE_ROW; e = sqlite3_step (stmt_)) + r++; + + // sqlite3_step() will return a detailed error code only if we used + // sqlite3_prepare_v2(). Otherwise, sqlite3_reset() returns the + // error. + // +#if SQLITE_VERSION_NUMBER >= 3003011 + sqlite3_reset (stmt_); + + if (e != SQLITE_DONE) + translate_error (e, conn_); +#else + e = sqlite3_reset (stmt_); + + if (e != SQLITE_OK) + { + // If the schema has changed, try to re-prepare and re-execute the + // statement. That's what newer versions of SQLite do automatically. + // + if (e == SQLITE_SCHEMA) + { + sqlite3_stmt* stmt (0); + e = sqlite3_prepare (h, + text_.c_str (), + static_cast (text_.size () + 1), + &stmt, + 0); + + if (e != SQLITE_OK) + translate_error (e, conn_); + + stmt_.reset (stmt); + return execute (); // Try again by recursively calling ourselves. + } + else + translate_error (e, conn_); + } +#endif + + if (!result_set_) + r = static_cast (sqlite3_changes (h)); + + return r; + } + + // select_statement + // + + select_statement:: + select_statement (connection_type& conn, + const string& text, + bool process, + bool optimize, + binding& param, + binding& result) + : statement (conn, + text, statement_select, + (process ? &result : 0), optimize), + param_ (¶m), + result_ (result) + { + } + + select_statement:: + select_statement (connection_type& conn, + const char* text, + bool process, + bool optimize, + binding& param, + binding& result) + : statement (conn, + text, statement_select, + (process ? &result : 0), optimize), + param_ (¶m), + result_ (result) + { + } + + select_statement:: + select_statement (connection_type& conn, + const string& text, + bool process, + bool optimize, + binding& result) + : statement (conn, + text, statement_select, + (process ? &result : 0), optimize), + param_ (0), + result_ (result) + { + } + + select_statement:: + select_statement (connection_type& conn, + const char* text, + bool process, + bool optimize, + binding& result) + : statement (conn, + text, statement_select, + (process ? &result : 0), optimize), + param_ (0), + result_ (result) + { + } + + void select_statement:: + execute () + { + if (active ()) + reset (); + + { + odb::tracer* t; + if ((t = conn_.transaction_tracer ()) || + (t = conn_.tracer ()) || + (t = conn_.database ().tracer ())) + t->execute (conn_, *this); + } + + done_ = false; + + if (param_ != 0) + bind_param (param_->bind, param_->count); + + active (true); + } + + void select_statement:: + free_result () + { + reset (); + done_ = true; + } + + bool select_statement:: + next () + { + if (!done_) + { + int e; + +#ifdef LIBODB_SQLITE_HAVE_UNLOCK_NOTIFY + sqlite3* h (conn_.handle ()); + while ((e = sqlite3_step (stmt_)) == SQLITE_LOCKED) + { + if (sqlite3_extended_errcode (h) != SQLITE_LOCKED_SHAREDCACHE) + break; + + sqlite3_reset (stmt_); + conn_.wait (); + } +#else + e = sqlite3_step (stmt_); +#endif + + if (e != SQLITE_ROW) + { + done_ = true; + + // sqlite3_step() will return a detailed error code only if we used + // sqlite3_prepare_v2(). Otherwise, sqlite3_reset() returns the + // error. + // +#if SQLITE_VERSION_NUMBER >= 3003011 + reset (); + + if (e != SQLITE_DONE) +#else + e = reset (); + + if (e != SQLITE_OK) +#endif + translate_error (e, conn_); + } + } + + return !done_; + } + + select_statement::result select_statement:: + load () + { + if (done_) + return no_data; + + return bind_result (result_.bind, result_.count) ? success : truncated; + } + + void select_statement:: + reload () + { + assert (!done_); + + if (!bind_result (result_.bind, result_.count, true)) + assert (false); + } + + // insert_statement + // + + insert_statement:: + insert_statement (connection_type& conn, + const string& text, + bool process, + binding& param, + binding* returning) + : statement (conn, + text, statement_insert, + (process ? ¶m : 0), false), + param_ (param), + returning_ (returning) + { + } + + insert_statement:: + insert_statement (connection_type& conn, + const char* text, + bool process, + binding& param, + binding* returning) + : statement (conn, + text, statement_insert, + (process ? ¶m : 0), false), + param_ (param), + returning_ (returning) + { + } + + bool insert_statement:: + execute () + { + { + odb::tracer* t; + if ((t = conn_.transaction_tracer ()) || + (t = conn_.tracer ()) || + (t = conn_.database ().tracer ())) + t->execute (conn_, *this); + } + + bind_param (param_.bind, param_.count); + + int e; + +#ifdef LIBODB_SQLITE_HAVE_UNLOCK_NOTIFY + sqlite3* h (conn_.handle ()); + while ((e = sqlite3_step (stmt_)) == SQLITE_LOCKED) + { + if (sqlite3_extended_errcode (h) != SQLITE_LOCKED_SHAREDCACHE) + break; + + sqlite3_reset (stmt_); + conn_.wait (); + } +#else + e = sqlite3_step (stmt_); +#endif + + // sqlite3_step() will return a detailed error code only if we used + // sqlite3_prepare_v2(). Otherwise, sqlite3_reset() returns the + // error. + // +#if SQLITE_VERSION_NUMBER >= 3003011 + sqlite3_reset (stmt_); + + if (e != SQLITE_DONE) +#else + e = sqlite3_reset (stmt_); + + if (e != SQLITE_OK) +#endif + { + // SQLITE_CONSTRAINT error code covers more than just a duplicate + // primary key. Unfortunately, there is nothing more precise that + // we can use (even sqlite3_errmsg() returns generic "constraint + // failed"). But an auto-assigned object id should never cause a + // duplicate primary key. + // + if (returning_ == 0 && e == SQLITE_CONSTRAINT) + return false; + else + translate_error (e, conn_); + } + + if (returning_ != 0) + { + bind& b (returning_->bind[0]); + + *b.is_null = false; + *static_cast (b.buffer) = + static_cast ( + sqlite3_last_insert_rowid (conn_.handle ())); + } + + return true; + } + + // update_statement + // + + update_statement:: + update_statement (connection_type& conn, + const string& text, + bool process, + binding& param) + : statement (conn, + text, statement_update, + (process ? ¶m : 0), false), + param_ (param) + { + } + + update_statement:: + update_statement (connection_type& conn, + const char* text, + bool process, + binding& param) + : statement (conn, + text, statement_update, + (process ? ¶m : 0), false), + param_ (param) + { + } + + unsigned long long update_statement:: + execute () + { + { + odb::tracer* t; + if ((t = conn_.transaction_tracer ()) || + (t = conn_.tracer ()) || + (t = conn_.database ().tracer ())) + t->execute (conn_, *this); + } + + bind_param (param_.bind, param_.count); + + int e; + sqlite3* h (conn_.handle ()); + +#ifdef LIBODB_SQLITE_HAVE_UNLOCK_NOTIFY + while ((e = sqlite3_step (stmt_)) == SQLITE_LOCKED) + { + if (sqlite3_extended_errcode (h) != SQLITE_LOCKED_SHAREDCACHE) + break; + + sqlite3_reset (stmt_); + conn_.wait (); + } +#else + e = sqlite3_step (stmt_); +#endif + + // sqlite3_step() will return a detailed error code only if we used + // sqlite3_prepare_v2(). Otherwise, sqlite3_reset() returns the + // error. + // +#if SQLITE_VERSION_NUMBER >= 3003011 + sqlite3_reset (stmt_); + + if (e != SQLITE_DONE) +#else + e = sqlite3_reset (stmt_); + + if (e != SQLITE_OK) +#endif + translate_error (e, conn_); + + return static_cast (sqlite3_changes (h)); + } + + // delete_statement + // + + delete_statement:: + delete_statement (connection_type& conn, + const string& text, + binding& param) + : statement (conn, + text, statement_delete, + 0, false), + param_ (param) + { + } + + delete_statement:: + delete_statement (connection_type& conn, + const char* text, + binding& param) + : statement (conn, + text, statement_delete, + 0, false), + param_ (param) + { + } + + unsigned long long delete_statement:: + execute () + { + { + odb::tracer* t; + if ((t = conn_.transaction_tracer ()) || + (t = conn_.tracer ()) || + (t = conn_.database ().tracer ())) + t->execute (conn_, *this); + } + + bind_param (param_.bind, param_.count); + + int e; + sqlite3* h (conn_.handle ()); + +#ifdef LIBODB_SQLITE_HAVE_UNLOCK_NOTIFY + while ((e = sqlite3_step (stmt_)) == SQLITE_LOCKED) + { + if (sqlite3_extended_errcode (h) != SQLITE_LOCKED_SHAREDCACHE) + break; + + sqlite3_reset (stmt_); + conn_.wait (); + } +#else + e = sqlite3_step (stmt_); +#endif + + // sqlite3_step() will return a detailed error code only if we used + // sqlite3_prepare_v2(). Otherwise, sqlite3_reset() returns the + // error. + // +#if SQLITE_VERSION_NUMBER >= 3003011 + sqlite3_reset (stmt_); + + if (e != SQLITE_DONE) +#else + e = sqlite3_reset (stmt_); + + if (e != SQLITE_OK) +#endif + translate_error (e, conn_); + + return static_cast (sqlite3_changes (h)); + } + } +} diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/statement.hxx b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/statement.hxx new file mode 100755 index 0000000..1be0cab --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/statement.hxx @@ -0,0 +1,405 @@ +// file : odb/sqlite/statement.hxx +// copyright : Copyright (c) 2005-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_SQLITE_STATEMENT_HXX +#define ODB_SQLITE_STATEMENT_HXX + +#include + +#include + +#include +#include // std::size_t +#include // std::strlen, std::memcpy +#include + +#include + +#include +#include +#include +#include +#include + +#include + +namespace odb +{ + namespace sqlite + { + class connection; + + class LIBODB_SQLITE_EXPORT statement: public odb::statement + { + public: + typedef sqlite::connection connection_type; + + virtual + ~statement () = 0; + + sqlite3_stmt* + handle () const + { + return stmt_; + } + + virtual const char* + text () const; + + virtual connection_type& + connection () + { + return conn_; + } + + // A statement can be empty. This is used to handle situations + // where a SELECT or UPDATE statement ends up not having any + // columns after processing. An empty statement cannot be + // executed. + // + bool + empty () const + { + return stmt_ == 0; + } + + protected: + // We keep two versions to take advantage of std::string COW. + // + statement (connection_type& conn, + const std::string& text, + statement_kind sk, + const binding* process, + bool optimize) + : conn_ (conn) + { + init (text.c_str (), text.size (), sk, process, optimize); + } + + statement (connection_type& conn, + const char* text, + statement_kind sk, + const binding* process, + bool optimize) + : conn_ (conn) + { + init (text, std::strlen (text), sk, process, optimize); + } + + statement (connection_type& conn, + const char* text, + std::size_t text_size, + statement_kind sk, + const binding* process, + bool optimize) + : conn_ (conn) + { + init (text, text_size, sk, process, optimize); + } + + protected: + void + bind_param (const bind*, std::size_t count); + + // Extract row columns into the bound buffers. If the truncated + // argument is true, then only truncated columns are extracted. + // Return true if all the data was extracted successfully and + // false if one or more columns were truncated. + // + bool + bind_result (const bind*, std::size_t count, bool truncated = false); + + // Active state. + // + protected: + bool + active () const + { + return active_; + } + + void + active (bool active) + { + assert (active); + + if (!active_) + { + list_add (); + active_ = true; + } + } + + int + reset () + { + int r (SQLITE_OK); + + if (active_) + { + r = sqlite3_reset (stmt_); + list_remove (); + active_ = false; + } + + return r; + } + + protected: + friend class sqlite::connection; + + connection_type& conn_; + auto_handle stmt_; + +#if SQLITE_VERSION_NUMBER < 3005003 + std::string text_; +#endif + + bool active_; + + private: + void + init (const char* text, + std::size_t text_size, + statement_kind, + const binding* process, + bool optimize); + + // Doubly-linked list of active statements. + // + protected: + void + list_add () + { + next_ = conn_.statements_; + conn_.statements_ = this; + + if (next_ != 0) + next_->prev_ = this; + } + + void + list_remove () + { + (prev_ == 0 ? conn_.statements_ : prev_->next_) = next_; + + if (next_ != 0) + next_->prev_ = prev_; + + prev_ = 0; + next_ = this; + } + + // prev_ == 0 means we are the first element. + // next_ == 0 means we are the last element. + // next_ == this means we are not on the list (prev_ should be 0). + // + statement* prev_; + statement* next_; + }; + + class LIBODB_SQLITE_EXPORT generic_statement: public statement + { + public: + generic_statement (connection_type&, const std::string& text); + generic_statement (connection_type&, const char* text); + generic_statement (connection_type&, + const char* text, + std::size_t text_size); + + unsigned long long + execute (); + + private: + generic_statement (const generic_statement&); + generic_statement& operator= (const generic_statement&); + + private: + bool result_set_; + }; + + class LIBODB_SQLITE_EXPORT select_statement: public statement + { + public: + select_statement (connection_type& conn, + const std::string& text, + bool process_text, + bool optimize_text, + binding& param, + binding& result); + + select_statement (connection_type& conn, + const char* text, + bool process_text, + bool optimize_text, + binding& param, + binding& result); + + select_statement (connection_type& conn, + const std::string& text, + bool process_text, + bool optimize_text, + binding& result); + + select_statement (connection_type& conn, + const char* text, + bool process_text, + bool optimize_text, + binding& result); + + // Common select interface expected by the generated code. + // + public: + enum result + { + success, + no_data, + truncated + }; + + void + execute (); + + // Load next row columns into bound buffers. + // + result + fetch () + { + return next () ? load () : no_data; + } + + // Reload truncated columns into bound buffers. + // + void + refetch () + { + reload (); + } + + // Free the result set. + // + void + free_result (); + + // More fine-grained SQLite-specific interface that splits fetch() + // into next() and load(). + // + public: + // Return false if there is no more rows. You should call next() + // until it returns false or, alternatively, call free_result (). + // Otherwise the statement will remain unfinished. + // + bool + next (); + + result + load (); + + void + reload (); + + private: + select_statement (const select_statement&); + select_statement& operator= (const select_statement&); + + private: + bool done_; + binding* param_; + binding& result_; + }; + + struct LIBODB_SQLITE_EXPORT auto_result + { + explicit auto_result (select_statement& s): s_ (s) {} + ~auto_result () {s_.free_result ();} + + private: + auto_result (const auto_result&); + auto_result& operator= (const auto_result&); + + private: + select_statement& s_; + }; + + class LIBODB_SQLITE_EXPORT insert_statement: public statement + { + public: + insert_statement (connection_type& conn, + const std::string& text, + bool process_text, + binding& param, + binding* returning); + + insert_statement (connection_type& conn, + const char* text, + bool process_text, + binding& param, + binding* returning); + + // Return true if successful and false if the row is a duplicate. + // All other errors are reported by throwing exceptions. + // + bool + execute (); + + private: + insert_statement (const insert_statement&); + insert_statement& operator= (const insert_statement&); + + private: + binding& param_; + binding* returning_; + }; + + class LIBODB_SQLITE_EXPORT update_statement: public statement + { + public: + update_statement (connection_type& conn, + const std::string& text, + bool process_text, + binding& param); + + update_statement (connection_type& conn, + const char* text, + bool process_text, + binding& param); + + unsigned long long + execute (); + + private: + update_statement (const update_statement&); + update_statement& operator= (const update_statement&); + + private: + binding& param_; + }; + + class LIBODB_SQLITE_EXPORT delete_statement: public statement + { + public: + delete_statement (connection_type& conn, + const std::string& text, + binding& param); + + delete_statement (connection_type& conn, + const char* text, + binding& param); + + unsigned long long + execute (); + + private: + delete_statement (const delete_statement&); + delete_statement& operator= (const delete_statement&); + + private: + binding& param_; + }; + } +} + +#include + +#endif // ODB_SQLITE_STATEMENT_HXX diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/statements-base.cxx b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/statements-base.cxx new file mode 100755 index 0000000..4a5aa6e --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/statements-base.cxx @@ -0,0 +1,16 @@ +// file : odb/sqlite/statements-base.cxx +// copyright : Copyright (c) 2005-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include + +namespace odb +{ + namespace sqlite + { + statements_base:: + ~statements_base () + { + } + } +} diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/statements-base.hxx b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/statements-base.hxx new file mode 100755 index 0000000..6ed5813 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/statements-base.hxx @@ -0,0 +1,64 @@ +// file : odb/sqlite/statements-base.hxx +// copyright : Copyright (c) 2005-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_SQLITE_STATEMENTS_BASE_HXX +#define ODB_SQLITE_STATEMENTS_BASE_HXX + +#include + +#include +#include + +#include +#include +#include + +#include + +namespace odb +{ + namespace sqlite + { + class LIBODB_SQLITE_EXPORT statements_base: public details::shared_base + { + public: + typedef sqlite::connection connection_type; + + connection_type& + connection () + { + return conn_; + } + + // Schema version. database::schema_version_migration() is thread- + // safe which means it is also slow. Cache the result in statements + // so we can avoid the mutex lock. This is thread-safe since if the + // version is updated, then the statements cache will be expired. + // + const schema_version_migration& + version_migration (const char* name = "") const + { + if (svm_ == 0) + svm_ = &conn_.database ().schema_version_migration (name); + + return *svm_; + } + + public: + virtual + ~statements_base (); + + protected: + statements_base (connection_type& conn): conn_ (conn), svm_ (0) {} + + protected: + connection_type& conn_; + mutable const schema_version_migration* svm_; + }; + } +} + +#include + +#endif // ODB_SQLITE_STATEMENTS_BASE_HXX diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/tracer.cxx b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/tracer.cxx new file mode 100755 index 0000000..10ce0b0 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/tracer.cxx @@ -0,0 +1,61 @@ +// file : odb/sqlite/tracer.cxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include +#include +#include + +namespace odb +{ + namespace sqlite + { + tracer:: + ~tracer () + { + } + + void tracer:: + prepare (connection&, const statement&) + { + } + + void tracer:: + execute (connection& c, const statement& s) + { + execute (c, s.text ()); + } + + void tracer:: + deallocate (connection&, const statement&) + { + } + + void tracer:: + prepare (odb::connection& c, const odb::statement& s) + { + prepare (static_cast (c), + static_cast (s)); + } + + void tracer:: + execute (odb::connection& c, const odb::statement& s) + { + execute (static_cast (c), + static_cast (s)); + } + + void tracer:: + execute (odb::connection& c, const char* s) + { + execute (static_cast (c), s); + } + + void tracer:: + deallocate (odb::connection& c, const odb::statement& s) + { + deallocate (static_cast (c), + static_cast (s)); + } + } +} diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/tracer.hxx b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/tracer.hxx new file mode 100755 index 0000000..023ac6b --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/tracer.hxx @@ -0,0 +1,62 @@ +// file : odb/sqlite/tracer.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_SQLITE_TRACER_HXX +#define ODB_SQLITE_TRACER_HXX + +#include + +#include + +#include +#include +#include + +namespace odb +{ + namespace sqlite + { + class LIBODB_SQLITE_EXPORT tracer: private odb::tracer + { + public: + virtual + ~tracer (); + + virtual void + prepare (connection&, const statement&); + + virtual void + execute (connection&, const statement&); + + virtual void + execute (connection&, const char* statement) = 0; + + virtual void + deallocate (connection&, const statement&); + + private: + // Allow these classes to convert sqlite::tracer to odb::tracer. + // + friend class database; + friend class connection; + friend class transaction; + + virtual void + prepare (odb::connection&, const odb::statement&); + + virtual void + execute (odb::connection&, const odb::statement&); + + virtual void + execute (odb::connection&, const char* statement); + + virtual void + deallocate (odb::connection&, const odb::statement&); + }; + } +} + +#include + +#endif // ODB_SQLITE_TRACER_HXX diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/traits-calls.hxx b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/traits-calls.hxx new file mode 100755 index 0000000..d1fb72f --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/traits-calls.hxx @@ -0,0 +1,215 @@ +// file : odb/sqlite/traits-calls.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_SQLITE_TRAITS_CALLS_HXX +#define ODB_SQLITE_TRAITS_CALLS_HXX + +#include + +#include // std::size_t + +#include +#include +#include + +#include +#include + +namespace odb +{ + namespace sqlite + { + // + // object_traits_calls + // + + template ::versioned> + struct object_traits_calls; + + template + struct object_traits_calls + { + typedef object_traits_impl traits; + typedef typename traits::image_type image_type; + typedef sqlite::bind bind_type; + + object_traits_calls (const schema_version_migration*) {} + + const schema_version_migration* + version () const {return 0;} + + static bool + grow (image_type& i, bool* t) + { + return traits::grow (i, t); + } + + static void + bind (bind_type* b, image_type& i, statement_kind sk) + { + traits::bind (b, i, sk); + } + + // Poly-derived version. + // + static void + bind (bind_type* b, + const bind_type* id, std::size_t id_size, + image_type& i, + statement_kind sk) + { + traits::bind (b, id, id_size, i, sk); + } + + static void + init (T& o, const image_type& i, odb::database* db) + { + traits::init (o, i, db); + } + + static bool + find_ (typename traits::statements_type& sts, + const typename traits::id_type* id) + { + return traits::find_ (sts, id); + } + + static void + load_ (typename traits::statements_type& sts, T& o, bool reload) + { + return traits::load_ (sts, o, reload); + } + }; + + template + struct object_traits_calls + { + typedef object_traits_impl traits; + typedef typename traits::image_type image_type; + typedef sqlite::bind bind_type; + + object_traits_calls (const schema_version_migration* svm): svm_ (*svm) {} + + const schema_version_migration* + version () const {return &svm_;} + + bool + grow (image_type& i, bool* t) const + { + return traits::grow (i, t, svm_); + } + + void + bind (bind_type* b, image_type& i, statement_kind sk) const + { + traits::bind (b, i, sk, svm_); + } + + // Poly-derived version. + // + void + bind (bind_type* b, + const bind_type* id, std::size_t id_size, + image_type& i, + statement_kind sk) const + { + traits::bind (b, id, id_size, i, sk, svm_); + } + + void + init (T& o, const image_type& i, odb::database* db) const + { + traits::init (o, i, db, svm_); + } + + bool + find_ (typename traits::statements_type& sts, + const typename traits::id_type* id) const + { + return traits::find_ (sts, id, svm_); + } + + void + load_ (typename traits::statements_type& sts, T& o, bool reload) const + { + return traits::load_ (sts, o, reload, svm_); + } + + private: + const schema_version_migration& svm_; + }; + + // + // view_traits_calls + // + + template ::versioned> + struct view_traits_calls; + + template + struct view_traits_calls + { + typedef view_traits_impl traits; + typedef typename traits::image_type image_type; + typedef sqlite::bind bind_type; + + view_traits_calls (const schema_version_migration*) {} + + static bool + grow (image_type& i, bool* t) + { + return traits::grow (i, t); + } + + static void + bind (bind_type* b, image_type& i) + { + traits::bind (b, i); + } + + static void + init (T& o, const image_type& i, odb::database* db) + { + traits::init (o, i, db); + } + }; + + template + struct view_traits_calls + { + typedef view_traits_impl traits; + typedef typename traits::image_type image_type; + typedef sqlite::bind bind_type; + + view_traits_calls (const schema_version_migration* svm): svm_ (*svm) {} + + bool + grow (image_type& i, bool* t) const + { + return traits::grow (i, t, svm_); + } + + void + bind (bind_type* b, image_type& i) const + { + traits::bind (b, i, svm_); + } + + void + init (T& o, const image_type& i, odb::database* db) const + { + traits::init (o, i, db, svm_); + } + + private: + const schema_version_migration& svm_; + }; + } +} + +#include + +#endif // ODB_SQLITE_TRAITS_CALLS_HXX diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/traits.cxx b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/traits.cxx new file mode 100755 index 0000000..9258d5b --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/traits.cxx @@ -0,0 +1,220 @@ +// file : odb/sqlite/traits.cxx +// copyright : Copyright (c) 2005-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include + +using namespace std; + +namespace odb +{ + namespace sqlite + { + using details::buffer; + + // + // default_value_traits + // + void default_value_traits:: + set_image (buffer& b, size_t& n, bool& is_null, const string& v) + { + is_null = false; + n = v.size (); + + if (n > b.capacity ()) + b.capacity (n); + + if (n != 0) + memcpy (b.data (), v.c_str (), n); + } + + // + // c_string_value_traits + // + void c_string_value_traits:: + set_image (buffer& b, size_t& n, bool& is_null, const char* v) + { + is_null = false; + n = strlen (v); + + if (n > b.capacity ()) + b.capacity (n); + + if (n != 0) + memcpy (b.data (), v, n); + } + + // + // c_array_value_traits_base + // + void c_array_value_traits_base:: + set_value (char* const& v, + const details::buffer& b, + size_t n, + bool is_null, + size_t N) + { + if (!is_null) + { + n = n < N ? n : N; + + if (n != 0) + memcpy (v, b.data (), n); + } + else + n = 0; + + if (n != N) // Append '\0' if there is space. + v[n] = '\0'; + } + + void c_array_value_traits_base:: + set_image (details::buffer& b, + size_t& n, + bool& is_null, + const char* v, + size_t N) + { + is_null = false; + + // Figure out the length. We cannot use strlen since it may + // not be 0-terminated (strnlen is not standard). + // + for (n = 0; n != N && v[n] != '\0'; ++n) ; + + if (n > b.capacity ()) + b.capacity (n); + + if (n != 0) + memcpy (b.data (), v, n); + } + + // + // default_value_traits + // +#ifdef _WIN32 + void default_value_traits:: + set_image (buffer& b, size_t& n, bool& is_null, const wstring& v) + { + is_null = false; + n = v.size () * 2; + + if (n > b.capacity ()) + b.capacity (n); + + if (n != 0) + memcpy (b.data (), v.c_str (), n); + } + + // + // c_wstring_value_traits + // + void c_wstring_value_traits:: + set_image (buffer& b, size_t& n, bool& is_null, const wchar_t* v) + { + is_null = false; + n = wcslen (v) * 2; + + if (n > b.capacity ()) + b.capacity (n); + + if (n != 0) + memcpy (b.data (), v, n); + } + + // + // c_warray_value_traits_base + // + void c_warray_value_traits_base:: + set_value (wchar_t* const& v, + const details::buffer& b, + size_t n, + bool is_null, + size_t N) + { + if (!is_null) + { + n /= 2; + n = n < N ? n : N; + + if (n != 0) + memcpy (v, b.data (), n * sizeof (wchar_t)); + } + else + n = 0; + + if (n != N) // Append '\0' if there is space. + v[n] = L'\0'; + } + + void c_warray_value_traits_base:: + set_image (details::buffer& b, + size_t& n, + bool& is_null, + const wchar_t* v, + size_t N) + { + is_null = false; + + // Figure out the length. We cannot use wcslen since it may + // not be 0-terminated (wcsnlen is not standard). + // + for (n = 0; n != N && v[n] != L'\0'; ++n) ; + + n *= 2; + + if (n > b.capacity ()) + b.capacity (n); + + if (n != 0) + memcpy (b.data (), v, n); + } +#endif // _WIN32 + + // + // default_value_traits, id_blob> + // + // std::vector has to be qualified for Sun CC. + // + void default_value_traits, id_blob>:: + set_image (details::buffer& b, + size_t& n, + bool& is_null, + const value_type& v) + { + is_null = false; + n = v.size (); + + if (n > b.capacity ()) + b.capacity (n); + + // std::vector::data() may not be available in older compilers. + // + if (n != 0) + memcpy (b.data (), &v.front (), n); + } + + // + // default_value_traits, id_blob> + // + // std::vector has to be qualified for Sun CC. + // + void default_value_traits, id_blob>:: + set_image (details::buffer& b, + size_t& n, + bool& is_null, + const value_type& v) + { + is_null = false; + n = v.size (); + + if (n > b.capacity ()) + b.capacity (n); + + // std::vector::data() may not be available in older compilers. + // + if (n != 0) + memcpy (b.data (), &v.front (), n); + } + } +} diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/traits.hxx b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/traits.hxx new file mode 100755 index 0000000..de8e3c3 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/traits.hxx @@ -0,0 +1,978 @@ +// file : odb/sqlite/traits.hxx +// copyright : Copyright (c) 2005-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_SQLITE_TRAITS_HXX +#define ODB_SQLITE_TRAITS_HXX + +#include + +#include // ODB_CXX11 + +#include +#include +#include // std::numeric_limits +#include // std::size_t +#include // std::memcpy, std::memset, std::strlen + +#ifdef ODB_CXX11 +# include +#endif + +#include +#include + +#include +#include + +#include +#include +#include + +namespace odb +{ + namespace sqlite + { + enum database_type_id + { + id_integer, + id_real, + id_text, + id_blob + }; + + // + // image_traits + // + + template + struct image_traits; + + template + struct image_traits {typedef long long image_type;}; + + template + struct image_traits {typedef double image_type;}; + + template + struct image_traits + { + typedef details::buffer image_type; + + // By default the text is in UTF-8. + // + static const bind::buffer_type bind_value = bind::text; + }; + + template + struct image_traits {typedef details::buffer image_type;}; + + // + // value_traits + // + + template + struct wrapped_value_traits; + + template + struct default_value_traits; + + template ::r> + struct select_traits; + + template + struct select_traits + { + typedef default_value_traits type; + }; + + template + struct select_traits + { + typedef + wrapped_value_traits::null_handler> + type; + }; + + template + class value_traits: public select_traits::type + { + }; + + // The wrapped_value_traits specializations should be able to handle + // any value type which means we have to have every possible signature + // of the set_value() and set_image() functions. + // + template + struct wrapped_value_traits + { + typedef wrapper_traits wtraits; + typedef typename wtraits::unrestricted_wrapped_type wrapped_type; + + typedef W value_type; + typedef wrapped_type query_type; + typedef typename image_traits::image_type image_type; + + typedef value_traits vtraits; + + static void + set_value (W& v, const image_type& i, bool is_null) + { + vtraits::set_value (wtraits::set_ref (v), i, is_null); + } + + static void + set_image (image_type& i, bool& is_null, const W& v) + { + vtraits::set_image (i, is_null, wtraits::get_ref (v)); + } + + // TEXT and BLOB. + // + static void + set_value (W& v, const details::buffer& b, std::size_t n, bool is_null) + { + vtraits::set_value (wtraits::set_ref (v), b, n, is_null); + } + + static void + set_image (details::buffer& b, std::size_t& n, bool& is_null, const W& v) + { + vtraits::set_image (b, n, is_null, wtraits::get_ref (v)); + } + }; + + template + struct wrapped_value_traits + { + typedef wrapper_traits wtraits; + typedef typename wtraits::unrestricted_wrapped_type wrapped_type; + + typedef W value_type; + typedef wrapped_type query_type; + typedef typename image_traits::image_type image_type; + + typedef value_traits vtraits; + + static void + set_value (W& v, const image_type& i, bool is_null) + { + if (is_null) + wtraits::set_null (v); + else + vtraits::set_value (wtraits::set_ref (v), i, is_null); + } + + static void + set_image (image_type& i, bool& is_null, const W& v) + { + is_null = wtraits::get_null (v); + + if (!is_null) + vtraits::set_image (i, is_null, wtraits::get_ref (v)); + } + + // TEXT and BLOB. + // + static void + set_value (W& v, const details::buffer& b, std::size_t n, bool is_null) + { + if (is_null) + wtraits::set_null (v); + else + vtraits::set_value (wtraits::set_ref (v), b, n, is_null); + } + + static void + set_image (details::buffer& b, std::size_t& n, bool& is_null, const W& v) + { + is_null = wtraits::get_null (v); + + if (!is_null) + vtraits::set_image (b, n, is_null, wtraits::get_ref (v)); + } + }; + + template + struct default_value_traits + { + typedef T value_type; + typedef T query_type; + typedef typename image_traits::image_type image_type; + + static void + set_value (T& v, const image_type& i, bool is_null) + { + if (!is_null) + v = T (i); + else + v = T (); + } + + static void + set_image (image_type& i, bool& is_null, T v) + { + is_null = false; + i = image_type (v); + } + }; + + // Float & double specialization. SQLite converts NaNs to NULLs so + // we convert NULLs to NaNs for consistency. + // + template + struct real_value_traits + { + typedef T value_type; + typedef T query_type; + typedef double image_type; + + static void + set_value (T& v, double i, bool is_null) + { + if (!is_null) + v = T (i); + else + v = std::numeric_limits::quiet_NaN (); + } + + static void + set_image (double& i, bool& is_null, T v) + { + is_null = false; + i = image_type (v); + } + }; + + template <> + struct LIBODB_SQLITE_EXPORT default_value_traits: + real_value_traits + { + }; + + template <> + struct LIBODB_SQLITE_EXPORT default_value_traits: + real_value_traits + { + }; + + // std::string specialization. + // + template <> + struct LIBODB_SQLITE_EXPORT default_value_traits + { + typedef std::string value_type; + typedef std::string query_type; + typedef details::buffer image_type; + + static void + set_value (std::string& v, + const details::buffer& b, + std::size_t n, + bool is_null) + { + if (!is_null) + v.assign (b.data (), n); + else + v.erase (); + } + + static void + set_image (details::buffer&, + std::size_t& n, + bool& is_null, + const std::string&); + }; + + // char*/const char* specialization + // + // Specialization for const char* which only supports initialization + // of an image from the value but not the other way around. This way + // we can pass such values to the queries. + // + struct LIBODB_SQLITE_EXPORT c_string_value_traits + { + typedef const char* value_type; + typedef details::buffer image_type; + + static void + set_image (details::buffer&, + std::size_t& n, + bool& is_null, + const char*); + }; + + template <> + struct LIBODB_SQLITE_EXPORT default_value_traits: + c_string_value_traits {}; + + template <> + struct LIBODB_SQLITE_EXPORT default_value_traits: + c_string_value_traits {}; + + // char[N] specialization. + // + struct LIBODB_SQLITE_EXPORT c_array_value_traits_base + { + static void + set_value (char* const& v, + const details::buffer& b, + std::size_t n, + bool is_null, + std::size_t N); + + static void + set_image (details::buffer& b, + std::size_t& n, + bool& is_null, + const char* v, + std::size_t N); + }; + + template + struct default_value_traits + { + typedef char* value_type; + typedef char query_type[N]; + typedef details::buffer image_type; + + static void + set_value (char* const& v, + const details::buffer& b, + std::size_t n, + bool is_null) + { + c_array_value_traits_base::set_value (v, b, n, is_null, N); + } + + static void + set_image (details::buffer& b, + std::size_t& n, + bool& is_null, + const char* v) + { + c_array_value_traits_base::set_image (b, n, is_null, v, N); + } + }; + + // std::array (string) specialization. + // +#ifdef ODB_CXX11 + template + struct default_value_traits, id_text> + { + typedef std::array value_type; + typedef std::array query_type; + typedef details::buffer image_type; + + static void + set_value (value_type& v, + const details::buffer& b, + std::size_t n, + bool is_null) + { + c_array_value_traits_base::set_value (v.data (), b, n, is_null, N); + } + + static void + set_image (details::buffer& b, + std::size_t& n, + bool& is_null, + const value_type& v) + { + c_array_value_traits_base::set_image (b, n, is_null, v.data (), N); + } + }; +#endif + + // char specialization. + // + template <> + struct LIBODB_SQLITE_EXPORT default_value_traits + { + typedef char value_type; + typedef char query_type; + typedef details::buffer image_type; + + static void + set_value (char& v, + const details::buffer& b, + std::size_t n, + bool is_null) + { + c_array_value_traits_base::set_value (&v, b, n, is_null, 1); + } + + static void + set_image (details::buffer& b, + std::size_t& n, + bool& is_null, + char v) + { + c_array_value_traits_base::set_image (b, n, is_null, &v, 1); + } + }; + +#ifdef _WIN32 + // std::wstring specialization. Using UTF-16 binding. + // + struct wstring_image_traits + { + typedef details::buffer image_type; + static const bind::buffer_type bind_value = bind::text16; + }; + + template <> + struct image_traits: wstring_image_traits {}; + + template <> + struct LIBODB_SQLITE_EXPORT default_value_traits + { + typedef std::wstring value_type; + typedef std::wstring query_type; + typedef details::buffer image_type; + + static void + set_value (std::wstring& v, + const details::buffer& b, + std::size_t n, + bool is_null) + { + if (!is_null) + v.assign (reinterpret_cast (b.data ()), n / 2); + else + v.erase (); + } + + static void + set_image (details::buffer&, + std::size_t& n, + bool& is_null, + const std::wstring&); + }; + + // wchar_t*/const wchar_t* specialization. + // + struct LIBODB_SQLITE_EXPORT c_wstring_value_traits + { + typedef const wchar_t* value_type; + typedef details::buffer image_type; + + static void + set_image (details::buffer&, + std::size_t& n, + bool& is_null, + const wchar_t*); + }; + + template <> + struct image_traits: wstring_image_traits {}; + + template <> + struct LIBODB_SQLITE_EXPORT default_value_traits: + c_wstring_value_traits {}; + + template <> + struct image_traits: wstring_image_traits {}; + + template <> + struct LIBODB_SQLITE_EXPORT default_value_traits: + c_wstring_value_traits {}; + + // wchar_t[N] specialization. + // + struct LIBODB_SQLITE_EXPORT c_warray_value_traits_base + { + static void + set_value (wchar_t* const& v, + const details::buffer& b, + std::size_t n, + bool is_null, + std::size_t N); + + static void + set_image (details::buffer& b, + std::size_t& n, + bool& is_null, + const wchar_t* v, + std::size_t N); + }; + + template + struct image_traits: wstring_image_traits {}; + + template + struct default_value_traits + { + typedef wchar_t* value_type; + typedef wchar_t query_type[N]; + typedef details::buffer image_type; + + static void + set_value (wchar_t* const& v, + const details::buffer& b, + std::size_t n, + bool is_null) + { + c_warray_value_traits_base::set_value (v, b, n, is_null, N); + } + + static void + set_image (details::buffer& b, + std::size_t& n, + bool& is_null, + const wchar_t* v) + { + c_warray_value_traits_base::set_image (b, n, is_null, v, N); + } + }; + + // std::array (string) specialization. + // +#ifdef ODB_CXX11 + template + struct image_traits, id_text>: + wstring_image_traits {}; + + template + struct default_value_traits, id_text> + { + typedef std::array value_type; + typedef std::array query_type; + typedef details::buffer image_type; + + static void + set_value (value_type& v, + const details::buffer& b, + std::size_t n, + bool is_null) + { + c_warray_value_traits_base::set_value (v.data (), b, n, is_null, N); + } + + static void + set_image (details::buffer& b, + std::size_t& n, + bool& is_null, + const value_type& v) + { + c_warray_value_traits_base::set_image (b, n, is_null, v.data (), N); + } + }; +#endif + + // wchar_t specialization. + // + template <> + struct image_traits: wstring_image_traits {}; + + template <> + struct LIBODB_SQLITE_EXPORT default_value_traits + { + typedef wchar_t value_type; + typedef wchar_t query_type; + typedef details::buffer image_type; + + static void + set_value (wchar_t& v, + const details::buffer& b, + std::size_t n, + bool is_null) + { + c_warray_value_traits_base::set_value (&v, b, n, is_null, 1); + } + + static void + set_image (details::buffer& b, + std::size_t& n, + bool& is_null, + wchar_t v) + { + c_warray_value_traits_base::set_image (b, n, is_null, &v, 1); + } + }; +#endif // _WIN32 + + // std::vector (buffer) specialization. + // + template <> + struct LIBODB_SQLITE_EXPORT default_value_traits< + std::vector, id_blob> + { + public: + typedef std::vector value_type; + typedef std::vector query_type; + typedef details::buffer image_type; + + static void + set_value (value_type& v, + const details::buffer& b, + std::size_t n, + bool is_null) + { + if (!is_null) + v.assign (b.data (), b.data () + n); + else + v.clear (); + } + + static void + set_image (details::buffer&, + std::size_t& n, + bool& is_null, + const value_type&); + }; + + // std::vector (buffer) specialization. + // + template <> + struct LIBODB_SQLITE_EXPORT default_value_traits< + std::vector, id_blob> + { + public: + typedef std::vector value_type; + typedef std::vector query_type; + typedef details::buffer image_type; + + static void + set_value (value_type& v, + const details::buffer& b, + std::size_t n, + bool is_null) + { + if (!is_null) + { + const unsigned char* d ( + reinterpret_cast (b.data ())); + v.assign (d, d + n); + } + else + v.clear (); + } + + static void + set_image (details::buffer&, + std::size_t& n, + bool& is_null, + const value_type&); + }; + + // char[N] (buffer) specialization. + // + template + struct default_value_traits + { + public: + typedef char* value_type; + typedef char query_type[N]; + typedef details::buffer image_type; + + static void + set_value (char* const& v, + const details::buffer& b, + std::size_t n, + bool is_null) + { + if (!is_null) + std::memcpy (v, b.data (), (n < N ? n : N)); + else + std::memset (v, 0, N); + } + + static void + set_image (details::buffer& b, + std::size_t& n, + bool& is_null, + const char* v) + { + is_null = false; + n = N; + + if (n > b.capacity ()) + b.capacity (n); + + std::memcpy (b.data (), v, n); + } + }; + + // unsigned char[N] (buffer) specialization. + // + template + struct default_value_traits + { + public: + typedef unsigned char* value_type; + typedef unsigned char query_type[N]; + typedef details::buffer image_type; + + static void + set_value (unsigned char* const& v, + const details::buffer& b, + std::size_t n, + bool is_null) + { + if (!is_null) + std::memcpy (v, b.data (), (n < N ? n : N)); + else + std::memset (v, 0, N); + } + + static void + set_image (details::buffer& b, + std::size_t& n, + bool& is_null, + const unsigned char* v) + { + is_null = false; + n = N; + + if (n > b.capacity ()) + b.capacity (n); + + std::memcpy (b.data (), v, n); + } + }; + +#ifdef ODB_CXX11 + // std::array (buffer) specialization. + // + template + struct default_value_traits, id_blob> + { + public: + typedef std::array value_type; + typedef value_type query_type; + typedef details::buffer image_type; + + static void + set_value (value_type& v, + const details::buffer& b, + std::size_t n, + bool is_null) + { + if (!is_null) + std::memcpy (v.data (), b.data (), (n < N ? n : N)); + else + std::memset (v.data (), 0, N); + } + + static void + set_image (details::buffer& b, + std::size_t& n, + bool& is_null, + const value_type& v) + { + is_null = false; + n = N; + + if (n > b.capacity ()) + b.capacity (n); + + std::memcpy (b.data (), v.data (), n); + } + }; + + // std::array (buffer) specialization. + // + template + struct default_value_traits, id_blob> + { + public: + typedef std::array value_type; + typedef value_type query_type; + typedef details::buffer image_type; + + static void + set_value (value_type& v, + const details::buffer& b, + std::size_t n, + bool is_null) + { + if (!is_null) + std::memcpy (v.data (), b.data (), (n < N ? n : N)); + else + std::memset (v.data (), 0, N); + } + + static void + set_image (details::buffer& b, + std::size_t& n, + bool& is_null, + const value_type& v) + { + is_null = false; + n = N; + + if (n > b.capacity ()) + b.capacity (n); + + std::memcpy (b.data (), v.data (), n); + } + }; +#endif + + // + // type_traits + // + + template + struct default_type_traits; + + template + class type_traits: public default_type_traits {}; + + // Integral types. + // + template <> + struct default_type_traits + { + static const database_type_id db_type_id = id_integer; + }; + + template <> + struct default_type_traits + { + static const database_type_id db_type_id = id_integer; + }; + + template <> + struct default_type_traits + { + static const database_type_id db_type_id = id_integer; + }; + + template <> + struct default_type_traits + { + static const database_type_id db_type_id = id_integer; + }; + + template <> + struct default_type_traits + { + static const database_type_id db_type_id = id_integer; + }; + + template <> + struct default_type_traits + { + static const database_type_id db_type_id = id_integer; + }; + + template <> + struct default_type_traits + { + static const database_type_id db_type_id = id_integer; + }; + + template <> + struct default_type_traits + { + static const database_type_id db_type_id = id_integer; + }; + + template <> + struct default_type_traits + { + static const database_type_id db_type_id = id_integer; + }; + + template <> + struct default_type_traits + { + static const database_type_id db_type_id = id_integer; + }; + + template <> + struct default_type_traits + { + static const database_type_id db_type_id = id_integer; + }; + + // Float types. + // + template <> + struct default_type_traits + { + static const database_type_id db_type_id = id_real; + }; + + template <> + struct default_type_traits + { + static const database_type_id db_type_id = id_real; + }; + + // String types. + // + template <> + struct default_type_traits + { + static const database_type_id db_type_id = id_text; + }; + + template <> + struct default_type_traits + { + static const database_type_id db_type_id = id_text; + }; + + template <> + struct default_type_traits + { + static const database_type_id db_type_id = id_text; + }; + + template + struct default_type_traits + { + static const database_type_id db_type_id = id_text; + }; + +#ifdef ODB_CXX11 + template + struct default_type_traits > + { + static const database_type_id db_type_id = id_text; + }; +#endif + + template <> + struct default_type_traits + { + static const database_type_id db_type_id = id_text; + }; + + // Binary types. + // + template + struct default_type_traits + { + static const database_type_id db_type_id = id_blob; + }; + + template <> + struct default_type_traits > + { + static const database_type_id db_type_id = id_blob; + }; + + template <> + struct default_type_traits > + { + static const database_type_id db_type_id = id_blob; + }; + +#ifdef ODB_CXX11 + template + struct default_type_traits > + { + static const database_type_id db_type_id = id_blob; + }; +#endif + } +} + +#include + +#endif // ODB_SQLITE_TRAITS_HXX diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/transaction-impl.cxx b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/transaction-impl.cxx new file mode 100755 index 0000000..2f83071 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/transaction-impl.cxx @@ -0,0 +1,144 @@ +// file : odb/sqlite/transaction-impl.cxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include + +#include +#include +#include +#include +#include + +namespace odb +{ + namespace sqlite + { + transaction_impl:: + transaction_impl (database_type& db, lock l) + : odb::transaction_impl (db), lock_ (l) + { + } + + transaction_impl:: + transaction_impl (connection_ptr c, lock l) + : odb::transaction_impl (c->database (), *c), + connection_ (c), + lock_ (l) + { + } + + transaction_impl:: + ~transaction_impl () + { + } + + void transaction_impl:: + start () + { + // Grab a connection if we don't already have one. + // + if (connection_ == 0) + { + connection_ = static_cast (database_).connection (); + odb::transaction_impl::connection_ = connection_.get (); + } + + statement_cache& sc (connection_->statement_cache ()); + + switch (lock_) + { + case deferred: + { + sc.begin_statement ().execute (); + break; + } + case immediate: + { + sc.begin_immediate_statement ().execute (); + break; + } + case exclusive: + { + sc.begin_exclusive_statement ().execute (); + break; + } + } + } + + // In SQLite, when a commit fails (e.g., because of the deferred + // foreign key constraint violation), the transaction may not + // be automatically rolled back. So we have to do it ourselves. + // + struct commit_guard + { + commit_guard (connection& c): c_ (&c) {} + void release () {c_ = 0;} + + ~commit_guard () + { + if (c_ != 0 && sqlite3_get_autocommit (c_->handle ()) == 0) + { + // This is happening while another exception is active. + // + try + { + c_->statement_cache ().rollback_statement ().execute (); + } + catch (...) {} + } + } + + private: + connection* c_; + }; + + void transaction_impl:: + commit () + { + // Invalidate query results. + // + connection_->invalidate_results (); + + // Reset active statements. Active statements will prevent COMMIT + // from completing (write statements) or releasing the locks (read + // statements). Normally, a statement is automatically reset on + // completion, however, if an exception is thrown, that may not + // happen. + // + connection_->clear (); + + { + commit_guard cg (*connection_); + connection_->statement_cache ().commit_statement ().execute (); + cg.release (); + } + + // Release the connection. + // + connection_.reset (); + } + + void transaction_impl:: + rollback () + { + // Invalidate query results. + // + connection_->invalidate_results (); + + // Reset active statements. Active statements will prevent ROLLBACK + // from completing (write statements) or releasing the locks (read + // statements). Normally, a statement is automatically reset on + // completion, however, if an exception is thrown, that may not + // happen. + // + connection_->clear (); + + connection_->statement_cache ().rollback_statement ().execute (); + + // Release the connection. + // + connection_.reset (); + } + } +} diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/transaction-impl.hxx b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/transaction-impl.hxx new file mode 100755 index 0000000..92de110 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/transaction-impl.hxx @@ -0,0 +1,63 @@ +// file : odb/sqlite/transaction-impl.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_SQLITE_TRANSACTION_IMPL_HXX +#define ODB_SQLITE_TRANSACTION_IMPL_HXX + +#include + +#include + +#include +#include + +#include + +namespace odb +{ + namespace sqlite + { + class LIBODB_SQLITE_EXPORT transaction_impl: public odb::transaction_impl + { + public: + typedef sqlite::database database_type; + typedef sqlite::connection connection_type; + + enum lock + { + deferred, + immediate, + exclusive + }; + + transaction_impl (database_type&, lock); + transaction_impl (connection_ptr, lock); + + virtual + ~transaction_impl (); + + virtual void + start (); + + virtual void + commit (); + + virtual void + rollback (); + + connection_type& + connection (); + + private: + connection_ptr connection_; + lock lock_; + }; + } +} + +#include + +#include + +#endif // ODB_SQLITE_TRANSACTION_IMPL_HXX diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/transaction-impl.ixx b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/transaction-impl.ixx new file mode 100755 index 0000000..40eeb5a --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/transaction-impl.ixx @@ -0,0 +1,15 @@ +// file : odb/sqlite/transaction-impl.ixx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +namespace odb +{ + namespace sqlite + { + inline transaction_impl::connection_type& transaction_impl:: + connection () + { + return *connection_; + } + } +} diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/transaction.cxx b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/transaction.cxx new file mode 100755 index 0000000..9cd9303 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/transaction.cxx @@ -0,0 +1,27 @@ +// file : odb/sqlite/transaction.cxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include + +#include + +namespace odb +{ + namespace sqlite + { + transaction& transaction:: + current () + { + // While the impl type can be of the concrete type, the transaction + // object can be created as either odb:: or odb::sqlite:: type. To + // work around that we are going to hard-cast one two the other + // relying on the fact that they have the same representation and + // no virtual functions. The former is checked in the tests. + // + odb::transaction& b (odb::transaction::current ()); + assert (dynamic_cast (&b.implementation ()) != 0); + return reinterpret_cast (b); + } + } +} diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/transaction.hxx b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/transaction.hxx new file mode 100755 index 0000000..5651694 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/transaction.hxx @@ -0,0 +1,85 @@ +// file : odb/sqlite/transaction.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_SQLITE_TRANSACTION_HXX +#define ODB_SQLITE_TRANSACTION_HXX + +#include + +#include + +#include +#include +#include +#include + +namespace odb +{ + namespace sqlite + { + class transaction_impl; + + class LIBODB_SQLITE_EXPORT transaction: public odb::transaction + { + public: + typedef sqlite::database database_type; + typedef sqlite::connection connection_type; + + explicit + transaction (transaction_impl*, bool make_current = true); + + transaction (); + + // Return the database this transaction is on. + // + database_type& + database (); + + // Return the underlying database connection for this transaction. + // + connection_type& + connection (); + + // Return current transaction or throw if there is no transaction + // in effect. + // + static transaction& + current (); + + // Set the current thread's transaction. + // + static void + current (transaction&); + + // SQL statement tracing. + // + public: + typedef sqlite::tracer tracer_type; + + void + tracer (tracer_type& t) + { + odb::transaction::tracer (t); + } + + void + tracer (tracer_type* t) + { + odb::transaction::tracer (t); + } + + using odb::transaction::tracer; + + public: + transaction_impl& + implementation (); + }; + } +} + +#include + +#include + +#endif // ODB_SQLITE_TRANSACTION_HXX diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/transaction.ixx b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/transaction.ixx new file mode 100755 index 0000000..3757175 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/transaction.ixx @@ -0,0 +1,52 @@ +// file : odb/sqlite/transaction.ixx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include +#include + +namespace odb +{ + namespace sqlite + { + inline transaction:: + transaction (transaction_impl* impl, bool make_current) + : odb::transaction (impl, make_current) + { + } + + inline transaction:: + transaction () + : odb::transaction () + { + } + + inline transaction_impl& transaction:: + implementation () + { + // We can use static_cast here since we have an instance of + // sqlite::transaction. + // + return static_cast ( + odb::transaction::implementation ()); + } + + inline transaction::database_type& transaction:: + database () + { + return static_cast (odb::transaction::database ()); + } + + inline transaction::connection_type& transaction:: + connection () + { + return implementation ().connection (); + } + + inline void transaction:: + current (transaction& t) + { + odb::transaction::current (t); + } + } +} diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/version.hxx b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/version.hxx new file mode 100755 index 0000000..ae0fb75 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/version.hxx @@ -0,0 +1,43 @@ +// file : odb/sqlite/version.hxx +// copyright : Copyright (c) 2005-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_SQLITE_VERSION_HXX +#define ODB_SQLITE_VERSION_HXX + +#include + +#include + +// Version format is AABBCCDD where +// +// AA - major version number +// BB - minor version number +// CC - bugfix version number +// DD - alpha / beta (DD + 50) version number +// +// When DD is not 00, 1 is subtracted from AABBCC. For example: +// +// Version AABBCCDD +// 2.0.0 02000000 +// 2.1.0 02010000 +// 2.1.1 02010100 +// 2.2.0.a1 02019901 +// 3.0.0.b2 02999952 +// + +// Check that we have compatible ODB version. +// +#if ODB_VERSION != 20400 +# error incompatible odb interface version detected +#endif + +// libodb-sqlite version: odb interface version plus the bugfix +// version. +// +#define LIBODB_SQLITE_VERSION 2040000 +#define LIBODB_SQLITE_VERSION_STR "2.4.0" + +#include + +#endif // ODB_SQLITE_VERSION_HXX diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/view-result.hxx b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/view-result.hxx new file mode 100755 index 0000000..2b3b167 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/view-result.hxx @@ -0,0 +1,81 @@ +// file : odb/sqlite/view-result.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_SQLITE_VIEW_RESULT_HXX +#define ODB_SQLITE_VIEW_RESULT_HXX + +#include + +#include // std::size_t + +#include +#include + +#include + +#include +#include // query_base, query_params +#include +#include + +namespace odb +{ + namespace sqlite + { + template + class view_result_impl: public odb::view_result_impl + { + public: + typedef odb::view_result_impl base_type; + + typedef typename base_type::view_type view_type; + typedef typename base_type::pointer_type pointer_type; + + typedef view_traits_impl view_traits; + typedef typename base_type::pointer_traits pointer_traits; + + typedef view_statements statements_type; + + virtual + ~view_result_impl (); + + view_result_impl (const query_base&, + const details::shared_ptr&, + statements_type&, + const schema_version_migration*); + + virtual void + load (view_type&); + + virtual void + next (); + + virtual void + cache (); + + virtual std::size_t + size (); + + virtual void + invalidate (); + + using base_type::current; + + private: + // We need to hold on to the query parameters because SQLite uses + // the parameter buffers to find each next row. + // + details::shared_ptr params_; + details::shared_ptr statement_; + statements_type& statements_; + view_traits_calls tc_; + }; + } +} + +#include + +#include + +#endif // ODB_SQLITE_VIEW_RESULT_HXX diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/view-result.txx b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/view-result.txx new file mode 100755 index 0000000..6b88971 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/view-result.txx @@ -0,0 +1,115 @@ +// file : odb/sqlite/view-result.txx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include +#include + +#include + +namespace odb +{ + namespace sqlite + { + template + view_result_impl:: + ~view_result_impl () + { + if (!this->end_) + statement_->free_result (); + } + + template + void view_result_impl:: + invalidate () + { + if (!this->end_) + { + statement_->free_result (); + this->end_ = true; + } + + params_.reset (); + statement_.reset (); + } + + template + view_result_impl:: + view_result_impl (const query_base& q, + const details::shared_ptr& s, + statements_type& sts, + const schema_version_migration* svm) + : base_type (sts.connection ()), + params_ (q.parameters ()), + statement_ (s), + statements_ (sts), + tc_ (svm) + { + } + + template + void view_result_impl:: + load (view_type& view) + { + // The image can grow between calls to load() as a result of other + // statements execution. + // + typename view_traits::image_type& im (statements_.image ()); + + if (im.version != statements_.image_version ()) + { + binding& b (statements_.image_binding ()); + tc_.bind (b.bind, im); + statements_.image_version (im.version); + b.version++; + } + + select_statement::result r (statement_->load ()); + + if (r == select_statement::truncated) + { + if (tc_.grow (im, statements_.image_truncated ())) + im.version++; + + if (im.version != statements_.image_version ()) + { + binding& b (statements_.image_binding ()); + tc_.bind (b.bind, im); + statements_.image_version (im.version); + b.version++; + statement_->reload (); + } + } + + view_traits::callback (this->db_, view, callback_event::pre_load); + tc_.init (view, im, &this->db_); + view_traits::callback (this->db_, view, callback_event::post_load); + } + + template + void view_result_impl:: + next () + { + this->current (pointer_type ()); + + if (!statement_->next ()) + { + statement_->free_result (); + this->end_ = true; + } + } + + template + void view_result_impl:: + cache () + { + } + + template + std::size_t view_result_impl:: + size () + { + throw result_not_cached (); + } + } +} diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/view-statements.hxx b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/view-statements.hxx new file mode 100755 index 0000000..6ecaaaa --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/view-statements.hxx @@ -0,0 +1,89 @@ +// file : odb/sqlite/view-statements.hxx +// copyright : Copyright (c) 2005-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_SQLITE_VIEW_STATEMENTS_HXX +#define ODB_SQLITE_VIEW_STATEMENTS_HXX + +#include + +#include // std::size_t + +#include +#include + +#include +#include +#include +#include + +namespace odb +{ + namespace sqlite + { + template + class view_statements: public statements_base + { + public: + typedef T view_type; + typedef view_traits_impl view_traits; + typedef typename view_traits::pointer_type pointer_type; + typedef typename view_traits::image_type image_type; + + public: + view_statements (connection_type&); + + virtual + ~view_statements (); + + // View image. + // + image_type& + image () + { + return image_; + } + + std::size_t + image_version () const + { + return image_version_; + } + + void + image_version (std::size_t v) + { + image_version_ = v; + } + + binding& + image_binding () + { + return image_binding_; + } + + bool* + image_truncated () + { + return image_truncated_; + } + + private: + view_statements (const view_statements&); + view_statements& operator= (const view_statements&); + + private: + image_type image_; + std::size_t image_version_; + binding image_binding_; + bind image_bind_[view_traits::column_count]; + bool image_truncated_[view_traits::column_count]; + }; + } +} + +#include + +#include + +#endif // ODB_SQLITE_VIEW_STATEMENTS_HXX diff --git a/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/view-statements.txx b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/view-statements.txx new file mode 100755 index 0000000..bd46aa3 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/odb/sqlite/view-statements.txx @@ -0,0 +1,34 @@ +// file : odb/sqlite/view-statements.txx +// copyright : Copyright (c) 2005-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#include // std::size_t +#include // std::memset + +namespace odb +{ + namespace sqlite + { + template + view_statements:: + ~view_statements () + { + } + + template + view_statements:: + view_statements (connection_type& conn) + : statements_base (conn), + image_binding_ (image_bind_, view_traits::column_count) + { + image_.version = 0; + image_version_ = 0; + + std::memset (image_bind_, 0, sizeof (image_bind_)); + std::memset (image_truncated_, 0, sizeof (image_truncated_)); + + for (std::size_t i (0); i < view_traits::column_count; ++i) + image_bind_[i].truncated = image_truncated_ + i; + } + } +} diff --git a/third-party/odb/libodb-sqlite-2.4.0/version b/third-party/odb/libodb-sqlite-2.4.0/version new file mode 100755 index 0000000..197c4d5 --- /dev/null +++ b/third-party/odb/libodb-sqlite-2.4.0/version @@ -0,0 +1 @@ +2.4.0 diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/README b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/README new file mode 100755 index 0000000..06b6a9b --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/README @@ -0,0 +1,44 @@ +ODB is an object-relational mapping (ORM) system for C++. It provides +tools, APIs, and library support that allow you to persist C++ objects +to a relational database (RDBMS) without having to deal with tables, +columns, or SQL and without manually writing any of the mapping code. +For more information see: + +http://www.codesynthesis.com/products/odb/ + +This package contains the pre-compiled binary distribution of the ODB +compiler. The top-level directory structure of this package is as +follows: + +bin/ ODB compiler binary +etc/ ODB compiler configuration +doc/ ODB system documentation +man/ man pages for the ODB compiler +-/ GCC compiler binaries, see manifest inside for details + +To install this package simply unpack it into a directory of your choice, +for example /opt/. You can run the ODB compiler by either using the +absolute path, for example: + +/opt/odb-x.y.z-i686-linux-gnu/bin/odb --version + +Or you can add the bin/ directory to the PATH environment variable, for +example: + +export PATH=/opt/odb-x.y.z-i686-linux-gnu/bin:$PATH +odb --version + +If you have commonly-used libraries that are not installed into one of the +default locations (normally /usr/include and /usr/local/include) and you +would like to add them to the ODB compiler header search list, then you +can add their include directories to the etc/odb/default.options file. +For more information, refer to the instructions at the beginning of this +file. + +Note also that while you can move the ODB compiler directory around, you +cannot move individual sub-directories or files inside it. For example, +copying or linking the ODB compiler executable to /usr/local/bin/ will +not work. + +Send questions, bug reports, or any other feedback to the +odb-users@codesynthesis.com mailing list. diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/bin/odb b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/bin/odb new file mode 100755 index 0000000..16430f5 Binary files /dev/null and b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/bin/odb differ diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/doc/GPLv3 b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/doc/GPLv3 new file mode 100755 index 0000000..94a9ed0 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/doc/GPLv3 @@ -0,0 +1,674 @@ + GNU GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The GNU General Public License is a free, copyleft license for +software and other kinds of works. + + The licenses for most software and other practical works are designed +to take away your freedom to share and change the works. By contrast, +the GNU General Public License is intended to guarantee your freedom to +share and change all versions of a program--to make sure it remains free +software for all its users. We, the Free Software Foundation, use the +GNU General Public License for most of our software; it applies also to +any other work released this way by its authors. You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +them if you wish), that you receive source code or can get it if you +want it, that you can change the software or use pieces of it in new +free programs, and that you know you can do these things. + + To protect your rights, we need to prevent others from denying you +these rights or asking you to surrender the rights. Therefore, you have +certain responsibilities if you distribute copies of the software, or if +you modify it: responsibilities to respect the freedom of others. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must pass on to the recipients the same +freedoms that you received. You must make sure that they, too, receive +or can get the source code. And you must show them these terms so they +know their rights. + + Developers that use the GNU GPL protect your rights with two steps: +(1) assert copyright on the software, and (2) offer you this License +giving you legal permission to copy, distribute and/or modify it. + + For the developers' and authors' protection, the GPL clearly explains +that there is no warranty for this free software. For both users' and +authors' sake, the GPL requires that modified versions be marked as +changed, so that their problems will not be attributed erroneously to +authors of previous versions. + + Some devices are designed to deny users access to install or run +modified versions of the software inside them, although the manufacturer +can do so. This is fundamentally incompatible with the aim of +protecting users' freedom to change the software. The systematic +pattern of such abuse occurs in the area of products for individuals to +use, which is precisely where it is most unacceptable. Therefore, we +have designed this version of the GPL to prohibit the practice for those +products. If such problems arise substantially in other domains, we +stand ready to extend this provision to those domains in future versions +of the GPL, as needed to protect the freedom of users. + + Finally, every program is threatened constantly by software patents. +States should not allow patents to restrict development and use of +software on general-purpose computers, but in those that do, we wish to +avoid the special danger that patents applied to a free program could +make it effectively proprietary. To prevent this, the GPL assures that +patents cannot be used to render the program non-free. + + The precise terms and conditions for copying, distribution and +modification follow. + + TERMS AND CONDITIONS + + 0. Definitions. + + "This License" refers to version 3 of the GNU General Public License. + + "Copyright" also means copyright-like laws that apply to other kinds of +works, such as semiconductor masks. + + "The Program" refers to any copyrightable work licensed under this +License. Each licensee is addressed as "you". "Licensees" and +"recipients" may be individuals or organizations. + + To "modify" a work means to copy from or adapt all or part of the work +in a fashion requiring copyright permission, other than the making of an +exact copy. The resulting work is called a "modified version" of the +earlier work or a work "based on" the earlier work. + + A "covered work" means either the unmodified Program or a work based +on the Program. + + To "propagate" a work means to do anything with it that, without +permission, would make you directly or secondarily liable for +infringement under applicable copyright law, except executing it on a +computer or modifying a private copy. Propagation includes copying, +distribution (with or without modification), making available to the +public, and in some countries other activities as well. + + To "convey" a work means any kind of propagation that enables other +parties to make or receive copies. Mere interaction with a user through +a computer network, with no transfer of a copy, is not conveying. + + An interactive user interface displays "Appropriate Legal Notices" +to the extent that it includes a convenient and prominently visible +feature that (1) displays an appropriate copyright notice, and (2) +tells the user that there is no warranty for the work (except to the +extent that warranties are provided), that licensees may convey the +work under this License, and how to view a copy of this License. If +the interface presents a list of user commands or options, such as a +menu, a prominent item in the list meets this criterion. + + 1. Source Code. + + The "source code" for a work means the preferred form of the work +for making modifications to it. "Object code" means any non-source +form of a work. + + A "Standard Interface" means an interface that either is an official +standard defined by a recognized standards body, or, in the case of +interfaces specified for a particular programming language, one that +is widely used among developers working in that language. + + The "System Libraries" of an executable work include anything, other +than the work as a whole, that (a) is included in the normal form of +packaging a Major Component, but which is not part of that Major +Component, and (b) serves only to enable use of the work with that +Major Component, or to implement a Standard Interface for which an +implementation is available to the public in source code form. A +"Major Component", in this context, means a major essential component +(kernel, window system, and so on) of the specific operating system +(if any) on which the executable work runs, or a compiler used to +produce the work, or an object code interpreter used to run it. + + The "Corresponding Source" for a work in object code form means all +the source code needed to generate, install, and (for an executable +work) run the object code and to modify the work, including scripts to +control those activities. However, it does not include the work's +System Libraries, or general-purpose tools or generally available free +programs which are used unmodified in performing those activities but +which are not part of the work. For example, Corresponding Source +includes interface definition files associated with source files for +the work, and the source code for shared libraries and dynamically +linked subprograms that the work is specifically designed to require, +such as by intimate data communication or control flow between those +subprograms and other parts of the work. + + The Corresponding Source need not include anything that users +can regenerate automatically from other parts of the Corresponding +Source. + + The Corresponding Source for a work in source code form is that +same work. + + 2. Basic Permissions. + + All rights granted under this License are granted for the term of +copyright on the Program, and are irrevocable provided the stated +conditions are met. This License explicitly affirms your unlimited +permission to run the unmodified Program. The output from running a +covered work is covered by this License only if the output, given its +content, constitutes a covered work. This License acknowledges your +rights of fair use or other equivalent, as provided by copyright law. + + You may make, run and propagate covered works that you do not +convey, without conditions so long as your license otherwise remains +in force. You may convey covered works to others for the sole purpose +of having them make modifications exclusively for you, or provide you +with facilities for running those works, provided that you comply with +the terms of this License in conveying all material for which you do +not control copyright. Those thus making or running the covered works +for you must do so exclusively on your behalf, under your direction +and control, on terms that prohibit them from making any copies of +your copyrighted material outside their relationship with you. + + Conveying under any other circumstances is permitted solely under +the conditions stated below. Sublicensing is not allowed; section 10 +makes it unnecessary. + + 3. Protecting Users' Legal Rights From Anti-Circumvention Law. + + No covered work shall be deemed part of an effective technological +measure under any applicable law fulfilling obligations under article +11 of the WIPO copyright treaty adopted on 20 December 1996, or +similar laws prohibiting or restricting circumvention of such +measures. + + When you convey a covered work, you waive any legal power to forbid +circumvention of technological measures to the extent such circumvention +is effected by exercising rights under this License with respect to +the covered work, and you disclaim any intention to limit operation or +modification of the work as a means of enforcing, against the work's +users, your or third parties' legal rights to forbid circumvention of +technological measures. + + 4. Conveying Verbatim Copies. + + You may convey verbatim copies of the Program's source code as you +receive it, in any medium, provided that you conspicuously and +appropriately publish on each copy an appropriate copyright notice; +keep intact all notices stating that this License and any +non-permissive terms added in accord with section 7 apply to the code; +keep intact all notices of the absence of any warranty; and give all +recipients a copy of this License along with the Program. + + You may charge any price or no price for each copy that you convey, +and you may offer support or warranty protection for a fee. + + 5. Conveying Modified Source Versions. + + You may convey a work based on the Program, or the modifications to +produce it from the Program, in the form of source code under the +terms of section 4, provided that you also meet all of these conditions: + + a) The work must carry prominent notices stating that you modified + it, and giving a relevant date. + + b) The work must carry prominent notices stating that it is + released under this License and any conditions added under section + 7. This requirement modifies the requirement in section 4 to + "keep intact all notices". + + c) You must license the entire work, as a whole, under this + License to anyone who comes into possession of a copy. This + License will therefore apply, along with any applicable section 7 + additional terms, to the whole of the work, and all its parts, + regardless of how they are packaged. This License gives no + permission to license the work in any other way, but it does not + invalidate such permission if you have separately received it. + + d) If the work has interactive user interfaces, each must display + Appropriate Legal Notices; however, if the Program has interactive + interfaces that do not display Appropriate Legal Notices, your + work need not make them do so. + + A compilation of a covered work with other separate and independent +works, which are not by their nature extensions of the covered work, +and which are not combined with it such as to form a larger program, +in or on a volume of a storage or distribution medium, is called an +"aggregate" if the compilation and its resulting copyright are not +used to limit the access or legal rights of the compilation's users +beyond what the individual works permit. Inclusion of a covered work +in an aggregate does not cause this License to apply to the other +parts of the aggregate. + + 6. Conveying Non-Source Forms. + + You may convey a covered work in object code form under the terms +of sections 4 and 5, provided that you also convey the +machine-readable Corresponding Source under the terms of this License, +in one of these ways: + + a) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by the + Corresponding Source fixed on a durable physical medium + customarily used for software interchange. + + b) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by a + written offer, valid for at least three years and valid for as + long as you offer spare parts or customer support for that product + model, to give anyone who possesses the object code either (1) a + copy of the Corresponding Source for all the software in the + product that is covered by this License, on a durable physical + medium customarily used for software interchange, for a price no + more than your reasonable cost of physically performing this + conveying of source, or (2) access to copy the + Corresponding Source from a network server at no charge. + + c) Convey individual copies of the object code with a copy of the + written offer to provide the Corresponding Source. This + alternative is allowed only occasionally and noncommercially, and + only if you received the object code with such an offer, in accord + with subsection 6b. + + d) Convey the object code by offering access from a designated + place (gratis or for a charge), and offer equivalent access to the + Corresponding Source in the same way through the same place at no + further charge. You need not require recipients to copy the + Corresponding Source along with the object code. If the place to + copy the object code is a network server, the Corresponding Source + may be on a different server (operated by you or a third party) + that supports equivalent copying facilities, provided you maintain + clear directions next to the object code saying where to find the + Corresponding Source. Regardless of what server hosts the + Corresponding Source, you remain obligated to ensure that it is + available for as long as needed to satisfy these requirements. + + e) Convey the object code using peer-to-peer transmission, provided + you inform other peers where the object code and Corresponding + Source of the work are being offered to the general public at no + charge under subsection 6d. + + A separable portion of the object code, whose source code is excluded +from the Corresponding Source as a System Library, need not be +included in conveying the object code work. + + A "User Product" is either (1) a "consumer product", which means any +tangible personal property which is normally used for personal, family, +or household purposes, or (2) anything designed or sold for incorporation +into a dwelling. In determining whether a product is a consumer product, +doubtful cases shall be resolved in favor of coverage. For a particular +product received by a particular user, "normally used" refers to a +typical or common use of that class of product, regardless of the status +of the particular user or of the way in which the particular user +actually uses, or expects or is expected to use, the product. A product +is a consumer product regardless of whether the product has substantial +commercial, industrial or non-consumer uses, unless such uses represent +the only significant mode of use of the product. + + "Installation Information" for a User Product means any methods, +procedures, authorization keys, or other information required to install +and execute modified versions of a covered work in that User Product from +a modified version of its Corresponding Source. The information must +suffice to ensure that the continued functioning of the modified object +code is in no case prevented or interfered with solely because +modification has been made. + + If you convey an object code work under this section in, or with, or +specifically for use in, a User Product, and the conveying occurs as +part of a transaction in which the right of possession and use of the +User Product is transferred to the recipient in perpetuity or for a +fixed term (regardless of how the transaction is characterized), the +Corresponding Source conveyed under this section must be accompanied +by the Installation Information. But this requirement does not apply +if neither you nor any third party retains the ability to install +modified object code on the User Product (for example, the work has +been installed in ROM). + + The requirement to provide Installation Information does not include a +requirement to continue to provide support service, warranty, or updates +for a work that has been modified or installed by the recipient, or for +the User Product in which it has been modified or installed. Access to a +network may be denied when the modification itself materially and +adversely affects the operation of the network or violates the rules and +protocols for communication across the network. + + Corresponding Source conveyed, and Installation Information provided, +in accord with this section must be in a format that is publicly +documented (and with an implementation available to the public in +source code form), and must require no special password or key for +unpacking, reading or copying. + + 7. Additional Terms. + + "Additional permissions" are terms that supplement the terms of this +License by making exceptions from one or more of its conditions. +Additional permissions that are applicable to the entire Program shall +be treated as though they were included in this License, to the extent +that they are valid under applicable law. If additional permissions +apply only to part of the Program, that part may be used separately +under those permissions, but the entire Program remains governed by +this License without regard to the additional permissions. + + When you convey a copy of a covered work, you may at your option +remove any additional permissions from that copy, or from any part of +it. (Additional permissions may be written to require their own +removal in certain cases when you modify the work.) You may place +additional permissions on material, added by you to a covered work, +for which you have or can give appropriate copyright permission. + + Notwithstanding any other provision of this License, for material you +add to a covered work, you may (if authorized by the copyright holders of +that material) supplement the terms of this License with terms: + + a) Disclaiming warranty or limiting liability differently from the + terms of sections 15 and 16 of this License; or + + b) Requiring preservation of specified reasonable legal notices or + author attributions in that material or in the Appropriate Legal + Notices displayed by works containing it; or + + c) Prohibiting misrepresentation of the origin of that material, or + requiring that modified versions of such material be marked in + reasonable ways as different from the original version; or + + d) Limiting the use for publicity purposes of names of licensors or + authors of the material; or + + e) Declining to grant rights under trademark law for use of some + trade names, trademarks, or service marks; or + + f) Requiring indemnification of licensors and authors of that + material by anyone who conveys the material (or modified versions of + it) with contractual assumptions of liability to the recipient, for + any liability that these contractual assumptions directly impose on + those licensors and authors. + + All other non-permissive additional terms are considered "further +restrictions" within the meaning of section 10. If the Program as you +received it, or any part of it, contains a notice stating that it is +governed by this License along with a term that is a further +restriction, you may remove that term. If a license document contains +a further restriction but permits relicensing or conveying under this +License, you may add to a covered work material governed by the terms +of that license document, provided that the further restriction does +not survive such relicensing or conveying. + + If you add terms to a covered work in accord with this section, you +must place, in the relevant source files, a statement of the +additional terms that apply to those files, or a notice indicating +where to find the applicable terms. + + Additional terms, permissive or non-permissive, may be stated in the +form of a separately written license, or stated as exceptions; +the above requirements apply either way. + + 8. Termination. + + You may not propagate or modify a covered work except as expressly +provided under this License. Any attempt otherwise to propagate or +modify it is void, and will automatically terminate your rights under +this License (including any patent licenses granted under the third +paragraph of section 11). + + However, if you cease all violation of this License, then your +license from a particular copyright holder is reinstated (a) +provisionally, unless and until the copyright holder explicitly and +finally terminates your license, and (b) permanently, if the copyright +holder fails to notify you of the violation by some reasonable means +prior to 60 days after the cessation. + + Moreover, your license from a particular copyright holder is +reinstated permanently if the copyright holder notifies you of the +violation by some reasonable means, this is the first time you have +received notice of violation of this License (for any work) from that +copyright holder, and you cure the violation prior to 30 days after +your receipt of the notice. + + Termination of your rights under this section does not terminate the +licenses of parties who have received copies or rights from you under +this License. If your rights have been terminated and not permanently +reinstated, you do not qualify to receive new licenses for the same +material under section 10. + + 9. Acceptance Not Required for Having Copies. + + You are not required to accept this License in order to receive or +run a copy of the Program. Ancillary propagation of a covered work +occurring solely as a consequence of using peer-to-peer transmission +to receive a copy likewise does not require acceptance. However, +nothing other than this License grants you permission to propagate or +modify any covered work. These actions infringe copyright if you do +not accept this License. Therefore, by modifying or propagating a +covered work, you indicate your acceptance of this License to do so. + + 10. Automatic Licensing of Downstream Recipients. + + Each time you convey a covered work, the recipient automatically +receives a license from the original licensors, to run, modify and +propagate that work, subject to this License. You are not responsible +for enforcing compliance by third parties with this License. + + An "entity transaction" is a transaction transferring control of an +organization, or substantially all assets of one, or subdividing an +organization, or merging organizations. If propagation of a covered +work results from an entity transaction, each party to that +transaction who receives a copy of the work also receives whatever +licenses to the work the party's predecessor in interest had or could +give under the previous paragraph, plus a right to possession of the +Corresponding Source of the work from the predecessor in interest, if +the predecessor has it or can get it with reasonable efforts. + + You may not impose any further restrictions on the exercise of the +rights granted or affirmed under this License. For example, you may +not impose a license fee, royalty, or other charge for exercise of +rights granted under this License, and you may not initiate litigation +(including a cross-claim or counterclaim in a lawsuit) alleging that +any patent claim is infringed by making, using, selling, offering for +sale, or importing the Program or any portion of it. + + 11. Patents. + + A "contributor" is a copyright holder who authorizes use under this +License of the Program or a work on which the Program is based. The +work thus licensed is called the contributor's "contributor version". + + A contributor's "essential patent claims" are all patent claims +owned or controlled by the contributor, whether already acquired or +hereafter acquired, that would be infringed by some manner, permitted +by this License, of making, using, or selling its contributor version, +but do not include claims that would be infringed only as a +consequence of further modification of the contributor version. For +purposes of this definition, "control" includes the right to grant +patent sublicenses in a manner consistent with the requirements of +this License. + + Each contributor grants you a non-exclusive, worldwide, royalty-free +patent license under the contributor's essential patent claims, to +make, use, sell, offer for sale, import and otherwise run, modify and +propagate the contents of its contributor version. + + In the following three paragraphs, a "patent license" is any express +agreement or commitment, however denominated, not to enforce a patent +(such as an express permission to practice a patent or covenant not to +sue for patent infringement). To "grant" such a patent license to a +party means to make such an agreement or commitment not to enforce a +patent against the party. + + If you convey a covered work, knowingly relying on a patent license, +and the Corresponding Source of the work is not available for anyone +to copy, free of charge and under the terms of this License, through a +publicly available network server or other readily accessible means, +then you must either (1) cause the Corresponding Source to be so +available, or (2) arrange to deprive yourself of the benefit of the +patent license for this particular work, or (3) arrange, in a manner +consistent with the requirements of this License, to extend the patent +license to downstream recipients. "Knowingly relying" means you have +actual knowledge that, but for the patent license, your conveying the +covered work in a country, or your recipient's use of the covered work +in a country, would infringe one or more identifiable patents in that +country that you have reason to believe are valid. + + If, pursuant to or in connection with a single transaction or +arrangement, you convey, or propagate by procuring conveyance of, a +covered work, and grant a patent license to some of the parties +receiving the covered work authorizing them to use, propagate, modify +or convey a specific copy of the covered work, then the patent license +you grant is automatically extended to all recipients of the covered +work and works based on it. + + A patent license is "discriminatory" if it does not include within +the scope of its coverage, prohibits the exercise of, or is +conditioned on the non-exercise of one or more of the rights that are +specifically granted under this License. You may not convey a covered +work if you are a party to an arrangement with a third party that is +in the business of distributing software, under which you make payment +to the third party based on the extent of your activity of conveying +the work, and under which the third party grants, to any of the +parties who would receive the covered work from you, a discriminatory +patent license (a) in connection with copies of the covered work +conveyed by you (or copies made from those copies), or (b) primarily +for and in connection with specific products or compilations that +contain the covered work, unless you entered into that arrangement, +or that patent license was granted, prior to 28 March 2007. + + Nothing in this License shall be construed as excluding or limiting +any implied license or other defenses to infringement that may +otherwise be available to you under applicable patent law. + + 12. No Surrender of Others' Freedom. + + If conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot convey a +covered work so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you may +not convey it at all. For example, if you agree to terms that obligate you +to collect a royalty for further conveying from those to whom you convey +the Program, the only way you could satisfy both those terms and this +License would be to refrain entirely from conveying the Program. + + 13. Use with the GNU Affero General Public License. + + Notwithstanding any other provision of this License, you have +permission to link or combine any covered work with a work licensed +under version 3 of the GNU Affero General Public License into a single +combined work, and to convey the resulting work. The terms of this +License will continue to apply to the part which is the covered work, +but the special requirements of the GNU Affero General Public License, +section 13, concerning interaction through a network will apply to the +combination as such. + + 14. Revised Versions of this License. + + The Free Software Foundation may publish revised and/or new versions of +the GNU General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + + Each version is given a distinguishing version number. If the +Program specifies that a certain numbered version of the GNU General +Public License "or any later version" applies to it, you have the +option of following the terms and conditions either of that numbered +version or of any later version published by the Free Software +Foundation. If the Program does not specify a version number of the +GNU General Public License, you may choose any version ever published +by the Free Software Foundation. + + If the Program specifies that a proxy can decide which future +versions of the GNU General Public License can be used, that proxy's +public statement of acceptance of a version permanently authorizes you +to choose that version for the Program. + + Later license versions may give you additional or different +permissions. However, no additional obligations are imposed on any +author or copyright holder as a result of your choosing to follow a +later version. + + 15. Disclaimer of Warranty. + + THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY +APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT +HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY +OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM +IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF +ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. Limitation of Liability. + + IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS +THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY +GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE +USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF +DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD +PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), +EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF +SUCH DAMAGES. + + 17. Interpretation of Sections 15 and 16. + + If the disclaimer of warranty and limitation of liability provided +above cannot be given local legal effect according to their terms, +reviewing courts shall apply local law that most closely approximates +an absolute waiver of all civil liability in connection with the +Program, unless a warranty or assumption of liability accompanies a +copy of the Program in return for a fee. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +state the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . + +Also add information on how to contact you by electronic and paper mail. + + If the program does terminal interaction, make it output a short +notice like this when it starts in an interactive mode: + + Copyright (C) + This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, your program's commands +might be different; for a GUI interface, you would use an "about box". + + You should also get your employer (if you work as a programmer) or school, +if any, to sign a "copyright disclaimer" for the program, if necessary. +For more information on this, and how to apply and follow the GNU GPL, see +. + + The GNU General Public License does not permit incorporating your program +into proprietary programs. If your program is a subroutine library, you +may consider it more useful to permit linking proprietary applications with +the library. If this is what you want to do, use the GNU Lesser General +Public License instead of this License. But first, please read +. diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/doc/LICENSE b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/doc/LICENSE new file mode 100755 index 0000000..b02dd2b --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/doc/LICENSE @@ -0,0 +1,19 @@ +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License version 3 as +published by the Free Software Foundation. + +For more information on ODB licensing as well as for answers to +some of the common licensing questions, visit the ODB License +page: + +http://www.codesynthesis.com/products/odb/license.xhtml + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for details. + +You should have received a copy of the GNU General Public License +along with this program; if not, see: + +http://www.codesynthesis.com/licenses/gpl-3.txt diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/doc/NEWS b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/doc/NEWS new file mode 100755 index 0000000..e3fb145 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/doc/NEWS @@ -0,0 +1,800 @@ +Version 2.4.0 + + * Support for object loading views. Object loading views allow loading of + one or more complete objects instead of, or in addition to, a subset of + data member and with a single SELECT statement execution. For details, + refer to Section 10.2, "Object Loading Views" in the ODB manual. + + * Support for bulk operations in Oracle and SQL Server. Bulk operations + persist, update, or erase a range of objects using a single database + statement execution which often translates to a significantly better + performance. For details, refer to Section 15.3, "Bulk Database + Operations" in the ODB manual. + + * New database class functions, query_one() and query_value(), provide + convenient shortcuts for situations where the query is known to return + at most one element (query_one) or exactly one element (query_value). + Corresponding execute_one() and execute_value() functions for prepared + queries are also provided. For details, refer to Sections 4.3, "Executing + a Query" and 4.5, "Prepared Queries" in the ODB manual. + + * Support for defining persistent objects as instantiations of C++ class + templates, similar to composite value types. For details, refer to + Section 15.2, "Persistent Class Template Instantiations" in the ODB + manual. + + * Support for object and table join types in views. Supported join type + are left, right, full, inner, and cross with left being the default. + For details, refer to Sections 10.1, "Object Views" and 10.3, "Table + Views" in the ODB manual. + + * Support for result modifiers in view query conditions. Currently + supported result modifiers are 'distinct' (which is translated to + SELECT DISTINCT) and 'for_update' (which is translated to FOR UPDATE or + equivalent for database systems that support it). For details, refer to + Section 10.5, "View Query Conditions" in the ODB manual. + + * Support for persisting std::deque containers. + + * New pragma, on_delete, allows the specification of an on-delete semantics + (translated to the ON DELETE SQL clause) for an object pointer. For more + information, refer to Section 14.4.15, "on_delete" in the ODB manual. + + * Besides odb::stderr_tracer there is now odb::stderr_full_tracer that + traces statement preparations and deallocations in addition to their + executions. This new implementation can be useful when you want to see + the text of a statement that contains a syntax error and therefore + will not actually be executed. For more information, refer to Section + 3.13, "Tracing SQL Statement Execution" in the ODB manual. + + * ODB can now compile headers that use #pragma once instead of include + guards. + + * User-supplied prologues and epilogues are now generated outside the + pre.hxx/post.hxx includes. This allows the use of precompiled headers + with the generated files. + + * Support for calling MySQL stored procedures. For details and limitations + refer to Section 17.7, "MySQL Stored Procedures" in the ODB manual. + + * Support for calling SQL Server stored procedures. For details and + limitations refer to Section 21.7, "SQL Server Stored Procedures" in + the ODB manual. + + * New option, --oracle-warn-truncation, makes ODB warn about SQL names + that are longer than 30 characters and are therefore truncated. ODB + now also detects when such truncations lead to Oracle name conflicts + and issues diagnostics even without this option specified. + + * For MySQL, PostgreSQL, and SQL Server, ODB now warns when an SQL name + exceeds the database limit (64, 63, and 128 characters, respectively). + SQLite has no limitation on name lengths. For Oracle, which has a limit + that is much more likely to be reached in normal circumstances (30 + characters), a more comprehensive detection is implemented (see the item + above). + + * New option, --statement-regex, can be used to process prepared statement + names that are used by PostgreSQL. This can be useful, for example, to + shorten names that exceed the PostgreSQL name limit. + + * The --std option now accepts the 'c++14' value. + +Version 2.3.0 + + * Support for database schema evolution, including schema migration, data + migration, and soft model changes. For more information, refer to Chapter + 13, "Database Schema Evolution" in the ODB manual. + + * Support for object sections. Sections are an optimization mechanism that + allows the partitioning of data members of a persistent class into groups + that can be loaded and/or updated separately. For more information, refer + to Chapter 9, "Sections" in the ODB manual as well as the 'section' + example in the odb-examples package. + + * Support for automatic mapping of C++11 enum classes in addition to "old" + enums. For more information, refer to the ODB manual "Type Mapping" + sections for each database system. + + * Support for defining composite value types inside persistent classes, + views, and other composite values. For more information, refer to Section + 7.2, "Composite Value Types" in the ODB manual. + + * Support for pattern matching (SQL LIKE operator) in the C++-integrated + queries. For more information, refer to Section 4.1, "ODB Query Language" + in the ODB manual. + + * The schema_catalog::create_schema() function now has a third argument + which indicates whether to drop the schema prior to creating the new one. + The default is true which is backwards-compatible. The schema_catalog + class now also provides the drop_schema() function which allows you to + drop the schema without creating the new one. Finally, the exists() + function now has the schema name argument which by default is an empty + string (the default schema name). For more information, refer to Section + 3.4, "Database" in the ODB manual. + + * The transaction class now provides the default constructor that allows + the creation of finalized transactions which can then be re-initialized + with the reset() function. The finalized() accessor has also been added + which allows querying of the finalization state. For more information, + refer to Section 3.5, "Transactions" in the ODB manual. + + * New option, --fkeys-deferrable-mode, specifies the alternative deferrable + mode for foreign keys. By default, the ODB compiler generates deferred + foreign keys for databases that support them (SQLite, PostgreSQL, and + Oracle) and comments the foreign keys out for databases that don't (MySQL + and SQL Server). This option can be used to override this behavior. Refer + to the ODB compiler command line interface documentation (man pages) for + details. + + * Starting with MySQL version 5.6.4 it is possible to store fractional + seconds up to microsecond precision in TIME, DATETIME, and TIMESTAMP + columns. Both Boost and Qt profiles have been updated to support this + new functionality. Note, however, that to enable sub-second precision, + the corresponding type with the desired precision has to be specified + explicitly. For details, refer to the "MySQL Database Type Mapping" + sections in the Boost and Qt profile chapters. + + * New SQLite-specific exception, odb::sqlite::forced_rollback, which is + thrown if SQLite forces a transaction to roll back. For more information, + refer to Section 16.5.6, "Forced Rollback" in the ODB manual. + + * New options, --pgsql-server-version, can be used to specify the minimum + PostgreSQL server version with which the generated C++ code and schema + will be used. Right now this information is used to enable the use of + the IF NOT EXISTS clause in the CREATE TABLE statement for the schema + version table creation in PostgreSQL 9.1 and later. Refer to the ODB + compiler command line interface documentation (man pages) for details. + + * The --output-name option has been renamed to --input-name, which is more + semantically correct. + + * The generated database schema now explicitly specify NULL for nullable + columns. + + * The generated separate C++ schema file (--schema-format separate) no + longer includes the generated header file (-odb.hxx). As a result, it is + now possible to use the --generate-schema-only and --at-once options to + generate a combined C++ schema file for several headers. + +Version 2.2.0 + + * Multi-database support. This mechanism allows an application to + simultaneously work with multiple database systems and comes in two + flavors: static and dynamic. With static support the application uses + the static database interfaces (that is, odb::::database instead + of odb::database). With dynamic support the same application code can + access multiple databases via a common interface. Dynamic multi-database + supports also allows the application to dynamically load the database + support code for individual database systems if and when necessary. For + more information, refer to Chapter 14, "Multi-Database Support" in the + ODB manual. + + * Support for prepared queries. Prepared queries are a thin wrapper around + the underlying database system's prepared statements functionality. They + provide a way to perform potentially expensive query preparation tasks + only once and then execute the query multiple times. For more information, + refer to Section 4.5, "Prepared Queries" in the ODB manual as well as the + 'prepared' example in the odb-examples package. + + * Mapping for char[N] and std::array to database VARCHAR(N-1) (or + similar) as well as for char to database CHAR(1) (or similar). For SQL + Server and SQLite on Windows equivalent mappings for wchar_t are also + provided. Also the query support for arrays has been improved to allow + passing a value of the decayed type (pointer) as a query parameter. + For more information, refer to the ODB manual "Type Mapping" sections + for each database system. + + * Support for change-tracking std::vector and QList container equivalents. + Change-tracking containers minimize the number of database operations + necessary to synchronize the container state with the database. For + more information, refer to Sections 5.4, "Change-Tracking Containers", + 5.4.1 "Change-Tracking vector", and 22.3.1, "Change-Tracking QList" + in the ODB manual. + + * Support for automatically-derived SQL name transformations (table, column, + index, etc). At the higher level, it is possible to assign prefixes and + suffixes (--table-prefix, --{index,fkey,sequence}--suffix options) as + well as to convert to upper or lower case (--sql-name-case option). At + the lower level, it is possible to specify transformations as regular + expressions (--{table,column,index,fkey,sequence,sql-name}-regex options). + For more information, refer to the SQL NAME TRANSFORMATIONS section in + the ODB compiler command line interface documentation (man pages). + + * New options, --export-symbol and --extern-symbol, allow DLL-exporting of + the generated database support code. + + * Support for transaction post- commit/rollback callbacks. For more + information, refer to Section 13.1, "Transaction Callbacks" in the ODB + manual. + + * Support for custom session implementations. For more information, refer + to Section 10.2, "Custom Sessions" in the ODB manual. + + * Support for early connection release. Now the database connection is + released when commit()/rollback() is called rather than when the + transaction instance goes out of scope. + + * New odb::schema_catalog function, exists(), can be used to check whether + a schema with the specified name exists in the catalog. + + * Support for SQL Server ROWVERSION-based optimistic concurrency. For more + information, refer to Section 19.1.1, "ROWVERSION Support" in the ODB + manual. + + * Support for specifying the SQL Server transaction isolation level. For + more information, refer to Section 19.2, "SQL Server Database Class" in + the ODB manual. + + * Support for "smart" containers. A smart container is provided with + additional functions which allow it to insert, update, and delete + individual elements in the database. Change-tracking containers are + examples of smart containers that utilizes this new functionality. + Currently only ordered smart containers are supported. Note also that + with this addition the names of the database functions provided by the + ODB compiler (see libodb/odb/container-traits.hxx) have changed. This + will only affect you if you have added ODB persistence support for a + custom container. + +Version 2.1.0 + + * The ODB compiler is now capable of automatically discovering accessor and + modifier functions for inaccessible data members in persistent classes, + composite value types, and views. It will then use these accessors and + modifiers in the generated code instead of trying to access such data + members directly. The names of these functions are derived from the + data member names and, by default, the ODB compiler will look for names + in the form: get_foo/set_foo, getFoo/setFoo, getfoo/setfoo, and just + foo. You can also add custom name derivations with the --accessor-regex + and --modifier-regex ODB compiler options. For more information, refer + to Section 3.2, "Declaring Persistent Objects and Values" in the ODB + manual. + + * New pragmas, get, set, and access, allow the specification of custom + accessor and modifier expressions for data members in persistent classes, + composite value types, and views. For more information, refer to Section + 12.4.5, "get/set/access" in the ODB manual as well as the 'access' example + in the odb-examples package. + + * New pragma, virtual, allows the declaration of virtual data members. A + virtual data member is an imaginary data member that is only used for + the purpose of database persistence. This mechanism can be useful to + aggregate or dis-aggregate real data members, implement the pimpl idiom, + and to handle third-party types for which names of real data members may + not be known. For more information, refer to Section 12.4.13, "virtual" + in the ODB manual as well as the 'access' and 'pimpl' examples in the + odb-examples package. + + * Support for defining database indexes. Both simple and composite indexes + can be defined with support for database-specific index types, methods, + and options. For more information, refer to Section 12.6, "Index + Definition Pragmas" as well as Sections [13-17].16, " Index + Definition" in the ODB manual. + + * Support for mapping extended database types, such as geospatial types, + user-defined types, and collections. This mechanism allows you to map + any database type to one of the types for which ODB provides built-in + support (normally string or binary). The text or binary representation + of the data can then be extracted into a C++ data type of your choice. + For more information, refer to Section 12.7, "Database Type Mapping + Pragmas" in the ODB manual. + + * The Boost profile now provides persistence support for the Boost Multi- + Index container (boost::multi_index_container). For more information, + refer to Section 19.3, "Multi-Index Container Library" in the ODB manual. + + * The Boost profile now provides persistence support for the Boost uuid type + (boost::uuids::uuid). For more information, refer to Section 19.6, "Uuid + Library" in the ODB manual as well as the 'boost' example in the odb- + examples package. + + * The Qt profile now provides persistence support for the QUuid type. For + more information, refer to Section 20.1, "Basic Types" in the ODB manual + as well as the 'qt' example in the odb-examples package. + + * SQLite improvements: Persistence support for std::wstring on Windows + (Section 14.1, "SQLite Type Mapping"). Ability to pass the database + name as std::wstring on Windows (Section 14.2, "SQLite Database Class"). + Ability to specify the virtual filesystem (vfs) module in the database + constructors (Section 14.2, "SQLite Database Class"). + + * Support for mapping C++11 std::array and std::array types to BLOB/BINARY database types. For more information, + refer to Sections [13-17].1, " Type Mapping" in the ODB manual. + + * Support for mapping the char[16] array to PostgreSQL UUID and SQL Server + UNIQUEIDENTIFIER types. For more information, refer to Sections 15.1, + "PostgreSQL Type Mapping" and 17.1, "SQL Server Type Mapping" in the + ODB manual. + + * New option, --output-name, specifies the alternative base name used to + construct the names of the generated files. Refer to the ODB compiler + command line interface documentation (man pages) for details. + + * New option, --generate-schema-only, instructs the ODB compiler to + generate the database schema only. Refer to the ODB compiler command + line interface documentation (man pages) for details. + + * New option, --at-once, triggers the generation of code for all the input + files as well as for all the files that they include at once. Refer to + the ODB compiler command line interface documentation (man pages) for + details. + + * New options, --sql-interlude and --sql-interlude-file, allow the insertion + of custom SQL between the DROP and CREATE statements in the generated + database schema file. + + * New options, --omit-drop and --omit-create, trigger the omission of DROP + and CREATE statements, respectively, from the generated database schema. + + * New ODB manual Section, 6.3 "Circular Relationships", explains how to + handle persistent classes with circular dependencies that are defined + in separate headers. + + * The id() pragma that was used to declare a persistent class without an + object id has been renamed to no_id. + + * New pragma, definition, allows the specification of an alternative code + generation point for persistent classes, views, and composite value + types. This mechanism is primarily useful for converting third-party + types to ODB composite value types. For more information, refer to + Section 12.3.7, "Definition" in the ODB manual. + + * The session constructor now accepts an optional bool argument (true by + default) which indicates whether to make this session current for this + thread. For more information, refer to Chapter 10, "Session" in the ODB + manual. + + * Simplified Oracle automatically-assigned object id implementation that + does not rely on triggers. + + * Support for mapping boost::posix_time::ptime and QDateTime to the DATE + Oracle type. For more information, refer to Sections 19.4.4 (Boost) and + 20.4.4 (Qt) in the ODB manual. + + * Default SQLite mapping for float and double now allows NULL since SQLite + treats NaN FLOAT values as NULL. For more information, refer to Section + 14.1, "SQLite Type Mapping" in the ODB manual. + +Version 2.0.0 + + * Support for C++11. The newly supported C++11 standard library components + include: + - std::unique_ptr as object pointer or value wrapper + - odb::lazy_unique_ptr lazy counterpart + - std::shared_ptr/weak_ptr as object pointer or value wrapper + - odb::lazy_shared_ptr/lazy_weak_ptr lazy counterparts + - support for array, forward_list, and unordered containers + - connection factory can be passed to the database constructor as + std::unique_ptr instead of std::auto_ptr + + The ODB compiler now recognizes the --std option. Valid values for this + option are 'c++98' (default) and 'c++11'. In the runtime libraries the + C++11 support is header-only which means that the same build of a runtime + library can be used in both the C++98 and C++11 modes. On UNIX, the tests + and examples can be compiled in the C++11 mode by passing the necessary + options to turn the C++ compiler into this mode (e.g., -std=c++0x GCC + option). On Windows, the tests and examples are always built in the C++11 + mode with VC++ 10 and later. The new 'c++11' example in the odb-examples + package shows ODB support for some of the C++11 features. + + * Support for polymorphism. Now a persistent class hierarchy can be + declared polymorphic which makes it possible to persist, load, update, + erase, and query objects of derived classes using their base class + interfaces. For more information, refer to Chapter 8, "Inheritance" in + the ODB manual as well as the 'inheritance/polymorphism' example in the + odb-examples package. + + * Support for composite object ids. Now a composite value type can be used + to declare an object id member. For more information, refer to Section + 7.2.1, "Composite Object Ids" in the ODB manual as well as the 'composite' + example in the odb-examples package. + + * Support for the NULL value semantics for composite values. For more + information, refer to Section 7.3, "Pointers and NULL Value Semantics" + in the ODB manual. + + * New schema format (--schema-format), 'separate', allows the generation + of the schema creation code into a separate C++ source file (called + '-schema.cxx' by default). This value is primarily useful if you + want to place the schema creation functionality into a separate program + or library. + + * New namespace-level pragmas: table, pointer. The table pragma specifies + the table prefix that is added to table names for all the persistent + classes inside a namespace. The pointer pragma specifies the default + pointer type to be used for persistent classes and views inside a + namespace. For more information, refer to Section 12.5.1, "pointer" and + Section 12.5.2, "table" in the ODB manual. + + * Session support is now optional and is disabled by default. This is a + backwards-incompatible change. Session support can be enabled on the + per class basis or at the namespace level using the new session pragma. + It can also be enabled by default for all the persistent classes using + the --generate-session ODB compiler option. Thus, to get the old behavior + where all the objects were session-enabled, simply add --generate-session + to your ODB compiler command line. For more information, refer to Chapter + 10, "Session" in the ODB manual. + + * The semantics of the database operations callbacks has changed with + respect to object const-ness. This is a backwards-incompatible change. + Now the callback function for the *_persist, *_update, and *_erase events + is always called on the constant object reference while for the *_load + events -- always on the unrestricted reference. For more information, + refer to Section 12.1.7, "callback" in the ODB manual. + + * New function, transaction::reset(), allows the reuse of the same + transaction instance to complete several database transactions. For more + information, refer to Section 3.4, "Transactions" in the ODB manual. + + * New exception, odb::session_required, is thrown when ODB detects that + correctly loading a bidirectional object relationship requires a session + but one is not used. For more information, refer to Section 6.2, + "Bidirectional Relationships" in the ODB manual. + +Version 1.8.0 + + * Support for the Microsoft SQL Server database. The provided connection + factories include 'new' (a new connection is created every time one is + requested) and 'pool' (a pool of connections is maintained). The Boost + and Qt profiles have been updated to support this database. For more + information, refer to Chapter 17, "Microsoft SQL Server Database" in + the ODB manual. + + * Support for defining composite value types as C++ class template + instantiations. For more information, refer to Section 7.2, "Composite + Value Types" in the ODB manual as well as the 'composite' example in the + odb-examples package. + + * Support for database schemas ("database namespaces"). A schema can be + specified for a persistent class, for a C++ namespace (the schema then + applies to all the persistent classes within this namespace), and for a + file with the --schema ODB compiler option. For more information, refer + to Section 12.1.8, "schema" in the ODB manual. + + * The --default-schema option has been renamed to --schema-name. + + * The default Oracle mapping for std::string has changed from VARCHAR2(4000) + to VARCHAR2(512). + +Version 1.7.0 + + * Support for the Oracle database. The provided connection factories + include 'new' (a new connection is created every time one is requested) + and 'pool' (a pool of connections is maintained). The Boost and Qt + profiles have been updated to support this database. For more information, + refer to Chapter 16, "Oracle Database" in the ODB manual. + + * Support for optimistic concurrency. For more information refer to Chapter + 11, "Optimistic Concurrency" in the ODB manual as well as the 'optimistic' + example in the odb-examples package. + + * Support for read-only objects, composite value types, and data members. + The new readonly pragma can be used to declare one of these entities as + read-only. Constant data members are automatically treated as read-only. + For more information, refer to Section 12.1.4 "readonly (object)", + Section 12.3.6 "readonly (composite value)", and Section 12.4.10 + "readonly (data member)" in the ODB manual. + + * Support for persistent classes without object identifiers. Such classes + have to be explicitly declared as not having an object id and they have + limited functionality. For more information, refer to Section 12.1.5 + "id" in the ODB manual. + + * Support for SQL statement execution tracing. For more information, refer + to Section 3.12 "Tracing SQL Statement Execution" in the ODB manual. + + * Support for mapping char[N], unsigned char[N], and std::vector to the BLOB (or equivalent) types. For more information, refer to + Chapters 13 (for MySQL), 14 (for SQLite), 15 (for PostgreSQL), and 16 + (for Oracle) in the ODB manual. + + * Query result iterator now provides the id() function which allows one + to get the object id without loading the object. For more information, + refer to Section 4.4 "Query Result" in the ODB manual. + + * Support for microsecond precision in Boost and Qt date-time types + mapping to PostgreSQL date-time data types. Additionally, Qt QDateTime + values stored in a PostgreSQL database can now be earlier than the UNIX + epoch. + +Version 1.6.0 + + * New concept, view, is a C++ class that embodies a light-weight, read- + only projection of one or more persistent objects or database tables + or the result of a native SQL query execution. Some of the common + applications of views include loading a subset of data members from + objects or columns from database tables, executing and handling + results of arbitrary SQL queries, including aggregate queries, as + well as joining multiple objects and/or database tables using object + relationships or custom join conditions. For more information refer + to Chapter 9, "Views" in the ODB manual as well as the 'view' example + in the odb-examples package. + + * New function, database::erase_query(), allows the deletion of the + database state of multiple objects matching certain criteria. It uses + the same query expression as the database::query() function. For more + information, refer to Section 3.10, "Deleting Persistent Objects" in + the ODB manual. + + * Support for value wrappers. An ODB value wrapper is a class template + that wraps a value type or a container. Common examples of wrappers + are smart pointers, holders, and "optional value" containers such as + boost::optional. A wrapper can be transparent or it can handle the + NULL semantics. To allow the easy conversion of value types that do + not support the NULL semantics into the ones that do, the odb::nullable + class template has been added. ODB now also includes built-in support for + std::auto_ptr and std::tr1::shared_ptr smart pointers as value wrappers + as well as for boost::shared_ptr and QSharedPointer via the Boost and Qt + profiles. Currently, the NULL semantics is only supported for simple + values but smart pointers can still be used with composite values and + containers. For more information, refer to Section 7.3, "NULL Value + Semantics" in the ODB manual. + + * Support for the boost::optional container in the Boost profile. A data + member of the boost::optional type is mapped to a column that can have + a NULL value. For more information, refer to Section 15.3 "Optional + Library" in the ODB manual. + + * Support for mapping std::vector to the BLOB (or equivalent) types. + For more information, refer to Chapters 11 (for MySQL), 12 (for SQLite) + and 13 (for PostgreSQL) in the ODB manual. + + * New option, --table-prefix, allows the specification of a prefix that + is added to table and index names. For more information, refer to the + ODB compiler command line interface documentation (man pages). + + * New ODB runtime library interface, odb::connection, represents a + connection to the database. The primary use case for a connection is to + execute native statements outside of a transaction. For more information, + refer to Section 3.5, "Connections" in the ODB manual. + + * Support for multiplexing several transactions on the same thread. For + more information, refer to Section 3.4, "Transactions" in the ODB + manual. + + * All the concrete connection classes now have a second constructor which + allows the creation of a connection instance from an already established + underlying connection handle. The connection_pool_factory and, in case of + SQLite, single_connection_factory now have a virtual create() function + that can be overridden to implement custom connection establishment and + configuration. + + * The query expression syntax for object pointers and composite values has + changed. Now, instead of using the scope resolution operator ('::'), the + member access via a pointer operator (->) is used for object pointers and + the member access operator (.) is used for composite values. Examples of + old and new syntax for pointers, old: query::employer::name, + new: query::employer->name. For composites values, old: + query::name::first, new: query::name.first. + + * SQLite ODB runtime now enables foreign key constraints checking by + default. While this should not affect correct applications, due to + bugs in SQLite DDL foreign keys support, you may need to temporarily + disable foreign key constraints checking when re-creating the database + schema (the sign that you may need to do so is the "foreign key + constraint failed" exception thrown by the commit() function after the + call to schema_catalog::create_schema()). For more information, refer + to Section 12.5.3, "Foreign Key Constraints" in the ODB manual. + + * Support for specifying the client character set for the MySQL database. + For more information, refer to Section 11.2, "MySQL Database Class" in + the ODB manual. + + * Object cache maintained by a session no longer distinguishes between + const and non-const objects. Instead, const objects are treated as + non-const by casting away constness. For more information on this new + behavior, refer to Section 9.1, "Object Cache" in the ODB manual. + +Version 1.5.0 + + * Support for the PostgreSQL database. The provided connection factories + include 'new' (a new connection is created every time one is requested) + and 'pool' (a pool of connections is maintained). The Boost and Qt + profiles have been updated to support this database. For more information, + refer to Chapter 13, "PostgreSQL Database" in the ODB manual. + + * New handling of the NULL semantics. Now, instead of being specified as + part of the SQL type with the type pragma, there are separate null and + not_null pragmas. The not_null pragma was used to control the NULL + semantics of object pointers. Now the two pragmas are used consistently + for object pointers and simple values (and, in the future, they will work + for composite values and containers). To control the NULL semantics of + the container's element values, the value_null and value_not_null pragmas + have been added, similar to the value_type, value_column, etc., pragmas. + For more information about the new mechanism, refer to Sections 10.2.3, + 10.2.8, 10.3.4, and 10.3.13 in the ODB manual. + + This is a backwards-incompatible change. Existing use cases that will + require manual changes are listed below. + + For pragmas that apply to simple value types and data members of + such types: + + #pragma db type("TEXT NOT NULL") => #pragma db type("TEXT") + #pragma db type("TEXT NULL") => #pragma db type("TEXT") null + #pragma db type("TEXT") => #pragma db type("TEXT") null + + For pragmas that apply to containers of pointers and data members of + such types: + + #pragma db not_null => #pragma db value_not_null + + * New pragma, default, allows the specification of the database default + value. For more information, refer to Section 10.3.5, "default" in the + ODB manual. + + * New pragmas, options, id_options, index_options, key_options, and + value_options, allow the specification of additional column definition + options. For more information, refer to Section 10.3.6, "options" in + the ODB manual. + + * Support for database operations callbacks. Now a persistent class can + register a callback function that will be called before and after every + database operation (such as persist, load, update, or erase) is performed + on an object of this class. A database operations callback can be used to + implement object-specific pre and post initializations, registrations, + and cleanups. For more information and an example, refer to Section + 10.1.4, "callback" in the ODB manual. + + * New option, --include-regex, allows the modification of the #include + directive paths generated by the ODB compiler. This is primarily useful + when placing the generated code into subdirectories and the #include + directives have to be adjusted accordingly. The --include-regex-trace + option is useful for debugging the expressions specified with + --include-regex. + +Version 1.4.0 + + * New profile, qt, provides persistence support for the Qt framework. This + version covers the most commonly used basic types, date-time types, smart + pointers, and containers. The qt profile implementation is provided by the + libodb-qt library. For more information refer to Chapter 13, "Profiles + Introduction" and Chapter 15, "Qt Profile" in the ODB manual as well as + the 'qt' example in the odb-examples package. + + * Support for non-polymorphic object inheritance, including the new abstract + pragma. For more information refer to Chapter 8, "Inheritance" in the ODB + manual as well as the 'inheritance' example in the odb-examples package. + + * Automatic mapping of C++ enumerations to suitable database types. In + database systems that support enumeration types (such as MySQL), a C++ + enum is mapped to such a type (for example, ENUM('red', 'green', 'blue') + in MySQL). Otherwise, it is mapped to a suitable integer type. Refer to + Part II, "Database Systems" in the ODB manual for more details on the + provided mappings. + + * New pragma, id_type, allows the specification of the native database type + that should be used for data members designated as object identifiers. In + combination with the type pragma, id_type allows you to map a C++ type + differently depending on whether it is used in an ordinary member or an + object id. + + * New options, --odb-prologue-file and --odb-epilogue-file, allow the + inclusion of file contents into the ODB compilation. + + * Default mapping of the size_t and std::size_t types to a 64-bit integer + database type irrespective of the platform width. This can be overridden + with the type pragma. + +Version 1.3.0 + + * Support for the SQLite database. The provided connection factories include + 'new' (a new connection is created every time one is requested), 'single' + (single connection is shared among all the callers), and 'pool' (a pool + of connections is maintained). In multi-threaded applications the runtime + uses the SQLite shared cache and unlock notification features to aid + concurrency. For more information, refer to Chapter 11, "SQLite Database" + in the ODB manual. + + * Support for database-specific profiles. Now the ODB compiler first looks + for the -.options file and only if this file is not + found, does it fall back to .options. + + * Support for the GCC 4.6 plugin interface changes. + +Version 1.2.0 + + * New profile, boost, provides persistence support for the Boost libraries. + This version covers the most commonly used types from the smart_ptr, + unordered, and date_time libraries. The boost profile implementation is + provided by the libodb-boost library. For more information refer to + Chapter 11, "Profiles Introduction" and Chapter 12, "Boost Profile" in + the ODB manual as well as the 'boost' example in the odb-examples package. + + * Support for embedded database schemas. The new option, --schema-format, + allows the selection of the schema format. The valid values for this + option are 'sql' for a standalone SQL file and 'embedded' for a schema + embedded into the generated C++ code. The new odb::schema_catalog class + provides support for accessing embedded schemas from within the + application. For details refer to Section 3.3, "Database" in the ODB + manual as well as the 'schema/embedded' example in the odb-examples + package. + + * New exceptions: odb::recoverable, odb::connection_lost, and odb::timeout. + The odb::recoverable exception is a common base class for all recoverable + ODB exceptions. The other two exceptions plus odb::deadlock now inherit + from this base. Refer to Section 3.5, "Error Handling and Recovery" for + details. + + * Support for connection validation (ping) in MySQL connection_pool_factory. + This transparently deals with the MySQL server closing connections after + a certain period of inactivity. + + * New namespace, odb::core, contains using-declarations for the core ODB + constructs, such as the database, transaction, etc. The primary use of + this namespace is in the using-directives: + + using namespace odb::core; + + The above form should be preferred over the old variant: + + using namespace odb; + + The new approach brings all the essential ODB names into the current + namespace without any of the auxiliary objects such as traits, etc., which + minimizes the likelihood of conflicts with other libraries. Note that you + should still use the odb namespace when qualifying individual names, for + example, odb::database. + + * New option aliases: -q for --generate-query and -s for --generate-schema. + + * Support for the default options file. Now, if configured, the ODB compiler + loads the default options file (by default ../etc/odb/default.options, + relative to the ODB compiler binary). This file can be used for + installation-wide customization, such as adding extra include search + paths. + +Version 1.1.0 + + * Support for storing containers in the database. For more information refer + to Chapter 5, "Containers" in the ODB manual as well as the 'container' + example in the odb-examples package. + + * Support for unidirectional and bidirectional object relationships, + including lazy loading. For more information refer to Chapter 6, + "Relationships" in the ODB manual as well as the 'relationship' and + 'inverse' examples in the odb-examples package. + + * Support for composite value types. For more information refer to Chapter + 7, "Composite Value Types" in the ODB manual as well as the 'composite' + example in the odb-examples package. + + * Support for sessions. A session is an application's unit of work that + may encompass several database transactions. In this version of ODB a + session is just an object cache. For more information refer to Chapter + 8, "Session" in the ODB manual. + + * Support for custom object pointers that allows you to use smart pointers + to return, pass, and cache persistent objects. See Section 3.2, "Object + Pointers" in the ODB manual for details. + + * Support for native SQL statement execution. See Section 3.9, "Executing + Native SQL Statements" in the ODB manual for details. + + * New option, --profile/-p, instructs the ODB compiler to use the specified + profile library. See the ODB compiler command line manual for details. + + * Support for literal names (template-id, derived type declarator such as + pointers, etc) in data member declarations. Now, for example, you can use + std::vector directly instead of having to create a typedef + alias for it. + + * Support for inheritance from transient base types for object types and + composite value types. + + * New example, 'schema/custom', shows how to map persistent C++ classes to + a custom database schema. + + * New options, --odb-prologue, --odb-epilogue, allow inclusion of extra code + into the ODB compilation process. This can be useful for making additional + traits specializations or ODB pragmas known to the ODB compiler. + + * Support for persistent classes without default constructors. For objects + of such classes only the load() and find() database functions that + populate an existing instance can be used. Similarly, only the load() + query result iterator function which populates an existing instance can + be used. + +Version 1.0.0 + + * Initial release. diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/doc/README b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/doc/README new file mode 100755 index 0000000..90078e5 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/doc/README @@ -0,0 +1,20 @@ +ODB is an object-relational mapping (ORM) system for C++. It provides +tools, APIs, and library support that allow you to persist C++ objects +to a relational database (RDBMS) without having to deal with tables, +columns, or SQL and without manually writing any of the mapping code. +For more information see: + +http://www.codesynthesis.com/products/odb/ + +This package contains the ODB compiler and the ODB system documentation. + +See the NEWS file for the user-visible changes from the previous release. + +See the LICENSE file for distribution conditions. + +See the INSTALL file for prerequisites and installation instructions. + +See the doc/ directory for documentation. + +Send questions, bug reports, or any other feedback to the +odb-users@codesynthesis.com mailing list. diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/doc/default.css b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/doc/default.css new file mode 100755 index 0000000..889f46b --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/doc/default.css @@ -0,0 +1,323 @@ +html { + margin : 0; + padding : 0; + background : white; +} + +body { + font-family : "Lucida Grande", Verdana, "Bitstream Vera Sans", sans-serif; + font-weight : normal; + font-size : 13px; + line-height : 19px; + + color : black; + + margin : 0 2em 0 2em; + padding : 0; +} + + +body { + min-width: 40em; +} + +#container { + max-width : 46em; + margin : 0 auto; + padding : 0 1em 0 1em; +} + + + +/* + * Footer + * + */ +#footer { + color : #3a84a7; + + padding : 1em 0 0.5em 0; + + font-size : 10px; + line-height : 15px; + + text-align: center; +} + +#footer a:link, #footer a:visited { + + color:#1d6699; + text-decoration: underline; +} + +#footer a { + margin-left: 0.7em; + margin-right: 0.7em; +} + +#footer p { + padding: 0; + margin: 0.3em 0 0 0; +} + +/* Distribution terms. */ +#footer #terms { + text-align: justify; + + font-size : 110%; + font-family : monospace; + + padding : 1em 0 0.5em 0; +} + + +/* + * Content + * + */ + +#content { + padding : 0em 0.1em 0 1.3em; + margin : 1.4em 0 0 0; +} + +#content p, +#content ol, +#content ul, +#content dl { + text-align: justify; +} + +#content h1 { + margin-left: -0.89em; +} + +a:link { + color:#0536d2; +} + + +/* + * Headings + * + */ + +h1, h2, h3, h4, h5, h6 { + font-weight : 500; +} + +h1 { font-size : 155%; } +h2 { font-size : 130%; } +h3 { font-size : 125%; } +h4 { font-size : 110%; } +h5 { font-size : 106%; } +h6 { font-size : 100%; } + +h1 { margin : 1.8em 0 0.8em 0;} +h2 { margin-top : 1.4em;} +h3 { margin-top : 1em;} + +p.indent { + margin-left : 1.5em; +} + + +/* + * Fix for IE 5.5 table font problem + * + */ + +table { + font-size : 13px; +} + + +/* + * table of content + * + */ + +ul.toc li { + padding : .4em 0em 0em 0em; +} + + +/* Toc links don't need to show when they are visited. */ +.toc a:visited { + color:#0536d2; +} + + +/* + * lists + * + */ + + +/* list of links */ +ul.menu { + list-style-type : none; +} + +ul.menu li { + padding-top : 0.3em; + padding-bottom : 0.3em; +} + + + +/* @@ I should probably use child selector here */ +/* list with multiline list-elements */ +ul.multiline li, ol.multiline li, dl.multiline dd { + padding-top : 0.16em; + padding-bottom : 0.16em; + + font-size : 11px; + line-height : 15px; +} + + + +/* C++ code snippet */ +pre.cxx { + margin-top : 0em; + margin-bottom : 2em; + + margin-left : 1em; +} + +/* SQL code snippet */ +pre.sql { + margin-top : 0em; + margin-bottom : 2em; + + margin-left : 1em; +} + +/* make code snippet */ +pre.make { + margin-top : 0em; + margin-bottom : 2em; + + margin-left : 1em; +} + +/* terminal output */ +pre.term { + margin-top : 0em; + margin-bottom : 2em; + + margin-left : 1em; +} + + +/* Images */ +div.center { + text-align: center; +} + +/* Document info. */ +#docinfo { + margin-top: 4em; + border-top: 1px dashed #000000; + font-size: 70%; +} + + +/* Footnote */ + +#footnote { + margin-top : 2.5em; +} + +#footnote hr, hr.footnote { + margin-left: 0; + margin-bottom: 0.6em; + width: 8em; + border-top: 1px solid #000000; + border-right: none; + border-bottom: none; + border-left: none; + +} + +#footnote ol { + margin-left: 0; + padding-left: 1.45em; +} + +#footnote li { + text-align : left; + font-size : 11px; + line-height : 15px; + + padding : .4em 0 .4em 0; +} + + +/* Normal table with borders, etc. */ + +table.std { + margin: 2em 0 2em 0; + + border-collapse : collapse; + border : 1px solid; + border-color : #000000; + + font-size : 11px; + line-height : 14px; +} + +table.std th, table.std td { + border : 1px solid; + padding : 0.6em 0.8em 0.6em 0.8em; +} + +table.std th { + background : #cde8f6; +} + +table.std td { + text-align: left; +} + + +/* + * "item | description" table. + * + */ + +table.description { + border-style : none; + border-collapse : separate; + border-spacing : 0; + + font-size : 13px; + + margin : 0.6em 0 0.6em 0; + padding : 0 0 0 0; +} + +table.description tr { + padding : 0 0 0 0; + margin : 0 0 0 0; +} + +table.description * td, table.description * th { + border-style : none; + margin : 0 0 0 0; + vertical-align : top; +} + +table.description * th { + font-weight : normal; + padding : 0.4em 1em 0.4em 0; + text-align : left; + white-space : nowrap; + background : none; +} + +table.description * td { + padding : 0.4em 0 0.4em 1em; + text-align : justify; +} diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/doc/manual.xhtml b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/doc/manual.xhtml new file mode 100755 index 0000000..e28f916 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/doc/manual.xhtml @@ -0,0 +1,26608 @@ + + + + + + C++ Object Persistence with ODB + + + + + + + + + + + + + + + + + +
+
+ +
+ +
+
C++ Object Persistence with ODB
+ +

Copyright © 2009-2015 Code Synthesis Tools CC

+ +

Permission is granted to copy, distribute and/or modify this + document under the terms of the + GNU Free + Documentation License, version 1.3; with no Invariant Sections, + no Front-Cover Texts and no Back-Cover Texts.

+ + +

Revision 2.4, February 2015

+

This revision of the manual describes ODB 2.4.0 and is available + in the following formats: + XHTML, + PDF, and + PostScript.

+
+ +
+

Table of Contents

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Preface + + + +
About This Document
More Information
+
PART I OBJECT-RELATIONAL MAPPING
1Introduction + + + + +
1.1Architecture and Workflow
1.2Benefits
1.3Supported C++ Standards
+
2Hello World Example + + + + + + + + + + + + +
2.1Declaring Persistent Classes
2.2Generating Database Support Code
2.3Compiling and Running
2.4Making Objects Persistent
2.5Querying the Database for Objects
2.6Updating Persistent Objects
2.7Defining and Using Views
2.8Deleting Persistent Objects
2.9Changing Persistent Classes
2.10Accessing Multiple Databases
2.11Summary
+
3Working with Persistent Objects + + + + + + + + + + + + + + + +
3.1Concepts and Terminology
3.2Declaring Persistent Objects and Values
3.3Object and View Pointers
3.4Database
3.5Transactions
3.6Connections
3.7Error Handling and Recovery
3.8Making Objects Persistent
3.9Loading Persistent Objects
3.10Updating Persistent Objects
3.11Deleting Persistent Objects
3.12Executing Native SQL Statements
3.13Tracing SQL Statement Execution
3.14ODB Exceptions
+
4Querying the Database + + + + + + +
4.1ODB Query Language
4.2Parameter Binding
4.3Executing a Query
4.4Query Result
4.5Prepared Queries
+
5Containers + + + + + + + + +
5.1Ordered Containers
5.2Set and Multiset Containers
5.3Map and Multimap Containers
5.4Change-Tracking Containers + + +
5.4.1Change-Tracking vector
+
5.5Using Custom Containers
+
6Relationships + + + + + + + + + + +
6.1Unidirectional Relationships + + + +
6.1.1To-One Relationships
6.1.2To-Many Relationships
+
6.2Bidirectional Relationships + + + + +
6.2.1One-to-One Relationships
6.2.2One-to-Many Relationships
6.2.3Many-to-Many Relationships
+
6.3Circular Relationships
6.4Lazy Pointers
6.5Using Custom Smart Pointers
+
7Value Types + + + + + + +
7.1Simple Value Types
7.2Composite Value Types + + + +
7.2.1Composite Object Ids
7.2.2Composite Value Column and Table Names
+
7.3Pointers and NULL Value Semantics
+
8Inheritance + + + + + + +
8.1Reuse Inheritance
8.2Polymorphism Inheritance + + +
8.2.1Performance and Limitations
+
8.3Mixed Inheritance
+
9Sections + + + + + +
9.1Sections and Inheritance
9.2Sections and Optimistic Concurrency
9.3Sections and Lazy Pointers
9.4Sections and Change-Tracking Containers
+
10Views + + + + + + + + +
10.1Object Views
10.2Object Loading Views
10.3Table Views
10.4Mixed Views
10.5View Query Conditions
10.6Native Views
10.7Other View Features and Limitations
+
11Session + + + +
11.1Object Cache
11.2Custom Sessions
+
12Optimistic Concurrency
13Database Schema Evolution + + + + + + + + + +
13.1Object Model Version and Changelog
13.2Schema Migration
13.3Data Migration + + + +
13.3.1Immediate Data Migration
13.3.2Gradual Data Migration
+
13.4Soft Object Model Changes + + + +
13.4.1Reuse Inheritance Changes
13.4.2Polymorphism Inheritance Changes
+
+
14ODB Pragma Language + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
14.1Object Type Pragmas + + + + + + + + + + + + + + + + +
14.1.1table
14.1.2pointer
14.1.3abstract
14.1.4readonly
14.1.5optimistic
14.1.6no_id
14.1.7callback
14.1.8schema
14.1.9polymorphic
14.1.10session
14.1.11definition
14.1.12transient
14.1.13sectionable
14.1.14deleted
14.1.15bulk
+
14.2View Type Pragmas + + + + + + + + +
14.2.1object
14.2.2table
14.2.3query
14.2.4pointer
14.2.5callback
14.2.6definition
14.2.7transient
+
14.3Value Type Pragmas + + + + + + + + + + + + + + + + + + + + + + +
14.3.1type
14.3.2id_type
14.3.3null/not_null
14.3.4default
14.3.5options
14.3.6readonly
14.3.7definition
14.3.8transient
14.3.9unordered
14.3.10index_type
14.3.11key_type
14.3.12value_type
14.3.13value_null/value_not_null
14.3.14id_options
14.3.15index_options
14.3.16key_options
14.3.17value_options
14.3.18id_column
14.3.19index_column
14.3.20key_column
14.3.21value_column
+
14.4Data Member Pragmas + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
14.4.1id
14.4.2auto
14.4.3type
14.4.4id_type
14.4.5get/set/access
14.4.6null/not_null
14.4.7default
14.4.8options
14.4.9column (object, composite value)
14.4.10column (view)
14.4.11transient
14.4.12readonly
14.4.13virtual
14.4.14inverse
14.4.15on_delete
14.4.16version
14.4.17index
14.4.18unique
14.4.19unordered
14.4.20table
14.4.21load/update
14.4.22section
14.4.23added
14.4.24deleted
14.4.25index_type
14.4.26key_type
14.4.27value_type
14.4.28value_null/value_not_null
14.4.29id_options
14.4.30index_options
14.4.31key_options
14.4.32value_options
14.4.33id_column
14.4.34index_column
14.4.35key_column
14.4.36value_column
+
14.5Namespace Pragmas + + + + + +
14.5.1pointer
14.5.2table
14.5.3schema
14.5.4session
+
14.6Object Model Pragmas + + +
14.6.1version
+
14.7Index Definition Pragmas
14.8Database Type Mapping Pragmas
14.9C++ Compiler Warnings + + + + + + + +
14.9.1GNU C++
14.9.2Visual C++
14.9.3Sun C++
14.9.4IBM XL C++
14.9.5HP aC++
14.9.6Clang
+
+
15Advanced Techniques and Mechanisms + + + + +
15.1Transaction Callbacks
15.2Persistent Class Template Instantiations
15.3Bulk Database Operations
+
PART II DATABASE SYSTEMS
16Multi-Database Support + + + + + +
16.1Static Multi-Database Support
16.2Dynamic Multi-Database Support + + +
16.2.216.2.2 Dynamic Loading of Database Support Code
+
+
17MySQL Database + + + + + + + + + + + + +
17.1MySQL Type Mapping + + + +
17.1.1String Type Mapping
17.1.2Binary Type Mapping
+
17.2MySQL Database Class
17.3MySQL Connection and Connection Factory
17.4MySQL Exceptions
17.5MySQL Limitations + + +
17.5.1Foreign Key Constraints
+
17.6MySQL Index Definition
17.7MySQL Stored Procedures
+
18SQLite Database + + + + + + + + + + + +
18.1SQLite Type Mapping + + + +
18.1.1String Type Mapping
18.1.2Binary Type Mapping
+
18.2SQLite Database Class
18.3SQLite Connection and Connection Factory
18.4SQLite Exceptions
18.5SQLite Limitations + + + + + + + + +
18.5.1Query Result Caching
18.5.2Automatic Assignment of Object Ids
18.5.3Foreign Key Constraints
18.5.4Constraint Violations
18.5.5Sharing of Queries
18.5.6Forced Rollback
18.5.7Database Schema Evolution
+
18.6SQLite Index Definition
+
19PostgreSQL Database + + + + + + + + + + + +
19.1PostgreSQL Type Mapping + + + +
19.1.1String Type Mapping
19.1.2Binary Type and UUID Mapping
+
19.2PostgreSQL Database Class
19.3PostgreSQL Connection and Connection Factory
19.4PostgreSQL Exceptions
19.5PostgreSQL Limitations + + + + + + + +
19.5.1Query Result Caching
19.5.2Foreign Key Constraints
19.5.3Unique Constraint Violations
19.5.4Date-Time Format
19.5.5Timezones
19.5.6NUMERIC Type Support
+
19.6PostgreSQL Index Definition
+
20Oracle Database + + + + + + + + + + + +
20.1Oracle Type Mapping + + + +
20.1.1String Type Mapping
20.1.2Binary Type Mapping
+
20.2Oracle Database Class
20.3Oracle Connection and Connection Factory
20.4Oracle Exceptions
20.5Oracle Limitations + + + + + + + + + + +
20.5.1Identifier Truncation
20.5.2Query Result Caching
20.5.3Foreign Key Constraints
20.5.4Unique Constraint Violations
20.5.5Large FLOAT and NUMBER Types
20.5.6Timezones
20.5.7LONG Types
20.5.8LOB Types and By-Value Accessors/Modifiers
20.5.9Database Schema Evolution
+
20.6Oracle Index Definition
+
21Microsoft SQL Server Database + + + + + + + + + + + + +
21.1SQL Server Type Mapping + + + + + +
21.1.1String Type Mapping
21.1.2Binary Type and UNIQUEIDENTIFIER Mapping
21.1.3ROWVERSION Mapping
21.1.4Long String and Binary Types
+
21.2SQL Server Database Class
21.3SQL Server Connection and Connection Factory
21.4SQL Server Exceptions
21.5SQL Server Limitations + + + + + + + + + +
21.5.1Query Result Caching
21.5.2Foreign Key Constraints
21.5.3Unique Constraint Violations
21.5.4Multi-threaded Windows Applications
21.5.5Affected Row Count and DDL Statements
21.5.6Long Data and Auto Object Ids, ROWVERSION
21.5.7Long Data and By-Value Accessors/Modifiers
21.5.8Bulk Update and ROWVERSION
+
21.6SQL Server Index Definition
21.7SQL Server Stored Procedures
+
PART III PROFILES
22Profiles Introduction
23Boost Profile + + + + + + + + + + + +
23.1Smart Pointers Library
23.2Unordered Containers Library
23.3Multi-Index Container Library
23.4Optional Library
23.5Date Time Library + + + + + + +
23.5.1MySQL Database Type Mapping
23.5.2SQLite Database Type Mapping
23.5.3PostgreSQL Database Type Mapping
23.5.4Oracle Database Type Mapping
23.5.5SQL Server Database Type Mapping
+
23.6Uuid Library + + + + + + +
23.6.1MySQL Database Type Mapping
23.6.2SQLite Database Type Mapping
23.6.3PostgreSQL Database Type Mapping
23.6.4Oracle Database Type Mapping
23.6.5SQL Server Database Type Mapping
+
+
24Qt Profile + + + + + + + + + + + +
24.1Basic Types Library + + + + + + +
24.1.1MySQL Database Type Mapping
24.1.2SQLite Database Type Mapping
24.1.3PostgreSQL Database Type Mapping
24.1.4Oracle Database Type Mapping
24.1.5SQL Server Database Type Mapping
+
24.2Smart Pointers Library
24.3Containers Library + + +
24.3.1Change-Tracking QList
+
24.4Date Time Library + + + + + + +
24.4.1MySQL Database Type Mapping
24.4.2SQLite Database Type Mapping
24.4.3PostgreSQL Database Type Mapping
24.4.4Oracle Database Type Mapping
24.4.5SQL Server Database Type Mapping
+
+
+
+ +
+

Preface

+ +

As more critical aspects of our lives become dependant on software + systems, more and more applications are required to save the data + they work on in persistent and reliable storage. Database management + systems and, in particular, relational database management systems + (RDBMS) are commonly used for such storage. However, while the + application development techniques and programming languages have + evolved significantly over the past decades, the relational database + technology in this area stayed relatively unchanged. In particular, + this led to the now infamous mismatch between the object-oriented + model used by many modern applications and the relational model still + used by RDBMS.

+ +

While relational databases may be inconvenient to use from modern + programming languages, they are still the main choice for many + applications due to their maturity, reliability, as well as the + availability of tools and alternative implementations.

+ +

To allow application developers to utilize relational databases + from their object-oriented applications, a technique called + object-relational mapping (ORM) is often used. It involves a + conversion layer that maps between objects in the application's + memory and their relational representation in the database. While + the object-relational mapping code can be written manually, + automated ORM systems are available for most object-oriented + programming languages in use today.

+ +

ODB is an ORM system for the C++ programming language. It was + designed and implemented with the following main goals:

+ +
    +
  • Provide a fully-automatic ORM system. In particular, the + application developer should not have to manually write any + mapping code, neither for persistent classes nor for their + data member.
    • + +
  • Provide clean and easy to use object-oriented persistence + model and database APIs that support the development of realistic + applications for a wide variety of domains.
    • + +
  • Provide a portable and thread-safe implementation. ODB should be + written in standard C++ and capable of persisting any standard + C++ classes.
    • + +
  • Provide profiles that integrate ODB with type systems of + widely-used frameworks and libraries such as Qt and Boost.
    • + +
  • Provide a high-performance and low overhead implementation. ODB + should make efficient use of database and application resources.
    • + +
+ + +

About This Document

+ +

The goal of this manual is to provide you with an understanding + of the object persistence model and APIs which are implemented by ODB. + As such, this document is intended for C++ application developers and + software architects who are looking for a C++ object persistence + solution. Prior experience with C++ is required to understand + this document. A basic understanding of relational database systems + is advantageous but not expected or required.

+ + +

More Information

+ +

Beyond this manual, you may also find the following sources of + information useful:

+ +
    +
  • ODB + Compiler Command Line Manual.
    • + +
  • The INSTALL files in the ODB source packages provide + build instructions for various platforms.
    • + +
  • The odb-examples package contains a collection of + examples and a README file with an overview of each example.
    • + +
  • The odb-users + mailing list is the place to ask technical questions about ODB. + Furthermore, the searchable + archives + may already have answers to some of your questions.
    • + +
+ + + + + +
+

PART I   + OBJECT-RELATIONAL MAPPING

+ +

Part I describes the essential database concepts, APIs, and tools that + together comprise the object-relational mapping for C++ as implemented + by ODB. It consists of the following chapters.

+ + + + + + + + + + + + + + + +
1Introduction
2Hello World Example
3Working with Persistent Objects
4Querying the Database
5Containers
6Relationships
7Value Types
8Inheritance
10Views
11Session
12Optimistic Concurrency
13Database Schema Evolution
14ODB Pragma Language
+ + + + + +
+

1 Introduction

+ +

ODB is an object-relational mapping (ORM) system for C++. It provides + tools, APIs, and library support that allow you to persist C++ objects + to a relational database (RDBMS) without having to deal with tables, + columns, or SQL and without manually writing any of the mapping code.

+ +

ODB is highly flexible and customizable. It can either completely + hide the relational nature of the underlying database or expose + some of the details as required. For example, you can automatically + map basic C++ types to suitable SQL types, generate the relational + database schema for your persistent classes, and use simple, safe, + and yet powerful object query language instead of SQL. Or you can + assign SQL types to individual data members, use the existing + database schema, run native SQL SELECT queries, and + call stored procedures. In fact, at an extreme, ODB can be used + as just a convenient way to handle results of native SQL + queries.

+ +

ODB is not a framework. It does not dictate how you should write + your application. Rather, it is designed to fit into your + style and architecture by only handling object persistence + and not interfering with any other functionality. There is + no common base type that all persistent classes should derive + from nor are there any restrictions on the data member types + in persistent classes. Existing classes can be made persistent + with a few or no modifications.

+ +

ODB has been designed for high performance and low memory + overhead. Prepared statements are used to send and receive + object state in binary format instead of text which reduces + the load on the application and the database server. Extensive + caching of connections, prepared statements, and buffers saves + time and resources on connection establishment, statement parsing, + and memory allocations. For each supported database system the + native C API is used instead of ODBC or higher-level wrapper + APIs to reduce overhead and provide the most efficient implementation + for each database operation. Finally, persistent classes have + zero memory overhead. There are no hidden "database" members + that each class must have nor are there per-object data structures + allocated by ODB.

+ +

In this chapter we present a high-level overview of ODB. + We will start with the ODB architecture and then outline the + workflow of building an application that uses ODB. We will + then continue by contrasting the drawbacks of the traditional + way of saving C++ objects to relational databases with the + benefits of using ODB for object persistence. We conclude the + chapter by discussing the C++ standards supported by ODB. The + next chapter takes a more hands-on approach and shows the + concrete steps necessary to implement object persistence in + a simple "Hello World" application.

+ +

1.1 Architecture and Workflow

+ +

From the application developer's perspective, ODB + consists of three main components: the ODB compiler, the common + runtime library, called libodb, and the + database-specific runtime libraries, called + libodb-<database>, where <database> is + the name of the database system this runtime + is for, for example, libodb-mysql. For instance, + if the application is going to use the MySQL database for + object persistence, then the three ODB components that this + application will use are the ODB compiler, libodb + and libodb-mysql.

+ +

The ODB compiler generates the database support code for + persistent classes in your application. The input to the ODB + compiler is one or more C++ header files defining C++ classes + that you want to make persistent. For each input header file + the ODB compiler generates a set of C++ source files implementing + conversion between persistent C++ classes defined in this + header and their database representation. The ODB compiler + can also generate a database schema file that creates tables + necessary to store the persistent classes.

+ +

The ODB compiler is a real C++ compiler except that it produces + C++ instead of assembly or machine code. In particular, it is not + an ad-hoc header pre-processor that is only capable of recognizing + a subset of C++. ODB is capable of parsing any standard C++ code.

+ +

The common runtime library defines database system-independent + interfaces that your application can use to manipulate persistent + objects. The database-specific runtime library provides implementations + of these interfaces for a concrete database as well as other + database-specific utilities that are used by the generated code. + Normally, the application does not use the database-specific + runtime library directly but rather works with it via the common + interfaces from libodb. The following diagram shows + the object persistence architecture of an application that uses + MySQL as the underlying database system:

+ + +
+ +

The ODB system also defines two special-purpose languages: + the ODB Pragma Language and ODB Query Language. The ODB Pragma + Language is used to communicate various properties of persistent + classes to the ODB compiler by means of special #pragma + directives embedded in the C++ header files. It controls aspects + of the object-relational mapping such as names of tables and columns + that are used for persistent classes and their members or mapping between + C++ types and database types.

+ +

The ODB Query Language is an object-oriented database query + language that can be used to search for objects matching + certain criteria. It is modeled after and is integrated into + C++ allowing you to write expressive and safe queries that look + and feel like ordinary C++.

+ +

The use of the ODB compiler to generate database support code + adds an additional step to your application build sequence. The + following diagram outlines the typical build workflow of an + application that uses ODB:

+ + +
+ +

1.2 Benefits

+ +

The traditional way of saving C++ objects to relational databases + requires that you manually write code which converts between the database + and C++ representations of each persistent class. The actions that + such code usually performs include conversion between C++ values and + strings or database types, preparation and execution of SQL queries, + as well as handling the result sets. Writing this code manually has + the following drawbacks:

+ +
    +
  • Difficult and time consuming. Writing database conversion + code for any non-trivial application requires extensive + knowledge of the specific database system and its APIs. + It can also take a considerable amount of time to write + and maintain. Supporting multi-threaded applications can + complicate this task even further.
    • + +
  • Suboptimal performance. Optimal conversion often + requires writing large amounts of extra code, such as + parameter binding for prepared statements and caching + of connections, statements, and buffers. Writing code + like this in an ad-hoc manner is often too difficult + and time consuming.
    • + +
  • Database vendor lock-in. The conversion code is written for + a specific database which makes it hard to switch to another + database vendor.
    • + +
  • Lack of type safety. It is easy to misspell column names or + pass incompatible values in SQL queries. Such errors will + only be detected at runtime.
    • + +
  • Complicates the application. The database conversion code + often ends up interspersed throughout the application making it + hard to debug, change, and maintain.
    • +
+ +

In contrast, using ODB for C++ object persistence has the + following benefits:

+ +
    +
  • Ease of use. ODB automatically generates database conversion + code from your C++ class declarations and allows you to manipulate + persistent objects using simple and thread-safe object-oriented + database APIs.
    • + +
  • Concise code. With ODB hiding the details of the underlying + database, the application logic is written using the natural object + vocabulary instead of tables, columns and SQL. The resulting code + is simpler and thus easier to read and understand.
    • + +
  • Optimal performance. ODB has been designed for high performance + and low memory overhead. All the available optimization techniques, + such as prepared statements and extensive connection, statement, + and buffer caching, are used to provide the most efficient + implementation for each database operation.
    • + +
  • Database portability. Because the database conversion code + is automatically generated, it is easy to switch from one database + vendor to another. In fact, it is possible to test your application + on several database systems before making a choice.
    • + +
  • Safety. The ODB object persistence and query APIs are + statically typed. You use C++ identifiers instead of strings + to refer to object members and the generated code makes sure + database and C++ types are compatible. All this helps catch + programming errors at compile-time rather than at runtime.
    • + +
  • Maintainability. Automatic code generation minimizes the + effort needed to adapt the application to changes in persistent + classes. The database support code is kept separately from the + class declarations and application logic. This makes the + application easier to debug and maintain.
    • +
+ +

Overall, ODB provides an easy to use yet flexible and powerful + object-relational mapping (ORM) system for C++. Unlike other + ORM implementations for C++ that still require you to write + database conversion or member registration code for each + persistent class, ODB keeps persistent classes purely + declarative. The functional part, the database conversion + code, is automatically generated by the ODB compiler from + these declarations.

+ +

1.3 Supported C++ Standards

+ +

ODB provides support for ISO/IEC C++ 1998/2003 (C++98/03), + ISO/IEC TR 19768 C++ Library Extensions (C++ TR1), and + ISO/IEC C++ 2011 (C++11). While the majority of the examples in + this manual use C++98/03, support for the new functionality and + library components introduced in TR1 and C++11 are discussed + throughout the document. The c++11 example in the + odb-examples package also shows ODB support for + various C++11 features.

+ + + + +
+

2 Hello World Example

+ +

In this chapter we will show how to create a simple C++ + application that relies on ODB for object persistence using + the traditional "Hello World" example. In particular, we will + discuss how to declare persistent classes, generate database + support code, as well as compile and run our application. We + will also learn how to make objects persistent, load, update + and delete persistent objects, as well as query the database + for persistent objects that match certain criteria. The example + also shows how to define and use views, a mechanism that allows + us to create projections of persistent objects, database tables, + or to handle results of native SQL queries or stored procedure + calls.

+ +

The code presented in this chapter is based on the + hello example which can be found in the + odb-examples package of the ODB distribution.

+ +

2.1 Declaring Persistent Classes

+ +

In our "Hello World" example we will depart slightly from + the norm and say hello to people instead of the world. People + in our application will be represented as objects of C++ class + person which is saved in person.hxx:

+ + 
+// person.hxx
+//
+
+#include <string>
+
+class person
+{
+public:
+  person (const std::string& first,
+          const std::string& last,
+          unsigned short age);
+
+  const std::string& first () const;
+  const std::string& last () const;
+
+  unsigned short age () const;
+  void age (unsigned short);
+
+private:
+  std::string first_;
+  std::string last_;
+  unsigned short age_;
+};
+
+ +

In order not to miss anyone whom we need to greet, we would like + to save the person objects in a database. To achieve this + we declare the person class as persistent:

+ + 
+// person.hxx
+//
+
+#include <string>
+
+#include <odb/core.hxx>     // (1)
+
+#pragma db object           // (2)
+class person
+{
+  ...
+
+private:
+  person () {}              // (3)
+
+  friend class odb::access; // (4)
+
+  #pragma db id auto        // (5)
+  unsigned long id_;        // (5)
+
+  std::string first_;
+  std::string last_;
+  unsigned short age_;
+};
+
+ +

To be able to save the person objects in the database + we had to make five changes, marked with (1) to (5), to the original + class definition. The first change is the inclusion of the ODB + header <odb/core.hxx>. This header provides a number + of core ODB declarations, such as odb::access, that + are used to define persistent classes.

+ +

The second change is the addition of db object + pragma just before the class definition. This pragma tells the + ODB compiler that the class that follows is persistent. Note + that making a class persistent does not mean that all objects + of this class will automatically be stored in the database. + You would still create ordinary or transient instances + of this class just as you would before. The difference is that + now you can make such transient instances persistent, as we will + see shortly.

+ +

The third change is the addition of the default constructor. + The ODB-generated database support code will use this constructor + when instantiating an object from the persistent state. Just as we have + done for the person class, you can make the default + constructor private or protected if you don't want to make it + available to the users of your class. Note also that with some + limitations it is possible to have a persistent class without + the default constructor.

+ +

With the fourth change we make the odb::access class a + friend of our person class. This is necessary to make + the default constructor and the data members accessible to the + database support code. If your class has a public default constructor and + either public data members or public accessors and modifiers for the + data members, then the friend declaration is unnecessary.

+ +

The final change adds a data member called id_ which + is preceded by another pragma. In ODB every persistent object normally + has a unique, within its class, identifier. Or, in other words, no two + persistent instances of the same type have equal identifiers. While it + is possible to define a persistent class without an object id, the number + of database operations that can be performed on such a class is limited. + For our class we use an integer id. The db id auto + pragma that precedes the id_ member tells the ODB compiler + that the following member is the object's identifier. The + auto specifier indicates that it is a database-assigned + id. A unique id will be automatically generated by the database and + assigned to the object when it is made persistent.

+ +

In this example we chose to add an identifier because none of + the existing members could serve the same purpose. However, if + a class already has a member with suitable properties, then it + is natural to use that member as an identifier. For example, + if our person class contained some form of personal + identification (SSN in the United States or ID/passport number + in other countries), then we could use that as an id. Or, if + we stored an email associated with each person, then we could + have used that if each person is presumed to have a unique + email address.

+ +

As another example, consider the following alternative version + of the person class. Here we use one of + the existing data members as id. Also the data members are kept + private and are instead accessed via public accessor and modifier + functions. Finally, the ODB pragmas are grouped together and are + placed after the class definition. They could have also been moved + into a separate header leaving the original class completely + unchanged (for more information on such a non-intrusive conversion + refer to Chapter 14, "ODB Pragma Language").

+ + 
+class person
+{
+public:
+  person ();
+
+  const std::string& email () const;
+  void email (const std::string&);
+
+  const std::string& get_name () const;
+  std::string& set_name ();
+
+  unsigned short getAge () const;
+  void setAge (unsigned short);
+
+private:
+  std::string email_;
+  std::string name_;
+  unsigned short age_;
+};
+
+#pragma db object(person)
+#pragma db member(person::email_) id
+
+ +

Now that we have the header file with the persistent class, let's + see how we can generate that database support code.

+ +

2.2 Generating Database Support Code

+ +

The persistent class definition that we created in the previous + section was particularly light on any code that could actually + do the job and store the person's data to a database. There + was no serialization or deserialization code, not even data member + registration, that you would normally have to write by hand in + other ORM libraries for C++. This is because in ODB code + that translates between the database and C++ representations + of an object is automatically generated by the ODB compiler.

+ +

To compile the person.hxx header we created in the + previous section and generate the support code for the MySQL + database, we invoke the ODB compiler from a terminal (UNIX) or + a command prompt (Windows):

+ + 
+odb -d mysql --generate-query person.hxx
+
+ +

We will use MySQL as the database of choice in the remainder of + this chapter, though other supported database systems can be used + instead.

+ +

If you haven't installed the common ODB runtime library + (libodb) or installed it into a directory where + C++ compilers don't search for headers by default, + then you may get the following error:

+ + 
+person.hxx:10:24: fatal error: odb/core.hxx: No such file or directory
+
+ +

To resolve this you will need to specify the libodb headers + location with the -I preprocessor option, for example:

+ + 
+odb -I.../libodb -d mysql --generate-query person.hxx
+
+ +

Here .../libodb represents the path to the + libodb directory.

+ +

The above invocation of the ODB compiler produces three C++ files: + person-odb.hxx, person-odb.ixx, + person-odb.cxx. You normally don't use types + or functions contained in these files directly. Rather, all + you have to do is include person-odb.hxx in + C++ files where you are performing database operations + with classes from person.hxx as well as compile + person-odb.cxx and link the resulting object + file to your application.

+ +

You may be wondering what the --generate-query + option is for. It instructs the ODB compiler to generate + optional query support code that we will use later in our + "Hello World" example. Another option that we will find + useful is --generate-schema. This option + makes the ODB compiler generate a fourth file, + person.sql, which is the database schema + for the persistent classes defined in person.hxx:

+ + 
+odb -d mysql --generate-query --generate-schema person.hxx
+
+ +

The database schema file contains SQL statements that creates + tables necessary to store the persistent classes. We will learn + how to use it in the next section.

+ +

If you would like to see a list of all the available ODB compiler + options, refer to the + ODB + Compiler Command Line Manual.

+ +

Now that we have the persistent class and the database support + code, the only part that is left is the application code that + does something useful with all of this. But before we move on to + the fun part, let's first learn how to build and run an application + that uses ODB. This way when we have some application code + to try, there are no more delays before we can run it.

+ +

2.3 Compiling and Running

+ +

Assuming that the main() function with the application + code is saved in driver.cxx and the database support + code and schema are generated as described in the previous section, + to build our application we will first need to compile all the C++ + source files and then link them with two ODB runtime libraries.

+ +

On UNIX, the compilation part can be done with the following commands + (substitute c++ with your C++ compiler name; for Microsoft + Visual Studio setup, see the odb-examples package):

+ + 
+c++ -c driver.cxx
+c++ -c person-odb.cxx
+
+ +

Similar to the ODB compilation, if you get an error stating that + a header in odb/ or odb/mysql directory + is not found, you will need to use the -I + preprocessor option to specify the location of the common ODB runtime + library (libodb) and MySQL ODB runtime library + (libodb-mysql).

+ +

Once the compilation is done, we can link the application with + the following command:

+ + 
+c++ -o driver driver.o person-odb.o -lodb-mysql -lodb
+
+ +

Notice that we link our application with two ODB libraries: + libodb which is a common runtime library and + libodb-mysql which is a MySQL runtime library + (if you use another database, then the name of this library + will change accordingly). If you get an error saying that + one of these libraries could not be found, then you will need + to use the -L linker option to specify their locations.

+ +

Before we can run our application we need to create a database + schema using the generated person.sql file. For MySQL + we can use the mysql client program, for example:

+ + 
+mysql --user=odb_test --database=odb_test < person.sql
+
+ +

The above command will log in to a local MySQL server as user + odb_test without a password and use the database + named odb_test. Beware that after executing this + command, all the data stored in the odb_test database + will be deleted.

+ +

Note also that using a standalone generated SQL file is not the + only way to create a database schema in ODB. We can also embed + the schema directly into our application or use custom schemas + that were not generated by the ODB compiler. Refer to + Section 3.4, "Database" for details.

+ +

Once the database schema is ready, we run our application + using the same login and database name:

+ + 
+./driver --user odb_test --database odb_test
+
+ + +

2.4 Making Objects Persistent

+ +

Now that we have the infrastructure work out of the way, it + is time to see our first code fragment that interacts with the + database. In this section we will learn how to make person + objects persistent:

+ + 
+// driver.cxx
+//
+
+#include <memory>   // std::auto_ptr
+#include <iostream>
+
+#include <odb/database.hxx>
+#include <odb/transaction.hxx>
+
+#include <odb/mysql/database.hxx>
+
+#include "person.hxx"
+#include "person-odb.hxx"
+
+using namespace std;
+using namespace odb::core;
+
+int
+main (int argc, char* argv[])
+{
+  try
+  {
+    auto_ptr<database> db (new odb::mysql::database (argc, argv));
+
+    unsigned long john_id, jane_id, joe_id;
+
+    // Create a few persistent person objects.
+    //
+    {
+      person john ("John", "Doe", 33);
+      person jane ("Jane", "Doe", 32);
+      person joe ("Joe", "Dirt", 30);
+
+      transaction t (db->begin ());
+
+      // Make objects persistent and save their ids for later use.
+      //
+      john_id = db->persist (john);
+      jane_id = db->persist (jane);
+      joe_id = db->persist (joe);
+
+      t.commit ();
+    }
+  }
+  catch (const odb::exception& e)
+  {
+    cerr << e.what () << endl;
+    return 1;
+  }
+}
+
+ +

Let's examine this code piece by piece. At the beginning we include + a bunch of headers. After the standard C++ headers we include + <odb/database.hxx> + and <odb/transaction.hxx> which define database + system-independent odb::database and + odb::transaction interfaces. Then we include + <odb/mysql/database.hxx> which defines the + MySQL implementation of the database interface. Finally, + we include person.hxx and person-odb.hxx + which define our persistent person class.

+ +

Then we have two using namespace directives. The first + one brings in the names from the standard namespace and the second + brings in the ODB declarations which we will use later in the file. + Notice that in the second directive we use the odb::core + namespace instead of just odb. The former only brings + into the current namespace the essential ODB names, such as the + database and transaction classes, without + any of the auxiliary objects. This minimizes the likelihood of name + conflicts with other libraries. Note also that you should continue + using the odb namespace when qualifying individual names. + For example, you should write odb::database, not + odb::core::database.

+ +

Once we are in main(), the first thing we do is create + the MySQL database object. Notice that this is the last line in + driver.cxx that mentions MySQL explicitly; the rest + of the code works through the common interfaces and is database + system-independent. We use the argc/argv + mysql::database constructor which automatically + extract the database parameters, such as login name, password, + database name, etc., from the command line. In your own applications + you may prefer to use other mysql::database + constructors which allow you to pass this information directly + (Section 17.2, "MySQL Database Class").

+ +

Next, we create three person objects. Right now they are + transient objects, which means that if we terminate the application + at this point, they will be gone without any evidence of them ever + existing. The next line starts a database transaction. We discuss + transactions in detail later in this manual. For now, all we need + to know is that all ODB database operations must be performed within + a transaction and that a transaction is an atomic unit of work; all + database operations performed within a transaction either succeed + (committed) together or are automatically undone (rolled back).

+ +

Once we are in a transaction, we call the persist() + database function on each of our person objects. + At this point the state of each object is saved in the database. + However, note that this state is not permanent until and unless + the transaction is committed. If, for example, our application + crashes at this point, there will still be no evidence of our + objects ever existing.

+ +

In our case, one more thing happens when we call persist(). + Remember that we decided to use database-assigned identifiers for our + person objects. The call to persist() is + where this assignment happens. Once this function returns, the + id_ member contains this object's unique identifier. + As a convenience, the persist() function also returns + a copy of the object's identifier that it made persistent. We + save the returned identifier for each object in a local variable. + We will use these identifiers later in the chapter to perform other + database operations on our persistent objects.

+ +

After we have persisted our objects, it is time to commit the + transaction and make the changes permanent. Only after the + commit() function returns successfully, are we + guaranteed that the objects are made persistent. Continuing + with the crash example, if our application terminates after + the commit for whatever reason, the objects' state in the + database will remain intact. In fact, as we will discover + shortly, our application can be restarted and load the + original objects from the database. Note also that a + transaction must be committed explicitly with the + commit() call. If the transaction + object leaves scope without the transaction being + explicitly committed or rolled back, it will automatically be + rolled back. This behavior allows you not to worry about + exceptions being thrown within a transaction; if they + cross the transaction boundary, the transaction will + automatically be rolled back and all the changes made + to the database undone.

+ +

The final bit of code in our example is the catch + block that handles the database exceptions. We do this by catching + the base ODB exception (Section 3.14, "ODB + Exceptions") and printing the diagnostics.

+ +

Let's now compile (Section 2.3, "Compiling and + Running") and then run our first ODB application:

+ + 
+mysql --user=odb_test --database=odb_test < person.sql
+./driver --user odb_test --database odb_test
+
+ +

Our first application doesn't print anything except for error + messages so we can't really tell whether it actually stored the + objects' state in the database. While we will make our application + more entertaining shortly, for now we can use the mysql + client to examine the database content. It will also give us a feel + for how the objects are stored:

+ + 
+mysql --user=odb_test --database=odb_test
+
+Welcome to the MySQL monitor.
+
+mysql> select * from person;
+
++----+-------+------+-----+
+| id | first | last | age |
++----+-------+------+-----+
+|  1 | John  | Doe  |  33 |
+|  2 | Jane  | Doe  |  32 |
+|  3 | Joe   | Dirt |  30 |
++----+-------+------+-----+
+3 rows in set (0.00 sec)
+
+mysql> quit
+
+ +

Another way to get more insight into what's going on under the hood, + is to trace the SQL statements executed by ODB as a result of + each database operation. Here is how we can enable tracing just for + the duration of our transaction:

+ + 
+    // Create a few persistent person objects.
+    //
+    {
+      ...
+
+      transaction t (db->begin ());
+
+      t.tracer (stderr_tracer);
+
+      // Make objects persistent and save their ids for later use.
+      //
+      john_id = db->persist (john);
+      jane_id = db->persist (jane);
+      joe_id = db->persist (joe);
+
+      t.commit ();
+    }
+
+ +

With this modification our application now produces the following + output:

+ + 
+INSERT INTO `person` (`id`,`first`,`last`,`age`) VALUES (?,?,?,?)
+INSERT INTO `person` (`id`,`first`,`last`,`age`) VALUES (?,?,?,?)
+INSERT INTO `person` (`id`,`first`,`last`,`age`) VALUES (?,?,?,?)
+
+ +

Note that we see question marks instead of the actual values + because ODB uses prepared statements and sends the data to the + database in binary form. For more information on tracing, refer + to Section 3.13, "Tracing SQL Statement Execution". + In the next section we will see how to access persistent objects + from our application.

+ +

2.5 Querying the Database for Objects

+ +

So far our application doesn't resemble a typical "Hello World" + example. It doesn't print anything except for error messages. + Let's change that and teach our application to say hello to + people from our database. To make it a bit more interesting, + let's say hello only to people over 30:

+ + 
+// driver.cxx
+//
+
+...
+
+int
+main (int argc, char* argv[])
+{
+  try
+  {
+    ...
+
+    // Create a few persistent person objects.
+    //
+    {
+      ...
+    }
+
+    typedef odb::query<person> query;
+    typedef odb::result<person> result;
+
+    // Say hello to those over 30.
+    //
+    {
+      transaction t (db->begin ());
+
+      result r (db->query<person> (query::age > 30));
+
+      for (result::iterator i (r.begin ()); i != r.end (); ++i)
+      {
+        cout << "Hello, " << i->first () << "!" << endl;
+      }
+
+      t.commit ();
+    }
+  }
+  catch (const odb::exception& e)
+  {
+    cerr << e.what () << endl;
+    return 1;
+  }
+}
+
+ +

The first half of our application is the same as before and is + replaced with "..." in the above listing for brevity. Again, let's + examine the rest of it piece by piece.

+ +

The two typedefs create convenient aliases for two + template instantiations that will be used a lot in our application. + The first is the query type for the person objects + and the second is the result type for that query.

+ +

Then we begin a new transaction and call the query() + database function. We pass a query expression + (query::age > 30) which limits the returned objects + only to those with the age greater than 30. We also save the result + of the query in a local variable.

+ +

The next few lines perform a standard for-loop iteration + over the result sequence printing hello for every returned person. + Then we commit the transaction and that's it. Let's see what + this application will print:

+ + 
+mysql --user=odb_test --database=odb_test < person.sql
+./driver --user odb_test --database odb_test
+
+Hello, John!
+Hello, Jane!
+
+ + +

That looks about right, but how do we know that the query actually + used the database instead of just using some in-memory artifacts of + the earlier persist() calls? One way to test this + would be to comment out the first transaction in our application + and re-run it without re-creating the database schema. This way the + objects that were persisted during the previous run will be returned. + Alternatively, we can just re-run the same application without + re-creating the schema and notice that we now show duplicate + objects:

+ + 
+./driver --user odb_test --database odb_test
+
+Hello, John!
+Hello, Jane!
+Hello, John!
+Hello, Jane!
+
+ +

What happens here is that the previous run of our application + persisted a set of person objects and when we re-run + the application, we persist another set with the same names but + with different ids. When we later run the query, matches from + both sets are returned. We can change the line where we print + the "Hello" string as follows to illustrate this point:

+ + 
+cout << "Hello, " << i->first () << " (" << i->id () << ")!" << endl;
+
+ +

If we now re-run this modified program, again without re-creating + the database schema, we will get the following output:

+ + 
+./driver --user odb_test --database odb_test
+
+Hello, John (1)!
+Hello, Jane (2)!
+Hello, John (4)!
+Hello, Jane (5)!
+Hello, John (7)!
+Hello, Jane (8)!
+
+ +

The identifiers 3, 6, and 9 that are missing from the above list belong + to the "Joe Dirt" objects which are not selected by this query.

+ +

2.6 Updating Persistent Objects

+ +

While making objects persistent and then selecting some of them using + queries are two useful operations, most applications will also need + to change the object's state and then make these changes persistent. + Let's illustrate this by updating Joe's age who just had a birthday:

+ + 
+// driver.cxx
+//
+
+...
+
+int
+main (int argc, char* argv[])
+{
+  try
+  {
+    ...
+
+    unsigned long john_id, jane_id, joe_id;
+
+    // Create a few persistent person objects.
+    //
+    {
+      ...
+
+      // Save object ids for later use.
+      //
+      john_id = john.id ();
+      jane_id = jane.id ();
+      joe_id = joe.id ();
+    }
+
+    // Joe Dirt just had a birthday, so update his age.
+    //
+    {
+      transaction t (db->begin ());
+
+      auto_ptr<person> joe (db->load<person> (joe_id));
+      joe->age (joe->age () + 1);
+      db->update (*joe);
+
+      t.commit ();
+    }
+
+    // Say hello to those over 30.
+    //
+    {
+      ...
+    }
+  }
+  catch (const odb::exception& e)
+  {
+    cerr << e.what () << endl;
+    return 1;
+  }
+}
+
+ +

The beginning and the end of the new transaction are the same as + the previous two. Once within a transaction, we call the + load() database function to instantiate a + person object with Joe's persistent state. We + pass Joe's object identifier that we stored earlier when we + made this object persistent. While here we use + std::auto_ptr to manage the returned object, we + could have also used another smart pointer, for example + std::unique_ptr from C++11 or shared_ptr + from TR1, C++11, or Boost. For more information + on the object lifetime management and the smart pointers that we + can use for that, see Section 3.3, "Object + and View Pointers".

+ +

With the instantiated object in hand we increment the age + and call the update() function to update + the object's state in the database. Once the transaction is + committed, the changes are made permanent.

+ +

If we now run this application, we will see Joe in the output + since he is now over 30:

+ + 
+mysql --user=odb_test --database=odb_test < person.sql
+./driver --user odb_test --database odb_test
+
+Hello, John!
+Hello, Jane!
+Hello, Joe!
+
+ +

What if we didn't have an identifier for Joe? Maybe this object + was made persistent in another run of our application or by another + application altogether. Provided that we only have one Joe Dirt + in the database, we can use the query facility to come up with + an alternative implementation of the above transaction:

+ + 
+    // Joe Dirt just had a birthday, so update his age. An
+    // alternative implementation without using the object id.
+    //
+    {
+      transaction t (db->begin ());
+
+      // Here we know that there can be only one Joe Dirt in our
+      // database so we use the query_one() shortcut instead of
+      // manually iterating over the result returned by query().
+      //
+      auto_ptr<person> joe (
+        db->query_one<person> (query::first == "Joe" &&
+                               query::last == "Dirt"));
+
+      if (joe.get () != 0)
+      {
+        joe->age (joe->age () + 1);
+        db->update (*joe);
+      }
+
+      t.commit ();
+    }
+
+ +

2.7 Defining and Using Views

+ +

Suppose that we need to gather some basic statistics about the people + stored in our database. Things like the total head count, as well as + the minimum and maximum ages. One way to do it would be to query + the database for all the person objects and then + calculate this information as we iterate over the query result. + While this approach may work fine for our database with just three + people in it, it would be very inefficient if we had a large + number of objects.

+ +

While it may not be conceptually pure from the object-oriented + programming point of view, a relational database can perform + some computations much faster and much more economically than + if we performed the same operations ourselves in the application's + process.

+ +

To support such cases ODB provides the notion of views. An ODB view + is a C++ class that embodies a light-weight, read-only + projection of one or more persistent objects or database tables or + the result of a native SQL query execution or stored procedure + call.

+ +

Some of the common applications of views include loading a subset of + data members from objects or columns database tables, executing and + handling results of arbitrary SQL queries, including aggregate + queries, as well as joining multiple objects and/or database + tables using object relationships or custom join conditions.

+ +

While you can find a much more detailed description of views in + Chapter 10, "Views", here is how we can define + the person_stat view that returns the basic statistics + about the person objects:

+ + 
+#pragma db view object(person)
+struct person_stat
+{
+  #pragma db column("count(" + person::id_ + ")")
+  std::size_t count;
+
+  #pragma db column("min(" + person::age_ + ")")
+  unsigned short min_age;
+
+  #pragma db column("max(" + person::age_ + ")")
+  unsigned short max_age;
+};
+
+ +

Normally, to get the result of a view we use the same + query() function as when querying the database for + an object. Here, however, we are executing an aggregate query + which always returns exactly one element. Therefore, instead + of getting the result instance and then iterating over it, we + can use the shortcut query_value() function. Here is + how we can load and print our statistics using the view we have + just created:

+ + 
+    // Print some statistics about all the people in our database.
+    //
+    {
+      transaction t (db->begin ());
+
+      // The result of this query always has exactly one element.
+      //
+      person_stat ps (db->query_value<person_stat> ());
+
+      cout << "count  : " << ps.count << endl
+           << "min age: " << ps.min_age << endl
+           << "max age: " << ps.max_age << endl;
+
+      t.commit ();
+    }
+
+ +

If we now add the person_stat view to the + person.hxx header, the above transaction + to driver.cxx, as well as re-compile and + re-run our example, then we will see the following + additional lines in the output:

+ + 
+count  : 3
+min age: 31
+max age: 33
+
+ +

2.8 Deleting Persistent Objects

+ +

The last operation that we will discuss in this chapter is deleting + the persistent object from the database. The following code + fragment shows how we can delete an object given its identifier:

+ + 
+    // John Doe is no longer in our database.
+    //
+    {
+      transaction t (db->begin ());
+      db->erase<person> (john_id);
+      t.commit ();
+    }
+
+ +

To delete John from the database we start a transaction, call + the erase() database function with John's object + id, and commit the transaction. After the transaction is committed, + the erased object is no longer persistent.

+ +

If we don't have an object id handy, we can use queries to find + and delete the object:

+ + 
+    // John Doe is no longer in our database. An alternative
+    // implementation without using the object id.
+    //
+    {
+      transaction t (db->begin ());
+
+      // Here we know that there can be only one John Doe in our
+      // database so we use the query_one() shortcut again.
+      //
+      auto_ptr<person> john (
+        db->query_one<person> (query::first == "John" &&
+                               query::last == "Doe"));
+
+      if (john.get () != 0)
+        db->erase (*john);
+
+      t.commit ();
+    }
+
+ +

2.9 Changing Persistent Classes

+ +

When the definition of a transient C++ class is changed, for + example by adding or deleting a data member, we don't have to + worry about any existing instances of this class not matching + the new definition. After all, to make the class changes + effective we have to restart the application and none of the + transient instances will survive this.

+ +

Things are not as simple for persistent classes. Because they + are stored in the database and therefore survive application + restarts, we have a new problem: what happens to the state of + existing objects (which correspond to the old definition) once + we change our persistent class?

+ +

The problem of working with old objects, called database + schema evolution, is a complex issue and ODB provides + comprehensive support for handling it. While this support + is covered in detail in Chapter 13, + "Database Schema Evolution", let us consider a simple + example that should give us a sense of the functionality + provided by ODB in this area.

+ +

Suppose that after using our person persistent + class for some time and creating a number of databases + containing its instances, we realized that for some people + we also need to store their middle name. If we go ahead and + just add the new data member, everything will work fine + with new databases. Existing databases, however, have a + table that does not correspond to the new class definition. + Specifically, the generated database support code now + expects there to be a column to store the middle name. + But such a column was never created in the old databases.

+ +

ODB can automatically generate SQL statements that will + migrate old databases to match the new class definitions. + But first, we need to enable schema evolution support by + defining a version for our object model:

+ + 
+// person.hxx
+//
+
+#pragma db model version(1, 1)
+
+class person
+{
+  ...
+
+  std::string first_;
+  std::string last_;
+  unsigned short age_;
+};
+
+ +

The first number in the version pragma is the + base model version. This is the lowest version we will be + able to migrate from. The second number is the current model + version. Since we haven't made any changes yet to our + persistent class, both of these values are 1.

+ +

Next we need to re-compile our person.hxx header + file with the ODB compiler, just as we did before:

+ + 
+odb -d mysql --generate-query --generate-schema person.hxx
+
+ +

If we now look at the list of files produced by the ODB compiler, + we will notice a new file: person.xml. This + is a changelog file where the ODB compiler keeps track of the + database changes corresponding to our class changes. Note that + this file is automatically maintained by the ODB compiler and + all we have to do is keep it around between re-compilations.

+ +

Now we are ready to add the middle name to our person + class. We also give it a default value (empty string) which + is what will be assigned to existing objects in old databases. + Notice that we have also incremented the current version:

+ + 
+// person.hxx
+//
+
+#pragma db model version(1, 2)
+
+class person
+{
+  ...
+
+  std::string first_;
+
+  #pragma db default("")
+  std::string middle_;
+
+  std::string last_;
+  unsigned short age_;
+};
+
+ +

If we now recompile the person.hxx header again, we will + see two extra generated files: person-002-pre.sql + and person-002-post.sql. These two files contain + schema migration statements from version 1 to + version 2. Similar to schema creation, schema + migration statements can also be embedded into the generated + C++ code.

+ +

person-002-pre.sql and person-002-post.sql + are the pre and post schema migration files. To migrate + one of our old databases, we first execute the pre migration + file:

+ + 
+mysql --user=odb_test --database=odb_test < person-002-pre.sql
+
+ +

Between the pre and post schema migrations we can run data + migration code, if required. At this stage, we can both + access the old and store the new data. In our case we don't + need any data migration code since we assigned the default + value to the middle name for all the existing objects.

+ +

To finish the migration process we execute the post migration + statements:

+ + 
+mysql --user=odb_test --database=odb_test < person-002-post.sql
+
+ +

2.10 Working with Multiple Databases

+ +

Accessing multiple databases (that is, data stores) is simply a + matter of creating multiple odb::<db>::database + instances representing each database. For example:

+ + 
+odb::mysql::database db1 ("john", "secret", "test_db1");
+odb::mysql::database db2 ("john", "secret", "test_db2");
+
+ +

Some database systems also allow attaching multiple databases to + the same instance. A more interesting question is how we access + multiple database systems (that is, database implementations) from + the same application. For example, our application may need to store + some objects in a remote MySQL database and others in a local SQLite + file. Or, our application may need to be able to store its objects + in a database system that is selected by the user at runtime.

+ +

ODB provides comprehensive multi-database support that ranges from + tight integration with specific database systems to being able to + write database-agnostic code and loading individual database systems + support dynamically. While all these aspects are covered in detail + in Chapter 16, "Multi-Database Support", in this + section we will get a taste of this functionality by extending our + "Hello World" example to be able to store its data either in MySQL + or PostgreSQL (other database systems supported by ODB can be added + in a similar manner).

+ +

The first step in adding multi-database support is to re-compile + our person.hxx header to generate database support + code for additional database systems:

+ + 
+odb --multi-database dynamic -d common -d mysql -d pgsql \
+--generate-query --generate-schema person.hxx
+
+ +

The --multi-database ODB compiler option turns on + multi-database support. For now it is not important what the + dynamic value that we passed to this option means, but + if you are curious, see Chapter 16. The result of this + command are three sets of generated files: person-odb.?xx + (common interface; corresponds to the common database), + person-odb-mysql.?xx (MySQL support code), and + person-odb-pgsql.?xx (PostgreSQL support code). There + are also two schema files: person-mysql.sql and + person-pgsql.sql.

+ +

The only part that we need to change in driver.cxx + is how we create the database instance. Specifically, this line:

+ + 
+auto_ptr<database> db (new odb::mysql::database (argc, argv));
+
+ +

Now our example is capable of storing its data either in MySQL or + PostgreSQL so we need to somehow allow the caller to specify which + database we must use. To keep things simple, we will make the first + command line argument specify the database system we must use while + the rest will contain the database-specific options which we will + pass to the odb::<db>::database constructor as + before. Let's put all this logic into a separate function which we + will call create_database(). Here is what the beginning + of our modified driver.cxx will look like (the remainder + is unchanged):

+ + 
+// driver.cxx
+//
+
+#include <string>
+#include <memory>   // std::auto_ptr
+#include <iostream>
+
+#include <odb/database.hxx>
+#include <odb/transaction.hxx>
+
+#include <odb/mysql/database.hxx>
+#include <odb/pgsql/database.hxx>
+
+#include "person.hxx"
+#include "person-odb.hxx"
+
+using namespace std;
+using namespace odb::core;
+
+auto_ptr<database>
+create_database (int argc, char* argv[])
+{
+  auto_ptr<database> r;
+
+  if (argc < 2)
+  {
+    cerr << "error: database system name expected" << endl;
+    return r;
+  }
+
+  string db (argv[1]);
+
+  if (db == "mysql")
+    r.reset (new odb::mysql::database (argc, argv));
+  else if (db == "pgsql")
+    r.reset (new odb::pgsql::database (argc, argv));
+  else
+    cerr << "error: unknown database system " << db << endl;
+
+  return r;
+}
+
+int
+main (int argc, char* argv[])
+{
+  try
+  {
+    auto_ptr<database> db (create_database (argc, argv));
+
+    if (db.get () == 0)
+      return 1; // Diagnostics has already been issued.
+
+    ...
+
+ +

And that's it. The only thing left is to build and run our + example:

+ + 
+c++ -c driver.cxx
+c++ -c person-odb.cxx
+c++ -c person-odb-mysql.cxx
+c++ -c person-odb-pgsql.cxx
+c++ -o driver driver.o person-odb.o person-odb-mysql.o \
+person-odb-pgsql.o -lodb-mysql -lodb-pgsql -lodb
+
+ +

Here is how we can access a MySQL database:

+ + 
+mysql --user=odb_test --database=odb_test < person-mysql.sql
+./driver mysql --user odb_test --database odb_test
+
+ +

Or a PostgreSQL database:

+ + 
+psql --user=odb_test --dbname=odb_test -f person-pgsql.sql
+./driver pgsql --user odb_test --database odb_test
+
+ +

2.11 Summary

+ +

This chapter presented a very simple application which, nevertheless, + exercised all of the core database functions: persist(), + query(), load(), update(), + and erase(). We also saw that writing an application + that uses ODB involves the following steps:

+ +
    +
  1. Declare persistent classes in header files.
    2. +
  2. Compile these headers to generate database support code.
    3. +
  3. Link the application with the generated code and two ODB runtime + libraries.
    4. +
+ +

Do not be concerned if, at this point, much appears unclear. The intent + of this chapter is to give you only a general idea of how to persist C++ + objects with ODB. We will cover all the details throughout the remainder + of this manual.

+ + + + + +
+

3 Working with Persistent Objects

+ +

The previous chapters gave us a high-level overview of ODB and + showed how to use it to store C++ objects in a database. In this + chapter we will examine the ODB object persistence model as + well as the core database APIs in greater detail. We will + start with basic concepts and terminology in Section + 3.1 and Section 3.3 and continue with the + discussion of the odb::database class in + Section 3.4, transactions in + Section 3.5, and connections in + Section 3.6. The remainder of this chapter + deals with the core database operations and concludes with + the discussion of ODB exceptions.

+ +

In this chapter we will continue to use and expand the + person persistent class that we have developed in the + previous chapter.

+ +

3.1 Concepts and Terminology

+ +

The term database can refer to three distinct things: + a general notion of a place where an application stores its data, + a software implementation for managing this data (for example + MySQL), and, finally, some database software implementations + may manage several data stores which are usually distinguished + by name. This name is also commonly referred to as a database.

+ +

In this manual, when we use the word database, we + refer to the first meaning above, for example, + "The update() function saves the object's state to + the database." The term Database Management System (DBMS) is + often used to refer to the second meaning of the word database. + In this manual we will use the term database system + for short, for example, "Database system-independent + application code." Finally, to distinguish the third meaning + from the other two, we will use the term database name, + for example, "The second option specifies the database name + that the application should use to store its data."

+ +

In C++ there is only one notion of a type and an instance + of a type. For example, a fundamental type, such as int, + is, for the most part, treated the same as a user defined class + type. However, when it comes to persistence, we have to place + certain restrictions and requirements on certain C++ types that + can be stored in the database. As a result, we divide persistent + C++ types into two groups: object types and value + types. An instance of an object type is called an object + and an instance of a value type — a value.

+ +

An object is an independent entity. It can be stored, updated, + and deleted in the database independent of other objects. + Normally, an object has an identifier, called object id, + that is unique among all instances of an object type within a + database. In contrast, a value can only be stored in the database + as part of an object and doesn't have its own unique identifier.

+ +

An object consists of data members which are either values + (Chapter 7, "Value Types"), pointers + to other objects (Chapter 6, "Relationships"), or + containers of values or pointers to other objects (Chapter + 5, "Containers"). Pointers to other objects and containers can + be viewed as special kinds of values since they also can only + be stored in the database as part of an object.

+ +

An object type is a C++ class. Because of this one-to-one + relationship, we will use terms object type + and object class interchangeably. In contrast, + a value type can be a fundamental C++ type, such as + int or a class type, such as std::string. + If a value consists of other values, then it is called a + composite value and its type — a + composite value type (Section 7.2, + "Composite Value Types"). Otherwise, the value is + called simple value and its type — a + simple value type (Section 7.1, + "Simple Value Types"). Note that the distinction between + simple and composite values is conceptual rather than + representational. For example, std::string + is a simple value type because conceptually string is a + single value even though the representation of the string + class may contain several data members each of which could be + considered a value. In fact, the same value type can be + viewed (and mapped) as both simple and composite by different + applications.

+ +

While not strictly necessary in a purely object-oriented application, + practical considerations often require us to only load a + subset of an object's data members or a combination of members + from several objects. We may also need to factor out some + computations to the relational database instead of performing + them in the application's process. To support such requirements + ODB distinguishes a third kind of C++ types, called views + (Chapter 10, "Views"). An ODB view is a C++ + class that embodies a light-weight, read-only + projection of one or more persistent objects or database + tables or the result of a native SQL query execution.

+ +

Understanding how all these concepts map to the relational model + will hopefully make these distinctions clearer. In a relational + database an object type is mapped to a table and a value type is + mapped to one or more columns. A simple value type is mapped + to a single column while a composite value type is mapped to + several columns. An object is stored as a row in this + table and a value is stored as one or more cells in this row. + A simple value is stored in a single cell while a composite + value occupies several cells. A view is not a persistent + entity and it is not stored in the database. Rather, it is a + data structure that is used to capture a single row of an SQL + query result.

+ +

Going back to the distinction between simple and composite + values, consider a date type which has three integer + members: year, month, and day. In one application it can be + considered a composite value and each member will get its + own column in a relational database. In another application + it can be considered a simple value and stored in a single + column as a number of days from some predefined date.

+ +

Until now, we have been using the term persistent class + to refer to object classes. We will continue to do so even though + a value type can also be a class. The reason for this asymmetry + is the subordinate nature of value types when it comes to + database operations. Remember that values are never stored + directly but rather as part of an object that contains them. + As a result, when we say that we want to make a C++ class + persistent or persist an instance of a class in the database, + we invariably refer to an object class rather than a value + class.

+ +

Normally, you would use object types to model real-world entities, + things that have their own identity. For example, in the + previous chapter we created a person class to model + a person, which is a real-world entity. Name and age, which we + used as data members in our person class are clearly + values. It is hard to think of age 31 or name "Joe" as having their + own identities.

+ +

A good test to determine whether something is an object or + a value, is to consider if other objects might reference + it. A person is clearly an object because it can be referred + to by other objects such as a spouse, an employer, or a + bank. On the other hand, a person's age or name is not + something that other objects would normally refer to.

+ +

Also, when an object represents a real entity, it is easy to + choose a suitable object id. For example, for a + person there is an established notion of an identifier + (SSN, student id, passport number, etc). Another alternative + is to use a person's email address as an identifier.

+ +

Note, however, that these are only guidelines. There could + be good reasons to make something that would normally be + a value an object. Consider, for example, a database that + stores a vast number of people. Many of the person + objects in this database have the same names and surnames and + the overhead of storing them in every object may negatively + affect the performance. In this case, we could make the first name + and last name each an object and only store pointers to + these objects in the person class.

+ +

An instance of a persistent class can be in one of two states: + transient and persistent. A transient + instance only has a representation in the application's + memory and will cease to exist when the application terminates, + unless it is explicitly made persistent. In other words, a + transient instance of a persistent class behaves just like an + instance of any ordinary C++ class. A persistent instance + has a representation in both the application's memory and the + database. A persistent instance will remain even after the + application terminates unless and until it is explicitly + deleted from the database.

+ +

3.2 Declaring Persistent Objects and Values

+ +

To make a C++ class a persistent object class we declare + it as such using the db object pragma, for + example:

+ + 
+#pragma db object
+class person
+{
+  ...
+};
+
+ +

The other pragma that we often use is db id + which designates one of the data members as an object id, for + example:

+ + 
+#pragma db object
+class person
+{
+  ...
+
+  #pragma db id
+  unsigned long id_;
+};
+
+ +

The object id can be of a simple or composite (Section + 7.2.1, "Composite Object Ids") value type. This type should be + default-constructible, copy-constructible, and copy-assignable. It + is also possible to declare a persistent class without an object id, + however, such a class will have limited functionality + (Section 14.1.6, "no_id").

+ +

The above two pragmas are the minimum required to declare a + persistent class with an object id. Other pragmas can be used to + fine-tune the database-related properties of a class and its + members (Chapter 14, "ODB Pragma Language").

+ +

Normally, a persistent class should define the default constructor. The + generated database support code uses this constructor when + instantiating an object from the persistent state. If we add the + default constructor only for the database support code, then we + can make it private provided we also make the odb::access + class, defined in the <odb/core.hxx> header, a + friend of this object class. For example:

+ + 
+#include <odb/core.hxx>
+
+#pragma db object
+class person
+{
+  ...
+
+private:
+  friend class odb::access;
+  person () {}
+};
+
+ +

It is also possible to have an object class without the default + constructor. However, in this case, the database operations will + only be able to load the persistent state into an existing instance + (Section 3.9, "Loading Persistent Objects", + Section 4.4, "Query Result").

+ +

The ODB compiler also needs access to the non-transient + (Section 14.4.11, "transient") + data members of a persistent class. The ODB compiler can access + such data members directly if they are public. It can also do + so if they are private or protected and the odb::access + class is declared a friend of the object type. For example:

+ + 
+#include <odb/core.hxx>
+
+#pragma db object
+class person
+{
+  ...
+
+private:
+  friend class odb::access;
+  person () {}
+
+  #pragma db id
+  unsigned long id_;
+
+  std::string name_;
+};
+
+ +

If data members are not accessible directly, then the ODB + compiler will try to automatically find suitable accessor and + modifier functions. To accomplish this, the ODB compiler will + try to lookup common accessor and modifier names derived from + the data member name. Specifically, for the name_ + data member in the above example, the ODB compiler will look + for accessor functions with names: get_name(), + getName(), getname(), and just + name() as well as for modifier functions with + names: set_name(), setName(), + setname(), and just name(). You can + also add support for custom name derivations with the + --accessor-regex and --modifier-regex + ODB compiler options. Refer to the + ODB + Compiler Command Line Manual for details on these options. + The following example illustrates automatic accessor and modifier + discovery:

+ + 
+#pragma db object
+class person
+{
+public:
+  person () {}
+
+  ...
+
+  unsigned long id () const;
+  void id (unsigned long);
+
+  const std::string& get_name () const;
+  std::string& set_name ();
+
+private:
+  #pragma db id
+  unsigned long id_; // Uses id() for access.
+
+  std::string name_; // Uses get_name()/set_name() for access.
+};
+
+ +

Finally, if a data member is not directly accessible and the + ODB compiler was unable to discover suitable accessor and + modifier functions, then we can provide custom accessor + and modifier expressions using the db get + and db set pragmas. For more information + on custom accessor and modifier expressions refer to + Section 14.4.5, + "get/set/access".

+ +

Data members of a persistent class can also be split into + separately-loaded and/or separately-updated sections. + For more information on this functionality, refer to + Chapter 9, "Sections".

+ +

You may be wondering whether we also have to declare value types + as persistent. We don't need to do anything special for simple value + types such as int or std::string since the + ODB compiler knows how to map them to suitable database types and + how to convert between the two. On the other hand, if a simple value + is unknown to the ODB compiler then we will need to provide the + mapping to the database type and, possibly, the code to + convert between the two. For more information on how to achieve + this refer to the db type pragma description + in Section 14.3.1, "type".

+ +

Similar to object classes, composite value types have to be + explicitly declared as persistent using the db value + pragma, for example:

+ + 
+#pragma db value
+class name
+{
+  ...
+
+  std::string first_;
+  std::string last_;
+};
+
+ +

Note that a composite value cannot have a data member designated + as an object id since, as we have discussed earlier, values do + not have a notion of identity. A composite value type also doesn't + have to define the default constructor, unless it is used as an + element of a container. The ODB compiler uses the same mechanisms + to access data members in composite value types as in object types. + Composite value types are discussed in more detail in + Section 7.2, "Composite Value Types".

+ +

3.3 Object and View Pointers

+ +

As we have seen in the previous chapter, some database operations + create dynamically allocated instances of persistent classes and + return pointers to these instances. As we will see in later chapters, + pointers are also used to establish relationships between objects + (Chapter 6, "Relationships") as well as to cache + persistent objects in a session (Chapter 11, + "Session"). While in most cases you won't need to deal with + pointers to views, it is possible to a obtain a dynamically allocated + instance of a view using the result_iterator::load() + function (Section 4.4, "Query Results").

+ +

By default, all these mechanisms use raw pointers to return + objects and views as well as to pass and cache objects. This + is normally sufficient for applications + that have simple object lifetime requirements and do not use sessions + or object relationships. In particular, a dynamically allocated object + or view that is returned as a raw pointer from a database operation + can be assigned to a smart pointer of our choice, for example + std::auto_ptr, std::unique_ptr from C++11, or + shared_ptr from TR1, C++11, or Boost.

+ +

However, to avoid any possibility of a mistake, such as forgetting + to use a smart pointer for a returned object or view, as well as to + simplify the use of more advanced ODB functionality, such as sessions + and bidirectional object relationships, it is recommended that you use + smart pointers with the sharing semantics as object pointers. + The shared_ptr smart pointer from TR1, C++11, or Boost + is a good default choice. However, if sharing is not required and + sessions are not used, then std::unique_ptr or + std::auto_ptr can be used just as well.

+ +

ODB provides several mechanisms for changing the object or view pointer + type. To specify the pointer type on the per object or per view basis + we can use the db pointer pragma, for example:

+ + 
+#pragma db object pointer(std::tr1::shared_ptr)
+class person
+{
+  ...
+};
+
+ +

We can also specify the default pointer for a group of objects or + views at the namespace level:

+ + 
+#pragma db namespace pointer(std::tr1::shared_ptr)
+namespace accounting
+{
+  #pragma db object
+  class employee
+  {
+    ...
+  };
+
+  #pragma db object
+  class employer
+  {
+    ...
+  };
+}
+
+ +

Finally, we can use the --default-pointer option to specify + the default pointer for the whole file. Refer to the + ODB + Compiler Command Line Manual for details on this option's argument. + The typical usage is shown below:

+ + 
+--default-pointer std::tr1::shared_ptr
+
+ +

An alternative to this method with the same effect is to specify the + default pointer for the global namespace:

+ + 
+#pragma db namespace() pointer(std::tr1::shared_ptr)
+
+ +

Note that we can always override the default pointer specified + at the namespace level or with the command line option using + the db pointer object or view pragma. For + example:

+ + 
+#pragma db object pointer(std::shared_ptr)
+namespace accounting
+{
+  #pragma db object
+  class employee
+  {
+    ...
+  };
+
+  #pragma db object pointer(std::unique_ptr)
+  class employer
+  {
+    ...
+  };
+}
+
+ +

Refer to Section 14.1.2, "pointer + (object)", Section 14.2.4, "pointer + (view)", and Section 14.5.1, "pointer + (namespace)" for more information on these mechanisms.

+ +

Built-in support that is provided by the ODB runtime library allows us + to use shared_ptr (TR1 or C++11), + std::unique_ptr (C++11), or std::auto_ptr as + pointer types. Plus, ODB profile libraries, that are available for + commonly used frameworks and libraries (such as Boost and Qt), + provide support for smart pointers found in these frameworks and + libraries (Part III, "Profiles"). It is also + easy to add support for our own smart pointers, as described in + Section 6.5, "Using Custom Smart Pointers".

+ +

3.4 Database

+ +

Before an application can make use of persistence services + offered by ODB, it has to create a database class instance. A + database instance is the representation of the place where + the application stores its persistent objects. We create + a database instance by instantiating one of the database + system-specific classes. For example, odb::mysql::database + would be such a class for the MySQL database system. We will + also normally pass a database name as an argument to the + class' constructor. The following code fragment + shows how we can create a database instance for the MySQL + database system:

+ + 
+#include <odb/database.hxx>
+#include <odb/mysql/database.hxx>
+
+auto_ptr<odb::database> db (
+  new odb::mysql::database (
+    "test_user"     // database login name
+    "test_password" // database password
+    "test_database" // database name
+    ));
+
+ +

The odb::database class is a common interface for + all the database system-specific classes provided by ODB. You + would normally work with the database + instance via this interface unless there is a specific + functionality that your application depends on and which is + only exposed by a particular system's database + class. You will need to include the <odb/database.hxx> + header file to make this class available in your application.

+ +

The odb::database interface defines functions for + starting transactions and manipulating persistent objects. + These are discussed in detail in the remainder of this chapter + as well as the next chapter which is dedicated to the topic of + querying the database for persistent objects. For details on the + system-specific database classes, refer to + Part II, "Database Systems".

+ +

Before we can persist our objects, the corresponding database schema has + to be created in the database. The schema contains table definitions and + other relational database artifacts that are used to store the state of + persistent objects in the database.

+ +

There are several ways to create the database schema. The easiest is to + instruct the ODB compiler to generate the corresponding schema from the + persistent classes (--generate-schema option). The ODB + compiler can generate the schema as a standalone SQL file, + embedded into the generated C++ code, or as a separate C++ source file + (--schema-format option). If we are using the SQL file + to create the database schema, then this file should be executed, + normally only once, before the application is started.

+ +

Alternatively, if the schema is embedded directly into the generated + code or produced as a separate C++ source file, then we can use the + odb::schema_catalog class to create it in the database + from within our application, for example:

+ + 
+#include <odb/schema-catalog.hxx>
+
+odb::transaction t (db->begin ());
+odb::schema_catalog::create_schema (*db);
+t.commit ();
+
+ +

Refer to the next section for information on the + odb::transaction class. The complete version of the above + code fragment is available in the schema/embedded example in + the odb-examples package.

+ +

The odb::schema_catalog class has the following interface. + You will need to include the <odb/schema-catalog.hxx> + header file to make this class available in your application.

+ + 
+namespace odb
+{
+  class schema_catalog
+  {
+  public:
+    static void
+    create_schema (database&,
+                   const std::string& name = "",
+                   bool drop = true);
+
+    static void
+    drop_schema (database&, const std::string& name = "");
+
+    static bool
+    exists (database_id, const std::string& name = "");
+
+    static bool
+    exists (const database&, const std::string& name = "")
+  };
+}
+
+ +

The first argument to the create_schema() function + is the database instance that we would like to create the schema in. + The second argument is the schema name. By default, the ODB + compiler generates all embedded schemas with the default schema + name (empty string). However, if your application needs to + have several separate schemas, you can use the + --schema-name ODB compiler option to assign + custom schema names and then use these names as a second argument + to create_schema(). By default, create_schema() + will also delete all the database objects (tables, indexes, etc.) if + they exist prior to creating the new ones. You can change this + behavior by passing false as the third argument. The + drop_schema() function allows you to delete all the + database objects without creating the new ones.

+ +

If the schema is not found, the create_schema() and + drop_schema() functions throw the + odb::unknown_schema exception. You can use the + exists() function to check whether a schema for the + specified database and with the specified name exists in the + catalog. Note also that the create_schema() and + drop_schema() functions should be called within a + transaction.

+ +

ODB also provides support for database schema evolution. Similar + to schema creation, schema migration statements can be generated + either as standalone SQL files or embedded into the generated C++ + code. For more information on schema evolution support, refer to + Chapter 13, "Database Schema Evolution".

+ +

Finally, we can also use a custom database schema with ODB. This approach + can work similarly to the standalone SQL file described above except that + the database schema is hand-written or produced by another program. Or we + could execute custom SQL statements that create the schema directly from + our application. To map persistent classes to custom database schemas, ODB + provides a wide range of mapping customization pragmas, such + as db table, db column, + and db type (Chapter 14, "ODB Pragma + Language"). For sample code that shows how to perform such mapping + for various C++ constructs, refer to the schema/custom + example in the odb-examples package.

+ +

3.5 Transactions

+ +

A transaction is an atomic, consistent, isolated and durable + (ACID) unit of work. Database operations can only be + performed within a transaction and each thread of execution + in an application can have only one active transaction at a + time.

+ +

By atomicity we mean that when it comes to making changes to + the database state within a transaction, + either all the changes are applied or none at all. Consider, + for example, a transaction that transfers funds between two + objects representing bank accounts. If the debit function + on the first object succeeds but the credit function on + the second fails, the transaction is rolled back and the + database state of the first object remains unchanged.

+ +

By consistency we mean that a transaction must take all the + objects stored in the database from one consistent state + to another. For example, if a bank account object must + reference a person object as its owner and we forget to + set this reference before making the object persistent, + the transaction will be rolled back and the database + will remain unchanged.

+ +

By isolation we mean that the changes made to the database + state during a transaction are only visible inside this + transaction until and unless it is committed. Using the + above example with the bank transfer, the results of the + debit operation performed on the first object is not + visible to other transactions until the credit operation + is successfully completed and the transaction is committed.

+ +

By durability we mean that once the transaction is committed, + the changes that it made to the database state are permanent + and will survive failures such as an application crash. From + now on the only way to alter this state is to execute and commit + another transaction.

+ +

A transaction is started by calling either the + database::begin() or connection::begin() + function. The returned transaction handle is stored in + an instance of the odb::transaction class. + You will need to include the <odb/transaction.hxx> + header file to make this class available in your application. + For example:

+ + 
+#include <odb/transaction.hxx>
+
+transaction t (db.begin ())
+
+// Perform database operations.
+
+t.commit ();
+
+ +

The odb::transaction class has the following + interface:

+ + 
+namespace odb
+{
+  class transaction
+  {
+  public:
+    typedef odb::database database_type;
+    typedef odb::connection connection_type;
+
+    explicit
+    transaction (transaction_impl*, bool make_current = true);
+
+    transaction ();
+
+    void
+    reset (transaction_impl*, bool make_current = true);
+
+    void
+    commit ();
+
+    void
+    rollback ();
+
+    database_type&
+    database ();
+
+    connection_type&
+    connection ();
+
+    bool
+    finilized () const;
+
+  public:
+    static bool
+    has_current ();
+
+    static transaction&
+    current ();
+
+    static void
+    current (transaction&);
+
+    static bool
+    reset_current ();
+
+    // Callback API.
+    //
+  public:
+    ...
+  };
+}
+
+ +

The commit() function commits a transaction and + rollback() rolls it back. Unless the transaction + has been finalized, that is, explicitly committed or rolled + back, the destructor of the transaction class will + automatically roll it back when the transaction instance goes + out of scope. If we try to commit or roll back a finalized + transaction, the odb::transaction_already_finalized + exception is thrown.

+ +

The database() accessor returns the database this + transaction is working on. Similarly, the connection() + accessor returns the database connection this transaction is on + (Section 3.6, "Connections").

+ +

The static current() accessor returns the + currently active transaction for this thread. If there is no active + transaction, this function throws the odb::not_in_transaction + exception. We can check whether there is a transaction in effect in + this thread using the has_current() static function.

+ +

The make_current argument in the transaction + constructor as well as the static current() modifier and + reset_current() function give us additional + control over the nomination of the currently active transaction. + If we pass false as the make_current + argument, then the newly created transaction will not + automatically be made the active transaction for this + thread. Later, we can use the static current() modifier + to set this transaction as the active transaction. + The reset_current() static function clears the + currently active transaction. Together, these mechanisms + allow for more advanced use cases, such as multiplexing + two or more transactions on the same thread. For example:

+ + 
+transaction t1 (db1.begin ());        // Active transaction.
+transaction t2 (db2.begin (), false); // Not active.
+
+// Perform database operations on db1.
+
+transaction::current (t2);            // Deactivate t1, activate t2.
+
+// Perform database operations on db2.
+
+transaction::current (t1);            // Switch back to t1.
+
+// Perform some more database operations on db1.
+
+t1.commit ();
+
+transaction::current (t2);            // Switch to t2.
+
+// Perform some more database operations on db2.
+
+t2.commit ();
+
+ +

The reset() modifier allows us to reuse the same + transaction instance to complete several database + transactions. Similar to the destructor, reset() + will roll the current transaction back if it hasn't been finalized. + The default transaction constructor creates a finalized + transaction which can later be initialized using reset(). + The finilized() accessor can be used to check whether the + transaction has been finalized. Here is how we can use this functionality + to commit the current transaction and start a new one every time a + certain number of database operations has been performed:

+ + 
+transaction t (db.begin ());
+
+for (size_t i (0); i < n; ++i)
+{
+  // Perform a database operation, such as persist an object.
+
+  // Commit the current transaction and start a new one after
+  // every 100 operations.
+  //
+  if (i % 100 == 0)
+  {
+    t.commit ();
+    t.reset (db.begin ());
+  }
+}
+
+t.commit ();
+
+ +

For more information on the transaction callback support, refer + to Section 15.1, "Transaction Callbacks".

+ +

Note that in the above discussion of atomicity, consistency, + isolation, and durability, all of those guarantees only apply + to the object's state in the database as opposed to the object's + state in the application's memory. It is possible to roll + a transaction back but still have changes from this + transaction in the application's memory. An easy way to + avoid this potential inconsistency is to instantiate + persistent objects only within the transaction scope. Consider, + for example, these two implementations of the same transaction:

+ + 
+void
+update_age (database& db, person& p)
+{
+  transaction t (db.begin ());
+
+  p.age (p.age () + 1);
+  db.update (p);
+
+  t.commit ();
+}
+
+ +

In the above implementation, if the update() call fails + and the transaction is rolled back, the state of the person + object in the database and the state of the same object in the + application's memory will differ. Now consider an + alternative implementation which only instantiates the + person object for the duration of the transaction:

+ + 
+void
+update_age (database& db, unsigned long id)
+{
+  transaction t (db.begin ());
+
+  auto_ptr<person> p (db.load<person> (id));
+  p.age (p.age () + 1);
+  db.update (p);
+
+  t.commit ();
+}
+
+ +

Of course, it may not always be possible to write the + application in this style. Oftentimes we need to access and + modify the application's state of persistent objects out of + transactions. In this case it may make sense to try to + roll back the changes made to the application state if + the transaction was rolled back and the database state + remains unchanged. One way to do this is to re-load + the object's state from the database, for example:

+ + 
+void
+update_age (database& db, person& p)
+{
+  try
+  {
+    transaction t (db.begin ());
+
+    p.age (p.age () + 1);
+    db.update (p);
+
+    t.commit ();
+  }
+  catch (...)
+  {
+    transaction t (db.begin ());
+    db.load (p.id (), p);
+    t.commit ();
+
+    throw;
+  }
+}
+
+ +

See also Section 15.1, "Transaction Callbacks" + for an alternative approach.

+ +

3.6 Connections

+ +

The odb::connection class represents a connection + to the database. Normally, you wouldn't work with connections + directly but rather let the ODB runtime obtain and release + connections as needed. However, certain use cases may require + obtaining a connection manually. For completeness, this section + describes the connection class and discusses some + of its use cases. You may want to skip this section if you are + reading through the manual for the first time.

+ +

Similar to odb::database, the odb::connection + class is a common interface for all the database system-specific + classes provided by ODB. For details on the system-specific + connection classes, refer to Part II, + "Database Systems".

+ +

To make the odb::connection class available in your + application you will need to include the <odb/connection.hxx> + header file. The odb::connection class has the + following interface:

+ + 
+namespace odb
+{
+  class connection
+  {
+  public:
+    typedef odb::database database_type;
+
+    transaction
+    begin () = 0;
+
+    unsigned long long
+    execute (const char* statement);
+
+    unsigned long long
+    execute (const std::string& statement);
+
+    unsigned long long
+    execute (const char* statement, std::size_t length);
+
+    database_type&
+    database ();
+  };
+
+  typedef details::shared_ptr<connection> connection_ptr;
+}
+
+ +

The begin() function is used to start a transaction + on the connection. The execute() functions allow + us to execute native database statements on the connection. + Their semantics are equivalent to the database::execute() + functions (Section 3.12, "Executing Native SQL + Statements") except that they can be legally called outside + a transaction. Finally, the database() accessor + returns a reference to the odb::database instance + to which this connection corresponds.

+ +

To obtain a connection we call the database::connection() + function. The connection is returned as odb::connection_ptr, + which is an implementation-specific smart pointer with the shared + pointer semantics. This, in particular, means that the connection + pointer can be copied and returned from functions. Once the last + instance of connection_ptr pointing to the same + connection is destroyed, the connection is returned to the + database instance. The following code fragment + shows how we can obtain, use, and release a connection:

+ + 
+using namespace odb::core;
+
+database& db = ...
+connection_ptr c (db.connection ());
+
+// Temporarily disable foreign key constraints.
+//
+c->execute ("SET FOREIGN_KEY_CHECKS = 0");
+
+// Start a transaction on this connection.
+//
+transaction t (c->begin ());
+...
+t.commit ();
+
+// Restore foreign key constraints.
+//
+c->execute ("SET FOREIGN_KEY_CHECKS = 1");
+
+// When 'c' goes out of scope, the connection is returned to 'db'.
+
+ +

Some of the use cases which may require direct manipulation of + connections include out-of-transaction statement execution, + such as the execution of connection configuration statements, + the implementation of a connection-per-thread policy, and making + sure that a set of transactions is executed on the same + connection.

+ +

3.7 Error Handling and Recovery

+ +

ODB uses C++ exceptions to report database operation errors. Most + ODB exceptions signify hard errors or errors that cannot + be corrected without some intervention from the application. + For example, if we try to load an object with an unknown object + id, the odb::object_not_persistent exception is + thrown. Our application may be able to correct this error, for + instance, by obtaining a valid object id and trying again. + The hard errors and corresponding ODB exceptions that can be + thrown by each database function are described in the remainder + of this chapter with Section 3.14, "ODB Exceptions" + providing a quick reference for all the ODB exceptions.

+ +

The second group of ODB exceptions signify soft or + recoverable errors. Such errors are temporary + failures which normally can be corrected by simply re-executing + the transaction. ODB defines three such exceptions: + odb::connection_lost, odb::timeout, + and odb::deadlock. All recoverable ODB exceptions + are derived from the common odb::recoverable base + exception which can be used to handle all the recoverable + conditions with a single catch block.

+ +

The odb::connection_lost exception is thrown if + a connection to the database is lost in the middle of + a transaction. In this situation the transaction is aborted but + it can be re-tried without any changes. Similarly, the + odb::timeout exception is thrown if one of the + database operations or the whole transaction has timed out. + Again, in this case the transaction is aborted but can be + re-tried as is.

+ +

If two or more transactions access or modify more than one object + and are executed concurrently by different applications or by + different threads within the same application, then it is possible + that these transactions will try to access objects in an incompatible + order and deadlock. The canonical example of a deadlock are + two transactions in which the first has modified object1 + and is waiting for the second transaction to commit its changes to + object2 so that it can also update object2. + At the same time the second transaction has modified object2 + and is waiting for the first transaction to commit its changes to + object1 because it also needs to modify object1. + As a result, none of the two transactions can be completed.

+ +

The database system detects such situations and automatically + aborts the waiting operation in one of the deadlocked transactions. + In ODB this translates to the odb::deadlock + recoverable exception being thrown from one of the database functions.

+ +

The following code fragment shows how to handle the recoverable + exceptions by restarting the affected transaction:

+ + 
+const unsigned short max_retries = 5;
+
+for (unsigned short retry_count (0); ; retry_count++)
+{
+  try
+  {
+    transaction t (db.begin ());
+
+    ...
+
+    t.commit ();
+    break;
+  }
+  catch (const odb::recoverable& e)
+  {
+    if (retry_count > max_retries)
+      throw retry_limit_exceeded (e.what ());
+    else
+      continue;
+  }
+}
+
+ +

3.8 Making Objects Persistent

+ +

A newly created instance of a persistent class is transient. + We use the database::persist() function template + to make a transient instance persistent. This function has four + overloaded versions with the following signatures:

+ + 
+  template <typename T>
+  typename object_traits<T>::id_type
+  persist (const T& object);
+
+  template <typename T>
+  typename object_traits<T>::id_type
+  persist (const object_traits<T>::const_pointer_type& object);
+
+  template <typename T>
+  typename object_traits<T>::id_type
+  persist (T& object);
+
+  template <typename T>
+  typename object_traits<T>::id_type
+  persist (const object_traits<T>::pointer_type& object);
+
+ +

Here and in the rest of the manual, + object_traits<T>::pointer_type and + object_traits<T>::const_pointer_type denote the + unrestricted and constant object pointer types (Section + 3.3, "Object and View Pointers"), respectively. + Similarly, object_traits<T>::id_type denotes the object + id type. The odb::object_traits template is part of the + database support code generated by the ODB compiler.

+ +

The first persist() function expects a constant reference + to an instance being persisted. The second function expects a constant + object pointer. Both of these functions can only be used on objects with + application-assigned object ids (Section 14.4.2, + "auto").

+ +

The second and third persist() functions are similar to the + first two except that they operate on unrestricted references and object + pointers. If the identifier of the object being persisted is assigned + by the database, these functions update the id member of the passed + instance with the assigned value. All four functions return the object + id of the newly persisted object.

+ +

If the database already contains an object of this type with this + identifier, the persist() functions throw the + odb::object_already_persistent exception. This should + never happen for database-assigned object ids as long as the + number of objects persisted does not exceed the value space of + the id type.

+ +

When calling the persist() functions, we don't need to + explicitly specify the template type since it will be automatically + deduced from the argument being passed. The following example shows + how we can call these functions:

+ + 
+person john ("John", "Doe", 33);
+shared_ptr<person> jane (new person ("Jane", "Doe", 32));
+
+transaction t (db.begin ());
+
+db.persist (john);
+unsigned long jane_id (db.persist (jane));
+
+t.commit ();
+
+cerr << "Jane's id: " << jane_id << endl;
+
+ +

Notice that in the above code fragment we have created instances + that we were planning to make persistent before starting the + transaction. Likewise, we printed Jane's id after we have committed + the transaction. As a general rule, you should avoid performing + operations within the transaction scope that can be performed + before the transaction starts or after it terminates. An active + transaction consumes both your application's resources, such as + a database connection, as well as the database server's + resources, such as object locks. By following the above rule you + make sure these resources are released and made available to other + threads in your application and to other applications as soon as + possible.

+ +

Some database systems support persisting multiple objects with a + single underlying statement execution which can result in significantly + improved performance. For such database systems ODB provides + bulk persist() functions. For details, refer to + Section 15.3, "Bulk Database Operations".

+ +

3.9 Loading Persistent Objects

+ +

Once an object is made persistent, and you know its object id, it + can be loaded by the application using the database::load() + function template. This function has two overloaded versions with + the following signatures:

+ + 
+  template <typename T>
+  typename object_traits<T>::pointer_type
+  load (const typename object_traits<T>::id_type& id);
+
+  template <typename T>
+  void
+  load (const typename object_traits<T>::id_type& id, T& object);
+
+ +

Given an object id, the first function allocates a new instance + of the object class in the dynamic memory, loads its state from + the database, and returns the pointer to the new instance. The + second function loads the object's state into an existing instance. + Both functions throw odb::object_not_persistent if + there is no object of this type with this id in the database.

+ +

When we call the first load() function, we need to + explicitly specify the object type. We don't need to do this for + the second function because the object type will be automatically + deduced from the second argument, for example:

+ + 
+transaction t (db.begin ());
+
+auto_ptr<person> jane (db.load<person> (jane_id));
+
+db.load (jane_id, *jane);
+
+t.commit ();
+
+ +

In certain situations it may be necessary to reload the state + of an object from the database. While this is easy to achieve + using the second load() function, ODB provides + the database::reload() function template that + has a number of special properties. This function has two + overloaded versions with the following signatures:

+ + 
+  template <typename T>
+  void
+  reload (T& object);
+
+  template <typename T>
+  void
+  reload (const object_traits<T>::pointer_type& object);
+
+ +

The first reload() function expects an object + reference, while the second expects an object pointer. Both + functions expect the id member in the passed object to contain + a valid object identifier and, similar to load(), + both will throw odb::object_not_persistent if + there is no object of this type with this id in the database.

+ +

The first special property of reload() + compared to the load() function is that it + does not interact with the session's object cache + (Section 11.1, "Object Cache"). That is, if + the object being reloaded is already in the cache, then it will + remain there after reload() returns. Similarly, if the + object is not in the cache, then reload() won't + put it there either.

+ +

The second special property of the reload() function + only manifests itself when operating on an object with the optimistic + concurrency model. In this case, if the states of the object + in the application memory and in the database are the same, then + no reloading will occur. For more information on optimistic + concurrency, refer to Chapter 12, "Optimistic + Concurrency".

+ +

If we don't know for sure whether an object with a given id + is persistent, we can use the find() function + instead of load(), for example:

+ + 
+  template <typename T>
+  typename object_traits<T>::pointer_type
+  find (const typename object_traits<T>::id_type& id);
+
+  template <typename T>
+  bool
+  find (const typename object_traits<T>::id_type& id, T& object);
+
+ +

If an object with this id is not found in the database, the first + find() function returns a NULL pointer + while the second function leaves the passed instance unmodified and + returns false.

+ +

If we don't know the object id, then we can use queries to + find the object (or objects) matching some criteria + (Chapter 4, "Querying the Database"). Note, + however, that loading an object's state using its + identifier can be significantly faster than executing a query.

+ + +

3.10 Updating Persistent Objects

+ +

If a persistent object has been modified, we can store the updated + state in the database using the database::update() + function template. This function has three overloaded versions with + the following signatures:

+ + 
+  template <typename T>
+  void
+  update (const T& object);
+
+  template <typename T>
+  void
+  update (const object_traits<T>::const_pointer_type& object);
+
+  template <typename T>
+  void
+  update (const object_traits<T>::pointer_type& object);
+
+ +

The first update() function expects an object reference, + while the other two expect object pointers. If the object passed to + one of these functions does not exist in the database, + update() throws the odb::object_not_persistent + exception (but see a note on optimistic concurrency below).

+ +

Below is an example of the funds transfer that we talked about + in the earlier section on transactions. It uses the hypothetical + bank_account persistent class:

+ + 
+void
+transfer (database& db,
+          unsigned long from_acc,
+          unsigned long to_acc,
+          unsigned int amount)
+{
+  bank_account from, to;
+
+  transaction t (db.begin ());
+
+  db.load (from_acc, from);
+
+  if (from.balance () < amount)
+    throw insufficient_funds ();
+
+  db.load (to_acc, to);
+
+  to.balance (to.balance () + amount);
+  from.balance (from.balance () - amount);
+
+  db.update (to);
+  db.update (from);
+
+  t.commit ();
+}
+
+ +

The same can be accomplished using dynamically allocated objects + and the update() function with object pointer argument, + for example:

+ + 
+transaction t (db.begin ());
+
+shared_ptr<bank_account> from (db.load<bank_account> (from_acc));
+
+if (from->balance () < amount)
+  throw insufficient_funds ();
+
+shared_ptr<bank_account> to (db.load<bank_account> (to_acc));
+
+to->balance (to->balance () + amount);
+from->balance (from->balance () - amount);
+
+db.update (to);
+db.update (from);
+
+t.commit ();
+
+ +

If any of the update() functions are operating on a + persistent class with the optimistic concurrency model, then they will + throw the odb::object_changed exception if the state of the + object in the database has changed since it was last loaded into the + application memory. Furthermore, for such classes, update() + no longer throws the object_not_persistent exception if + there is no such object in the database. Instead, this condition is + treated as a change of object state and object_changed + is thrown instead. For a more detailed discussion of optimistic + concurrency, refer to Chapter 12, "Optimistic + Concurrency".

+ +

In ODB, persistent classes, composite value types, as well as individual + data members can be declared read-only (see Section + 14.1.4, "readonly (object)", Section + 14.3.6, "readonly (composite value)", and + Section 14.4.12, "readonly + (data member)").

+ +

If an individual data member is declared read-only, then + any changes to this member will be ignored when updating the database + state of an object using any of the above update() + functions. A const data member is automatically treated + as read-only. If a composite value is declared read-only then all its + data members are treated as read-only.

+ +

If the whole object is declared read-only then the database state of + this object cannot be changed. Calling any of the above + update() functions for such an object will result in a + compile-time error.

+ +

Similar to persist(), for database systems that support + this functionality, ODB provides bulk update() functions. + For details, refer to Section 15.3, "Bulk Database + Operations".

+ +

3.11 Deleting Persistent Objects

+ +

To delete a persistent object's state from the database we use the + database::erase() or database::erase_query() + function templates. If the application still has an instance of the + erased object, this instance becomes transient. The erase() + function has the following overloaded versions:

+ + 
+  template <typename T>
+  void
+  erase (const T& object);
+
+  template <typename T>
+  void
+  erase (const object_traits<T>::const_pointer_type& object);
+
+  template <typename T>
+  void
+  erase (const object_traits<T>::pointer_type& object);
+
+  template <typename T>
+  void
+  erase (const typename object_traits<T>::id_type& id);
+
+ +

The first erase() function uses an object itself, in + the form of an object reference, to delete its state from the + database. The next two functions accomplish the same result but using + object pointers. Note that all three functions leave the passed + object unchanged. It simply becomes transient. The last function + uses the object id to identify the object to be deleted. If the + object does not exist in the database, then all four functions + throw the odb::object_not_persistent exception + (but see a note on optimistic concurrency below).

+ +

We have to specify the object type when calling the last + erase() function. The same is unnecessary for the + first three functions because the object type will be automatically + deduced from their arguments. The following example shows how we + can call these functions:

+ + 
+person& john = ...
+shared_ptr<jane> jane = ...
+unsigned long joe_id = ...
+
+transaction t (db.begin ());
+
+db.erase (john);
+db.erase (jane);
+db.erase<person> (joe_id);
+
+t.commit ();
+
+ +

If any of the erase() functions except the last one are + operating on a persistent class with the optimistic concurrency + model, then they will throw the odb::object_changed exception + if the state of the object in the database has changed since it was + last loaded into the application memory. Furthermore, for such + classes, erase() no longer throws the + object_not_persistent exception if there is no such + object in the database. Instead, this condition is treated as a + change of object state and object_changed is thrown + instead. For a more detailed discussion of optimistic concurrency, + refer to Chapter 12, "Optimistic Concurrency".

+ +

Similar to persist() and update(), for + database systems that support this functionality, ODB provides + bulk erase() functions. For details, refer to + Section 15.3, "Bulk Database Operations".

+ +

The erase_query() function allows us to delete + the state of multiple objects matching certain criteria. It uses + the query expression of the database::query() function + (Chapter 4, "Querying the Database") and, + because the ODB query facility is optional, it is only available + if the --generate-query ODB compiler option was + specified. The erase_query() function has the + following overloaded versions:

+ + 
+  template <typename T>
+  unsigned long long
+  erase_query ();
+
+  template <typename T>
+  unsigned long long
+  erase_query (const odb::query<T>&);
+
+ +

The first erase_query() function is used to delete + the state of all the persistent objects of a given type stored + in the database. The second function uses the passed query instance + to only delete the state of objects matching the query criteria. + Both functions return the number of objects erased. When calling + the erase_query() function, we have to explicitly + specify the object type we are erasing. For example:

+ + 
+typedef odb::query<person> query;
+
+transaction t (db.begin ());
+
+db.erase_query<person> (query::last == "Doe" && query::age < 30);
+
+t.commit ();
+
+ +

Unlike the query() function, when calling + erase_query() we cannot use members from pointed-to + objects in the query expression. However, we can still use + a member corresponding to a pointer as an ordinary object + member that has the id type of the pointed-to object + (Chapter 6, "Relationships"). This allows us + to compare object ids as well as test the pointer for + NULL. As an example, the following transaction + makes sure that all the employee objects that + reference an employer object that is about to + be deleted are deleted as well. Here we assume that the + employee class contains a pointer to the + employer class. Refer to Chapter 6, + "Relationships" for complete definitions of these + classes.

+ + 
+typedef odb::query<employee> query;
+
+transaction t (db.begin ());
+
+employer& e = ... // Employer object to be deleted.
+
+db.erase_query<employee> (query::employer == e.id ());
+db.erase (e);
+
+t.commit ();
+
+ + +

3.12 Executing Native SQL Statements

+ +

In some situations we may need to execute native SQL statements + instead of using the object-oriented database API described above. + For example, we may want to tune the database schema generated + by the ODB compiler or take advantage of a feature that is + specific to the database system we are using. The + database::execute() function, which has three + overloaded versions, provides this functionality:

+ + 
+  unsigned long long
+  execute (const char* statement);
+
+  unsigned long long
+  execute (const std::string& statement);
+
+  unsigned long long
+  execute (const char* statement, std::size_t length)
+
+ +

The first execute() function expects the SQL statement + as a zero-terminated C-string. The last version expects the explicit + statement length as the second argument and the statement itself + may contain '\0' characters, for example, to represent + binary data, if the database system supports it. All three functions + return the number of rows that were affected by the statement. For + example:

+ + 
+transaction t (db.begin ());
+
+db.execute ("DROP TABLE test");
+db.execute ("CREATE TABLE test (n INT PRIMARY KEY)");
+
+t.commit ();
+
+ +

While these functions must always be called within a transaction, + it may be necessary to execute a native statement outside a + transaction. This can be done using the + connection::execute() functions as described in + Section 3.6, "Connections".

+ +

3.13 Tracing SQL Statement Execution

+ +

Oftentimes it is useful to understand what SQL statements are + executed as a result of high-level database operations. For + example, we can use this information to figure out why certain + transactions don't produce desired results or why they take + longer than expected.

+ +

While this information can usually be obtained from the database + logs, ODB provides an application-side SQL statement tracing + support that is both more convenient and finer-grained. + For example, in a typical situation that calls for tracing + we would like to see the SQL statements executed as a result + of a specific transaction. While it may be difficult to + extract such a subset of statements from the database logs, + it is easy to achieve with ODB tracing support:

+ + 
+transaction t (db.begin ());
+t.tracer (stderr_tracer);
+
+...
+
+t.commit ();
+
+ +

ODB allows us to specify a tracer on the database, connection, + and transaction levels. If specified for the database, then + all the statements executed on this database will be traced. + On the other hand, if a tracer is specified for the + connection, then only the SQL statements executed on this + connection will be traced. Similarly, a tracer specified + for a transaction will only show statements that are + executed as part of this transaction. All three classes + (odb::database, odb::connection, + and odb::transaction) provide the identical + tracing API:

+ + 
+  void
+  tracer (odb::tracer&);
+
+  void
+  tracer (odb::tracer*);
+
+  odb::tracer*
+  tracer () const;
+
+ +

The first two tracer() functions allow us to set + the tracer object with the second one allowing us to clear the + current tracer by passing a NULL pointer. The + last tracer() function allows us to get the + current tracer object. It returns a NULL pointer + if there is no tracer in effect. Note that the tracing API + does not manage the lifetime of the tracer object. The tracer + should be valid for as long as it is being used. Furthermore, + the tracing API is not thread-safe. Trying to set a tracer + from multiple threads simultaneously will result in + undefined behavior.

+ +

The odb::tracer class defines a callback interface + that can be used to create custom tracer implementations. The + odb::stderr_tracer and odb::stderr_full_tracer + are built-in tracer implementations provided by the ODB runtime. + They both print SQL statements being executed to the standard error + stream. The full tracer, in addition to tracing statement executions, + also traces their preparations and deallocations. One situation where + the full tracer can be particularly useful is if a statement (for + example a custom query) contains a syntax error. In this case the + error will be detected during preparation and, as a result, the + statement will never be executed. The only way to see such a statement + is by using the full tracing.

+ +

The odb::tracer class is defined in the + <odb/tracer.hxx> header file which you will need to + include in order to make this class available in your application. + The odb::tracer interface provided the following + callback functions:

+ + 
+namespace odb
+{
+  class tracer
+  {
+  public:
+    virtual void
+    prepare (connection&, const statement&);
+
+    virtual void
+    execute (connection&, const statement&);
+
+    virtual void
+    execute (connection&, const char* statement) = 0;
+
+    virtual void
+    deallocate (connection&, const statement&);
+  };
+}
+
+ +

The prepare() and deallocate() functions + are called when a prepared statement is created and destroyed, + respectively. The first execute() function is called + when a prepared statement is executed while the second one is called + when a normal statement is executed. The default implementations + for the prepare() and deallocate() + functions do nothing while the first execute() function + calls the second one passing the statement text as the second + argument. As a result, if all you are interested in are the + SQL statements being executed, then you only need to override the + second execute() function.

+ +

In addition to the common odb::tracer interface, + each database runtime provides a database-specific version + as odb::<database>::tracer. It has exactly + the same interface as the common version except that the + connection and statement types + are database-specific, which gives us access to additional, + database-specific information.

+ +

As an example, consider a more elaborate, PostgreSQL-specific + tracer implementation. Here we rely on the fact that the PostgreSQL + ODB runtime uses names to identify prepared statements and this + information can be obtained from the odb::pgsql::statement + object:

+ + 
+#include <odb/pgsql/tracer.hxx>
+#include <odb/pgsql/database.hxx>
+#include <odb/pgsql/connection.hxx>
+#include <odb/pgsql/statement.hxx>
+
+class pgsql_tracer: public odb::pgsql::tracer
+{
+  virtual void
+  prepare (odb::pgsql::connection& c, const odb::pgsql::statement& s)
+  {
+    cerr << c.database ().db () << ": PREPARE " << s.name ()
+         << " AS " << s.text () << endl;
+  }
+
+  virtual void
+  execute (odb::pgsql::connection& c, const odb::pgsql::statement& s)
+  {
+    cerr << c.database ().db () << ": EXECUTE " << s.name () << endl;
+  }
+
+  virtual void
+  execute (odb::pgsql::connection& c, const char* statement)
+  {
+    cerr << c.database ().db () << ": " << statement << endl;
+  }
+
+  virtual void
+  deallocate (odb::pgsql::connection& c, const odb::pgsql::statement& s)
+  {
+    cerr << c.database ().db () << ": DEALLOCATE " << s.name () << endl;
+  }
+};
+
+ +

Note also that you can only set a database-specific tracer object + using a database-specific database instance, for example:

+ + 
+pgsql_tracer tracer;
+
+odb::database& db = ...;
+db.tracer (tracer); // Compile error.
+
+odb::pgsql::database& db = ...;
+db.tracer (tracer); // Ok.
+
+ +

3.14 ODB Exceptions

+ +

In the previous sections we have already mentioned some of the + exceptions that can be thrown by the database functions. In this + section we will discuss the ODB exception hierarchy and document + all the exceptions that can be thrown by the common ODB + runtime.

+ +

The root of the ODB exception hierarchy is the abstract + odb::exception class. This class derives + from std::exception and has the following + interface:

+ + 
+namespace odb
+{
+  struct exception: std::exception
+  {
+    virtual const char*
+    what () const throw () = 0;
+  };
+}
+
+ +

Catching this exception guarantees that we will catch all the + exceptions thrown by ODB. The what() function + returns a human-readable description of the condition that + triggered the exception.

+ +

The concrete exceptions that can be thrown by ODB are presented + in the following listing:

+ + 
+namespace odb
+{
+  struct null_pointer: exception
+  {
+    virtual const char*
+    what () const throw ();
+  };
+
+  // Transaction exceptions.
+  //
+  struct already_in_transaction: exception
+  {
+    virtual const char*
+    what () const throw ();
+  };
+
+  struct not_in_transaction: exception
+  {
+    virtual const char*
+    what () const throw ();
+  };
+
+  struct transaction_already_finalized: exception
+  {
+    virtual const char*
+    what () const throw ();
+  };
+
+  // Session exceptions.
+  //
+  struct already_in_session: exception
+  {
+    virtual const char*
+    what () const throw ();
+  };
+
+  struct not_in_session: exception
+  {
+    virtual const char*
+    what () const throw ();
+  };
+
+  struct session_required: exception
+  {
+    virtual const char*
+    what () const throw ();
+  };
+
+  // Database operations exceptions.
+  //
+  struct recoverable: exception
+  {
+  };
+
+  struct connection_lost: recoverable
+  {
+    virtual const char*
+    what () const throw ();
+  };
+
+  struct timeout: recoverable
+  {
+    virtual const char*
+    what () const throw ();
+  };
+
+  struct deadlock: recoverable
+  {
+    virtual const char*
+    what () const throw ();
+  };
+
+  struct object_not_persistent: exception
+  {
+    virtual const char*
+    what () const throw ();
+  };
+
+  struct object_already_persistent: exception
+  {
+    virtual const char*
+    what () const throw ();
+  };
+
+  struct object_changed: exception
+  {
+    virtual const char*
+    what () const throw ();
+  };
+
+  struct result_not_cached: exception
+  {
+    virtual const char*
+    what () const throw ();
+  };
+
+  struct database_exception: exception
+  {
+  };
+
+  // Polymorphism support exceptions.
+  //
+  struct abstract_class: exception
+  {
+    virtual const char*
+    what () const throw ();
+  };
+
+  struct no_type_info: exception
+  {
+    virtual const char*
+    what () const throw ();
+  };
+
+  // Prepared query support exceptions.
+  //
+  struct prepared_already_cached: exception
+  {
+    const char*
+    name () const;
+
+    virtual const char*
+    what () const throw ();
+  };
+
+  struct prepared_type_mismatch: exception
+  {
+    const char*
+    name () const;
+
+    virtual const char*
+    what () const throw ();
+  };
+
+  // Schema catalog exceptions.
+  //
+  struct unknown_schema: exception
+  {
+    const std::string&
+    name () const;
+
+    virtual const char*
+    what () const throw ();
+  };
+
+  struct unknown_schema_version: exception
+  {
+    schema_version
+    version () const;
+
+    virtual const char*
+    what () const throw ();
+  };
+
+  // Section exceptions.
+  //
+  struct section_not_loaded: exception
+  {
+    virtual const char*
+    what () const throw ();
+  };
+
+  struct section_not_in_object: exception
+  {
+    virtual const char*
+    what () const throw ();
+  };
+
+  // Bulk operation exceptions.
+  //
+  struct multiple_exceptions: exception
+  {
+    ...
+
+    virtual const char*
+    what () const throw ();
+  };
+}
+
+ +

The null_pointer exception is thrown when a + pointer to a persistent object declared non-NULL + with the db not_null or + db value_not_null pragma has the NULL + value. See Chapter 6, "Relationships" for details.

+ +

The next three exceptions (already_in_transaction, + not_in_transaction, + transaction_already_finalized) are thrown by the + odb::transaction class and are discussed + in Section 3.5, "Transactions".

+ +

The next two exceptions (already_in_session, and + not_in_session) are thrown by the odb::session + class and are discussed in Chapter 11, "Session".

+ +

The session_required exception is thrown when ODB detects + that correctly loading a bidirectional object relationship requires a + session but one is not used. See Section 6.2, + "Bidirectional Relationships" for more information on this + exception.

+ +

The recoverable exception serves as a common base + for all the recoverable exceptions, which are: connection_lost, + timeout, and deadlock. The + connection_lost exception is thrown when a connection + to the database is lost. Similarly, the timeout exception + is thrown if one of the database operations or the whole transaction + has timed out. The deadlock exception is thrown when a + transaction deadlock is detected by the database system. These + exceptions can be thrown by any database function. See + Section 3.7, "Error Handling and Recovery" + for details.

+ +

The object_already_persistent exception is thrown + by the persist() database function. See + Section 3.8, "Making Objects Persistent" + for details.

+ +

The object_not_persistent exception is thrown + by the load(), update(), and + erase() database functions. Refer to + Section 3.9, "Loading Persistent Objects", + Section 3.10, "Updating Persistent Objects", and + Section 3.11, "Deleting Persistent Objects" for + more information.

+ +

The object_changed exception is thrown + by the update() database function and certain + erase() database functions when + operating on objects with the optimistic concurrency model. See + Chapter 12, "Optimistic Concurrency" for details.

+ +

The result_not_cached exception is thrown by + the query result class. Refer to Section 4.4, + "Query Result" for details.

+ +

The database_exception exception is a base class for all + database system-specific exceptions that are thrown by the + database system-specific runtime library. Refer to Part + II, "Database Systems" for more information.

+ +

The abstract_class exception is thrown by the database + functions when we attempt to persist, update, load, or erase an + instance of a polymorphic abstract class. For more information + on abstract classes, refer to Section 14.1.3, + "abstract".

+ +

The no_type_info exception is thrown by the database + functions when we attempt to persist, update, load, or erase an + instance of a polymorphic class for which no type information + is present in the application. This normally means that the + generated database support code for this class has not been + linked (or dynamically loaded) into the application or the + discriminator value has not been mapped to a persistent + class. For more information on polymorphism support, refer to + Section 8.2, "Polymorphism Inheritance".

+ +

The prepared_already_cached exception is thrown by the + cache_query() function if a prepared query with the + specified name is already cached. The prepared_type_mismatch + exception is thrown by the lookup_query() function if + the specified prepared query object type or parameters type + does not match the one in the cache. Refer to Section + 4.5, "Prepared Queries" for details.

+ +

The unknown_schema exception is thrown by the + odb::schema_catalog class if a schema with the specified + name is not found. Refer to Section 3.4, "Database" + for details. The unknown_schema_version exception is + thrown by the schema_catalog functions that deal with + database schema evolution if the passed version is unknow. Refer + to Chapter 13, "Database Schema Evolution" for + details.

+ +

The section_not_loaded exception is thrown if we + attempt to update an object section that hasn't been loaded. + The section_not_in_object exception is thrown if + the section instance being loaded or updated does not belong + to the corresponding object. See Chapter 9, + "Sections" for more information on these exceptions.

+ +

The multiple_exceptions exception is thrown by the + bulk API functions. Refer to Section 15.3, "Bulk + Database Operations" for details.

+ +

The odb::exception class is defined in the + <odb/exception.hxx> header file. All the + concrete ODB exceptions are defined in + <odb/exceptions.hxx> which also includes + <odb/exception.hxx>. Normally you don't + need to include either of these two headers because they are + automatically included by <odb/database.hxx>. + However, if the source file that handles ODB exceptions + does not include <odb/database.hxx>, then + you will need to explicitly include one of these headers.

+ + + + + +
+

4 Querying the Database

+ +

If we don't know the identifiers of the objects that we are looking + for, we can use queries to search the database for objects matching + certain criteria. The ODB query facility is optional and we need to + explicitly request the generation of the necessary database support + code with the --generate-query ODB compiler option.

+ +

ODB provides a flexible query API that offers two distinct levels of + abstraction from the database system query language such as SQL. + At the high level we are presented with an easy to use yet powerful + object-oriented query language, called ODB Query Language. This + query language is modeled after and is integrated into C++ allowing + us to write expressive and safe queries that look and feel like + ordinary C++. We have already seen examples of these queries in the + introductory chapters. Below is another, more interesting, example:

+ + 
+  typedef odb::query<person> query;
+  typedef odb::result<person> result;
+
+  unsigned short age;
+  query q (query::first == "John" && query::age < query::_ref (age));
+
+  for (age = 10; age < 100; age += 10)
+  {
+    result r (db.query<person> (q));
+    ...
+  }
+
+ +

At the low level, queries can be written as predicates using + the database system-native query language such as the + WHERE predicate from the SQL SELECT + statement. This language will be referred to as native query + language. At this level ODB still takes care of converting + query parameters from C++ to the database system format. Below + is the re-implementation of the above example using SQL as + the native query language:

+ + 
+  query q ("first = 'John' AND age = " + query::_ref (age));
+
+ +

Note that at this level we lose the static typing of + query expressions. For example, if we wrote something like this:

+ + 
+  query q (query::first == 123 && query::agee < query::_ref (age));
+
+ +

We would get two errors during the C++ compilation. The first would + indicate that we cannot compare query::first to an + integer and the second would pick the misspelling in + query::agee. On the other hand, if we wrote something + like this:

+ + 
+  query q ("first = 123 AND agee = " + query::_ref (age));
+
+ +

It would compile fine and would trigger an error only when executed + by the database system.

+ +

We can also combine the two query languages in a single query, for + example:

+ + 
+  query q ("first = 'John' AND" + (query::age < query::_ref (age)));
+
+ +

4.1 ODB Query Language

+ +

An ODB query is an expression that tells the database system whether + any given object matches the desired criteria. As such, a query expression + always evaluates as true or false. At + the higher level, an expression consists of other expressions + combined with logical operators such as && (AND), + || (OR), and ! (NOT). For example:

+ + 
+  typedef odb::query<person> query;
+
+  query q (query::first == "John" || query::age == 31);
+
+ +

At the core of every query expression lie simple expressions which + involve one or more object members, values, or parameters. To + refer to an object member we use an expression such as + query::first above. The names of members in the + query class are derived from the names of data members + in the object class by removing the common member name decorations, + such as leading and trailing underscores, the m_ prefix, + etc.

+ +

In a simple expression an object member can be compared to a value, + parameter, or another member using a number of predefined operators + and functions. The following table gives an overview of the available + expressions:

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
OperatorDescriptionExample
==equalquery::age == 31
!=unequalquery::age != 31
<less thanquery::age < 31
>greater thanquery::age > 31
<=less than or equalquery::age <= 31
>=greater than or equalquery::age >= 31
in()one of the valuesquery::age.in (30, 32, 34)
in_range()one of the values in rangequery::age.in_range (begin, end)
like()matches a patternquery::first.like ("J%")
is_null()value is NULLquery::age.is_null ()
is_not_null()value is NOT NULLquery::age.is_not_null ()
+ +

The in() function accepts a maximum of five arguments. + Use the in_range() function if you need to compare + to more than five values. This function accepts a pair of + standard C++ iterators and compares to all the values from + the begin position inclusive and until and + excluding the end position. The following + code fragment shows how we can use these functions:

+ + 
+  std::vector<string> names;
+
+  names.push_back ("John");
+  names.push_back ("Jack");
+  names.push_back ("Jane");
+
+  query q1 (query::first.in ("John", "Jack", "Jane"));
+  query q2 (query::first.in_range (names.begin (), names.end ()));
+
+ +

Note that the like() function does not perform any + translation of the database system-specific extensions of the + SQL LIKE operator. As a result, if you would like + your application to be portable among various database systems, + then limit the special characters used in the pattern to + % (matches zero or more characters) and _ + (matches exactly one character). It is also possible to specify + the escape character as a second argument to the like() + function. This character can then be used to escape the special + characters (% and _) in the pattern. + For example, the following query will match any two characters + separated by an underscore:

+ + 
+  query q (query::name.like ("_!__", "!"));
+
+ +

The operator precedence in the query expressions are the same + as for equivalent C++ operators. We can use parentheses to + make sure the expression is evaluated in the desired order. + For example:

+ + 
+  query q ((query::first == "John" || query::first == "Jane") &&
+           query::age < 31);
+
+ + +

4.2 Parameter Binding

+ +

An instance of the odb::query class encapsulates two + parts of information about the query: the query expression and + the query parameters. Parameters can be bound to C++ variables + either by value or by reference.

+ +

If a parameter is bound by value, then the value for this parameter + is copied from the C++ variable to the query instance at the query + construction time. On the other hand, if a parameter is bound by + reference, then the query instance stores a reference to the + bound variable. The actual value of the parameter is only extracted + at the query execution time. Consider, for example, the following + two queries:

+ + 
+  string name ("John");
+
+  query q1 (query::first == query::_val (name));
+  query q2 (query::first == query::_ref (name));
+
+  name = "Jane";
+
+  db.query<person> (q1); // Find John.
+  db.query<person> (q2); // Find Jane.
+
+ +

The odb::query class provides two special functions, + _val() and _ref(), that allow us to + bind the parameter either by value or by reference, respectively. + In the ODB query language, if the binding is not specified + explicitly, the value semantic is used by default. In the + native query language, binding must always be specified + explicitly. For example:

+ + 
+  query q1 (query::age < age);                // By value.
+  query q2 (query::age < query::_val (age));  // By value.
+  query q3 (query::age < query::_ref (age));  // By reference.
+
+  query q4 ("age < " + age);                  // Error.
+  query q5 ("age < " + query::_val (age));    // By value.
+  query q6 ("age < " + query::_ref (age));    // By reference.
+
+ +

A query that only has by-value parameters does not depend on any + other variables and is self-sufficient once constructed. A query + that has one or more by-reference parameters depends on the + bound variables until the query is executed. If one such variable + goes out of scope and we execute the query, the behavior is + undefined.

+ +

4.3 Executing a Query

+ +

Once we have the query instance ready and by-reference parameters + initialized, we can execute the query using the + database::query() function template. It has two + overloaded versions:

+ + 
+  template <typename T>
+  result<T>
+  query (bool cache = true);
+
+  template <typename T>
+  result<T>
+  query (const odb::query<T>&, bool cache = true);
+
+ +

The first query() function is used to return all the + persistent objects of a given type stored in the database. + The second function uses the passed query instance to only return + objects matching the query criteria. The cache argument + determines whether the objects' states should be cached in the + application's memory or if they should be returned by the database + system one by one as the iteration over the result progresses. The + result caching is discussed in detail in the next section.

+ +

When calling the query() function, we have to + explicitly specify the object type we are querying. For example:

+ + 
+  typedef odb::query<person> query;
+  typedef odb::result<person> result;
+
+  result all (db.query<person> ());
+  result johns (db.query<person> (query::first == "John"));
+
+ +

Note that it is not required to explicitly create a named + query variable before executing it. For example, the following + two queries are equivalent:

+ + 
+  query q (query::first == "John");
+
+  result r1 (db.query<person> (q));
+  result r1 (db.query<person> (query::first == "John"));
+
+ +

Normally, we would create a named query instance if we are + planning to run the same query multiple times and would use the + in-line version for those that are executed only once (see also + Section 4.5, "Prepared Queries" for a more + optimal way to re-execute the same query multiple times). A named + query instance that does not have any by-reference parameters is + immutable and can be shared between multiple threads without + synchronization. On the other hand, a query instance with + by-reference parameters is modified every time it is executed. + If such a query is shared among multiple threads, then access + to this query instance must be synchronized from the execution + point and until the completion of the iteration over the result.

+ +

It is also possible to create queries from other queries by + combining them using logical operators. For example:

+ + 
+result
+find_minors (database& db, const query& name_query)
+{
+  return db.query<person> (name_query && query::age < 18);
+}
+
+result r (find_minors (db, query::first == "John"));
+
+ +

The result of executing a query is zero, one, or more objects + matching the query criteria. The query() function + returns this result as an instance of the odb::result + class template, which provides a stream-like interface and is + discussed in detail in the next section.

+ +

In situations where we know that a query produces at most one + element, we can instead use the database::query_one() and + database::query_value() shortcut functions, for example:

+ + 
+  typedef odb::query<person> query;
+
+  auto_ptr<person> p (
+    db.query_one<person> (
+      query::email == "jon@example.com"));
+
+ +

The shortcut query functions have the following signatures:

+ + 
+  template <typename T>
+  typename object_traits<T>::pointer_type
+  query_one ();
+
+  template <typename T>
+  bool
+  query_one (T&);
+
+  template <typename T>
+  T
+  query_value ();
+
+  template <typename T>
+  typename object_traits<T>::pointer_type
+  query_one (const odb::query<T>&);
+
+  template <typename T>
+  bool
+  query_one (const odb::query<T>&, T&);
+
+  template <typename T>
+  T
+  query_value (const odb::query<T>&);
+
+ +

Similar to query(), the first three functions are used + to return the only persistent object of a given type stored in the + database. The second three versions use the passed query instance + to only return the object matching the query criteria.

+ +

Similar to the database::find() functions + (Section 3.9, "Loading Persistent Objects"), + query_one() can either allocate a new instance of the + object class in the dynamic memory or it can load the object's state + into an existing instance. The query_value() function + allocates and returns the object by value.

+ +

The query_one() function allows us to determine + if the query result contains zero or one element. If no objects + matching the query criteria were found in the database, the + first version of query_one() returns the NULL + pointer while the second — false. If the second + version returns false, then the passed object + remains unchanged. For example:

+ + 
+  if (unique_ptr<person> p = db.query_one<person> (
+        query::email == "jon@example.com"))
+  {
+    ...
+  }
+
+  person p;
+  if (db.query_one<person> (query::email == "jon@example.com", p))
+  {
+    ...
+  }
+
+ +

If the query executed using query_one() or + query_value() returns more than one element, + then these functions fail with an assertion. Additionally, + query_value() also fails with an assertion if + the query returned no elements.

+ +

Common situations where we can use the shortcut functions are a + query condition that uses a data member with the + unique constraint (at most one element returned; + see Section 14.7, "Index Definition Pragmas") + as well as aggregate queries (exactly one element returned; see + Chapter 10, "Views").

+ +

4.4 Query Result

+ +

The database::query() function returns the result of + executing a query as an instance of the odb::result + class template, for example:

+ + 
+  typedef odb::query<person> query;
+  typedef odb::result<person> result;
+
+  result johns (db.query<person> (query::first == "John"));
+
+ +

It is best to view an instance of odb::result + as a handle to a stream, such as a file stream. While we can + make a copy of a result or assign one result to another, the + two instances will refer to the same result stream. Advancing + the current position in one instance will also advance it in + another. The result instance is only usable within the transaction + it was created in. Trying to manipulate the result after the + transaction has terminated leads to undefined behavior.

+ +

The odb::result class template conforms to the + standard C++ sequence requirements and has the following + interface:

+ + 
+namespace odb
+{
+  template <typename T>
+  class result
+  {
+  public:
+    typedef odb::result_iterator<T> iterator;
+
+  public:
+    result ();
+
+    result (const result&);
+
+    result&
+    operator= (const result&);
+
+    void
+    swap (result&)
+
+  public:
+    iterator
+    begin ();
+
+    iterator
+    end ();
+
+  public:
+    void
+    cache ();
+
+    bool
+    empty () const;
+
+    std::size_t
+    size () const;
+  };
+}
+
+ +

The default constructor creates an empty result set. The + cache() function caches the returned objects' + state in the application's memory. We have already mentioned + result caching when we talked about query execution. As you + may remember the database::query() function + caches the result unless instructed not to by the caller. + The cache() function allows us to + cache the result at a later stage if it wasn't already + cached during query execution.

+ +

If the result is cached, the database state of all the returned + objects is stored in the application's memory. Note that + the actual objects are still only instantiated on demand + during result iteration. It is the raw database state that + is cached in memory. In contrast, for uncached results + the object's state is sent by the database system one object + at a time as the iteration progresses.

+ +

Uncached results can improve the performance of both the application + and the database system in situations where we have a large + number of objects in the result or if we will only examine + a small portion of the returned objects. However, uncached + results have a number of limitations. There can only be one + uncached result in a transaction. Creating another result + (cached or uncached) by calling database::query() + will invalidate the existing uncached result. Furthermore, + calling any other database functions, such as update() + or erase() will also invalidate the uncached result. + It also follows that uncached results cannot be used on objects + with containers (Chapter 5, "Containers") since + loading a container would invalidate the uncached result.

+ +

The empty() function returns true if + there are no objects in the result and false otherwise. + The size() function can only be called for cached results. + It returns the number of objects in the result. If we call this + function on an uncached result, the odb::result_not_cached + exception is thrown.

+ +

To iterate over the objects in a result we use the + begin() and end() functions + together with the odb::result<T>::iterator + type, for example:

+ + 
+  result r (db.query<person> (query::first == "John"));
+
+  for (result::iterator i (r.begin ()); i != r.end (); ++i)
+  {
+    ...
+  }
+
+ +

In C++11 we can use the auto-typed variabe instead + of spelling the iterator type explicitly, for example:

+ + 
+  for (auto i (r.begin ()); i != r.end (); ++i)
+  {
+    ...
+  }
+
+ +

The C++11 range-based for-loop can be used to further + simplify the iteration:

+ + 
+  for (person& p: r)
+  {
+    ...
+  }
+
+ +

The result iterator is an input iterator which means that the + only two position operations that it supports are to move to the + next object and to determine whether the end of the result stream + has been reached. In fact, the result iterator can only be in two + states: the current position and the end position. If we have + two iterators pointing to the current position and then we + advance one of them, the other will advance as well. This, + for example, means that it doesn't make sense to store an + iterator that points to some object of interest in the result + stream with the intent of dereferencing it after the iteration + is over. Instead, we would need to store the object itself.

+ +

The result iterator has the following dereference functions + that can be used to access the pointed-to object:

+ + 
+namespace odb
+{
+  template <typename T>
+  class result_iterator
+  {
+  public:
+    T*
+    operator-> () const;
+
+    T&
+    operator* () const;
+
+    typename object_traits<T>::pointer_type
+    load ();
+
+    void
+    load (T& x);
+
+    typename object_traits<T>::id_type
+    id ();
+  };
+}
+
+ +

When we call the * or -> operator, + the iterator will allocate a new instance of the object class + in the dynamic memory, load its state from the database + state, and return a reference or pointer to the new instance. The + iterator maintains the ownership of the returned object and will + return the same pointer for subsequent calls to either of these + operators until it is advanced to the next object or we call + the first load() function (see below). For example:

+ + 
+  result r (db.query<person> (query::first == "John"));
+
+  for (result::iterator i (r.begin ()); i != r.end ();)
+  {
+    cout << i->last () << endl; // Create an object.
+    person& p (*i);             // Reference to the same object.
+    cout << p.age () << endl;
+    ++i;                        // Free the object.
+  }
+
+ +

The overloaded result_iterator::load() functions are + similar to database::load(). The first function + returns a dynamically allocated instance of the current + object. As an optimization, if the iterator already owns an object + as a result of an earlier + call to the * or -> operator, then it + relinquishes the ownership of this object and returns it instead. + This allows us to write code like this without worrying about + a double allocation:

+ + 
+  result r (db.query<person> (query::first == "John"));
+
+  for (result::iterator i (r.begin ()); i != r.end (); ++i)
+  {
+    if (i->last == "Doe")
+    {
+      auto_ptr p (i.load ());
+      ...
+    }
+  }
+
+ +

Note, however, that because of this optimization, a subsequent + to load() call to the * or -> + operator results in the allocation of a new object.

+ +

The second load() function allows + us to load the current object's state into an existing instance. + For example:

+ + 
+  result r (db.query<person> (query::first == "John"));
+
+  person p;
+  for (result::iterator i (r.begin ()); i != r.end (); ++i)
+  {
+    i.load (p);
+    cout << p.last () << endl;
+    cout << i.age () << endl;
+  }
+
+ +

The id() function return the object id of the current + object. While we can achieve the same by loading the object and getting + its id, this function is more efficient since it doesn't actually + create the object. This can be useful when all we need is the object's + identifier. For example:

+ + 
+  std::set<unsigned long> set = ...; // Persons of interest.
+
+  result r (db.query<person> (query::first == "John"));
+
+  for (result::iterator i (r.begin ()); i != r.end (); ++i)
+  {
+    if (set.find (i.id ()) != set.end ()) // No object loaded.
+    {
+      cout << i->first () << endl; // Object loaded.
+    }
+  }
+
+ +

4.5 Prepared Queries

+ +

Most modern relational database systems have the notion of a prepared + statement. Prepared statements allow us to perform the potentially + expensive tasks of parsing SQL, preparing the query execution + plan, etc., once and then executing the same query multiple + times, potentially using different values for parameters in + each execution.

+ +

In ODB all the non-query database operations such as + persist(), load(), update(), + etc., are implemented in terms of prepared statements that are cached + and reused. While the query(), query_one(), + and query_one() database operations also use prepared + statements, these statements are not cached or reused by default since + ODB has no knowledge of whether a query will be executed multiple times + or only once. Instead, ODB provides a mechanism, called prepared queries, + that allows us to prepare a query once and execute it multiple + times. In other words, ODB prepared queries are a thin wrapper + around the underlying database's prepared statement functionality.

+ +

In most cases ODB shields the application developer from database + connection management and multi-threading issues. However, when it + comes to prepared queries, a basic understanding of how ODB manages + these aspects is required. Conceptually, the odb::database + class represents a specific database, that is, a data store. However, + underneath, it maintains one or more connections to this database. + A connection can be used only by a single thread at a time. When + we start a transaction (by calling database::begin()), + the transaction instance obtains a connection and holds on to it + until the transaction is committed or rolled back. During this time + no other thread can use this connection. When the transaction + releases the connection, it may be closed or reused by another + transaction in this or another thread. What exactly happens to + a connection after it has been released depends on the connection + factory that is used by the odb::database instance. + For more information on connection factories, refer to + Part II, "Database Systems".

+ +

A query prepared on one connection cannot be executed on another. + In other words, a prepared query is associated with the connection. + One important implication of this restriction is that we cannot + prepare a query in one transaction and then try to execute it + in another without making sure that both transactions use the + same connection.

+ +

To enable the prepared query functionality we need to specify + the --generate-prepared ODB compiler option. If + we are planning to always prepare our queries, then we can + disable the once-off query execution support by also specifying + the --omit-unprepared option.

+ +

To prepare a query we use the prepare_query() function + template. This function can be called on both the odb::database + and odb::connection instances. The odb::database + version simply obtains the connection used by the currently active + transaction and calls the corresponding odb::connection + version. If no transaction is currently active, then this function + throws the odb::not_in_transaction exception + (Section 3.5, "Transactions"). The + prepare_query() function has the following signature:

+ + 
+  template <typename T>
+  prepared_query<T>
+  prepare_query (const char* name, const odb::query<T>&);
+
+ +

The first argument to the prepare_query() function is + the prepared query name. This name is used as a key for prepared + query caching (discussed later) and must be unique. For some databases, + notably PostgreSQL, it is also used as a name of the underlying prepared + statement. The name "object_query" (for example, + "person_query") is reserved for the once-off queries + executed by the database::query() function. Note that + the prepare_query() function makes only a shallow copy + of this argument, which means that the name must be valid for the + lifetime of the returned prepared_query instance.

+ +

The second argument to the prepare_query() function + is the query criteria. It has the same semantics as in the + query() function discussed in Section + 4.3, "Executing a Query". Similar to query(), we + also have to explicitly specify the object type that we will be + querying. For example:

+ + 
+typedef odb::query<person> query;
+typedef odb::prepared_query<person> prep_query;
+
+prep_query pq (
+  db.prepare_query<person> ("person-age-query", query::age > 50));
+
+ +

The result of executing the prepare_query() function is + the prepared_query instance that represent the prepared + query. It is best to view prepared_query as a handle to + the underlying prepared statement. While we can make a copy of it or + assign one prepared_query to another, the two instances + will refer to the same prepared statement. Once the last instance of + prepared_query referencing a specific prepared statement + is destroyed, this statement is released. The prepared_query + class template has the following interface:

+ + 
+namespace odb
+{
+  template <typename T>
+  struct prepared_query
+  {
+    prepared_query ();
+
+    prepared_query (const prepared_query&)
+    prepared_query& operator= (const prepared_query&)
+
+    result<T>
+    execute (bool cache = true);
+
+    typename object_traits<T>::pointer_type
+    execute_one ();
+
+    bool
+    execute_one (T& object);
+
+    T
+    execute_value ();
+
+    const char*
+    name () const;
+
+    statement&
+    statement () const;
+
+    operator unspecified_bool_type () const;
+  };
+}
+
+ +

The default constructor creates an empty prepared_query + instance, that is, an instance that does not reference a prepared + statement and therefore cannot be executed. The only way to create + a non-empty prepared query is by calling the prepare_query() + function discussed above. To test whether the prepared query is empty, + we can use the implicit conversion operator to a boolean type. For + example:

+ + 
+  prepared_query<person> pq;
+
+  if (pq)
+  {
+    // Not empty.
+    ...
+  }
+
+ +

The execute() function executes the query and returns + the result instance. The cache argument indicates + whether the result should be cached and has the same semantics + as in the query() function. In fact, conceptually, + prepare_query() and execute() are just + the query() function split into two: + prepare_query() takes the first + query() argument (the query condition) while + execute() takes the second (the cache flag). Note + also that re-executing a prepared query invalidates the + previous execution result, whether cached or uncached.

+ +

The execute_one() and execute_value() + functions can be used as shortcuts to execute a query that is + known to return at most one or exactly one object, respectively. + The arguments and return values in these functions have the same + semantics as in query_one() and query_value(). + And similar to execute() above, prepare_query() + and execute_one/value() can be seen as the + query_one/value() function split into two: + prepare_query() takes the first + query_one/value() argument (the query condition) while + execute_one/value() takes the second argument (if any) + and returns the result. Note also that execute_one/value() + never caches its result but invalidates the result of any previous + execute() call on the same prepared query.

+ +

The name() function returns the prepared query name. + This is the same name as was passed as the first argument in the + prepare_query() call. The statement() + function returns a reference to the underlying prepared statement. + Note also that calling any of these functions on an empty + prepared_query instance results in undefined behavior.

+ +

The simplest use-case for a prepared query is the need to + execute the same query multiple times within a single transaction. + Consider the following example that queries for people that are older + than a number of different ages. This and subsequent code fragments + are taken from the prepared example in the + odb-examples package.

+ + 
+typedef odb::query<person> query;
+typedef odb::prepared_query<person> prep_query;
+typedef odb::result<person> result;
+
+transaction t (db.begin ());
+
+unsigned short age;
+query q (query::age > query::_ref (age));
+prep_query pq (db.prepare_query<person> ("person-age-query", q));
+
+for (age = 90; age > 40; age -= 10)
+{
+  result r (pq.execute ());
+  ...
+}
+
+t.commit ();
+
+ +

Another scenario is the need to reuse the same query in multiple + transactions that are executed at once. As was mentioned above, + in this case we need to make sure that the prepared query and + all the transactions use the same connection. Consider an + alternative version of the above example that executes each + query in a separate transaction:

+ + 
+connection_ptr conn (db.connection ());
+
+unsigned short age;
+query q (query::age > query::_ref (age));
+prep_query pq (conn->prepare_query<person> ("person-age-query", q));
+
+for (age = 90; age > 40; age -= 10)
+{
+  transaction t (conn->begin ());
+
+  result r (pq.execute ());
+  ...
+
+  t.commit ();
+}
+
+ + +

Note that with this approach we hold on to the database connection + until all the transactions involving the prepared query are + executed. In particular, this means that while we are busy, the + connection cannot be reused by another thread. Therefore, this + approach is only recommended if all the transactions are executed + close to each other. Also note that an uncached (see below) + prepared query is invalidated once we release the connection + on which it was prepared.

+ +

If we need to reuse a prepared query in transactions that are + executed at various times, potentially in different threads, then + the recommended approach is to cache the prepared query on the + connection. To support this functionality the odb::database + and odb::connection classes provide the following + function templates. Similar to prepare_query(), + the odb::database versions of the below + functions call the corresponding odb::connection + versions using the currently active transaction to resolve + the connection.

+ + 
+  template <typename T>
+  void
+  cache_query (const prepared_query<T>&);
+
+  template <typename T, typename P>
+  void
+  cache_query (const prepared_query<T>&,
+               std::[auto|unique]_ptr<P> params);
+
+  template <typename T>
+  prepared_query<T>
+  lookup_query (const char* name) const;
+
+  template <typename T, typename P>
+  prepared_query<T>
+  lookup_query (const char* name, P*& params) const;
+
+ +

The cache_query() function caches the passed prepared + query on the connection. The second overloaded version of + cache_query() also takes a pointer to the + by-reference query parameters. In C++98/03 it should be + std::auto_ptr while in C++11 std::auto_ptr + or std::unique_ptr can be used. The + cache_query() function assumes ownership of the + passed params argument. If a prepared query + with the same name is already cached on this connection, + then the odb::prepared_already_cached exception + is thrown.

+ +

The lookup_query() function looks up a previously + cached prepared query given its name. The second overloaded + version of lookup_query() also returns a pointer + to the by-reference query parameters. If a prepared query + with this name has not been cached, then an empty + prepared_query instance is returned. If a + prepared query with this name has been cached but either + the object type or the parameters type does not match + that which was cached, then the odb::prepared_type_mismatch + exception is thrown.

+ +

As a first example of the prepared query cache functionality, + consider the case that does not use any by-reference parameters:

+ + 
+for (unsigned short i (0); i < 5; ++i)
+{
+  transaction t (db.begin ());
+
+  prep_query pq (db.lookup_query<person> ("person-age-query"));
+
+  if (!pq)
+  {
+    pq = db.prepare_query<person> (
+      "person-val-age-query", query::age > 50);
+    db.cache_query (pq);
+  }
+
+  result r (pq.execute ());
+  ...
+
+  t.commit ();
+
+  // Do some other work.
+  //
+  ...
+}
+
+ +

The following example shows how to do the same but for a query that + includes by-reference parameters. In this case the parameters are + cached together with the prepared query.

+ + 
+for (unsigned short age (90); age > 40; age -= 10)
+{
+  transaction t (db.begin ());
+
+  unsigned short* age_param;
+  prep_query pq (
+    db.lookup_query<person> ("person-age-query", age_param));
+
+  if (!pq)
+  {
+    auto_ptr<unsigned short> p (new unsigned short);
+    age_param = p.get ();
+    query q (query::age > query::_ref (*age_param));
+    pq = db.prepare_query<person> ("person-age-query", q);
+    db.cache_query (pq, p); // Assumes ownership of p.
+  }
+
+  *age_param = age; // Initialize the parameter.
+  result r (pq.execute ());
+  ...
+
+  t.commit ();
+
+  // Do some other work.
+  //
+  ...
+}
+
+ +

As is evident from the above examples, when we use a prepared + query cache, each transaction that executes a query must also + include code that prepares and caches this query if it hasn't already + been done. If a prepared query is used in a single place in the + application, then this is normally not an issue since all the + relevant code is kept in one place. However, if the same query + is used in several different places in the application, then + we may end up duplicating the same preparation and caching + code, which makes it hard to maintain.

+ +

To resolve this issue ODB allows us to register a prepared + query factory that will be called to prepare and cache a + query during the call to lookup_query(). To + register a factory we use the database::query_factory() + function. In C++98/03 it has the following signature:

+ + 
+  void
+  query_factory (const char* name,
+                 void (*factory) (const char* name, connection&));
+
+ +

While in C++11 it uses the std::function class + template:

+ + 
+  void
+  query_factory (const char* name,
+                 std::function<void (const char* name, connection&)>);
+
+ +

The first argument to the query_factory() function is + the prepared query name that this factory will be called to prepare + and cache. An empty name is treated as a fallback wildcard factory + that is capable of preparing any query. The second argument is the + factory function or, in C++11, function object or lambda.

+ +

The example fragment shows how we can use the prepared query + factory:

+ + 
+struct params
+{
+  unsigned short age;
+  string first;
+};
+
+static void
+query_factory (const char* name, connection& c)
+{
+  auto_ptr<params> p (new params);
+  query q (query::age > query::_ref (p->age) &&
+           query::first == query::_ref (p->first));
+  prep_query pq (c.prepare_query<person> (name, q));
+  c.cache_query (pq, p);
+}
+
+db.query_factory ("person-age-name-query", &query_factory);
+
+for (unsigned short age (90); age > 40; age -= 10)
+{
+  transaction t (db.begin ());
+
+  params* p;
+  prep_query pq (db.lookup_query<person> ("person-age-name-query", p));
+  assert (pq);
+
+  p->age = age;
+  p->first = "John";
+  result r (pq.execute ());
+  ...
+
+  t.commit ();
+}
+
+ +

In C++11 we could have instead used a lambda function as well as + unique_ptr rather than auto_ptr:

+ + 
+db.query_factory (
+  "person-age-name-query",
+  [] (const char* name, connection& c)
+  {
+    unique_ptr<params> p (new params);
+    query q (query::age > query::_ref (p->age) &&
+             query::first == query::_ref (p->first));
+    prep_query pq (c.prepare_query<person> (name, q));
+    c.cache_query (pq, std::move (p));
+  });
+
+ + + +
+

5 Containers

+ +

The ODB runtime library provides built-in persistence support for all the + commonly used standard C++98/03 containers, namely, + std::vector, std::list, std::deque, + std::set, std::multiset, std::map, and + std::multimap as well as C++11 std::array, + std::forward_list, std::unordered_set, + std::unordered_multiset, std::unordered_map, + and std::unordered_multimap. + Plus, ODB profile libraries, that are + available for commonly used frameworks and libraries (such as Boost and + Qt), provide persistence support for containers found in these frameworks + and libraries (Part III, "Profiles"). Both the + ODB runtime library and profile libraries also provide a number of + change-tracking container equivalents which can be used to minimize + the number of database operations necessary to synchronize the container + state with the database (Section 5.4, "Change-Tracking + Containers"). It is also easy to persist custom container types + as discussed later in Section 5.5, "Using Custom + Containers".

+ +

We don't need to do anything special to declare a member of a + container type in a persistent class. For example:

+ + 
+#pragma db object
+class person
+{
+  ...
+private:
+  std::vector<std::string> nicknames_;
+  ...
+};
+
+ +

The complete version of the above code fragment and the other code + samples presented in this chapter can be found in the container + example in the odb-examples package.

+ +

A data member in a persistent class that is of a container type + behaves like a value type. That is, when an object is made persistent, + the elements of the container are stored in the database. Similarly, + when a persistent object is loaded from the database, the contents + of the container are automatically loaded as well. A data member + of a container type can also use a smart pointer, as discussed + in Section 7.3, "Pointers and NULL + Value Semantics".

+ +

While an ordinary member is mapped to one or more columns in the + object's table, a member of a container type is mapped to a separate + table. The exact schema of such a table depends on the kind of + container. ODB defines the following container kinds: ordered, + set, multiset, map, and multimap. The container kinds and the + contents of the tables to which they are mapped are discussed + in detail in the following sections.

+ +

Containers in ODB can contain simple value types (Section + 7.1, "Simple Value Types"), composite value types + (Section 7.2, "Composite Value Types"), and pointers + to objects (Chapter 6, "Relationships"). Containers of + containers, either directly or indirectly via a composite value + type, are not allowed. A key in a map or multimap container can + be a simple or composite value type but not a pointer to an object. + An index in the ordered container should be a simple integer value + type.

+ +

The value type in the ordered, set, and map containers as well as + the key type in the map containers should be default-constructible. + The default constructor in these types can be made private in which + case the odb::access class should be made a friend of + the value or key type. For example:

+ + 
+#pragma db value
+class name
+{
+public:
+  name (const std::string&, const std::string&);
+  ...
+private:
+  friend class odb::access;
+  name ();
+  ...
+};
+
+#pragma db object
+class person
+{
+  ...
+private:
+  std::vector<name> aliases_;
+  ...
+};
+
+ + +

5.1 Ordered Containers

+ +

In ODB an ordered container is any container that maintains (explicitly + or implicitly) an order of its elements in the form of an integer index. + Standard C++ containers that are ordered include std::vector + std::list, and std::deque as well as C++11 std::array and + std::forward_list. While elements in std::set + are also kept in a specific order, this order is not based on an + integer index but rather on the relationship between elements. As + a result, std::set is not considered an ordered + container for the purpose of persistence.

+ +

The database table for an ordered container consists of at least + three columns. The first column contains the object id of a + persistent class instance of which the container is a member. + The second column contains the element index within a container. + And the last column contains the element value. If the object + id or element value are composite, then, instead of a single + column, they can occupy multiple columns. For an ordered + container table the ODB compiler also defines two indexes: + one for the object id column(s) and the other for the index + column. Refer to Section 14.7, "Index Definition + Pragmas" for more information on how to customize these + indexes.

+ +

Consider the following persistent object as an example:

+ + 
+#pragma db object
+class person
+{
+  ...
+private:
+  #pragma db id auto
+  unsigned long id_;
+
+  std::vector<std::string> nicknames_;
+  ...
+};
+
+ +

The resulting database table (called person_nicknames) will + contain the object id column of type unsigned long + (called object_id), the index column of an integer type + (called index), and the value column of type + std::string (called value).

+ +

A number of ODB pragmas allow us to customize the table name, column + names, and native database types of an ordered container both, on + the per-container and per-member basis. For more information on + these pragmas, refer to Chapter 14, "ODB Pragma + Language". The following example shows some of the possible + customizations:

+ + 
+#pragma db object
+class person
+{
+  ...
+private:
+  #pragma db table("nicknames")              \
+             id_column("person_id")          \
+             index_type("SMALLINT UNSIGNED") \
+             index_column("nickname_number") \
+             value_type("VARCHAR(255)")      \
+             value_column("nickname")
+  std::vector<std::string> nicknames_;
+  ...
+};
+
+ +

While the C++ container used in a persistent class may be ordered, + sometimes we may wish to store such a container in the database without + the order information. In the example above, for instance, the order + of person's nicknames is probably not important. To instruct the ODB + compiler to ignore the order in ordered containers we can use the + db unordered pragma (Section 14.3.9, + "unordered", Section 14.4.19, + "unordered"). For example:

+ + 
+#pragma db object
+class person
+{
+  ...
+private:
+  #pragma db unordered
+  std::vector<std::string> nicknames_;
+  ...
+};
+
+ +

The table for an ordered container that is marked unordered won't + have the index column and the order in which elements are retrieved + from the database may not be the same as the order in which they + were stored.

+ +

5.2 Set and Multiset Containers

+ +

In ODB set and multiset containers (referred to as just set + containers) are associative containers that contain elements + based on some relationship between them. A set container may + or may not guarantee a particular order of the elements that + it stores. Standard C++ containers that are considered set + containers for the purpose of persistence include + std::set and std::multiset as well + as C++11 std::unordered_set and + std::unordered_multiset.

+ +

The database table for a set container consists of at least + two columns. The first column contains the object id of a + persistent class instance of which the container is a member. + And the second column contains the element value. If the object + id or element value are composite, then, instead of a single + column, they can occupy multiple columns. ODB compiler also + defines an index on a set container table for the object id + column(s). Refer to Section 14.7, "Index Definition + Pragmas" for more information on how to customize this + index.

+ +

Consider the following persistent object as an example:

+ + 
+#pragma db object
+class person
+{
+  ...
+private:
+  #pragma db id auto
+  unsigned long id_;
+
+  std::set<std::string> emails_;
+  ...
+};
+
+ +

The resulting database table (called person_emails) will + contain the object id column of type unsigned long + (called object_id) and the value column of type + std::string (called value).

+ +

A number of ODB pragmas allow us to customize the table name, + column names, and native database types of a set container, both on + the per-container and per-member basis. For more information on + these pragmas, refer to Chapter 14, "ODB Pragma + Language". The following example shows some of the possible + customizations:

+ + 
+#pragma db object
+class person
+{
+  ...
+private:
+  #pragma db table("emails")            \
+             id_column("person_id")     \
+             value_type("VARCHAR(255)") \
+             value_column("email")
+  std::set<std::string> emails_;
+  ...
+};
+
+ +

5.3 Map and Multimap Containers

+ +

In ODB map and multimap containers (referred to as just map + containers) are associative containers that contain key-value + elements based on some relationship between keys. A map container + may or may not guarantee a particular order of the elements that + it stores. Standard C++ containers that are considered map + containers for the purpose of persistence include + std::map and std::multimap as well + as C++11 std::unordered_map and + std::unordered_multimap.

+ +

The database table for a map container consists of at least + three columns. The first column contains the object id of a + persistent class instance of which the container is a member. + The second column contains the element key. And the last column + contains the element value. If the object id, element key, or + element value are composite, then instead of a single column + they can occupy multiple columns. ODB compiler also + defines an index on a map container table for the object id + column(s). Refer to Section 14.7, "Index Definition + Pragmas" for more information on how to customize this + index.

+ +

Consider the following persistent object as an example:

+ + 
+#pragma db object
+class person
+{
+  ...
+private:
+  #pragma db id auto
+  unsigned long id_;
+
+  std::map<unsigned short, float> age_weight_map_;
+  ...
+};
+
+ +

The resulting database table (called person_age_weight_map) + will contain the object id column of type unsigned long + (called object_id), the key column of type + unsigned short (called key), and the value + column of type float (called value).

+ +

A number of ODB pragmas allow us to customize the table name, + column names, and native database types of a map container, both on + the per-container and per-member basis. For more information on + these pragmas, refer to Chapter 14, "ODB Pragma + Language". The following example shows some of the possible + customizations:

+ + 
+#pragma db object
+class person
+{
+  ...
+private:
+  #pragma db table("weight_map")      \
+             id_column("person_id")   \
+             key_type("INT UNSIGNED") \
+             key_column("age")        \
+             value_type("DOUBLE")     \
+             value_column("weight")
+  std::map<unsigned short, float> age_weight_map_;
+  ...
+};
+
+ +

5.4 Change-Tracking Containers

+ +

When a persistent object containing one of the standard containers + is updated in the database, ODB has no knowledge of which elements + were inserted, erased, or modified. As a result, ODB has no choice + but to assume the whole container has changed and update the state + of every single element. This can result in a significant overhead + if a container contains a large number of elements and we only + changed a small subset of them.

+ +

To eliminate this overhead, ODB provides a notion of change-tracking + containers. A change-tracking container, besides containing + its elements, just like an ordinary container, also includes the + change state for each element. When it is time to update such a + container in the database, ODB can use this change information to + perform a minimum number of database operations necessary to + synchronize the container state with the database.

+ +

The current version of the ODB runtime library provides a change-tracking + equivalent of std::vector (Section 5.4.1, + "Change-Tracking vector") with support for other + standard container equivalents planned for future releases. ODB + profile libraries also provide change-tracking equivalents for some + containers found in the corresponding frameworks and libraries + (Part III, "Profiles").

+ +

A change-tracking container equivalent can normally be used as a drop-in + replacement for an ordinary container except for a few minor + interface differences (discussed in the corresponding sub-sections). + In particular, we don't need to do anything extra to effect + change tracking. ODB will automatically start, stop, and reset + change tracking when necessary. The following example illustrates + this point using odb::vector as a replacement for + std::vector.

+ + 
+#pragma db object
+class person
+{
+  ...
+
+  odb::vector<std::string> names;
+};
+
+person p; // No change tracking (not persistent).
+p.names.push_back ("John Doe");
+
+{
+  transaction t (db.begin ());
+  db.persist (p); // Start change tracking (persistent).
+  t.commit ();
+}
+
+p.names.push_back ("Johnny Doo");
+
+{
+  transaction t (db.begin ());
+  db.update (p); // One INSERT; reset change state.
+  t.commit ();
+}
+
+p.names.modify (0) = "Doe, John"; // Instead of operator[].
+p.names.pop_back ();
+
+{
+  transaction t (db.begin ());
+  db.update (p); // One UPDATE, one DELETE; reset change state.
+  t.commit ();
+}
+
+{
+  transaction t (db.begin ());
+  auto_ptr<person> p1 (db.load<person> (...)); // Start change tracking.
+  p1->names.insert (p1->names.begin (), "Joe Do");
+  db.update (*p1); // One UPDATE, one INSERT; reset change state.
+  t.commit ();
+}
+
+{
+  transaction t (db.begin ());
+  db.erase (p); // One DELETE; stop change tracking (not persistent).
+  t.commit ();
+}
+
+ +

One interesting aspect of change tracking is what happens when a + transaction that contains an update is later rolled back. In this + case, while the change-tracking container has reset the change + state (after update), actual changes were not committed to the + database. Change-tracking containers handle this case by + automatically registering a rollback callback and then, if it is + called, marking the container as "completely changed". In this + state, the container no longer tracks individual element changes + and, when updated, falls back to the complete state update, just + like an ordinary container. The following example illustrates + this point:

+ + 
+person p;
+p.names.push_back ("John Doe");
+
+{
+  transaction t (db.begin ());
+  db.persist (p); // Start change tracking (persistent).
+  t.commit ();
+}
+
+p.names.push_back ("Johnny Doo");
+
+for (;;)
+{
+  try
+  {
+    transaction t (db.begin ());
+
+    // First try: one INSERT.
+    // Next try: one DELETE, two INSERTs.
+    //
+    db.update (p); // Reset change state.
+
+    t.commit (); // If throws (rollback), mark as completely changed.
+    break;
+  }
+  catch (const odb::recoverable&)
+  {
+    continue;
+  }
+}
+
+ +

For the interaction of change-tracking containers with change-updated + object sections, refer to Section 9.4, "Sections and + Change-Tracking Containers".

+ +

5.4.1 Change-Tracking vector

+ +

Class template odb::vector, defined in + <odb/vector.hxx>, is a change-tracking + equivalent for std::vector. It + is implemented in terms of std::vector and is + implicit-convertible to and implicit-constructible from + const std::vector&. In particular, this + means that we can use odb::vector instance + anywhere const std::vector& is + expected. In addition, odb::vector constant + iterator (const_iterator) is the same type as + that of std::vector.

+ +

odb::vector incurs 2-bit per element overhead + in order to store the change state. It cannot + be stored unordered in the database (Section + 14.4.19 "unordered") but can be used as an inverse + side of a relationship (6.2 "Bidirectional + Relationships"). In this case, no change tracking is performed + since no state for such a container is stored in the database.

+ +

The number of database operations required to update the state + of odb::vector corresponds well to the complexity + of std::vector functions. In particular, adding or + removing an element from the back of the vector (for example, + with push_back() and pop_back()), + requires only a single database statement execution. In contrast, + inserting or erasing an element somewhere in the middle of the + vector will require a database statement for every element that + follows it.

+ +

odb::vector replicates most of the std::vector + interface as defined in both C++98/03 and C++11 standards. However, + functions and operators that provide direct write access to + the elements had to be altered or disabled in order to support + change tracking. Additional functions used to interface with + std::vector and to control the change tracking state + were also added. The following listing summarizes the differences + between the odb::vector and std::vector + interfaces. Any std::vector function or operator + not mentioned in this listing has exactly the same signature + and semantics in odb::vector. Functions and + operators that were disabled are shown as commented out and + are followed by functions/operators that replace them.

+ + 
+namespace odb
+{
+  template <class T, class A = std::allocator<T> >
+  class vector
+  {
+    ...
+
+    // Element access.
+    //
+
+    //reference operator[] (size_type);
+      reference modify (size_type);
+
+    //reference at (size_type);
+      reference modify_at (size_type);
+
+    //reference front ();
+      reference modify_front ();
+
+    //reference back ();
+      reference modify_back ();
+
+    //T*        data () noexcept;
+      T*        modify_data () noexcept; // C++11 only.
+
+    // Iterators.
+    //
+    typedef typename std::vector<T, A>::const_iterator const_iterator;
+
+    class iterator
+    {
+      ...
+
+      // Element Access.
+      //
+
+      //reference       operator* () const;
+        const_reference operator* () const;
+        reference       modify () const;
+
+      //pointer       operator-> () const;
+        const_pointer operator-> () const;
+
+      //reference       operator[] (difference_type);
+        const_reference operator[] (difference_type);
+        reference       modify (difference_type) const;
+
+      // Interfacing with std::vector::iterator.
+      //
+      typename std::vector<T, A>::iterator base () const;
+    };
+
+    // Return std::vector iterators. The begin() functions mark
+    // all the elements as modified.
+    //
+    typename std::vector<T, A>::iterator         mbegin ();
+    typename std::vector<T, A>::iterator         mend ();
+    typename std::vector<T, A>::reverse_iterator mrbegin ();
+    typename std::vector<T, A>::reverse_iterator mrend ();
+
+    // Interfacing with std::vector.
+    //
+    vector (const std::vector<T, A>&);
+    vector (std::vector<T, A>&&); // C++11 only.
+
+    vector& operator= (const std::vector<T, A>&);
+    vector& operator= (std::vector<T, A>&&); // C++11 only.
+
+    operator const std::vector<T, A>& () const;
+    std::vector<T, A>& base ();
+    const std::vector<T, A>& base ();
+
+    // Change tracking.
+    //
+    bool _tracking () const;
+    void _start () const;
+    void _stop () const;
+    void _arm (transaction&) const;
+  };
+}
+
+ +

The following example highlights some of the differences between + the two interfaces. std::vector versions are commented + out.

+ + 
+#include <vector>
+#include <odb/vector.hxx>
+
+void f (const std::vector<int>&);
+
+odb::vector<int> v ({1, 2, 3});
+
+f (v); // Ok, implicit conversion.
+
+if (v[1] == 2) // Ok, const access.
+  //v[1]++;
+  v.modify (1)++;
+
+//v.back () = 4;
+v.modify_back () = 4;
+
+for (auto i (v.begin ()); i != v.end (); ++i)
+{
+  if (*i != 0) // Ok, const access.
+    //*i += 10;
+    i.modify () += 10;
+}
+
+std::sort (v.mbegin (), v.mend ());
+
+ +

Note also the subtle difference between copy/move construction + and copy/move assignment of odb::vector instances. + While copy/move constructor will copy/move both the elements as + well as their change state, in contrast, assignment is tracked + as any other change to the vector content.

+ +

5.5 Using Custom Containers

+ +

While the ODB runtime and profile libraries provide support for + a wide range of containers, it is also easy to persist custom + container types or make a change-tracking version out of one.

+ +

To achieve this you will need to implement the + container_traits class template specialization for + your container. First, determine the container kind (ordered, set, + multiset, map, or multimap) for your container type. Then use a + specialization for one of the standard C++ containers found in + the common ODB runtime library (libodb) as a base + for your own implementation.

+ +

Once the container traits specialization is ready for your container, + you will need to include it into the ODB compilation process using + the --odb-epilogue option and into the generated header + files with the --hxx-prologue option. As an example, + suppose we have a hash table container for which we have the traits + specialization implemented in the hashtable-traits.hxx + file. Then, we can create an ODB compiler options file for this + container and save it to hashtable.options:

+ + 
+# Options file for the hash table container.
+#
+--odb-epilogue '#include "hashtable-traits.hxx"'
+--hxx-prologue '#include "hashtable-traits.hxx"'
+
+ +

Now, whenever we compile a header file that uses the hashtable + container, we can specify the following command line option to + make sure it is recognized by the ODB compiler as a container + and the traits file is included in the generated code:

+ + 
+--options-file hashtable.options
+
+ + + + + +
+

6 Relationships

+ +

Relationships between persistent objects are expressed with pointers or + containers of pointers. The ODB runtime library provides built-in support + for shared_ptr/weak_ptr (TR1 or C++11), + std::unique_ptr (C++11), + std::auto_ptr, and raw pointers. Plus, ODB profile + libraries, that are available for commonly used frameworks and libraries + (such as Boost and Qt), provide support for smart pointers found in these + frameworks and libraries (Part III, "Profiles"). It is + also easy to add support for a custom smart pointer as discussed later + in Section 6.5, "Using Custom Smart Pointers". Any + supported smart pointer can be used in a data member as long as it can be + explicitly constructed from the canonical object pointer + (Section 3.3, "Object and View Pointers"). For + example, we can use weak_ptr if the object pointer + is shared_ptr.

+ +

When an object containing a pointer to another object is loaded, + the pointed-to object is loaded as well. In some situations this + eager loading of the relationships is undesirable since it + can lead to a large number of otherwise unused objects being + instantiated from the database. To support finer control + over relationships loading, the ODB runtime and profile + libraries provide the so-called lazy versions of + the supported pointers. An object pointed-to by a lazy pointer + is not loaded automatically when the containing object is loaded. + Instead, we have to explicitly request the instantiation of the + pointed-to object. Lazy pointers are discussed in + detail in Section 6.4, "Lazy Pointers".

+ +

As a simple example, consider the following employee-employer + relationship. Code examples presented in this chapter + will use the shared_ptr and weak_ptr + smart pointers from the TR1 (std::tr1) namespace.

+ + 
+#pragma db object
+class employer
+{
+  ...
+
+  #pragma db id
+  std::string name_;
+};
+
+#pragma db object
+class employee
+{
+  ...
+
+  #pragma db id
+  unsigned long id_;
+
+  std::string first_name_;
+  std::string last_name_;
+
+  shared_ptr<employer> employer_;
+};
+
+ +

By default, an object pointer can be NULL. To + specify that a pointer always points to a valid object we can + use the not_null pragma (Section + 14.4.6, "null/not_null") for + single object pointers and the value_not_null pragma + (Section + 14.4.28, "value_null/value_not_null") + for containers of object pointers. For example:

+ + 
+#pragma db object
+class employee
+{
+  ...
+
+  #pragma db not_null
+  shared_ptr<employer> current_employer_;
+
+  #pragma db value_not_null
+  std::vector<shared_ptr<employer> > previous_employers_;
+};
+
+ +

In this case, if we call either persist() or + update() database function on the + employee object and the current_employer_ + pointer or one of the pointers stored in the + previous_employers_ container is NULL, + then the odb::null_pointer exception will be thrown.

+ +

We don't need to do anything special to establish or navigate a + relationship between two persistent objects, as shown in the + following code fragment:

+ + 
+// Create an employer and a few employees.
+//
+unsigned long john_id, jane_id;
+{
+  shared_ptr<employer> er (new employer ("Example Inc"));
+  shared_ptr<employee> john (new employee ("John", "Doe"));
+  shared_ptr<employee> jane (new employee ("Jane", "Doe"));
+
+  john->employer_ = er;
+  jane->employer_ = er;
+
+  transaction t (db.begin ());
+
+  db.persist (er);
+  john_id = db.persist (john);
+  jane_id = db.persist (jane);
+
+  t.commit ();
+}
+
+// Load a few employee objects and print their employer.
+//
+{
+  session s;
+  transaction t (db.begin ());
+
+  shared_ptr<employee> john (db.load<employee> (john_id));
+  shared_ptr<employee> jane (db.load<employee> (jane_id));
+
+  cout << john->employer_->name_ << endl;
+  cout << jane->employer_->name_ << endl;
+
+  t.commit ();
+}
+
+ +

The only notable line in the above code is the creation of a + session before the second transaction starts. As discussed in + Chapter 11, "Session", a session acts as a cache + of persistent objects. + By creating a session before loading the employee + objects we make sure that their employer_ pointers + point to the same employer object. Without a + session, each employee would have ended up pointing + to its own, private instance of the Example Inc employer.

+ +

As a general guideline, you should use a session when loading + objects that have pointers to other persistent objects. A + session makes sure that for a given object id, a single instance + is shared among all other objects that relate to it.

+ +

We can also use data members from pointed-to + objects in database queries (Chapter 4, "Querying the + Database"). For each pointer in a persistent class, the query + class defines a smart pointer-like member that contains members + corresponding to the data members in the pointed-to object. We + can then use the access via a pointer syntax (->) + to refer to data members in pointed-to objects. + For example, the query class for the employee object + contains the employer member (its name is derived from the + employer_ pointer) which in turn contains the + name member (its name is derived from the + employer::name_ data member of the pointed-to object). + As a result, we can use the query::employer->name + expression while querying the database for the employee + objects. For example, the following transaction finds all the + employees of Example Inc that have the Doe last name:

+ + 
+typedef odb::query<employee> query;
+typedef odb::result<employee> result;
+
+session s;
+transaction t (db.begin ());
+
+result r (db.query<employee> (
+  query::employer->name == "Example Inc" && query::last == "Doe"));
+
+for (result::iterator i (r.begin ()); i != r.end (); ++i)
+  cout << i->first_ << " " << i->last_ << endl;
+
+t.commit ();
+
+ +

A query class member corresponding to a non-inverse + (Section 6.2, "Bidirectional Relationships") object + pointer can also be used as a normal member that has the id type + of the pointed-to object. For example, the following query locates + all the employee objects that don't have an associated + employer object:

+ + 
+result r (db.query<employee> (query::employer.is_null ()));
+
+ +

An important concept to keep in mind when working with object + relationships is the independence of persistent objects. In particular, + when an object containing a pointer to another object is made persistent + or is updated, the pointed-to object is not automatically persisted + or updated. Rather, only a reference to the object (in the form of the + object id) is stored for the pointed-to object in the database. + The pointed-to object itself is a separate entity and should + be made persistent or updated independently. By default, the + same principle also applies to erasing pointed-to objects. That + is, we have to make sure all the pointing objects are updated + accordingly. However, in the case of erase, we can specify an + alternative on-delete semantic as discussed in + Section 14.4.15, "on_delete".

+ +

When persisting or updating an object containing a pointer to another + object, the pointed-to object must have a valid object id. This, + however, may not always be easy to achieve in complex relationships that + involve objects with automatically assigned identifiers. In such + cases it may be necessary to first persist an object with a pointer + set to NULL and then, once the pointed-to object is + made persistent and its identifier assigned, set the pointer + to the correct value and update the object in the database.

+ +

Persistent object relationships can be divided into two groups: + unidirectional and bidirectional. Each group in turn contains + several configurations that vary depending on the cardinality + of the sides of the relationship. All possible unidirectional + and bidirectional configurations are discussed in the following + sections.

+ +

6.1 Unidirectional Relationships

+ +

In unidirectional relationships we are only interested in navigating + from object to object in one direction. Because there is no interest + in navigating in the opposite direction, the cardinality of the other + end of the relationship is unimportant. As a result, there are only + two possible unidirectional relationships: to-one and to-many. Each + of these relationships is described in the following sections. For + sample code that shows how to work with these relationships, refer + to the relationship example in the odb-examples + package.

+ +

6.1.1 To-One Relationships

+ +

An example of a unidirectional to-one relationship is the + employee-employer relationship (an employee has one employer). + The following persistent C++ classes model this relationship:

+ + 
+#pragma db object
+class employer
+{
+  ...
+
+  #pragma db id
+  std::string name_;
+};
+
+#pragma db object
+class employee
+{
+  ...
+
+  #pragma db id
+  unsigned long id_;
+
+  #pragma db not_null
+  shared_ptr<employer> employer_;
+};
+
+ +

The corresponding database tables look like this:

+ + 
+CREATE TABLE employer (
+  name VARCHAR (255) NOT NULL PRIMARY KEY);
+
+CREATE TABLE employee (
+  id BIGINT UNSIGNED NOT NULL PRIMARY KEY,
+  employer VARCHAR (255) NOT NULL REFERENCES employer (name));
+
+ +

6.1.2 To-Many Relationships

+ +

An example of a unidirectional to-many relationship is the + employee-project relationship (an employee can be involved + in multiple projects). The following persistent C++ classes + model this relationship:

+ + 
+#pragma db object
+class project
+{
+  ...
+
+  #pragma db id
+  std::string name_;
+};
+
+#pragma db object
+class employee
+{
+  ...
+
+  #pragma db id
+  unsigned long id_;
+
+  #pragma db value_not_null unordered
+  std::vector<shared_ptr<project> > projects_;
+};
+
+ +

The corresponding database tables look like this:

+ + 
+CREATE TABLE project (
+  name VARCHAR (255) NOT NULL PRIMARY KEY);
+
+CREATE TABLE employee (
+  id BIGINT UNSIGNED NOT NULL PRIMARY KEY);
+
+CREATE TABLE employee_projects (
+  object_id BIGINT UNSIGNED NOT NULL,
+  value VARCHAR (255) NOT NULL REFERENCES project (name));
+
+ +

To obtain a more canonical database schema, the names of tables + and columns above can be customized using ODB pragmas + (Chapter 14, "ODB Pragma Language"). For example:

+ + 
+#pragma db object
+class employee
+{
+  ...
+
+  #pragma db value_not_null unordered \
+             id_column("employee_id") value_column("project_name")
+  std::vector<shared_ptr<project> > projects_;
+};
+
+ +

The resulting employee_projects table would then + look like this:

+ + 
+CREATE TABLE employee_projects (
+  employee_id BIGINT UNSIGNED NOT NULL,
+  project_name VARCHAR (255) NOT NULL REFERENCES project (name));
+
+ + +

6.2 Bidirectional Relationships

+ +

In bidirectional relationships we are interested in navigating + from object to object in both directions. As a result, each + object class in a relationship contains a pointer to the other + object. If smart pointers are used, then a weak pointer should + be used as one of the pointers to avoid ownership cycles. For + example:

+ + 
+class employee;
+
+#pragma db object
+class position
+{
+  ...
+
+  #pragma db id
+  unsigned long id_;
+
+  weak_ptr<employee> employee_;
+};
+
+#pragma db object
+class employee
+{
+  ...
+
+  #pragma db id
+  unsigned long id_;
+
+  #pragma db not_null
+  shared_ptr<position> position_;
+};
+
+ +

Note that when we establish a bidirectional relationship, we + have to set both pointers consistently. One way to make sure + that a relationship is always in a consistent state is to + provide a single function that updates both pointers at the + same time. For example:

+ + 
+#pragma db object
+class position: public enable_shared_from_this<position>
+{
+  ...
+
+  void
+  fill (shared_ptr<employee> e)
+  {
+    employee_ = e;
+    e->positions_ = shared_from_this ();
+  }
+
+private:
+  weak_ptr<employee> employee_;
+};
+
+#pragma db object
+class employee
+{
+  ...
+
+private:
+  friend class position;
+
+  #pragma db not_null
+  shared_ptr<position> position_;
+};
+
+ +

At the beginning of this chapter we examined how to use a session + to make sure a single object is shared among all other objects pointing + to it. With bidirectional relationships involving weak pointers the + use of a session becomes even more crucial. Consider the following + transaction that tries to load the position object + from the above example without using a session:

+ + 
+transaction t (db.begin ())
+shared_ptr<position> p (db.load<position> (1));
+...
+t.commit ();
+
+ +

When we load the position object, the employee + object, which it points to, is also loaded. While employee + is initially stored as shared_ptr, it is then assigned to + the employee_ member which is weak_ptr. Once + the assignment is complete, the shared pointer goes out of scope + and the only pointer that points to the newly loaded + employee object is the employee_ weak + pointer. And that means the employee object is deleted + immediately after being loaded. To help avoid such pathological + situations ODB detects cases where a newly loaded object will + immediately be deleted and throws the odb::session_required + exception.

+ +

As the exception name suggests, the easiest way to resolve this + problem is to use a session:

+ + 
+session s;
+transaction t (db.begin ())
+shared_ptr<position> p (db.load<position> (1));
+...
+t.commit ();
+
+ +

In our example, the session will maintain a shared pointer to the + loaded employee object preventing its immediate + deletion. Another way to resolve this problem is to avoid + immediate loading of the pointed-to objects using lazy weak + pointers. Lazy pointers are discussed in Section 6.4, + "Lazy Pointers" later in this chapter.

+ +

Above, to model a bidirectional relationship in persistent classes, + we used two pointers, one in each object. While this is a natural + representation in C++, it does not translate to a canonical + relational model. Consider the database schema generated for + the above two classes:

+ + 
+CREATE TABLE position (
+  id BIGINT UNSIGNED NOT NULL PRIMARY KEY,
+  employee BIGINT UNSIGNED REFERENCES employee (id));
+
+CREATE TABLE employee (
+  id BIGINT UNSIGNED NOT NULL PRIMARY KEY,
+  position BIGINT UNSIGNED NOT NULL REFERENCES position (id));
+
+ +

While this database schema is valid, it is unconventional. We have + a reference from a row in the position table to a row + in the employee table. We also have a reference + from this same row in the employee table back to + the row in the position table. From the relational + point of view, one of these references is redundant since + in SQL we can easily navigate in both directions using just one + of these references.

+ +

To eliminate redundant database schema references we can use the + inverse pragma (Section 14.4.14, + "inverse") which tells the ODB compiler that + a pointer is the inverse side of a bidirectional relationship. + Either side of a relationship can be made inverse. For example:

+ + 
+#pragma db object
+class position
+{
+  ...
+
+  #pragma db inverse(position_)
+  weak_ptr<employee> employee_;
+};
+
+#pragma db object
+class employee
+{
+  ...
+
+  #pragma db not_null
+  shared_ptr<position> position_;
+};
+
+ +

The resulting database schema looks like this:

+ + 
+CREATE TABLE position (
+  id BIGINT UNSIGNED NOT NULL PRIMARY KEY);
+
+CREATE TABLE employee (
+  id BIGINT UNSIGNED NOT NULL PRIMARY KEY,
+  position BIGINT UNSIGNED NOT NULL REFERENCES position (id));
+
+ +

As you can see, an inverse member does not have a corresponding + column (or table, in case of an inverse container of pointers) + and, from the point of view of database operations, is effectively + read-only. The only way to change a bidirectional relationship + with an inverse side is to set its direct (non-inverse) + pointer. Also note that an ordered container (Section + 5.1, "Ordered Containers") of pointers that is an inverse side + of a bidirectional relationship is always treated as unordered + (Section 14.4.19, "unordered") + because the contents of such a container are implicitly built from + the direct side of the relationship which does not contain the + element order (index).

+ +

There are three distinct bidirectional relationships that we + will cover in the following sections: one-to-one, one-to-many, + and many-to-many. We will only talk about bidirectional + relationships with inverse sides since they result in canonical + database schemas. For sample code that shows how to work with + these relationships, refer to the inverse example + in the odb-examples package.

+ +

6.2.1 One-to-One Relationships

+ +

An example of a bidirectional one-to-one relationship is the + presented above employee-position relationship (an employee + fills one position and a position is filled by one employee). + The following persistent C++ classes model this relationship:

+ + 
+class employee;
+
+#pragma db object
+class position
+{
+  ...
+
+  #pragma db id
+  unsigned long id_;
+
+  #pragma db inverse(position_)
+  weak_ptr<employee> employee_;
+};
+
+#pragma db object
+class employee
+{
+  ...
+
+  #pragma db id
+  unsigned long id_;
+
+  #pragma db not_null
+  shared_ptr<position> position_;
+};
+
+ +

The corresponding database tables look like this:

+ + 
+CREATE TABLE position (
+  id BIGINT UNSIGNED NOT NULL PRIMARY KEY);
+
+CREATE TABLE employee (
+  id BIGINT UNSIGNED NOT NULL PRIMARY KEY,
+  position BIGINT UNSIGNED NOT NULL REFERENCES position (id));
+
+ +

If instead the other side of this relationship is made inverse, + then the database tables will change as follows:

+ + 
+CREATE TABLE position (
+  id BIGINT UNSIGNED NOT NULL PRIMARY KEY,
+  employee BIGINT UNSIGNED REFERENCES employee (id));
+
+CREATE TABLE employee (
+  id BIGINT UNSIGNED NOT NULL PRIMARY KEY);
+
+ +

6.2.2 One-to-Many Relationships

+ +

An example of a bidirectional one-to-many relationship is the + employer-employee relationship (an employer has multiple + employees and an employee is employed by one employer). + The following persistent C++ classes model this relationship:

+ + 
+class employee;
+
+#pragma db object
+class employer
+{
+  ...
+
+  #pragma db id
+  std::string name_;
+
+  #pragma db value_not_null inverse(employer_)
+  std::vector<weak_ptr<employee> > employees_
+};
+
+#pragma db object
+class employee
+{
+  ...
+
+  #pragma db id
+  unsigned long id_;
+
+  #pragma db not_null
+  shared_ptr<employer> employer_;
+};
+
+ +

The corresponding database tables differ significantly depending + on which side of the relationship is made inverse. If the one + side (employer) is inverse as in the code + above, then the resulting database schema looks like this:

+ + 
+CREATE TABLE employer (
+  name VARCHAR (255) NOT NULL PRIMARY KEY);
+
+CREATE TABLE employee (
+  id BIGINT UNSIGNED NOT NULL PRIMARY KEY,
+  employer VARCHAR (255) NOT NULL REFERENCES employer (name));
+
+ +

If instead the many side (employee) of this + relationship is made inverse, then the database tables will change + as follows:

+ + 
+CREATE TABLE employer (
+  name VARCHAR (255) NOT NULL PRIMARY KEY);
+
+CREATE TABLE employer_employees (
+  object_id VARCHAR (255) NOT NULL,
+  value BIGINT UNSIGNED NOT NULL REFERENCES employee (id));
+
+CREATE TABLE employee (
+  id BIGINT UNSIGNED NOT NULL PRIMARY KEY);
+
+ +

6.2.3 Many-to-Many Relationships

+ +

An example of a bidirectional many-to-many relationship is the + employee-project relationship (an employee can work on multiple + projects and a project can have multiple participating employees). + The following persistent C++ classes model this relationship:

+ + 
+class employee;
+
+#pragma db object
+class project
+{
+  ...
+
+  #pragma db id
+  std::string name_;
+
+  #pragma db value_not_null inverse(projects_)
+  std::vector<weak_ptr<employee> > employees_;
+};
+
+#pragma db object
+class employee
+{
+  ...
+
+  #pragma db id
+  unsigned long id_;
+
+  #pragma db value_not_null unordered
+  std::vector<shared_ptr<project> > projects_;
+};
+
+ +

The corresponding database tables look like this:

+ + 
+CREATE TABLE project (
+  name VARCHAR (255) NOT NULL PRIMARY KEY);
+
+CREATE TABLE employee (
+  id BIGINT UNSIGNED NOT NULL PRIMARY KEY);
+
+CREATE TABLE employee_projects (
+  object_id BIGINT UNSIGNED NOT NULL,
+  value VARCHAR (255) NOT NULL REFERENCES project (name));
+
+ +

If instead the other side of this relationship is made inverse, + then the database tables will change as follows:

+ + 
+CREATE TABLE project (
+  name VARCHAR (255) NOT NULL PRIMARY KEY);
+
+CREATE TABLE project_employees (
+  object_id VARCHAR (255) NOT NULL,
+  value BIGINT UNSIGNED NOT NULL REFERENCES employee (id));
+
+CREATE TABLE employee (
+  id BIGINT UNSIGNED NOT NULL PRIMARY KEY);
+
+ +

6.3 Circular Relationships

+ +

A relationship between two persistent classes is circular if each + of them references the other. Bidirectional relationships are + always circular. A unidirectional relationship combined with + inheritance (Chapter 8, "Inheritance") can also + be circular. For example, the employee class could + derive from person which, in turn, could contain a + pointer to employee.

+ +

We don't need to do anything extra if persistent classes with + circular dependencies are defined in the same header + file. Specifically, ODB will make sure that the database tables + and foreign key constraints are created in the correct order. As a + result, unless you have good reasons not to, it is recommended that + you keep persistent classes with circular dependencies in the same + header file.

+ +

If you have to keep such classes in separate header files, then + there are two extra steps that you may need to take in order to + use these classes with ODB. Consider again the example from + Section 6.2.1, "One-to-One Relationships" + but this time with the classes defined in separate headers:

+ + 
+// position.hxx
+//
+class employee;
+
+#pragma db object
+class position
+{
+  ...
+
+  #pragma db id
+  unsigned long id_;
+
+  #pragma db inverse(position_)
+  weak_ptr<employee> employee_;
+};
+
+ + 
+// employee.hxx
+//
+#include "position.hxx"
+
+#pragma db object
+class employee
+{
+  ...
+
+  #pragma db id
+  unsigned long id_;
+
+  #pragma db not_null
+  shared_ptr<position> position_;
+};
+
+ +

Note that the position.hxx header contains only the forward + declaration for employee. While this is sufficient to + define a valid, from the C++ point of view, position class, + the ODB compiler needs to "see" the definitions of the pointed-to + persistent classes. There are several ways we can fulfil this + requirement. The easiest is to simply include employee.hxx + at the end of position.hxx:

+ + 
+// position.hxx
+//
+class employee;
+
+#pragma db object
+class position
+{
+  ...
+};
+
+#include "employee.hxx"
+
+ +

We can also limit this inclusion only to the time when + position.hxx is compiled with the ODB compiler:

+ + 
+// position.hxx
+//
+
+...
+
+#ifdef ODB_COMPILER
+#  include "employee.hxx"
+#endif
+
+ +

Finally, if we don't want to modify position.hxx, + then we can add employee.hxx to the ODB compilation + process with the --odb-epilogue option. For example:

+ + 
+odb ... --odb-epilogue "#include \"employee.hxx\"" position.hxx
+
+ +

Note also that in this example we didn't have to do anything extra + for employee.hxx because it already includes + position.hxx. However, if instead it relied only + on the forward declaration of the position class, + then we would have to handle it in the same way as + position.hxx.

+ +

The other difficulty with separately defined classes involving + circular relationships has to do with the correct order of foreign + key constraint creation in the generated database schema. In + the above example, if we generate the database schema as + standalone SQL files, then we will end up with two such files: + position.sql and employee.sql. + If we try to execute employee.sql first, then + we will get an error indicating that the table corresponding to + the position class and referenced by the foreign + key constraint corresponding to the position_ + pointer does not yet exist.

+ +

Note that there is no such problem if the database schema + is embedded in the generated C++ code instead of being produced + as standalone SQL files. In this case, the ODB compiler is + able to ensure the correct creation order even if the classes + are defined in separate header files.

+ +

In certain cases, for example, a bidirectional relationship + with an inverse side, this problem can be resolved by executing + the database schema creation files in the correct order. In our + example, this would be position.sql first + and employee.sql second. However, this approach + doesn't scale beyond simple object models.

+ +

A more robust solution to this problem is to generate the database + schema for all the persistent classes into a single SQL file. This + way, the ODB compiler can again ensure the correct creation order + of tables and foreign keys. To instruct the ODB compiler to produce + a combined schema file for several headers we can use the + --generate-schema-only and --at-once + options. For example:

+ + 
+odb ... --generate-schema-only --at-once --input-name company \
+position.hxx employee.hxx
+
+ +

The result of the above command is a single company.sql + file (the name is derived from the --input-name value) + that contains the database creation code for both position + and employee classes.

+ +

6.4 Lazy Pointers

+ +

Consider again the bidirectional, one-to-many employer-employee + relationship that was presented earlier in this chapter:

+ + 
+class employee;
+
+#pragma db object
+class employer
+{
+  ...
+
+  #pragma db id
+  std::string name_;
+
+  #pragma db value_not_null inverse(employer_)
+  std::vector<weak_ptr<employee> > employees_;
+};
+
+#pragma db object
+class employee
+{
+  ...
+
+  #pragma db id
+  unsigned long id_;
+
+  #pragma db not_null
+  shared_ptr<employer> employer_;
+};
+
+ +

Consider also the following transaction which obtains the employer + name given the employee id:

+ + 
+unsigned long id = ...
+string name;
+
+session s;
+transaction t (db.begin ());
+
+shared_ptr<employee> e (db.load<employee> (id));
+name = e->employer_->name_;
+
+t.commit ();
+
+ +

While this transaction looks very simple, it actually does a lot more + than what meets the eye and is necessary. Consider what happens when + we load the employee object: the employer_ + pointer is also automatically loaded which means the employer + object corresponding to this employee is also loaded. But the + employer object in turn contains the list of pointers + to all the employees, which are also loaded. A a result, when object + relationships are involved, a simple transaction like the above can + load many more objects than is necessary.

+ +

To overcome this problem ODB offers finer grained control over + the relationship loading in the form of lazy pointers. A lazy + pointer does not automatically load the pointed-to object + when the containing object is loaded. Instead, we have to + explicitly load the pointed-to object if and when we need to + access it.

+ +

The ODB runtime library provides lazy counterparts for all the + supported pointers, namely: + odb::lazy_shared_ptr/lazy_weak_ptr + for C++11 std::shared_ptr/weak_ptr, + odb::tr1::lazy_shared_ptr/lazy_weak_ptr + for TR1 std::tr1::shared_ptr/weak_ptr, + odb::lazy_unique_ptr for C++11 std::unique_ptr, + odb::lazy_auto_ptr for std::auto_ptr, + and odb::lazy_ptr for raw pointers. The TR1 lazy + pointers are defined in the <odb/tr1/lazy-ptr.hxx> + header while all the others — in + <odb/lazy-ptr.hxx>. The ODB profile + libraries also provide lazy pointer implementations for smart pointers + from popular frameworks and libraries (Part III, + "Profiles").

+ +

While we will discuss the interface of lazy pointers in more detail + shortly, the most commonly used extra function provided by these + pointers is load(). This function loads the + pointed-to object if it hasn't already been loaded. After + the call to this function, the lazy pointer can be used + in the the same way as its eager counterpart. The load() + function also returns the eager pointer, in case you need to pass + it around. For a lazy weak pointer, the + load() function also locks the pointer.

+ +

The following example shows how we can change our employer-employee + relationship to use lazy pointers. Here we choose to use lazy pointers + for both sides of the relationship.

+ + 
+class employee;
+
+#pragma db object
+class employer
+{
+  ...
+
+  #pragma db value_not_null inverse(employer_)
+  std::vector<lazy_weak_ptr<employee> > employees_;
+};
+
+#pragma db object
+class employee
+{
+  ...
+
+  #pragma db not_null
+  lazy_shared_ptr<employer> employer_;
+};
+
+ +

And the transaction is changed like this:

+ + 
+unsigned long id = ...
+string name;
+
+session s;
+transaction t (db.begin ());
+
+shared_ptr<employee> e (db.load<employee> (id));
+e->employer_.load ();
+name = e->employer_->name_;
+
+t.commit ();
+
+ + +

As a general guideline we recommend that you make at least one side + of a bidirectional relationship lazy, especially for relationships + with a many side.

+ +

A lazy pointer implementation mimics the interface of its eager + counterpart which can be used once the pointer is loaded. It also + adds a number of additional functions that are specific to the + lazy loading functionality. Overall, the interface of a lazy + pointer follows this general outline:

+ + 
+template <class T>
+class lazy_ptr
+{
+public:
+  //
+  // The eager pointer interface.
+  //
+
+  // Initialization/assignment from an eager pointer.
+  //
+public:
+  template <class Y> lazy_ptr (const eager_ptr<Y>&);
+  template <class Y> lazy_ptr& operator= (const eager_ptr<Y>&);
+
+  // Lazy loading interface.
+  //
+public:
+  //  NULL      loaded()
+  //
+  //  true       true      NULL pointer to transient object
+  //  false      true      valid pointer to persistent object
+  //  true       false     unloaded pointer to persistent object
+  //  false      false     valid pointer to transient object
+  //
+  bool loaded () const;
+
+  eager_ptr<T> load () const;
+
+  // Unload the pointer. For transient objects this function is
+  // equivalent to reset().
+  //
+  void unload () const;
+
+  // Get the underlying eager pointer. If this is an unloaded pointer
+  // to a persistent object, then the returned pointer will be NULL.
+  //
+  eager_ptr<T> get_eager () const;
+
+  // Initialization with a persistent loaded object.
+  //
+  template <class Y> lazy_ptr (database&, Y*);
+  template <class Y> lazy_ptr (database&, const eager_ptr<Y>&);
+
+  template <class Y> void reset (database&, Y*);
+  template <class Y> void reset (database&, const eager_ptr<Y>&);
+
+  // Initialization with a persistent unloaded object.
+  //
+  template <class ID> lazy_ptr (database&, const ID&);
+
+  template <class ID> void reset (database&, const ID&);
+
+  // Query object id and database of a persistent object.
+  //
+  template <class O /* = T */>
+  // C++11: template <class O = T>
+  object_traits<O>::id_type object_id () const;
+
+  odb::database& database () const;
+};
+
+ +

In a lazy weak pointer interface, the load() function + returns the strong (shared) eager pointer. The following + transaction demonstrates the use of a lazy weak pointer based on + the employer and employee classes + presented earlier.

+ + 
+typedef std::vector<lazy_weak_ptr<employee> > employees;
+
+session s;
+transaction t (db.begin ());
+
+shared_ptr<employer> er (db.load<employer> ("Example Inc"));
+employees& es (er->employees ());
+
+for (employees::iterator i (es.begin ()); i != es.end (); ++i)
+{
+  // We are only interested in employees with object id less than
+  // 100.
+  //
+  lazy_weak_ptr<employee>& lwp (*i);
+
+  if (lwp.object_id<employee> () < 100)
+  // C++11: if (lwp.object_id () < 100)
+  {
+    shared_ptr<employee> e (lwp.load ()); // Load and lock.
+    cout << e->first_ << " " << e->last_ << endl;
+  }
+}
+
+t.commit ();
+
+ +

Notice that inside the for-loop we use a reference to the lazy + weak pointer instead of making a copy. This is not merely to + avoid a copy. When a lazy pointer is loaded, all other lazy + pointers that point to the same object do not automatically + become loaded (though an attempt to load such copies will + result in them pointing to the same object, provided the + same session is still in effect). By using a reference + in the above transaction we make sure that we load the + pointer that is contained in the employer + object. This way, if we later need to re-examine this + employee object, the pointer will already + be loaded.

+ +

As another example, suppose we want to add an employee + to Example Inc. The straightforward implementation of this + transaction is presented below:

+ + 
+session s;
+transaction t (db.begin ());
+
+shared_ptr<employer> er (db.load<employer> ("Example Inc"));
+shared_ptr<employee> e (new employee ("John", "Doe"));
+
+e->employer_ = er;
+er->employees ().push_back (e);
+
+db.persist (e);
+t.commit ();
+
+ +

Notice here that we didn't have to update the employer object + in the database since the employees_ list of + pointers is an inverse side of a bidirectional relationship + and is effectively read-only, from the persistence point of + view.

+ +

A faster implementation of this transaction, that avoids loading + the employer object, relies on the ability to initialize an + unloaded lazy pointer with the database where the object + is stored as well as its identifier:

+ + 
+lazy_shared_ptr<employer> er (db, std::string ("Example Inc"));
+shared_ptr<employee> e (new employee ("John", "Doe"));
+
+e->employer_ = er;
+
+session s;
+transaction t (db.begin ());
+
+db.persist (e);
+
+t.commit ();
+
+ +

For the interaction of lazy pointers with lazy-loaded object + sections, refer to Section 9.3, "Sections and + Lazy Pointers".

+ +

6.5 Using Custom Smart Pointers

+ +

While the ODB runtime and profile libraries provide support for + the majority of widely-used pointers, it is also easy to add + support for a custom smart pointer.

+ +

To achieve this you will need to implement the + pointer_traits class template specialization for + your pointer. The first step is to determine the pointer kind + since the interface of the pointer_traits specialization + varies depending on the pointer kind. The supported pointer kinds + are: raw (raw pointer or equivalent, that is, unmanaged), + unique (smart pointer that doesn't support sharing), + shared (smart pointer that supports sharing), and + weak (weak counterpart of the shared pointer). Any of + these pointers can be lazy, which also affects the + interface of the pointer_traits specialization.

+ +

Once you have determined the pointer kind for your smart pointer, + use a specialization for one of the standard pointers found in + the common ODB runtime library (libodb) as a base + for your own implementation.

+ +

Once the pointer traits specialization is ready, you will need to + include it into the ODB compilation process using the + --odb-epilogue option and into the generated header + files with the --hxx-prologue option. As an example, + suppose we have the smart_ptr smart pointer for which + we have the traits specialization implemented in the + smart-ptr-traits.hxx file. Then, we can create an ODB + compiler options file for this pointer and save it to + smart-ptr.options:

+ + 
+# Options file for smart_ptr.
+#
+--odb-epilogue '#include "smart-ptr-traits.hxx"'
+--hxx-prologue '#include "smart-ptr-traits.hxx"'
+
+ +

Now, whenever we compile a header file that uses smart_ptr, + we can specify the following command line option to make sure it is + recognized by the ODB compiler as a smart pointer and the traits file + is included in the generated code:

+ + 
+--options-file smart-ptr.options
+
+ +

It is also possible to implement a lazy counterpart for your + smart pointer. The ODB runtime library provides a class template + that encapsulates the object id management and loading + functionality that is needed to implement a lazy pointer. All + you need to do is wrap it with an interface that mimics + your smart pointer. Using one of the existing lazy pointer + implementations (either from the ODB runtime library or one + of the profile libraries) as a base for your implementation + is the easiest way to get started.

+ + + + +
+

7 Value Types

+ +

In Section 3.1, "Concepts and Terminology" we have + already discussed the notion of values and value types as well as the + distinction between simple and composite values. This chapter covers + simple and composite value types in more detail.

+ +

7.1 Simple Value Types

+ +

A simple value type is a fundamental C++ type or a class type that + is mapped to a single database column. For each supported database + system the ODB compiler provides a default mapping to suitable + database types for most fundamental C++ types, such as int + or float as well as some class types, such as + std::string. For more information about the default + mapping for each database system refer to Part II, + Database Systems. We can also provide a custom mapping for + these or our own value types using the db type + pragma (Section 14.3.1, "type").

+ +

7.2 Composite Value Types

+ +

A composite value type is a class or struct + type that is mapped to more than one database column. To declare + a composite value type we use the db value pragma, + for example:

+ + 
+#pragma db value
+class basic_name
+{
+  ...
+
+  std::string first_;
+  std::string last_;
+};
+
+ +

The complete version of the above code fragment and the other code + samples presented in this section can be found in the composite + example in the odb-examples package.

+ +

A composite value type does not have to define a default constructor, + unless it is used as an element of a container. In this case the + default constructor can be made private provided we also make the + odb::access class, defined in the + <odb/core.hxx> header, a friend of this value type. + For example:

+ + 
+#include <odb/core.hxx>
+
+#pragma db value
+class basic_name
+{
+public:
+  basic_name (const std::string& first, const std::string& last);
+
+  ...
+
+private:
+  friend class odb::access;
+
+  basic_name () {} // Needed for storing basic_name in containers.
+
+  ...
+};
+
+ +

The ODB compiler also needs access to the non-transient + (Section 14.4.11, "transient") + data members of a composite value type. It uses the same mechanisms + as for persistent classes which are discussed in + Section 3.2, "Declaring Persistent Objects and + Values".

+ +

The members of a composite value can be other value types (either + simple or composite), containers (Chapter 5, + "Containers"), and pointers to objects (Chapter 6, + "Relationships"). + Similarly, a composite value type can be used in object members, + as an element of a container, and as a base for another composite + value type. In particular, composite value types can be used as + element types in set containers (Section 5.2, "Set + and Multiset Containers") and as key types in map containers + (Section 5.3, "Map and Multimap Containers"). + A composite value type that is used as an element of a container + cannot contain other containers since containers of containers + are not allowed. The following example illustrates some of the + possible use cases:

+ + 
+#pragma db value
+class basic_name
+{
+  ...
+
+  std::string first_;
+  std::string last_;
+};
+
+typedef std::vector<basic_name> basic_names;
+
+#pragma db value
+class name_extras
+{
+  ...
+
+  std::string nickname_;
+  basic_names aliases_;
+};
+
+#pragma db value
+class name: public basic_name
+{
+  ...
+
+  std::string title_;
+  name_extras extras_;
+};
+
+#pragma db object
+class person
+{
+  ...
+
+  name name_;
+};
+
+ +

A composite value type can be defined inside a persistent class, + view, or another composite value and even made private, provided + we make odb::access a friend of the containing class, + for example:

+ +
+#pragma db object
+class person
+{
+  ...
+
+  #pragma db value
+  class name
+  {
+    ...
+
+    std::string first_;
+    std::string last_;
+  };
+
+  name name_;
+};
+
+ +

A composite value type can also be defined as an instantiation + of a C++ class template, for example:

+ + 
+template <typename T>
+struct point
+{
+  T x;
+  T y;
+  T z;
+};
+
+typedef point<int> int_point;
+#pragma db value(int_point)
+
+#pragma db object
+class object
+{
+  ...
+
+  int_point center_;
+};
+
+ +

Note that the database support code for such a composite value type + is generated when compiling the header containing the + db value pragma and not the header containing + the template definition or the typedef name. This + allows us to use templates defined in other files, such as + std::pair defined in the utility + standard header file:

+ + 
+#include <utility> // std::pair
+
+typedef std::pair<std::string, std::string> phone_numbers;
+#pragma db value(phone_numbers)
+
+#pragma db object
+class person
+{
+  ...
+
+  phone_numbers phone_;
+};
+
+ +

We can also use data members from composite value types + in database queries (Chapter 4, "Querying the + Database"). For each composite value in a persistent class, the + query class defines a nested member that contains members corresponding + to the data members in the value type. We can then use the member access + syntax (.) to refer to data members in value types. For example, the + query class for the person object presented above + contains the name member (its name is derived from + the name_ data member) which in turn contains the + extras member (its name is derived from the + name::extras_ data member of the composite value type). + This process continues recursively for nested composite value types + and, as a result, we can use the query::name.extras.nickname + expression while querying the database for the person + objects. For example:

+ + 
+typedef odb::query<person> query;
+typedef odb::result<person> result;
+
+transaction t (db.begin ());
+
+result r (db.query<person> (
+  query::name.extras.nickname == "Squeaky"));
+
+...
+
+t.commit ();
+
+ +

7.2.1 Composite Object Ids

+ +

An object id can be of a composite value type, for example:

+ + 
+#pragma db value
+class name
+{
+  ...
+
+  std::string first_;
+  std::string last_;
+};
+
+#pragma db object
+class person
+{
+  ...
+
+  #pragma db id
+  name name_;
+};
+
+ +

However, a value type that can be used as an object id has a number + of restrictions. Such a value type cannot have container, object + pointer, or read-only data members. It also must be + default-constructible, copy-constructible, and copy-assignable. + Furthermore, if the persistent class in which + this composite value type is used as object id has session support + enabled (Chapter 11, "Session"), then it must also + implement the less-than comparison operator (operator<).

+ +

7.2.2 Composite Value Column and Table Names

+ +

Customizing a column name for a data member of a simple value + type is straightforward: we simply specify the desired name with + the db column pragma (Section + 14.4.9, "column"). For composite value + types things are slightly more complex since they are mapped to + multiple columns. Consider the following example:

+ + 
+#pragma db value
+class name
+{
+  ...
+
+  std::string first_;
+  std::string last_;
+};
+
+#pragma db object
+class person
+{
+  ...
+
+  #pragma db id auto
+  unsigned long id_;
+
+  name name_;
+};
+
+ +

The column names for the first_ and last_ + members are constructed by using the sanitized name of the + person::name_ member as a prefix and the names of the + members in the value type (first_ and last_) + as suffixes. As a result, the database schema for the above classes + will look like this:

+ + 
+CREATE TABLE person (
+  id BIGINT UNSIGNED NOT NULL PRIMARY KEY,
+  name_first TEXT NOT NULL,
+  name_last TEXT NOT NULL);
+
+ +

We can customize both the prefix and the suffix using the + db column pragma as shown in the following + example:

+ + 
+#pragma db value
+class name
+{
+  ...
+
+  #pragma db column("first_name")
+  std::string first_;
+
+  #pragma db column("last_name")
+  std::string last_;
+};
+
+#pragma db object
+class person
+{
+  ...
+
+  #pragma db column("person_")
+  name name_;
+};
+
+ +

The database schema changes as follows:

+ + 
+CREATE TABLE person (
+  id BIGINT UNSIGNED NOT NULL PRIMARY KEY,
+  person_first_name TEXT NOT NULL,
+  person_last_name TEXT NOT NULL);
+
+ +

We can also make the column prefix empty, for example:

+ + 
+#pragma db object
+class person
+{
+  ...
+
+  #pragma db column("")
+  name name_;
+};
+
+ +

This will result in the following schema:

+ + 
+CREATE TABLE person (
+  id BIGINT UNSIGNED NOT NULL PRIMARY KEY,
+  first_name TEXT NOT NULL,
+  last_name TEXT NOT NULL);
+
+ +

The same principle applies when a composite value type is used + as an element of a container, except that instead of + db column, either the db value_column + (Section 14.4.36, "value_column") or + db key_column + (Section 14.4.35, "key_column") + pragmas are used to specify the column prefix.

+ +

When a composite value type contains a container, an extra table + is used to store its elements (Chapter 5, "Containers"). + The names of such tables are constructed in a way similar to the + column names, except that by default both the object name and the + member name are used as a prefix. For example:

+ + 
+#pragma db value
+class name
+{
+  ...
+
+  std::string first_;
+  std::string last_;
+  std::vector<std::string> nicknames_;
+};
+
+#pragma db object
+class person
+{
+  ...
+
+  name name_;
+};
+
+ +

The corresponding database schema will look like this:

+ + 
+CREATE TABLE person_name_nicknames (
+  object_id BIGINT UNSIGNED NOT NULL,
+  index BIGINT UNSIGNED NOT NULL,
+  value TEXT NOT NULL)
+
+CREATE TABLE person (
+  id BIGINT UNSIGNED NOT NULL PRIMARY KEY,
+  name_first TEXT NOT NULL,
+  name_last TEXT NOT NULL);
+
+ +

To customize the container table name we can use the + db table pragma (Section + 14.4.20, "table"), for example:

+ + 
+#pragma db value
+class name
+{
+  ...
+
+  #pragma db table("nickname")
+  std::vector<std::string> nicknames_;
+};
+
+#pragma db object
+class person
+{
+  ...
+
+  #pragma db table("person_")
+  name name_;
+};
+
+ +

This will result in the following schema changes:

+ + 
+CREATE TABLE person_nickname (
+  object_id BIGINT UNSIGNED NOT NULL,
+  index BIGINT UNSIGNED NOT NULL,
+  value TEXT NOT NULL)
+
+ +

Similar to columns, we can make the table prefix empty.

+ + +

7.3 Pointers and NULL Value Semantics

+ +

Relational database systems have a notion of the special + NULL value that is used to indicate the absence + of a valid value in a column. While by default ODB maps + values to columns that do not allow NULL values, + it is possible to change that with the db null + pragma (Section 14.4.6, + "null/not_null").

+ +

To properly support the NULL semantics, the + C++ value type must have a notion of a NULL + value or a similar special state concept. Most basic + C++ types, such as int or std::string, + do not have this notion and therefore cannot be used directly + for NULL-enabled data members (in the case of a + NULL value being loaded from the database, + such data members will be default-initialized).

+ +

To allow the easy conversion of value types that do not support + the NULL semantics into the ones that do, ODB + provides the odb::nullable class template. It + allows us to wrap an existing C++ type into a container-like + class that can either be NULL or contain a + value of the wrapped type. ODB also automatically enables + the NULL values for data members of the + odb::nullable type. For example:

+ + 
+#include <odb/nullable.hxx>
+
+#pragma db object
+class person
+{
+  ...
+
+  std::string first_;                    // TEXT NOT NULL
+  odb::nullable<std::string> middle_;    // TEXT NULL
+  std::string last_;                     // TEXT NOT NULL
+};
+
+ +

The odb::nullable class template is defined + in the <odb/nullable.hxx> header file and + has the following interface:

+ + 
+namespace odb
+{
+  template <typename T>
+  class nullable
+  {
+  public:
+    typedef T value_type;
+
+    nullable ();
+    nullable (const T&);
+    nullable (const nullable&);
+    template <typename Y> explicit nullable (const nullable<Y>&);
+
+    nullable& operator= (const T&);
+    nullable& operator= (const nullable&);
+    template <typename Y> nullable& operator= (const nullable<Y>&);
+
+    void swap (nullable&);
+
+    // Accessor interface.
+    //
+    bool null () const;
+
+    T&       get ();
+    const T& get () const;
+
+    // Pointer interface.
+    //
+    operator bool_convertible () const;
+
+    T*       operator-> ();
+    const T* operator-> () const;
+
+    T&       operator* ();
+    const T& operator* () const;
+
+    // Reset to the NULL state.
+    //
+    void reset ();
+  };
+}
+
+ +

The following example shows how we can use this interface:

+ + 
+  nullable<string> ns;
+
+  // Using the accessor interface.
+  //
+  if (ns.null ())
+  {
+    s = "abc";
+  }
+  else
+  {
+    string s (ns.get ());
+    ns.reset ();
+  }
+
+  // The same using the pointer interface.
+  //
+  if (ns)
+  {
+    s = "abc";
+  }
+  else
+  {
+    string s (*ns);
+    ns.reset ();
+  }
+
+ + +

The odb::nullable class template requires the wrapped + type to have public default and copy constructors as well as the + copy assignment operator. Note also that the odb::nullable + implementation is not the most efficient in that it always contains + a fully constructed value of the wrapped type. This is normally + not a concern for simple types such as the C++ fundamental + types or std::string. However, it may become + an issue for more complex types. In such cases you may want to + consider using a more efficient implementation of the + optional value concept such as the + optional class template from Boost + (Section 23.4, "Optional Library").

+ +

Another common C++ representation of a value that can be + NULL is a pointer. ODB will automatically + handle data members that are pointers to values, however, + it will not automatically enable NULL values + for such data members, as is the case for odb::nullable. + Instead, if the NULL value is desired, we will + need to enable it explicitly using the db null + pragma. For example:

+ + 
+#pragma db object
+class person
+{
+  ...
+
+  std::string first_;
+
+  #pragma db null
+  std::auto_ptr<std::string> middle_;
+
+  std::string last_;
+};
+
+ +

The ODB compiler includes built-in support for using + std::auto_ptr, std::unique_ptr (C++11), + and shared_ptr (TR1 or C++11) as pointers to values. + Plus, ODB profile libraries, that are + available for commonly used frameworks and libraries (such as Boost and + Qt), provide support for smart pointers found in these frameworks + and libraries (Part III, "Profiles").

+ +

ODB also supports the NULL semantics for composite + values. In the relational database the NULL composite + value is translated to NULL values for all the simple + data members of this composite value. For example:

+ + 
+#pragma db value
+struct name
+{
+  std::string first_;
+  odb::nullable<std::string> middle_;
+  std::string last_;
+};
+
+#pragma db object
+class person
+{
+  ...
+  odb::nullable<name> name_;
+};
+
+ +

ODB does not support the NULL semantics for containers. + This also means that a composite value that contains a container + cannot be NULL. With this limitation in mind, we can + still use smart pointers in data members of container types. The + only restriction is that these pointers must not be NULL. + For example:

+ + 
+#pragma db object
+class person
+{
+  ...
+
+  std::auto_ptr<std::vector<std::string> > aliases_;
+};
+
+ + + + + +
+

8 Inheritance

+ +

In C++ inheritance can be used to achieve two different goals. + We can employ inheritance to reuse common data and functionality + in multiple classes. For example:

+ + 
+class person
+{
+public:
+  const std::string& first () const;
+  const std::string& last () const;
+
+private:
+  std::string first_;
+  std::string last_;
+};
+
+class employee: public person
+{
+  ...
+};
+
+class contractor: public person
+{
+  ...
+};
+
+ +

In the above example both the employee and + contractor classes inherit the first_ + and last_ data members as well as the first() + and last() accessors from the person base + class.

+ +

A common trait of this inheritance style, referred to as reuse + inheritance from now on, is the lack of virtual functions and + a virtual destructor in the base class. Also with this style the + application code is normally written in terms of the derived classes + instead of the base.

+ +

The second way to utilize inheritance in C++ is to provide polymorphic + behavior through a common interface. In this case the base class + defines a number of virtual functions and, normally, a virtual + destructor while the derived classes provide specific + implementations of these virtual functions. For example:

+ + 
+class person
+{
+public:
+  enum employment_status
+  {
+    unemployed,
+    temporary,
+    permanent,
+    self_employed
+  };
+
+  virtual employment_status
+  employment () const = 0;
+
+  virtual
+  ~person ();
+};
+
+class employee: public person
+{
+public:
+  virtual employment_status
+  employment () const
+  {
+    return temporary_ ? temporary : permanent;
+  }
+
+private:
+  bool temporary_;
+};
+
+class contractor: public person
+{
+public:
+  virtual employment_status
+  employment () const
+  {
+    return self_employed;
+  }
+};
+
+ +

With this inheritance style, which we will call polymorphism + inheritance, the application code normally works with derived + classes via the base class interface. Note also that it is very common + to mix both styles in the same hierarchy. For example, the above two + code fragments can be combined so that the person base + class provides the common data members and functions as well as + defines the polymorphic interface.

+ +

The following sections describe the available strategies for + mapping reuse and polymorphism inheritance styles to a relational + data model. Note also that the distinction between the two styles is + conceptual rather than formal. For example, it is possible to treat + a class hierarchy that defines virtual functions as a case of reuse + inheritance if this results in the desired database mapping and + semantics.

+ +

Generally, classes that employ reuse inheritance are mapped to + completely independent entities in the database. They use different + object id spaces and should always be passed to and returned from + the database operations as pointers or references to derived types. + In other words, from the persistence point of view, such classes + behave as if the data members from the base classes were copied + verbatim into the derived ones.

+ +

In contrast, classes that employ polymorphism inheritance share + the object id space and can be passed to and returned from the + database operations polymorphically as pointers or + references to the base class.

+ +

For both inheritance styles it is sometimes desirable to prevent + instances of a base class from being stored in the database. + To achieve this a persistent + class can be declared abstract using the db abstract + pragma (Section 14.1.3, "abstract"). + Note that a C++-abstract class, or a class that + has one or more pure virtual functions and therefore cannot be + instantiated, is also database-abstract. However, a + database-abstract class is not necessarily C++-abstract. The + ODB compiler automatically treats C++-abstract classes as + database-abstract.

+ +

8.1 Reuse Inheritance

+ +

Each non-abstract class from the reuse inheritance hierarchy is + mapped to a separate database table that contains all its data + members, including those inherited from base classes. An abstract + persistent class does not have to define an object id, nor a default + constructor, and it does not have a corresponding database table. + An abstract class cannot be a pointed-to object in a relationship. + Multiple inheritance is supported as long as each base + class is only inherited once. The following example shows a + persistent class hierarchy employing reuse inheritance:

+ + 
+// Abstract person class. Note that it does not declare the
+// object id.
+//
+#pragma db object abstract
+class person
+{
+  ...
+
+  std::string first_;
+  std::string last_;
+};
+
+// Abstract employee class. It derives from the person class and
+// declares the object id for all the concrete employee types.
+//
+#pragma db object abstract
+class employee: public person
+{
+  ...
+
+  #pragma db id auto
+  unsigned long id_;
+};
+
+// Concrete permanent_employee class. Note that it doesn't define
+// any data members of its own.
+//
+#pragma db object
+class permanent_employee: public employee
+{
+  ...
+};
+
+// Concrete temporary_employee class. It adds the employment
+// duration in months.
+//
+#pragma db object
+class temporary_employee: public employee
+{
+  ...
+
+  unsigned long duration_;
+};
+
+// Concrete contractor class. It derives from the person class
+// (and not employee; an independent contractor is not considered
+// an employee). We use the contractor's external email address
+// as the object id.
+//
+#pragma db object
+class contractor: public person
+{
+  ...
+
+  #pragma db id
+  std::string email_;
+};
+
+ +

The sample database schema for this hierarchy is shown below.

+ + 
+CREATE TABLE permanent_employee (
+  first TEXT NOT NULL,
+  last TEXT NOT NULL,
+  id BIGINT UNSIGNED NOT NULL PRIMARY KEY AUTO_INCREMENT);
+
+CREATE TABLE temporary_employee (
+  first TEXT NOT NULL,
+  last TEXT NOT NULL,
+  id BIGINT UNSIGNED NOT NULL PRIMARY KEY AUTO_INCREMENT,
+  duration BIGINT UNSIGNED NOT NULL);
+
+CREATE TABLE contractor (
+  first TEXT NOT NULL,
+  last TEXT NOT NULL,
+  email VARCHAR (255) NOT NULL PRIMARY KEY);
+
+ +

The complete version of the code presented in this section is + available in the inheritance/reuse example in the + odb-examples package.

+ +

8.2 Polymorphism Inheritance

+ +

There are three general approaches to mapping a polymorphic + class hierarchy to a relational database. These are + table-per-hierarchy, table-per-difference, + and table-per-class. With the table-per-hierarchy + mapping, all the classes in a hierarchy are stored in a single, + "wide" table. NULL values are stored in columns + corresponding to data members of derived classes that are + not present in any particular instance.

+ +

In the table-per-difference mapping, each class is mapped + to a separate table. For a derived class, this table contains + only columns corresponding to the data members added by this + derived class.

+ +

Finally, in the table-per-class mapping, each class is mapped + to a separate table. For a derived class, this table contains + columns corresponding to all the data members, from this derived + class all the way down to the root of the hierarchy.

+ +

The table-per-difference mapping is generally considered as + having the best balance of flexibility, performance, and space + efficiency. It also results in a more canonical relational + database model compared to the other two approaches. As a + result, this is the mapping currently implemented in ODB. + Other mappings may be supported in the future.

+ +

A pointer or reference to an ordinary, non-polymorphic object + has just one type — the class type of that object. When we + start working with polymorphic objects, there are two types + to consider: the static type, or the declaration type + of a reference or pointer, and the object's actual or dynamic + type. An example will help illustrate the difference:

+ + 
+class person {...};
+class employee: public person {...};
+
+person p;
+employee e;
+
+person& r1 (p);
+person& r2 (e);
+
+auto_ptr<person> p1 (new employee);
+
+ +

In the above example, the r1 reference's both static + and dynamic types are person. + In contrast, the r2 reference's static type is + person while its dynamic type (the actual object + that it refers to) is employee. Similarly, + p1 points to the object of the person + static type but employee dynamic type.

+ +

In C++, the primary mechanisms for working with polymorphic objects + are virtual functions. We call a virtual function only knowing the + object's static type, but the version corresponding to the object's + dynamic type is automatically executed. This is the essence of + runtime polymorphism support in C++: we can operate in terms of a base + class interface but get the derived class' behavior. Similarly, the + essence of the runtime polymorphism support in ODB is to allow us to + persist, load, update, and query in terms of the base class interface + but have the derived class actually stored in the database.

+ +

To declare a persistent class as polymorphic we use the + db polymorphic pragma. We only need to + declare the root class of a hierarchy as polymorphic; ODB will + treat all the derived classes as polymorphic automatically. For + example:

+ + 
+#pragma db object polymorphic
+class person
+{
+  ...
+
+  virtual
+  ~person () = 0; // Automatically abstract.
+
+  #pragma db id auto
+  unsigned long id_;
+
+  std::string first_;
+  std::string last_;
+};
+
+#pragma db object
+class employee: public person
+{
+  ...
+
+  bool temporary_;
+};
+
+#pragma db object
+class contractor: public person
+{
+
+  std::string email_;
+};
+
+ +

A persistent class hierarchy declared polymorphic must also be + polymorphic in the C++ sense, that is, the root class must + declare or inherit at least one virtual function. It is + recommended that the root class also declares a virtual destructor. + The root class of the polymorphic hierarchy must contain + the data member designated as object id (a persistent class + without an object id cannot be polymorphic). Note also that, + unlike reuse inheritance, abstract polymorphic classes have + a table in the database, just like non-abstract classes.

+ +

Persistent classes in the same polymorphic hierarchy must use the + same kind of object pointer (Section 3.3, + "Object and View Pointers"). If the object pointer + for the root class is specified as a template or using the + special raw pointer syntax (*), then the ODB + compiler will automatically use the same object pointer + for all the derived classes. For example:

+ + 
+#pragma db object polymorphic pointer(std::shared_ptr)
+class person
+{
+  ...
+};
+
+#pragma db object // Object pointer is std::shared_ptr<employee>.
+class employee: public person
+{
+  ...
+};
+
+#pragma db object // Object pointer is std::shared_ptr<contractor>.
+class contractor: public person
+{
+  ...
+};
+
+ +

Similarly, if we enable or disable session support + (Chapter 11, "Session") for the root class, then + the ODB compiler will automatically enable or disable it for all + the derived classes.

+ +

For polymorphic persistent classes, all the database operations can + be performed on objects with different static and dynamic types. + Similarly, operations that load persistent objects from the + database (load(), query(), etc.), can + return objects with different static and dynamic types. For + example:

+ + 
+unsigned long id1, id2;
+
+// Persist.
+//
+{
+  shared_ptr<person> p1 (new employee (...));
+  shared_ptr<person> p2 (new contractor (...));
+
+  transaction t (db.begin ());
+  id1 = db.persist (p1); // Stores employee.
+  id2 = db.persist (p2); // Stores contractor.
+  t.commit ();
+}
+
+// Load.
+//
+{
+  shared_ptr<person> p;
+
+  transaction t (db.begin ());
+  p = db.load<person> (id1); // Loads employee.
+  p = db.load<person> (id2); // Loads contractor.
+  t.commit ();
+}
+
+// Query.
+//
+{
+  typedef odb::query<person> query;
+  typedef odb::result<person> result;
+
+  transaction t (db.begin ());
+
+  result r (db.query<person> (query::last == "Doe"));
+
+  for (result::iterator i (r.begin ()); i != r.end (); ++i)
+  {
+    person& p (*i); // Can be employee or contractor.
+  }
+
+  t.commit ();
+}
+
+// Update.
+//
+{
+  shared_ptr<person> p;
+  shared_ptr<employee> e;
+
+  transaction t (db.begin ());
+
+  e = db.load<employee> (id1);
+  e->temporary (false);
+  p = e;
+  db.update (p); // Updates employee.
+
+  t.commit ();
+}
+
+// Erase.
+//
+{
+  shared_ptr<person> p;
+
+  transaction t (db.begin ());
+  p = db.load<person> (id1); // Loads employee.
+  db.erase (p);              // Erases employee.
+  db.erase<person> (id2);    // Erases contractor.
+  t.commit ();
+}
+
+ + +

The table-per-difference mapping, as supported by ODB, requires + two extra columns, in addition to those corresponding to the + data members. The first, called discriminator, is added + to the table corresponding to the root class of the hierarchy. + This column is used to determine the dynamic type of each + object. The second column is added to tables corresponding + to the derived classes and contains the object id. This + column is used to form a foreign key constraint referencing + the root class table.

+ +

When querying the database for polymorphic objects, it is + possible to obtain the discriminator value without + instantiating the object. For example:

+ + 
+typedef odb::query<person> query;
+typedef odb::result<person> result;
+
+transaction t (db.begin ());
+
+result r (db.query<person> (query::last == "Doe"));
+
+for (result::iterator i (r.begin ()); i != r.end (); ++i)
+{
+  std::string d (i.discriminator ());
+  ...
+}
+
+t.commit ();
+
+ +

In the current implementation, ODB has limited support for + customizing names, types, and values of the extra columns. + Currently, the discriminator column is always called + typeid and contains a namespace-qualified class + name (for example, "employee" or + "hr::employee"). The id column in the derived + class table has the same name as the object id column in + the root class table. Future versions of ODB will add support + for customizing these extra columns.

+ +

The sample database schema for the above polymorphic hierarchy + is shown below.

+ + 
+CREATE TABLE person (
+  id BIGINT UNSIGNED NOT NULL PRIMARY KEY AUTO_INCREMENT,
+  typeid VARCHAR(255) NOT NULL,
+  first TEXT NOT NULL,
+  last TEXT NOT NULL);
+
+CREATE TABLE employee (
+  id BIGINT UNSIGNED NOT NULL PRIMARY KEY,
+  temporary TINYINT(1) NOT NULL,
+
+  CONSTRAINT employee_id_fk
+    FOREIGN KEY (id)
+    REFERENCES person (id)
+    ON DELETE CASCADE);
+
+CREATE TABLE contractor (
+  id BIGINT UNSIGNED NOT NULL PRIMARY KEY,
+  email TEXT NOT NULL,
+
+  CONSTRAINT contractor_id_fk
+    FOREIGN KEY (id)
+    REFERENCES person (id)
+    ON DELETE CASCADE);
+
+ +

The complete version of the code presented in this section is + available in the inheritance/polymorphism example + in the odb-examples package.

+ +

8.2.1 Performance and Limitations

+ +

A database operation on a non-polymorphic object normally translates + to a single database statement execution (objects with containers + and eager object pointers can be the exception). Because polymorphic + objects have their data members + stored in multiple tables, some database operations on such objects + may result in multiple database statements being executed while others + may require more complex statements. There is also some functionality + that is not available to polymorphic objects.

+ +

The first part of this section discusses the performance implications + to keep in mind when designing and working with polymorphic hierarchies. + The second part talks about limitations of polymorphic objects.

+ +

The most important aspect of a polymorphic hierarchy that + affects database performance is its depth. The distance between + the root of the hierarchy and the derived class translates + directly to the number of database statements that will have to + be executed in order to persist, update, or erase this derived class. + It also translates directly to the number of SQL JOIN + clauses that will be needed to load or query the database for this + derived class. As a result, to achieve best performance, we should + try to keep our polymorphic hierarchies as flat as possible.

+ +

When loading an object or querying the database for objects, + ODB will need to execute two statements if this object's static + and dynamic types are different but only one statement if + they are the same. This example will help illustrate the + difference:

+ + 
+unsigned long id;
+
+{
+  employee e (...);
+
+  transaction t (db.begin ());
+  id = db.persist (e);
+  t.commit ();
+}
+
+{
+  shared_ptr<person> p;
+
+  transaction t (db.begin ());
+  p = db.load<person> (id);   // Requires two statement.
+  p = db.load<employee> (id); // Requires only one statement.
+  t.commit ();
+}
+
+ +

As a result, we should try to load and query using the most + derived class possible.

+ +

Finally, for polymorphic objects, erasing via the object instance + is faster than erasing via its object id. In the former case the + object's dynamic type can be determined locally in the application + while in the latter case an extra statement has to be executed to + achieve the same result. For example:

+ + 
+shared_ptr<person> p = ...;
+
+transaction t (db.begin ());
+db.erase<person> (p.id ()); // Slower (executes extra statement).
+db.erase (p);               // Faster.
+t.commit ();
+
+ +

Polymorphic objects can use all the mechanisms that are available + to ordinary objects. These include containers (Chapter 5, + "Containers"), object relationships, including to polymorphic + objects (Chapter 6, "Relationships"), views + (Chapter 10, "Views"), session (Chapter + 11, "Session"), and optimistic concurrency (Chapter + 12, "Optimistic Concurrency"). There are, however, a few + limitations, mainly due to the underlying use of SQL to access the + data.

+ +

When a polymorphic object is "joined" in a view, and the join + condition (either in the form of an object pointer or a custom + condition) comes from the object itself (as opposed to one of + the objects joined previously), then this condition must only + use data members from the derived class. For example, consider + the following polymorphic object hierarchy and a view:

+ + + 
+#pragma db object polymorphic
+class employee
+{
+  ...
+};
+
+#pragma db object
+class permanent_employee: public employee
+{
+  ...
+};
+
+#pragma db object
+class temporary_employee: public employee
+{
+  ...
+
+  shared_ptr<permanent_employee> manager_;
+};
+
+#pragma db object
+class contractor: public temporary_employee
+{
+  shared_ptr<permanent_employee> manager_;
+};
+
+#pragma db view object(permanent_employee) \
+                object(contractor: contractor::manager_)
+struct contractor_manager
+{
+  ...
+};
+
+ +

This view will not function correctly because the join condition + (manager_) comes from the base class + (temporary_employee) instead of the derived + (contractor). The reason for this limitation is the + JOIN clause order in the underlying SQL SELECT + statement. In the view presented above, the table corresponding + to the base class (temporary_employee) will have to + be joined first which will result in this view matching both + the temporary_employee and contractor + objects instead of just contractor. It is usually + possible to resolve this issue by reordering the objects in the + view. Our example, for instance, can be fixed by swapping the + two objects:

+ + 
+#pragma db view object(contractor) \
+                object(permanent_employee: contractor::manager_)
+struct contractor_manager
+{
+  ...
+};
+
+ +

The erase_query() database function (Section + 3.11, "Deleting Persistent Objects") also has limited functionality + when used on polymorphic objects. Because many database implementations + do not support JOIN clauses in the SQL DELETE + statement, only data members from the derived class being erased can + be used in the query condition. For example:

+ + 
+typedef odb::query<employee> query;
+
+transaction t (db.begin ());
+db.erase_query<employee> (query::permanent);     // Ok.
+db.erase_query<employee> (query::last == "Doe"); // Error.
+t.commit ();
+
+ +

8.3 Mixed Inheritance

+ +

It is possible to mix the reuse and polymorphism inheritance + styles in the same hierarchy. In this case, the reuse inheritance + must be used for the "bottom" (base) part of the hierarchy while + the polymorphism inheritance — for the "top" (derived) part. + For example:

+ + 
+#pragma db object
+class person
+{
+  ...
+};
+
+#pragma db object polymorphic
+class employee: public person // Reuse inheritance.
+{
+  ...
+};
+
+#pragma db object
+class temporary_employee: public employee // Polymorphism inheritance.
+{
+  ...
+};
+
+#pragma db object
+class permanent_employee: public employee // Polymorphism inheritance.
+{
+  ...
+};
+
+ + + + + +
+

9 Sections

+ +

ODB sections are an optimization mechanism that allows us to + partition data members of a persistent class into groups that + can be separately loaded and/or updated. This can be useful, + for example, if an object contains expensive to load or update + data members (such as BLOBs or containers) and + that are accessed or modified infrequently. For example:

+ + 
+#include <odb/section.hxx>
+
+#pragma db object
+class person
+{
+  ...
+
+  #pragma db load(lazy) update(manual)
+  odb::section keys_;
+
+  #pragma db section(keys_) type("BLOB")
+  char public_key_[1024];
+
+  #pragma db section(keys_) type("BLOB")
+  char private_key_[1024];
+};
+
+transaction t (db.begin ());
+
+auto_ptr<person> p (db.load<person> (...)); // Keys are not loaded.
+
+if (need_keys)
+{
+  db.load (*p, p->keys_); // Load keys.
+  ...
+}
+
+db.update (*p); // Keys are not updated.
+
+if (update_keys)
+{
+  ...
+  db.update (*p, p->keys_); // Update keys.
+}
+
+t.commit ();
+
+ +

A complete example that shows how to use sections is available in + the section directory in the odb-examples + package.

+ +

Why do we need to group data members into sections? Why can't + each data member be loaded and updated independently if and + when necessary? The reason for this requirement is that loading + or updating a group of data members with a single database + statement is significantly more efficient than loading or updating + each data member with a separate statement. Because ODB + prepares and caches statements used to load and update + persistent objects, generating a custom statement for + a specific set of data members that need to be loaded or + updated together is not a viable approach either. To resolve + this, ODB allows us to group data members that are + often updated and/or loaded together into sections. To + achieve the best performance, we should aim to find a balance + between having too many sections with too few data + members and too few sections with too many data + members. We can use the access and modification patterns + of our application as a base for this decision.

+ +

To add a new section to a persistent class we declare a new + data member of the odb::section type. At this + point we also need to specify the loading and updating behavior + of this section with the db load and + db update pragmas, respectively.

+ +

The loading behavior of a section can be either eager + or lazy. An eager-loaded section is always loaded as + part of the object load. A lazy-loaded section is not loaded + as part of the object load and has to be explicitly loaded with + the database::load() function (discussed below) if + and when necessary.

+ +

The updating behavior of a section can be always, + change, or manual. An always-updated + section is always updated as part of the object update, + provided it has been loaded. A change-updated section + is only updated as part of the object update if it has been loaded + and marked as changed. A manually-updated section is never updated + as part of the object update and has to be explicitly updated with + the database::update() function (discussed below) if + and when necessary.

+ +

If no loading behavior is specified explicitly, then an eager-loaded + section is assumed. Similarly, if no updating behavior is specified, + then an always-updated section is assumed. An eager-loaded, always-updated + section is pointless and therefore illegal. Only persistent classes + with an object id can have sections.

+ +

To specify that a data member belongs to a section we use the + db section pragma with the section's member + name as its single argument. Except for special data members + such as the object id and optimistic concurrency version, any + direct, non-transient member of a persistent class can belong + to a section, including composite values, containers, and + pointers to objects. For example:

+ + 
+#pragma db value
+class text
+{
+  std::string data;
+  std::string lang;
+};
+
+#pragma db object
+class person
+{
+  ...
+
+  #pragma db load(lazy)
+  odb::section extras_;
+
+  #pragma db section(extras_)
+  text bio_;
+
+  #pragma db section(extras_)
+  std::vector<std::string> nicknames_;
+
+  #pragma db section(extras_)
+  std::shared_ptr<person> emergency_contact_;
+};
+
+ +

An empty section is pointless and therefore illegal, except + in abstract or polymorphic classes where data members can be + added to a section by derived classes (see Section + 9.1, "Sections and Inheritance").

+ +

The odb::section class is defined in the + <odb/section.hxx> header file and has the + following interface:

+ + 
+namespace odb
+{
+  class section
+  {
+  public:
+    // Load state.
+    //
+    bool
+    loaded () const;
+
+    void
+    unload ();
+
+    // Change state.
+    //
+    bool
+    changed () const;
+
+    void
+    change ();
+
+    // User data.
+    //
+    unsigned char
+    user_data () const;
+
+    void
+    user_data (unsigned char);
+  };
+}
+
+ +

The loaded() accessor can be used to determine + whether a section is already loaded. The unload() + modifier marks a loaded section as not loaded. This, for example, + can be useful if you don't want the section to be reloaded during + the object reload.

+ +

The changed() accessor can be used to query the + section's change state. The change() modifier + marks the section as changed. It is valid to call this modifier + for an unloaded (or transient) section, however, the state will + be reset back to unchanged once the section (or object) is loaded. + The change state is only relevant to sections with change-updated + behavior and is ignored for all other sections.

+ +

The size of the section class is one byte with four bits available + to store a custom state via the user_data() accessor + and modifier.

+ +

The odb::database class provides special + versions of the load() and update() + functions that allow us to load and update sections of a + persistent class. Their signatures are as follows:

+ + 
+  template <typename T>
+  void
+  load (T& object, section&);
+
+  template <typename T>
+  void
+  update (const T& object, const section&);
+
+ +

Before calling the section load() function, the + object itself must already be loaded. If the section is already + loaded, then the call to load() will reload its + data members. It is illegal to explicitly load an eager-loaded + section.

+ +

Before calling the section update() function, the + section (and therefore the object) must be in the loaded state. + If the section is not loaded, the odb::section_not_loaded + exception is thrown. The section update() function + does not check but does clear the section's change state. In + other words, section update() will always update + section data members in the database and clear the change flag. + Note also that any section, that is, always-, change-, or + manually-updated, can be explicitly updated with this function.

+ +

Both section load() and update(), just + like the rest of the database operations, must be performed within + a transaction. Notice also that both load() and + update() expect a reference to the section as + their second argument. This reference must refer to the data + member in the object passed as the first argument. If instead + it refers to some other instance of the section + class, for example, a local copy or a temporary, then the + odb::section_not_in_object exception is thrown. + For example:

+ + 
+#pragma db object
+class person
+{
+public:
+  ...
+
+  odb::section
+  keys () const {return keys_;}
+
+private:
+  odb::section keys_;
+
+  ...
+};
+
+auto_ptr<person> p (db.load<person> (...));
+
+section s (p->keys ());
+db.load (*p, s);            // Throw section_not_in_object, copy.
+
+db.update (*p, p->keys ()); // Throw section_not_in_object, copy.
+
+ +

At first glance it may seem more appropriate to make the + section class non-copyable in order to prevent + such errors from happening. However, it is perfectly reasonable + to expect to be able to copy (or assign) sections as part of + the object copying (or assignment). As a result, sections are + left copyable and copy-assignable, however, this functionality + should not be used in accessors or modifiers. Instead, section + accessors and modifiers should always be by-reference. Here is + how we can fix our previous example:

+ +
+#pragma db object
+class person
+{
+public:
+  ...
+
+  const odb::section&
+  keys () const {return keys_;}
+
+  odb::section&
+  keys () {return keys_;}
+
+private:
+  odb::section keys_;
+
+  ...
+};
+
+auto_ptr<person> p (db.load<person> (...));
+
+section& s (p->keys ());
+db.load (*p, s);            // Ok, reference.
+
+db.update (*p, p->keys ()); // Ok, reference.
+
+ +

Several other database operations affect sections. The state of + a section in a transient object is undefined. That is, before + the call to object persist() or load() + functions, or after the call to object erase() + function, the values returned by the section::loaded() and + section::changed() accessors are undefined.

+ +

After the call to persist(), all sections, including + eager-loaded ones, are marked as loaded and unchanged. If instead we + are loading an object with the load() call or as + a result of a query, then eager-loaded sections are loaded + and marked as loaded and unchanged while lazy-loaded ones are marked + as unloaded. If a lazy-loaded section is later loaded with the + section load() call, then it is marked as loaded and + unchanged.

+ +

When we update an object with the update() call, + manually-updated sections are ignored while always-updated + sections are updated if they are loaded. Change-updated + sections are only updated if they are both loaded and marked + as changed. After the update, such sections are reset to the + unchanged state. When we reload an object with the + reload() call, sections that were loaded are + automatically reloaded and reset to the unchanged state.

+ +

To further illustrate the state transitions of a section, + consider this example:

+ + 
+#pragma db object
+class person
+{
+  ...
+
+  #pragma db load(lazy) update(change)
+  odb::section keys_;
+
+  ...
+};
+
+transaction t (db.begin ());
+
+person p ("John", "Doe"); // Section state is undefined (transient).
+
+db.persist (p);           // Section state: loaded, unchanged.
+
+auto_ptr<person> l (
+  db.load<person> (...)); // Section state: unloaded, unchanged.
+
+db.update (*l);           // Section not updated since not loaded.
+db.update (p);            // Section not updated since not changed.
+
+p.keys_.change ();        // Section state: loaded, changed.
+db.update (p);            // Section updated, state: loaded, unchanged.
+
+db.update (*l, l->keys_); // Throw section_not_loaded.
+db.update (p, p.keys_);   // Section updated even though not changed.
+
+db.reload (*l);           // Section not reloaded since not loaded.
+db.reload (p);            // Section reloaded, state: loaded, unchanged.
+
+db.load (*l, l->keys_);   // Section loaded, state: loaded, unchanged.
+db.load (p, p.keys_);     // Section reloaded, state: loaded, unchanged.
+
+db.erase (p);             // Section state is undefined (transient).
+
+t.commit ();
+
+ +

When using change-updated behavior, it is our responsibility to + mark the section as changed when any of the data members belonging + to this section is modified. A natural place to mark the section + as changed is the modifiers for section data members, for example:

+ + 
+#pragma db object
+class person
+{
+  ...
+
+  typedef std::array<char, 1024> key_type;
+
+  const key_type&
+  public_key () const {return public_key_;}
+
+  void
+  public_key (const key_type& k)
+  {
+    public_key_ = k;
+    keys_.change ();
+  }
+
+  const key_type&
+  private_key () const {return private_key_;}
+
+  void
+  private_key (const key_type& k)
+  {
+    private_key_ = k;
+    keys_.change ();
+  }
+
+private:
+  #pragma db load(lazy) update(change)
+  odb::section keys_;
+
+  #pragma db section(keys_) type("BLOB")
+  key_type public_key_;
+
+  #pragma db section(keys_) type("BLOB")
+  key_type private_key_;
+
+  ...
+};
+
+ +

One interesting aspect of change-updated sections is what happens + when a transaction that performed an object or section update is + later rolled back. In this case, while the change state of a + section has been reset (after update), actual changes were not + committed to the database. Change-updated sections handle this + case by automatically registering a rollback callback and then, + if it is called, restoring the original change state. The + following code illustrates this semantics (continuing with + the previous example):

+ + 
+auto_ptr<person> p;
+
+try
+{
+  transaction t (db.begin ());
+  p = db.load<person> (...);
+  db.load (*p, p->keys_);
+
+  p->private_key (new_key); // The section is marked changed.
+  db.update (*p);           // The section is reset to unchanged.
+
+  throw failed ();          // Triggers rollback.
+  t.commit ();
+}
+catch (const failed&)
+{
+  // The section is restored back to changed.
+}
+
+ + +

9.1 Sections and Inheritance

+ +

With both reuse and polymorphism inheritance (Chapter 8, + "Inheritance") it is possible to add new sections to derived + classes. It is also possible to add data members from derived + classes to sections declared in the base. For example:

+ + 
+#pragma db object polymorphic
+class person
+{
+  ...
+
+  virtual void
+  print ();
+
+  #pragma db load(lazy)
+  odb::section print_;
+
+  #pragma db section(print_)
+  std::string bio_;
+};
+
+#pragma db object
+class employee: public person
+{
+  ...
+
+  virtual void
+  print ();
+
+  #pragma db section(print_)
+  std::vector<std::string> employment_history_;
+};
+
+transaction t (db.begin ());
+
+auto_ptr<person> p (db.load<person> (...)); // Person or employee.
+db.load (*p, p->print_); // Load data members needed for print.
+p->print ();
+
+t.commit ();
+
+ +

When data members of a section are spread over several classes in a + reuse inheritance hierarchy, both section load and update are + performed with a single database statement. In contrast, with + polymorphism inheritance, section load is performed with a + single statement while update requires a separate statement + for each class that adds to the section.

+ +

Note also that in polymorphism inheritance the section-to-object + association is static. Or, in other words, you can load a section + via an object only if its static type actually contains this + section. The following example will help illustrate this + point further:

+ + 
+#pragma db object polymorphic
+class person
+{
+  ...
+};
+
+#pragma db object
+class employee: public person
+{
+  ...
+
+  #pragma db load(lazy)
+  odb::section extras_;
+
+  ...
+};
+
+#pragma db object
+class manager: public employee
+{
+  ...
+};
+
+auto_ptr<manager> m (db.load<manager> (...));
+
+person& p (*m);
+employee& e (*m);
+section& s (m->extras_);
+
+db.load (p, s); // Error: extras_ is not in person.
+db.load (e, s); // Ok: extras_ is in employee.
+
+ +

9.2 Sections and Optimistic Concurrency

+ +

When sections are used in a class with the optimistic concurrency + model (Chapter 12, "Optimistic Concurrency"), + both section update and load operations compare the object version + to that in the database and throw the odb::object_changed + exception if they do not match. In addition, the section update + operation increments the version to indicate that the object state + has changed. For example:

+ + 
+#pragma db object optimistic
+class person
+{
+  ...
+
+  #pragma db version
+  unsigned long long version_;
+
+  #pragma db load(lazy)
+  odb::section extras_;
+
+  #pragma db section(extras_)
+  std::string bio_;
+};
+
+auto_ptr<person> p;
+
+{
+  transaction t (db.begin ());
+  p = db.load<person> (...);
+  t.commit ();
+}
+
+{
+  transaction t (db.begin ());
+
+  try
+  {
+    db.load (*p, p->extras_); // Throws if object state has changed.
+  }
+  catch (const object_changed&)
+  {
+    db.reload (*p);
+    db.load (*p, p->extras_); // Cannot fail.
+  }
+
+  t.commit ();
+}
+
+ +

Note also that if an object update triggers one or more + section updates, then each such update will increment the + object version. As a result, an update of an object that + contains sections may result in a version increment by + more than one.

+ +

When sections are used together with optimistic concurrency and + inheritance, an extra step may be required to enable this + functionality. If you plan to add new sections to derived + classes, then the root class of the hierarchy + (the one that declares the version data member) must be + declared as sectionable with the db sectionable + pragma. For example:

+ + 
+#pragma db object polymorphic sectionable
+class person
+{
+  ...
+
+  #pragma db version
+  unsigned long long version_;
+};
+
+#pragma db object
+class employee: public person
+{
+  ...
+
+  #pragma db load(lazy)
+  odb::section extras_;
+
+  #pragma db section(extras_)
+  std::vector<std::string> employment_history_;
+};
+
+ +

This requirement has to do with the need to generate extra + version increment code in the root class that will be used + by sections added in the derived classes. If you forget to + declare the root class as sectionable and later add a + section to one of the derived classes, the ODB compiler + will issue diagnostics.

+ +

9.3 Sections and Lazy Pointers

+ +

If a lazy pointer (Section 6.4, "Lazy Pointers") + belongs to a lazy-loaded section, then we end up with two levels of + lazy loading. Specifically, when the section is loaded, the lazy + pointer is initialized with the object id but the object itself + is not loaded. For example:

+ + 
+#pragma db object
+class employee
+{
+  ...
+
+  #pragma db load(lazy)
+  odb::section extras_;
+
+  #pragma db section(extras_)
+  odb::lazy_shared_ptr<employer> employer_;
+};
+
+transaction t (db.begin ());
+
+auto_ptr<employee> e (db.load<employee> (...)); // employer_ is NULL.
+
+db.load (*e, e->extras_); // employer_ contains valid employer id.
+
+e->employer_.load (); // employer_ points to employer object.
+
+t.commit ();
+
+ +

9.4 Sections and Change-Tracking Containers

+ +

If a change-tracking container (Section 5.4, + "Change-Tracking Containers") belongs to a change-updated + section, then prior to an object update ODB will check if the + container has been changed and if so, automatically mark the + section as changed. For example:

+ +
+#pragma db object
+class person
+{
+  ...
+
+  #pragma db load(lazy) update(change)
+  odb::section extras_;
+
+  #pragma db section(extras_)
+  odb::vector<std::string> nicknames_;
+};
+
+transaction t (db.begin ());
+
+auto_ptr<person> p (db.load<person> (...));
+db.load (*p, p->extras_);
+
+p->nicknames_.push_back ("JD");
+
+db.update (*p); // Section is automatically updated even
+                // though it was not marked as changed.
+t.commit ();
+
+ + + + + +
+

10 Views

+ +

An ODB view is a C++ class or struct type + that embodies a light-weight, read-only projection of one or more + persistent objects or database tables or the result of a native SQL + query execution.

+ +

Some of the common applications of views include loading a subset + of data members from objects or columns from database tables, executing + and handling results of arbitrary SQL queries, including aggregate + queries and stored procedure calls, as well as joining multiple + objects and/or database tables using object relationships or custom + join conditions.

+ +

Many relational databases also define the concept of views. Note, + however, that ODB views are not mapped to database views. Rather, + by default, an ODB view is mapped to an SQL SELECT + query. However, if desired, it is easy to create an ODB view + that is based on a database view.

+ +

Usually, views are defined in terms of other persistent entities, + such as persistent objects, database tables, sequences, etc. + Therefore, before we can examine our first view, we need to + define a few persistent objects and a database table. We will + use this model in examples throughout this chapter. Here we + assume that you are familiar with ODB object relationship + support (Chapter 6, "Relationships").

+ + 
+#pragma db object
+class country
+{
+  ...
+
+  #pragma db id
+  std::string code_; // ISO 2-letter country code.
+
+  std::string name_;
+};
+
+#pragma db object
+class employer
+{
+  ...
+
+  #pragma db id
+  unsigned long id_;
+
+  std::string name_;
+};
+
+#pragma db object
+class employee
+{
+  ...
+
+  #pragma db id
+  unsigned long id_;
+
+  std::string first_;
+  std::string last_;
+
+  unsigned short age_;
+
+  shared_ptr<country> residence_;
+  shared_ptr<country> nationality_;
+
+  shared_ptr<employer> employed_by_;
+};
+
+ +

Besides these objects, we also have the legacy + employee_extra table that is not mapped to any persistent + class. It has the following definition:

+ + 
+CREATE TABLE employee_extra(
+  employee_id INTEGER NOT NULL,
+  vacation_days INTEGER NOT NULL,
+  previous_employer_id INTEGER)
+
+ +

The above persistent objects and database table as well as many of + the views shown in this chapter are based on the + view example which can be found in the + odb-examples package of the ODB distribution.

+ +

To declare a view we use the db view pragma, + for example:

+ + 
+#pragma db view object(employee)
+struct employee_name
+{
+  std::string first;
+  std::string last;
+};
+
+ +

The above example shows one of the simplest views that we can create. + It has a single associated object (employee) and its + purpose is to extract the employee's first and last names without + loading any other data, such as the referenced country + and employer objects.

+ +

Views use the same query facility (Chapter 4, "Querying + the Database") as persistent objects. Because support for queries + is optional and views cannot be used without this support, you need + to compile any header that defines a view with the + --generate-query ODB compiler option.

+ +

To query the database for a view we use the + database::query(), database::query_one(), or + database::query_value() functions in exactly the same way + as we would use them to query the database for an object. For example, + the following code fragment shows how we can find the names of all the + employees that are younger than 31:

+ + 
+typedef odb::query<employee_name> query;
+typedef odb::result<employee_name> result;
+
+transaction t (db.begin ());
+
+result r (db.query<employee_name> (query::age < 31));
+
+for (result::iterator i (r.begin ()); i != r.end (); ++i)
+{
+  const employee_name& en (*i);
+  cout << en.first << " " << en.last << endl;
+}
+
+t.commit ();
+
+ +

A view can be defined as a projection of one or more objects, one + or more tables, a combination of objects and tables, or it can be + the result of a custom SQL query. The following sections discuss each + of these kinds of view in more detail.

+ +

10.1 Object Views

+ +

To associate one or more objects with a view we use the + db object pragma (Section + 14.2.1, "object"). We have already seen + a simple, single-object view in the introduction to this chapter. + To associate the second and subsequent objects we repeat the + db object pragma for each additional object, + for example:

+ + 
+#pragma db view object(employee) object(employer)
+struct employee_employer
+{
+  std::string first;
+  std::string last;
+  std::string name;
+};
+
+ +

The complete syntax of the db object pragma is + shown below:

+ +

object(name + [= alias] + [join-type] + [: join-condition])

+ +

The name part is a potentially qualified persistent class + name that has been defined previously. The optional alias + part gives this object an alias. If provided, the alias is used + in several contexts instead of the object's unqualified name. We + will discuss aliases further as we cover each of these contexts + below. The optional join-type part specifies the way this + object is associated. It can be left, right, + full, inner, and cross + with left being the default. + Finally, the optional join-condition part provides the + criteria which should be used to associate this object with any + of the previously associated objects or, as we will see in + Section 10.4, "Mixed Views", tables. Note that + while the first associated object can have an alias, it cannot + have a join type or condition.

+ +

For each subsequent associated object the ODB compiler needs + a join condition and there are several ways to specify + it. The easiest way is to omit it altogether and let the ODB + compiler try to come up with a join condition automatically. + To do this the ODB compiler will examine each previously + associated object for object relationships + (Chapter 6, "Relationships") that + may exist between these objects and the object being associated. + If such a relationship exists and is unambiguous, that is + there is only one such relationship, then the ODB compiler + will automatically use it to come up with the join condition for + this object. This is exactly what happens in the previous + example: there is a single relationship + (employee::employed_by) between the + employee and employer objects.

+ +

On the other hand, consider this view:

+ + 
+#pragma db view object(employee) object(country)
+struct employee_residence
+{
+  std::string first;
+  std::string last;
+  std::string name;
+};
+
+ +

While there is a relationship between country and + employee, it is ambiguous. It can be + employee::residence_ (which is what we want) or + it can be employee::nationality_ (which we don't + want). As result, when compiling the above view, the ODB + compiler will issue an error indicating an ambiguous object + relationship. To resolve this ambiguity, we can explicitly + specify the object relationship that should be used to create + the join condition as the name of the corresponding data member. + Here is how we can fix the employee_residence + view:

+ + 
+#pragma db view object(employee) object(country: employee::residence_)
+struct employee_residence
+{
+  std::string first;
+  std::string last;
+  std::string name;
+};
+
+ +

It is possible to associate the same object with a single view + more than once using different join conditions. However, in + this case, we have to use aliases to assign different names + for each association. For example:

+ + 
+#pragma db view object(employee) \
+  object(country = res_country: employee::residence_) \
+  object(country = nat_country: employee::nationality_)
+struct employee_country
+{
+  ...
+};
+
+ +

Note that correctly defining data members in this view requires + the use of a mechanism that we haven't yet covered. We will + see how to do this shortly.

+ +

If we assign an alias to an object and refer to a data member of + this object in one of the join conditions, we have to use the + unqualified alias name instead of the potentially qualified + object name. For example:

+ + 
+#pragma db view object(employee = ee) object(country: ee::residence_)
+struct employee_residence
+{
+  ...
+};
+
+ +

The last way to specify a join condition is to provide a custom + query expression. This method is primarily useful if you would + like to associate an object using a condition that does not + involve an object relationship. Consider, for example, a + modified employee object from the beginning of + the chapter with an added country of birth member. For one + reason or another we have decided not to use a relationship to + the country object, as we have done with + residence and nationality.

+ + 
+#pragma db object
+class employee
+{
+  ...
+
+  std::string birth_place_; // Country name.
+};
+
+ +

If we now want to create a view that returns the birth country code + for an employee, then we have to use a custom join condition when + associating the country object. For example:

+ + 
+#pragma db view object(employee) \
+  object(country: employee::birth_place_ == country::name_)
+struct employee_birth_code
+{
+  std::string first;
+  std::string last;
+  std::string code;
+};
+
+ +

The syntax of the query expression in custom join conditions + is the same as in the query facility used to query the database + for objects (Chapter 4, "Querying the Database") + except that for query members, instead of using + odb::query<object>::member names, we refer directly + to object members.

+ +

Looking at the views we have defined so far, you may be wondering + how the ODB compiler knows which view data members correspond to which + object data members. While the names are similar, they are not exactly + the same, for example employee_name::first and + employee::first_.

+ +

As with join conditions, when it comes to associating data members, + the ODB compiler tries to do this automatically. It first searches + all the associated objects for an exact name match. If no match is + found, then the ODB compiler compares the so-called public names. + A public name of a member is obtained by removing the common member + name decorations, such as leading and trailing underscores, the + m_ prefix, etc. In both of these searches the ODB + compiler also makes sure that the types of the two members are the + same or compatible.

+ +

If one of the above searches returned a match and it is unambiguous, that + is there is only one match, then the ODB compiler will automatically + associate the two members. On the other hand, if no match is found + or the match is ambiguous, the ODB compiler will issue an error. + To associate two differently-named members or to resolve an ambiguity, + we can explicitly specify the member association using the + db column pragma (Section 14.4.9, + "column"). For example:

+ + 
+#pragma db view object(employee) object(employer)
+struct employee_employer
+{
+  std::string first;
+  std::string last;
+
+  #pragma db column(employer::name_)
+  std::string employer_name;
+};
+
+ +

If an object data member specifies the SQL type with + the db type pragma (Section + 14.4.3, "type"), then this type is also used for + the associated view data members.

+ +

Note also that similar to join conditions, if we assign an alias to + an object and refer to a data member of this object in one of the + db column pragmas, then we have to use the + unqualified alias name instead of the potentially qualified + object name. For example:

+ + 
+#pragma db view object(employee) \
+  object(country = res_country: employee::residence_) \
+  object(country = nat_country: employee::nationality_)
+struct employee_country
+{
+  std::string first;
+  std::string last;
+
+  #pragma db column(res_country::name_)
+  std::string res_country_name;
+
+  #pragma db column(nat_country::name_)
+  std::string nat_country_name;
+};
+
+ +

Besides specifying just the object member, we can also specify a + +-expression in the db column pragma. A + +-expression consists of string literals and object + member references connected using the + operator. + It is primarily useful for defining aggregate views based on + SQL aggregate functions, for example:

+ + 
+#pragma db view object(employee)
+struct employee_count
+{
+  #pragma db column("count(" + employee::id_ + ")")
+  std::size_t count;
+};
+
+ +

When querying the database for a view, we may want to provide + additional query criteria based on the objects associated with + this view. To support this a view defines query members for all + the associated objects which allows us to refer to such objects' + members using the odb::query<view>::member expressions. + This is similar to how we can refer to object members using the + odb::query<object>::member expressions when + querying the database for an object. For example:

+ + 
+typedef odb::query<employee_count> query;
+
+transaction t (db.begin ());
+
+// Find the number of employees with the Doe last name. Result of this
+// aggregate query contains only one element so use the query_value()
+// shortcut function.
+//
+employee_count ec (
+  db.query_value<employee_count> (query::last == "Doe"));
+
+cout << ec.count << endl;
+
+t.commit ();
+
+ +

In the above query we used the last name data member from the associated + employee object to only count employees with the specific + name.

+ +

When a view has only one associated object, the query members + corresponding to this object are defined directly in the + odb::query<view> scope. For instance, + in the above example, we referred to the last name member as + odb::query<employee_count>::last. However, if + a view has multiple associated objects, then query members + corresponding to each such object are defined in a nested + scope named after the object. As an example, consider + the employee_employer view again:

+ + 
+#pragma db view object(employee) object(employer)
+struct employee_employer
+{
+  std::string first;
+  std::string last;
+
+  #pragma db column(employer::name_)
+  std::string employer_name;
+};
+
+ +

Now, to refer to the last name data member from the employee + object we use the + odb::query<...>::employee::last expression. + Similarly, to refer to the employer name, we use the + odb::query<...>::employer::name expression. + For example:

+ + 
+typedef odb::result<employee_employer> result;
+typedef odb::query<employee_employer> query;
+
+transaction t (db.begin ());
+
+result r (db.query<employee_employer> (
+  query::employee::last == "Doe" &&
+  query::employer::name == "Simple Tech Ltd"));
+
+for (result::iterator i (r.begin ()); i != r.end (); ++i)
+  cout << i->first << " " << i->last <<  " " << i->employer_name << endl;
+
+t.commit ();
+
+ +

If we assign an alias to an object, then this alias is used to + name the query members scope instead of the object name. As an + example, consider the employee_country view again:

+ + 
+#pragma db view object(employee) \
+  object(country = res_country: employee::residence_) \
+  object(country = nat_country: employee::nationality_)
+struct employee_country
+{
+  ...
+};
+
+ +

And a query which returns all the employees that have the same + country of residence and nationality:

+ + 
+typedef odb::query<employee_country> query;
+typedef odb::result<employee_country> result;
+
+transaction t (db.begin ());
+
+result r (db.query<employee_country> (
+  query::res_country::name == query::nat_country::name));
+
+for (result::iterator i (r.begin ()); i != r.end (); ++i)
+  cout << i->first << " " << i->last << " " << i->res_country_name << endl;
+
+t.commit ();
+
+ +

Note also that unlike object query members, view query members do + no support referencing members in related objects. For example, + the following query is invalid:

+ + 
+typedef odb::query<employee_name> query;
+typedef odb::result<employee_name> result;
+
+transaction t (db.begin ());
+
+result r (db.query<employee_name> (
+  query::employed_by->name == "Simple Tech Ltd"));
+
+t.commit ();
+
+ +

To get this behavior, we would instead need to associate the + employer object with this view and then use the + query::employer::name expression instead of + query::employed_by->name.

+ +

As we have discussed above, if specified, an object alias is + used instead of the object name in the join condition, data + member references in the db column pragma, + as well as to name the query members scope. The object alias + is also used as a table name alias in the underlying + SELECT statement generated by the ODB compiler. + Normally, you would not use the table alias directly with + object views. However, if for some reason you need to refer + to a table column directly, for example, as part of a native + query expression, and you need to qualify the column with + the table, then you will need to use the table alias instead.

+ +

10.2 Object Loading Views

+ +

A special variant of object views is object loading views. Object + loading views allow us to load one or more complete objects + instead of, or in addition to, a subset of data member. While we + can often achieve the same end result by calling + database::load(), using a view has several advantages.

+ +

If we need to load multiple objects, then using a view allows us + to do this with a single SELECT statement execution + instead of one for each object that would be necessary in case of + load(). A view can also be useful for loading only + a single object if the query criterion that we would like to use + involves other, potentially unrelated, objects. We will examine + concrete examples of these and other scenarios in the rest of this + section.

+ +

To load a complete object as part of a view we use a data member of + the pointer to object type, just like for object relationships + (Chapter 6, "Relationships"). As an example, here + is how we can load both the employee and + employer objects from the previous section with a single + statement:

+ + 
+#pragma db view object(employee) object(employer)
+struct employee_employer
+{
+  shared_ptr<employee> ee;
+  shared_ptr<employer> er;
+};
+
+ +

We use an object loading view just like any other view. In the + result of a query, as we would expect, the pointer data members + point to the loaded objects. For example:

+ + 
+typedef odb::query<employee_employer> query;
+
+transaction t (db.begin ());
+
+for (const employee_employer& r:
+       db.query<employee_employer> (query::employee::age < 31))
+{
+  cout << r.ee->age () << " " << r.er->name () << endl;
+}
+
+t.commit ();
+
+ +

As another example, consider a query that loads the employer + objects using some condition based on its employees. For instance, we + want to find all the employers that employ people over 65 years old. + We can use this object loading view to implement such a query (notice + the distinct result modifier discussed later in + Section 10.5, "View Query Conditions"):

+ + 
+#pragma db view object(employer) object(employee) query(distinct)
+struct employer_view
+{
+  shared_ptr<employer> er;
+};
+
+ +

And this is how we can use this view to find all the employers that + employ seniors:

+ + 
+typedef odb::query<employee_employer> query;
+
+db.query<employer_view> (query::employee::age > 65)
+
+ +

We can even use object loading views to load completely unrelated + (from the ODB object relationships point of view) objects. For example, + the following view will load all the employers that are named the + same as a country (notice the inner join type):

+ + 
+#pragma db view object(employer) \
+  object(country inner: employer::name == country::name)
+struct employer_named_country
+{
+  shared_ptr<employer> e;
+  shared_ptr<country> c;
+};
+
+ +

An object loading view can contain ordinary data members + in addition to object pointers. For example, if we are only + interested in the country code in the above view, then we + can reimplement it like this:

+ + 
+#pragma db view object(employer) \
+  object(country inner: employer::name == country::name)
+struct employer_named_country
+{
+  shared_ptr<employer> e;
+  std::string code;
+};
+
+ +

Object loading views also have a few rules and restrictions. + Firstly, the pointed-to object in the data member must be associated + with the view. Furthermore, if the associated object has an alias, + then the data member name must be the same as the alias (more + precisely, the public name derived from the data member must + match the alias; which means we can use normal data member + decorations such as trailing underscores, etc., see the previous + section for more information on public names). The following view + illustrates the use of aliases as data member names:

+ + 
+#pragma db view object(employee)               \
+  object(country = res: employee::residence_)  \
+  object(country = nat: employee::nationality_)
+struct employee_country
+{
+  shared_ptr<country> res;
+  shared_ptr<country> nat_;
+};
+
+ +

Finally, the object pointers must be direct data members of + the view. Using, for example, a composite value that contains + pointers as a view data member is not supported. Note also + that depending on the join type you are using, some of the + resulting pointers might be NULL.

+ +

Up until now we have consistently used shared_ptr + as an object pointer in our views. Can we use other pointers, + such as unique_ptr or raw pointers? To answer + this question we first need to discuss what happens with + object pointers that may be inside objects that a view + loads. As a concrete example, let us revisit the + employee_employer view from the beginning of + this section:

+ + 
+#pragma db view object(employee) object(employer)
+struct employee_employer
+{
+  shared_ptr<employee> ee;
+  shared_ptr<employer> er;
+};
+
+ +

This view loads two objects: employee and + employer. The employee object, + however, also contains a pointer to employer + (see the employed_by_ data member). In fact, + this is the same object that the view loads since employer + is associated with the view using this same relationship (ODB + automatically uses it since it is the only one). The correct + result of loading such a view is then clear: both er and + er->employed_by_ must point to (or share) the + same instance.

+ +

Just like object loading via the database class + functions, views achieve this correct behavior of only loading + a single instance of the same object with the help of session's + object cache (Chapter 11, "Session"). In fact, + object loading views enforce this by throwing the + session_required exception if there is no current + session and the view loads an object that is also indirectly + loaded by one of the other objects. The ODB compiler will also + issue diagnostics if such an object has session support + disabled (Section 14.1.10, + "session").

+ +

With this understanding we can now provide the correct implementation + of our transaction that uses the employee_employer view:

+ + 
+typedef odb::query<employee_employer> query;
+
+transaction t (db.begin ());
+odb::session s;
+
+for (const employee_employer& r:
+       db.query<employee_employer> (query::employee::age < 31))
+{
+  assert (r.ee->employed_by_ == r.er);
+  cout << r.ee->age () << " " << r.er->name () << endl;
+}
+
+t.commit ();
+
+ +

It might seem logical, then, to always load all the objects from + all the eager relationships with the view. After all, this will + lead to them all being loaded with a single statement. While + this is theoretically true, the reality is slightly more nuanced. + If there is a high probability of the object already have been + loaded and sitting in the cache, then not loading the object + as part of the view (and therefore not fetching all its data + from the database) might result in better performance.

+ +

Now we can also answer the question about which pointers we can + use in object loading views. From the above discussion it should + be clear that if an object that we are loading is also part of a + relationship inside another object that we are loading, then we + should use some form of a shared ownership pointer. If, however, + there are no relationships involved, as is the case, for example, + in our employer_named_country and + employee_country views above, then we can use a + unique ownership pointer such as unique_ptr.

+ +

Note also that your choice of a pointer type can be limited by the + "official" object pointer type assigned to the object + (Section 3.3, "Object and View Pointers"). + For example, if the object pointer type is shared_ptr, + you will not be able to use unique_ptr to load + such an object into a view since initializing unique_ptr + from shared_ptr would be a mistake.

+ +

Unless you want to perform your own object cleanup, raw object + pointers in views are not particularly useful. They do have one + special semantics, however: If a raw pointer is used as a view + member, then, before creating a new instance, the implementation + will check if the member is NULL. If it is not, then + it is assumed to point to an existing instance and the implementation + will load the data into it instead of creating a new one. The + primary use of this special functionality is to implement by-value + loading with the ability to detect NULL values.

+ +

To illustrate this functionality, consider the following view that + load the employee's residence country by value:

+ + 
+#pragma db view object(employee) \
+  object(country = res: employee::residence_) transient
+struct employee_res_country
+{
+  typedef country* country_ptr;
+
+  #pragma db member(res_) virtual(country_ptr) get(&this.res) \
+    set(this.res_null = ((?) == nullptr))
+
+  country res;
+  bool res_null;
+};
+
+ +

Here we are using a virtual data member + (Section 14.4.13, "virtual") to + add an object pointer member to the view. Its accessor expression + returns the pointer to the res member so that + the implementation can load the data into it. The modifier + expression checks the passed pointer to initialize the + NULL value indicator. Here, the two possible + values that can be passed to the modifier expression are + the address of the res member that we returned + earlier from the accessor and NULL (strictly + speaking, there is a third possibility: the address of an + object that was found in the session cache).

+ +

If we are not interested in the NULL indicator, + then the above view can simplified to this:

+ + 
+#pragma db view object(employee) \
+  object(country = res: employee::residence_) transient
+struct employee_res_country
+{
+  typedef country* country_ptr;
+
+  #pragma db member(res_) virtual(country_ptr) get(&this.res) set()
+
+  country res;
+};
+
+ +

That is, we specify an empty modifier expression which leads to + the value being ignored.

+ +

As another example of by-value loading, consider a view that allows + us to load objects into existing instances that have been allocated + outside the view:

+ + 
+#pragma db view object(employee)               \
+  object(country = res: employee::residence_)  \
+  object(country = nat: employee::nationality_)
+struct employee_country
+{
+  employee_country (country& r, country& n): res (&r), nat (&n) {}
+
+  country* res;
+  country* nat;
+};
+
+ +

And here is how we can use this view:

+ + 
+typedef odb::result<employee_country> result;
+
+transaction t (db.begin ());
+
+result r (db.query<employee_country> (...);
+
+for (result::iterator i (r.begin ()); i != r.end (); ++i)
+{
+  country res, nat;
+  employee_country v (res, nat);
+  i.load (v);
+
+  if (v.res != nullptr)
+    ... // Result is in res.
+
+  if (v.nat != nullptr)
+    ... // Result is in nat.
+}
+
+t.commit ();
+
+ +

As a final example of the by-value loading, consider the following + view which implements a slightly more advanced logic: if the object + is already in the session cache, then it sets the pointer data member + in the view (er_p) to that. Otherwise, it loads the data + into the by-value instance (er). We can also check + whether the pointer data member points to the instance to distinguish + between the two outcomes. And we can check it for nullptr + to detect NULL values.

+ + 
+#pragma db view object(employer)
+struct employer_view
+{
+  // Since we may be getting the pointer as both smart and raw, we
+  // need to create a bit of support code to use in the modifier
+  // expression.
+  //
+  void set_er (employer* p) {er_p = p;}                   // &er or NULL.
+  void set_er (shared_ptr<employer> p) {er_p = p.get ();} // From cache.
+
+  #pragma db get(&this.er) set(set_er(?))
+  employer* er_p;
+
+  #pragma db transient
+  employer er;
+
+  // Return-by-value support (e.g., query_value()).
+  //
+  employer_view (): er_p (0) {}
+  employer_view (const employer_view& x)
+    : er_p (x.er_p == &x.er ? &er : x.er_p), er (x.er) {}
+};
+
+ +

We can use object loading views with polymorphic objects + (Section 8.2, "Polymorphism Inheritance"). Note, + however, that when loading a derived object via the base pointer + in a view, a separate statement will be executed to load the + dynamic part of the object. There is no support for by-value + loading for polymorphic objects.

+ +

We can also use object loading views with objects without id + (Section 14.1.6, "no_id"). + Note, however, that for such objects, NULL values + are not automatically detected (since there is no primary key, + which is otherwise guaranteed to be not NULL, there + might not be a column on which to base this detection). The + workaround for this limitation is to load an otherwise not + NULL column next to the object which will serve + as an indicator. For example:

+ + 
+#pragma db object no_id
+class object
+{
+  ...
+
+  int n; // NOT NULL
+  std::string s;
+};
+
+#include <odb/nullable.hxx>
+
+#pragma db view object(object)
+struct view
+{
+
+  odb::nullable<int> n; // If 'n' is NULL, then, logically, so is 'o'.
+  unique_ptr<object> o;
+};
+
+ +

10.3 Table Views

+ +

A table view is similar to an object view except that it is + based on one or more database tables instead of persistent + objects. Table views are primarily useful when dealing with + ad-hoc tables that are not mapped to persistent classes.

+ +

To associate one or more tables with a view we use the + db table pragma (Section 14.2.2, + "table"). To associate the second and subsequent + tables we repeat the db table pragma for each + additional table. For example, the following view is based on the + employee_extra legacy table we have defined at the + beginning of the chapter.

+ + 
+#pragma db view table("employee_extra")
+struct employee_vacation
+{
+  #pragma db column("employee_id") type("INTEGER")
+  unsigned long employee_id;
+
+  #pragma db column("vacation_days") type("INTEGER")
+  unsigned short vacation_days;
+};
+
+ +

Besides the table name in the db table pragma + we also have to specify the column name for each view data + member. Note that unlike for object views, the ODB compiler + does not try to automatically come up with column names for + table views. Furthermore, we cannot use references to object + members either, since there are no associated objects in table + views. Instead, the actual column name or column expression + must be specified as a string literal. The column name can + also be qualified with a table name either in the + "table.column" form or, if either a table + or a column name contains a period, in the + "table"."column" form. The following example + illustrates the use of a column expression:

+ + 
+#pragma db view table("employee_extra")
+struct employee_max_vacation
+{
+  #pragma db column("max(vacation_days)") type("INTEGER")
+  unsigned short max_vacation_days;
+};
+
+ +

Both the asociated table names and the column names can be qualified + with a database schema, for example:

+ + 
+#pragma db view table("hr.employee_extra")
+struct employee_max_vacation
+{
+  #pragma db column("hr.employee_extra.vacation_days") type("INTEGER")
+  unsigned short vacation_days;
+};
+
+ +

For more information on database schemas and the format of the + qualified names, refer to Section 14.1.8, + "schema".

+ +

Note also that in the above examples we specified the SQL type + for each of the columns to make sure that the ODB compiler + has knowledge of the actual types as specified in the database + schema. This is required to obtain correct and optimal + generated code.

+ + +

The complete syntax of the db table pragma + is similar to the db object pragma and is shown + below:

+ +

table("name" + [= "alias"] + [join-type] + [: join-condition])

+ +

The name part is a database table name. The optional + alias part gives this table an alias. If provided, the + alias must be used instead of the table whenever a reference + to a table is used. Contexts where such a reference may + be needed include the join condition (discussed below), + column names, and query expressions. The optional join-type + part specifies the way this table is associated. It can + be left, right, full, + inner, and cross with left + being the default. Finally, the optional join-condition + part provides the criteria which should be used to associate this + table with any of the previously associated tables or, as we will see in + Section 10.4, "Mixed Views", objects. Note that + while the first associated table can have an alias, it cannot have + a join type or condition.

+ +

Similar to object views, for each subsequent associated table the + ODB compiler needs a join condition. However, unlike for object views, + for table views the ODB compiler does not try to come up with one + automatically. Furthermore, we cannot use references to object + members corresponding to object relationships either, since there + are no associated objects in table views. Instead, for each + subsequent associated table, a join condition must be + specified as a custom query expression. While the syntax of the + query expression is the same as in the query facility used to query + the database for objects (Chapter 4, "Querying the + Database"), a join condition for a table is normally specified + as a single string literal containing a native SQL query expression.

+ +

As an example of a multi-table view, consider the + employee_health table that we define in addition + to employee_extra:

+ + 
+CREATE TABLE employee_health(
+  employee_id INTEGER NOT NULL,
+  sick_leave_days INTEGER NOT NULL)
+
+ +

Given these two tables we can now define a view that returns both + the vacation and sick leave information for each employee:

+ + 
+#pragma db view table("employee_extra" = "extra") \
+  table("employee_health" = "health": \
+        "extra.employee_id = health.employee_id")
+struct employee_leave
+{
+  #pragma db column("extra.employee_id") type("INTEGER")
+  unsigned long employee_id;
+
+  #pragma db column("vacation_days") type("INTEGER")
+  unsigned short vacation_days;
+
+  #pragma db column("sick_leave_days") type("INTEGER")
+  unsigned short sick_leave_days;
+};
+
+ +

Querying the database for a table view is the same as for an + object view except that we can only use native query expressions. + For example:

+ + 
+typedef odb::query<employee_leave> query;
+typedef odb::result<employee_leave> result;
+
+transaction t (db.begin ());
+
+unsigned short v_min = ...
+unsigned short l_min = ...
+
+result r (db.query<employee_leave> (
+  "vacation_days > " + query::_val(v_min) + "AND"
+  "sick_leave_days > " + query::_val(l_min)));
+
+t.commit ();
+
+ + +

10.4 Mixed Views

+ +

A mixed view has both associated objects and tables. As a first + example of a mixed view, let us improve employee_vacation + from the previous section to return the employee's first + and last names instead of the employee id. To achieve this we + have to associate both the employee object and + the employee_extra table with the view:

+ + 
+#pragma db view object(employee) \
+  table("employee_extra" = "extra": "extra.employee_id = " + employee::id_)
+struct employee_vacation
+{
+  std::string first;
+  std::string last;
+
+  #pragma db column("extra.vacation_days") type("INTEGER")
+  unsigned short vacation_days;
+};
+
+ +

When querying the database for a mixed view, we can use query members + for the parts of the query expression that involves object members + but have to fall back to using the native syntax for the parts that + involve table columns. For example:

+ + 
+typedef odb::query<employee_vacation> query;
+typedef odb::result<employee_vacation> result;
+
+transaction t (db.begin ());
+
+result r (db.query<employee_vacation> (
+  (query::last == "Doe") + "AND extra.vacation_days <> 0"));
+
+for (result::iterator i (r.begin ()); i != r.end (); ++i)
+  cout << i->first << " " << i->last << " " << i->vacation_days << endl;
+
+t.commit ();
+
+ +

As another example, consider a more advanced view that associates + two objects via a legacy table. This view allows us to find the + previous employer name for each employee:

+ + 
+#pragma db view object(employee) \
+  table("employee_extra" = "extra": "extra.employee_id = " + employee::id_) \
+  object(employer: "extra.previous_employer_id = " + employer::id_)
+struct employee_prev_employer
+{
+  std::string first;
+  std::string last;
+
+  // If previous_employer_id is NULL, then the name will be NULL as well.
+  // We use the odb::nullable wrapper to handle this.
+  //
+  #pragma db column(employer::name_)
+  odb::nullable<std::string> prev_employer_name;
+};
+
+ +

10.5 View Query Conditions

+ +

Object, table, and mixed views can also specify an optional query + condition that should be used whenever the database is queried for + this view. To specify a query condition we use the + db query pragma (Section 14.2.3, + "query").

+ +

As an example, consider a view that returns some information about + all the employees that are over a predefined retirement age. + One way to implement this would be to define a standard object + view as we have done in the previous sections and then use a + query like this:

+ + 
+result r (db.query<employee_retirement> (query::age > 50));
+
+ +

The problem with the above approach is that we have to keep + repeating the query::age > 50 expression every + time we execute the query, even though this expression always + stays the same. View query conditions allow us to solve this + problem. For example:

+ + 
+#pragma db view object(employee) query(employee::age > 50)
+struct employee_retirement
+{
+  std::string first;
+  std::string last;
+  unsigned short age;
+};
+
+ +

With this improvement we can rewrite our query like this:

+ + 
+result r (db.query<employee_retirement> ());
+
+ +

But what if we may also need to restrict the result set based on + some varying criteria, such as the employee's last name? Or, in other + words, we may need to combine a constant query expression specified + in the db query pragma with the varying expression + specified at the query execution time. To allow this, the + db query pragma syntax supports the use of the special + (?) placeholder that indicates the position in the + constant query expression where the runtime expression should be + inserted. For example:

+ + 
+#pragma db view object(employee) query(employee::age > 50 && (?))
+struct employee_retirement
+{
+  std::string first;
+  std::string last;
+  unsigned short name;
+};
+
+ +

With this change we can now use additional query criteria in our + view:

+ + 
+result r (db.query<employee_retirement> (query::last == "Doe"));
+
+ +

The syntax of the expression in a query condition is the same as in + the query facility used to query the database for objects + (Chapter 4, "Querying the Database") except for + two differences. Firstly, for query members, instead of + using odb::query<object>::member names, we refer + directly to object members, using the object alias instead of the + object name if an alias was assigned. Secondly, query conditions + support the special (?) placeholder which can be used + both in the C++-integrated query expressions as was shown above + and in native SQL expressions specified as string literals. The + following view is an example of the latter case:

+ + 
+#pragma db view table("employee_extra") \
+  query("vacation_days <> 0 AND (?)")
+struct employee_vacation
+{
+  ...
+};
+
+ +

Another common use case for query conditions are views with the + ORDER BY or GROUP BY clause. Such + clauses are normally present in the same form in every query + involving such views. As an example, consider an aggregate + view which calculate the minimum and maximum ages of employees + for each employer:

+ + 
+#pragma db view object(employee) object(employer) \
+  query((?) + "GROUP BY" + employer::name_)
+struct employer_age
+{
+  #pragma db column(employer::name_)
+  std::string employer_name;
+
+  #pragma db column("min(" + employee::age_ + ")")
+  unsigned short min_age;
+
+  #pragma db column("max(" + employee::age_ + ")")
+  unsigned short max_age;
+};
+
+ +

The query condition can be optionally followed (or replaced, + if no constant query expression is needed) by one or more + result modifiers. Currently supported result modifiers + are distinct (which is translated to SELECT + DISTINCT) and for_update (which is translated + to FOR UPDATE or equivalent for database systems + that support it). As an example, consider a view that + allows us to get some information about employers ordered + by the object id and without any duplicates:

+ + 
+#pragma db view object(employer) object(employee) \
+  query((?) + "ORDER BY" + employer::name_, distinct)
+struct employer_info
+{
+  ...
+};
+
+ +

If we don't require ordering, then this view can be re-implemented + like this:

+ + 
+#pragma db view object(employer) object(employee) query(distinct)
+struct employer_info
+{
+  ...
+};
+
+ +

10.6 Native Views

+ +

The last kind of view supported by ODB is a native view. Native + views are a low-level mechanism for capturing results of native + SQL queries, stored procedure calls, etc. Native views don't have + associated tables or objects. Instead, we use the + db query pragma to specify the native SQL query, + which should normally include the select-list and, if applicable, + the from-list. For example, here is how we can re-implement the + employee_vacation table view from Section 10.3 above + as a native view:

+ + 
+#pragma db view query("SELECT employee_id, vacation_days " \
+                      "FROM employee_extra")
+struct employee_vacation
+{
+  #pragma db type("INTEGER")
+  unsigned long employee_id;
+
+  #pragma db type("INTEGER")
+  unsigned short vacation_days;
+};
+
+ +

In native views the columns in the query select-list are + associated with the view data members in the order specified. + That is, the first column is stored in the first member, the + second column — in the second member, and so on. The ODB compiler + does not perform any error checking in this association. As a result + you must make sure that the number and order of columns in the + query select-list match the number and order of data members + in the view. This is also the reason why we are not + required to provide the column name for each data member in native + views, as is the case for object and table views.

+ +

Note also that while it is always possible to implement a table + view as a native view, the table views must be preferred since + they are safer. In a native view, if you add, remove, or + rearrange data members without updating the column list in the + query, or vice versa, at best, this will result in a runtime + error. In contrast, in a table view such changes will result + in the query being automatically updated.

+ +

Similar to object and table views, the query specified for + a native view can contain the special (?) + placeholder which is replaced with the query expression + specified at the query execution time. + If the native query does not contain a placeholder, as in + the example above, then any query expression specified at + the query execution time is appended to the query text + along with the WHERE keyword, if required. + The following example shows the usage of the placeholder:

+ + 
+#pragma db view query("SELECT employee_id, vacation_days " \
+                      "FROM employee_extra " \
+                      "WHERE vacation_days <> 0 AND (?)")
+struct employee_vacation
+{
+  ...
+};
+
+ +

As another example, consider a view that returns the next + value of a database sequence:

+ + 
+#pragma db view query("SELECT nextval('my_seq')")
+struct sequence_value
+{
+  unsigned long long value;
+};
+
+ +

While this implementation can be acceptable in some cases, it has + a number of drawbacks. Firstly, the name of the sequence is + fixed in the view, which means if we have a second sequence, we + will have to define another, almost identical view. Similarly, + the operation that we perform on the sequence is also fixed. + In some situations, instead of returning the next value, we may + need the last value.

+ +

Note that we cannot use the placeholder mechanism to resolve + these problems since placeholders can only be used in the + WHERE, GROUP BY, and similar + clauses. In other words, the following won't work:

+ + 
+#pragma db view query("SELECT nextval('(?)')")
+struct sequence_value
+{
+  unsigned long long value;
+};
+
+result r (db.query<sequence_value> ("my_seq"));
+
+ +

To support these kinds of use cases, ODB allows us to specify the + complete query for a native view at runtime rather than at the view + definition. To indicate that a native view has a runtime query, + we can either specify the empty db query + pragma or omit the pragma altogether. For example:

+ + 
+#pragma db view
+struct sequence_value
+{
+  unsigned long long value;
+};
+
+ +

Given this view, we can perform the following queries:

+ + 
+typedef odb::query<sequence_value> query;
+typedef odb::result<sequence_value> result;
+
+string seq_name = ...
+
+result l (db.query<sequence_value> (
+  "SELECT lastval('" + seq_name + "')"));
+
+result n (db.query<sequence_value> (
+  "SELECT nextval('" + seq_name + "')"));
+
+ +

Native views can also be used to call and handle results of + stored procedures. The semantics and limitations of stored + procedures vary greatly between database systems while some + do not support this functionality at all. As a result, support + for calling stored procedures using native views is described + for each database system in Part II, "Database + Systems".

+ +

10.7 Other View Features and Limitations

+ +

Views cannot be derived from other views. However, you can derive + a view from a transient C++ class. View data members cannot be + object pointers. If you need to access data from a pointed-to + object, then you will need to associate such an object with + the view. Similarly, view data members cannot be containers. + These two limitations also apply to composite value types that + contain object pointers or containers. Such composite values + cannot be used as view data members.

+ +

On the other hand, composite values that do not contain object + pointers or containers can be used in views. As an example, + consider a modified version of the employee persistent + class that stores a person's name as a composite value:

+ + 
+#pragma db value
+class person_name
+{
+  std::string first_;
+  std::string last_;
+};
+
+#pragma db object
+class employee
+{
+  ...
+
+  person_name name_;
+
+  ...
+};
+
+ +

Given this change, we can re-implement the employee_name + view like this:

+ + 
+#pragma db view object(employee)
+struct employee_name
+{
+  person_name name;
+};
+
+ +

It is also possible to extract some or all of the nested members + of a composite value into individual view data members. Here is + how we could have defined the employee_name view + if we wanted to keep its original structure:

+ + 
+#pragma db view object(employee)
+struct employee_name
+{
+  #pragma db column(employee::name.first_)
+  std::string first;
+
+  #pragma db column(employee::name.last_)
+  std::string last;
+};
+
+ + + + + +
+

11 Session

+ +

A session is an application's unit of work that may encompass several + database transactions. In this version of ODB a session is just an + object cache. In future versions it may provide additional + functionality, such as delayed database operations and automatic + object state change tracking. As discussed later in + Section 11.2, "Custom Sessions", it is also + possible to provide a custom session implementation that provides + these or other features.

+ +

Session support is optional and can be enabled or disabled on the + per object basis using the db session pragma, for + example:

+ + 
+#pragma db object session
+class person
+{
+  ...
+};
+
+ +

We can also enable or disable session support for a group of + objects at the namespace level:

+ + 
+#pragma db namespace session
+namespace accounting
+{
+  #pragma db object                // Session support is enabled.
+  class employee
+  {
+    ...
+  };
+
+  #pragma db object session(false) // Session support is disabled.
+  class employer
+  {
+    ...
+  };
+}
+
+ +

Finally, we can pass the --generate-session ODB compiler + option to enable session support by default. With this option session + support will be enabled for all the persistent classes except those + for which it was explicitly disabled using the + db session. An alternative to this method with the + same effect is to enable session support for the global namespace:

+ + 
+#pragma db namespace() session
+
+ +

Each thread of execution in an application can have only one active + session at a time. A session is started by creating an instance of + the odb::session class and is automatically terminated + when this instance is destroyed. You will need to include the + <odb/session.hxx> header file to make this class + available in your application. For example:

+ + 
+#include <odb/database.hxx>
+#include <odb/session.hxx>
+#include <odb/transaction.hxx>
+
+using namespace odb::core;
+
+{
+  session s;
+
+  // First transaction.
+  //
+  {
+    transaction t (db.begin ());
+    ...
+    t.commit ();
+  }
+
+  // Second transaction.
+  //
+  {
+    transaction t (db.begin ());
+    ...
+    t.commit ();
+  }
+
+  // Session 's' is terminated here.
+}
+
+ +

The session class has the following interface:

+ + 
+namespace odb
+{
+  class session
+  {
+  public:
+    session (bool make_current = true);
+    ~session ();
+
+    // Copying or assignment of sessions is not supported.
+    //
+  private:
+    session (const session&);
+    session& operator= (const session&);
+
+    // Current session interface.
+    //
+  public:
+    static session&
+    current ();
+
+    static bool
+    has_current ();
+
+    static void
+    current (session&);
+
+    static void
+    reset_current ();
+
+    static session*
+    current_pointer ();
+
+    static void
+    current_pointer (session*);
+
+    // Object cache interface.
+    //
+  public:
+    template <typename T>
+    struct cache_position {...};
+
+    template <typename T>
+    cache_position<T>
+    cache_insert (database&,
+                  const object_traits<T>::id_type&,
+                  const object_traits<T>::pointer_type&);
+
+    template <typename T>
+    object_traits<T>::pointer_type
+    cache_find (database&, const object_traits<T>::id_type&) const;
+
+    template <typename T>
+    void
+    cache_erase (const cache_position<T>&);
+
+    template <typename T>
+    void
+    cache_erase (database&, const object_traits<T>::id_type&);
+  };
+}
+
+ +

The session constructor creates a new session and, if the + make_current argument is true, sets it as a + current session for this thread. If we try to make a session current + while there is already another session in effect for this thread, + then the constructor throws the odb::already_in_session + exception. The destructor clears the current session for this + thread if this session is the current one.

+ +

The static current() accessor returns the currently active + session for this thread. If there is no active session, this function + throws the odb::not_in_session exception. We can check + whether there is a session in effect in this thread using the + has_current() static function.

+ +

The static current() modifier allows us to set the + current session for this thread. The reset_current() + static function clears the current session. These two functions + allow for more advanced use cases, such as multiplexing + two or more sessions on the same thread.

+ +

The static current_pointer() overloaded functions + provided the same functionality but using pointers. Specifically, + the current_pointer() accessor can be used to + test whether there is a current session and get a pointer to it + all with a single call.

+ +

We normally don't use the object cache interface directly. However, + it could be useful in some cases, for example, to find out whether + an object has already been loaded. Note that when calling + cache_insert(), cache_find(), or + the second version of cache_erase(), you need to + specify the template argument (object type) explicitly. It is + also possible to access the underlying cache data structures + directly. This can be useful if, for example, you want to + iterate over the objects store in the cache. Refer to the ODB + runtime header files for more details on this direct access.

+ +

11.1 Object Cache

+ +

A session is an object cache. Every time a session-enabled object is + made persistent by calling the database::persist() function + (Section 3.8, "Making Objects Persistent"), loaded + by calling the database::load() or database::find() + function (Section 3.9, "Loading Persistent Objects"), + or loaded by iterating over a query result (Section 4.4, + "Query Result"), the pointer to the persistent object, in the form + of the canonical object pointer (Section 3.3, "Object + and View Pointers"), is stored in the session. For as long as the + session is in effect, any subsequent calls to load the same object will + return the cached instance. When an object's state is deleted from the + database with the database::erase() function + (Section 3.11, "Deleting Persistent Objects"), the + cached object pointer is removed from the session. For example:

+ + 
+shared_ptr<person> p (new person ("John", "Doe"));
+
+session s;
+transaction t (db.begin ());
+
+unsigned long id (db.persist (p));            // p is cached in s.
+shared_ptr<person> p1 (db.load<person> (id)); // p1 same as p.
+
+t.commit ();
+
+ + +

The per-object caching policies depend on the object pointer kind + (Section 6.5, "Using Custom Smart Pointers"). + Objects with a unique pointer, such as std::auto_ptr + or std::unique_ptr, as an object pointer are never + cached since it is not possible to have two such pointers pointing + to the same object. When an object is persisted via a pointer or + loaded as a dynamically allocated instance, objects with both raw + and shared pointers as object pointers are cached. If an object is + persisted as a reference or loaded into a pre-allocated instance, + the object is only cached if its object pointer is a raw pointer.

+ +

Also note that when we persist an object as a constant reference + or constant pointer, the session caches such an object as + unrestricted (non-const). This can lead to undefined + behavior if the object being persisted was actually created as + const and is later found in the session cache and + used as non-const. As a result, when using sessions, + it is recommended that all persistent objects be created as + non-const instances. The following code fragment + illustrates this point:

+ + 
+void save (database& db, shared_ptr<const person> p)
+{
+  transaction t (db.begin ());
+  db.persist (p); // Persisted as const pointer.
+  t.commit ();
+}
+
+session s;
+
+shared_ptr<const person> p1 (new const person ("John", "Doe"));
+unsigned long id1 (save (db, p1)); // p1 is cached in s as non-const.
+
+{
+  transaction t (db.begin ());
+  shared_ptr<person> p (db.load<person> (id1)); // p == p1
+  p->age (30); // Undefined behavior since p1 was created const.
+  t.commit ();
+}
+
+shared_ptr<const person> p2 (new person ("Jane", "Doe"));
+unsigned long id2 (save (db, p2)); // p2 is cached in s as non-const.
+
+{
+  transaction t (db.begin ());
+  shared_ptr<person> p (db.load<person> (id2)); // p == p2
+  p->age (30); // Ok, since p2 was not created const.
+  t.commit ();
+}
+
+ +

11.2 Custom Sessions

+ +

ODB can use a custom session implementation instead of the + default odb::session. There could be multiple + reasons for an application to provide its own session. For + example, the application may already include a notion of an + object cache or registry which ODB can re-use. A custom + session can also provide additional functionality, such as + automatic change tracking, delayed database operations, or + object eviction. Finally, the session-per-thread approach used + by odb::session may not be suitable for all + applications. For instance, some may need a thread-safe + session that can be shared among multiple threads. For + an example of a custom session that implements automatic + change tracking by keeping original copies of the objects, + refer to the common/session/custom test + in the odb-tests package.

+ +

To use a custom session we need to specify its type with + the --session-type ODB compiler command line + option. We also need to include its definition into the + generated header file. This can be achieved with the + --hxx-prologue option. For example, if our + custom session is called app::session and + is defined in the app/session.hxx header + file, then the corresponding ODB compiler options would + look like this:

+ + 
+odb --hxx-prologue "#include \"app/session.hxx\"" \
+--session-type ::app::session ...
+
+ +

A custom session should provide the following interface:

+ + 
+class custom_session
+{
+public:
+  template <typename T>
+  struct cache_position
+  {
+    ...
+  };
+
+  // Cache management functions.
+  //
+  template <typename T>
+  static cache_position<T>
+  _cache_insert (odb::database&,
+                 const typename odb::object_traits<T>::id_type&,
+                 const typename odb::object_traits<T>::pointer_type&);
+
+  template <typename T>
+  static typename odb::object_traits<T>::pointer_type
+  _cache_find (odb::database&,
+               const typename odb::object_traits<T>::id_type&);
+
+  template <typename T>
+  static void
+  _cache_erase (const cache_position<T>&);
+
+  // Notification functions.
+  //
+  template <typename T>
+  static void
+  _cache_persist (const cache_position<T>&);
+
+  template <typename T>
+  static void
+  _cache_load (const cache_position<T>&);
+
+  template <typename T>
+  static void
+  _cache_update (odb::database&, const T& obj);
+
+  template <typename T>
+  static void
+  _cache_erase (odb::database&,
+                const typename odb::object_traits<T>::id_type&);
+};
+
+ +

The cache_position class template represents a position + in the cache of the inserted object. It should be default and + copy-constructible as well as copy-assignable. The default + constructor shall create a special empty/NULL + position. A call of any of the cache management or notification + functions with such an empty/NULL position shall be + ignored.

+ +

The _cache_insert() function shall add the object into + the object cache and return its position. The _cache_find() + function looks an object up in the object cache given its id. + It returns a NULL pointer if the object is not + found. The _cache_erase() cache management function + shall remove the object from the cache. It is called + if the database operation that caused the object to be inserted + (for example, load) failed. Note also that after insertion the object + state is undefined. You can only access the object state + (for example, make a copy or clear a flag) from one of the + notification functions discussed below.

+ +

The notification functions are called after an object has + been persisted, loaded, updated, or erased, respectively. If + your session implementation does not need some of the + notifications, you still have to provide their functions, + however, you can leave their implementations empty.

+ +

Notice also that all the cache management and notification + functions are static. This is done in order to allow for a + custom notion of a current session. Normally, the first + step a non-empty implementation will perform is lookup the + current session.

+ + + + + +
+

12 Optimistic Concurrency

+ +

The ODB transaction model (Section 3.5, + "Transactions") guarantees consistency as long as we perform all the + database operations corresponding to a specific application transaction + in a single database transaction. That is, if we load an object within a + database transaction and update it in the same transaction, then we are + guaranteed that the object state that we are updating in the database is + exactly the same as the state we have loaded. In other words, it is + impossible for another process or thread to modify the object state + in the database between these load and update operations.

+ +

In this chapter we use the term application transaction + to refer to a set of operations on persistent objects that an + application needs to perform in order to implement some + application-specific functionality. The term database + transaction refers to the set of database operations + performed between the ODB begin() and commit() + calls. Up until now we have treated application transactions and + database transactions as essentially the same thing.

+ +

While this model is easy to understand and straightforward to use, + it may not be suitable for applications that have long application + transactions. The canonical example of such a situation is an + application transaction that requires user input between loading + an object and updating it. Such an operation may take an arbitrary + long time to complete and performing it within a single database + transaction will consume database resources as well as prevent + other processes/threads from updating the object for too long.

+ +

The solution to this problem is to break up the long-lived + application transaction into several short-lived database + transactions. In our example that would mean loading the object + in one database transaction, waiting for user input, and then + updating the object in another database transaction. For example:

+ + 
+unsigned long id = ...;
+person p;
+
+{
+  transaction t (db.begin ());
+  db.load (id, p);
+  t.commit ();
+}
+
+cerr << "enter age for " << p.first () << " " << p.last () << endl;
+unsigned short age;
+cin >> age;
+p.age (age);
+
+{
+  transaction t (db.begin ());
+  db.update (p);
+  t.commit ();
+}
+
+ +

This approach works well if we only have one process/thread that can ever + update the object. However, if we have multiple processes/threads + modifying the same object, then this approach does not guarantee + consistency anymore. Consider what happens in the above example if + another process updates the person's last name while we are waiting for + the user input. Since we loaded the object before this change occured, + our version of the person's data will still have the old name. Once we + receive the input from the user, we go ahead and update the object, + overwriting both the old age with the new one (correct) and the new name + with the old one (incorrect).

+ +

While there is no way to restore the consistency guarantee in + an application transaction that consists of multiple database + transactions, ODB provides a mechanism, called optimistic + concurrency, that allows applications to detect and potentially + recover from such inconsistencies.

+ +

In essence, the optimistic concurrency model detects mismatches + between the current object state in the database and the state + when it was loaded into the application memory. Such a mismatch + would mean that the object was changed by another process or + thread. There are several ways to implement such state mismatch + detection. Currently, ODB uses object versioning while other + methods, such as timestamps, may be supported in the future.

+ +

To declare a persistent class with the optimistic concurrency model we + use the optimistic pragma (Section 14.1.5, + "optimistic"). We also use the version + pragma (Section 14.4.16, "version") + to specify which data member will store the object version. For + example:

+ + 
+#pragma db object optimistic
+class person
+{
+  ...
+
+  #pragma db version
+  unsigned long version_;
+};
+
+ +

The version data member is managed by ODB. It is initialized to + 1 when the object is made persistent and incremented + by 1 with each update. The 0 version value + is not used by ODB and the application can use it as a special value, + for example, to indicate that the object is transient. Note that + for optimistic concurrency to function properly, the application + should not modify the version member after making the object persistent + or loading it from the database and until deleting the state of this + object from the database. To avoid any accidental modifications + to the version member, we can declare it const, for + example:

+ + 
+#pragma db object optimistic
+class person
+{
+  ...
+
+  #pragma db version
+  const unsigned long version_;
+};
+
+ +

When we call the database::update() function + (Section 3.10, "Updating Persistent Objects") and pass + an object that has an outdated state, the odb::object_changed + exception is thrown. At this point the application has two + recovery options: it can abort and potentially restart the + application transaction or it can reload the new object + state from the database, re-apply or merge the changes, and call + update() again. Note that aborting an application + transaction that performs updates in multiple database transactions + may require reverting changes that have already been committed to + the database. As a result, this strategy works best if all the + updates are performed in the last database transaction of the + application transaction. This way the changes can be reverted + by simply rolling back this last database transaction.

+ +

The following example shows how we can reimplement the above + transaction using the second recovery option:

+ + 
+unsigned long id = ...;
+person p;
+
+{
+  transaction t (db.begin ());
+  db.load (id, p);
+  t.commit ();
+}
+
+cerr << "enter age for " << p.first () << " " << p.last () << endl;
+unsigned short age;
+cin >> age;
+p.age (age);
+
+{
+  transaction t (db.begin ());
+
+  try
+  {
+    db.update (p);
+  }
+  catch (const object_changed&)
+  {
+    db.reload (p);
+    p.age (age);
+    db.update (p);
+  }
+
+  t.commit ();
+}
+
+ +

An important point to note in the above code fragment is that the second + update() call cannot throw the object_changed + exception because we are reloading the state of the object + and updating it within the same database transaction.

+ +

Depending on the recovery strategy employed by the application, + an application transaction with a failed update can be significantly + more expensive than a successful one. As a result, optimistic + concurrency works best for situations with low to medium contention + levels where the majority of the application transactions complete + without update conflicts. This is also the reason why this concurrency + model is called optimistic.

+ +

In addition to updates, ODB also performs state mismatch detection + when we are deleting an object from the database + (Section 3.11, "Deleting Persistent Objects"). + To understand why this can be important, consider the following + application transaction:

+ + 
+unsigned long id = ...;
+person p;
+
+{
+  transaction t (db.begin ());
+  db.load (id, p);
+  t.commit ();
+}
+
+string answer;
+cerr << "age is " << p.age () << ", delete?" << endl;
+getline (cin, answer);
+
+if (answer == "yes")
+{
+  transaction t (db.begin ());
+  db.erase (p);
+  t.commit ();
+}
+
+ +

Consider again what happens if another process or thread updates + the object by changing the person's age while we are waiting for + the user input. In this case, the user makes the decision based on + a certain age while we may delete (or not delete) an object that has + a completely different age. Here is how we can fix this problem + using optimistic concurrency:

+ + 
+unsigned long id = ...;
+person p;
+
+{
+  transaction t (db.begin ());
+  db.load (id, p);
+  t.commit ();
+}
+
+string answer;
+for (bool done (false); !done; )
+{
+  if (answer.empty ())
+    cerr << "age is " << p.age () << ", delete?" << endl;
+  else
+    cerr << "age changed to " << p.age () << ", still delete?" << endl;
+
+  getline (cin, answer);
+
+  if (answer == "yes")
+  {
+    transaction t (db.begin ());
+
+    try
+    {
+      db.erase (p);
+      done = true;
+    }
+    catch (const object_changed&)
+    {
+      db.reload (p);
+    }
+
+    t.commit ();
+  }
+  else
+    done = true;
+}
+
+ +

Note that state mismatch detection is performed only if we delete + an object by passing the object instance to the erase() + function. If we want to delete an object with the optimistic concurrency + model regardless of its state, then we need to use the erase() + function that deletes an object given its id, for example:

+ + 
+{
+  transaction t (db.begin ());
+  db.erase (p.id ());
+  t.commit ();
+}
+
+ +

Finally, note that for persistent classes with the optimistic concurrency + model both the update() function as well as the + erase() function that accepts an object instance as its + argument no longer throw the object_not_persistent + exception if there is no such object in the database. Instead, + this condition is treated as a change of object state and the + object_changed exception is thrown instead.

+ +

For complete sample code that shows how to use optimistic + concurrency, refer to the optimistic example in + the odb-examples package.

+ + + + + +
+

13 Database Schema Evolution

+ +

When we add new persistent classes or change the existing ones, for + example, by adding or deleting data members, the database schema + necessary to store the new object model changes as well. At the + same time, we may have existing databases that contain existing data. + If new versions of your application don't need to handle + old databases, then the schema creating functionality is all that + you need. However, most applications will need to work with data + stored by older versions of the same application.

+ +

We will call database schema evolution the overall task + of updating the database to match the changes in the object model. + Schema evolution usually consists of two sub-tasks: schema + migration and data migration. Schema migration + modifies the database schema to correspond to the current + object model. In a relational database, this, for example, could + require adding or dropping tables and columns. The data migration + task involves converting the data stored in the existing database + from the old format to the new one.

+ +

If performed manually, database schema evolution is a tedious and + error-prone task. As a result, ODB provides comprehensive support + for automated or, more precisely, semi-automated schema + evolution. Specifically, ODB does fully-automatic schema + migration and provides facilities to help you with data + migration.

+ +

The topic of schema evolution is a complex and sensitive + issue since normally there would be valuable, production data at + stake. As a result, the approach taken by ODB is to provide simple + and bullet-proof elementary building blocks (or migration steps) + that we can understand and trust. Using these elementary blocks we + can then implement more complex migration scenarios. In particular, + ODB does not try to handle data migration automatically since in most + cases this requires understanding of application-specific semantics. + In other words, there is no magic.

+ +

There are two general approaches to working with older data: the + application can either convert it to correspond to the new format + or it can be made capable of working with multiple versions of this + format. There is also a hybrid approach where the application + may convert the data to the new format gradually as part of its + normal functionality. ODB is capable of handling all these + scenarios. That is, there is support for working with older + models without performing any migration (schema or data). + Alternatively, we can migrate the schema after + which we have the choice of either also immediately migrating the + data (immediate data migration) or doing it gradually + (gradual data migration).

+ +

Schema evolution is already a complex task and we should not + unnecessarily use a more complex approach where a simpler one + would be sufficient. From the above, the simplest approach is + the immediate schema migration that does not require any data + migration. An example of such a change would be adding a new + data member with the default value (Section + 14.3.4, "default"). This case ODB can handle + completely automatically.

+ +

If we do require data migration, then the next simplest approach + is the immediate schema and data migration. Here we have to write + custom migration code. However, it is separate from the rest of + the core application logic and is executed at a well defined point + (database migration). In other words, the core application logic + need not be aware of older model versions. The potential drawback + of this approach is performance. It may take a lot of resources + and/or time to convert all the data upfront.

+ +

If the immediate migration is not possible, then the next option + is the immediate schema migration followed by the gradual data + migration. With this approach, both old and new data must co-exist + in the new database. We also have to change the application + logic to both account for different sources of the same data (for + example, when either an old or new version of the object is loaded) + as well as migrate the data when appropriate (for example, when + the old version of the object is updated). At some point, usually + when the majority of the data has been converted, gradual migrations + are terminated with an immediate migration.

+ +

The most complex approach is working with multiple versions of + the database without performing any migrations, schema or data. + ODB does provide support for implementing this approach + (Section 13.4, "Soft Object Model Changes"), + however we will not cover it any further in this chapter. + Generally, this will require embedding knowledge about each + version into the core application logic which makes it hard + to maintain for any non-trivial object model.

+ +

Note also that when it comes to data migration, we can use + the immediate variant for some changes and gradual for others. + We will discuss various migration scenarios in greater detail + in section Section 13.3, "Data Migration".

+ +

13.1 Object Model Version and Changelog

+ +

To enable schema evolution support in ODB we need to specify + the object model version, or, more precisely, two versions. + The first is the base model version. It is the lowest + version from which we will be able to migrate. The second + version is the current model version. In ODB we can migrate + from multiple previous versions by successively migrating + from one to the next until we reach the current version. + We use the db model version pragma + to specify both the base and current versions.

+ +

When we enable schema evolution for the first time, our + base and current versions will be the same, for example:

+ + 
+#pragma db model version(1, 1)
+
+ +

Once we release our application, its users may create databases + with the schema corresponding to this version of the object + model. This means that if we make any modifications to our + object model that also change the schema, then we will need + to be able to migrate the old databases to this new schema. + As a result, before making any new changes after a release, + we increment the current version, for example:

+ + 
+#pragma db model version(1, 2)
+
+ +

To put this another way, we can stay on the same version + during development and keep adding new changes to it. But + once we release it, any new changes to the object model will + have to be done in a new version.

+ +

It is easy to forget to increment the version before + making new changes to the object model. To help solve this + problem, the db model version pragma + accepts a third optional argument that specify whether the + current version is open or closed for changes. For example:

+ + 
+#pragma db model version(1, 2, open)   // Can add new changes to
+                                       // version 2.
+
+ + 
+#pragma db model version(1, 2, closed) // Can no longer add new
+                                       // changes to version 2.
+
+ +

If the current version is closed, ODB will refuse to accept + any new schema changes. In this situation you would + normally increment the current version and mark it as open + or you could re-open the existing version if, for example, + you need to fix something. Note, however, that re-opening + versions that have been released will most likely result + in migration malfunctions. By default the version is open.

+ +

Normally, an application will have a range of older database + versions from which it is able to migrate. When we change + this range by removing support for older versions, we also + need to adjust the base model version. This will make sure + that ODB does not keep unnecessary information around.

+ +

A model version (both base and current) is a 64-bit unsigned + integer (unsigned long long). 0 + is reserved to signify special situations, such as the lack of + schema in the database. Other than that, we can use any values + as versions as long as they are monotonically increasing. In + particular, we don't have to start with version 1 + and can increase the versions by any increment.

+ +

One versioning approach is to use an independent + object model version by starting from version 1 + and also incrementing by 1. The alternative + is to make the model version correspond to the application + version. For example, if our application is using the + X.Y.Z version format, then we could encode it + as a hexadecimal number and use that as our model version, + for example:

+ + 
+#pragma db model version(0x020000, 0x020306) // 2.0.0-2.3.6
+
+ +

Most real-world object models will be spread over multiple + header files and it will be burdensome to repeat the + db model version pragma in each of + them. The recommended way to handle this situation is to + place the version pragma into a separate header + file and include it into the object model files. If your + project already has a header file that defines the + application version, then it is natural to place this + pragma there. For example:

+ + 
+// version.hxx
+//
+// Define the application version.
+//
+
+#define MYAPP_VERSION 0x020306 // 2.3.6
+
+#ifdef ODB_COMPILER
+#pragma db model version(1, 7)
+#endif
+
+ +

Note that we can also use macros in the version + pragma which allows us to specify all the versions in a single + place. For example:

+ + 
+#define MYAPP_VERSION      0x020306 // 2.3.6
+#define MYAPP_BASE_VERSION 0x020000 // 2.0.0
+
+#ifdef ODB_COMPILER
+#pragma db model version(MYAPP_BASE_VERSION, MYAPP_VERSION)
+#endif
+
+ +

It is also possible to have multiple object models within the + same application that have different versions. Such models + must be independent, that is, no headers from one model shall + include a header from another. You will also need to assign + different schema names to each model with the + --schema-name ODB compiler option.

+ +

Once we specify the object model version, the ODB compiler + starts tracking database schema changes in a changelog file. + Changelog has an XML-based, line-oriented format. It uses + XML in order to provide human readability while also + facilitating, if desired, processing and analysis with + custom tools. The line orientation makes it easy to review + with tools like diff.

+ +

The changelog is maintained by the ODB compiler. Specifically, + you do not need to make any manual changes to this file. You + will, however, need to keep it around from one invocation of + the ODB compiler to the next. In other words, the changelog + file is both the input and the output of the ODB compiler. This, + for example, means that if your project's source code is stored + in a version control repository, then you will most likely want + to store the changelog there as well. If you delete the changelog, + then any ability to do schema migration will be lost.

+ +

The only operation that you may want to perform with the + changelog is to review the database schema changes that resulted + from the C++ object model changes. For this you can use a tool + like diff or, better yet, the change review facilities + offered by your revision control system. For this purpose the + contents of a changelog will be self-explanatory.

+ +

As an example, consider the following initial object model:

+ + 
+// person.hxx
+//
+
+#include <string>
+
+#pragma db model version(1, 1)
+
+#pragma db object
+class person
+{
+  ...
+
+  #pragma db id auto
+  unsigned long id_;
+
+  std::string first_;
+  std::string last_;
+};
+
+ +

We then compile this header file with the ODB compiler (using the + PostgreSQL database as an example):

+ + 
+odb --database pgsql --generate-schema person.hxx
+
+ +

If we now look at the list of generated files, then in addition to + the now familiar person-odb.?xx and person.sql, + we will also see person.xml — the changelog file. + Just for illustration, below are the contents of this changelog.

+ + 
+<changelog database="pgsql">
+  <model version="1">
+    <table name="person" kind="object">
+      <column name="id" type="BIGINT" null="false"/>
+      <column name="first" type="TEXT" null="false"/>
+      <column name="last" type="TEXT" null="false"/>
+      <primary-key auto="true">
+        <column name="id"/>
+      </primary-key>
+    </table>
+  </model>
+</changelog>
+
+ +

Let's say we now would like to add another data member to the + person class — the middle name. We increment + the version and make the change:

+ + 
+#pragma db model version(1, 2)
+
+#pragma db object
+class person
+{
+  ...
+
+  #pragma db id auto
+  unsigned long id_;
+
+  std::string first_;
+  std::string middle_;
+  std::string last_;
+};
+
+ +

We use exactly the same command line to re-compile our file:

+ + 
+odb --database pgsql --generate-schema person.hxx
+
+ +

This time the ODB compiler will read the old changelog, update + it, and write out the new version. Again, for illustration only, + below are the updated changelog contents:

+ + 
+<changelog database="pgsql">
+  <changeset version="2">
+    <alter-table name="person">
+      <add-column name="middle" type="TEXT" null="false"/>
+    </alter-table>
+  </changeset>
+
+  <model version="1">
+    <table name="person" kind="object">
+      <column name="id" type="BIGINT" null="false"/>
+      <column name="first" type="TEXT" null="false"/>
+      <column name="last" type="TEXT" null="false"/>
+      <primary-key auto="true">
+        <column name="id"/>
+      </primary-key>
+    </table>
+  </model>
+</changelog>
+
+ +

Just to reiterate, while the changelog may look like it could + be written by hand, it is maintained completely automatically + by the ODB compiler and the only reason you may want to look + at its contents is to review the database schema changes. For + example, if we compare the above two changelogs with + diff, we will get the following summary of the + database schema changes:

+ + 
+--- person.xml.orig
++++ person.xml
+@@ -1,4 +1,10 @@
+<changelog database="pgsql">
++  <changeset version="2">
++    <alter-table name="person">
++      <add-column name="middle" type="TEXT" null="false"/>
++    </alter-table>
++  </changeset>
++
+  <model version="1">
+    <table name="person" kind="object">
+      <column name="id" type="BIGINT" null="false"/>
+
+ +

The changelog is only written when we generate the database schema, + that is, the --generate-schema option is specified. + Invocations of the ODB compiler that only produce the database + support code (C++) do not read or update the changelog. To put it + another way, the changelog tracks changes in the resulting database + schema, not the C++ object model.

+ +

ODB ignores column order when comparing database schemas. This means + that we can re-order data members in a class without causing any + schema changes. Member renames, however, will result in schema + changes since the column name changes as well (unless we specified + the column name explicitly). From ODB's perspective such a rename + looks like the deletion of one data member and the addition of + another. If we don't want this to be treated as a schema change, + then we will need to keep the old column name by explicitly + specifying it with the db column pragma. For + example, here is how we can rename middle_ to + middle_name_ without causing any schema changes:

+ + 
+#pragma db model version(1, 2)
+
+#pragma db object
+class person
+{
+  ...
+
+  #pragma db column("middle") // Keep the original column name.
+  std::string middle_name_;
+
+  ...
+};
+
+ +

If your object model consists of a large number of header files and + you generate the database schema for each of them individually, then + a changelog will be created for each of your header files. This may + be what you want, however, the large number of changelogs can quickly + become unwieldy. In fact, if you are generating the database schema + as standalone SQL files, then you may have already experienced a + similar problem caused by a large number of .sql files, + one for each header.

+ +

The solution to both of these problems is to generate a combined + database schema file and a single changelog. For example, assume + we have three header files in our object model: + person.hxx, employee.hxx, and + employer.hxx. To generate the database support code + we compile them as usual but without specifying the + --generate-schema option. In this case no changelog + is created or updated:

+ + 
+odb --database pgsql person.hxx
+odb --database pgsql employee.hxx
+odb --database pgsql employer.hxx
+
+ +

To generate the database schema, we perform a separate invocation + of the ODB compiler. This time, however, we instruct it to only + generate the schema (--generate-schema-only) and + produce it combined (--at-once) for all the files + in our object model:

+ + 
+odb --database pgsql --generate-schema-only --at-once \
+--input-name company person.hxx employee.hxx employer.hxx
+
+ +

The result of the above command is a single company.sql + file (the name is derived from the --input-name value) + that contains the database schema for our entire object model. There + is also a single corresponding changelog file — + company.xml.

+ +

The same can be achieved for the embedded schema by instructing + the ODB compiler to generate the database creation code into a + separate C++ file (--schema-format separate):

+ + 
+odb --database pgsql --generate-schema-only --schema-format separate \
+--at-once --input-name company person.hxx employee.hxx employer.hxx
+
+ +

The result of this command is a single company-schema.cxx + file and, again, company.xml.

+ +

Note also that by default the changelog file is not placed into + the directory specified with the --output-dir option. + This is due to the changelog being both an input and an output file + at the same time. As a result, by default, the ODB compiler will + place it in the directory of the input header file.

+ +

There is, however, a number of command line options (including + --changelog-dir) that allow us to fine-tune the name and + location of the changelog file. For example, you can instruct the ODB + compiler to read the changelog from one file while writing it to + another. This, for example, can be useful if you want to review + the changes before discarding the old file. For more information + on these options, refer to the + ODB + Compiler Command Line Manual and search for "changelog".

+ +

When we were discussing version increments above, we used the + terms development and release. Specifically, + we talked about keeping the same object model versions during + development periods and incrementing them after releases. + What is a development period and a release in this context? + These definitions can vary from project to project. + Generally, during a development period we work on one or + more changes to the object model that result in the changes + to the database schema. A release is a point where we + make our changes available to someone else who may have an + older database to migrate from. In the traditional sense, a release + is a point where you make a new version of your application available + to its users. However, for schema evolution purposes, a release + could also mean simply making your schema-altering changes + available to other developers on your team. Let us consider + two common scenarios to illustrate how all this fits together.

+ +

One way to setup a project would be to re-use the application + development period and application release for schema evolution. + That is, during a new application version development we keep + a single object model version and when we release the application, + we increment the model version. In this case it makes sense to + also reuse the application version as a model version for + consistency. Here is a step-by-step guide for this setup:

+ +
    +
  1. During development, keep the current object model version open.
    2. + +
  2. Before the release (for example, when entering a "feature freeze") + close the version.
    3. + +
  3. After the release, update the version and open it.
    4. + +
  4. For each new feature, review the changeset at the top of the + changelog, for example, with diff or your + version control facilities. If you are using a version + control, then this is best done just before committing + your changes to the repository.
    5. +
+ +

An alternative way to setup schema versioning in a project would + be to define the development period as working on a single + feature and the release as making this feature available to + other people (developers, testers, etc.) on your team, for + example, by committing the changes to a public version control + repository. In this case, the object model version will be + independent of the application version and can simply be + a sequence that starts with 1 and is + incremented by 1. Here is a step-by-step guide + for this setup:

+ +
    +
  1. Keep the current model version closed. Once a change is made + that affects the database schema, the ODB compiler will refuse + to update the changelog.
    2. + +
  2. If the change is legitimate, open a new version, that is, + increment the current version and make it open.
    3. + +
  3. Once the feature is implemented and tested, review the final + set of database changes (with diff or your + version control facilities), close the version, and commit + the changes to the version control repository (if using).
    4. +
+ +

If you are using a version control repository that supports + pre-commit checks, then you may want to consider adding such + a check to make sure the committed version is always closed.

+ +

If we are just starting schema evolution in our project, which + approach should we choose? The two approaches will work better + in different situations since they have a different set of + advantages and disadvantages. The first approach, which we + can call version per application release, is best suited + for simpler projects with smaller releases since otherwise + a single migration will bundle a large number of unrelated + actions corresponding to different features. This can + become difficult to review and, if things go wrong, debug.

+ +

The second approach, which we can call version per feature, + is much more modular and provides a number of additional benefits. + We can perform migrations for each feature as a discreet step + which makes it easier to debug. We can also place each such + migration step into a separate transaction further improving + reliability. It also scales much better in larger teams + where multiple developers can work concurrently on features + that affect the database schema. For example, if you find + yourself in a situation where another developer on your + team used the same version as you and managed to commit his + changes before you (that is, you have a merge conflict), + then you can simply change the version to the next available + one, regenerate the changelog, and continue with your commit.

+ +

Overall, unless you have strong reasons to prefer the version + per application release approach, rather choose version per + feature even though it may seem more complex at the + beginning. Also, if you do select the first approach, consider + provisioning for switching to the second method by reserving + a sub-version number. For example, for an application version + in the form 2.3.4 you can make the object model + version to be in the form 0x0203040000, reserving + the last two bytes for a sub-version. Later on you can use it to + switch to the version per feature approach.

+ +

13.2 Schema Migration

+ +

Once we enable schema evolution by specifying the object model + version, in addition to the schema creation statements, the + ODB compiler starts generating schema migration statements + for each version all the way from the base to the current. + As with schema creation, schema migration can be generated + either as a set of SQL files or embedded into the generated + C++ code (--schema-format option).

+ +

For each migration step, that is from one version to the next, + ODB generates two sets of statements: pre-migration and + post-migration. The pre-migration statements "relax" + the database schema so that both old and new data can co-exist. + At this stage new columns and tables are added while old + constraints are dropped. The post-migration statements + "tighten" the database schema back so that only + data conforming to the new format can remain. At this stage + old columns and tables are dropped and new constraints are + added. Now you can probably guess where the data + migration fits into this — between the pre and post + schema migrations where we can both access the old data + and create the new one.

+ +

If the schema is being generated as standalone SQL files, + then we end up with a pair of files for each step: the pre-migration + file and the post-migration file. For the person + example we started in the previous section we will have the + person-002-pre.sql and person-002-post.sql + files. Here 002 is the version to which + we are migrating while the pre and post + suffixes specify the migration stage. So if we wanted to migrate + a person database from version 1 + to 2, then we would first execute + person-002-pre.sql, then migrate the data, if any + (discussed in more detail in the next section), and finally + execute person-002-post.sql. If our database is + several versions behind, for example the database has version + 1 while the current version is 5, + then we simply perform this set of steps for each version + until we reach the current version.

+ +

If we look at the contents of the person-002-pre.sql + file, we will see the following (or equivalent, depending on the + database used) statement:

+ + 
+ALTER TABLE "person"
+  ADD COLUMN "middle" TEXT NULL;
+
+ +

As we would expect, this statement adds a new column corresponding + to the new data member. An observant reader would notice, + however, that the column is added as NULL + even though we never requested this semantics in our object model. + Why is the column added as NULL? If during migration + the person table already contains rows (that is, existing + objects), then an attempt to add a non-NULL column that + doesn't have a default value will fail. As a result, ODB will initially + add a new column that doesn't have a default value as NULL + but then clean this up at the post-migration stage. This way your data + migration code is given a chance to assign some meaningful values for + the new data member for all the existing objects. Here are the contents + of the person-002-post.sql file:

+ + 
+ALTER TABLE "person"
+  ALTER COLUMN "middle" SET NOT NULL;
+
+ +

Currently ODB directly supports the following elementary database + schema changes:

+ +
    +
  • add table
    • +
  • drop table
    • +
  • add column
    • +
  • drop column
    • +
  • alter column, set NULL/NOT NULL
    • +
  • add foreign key
    • +
  • drop foreign key
    • +
  • add index
    • +
  • drop index
    • +
+ +

More complex changes can normally be implemented in terms of + these building blocks. For example, to change a type of a + data member (which leads to a change of a column type), we + can add a new data member with the desired type (add column), + migrate the data, and then delete the old data member (drop + column). ODB will issue diagnostics for cases that are + currently not supported directly. Note also that some database + systems (notably SQLite) have a number of limitations in their + support for schema changes. For more information on these + database-specific limitations, refer to the "Limitations" sections + in Part II, "Database Systems".

+ +

How do we know what the current database version is? That is, the + version from which we need to migrate? We need to know this, + for example, in order to determine the set of migrations we have to + perform. By default, when schema evolution is enabled, ODB maintains + this information in a special table called schema_version + that has the following (or equivalent, depending on the database + used) definition:

+ + 
+CREATE TABLE "schema_version" (
+  "name" TEXT NOT NULL PRIMARY KEY,
+  "version" BIGINT NOT NULL,
+  "migration" BOOLEAN NOT NULL);
+
+ +

The name column is the schema name as specified with + the --schema-name option. It is empty for the default + schema. The version column contains the current database + version. And, finally, the migration flag indicates + whether we are in the process of migrating the database, that is, + between the pre and post-migration stages.

+ +

The schema creation statements (person.sql in our case) + create this table and populate it with the initial model version. For + example, if we executed person.sql corresponding to + version 1 of our object model, then name + would have been empty (which signifies the default schema since we + didn't specify --schema-name), version will + be 1 and migration will be + FALSE.

+ +

The pre-migration statements update the version and set the migration + flag to TRUE. Continuing with our example, after executing + person-002-pre.sql, version will + become 2 and migration will be set to + TRUE. The post-migration statements simply clear the + migration flag. In our case, after running + person-002-post.sql, version will + remain 2 while migration will be reset + to FALSE.

+ +

Note also that above we mentioned that the schema creation statements + (person.sql) create the schema_version table. + This means that if we enable schema evolution support in the middle + of a project, then we could already have existing databases that + don't include this table. As a result, ODB will not be able to handle + migrations for such databases unless we manually add the + schema_version table and populate it with the correct + version information. For this reason, it is highly recommended that + you consider whether to use schema evolution and, if so, enable it + from the beginning of your project.

+ +

The odb::database class provides an API for accessing + and modifying the current database version:

+ + 
+namespace odb
+{
+  typedef unsigned long long schema_version;
+
+  struct LIBODB_EXPORT schema_version_migration
+  {
+    schema_version_migration (schema_version = 0,
+                              bool migration = false);
+
+    schema_version version;
+    bool migration;
+
+    // This class also provides the ==, !=, <, >, <=, and >= operators.
+    // Version ordering is as follows: {1,f} < {2,t} < {2,f} < {3,t}.
+  };
+
+  class database
+  {
+  public:
+    ...
+
+    schema_version
+    schema_version (const std::string& name = "") const;
+
+    bool
+    schema_migration (const std::string& name = "") const;
+
+    const schema_version_migration&
+    schema_version_migration (const std::string& name = "") const;
+
+    // Set schema version and migration state manually.
+    //
+    void
+    schema_version_migration (schema_version,
+                              bool migration,
+                              const std::string& name = "");
+
+    void
+    schema_version_migration (const schema_version_migration&,
+                              const std::string& name = "");
+
+    // Set default schema version table for all schemas.
+    //
+    void
+    schema_version_table (const std::string& table_name);
+
+    // Set schema version table for a specific schema.
+    //
+    void
+    schema_version_table (const std::string& table_name,
+                          const std::string& name);
+  };
+}
+
+ +

The schema_version() and schema_migration() + accessors return the current database version and migration flag, + respectively. The optional name argument is the schema + name. If the database schema hasn't been created (that is, there is + no corresponding entry in the schema_version table or + this table does not exist), then schema_version() returns + 0. The schema_version_migration() accessor + returns both version and migration flag together in the + schema_version_migration struct.

+ +

You may already have a version table in your database or you (or your + database administrator) may prefer to keep track of versions your own + way. You can instruct ODB not to create the schema_version + table with the --suppress-schema-version option. However, + ODB still needs to know the current database version in order for certain + schema evolution mechanisms to function properly. As a result, in + this case, you will need to set the schema version on the database + instance manually using the schema_version_migration() modifier. + Note that the modifier API is not thread-safe. That is, you should + not modify the schema version while other threads may be accessing + or modifying the same information.

+ +

Note also that the accessors we discussed above will only query the + schema_version table once and, if the version could + be determined, cache the result. If, however, the version could + not be determined (that is, schema_version() returned + 0), then a subsequent call will re-query the table. While it is + probably a bad idea to modify the database schema while the + application is running (other than via the schema_catalog + API, as discussed below), if for some reason you need ODB to re-query + the version, then you can manually set it to 0 using the + schema_version_migration() modifier.

+ +

It is also possible to change the name of the table that stores + the schema version using the --schema-version-table + option. You will also need to specify this alternative name on + the database instance using the schema_version_table() + modifier. The first version specifies the default table that is + used for all the schema names. The second version specifies the + table for a specific schema. The table name should be + database-quoted, if necessary.

+ +

If we are generating our schema migrations as standalone SQL files, + then the migration workflow could look like this:

+ +
    +
  1. The database administrator determines the current database version. + If migration is required, then for each migration step (that + is, from one version to the next), he performs the following:
    2. + +
  2. Execute the pre-migration file.
    3. + +
  3. Execute our application (or a separate migration program) + to perform data migration (discussed later). Our application + can determine that is is being executed in the "migration mode" + by calling schema_migration() and then which + migration code to run by calling schema_version().
    4. + +
  4. Execute the post-migration file.
    5. +
+ +

These steps become more integrated and automatic if we embed the + schema creation and migration code into the generated C++ code. + Now we can perform schema creation, schema migration, and data + migration as well as determine when each step is necessary + programmatically from within the application.

+ +

Schema evolution support adds the following extra functions to + the odb::schema_catalog class, which we first discussed + in Section 3.4, "Database".

+ + 
+namespace odb
+{
+  class schema_catalog
+  {
+  public:
+    ...
+
+
+    // Schema migration.
+    //
+    static void
+    migrate_schema_pre (database&,
+                        schema_version,
+                        const std::string& name = "");
+
+    static void
+    migrate_schema_post (database&,
+                         schema_version,
+                         const std::string& name = "");
+
+    static void
+    migrate_schema (database&,
+                    schema_version,
+                    const std::string& name = "");
+
+    // Data migration.
+    //
+    // Discussed in the next section.
+
+
+    // Combined schema and data migration.
+    //
+    static void
+    migrate (database&,
+             schema_version = 0,
+             const std::string& name = "");
+
+    // Schema version information.
+    //
+    static schema_version
+    base_version (const database&,
+                  const std::string& name = "");
+
+    static schema_version
+    base_version (database_id,
+                  const std::string& name = "");
+
+    static schema_version
+    current_version (const database&,
+                     const std::string& name = "");
+
+    static schema_version
+    current_version (database_id,
+                     const std::string& name = "");
+
+    static schema_version
+    next_version (const database&,
+                  schema_version = 0,
+                  const std::string& name = "");
+
+    static schema_version
+    next_version (database_id,
+                  schema_version,
+                  const std::string& name = "");
+  };
+}
+
+ +

The migrate_schema_pre() and + migrate_schema_post() static functions perform + a single stage (that is, pre or post) of a single migration + step (that is, from one version to the next). The version + argument specifies the version we are migrating to. For + instance, in our person example, if we know that + the database version is 1 and the next version + is 2, then we can execute code like this:

+ + 
+transaction t (db.begin ());
+
+schema_catalog::migrate_schema_pre (db, 2);
+
+// Data migration goes here.
+
+schema_catalog::migrate_schema_post (db, 2);
+
+t.commit ();
+
+ +

If you don't have any data migration code to run, then you can + perform both stages with a single call using the + migrate_schema() static function.

+ +

The migrate() static function perform both schema + and data migration (we discuss data migration in the next section). + It can also perform several migration steps at once. If we don't + specify its target version, then it will migrate (if necessary) + all the way to the current model version. As an extra convenience, + migrate() will also create the database schema if + none exists. As a result, if we don't have any data migration + code or we have registered it with schema_catalog (as + discussed later), then the database schema creation and migration, + whichever is necessary, if at all, can be performed with a single + function call:

+ + 
+transaction t (db.begin ());
+schema_catalog::migrate (db);
+t.commit ();
+
+ +

Note also that schema_catalog is integrated with the + odb::database schema version API. In particular, + schema_catalog functions will query and synchronize + the schema version on the database instance if and + when required.

+ +

The schema_catalog class also allows you to iterate + over known versions (remember, there could be "gaps" in version + numbers) with the base_version(), + current_version() and next_version() + static functions. The base_version() and + current_version() functions return the base and + current object model versions, respectively. That is, the + lowest version from which we can migrate and the version that + we ultimately want to migrate to. The next_version() + function returns the next known version. If the passed version is + greater or equal to the current version, then this function + will return the current version plus one (that is, one past + current). If we don't specify the version, then + next_version() will use the current database version + as the starting point. Note also that the schema version information + provided by these functions is only available if we embed the schema + migration code into the generated C++ code. For standalone SQL file + migrations this information is normally not needed since the migration + process is directed by an external entity, such as a database + administrator or a script.

+ +

Most schema_catalog functions presented above also + accept the optional schema name argument. If the passed schema + name is not found, then the odb::unknown_schema exception + is thrown. Similarly, functions that accept the schema version + argument will throw the odb::unknown_schema_version exception + if the passed version is invalid. Refer to Section + 3.14, "ODB Exceptions" for more information on these exceptions.

+ +

To illustrate how all these parts fit together, consider the + following more realistic database schema management example. + Here we want to handle the schema creation in a special way + and perform each migration step in its own transaction.

+ + 
+schema_version v (db.schema_version ());
+schema_version bv (schema_catalog::base_version (db));
+schema_version cv (schema_catalog::current_version (db));
+
+if (v == 0)
+{
+  // No schema in the database. Create the schema and
+  // initialize the database.
+  //
+  transaction t (db.begin ());
+  schema_catalog::create_schema (db);
+
+  // Populate the database with initial data, if any.
+
+  t.commit ();
+}
+else if (v < cv)
+{
+  // Old schema (and data) in the database, migrate them.
+  //
+
+  if (v < bv)
+  {
+    // Error: migration from this version is no longer supported.
+  }
+
+  for (v = schema_catalog::next_version (db, v);
+       v <= cv;
+       v = schema_catalog::next_version (db, v))
+  {
+    transaction t (db.begin ());
+    schema_catalog::migrate_schema_pre (db, v);
+
+    // Data migration goes here.
+
+    schema_catalog::migrate_schema_post (db, v);
+    t.commit ();
+  }
+}
+else if (v > cv)
+{
+  // Error: old application trying to access new database.
+}
+
+ +

13.3 Data Migration

+ +

In quite a few cases specifying the default value for new data + members will be all that's required to handle the existing objects. + For example, the natural default value for the new middle name + that we have added is an empty string. And we can handle + this case with the db default pragma and without + any extra C++ code:

+ + 
+#pragma db model version(1, 2)
+
+#pragma db object
+class person
+{
+  ...
+
+
+  #pragma db default("")
+  std::string middle_;
+};
+
+ +

However, there will be situations where we would need to perform + more elaborate data migrations, that is, convert old data to the + new format. As an example, suppose we want to add gender to our + person class. And, instead of leaving it unassigned + for all the existing objects, we will try to guess it from the + first name. This is not particularly accurate but it could be + sufficient for our hypothetical application:

+ + 
+#pragma db model version(1, 3)
+
+enum gender {male, female};
+
+#pragma db object
+class person
+{
+  ...
+
+  gender gender_;
+};
+
+ +

As we have discussed earlier, there are two ways to perform data + migration: immediate and gradual. To recap, with immediate + migration we migrate all the existing objects at once, normally + after the schema pre-migration statements but before the + post-migration statements. With gradual migration, we make sure + the new object model can accommodate both old and new data and + gradually migrate existing objects as the application runs and + the opportunities to do so arise, for example, an object is + updated.

+ +

There is also another option for data migration that is not + discussed further in this section. Instead of using our C++ + object model we could execute ad-hoc SQL statements that + perform the necessary conversions and migrations directly + on the database server. While in certain cases this can be + a better option from the performance point of view, this + approach is often limited in terms of the migration logic + that we can handle.

+ +

13.3.1 Immediate Data Migration

+ +

Let's first see how we can implement an immediate migration for the + new gender_ data member we have added above. If we + are using standalone SQL files for migration, then we could add + code along these lines somewhere early in main(), + before the main application logic:

+ + 
+int
+main ()
+{
+  ...
+
+  odb::database& db = ...
+
+  // Migrate data if necessary.
+  //
+  if (db.schema_migration ())
+  {
+    switch (db.schema_version ())
+    {
+    case 3:
+      {
+        // Assign gender to all the existing objects.
+        //
+        transaction t (db.begin ());
+
+        for (person& p: db.query<person> ())
+        {
+          p.gender (guess_gender (p.first ()));
+          db.update (p);
+        }
+
+        t.commit ();
+        break;
+      }
+    }
+  }
+
+  ...
+}
+
+ +

If you have a large number of objects to migrate, it may also be + a good idea, from the performance point of view, to break one big + transaction that we now have into multiple smaller transactions + (Section 3.5, "Transactions"). For example:

+ + 
+case 3:
+  {
+    transaction t (db.begin ());
+
+    size_t n (0);
+    for (person& p: db.query<person> ())
+    {
+      p.gender (guess_gender (p.first ()));
+      db.update (p);
+
+      // Commit the current transaction and start a new one after
+      // every 100 updates.
+      //
+      if (n++ % 100 == 0)
+      {
+        t.commit ();
+        t.reset (db.begin ());
+      }
+    }
+
+    t.commit ();
+    break;
+  }
+
+ +

While it looks straightforward enough, as we add more migration + snippets, this approach can quickly become unmaintainable. Instead + of having all the migrations in a single function and determining + when to run each piece ourselves, we can package each migration into + a separate function, register it with the schema_catalog + class, and let ODB figure out when to run which migration functions. + To support this functionality, schema_catalog provides + the following data migration API:

+ + 
+namespace odb
+{
+  class schema_catalog
+  {
+  public:
+    ...
+
+    // Data migration.
+    //
+    static std::size_t
+    migrate_data (database&,
+                  schema_version = 0,
+                  const std::string& name = "");
+
+    typedef void data_migration_function_type (database&);
+
+    // Common (for all the databases) data migration, C++98/03 version:
+    //
+    template <schema_version v, schema_version base>
+    static void
+    data_migration_function (data_migration_function_type*,
+                             const std::string& name = "");
+
+    // Common (for all the databases) data migration, C++11 version:
+    //
+    template <schema_version v, schema_version base>
+    static void
+    data_migration_function (std::function<data_migration_function_type>,
+                             const std::string& name = "");
+
+    // Database-specific data migration, C++98/03 version:
+    //
+    template <schema_version v, schema_version base>
+    static void
+    data_migration_function (database&,
+                             data_migration_function_type*,
+                             const std::string& name = "");
+
+    template <schema_version v, schema_version base>
+    static void
+    data_migration_function (database_id,
+                             data_migration_function_type*,
+                             const std::string& name = "");
+
+    // Database-specific data migration, C++11 version:
+    //
+    template <schema_version v, schema_version base>
+    static void
+    data_migration_function (database&,
+                             std::function<data_migration_function_type>,
+                             const std::string& name = "");
+
+    template <schema_version v, schema_version base>
+    static void
+    data_migration_function (database_id,
+                             std::function<data_migration_function_type>,
+                             const std::string& name = "");
+  };
+
+  // Static data migration function registration, C++98/03 version:
+  //
+  template <schema_version v, schema_version base>
+  struct data_migration_entry
+  {
+    data_migration_entry (data_migration_function_type*,
+                          const std::string& name = "");
+
+    data_migration_entry (database_id,
+                          data_migration_function_type*,
+                          const std::string& name = "");
+  };
+
+  // Static data migration function registration, C++11 version:
+  //
+  template <schema_version v, schema_version base>
+  struct data_migration_entry
+  {
+    data_migration_entry (std::function<data_migration_function_type>,
+                          const std::string& name = "");
+
+    data_migration_entry (database_id,
+                          std::function<data_migration_function_type>,
+                          const std::string& name = "");
+  };
+}
+
+ +

The migrate_data() static function performs data + migration for the specified version. If no version is specified, + then it will use the current database version and also check + whether the database is in migration, that is, + database::schema_migration() returns true. + As a result, all we need to do in our main() is call + this function. It will check if migration is required and if so, + call all the migration functions registered for this version. For + example:

+ + 
+int
+main ()
+{
+  ...
+
+  database& db = ...
+
+  // Check if we need to migrate any data and do so
+  // if that's the case.
+  //
+  schema_catalog::migrate_data (db);
+
+  ...
+}
+
+ +

The migrate_data() function returns the number of + migration functions called. You can use this value for debugging + or logging.

+ +

The only other step that we need to perform is register our data + migration functions with schema_catalog. At the + lower level we can call the data_migration_function() + static function for every migration function we have, for example, + at the beginning of main(). For each version, data + migration functions are called in the order of registration.

+ +

A more convenient approach, however, is to use the + data_migration_entry helper class template to register the + migration functions during static initialization. This way we + can keep the migration function and its registration code next + to each other. Here is how we can reimplement our gender + migration code to use this mechanism:

+ + 
+static void
+migrate_gender (odb::database& db)
+{
+  transaction t (db.begin ());
+
+  for (person& p: db.query<person> ())
+  {
+    p.gender (guess_gender (p.first ()));
+    db.update (p);
+  }
+
+  t.commit ();
+}
+
+static const odb::data_migration_entry<3, MYAPP_BASE_VERSION>
+migrate_gender_entry (&migrate_gender);
+
+ +

The first template argument to the data_migration_entry + class template is the version we want this data migration function + to be called for. The second template argument is the base model + version. This second argument is necessary to detect the situation + where we no longer need this data migration function. Remember + that when we move the base model version forward, migrations from + any version below the new base are no longer possible. We, however, + may still have migration functions registered for those lower + versions. Since these functions will never be called, they are + effectively dead code and it would be useful to identify and + remove them. To assist with this, data_migration_entry + (and lower lever data_migration_function()) will + check at compile time (that is, static_assert) that + the registration version is greater than the base model version.

+ +

In the above example we use the MYAPP_BASE_VERSION + macro that is presumably defined in a central place, for example, + version.hxx. This is the recommended approach since + we can update the base version in a single place and have the + C++ compiler automatically identify all the data migration + functions that can be removed.

+ +

In C++11 we can also create a template alias so that we don't + have to repeat the base model macro in every registration, for + example:

+ + 
+template <schema_version v>
+using migration_entry = odb::data_migration_entry<v, MYAPP_BASE_VERSION>;
+
+static const migration_entry<3>
+migrate_gender_entry (&migrate_gender);
+
+ +

For cases where you need to by-pass the base version check, for + example, to implement your own registration helper, ODB also + provides "unsafe" versions of the data_migration_function() + functions that take the version as a function argument rather than + as a template parameter.

+ +

In C++11 we can also use lambdas as migration functions, which makes + the migration code more concise:

+ + 
+static const migration_entry<3>
+migrate_gender_entry (
+  [] (odb::database& db)
+  {
+    transaction t (db.begin ());
+
+    for (person& p: db.query<person> ())
+    {
+      p.gender (guess_gender (p.first ()));
+      db.update (p);
+    }
+
+    t.commit ();
+  });
+
+ +

If we are using embedded schema migrations, then both schema and + data migration is integrated and can be performed with a single + call to the schema_catalog::migrate() function that + we discussed earlier. For example:

+ +
+int
+main ()
+{
+  ...
+
+  database& db = ...
+
+  // Check if we need to migrate the database and do so
+  // if that's the case.
+  //
+  {
+    transaction t (db.begin ());
+    schema_catalog::migrate (db);
+    t.commit ();
+  }
+
+  ...
+}
+
+ +

Note, however, that in this case we call migrate() + within a transaction (for the schema migration part) which means + that our migration functions will also be called within this + transaction. As a result, we will need to adjust our migration + functions not to start their own transaction:

+ + 
+static void
+migrate_gender (odb::database& db)
+{
+  // Assume we are already in a transaction.
+  //
+  for (person& p: db.query<person> ())
+  {
+    p.gender (guess_gender (p.first ()));
+    db.update (p);
+  }
+}
+
+ +

If, however, we want more granular transactions, then we can + use the lower-level schema_catalog functions to + gain more control, as we have seen at the end of the previous + section. Here is the relevant part of that example with + an added data migration call:

+ + 
+  // Old schema (and data) in the database, migrate them.
+  //
+  for (v = schema_catalog::next_version (db, v);
+       v <= cv;
+       v = schema_catalog::next_version (db, v))
+  {
+    transaction t (db.begin ());
+    schema_catalog::migrate_schema_pre (db, v);
+    schema_catalog::migrate_data (db, v);
+    schema_catalog::migrate_schema_post (db, v);
+    t.commit ();
+  }
+
+ +

13.3.2 Gradual Data Migration

+ +

If the number of existing objects that require migration is large, + then an all-at-once, immediate migration, while simple, may not + be practical from a performance point of view. In this case, + we can perform a gradual migration as the application does + its normal functions.

+ +

With gradual migrations, the object model must be capable of + representing data that conforms to both old and new formats at + the same time since, in general, the database will contain a + mixture of old and new objects. For example, in case of our + gender data member, we need a special value that + represents the "no gender assigned yet" case (an old object). + We also need to assign this special value to all the existing + objects during the schema pre-migration stage. One way to do + this would be add a special value to our gender + enum and then make it the default value with the + db default pragma. A cleaner and easier approach, + however, is to use NULL as a special value. We + can add support for the NULL value semantics + to any existing type by wrapping it with + odb::nullable, boost::optional + or similar (Section 7.3, "Pointers and NULL + Value Semantics"). We also don't need to specify the default value + explicitly since NULL is used automatically. Here + is how we can use this approach in our gender + example:

+ + 
+#include <odb/nullable.hxx>
+
+#pragma db object
+class person
+{
+  ...
+
+  odb::nullable<gender> gender_;
+};
+
+ +

A variety of strategies can be employed to implement gradual + migrations. For example, we can migrate the data when the object + is updated as part of the normal application logic. While there + is no migration cost associated with this approach (the object + is updated anyway), depending on how often objects are typically + updated, this strategy can take a long time to complete. An + alternative strategy would be to perform an update whenever + an old object is loaded. Yet another strategy is to have a + separate thread that slowly migrates all the old objects as + the application runs.

+ +

As an example, let us implement the first approach for our + gender migration. While we could have added + the necessary code throughout the application, from the + maintenance point of view, it is best to try and localize + the gradual migration logic to the persistent classes that + it affects. And for this database operation callbacks + (Section 14.1.7, "callback") + are a very useful mechanism. In our case, all we have to do is handle + the post_load event where we guess the gender + if it is NULL:

+ + 
+#include <odb/core.hxx>     // odb::database
+#include <odb/callback.hxx> // odb::callback_event
+#include <odb/nullable.hxx>
+
+#pragma db object callback(migrate)
+class person
+{
+  ...
+
+  void
+  migrate (odb::callback_event e, odb::database&)
+  {
+    if (e == odb::callback_event::post_load)
+    {
+      // Guess gender if not assigned.
+      //
+      if (gender_.null ())
+        gender_ = guess_gender (first_);
+    }
+  }
+
+  odb::nullable<gender> gender_;
+};
+
+ +

In particular, we don't have to touch any of the accessors + or modifiers or the application logic — all of them + can assume that the value can never be NULL. + And when the object is next updated, the new gender + value will be stored automatically.

+ +

All gradual migrations normally end up with a terminating + immediate migration some number of versions down the line, + when the bulk of the objects has presumably been converted. + This way we don't have to keep the gradual migration code + around forever. Here is how we could implement a terminating + migration for our example:

+ + 
+// person.hxx
+//
+#pragma db model version(1, 4)
+
+#pragma db object
+class person
+{
+  ...
+
+  gender gender_;
+};
+
+// person.cxx
+//
+static void
+migrate_gender (odb::database& db)
+{
+  typedef odb::query<person> query;
+
+  for (person& p: db.query<person> (query::gender.is_null ()))
+  {
+    p.gender (guess_gender (p.first ()));
+    db.update (p);
+  }
+}
+
+static const odb::data_migration_entry<4, MYAPP_BASE_VERSION>
+migrate_gender_entry (&migrate_gender);
+
+ +

A couple of points to note about this code. Firstly, we + removed all the gradual migration logic (the callback) + from the class and replaced it with the immediate migration + function. We also removed the odb::nullable + wrapper (and therefore disallowed the NULL values) + since after this migration all the objects will have been + converted. Finally, in the migration function, we only query + the database for objects that need migration, that is, have + NULL gender.

+ +

13.4 Soft Object Model Changes

+ +

Let us consider another common kind of object model change: + we delete an old member, add a new one, and need to copy + the data from the old to the new, perhaps applying some + conversion. For example, we may realize that in our application + it is a better idea to store a person's name as a single string + rather than split it into three fields. So what we would like to do + is add a new data member, let's call it name_, convert + all the existing split names, and then delete the first_, + middle_, and last_ data members.

+ +

While this sounds straightforward, there is a problem. If we + delete (that is, physically remove from the source code) the + old data members, then we won't be able to access the old + data. The data will still be available in the database between + the schema pre and post-migrations, it is just we will no longer + be able to access it through our object model. And if we keep + the old data members around, then the old data will remain + stored in the database even after the schema post-migration.

+ +

There is also a more subtle problem that has to do with existing + migrations for the previous versions. Remember, in version 3 + of our person example we added the gender_ + data member. We also have a data migration function which guesses + the gender based on the first name. Deleting the first_ + data member from our class will obviously break this code. But + even adding the new name_ data member will cause + problems because when we try to update the object in order to + store the new gender, ODB will try to update name_ + as well. But there is no corresponding column in the database + yet. When we run this migration function, we are still several + versions away from the point where the name column + will be added.

+ +

This is a very subtle but also very important implication to + understand. Unlike the main application logic, which only needs + to deal with the current model version, data migration code works + on databases that can be multiple versions behind the current + version.

+ +

How can we resolve this problem? It appears what we need is the + ability to add or delete data members starting from a specific + version. In ODB this mechanism is called soft member additions + and deletions. A soft-added member is only treated as persistent + starting from the addition version. A soft-deleted member is + persistent until the deletion version (but including the migration + stage). In its essence, soft model changes allow us to maintain + multiple versions of our object model all with a single set of + persistent classes. Let us now see how this functionality can + help implement our changes:

+ + 
+#pragma db model version(1, 4)
+
+#pragma db object
+class person
+{
+  ...
+
+  #pragma db id auto
+  unsigned long id_;
+
+  #pragma db deleted(4)
+  std::string first_;
+
+  #pragma db deleted(4)
+  std::string middle_;
+
+  #pragma db deleted(4)
+  std::string last_;
+
+  #pragma db added(4)
+  std::string name_;
+
+  gender gender_;
+};
+
+ +

The migration function for this change could then look like + this:

+ + 
+static void
+migrate_name (odb::database& db)
+{
+  for (person& p: db.query<person> ())
+  {
+    p.name (p.first () + " " +
+            p.middle () + (p.middle ().empty () ? "" : " ") +
+            p.last ());
+    db.update (p);
+  }
+}
+
+static const odb::data_migration_entry<4, MYAPP_BASE_VERSION>
+migrate_name_entry (&migrate_name);
+
+ +

Note also that no changes are required to the gender migration + function.

+ +

As you may have noticed, in the code above we assumed that the + person class still provides public accessors for + the now deleted data members. This might not be ideal since now + they should not be used by the application logic. The only code + that may still need to access them is the migration functions. The + recommended way to resolve this is to remove the accessors/modifiers + corresponding to the deleted data member, make migration functions + static functions of the class being migrated, and then access + the deleted data members directly. For example:

+ + 
+#pragma db model version(1, 4)
+
+#pragma db object
+class person
+{
+  ...
+
+private:
+  friend class odb::access;
+
+  #pragma db id auto
+  unsigned long id_;
+
+  #pragma db deleted(4)
+  std::string first_;
+
+  #pragma db deleted(4)
+  std::string middle_;
+
+  #pragma db deleted(4)
+  std::string last_;
+
+  #pragma db added(4)
+  std::string name_;
+
+  gender gender_;
+
+private:
+  static void
+  migrate_gender (odb::database&);
+
+  static void
+  migrate_name (odb::database&);
+};
+
+void person::
+migrate_gender (odb::database& db)
+{
+  for (person& p: db.query<person> ())
+  {
+    p.gender_ = guess_gender (p.first_);
+    db.update (p);
+  }
+}
+
+static const odb::data_migration_entry<3, MYAPP_BASE_VERSION>
+migrate_name_entry (&migrate_gender);
+
+void person::
+migrate_name (odb::database& db)
+{
+  for (person& p: db.query<person> ())
+  {
+    p.name_ = p.first_ + " " +
+              p.middle_ + (p.middle_.empty () ? "" : " ") +
+              p.last_;
+    db.update (p);
+  }
+}
+
+static const odb::data_migration_entry<4, MYAPP_BASE_VERSION>
+migrate_name_entry (&migrate_name);
+
+ +

Another potential issue with the soft-deletion is the requirement + to keep the delete data members in the class. While they will not + be initialized in the normal operation of the application (that + is, not a migration), this can still be a problem if we need to + minimize the memory footprint of our classes. For example, we may + cache a large number of objects in memory and having three + std::string data members can be a significant + overhead.

+ +

The recommended way to resolve this issue is to place all the + deleted data members into a dynamically allocated composite + value type. For example:

+ + 
+#pragma db model version(1, 4)
+
+#pragma db object
+class person
+{
+  ...
+
+  #pragma db id auto
+  unsigned long id_;
+
+  #pragma db added(4)
+  std::string name_;
+
+  gender gender_;
+
+  #pragma db value
+  struct deleted_data
+  {
+    #pragma db deleted(4)
+    std::string first_;
+
+    #pragma db deleted(4)
+    std::string middle_;
+
+    #pragma db deleted(4)
+    std::string last_;
+  };
+
+  #pragma db column("")
+  std::unique_ptr<deleted_data> dd_;
+
+  ...
+};
+
+ +

ODB will then automatically allocate the deleted value type if + any of the deleted data members are being loaded. During the normal + operation, however, the pointer will stay NULL and + therefore reduce the common case overhead to a single pointer + per class. Note that we make the composite value column prefix + empty (the db column("") pragma) in order to + keep the same column names for the deleted data members.

+ +

Soft-added and deleted data members can be used in objects, + composite values, views, and container value types. We can + also soft-add and delete data members of simple, composite, + pointer to object, and container types. Only special data + members, such as the object id and the optimistic concurrency + version, cannot be soft-added or deleted.

+ +

It is also possible to soft-delete a persistent class. We + can still work with the existing objects of such a class, + however, no table is created in new databases for soft-deleted + classes. To put it another way, a soft-delete class is like an + abstract class (no table) but which can still be loaded, updated, + etc. Soft-added persistent classes do not make much sense and + are therefore not supported.

+ +

As an example of a soft-deleted class, suppose we want to + replace our person class with the new + employee object and migrate the data. Here is + how we could do this:

+ + 
+#pragma db model version(1, 5)
+
+#pragma db object deleted(5)
+class person
+{
+  ...
+};
+
+#pragma db object
+class employee
+{
+  ...
+
+  #pragma db id auto
+  unsigned long id_;
+
+  std::string name_;
+  gender gender_;
+
+  static void
+  migrate_person (odb::database&);
+};
+
+void employee::
+migrate_person (odb::database& db)
+{
+  for (person& p: db.query<person> ())
+  {
+    employee e (p.name (), p.gender ());
+    db.persist (e);
+  }
+}
+
+static const odb::data_migration_entry<5, MYAPP_BASE_VERSION>
+migrate_person_entry (&migrate_person);
+
+ +

As we have seen above, hard member additions and deletions can + (and most likely will) break existing data migration code. Why, + then, not treat all the changes, or at least additions, as soft? + ODB requires you to explicitly request this semantics because + support for soft-added and deleted data members incurs runtime + overhead. And there can be plenty of cases where there is no + existing data migration and therefore hard additions and deletions + are sufficient.

+ +

In some cases a hard addition or deletion will result in a + compile-time error. For example, one of the data migration + functions may reference the data member we just deleted. In + many cases, however, such errors can only be detected at + runtime, and, worse yet, only when the migration function + is executed. For example, we may hard-add a new data member + that an existing migration function will try to indirectly + store in the database as part of an object update. As a result, + it is highly recommended that you always test your application + with the database that starts at the base version so that every + data migration function is called and therefore ensured to + still work correctly.

+ +

To help with this problem you can also instruct ODB to warn + you about any hard additions or deletions with the + --warn-hard-add, --warn-hard-delete, + and --warn-hard command line options. ODB will + only warn you about hard changes in the current version and + only for as long as it is open, which makes this mechanism + fairly usable.

+ +

You may also be wondering why we have to specify the addition + and deletion versions explicitly. It may seem like the ODB compiler + should be able to figure this out automatically. While it is + theoretically possible, to achieve this, ODB would have to also + maintain a separate changelog of the C++ object model in + addition to the database schema changelog it already maintains. + While being a lot more complex, such an additional changelog + would also complicate the workflow significantly. In this light, + maintaining this change information as part of the original + source files appears to be a cleaner and simpler approach.

+ +

As we discussed before, when we move the base model version + forward we essentially drop support for migrations from + versions before the new base. As a result, it is no longer + necessary to maintain the soft semantics of additions and + deletions up to and including the new base version. ODB + will issue diagnostics for all such members and classes. + For soft deletions we can simply remove the data member or + class entirely. For soft additions we only need to remove the + db added pragma.

+ +

13.4.1 Reuse Inheritance Changes

+ +

Besides adding and deleting data members, another way to alter + the object's table is using reuse-style inheritance. If we add + a new reuse base, then, from the database schema point of view, + this is equivalent to adding all its columns to the derived + object's table. Similarly, deleting reuse inheritance results in + all the base's columns being deleted from the derived's table.

+ +

In the future ODB may provide direct support for soft addition + and deletion of inheritance. Currently, however, this semantics + can be emulated with soft-added and deleted data members. The + following table describes the most common scenarios depending + on where columns are added or deleted, that is, base table, + derived table, or both.

+ + + + + + + + + + + + + + + + + + + + + + + + + + +
DELETEHARDSOFT
In both (delete inheritance and base)Delete inheritance and base. Move object id to derived.Soft-delete base. Mark all data members (except id) in + base as soft-deleted.
In base only (delete base)Option 1: mark base as abstract.

+ Option 2: move all the base member to derived, delete base.		Soft-delete base.
In derived only (delete inheritance)Delete inheritance, add object id to derived.Option 1: copy base to a new soft-deleted base, inherit + from it instead. Mark all the data members (expect id) in + this new base as soft-deleted. Note: we add the new base + as soft-deleted to get notified when we can remove it.

+ Option 2: Copy all the data members from base to derived + and mark them as soft-deleted in derived.
+ + + + + + + + + + + + + + + + + + + + + + + + + + +
ADDHARDSOFT
In both (add new base and inheritance)Add new base and inheritance. Potentially move object id + member from derived to base.Add new base and mark all its data members as soft-added. + Add inheritance. Move object id from derived to base.
In base only (refactor existing data to new base)Add new base and move data members from derived to base. + Note: in most cases the new base will be made abstract + which make this scenario non-schema changing.The same as HARD.
In derived only (add inheritance to existing base)Add inheritance, delete object id in derived.Copy existing base to a new abstract base and inherit + from it. Mark all the database members in the new base + as soft-added (except object id). When notified by the + ODB compiler that the soft addition of the data members + is no longer necessary, delete the copy and inherit from + the original base.
+ +

13.4.2 Polymorphism Inheritance Changes

+ +

Unlike reuse inheritance, adding or deleting a polymorphic base + does not result in the base's data members being added or deleted + from the derived object's table because each class in a polymorphic + hierarchy is stored in a separate table. There are, however, other + complications due to the presence of special columns (discriminator + in the root table and object id links in derived tables) which makes + altering the hierarchy structure difficult to handle automatically. + Adding or deleting (including soft-deleting) of leaf classes (or + leaf sub-hierarchies) in a polymorphic hierarchy is fully supported. + Any more complex changes, such as adding or deleting the root or + an intermediate base or getting an existing class into or out of + a polymorphic hierarchy can be handled by creating a new leaf class + (or leaf sub-hierarchy), soft-deleting the old class, and migrating + the data.

+ + + + +
+

14 ODB Pragma Language

+ +

As we have already seen in previous chapters, ODB uses a pragma-based + language to capture database-specific information about C++ types. + This chapter describes the ODB pragma language in more detail. It + can be read together with other chapters in the manual to get a + sense of what kind of configurations and mapping fine-tuning are + possible. You can also use this chapter as a reference at a later + stage.

+ +

An ODB pragma has the following syntax:

+ +

#pragma db qualifier [specifier specifier ...]

+ +

The qualifier tells the ODB compiler what kind of C++ construct + this pragma describes. Valid qualifiers are object, + view, value, member, + namespace, model, index, and + map. + A pragma with the object qualifier describes a persistent + object type. It tells the ODB compiler that the C++ class it describes + is a persistent class. Similarly, pragmas with the view + qualifier describe view types, the value qualifier + describes value types and the member qualifier is used + to describe data members of persistent object, view, and value types. + The namespace qualifier is used to describe common + properties of objects, views, and value types that belong to + a C++ namespace while the model qualifier describes + the whole C++ object model. The index qualifier defines + a database index. And, finally, the map qualifier + describes a mapping between additional database types and types + for which ODB provides built-in support.

+ +

The specifier informs the ODB compiler about a particular + database-related property of the C++ declaration. For example, the + id member specifier tells the ODB compiler that this + member contains this object's identifier. Below is the declaration + of the person class that shows how we can use ODB + pragmas:

+ + 
+#pragma db object
+class person
+{
+  ...
+private:
+  #pragma db member id
+  unsigned long id_;
+  ...
+};
+
+ +

In the above example we don't explicitly specify which C++ class or + data member the pragma belongs to. Rather, the pragma applies to + a C++ declaration that immediately follows the pragma. Such pragmas + are called positioned pragmas. In positioned pragmas that + apply to data members, the member qualifier can be + omitted for brevity, for example:

+ + 
+  #pragma db id
+  unsigned long id_;
+
+ +

Note also that if the C++ declaration immediately following a + position pragma is incompatible with the pragma qualifier, an + error will be issued. For example:

+ + 
+  #pragma db object  // Error: expected class instead of data member.
+  unsigned long id_;
+
+ +

While keeping the C++ declarations and database declarations close + together eases maintenance and increases readability, we can also + place them in different parts of the same header file or even + factor them to a separate file. To achieve this we use the so called + named pragmas. Unlike positioned pragmas, named pragmas + explicitly specify the C++ declaration to which they apply by + adding the declaration name after the pragma qualifier. For example:

+ + 
+class person
+{
+  ...
+private:
+  unsigned long id_;
+  ...
+};
+
+#pragma db object(person)
+#pragma db member(person::id_) id
+
+ +

Note that in the named pragmas for data members the member + qualifier is no longer optional. The C++ declaration name in the + named pragmas is resolved using the standard C++ name resolution + rules, for example:

+ + 
+namespace db
+{
+  class person
+  {
+    ...
+  private:
+    unsigned long id_;
+    ...
+  };
+}
+
+namespace db
+{
+  #pragma db object(person)  // Resolves db::person.
+}
+
+#pragma db member(db::person::id_) id
+
+ +

As another example, the following code fragment shows how to use the + named value type pragma to map a C++ type to a native database type:

+ + 
+#pragma db value(bool) type("INT")
+
+#pragma db object
+class person
+{
+  ...
+private:
+  bool married_; // Mapped to INT NOT NULL database type.
+  ...
+};
+
+ +

If we would like to factor the ODB pragmas into a separate file, + we can include this file into the original header file (the one + that defines the persistent types) using the #include + directive, for example:

+ + 
+// person.hxx
+
+class person
+{
+  ...
+};
+
+#ifdef ODB_COMPILER
+#  include "person-pragmas.hxx"
+#endif
+
+ +

Alternatively, instead of using the #include directive, + we can use the --odb-epilogue option to make the pragmas + known to the ODB compiler when compiling the original header file, + for example:

+ + 
+--odb-epilogue  '#include "person-pragmas.hxx"'
+
+ +

The following sections cover the specifiers applicable to all the + qualifiers mentioned above.

+ +

The C++ header file that defines our persistent classes and + normally contains one or more ODB pragmas is compiled by both + the ODB compiler to generate the database support code and + the C++ compiler to build the application. Some C++ compilers + issue warnings about pragmas that they do not recognize. There + are several ways to deal with this problem which are covered + at the end of this chapter in Section 14.9, + "C++ Compiler Warnings".

+ +

14.1 Object Type Pragmas

+ +

A pragma with the object qualifier declares a C++ class + as a persistent object type. The qualifier can be optionally followed, + in any order, by one or more specifiers summarized in the table below:

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpecifierSummarySection
tabletable name for a persistent class14.1.1
pointerpointer type for a persistent class14.1.2
abstractpersistent class is abstract14.1.3
readonlypersistent class is read-only14.1.4
optimisticpersistent class with the optimistic concurrency model14.1.5
no_idpersistent class has no object id14.1.6
callbackdatabase operations callback14.1.7
schemadatabase schema for a persistent class14.1.8
polymorphicpersistent class is polymorphic14.1.9
sessionenable/disable session support for a persistent class14.1.10
definitiondefinition location for a persistent class14.1.11
transientall non-virtual data members in a persistent class are transient14.1.12
sectionablesupport addition of new sections in derived classes14.1.13
deletedpersistent class is soft-deleted14.1.14
bulkenable bulk operations for a persistent class14.1.15
+ +

14.1.1 table

+ +

The table specifier specifies the table name that should + be used to store objects of the persistent class in a relational + database. For example:

+ + 
+#pragma db object table("people")
+class person
+{
+  ...
+};
+
+ +

If the table name is not specified, the class name is used as the + table name. The table name can be qualified with a database + schema, for example:

+ + 
+#pragma db object table("census.people")
+class person
+{
+  ...
+};
+
+ +

For more information on database schemas and the format of the + qualified names, refer to Section 14.1.8, + "schema".

+ +

14.1.2 pointer

+ +

The pointer specifier specifies the object pointer type + for the persistent class. The object pointer type is used to return, + pass, and cache dynamically allocated instances of a persistent + class. For example:

+ + 
+#pragma db object pointer(std::tr1::shared_ptr<person>)
+class person
+{
+  ...
+};
+
+ +

There are several ways to specify an object pointer with the + pointer specifier. We can use a complete pointer + type as shown in the example above. Alternatively, we can + specify only the template name of a smart pointer in which + case the ODB compiler will automatically append the class + name as a template argument. The following example is therefore + equivalent to the one above:

+ + 
+#pragma db object pointer(std::tr1::shared_ptr)
+class person
+{
+  ...
+};
+
+ +

If you would like to use the raw pointer as an object pointer, + you can use * as a shortcut:

+ + 
+#pragma db object pointer(*) // Same as pointer(person*)
+class person
+{
+  ...
+};
+
+ +

If a pointer type is not explicitly specified, the default pointer, + specified at the namespace level (Section 14.5.1, + "pointer") or with the --default-pointer + ODB compiler option, is used. If neither of these two mechanisms is + used to specify the pointer, then the raw pointer is used by default.

+ +

For a more detailed discussion of object pointers, refer to + Section 3.3, "Object and View Pointers".

+ +

14.1.3 abstract

+ +

The abstract specifier specifies that the persistent class + is abstract. An instance of an abstract class cannot be stored in + the database and is normally used as a base for other persistent + classes. For example:

+ + 
+#pragma db object abstract
+class person
+{
+  ...
+};
+
+#pragma db object
+class employee: public person
+{
+  ...
+};
+
+#pragma db object
+class contractor: public person
+{
+  ...
+};
+
+ +

Persistent classes with pure virtual functions are automatically + treated as abstract by the ODB compiler. For a more detailed + discussion of persistent class inheritance, refer to + Chapter 8, "Inheritance".

+ +

14.1.4 readonly

+ +

The readonly specifier specifies that the persistent class + is read-only. The database state of read-only objects cannot be + updated. In particular, this means that you cannot call the + database::update() function (Section 3.10, + "Updating Persistent Objects") for such objects. For example:

+ + 
+#pragma db object readonly
+class person
+{
+  ...
+};
+
+ +

Read-only and read-write objects can derive from each other without + any restrictions. When a read-only object derives from a read-write + object, the resulting whole object is read-only, including the part + corresponding to the read-write base. On the other hand, when a + read-write object derives from a read-only object, all the data + members that correspond to the read-only base are treated as + read-only while the rest is treated as read-write.

+ +

Note that it is also possible to declare individual data members + (Section 14.4.12, "readonly") + as well as composite value types (Section 14.3.6, + "readonly") as read-only.

+ +

14.1.5 optimistic

+ +

The optimistic specifier specifies that the persistent class + has the optimistic concurrency model. A class with the optimistic + concurrency model must also specify the data member that is used to + store the object version using the version pragma + (Section 14.4.16, "version"). + For example:

+ + 
+#pragma db object optimistic
+class person
+{
+  ...
+
+  #pragma db version
+  unsigned long version_;
+};
+
+ +

If a base class has the optimistic concurrency model, then all its derived + classes will automatically have the optimistic concurrency model. The + current implementation also requires that in any given inheritance + hierarchy the object id and the version data members reside in the + same class.

+ +

For a more detailed discussion of optimistic concurrency, refer to + Chapter 12, "Optimistic Concurrency".

+ +

14.1.6 no_id

+ +

The no_id specifier specifies that the persistent class + has no object id. For example:

+ + 
+#pragma db object no_id
+class person
+{
+  ...
+};
+
+ +

A persistent class without an object id has limited functionality. + Such a class cannot be loaded with the database::load() + or database::find() functions (Section 3.9, + "Loading Persistent Objects"), updated with the + database::update() function (Section 3.10, + "Updating Persistent Objects"), or deleted with the + database::erase() function (Section 3.11, + "Deleting Persistent Objects"). To load and delete + objects without ids you can use the database::query() + (Chapter 4, "Querying the Database") and + database::erase_query() (Section 3.11, + "Deleting Persistent Objects") functions, respectively. + There is no way to update such objects except by using native SQL + statements (Section 3.12, "Executing Native SQL + Statements").

+ +

Furthermore, persistent classes without object ids cannot have container + data members nor can they be used in object relationships. Such objects + are not entered into the session object cache + (Section 11.1, "Object Cache") either.

+ +

To declare a persistent class with an object id, use the data member + id specifier (Section 14.4.1, + "id").

+ +

14.1.7 callback

+ +

The callback specifier specifies the persist class + member function that should be called before and after a + database operation is performed on an object of this class. + For example:

+ + 
+#include <odb/callback.hxx>
+
+#pragma db object callback(init)
+class person
+{
+  ...
+
+  void
+  init (odb::callback_event, odb::database&);
+};
+
+ +

The callback function has the following signature and can be + overloaded for constant objects:

+ + 
+void
+name (odb::callback_event, odb::database&);
+
+void
+name (odb::callback_event, odb::database&) const;
+
+ +

The first argument to the callback function is the event that + triggered this call. The odb::callback_event + enum-like type is defined in the <odb/callback.hxx> + header file and has the following interface:

+ + 
+namespace odb
+{
+  struct callback_event
+  {
+    enum value
+    {
+      pre_persist,
+      post_persist,
+      pre_load,
+      post_load,
+      pre_update,
+      post_update,
+      pre_erase,
+      post_erase
+    };
+
+    callback_event (value v);
+    operator value () const;
+  };
+}
+
+ +

The second argument to the callback function is the database + on which the operation is about to be performed or has just + been performed. A callback function can be inline or virtual.

+ +

The callback function for the *_persist, + *_update, and *_erase events is always + called on the constant object reference while for the *_load + events — always on the unrestricted reference.

+ +

If only the non-const version of the callback function + is provided, then only the *_load events will be delivered. + If only the const version is provided, then all the + events will be delivered to this function. Finally, if both versions + are provided, then the *_load events will be delivered + to the non-const version while all others — to the + const version. If you need to modify the object in one + of the "const" events, then you can safely cast away + const-ness using the const_cast operator if + you know that none of the objects will be created const. Alternatively, + if you cannot make this assumption, then you can declare the data + members you wish to modify as mutable.

+ +

A database operations callback can be used to implement object-specific + pre and post initializations, registrations, and cleanups. As an example, + the following code fragment outlines an implementation of a + person class that maintains the transient age + data member in addition to the persistent date of birth. A callback + is used to calculate the value of the former from the latter every + time a person object is loaded from the database.

+ + 
+#include <odb/core.hxx>
+#include <odb/callback.hxx>
+
+#pragma db object callback(init)
+class person
+{
+  ...
+
+private:
+  friend class odb::access;
+
+  date born_;
+
+  #pragma db transient
+  unsigned short age_;
+
+  void
+  init (odb::callback_event e, odb::database&)
+  {
+    switch (e)
+    {
+    case odb::callback_event::post_load:
+    {
+      // Calculate age from the date of birth.
+      ...
+      break;
+    }
+    default:
+      break;
+    }
+  }
+};
+
+ +

14.1.8 schema

+ +

The schema specifier specifies a database schema + that should be used for the persistent class.

+ +

In relational databases the term schema can refer to two related + but ultimately different concepts. Normally it means a collection + of tables, indexes, sequences, etc., that are created in the + database or the actual DDL statements that create these + database objects. Some database implementations support what + would be more accurately called a database namespace + but is also called a schema. In this sense, a schema is a + separate namespace in which tables, indexes, sequences, etc., + can be created. For example, two tables that have the same + name can coexist in the same database if they belong to + different schemas. In this section when we talk about a + schema, we refer to the database namespace meaning + of this term.

+ +

When schemas are in use, a database object name is qualified + with a schema. For example:

+ + 
+CREATE TABLE accounting.employee (...)
+
+SELECT ... FROM accounting.employee WHERE ...
+
+ +

In the above example accounting is the schema + and the employee table belongs to this + schema.

+ +

Not all database implementations support schemas. Some + implementation that don't support schemas (for example, + MySQL, SQLite) allow the use of the above syntax to specify + the database name. Yet others may support several levels + of qualification. For example, Microsoft SQL Server has + three levels starting with the linked database server, + followed by the database, and then followed by + the schema: + server1.company1.accounting.employee. + While the actual meaning of the qualifier in a qualified name + vary from one database implementation to another, here we + refer to all of them collectively as a schema.

+ +

In ODB, a schema for a table of a persistent class can be + specified at the class level, C++ namespace level, or the + file level. To assign a schema to a specific persistent class + we can use the schema specifier, for example:

+ + 
+#pragma db object schema("accounting")
+class employee
+{
+  ...
+};
+
+ +

If we are also assigning a table name, then we can use + a shorter notation by specifying both the schema and + the table name in the table specifier:

+ + 
+#pragma db object table("accounting.employee")
+class employee
+{
+  ...
+};
+
+ +

If we want to assign a schema to all the persistent classes + in a C++ namespace, then, instead of specifying the schema + for each class, we can specify it once at the C++ namespace level. + For example:

+ + 
+#pragma db namespace schema("accounting")
+namespace accounting
+{
+  #pragma db object
+  class employee
+  {
+    ...
+  };
+
+  #pragma db object
+  class employer
+  {
+    ...
+  };
+}
+
+ +

If we want to assign a schema to all the persistent classes in + a file, then we can use the --schema ODB compiler + option. For example:

+ + 
+odb ... --schema accounting ...
+
+ +

An alternative to this approach with the same effect is to + assign a schema to the global namespace:

+ + 
+#pragma db namespace() schema("accounting")
+
+ +

By default schema qualifications are accumulated starting from + the persistent class, continuing with the namespace hierarchy + to which this class belongs, and finishing with the schema + specified with the --schema option. For + example:

+ + 
+#pragma db namespace schema("audit_db")
+namespace audit
+{
+  #pragma db namespace schema("accounting")
+  namespace accounting
+  {
+    #pragma db object
+    class employee
+    {
+      ...
+    };
+  }
+}
+
+ +

If we compile the above code fragment with the + --schema server1 option, then the + employee table will have the + server1.audit_db.accounting.employee qualified + name.

+ +

In some situations we may want to prevent such accumulation + of the qualifications. To accomplish this we can use the + so-called fully-qualified names, which have the empty leading + name component. This is analogous to the C++ fully-qualified + names in the ::accounting::employee form. For + example:

+ + 
+#pragma db namespace schema("accounting")
+namespace accounting
+{
+  #pragma db object schema(".hr")
+  class employee
+  {
+    ...
+  };
+
+  #pragma db object
+  class employer
+  {
+    ...
+  };
+}
+
+ +

In the above code fragment, the employee table will + have the hr.employee qualified name while the + employer — accounting.employer. + Note also that the empty leading name component is a special + ODB syntax and is not propagated to the actual database names + (using a name like .hr.employee to refer to a table + will most likely result in an error).

+ +

Auxiliary database objects for a persistent class, such as indexes, + sequences, triggers, etc., are all created in the same schema + as the class table. By default, this is also true for the + container tables. However, if you need to store a container + table in a different schema, then you can provide a qualified + name using the table specifier, for example:

+ + 
+#pragma db object table("accounting.employee")
+class employee
+{
+  ...
+
+  #pragma db object table("operations.projects")
+  std::vector<std::string> projects_;
+};
+
+ +

The standard syntax for qualified names used in the + schema and table specifiers as well + as the view column specifier (Section + 14.4.10, "column (view)") has the + "name.name..." + form where, as discussed above, the leading name component + can be empty to denote a fully qualified name. This form, however, + doesn't work if one of the name components contains periods. To + support such cases the alternative form is available: + "name"."name"... + For example:

+ + 
+#pragma db object table("accounting_1.2"."employee")
+class employee
+{
+  ...
+};
+
+ +

Finally, to specify an unqualified name that contains periods + we can use the following special syntax:

+ + 
+#pragma db object schema(."accounting_1.2") table("employee")
+class employee
+{
+  ...
+};
+
+ +

Table prefixes (Section 14.5.2, "table") + can be used as an alternative to database schemas if the target + database system does not support schemas.

+ +

14.1.9 polymorphic

+ +

The polymorphic specifier specifies that the persistent + class is polymorphic. For more information on polymorphism support, + refer to Chapter 8, "Inheritance".

+ +

14.1.10 session

+ +

The session specifier specifies whether to enable + session support for the persistent class. For example:

+ + 
+#pragma db object session        // Enable.
+class person
+{
+  ...
+};
+
+#pragma db object session(true)  // Enable.
+class employee
+{
+  ...
+};
+
+#pragma db object session(false) // Disable.
+class employer
+{
+  ...
+};
+
+ +

Session support is disabled by default unless the + --generate-session ODB compiler option is specified + or session support is enabled at the namespace level + (Section 14.5.4, "session"). + For more information on sessions, refer to Chapter + 11, "Session".

+ +

14.1.11 definition

+ +

The definition specifier specifies an alternative + definition location for the persistent class. By + default, the ODB compiler generates the database support code for + a persistent class when we compile the header file that + defines this class. However, if the definition + specifier is used, then the ODB compiler will instead generate + the database support code when we compile the header file + containing this pragma.

+ +

For more information on this functionality, refer to + Section 14.3.7, "definition".

+ +

14.1.12 transient

+ +

The transient specifier instructs the ODB compiler to + treat all non-virtual data members in the persistent class as transient + (Section 14.4.1, "transient"). + This specifier is primarily useful when declaring virtual data + members, as discussed in Section 14.4.13, + "virtual".

+ +

14.1.13 sectionable

+ +

The sectionable specifier instructs the ODB compiler + to generate support for the addition of new object sections in + derived classes in a hierarchy with the optimistic concurrency + model. For more information on this functionality, refer to + Section 9.2, "Sections and Optimistic + Concurrency".

+ +

14.1.14 deleted

+ +

The deleted specifier marks the persistent class as + soft-deleted. The single required argument to this specifier is + the deletion version. For more information on this functionality, + refer to Section 13.4, "Soft Object Model + Changes".

+ +

14.1.15 bulk

+ +

The bulk specifier enables bulk operation support for + the persistent class. The single required argument to this specifier + is the batch size. For more information on this functionality, refer + to Section 15.3, "Bulk Database Operations".

+ +

14.2 View Type Pragmas

+ +

A pragma with the view qualifier declares a C++ class + as a view type. The qualifier can be optionally followed, + in any order, by one or more specifiers summarized in the + table below:

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpecifierSummarySection
objectobject associated with a view14.2.1
tabletable associated with a view14.2.2
queryview query condition14.2.3
pointerpointer type for a view14.2.4
callbackdatabase operations callback14.2.5
definitiondefinition location for a view14.2.6
transientall non-virtual data members in a view are transient14.2.7
+ +

For more information on view types refer to Chapter 10, + "Views".

+ +

14.2.1 object

+ +

The object specifier specifies a persistent class + that should be associated with the view. For more information + on object associations refer to Section 10.1, "Object + Views".

+ +

14.2.2 table

+ +

The table specifier specifies a database table + that should be associated with the view. For more information + on table associations refer to Section 10.3, "Table + Views".

+ +

14.2.3 query

+ +

The query specifier specifies a query condition + and, optionally, result modifiers for an object or table view + or a native SQL query for a native view. An empty query + specifier indicates that a native SQL query is provided at runtime. + For more information on query conditions refer to + Section 10.5, "View Query Conditions". For + more information on native SQL queries, refer to + Section 10.6, "Native Views".

+ +

14.2.4 pointer

+ +

The pointer specifier specifies the view pointer type + for the view class. Similar to objects, the view pointer type is used + to return dynamically allocated instances of a view class. The + semantics of the pointer specifier for a view are the + same as those of the pointer specifier for an object + (Section 14.1.2, "pointer").

+ +

14.2.5 callback

+ +

The callback specifier specifies the view class + member function that should be called before and after an + instance of this view class is created as part of the query + result iteration. The semantics of the callback + specifier for a view are similar to those of the + callback specifier for an object + (Section 14.1.7, "callback") + except that the only events that can trigger a callback + call in the case of a view are pre_load and + post_load.

+ +

14.2.6 definition

+ +

The definition specifier specifies an alternative + definition location for the view class. By + default, the ODB compiler generates the database support code for + a view class when we compile the header file that + defines this class. However, if the definition + specifier is used, then the ODB compiler will instead generate + the database support code when we compile the header file + containing this pragma.

+ +

For more information on this functionality, refer to + Section 14.3.7, "definition".

+ +

14.2.7 transient

+ +

The transient specifier instructs the ODB compiler + to treat all non-virtual data members in the view class as transient + (Section 14.4.1, "transient"). + This specifier is primarily useful when declaring virtual data + members, as discussed in Section 14.4.13, + "virtual".

+ +

14.3 Value Type Pragmas

+ +

A pragma with the value qualifier describes a value + type. It can be optionally followed, in any order, by one or more + specifiers summarized in the table below:

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpecifierSummarySection
typedatabase type for a value type14.3.1
id_typedatabase type for a value type when used as an object id14.3.2
null/not_nulltype can/cannot be NULL14.3.3
defaultdefault value for a value type14.3.4
optionsdatabase options for a value type14.3.5
readonlycomposite value type is read-only14.3.6
definitiondefinition location for a composite value type14.3.7
transientall non-virtual data members in a composite value are transient14.3.8
unorderedordered container should be stored unordered14.3.9
index_typedatabase type for a container's index type14.3.10
key_typedatabase type for a container's key type14.3.11
value_typedatabase type for a container's value type14.3.12
value_null/value_not_nullcontainer's value can/cannot be NULL14.3.13
id_optionsdatabase options for a container's id column14.3.14
index_optionsdatabase options for a container's index column14.3.15
key_optionsdatabase options for a container's key column14.3.16
value_optionsdatabase options for a container's value column14.3.17
id_columncolumn name for a container's object id14.3.18
index_columncolumn name for a container's index14.3.19
key_columncolumn name for a container's key14.3.20
value_columncolumn name for a container's value14.3.21
+ +

Many of the value type specifiers have corresponding member type + specifiers with the same names (Section 14.4, + "Data Member Pragmas"). The behavior of such specifiers + for members is similar to that for value types. The only difference + is the scope. A particular value type specifier applies to all the + members of this value type that don't have a pre-member version + of the specifier, while the member specifier always applies only + to a single member. Also, with a few exceptions, member specifiers + take precedence over and override parameters specified with value + specifiers.

+ +

14.3.1 type

+ +

The type specifier specifies the native database type + that should be used for data members of this type. For example:

+ + 
+#pragma db value(bool) type("INT")
+
+#pragma db object
+class person
+{
+  ...
+
+  bool married_; // Mapped to INT NOT NULL database type.
+};
+
+ +

The ODB compiler provides the default mapping between common C++ + types, such as bool, int, and + std::string and the database types for each supported + database system. For more information on the default mapping, + refer to Part II, "Database Systems". The + null and not_null (Section + 14.3.3, "null/not_null") specifiers + can be used to control the NULL semantics of a type.

+ +

In the above example we changed the mapping for the bool + type which is now mapped to the INT database type. In + this case, the value pragma is all that is necessary + since the ODB compiler will be able to figure out how to store + a boolean value as an integer in the database. However, there + could be situations where the ODB compiler will not know how to + handle the conversion between the C++ and database representations + of a value. Consider, as an example, a situation where the + boolean value is stored in the database as a string:

+ + 
+#pragma db value(bool) type("VARCHAR(5)")
+
+ +

The possible database values for the C++ true value could + be "true", or "TRUE", or "True". + Or, maybe, all of the above could be valid. The ODB compiler has no way + of knowing how your application wants to convert bool + to a string and back. To support such custom value type mappings, + ODB allows you to provide your own database conversion functions + by specializing the value_traits class template. The + mapping example in the odb-examples + package shows how to do this for all the supported database systems.

+ +

14.3.2 id_type

+ +

The id_type specifier specifies the native database type + that should be used for data members of this type that are designated as + object identifiers (Section 14.4.1, + "id"). In combination with the type + specifier (Section 14.3.1, "type") + id_type allows you to map a C++ type differently depending + on whether it is used in an ordinary member or an object id. For + example:

+ + 
+#pragma db value(std::string) type("TEXT") id_type("VARCHAR(128)")
+
+#pragma db object
+class person
+{
+  ...
+
+  #pragma db id
+  std::string email_; // Mapped to VARCHAR(128) NOT NULL.
+
+  std::string name_;  // Mapped to TEXT NOT NULL.
+};
+
+ +

Note that there is no corresponding member type specifier for + id_type since the desired result can be achieved + with just the type specifier, for example:

+ + 
+#pragma db object
+class person
+{
+  ...
+
+  #pragma db id type("VARCHAR(128)")
+  std::string email_;
+};
+
+ +

14.3.3 null/not_null

+ +

The null and not_null specifiers specify that + a value type or object pointer can or cannot be NULL, + respectively. By default, value types are assumed not to allow + NULL values while object pointers are assumed to + allow NULL values. Data members of types that allow + NULL values are mapped in a relational database to + columns that allow NULL values. For example:

+ + 
+using std::tr1::shared_ptr;
+
+typedef shared_ptr<std::string> string_ptr;
+#pragma db value(string_ptr) type("TEXT") null
+
+#pragma db object
+class person
+{
+  ...
+
+  string_ptr name_; // Mapped to TEXT NULL.
+};
+
+typedef shared_ptr<person> person_ptr;
+#pragma db value(person_ptr) not_null
+
+ +

The NULL semantics can also be specified on the + per-member basis (Section 14.4.6, + "null/not_null"). If both a type and + a member have null/not_null specifiers, + then the member specifier takes precedence. If a member specifier + relaxes the NULL semantics (that is, if a member has + the null specifier and the type has the explicit + not_null specifier), then a warning is issued.

+ +

It is also possible to override a previously specified + null/not_null specifier. This is + primarily useful if a third-party type, for example, + one provided by a profile library (Part III, + "Profiles"), allows NULL values but in your + object model data members of this type should never be + NULL. In this case you can use the not_null + specifier to disable NULL values for this type for the + entire translation unit. For example:

+ + 
+// By default, null_string allows NULL values.
+//
+#include <null-string.hxx>
+
+// Disable NULL values for all the null_string data members.
+//
+#pragma db value(null_string) not_null
+
+ +

For a more detailed discussion of the NULL semantics + for values, refer to Section 7.3, "Pointers and + NULL Value Semantics". For a more detailed + discussion of the NULL semantics for object pointers, + refer to Chapter 6, "Relationships".

+ +

14.3.4 default

+ +

The default specifier specifies the database default value + that should be used for data members of this type. For example:

+ + 
+#pragma db value(std::string) default("")
+
+#pragma db object
+class person
+{
+  ...
+
+  std::string name_; // Mapped to TEXT NOT NULL DEFAULT ''.
+};
+
+ +

The semantics of the default specifier for a value type + are similar to those of the default specifier for a + data member (Section 14.4.7, + "default").

+ +

14.3.5 options

+ +

The options specifier specifies additional column + definition options that should be used for data members of this + type. For example:

+ + 
+#pragma db value(std::string) options("COLLATE binary")
+
+#pragma db object
+class person
+{
+  ...
+
+  std::string name_; // Mapped to TEXT NOT NULL COLLATE binary.
+};
+
+ +

The semantics of the options specifier for a value type + are similar to those of the options specifier for a + data member (Section 14.4.8, + "options").

+ +

14.3.6 readonly

+ +

The readonly specifier specifies that the composite + value type is read-only. Changes to data members of a read-only + composite value type are ignored when updating the database + state of an object (Section 3.10, "Updating Persistent + Objects") containing such a value type. Note that this specifier + is only valid for composite value types. For example:

+ + 
+#pragma db value readonly
+class person_name
+{
+  ...
+};
+
+ +

Read-only and read-write composite values can derive from each other + without any restrictions. When a read-only value derives from a + read-write value, the resulting whole value is read-only, including + the part corresponding to the read-write base. On the other hand, when a + read-write value derives from a read-only value, all the data + members that correspond to the read-only base are treated as + read-only while the rest is treated as read-write.

+ +

Note that it is also possible to declare individual data members + (Section 14.4.12, "readonly") + as well as whole objects (Section 14.1.4, + "readonly") as read-only.

+ +

14.3.7 definition

+ +

The definition specifier specifies an alternative + definition location for the composite value type. By + default, the ODB compiler generates the database support code for + a composite value type when we compile the header file that + defines this value type. However, if the definition + specifier is used, then the ODB compiler will instead generate + the database support code when we compile the header file containing + this pragma.

+ +

This mechanism is primarily useful for converting third-party + types to ODB composite value types. In such cases we normally + cannot modify the header files to add the necessary pragmas. + It is also often inconvenient to compile these header files + with the ODB compiler. With the definition + specifier we can create a wrapper header that contains + the necessary pragmas and instructs the ODB compiler to generate + the database support code for a third-party type when we compile + the wrapper header. As an example, consider struct timeval + that is defined in the <sys/time.h> system header. + This type has the following (or similar) definition:

+ + 
+struct timeval
+{
+  long tv_sec;
+  long tv_usec;
+};
+
+ +

If we would like to make this type an ODB composite value type, + then we can create a wrapper header, for example + time-mapping.hxx, with the following content:

+ + 
+#ifndef TIME_MAPPING_HXX
+#define TIME_MAPPING_HXX
+
+#include <sys/time.h>
+
+#pragma db value(timeval) definition
+#pragma db member(timeval::tv_sec) column("sec")
+#pragma db member(timeval::tv_usec) column("usec")
+
+#endif // TIME_MAPPING_HXX
+
+ +

If we now compile this header with the ODB compiler, the + resulting time-mapping-odb.?xx files will + contain the database support code for struct timeval. + To use timeval in our persistent classes, we simply + include the time-mapping.hxx header:

+ + 
+#include <sys/time.h>
+#include "time-mapping.hxx"
+
+#pragma db object
+class object
+{
+  timeval timestamp;
+};
+
+ +

14.3.8 transient

+ +

The transient specifier instructs the ODB compiler + to treat all non-virtual data members in the composite value type + as transient (Section 14.4.1, + "transient"). This specifier is primarily useful + when declaring virtual data members, as discussed in + Section 14.4.13, "virtual".

+ +

14.3.9 unordered

+ +

The unordered specifier specifies that the ordered + container should be stored unordered in the database. The database + table for such a container will not contain the index column + and the order in which elements are retrieved from the database may + not be the same as the order in which they were stored. For example:

+ + 
+typedef std::vector<std::string> names;
+#pragma db value(names) unordered
+
+ +

For a more detailed discussion of ordered containers and their + storage in the database, refer to Section 5.1, + "Ordered Containers".

+ +

14.3.10 index_type

+ +

The index_type specifier specifies the native + database type that should be used for the ordered container's + index column. The semantics of index_type + are similar to those of the type specifier + (Section 14.3.1, "type"). The native + database type is expected to be an integer type. For example:

+ + 
+typedef std::vector<std::string> names;
+#pragma db value(names) index_type("SMALLINT UNSIGNED")
+
+ +

14.3.11 key_type

+ +

The key_type specifier specifies the native + database type that should be used for the map container's + key column. The semantics of key_type + are similar to those of the type specifier + (Section 14.3.1, "type"). For + example:

+ + 
+typedef std::map<unsigned short, float> age_weight_map;
+#pragma db value(age_weight_map) key_type("INT UNSIGNED")
+
+ +

14.3.12 value_type

+ +

The value_type specifier specifies the native + database type that should be used for the container's + value column. The semantics of value_type + are similar to those of the type specifier + (Section 14.3.1, "type"). For + example:

+ + 
+typedef std::vector<std::string> names;
+#pragma db value(names) value_type("VARCHAR(255)")
+
+ +

The value_null and value_not_null + (Section 14.3.13, + "value_null/value_not_null") specifiers + can be used to control the NULL semantics of a value + column.

+ +

14.3.13 value_null/value_not_null

+ +

The value_null and value_not_null specifiers + specify that the container type's element value can or cannot be + NULL, respectively. The semantics of value_null + and value_not_null are similar to those of the + null and not_null specifiers + (Section 14.3.3, "null/not_null"). + For example:

+ + 
+using std::tr1::shared_ptr;
+
+#pragma db object
+class account
+{
+  ...
+};
+
+typedef std::vector<shared_ptr<account> > accounts;
+#pragma db value(accounts) value_not_null
+
+ +

For set and multiset containers (Section 5.2, "Set and + Multiset Containers") the element value is automatically treated + as not allowing a NULL value.

+ + +

14.3.14 id_options

+ +

The id_options specifier specifies additional + column definition options that should be used for the container's + id column. For example:

+ + 
+typedef std::vector<std::string> nicknames;
+#pragma db value(nicknames) id_options("COLLATE binary")
+
+ +

The semantics of the id_options specifier for a container + type are similar to those of the id_options specifier for + a container data member (Section 14.4.29, + "id_options").

+ + +

14.3.15 index_options

+ +

The index_options specifier specifies additional + column definition options that should be used for the container's + index column. For example:

+ + 
+typedef std::vector<std::string> nicknames;
+#pragma db value(nicknames) index_options("ZEROFILL")
+
+ +

The semantics of the index_options specifier for a container + type are similar to those of the index_options specifier for + a container data member (Section 14.4.30, + "index_options").

+ + +

14.3.16 key_options

+ +

The key_options specifier specifies additional + column definition options that should be used for the container's + key column. For example:

+ + 
+typedef std::map<std::string, std::string> properties;
+#pragma db value(properties) key_options("COLLATE binary")
+
+ +

The semantics of the key_options specifier for a container + type are similar to those of the key_options specifier for + a container data member (Section 14.4.31, + "key_options").

+ + +

14.3.17 value_options

+ +

The value_options specifier specifies additional + column definition options that should be used for the container's + value column. For example:

+ + 
+typedef std::set<std::string> nicknames;
+#pragma db value(nicknames) value_options("COLLATE binary")
+
+ +

The semantics of the value_options specifier for a container + type are similar to those of the value_options specifier for + a container data member (Section 14.4.32, + "value_options").

+ + +

14.3.18 id_column

+ +

The id_column specifier specifies the column + name that should be used to store the object id in the + container's table. For example:

+ + 
+typedef std::vector<std::string> names;
+#pragma db value(names) id_column("id")
+
+ +

If the column name is not specified, then object_id + is used by default.

+ +

14.3.19 index_column

+ +

The index_column specifier specifies the column + name that should be used to store the element index in the + ordered container's table. For example:

+ + 
+typedef std::vector<std::string> names;
+#pragma db value(names) index_column("name_number")
+
+ +

If the column name is not specified, then index + is used by default.

+ +

14.3.20 key_column

+ +

The key_column specifier specifies the column + name that should be used to store the key in the map + container's table. For example:

+ + 
+typedef std::map<unsigned short, float> age_weight_map;
+#pragma db value(age_weight_map) key_column("age")
+
+ +

If the column name is not specified, then key + is used by default.

+ +

14.3.21 value_column

+ +

The value_column specifier specifies the column + name that should be used to store the element value in the + container's table. For example:

+ + 
+typedef std::map<unsigned short, float> age_weight_map;
+#pragma db value(age_weight_map) value_column("weight")
+
+ +

If the column name is not specified, then value + is used by default.

+ + + + +

14.4 Data Member Pragmas

+ +

A pragma with the member qualifier or a positioned + pragma without a qualifier describes a data member. It can + be optionally followed, in any order, by one or more specifiers + summarized in the table below:

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpecifierSummarySection
idmember is an object id14.4.1
autoid is assigned by the database14.4.2
typedatabase type for a member14.4.3
id_typedatabase type for a member when used as an object id14.4.4
get/set/accessmember accessor/modifier expressions14.4.5
null/not_nullmember can/cannot be NULL14.4.6
defaultdefault value for a member14.4.7
optionsdatabase options for a member14.4.8
columncolumn name for a member of an object or composite value14.4.9
columncolumn name for a member of a view14.4.10
transientmember is not stored in the database14.4.11
readonlymember is read-only14.4.12
virtualdeclare a virtual data member14.4.13
inversemember is an inverse side of a bidirectional relationship14.4.14
on_deleteON DELETE clause for object pointer member14.4.15
versionmember stores object version14.4.16
indexdefine database index for a member14.4.17
uniquedefine unique database index for a member14.4.18
unorderedordered container should be stored unordered14.4.19
tabletable name for a container14.4.20
load/updateloading/updating behavior for a section14.4.21
sectionmember belongs to a section14.4.22
addedmember is soft-added14.4.23
deletedmember is soft-deleted14.4.24
index_typedatabase type for a container's index type14.4.25
key_typedatabase type for a container's key type14.4.26
value_typedatabase type for a container's value type14.4.27
value_null/value_not_nullcontainer's value can/cannot be NULL14.4.28
id_optionsdatabase options for a container's id column14.4.29
index_optionsdatabase options for a container's index column14.4.30
key_optionsdatabase options for a container's key column14.4.31
value_optionsdatabase options for a container's value column14.4.32
id_columncolumn name for a container's object id14.4.33
index_columncolumn name for a container's index14.4.34
key_columncolumn name for a container's key14.4.35
value_columncolumn name for a container's value14.4.36
+ +

Many of the member specifiers have corresponding value type + specifiers with the same names (Section 14.3, + "Value Type Pragmas"). The behavior of such specifiers + for members is similar to that for value types. The only difference + is the scope. A particular value type specifier applies to all the + members of this value type that don't have a pre-member version + of the specifier, while the member specifier always applies only + to a single member. Also, with a few exceptions, member specifiers + take precedence over and override parameters specified with value + specifiers.

+ +

14.4.1 id

+ +

The id specifier specifies that the data member contains + the object id. In a relational database, an identifier member is + mapped to a primary key. For example:

+ + 
+#pragma db object
+class person
+{
+  ...
+
+  #pragma db id
+  std::string email_;
+};
+
+ +

Normally, every persistent class has a data member designated as an + object's identifier. However, it is possible to declare a + persistent class without an id using the object no_id + specifier (Section 14.1.6, "no_id").

+ +

Note also that the id specifier cannot be used for data + members of composite value types or views.

+ +

14.4.2 auto

+ +

The auto specifier specifies that the object's identifier + is automatically assigned by the database. Only a member that was + designated as an object id can have this specifier. For example:

+ + 
+#pragma db object
+class person
+{
+  ...
+
+  #pragma db id auto
+  unsigned long id_;
+};
+
+ +

Note that automatically-assigned object ids are not reused. + If you have a high object turnover (that is, objects are routinely + made persistent and then erased), then care must be taken not to + run out of object ids. In such situations, using + unsigned long long as the identifier type + is a safe choice.

+ +

For additional information on the automatic identifier assignment, + refer to Section 3.8, "Making Objects Persistent".

+ +

Note also that the auto specifier cannot be specified + for data members of composite value types or views.

+ +

14.4.3 type

+ +

The type specifier specifies the native database type + that should be used for the data member. For example:

+ + 
+#pragma db object
+class person
+{
+  ...
+
+  #pragma db type("INT")
+  bool married_;
+};
+
+ +

The null and not_null (Section + 14.4.6, "null/not_null") specifiers + can be used to control the NULL semantics of a data member. + It is also possible to specify the database type on the per-type instead + of the per-member basis using the value type + specifier (Section 14.3.1, "type").

+ +

14.4.4 id_type

+ +

The id_type specifier specifies the native database type + that should be used for the data member when it is part of an + object identifier. This specifier only makes sense when applied to + a member of a composite value type that is used for both id and + non-id members. For example:

+ + 
+#pragma db value
+class name
+{
+  ...
+
+  #pragma db type("VARCHAR(256)") id_type("VARCHAR(64)")
+  std::string first_;
+
+  #pragma db type("VARCHAR(256)") id_type("VARCHAR(64)")
+  std::string last_;
+};
+
+#pragma db object
+class person
+{
+  ...
+
+  #pragma db id
+  name name_;  // name_.first_, name_.last_ mapped to VARCHAR(64)
+
+  name alias_; // alias_.first_, alias_.last_ mapped to VARCHAR(256)
+};
+
+ +

14.4.5 get/set/access

+ +

The get and set specifiers specify the + data member accessor and modifier expressions, respectively. If + provided, the generated database support code will use these + expressions to access and modify the data member when performing + database operations. The access specifier can be used + as a shortcut to specify both the accessor and modifier if they + happen to be the same.

+ +

In its simplest form the accessor or modifier expression can be + just a name. Such a name should resolve either to another data + member of the same type or to a suitable accessor or modifier + member function. For example:

+ + 
+#pragma db object
+class person
+{
+  ...
+
+public:
+  const std::string& name () const;
+  void name (const std::string&);
+private:
+  #pragma db access(name)
+  std::string name_;
+};
+
+ +

A suitable accessor function is a const member function + that takes no arguments and whose return value can be implicitly + converted to the const reference to the member type + (const std::string& in the example above). + An accessor function that returns a const reference + to the data member is called by-reference accessor. + Otherwise, it is called by-value accessor.

+ +

A suitable modifier function can be of two forms. It can be the + so called by-reference modifier which is a member function + that takes no arguments and returns a non-const reference + to the data member (std::string& in the example above). + Alternatively, it can be the so called by-value modifier which + is a member function taking a single argument — the new value + — that can be implicitly initialized from a variable of the member + type (std::string in the example above). The return value + of a by-value modifier, if any, is ignored. If both by-reference and + by-value modifiers are available, then ODB prefers the by-reference + version since it is more efficient. For example:

+ + 
+#pragma db object
+class person
+{
+  ...
+
+public:
+  std::string get_name () const;      // By-value accessor.
+  std::string& set_name ();           // By-reference modifier.
+  void set_name (std::string const&); // By-value modifier.
+private:
+  #pragma db get(get_name) \ // Uses by-value accessor.
+             set(set_name)   // Uses by-reference modifier.
+  std::string name_;
+};
+
+ +

Note that in many cases it is not necessary to specify accessor and + modifier functions explicitly since the ODB compiler will try to + discover them automatically in case the data member will be inaccessible + to the generated code. In particular, in both of the above examples + the ODB compiler would have successfully discovered the necessary + functions. For more information on this functionality, refer to + Section 3.2, "Declaring Persistent Objects and + Values".

+ +

Note also that by-value accessors and by-value modifiers cannot be + used for certain data members in certain situations. These limitations + are discussed in more detail later in this section.

+ +

Accessor and modifier expressions can be more elaborate than simple + names. An accessor expression is any C++ expression that can be + used to initialize a const reference to the member + type. Similar to accessor functions, which are just a special case + of accessor expressions, an accessor expression that evaluates to a + const reference to the data member is called + by-reference accessor expression. Otherwise, it is + called by-value accessor expression.

+ +

Modifier expressions can also be of two forms: by-reference + modifier expression and by-value modifier expression + (again, modifier functions are just a special case of modifier + expressions). A by-reference modifier expression is any C++ + expression that evaluates to the non-const reference + to the member type. A by-value modifier expression can be a + single or multiple (separated by semicolon) C++ statements + with the effect of setting the new member value.

+ +

There are two special placeholders that are recognized by the + ODB compiler in accessor and modifier expressions. The first + is the this keyword which denotes a reference + (note: not a pointer) to the persistent object. In accessor + expressions this reference is const while in + modifier expressions it is non-const. If an + expression does not contain the this placeholder, + then the ODB compiler automatically prefixes it with this. + sequence.

+ +

The second placeholder, the (?) sequence, is used + to denote the new value in by-value modifier expressions. The + ODB compiler replaces the question mark with the variable name, + keeping the surrounding parenthesis. The following example shows + a few more interesting accessor and modifier expressions:

+ + 
+#pragma db value
+struct point
+{
+  point (int, int);
+
+  int x;
+  int y;
+};
+
+#pragma db object
+class person
+{
+  ...
+
+  public:
+    const char* name () const;
+    void name (const char*);
+  private:
+    #pragma db get(std::string (this.name ())) \
+               set(name ((?).c_str ())) // The same as this.name (...).
+    std::string name_;
+
+  public:
+    const std::unique_ptr<account>& acc () const;
+    void acc (std::unique_ptr<account>);
+  private:
+    #pragma db set(acc (std::move (?)))
+    std::unique_ptr<account> acc_;
+
+  public:
+    int loc_x () const
+    int loc_y () const
+    void loc_x (int);
+    void loc_y (int);
+  private:
+    #pragma db get(point (this.loc_x (), this.loc_y ()))    \
+               set(this.loc_x ((?).x); this.loc_y ((?).y))
+    point loc_;
+};
+
+ +

When the data member is of an array type, then the terms "reference" + and "member type" in the above discussion should be replaced with + "pointer" and "array element type", respectively. That is, the accessor + expression for an array member is any C++ expression that can be + used to initialize a const pointer to the array + element type, and so on. The following example shows common + accessor and modifier signatures for array members:

+ + 
+#pragma db object
+class person
+{
+  ...
+
+  public:
+    const char* id () const; // By-reference accessor.
+    void id (const char*);   // By-value modifier.
+  private:
+    char id_[16];
+
+  public:
+    const char* pub_key () const; // By-reference accessor.
+    char* pub_key ();             // By-reference modifier.
+  private:
+    char pub_key_[2048];
+};
+
+ +

Accessor and modifier expressions can be used with data members + of simple value, composite value, container, and object pointer + types. They can be used for data members in persistent classes, + composite value types, and views. There is also a mechanism + related to accessors and modifiers called virtual data members + and which is discussed in Section 14.4.13, + "virtual".

+ +

There are, however, certain limitations when it comes to using + by-value accessor and modifier expressions. First of all, if a + by-value modifier is used, then the data member type should be + default-constructible. Furthermore, a composite value type that + has a container member cannot be modified with a by-value modifier. + Only a by-reference modifier expression can be used. The ODB + compiler will detect such cases and issue diagnostics. For + example:

+ + 
+#pragma db value
+struct name
+{
+  std::string first_;
+  std::string last_;
+  std::vector<std::string> aliases_;
+};
+
+#pragma db object
+class person
+{
+  ...
+
+public:
+  const name& name () const;
+  void name (const name&);
+private:
+  #pragma db access(name) // Error: by-value modifier.
+  name name_;
+};
+
+ +

In certain database systems it is also not possible to use by-value + accessor and modifier expression with certain database types. + The ODB compiler is only able to detect such cases and issue diagnostics + if you specified accessor/modifier function names as opposed to custom + expressions. For more information on these database and type-specific + limitations, refer to the "Limitations" sections in Part + II, "Database Systems".

+ +

14.4.6 null/not_null

+ +

The null and not_null specifiers specify that + the data member can or cannot be NULL, respectively. + By default, data members of basic value types for which database + mapping is provided by the ODB compiler do not allow NULL + values while data members of object pointers allow NULL + values. Other value types, such as those provided by the profile + libraries (Part III, "Profiles"), may or may + not allow NULL values, depending on the semantics + of each value type. Consult the relevant documentation to find + out more about the NULL semantics for such value + types. A data member containing the object id (Section + 14.4.1, "id") is automatically treated as not + allowing a NULL value. Data members that + allow NULL values are mapped in a relational database + to columns that allow NULL values. For example:

+ + 
+using std::tr1::shared_ptr;
+
+#pragma db object
+class person
+{
+  ...
+
+  #pragma db null
+  std::string name_;
+};
+
+#pragma db object
+class account
+{
+  ...
+
+  #pragma db not_null
+  shared_ptr<person> holder_;
+};
+
+ +

The NULL semantics can also be specified on the + per-type basis (Section 14.3.3, + "null/not_null"). If both a type and + a member have null/not_null specifiers, + then the member specifier takes precedence. If a member specifier + relaxes the NULL semantics (that is, if a member has + the null specifier and the type has the explicit + not_null specifier), then a warning is issued.

+ +

For a more detailed discussion of the NULL semantics + for values, refer to Section 7.3, "Pointers and + NULL Value Semantics". For a more detailed + discussion of the NULL semantics for object pointers, + refer to Chapter 6, "Relationships".

+ +

14.4.7 default

+ +

The default specifier specifies the database default value + that should be used for the data member. For example:

+ + 
+#pragma db object
+class person
+{
+  ...
+
+  #pragma db default(-1)
+  int age_;              // Mapped to INT NOT NULL DEFAULT -1.
+};
+
+ +

A default value can be the special null keyword, + a bool literal (true or false), + an integer literal, a floating point literal, a string literal, or + an enumerator name. If you need to specify a default value that is + an expression, for example an SQL function call, then you can use + the options specifier (Section + 14.4.8, "options") instead. For example:

+ + 
+enum gender {male, female, undisclosed};
+
+#pragma db object
+class person
+{
+  ...
+
+  #pragma db default(null)
+  odb::nullable<std::string> middle_; // DEFAULT NULL
+
+  #pragma db default(false)
+  bool married_;                      // DEFAULT 0/FALSE
+
+  #pragma db default(0.0)
+  float weight_;                      // DEFAULT 0.0
+
+  #pragma db default("Mr")
+  string title_;                      // DEFAULT 'Mr'
+
+  #pragma db default(undisclosed)
+  gender gender_;                     // DEFAULT 2/'undisclosed'
+
+  #pragma db options("DEFAULT CURRENT_TIMESTAMP()")
+  date timestamp_;                    // DEFAULT CURRENT_TIMESTAMP()
+};
+
+ +

Default values specified as enumerators are only supported for + members that are mapped to an ENUM or an integer + type in the database, which is the case for the automatic + mapping of C++ enums and enum classes to suitable database + types as performed by the ODB compiler. If you have mapped + a C++ enum or enum class to another database type, then you + should use a literal corresponding to that type to specify + the default value. For example:

+ + 
+enum gender {male, female, undisclosed};
+#pragma db value(gender) type("VARCHAR(11)")
+
+#pragma db object
+class person
+{
+  ...
+
+  #pragma db default("undisclosed")
+  gender gender_;                   // DEFAULT 'undisclosed'
+};
+
+ +

A default value can also be specified on the per-type basis + (Section 14.3.4, "default"). + An empty default specifier can be used to reset + a default value that was previously specified on the per-type + basis. For example:

+ + 
+#pragma db value(std::string) default("")
+
+#pragma db object
+class person
+{
+  ...
+
+  #pragma db default()
+  std::string name_;   // No default value.
+};
+
+ +

A data member containing the object id (Section + 14.4.1, "id" ) is automatically treated as not + having a default value even if its type specifies a default value.

+ +

Note also that default values do not affect the generated C++ code + in any way. In particular, no automatic initialization of data members + with their default values is performed at any point. If you need such + an initialization, you will need to implement it yourself, for example, + in your persistent class constructors. The default values only + affect the generated database schemas and, in the context of ODB, + are primarily useful for schema evolution.

+ +

Additionally, the default specifier cannot be specified + for view data members.

+ +

14.4.8 options

+ +

The options specifier specifies additional column + definition options that should be used for the data member. For + example:

+ + 
+#pragma db object
+class person
+{
+  ...
+
+  #pragma db options("CHECK(email != '')")
+  std::string email_; // Mapped to TEXT NOT NULL CHECK(email != '').
+};
+
+ +

Options can also be specified on the per-type basis + (Section 14.3.5, "options"). + By default, options are accumulating. That is, the ODB compiler + first adds all the options specified for a value type followed + by all the options specified for a data member. To clear the + accumulated options at any point in this sequence you can use + an empty options specifier. For example:

+ + 
+#pragma db value(std::string) options("COLLATE binary")
+
+#pragma db object
+class person
+{
+  ...
+
+  std::string first_; // TEXT NOT NULL COLLATE binary
+
+  #pragma db options("CHECK(email != '')")
+  std::string last_;  // TEXT NOT NULL COLLATE binary CHECK(email != '')
+
+  #pragma db options()
+  std::string title_; // TEXT NOT NULL
+
+  #pragma db options() options("CHECK(email != '')")
+  std::string email_; // TEXT NOT NULL CHECK(email != '')
+};
+
+ +

ODB provides dedicated specifiers for specifying column types + (Section 14.4.3, "type"), + NULL constraints (Section 14.4.6, + "null/not_null"), and default + values (Section 14.4.7, "default"). + For ODB to function correctly these specifiers should always be + used instead of the opaque options specifier for + these components of a column definition.

+ +

Note also that the options specifier cannot be specified + for view data members.

+ +

14.4.9 column (object, composite value)

+ +

The column specifier specifies the column name + that should be used to store the data member of a persistent class + or composite value type in a relational database. For example:

+ + 
+#pragma db object
+class person
+{
+  ...
+
+  #pragma db id column("person_id")
+  unsigned long id_;
+};
+
+ +

For a member of a composite value type, the column specifier + specifies the column name prefix. Refer to Section 7.2.2, + "Composite Value Column and Table Names" for details.

+ +

If the column name is not specified, it is derived from the member's + so-called public name. A public member name is obtained by removing + the common data member name decorations, such as leading and trailing + underscores, the m_ prefix, etc.

+ +

14.4.10 column (view)

+ +

The column specifier can be used to specify the associated + object data member, the potentially qualified column name, or the column + expression for the data member of a view class. For more information, + refer to Section 10.1, "Object Views" and + Section 10.3, "Table Views".

+ +

14.4.11 transient

+ +

The transient specifier instructs the ODB compiler + not to store the data member in the database. For example:

+ + 
+#pragma db object
+class person
+{
+  ...
+
+  date born_;
+
+  #pragma db transient
+  unsigned short age_; // Computed from born_.
+};
+
+ +

This pragma is usually used on computed members, pointers and + references that are only meaningful in the application's + memory, as well as utility members such as mutexes, etc.

+ +

14.4.12 readonly

+ +

The readonly specifier specifies that the data member of + an object or composite value type is read-only. Changes to a read-only + data member are ignored when updating the database state of an object + (Section 3.10, "Updating Persistent Objects") + containing such a member. Since views are read-only, it is not + necessary to use this specifier for view data members. Object id + (Section 14.4.1, "id") + and inverse (Section 14.4.14, + "inverse") data members are automatically treated + as read-only and must not be explicitly declared as such. For + example:

+ + 
+#pragma db object
+class person
+{
+  ...
+
+  #pragma db readonly
+  date born_;
+};
+
+ +

Besides simple value members, object pointer, container, and composite + value members can also be declared read-only. A change of a pointed-to + object is ignored when updating the state of a read-only object + pointer. Similarly, any changes to the number or order of + elements or to the element values themselves are ignored when + updating the state of a read-only container. Finally, any changes + to the members of a read-only composite value type are also ignored + when updating the state of such a composite value.

+ +

ODB automatically treats const data members as read-only. + For example, the following person object is equivalent + to the above declaration for the database persistence purposes:

+ + 
+#pragma db object
+class person
+{
+  ...
+
+  const date born_; // Automatically read-only.
+};
+
+ +

When declaring an object pointer const, make sure to + declare the pointer as const rather than (or in addition + to) the object itself. For example:

+ + 
+#pragma db object
+class person
+{
+  ...
+
+  const person* father_; // Read-write pointer to a read-only object.
+  person* const mother_; // Read-only pointer to a read-write object.
+};
+
+ +

Note that in case of a wrapper type (Section 7.3, + "Pointers and NULL Value Semantics"), both the + wrapper and the wrapped type must be const in + order for the ODB compiler to automatically treat the data + member as read-only. For example:

+ + 
+#pragma db object
+class person
+{
+  ...
+
+  const std::auto_ptr<const date> born_;
+};
+
+ +

Read-only members are useful when dealing with + asynchronous changes to the state of a data member in the + database which should not be overwritten. In other cases, + where the state of a data member never changes, declaring such a member + read-only allows ODB to perform more efficient object updates. + In such cases, however, it is conceptually more correct to + declare such a data member as const rather than + as read-only.

+ +

Note that it is also possible to declare composite value types + (Section 14.3.6, "readonly") + as well as whole objects (Section 14.1.4, + "readonly") as read-only.

+ +

14.4.13 virtual

+ +

The virtual specifier is used to declare a virtual + data member in an object, view, or composite value type. A virtual + data member is an imaginary data member that is only + used for the purpose of database persistence. A virtual data + member does not actually exist (that is, occupy space) in the + C++ class. Note also that virtual data members have nothing to + do with C++ virtual functions or virtual inheritance. Specifically, + no virtual function call overhead is incurred when using virtual + data members.

+ +

To declare a virtual data member we must specify the data + member name using the member specifier. We must + also specify the data member type with the virtual + specifier. Finally, the virtual data member declaration must + also specify the accessor and modifier expressions, unless + suitable accessor and modifier functions can automatically be + found by the ODB compiler (Section 14.4.5, + "get/set/access"). + For example:

+ + 
+#pragma db object
+class person
+{
+  ...
+
+  // Transient real data member that actually stores the data.
+  //
+  #pragma db transient
+  std::string name_;
+
+  // Virtual data member.
+  //
+  #pragma db member(name) virtual(std::string) access(name_)
+};
+
+ +

From the pragma language point of view, a virtual data member + behaves exactly like a normal data member. Specifically, we + can reference the virtual data member after it has been + declared and use positioned pragmas before its declaration. + For example:

+ + 
+#pragma db object
+class person
+{
+  ...
+
+  #pragma db transient
+  std::string name_;
+
+  #pragma db access(name_)
+  #pragma db member(name) virtual(std::string)
+};
+
+#pragma db member(person::name) column("person_name")
+#pragma db index member(person::name)
+
+ +

We can also declare a virtual data member outside the class + scope:

+ + 
+#pragma db object
+class person
+{
+  ...
+
+  std::string name_;
+};
+
+#pragma db member(person::name_) transient
+#pragma db member(person::name) virtual(std::string) access(name_)
+
+ +

While in the above examples using virtual data members doesn't + seem to yield any benefits, this mechanism can be useful in a + number of situations. As one example, consider the need to + aggregate or dis-aggregate a data member:

+ + 
+#pragma db object
+class person
+{
+  ...
+
+  #pragma db transient
+  std::pair<std::string, std::string> name_;
+
+  #pragma db member(first) virtual(std::string) access(name_.first)
+  #pragma db member(last) virtual(std::string) access(name_.second)
+};
+
+ +

We can also use virtual data members to implement composite + object ids that are spread over multiple data members:

+ + 
+#pragma db value
+struct name
+{
+  name () {}
+  name (std::string const& f, std::string const& l)
+    : first (f), last(l) {}
+
+  std::string first;
+  std::string last;
+};
+
+#pragma db object
+class person
+{
+  ...
+
+  #pragma db transient
+  std::string first_;
+
+  #pragma db transient
+  std::string last_;
+
+  #pragma db member(name) virtual(name) id                       \
+             get(::name (this.first_, this.last_))               \
+             set(this.first_ = (?).first; this.last_ = (?).last)
+};
+
+ +

Another common situation that calls for virtual data members is + a class that uses the pimpl idiom. While the following code + fragment outlines the idea, for details refer to the + pimpl example in the odb-examples + package.

+ + 
+#pragma db object
+class person
+{
+public:
+  std::string const& name () const;
+  void name (std::string const&);
+
+  unsigned short age () const;
+  void age (unsigned short);
+
+  ...
+
+private:
+  class impl;
+
+  #pragma db transient
+  impl* pimpl_;
+
+  #pragma db member(name) virtual(std::string)   // Uses name().
+  #pragma db member(age) virtual(unsigned short) // Uses age().
+};
+
+ +

The above example also shows that names used for virtual data + members (name and age in our case) can + be the same as the names of accessor/modifier functions. The only + names that virtual data members cannot clash with are those of + other data members, virtual or real.

+ +

A common pattern in the above examples is the need to + declare the real data member that actually stores the + data as transient. If all the real data members in a + class are treated as transient, then we can use the + class-level transient specifier + (Section 14.1.12, "transient + (object)", + Section 14.3.8, "transient + (composite value)", + Section 14.2.7, "transient + (view)") + instead of doing it for each individual member. For example:

+ + 
+#pragma db object transient
+class person
+{
+  ...
+
+  std::string first_; // Transient.
+  std::string last_;  // Transient.
+
+  #pragma db member(name) virtual(name) ...
+};
+
+ +

The ability to treat all the real data members as transient + becomes more important if we don't know the names of these + data members. This is often the case when we are working + with third-party types that document the accessor and + modifier functions but not the names of their private data + members. As an example, consider the point class + defined in a third-party <point> header file:

+ + 
+class point
+{
+public:
+  point ();
+  point (int x, int y);
+
+  int x () const;
+  int y () const;
+
+  void x (int);
+  void y (int);
+
+private:
+  ...
+};
+
+ +

To convert this class to an ODB composite value type we could + create the point-mapping.hxx file with the following + content:

+ + 
+#include <point>
+
+#pragma db value(point) transient definition
+#pragma db member(point::x) virtual(int)
+#pragma db member(point::y) virtual(int)
+
+ +

Virtual data members can be of simple value, composite value, + container, or object pointer types. They can be used in persistent + classes, composite value types, and views.

+ +

14.4.14 inverse

+ +

The inverse specifier specifies that the data member of + an object pointer or a container of object pointers type is an + inverse side of a bidirectional object relationship. The single + required argument to this specifier is the corresponding data + member name in the referenced object. For example:

+ + 
+using std::tr1::shared_ptr;
+using std::tr1::weak_ptr;
+
+class person;
+
+#pragma db object pointer(shared_ptr)
+class employer
+{
+  ...
+
+  std::vector<shared_ptr<person> > employees_;
+};
+
+#pragma db object pointer(shared_ptr)
+class person
+{
+  ...
+
+  #pragma db inverse(employee_)
+  weak_ptr<employer> employer_;
+};
+
+ +

An inverse member does not have a corresponding column or, in case + of a container, table in the resulting database schema. Instead, the + column or table from the referenced object is used to retrieve the + relationship information. Only ordered and set containers can be used + for inverse members. If an inverse member is of an ordered container + type, it is automatically marked as unordered + (Section 14.4.19, "unordered").

+ +

For a more detailed discussion of inverse members, refer to + Section 6.2, "Bidirectional Relationships".

+ +

14.4.15 on_delete

+ +

The on_delete specifier specifies the on-delete semantics + for a data member of an object pointer or a container of object + pointers type. The single required argument to this specifier must + be either cascade or set_null.

+ +

The on_delete specifier is translated directly to the + corresponding ON DELETE SQL clause. That is, if + cascade is specified, then when a pointed-to object + is erased from the database, the database state of the pointing + object is automatically erased as well. If set_null is + specified, then when a pointed-to object is erased from the database, + the database state of the pointing object is automatically updated + to set the pointer column to NULL. For example:

+ + 
+#pragma db object
+class employer
+{
+  ...
+
+  #pragma db id auto
+  unsigned long id_;
+};
+
+#pragma db object
+class person
+{
+  ...
+
+  #pragma db on_delete(cascade)
+  employer* employer_;
+};
+
+unsigned long id;
+
+{
+  employer e;
+  person p;
+  p.employer_ = &e;
+
+  transaction t (db.begin ());
+
+  id = db.persist (e);
+  db.persist (p);
+
+  t.commit ();
+}
+
+{
+  transaction t (db.begin ());
+
+  // Database state of the person object is erased as well.
+  //
+  db.erase<employer> (id);
+
+  t.commit ();
+}
+
+ + +

Note that this is a database-level functionality and care must be + taken in order not to end up with inconsistent object states in the + application's memory and database. The following example illustrates + the kind of problems one may encounter:

+ + 
+#pragma db object
+class employer
+{
+  ...
+};
+
+#pragma db object
+class person
+{
+  ...
+
+  #pragma db on_delete(set_null)
+  employer* employer_;
+};
+
+employer e;
+person p;
+p.employer_ = &e;
+
+{
+  transaction t (db.begin ());
+  db.persist (e);
+  db.persist (p);
+  t.commit ();
+}
+
+{
+  transaction t (db.begin ());
+
+  // The employer column is set to NULL in the database but
+  // not the p.employer_ data member in the application.
+  //
+  db.erase (e);
+  t.commit ();
+}
+
+{
+  transaction t (db.begin ());
+
+  // Override the employer column with an invalid pointer.
+  //
+  db.update (p);
+
+  t.commit ();
+}
+
+ +

Note that even optimistic concurrency will not resolve such + issues unless you are using database-level support for optimistic + concurrency as well (for example, ROWVERSION in SQL + Server).

+ +

The on_delete specifier is only valid for non-inverse + object pointer data members. If the set_null semantics + is used, then the pointer must allow the NULL value.

+ +

14.4.16 version

+ +

The version specifier specifies that the data member stores + the object version used to support optimistic concurrency. If a class + has a version data member, then it must also be declared as having the + optimistic concurrency model using the optimistic pragma + (Section 14.1.5, "optimistic"). For + example:

+ + 
+#pragma db object optimistic
+class person
+{
+  ...
+
+  #pragma db version
+  unsigned long version_;
+};
+
+ +

A version member must be of an integral C++ type and must map to + an integer or similar database type. Note also that object versions + are not reused. If you have a high update frequency, then care must + be taken not to run out of versions. In such situations, using + unsigned long long as the version type is a safe + choice.

+ +

For a more detailed discussion of optimistic concurrency, refer to + Chapter 12, "Optimistic Concurrency".

+ +

14.4.17 index

+ +

The index specifier instructs the ODB compiler to define + a database index for the data member. For example:

+ + 
+#pragma db object
+class person
+{
+  ...
+
+  #pragma db index
+  std::string name_;
+};
+
+ +

For more information on defining database indexes, refer to + Section 14.7, "Index Definition Pragmas".

+ +

14.4.18 unique

+ +

The index specifier instructs the ODB compiler to define + a unique database index for the data member. For example:

+ + 
+#pragma db object
+class person
+{
+  ...
+
+  #pragma db unique
+  std::string name_;
+};
+
+ +

For more information on defining database indexes, refer to + Section 14.7, "Index Definition Pragmas".

+ +

14.4.19 unordered

+ +

The unordered specifier specifies that the member of + an ordered container type should be stored unordered in the database. + The database table for such a member will not contain the index column + and the order in which elements are retrieved from the database may + not be the same as the order in which they were stored. For example:

+ + 
+#pragma db object
+class person
+{
+  ...
+
+  #pragma db unordered
+  std::vector<std::string> nicknames_;
+};
+
+ +

For a more detailed discussion of ordered containers and their + storage in the database, refer to Section 5.1, + "Ordered Containers".

+ +

14.4.20 table

+ +

The table specifier specifies the table name that should + be used to store the contents of the container member. For example:

+ + 
+#pragma db object
+class person
+{
+  ...
+
+  #pragma db table("nicknames")
+  std::vector<std::string> nicknames_;
+};
+
+ +

If the table name is not specified, then the container table name + is constructed by concatenating the object's table name, underscore, + and the public member name. The public member name is obtained + by removing the common member name decorations, such as leading and + trailing underscores, the m_ prefix, etc. In the example + above, without the table specifier, the container's + table name would have been person_nicknames.

+ +

The table specifier can also be used for members of + composite value types. In this case it specifies the table name + prefix for container members inside the composite value type. Refer + to Section 7.2.2, "Composite Value Column and Table + Names" for details.

+ +

The container table name can be qualified with a database + schema, for example:

+ + 
+#pragma db object
+class person
+{
+  ...
+
+  #pragma db table("extras.nicknames")
+  std::vector<std::string> nicknames_;
+};
+
+ +

For more information on database schemas and the format of the + qualified names, refer to Section 14.1.8, + "schema".

+ +

14.4.21 load/update

+ +

The load and update specifiers specify the + loading and updating behavior for an object section, respectively. + Valid values for the load specifier are + eager (default) and lazy. Valid values for + the update specifier are always (default), + change, and manual. For more information + on object sections, refer to Chapter 9, "Sections".

+ +

14.4.22 section

+ +

The section specifier indicates that a data member + of a persistent class belongs to an object section. The single + required argument to this specifier is the name of the section + data member. This specifier can only be used on direct data + members of a persistent class. For more information on object + sections, refer to Chapter 9, "Sections".

+ +

14.4.23 added

+ +

The added specifier marks the data member as + soft-added. The single required argument to this specifier is + the addition version. For more information on this functionality, + refer to Section 13.4, "Soft Object Model + Changes".

+ +

14.4.24 deleted

+ +

The deleted specifier marks the data member as + soft-deleted. The single required argument to this specifier is + the deletion version. For more information on this functionality, + refer to Section 13.4, "Soft Object Model + Changes".

+ +

14.4.25 index_type

+ +

The index_type specifier specifies the native + database type that should be used for an ordered container's + index column of the data member. The semantics of index_type + are similar to those of the type specifier + (Section 14.4.3, "type"). The native + database type is expected to be an integer type. For example:

+ + 
+#pragma db object
+class person
+{
+  ...
+
+  #pragma db index_type("SMALLINT UNSIGNED")
+  std::vector<std::string> nicknames_;
+};
+
+ +

14.4.26 key_type

+ +

The key_type specifier specifies the native + database type that should be used for a map container's + key column of the data member. The semantics of key_type + are similar to those of the type specifier + (Section 14.4.3, "type"). For + example:

+ + 
+#pragma db object
+class person
+{
+  ...
+
+  #pragma db key_type("INT UNSIGNED")
+  std::map<unsigned short, float> age_weight_map_;
+};
+
+ +

14.4.27 value_type

+ +

The value_type specifier specifies the native + database type that should be used for a container's + value column of the data member. The semantics of value_type + are similar to those of the type specifier + (Section 14.4.3, "type"). For + example:

+ + 
+#pragma db object
+class person
+{
+  ...
+
+  #pragma db value_type("VARCHAR(255)")
+  std::vector<std::string> nicknames_;
+};
+
+ +

The value_null and value_not_null + (Section 14.4.28, + "value_null/value_not_null") specifiers + can be used to control the NULL semantics of a value + column.

+ +

14.4.28 value_null/value_not_null

+ +

The value_null and value_not_null specifiers + specify that a container's element value for the data member can or + cannot be NULL, respectively. The semantics of + value_null and value_not_null are similar + to those of the null and not_null specifiers + (Section 14.4.6, "null/not_null"). + For example:

+ + 
+using std::tr1::shared_ptr;
+
+#pragma db object
+class person
+{
+  ...
+};
+
+#pragma db object
+class account
+{
+  ...
+
+  #pragma db value_not_null
+  std::vector<shared_ptr<person> > holders_;
+};
+
+ +

For set and multiset containers (Section 5.2, "Set and + Multiset Containers") the element value is automatically treated + as not allowing a NULL value.

+ +

14.4.29 id_options

+ +

The id_options specifier specifies additional + column definition options that should be used for a container's + id column of the data member. For example:

+ + 
+#pragma db object
+class person
+{
+  ...
+
+  #pragma db id options("COLLATE binary")
+  std::string name_;
+
+  #pragma db id_options("COLLATE binary")
+  std::vector<std::string> nicknames_;
+};
+
+ +

The semantics of id_options are similar to those + of the options specifier (Section + 14.4.8, "options").

+ +

14.4.30 index_options

+ +

The index_options specifier specifies additional + column definition options that should be used for a container's + index column of the data member. For example:

+ + 
+#pragma db object
+class person
+{
+  ...
+
+  #pragma db index_options("ZEROFILL")
+  std::vector<std::string> nicknames_;
+};
+
+ +

The semantics of index_options are similar to those + of the options specifier (Section + 14.4.8, "options").

+ +

14.4.31 key_options

+ +

The key_options specifier specifies additional + column definition options that should be used for a container's + key column of the data member. For example:

+ + 
+#pragma db object
+class person
+{
+  ...
+
+  #pragma db key_options("COLLATE binary")
+  std::map<std::string, std::string> properties_;
+};
+
+ +

The semantics of key_options are similar to those + of the options specifier (Section + 14.4.8, "options").

+ +

14.4.32 value_options

+ +

The value_options specifier specifies additional + column definition options that should be used for a container's + value column of the data member. For example:

+ + 
+#pragma db object
+class person
+{
+  ...
+
+  #pragma db value_options("COLLATE binary")
+  std::set<std::string> nicknames_;
+};
+
+ +

The semantics of value_options are similar to those + of the options specifier (Section + 14.4.8, "options").

+ +

14.4.33 id_column

+ +

The id_column specifier specifies the column + name that should be used to store the object id in a + container's table for the data member. The semantics of + id_column are similar to those of the + column specifier + (Section 14.4.9, "column"). + For example:

+ + 
+#pragma db object
+class person
+{
+  ...
+
+  #pragma db id_column("person_id")
+  std::vector<std::string> nicknames_;
+};
+
+ +

If the column name is not specified, then object_id + is used by default.

+ +

14.4.34 index_column

+ +

The index_column specifier specifies the column + name that should be used to store the element index in an + ordered container's table for the data member. The semantics of + index_column are similar to those of the + column specifier + (Section 14.4.9, "column"). + For example:

+ + 
+#pragma db object
+class person
+{
+  ...
+
+  #pragma db index_column("nickname_number")
+  std::vector<std::string> nicknames_;
+};
+
+ +

If the column name is not specified, then index + is used by default.

+ +

14.4.35 key_column

+ +

The key_column specifier specifies the column + name that should be used to store the key in a map + container's table for the data member. The semantics of + key_column are similar to those of the + column specifier + (Section 14.4.9, "column"). + For example:

+ + 
+#pragma db object
+class person
+{
+  ...
+
+  #pragma db key_column("age")
+  std::map<unsigned short, float> age_weight_map_;
+};
+
+ +

If the column name is not specified, then key + is used by default.

+ +

14.4.36 value_column

+ +

The value_column specifier specifies the column + name that should be used to store the element value in a + container's table for the data member. The semantics of + value_column are similar to those of the + column specifier + (Section 14.4.9, "column"). + For example:

+ + 
+#pragma db object
+class person
+{
+  ...
+
+  #pragma db value_column("weight")
+  std::map<unsigned short, float> age_weight_map_;
+};
+
+ +

If the column name is not specified, then value + is used by default.

+ +

14.5 Namespace Pragmas

+ +

A pragma with the namespace qualifier describes a + C++ namespace. Similar to other qualifiers, namespace + can also refer to a named C++ namespace, for example:

+ + 
+namespace test
+{
+  ...
+}
+
+#pragma db namespace(test) ...
+
+ +

To refer to the global namespace in the namespace + qualifier the following special syntax is used:

+ + 
+#pragma db namespace() ....
+
+ +

The namespace qualifier can be optionally followed, + in any order, by one or more specifiers summarized in the + table below:

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpecifierSummarySection
pointerpointer type for persistent classes and views inside a namespace14.5.1
tabletable name prefix for persistent classes inside a namespace14.5.2
schemadatabase schema for persistent classes inside a namespace14.5.3
sessionenable/disable session support for persistent classes inside a namespace14.5.4
+ +

14.5.1 pointer

+ +

The pointer specifier specifies the default pointer + type for persistent classes and views inside the namespace. For + example:

+ + 
+#pragma db namespace pointer(std::tr1::shared_ptr)
+namespace accounting
+{
+  #pragma db object
+  class employee
+  {
+    ...
+  };
+
+  #pragma db object
+  class employer
+  {
+    ...
+  };
+}
+
+ +

There are only two valid ways to specify a pointer with the + pointer specifier at the namespace level. We can + specify the template name of a smart pointer in which + case the ODB compiler will automatically append the class + name as a template argument. Or we can use * + to denote a raw pointer.

+ +

Note also that we can always override the default pointer + specified at the namespace level for any persistent class + or view inside this namespace. For example:

+ + 
+#pragma db namespace pointer(std::unique_ptr)
+namespace accounting
+{
+  #pragma db object pointer(std::shared_ptr)
+  class employee
+  {
+    ...
+  };
+
+  #pragma db object
+  class employer
+  {
+    ...
+  };
+}
+
+ +

For a more detailed discussion of object and view pointers, refer + to Section 3.3, "Object and View Pointers".

+ +

14.5.2 table

+ +

The table specifier specifies a table prefix + that should be added to table names of persistent classes inside + the namespace. For example:

+ + 
+#pragma db namespace table("acc_")
+namespace accounting
+{
+  #pragma db object table("employees")
+  class employee
+  {
+    ...
+  };
+
+  #pragma db object table("employers")
+  class employer
+  {
+    ...
+  };
+}
+
+ +

In the above example the resulting table names will be + acc_employees and acc_employers.

+ +

The table name prefix can also be specified with the + --table-prefix ODB compiler option. Note + that table prefixes specified at the namespace level as well + as with the command line option are accumulated. For example:

+ + 
+#pragma db namespace() table("audit_")
+
+#pragma db namespace table("hr_")
+namespace hr
+{
+  #pragma db object table("employees")
+  class employee
+  {
+    ...
+  };
+}
+
+#pragma db object table("employers")
+class employer
+{
+  ...
+};
+
+ +

If we compile the above example with the + --table-prefix test_ option, then the + employee class table will be called + test_audit_hr_employees and employer — + test_audit_employers.

+ +

Table prefixes can be used as an alternative to database schemas + (Section 14.1.8, "schema") if + the target database system does not support schemas.

+ +

14.5.3 schema

+ +

The schema specifier specifies a database schema + that should be used for persistent classes inside the namespace. + For more information on specifying a database schema refer to + Section 14.1.8, "schema".

+ +

14.5.4 session

+ +

The session specifier specifies whether to enable + session support for persistent classes inside the namespace. For + example:

+ + 
+#pragma db namespace session
+namespace hr
+{
+  #pragma db object                // Enabled.
+  class employee
+  {
+    ...
+  };
+
+  #pragma db object session(false) // Disabled.
+  class employer
+  {
+    ...
+  };
+}
+
+ +

Session support is disabled by default unless the + --generate-session ODB compiler option is specified. + Session support specified at the namespace level can be overridden + on the per object basis (Section 14.1.10, + "session"). For more information on sessions, + refer to Chapter 11, "Session".

+ +

14.6 Object Model Pragmas

+ +

A pragma with the model qualifier describes the + whole C++ object model. For example:

+ + 
+#pragma db model ...
+
+ +

The model qualifier can be followed, in any order, + by one or more specifiers summarized in the table below:

+ + + + + + + + + + + + + + + +
SpecifierSummarySection
versionobject model version14.6.1
+ +

14.6.1 version

+ +

The version specifier specifies the object model + version when schema evolution support is used. The first two + required arguments to this specifier are the base and current + model versions, respectively. The third optional argument + specifies whether the current version is open for changes. + Valid values for this argument are open (the + default) and closed. For more information on + this functionality, refer to Chapter 13, + "Database Schema Evolution".

+ + +

14.7 Index Definition Pragmas

+ +

While it is possible to manually add indexes to the generated + database schema, it is more convenient to do this as part of + the persistent class definitions. A pragma with the index + qualifier describes a database index. It has the following + general format:

+ +
+#pragma db index[("<name>")]                       \
+           [unique|type("<type>")]                 \
+           [method("<method>")]                    \
+           [options("<index-options>")]            \
+           member(<name>[, "<column-options>"])... \
+           members(<name>[,<name>...])...
+
+ +

The index qualifier can optionally specify the + index name. If the index name is not specified, then one is + automatically derived by appending the _i suffix + to the column name of the index member. If the name is not + specified and the index contains multiple members, then the + index definition is invalid.

+ +

The optional type, method, and + options clauses specify the index type, for + example UNIQUE, index method, for example + BTREE, and index options, respectively. The + unique clause is a shortcut for + type("UNIQUE"). Note that not all database + systems support specifying an index method or options. + For more information on the database system-specific index + types, methods, and options, refer to Part II, + "Database Systems".

+ +

To specify index members we can use the member + or members clauses, or a mix of the two. The + member clause allows us to specify a single + index member with optional column options, for example, + "ASC". If we need to create a composite + index that contains multiple members, then we can repeat + the member clause several times or, if the + members don't have any column options, we can use a single + members clause instead. Similar to the index + type, method, and options, the format of column options is + database system-specific. For more details, refer to + Part II, "Database Systems".

+ +

The following code fragment shows some typical examples + of index definitions:

+ +
+#pragma db object
+class object
+{
+  ...
+
+  int x;
+  int y;
+  int z1;
+  int z2;
+
+  // An index for member x with automatically-assigned name x_i.
+  //
+  #pragma db index member(x)
+
+  // A unique index named y_index for member y which is sorted in
+  // the descending order. The index is using the BTREE method.
+  //
+  #pragma db index("y_index") unique method("BTREE") member(y, "DESC")
+
+  // A composite BITMAP index named z_i for members z1 and z2.
+  //
+  #pragma db index("z_i") type("BITMAP") members(z1, z2)
+};
+
+ +

ODB also offers a shortcut for defining an index with the default + method and options for a single data member. Such an index can + be defined using the index (Section + 14.4.17, "index") or unique + (Section 14.4.18, "unique") + member specifier. For example:

+ +
+#pragma db object
+class object
+{
+  ...
+
+  #pragma db index
+  int x;
+
+  #pragma db type("INT") unique
+  int y;
+};
+
+ +

The above example is semantically equivalent to the following + more verbose version:

+ +
+#pragma db object
+class object
+{
+  ...
+
+  int x;
+
+  #pragma db type("INT")
+  int y;
+
+  #pragma db index member(x)
+  #pragma db index unique member(y)
+};
+
+ +

While it is convenient to define an index inside a persistent + class, it is also possible to do that out of the class body. In this + case, the index name, if specified, must be prefixed with the + potentially-qualified class name. For example:

+ +
+namespace n
+{
+  #pragma db object
+  class object
+  {
+    ...
+
+    int x;
+    int y;
+  };
+
+  // An index for member x in persistent class object with automatically-
+  // assigned name x_i.
+  //
+  #pragma db index(object) member(x)
+}
+
+// An index named y_index for member y in persistent class n::object.
+//
+#pragma db index(n::object::"y_index") member(y)
+
+ +

It is possible to define an index on a member that is of a + composite value type or on some of its nested members. For + example:

+ +
+#pragma db value
+struct point
+{
+  int x;
+  int y;
+  int z;
+};
+
+#pragma db object
+class object
+{
+  // An index that includes all of the p1's nested members.
+  //
+  #pragma db index
+  point p1;
+
+  point p2;
+
+  // An index that includes only p2.x and p2.y.
+  //
+  #pragma db index("p2_xy_i") members(p2.x, p2.y)
+};
+
+ +

When generating a schema for a container member (Chapter 5, + "Containers"), ODB automatically defines two indexes on the container + table. One is for the object id that references the object table and the + other is for the index column in case the container is ordered + (Section 5.1, "Ordered Containers"). By default these + indexes use the default index name, type, method, and options. The + index pragma allows us to customize these two indexes by + recognizing the special id and index nested + member names when specified after a container member. For example:

+ +
+#pragma db object
+class object
+{
+  std::vector<int> v;
+
+  // Change the container id index name.
+  //
+  #pragma db index("id_index") member(v.id)
+
+  // Change the container index index method.
+  //
+  #pragma db index method("BTREE") member(v.index)
+};
+
+ +

14.8 Database Type Mapping Pragmas

+ +

A pragma with the map qualifier describes a + mapping between two database types. For each database system + ODB provides built-in support for a core set of database types, + such as integers, strings, binary, etc. However, many database + systems provide extended types such as geospatial types, + user-defined types, and collections (arrays, table types, + key-value stores, etc). In order to support such extended types, + ODB allows us to map them to one of the built-in types, normally + a string or a binary. Given the text or binary representation + of the data we can then extract it into our chosen C++ data type + and thus establish a mapping between an extended database type and + its C++ equivalent.

+ +

The map pragma has the following format:

+ +
+#pragma db map type("regex") as("subst") [to("subst")] [from("subst")]
+
+ +

The type clause specifies the name of the database type + that we are mapping. We will refer to it as the mapped type + from now on. The name of the mapped type is a Perl-like regular + expression pattern that is matched in the case-insensitive mode.

+ +

The as clause specifies the name of the database type + that we are mapping the mapped type to. We will refer to it as + the interface type from now on. The name of the interface + type is a regular expression substitution and should expand to a + name of a database type for which ODB provides built-in support.

+ +

The optional to and from clauses specify the + database conversion expressions between the mapped type and the + interface type. The to expression converts from the + interface type to the mapped type and from converts + in the other direction. If no explicit conversion is required for + either direction, then the corresponding clause can be omitted. + The conversion expressions are regular expression substitutions. + They must contain the special (?) placeholder which will + be replaced with the actual value to be converted. Turning on SQL + statement tracing (Section 3.13, "Tracing SQL + Statement Execution") can be useful for debugging conversion + expressions. This allows you to see the substituted expressions + as used in the actual statements.

+ +

As an example, the following map pragma maps the + PostgreSQL array of INTEGER's to TEXT:

+ +
+#pragma db map type("INTEGER *\\[(\\d*)\\]") \
+               as("TEXT")                    \
+               to("(?)::INTEGER[$1]")        \
+               from("(?)::TEXT")
+
+ +

With the above mapping we can now have a persistent class that + has a member of the PostgreSQL array type:

+ +
+#pragma db object
+class object
+{
+  ...
+
+  #pragma db type("INTEGER[]")
+  std::string array_;
+};
+
+ +

In PostgreSQL the array literal has the {n1,n2,...} form. + As a result, we need to make sure that we pass the correct text + representation in the array_ member, for example:

+ +
+object o;
+o.array_ = "{1,2,3}";
+db.persist (o);
+
+ +

Of course, std::string is not the most natural + representation of an array of integers in C++. Instead, + std::vector<int> would have been much more + appropriate. To add support for mapping + std::vector<int> to PostgreSQL INTEGER[] + we need to provide a value_traits specialization + that implements conversion between the PostgreSQL text representation + of an array and std::vector<int>. Below is a sample + implementation:

+ +
+namespace odb
+{
+  namespace pgsql
+  {
+    template <>
+    class value_traits<std::vector<int>, id_string>
+    {
+    public:
+      typedef std::vector<int> value_type;
+      typedef value_type query_type;
+      typedef details::buffer image_type;
+
+      static void
+      set_value (value_type& v,
+                 const details::buffer& b,
+                 std::size_t n,
+                 bool is_null)
+      {
+        v.clear ();
+
+        if (!is_null)
+        {
+          char c;
+          std::istringstream is (std::string (b.data (), n));
+
+          is >> c; // '{'
+
+          for (c = static_cast<char> (is.peek ()); c != '}'; is >> c)
+          {
+            v.push_back (int ());
+            is >> v.back ();
+          }
+        }
+      }
+
+      static void
+      set_image (details::buffer& b,
+                 std::size_t& n,
+                 bool& is_null,
+                 const value_type& v)
+      {
+        is_null = false;
+        std::ostringstream os;
+
+        os << '{';
+
+        for (value_type::const_iterator i (v.begin ()), e (v.end ());
+             i != e;)
+        {
+          os << *i;
+
+          if (++i != e)
+            os << ',';
+        }
+
+        os << '}';
+
+        const std::string& s (os.str ());
+        n = s.size ();
+
+        if (n > b.capacity ())
+          b.capacity (n);
+
+        std::memcpy (b.data (), s.c_str (), n);
+      }
+    };
+  }
+}
+
+ +

Once this specialization is included in the generated code (see + the mapping example in the odb-examples + package for details), we can use std::vector<int> + instead of std::string in our persistent class:

+ +
+#pragma db object
+class object
+{
+  ...
+
+  #pragma db type("INTEGER[]")
+  std::vector<int> array_;
+};
+
+ +

If we wanted to always map std::vector<int> + to PostgreSQL INTEGER[], then we could instead + write:

+ +
+typedef std::vector<int> int_vector;
+#pragma db value(int_vector) type("INTEGER[]")
+
+#pragma db object
+class object
+{
+  ...
+
+  std::vector<int> array_; // Mapped to INTEGER[].
+};
+
+ +

While the above example only shows how to handle PostgreSQL arrays, + other types in PostgreSQL and in other databases can be supported + in a similar way. The odb-tests package contains a + set of tests in the <database>/custom directories that, + for each database, shows how to provide custom mapping for some of + the extended types.

+ +

14.9 C++ Compiler Warnings

+ +

When a C++ header file defining persistent classes and containing + ODB pragmas is used to build the application, the C++ compiler may + issue warnings about pragmas that it doesn't recognize. There + are several ways to deal with this problem. The easiest is to + disable such warnings using one of the compiler-specific command + line options or warning control pragmas. This method is described + in the following sub-section for popular C++ compilers.

+ +

There are also several C++ compiler-independent methods that we + can employ. The first is to use the PRAGMA_DB macro, + defined in <odb/core.hxx>, instead of using + #pragma db directly. This macro expands to the + ODB pragma when compiled with the ODB compiler and to an empty + declaration when compiled with other compilers. The following example + shows how we can use this macro:

+ + 
+#include <odb/core.hxx>
+
+PRAGMA_DB(object)
+class person
+{
+  ...
+
+  PRAGMA_DB(id)
+  unsigned long id_;
+};
+
+ +

An alternative to using the PRAGMA_DB macro is to + group the #pragma db directives in blocks that are + conditionally included into compilation only when compiled with the + ODB compiler. For example:

+ + 
+class person
+{
+  ...
+
+  unsigned long id_;
+};
+
+#ifdef ODB_COMPILER
+#  pragma db object(person)
+#  pragma db member(person::id_) id
+#endif
+
+ +

The disadvantage of this approach is that it can quickly become + overly verbose when positioned pragmas are used.

+ +

14.9.1 GNU C++

+ +

GNU g++ does not issue warnings about unknown pragmas + unless requested with the -Wall command line option. + To disable only the unknown pragma warning, we can add the + -Wno-unknown-pragmas option after -Wall, + for example:

+ + 
+g++ -Wall -Wno-unknown-pragmas ...
+
+ +

14.9.2 Visual C++

+ +

Microsoft Visual C++ issues an unknown pragma warning (C4068) at + warning level 1 or higher. This means that unless we have disabled + the warnings altogether (level 0), we will see this warning.

+ +

To disable this warning via the compiler command line, we can add + the /wd4068 C++ compiler option in Visual Studio 2008 + and earlier. In Visual Studio 2010 and later there is now a special + GUI field where we can enter warning numbers that should be disabled. + Simply enter 4068 into this field.

+ +

We can also disable this warning for only a specific header or + a fragment of a header using the warning control pragma. For + example:

+ + 
+#include <odb/core.hxx>
+
+#pragma warning (push)
+#pragma warning (disable:4068)
+
+#pragma db object
+class person
+{
+  ...
+
+  #pragma db id
+  unsigned long id_;
+};
+
+#pragma warning (pop)
+
+ +

14.9.3 Sun C++

+ +

The Sun C++ compiler does not issue warnings about unknown pragmas + unless the +w or +w2 option is specified. + To disable only the unknown pragma warning we can add the + -erroff=unknownpragma option anywhere on the + command line, for example:

+ + 
+CC +w -erroff=unknownpragma ...
+
+ +

14.9.4 IBM XL C++

+ +

IBM XL C++ issues an unknown pragma warning (1540-1401) by default. + To disable this warning we can add the -qsuppress=1540-1401 + command line option, for example:

+ + 
+xlC -qsuppress=1540-1401 ...
+
+ +

14.9.5 HP aC++

+ +

HP aC++ (aCC) issues an unknown pragma warning (2161) by default. + To disable this warning we can add the +W2161 + command line option, for example:

+ + 
+aCC +W2161 ...
+
+ +

14.9.6 Clang

+ +

Clang does not issue warnings about unknown pragmas + unless requested with the -Wall command line option. + To disable only the unknown pragma warning, we can add the + -Wno-unknown-pragmas option after -Wall, + for example:

+ + 
+clang++ -Wall -Wno-unknown-pragmas ...
+
+ +

We can also disable this warning for only a specific header or + a fragment of a header using the warning control pragma. For + example:

+ + 
+#include <odb/core.hxx>
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunknown-pragmas"
+
+#pragma db object
+class person
+{
+  ...
+
+  #pragma db id
+  unsigned long id_;
+};
+
+#pragma clang diagnostic pop
+
+ + + + + +
+

15 Advanced Techniques and Mechanisms

+ +

This chapter covers more advanced techniques and mechanisms + provided by ODB that may be useful in certain situations.

+ +

15.1 Transaction Callbacks

+ +

The ODB transaction class (odb::transaction) allows + an application to register a callback that will be called after + the transaction is finalized, that is, committed or rolled back. + This mechanism can be used, for example, to restore values that + were updated during the transaction execution to their original + states if the transaction is rolled back.

+ +

The callback management interface of the transaction + class is shown below.

+ + 
+namespace odb
+{
+  class transaction
+  {
+    ...
+
+  public:
+    static const unsigned short event_commit = 0x01;
+    static const unsigned short event_rollback = 0x02;
+    static const unsigned short event_all = event_commit | event_rollback;
+
+    typedef void (*callback_type) (
+      unsigned short event, void* key, unsigned long long data);
+
+    void
+    callback_register (callback_type callback,
+                       void* key,
+                       unsigned short event = event_all,
+                       unsigned long long data = 0,
+                       transaction** state = 0);
+
+
+    void
+    callback_unregister (void* key);
+
+    void
+    callback_update (void* key,
+                     unsigned short event,
+                     unsigned long long data = 0,
+                     transaction** state = 0);
+  }
+}
+
+ +

The callback_register() function registers a + post-commit/rollback callback. The callback + argument is the function that should be called. The + key argument is used by the transaction + to identify this callback. It is also normally used + to pass an address of the data object on which the + callback function will work. The event + argument is the bitwise-or of the events that should + trigger the callback.

+ +

The optional data argument can be used to store any POD + user data that doesn't exceed 8 bytes in size and doesn't require + alignment greater than unsigned long long. For + example, we could store an old value of a flag or a counter + that needs to be restored in case of a roll back.

+ +

The optional state argument can be used to + indicate that the callback has been unregistered because + the transaction was finalized. In this case the transaction + automatically resets the passed pointer to 0. This is + primarily useful if we are interested in only one of + the events (commit or rollback).

+ +

The callback_unregister() function unregisters a previously + registered callback. If the number of registered callbacks is + large, then this can be a slow operation. Generally, the callback + mechanism is optimized for cases where the callbacks stay + registered until the transaction is finalized.

+ +

Note also that you don't need to unregister a callback that has + been called or auto-reset using the state argument + passed to callback_register(). This function does nothing + if the key is not found.

+ +

The callback_update() function can be used to update + the event, data, and state + values of a previously registered callback. Similar to + callback_unregister(), this is a potentially slow + operation.

+ +

When the callback is called, it is passed the event that + triggered it, as well as the key and + data values that were passed to the + callback_register() function. Note also that the order + in which the callbacks are called is unspecified. The rollback + event can be triggered by an exception. In this case, if the + callback throws, the program will be terminated.

+ +

The following example shows how we can use transaction + callbacks together with database operation callbacks + (Section 14.1.7, "callback") + to manage the object's "dirty" flag.

+ + 
+#include <odb/callback.hxx>
+#include <odb/transaction.hxx>
+
+#pragma db object callback(update)
+class object
+{
+  ...
+
+  #pragma db transient
+  mutable bool dirty_;
+
+  // Non-NULL value indicates that we are registered
+  // with this transaction.
+  //
+  #pragma db transient
+  mutable odb::transaction* tran_;
+
+  void
+  update (odb::callback_event e, odb::database&) const
+  {
+    using namespace odb::core;
+
+    if (e == callback_event::post_update)
+      return;
+
+    // Mark the object as clean again but register a
+    // transaction callback in case the update is rolled
+    // back.
+    //
+    tran_ = &transaction::current ();
+    tran_->callback_register (&rollback,
+                              const_cast<object*> (this),
+                              transaction::event_rollback,
+                              0,
+                              &tran_);
+    dirty_ = false;
+  }
+
+  static void
+  rollback (unsigned short, void* key, unsigned long long)
+  {
+    // Restore the dirty flag since the changes have been
+    // rolled back.
+    //
+    object& o (*static_cast<object*> (key));
+    o.dirty_ = true;
+  }
+
+  ~object ()
+  {
+    // Unregister the callback if we are going away before
+    // the transaction.
+    //
+    if (tran_ != 0)
+      tran_->callback_unregister (this);
+  }
+};
+
+ +

15.2 Persistent Class Template Instantiations

+ +

Similar to composite value types (Section 7.2, "Composite + Value Types"), a persistent object can be defined as an instantiation + of a C++ class template, for example:

+ + 
+template <typename T>
+class person
+{
+  ...
+
+  T first_;
+  T last_;
+};
+
+typedef person<std::string> std_person;
+
+#pragma db object(std_person)
+#pragma db member(std_person::last_) id
+
+ +

Note that the database support code for such a persistent object + is generated when compiling the header containing the + db object pragma and not the header containing + the template definition or the typedef name. This + allows us to use templates defined in other files, for example:

+ + 
+#include <utility> // std::pair
+
+typedef std::pair<unsigned int, std::string> person;
+#pragma db object(person)
+#pragma db member(person::first) id auto column("id")
+#pragma db member(person::second) column("name")
+
+ +

You may also have to explicitly specify the object type in + calls to certain database class functions due + to the inability do distinguish, at the API level, between + smart pointers and persistent objects defined as class + template instantiations. For example:

+ + 
+person p;
+
+db.update (p); // Error.
+db.reload (p); // Error.
+db.erase (p);  // Error.
+
+db.update<person> (p); // Ok.
+db.reload<person> (p); // Ok.
+db.erase<person> (p);  // Ok.
+
+ +

It also makes sense to factor persistent data members that do not + depend on template arguments into a common, non-template base class. + The following more realistic example illustrates this approach:

+ + 
+#pragma db object abstract
+class base_common
+{
+  ...
+
+  #pragma db id auto
+  unsigned long id;
+};
+
+template <typename T>
+class base: public base_common
+{
+  ...
+
+  T value;
+};
+
+typedef base<std::string> string_base;
+#pragma db object(string_base) abstract
+
+#pragma db object
+class derived: public string_base
+{
+  ...
+};
+
+ +

15.3 Bulk Database Operations

+ +

Some database systems supported by ODB provide a mechanism, often + called bulk or batch statement execution, that allows us to execute + the same SQL statement on multiple sets of data at once and with a + single database API call. This often results in significantly + better performance if we need to execute the same statement for a + large number of data sets (thousands to millions).

+ +

ODB translates this mechanism to bulk operations which allow + us to persist, update, or erase a range of objects in the database. + Currently, from all the database systems supported by ODB, only + Oracle and Microsoft SQL Server are capable of bulk operations. + There is also currently no emulation of the bulk API for other + databases nor dynamic multi-database support. As a result, if + you are using dynamic multi-database support, you will need to + "drop down" to static support in order to access the bulk API. + Refer to Chapter 16, "Multi-Database Support" + for details.

+ +

As we will discuss later in this section, bulk operations have + complex failure semantics that is dictated by the underlying + database API. As a result, support for bulk persist, update, + and erase is limited to persistent classes for which these + operations can be performed with a single database statement + execution. In particular, bulk operations are not available + for polymorphic objects (Section 8.2, + "Polymorphism Inheritance") or objects that have + containers (inverse containers of object pointers are an + exception). Furthermore, for objects that have sections + (Chapter 9, "Sections") the bulk update operation + will only be available if all the sections are manually-updated. + On the other hand, bulk operations are supported for objects + that use optimistic concurrency (Chapter 12, + "Optimistic Concurrency") or have no object id + (Section 14.1.6, "no_id").

+ +

To enable the generation of bulk operation support for a persistent + class we use the bulk pragma. For example:

+ + 
+#pragma db object bulk(5000)
+class person
+{
+  ...
+
+  #pragma db id auto
+  unsigned long id;
+};
+
+ +

The single argument to the bulk pragma is the batch + size. The batch size specifies the maximum number of data sets + that should be handled with a single underlying statement execution. + If the range that we want to perform the bulk operation on contains + more objects than the batch size, then ODB will split this operation + into multiple underlying statement executions (batches). To illustrate + this point with an example, suppose we want to persist 53,000 objects + and the batch size is 5,000. ODB will then execute the statement + 11 times, the first 10 times with 5,000 data sets each, and the + last time with the remaining 3,000 data sets.

+ +

The commonly used batch sizes are in the 2,000-5,000 range, though + smaller or larger batches could provide better performance, + depending on the situation. As a result, it is recommended to + experiment with different batch sizes to determine the optimum + number for a particular object and its use-cases. Note also that + you may achieve better performance by also splitting a large bulk + operation into multiple transactions (Section 3.5, + "Transactions").

+ +

For database systems that do not support bulk operations the + bulk pragma is ignored. It is also possible to + specify different batch sizes for different database systems + by using the database prefix, for example:

+ + 
+#pragma db object mssql:bulk(3000) oracle:bulk(4000)
+class person
+{
+  ...
+};
+
+ +

Note that while specifying the batch size at compile time might + seem inflexible, this approach allows ODB to place internal + arrays of the fixed batch size on the stack rather than + allocating them in the dynamic memory. However, specifying the + batch size at runtime may be supported in the future.

+ +

Once the bulk support is enabled for a particular object, we can + use the following database functions to perform bulk + operations:

+ + 
+template <typename I>
+void
+persist (I begin, I end, bool continue_failed = true);
+
+template <typename I>
+void
+update (I begin, I end, bool continue_failed = true);
+
+template <typename I>
+void
+erase (I obj_begin, I obj_end, bool continue_failed = true);
+
+template <typename T, typename I>
+void
+erase (I id_begin, I id_end, bool continue_failed = true);
+
+ +

Every bulk API function expects a range of elements, passed in + the canonical C++ form as a pair of input iterators. In case of + persist(), update(), and the first + erase() overload, we pass a range of objects, + either as references or as pointers, raw or smart. The following + example illustrates the most common scenarios using the + persist() call:

+ + 
+// C array of objects.
+//
+person a[2] {{"John", "Doe"}, {"Jane", "Doe"}};
+
+db.persist (a, a + sizeof(a) / sizeof(a[0]));
+
+
+// Vector of objects.
+//
+std::vector<person> v {{"John", "Doe"}, {"Jane", "Doe"}};
+
+db.persist (v.begin (), v.end ());
+
+
+// C array of raw pointers to objects.
+//
+person p1 ("John", "Doe");
+person p2 ("Jane", "Doe");
+person* pa[2] {&p1, &p2};
+
+db.persist (pa, pa + sizeof(pa) / sizeof(pa[0]));
+
+
+// Vector of raw pointers to objects.
+//
+std::vector<person*> pv {&p1, &p2};
+
+db.persist (pv.begin (), pv.end ());
+
+
+// Vector of smart (shared) pointers to objects.
+//
+std::vector<std::shared_ptr<person>> sv {
+  std::make_shared<person> ("John", "Doe"),
+  std::make_shared<person> ("Jane", "Doe")};
+
+db.persist (sv.begin (), sv.end ());
+
+ +

The ability to perform a bulk operation on a range of raw pointers + to objects can be especially useful when the application stores + objects in a way that does not easily conform to the pair of + iterators interface. In such cases we can create a temporary + container of shallow pointers to objects and use that to perform + the bulk operation, for example:

+ + 
+struct person_entry
+{
+  person obj;
+
+  // Some additional data.
+  ...
+};
+
+typedef std::vector<person_entry> people;
+
+void
+persist (odb::database& db, people& p)
+{
+  std::vector<person*> tmp;
+  tmp.reserve (p.size ());
+  std::for_each (p.begin (),
+                 p.end (),
+                 [&tmp] (person_entry& pe)
+                 {
+                   tmp.push_back (&pe.obj);
+                 });
+
+
+  db.persist (tmp.begin (), tmp.end ());
+}
+
+ +

The second overload of the bulk erase() function + allows us to pass a range of object ids rather than objects + themselves. As with the corresponding non-bulk version, we + have to specify the object type explicitly, for example:

+ + 
+std::vector<unsigned long> ids {1, 2};
+
+db.erase<person> (ids.begin (), ids.end ());
+
+ +

Conceptually, a bulk operation is equivalent to performing the + corresponding non-bulk version in a loop, except when it comes to the + failure semantics. Both databases that currently are capable of + bulk operations (Oracle and SQL Server) do not stop when a data + set in a batch fails (for example, because of a unique constraint + violation). Instead, they continue executing subsequent data + sets until every element in the batch has been attempted. The + continue_failed argument in the bulk functions listed + above specifies whether ODB should extend this behavior and continue + with subsequent batches if the one it has tried to execute has failed + elements. The default behavior is to continue.

+ +

The consequence of this failure semantics is that we may have + multiple elements in the range failed for different reasons. + For example, if we tried to persist a number of objects, some + of them might have failed because they are already persistent + while others — because of a unique constraint violation. + As a result, ODB uses the special odb::multiple_exceptions + class to report failures in the bulk API functions. This + exception is thrown if one or more elements in the range have + failed and it contains the error information in the form of other + ODB exception for each failed position. The + multiple_exceptions class has the following interface:

+ + 
+struct multiple_exceptions: odb::exception
+{
+  // Element type.
+  //
+  struct value_type
+  {
+    std::size_t
+    position () const;
+
+    const odb::exception&
+    exception () const;
+
+    bool
+    maybe () const;
+  };
+
+  // Iteration.
+  //
+  typedef std::set<value_type> set_type;
+
+  typedef set_type::const_iterator iterator;
+  typedef set_type::const_iterator const_iterator;
+
+  iterator
+  begin () const;
+
+  iterator
+  end () const;
+
+  // Lookup.
+  //
+  const value_type*
+  operator[] (std::size_t) const;
+
+  // Severity, failed and attempted counts.
+  //
+  std::size_t
+  attempted () const;
+
+  std::size_t
+  failed () const;
+
+  bool
+  fatal () const;
+
+  void
+  fatal (bool);
+
+  // Direct data access.
+  //
+  const set_type&
+  set () const;
+
+  // odb::exception interface.
+  //
+  virtual const char*
+  what () const throw ();
+};
+
+ +

The multiple_exceptions class has a map-like interface + with the key being the position in the range and the value being + the exception plus the maybe flag (discussed below). + As a result, we can either iterate over the failed positions or + we can check whether a specific position in the range has failed. + The following example shows what a catch-handler for + this exception might look like:

+ + 
+std::vector<person> objs {{"John", "Doe"}, {"Jane", "Doe"}};
+
+try
+{
+  db.persist (objs.begin (), objs.end ());
+}
+catch (const odb::multiple_exceptions& me)
+{
+  for (const auto& v: me)
+  {
+    size_t p (v.position ());
+
+    try
+    {
+      throw v.exception ();
+    }
+    catch (const odb::object_already_persistent&)
+    {
+      cerr << p << ": duplicate id: " << objs[p].id () << endl;
+    }
+    catch (const odb::exception& e)
+    {
+      cerr << p << ": " << e.what () << endl;
+    }
+  }
+}
+
+ +

If, however, all we want is to show the diagnostics to the user, + then the string returned by the what() function + will contain the error information for each failed position. + Here is what it might look like (using Oracle as an example):

+ + 
+multiple exceptions, 4 elements attempted, 2 failed:
+[0] object already persistent
+[3] 1: ORA-00001: unique constraint (ODB_TEST.person_last_i) violated
+
+ +

Both databases that currently are capable of bulk operations return + a total count of affected rows rather than individual counts for + each data set. This limitation prevents ODB from being able to + always determine which elements in the batch haven't affected + any rows and, for the update and erase operations, translate + this to the object_not_persistent exceptions. As + a result, if some elements in the batch haven't affected any + rows and ODB is unable to determine exactly which ones, it will mark + all the elements in this batch as "maybe not persistent". That + is, it will insert the object_not_persistent exception + and set the maybe flag for every position in the + batch. The diagnostics string returned by what() + will also reflect this situation, for example (assuming batch + size of 3):

+ + 
+multiple exceptions, 4 elements attempted, 4 failed:
+[0-2] (some) object not persistent
+[3] object not persistent
+
+ +

The way to handle and recover from such "maybe failures" will have + to be application-specific. For example, for some applications the + fact that some objects no longer exist in the database when + performing bulk erase might be an ignorable error. If, however, + the application needs to determine exactly which elements in the batch + have failed, then a load() call will be required for each + element in the batch (or a query using a view to avoid loading all + the data members; Chapter 10, "Views"). This is also + something to keep in mind when selecting the batch size since for + larger sizes it will be more expensive (more loads to perform) to + handle such "maybe failures". If the failures are not uncommon, as + is the case, for example, when using optimistic concurrency, then + it may make sense to use a smaller batch.

+ +

The lookup operator (operator[]) returns NULL + if the element at this position has no exception. Note also that the + returned value is value_type* and not + odb::exception* in order to provide access to the + maybe flag discussed above.

+ +

The multiple_exceptions class also provides access + to the number of positions attempted (the attempted() + accessor) and failed (the failed() accessor). Note + that the failed count includes the "maybe failed" positions.

+ +

The multiple_exceptions exception can also be fatal. + If the fatal() accessor returns true, then + (some of) the exceptions were fatal. In this case, even for positions + that did not fail, no attempts were made to complete the operation + and the transaction must be aborted.

+ +

If fatal() returns false, then the operation on the + elements that don't have an exception has succeeded. The application + can ignore the errors or try to correct the errors and re-attempt + the operation on the elements that did fail. In either case, the + transaction can be committed.

+ +

An example of a fatal exception would be the situation where the + execution of the underlying statement failed summarily, without + attempting any data sets, for instance, because of an error in + the statement itself.

+ +

The fatal() modifier allows you to "upgrade" an + exception to fatal, for example, for specific database error + codes.

+ + + + + +
+

PART II   + DATABASE SYSTEMS

+ +

Part II covers topics specific to the database system + implementations and their support in ODB. The first chapter in + Part II discusses how to use multiple database systems in the + same application. The subsequent chapters describe the system-specific + database classes as well as the default mapping + between basic C++ value types and native database types. Part + II consists of the following chapters.

+ + + + + + + + +
16Multi-Database Support
17MySQL Database
18SQLite Database
19PostgreSQL Database
20Oracle Database
21Microsoft SQL Server Database
+ + + + + +
+

16 Multi-Database Support

+ +

Some applications may need to access multiple database systems, either + simultaneously or one at a time. For example, an application may + utilize an embedded database such as SQLite as a local cache and use + a client-server database such as PostgreSQL for more permanent + but slower to access remote storage. Or an application may need + to be able to store its data in any database selected at runtime + by the user. Yet another scenario is the data migration from one + database system to another. In this case, multi-database support + is only required for a short period. It is also plausible that an + application implements all three of these scenarios, that is, it + uses SQLite as a local cache, allows the user to select the remote + database system, and supports data migration from one remote database + system to another.

+ +

ODB provides two types of multi-database support: static + and dynamic. With static support we use the + database system-specific interfaces to perform database + operations. That is, instead of using odb::database, + odb::transaction, or odb::query, we + would use, for example, odb::sqlite::database, + odb::sqlite::transaction, or + odb::sqlite::query to access an SQLite database.

+ +

In contrast, with dynamic multi-database support we can + use the common interface to access any database without having to + know which one it is. At runtime, ODB will automatically dispatch + a call on the common interface to the specific database implementation + based on the actual database instance being + used. In fact, this mechanism is very similar to C++ virtual + functions.

+ +

Both static and dynamic multi-database support have a different set + of advantages and disadvantages which makes them more or less suitable + for different use cases. Static support has zero overhead compared + to single-database support and allows us to use database + system-specific features, extensions, etc. At the same time, the + code that we write will be tied to the specific database system. + As a result, this type of multi-database support is more + suitable for situations where different parts of an application + access different but specific database systems. For example, + using SQLite as a local cache most likely falls into this + category since we are using a specific database system (SQLite) + and the code that will check the cache will most likely (but + not necessarily) be separate from the code that interact with + the remote database. Another example where static multi-database + support might be more suitable is a once-off data migration from + one database system to another. In this case both the source and + target are specific database systems. In contrast, if data migration + from one database system to another is a general feature in an + application, then dynamic multi-database support might be more + suitable.

+ +

The main advantage of dynamic multi-database support is the + database system-independence of the code that we write. The same + application code will work with any database system supported by + ODB and the generated database support code can be packaged into + separate libraries and loaded dynamically by the application. The + disadvantages of dynamic support are slight overhead and certain + limitations in functionality compared to static support (see + Section 16.2, "Dynamic Multi-Database Support" + for details). As a result, dynamic multi-database support is most + suitable to situations where we need the same code to + work with a range of database systems. For example, if your + application must be able to store its data in any database + selected by the user, then dynamic support is probably the + best option.

+ +

Note also that it is possible to mix and match static and dynamic + support in the same application. In fact, dynamic support is built + on top of static support so it is possible to use the same database + system both "statically" and "dynamically". In particular, the ability + to "drop down" from dynamic to static support can be used to overcome + the functionality limitations mentioned above. Finally, + single-database support is just a special case of static + multi-database support with a single database system.

+ +

By default ODB assumes single-database support. To enable + multi-database support we use the --multi-database + (or -m) ODB compiler option. This option is also used to + specify the support type: static or dynamic. + For example:

+ + 
+odb -m static ... person.hxx
+
+ +

With multi-database support enabled, we can now generate the database + support code for several database systems. This can be accomplished + either with a single ODB compiler invocation by specifying multiple + --database (or -d) options or with multiple + ODB compiler invocations. Both approaches produce the same result, + for example:

+ + 
+odb -m static -d common -d sqlite -d pgsql person.hxx
+
+ +

Is equivalent to:

+ + 
+odb -m static -d common person.hxx
+odb -m static -d sqlite person.hxx
+odb -m static -d pgsql person.hxx
+
+ +

Notice that the first -d option has common + as its value. This is not a real database system. Rather, it instructs + the ODB compiler to generate code that is common to all the database + systems and, in case of dynamic support, is also the common + interfaces.

+ +

If you look at the result of the above commands, you will also notice + changes in the output file names. In the single-database mode the ODB + compiler produces a single set of the person-odb.?xx files + which contain both the common as well as the database specific + generated code (since there is only one database system in use, + there is no reason to split the two). In contrast, in the + multi-database mode, the person-odb.?xx set of files + contains the common code while the database system-specific code is + written to files in the form person-odb-<db>.?xx. + That is, person-odb-sqlite.?xx for SQLite, + person-odb-pgsql.?xx for PostgreSQL, etc.

+ +

If we need dynamic support for some databases and static for + others, then the common code must be generated + in the dynamic mode. For example, if we need static support + for SQLite and dynamic support for PostgreSQL and Oracle, then + the ODB compiler invocations could look like this:

+ + 
+odb -m dynamic -d common person.hxx
+odb -m static -d sqlite person.hxx
+odb -m dynamic -d pgsql person.hxx
+odb -m dynamic -d oracle person.hxx
+
+ +

With multi-database support enabled, it is possible to restrict ODB + pragmas to apply only to a specific database system (unrestricted + pragmas apply to all the databases). For example:

+ + 
+#pragma db object
+class person
+{
+  ...
+
+  #pragma db pgsql:type("VARCHAR(128)") sqlite:type("TEXT")
+  std::string name_;
+
+  unsigned short age_;
+
+  #pragma db pgsql index member(age_)
+};
+
+ +

Above, the pragma for the name_ data member shows the + use of a database prefix (for example, pgsql:) that + only applies to the specifier that follows. The pragma that defines + an index on the age_ data member shows the use of a + database prefix that applies to the whole pragma. In this case the + database name must immediately follow the db keyword.

+ + +

Similar to pragmas, ODB compiler options that determine the kind + (for example, --schema-format), names (for example, + --odb-file-suffix), or content (for example, prologue + and epilogue options) of the output files can be prefixed with the + database name. For example:

+ + 
+odb --odb-file-suffix common:-odb-common ...
+
+ +

Dynamic multi-database support requires consistent mapping across + all the databases. That is, the same classes and data members + should be mapped to objects, simple/composite values, etc., for + all the databases. In contrast, static multi-database support + does not have this restriction. Specifically, with static support, + some data members can be transient for some database systems. + Similarly, the same class (for example, point) can + be mapped to a simple value in one database (for example, to the + POINT PostgreSQL type) and to a composite value + in another (for example, in SQLite, which does not have a + built-in point type).

+ +

The following sections discuss static and dynamic multi-database + support in more detail.

+ + +

16.1 Static Multi-Database Support

+ +

With static multi-database support, instead of including + person-odb.hxx, application source code has + to include person-odb-<db>.hxx header files + corresponding to the database systems that will be used.

+ +

The application code has to also use database system-specific + interfaces when performing database operations. As an example, + consider the following transaction in a single-database + application. It uses the common interfaces, that is, classes + from the odb namespace.

+ + 
+#include "person-odb.hxx"
+
+odb::database& db = ...
+
+typedef odb::query<person> query;
+typedef odb::result<person> result;
+
+odb::transaction t (db.begin ());
+result r (db.query<person> (query::age < 30));
+...
+t.commit ();
+
+ +

In an application that employs static multi-database support + the same transaction for SQLite would be rewritten like this:

+ + 
+#include "person-odb-sqlite.hxx"
+
+odb::sqlite::database& db = ...
+
+typedef odb::sqlite::query<person> query;
+typedef odb::result<person> result;      // odb:: not odb::sqlite::
+
+odb::sqlite::transaction t (db.begin ());
+result r (db.query<person> (query::age < 30));
+...
+t.commit ();
+
+ +

That is, the database, transaction, and + query classes now come from the odb::sqlite + namespace instead of odb. Other classes that have + database system-specific interfaces are connection, + statement, and tracer. Note that + all of them derive from the corresponding common versions. It + is also possible to use common transaction, + connection, and statement classes + with static support, if desired.

+ +

Notice that we didn't use the odb::sqlite namespace + for the result class template. This is because + result is database system-independent. All other + classes defined in namespace odb, except those + specifically mentioned above, are database system-independent. + In particular, result, prepared_query, + session, schema_catalog, and all the + exceptions are database system-independent.

+ +

Writing odb::sqlite:: before every name can quickly + become burdensome. As we have seen before, in single-database + applications that use the common interface we can add the + using namespace directive to avoid qualifying + each name. For example:

+ + 
+#include "person-odb.hxx"
+
+odb::database& db = ...
+
+{
+  using namespace odb::core;
+
+  typedef query<person> person_query;
+  typedef result<person> person_result;
+
+  transaction t (db.begin ());
+  person_result r (db.query<person> (person_query::age < 30));
+  ...
+  t.commit ();
+}
+
+ +

A similar mechanism is available in multi-database support. Each + database runtime defines the odb::<db>::core + namespace that contains all the database system-independent + names as well as the database system-specific ones for this + database. Here is how we can rewire the above transaction + using this approach:

+ + 
+#include "person-odb-sqlite.hxx"
+
+odb::sqlite::database& db = ...
+
+{
+  using namespace odb::sqlite::core;
+
+  typedef query<person> person_query;
+  typedef result<person> person_result;
+
+  transaction t (db.begin ());
+  person_result r (db.query<person> (person_query::age < 30));
+  ...
+  t.commit ();
+}
+
+ +

If the using namespace directive cannot be used, for + example, because the same code fragment accesses several databases, + then we can still make the namespace qualifications more concise + by assigning shorter aliases to database namespaces. For example:

+ + 
+#include "person-odb-pgsql.hxx"
+#include "person-odb-sqlite.hxx"
+
+namespace pg = odb::pgsql;
+namespace sl = odb::sqlite;
+
+pg::database& pg_db = ...
+sl::database& sl_db = ...
+
+typedef pg::query<person> pg_query;
+typedef sl::query<person> sl_query;
+typedef odb::result<person> result;
+
+// First check the local cache.
+//
+odb::transaction t (sl_db.begin ()); // Note: using common transaction.
+result r (sl_db.query<person> (sl_query::age < 30));
+
+// If no hits, try the remote database.
+//
+if (r.empty ())
+{
+  t.commit ();              // End the SQLite transaction.
+  t.reset (pg_db.begin ()); // Start the PostgreSQL transaction.
+
+  r = pg_db.query<person> (pg_query::age < 30);
+}
+
+// Handle the result.
+//
+...
+
+t.commit ();
+
+ +

With static multi-database support we can make one of the databases + the default database with the --default-database option. + The default database can be accessed via the common interface, just + like with single-database support. For example:

+ + 
+odb -m static -d common -d pgsql -d sqlite --default-database pgsql ...
+
+ +

The default database mechanism can be useful when one of the + databases is primary or when retrofitting multi-database support + into an existing single-database application. For example, if + we are adding SQLite as a local cache into an existing + application that uses PostgreSQL as its only database, then + by making PostgreSQL the default database we avoid having to + change all the existing code. Note that if dynamic multi-database + support is enabled, then the common (dynamic) interface is always + made the default database.

+ +

16.2 Dynamic Multi-Database Support

+ +

With dynamic multi-database support, application source code only + needs to include the person-odb.hxx header file, just + like with single-database support. In particular, we don't need + to include any of the person-odb-<db>.hxx files + unless we would also like to use certain database systems in the + static multi-database mode.

+ +

When performing database operations, the application code + uses the common interfaces from the odb namespace, + just like with single-database support. As an example, consider + a function that can be used to load an object either from a local + SQLite cache or a remote PostgreSQL database (in reality, this + function can be used with any database system support by ODB + provided we generated the database support code for this database + and linked it into our application):

+ + 
+#include "person-odb.hxx"
+
+std::unique_ptr<person>
+load (odb::database& db, const std::string& name)
+{
+  odb::transaction t (db.begin ());
+  std::unique_ptr<person> p (db.find (name));
+  t.commit ();
+  return p;
+}
+
+odb::pgsql::database& pg_db = ...
+odb::sqlite::database& sl_db = ...
+
+// First try the local cache.
+//
+std::unique_ptr<person> p (load (sl_db, "John Doe"));
+
+// If not found, try the remote database.
+//
+if (p == 0)
+  p = load (pg_db, "John Doe");
+
+...
+
+ +

As you can see, we can use dynamic multi-database support just like + single-database support except that now our code can work with + different database systems. Note, however, one difference: with + single-database support we could perform database operations using + either the common odb::database or a database system-specific + (for example, odb::sqlite::database) interface + with the same effect. In contrast, with dynamic multi-database support, + the use of the database system-specific interface results in the + switch to the static mode (for which, as was mentioned earlier, we would + need to include the corresponding person-odb-<db>.hxx + header file). As we will discuss shortly, switching from dynamic to + static mode can be used to overcome limitations imposed by dynamic + multi-database support.

+ +

Dynamic multi-database support has certain overheads and limitations + compared to static support. For database operations, the generated code + maintains function tables that are used to dispatch calls to the database + system-specific implementations. In single-database and static + multi-database support, the query type implements a thin + wrapper around the underlying database system's SELECT + statement. With dynamic multi-database support, because the + underlying database system is only known at query execution + (or preparation) time, the query type stores a + database system-independent representation of the query that + is then translated to the database system-specific form. Because + of this database system-independent representation, dynamic + support queries have a number of limitations. Specifically, dynamic + queries do not support parameter binding in native query fragments. + They also make copies of by-value parameterd (by-reference parameters + can be used to remove this overhead). Finally, parameters of array + types (for example, char[256]) can only be bound + by-reference.

+ +

As we mentioned earlier, switching from dynamic to static mode + can be an effective way to overcome these limitations. As an + example, consider a function that prints the list of people of + a certain age. The caller also specified the limit on the number + of entries to print. Some database systems, for example, PostgreSQL, + allow us to propagate this limit to the database server with the + LIMIT clause. To add this clause we would need to + construct a native query fragment and, as we discussed above, we + won't be able to bind a parameter (the limit) while in the dynamic + mode. The following implementation shows how we can overcome this + by switching to the static mode and using the PostgreSQL-specific + interface:

+ + 
+#include "person-odb.hxx"
+#include "person-odb-pgsql.hxx" // Needed for static mode.
+
+void
+print (odb::database& db, unsigned short age, unsigned long limit)
+{
+  typedef odb::query<person> query;
+  typedef odb::result<person> result;
+
+  odb::transaction t (db.begin ());
+
+  query q (query::age == age);
+  result r;
+
+  if (db.id () == odb::id_pgsql)
+  {
+    // We are using PostgreSQL. Drop down to the static mode and
+    // add the LIMIT clause to the query.
+    //
+    namespace pg = odb::pgsql;
+    typedef pg::query<person> pg_query;
+
+    pg::database& pg_db (static_cast<pg::database&> (db));
+    pg_query pg_q (pg_query (q) + "LIMIT" + pg_query::_val (limit));
+    r = pg_db.query<person> (pg_q);
+  }
+  else
+    r = db.query<person> (q);
+
+  // Handle the result up to the limit elements.
+  //
+  ...
+
+  t.commit ();
+}
+
+odb::pgsql::database& pg_db = ...
+odb::sqlite::database& sl_db = ...
+
+print (sl_db, 30, 100);
+print (sl_db, 30, 100);
+
+ +

A few things to note about this example. First, we use the + database::id() function to determine the actual database + system we use. This function has the following signature:

+ + 
+namespace odb
+{
+  enum database_id
+  {
+    id_mysql,
+    id_sqlite,
+    id_pgsql,
+    id_oracle,
+    id_mssql,
+    id_common
+  };
+
+  class database
+  {
+  public:
+    ...
+
+    database_id
+    id () const;
+  }
+}
+
+ +

Note that database::id() can never return the + id_common value.

+ +

The other thing to note is how we translate the dynamic query + to the database system-specific one (the pg_query (q) + expression). Every odb::<db>::query class provides + such a translation constructor.

+ +

16.2.2 Dynamic Loading of Database Support Code

+ +

With dynamic multi-database support, the generated database support + code automatically registers itself with the function tables that + we mentioned earlier. This makes it possible to package the generated + code for each database into a separate dynamic-link library (Windows + DLL) or dynamic shared object (Unix DSO; collectively referred to as + DLLs from now on) and load/unload them from the application + dynamically using APIs such as Win32 LoadLibrary() or + POSIX dlopen(). This allows the application address + space to contain code only for database systems that are actually + needed in any particular moment. Another advantage of this approach + is the ability to distribute individual database system support + separately.

+ +

This section provides an overview of how to package the generated + database support code into DLLs for both Windows and Unix using + GNU/Linux as an example. Note also that if static multi-database + support is used for a particular database system, then the dynamic + loading cannot be used for this database. It is, however, still + possible to package the generated code into a DLL but this DLL + will have to be linked to the executable at link-time rather + than at runtime. If dynamic loading is desirable in this situation, + then another alternative would be to package the functionality + that requires static support together with the database support + code into the DLL and import this functionality dynamically + using the GetProcAddress() (Win32) or dlsym() + (Unix) function.

+ +

The first step in packaging the generated code into DLLs is to + set up the symbol exporting. This step is required for + Windows DLLs but is optional for Unix DSOs. Most modern Unix + systems (such as GNU/Linux) provide control over symbol + visibility, which is a mechanism similar to Windows symbol + exporting. Notable advantages of using this mechanism to + explicitly specify which symbols are visible include + smaller Unix DSOs and faster load times. If, however, you are + not planning to control symbol visibility on Unix, then you can + skip directly to the second step below.

+ +

An important point to understand is that we only need to export + the common interface, that is, the classes defined in the + person-odb.hxx header. In particular, we don't need + to export the database system-specific classes defined in + the person-odb-<db>.hxx, unless we are also using + this database in the static mode (in which case, the procedure + described below will need to be repeated for that database as + well).

+ +

The ODB compiler provides two command line options, + --export-symbol and --extern-symbol, + which can be used to insert the export and extern + macros in all the necessary places in the generated header file. + You are probably familiar with the concept of export macro which + expands to an export directive if we are building the DLL and to + an import directive if we are building client code. The + extern macro is a supplementary mechanism which is necessary to + export explicit template instantiations used by the generated + code when query support is enabled. As we will see shortly, the + extern macro must expand into the extern C++ keyword + in certain situations and must be left undefined in others. To + manage all these macro definitions, it is customary to create the + so called export header. Based on a single macro that is normally + defined in the project file or on the command line and which + indicates whether we are building the DLL or client code, the + export header file sets the export and extern macros to their + appropriate values. Continuing with our person example, on Windows + the export header, which we will call person-export.hxx, + could look like this:

+ + 
+// person-export.hxx
+//
+// Define PERSON_BUILD_DLL if we are building the DLL. Leave it
+// undefined in client code.
+//
+#ifndef PERSON_EXPORT_HXX
+#define PERSON_EXPORT_HXX
+
+#ifdef PERSON_BUILD_DLL
+#  define PERSON_EXPORT __declspec(dllexport)
+#else
+#  define PERSON_EXPORT __declspec(dllimport)
+#  define PERSON_EXTERN extern
+#endif
+
+#endif // PERSON_EXPORT_HXX
+
+ +

The equivalent export header for GCC on GNU/Linux is shown below. + Note also that on GNU/Linux, by default, all symbols are visible + and we need to add the GCC -fvisibility=hidden option to + make them hidden by default.

+ + 
+// person-export.hxx
+//
+#ifndef PERSON_EXPORT_HXX
+#define PERSON_EXPORT_HXX
+
+#define PERSON_EXPORT __attribute__ ((visibility ("default")))
+#define PERSON_EXTERN extern
+
+#endif // PERSON_EXPORT_HXX
+
+ +

Next we need to export the person persistent class + using the export macro and re-compile our person.hxx file + with the --export-symbol and --extern-symbol + options. We will also need to include person-export.hxx + into the generated person-odb.hxx file. For that we use + the --hxx-prologue option. Here is how we can do + this with multiple invocations of the ODB compiler:

+ + 
+odb -m dynamic -d common --hxx-prologue "#include \"person-export.hxx\"" \
+--export-symbol PERSON_EXPORT --extern-symbol PERSON_EXTERN person.hxx
+
+odb -m dynamic -d sqlite person.hxx
+odb -m dynamic -d pgsql person.hxx
+
+ +

It is also possible to achieve the same with a single invocation. + Here we need to restrict some option values to apply only to the + common database:

+ + 
+odb -m dynamic -d common -d sqlite -d pgsql \
+--hxx-prologue "common:#include \"person-export.hxx\"" \
+--export-symbol common:PERSON_EXPORT --extern-symbol common:PERSON_EXTERN \
+person.hxx
+
+ +

The second step in packaging the generated code into DLLs is to + decide where to place the generated common interface code. One + option is to place it into a DLL of its own so that we will end + up with (replace *.dll with lib*.so for + Unix): person.dll plus person-sqlite.dll and + person-pgsql.dll, which both link to person.dll, + as well as person.exe, which links to person.dll + and dynamically loads person-sqlite.dll + and/or person-pgsql.dll. If this is the organization + that you prefer, then the next step is to build all the DLLs as you + normally would any other DLL, placing person-odb.cxx + and person.cxx into person.dll, + person-odb-sqlite.cxx into person-sqlite.dll, + etc. Note that in the pure dynamic multi-database support, + person-sqlite.dll and person-pgsql.dll + do not export any symbols.

+ +

We can improve on the above organization by getting rid of + person.dll, which is not really necessary unless + we have multiple executables sharing the same database support. + To achieve this, we will place person-odb.cxx into + person.exe and export its symbols from the executable + instead of a DLL. Exporting symbols from an executable is a seldom + used functionality, especially on Windows, however, it is well + supported on both Windows and most Unix platforms. Note also that + this approach won't work if we also use one of the databases in the + static mode.

+ +

On Windows all we have to do is place person-odb.cxx + into the executable and compile it as we would in a DLL (that is, + with the PERSON_BUILD_DLL macro defined). If Windows + linker detects that an executable exports any symbols, then it + will automatically create the corresponding import library + (person.lib in our case). We then use this import + library to build person-sqlite.dll and + person-pgsql.dll as before.

+ +

To export symbols from an executable on GNU/Linux all we need to + do is add the -rdynamic option when linking our + executable.

+ + + + +
+

17 MySQL Database

+ +

To generate support code for the MySQL database you will need + to pass the "--database mysql" + (or "-d mysql") option to the ODB compiler. + Your application will also need to link to the MySQL ODB runtime + library (libodb-mysql). All MySQL-specific ODB + classes are defined in the odb::mysql namespace.

+ +

17.1 MySQL Type Mapping

+ +

The following table summarizes the default mapping between basic + C++ value types and MySQL database types. This mapping can be + customized on the per-type and per-member basis using the ODB + Pragma Language (Chapter 14, "ODB Pragma + Language").

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
C++ TypeMySQL TypeDefault NULL Semantics
boolTINYINT(1)NOT NULL
charCHAR(1)NOT NULL
signed charTINYINTNOT NULL
unsigned charTINYINT UNSIGNEDNOT NULL
shortSMALLINTNOT NULL
unsigned shortSMALLINT UNSIGNEDNOT NULL
intINTNOT NULL
unsigned intINT UNSIGNEDNOT NULL
longBIGINTNOT NULL
unsigned longBIGINT UNSIGNEDNOT NULL
long longBIGINTNOT NULL
unsigned long longBIGINT UNSIGNEDNOT NULL
floatFLOATNOT NULL
doubleDOUBLENOT NULL
std::stringTEXT/VARCHAR(255)NOT NULL
char[N]VARCHAR(N-1)NOT NULL
+ +

It is possible to map the char C++ type to an integer + database type (for example, TINYINT) using the + db type pragma (Section 14.4.3, + "type").

+ +

Note that the std::string type is mapped + differently depending on whether a member of this type + is an object id or not. If the member is an object id, + then for this member std::string is mapped + to the VARCHAR(255) MySQL type. Otherwise, + it is mapped to TEXT.

+ +

Additionally, by default, C++ enums and C++11 enum classes are + automatically mapped to suitable MySQL types. Contiguous + enumerations with the zero first enumerator are mapped to + the MySQL ENUM type. All other enumerations + are mapped to the MySQL types corresponding to their + underlying integral types (see table above). In both + cases the default NULL semantics is + NOT NULL. For example:

+ + 
+enum color {red, green, blue};
+enum class taste: unsigned char
+{
+  bitter = 1, // Non-zero first enumerator.
+  sweet,
+  sour = 4,   // Non-contiguous.
+  salty
+};
+
+#pragma db object
+class object
+{
+  ...
+
+  color color_; // Mapped to ENUM ('red', 'green', 'blue') NOT NULL.
+  taste taste_; // Mapped to TINYNT UNSIGNED NOT NULL.
+};
+
+ +

It is also possible to add support for additional MySQL types, + such as geospatial types. For more information, refer to + Section 14.8, "Database Type Mapping + Pragmas".

+ +

17.1.1 String Type Mapping

+ +

The MySQL ODB runtime library provides support for mapping the + std::string, char[N], and + std::array<char, N> types to the MySQL CHAR, + VARCHAR, TEXT, NCHAR, and + NVARCHAR types. However, these mappings are not enabled + by default (in particular, by default, std::array will + be treated as a container). To enable the alternative mappings for + these types we need to specify the database type explicitly using + the db type pragma (Section + 14.4.3, "type"), for example:

+ + 
+#pragma db object
+class object
+{
+  ...
+
+  #pragma db type("CHAR(2)")
+  char state_[2];
+
+  #pragma db type("VARCHAR(128)")
+  std::string name_;
+};
+
+ +

Alternatively, this can be done on the per-type basis, for example:

+ + 
+#pragma db value(std::string) type("VARCHAR(128)")
+
+#pragma db object
+class object
+{
+  ...
+
+  std::string name_; // Mapped to VARCHAR(128).
+};
+
+ +

The char[N] and std::array<char, N> values + may or may not be zero-terminated. When extracting such values from the + database, ODB will append the zero terminator if there is enough + space.

+ +

17.1.2 Binary Type Mapping

+ +

The MySQL ODB runtime library provides support for mapping the + std::vector<char>, + std::vector<unsigned char>, + char[N], unsigned char[N], + std::array<char, N>, and + std::array<unsigned char, N> + types to the MySQL BINARY, VARBINARY, + and BLOB types. However, these mappings are not enabled + by default (in particular, by default, std::vector and + std::array will be treated as containers). To enable the + alternative mappings for these types we need to specify the database + type explicitly using the db type pragma + (Section 14.4.3, "type"), for + example:

+ + 
+#pragma db object
+class object
+{
+  ...
+
+  #pragma db type("BLOB")
+  std::vector<char> buf_;
+
+  #pragma db type("BINARY(16)")
+  unsigned char uuid_[16];
+};
+
+ +

Alternatively, this can be done on the per-type basis, for example:

+ + 
+typedef std::vector<char> buffer;
+#pragma db value(buffer) type("BLOB")
+
+#pragma db object
+class object
+{
+  ...
+
+  buffer buf_; // Mapped to BLOB.
+};
+
+ +

Note also that in native queries (Chapter 4, "Querying + the Database") char[N] and + std::array<char, N> parameters are by default passed + as a string rather than a binary. To pass such parameters as a binary, + we need to specify the database type explicitly in the + _val()/_ref() calls. Note also that we + don't need to do this for the integrated queries, for example:

+ + 
+char u[16] = {...};
+
+db.query<object> ("uuid = " + query::_val<odb::mysql::id_blob> (u));
+db.query<object> (query::uuid == query::_ref (u));
+
+ +

17.2 MySQL Database Class

+ +

The MySQL database class has the following + interface:

+ + 
+namespace odb
+{
+  namespace mysql
+  {
+    class database: public odb::database
+    {
+    public:
+      database (const char* user,
+                const char* passwd,
+                const char* db,
+                const char* host = 0,
+                unsigned int port = 0,
+                const char* socket = 0,
+                const char* charset = 0,
+                unsigned long client_flags = 0,
+                std::[auto|unique]_ptr<connection_factory> = 0);
+
+      database (const std::string& user,
+                const std::string& passwd,
+                const std::string& db,
+                const std::string& host = "",
+                unsigned int port = 0,
+                const std::string* socket = 0,
+                const std::string& charset = "",
+                unsigned long client_flags = 0,
+                std::[auto|unique]_ptr<connection_factory> = 0);
+
+      database (const std::string& user,
+                const std::string* passwd,
+                const std::string& db,
+                const std::string& host = "",
+                unsigned int port = 0,
+                const std::string* socket = 0,
+                const std::string& charset = "",
+                unsigned long client_flags = 0,
+                std::[auto|unique]_ptr<connection_factory> = 0);
+
+      database (const std::string& user,
+                const std::string& passwd,
+                const std::string& db,
+                const std::string& host,
+                unsigned int port,
+                const std::string& socket,
+                const std::string& charset = "",
+                unsigned long client_flags = 0,
+                std::[auto|unique]_ptr<connection_factory> = 0);
+
+      database (const std::string& user,
+                const std::string* passwd,
+                const std::string& db,
+                const std::string& host,
+                unsigned int port,
+                const std::string& socket,
+                const std::string& charset = "",
+                unsigned long client_flags = 0,
+                std::[auto|unique]_ptr<connection_factory> = 0);
+
+      database (int& argc,
+                char* argv[],
+                bool erase = false,
+                const std::string& charset = "",
+                unsigned long client_flags = 0,
+                std::[auto|unique]_ptr<connection_factory> = 0);
+
+      static void
+      print_usage (std::ostream&);
+
+    public:
+      const char*
+      user () const;
+
+      const char*
+      password () const;
+
+      const char*
+      db () const;
+
+      const char*
+      host () const;
+
+      unsigned int
+      port () const;
+
+      const char*
+      socket () const;
+
+      const char*
+      charset () const;
+
+      unsigned long
+      client_flags () const;
+
+    public:
+      connection_ptr
+      connection ();
+    };
+  }
+}
+
+ +

You will need to include the <odb/mysql/database.hxx> + header file to make this class available in your application.

+ +

The overloaded database constructors allow us + to specify MySQL database parameters that should be used when + connecting to the database. In MySQL NULL and an + empty string are treated as the same values for all the + string parameters except password and + socket.

+ +

The charset argument allows us to specify the client + character set, that is, the character set in which the application + will encode its text data. Note that this can be different from + the MySQL server character set. If this argument is not specified or + is empty, then the default MySQL client character set is used, normally + latin1. Commonly used values for this argument are + latin1 (equivalent to Windows cp1252 and similar to + ISO-8859-1) and utf8. For other possible values + as well as more information on character set support in MySQL, + refer to the MySQL documentation.

+ +

The client_flags argument allows us to specify various + MySQL client library flags. For more information on the possible + values, refer to the MySQL C API documentation. The + CLIENT_FOUND_ROWS flag is always set by the MySQL ODB + runtime regardless of whether it was passed in the + client_flags argument.

+ +

The last constructor extracts the database parameters + from the command line. The following options are recognized:

+ + 
+  --user <login>
+  --password <password>
+  --database <name>
+  --host <host>
+  --port <integer>
+  --socket <socket>
+  --options-file <file>
+
+ +

The --options-file option allows us to specify some + or all of the database options in a file with each option appearing + on a separate line followed by a space and an option value.

+ +

If the erase argument to this constructor is true, + then the above options are removed from the argv + array and the argc count is updated accordingly. + This is primarily useful if your application accepts other + options or arguments and you would like to get the MySQL + options out of the argv array.

+ +

This constructor throws the odb::mysql::cli_exception + exception if the MySQL option values are missing or invalid. + See section Section 17.4, "MySQL Exceptions" + for more information on this exception.

+ +

The static print_usage() function prints the list of options + with short descriptions that are recognized by this constructor.

+ +

The last argument to all of the constructors is a pointer to the + connection factory. In C++98/03, it is std::auto_ptr while + in C++11 std::unique_ptr is used instead. If we pass a + non-NULL value, the database instance assumes ownership + of the factory instance. The connection factory interface as well as + the available implementations are described in the next section.

+ +

The set of accessor functions following the constructors allows us + to query the parameters of the database instance.

+ +

The connection() function returns a pointer to the + MySQL database connection encapsulated by the + odb::mysql::connection class. For more information + on mysql::connection, refer to Section + 17.3, "MySQL Connection and Connection Factory".

+ +

17.3 MySQL Connection and Connection Factory

+ +

The mysql::connection class has the following interface:

+ + 
+namespace odb
+{
+  namespace mysql
+  {
+    class connection: public odb::connection
+    {
+    public:
+      connection (database&);
+      connection (database&, MYSQL*);
+
+      MYSQL*
+      handle ();
+    };
+
+    typedef details::shared_ptr<connection> connection_ptr;
+  }
+}
+
+ +

For more information on the odb::connection interface, + refer to Section 3.6, "Connections". The first + overloaded mysql::connection constructor establishes a + new MySQL connection. The second constructor allows us to create + a connection instance by providing an already connected + native MySQL handle. Note that the connection + instance assumes ownership of this handle. The handle() + accessor returns the MySQL handle corresponding to the connection.

+ +

The mysql::connection_factory abstract class has the + following interface:

+ + 
+namespace odb
+{
+  namespace mysql
+  {
+    class connection_factory
+    {
+    public:
+      virtual void
+      database (database&) = 0;
+
+      virtual connection_ptr
+      connect () = 0;
+    };
+  }
+}
+
+ +

The database() function is called when a connection + factory is associated with a database instance. This happens in + the odb::mysql::database class constructors. The + connect() function is called whenever a database + connection is requested.

+ +

The two implementations of the connection_factory + interface provided by the MySQL ODB runtime are + new_connection_factory and + connection_pool_factory. You will need to include + the <odb/mysql/connection-factory.hxx> + header file to make the connection_factory interface + and these implementation classes available in your application.

+ +

The new_connection_factory class creates a new + connection whenever one is requested. When a connection is no + longer needed, it is released and closed. The + new_connection_factory class has the following + interface:

+ + 
+namespace odb
+{
+  namespace mysql
+  {
+    class new_connection_factory: public connection_factory
+    {
+    public:
+      new_connection_factory ();
+    };
+};
+
+ +

The connection_pool_factory class implements a + connection pool. It has the following interface:

+ + 
+namespace odb
+{
+  namespace mysql
+  {
+    class connection_pool_factory: public connection_factory
+    {
+    public:
+      connection_pool_factory (std::size_t max_connections = 0,
+                               std::size_t min_connections = 0,
+                               bool ping = true);
+
+    protected:
+      class pooled_connection: public connection
+      {
+      public:
+        pooled_connection (database_type&);
+        pooled_connection (database_type&, MYSQL*);
+      };
+
+      typedef details::shared_ptr<pooled_connection> pooled_connection_ptr;
+
+      virtual pooled_connection_ptr
+      create ();
+    };
+};
+
+ +

The max_connections argument in the + connection_pool_factory constructor specifies the maximum + number of concurrent connections that this pool factory will + maintain. Similarly, the min_connections argument + specifies the minimum number of available connections that + should be kept open. The ping argument specifies + whether the factory should validate the connection before + returning it to the caller.

+ +

Whenever a connection is requested, the pool factory first + checks if there is an unused connection that can be returned. + If there is none, the pool factory checks the + max_connections value to see if a new connection + can be created. If the total number of connections maintained + by the pool is less than this value, then a new connection is + created and returned. Otherwise, the caller is blocked until + a connection becomes available.

+ +

When a connection is released, the pool factory first checks + if there are blocked callers waiting for a connection. If so, then + one of them is unblocked and is given the connection. Otherwise, + the pool factory checks whether the total number of connections + maintained by the pool is greater than the min_connections + value. If that's the case, the connection is closed. Otherwise, the + connection is added to the pool of available connections to be + returned on the next request. In other words, if the number of + connections maintained by the pool exceeds min_connections + and there are no callers waiting for a new connection, + then the pool will close the excess connections.

+ +

If the max_connections value is 0, then the pool will + create a new connection whenever all of the existing connections + are in use. If the min_connections value is 0, then + the pool will never close a connection and instead maintain all + the connections that were ever created.

+ +

Connection validation (the ping argument) is useful + if your application may experience long periods of inactivity. In + such cases the MySQL server may close network connections that have + been inactive for too long. If during connection validation the pool + factory detects that the connection has been terminated, it silently + closes it and tries to find or create another connection instead.

+ +

The create() virtual function is called whenever the + pool needs to create a new connection. By deriving from the + connection_pool_factory class and overriding this + function we can implement custom connection establishment + and configuration.

+ +

If you pass NULL as the connection factory to + one of the database constructors, then the + connection_pool_factory instance will be + created by default with the min and max connections values + set to 0 and connection validation enabled. + The following code fragment shows how we can pass our own + connection factory instance:

+ + 
+#include <odb/database.hxx>
+
+#include <odb/mysql/database.hxx>
+#include <odb/mysql/connection-factory.hxx>
+
+int
+main (int argc, char* argv[])
+{
+  auto_ptr<odb::mysql::connection_factory> f (
+    new odb::mysql::connection_pool_factory (20));
+
+  auto_ptr<odb::database> db (
+    new mysql::database (argc, argv, false, 0, f));
+}
+
+ +

17.4 MySQL Exceptions

+ +

The MySQL ODB runtime library defines the following MySQL-specific + exceptions:

+ + 
+namespace odb
+{
+  namespace mysql
+  {
+    class database_exception: odb::database_exception
+    {
+    public:
+      unsigned int
+      error () const;
+
+      const std::string&
+      sqlstate () const;
+
+      const std::string&
+      message () const;
+
+      virtual const char*
+      what () const throw ();
+    };
+
+    class cli_exception: odb::exception
+    {
+    public:
+      virtual const char*
+      what () const throw ();
+    };
+  }
+}
+
+ +

You will need to include the <odb/mysql/exceptions.hxx> + header file to make these exceptions available in your application.

+ +

The odb::mysql::database_exception is thrown if + a MySQL database operation fails. The MySQL-specific error + information is accessible via the error(), + sqlstate(), and message() functions. + All this information is also combined and returned in a + human-readable form by the what() function.

+ +

The odb::mysql::cli_exception is thrown by the + command line parsing constructor of the odb::mysql::database + class if the MySQL option values are missing or invalid. The + what() function returns a human-readable description + of an error.

+ +

17.5 MySQL Limitations

+ +

The following sections describe MySQL-specific limitations imposed + by the current MySQL and ODB runtime versions.

+ +

17.5.1 Foreign Key Constraints

+ +

ODB relies on standard SQL behavior which requires that foreign + key constraints checking is deferred until the transaction is + committed. The only behaviors supported by MySQL are to either + check such constraints immediately (InnoDB engine) or to ignore + foreign key constraints altogether (all other engines). As a + result, by default, schemas generated by the ODB compiler for + MySQL have foreign key definitions commented out. They are + retained only for documentation.

+ +

You can override the default behavior and instruct the ODB + compiler to generate non-deferrable foreign keys by specifying + the --fkeys-deferrable-mode not_deferrable ODB + compiler option. Note, however, that in this case the order in + which you persist, update, and erase objects within a transaction + becomes important.

+ +

17.6 MySQL Index Definitions

+ +

When the index pragma (Section 14.7, + "Index Definition Pragmas") is used to define a MySQL index, + the type clause specifies the index type (for example, + UNIQUE, FULLTEXT, SPATIAL), + the method clause specifies the index method (for + example, BTREE, HASH), and the + options clause is not used. The column options + can be used to specify column length limits and the sort order. + For example:

+ + 
+#pragma db object
+class object
+{
+  ...
+
+  std::string name_;
+
+  #pragma db index method("HASH") member(name_, "(100) DESC")
+};
+
+ +

17.7 MySQL Stored Procedures

+ +

ODB native views (Section 10.6, "Native Views") + can be used to call MySQL stored procedures. For example, assuming + we are using the person class from Chapter + 2, "Hello World Example" (and the corresponding person + table), we can create a stored procedure that given the min and max + ages returns some information about all the people in that range:

+ + 
+CREATE PROCEDURE person_range (
+  IN min_age SMALLINT,
+  IN max_age SMALLINT)
+BEGIN
+  SELECT age, first, last FROM person
+    WHERE age >= min_age AND age <= max_age;
+END
+
+ +

Given the above stored procedure we can then define an ODB view + that can be used to call it and retrieve its result:

+ + 
+#pragma db view query("CALL person_range((?))")
+struct person_range
+{
+  unsigned short age;
+  std::string first;
+  std::string last;
+};
+
+ +

The following example shows how we can use the above view to + print the list of people in a specific age range:

+ + 
+typedef odb::query<person_range> query;
+typedef odb::result<person_range> result;
+
+transaction t (db.begin ());
+
+result r (
+  db.query<person_range> (
+    query::_val (1) + "," + query::_val (18)));
+
+for (result::iterator i (r.begin ()); i != r.end (); ++i)
+  cerr << i->first << " " << i->last << " " << i->age << endl;
+
+t.commit ();
+
+ +

Note that as with all native views, the order and types of data members + must match those of columns in the SELECT list inside + the stored procedure.

+ +

There are also a number of limitations when it comes to support for + MySQL stored procedures in ODB views. First of all, you have to use + MySQL server and client libraries version 5.5.3 or later since this + is the version in which support for calling stored procedures with + prepared statements was first added (the + mysql_stmt_next_result() function).

+ +

In MySQL, a stored procedure can produce multiple results. + For example, if a stored procedure executes several + SELECT statements, then the result of calling such + a procedure consists of two row sets, one for each SELECT + statement. Additionally, if the procedure has any OUT + or INOUT parameters, then their values are returned as + an additional special row set containing only a single row. + Because such multiple row sets can contain varying number + and type of columns, they cannot be all extracted into a + single view. As a result, an ODB view will only extract the + data from the first row set and ignore all the subsequent + ones.

+ +

In particular, this means that we can use an ODB view to extract + the values of the OUT and INOUT + parameters provided that the stored procedure does not generate + any other row sets. For example:

+ + 
+CREATE PROCEDURE person_min_max_age (
+  OUT min_age SMALLINT,
+  OUT max_age SMALLINT)
+BEGIN
+  SELECT MIN(age), MAX(age) INTO min_age, max_age FROM person;
+END
+
+ + 
+#pragma db view query("CALL person_min_max_age((?))")
+struct person_min_max_age
+{
+  unsigned short min_age;
+  unsigned short max_age;
+};
+
+ + 
+typedef odb::query<person_min_max_age> query;
+
+transaction t (db.begin ());
+
+// We know this query always returns a single row, so use query_value().
+// We have to pass dummy values for OUT parameters.
+//
+person_min_max_age mma (
+  db.query_value<person_min_max_age> (
+    query::_val (0) + "," + query::_val (0)));
+
+cerr << mma.min_age << " " << mma.max_age << endl;
+
+t.commit ();
+
+ +

Another limitation that stems from having multiple results is the + inability to cache the result of a stored procedure call. In + other words, a MySQL stored procedure call always produces an + uncached query result (Section 4.4, "Query + Result").

+ +
+

18 SQLite Database

+ +

To generate support code for the SQLite database you will need + to pass the "--database sqlite" + (or "-d sqlite") option to the ODB compiler. + Your application will also need to link to the SQLite ODB runtime + library (libodb-sqlite). All SQLite-specific ODB + classes are defined in the odb::sqlite namespace.

+ +

18.1 SQLite Type Mapping

+ +

The following table summarizes the default mapping between basic + C++ value types and SQLite database types. This mapping can be + customized on the per-type and per-member basis using the ODB + Pragma Language (Chapter 14, "ODB Pragma + Language").

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
C++ TypeSQLite TypeDefault NULL Semantics
boolINTEGERNOT NULL
charTEXTNOT NULL
signed charINTEGERNOT NULL
unsigned charINTEGERNOT NULL
shortINTEGERNOT NULL
unsigned shortINTEGERNOT NULL
intINTEGERNOT NULL
unsigned intINTEGERNOT NULL
longINTEGERNOT NULL
unsigned longINTEGERNOT NULL
long longINTEGERNOT NULL
unsigned long longINTEGERNOT NULL
floatREALNULL
doubleREALNULL
std::stringTEXTNOT NULL
char[N]TEXTNOT NULL
std::wstring (Windows only)TEXTNOT NULL
wchar_t[N] (Windows only)TEXTNOT NULL
+ +

It is possible to map the char C++ type to the + INTEGER SQLite type using the db type + pragma (Section 14.4.3, "type").

+ +

SQLite represents the NaN FLOAT value + as a NULL value. As a result, columns of the + float and double types are by default + declared as NULL. However, you can override this by + explicitly declaring them as NOT NULL with the + db not_null pragma (Section + 14.4.6, "null/not_null").

+ +

Additionally, by default, C++ enums and C++11 enum classes are + automatically mapped to the SQLite INTEGER type with + the default NULL semantics being NOT NULL. + For example:

+ + 
+enum color {red, green, blue};
+enum class taste: unsigned char
+{
+  bitter = 1,
+  sweet,
+  sour = 4,
+  salty
+};
+
+#pragma db object
+class object
+{
+  ...
+
+  color color_; // Automatically mapped to INTEGER.
+  taste taste_; // Automatically mapped to INTEGER.
+};
+
+ +

Note also that SQLite only operates with signed integers and the largest + value that an SQLite database can store is a signed 64-bit integer. As + a result, greater unsigned long and + unsigned long long values will be represented in + the database as negative values.

+ +

It is also possible to add support for additional SQLite types, + such as NUMERIC. For more information, refer to + Section 14.8, "Database Type Mapping + Pragmas".

+ +

18.1.1 String Type Mapping

+ +

The SQLite ODB runtime library provides support for mapping the + std::array<char, N> and, on Windows, + std::array<wchar_t, N> types to the SQLite + TEXT type. However, this mapping is not enabled by + default (in particular, by default, std::array will + be treated as a container). To enable the alternative mapping for + this type we need to specify the database type explicitly using + the db type pragma (Section + 14.4.3, "type"), for example:

+ + 
+#pragma db object
+class object
+{
+  ...
+
+  #pragma db type("TEXT")
+  std::array<char, 128> name_;
+};
+
+ +

Alternatively, this can be done on the per-type basis, for example:

+ + 
+typedef std::array<char, 128> name_type;
+#pragma db value(name_type) type("TEXT")
+
+#pragma db object
+class object
+{
+  ...
+
+  name_type name_; // Mapped to TEXT.
+};
+
+ +

The char[N], std::array<char, N>, + wchar_t[N], and std::array<wchar_t, N> + values may or may not be zero-terminated. When extracting such values + from the database, ODB will append the zero terminator if there is + enough space.

+ +

18.1.2 Binary Type Mapping

+ +

The SQLite ODB runtime library provides support for mapping the + std::vector<char>, + std::vector<unsigned char>, + char[N], unsigned char[N], + std::array<char, N>, and + std::array<unsigned char, N> + types to the SQLite BLOB type. However, these mappings + are not enabled by default (in particular, by default, + std::vector and std::array will be treated + as containers). To enable the alternative mappings for these types + we need to specify the database type explicitly using the + db type pragma (Section 14.4.3, + "type"), for example:

+ + 
+#pragma db object
+class object
+{
+  ...
+
+  #pragma db type("BLOB")
+  std::vector<char> buf_;
+
+  #pragma db type("BLOB")
+  unsigned char uuid_[16];
+};
+
+ +

Alternatively, this can be done on the per-type basis, for example:

+ + 
+typedef std::vector<char> buffer;
+#pragma db value(buffer) type("BLOB")
+
+#pragma db object
+class object
+{
+  ...
+
+  buffer buf_; // Mapped to BLOB.
+};
+
+ +

Note also that in native queries (Chapter 4, "Querying + the Database") char[N] and + std::array<char, N> parameters are by default passed + as a string rather than a binary. To pass such parameters as a binary, + we need to specify the database type explicitly in the + _val()/_ref() calls. Note also that we + don't need to do this for the integrated queries, for example:

+ + 
+char u[16] = {...};
+
+db.query<object> ("uuid = " + query::_val<odb::sqlite::id_blob> (u));
+db.query<object> (query::uuid == query::_ref (u));
+
+ +

18.2 SQLite Database Class

+ +

The SQLite database class has the following + interface:

+ + 
+namespace odb
+{
+  namespace sqlite
+  {
+    class database: public odb::database
+    {
+    public:
+      database (const std::string& name,
+                int flags = SQLITE_OPEN_READWRITE,
+                bool foreign_keys = true,
+                const std::string& vfs = "",
+                std::[auto|unique]_ptr<connection_factory> = 0);
+
+#ifdef _WIN32
+      database (const std::wstring& name,
+                int flags = SQLITE_OPEN_READWRITE,
+                bool foreign_keys = true,
+                const std::string& vfs = "",
+                std::[auto|unique]_ptr<connection_factory> = 0);
+#endif
+
+      database (int& argc,
+                char* argv[],
+                bool erase = false,
+                int flags = SQLITE_OPEN_READWRITE,
+                bool foreign_keys = true,
+                const std::string& vfs = "",
+                std::[auto|unique]_ptr<connection_factory> = 0);
+
+      static void
+      print_usage (std::ostream&);
+
+    public:
+      const std::string&
+      name () const;
+
+      int
+      flags () const;
+
+    public:
+      transaction
+      begin_immediate ();
+
+      transaction
+      begin_exclusive ();
+
+    public:
+      connection_ptr
+      connection ();
+    };
+  }
+}
+
+ +

You will need to include the <odb/sqlite/database.hxx> + header file to make this class available in your application.

+ +

The first constructor opens the specified SQLite database. The + name argument is the database file name to open in + the UTF-8 encoding. If this argument is empty, then a temporary, + on-disk database is created. If this argument is the + :memory: special value, then a temporary, in-memory + database is created. The flags argument allows us to + specify SQLite opening flags. For more information on the possible + values, refer to the sqlite3_open_v2() function description + in the SQLite C API documentation. The foreign_keys + argument specifies whether foreign key constraints checking + should be enabled. See Section 18.5.3, + "Foreign Key Constraints" for more information on foreign + keys. The vfs argument specifies the SQLite + virtual file system module that should be used to access the + database. If this argument is empty, then the default vfs module + is used. Again, refer to the sqlite3_open_v2() function + documentation for detail.

+ +

The following example shows how we can open the test.db + database in the read-write mode and create it if it does not exist:

+ + 
+auto_ptr<odb::database> db (
+  new odb::sqlite::database (
+    "test.db",
+    SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE));
+
+ +

The second constructor is the same as the first except that the database + name is passes as std::wstring in the UTF-16 encoding. This + constructor is only available when compiling for Windows.

+ +

The third constructor extracts the database parameters from the + command line. The following options are recognized:

+ + 
+  --database <name>
+  --create
+  --read-only
+  --options-file <file>
+
+ +

By default, this constructor opens the database in the read-write mode + (SQLITE_OPEN_READWRITE flag). If the --create + flag is specified, then the database file is created if it does + not already exist (SQLITE_OPEN_CREATE flag). If the + --read-only flag is specified, then the database is + opened in the read-only mode (SQLITE_OPEN_READONLY + flag instead of SQLITE_OPEN_READWRITE). The + --options-file option allows us to specify some + or all of the database options in a file with each option appearing + on a separate line followed by a space and an option value.

+ +

If the erase argument to this constructor is true, + then the above options are removed from the argv + array and the argc count is updated accordingly. + This is primarily useful if your application accepts other + options or arguments and you would like to get the SQLite + options out of the argv array.

+ +

The flags argument has the same semantics as in + the first constructor. Flags from the command line always override + the corresponding values specified with this argument.

+ +

The third constructor throws the odb::sqlite::cli_exception + exception if the SQLite option values are missing or invalid. + See Section 18.4, "SQLite Exceptions" + for more information on this exception.

+ +

The static print_usage() function prints the list of options + with short descriptions that are recognized by the third constructor.

+ +

The last argument to all of the constructors is a pointer to the + connection factory. In C++98/03, it is std::auto_ptr while + in C++11 std::unique_ptr is used instead. If we pass a + non-NULL value, the database instance assumes ownership + of the factory instance. The connection factory interface as well as + the available implementations are described in the next section.

+ +

The set of accessor functions following the constructors allows us + to query the parameters of the database instance.

+ +

The begin_immediate() and begin_exclusive() + functions are the SQLite-specific extensions to the standard + odb::database::begin() function (see + Section 3.5, "Transactions"). They allow us + to start an immediate (BEGIN IMMEDIATE) and an exclusive + (BEGIN EXCLUSIVE) SQLite transaction, respectively. + For more information on the semantics of the immediate and exclusive + transactions, refer to the BEGIN statement description + in the SQLite documentation.

+ +

The connection() function returns a pointer to the + SQLite database connection encapsulated by the + odb::sqlite::connection class. For more information + on sqlite::connection, refer to Section + 18.3, "SQLite Connection and Connection Factory".

+ +

18.3 SQLite Connection and Connection Factory

+ +

The sqlite::connection class has the following interface:

+ + 
+namespace odb
+{
+  namespace sqlite
+  {
+    class connection: public odb::connection
+    {
+    public:
+      connection (database&, int extra_flags = 0);
+      connection (database&, sqlite3*);
+
+      transaction
+      begin_immediate ();
+
+      transaction
+      begin_exclusive ();
+
+      sqlite3*
+      handle ();
+    };
+
+    typedef details::shared_ptr<connection> connection_ptr;
+  }
+}
+
+ +

For more information on the odb::connection interface, + refer to Section 3.6, "Connections". The first + overloaded sqlite::connection constructor opens + a new SQLite connection. The extra_flags argument can + be used to specify extra sqlite3_open_v2() flags + that are combined with the flags specified in the + sqlite::database constructor. The second constructor + allows us to create a connection instance by providing + an already open native SQLite handle. Note that the + connection instance assumes ownership of this handle.

+ +

The begin_immediate() and begin_exclusive() + functions allow us to start an immediate and an exclusive SQLite + transaction on the connection, respectively. Their semantics are + equivalent to the corresponding functions defined in the + sqlite::database class (Section 18.2, + "SQLite Database Class"). The handle() accessor + returns the SQLite handle corresponding to the connection.

+ +

The sqlite::connection_factory abstract class has the + following interface:

+ + 
+namespace odb
+{
+  namespace sqlite
+  {
+    class connection_factory
+    {
+    public:
+      virtual void
+      database (database&) = 0;
+
+      virtual connection_ptr
+      connect () = 0;
+    };
+  }
+}
+
+ +

The database() function is called when a connection + factory is associated with a database instance. This happens in + the odb::sqlite::database class constructors. The + connect() function is called whenever a database + connection is requested.

+ +

The three implementations of the connection_factory + interface provided by the SQLite ODB runtime library are + single_connection_factory, + new_connection_factory, and + connection_pool_factory. You will need to include + the <odb/sqlite/connection-factory.hxx> + header file to make the connection_factory interface + and these implementation classes available in your application.

+ +

The single_connection_factory class creates a + single connection that is shared between all the threads in + an application. If the connection is currently not in use, + then it is returned to the caller. Otherwise, the caller is + blocked until the connection becomes available. The + single_connection_factory class has the following + interface:

+ + 
+namespace odb
+{
+  namespace sqlite
+  {
+    class single_connection_factory: public connection_factory
+    {
+    public:
+      single_connection_factory ();
+
+    protected:
+      class single_connection: public connection
+      {
+      public:
+        single_connection (database_type&);
+        single_connection (database_type&, MYSQL*);
+      };
+
+      typedef details::shared_ptr<single_connection> single_connection_ptr;
+
+      virtual single_connection_ptr
+      create ();
+    };
+};
+
+ +

The create() virtual function is called when the + factory needs to create the connection. By deriving from the + single_connection_factory class and overriding this + function we can implement custom connection establishment + and configuration.

+ +

The new_connection_factory class creates a new + connection whenever one is requested. When a connection is no + longer needed, it is released and closed. The + new_connection_factory class has the following + interface:

+ + 
+namespace odb
+{
+  namespace sqlite
+  {
+    class new_connection_factory: public connection_factory
+    {
+    public:
+      new_connection_factory ();
+    };
+};
+
+ +

The connection_pool_factory class implements a + connection pool. It has the following interface:

+ + 
+namespace odb
+{
+  namespace sqlite
+  {
+    class connection_pool_factory: public connection_factory
+    {
+    public:
+      connection_pool_factory (std::size_t max_connections = 0,
+                               std::size_t min_connections = 0);
+
+    protected:
+      class pooled_connection: public connection
+      {
+      public:
+        pooled_connection (database_type&, int extra_flags = 0);
+        pooled_connection (database_type&, sqlite3*);
+      };
+
+      typedef details::shared_ptr<pooled_connection> pooled_connection_ptr;
+
+      virtual pooled_connection_ptr
+      create ();
+    };
+};
+
+ +

The max_connections argument in the + connection_pool_factory constructor specifies the maximum + number of concurrent connections that this pool factory will + maintain. Similarly, the min_connections argument + specifies the minimum number of available connections that + should be kept open.

+ +

Whenever a connection is requested, the pool factory first + checks if there is an unused connection that can be returned. + If there is none, the pool factory checks the + max_connections value to see if a new connection + can be created. If the total number of connections maintained + by the pool is less than this value, then a new connection is + created and returned. Otherwise, the caller is blocked until + a connection becomes available.

+ +

When a connection is released, the pool factory first checks + if there are blocked callers waiting for a connection. If so, then + one of them is unblocked and is given the connection. Otherwise, + the pool factory checks whether the total number of connections + maintained by the pool is greater than the min_connections + value. If that's the case, the connection is closed. Otherwise, the + connection is added to the pool of available connections to be + returned on the next request. In other words, if the number of + connections maintained by the pool exceeds min_connections + and there are no callers waiting for a new connection, + then the pool will close the excess connections.

+ +

If the max_connections value is 0, then the pool will + create a new connection whenever all of the existing connections + are in use. If the min_connections value is 0, then + the pool will never close a connection and instead maintain all + the connections that were ever created.

+ +

The create() virtual function is called whenever the + pool needs to create a new connection. By deriving from the + connection_pool_factory class and overriding this + function we can implement custom connection establishment + and configuration.

+ +

By default, connections created by new_connection_factory + and connection_pool_factory enable the SQLite shared cache + mode and use the unlock notify functionality to aid concurrency. To + disable the shared cache mode you can pass the + SQLITE_OPEN_PRIVATECACHE flag when creating the database + instance. For more information on the shared cache mode refer to the + SQLite documentation.

+ +

If you pass NULL as the connection factory to one of the + database constructors, then the connection_pool_factory + instance will be created by default with the min and max connections + values set to 0. The following code fragment shows how we + can pass our own connection factory instance:

+ + 
+#include <odb/database.hxx>
+
+#include <odb/sqlite/database.hxx>
+#include <odb/sqlite/connection-factory.hxx>
+
+int
+main (int argc, char* argv[])
+{
+  auto_ptr<odb::sqlite::connection_factory> f (
+    new odb::sqlite::connection_pool_factory (20));
+
+  auto_ptr<odb::database> db (
+    new sqlite::database (argc, argv, false, SQLITE_OPEN_READWRITE, f));
+}
+
+ +

18.4 SQLite Exceptions

+ +

The SQLite ODB runtime library defines the following SQLite-specific + exceptions:

+ + 
+namespace odb
+{
+  namespace sqlite
+  {
+    class forced_rollback: odb::recoverable
+    {
+    public:
+      virtual const char*
+      what () const throw ();
+    };
+
+    class database_exception: odb::database_exception
+    {
+    public:
+      int
+      error () const
+
+      int
+      extended_error () const;
+
+      const std::string&
+      message () const;
+
+      virtual const char*
+      what () const throw ();
+    };
+
+    class cli_exception: odb::exception
+    {
+    public:
+      virtual const char*
+      what () const throw ();
+    };
+  }
+}
+
+ +

You will need to include the <odb/sqlite/exceptions.hxx> + header file to make these exceptions available in your application.

+ +

The odb::sqlite::forced_rollback exception is thrown if + SQLite is forcing the current transaction to roll back. For more + information on this behavior refer to Section 18.5.6, + "Forced Rollback".

+ +

The odb::sqlite::database_exception is thrown if + an SQLite database operation fails. The SQLite-specific error + information is accessible via the error(), + extended_error(), and message() functions. + All this information is also combined and returned in a + human-readable form by the what() function.

+ +

The odb::sqlite::cli_exception is thrown by the + command line parsing constructor of the odb::sqlite::database + class if the SQLite option values are missing or invalid. The + what() function returns a human-readable description + of an error.

+ + +

18.5 SQLite Limitations

+ +

The following sections describe SQLite-specific limitations imposed by + the current SQLite and ODB runtime versions.

+ +

18.5.1 Query Result Caching

+ +

SQLite ODB runtime implementation does not perform query result caching + (Section 4.4, "Query Result") even when explicitly + requested. The SQLite API supports interleaving execution of multiple + prepared statements on a single connection. As a result, with SQLite, it + is possible to have multiple uncached results and calls to other database + functions do not invalidate them. The only limitation of the uncached + SQLite results is the unavailability of the result::size() + function. If you call this function on an SQLite query result, then + the odb::result_not_cached exception + (Section 3.14, "ODB Exceptions") is always + thrown. Future versions of the SQLite ODB runtime library may add support + for result caching.

+ +

18.5.2 Automatic Assignment of Object Ids

+ +

Due to SQLite API limitations, every automatically assigned object id + (Section 14.4.2, "auto") should have + the INTEGER SQLite type. While SQLite will treat other + integer type names (such as INT, BIGINT, etc.) + as INTEGER, automatic id assignment will not work. By default, + ODB maps all C++ integral types to INTEGER. This means that + the only situation that requires consideration is the assignment of a + custom database type using the db type pragma + (Section 14.4.3, "type"). For + example:

+ + 
+#pragma db object
+class person
+{
+  ...
+
+  //#pragma db id auto type("INT")     // Will not work.
+  //#pragma db id auto type("INTEGER") // Ok.
+  #pragma db id auto                   // Ok, Mapped to INTEGER.
+  unsigned int id_;
+};
+
+ +

18.5.3 Foreign Key Constraints

+ +

By default the SQLite ODB runtime enables foreign key constraints + checking (PRAGMA foreign_keys=ON). You can disable foreign + keys by passing false as the foreign_keys + argument to one of the odb::sqlite::database constructors. + Foreign keys will also be disabled if the SQLite library is built without + support for foreign keys (SQLITE_OMIT_FOREIGN_KEY and + SQLITE_OMIT_TRIGGER macros) or if you are using + an SQLite version prior to 3.6.19, which does not support foreign + key constraints checking.

+ +

If foreign key constraints checking is disabled or not available, + then inconsistencies in object relationships will not be detected. + Furthermore, using the erase_query() function + (Section 3.11, "Deleting Persistent Objects") + to delete persistent objects that contain containers will not work + correctly. Container data for such objects will not be deleted.

+ +

When foreign key constraints checking is enabled, then you may + get the "foreign key constraint failed" error while re-creating the + database schema. This error is due to bugs in the SQLite DDL foreign + keys support. The recommended work-around for this problem is to + temporarily disable foreign key constraints checking while + re-creating the schema. The following code fragment shows how + this can be done:

+ + 
+#include <odb/connection.hxx>
+#include <odb/transaction.hxx>
+#include <odb/schema-catalog.hxx>
+
+odb::database& db = ...
+
+{
+  odb::connection_ptr c (db.connection ());
+
+  c->execute ("PRAGMA foreign_keys=OFF");
+
+  odb::transaction t (c->begin ());
+  odb::schema_catalog::create_schema (db);
+  t.commit ();
+
+  c->execute ("PRAGMA foreign_keys=ON");
+}
+
+ +

Finally, ODB assumes the standard SQL behavior which requires + that foreign key constraints checking is deferred until the + transaction is committed. Default SQLite behavior is to check such + constraints immediately. As a result, when used with ODB, a custom + database schema that defines foreign key constraints may need to + declare such constraints as DEFERRABLE INITIALLY DEFERRED, + as shown in the following example. By default, schemas generated by + the ODB compiler meet this requirement automatically.

+ + 
+CREATE TABLE Employee (
+  ...
+  employer INTEGER REFERENCES Employer(id)
+           DEFERRABLE INITIALLY DEFERRED);
+
+ +

You can override the default behavior and instruct the ODB + compiler to generate non-deferrable foreign keys by specifying + the --fkeys-deferrable-mode not_deferrable ODB + compiler option. Note, however, that in this case the order in + which you persist, update, and erase objects within a transaction + becomes important.

+ +

18.5.4 Constraint Violations

+ +

Due to the granularity of the SQLite error codes, it is impossible + to distinguish between the duplicate primary key and other constraint + violations. As a result, when making an object persistent, the SQLite + ODB runtime will translate all constraint violation errors to the + object_already_persistent exception (Section + 3.14, "ODB Exceptions").

+ +

18.5.5 Sharing of Queries

+ +

As discussed in Section 4.3, "Executing a Query", a + query instance that does not have any by-reference parameters is + immutable and can be shared between multiple threads without + synchronization. Currently, the SQLite ODB runtime does not support this + functionality. Future versions of the library will remove this + limitation.

+ +

18.5.6 Forced Rollback

+ +

In SQLite 3.7.11 or later, if one of the connections participating in + the shared cache rolls back a transaction, then ongoing transactions + on other connections in the shared cache may also be forced to roll back. + An example of such behavior would be a read-only transaction that is + forced to roll back while iterating over the query result because another + transaction on another connection was rolled back.

+ +

If a transaction is being forced to roll back by SQLite, then ODB + throws odb::sqlite::forced_rollback + (Section 18.4, "SQLite Exceptions") which is + a recoverable exception (3.7 Error Handling and + Recovery). As a result, the recommended way to handle this + exception is to re-execute the affected transaction.

+ +

18.5.7 Database Schema Evolution

+ +

From the list of schema migration changes supported by ODB + (Section 13.2, "Schema Migration"), the + following are not supported by SQLite:

+ +
    +
  • drop column
    • +
  • alter column, set NULL/NOT NULL
    • +
  • add foreign key
    • +
  • drop foreign key
    • +
+ +

The biggest problem is the lack of support for dropping columns. + This means that it would be impossible to delete a data member + in a persistent class. To work around this limitation ODB + implements logical delete for columns that allow + NULL values. In this case, instead of dropping + the column (in the post-migration stage), the schema migration + statements will automatically reset this column in all the + existing rows to NULL. Any new rows that are + inserted later will also automatically have this column set + to NULL (unless the column specifies a default + value).

+ +

Since it is also impossible to change the column's + NULL/NOT NULL attribute after it + has been added, to make schema evolution support usable in + SQLite, all the columns should be added as NULL + even if semantically they should not allow NULL + values. We should also normally refrain from assigning + default values to columns (Section 14.4.7, + default), unless the space overhead of + a default value is not a concern. Explicitly making all + the data members NULL would be burdensome + and ODB provides the --sqlite-override-null + command line option that forces all the columns, even those + that were explicitly marked NOT NULL, to be + NULL in SQLite.

+ +

SQLite only supports adding foreign keys as part of the + column addition. As a result, we can only add a new + data member of an object pointer type if it points + to an object with a simple (single-column) object id.

+ +

SQLite also doesn't support dropping foreign keys. + Leaving a foreign key around works well with logical + delete unless we also want to delete the pointed-to + object. In this case we will have to leave an + empty table corresponding to the pointed-to object + around. An alternative would be to make a copy of the + pointing object without the object pointer, migrate the + data, and then delete both the old pointing and the + pointed-to objects. Since this will result in dropping + the pointing table, the foreign key will be dropped + as well. Yet another, more radical, solution to this + problem is to disable foreign keys checking altogether + (see the foreign_keys SQLite pragma).

+ +

To summarize, to make schema evolution support usable + in SQLite we should pass the --sqlite-override-null + option when compiling our persistent classes and also refrain + from assigning default values to data members. Note also that + this has to be done from the start so that every column is added + as NULL and therefore can be logically deleted later. + In particular, you cannot add the --sqlite-override-null + option when you realize you need to delete a data member. At this + point it is too late since the column has already been added + as NOT NULL in existing databases. We should also + avoid composite object ids if we are planning to use object + relationships.

+ +

18.6 SQLite Index Definitions

+ +

When the index pragma (Section 14.7, + "Index Definition Pragmas") is used to define an SQLite index, + the type clause specifies the index type (for example, + UNIQUE) while the method and + options clauses are not used. The column options + can be used to specify collations and the sort order. For example:

+ + 
+#pragma db object
+class object
+{
+  ...
+
+  std::string name_;
+
+  #pragma db index member(name_, "COLLATE binary DESC")
+};
+
+ +

Index names in SQLite are database-global. To avoid name clashes, + ODB automatically prefixes each index name with the table name on + which it is defined.

+ + + + +
+

19 PostgreSQL Database

+ +

To generate support code for the PostgreSQL database you will need + to pass the "--database pgsql" + (or "-d pgsql") option to the ODB compiler. + Your application will also need to link to the PostgreSQL ODB runtime + library (libodb-pgsql). All PostgreSQL-specific ODB + classes are defined in the odb::pgsql namespace.

+ +

ODB utilizes prepared statements extensively. Support for prepared + statements was added in PostgreSQL version 7.4 with the introduction + of the messaging protocol version 3.0. For this reason, ODB supports + only PostgreSQL version 7.4 and later.

+ +

19.1 PostgreSQL Type Mapping

+ +

The following table summarizes the default mapping between basic + C++ value types and PostgreSQL database types. This mapping can be + customized on the per-type and per-member basis using the ODB + Pragma Language (Chapter 14, "ODB Pragma + Language").

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
C++ TypePostgreSQL TypeDefault NULL Semantics
boolBOOLEANNOT NULL
charCHAR(1)NOT NULL
signed charSMALLINTNOT NULL
unsigned charSMALLINTNOT NULL
shortSMALLINT NULLNOT NULL
unsigned shortSMALLINTNOT NULL
intINTEGERNOT NULL
unsigned intINTEGERNOT NULL
longBIGINTNOT NULL
unsigned longBIGINTNOT NULL
long longBIGINTNOT NULL
unsigned long longBIGINTNOT NULL
floatREALNOT NULL
doubleDOUBLE PRECISIONNOT NULL
std::stringTEXTNOT NULL
char[N]VARCHAR(N-1)NOT NULL
+ +

It is possible to map the char C++ type to an integer + database type (for example, SMALLINT) using the + db type pragma (Section 14.4.3, + "type").

+ +

Additionally, by default, C++ enums and C++11 enum classes are + automatically mapped to the PostgreSQL types corresponding to their + underlying integral types (see table above). The default + NULL semantics is NOT NULL. For + example:

+ + 
+enum color {red, green, blue};
+enum class taste: unsigned char
+{
+  bitter = 1,
+  sweet,
+  sour = 4,
+  salty
+};
+
+#pragma db object
+class object
+{
+  ...
+
+  color color_; // Automatically mapped to INTEGER.
+  taste taste_; // Automatically mapped to SMALLINT.
+};
+
+ +

Note also that because PostgreSQL does not support unsigned integers, + the unsigned short, unsigned int, and + unsigned long/unsigned long long C++ types + are by default mapped to the SMALLINT, INTEGER, + and BIGINT PostgreSQL types, respectively. The sign bit + of the value stored by the database for these types will contain + the most significant bit of the actual unsigned value being + persisted.

+ +

It is also possible to add support for additional PostgreSQL types, + such as NUMERIC, geometry types, XML, + JSON, enumeration types, composite types, arrays, + geospatial types, and the key-value store (HSTORE). + For more information, refer to Section 14.8, + "Database Type Mapping Pragmas".

+ +

19.1.1 String Type Mapping

+ +

The PostgreSQL ODB runtime library provides support for mapping the + std::string, char[N], and + std::array<char, N> types to the PostgreSQL + CHAR, VARCHAR, and TEXT + types. However, these mappings are not enabled by default (in + particular, by default, std::array will be treated + as a container). To enable the alternative mappings for these + types we need to specify the database type explicitly using the + db type pragma (Section 14.4.3, + "type"), for example:

+ + 
+#pragma db object
+class object
+{
+  ...
+
+  #pragma db type("CHAR(2)")
+  char state_[2];
+
+  #pragma db type("VARCHAR(128)")
+  std::string name_;
+};
+
+ +

Alternatively, this can be done on the per-type basis, for example:

+ + 
+#pragma db value(std::string) type("VARCHAR(128)")
+
+#pragma db object
+class object
+{
+  ...
+
+  std::string name_; // Mapped to VARCHAR(128).
+};
+
+ +

The char[N] and std::array<char, N> values + may or may not be zero-terminated. When extracting such values from the + database, ODB will append the zero terminator if there is enough + space.

+ +

19.1.2 Binary Type and UUID Mapping

+ +

The PostgreSQL ODB runtime library provides support for mapping the + std::vector<char>, + std::vector<unsigned char>, + char[N], unsigned char[N], + std::array<char, N>, and + std::array<unsigned char, N> types to the PostgreSQL + BYTEA type. There is also support for mapping the + char[16] array to the PostgreSQL UUID type. + However, these mappings are not enabled by default (in particular, by + default, std::vector and std::array will be + treated as containers). To enable the alternative mappings for these + types we need to specify the database type explicitly using the + db type pragma (Section 14.4.3, + "type"), for example:

+ + 
+#pragma db object
+class object
+{
+  ...
+
+  #pragma db type("UUID")
+  char uuid_[16];
+
+  #pragma db type("BYTEA")
+  std::vector<char> buf_;
+
+  #pragma db type("BYTEA")
+  unsigned char data_[256];
+};
+
+ +

Alternatively, this can be done on the per-type basis, for example:

+ + 
+typedef std::vector<char> buffer;
+#pragma db value(buffer) type("BYTEA")
+
+#pragma db object
+class object
+{
+  ...
+
+  buffer buf_; // Mapped to BYTEA.
+};
+
+ +

Note also that in native queries (Chapter 4, "Querying + the Database") char[N] and + std::array<char, N> parameters are by default passed + as a string rather than a binary. To pass such parameters as a binary, + we need to specify the database type explicitly in the + _val()/_ref() calls. Note also that we + don't need to do this for the integrated queries, for example:

+ + 
+char u[16] = {...};
+
+db.query<object> ("uuid = " + query::_val<odb::pgsql::id_uuid> (u));
+db.query<object> ("buf = " + query::_val<odb::pgsql::id_bytea> (u));
+db.query<object> (query::uuid == query::_ref (u));
+
+ +

19.2 PostgreSQL Database Class

+ +

The PostgreSQL database class has the following + interface:

+ + 
+namespace odb
+{
+  namespace pgsql
+  {
+    class database: public odb::database
+    {
+    public:
+      database (const std::string& user,
+                const std::string& password,
+                const std::string& db,
+                const std::string& host = "",
+                unsigned int port = 0,
+                const std::string& extra_conninfo = "",
+                std::[auto|unique]_ptr<connection_factory> = 0);
+
+      database (const std::string& user,
+                const std::string& password,
+                const std::string& db,
+                const std::string& host,
+                const std::string& socket_ext,
+                const std::string& extra_conninfo = "",
+                std::[auto|unique]_ptr<connection_factory> = 0);
+
+      database (const std::string& conninfo,
+                std::[auto|unique]_ptr<connection_factory> = 0);
+
+      database (int& argc,
+                char* argv[],
+                bool erase = false,
+                const std::string& extra_conninfo = "",
+                std::[auto|unique]_ptr<connection_factory> = 0);
+
+      static void
+      print_usage (std::ostream&);
+
+    public:
+      const std::string&
+      user () const;
+
+      const std::string&
+      password () const;
+
+      const std::string&
+      db () const;
+
+      const std::string&
+      host () const;
+
+      unsigned int
+      port () const;
+
+      const std::string&
+      socket_ext () const;
+
+      const std::string&
+      extra_conninfo () const;
+
+      const std::string&
+      conninfo () const;
+
+    public:
+      connection_ptr
+      connection ();
+    };
+  }
+}
+
+ +

You will need to include the <odb/pgsql/database.hxx> + header file to make this class available in your application.

+ +

The overloaded database constructors allow us to specify + the PostgreSQL database parameters that should be used when connecting + to the database. The port argument in the first constructor + is an integer value specifying the TCP/IP port number to connect to. A + zero port number indicates that the default port should be used. + The socket_ext argument in the second constructor is a + string value specifying the UNIX-domain socket file name extension.

+ +

The third constructor allows us to specify all the database parameters + as a single conninfo string. All other constructors + accept additional database connection parameters as the + extra_conninfo argument. For more information + about the format of the conninfo string, refer to + the PQconnectdb() function description in the PostgreSQL + documentation. In the case of extra_conninfo, all the + database parameters provided in this string will take precedence + over those explicitly specified with other constructor arguments.

+ +

The last constructor extracts the database parameters + from the command line. The following options are recognized:

+ + 
+  --user <login> | --username <login>
+  --password <password>
+  --database <name> | --dbname <name>
+  --host <host>
+  --port <integer>
+  --options-file <file>
+
+ +

The --options-file option allows us to specify some + or all of the database options in a file with each option appearing + on a separate line followed by a space and an option value.

+ +

If the erase argument to this constructor is true, + then the above options are removed from the argv + array and the argc count is updated accordingly. + This is primarily useful if your application accepts other + options or arguments and you would like to get the PostgreSQL + options out of the argv array.

+ +

This constructor throws the odb::pgsql::cli_exception + exception if the PostgreSQL option values are missing or invalid. + See section Section 19.4, "PostgreSQL Exceptions" + for more information on this exception.

+ +

The static print_usage() function prints the list of options + with short descriptions that are recognized by this constructor.

+ +

The last argument to all of the constructors is a pointer to the + connection factory. In C++98/03, it is std::auto_ptr while + in C++11 std::unique_ptr is used instead. If we pass a + non-NULL value, the database instance assumes ownership + of the factory instance. The connection factory interface as well as + the available implementations are described in the next section.

+ +

The set of accessor functions following the constructors allows us + to query the parameters of the database instance. Note that + the conninfo() accessor returns a complete + conninfo string which includes parameters that were + explicitly specified with the various constructor arguments, as well as + the extra parameters passed in the extra_conninfo argument. + The extra_conninfo() accessor will return the + conninfo string as passed in the extra_conninfo + argument.

+ +

The connection() function returns a pointer to the + PostgreSQL database connection encapsulated by the + odb::pgsql::connection class. For more information + on pgsql::connection, refer to Section + 19.3, "PostgreSQL Connection and Connection Factory".

+ +

19.3 PostgreSQL Connection and Connection Factory

+ +

The pgsql::connection class has the following interface:

+ + 
+namespace odb
+{
+  namespace pgsql
+  {
+    class connection: public odb::connection
+    {
+    public:
+      connection (database&);
+      connection (database&, PGconn*);
+
+      PGconn*
+      handle ();
+    };
+
+    typedef details::shared_ptr<connection> connection_ptr;
+  }
+}
+
+ +

For more information on the odb::connection interface, + refer to Section 3.6, "Connections". The first + overloaded pgsql::connection constructor establishes a + new PostgreSQL connection. The second constructor allows us to create + a connection instance by providing an already connected + native PostgreSQL handle. Note that the connection + instance assumes ownership of this handle. The handle() + accessor returns the PostgreSQL handle corresponding to the connection.

+ +

The pgsql::connection_factory abstract class has the + following interface:

+ + 
+namespace odb
+{
+  namespace pgsql
+  {
+    class connection_factory
+    {
+    public:
+      virtual void
+      database (database&) = 0;
+
+      virtual connection_ptr
+      connect () = 0;
+    };
+  }
+}
+
+ +

The database() function is called when a connection + factory is associated with a database instance. This happens in + the odb::pgsql::database class constructors. The + connect() function is called whenever a database + connection is requested.

+ +

The two implementations of the connection_factory + interface provided by the PostgreSQL ODB runtime are + new_connection_factory and + connection_pool_factory. You will need to include + the <odb/pgsql/connection-factory.hxx> + header file to make the connection_factory interface + and these implementation classes available in your application.

+ +

The new_connection_factory class creates a new + connection whenever one is requested. When a connection is no + longer needed, it is released and closed. The + new_connection_factory class has the following + interface:

+ + 
+namespace odb
+{
+  namespace pgsql
+  {
+    class new_connection_factory: public connection_factory
+    {
+    public:
+      new_connection_factory ();
+    };
+};
+
+ +

The connection_pool_factory class implements a + connection pool. It has the following interface:

+ + 
+namespace odb
+{
+  namespace pgsql
+  {
+    class connection_pool_factory: public connection_factory
+    {
+    public:
+      connection_pool_factory (std::size_t max_connections = 0,
+                               std::size_t min_connections = 0);
+
+    protected:
+      class pooled_connection: public connection
+      {
+      public:
+        pooled_connection (database_type&);
+        pooled_connection (database_type&, PGconn*);
+      };
+
+      typedef details::shared_ptr<pooled_connection> pooled_connection_ptr;
+
+      virtual pooled_connection_ptr
+      create ();
+    };
+};
+
+ +

The max_connections argument in the + connection_pool_factory constructor specifies the maximum + number of concurrent connections that this pool factory will + maintain. Similarly, the min_connections argument + specifies the minimum number of available connections that + should be kept open.

+ +

Whenever a connection is requested, the pool factory first + checks if there is an unused connection that can be returned. + If there is none, the pool factory checks the + max_connections value to see if a new connection + can be created. If the total number of connections maintained + by the pool is less than this value, then a new connection is + created and returned. Otherwise, the caller is blocked until + a connection becomes available.

+ +

When a connection is released, the pool factory first checks + if there are blocked callers waiting for a connection. If so, then + one of them is unblocked and is given the connection. Otherwise, + the pool factory checks whether the total number of connections + maintained by the pool is greater than the min_connections + value. If that's the case, the connection is closed. Otherwise, the + connection is added to the pool of available connections to be + returned on the next request. In other words, if the number of + connections maintained by the pool exceeds min_connections + and there are no callers waiting for a new connection, + the pool will close the excess connections.

+ +

If the max_connections value is 0, then the pool will + create a new connection whenever all of the existing connections + are in use. If the min_connections value is 0, then + the pool will never close a connection and instead maintain all + the connections that were ever created.

+ +

The create() virtual function is called whenever the + pool needs to create a new connection. By deriving from the + connection_pool_factory class and overriding this + function we can implement custom connection establishment + and configuration.

+ +

If you pass NULL as the connection factory to one of the + database constructors, then the + connection_pool_factory instance will be created by default + with the min and max connections values set to 0. The + following code fragment shows how we can pass our own connection factory + instance:

+ + 
+#include <odb/database.hxx>
+
+#include <odb/pgsql/database.hxx>
+#include <odb/pgsql/connection-factory.hxx>
+
+int
+main (int argc, char* argv[])
+{
+  auto_ptr<odb::pgsql::connection_factory> f (
+    new odb::pgsql::connection_pool_factory (20));
+
+  auto_ptr<odb::database> db (
+    new pgsql::database (argc, argv, false, "", f));
+}
+
+ +

19.4 PostgreSQL Exceptions

+ +

The PostgreSQL ODB runtime library defines the following + PostgreSQL-specific exceptions:

+ + 
+namespace odb
+{
+  namespace pgsql
+  {
+    class database_exception: odb::database_exception
+    {
+    public:
+      const std::string&
+      message () const;
+
+      const std::string&
+      sqlstate () const;
+
+      virtual const char*
+      what () const throw ();
+    };
+
+    class cli_exception: odb::exception
+    {
+    public:
+      virtual const char*
+      what () const throw ();
+    };
+  }
+}
+
+ +

You will need to include the <odb/pgsql/exceptions.hxx> + header file to make these exceptions available in your application.

+ +

The odb::pgsql::database_exception is thrown if + a PostgreSQL database operation fails. The PostgreSQL-specific error + information is accessible via the message() and + sqlstate() functions. All this information is also + combined and returned in a human-readable form by the what() + function.

+ +

The odb::pgsql::cli_exception is thrown by the + command line parsing constructor of the odb::pgsql::database + class if the PostgreSQL option values are missing or invalid. The + what() function returns a human-readable description + of an error.

+ +

19.5 PostgreSQL Limitations

+ +

The following sections describe PostgreSQL-specific limitations imposed + by the current PostgreSQL and ODB runtime versions.

+ +

19.5.1 Query Result Caching

+ +

The PostgreSQL ODB runtime implementation will always return a + cached query result (Section 4.4, "Query Result") + even when explicitly requested not to. This is a limitation of the + PostgreSQL client library (libpq) which does not + support uncached (streaming) query results.

+ +

19.5.2 Foreign Key Constraints

+ +

ODB assumes the standard SQL behavior which requires that + foreign key constraints checking is deferred until the + transaction is committed. Default PostgreSQL behavior is + to check such constraints immediately. As a result, when + used with ODB, a custom database schema that defines foreign + key constraints may need to declare such constraints as + INITIALLY DEFERRED, as shown in the following example. + By default, schemas generated by the ODB compiler meet this requirement + automatically.

+ + 
+CREATE TABLE Employee (
+  ...
+  employer BIGINT REFERENCES Employer(id) INITIALLY DEFERRED);
+
+ +

You can override the default behavior and instruct the ODB + compiler to generate non-deferrable foreign keys by specifying + the --fkeys-deferrable-mode not_deferrable ODB + compiler option. Note, however, that in this case the order in + which you persist, update, and erase objects within a transaction + becomes important.

+ +

19.5.3 Unique Constraint Violations

+ +

Due to the granularity of the PostgreSQL error codes, it is impossible + to distinguish between the duplicate primary key and other unique + constraint violations. As a result, when making an object persistent, + the PostgreSQL ODB runtime will translate all unique constraint violation + errors to the object_already_persistent exception + (Section 3.14, "ODB Exceptions").

+ +

19.5.4 Date-Time Format

+ +

ODB expects the PostgreSQL server to use integers as a binary + format for the date-time types, which is the default for most + PostgreSQL configurations. When creating a connection, ODB + examines the integer_datetimes PostgreSQL server + parameter and if it is false, + odb::pgsql::database_exception is thrown. You may + check the value of this parameter for your server by executing + the following SQL query:

+ + 
+SHOW integer_datetimes
+
+ +

19.5.5 Timezones

+ +

ODB does not currently natively support the PostgreSQL date-time types + with timezone information. However, these types can be accessed by + mapping them to one of the natively supported types, as discussed + in Section 14.8, "Database Type Mapping Pragmas".

+ +

19.5.6 NUMERIC Type Support

+ +

Support for the PostgreSQL NUMERIC type is limited + to providing a binary buffer containing the binary representation + of the value. For more information on the binary format used to + store NUMERIC values refer to the PostgreSQL + documentation. An alternative approach to accessing NUMERIC + values is to map this type to one of the natively supported + ones, as discussed in Section 14.8, "Database + Type Mapping Pragmas".

+ + +

19.6 PostgreSQL Index Definitions

+ +

When the index pragma (Section 14.7, + "Index Definition Pragmas") is used to define a PostgreSQL index, + the type clause specifies the index type (for example, + UNIQUE), the method clause specifies the + index method (for example, BTREE, HASH, + GIN, etc.), and the options clause + specifies additional index options, such as storage parameters, + table spaces, and the WHERE predicate. To support + the definition of concurrent indexes, the type + clause can end with the word CONCURRENTLY (upper and + lower cases are recognized). The column options can be used to + specify collations, operator classes, and the sort order. For example:

+ + 
+#pragma db object
+class object
+{
+  ...
+
+  std::string name_;
+
+  #pragma db index                            \
+             type("UNIQUE CONCURRENTLY")      \
+             method("HASH")                   \
+             member(name_, "DESC")            \
+             options("WITH(FILLFACTOR = 80)")
+};
+
+ +

Index names in PostgreSQL are schema-global. To avoid name clashes, + ODB automatically prefixes each index name with the table name on + which it is defined.

+ + + + +
+

20 Oracle Database

+ +

To generate support code for the Oracle database you will need + to pass the "--database oracle" + (or "-d oracle") option to the ODB compiler. + Your application will also need to link to the Oracle ODB runtime + library (libodb-oracle). All Oracle-specific ODB + classes are defined in the odb::oracle namespace.

+ +

20.1 Oracle Type Mapping

+ +

The following table summarizes the default mapping between basic + C++ value types and Oracle database types. This mapping can be + customized on the per-type and per-member basis using the ODB + Pragma Language (Chapter 14, "ODB Pragma + Language").

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
C++ TypeOracle TypeDefault NULL Semantics
boolNUMBER(1)NOT NULL
charCHAR(1)NOT NULL
signed charNUMBER(3)NOT NULL
unsigned charNUMBER(3)NOT NULL
shortNUMBER(5)NOT NULL
unsigned shortNUMBER(5)NOT NULL
intNUMBER(10)NOT NULL
unsigned intNUMBER(10)NOT NULL
longNUMBER(19)NOT NULL
unsigned longNUMBER(20)NOT NULL
long longNUMBER(19)NOT NULL
unsigned long longNUMBER(20)NOT NULL
floatBINARY_FLOATNOT NULL
doubleBINARY_DOUBLENOT NULL
std::stringVARCHAR2(512)NULL
char[N]VARCHAR2(N-1)NULL
+ +

It is possible to map the char C++ type to an integer + database type (for example, NUMBER(3)) using the + db type pragma (Section 14.4.3, + "type").

+ +

In Oracle empty VARCHAR2 and NVARCHAR2 + strings are represented as a NULL value. As a result, + columns of the std::string and char[N] + types are by default declared as NULL except for + primary key columns. However, you can override this by explicitly + declaring such columns as NOT NULL with the + db not_null pragma (Section + 14.4.6, "null/not_null"). This also means that for + object ids that are mapped to these Oracle types, an empty string is + an invalid value.

+ +

Additionally, by default, C++ enums and C++11 enum classes are + automatically mapped to the Oracle types corresponding to their + underlying integral types (see table above). The default + NULL semantics is NOT NULL. For + example:

+ + 
+enum color {red, green, blue};
+enum class taste: unsigned char
+{
+  bitter = 1,
+  sweet,
+  sour = 4,
+  salty
+};
+
+#pragma db object
+class object
+{
+  ...
+
+  color color_; // Automatically mapped to NUMBER(10).
+  taste taste_; // Automatically mapped to NUMBER(3).
+};
+
+ +

It is also possible to add support for additional Oracle types, + such as XML, geospatial types, user-defined types, + and collections (arrays, table types). For more information, refer to + Section 14.8, "Database Type Mapping + Pragmas".

+ +

20.1.1 String Type Mapping

+ +

The Oracle ODB runtime library provides support for mapping the + std::string, char[N], and + std::array<char, N> types to the Oracle CHAR, + VARCHAR2, CLOB, NCHAR, + NVARCHAR2, and NCLOB types. However, + these mappings are not enabled by default (in particular, by + default, std::array will be treated as a container). + To enable the alternative mappings for these types we need to + specify the database type explicitly using the db type + pragma (Section 14.4.3, "type"), + for example:

+ + 
+#pragma db object
+class object
+{
+  ...
+
+  #pragma db type ("CHAR(2)")
+  char state_[2];
+
+  #pragma db type ("VARCHAR(128)") null
+  std::string name_;
+
+  #pragma db type ("CLOB")
+  std::string text_;
+};
+
+ +

Alternatively, this can be done on the per-type basis, for example:

+ + 
+#pragma db value(std::string) type("VARCHAR(128)") null
+
+#pragma db object
+class object
+{
+  ...
+
+  std::string name_; // Mapped to VARCHAR(128).
+
+  #pragma db type ("CLOB")
+  std::string text_; // Mapped to CLOB.
+};
+
+ +

The char[N] and std::array<char, N> values + may or may not be zero-terminated. When extracting such values from the + database, ODB will append the zero terminator if there is enough + space.

+ +

20.1.2 Binary Type Mapping

+ +

The Oracle ODB runtime library provides support for mapping the + std::vector<char>, + std::vector<unsigned char>, + char[N], unsigned char[N], + std::array<char, N>, and + std::array<unsigned char, N> + types to the Oracle BLOB and RAW types. + However, these mappings are not enabled by default (in particular, by + default, std::vector and std::array will be + treated as containers). To enable the alternative mappings for these + types we need to specify the database type explicitly using the + db type pragma (Section 14.4.3, + "type"), for example:

+ + 
+#pragma db object
+class object
+{
+  ...
+
+  #pragma db type("BLOB")
+  std::vector<char> buf_;
+
+  #pragma db type("RAW(16)")
+  unsigned char uuid_[16];
+};
+
+ +

Alternatively, this can be done on the per-type basis, for example:

+ + 
+typedef std::vector<char> buffer;
+#pragma db value(buffer) type("BLOB")
+
+#pragma db object
+class object
+{
+  ...
+
+  buffer buf_; // Mapped to BLOB.
+};
+
+ +

Note also that in native queries (Chapter 4, "Querying + the Database") char[N] and + std::array<char, N> parameters are by default passed + as a string rather than a binary. To pass such parameters as a binary, + we need to specify the database type explicitly in the + _val()/_ref() calls. Note also that we + don't need to do this for the integrated queries, for example:

+ + 
+char u[16] = {...};
+
+db.query<object> ("uuid = " + query::_val<odb::oracle::id_raw> (u));
+db.query<object> (query::uuid == query::_ref (u));
+
+ +

20.2 Oracle Database Class

+ +

The Oracle database class encapsulates the OCI environment + handle as well as the database connection string and user credentials + that are used to establish connections to the database. It has the + following interface:

+ + 
+namespace odb
+{
+  namespace oracle
+  {
+    class database: public odb::database
+    {
+    public:
+      database (const std::string& user,
+                const std::string& password,
+                const std::string& db,
+                ub2 charset = 0,
+                ub2 ncharset = 0,
+                OCIEnv* environment = 0,
+                std::[auto|unique]_ptr<connection_factory> = 0);
+
+      database (const std::string& user,
+                const std::string& password,
+                const std::string& service,
+                const std::string& host,
+                unsigned int port = 0,
+                ub2 charset = 0,
+                ub2 ncharset = 0,
+                OCIEnv* environment = 0,
+                std::[auto|unique]_ptr<connection_factory> = 0);
+
+      database (int& argc,
+                char* argv[],
+                bool erase = false,
+                ub2 charset = 0,
+                ub2 ncharset = 0,
+                OCIEnv* environment = 0,
+                std::[auto|unique]_ptr<connection_factory> = 0);
+
+      static void
+      print_usage (std::ostream&);
+
+    public:
+      const std::string&
+      user () const;
+
+      const std::string&
+      password () const;
+
+      const std::string&
+      db () const;
+
+      const std::string&
+      service () const;
+
+      const std::string&
+      host () const;
+
+      unsigned int
+      port () const;
+
+      ub2
+      charset () const;
+
+      ub2
+      ncharset () const;
+
+      OCIEnv*
+      environment ();
+
+    public:
+      connection_ptr
+      connection ();
+    };
+  }
+}
+
+ +

You will need to include the <odb/oracle/database.hxx> + header file to make this class available in your application.

+ +

The overloaded database constructors allow us to specify the + Oracle database parameters that should be used when connecting to the + database. The db argument in the first constructor is a + connection identifier that specifies the database to connect to. For more + information on the format of the connection identifier, refer to the + Oracle documentation.

+ +

The second constructor allows us to specify the individual components + of a connection identifier as the service, host, + and port arguments. If the host argument is + empty, then localhost is used by default. Similarly, if the + port argument is zero, then the default port is used.

+ +

The last constructor extracts the database parameters + from the command line. The following options are recognized:

+ + 
+  --user <login>
+  --password <password>
+  --database <connect-id>
+  --service <name>
+  --host <host>
+  --port <integer>
+  --options-file <file>
+
+ +

The --options-file option allows us to specify some + or all of the database options in a file with each option appearing + on a separate line followed by a space and an option value. Note that it + is invalid to specify the --database option + together with --service, --host, or + --port options.

+ +

If the erase argument to this constructor is true, + then the above options are removed from the argv + array and the argc count is updated accordingly. + This is primarily useful if your application accepts other + options or arguments and you would like to get the Oracle + options out of the argv array.

+ +

This constructor throws the odb::oracle::cli_exception + exception if the Oracle option values are missing or invalid. See section + Section 20.4, "Oracle Exceptions" for more + information on this exception.

+ +

The static print_usage() function prints the list of options + with short descriptions that are recognized by this constructor.

+ +

Additionally, all the constructors have the charset, + ncharset, and environment arguments. + The charset argument specifies the client-side database + character encoding. Character data corresponding to the CHAR, + VARCHAR2, and CLOB types will be delivered + to and received from the application in this encoding. Similarly, + the ncharset argument specifies the client-side national + character encoding. Character data corresponding to the NCHAR, + NVARCHAR2, and NCLOB types will be delivered + to and received from the application in this encoding. For the complete + list of available character encoding values, refer to the Oracle + documentation. Commonly used encoding values are 873 + (UTF-8), 31 (ISO-8859-1), and 1000 (UTF-16). + If the database character encoding is not specified, then the + NLS_LANG environment/registry variable is used. Similarly, + if the national character encoding is not specified, then the + NLS_NCHAR environment/registry variable is used. For more + information on character encodings, refer to the + OCIEnvNlsCreate() function in the Oracle Call Interface + (OCI) documentation.

+ +

The environment argument allows us to provide a custom + OCI environment handle. If this argument is not NULL, + then the passed handle is used in all the OCI function calls made + by this database class instance. Note also that the + database instance does not assume ownership of the + passed environment handle and this handle should be valid for + the lifetime of the database instance. If a custom + environment handle is used, then the charset and + ncharset arguments have no effect.

+ +

The last argument to all of the constructors is a pointer to the + connection factory. In C++98/03, it is std::auto_ptr while + in C++11 std::unique_ptr is used instead. If we pass a + non-NULL value, the database instance assumes ownership + of the factory instance. The connection factory interface as well as + the available implementations are described in the next section.

+ +

The set of accessor functions following the constructors allows us + to query the parameters of the database instance.

+ +

The connection() function returns a pointer to the + Oracle database connection encapsulated by the + odb::oracle::connection class. For more information + on oracle::connection, refer to Section + 20.3, "Oracle Connection and Connection Factory".

+ +

20.3 Oracle Connection and Connection Factory

+ +

The oracle::connection class has the following interface:

+ + 
+namespace odb
+{
+  namespace oracle
+  {
+    class connection: public odb::connection
+    {
+    public:
+      connection (database&);
+      connection (database&, OCISvcCtx*);
+
+      OCISvcCtx*
+      handle ();
+
+      OCIError*
+      error_handle ();
+
+      details::buffer&
+      lob_buffer ();
+    };
+
+    typedef details::shared_ptr<connection> connection_ptr;
+  }
+}
+
+ +

For more information on the odb::connection interface, refer + to Section 3.6, "Connections". The first overloaded + oracle::connection constructor creates a new OCI service + context. The OCI statement caching is enabled for the underlying session + while the OCI connection pooling and session pooling are not used. The + second constructor allows us to create a connection instance by + providing an already connected Oracle service context. Note that the + connection instance assumes ownership of this handle. The + handle() accessor returns the OCI service context handle + associated with the connection instance.

+ +

An OCI error handle is allocated for each connection + instance and is available via the error_handle() accessor + function.

+ +

Additionally, each connection instance maintains a large + object (LOB) buffer. This buffer is used by the Oracle ODB runtime + as an intermediate storage for piecewise handling of LOB data. + By default, the LOB buffer has zero initial capacity and is + expanded to 4096 bytes when the first LOB operation is performed. + If your application requires a bigger or smaller LOB buffer, you can + specify a custom capacity using the lob_buffer() + accessor.

+ +

The oracle::connection_factory abstract class has the + following interface:

+ + 
+namespace odb
+{
+  namespace oracle
+  {
+    class connection_factory
+    {
+    public:
+      virtual void
+      database (database&) = 0;
+
+      virtual connection_ptr
+      connect () = 0;
+    };
+  }
+}
+
+ +

The database() function is called when a connection + factory is associated with a database instance. This happens in + the odb::oracle::database class constructors. The + connect() function is called whenever a database + connection is requested.

+ +

The two implementations of the connection_factory + interface provided by the Oracle ODB runtime are + new_connection_factory and + connection_pool_factory. You will need to include + the <odb/oracle/connection-factory.hxx> + header file to make the connection_factory interface + and these implementation classes available in your application.

+ +

The new_connection_factory class creates a new + connection whenever one is requested. When a connection is no + longer needed, it is released and closed. The + new_connection_factory class has the following + interface:

+ + 
+namespace odb
+{
+  namespace oracle
+  {
+    class new_connection_factory: public connection_factory
+    {
+    public:
+      new_connection_factory ();
+    };
+};
+
+ +

The connection_pool_factory class implements a + connection pool. It has the following interface:

+ + 
+namespace odb
+{
+  namespace oracle
+  {
+    class connection_pool_factory: public connection_factory
+    {
+    public:
+      connection_pool_factory (std::size_t max_connections = 0,
+                               std::size_t min_connections = 0);
+
+    protected:
+      class pooled_connection: public connection
+      {
+      public:
+        pooled_connection (database_type&);
+        pooled_connection (database_type&, OCISvcCtx*);
+      };
+
+      typedef details::shared_ptr<pooled_connection> pooled_connection_ptr;
+
+      virtual pooled_connection_ptr
+      create ();
+    };
+};
+
+ +

The max_connections argument in the + connection_pool_factory constructor specifies the maximum + number of concurrent connections that this pool factory will + maintain. Similarly, the min_connections argument + specifies the minimum number of available connections that + should be kept open.

+ +

Whenever a connection is requested, the pool factory first + checks if there is an unused connection that can be returned. + If there is none, the pool factory checks the + max_connections value to see if a new connection + can be created. If the total number of connections maintained + by the pool is less than this value, then a new connection is + created and returned. Otherwise, the caller is blocked until + a connection becomes available.

+ +

When a connection is released, the pool factory first checks + if there are blocked callers waiting for a connection. If so, then + one of them is unblocked and is given the connection. Otherwise, + the pool factory checks whether the total number of connections + maintained by the pool is greater than the min_connections + value. If that's the case, the connection is closed. Otherwise, the + connection is added to the pool of available connections to be + returned on the next request. In other words, if the number of + connections maintained by the pool exceeds min_connections + and there are no callers waiting for a new connection, + the pool will close the excess connections.

+ +

If the max_connections value is 0, then the pool will + create a new connection whenever all of the existing connections + are in use. If the min_connections value is 0, then + the pool will never close a connection and instead maintain all + the connections that were ever created.

+ +

The create() virtual function is called whenever the + pool needs to create a new connection. By deriving from the + connection_pool_factory class and overriding this + function we can implement custom connection establishment + and configuration.

+ +

If you pass NULL as the connection factory to one of the + database constructors, then the + connection_pool_factory instance will be created by default + with the min and max connections values set to 0. The + following code fragment shows how we can pass our own connection factory + instance:

+ + 
+#include <odb/database.hxx>
+
+#include <odb/oracle/database.hxx>
+#include <odb/oracle/connection-factory.hxx>
+
+int
+main (int argc, char* argv[])
+{
+  auto_ptr<odb::oracle::connection_factory> f (
+    new odb::oracle::connection_pool_factory (20));
+
+  auto_ptr<odb::database> db (
+    new oracle::database (argc, argv, false, 0, 0, 0, f));
+}
+
+ +

20.4 Oracle Exceptions

+ +

The Oracle ODB runtime library defines the following + Oracle-specific exceptions:

+ + 
+namespace odb
+{
+  namespace oracle
+  {
+    class database_exception: odb::database_exception
+    {
+    public:
+      class record
+      {
+      public:
+        sb4
+        error () const;
+
+        const std::string&
+        message () const;
+      };
+
+      typedef std::vector<record> records;
+
+      typedef records::size_type size_type;
+      typedef records::const_iterator iterator;
+
+      iterator
+      begin () const;
+
+      iterator
+      end () const;
+
+      size_type
+      size () const;
+
+      virtual const char*
+      what () const throw ();
+    };
+
+    class cli_exception: odb::exception
+    {
+    public:
+      virtual const char*
+      what () const throw ();
+    };
+
+    class invalid_oci_handle: odb::exception
+    {
+    public:
+      virtual const char*
+      what () const throw ();
+    };
+  }
+}
+
+ +

You will need to include the <odb/oracle/exceptions.hxx> + header file to make these exceptions available in your application.

+ +

The odb::oracle::database_exception is thrown if + an Oracle database operation fails. The Oracle-specific error + information is stored as a series of records, each containing + the error code as a signed 4-byte integer and the message string. + All this information is also combined and returned in a + human-readable form by the what() function.

+ +

The odb::oracle::cli_exception is thrown by the + command line parsing constructor of the odb::oracle::database + class if the Oracle option values are missing or invalid. The + what() function returns a human-readable description + of an error.

+ +

The odb::oracle::invalid_oci_handle is thrown if an + invalid handle is passed to an OCI function or if an OCI function + was unable to allocate a handle. The former normally indicates + a programming error while the latter indicates an out of memory + condition. The what() function returns a human-readable + description of an error.

+ +

20.5 Oracle Limitations

+ +

The following sections describe Oracle-specific limitations imposed + by the current Oracle and ODB runtime versions.

+ +

20.5.1 Identifier Truncation

+ +

Oracle limits the length of database identifiers (table, column, etc., + names) to 30 characters. The ODB compiler automatically truncates + any identifier that is longer than 30 characters. This, however, + can lead to duplicate names. A common symptom of this problem + are errors during the database schema creation indicating + that a database object with the same name already exists. To + resolve this problem we can assign custom, shorter identifiers + using the db table and db column + pragmas (Chapter 14, "ODB Pragma Language"). For + example:

+ + 
+#pragma db object
+class long_class_name
+{
+  ...
+
+  std::vector<int> long_container_x_;
+  std::vector<int> long_container_y_;
+};
+
+ +

In the above example, the names of the two container tables will be + long_class_name_long_container_x_ and + long_class_name_long_container_y_. However, when + truncated to 30 characters, they both become + long_class_name_long_container. To resolve this + collision we can assign a custom table name for each container:

+ + 
+#pragma db object
+class long_class_name
+{
+  ...
+
+  #pragma db table("long_class_name_cont_x")
+  std::vector<int> long_container_x_;
+
+  #pragma db table("long_class_name_cont_y")
+  std::vector<int> long_container_y_;
+};
+
+ +

20.5.2 Query Result Caching

+ +

Oracle ODB runtime implementation does not perform query result caching + (Section 4.4, "Query Result") even when explicitly + requested. The OCI API supports interleaving execution of multiple + prepared statements on a single connection. As a result, with OCI, + it is possible to have multiple uncached results and calls to other + database functions do not invalidate them. The only limitation of + the uncached Oracle results is the unavailability of the + result::size() function. If you call this function on + an Oracle query result, then the odb::result_not_cached + exception (Section 3.14, "ODB Exceptions") is + always thrown. Future versions of the Oracle ODB runtime library + may add support for result caching.

+ +

20.5.3 Foreign Key Constraints

+ +

ODB assumes the standard SQL behavior which requires that + foreign key constraints checking is deferred until the + transaction is committed. Default Oracle behavior is + to check such constraints immediately. As a result, when + used with ODB, a custom database schema that defines foreign + key constraints may need to declare such constraints as + INITIALLY DEFERRED, as shown in the following example. + By default, schemas generated by the ODB compiler meet this requirement + automatically.

+ + 
+CREATE TABLE Employee (
+  ...
+  employer NUMBER(20) REFERENCES Employer(id)
+           DEFERRABLE INITIALLY DEFERRED);
+
+ +

You can override the default behavior and instruct the ODB + compiler to generate non-deferrable foreign keys by specifying + the --fkeys-deferrable-mode not_deferrable ODB + compiler option. Note, however, that in this case the order in + which you persist, update, and erase objects within a transaction + becomes important.

+ +

20.5.4 Unique Constraint Violations

+ +

Due to the granularity of the Oracle error codes, it is impossible + to distinguish between the duplicate primary key and other unique + constraint violations. As a result, when making an object persistent, + the Oracle ODB runtime will translate all unique constraint violation + errors to the object_already_persistent exception + (Section 3.14, "ODB Exceptions").

+ +

20.5.5 Large FLOAT and + NUMBER Types

+ +

The Oracle FLOAT type with a binary precision greater + than 53 and fixed-point NUMBER type with a decimal + precision greater than 15 cannot be automatically extracted + into the C++ float and double types. + Instead, the Oracle ODB runtime uses a 21-byte buffer containing + the binary representation of a value as an image type for such + FLOAT and NUMBER types. In order to + convert them into an application-specific large number representation, + you will need to provide a suitable value_traits + template specialization. For more information on the binary format + used to store the FLOAT and NUMBER values, + refer to the Oracle Call Interface (OCI) documentation.

+ +

An alternative approach to accessing large FLOAT and + NUMBER values is to map these type to one of the + natively supported ones, as discussed in Section + 14.8, "Database Type Mapping Pragmas".

+ +

Note that a NUMBER type that is used to represent a + floating point number (declared by specifying NUMBER + without any range and scale) can be extracted into the C++ + float and double types.

+ +

20.5.6 Timezones

+ +

ODB does not currently support the Oracle date-time types with timezone + information. However, these types can be accessed by mapping them to + one of the natively supported types, as discussed in + Section 14.8, "Database Type Mapping Pragmas".

+ +

20.5.7 LONG Types

+ +

ODB does not support the deprecated Oracle LONG and + LONG RAW data types. However, these types can be accessed + by mapping them to one of the natively supported types, as discussed + in Section 14.8, "Database Type Mapping Pragmas".

+ +

20.5.8 LOB Types and By-Value Accessors/Modifiers

+ +

As discussed in Section 14.4.5, + "get/set/access", by-value + accessor and modifier expressions cannot be used with data members + of Oracle large object (LOB) data types: BLOB, + CLOB, and NCLOB. The Oracle ODB runtime + uses streaming for reading/writing LOB data directly from/to + data members. As a result, by-reference accessors and modifiers + should be used for these data types.

+ +

20.5.9 Database Schema Evolution

+ +

In Oracle, the type of the name column in the + schema_version table is VARCHAR2(512). + Because this column is a primary key and VARCHAR2 + represents empty strings as NULL values, it is + impossible to store an empty string in this column, which + is what is used to represent the default schema name. As a + result, in Oracle, the empty schema name is stored as a + string containing a single space character. ODB performs + all the necessary translations automatically and normally + you do not need to worry about this implementation detail + unless you are querying or modifying the schema_version + table directly.

+ +

20.6 Oracle Index Definitions

+ +

When the index pragma (Section 14.7, + "Index Definition Pragmas") is used to define an Oracle index, + the type clause specifies the index type (for example, + UNIQUE, BITMAP), the method + clause is not used, and the options clause specifies + additional index properties, such as partitioning, table spaces, etc. + The column options can be used to specify the sort order. For example:

+ + 
+#pragma db object
+class object
+{
+  ...
+
+  std::string name_;
+
+  #pragma db index                     \
+             type("BITMAP")            \
+             member(name_, "DESC")     \
+             options("TABLESPACE TBS1")
+};
+
+ +

Index names in Oracle are schema-global. To avoid name clashes, + ODB automatically prefixes each index name with the table name on + which it is defined.

+ + + + + +
+

21 Microsoft SQL Server Database

+ +

To generate support code for the SQL Server database you will need + to pass the "--database mssql" + (or "-d mssql") option to the ODB compiler. + Your application will also need to link to the SQL Server ODB runtime + library (libodb-mssql). All SQL Server-specific ODB + classes are defined in the odb::mssql namespace.

+ +

21.1 SQL Server Type Mapping

+ +

The following table summarizes the default mapping between basic + C++ value types and SQL Server database types. This mapping can be + customized on the per-type and per-member basis using the ODB + Pragma Language (Chapter 14, "ODB Pragma Language").

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
C++ TypeSQL Server TypeDefault NULL Semantics
boolBITNOT NULL
charCHAR(1)NOT NULL
signed charTINYINTNOT NULL
unsigned charTINYINTNOT NULL
shortSMALLINTNOT NULL
unsigned shortSMALLINTNOT NULL
intINTNOT NULL
unsigned intINTNOT NULL
longBIGINTNOT NULL
unsigned longBIGINTNOT NULL
long longBIGINTNOT NULL
unsigned long longBIGINTNOT NULL
floatREALNOT NULL
doubleFLOATNOT NULL
std::stringVARCHAR(512)/VARCHAR(256)NOT NULL
char[N]VARCHAR(N-1)NOT NULL
std::wstringNVARCHAR(512)/NVARCHAR(256)NOT NULL
wchar_t[N]NVARCHAR(N-1)NOT NULL
GUIDUNIQUEIDENTIFIERNOT NULL
+ +

It is possible to map the char C++ type to an integer + database type (for example, TINYINT) using the + db type pragma (Section 14.4.3, + "type").

+ +

Note that the std::string and std::wstring + types are mapped differently depending on whether a member of one of + these types is an object id or not. If the member is an object id, + then for this member std::string is mapped + to VARCHAR(256) and std::wstring — + to NVARCHAR(256). Otherwise, std::string + is mapped to VARCHAR(512) and std::wstring + — to NVARCHAR(512). Note also that you can + always change this mapping using the db type pragma + (Section 14.4.3, "type").

+ +

Additionally, by default, C++ enums and C++11 enum classes are + automatically mapped to the SQL Server types corresponding to their + underlying integral types (see table above). The default + NULL semantics is NOT NULL. For + example:

+ + 
+enum color {red, green, blue};
+enum class taste: unsigned char
+{
+  bitter = 1,
+  sweet,
+  sour = 4,
+  salty
+};
+
+#pragma db object
+class object
+{
+  ...
+
+  color color_; // Automatically mapped to INT.
+  taste taste_; // Automatically mapped to TINYINT.
+};
+
+ +

Note also that because SQL Server does not support unsigned integers, + the unsigned short, unsigned int, and + unsigned long/unsigned long long C++ types + are by default mapped to the SMALLINT, INT, + and BIGINT SQL Server types, respectively. The sign bit + of the value stored by the database for these types will contain + the most significant bit of the actual unsigned value being + persisted. Similarly, because there is no signed version of the + TINYINT SQL Server type, by default, the + signed char C++ type is mapped to TINYINT. + As a result, the most significant bit of the value stored by the + database for this type will contain the sign bit of the actual + signed value being persisted.

+ +

It is also possible to add support for additional SQL Server types, + such as geospatial types, XML, and user-defined types. + For more information, refer to Section 14.8, "Database + Type Mapping Pragmas".

+ +

21.1.1 String Type Mapping

+ +

The SQL Server ODB runtime library provides support for mapping the + std::string, char[N], and + std::array<char, N> types to the SQL Server + CHAR, VARCHAR, and TEXT + types as well as the std::wstring, wchar_t[N], + and std::array<wchar_t, N> types to NCHAR, + NVARCHAR, and NTEXT. However, these mappings + are not enabled by default (in particular, by default, + std::array will be treated as a container). To enable the + alternative mappings for these types we need to specify the database + type explicitly using the db type pragma + (Section 14.4.3, "type"), for + example:

+ + 
+#pragma db object
+class object
+{
+  ...
+
+  #pragma db type ("CHAR(2)")
+  char state_[2];
+
+  #pragma db type ("NVARCHAR(max)")
+  std::wstring text_;
+};
+
+ +

Alternatively, this can be done on the per-type basis, for example:

+ + 
+#pragma db value(std::wstring) type("NVARCHAR(max)")
+
+#pragma db object
+class object
+{
+  ...
+
+  std::wstring text_; // Mapped to NVARCHAR(max).
+};
+
+ +

The char[N], std::array<char, N>, + wchar_t[N], and std::array<wchar_t, N> + values may or may not be zero-terminated. When extracting such values + from the database, ODB will append the zero terminator if there is + enough space.

+ +

See also Section 21.1.4, "Long String and Binary + Types" for certain limitations of long string types.

+ +

21.1.2 Binary Type and UNIQUEIDENTIFIER Mapping

+ +

The SQL Server ODB runtime library also provides support for mapping the + std::vector<char>, + std::vector<unsigned char>, + char[N], unsigned char[N], + std::array<char, N>, and std::array<unsigned char, N> + types to the SQL Server BINARY, VARBINARY, and + IMAGE types. There is also support for mapping the + char[16] array to the SQL Server UNIQUEIDENTIFIER + type. However, these mappings are not enabled by default (in particular, + by default, std::vector and std::array will + be treated as containers). To enable the alternative mappings for these + types we need to specify the database type explicitly using the + db type pragma (Section 14.4.3, + "type"), for example:

+ + 
+#pragma db object
+class object
+{
+  ...
+
+  #pragma db type("UNIQUEIDENTIFIER")
+  char uuid_[16];
+
+  #pragma db type("VARBINARY(max)")
+  std::vector<char> buf_;
+
+  #pragma db type("BINARY(256)")
+  unsigned char data_[256];
+};
+
+ +

Alternatively, this can be done on the per-type basis, for example:

+ + 
+typedef std::vector<char> buffer;
+#pragma db value(buffer) type("VARBINARY(max)")
+
+#pragma db object
+class object
+{
+  ...
+
+  buffer buf_; // Mapped to VARBINARY(max).
+};
+
+ +

Note also that in native queries (Chapter 4, "Querying + the Database") char[N] and + std::array<char, N> parameters are by default passed + as a string rather than a binary. To pass such parameters as a binary, + we need to specify the database type explicitly in the + _val()/_ref() calls. Note also that we + don't need to do this for the integrated queries, for example:

+ + 
+char u[16] = {...};
+
+db.query<object> ("uuid = " + query::_val<odb::mssql::id_binary> (u));
+db.query<object> (
+  "uuid = " + query::_val<odb::mssql::id_uniqueidentifier> (u));
+db.query<object> (query::uuid == query::_ref (u));
+
+ +

See also Section 21.1.4, "Long String and Binary + Types" for certain limitations of long binary types.

+ +

21.1.3 ROWVERSION Mapping

+ +

ROWVERSION is a special SQL Server data type that is + automatically incremented by the database server whenever a row + is inserted or updated. As such, it is normally used to implement + optimistic concurrency and ODB provides support for using + ROWVERSION instead of the more portable approach + for optimistic concurrency (Chapter 12, "Optimistic + Concurrency").

+ +

ROWVERSION is a 64-bit value which is mapped by ODB + to unsigned long long. As a result, to use + ROWVERSION for optimistic concurrency we need to + make sure that the version column is of the unsigned long + long type. We also need to explicitly specify that it + should be mapped to the ROWVERSION data type. For + example:

+ + 
+#pragma db object optimistic
+class person
+{
+  ...
+
+  #pragma db version type("ROWVERSION")
+  unsigned long long version_;
+};
+
+ +

21.1.4 Long String and Binary Types

+ +

For SQL Server, ODB handles character, national character, and + binary data in two different ways depending on its maximum length. + If the maximum length (in bytes) is less than or equal to the limit + specified with the --mssql-short-limit ODB compiler + option (1024 by default), then it is treated as short data, + otherwise — long data. For short data ODB pre-allocates + an intermediate buffer of the maximum size and binds it directly + to a parameter or result column. This way the underlying database + API (ODBC) can read/write directly from/to this buffer. In the case + of long data, the data is read/written in chunks using the + SQLGetData()/SQLPutData() ODBC functions. + While the long data approach reduces the amount of memory used by + the application, it may require greater CPU resources.

+ +

Long data has a number of limitations. In particular, when setting + a custom short data limit, make sure that it is sufficiently large + so that no object id in the application is treated as long data. + It is also impossible to load an object or view with long data more + than once as part of a query result iteration (Section + 4.4, "Query Result"). Any such attempt will result in the + odb::mssql::long_data_reload exception + (Section 21.4, "SQL Server Exceptions"). For + example:

+ + 
+#pragma db object
+class object
+{
+  ...
+
+  int num_;
+
+  #pragma db type("VARCHAR(max)") // Long data.
+  std::string str_;
+};
+
+typedef odb::query<object> query;
+typedef odb::result<object> result;
+
+transaction t (db.begin ());
+
+result r (db.query<object> (query::num < 100));
+
+for (result::iterator i (r.begin ()); i != r.end (); ++i)
+{
+  if (!i->str_.empty ()) // First load.
+  {
+    object o;
+    i.load (o); // Error: second load, long_data_reload is thrown.
+  }
+}
+
+t.commit ();
+
+ +

Finally, if a native view (Section 10.6, "Native + Views") contains one or more long data members, then such + members should come last both in the select-list of the native + SQL query and the list of data members in the C++ class.

+ +

21.2 SQL Server Database Class

+ +

The SQL Server database class encapsulates the ODBC + environment handle as well as the server instance address and + user credentials that are used to establish connections to the + database. It has the following interface:

+ + 
+namespace odb
+{
+  namespace mssql
+  {
+    enum protocol
+    {
+      protocol_auto,
+      protocol_tcp, // TCP/IP.
+      protocol_lpc, // Shared memory (local procedure call).
+      protocol_np   // Named pipes.
+    };
+
+    enum transaction_isolation
+    {
+      isolation_read_uncommitted,
+      isolation_read_committed,   // SQL Server default.
+      isolation_repeatable_read,
+      isolation_snapshot,
+      isolation_serializable
+    };
+
+    class database: public odb::database
+    {
+    public:
+      typedef protocol protocol_type;
+      typedef transaction_isolation transaction_isolation_type;
+
+      database (const std::string& user,
+                const std::string& password,
+                const std::string& db,
+                const std::string& server,
+                const std::string& driver = "",
+                const std::string& extra_connect_string = "",
+                transaction_isolation_type = isolation_read_committed,
+                SQLHENV environment = 0,
+                std::[auto|unique]_ptr<connection_factory> = 0);
+
+      database (const std::string& user,
+                const std::string& password,
+                const std::string& db,
+                protocol_type protocol = protocol_auto,
+                const std::string& host = "",
+                const std::string& instance = "",
+                const std::string& driver = "",
+                const std::string& extra_connect_string = "",
+                transaction_isolation_type = isolation_read_committed,
+                SQLHENV environment = 0,
+                std::[auto|unique]_ptr<connection_factory> = 0);
+
+      database (const std::string& user,
+                const std::string& password,
+                const std::string& db,
+                const std::string& host,
+                unsigned int port,
+                const std::string& driver = "",
+                const std::string& extra_connect_string = "",
+                transaction_isolation_type = isolation_read_committed,
+                SQLHENV environment = 0,
+                std::[auto|unique]_ptr<connection_factory> = 0);
+
+      database (const std::string& connect_string,
+                transaction_isolation_type = isolation_read_committed,
+                SQLHENV environment = 0,
+                std::[auto|unique]_ptr<connection_factory> = 0);
+
+      database (int& argc,
+                char* argv[],
+                bool erase = false,
+                const std::string& extra_connect_string = "",
+                transaction_isolation_type = isolation_read_committed,
+                SQLHENV environment = 0,
+                std::[auto|unique]_ptr<connection_factory> = 0);
+
+      static void
+      print_usage (std::ostream&);
+
+    public:
+      const std::string&
+      user () const;
+
+      const std::string&
+      password () const;
+
+      const std::string&
+      db () const;
+
+      protocol_type
+      protocol () const;
+
+      const std::string&
+      host () const;
+
+      const std::string&
+      instance () const;
+
+      unsigned int
+      port () const;
+
+      const std::string&
+      server () const;
+
+      const std::string&
+      driver () const;
+
+      const std::string&
+      extra_connect_string () const;
+
+      transaction_isolation_type
+      transaction_isolation () const;
+
+      const std::string&
+      connect_string () const;
+
+      SQLHENV
+      environment ();
+
+    public:
+      connection_ptr
+      connection ();
+    };
+  }
+}
+
+ +

You will need to include the <odb/mssql/database.hxx> + header file to make this class available in your application.

+ +

The overloaded database constructors allow us to specify the + SQL Server database parameters that should be used when connecting to the + database. The user and password arguments + specify the login name and password. If user is empty, + then Windows authentication is used and the password + argument is ignored. The db argument specifies the + database name to open. If it is empty, then the default database for + the user is used.

+ +

The server argument in the first constructor specifies + the SQL Server instance address in the standard SQL Server address + format:

+ +

+ [protocol:]host[\instance][,port] +

+ +

Where protocol can be tcp + (TCP/IP), lpc (shared memory), or + np (named pipe). If protocol is not specified, then a + suitable protocol is automatically selected based on the SQL Server + Native Client configuration. The host component + can be a host name or an IP address. If instance + is not specified, then the default SQL Server instance is assumed. + If port is not specified, then the default SQL Server port is + used (1433). Note that you would normally specify either the + instance name or the port, but not both. If both are specified, + then the instance name is ignored by the SQL Server Native Client + ODBC driver. For more information on the format of the SQL + Server address, refer to the SQL Server Native Client ODBC + driver documentation.

+ +

The second and third constructors allow us to specify all these address + components (protocol, host, instance, and port) as separate + arguments. The third constructor always connects using TCP/IP + to the specified host and port.

+ +

The driver argument specifies the SQL Server Native + Client ODBC driver that should be used to connect to the database. + If not specified, then the latest available version is used. The + following examples show common ways of connecting to the database + using the first three constructors:

+ + 
+// Connect to the default SQL Server instance on the local machine
+// using the default protocol. Login as 'test' with password 'secret'
+// and open the 'example_db' database.
+//
+odb::mssql::database db1 ("test",
+                          "secret",
+                          "example_db");
+
+// As above except use Windows authentication and open the default
+// database for this user.
+//
+odb::mssql::database db2 ("",
+                          "",
+                          "");
+
+// Connect to the default SQL Server instance on 'onega' using the
+// default protocol. Login as 'test' with password 'secret' and open
+// the 'example_db' database.
+//
+odb::mssql::database db3 ("test",
+                          "secret",
+                          "example_db"
+                          "onega");
+
+// As above but connect to the 'production' SQL Server instance.
+//
+odb::mssql::database db4 ("test",
+                          "secret",
+                          "example_db"
+                          "onega\\production");
+
+// Same as above but specify protocol, host, and instance as separate
+// arguments.
+//
+odb::mssql::database db5 ("test",
+                          "secret",
+                          "example_db",
+                          odb::mssql::protocol_auto,
+                          "onega",
+                          "production");
+
+// As above, but use TCP/IP as the protocol.
+//
+odb::mssql::database db6 ("test",
+                          "secret",
+                          "example_db"
+                          "tcp:onega\\production");
+
+// Same as above but using separate arguments.
+//
+odb::mssql::database db7 ("test",
+                          "secret",
+                          "example_db",
+                          odb::mssql::protocol_tcp,
+                          "onega",
+                          "production");
+
+// As above, but use TCP/IP port instead of the instance name.
+//
+odb::mssql::database db8 ("test",
+                          "secret",
+                          "example_db"
+                          "tcp:onega,1435");
+
+// Same as above but using separate arguments. Note that here we
+// don't need to specify protocol explicitly since it can only
+// be TCP/IP.
+//
+odb::mssql::database db9 ("test",
+                          "secret",
+                          "example_db",
+                          "onega",
+                          1435);
+
+// As above but use the specific SQL Server Native Client ODBC
+// driver version.
+//
+odb::mssql::database dbA ("test",
+                          "secret",
+                          "example_db"
+                          "tcp:onega,1435",
+                          "SQL Server Native Client 10.0");
+
+ + +

The fourth constructor allows us to pass a custom ODBC connection + string that provides all the information necessary to connect to + the database. Note also that all the other constructors have the + extra_connect_string argument which can be used to + specify additional ODBC connection attributes. For more information + on the format of the ODBC connection string, refer to the SQL + Server Native Client ODBC driver documentation.

+ +

The last constructor extracts the database parameters + from the command line. The following options are recognized:

+ + 
+  --user | -U <login>
+  --password | -P <password>
+  --database | -d <name>
+  --server | -S <address>
+  --driver <name>
+  --options-file <file>
+
+ +

The --options-file option allows us to specify some + or all of the database options in a file with each option appearing + on a separate line followed by a space and an option value.

+ +

If the erase argument to this constructor is true, + then the above options are removed from the argv + array and the argc count is updated accordingly. + This is primarily useful if your application accepts other + options or arguments and you would like to get the SQL Server + options out of the argv array.

+ +

This constructor throws the odb::mssql::cli_exception + exception if the SQL Server option values are missing or invalid. See + section Section 21.4, "SQL Server Exceptions" for + more information on this exception.

+ +

The static print_usage() function prints the list of options + with short descriptions that are recognized by this constructor.

+ +

Additionally, all the constructors have the transaction_isolation + and environment arguments. The transaction_isolation + argument allows us to specify an alternative transaction isolation level + that should be used by all the connections created by this database instance. + The environment argument allows us to provide a custom ODBC + environment handle. If this argument is not NULL, then the + passed handle is used in all the ODBC function calls made by this + database instance. Note also that the database + instance does not assume ownership of the passed environment handle and + this handle should be valid for the lifetime of the database + instance.

+ +

The last argument to all of the constructors is a pointer to the + connection factory. In C++98/03, it is std::auto_ptr while + in C++11 std::unique_ptr is used instead. If we pass a + non-NULL value, the database instance assumes ownership + of the factory instance. The connection factory interface as well as + the available implementations are described in the next section.

+ +

The set of accessor functions following the constructors allows us + to query the parameters of the database instance.

+ +

The connection() function returns a pointer to the + SQL Server database connection encapsulated by the + odb::mssql::connection class. For more information + on mssql::connection, refer to Section + 21.3, "SQL Server Connection and Connection Factory".

+ +

21.3 SQL Server Connection and Connection Factory

+ +

The mssql::connection class has the following interface:

+ + 
+namespace odb
+{
+  namespace mssql
+  {
+    class connection: public odb::connection
+    {
+    public:
+      connection (database&);
+      connection (database&, SQLHDBC handle);
+
+      SQLHDBC
+      handle ();
+
+      details::buffer&
+      long_data_buffer ();
+    };
+
+    typedef details::shared_ptr<connection> connection_ptr;
+  }
+}
+
+ +

For more information on the odb::connection interface, refer + to Section 3.6, "Connections". The first overloaded + mssql::connection constructor creates a new ODBC connection. + The created connection is configured to use the manual commit mode with + multiple active result sets (MARS) enabled. The second constructor allows + us to create a connection instance by providing an already + established ODBC connection. Note that the connection + instance assumes ownership of this handle. The handle() + accessor returns the underlying ODBC connection handle associated with + the connection instance.

+ +

Additionally, each connection instance maintains a long + data buffer. This buffer is used by the SQL Server ODB runtime + as an intermediate storage for piecewise handling of long data. + By default, the long data buffer has zero initial capacity and is + expanded to 4096 bytes when the first long data operation is performed. + If your application requires a bigger or smaller long data buffer, + you can specify a custom capacity using the long_data_buffer() + accessor.

+ +

The mssql::connection_factory abstract class has the + following interface:

+ + 
+namespace odb
+{
+  namespace mssql
+  {
+    class connection_factory
+    {
+    public:
+      virtual void
+      database (database&) = 0;
+
+      virtual connection_ptr
+      connect () = 0;
+    };
+  }
+}
+
+ +

The database() function is called when a connection + factory is associated with a database instance. This happens in + the odb::mssql::database class constructors. The + connect() function is called whenever a database + connection is requested.

+ +

The two implementations of the connection_factory + interface provided by the SQL Server ODB runtime are + new_connection_factory and + connection_pool_factory. You will need to include + the <odb/mssql/connection-factory.hxx> + header file to make the connection_factory interface + and these implementation classes available in your application.

+ +

The new_connection_factory class creates a new + connection whenever one is requested. When a connection is no + longer needed, it is released and closed. The + new_connection_factory class has the following + interface:

+ + 
+namespace odb
+{
+  namespace mssql
+  {
+    class new_connection_factory: public connection_factory
+    {
+    public:
+      new_connection_factory ();
+    };
+};
+
+ +

The connection_pool_factory class implements a + connection pool. It has the following interface:

+ + 
+namespace odb
+{
+  namespace mssql
+  {
+    class connection_pool_factory: public connection_factory
+    {
+    public:
+      connection_pool_factory (std::size_t max_connections = 0,
+                               std::size_t min_connections = 0);
+
+    protected:
+      class pooled_connection: public connection
+      {
+      public:
+        pooled_connection (database_type&);
+        pooled_connection (database_type&, SQLHDBC handle);
+      };
+
+      typedef details::shared_ptr<pooled_connection> pooled_connection_ptr;
+
+      virtual pooled_connection_ptr
+      create ();
+    };
+};
+
+ +

The max_connections argument in the + connection_pool_factory constructor specifies the maximum + number of concurrent connections that this pool factory will + maintain. Similarly, the min_connections argument + specifies the minimum number of available connections that + should be kept open.

+ +

Whenever a connection is requested, the pool factory first + checks if there is an unused connection that can be returned. + If there is none, the pool factory checks the + max_connections value to see if a new connection + can be created. If the total number of connections maintained + by the pool is less than this value, then a new connection is + created and returned. Otherwise, the caller is blocked until + a connection becomes available.

+ +

When a connection is released, the pool factory first checks + if there are blocked callers waiting for a connection. If so, then + one of them is unblocked and is given the connection. Otherwise, + the pool factory checks whether the total number of connections + maintained by the pool is greater than the min_connections + value. If that's the case, the connection is closed. Otherwise, the + connection is added to the pool of available connections to be + returned on the next request. In other words, if the number of + connections maintained by the pool exceeds min_connections + and there are no callers waiting for a new connection, + the pool will close the excess connections.

+ +

If the max_connections value is 0, then the pool will + create a new connection whenever all of the existing connections + are in use. If the min_connections value is 0, then + the pool will never close a connection and instead maintain all + the connections that were ever created.

+ +

The create() virtual function is called whenever the + pool needs to create a new connection. By deriving from the + connection_pool_factory class and overriding this + function we can implement custom connection establishment + and configuration.

+ +

If you pass NULL as the connection factory to one of the + database constructors, then the + connection_pool_factory instance will be created by default + with the min and max connections values set to 0. The + following code fragment shows how we can pass our own connection factory + instance:

+ + 
+#include <odb/database.hxx>
+
+#include <odb/mssql/database.hxx>
+#include <odb/mssql/connection-factory.hxx>
+
+int
+main (int argc, char* argv[])
+{
+  auto_ptr<odb::mssql::connection_factory> f (
+    new odb::mssql::connection_pool_factory (20));
+
+  auto_ptr<odb::database> db (
+    new mssql::database (argc, argv, false, "", 0, f));
+}
+
+ +

21.4 SQL Server Exceptions

+ +

The SQL Server ODB runtime library defines the following + SQL Server-specific exceptions:

+ + 
+namespace odb
+{
+  namespace mssql
+  {
+    class database_exception: odb::database_exception
+    {
+    public:
+      class record
+      {
+      public:
+        SQLINTEGER
+        error () const;
+
+        const std::string&
+        sqlstate () const;
+
+        const std::string&
+        message () const;
+      };
+
+      typedef std::vector<record> records;
+
+      typedef records::size_type size_type;
+      typedef records::const_iterator iterator;
+
+      iterator
+      begin () const;
+
+      iterator
+      end () const;
+
+      size_type
+      size () const;
+
+      virtual const char*
+      what () const throw ();
+    };
+
+    class cli_exception: odb::exception
+    {
+    public:
+      virtual const char*
+      what () const throw ();
+    };
+
+    class long_data_reload: odb::exception
+    {
+    public:
+      virtual const char*
+      what () const throw ();
+    };
+  }
+}
+
+ +

You will need to include the <odb/mssql/exceptions.hxx> + header file to make these exceptions available in your application.

+ +

The odb::mssql::database_exception is thrown if + an SQL Server database operation fails. The SQL Server-specific error + information is stored as a series of records, each containing + the error code as a signed 4-byte integer, the SQLSTATE code, + and the message string. All this information is also combined + and returned in a human-readable form by the what() + function.

+ +

The odb::mssql::cli_exception is thrown by the + command line parsing constructor of the odb::mssql::database + class if the SQL Server option values are missing or invalid. The + what() function returns a human-readable description + of an error.

+ +

The odb::mssql::long_data_reload is thrown if an + attempt is made to re-load an object or view with long data as + part of a query result iteration. For more information, refer + to Section 21.1, "SQL Server Type Mapping".

+ +

21.5 SQL Server Limitations

+ +

The following sections describe SQL Server-specific limitations imposed + by the current SQL Server and ODB runtime versions.

+ +

21.5.1 Query Result Caching

+ +

SQL Server ODB runtime implementation does not perform query result + caching (Section 4.4, "Query Result") even when + explicitly requested. The ODBC API and the SQL Server Native Client ODBC + driver support interleaving execution of multiple prepared statements + on a single connection. As a result, it is possible to have multiple + uncached results and calls to other database functions do not invalidate + them. The only limitation of the uncached SQL Server results is the + unavailability of the result::size() function. If you + call this function on an SQL Server query result, then the + odb::result_not_cached exception (Section + 3.14, "ODB Exceptions") is always thrown. Future versions of the + SQL Server ODB runtime library may add support for result caching.

+ +

21.5.2 Foreign Key Constraints

+ +

ODB assumes the standard SQL behavior which requires that foreign + key constraints checking is deferred until the transaction is + committed. The only behavior supported by SQL Server is to check + such constraints immediately. As a result, by default, schemas + generated by the ODB compiler for SQL Server have foreign key + definitions commented out. They are retained only for documentation.

+ +

You can override the default behavior and instruct the ODB + compiler to generate non-deferrable foreign keys by specifying + the --fkeys-deferrable-mode not_deferrable ODB + compiler option. Note, however, that in this case the order in + which you persist, update, and erase objects within a transaction + becomes important.

+ +

21.5.3 Unique Constraint Violations

+ +

Due to the granularity of the ODBC error codes, it is impossible + to distinguish between the duplicate primary key and other unique + constraint violations. As a result, when making an object persistent, + the SQL Server ODB runtime will translate all unique constraint violation + errors to the object_already_persistent exception + (Section 3.14, "ODB Exceptions").

+ +

21.5.4 Multi-threaded Windows Applications

+ +

Multi-threaded Windows applications must use the + _beginthread()/_beginthreadex() and + _endthread()/_endthreadex() CRT functions + instead of the CreateThread() and EndThread() + Win32 functions to start and terminate threads. This is a limitation of + the ODBC implementation on Windows.

+ +

21.5.5 Affected Row Count and DDL Statements

+ +

SQL Server always returns zero as the number of affected rows + for DDL statements. In particular, this means that the + database::execute() (Section 3.12, + "Executing Native SQL Statements") function will always + return zero for such statements.

+ +

21.5.6 Long Data and Auto Object Ids, ROWVERSION

+ +

SQL Server 2005 has a bug that causes it to fail on an INSERT + or UPDATE statement with the OUTPUT clause + (used to return automatically assigned object ids as well as + ROWVERSION values) if one of the inserted columns + is long data. The symptom of this bug in ODB is an exception thrown + by the database::persist() or database::update() + function when used on an object that contains long data and has an + automatically assigned object id or uses ROWVERSION-based + optimistic concurrency (Section 21.1.1, + "ROWVERSION Support"). The error message reads "This + operation conflicts with another pending operation on this transaction. + The operation failed."

+ +

For automatically assigned object ids ODB includes a workaround for + this bug which uses a less efficient method to obtain id values for + objects that contain long data. To enable this workaround you need + to specify that the generated code will be used with SQL Server 2005 + or later by passing the --mssql-server-version 9.0 + ODB compiler option.

+ +

For ROWVERSION-based optimistic concurrency no workaround + is currently provided. The ODB compiler will issue an error for + objects that use ROWVERSION for optimistic concurrency + and containing long data.

+ +

21.5.7 Long Data and By-Value Accessors/Modifiers

+ +

As discussed in Section 14.4.5, + "get/set/access", by-value + accessor and modifier expressions cannot be used with data members + of long data types. The SQL Server ODB runtime uses streaming for + reading/writing long data directly from/to data members. As a result, + by-reference accessors and modifiers should be used for these data + types.

+ +

21.5.8 Bulk Update and ROWVERSION

+ +

The bulk update operation (Section 15.3, "Bulk Database + Operations") is not yet supported for persistent classes that use + ROWVERSION-based optimistic concurrency. For such classes + the bulk update() function is not available. The bulk + persist and erase support is still provided.

+ +

21.6 SQL Server Index Definitions

+ +

When the index pragma (Section 14.7, + "Index Definition Pragmas") is used to define an SQL Server index, + the type clause specifies the index type (for example, + UNIQUE, CLUSTERED), the method + clause is not used, and the options clause specifies + additional index properties. The column options can be used to specify + the sort order. For example:

+ + 
+#pragma db object
+class object
+{
+  ...
+
+  std::string name_;
+
+  #pragma db index                             \
+             type("UNIQUE CLUSTERED")          \
+             member(name_, "DESC")             \
+             options("WITH(FILLFACTOR = 80)")
+};
+
+ +

21.7 SQL Server Stored Procedures

+ +

ODB native views (Section 10.6, "Native Views") + can be used to call SQL Server stored procedures. For example, assuming + we are using the person class from Chapter + 2, "Hello World Example" (and the corresponding person + table), we can create a stored procedure that given the min and max + ages returns some information about all the people in that range:

+ + 
+CREATE PROCEDURE dbo.person_range (
+  @min_age SMALLINT,
+  @max_age SMALLINT)
+AS
+  SELECT age, first, last FROM person
+    WHERE age >= @min_age AND age <= @max_age;
+
+ +

Given the above stored procedure we can then define an ODB view + that can be used to call it and retrieve its result:

+ + 
+#pragma db view query("EXEC person_range (?)")
+struct person_range
+{
+  unsigned short age;
+  std::string first;
+  std::string last;
+};
+
+ +

The following example shows how we can use the above view to + print the list of people in a specific age range:

+ + 
+typedef odb::query<person_range> query;
+typedef odb::result<person_range> result;
+
+transaction t (db.begin ());
+
+result r (
+  db.query<person_range> (
+    query::_val (1) + "," + query::_val (18)));
+
+for (result::iterator i (r.begin ()); i != r.end (); ++i)
+  cerr << i->first << " " << i->last << " " << i->age << endl;
+
+t.commit ();
+
+ +

Note that as with all native views, the order and types of data members + must match those of columns in the SELECT list inside + the stored procedure.

+ +

There are also a number of limitations when it comes to calling + SQL Server stored procedures with ODB views. There is currently + no support for output parameters, however, this is planned for + a future version. In the meantime, to call a stored procedure + that has output parameters we have to use a wrapper procedure + that converts such parameters to a SELECT + result. For example, given the following procedure that + calculates the age range of the people in our database:

+ + 
+CREATE PROCEDURE dbo.person_age_range (
+  @min_age SMALLINT = NULL OUTPUT,
+  @max_age SMALLINT = NULL OUTPUT)
+AS
+  SELECT @min_age = MIN(age), @max_age = MAX(max) FROM person;
+
+ +

We can create a wrapper procedure like this:

+ + 
+CREATE PROCEDURE dbo.person_age_range_odb
+AS
+  DECLARE @min_age SMALLINT, @max_age SMALLINT;
+  EXEC person_age_range @min_age OUTPUT, @max_age OUTPUT;
+  SELECT @min_age, @max_age;
+
+ +

And a view like this:

+ + 
+#pragma db view query("EXEC person_age_range_odb")
+struct person_age_range
+{
+  unsigned short min_age;
+  unsigned short max_age;
+};
+
+ +

Which we can then use to call the stored procedure:

+ + 
+transaction t (db.begin ());
+
+person_age_range ar (db.query_value<person_age_range> ());
+cerr << ar.min_age << " " << ar.max_age << endl;
+
+t.commit ();
+
+ +

In SQL Server, a stored procedure can produce multiple results. + For example, if a stored procedure executes several + SELECT statements, then the result of calling such + a procedure consists of two row sets, one for each SELECT + statement. Because such multiple row sets can contain varying number + and type of columns, they cannot be all extracted into a + single view. Consequently, these kind of stored procedures are + currently not supported.

+ +

A stored procedure may also produce no row sets at all. For + example, a stored procedure that only executes DML statements + would exhibit this behavior. To call such a procedure we use + an empty view, for example:

+ + 
+CREATE PROCEDURE dbo.insert_person (
+  @first VARCHAR(512),
+  @last VARCHAR(512),
+  @age SMALLINT)
+AS
+  INSERT INTO person(first, last, age)
+    VALUES(@first, @last, @age);
+
+ + 
+#pragma db view
+struct no_result {};
+
+transaction t (db.begin ());
+
+db.query_one<no_result> (
+  "EXEC insert_person" +
+    query::_val ("John") + "," +
+    query::_val ("Doe") + "," +
+    query::_val (21));
+
+t.commit ();
+
+ +

Finally, an SQL Server stored procedure can also return an + integer status code. Similar to output parameters, this code + can only be observed by an ODB view if it is converted to a + SELECT result. For more information on how to + do this and for other examples of stored procedure calls, + refer to the mssql/stored-proc test in the + odb-tests package.

+ + + + +
+

PART III   + PROFILES

+ +

Part III covers the integration of ODB with popular C++ frameworks + and libraries. It consists of the following chapters.

+ + + + + +
22Profiles Introduction
23Boost Profile
24Qt Profile
+ + + + + +
+

22 Profiles Introduction

+ +

ODB profiles are a generic mechanism for integrating ODB with + widely-used C++ frameworks and libraries. A profile provides glue + code which allows you to seamlessly persist various components, such + as smart pointers, containers, and value types found in these + frameworks or libraries. The code necessary to implement a profile + is packaged into the so called profile library. For example, the + Boost profile implementation is provided by the libodb-boost + profile library.

+ +

Besides linking the profile library to our application, it is also + necessary to let the ODB compiler know which profiles we + are using. This is accomplished with the --profile + (or -p alias) option. For example:

+ + 
+odb --profile boost ...
+
+ +

Some profiles, especially those covering frameworks or libraries that + consist of multiple sub-libraries, provide sub-profiles that allow you + to pick and choose which components you would like to use in your + application. For example, the boost profile contains + the boost/data-time sub-profile. If we are only + interested in the date_time types, then we can + pass boost/data-time instead of boost + to the --profile option, for example:

+ + 
+odb --profile boost/date-time ...
+
+ +

To summarize, you will need to perform the following steps in order + to make use of a profile in your application:

+ +
    +
  1. ODB compiler: if necessary, specify the path to the profile library + headers (-I option).
    2. +
  2. ODB compiler: specify the profile you would like to use with + the --profile option.
    3. +
  3. C++ compiler: if necessary, specify the path to the profile library + headers (normally -I option).
    4. +
  4. Linker: link the profile library to the application.
    5. +
+ +

The remaining chapters in this part of the manual describe the + standard profiles provided by ODB.

+ + + + + +
+

23 Boost Profile

+ +

The ODB profile implementation for Boost is provided by the + libodb-boost library and consists of multiple sub-profiles + corresponding to the individual Boost libraries. To enable all the + available Boost sub-profiles, pass boost as the profile + name to the --profile ODB compiler option. Alternatively, + you can enable only specific sub-profiles by passing individual + sub-profile names to --profile. The following sections in + this chapter discuss each Boost sub-profile in detail. The + boost example in the odb-examples + package shows how to enable and use the Boost profile.

+ +

Some sub-profiles may throw exceptions to indicate error conditions, + such as the inability to store a specific value in a particular database + system. All such exceptions derive from the + odb::boost::exception class which in turn derives from + the root of the ODB exception hierarchy, class odb::exception + (Section 3.14, "ODB Exceptions"). The + odb::boost::exception class is defined in the + <odb/boost/exception.hxx> header file and has the + same interface as odb::exception. Concrete exceptions + that can be thrown by the Boost sub-profiles are described in the + following sections.

+ +

23.1 Smart Pointers Library

+ +

The smart-ptr sub-profile provides persistence + support for a subset of smart pointers from the Boost + smart_ptr library. To enable only this profile, + pass boost/smart-ptr to the --profile + ODB compiler option.

+ +

The currently supported smart pointers are + boost::shared_ptr and boost::weak_ptr. For + more information on using smart pointers as pointers to objects and + views, refer to Section 3.3, "Object and View Pointers" + and Chapter 6, "Relationships". For more information + on using smart pointers as pointers to values, refer to + Section 7.3, "Pointers and NULL Value + Semantics". When used as a pointer to a value, only + boost::shared_ptr is supported. For example:

+ + 
+#pragma db object
+class person
+{
+  ...
+
+  #pragma db null
+  boost::shared_ptr<std::string> middle_name_;
+};
+
+ +

To provide finer grained control over object relationship loading, + the smart-ptr sub-profile also provides the lazy + counterparts for the above pointers: odb::boost::lazy_shared_ptr and + odb::boost::lazy_weak_ptr. You will need to include the + <odb/boost/lazy-ptr.hxx> header file to make the lazy + variants available in your application. For a description of the lazy + pointer interface and semantics refer to Section 6.4, + "Lazy Pointers". The following example shows how we can use these + smart pointers to establish a relationship between persistent objects.

+ + 
+class employee;
+
+#pragma db object
+class position
+{
+  ...
+
+  #pragma db inverse(position_)
+  odb::boost::lazy_weak_ptr<employee> employee_;
+};
+
+#pragma db object
+class employee
+{
+  ...
+
+  #pragma db not_null
+  boost::shared_ptr<position> position_;
+};
+
+ +

Besides providing persistence support for the above smart pointers, + the smart-ptr sub-profile also changes the default + pointer (Section 3.3, "Object and View Pointers") + to boost::shared_ptr. In particular, this means that + database functions that return dynamically allocated objects and views + will return them as boost::shared_ptr pointers. To override + this behavior, add the --default-pointer option specifying + the alternative pointer type after the --profile option.

+ +

23.2 Unordered Containers Library

+ +

The unordered sub-profile provides persistence support for + the containers from the Boost unordered library. To enable + only this profile, pass boost/unordered to + the --profile ODB compiler option.

+ +

The supported containers are boost::unordered_set, + boost::unordered_map, boost::unordered_multiset, + and boost::unordered_multimap. For more information on using + the set and multiset containers with ODB, refer to Section + 5.2, "Set and Multiset Containers". For more information on using the + map and multimap containers with ODB, refer to Section + 5.3, "Map and Multimap Containers". The following example shows how + the unordered_set container may be used within a persistent + object.

+ + 
+#pragma db object
+class person
+{
+  ...
+  boost::unordered_set<std::string> emails_;
+};
+
+ +

23.3 Multi-Index Container Library

+ +

The multi-index sub-profile provides persistence support for + boost::multi_index_container from the Boost Multi-Index + library. To enable only this profile, pass boost/multi-index + to the --profile ODB compiler option. The following example + shows how multi_index_container may be used within a + persistent object.

+ + 
+namespace mi = boost::multi_index;
+
+#pragma db object
+class person
+{
+  ...
+
+  typedef
+  mi::multi_index_container<
+    std::string,
+    mi::indexed_by<
+      mi::sequenced<>,
+      mi::ordered_unique<mi::identity<std::string> >
+    >
+  > emails;
+
+  emails emails_;
+};
+
+ +

Note that a multi_index_container instantiation is + stored differently in the database depending on whether it has + any sequenced or random_access indexes. + If it does, then it is treated as an ordered container + (Section 5.1, "Ordered Containers") with the + first such index establishing the order. Otherwise, it is treated + as a set container (Section 5.2, "Set and Multiset + Containers").

+ +

Note also that there is a terminology clash between ODB and Boost + Multi-Index. The ODB term ordered container translates + to Multi-Index terms sequenced index and random access + index while the ODB term set container translates + to Multi-Index terms ordered index and hashed + index.

+ +

The emails container from the above example is stored + as an ordered container. In contrast, the following aliases + container is stored as a set.

+ + 
+namespace mi = boost::multi_index;
+
+#pragma db value
+struct name
+{
+  std::string first;
+  std::string last;
+};
+
+bool operator< (const name&, const name&);
+
+#pragma db object
+class person
+{
+  ...
+
+  typedef
+  mi::multi_index_container<
+    name,
+    mi::indexed_by<
+      mi::ordered_unique<mi::identity<name> >
+      mi::ordered_non_unique<
+        mi::member<name, std::string, &name::first>
+      >,
+      mi::ordered_non_unique<
+        mi::member<name, std::string, &name::last>
+      >
+    >
+  > aliases;
+
+  aliases aliases_;
+};
+
+ +

23.4 Optional Library

+ +

The optional sub-profile provides persistence support for + the boost::optional container from the Boost + optional library. To enable only this profile, pass + boost/optional to the --profile ODB compiler + option.

+ +

In a relational database boost::optional is mapped to + a column that can have a NULL value. Similar to + odb::nullable (Section 7.3, "Pointers and + NULL Value Semantics"), it can be used to add the + NULL semantics to existing C++ types. For example:

+ + 
+#include <boost/optional.hpp>
+
+#pragma db object
+class person
+{
+  ...
+
+  std::string first_;                    // TEXT NOT NULL
+  boost::optional<std::string> middle_;  // TEXT NULL
+  std::string last_;                     // TEXT NOT NULL
+};
+
+ +

Note also that similar to odb::nullable, when + this profile is used, the NULL values are automatically + enabled for data members of the boost::optional type.

+ +

23.5 Date Time Library

+ +

The date-time sub-profile provides persistence support for a + subset of types from the Boost date_time library. It is + further subdivided into two sub-profiles, gregorian + and posix_time. The gregorian sub-profile + provides support for types from the boost::gregorian + namespace, while the posix-time sub-profile provides support + for types from the boost::posix_time namespace. To enable + the entire date-time sub-profile, pass + boost/date-time to the --profile ODB compiler + option. To enable only the gregorian sub-profile, pass + boost/date-time/gregorian, and to enable only the + posix-time sub-profile, pass + boost/date-time/posix-time.

+ +

The only type that the gregorian sub-profile currently + supports is gregorian::date. The types currently supported + by the posix-time sub-profile are + posix_time::ptime and + posix_time::time_duration. The manner in which these types + are persisted is database system dependent and is discussed in the + sub-sections that follow. The example below shows how + gregorian::date may be used within a persistent object.

+ + 
+#pragma db object
+class person
+{
+  ...
+  boost::gregorian::date date_of_birth_;
+};
+
+ +

Concrete exceptions that can be thrown by the date-time + sub-profile implementation are presented below.

+ + + 
+namespace odb
+{
+  namespace boost
+  {
+    namespace date_time
+    {
+      struct special_value: odb::boost::exception
+      {
+        virtual const char*
+        what () const throw ();
+      };
+
+      struct value_out_of_range: odb::boost::exception
+      {
+        virtual const char*
+        what () const throw ();
+      };
+    }
+  }
+}
+
+ +

You will need to include the + <odb/boost/date-time/exceptions.hxx> header file to + make these exceptions available in your application.

+ +

The special_value exception is thrown if an attempt is made + to store a Boost date-time special value that cannot be represented in + the target database. The value_out_of_range exception is + thrown if an attempt is made to store a date-time value that is out of + the target database range. The specific conditions under which these + exceptions are thrown are database system dependent and are discussed in + more detail in the following sub-sections.

+ +

23.5.1 MySQL Database Type Mapping

+ +

The following table summarizes the default mapping between the currently + supported Boost date_time types and the MySQL database + types.

+ + + + + + + + + + + + + + + + + + + + + + + + + + +
Boost date_time TypeMySQL TypeDefault NULL Semantics
gregorian::dateDATENULL
posix_time::ptimeDATETIMENULL
posix_time::time_durationTIMENULL
+ +

The Boost special value date_time::not_a_date_time is stored + as a NULL value in a MySQL database.

+ +

The posix-time sub-profile implementation also provides + support for mapping posix_time::ptime to the + TIMESTAMP MySQL type. However, this mapping has to be + explicitly requested using the db type pragma + (Section 14.4.3, "type"), as shown in + the following example:

+ + 
+#pragma db object
+class person
+{
+  ...
+  #pragma db type("TIMESTAMP") not_null
+  boost::posix_time::ptime updated_;
+};
+
+ +

Starting with MySQL version 5.6.4 it is possible to store fractional + seconds up to microsecond precision in TIME, + DATETIME, and TIMESTAMP columns. However, + to enable sub-second precision, the corresponding type with the + desired precision has to be specified explicitly, as shown in the + following example:

+ + 
+#pragma db object
+class person
+{
+  ...
+  #pragma db type("DATETIME(6)")     // Microsecond precision.
+  boost::posix_time::ptime updated_;
+};
+
+ +

Alternatively, you can enable sub-second precision on the per-type + basis, for example:

+ + 
+#pragma db value(boost::posix_time::ptime) type("DATETIME(6)")
+
+#pragma db object
+class person
+{
+  ...
+  boost::posix_time::ptime created_; // Microsecond precision.
+  boost::posix_time::ptime updated_; // Microsecond precision.
+};
+
+ +

Some valid Boost date-time values cannot be stored in a MySQL database. + An attempt to persist any Boost date-time special value other than + date_time::not_a_date_time will result in the + special_value exception. An attempt to persist a Boost + date-time value that is out of the MySQL type range will result in + the out_of_range exception. Refer to the MySQL + documentation for more information on the MySQL data type ranges.

+ +

23.5.2 SQLite Database Type Mapping

+ +

The following table summarizes the default mapping between the currently + supported Boost date_time types and the SQLite database + types.

+ + + + + + + + + + + + + + + + + + + + + + + + + + +
Boost date_time TypeSQLite TypeDefault NULL Semantics
gregorian::dateTEXTNULL
posix_time::ptimeTEXTNULL
posix_time::time_durationTEXTNULL
+ +

The Boost special value date_time::not_a_date_time is stored + as a NULL value in an SQLite database.

+ +

The date-time sub-profile implementation also provides + support for mapping gregorian::date and + posix_time::ptime to the INTEGER SQLite type, + with the integer value representing the UNIX time. Similarly, an + alternative mapping for posix_time::time_duration to the + INTEGER type represents the duration as a number of + seconds. These mappings have to be explicitly requested using the + db type pragma (Section 14.4.3, + "type"), as shown in the following example:

+ + 
+#pragma db object
+class person
+{
+  ...
+  #pragma db type("INTEGER")
+  boost::gregorian::date born_;
+};
+
+ + + +

Some valid Boost date-time values cannot be stored in an SQLite database. + An attempt to persist any Boost date-time special value other than + date_time::not_a_date_time will result in the + special_value exception. An attempt to persist a negative + posix_time::time_duration value as SQLite TEXT + will result in the out_of_range exception.

+ + +

23.5.3 PostgreSQL Database Type Mapping

+ +

The following table summarizes the default mapping between the currently + supported Boost date_time types and the PostgreSQL database + types.

+ + + + + + + + + + + + + + + + + + + + + + + + + + +
Boost date_time TypePostgreSQL TypeDefault NULL Semantics
gregorian::dateDATENULL
posix_time::ptimeTIMESTAMPNULL
posix_time::time_durationTIMENULL
+ +

The Boost special value date_time::not_a_date_time is stored + as a NULL value in a PostgreSQL database. + posix_time::ptime values representing the special values + date_time::pos_infin and date_time::neg_infin + are stored as the special PostgreSQL TIMESTAMP values + infinity and -infinity, respectively.

+ +

Some valid Boost date-time values cannot be stored in a PostgreSQL + database. The PostgreSQL TIME type represents a clock time, and can + therefore only store positive durations with a total length of time less + than 24 hours. An attempt to persist a + posix_time::time_duration value outside of this range will + result in the value_out_of_range exception. An attempt to + persist a posix_time::time_duration value representing any + special value other than date_time::not_a_date_time will + result in the special_value exception.

+ + +

23.5.4 Oracle Database Type Mapping

+ +

The following table summarizes the default mapping between the currently + supported Boost date_time types and the Oracle database + types.

+ + + + + + + + + + + + + + + + + + + + + + + + + + +
Boost date_time TypeOracle TypeDefault NULL Semantics
gregorian::dateDATENULL
posix_time::ptimeTIMESTAMPNULL
posix_time::time_durationINTERVAL DAY TO SECONDNULL
+ +

The Boost special value date_time::not_a_date_time is stored + as a NULL value in an Oracle database.

+ +

The date-time sub-profile implementation also provides + support for mapping posix_time::ptime to the + DATE Oracle type with fractional seconds that may be + stored in a ptime instance being ignored. This + alternative mapping has to be explicitly requested using the + db type pragma (Section 14.4.3, + "type"), as shown in the following example:

+ + 
+#pragma db object
+class person
+{
+  ...
+  #pragma db type("DATE")
+  boost::posix_time::ptime updated_;
+};
+
+ +

Some valid Boost date-time values cannot be stored in an Oracle database. + An attempt to persist a gregorian::date, + posix_time::ptime, or + posix_time::time_duration value representing any special + value other than date_time::not_a_date_time will result in + the special_value exception.

+ + +

23.5.5 SQL Server Database Type Mapping

+ +

The following table summarizes the default mapping between the currently + supported Boost date_time types and the SQL Server database + types.

+ + + + + + + + + + + + + + + + + + + + + + + + + + +
Boost date_time TypeSQL Server TypeDefault NULL Semantics
gregorian::dateDATENULL
posix_time::ptimeDATETIME2NULL
posix_time::time_durationTIMENULL
+ +

The Boost special value date_time::not_a_date_time is stored + as a NULL value in an SQL Server database.

+ +

Note that the DATE, TIME, and + DATETIME2 types are only available in SQL Server 2008 and + later. SQL Server 2005 only supports the DATETIME and + SMALLDATETIME date-time types. The new types are + also unavailable when connecting to an SQL Server 2008 or + later with the SQL Server 2005 Native Client ODBC driver.

+ +

The date-time sub-profile implementation provides + support for mapping posix_time::ptime to the + DATETIME and SMALLDATETIME types, + however, this mapping has to be explicitly requested using the + db type pragma (Section 14.4.3, + "type"), as shown in the following example:

+ + 
+#pragma db object
+class person
+{
+  ...
+  #pragma db type("DATETIME")
+  boost::posix_time::ptime updated_;
+};
+
+ +

Some valid Boost date-time values cannot be stored in an SQL Server + database. An attempt to persist a gregorian::date, + posix_time::ptime, or posix_time::time_duration + value representing any special value other than + date_time::not_a_date_time will result in the + special_value exception. The range of the TIME + type in SQL server is from 00:00:00.0000000 to + 23:59:59.9999999. An attempt to persist a + posix_time::time_duration value out of this range will + result in the value_out_of_range exception.

+ +

23.6 Uuid Library

+ +

The uuid sub-profile provides persistence support for the + uuid type from the Boost uuid library. To + enable only this profile, pass boost/uuid to the + --profile ODB compiler option.

+ +

The manner in which these types are persisted is database system + dependent and is discussed in the sub-sections that follow. By + default a data member of the uuid type is mapped to a + database column with NULL enabled and nil uuid + instances are stored as a NULL value. However, you can + change this behavior by declaring the data member NOT NULL + with the not_null pragma (Section + 14.4.6, "null/not_null"). In this + case, or if the data member is an object id, the implementation + will store nil uuid instances as zero UUID values + ({00000000-0000-0000-0000-000000000000}). For example:

+ + 
+#pragma db object
+class object
+{
+  ...
+
+  boost::uuids::uuid x_; // Nil values stored as NULL.
+
+  #pragma db not_null
+  boost::uuids::uuid y_; // Nil values stored as zero.
+};
+
+ +

23.6.1 MySQL Database Type Mapping

+ +

The following table summarizes the default mapping between the Boost + uuid type and the MySQL database type.

+ + + + + + + + + + + + + + +
Boost TypeMySQL TypeDefault NULL Semantics
boost::uuids::uuidBINARY(16)NULL
+ +

23.6.2 SQLite Database Type Mapping

+ +

The following table summarizes the default mapping between the Boost + uuid type and the SQLite database type.

+ + + + + + + + + + + + + + +
Boost TypeSQLite TypeDefault NULL Semantics
boost::uuids::uuidBLOBNULL
+ +

23.6.3 PostgreSQL Database Type Mapping

+ +

The following table summarizes the default mapping between the Boost + uuid type and the PostgreSQL database type.

+ + + + + + + + + + + + + + +
Boost TypePostgreSQL TypeDefault NULL Semantics
boost::uuids::uuidUUIDNULL
+ +

23.6.4 Oracle Database Type Mapping

+ +

The following table summarizes the default mapping between the Boost + uuid type and the Oracle database type.

+ + + + + + + + + + + + + + +
Boost TypeOracle TypeDefault NULL Semantics
boost::uuids::uuidRAW(16)NULL
+ +

23.6.5 SQL Server Database Type Mapping

+ +

The following table summarizes the default mapping between the Boost + uuid type and the SQL Server database type.

+ + + + + + + + + + + + + + +
Boost TypeSQL Server TypeDefault NULL Semantics
boost::uuids::uuidUNIQUEIDENTIFIERNULL
+ + + + + +
+

24 Qt Profile

+ +

The ODB profile implementation for Qt is provided by the + libodb-qt library. Both Qt4 and Qt5 as well + as C++98/03 and C++11 are supported.

+ +

The Qt profile consists of multiple sub-profiles + corresponding to the common type groups within Qt. Currently, + only types from the QtCore module are supported. To + enable all the available Qt sub-profiles, pass qt as the + profile name to the --profile ODB compiler option. + Alternatively, you can enable only specific sub-profiles by passing + individual sub-profile names to --profile. The following + sections in this chapter discuss each Qt sub-profile in detail. The + qt example in the odb-examples + package shows how to enable and use the Qt profile.

+ +

Some sub-profiles may throw exceptions to indicate error conditions, + such as the inability to store a specific value in a particular database + system. All such exceptions derive from the + odb::qt::exception class which in turn derives from + the root of the ODB exception hierarchy, class odb::exception + (Section 3.14, "ODB Exceptions"). The + odb::qt::exception class is defined in the + <odb/qt/exception.hxx> header file and has the + same interface as odb::exception. Concrete exceptions + that can be thrown by the Qt sub-profiles are described in the + following sections.

+ +

24.1 Basic Types Library

+ +

The basic sub-profile provides persistence support for basic + types defined by Qt. To enable only this profile, pass + qt/basic to the --profile ODB compiler + option.

+ +

The currently supported basic types are QString, + QByteArray, and QUuid. The manner in + which these types are persisted is database system dependent + and is discussed in the sub-sections that follow. The example + below shows how QString may be used within a + persistent object.

+ + 
+#pragma db object
+class Person
+{
+  ...
+  QString name_;
+};
+
+ +

By default a data member of the QUuid type is mapped to a + database column with NULL enabled and null QUuid + instances are stored as a NULL value. However, you can + change this behavior by declaring the data member NOT NULL + with the not_null pragma (Section + 14.4.6, "null/not_null"). In this + case, or if the data member is an object id, the implementation + will store null QUuid instances as zero UUID values + ({00000000-0000-0000-0000-000000000000}). For example:

+ + 
+#pragma db object
+class object
+{
+  ...
+
+  QUuid x_; // Null values stored as NULL.
+
+  #pragma db not_null
+  QUuid y_; // Null values stored as zero.
+};
+
+ +

24.1.1 MySQL Database Type Mapping

+ +

The following table summarizes the default mapping between the currently + supported basic Qt types and the MySQL database types.

+ + + + + + + + + + + + + + + + + + + + + + + + + + +
Qt TypeMySQL TypeDefault NULL Semantics
QStringTEXT/VARCHAR(255)NULL
QByteArrayBLOBNULL
QUuidBINARY(16)NULL
+ +

Instances of the QString and QByteArray + types are stored as a NULL value if their + isNull() member function returns true.

+ +

Note also that the QString type is mapped + differently depending on whether a member of this type + is an object id or not. If the member is an object id, + then for this member QString is mapped + to the VARCHAR(255) MySQL type. Otherwise, + it is mapped to TEXT.

+ +

The basic sub-profile also provides support + for mapping QString to the CHAR, + NCHAR, and NVARCHAR MySQL types. + However, these alternative mappings have to be explicitly + requested using the db type pragma + (Section 14.4.3, "type"), as shown in + the following example:

+ + 
+#pragma db object
+class Person
+{
+  ...
+
+  #pragma db type("CHAR(2)") not_null
+  QString licenseState_;
+};
+
+ + +

24.1.2 SQLite Database Type Mapping

+ +

The following table summarizes the default mapping between the currently + supported basic Qt types and the SQLite database types.

+ + + + + + + + + + + + + + + + + + + + + + + + + + +
Qt TypeSQLite TypeDefault NULL Semantics
QStringTEXTNULL
QByteArrayBLOBNULL
QUuidBLOBNULL
+ +

Instances of the QString and QByteArray types + are stored as a NULL value if their isNull() + member function returns true.

+ +

24.1.3 PostgreSQL Database Type Mapping

+ +

The following table summarizes the default mapping between the currently + supported basic Qt types and the PostgreSQL database types.

+ + + + + + + + + + + + + + + + + + + + + + + + + + +
Qt TypePostgreSQL TypeDefault NULL Semantics
QStringTEXTNULL
QByteArrayBYTEANULL
QUuidUUIDNULL
+ +

Instances of the QString and QByteArray types + are stored as a NULL value if their isNull() + member function returns true.

+ +

The basic sub-profile also provides support + for mapping QString to the CHAR + and VARCHAR PostgreSQL types. + However, these alternative mappings have to be explicitly + requested using the db type pragma + (Section 14.4.3, "type"), as shown in + the following example:

+ + 
+#pragma db object
+class Person
+{
+  ...
+
+  #pragma db type("CHAR(2)") not_null
+  QString licenseState_;
+};
+
+ +

24.1.4 Oracle Database Type Mapping

+ +

The following table summarizes the default mapping between the currently + supported basic Qt types and the Oracle database types.

+ + + + + + + + + + + + + + + + + + + + + + + + + + +
Qt TypeOracle TypeDefault NULL Semantics
QStringVARCHAR2(512)NULL
QByteArrayBLOBNULL
QUuidRAW(16)NULL
+ +

Instances of the QString and QByteArray types + are stored as a NULL value if their isNull() + member function returns true.

+ +

The basic sub-profile also provides support + for mapping QString to the CHAR, + NCHAR, NVARCHAR, CLOB, and + NCLOB Oracle types, and for mapping QByteArray + to the RAW Oracle type. However, these alternative + mappings have to be explicitly requested using the db type + pragma (Section 14.4.3, "type"), as shown in the + following example:

+ + 
+#pragma db object
+class Person
+{
+  ...
+
+  #pragma db type("CLOB") not_null
+  QString firstName_;
+
+  #pragma db type("RAW(16)") null
+  QByteArray uuid_;
+};
+
+ +

24.1.5 SQL Server Database Type Mapping

+ +

The following table summarizes the default mapping between the currently + supported basic Qt types and the SQL Server database types.

+ + + + + + + + + + + + + + + + + + + + + + + + + + +
Qt TypeSQL Server TypeDefault NULL Semantics
QStringVARCHAR(512)/VARCHAR(256)NULL
QByteArrayVARBINARY(max)NULL
QUuidUNIQUEIDENTIFIERNULL
+ +

Instances of the QString and QByteArray types + are stored as a NULL value if their isNull() + member function returns true.

+ +

Note also that the QString type is mapped + differently depending on whether a member of this type + is an object id or not. If the member is an object id, + then for this member QString is mapped + to the VARCHAR(256) SQL Server type. Otherwise, + it is mapped to VARCHAR(512).

+ +

The basic sub-profile also provides support + for mapping QString to the CHAR, + NCHAR, NVARCHAR, TEXT, and + NTEXT SQL Server types, and for mapping + QByteArray to the BINARY and + IMAGE SQL Server types. However, these alternative + mappings have to be explicitly requested using the db type + pragma (Section 14.4.3, "type"), as shown in the + following example:

+ + 
+#pragma db object
+class Person
+{
+  ...
+
+  #pragma db type("NVARCHAR(256)") not_null
+  QString firstName_;
+
+  #pragma db type("BINARY(16)") null
+  QByteArray uuid_;
+};
+
+ +

24.2 Smart Pointers Library

+ +

The smart-ptr sub-profile provides persistence support the + Qt smart pointers. To enable only this profile, pass + qt/smart-ptr to the --profile ODB compiler + option.

+ +

The currently supported smart pointers are + QSharedPointer and QWeakPointer. + For more information on using smart pointers as pointers to objects + and views, refer to Section 3.3, "Object and View + Pointers" and Chapter 6, "Relationships". For + more information on using smart pointers as pointers to values, refer + to Section 7.3, "Pointers and NULL Value + Semantics". When used as a pointer to a value, only + QSharedPointer is supported. For example:

+ + 
+#pragma db object
+class person
+{
+  ...
+
+  #pragma db null
+  QSharedPointer<QString> middle_name_;
+};
+
+ +

To provide finer grained control over object relationship loading, + the smart-ptr sub-profile also provides the lazy + counterparts for the above pointers: QLazySharedPointer + and QLazyWeakPointer. You will need to include the + <odb/qt/lazy-ptr.hxx> header file to make the lazy + variants available in your application. For a description of the lazy + pointer interface and semantics refer to Section 6.4, + "Lazy Pointers". The following example shows how we can use these + smart pointers to establish a relationship between persistent objects.

+ + 
+class Employee;
+
+#pragma db object
+class Position
+{
+  ...
+
+  #pragma db inverse(position_)
+  QLazyWeakPointer<Employee> employee_;
+};
+
+#pragma db object
+class Employee
+{
+  ...
+
+  #pragma db not_null
+  QSharedPointer<Position> position_;
+};
+
+ +

Besides providing persistence support for the above smart pointers, + the smart-ptr sub-profile also changes the default + pointer (Section 3.3, "Object and View Pointers") + to QSharedPointer. In particular, this means that + database functions that return dynamically allocated objects and views + will return them as QSharedPointer pointers. To override + this behavior, add the --default-pointer option specifying + the alternative pointer type after the --profile option.

+ +

24.3 Containers Library

+ +

The containers sub-profile provides persistence support for + Qt containers. To enable only this profile, pass + qt/containers to the --profile ODB compiler + option.

+ +

The currently supported ordered containers are QVector, + QList, and QLinkedList. Supported map + containers are QMap, QMultiMap, + QHash, and QMultiHash. The supported set + container is QSet. For more information on using + containers with ODB, refer to Chapter 5, "Containers". + The following example shows how the QSet container may + be used within a persistent object.

+ + 
+#pragma db object
+class Person
+{
+  ...
+  QSet<QString> emails_;
+};
+
+ +

The containers sub-profile also provide a change-tracking + equivalent for QList (Section 24.3.1, + "Change-Tracking QList") with support for other Qt + container equivalents planned for future releases. For general information + on change-tracking containers refer to Section 5.4, + "Change-Tracking Containers".

+ +

24.3.1 Change-Tracking QList

+ +

Class template QOdbList, defined in + <odb/qt/list.hxx>, is a change-tracking + equivalent for QList. It + is implemented in terms of QList and is + implicit-convertible to and implicit-constructible from + const QList&. In particular, this + means that we can use QOdbList instance + anywhere const QList& is + expected. In addition, QOdbList constant + iterator (const_iterator) is the same type as + that of QList.

+ +

QOdbList incurs 2-bit per element overhead + in order to store the change state. It cannot + be stored unordered in the database (Section + 14.4.19 "unordered") but can be used as an inverse + side of a relationship (6.2 "Bidirectional + Relationships"). In this case, no change tracking is performed + since no state for such a container is stored in the database.

+ +

The number of database operations required to update the state + of QOdbList corresponds well to the complexity + of QList functions, except for + prepend()/push_front(). In particular, adding + or removing an element from the back of the list (for example, + with append()/push_back() and + removeLast()/pop_back()), + requires only a single database statement execution. In contrast, + inserting or erasing an element at the beginning or in the middle + of the list will require a database statement for every element that + follows it.

+ +

QOdbList replicates most of the QList + interface as defined in both Qt4 and Qt5 and includes support for + C++11. However, functions and operators that provide direct write + access to the elements had to be altered or disabled in order to + support change tracking. Additional functions used to interface with + QList and to control the change tracking state + were also added. The following listing summarizes the differences + between the QOdbList and QList + interfaces. Any QList function or operator + not mentioned in this listing has exactly the same signature + and semantics in QOdbList. Functions and + operators that were disabled are shown as commented out and + are followed by functions/operators that replace them.

+ + 
+template <typename T>
+class QOdbList
+{
+  ...
+
+  // Element access.
+  //
+
+  //T& operator[] (int);
+    T& modify (int);
+
+  //T& first();
+    T& modifyFirst();
+
+  //T& last();
+    T& modifyLast();
+
+  //T& front();
+    T& modify_front();
+
+  //T& back();
+    T& modify_back();
+
+  // Iterators.
+  //
+  typedef typename QList<T>::const_iterator const_iterator;
+
+  class iterator
+  {
+    ...
+
+    // Element Access.
+    //
+
+    //reference       operator* () const;
+      const_reference operator* () const;
+      reference       modify () const;
+
+    //pointer       operator-> () const;
+      const_pointer operator-> () const;
+
+    //reference       operator[] (difference_type);
+      const_reference operator[] (difference_type);
+      reference       modify (difference_type) const;
+
+    // Interfacing with QList::iterator.
+    //
+    typename QList<T>::iterator base () const;
+  };
+
+  // Return QList iterators. The begin() functions mark all
+  // the elements as modified.
+  //
+  typename QList<T>::iterator mbegin ();
+  typename QList<T>::iterator modifyBegin ();
+  typename QList<T>::iterator mend ();
+  typename QList<T>::iterator modifyEnd ();
+
+  // Interfacing with QList.
+  //
+  QOdbList (const QList<T>&);
+  QOdbList (QList<T>&&); // C++11 only.
+
+  QOdbList& operator= (const QList<T>&);
+  QOdbList& operator= (QList<T>&&);
+
+  operator const QList<T>& () const;
+  QList<T>& base ();
+  const QList<T>& base () const;
+
+  // Change tracking.
+  //
+  bool _tracking () const;
+  void _start () const;
+  void _stop () const;
+  void _arm (transaction&) const;
+};
+
+ +

The following example highlights some of the differences between + the two interfaces. QList versions are commented + out.

+ + 
+#include <QtCore/QList>
+#include <odb/qt/list.hxx>
+
+void f (const QList<int>&);
+
+QOdbList<int> l ({1, 2, 3});
+
+f (l); // Ok, implicit conversion.
+
+if (l[1] == 2) // Ok, const access.
+  //l[1]++;
+  l.modify (1)++;
+
+//l.last () = 4;
+l.modifyLast () = 4;
+
+for (auto i (l.begin ()); i != l.end (); ++i)
+{
+  if (*i != 0) // Ok, const access.
+    //*i += 10;
+    i.modify () += 10;
+}
+
+qSort (l.modifyBegin (), l.modifyEnd ());
+
+ +

Note also the subtle difference between copy/move construction + and copy/move assignment of QOdbList instances. + While copy/move constructor will copy/move both the elements as + well as their change state, in contrast, assignment is tracked + as any other change to the vector content.

+ +

The QListIterator and QMutableListIterator + equivalents are also provided. These are QOdbListIterator + and QMutableOdbListIterator and are defined in + <odb/qt/list-iterator.hxx> and + <odb/qt/mutable-list-iterator.hxx>, respectively.

+ +

QOdbListIterator has exactly the same interface and + semantics as QListIterator. In fact, we can use + QListIterator to iterate over a QOdbList + instance.

+ +

QMutableOdbListIterator also has exactly the same + interface as QMutableListIterator. Note, however, + that any element that such an iterator passes over with the + call to next() is marked as modified.

+ +

24.4 Date Time Library

+ +

The date-time sub-profile provides persistence support for + the Qt date-time types. To enable only this profile, pass + qt/date-time to the --profile ODB compiler + option.

+ +

The currently supported date-time types are QDate, + QTime, and QDateTime. The manner in which + these types are persisted is database system dependent and is + discussed in the sub-sections that follow. The example below shows how + QDate may be used within a persistent object.

+ + 
+#pragma db object
+class Person
+{
+  ...
+  QDate dateOfBirth_;
+};
+
+ +

The single concrete exception that can be thrown by the + date-time sub-profile implementation is presented below.

+ + + 
+namespace odb
+{
+  namespace qt
+  {
+    namespace date_time
+    {
+      struct value_out_of_range: odb::qt::exception
+      {
+        virtual const char*
+        what () const throw ();
+      };
+    }
+  }
+}
+
+ +

You will need to include the + <odb/qt/date-time/exceptions.hxx> header file to + make this exception available in your application.

+ +

The value_out_of_range exception is thrown if an attempt + is made to store a date-time value that is out of the target database + range. The specific conditions under which it is thrown is database + system dependent and is discussed in more detail in the + following sub-sections.

+ +

24.4.1 MySQL Database Type Mapping

+ +

The following table summarizes the default mapping between the currently + supported Qt date-time types and the MySQL database types.

+ + + + + + + + + + + + + + + + + + + + + + + + + + +
Qt Date Time TypeMySQL TypeDefault NULL Semantics
QDateDATENULL
QTimeTIMENULL
QDateTimeDATETIMENULL
+ +

Instances of the QDate, QTime, and + QDateTime types are stored as a NULL value + if their isNull() member function returns true.

+ +

The date-time sub-profile implementation also provides + support for mapping QDateTime to the TIMESTAMP + MySQL type. However, this mapping has to be explicitly requested using + the db type pragma + (Section 14.4.3, "type"), as shown in + the following example:

+ + 
+#pragma db object
+class Person
+{
+  ...
+  #pragma db type("TIMESTAMP") not_null
+  QDateTime updated_;
+};
+
+ +

Starting with MySQL version 5.6.4 it is possible to store fractional + seconds up to microsecond precision in TIME, + DATETIME, and TIMESTAMP columns. However, + to enable sub-second precision, the corresponding type with the + desired precision has to be specified explicitly, as shown in the + following example:

+ + 
+#pragma db object
+class Person
+{
+  ...
+  #pragma db type("DATETIME(3)") // Millisecond precision.
+  QDateTime updated_;
+};
+
+ +

Alternatively, you can enable sub-second precision on the per-type + basis, for example:

+ + 
+#pragma db value(QDateTime) type("DATETIME(3)")
+
+#pragma db object
+class Person
+{
+  ...
+  QDateTime created_; // Millisecond precision.
+  QDateTime updated_; // Millisecond precision.
+};
+
+ +

Some valid Qt date-time values cannot be stored in a MySQL database. An + attempt to persist a Qt date-time value that is out of the MySQL type + range will result in the out_of_range exception. Refer to + the MySQL documentation for more information on the MySQL data type + ranges.

+ +

24.4.2 SQLite Database Type Mapping

+ +

The following table summarizes the default mapping between the currently + supported Qt date-time types and the SQLite database types.

+ + + + + + + + + + + + + + + + + + + + + + + + + + +
Qt Date Time TypeSQLite TypeDefault NULL Semantics
QDateTEXTNULL
QTimeTEXTNULL
QDateTimeTEXTNULL
+ +

Instances of the QDate, QTime, and + QDateTime types are stored as a NULL value + if their isNull() member function returns true.

+ +

The date-time sub-profile implementation also provides + support for mapping QDate and QDateTime to the + SQLite INTEGER type, with the integer value representing the + UNIX time. Similarly, an alternative mapping for QTime to + the INTEGER type represents a clock time as the number of + seconds since midnight. These mappings have to be explicitly requested + using the db type pragma + (Section 14.4.3, "type"), as shown + in the following example:

+ + 
+#pragma db object
+class Person
+{
+  ...
+  #pragma db type("INTEGER")
+  QDate born_;
+};
+
+ +

Some valid Qt date-time values cannot be stored in an SQLite database. + An attempt to persist any Qt date-time value representing a negative UNIX + time (any point in time prior to the 1970-01-01 00:00:00 UNIX time + epoch) as an SQLite INTEGER will result in the + out_of_range exception.

+ +

24.4.3 PostgreSQL Database Type Mapping

+ +

The following table summarizes the default mapping between the currently + supported Qt date-time types and the PostgreSQL database types.

+ + + + + + + + + + + + + + + + + + + + + + + + + + +
Qt Date Time TypePostgreSQL TypeDefault NULL Semantics
QDateDATENULL
QTimeTIMENULL
QDateTimeTIMESTAMPNULL
+ +

Instances of the QDate, QTime, and + QDateTime types are stored as a NULL value + if their isNull() member function returns true.

+ +

24.4.4 Oracle Database Type Mapping

+ +

The following table summarizes the default mapping between the currently + supported Qt date-time types and the Oracle database types.

+ + + + + + + + + + + + + + + + + + + + + + + + + + +
Qt Date Time TypeOracle TypeDefault NULL Semantics
QDateDATENULL
QTimeINTERVAL DAY(0) TO SECOND(3)NULL
QDateTimeTIMESTAMP(3)NULL
+ +

Instances of the QDate, QTime, and + QDateTime types are stored as a NULL value + if their isNull() member function returns true.

+ +

The date-time sub-profile implementation also provides + support for mapping QDateTime to the + DATE Oracle type with fractional seconds that may be + stored in a QDateTime instance being ignored. This + alternative mapping has to be explicitly requested using the + db type pragma (Section 14.4.3, + "type"), as shown in the following example:

+ + 
+#pragma db object
+class person
+{
+  ...
+  #pragma db type("DATE")
+  QDateTime updated_;
+};
+
+ +

24.4.5 SQL Server Database Type Mapping

+ +

The following table summarizes the default mapping between the currently + supported Qt date-time types and the SQL Server database types.

+ + + + + + + + + + + + + + + + + + + + + + + + + + +
Qt Date Time TypeSQL Server TypeDefault NULL Semantics
QDateDATENULL
QTimeTIME(3)NULL
QDateTimeDATETIME2(3)NULL
+ +

Instances of the QDate, QTime, and + QDateTime types are stored as a NULL value + if their isNull() member function returns true.

+ +

Note that the DATE, TIME, and + DATETIME2 types are only available in SQL Server 2008 and + later. SQL Server 2005 only supports the DATETIME and + SMALLDATETIME date-time types. The new types are + also unavailable when connecting to an SQL Server 2008 or + later with the SQL Server 2005 Native Client ODBC driver.

+ +

The date-time sub-profile implementation provides + support for mapping QDateTime to the DATETIME + and SMALLDATETIME types, however, this mapping has to + be explicitly requested using the db type pragma + (Section 14.4.3, "type"), as + shown in the following example:

+ + 
+#pragma db object
+class person
+{
+  ...
+  #pragma db type("DATETIME")
+  QDateTime updated_;
+};
+
+ +
+
+ + + diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/doc/odb-arch.png b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/doc/odb-arch.png new file mode 100755 index 0000000..511b198 Binary files /dev/null and b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/doc/odb-arch.png differ diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/doc/odb-flow.png b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/doc/odb-flow.png new file mode 100755 index 0000000..0063317 Binary files /dev/null and b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/doc/odb-flow.png differ diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/doc/odb-manual.pdf b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/doc/odb-manual.pdf new file mode 100755 index 0000000..b883f59 Binary files /dev/null and b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/doc/odb-manual.pdf differ diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/doc/odb-manual.ps b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/doc/odb-manual.ps new file mode 100755 index 0000000..75f085b --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/doc/odb-manual.ps @@ -0,0 +1,69560 @@ +%!PS +%%Title: C++ Object Persistence with ODB +%%Creator: html2ps version 1.0 beta7 +%%EndComments +save +2000 dict begin +/d {bind def} bind def +/D {def} d +/t true D +/f false D +/FL [/Times-Roman +/Times-Italic +/Times-Bold +/Times-BoldItalic +/Courier +/Courier-Oblique +/Courier-Bold +/Courier-BoldOblique +/Helvetica +/Helvetica-Oblique +/Helvetica-Bold +/Helvetica-BoldOblique] D +/WF t D +/WI 0 D +/F 1 D +/IW 454 F div D +/IL 672 F div D +/PS 842 D +/EF [0 1 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 2 2] D +/EZ [12 10 19 17 15 13 12 11 12 12 12 12 12 12 12 12 12 12 12 12 12 12 8 8] D +/Ey [0 0 2 2 2 2 2 2 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0] D +/EG [-1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1] D +/Tm [1 1 0.8 0.8 0.8 0.8 0.8 0.8 0 0 0 0 0 0 0.5 1 1 1 1 0 0 1.3 0 0] D +/Bm [1 1 0.5 0.5 0.5 0.5 0.5 0.5 0 0 0 0 0 0 0.5 1 1 1 1 0 0 1 0 0] D +/Lm [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 2 2 0 0 2 0 0 0] D +/Rm [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0] D +/EU [-1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 0 0] D +/NO f D +/YY [[{()}{ h }][{ h }{()}][{()}{()}]] D +/ZZ [[{ (Revision ) ME 0 get join(, February 2015)join }{ Pn }][{ Pn }{ (Revision ) ME 0 get join(, February 2015)join }][{ Ti }{ Ti }]] D +/Ts EZ 0 get D +/TU f D +/Xp t D +/AU f D +/SN 0 D +/Cf t D +/Tp t D +/Fe f D +/TI 2 Ts mul D +/Fm 14 D +/xL 71 D +/xR 71 D +/yL 757 D +/yR 757 D +/Wl 454 F div D +/Wr 454 F div D +/hL 672 F div D +/hR 672 F div D +/FE {newpath Fm neg Fm M CP BB IW Fm add Fm L IW Fm add IL Fm add neg L CP BB + Fm neg IL Fm add neg L closepath} D +/LA {PM 0 eq{/IW Wl D /IL hL D}{/IW Wr D /IL hR D}ie /W IW D /LL W D /LS W D + TU PM 0 eq and{IW 56 F div add SA{Sf div}if 0 translate} + {PM 0 eq{xL yL}{xR yR}ie translate F SA{Sf mul}if dup scale + CS CF FS Cf{CA CL get VC}if /Bb f D}ie 0 0 M + TF not Tc or {Cf{gsave SA{1 Sf div dup scale}if Cb VC FE fill grestore}if}if}D +/Pi 0 Ts mul D +/SG [0.8 1 1] D +/Ab 15 D +/J 0 D +/Tc t D +/NH 6 D +/Nf f D +/Pa f D +/LH 1.2 D +/XR f D +/Xr {/pN E D ( [p ) WB pN WB (] )WB} D +/Db [16#FF 16#FF 16#FF] D +/Dt [16#00 16#00 16#00] D +/eA f D +/Fi f D +/bT f D +/Lc t D +/Dl [16#00 16#00 16#00] D +/LX f D +/Br 0.25 D +/IA ([IMAGE]) D +/DS {/PF f D()WB NL NP()pop RC ZF} D +/Gb f D +/Mb t D +/Hc [16#00 16#00 16#00] D +/Bl 3 D +/MI -15.6 D +/DX (DRAFT) D +/Di 0 D +/Tt 113.385826771654 D +/Th { ( +) 2 Al()BR ( + ) 0 1 -1 H()4 FZ (C++ Object Persistence with ODB) ES()EH ( + ) 0 1 -1 H ( ) EH ( + ) 0 1 -1 H ( ) EH ( + ) 0 1 -1 H ( ) EH ( + ) 0 1 -1 H ( ) EH ( + ) 0 1 -1 H ( ) EH ( + ) 0 1 -1 H ( ) EH ( + ) 0 1 -1 H ( ) EH ( + ) 0 1 -1 H ( ) EH ( +) Ea()BR ( + ) 0 P (Copyright © 2009-2015 Code Synthesis Tools CC) EP ( + + ) 0 P (Permission is granted to copy, distribute and/or modify this + document under the terms of the + ) R0 2 A (GNU Free + Documentation License, version 1.3) EA (; with no Invariant Sections, + no Front-Cover Texts and no Back-Cover Texts. + ) EP ( + + ) 0 P (Revision ) ME 0 get join(, February 2015)join EP ( + + ) 0 P (This revision of the manual describes ODB ) ME 1 get join( and is available + in the following formats: + )join R1 2 A (XHTML) EA (, + ) R2 2 A (PDF) EA (, and + ) R3 2 A (PostScript) EA (.) EP()} D +/tH {()0 1 -1 H (Table of Contents) EH()} D +/FD 2 D +/Dy 2 D +/cD [16#F0 16#F0 16#F0] D +/FW 0.6 D +/FU [16#00 16#00 16#00] D +/ET {/RM f D /A0 3 D /PN SN D /OU t D /Ou t D /W IW D /LL W D D1 + Ms not TP and{Ip}if /TF f D} D + +%-- End of variable part -- +/MySymbol 10 dict dup begin + /FontType 3 D /FontMatrix [.001 0 0 .001 0 0 ] D /FontBBox [25 -10 600 600] D + /Encoding 256 array D 0 1 255{Encoding exch /.notdef put}for + Encoding (e) 0 get /euro put + /Metrics 2 dict D Metrics begin + /.notdef 0 D + /euro 651 D + end + /BBox 2 dict D BBox begin + /.notdef [0 0 0 0] D + /euro [25 -10 600 600] D + end + /CharacterDefs 2 dict D CharacterDefs begin + /.notdef {} D + /euro{newpath 114 600 moveto 631 600 lineto 464 200 lineto 573 200 lineto + 573 0 lineto -94 0 lineto 31 300 lineto -10 300 lineto closepath clip + 50 setlinewidth newpath 656 300 moveto 381 300 275 0 360 arc stroke + -19 350 moveto 600 0 rlineto -19 250 moveto 600 0 rlineto stroke}d + end + /BuildChar{0 begin + /char E D /fontdict E D /charname fontdict /Encoding get char get D + fontdict begin + Metrics charname get 0 BBox charname get aload pop setcachedevice + CharacterDefs charname get exec + end + end}D + /BuildChar load 0 3 dict put /UniqueID 1 D +end +definefont pop + +/Cd {aload length 2 idiv dup dict begin {D} repeat currentdict end} D +/EX {EC cvx exec} D +/DU {} d +/BB {pop pop}d +/ie {ifelse} d +/E {exch} d +/M {moveto} d +/R {rmoveto} d +/L {lineto} d +/RL {rlineto} d +/CP {currentpoint} d +/SW {stringwidth} d +/GI {getinterval} d +/PI {putinterval} d +/Sg {setgray} d +/LW {setlinewidth} d +/S {dup () ne OU and{0 Co R AT 3 eq LB and HF not and A1 0 ne A2 0 ne or and + {A2 0 32 A1 0 6 -1 roll awidthshow}{show}ie 0 Co neg R}{pop}ie + OU PH 3 eq or{/Ms t D}if} D +/U {OU{gsave CP currentfont /FontInfo get /UnderlinePosition get + 0 E currentfont /FontMatrix get dtransform E pop add newpath M dup SW pop + CJ 0 RL stroke grestore}if} D +/B {OU Br 0 gt and{CP Ts neg Ts .33 mul R gsave 0 Sg + CP newpath Ts Br mul 0 360 arc closepath UI 2 mod 0 eq{stroke}{fill}ie + grestore M CP E Ts Br 1 add mul sub E BB /Ms t D}if}D +/NP {Ms TP not or PA and OU and{TP{OR}if f1{mF k2 /mF E D /YC 0 D}if + TP TU not PM 0 eq or and{showpage}if DU Ip TE not{LA}if 0.6 LW + /CI 0 D /TP t D /Hs f D /hl 6 D /Hv 6 D /HI hi D /Ms f D}if Bs XO BO M} D +/Np {LE sub CP E pop gt PL 0 eq and{NP}if}D +/Ip {/PN PN 1 add D /Pn RM{1}{4}ie PN Ns D /PM PN SN sub 2 mod D} D +/GP {E dup 3 -1 roll get PN 1 add 2 mod get dup type /integertype eq + {get 0 get}{E pop}ie}d +/Fc {dup 2 GP exec SW pop /S1 E D dup 1 GP exec SW pop /S2 E D 0 GP exec SW + pop /S3 E D S1 0 gt{S2 2 mul S1 add S3 2 mul S1 add 2 copy lt{E}if pop}{0}ie + S2 S3 add 2 copy lt{E}if pop IW .9 mul div dup 1 gt{1 E div}{pop 1}ie}D +/OR {Df{Sd}if tp not{gsave SA{1 Sf div dup scale}if Fe{Cf{FU VC}if FW LW + 1 setlinejoin FE stroke}if /YO {60 F div dup 40 gt{pop 40}if}D /cs CS D + /cf CF D /CF 0 D /pf PF D /PF f D /Fn FN D /At AT D /AT 0 D /FN EF Hf 1 add + get D Fz Fs FS ZZ Fc Fz mul Fs FS EU Hf 1 add get dup type /arraytype eq + Cf and{VC}{pop 0 Sg}ie IW IL neg YO sub M ZZ 1 GP exec dup SW pop neg 0 R Sh + 0 IL neg YO sub M ZZ 0 GP exec Sh ZZ 2 GP exec dup SW pop IW E sub 2 div + IL neg YO sub M Sh Fz Fs FS NO{/AW IW Pn SW pop sub D AW 2 div IL neg YO sub + S1 0 gt S2 AW .45 mul gt or S3 AW .45 mul gt or{Fz 2 mul sub}if M Pn Sh}if + EU Hf get dup type /arraytype eq Cf and{VC}{pop 0 Sg}ie YY Fc /FN EF Hf get D + Hz mul HS FS IW YO M YY 1 GP exec dup SW pop neg 0 R Sh 0 YO M YY 0 GP exec Sh + YY 2 GP exec dup SW pop IW E sub 2 div YO M Sh /FN Fn D /AT At D t Pb XO SZ + SL get neg R /PF pf D grestore /CF 0 D cs cf FS}if}D +/Sh {dup () ne{CP Hz 4 div sub BB show CP CS add BB}{pop}ie}D +/Pb {/OU E D /Ou OU D /PB t D 0 0 M Ba{/Sa save D /BP t D /Fl t D RC /PL 0 D + /PH 0 D /W IW D /LE IL .7 mul D /EO 0 D SI ZF /YA 0 D /BO 0 D /C1 () D + BA 0 Ts neg R Bb{Xl Yl Xh Yh}if Bb CP Sa restore M + {/Yh E D /Xh E D /Yl E D /Xl E D}if /Fl t D}if + BL /OU t D /HM f D /Ou t D /PB f D} D +/Bs {/BP Ba not D}D +/reencodeISO { + dup dup findfont dup length dict begin{1 index /FID ne{D}{pop pop}ie}forall + /Encoding ISOLatin1Encoding D currentdict end definefont} D +/ISOLatin1Encoding [ +/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef +/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef +/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef +/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef +/space/exclam/quotedbl/numbersign/dollar/percent/ampersand/quoteright +/parenleft/parenright/asterisk/plus/comma/hyphen/period/slash +/zero/one/two/three/four/five/six/seven/eight/nine/colon/semicolon +/less/equal/greater/question/at/A/B/C/D/E/F/G/H/I/J/K/L/M/N +/O/P/Q/R/S/T/U/V/W/X/Y/Z/bracketleft/backslash/bracketright +/asciicircum/underscore/quoteleft/a/b/c/d/e/f/g/h/i/j/k/l/m +/n/o/p/q/r/s/t/u/v/w/x/y/z/braceleft/bar/braceright/asciitilde +/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef +/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef +/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef +/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef +/.notdef/space/exclamdown/cent/sterling/currency/yen/brokenbar +/section/dieresis/copyright/ordfeminine/guillemotleft/logicalnot +/hyphen/registered/macron/degree/plusminus/twosuperior/threesuperior +/acute/mu/paragraph/periodcentered/cedilla/onesuperior/ordmasculine +/guillemotright/onequarter/onehalf/threequarters/questiondown +/Agrave/Aacute/Acircumflex/Atilde/Adieresis/Aring/AE/Ccedilla +/Egrave/Eacute/Ecircumflex/Edieresis/Igrave/Iacute/Icircumflex +/Idieresis/Eth/Ntilde/Ograve/Oacute/Ocircumflex/Otilde/Odieresis +/multiply/Oslash/Ugrave/Uacute/Ucircumflex/Udieresis/Yacute +/Thorn/germandbls/agrave/aacute/acircumflex/atilde/adieresis +/aring/ae/ccedilla/egrave/eacute/ecircumflex/edieresis/igrave +/iacute/icircumflex/idieresis/eth/ntilde/ograve/oacute/ocircumflex +/otilde/odieresis/divide/oslash/ugrave/uacute/ucircumflex/udieresis +/yacute/thorn/ydieresis +] D +[128/backslash 129/parenleft 130/parenright 141/circumflex 142/tilde +143/perthousand 144/dagger 145/daggerdbl 146/Ydieresis 147/scaron 148/Scaron +149/oe 150/OE 151/guilsinglleft 152/guilsinglright 153/quotesinglbase +154/quotedblbase 155/quotedblleft 156/quotedblright 157/endash 158/emdash +159/trademark] +aload length 2 idiv 1 1 3 -1 roll{pop ISOLatin1Encoding 3 1 roll put}for +/colorimage where{pop}{ + /colorimage { + pop pop /Pr E D {/Cv Pr D /Gr Cv length 3 idiv string D 0 1 Gr length 1 sub + {Gr E dup /i E 3 mul D Cv i get 0.299 mul Cv i 1 add get 0.587 mul add + Cv i 2 add get 0.114 mul add cvi put}for Gr} image} D +}ie +/pdfmark where{pop}{userdict /pdfmark /cleartomark load put}ie +WF{FL{reencodeISO D}forall}{4 1 FL length 1 sub{FL E get reencodeISO D}for}ie +/Symbol dup dup findfont dup length dict begin + {1 index /FID ne{D}{pop pop}ie}forall /Encoding [Encoding aload pop] + dup 128 /therefore put D currentdict end definefont D + +/SF {/CS E D SZ SL CS put FO SL FN put /YI CS LH neg mul D dup ST cvs ( ) join + CS ST cvs join C1 E join ( NF ) join /C1 E D CS NF /Wf WF FN 0 gt or D + /BW Wf{( ) SW pop}{0}ie D}D +/NF {/cS E D /cF E D cF 0 ge{FL cF get}{cF -1 eq{/Symbol}{/MySymbol}ie}ie + findfont cS scalefont setfont} D +/FS {CF or /CF E D FR SL CF put CF CF 0 ge{FN 4 mul add}if E SF} D +/PC {SH /BP f D fin not GL not and{NL}if /HM t D /LL LS D} D +/BS {/TX E D Wf{/fin f D /CW 0 D /LK 0 D /SC 0 D + /RT TX D {RT ( ) search{/NW E D pop /RT E D /WH NW SW pop D CW WH add LL gt + {TX SC LK SC sub 1 sub NN GI GL{SH cF cS OC + 2 copy cS ne E cF ne or{NF}{pop pop}ie}{PC /CW WH BW add D}ie + /SC LK D} + {GL{JC}if + /CW CW WH add BW add D /HM t D}ie /GL f D /Ph f D + /LK LK NW length 1 add add D}{pop exit}ie}loop + /fin t D TX SC LK SC sub GI SH RT () ne{GL not{CC}if}if + /LC TX length D /WH RT SW pop D CW WH add Hy{HC SW pop add}if LL gt + {RT GL{SH cF cS OC 2 copy cS ne E cF ne or{NF}{pop pop}ie + Hy{/Ph t D}if /LL LS D}{NL /LL LS D SH}ie} + {RT PC Hy{CC}if /Ph Ph Hy or D}ie RT () ne{/GL t D /HM t D}if} + {TX SW pop LL le{TX SH}{/NW () D 0 2 TX length 1 sub + {/CW E D TX 0 CW GI dup SW pop LL gt{pop NW SH /HM t D NL/LL W XO sub MR sub D + /CW CW 2 sub NN D /TX TX CW TX length CW sub GI D TX BS exit} + {/NW E D}ie}for}ie}ie /HM t D}D +/CC {C0 length 0 gt{JC}if /C0 [C1 L1 YA YB Mf NS NB TB AF Bw] D + /C1 () D /L0 L1 D /YA 0 D /YB 0 D /Mf 0 D /NS 0 D /NB 0 D}D +/JC {C0 aload length 0 gt{pop pop pop NB add /NB E D NS add /NS E D + dup Mf gt{/Mf E D}{pop}ie dup YB gt{/YB E D}{pop}ie + dup YA gt{/YA E D}{pop}ie pop C1 join /C1 E D /C0 [] D}if}D +/OC {C0 length 0 gt{C1 L1 L0 sub YA YB Mf NS NB TB AF Bw GL C0 aload pop + /Bw E D /AF E D /TB E D /NB E D /NS E D /Mf E D /YB E D /YA E D /C0 [] D + /L1 E D /C1 E D Ph{HC SH}if NL /GL E D /Bw E D /AF E D /TB E D /NB E D /NS E D + /Mf E D /YB E D /YA E D /L1 E D /LL W L1 sub XO sub MR sub WH sub D /CW 0 D + C1 E join /C1 E D}if}D +/BT {/LB t D dup length string copy RS dup dup () ne E ( ) ne and + {/CI 0 D /LS LL D /LL W L1 sub XO sub MR sub D BS} + {dup ( ) eq{/GL f D}if dup () eq L1 0 eq or{pop}{SH /BP f D /Ph f D}ie}ie + /LB f D} D +/BL {CP E pop XO E M} D +/NL {JC /GL f D /SK W XO sub MR sub L1 sub TB{Bw add}if D + /YA LF{Mf HM Fl not and PF or{LH mul}if}{0 /LF t D}ie YA 2 copy lt{E}if pop D + C1 () ne{/FB YB Mf SA{Sf mul}if 4 div 2 copy lt{E}if pop D}if Fl{/Ya YA D}if + CP E pop YA sub YB sub LE neg lt Fl not and PB not and{NP}if NT TL BL + OU PF not and PB or{/RE L1 TB{Bw sub}if + W XO sub MR sub div YA YB add LE BO add div 2 copy lt{E}if pop D + RE 1 gt{BL 1 RE div dup scale}if}if + AT 2 le{SK AT mul 2 div YA neg R}if + AT 3 eq{0 YA neg R TB{/NB NB 1 sub D /NS NS 1 sub D}if /NB NB 1 sub NN D + /A3 NS 6 mul NB add D NS NB add 0 eq + {/A1 0 D /A2 0 D} + {NS 0 eq{/A1 SK NB div dup J gt{pop 0}if D /A2 0 D}{J A3 mul SK lt + {/A1 J D /A2 SK J NB mul sub NS div dup Ab gt{/A1 0 D pop 0}if D} + {/A1 SK A3 div D /A2 A1 6 mul D}ie}ie}ie /A1 A1 NN D /A2 A2 NN D}if + AT 4 eq{0 YA neg R PH 2 le{PD 0 lt{/PD L1 D}if PD M1 gt{/M1 PD D}if + L1 PD sub M2 gt{/M2 L1 PD sub D}if}{DV ID 1 sub get 0 ge{Lo 0 R}if}ie}if + F0 cF ne Cs cS ne or{F0 Cs NF}if + /ms Ms D /Ms f D CP FB sub + C1 cvx exec XO EO sub L1 add TB{BW sub}if dup LM gt{/LM E D}{pop}ie + PH 0 eq PH 4 eq or Ms and{HF not{/PO t D /AH t D}if + BB CP YA add E AT 3 eq LB and{A1 sub}if TB{BW sub}if E BB} + {pop pop}ie Ms HM PH 3 eq and or{/BP f D /Fl f D}if + /Lo 0 D /L1 0 D /F0 cF D /Cs cS D BP not{0 YB NN neg R}if + OU f1 and mF not and{k2 /f1 f D}if + OU PF not and PB or{RE 1 gt{RE dup scale}if}if /Ms ms Ms or D + /C1 AF{(Cp )}{()}ie D /YA 0 D /YB 0 D BL + AT 4 eq LB not and PH 3 ge and + {ID DV length lt{DV ID get dup 0 ge{DO E sub /Lo E D /L1 Lo D}{pop}ie + /ID ID 1 add D}if}if /T t D CD{/LN LN 1 add D PD}if + /PD -1 D /NS 0 D /NB 0 D /TB f D /Ph f D /Mf 0 D /HM f D} D +/RS {/TM E D /CN 0 D TM{10 eq{TM CN ( ) PI}if /CN CN 1 add D}forall + /CN 0 D /BK HM EN and{0}{1}ie D TM + {dup 32 ne{TM CN 3 2 roll put /CN CN 1 add D /BK 0 D} + {pop BK 0 eq{TM CN 32 put /CN CN 1 add D}if /BK 1 D}ie}forall + TM 0 CN GI dup dup () ne E ( ) ne and + {dup CN 1 sub get 32 eq{/EN f D}{/EN t D}ie}if} D +/join {2 copy length E length add string dup 4 2 roll 2 index 0 3 index + PI E length E PI}d +/WR {(\n) search{dup () ne BP not or + {Li 4 le CP E pop YI Li mul add LE add 0 lt and PL 0 eq and{NP}if + SH NL pop /Li Li 1 sub D WR}{pop pop WR}ie}{SH}ie /CI 0 D /BP f D} D +/SH {dup dup () ne E ( ) ne and PF or CS Mf gt and{/Mf CS D}if + T not Wf and{( ) E join /T t D}if dup BP{/MF CS D}if + AT 3 eq{2 copy length dup 0 gt{/NB E NB add D + {( ) search{/NS NS 1 add D pop pop}{pop exit}ie}loop}{pop pop}ie}if + CD PD 0 lt and{dup DC search{SW pop /PD E L1 add D pop pop}{pop}ie}if + 0 Np dup SW pop L1 add /L1 E D dup () ne + {C1 (\() join E join (\)) join AU AF and UF or Wf and{( U ) join}if + sF{( s ) join}if ( S ) join + /C1 E D dup length 1 sub get 32 eq /TB E D /Bw BW D}{pop pop}ie} D +/BG {AI LG BC add add 0 eq} D +/ON {OU{Ty AR AI NN get dup 1 add Ln Ns Ty 2 mod 0 eq{(. )}{(\) )}ie join + dup SW pop neg 0 R CP E 0 lt{0 E M}{pop}ie CP BB show /Ms t D}if} D +/Ln {AR AI 3 -1 roll put}D +/SP {dup CI lt BP not and{dup CI sub 0 E R /CI E D}{pop}ie} D +/BN {PF{WR /HM f D}{BT NL}ie} D +/NN {dup 0 lt{pop 0}if} D +/h {(h) HI ST cvs join cvx exec dup 1 get E Nf{0 get E join}{pop}ie} D +/H {/fn FN D /Hi E 1 add D 1 sub /HL E D /H2 HL 2 add D /GS EZ H2 get D + E Tm H2 get GS mul BE dup 0 gt{1 sub}{pop EG H2 get dup 0 lt{pop AT}if}ie NA + WW Np /SL SL 1 add D /FN EF H2 get D GS Ey H2 get FS + EU H2 get Sc Hs not HL Hl lt and Hs HL hl lt and or Hi 0 eq or + {/HI Hi D /Hs t D /hl HL D /Hv HL D}if HL Hl lt{/hi Hi D}if + Nf HI 0 gt and{(h) Hi ST cvs join cvx exec 0 get WB}if + /HF t D /AH f D /PO f D} D +/EH {Bm H2 get GS mul BE OA /SL SL 1 sub NN D /CF 0 D /FN fn D + SZ SL get FR SL get FS /HF f D /GS Ts D ()Ec} D +/P {E PF{WR}{PO{EP}{BN}ie Ts 4 mul Np AE not{Tm 0 get Ts mul neg SP}if + dup 0 ge AH and{Pi Pd}if}ie 1 sub dup 0 lt{pop AV AL get}if /AT E D /PO t D} D +/EP {PF{WR}{BN Ts 4 mul Np}ie AE not{Bm 0 get Ts mul neg SP}if + /AT AV AL get D /PO f D} D +/BE {E PO{EP}{BN}ie Ts 4 mul Np neg SP} D +/HR {/Aw W EO sub D /RW E dup 0 gt{Aw mul}{neg}ie dup Aw gt{pop Aw}if D /RZ E D + E BN Ts neg SP 1 sub 2 div Aw RW sub mul EO add CP E pop M PF{0 Ps neg R}if + 0 Np OU{gsave RZ LW Cf{Hc VC}{0 Sg}ie CP BB RW 0 RL CP BB stroke grestore}if + /CI 0 D /BP f D PF not{Ts neg SP}if /Ms t D} D +/AD {I NL EG 14 get dup 0 lt{pop AT}if NA /AE t D Tm 14 get Ts mul neg SP + Cf{EU 14 get dup -1 eq{pop CA CL get}if Sc}if} D +/DA {BN ()ES OA /AE f D ()Ec Bm 14 get Ts mul neg SP} D +/PR {/MW E D /Li E D Tm 1 get Ps mul BE 0 NA /FN Fp D /PF t D SI /SL SL 1 add D + /CF 0 D Ps CS mul Ts div MW WC mul CS mul Ts div dup LL gt PL 0 eq and + {LL div div}{pop}ie Ey 1 get FS CP E pop LE add YI neg div cvi dup Li lt + AH and{4 lt YI Li mul 5 mul LE add 0 gt or PL 0 eq and{NP}if}{pop}ie + EU 1 get Sc /GS Ps D}D +/RP {WR NL () /PF f D SI /FN 0 D ES Bm 1 get Ps mul neg SP OA /GS Ts D} D +/SI {/XO Lm 15 get BC NN mul Lm 16 get AI UI sub NN mul add + Lm 17 get UI NN mul add Lm 20 get LG NN mul add Ts mul + PF{Lm 1 get Ps mul add}if EO add D + /MR Rm 15 get BC NN mul Rm 16 get AI UI sub NN mul add + Rm 17 get UI NN mul add Rm 20 get LG NN mul add Ts mul + PF{Rm 1 get Ps mul add}if D /LL W XO sub MR sub D} D +/DT {/cC E D BN /LG LG 1 sub D SI /LG LG 1 add D WW 2 div Np BL} D +/DD {WB Cc 0 eq cC 0 eq and L1 0 eq or Lm 20 get Ts mul L1 sub TB{BW add}if + Ts 2 div lt or NL /LF E D SI BL /cC 0 D} D +/DL {Dc LG Cc put /Cc E D BG{Tm 18 get Ts mul BE}{BN}ie /LG LG 1 add D BL} D +/LD {BN LG 0 gt{/LG LG 1 sub D}if /Cc Dc LG get D SI + BG{()Bm 18 get Ts mul BE}if BL} D +/UL {BG{Tm 17 get Ts mul BE}{BN}ie NR AI NN 0 put /UI UI 1 add D + /AI AI 1 add D SI BL} D +/LU {BN /UI UI 1 sub D /AI AI 1 sub D SI BG{()Bm 17 get Ts mul BE}if BL} D +/OL {E BG{Tm 16 get Ts mul BE}{BN}ie TR AI NN Ty put /Ty E D NR AI NN 1 put + /AI AI 1 add D SI BL 1 Ln} D +/LO {BN /AI AI 1 sub D /Ty TR AI get D SI BG{()Bm 16 get Ts mul BE}if BL} D +/LI {E BN -1 SP /BP f D /CI 0 D 0 Np NR AI 1 sub NN get 1 eq + {dup dup 0 gt E 4 le and{/Ty E D}{pop}ie + /L1 L1 Ty AR AI NN get Ns SW pop XO sub dup 0 lt{pop 0}if add D ( ON )} + {pop ( B )}ie C1 E join /C1 E D CS Mf gt{/Mf CS D}if BL} D +/BQ {Tm 15 get Ts mul BE /BC BC 1 add D SI BL} D +/QB {Bm 15 get Ts mul BE /BC BC 1 sub D SI BL} D +/Al {E EP 1 sub dup 0 lt{pop AV AL get}if NA} D +/Ea {EP OA} D +/WB {PF{WR}{BT}ie} D +/F1 {WB /FN 0 D CS 0 FS} D +/F2 {WB /FN WI D CS 0 FS} D +/HY {/Hy t D WB /Hy f D} D +/YH {WB} D +/A {/LT E D LT 1 eq{/RN E D}if /Lh E D WB /C1 C1 ( Cp ) join D + Lc AF not and{Cl Sc}if /AF t D} D +/EA {Lc AF and{Ec}{WB}ie TL Pa AF and Lh 0 ne and + {( \() Lh join (\)) join /AF f D WB}if /AF f D} D +/TL {C1 ( Tl ) apa /C1 E D} d +/apa {AF OU and Lh 0 ne LT 1 eq or and{LT 1 eq{RN ( /) E ST cvs join} + {(\() Lh join (\)) join}ie E join join}{pop}ie} d +/Cp {/Xc CP /Yc E D D} D +/SS {Cf{dup 0 ge{EU E get dup -1 eq{pop CA CL get}if}{pop CA CL get}ie Sc} + {pop}ie SZ SL get /SL SL 1 add D} D +/I {WB 8 SS 1 FS} D +/EM {WB 8 SS /CF CF 1 xor D 0 FS} D +/BD {WB 9 SS 2 FS} D +/TT {WB 10 SS /FN Fp D 0 FS} D +/KB {WB 11 SS /FN Fp D 2 FS} D +/CT {WB 12 SS 1 FS} D +/SM {WB 13 SS /FN Fp D 0 FS} D +/Q {/QL QL 1 add D QO QL 2 mod get La get join WB} D +/EQ {QC QL 2 mod get La get join WB /QL QL 1 sub D} D +/RO {WB -1 SS /CF 0 D 0 FS} D +/SY {WB -1 SS -1 FS} D +/MY {WB -1 SS -2 FS} D +/ES {WB /SL SL 1 sub NN D /CF 0 D /FN FO SL get D SZ SL get FR SL get FS ()Ec}D +/FZ {3 sub 1.2 E exp GS mul E WB TL /C1 C1 ( Cp ) join D /SL SL 1 add D 0 FS} D +/Ef {WB TL ()ES /C1 C1 ( Cp ) join D} D +/BZ {dup /Bf E D FZ}D +/Sc {dup -1 ne Cf and{/CL CL 1 add D dup 0 eq{pop [0 0 0]}if + dup CA E CL E put VS ( VC ) join C1 E join /C1 E D}{pop}ie} D +/Ec {WB Cf{/CL CL 1 sub NN D CA CL get VS ( VC ) join C1 E join /C1 E D}if} D +/VS {dup type /arraytype eq{([) E {ST cvs join ( ) join}forall (]) join}if} D +/VC {{255 div}forall setrgbcolor} D +/Sl {dup type /integertype ne{Ds}if /La E D WB}d +/UN {WB /UF t D} D +/NU {WB /UF f D} D +/SE {WB /sF t D} D +/XE {WB /sF f D} D +/sM {/C1 C1 ( k1 ) join D}d +/eM {/C1 C1 ( k2 ) join D}d +/k1 {/YC CP E pop Ts add D /mF t D /f1 t D}d +/k2 {gsave 3 LW -9 CP E pop Ts 0.2 mul sub M -9 YC L stroke grestore /mF f D}d +/Ac {/AC E D WB}d +/Ca {eA{( \()join AC join(\) )join}if WB}d +/s {OU{gsave 0 CS .25 mul R dup SW pop CJ 0 RL stroke grestore}if}D +/CJ {AT 3 eq LB and{E dup dup length 1 sub A1 mul E + {( ) search{pop pop E A2 add E}{pop exit}ie}loop 3 -1 roll add + W CP pop sub 2 copy gt{E}if pop}if}D +/So {/Co E D} D +/SO {C1 Yo ST cvs join ( So ) join /C1 E D (j) SW pop 2 div Pd} D +/Se {E WB CS E div Pd}D +/Pd {dup type /stringtype eq{SW pop}if dup /L1 E L1 add D + ST cvs ( 0 R ) join C1 E join /C1 E D} D +/Sp {0.35 CO} D +/Sb {-0.2 CO} D +/CO {OV Io Yo put /Yo E CS mul Yo add D /Io Io 1 add D -1.5 Io mul 3 add FZ SO + CS Yo add dup YA gt{/YA E D}{pop}ie + Yo neg dup YB gt{/YB E D}{pop}ie} D +/Es {ES /Io Io 1 sub NN D /Yo OV Io get D SO} D +/SB {/N2 0 D 0 1 NI{/N E D{IX N2 get 0 lt{/N2 N2 1 add D}{exit}ie}loop + /K WS N get FC N get mul D /NY AY N2 get D /BV NY array D + 0 1 NY 1 sub{/TM K string D currentfile TM readhexstring pop pop BV E TM put} + for BM N BV put /N2 N2 1 add D}for} D +/IC [{/MA E D /MB 0 D}{2 div /MA E D /MB MA D}{/MB E CS sub D /MA CS D} + {pop /MA YS AB mul D /MB 1 AB sub YS mul D}{pop /MA 0 D /MB 0 D}] D +/IP {BV N get /N N 1 add D} D +/II {/K E D IX K get 0 lt{/EC E D}if /TY E D + TY 4 eq{/Y E D /X E D}if TY 3 eq{/AB E D}if + /XW AX K get D /YW AY K get D /IS SG IT K get get D /XS XW IS mul D + /YS YW IS mul D YS IC TY get exec /MA MA Fl not{3 add}if D} D +/IM {II /ty TY D /xs XS D /ys YS D /ya YA D /yb YB D /ma MA D /mb MB D /k K D + /ec EC D /BP f D /CI 0 D WB TL L1 xs add dup XO add MR add W gt + {pop /ma ma Fl{3 add}if D NL /YA ma D /YB mb D /YS ys D /L1 xs D} + {/L1 E D ma YA gt{/YA ma D}if mb YB gt{/YB mb D}if}ie /TB f D + OU{CP E pop YS sub LE neg lt Fl not and PB not and{NP /YA ma D /YB mb D}if + /BP f D ty ST cvs ( ) join IX k get 0 lt{(\() join ec join (\) ) join}if + k ST cvs join ty 3 eq{AB ST cvs ( ) join E join}if + ty 4 eq{X ST cvs ( ) join Y ST cvs join ( ) join E join}if C1 E join + ( DI ) join FP 2 eq FP 1 eq AF and or{( FM ) join}if + ( Il Cp ) apa /C1 E D /EN f D}if /HM t D /T f D} D +/DI {II /Xc CP /Yc E D D /YN YW neg D /HM t D /CI 0 D /K2 IX K get D gsave + TY 4 eq{OX X IS mul add OY FY add YS sub Y IS mul sub} + {/FY YS D CP MB sub 2 copy /OY E D /OX E D}ie + translate K2 0 ge{/DP AZ K2 get D /BV BM K2 get D XS YS scale /N 0 D XW YW DP + [XW 0 0 YN 0 YW] {IP} FC K2 get 1 eq{image}{f 3 colorimage}ie} + {EX}ie grestore XS 0 R /Ms t D} D +/FM {gsave 0 Sg CP MB sub translate XS neg 0 M 0 YS RL XS 0 RL 0 YS neg RL + XS neg 0 RL stroke grestore} D +/NA {/AT E D /AL AL 1 add D AV AL AT put} D +/OA {AL 0 gt{/AL AL 1 sub D /AT AV AL get D}if} D +/D1 {/BR {CP E pop E BN Mb{CP E pop eq{0 YI R}if}{pop}ie} D + /Sn {OU{C1 E ST cvs join ( Ld ) join /C1 E D}{pop}ie} D} D +/D1 {/BR {BN} D /Sn {OU {C1 E ST cvs join ( Ld ) join /C1 E D} {pop} ie} D} D +/TC {/TF t D /ML 0 D HN{SW pop dup ML gt{/ML E D}{pop}ie}forall NP /RM RM not D + RC /OU Tc D Ep /PN 0 D Ms not TP and{Ip}if /W IW ML sub Ts sub D + /A0 0 D TH{/BR {( ) join BT} D /Sn {pop} D /Au () D}if} D +/TN {0 eq{E EA PF HF or not XR and{HN E get Xr}{pop}ie} + {OU{Tn 0 ge{() BN}if /Tn E D}{pop}ie WB}ie} D +/NT {OU LB not and Tn 0 ge and{PL 0 eq{Ms not{CS CF FS}if CP dup + /y E YA sub D W 9 sub CS -1.8 mul XO L1 add 2 add{y M (.) show}for + HN Tn get dup SW pop IW E sub y M show CP BB M}if /Tn -1 D}if} D +/Ld {/DN E D HN DN Pn put [/View [/XYZ -4 Fl{PS}{CP YA add US E pop}ie null] + /Dest DN ST cvs cvn /DEST pdfmark} D +/C {ND 1 eq{1 sub}if TI mul /XO E D NL Nf not{pop()}if 0 3 -1 roll 1 A} D +/OP {BP not{NP}if PN 2 mod 0 eq{/Ms t D NP}if}D +/Ep {Xp PN 2 mod 0 eq and OU and{/Pn (-) D showpage /PM 1 D LA}if}D +/Dg [73 86 88 76 67 68 77] D +/Rd [0 [1 1 0][2 1 0][3 1 0][2 1 1][1 1 1][2 2 1][3 3 1][4 4 1][2 1 2]] D +/Ns {/m E D /c E 32 mul D /j m 1000 idiv D /p j 12 add string D + c 96 le m 0 gt and{c 32 le {/i 0 D /d 77 D /l 100 D /m m j 1000 mul sub D + j -1 1 {pop p i d c add put /i i 1 add D}for + 4 -2 0 {/j E D /n m l idiv D /m m n l mul sub D /d Dg j get D + n 0 gt {/x Rd n get D x 0 get -1 1 {pop p i d c add put /i i 1 add D}for + p i x 1 get sub Dg x 2 get j add get c add put}if /l l 10 idiv D + }for p 0 i GI} + {/i ST length 1 sub D m {1 sub dup 0 ge{dup 26 mod c add 1 add + ST i 3 -1 roll put 26 idiv dup 0 eq{pop exit}if}if /i i 1 sub D}loop + ST i ST length i sub GI}ie} + {m p cvs}ie} D +/US {matrix currentmatrix matrix defaultmatrix matrix invertmatrix + matrix concatmatrix transform} D +/GB {Gb{US}if}D +/Tl {/Rn E D Xc CP pop ne{ + [/Rect [Xc 1 sub Yc cS 0.25 mul sub GB CP E 1 add E cS 0.85 mul add GB] + /Subtype /Link /Border [0 0 Cf Lc and LX and AU or{0}{1}ie] Rn type + /nametype eq {/Dest Rn}{/Action [/Subtype /URI /URI Rn] Cd}ie + /ANN pdfmark}if} D +/Il {/Rn E D [/Rect [Xc Yc GB Xc XS add Yc YS add GB] /Subtype /Link + /Border [0 0 0] Rn type /nametype eq{/Dest Rn} + {/Action [/Subtype /URI /URI Rn] Cd}ie /ANN pdfmark} D +/XP {[{/Z Bz 2 div D Z 0 R Z Z RL Z neg Z RL Z neg Z neg RL Z Z neg RL + Fi cH 1 eq and{fill}if} {Bz 0 RL 0 Bz RL Bz neg 0 RL 0 Bz neg RL + Fi cH 1 eq and{fill}if} {0 -5 R Bz 0 RL 0 21 RL Bz neg 0 RL 0 -21 RL}]} D +/MS {/Sm E D WB}D +/O {BN()0 Sm BX} D +/BX {/Bt E D Bt 2 lt{/Ch E D CS 0.8 mul}{11 mul}ie W XO sub MR sub + 2 copy gt{E}if pop /HZ E D Bt 2 eq{Fi not{pop()}if ( )E join /Ft E D TT + /PF t D /MW 1 D /Li 1 D /Fw Ft SW pop D Fw HZ gt{/HZ Fw 8 add D}if + HZ ST cvs( )join}{WB Ch ST cvs( )join}ie L1 HZ add XO add MR add W gt{NL}if + Bt 2 eq{Ft ES Fw neg HM{CS sub}if Pd}if Bt ST cvs join( Bx )join + Bt 2 eq HM and{CS Pd}if C1 E join /C1 E D /L1 L1 HZ add D /T f D + ( ) Pd /PF f D Bt 2 lt{YA CS .8 mul lt{/YA CS .8 mul D}if} + {YB 5 lt{/YB 5 D}if YA 21 lt{/YA 21 D}if}ie /CI 0 D} D +/Bx {dup 2 eq{E /Bz E D}{E /cH E D /Bz CS .8 mul D}ie + OU {gsave 0 Sg XP E get exec stroke grestore}{pop}ie Bz 0 R /Ms t D}D +/SD {FD 4 mul Dy add DZ NF newpath 0 0 M DX t charpath pathbbox + 3 -1 roll sub /DY E D E dup /X1 E D sub WM mul WX DY mul add WM DG mul E div + /DF E D /DR WX DF mul DY mul WM div 2 div D} d +/Sd {gsave 0 IL Di mul neg translate IL IW atan Di 0 eq{neg}if rotate + FD 4 mul Dy add DZ NF DR X1 sub DY 2 div neg M cD VC DX show grestore} d +/Pt {/tp t D Tp{NP /Pn (TP) D 0 Tt neg R Th BN NP Ep ET RC ZF}if /tp f D} D +/RC {/AI 0 D /LG 0 D /BC 0 D /UI 0 D /PF f D /Cc 0 D /cC 0 D /Dc 10 array D + /NR [0 1 9{pop 0}for] D /La Ds D /AR 10 array D /TR 10 array D /AV 30 array D + SI /AL -1 D /AT A0 D AT NA /OV 9 array D /Yo 0 D /Co 0 D /Io 0 D /Hy f D + /Ph f D /CL -1 D Ct Sc}D +/ZF {/FR [0 1 30{pop 0}for] D /SZ [0 1 30{pop 0}for] D /FO [0 1 30{pop 0}for] D + /SL 0 D /CF 0 D /FN 0 D 0 Ts SF}D +/QO [[(\234)(\233)(\253\240)(\232)(\273)(\253)][(')(`)(\253\240)(\231)(\273)(\253)]] D +/QC [[(\234)(\234)(\240\273)(\233)(\253)(\273)][(')(')(\240\273)(`)(\253)(\273)]] D +/Hf EF length 2 sub D +/Hz EZ Hf get D +/HS Ey Hf get D +/Fz EZ Hf 1 add get D +/Fs Ey Hf 1 add get D +/LE IL D +/Ps EZ 1 get D +/Fp EF 1 get D +/XO 0 D +/YI 0 D +/CI 0 D +/FP 0 D +/WW Ts 7 mul D +/Mf 0 D +/YA 0 D +/YB 0 D +/Cs Ts D +/GS Ts D +/F0 0 D +/NS 0 D +/NB 0 D +/N 0 D +/C0 [] D +/C1 () D +/Lo 0 D +/L1 0 D +/LM 0 D +/PH 0 D +/EC 0 D +/Lh 0 D +/LT 0 D +/CH 1 string D +/ST 16 string D +/CA 9 array D +/HC (\255) D +/HM f D +/PF f D +/EN f D +/TB f D +/UF f D +/sF f D +/AE f D +/AF f D +/BP t D +/CD f D +/PA t D +/GL f D +/T t D +/HF f D +/AH f D +/SA f D +/PB f D +/f1 f D +/mF f D +/OX 0 D +/OY 0 D +/FY 0 D +/EO 0 D +/FB 0 D +/PL 0 D +/Bw 0 D +/PD -1 D +/TP f D +/tp f D +/TH t D +/Ty 4 D +/Tn -1 D +/Fl t D +/LB t D +/PM 1 D +/Ms f D +/Ba f D +/Bb f D +/Hl 3 D +/hl 6 D +/Hv 6 D +/Hs f D +/HI 0 D +/hi 0 D +/PO t D +/TE f D +/LF t D +/BO 0 D +/Sm 1 D +/Bf 3 D +/A1 0 D +/A2 0 D +/Ds 1 D +/QL -1 D +/Cb Db D +/Ct Dt D +/Cl Dl D +/AX [280 445] D +/AY [272 808] D +/IX [0 1] D +/IT [0 0] D +/AZ [8 8] D +/WS [280 445] D +/FC [3 3] D +/NI 1 D +/BM 2 array D +SB +ffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffff +ffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6686d7254585c9aa2a9e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6787e83141516c5ced7b0b9c11415168c9399e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +aab3ba989fa6e1ecf6e1ecf6a4acb314151699a0a7e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6bcc5cd0000000000002a2c2ee1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf66d7378000000c1cbd3cad4dd7e848ab8c1cae1ecf6e1ecf6e1ecf6 +e0ebf5e1ecf6e1ecf6e1ecf6e1ecf6e0ebf5e1ecf6e1ecf6e1ecf6e1ecf6 +4245480b0b0ce1ecf6e1ecf6c4cdd67e848abfc8d0e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6676c710000004e5155000000b8c1c9e1ecf6bdc6ce14151652565a +2021231e1f2190979de1ecf69aa2a91415165b5f631415162d2f31a7afb6 +e1ecf66d7378000000c1cbd3b0b9c11415168c9399e1ecf69fa7ae262829 +030303131415bac3ccb8c1c91a1c1d0303031d1f205d6165dde8f271767b +060607010101141516585d60a4acb314151699a0a7e1ecf69ba3aa404446 +0c0d0e4a4e51acb4bce1ecf681878d14151662676b101111303234b9c2cb +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +dee9f31516172b2d2fbdc6ce00000062676be1ecf6b8c1ca000000202123 +9ca4ab333638050606d5dfe8929aa000000037393c9ca4ab1d1f201f2022 +e1ecf66d7378000000c1cbd3abb4bb000000838a90c7d0d9070708222325 +a0a8af9ea6adc6cfd8c9d3dcaab3bac9d3dc83898f000000a1a8b0bfc8d0 +303234070708a1a9b1b7c0c89ea6ad00000091989ed8e3ec0c0d0e35383a +a2aab2262829232527e1ecf6777d82000000404446949ba202020262676b +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +9fa7ae0000004f5357a1a9b1161718121313dde7f1b8c1ca000000656a6f +e1ecf68b919700000099a0a7929aa00000008b9298e1ecf6656a6e000000 +bfc8d06d7378000000c1cbd3abb4bb000000838a9099a0a7000000757b80 +e1ecf6e1ecf6e1ecf6c1cbd3393c3f0f10100c0d0e00000064696de1ecf6 +4245480b0b0ce1ecf6e1ecf69ea6ad00000091989e99a0a7000000898f96 +e1ecf670767b000000b8c1ca777d82000000a9b1b8e1ecf6121313383b3e +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +494d500000000000000000000000000000009aa1a8b8c1ca000000424548 +e0ebf562676b000000bfc9d1929aa0000000666b70dfeaf43e41440b0b0c +dae5ee6d7378000000c1cbd3abb4bb000000838a90afb7bf000000474b4e +dee9f3dee9f3d8e3ec606569000000c6cfd8a7afb6000000606569e1ecf6 +4c5053050606dce6f0e1ecf69ea6ad00000091989ec5ced701010164696d +e1ecf64c50530c0d0ed9e4ed777d82000000b8c1c9e1ecf6141516383b3e +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6d0dae4 +0506063a3d40e1ecf6e1ecf6cad4dd02020244474ab8c1ca0000001e1f21 +111212000000434649e1ecf6929aa00000001e1f21111212010101676c71 +e1ecf66d7378000000c1cbd3abb4bb000000838a90e1ecf6565b5f000000 +151617151617afb7bf8e959b00000027292a292b2c000000606569e1ecf6 +8e959b020202060607747a7f9ea6ad00000091989ee1ecf6585d60040404 +16171808080974797ee1ecf6777d82000000b8c1c9e1ecf6141516383b3e +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6d1dbe5 +a9b1b8c4cdd6e1ecf6e1ecf6e1ecf6b0b8c0adb5bdb8c1ca000000767c81 +b0b8c0b0b8c0e1ecf6e1ecf6929aa00000009aa1a8a4acb3bec7cfe1ecf6 +e1ecf6c5ced7a9b1b8d9e4edd4dee8a9b1b8cad4dde1ecf6e1ecf6b5bec6 +939ba1a3abb2dbe6efe1ecf6bec7cf9ea6add0dae4a9b1b8c1cbd3e1ecf6 +e1ecf6ced8e1a9b2b9c5ced7d0dae4a9b1b8ced8e1e1ecf6e1ecf6d0dae4 +a1a8b0d6e1eae1ecf6e1ecf6c7d0d9a9b1b8d7e2ebe1ecf6aeb6beb8c1c9 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6b8c1ca000000767c81 +e1ecf6e1ecf6e1ecf6e1ecf6929aa00000009ca4abe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6d8e3ecb0b8c0cad4dd +e1ecf6e1ecf6e1ecf6e1ecf6d0dae4b0b8c0d2dce6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6dfeaf5bfd0e396aecb7d99bd +7d99bc7d99bc7d99bc7d99bc7d99bc7d99bc7d99bc7d99bc7d99bc7d99bc +7d99bc7d99bc7d99bc7d99bc7d99bc7d99bc7d99bc7d99bc7d99bc7d99bc +7d99bc7d99bc7d99bc7d99bc7d99bc7d99bc7d99bc7d99bc7d99bc7d99bc +7d99bc7d99bc7d99bc7d99bc7d99bc7d99bc7d99bc7d99bc7d99bc7d99bc +7d99bc7d99bc7d99bc7d99bc7d99bc7d99bc7d99bc7d99bc7d99bc7d99bc +7d99bc7d99bc7d99bc7d99bc7d99bc7d99bc7d99bc7d99bc7d99bc7d99bc +7d99bc7d99bc7d99bc7d99bc7d99bc7d99bc7d99bc7d99bc7d99bc7d99bc +7d99bc7d99bc7d99bc7d99bc7d99bc7d99bc7d99bc7d99bc7d99bc7d99bc +7d99bc7d99bc7d99bc7d99bc7d99bc7d99bc7d99bc7d99bc7d99bc7d99bc +7d99bc7d99bc7d99bc7d99bc7d99bc7d99bc7d99bc7d99bc7d99bc7d99bc +7d99bc7d99bc839ec09eb5d0bbcde0d9e5f1e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6deeaf4becfe296aecb7996ba7895ba7895ba7895ba +7895ba7895ba7895ba7895ba7895ba7895ba7895ba7895ba7895ba7895ba +7895ba7895ba7895ba7895ba7895ba7895ba7895ba7895ba7895ba7895ba +7895ba7895ba7895ba7895ba7895ba7895ba7895ba7895ba7895ba7895ba +7895ba7895ba7895ba7895ba7895ba7895ba7895ba7895ba7895ba7895ba +7895ba7895ba7895ba7895ba7895ba7895ba7895ba7895ba7895ba7895ba +7895ba7895ba7895ba7895ba7895ba7895ba7895ba7895ba7895ba7895ba +7895ba7895ba7895ba7895ba7895ba7895ba7895ba7895ba7895ba7895ba +7895ba7895ba7895ba7895ba7895ba7895ba7895ba7895ba7895ba7895ba +7895ba7895ba7895ba7895ba7895ba7895ba7895ba7895ba7895ba7895ba +7895ba7895ba7895ba7895ba7895ba7895ba7895ba7895ba7895ba7895ba +7895ba7895ba7895ba7895ba7895ba7895ba7895ba7895ba7895ba7895ba +819cbe9eb5cfbdcee1dae6f2e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6c7d7e787a1c25f81ab5679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a66082acc0d0e3e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6c5d5e6839ec05e7faa5679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65b7ea9b7c9dee1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6d2dfed6484ae5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a6597ca8adc1d8e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +ceddeb6182ad5679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a6587aa7a7bcd5e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6dbe7f3708fb55679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a699b0cce1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6d8e5f1 +6c8bb35679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a696aecbe0ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e0ebf5819cbe5679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a6ceddeb +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6deeaf47a97bb +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6b8cadee1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6c1d2e45679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a6a6bbd4 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6b4c7dc5679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a68ea7c6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6a4bad35679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a67c98bc +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf696aecb5679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a66586afe1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf687a2c25679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a6597ca8 +dae7f2e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf67794b95679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6c7d6e7e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf67592b85679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +c3d3e5e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf65d7faa5679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6a4b9d3e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf67492b75679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +c2d3e4e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf65a7ca85679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6a0b6d0e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf67492b75679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +c2d3e4e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf65a7ca85679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6a0b6d0e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf67492b75679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +c2d3e4e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf65a7ca85679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6a0b6d0e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf67492b75679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +c2d3e4e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf65a7ca85679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6a0b6d0e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf67492b75679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +c2d3e4e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf65a7ca85679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6a0b6d0e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf67492b75679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +c2d3e4e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf65a7ca85679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6a0b6d0e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf67492b75679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +c2d3e4e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf65a7ca85679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6a0b6d0e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf67492b75679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6577aa7577aa7577aa7 +577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7 +577aa7577aa7577aa7577aa7bac9dba8bad1577aa7577aa7577aa7577aa7 +577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7 +577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7 +577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7 +577aa7577aa7577aa7577aa7577aa7577aa7587ba7577aa76585ae7c97ba +7c97ba6484ae577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7 +577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7 +577aa7577aa7577aa7577aa75679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +c2d3e4e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf65a7ca85679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a66585ae7b96ba7b96ba6384ad5679a65679a6 +5679a65679a6a4b6cfc2cfdf5679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a66c8ab2dbe2ec7692b75679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +577aa65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a66f8db3718eb45679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6a0b6d0e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf67492b75679a65679a65679a65679a65679a65679a65679a6a5b8d0 +eaeff4e1e7efb7c6d97693b75679a65679a65679a6577aa7577aa7577aa7 +577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7 +577aa7577aa7577aa7577aa7d6dfeabfccde577aa7577aa7577aa7577aa7 +577aa7577aa7577aa7577aa7577aa79bb0cb9cb1cb577aa7577aa7577aa7 +577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7 +577aa7577aa77793b8bbc9db5c7eaa577aa7577aa7577aa7577aa7577aa7 +577aa7577aa7577aa7587ba7adbed4f1f4f8f9fafc94aac797adc8fafbfd +ffffff93a9c6577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7 +577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7 +577aa7577aa7577aa7577aa75679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +c2d3e4e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf65a7ca85679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a6577aa7577aa7577aa7577aa79aafcaebeff4 +9cb1cb577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7 +577aa7577aa7577aa7577aa79aafcafafbfdffffff95abc7577aa7577aa7 +577aa7577aa7bac8dbe1e7ef577aa7577aa7577aa7577aa7577aa7577aa7 +577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa78ea5c4 +acbdd4577aa7577aa7577aa7577aa77390b5ffffff7f9abc577aa7577aa7 +577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7 +577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa77491b6dbe2ec +fcfdfee1e8ef577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7 +577aa7577aa7cbd6e4d0d9e6577aa7577aa7577aa7577aa7577aa7577aa7 +577aa7577aa75679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6a0b6d0e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf67492b75679a65679a65679a65679a65679a65679a65679a6b0c0d5 +f3f6f9a7b9d1e6ebf2d2dbe75679a65679a65679a6587ba8577aa7577aa7 +577aa7577aa7577aa7577aa75a7ca8577aa7577aa7577aa7587ba75a7ca8 +577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7 +5b7da9577aa7577aa7577aa7577aa7cad5e3ccd6e4577aa7577aa7577aa7 +577aa7577aa7587ba8577aa7577aa7577aa7577aa7577aa7587ba8577aa7 +577aa7577aa78ca4c3ffffff6081ac577aa7577aa7577aa7577aa7577aa7 +577aa7577aa7577aa792a9c6ffffffcfd9e6acbdd49fb3cd577aa75a7ca8 +ffffff93a9c6577aa7577aa7577aa7577aa75b7da9577aa7577aa7577aa7 +577aa7577aa75a7da9577aa7577aa7577aa7577aa7577aa75b7da9577aa7 +577aa7577aa7577aa7577aa7577aa75679a65679a65679a65679a6577aa6 +597ba75679a65679a65679a65679a65679a65679a65679a65679a65679a6 +c2d3e4e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf65a7ca85679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a6577aa7577aa7577aa7577aa7cad5e3f8f9fb +ced8e5577aa7577aa7577aa7577aa7587ba8577aa7577aa7577aa7577aa7 +577aa7587ba8577aa7577aa7577aa7587ba7ffffff95abc7577aa7577aa7 +577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa75c7ea9 +577aa7577aa7577aa7577aa75b7da9577aa7577aa7577aa7577aa7b4c4d8 +e7ecf2577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7 +577aa7577aa7587ba8577aa7577aa7577aa7577aa7577aa7587ba8577aa7 +577aa7577aa7577aa7577aa7577aa7577aa7577aa7597ca8eaeef4f4f7f9 +abbdd3cfd9e6577aa7577aa7577aa7587ba8577aa7577aa7577aa7577aa7 +587ba7587ba7cbd6e4d0d9e6577aa7577aa7577aa7587ba8577aa7577aa7 +577aa7577aa75679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6a0b6d0e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf67492b75679a65679a65679a65679a65679a65679a65679a6b0c0d5 +eaeef45679a69eb2ccfcfdfe5a7ca86c8ab2c1cedef6f8fabdcbdc6787b0 +577aa78aa2c2f0f3f7b5c4d8fbfcfdc0cdde577aa7a5b8d0f0f3f7fefefe +bdcbdc577aa76686aff0f3f7f0f3f7b5c5d8577aa7577aa76283add4dde9 +fcfdfef4f6f97f9abc5a7da9f0f3f7fafbfdfafbfdf0f3f79fb3cd577aa7 +829cbed6dfeaeff2f6a9bbd2587ba7708eb4f0f3f7c2cedff7f9fba8bad1 +577aa7bccadcf4f7f9fffffff1f4f7d7dfea577aa7577aa7577aa7577aa7 +577aa7577aa7577aa7cfd9e6e3e9f1577aa7577aa7587ba7577aa75a7ca8 +ffffff93a9c6577aa7577aa75f80abe6ebf2ffffffe5ebf29aafca577aa7 +5b7da9ced8e5fafbfdf6f8fb8ca4c3577aa76f8db3dae2ecfefefef0f3f7 +6f8db3577aa77b96bacfd9e6f2f4f8afc0d55b7da95679a6a0b4cdeef2f6 +fefefec1cedf5679a65679a65679a65679a65679a65679a65679a65679a6 +c2d3e4e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf65a7ca85679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a6577aa7577aa7577aa7587ba7f2f5f8bdcbdc +f5f7fa587ba8577aa7d7e0eac3d0e0f0f3f7d4dde96f8db3577aa7edf1f6 +beccddf6f8fac7d3e26484ae577aa7587ba7ffffff95abc7577aa7577aa7 +577aa7e5ebf2f0f3f7d4dde8577aa7577aa7577aa78ea5c4f1f4f7ffffff +d2dce8577aa77c97baf1f4f7fefeffdae2ec86a0c0577aa7dfe6eef8fafc +fdfdfef0f3f7bccadc577aa7a5b8d0f0f3f7f0f3f77b97ba577aa7577aa7 +7b97bad1dae7eff2f6a3b7cf587ba85e80abf0f3f7c0cddef6f8fbc2cfdf +577aa7577aa7577aa7577aa7577aa7577aa7577aa7819bbdffffff8fa6c4 +577aa7587ba7577aa75f80abb0c0d6f3f6f9c6d2e16f8db3577aa77995b9 +dde4ede5ebf2d8e0ebd0d9e6577aa7718eb4c6d2e1f5f7fabac9db6585af +577aa7577aa75679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6a0b6d0e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf67492b75679a65679a65679a65679a65679a65679a65679a6b0c0d5 +eff2f788a1c1d8e0eadce3ed5679a6bdcadcd7dfea829cbee2e8f0a9bbd2 +577aa78ea6c4ffffffcad5e38aa2c292a8c65c7eaaf8f9fba4b7cf6e8cb3 +8ca4c3577aa75c7ea986a0c0e2e8f0bfccde577aa7577aa79cb1cbf2f5f8 +708eb4819bbd7390b6587ba786a0c0d9e1ebdae2ec86a0c06d8cb3577aa7 +ebeff5b7c6d98aa2c2fcfcfd7b97ba7390b5ffffffbccadcc0cddeeff2f6 +577aa77693b7adbed4ffffff8da5c37f99bc577aa7577aa7577aa7577aa7 +577aa7577aa7577aa7e4eaf1c4d0e0577aa7577aa7577aa7577aa75a7ca8 +ffffff93a9c6577aa7577aa75f80ab9cb1cb6f8db3a3b7cfedf1f6577aa7 +8ca4c3fafbfd7693b77c97ba7a96b9577aa7b1c1d6e5ebf26b8ab288a1c1 +6989b1577aa7dce3edc2cedf859ebff4f7f98aa2c1597ba7f5f7faa8bad1 +6d8bb28da5c35679a65679a65679a65679a65679a65679a65679a65679a6 +c2d3e4e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf65a7ca85679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a6577aa7577aa7577aa77390b6ffffff7995b9 +ffffff7894b8577aa7e5eaf1f2f5f898adc9eff2f7b2c2d7577aa7fdfdfe +e6ebf29aafcafafbfc9aafca577aa7587ba7ffffff95abc7577aa7577aa7 +577aa7839dbeced8e5e1e7ef577aa7577aa76383adf7f9fbd2dbe7849ebf +a3b7cf577aa77794b88ca4c36e8cb3c1cedfcfd9e6577aa7819bbdc9d4e3 +eef1f686a0c07793b8577aa76f8db39aafcaffffff7f9abc577aa7577aa7 +dde4edcfd9e69aafcafefefe7c97ba5f80abffffffd0d9e6acbdd4ffffff +6585af577aa7577aa7577aa7577aa7577aa7577aa795abc7ffffff6f8db3 +577aa7577aa7577aa796acc8f5f7fa94aac7dde4edc3d0e0577aa7c6d2e1 +e4eaf19cb0cbfbfcfdd0d9e6577aa7c8d4e2d1dae7829cbee5eaf1a5b8d0 +577aa7577aa75679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6a0b6d0e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf67492b75679a65679a65679a65679a65679a65679a65679a6b0c0d5 +fffffffcfcfdd4dde8869fbf5679a6edf1f6dbe2ecc0cddee3e9f1dbe3ec +577aa78ea6c4ffffff6787af577aa7577aa7577aa7ebeff4fafbfcb5c4d8 +6585ae577aa7577aa7577aa7d6dfeabfccde577aa7577aa78aa2c2ffffff +e2e8f092a9c6577aa7577aa7577aa7cad5e3ccd6e4577aa7577aa77390b6 +ffffffcad5e3c0cddef4f7f9adbed47390b5ffffff7f9abc90a7c5ffffff +5f80ab577aa78ca4c3ffffff6081ac577aa7577aa7577aa7577aa7577aa7 +577aa7577aa7577aa7e6ebf2c0cdde577aa7577aa7577aa7577aa75a7ca8 +ffffff93a9c6577aa7577aa75d7faab3c2d7dfe6eef2f5f8ffffff6c8bb2 +7b96baffffffe8edf39aafca587ba8577aa79eb2ccffffffd9e1eb87a0c0 +577aa76585aefefeffcfd9e6c0cddeeef2f6bdcadc5679a6e5ebf1fbfcfd +b6c5d96585ae5679a65679a65679a65679a65679a65679a65679a65679a6 +c2d3e4e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf65a7ca85679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a6577aa7577aa7577aa79cb1cbf8f9fb7c97ba +f2f5f8a1b5ce577aa7e5eaf1c4d0e0577aa7c0cdded6dfea577aa7fdfdfe +abbdd3577aa7d9e1ebbecbdd577aa7587ba7ffffff95abc7577aa7577aa7 +577aa7577aa7bac8dbe1e7ef577aa7577aa7829cbeffffff7c97ba577aa7 +577aa7577aa76d8bb2bccadce7ecf2f6f8faf7f9fb577aa7577aa7b4c4d8 +e7ecf2577aa7577aa7577aa7577aa77390b5ffffff7f9abc577aa76686af +fefeff829cbd577aa7e3e9f0afbfd55f80abffffff95abc7718fb5ffffff +7e99bb577aa7577aa7577aa7577aa7577aa7577aa798adc9ffffff6b8ab2 +577aa7577aa7577aa7c6d2e1c9d4e3577aa79cb0cbf3f6f9597ca8ebeff4 +a7bad1577aa7dce3edd0d9e65b7da9f6f8fbd7dfeac0cddee5eaf1d7e0ea +577aa7577aa75679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6a0b6d0e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf67492b75679a65679a65679a65679a65679a65679a65679a6b0c0d5 +ebeff55b7da85679a65679a6597ba7fdfdfed1dbe7b1c1d6b1c1d6a8bad1 +577aa78ea6c4ffffff5e80ab577aa7577aa7577aa76787afb2c2d7eff2f7 +e3e9f1577aa7577aa7577aa7d6dfeabfccde577aa7577aa7577aa7869fc0 +ccd7e4fdfdfe9cb1cb577aa7577aa7cad5e3ccd6e4577aa7577aa7869fc0 +ffffffbccadcb1c1d6b1c1d690a7c57390b5ffffff7a96b98da5c3ffffff +6081ab577aa78ca4c3ffffff6081ac577aa7577aa7577aa7577aa7577aa7 +577aa7577aa7577aa7d3dce8dfe6ee577aa7577aa7577aa7577aa7587ba8 +fcfdfe97adc8577aa7577aa794aac7ffffff9cb0cb9fb3cdffffff7591b7 +577aa77d98bbc7d3e2fbfcfdabbdd3577aa7587ba790a7c5d4dde8ffffff +87a0c07693b7ffffffc4d0e0b0c0d5b0c0d598adc95679a66484adafc0d5 +eef1f6e8edf35679a65679a65679a65679a65679a65679a65679a65679a6 +c2d3e4e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf65a7ca85679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a6577aa7577aa7577aa7c5d1e1ffffffffffff +ffffffcbd6e4577aa7e5eaf1c1cedf577aa7beccddd9e1eb577aa7fdfdfe +a9bbd2577aa7d7dfeac1cedf577aa7577aa7fcfcfd99aeca577aa7577aa7 +577aa7577aa7bac8dbe1e7ef577aa7577aa7849ebfffffff7794b8577aa7 +577aa7577aa7bac9dbf2f5f88ea5c4b9c8daffffff577aa7577aa7b4c4d8 +e7ecf2577aa7577aa7577aa7577aa77390b5ffffff7f9abc577aa76b8ab1 +ffffff7e99bb577aa7dfe5eeb5c4d85f80abffffff8ea5c46f8db3ffffff +7e99bb577aa7577aa7577aa7577aa7577aa7577aa7849ebfffffff8aa3c2 +577aa7577aa7577aa7ccd7e4c5d1e1577aa798adc9f7f9fb5b7da9eff2f7 +a3b7cf577aa7d9e1ebd0d9e66484aeffffffccd6e4b1c1d6b1c1d6a6b9d0 +577aa7577aa75679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6a0b6d0e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf67492b75679a65679a65679a65679a65679a65679a65679a6b0c0d5 +eaeef45679a65679a65679a65679a6dfe5eed4dde8728fb57794b896acc8 +577aa78ea6c4ffffff5e80ab577aa7577aa7587ba78ca4c35c7eaa94aac7 +f8f9fb5a7da96585af7793b8dee5eecbd6e47793b86282ad7995b9718eb4 +5b7da9d7e0eab4c4d8577aa7577aa7b3c3d7e5eaf17b96ba6585af6888b0 +fbfcfdb3c2d76b8ab2869fc0829cbd7390b5ffffff7a96b98da5c3ffffff +6081ab577aa77693b7ffffff92a8c6718fb5577aa7577aa7577aa7577aa7 +577aa7577aa7577aa79cb0cbfefefebac8db94abc796acc8577aa7577aa7 +dde4edcbd6e47894b86081aca7b9d1f8f9fb6182acb9c7daffffff7591b7 +7390b57693b75a7da9cad5e3c3d0e0577aa77f9abc6b8ab15d7faaeaeef4 +9fb3cd5e80abf6f8fabeccdd6d8bb2809abc88a1c15679a68ca4c35c7ea9 +8ea6c4fafbfd5c7ea95679a65679a65679a65679a65679a65679a65679a6 +c2d3e4e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf65a7ca85679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a6577aa7577aa7577aa7eef1f6adbed46282ad +a6b9d0f3f6f9587ba7e5eaf1eff2f78aa2c2edf0f5b2c2d7577aa7fdfdfe +e1e8ef8ca4c3f8f9fb9aafca577aa7577aa7dbe2eccfd9e67995b96282ad +6081ac7793b8c7d3e2e7ecf27793b86787b06686affafbfdc8d4e27995b9 +96acc8577aa7cfd9e6dbe2ec6081abd3dce8ffffff577aa7577aa79cb1cb +f7f9fb7f99bc6c8bb2577aa77390b58da5c3ffffff98adc97592b7577aa7 +e2e8f0c5d1e18aa2c2fcfdfe819bbd5f80abffffff8ea5c46f8db3ffffff +7e99bb577aa7577aa7577aa7577aa7577aa7577aa75c7ea9f1f4f7e9edf3 +96acc8b9c7da577aa79bb0cbf2f5f8849dbed5dee9c8d4e2577aa7cad5e3 +dbe3ec8aa2c2f8fafcd0d9e6577aa7e9edf3cdd7e5708eb47a96b995abc7 +577aa7577aa75679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6a0b6d0e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf67492b75679a65679a65679a65679a65679a65679a65679a6b0c0d5 +eaeef45679a65679a65679a65679a67c97baeff2f7fffffffefeffb7c6d9 +577aa78ea6c4ffffff5e80ab577aa7577aa7587ba8f1f4f8fefefff9fafc +adbed4577aa7a7b9d1ffffffffffffffffffffffff90a7c595abc7fcfdfe +fefeffe9eef47592b7577aa7577aa77995b9d9e1ebfdfdfea7b9d1577aa7 +9eb2ccfbfcfdfffffff9fafc8ea6c47390b5ffffff7a96b98da5c3ffffff +6081ab577aa7587ba7c6d2e1f4f7f9e4eaf1577aa7577aa7577aa7577aa7 +577aa7577aa7577aa75b7da9c2cedffefefeffffff9db1cc577aa7577aa7 +90a7c5e8edf3ffffff88a1c16d8bb2e6ebf2fcfdfed6dfeaffffff7591b7 +87a0c0fbfcfdfefeffeef1f6819bbd577aa7a8bad1fefefffefeffe3e9f1 +6686af577aa792a9c6f8fafcfffffffbfcfd9bb0ca5679a6eef1f6fefeff +fafbfcb1c1d65679a65679a65679a65679a65679a65679a65679a65679a6 +c2d3e4e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf65a7ca85679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a6577aa7577aa76e8cb3ffffff829cbe577aa7 +7b97baffffff7592b7e5eaf1d4dde9f9fafcdfe6ee7390b5577aa7fdfdfe +d0dae6fdfdfed4dde86787af577aa7577aa78fa6c4e8edf3ffffff90a7c5 +8aa3c2ffffffffffffffffffffffffb1c1d6577aa79aafcafafbfcffffff +dbe3ec577aa78aa2c2f1f4f8fafbfddae2ecffffff577aa7577aa76989b1 +d2dbe7fafbfcc7d3e2577aa7ecf0f5fffffffffffffffffff8fafc577aa7 +869fc0e1e7eff7f9fbb3c3d75a7ca85f80abffffff8ea5c46f8db3ffffff +7e99bb577aa7577aa7577aa7577aa7577aa7577aa7577aa7829cbeeff2f7 +fffffff1f4f8577aa76383adc0cddefcfcfdd5dee97793b8577aa7829cbd +ecf0f5f2f5f8dde4edd0d9e6577aa7829cbef2f5f8fffffffefefeb3c3d7 +577aa7577aa75679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6a0b6d0e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf67492b75679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6577aa7577aa7577aa7 +577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7 +577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7 +577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7 +577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7 +577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7 +577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7 +577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7 +577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7 +577aa7577aa7577aa7577aa75679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +c2d3e4e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf65a7ca85679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a6e4eaf1b0c0d55e7faa577aa75679a65679a6fdfdfe +98adc96081ab5679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65a7ca86988b0 +577aa65679a65679a6597ca86081ab5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65e7faa5679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a6577aa6 +6988b05b7da85679a65679a65679a65f80ab5679a65679a65679a65679a6 +5b7da95b7da85679a65679a65679a65679a6577aa76a89b05e7faa5679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6a0b6d0e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf67492b75679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +c2d3e4e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf65a7ca85679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a6e4eaf1b0c0d55679a65679a65679a65679a6fdfdfe +98adc95679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6a0b6d0e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf67492b75679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +c2d3e4e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf65a7ca85679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a67995b86d8bb25679a65679a65679a65679a6809abc +6686ae5679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6a0b6d0e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf67492b75679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +c2d3e4e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf65a7ca85679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6a0b6d0e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf67492b75679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +c2d3e4e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf65a7ca85679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6a0b6d0e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf67492b75679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +c2d3e4e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf65a7ca85679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6a0b6d0e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf67492b75679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +c2d3e4e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf65a7ca85679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6a0b6d0e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf67492b75679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +c2d3e4e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf65a7ca85679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6a0b6d0e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf67593b85679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +c3d3e5e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf65e80ab5679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6a3b9d2e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf691aac85679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +d7e3f0e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6809cbe5679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6bccee1e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6bccde15679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a66888b0 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6a8bdd55679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6577aa7d9e6f2e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6deeaf45e80ab5679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a685a0c1 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6d0deec5679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a66e8db4e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf685a0c15679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65e7faacad9e9 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf66d8cb3 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a6587aa7b8cadee1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6ccdaea6988b15679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6587aa7baccdfe1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6c5d5e6 +6384ae5679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a6a8bdd5e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6d6e3f07794b95679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6a6bbd4e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +d0deec6d8cb35679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a697afcbe1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6dee9f489a3c35679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a6587ba77996baa9bed6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6d9e5f17b97bb5679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a6708eb59eb5cfe0ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6cddcebb0c3da93abc9829dbf +819dbf819dbf819dbf819dbf819dbf819dbf819dbf819dbf819dbf819dbf +819dbf819dbf819dbf819dbf819dbf819dbf819dbf819dbf819dbf819dbf +819dbf819dbf819dbf819dbf819dbf819dbf819dbf819dbf819dbf819dbf +819dbf819dbf819dbf819dbf819dbf819dbf819dbf819dbf819dbf819dbf +819dbf819dbf819dbf819dbf819dbf819dbf819dbf819dbf819dbf819dbf +819dbf819dbf819dbf819dbf819dbf819dbf819dbf819dbf819dbf819dbf +819dbf819dbf819dbf819dbf819dbf819dbf819dbf819dbf819dbf819dbf +819dbf819dbf819dbf819dbf819dbf819dbf819dbf819dbf819dbf819dbf +819dbf819dbf819dbf819dbf819dbf819dbf819dbf819dbf819dbf819dbf +819dbf819dbf819dbf819dbf819dbf819dbf819dbf819dbf819dbf819dbf +819dbf819dbf8aa4c4b1c4dad8e5f1e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e0ecf6cbdae9adc1d88fa8c77996ba7895ba7895ba7895ba +7895ba7895ba7895ba7895ba7895ba7895ba7895ba7895ba7895ba7895ba +7895ba7895ba7895ba7895ba7895ba7895ba7895ba7895ba7895ba7895ba +7895ba7895ba7895ba7895ba7895ba7895ba7895ba7895ba7895ba7895ba +7895ba7895ba7895ba7895ba7895ba7895ba7895ba7895ba7895ba7895ba +7895ba7895ba7895ba7895ba7895ba7895ba7895ba7895ba7895ba7895ba +7895ba7895ba7895ba7895ba7895ba7895ba7895ba7895ba7895ba7895ba +7895ba7895ba7895ba7895ba7895ba7895ba7895ba7895ba7895ba7895ba +7895ba7895ba7895ba7895ba7895ba7895ba7895ba7895ba7895ba7895ba +7895ba7895ba7895ba7895ba7895ba7895ba7895ba7895ba7895ba7895ba +7895ba7895ba7895ba7895ba7895ba7895ba7895ba7895ba7895ba7895ba +7895ba7895ba7895ba7895ba7895ba7895ba7895ba7895ba7895ba7895ba +839ec0aabed6d2e0eee1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +ffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffff +ffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffff +ffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffff +ffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffff +ffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +ccd6df90979d7c8287a0a8afdee9f3e1ecf6e1ecf6a1a8b08c9399969da4 +aeb6beced8e1e1ecf6e1ecf6e1ecf69aa1a88c93998d949aacb4bcd8e3ec +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6a3abb2 +0d0e0e0000001011110000002d2f31d3dde7e1ecf636383b000000040505 +0000000506066a6f74e1ecf6e1ecf6222325020202222426070708040404 +c0cad2e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6dde7f1171819 +050606b4bdc5dde8f26a6f74000000656a6fe1ecf636383b000000dbe6ef +aeb6be383a3d000000898f96e1ecf62223250f1010e1ecf69fa7ae000000 +72777ce1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6bbc4cd000000 +3b3e41e1ecf6e1ecf6c7d1da0000002e3032e1ecf636383b000000dde7f1 +e1ecf6a3abb2000000474b4ee1ecf62223250404043f42441a1c1d131314 +bcc5cde1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6b6bfc7000000 +434649e1ecf6e1ecf6ced9e2010101292b2ce1ecf636383b000000dde7f1 +e1ecf6adb5bd000000434649e1ecf622232507070870767b4a4e51010101 +7a8085e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6d9e4ed0b0c0d +0b0b0cced9e2e1ecf6858c92000000585d60e1ecf636383b000000dde7f1 +c9d3dc474b4e0000007a8085e1ecf62223250f1010e1ecf6d8e3ec040404 +313436e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf68b9197 +03030309090a303234000000151617c7d1dae1ecf636383b0000001e1f21 +010101000000474a4ddde7f1e1ecf62223250404043f42441f2022000000 +838a90e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +b4bdc56f757a5e62667e848ad3dde7e1ecf6e1ecf68b929870767b797f84 +8d949ab0b9c1e1ecf6e1ecf6e1ecf682888e70767b70767b868d93bcc5cd +e0ebf5e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e0ebf5c2d3e4a0b6d0 +9bb2ce9bb2ce9bb2ce9bb2ce9bb2ce9bb2ce9bb2ce9bb2ce9bb2ce9bb2ce +9bb2ce9bb2ce9bb2ce9bb2ce9bb2ce9bb2ce9bb2ce9bb2ce9bb2ce9bb2ce +9bb2ce9bb2ce9bb2ce9bb2ce9bb2ce9bb2ce9bb2ce9bb2ce9bb2ce9bb2ce +9bb2ce9bb2ce9bb2ce9bb2ce9bb2ce9bb2ce9bb2ce9bb2ce9bb2ce9bb2ce +9bb2ce9bb2ce9bb2ce9bb2ce9bb2ce9bb2ce9bb2ce9bb2ce9bb2ce9bb2ce +9bb2ce9bb2ce9bb2ce9bb2ce9bb2ce9bb2ce9bb2ce9bb2ce9bb2ce9bb2ce +9bb2ce9bb2ce9bb2ce9bb2ce9bb2ce9bb2ce9bb2ce9bb2ce9bb2ce9bb2ce +9bb2ce9bb2ce9bb2ce9bb2ce9bb2ce9bb2ce9bb2ce9bb2ce9bb2ce9bb2ce +9bb2ce9bb2ce9bb2ce9bb2ce9bb2ce9bb2ce9bb2ce9bb2ce9bb2ce9bb2ce +9bb2ce9bb2ce9bb2ce9bb2ce9bb2ce9bb2ce9bb2ce9bb2ce9bb2ce9bb2ce +9bb2ce9bb2cea4b9d3c1d2e4dde8f3e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6dde9f4dde8f3dde8f3dde8f3 +dde8f3dde8f3dde8f3dde8f3dde8f3dde8f3dde8f3dde8f3dde8f3dde8f3 +dde8f3dde8f3dde8f3dde8f3dde8f3dde8f3dde8f3dde8f3dde8f3dde8f3 +dde8f3dde8f3dde8f3dde8f3dde8f3dde8f3dde8f3dde8f3dde8f3dde8f3 +dde8f3dde8f3dde8f3dde8f3dde8f3dde8f3dde8f3dde8f3dde8f3dde8f3 +dde8f3dde8f3dde8f3dde8f3dde8f3dde8f3dde8f3dde8f3dde8f3dde8f3 +dde8f3dde8f3dde8f3dde8f3dde8f3dde8f3dde8f3dde8f3dde8f3dde8f3 +dde8f3dde8f3dde8f3dde8f3dde8f3dde8f3dde8f3dde8f3dde8f3dde8f3 +dde8f3dde8f3dde8f3dde8f3dde8f3dde8f3dde8f3dde8f3dde8f3dde8f3 +dde8f3dde8f3dde8f3dde8f3dde8f3dde8f3dde8f3dde8f3dde8f3dde8f3 +dde8f3dde8f3dde8f3dde8f3dde8f3dde8f3dde8f3dde8f3dde8f3dde8f3 +dde8f3dde8f3dde8f3dde8f3dde8f3dde8f3dde8f3dde8f3dde8f3dde8f3 +deeaf4e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6b4c7dc8aa4c46182ad5679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a6597ba87f9bbed8e4f1e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6dfebf5c0d1e397afcb6d8cb35679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +577aa76d8cb38da6c5acc0d7dce8f3e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf69eb5cf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a66b8bb2cddcebe1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6abbfd76082ac5679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a67492b7d5e2efe1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6b3c6db5779a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a66081acbfd0e2e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +b9cbdf587aa75679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a66888b0cbdae9e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6c4d4e55b7da95679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65b7ea9dce8f3 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6c7d6e7 +5d7eaa5679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65f81abc3d3e5e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf66b8bb25679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a6b8cade +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6d5e2ef6585ae +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6849fc0e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6d7e4f05679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a68da7c6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6acc0d75679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65e7faadeeaf4e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6bbcce05679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a66484ae +e0ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf68da6c55679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6bccde1e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6a3b9d25679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +cbdae9e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf66d8cb35679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a693abc9e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6a0b6d05679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +c7d6e7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf65a7da95679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a67996bae1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6a0b6d05679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +c7d6e7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf65a7ca85679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a67895bae1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6a0b6d05679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +c7d6e7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf65a7ca85679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a67895bae1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6a0b6d05679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +c7d6e7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf65a7ca85679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a67895bae1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6a0b6d05679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +c7d6e7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf65a7ca85679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a67895bae1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6a0b6d05679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +c7d6e7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf65a7ca85679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a67895bae1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6a0b6d05679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +c7d6e7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf65a7ca85679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a67895bae1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6a0b6d05679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6577aa7577aa7 +577aa7577aa7577aa7587ba7577aa7577aa7577aa7577aa7577aa7577aa7 +577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7 +577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7 +577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7 +577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7 +6989b17894b8577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7 +577aa7577aa7587ba7577aa7577aa7577aa7577aa7577aa7577aa7577aa7 +577aa7577aa7577aa75a7ca87c97ba6283ad577aa7577aa7577aa7577aa7 +577aa7577aa7577aa7577aa75679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +c7d6e7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf65a7ca85679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a6577aa65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6577aa65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +6887afdbe2ec7995b85679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a67895bae1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6a0b6d05679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6577aa7577aa7577aa7 +577aa77f99bce1e8effbfcfdd4dde8587ba8577aa7577aa7577aa7577aa7 +577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7 +577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7 +577aa7577aa7577aa7577aa7577aa7577aa76081acbbc9db7693b7577aa7 +577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7 +adbed4eef1f6577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7 +a2b5ceedf1f6fbfcfda2b5ce577aa7577aa7577aa7577aa7577aa7577aa7 +577aa7577aa7577aa76585afffffff8ca4c3577aa7577aa7577aa7577aa7 +577aa7577aa7577aa7577aa75679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +c7d6e7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf65a7ca85679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65e7faacdd8e5fafbfcd6dfea6484ae577aa7d6dfeae9edf3d5dee9 +9aafca577aa76282adf0f3f7f0f3f7e1e7efb3c2d75c7ea9577aa7577aa7 +577aa7577aa7577aa7577aa7577aa76585aecdd7e5f9fafceef1f66b8ab1 +577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7 +577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7 +577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7 +577aa7577aa7577aa7577aa7577aa789a2c1ebeff4e8edf3c6d2e18aa3c2 +577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7 +577aa7577aa7577aa7577aa78ba3c2afbfd5577aa7577aa7577aa7577aa7 +6e8cb3ffffff849dbe577aa7577aa7577aa7577aa7577aa7577aa7577aa7 +577aa7577aa75679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a67895bae1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6a0b6d05679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6577aa7577aa7577aa7 +6081abf6f8faecf0f5a7b9d1d7dfea5a7da9577aa7577aa7587ba8577aa7 +577aa7577aa7577aa7577aa7577aa7587ba8577aa7577aa7577aa7577aa7 +587ba8577aa7577aa7577aa7577aa7577aa7577aa75a7ca8577aa7577aa7 +577aa75a7ca8587ba8577aa7577aa7577aa76787afffffff8ba3c2577aa7 +577aa7577aa7577aa7587ba8577aa7577aa7577aa7577aa7577aa7587ba8 +adbed4eef1f6577aa7577aa7577aa7577aa7577aa7577aa7577aa787a0c0 +ffffffd9e1eba7bad1abbcd3577aa7577aa7577aa7587ba8577aa7577aa7 +577aa7577aa7587ba86585afffffff8ca4c3577aa7577aa7587ba7577aa7 +577aa7577aa7577aa7577aa75679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +c7d6e7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf65a7ca85679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a6aabcd2fcfcfdb7c6d9f8f9fbbac8db577aa7e9edf3dbe3ecdfe5ee +ffffff92a8c66383adffffffafbfd5a0b4cdfcfdfe92a8c6577aa7577aa7 +577aa7577aa7577aa7577aa7577aa7ccd6e4fbfcfdb6c5d9c2cedf7390b6 +577aa7577aa7587ba8577aa7577aa7577aa7577aa7577aa7587ba8587ba7 +587ba7577aa7577aa7587ba7587ba7587ba8577aa7577aa7577aa7577aa7 +587ba8577aa7577aa7577aa7577aa7577aa7587ba8577aa7577aa7577aa7 +577aa7577aa7577aa7577aa7577aa790a7c5ffffffa9bbd2d7dfeaf2f5f8 +5a7ca8577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7 +587ba8577aa7577aa7577aa7afc0d5ebeff5577aa7577aa7577aa7577aa7 +577aa7577aa7577aa7577aa7577aa7577aa7587ba8577aa7587ba8577aa7 +577aa7577aa75679a6577aa75679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a67895bae1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6a0b6d05679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6577aa7577aa7577aa7 +93a9c6ffffff7a96b9577aa75a7da9587ba75d7faaacbdd4f2f5f8d2dce8 +7f99bc577aa7afc0d5d6dfeadbe2ecebeff57b97ba577aa76d8cb3c2cedf +f6f8fabecbdd6888b0577aa7869fc0f0f3f7b5c5d8f9fafcced8e5577aa7 +cad5e3fefefef1f4f8bbc9db577aa79aafcaf1f4f8fffffff4f7f9f0f3f7 +6989b1587ba7a1b5ceebeff5dbe3ec8ba3c2577aa76a89b1ced8e5f2f5f8 +ccd6e4eef1f6577aa7577aa7577aa7577aa7577aa7577aa7577aa7c4d0e0 +f4f6f9587ba7577aa7587ba7577aa77995b9d0d9e6eff2f7a5b8d0597ca8 +577aa7a3b7cff4f6f9c0cddeffffff8ca4c3577aa794aac7e3e9f1e5eaf1 +99aeca577aa7577aa7577aa75679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +c7d6e7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf65a7ca85679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a6dce3edcfd9e65679a6bccadcecf0f5577aa7e9edf3b2c2d7577aa7 +e3e9f1d0d9e66383adffffff849ebf587ba7eef1f6a5b8d0577aa7577aa7 +577aa7577aa7577aa7577aa76182acfefefeb0c0d6577aa7577aa7587ba7 +577aa7a1b4ceecf0f5d5dee97e99bb577aa7dbe3ecdde4ede7ecf3dbe3ec +dce3ed5a7ca8f0f3f7dfe5eed8e0ebebeff4c5d1e1577aa76d8cb3c3d0e0 +f4f6f9b3c2d76081ac577aa7dbe2ecc4d0e0f2f5f8d7e0ea5f80ab577aa7 +577aa7577aa7577aa7577aa7577aa790a7c5ffffff6282ad839dbeffffff +7591b78ea5c4f0f3f75e7faa9cb1cbe3e9f1577aa79aafcae6ebf2c9d4e3 +f2f5f88ba3c2577aa7dbe3ecf8f9fbfefefef0f3f7c0cdde577aa7a0b4cd +f0f3f7f0f3f7809abc577aa786a0c0dde4edf6f8fac8d4e2f7f9fb97adc8 +577aa7859fbfd9e1ebedf1f6a8bad1577aa65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a67895bae1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6a0b6d05679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6577aa7577aa7577aa7 +a8bad1fcfcfd5c7ea97d98bb819bbd6283ad90a7c5f4f6f9869fc0bfccde +dde4ed577aa7b9c7dafdfdfe91a8c5edf1f6b4c4d8577aa7c1cedfd6dfea +829cbde0e6efadbed4577aa78aa3c2ffffffd2dbe78aa3c297adc8577aa7 +9cb1cb7390b6809abcfefefe7390b66b8ab292a8c6ffffffacbdd486a0c0 +5c7eaa7995b9fdfdfe8da5c3aebfd5f2f5f8587ba8a9bbd2f2f5f899aeca +eff2f7eef1f6577aa7577aa7577aa7577aa7577aa7577aa7577aa7d9e1eb +d4dde9577aa7577aa7577aa7577aa7d9e1ebd2dbe798aec9fcfdfe809abc +6283adfefeffb7c6d9c5d1e1ffffff8ca4c36585aefefefe9db2cc9cb0cb +fdfdfe6484ae577aa7577aa75679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +c7d6e7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf65a7ca85679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a6edf1f6bbc9db5679a6a7bad1fdfdfe597ca8e9edf3b2c2d7577aa7 +c4d1e0e5ebf26383adffffffe9edf3eff2f6d1dae76686af577aa7577aa7 +577aa7577aa7577aa7577aa77591b7ffffff90a7c5577aa7577aa7577aa7 +7592b7ffffff9fb3cdc8d4e2e3e9f1577aa7e9eef4a7bad1f7f9fba3b7cf +fafbfd6b8ab1ffffff9fb3cdffffff9fb3cdf8fafc577aa7beccdde2e8f0 +92a9c6f2f5f89aafca577aa7e9edf3e4eaf198adc9ffffff849dbe577aa7 +577aa7577aa7577aa7577aa7577aa790a7c5ffffffa9bbd2d7dfeae9eef4 +5a7ca894aac7ffffff5e80aba3b7cff2f5f8577aa7a1b5ceffffff9db2cc +dfe5eecbd6e4577aa7809abcc6d2e1f1f4f886a0c07794b8577aa76d8cb3 +97adc8ffffff849dbe577aa78ca4c3f4f6f9abbcd3f0f3f7afbfd5c6d2e1 +587ba8f1f4f8b1c2d68aa2c1fcfcfd7a95b95679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a67895bae1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6a0b6d05679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6577aa7577aa7577aa7 +aabcd2fafbfc5a7ca8f1f4f8ffffff849ebfc3d0e0ecf0f5c0cdded0d9e6 +fefeff6787b0b9c7dae3e9f1577aa7cbd6e4ccd7e4587ba8f2f5f8dae2ec +c0cddee2e8f0dfe5ee577aa78aa3c2ffffff708eb4577aa7577aa7577aa7 +9eb2ccd5dee9eff2f7fefeff9bb0cb577aa76787afffffff8ba3c2577aa7 +577aa7adbed4f4f7f9c0cddec7d3e2ffffff7d98bbcdd7e5c6d2e1577aa7 +beccddeef1f6577aa7577aa7577aa7577aa7577aa7577aa7577aa7dbe2ec +d0dae6577aa7577aa7577aa76383adfefefe869fc0577aa7dfe5eeb3c2d7 +869fc0ffffff6484ae7794b8ffffff8ca4c396acc8fdfdfec0cddec0cdde +fefefe94abc7577aa7577aa75679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +c7d6e7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf65a7ca85679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a6eef2f6b9c7da5679a6a5b8d0fefeff5a7da9e9edf3b2c2d7577aa7 +c1cedfe8edf36383adffffffb7c6d9abbdd3f0f3f794abc7577aa7577aa7 +577aa7577aa7577aa7577aa77793b8ffffff8ca4c3577aa7577aa7577aa7 +a6b9d0eaeef4577aa77b97baffffff6e8cb3e9eef488a1c1eaeef4829cbe +eff2f77f99bcffffff728fb5ffffff728fb5ffffff6585aeeff2f6a1b4ce +577aa7c4d0e0ced8e5577aa7e9edf3b3c3d7587ba7fafbfd9cb1cb577aa7 +577aa7577aa7577aa7577aa7577aa790a7c5fffffff5f7fafefefe7f99bc +577aa794aac7ffffff5e80aba3b7cff2f5f8577aa7a1b5cef9fafc587ba8 +b4c4d8e3e9f1577aa7577aa7afc0d5ebeff5577aa7577aa7577aa7577aa7 +6e8cb3ffffff849dbe577aa78ca4c3e5ebf28ca4c3e0e6ef91a8c5dbe2ec +7d98bbffffffc7d2e1c0cddef4f7f9adbed45679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a67895bae1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6a0b6d05679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6577aa7577aa7577aa7 +97adc8ffffff7793b86081acf7f9fb849ebfd5dee9e6ebf2b1c1d6b1c1d6 +b1c1d66a89b1b9c7dadde4ed577aa7c8d4e2cdd7e55e7faafefeffcfd9e6 +b1c1d6b1c1d6aabcd2577aa78aa3c2ffffff6787b0577aa7577aa76e8cb3 +fefeffb9c7da839dbefefefea3b7cf577aa76787afffffff8ba3c2577aa7 +577aa7beccddf1f4f7b1c1d6b1c1d6b1c1d67793b8d1dae7c2cedf577aa7 +bac9dbeef1f6577aa7577aa7577aa7577aa7577aa7577aa7577aa7c8d3e2 +f0f3f7577aa7577aa7577aa76787b0fefeff819bbd577aa7dbe3ecb9c7da +8aa2c2ffffff6182ac7390b6ffffff8ca4c3a8bad1fbfcfdb1c1d6b1c1d6 +b1c1d6829cbe577aa7577aa75679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +c7d6e7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf65a7ca85679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a6dfe6eecdd7e45679a6b9c8daeff2f7577aa7e9edf3b2c2d7577aa7 +dee5eed3dce86383adffffff849ebf577aa7c5d1e1d2dce8577aa7577aa7 +577aa7577aa7577aa7577aa76484aeffffffabbdd3577aa7577aa7577aa7 +abbdd3e5ebf2577aa77794b8ffffff7390b6e9eef487a0c0e9eef4829cbd +eff2f6839dbeffffff718fb5ffffff718fb5ffffff6b8ab1f2f5f89cb1cb +577aa7c0cdded3dce8577aa7e9edf3adbed4577aa7f8fafc9db1cc577aa7 +577aa7577aa7577aa7577aa7577aa790a7c5ffffff6d8cb3e1e7efd5dee9 +577aa794aac7ffffff6081aba8bad1f2f5f8577aa7a1b5cef4f6f9577aa7 +b1c1d6e4eaf1577aa7577aa7afc0d5ebeff5577aa7577aa7577aa7577aa7 +6e8cb3ffffff849dbe577aa78ca4c3e5eaf18ca4c3dfe6ee91a8c5dfe6ee +8fa6c4ffffffb7c6d9b0c0d5b0c0d58fa6c45679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a67895bae1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6a0b6d05679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6577aa7577aa7577aa7 +6585aefafbfcdee5ee8ea5c4fafbfd849ebfb0c0d6f2f5f87f9abc6d8cb3 +a5b8d0577aa7b9c7dadde4ed577aa7c8d4e2cdd7e5577aa7e1e7efd2dce8 +728fb57894b898adc9577aa78aa3c2ffffff6787b0577aa7577aa7829cbe +ffffff819bbd8da5c3ffffffa3b7cf577aa75a7ca8f5f7fab5c4d87793b8 +5a7da99aafcafcfdfe88a1c16b8ab29bb0cb6686afacbdd4edf1f687a0c0 +e9eef4eef1f6577aa7577aa7577aa7577aa7577aa7577aa7577aa790a7c5 +ffffffc6d2e190a7c59eb2cc577aa7dfe5eec8d3e288a1c1fafbfd859fbf +6585afffffffa7b9d1b7c6d9ffffff8ca4c3839dbeffffff99aeca6a89b1 +91a8c57491b6577aa7577aa75679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +c7d6e7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf65a7ca85679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a6b2c2d7f7f9fba2b5cef0f3f7c1cedf577aa7e9edf3d2dbe7cad5e3 +fefeff99aeca6383adffffffa3b7cf8fa6c4ecf0f5bccadc577aa7577aa7 +577aa7577aa7577aa7577aa7577aa7d5dee9f4f6f9a1b4cea9bbd2718eb4 +7b96baffffff8fa6c4bdcbdce9edf3577aa7e9eef487a0c0e9eef4829cbd +eff2f6839dbeffffff718fb5ffffff718fb5ffffff6989b1c4d0e0dbe2ec +829cbeeef1f6a0b4cd577aa7e9edf3adbed4577aa7f8fafc9db1cc577aa7 +577aa7577aa7577aa7577aa7577aa790a7c5ffffff6282ad87a0c0ffffff +7b97ba7d98bbffffff93a9c6d8e0ebf2f5f8577aa7a1b5cef4f6f9577aa7 +b1c1d6e4eaf1577aa7577aa798adc9fafbfc809abc6d8bb2577aa7728fb5 +89a2c1ffffff9bb0cb7693b78ca4c3e5eaf18ca4c3dfe6ee91a8c5dfe6ee +6c8bb2fdfdfeadbed46b89b187a0c0819bbd5679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a67895bae1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6a0b6d05679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6577aa7577aa7577aa7 +577aa791a8c5f6f8fbffffffe5ebf26c8bb26484aed9e1ebffffffffffff +eaeef4577aa7b9c7dadde4ed577aa7c8d4e2cdd7e5577aa77e99bbf0f3f7 +fffffffefeffbac9db577aa78aa3c2ffffff6787b0577aa7577aa7597ca8 +d5dee9fcfcfddde4edfafbfda3b7cf577aa7577aa7a7b9d1eaeef4ffffff +6b8ab25b7da9ccd6e4fffffffffffff0f3f76787b0718eb4dfe6eefbfcfd +d3dce8eef1f6577aa7577aa7577aa7577aa7577aa7577aa7577aa7597ca8 +b7c6d9fcfdfeffffffaebfd5577aa7849dbedfe5eef8fafcb5c5d85a7da9 +577aa7b5c4d8fcfdfecfd9e6ffffff8ca4c3577aa7bac8dbffffffffffff +f5f7fa7995b9577aa7577aa75679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +c7d6e7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf65a7ca85679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a66585aee3e8f0ffffffeaeef46d8cb3577aa7e9edf3fefefeeaeef4 +adbed45a7ca86383adfffffffffffff2f5f8cad5e37390b6577aa7577aa7 +577aa7577aa7577aa7577aa7577aa76f8db4e2e8f0fffffffbfcfd6e8cb3 +587ba7b1c1d6f5f7fae3e9f189a2c1577aa7e9eef487a0c0e9eef4829cbd +eff2f6839dbeffffff718fb5ffffff718fb5ffffff6989b17592b7d3dce8 +fcfdfec2cfdf6484ae577aa7e9edf3adbed4577aa7f8fafc9db1cc577aa7 +577aa7577aa7577aa7577aa7577aa790a7c5ffffff6282ad587ba7e7ecf3 +c9d4e35a7da9dfe6eefcfdfed4dde9f2f5f8577aa7a1b5cef4f6f9577aa7 +b1c1d6e4eaf1577aa7577aa76787afd0dae6f9fafcccd6e4577aa7e7ecf3 +fffffffffffffffffffdfdfe8ca4c3e5eaf18ca4c3dfe6ee91a8c5dfe6ee +577aa7a3b6cffcfdfefffffff9fafc8da5c35679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a67895bae1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6a0b6d05679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6577aa7577aa7577aa7 +577aa7577aa7597ca86888b0577aa7577aa7577aa7577aa76585af6686af +577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7587ba8 +6a89b16081ab577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7 +577aa76484ae577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7 +577aa7577aa7577aa76283ad6888b0587ba7577aa7577aa7587ba86081ab +577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7 +577aa75d7faa6888b0577aa7577aa7577aa7577aa75f80ab577aa7577aa7 +577aa7577aa76182ac577aa7577aa7577aa7577aa7577aa75f80ab6a89b1 +597ca8577aa7577aa7577aa75679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +c7d6e7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf65a7ca85679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a66686ae577aa6577aa7577aa7577aa7577aa7577aa7 +577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7 +577aa7577aa7577aa7577aa7577aa7577aa7577aa76787af5f80ab577aa7 +577aa7577aa75e80ab587ba7577aa7577aa7577aa7577aa7577aa7577aa7 +577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7 +6081ab577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7 +577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7 +577aa7577aa7587ba76081ac577aa7577aa7577aa7577aa7577aa7577aa7 +577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7 +577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7 +577aa7577aa75b7da96b89b15a7ca85679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a67895bae1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6a0b6d05679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6577aa7577aa7 +577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7 +577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7 +577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7 +577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7 +577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7 +577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7 +577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7 +577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7577aa7 +577aa7577aa7577aa7577aa75679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +c7d6e7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf65a7ca85679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a67895bae1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6a0b6d05679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +c7d6e7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf65a7ca85679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a67895bae1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6a0b6d05679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +c7d6e7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf65a7ca85679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a67895bae1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6a0b6d05679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +c7d6e7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf65a7ca85679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a67895bae1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6a0b6d05679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +c7d6e7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf65a7ca85679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a67895bae1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6a0b6d05679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +c7d6e7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf65a7ca85679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a67895bae1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6a0b6d05679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +c7d6e7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf65a7ca85679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a67895bae1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6a0b6d05679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +c7d6e7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf65a7da95679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a67996bae1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6a5bad35679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +cbdae9e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf67592b85679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a68ca6c5e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6cad9e95679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65b7ea9 +dfebf5e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf69eb5cf5679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6abbfd7e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf66787b05679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a67895b9 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6c8d7e85679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6cad9e9e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf691aac85679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a69ab1cd +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf66687af +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a67895b9e0ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6bccee15679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a67592b8dde8f3 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6afc3d9 +587ba75679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a66b8bb2d7e4f0e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6a9bed6587ba75679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a66787b0d4e2efe1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +bbcce05d7faa5679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a66182adcedcebe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6bbcde05e80ab5679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65d7faac9d8e8e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6c7d7e76585ae5679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a66988b1c2d2e4e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6cad9e97592b8597ba85679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a6597ba87996baa3b9d2ceddebe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6d4e1eea8bdd589a3c36a8ab25679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +597ca87b97bba3b9d2ccdaeae1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6dde9f4c4d4e5acc0d7 +a8bdd5a8bdd5a8bdd5a8bdd5a8bdd5a8bdd5a8bdd5a8bdd5a8bdd5a8bdd5 +a8bdd5a8bdd5a8bdd5a8bdd5a8bdd5a8bdd5a8bdd5a8bdd5a8bdd5a8bdd5 +a8bdd5a8bdd5a8bdd5a8bdd5a8bdd5a8bdd5a8bdd5a8bdd5a8bdd5a8bdd5 +a8bdd5a8bdd5a8bdd5a8bdd5a8bdd5a8bdd5a8bdd5a8bdd5a8bdd5a8bdd5 +a8bdd5a8bdd5a8bdd5a8bdd5a8bdd5a8bdd5a8bdd5a8bdd5a8bdd5a8bdd5 +a8bdd5a8bdd5a8bdd5a8bdd5a8bdd5a8bdd5a8bdd5a8bdd5a8bdd5a8bdd5 +a8bdd5a8bdd5a8bdd5a8bdd5a8bdd5a8bdd5a8bdd5a8bdd5a8bdd5a8bdd5 +a8bdd5a8bdd5a8bdd5a8bdd5a8bdd5a8bdd5a8bdd5a8bdd5a8bdd5a8bdd5 +a8bdd5a8bdd5a8bdd5a8bdd5a8bdd5a8bdd5a8bdd5a8bdd5a8bdd5a8bdd5 +a8bdd5a8bdd5a8bdd5a8bdd5a8bdd5a8bdd5a8bdd5a8bdd5a8bdd5a8bdd5 +a8bdd5a8bdd5b4c7dcd9e6f2e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6cddbeaa9bed6 +85a0c16383ad5a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca8 +5a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca8 +5a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca8 +5a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca8 +5a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca8 +5a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca8 +5a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca8 +5a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca8 +5a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca8 +5a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca8 +5a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca8 +5a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca8 +5a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca8 +5a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca8 +5a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca8 +5a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca8 +5a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca8 +5a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca8 +5a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca8 +5a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca8 +5a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca8 +5a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca8 +5a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca8 +5a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca85a7ca86485ae8ea7c6 +b9cbdfdde9f4e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e0ecf69ab1cd6586af5679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65d7eaa849fc0c0d1e3e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e0ebf58da7c65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65b7da9bfd0e3e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6dfebf588a2c35679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65d7faac4d4e5e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6deeaf4839ec05679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a66081acc8d8e8e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6adc1d85679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a66383addce7f3e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6819cbe5679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bbcce0e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6dbe7f35a7da95679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a697afcbe1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6b4c7dc5679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a67391b7e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf688a2c35679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6587aa7d9e5f1e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6708fb55679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6bbcce0e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6708eb55679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6b5c8dde1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6708eb55679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6b5c8dde1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6708eb55679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6b5c8dde1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6708eb55679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6b5c8dde1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6708eb55679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6577aa65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6577aa65679a65679a6 +5679a65679a65679a6577aa65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a66384addbe2ec7e99bb5679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6b5c8dde1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6708eb55679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +6585aed7dfeafafbfccbd6e45d7faa5679a6e6ecf2e7ecf2d2dbe78ea5c3 +5679a6728fb5f0f3f7f0f3f7dce3edaabcd25679a65679a65679a65679a6 +5679a65679a65679a6b7c6d9eaeff46a89b090a7c4eaeff48da5c35679a6 +5679a65679a65679a65679a65679a66585aec2cfdff7f9fbecf0f58ea5c3 +5679a66686aed9e1ebfafbfccad5e35d7ea95679a6abbdd3d1dae75679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6839dbeeaeff4 +e8edf3c7d2e18ca4c35679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a687a0c0b2c2d75679a6 +5679a65679a65679a66787afffffff89a1c15679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6b5c8dde1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6708eb55679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +bdcadcf8f9fbb7c6d9fcfcfda7b9d15679a6fbfcfdd4dde8e6ebf2ffffff +7e99bb7491b6ffffffa2b5cea9bbd2ffffff7e99bb5679a65679a65679a6 +5679a65679a65679a6c5d1e1fefefe94aac7bfccddfefefe95abc75679a6 +5679a65679a65679a65679a65679a6a2b5ceeef1f68ea6c4a2b5cea0b4cd +5679a6bfccddf8f9fbb7c6d9fcfcfda5b8d05679a6b8c7dae2e8f05679a6 +5679a65679a65679a65679a65679a65679a65679a65679a68aa2c1ffffff +abbcd3d4dde8f6f8fa5b7da95679a65679a65679a65679a65679a65679a6 +5679a65679a65679a6577aa75679a65679a65679a6a9bbd2f1f4f85679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a6577aa7 +5679a6577aa75679a65679a65679a65679a6577aa75679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6b5c8dde1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6708eb55679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +eef2f6bdcbdc5679a6cdd8e5d9e1eb5679a6fbfcfd9fb3cc577aa7f4f6f9 +bdcadc7491b6ffffff718fb45c7ea9fafbfd92a8c55679a65679a65679a6 +5679a65679a65679a6c5d1e1e1e7efbdcbdce4eaf1e5ebf195abc7cbd6e4 +bfccdd5679a67793b7f0f3f77995b8c2cfdfdfe5ee5d7ea95679a65679a6 +5679a6f0f3f7bbc9db5679a6cfd9e6d7dfea5679a6b8c7dae2e8f05679a6 +5679a65679a65679a65679a65679a65679a65679a65679a68aa2c1ffffff +6786af7c97baffffff7a95b988a0c0f0f3f76282ac96acc8e8edf35679a6 +94aac7ebeff5c3d0e0f3f6f98fa6c45679a6d6dee9f7f9fbfefefff0f3f7 +c6d2e15679a69aafcaf0f3f7f0f3f7849ebe5679a6809bbcdee5eef4f6f9 +c9d4e2f7f9fb9bb0ca5679a6819bbdd6dee9eef2f6aabcd2597ba75679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6b5c8dde1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6708eb55679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a6577aa7 +fefefea9bbd25679a6b9c7daedf1f65679a6fbfcfd9fb3cc5679a6d7dfea +d3dce87491b6ffffffe4eaf1f2f4f8c5d1e05f80ab5679a65679a65679a6 +5679a65679a65679a6c5d1e1beccddf0f3f7dce3ede0e6ef95abc79fb3cc +f8f9fb5b7da9abbdd3eef2f6577aa788a1c1fbfcfdeef2f69bb0ca5679a6 +597ba7fefeffa7b9d15679a6bbc9dbebeff55679a6b8c7dae2e8f05679a6 +5679a65679a65679a65679a65679a65679a65679a65679a68aa2c1ffffff +abbcd3d4dde8edf1f65b7da88da5c3ffffff6384ad9db1cbf8f9fb5679a6 +9bb0caffffffa1b4cddae2ebd1dae75679a67d98bbc1cedef5f7fa869fbf +7894b85679a66b8ab192a8c5ffffff89a1c15679a6859ebff8f9fba6b8d0 +f4f7f9aabbd2ccd7e45679a6ecf0f5b6c5d988a0c0f9fafc809abc5679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6b5c8dde1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6708eb55679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a6597ba7 +fefeffa6b9d05679a6b7c6d9eff2f75679a6fbfcfd9fb3cc5679a6d3dce8 +d5dee97491b6ffffffabbcd3afc0d5f2f5f8859ebf5679a65679a65679a6 +5679a65679a65679a6c5d1e1b5c4d8e2e8f0b7c6d9e0e6ef95abc76585ae +fdfdfe89a1c1dfe5eeb6c5d95679a65679a67390b5d1dbe7ffffffabbdd3 +5a7ca8ffffffa4b7cf5679a6b8c7daebeff55679a6b8c7dae2e8f05679a6 +5679a65679a65679a65679a65679a65679a65679a65679a68aa2c1ffffff +f5f7fafefeff839dbe5679a68da5c3ffffff6384ad9db1cbf8f9fb5679a6 +9bb0cafdfdfe597ca8adbed4eaeef45679a65679a6a9bbd2f1f4f85679a6 +5679a65679a65679a66787afffffff89a1c15679a6859ebfebeff5859ebf +e6ebf28aa3c2e1e7ef7692b7ffffffc9d4e3c0cddef2f5f8b3c3d75679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6b5c8dde1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6708eb55679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +f2f4f8bbc9db5679a6cbd6e4dde4ed5679a6fbfcfd9fb3cc5679a6f0f3f7 +c0cdde7491b6ffffff718fb45679a6d7dfeabfcddd5679a65679a65679a6 +5679a65679a65679a6c5d1e1b5c4d86585ae5f80abe0e6ef95abc75679a6 +d1dae7d2dbe7ffffff7c97ba5679a65679a65679a65679a6c5d1e1e3e9f0 +5679a6f4f6f9b9c7da5679a6cdd7e4d5dde95679a6b8c7dae2e8f05679a6 +5679a65679a65679a65679a65679a65679a65679a65679a68aa2c1ffffff +718eb4dde4eddbe3ec5679a68da5c3ffffff6585aea2b5cef8f9fb5679a6 +9bb0cafafbfc5679a6abbcd3eaeef45679a65679a6a9bbd2f1f4f85679a6 +5679a65679a65679a66787afffffff89a1c15679a6859ebfeaeff4859ebf +e5ebf18aa3c2e5ebf188a0c0ffffffbac8dbb0c0d5b0c0d592a9c65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6b5c8dde1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6708eb55679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +c4d0e0f1f4f8a2b5cef6f8faafbfd55679a6fbfcfdc7d3e2d3dce8ffffff +869fbf7491b6ffffff95abc792a9c6f5f7faa9bbd25679a65679a65679a6 +5679a65679a65679a6c5d1e1b5c4d85679a65679a6e0e6ef95abc75679a6 +94aac7ffffffecf0f5577aa65679a6b2c2d790a7c47894b8dde4edc6d2e1 +5679a6c6d2e1f0f3f7a2b5cef7f9fbaebfd45679a6b8c7daedf1f696abc8 +96abc88aa3c25679a65679a65679a65679a65679a65679a68aa2c1ffffff +6786af809bbcffffff809bbc7592b6ffffff96acc8d3dce8f8f9fb5679a6 +9bb0cafafbfc5679a6abbcd3eaeef45679a65679a691a8c5fcfdfe819bbd +6d8bb25679a6708db4849dbeffffffa0b3cd7692b7869fbfeaeff4859ebf +e5ebf18aa3c2e5ebf16787affbfcfdb1c2d66b89b1849ebe849ebe5679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6b5c8dde1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6708eb55679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +6f8cb3ecf0f5ffffffe1e7ef6484ad5679a6fbfcfdfcfdfee7ecf2a0b4cd +5679a67491b6ffffffffffffeef2f6c5d1e06988b05679a65679a65679a6 +5679a65679a65679a6c5d1e1b5c4d85679a65679a6e0e6ef95abc75679a6 +5f80abfbfcfdb3c3d75679a65679a6adbed4fcfdfeffffffdee5ee7c97ba +5679a66f8db3ecf0f5fffffff2f4f85d7ea95679a6b8c7daffffffffffff +ffffffe2e8f05679a65679a65679a65679a65679a65679a68aa2c1ffffff +6786af5679a6e2e8f0cfd9e6577aa7dbe3ecfdfdfed3dce8f8f9fb5679a6 +9bb0cafafbfc5679a6abbcd3eaeef45679a65679a66282accfd9e6f8f9fb +d1dbe75679a6e1e7efffffffffffffffffffffffff88a0c0eaeff4859ebf +e5ebf18aa3c2e5ebf15679a69eb2ccfbfcfdfffffffafbfd92a9c65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6b5c8dde1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6708eb55679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a6577aa66686ae5679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +7c97baffffff7793b75679a65679a65679a65c7ea96585ae5679a65679a6 +5679a65679a6577aa67995b8f4f7f992a9c65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a66081ab5679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65b7da86b89b15b7da85679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6b5c8dde1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6708eb55679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a6b7c6d9 +fefeffc8d3e25679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a67693b75a7ca85679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6b5c8dde1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6708eb55679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a6708db4 +7894b8577aa65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6b5c8dde1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6708eb55679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6b5c8dde1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6708eb55679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6b5c8dde1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6708eb55679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6b5c8dde1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf67492b75679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6b5c8dde1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf693abc95679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6cad9e9e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6b6c9de5679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a66b8ab2e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6d8e5f1577aa75679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a696aecbe1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf67290b65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6c2d3e4e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf69cb3ce5679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a66484aee0ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6dfebf5839ec05679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a6597ca8b5c8dde1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6deeaf47e9abd5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65b7da9bacce0e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6dde8f37a97bb5679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65d7faabfd0e3e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6dbe7f392abc96686af5679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a66f8db4c4d4e5e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6c6d5e69bb2ce +6f8eb45679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a66687af8ba5c4 +b0c3dad4e2efe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6dbe7f3d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1 +d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1 +d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1 +d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1 +d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1 +d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1 +d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1 +d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1 +d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1 +d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1 +d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1 +d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1 +d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1 +d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1 +d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1 +d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1 +d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1 +d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1 +d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1 +d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1 +d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1 +d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1 +d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1 +d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d8e5f1d9e6f2e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +ffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +ffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffff +ffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffff +ffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ced8e154585c54585cbac3cce1ecf6e1ecf6 +70767b54585c90979de1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf69aa1a8575c604144475d6165b8c1c9e1ecf6e1ecf6c3cdd564696d +424548595d61a4acb3e1ecf6e1ecf6a1a8b054585cb4bdc5e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6d6e1ea54585c55595d656a6e7c8288b7c0c8 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6b0b9c1 +939ba1dfeaf4e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +4144472f3133e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6c2ccd400000000000054585ce1ecf6bdc6ce +0101010000005e6367e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +abb4bb000000383b3e5a5e62343739858c92e1ecf6b7c0c8080809040505 +474a4d10111100000081878de1ecf67a808500000099a0a7e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6d0dae4000000131314313335020202020202 +6e7479e1ecf6e1ecf6e1ecf6e0ebf5e1ecf6e1ecf6e1ecf6e1ecf654585c +000000dbe6efe1ecf6e1ecf6e1ecf6e0ebf5e1ecf6e1ecf6e1ecf6e1ecf6 +3133351c1e1fe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e0ebf5 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e0ebf5e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6c2ccd40000001e1f21060607ced8e15d6165 +1d1f200000005e6367b8c1ca141516878e94e1ecf6a4acb31415169da5ac +6d7277000000a6aeb5e1ecf6e1ecf6e0ebf5e1ecf6404446000000a3abb2 +e1ecf6d2dce60506060c0d0edfeaf47a808500000099a0a7e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6d0dae4000000424548e1ecf6ced8e11f2022 +000000b5bec6c5ced71e1f21040404191a1b565b5fd6e1ea81878d070708 +000000141516484c4fc6cfd81e1f21040404191a1b565b5fd6e0e9e1ecf6 +3133351617184d51540b0c0d5d6165d3dde7e1ecf63b3e410808090b0c0d +46494cb6bfc7e1ecf6a7afb62c2e300404041112127d8389e1ecf6b5bec6 +52565a0f1010414447a8b0b7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6c2ccd400000063686c1b1d1e64696d0a0a0b +7c82870000005e6367e1ecf630323427292ae1ecf655595d0e0f0fdae5ee +b6bfc70e0f0f00000013141564696dc9d3dce1ecf61516170a0a0bdde7f1 +e1ecf6e1ecf6383b3e000000c3cdd57a808500000099a0a7e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6d0dae4000000424548e1ecf6e1ecf66d7378 +000000878e94d0dae4a5adb4cad4dd91989e0000008f969cc4cdd63c3f42 +0000009da5acb2bbc3d0dae4a5adb4cad4dd92999f0000008f969ce1ecf6 +3133350000007d838973787d00000081878de1ecf69ea6adc7d0d9b5bec6 +131415515559e1ecf641444727292ac5ced7b3bcc4adb5bde1ecf6333638 +2d2f31bcc5cd494d50171819dee9f3e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6c2ccd4000000656a6f7b8186000000171819 +c5ced70000005e6367e1ecf692999f000000a9b1b80e0f0f5e6367e1ecf6 +e1ecf6d6e0e9838a903e414400000054585ce1ecf6222325020202d0dae4 +e1ecf6e1ecf6232527040505d8e3ec7a808500000099a0a7e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6d0dae4000000424548e1ecf6e1ecf652565a +000000939ba1ccd6df3d40431112120d0e0e00000053575be1ecf654585c +000000dbe6efe1ecf6ccd6df3d40431112120d0e0e00000052565ae1ecf6 +3133350d0e0ee0ebf5dde8f20606073f4244e1ecf65a5e621c1e1f0b0c0d +030303141516e1ecf6878e9409090a080809424548a9b1b8c2ccd4000000 +0d0e0e1c1e1f111212000000a3abb2e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6c2ccd4000000656a6fd3dde7151617787e83 +c9d3dc0000005e6367e1ecf6dde7f11617181d1f20000000b6bfc7e1ecf6 +a6aeb5bcc5cde1ecf6d2dce6080809424548e1ecf66065690000006c7176 +d7e2eb949ba200000037393ce1ecf67a80850000008b9197ccd6dfccd6df +d7e2ebe1ecf6e1ecf6e1ecf6d0dae40000003c3f42bec7cf7c82870a0a0b +111212ced8e172777c000000b5bec6b8c1ca0000004f5256e1ecf65d6165 +000000d0dae4e1ecf672777c000000b4bdc5b9c2cb0000004f5256e1ecf6 +313335010101c7d1dabcc5cd000000656a6fb0b8c0000000767c81dfeaf4 +18191a111212e1ecf6d6e0e9d8e3eca3abb21e1f21313436ccd6df010101 +404446c5ced7c5ced7adb5bdcfd9e3e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6c2ccd4000000656a6fe1ecf6e1ecf6e1ecf6 +c9d3dc0000005e6367e1ecf6e1ecf674797e0000002b2d2fe1ecf6e1ecf6 +686d7200000009090a030303050606a0a8afe1ecf6d4dee83b3e41000000 +040404000000292b2ccad4dde1ecf67a8085000000000000000000000000 +757b80e1ecf6e1ecf6e1ecf6d0dae4000000000000000000000000262829 +adb5bde1ecf69fa7ae0000002325272c2e300000004f5256e1ecf69ea6ad +030303050606656a6e9fa7ae0000002325272c2e300000004f5256e1ecf6 +3133350c0d0e1b1d1e070708131415b7c0c8d2dce60b0b0c131415282a2b +141516111212e1ecf6383a3d27292a35383a0405056f757ae1ecf6696e73 +0101012628292b2d2f040404cad4dde1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6dae5eea9b1b8c2ccd4e1ecf6e1ecf6e1ecf6 +dce6f0a9b1b8c0cad2e1ecf6e1ecf6b6bfc7000000848b91e1ecf6e1ecf6 +e0ebf5b9c2cb9aa1a8a4acb3d8e3ece1ecf6e1ecf6e1ecf6e1ecf6b8c1ca +91989e12131352565ae0ebf5e1ecf6c7d1daa9b1b8a9b1b8a9b1b8a9b1b8 +c7d0d9e1ecf6e1ecf6e1ecf6dde8f2a9b1b8a9b2b9b8c1c9cdd7e0e0ebf5 +e1ecf6e1ecf6e1ecf6c3cdd59ca4abd1dbe5a9b1b8bdc6cee1ecf6e1ecf6 +d1dbe5a9b2b9c0cad2e1ecf6c3cdd59ca4abd1dbe5a9b1b8bdc6cee1ecf6 +b5bec6b0b9c1cad4dd9da5acd9e4ede1ecf6e1ecf6d3dde79ba3aac4cdd6 +b7c0c8adb5bde1ecf6c8d2db9ca4ab959ca3c1cbd3e1ecf6e1ecf6e1ecf6 +bbc4cd959ca39aa2a9c7d1dae1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf67c82880f10102b2d2fdde8f2e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6b1bac254585cadb5bde1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6bfc8d0afb7bfdde8f2e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +ffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +ffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffff +ffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffff +ffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffff + + +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffe1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6adb5bd54585cc7d1dae1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6b9c2cb131314e1ecf6 +e1ecf6202123acb4bce1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6b8c1c9c0cad2 +e1ecf6e1ecf6e1ecf6171819b5bec6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6cad4dd676c71414447404446 +6a6f74c8d2dbe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6232527b0b8c0e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6474a4d12131371767be1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6b9c2cb131314e1ecf6e1ecf69fa7aecfd9e3e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf65a5e62797f84e1ecf6e1ecf6e1ecf69ba3aad2dce6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +b3bcc4111212606569a8b0b7a9b2b96f757a414447e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +232527b0b8c0e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6cdd7e00a0a0b9ca4ab1b1d1edfeaf4 +e1ecf6e1ecf6b6bfc79ca4aba9b2b9656a6e787e83d8e3ece1ecf6e1ecf6 +8b9298c1cbd382888e61666a9fa7aee1ecf6e1ecf6b9c2cb131314e1ecf6 +e1ecf6878e94c8d2dbe1ecf6e1ecf6bfc8d071767b5b5f637d8389d7e2eb +e1ecf6a2aab2676c715d6165838a90dae5eee1ecf6b6bfc7303234404345 +777d829aa1a8e1ecf683898fcdd7e0e1ecf6e1ecf6abb4bb666b706a6f74 +b4bdc5e1ecf6e1ecf6c3cdd590979db8c1ca6a6f748b9197d8e3ece1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf62f31336d7277e1ecf6e1ecf6e1ecf6 +e1ecf6d6e1eae1ecf6e1ecf6b6bfc76a6f74656a6fa9b2b9e1ecf6e1ecf6 +e1ecf6c9d3dc6d73786b7075bbc4cd232527b0b8c0e1ecf6e1ecf6bcc5cd +6e74796065699ba3aae1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +797f84494d50e1ecf6202123a4acb3e1ecf6e1ecf6858c921a1b1c383b3e +8c9399343739383b3ee1ecf6e1ecf62a2c2e24262864696d797f84121313 +92999fe1ecf6b9c2cb131314e1ecf6e1ecf6202123acb4bce1ecf6a7afb6 +0e0f0f565a5e969da46e7479c3cdd5e1ecf663686c8e959b8e959b3d4043 +404446e1ecf6c1cbd33b3e414f5357939ba1acb4bce1ecf6171819b5bec6 +e1ecf6969da40f101070767b676c710e0f0fa2aab2e1ecf6a0a8af151617 +3e4144898f9646494c3c3f42e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6cad4dd +000000c7d1dae1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6aab3ba0d0e0e +656a6e72777c1112128e959be1ecf6d6e0e91a1b1c4b4f52888f95313335 +0f1010b0b8c0e1ecf6a9b1b81718196c7176848b912325277f858be1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf62224269ea6ade1ecf673787d4c5053 +e1ecf6e1ecf6858c92070708dae5eee1ecf6d9e4ed060607acb4bce1ecf6 +2a2c2e5a5e62e1ecf6e1ecf6858c92252729e1ecf6b9c2cb131314e1ecf6 +e1ecf6202123acb4bce1ecf6313335696e73e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6d5dfe8bec7cf060607d2dce6e1ecf65a5e62797f84 +e1ecf6e1ecf6e1ecf6171819b5bec6e1ecf627292a7c8288e1ecf6e1ecf6 +6d727736383be1ecf6a0a8af040404d1dbe5e1ecf6d3dde709090ad8e3ec +e1ecf6e1ecf6e1ecf6e1ecf6abb4bb050606e0ebf5e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf63e4144656a6ee1ecf6e1ecf6838a901e1f21e1ecf6 +82888e27292ae1ecf6e1ecf6b7c0c8000000b0b8c0e1ecf63133357e848a +e1ecf6e1ecf6a5adb4191a1be1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6acb4bc +0b0b0cb3bcc4b7c0c89ba3aa050606d0dae4e1ecf6858c923a3d40e1ecf6 +e1ecf6e1ecf6383b3e8a9096e1ecf62a2c2e949ba2e1ecf6e1ecf6bfc9d1 +040404dfeaf4b9c2cb131314e1ecf6e1ecf6202123acb4bce1ecf60a0a0b +afb7bfe1ecf6e1ecf6e1ecf6e1ecf6e1ecf681878d2f313327292a383a3d +060607b9c2cbe1ecf65a5e62797f84e1ecf6e1ecf6e1ecf6171819b5bec6 +dee9f3040404bac3cce1ecf6e1ecf6a7afb6131415e1ecf6a0a8af2e3032 +e1ecf6e1ecf6e1ecf61a1b1cb9c2cbe1ecf6e1ecf6e1ecf6e1ecf6bdc6ce +000000d5dfe8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf618191aa3abb2 +e1ecf6e1ecf6bec7cf010101dde7f15e63675e6266e1ecf6e1ecf6e0ebf5 +111212b0b8c0e1ecf6070708222426292b2d292b2d282a2b000000dce6f0 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf654585c1d1f20313335313335313335141516 +7f858be1ecf6858c92222426e1ecf6e1ecf6e1ecf6212224959ca3e1ecf6 +2a2c2e7c8288e1ecf6e1ecf6a8b0b70e0f0fe1ecf6b9c2cb131314e1ecf6 +e1ecf6202123acb4bce1ecf618191a929aa0e1ecf6e1ecf6e1ecf6e1ecf6 +ccd6df151617d2dce6e1ecf6d0dae4040404b8c1cae1ecf65b5f63787e83 +e1ecf6e1ecf6e1ecf6171819b5bec6e1ecf60e0f0fa3abb2e1ecf6e1ecf6 +8e959b202123e1ecf6a0a8af323537e1ecf6e1ecf6e1ecf61a1b1cb8c1ca +e1ecf6e1ecf6e1ecf6e1ecf6dce6f00c0d0e989fa6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf62628298b9298e1ecf6e1ecf6a5adb409090ae1ecf6 +6b7075474a4de1ecf6e1ecf6d6e0e9040404b0b8c0e1ecf61313149aa1a8 +dae5eedae5eedae5eedae5eee1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6d5dfe809090a +b8c1cae1ecf6e1ecf6e1ecf690979d282a2be1ecf6858c92000000aab3ba +e1ecf6a9b1b8080809ccd6dfe1ecf62a2c2e313436d3dde7dce6f055595d +4d5154e1ecf6b9c2cb131314e1ecf6e1ecf6202123acb4bce1ecf65f6468 +393c3fcdd7e0e1ecf6dce6f0dae5eeb6bfc718191adde7f1dee9f372777c +000000b8c1cae1ecf683898f54585ce0ebf5e1ecf6e1ecf6171819b5bec6 +e1ecf64f53574d5154d7e2ebd3dde73d40435e6266e1ecf6a0a8af323537 +e1ecf6e1ecf6e1ecf61a1b1cb8c1cae1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +7e848a1c1e1fb5bec6e1ecf6e1ecf6c3cdd5757b80e1ecf6676c713a3d40 +d2dce6d8e3ec4f525646494ce1ecf6a9b2b90f1010c3cdd5e1ecf681878d +000000b0b8c0e1ecf6595d613c3f42cfd9e3e1ecf6e1ecf6c0cad2e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6878e94262829e1ecf6e1ecf6e1ecf6e1ecf6d7e2eb +0b0b0cb1bac2858c923f424435383a23252707070890979de1ecf6e1ecf6 +2a2c2e666b701a1b1c18191a282a2bc9d3dce1ecf6b9c2cb131314e1ecf6 +e1ecf6202123acb4bce1ecf6d5dfe84b4f520506062e30321d1f20c1cbd3 +e1ecf6505458191a1b1f20225e6367191a1bb8c1cae1ecf6c8d2db434649 +171819565a5ee1ecf6171819b5bec6e1ecf6ccd6df35383a1112120c0d0e +404345d1dbe5e1ecf6a0a8af323537e1ecf6e1ecf6e1ecf61a1b1cb8c1ca +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e0ebf5848b911313141a1c1d1c1e1f +1617188a9096e1ecf6d5dfe84346490b0c0d121313323537c7d1dae1ecf6 +e1ecf66a6f74050606222426515559202123b0b8c0e1ecf6d6e0e9515559 +0506062d2f311e1f21565b5fe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6858c924e5155e1ecf6 +ced8e1dbe6efe1ecf6e1ecf6e1ecf62a2c2ea9b1b8dee9f3cbd5dee1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6d7e2ebc6cfd8dce6f0e1ecf6e1ecf6e1ecf6d4dee8d9e4ede1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6d0dae4d3dde7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6ced9e2ced8e1e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +d4dee8cfd9e3e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6d6e0e9d3dde7e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6dbe6efc5ced7d9e4ede1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6858c924e5155e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +2a2c2ea9b1b8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6b6bfc79ca4abe1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf68b9298c7d0d9e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e7f0f7e7eef5e7eef5e7eef5e7eef5e7eef5e7eef5 +e7eef5e7eef5e7eef5e7eef5e7eef5e7eef5e7eef5e7eef5e7eef5e7eef5 +e7eef5e7eef5e7eef5e7eef5e7eef5e7eef5e7eef5e7eef5e7eef5e7eef5 +e7eef5e7eef5e7eef5e7eef5e7eef5e7eef5e7eef5e7eef5e7eef5e7eef5 +e7eef5e7eef5e7eef5e7eef5e7eef5e7eef5e7eef5e7eef5e7eef5e7eef5 +e7eef5e7eef5e7eef5e7eef5e7eef5e7eef5e7eef5e7eef5e7eef5e7eef5 +e7eef5e7eef5e7eef5e7eef5e7eef5e7eef5e7eef5e7eef5e7eef5e7eef5 +e7eef5e7eef5e7eef5e7eef5e7eef5e7eef5e7eef5e9eff6e4eef7e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6a0b4cd +7b96ba7b96ba7b96ba7b96ba7b96ba7b96ba7b96ba7b96ba7b96ba7b96ba +7b96ba7b96ba7b96ba7b96ba7b96ba7b96ba7b96ba7b96ba7b96ba7b96ba +7b96ba7b96ba7b96ba7b96ba7b96ba7b96ba7b96ba7b96ba7b96ba7b96ba +7b96ba7b96ba7b96ba7b96ba7b96ba7b96ba7b96ba7b96ba7b96ba7b96ba +7b96ba7b96ba7b96ba7b96ba7b96ba7b96ba7b96ba7b96ba7b96ba7b96ba +7b96ba7b96ba7b96ba7b96ba7b96ba7b96ba7b96ba7b96ba7b96ba7b96ba +7b96ba7b96ba7b96ba7b96ba7b96ba7b96ba7b96ba7b96ba7b96ba7b96ba +7b96ba7b96bac9d5e3e8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +ecf3f9ecf0f5e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1 +e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1 +e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1 +e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1 +e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1 +e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1 +e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1 +e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1f8fafce1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ecf3f990a7c55679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +ecf3f990a7c55679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a6e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ecf3f990a7c55679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +ecf3f990a7c55679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a6e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e2edf6 +e5eef7e5eef7e5eef7e5eef7e5eef7eef5fa9eb2cc6b8ab16b8ab16b8ab1 +6b8ab16b8ab16b8ab16b8ab16b8ab16b8ab16b8ab16b8ab16b8ab16b8ab1 +6b8ab16b8ab16b8ab16b8ab16b8ab16b8ab16b8ab16b8ab16b8ab16b8ab1 +6b8ab16b8ab16b8ab16b8ab16b8ab16b8ab16b8ab16b8ab16b8ab16b8ab1 +6b8ab16b8ab16b8ab16b8ab16b8ab16b8ab16b8ab16b8ab16b8ab16b8ab1 +6b8ab16b8ab16b8ab16b8ab16b8ab16b8ab16b8ab16b8ab16b8ab16b8ab1 +6b8ab16b8ab16b8ab16b8ab16b8ab16b8ab16b8ab16b8ab16b8ab16b8ab1 +6b8ab16b8ab16b8ab16b8ab16b8ab1577aa65679a65679a65679a65679a6 +e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ebf3f9e2e8f0cdd8e5cdd8e5cdd8e5cdd8e5 +ced8e6c5d1e1c0cddec0cddec0cddec0cddec0cddec0cddec0cddec0cdde +c0cddec0cddec0cddec0cddec0cddec0cddec0cddec0cddec0cddec0cdde +c0cddec0cddec0cddec0cddec0cddec0cddec0cddec0cddec0cddec0cdde +c0cddec0cddec0cddec0cddec0cddec0cddec0cddec0cddec0cddec0cdde +c0cddec0cddec0cddec0cddec0cddec0cddec0cddec0cddec0cddec0cdde +c0cddec0cddec0cddec0cddec0cddec0cddec0cddec0cddec0cddec0cdde +c0cddec0cddec0cddec0cddec0cddec0cddec0cddec0cddec0cddeecf0f5 +5b7da95679a65679a65679a65679a6e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ebf3f9 +9db1cb5679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a6cbd5e35b7da95679a65679a65679a65679a6 +e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ebf3f99db1cb5679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a6cbd5e3 +5b7da95679a65679a65679a65679a6e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ebf3f9 +9db1cb5679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a6cbd5e35b7da95679a65679a65679a65679a6 +e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ebf3f99db1cb5679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a6cbd5e3 +5b7da95679a65679a65679a65679a6e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ebf3f9 +9db1cb5679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a6cbd5e35b7da95679a65679a65679a65679a6 +e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ebf3f99db1cb5679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a6cbd5e3 +5b7da95679a65679a65679a65679a6e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ebf3f9 +9db1cb5679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a6cbd5e35b7da95679a65679a65679a65679a6 +e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ebf3f99db1cb5679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a6cbd5e3 +5b7da95679a65679a65679a65679a6e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ebf3f9 +9db1cb5679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a6cbd5e35b7da95679a65679a65679a65679a6 +e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ebf3f99db1cb5679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a6cbd5e3 +5b7da95679a65679a65679a65679a6e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ebf3f9 +9db1cb5679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a6cbd5e35b7da95679a65679a65679a65679a6 +e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ebf3f99db1cb5679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a6cbd5e3 +5b7da95679a65679a65679a65679a6e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ebf3f9 +9db1cb5679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a6cbd5e35b7da95679a65679a65679a65679a6 +e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ebf3f99db1cb5679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a6cbd5e3 +5b7da95679a65679a65679a65679a6e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ebf3f9 +9db1cb5679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a6cbd5e35b7da95679a65679a65679a65679a6 +e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ebf3f99db1cb5679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a6cbd5e3 +5b7da95679a65679a65679a65679a6e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ebf3f9 +9db1cb5679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a6cbd5e35b7da95679a65679a65679a65679a6 +e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ebf3f99db1cb5679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a6cbd5e3 +5b7da95679a65679a65679a65679a6e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ebf3f9 +9db1cb5679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a6cbd5e35b7da95679a65679a65679a65679a6 +e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ebf3f99db1cb5679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a6cbd5e3 +5b7da95679a65679a65679a65679a6e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ebf3f9 +9db1cb5679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a6cbd5e35b7da95679a65679a65679a65679a6 +e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ebf3f99db1cb5679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a6cbd5e3 +5b7da95679a65679a65679a65679a6e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ebf3f9 +9db1cb5679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a6cbd5e35b7da95679a65679a65679a65679a6 +e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ebf3f99db1cb5679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a6cbd5e3 +5b7da95679a65679a65679a65679a6e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ebf3f9 +9db1cb5679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a6cbd5e35b7da95679a65679a65679a65679a6 +e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ebf3f99db1cb5679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a6cbd5e3 +5b7da95679a65679a65679a65679a6e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ebf3f9 +9db1cb5679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a6cbd5e35b7da95679a65679a65679a65679a6 +e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ebf3f99db1cb5679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a6cbd5e3 +5b7da95679a65679a65679a65679a6e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6abb4bbdae5eee1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6c8d2db +bdc6cee1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6d6e0e9b1bac2e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ebf3f9 +9db1cb5679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a6cbd5e35b7da95679a65679a65679a65679a6 +e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +4a4e51dae5eeb8c1c96d7277e1ecf6e1ecf6e1ecf609090ac3cdd5e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf67d83894f5256e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6b2bbc3 +212224e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ebf3f99db1cb5679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a6cbd5e3 +5b7da95679a65679a65679a65679a6e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6c4cdd62b2d2fe1ecf6767c81797f84e1ecf6 +e1ecf6e1ecf6cdd7e0dee9f3e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf67d8389 +4f5256e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6b2bbc3212224e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ebf3f9 +9db1cb5679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a6cbd5e35b7da95679a65679a65679a65679a6 +e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6b8c1ca939ba161666a +3c3f42939ba12e30326f757a939ba1e1ecf6e1ecf646494cccd6dfe1ecf6 +747a7f979ea5585d602d2f31747a7fd4dee8e1ecf6e1ecf6c8d2db55595d +282a2b2d2f31878e94e1ecf67d83894f5256e1ecf6bfc8d0585d60e1ecf6 +e1ecf6e1ecf65e6266b8c1cae1ecf6dee9f36d7277292b2d474a4d939ba1 +212224e1ecf6e1ecf6d3dde75e6266292b2d343739959ca3e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ebf3f99db1cb5679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a6cbd5e3 +5b7da95679a65679a65679a65679a6e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6a2aab2696e731e1f21515559656a6e0b0c0d696e73696e73 +e0ebf5e1ecf609090ac3cdd5e1ecf64a4e511a1b1c939ba1bdc6ce37393c +81878de1ecf6d7e2eb1b1d1e575c60bac3ccc5ced7a5adb4e1ecf67d8389 +4f5256e1ecf6b0b9c1222426e1ecf6e1ecf6e1ecf62a2c2ea9b1b8e1ecf6 +777d82282a2baeb6bea1a9b1232527212224e1ecf6e0ebf53336385a5e62 +bfc8d09fa7ae151617adb5bde1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ebf3f9 +9db1cb5679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a6cbd5e35b7da95679a65679a65679a65679a6 +e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6191a1b +d3dde7afb7bf404446e1ecf6e1ecf6e1ecf6e1ecf609090ac3cdd5e1ecf6 +4a4e515c6064e1ecf6e1ecf68e959b434649e1ecf6929aa00f1010dde8f2 +e1ecf6e1ecf6e1ecf6e1ecf67d83894f5256e1ecf6b0b9c1222426e1ecf6 +e1ecf6e1ecf62a2c2ea9b1b8e1ecf6222325888f95e1ecf6e1ecf673787d +212224e1ecf6b0b8c00d0e0ecbd5ded3dde7d3dde75e626662676be1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ebf3f99db1cb5679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a6cbd5e3 +5b7da95679a65679a65679a65679a6e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6ccd6df696e736065690c0d0e696e733f4244313335696e73bbc4cd +e1ecf6e1ecf609090ac3cdd5e1ecf64a4e51898f96e1ecf6e1ecf6a6aeb5 +2d2f31e1ecf6787e8344474ae1ecf6e1ecf6e1ecf6e1ecf6e1ecf67d8389 +4f5256e1ecf6b0b9c1222426e1ecf6e1ecf6e1ecf62a2c2ea9b1b8e1ecf6 +09090ab5bec6e1ecf6e1ecf6a2aab2212224e1ecf692999f0b0b0c313335 +3133353133353133356c7176e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ebf3f9 +9db1cb5679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a6cbd5e35b7da95679a65679a65679a65679a6 +e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6d4dee8939ba15155594b4f52 +939ba11f20227e848a939ba1c8d2dbe1ecf6e1ecf609090ac3cdd5e1ecf6 +4a4e51898f96e1ecf6e1ecf6a6aeb52d2f31e1ecf6929aa0131314dee9f3 +e1ecf6e1ecf6e1ecf6e1ecf67d83894f5256e1ecf6c5ced70f1010dfeaf4 +e1ecf6d6e1ea09090aa9b1b8e1ecf62021238b9298e1ecf6e1ecf6767c81 +212224e1ecf6aab3ba09090ad4dee8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ebf3f99db1cb5679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a6cbd5e3 +5b7da95679a65679a65679a65679a6e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf64f5256a1a8b0dbe6ef161718dfeaf4e1ecf6e1ecf6 +e1ecf6e1ecf609090ac3cdd5e1ecf64a4e51898f96e1ecf6e1ecf6a6aeb5 +2d2f31e1ecf6d7e2eb191a1b63686cc3cdd5d0dae4afb7bfe1ecf67d8389 +4f5256e1ecf6e1ecf6212224848b91c6cfd85d6165060607a9b1b8e1ecf6 +73787d2e3032b7c0c8abb4bb27292a212224e1ecf6dde8f22c2e3052565a +b6bfc7d7e2ebadb5bdb1bac2e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ebf3f9 +9db1cb5679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a6cbd5e35b7da95679a65679a65679a65679a6 +e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf64f5256d6e0e9 +bec7cf666b70e1ecf6e1ecf6e1ecf6e1ecf6e1ecf63f4244cbd5dee1ecf6 +70767b9fa7aee1ecf6e1ecf6b5bec65a5e62e1ecf6e1ecf6c3cdd54b4f52 +1f202227292a838a90e1ecf6969da474797ee1ecf6e1ecf6acb4bc474b4e +2c2e308d949a585d60b7c0c8e1ecf6dde8f2656a6f2224264043459ba3aa +515559e1ecf6e1ecf6d1dbe55e626627292a20212346494cb5bec6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ebf3f99db1cb5679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a6cbd5e3 +5b7da95679a65679a65679a65679a6e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ebf3f9 +9db1cb5679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a6cbd5e35b7da95679a65679a65679a65679a6 +e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ebf3f99db1cb5679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65f80ab8ea6c49aafca6887af5679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a66686ae8ba3c25b7da8 +5c7ea98ba3c26585ae5679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a689a1c1bfccdd +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a6cbd5e3 +5b7da95679a65679a65679a65679a6e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ebf3f9 +9db1cb5679a65679a65679a65679a65679a65679a65679a65679a66182ac +e3e8f0ffffffffffffbbc9db5679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a68aa2c1ffffff6786af6a89b0ffffff869fbf5679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a6a4b6cff6f8fa5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a6cbd5e35b7da95679a65679a65679a65679a6 +e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6dde8f2a8b0b75b5f63 +a1a9b1e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ebf3f99db1cb5679a65679a65679a65679a6 +5679a65679a65679a65679a6a8bad1fefefe94aac76383ad859ebf5679a6 +5679a67a95b9b8c7da5679a65679a65679a65679a6849ebeadbed45679a6 +5679a65679a65679a65679a65679a65679a65679a68aa2c1ffffff6786af +6a89b0ffffff869fbf5679a65f80ab90a7c57894b85679a65679a6577aa7 +7f9abc9aafca7995b85679a65679a65679a66887af8ca4c2a5b8d0f6f8fa +5679a65679a66d8bb294aac76787af5679a65679a6577aa68ba3c26b8ab1 +88a0c091a8c5587ba75679a65679a65679a65679a65679a65679a6cbd5e3 +5b7da95679a65679a65679a65679a6e2e9f0e1ecf6e1ecf6e1ecf6c5ced7 +777d82393c3f2021230b0c0d656a6ee1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ebf3f9 +9db1cb5679a65679a65679a65679a65679a65679a65679a65679a6d4dde8 +e3e9f05679a65679a65679a65679a65679a68aa3c2e5ebf15679a65679a6 +5679a65679a69aafcad5dee95679a65679a65679a65679a65679a65679a6 +5679a65679a68aa2c1ffffff8da5c38fa6c4ffffff869fbf5e7faae8edf3 +f4f7f9f7f9fbcfd9e65679a67491b6f8fafcd9e1ebf3f6f9c9d4e35679a6 +819bbdf9fafcfcfcfdeaeef4f6f8fa5679a67c97baf9fafcedf1f6fafbfd +a2b5ce5679a6597ca8ffffffe3e9f0fafbfcfcfcfd6787af5679a65679a6 +5679a65679a65679a65679a6cbd5e35b7da95679a65679a65679a65679a6 +e2e9f0b0b8c04e51551011110606070000000000000404041e1f2145484b +474a4d474b4e484c4f494d504a4e514b4f524c50534d51544e51554f5357 +50545851555952565a53575b54585c55595d565a5e565b5f585d60595d61 +5a5e625b5f635c60645d61655e62665e63675f646861666a62676b63686c +64696d656a6e656a6f666b70676c71686d726a6f746b70756c71766d7277 +6d73786e74796f757a70767b71767b73787d74797e747a7f757b80767c81 +777d82787e83797f847a80857b81867c82887d83897e848a7f858b80868c +81878d82888e83898f838a90858c92868d93878e94888f95898f968a9096 +8b91978b92988c93998e959b8f969c90979d91989e92999f929aa0939ba1 +949ba2959ca3979ea5989fa699a0a79aa1a89aa2a99ba3aa9ca4ab9da5ac +9ea6ada0a8afa1a8b0a6acb18098b75679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ebf3f99db1cb5679a65679a65679a65679a6 +5679a65679a65679a65679a6e4eaf1c5d1e05679a65679a65679a66d8bb2 +96abc8b6c5d9eff2f796abc890a7c47390b596abc8c0cddee5ebf196abc8 +8aa2c15679a65679a65679a65679a65679a65679a68aa2c1ffffffffffff +ffffffffffff869fbf9bb0cafafbfc6282ac6d8bb2ffffff6b8ab15f80ab +6282ac6d8bb2a4b7cff6f8fa587ba7b2c2d7e8edf36383add6dee9f6f8fa +5679a6cad5e3d6dee9577aa69cb1cbe5ebf15679a6597ca8ffffffced8e5 +597ca86182ac5c7ea95679a65679a65679a65679a65679a65679a6cbd5e3 +5b7da95679a65679a65679a65679a6e2e9f0dee9f3aab3ba393c3f1a1c1d +0c0d0e0000000202022224267d83897f858b7e848a7d83897c82887c8287 +7b81867a8085797f84787e83777d82767c81757b80747a7f74797e73787d +72777c71767b6f757a6e74796d73786d72776c71766b70756a6f74696e73 +686d72676c71666b70656a6f656a6e64696d63686c62676b61666a606569 +5f64685e63675e62665d61655c60645b5f635a5e62595d61585d60575c60 +565b5f565a5e55595d54585c53575b5155595054584f53574f52564e5155 +4d51544c50534b4f524a4e51494d50484c4f474b4e474a4d46494c45484b +44474a4346494245484144474044464043453f42443e41443d40433c3f42 +3b3e413a3d40393c3f383b3e383a3d37393c36383b35383a333638323537 +3134363133353032342f31332e30322d2f312c2e302b2d2f2c2d2e758ba7 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ebf3f9 +9db1cb5679a65679a65679a65679a65679a65679a65679a65679a6dce3ed +d5dde95679a65679a65679a68fa6c4f0f3f7f4f7f9fdfdfef0f3f7e1e7ef +9db1cbf0f3f7f6f8fafcfcfdf0f3f7d3dce85679a65679a65679a65679a6 +5679a65679a68aa2c1ffffff7e99bb819bbdffffff869fbfb7c6d9fefefe +f4f7f9f4f7f9ffffff98aec9728fb5eaeff4fefefff4f6f9ffffff6f8db3 +d3dce8c5d1e15679a6adbed4f6f8fa5679a6e6ecf2fafbfdf4f7f9f8f9fb +ffffff6988b0597ca8ffffff9aafca5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a6cbd5e35b7da95679a65679a65679a65679a6 +e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6c9d3dc787e83393c3f151617313436 +dce6f0e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ebf3f99db1cb5679a65679a65679a65679a6 +5679a65679a65679a65679a6c4d0e0f6f8fa5d7ea95679a65d7ea95679a6 +5679a68aa3c2e5ebf15679a65679a65679a65679a69aafcad5dee95679a6 +5679a65679a65679a65679a65679a65679a65679a68aa2c1ffffff6786af +6a89b0ffffff869fbfadbed4f8f9fb829cbd809bbc809bbc6988b0b5c5d8 +f2f5f86181ac90a7c4ffffff718fb4c2cfdfd3dce85679a6bbc9dbf6f8fa +5679a6dce3edd6dee9809bbc809bbc809bbc5d7ea9597ca8ffffff97acc8 +5679a65679a65679a65679a65679a65679a65679a65679a65679a6cbd5e3 +5b7da95679a65679a65679a65679a6e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6dbe6efa2aab2a7afb6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ebf3f9 +9db1cb5679a65679a65679a65679a65679a65679a65679a65679a67e99bb +ffffffecf0f5bfccddb5c5d85679a65679a68aa3c2e5ebf15679a65679a6 +5679a65679a69aafcad5dee95679a65679a65679a65679a65679a65679a6 +5679a65679a68aa2c1ffffff6786af6a89b0ffffff869fbf7a96b9ffffff +c0cdde99aec9c2cfdf7a95b9a8bad1f7f9fb8aa2c1d7dfeaffffff718fb4 +9eb2ccfafbfdb3c3d7f2f5f8f6f8fa5679a6aabbd2f8f9fbabbcd39eb2cc +cfd9e65679a6597ca8ffffff97acc85679a65679a65679a65679a65679a6 +5679a65679a65679a65679a6cbd5e35b7da95679a65679a65679a65679a6 +e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ebf3f99db1cb5679a65679a65679a65679a6 +5679a65679a65679a65679a65679a68ea6c4d9e1ebe6ecf297acc85679a6 +5679a66383ad7a95b95679a65679a65679a65679a66786af7692b75679a6 +5679a65679a65679a65679a65679a65679a65679a67c97bad5dee96383ad +6585aed5dee97a96b95679a696abc8dee5eee8edf3c9d4e36887af6786af +c1cedee1e7efaabcd2d5dee96b89b15d7faab0c0d5dce3eda7b9d1ced8e5 +5679a65b7da8b3c3d7e5ebf1e3e9f0b6c5d95679a6597ba7d5dee9869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a6cbd5e3 +5b7da95679a65679a65679a65679a6e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ebf3f9 +9db1cb5679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a6cbd5e35b7da95679a65679a65679a65679a6 +e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ebf3f99db1cb5679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a6cbd5e3 +5b7da95679a65679a65679a65679a6e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ebf3f9 +9db1cb5679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a6cbd5e35b7da95679a65679a65679a65679a6 +e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ebf3f99db1cb5679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a6cbd5e3 +5b7da95679a65679a65679a65679a6e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ebf3f9 +9db1cb5679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a6cbd5e35b7da95679a65679a65679a65679a6 +e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ebf3f99db1cb5679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a6cbd5e3 +5b7da95679a65679a65679a65679a6e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ebf3f9 +9db1cb5679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a6cbd5e35b7da95679a65679a65679a65679a6 +e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ebf3f99db1cb5679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a6cbd5e3 +5b7da95679a65679a65679a65679a6e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ebf3f9 +9db1cb5679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a6cbd5e35b7da95679a65679a65679a65679a6 +e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ebf3f99db1cb5679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a6cbd5e3 +5b7da95679a65679a65679a65679a6e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ebf3f9 +9db1cb5679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a6cbd5e35b7da95679a65679a65679a65679a6 +e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ebf3f99db1cb5679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a6cbd5e3 +5b7da95679a65679a65679a65679a6e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ebf3f9 +9db1cb5679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a6cbd5e35b7da95679a65679a65679a65679a6 +e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ebf3f99db1cb5679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a6cbd5e3 +5b7da95679a65679a65679a65679a6e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ebf3f9 +9db1cb5679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a6cbd5e35b7da95679a65679a65679a65679a6 +e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ebf3f99db1cb5679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a6cbd5e3 +5b7da95679a65679a65679a65679a6e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ebf3f9 +9db1cb5679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a6cbd5e35b7da95679a65679a65679a65679a6 +e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ebf3f99db1cb5679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a6cbd5e3 +5b7da95679a65679a65679a65679a6e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ebf3f9 +9db1cb5679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a6cbd5e35b7da95679a65679a65679a65679a6 +e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ebf3f99db1cb5679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a6cbd5e3 +5b7da95679a65679a65679a65679a6e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ebf3f9 +9db1cb5679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a6cbd5e35b7da95679a65679a65679a65679a6 +e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ebf3f99db1cb5679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a6cbd5e3 +5b7da95679a65679a65679a65679a6e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ebf3f9 +9db1cb5679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a6cbd5e35b7da95679a65679a65679a65679a6 +e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ebf3f99db1cb5679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a6cbd5e3 +5b7da95679a65679a65679a65679a6e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ebf3f9 +9db1cb5679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a6cbd5e35b7da95679a65679a65679a65679a6 +e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ebf3f99db1cb5679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a6cbd5e3 +5b7da95679a65679a65679a65679a6e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ebf3f9 +9db1cb5679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a6cbd5e35b7da95679a65679a65679a65679a6 +e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ebf3f99db1cb5679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a6cbd5e3 +5b7da95679a65679a65679a65679a6e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ebf3f9 +9db1cb5679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a6cbd5e35b7da95679a65679a65679a65679a6 +e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ebf3f99db1cb5679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a6cbd5e3 +5b7da95679a65679a65679a65679a6e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ebf3f9 +9db1cb5679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a6cbd5e35b7da95679a65679a65679a65679a6 +e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ebf3f99db1cb5679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a6cbd5e3 +5b7da95679a65679a65679a65679a6e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ebf3f9 +9db1cb5679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a6cbd5e35b7da95679a65679a65679a65679a6 +e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ebf3f99fb3cd597ba8597ba8587ba7587ba7 +587aa7577aa65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a6cbd5e3 +5b7da95679a65679a65679a65679a6e2e9f0e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ebf3f9 +a1b4ce5c7ea95b7ea95b7ea95b7da95b7da9587ba75679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a6cbd6e46081ac5b7da95b7da95b7da95b7da9 +e3e9f1e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ebf3f9a3b6ce5f81ab5f80ab5f80ab5e80ab +5f80ab5e7faa5e7faa5d7faa5d7faa5d7faa5d7faa5c7ea95c7ea95c7ea9 +5c7ea95b7da95b7da85b7da85a7ca85a7ca8597ca8597ca8597ba8597ba8 +587ba7587ba7587aa7587aa7577aa7577aa75779a65779a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a6dae2ec +eaf0f5e9eff5e9eff5e9eff5e9eff5eef3f8e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ebf3f9 +a4b7d06383ad6283ad6182ad6182ad6182ac6182ac6082ac6082ac6081ac +6081ac5f81ab5f81ab5f80ab5f80ab5e80ab5e80ab5e7faa5e7faa5d7faa +5d7faa5d7eaa5d7eaa5c7ea95c7ea95b7ea95b7ea95b7da95b7da95a7da9 +5a7da95a7ca85a7ca8597ca8597ba8597ba8587ba7587ba7587aa7587aa7 +577aa7577aa75779a65779a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a6d9e2ece2edf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ebf3f9a6b9d16586af6586af6585ae6585ae +6485ae6485ae6484ae6484ae6384ae6384ae6383ad6383ad6283ad6283ad +6182ad6182ad6182ac6182ac6082ac6081ac6081ac5f81ab5f81ab5f80ab +5f80ab5e80ab5e80ab5e7faa5e7faa5d7faa5d7faa5d7eaa5d7eaa5c7ea9 +5c7ea95b7ea95b7ea95b7da95b7da95a7da95a7da95a7ca85a7ca8597ca8 +597ca8597ba8597ba8587ba7587ba7587aa7577aa7577aa75779a65779a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a6d9e2ec +e2edf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ebf3f9 +a8bbd26988b16988b16888b06787b06787b06787b06787b06687af6687af +6686af6686af6586af6586af6585ae6585ae6485ae6485ae6484ae6484ae +6384ae6384ae6383ad6383ad6283ad6283ad6182ad6182ad6182ac6182ac +6082ac6082ac6081ac6081ac5f81ab5f81ab5f80ab5e80ab5e80ab5e7faa +5e7faa5d7faa5d7faa5d7eaa5d7eaa5c7ea95c7ea95b7ea95b7ea95b7da9 +5b7da95a7da95a7da95a7ca85a7ca8597ca8597ca8597ba8597ba8587ba7 +587ba7587aa7587aa7577aa7577aa75779a65779a65679a65679a65679a6 +5679a65679a65679a65679a6d9e2ece2edf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ebf3f9aabcd36c8bb36b8bb26b8bb26b8ab2 +6b8ab26a8ab26a8ab26a89b16a89b16989b16989b16988b16988b16888b0 +6888b06787b06787b06787b06787b06687af6686af6686af6586af6586af +6585ae6585ae6485ae6485ae6484ae6484ae6384ae6384ae6383ad6383ad +6283ad6283ad6182ad6182ad6182ac6182ac6082ac6082ac6081ac6081ac +5f81ab5f81ab5f80ab5f80ab5e80ab5e80ab5e7faa5d7faa5d7faa5d7eaa +5d7eaa5c7ea95c7ea95b7ea95b7ea95b7da95b7da95a7da95a7da95a7ca8 +5a7ca8597ca8597ca8597ba8597ba8587ba7587ba7587aa7587aa7dae2ec +e2edf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ebf3f9 +bbc9dc8aa3c28aa2c28aa2c289a2c289a2c288a2c188a2c188a2c188a1c1 +88a1c188a1c188a1c187a1c087a1c087a0c087a0c086a0c086a0c0869fc0 +869fc0859fc0859fc0859ec0859ec0849ebf849ebf849ebf849ebf849ebf +849ebf839ebe839ebe839dbe839dbe829dbe829dbe829cbd819cbd819cbd +819bbd819bbd809bbd809bbd809abc809abc809abc809abc7f9abc7f9abc +7f9abc7f9abc7e9abc7e9abc7e99bc7e99bc7d99bb7d99bb7d98bb7d98bb +7c98bb7c98bb7c97ba7c97ba7b97ba7b97ba7b96ba7b96ba7b96b97a96b9 +7a96b97a95b97a95b97995b9e1e8f0e2edf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e7f0f8e9eff6e9eff6e9eff6e9eff6e9eff6 +e9eff6e9eff6e9eff6e9eff6e9eff6e9eff6e9eff6e9eff6e8eff6e8eff6 +e8eff6e8eff6e8eff5e8eff5e8eff5e8eff5e8eff5e8eff5e8eff5e8eff5 +e8eff5e8eff5e8eff5e8eef5e8eef5e8eef5e8eef5e8eef5e8eef5e8eef5 +e8eef5e8eef5444648c0c5cbe8eef5e8eef5e8eef5e8eef5e8eef5e8eef5 +e8eef5e8eef5e8eef5e8eef5e8eef5e8eef5e8eef5e7eef5e7eef5e7eef5 +e7eef5e7eef5e7eef5e7eef5e7eef5e7eef5e7eef5e7eef5e7eef5e7eef5 +e7eef5e7eef5e7eef5e7eef5e7eef5e7eef5e7eef5e7eef5e7eef5ebf1f7 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6161718afb7bfe1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf618191aaeb6bee1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffe1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6191a1badb5bde1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf61a1b1cacb4bce1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf61a1c1dabb4bbe1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf61c1e1faab3bae1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf61d1f20a9b1b8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf61e1f21a8b0b7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6202123a7afb6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6212224a6aeb5e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf618191b939ba1e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e8f0f8e8f0f8e8f0f8e8f0f8e8f0f8e8f0f8e8f0f8e8f0f8e8f0f8e8f0f8 +e8f0f8e8f0f8e8f0f8e8f0f8e8f0f8e8f0f8e8f0f8e8f0f8e8f0f8e8f0f8 +e8f0f8e8f0f8e8f0f8e8f0f8e8f0f8e8f0f8e8f0f8e8f0f8e8f0f8e8f0f8 +e8f0f8e8f0f8e8f0f8e8f0f8e8f0f8e8f0f8e8f0f8e8f0f8e8f0f8e8f0f8 +e8f0f8e8f0f8e8f0f8e8f0f8e8f0f8e8f0f8e8f0f8e8f0f8e8f0f8e8f0f8 +e8f0f8e9f1f8e8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffdfefef7fafdf0f5fae6eff7e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffff9fbfdeef4fae3edf7e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fdfefef1f6fbe3edf7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffffffffffffffffcfdfeecf3f9e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffff7fafde5eef7e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fdfefeeaf2f9e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffedf4fae1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffeff5fae1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffffffffffffffffffffffffffff0f6fb +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffecf3f9e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fefeffe7f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffffffffffbfcfee3edf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffff4f8fce1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffeaf2f9e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffbfcfee2edf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffedf4fa +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff000000000000ffffff000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffbfcfee1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000000000000000000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ecf3f9e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000000000000000000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffff9fbfde1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000000000000000000000 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffe6eff8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000000000000000000000ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffffffffff0f5fae1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffff000000000000000000000000 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffff8fafde1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffff000000000000000000000000ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffffffffffeffffe2edf7e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffff000000000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe6eff8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffeaf2f9e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffeef4fae1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000f6f6f6f7f7f7f7f7f7f7f7f7f7f7f7 +f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7 +f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7 +f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7 +f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7fdfdfdffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffffffffffffffff2f7fbe1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +0000000000000f0f0f5454549e9e9ee7e7e7ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffff2f7fbe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff000000000000000000 +000000010102161e2a324761405b7c405b7c405b7c405b7c405b7c405b7c +405b7c405b7c405b7c405b7c405b7c405b7c405b7c405b7c405b7c405b7c +405b7c405b7c405b7c405b7c405b7c405b7c405b7c405b7c405b7c405b7c +405b7c405b7c405b7c405b7c405b7c405b7c405b7c405b7c405b7c405b7c +405b7c405b7c405b7c405b7c405b7c405b7c405b7c405b7c405b7c405b7c +405b7c405b7c405b7c405b7c405b7c405b7c405b7c405b7c405b7c405b7c +405b7c405b7c405b7c405b7c405b7c405b7c405b7c405b7c405b7c405b7c +405b7c405b7c405b7c405b7c405b7c405b7c405b7c405b7c405b7c405b7c +405b7c405b7c405b7c405b7c405b7c405b7c405b7c405b7c405b7c405b7c +405b7c405b7c405b7c405b7c405b7c405b7c405b7c405b7c405b7c405b7c +405b7c405b7c405b7c405b7c405b7c405b7c405b7c405b7c405b7c405b7c +405b7c405b7c405b7c405b7c405b7c405b7c405b7c405b7c405b7c405b7c +405b7c405b7c405b7c405b7c405b7c405b7c405b7c405b7c405b7c405b7c +405b7c405b7c405b7c405b7c405b7c405b7c405b7c405b7c405b7c405b7c +405b7c405b7c405b7c405b7c405b7c405b7c405b7c405b7c405b7c405b7c +405b7c405b7c405b7c405b7c405b7c405b7c405b7c405b7c405b7c405b7c +405b7c405b7c405b7c405b7c405b7c405b7c405b7c405b7c405b7c405b7c +405b7c405b7c405b7c405b7c405b7c405b7c405b7c405b7c405b7c405b7c +405b7c405b7c405b7c405b7c405b7c3f597a2a3a500d1218000000000000 +010101323232b0b0b0ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffffffffffffffff2f7fbe1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffff0000000000000304052b3c5248658b648dc16c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d05c81b13f597a1d2937000000050505afafafffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffff2f7fbe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff0000000000000304054b6a906c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c97cf2c3f56000000050505b3b3b3ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffffffffffffffff2f7fbe1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +0000000304054b6a906c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c97cf2c3f56000000060606 +b6b6b6ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffff2f7fbe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff0000000000000304054b6a906c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c97cf2c3f56000000101010fcfcfcffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffffffffffffffff2f7fbe1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +3d55756c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c97cf1a2432 +000000c9c9c9ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffff2f7fbe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff0000000000005e85b66c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d03a5271000000868686ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffffffffffffffff2f7fbe1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff0000000f151d +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0587caa +000000434343ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffff2f7fbe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff0000000000002c3e556c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c97cf0a0e13080808f7f7f7ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffffffffffffffff2f7fbe1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff00000000000049678c +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +27364a000000d8d8d8ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffff2f7fbe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff0000000000005e84b46c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d03c5473000000d7d7d7ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffffffffffffffff2f7fbe1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff0000000000005f86b7 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +3d5675000000d7d7d7ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffff2f7fbe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff0000000000005f86b76c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d03d5675000000d7d7d7ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffffffffffffffff2f7fbe1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff0000000000005f86b7 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +3d5675000000d7d7d7ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffff2f7fbe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff0000000000005f86b76c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d03d5675000000d7d7d7ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffffffffffffffff2f7fbe1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff0000000000005f86b7 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +3d5675000000d7d7d7ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffff2f7fbe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff0000000000005f86b76c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d03d5675000000d7d7d7ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffffffffffffffff2f7fbe1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff0000000000005f86b7 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +3d5675000000d7d7d7ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffff2f7fbe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff0000000000005f86b76c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d03d5675000000d7d7d7ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffffffffffffffff2f7fbe1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff0000000000005f86b7 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +3d5675000000d7d7d7ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffff2f7fbe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff0000000000005f86b76c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d03d5675000000d7d7d7ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffffffffffffffff2f7fbe1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff0000000000005f86b7 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +3d5675000000d7d7d7ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffff2f7fbe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff0000000000005f86b76c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d03d5675000000d7d7d7ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffffffffffffffff2f7fbe1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff0000000000005f86b7 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +3d5675000000d7d7d7ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffff2f7fbe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff0000000000005f86b76c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06993c9658ec36a96cd6c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d03d5675000000d7d7d7ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffffffffffffffff2f7fbe1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff0000000000005f86b7 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06a96cd6c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06a95cc +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d032465f000000 +4f6f986c98d06c98d05b80af4a688f4a688f4a688f6893c96c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +3d5675000000d7d7d7ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffff2f7fbe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a6587ba77f9abc93a9c66786af5679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65e7faa8ea6c4809abc +577aa75679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff0000000000005f86b76c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d04f6f981117200202031924316087b86c98d06c98d00e141c0e131a +17202c29394e5a7ead6c98d06c98d0415c7e0d12190d12190f151d1a2533 +4561856c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d052739d151d2802020306080b3f58796c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d032465f0000004f6f986c98d06c98d0354b66000000 +0000000000006087b86c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d03d5675000000d7d7d7ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffffffffffffffff2f7fbe1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a6577aa6cbd5e3 +ffffffffffffc5d1e15679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a67693b7f6f8fafdfdfeffffffa4b7cf5679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff0000000000005f86b7 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d05f86b803050700000006080b000000 +121a236c98d06c98d001020200010101010200000003040651729d6c98d0 +3b5371000000131b2517212d0203040000004e6e976c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d0577ba8030406000000080c10 +05070a2a3b516c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d05a7ead4a688f +638bbf6c98d06c98d05e85b651729c19232f0000006087b86c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +3d5675000000d7d7d7ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffff2f7fbe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a6849ebeffffffb6c5d9718eb492a9c65679a65679a6 +7390b5a6b9d05679a65679a65679a65679a68ba3c28ea6c45679a65679a6 +5679a65679a65679a65679a65679a65679a6b6c5d9dbe2ec5b7da96f8db3 +819bbd5679a65679a65c7ea97894b85679a65679a6577aa77692b76081ab +5d7ea97692b75b7da85679a66b89b16b8ab16988b0869fbf5b7da95679a6 +577aa77c97ba88a0c05d7faa5679a65679a66b89b1809abc577aa65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff0000000000005f86b76c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +39506e0000002d4057668fc417212d0000005375a06c98d0010202131a24 +628abc2c3e550000001c27356c98d03b53710000004c6b936c98d0435e81 +0000003449646c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d027374c00000029394e6690c56791c74c6b926c98d06c98d06a96cd +4d6c9440597a577aa76c98d06c98d06189bc4f6f995a7ead4764886791c7 +456184648dc16c98d0628abd4e6d955e85b65679a6425d7f628abc6c98d0 +6c98d0638bbf4e6d954e6d954e6d95648dc16c98d06c98d06c98d06c98d0 +212e3f0000006087b86c98d06c98d06c98d06c98d06a96cd4d6c943f5879 +52739d6c98d06c98d06c98d06994ca4e6d95567aa6648cc044608349678d +6a95cc6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d03d5675000000d7d7d7ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffffffffffffffff2f7fbe1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a6b2c2d7fbfcfd +597ca85679a65679a65679a65679a688a0c0dde4ed5679a65679a65679a6 +5679a6afc0d5b5c5d85679a65679a65679a65679a65679a65679a65679a6 +5679a6bdcbdceaeff4728fb55679a65679a65679a687a0c0eff2f7ffffff +d6dee96282ac5f80abffffff8ca4c27a95b9ffffff718fb45679a6c7d2e1 +e1e7eff8f9fbffffff8ea6c45679a6cdd7e4ffffffffffffc9d4e25679a6 +8ca4c2fbfcfdfcfcfde5ebf1718fb45679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff0000000000005f86b7 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d0212e4000000050719b6c98d0364c68 +0000003a52716c98d0010202131a246c98d06994cb0203040101026a96cd +3b53710000004c6b936c98d03e57770000004561846c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d00a0e130000005d83b36c98d0 +6c98d06c98d06c98d06994cb1d29370000000000000001013b53726c98d0 +456286020304080b0f000000121922000000090d116c98d049678c000000 +1f2c3c0101020000000b10166189bc6c98d04d6c94000000000000000000 +4f6f986c98d06c98d06c98d06c98d0212e3f0000006087b86c98d06c98d0 +6c98d06791c71a25330000000000000000002c3e556c98d06c98d06189bb +00000017212d0e131a0000000000005678a56c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +3d5675000000d7d7d7ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffff2f7fbe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a6c3d0e0e1e7ef5679a65679a65679a66282ac7b96ba +a2b5cee4eaf17b96ba7390b56b89b17b96bac1cedec5d1e17b96ba6b89b1 +5679a65679a65679a65679a65679a65679a67b96baf1f4f8fefefeb9c8da +5b7da85679a6cfd9e6c9d4e27290b5f4f6f991a8c55f80abffffff8ca4c2 +7a95b9ffffff718fb45679a6c7d2e1f8f9fb809bbc6988b06c8ab2809bbc +ffffffa0b3cd5d7faa7e99bb5679a6e6ebf2bfccdd5c7ea9d5dee9abbcd3 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff0000000000005f86b76c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +17212d0000005d83b36c98d0435f820000003246606c98d0010202131a24 +6c98d06c98d0131b250000006087b83b53710000000c11170d1219020203 +29394e668fc46c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6994cb00010106080b6c97cf6c98d06c98d06c98d06c98d03f597a000000 +1b26344561850b0f140203045e85b64562860000004561850b0f14121a23 +3e5878000000648dc149678c00000005070a3e58781a25330000003a516f +6c98d0638bbf4e6d952432450000004f6f986c98d06c98d06c98d06c98d0 +212e3f0000006087b86c98d06c98d06c98d039506e0000002b3c525375a1 +1d293700000053749f6c98d06189bb0000000000002230414a688f3a5271 +5a7ead6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d03d5675000000d7d7d7ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffffffffffffffff2f7fbe1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a6bfcddde8edf3 +5679a65679a65679a68da5c3ffffffffffffffffffffffffdde4edb5c4d8 +ffffffffffffffffffffffffb5c5d85679a65679a65679a65679a65679a6 +5679a65679a66585aebbc9dbfefeffb2c2d75b7da8f9fafc92a8c55679a6 +d0dae6bfcddd5f80abffffff8ca4c27a95b9ffffff718fb45679a6c7d2e1 +d1dbe75679a65679a65679a6a0b3cdfcfcfd5b7da95679a65679a65a7ca8 +fefeffe8edf3dbe2eceef2f6dae2eb5679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff0000000000005f86b7 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d0111821000000648dc16c98d04b6a90 +0000002d3f566c98d0010202131a246c98d06c98d01d29380000005a7ead +3b5371000000111720131b260102022331435e84b56c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d0648cc000000010171f6c98d06c98d0 +6c98d06c98d06c98d01f2c3c000000587ba96c98d0364c68000000415b7d +4562860000005b81b018222e212f405578a4000000577ba849678c000000 +2432456c98d05375a10000002433456c98d06c98d06c98d032465f000000 +4f6f986c98d06c98d06c98d06c98d0212e3f0000006087b86c98d06c98d0 +6c98d019233000000049678d51729c364c68000000374d6a6c98d06189bb +0000000d12196b97ce6c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +3d5675000000d7d7d7ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffff2f7fbe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a6acbdd3fefeff5d7faa5679a65679a65b7da86686ae +93a9c6e1e7ef6686ae6383ad5f80ab6686aeb7c6d9bdcadc6686ae5f80ab +5679a65679a65679a65679a65679a65679a6577aa65679a65679a6c6d2e1 +d9e1eb577aa7f4f6f997acc85679a6d5dee9b7c6d95f80abffffff8ea5c3 +819bbdffffff718fb45679a6c7d2e1c9d4e25679a65679a65679a69cb0cb +fefefe6181ac5679a65679a6597ba7fefefec6d2e1a0b4cda0b4cd96acc8 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000005f86b76c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +1a2533000000597dab6c98d03f597a000000354b666c98d0010202131a24 +6c98d06c98d00c1117000000648dc13b53710000004c6b936c98d05375a1 +0000002d40576c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c97cf0304050202036993c96c98d06c98d06c98d06c98d0131b25010102 +6a95cc6c98d049678d000000354a654562860000005d83b3192431233144 +567aa60000004f6f9949678c000000354b676c98d0658ec30000001c2735 +6c98d06c98d06c98d032465f0000004f6f986c98d06c98d06c98d06c98d0 +212e3f0000006087b86c98d06c98d06c98d00d1218000000000000000000 +0000000000002b3c526c98d06189bb0000001d29376c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d03d5675000000d7d7d7ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffffffffffffffff2f7fbe1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a67390b5ffffff +d9e1eb99aec9acbdd35679a65679a688a0c0dde4ed5679a65679a65679a6 +5679a6afc0d5b5c5d85679a65679a65679a65679a65679a65679a65679a6 +5679a6bdcbdc9aafca849dbee7ecf2b7c6d95679a6c7d2e1d8e0ea90a7c4 +f8fafc88a1c15679a6f0f3f7beccddbeccddffffff718fb45679a6c7d2e1 +c9d4e25679a65679a65679a67692b7ffffffbbc9db7c97ba96acc85679a6 +dde4edd7dfea7c97ba839dbe99aec95679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +0000000000000000000000000000000000000000000000000000005f86b7 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d027364a0000004c6b936c98d031455f +00000040597a6c98d0010202131a246c98d0648cc000000005070a6c98d0 +3b53710000004c6b936c98d06994cb0202031117206c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d010171f0000005678a56c98d0 +6c98d06c98d06c98d01c27350000005d83b36c98d03c54730000003d5675 +4562860000005d83b3192431233144567aa60000004f6f9949678c000000 +28384d6c98d0587caa000000212f406c98d06c98d06c98d032465f000000 +4f6f986c98d06c98d06c98d06c98d027374c0000005a7ead6c98d06c98d0 +6c98d0151d2800010149678c4e6d954e6d954e6d95597eac6c98d06189bb +0000001f2c3c6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +3d5675000000d7d7d7ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffff2f7fbe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a6a2b5cefafbfdffffffb9c8da5679a65679a6 +6f8cb39aafca5679a65679a65679a65679a6829cbd869fbf5679a65679a6 +5679a65679a65679a65679a65679a65679a6afc0d5fcfdfefefeffd9e1eb +7390b55679a67692b7d6dee9f9fafcb6c5d95c7ea95679a6b1c2d6fefeff +d0dae6ffffff718fb45679a6c7d2e1c9d4e25679a65679a65679a65679a6 +afbfd5fefefeffffffb9c8da5679a67a95b9ecf0f5fffffffefefeaebfd4 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff000000000000000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff0000000000005f86b76c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +466387000000141d27476488080b0f0101026087b86c98d00102020c1118 +3b53710b10160000002f425a6c98d03b5371000000425e805b80af354b66 +00000018222e6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d0374e6b0000000e131a49678d476489354b676c98d0334863000000 +2f425a5f86b8161f2a0000005577a34562860000005d83b3192431233144 +567aa60000004f6f9949678c0000000b0f155679a62b3c5200000032465f +6c98d06791c6658ec32e41590000004a688f658ec36993c96c98d06c98d0 +3f597a000000334863648dc16892c86c98d02b3d53000000374d696791c6 +6893c94663875679a66c98d06189bb0000001f2c3c6c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d03d5675000000d7d7d7ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffffffffffffffff2f7fbe1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffff000000000000000000000000 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff0000000000005f86b7 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06892c8131b26000000000000000000 +2b3d536c98d06c98d00102020000000000000000001a2533638bbe6c98d0 +3b53710000000000000000000000000202034a688f6c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d0648dc1141d27000000000000 +0000002a3b516c98d0648cc00b0f150000000001010000002433456c98d0 +4562860000005d83b3192431233144567aa60000004f6f9949678c000000 +0f151d0000000000000304055a7fae6c98d016202b000000000000000000 +0000000000003449646c98d06c98d05a7ead050709000000000000233143 +6c98d05f86b7080c100000000304050101020000004b6a916c98d06189bb +0000001f2c3c6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +3d5675000000d7d7d7ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffff2f7fbe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffff000000000000ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff0000000000005f86b76c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d0648dc1374d6a28394d40597a6b97ce6c98d06c98d0374d69364c68 +40597a51729d6b97ce6c98d06c98d05375a1364c68364c68374e6b415b7d +5e84b46c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06791c73d567628384d2e4058587ba96c98d06c98d06188ba +33486327374c3d56756b96ce6c98d0597dab364c68648dc1435e8148658a +6189bc364c685e84b449678c0000003a52713d56762a3b5151729c6c98d0 +6c98d0415c7e364c68364c68364c68364c68364c6850719a6c98d06c98d0 +6c98d06690c5415c7e364c6848658a6c98d06c98d0628abd364c68263649 +2a3b51415b7d6690c56c98d06690c5364c684662876c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d03d5675000000d7d7d7ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffffffffffffffff2f7fbe1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000000000ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff0000000000005f86b7 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d049678c000000 +3b53716c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +3d5675000000d7d7d7ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffff2f7fbe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff0000000000005f86b76c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d049678c0000003b53716c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d03d5675000000d7d7d7ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffffffffffffffff2f7fbe1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff0000000000005f86b7 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d05c81b139506e +5578a46c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +3d5675000000d7d7d7ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffff2f7fbe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff0000000000005f86b76c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d03d5675000000d7d7d7ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffffffffffffffff2f7fbe1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff0000000000005f86b7 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +3d5675000000d7d7d7ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffff2f7fbe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff0000000000005f86b76c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d03d5675000000d7d7d7ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffffffffffffffff2f7fbe1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff0000000000005f86b7 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +3d5675000000d7d7d7ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffff2f7fbe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff0000000000005f86b76c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d03d5675000000d7d7d7ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffffffffffffffff2f7fbe1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff0000000000005f86b7 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +3d5675000000d7d7d7ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffff2f7fbe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff0000000000005f86b76c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d03d5675000000d7d7d7ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffffffffffffffff2f7fbe1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff0000000000005f86b7 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +3d5675000000d7d7d7ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffff2f7fbe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff0000000000005f86b76c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d03d5675000000d7d7d7ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffffffffffffffff2f7fbe1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff0000000000005f86b7 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +3d5675000000757575ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe6eff8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff0000000000005f86b76c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d03d5675000000000000ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff0000000000005f86b7 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +3d5675000000000000ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff0000000000005f86b76c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d03d5675000000000000ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff0000000000005d83b3 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +3b5372000000000000ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff0000000000004764896c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d0253448000000000000ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff0000000000002a3c52 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c97cf +090d11000000000000ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff0000000e131a6c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d0587caa000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +5d83b36c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d03b5372 +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff0000000000003b53716c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06b97ce1a2432000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +02020348658a6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06b97ce29394e000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff0000000000000102024764886c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06b97ce28384d000000000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +0000000000000102024663876c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06b96ce27374b000000000000000000 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffff000000000000010202243345 +415c7e5e84b56c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06b97ce5578a4384f6c +17202c000000000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff0000000000000000000000000000000f151d2c3d543a516f +3a516f3a516f3a516f3a516f3a516f3a516f3a516f3a516f3a516f3a516f +3a516f3a516f3a516f3a516f3a516f3a516f3a516f3a516f3a516f3a516f +3a516f3a516f3a516f3a516f3a516f3a516f3a516f3a516f3a516f3a516f +3a516f3a516f3a516f3a516f3a516f3a516f3a516f3a516f3a516f3a516f +3a516f3a516f3a516f3a516f3a516f3a516f3a516f3a516f3a516f3a516f +3a516f3a516f3a516f3a516f3a516f3a516f3a516f3a516f3a516f3a516f +3a516f3a516f3a516f3a516f3a516f3a516f3a516f3a516f3a516f3a516f +3a516f3a516f3a516f3a516f3a516f3a516f3a516f3a516f3a516f3a516f +3a516f3a516f3a516f3a516f3a516f3a516f3a516f3a516f3a516f3a516f +3a516f3a516f3a516f3a516f3a516f3a516f3a516f3a516f3a516f3a516f +3a516f3a516f3a516f3a516f3a516f3a516f3a516f3a516f3a516f3a516f +3a516f3a516f3a516f3a516f3a516f3a516f3a516f3a516f3a516f3a516f +3a516f3a516f3a516f3a516f3a516f3a516f3a516f3a516f3a516f3a516f +3a516f3a516f3a516f3a516f3a516f3a516f3a516f3a516f3a516f3a516f +3a516f3a516f3a516f3a516f3a516f3a516f3a516f3a516f3a516f3a516f +3a516f3a516f3a516f3a516f3a516f3a516f3a516f3a516f3a516f3a516f +3a516f3a516f3a516f3a516f3a516f3a516f3a516f3a516f3a516f3a516f +3a516f3a516f3a516f3a516f3a516f3a516f3a516f3a516f3a516f3a516f +384f6c233143070a0e000000000000000000000000000000ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffff000000000000ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffff000000000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffff000000000000ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffff000000000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffff000000000000ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffff000000000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffff000000000000ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffff000000000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffff000000000000ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffff000000000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffff000000000000ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffff000000000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffff000000000000ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffff000000000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffff000000000000ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffff000000000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffff000000000000ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffff000000000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffff000000000000ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffff000000000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffff000000000000ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffff000000000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffff000000000000ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffff000000000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffff000000000000ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffff000000000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffff000000000000ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffff000000000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffff000000000000ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffff000000000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffff000000000000ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffff000000000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffff000000000000ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffff000000000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffff000000000000ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffff000000000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffff000000000000ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffff000000000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffff000000000000ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffff000000000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffff000000000000ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffff000000000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffff000000000000ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffff000000000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffff000000000000ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffff000000000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffff000000000000ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffff000000000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffff000000000000ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffff000000000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffff000000000000ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffff000000000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffff000000000000ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffff000000000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffff000000000000ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffff000000000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffff000000000000ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffff000000000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6777c82090a0ae1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6b9c2cb000000b9c2cbe1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6b0b8c01b1d1ee1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6d3dde7000000d3dde7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6b0b8c01b1d1ee1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6d3dde7000000d3dde7e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6b0b8c01b1d1ee1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6d3dde7000000d3dde7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6b0b8c01b1d1ee1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6d3dde7000000d3dde7e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffe1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6b0b8c01b1d1ee1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6d3dde7000000d3dde7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6b0b8c01b1d1ee1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6d3dde7000000d3dde7e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6b0b8c01b1d1ee1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6dde7f1bec7cfaab3bac1cbd3e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6bbc4cd90979de1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6c8d2dbaab3babdc6cedee9f3e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +c7d0d9848b91e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6d3dde7000000d3dde7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6b0b8c01b1d1ee1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf68f969c +1314152e3032434649202123262829bac3cce1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf65e6266a2aab2e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6959ca33e4144 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6bec7cf3032341a1b1c414447 +27292a212224b5bec6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6acb4bc27292ae1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6d3dde7000000d3dde7e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6b0b8c01b1d1ee1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6a1a9b10d0e0eb0b8c0e1ecf6e1ecf6e1ecf6a3abb2 +b0b8c0e1ecf6e1ecf6e1ecf6dfeaf4ced9e2e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6dee9f3d8e3ece1ecf6e1ecf6e1ecf6e1ecf6e1ecf6dfeaf4 +ced9e2e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6dfeaf4ced9e2e1ecf6 +e1ecf6d5dfe8cfd9e3e1ecf6e1ecf6e1ecf6e1ecf63f4244949ba2e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6d0dae4dde7f1e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6d1dbe5e1ecf6959ca33e4144e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +dae5ee1d1f206b7075dfeaf4e1ecf6e1ecf6b0b9c1afb7bfe1ecf6e1ecf6 +e1ecf6d0dae4dee9f3e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6d2dce6e0ebf5 +acb4bc27292ae1ecf6e1ecf6e1ecf6e1ecf6d2dce6dbe6efe1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6d3dde7000000d3dde7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6b0b8c01b1d1ee1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf632353772777c +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6757b800b0b0c +1b1d1e141516a6aeb5e1ecf6e1ecf60808097b81861a1c1d1415165d6165 +e1ecf6e1ecf6e0ebf56f757a0a0a0b1a1c1d171819abb4bbe1ecf6dce6f0 +0606077c8287161718404345e1ecf627292a21222418191a1c1e1fabb4bb +e1ecf680868c0b0c0d1b1d1e292b2d7b8186e1ecf6a8b0b71c1e1f1a1b1c +08080970767be1ecf6e1ecf6c2ccd42426281617181d1f20656a6f3e4144 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6898f961e1f21dee9f3e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6aeb6be1c1e1f15161709090a747a7fe1ecf6 +e1ecf6ced8e13133351213131a1c1d6d727727292ae1ecf6e1ecf6b1bac2 +22242617181908080963686ce1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6d3dde7000000d3dde7e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6b0b8c01b1d1ee1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf60b0c0da5adb4e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6969da41c1e1fc9d3dce1ecf69ca4ab131415d9e4ede1ecf6 +010101585d60dae5eed3dde7171819bbc4cde1ecf68f969c222325cbd5de +e1ecf6949ba218191adde7f1dbe6ef00000054585cd6e0e9e1ecf6e1ecf6 +c6cfd8e1ecf6e1ecf6858c9227292ae1ecf6e1ecf63f4244949ba2e1ecf6 +e1ecf6ced9e20e0f0fa0a8afe1ecf6cbd5de161718a8b0b7e1ecf63c3f42 +5c6064dbe6efc6cfd81f20223e4144e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +606569505458e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6dae5ee191a1b +7a8085dfeaf4b8c1c90e0f0fa2aab2e1ecf654585c484c4fd6e1eaced8e1 +2f313327292ae1ecf6d6e0e916171891989ee0ebf5cfd9e3222426989fa6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6d3dde7000000d3dde7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6b0b8c01b1d1ee1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6dee9f3040404b0b9c1 +e1ecf6e1ecf66d72770d0e0e050606676c71e1ecf64a4e514c50539aa2a9 +9aa2a99aa2a90c0d0eb6bfc7e1ecf6010101b8c1c9e1ecf6e1ecf6505458 +82888ee1ecf64245485054589aa2a99aa2a999a0a709090abec7cfdbe6ef +000000b2bbc3e1ecf6e1ecf6e1ecf6ced8e1939ba162676b565b5f020202 +dce6f0e1ecf63f4244949ba2e1ecf6e1ecf690979d1b1d1e9aa2a99aa2a9 +9aa2a93c3f4270767bdce6f0020202b4bdc5e1ecf6e1ecf6656a6e3e4144 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf654585c5c6064e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6b0b9c1060607d7e2ebe1ecf6e1ecf6494d5063686c +e1ecf61314159ca4abe1ecf6e1ecf67c828827292ae1ecf6a0a8af111212 +9aa2a99aa2a99aa2a9474b4e5f6468e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6d3dde7000000d3dde7e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6b0b8c01b1d1ee1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf62122248e959be1ecf6e1ecf6e1ecf6e1ecf6565b5f +676c71e1ecf6383a3d3d4043696e73696e73696e73696e73c2ccd4e1ecf6 +010101d2dce6e1ecf6e1ecf65d6165767c81e1ecf6303234404446696e73 +696e73696e73696e73c6cfd8dbe6ef000000d9e4ede1ecf6e1ecf6d9e4ed +14151674797e9aa2a99fa7ae000000d3dde7e1ecf63f4244949ba2e1ecf6 +e1ecf67d83891c1e1f696e73696e73696e73696e739ca4abcfd9e3000000 +cfd9e3e1ecf6e1ecf683898f3e4144e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +747a7f383a3de1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6a0a8af1d1f20 +e1ecf6e1ecf6e1ecf6666b7055595de1ecf6050606b8c1c9e1ecf6e1ecf6 +9aa1a827292ae1ecf68d949a141516696e73696e73696e73696e73949ba2 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6d3dde7000000d3dde7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6b0b8c01b1d1ee1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf66d73782c2e30 +dde7f1e1ecf6e1ecf6e1ecf6565b5f676c71e1ecf65c6064414447e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6010101d2dce6e1ecf6e1ecf65d6165 +767c81e1ecf654585c484c4fe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6dbe6ef +000000dae5eee1ecf6e1ecf692999f404446e1ecf6e1ecf6949ba2000000 +d3dde7e1ecf64c50538b9197e1ecf6e1ecf6a1a9b109090ad4dee8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf61011119aa2a9e1ecf6e1ecf64a4e513e4144 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6bfc8d0060607b2bbc3e1ecf6e1ecf6 +e1ecf6dde8f2cdd7e0c4cdd6000000c6cfd8e1ecf6e1ecf62d2f31757b80 +e1ecf627292a838a90e1ecf6e1ecf662676b27292ae1ecf6b1bac2030303 +c9d3dce1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6d3dde7000000d3dde7e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6b0b8c01b1d1ee1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6d8e3ec37393c2b2d2f83898f9aa2a97f858b1f2022 +7c8288e1ecf6c7d1da151617515559979ea5949ba252565adee9f3e1ecf6 +010101d2dce6e1ecf6e1ecf65d6165767c81e1ecf6c3cdd513141553575b +989fa6939ba153575be1ecf6dbe6ef000000dae5eee1ecf6e1ecf6c4cdd6 +0d0e0e8b91977f858b35383a000000d3dde7e1ecf6878e942d2f3180868c +aeb6bee0ebf5404446313436848b919da5ac6d7378a9b1b8e1ecf6797f84 +1e1f218a9096656a6e2021233e4144e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf681878d0e0f0f6c7176969da47c8287292b2c979ea5e1ecf6515559 +2a2c2e8b92984f5256141516cfd9e3e1ecf691989e16171881878d70767b +25272927292ae1ecf6e1ecf64f53572b2d2f7f858b9ea6ad73787d9da5ac +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6d3dde7000000d3dde7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6dde7f1 +e1ecf6b0b8c01b1d1ee1ecf6e0ebf5dee9f3e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e0ebf5 +99a0a7696e73565a5e6f757ab2bbc3e1ecf6e1ecf6e1ecf6d0dae4767c81 +565a5e63686c9aa1a8e1ecf6e1ecf671767bdae5eee1ecf6e1ecf69fa7ae +acb4bce1ecf6e1ecf6ced8e1747a7f55595d64696d9ca4abe1ecf6dee9f3 +70767bdde8f2e1ecf6e1ecf6e1ecf6abb4bb63686c72777ccad4dd71767b +dae5eee1ecf6dde8f2acb4bc777d82a2aab2e1ecf6dfeaf48d949a5c6064 +5b5f63838a90d2dce6e1ecf6e1ecf68e959b595d6182888eb8c1c990979d +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6b8c1c974797e565a5e +686d72a9b1b8e1ecf6e1ecf6dee9f3868d93585d606e7479cbd5dee1ecf6 +e1ecf6e1ecf69aa2a95a5e627a8085bfc8d0848b91e1ecf6e1ecf6e0ebf5 +939ba15e6367595d617f858bced8e1e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6cbd5deced9e2d3dde7000000d3dde7ced8e1 +cdd7e0e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6acb4bc9da5acb0b8c01b1d1ee0ebf56f757a +e0ebf5e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6dde8f2 +2a2c2ec2cbd4000000c2cbd42a2c2edde8f2e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6dce6f0 +0d0e0e757b801b1d1e474b4e3e4144e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf633363825272900000024262835383a +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf63b3e411112130606070506068e959b +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +7c82870000000000000101017e848ae1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +767c810000000000001a1b1cd5dfe8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6c9d3dc151617000000161718c9d3dc +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6c7d0d9101111000000313335e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6292b2d0000002a2c2ee1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf623242600000061666ae1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf64d51540000004e5155e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf63f4245020202b7c0c8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf69da5ac0101019da5ace1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6979ea50b0b0ce1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6dde7f1101111dde7f1e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e4eef7e4eef7e4eef7 +e4eef7e4eef7e4eef7e4eef7e4eef7e4eef7e4eef7e4eef7e4eef7e4eef7 +e4eef7e4eef7e4eef7e4eef7e4eef7e4eef7e0e9f25b5f63e4eef7e4eef7 +e4eef7e4eef7e4eef7e4eef7e4eef7e4eef7e4eef7e4eef7e4eef7e4eef7 +e4eef7e4eef7e4eef7e4eef7e4eef7e4eef7e4eef7e4eef7e4eef7e4eef7 +e4eef7e4eef7e4eef7e4eef7e4eef7e4eef7e4eef7e4eef7e4eef7e4eef7 +e4eef7e4eef7e4eef7e4eef7e4eef7e4eef7e4eef7e4eef7e4eef7e4eef7 +e4eef7e4eef7e4eef7e4eef7e4eef7e4eef7e4eef7e4eef7e4eef7e4eef7 +e4eef7e4eef7e2edf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e4eef7e7f0f8e7f0f8e7f0f8e7f0f8e7f0f8e7f0f8e7f0f8 +e7f0f8e7f0f8e7f0f8e7f0f8e7f0f8e7f0f8e7f0f8e7f0f8e7f0f8e7f0f8 +e7f0f8e7f0f8e7f0f8e7f0f8e7f0f8e7f0f8e7f0f8e7f0f8e7f0f8e7f0f8 +e7f0f8e7f0f8e7f0f8e7f0f8e7f0f8e7f0f8e7f0f8e7f0f8e7f0f8e7f0f8 +e7f0f8e7f0f8e7f0f8e7f0f8e7f0f8e7f0f8e7f0f8e7f0f8e7f0f8e7f0f8 +e7f0f8e7f0f8959a9fe7f0f8e7f0f8e7f0f8e7f0f8e7f0f8e7f0f8e7f0f8 +e7f0f8e7f0f8e7f0f8e7f0f8e7f0f8e7f0f8e7f0f8e7f0f8e7f0f8e7f0f8 +e7f0f8e7f0f8e7f0f8e7f0f8e7f0f8e7f0f8e7f0f8e6eff8e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6f6f8fad3dce8d3dce8d3dce8d3dce8d3dce8d3dce8d3dce8 +d3dce8d3dce8d3dce8d3dce8d3dce8d3dce8d3dce8d3dce8d3dce8d3dce8 +d3dce8d3dce8c2cbd6d3dce8d3dce8d3dce8d3dce8d3dce8d3dce8d3dce8 +d3dce8d3dce8d3dce8d3dce8d3dce8d3dce8d3dce8d3dce8d3dce8d3dce8 +d3dce8d3dce8d3dce8d3dce8d3dce8d3dce8d3dce8d3dce8d3dce8d3dce8 +d3dce8d3dce8d3dce8d3dce8d3dce8d3dce8d3dce8d3dce8d3dce8d3dce8 +d3dce8d3dce8d3dce8d3dce8d3dce8d3dce8d3dce8d3dce8d3dce8d3dce8 +d3dce8d3dce8d3dce8d3dce8d3dce8d3dce8e0e7efebf2f8e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6eaf0f7d2dce8c1cedf +c1cedfc1cedfc1cedfc1cedfc1cedfc1cedfc1cedfc1cedfc1cedfc1cedf +c1cedfc1cedfc1cedfc1cedfc1cedfc1cedfc1cedfc1cedfc1cedfc1cedf +c1cedfc1cedfc1cedfc1cedfc1cedfc1cedfc1cedfc1cedfc1cedfc1cedf +c1cedfc1cedfc1cedfc1cedfc1cedfc1cedfc1cedfc1cedfc1cedfc1cedf +c1cedfc1cedfc1cedfc1cedfc1cedfc1cedfc1cedfc1cedfc1cedfc1cedf +c1cedfc1cedfc1cedfc1cedfc1cedfc1cedfc1cedfc1cedfc1cedfc1cedf +c1cedfc1cedfc1cedfc1cedfc1cedfc1cedfc1cedfc1cedfc1cedfc1cedf +c1cedfc1cedff1f4f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e3e9f15679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a68ba3c2e9f0f7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6e5ebf2e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e3e9f15679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a68ba3c2e9f0f7e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6e5ebf2e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e3e9f15679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a68ba3c2e9f0f7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6e5ebf2e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e3e9f15679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a68ba3c2e9f0f7e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6e5ebf2e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e8f0f8e9f1f8e9f1f8e9f1f8e9f1f8e9f1f8eaeff5809bbc809bbc +809bbc809bbc809bbc809bbc809bbc809bbc809bbc809bbc809bbc809bbc +809bbc809bbc809bbc809bbc809bbc809bbc809bbc809bbc809bbc809bbc +809bbc809bbc809bbc809bbc809bbc809bbc809bbc809bbc809bbc809bbc +809bbc809bbc809bbc809bbc809bbc809bbc809bbc809bbc809bbc809bbc +809bbc809bbc809bbc809bbc809bbc809bbc809bbc809bbc809bbc809bbc +809bbc809bbc809bbc809bbc809bbc809bbc809bbc809bbc809bbc809bbc +809bbc809bbc809bbc809bbc809bbc809bbc6a89b05679a65679a65679a6 +5679a68ba3c2e9f0f7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e5eff7ebf3f9ebf3f9ebf3f9 +ebf3f9ebf3f9f0f5f9b0c0d590a7c590a7c590a7c590a7c590a7c590a7c5 +90a7c590a7c590a7c590a7c590a7c590a7c590a7c590a7c590a7c590a7c5 +90a7c590a7c590a7c590a7c590a7c590a7c590a7c590a7c590a7c590a7c5 +90a7c590a7c590a7c590a7c590a7c590a7c590a7c590a7c590a7c590a7c5 +90a7c590a7c590a7c590a7c590a7c590a7c590a7c590a7c590a7c590a7c5 +90a7c590a7c590a7c590a7c590a7c590a7c590a7c590a7c590a7c590a7c5 +90a7c590a7c590a7c590a7c590a7c590a7c590a7c590a7c590a7c590a7c5 +90a7c58ea6c45679a65679a65679a65679a65679a6e5ebf2e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6eff3f7b3c3d8b3c3d8b3c3d8 +b3c3d8b3c3d8b3c3d7abbcd3abbcd3abbcd3abbcd3abbcd3abbcd3abbcd3 +abbcd3abbcd3abbcd3abbcd3abbcd3abbcd3abbcd3abbcd3abbcd3abbcd3 +abbcd3abbcd3abbcd3abbcd3abbcd3abbcd3abbcd3abbcd3abbcd3abbcd3 +abbcd3abbcd3abbcd3abbcd3abbcd3abbcd3abbcd3abbcd3abbcd3abbcd3 +abbcd3abbcd3abbcd3abbcd3abbcd3abbcd3abbcd3abbcd3abbcd3abbcd3 +abbcd3abbcd3abbcd3abbcd3abbcd3abbcd3abbcd3abbcd3abbcd3abbcd3 +abbcd3abbcd3abbcd3abbcd3abbcd3abbcd3abbcd3abbcd3abbcd3abbcd3 +c3cfdfa6b8d05679a65679a65679a65679a68ba3c2e9f0f7e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6eaf0f7bccadc9db1cb9db1cb9db1cb9db1cb9db1cb9cb0cb9bb0ca +9bb0ca9bb0ca9bb0ca9bb0ca9bb0ca9bb0ca9bb0ca9bb0ca9bb0ca9bb0ca +9bb0ca9bb0ca9bb0ca9bb0ca9bb0ca9bb0ca9bb0ca9bb0ca9bb0ca9bb0ca +9bb0ca9bb0ca9bb0ca9bb0ca9bb0ca9bb0ca9bb0ca9bb0ca9bb0ca9bb0ca +9bb0ca9bb0ca9bb0ca9bb0ca9bb0ca9bb0ca9bb0ca9bb0ca9bb0ca9bb0ca +9bb0ca9bb0ca9bb0ca9bb0ca9bb0ca9bb0ca9bb0ca9bb0ca9bb0ca9bb0ca +9bb0ca9bb0ca9bb0ca9bb0ca9bb0ca9bb0ca9bb0ca9bb0ca9bb0ca9bb0ca +9bb0ca9bb0ca9bb0ca9bb0ca9bb0ca9bb0cae4e9f15679a65679a65679a6 +5679a65679a6e5ebf2e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e5ebf25679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a6869fbfa6b8d05679a65679a65679a6 +5679a68ba3c2e9f0f7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e9f0f78ba3c25679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a6d5dee95679a65679a65679a65679a65679a6e5ebf2e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e5ebf25679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +869fbfa6b8d05679a65679a65679a65679a68ba3c2e9f0f7e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e9f0f78ba3c25679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a6d5dee95679a65679a65679a6 +5679a65679a6e5ebf2e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e5ebf25679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a6869fbfa6b8d05679a65679a65679a6 +5679a68ba3c2e9f0f7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e9f0f78ba3c25679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a6d5dee95679a65679a65679a65679a65679a6e5ebf2e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e5ebf25679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +869fbfa6b8d05679a65679a65679a65679a68ba3c2e9f0f7e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e9f0f78ba3c25679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a6d5dee95679a65679a65679a6 +5679a65679a6e5ebf2e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e5ebf25679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a6869fbfa6b8d05679a65679a65679a6 +5679a68ba3c2e9f0f7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e9f0f78ba3c25679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a6d5dee95679a65679a65679a65679a65679a6e5ebf2e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e5ebf25679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +869fbfa6b8d05679a65679a65679a65679a68ba3c2e9f0f7e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e9f0f78ba3c25679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a6d5dee95679a65679a65679a6 +5679a65679a6e5ebf2e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e5ebf25679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a6869fbfa6b8d05679a65679a65679a6 +5679a68ba3c2e9f0f7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e9f0f78ba3c25679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a6d5dee95679a65679a65679a65679a65679a6e5ebf2e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e5ebf25679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +869fbfa6b8d05679a65679a65679a65679a68ba3c2e9f0f7e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e9f0f78ba3c25679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a6d5dee95679a65679a65679a6 +5679a65679a6e5ebf2e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e5ebf25679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a6869fbfa6b8d05679a65679a65679a6 +5679a68ba3c2e9f0f7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e9f0f78ba3c25679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a6d5dee95679a65679a65679a65679a65679a6e5ebf2e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e5ebf25679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +869fbfa6b8d05679a65679a65679a65679a68ba3c2e9f0f7e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e9f0f78ba3c25679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a6d5dee95679a65679a65679a6 +5679a65679a6e5ebf2e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e5ebf25679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a6869fbfa6b8d05679a65679a65679a6 +5679a68ba3c2e9f0f7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e9f0f78ba3c25679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a6d5dee95679a65679a65679a65679a65679a6e5ebf2e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e5ebf25679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +869fbfa6b8d05679a65679a65679a65679a68ba3c2e9f0f7e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e9f0f78ba3c25679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a6d5dee95679a65679a65679a6 +5679a65679a6e5ebf2e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e5ebf25679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a6869fbfa6b8d05679a65679a65679a6 +5679a68ba3c2e9f0f7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e9f0f78ba3c25679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a6d5dee95679a65679a65679a65679a65679a6e5ebf2e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e5ebf25679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +869fbfa6b8d05679a65679a65679a65679a68ba3c2e9f0f7e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e9f0f78ba3c25679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a6d5dee95679a65679a65679a6 +5679a65679a6e5ebf2e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e5ebf25679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a6869fbfa6b8d05679a65679a65679a6 +5679a68ba3c2e9f0f7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e9f0f78ba3c25679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a6d5dee95679a65679a65679a65679a65679a6e5ebf2e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e5ebf25679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +869fbfa6b8d05679a65679a65679a65679a68ba3c2e9f0f7e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e9f0f78ba3c25679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a6d5dee95679a65679a65679a6 +5679a65679a6e5ebf2e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e5ebf25679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a6869fbfa6b8d05679a65679a65679a6 +5679a68ba3c2e9f0f7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e9f0f78ba3c25679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a6d5dee95679a65679a65679a65679a65679a6e5ebf2e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e5ebf25679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +869fbfa6b8d05679a65679a65679a65679a68ba3c2e9f0f7e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e9f0f78ba3c25679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a6d5dee95679a65679a65679a6 +5679a65679a6e5ebf2e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e5ebf25679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a6869fbfa6b8d05679a65679a65679a6 +5679a68ba3c2e9f0f7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e9f0f78ba3c25679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a6d5dee95679a65679a65679a65679a65679a6e5ebf2e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e5ebf25679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +869fbfa6b8d05679a65679a65679a65679a68ba3c2e9f0f7e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e9f0f78ba3c25679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a6d5dee95679a65679a65679a6 +5679a65679a6e5ebf2e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e5ebf25679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a6869fbfa6b8d05679a65679a65679a6 +5679a68ba3c2e9f0f7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e9f0f78ba3c25679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a6d5dee95679a65679a65679a65679a65679a6e5ebf2e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e5ebf25679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +869fbfa6b8d05679a65679a65679a65679a68ba3c2e9f0f7e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e9f0f78ba3c25679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a6d5dee95679a65679a65679a6 +5679a65679a6e5ebf2e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e5ebf25679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a6869fbfa6b8d05679a65679a65679a6 +5679a68ba3c2e9f0f7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e9f0f78ba3c25679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a6d5dee95679a65679a65679a65679a65679a6e5ebf2e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e5ebf25679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +869fbfa6b8d05679a65679a65679a65679a68ba3c2e9f0f7e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e9f0f78ba3c25679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a6d5dee95679a65679a65679a6 +5679a65679a6e5ebf2e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e5ebf25679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a6869fbfa6b8d05679a65679a65679a6 +5679a68ba3c2e9f0f7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e9f0f78ba3c25679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a6d5dee95679a65679a65679a65679a65679a6e5ebf2e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e5ebf25679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +869fbfa6b8d05679a65679a65679a65679a68ba3c2e9f0f7e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e9f0f78ba3c25679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a6d5dee95679a65679a65679a6 +5679a65679a6e5ebf2e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e5ebf25679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a6869fbfa6b8d05679a65679a65679a6 +5679a68ba3c2e9f0f7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e9f0f78ba3c25679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a6d5dee95679a65679a65679a65679a65679a6e5ebf2e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e5ebf25679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +869fbfa6b8d05679a65679a65679a65679a68ba3c2e9f0f7e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e9f0f78ba3c25679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a6d5dee95679a65679a65679a6 +5679a65679a6e5ebf2e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e5ebf25679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a6869fbfa6b8d05679a65679a65679a6 +5679a68ba3c2e9f0f7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e9f0f78ba3c25679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a6d5dee95679a65679a65679a65679a65679a6e5ebf2e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e5ebf25679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +869fbfa6b8d05679a65679a65679a65679a68ba3c2e9f0f7e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e9f0f78ba3c25679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a6d5dee95679a65679a65679a6 +5679a65679a6e5ebf2e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6f3f7fbffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffffffffffffffff2f7fbe1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e5ebf25679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a6869fbfa6b8d05679a65679a65679a6 +5679a68ba3c2e9f0f7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e9f0f78ba3c25679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a6d5dee95679a65679a65679a65679a65679a6e5ebf2e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6aeb6be +9aa1a8e1ecf6f3f7fbffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff878787ecececffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff9da0a3b9c2cbe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e5ebf25679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +869fbfa6b8d05679a65679a65679a65679a68ba3c2e9f0f7e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e9f0f78ba3c25679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a6d5dee95679a65679a65679a6 +5679a65679a6e5ebf2e1ecf6e1ecf6e1ecf6e1ecf681878d6e7479e1ecf6 +333638bcc5cde1ecf6e1ecf68b9197676c71e1ecf6f3f7fbffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff0f0f0fd8d8d8ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff47494a91989ee1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e5ebf25679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a6869fbfa6b8d05679a65679a65679a6 +5679a68ba3c2e9f0f7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e9f0f78ba3c25679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a6d5dee95679a65679a65679a65679a65679a6e5ebf2e1ecf6e1ecf6 +e1ecf6e1ecf646494ca9b2b9d6e1ea1a1b1ce1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6f3f7fbfffffffffffff8f8f8fafafaffffffffffffffffff +fffffffffffffbfbfbe7e7e7fcfcfcffffffffffff0f0f0fd8d8d8ffffff +fffffffffffffffffffffffffffffffffffffffffffffffffffffffbfbfb +f1f1f1ffffff47494a91989ee1ecf6e1ecf6e1ecf6dee9f3cfd9e3e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e5ebf25679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +869fbfa6b8d05679a65679a65679a65679a68ba3c2e9f0f7e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e9f0f78ba3c25679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a6d5dee95679a65679a65679a6 +5679a65679a6e5ebf2e1ecf6dfeaf45b5f635b5f630b0c0d565a5e474b4e +191a1b5b5f639ca4abe1ecf67e848a565a5ee1ecf6cdd0d4202020767676 +1f1f1f1b1b1b898989fffffffffffff3f3f36060600707072a2a2a1c1c1c +dcdcdcffffff0f0f0fd8d8d8ffffff4f4f4fa8a8a8ffffffffffffb4b4b4 +444444ffffffffffff9f9f9f0909092121214c4c4c3d3e3f91989ee1ecf6 +dee9f3666b700a0a0b1a1b1c1c1e1fb2bbc3e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e5ebf25679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a6869fbfa6b8d05679a65679a65679a6 +5679a68ba3c2e9f0f7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e9f0f78ba3c25679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a6d5dee95679a65679a65679a65679a65679a6e5ebf2e1ecf6e0ebf5 +a1a9b17c82872f3133a1a9b145484b676c71a1a9b1c1cbd3e1ecf67b8186 +515559e1ecf6cbced20000008a8a8afdfdfddcdcdc0b0b0bf6f6f6ffffff +6f6f6f393939dededefffffff3f3f3f4f4f4ffffff0f0f0fd8d8d8ffffff +494949a6a6a6ffffffffffffb1b1b13e3e3effffffe0e0e0070707bebebe +ffffffa6a6a600000091989ee1ecf683898f2b2d2fced8e1e1ecf6898f96 +212224e0ebf5e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e5ebf25679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +869fbfa6b8d05679a65679a65679a65679a68ba3c2e9f0f7e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e9f0f78ba3c25679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a6d5dee95679a65679a65679a6 +5679a65679a6e5ebf2e1ecf6e1ecf6e1ecf67a808571767be1ecf6313335 +bfc8d0e1ecf6e1ecf6e1ecf67b8186515559e1ecf6cbced2080808f3f3f3 +ffffffffffff303030bebebeffffff1d1d1da0a0a0ffffffffffffffffff +ffffffffffff0f0f0fd8d8d8ffffff494949a6a6a6ffffffffffffb1b1b1 +3e3e3effffff9e9e9e292929fffffffffffffefefe15151691989ee1ecf6 +36383b595d619aa2a99aa2a9959ca3040404cad4dde1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e5ebf25679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a6869fbfa6b8d05679a65679a65679a6 +5679a68ba3c2e9f0f7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e9f0f78ba3c25679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a6d5dee95679a65679a65679a65679a65679a6e5ebf2e1ecf66b7075 +3133351313142021233133350404043133354f5357e1ecf6e1ecf67b8186 +515559e1ecf6cbced21a1a1affffffffffffffffff3d3d3db2b2b2ffffff +0b0b0bc7c7c7ffffffffffffffffffffffffffffff0f0f0fd8d8d8ffffff +4a4a4aa5a5a5ffffffffffffadadad3e3e3effffff8d8d8d494949ffffff +ffffffffffff33343591989ee1ecf6232527474a4d696e73696e73696e73 +696e73ccd6dfe1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e5ebf25679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +869fbfa6b8d05679a65679a65679a65679a68ba3c2e9f0f7e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e9f0f78ba3c25679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a6d5dee95679a65679a65679a6 +5679a65679a6e5ebf2e1ecf6d3dde7c9d3dc131314cad4dd8b92984e5155 +ccd6dfd0dae4e1ecf6e1ecf67b8186515559e1ecf6cbced21a1a1affffff +ffffffffffff3d3d3db2b2b2ffffff3737377b7b7bffffffffffffffffff +ffffffffffff0f0f0fd8d8d8ffffff7171717c7c7cffffffffffff686868 +3e3e3effffffb4b4b4101010fdfdfdfffffff2f2f204040491989ee1ecf6 +474b4e55595de1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e5ebf25679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a6869fbfa6b8d05679a65679a65679a6 +5679a68ba3c2e9f0f7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e9f0f78ba3c25679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a6d5dee95679a65679a65679a65679a65679a6e5ebf2e1ecf6e1ecf6 +b2bbc33d4043e1ecf6656a6e8b9197e1ecf6e1ecf6e1ecf6e1ecf67b8186 +515559e1ecf6cbced21a1a1affffffffffffffffff3d3d3db2b2b2ffffff +bbbbbb1212126d6d6db4b4b48d8d8ddfdfdfffffff0f0f0fd8d8d8ffffff +b8b8b81a1a1a9a9a9a7575752d2d2d3e3e3efffffffcfcfc2f2f2f4e4e4e +a8a8a846464616161791989ee1ecf6bac3cc131314575c609aa2a992999f +585d60e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e5ebf25679a65679a65679a6 +5679a65679a65679a65679a65679a65679a6577aa7859ebf9db1cb7592b6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +7894b89cb0cb7894b85679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +869fbfa6b8d05679a65679a65679a65679a68ba3c2e9f0f7e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e9f0f78ba3c25679a65679a65679a65679a65679a65679a65679a6 +5679a65679a67b96babccadcc1cedf7995b85679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a67b96bab5c5d8577aa76988b0b5c5d86988b0 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a6aabbd2dae2eb5679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a6d5dee95679a65679a65679a6 +5679a65679a6e5ebf2e1ecf6e1ecf6b5bec6a4acb3e1ecf68e959bcbd5de +e1ecf6e1ecf6e1ecf6e1ecf6aeb6be9aa1a8e1ecf6dfe3e78d8d8dffffff +ffffffffffff9e9e9ed9d9d9ffffffffffffd0d0d0767676606060878787 +f2f2f2ffffff878787ecececffffffffffffc5c5c56e6e6e959595d5d5d5 +9f9f9fffffffffffffeeeeee7c7c7c6b6b6bbfbfbf9da0a3b9c2cbe1ecf6 +e1ecf6c9d3dc72777c55595d656a6fa2aab2e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e5ebf25679a65679a65679a65679a65679a65679a65679a65679a6 +5679a6c6d2e1ffffffffffffe3e8f05679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a6b7c6d9fffffff4f7f9ffffff7390b55679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a6869fbfa6b8d05679a65679a65679a6 +5679a68ba3c2e9f0f7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e9f0f78ba3c25679a65679a6 +5679a65679a65679a65679a65679a65679a67a95b9fafbfdf8fafce4e9f1 +acbdd35679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a698aec9 +ffffff587ba77894b8ffffff7894b85679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +b2c2d7e8edf35679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a6d5dee95679a65679a65679a65679a65679a6e5ebf2e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6f3f7fbffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffff2f7fbe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e5ebf25679a65679a65679a6 +5679a65679a65679a65679a65679a6809bbcffffffb4c4d86182ac8ca4c2 +5679a65679a65f80abcbd5e35f80ab5679a65679a65679a66988b0c9d4e2 +5679a65679a65679a65679a65679a65679a65679a65679a65a7ca8f4f6f9 +9cb1cb5679a67a95b96686ae5679a65679a66f8cb3829cbd5679a65679a6 +5d7ea98ba3c26484ad6282ac8ba3c25f80ab5679a67692b7809bbc6e8cb3 +98aec96c8ab25679a65679a6869fbf9eb2cc7894b85679a65679a66686ae +93a9c66f8db35679a65679a65679a65679a65679a65679a65679a65679a6 +869fbfa6b8d05679a65679a65679a65679a68ba3c2e9f0f7e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e9f0f78ba3c25679a65679a65679a65679a65679a65679a65679a6 +5679a6c7d3e2f1f4f86988b05679a66b8ab15679a65679a694aac7cfd9e6 +5679a65679a65679a65679a6a3b6cec0cdde5679a65679a65679a65679a6 +5679a65679a65679a65679a698aec9ffffff587ba77894b8ffffff7894b8 +5679a67f9abcbdcadc9cb1cb5e7faa5679a66585aeadbed4c4d0e09fb3cc +6786af5679a6577aa694aac6b1c2d6b7c6d9e8edf35679a65679a698adc9 +beccdd88a1c1577aa75679a66081abb5c5d8829cbdb6c5d9b7c6d9577aa6 +5679a65679a65679a65679a65679a65679a6d5dee95679a65679a65679a6 +5679a65679a6e5ebf2e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6f3f7fbffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffffffffffffffff2f7fbe1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e5ebf25679a65679a65679a65679a65679a65679a65679a65679a6 +acbdd3ffffff6282ac5679a65679a65679a65679a66383adffffff6384ad +5679a65679a65679a67290b5fdfdfe5679a65679a65679a65679a65679a6 +5679a65679a65679a6577aa7f3f6f9d2dbe76e8cb35679a65679a65679a6 +b3c3d7fdfdfef9fafcdee5ee5b7da86d8bb2ffffff849dbe7c97baffffff +7491b65679a6bccadceef1f6f4f7f9f7f9fbaebfd45679a6b9c8daffffff +f2f5f8fcfdfe5679a66b8ab1f2f4f8f0f3f7fafbfcb8c7da5679a65679a6 +5679a65679a65679a65679a65679a6869fbfa6b8d05679a65679a65679a6 +5679a68ba3c2e9f0f7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e9f0f78ba3c25679a65679a6 +5679a65679a65679a65679a65679a65679a6e7ecf2cdd7e45679a65679a6 +5679a65679a65679a698aec9d7dfea5679a65679a65679a65679a6a8bad1 +c7d3e25679a65679a65679a65679a65679a65679a65679a65679a698aec9 +ffffffabbdd3bccadcffffff7894b87592b6fdfdfecdd7e4dfe5eedfe6ee +5679a6829cbdd4dde8aebfd4e1e7efcbd6e45679a6a3b6ceffffffdde4ed +f9fafce8edf35679a6a2b5cef9fafcc2cfdfeff2f7b0c0d55679a66887af +fffffff2f5f8d1dae7e2e8f0597ba75679a65679a65679a65679a65679a6 +5679a6d5dee95679a65679a65679a65679a65679a6e5ebf2e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e0ebf5b5bec6d6e0e9e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e5ebf25679a65679a65679a6 +5679a65679a65679a65679a65679a6bdcadcecf0f55679a65679a65679a6 +5f80ab96abc89eb2ccffffff9eb2cc96abc86d8bb296abc8a8bad1fefefe +96abc896abc8597ba75679a65679a65679a65679a65679a65679a694aac7 +f7f9fbfefefeabbdd3577aa75b7da9f8fafc97acc86c8ab2fefefe839dbe +6d8bb2ffffff849dbe7c97baffffff7491b65679a6bccadcfafbfd7491b6 +5679a66787af6988b0fefeffb3c3d7577aa7718fb45679a6b2c2d7ebeff5 +597ca8849ebef8f9fb5b7da85679a65679a65679a65679a65679a65679a6 +869fbfa6b8d05679a65679a65679a65679a68ba3c2e9f0f7e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e9f0f78ba3c25679a65679a65679a65679a65679a65679a65679a6 +5679a6f4f6f9b5c4d85679a65679a65679a6869fbfc0cdded9e1ebf0f3f7 +c0cddeadbed490a7c4c0cddedfe5eeeaeff4c0cddea4b6cf5679a65679a6 +5679a65679a65679a65679a698aec9fffffff0f3f7f2f5f8ffffff7894b8 +b4c4d8eff2f77692b78ca4c3ffffff6988b0577aa76f8cb39aafcac5d1e1 +f4f6f9577aa7c9d4e3ced8e55679a6d3dce8e8edf35679a6e3e9f0c9d4e2 +7692b7b3c3d7e3e9f05679a66887afffffffa8bad15679a6577aa75679a6 +5679a65679a65679a65679a65679a65679a6d5dee95679a65679a65679a6 +5679a65679a6e5ebf2e1ecf6e1ecf6e1ecf6e1ecf6d3dde78b92983f4244 +1112127a8085e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e5ebf25679a65679a65679a65679a65679a65679a65679a65679a6 +b5c4d8fafbfc597ba75679a65679a66b8ab1f0f3f7f0f3f7fffffff0f3f7 +f0f3f78aa3c2f0f3f7f2f5f8fffffff0f3f7f0f3f75d7faa5679a65679a6 +5679a65679a65679a65679a65679a66988b0bdcbdcffffff8ba3c2839dbe +ffffff6988b05679a6e6ecf2afc0d56d8bb2ffffff849dbe7c97baffffff +7491b65679a6bccadce1e7ef5679a65679a65679a6809bbcffffff7793b7 +5679a65679a65679a6cfd9e6fcfdfef4f7f9f6f8faffffff819bbd5679a6 +5679a65679a65679a65679a65679a6869fbfa6b8d05679a65679a65679a6 +5679a68ba3c2e9f0f7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e9f0f78ba3c25679a65679a6 +5679a65679a65679a65679a65679a65679a6e6ebf2cfd9e65679a65679a6 +5679a688a1c1c5d1e1dce3edf2f4f8c5d1e1b1c2d693a9c6c5d1e1e1e7ef +ecf0f5c5d1e1a7b9d15679a65679a65679a65679a65679a65679a698aec9 +ffffff587ba77894b8ffffff7894b8c7d3e2ffffffffffffffffffffffff +90a7c492a9c6ffffffdae2ebd9e1ebffffff6383ade3e9f0b5c4d85679a6 +bac8dbe8edf35679a6f6f8faffffffffffffffffffffffff6181ac6887af +ffffff8aa3c25679a65679a65679a65679a65679a65679a65679a65679a6 +5679a6d5dee95679a65679a65679a65679a65679a6e5ebf2e1ecf6aeb6be +4d51542527291314150101010c0d0e5d6165b7c0c8b7c0c8b7c0c8b7c0c8 +b7c0c8b7c0c88f969d000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000939aa1b7c0c8b7c0c8b7c0c8b7c0c8b7c0c8b7c0c8b7c0c8 +b7c0c8b7c0c8b7c0c8bcc2c87c93b15679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e5ebf25679a65679a65679a6 +5679a65679a65679a65679a65679a69cb1cbffffff7a96b95679a65d7ea9 +5679a65679a66383adffffff6384ad5679a65679a65679a67290b5fdfdfe +5679a65679a65679a65679a65679a65679a65679a65679a6597ca85f80ab +5679a65679a6f4f7f9abbdd36b8ab1ffffff7995b8577aa6f6f8fa99aec9 +6a89b0ffffff89a1c188a1c1ffffff7491b65679a6bccadcdee5ee5679a6 +5679a65679a67793b7ffffff8da5c35679a65679a65679a6c4d0e0e8edf3 +809bbc809bbc809bbc6383ad5679a65679a65679a65679a65679a65679a6 +869fbfa6b8d05679a65679a65679a65679a68ba3c2e9f0f7e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e9f0f78ba3c25679a65679a65679a65679a65679a65679a65679a6 +5679a6c5d1e1f3f6f9708db4577aa6708db45679a65679a698aec9d7dfea +5679a65679a65679a65679a6a8bad1c7d3e25679a65679a65679a65679a6 +5679a65679a65679a65679a698aec9ffffff587ba77894b8ffffff7894b8 +b5c4d8eef2f6577aa75679a65b7da85b7da8ccd7e4dfe6ee5679a6a8bad1 +ffffff6384adc7d3e2ced8e55679a6d3dce8e8edf35679a6e4e9f1c1cede +5679a65679a66081ab5679a66887afffffff88a1c15679a65679a65679a6 +5679a65679a65679a65679a65679a65679a6d5dee95679a65679a65679a6 +5679a65679a6dbe1e8696e730b0c0d010101000000000000000000040404 +14151614151614151614151614151614151614151609090a000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000090a0a141516141516 +141516141516141516141516141516141516141516141516151616556479 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e5ebf25679a65679a65679a65679a65679a65679a65679a65679a6 +6181acf5f7faf8f9fbbfccddd2dbe75679a65679a66383adffffff6384ad +5679a65679a65679a67290b5fdfdfe5679a65679a65679a65679a65679a6 +5679a65679a65679a66282aceef1f6aebfd4b9c7daffffff7d98bb5679a6 +e3e8f0dae2ebbfccddffffff6988b0577aa6f4f7f9ced8e5d7dfeaffffff +7491b65679a6bccadcdee5ee5679a65679a65679a65a7ca8eaeef4eaeef4 +a5b8d0c9d4e25679a692a8c5fefeffb3c3d79aafcacdd7e46484ad5679a6 +5679a65679a65679a65679a65679a6869fbfa6b8d05679a65679a65679a6 +5679a68ba3c2e9f0f7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e9f0f78ba3c25679a65679a6 +5679a65679a65679a65679a65679a65679a67793b7f8fafcfcfcfdebeff5 +acbdd35679a65679a698aec9d7dfea5679a65679a65679a65679a6a8bad1 +c7d3e25679a65679a65679a65679a65679a65679a65679a65679a698aec9 +ffffff587ba77894b8ffffff7894b87491b6fcfcfde1e7efc4d0e0edf1f6 +6d8bb2a8bad1f8fafcb4c4d8eff2f7ffffff6384ad9fb3ccffffffdde4ed +f6f8fae8edf35679a6a0b3cdfcfdfed1dbe7cbd5e3e2e8f05679a66887af +ffffff88a1c15679a65679a65679a65679a65679a65679a65679a65679a6 +5679a6d5dee95679a65679a65679a65679a65679a6e5ebf2e1ecf6e1ecf6 +b8c1c962676b3336381a1c1d0404043b3e41dde8f2e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e5ebf25679a65679a65679a6 +5679a65679a65679a65679a65679a65679a67592b6cfd9e6e8edf3b7c6d9 +5679a65679a6597ba7809bbc597ca85679a65679a65679a65d7ea9809abc +5679a65679a65679a65679a65679a65679a65679a65679a65a7ca8b6c5d9 +e3e8f0d7dfeaa2b5ce577aa65679a66f8cb3bdcadcd2dbe7849ebe5679a6 +5679a69cb1cbdfe6eea7b9d1d5dee96d8bb25679a6a2b5cebccadc5679a6 +5679a65679a65679a67390b5d1dae7e8edf3c3cfdf5679a6577aa6a6b8d0 +e1e7efe6ebf2c2cfdf5d7ea95679a65679a65679a65679a65679a65679a6 +869fbfa6b8d05679a65679a65679a65679a68ba3c2e9f0f7e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e9f0f78ba3c25679a65679a65679a65679a65679a65679a65679a6 +5679a65679a67491b6b1c2d6bac8db7693b75679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a67793b7abbcd3577aa66787afabbcd36786af +5679a67894b8b5c5d8bdcadc9aafca5b7da85e7faa9cb1cbb5c4d8849dbe +abbcd35d7ea95679a68ea6c4adbed488a0c09fb3cc5679a65679a690a7c5 +bccadcb7c6d9869fbf5679a65f80ababbcd36f8db35679a65679a65679a6 +5679a65679a65679a65679a65679a65679a6d5dee95679a65679a65679a6 +5679a65679a6e5ebf2e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6d5dfe891989e +3d40435b5f63dce6f0e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e5ebf25679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a6869fbfa6b8d05679a65679a65679a6 +5679a68ba3c2e9f0f7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e9f0f78ba3c25679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a6d5dee95679a65679a65679a65679a65679a6e5ebf2e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6dce6f0e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e5ebf25679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +869fbfa6b8d05679a65679a65679a65679a68ba3c2e9f0f7e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e9f0f78ba3c25679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a6d5dee95679a65679a65679a6 +5679a65679a6e5ebf2e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e5ebf25679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a6869fbfa6b8d05679a65679a65679a6 +5679a68ba3c2e9f0f7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e9f0f78ba3c25679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a6d5dee95679a65679a65679a65679a65679a6e5ebf2e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e5ebf25679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +869fbfa6b8d05679a65679a65679a65679a68ba3c2e9f0f7e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e9f0f78ba3c25679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a6d5dee95679a65679a65679a6 +5679a65679a6e5ebf2e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e5ebf25679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a6869fbfa6b8d05679a65679a65679a6 +5679a68ba3c2e9f0f7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e9f0f78ba3c25679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a6d5dee95679a65679a65679a65679a65679a6e5ebf2e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e5ebf25679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +869fbfa6b8d05679a65679a65679a65679a68ba3c2e9f0f7e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e9f0f78ba3c25679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a6d5dee95679a65679a65679a6 +5679a65679a6e5ebf2e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e5ebf25679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a6869fbfa6b8d05679a65679a65679a6 +5679a68ba3c2e9f0f7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e9f0f78ba3c25679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a6d5dee95679a65679a65679a65679a65679a6e5ebf2e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e5ebf25679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +869fbfa6b8d05679a65679a65679a65679a68ba3c2e9f0f7e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e9f0f78ba3c25679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a6d5dee95679a65679a65679a6 +5679a65679a6e5ebf2e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e5ebf25679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a6869fbfa6b8d05679a65679a65679a6 +5679a68ba3c2e9f0f7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e9f0f78ba3c25679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a6d5dee95679a65679a65679a65679a65679a6e5ebf2e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e5ebf25679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +869fbfa6b8d05679a65679a65679a65679a68ba3c2e9f0f7e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e9f0f78ba3c25679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a6d5dee95679a65679a65679a6 +5679a65679a6e5ebf2e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e5ebf25679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a6869fbfa6b8d05679a65679a65679a6 +5679a68ba3c2e9f0f7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e9f0f78ba3c25679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a6d5dee95679a65679a65679a65679a65679a6e5ebf2e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e5ebf25679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +869fbfa6b8d05679a65679a65679a65679a68ba3c2e9f0f7e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e9f0f78ba3c25679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a6d5dee95679a65679a65679a6 +5679a65679a6e5ebf2e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e5ebf25679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a6869fbfa6b8d05679a65679a65679a6 +5679a68ba3c2e9f0f7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e9f0f78ba3c25679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a6d5dee95679a65679a65679a65679a65679a6e5ebf2e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e5ebf25679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +869fbfa6b8d05679a65679a65679a65679a68ba3c2e9f0f7e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e9f0f78ba3c25679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a6d5dee95679a65679a65679a6 +5679a65679a6e5ebf2e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e5ebf25679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a6869fbfa6b8d05679a65679a65679a6 +5679a68ba3c2e9f0f7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e9f0f78ba3c25679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a6d5dee95679a65679a65679a65679a65679a6e5ebf2e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e5ebf25679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +869fbfa6b8d05679a65679a65679a65679a68ba3c2e9f0f7e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e9f0f78ba3c25679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a6d5dee95679a65679a65679a6 +5679a65679a6e5ebf2e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e5ebf25679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a6869fbfa6b8d05679a65679a65679a6 +5679a68ba3c2e9f0f7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e9f0f78ba3c25679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a6d5dee95679a65679a65679a65679a65679a6e5ebf2e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e5ebf25679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +869fbfa6b8d05679a65679a65679a65679a68ba3c2e9f0f7e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e9f0f78ba3c25679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a6d5dee95679a65679a65679a6 +5679a65679a6e5ebf2e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e5ebf25679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a6869fbfa6b8d05679a65679a65679a6 +5679a68ba3c2e9f0f7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e9f0f78ba3c25679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a6d5dee95679a65679a65679a65679a65679a6e5ebf2e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e5ebf25679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +869fbfa6b8d05679a65679a65679a65679a68ba3c2e9f0f7e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e9f0f78ba3c25679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a6d5dee95679a65679a65679a6 +5679a65679a6e5ebf2e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e5ebf25679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a6869fbfa6b8d05679a65679a65679a6 +5679a68ba3c2e9f0f7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e9f0f78ba3c25679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a6d5dee95679a65679a65679a65679a65679a6e5ebf2e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e5ebf25679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +869fbfa6b8d05679a65679a65679a65679a68ba3c2e9f0f7e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e9f0f78ba3c25679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a6d5dee95679a65679a65679a6 +5679a65679a6e5ebf2e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e5ebf25679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a6869fbfa6b8d05679a65679a65679a6 +5679a68ba3c2e9f0f7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e9f0f78ba3c25679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a6d5dee95679a65679a65679a65679a65679a6e5ebf2e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e5ebf25679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +869fbfa6b8d05679a65679a65679a65679a68ba3c2e9f0f7e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e9f0f78ba3c25679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a6d5dee95679a65679a65679a6 +5679a65679a6e5ebf2e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e5ebf25679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a6869fbfa6b8d05679a65679a65679a6 +5679a68ba3c2e9f0f7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e9f0f78ba3c25679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a6d5dee95679a65679a65679a65679a65679a6e5ebf2e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e5ebf25679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +869fbfa6b8d05679a65679a65679a65679a68ba3c2e9f0f7e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e9f0f78ba3c25679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a6d5dee95679a65679a65679a6 +5679a65679a6e5ebf2e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e5ebf25679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a6869fbfa6b8d05679a65679a65679a6 +5679a68ba3c2e9f0f7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e9f0f78ba3c25679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a6d5dee95679a65679a65679a65679a65679a6e5ebf2e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e5ebf25679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +869fbfa6b8d05679a65679a65679a65679a68ba3c2e9f0f7e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e9f0f78ba3c25679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a6d5dee95679a65679a65679a6 +5679a65679a6e5ebf2e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e5ebf25679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a6869fbfa6b8d05679a65679a65679a6 +5679a68ba3c2e9f0f7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e9f0f78ba3c25679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a6d5dee95679a65679a65679a65679a65679a6e5ebf2e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e5ebf25679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +869fbfa6b8d05679a65679a65679a65679a68ba3c2e9f0f7e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e9f0f78ba3c25679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a6d5dee95679a65679a65679a6 +5679a65679a6e5ebf2e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e5ebf25679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a6869fbfa6b8d05679a65679a65679a6 +5679a68ba3c2e9f0f7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e9f0f78ba3c25679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a6d5dee95679a65679a65679a65679a65679a6e5ebf2e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e5ebf25679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +869fbfa6b8d05679a65679a65679a65679a68ba3c2e9f0f7e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e9f0f78ba3c25679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a6d5dee95679a65679a65679a6 +5679a65679a6e5ebf2e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e5ebf25679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a6869fbfa6b8d05679a65679a65679a6 +5679a68ba3c2e9f0f7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e9f0f78ba3c25679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a6d5dee95679a65679a65679a65679a65679a6e5ebf2e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e5ebf25679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +869fbfa6b8d05679a65679a65679a65679a68ba3c2e9f0f7e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e9f0f78ba3c25679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a6d5dee95679a65679a65679a6 +5679a65679a6e5ebf2e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e5ebf25679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a6869fbfb2c2d7718eb4718eb4718eb4 +718eb49db1cbe9f0f7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e9f0f78ba3c25679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a6dae2eb869fbf869fbf869fbf869fbf869fbfeaeff4e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e5ebf25679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +869fbfeaf0f5e6edf4e6edf4e6edf4e6edf4e6edf4e7f0f8e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e9f0f78ba3c25679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a6e4eaf1e8eff6e8eff6e8eff6 +e8eff6e8eff6eaf1f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e5ebf25679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a6869fbfe8eff6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e9f0f78ba3c25679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a6e3e9f1e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e5ebf25679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +869fbfe8eff6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e9f0f78ba3c25679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a6e3e9f1e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e5ebf25679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a6869fbfe8eff6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e9f0f78ba3c25679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a6e3e9f1e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e8eff6869fbf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6bac9dbe8f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e5ebf25679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +869fbfe8eff6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e9f0f78ba3c25679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a6e3e9f1e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8eff6869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6bac9dbe8f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6eaeff58ba3c28ba3c28ba3c28ba3c28ba3c28ba3c28ba3c28ba3c2 +8ba3c28ba3c28ba3c28ba3c28ba3c28ba3c28ba3c28ba3c28ba3c28ba3c2 +8ba3c28ba3c28ba3c28ba3c28ba3c28ba3c28ba3c28ba3c28ba3c28ba3c2 +8ba3c28ba3c28ba3c28ba3c28ba3c28ba3c28ba3c28ba3c28ba3c28ba3c2 +8ba3c28ba3c28ba3c28ba3c28ba3c28ba3c28ba3c28ba3c28ba3c28ba3c2 +8ba3c28ba3c28ba3c28ba3c28ba3c28ba3c28ba3c28ba3c28ba3c28ba3c2 +8ba3c28ba3c28ba3c28ba3c28ba3c28ba3c28ba3c28ba3c28ba3c28ba3c2 +8ba3c28ba3c28ba3c28ba3c28ba3c2abbdd3e8eff6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6eaf0f7c1cedfa5b8d0a5b8d0 +a5b8d0a5b8d0a5b8d0a5b8d0a5b8d0a5b8d0a5b8d0a5b8d0a5b8d0a5b8d0 +a5b8d0a5b8d0a5b8d0a5b8d0a5b8d0a5b8d0a5b8d0a5b8d0a5b8d0a5b8d0 +a5b8d0a5b8d0a5b8d0a5b8d0a5b8d0a5b8d0a5b8d0a5b8d0a5b8d0a5b8d0 +a5b8d0a5b8d0a5b8d0a5b8d0a5b8d0a5b8d0a5b8d0a5b8d0a5b8d0a5b8d0 +a5b8d0a5b8d0a5b8d0a5b8d0a5b8d0a5b8d0a5b8d0a5b8d0a5b8d0a5b8d0 +a5b8d0a5b8d0a5b8d0a5b8d0a5b8d0a5b8d0a5b8d0a5b8d0a5b8d0a5b8d0 +a5b8d0a5b8d0a5b8d0a5b8d0a5b8d0a5b8d0a5b8d0a5b8d0a5b8d0a5b8d0 +a5b8d0eff2f7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6eaf1f8eaeef4e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1 +e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1 +e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1 +e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1 +e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1 +e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1 +e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1 +e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1e3e9f1f2f5f8e7f0f8e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6eaf1f8e9f0f7e9f0f7e9f0f7 +e9f0f7e9f0f7e9f0f7e9f0f7e9f0f7e9f0f7e9f0f7e9f0f7e9f0f7e9f0f7 +e9f0f7e9f0f7e9f0f7e9f0f7e9f0f7e9f0f7e9f0f7e9f0f7e9f0f7e9f0f7 +e9f0f7e9f0f7e9f0f7e9f0f7e9f0f7e9f0f7e9f0f7e9f0f7e9f0f7e9f0f7 +e9f0f7e9f0f7e9f0f7151616c7cdd3e9f0f7e9f0f7e9f0f7e9f0f7e9f0f7 +e9f0f7e9f0f7e9f0f7e9f0f7e9f0f7e9f0f7e9f0f7e9f0f7e9f0f7e9f0f7 +e9f0f7e9f0f7e9f0f7e9f0f7e9f0f7e9f0f7e9f0f7e9f0f7e9f0f7e9f0f7 +e9f0f7e9f0f7e9f0f7e9f0f7e9f0f7e9f0f7e9f0f7e9f0f7e9f0f7e9f0f7 +e9f0f7e6f0f8e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e5eff7eaf2f9eaf2f9eaf2f9eaf2f9eaf2f9eaf2f9eaf2f9eaf2f9 +eaf2f9eaf2f9eaf2f9eaf2f9eaf2f9eaf2f9eaf2f9eaf2f9eaf2f9eaf2f9 +eaf2f9eaf2f9eaf2f9eaf2f9eaf2f9eaf2f9eaf2f9eaf2f9eaf2f9eaf2f9 +eaf2f9eaf2f9eaf2f9eaf2f9eaf2f9eaf2f9eaf2f9eaf2f9eaf2f9eaf2f9 +eaf2f9eaf2f9eaf2f9eaf2f9eaf2f9eaf2f9eaf2f9eaf2f9eaf2f9eaf2f9 +eaf2f9eaf2f9eaf2f9eaf2f9eaf2f9eaf2f9eaf2f9eaf2f9eaf2f9eaf2f9 +eaf2f9eaf2f9eaf2f9eaf2f9eaf2f9eaf2f9eaf2f9eaf2f9eaf2f9eaf2f9 +eaf2f9eaf2f9eaf2f9eaf2f9eaf2f9eaf2f9eaf2f9e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf60d0e0ec7d0d9e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6060607bec7cf +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6000000c5ced7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6060607bec7cfe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6000000c5ced7e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6060607bec7cf +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6000000c5ced7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6060607bec7cfe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6000000c5ced7e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6060607bec7cf +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6000000c5ced7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6060607bec7cfe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6000000c5ced7e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6060607bec7cf +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6000000c5ced7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6060607bec7cfe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6000000c5ced7e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6040505b3bcc4 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf60000008f969de1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff000000000000ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff000000000000ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff000000000000ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff000000000000ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff000000000000ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff000000000000ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff000000000000ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff000000000000ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff000000000000ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff000000000000ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff000000000000ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffff000000000000000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000ffffff000000000000 +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000000000000000000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffff000000000000000000000000000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000000000000000000000 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffff000000000000000000000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000000000000000000000ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffff000000000000000000000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000000000000000000000 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffff000000000000000000000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffff000000000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff000000000000000000ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffff000000000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff000000000000000000 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffff000000000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff000000000000000000ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffff000000000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff000000ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +0000000000000000000507091d2937374d6951729c6893c96c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06791c75d83b3 +4b69901d2937000000000000000000000000000000000000ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff000000000000000000000000202d3e5678a56a96cd6c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d0597dab293a4f030406 +000000000000000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffff000000000000000000000000 +3246606b97ce6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d0628abd2f435b000000000000000000000000 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +0000000000000000000304064460836c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d02b3d53000000000000000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000000000090d125375a16c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06a95cc1a2533000000000000 +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +0000000000004d6c946c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d0648cc00e141b000000000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff0000000000000000001219226c97cf6c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0597eac05070a +000000000000000000ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +000000425d7f6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d02e4058000000000000000000ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff0000000000000a0e136994ca6c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d048658a +000000000000000000ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff000000000000000000 +374d6a6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06189bc000000000000000000ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff0000000000000000005f86b76c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +0f151d000000000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff000000000000000101 +6a95cc6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d0293a4f000000000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff000000000000080b0f6c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +415c7e000000000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff0000000000000a0e14 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d0476489000000000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff0000000000000a0e146c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +476489000000000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff0000000000000a0e14 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d0476489000000000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff0000000000000a0e146c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +476489000000000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff0000000000000a0e14 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d0476489000000000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff0000000000000a0e146c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +476489000000000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff0000000000000a0e14 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d0476489000000000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff0000000000000a0e146c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +476489000000000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff0000000000000a0e14 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d0476489000000000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff0000000000000a0e146c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +476489000000000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff0000000000000a0e14 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d0476489000000000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff0000000000000a0e146c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +476489000000000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff0000000000000a0e14 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d0476489000000000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff0000000000000a0e146c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +476489000000000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff0000000000000a0e14 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d0476489000000000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff0000000000000a0e146c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d050719a141c26415b7d +6c98d06c98d06a96cd658ec3658ec3658ec36a95cc6c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +476489000000000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff0000000000000a0e14 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d05b80af2c3e55192330243346587caa6c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06994cb384f6c1e2a3a1c2736405b7c6c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d04a688e000000374d696c98d06c98d04d6c94000000000000 +00000048658a6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d0476489000000000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff0000000000000a0e146c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d0577ba8070a0d000000000000000000 +3b53716c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06b97ce1c2736000000000000000000 +1219226c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d0597dab2f425b4e6e96 +6c98d06c98d05d83b3364c681c283700000048658a6c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +476489000000000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff0000000000000a0e14 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +2230420000001e2a39597eac4a688e4561856c98d06c98d06c98d04d6c94 +374d6a6c98d06c98d06c98d06c98d06c98d06c98d0354b674e6e976c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +4b6a910000000b0f144764885a7fae31455f6c98d06c98d06c98d06a95cc +5a7fae6892c86c98d06c98d06c97cf6993c96b97ce5e85b66c98d0628abd +6994cb6c98d06c98d06993c96a95cc6c97cf5c82b26b96ce6c98d06c98d0 +6c98d06993c96993c96993c96b96ce6c98d06c98d06c98d06c98d039506d +00000048658a6c98d06c98d06c98d06c98d06c98d06a95cc5a7fae6690c5 +6c98d06c98d06c98d06c98d06994ca6994ca6c98d0648dc15e84b56c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d0476489000000000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff0000000000000a0e146c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06892c80102020101026791c76c98d06c98d0 +6c98d06c98d06c98d06c98d031455f080b0f6c98d06c98d06c98d06c98d0 +6c98d06c98d005070a3449646c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d02636490000003f597a6c98d06c98d0 +6c98d06c98d06c98d04a688e05070a0000000203043e58786c98d05e84b4 +00000017212d00000027364a0203040e141c6189bc6189bb0000001f2c3c +161f2a0000000e141b5e85b66c98d0658ec2000000000000000000374d69 +6c98d06c98d06c98d06c98d039506d00000048658a6c98d06c98d06c98d0 +6c98d047648805070a00000000010131455e6c97cf6c98d06c98d00d1219 +070a0d364c68010102000000425c7e6c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +476489000000000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff0000000000000a0e14 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d05c82b2 +0000001117206c98d06c98d06c98d06c98d06c98d06c98d06c98d031455f +080b0f6c98d06c98d06c98d06c98d06c98d06c98d005070a3449646c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +1923300000005476a26c98d06c98d06c98d06c98d06189bc040507030406 +2b3c52070a0d0000005679a65e84b4000000223041131b26000000354b67 +0000004f6f996189bb000000010102192330141c260000002b3d536c98d0 +6893c9324761223042000000374d696c98d06c98d06c98d06c98d039506d +00000048658a6c98d06c98d06c98d05d83b30202030d1219384f6c192330 +00000048658b6c98d06c98d00d1219010102070a0e2c3d5428394d40597a +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d0476489000000000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff0000000000000a0e146c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d053749f000000212f406c98d06c98d06c98d0 +6c98d06188ba32476132476117202c0405073247613247614b6a9049678d +32476132476102030418222e324761324761628abd6c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d00f151d000000658ec26c98d06c98d0 +6c98d06c98d03b537200000039506d6c98d048658a0000002c3f565e84b4 +000000425d7f2e4159080b0f6a96cd010102425d7f6189bb00000006090c +6b97ce658ec30001010e141c6c98d06c98d06c98d04a688e000000374d69 +6c98d06c98d06c98d06c98d039506d00000048658a6c98d06c98d06c98d0 +354b670000004561856c98d05c82b20000002230426c98d06c98d00d1219 +00000053749f6c98d06c98d06b97ce6c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +476489000000000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff0000000000000a0e14 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d05a7fae +000000141c266c98d06c98d06c98d06c98d0567aa6000000000000000000 +0000000000000000002d40572a3c52000000000000000000000000000000 +000000597eac6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +17202c000000577ba86c98d06c98d06c98d06c98d02d3f5600000050719a +6c98d05f86b70000001e2a3a5e84b400000045618432465f0b0f156c98d0 +020304384f6c6189bb0000001b26336c98d06c98d00f151d0507096c98d0 +6c98d06c98d04a688e000000374d696c98d06c98d06c98d06c98d039506d +00000048658a6c98d06c98d06c98d027374b000000000000000000000000 +000000151d286c98d06c98d00d12190304066c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d0476489000000000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff0000000000000a0e146c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06690c50000000203046994cb6c98d06c98d0 +6c98d06994cb5e85b65e85b62b3c52070a0e5e85b65e85b6648dc1648dc1 +5e85b65e85b60507092d40575e85b65e85b66a95cc6c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d0233144000000425e806c98d06c98d0 +6c98d06c98d030445d0000004b69906c98d0597eac000000212f405e84b4 +00000045618432465f0b0f156c98d0020304374d6a6189bb000000151d28 +6c98d06c98d0090d11070a0d6c98d06c98d06c98d04a688e000000374d69 +6c98d06c98d06c98d06c98d03c54730000004561856c98d06c98d06c98d0 +2a3a5000000027364a3247613247613247613c54736c98d06c98d00d1219 +070a0d6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +476489000000000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff0000000000000a0e14 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +1b26340000002d3f566690c55b80af4d6c946c98d06c98d06c98d031455f +080b0f6c98d06c98d06c98d06c98d06c98d06c98d005070a3449646c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +446083000000131b25567aa66892c840597a6c98d0425d7f0000002c3d54 +6c98d03a52700000003348635e84b400000045618432465f0b0f156c98d0 +020304374d6a6189bb0000000304056087b8577aa7000000131a246c98d0 +6c98d06c98d04a688e000000374d696c98d06c98d06c98d06c98d051729d +0000002f425b6c98d06c98d06c98d03a5271000000354b666c98d06c98d0 +6690c5577ba86c98d06c98d00d1219070a0d6c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d0476489000000000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff0000000000000a0e146c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d04f6f98020304000000040608000000 +3b53716c98d06c98d06c98d031455f080b0f6c98d06c98d06c98d06c98d0 +6c98d06c98d005070a3449646c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06994ca111821000000010102030406 +1219226c98d06893c90b101600000010171f0000000406086189bb5e84b4 +00000045618432465f0b0f156c98d0020304374d6a6189bb00000005070a +06080b040507000000374d6a6c98d03a5270141c260e131a0000000a0e14 +141c262b3c526c98d06c98d06892c80202030000000f151d1d29376c98d0 +658ec2070a0e0000001118211c283706080b3348636c98d06c98d00d1219 +070a0d6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +476489000000000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff0000000000000a0e14 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d050719b1e2b3b0b101617202c52749e6c98d06c98d06c98d0658ec2 +6087b86c98d06c98d06c98d06c98d06c98d06c98d05f86b8658ec36c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d0658ec22a3c521117200e141c354b676c98d06c98d05d83b31e2b3b +0c11171a24325578a46c98d06189bc1b26334e6e97405b7c2331446c98d0 +1d29374460836189bb0000002230423246600e141b29394e6994ca6c98d0 +3e57771b26331b26331b26331b26331b263330435c6c98d06c98d06c98d0 +5a7ead2e41591b26332331446c98d06c98d05c82b22230420e131a0d1218 +1e2b3b52739d6c98d06c98d0253447202d3e6c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d0476489000000000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff0000000000000a0e146c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06189bb000000233143 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +476489000000000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff0000000000000a0e14 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06189bb0000002331436c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d0476489000000000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff0000000000000a0e146c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d0648dc11e2a3a374d6a +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +476489000000000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff0000000000000a0e14 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d0476489000000000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff0000000000000a0e146c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +476489000000000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff0000000000000a0e14 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d0476489000000000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff0000000000000a0e146c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +476489000000000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff0000000000000a0e14 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d0476489000000000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff0000000000000a0e146c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +476489000000000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff0000000000000a0e14 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d0476489000000000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff0000000000000a0e146c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +476489000000000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff0000000000000a0e14 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d0476489000000000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff0000000000000a0e146c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +476489000000000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff0000000000000a0e14 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d0476489000000000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff0000000000000a0e146c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +476489000000000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff0000000000000a0e14 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d0476489000000000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff0000000000000304066994ca6c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +435e81000000000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff000000000000000000 +53749f6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d039506e000000000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff00000000000039506d6c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +2a3a50000000000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +1f2c3c6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d0658ec2050709000000000000ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff00000000000006090c6b97ce6c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d039506d +000000000000000000ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +0000005678a56c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06994cb0b0f14000000000000000000ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff000000000000000000131b256791c66c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0435f82000000 +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +0000000000002230416c97cf6c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06994cb131a24000000000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff0000000000000000003449646c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d0648cc01a2432000000000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffff0000000000000000004764886c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +597eac0e141b000000000000000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffff000000000000000000030507 +3247616188ba6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d04c6b9206080b000000000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff00000000000000000000000002030427364a567aa66c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d0658ec34c6b932e4058010102 +000000000000000000ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +0000000000000000000000001a25333f58794a688e5375a05577a35577a3 +5577a35577a35577a35577a35577a35577a35577a35577a35577a35577a3 +5577a35577a35577a35577a35577a35577a35577a35577a35577a35577a3 +5577a35577a35577a35577a35577a35577a35577a35577a35577a35577a3 +5577a35577a35577a35577a35577a35577a35577a35577a35577a35577a3 +5577a35577a35577a35577a35577a35577a35577a35577a35577a35577a3 +5577a35577a35577a35577a35577a35577a35577a35577a35577a35577a3 +5577a35577a35577a35577a35577a35577a35577a35577a35577a35577a3 +5577a35577a35577a35577a35577a35577a35577a35577a35577a35577a3 +5577a35577a35577a35577a35577a35577a35577a35577a35577a35577a3 +5577a35577a35577a35577a35577a35577a35577a35577a35577a35577a3 +5577a35577a35577a35577a35577a35577a35577a35577a35577a35577a3 +5577a35577a35577a35577a35577a35577a35577a35577a35577a35577a3 +5577a35577a35577a35577a35577a35577a35577a35577a35577a35577a3 +5577a35577a35577a35577a35577a35577a35577a35577a35577a35577a3 +5577a35577a35577a35577a35577a35577a35577a35577a35577a35577a3 +5577a35577a35577a35577a35577a35577a35577a35577a35577a35577a3 +5577a35577a35577a35577a35577a35577a35577a35577a35577a35577a3 +5577a35577a35577a35577a35577a35577a35577a35577a35577a35577a3 +5577a35577a35577a35577a35577a35577a35577a35577a35577a35577a3 +5577a35577a35577a35577a35577a35577a35577a35577a35577a35577a3 +5577a35577a35577a35577a35577a35577a35577a35577a35577a35577a3 +5577a35577a35577a35577a35577a35577a35577a35577a35577a35577a3 +5577a35577a35577a35577a35577a35577a35577a35577a35577a35577a3 +5577a35577a35577a35577a35577a35577a35577a35577a35577a35577a3 +5577a35577a35577a35577a35577a35577a35577a35577a35577a35577a3 +5577a35577a35577a35577a35577a35577a35577a35577a35577a35577a3 +5577a35577a35577a35577a35577a35577a35577a35577a35577a35577a3 +5577a35577a35577a35577a35577a35577a35577a35577a35577a35577a3 +5577a35577a35577a35577a35577a35577a35577a35577a35577a35577a3 +5577a35577a35577a35577a35577a35577a35577a35577a348658a2e4058 +141c26010102000000000000000000000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffff000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffe1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff000000000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff000000000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff000000000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff000000000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6bbc4cd858c92767c819ca4abdde8f2e1ecf6e1ecf6e1ecf6 +969da48c939990979da6aeb5c2ccd4e1ecf6e1ecf6e1ecf6e1ecf6a8b0b7 +8c93998c93999aa1a8cfd9e3e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6a9b2b98c93998d949aabb4bbdde7f1e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6d7e2ebdde7f1e1ecf6e1ecf6dce6f0383a3d +d7e2ebe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf69ea6adc3cdd5e1ecf6e1ecf6e1ecf6 +e1ecf6bfc9d14a4e51e1ecf6e1ecf6474b4ec7d1dae1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6d6e1ea +383a3ddde7f1e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff000000000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf67c828811121263686c757b80 +313335323537ced9e2e1ecf6e1ecf618191a484c4f61666a494d5018191a +3e4144c3cdd5e1ecf6e1ecf6484c4f33363862676b505458131415696e73 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf64d515431343662676b3f4244 +0f10109ea6ade1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf63c3f42 +979ea5e1ecf6e1ecf6dde8f25b5f63d9e4ede1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +2d2f3191989ee1ecf6e1ecf6e1ecf6e1ecf6c7d0d9696e73e1ecf6e1ecf6 +141516bfc8d0e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6d9e4ed5b5f63dde8f2e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +b0b9c1080809bfc8d0e1ecf6e1ecf6dee9f342454855595de1ecf6e1ecf6 +18191aa6aeb5e1ecf6e1ecf6dbe6ef54585c303234dee9f3e1ecf6484c4f +757b80e1ecf6e1ecf6aeb6be0a0a0bd7e2ebe1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf64d515471767be1ecf6e1ecf66d73783d4043e1ecf6e0ebf5b0b8c0 +dfeaf4e1ecf6e1ecf6c3cdd5ccd6dfe1ecf6cfd9e3bfc8d0d4dee8a0a8af +c7d1dae1ecf6e1ecf6c7d0d92f3133757b80b0b8c0c7d0d9e0ebf5b0b8c0 +dee9f3e1ecf6bdc6ced2dce6c0cad29ca4abcfd9e3e1ecf6d0dae4a0a8af +d4dee8e1ecf6e1ecf6e1ecf6e1ecf6c1cbd3989fa6a9b2b9dfeaf4e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf62d2f3191989ee1ecf6e1ecf6e1ecf6 +e1ecf6d7e2ebb5bec6e1ecf6e1ecf6141516bfc8d0b4bdc59ba3aacfd9e3 +e1ecf6e1ecf6d2dce6bcc5cdd6e1eaa3abb2b8c1cae1ecf6bcc5cd969da4 +9fa7aed2dce6e1ecf6e1ecf6e0ebf5b0b8c0dde8f2b1bac2a2aab2dee9f3 +b0b8c0e0ebf5e1ecf6e1ecf6d1dbe5a0a8af9ea6add3dde7e1ecf6e1ecf6 +e1ecf6d3dde79da5ac9ca4abc8d2dbe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff000000000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6565a5e54585ce1ecf6e1ecf6e1ecf6 +e1ecf6aeb6be020202d9e4ede1ecf618191aa6aeb5e1ecf6e1ecf6e1ecf6 +d3dde7030303b1bac2e1ecf6484c4f757b80e1ecf6e1ecf692999f151617 +e0ebf5e1ecf6e1ecf6e1ecf6e1ecf6e1ecf64d515471767be1ecf6e1ecf6 +7e848a212224e1ecf6dce6f0000000d9e4ede1ecf6e1ecf6565a5e7d8389 +e1ecf68f969c2a2c2e2b2d2f51555918191a71767be1ecf699a0a718191a +3d40435b5f63989fa6dae5ee000000d4dee8e1ecf63a3d4045484b2e3032 +424548141516a1a9b12527294f5256121313a8b0b7e1ecf6e1ecf6767c81 +12131352565a2426283f4244dfeaf4e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +2d2f3191989ee1ecf6e1ecf6e1ecf6e1ecf6b5bec6171819e1ecf6e1ecf6 +14151641444737393c37393c151617c0cad2e1ecf69ca4ab242628292b2c +4c505391989ea4acb335383a5f64683e4144141516b8c1cae1ecf6dbe6ef +000000474b4e383b3e6c7176d3dde7000000dbe6efe1ecf6aab3ba151617 +4245483e41441a1b1cc2ccd4e1ecf699a0a71f20226065695e62664b4f52 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +37393c7a8085e1ecf6e1ecf6e1ecf6e1ecf6d4dee8000000b9c2cbe1ecf6 +18191aa6aeb5e1ecf6e1ecf6e1ecf6e1ecf61f202291989ee1ecf6484c4f +161718292b2d1a1b1c0e0f0fb5bec6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf64d51544a4e51939ba170767b191a1b83898fe1ecf6dce6f0000000 +d9e4ede1ecf6e1ecf6565a5e7d8389e1ecf68f969c040404ced8e1e1ecf6 +b5bec61c1e1fe1ecf6e1ecf63c3f42979ea5e1ecf6e1ecf6dae5ee000000 +d4dee8e1ecf63a3d4045484be1ecf6e1ecf63f4244121313dce6f0e1ecf6 +73787d5d6165e1ecf6b8c1ca080809cdd7e0e1ecf6e1ecf6232527979ea5 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf62d2f3191989ee1ecf6e1ecf6e1ecf6 +e1ecf6b5bec6171819e1ecf6e1ecf61415165a5e62e1ecf6e1ecf6595d61 +4e5155e1ecf69ca4ab000000b9c2cbe1ecf6e1ecf6e0ebf5e1ecf6e1ecf6 +e1ecf66a6f74565a5ee1ecf6dbe6ef0000007b8186e1ecf6e1ecf6d3dde7 +000000dbe6efe0ebf51d1f2090979de1ecf6e1ecf6656a6f54585ce1ecf6 +4144478e959be1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff000000000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf63a3d40767c81e1ecf6e1ecf6e1ecf6 +e1ecf6d0dae4000000bdc6cee1ecf618191aa6aeb5e1ecf6e1ecf6e1ecf6 +e1ecf61a1c1d959ca3e1ecf6484c4f666b70c5ced7bac3cc767c811a1c1d +d1dbe5e1ecf6e1ecf6e1ecf6e1ecf6e1ecf64d51542e30325a5e62323537 +282a2bcdd7e0e1ecf6dce6f0000000d9e4ede1ecf6e1ecf6565a5e7d8389 +e1ecf68f969c37393ce1ecf6e1ecf6e0ebf5060607ced8e1e1ecf63c3f42 +979ea5e1ecf6e1ecf6dae5ee000000d4dee8e1ecf63a3d408b9298e1ecf6 +e1ecf6676c7153575be1ecf6e1ecf6a0a8af2c2e30e1ecf682888e191a1b +62676b62676b62676b292b2c6d7378e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +2d2f3191989ee1ecf6e1ecf6e1ecf6e1ecf6b5bec6171819e1ecf6e1ecf6 +1415169ea6ade1ecf6e1ecf69da5ac1e1f21e1ecf69ca4ab1f2022e1ecf6 +e1ecf6e1ecf6dde8f2858c924b4f52242628191a1b36383be1ecf6dbe6ef +000000c2ccd4e1ecf6e1ecf6d3dde7000000dbe6efc5ced70000005e6266 +62676b62676b46494c2a2c2ee1ecf6888f95131415595d61a5adb4e0ebf5 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +5c60644a4e51e1ecf6e1ecf6e1ecf6e1ecf6a5adb4050606dce6f0e1ecf6 +18191aa6aeb5e1ecf6e1ecf6e1ecf6c9d3dc010101b7c0c8e1ecf6484c4f +757b80e1ecf6e1ecf6e1ecf62122248b9197e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf64d515471767be1ecf6e1ecf651555944474ae1ecf6dde8f2010101 +d6e0e9e1ecf6e1ecf6484c4f7d8389e1ecf68f969c44474ae1ecf6e1ecf6 +e1ecf609090acad4dde1ecf63c3f42979ea5e1ecf6e1ecf6dae5ee000000 +d4dee8e1ecf63a3d4099a0a7e1ecf6e1ecf66c7176606569e1ecf6e1ecf6 +a4acb3282a2be1ecf67e848a27292aa1a9b1a1a9b1a1a9b1a1a9b1bfc8d0 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf62d2f3191989ee1ecf6e1ecf6e1ecf6 +e1ecf6b5bec6171819e1ecf6e1ecf6141516a2aab2e1ecf6e1ecf6a1a8b0 +1d1f20e1ecf69ca4ab37393ce1ecf6e1ecf6e1ecf692999f383b3eb9c2cb +dbe6ef8b9298313335e1ecf6dbe6ef000000dae5eee1ecf6e1ecf6d3dde7 +000000dbe6efc0cad2020202979ea5a1a9b1a1a9b1a1a9b1abb4bbe1ecf6 +e1ecf6c8d2db7a80852b2d2f404345e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff000000000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6bdc6ce070708abb4bbe1ecf6e1ecf6 +d6e1ea32353763686ce1ecf6e1ecf618191aa6aeb5e1ecf6e1ecf6cdd7e0 +3d4043404345e1ecf6e1ecf6484c4f757b80e1ecf6e1ecf6cdd7e0060607 +b1bac2e1ecf6e1ecf6e1ecf6e1ecf6e1ecf64d515471767be1ecf6e1ecf6 +d1dbe50c0d0ea9b2b9e1ecf62c2e30a5adb4e1ecf6d7e2eb0a0a0b7d8389 +e1ecf68f969c44474ae1ecf6e1ecf6e1ecf609090acad4dde1ecf655595d +838a90e1ecf6e1ecf6dae5ee000000d4dee8e1ecf63a3d4099a0a7e1ecf6 +e1ecf66c7176606569e1ecf6e1ecf6a4acb3282a2be1ecf6b0b9c1040404 +c7d1dae1ecf6e1ecf6e1ecf6dfeaf4e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +2d2f3191989ee1ecf6e1ecf6e1ecf6e1ecf6b5bec6171819e1ecf6e1ecf6 +14151662676be1ecf6e1ecf66065694b4f52e1ecf69ca4ab37393ce1ecf6 +e1ecf6e1ecf65155597e848ae1ecf6e1ecf6404345313335e1ecf6dbe6ef +000000dae5eee1ecf6e1ecf6d3dde7000000dbe6efdee9f3151617878e94 +e1ecf6e1ecf6e1ecf6dfeaf4e1ecf6dfeaf4e1ecf6e1ecf6cfd9e3040505 +d6e0e9e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf691989e101111474a4d595d611c1e1f474b4ed5dfe8e1ecf6e1ecf6 +18191a2e30323e4144292b2d0d0e0e5c6064cfd9e3e1ecf6e1ecf6484c4f +2122243f42443437391313145c6064e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf64d515471767be1ecf6e1ecf6e1ecf66f757a383b3ee1ecf67c8288 +18191a585d60292b2c3133357d8389e1ecf68f969c44474ae1ecf6e1ecf6 +e1ecf609090acad4dde1ecf69da5ac1b1d1e474b4e90979ddae5ee000000 +d4dee8e1ecf63a3d4099a0a7e1ecf6e1ecf66c7176606569e1ecf6e1ecf6 +a4acb3282a2be1ecf6e1ecf671767b0d0e0e4e515564696d333638a1a8b0 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf62d2f31292b2c3f42443f42443f4244 +7f858bb5bec6171819e1ecf6e1ecf61415163d4043404446404446131314 +bec7cfe1ecf69ca4ab37393ce1ecf6e1ecf6e1ecf6a0a8af141516606569 +2c2e30404345313335e1ecf6dbe6ef000000dae5eee1ecf6e1ecf6d3dde7 +000000dbe6efe1ecf6a5adb4131314383a3d676c71484c4f64696de1ecf6 +333638575c606d737836383b55595de1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff000000000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ced9e2a1a9b1929aa0 +b8c1c9e1ecf6e1ecf6e1ecf6e1ecf6afb7bfa9b1b8acb4bcc2ccd4dbe6ef +e1ecf6e1ecf6e1ecf6e1ecf6bbc4cda9b1b8a9b1b8b2bbc3dde8f2e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6bcc5cdc6cfd8e1ecf6e1ecf6 +e1ecf6d6e1eaa9b2b9dee9f3e1ecf6c7d1da989fa6ced8e1bfc8d0c8d2db +e1ecf6cdd7e0bac3cce1ecf6e1ecf6e1ecf6abb4bbdce6f0e1ecf6e1ecf6 +dbe6efb0b8c0c2ccd4dfeaf4a9b1b8dee9f3e1ecf6b8c1c9cfd9e3e1ecf6 +e1ecf6c4cdd6c1cbd3e1ecf6e1ecf6d2dce6b3bcc4e1ecf6e1ecf6e1ecf6 +c1cbd3949ba2939ba1bec7cfe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +b4bdc5a9b1b8a9b1b8a9b1b8a9b1b8bfc9d1d6e1eaafb7bfe1ecf6e1ecf6 +aeb6bed7e2ebadb5bd949ba2ccd6dfe1ecf6e1ecf6d0dae4b7c0c8e1ecf6 +e1ecf6e1ecf6e1ecf6cbd5de949ba2bbc4cdd2dce6b5bec6e1ecf6e0ebf5 +a9b1b8dfeaf4e1ecf6e1ecf6dde8f2a9b1b8e0ebf5e1ecf6e1ecf6d1dbe5 +9ea6ad8e959bacb4bcdee9f3e1ecf6ccd6df9aa2a991989ec2ccd4e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff000000000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff000000000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff000000000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff000000000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff000000000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff000000000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e5eff7e9eff5e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4 +e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4 +e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4 +e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4 +e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4 +e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4 +e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4ebf0f6e2ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e6eff8e8eef5e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4 +e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4 +e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4 +e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4 +e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4 +e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4 +e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4 +e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4 +e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4 +e7edf4e7edf4e7edf4eaf1f7e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8f0f8c0cede6686ae6686ae6686ae +6686ae6686ae6686ae6686ae6686ae6686ae6686ae6686ae6686ae6686ae +6686ae6686ae6686ae6686ae6686ae6686ae6686ae6686ae6686ae6686ae +6686ae6686ae6686ae6686ae6686ae6686ae6686ae6686ae6686ae6686ae +6686ae6686ae6686ae6686ae6686ae6686ae6686ae6686ae6686ae6686ae +6686ae6686ae6686ae6686ae6686ae6686ae6686ae6686ae6686ae6686ae +6686ae6686ae6686ae6686ae6686ae6686ae6686ae6686ae6686ae6686ae +6686ae6686aedbe3ede2edf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e9f1f9b4c3d76686ae6686ae6686ae +6686ae6686ae6686ae6686ae6686ae6686ae6686ae6686ae6686ae6686ae +6686ae6686ae6686ae6686ae6686ae6686ae6686ae6686ae6686ae6686ae +6686ae6686ae6686ae6686ae6686ae6686ae6686ae6686ae6686ae6686ae +6686ae6686ae6686ae6686ae6686ae6686ae6686ae6686ae6686ae6686ae +6686ae6686ae6686ae6686ae6686ae6686ae6686ae6686ae6686ae6686ae +6686ae6686ae6686ae6686ae6686ae6686ae6686ae6686ae6686ae6686ae +6686ae6686ae6686ae6686ae6686ae6686ae6686ae6686ae6686ae6686ae +6686ae6686ae6686ae6686ae6686ae6686ae6686ae6686ae6686ae6686ae +6686ae6686ae6686ae6686ae6686ae6686ae6686ae6686aee6ecf3e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff000000000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e8f0f8bac9db5679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6d8e1ebe2edf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e9f1f9acbdd45679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a6e4eaf2e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8f0f8bac9db5679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6d8e1ebe2edf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e9f1f9acbdd45679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6e4eaf2e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff000000000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e8f0f8bac9db5679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6d8e1ebe2edf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e9f1f9acbdd45679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a6e4eaf2e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8f0f8bac9db5679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6d8e1ebe2edf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e9f1f9acbdd45679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6e4eaf2e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff000000000000ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e8f0f8bac9db5679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6d8e1ebe2edf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e9f1f9acbdd45679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a6e4eaf2e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8f0f8bac9db5679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6d8e1ebe2edf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e9f1f9acbdd45679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6e4eaf2e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff000000000000ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e8f0f8bac9db5679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6d8e1ebe2edf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e9f1f9acbdd45679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a6e4eaf2e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8f0f8bac9db5679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6d8e1ebe2edf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e9f1f9acbdd45679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6e4eaf2e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff000000000000ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e8f0f8bac9db5679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6d8e1ebe2edf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e9f1f9acbdd45679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a6e4eaf2e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8f0f8bac9db5679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6d8e1ebe2edf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e9f1f9acbdd45679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6e4eaf2e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff000000000000ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e8f0f8bac9db5679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6d8e1ebe2edf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e9f1f9acbdd45679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a6e4eaf2e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8f0f8bac9db5679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6d8e1ebe2edf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e9f1f9acbdd45679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6e4eaf2e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff000000000000ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e8f0f8bac9db5679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6d8e1ebe2edf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e9f1f9acbdd45679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a6e4eaf2e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8f0f8bac9db5679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6d8e1ebe2edf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e9f1f9acbdd45679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6e4eaf2e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff000000000000ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e8f0f8bac9db5679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6d8e1ebe2edf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e9f1f9acbdd45679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a6e4eaf2e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8f0f8bac9db5679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5d7ea9718eb4718eb46585ae5679a65679a65679a65679a6829cbdd5dee9 +5d7ea95679a65a7ca8718eb45c7ea95679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65d7faa718eb4597ba7 +6182ac6f8db35679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6d8e1ebe2edf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e9f1f9acbdd45679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6597ca8718eb4718eb4 +6787af5679a65679a65679a65679a67491b6d5dee96b8ab15679a6577aa7 +718eb45f80ab5679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65a7ca8718eb45c7ea95f80ab718eb4587ba7 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65a7ca8718eb4718eb46786af5679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6e4eaf2e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff000000000000ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e8f0f8bac9db5679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a6819bbdffffffffffffb4c4d85679a6 +5679a65679a65679a691a8c5ffffff5f80ab5679a6718fb4ffffff7f9abc +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6869fbfffffff6b89b1a0b4cdfafbfc5679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6d8e1ebe2edf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e9f1f9acbdd45679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a66f8cb3ffffffffffffc7d2e15679a65679a65679a65679a6 +7e99bbffffff728fb55679a65f80abffffff92a8c55679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a67390b5 +ffffff7d98bb8ea5c3ffffff6383ad5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a67290b5ffffffffffff +c3cfdf5679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a6e4eaf2e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8f0f8bac9db5679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +597ba76181ace8edf3b4c4d85679a65679a65679a65679a65b7da96686ae +577aa65679a6718fb4ffffff7f9abc5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6869fbfffffff6b89b1 +a0b4cdfafbfc5679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6d8e1ebe2edf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e9f1f9acbdd45679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6577aa76181acd6dee9 +c7d2e15679a65679a65679a65679a6597ca86686ae597ba75679a65f80ab +ffffff92a8c55679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a67390b5ffffff7d98bb8ea5c3ffffff6383ad +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6577aa76181acd9e1ebc3cfdf5679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6e4eaf2e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff000000000000ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e8f0f8bac9db5679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6e6ebf2b4c4d85679a6 +5679a65679a6b9c8dae0e6efe0e6ef5d7faa5679a6718fb4ffffffb3c3d7 +e4e9f1a2b5ce587ba75679a67d98bbcdd8e5cdd7e47c97ba5679a6597ca8 +a6b8d0e3e9f0b4c4d8ffffff6b89b1a0b4cdfafbfcaebfd4dde4ed869fbf +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6d8e1ebe2edf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e9f1f9acbdd45679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a6d3dce8c7d2e15679a65679a65679a6aabcd2 +e0e6efe0e6ef6d8bb25679a65f80abffffffb7c6d9e3e9f0acbdd35c7ea9 +5679a67592b6c5d1e0d5dde9869fbf5679a6577aa69cb0cbe3e9f0afc0d5 +ffffff7d98bb8ea5c3ffffffabbdd3e1e7ef91a8c55679a65679a65679a6 +5679a65679a65679a65679a6c8d3e2c5d1e0d6dee9c2cfdfcdd8e55b7da8 +d2dbe7a2b5ce5679a67e99bbe0e6ef6d8bb26182acc1cedeebeff5dfe6ee +7a95b95679a6728fb5d1dae7ccd7e4bfccddb3c3d75679a65679a6d7dfea +c3cfdf5679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a6e4eaf2e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8f0f8bac9db5679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6e6ebf2b4c4d85679a65679a65679a688a0c0beccddffffff +5f80ab5679a6718fb4ffffffe5ebf1bdcbdcffffff7b96ba5b7da9f8fafc +c7d2e1c9d4e3f7f9fb5a7ca8829cbdffffffbac8dbe8edf3ffffff6b89b1 +a0b4cdffffffcbd5e3d8e0eaf5f7fa577aa65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6d8e1ebe2edf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e9f1f9acbdd45679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a6d3dce8 +c7d2e15679a65679a65679a6809abcb3c3d7ffffff728fb55679a65f80ab +ffffffedf1f6b7c6d9fefeff8ea6c45679a6ebeff5d2dbe7beccddfefeff +6585ae6f8db3ffffffc3d0e0dfe6eeffffff7d98bb8ea5c3ffffffd6dee9 +cdd7e4fefeff6081ab5679a65679a65679a65679a65679a65679a6e3e8f0 +b9c8daf6f8fabac8dbf8fafc6f8cb3bbc9dbe4e9f15679a6b4c4d8e8edf3 +5679a6a0b4cdf1f4f8859ebf97acc87c97ba5679a6ced8e5e9eef3b2c2d7 +fefefec8d3e25679a65679a6d7dfeac3cfdf5679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6e4eaf2e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff000000000000ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e8f0f8bac9db5679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6e6ebf2b4c4d85679a6 +5679a65679a65679a691a8c5ffffff5f80ab5679a6718fb4ffffff96acc8 +577aa6f6f8faa0b3cd87a0c0fefeff5f80ab6585aeffffff829cbda6b9d0 +f1f4f85679a69db1cbffffff6b89b1a0b4cdffffff6787af7d98bbffffff +718eb45679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6d8e1ebe2edf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e9f1f9acbdd45679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a6d3dce8c7d2e15679a65679a65679a65679a6 +7e99bbffffff728fb55679a65f80abffffffa9bbd25679a6e5ebf1b2c2d7 +7491b6ffffff718eb4597ba7f9fafc94aac794aac6fdfdfe5c7ea98aa3c2 +ffffff7d98bb8ea5c3ffffff7a95b96b89b1ffffff839dbe5679a6abbdd3 +d0dae6d0dae67e99bb5679a6e3e8f089a1c1e3e9f089a1c1e8edf3819bbd +809bbcffffff718eb4e6ebf2b0c0d55679a69cb1cbffffffc7d2e17491b6 +5679a65679a6f2f4f8a4b7cf5679a6e8edf3c8d3e25679a65679a6d7dfea +c3cfdf5679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a6e4eaf2e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8f0f8bac9db5679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6e4eaf1b5c5d85679a65679a65679a65679a691a8c5ffffff +5f80ab5679a6718fb4ffffff89a1c15679a6eaeef4adbed49bb0caf8fafc +577aa75a7ca8fcfdfe95abc7b4c4d8e3e9f05679a690a7c4ffffff6b89b1 +a0b4cdfefeff5b7da8708db4ffffff7e99bb5679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6d8e1ebe2edf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e9f1f9acbdd45679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a6d2dbe7 +c8d3e25679a65679a65679a65679a67e99bbffffff728fb55679a65f80ab +ffffff9cb0cb5679a6d7dfeac0cdde88a1c1ffffff6383ad5679a6eef1f6 +a8bad1a2b5cef6f8fa5679a67d98bbffffff7d98bb8ea5c3ffffff6d8bb2 +5d7faaffffff91a8c55679a6bbc9dbe5ebf1e5ebf1849ebe5679a6e3e8f0 +88a0c0e3e8f088a0c0e8edf388a0c0577aa7eef1f6bfccddffffff7894b8 +5679a65b7da8a5b8d0ebeff5fdfdfe8ea5c35a7ca8fcfdfe98adc95679a6 +dce3edc8d3e25679a65679a6d5dee9c4d0e05679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6e4eaf2e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff000000000000ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e8f0f8bac9db5679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6c8d3e2d7dfea5b7da8 +5679a65679a65679a691a8c5ffffff5f80ab5679a6718fb4ffffffb5c4d8 +6d8bb2fefeff8ba3c26b8ab1ffffff829cbd88a0c0ffffff6887af92a8c5 +fcfcfd6988b0bbc9dbffffff6b89b1a0b4cdffffff869fbf9cb0cbfefefe +5e7faa5679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6d8e1ebe2edf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e9f1f9acbdd45679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a6b5c5d8e6ebf25e7faa5679a65679a65679a6 +7e99bbffffff728fb55679a65f80abffffffc6d2e16585aef4f7f99eb2cc +5d7faafafbfd94aac77592b6ffffff7a96b97f9abcffffff7894b8a9bbd2 +ffffff7d98bb8ea5c3ffffff98aec989a1c1ffffff6f8cb35679a65679a6 +5679a65679a65679a65679a6e3e8f088a0c0e3e8f088a0c0e8edf388a0c0 +5679a6b5c5d8fefeffeaeef45679a65679a66988b0577aa7577aa6d7dfea +bfccdd5679a6dfe5eec5d1e16a89b0f8fafcc8d3e25679a65679a6b9c7da +e3e9f05d7ea95679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a6e4eaf2e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8f0f8bac9db5679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a692a8c5f9fafcfcfdfeb1c1d66686aefafbfdfcfcfdffffff +fafbfddbe2ec718fb4ffffffe6ebf2fcfcfdeaeef46585ae5679a6c6d2e1 +fcfdfefcfdfec4d0e05679a66988b0ecf0f5fcfcfde6ebf2ffffff6b89b1 +a0b4cdfcfcfde6ecf2fefeffc9d4e35679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6d8e1ebe2edf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e9f1f9acbdd45679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a6839dbe +f6f8fafdfdfec3d0e05679a6f8fafcfbfcfdfffffffbfcfdecf0f55f80ab +ffffffe6ebf2fcfcfdf0f3f7718eb45679a6b5c4d8fdfdfefcfcfdd5dde9 +577aa75d7faae5ebf1fcfcfde6ebf2ffffff7d98bb8ea5c3ffffffe5ebf1 +fcfdfedbe3ec5679a65679a65679a65679a65679a65679a65679a6e3e8f0 +88a0c0e3e8f088a0c0e8edf388a0c05679a67b96baffffffb2c2d75679a6 +5679a6adbed4f0f3f7dee5eefdfdfe8aa3c25679a6a6b8d0fefefff9fafc +ecf0f5c8d3e25679a65679a6869fbff6f8fafcfdfebfcddd5679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6e4eaf2e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff000000000000ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e8f0f8bac9db5679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a66182ac809abc +6d8bb25a7ca8809bbc809bbc809bbc809bbc7894b85d7ea9809bbc6787af +8aa2c15b7da95679a65679a65679a67491b67390b55679a65679a65679a6 +5d7ea98aa2c16887af809bbc5b7da86988b07e99bb6988b0849dbe5679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6d8e1ebe2edf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e9f1f9acbdd45679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65d7faa809abc728fb55679a6809abc +809bbc809bbc809bbc7c97ba587ba7809bbc6988b089a1c16081ab5679a6 +5679a65679a66d8bb27a96b95679a65679a65679a6597ca88aa2c16787af +809bbc5f80ab6484ad809bbc6787af88a0c0577aa75679a65679a65679a6 +5679a65679a65679a65679a67995b86282ac7995b86282ac7a96b96282ac +5679a67491b6ffffff7a95b95679a65679a65f80ab869fbf93a9c66b89b1 +5679a65679a65679a67692b77692b7d2dbe7c8d3e25679a65679a65679a6 +5e7faa809abc718fb45679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a6e4eaf2e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8f0f8bac9db5679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6d8e1ebe2edf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e9f1f9acbdd45679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a6a8bad1ebeff5d5dee95679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +d2dbe7c8d3e25679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6e4eaf2e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff000000000000ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e8f0f8bac9db5679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6d8e1ebe2edf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e9f1f9acbdd45679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +98adc9a6b8d06786af5679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a69cb0cb96acc85679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a6e4eaf2e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8f0f8bac9db5679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6d8e1ebe2edf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e9f1f9acbdd45679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6e4eaf2e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff000000000000ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e8f0f8bac9db5679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6d8e1ebe2edf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e9f1f9acbdd45679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a6e4eaf2e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8f0f8bac9db5679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6d8e1ebe2edf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e9f1f9acbdd45679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6e4eaf2e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff000000000000ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e8f0f8bac9db5679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6d8e1ebe2edf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e9f1f9acbdd45679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a6e4eaf2e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8f0f8bac9db5679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6d8e1ebe2edf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e9f1f9acbdd45679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6e4eaf2e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff000000000000ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e8f0f8bac9db5679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6d8e1ebe2edf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e9f1f9acbdd45679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a6e4eaf2e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8f0f8bac9db5679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6d8e1ebe2edf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e9f1f9acbdd45679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6e4eaf2e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff000000000000ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e8f0f8bac9db5679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6d8e1ebe2edf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e9f1f9acbdd45679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a6e4eaf2e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8f0f8bac9db5679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6d8e1ebe2edf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e9f1f9acbdd45679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6e4eaf2e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff000000000000ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e8f0f8bac9db5679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6d8e1ebe2edf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e9f1f9acbdd45679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a6e4eaf2e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8f0f8bac9db5679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6d8e1ebe2edf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e9f1f9acbdd45679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6e4eaf2e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff000000000000ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e8f0f8bac9db5679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6d8e1ebe2edf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e9f1f9acbdd45679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a6e4eaf2e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8f0f8bac9db5679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6d8e1ebe2edf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e9f1f9acbdd45679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6e4eaf2e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff000000000000ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e8f0f8bac9db5679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6d8e1ebe2edf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e9f1f9acbdd45679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a6e4eaf2e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e8f0f8bac9db5679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6d8e1ebe2edf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e9f1f9acbdd45679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6e4eaf2e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff000000000000ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e8f0f8bccadc5b7da95b7da95b7da95b7da95b7da95b7da95b7da95b7da9 +5b7da95b7da95b7da95b7da95b7da95b7da95b7da95b7da95b7da95b7da9 +5b7da95b7da95b7da95b7da95b7da95b7da95b7da95b7da95b7da95b7da9 +5b7da95b7da95b7da95b7da93b516d415a795b7da95b7da95b7da95b7da9 +5b7da95b7da95b7da95b7da95b7da95b7da95b7da95b7da95b7da95b7da9 +5b7da95b7da95b7da95b7da95b7da95b7da95b7da95b7da95b7da95b7da9 +5b7da95b7da95b7da95b7da95b7da95b7da95b7da9d9e1ece2edf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e9f1f9b7c6d96b8ab16b8ab16b8ab16b8ab16b8ab16b8ab16b8ab16b8ab1 +6b8ab16b8ab16b8ab16b8ab16b8ab16b8ab16b8ab16b8ab16b8ab16b8ab1 +6b8ab16b8ab16b8ab16b8ab16b8ab16b8ab16b8ab16b8ab16b8ab16b8ab1 +6b8ab16b8ab16b8ab16b8ab16b8ab16b8ab16b8ab16b8ab16b8ab16b8ab1 +6b8ab16b8ab16b8ab16b8ab16b8ab16b8ab16987ae627fa26b8ab16b8ab1 +6b8ab16b8ab16b8ab16b8ab16b8ab16b8ab16b8ab16b8ab16b8ab16b8ab1 +6b8ab16b8ab16b8ab16b8ab16b8ab16b8ab16b8ab16b8ab16b8ab16b8ab1 +6b8ab16b8ab16b8ab16b8ab16b8ab16b8ab16b8ab16b8ab16b8ab16b8ab1 +6b8ab16b8ab16b8ab16b8ab16b8ab16b8ab16b8ab16b8ab16b8ab16b8ab1 +6b8ab16b8ab16b8ab1e7ecf3e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e6eff7ecf1f6e9eff5e9eff5e9eff5 +e9eff5e9eff5e9eff5e9eff5e9eff5e9eff5e9eff5e9eff5e9eff5e9eff5 +e9eff5e9eff5e9eff5e9eff5e9eff5e9eff5e9eff5e9eff5e9eff5e9eff5 +e9eff5e9eff5e9eff5e9eff5e9eff5e9eff5e9eff5e9eff5e9eff557595b +74777ae9eff5e9eff5e9eff5e9eff5e9eff5e9eff5e9eff5e9eff5e9eff5 +e9eff5e9eff5e9eff5e9eff5e9eff5e9eff5e9eff5e9eff5e9eff5e9eff5 +e9eff5e9eff5e9eff5e9eff5e9eff5e9eff5e9eff5e9eff5e9eff5e9eff5 +e9eff5e9eff5edf2f7e2ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e6eff8e8eef5e7edf4e7edf4e7edf4 +e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4 +e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4 +e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4 +e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4 +e7edf4afb3b91b1c1de7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4 +e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4 +e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4 +e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4 +e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4e7edf4eaf1f7e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff000000000000ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf654585c70767be1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6aeb6be171819e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf654585c +70767be1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6b0b9c1141516e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff000000000000ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf654585c70767be1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6b4bdc5111212e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf654585c +70767be1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6b7c0c80e0f0fe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff000000000000ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf654585c70767be1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6b9c2cb0b0c0de1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf654585c +70767be1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6bdc6ce080809e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff000000000000ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffe1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf654585c70767be1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6bfc9d1050606e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffe1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf654585c +70767be1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6c2ccd4030303e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff000000000000ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffe1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6171819232527e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf682888e000000e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6 +e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6e1ecf6ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffff000000000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff000000000000ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffff000000000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffff000000000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff000000000000ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffff000000000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffff000000000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff000000000000ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffff000000000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffff000000000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff000000000000ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffff000000000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffff000000000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff000000000000ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff000000000000ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff000000000000ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff000000000000ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffff000000ffffff000000000000ffffff000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffff000000000000000000000000 +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff000000ffffff000000 +000000ffffff000000ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffff000000000000000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffff000000000000000000000000000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff000000000000000000000000000000000000ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000000000000000000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff000000000000000000 +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff000000000000000000 +000000000000000000ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000000000000000000000ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff000000000000000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff000000000000000000000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000000000000000000000 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff000000000000000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffff000000000000000000000000ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff000000000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff000000000000000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffff000000000000000000000000 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffff000000000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff000000000000ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff000000ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000000000000000000000000000000000030406131b25141d27 +141d27141d27141d27141d27141d27141d27141d27141d27141d27141d27 +141d27141d27141d27141d27141d27141d27141d27141d27141d27141d27 +141d27141d27141d27141d27141d27141d27141d27141d27141d27141d27 +141d27141d27141d27141d27141d27141d27141d27141d27141d27141d27 +141d27141d27141d27141d27141d27141d27141d27141d27141d27141d27 +141d27141d27141d27141d27141d27141d27141d27141d27141d27141d27 +141d27141d27141d27141d27141d27141d27141d27141d27141d27141d27 +141d27141d27141d27141d27141d27141d27141d27141d27141d27141d27 +141d27141d27141d27141d27141d27141d27141d27141d27141d27141d27 +141d27141d27141d27141d27141d27141d27141d27141d27141d27141d27 +141d27141d27141d27141d27141d27141d27141d27141d27141d27141d27 +141d27141d27141d27141d27141d27141d27141d27141d27141d27141d27 +141d27141d27141d27141d27141d27141d27141d27141d27141d27141d27 +141d27141d27141d27141d27141d27141d27141d27141d27141d27141d27 +141d27141d27141d27141d27141d27141d27141d27141d27141d27141d27 +141d27141d27141d27141d27141d27141d27141d27141d27141d27141d27 +141d27141d27141d27141d27141d27141d27141d27141d27141d27141d27 +141d27141d27141d27141d27141d27141d27141d27141d27141d27141d27 +141d27141d27141d27141d27141d27141d27141d27141d27141d27141d27 +141d27141d27141d27141d27141d27141d27141d27141d27141d27141d27 +141d27141d27141d27141d27141d27141d27141d27141d27141d27141d27 +141d27141d27141d27141d27141d27141d27141d27141d27141d27141d27 +141d27141d27141d27141d27141d27141d27141d27141d27141d27141d27 +141d27141d27141d27141d27141d27141d27141d27141d27141d27141d27 +141d27141d27141d27141d27141d27141d27141d27141d27141d27141d27 +141d27141d27141d27141d27141d27141d27141d27141d27141d27141d27 +141d27141d27141d27141d27141d27141d27141d27141d27141d27141d27 +141d27141d27141d27141d27141d27141d27141d27141d27141d27141d27 +141d27141d27141d27141d27141d27141d27141d27141d27141d27141d27 +141d27141d27141d27141d27141d27141d27141d27141d27141c260c1118 +030405000000000000000000000000000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000000000000000080b0f202d3e +3a516f53749f6994ca6c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d05578a4253448020203000000 +000000000000000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff000000000000000000 +00000006080b4b69906c97cf6c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06087b832465f06090c000000000000000000000000 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffff0000000000000000000000000f151d5b80af6c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6791c62e4159000000000000000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff0000000000000000000000001c2837 +648dc16c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c97cf223042000000000000 +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +0000000000000000002c3d546a96cd6c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06791c7141c26000000000000000000000000ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff0000000000000000000b10166a95cc6c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d05f86b80a0e13 +000000000000000000ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +00000000000039506d6c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d05476a2020203000000000000ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000040608648dc16c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +18212e000000000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +0000002c3e556c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d031455f000000000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff0000000000000001015b80af6c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +4a688f000000000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +1118216c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d0638bbf000000000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff0000000000001b26346c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d010171f000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +2433456c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d0263549000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff0000000000002534486c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d029394e000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +2534486c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d029394e000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff0000000000002534486c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d029394e000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +2534486c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d029394e000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff0000000000002534486c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d029394e000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +2534486c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d029394e000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff0000000000002534486c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d029394e000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +2534486c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d029394e000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff0000000000002534486c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d029394e000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +2534486c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d029394e000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff0000000000002534486c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d029394e000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +2534486c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d029394e000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff0000000000002534486c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d029394e000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +2534486c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d029394e000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff0000000000002534486c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d029394e000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +2534486c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d05679a6 +4a688f6791c66c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d029394e000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff0000000000002534486c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d05f86b76188ba6c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d02534480000005b80af6c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d04c6b932f425b5b80af +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d029394e000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +2534486c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +0000001117206c98d06c98d06c98d06c98d06c98d06c98d06c98d0253448 +0000005b80af6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d03348630000004d6c946c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d029394e000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff0000000000002534486c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d00000001117206c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06892c8658ec36b97ce6c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d03348630000004d6c94 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d029394e000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +2534486c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +0000001117206c98d06c98d06c98d06c98d06c98d05577a3324761324761 +324761638bbf6c98d06c98d0658ec33247614663874662872a3c52587caa +6c98d06c98d03348630000004d6c946c98d0415c7e3247615476a26c98d0 +6c98d045618527364a2b3d5351729c6c98d06c98d06c98d048668b324761 +5c82b2374e6b2433464a688f6c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d029394e000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff0000000000002534486c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d00000001117206c98d06c98d06c98d0 +6c98d06c98d0405b7c0000000000000000005b80af6c98d06c98d05f86b7 +0000000e141c0102020000000203046893c96c98d03348630000004d6c94 +435f820000001f2c3c6a96cd6c98d031455f000000030507000101010202 +4c6b926c98d06c98d0293a4f000000141c26000000000000212e406c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d029394e000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +2534486c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +0000001117206c98d06c98d06c98d06c98d06c98d06b96ce6993c9243345 +0000005b80af6c98d06c98d05f86b7000000070a0e5e84b528384d000000 +52739d6c98d0334863000000354a6503040517212d6892c86c98d05f86b8 +020203131b26658ec35d83b3020304131b266c98d06c98d0293a4f000000 +141d275a7fae658ec24f6f996c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d029394e000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff0000000000002534486c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d00000001117206c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d02534480000005b80af6c98d06c98d05f86b7 +0000001d29386c98d0415c7e000000405b7c6c98d0334863000000000101 +0000005678a56c98d06c98d04a688e000000192330364c68364c680a0e13 +0102026a95cc6c98d0293a4f0000004c6b926c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d029394e000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +2534486c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +0000001117206c98d06c98d06c98d06c98d06c98d06c98d06c98d0253448 +0000005b80af6c98d06c98d05f86b70000002534476c98d0445f83000000 +405a7b6c98d03348630000000a0e130101022432456c98d06c98d0415b7d +000000000000000000000000000000000000628abc6c98d0293a4f000000 +5679a66c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d029394e000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff0000000000002534486c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d00000001117206c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d02534480000005b80af6c98d06c98d05f86b7 +0000002534476c98d0445f83000000405a7b6c98d033486300000049678d +27374b00000053749f6c98d04c6b930000002c3e556993c96993c96993c9 +6993c96c98d06c98d0293a4f000000577ba86c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d029394e000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +2534486c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +000000070a0e2f425b2f425b2f425b405b7c6c98d04e6d954a688f192431 +0000003f58794a688f5e85b65f86b70000002534476c98d0445f83000000 +405a7b6c98d03348630000004d6c945d83b302020316202b6c97cf658ec2 +06090c080b0f3e58785578a4405b7c28384d6c98d06c98d0293a4f000000 +577ba86c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d029394e000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff0000000000002534486c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d0000000000000000000000000000000 +1e2a3a6c98d00a0e14000000000000000000000000000000405a7b5f86b7 +0000002534476c98d0445f83000000405a7b6c98d03348630000004d6c94 +6c98d02b3c520000004561856c98d0466287040507000000000000000000 +1924316c98d06c98d0293a4f000000577ba86c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d029394e000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +2534486c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +51729d51729c51729c51729c51729c597daa6c98d05476a251729c51729c +51729c51729c51729c6189bb6994ca51729c5a7fae6c98d0628abd51729c +6189bb6c98d05e84b551729c648dc16c98d0658ec251729c597dab6c98d0 +6c98d06087b848658b415b7d4e6d956994ca6c98d06c98d05b81b051729c +6791c66c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d029394e000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff0000000000002534486c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d029394e000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +2534486c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d029394e000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff0000000000002534486c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d029394e000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +2534486c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d029394e000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff0000000000002534486c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d029394e000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +2534486c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d029394e000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff0000000000002534486c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d029394e000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +2534486c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d029394e000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff0000000000002534486c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d029394e000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +2534486c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d029394e000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff0000000000002534486c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d029394e000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +2534486c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d029394e000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff0000000000002534486c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d029394e000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +2534486c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d029394e000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff0000000000002534476c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d028394d000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +161e2a6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d0223042000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff0000000000000102026791c66c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d018222e000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +0000004f6f986c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06993c9070a0e000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000354b666c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +415c7e000000000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +0000001b26346c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d0121922000000000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000040507648cc06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d04e6e96 +000000000000000000ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +0000000000001a25336a95cc6c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d01e2b3b000000000000000000ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff0000000000000000002a3b516c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d053749f000101 +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffff0000000000000000003d55756c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d0466387030507000000000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff000000000000010202 +4e6d956c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c97cf344964000000000000000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff00000000000000000002030427374b577aa76c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06791c7 +233143000000000000000000000000ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +0000000000000000001b26334b6a906b97ce6c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d06c98d0 +6c98d0638bbf4a688f31455e10161e000000000000000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000000000000000000000 +0f151d2a3c52354a653c55743d56753d56753d56753d56753d56753d5675 +3d56753d56753d56753d56753d56753d56753d56753d56753d56753d5675 +3d56753d56753d56753d56753d56753d56753d56753d56753d56753d5675 +3d56753d56753d56753d56753d56753d56753d56753d56753d56753d5675 +3d56753d56753d56753d56753d56753d56753d56753d56753d56753d5675 +3d56753d56753d56753d56753d56753d56753d56753d56753d56753d5675 +3d56753d56753d56753d56753d56753d56753d56753d56753d56753d5675 +3d56753d56753d56753d56753d56753d56753d56753d56753d56753d5675 +3d56753d56753d56753d56753d56753d56753d56753d56753d56753d5675 +3d56753d56753d56753d56753d56753d56753d56753d56753d56753d5675 +3d56753d56753d56753d56753d56753d56753d56753d56753d56753d5675 +3d56753d56753d56753d56753d56753d56753d56753d56753d56753d5675 +3d56753d56753d56753d56753d56753d56753d56753d56753d56753d5675 +3d56753d56753d56753d56753d56753d56753d56753d56753d56753d5675 +3d56753d56753d56753d56753d56753d56753d56753d56753d56753d5675 +3d56753d56753d56752332433a516f3d56753d56753d56753d56753d5675 +3d56753d56753d56753d56753d56753d56753d56753d56753d56753d5675 +3d56753d56753d56753d56753d56753d56753d56753d56753d56753d5675 +3d56753d56753d56753d56753d56753d56753d56753d56753d56753d5675 +3d56753d56753d56753d56753d56753d56753d56753d56753d56753d5675 +3d56753d56753d56753d56753d56753d56753d56753d56753d56753d5675 +3d56753d56753d56753d56753d56753d56753d56753d56753d56753d5675 +3d56753d56753d56753d56753d56753d56753d56753d56753d56753d5675 +3d56753d56753d56753d56753d56753d56753d56753d56753d56753d5675 +3d56753d56753d56753d56753d56753d56753d56753d56753d56753d5675 +3d56753d56753d56753d56753d56753d56753d56753d56753d56753d5675 +3d56753d56753d56753d56753d56753d56753d56753d56753d56753d5675 +3d56753d56753d56753d56753d56753d56753d56753d56753d56753d5675 +3d56753d56753d56753d56753d56753d56753d56753d56753d56753d5675 +3d56753d56753d56753d56753d56753d56753d56753d56753d56753d5675 +3d56753d56753d56753c5473293a4f10171f000000000000000000000000 +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000000000000000000000000000000000000000 +000000000000000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff000000000000ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff000000000000ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff000000000000ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff000000000000ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff000000000000ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff000000000000ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff000000000000ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff000000000000ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000ffffffffffff000000000000 +ffffff000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffff000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffff000000000000000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffff000000000000000000000000 +000000000000ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff000000ffffff000000000000000000000000ffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffff000000000000000000000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +000000000000000000000000ffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffff000000000000000000000000 +000000ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffff000000000000000000000000000000ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff000000000000000000000000ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffff000000000000 +000000000000000000ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffff000000000000000000 +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000000000000000ffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffff000000000000000000ffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff000000 +000000000000000000ffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffeeeeee0404048b8b8b +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff000000000000000000ffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +fffffffffffffffffffffffffffffffffffffffffffffffffffffff2f5f8 +eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6 +eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6 +eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6 +eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6 +eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6 +eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6 +eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6 +eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6 +eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6 +eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6 +eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6 +eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6 +eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6 +eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6 +eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6 +eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6 +eef1f6eef1f6eef1f64d4e50eceff4eef1f6eef1f6eef1f6eef1f6eef1f6 +eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6 +eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6 +eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6 +eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6 +eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6 +eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6 +eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6 +eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6 +eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6 +eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6 +eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6 +eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6 +eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6 +eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6 +eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6 +eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6eef1f6fefeffffffff +ffffffffffffffffffffffffffffffffffffe9edf3d6dfead6dfead6dfea +d6dfead6dfead6dfead6dfead6dfead6dfead6dfead6dfead6dfead6dfea +d6dfead6dfead6dfead6dfead6dfead6dfead6dfead6dfead6dfead6dfea +d6dfead6dfead6dfead6dfead6dfead6dfead6dfead6dfead6dfead6dfea +09090a606469d6dfead6dfead6dfead6dfead6dfead6dfead6dfead6dfea +d6dfead6dfead6dfead6dfead6dfead6dfead6dfead6dfead6dfead6dfea +d6dfead6dfead6dfead6dfead6dfead6dfead6dfead6dfead6dfead6dfea +d6dfead6dfead6dfead6dfead6dfead6dfead6dfead6dfead6dfead6dfea +d6dfeae6ecf2ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff809bbc5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a64d6c945679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a6f3f5f9ffffffffffffffffffffffffffffffffffff +ffffffdee5ee5679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a61e2a3a4f70995679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a6dde4edffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff809bbc +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6f3f5f9ffffff +ffffffffffffffffffffffffffffffffffffdee5ee5679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +4b69905679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a6dde4edffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff809bbc5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a6f3f5f9ffffffffffffffffffffffffffffffffffff +ffffffdee5ee5679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a6dde4edffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff809bbc +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6f3f5f9ffffff +ffffffffffffffffffffffffffffffffffffdee5ee5679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a6dde4edffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff809bbc5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a6f3f5f9ffffffffffffffffffffffffffffffffffff +ffffffdee5ee5679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a6dde4edffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff809bbc +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6f3f5f9ffffff +ebeff5e4e9f1e4e9f1e4e9f1e4e9f1e4e9f1e2e8f0b5c5d8b5c5d8b5c5d8 +b5c5d8b5c5d8b5c5d8b5c5d8b5c5d8b5c5d8b5c5d8b5c5d8b5c5d8b5c5d8 +b5c5d8b5c5d8b5c5d8b5c5d8b5c5d8b5c5d8b5c5d8b5c5d8b5c5d8b5c5d8 +b5c5d8b5c5d8b5c5d8b5c5d8b5c5d8b5c5d8b5c5d8b5c5d8b5c5d8b5c5d8 +b5c5d8b5c5d8b5c5d8b5c5d8b5c5d8b5c5d8b5c5d8b5c5d8b5c5d8b5c5d8 +b5c5d8b5c5d8b5c5d8b5c5d8b5c5d8b5c5d8b5c5d8b5c5d8b5c5d8b5c5d8 +b5c5d8b5c5d8b5c5d8b5c5d8b5c5d8b5c5d8b5c5d8b5c5d8b5c5d8b5c5d8 +b5c5d8b5c5d8b5c5d8b5c5d8b5c5d87a95b95679a65679a65679a65679a6 +5679a6dde4edffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff809bbc5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a6f3f5f9ffffffd1dbe76181ac6181ac6181ac6181ac +6181ac6181ac6181ac6181ac6181ac6181ac6181ac6181ac6181ac6181ac +6181ac6181ac6181ac6181ac6181ac6181ac6181ac6181ac6181ac6181ac +6181ac6181ac6181ac6181ac6181ac6181ac6181ac6181ac6181ac6181ac +6181ac6181ac6181ac6181ac6181ac6181ac6181ac6181ac6181ac6181ac +6181ac6181ac6181ac6181ac6181ac6181ac6181ac6181ac6181ac6181ac +6181ac6181ac6181ac6181ac6181ac6181ac6181ac6181ac6181ac6181ac +6181ac6181ac6181ac6181ac6181ac6181ac6181ac6181ac6181ac839dbe +96abc85679a65679a65679a65679a65679a6dde4edffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff809bbc +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6f3f5f9ffffff +ced8e55679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a67b96ba96abc85679a65679a65679a65679a6 +5679a6dde4edffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff809bbc5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a6f3f5f9ffffffced8e55679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a67b96ba +96abc85679a65679a65679a65679a65679a6dde4edffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff809bbc +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6f3f5f9ffffff +ced8e55679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a67b96ba96abc85679a65679a65679a65679a6 +5679a6dde4edffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff809bbc5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a6f3f5f9ffffffced8e55679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a67b96ba +96abc85679a65679a65679a65679a65679a6dde4edffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff809bbc +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6f3f5f9ffffff +ced8e55679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a67b96ba96abc85679a65679a65679a65679a6 +5679a6dde4edffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff809bbc5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a6f3f5f9ffffffced8e55679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a67b96ba +96abc85679a65679a65679a65679a65679a6dde4edffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff809bbc +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6f3f5f9ffffff +ced8e55679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a67b96ba96abc85679a65679a65679a65679a6 +5679a6dde4edffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff809bbc5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a6f3f5f9ffffffced8e55679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a67b96ba +96abc85679a65679a65679a65679a65679a6dde4edffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff809bbc +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6f3f5f9ffffff +ced8e55679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a67b96ba96abc85679a65679a65679a65679a6 +5679a6dde4edffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff809bbc5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a6f3f5f9ffffffced8e55679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a67b96ba +96abc85679a65679a65679a65679a65679a6dde4edffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff809bbc +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6f3f5f9ffffff +ced8e55679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a67b96ba96abc85679a65679a65679a65679a6 +5679a6dde4edffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff809bbc5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a6f3f5f9ffffffced8e55679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a67b96ba +96abc85679a65679a65679a65679a65679a6dde4edffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff809bbc +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6f3f5f9ffffff +ced8e55679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a67b96ba96abc85679a65679a65679a65679a6 +5679a6dde4edffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff809bbc5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a6f3f5f9ffffffced8e55679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a67b96ba +96abc85679a65679a65679a65679a65679a6dde4edffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff809bbc +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6f3f5f9ffffff +ced8e55679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a67b96ba96abc85679a65679a65679a65679a6 +5679a6dde4edffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff809bbc5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a6f3f5f9ffffffced8e55679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a67b96ba +96abc85679a65679a65679a65679a65679a6dde4edffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff809bbc +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6f3f5f9ffffff +ced8e55679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a67b96ba96abc85679a65679a65679a65679a6 +5679a6dde4edffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff809bbc5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a6f3f5f9ffffffced8e55679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a67b96ba +96abc85679a65679a65679a65679a65679a6dde4edffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff809bbc +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6f3f5f9ffffff +ced8e55679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a67b96ba96abc85679a65679a65679a65679a6 +5679a6dde4edffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff809bbc5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a6f3f5f9ffffffced8e55679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +8ca4c2b5c4d8a6b9d07d98bb5679a65679a65679a65679a65679a65679a6 +5679a65679a65679a66b8ab17c97ba5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a6dde4eda7b9d15679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a67b96ba +96abc85679a65679a65679a65679a65679a6dde4edffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff809bbc +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6f3f5f9ffffff +ced8e55679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a6b6c5d9fcfcfdf8f9fbffffffa3b6ce +5679a65679a65679a65679a65679a65679a65679a65679a6abbdd3eef2f6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a6eaeff4 +afc0d55679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a67b96ba96abc85679a65679a65679a65679a6 +5679a6dde4edffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff809bbc5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a67290b5 +7491b65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a6587ba7809bbc6585ae5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a6f3f5f9ffffffced8e55679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +b6c5d9e4e9f16181accdd7e4f5f7fa5b7da96a89b0b1c1d6c3d0e09aafca +6384ad5679a6aabbd2dbe2ecf8f9fbb5c5d89db1cb5679a67793b7b8c7da +c0cdde90a7c55d7ea95679a6eaeff4b5c4d8b3c3d792a9c6577aa65679a6 +869fbfbdcbdcbac8db869fbf577aa75679a66b89b1a8bad1c3d0e0a5b8d0 +5679a65679a66988b0b4c4d8afbfd56a89b05679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a67b96ba +96abc85679a65679a65679a65679a65679a6dde4edffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff809bbc +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +7a96b98ba3c25b7da85679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a698adc9c5d1e1c5d1e16f8cb3 +5679a65679a65679a65679a6cad5e3d0dae65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65f80abffffff91a8c5 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a6597ba7 +8ba3c28ba3c28ba3c28ba3c26a89b05679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a6aebfd49aafca5679a65679a65679a66988b0c5d1e1c5d1e19db1cb +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6f3f5f9ffffff +ced8e55679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a6b6c5d9e4e9f15679a698aec9ffffff +6f8cb390a7c5cfd9e6aebfd4e6ecf2bdcadc5679a6b7c6d9e3e8f0fafbfc +c5d1e1a9bbd25679a6acbdd3c5d1e0b0c0d5f3f6f99eb2cc5679a6eaeff4 +f8fafcdde4edffffffa0b4cd5679a6c5d1e1bbc9dbb5c4d8fdfdfe7e99bb +5679a6cdd7e4dee5eeadbed4d5dde95679a65a7ca8ebeff5e1e7efcbd5e3 +fdfdfe6585ae5679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a67b96ba96abc85679a65679a65679a65679a6 +5679a6dde4edffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff809bbc5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a6e6ecf2ffffff819bbd5679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a68ea6c4c3cfdfffffff7b96ba5679a65679a65679a65679a69bb0ca +9eb2cc5679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a6aabbd2f0f3f75679a65679a6 +5679a65679a65b7da9bbc9db7995b85679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65f80abffffffffffffffffffffffff97acc8 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a69eb2ccfcfdfe5679a65679a65679a6 +5679a65679a65679a65679a65679a65679a6dde4edbdcadc5679a65679a6 +5679a66686aeb5c5d8eef1f6c3cfdf5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a6f3f5f9ffffffced8e55679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +b6c5d9e4e9f15679a6839dbeffffff7a96b9587ba77290b59cb1cbcdd7e4 +e7ecf25679a65679a6abbdd3eef2f65679a65679a65679a6597ca87b96ba +a1b4cddde4edc7d3e25679a6eaeff4d0dae65679a6d1dae7c7d2e15679a6 +5d7faa839dbea4b6cfeef2f6a8bad15679a6e6ebf2e2e8f07c97ba5679a6 +5679a687a0c0ffffff8aa2c17692b7f2f4f896abc85679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a67b96ba +96abc85679a65679a65679a65679a65679a6dde4edffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff809bbc +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a66686ae +ffffffe6ecf2aabcd25679a65c7ea98ba3c26d8bb290a7c46081ab5679a6 +6182ac8ba3c26b8ab18fa6c45c7ea95679a65679a67592b6ffffff7b96ba +5679a65679a6597ba78ba3c28ba3c27c97ba5679a65679a65679a6587ba7 +8ca4c29db1cb718fb45679a65b7da8869fbf99aec9718eb45679a65679a6 +849dbec5d1e0f5f7fa8ba3c27e99bb5679a66d8bb28ba3c28ba3c26887af +5679a65679a65679a66282ac8ba3c25a7ca85679a65679a6849dbe7290b5 +88a1c1718fb45679a65679a65679a65679a65679a65679a65679a65f80ab +ffffff9cb0cb6686ae6686ae5c7ea96c8ab28ba3c25f80ab6081ab8ba3c2 +6d8bb25679a65f80ab90a7c57894b85679a65679a65679a6577aa688a0c0 +9eb2cc7692b75679a66e8cb388a1c15679a67290b5839dbe5679a6809abc +bccadcfdfdfe8ba3c2829cbd5679a65e7faa8aa3c298adc96b89b15679a6 +5679a6dde4edbdcadc829cbd728fb55679a65679a65679a6d7dfeac3cfdf +5679a65679a65679a65679a6819bbd8ca4c3597ca85679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6f3f5f9ffffff +ced8e55679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a6b6c5d9e4e9f15679a69aafcaffffff +6d8bb2a1b4cdfdfdfed7dfeadee5eefefeff5679a65679a6abbdd3eef2f6 +5679a65679a65679a6c0cddef8fafcd1dbe7e8edf3dfe5ee5679a6eaeff4 +b7c6d95679a6b8c7dae1e7ef5679a6e0e6eff2f5f8ccd7e4f4f6f9bfcddd +5679a688a1c1ebeff5ffffffced8e5597ba79aafcaffffffffffffffffff +ffffffbdcadc5679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a67b96ba96abc85679a65679a65679a65679a6 +5679a6dde4edffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff809bbc5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a68ea6c4f4f6f9adbed4d3dce85679a66b89b1 +ffffffe8edf3fafbfcf2f4f86b89b17a96b9ffffffe8edf3fafbfcecf0f5 +6081ab5679a67592b6ffffff7b96ba5679a65679a65f80abf0f3f7fafbfd +d0dae65679a65679a65679a6cdd7e4fffffff2f4f8eaeef45679a68fa6c4 +f4f6f9d9e1ebf8fafcaebfd45679a6dbe3ecf7f9fbfefefef0f3f7cad5e3 +5679a698aec9f0f3f7ffffff91a8c55679a65679a691a8c5f8f9fbf9fafc +edf1f67390b55679a6e9eef3eaeff4f8fafcfefefe6f8cb35679a65679a6 +5679a65679a65679a65679a65f80abffffffa3b6ce718eb4718eb4597ba7 +6484adf3f6f9acbdd3abbdd3f5f7fa6686ae5e7faae7ecf2f4f7f9f6f8fa +cfd9e65679a65679a6c1cedefffffff2f5f8f6f8fa5679a6a3b6cef7f9fb +5679a6b3c3d7e7ecf25679a6d1dae7f6f8fafffffff0f3f7d5dde95679a6 +a3b6cef0f3f7d9e1ebfbfcfd9cb0cb5679a6dde4edeaeff4fbfcfdfdfdfe +96acc85679a65679a6d7dfeac3cfdf5679a65679a65679a6b4c4d8fefefe +edf1f6eff2f7718fb45679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a6f3f5f9ffffffced8e55679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +b6c5d9e4e9f16786afd2dbe7f2f5f85a7ca8dbe2ecd1dae75679a6b5c5d8 +fefeff5679a65679a6a5b8d0f3f6f95679a65679a6587ba7f8f9fbb1c2d6 +5679a6d5dee9dfe5ee5679a6eaeff4d0dae65679a6d1dae7c4d0e0708db4 +ffffff92a8c5577aa6f4f6f9bfcddd5679a6577aa7577aa78aa3c2ffffff +7e99bb88a0c0ffffff7491b65679a65679a66081ab5679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a67b96ba +96abc85679a65679a65679a65679a65679a6dde4edffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff809bbc +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a6b7c6d9 +d1dbe78ba3c2f8fafc597ca86b89b1ffffffb7c6d96786affcfcfd94aac6 +7a96b9ffffffa8bad17290b5ffffff849dbe5679a67592b6ffffff7b96ba +5679a65679a65679a65679a6cad5e3d0dae65679a65679a67c97baffffff +a1b4cd5679a6718fb45679a66585ae5d7ea9728fb5b9c8dadee5ee5679a6 +5679a6aabbd2f0f3f75679a65679a65679a65679a65f80abffffff91a8c5 +5679a65679a6d6dee9beccdd5e7faae4eaf1abbdd35679a6e9eef3d1dbe7 +6182acfefefe95abc75679a65679a65679a65679a65679a65679a65f80ab +ffffffffffffffffffffffff6787af5679a698adc9f6f8faf4f7f99cb0cb +5679a69aafcafafbfc6383ad6c8ab2ffffff6c8ab2708db4ffffffacbdd3 +577aa6718fb45679a6a3b6cef7f9fb5679a6b3c3d7e7ecf25679a65679a6 +9eb2ccfcfdfe5679a65679a65679a66887af5b7da87491b6c9d4e2cbd5e3 +5679a6dde4ede9eef36383add5dde9cbd6e45679a65679a6d7dfeac3cfdf +5679a65679a66282acfcfdfe99aec95679a6dae2eba7b9d15679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6f3f5f9ffffff +ced8e55679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a6b6c5d9fefefefcfdfefefefe9bb0ca +5679a6b5c5d8f3f6f9b5c5d8f3f6f9fefeff5679a65679a67b96baffffff +dae2ebb1c1d65679a6d5dee9e6ebf2bccadcfafbfcdfe5ee5679a6eaeff4 +f6f8fadde4edffffff9cb0cb597ba7f2f4f8d6dee9c9d4e2fcfdfebfcddd +5679a6d9e1ebb9c7dac5d1e0fbfcfd6384ad5a7ca8e8edf3eef2f6c4d0e0 +e0e6ef9aafca5679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a67b96ba96abc85679a65679a65679a65679a6 +5679a6dde4edffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff809bbc5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a6e0e6efe0e6efc1cedfffffff7a96b96b89b1 +ffffff8ea6c45679a6e3e9f0b5c4d87a96b9ffffff7f9abc5679a6f3f6f9 +a6b8d05679a67592b6ffffff7b96ba5679a65679a65679a65679a6cad5e3 +d0dae65679a65679a694aac7ffffff6484ad5679a65679a65679a6869fbf +f0f3f7fcfdfef6f8fafefefe5679a65679a6aabbd2f0f3f75679a65679a6 +5679a65679a65f80abffffff91a8c55679a65d7faafdfdfe91a8c55679a6 +beccddd8e0ea5679a6e9eef3b3c3d75679a6f4f6f9a2b5ce5679a65679a6 +5679a65679a65679a65679a65f80abffffffadbed4809bbc809bbc5a7ca8 +5679a6577aa6e8edf3ebeff5577aa75679a6b6c5d9fefefef4f7f9f4f7f9 +ffffff99aec988a0c0ffffff708db45679a65679a65679a6a3b6cef7f9fb +5679a6b3c3d7e7ecf25679a65679a69eb2ccfcfdfe5679a65679a65679a6 +96acc8f4f7f9fafbfdf8f9fbeaeff45679a6dde4edc7d2e15679a6acbdd3 +ecf0f55679a65679a6d7dfeac3cfdf5679a65679a67b96bafffffff6f8fa +f4f7f9fbfcfdd5dde95679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a6f3f5f9ffffffced8e55679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +869fbfaabcd29cb0cb7491b65679a65679a66182aca2b5ceb1c2d6859ebf +aabcd25679a65679a6577aa67a96b9a4b6cf95abc75679a66b89b1acbdd3 +a6b9d08ca4c29aafca5679a6a0b4cd87a0c0aebfd48ca4c35679a65679a6 +7692b7b4c4d897acc898aec98aa3c25679a691a8c5bac8dbb3c3d77e99bb +5679a65679a66585aeadbed4bfcddda7b9d16787af5679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a67b96ba +96abc85679a65679a65679a65679a65679a6dde4edffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff809bbc +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a66181acfefefe +dfe5eed5dee9f8f9fba4b6cf6b89b1ffffff9eb2cc5679a6f2f5f8a4b6cf +7a96b9ffffff8ea5c35b7da9fdfdfe94aac75679a66988b0ffffff869fbf +5679a65679a65679a65679a6cad5e3d0dae65679a65679a68aa3c2ffffff +7a95b95679a65679a65679a6d1dae7dde4ed5b7da9abbcd3ffffff577aa6 +5679a6a8bad1f1f4f85679a65679a65679a65679a65f80abffffff91a8c5 +5679a65679a6ecf0f5a1b4cd5679a6cfd9e6c1cede5679a6e9eef3b1c2d6 +5679a6f4f6f9a2b5ce5679a65679a65679a65679a65679a65679a65f80ab +ffffff92a8c55679a65679a65679a65679a6869fbffcfdfefcfcfd88a0c0 +5679a6acbdd3f8f9fb829cbd809bbc809bbc6988b07e99bbffffff869fbf +5679a65679a65679a6a0b4cdfafbfd577aa6bfccdde7ecf25679a65679a6 +9cb0cbfdfdfe5679a65679a65679a6e4e9f1ccd7e4597ca8bfccddecf0f5 +5679a6dde4edd4dde85679a6b9c8dadbe3ec5679a65679a6ccd7e4cdd8e5 +5679a65679a6718eb4ffffffa7b9d1809bbc809bbc7894b85679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6f3f5f9ffffff +ced8e55679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a67b96ba96abc85679a65679a65679a65679a6 +5679a6dde4edffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff809bbc5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a688a0c0ffffff6585ae5679a6c9d4e3ccd7e46b89b1 +ffffffeaeff4c0cddeffffff809bbc7a96b9ffffffe3e9f0c7d2e1ffffff +718eb45679a65679a6eef1f6dbe3eca6b8d06787af7894b8a6b8d0e3e9f0 +e6ecf2a6b8d07b96ba6282acf5f7fae3e8f0a3b6cebfcddd5679a6c3cfdf +e7ecf28aa3c2e6ebf2ffffff577aa65679a6859ebfffffffb0c0d592a8c5 +5679a696abc8aabcd2ffffffc5d1e0a6b8d05d7faabbc9dbecf0f5b1c2d6 +fafbfd92a8c55679a6e9eef3b1c2d65679a6f4f6f9a2b5ce5679a65679a6 +5679a65679a65679a65679a65f80abffffffdae2ebc5d1e1c5d1e1809bbc +5d7ea9eaeef4bccadcbac8dbeaeff45d7ea97a95b9ffffffc1cede99aec9 +c1cedf7a96b95d7ea9eef2f6e7ecf2a4b7cfc5d1e15679a6829cbdffffff +b3c3d7f2f4f8e7ecf25679a65679a67995b8ffffffb7c6d998adc95679a6 +d6dee9dbe2ec8ea5c3f0f3f7ecf0f55679a6dde4edfafbfcb3c3d7f4f6f9 +b7c6d95679a65679a6a6b9d0f8f9fbafbfd588a1c1587ba7e5ebf1dfe6ee +9db1cbacbdd3aabbd25679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a6f3f5f9ffffffced8e55679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a67b96ba +96abc85679a65679a65679a65679a65679a6dde4edffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff809bbc +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a696abc8c7d3e2 +5679a65679a694aac6c9d4e36b89b1ffffffb1c1d6dee5eea0b4cd597ba7 +7a96b9ffffffacbdd3dee5ee98adc9577aa65679a65679a67e99bbc4d0e0 +d5dee9728fb58da5c3d5dee9d5dee9d5dee9d5dee992a8c55679a67e99bb +d6dee9e7ecf2b3c3d75679a67390b5cbd6e4dde4edacbdd3d5dee95679a6 +5679a65b7da9a4b7cfcdd8e5b6c5d95679a6bccadcd5dee9d5dee9d5dee9 +d5dee96383ad6282acaabbd2dbe2ec97acc8597ca85679a6c4d0e09aafca +5679a6ccd7e48ea6c45679a65679a65679a65679a65679a65679a65d7ea9 +d5dee9d5dee9d5dee9d5dee9869fbf92a8c5d5dde96988b06988b0d5dde9 +91a8c55679a695abc7dee5eee8edf3c9d4e36988b05679a67693b7d3dce8 +e8edf3bdcbdc5679a65d7ea9c0cdded8e0eaacbdd3c3cfdf5679a65679a6 +577aa7a1b4cdcbd6e4bfccdd5679a67d98bbd3dce8d7dfeaafc0d5c7d2e1 +5679a6bbc9dbadbed4d3dce8bfcddd6585ae5679a65679a66383adaabcd2 +d5dde9a8bad15679a6718eb4cfd9e6eaeef4d9e1eb8aa3c25679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6f3f5f9ffffff +ced8e55679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a66282ac96acc88ca4c25d7faa5679a65679a65679a65679a6 +5679a65679a65679a6a3b6cea6b8d05679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a67b96ba96abc85679a65679a65679a65679a6 +5679a6dde4edffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff809bbc5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a66b89b1 +ffffff869fbf5679a65679a65679a67a96b9ffffff7692b75679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a6f3f5f9ffffffced8e55679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a67592b6fbfcfdf6f8fafdfdfe +b9c8da5679a65679a65679a65679a65679a65679a65679a6cbd6e4cfd9e6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a67b96ba +96abc85679a65679a65679a65679a65679a6dde4edffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff809bbc +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a66b89b1ffffff869fbf5679a65679a65679a6 +7a96b9ffffff7692b75679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6f3f5f9ffffff +ced8e55679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a6b2c2d7e0e6ef587ba76081ab809abc5679a65679a65f80ab93a9c6 +99aec96786af5679a6cbd6e4cfd9e67c97ba7e99bb5679a65679a65679a6 +7b96ba90a7c55d7ea95679a66585ae7c97ba8ca4c36887af8fa6c45e7faa +5679a66c8ab295abc78ca4c35d7ea95679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a67b96ba96abc85679a65679a65679a65679a6 +5679a6dde4edffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff809bbc5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a6f3f5f9ffffffced8e55679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a6afc0d5f5f7fa90a7c4577aa7 +5679a65679a65e7faae6ebf2fffffff1f4f8c9d4e35679a6cbd6e4ecf0f5 +f6f8faffffff8ba3c25679a6a2b5ceffffffecf0f5f4f6f97e99bb869fbf +f8f9fbf0f3f7f4f6f9f0f3f7c1cede5679a6dfe6eee3e8f0e3e9f0f9fafc +6585ae5679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a67b96ba +96abc85679a65679a65679a65679a65679a6dde4edffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff809bbc +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6f3f5f9ffffff +ced8e55679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a66b89b1dbe3ecffffffdce3ed6c8ab25679a69db1cbffffff809abc +5679a6718fb45679a6cbd6e4ecf0f55c7ea9eaeef4b3c3d7577aa7f5f7fa +aabcd25679a6c9d4e2b9c7da869fbfebeff58ca4c3ebeff592a8c5d5dde9 +5679a66b8ab16081ab7c97baf6f8fa8ea5c35679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a67b96ba96abc85679a65679a65679a65679a6 +5679a6dde4edffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff809bbc5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a6f3f5f9ffffffced8e55679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a6587ba796acc8f2f5f8 +d1dae75679a6b5c5d8ecf0f55679a65679a65679a65679a6cbd6e4d1dae7 +5679a6d6dee9bfccdd6988b0fffffff8f9fbf4f7f9fafbfde6ecf2869fbf +e4eaf1869fbfe4eaf18ba3c2e3e9f05679a6cbd5e3fdfdfef4f7f9fefefe +adbed45679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a67b96ba +96abc85679a65679a65679a65679a65679a6dde4edffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff809bbc +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6f3f5f9ffffff +ced8e55679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a66383ad5679a65679a6afbfd5f1f4f85679a6acbdd3fbfcfd5d7ea9 +5679a65679a65679a6cbd6e4cfd9e65679a6d6dee9bfccdd5f80abffffff +b4c4d8809bbc809bbc7c97ba869fbfe4eaf1869fbfe4eaf18ba3c2e4eaf1 +7793b7ffffff92a9c6597ba7f8fafcafc0d55679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a67b96ba96abc85679a65679a65679a65679a6 +5679a6dde4edffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff809bbc5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a6f3f5f9ffffffced8e55679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a6c5d1e0c4d0e0a7b9d1ebeff5 +c3d0e05679a67a95b9ffffffd3dce8a2b5ceafbfd55679a6cbd6e4cfd9e6 +5679a6d6dee9bfccdd5679a6d6dee9e6ecf2a0b3cda7b9d1b5c5d8869fbf +e4eaf1869fbfe4eaf18ba3c2e4eaf16b89b1fefeffadbed4acbdd3ffffff +afc0d55679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a67b96ba +96abc85679a65679a65679a65679a65679a6dde4edffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff809bbc +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6f3f5f9ffffff +ced8e55679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a68ba3c2d5dee9e4eaf1b8c7da708db45679a65679a694aac6dee5ee +e4e9f19aafca5679a6adbed4b1c1d65679a6b5c5d8a5b8d05679a66988b0 +c9d4e2e9eef3dce3ed96acc87a95b9c1cede7a95b9c1cede7e99bbc1cede +5679a6a3b6cee1e7efb8c7dac8d3e299aec95679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a67b96ba96abc85679a65679a65679a65679a6 +5679a6dde4edffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff809bbc5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a6f3f5f9ffffffced8e55679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a67b96ba +96abc85679a65679a65679a65679a65679a6dde4edffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff809bbc +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6f3f5f9ffffff +ced8e55679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a67b96ba96abc85679a65679a65679a65679a6 +5679a6dde4edffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff809bbc5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a6f3f5f9ffffffced8e55679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a67b96ba +96abc85679a65679a65679a65679a65679a6dde4edffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff809bbc +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6f3f5f9ffffff +ced8e55679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a67b96ba96abc85679a65679a65679a65679a6 +5679a6dde4edffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff809bbc5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a6f3f5f9ffffffced8e55679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a67b96ba +96abc85679a65679a65679a65679a65679a6dde4edffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff809bbc +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6f3f5f9ffffff +ced8e55679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a67b96ba96abc85679a65679a65679a65679a6 +5679a6dde4edffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff809bbc5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a6f3f5f9ffffffced8e55679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a67b96ba +96abc85679a65679a65679a65679a65679a6dde4edffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff809bbc +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6f3f5f9ffffff +ced8e55679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a67b96ba96abc85679a65679a65679a65679a6 +5679a6dde4edffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff809bbc5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a6f3f5f9ffffffced8e55679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a67b96ba +96abc85679a65679a65679a65679a65679a6dde4edffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff809bbc +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6f3f5f9ffffff +ced8e55679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a67b96ba96abc85679a65679a65679a65679a6 +5679a6dde4edffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff809bbc5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a6f3f5f9ffffffced8e55679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a67b96ba +96abc85679a65679a65679a65679a65679a6dde4edffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff809bbc +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6f3f5f9ffffff +ced8e55679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a67b96ba96abc85679a65679a65679a65679a6 +5679a6dde4edffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff809bbc5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a6f3f5f9ffffffced8e55679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a67b96ba +96abc85679a65679a65679a65679a65679a6dde4edffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff809bbc +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6f3f5f9ffffff +ced8e55679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a67b96bacbd6e4b3c3d7b3c3d7b3c3d7b3c3d7 +b3c3d7e5eaf1ffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff809bbc5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a6f3f5f9ffffffced8e55679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a67b96ba +ebeff5ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff809bbc +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6f3f5f9ffffff +ced8e55679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a67b96bae8edf3ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff809bbc5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a6f3f5f9ffffffced8e55679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a67b96ba +e8edf3ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff809bbc +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6f3f5f9ffffff +ced8e55679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a67b96bae8edf3ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffff809bbc5679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a6f3f5f9ffffffced8e55679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a67b96ba +e8edf3ffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffff809bbc +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a65679a65679a6 +5679a65679a65679a65679a65679a65679a65679a65679a6f3f5f9ffffff +dae2eb7b96ba7b96ba7b96ba7b96ba7b96ba7b96ba7b96ba7b96ba7b96ba +7b96ba7b96ba7b96ba7b96ba7b96ba7b96ba7b96ba7b96ba7b96ba7b96ba +7b96ba7b96ba7b96ba7b96ba7b96ba7b96ba7b96ba7b96ba7b96ba7b96ba +7b96ba7b96ba7b96ba7b96ba7b96ba7b96ba7b96ba7b96ba7b96ba7b96ba +7b96ba7b96ba7b96ba7b96ba7b96ba7b96ba7b96ba7b96ba7b96ba7b96ba +7b96ba7b96ba7b96ba7b96ba7b96ba7b96ba7b96ba7b96ba7b96ba7b96ba +7b96ba7b96ba7b96ba7b96ba7b96ba7b96ba7b96ba7b96ba7b96ba7b96ba +7b96ba7b96ba7b96ba7b96ba98adc9e8edf3ffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffb0c0d596abc896abc896abc896abc896abc8 +96abc896abc896abc896abc896abc896abc896abc896abc896abc896abc8 +96abc896abc896abc896abc896abc896abc896abc896abc896abc896abc8 +96abc896abc896abc896abc896abc896abc896abc896abc896abc896abc8 +96abc896abc896abc896abc896abc896abc896abc896abc896abc896abc8 +96abc896abc896abc896abc896abc896abc896abc896abc896abc896abc8 +96abc896abc896abc896abc896abc896abc896abc896abc896abc896abc8 +96abc896abc896abc896abc896abc896abc896abc896abc896abc896abc8 +96abc896abc896abc896abc896abc896abc896abc896abc896abc896abc8 +96abc896abc896abc896abc896abc896abc896abc896abc896abc896abc8 +96abc896abc896abc896abc896abc896abc896abc896abc896abc896abc8 +96abc896abc896abc896abc896abc896abc896abc896abc896abc896abc8 +96abc896abc896abc896abc896abc896abc896abc896abc896abc896abc8 +96abc896abc896abc896abc896abc896abc896abc896abc896abc896abc8 +96abc896abc896abc896abc896abc896abc896abc896abc896abc896abc8 +96abc896abc896abc896abc896abc896abc896abc896abc896abc896abc8 +96abc896abc896abc896abc896abc896abc896abc896abc896abc896abc8 +96abc896abc896abc896abc896abc896abc896abc896abc896abc896abc8 +96abc896abc896abc896abc896abc896abc896abc896abc896abc896abc8 +96abc896abc896abc896abc896abc896abc896abc896abc896abc896abc8 +96abc896abc896abc896abc896abc896abc896abc896abc896abc896abc8 +96abc896abc896abc896abc896abc896abc896abc896abc896abc896abc8 +96abc896abc896abc896abc896abc896abc896abc896abc896abc896abc8 +96abc896abc896abc896abc896abc896abc896abc896abc896abc896abc8 +96abc896abc896abc896abc896abc896abc896abc896abc896abc896abc8 +96abc896abc896abc896abc896abc896abc896abc896abc896abc896abc8 +96abc896abc896abc896abc896abc896abc896abc896abc896abc896abc8 +96abc896abc896abc896abc896abc896abc896abc896abc896abc896abc8 +96abc896abc896abc896abc896abc896abc896abc896abc896abc896abc8 +96abc896abc896abc896abc896abc896abc896abc896abc896abc896abc8 +96abc896abc896abc896abc896abc896abc896abc896abc896abc896abc8 +96abc896abc896abc896abc896abc896abc896abc896abc896abc896abc8 +96abc896abc896abc896abc896abc896abc896abc896abc896abc896abc8 +96abc896abc896abc8f8f9fbfffffff1f4f8ebeff4ebeff4ebeff4ebeff4 +ebeff4ebeff4ebeff4ebeff4ebeff4ebeff4ebeff4ebeff4ebeff4ebeff4 +ebeff4ebeff4ebeff4ebeff4ebeff4ebeff4ebeff4ebeff4ebeff4ebeff4 +ebeff4ebeff4ebeff4ebeff4ebeff4ebeff4ebeff4ebeff4ebeff4ebeff4 +ebeff4ebeff4ebeff4ebeff4ebeff4ebeff4ebeff4ebeff4ebeff4ebeff4 +ebeff4ebeff4ebeff4ebeff4ebeff4ebeff4ebeff4ebeff4ebeff4ebeff4 +ebeff4ebeff4ebeff4ebeff4ebeff4ebeff4ebeff4ebeff4ebeff4ebeff4 +ebeff4ebeff4ebeff4ebeff4ebeff4ebeff4ebeff4ebeff4ebeff4ebeff4 +f8f9fbffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff +ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + + +[/Creator (html2ps version 1.0 beta7) /Author () /Keywords (odb, c++, object, persistence, ORM, relational, database, RDBMS, ODBMS, OODBMS) /Subject () + /Title (C++ Object Persistence with ODB) /DOCINFO pdfmark +/ND 1 D +/HN [(1) (1) (1) (1) (1) (2) (3) (4) (4) (8) (9) (10) (10) (13) (14) (15) (18) +(20) (22) (24) (25) (27) (29) (30) (30) (32) (35) (37) (39) (44) (45) (47) +(48) (50) (52) (54) (54) (57) (63) (64) (??) (65) (66) (69) (73) (81) (82) +(84) (85) (86) (88) (91) (92) (95) (95) (96) (97) (100) (101) (102) (103) +(106) (111) (112) (112) (112) (115) (116) (119) (123) (125) (126) (131) +(134) (135) (142) (143) (145) (146) (147) (149) (155) (161) (163) (164) +(166) (168) (170) (173) (174) (177) (182) (183) (191) (198) (199) (205) +(207) (213) (215) (216) (218) (219) (220) (220) (221) (221) (222) (222) +(225) (228) (228) (228) (229) (229) (229) (229) (229) (230) (230) (230) +(230) (230) (230) (231) (231) (233) (233) (234) (235) (235) (236) (236) +(237) (237) (238) (238) (238) (238) (239) (239) (239) (239) (240) (240) +(240) (240) (240) (242) (243) (243) (244) (244) (248) (249) (250) (251) +(252) (252) (252) (254) (257) (258) (260) (261) (261) (261) (262) (262) +(263) (263) (263) (263) (263) (264) (264) (265) (265) (265) (266) (266) +(266) (267) (267) (267) (268) (269) (270) (270) (271) (271) (271) (274) +(278) (278) (279) (279) (279) (280) (280) (281) (281) (283) (285) (292) +(293) (295) (298) (301) (305) (305) (??) (306) (307) (308) (311) (314) (315) +(315) (315) (316) (319) (319) (320) (321) (322) (325) (329) (330) (330) +(330) (331) (332) (332) (332) (332) (333) (335) (335) (336) (337) (338) +(341) (343) (344) (344) (345) (345) (345) (345) (345) (346) (347) (347) +(348) (349) (350) (353) (356) (358) (358) (359) (359) (359) (359) (360) +(360) (360) (360) (360) (362) (362) (364) (365) (366) (367) (368) (373) +(376) (378) (378) (378) (379) (379) (379) (379) (379) (380) (380) (380) +(383) (384) (385) (385) (386) (387) (388) (389) (390) (391) (392) (392) +(393) (394) (394) (395) (395) (395) (395) (396) (396) (397) (397) (398) +(398) (399) (400) (401) (402) (404) (405) (406) (407) (408) (408) (1) (1) +(2) (3) (4) (4) (8) (9) (10) (10) (13) (14) (15) (18) (20) (22) (24) (25) +(27) (29) (30) (30) (32) (35) (37) (39) (44) (45) (47) (48) (50) (52) (54) +(54) (57) (63) (64) (65) (66) (69) (73) (81) (82) (84) (85) (86) (88) (91) +(92) (95) (95) (96) (97) (100) (101) (102) (103) (106) (111) (112) (112) +(112) (115) (116) (119) (123) (125) (126) (131) (134) (135) (142) (143) +(145) (146) (147) (149) (155) (161) (163) (164) (166) (168) (170) (173) +(174) (177) (182) (183) (191) (198) (199) (205) (207) (213) (215) (216) +(218) (219) (220) (220) (221) (221) (222) (222) (225) (228) (228) (228) +(229) (229) (229) (229) (229) (230) (230) (230) (230) (230) (230) (231) +(231) (233) (233) (234) (235) (235) (236) (236) (237) (237) (238) (238) +(238) (238) (239) (239) (239) (239) (240) (240) (240) (240) (240) (242) +(243) (243) (244) (244) (248) (249) (250) (251) (252) (252) (252) (254) +(257) (258) (260) (261) (261) (261) (262) (262) (263) (263) (263) (263) +(263) (264) (264) (265) (265) (265) (266) (266) (266) (267) (267) (267) +(268) (269) (270) (270) (271) (271) (271) (274) (278) (278) (279) (279) +(279) (280) (280) (281) (281) (283) (285) (292) (293) (295) (298) (301) +(305) (305) (306) (307) (308) (311) (314) (315) (315) (315) (316) (319) +(319) (320) (321) (322) (325) (329) (330) (330) (330) (331) (332) (332) +(332) (332) (333) (335) (335) (336) (337) (338) (341) (343) (344) (344) +(345) (345) (345) (345) (345) (346) (347) (347) (348) (349) (350) (353) +(356) (358) (358) (359) (359) (359) (359) (360) (360) (360) (360) (360) +(362) (362) (364) (365) (366) (367) (368) (373) (376) (378) (378) (378) +(379) (379) (379) (379) (379) (380) (380) (380) (383) (384) (385) (385) +(386) (387) (388) (389) (390) (391) (392) (392) (393) (394) (394) (395) +(395) (395) (395) (396) (396) (397) (397) (398) (398) (399) (400) (401) +(402) (404) (405) (406) (407) (408) (408)] D +/h0 [()(Table of Contents)] D +/h1 [(1\240\240)(Preface)] D +/h2 [(1.1\240\240)(About This Document)] D +/h3 [(1.2\240\240)(More Information)] D +/h4 [(2\240\240)(PART I\240\240 OBJECT-RELATIONAL MAPPING)] D +/h5 [(3\240\240)(1 Introduction)] D +/h6 [(3.1\240\240)(1.1 Architecture and Workflow)] D +/h7 [(3.2\240\240)(1.2 Benefits)] D +/h8 [(3.3\240\240)(1.3 Supported C++ Standards)] D +/h9 [(4\240\240)(2 Hello World Example)] D +/h10 [(4.1\240\240)(2.1 Declaring Persistent Classes)] D +/h11 [(4.2\240\240)(2.2 Generating Database Support Code)] D +/h12 [(4.3\240\240)(2.3 Compiling and Running)] D +/h13 [(4.4\240\240)(2.4 Making Objects Persistent)] D +/h14 [(4.5\240\240)(2.5 Querying the Database for Objects)] D +/h15 [(4.6\240\240)(2.6 Updating Persistent Objects)] D +/h16 [(4.7\240\240)(2.7 Defining and Using Views)] D +/h17 [(4.8\240\240)(2.8 Deleting Persistent Objects)] D +/h18 [(4.9\240\240)(2.9 Changing Persistent Classes)] D +/h19 [(4.10\240\240)(2.10 Working with Multiple Databases)] D +/h20 [(4.11\240\240)(2.11 Summary)] D +/h21 [(5\240\240)(3 Working with Persistent Objects)] D +/h22 [(5.1\240\240)(3.1 Concepts and Terminology)] D +/h23 [(5.2\240\240)(3.2 Declaring Persistent Objects and Values)] D +/h24 [(5.3\240\240)(3.3 Object and View Pointers)] D +/h25 [(5.4\240\240)(3.4 Database)] D +/h26 [(5.5\240\240)(3.5 Transactions)] D +/h27 [(5.6\240\240)(3.6 Connections)] D +/h28 [(5.7\240\240)(3.7 Error Handling and Recovery)] D +/h29 [(5.8\240\240)(3.8 Making Objects Persistent)] D +/h30 [(5.9\240\240)(3.9 Loading Persistent Objects)] D +/h31 [(5.10\240\240)(3.10 Updating Persistent Objects)] D +/h32 [(5.11\240\240)(3.11 Deleting Persistent Objects)] D +/h33 [(5.12\240\240)(3.12 Executing Native SQL Statements)] D +/h34 [(5.13\240\240)(3.13 Tracing SQL Statement Execution)] D +/h35 [(5.14\240\240)(3.14 ODB Exceptions)] D +/h36 [(6\240\240)(4 Querying the Database)] D +/h37 [(6.1\240\240)(4.1 ODB Query Language)] D +/h38 [(6.2\240\240)(4.2 Parameter Binding)] D +/h39 [(6.3\240\240)(4.3 Executing a Query)] D +/h40 [(6.4\240\240)(4.4 Query Result)] D +/h41 [(6.5\240\240)(4.5 Prepared Queries)] D +/h42 [(7\240\240)(5 Containers)] D +/h43 [(7.1\240\240)(5.1 Ordered Containers)] D +/h44 [(7.2\240\240)(5.2 Set and Multiset Containers)] D +/h45 [(7.3\240\240)(5.3 Map and Multimap Containers)] D +/h46 [(7.4\240\240)(5.4 Change-Tracking Containers)] D +/h47 [(7.4.1\240\240)(5.4.1 Change-Tracking vector)] D +/h48 [(7.5\240\240)(5.5 Using Custom Containers)] D +/h49 [(8\240\240)(6 Relationships)] D +/h50 [(8.1\240\240)(6.1 Unidirectional Relationships)] D +/h51 [(8.1.1\240\240)(6.1.1 To-One Relationships)] D +/h52 [(8.1.2\240\240)(6.1.2 To-Many Relationships)] D +/h53 [(8.2\240\240)(6.2 Bidirectional Relationships)] D +/h54 [(8.2.1\240\240)(6.2.1 One-to-One Relationships)] D +/h55 [(8.2.2\240\240)(6.2.2 One-to-Many Relationships)] D +/h56 [(8.2.3\240\240)(6.2.3 Many-to-Many Relationships)] D +/h57 [(8.3\240\240)(6.3 Circular Relationships)] D +/h58 [(8.4\240\240)(6.4 Lazy Pointers)] D +/h59 [(8.5\240\240)(6.5 Using Custom Smart Pointers)] D +/h60 [(9\240\240)(7 Value Types)] D +/h61 [(9.1\240\240)(7.1 Simple Value Types)] D +/h62 [(9.2\240\240)(7.2 Composite Value Types)] D +/h63 [(9.2.1\240\240)(7.2.1 Composite Object Ids)] D +/h64 [(9.2.2\240\240)(7.2.2 Composite Value Column and Table Names)] D +/h65 [(9.3\240\240)(7.3 Pointers and NULL Value Semantics)] D +/h66 [(10\240\240)(8 Inheritance)] D +/h67 [(10.1\240\240)(8.1 Reuse Inheritance)] D +/h68 [(10.2\240\240)(8.2 Polymorphism Inheritance)] D +/h69 [(10.2.1\240\240)(8.2.1 Performance and Limitations)] D +/h70 [(10.3\240\240)(8.3 Mixed Inheritance)] D +/h71 [(11\240\240)(9 Sections)] D +/h72 [(11.1\240\240)(9.1 Sections and Inheritance)] D +/h73 [(11.2\240\240)(9.2 Sections and Optimistic Concurrency)] D +/h74 [(11.3\240\240)(9.3 Sections and Lazy Pointers)] D +/h75 [(11.4\240\240)(9.4 Sections and Change-Tracking Containers)] D +/h76 [(12\240\240)(10 Views)] D +/h77 [(12.1\240\240)(10.1 Object Views)] D +/h78 [(12.2\240\240)(10.2 Object Loading Views)] D +/h79 [(12.3\240\240)(10.3 Table Views)] D +/h80 [(12.4\240\240)(10.4 Mixed Views)] D +/h81 [(12.5\240\240)(10.5 View Query Conditions)] D +/h82 [(12.6\240\240)(10.6 Native Views)] D +/h83 [(12.7\240\240)(10.7 Other View Features and Limitations)] D +/h84 [(13\240\240)(11 Session)] D +/h85 [(13.1\240\240)(11.1 Object Cache)] D +/h86 [(13.2\240\240)(11.2 Custom Sessions)] D +/h87 [(14\240\240)(12 Optimistic Concurrency)] D +/h88 [(15\240\240)(13 Database Schema Evolution)] D +/h89 [(15.1\240\240)(13.1 Object Model Version and Changelog)] D +/h90 [(15.2\240\240)(13.2 Schema Migration)] D +/h91 [(15.3\240\240)(13.3 Data Migration)] D +/h92 [(15.4\240\240)(13.3.1 Immediate Data Migration)] D +/h93 [(15.5\240\240)(13.3.2 Gradual Data Migration)] D +/h94 [(15.6\240\240)(13.4 Soft Object Model Changes)] D +/h95 [(15.7\240\240)(13.4.1 Reuse Inheritance Changes)] D +/h96 [(15.8\240\240)(13.4.2 Polymorphism Inheritance Changes)] D +/h97 [(16\240\240)(14 ODB Pragma Language)] D +/h98 [(16.1\240\240)(14.1 Object Type Pragmas)] D +/h99 [(16.1.1\240\240)(14.1.1 table)] D +/h100 [(16.1.2\240\240)(14.1.2 pointer)] D +/h101 [(16.1.3\240\240)(14.1.3 abstract)] D +/h102 [(16.1.4\240\240)(14.1.4 readonly)] D +/h103 [(16.1.5\240\240)(14.1.5 optimistic)] D +/h104 [(16.1.6\240\240)(14.1.6 no_id)] D +/h105 [(16.1.7\240\240)(14.1.7 callback)] D +/h106 [(16.1.8\240\240)(14.1.8 schema)] D +/h107 [(16.1.9\240\240)(14.1.9 polymorphic)] D +/h108 [(16.1.10\240\240)(14.1.10 session)] D +/h109 [(16.1.11\240\240)(14.1.11 definition)] D +/h110 [(16.1.12\240\240)(14.1.12 transient)] D +/h111 [(16.1.13\240\240)(14.1.13 sectionable)] D +/h112 [(16.1.14\240\240)(14.1.14 deleted)] D +/h113 [(16.1.15\240\240)(14.1.15 bulk)] D +/h114 [(16.2\240\240)(14.2 View Type Pragmas)] D +/h115 [(16.2.1\240\240)(14.2.1 object)] D +/h116 [(16.2.2\240\240)(14.2.2 table)] D +/h117 [(16.2.3\240\240)(14.2.3 query)] D +/h118 [(16.2.4\240\240)(14.2.4 pointer)] D +/h119 [(16.2.5\240\240)(14.2.5 callback)] D +/h120 [(16.2.6\240\240)(14.2.6 definition)] D +/h121 [(16.2.7\240\240)(14.2.7 transient)] D +/h122 [(16.3\240\240)(14.3 Value Type Pragmas)] D +/h123 [(16.3.1\240\240)(14.3.1 type)] D +/h124 [(16.3.2\240\240)(14.3.2 id_type)] D +/h125 [(16.3.3\240\240)(14.3.3 null/not_null)] D +/h126 [(16.3.4\240\240)(14.3.4 default)] D +/h127 [(16.3.5\240\240)(14.3.5 options)] D +/h128 [(16.3.6\240\240)(14.3.6 readonly)] D +/h129 [(16.3.7\240\240)(14.3.7 definition)] D +/h130 [(16.3.8\240\240)(14.3.8 transient)] D +/h131 [(16.3.9\240\240)(14.3.9 unordered)] D +/h132 [(16.3.10\240\240)(14.3.10 index_type)] D +/h133 [(16.3.11\240\240)(14.3.11 key_type)] D +/h134 [(16.3.12\240\240)(14.3.12 value_type)] D +/h135 [(16.3.13\240\240)(14.3.13 value_null/value_not_null)] D +/h136 [(16.3.14\240\240)(14.3.14 id_options)] D +/h137 [(16.3.15\240\240)(14.3.15 index_options)] D +/h138 [(16.3.16\240\240)(14.3.16 key_options)] D +/h139 [(16.3.17\240\240)(14.3.17 value_options)] D +/h140 [(16.3.18\240\240)(14.3.18 id_column)] D +/h141 [(16.3.19\240\240)(14.3.19 index_column)] D +/h142 [(16.3.20\240\240)(14.3.20 key_column)] D +/h143 [(16.3.21\240\240)(14.3.21 value_column)] D +/h144 [(16.4\240\240)(14.4 Data Member Pragmas)] D +/h145 [(16.4.1\240\240)(14.4.1 id)] D +/h146 [(16.4.2\240\240)(14.4.2 auto)] D +/h147 [(16.4.3\240\240)(14.4.3 type)] D +/h148 [(16.4.4\240\240)(14.4.4 id_type)] D +/h149 [(16.4.5\240\240)(14.4.5 get/set/access)] D +/h150 [(16.4.6\240\240)(14.4.6 null/not_null)] D +/h151 [(16.4.7\240\240)(14.4.7 default)] D +/h152 [(16.4.8\240\240)(14.4.8 options)] D +/h153 [(16.4.9\240\240)(14.4.9 column \(object, composite value\))] D +/h154 [(16.4.10\240\240)(14.4.10 column \(view\))] D +/h155 [(16.4.11\240\240)(14.4.11 transient)] D +/h156 [(16.4.12\240\240)(14.4.12 readonly)] D +/h157 [(16.4.13\240\240)(14.4.13 virtual)] D +/h158 [(16.4.14\240\240)(14.4.14 inverse)] D +/h159 [(16.4.15\240\240)(14.4.15 on_delete)] D +/h160 [(16.4.16\240\240)(14.4.16 version)] D +/h161 [(16.4.17\240\240)(14.4.17 index)] D +/h162 [(16.4.18\240\240)(14.4.18 unique)] D +/h163 [(16.4.19\240\240)(14.4.19 unordered)] D +/h164 [(16.4.20\240\240)(14.4.20 table)] D +/h165 [(16.4.21\240\240)(14.4.21 load/update)] D +/h166 [(16.4.22\240\240)(14.4.22 section)] D +/h167 [(16.4.23\240\240)(14.4.23 added)] D +/h168 [(16.4.24\240\240)(14.4.24 deleted)] D +/h169 [(16.4.25\240\240)(14.4.25 index_type)] D +/h170 [(16.4.26\240\240)(14.4.26 key_type)] D +/h171 [(16.4.27\240\240)(14.4.27 value_type)] D +/h172 [(16.4.28\240\240)(14.4.28 value_null/value_not_null)] D +/h173 [(16.4.29\240\240)(14.4.29 id_options)] D +/h174 [(16.4.30\240\240)(14.4.30 index_options)] D +/h175 [(16.4.31\240\240)(14.4.31 key_options)] D +/h176 [(16.4.32\240\240)(14.4.32 value_options)] D +/h177 [(16.4.33\240\240)(14.4.33 id_column)] D +/h178 [(16.4.34\240\240)(14.4.34 index_column)] D +/h179 [(16.4.35\240\240)(14.4.35 key_column)] D +/h180 [(16.4.36\240\240)(14.4.36 value_column)] D +/h181 [(16.5\240\240)(14.5 Namespace Pragmas)] D +/h182 [(16.5.1\240\240)(14.5.1 pointer)] D +/h183 [(16.5.2\240\240)(14.5.2 table)] D +/h184 [(16.5.3\240\240)(14.5.3 schema)] D +/h185 [(16.5.4\240\240)(14.5.4 session)] D +/h186 [(16.6\240\240)(14.6 Object Model Pragmas)] D +/h187 [(16.6.1\240\240)(14.6.1 version)] D +/h188 [(16.7\240\240)(14.7 Index Definition Pragmas)] D +/h189 [(16.8\240\240)(14.8 Database Type Mapping Pragmas)] D +/h190 [(16.9\240\240)(14.9 C++ Compiler Warnings)] D +/h191 [(16.9.1\240\240)(14.9.1 GNU C++)] D +/h192 [(16.9.2\240\240)(14.9.2 Visual C++)] D +/h193 [(16.9.3\240\240)(14.9.3 Sun C++)] D +/h194 [(16.9.4\240\240)(14.9.4 IBM XL C++)] D +/h195 [(16.9.5\240\240)(14.9.5 HP aC++)] D +/h196 [(16.9.6\240\240)(14.9.6 Clang)] D +/h197 [(17\240\240)(15 Advanced Techniques and Mechanisms)] D +/h198 [(17.1\240\240)(15.1 Transaction Callbacks)] D +/h199 [(17.2\240\240)(15.2 Persistent Class Template Instantiations)] D +/h200 [(17.3\240\240)(15.3 Bulk Database Operations)] D +/h201 [(18\240\240)(PART II\240\240 DATABASE SYSTEMS)] D +/h202 [(19\240\240)(16 Multi-Database Support)] D +/h203 [(19.1\240\240)(16.1 Static Multi-Database Support)] D +/h204 [(19.2\240\240)(16.2 Dynamic Multi-Database Support)] D +/h205 [(19.2.1\240\240)(16.2.2 Dynamic Loading of Database Support Code)] D +/h206 [(20\240\240)(17 MySQL Database)] D +/h207 [(20.1\240\240)(17.1 MySQL Type Mapping)] D +/h208 [(20.1.1\240\240)(17.1.1 String Type Mapping)] D +/h209 [(20.1.2\240\240)(17.1.2 Binary Type Mapping)] D +/h210 [(20.2\240\240)(17.2 MySQL Database Class)] D +/h211 [(20.3\240\240)(17.3 MySQL Connection and Connection Factory)] D +/h212 [(20.4\240\240)(17.4 MySQL Exceptions)] D +/h213 [(20.5\240\240)(17.5 MySQL Limitations)] D +/h214 [(20.5.1\240\240)(17.5.1 Foreign Key Constraints)] D +/h215 [(20.6\240\240)(17.6 MySQL Index Definitions)] D +/h216 [(20.7\240\240)(17.7 MySQL Stored Procedures)] D +/h217 [(21\240\240)(18 SQLite Database)] D +/h218 [(21.1\240\240)(18.1 SQLite Type Mapping)] D +/h219 [(21.1.1\240\240)(18.1.1 String Type Mapping)] D +/h220 [(21.1.2\240\240)(18.1.2 Binary Type Mapping)] D +/h221 [(21.2\240\240)(18.2 SQLite Database Class)] D +/h222 [(21.3\240\240)(18.3 SQLite Connection and Connection Factory)] D +/h223 [(21.4\240\240)(18.4 SQLite Exceptions)] D +/h224 [(21.5\240\240)(18.5 SQLite Limitations)] D +/h225 [(21.5.1\240\240)(18.5.1 Query Result Caching)] D +/h226 [(21.5.2\240\240)(18.5.2 Automatic Assignment of Object Ids)] D +/h227 [(21.5.3\240\240)(18.5.3 Foreign Key Constraints)] D +/h228 [(21.5.4\240\240)(18.5.4 Constraint Violations)] D +/h229 [(21.5.5\240\240)(18.5.5 Sharing of Queries)] D +/h230 [(21.5.6\240\240)(18.5.6 Forced Rollback)] D +/h231 [(21.5.7\240\240)(18.5.7 Database Schema Evolution)] D +/h232 [(21.6\240\240)(18.6 SQLite Index Definitions)] D +/h233 [(22\240\240)(19 PostgreSQL Database)] D +/h234 [(22.1\240\240)(19.1 PostgreSQL Type Mapping)] D +/h235 [(22.1.1\240\240)(19.1.1 String Type Mapping)] D +/h236 [(22.1.2\240\240)(19.1.2 Binary Type and UUID Mapping)] D +/h237 [(22.2\240\240)(19.2 PostgreSQL Database Class)] D +/h238 [(22.3\240\240)(19.3 PostgreSQL Connection and Connection Factory)] D +/h239 [(22.4\240\240)(19.4 PostgreSQL Exceptions)] D +/h240 [(22.5\240\240)(19.5 PostgreSQL Limitations)] D +/h241 [(22.5.1\240\240)(19.5.1 Query Result Caching)] D +/h242 [(22.5.2\240\240)(19.5.2 Foreign Key Constraints)] D +/h243 [(22.5.3\240\240)(19.5.3 Unique Constraint Violations)] D +/h244 [(22.5.4\240\240)(19.5.4 Date-Time Format)] D +/h245 [(22.5.5\240\240)(19.5.5 Timezones)] D +/h246 [(22.5.6\240\240)(19.5.6 NUMERIC Type Support)] D +/h247 [(22.6\240\240)(19.6 PostgreSQL Index Definitions)] D +/h248 [(23\240\240)(20 Oracle Database)] D +/h249 [(23.1\240\240)(20.1 Oracle Type Mapping)] D +/h250 [(23.1.1\240\240)(20.1.1 String Type Mapping)] D +/h251 [(23.1.2\240\240)(20.1.2 Binary Type Mapping)] D +/h252 [(23.2\240\240)(20.2 Oracle Database Class)] D +/h253 [(23.3\240\240)(20.3 Oracle Connection and Connection Factory)] D +/h254 [(23.4\240\240)(20.4 Oracle Exceptions)] D +/h255 [(23.5\240\240)(20.5 Oracle Limitations)] D +/h256 [(23.5.1\240\240)(20.5.1 Identifier Truncation)] D +/h257 [(23.5.2\240\240)(20.5.2 Query Result Caching)] D +/h258 [(23.5.3\240\240)(20.5.3 Foreign Key Constraints)] D +/h259 [(23.5.4\240\240)(20.5.4 Unique Constraint Violations)] D +/h260 [(23.5.5\240\240)(20.5.5 Large FLOAT and NUMBER Types)] D +/h261 [(23.5.6\240\240)(20.5.6 Timezones)] D +/h262 [(23.5.7\240\240)(20.5.7 LONG Types)] D +/h263 [(23.5.8\240\240)(20.5.8 LOB Types and By-Value Accessors/Modifiers)] D +/h264 [(23.5.9\240\240)(20.5.9 Database Schema Evolution)] D +/h265 [(23.6\240\240)(20.6 Oracle Index Definitions)] D +/h266 [(24\240\240)(21 Microsoft SQL Server Database)] D +/h267 [(24.1\240\240)(21.1 SQL Server Type Mapping)] D +/h268 [(24.1.1\240\240)(21.1.1 String Type Mapping)] D +/h269 [(24.1.2\240\240)(21.1.2 Binary Type and UNIQUEIDENTIFIER Mapping)] D +/h270 [(24.1.3\240\240)(21.1.3 ROWVERSION Mapping)] D +/h271 [(24.1.4\240\240)(21.1.4 Long String and Binary Types)] D +/h272 [(24.2\240\240)(21.2 SQL Server Database Class)] D +/h273 [(24.3\240\240)(21.3 SQL Server Connection and Connection Factory)] D +/h274 [(24.4\240\240)(21.4 SQL Server Exceptions)] D +/h275 [(24.5\240\240)(21.5 SQL Server Limitations)] D +/h276 [(24.5.1\240\240)(21.5.1 Query Result Caching)] D +/h277 [(24.5.2\240\240)(21.5.2 Foreign Key Constraints)] D +/h278 [(24.5.3\240\240)(21.5.3 Unique Constraint Violations)] D +/h279 [(24.5.4\240\240)(21.5.4 Multi-threaded Windows Applications)] D +/h280 [(24.5.5\240\240)(21.5.5 Affected Row Count and DDL Statements)] D +/h281 [(24.5.6\240\240)(21.5.6 Long Data and Auto Object Ids, ROWVERSION)] D +/h282 [(24.5.7\240\240)(21.5.7 Long Data and By-Value Accessors/Modifiers)] D +/h283 [(24.5.8\240\240)(21.5.8 Bulk Update and ROWVERSION)] D +/h284 [(24.6\240\240)(21.6 SQL Server Index Definitions)] D +/h285 [(24.7\240\240)(21.7 SQL Server Stored Procedures)] D +/h286 [(25\240\240)(PART III\240\240 PROFILES)] D +/h287 [(26\240\240)(22 Profiles Introduction)] D +/h288 [(27\240\240)(23 Boost Profile)] D +/h289 [(27.1\240\240)(23.1 Smart Pointers Library)] D +/h290 [(27.2\240\240)(23.2 Unordered Containers Library)] D +/h291 [(27.3\240\240)(23.3 Multi-Index Container Library)] D +/h292 [(27.4\240\240)(23.4 Optional Library)] D +/h293 [(27.5\240\240)(23.5 Date Time Library)] D +/h294 [(27.5.1\240\240)(23.5.1 MySQL Database Type Mapping)] D +/h295 [(27.5.2\240\240)(23.5.2 SQLite Database Type Mapping)] D +/h296 [(27.5.3\240\240)(23.5.3 PostgreSQL Database Type Mapping)] D +/h297 [(27.5.4\240\240)(23.5.4 Oracle Database Type Mapping)] D +/h298 [(27.5.5\240\240)(23.5.5 SQL Server Database Type Mapping)] D +/h299 [(27.6\240\240)(23.6 Uuid Library)] D +/h300 [(27.6.1\240\240)(23.6.1 MySQL Database Type Mapping)] D +/h301 [(27.6.2\240\240)(23.6.2 SQLite Database Type Mapping)] D +/h302 [(27.6.3\240\240)(23.6.3 PostgreSQL Database Type Mapping)] D +/h303 [(27.6.4\240\240)(23.6.4 Oracle Database Type Mapping)] D +/h304 [(27.6.5\240\240)(23.6.5 SQL Server Database Type Mapping)] D +/h305 [(28\240\240)(24 Qt Profile)] D +/h306 [(28.1\240\240)(24.1 Basic Types Library)] D +/h307 [(28.1.1\240\240)(24.1.1 MySQL Database Type Mapping)] D +/h308 [(28.1.2\240\240)(24.1.2 SQLite Database Type Mapping)] D +/h309 [(28.1.3\240\240)(24.1.3 PostgreSQL Database Type Mapping)] D +/h310 [(28.1.4\240\240)(24.1.4 Oracle Database Type Mapping)] D +/h311 [(28.1.5\240\240)(24.1.5 SQL Server Database Type Mapping)] D +/h312 [(28.2\240\240)(24.2 Smart Pointers Library)] D +/h313 [(28.3\240\240)(24.3 Containers Library)] D +/h314 [(28.3.1\240\240)(24.3.1 Change-Tracking QList)] D +/h315 [(28.4\240\240)(24.4 Date Time Library)] D +/h316 [(28.4.1\240\240)(24.4.1 MySQL Database Type Mapping)] D +/h317 [(28.4.2\240\240)(24.4.2 SQLite Database Type Mapping)] D +/h318 [(28.4.3\240\240)(24.4.3 PostgreSQL Database Type Mapping)] D +/h319 [(28.4.4\240\240)(24.4.4 Oracle Database Type Mapping)] D +/h320 [(28.4.5\240\240)(24.4.5 SQL Server Database Type Mapping)] D +/Hr [325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 +342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 +360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 +378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 +396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 +414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 +432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 +450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 +468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 +486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 +504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 +522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 +540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 +558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 +576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 +594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 +612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 +630 631 632 633 634 635 636 637 638 639 640 641 642 643 644]D +/HV [1 2 2 1 1 2 2 2 1 2 2 2 2 2 2 2 2 2 2 2 1 2 2 2 2 2 2 2 2 2 2 2 2 +2 2 1 2 2 2 2 2 1 2 2 2 2 3 2 1 2 3 3 2 3 3 3 2 2 2 1 2 2 3 3 2 1 2 2 3 +2 1 2 2 2 2 1 2 2 2 2 2 2 2 1 2 2 1 1 2 2 2 2 2 2 2 2 1 2 3 3 3 3 3 3 3 +3 3 3 3 3 3 3 3 2 3 3 3 3 3 3 3 2 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 +3 3 2 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 +3 3 3 2 3 3 3 3 2 3 2 2 2 3 3 3 3 3 3 1 2 2 2 1 1 2 2 3 1 2 3 3 2 2 2 2 +3 2 2 1 2 3 3 2 2 2 2 3 3 3 3 3 3 3 2 1 2 3 3 2 2 2 2 3 3 3 3 3 3 2 1 2 +3 3 2 2 2 2 3 3 3 3 3 3 3 3 3 2 1 2 3 3 3 3 2 2 2 2 3 3 3 3 3 3 3 3 2 2 +1 1 1 2 2 2 2 2 3 3 3 3 3 2 3 3 3 3 3 1 2 3 3 3 3 3 2 2 3 2 3 3 3 3 3]D +/Cn [2 0 0 0 3 0 0 0 11 0 0 0 0 0 0 0 0 0 0 0 14 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 5 0 0 0 0 0 5 0 0 0 1 0 0 5 2 0 0 3 0 0 0 0 0 0 3 0 2 0 0 0 3 0 1 +0 0 4 0 0 0 0 7 0 0 0 0 0 0 0 2 0 0 0 8 0 0 0 0 0 0 0 0 9 15 0 0 0 0 0 0 +0 0 0 0 0 0 0 0 0 7 0 0 0 0 0 0 0 21 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 36 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 +0 0 0 0 4 0 0 0 0 1 0 0 0 6 0 0 0 0 0 0 3 0 0 0 0 2 0 1 0 7 2 0 0 0 0 0 +1 0 0 0 6 2 0 0 0 0 0 7 0 0 0 0 0 0 0 0 6 2 0 0 0 0 0 6 0 0 0 0 0 0 0 6 +2 0 0 0 0 0 9 0 0 0 0 0 0 0 0 0 0 7 4 0 0 0 0 0 0 0 8 0 0 0 0 0 0 0 0 0 +0 0 0 6 0 0 0 0 5 0 0 0 0 0 5 0 0 0 0 0 4 5 0 0 0 0 0 0 1 0 5 0 0 0 0 0]D +Hr length 0 gt{[/PageMode /UseOutlines /DOCVIEW pdfmark}if +/Hn 1 D +0 1 Hr length 1 sub{ + /Bn E D [Cn Bn get dup 0 gt{/Count E HV Bn get Bl ge{neg}if}{pop}ie + /Dest Hr Bn get dup abs ST cvs cvn E 0 ge{(h)Hn ST cvs join cvx exec + dup 1 get E Nf{0 get E join}{pop}ie /Hn Hn 1 add D}{()}ie + /Title E dup length 255 gt{0 255 getinterval}if /OUT pdfmark}for +ZF /FN Fp D Ps 0 FS /WC Wf{( )}{}ie SW pop D +ET RC ZF +/Df f D +/R0 (http://www.codesynthesis.com/licenses/fdl-1.3.txt) D +/R1 (http://www.codesynthesis.com/products/odb/doc/manual.xhtml) D +/R2 (http://www.codesynthesis.com/products/odb/doc/odb-manual.pdf) D +/R3 (http://www.codesynthesis.com/products/odb/doc/odb-manual.ps) D +/R1 (http://www.codesynthesis.com/products/odb/doc/odb.xhtml) D +/R2 (http://www.codesynthesis.com/mailman/listinfo/odb-users) D +/R3 (http://www.codesynthesis.com/pipermail/odb-users/) D +/TS { + tables E get /table E D + table aload pop /rdesc E D /cdesc E D /tdesc E D + tdesc aload pop /capalg E D /caption E D /rules E D /frame E D /nfoot E D + /nhead E D /ncol E D /nrow E D /border E D /twid E D /units E D /talign E D + /flow E D /clear E D /tclass E D pop pop + /w W D /eps 0.1 D /OU f D /PL 1 D + /FN EF 21 get D EZ 21 get Ey 21 get FS + 0 1 1{ + /pass E D + 0 1 nrow{ + /irow E D + /cells rdesc irow get 6 get D + 0 1 ncol{ + /icol E D + /cell cells icol get D + cell 0 ne{ + cell aload pop /ang E D /CB E D pop pop pop + /DV E D /bot E D /top E D /right E D /left E D /nowrap E D /valign E D + /dp E D /align E D /rspan E D /cspan E D /cclass E D /ctype E D /cmax E D + /cmin E D /proc E D + rspan 0 eq{/rspan nrow irow sub 1 add D}if + cspan 0 eq{/cspan ncol icol sub 1 add D}if + pass 0 eq cspan 1 eq and pass 1 eq cspan 1 gt and or{ + /W 1e5 D /LL W D /PH 1 D + ctype 1 eq{() BD}if + RC align NA + AT 4 eq{/CD t D /DC dp D /LN 0 D /M1 0 D /M2 0 D}{/CD f D}ie + 0 0 M /LM 0 D proc exec BN + AT 4 eq{ + LN array astore cell 15 3 -1 roll put + cdesc icol get dup dup 5 get M1 lt{5 M1 put}{5 get /M1 E D}ie + dup 6 get M2 lt{6 M2 put}{6 get /M2 E D}ie + /LM M1 M2 add D + }if + /CD f D + ang 0 ne{/LM CP E pop neg D}if + /thiswid LM left add right add eps add D + /oldmin 0 D /oldmax 0 D + 0 1 cspan 1 sub{ + icol add cdesc E get dup 2 get /oldmax E oldmax add D + 1 get /oldmin E oldmin add D + }for + thiswid oldmax ge{ + 0 1 cspan 1 sub{ + icol add cdesc E get dup 2 E 2 get oldmax 0 eq + {pop thiswid cspan div}{thiswid mul oldmax div}ie + put + }for + }if + nowrap 1 eq{ + thiswid oldmin ge{ + 0 1 cspan 1 sub{ + icol add cdesc E get dup 1 E 1 get oldmin 0 eq + {pop thiswid cspan div}{thiswid mul oldmin div}ie + put + }for + }if + }{ + /W 0 D /LL W D /PH 2 D + ctype 1 eq{() ES () BD}if + 0 0 M /LM 0 D RC proc exec BN + /thiswid LM left add right add eps add D + thiswid oldmin ge{ + 0 1 cspan 1 sub{ + icol add cdesc E get dup 1 E 1 get oldmin 0 eq + {pop thiswid cspan div}{thiswid mul oldmin div}ie + put + }for + }if + }ie + ctype 1 eq{() ES}if + }if + }if + }for + }for + }for + /tmin 0 D /tmax 0 D + 0 1 ncol{ + cdesc E get dup 1 get E 2 get 2 copy gt{pop dup}if + tmax add /tmax E D tmin add /tmin E D + }for + twid 0 lt{twid neg IW gt{IW neg}{twid}ie /twid E D}if + tdesc 0 twid neg tmin 2 copy lt{E}if pop put + tdesc 1 twid neg tmax 2 copy lt{E}if pop put + /W w D /LL W D /OU t D /PH 0 D /PL 0 D +} D +/PT { + /PL PL 1 add D + tables E get /table E D Tm 21 get Ts mul BE + PL 2 ge{save}if + /SL SL 1 add D /FN EF 21 get D EZ 21 get Ey 21 get FS + table aload pop /rdesc E D /cdesc E D /tdesc E D + tdesc aload pop /capalg E D /caption E D /rules E D /frame E D /nfoot E D + /nhead E D /ncol E D /nrow E D /border E D /twid E D /units E D /talign E D + /flow E D /clear E D /tclass E D /tmax E D /tmin E D + /w W D /xo XO D /mr MR D /ll LL D /lg LG D /ai AI D /bc BC D /nr NR D /ar AR D + /tr TR D /ui UI D /ph PH D /a0 A0 D /pf PF D /at AT D /av AV D /al AL D + /Le LE D /la La D + talign 0 lt{/talign AL 0 gt{AV AL get}{A0 2 le{A0}{0}ie}ie D}if + ph 1 eq ph 2 eq or{ + NL ph 1 eq{tmax}{tmin}ie dup XO add LM gt{/LM E XO add D}{pop}ie LM E + }{ + /PH 3 D /LE 1e5 D RC %ZF + border 0 gt{/border 1 D}if + /twidth 0 D /avail W xo sub D + twid 0 eq{0 1 ncol{cdesc E get dup 2 get E 3 get dup 0 gt{div neg dup twid lt + {/twid E D}{pop}ie}{pop pop}ie}for}if + /twid twid dup 0 lt{neg avail 2 copy gt{E}if pop}{avail mul}ie D + /OK t D 0 1 ncol{cdesc E get dup 1 get E 3 get twid mul gt{/OK f D}if}for + 0 1 ncol{ + cdesc E get dup 1 get /colmin E D dup 3 get /cwid E twid mul D dup + tmax avail le{2 get}if + tmin avail le tmax avail gt and{ + dup 2 get E 1 get dup 3 1 roll sub avail tmin sub mul tmax tmin sub div add + }if + tmin avail gt{1 get}if + 0 E colmin cwid lt OK and{pop cwid}if dup /twidth E twidth add D put + }for + /OU f D CP + tmin twid le{ + 0 1 ncol{cdesc E get dup 0 get twidth div twid mul 0 E put}for + /twidth twid D + }if + CP printcap CP E pop sub /caphig E D pop + 0 1 1{ + /pass E D + 0 1 nrow{ + /irow E D + /cells rdesc irow get 6 get D + 0 1 ncol{ + /icol E D + /cell cells icol get D + cell 0 ne{ + cell aload pop /ang E D /CB E D pop pop pop + /DV E D /bot E D /top E D /right E D /left E D /nowrap E D /valign E D + /dp E D /align E D /rspan E D /cspan E D /cclass E D /ctype E D /cmax E D + /cmin E D /proc E D + rspan 0 eq{/rspan nrow irow sub 1 add D}if + cspan 0 eq{/cspan ncol icol sub 1 add D}if + /W 0 D + 0 1 cspan 1 sub{icol add cdesc E get 0 get /W E W add D}for + pass 0 eq rspan 1 eq and pass 1 eq rspan 1 gt and or{ + ctype 1 eq{() BD}if + /W W left sub right sub D /XO 0 D /EO 0 D SI + /A0 align D RC align NA + AT 4 eq{ + /DC dp D /DO 0 D /ID 1 D + 0 1 DV length 1 sub{DV E get dup DO gt{/DO E D}{pop}ie}for + /Lo DO DV 0 get sub D /L1 Lo D + }if + 0 0 M /BP t D /Fl t D /MF 0 D /FB 0 D + proc exec T not{/CI 0 D}if BN 0 FB neg R MF 0 eq{/MF CS D}if + CP /thishig E neg bot add top add CI add D pop + ang 0 ne{/thishig LM bot add top add D}if + cell 16 MF put cell 17 Ya put cell 18 thishig put + valign 4 eq{ + /below thishig Ya sub D + rdesc irow get dup dup 4 get Ya lt + {4 Ya put}{4 get /Ya E D}ie + dup 5 get below lt{5 below put}{5 get /below E D}ie + /thishig Ya below add D + }if + ctype 1 eq{()ES}if + /oldhig 0 D + 0 1 rspan 1 sub{ + irow add rdesc E get 0 get /oldhig E oldhig add D + }for + thishig oldhig ge{ + 0 1 rspan 1 sub{ + irow add rdesc E get dup 0 E 0 get oldhig 0 eq + {pop thishig rspan div}{thishig mul oldhig div}ie + put + }for + }if + }if + }if + }for + }for + }for M RC %ZF + /thight 0 D /racc 0 D /maxh 0 D /brk 0 D /rbeg nhead nfoot add D + 0 1 nrow{ + rdesc E get dup 0 get dup /thight E thight add D + brk 0 eq{/racc E D}{/racc E racc add D}ie + racc maxh gt{/maxh racc D}if 2 get /brk E D + }for + ph 3 ge{thight caphig add E}if + ph 0 eq ph 4 eq or{ + /PH 4 D /LE Le D /OU Ou D /yoff 0 D /headsz 0 D + 0 1 nhead 1 sub{rdesc E get 0 get headsz add /headsz E D}for + /footsz 0 D + 0 1 nfoot 1 sub{rdesc E nhead add get 0 get footsz add /footsz E D}for + /ahig LE BO add MI add D /maxh maxh headsz add footsz add D + /thight thight headsz add footsz add D + tmin avail gt maxh ahig gt or + {/Sf avail tmin div dup ahig maxh div gt{pop ahig maxh div}if D /SA t D} + {/Sf 1 D}ie + tclass 1 eq thight LE 15 sub gt and + {/SA t D LE 15 sub thight div dup Sf lt{/Sf E D}{pop}ie}if + SA{Sf Sf scale /ll ll Sf div D /xo xo Sf div D /LE LE Sf div D + /mr mr Sf div D /BO BO Sf div D /ahig ahig Sf div D}if + nhead nfoot add getwid + LE CP E pop add capalg 0 eq{caphig sub}if + bT{f}{dup thight lt thight ahig lt and}ie + E headsz sub footsz sub rwid lt or{NP}if + capalg 0 eq{printcap -8 SP}if + CP /ycur E D pop + printhead + rbeg 1 nrow{/row E D row + getwid + ycur yoff add rwid sub footsz sub LE add 0 lt + {nfoot 0 gt{printfoot}if Tf NP /rbeg irow1 D + Ba{MI /MI MI SA{Sf div}if D MI SP /MI E D}if + CP /ycur E D pop /yoff 0 D printhead}if + irow1 printrow + }for + printfoot /row row 1 add D Tf + 0 ycur yoff add M + capalg 1 eq{/EO 0 D SI -3 SP printcap}if + Sf 1 lt{1 Sf div dup scale /ll ll Sf mul D /xo xo Sf mul D /LE LE Sf mul D + /mr mr Sf mul D /BO BO Sf mul D /SA f D}if + /EO 0 D + }if + }ie + /W w D /XO xo D /MR mr D /LL ll D /LG lg D /AI ai D /BC bc D /NR nr D /AR ar D + /TR tr D /UI ui D /PH ph D /A0 a0 D /PF pf D /AT at D /AV av D /AL al D + /La la D + /SL SL 1 sub NN D /CF 0 D /FN 0 D SZ SL get FR SL get FS Wf not{()F2}if + PL 2 ge{Ms E restore Ms or /Ms E D PH 1 eq PH 2 eq or + {/LM E D}if PH 3 ge{/CI 0 D NL 0 E neg R}if + }if + /PL PL 1 sub D /CI 0 D /BP f D /PO f D () Bm 21 get Ts mul BE BL %CF CS SF +} D +/printcap{ + capalg 0 ge{ + SA{/W w Sf div D} + {talign 1 eq{/XO xo ll twidth sub 2 div add D}if + talign 2 eq{/XO xo ll twidth sub add D}if + /W XO twidth add D + }ie /XO xo D /LL W XO sub MR sub D + /PA f D /Fl capalg 0 eq D + 1 NA BL caption exec BN OA /PA t D + }if +} D +/getwid{ + /irow1 E D + /irow2 irow1 D + /rwid 0 D + {rdesc irow2 get dup 0 get rwid add /rwid E D 2 get 0 eq + {exit}{/irow2 irow2 1 add D}ie + }loop +} D +/printrow{ + /xoff ll twidth PL 2 ge{Sf div}if sub talign mul 2 div D + /xleft xoff xo add D + /irow E D + /cells rdesc irow get 6 get D + 0 1 ncol{ + /icol E D + /cell cells icol get D + cell 0 ne{ + cell aload pop /ang E D /CB E D /cvsize E D /above E D /fontsz E D + /DV E D /bot E D /top E D /right E D /left E D /nowrap E D /valign E D + /dp E D /align E D /rspan E D /cspan E D /cclass E D /ctype E D /cmax E D + /cmin E D /proc E D + rspan 0 eq{/rspan nrow irow sub 1 add D}if + cspan 0 eq{/cspan ncol icol sub 1 add D}if + /width 0 D + 0 1 cspan 1 sub{icol add cdesc E get 0 get /width E width add D}for + /rhight rdesc irow get 0 get D + /hight rhight D + 1 1 rspan 1 sub{irow add rdesc E get 0 get /hight E hight add D}for + /W xo xoff add width add right sub D + ang 0 ne{/W xo xoff add hight add right sub D}if + /EO xo xoff add left add D SI + Cf{ + gsave CB VC xo xoff add ycur yoff add M + 0 hight neg RL width 0 RL 0 hight RL width neg 0 RL fill + grestore + }if + ctype 1 eq{() BD}if + /A0 align D RC + AT 4 eq{ + /DC dp D /ID 1 D /DO cdesc icol get 5 get D /Lo DO DV 0 get sub D /L1 Lo D + }if + ang 0 ne{ + gsave ang 90 eq + {xoff ycur add hight cvsize sub 2 div sub ycur hight sub xoff sub} + {xoff ycur sub width add hight cvsize sub 2 div add ycur xoff add}ie + translate ang rotate + }if + valign 3 le{0 ycur yoff add top sub + hight cvsize sub valign 1 sub mul 2 div sub M} + {0 ycur yoff add top sub above add rdesc irow get 4 get sub M}ie + /PA f D /BP t D /Fl t D + BL proc exec BN + ang 0 ne{grestore}if + /PA t D + ctype 1 eq{() ES}if + }if + /xoff xoff cdesc icol get 0 get add D + }for + /yoff yoff rhight sub D +} D +/printhead {0 1 nhead 1 sub{printrow}for} D +/printfoot {nhead 1 nhead nfoot add 1 sub{printrow}for} D +/Tf { + OU{rules 2 ge{/yoff 0 D + gsave 0 Sg + [0 1 nhead 1 sub{}for rbeg 1 row 1 sub{}for nhead 1 nhead nfoot add 1 sub{}for]{ + /irow E D + /xoff ll twidth PL 2 ge{Sf div}if sub talign mul 2 div D + /cells rdesc irow get 6 get D + 0 1 ncol{ + /icol E D + /cell cells icol get D + cell 0 ne{ + /rspan cell 6 get D + /cspan cell 5 get D + rspan 0 eq{/rspan nrow irow sub 1 add D}if + cspan 0 eq{/cspan ncol icol sub 1 add D}if + /width 0 D + 0 1 cspan 1 sub{icol add cdesc E get 0 get /width E width add D}for + /rhight rdesc irow get 0 get D + /hight rhight D + 1 1 rspan 1 sub{irow add rdesc E get 0 get /hight E hight add D}for + xo xoff add width add ycur yoff add M + 0 hight neg icol cspan add 1 sub ncol lt + {cdesc icol 1 add get 4 get dup rules 3 le{1 eq}{pop t}ie + {1 eq{0.8}{0.3}ie + LW RL CP stroke M}{pop R}ie}{R}ie + irow nhead nfoot add 1 sub ne nfoot 0 eq or + {irow rspan add 1 sub nrow lt + {rdesc irow rspan add get 3 get}{nfoot 0 eq{0}{1}ie}ie + dup rules 2 mod 0 eq{1 eq}{pop t}ie + {1 eq irow rspan add nhead eq or irow rspan add row eq nfoot 0 gt and or + {0.8}{0.3}ie LW width neg 0 RL CP stroke M}{pop}ie}if + }if + /xoff xoff cdesc icol get 0 get add D + }for + /yoff yoff rhight sub D + }forall + grestore + /Ms t D + }if + frame 1 gt{ + gsave + 1 LW 0 Sg + xleft ycur M CP BB + 0 yoff frame 5 eq frame 7 ge or{RL}{R}ie + twidth 0 frame 3 eq frame 4 eq or frame 8 ge or{RL}{R}ie CP BB + 0 yoff neg frame 6 ge{RL}{R}ie + twidth neg 0 frame 2 eq frame 4 eq or frame 8 ge or{RL}{R}ie + closepath stroke + grestore + /Ms t D + }if + }if +} D +/tables [[[0 0 0 0 0 -1 0 0 0 12 1 0 0 1 1 {()} -1] + [[0 0 0 0 0 0 0][0 0 0 0 0 0 0]] + [[0 0 0 0 0 0 [[{()1 Sl()WB(1)} 0 0 1 0 1 1 1 (.) 2 0 8 8 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 7 1 A(Intro)HY(duc)HY(tion)YH()7 0 TN TL()Ec /AF f D()} 0 0 0 0 1 1 0 (.) 2 0 8 8 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB(2)} 0 0 1 0 1 1 1 (.) 2 0 8 8 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 11 1 A(Hello World Example)11 0 TN TL()Ec /AF f D()} 0 0 0 0 1 1 0 (.) 2 0 8 8 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB(3)} 0 0 1 0 1 1 1 (.) 2 0 8 8 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 23 1 A(Working with Persis)HY(tent)YH( Objects)23 0 TN TL()Ec /AF f D()} 0 0 0 0 1 1 0 (.) 2 0 8 8 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB(4)} 0 0 1 0 1 1 1 (.) 2 0 8 8 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 38 1 A(Query)HY(ing)YH( the Database)38 0 TN TL()Ec /AF f D()} 0 0 0 0 1 1 0 (.) 2 0 8 8 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB(5)} 0 0 1 0 1 1 1 (.) 2 0 8 8 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 45 1 A(Contain)HY(ers)YH()45 0 TN TL()Ec /AF f D()} 0 0 0 0 1 1 0 (.) 2 0 8 8 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB(6)} 0 0 1 0 1 1 1 (.) 2 0 8 8 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 52 1 A(Rela)HY(tion)HY(ships)YH()52 0 TN TL()Ec /AF f D()} 0 0 0 0 1 1 0 (.) 2 0 8 8 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB(7)} 0 0 1 0 1 1 1 (.) 2 0 8 8 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 63 1 A(Value Types)63 0 TN TL()Ec /AF f D()} 0 0 0 0 1 1 0 (.) 2 0 8 8 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB(8)} 0 0 1 0 1 1 1 (.) 2 0 8 8 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 69 1 A(Inher)HY(i)HY(tance)YH()69 0 TN TL()Ec /AF f D()} 0 0 0 0 1 1 0 (.) 2 0 8 8 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB(10)} 0 0 1 0 1 1 1 (.) 2 0 8 8 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 79 1 A(Views)79 0 TN TL()Ec /AF f D()} 0 0 0 0 1 1 0 (.) 2 0 8 8 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB(11)} 0 0 1 0 1 1 1 (.) 2 0 8 8 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 87 1 A(Session)87 0 TN TL()Ec /AF f D()} 0 0 0 0 1 1 0 (.) 2 0 8 8 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB(12)} 0 0 1 0 1 1 1 (.) 2 0 8 8 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 90 1 A(Opti)HY(mistic)YH( Concur)HY(rency)YH()90 0 TN TL()Ec /AF f D()} 0 0 0 0 1 1 0 (.) 2 0 8 8 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB(13)} 0 0 1 0 1 1 1 (.) 2 0 8 8 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 91 1 A(Database Schema Evolu)HY(tion)YH()91 0 TN TL()Ec /AF f D()} 0 0 0 0 1 1 0 (.) 2 0 8 8 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB(14)} 0 0 1 0 1 1 1 (.) 2 0 8 8 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 100 1 A(ODB Pragma Language)100 0 TN TL()Ec /AF f D()} 0 0 0 0 1 1 0 (.) 2 0 8 8 2 6 0 0 0 0 Db 0 ] +]] +]] +[[0 0 0 0 0 -1 0 0 1 11 2 0 0 9 5 {()} -1] + [[0 0 0 0 0 0 0][0 0 0 0 0 0 0][0 0 0 0 0 0 0]] + [[0 0 0 0 0 0 [[{()1 Sl()WB(Oper)HY(a)HY(tor)YH()} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(Descrip)HY(tion)YH()} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(Example + )} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(==)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(equal)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(query::age == 31)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(!=)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(unequal)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(query::age != 31)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(<)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(less than)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(query::age < 31)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(>)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(greater than)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(query::age > 31)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(<=)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(less than or equal)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(query::age <= 31)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(>=)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(greater than or equal)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(query::age >= 31)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(in\201\202)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(one of the values)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(query::age.in \20130, 32, 34\202)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(in_range\201\202)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(one of the values in range)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(query::age.in_range \201begin, end\202)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(like\201\202)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(matches a pattern)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(query::first.like \201"J%"\202)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(is_null\201\202)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(value is )SM(NULL)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(query::age.is_null \201\202)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(is_not_null\201\202)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(value is )SM(NOT NULL)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(query::age.is_not_null \201\202)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +]] +[[0 0 0 0 0 -1 0 0 1 3 2 0 0 9 5 {()} -1] + [[0 0 0 0 0 0 0][0 0 0 0 0 0 0][0 0 0 0 0 0 0]] + [[0 0 0 0 0 0 [[{()1 Sl()WB(DELETE)} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(HARD)} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(SOFT + )} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB(In both \201delete inher)HY(i)HY(tance)YH( and base\202)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(Delete inher)HY(i)HY(tance)YH( and base. Move object id to derived.)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(Soft-delete base. Mark all data members \201except id\202 in + base as soft-deleted. + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB(In base only \201delete base\202)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(Option 1: mark base as abstract.)BR()BR( Option 2: move all the base member to derived, delete base.)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(Soft-delete base. + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB(In derived only \201delete inher)HY(i)HY(tance)YH(\202)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(Delete inher)HY(i)HY(tance)YH(, add object id to derived.)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(Option 1: copy base to a new soft-deleted base, inherit + from it instead. Mark all the data members \201expect id\202 in + this new base as soft-deleted. Note: we add the new base + as soft-deleted to get noti)HY(fied)YH( when we can remove it.)BR()BR( Option 2: Copy all the data members from base to derived + and mark them as soft-deleted in derived. + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +]] +[[0 0 0 0 0 -1 0 0 1 3 2 0 0 9 5 {()} -1] + [[0 0 0 0 0 0 0][0 0 0 0 0 0 0][0 0 0 0 0 0 0]] + [[0 0 0 0 0 0 [[{()1 Sl()WB(ADD)} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(HARD)} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(SOFT + )} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB(In both \201add new base and inher)HY(i)HY(tance)YH(\202)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(Add new base and inher)HY(i)HY(tance)YH(. Poten)HY(tially)YH( move object id + member from derived to base.)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(Add new base and mark all its data members as soft-added. + Add inher)HY(i)HY(tance)YH(. Move object id from derived to base. + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB(In base only \201refac)HY(tor)YH( exist)HY(ing)YH( data to new base\202)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(Add new base and move data members from derived to base. + Note: in most cases the new base will be made abstract + which make this scenario non-schema chang)HY(ing)YH(.)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(The same as HARD. + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB(In derived only \201add inher)HY(i)HY(tance)YH( to exist)HY(ing)YH( base\202)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(Add inher)HY(i)HY(tance)YH(, delete object id in derived.)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(Copy exist)HY(ing)YH( base to a new abstract base and inherit + from it. Mark all the database members in the new base + as soft-added \201except object id\202. When noti)HY(fied)YH( by the + ODB compiler that the soft addi)HY(tion)YH( of the data members + is no longer neces)HY(sary)YH(, delete the copy and inherit from + the orig)HY(i)HY(nal)YH( base. + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +]] +[[0 0 0 0 0 -1 0 0 1 15 2 0 0 9 5 {()} -1] + [[0 0 0 0 0 0 0][0 0 0 0 0 0 0][0 0 0 0 0 0 0]] + [[0 0 0 0 0 0 [[{()1 Sl()WB(Spec)HY(i)HY(fier)YH()} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(Summary)} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(Section + )} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(table)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(table name for a persis)HY(tent)YH( class)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 102 1 A(14.1.1)102 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(pointer)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(pointer type for a persis)HY(tent)YH( class)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 103 1 A(14.1.2)103 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(abstract)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(persis)HY(tent)YH( class is abstract)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 104 1 A(14.1.3)104 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(read)HY(only)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(persis)HY(tent)YH( class is read-only)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 105 1 A(14.1.4)105 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(opti)HY(mistic)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(persis)HY(tent)YH( class with the opti)HY(mistic)YH( concur)HY(rency)YH( model)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 106 1 A(14.1.5)106 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(no_id)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(persis)HY(tent)YH( class has no object id)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 107 1 A(14.1.6)107 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(call)HY(back)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(database oper)HY(a)HY(tions)YH( call)HY(back)YH()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 108 1 A(14.1.7)108 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(schema)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(database schema for a persis)HY(tent)YH( class)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 109 1 A(14.1.8)109 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(poly)HY(mor)HY(phic)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(persis)HY(tent)YH( class is poly)HY(mor)HY(phic)YH()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 110 1 A(14.1.9)110 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(session)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(enable/disable session support for a persis)HY(tent)YH( class)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 111 1 A(14.1.10)111 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(defi)HY(ni)HY(tion)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(defi)HY(ni)HY(tion)YH( loca)HY(tion)YH( for a persis)HY(tent)YH( class)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 112 1 A(14.1.11)112 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(tran)HY(sient)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(all non-virtual data members in a persis)HY(tent)YH( class are tran)HY(sient)YH()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 113 1 A(14.1.12)113 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(section)HY(able)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(support addi)HY(tion)YH( of new sections in derived classes)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 114 1 A(14.1.13)114 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(deleted)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(persis)HY(tent)YH( class is soft-deleted)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 115 1 A(14.1.14)115 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(bulk)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(enable bulk oper)HY(a)HY(tions)YH( for a persis)HY(tent)YH( class)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 116 1 A(14.1.15)116 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +]] +[[0 0 0 0 0 -1 0 0 1 7 2 0 0 9 5 {()} -1] + [[0 0 0 0 0 0 0][0 0 0 0 0 0 0][0 0 0 0 0 0 0]] + [[0 0 0 0 0 0 [[{()1 Sl()WB(Spec)HY(i)HY(fier)YH()} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(Summary)} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(Section + )} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(object)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(object asso)HY(ci)HY(ated)YH( with a view)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 118 1 A(14.2.1)118 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(table)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(table asso)HY(ci)HY(ated)YH( with a view)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 119 1 A(14.2.2)119 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(query)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(view query condi)HY(tion)YH()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 120 1 A(14.2.3)120 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(pointer)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(pointer type for a view)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 121 1 A(14.2.4)121 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(call)HY(back)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(database oper)HY(a)HY(tions)YH( call)HY(back)YH()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 122 1 A(14.2.5)122 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(defi)HY(ni)HY(tion)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(defi)HY(ni)HY(tion)YH( loca)HY(tion)YH( for a view)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 123 1 A(14.2.6)123 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(tran)HY(sient)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(all non-virtual data members in a view are tran)HY(sient)YH()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 124 1 A(14.2.7)124 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +]] +[[0 0 0 0 0 -1 0 0 1 21 2 0 0 9 5 {()} -1] + [[0 0 0 0 0 0 0][0 0 0 0 0 0 0][0 0 0 0 0 0 0]] + [[0 0 0 0 0 0 [[{()1 Sl()WB(Spec)HY(i)HY(fier)YH()} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(Summary)} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(Section + )} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(type)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(database type for a value type)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 126 1 A(14.3.1)126 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(id_type)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(database type for a value type when used as an object id)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 127 1 A(14.3.2)127 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(null)ES(/)SM(not_null)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(type can/cannot be )SM(NULL)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 128 1 A(14.3.3)128 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(default)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(default value for a value type)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 129 1 A(14.3.4)129 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(options)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(database options for a value type)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 130 1 A(14.3.5)130 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(read)HY(only)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(compos)HY(ite)YH( value type is read-only)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 131 1 A(14.3.6)131 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(defi)HY(ni)HY(tion)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(defi)HY(ni)HY(tion)YH( loca)HY(tion)YH( for a compos)HY(ite)YH( value type)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 132 1 A(14.3.7)132 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(tran)HY(sient)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(all non-virtual data members in a compos)HY(ite)YH( value are tran)HY(sient)YH()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 133 1 A(14.3.8)133 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(unordered)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(ordered container should be stored unordered)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 134 1 A(14.3.9)134 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(index_type)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(database type for a container's index type)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 135 1 A(14.3.10)135 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(key_type)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(database type for a container's key type)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 136 1 A(14.3.11)136 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(value_type)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(database type for a container's value type)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 137 1 A(14.3.12)137 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(value_null)ES(/)SM(value_not_null)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(container's value can/cannot be )SM(NULL)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 138 1 A(14.3.13)138 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(id_options)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(database options for a container's id column)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 139 1 A(14.3.14)139 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(index_options)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(database options for a container's index column)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 140 1 A(14.3.15)140 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(key_options)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(database options for a container's key column)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 141 1 A(14.3.16)141 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(value_options)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(database options for a container's value column)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 142 1 A(14.3.17)142 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(id_column)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(column name for a container's object id)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 143 1 A(14.3.18)143 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(index_column)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(column name for a container's index)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 144 1 A(14.3.19)144 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(key_column)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(column name for a container's key)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 145 1 A(14.3.20)145 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(value_column)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(column name for a container's value)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 146 1 A(14.3.21)146 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +]] +[[0 0 0 0 0 -1 0 0 1 36 2 0 0 9 5 {()} -1] + [[0 0 0 0 0 0 0][0 0 0 0 0 0 0][0 0 0 0 0 0 0]] + [[0 0 0 0 0 0 [[{()1 Sl()WB(Spec)HY(i)HY(fier)YH()} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(Summary)} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(Section + )} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(id)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(member is an object id)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 148 1 A(14.4.1)148 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(auto)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(id is assigned by the database)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 149 1 A(14.4.2)149 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(type)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(database type for a member)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 150 1 A(14.4.3)150 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(id_type)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(database type for a member when used as an object id)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 151 1 A(14.4.4)151 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(get)ES(/)SM(set)ES(/)SM(access)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(member acces)HY(sor)YH(/modi)HY(fier)YH( expres)HY(sions)YH()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 152 1 A(14.4.5)152 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(null)ES(/)SM(not_null)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(member can/cannot be )SM(NULL)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 153 1 A(14.4.6)153 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(default)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(default value for a member)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 154 1 A(14.4.7)154 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(options)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(database options for a member)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 155 1 A(14.4.8)155 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(column)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(column name for a member of an object or compos)HY(ite)YH( value)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 156 1 A(14.4.9)156 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(column)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(column name for a member of a view)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 157 1 A(14.4.10)157 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(tran)HY(sient)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(member is not stored in the database)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 158 1 A(14.4.11)158 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(read)HY(only)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(member is read-only)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 159 1 A(14.4.12)159 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(virtual)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(declare a virtual data member)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 160 1 A(14.4.13)160 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(inverse)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(member is an inverse side of a bidi)HY(rec)HY(tional)YH( rela)HY(tion)HY(ship)YH()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 161 1 A(14.4.14)161 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(on_delete)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(ON DELETE)ES( clause for object pointer member)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 162 1 A(14.4.15)162 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(version)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(member stores object version)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 163 1 A(14.4.16)163 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(index)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(define database index for a member)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 164 1 A(14.4.17)164 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(unique)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(define unique database index for a member)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 165 1 A(14.4.18)165 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(unordered)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(ordered container should be stored unordered)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 166 1 A(14.4.19)166 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(table)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(table name for a container)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 167 1 A(14.4.20)167 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(load)ES(/)SM(update)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(loading/updat)HY(ing)YH( behav)HY(ior)YH( for a section)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 168 1 A(14.4.21)168 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(section)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(member belongs to a section)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 169 1 A(14.4.22)169 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(added)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(member is soft-added)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 170 1 A(14.4.23)170 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(deleted)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(member is soft-deleted)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 171 1 A(14.4.24)171 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(index_type)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(database type for a container's index type)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 172 1 A(14.4.25)172 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(key_type)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(database type for a container's key type)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 173 1 A(14.4.26)173 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(value_type)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(database type for a container's value type)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 174 1 A(14.4.27)174 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(value_null)ES(/)SM(value_not_null)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(container's value can/cannot be )SM(NULL)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 175 1 A(14.4.28)175 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(id_options)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(database options for a container's id column)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 176 1 A(14.4.29)176 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(index_options)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(database options for a container's index column)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 177 1 A(14.4.30)177 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(key_options)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(database options for a container's key column)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 178 1 A(14.4.31)178 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(value_options)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(database options for a container's value column)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 179 1 A(14.4.32)179 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(id_column)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(column name for a container's object id)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 180 1 A(14.4.33)180 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(index_column)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(column name for a container's index)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 181 1 A(14.4.34)181 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(key_column)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(column name for a container's key)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 182 1 A(14.4.35)182 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(value_column)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(column name for a container's value)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 183 1 A(14.4.36)183 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +]] +[[0 0 0 0 0 -1 0 0 1 4 2 0 0 9 5 {()} -1] + [[0 0 0 0 0 0 0][0 0 0 0 0 0 0][0 0 0 0 0 0 0]] + [[0 0 0 0 0 0 [[{()1 Sl()WB(Spec)HY(i)HY(fier)YH()} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(Summary)} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(Section + )} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(pointer)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(pointer type for persis)HY(tent)YH( classes and views inside a names)HY(pace)YH()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 185 1 A(14.5.1)185 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(table)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(table name prefix for persis)HY(tent)YH( classes inside a names)HY(pace)YH()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 186 1 A(14.5.2)186 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(schema)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(database schema for persis)HY(tent)YH( classes inside a names)HY(pace)YH()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 187 1 A(14.5.3)187 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(session)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(enable/disable session support for persis)HY(tent)YH( classes inside a names)HY(pace)YH()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 188 1 A(14.5.4)188 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +]] +[[0 0 0 0 0 -1 0 0 1 1 2 0 0 9 5 {()} -1] + [[0 0 0 0 0 0 0][0 0 0 0 0 0 0][0 0 0 0 0 0 0]] + [[0 0 0 0 0 0 [[{()1 Sl()WB(Spec)HY(i)HY(fier)YH()} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(Summary)} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(Section + )} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(version)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(object model version)} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 190 1 A(14.6.1)190 0 TN TL()Ec /AF f D( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +]] +[[0 0 0 0 0 -1 0 0 0 5 1 0 0 1 1 {()} -1] + [[0 0 0 0 0 0 0][0 0 0 0 0 0 0]] + [[0 0 0 0 0 0 [[{()1 Sl()WB(16)} 0 0 1 0 1 1 1 (.) 2 0 8 8 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 205 1 A(Multi-Database Support)205 0 TN TL()Ec /AF f D()} 0 0 0 0 1 1 0 (.) 2 0 8 8 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB(17)} 0 0 1 0 1 1 1 (.) 2 0 8 8 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 209 1 A(MySQL Database)209 0 TN TL()Ec /AF f D()} 0 0 0 0 1 1 0 (.) 2 0 8 8 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB(18)} 0 0 1 0 1 1 1 (.) 2 0 8 8 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 221 1 A(SQLite Database)221 0 TN TL()Ec /AF f D()} 0 0 0 0 1 1 0 (.) 2 0 8 8 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB(19)} 0 0 1 0 1 1 1 (.) 2 0 8 8 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 237 1 A(Post)HY(greSQL)YH( Database)237 0 TN TL()Ec /AF f D()} 0 0 0 0 1 1 0 (.) 2 0 8 8 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB(20)} 0 0 1 0 1 1 1 (.) 2 0 8 8 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 252 1 A(Oracle Database)252 0 TN TL()Ec /AF f D()} 0 0 0 0 1 1 0 (.) 2 0 8 8 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB(21)} 0 0 1 0 1 1 1 (.) 2 0 8 8 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 270 1 A(Microsoft SQL Server Database)270 0 TN TL()Ec /AF f D()} 0 0 0 0 1 1 0 (.) 2 0 8 8 2 6 0 0 0 0 Db 0 ] +]] +]] +[[0 0 0 0 0 -1 0 0 1 16 2 0 0 9 5 {()} -1] + [[0 0 0 0 0 0 0][0 0 0 0 0 0 0][0 0 0 0 0 0 0]] + [[0 0 0 0 0 0 [[{()1 Sl()WB(C++ Type)} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(MySQL Type)} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(Default )SM(NULL)ES( Seman)HY(tics)YH( + )} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(bool)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(TINYINT\2011\202)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(char)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(CHAR\2011\202)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(signed char)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(TINYINT)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(unsigned char)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(TINYINT UNSIGNED)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(short)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(SMALL)HY(INT)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(unsigned short)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(SMALL)HY(INT)YH( UNSIGNED)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(int)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(INT)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(unsigned int)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(INT UNSIGNED)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(long)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(BIGINT)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(unsigned long)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(BIGINT UNSIGNED)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(long long)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(BIGINT)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(unsigned long long)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(BIGINT UNSIGNED)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(float)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(FLOAT)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(double)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(DOUBLE)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(std::string)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(TEXT/VARCHAR\201255\202)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(char[N])ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(VARCHAR\201N-1\202)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +]] +[[0 0 0 0 0 -1 0 0 1 18 2 0 0 9 5 {()} -1] + [[0 0 0 0 0 0 0][0 0 0 0 0 0 0][0 0 0 0 0 0 0]] + [[0 0 0 0 0 0 [[{()1 Sl()WB(C++ Type)} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(SQLite Type)} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(Default )SM(NULL)ES( Seman)HY(tics)YH( + )} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(bool)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(INTEGER)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(char)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(TEXT)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(signed char)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(INTEGER)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(unsigned char)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(INTEGER)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(short)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(INTEGER)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(unsigned short)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(INTEGER)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(int)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(INTEGER)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(unsigned int)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(INTEGER)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(long)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(INTEGER)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(unsigned long)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(INTEGER)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(long long)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(INTEGER)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(unsigned long long)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(INTEGER)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(float)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(REAL)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(double)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(REAL)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(std::string)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(TEXT)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(char[N])ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(TEXT)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(std::wstring \201Windows only\202)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(TEXT)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(wchar_t[N] \201Windows only\202)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(TEXT)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +]] +[[0 0 0 0 0 -1 0 0 1 16 2 0 0 9 5 {()} -1] + [[0 0 0 0 0 0 0][0 0 0 0 0 0 0][0 0 0 0 0 0 0]] + [[0 0 0 0 0 0 [[{()1 Sl()WB(C++ Type)} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(Post)HY(greSQL)YH( Type)} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(Default )SM(NULL)ES( Seman)HY(tics)YH( + )} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(bool)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(BOOLEAN)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(char)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(CHAR\2011\202)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(signed char)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(SMALL)HY(INT)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(unsigned char)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(SMALL)HY(INT)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(short)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(SMALL)HY(INT)YH( NULL)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(unsigned short)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(SMALL)HY(INT)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(int)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(INTEGER)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(unsigned int)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(INTEGER)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(long)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(BIGINT)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(unsigned long)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(BIGINT)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(long long)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(BIGINT)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(unsigned long long)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(BIGINT)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(float)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(REAL)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(double)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(DOUBLE PRECI)HY(SION)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(std::string)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(TEXT)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(char[N])ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(VARCHAR\201N-1\202)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +]] +[[0 0 0 0 0 -1 0 0 1 16 2 0 0 9 5 {()} -1] + [[0 0 0 0 0 0 0][0 0 0 0 0 0 0][0 0 0 0 0 0 0]] + [[0 0 0 0 0 0 [[{()1 Sl()WB(C++ Type)} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(Oracle Type)} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(Default )SM(NULL)ES( Seman)HY(tics)YH( + )} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(bool)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NUMBER\2011\202)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(char)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(CHAR\2011\202)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(signed char)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NUMBER\2013\202)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(unsigned char)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NUMBER\2013\202)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(short)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NUMBER\2015\202)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(unsigned short)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NUMBER\2015\202)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(int)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NUMBER\20110\202)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(unsigned int)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NUMBER\20110\202)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(long)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NUMBER\20119\202)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(unsigned long)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NUMBER\20120\202)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(long long)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NUMBER\20119\202)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(unsigned long long)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NUMBER\20120\202)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(float)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(BINARY_FLOAT)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(double)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(BINARY_DOUBLE)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(std::string)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(VARCHAR2\201512\202)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(char[N])ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(VARCHAR2\201N-1\202)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +]] +[[0 0 0 0 0 -1 0 0 1 19 2 0 0 9 5 {()} -1] + [[0 0 0 0 0 0 0][0 0 0 0 0 0 0][0 0 0 0 0 0 0]] + [[0 0 0 0 0 0 [[{()1 Sl()WB(C++ Type)} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(SQL Server Type)} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(Default )SM(NULL)ES( Seman)HY(tics)YH( + )} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(bool)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(BIT)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(char)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(CHAR\2011\202)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(signed char)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(TINYINT)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(unsigned char)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(TINYINT)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(short)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(SMALL)HY(INT)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(unsigned short)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(SMALL)HY(INT)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(int)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(INT)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(unsigned int)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(INT)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(long)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(BIGINT)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(unsigned long)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(BIGINT)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(long long)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(BIGINT)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(unsigned long long)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(BIGINT)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(float)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(REAL)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(double)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(FLOAT)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(std::string)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(VARCHAR\201512\202/VARCHAR\201256\202)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(char[N])ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(VARCHAR\201N-1\202)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(std::wstring)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NVAR)HY(CHAR)YH(\201512\202/NVAR)HY(CHAR)YH(\201256\202)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(wchar_t[N])ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NVAR)HY(CHAR)YH(\201N-1\202)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(GUID)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(UNIQUEI)HY(DEN)HY(TI)HY(FIER)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NOT NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +]] +[[0 0 0 0 0 -1 0 0 0 2 1 0 0 1 1 {()} -1] + [[0 0 0 0 0 0 0][0 0 0 0 0 0 0]] + [[0 0 0 0 0 0 [[{()1 Sl()WB(22)} 0 0 1 0 1 1 1 (.) 2 0 8 8 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 291 1 A(Profiles Intro)HY(duc)HY(tion)YH()291 0 TN TL()Ec /AF f D()} 0 0 0 0 1 1 0 (.) 2 0 8 8 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB(23)} 0 0 1 0 1 1 1 (.) 2 0 8 8 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 292 1 A(Boost Profile)292 0 TN TL()Ec /AF f D()} 0 0 0 0 1 1 0 (.) 2 0 8 8 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB(24)} 0 0 1 0 1 1 1 (.) 2 0 8 8 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()0 309 1 A(Qt Profile)309 0 TN TL()Ec /AF f D()} 0 0 0 0 1 1 0 (.) 2 0 8 8 2 6 0 0 0 0 Db 0 ] +]] +]] +[[0 0 0 0 0 -1 0 0 1 3 2 0 0 9 5 {()} -1] + [[0 0 0 0 0 0 0][0 0 0 0 0 0 0][0 0 0 0 0 0 0]] + [[0 0 0 0 0 0 [[{()1 Sl()WB(Boost )SM(date_time)ES( Type)} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(MySQL Type)} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(Default )SM(NULL)ES( Seman)HY(tics)YH( + )} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(grego)HY(rian)YH(::date)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(DATE)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(posix_time::ptime)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(DATE)HY(TIME)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(posix_time::time_dura)HY(tion)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(TIME)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +]] +[[0 0 0 0 0 -1 0 0 1 3 2 0 0 9 5 {()} -1] + [[0 0 0 0 0 0 0][0 0 0 0 0 0 0][0 0 0 0 0 0 0]] + [[0 0 0 0 0 0 [[{()1 Sl()WB(Boost )SM(date_time)ES( Type)} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(SQLite Type)} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(Default )SM(NULL)ES( Seman)HY(tics)YH( + )} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(grego)HY(rian)YH(::date)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(TEXT)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(posix_time::ptime)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(TEXT)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(posix_time::time_dura)HY(tion)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(TEXT)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +]] +[[0 0 0 0 0 -1 0 0 1 3 2 0 0 9 5 {()} -1] + [[0 0 0 0 0 0 0][0 0 0 0 0 0 0][0 0 0 0 0 0 0]] + [[0 0 0 0 0 0 [[{()1 Sl()WB(Boost )SM(date_time)ES( Type)} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(Post)HY(greSQL)YH( Type)} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(Default )SM(NULL)ES( Seman)HY(tics)YH( + )} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(grego)HY(rian)YH(::date)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(DATE)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(posix_time::ptime)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(TIMES)HY(TAMP)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(posix_time::time_dura)HY(tion)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(TIME)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +]] +[[0 0 0 0 0 -1 0 0 1 3 2 0 0 9 5 {()} -1] + [[0 0 0 0 0 0 0][0 0 0 0 0 0 0][0 0 0 0 0 0 0]] + [[0 0 0 0 0 0 [[{()1 Sl()WB(Boost )SM(date_time)ES( Type)} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(Oracle Type)} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(Default )SM(NULL)ES( Seman)HY(tics)YH( + )} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(grego)HY(rian)YH(::date)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(DATE)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(posix_time::ptime)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(TIMES)HY(TAMP)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(posix_time::time_dura)HY(tion)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(INTER)HY(VAL)YH( DAY TO SECOND)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +]] +[[0 0 0 0 0 -1 0 0 1 3 2 0 0 9 5 {()} -1] + [[0 0 0 0 0 0 0][0 0 0 0 0 0 0][0 0 0 0 0 0 0]] + [[0 0 0 0 0 0 [[{()1 Sl()WB(Boost )SM(date_time)ES( Type)} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(SQL Server Type)} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(Default )SM(NULL)ES( Seman)HY(tics)YH( + )} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(grego)HY(rian)YH(::date)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(DATE)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(posix_time::ptime)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(DATE)HY(TIME)YH(2)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(posix_time::time_dura)HY(tion)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(TIME)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +]] +[[0 0 0 0 0 -1 0 0 1 1 2 0 0 9 5 {()} -1] + [[0 0 0 0 0 0 0][0 0 0 0 0 0 0][0 0 0 0 0 0 0]] + [[0 0 0 0 0 0 [[{()1 Sl()WB(Boost Type)} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(MySQL Type)} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(Default )SM(NULL)ES( Seman)HY(tics)YH( + )} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(boost::uuids::uuid)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(BINARY\20116\202)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +]] +[[0 0 0 0 0 -1 0 0 1 1 2 0 0 9 5 {()} -1] + [[0 0 0 0 0 0 0][0 0 0 0 0 0 0][0 0 0 0 0 0 0]] + [[0 0 0 0 0 0 [[{()1 Sl()WB(Boost Type)} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(SQLite Type)} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(Default )SM(NULL)ES( Seman)HY(tics)YH( + )} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(boost::uuids::uuid)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(BLOB)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +]] +[[0 0 0 0 0 -1 0 0 1 1 2 0 0 9 5 {()} -1] + [[0 0 0 0 0 0 0][0 0 0 0 0 0 0][0 0 0 0 0 0 0]] + [[0 0 0 0 0 0 [[{()1 Sl()WB(Boost Type)} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(Post)HY(greSQL)YH( Type)} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(Default )SM(NULL)ES( Seman)HY(tics)YH( + )} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(boost::uuids::uuid)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(UUID)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +]] +[[0 0 0 0 0 -1 0 0 1 1 2 0 0 9 5 {()} -1] + [[0 0 0 0 0 0 0][0 0 0 0 0 0 0][0 0 0 0 0 0 0]] + [[0 0 0 0 0 0 [[{()1 Sl()WB(Boost Type)} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(Oracle Type)} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(Default )SM(NULL)ES( Seman)HY(tics)YH( + )} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(boost::uuids::uuid)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(RAW\20116\202)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +]] +[[0 0 0 0 0 -1 0 0 1 1 2 0 0 9 5 {()} -1] + [[0 0 0 0 0 0 0][0 0 0 0 0 0 0][0 0 0 0 0 0 0]] + [[0 0 0 0 0 0 [[{()1 Sl()WB(Boost Type)} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(SQL Server Type)} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(Default )SM(NULL)ES( Seman)HY(tics)YH( + )} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(boost::uuids::uuid)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(UNIQUEI)HY(DEN)HY(TI)HY(FIER)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +]] +[[0 0 0 0 0 -1 0 0 1 3 2 0 0 9 5 {()} -1] + [[0 0 0 0 0 0 0][0 0 0 0 0 0 0][0 0 0 0 0 0 0]] + [[0 0 0 0 0 0 [[{()1 Sl()WB(Qt Type)} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(MySQL Type)} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(Default )SM(NULL)ES( Seman)HY(tics)YH( + )} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(QString)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(TEXT/VARCHAR\201255\202)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(QByteAr)HY(ray)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(BLOB)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(QUuid)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(BINARY\20116\202)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +]] +[[0 0 0 0 0 -1 0 0 1 3 2 0 0 9 5 {()} -1] + [[0 0 0 0 0 0 0][0 0 0 0 0 0 0][0 0 0 0 0 0 0]] + [[0 0 0 0 0 0 [[{()1 Sl()WB(Qt Type)} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(SQLite Type)} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(Default )SM(NULL)ES( Seman)HY(tics)YH( + )} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(QString)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(TEXT)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(QByteAr)HY(ray)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(BLOB)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(QUuid)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(BLOB)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +]] +[[0 0 0 0 0 -1 0 0 1 3 2 0 0 9 5 {()} -1] + [[0 0 0 0 0 0 0][0 0 0 0 0 0 0][0 0 0 0 0 0 0]] + [[0 0 0 0 0 0 [[{()1 Sl()WB(Qt Type)} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(Post)HY(greSQL)YH( Type)} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(Default )SM(NULL)ES( Seman)HY(tics)YH( + )} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(QString)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(TEXT)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(QByteAr)HY(ray)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(BYTEA)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(QUuid)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(UUID)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +]] +[[0 0 0 0 0 -1 0 0 1 3 2 0 0 9 5 {()} -1] + [[0 0 0 0 0 0 0][0 0 0 0 0 0 0][0 0 0 0 0 0 0]] + [[0 0 0 0 0 0 [[{()1 Sl()WB(Qt Type)} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(Oracle Type)} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(Default )SM(NULL)ES( Seman)HY(tics)YH( + )} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(QString)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(VARCHAR2\201512\202)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(QByteAr)HY(ray)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(BLOB)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(QUuid)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(RAW\20116\202)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +]] +[[0 0 0 0 0 -1 0 0 1 3 2 0 0 9 5 {()} -1] + [[0 0 0 0 0 0 0][0 0 0 0 0 0 0][0 0 0 0 0 0 0]] + [[0 0 0 0 0 0 [[{()1 Sl()WB(Qt Type)} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(SQL Server Type)} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(Default )SM(NULL)ES( Seman)HY(tics)YH( + )} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(QString)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(VARCHAR\201512\202/VARCHAR\201256\202)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(QByteAr)HY(ray)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(VARBINARY\201max\202)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(QUuid)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(UNIQUEI)HY(DEN)HY(TI)HY(FIER)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +]] +[[0 0 0 0 0 -1 0 0 1 3 2 0 0 9 5 {()} -1] + [[0 0 0 0 0 0 0][0 0 0 0 0 0 0][0 0 0 0 0 0 0]] + [[0 0 0 0 0 0 [[{()1 Sl()WB(Qt Date Time Type)} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(MySQL Type)} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(Default )SM(NULL)ES( Seman)HY(tics)YH( + )} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(QDate)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(DATE)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(QTime)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(TIME)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(QDate)HY(Time)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(DATE)HY(TIME)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +]] +[[0 0 0 0 0 -1 0 0 1 3 2 0 0 9 5 {()} -1] + [[0 0 0 0 0 0 0][0 0 0 0 0 0 0][0 0 0 0 0 0 0]] + [[0 0 0 0 0 0 [[{()1 Sl()WB(Qt Date Time Type)} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(SQLite Type)} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(Default )SM(NULL)ES( Seman)HY(tics)YH( + )} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(QDate)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(TEXT)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(QTime)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(TEXT)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(QDate)HY(Time)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(TEXT)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +]] +[[0 0 0 0 0 -1 0 0 1 3 2 0 0 9 5 {()} -1] + [[0 0 0 0 0 0 0][0 0 0 0 0 0 0][0 0 0 0 0 0 0]] + [[0 0 0 0 0 0 [[{()1 Sl()WB(Qt Date Time Type)} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(Post)HY(greSQL)YH( Type)} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(Default )SM(NULL)ES( Seman)HY(tics)YH( + )} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(QDate)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(DATE)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(QTime)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(TIME)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(QDate)HY(Time)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(TIMES)HY(TAMP)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +]] +[[0 0 0 0 0 -1 0 0 1 3 2 0 0 9 5 {()} -1] + [[0 0 0 0 0 0 0][0 0 0 0 0 0 0][0 0 0 0 0 0 0]] + [[0 0 0 0 0 0 [[{()1 Sl()WB(Qt Date Time Type)} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(Oracle Type)} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(Default )SM(NULL)ES( Seman)HY(tics)YH( + )} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(QDate)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(DATE)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(QTime)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(INTER)HY(VAL)YH( DAY\2010\202 TO SECOND\2013\202)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(QDate)HY(Time)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(TIMES)HY(TAMP)YH(\2013\202)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +]] +[[0 0 0 0 0 -1 0 0 1 3 2 0 0 9 5 {()} -1] + [[0 0 0 0 0 0 0][0 0 0 0 0 0 0][0 0 0 0 0 0 0]] + [[0 0 0 0 0 0 [[{()1 Sl()WB(Qt Date Time Type)} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(SQL Server Type)} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB(Default )SM(NULL)ES( Seman)HY(tics)YH( + )} 0 0 1 0 1 1 1 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(QDate)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(DATE)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(QTime)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(TIME\2013\202)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +[0 0 0 0 0 0 [[{()1 Sl()WB()SM(QDate)HY(Time)YH()ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(DATE)HY(TIME)YH(2\2013\202)ES()} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +[{()1 Sl()WB()SM(NULL)ES( + )} 0 0 0 0 1 1 0 (.) 2 0 4 4 2 6 0 0 0 0 Db 0 ] +]] +]] +] D +0 1 36{TS}for RC ZF +/Ba f D /BO 0 D Bs +/UR (/home/boris/work/odb/odb/doc/manual.xhtml) D +/Ti (C++ Object Persistence with ODB) D +/Au () D +/Df f D +/ME [(2.4)(2.4.0)] D +Pt +/BO 0 D TC /Ba f D Bs /AU f D /UR () D RC ZF + tH WB +ND 1 gt{Ts 3 mul Np 0()0 C()BD(C++ Object Persistence with ODB)ES()0 1 TN()EA()BN}if +1 NH le{325(1\240\240)1 C(Preface)WB 3 Sn()325 1 TN()EA()BN}if +2 NH le{326(1.1\240\240)2 C(About)WB 4 Sn( This Docu)HY(ment)YH()326 1 TN()EA()BN}if +2 NH le{327(1.2\240\240)2 C(More)WB 5 Sn( Infor)HY(ma)HY(tion)YH()327 1 TN()EA()BN}if +1 NH le{328(2\240\240)1 C(PART)WB 6 Sn( I\240\240 + OBJECT-RELA)HY(TIONAL)YH( MAPPING)328 1 TN()EA()BN}if +1 NH le{329(3\240\240)1 C(1)WB 7 Sn( Intro)HY(duc)HY(tion)YH()329 1 TN()EA()BN}if +2 NH le{330(3.1\240\240)2 C(1.1)WB 8 Sn( Archi)HY(tec)HY(ture)YH( and Work)HY(flow)YH()330 1 TN()EA()BN}if +2 NH le{331(3.2\240\240)2 C(1.2)WB 9 Sn( Bene)HY(fits)YH()331 1 TN()EA()BN}if +2 NH le{332(3.3\240\240)2 C(1.3)WB 10 Sn( Supported C++ Stan)HY(dards)YH()332 1 TN()EA()BN}if +1 NH le{333(4\240\240)1 C(2)WB 11 Sn( Hello World Example)333 1 TN()EA()BN}if +2 NH le{334(4.1\240\240)2 C(2.1)WB 12 Sn( Declar)HY(ing)YH( Persis)HY(tent)YH( Classes)334 1 TN()EA()BN}if +2 NH le{335(4.2\240\240)2 C(2.2)WB 13 Sn( Gener)HY(at)HY(ing)YH( Database Support Code)335 1 TN()EA()BN}if +2 NH le{336(4.3\240\240)2 C(2.3)WB 14 Sn( Compil)HY(ing)YH( and Running)336 1 TN()EA()BN}if +2 NH le{337(4.4\240\240)2 C(2.4)WB 15 Sn( Making Objects Persis)HY(tent)YH()337 1 TN()EA()BN}if +2 NH le{338(4.5\240\240)2 C(2.5)WB 16 Sn( Query)HY(ing)YH( the Database for Objects)338 1 TN()EA()BN}if +2 NH le{339(4.6\240\240)2 C(2.6)WB 17 Sn( Updat)HY(ing)YH( Persis)HY(tent)YH( Objects)339 1 TN()EA()BN}if +2 NH le{340(4.7\240\240)2 C(2.7)WB 18 Sn( Defin)HY(ing)YH( and Using Views)340 1 TN()EA()BN}if +2 NH le{341(4.8\240\240)2 C(2.8)WB 19 Sn( Delet)HY(ing)YH( Persis)HY(tent)YH( Objects)341 1 TN()EA()BN}if +2 NH le{342(4.9\240\240)2 C(2.9)WB 20 Sn( Chang)HY(ing)YH( Persis)HY(tent)YH( Classes)342 1 TN()EA()BN}if +2 NH le{343(4.10\240\240)2 C(2.10)WB 21 Sn( Working with Multi)HY(ple)YH( Databases)343 1 TN()EA()BN}if +2 NH le{344(4.11\240\240)2 C(2.11)WB 22 Sn( Summary)344 1 TN()EA()BN}if +1 NH le{345(5\240\240)1 C(3)WB 23 Sn( Working with Persis)HY(tent)YH( Objects)345 1 TN()EA()BN}if +2 NH le{346(5.1\240\240)2 C(3.1)WB 24 Sn( Concepts and Termi)HY(nol)HY(ogy)YH()346 1 TN()EA()BN}if +2 NH le{347(5.2\240\240)2 C(3.2)WB 25 Sn( Declar)HY(ing)YH( Persis)HY(tent)YH( Objects and Values)347 1 TN()EA()BN}if +2 NH le{348(5.3\240\240)2 C(3.3)WB 26 Sn( Object and View Point)HY(ers)YH()348 1 TN()EA()BN}if +2 NH le{349(5.4\240\240)2 C(3.4)WB 27 Sn( Database)349 1 TN()EA()BN}if +2 NH le{350(5.5\240\240)2 C(3.5)WB 28 Sn( Trans)HY(ac)HY(tions)YH()350 1 TN()EA()BN}if +2 NH le{351(5.6\240\240)2 C(3.6)WB 29 Sn( Connec)HY(tions)YH()351 1 TN()EA()BN}if +2 NH le{352(5.7\240\240)2 C(3.7)WB 30 Sn( Error Handling and Recov)HY(ery)YH()352 1 TN()EA()BN}if +2 NH le{353(5.8\240\240)2 C(3.8)WB 31 Sn( Making Objects Persis)HY(tent)YH()353 1 TN()EA()BN}if +2 NH le{354(5.9\240\240)2 C(3.9)WB 32 Sn( Loading Persis)HY(tent)YH( Objects)354 1 TN()EA()BN}if +2 NH le{355(5.10\240\240)2 C(3.10)WB 33 Sn( Updat)HY(ing)YH( Persis)HY(tent)YH( Objects)355 1 TN()EA()BN}if +2 NH le{356(5.11\240\240)2 C(3.11)WB 34 Sn( Delet)HY(ing)YH( Persis)HY(tent)YH( Objects)356 1 TN()EA()BN}if +2 NH le{357(5.12\240\240)2 C(3.12)WB 35 Sn( Execut)HY(ing)YH( Native SQL State)HY(ments)YH()357 1 TN()EA()BN}if +2 NH le{358(5.13\240\240)2 C(3.13)WB 36 Sn( Tracing SQL State)HY(ment)YH( Execu)HY(tion)YH()358 1 TN()EA()BN}if +2 NH le{359(5.14\240\240)2 C(3.14)WB 37 Sn( ODB Excep)HY(tions)YH()359 1 TN()EA()BN}if +1 NH le{360(6\240\240)1 C(4)WB 38 Sn( Query)HY(ing)YH( the Database)360 1 TN()EA()BN}if +2 NH le{361(6.1\240\240)2 C(4.1)WB 39 Sn( ODB Query Language)361 1 TN()EA()BN}if +2 NH le{362(6.2\240\240)2 C(4.2)WB 41 Sn( Param)HY(e)HY(ter)YH( Binding)362 1 TN()EA()BN}if +2 NH le{363(6.3\240\240)2 C(4.3)WB 42 Sn( Execut)HY(ing)YH( a Query)363 1 TN()EA()BN}if +2 NH le{364(6.4\240\240)2 C(4.4)WB 43 Sn( Query Result)364 1 TN()EA()BN}if +2 NH le{365(6.5\240\240)2 C(4.5)WB 44 Sn( Prepared Queries)365 1 TN()EA()BN}if +1 NH le{366(7\240\240)1 C(5)WB 45 Sn( Contain)HY(ers)YH()366 1 TN()EA()BN}if +2 NH le{367(7.1\240\240)2 C(5.1)WB 46 Sn( Ordered Contain)HY(ers)YH()367 1 TN()EA()BN}if +2 NH le{368(7.2\240\240)2 C(5.2)WB 47 Sn( Set and Multi)HY(set)YH( Contain)HY(ers)YH()368 1 TN()EA()BN}if +2 NH le{369(7.3\240\240)2 C(5.3)WB 48 Sn( Map and Multimap Contain)HY(ers)YH()369 1 TN()EA()BN}if +2 NH le{370(7.4\240\240)2 C(5.4)WB 49 Sn( Change-Track)HY(ing)YH( Contain)HY(ers)YH()370 1 TN()EA()BN}if +3 NH le{371(7.4.1\240\240)3 C(5.4.1)WB 50 Sn( Change-Track)HY(ing)YH( )SM(vector)ES()371 1 TN()EA()BN}if +2 NH le{372(7.5\240\240)2 C(5.5)WB 51 Sn( Using Custom Contain)HY(ers)YH()372 1 TN()EA()BN}if +1 NH le{373(8\240\240)1 C(6)WB 52 Sn( Rela)HY(tion)HY(ships)YH()373 1 TN()EA()BN}if +2 NH le{374(8.1\240\240)2 C(6.1)WB 53 Sn( Unidi)HY(rec)HY(tional)YH( Rela)HY(tion)HY(ships)YH()374 1 TN()EA()BN}if +3 NH le{375(8.1.1\240\240)3 C(6.1.1)WB 54 Sn( To-One Rela)HY(tion)HY(ships)YH()375 1 TN()EA()BN}if +3 NH le{376(8.1.2\240\240)3 C(6.1.2)WB 55 Sn( To-Many Rela)HY(tion)HY(ships)YH()376 1 TN()EA()BN}if +2 NH le{377(8.2\240\240)2 C(6.2)WB 56 Sn( Bidi)HY(rec)HY(tional)YH( Rela)HY(tion)HY(ships)YH()377 1 TN()EA()BN}if +3 NH le{378(8.2.1\240\240)3 C(6.2.1)WB 57 Sn( One-to-One Rela)HY(tion)HY(ships)YH()378 1 TN()EA()BN}if +3 NH le{379(8.2.2\240\240)3 C(6.2.2)WB 58 Sn( One-to-Many Rela)HY(tion)HY(ships)YH()379 1 TN()EA()BN}if +3 NH le{380(8.2.3\240\240)3 C(6.2.3)WB 59 Sn( Many-to-Many Rela)HY(tion)HY(ships)YH()380 1 TN()EA()BN}if +2 NH le{381(8.3\240\240)2 C(6.3)WB 60 Sn( Circu)HY(lar)YH( Rela)HY(tion)HY(ships)YH()381 1 TN()EA()BN}if +2 NH le{382(8.4\240\240)2 C(6.4)WB 61 Sn( Lazy Point)HY(ers)YH()382 1 TN()EA()BN}if +2 NH le{383(8.5\240\240)2 C(6.5)WB 62 Sn( Using Custom Smart Point)HY(ers)YH()383 1 TN()EA()BN}if +1 NH le{384(9\240\240)1 C(7)WB 63 Sn( Value Types)384 1 TN()EA()BN}if +2 NH le{385(9.1\240\240)2 C(7.1)WB 64 Sn( Simple Value Types)385 1 TN()EA()BN}if +2 NH le{386(9.2\240\240)2 C(7.2)WB 65 Sn( Compos)HY(ite)YH( Value Types)386 1 TN()EA()BN}if +3 NH le{387(9.2.1\240\240)3 C(7.2.1)WB 66 Sn( Compos)HY(ite)YH( Object Ids)387 1 TN()EA()BN}if +3 NH le{388(9.2.2\240\240)3 C(7.2.2)WB 67 Sn( Compos)HY(ite)YH( Value Column and Table Names)388 1 TN()EA()BN}if +2 NH le{389(9.3\240\240)2 C(7.3)WB 68 Sn( Point)HY(ers)YH( and )SM(NULL)ES( Value Seman)HY(tics)YH()389 1 TN()EA()BN}if +1 NH le{390(10\240\240)1 C(8)WB 69 Sn( Inher)HY(i)HY(tance)YH()390 1 TN()EA()BN}if +2 NH le{391(10.1\240\240)2 C(8.1)WB 70 Sn( Reuse Inher)HY(i)HY(tance)YH()391 1 TN()EA()BN}if +2 NH le{392(10.2\240\240)2 C(8.2)WB 71 Sn( Poly)HY(mor)HY(phism)YH( Inher)HY(i)HY(tance)YH()392 1 TN()EA()BN}if +3 NH le{393(10.2.1\240\240)3 C(8.2.1)WB 72 Sn( Perfor)HY(mance)YH( and Limi)HY(ta)HY(tions)YH()393 1 TN()EA()BN}if +2 NH le{394(10.3\240\240)2 C(8.3)WB 73 Sn( Mixed Inher)HY(i)HY(tance)YH()394 1 TN()EA()BN}if +1 NH le{395(11\240\240)1 C(9)WB 74 Sn( Sections)395 1 TN()EA()BN}if +2 NH le{396(11.1\240\240)2 C(9.1)WB 75 Sn( Sections and Inher)HY(i)HY(tance)YH()396 1 TN()EA()BN}if +2 NH le{397(11.2\240\240)2 C(9.2)WB 76 Sn( Sections and Opti)HY(mistic)YH( Concur)HY(rency)YH()397 1 TN()EA()BN}if +2 NH le{398(11.3\240\240)2 C(9.3)WB 77 Sn( Sections and Lazy Point)HY(ers)YH()398 1 TN()EA()BN}if +2 NH le{399(11.4\240\240)2 C(9.4)WB 78 Sn( Sections and Change-Track)HY(ing)YH( Contain)HY(ers)YH()399 1 TN()EA()BN}if +1 NH le{400(12\240\240)1 C(10)WB 79 Sn( Views)400 1 TN()EA()BN}if +2 NH le{401(12.1\240\240)2 C(10.1)WB 80 Sn( Object Views)401 1 TN()EA()BN}if +2 NH le{402(12.2\240\240)2 C(10.2)WB 81 Sn( Object Loading Views)402 1 TN()EA()BN}if +2 NH le{403(12.3\240\240)2 C(10.3)WB 82 Sn( Table Views)403 1 TN()EA()BN}if +2 NH le{404(12.4\240\240)2 C(10.4)WB 83 Sn( Mixed Views)404 1 TN()EA()BN}if +2 NH le{405(12.5\240\240)2 C(10.5)WB 84 Sn( View Query Condi)HY(tions)YH()405 1 TN()EA()BN}if +2 NH le{406(12.6\240\240)2 C(10.6)WB 85 Sn( Native Views)406 1 TN()EA()BN}if +2 NH le{407(12.7\240\240)2 C(10.7)WB 86 Sn( Other View Features and Limi)HY(ta)HY(tions)YH()407 1 TN()EA()BN}if +1 NH le{408(13\240\240)1 C(11)WB 87 Sn( Session)408 1 TN()EA()BN}if +2 NH le{409(13.1\240\240)2 C(11.1)WB 88 Sn( Object Cache)409 1 TN()EA()BN}if +2 NH le{410(13.2\240\240)2 C(11.2)WB 89 Sn( Custom Sessions)410 1 TN()EA()BN}if +1 NH le{411(14\240\240)1 C(12)WB 90 Sn( Opti)HY(mistic)YH( Concur)HY(rency)YH()411 1 TN()EA()BN}if +1 NH le{412(15\240\240)1 C(13)WB 91 Sn( Database Schema Evolu)HY(tion)YH()412 1 TN()EA()BN}if +2 NH le{413(15.1\240\240)2 C(13.1)WB 92 Sn( Object Model Version and Changelog)413 1 TN()EA()BN}if +2 NH le{414(15.2\240\240)2 C(13.2)WB 93 Sn( Schema Migra)HY(tion)YH()414 1 TN()EA()BN}if +2 NH le{415(15.3\240\240)2 C(13.3)WB 94 Sn( Data Migra)HY(tion)YH()415 1 TN()EA()BN}if +2 NH le{416(15.4\240\240)2 C(13.3.1)WB 95 Sn( Imme)HY(di)HY(ate)YH( Data Migra)HY(tion)YH()416 1 TN()EA()BN}if +2 NH le{417(15.5\240\240)2 C(13.3.2)WB 96 Sn( Gradual Data Migra)HY(tion)YH()417 1 TN()EA()BN}if +2 NH le{418(15.6\240\240)2 C(13.4)WB 97 Sn( Soft Object Model Changes)418 1 TN()EA()BN}if +2 NH le{419(15.7\240\240)2 C(13.4.1)WB 98 Sn( Reuse Inher)HY(i)HY(tance)YH( Changes)419 1 TN()EA()BN}if +2 NH le{420(15.8\240\240)2 C(13.4.2)WB 99 Sn( Poly)HY(mor)HY(phism)YH( Inher)HY(i)HY(tance)YH( Changes)420 1 TN()EA()BN}if +1 NH le{421(16\240\240)1 C(14)WB 100 Sn( ODB Pragma Language)421 1 TN()EA()BN}if +2 NH le{422(16.1\240\240)2 C(14.1)WB 101 Sn( Object Type Pragmas)422 1 TN()EA()BN}if +3 NH le{423(16.1.1\240\240)3 C(14.1.1)WB 102 Sn( )SM(table)ES()423 1 TN()EA()BN}if +3 NH le{424(16.1.2\240\240)3 C(14.1.2)WB 103 Sn( )SM(pointer)ES()424 1 TN()EA()BN}if +3 NH le{425(16.1.3\240\240)3 C(14.1.3)WB 104 Sn( )SM(abstract)ES()425 1 TN()EA()BN}if +3 NH le{426(16.1.4\240\240)3 C(14.1.4)WB 105 Sn( )SM(read)HY(only)YH()ES()426 1 TN()EA()BN}if +3 NH le{427(16.1.5\240\240)3 C(14.1.5)WB 106 Sn( )SM(opti)HY(mistic)YH()ES()427 1 TN()EA()BN}if +3 NH le{428(16.1.6\240\240)3 C(14.1.6)WB 107 Sn( )SM(no_id)ES()428 1 TN()EA()BN}if +3 NH le{429(16.1.7\240\240)3 C(14.1.7)WB 108 Sn( )SM(call)HY(back)YH()ES()429 1 TN()EA()BN}if +3 NH le{430(16.1.8\240\240)3 C(14.1.8)WB 109 Sn( )SM(schema)ES()430 1 TN()EA()BN}if +3 NH le{431(16.1.9\240\240)3 C(14.1.9)WB 110 Sn( )SM(poly)HY(mor)HY(phic)YH()ES()431 1 TN()EA()BN}if +3 NH le{432(16.1.10\240\240)3 C(14.1.10)WB 111 Sn( )SM(session)ES()432 1 TN()EA()BN}if +3 NH le{433(16.1.11\240\240)3 C(14.1.11)WB 112 Sn( )SM(defi)HY(ni)HY(tion)YH()ES()433 1 TN()EA()BN}if +3 NH le{434(16.1.12\240\240)3 C(14.1.12)WB 113 Sn( )SM(tran)HY(sient)YH()ES()434 1 TN()EA()BN}if +3 NH le{435(16.1.13\240\240)3 C(14.1.13)WB 114 Sn( )SM(section)HY(able)YH()ES()435 1 TN()EA()BN}if +3 NH le{436(16.1.14\240\240)3 C(14.1.14)WB 115 Sn( )SM(deleted)ES()436 1 TN()EA()BN}if +3 NH le{437(16.1.15\240\240)3 C(14.1.15)WB 116 Sn( )SM(bulk)ES()437 1 TN()EA()BN}if +2 NH le{438(16.2\240\240)2 C(14.2)WB 117 Sn( View Type Pragmas)438 1 TN()EA()BN}if +3 NH le{439(16.2.1\240\240)3 C(14.2.1)WB 118 Sn( )SM(object)ES()439 1 TN()EA()BN}if +3 NH le{440(16.2.2\240\240)3 C(14.2.2)WB 119 Sn( )SM(table)ES()440 1 TN()EA()BN}if +3 NH le{441(16.2.3\240\240)3 C(14.2.3)WB 120 Sn( )SM(query)ES()441 1 TN()EA()BN}if +3 NH le{442(16.2.4\240\240)3 C(14.2.4)WB 121 Sn( )SM(pointer)ES()442 1 TN()EA()BN}if +3 NH le{443(16.2.5\240\240)3 C(14.2.5)WB 122 Sn( )SM(call)HY(back)YH()ES()443 1 TN()EA()BN}if +3 NH le{444(16.2.6\240\240)3 C(14.2.6)WB 123 Sn( )SM(defi)HY(ni)HY(tion)YH()ES()444 1 TN()EA()BN}if +3 NH le{445(16.2.7\240\240)3 C(14.2.7)WB 124 Sn( )SM(tran)HY(sient)YH()ES()445 1 TN()EA()BN}if +2 NH le{446(16.3\240\240)2 C(14.3)WB 125 Sn( Value Type Pragmas)446 1 TN()EA()BN}if +3 NH le{447(16.3.1\240\240)3 C(14.3.1)WB 126 Sn( )SM(type)ES()447 1 TN()EA()BN}if +3 NH le{448(16.3.2\240\240)3 C(14.3.2)WB 127 Sn( )SM(id_type)ES()448 1 TN()EA()BN}if +3 NH le{449(16.3.3\240\240)3 C(14.3.3)WB 128 Sn( )SM(null)ES(/)SM(not_null)ES()449 1 TN()EA()BN}if +3 NH le{450(16.3.4\240\240)3 C(14.3.4)WB 129 Sn( )SM(default)ES()450 1 TN()EA()BN}if +3 NH le{451(16.3.5\240\240)3 C(14.3.5)WB 130 Sn( )SM(options)ES()451 1 TN()EA()BN}if +3 NH le{452(16.3.6\240\240)3 C(14.3.6)WB 131 Sn( )SM(read)HY(only)YH()ES()452 1 TN()EA()BN}if +3 NH le{453(16.3.7\240\240)3 C(14.3.7)WB 132 Sn( )SM(defi)HY(ni)HY(tion)YH()ES()453 1 TN()EA()BN}if +3 NH le{454(16.3.8\240\240)3 C(14.3.8)WB 133 Sn( )SM(tran)HY(sient)YH()ES()454 1 TN()EA()BN}if +3 NH le{455(16.3.9\240\240)3 C(14.3.9)WB 134 Sn( )SM(unordered)ES()455 1 TN()EA()BN}if +3 NH le{456(16.3.10\240\240)3 C(14.3.10)WB 135 Sn( )SM(index_type)ES()456 1 TN()EA()BN}if +3 NH le{457(16.3.11\240\240)3 C(14.3.11)WB 136 Sn( )SM(key_type)ES()457 1 TN()EA()BN}if +3 NH le{458(16.3.12\240\240)3 C(14.3.12)WB 137 Sn( )SM(value_type)ES()458 1 TN()EA()BN}if +3 NH le{459(16.3.13\240\240)3 C(14.3.13)WB 138 Sn( )SM(value_null)ES(/)SM(value_not_null)ES()459 1 TN()EA()BN}if +3 NH le{460(16.3.14\240\240)3 C(14.3.14)WB 139 Sn( )SM(id_options)ES()460 1 TN()EA()BN}if +3 NH le{461(16.3.15\240\240)3 C(14.3.15)WB 140 Sn( )SM(index_options)ES()461 1 TN()EA()BN}if +3 NH le{462(16.3.16\240\240)3 C(14.3.16)WB 141 Sn( )SM(key_options)ES()462 1 TN()EA()BN}if +3 NH le{463(16.3.17\240\240)3 C(14.3.17)WB 142 Sn( )SM(value_options)ES()463 1 TN()EA()BN}if +3 NH le{464(16.3.18\240\240)3 C(14.3.18)WB 143 Sn( )SM(id_column)ES()464 1 TN()EA()BN}if +3 NH le{465(16.3.19\240\240)3 C(14.3.19)WB 144 Sn( )SM(index_column)ES()465 1 TN()EA()BN}if +3 NH le{466(16.3.20\240\240)3 C(14.3.20)WB 145 Sn( )SM(key_column)ES()466 1 TN()EA()BN}if +3 NH le{467(16.3.21\240\240)3 C(14.3.21)WB 146 Sn( )SM(value_column)ES()467 1 TN()EA()BN}if +2 NH le{468(16.4\240\240)2 C(14.4)WB 147 Sn( Data Member Pragmas)468 1 TN()EA()BN}if +3 NH le{469(16.4.1\240\240)3 C(14.4.1)WB 148 Sn( )SM(id)ES()469 1 TN()EA()BN}if +3 NH le{470(16.4.2\240\240)3 C(14.4.2)WB 149 Sn( )SM(auto)ES()470 1 TN()EA()BN}if +3 NH le{471(16.4.3\240\240)3 C(14.4.3)WB 150 Sn( )SM(type)ES()471 1 TN()EA()BN}if +3 NH le{472(16.4.4\240\240)3 C(14.4.4)WB 151 Sn( )SM(id_type)ES()472 1 TN()EA()BN}if +3 NH le{473(16.4.5\240\240)3 C(14.4.5)WB 152 Sn( )SM(get)ES(/)SM(set)ES(/)SM(access)ES()473 1 TN()EA()BN}if +3 NH le{474(16.4.6\240\240)3 C(14.4.6)WB 153 Sn( )SM(null)ES(/)SM(not_null)ES()474 1 TN()EA()BN}if +3 NH le{475(16.4.7\240\240)3 C(14.4.7)WB 154 Sn( )SM(default)ES()475 1 TN()EA()BN}if +3 NH le{476(16.4.8\240\240)3 C(14.4.8)WB 155 Sn( )SM(options)ES()476 1 TN()EA()BN}if +3 NH le{477(16.4.9\240\240)3 C(14.4.9)WB 156 Sn( )SM(column)ES( \201object, compos)HY(ite)YH( value\202)477 1 TN()EA()BN}if +3 NH le{478(16.4.10\240\240)3 C(14.4.10)WB 157 Sn( )SM(column)ES( \201view\202)478 1 TN()EA()BN}if +3 NH le{479(16.4.11\240\240)3 C(14.4.11)WB 158 Sn( )SM(tran)HY(sient)YH()ES()479 1 TN()EA()BN}if +3 NH le{480(16.4.12\240\240)3 C(14.4.12)WB 159 Sn( )SM(read)HY(only)YH()ES()480 1 TN()EA()BN}if +3 NH le{481(16.4.13\240\240)3 C(14.4.13)WB 160 Sn( )SM(virtual)ES()481 1 TN()EA()BN}if +3 NH le{482(16.4.14\240\240)3 C(14.4.14)WB 161 Sn( )SM(inverse)ES()482 1 TN()EA()BN}if +3 NH le{483(16.4.15\240\240)3 C(14.4.15)WB 162 Sn( )SM(on_delete)ES()483 1 TN()EA()BN}if +3 NH le{484(16.4.16\240\240)3 C(14.4.16)WB 163 Sn( )SM(version)ES()484 1 TN()EA()BN}if +3 NH le{485(16.4.17\240\240)3 C(14.4.17)WB 164 Sn( )SM(index)ES()485 1 TN()EA()BN}if +3 NH le{486(16.4.18\240\240)3 C(14.4.18)WB 165 Sn( )SM(unique)ES()486 1 TN()EA()BN}if +3 NH le{487(16.4.19\240\240)3 C(14.4.19)WB 166 Sn( )SM(unordered)ES()487 1 TN()EA()BN}if +3 NH le{488(16.4.20\240\240)3 C(14.4.20)WB 167 Sn( )SM(table)ES()488 1 TN()EA()BN}if +3 NH le{489(16.4.21\240\240)3 C(14.4.21)WB 168 Sn( )SM(load)ES(/)SM(update)ES()489 1 TN()EA()BN}if +3 NH le{490(16.4.22\240\240)3 C(14.4.22)WB 169 Sn( )SM(section)ES()490 1 TN()EA()BN}if +3 NH le{491(16.4.23\240\240)3 C(14.4.23)WB 170 Sn( )SM(added)ES()491 1 TN()EA()BN}if +3 NH le{492(16.4.24\240\240)3 C(14.4.24)WB 171 Sn( )SM(deleted)ES()492 1 TN()EA()BN}if +3 NH le{493(16.4.25\240\240)3 C(14.4.25)WB 172 Sn( )SM(index_type)ES()493 1 TN()EA()BN}if +3 NH le{494(16.4.26\240\240)3 C(14.4.26)WB 173 Sn( )SM(key_type)ES()494 1 TN()EA()BN}if +3 NH le{495(16.4.27\240\240)3 C(14.4.27)WB 174 Sn( )SM(value_type)ES()495 1 TN()EA()BN}if +3 NH le{496(16.4.28\240\240)3 C(14.4.28)WB 175 Sn( )SM(value_null)ES(/)SM(value_not_null)ES()496 1 TN()EA()BN}if +3 NH le{497(16.4.29\240\240)3 C(14.4.29)WB 176 Sn( )SM(id_options)ES()497 1 TN()EA()BN}if +3 NH le{498(16.4.30\240\240)3 C(14.4.30)WB 177 Sn( )SM(index_options)ES()498 1 TN()EA()BN}if +3 NH le{499(16.4.31\240\240)3 C(14.4.31)WB 178 Sn( )SM(key_options)ES()499 1 TN()EA()BN}if +3 NH le{500(16.4.32\240\240)3 C(14.4.32)WB 179 Sn( )SM(value_options)ES()500 1 TN()EA()BN}if +3 NH le{501(16.4.33\240\240)3 C(14.4.33)WB 180 Sn( )SM(id_column)ES()501 1 TN()EA()BN}if +3 NH le{502(16.4.34\240\240)3 C(14.4.34)WB 181 Sn( )SM(index_column)ES()502 1 TN()EA()BN}if +3 NH le{503(16.4.35\240\240)3 C(14.4.35)WB 182 Sn( )SM(key_column)ES()503 1 TN()EA()BN}if +3 NH le{504(16.4.36\240\240)3 C(14.4.36)WB 183 Sn( )SM(value_column)ES()504 1 TN()EA()BN}if +2 NH le{505(16.5\240\240)2 C(14.5)WB 184 Sn( Names)HY(pace)YH( Pragmas)505 1 TN()EA()BN}if +3 NH le{506(16.5.1\240\240)3 C(14.5.1)WB 185 Sn( )SM(pointer)ES()506 1 TN()EA()BN}if +3 NH le{507(16.5.2\240\240)3 C(14.5.2)WB 186 Sn( )SM(table)ES()507 1 TN()EA()BN}if +3 NH le{508(16.5.3\240\240)3 C(14.5.3)WB 187 Sn( )SM(schema)ES()508 1 TN()EA()BN}if +3 NH le{509(16.5.4\240\240)3 C(14.5.4)WB 188 Sn( )SM(session)ES()509 1 TN()EA()BN}if +2 NH le{510(16.6\240\240)2 C(14.6)WB 189 Sn( Object Model Pragmas)510 1 TN()EA()BN}if +3 NH le{511(16.6.1\240\240)3 C(14.6.1)WB 190 Sn( )SM(version)ES()511 1 TN()EA()BN}if +2 NH le{512(16.7\240\240)2 C(14.7)WB 191 Sn( Index Defi)HY(ni)HY(tion)YH( Pragmas)512 1 TN()EA()BN}if +2 NH le{513(16.8\240\240)2 C(14.8)WB 192 Sn( Database Type Mapping Pragmas)513 1 TN()EA()BN}if +2 NH le{514(16.9\240\240)2 C(14.9)WB 193 Sn( C++ Compiler Warn)HY(ings)YH()514 1 TN()EA()BN}if +3 NH le{515(16.9.1\240\240)3 C(14.9.1)WB 194 Sn( GNU C++)515 1 TN()EA()BN}if +3 NH le{516(16.9.2\240\240)3 C(14.9.2)WB 195 Sn( Visual C++)516 1 TN()EA()BN}if +3 NH le{517(16.9.3\240\240)3 C(14.9.3)WB 196 Sn( Sun C++)517 1 TN()EA()BN}if +3 NH le{518(16.9.4\240\240)3 C(14.9.4)WB 197 Sn( IBM XL C++)518 1 TN()EA()BN}if +3 NH le{519(16.9.5\240\240)3 C(14.9.5)WB 198 Sn( HP aC++)519 1 TN()EA()BN}if +3 NH le{520(16.9.6\240\240)3 C(14.9.6)WB 199 Sn( Clang)520 1 TN()EA()BN}if +1 NH le{521(17\240\240)1 C(15)WB 200 Sn( Advanced Tech)HY(niques)YH( and Mech)HY(a)HY(nisms)YH()521 1 TN()EA()BN}if +2 NH le{522(17.1\240\240)2 C(15.1)WB 201 Sn( Trans)HY(ac)HY(tion)YH( Call)HY(backs)YH()522 1 TN()EA()BN}if +2 NH le{523(17.2\240\240)2 C(15.2)WB 202 Sn( Persis)HY(tent)YH( Class Template Instan)HY(ti)HY(a)HY(tions)YH()523 1 TN()EA()BN}if +2 NH le{524(17.3\240\240)2 C(15.3)WB 203 Sn( Bulk Database Oper)HY(a)HY(tions)YH()524 1 TN()EA()BN}if +1 NH le{525(18\240\240)1 C(PART)WB 204 Sn( II\240\240 + DATABASE SYSTEMS)525 1 TN()EA()BN}if +1 NH le{526(19\240\240)1 C(16)WB 205 Sn( Multi-Database Support)526 1 TN()EA()BN}if +2 NH le{527(19.1\240\240)2 C(16.1)WB 206 Sn( Static Multi-Database Support)527 1 TN()EA()BN}if +2 NH le{528(19.2\240\240)2 C(16.2)WB 207 Sn( Dynamic Multi-Database Support)528 1 TN()EA()BN}if +3 NH le{529(19.2.1\240\240)3 C(16.2.2)WB 208 Sn( Dynamic Loading of Database Support Code)529 1 TN()EA()BN}if +1 NH le{530(20\240\240)1 C(17)WB 209 Sn( MySQL Database)530 1 TN()EA()BN}if +2 NH le{531(20.1\240\240)2 C(17.1)WB 210 Sn( MySQL Type Mapping)531 1 TN()EA()BN}if +3 NH le{532(20.1.1\240\240)3 C(17.1.1)WB 212 Sn( String Type Mapping)532 1 TN()EA()BN}if +3 NH le{533(20.1.2\240\240)3 C(17.1.2)WB 213 Sn( Binary Type Mapping)533 1 TN()EA()BN}if +2 NH le{534(20.2\240\240)2 C(17.2)WB 214 Sn( MySQL Database Class)534 1 TN()EA()BN}if +2 NH le{535(20.3\240\240)2 C(17.3)WB 215 Sn( MySQL Connec)HY(tion)YH( and Connec)HY(tion)YH( Factory)535 1 TN()EA()BN}if +2 NH le{536(20.4\240\240)2 C(17.4)WB 216 Sn( MySQL Excep)HY(tions)YH()536 1 TN()EA()BN}if +2 NH le{537(20.5\240\240)2 C(17.5)WB 217 Sn( MySQL Limi)HY(ta)HY(tions)YH()537 1 TN()EA()BN}if +3 NH le{538(20.5.1\240\240)3 C(17.5.1)WB 218 Sn( Foreign Key Constraints)538 1 TN()EA()BN}if +2 NH le{539(20.6\240\240)2 C(17.6)WB 219 Sn( MySQL Index Defi)HY(ni)HY(tions)YH()539 1 TN()EA()BN}if +2 NH le{540(20.7\240\240)2 C(17.7)WB 220 Sn( MySQL Stored Proce)HY(dures)YH()540 1 TN()EA()BN}if +1 NH le{541(21\240\240)1 C(18)WB 221 Sn( SQLite Database)541 1 TN()EA()BN}if +2 NH le{542(21.1\240\240)2 C(18.1)WB 222 Sn( SQLite Type Mapping)542 1 TN()EA()BN}if +3 NH le{543(21.1.1\240\240)3 C(18.1.1)WB 223 Sn( String Type Mapping)543 1 TN()EA()BN}if +3 NH le{544(21.1.2\240\240)3 C(18.1.2)WB 224 Sn( Binary Type Mapping)544 1 TN()EA()BN}if +2 NH le{545(21.2\240\240)2 C(18.2)WB 225 Sn( SQLite Database Class)545 1 TN()EA()BN}if +2 NH le{546(21.3\240\240)2 C(18.3)WB 226 Sn( SQLite Connec)HY(tion)YH( and Connec)HY(tion)YH( Factory)546 1 TN()EA()BN}if +2 NH le{547(21.4\240\240)2 C(18.4)WB 227 Sn( SQLite Excep)HY(tions)YH()547 1 TN()EA()BN}if +2 NH le{548(21.5\240\240)2 C(18.5)WB 228 Sn( SQLite Limi)HY(ta)HY(tions)YH()548 1 TN()EA()BN}if +3 NH le{549(21.5.1\240\240)3 C(18.5.1)WB 229 Sn( Query Result Caching)549 1 TN()EA()BN}if +3 NH le{550(21.5.2\240\240)3 C(18.5.2)WB 230 Sn( Auto)HY(matic)YH( Assign)HY(ment)YH( of Object Ids)550 1 TN()EA()BN}if +3 NH le{551(21.5.3\240\240)3 C(18.5.3)WB 231 Sn( Foreign Key Constraints)551 1 TN()EA()BN}if +3 NH le{552(21.5.4\240\240)3 C(18.5.4)WB 232 Sn( Constraint Viola)HY(tions)YH()552 1 TN()EA()BN}if +3 NH le{553(21.5.5\240\240)3 C(18.5.5)WB 233 Sn( Sharing of Queries)553 1 TN()EA()BN}if +3 NH le{554(21.5.6\240\240)3 C(18.5.6)WB 234 Sn( Forced Roll)HY(back)YH()554 1 TN()EA()BN}if +3 NH le{555(21.5.7\240\240)3 C(18.5.7)WB 235 Sn( Database Schema Evolu)HY(tion)YH()555 1 TN()EA()BN}if +2 NH le{556(21.6\240\240)2 C(18.6)WB 236 Sn( SQLite Index Defi)HY(ni)HY(tions)YH()556 1 TN()EA()BN}if +1 NH le{557(22\240\240)1 C(19)WB 237 Sn( Post)HY(greSQL)YH( Database)557 1 TN()EA()BN}if +2 NH le{558(22.1\240\240)2 C(19.1)WB 238 Sn( Post)HY(greSQL)YH( Type Mapping)558 1 TN()EA()BN}if +3 NH le{559(22.1.1\240\240)3 C(19.1.1)WB 239 Sn( String Type Mapping)559 1 TN()EA()BN}if +3 NH le{560(22.1.2\240\240)3 C(19.1.2)WB 240 Sn( Binary Type and )SM(UUID)ES( Mapping)560 1 TN()EA()BN}if +2 NH le{561(22.2\240\240)2 C(19.2)WB 241 Sn( Post)HY(greSQL)YH( Database Class)561 1 TN()EA()BN}if +2 NH le{562(22.3\240\240)2 C(19.3)WB 242 Sn( Post)HY(greSQL)YH( Connec)HY(tion)YH( and Connec)HY(tion)YH( Factory)562 1 TN()EA()BN}if +2 NH le{563(22.4\240\240)2 C(19.4)WB 243 Sn( Post)HY(greSQL)YH( Excep)HY(tions)YH()563 1 TN()EA()BN}if +2 NH le{564(22.5\240\240)2 C(19.5)WB 244 Sn( Post)HY(greSQL)YH( Limi)HY(ta)HY(tions)YH()564 1 TN()EA()BN}if +3 NH le{565(22.5.1\240\240)3 C(19.5.1)WB 245 Sn( Query Result Caching)565 1 TN()EA()BN}if +3 NH le{566(22.5.2\240\240)3 C(19.5.2)WB 246 Sn( Foreign Key Constraints)566 1 TN()EA()BN}if +3 NH le{567(22.5.3\240\240)3 C(19.5.3)WB 247 Sn( Unique Constraint Viola)HY(tions)YH()567 1 TN()EA()BN}if +3 NH le{568(22.5.4\240\240)3 C(19.5.4)WB 248 Sn( Date-Time Format)568 1 TN()EA()BN}if +3 NH le{569(22.5.5\240\240)3 C(19.5.5)WB 249 Sn( Time)HY(zones)YH()569 1 TN()EA()BN}if +3 NH le{570(22.5.6\240\240)3 C(19.5.6)WB 250 Sn( )SM(NUMERIC)ES( Type Support)570 1 TN()EA()BN}if +2 NH le{571(22.6\240\240)2 C(19.6)WB 251 Sn( Post)HY(greSQL)YH( Index Defi)HY(ni)HY(tions)YH()571 1 TN()EA()BN}if +1 NH le{572(23\240\240)1 C(20)WB 252 Sn( Oracle Database)572 1 TN()EA()BN}if +2 NH le{573(23.1\240\240)2 C(20.1)WB 253 Sn( Oracle Type Mapping)573 1 TN()EA()BN}if +3 NH le{574(23.1.1\240\240)3 C(20.1.1)WB 254 Sn( String Type Mapping)574 1 TN()EA()BN}if +3 NH le{575(23.1.2\240\240)3 C(20.1.2)WB 255 Sn( Binary Type Mapping)575 1 TN()EA()BN}if +2 NH le{576(23.2\240\240)2 C(20.2)WB 256 Sn( Oracle Database Class)576 1 TN()EA()BN}if +2 NH le{577(23.3\240\240)2 C(20.3)WB 257 Sn( Oracle Connec)HY(tion)YH( and Connec)HY(tion)YH( Factory)577 1 TN()EA()BN}if +2 NH le{578(23.4\240\240)2 C(20.4)WB 258 Sn( Oracle Excep)HY(tions)YH()578 1 TN()EA()BN}if +2 NH le{579(23.5\240\240)2 C(20.5)WB 259 Sn( Oracle Limi)HY(ta)HY(tions)YH()579 1 TN()EA()BN}if +3 NH le{580(23.5.1\240\240)3 C(20.5.1)WB 260 Sn( Iden)HY(ti)HY(fier)YH( Trun)HY(ca)HY(tion)YH()580 1 TN()EA()BN}if +3 NH le{581(23.5.2\240\240)3 C(20.5.2)WB 261 Sn( Query Result Caching)581 1 TN()EA()BN}if +3 NH le{582(23.5.3\240\240)3 C(20.5.3)WB 262 Sn( Foreign Key Constraints)582 1 TN()EA()BN}if +3 NH le{583(23.5.4\240\240)3 C(20.5.4)WB 263 Sn( Unique Constraint Viola)HY(tions)YH()583 1 TN()EA()BN}if +3 NH le{584(23.5.5\240\240)3 C(20.5.5)WB 264 Sn( Large )SM(FLOAT)ES( and + )SM(NUMBER)ES( Types)584 1 TN()EA()BN}if +3 NH le{585(23.5.6\240\240)3 C(20.5.6)WB 265 Sn( Time)HY(zones)YH()585 1 TN()EA()BN}if +3 NH le{586(23.5.7\240\240)3 C(20.5.7)WB 266 Sn( )SM(LONG)ES( Types)586 1 TN()EA()BN}if +3 NH le{587(23.5.8\240\240)3 C(20.5.8)WB 267 Sn( LOB Types and By-Value Acces)HY(sors)YH(/Modi)HY(fiers)YH()587 1 TN()EA()BN}if +3 NH le{588(23.5.9\240\240)3 C(20.5.9)WB 268 Sn( Database Schema Evolu)HY(tion)YH()588 1 TN()EA()BN}if +2 NH le{589(23.6\240\240)2 C(20.6)WB 269 Sn( Oracle Index Defi)HY(ni)HY(tions)YH()589 1 TN()EA()BN}if +1 NH le{590(24\240\240)1 C(21)WB 270 Sn( Microsoft SQL Server Database)590 1 TN()EA()BN}if +2 NH le{591(24.1\240\240)2 C(21.1)WB 271 Sn( SQL Server Type Mapping)591 1 TN()EA()BN}if +3 NH le{592(24.1.1\240\240)3 C(21.1.1)WB 272 Sn( String Type Mapping)592 1 TN()EA()BN}if +3 NH le{593(24.1.2\240\240)3 C(21.1.2)WB 273 Sn( Binary Type and )SM(UNIQUEI)HY(DEN)HY(TI)HY(FIER)YH()ES( Mapping)593 1 TN()EA()BN}if +3 NH le{594(24.1.3\240\240)3 C(21.1.3)WB 274 Sn( )SM(ROWVER)HY(SION)YH()ES( Mapping)594 1 TN()EA()BN}if +3 NH le{595(24.1.4\240\240)3 C(21.1.4)WB 275 Sn( Long String and Binary Types)595 1 TN()EA()BN}if +2 NH le{596(24.2\240\240)2 C(21.2)WB 276 Sn( SQL Server Database Class)596 1 TN()EA()BN}if +2 NH le{597(24.3\240\240)2 C(21.3)WB 277 Sn( SQL Server Connec)HY(tion)YH( and Connec)HY(tion)YH( Factory)597 1 TN()EA()BN}if +2 NH le{598(24.4\240\240)2 C(21.4)WB 278 Sn( SQL Server Excep)HY(tions)YH()598 1 TN()EA()BN}if +2 NH le{599(24.5\240\240)2 C(21.5)WB 279 Sn( SQL Server Limi)HY(ta)HY(tions)YH()599 1 TN()EA()BN}if +3 NH le{600(24.5.1\240\240)3 C(21.5.1)WB 280 Sn( Query Result Caching)600 1 TN()EA()BN}if +3 NH le{601(24.5.2\240\240)3 C(21.5.2)WB 281 Sn( Foreign Key Constraints)601 1 TN()EA()BN}if +3 NH le{602(24.5.3\240\240)3 C(21.5.3)WB 282 Sn( Unique Constraint Viola)HY(tions)YH()602 1 TN()EA()BN}if +3 NH le{603(24.5.4\240\240)3 C(21.5.4)WB 283 Sn( Multi-threaded Windows Appli)HY(ca)HY(tions)YH()603 1 TN()EA()BN}if +3 NH le{604(24.5.5\240\240)3 C(21.5.5)WB 284 Sn( Affected Row Count and DDL State)HY(ments)YH()604 1 TN()EA()BN}if +3 NH le{605(24.5.6\240\240)3 C(21.5.6)WB 285 Sn( Long Data and Auto Object Ids, )SM(ROWVER)HY(SION)YH()ES()605 1 TN()EA()BN}if +3 NH le{606(24.5.7\240\240)3 C(21.5.7)WB 286 Sn( Long Data and By-Value Acces)HY(sors)YH(/Modi)HY(fiers)YH()606 1 TN()EA()BN}if +3 NH le{607(24.5.8\240\240)3 C(21.5.8)WB 287 Sn( Bulk Update and )SM(ROWVER)HY(SION)YH()ES()607 1 TN()EA()BN}if +2 NH le{608(24.6\240\240)2 C(21.6)WB 288 Sn( SQL Server Index Defi)HY(ni)HY(tions)YH()608 1 TN()EA()BN}if +2 NH le{609(24.7\240\240)2 C(21.7)WB 289 Sn( SQL Server Stored Proce)HY(dures)YH()609 1 TN()EA()BN}if +1 NH le{610(25\240\240)1 C(PART)WB 290 Sn( III\240\240 + PROFILES)610 1 TN()EA()BN}if +1 NH le{611(26\240\240)1 C(22)WB 291 Sn( Profiles Intro)HY(duc)HY(tion)YH()611 1 TN()EA()BN}if +1 NH le{612(27\240\240)1 C(23)WB 292 Sn( Boost Profile)612 1 TN()EA()BN}if +2 NH le{613(27.1\240\240)2 C(23.1)WB 293 Sn( Smart Point)HY(ers)YH( Library)613 1 TN()EA()BN}if +2 NH le{614(27.2\240\240)2 C(23.2)WB 294 Sn( Unordered Contain)HY(ers)YH( Library)614 1 TN()EA()BN}if +2 NH le{615(27.3\240\240)2 C(23.3)WB 295 Sn( Multi-Index Container Library)615 1 TN()EA()BN}if +2 NH le{616(27.4\240\240)2 C(23.4)WB 296 Sn( Optional Library)616 1 TN()EA()BN}if +2 NH le{617(27.5\240\240)2 C(23.5)WB 297 Sn( Date Time Library)617 1 TN()EA()BN}if +3 NH le{618(27.5.1\240\240)3 C(23.5.1)WB 298 Sn( MySQL Database Type Mapping)618 1 TN()EA()BN}if +3 NH le{619(27.5.2\240\240)3 C(23.5.2)WB 299 Sn( SQLite Database Type Mapping)619 1 TN()EA()BN}if +3 NH le{620(27.5.3\240\240)3 C(23.5.3)WB 300 Sn( Post)HY(greSQL)YH( Database Type Mapping)620 1 TN()EA()BN}if +3 NH le{621(27.5.4\240\240)3 C(23.5.4)WB 301 Sn( Oracle Database Type Mapping)621 1 TN()EA()BN}if +3 NH le{622(27.5.5\240\240)3 C(23.5.5)WB 302 Sn( SQL Server Database Type Mapping)622 1 TN()EA()BN}if +2 NH le{623(27.6\240\240)2 C(23.6)WB 303 Sn( Uuid Library)623 1 TN()EA()BN}if +3 NH le{624(27.6.1\240\240)3 C(23.6.1)WB 304 Sn( MySQL Database Type Mapping)624 1 TN()EA()BN}if +3 NH le{625(27.6.2\240\240)3 C(23.6.2)WB 305 Sn( SQLite Database Type Mapping)625 1 TN()EA()BN}if +3 NH le{626(27.6.3\240\240)3 C(23.6.3)WB 306 Sn( Post)HY(greSQL)YH( Database Type Mapping)626 1 TN()EA()BN}if +3 NH le{627(27.6.4\240\240)3 C(23.6.4)WB 307 Sn( Oracle Database Type Mapping)627 1 TN()EA()BN}if +3 NH le{628(27.6.5\240\240)3 C(23.6.5)WB 308 Sn( SQL Server Database Type Mapping)628 1 TN()EA()BN}if +1 NH le{629(28\240\240)1 C(24)WB 309 Sn( Qt Profile)629 1 TN()EA()BN}if +2 NH le{630(28.1\240\240)2 C(24.1)WB 310 Sn( Basic Types Library)630 1 TN()EA()BN}if +3 NH le{631(28.1.1\240\240)3 C(24.1.1)WB 311 Sn( MySQL Database Type Mapping)631 1 TN()EA()BN}if +3 NH le{632(28.1.2\240\240)3 C(24.1.2)WB 312 Sn( SQLite Database Type Mapping)632 1 TN()EA()BN}if +3 NH le{633(28.1.3\240\240)3 C(24.1.3)WB 313 Sn( Post)HY(greSQL)YH( Database Type Mapping)633 1 TN()EA()BN}if +3 NH le{634(28.1.4\240\240)3 C(24.1.4)WB 314 Sn( Oracle Database Type Mapping)634 1 TN()EA()BN}if +3 NH le{635(28.1.5\240\240)3 C(24.1.5)WB 315 Sn( SQL Server Database Type Mapping)635 1 TN()EA()BN}if +2 NH le{636(28.2\240\240)2 C(24.2)WB 316 Sn( Smart Point)HY(ers)YH( Library)636 1 TN()EA()BN}if +2 NH le{637(28.3\240\240)2 C(24.3)WB 317 Sn( Contain)HY(ers)YH( Library)637 1 TN()EA()BN}if +3 NH le{638(28.3.1\240\240)3 C(24.3.1)WB 318 Sn( Change-Track)HY(ing)YH( )SM(QList)ES()638 1 TN()EA()BN}if +2 NH le{639(28.4\240\240)2 C(24.4)WB 319 Sn( Date Time Library)639 1 TN()EA()BN}if +3 NH le{640(28.4.1\240\240)3 C(24.4.1)WB 320 Sn( MySQL Database Type Mapping)640 1 TN()EA()BN}if +3 NH le{641(28.4.2\240\240)3 C(24.4.2)WB 321 Sn( SQLite Database Type Mapping)641 1 TN()EA()BN}if +3 NH le{642(28.4.3\240\240)3 C(24.4.3)WB 322 Sn( Post)HY(greSQL)YH( Database Type Mapping)642 1 TN()EA()BN}if +3 NH le{643(28.4.4\240\240)3 C(24.4.4)WB 323 Sn( Oracle Database Type Mapping)643 1 TN()EA()BN}if +3 NH le{644(28.4.5\240\240)3 C(24.4.5)WB 324 Sn( SQL Server Database Type Mapping)644 1 TN()EA()BN}if +/OU t D /Cb Db D NP Ep ET +/Cb Db D /Ct [16#00 16#00 16#00] D /Cl [16#00 16#00 16#00] D /CL -1 D Ct Sc + +/Ba f D /BO 0 D Bs +/UR (/home/boris/work/odb/odb/doc/manual.xhtml) D +/Ti (C++ Object Persistence with ODB) D +/Au () D +/Df f D +/ME [(2.4)(2.4.0)] D + +NP RC ZF +()1 Sl()WB 0 Sn( + +)BR()WB 1 Sn( )BR()WB 2 Sn( + + + )WB NL NP( + )0 1 0 H(Preface)WB 325 Sn()WB 3 Sn()EA()EH( + + )0 P(As more crit)HY(i)HY(cal)YH( aspects of our lives become depen)HY(dant)YH( on soft)HY(ware)YH( + systems, more and more appli)HY(ca)HY(tions)YH( are required to save the data + they work on in persis)HY(tent)YH( and reli)HY(able)YH( storage. Database manage)HY(ment)YH( + systems and, in partic)HY(u)HY(lar)YH(, rela)HY(tional)YH( database manage)HY(ment)YH( systems + \201RDBMS\202 are commonly used for such storage. However, while the + appli)HY(ca)HY(tion)YH( devel)HY(op)HY(ment)YH( tech)HY(niques)YH( and program)HY(ming)YH( languages have + evolved signif)HY(i)HY(cantly)YH( over the past decades, the rela)HY(tional)YH( database + tech)HY(nol)HY(ogy)YH( in this area stayed rela)HY(tively)YH( unchanged. In partic)HY(u)HY(lar)YH(, + this led to the now infa)HY(mous)YH( mismatch between the object-oriented + model used by many modern appli)HY(ca)HY(tions)YH( and the rela)HY(tional)YH( model still + used by RDBMS.)EP( + + )0 P(While rela)HY(tional)YH( databases may be incon)HY(ve)HY(nient)YH( to use from modern + program)HY(ming)YH( languages, they are still the main choice for many + appli)HY(ca)HY(tions)YH( due to their matu)HY(rity)YH(, reli)HY(a)HY(bil)HY(ity)YH(, as well as the + avail)HY(abil)HY(ity)YH( of tools and alter)HY(na)HY(tive)YH( imple)HY(men)HY(ta)HY(tions)YH(.)EP( + + )0 P(To allow appli)HY(ca)HY(tion)YH( devel)HY(op)HY(ers)YH( to utilize rela)HY(tional)YH( databases + from their object-oriented appli)HY(ca)HY(tions)YH(, a tech)HY(nique)YH( called + object-rela)HY(tional)YH( mapping \201ORM\202 is often used. It involves a + conver)HY(sion)YH( layer that maps between objects in the appli)HY(ca)HY(tion)YH('s + memory and their rela)HY(tional)YH( repre)HY(sen)HY(ta)HY(tion)YH( in the database. While + the object-rela)HY(tional)YH( mapping code can be written manu)HY(ally)YH(, + auto)HY(mated)YH( ORM systems are avail)HY(able)YH( for most object-oriented + program)HY(ming)YH( languages in use today.)EP( + + )0 P(ODB is an ORM system for the C++ program)HY(ming)YH( language. It was + designed and imple)HY(mented)YH( with the follow)HY(ing)YH( main goals:)EP( + + )UL( )-1 LI(Provide a fully-auto)HY(matic)YH( ORM system. In partic)HY(u)HY(lar)YH(, the + appli)HY(ca)HY(tion)YH( devel)HY(oper)YH( should not have to manu)HY(ally)YH( write any + mapping code, neither for persis)HY(tent)YH( classes nor for their + data member. + + )-1 LI(Provide clean and easy to use object-oriented persis)HY(tence)YH( + model and database APIs that support the devel)HY(op)HY(ment)YH( of real)HY(is)HY(tic)YH( + appli)HY(ca)HY(tions)YH( for a wide variety of domains. + + )-1 LI(Provide a portable and thread-safe imple)HY(men)HY(ta)HY(tion)YH(. ODB should be + written in stan)HY(dard)YH( C++ and capable of persist)HY(ing)YH( any stan)HY(dard)YH( + C++ classes. + + )-1 LI(Provide profiles that inte)HY(grate)YH( ODB with type systems of + widely-used frame)HY(works)YH( and libraries such as Qt and Boost. + + )-1 LI(Provide a high-perfor)HY(mance)YH( and low over)HY(head)YH( imple)HY(men)HY(ta)HY(tion)YH(. ODB + should make effi)HY(cient)YH( use of database and appli)HY(ca)HY(tion)YH( resources. + + )LU( + + + )0 2 1 H(About)WB 326 Sn()WB 4 Sn( This Docu)HY(ment)YH()EA()EH( + + )0 P(The goal of this manual is to provide you with an under)HY(stand)HY(ing)YH( + of the object persis)HY(tence)YH( model and APIs which are imple)HY(mented)YH( by ODB. + As such, this docu)HY(ment)YH( is intended for C++ appli)HY(ca)HY(tion)YH( devel)HY(op)HY(ers)YH( and + soft)HY(ware)YH( archi)HY(tects)YH( who are looking for a C++ object persis)HY(tence)YH( + solu)HY(tion)YH(. Prior expe)HY(ri)HY(ence)YH( with C++ is required to under)HY(stand)YH( + this docu)HY(ment)YH(. A basic under)HY(stand)HY(ing)YH( of rela)HY(tional)YH( database systems + is advan)HY(ta)HY(geous)YH( but not expected or required.)EP( + + + )0 2 2 H(More)WB 327 Sn()WB 5 Sn( Infor)HY(ma)HY(tion)YH()EA()EH( + + )0 P(Beyond this manual, you may also find the follow)HY(ing)YH( sources of + infor)HY(ma)HY(tion)YH( useful:)EP( + + )UL( )-1 LI()R1 2 A(ODB + Compiler Command Line Manual.)EA( + + )-1 LI(The )SM(INSTALL)ES( files in the ODB source pack)HY(ages)YH( provide + build instruc)HY(tions)YH( for various plat)HY(forms)YH(. + + )-1 LI(The )SM(odb-exam)HY(ples)YH()ES( package contains a collec)HY(tion)YH( of + exam)HY(ples)YH( and a README file with an overview of each example. + + )-1 LI(The )R2 2 A(odb-users)EA( + mailing list is the place to ask tech)HY(ni)HY(cal)YH( ques)HY(tions)YH( about ODB. + Further)HY(more)YH(, the search)HY(able)YH( + )R3 2 A(archives)EA( + may already have answers to some of your ques)HY(tions)YH(. + + )LU( + + + + + + )WB NL NP( + )0 1 3 H(PART)WB 328 Sn()WB 6 Sn( I\240\240 + OBJECT-RELA)HY(TIONAL)YH( MAPPING)EA()EH( + + )0 P(Part I describes the essen)HY(tial)YH( database concepts, APIs, and tools that + together comprise the object-rela)HY(tional)YH( mapping for C++ as imple)HY(mented)YH( + by ODB. It consists of the follow)HY(ing)YH( chap)HY(ters)YH(.)EP( + + )0 PT( + + + + + + )WB NL NP( + )0 1 4 H(1)WB 329 Sn()WB 7 Sn( Intro)HY(duc)HY(tion)YH()EA()EH( + + )0 P(ODB is an object-rela)HY(tional)YH( mapping \201ORM\202 system for C++. It provides + tools, APIs, and library support that allow you to persist C++ objects + to a rela)HY(tional)YH( database \201RDBMS\202 without having to deal with tables, + columns, or SQL and without manu)HY(ally)YH( writing any of the mapping code.)EP( + + )0 P(ODB is highly flex)HY(i)HY(ble)YH( and customiz)HY(able)YH(. It can either completely + hide the rela)HY(tional)YH( nature of the under)HY(ly)HY(ing)YH( database or expose + some of the details as required. For example, you can auto)HY(mat)HY(i)HY(cally)YH( + map basic C++ types to suit)HY(able)YH( SQL types, gener)HY(ate)YH( the rela)HY(tional)YH( + database schema for your persis)HY(tent)YH( classes, and use simple, safe, + and yet power)HY(ful)YH( object query language instead of SQL. Or you can + assign SQL types to indi)HY(vid)HY(ual)YH( data members, use the exist)HY(ing)YH( + database schema, run native SQL )SM(SELECT)ES( queries, and + call stored proce)HY(dures)YH(. In fact, at an extreme, ODB can be used + as )EM(just)ES( a conve)HY(nient)YH( way to handle results of native SQL + queries.)EP( + + )0 P(ODB is not a frame)HY(work)YH(. It does not dictate how you should write + your appli)HY(ca)HY(tion)YH(. Rather, it is designed to fit into your + style and archi)HY(tec)HY(ture)YH( by only handling object persis)HY(tence)YH( + and not inter)HY(fer)HY(ing)YH( with any other func)HY(tion)HY(al)HY(ity)YH(. There is + no common base type that all persis)HY(tent)YH( classes should derive + from nor are there any restric)HY(tions)YH( on the data member types + in persis)HY(tent)YH( classes. Exist)HY(ing)YH( classes can be made persis)HY(tent)YH( + with a few or no modi)HY(fi)HY(ca)HY(tions)YH(.)EP( + + )0 P(ODB has been designed for high perfor)HY(mance)YH( and low memory + over)HY(head)YH(. Prepared state)HY(ments)YH( are used to send and receive + object state in binary format instead of text which reduces + the load on the appli)HY(ca)HY(tion)YH( and the database server. Exten)HY(sive)YH( + caching of connec)HY(tions)YH(, prepared state)HY(ments)YH(, and buffers saves + time and resources on connec)HY(tion)YH( estab)HY(lish)HY(ment)YH(, state)HY(ment)YH( parsing, + and memory allo)HY(ca)HY(tions)YH(. For each supported database system the + native C API is used instead of ODBC or higher-level wrapper + APIs to reduce over)HY(head)YH( and provide the most effi)HY(cient)YH( imple)HY(men)HY(ta)HY(tion)YH( + for each database oper)HY(a)HY(tion)YH(. Finally, persis)HY(tent)YH( classes have + zero memory over)HY(head)YH(. There are no hidden "database" members + that each class must have nor are there per-object data struc)HY(tures)YH( + allo)HY(cated)YH( by ODB.)EP( + + )0 P(In this chapter we present a high-level overview of ODB. + We will start with the ODB archi)HY(tec)HY(ture)YH( and then outline the + work)HY(flow)YH( of build)HY(ing)YH( an appli)HY(ca)HY(tion)YH( that uses ODB. We will + then continue by contrast)HY(ing)YH( the draw)HY(backs)YH( of the tradi)HY(tional)YH( + way of saving C++ objects to rela)HY(tional)YH( databases with the + bene)HY(fits)YH( of using ODB for object persis)HY(tence)YH(. We conclude the + chapter by discussing the C++ stan)HY(dards)YH( supported by ODB. The + next chapter takes a more hands-on approach and shows the + concrete steps neces)HY(sary)YH( to imple)HY(ment)YH( object persis)HY(tence)YH( in + a simple "Hello World" appli)HY(ca)HY(tion)YH(.)EP( + + )0 2 5 H(1.1)WB 330 Sn()WB 8 Sn( Archi)HY(tec)HY(ture)YH( and Work)HY(flow)YH()EA()EH( + + )0 P(From the appli)HY(ca)HY(tion)YH( devel)HY(oper)YH('s perspec)HY(tive)YH(, ODB + consists of three main compo)HY(nents)YH(: the ODB compiler, the common + runtime library, called )SM(libodb)ES(, and the + database-specific runtime libraries, called + )SM(libodb-)ES(, where is + the name of the database system this runtime + is for, for example, )SM(libodb-mysql)ES(. For instance, + if the appli)HY(ca)HY(tion)YH( is going to use the MySQL database for + object persis)HY(tence)YH(, then the three ODB compo)HY(nents)YH( that this + appli)HY(ca)HY(tion)YH( will use are the ODB compiler, )SM(libodb)ES( + and )SM(libodb-mysql)ES(.)EP( + + )0 P(The ODB compiler gener)HY(ates)YH( the database support code for + persis)HY(tent)YH( classes in your appli)HY(ca)HY(tion)YH(. The input to the ODB + compiler is one or more C++ header files defin)HY(ing)YH( C++ classes + that you want to make persis)HY(tent)YH(. For each input header file + the ODB compiler gener)HY(ates)YH( a set of C++ source files imple)HY(ment)HY(ing)YH( + conver)HY(sion)YH( between persis)HY(tent)YH( C++ classes defined in this + header and their database repre)HY(sen)HY(ta)HY(tion)YH(. The ODB compiler + can also gener)HY(ate)YH( a database schema file that creates tables + neces)HY(sary)YH( to store the persis)HY(tent)YH( classes.)EP( + + )0 P(The ODB compiler is a real C++ compiler except that it produces + C++ instead of assem)HY(bly)YH( or machine code. In partic)HY(u)HY(lar)YH(, it is not + an ad-hoc header pre-proces)HY(sor)YH( that is only capable of recog)HY(niz)HY(ing)YH( + a subset of C++. ODB is capable of parsing any stan)HY(dard)YH( C++ code.)EP( + + )0 P(The common runtime library defines database system-inde)HY(pen)HY(dent)YH( + inter)HY(faces)YH( that your appli)HY(ca)HY(tion)YH( can use to manip)HY(u)HY(late)YH( persis)HY(tent)YH( + objects. The database-specific runtime library provides imple)HY(men)HY(ta)HY(tions)YH( + of these inter)HY(faces)YH( for a concrete database as well as other + database-specific util)HY(i)HY(ties)YH( that are used by the gener)HY(ated)YH( code. + Normally, the appli)HY(ca)HY(tion)YH( does not use the database-specific + runtime library directly but rather works with it via the common + inter)HY(faces)YH( from )SM(libodb)ES(. The follow)HY(ing)YH( diagram shows + the object persis)HY(tence)YH( archi)HY(tec)HY(ture)YH( of an appli)HY(ca)HY(tion)YH( that uses + MySQL as the under)HY(ly)HY(ing)YH( database system:)EP( + + + )2 Al()BR()0 0 IM()Ea()BR( + + )0 P(The ODB system also defines two special-purpose languages: + the ODB Pragma Language and ODB Query Language. The ODB Pragma + Language is used to commu)HY(ni)HY(cate)YH( various prop)HY(er)HY(ties)YH( of persis)HY(tent)YH( + classes to the ODB compiler by means of special )SM(#pragma)ES( + direc)HY(tives)YH( embed)HY(ded)YH( in the C++ header files. It controls aspects + of the object-rela)HY(tional)YH( mapping such as names of tables and columns + that are used for persis)HY(tent)YH( classes and their members or mapping between + C++ types and database types.)EP( + + )0 P(The ODB Query Language is an object-oriented database query + language that can be used to search for objects match)HY(ing)YH( + certain crite)HY(ria)YH(. It is modeled after and is inte)HY(grated)YH( into + C++ allow)HY(ing)YH( you to write expres)HY(sive)YH( and safe queries that look + and feel like ordi)HY(nary)YH( C++.)EP( + + )0 P(The use of the ODB compiler to gener)HY(ate)YH( database support code + adds an addi)HY(tional)YH( step to your appli)HY(ca)HY(tion)YH( build sequence. The + follow)HY(ing)YH( diagram outlines the typical build work)HY(flow)YH( of an + appli)HY(ca)HY(tion)YH( that uses ODB:)EP( + + + )2 Al()BR()0 1 IM()Ea()BR( + + )0 2 6 H(1.2)WB 331 Sn()WB 9 Sn( Bene)HY(fits)YH()EA()EH( + + )0 P(The tradi)HY(tional)YH( way of saving C++ objects to rela)HY(tional)YH( databases + requires that you manu)HY(ally)YH( write code which converts between the database + and C++ repre)HY(sen)HY(ta)HY(tions)YH( of each persis)HY(tent)YH( class. The actions that + such code usually performs include conver)HY(sion)YH( between C++ values and + strings or database types, prepa)HY(ra)HY(tion)YH( and execu)HY(tion)YH( of SQL queries, + as well as handling the result sets. Writing this code manu)HY(ally)YH( has + the follow)HY(ing)YH( draw)HY(backs)YH(:)EP( + + )UL( )-1 LI()BD(Diffi)HY(cult)YH( and time consum)HY(ing)YH(.)ES( Writing database conver)HY(sion)YH( + code for any non-trivial appli)HY(ca)HY(tion)YH( requires exten)HY(sive)YH( + knowl)HY(edge)YH( of the specific database system and its APIs. + It can also take a consid)HY(er)HY(able)YH( amount of time to write + and main)HY(tain)YH(. Support)HY(ing)YH( multi-threaded appli)HY(ca)HY(tions)YH( can + compli)HY(cate)YH( this task even further. + + )-1 LI()BD(Subop)HY(ti)HY(mal)YH( perfor)HY(mance)YH(.)ES( Optimal conver)HY(sion)YH( often + requires writing large amounts of extra code, such as + param)HY(e)HY(ter)YH( binding for prepared state)HY(ments)YH( and caching + of connec)HY(tions)YH(, state)HY(ments)YH(, and buffers. Writing code + like this in an ad-hoc manner is often too diffi)HY(cult)YH( + and time consum)HY(ing)YH(. + + )-1 LI()BD(Database vendor lock-in.)ES( The conver)HY(sion)YH( code is written for + a specific database which makes it hard to switch to another + database vendor. + + )-1 LI()BD(Lack of type safety.)ES( It is easy to misspell column names or + pass incom)HY(pat)HY(i)HY(ble)YH( values in SQL queries. Such errors will + only be detected at runtime. + + )-1 LI()BD(Compli)HY(cates)YH( the appli)HY(ca)HY(tion)YH(.)ES( The database conver)HY(sion)YH( code + often ends up inter)HY(spersed)YH( through)HY(out)YH( the appli)HY(ca)HY(tion)YH( making it + hard to debug, change, and main)HY(tain)YH(. + )LU( + + )0 P(In contrast, using ODB for C++ object persis)HY(tence)YH( has the + follow)HY(ing)YH( bene)HY(fits)YH(:)EP( + + )UL( )-1 LI()BD(Ease of use.)ES( ODB auto)HY(mat)HY(i)HY(cally)YH( gener)HY(ates)YH( database conver)HY(sion)YH( + code from your C++ class decla)HY(ra)HY(tions)YH( and allows you to manip)HY(u)HY(late)YH( + persis)HY(tent)YH( objects using simple and thread-safe object-oriented + database APIs. + + )-1 LI()BD(Concise code.)ES( With ODB hiding the details of the under)HY(ly)HY(ing)YH( + database, the appli)HY(ca)HY(tion)YH( logic is written using the natural object + vocab)HY(u)HY(lary)YH( instead of tables, columns and SQL. The result)HY(ing)YH( code + is simpler and thus easier to read and under)HY(stand)YH(. + + )-1 LI()BD(Optimal perfor)HY(mance)YH(.)ES( ODB has been designed for high perfor)HY(mance)YH( + and low memory over)HY(head)YH(. All the avail)HY(able)YH( opti)HY(miza)HY(tion)YH( tech)HY(niques)YH(, + such as prepared state)HY(ments)YH( and exten)HY(sive)YH( connec)HY(tion)YH(, state)HY(ment)YH(, + and buffer caching, are used to provide the most effi)HY(cient)YH( + imple)HY(men)HY(ta)HY(tion)YH( for each database oper)HY(a)HY(tion)YH(. + + )-1 LI()BD(Database porta)HY(bil)HY(ity)YH(.)ES( Because the database conver)HY(sion)YH( code + is auto)HY(mat)HY(i)HY(cally)YH( gener)HY(ated)YH(, it is easy to switch from one database + vendor to another. In fact, it is possi)HY(ble)YH( to test your appli)HY(ca)HY(tion)YH( + on several database systems before making a choice. + + )-1 LI()BD(Safety.)ES( The ODB object persis)HY(tence)YH( and query APIs are + stat)HY(i)HY(cally)YH( typed. You use C++ iden)HY(ti)HY(fiers)YH( instead of strings + to refer to object members and the gener)HY(ated)YH( code makes sure + database and C++ types are compat)HY(i)HY(ble)YH(. All this helps catch + program)HY(ming)YH( errors at compile-time rather than at runtime. + + )-1 LI()BD(Main)HY(tain)HY(abil)HY(ity)YH(.)ES( Auto)HY(matic)YH( code gener)HY(a)HY(tion)YH( mini)HY(mizes)YH( the + effort needed to adapt the appli)HY(ca)HY(tion)YH( to changes in persis)HY(tent)YH( + classes. The database support code is kept sepa)HY(rately)YH( from the + class decla)HY(ra)HY(tions)YH( and appli)HY(ca)HY(tion)YH( logic. This makes the + appli)HY(ca)HY(tion)YH( easier to debug and main)HY(tain)YH(. + )LU( + + )0 P(Overall, ODB provides an easy to use yet flex)HY(i)HY(ble)YH( and power)HY(ful)YH( + object-rela)HY(tional)YH( mapping \201ORM\202 system for C++. Unlike other + ORM imple)HY(men)HY(ta)HY(tions)YH( for C++ that still require you to write + database conver)HY(sion)YH( or member regis)HY(tra)HY(tion)YH( code for each + persis)HY(tent)YH( class, ODB keeps persis)HY(tent)YH( classes purely + declar)HY(a)HY(tive)YH(. The func)HY(tional)YH( part, the database conver)HY(sion)YH( + code, is auto)HY(mat)HY(i)HY(cally)YH( gener)HY(ated)YH( by the ODB compiler from + these decla)HY(ra)HY(tions)YH(.)EP( + + )0 2 7 H(1.3)WB 332 Sn()WB 10 Sn( Supported C++ Stan)HY(dards)YH()EA()EH( + + )0 P(ODB provides support for ISO/IEC C++ 1998/2003 \201C++98/03\202, + ISO/IEC TR 19768 C++ Library Exten)HY(sions)YH( \201C++ TR1\202, and + ISO/IEC C++ 2011 \201C++11\202. While the major)HY(ity)YH( of the exam)HY(ples)YH( in + this manual use C++98/03, support for the new func)HY(tion)HY(al)HY(ity)YH( and + library compo)HY(nents)YH( intro)HY(duced)YH( in TR1 and C++11 are discussed + through)HY(out)YH( the docu)HY(ment)YH(. The )SM(c++11)ES( example in the + )SM(odb-exam)HY(ples)YH()ES( package also shows ODB support for + various C++11 features.)EP( + + + + + )WB NL NP( + )0 1 8 H(2)WB 333 Sn()WB 11 Sn( Hello World Example)EA()EH( + + )0 P(In this chapter we will show how to create a simple C++ + appli)HY(ca)HY(tion)YH( that relies on ODB for object persis)HY(tence)YH( using + the tradi)HY(tional)YH( "Hello World" example. In partic)HY(u)HY(lar)YH(, we will + discuss how to declare persis)HY(tent)YH( classes, gener)HY(ate)YH( database + support code, as well as compile and run our appli)HY(ca)HY(tion)YH(. We + will also learn how to make objects persis)HY(tent)YH(, load, update + and delete persis)HY(tent)YH( objects, as well as query the database + for persis)HY(tent)YH( objects that match certain crite)HY(ria)YH(. The example + also shows how to define and use views, a mech)HY(a)HY(nism)YH( that allows + us to create projec)HY(tions)YH( of persis)HY(tent)YH( objects, database tables, + or to handle results of native SQL queries or stored proce)HY(dure)YH( + calls.)EP( + + )0 P(The code presented in this chapter is based on the + )SM(hello)ES( example which can be found in the + )SM(odb-exam)HY(ples)YH()ES( package of the ODB distri)HY(bu)HY(tion)YH(.)EP( + + )0 2 9 H(2.1)WB 334 Sn()WB 12 Sn( Declar)HY(ing)YH( Persis)HY(tent)YH( Classes)EA()EH( + + )0 P(In our "Hello World" example we will depart slightly from + the norm and say hello to people instead of the world. People + in our appli)HY(ca)HY(tion)YH( will be repre)HY(sented)YH( as objects of C++ class + )SM(person)ES( which is saved in )SM(person.hxx)ES(:)EP( + + ) 23 36 PR(// person.hxx +// + +#include + +class person +{ +public: + person \201const std::string& first, + const std::string& last, + unsigned short age\202; + + const std::string& first \201\202 const; + const std::string& last \201\202 const; + + unsigned short age \201\202 const; + void age \201unsigned short\202; + +private: + std::string first_; + std::string last_; + unsigned short age_; +};)RP( + + )0 P(In order not to miss anyone whom we need to greet, we would like + to save the )SM(person)ES( objects in a database. To achieve this + we declare the )SM(person)ES( class as persis)HY(tent)YH(:)EP( + + ) 24 34 PR(// person.hxx +// + +#include + +#include // \2011\202 + +#pragma db object // \2012\202 +class person +{ + ... + +private: + person \201\202 {} // \2013\202 + + friend class odb::access; // \2014\202 + + #pragma db id auto // \2015\202 + unsigned long id_; // \2015\202 + + std::string first_; + std::string last_; + unsigned short age_; +};)RP( + + )0 P(To be able to save the )SM(person)ES( objects in the database + we had to make five changes, marked with \2011\202 to \2015\202, to the orig)HY(i)HY(nal)YH( + class defi)HY(ni)HY(tion)YH(. The first change is the inclu)HY(sion)YH( of the ODB + header )SM()ES(. This header provides a number + of core ODB decla)HY(ra)HY(tions)YH(, such as )SM(odb::access)ES(, that + are used to define persis)HY(tent)YH( classes.)EP( + + )0 P(The second change is the addi)HY(tion)YH( of )SM(db\240object)ES( + pragma just before the class defi)HY(ni)HY(tion)YH(. This pragma tells the + ODB compiler that the class that follows is persis)HY(tent)YH(. Note + that making a class persis)HY(tent)YH( does not mean that all objects + of this class will auto)HY(mat)HY(i)HY(cally)YH( be stored in the database. + You would still create ordi)HY(nary)YH( or )EM(tran)HY(sient)YH()ES( instances + of this class just as you would before. The differ)HY(ence)YH( is that + now you can make such tran)HY(sient)YH( instances persis)HY(tent)YH(, as we will + see shortly.)EP( + + )0 P(The third change is the addi)HY(tion)YH( of the default construc)HY(tor)YH(. + The ODB-gener)HY(ated)YH( database support code will use this construc)HY(tor)YH( + when instan)HY(ti)HY(at)HY(ing)YH( an object from the persis)HY(tent)YH( state. Just as we have + done for the )SM(person)ES( class, you can make the default + construc)HY(tor)YH( private or protected if you don't want to make it + avail)HY(able)YH( to the users of your class. Note also that with some + limi)HY(ta)HY(tions)YH( it is possi)HY(ble)YH( to have a persis)HY(tent)YH( class without + the default construc)HY(tor)YH(.)EP( + + )0 P(With the fourth change we make the )SM(odb::access)ES( class a + friend of our )SM(person)ES( class. This is neces)HY(sary)YH( to make + the default construc)HY(tor)YH( and the data members acces)HY(si)HY(ble)YH( to the + database support code. If your class has a public default construc)HY(tor)YH( and + either public data members or public acces)HY(sors)YH( and modi)HY(fiers)YH( for the + data members, then the )SM(friend)ES( decla)HY(ra)HY(tion)YH( is unnec)HY(es)HY(sary)YH(.)EP( + + )0 P(The final change adds a data member called )SM(id_)ES( which + is preceded by another pragma. In ODB every persis)HY(tent)YH( object normally + has a unique, within its class, iden)HY(ti)HY(fier)YH(. Or, in other words, no two + persis)HY(tent)YH( instances of the same type have equal iden)HY(ti)HY(fiers)YH(. While it + is possi)HY(ble)YH( to define a persis)HY(tent)YH( class without an object id, the number + of database oper)HY(a)HY(tions)YH( that can be performed on such a class is limited. + For our class we use an integer id. The )SM(db\240id auto)ES( + pragma that precedes the )SM(id_)ES( member tells the ODB compiler + that the follow)HY(ing)YH( member is the object's iden)HY(ti)HY(fier)YH(. The + )SM(auto)ES( spec)HY(i)HY(fier)YH( indi)HY(cates)YH( that it is a database-assigned + id. A unique id will be auto)HY(mat)HY(i)HY(cally)YH( gener)HY(ated)YH( by the database and + assigned to the object when it is made persis)HY(tent)YH(.)EP( + + )0 P(In this example we chose to add an iden)HY(ti)HY(fier)YH( because none of + the exist)HY(ing)YH( members could serve the same purpose. However, if + a class already has a member with suit)HY(able)YH( prop)HY(er)HY(ties)YH(, then it + is natural to use that member as an iden)HY(ti)HY(fier)YH(. For example, + if our )SM(person)ES( class contained some form of personal + iden)HY(ti)HY(fi)HY(ca)HY(tion)YH( \201SSN in the United States or ID/pass)HY(port)YH( number + in other coun)HY(tries)YH(\202, then we could use that as an id. Or, if + we stored an email asso)HY(ci)HY(ated)YH( with each person, then we could + have used that if each person is presumed to have a unique + email address.)EP( + + )0 P(As another example, consider the follow)HY(ing)YH( alter)HY(na)HY(tive)YH( version + of the )SM(person)ES( class. Here we use one of + the exist)HY(ing)YH( data members as id. Also the data members are kept + private and are instead accessed via public acces)HY(sor)YH( and modi)HY(fier)YH( + func)HY(tions)YH(. Finally, the ODB pragmas are grouped together and are + placed after the class defi)HY(ni)HY(tion)YH(. They could have also been moved + into a sepa)HY(rate)YH( header leaving the orig)HY(i)HY(nal)YH( class completely + unchanged \201for more infor)HY(ma)HY(tion)YH( on such a non-intru)HY(sive)YH( conver)HY(sion)YH( + refer to )0 100 1 A(Chapter 14, "ODB Pragma Language")100 0 TN TL()Ec /AF f D(\202.)EP( + + ) 22 39 PR(class person +{ +public: + person \201\202; + + const std::string& email \201\202 const; + void email \201const std::string&\202; + + const std::string& get_name \201\202 const; + std::string& set_name \201\202; + + unsigned short getAge \201\202 const; + void setAge \201unsigned short\202; + +private: + std::string email_; + std::string name_; + unsigned short age_; +}; + +#pragma db object\201person\202 +#pragma db member\201person::email_\202 id)RP( + + )0 P(Now that we have the header file with the persis)HY(tent)YH( class, let's + see how we can gener)HY(ate)YH( that database support code.)EP( + + )0 2 10 H(2.2)WB 335 Sn()WB 13 Sn( Gener)HY(at)HY(ing)YH( Database Support Code)EA()EH( + + )0 P(The persis)HY(tent)YH( class defi)HY(ni)HY(tion)YH( that we created in the previ)HY(ous)YH( + section was partic)HY(u)HY(larly)YH( light on any code that could actu)HY(ally)YH( + do the job and store the person's data to a database. There + was no seri)HY(al)HY(iza)HY(tion)YH( or dese)HY(ri)HY(al)HY(iza)HY(tion)YH( code, not even data member + regis)HY(tra)HY(tion)YH(, that you would normally have to write by hand in + other ORM libraries for C++. This is because in ODB code + that trans)HY(lates)YH( between the database and C++ repre)HY(sen)HY(ta)HY(tions)YH( + of an object is auto)HY(mat)HY(i)HY(cally)YH( gener)HY(ated)YH( by the ODB compiler.)EP( + + )0 P(To compile the )SM(person.hxx)ES( header we created in the + previ)HY(ous)YH( section and gener)HY(ate)YH( the support code for the MySQL + database, we invoke the ODB compiler from a termi)HY(nal)YH( \201UNIX\202 or + a command prompt \201Windows\202:)EP( + + ) 1 40 PR(odb -d mysql --generate-query person.hxx)RP( + + )0 P(We will use MySQL as the database of choice in the remain)HY(der)YH( of + this chapter, though other supported database systems can be used + instead.)EP( + + )0 P(If you haven't installed the common ODB runtime library + \201)SM(libodb)ES(\202 or installed it into a direc)HY(tory)YH( where + C++ compil)HY(ers)YH( don't search for headers by default, + then you may get the follow)HY(ing)YH( error:)EP( + + ) 1 70 PR(person.hxx:10:24: fatal error: odb/core.hxx: No such file or directory)RP( + + )0 P(To resolve this you will need to specify the )SM(libodb)ES( headers + loca)HY(tion)YH( with the )SM(-I)ES( prepro)HY(ces)HY(sor)YH( option, for example:)EP( + + ) 1 53 PR(odb -I.../libodb -d mysql --generate-query person.hxx)RP( + + )0 P(Here )SM(.../libodb)ES( repre)HY(sents)YH( the path to the + )SM(libodb)ES( direc)HY(tory)YH(.)EP( + + )0 P(The above invo)HY(ca)HY(tion)YH( of the ODB compiler produces three C++ files: + )SM(person-odb.hxx)ES(, )SM(person-odb.ixx)ES(, + )SM(person-odb.cxx)ES(. You normally don't use types + or func)HY(tions)YH( contained in these files directly. Rather, all + you have to do is include )SM(person-odb.hxx)ES( in + C++ files where you are perform)HY(ing)YH( database oper)HY(a)HY(tions)YH( + with classes from )SM(person.hxx)ES( as well as compile + )SM(person-odb.cxx)ES( and link the result)HY(ing)YH( object + file to your appli)HY(ca)HY(tion)YH(.)EP( + + )0 P(You may be wonder)HY(ing)YH( what the )SM(--gener)HY(ate)YH(-query)ES( + option is for. It instructs the ODB compiler to gener)HY(ate)YH( + optional query support code that we will use later in our + "Hello World" example. Another option that we will find + useful is )SM(--gener)HY(ate)YH(-schema)ES(. This option + makes the ODB compiler gener)HY(ate)YH( a fourth file, + )SM(person.sql)ES(, which is the database schema + for the persis)HY(tent)YH( classes defined in )SM(person.hxx)ES(:)EP( + + ) 1 58 PR(odb -d mysql --generate-query --generate-schema person.hxx)RP( + + )0 P(The database schema file contains SQL state)HY(ments)YH( that creates + tables neces)HY(sary)YH( to store the persis)HY(tent)YH( classes. We will learn + how to use it in the next section.)EP( + + )0 P(If you would like to see a list of all the avail)HY(able)YH( ODB compiler + options, refer to the + )R1 2 A(ODB + Compiler Command Line Manual)EA(.)EP( + + )0 P(Now that we have the persis)HY(tent)YH( class and the database support + code, the only part that is left is the appli)HY(ca)HY(tion)YH( code that + does some)HY(thing)YH( useful with all of this. But before we move on to + the fun part, let's first learn how to build and run an appli)HY(ca)HY(tion)YH( + that uses ODB. This way when we have some appli)HY(ca)HY(tion)YH( code + to try, there are no more delays before we can run it.)EP( + + )0 2 11 H(2.3)WB 336 Sn()WB 14 Sn( Compil)HY(ing)YH( and Running)EA()EH( + + )0 P(Assum)HY(ing)YH( that the )SM(main\201\202)ES( func)HY(tion)YH( with the appli)HY(ca)HY(tion)YH( + code is saved in )SM(driver.cxx)ES( and the database support + code and schema are gener)HY(ated)YH( as described in the previ)HY(ous)YH( section, + to build our appli)HY(ca)HY(tion)YH( we will first need to compile all the C++ + source files and then link them with two ODB runtime libraries.)EP( + + )0 P(On UNIX, the compi)HY(la)HY(tion)YH( part can be done with the follow)HY(ing)YH( commands + \201substi)HY(tute)YH( )SM(c++)ES( with your C++ compiler name; for Microsoft + Visual Studio setup, see the )SM(odb-exam)HY(ples)YH()ES( package\202:)EP( + + ) 2 21 PR(c++ -c driver.cxx +c++ -c person-odb.cxx)RP( + + )0 P(Similar to the ODB compi)HY(la)HY(tion)YH(, if you get an error stating that + a header in )SM(odb/)ES( or )SM(odb/mysql)ES( direc)HY(tory)YH( + is not found, you will need to use the )SM(-I)ES( + prepro)HY(ces)HY(sor)YH( option to specify the loca)HY(tion)YH( of the common ODB runtime + library \201)SM(libodb)ES(\202 and MySQL ODB runtime library + \201)SM(libodb-mysql)ES(\202.)EP( + + )0 P(Once the compi)HY(la)HY(tion)YH( is done, we can link the appli)HY(ca)HY(tion)YH( with + the follow)HY(ing)YH( command:)EP( + + ) 1 53 PR(c++ -o driver driver.o person-odb.o -lodb-mysql -lodb)RP( + + )0 P(Notice that we link our appli)HY(ca)HY(tion)YH( with two ODB libraries: + )SM(libodb)ES( which is a common runtime library and + )SM(libodb-mysql)ES( which is a MySQL runtime library + \201if you use another database, then the name of this library + will change accord)HY(ingly)YH(\202. If you get an error saying that + one of these libraries could not be found, then you will need + to use the )SM(-L)ES( linker option to specify their loca)HY(tions)YH(.)EP( + + )0 P(Before we can run our appli)HY(ca)HY(tion)YH( we need to create a database + schema using the gener)HY(ated)YH( )SM(person.sql)ES( file. For MySQL + we can use the )SM(mysql)ES( client program, for example:)EP( + + ) 1 54 PR(mysql --user=odb_test --database=odb_test < person.sql)RP( + + )0 P(The above command will log in to a local MySQL server as user + )SM(odb_test)ES( without a pass)HY(word)YH( and use the database + named )SM(odb_test)ES(. Beware that after execut)HY(ing)YH( this + command, all the data stored in the )SM(odb_test)ES( database + will be deleted.)EP( + + )0 P(Note also that using a stan)HY(dalone)YH( gener)HY(ated)YH( SQL file is not the + only way to create a database schema in ODB. We can also embed + the schema directly into our appli)HY(ca)HY(tion)YH( or use custom schemas + that were not gener)HY(ated)YH( by the ODB compiler. Refer to + )0 27 1 A(Section 3.4, "Database")27 0 TN TL()Ec /AF f D( for details.)EP( + + )0 P(Once the database schema is ready, we run our appli)HY(ca)HY(tion)YH( + using the same login and database name:)EP( + + ) 1 44 PR(./driver --user odb_test --database odb_test)RP( + + + )0 2 12 H(2.4)WB 337 Sn()WB 15 Sn( Making Objects Persis)HY(tent)YH()EA()EH( + + )0 P(Now that we have the infras)HY(truc)HY(ture)YH( work out of the way, it + is time to see our first code frag)HY(ment)YH( that inter)HY(acts)YH( with the + database. In this section we will learn how to make )SM(person)ES( + objects persis)HY(tent)YH(:)EP( + + ) 50 66 PR(// driver.cxx +// + +#include // std::auto_ptr +#include + +#include +#include + +#include + +#include "person.hxx" +#include "person-odb.hxx" + +using namespace std; +using namespace odb::core; + +int +main \201int argc, char* argv[]\202 +{ + try + { + auto_ptr db \201new odb::mysql::database \201argc, argv\202\202; + + unsigned long john_id, jane_id, joe_id; + + // Create a few persistent person objects. + // + { + person john \201"John", "Doe", 33\202; + person jane \201"Jane", "Doe", 32\202;)WR( + person joe \201"Joe", "Dirt", 30\202; + + transaction t \201db->begin \201\202\202; + + // Make objects persistent and save their ids for later use. + // + john_id = db->persist \201john\202; + jane_id = db->persist \201jane\202; + joe_id = db->persist \201joe\202; + + t.commit \201\202; + } + } + catch \201const odb::exception& e\202 + { + cerr << e.what \201\202 << endl; + return 1; + } +})RP( + + )0 P(Let's examine this code piece by piece. At the begin)HY(ning)YH( we include + a bunch of headers. After the stan)HY(dard)YH( C++ headers we include + )SM()ES( + and )SM()ES( which define database + system-inde)HY(pen)HY(dent)YH( )SM(odb::database)ES( and + )SM(odb::trans)HY(ac)HY(tion)YH()ES( inter)HY(faces)YH(. Then we include + )SM()ES( which defines the + MySQL imple)HY(men)HY(ta)HY(tion)YH( of the )SM(database)ES( inter)HY(face)YH(. Finally, + we include )SM(person.hxx)ES( and )SM(person-odb.hxx)ES( + which define our persis)HY(tent)YH( )SM(person)ES( class.)EP( + + )0 P(Then we have two )SM(using names)HY(pace)YH()ES( direc)HY(tives)YH(. The first + one brings in the names from the stan)HY(dard)YH( names)HY(pace)YH( and the second + brings in the ODB decla)HY(ra)HY(tions)YH( which we will use later in the file. + Notice that in the second direc)HY(tive)YH( we use the )SM(odb::core)ES( + names)HY(pace)YH( instead of just )SM(odb)ES(. The former only brings + into the current names)HY(pace)YH( the essen)HY(tial)YH( ODB names, such as the + )SM(database)ES( and )SM(trans)HY(ac)HY(tion)YH()ES( classes, without + any of the auxil)HY(iary)YH( objects. This mini)HY(mizes)YH( the like)HY(li)HY(hood)YH( of name + conflicts with other libraries. Note also that you should continue + using the )SM(odb)ES( names)HY(pace)YH( when qual)HY(i)HY(fy)HY(ing)YH( indi)HY(vid)HY(ual)YH( names. + For example, you should write )SM(odb::database)ES(, not + )SM(odb::core::database)ES(.)EP( + + )0 P(Once we are in )SM(main\201\202)ES(, the first thing we do is create + the MySQL database object. Notice that this is the last line in + )SM(driver.cxx)ES( that mentions MySQL explic)HY(itly)YH(; the rest + of the code works through the common inter)HY(faces)YH( and is database + system-inde)HY(pen)HY(dent)YH(. We use the )SM(argc)ES(/)SM(argv)ES( + )SM(mysql::database)ES( construc)HY(tor)YH( which auto)HY(mat)HY(i)HY(cally)YH( + extract the database param)HY(e)HY(ters)YH(, such as login name, pass)HY(word)YH(, + database name, etc., from the command line. In your own appli)HY(ca)HY(tions)YH( + you may prefer to use other )SM(mysql::database)ES( + construc)HY(tors)YH( which allow you to pass this infor)HY(ma)HY(tion)YH( directly + \201)0 214 1 A(Section 17.2, "MySQL Database Class")214 0 TN TL()Ec /AF f D(\202.)EP( + + )0 P(Next, we create three )SM(person)ES( objects. Right now they are + tran)HY(sient)YH( objects, which means that if we termi)HY(nate)YH( the appli)HY(ca)HY(tion)YH( + at this point, they will be gone without any evidence of them ever + exist)HY(ing)YH(. The next line starts a database trans)HY(ac)HY(tion)YH(. We discuss + trans)HY(ac)HY(tions)YH( in detail later in this manual. For now, all we need + to know is that all ODB database oper)HY(a)HY(tions)YH( must be performed within + a trans)HY(ac)HY(tion)YH( and that a trans)HY(ac)HY(tion)YH( is an atomic unit of work; all + database oper)HY(a)HY(tions)YH( performed within a trans)HY(ac)HY(tion)YH( either succeed + \201commit)HY(ted)YH(\202 together or are auto)HY(mat)HY(i)HY(cally)YH( undone \201rolled back\202.)EP( + + )0 P(Once we are in a trans)HY(ac)HY(tion)YH(, we call the )SM(persist\201\202)ES( + database func)HY(tion)YH( on each of our )SM(person)ES( objects. + At this point the state of each object is saved in the database. + However, note that this state is not perma)HY(nent)YH( until and unless + the trans)HY(ac)HY(tion)YH( is commit)HY(ted)YH(. If, for example, our appli)HY(ca)HY(tion)YH( + crashes at this point, there will still be no evidence of our + objects ever exist)HY(ing)YH(.)EP( + + )0 P(In our case, one more thing happens when we call )SM(persist\201\202)ES(. + Remem)HY(ber)YH( that we decided to use database-assigned iden)HY(ti)HY(fiers)YH( for our + )SM(person)ES( objects. The call to )SM(persist\201\202)ES( is + where this assign)HY(ment)YH( happens. Once this func)HY(tion)YH( returns, the + )SM(id_)ES( member contains this object's unique iden)HY(ti)HY(fier)YH(. + As a conve)HY(nience)YH(, the )SM(persist\201\202)ES( func)HY(tion)YH( also returns + a copy of the object's iden)HY(ti)HY(fier)YH( that it made persis)HY(tent)YH(. We + save the returned iden)HY(ti)HY(fier)YH( for each object in a local vari)HY(able)YH(. + We will use these iden)HY(ti)HY(fiers)YH( later in the chapter to perform other + database oper)HY(a)HY(tions)YH( on our persis)HY(tent)YH( objects.)EP( + + )0 P(After we have persisted our objects, it is time to commit the + trans)HY(ac)HY(tion)YH( and make the changes perma)HY(nent)YH(. Only after the + )SM(commit\201\202)ES( func)HY(tion)YH( returns success)HY(fully)YH(, are we + guar)HY(an)HY(teed)YH( that the objects are made persis)HY(tent)YH(. Contin)HY(u)HY(ing)YH( + with the crash example, if our appli)HY(ca)HY(tion)YH( termi)HY(nates)YH( after + the commit for what)HY(ever)YH( reason, the objects' state in the + database will remain intact. In fact, as we will discover + shortly, our appli)HY(ca)HY(tion)YH( can be restarted and load the + orig)HY(i)HY(nal)YH( objects from the database. Note also that a + trans)HY(ac)HY(tion)YH( must be commit)HY(ted)YH( explic)HY(itly)YH( with the + )SM(commit\201\202)ES( call. If the )SM(trans)HY(ac)HY(tion)YH()ES( + object leaves scope without the trans)HY(ac)HY(tion)YH( being + explic)HY(itly)YH( commit)HY(ted)YH( or rolled back, it will auto)HY(mat)HY(i)HY(cally)YH( be + rolled back. This behav)HY(ior)YH( allows you not to worry about + excep)HY(tions)YH( being thrown within a trans)HY(ac)HY(tion)YH(; if they + cross the trans)HY(ac)HY(tion)YH( bound)HY(ary)YH(, the trans)HY(ac)HY(tion)YH( will + auto)HY(mat)HY(i)HY(cally)YH( be rolled back and all the changes made + to the database undone.)EP( + + )0 P(The final bit of code in our example is the )SM(catch)ES( + block that handles the database excep)HY(tions)YH(. We do this by catch)HY(ing)YH( + the base ODB excep)HY(tion)YH( \201)0 37 1 A(Section 3.14, "ODB + Excep)HY(tions)YH(")37 0 TN TL()Ec /AF f D(\202 and print)HY(ing)YH( the diag)HY(nos)HY(tics)YH(.)EP( + + )0 P(Let's now compile \201)0 14 1 A(Section 2.3, "Compil)HY(ing)YH( and + Running")14 0 TN TL()Ec /AF f D(\202 and then run our first ODB appli)HY(ca)HY(tion)YH(:)EP( + + ) 2 54 PR(mysql --user=odb_test --database=odb_test < person.sql +./driver --user odb_test --database odb_test)RP( + + )0 P(Our first appli)HY(ca)HY(tion)YH( doesn't print anything except for error + messages so we can't really tell whether it actu)HY(ally)YH( stored the + objects' state in the database. While we will make our appli)HY(ca)HY(tion)YH( + more enter)HY(tain)HY(ing)YH( shortly, for now we can use the )SM(mysql)ES( + client to examine the database content. It will also give us a feel + for how the objects are stored:)EP( + + ) 16 41 PR(mysql --user=odb_test --database=odb_test + +Welcome to the MySQL monitor. + +mysql> select * from person; + ++----+-------+------+-----+ +| id | first | last | age | ++----+-------+------+-----+ +| 1 | John | Doe | 33 | +| 2 | Jane | Doe | 32 | +| 3 | Joe | Dirt | 30 | ++----+-------+------+-----+ +3 rows in set \2010.00 sec\202 + +mysql> quit)RP( + + )0 P(Another way to get more insight into what's going on under the hood, + is to trace the SQL state)HY(ments)YH( executed by ODB as a result of + each database oper)HY(a)HY(tion)YH(. Here is how we can enable tracing just for + the dura)HY(tion)YH( of our trans)HY(ac)HY(tion)YH(:)EP( + + ) 17 66 PR( // Create a few persistent person objects. + // + { + ... + + transaction t \201db->begin \201\202\202; + + t.tracer \201stderr_tracer\202; + + // Make objects persistent and save their ids for later use. + // + john_id = db->persist \201john\202; + jane_id = db->persist \201jane\202; + joe_id = db->persist \201joe\202; + + t.commit \201\202; + })RP( + + )0 P(With this modi)HY(fi)HY(ca)HY(tion)YH( our appli)HY(ca)HY(tion)YH( now produces the follow)HY(ing)YH( + output:)EP( + + ) 3 65 PR(INSERT INTO `person` \201`id`,`first`,`last`,`age`\202 VALUES \201?,?,?,?\202 +INSERT INTO `person` \201`id`,`first`,`last`,`age`\202 VALUES \201?,?,?,?\202 +INSERT INTO `person` \201`id`,`first`,`last`,`age`\202 VALUES \201?,?,?,?\202)RP( + + )0 P(Note that we see ques)HY(tion)YH( marks instead of the actual values + because ODB uses prepared state)HY(ments)YH( and sends the data to the + database in binary form. For more infor)HY(ma)HY(tion)YH( on tracing, refer + to )0 36 1 A(Section 3.13, "Tracing SQL State)HY(ment)YH( Execu)HY(tion)YH(")36 0 TN TL()Ec /AF f D(. + In the next section we will see how to access persis)HY(tent)YH( objects + from our appli)HY(ca)HY(tion)YH(.)EP( + + )0 2 13 H(2.5)WB 338 Sn()WB 16 Sn( Query)HY(ing)YH( the Database for Objects)EA()EH( + + )0 P(So far our appli)HY(ca)HY(tion)YH( doesn't resem)HY(ble)YH( a typical "Hello World" + example. It doesn't print anything except for error messages. + Let's change that and teach our appli)HY(ca)HY(tion)YH( to say hello to + people from our database. To make it a bit more inter)HY(est)HY(ing)YH(, + let's say hello only to people over 30:)EP( + + ) 42 63 PR(// driver.cxx +// + +... + +int +main \201int argc, char* argv[]\202 +{ + try + { + ... + + // Create a few persistent person objects. + // + { + ... + } + + typedef odb::query query; + typedef odb::result result; + + // Say hello to those over 30. + // + { + transaction t \201db->begin \201\202\202; + + result r \201db->query \201query::age > 30\202\202; + + for \201result::iterator i \201r.begin \201\202\202; i != r.end \201\202; ++i\202 + { + cout << "Hello, " << i->first \201\202 << "!" << endl;)WR( + } + + t.commit \201\202; + } + } + catch \201const odb::exception& e\202 + { + cerr << e.what \201\202 << endl; + return 1; + } +})RP( + + )0 P(The first half of our appli)HY(ca)HY(tion)YH( is the same as before and is + replaced with "..." in the above listing for brevity. Again, let's + examine the rest of it piece by piece.)EP( + + )0 P(The two )SM(typedef)ES(s create conve)HY(nient)YH( aliases for two + template instan)HY(ti)HY(a)HY(tions)YH( that will be used a lot in our appli)HY(ca)HY(tion)YH(. + The first is the query type for the )SM(person)ES( objects + and the second is the result type for that query.)EP( + + )0 P(Then we begin a new trans)HY(ac)HY(tion)YH( and call the )SM(query\201\202)ES( + database func)HY(tion)YH(. We pass a query expres)HY(sion)YH( + \201)SM(query::age > 30)ES(\202 which limits the returned objects + only to those with the age greater than 30. We also save the result + of the query in a local vari)HY(able)YH(.)EP( + + )0 P(The next few lines perform a stan)HY(dard)YH( for-loop iter)HY(a)HY(tion)YH( + over the result sequence print)HY(ing)YH( hello for every returned person. + Then we commit the trans)HY(ac)HY(tion)YH( and that's it. Let's see what + this appli)HY(ca)HY(tion)YH( will print:)EP( + + ) 5 54 PR(mysql --user=odb_test --database=odb_test < person.sql +./driver --user odb_test --database odb_test + +Hello, John! +Hello, Jane!)RP( + + + )0 P(That looks about right, but how do we know that the query actu)HY(ally)YH( + used the database instead of just using some in-memory arti)HY(facts)YH( of + the earlier )SM(persist\201\202)ES( calls? One way to test this + would be to comment out the first trans)HY(ac)HY(tion)YH( in our appli)HY(ca)HY(tion)YH( + and re-run it without re-creat)HY(ing)YH( the database schema. This way the + objects that were persisted during the previ)HY(ous)YH( run will be returned. + Alter)HY(na)HY(tively)YH(, we can just re-run the same appli)HY(ca)HY(tion)YH( without + re-creat)HY(ing)YH( the schema and notice that we now show dupli)HY(cate)YH( + objects:)EP( + + ) 6 44 PR(./driver --user odb_test --database odb_test + +Hello, John! +Hello, Jane! +Hello, John! +Hello, Jane!)RP( + + )0 P(What happens here is that the previ)HY(ous)YH( run of our appli)HY(ca)HY(tion)YH( + persisted a set of )SM(person)ES( objects and when we re-run + the appli)HY(ca)HY(tion)YH(, we persist another set with the same names but + with differ)HY(ent)YH( ids. When we later run the query, matches from + both sets are returned. We can change the line where we print + the "Hello" string as follows to illus)HY(trate)YH( this point:)EP( + + ) 1 69 PR(cout << "Hello, " << i->first \201\202 << " \201" << i->id \201\202 << "\202!" << endl;)RP( + + )0 P(If we now re-run this modi)HY(fied)YH( program, again without re-creat)HY(ing)YH( + the database schema, we will get the follow)HY(ing)YH( output:)EP( + + ) 8 44 PR(./driver --user odb_test --database odb_test + +Hello, John \2011\202! +Hello, Jane \2012\202! +Hello, John \2014\202! +Hello, Jane \2015\202! +Hello, John \2017\202! +Hello, Jane \2018\202!)RP( + + )0 P(The iden)HY(ti)HY(fiers)YH( 3, 6, and 9 that are missing from the above list belong + to the "Joe Dirt" objects which are not selected by this query.)EP( + + )0 2 14 H(2.6)WB 339 Sn()WB 17 Sn( Updat)HY(ing)YH( Persis)HY(tent)YH( Objects)EA()EH( + + )0 P(While making objects persis)HY(tent)YH( and then select)HY(ing)YH( some of them using + queries are two useful oper)HY(a)HY(tions)YH(, most appli)HY(ca)HY(tions)YH( will also need + to change the object's state and then make these changes persis)HY(tent)YH(. + Let's illus)HY(trate)YH( this by updat)HY(ing)YH( Joe's age who just had a birth)HY(day)YH(:)EP( + + ) 50 55 PR(// driver.cxx +// + +... + +int +main \201int argc, char* argv[]\202 +{ + try + { + ... + + unsigned long john_id, jane_id, joe_id; + + // Create a few persistent person objects. + // + { + ... + + // Save object ids for later use. + // + john_id = john.id \201\202; + jane_id = jane.id \201\202; + joe_id = joe.id \201\202; + } + + // Joe Dirt just had a birthday, so update his age. + // + { + transaction t \201db->begin \201\202\202; +)WR( + auto_ptr joe \201db->load \201joe_id\202\202; + joe->age \201joe->age \201\202 + 1\202; + db->update \201*joe\202; + + t.commit \201\202; + } + + // Say hello to those over 30. + // + { + ... + } + } + catch \201const odb::exception& e\202 + { + cerr << e.what \201\202 << endl; + return 1; + } +})RP( + + )0 P(The begin)HY(ning)YH( and the end of the new trans)HY(ac)HY(tion)YH( are the same as + the previ)HY(ous)YH( two. Once within a trans)HY(ac)HY(tion)YH(, we call the + )SM(load\201\202)ES( database func)HY(tion)YH( to instan)HY(ti)HY(ate)YH( a + )SM(person)ES( object with Joe's persis)HY(tent)YH( state. We + pass Joe's object iden)HY(ti)HY(fier)YH( that we stored earlier when we + made this object persis)HY(tent)YH(. While here we use + )SM(std::auto_ptr)ES( to manage the returned object, we + could have also used another smart pointer, for example + )SM(std::unique_ptr)ES( from C++11 or )SM(shared_ptr)ES( + from TR1, C++11, or Boost. For more infor)HY(ma)HY(tion)YH( + on the object life)HY(time)YH( manage)HY(ment)YH( and the smart point)HY(ers)YH( that we + can use for that, see )0 26 1 A(Section 3.3, "Object + and View Point)HY(ers)YH(")26 0 TN TL()Ec /AF f D(.)EP( + + )0 P(With the instan)HY(ti)HY(ated)YH( object in hand we incre)HY(ment)YH( the age + and call the )SM(update\201\202)ES( func)HY(tion)YH( to update + the object's state in the database. Once the trans)HY(ac)HY(tion)YH( is + commit)HY(ted)YH(, the changes are made perma)HY(nent)YH(.)EP( + + )0 P(If we now run this appli)HY(ca)HY(tion)YH(, we will see Joe in the output + since he is now over 30:)EP( + + ) 6 54 PR(mysql --user=odb_test --database=odb_test < person.sql +./driver --user odb_test --database odb_test + +Hello, John! +Hello, Jane! +Hello, Joe!)RP( + + )0 P(What if we didn't have an iden)HY(ti)HY(fier)YH( for Joe? Maybe this object + was made persis)HY(tent)YH( in another run of our appli)HY(ca)HY(tion)YH( or by another + appli)HY(ca)HY(tion)YH( alto)HY(gether)YH(. Provided that we only have one Joe Dirt + in the database, we can use the query facil)HY(ity)YH( to come up with + an alter)HY(na)HY(tive)YH( imple)HY(men)HY(ta)HY(tion)YH( of the above trans)HY(ac)HY(tion)YH(:)EP( + + ) 22 64 PR( // Joe Dirt just had a birthday, so update his age. An + // alternative implementation without using the object id. + // + { + transaction t \201db->begin \201\202\202; + + // Here we know that there can be only one Joe Dirt in our + // database so we use the query_one\201\202 shortcut instead of + // manually iterating over the result returned by query\201\202. + // + auto_ptr joe \201 + db->query_one \201query::first == "Joe" && + query::last == "Dirt"\202\202; + + if \201joe.get \201\202 != 0\202 + { + joe->age \201joe->age \201\202 + 1\202; + db->update \201*joe\202; + } + + t.commit \201\202; + })RP( + + )0 2 15 H(2.7)WB 340 Sn()WB 18 Sn( Defin)HY(ing)YH( and Using Views)EA()EH( + + )0 P(Suppose that we need to gather some basic statis)HY(tics)YH( about the people + stored in our database. Things like the total head count, as well as + the minimum and maximum ages. One way to do it would be to query + the database for all the )SM(person)ES( objects and then + calcu)HY(late)YH( this infor)HY(ma)HY(tion)YH( as we iterate over the query result. + While this approach may work fine for our database with just three + people in it, it would be very inef)HY(fi)HY(cient)YH( if we had a large + number of objects.)EP( + + )0 P(While it may not be concep)HY(tu)HY(ally)YH( pure from the object-oriented + program)HY(ming)YH( point of view, a rela)HY(tional)YH( database can perform + some compu)HY(ta)HY(tions)YH( much faster and much more econom)HY(i)HY(cally)YH( than + if we performed the same oper)HY(a)HY(tions)YH( ourselves in the appli)HY(ca)HY(tion)YH('s + process.)EP( + + )0 P(To support such cases ODB provides the notion of views. An ODB view + is a C++ )SM(class)ES( that embod)HY(ies)YH( a light-weight, read-only + projec)HY(tion)YH( of one or more persis)HY(tent)YH( objects or database tables or + the result of a native SQL query execu)HY(tion)YH( or stored proce)HY(dure)YH( + call.)EP( + + )0 P(Some of the common appli)HY(ca)HY(tions)YH( of views include loading a subset of + data members from objects or columns database tables, execut)HY(ing)YH( and + handling results of arbi)HY(trary)YH( SQL queries, includ)HY(ing)YH( aggre)HY(gate)YH( + queries, as well as joining multi)HY(ple)YH( objects and/or database + tables using object rela)HY(tion)HY(ships)YH( or custom join condi)HY(tions)YH(.)EP( + + )0 P(While you can find a much more detailed descrip)HY(tion)YH( of views in + )0 79 1 A(Chapter 10, "Views")79 0 TN TL()Ec /AF f D(, here is how we can define + the )SM(person_stat)ES( view that returns the basic statis)HY(tics)YH( + about the )SM(person)ES( objects:)EP( + + ) 12 49 PR(#pragma db view object\201person\202 +struct person_stat +{ + #pragma db column\201"count\201" + person::id_ + "\202"\202 + std::size_t count; + + #pragma db column\201"min\201" + person::age_ + "\202"\202 + unsigned short min_age; + + #pragma db column\201"max\201" + person::age_ + "\202"\202 + unsigned short max_age; +};)RP( + + )0 P(Normally, to get the result of a view we use the same + )SM(query\201\202)ES( func)HY(tion)YH( as when query)HY(ing)YH( the database for + an object. Here, however, we are execut)HY(ing)YH( an aggre)HY(gate)YH( query + which always returns exactly one element. There)HY(fore)YH(, instead + of getting the result instance and then iter)HY(at)HY(ing)YH( over it, we + can use the short)HY(cut)YH( )SM(query_value\201\202)ES( func)HY(tion)YH(. Here is + how we can load and print our statis)HY(tics)YH( using the view we have + just created:)EP( + + ) 15 66 PR( // Print some statistics about all the people in our database. + // + { + transaction t \201db->begin \201\202\202; + + // The result of this query always has exactly one element. + // + person_stat ps \201db->query_value \201\202\202; + + cout << "count : " << ps.count << endl + << "min age: " << ps.min_age << endl + << "max age: " << ps.max_age << endl; + + t.commit \201\202; + })RP( + + )0 P(If we now add the )SM(person_stat)ES( view to the + )SM(person.hxx)ES( header, the above trans)HY(ac)HY(tion)YH( + to )SM(driver.cxx)ES(, as well as re-compile and + re-run our example, then we will see the follow)HY(ing)YH( + addi)HY(tional)YH( lines in the output:)EP( + + ) 3 11 PR(count : 3 +min age: 31 +max age: 33)RP( + + )0 2 16 H(2.8)WB 341 Sn()WB 19 Sn( Delet)HY(ing)YH( Persis)HY(tent)YH( Objects)EA()EH( + + )0 P(The last oper)HY(a)HY(tion)YH( that we will discuss in this chapter is delet)HY(ing)YH( + the persis)HY(tent)YH( object from the database. The follow)HY(ing)YH( code + frag)HY(ment)YH( shows how we can delete an object given its iden)HY(ti)HY(fier)YH(:)EP( + + ) 7 45 PR( // John Doe is no longer in our database. + // + { + transaction t \201db->begin \201\202\202; + db->erase \201john_id\202; + t.commit \201\202; + })RP( + + )0 P(To delete John from the database we start a trans)HY(ac)HY(tion)YH(, call + the )SM(erase\201\202)ES( database func)HY(tion)YH( with John's object + id, and commit the trans)HY(ac)HY(tion)YH(. After the trans)HY(ac)HY(tion)YH( is commit)HY(ted)YH(, + the erased object is no longer persis)HY(tent)YH(.)EP( + + )0 P(If we don't have an object id handy, we can use queries to find + and delete the object:)EP( + + ) 18 64 PR( // John Doe is no longer in our database. An alternative + // implementation without using the object id. + // + { + transaction t \201db->begin \201\202\202; + + // Here we know that there can be only one John Doe in our + // database so we use the query_one\201\202 shortcut again. + // + auto_ptr john \201 + db->query_one \201query::first == "John" && + query::last == "Doe"\202\202; + + if \201john.get \201\202 != 0\202 + db->erase \201*john\202; + + t.commit \201\202; + })RP( + + )0 2 17 H(2.9)WB 342 Sn()WB 20 Sn( Chang)HY(ing)YH( Persis)HY(tent)YH( Classes)EA()EH( + + )0 P(When the defi)HY(ni)HY(tion)YH( of a tran)HY(sient)YH( C++ class is changed, for + example by adding or delet)HY(ing)YH( a data member, we don't have to + worry about any exist)HY(ing)YH( instances of this class not match)HY(ing)YH( + the new defi)HY(ni)HY(tion)YH(. After all, to make the class changes + effec)HY(tive)YH( we have to restart the appli)HY(ca)HY(tion)YH( and none of the + tran)HY(sient)YH( instances will survive this.)EP( + + )0 P(Things are not as simple for persis)HY(tent)YH( classes. Because they + are stored in the database and there)HY(fore)YH( survive appli)HY(ca)HY(tion)YH( + restarts, we have a new problem: what happens to the state of + exist)HY(ing)YH( objects \201which corre)HY(spond)YH( to the old defi)HY(ni)HY(tion)YH(\202 once + we change our persis)HY(tent)YH( class?)EP( + + )0 P(The problem of working with old objects, called )EM(database + schema evolu)HY(tion)YH()ES(, is a complex issue and ODB provides + compre)HY(hen)HY(sive)YH( support for handling it. While this support + is covered in detail in )0 91 1 A(Chapter 13, + "Database Schema Evolu)HY(tion)YH(")91 0 TN TL()Ec /AF f D(, let us consider a simple + example that should give us a sense of the func)HY(tion)HY(al)HY(ity)YH( + provided by ODB in this area.)EP( + + )0 P(Suppose that after using our )SM(person)ES( persis)HY(tent)YH( + class for some time and creat)HY(ing)YH( a number of databases + contain)HY(ing)YH( its instances, we real)HY(ized)YH( that for some people + we also need to store their middle name. If we go ahead and + just add the new data member, every)HY(thing)YH( will work fine + with new databases. Exist)HY(ing)YH( databases, however, have a + table that does not corre)HY(spond)YH( to the new class defi)HY(ni)HY(tion)YH(. + Specif)HY(i)HY(cally)YH(, the gener)HY(ated)YH( database support code now + expects there to be a column to store the middle name. + But such a column was never created in the old databases.)EP( + + )0 P(ODB can auto)HY(mat)HY(i)HY(cally)YH( gener)HY(ate)YH( SQL state)HY(ments)YH( that will + migrate old databases to match the new class defi)HY(ni)HY(tions)YH(. + But first, we need to enable schema evolu)HY(tion)YH( support by + defin)HY(ing)YH( a version for our object model:)EP( + + ) 13 30 PR(// person.hxx +// + +#pragma db model version\2011, 1\202 + +class person +{ + ... + + std::string first_; + std::string last_; + unsigned short age_; +};)RP( + + )0 P(The first number in the )SM(version)ES( pragma is the + base model version. This is the lowest version we will be + able to migrate from. The second number is the current model + version. Since we haven't made any changes yet to our + persis)HY(tent)YH( class, both of these values are )SM(1)ES(.)EP( + + )0 P(Next we need to re-compile our )SM(person.hxx)ES( header + file with the ODB compiler, just as we did before:)EP( + + ) 1 58 PR(odb -d mysql --generate-query --generate-schema person.hxx)RP( + + )0 P(If we now look at the list of files produced by the ODB compiler, + we will notice a new file: )SM(person.xml)ES(. This + is a changelog file where the ODB compiler keeps track of the + database changes corre)HY(spond)HY(ing)YH( to our class changes. Note that + this file is auto)HY(mat)HY(i)HY(cally)YH( main)HY(tained)YH( by the ODB compiler and + all we have to do is keep it around between re-compi)HY(la)HY(tions)YH(.)EP( + + )0 P(Now we are ready to add the middle name to our )SM(person)ES( + class. We also give it a default value \201empty string\202 which + is what will be assigned to exist)HY(ing)YH( objects in old databases. + Notice that we have also incre)HY(mented)YH( the current version:)EP( + + ) 17 30 PR(// person.hxx +// + +#pragma db model version\2011, 2\202 + +class person +{ + ... + + std::string first_; + + #pragma db default\201""\202 + std::string middle_; + + std::string last_; + unsigned short age_; +};)RP( + + )0 P(If we now recom)HY(pile)YH( the )SM(person.hxx)ES( header again, we will + see two extra gener)HY(ated)YH( files: )SM(person-002-pre.sql)ES( + and )SM(person-002-post.sql)ES(. These two files contain + schema migra)HY(tion)YH( state)HY(ments)YH( from version )SM(1)ES( to + version )SM(2)ES(. Similar to schema creation, schema + migra)HY(tion)YH( state)HY(ments)YH( can also be embed)HY(ded)YH( into the gener)HY(ated)YH( + C++ code.)EP( + + )0 P()SM(person-002-pre.sql)ES( and )SM(person-002-post.sql)ES( + are the pre and post schema migra)HY(tion)YH( files. To migrate + one of our old databases, we first execute the pre migra)HY(tion)YH( + file:)EP( + + ) 1 62 PR(mysql --user=odb_test --database=odb_test < person-002-pre.sql)RP( + + )0 P(Between the pre and post schema migra)HY(tions)YH( we can run data + migra)HY(tion)YH( code, if required. At this stage, we can both + access the old and store the new data. In our case we don't + need any data migra)HY(tion)YH( code since we assigned the default + value to the middle name for all the exist)HY(ing)YH( objects.)EP( + + )0 P(To finish the migra)HY(tion)YH( process we execute the post migra)HY(tion)YH( + state)HY(ments)YH(:)EP( + + ) 1 63 PR(mysql --user=odb_test --database=odb_test < person-002-post.sql)RP( + + )0 2 18 H(2.10)WB 343 Sn()WB 21 Sn( Working with Multi)HY(ple)YH( Databases)EA()EH( + + )0 P(Access)HY(ing)YH( multi)HY(ple)YH( databases \201that is, data stores\202 is simply a + matter of creat)HY(ing)YH( multi)HY(ple)YH( )SM(odb::::database)ES( + instances repre)HY(sent)HY(ing)YH( each database. For example:)EP( + + ) 2 56 PR(odb::mysql::database db1 \201"john", "secret", "test_db1"\202; +odb::mysql::database db2 \201"john", "secret", "test_db2"\202;)RP( + + )0 P(Some database systems also allow attach)HY(ing)YH( multi)HY(ple)YH( databases to + the same instance. A more inter)HY(est)HY(ing)YH( ques)HY(tion)YH( is how we access + multi)HY(ple)YH( database systems \201that is, database imple)HY(men)HY(ta)HY(tions)YH(\202 from + the same appli)HY(ca)HY(tion)YH(. For example, our appli)HY(ca)HY(tion)YH( may need to store + some objects in a remote MySQL database and others in a local SQLite + file. Or, our appli)HY(ca)HY(tion)YH( may need to be able to store its objects + in a database system that is selected by the user at runtime.)EP( + + )0 P(ODB provides compre)HY(hen)HY(sive)YH( multi-database support that ranges from + tight inte)HY(gra)HY(tion)YH( with specific database systems to being able to + write database-agnos)HY(tic)YH( code and loading indi)HY(vid)HY(ual)YH( database systems + support dynam)HY(i)HY(cally)YH(. While all these aspects are covered in detail + in )0 205 1 A(Chapter 16, "Multi-Database Support")205 0 TN TL()Ec /AF f D(, in this + section we will get a taste of this func)HY(tion)HY(al)HY(ity)YH( by extend)HY(ing)YH( our + "Hello World" example to be able to store its data either in MySQL + or Post)HY(greSQL)YH( \201other database systems supported by ODB can be added + in a similar manner\202.)EP( + + )0 P(The first step in adding multi-database support is to re-compile + our )SM(person.hxx)ES( header to gener)HY(ate)YH( database support + code for addi)HY(tional)YH( database systems:)EP( + + ) 2 58 PR(odb --multi-database dynamic -d common -d mysql -d pgsql \200 +--generate-query --generate-schema person.hxx)RP( + + )0 P(The )SM(--multi-database)ES( ODB compiler option turns on + multi-database support. For now it is not impor)HY(tant)YH( what the + )SM(dynamic)ES( value that we passed to this option means, but + if you are curious, see )0 205 1 A(Chapter 16)205 0 TN TL()Ec /AF f D(. The result of this + command are three sets of gener)HY(ated)YH( files: )SM(person-odb.?xx)ES( + \201common inter)HY(face)YH(; corre)HY(sponds)YH( to the )SM(common)ES( database\202, + )SM(person-odb-mysql.?xx)ES( \201MySQL support code\202, and + )SM(person-odb-pgsql.?xx)ES( \201Post)HY(greSQL)YH( support code\202. There + are also two schema files: )SM(person-mysql.sql)ES( and + )SM(person-pgsql.sql)ES(.)EP( + + )0 P(The only part that we need to change in )SM(driver.cxx)ES( + is how we create the database instance. Specif)HY(i)HY(cally)YH(, this line:)EP( + + ) 1 62 PR(auto_ptr db \201new odb::mysql::database \201argc, argv\202\202;)RP( + + )0 P(Now our example is capable of storing its data either in MySQL or + Post)HY(greSQL)YH( so we need to somehow allow the caller to specify which + database we must use. To keep things simple, we will make the first + command line argu)HY(ment)YH( specify the database system we must use while + the rest will contain the database-specific options which we will + pass to the )SM(odb::::database)ES( construc)HY(tor)YH( as + before. Let's put all this logic into a sepa)HY(rate)YH( func)HY(tion)YH( which we + will call )SM(create_database\201\202)ES(. Here is what the begin)HY(ning)YH( + of our modi)HY(fied)YH( )SM(driver.cxx)ES( will look like \201the remain)HY(der)YH( + is unchanged\202:)EP( + + ) 53 60 PR(// driver.cxx +// + +#include +#include // std::auto_ptr +#include + +#include +#include + +#include +#include + +#include "person.hxx" +#include "person-odb.hxx" + +using namespace std; +using namespace odb::core; + +auto_ptr +create_database \201int argc, char* argv[]\202 +{ + auto_ptr r; + + if \201argc < 2\202 + { + cerr << "error: database system name expected" << endl; + return r; + } + + string db \201argv[1]\202;)WR( + + if \201db == "mysql"\202 + r.reset \201new odb::mysql::database \201argc, argv\202\202; + else if \201db == "pgsql"\202 + r.reset \201new odb::pgsql::database \201argc, argv\202\202; + else + cerr << "error: unknown database system " << db << endl; + + return r; +} + +int +main \201int argc, char* argv[]\202 +{ + try + { + auto_ptr db \201create_database \201argc, argv\202\202; + + if \201db.get \201\202 == 0\202 + return 1; // Diagnostics has already been issued. + + ...)RP( + + )0 P(And that's it. The only thing left is to build and run our + example:)EP( + + ) 6 56 PR(c++ -c driver.cxx +c++ -c person-odb.cxx +c++ -c person-odb-mysql.cxx +c++ -c person-odb-pgsql.cxx +c++ -o driver driver.o person-odb.o person-odb-mysql.o \200 +person-odb-pgsql.o -lodb-mysql -lodb-pgsql -lodb)RP( + + )0 P(Here is how we can access a MySQL database:)EP( + + ) 2 60 PR(mysql --user=odb_test --database=odb_test < person-mysql.sql +./driver mysql --user odb_test --database odb_test)RP( + + )0 P(Or a Post)HY(greSQL)YH( database:)EP( + + ) 2 58 PR(psql --user=odb_test --dbname=odb_test -f person-pgsql.sql +./driver pgsql --user odb_test --database odb_test)RP( + + )0 2 19 H(2.11)WB 344 Sn()WB 22 Sn( Summary)EA()EH( + + )0 P(This chapter presented a very simple appli)HY(ca)HY(tion)YH( which, never)HY(the)HY(less)YH(, + exer)HY(cised)YH( all of the core database func)HY(tions)YH(: )SM(persist\201\202)ES(, + )SM(query\201\202)ES(, )SM(load\201\202)ES(, )SM(update\201\202)ES(, + and )SM(erase\201\202)ES(. We also saw that writing an appli)HY(ca)HY(tion)YH( + that uses ODB involves the follow)HY(ing)YH( steps:)EP( + + )4 OL( )-1 LI(Declare persis)HY(tent)YH( classes in header files. + )-1 LI(Compile these headers to gener)HY(ate)YH( database support code. + )-1 LI(Link the appli)HY(ca)HY(tion)YH( with the gener)HY(ated)YH( code and two ODB runtime + libraries. + )LO( + + )0 P(Do not be concerned if, at this point, much appears unclear. The intent + of this chapter is to give you only a general idea of how to persist C++ + objects with ODB. We will cover all the details through)HY(out)YH( the remain)HY(der)YH( + of this manual.)EP( + + + + + + )WB NL NP( + )0 1 20 H(3)WB 345 Sn()WB 23 Sn( Working with Persis)HY(tent)YH( Objects)EA()EH( + + )0 P(The previ)HY(ous)YH( chap)HY(ters)YH( gave us a high-level overview of ODB and + showed how to use it to store C++ objects in a database. In this + chapter we will examine the ODB object persis)HY(tence)YH( model as + well as the core database APIs in greater detail. We will + start with basic concepts and termi)HY(nol)HY(ogy)YH( in )0 24 1 A(Section + 3.1)24 0 TN TL()Ec /AF f D( and )0 26 1 A(Section 3.3)26 0 TN TL()Ec /AF f D( and continue with the + discus)HY(sion)YH( of the )SM(odb::database)ES( class in + )0 27 1 A(Section 3.4)27 0 TN TL()Ec /AF f D(, trans)HY(ac)HY(tions)YH( in + )0 28 1 A(Section 3.5)28 0 TN TL()Ec /AF f D(, and connec)HY(tions)YH( in + )0 29 1 A(Section 3.6)29 0 TN TL()Ec /AF f D(. The remain)HY(der)YH( of this chapter + deals with the core database oper)HY(a)HY(tions)YH( and concludes with + the discus)HY(sion)YH( of ODB excep)HY(tions)YH(.)EP( + + )0 P(In this chapter we will continue to use and expand the + )SM(person)ES( persis)HY(tent)YH( class that we have devel)HY(oped)YH( in the + previ)HY(ous)YH( chapter.)EP( + + )0 2 21 H(3.1)WB 346 Sn()WB 24 Sn( Concepts and Termi)HY(nol)HY(ogy)YH()EA()EH( + + )0 P(The term )EM(database)ES( can refer to three distinct things: + a general notion of a place where an appli)HY(ca)HY(tion)YH( stores its data, + a soft)HY(ware)YH( imple)HY(men)HY(ta)HY(tion)YH( for manag)HY(ing)YH( this data \201for example + MySQL\202, and, finally, some database soft)HY(ware)YH( imple)HY(men)HY(ta)HY(tions)YH( + may manage several data stores which are usually distin)HY(guished)YH( + by name. This name is also commonly referred to as a database.)EP( + + )0 P(In this manual, when we use the word )EM(database)ES(, we + refer to the first meaning above, for example, + "The )SM(update\201\202)ES( func)HY(tion)YH( saves the object's state to + the database." The term Database Manage)HY(ment)YH( System \201DBMS\202 is + often used to refer to the second meaning of the word database. + In this manual we will use the term )EM(database system)ES( + for short, for example, "Database system-inde)HY(pen)HY(dent)YH( + appli)HY(ca)HY(tion)YH( code." Finally, to distin)HY(guish)YH( the third meaning + from the other two, we will use the term )EM(database name)ES(, + for example, "The second option spec)HY(i)HY(fies)YH( the database name + that the appli)HY(ca)HY(tion)YH( should use to store its data.")EP( + + )0 P(In C++ there is only one notion of a type and an instance + of a type. For example, a funda)HY(men)HY(tal)YH( type, such as )SM(int)ES(, + is, for the most part, treated the same as a user defined class + type. However, when it comes to persis)HY(tence)YH(, we have to place + certain restric)HY(tions)YH( and require)HY(ments)YH( on certain C++ types that + can be stored in the database. As a result, we divide persis)HY(tent)YH( + C++ types into two groups: )EM(object types)ES( and )EM(value + types)ES(. An instance of an object type is called an )EM(object)ES( + and an instance of a value type \236 a )EM(value)ES(.)EP( + + )0 P(An object is an inde)HY(pen)HY(dent)YH( entity. It can be stored, updated, + and deleted in the database inde)HY(pen)HY(dent)YH( of other objects. + Normally, an object has an iden)HY(ti)HY(fier)YH(, called )EM(object id)ES(, + that is unique among all instances of an object type within a + database. In contrast, a value can only be stored in the database + as part of an object and doesn't have its own unique iden)HY(ti)HY(fier)YH(.)EP( + + )0 P(An object consists of data members which are either values + \201)0 63 1 A(Chapter 7, "Value Types")63 0 TN TL()Ec /AF f D(\202, point)HY(ers)YH( + to other objects \201)0 52 1 A(Chapter 6, "Rela)HY(tion)HY(ships)YH(")52 0 TN TL()Ec /AF f D(\202, or + contain)HY(ers)YH( of values or point)HY(ers)YH( to other objects \201)0 45 1 A(Chapter + 5, "Contain)HY(ers)YH("\202)45 0 TN TL()Ec /AF f D(. Point)HY(ers)YH( to other objects and contain)HY(ers)YH( can + be viewed as special kinds of values since they also can only + be stored in the database as part of an object.)EP( + + )0 P(An object type is a C++ class. Because of this one-to-one + rela)HY(tion)HY(ship)YH(, we will use terms )EM(object type)ES( + and )EM(object class)ES( inter)HY(change)HY(ably)YH(. In contrast, + a value type can be a funda)HY(men)HY(tal)YH( C++ type, such as + )SM(int)ES( or a class type, such as )SM(std::string)ES(. + If a value consists of other values, then it is called a + )EM(compos)HY(ite)YH( value)ES( and its type \236 a + )EM(compos)HY(ite)YH( value type)ES( \201)0 65 1 A(Section 7.2, + "Compos)HY(ite)YH( Value Types")65 0 TN TL()Ec /AF f D(\202. Other)HY(wise)YH(, the value is + called )EM(simple value)ES( and its type \236 a + )EM(simple value type)ES( \201)0 64 1 A(Section 7.1, + "Simple Value Types")64 0 TN TL()Ec /AF f D(\202. Note that the distinc)HY(tion)YH( between + simple and compos)HY(ite)YH( values is concep)HY(tual)YH( rather than + repre)HY(sen)HY(ta)HY(tional)YH(. For example, )SM(std::string)ES( + is a simple value type because concep)HY(tu)HY(ally)YH( string is a + single value even though the repre)HY(sen)HY(ta)HY(tion)YH( of the string + class may contain several data members each of which could be + consid)HY(ered)YH( a value. In fact, the same value type can be + viewed \201and mapped\202 as both simple and compos)HY(ite)YH( by differ)HY(ent)YH( + appli)HY(ca)HY(tions)YH(.)EP( + + )0 P(While not strictly neces)HY(sary)YH( in a purely object-oriented appli)HY(ca)HY(tion)YH(, + prac)HY(ti)HY(cal)YH( consid)HY(er)HY(a)HY(tions)YH( often require us to only load a + subset of an object's data members or a combi)HY(na)HY(tion)YH( of members + from several objects. We may also need to factor out some + compu)HY(ta)HY(tions)YH( to the rela)HY(tional)YH( database instead of perform)HY(ing)YH( + them in the appli)HY(ca)HY(tion)YH('s process. To support such require)HY(ments)YH( + ODB distin)HY(guishes)YH( a third kind of C++ types, called )EM(views)ES( + \201)0 79 1 A(Chapter 10, "Views")79 0 TN TL()Ec /AF f D(\202. An ODB view is a C++ + )SM(class)ES( that embod)HY(ies)YH( a light-weight, read-only + projec)HY(tion)YH( of one or more persis)HY(tent)YH( objects or database + tables or the result of a native SQL query execu)HY(tion)YH(.)EP( + + )0 P(Under)HY(stand)HY(ing)YH( how all these concepts map to the rela)HY(tional)YH( model + will hope)HY(fully)YH( make these distinc)HY(tions)YH( clearer. In a rela)HY(tional)YH( + database an object type is mapped to a table and a value type is + mapped to one or more columns. A simple value type is mapped + to a single column while a compos)HY(ite)YH( value type is mapped to + several columns. An object is stored as a row in this + table and a value is stored as one or more cells in this row. + A simple value is stored in a single cell while a compos)HY(ite)YH( + value occu)HY(pies)YH( several cells. A view is not a persis)HY(tent)YH( + entity and it is not stored in the database. Rather, it is a + data struc)HY(ture)YH( that is used to capture a single row of an SQL + query result.)EP( + + )0 P(Going back to the distinc)HY(tion)YH( between simple and compos)HY(ite)YH( + values, consider a date type which has three integer + members: year, month, and day. In one appli)HY(ca)HY(tion)YH( it can be + consid)HY(ered)YH( a compos)HY(ite)YH( value and each member will get its + own column in a rela)HY(tional)YH( database. In another appli)HY(ca)HY(tion)YH( + it can be consid)HY(ered)YH( a simple value and stored in a single + column as a number of days from some prede)HY(fined)YH( date.)EP( + + )0 P(Until now, we have been using the term )EM(persis)HY(tent)YH( class)ES( + to refer to object classes. We will continue to do so even though + a value type can also be a class. The reason for this asym)HY(me)HY(try)YH( + is the subor)HY(di)HY(nate)YH( nature of value types when it comes to + database oper)HY(a)HY(tions)YH(. Remem)HY(ber)YH( that values are never stored + directly but rather as part of an object that contains them. + As a result, when we say that we want to make a C++ class + persis)HY(tent)YH( or persist an instance of a class in the database, + we invari)HY(ably)YH( refer to an object class rather than a value + class.)EP( + + )0 P(Normally, you would use object types to model real-world enti)HY(ties)YH(, + things that have their own iden)HY(tity)YH(. For example, in the + previ)HY(ous)YH( chapter we created a )SM(person)ES( class to model + a person, which is a real-world entity. Name and age, which we + used as data members in our )SM(person)ES( class are clearly + values. It is hard to think of age 31 or name "Joe" as having their + own iden)HY(ti)HY(ties)YH(.)EP( + + )0 P(A good test to deter)HY(mine)YH( whether some)HY(thing)YH( is an object or + a value, is to consider if other objects might refer)HY(ence)YH( + it. A person is clearly an object because it can be referred + to by other objects such as a spouse, an employer, or a + bank. On the other hand, a person's age or name is not + some)HY(thing)YH( that other objects would normally refer to.)EP( + + )0 P(Also, when an object repre)HY(sents)YH( a real entity, it is easy to + choose a suit)HY(able)YH( object id. For example, for a + person there is an estab)HY(lished)YH( notion of an iden)HY(ti)HY(fier)YH( + \201SSN, student id, pass)HY(port)YH( number, etc\202. Another alter)HY(na)HY(tive)YH( + is to use a person's email address as an iden)HY(ti)HY(fier)YH(.)EP( + + )0 P(Note, however, that these are only guide)HY(lines)YH(. There could + be good reasons to make some)HY(thing)YH( that would normally be + a value an object. Consider, for example, a database that + stores a vast number of people. Many of the )SM(person)ES( + objects in this database have the same names and surnames and + the over)HY(head)YH( of storing them in every object may nega)HY(tively)YH( + affect the perfor)HY(mance)YH(. In this case, we could make the first name + and last name each an object and only store point)HY(ers)YH( to + these objects in the )SM(person)ES( class.)EP( + + )0 P(An instance of a persis)HY(tent)YH( class can be in one of two states: + )EM(tran)HY(sient)YH()ES( and )EM(persis)HY(tent)YH()ES(. A tran)HY(sient)YH( + instance only has a repre)HY(sen)HY(ta)HY(tion)YH( in the appli)HY(ca)HY(tion)YH('s + memory and will cease to exist when the appli)HY(ca)HY(tion)YH( termi)HY(nates)YH(, + unless it is explic)HY(itly)YH( made persis)HY(tent)YH(. In other words, a + tran)HY(sient)YH( instance of a persis)HY(tent)YH( class behaves just like an + instance of any ordi)HY(nary)YH( C++ class. A persis)HY(tent)YH( instance + has a repre)HY(sen)HY(ta)HY(tion)YH( in both the appli)HY(ca)HY(tion)YH('s memory and the + database. A persis)HY(tent)YH( instance will remain even after the + appli)HY(ca)HY(tion)YH( termi)HY(nates)YH( unless and until it is explic)HY(itly)YH( + deleted from the database.)EP( + + )0 2 22 H(3.2)WB 347 Sn()WB 25 Sn( Declar)HY(ing)YH( Persis)HY(tent)YH( Objects and Values)EA()EH( + + )0 P(To make a C++ class a persis)HY(tent)YH( object class we declare + it as such using the )SM(db\240object)ES( pragma, for + example:)EP( + + ) 5 17 PR(#pragma db object +class person +{ + ... +};)RP( + + )0 P(The other pragma that we often use is )SM(db\240id)ES( + which desig)HY(nates)YH( one of the data members as an object id, for + example:)EP( + + ) 8 20 PR(#pragma db object +class person +{ + ... + + #pragma db id + unsigned long id_; +};)RP( + + )0 P(The object id can be of a simple or compos)HY(ite)YH( \201)0 66 1 A(Section + 7.2.1, "Compos)HY(ite)YH( Object Ids")66 0 TN TL()Ec /AF f D(\202 value type. This type should be + default-constructible, copy-constructible, and copy-assignable. It + is also possi)HY(ble)YH( to declare a persis)HY(tent)YH( class without an object id, + however, such a class will have limited func)HY(tion)HY(al)HY(ity)YH( + \201)0 107 1 A(Section 14.1.6, ")SM(no_id)ES(")107 0 TN TL()Ec /AF f D(\202.)EP( + + )0 P(The above two pragmas are the minimum required to declare a + persis)HY(tent)YH( class with an object id. Other pragmas can be used to + fine-tune the database-related prop)HY(er)HY(ties)YH( of a class and its + members \201)0 100 1 A(Chapter 14, "ODB Pragma Language")100 0 TN TL()Ec /AF f D(\202.)EP( + + )0 P(Normally, a persis)HY(tent)YH( class should define the default construc)HY(tor)YH(. The + gener)HY(ated)YH( database support code uses this construc)HY(tor)YH( when + instan)HY(ti)HY(at)HY(ing)YH( an object from the persis)HY(tent)YH( state. If we add the + default construc)HY(tor)YH( only for the database support code, then we + can make it private provided we also make the )SM(odb::access)ES( + class, defined in the )SM()ES( header, a + friend of this object class. For example:)EP( + + ) 11 27 PR(#include + +#pragma db object +class person +{ + ... + +private: + friend class odb::access; + person \201\202 {} +};)RP( + + )0 P(It is also possi)HY(ble)YH( to have an object class without the default + construc)HY(tor)YH(. However, in this case, the database oper)HY(a)HY(tions)YH( will + only be able to load the persis)HY(tent)YH( state into an exist)HY(ing)YH( instance + \201)0 32 1 A(Section 3.9, "Loading Persis)HY(tent)YH( Objects")32 0 TN TL()Ec /AF f D(, + )0 43 1 A(Section 4.4, "Query Result")43 0 TN TL()Ec /AF f D(\202.)EP( + + )0 P(The ODB compiler also needs access to the non-tran)HY(sient)YH( + \201)0 158 1 A(Section 14.4.11, ")SM(tran)HY(sient)YH()ES(")158 0 TN TL()Ec /AF f D(\202 + data members of a persis)HY(tent)YH( class. The ODB compiler can access + such data members directly if they are public. It can also do + so if they are private or protected and the )SM(odb::access)ES( + class is declared a friend of the object type. For example:)EP( + + ) 16 27 PR(#include + +#pragma db object +class person +{ + ... + +private: + friend class odb::access; + person \201\202 {} + + #pragma db id + unsigned long id_; + + std::string name_; +};)RP( + + )0 P(If data members are not acces)HY(si)HY(ble)YH( directly, then the ODB + compiler will try to auto)HY(mat)HY(i)HY(cally)YH( find suit)HY(able)YH( acces)HY(sor)YH( and + modi)HY(fier)YH( func)HY(tions)YH(. To accom)HY(plish)YH( this, the ODB compiler will + try to lookup common acces)HY(sor)YH( and modi)HY(fier)YH( names derived from + the data member name. Specif)HY(i)HY(cally)YH(, for the )SM(name_)ES( + data member in the above example, the ODB compiler will look + for acces)HY(sor)YH( func)HY(tions)YH( with names: )SM(get_name\201\202)ES(, + )SM(getName\201\202)ES(, )SM(getname\201\202)ES(, and just + )SM(name\201\202)ES( as well as for modi)HY(fier)YH( func)HY(tions)YH( with + names: )SM(set_name\201\202)ES(, )SM(setName\201\202)ES(, + )SM(setname\201\202)ES(, and just )SM(name\201\202)ES(. You can + also add support for custom name deriva)HY(tions)YH( with the + )SM(--acces)HY(sor)YH(-regex)ES( and )SM(--modi)HY(fier)YH(-regex)ES( + ODB compiler options. Refer to the + )R1 2 A(ODB + Compiler Command Line Manual)EA( for details on these options. + The follow)HY(ing)YH( example illus)HY(trates)YH( auto)HY(matic)YH( acces)HY(sor)YH( and modi)HY(fier)YH( + discov)HY(ery)YH(:)EP( + + ) 20 62 PR(#pragma db object +class person +{ +public: + person \201\202 {} + + ... + + unsigned long id \201\202 const; + void id \201unsigned long\202; + + const std::string& get_name \201\202 const; + std::string& set_name \201\202; + +private: + #pragma db id + unsigned long id_; // Uses id\201\202 for access. + + std::string name_; // Uses get_name\201\202/set_name\201\202 for access. +};)RP( + + )0 P(Finally, if a data member is not directly acces)HY(si)HY(ble)YH( and the + ODB compiler was unable to discover suit)HY(able)YH( acces)HY(sor)YH( and + modi)HY(fier)YH( func)HY(tions)YH(, then we can provide custom acces)HY(sor)YH( + and modi)HY(fier)YH( expres)HY(sions)YH( using the )SM(db\240get)ES( + and )SM(db\240set)ES( pragmas. For more infor)HY(ma)HY(tion)YH( + on custom acces)HY(sor)YH( and modi)HY(fier)YH( expres)HY(sions)YH( refer to + )0 152 1 A(Section 14.4.5, + ")SM(get)ES(/)SM(set)ES(/)SM(access)ES(")152 0 TN TL()Ec /AF f D(.)EP( + + )0 P(Data members of a persis)HY(tent)YH( class can also be split into + sepa)HY(rately)YH(-loaded and/or sepa)HY(rately)YH(-updated sections. + For more infor)HY(ma)HY(tion)YH( on this func)HY(tion)HY(al)HY(ity)YH(, refer to + )0 74 1 A(Chapter 9, "Sections")74 0 TN TL()Ec /AF f D(.)EP( + + )0 P(You may be wonder)HY(ing)YH( whether we also have to declare value types + as persis)HY(tent)YH(. We don't need to do anything special for simple value + types such as )SM(int)ES( or )SM(std::string)ES( since the + ODB compiler knows how to map them to suit)HY(able)YH( database types and + how to convert between the two. On the other hand, if a simple value + is unknown to the ODB compiler then we will need to provide the + mapping to the database type and, possi)HY(bly)YH(, the code to + convert between the two. For more infor)HY(ma)HY(tion)YH( on how to achieve + this refer to the )SM(db\240type)ES( pragma descrip)HY(tion)YH( + in )0 126 1 A(Section 14.3.1, ")SM(type)ES(")126 0 TN TL()Ec /AF f D(.)EP( + + )0 P(Similar to object classes, compos)HY(ite)YH( value types have to be + explic)HY(itly)YH( declared as persis)HY(tent)YH( using the )SM(db\240value)ES( + pragma, for example:)EP( + + ) 8 21 PR(#pragma db value +class name +{ + ... + + std::string first_; + std::string last_; +};)RP( + + )0 P(Note that a compos)HY(ite)YH( value cannot have a data member desig)HY(nated)YH( + as an object id since, as we have discussed earlier, values do + not have a notion of iden)HY(tity)YH(. A compos)HY(ite)YH( value type also doesn't + have to define the default construc)HY(tor)YH(, unless it is used as an + element of a container. The ODB compiler uses the same mech)HY(a)HY(nisms)YH( + to access data members in compos)HY(ite)YH( value types as in object types. + Compos)HY(ite)YH( value types are discussed in more detail in + )0 65 1 A(Section 7.2, "Compos)HY(ite)YH( Value Types")65 0 TN TL()Ec /AF f D(.)EP( + + )0 2 23 H(3.3)WB 348 Sn()WB 26 Sn( Object and View Point)HY(ers)YH()EA()EH( + + )0 P(As we have seen in the previ)HY(ous)YH( chapter, some database oper)HY(a)HY(tions)YH( + create dynam)HY(i)HY(cally)YH( allo)HY(cated)YH( instances of persis)HY(tent)YH( classes and + return point)HY(ers)YH( to these instances. As we will see in later chap)HY(ters)YH(, + point)HY(ers)YH( are also used to estab)HY(lish)YH( rela)HY(tion)HY(ships)YH( between objects + \201)0 52 1 A(Chapter 6, "Rela)HY(tion)HY(ships)YH(")52 0 TN TL()Ec /AF f D(\202 as well as to cache + persis)HY(tent)YH( objects in a session \201)0 87 1 A(Chapter 11, + "Session")87 0 TN TL()Ec /AF f D(\202. While in most cases you won't need to deal with + point)HY(ers)YH( to views, it is possi)HY(ble)YH( to a obtain a dynam)HY(i)HY(cally)YH( allo)HY(cated)YH( + instance of a view using the )SM(result_iter)HY(a)HY(tor)YH(::load\201\202)ES( + func)HY(tion)YH( \201)0 43 1 A(Section 4.4, "Query Results")43 0 TN TL()Ec /AF f D(\202.)EP( + + )0 P(By default, all these mech)HY(a)HY(nisms)YH( use raw point)HY(ers)YH( to return + objects and views as well as to pass and cache objects. This + is normally suffi)HY(cient)YH( for appli)HY(ca)HY(tions)YH( + that have simple object life)HY(time)YH( require)HY(ments)YH( and do not use sessions + or object rela)HY(tion)HY(ships)YH(. In partic)HY(u)HY(lar)YH(, a dynam)HY(i)HY(cally)YH( allo)HY(cated)YH( object + or view that is returned as a raw pointer from a database oper)HY(a)HY(tion)YH( + can be assigned to a smart pointer of our choice, for example + )SM(std::auto_ptr)ES(, )SM(std::unique_ptr)ES( from C++11, or + )SM(shared_ptr)ES( from TR1, C++11, or Boost.)EP( + + )0 P(However, to avoid any possi)HY(bil)HY(ity)YH( of a mistake, such as forget)HY(ting)YH( + to use a smart pointer for a returned object or view, as well as to + simplify the use of more advanced ODB func)HY(tion)HY(al)HY(ity)YH(, such as sessions + and bidi)HY(rec)HY(tional)YH( object rela)HY(tion)HY(ships)YH(, it is recom)HY(mended)YH( that you use + smart point)HY(ers)YH( with the sharing seman)HY(tics)YH( as object point)HY(ers)YH(. + The )SM(shared_ptr)ES( smart pointer from TR1, C++11, or Boost + is a good default choice. However, if sharing is not required and + sessions are not used, then )SM(std::unique_ptr)ES( or + )SM(std::auto_ptr)ES( can be used just as well.)EP( + + )0 P(ODB provides several mech)HY(a)HY(nisms)YH( for chang)HY(ing)YH( the object or view pointer + type. To specify the pointer type on the per object or per view basis + we can use the )SM(db\240pointer)ES( pragma, for example:)EP( + + ) 5 47 PR(#pragma db object pointer\201std::tr1::shared_ptr\202 +class person +{ + ... +};)RP( + + )0 P(We can also specify the default pointer for a group of objects or + views at the names)HY(pace)YH( level:)EP( + + ) 15 50 PR(#pragma db namespace pointer\201std::tr1::shared_ptr\202 +namespace accounting +{ + #pragma db object + class employee + { + ... + }; + + #pragma db object + class employer + { + ... + }; +})RP( + + )0 P(Finally, we can use the )SM(--default-pointer)ES( option to specify + the default pointer for the whole file. Refer to the + )R1 2 A(ODB + Compiler Command Line Manual)EA( for details on this option's argu)HY(ment)YH(. + The typical usage is shown below:)EP( + + ) 1 38 PR(--default-pointer std::tr1::shared_ptr)RP( + + )0 P(An alter)HY(na)HY(tive)YH( to this method with the same effect is to specify the + default pointer for the global names)HY(pace)YH(:)EP( + + ) 1 52 PR(#pragma db namespace\201\202 pointer\201std::tr1::shared_ptr\202)RP( + + )0 P(Note that we can always over)HY(ride)YH( the default pointer spec)HY(i)HY(fied)YH( + at the names)HY(pace)YH( level or with the command line option using + the )SM(db\240pointer)ES( object or view pragma. For + example:)EP( + + ) 15 44 PR(#pragma db object pointer\201std::shared_ptr\202 +namespace accounting +{ + #pragma db object + class employee + { + ... + }; + + #pragma db object pointer\201std::unique_ptr\202 + class employer + { + ... + }; +})RP( + + )0 P(Refer to )0 103 1 A(Section 14.1.2, ")SM(pointer)ES( + \201object\202")103 0 TN TL()Ec /AF f D(, )0 121 1 A(Section 14.2.4, ")SM(pointer)ES( + \201view\202")121 0 TN TL()Ec /AF f D(, and )0 185 1 A(Section 14.5.1, ")SM(pointer)ES( + \201names)HY(pace)YH(\202")185 0 TN TL()Ec /AF f D( for more infor)HY(ma)HY(tion)YH( on these mech)HY(a)HY(nisms)YH(.)EP( + + )0 P(Built-in support that is provided by the ODB runtime library allows us + to use )SM(shared_ptr)ES( \201TR1 or C++11\202, + )SM(std::unique_ptr)ES( \201C++11\202, or )SM(std::auto_ptr)ES( as + pointer types. Plus, ODB profile libraries, that are avail)HY(able)YH( for + commonly used frame)HY(works)YH( and libraries \201such as Boost and Qt\202, + provide support for smart point)HY(ers)YH( found in these frame)HY(works)YH( and + libraries \201)0 290 1 A(Part III, "Profiles")290 0 TN TL()Ec /AF f D(\202. It is also + easy to add support for our own smart point)HY(ers)YH(, as described in + )0 62 1 A( Section 6.5, "Using Custom Smart Point)HY(ers)YH(")62 0 TN TL()Ec /AF f D(.)EP( + + )0 2 24 H(3.4)WB 349 Sn()WB 27 Sn( Database)EA()EH( + + )0 P(Before an appli)HY(ca)HY(tion)YH( can make use of persis)HY(tence)YH( services + offered by ODB, it has to create a database class instance. A + database instance is the repre)HY(sen)HY(ta)HY(tion)YH( of the place where + the appli)HY(ca)HY(tion)YH( stores its persis)HY(tent)YH( objects. We create + a database instance by instan)HY(ti)HY(at)HY(ing)YH( one of the database + system-specific classes. For example, )SM(odb::mysql::database)ES( + would be such a class for the MySQL database system. We will + also normally pass a database name as an argu)HY(ment)YH( to the + class' construc)HY(tor)YH(. The follow)HY(ing)YH( code frag)HY(ment)YH( + shows how we can create a database instance for the MySQL + database system:)EP( + + ) 9 42 PR(#include +#include + +auto_ptr db \201 + new odb::mysql::database \201 + "test_user" // database login name + "test_password" // database password + "test_database" // database name + \202\202;)RP( + + )0 P(The )SM(odb::database)ES( class is a common inter)HY(face)YH( for + all the database system-specific classes provided by ODB. You + would normally work with the database + instance via this inter)HY(face)YH( unless there is a specific + func)HY(tion)HY(al)HY(ity)YH( that your appli)HY(ca)HY(tion)YH( depends on and which is + only exposed by a partic)HY(u)HY(lar)YH( system's )SM(database)ES( + class. You will need to include the )SM()ES( + header file to make this class avail)HY(able)YH( in your appli)HY(ca)HY(tion)YH(.)EP( + + )0 P(The )SM(odb::database)ES( inter)HY(face)YH( defines func)HY(tions)YH( for + start)HY(ing)YH( trans)HY(ac)HY(tions)YH( and manip)HY(u)HY(lat)HY(ing)YH( persis)HY(tent)YH( objects. + These are discussed in detail in the remain)HY(der)YH( of this chapter + as well as the next chapter which is dedi)HY(cated)YH( to the topic of + query)HY(ing)YH( the database for persis)HY(tent)YH( objects. For details on the + system-specific )SM(database)ES( classes, refer to + )0 204 1 A(Part II, "Database Systems")204 0 TN TL()Ec /AF f D(.)EP( + + )0 P(Before we can persist our objects, the corre)HY(spond)HY(ing)YH( database schema has + to be created in the database. The schema contains table defi)HY(ni)HY(tions)YH( and + other rela)HY(tional)YH( database arti)HY(facts)YH( that are used to store the state of + persis)HY(tent)YH( objects in the database.)EP( + + )0 P(There are several ways to create the database schema. The easiest is to + instruct the ODB compiler to gener)HY(ate)YH( the corre)HY(spond)HY(ing)YH( schema from the + persis)HY(tent)YH( classes \201)SM(--gener)HY(ate)YH(-schema)ES( option\202. The ODB + compiler can gener)HY(ate)YH( the schema as a stan)HY(dalone)YH( SQL file, + embed)HY(ded)YH( into the gener)HY(ated)YH( C++ code, or as a sepa)HY(rate)YH( C++ source file + \201)SM(--schema-format)ES( option\202. If we are using the SQL file + to create the database schema, then this file should be executed, + normally only once, before the appli)HY(ca)HY(tion)YH( is started.)EP( + + )0 P(Alter)HY(na)HY(tively)YH(, if the schema is embed)HY(ded)YH( directly into the gener)HY(ated)YH( + code or produced as a sepa)HY(rate)YH( C++ source file, then we can use the + )SM(odb::schema_catalog)ES( class to create it in the database + from within our appli)HY(ca)HY(tion)YH(, for example:)EP( + + ) 5 41 PR(#include + +odb::transaction t \201db->begin \201\202\202; +odb::schema_catalog::create_schema \201*db\202; +t.commit \201\202;)RP( + + )0 P(Refer to the next section for infor)HY(ma)HY(tion)YH( on the + )SM(odb::trans)HY(ac)HY(tion)YH()ES( class. The complete version of the above + code frag)HY(ment)YH( is avail)HY(able)YH( in the )SM(schema/embed)HY(ded)YH()ES( example in + the )SM(odb-exam)HY(ples)YH()ES( package.)EP( + + )0 P(The )SM(odb::schema_catalog)ES( class has the follow)HY(ing)YH( inter)HY(face)YH(. + You will need to include the )SM()ES( + header file to make this class avail)HY(able)YH( in your appli)HY(ca)HY(tion)YH(.)EP( + + ) 20 58 PR(namespace odb +{ + class schema_catalog + { + public: + static void + create_schema \201database&, + const std::string& name = "", + bool drop = true\202; + + static void + drop_schema \201database&, const std::string& name = ""\202; + + static bool + exists \201database_id, const std::string& name = ""\202; + + static bool + exists \201const database&, const std::string& name = ""\202 + }; +})RP( + + )0 P(The first argu)HY(ment)YH( to the )SM(create_schema\201\202)ES( func)HY(tion)YH( + is the database instance that we would like to create the schema in. + The second argu)HY(ment)YH( is the schema name. By default, the ODB + compiler gener)HY(ates)YH( all embed)HY(ded)YH( schemas with the default schema + name \201empty string\202. However, if your appli)HY(ca)HY(tion)YH( needs to + have several sepa)HY(rate)YH( schemas, you can use the + )SM(--schema-name)ES( ODB compiler option to assign + custom schema names and then use these names as a second argu)HY(ment)YH( + to )SM(create_schema\201\202)ES(. By default, )SM(create_schema\201\202)ES( + will also delete all the database objects \201tables, indexes, etc.\202 if + they exist prior to creat)HY(ing)YH( the new ones. You can change this + behav)HY(ior)YH( by passing )SM(false)ES( as the third argu)HY(ment)YH(. The + )SM(drop_schema\201\202)ES( func)HY(tion)YH( allows you to delete all the + database objects without creat)HY(ing)YH( the new ones.)EP( + + )0 P(If the schema is not found, the )SM(create_schema\201\202)ES( and + )SM(drop_schema\201\202)ES( func)HY(tions)YH( throw the + )SM(odb::unknown_schema)ES( excep)HY(tion)YH(. You can use the + )SM(exists\201\202)ES( func)HY(tion)YH( to check whether a schema for the + spec)HY(i)HY(fied)YH( database and with the spec)HY(i)HY(fied)YH( name exists in the + catalog. Note also that the )SM(create_schema\201\202)ES( and + )SM(drop_schema\201\202)ES( func)HY(tions)YH( should be called within a + trans)HY(ac)HY(tion)YH(.)EP( + + )0 P(ODB also provides support for database schema evolu)HY(tion)YH(. Similar + to schema creation, schema migra)HY(tion)YH( state)HY(ments)YH( can be gener)HY(ated)YH( + either as stan)HY(dalone)YH( SQL files or embed)HY(ded)YH( into the gener)HY(ated)YH( C++ + code. For more infor)HY(ma)HY(tion)YH( on schema evolu)HY(tion)YH( support, refer to + )0 91 1 A(Chapter 13, "Database Schema Evolu)HY(tion)YH(")91 0 TN TL()Ec /AF f D(.)EP( + + )0 P(Finally, we can also use a custom database schema with ODB. This approach + can work simi)HY(larly)YH( to the stan)HY(dalone)YH( SQL file described above except that + the database schema is hand-written or produced by another program. Or we + could execute custom SQL state)HY(ments)YH( that create the schema directly from + our appli)HY(ca)HY(tion)YH(. To map persis)HY(tent)YH( classes to custom database schemas, ODB + provides a wide range of mapping customiza)HY(tion)YH( pragmas, such + as )SM(db\240table)ES(, )SM(db\240column)ES(, + and )SM(db\240type)ES( \201)0 100 1 A(Chapter 14, "ODB Pragma + Language")100 0 TN TL()Ec /AF f D(\202. For sample code that shows how to perform such mapping + for various C++ constructs, refer to the )SM(schema/custom)ES( + example in the )SM(odb-exam)HY(ples)YH()ES( package.)EP( + + )0 2 25 H(3.5)WB 350 Sn()WB 28 Sn( Trans)HY(ac)HY(tions)YH()EA()EH( + + )0 P(A trans)HY(ac)HY(tion)YH( is an atomic, consis)HY(tent)YH(, isolated and durable + \201ACID\202 unit of work. Database oper)HY(a)HY(tions)YH( can only be + performed within a trans)HY(ac)HY(tion)YH( and each thread of execu)HY(tion)YH( + in an appli)HY(ca)HY(tion)YH( can have only one active trans)HY(ac)HY(tion)YH( at a + time.)EP( + + )0 P(By atom)HY(ic)HY(ity)YH( we mean that when it comes to making changes to + the database state within a trans)HY(ac)HY(tion)YH(, + either all the changes are applied or none at all. Consider, + for example, a trans)HY(ac)HY(tion)YH( that trans)HY(fers)YH( funds between two + objects repre)HY(sent)HY(ing)YH( bank accounts. If the debit func)HY(tion)YH( + on the first object succeeds but the credit func)HY(tion)YH( on + the second fails, the trans)HY(ac)HY(tion)YH( is rolled back and the + database state of the first object remains unchanged.)EP( + + )0 P(By consis)HY(tency)YH( we mean that a trans)HY(ac)HY(tion)YH( must take all the + objects stored in the database from one consis)HY(tent)YH( state + to another. For example, if a bank account object must + refer)HY(ence)YH( a person object as its owner and we forget to + set this refer)HY(ence)YH( before making the object persis)HY(tent)YH(, + the trans)HY(ac)HY(tion)YH( will be rolled back and the database + will remain unchanged.)EP( + + )0 P(By isola)HY(tion)YH( we mean that the changes made to the database + state during a trans)HY(ac)HY(tion)YH( are only visible inside this + trans)HY(ac)HY(tion)YH( until and unless it is commit)HY(ted)YH(. Using the + above example with the bank trans)HY(fer)YH(, the results of the + debit oper)HY(a)HY(tion)YH( performed on the first object is not + visible to other trans)HY(ac)HY(tions)YH( until the credit oper)HY(a)HY(tion)YH( + is success)HY(fully)YH( completed and the trans)HY(ac)HY(tion)YH( is commit)HY(ted)YH(.)EP( + + )0 P(By dura)HY(bil)HY(ity)YH( we mean that once the trans)HY(ac)HY(tion)YH( is commit)HY(ted)YH(, + the changes that it made to the database state are perma)HY(nent)YH( + and will survive fail)HY(ures)YH( such as an appli)HY(ca)HY(tion)YH( crash. From + now on the only way to alter this state is to execute and commit + another trans)HY(ac)HY(tion)YH(.)EP( + + )0 P(A trans)HY(ac)HY(tion)YH( is started by calling either the + )SM(database::begin\201\202)ES( or )SM(connec)HY(tion)YH(::begin\201\202)ES( + func)HY(tion)YH(. The returned trans)HY(ac)HY(tion)YH( handle is stored in + an instance of the )SM(odb::trans)HY(ac)HY(tion)YH()ES( class. + You will need to include the )SM()ES( + header file to make this class avail)HY(able)YH( in your appli)HY(ca)HY(tion)YH(. + For example:)EP( + + ) 7 31 PR(#include + +transaction t \201db.begin \201\202\202 + +// Perform database operations. + +t.commit \201\202;)RP( + + )0 P(The )SM(odb::trans)HY(ac)HY(tion)YH()ES( class has the follow)HY(ing)YH( + inter)HY(face)YH(:)EP( + + ) 50 62 PR(namespace odb +{ + class transaction + { + public: + typedef odb::database database_type; + typedef odb::connection connection_type; + + explicit + transaction \201transaction_impl*, bool make_current = true\202; + + transaction \201\202; + + void + reset \201transaction_impl*, bool make_current = true\202; + + void + commit \201\202; + + void + rollback \201\202; + + database_type& + database \201\202; + + connection_type& + connection \201\202; + + bool + finilized \201\202 const; +)WR( + public: + static bool + has_current \201\202; + + static transaction& + current \201\202; + + static void + current \201transaction&\202; + + static bool + reset_current \201\202; + + // Callback API. + // + public: + ... + }; +})RP( + + )0 P(The )SM(commit\201\202)ES( func)HY(tion)YH( commits a trans)HY(ac)HY(tion)YH( and + )SM(roll)HY(back)YH(\201\202)ES( rolls it back. Unless the trans)HY(ac)HY(tion)YH( + has been )EM(final)HY(ized)YH()ES(, that is, explic)HY(itly)YH( commit)HY(ted)YH( or rolled + back, the destruc)HY(tor)YH( of the )SM(trans)HY(ac)HY(tion)YH()ES( class will + auto)HY(mat)HY(i)HY(cally)YH( roll it back when the trans)HY(ac)HY(tion)YH( instance goes + out of scope. If we try to commit or roll back a final)HY(ized)YH( + trans)HY(ac)HY(tion)YH(, the )SM(odb::trans)HY(ac)HY(tion)YH(_already_final)HY(ized)YH()ES( + excep)HY(tion)YH( is thrown.)EP( + + )0 P(The )SM(database\201\202)ES( acces)HY(sor)YH( returns the database this + trans)HY(ac)HY(tion)YH( is working on. Simi)HY(larly)YH(, the )SM(connec)HY(tion)YH(\201\202)ES( + acces)HY(sor)YH( returns the database connec)HY(tion)YH( this trans)HY(ac)HY(tion)YH( is on + \201)0 29 1 A(Section 3.6, "Connec)HY(tions)YH(")29 0 TN TL()Ec /AF f D(\202.)EP( + + )0 P(The static )SM(current\201\202)ES( acces)HY(sor)YH( returns the + currently active trans)HY(ac)HY(tion)YH( for this thread. If there is no active + trans)HY(ac)HY(tion)YH(, this func)HY(tion)YH( throws the )SM(odb::not_in_trans)HY(ac)HY(tion)YH()ES( + excep)HY(tion)YH(. We can check whether there is a trans)HY(ac)HY(tion)YH( in effect in + this thread using the )SM(has_current\201\202)ES( static func)HY(tion)YH(.)EP( + + )0 P(The )SM(make_current)ES( argu)HY(ment)YH( in the )SM(trans)HY(ac)HY(tion)YH()ES( + construc)HY(tor)YH( as well as the static )SM(current\201\202)ES( modi)HY(fier)YH( and + )SM(reset_current\201\202)ES( func)HY(tion)YH( give us addi)HY(tional)YH( + control over the nomi)HY(na)HY(tion)YH( of the currently active trans)HY(ac)HY(tion)YH(. + If we pass )SM(false)ES( as the )SM(make_current)ES( + argu)HY(ment)YH(, then the newly created trans)HY(ac)HY(tion)YH( will not + auto)HY(mat)HY(i)HY(cally)YH( be made the active trans)HY(ac)HY(tion)YH( for this + thread. Later, we can use the static )SM(current\201\202)ES( modi)HY(fier)YH( + to set this trans)HY(ac)HY(tion)YH( as the active trans)HY(ac)HY(tion)YH(. + The )SM(reset_current\201\202)ES( static func)HY(tion)YH( clears the + currently active trans)HY(ac)HY(tion)YH(. Together, these mech)HY(a)HY(nisms)YH( + allow for more advanced use cases, such as multi)HY(plex)HY(ing)YH( + two or more trans)HY(ac)HY(tions)YH( on the same thread. For example:)EP( + + ) 20 68 PR(transaction t1 \201db1.begin \201\202\202; // Active transaction. +transaction t2 \201db2.begin \201\202, false\202; // Not active. + +// Perform database operations on db1. + +transaction::current \201t2\202; // Deactivate t1, activate t2. + +// Perform database operations on db2. + +transaction::current \201t1\202; // Switch back to t1. + +// Perform some more database operations on db1. + +t1.commit \201\202; + +transaction::current \201t2\202; // Switch to t2. + +// Perform some more database operations on db2. + +t2.commit \201\202;)RP( + + )0 P(The )SM(reset\201\202)ES( modi)HY(fier)YH( allows us to reuse the same + )SM(trans)HY(ac)HY(tion)YH()ES( instance to complete several database + trans)HY(ac)HY(tions)YH(. Similar to the destruc)HY(tor)YH(, )SM(reset\201\202)ES( + will roll the current trans)HY(ac)HY(tion)YH( back if it hasn't been final)HY(ized)YH(. + The default )SM(trans)HY(ac)HY(tion)YH()ES( construc)HY(tor)YH( creates a final)HY(ized)YH( + trans)HY(ac)HY(tion)YH( which can later be initial)HY(ized)YH( using )SM(reset\201\202)ES(. + The )SM(finilized\201\202)ES( acces)HY(sor)YH( can be used to check whether the + trans)HY(ac)HY(tion)YH( has been final)HY(ized)YH(. Here is how we can use this func)HY(tion)HY(al)HY(ity)YH( + to commit the current trans)HY(ac)HY(tion)YH( and start a new one every time a + certain number of database oper)HY(a)HY(tions)YH( has been performed:)EP( + + ) 17 61 PR(transaction t \201db.begin \201\202\202; + +for \201size_t i \2010\202; i < n; ++i\202 +{ + // Perform a database operation, such as persist an object. + + // Commit the current transaction and start a new one after + // every 100 operations. + // + if \201i % 100 == 0\202 + { + t.commit \201\202; + t.reset \201db.begin \201\202\202; + } +} + +t.commit \201\202;)RP( + + )0 P(For more infor)HY(ma)HY(tion)YH( on the trans)HY(ac)HY(tion)YH( call)HY(back)YH( support, refer + to )0 201 1 A(Section 15.1, "Trans)HY(ac)HY(tion)YH( Call)HY(backs)YH(")201 0 TN TL()Ec /AF f D(.)EP( + + )0 P(Note that in the above discus)HY(sion)YH( of atom)HY(ic)HY(ity)YH(, consis)HY(tency)YH(, + isola)HY(tion)YH(, and dura)HY(bil)HY(ity)YH(, all of those guar)HY(an)HY(tees)YH( only apply + to the object's state in the database as opposed to the object's + state in the appli)HY(ca)HY(tion)YH('s memory. It is possi)HY(ble)YH( to roll + a trans)HY(ac)HY(tion)YH( back but still have changes from this + trans)HY(ac)HY(tion)YH( in the appli)HY(ca)HY(tion)YH('s memory. An easy way to + avoid this poten)HY(tial)YH( incon)HY(sis)HY(tency)YH( is to instan)HY(ti)HY(ate)YH( + persis)HY(tent)YH( objects only within the trans)HY(ac)HY(tion)YH( scope. Consider, + for example, these two imple)HY(men)HY(ta)HY(tions)YH( of the same trans)HY(ac)HY(tion)YH(:)EP( + + ) 10 36 PR(void +update_age \201database& db, person& p\202 +{ + transaction t \201db.begin \201\202\202; + + p.age \201p.age \201\202 + 1\202; + db.update \201p\202; + + t.commit \201\202; +})RP( + + )0 P(In the above imple)HY(men)HY(ta)HY(tion)YH(, if the )SM(update\201\202)ES( call fails + and the trans)HY(ac)HY(tion)YH( is rolled back, the state of the )SM(person)ES( + object in the database and the state of the same object in the + appli)HY(ca)HY(tion)YH('s memory will differ. Now consider an + alter)HY(na)HY(tive)YH( imple)HY(men)HY(ta)HY(tion)YH( which only instan)HY(ti)HY(ates)YH( the + )SM(person)ES( object for the dura)HY(tion)YH( of the trans)HY(ac)HY(tion)YH(:)EP( + + ) 11 44 PR(void +update_age \201database& db, unsigned long id\202 +{ + transaction t \201db.begin \201\202\202; + + auto_ptr p \201db.load \201id\202\202; + p.age \201p.age \201\202 + 1\202; + db.update \201p\202; + + t.commit \201\202; +})RP( + + )0 P(Of course, it may not always be possi)HY(ble)YH( to write the + appli)HY(ca)HY(tion)YH( in this style. Often)HY(times)YH( we need to access and + modify the appli)HY(ca)HY(tion)YH('s state of persis)HY(tent)YH( objects out of + trans)HY(ac)HY(tions)YH(. In this case it may make sense to try to + roll back the changes made to the appli)HY(ca)HY(tion)YH( state if + the trans)HY(ac)HY(tion)YH( was rolled back and the database state + remains unchanged. One way to do this is to re-load + the object's state from the database, for example:)EP( + + ) 21 36 PR(void +update_age \201database& db, person& p\202 +{ + try + { + transaction t \201db.begin \201\202\202; + + p.age \201p.age \201\202 + 1\202; + db.update \201p\202; + + t.commit \201\202; + } + catch \201...\202 + { + transaction t \201db.begin \201\202\202; + db.load \201p.id \201\202, p\202; + t.commit \201\202; + + throw; + } +})RP( + + )0 P(See also )0 201 1 A(Section 15.1, "Trans)HY(ac)HY(tion)YH( Call)HY(backs)YH(")201 0 TN TL()Ec /AF f D( + for an alter)HY(na)HY(tive)YH( approach.)EP( + + )0 2 26 H(3.6)WB 351 Sn()WB 29 Sn( Connec)HY(tions)YH()EA()EH( + + )0 P(The )SM(odb::connec)HY(tion)YH()ES( class repre)HY(sents)YH( a connec)HY(tion)YH( + to the database. Normally, you wouldn't work with connec)HY(tions)YH( + directly but rather let the ODB runtime obtain and release + connec)HY(tions)YH( as needed. However, certain use cases may require + obtain)HY(ing)YH( a connec)HY(tion)YH( manu)HY(ally)YH(. For complete)HY(ness)YH(, this section + describes the )SM(connec)HY(tion)YH()ES( class and discusses some + of its use cases. You may want to skip this section if you are + reading through the manual for the first time.)EP( + + )0 P(Similar to )SM(odb::database)ES(, the )SM(odb::connec)HY(tion)YH()ES( + class is a common inter)HY(face)YH( for all the database system-specific + classes provided by ODB. For details on the system-specific + )SM(connec)HY(tion)YH()ES( classes, refer to )0 204 1 A(Part II, + "Database Systems")204 0 TN TL()Ec /AF f D(.)EP( + + )0 P(To make the )SM(odb::connec)HY(tion)YH()ES( class avail)HY(able)YH( in your + appli)HY(ca)HY(tion)YH( you will need to include the )SM()ES( + header file. The )SM(odb::connec)HY(tion)YH()ES( class has the + follow)HY(ing)YH( inter)HY(face)YH(:)EP( + + ) 25 57 PR(namespace odb +{ + class connection + { + public: + typedef odb::database database_type; + + transaction + begin \201\202 = 0; + + unsigned long long + execute \201const char* statement\202; + + unsigned long long + execute \201const std::string& statement\202; + + unsigned long long + execute \201const char* statement, std::size_t length\202; + + database_type& + database \201\202; + }; + + typedef details::shared_ptr connection_ptr; +})RP( + + )0 P(The )SM(begin\201\202)ES( func)HY(tion)YH( is used to start a trans)HY(ac)HY(tion)YH( + on the connec)HY(tion)YH(. The )SM(execute\201\202)ES( func)HY(tions)YH( allow + us to execute native database state)HY(ments)YH( on the connec)HY(tion)YH(. + Their seman)HY(tics)YH( are equiv)HY(a)HY(lent)YH( to the )SM(database::execute\201\202)ES( + func)HY(tions)YH( \201)0 35 1 A(Section 3.12, "Execut)HY(ing)YH( Native SQL + State)HY(ments)YH(")35 0 TN TL()Ec /AF f D(\202 except that they can be legally called outside + a trans)HY(ac)HY(tion)YH(. Finally, the )SM(database\201\202)ES( acces)HY(sor)YH( + returns a refer)HY(ence)YH( to the )SM(odb::database)ES( instance + to which this connec)HY(tion)YH( corre)HY(sponds)YH(.)EP( + + )0 P(To obtain a connec)HY(tion)YH( we call the )SM(database::connec)HY(tion)YH(\201\202)ES( + func)HY(tion)YH(. The connec)HY(tion)YH( is returned as )SM(odb::connec)HY(tion)YH(_ptr)ES(, + which is an imple)HY(men)HY(ta)HY(tion)YH(-specific smart pointer with the shared + pointer seman)HY(tics)YH(. This, in partic)HY(u)HY(lar)YH(, means that the connec)HY(tion)YH( + pointer can be copied and returned from func)HY(tions)YH(. Once the last + instance of )SM(connec)HY(tion)YH(_ptr)ES( point)HY(ing)YH( to the same + connec)HY(tion)YH( is destroyed, the connec)HY(tion)YH( is returned to the + )SM(database)ES( instance. The follow)HY(ing)YH( code frag)HY(ment)YH( + shows how we can obtain, use, and release a connec)HY(tion)YH(:)EP( + + ) 20 66 PR(using namespace odb::core; + +database& db = ... +connection_ptr c \201db.connection \201\202\202; + +// Temporarily disable foreign key constraints. +// +c->execute \201"SET FOREIGN_KEY_CHECKS = 0"\202; + +// Start a transaction on this connection. +// +transaction t \201c->begin \201\202\202; +... +t.commit \201\202; + +// Restore foreign key constraints. +// +c->execute \201"SET FOREIGN_KEY_CHECKS = 1"\202; + +// When 'c' goes out of scope, the connection is returned to 'db'.)RP( + + )0 P(Some of the use cases which may require direct manip)HY(u)HY(la)HY(tion)YH( of + connec)HY(tions)YH( include out-of-trans)HY(ac)HY(tion)YH( state)HY(ment)YH( execu)HY(tion)YH(, + such as the execu)HY(tion)YH( of connec)HY(tion)YH( config)HY(u)HY(ra)HY(tion)YH( state)HY(ments)YH(, + the imple)HY(men)HY(ta)HY(tion)YH( of a connec)HY(tion)YH(-per-thread policy, and making + sure that a set of trans)HY(ac)HY(tions)YH( is executed on the same + connec)HY(tion)YH(.)EP( + + )0 2 27 H(3.7)WB 352 Sn()WB 30 Sn( Error Handling and Recov)HY(ery)YH()EA()EH( + + )0 P(ODB uses C++ excep)HY(tions)YH( to report database oper)HY(a)HY(tion)YH( errors. Most + ODB excep)HY(tions)YH( signify )EM(hard)ES( errors or errors that cannot + be corrected without some inter)HY(ven)HY(tion)YH( from the appli)HY(ca)HY(tion)YH(. + For example, if we try to load an object with an unknown object + id, the )SM(odb::object_not_persis)HY(tent)YH()ES( excep)HY(tion)YH( is + thrown. Our appli)HY(ca)HY(tion)YH( may be able to correct this error, for + instance, by obtain)HY(ing)YH( a valid object id and trying again. + The hard errors and corre)HY(spond)HY(ing)YH( ODB excep)HY(tions)YH( that can be + thrown by each database func)HY(tion)YH( are described in the remain)HY(der)YH( + of this chapter with )0 37 1 A(Section 3.14, "ODB Excep)HY(tions)YH(")37 0 TN TL()Ec /AF f D( + provid)HY(ing)YH( a quick refer)HY(ence)YH( for all the ODB excep)HY(tions)YH(.)EP( + + )0 P(The second group of ODB excep)HY(tions)YH( signify )EM(soft)ES( or + )EM(recov)HY(er)HY(able)YH()ES( errors. Such errors are tempo)HY(rary)YH( + fail)HY(ures)YH( which normally can be corrected by simply re-execut)HY(ing)YH( + the trans)HY(ac)HY(tion)YH(. ODB defines three such excep)HY(tions)YH(: + )SM(odb::connec)HY(tion)YH(_lost)ES(, )SM(odb::timeout)ES(, + and )SM(odb::dead)HY(lock)YH()ES(. All recov)HY(er)HY(able)YH( ODB excep)HY(tions)YH( + are derived from the common )SM(odb::recov)HY(er)HY(able)YH()ES( base + excep)HY(tion)YH( which can be used to handle all the recov)HY(er)HY(able)YH( + condi)HY(tions)YH( with a single )SM(catch)ES( block.)EP( + + )0 P(The )SM(odb::connec)HY(tion)YH(_lost)ES( excep)HY(tion)YH( is thrown if + a connec)HY(tion)YH( to the database is lost in the middle of + a trans)HY(ac)HY(tion)YH(. In this situ)HY(a)HY(tion)YH( the trans)HY(ac)HY(tion)YH( is aborted but + it can be re-tried without any changes. Simi)HY(larly)YH(, the + )SM(odb::timeout)ES( excep)HY(tion)YH( is thrown if one of the + database oper)HY(a)HY(tions)YH( or the whole trans)HY(ac)HY(tion)YH( has timed out. + Again, in this case the trans)HY(ac)HY(tion)YH( is aborted but can be + re-tried as is.)EP( + + )0 P(If two or more trans)HY(ac)HY(tions)YH( access or modify more than one object + and are executed concur)HY(rently)YH( by differ)HY(ent)YH( appli)HY(ca)HY(tions)YH( or by + differ)HY(ent)YH( threads within the same appli)HY(ca)HY(tion)YH(, then it is possi)HY(ble)YH( + that these trans)HY(ac)HY(tions)YH( will try to access objects in an incom)HY(pat)HY(i)HY(ble)YH( + order and dead)HY(lock)YH(. The canon)HY(i)HY(cal)YH( example of a dead)HY(lock)YH( are + two trans)HY(ac)HY(tions)YH( in which the first has modi)HY(fied)YH( )SM(object1)ES( + and is waiting for the second trans)HY(ac)HY(tion)YH( to commit its changes to + )SM(object2)ES( so that it can also update )SM(object2)ES(. + At the same time the second trans)HY(ac)HY(tion)YH( has modi)HY(fied)YH( )SM(object2)ES( + and is waiting for the first trans)HY(ac)HY(tion)YH( to commit its changes to + )SM(object1)ES( because it also needs to modify )SM(object1)ES(. + As a result, none of the two trans)HY(ac)HY(tions)YH( can be completed.)EP( + + )0 P(The database system detects such situ)HY(a)HY(tions)YH( and auto)HY(mat)HY(i)HY(cally)YH( + aborts the waiting oper)HY(a)HY(tion)YH( in one of the dead)HY(locked)YH( trans)HY(ac)HY(tions)YH(. + In ODB this trans)HY(lates)YH( to the )SM(odb::dead)HY(lock)YH()ES( + recov)HY(er)HY(able)YH( excep)HY(tion)YH( being thrown from one of the database func)HY(tions)YH(.)EP( + + )0 P(The follow)HY(ing)YH( code frag)HY(ment)YH( shows how to handle the recov)HY(er)HY(able)YH( + excep)HY(tions)YH( by restart)HY(ing)YH( the affected trans)HY(ac)HY(tion)YH(:)EP( + + ) 21 53 PR(const unsigned short max_retries = 5; + +for \201unsigned short retry_count \2010\202; ; retry_count++\202 +{ + try + { + transaction t \201db.begin \201\202\202; + + ... + + t.commit \201\202; + break; + } + catch \201const odb::recoverable& e\202 + { + if \201retry_count > max_retries\202 + throw retry_limit_exceeded \201e.what \201\202\202; + else + continue; + } +})RP( + + )0 2 28 H(3.8)WB 353 Sn()WB 31 Sn( Making Objects Persis)HY(tent)YH()EA()EH( + + )0 P(A newly created instance of a persis)HY(tent)YH( class is tran)HY(sient)YH(. + We use the )SM(database::persist\201\202)ES( func)HY(tion)YH( template + to make a tran)HY(sient)YH( instance persis)HY(tent)YH(. This func)HY(tion)YH( has four + over)HY(loaded)YH( versions with the follow)HY(ing)YH( signa)HY(tures)YH(:)EP( + + ) 15 63 PR( template + typename object_traits::id_type + persist \201const T& object\202; + + template + typename object_traits::id_type + persist \201const object_traits::const_pointer_type& object\202; + + template + typename object_traits::id_type + persist \201T& object\202; + + template + typename object_traits::id_type + persist \201const object_traits::pointer_type& object\202;)RP( + + )0 P(Here and in the rest of the manual, + )SM(object_traits::pointer_type)ES( and + )SM(object_traits::const_pointer_type)ES( denote the + unre)HY(stricted)YH( and constant object pointer types \201)0 26 1 A(Section + 3.3, "Object and View Point)HY(ers)YH(")26 0 TN TL()Ec /AF f D(\202, respec)HY(tively)YH(. + Simi)HY(larly)YH(, )SM(object_traits::id_type)ES( denotes the object + id type. The )SM(odb::object_traits)ES( template is part of the + database support code gener)HY(ated)YH( by the ODB compiler.)EP( + + )0 P(The first )SM(persist\201\202)ES( func)HY(tion)YH( expects a constant refer)HY(ence)YH( + to an instance being persisted. The second func)HY(tion)YH( expects a constant + object pointer. Both of these func)HY(tions)YH( can only be used on objects with + appli)HY(ca)HY(tion)YH(-assigned object ids \201)0 149 1 A(Section 14.4.2, + ")SM(auto)ES(")149 0 TN TL()Ec /AF f D(\202.)EP( + + )0 P(The second and third )SM(persist\201\202)ES( func)HY(tions)YH( are similar to the + first two except that they operate on unre)HY(stricted)YH( refer)HY(ences)YH( and object + point)HY(ers)YH(. If the iden)HY(ti)HY(fier)YH( of the object being persisted is assigned + by the database, these func)HY(tions)YH( update the id member of the passed + instance with the assigned value. All four func)HY(tions)YH( return the object + id of the newly persisted object.)EP( + + )0 P(If the database already contains an object of this type with this + iden)HY(ti)HY(fier)YH(, the )SM(persist\201\202)ES( func)HY(tions)YH( throw the + )SM(odb::object_already_persis)HY(tent)YH()ES( excep)HY(tion)YH(. This should + never happen for database-assigned object ids as long as the + number of objects persisted does not exceed the value space of + the id type.)EP( + + )0 P(When calling the )SM(persist\201\202)ES( func)HY(tions)YH(, we don't need to + explic)HY(itly)YH( specify the template type since it will be auto)HY(mat)HY(i)HY(cally)YH( + deduced from the argu)HY(ment)YH( being passed. The follow)HY(ing)YH( example shows + how we can call these func)HY(tions)YH(:)EP( + + ) 11 57 PR(person john \201"John", "Doe", 33\202; +shared_ptr jane \201new person \201"Jane", "Doe", 32\202\202; + +transaction t \201db.begin \201\202\202; + +db.persist \201john\202; +unsigned long jane_id \201db.persist \201jane\202\202; + +t.commit \201\202; + +cerr << "Jane's id: " << jane_id << endl;)RP( + + )0 P(Notice that in the above code frag)HY(ment)YH( we have created instances + that we were plan)HY(ning)YH( to make persis)HY(tent)YH( before start)HY(ing)YH( the + trans)HY(ac)HY(tion)YH(. Like)HY(wise)YH(, we printed Jane's id after we have commit)HY(ted)YH( + the trans)HY(ac)HY(tion)YH(. As a general rule, you should avoid perform)HY(ing)YH( + oper)HY(a)HY(tions)YH( within the trans)HY(ac)HY(tion)YH( scope that can be performed + before the trans)HY(ac)HY(tion)YH( starts or after it termi)HY(nates)YH(. An active + trans)HY(ac)HY(tion)YH( consumes both your appli)HY(ca)HY(tion)YH('s resources, such as + a database connec)HY(tion)YH(, as well as the database server's + resources, such as object locks. By follow)HY(ing)YH( the above rule you + make sure these resources are released and made avail)HY(able)YH( to other + threads in your appli)HY(ca)HY(tion)YH( and to other appli)HY(ca)HY(tions)YH( as soon as + possi)HY(ble)YH(.)EP( + + )0 P(Some database systems support persist)HY(ing)YH( multi)HY(ple)YH( objects with a + single under)HY(ly)HY(ing)YH( state)HY(ment)YH( execu)HY(tion)YH( which can result in signif)HY(i)HY(cantly)YH( + improved perfor)HY(mance)YH(. For such database systems ODB provides + bulk )SM(persist\201\202)ES( func)HY(tions)YH(. For details, refer to + )0 203 1 A(Section 15.3, "Bulk Database Oper)HY(a)HY(tions)YH(")203 0 TN TL()Ec /AF f D(.)EP( + + )0 2 29 H(3.9)WB 354 Sn()WB 32 Sn( Loading Persis)HY(tent)YH( Objects)EA()EH( + + )0 P(Once an object is made persis)HY(tent)YH(, and you know its object id, it + can be loaded by the appli)HY(ca)HY(tion)YH( using the )SM(database::load\201\202)ES( + func)HY(tion)YH( template. This func)HY(tion)YH( has two over)HY(loaded)YH( versions with + the follow)HY(ing)YH( signa)HY(tures)YH(:)EP( + + ) 7 65 PR( template + typename object_traits::pointer_type + load \201const typename object_traits::id_type& id\202; + + template + void + load \201const typename object_traits::id_type& id, T& object\202;)RP( + + )0 P(Given an object id, the first func)HY(tion)YH( allo)HY(cates)YH( a new instance + of the object class in the dynamic memory, loads its state from + the database, and returns the pointer to the new instance. The + second func)HY(tion)YH( loads the object's state into an exist)HY(ing)YH( instance. + Both func)HY(tions)YH( throw )SM(odb::object_not_persis)HY(tent)YH()ES( if + there is no object of this type with this id in the database.)EP( + + )0 P(When we call the first )SM(load\201\202)ES( func)HY(tion)YH(, we need to + explic)HY(itly)YH( specify the object type. We don't need to do this for + the second func)HY(tion)YH( because the object type will be auto)HY(mat)HY(i)HY(cally)YH( + deduced from the second argu)HY(ment)YH(, for example:)EP( + + ) 7 50 PR(transaction t \201db.begin \201\202\202; + +auto_ptr jane \201db.load \201jane_id\202\202; + +db.load \201jane_id, *jane\202; + +t.commit \201\202;)RP( + + )0 P(In certain situ)HY(a)HY(tions)YH( it may be neces)HY(sary)YH( to reload the state + of an object from the database. While this is easy to achieve + using the second )SM(load\201\202)ES( func)HY(tion)YH(, ODB provides + the )SM(database::reload\201\202)ES( func)HY(tion)YH( template that + has a number of special prop)HY(er)HY(ties)YH(. This func)HY(tion)YH( has two + over)HY(loaded)YH( versions with the follow)HY(ing)YH( signa)HY(tures)YH(:)EP( + + ) 7 56 PR( template + void + reload \201T& object\202; + + template + void + reload \201const object_traits::pointer_type& object\202;)RP( + + )0 P(The first )SM(reload\201\202)ES( func)HY(tion)YH( expects an object + refer)HY(ence)YH(, while the second expects an object pointer. Both + func)HY(tions)YH( expect the id member in the passed object to contain + a valid object iden)HY(ti)HY(fier)YH( and, similar to )SM(load\201\202)ES(, + both will throw )SM(odb::object_not_persis)HY(tent)YH()ES( if + there is no object of this type with this id in the database.)EP( + + )0 P(The first special prop)HY(erty)YH( of )SM(reload\201\202)ES( + compared to the )SM(load\201\202)ES( func)HY(tion)YH( is that it + does not inter)HY(act)YH( with the session's object cache + \201)0 88 1 A(Section 11.1, "Object Cache")88 0 TN TL()Ec /AF f D(\202. That is, if + the object being reloaded is already in the cache, then it will + remain there after )SM(reload\201\202)ES( returns. Simi)HY(larly)YH(, if the + object is not in the cache, then )SM(reload\201\202)ES( won't + put it there either.)EP( + + )0 P(The second special prop)HY(erty)YH( of the )SM(reload\201\202)ES( func)HY(tion)YH( + only mani)HY(fests)YH( itself when oper)HY(at)HY(ing)YH( on an object with the opti)HY(mistic)YH( + concur)HY(rency)YH( model. In this case, if the states of the object + in the appli)HY(ca)HY(tion)YH( memory and in the database are the same, then + no reload)HY(ing)YH( will occur. For more infor)HY(ma)HY(tion)YH( on opti)HY(mistic)YH( + concur)HY(rency)YH(, refer to )0 90 1 A(Chapter 12, "Opti)HY(mistic)YH( + Concur)HY(rency)YH(")90 0 TN TL()Ec /AF f D(.)EP( + + )0 P(If we don't know for sure whether an object with a given id + is persis)HY(tent)YH(, we can use the )SM(find\201\202)ES( func)HY(tion)YH( + instead of )SM(load\201\202)ES(, for example:)EP( + + ) 7 65 PR( template + typename object_traits::pointer_type + find \201const typename object_traits::id_type& id\202; + + template + bool + find \201const typename object_traits::id_type& id, T& object\202;)RP( + + )0 P(If an object with this id is not found in the database, the first + )SM(find\201\202)ES( func)HY(tion)YH( returns a )SM(NULL)ES( pointer + while the second func)HY(tion)YH( leaves the passed instance unmod)HY(i)HY(fied)YH( and + returns )SM(false)ES(.)EP( + + )0 P(If we don't know the object id, then we can use queries to + find the object \201or objects\202 match)HY(ing)YH( some crite)HY(ria)YH( + \201)0 38 1 A(Chapter 4, "Query)HY(ing)YH( the Database")38 0 TN TL()Ec /AF f D(\202. Note, + however, that loading an object's state using its + iden)HY(ti)HY(fier)YH( can be signif)HY(i)HY(cantly)YH( faster than execut)HY(ing)YH( a query.)EP( + + + )0 2 30 H(3.10)WB 355 Sn()WB 33 Sn( Updat)HY(ing)YH( Persis)HY(tent)YH( Objects)EA()EH( + + )0 P(If a persis)HY(tent)YH( object has been modi)HY(fied)YH(, we can store the updated + state in the database using the )SM(database::update\201\202)ES( + func)HY(tion)YH( template. This func)HY(tion)YH( has three over)HY(loaded)YH( versions with + the follow)HY(ing)YH( signa)HY(tures)YH(:)EP( + + ) 11 62 PR( template + void + update \201const T& object\202; + + template + void + update \201const object_traits::const_pointer_type& object\202; + + template + void + update \201const object_traits::pointer_type& object\202;)RP( + + )0 P(The first )SM(update\201\202)ES( func)HY(tion)YH( expects an object refer)HY(ence)YH(, + while the other two expect object point)HY(ers)YH(. If the object passed to + one of these func)HY(tions)YH( does not exist in the database, + )SM(update\201\202)ES( throws the )SM(odb::object_not_persis)HY(tent)YH()ES( + excep)HY(tion)YH( \201but see a note on opti)HY(mistic)YH( concur)HY(rency)YH( below\202.)EP( + + )0 P(Below is an example of the funds trans)HY(fer)YH( that we talked about + in the earlier section on trans)HY(ac)HY(tions)YH(. It uses the hypo)HY(thet)HY(i)HY(cal)YH( + )SM(bank_account)ES( persis)HY(tent)YH( class:)EP( + + ) 25 42 PR(void +transfer \201database& db, + unsigned long from_acc, + unsigned long to_acc, + unsigned int amount\202 +{ + bank_account from, to; + + transaction t \201db.begin \201\202\202; + + db.load \201from_acc, from\202; + + if \201from.balance \201\202 < amount\202 + throw insufficient_funds \201\202; + + db.load \201to_acc, to\202; + + to.balance \201to.balance \201\202 + amount\202; + from.balance \201from.balance \201\202 - amount\202; + + db.update \201to\202; + db.update \201from\202; + + t.commit \201\202; +})RP( + + )0 P(The same can be accom)HY(plished)YH( using dynam)HY(i)HY(cally)YH( allo)HY(cated)YH( objects + and the )SM(update\201\202)ES( func)HY(tion)YH( with object pointer argu)HY(ment)YH(, + for example:)EP( + + ) 16 65 PR(transaction t \201db.begin \201\202\202; + +shared_ptr from \201db.load \201from_acc\202\202; + +if \201from->balance \201\202 < amount\202 + throw insufficient_funds \201\202; + +shared_ptr to \201db.load \201to_acc\202\202; + +to->balance \201to->balance \201\202 + amount\202; +from->balance \201from->balance \201\202 - amount\202; + +db.update \201to\202; +db.update \201from\202; + +t.commit \201\202;)RP( + + )0 P(If any of the )SM(update\201\202)ES( func)HY(tions)YH( are oper)HY(at)HY(ing)YH( on a + persis)HY(tent)YH( class with the opti)HY(mistic)YH( concur)HY(rency)YH( model, then they will + throw the )SM(odb::object_changed)ES( excep)HY(tion)YH( if the state of the + object in the database has changed since it was last loaded into the + appli)HY(ca)HY(tion)YH( memory. Further)HY(more)YH(, for such classes, )SM(update\201\202)ES( + no longer throws the )SM(object_not_persis)HY(tent)YH()ES( excep)HY(tion)YH( if + there is no such object in the database. Instead, this condi)HY(tion)YH( is + treated as a change of object state and )SM(object_changed)ES( + is thrown instead. For a more detailed discus)HY(sion)YH( of opti)HY(mistic)YH( + concur)HY(rency)YH(, refer to )0 90 1 A(Chapter 12, "Opti)HY(mistic)YH( + Concur)HY(rency)YH(")90 0 TN TL()Ec /AF f D(.)EP( + + )0 P(In ODB, persis)HY(tent)YH( classes, compos)HY(ite)YH( value types, as well as indi)HY(vid)HY(ual)YH( + data members can be declared read-only \201see )0 105 1 A(Section + 14.1.4, ")SM(read)HY(only)YH()ES( \201object\202")105 0 TN TL()Ec /AF f D(, )0 131 1 A(Section + 14.3.6, ")SM(read)HY(only)YH()ES( \201compos)HY(ite)YH( value\202")131 0 TN TL()Ec /AF f D(, and + )0 159 1 A(Section 14.4.12, ")SM(read)HY(only)YH()ES( + \201data member\202")159 0 TN TL()Ec /AF f D(\202.)EP( + + )0 P(If an indi)HY(vid)HY(ual)YH( data member is declared read-only, then + any changes to this member will be ignored when updat)HY(ing)YH( the database + state of an object using any of the above )SM(update\201\202)ES( + func)HY(tions)YH(. A )SM(const)ES( data member is auto)HY(mat)HY(i)HY(cally)YH( treated + as read-only. If a compos)HY(ite)YH( value is declared read-only then all its + data members are treated as read-only.)EP( + + )0 P(If the whole object is declared read-only then the database state of + this object cannot be changed. Calling any of the above + )SM(update\201\202)ES( func)HY(tions)YH( for such an object will result in a + compile-time error.)EP( + + )0 P(Similar to )SM(persist\201\202)ES(, for database systems that support + this func)HY(tion)HY(al)HY(ity)YH(, ODB provides bulk )SM(update\201\202)ES( func)HY(tions)YH(. + For details, refer to )0 203 1 A(Section 15.3, "Bulk Database + Oper)HY(a)HY(tions)YH(")203 0 TN TL()Ec /AF f D(.)EP( + + )0 2 31 H(3.11)WB 356 Sn()WB 34 Sn( Delet)HY(ing)YH( Persis)HY(tent)YH( Objects)EA()EH( + + )0 P(To delete a persis)HY(tent)YH( object's state from the database we use the + )SM(database::erase\201\202)ES( or )SM(database::erase_query\201\202)ES( + func)HY(tion)YH( templates. If the appli)HY(ca)HY(tion)YH( still has an instance of the + erased object, this instance becomes tran)HY(sient)YH(. The )SM(erase\201\202)ES( + func)HY(tion)YH( has the follow)HY(ing)YH( over)HY(loaded)YH( versions:)EP( + + ) 15 61 PR( template + void + erase \201const T& object\202; + + template + void + erase \201const object_traits::const_pointer_type& object\202; + + template + void + erase \201const object_traits::pointer_type& object\202; + + template + void + erase \201const typename object_traits::id_type& id\202;)RP( + + )0 P(The first )SM(erase\201\202)ES( func)HY(tion)YH( uses an object itself, in + the form of an object refer)HY(ence)YH(, to delete its state from the + database. The next two func)HY(tions)YH( accom)HY(plish)YH( the same result but using + object point)HY(ers)YH(. Note that all three func)HY(tions)YH( leave the passed + object unchanged. It simply becomes tran)HY(sient)YH(. The last func)HY(tion)YH( + uses the object id to iden)HY(tify)YH( the object to be deleted. If the + object does not exist in the database, then all four func)HY(tions)YH( + throw the )SM(odb::object_not_persis)HY(tent)YH()ES( excep)HY(tion)YH( + \201but see a note on opti)HY(mistic)YH( concur)HY(rency)YH( below\202.)EP( + + )0 P(We have to specify the object type when calling the last + )SM(erase\201\202)ES( func)HY(tion)YH(. The same is unnec)HY(es)HY(sary)YH( for the + first three func)HY(tions)YH( because the object type will be auto)HY(mat)HY(i)HY(cally)YH( + deduced from their argu)HY(ments)YH(. The follow)HY(ing)YH( example shows how we + can call these func)HY(tions)YH(:)EP( + + ) 11 28 PR(person& john = ... +shared_ptr jane = ... +unsigned long joe_id = ... + +transaction t \201db.begin \201\202\202; + +db.erase \201john\202; +db.erase \201jane\202; +db.erase \201joe_id\202; + +t.commit \201\202;)RP( + + )0 P(If any of the )SM(erase\201\202)ES( func)HY(tions)YH( except the last one are + oper)HY(at)HY(ing)YH( on a persis)HY(tent)YH( class with the opti)HY(mistic)YH( concur)HY(rency)YH( + model, then they will throw the )SM(odb::object_changed)ES( excep)HY(tion)YH( + if the state of the object in the database has changed since it was + last loaded into the appli)HY(ca)HY(tion)YH( memory. Further)HY(more)YH(, for such + classes, )SM(erase\201\202)ES( no longer throws the + )SM(object_not_persis)HY(tent)YH()ES( excep)HY(tion)YH( if there is no such + object in the database. Instead, this condi)HY(tion)YH( is treated as a + change of object state and )SM(object_changed)ES( is thrown + instead. For a more detailed discus)HY(sion)YH( of opti)HY(mistic)YH( concur)HY(rency)YH(, + refer to )0 90 1 A(Chapter 12, "Opti)HY(mistic)YH( Concur)HY(rency)YH(")90 0 TN TL()Ec /AF f D(.)EP( + + )0 P(Similar to )SM(persist\201\202)ES( and )SM(update\201\202)ES(, for + database systems that support this func)HY(tion)HY(al)HY(ity)YH(, ODB provides + bulk )SM(erase\201\202)ES( func)HY(tions)YH(. For details, refer to + )0 203 1 A(Section 15.3, "Bulk Database Oper)HY(a)HY(tions)YH(")203 0 TN TL()Ec /AF f D(.)EP( + + )0 P(The )SM(erase_query\201\202)ES( func)HY(tion)YH( allows us to delete + the state of multi)HY(ple)YH( objects match)HY(ing)YH( certain crite)HY(ria)YH(. It uses + the query expres)HY(sion)YH( of the )SM(database::query\201\202)ES( func)HY(tion)YH( + \201)0 38 1 A(Chapter 4, "Query)HY(ing)YH( the Database")38 0 TN TL()Ec /AF f D(\202 and, + because the ODB query facil)HY(ity)YH( is optional, it is only avail)HY(able)YH( + if the )SM(--gener)HY(ate)YH(-query)ES( ODB compiler option was + spec)HY(i)HY(fied)YH(. The )SM(erase_query\201\202)ES( func)HY(tion)YH( has the + follow)HY(ing)YH( over)HY(loaded)YH( versions:)EP( + + ) 7 37 PR( template + unsigned long long + erase_query \201\202; + + template + unsigned long long + erase_query \201const odb::query&\202;)RP( + + )0 P(The first )SM(erase_query\201\202)ES( func)HY(tion)YH( is used to delete + the state of all the persis)HY(tent)YH( objects of a given type stored + in the database. The second func)HY(tion)YH( uses the passed query instance + to only delete the state of objects match)HY(ing)YH( the query crite)HY(ria)YH(. + Both func)HY(tions)YH( return the number of objects erased. When calling + the )SM(erase_query\201\202)ES( func)HY(tion)YH(, we have to explic)HY(itly)YH( + specify the object type we are erasing. For example:)EP( + + ) 7 65 PR(typedef odb::query query; + +transaction t \201db.begin \201\202\202; + +db.erase_query \201query::last == "Doe" && query::age < 30\202; + +t.commit \201\202;)RP( + + )0 P(Unlike the )SM(query\201\202)ES( func)HY(tion)YH(, when calling + )SM(erase_query\201\202)ES( we cannot use members from pointed-to + objects in the query expres)HY(sion)YH(. However, we can still use + a member corre)HY(spond)HY(ing)YH( to a pointer as an ordi)HY(nary)YH( object + member that has the id type of the pointed-to object + \201)0 52 1 A(Chapter 6, "Rela)HY(tion)HY(ships)YH(")52 0 TN TL()Ec /AF f D(\202. This allows us + to compare object ids as well as test the pointer for + )SM(NULL)ES(. As an example, the follow)HY(ing)YH( trans)HY(ac)HY(tion)YH( + makes sure that all the )SM(employee)ES( objects that + refer)HY(ence)YH( an )SM(employer)ES( object that is about to + be deleted are deleted as well. Here we assume that the + )SM(employee)ES( class contains a pointer to the + )SM(employer)ES( class. Refer to )0 52 1 A(Chapter 6, + "Rela)HY(tion)HY(ships)YH(")52 0 TN TL()Ec /AF f D( for complete defi)HY(ni)HY(tions)YH( of these + classes.)EP( + + ) 10 54 PR(typedef odb::query query; + +transaction t \201db.begin \201\202\202; + +employer& e = ... // Employer object to be deleted. + +db.erase_query \201query::employer == e.id \201\202\202; +db.erase \201e\202; + +t.commit \201\202;)RP( + + + )0 2 32 H(3.12)WB 357 Sn()WB 35 Sn( Execut)HY(ing)YH( Native SQL State)HY(ments)YH()EA()EH( + + )0 P(In some situ)HY(a)HY(tions)YH( we may need to execute native SQL state)HY(ments)YH( + instead of using the object-oriented database API described above. + For example, we may want to tune the database schema gener)HY(ated)YH( + by the ODB compiler or take advan)HY(tage)YH( of a feature that is + specific to the database system we are using. The + )SM(database::execute\201\202)ES( func)HY(tion)YH(, which has three + over)HY(loaded)YH( versions, provides this func)HY(tion)HY(al)HY(ity)YH(:)EP( + + ) 8 53 PR( unsigned long long + execute \201const char* statement\202; + + unsigned long long + execute \201const std::string& statement\202; + + unsigned long long + execute \201const char* statement, std::size_t length\202)RP( + + )0 P(The first )SM(execute\201\202)ES( func)HY(tion)YH( expects the SQL state)HY(ment)YH( + as a zero-termi)HY(nated)YH( C-string. The last version expects the explicit + state)HY(ment)YH( length as the second argu)HY(ment)YH( and the state)HY(ment)YH( itself + may contain )SM('\2000')ES( char)HY(ac)HY(ters)YH(, for example, to repre)HY(sent)YH( + binary data, if the database system supports it. All three func)HY(tions)YH( + return the number of rows that were affected by the state)HY(ment)YH(. For + example:)EP( + + ) 6 53 PR(transaction t \201db.begin \201\202\202; + +db.execute \201"DROP TABLE test"\202; +db.execute \201"CREATE TABLE test \201n INT PRIMARY KEY\202"\202; + +t.commit \201\202;)RP( + + )0 P(While these func)HY(tions)YH( must always be called within a trans)HY(ac)HY(tion)YH(, + it may be neces)HY(sary)YH( to execute a native state)HY(ment)YH( outside a + trans)HY(ac)HY(tion)YH(. This can be done using the + )SM(connec)HY(tion)YH(::execute\201\202)ES( func)HY(tions)YH( as described in + )0 29 1 A(Section 3.6, "Connec)HY(tions)YH(")29 0 TN TL()Ec /AF f D(.)EP( + + )0 2 33 H(3.13)WB 358 Sn()WB 36 Sn( Tracing SQL State)HY(ment)YH( Execu)HY(tion)YH()EA()EH( + + )0 P(Often)HY(times)YH( it is useful to under)HY(stand)YH( what SQL state)HY(ments)YH( are + executed as a result of high-level database oper)HY(a)HY(tions)YH(. For + example, we can use this infor)HY(ma)HY(tion)YH( to figure out why certain + trans)HY(ac)HY(tions)YH( don't produce desired results or why they take + longer than expected.)EP( + + )0 P(While this infor)HY(ma)HY(tion)YH( can usually be obtained from the database + logs, ODB provides an appli)HY(ca)HY(tion)YH(-side SQL state)HY(ment)YH( tracing + support that is both more conve)HY(nient)YH( and finer-grained. + For example, in a typical situ)HY(a)HY(tion)YH( that calls for tracing + we would like to see the SQL state)HY(ments)YH( executed as a result + of a specific trans)HY(ac)HY(tion)YH(. While it may be diffi)HY(cult)YH( to + extract such a subset of state)HY(ments)YH( from the database logs, + it is easy to achieve with ODB tracing support:)EP( + + ) 6 28 PR(transaction t \201db.begin \201\202\202; +t.tracer \201stderr_tracer\202; + +... + +t.commit \201\202;)RP( + + )0 P(ODB allows us to specify a tracer on the database, connec)HY(tion)YH(, + and trans)HY(ac)HY(tion)YH( levels. If spec)HY(i)HY(fied)YH( for the database, then + all the state)HY(ments)YH( executed on this database will be traced. + On the other hand, if a tracer is spec)HY(i)HY(fied)YH( for the + connec)HY(tion)YH(, then only the SQL state)HY(ments)YH( executed on this + connec)HY(tion)YH( will be traced. Simi)HY(larly)YH(, a tracer spec)HY(i)HY(fied)YH( + for a trans)HY(ac)HY(tion)YH( will only show state)HY(ments)YH( that are + executed as part of this trans)HY(ac)HY(tion)YH(. All three classes + \201)SM(odb::database)ES(, )SM(odb::connec)HY(tion)YH()ES(, + and )SM(odb::trans)HY(ac)HY(tion)YH()ES(\202 provide the iden)HY(ti)HY(cal)YH( + tracing API:)EP( + + ) 8 24 PR( void + tracer \201odb::tracer&\202; + + void + tracer \201odb::tracer*\202; + + odb::tracer* + tracer \201\202 const;)RP( + + )0 P(The first two )SM(tracer\201\202)ES( func)HY(tions)YH( allow us to set + the tracer object with the second one allow)HY(ing)YH( us to clear the + current tracer by passing a )SM(NULL)ES( pointer. The + last )SM(tracer\201\202)ES( func)HY(tion)YH( allows us to get the + current tracer object. It returns a )SM(NULL)ES( pointer + if there is no tracer in effect. Note that the tracing API + does not manage the life)HY(time)YH( of the tracer object. The tracer + should be valid for as long as it is being used. Further)HY(more)YH(, + the tracing API is not thread-safe. Trying to set a tracer + from multi)HY(ple)YH( threads simul)HY(ta)HY(ne)HY(ously)YH( will result in + unde)HY(fined)YH( behav)HY(ior)YH(.)EP( + + )0 P(The )SM(odb::tracer)ES( class defines a call)HY(back)YH( inter)HY(face)YH( + that can be used to create custom tracer imple)HY(men)HY(ta)HY(tions)YH(. The + )SM(odb::stderr_tracer)ES( and )SM(odb::stderr_full_tracer)ES( + are built-in tracer imple)HY(men)HY(ta)HY(tions)YH( provided by the ODB runtime. + They both print SQL state)HY(ments)YH( being executed to the stan)HY(dard)YH( error + stream. The full tracer, in addi)HY(tion)YH( to tracing state)HY(ment)YH( execu)HY(tions)YH(, + also traces their prepa)HY(ra)HY(tions)YH( and deal)HY(lo)HY(ca)HY(tions)YH(. One situ)HY(a)HY(tion)YH( where + the full tracer can be partic)HY(u)HY(larly)YH( useful is if a state)HY(ment)YH( \201for + example a custom query\202 contains a syntax error. In this case the + error will be detected during prepa)HY(ra)HY(tion)YH( and, as a result, the + state)HY(ment)YH( will never be executed. The only way to see such a state)HY(ment)YH( + is by using the full tracing.)EP( + + )0 P(The )SM(odb::tracer)ES( class is defined in the + )SM()ES( header file which you will need to + include in order to make this class avail)HY(able)YH( in your appli)HY(ca)HY(tion)YH(. + The )SM(odb::tracer)ES( inter)HY(face)YH( provided the follow)HY(ing)YH( + call)HY(back)YH( func)HY(tions)YH(:)EP( + + ) 18 53 PR(namespace odb +{ + class tracer + { + public: + virtual void + prepare \201connection&, const statement&\202; + + virtual void + execute \201connection&, const statement&\202; + + virtual void + execute \201connection&, const char* statement\202 = 0; + + virtual void + deallocate \201connection&, const statement&\202; + }; +})RP( + + )0 P(The )SM(prepare\201\202)ES( and )SM(deal)HY(lo)HY(cate)YH(\201\202)ES( func)HY(tions)YH( + are called when a prepared state)HY(ment)YH( is created and destroyed, + respec)HY(tively)YH(. The first )SM(execute\201\202)ES( func)HY(tion)YH( is called + when a prepared state)HY(ment)YH( is executed while the second one is called + when a normal state)HY(ment)YH( is executed. The default imple)HY(men)HY(ta)HY(tions)YH( + for the )SM(prepare\201\202)ES( and )SM(deal)HY(lo)HY(cate)YH(\201\202)ES( + func)HY(tions)YH( do nothing while the first )SM(execute\201\202)ES( func)HY(tion)YH( + calls the second one passing the state)HY(ment)YH( text as the second + argu)HY(ment)YH(. As a result, if all you are inter)HY(ested)YH( in are the + SQL state)HY(ments)YH( being executed, then you only need to over)HY(ride)YH( the + second )SM(execute\201\202)ES( func)HY(tion)YH(.)EP( + + )0 P(In addi)HY(tion)YH( to the common )SM(odb::tracer)ES( inter)HY(face)YH(, + each database runtime provides a database-specific version + as )SM(odb::::tracer)ES(. It has exactly + the same inter)HY(face)YH( as the common version except that the + )SM(connec)HY(tion)YH()ES( and )SM(state)HY(ment)YH()ES( types + are database-specific, which gives us access to addi)HY(tional)YH(, + database-specific infor)HY(ma)HY(tion)YH(.)EP( + + )0 P(As an example, consider a more elab)HY(o)HY(rate)YH(, Post)HY(greSQL)YH(-specific + tracer imple)HY(men)HY(ta)HY(tion)YH(. Here we rely on the fact that the Post)HY(greSQL)YH( + ODB runtime uses names to iden)HY(tify)YH( prepared state)HY(ments)YH( and this + infor)HY(ma)HY(tion)YH( can be obtained from the )SM(odb::pgsql::state)HY(ment)YH()ES( + object:)EP( + + ) 32 72 PR(#include +#include +#include +#include + +class pgsql_tracer: public odb::pgsql::tracer +{ + virtual void + prepare \201odb::pgsql::connection& c, const odb::pgsql::statement& s\202 + { + cerr << c.database \201\202.db \201\202 << ": PREPARE " << s.name \201\202 + << " AS " << s.text \201\202 << endl; + } + + virtual void + execute \201odb::pgsql::connection& c, const odb::pgsql::statement& s\202 + { + cerr << c.database \201\202.db \201\202 << ": EXECUTE " << s.name \201\202 << endl; + } + + virtual void + execute \201odb::pgsql::connection& c, const char* statement\202 + { + cerr << c.database \201\202.db \201\202 << ": " << statement << endl; + } + + virtual void + deallocate \201odb::pgsql::connection& c, const odb::pgsql::statement& s\202 + { + cerr << c.database \201\202.db \201\202 << ": DEALLOCATE " << s.name \201\202 << endl; + })WR( +};)RP( + + )0 P(Note also that you can only set a database-specific tracer object + using a database-specific database instance, for example:)EP( + + ) 7 37 PR(pgsql_tracer tracer; + +odb::database& db = ...; +db.tracer \201tracer\202; // Compile error. + +odb::pgsql::database& db = ...; +db.tracer \201tracer\202; // Ok.)RP( + + )0 2 34 H(3.14)WB 359 Sn()WB 37 Sn( ODB Excep)HY(tions)YH()EA()EH( + + )0 P(In the previ)HY(ous)YH( sections we have already mentioned some of the + excep)HY(tions)YH( that can be thrown by the database func)HY(tions)YH(. In this + section we will discuss the ODB excep)HY(tion)YH( hier)HY(ar)HY(chy)YH( and docu)HY(ment)YH( + all the excep)HY(tions)YH( that can be thrown by the common ODB + runtime.)EP( + + )0 P(The root of the ODB excep)HY(tion)YH( hier)HY(ar)HY(chy)YH( is the abstract + )SM(odb::excep)HY(tion)YH()ES( class. This class derives + from )SM(std::excep)HY(tion)YH()ES( and has the follow)HY(ing)YH( + inter)HY(face)YH(:)EP( + + ) 8 34 PR(namespace odb +{ + struct exception: std::exception + { + virtual const char* + what \201\202 const throw \201\202 = 0; + }; +})RP( + + )0 P(Catch)HY(ing)YH( this excep)HY(tion)YH( guar)HY(an)HY(tees)YH( that we will catch all the + excep)HY(tions)YH( thrown by ODB. The )SM(what\201\202)ES( func)HY(tion)YH( + returns a human-read)HY(able)YH( descrip)HY(tion)YH( of the condi)HY(tion)YH( that + trig)HY(gered)YH( the excep)HY(tion)YH(.)EP( + + )0 P(The concrete excep)HY(tions)YH( that can be thrown by ODB are presented + in the follow)HY(ing)YH( listing:)EP( + + ) 178 49 PR(namespace odb +{ + struct null_pointer: exception + { + virtual const char* + what \201\202 const throw \201\202; + }; + + // Transaction exceptions. + // + struct already_in_transaction: exception + { + virtual const char* + what \201\202 const throw \201\202; + }; + + struct not_in_transaction: exception + { + virtual const char* + what \201\202 const throw \201\202; + }; + + struct transaction_already_finalized: exception + { + virtual const char* + what \201\202 const throw \201\202; + }; + + // Session exceptions. + // + struct already_in_session: exception)WR( + { + virtual const char* + what \201\202 const throw \201\202; + }; + + struct not_in_session: exception + { + virtual const char* + what \201\202 const throw \201\202; + }; + + struct session_required: exception + { + virtual const char* + what \201\202 const throw \201\202; + }; + + // Database operations exceptions. + // + struct recoverable: exception + { + }; + + struct connection_lost: recoverable + { + virtual const char* + what \201\202 const throw \201\202; + }; + + struct timeout: recoverable)WR( + { + virtual const char* + what \201\202 const throw \201\202; + }; + + struct deadlock: recoverable + { + virtual const char* + what \201\202 const throw \201\202; + }; + + struct object_not_persistent: exception + { + virtual const char* + what \201\202 const throw \201\202; + }; + + struct object_already_persistent: exception + { + virtual const char* + what \201\202 const throw \201\202; + }; + + struct object_changed: exception + { + virtual const char* + what \201\202 const throw \201\202; + }; + + struct result_not_cached: exception)WR( + { + virtual const char* + what \201\202 const throw \201\202; + }; + + struct database_exception: exception + { + }; + + // Polymorphism support exceptions. + // + struct abstract_class: exception + { + virtual const char* + what \201\202 const throw \201\202; + }; + + struct no_type_info: exception + { + virtual const char* + what \201\202 const throw \201\202; + }; + + // Prepared query support exceptions. + // + struct prepared_already_cached: exception + { + const char* + name \201\202 const; +)WR( + virtual const char* + what \201\202 const throw \201\202; + }; + + struct prepared_type_mismatch: exception + { + const char* + name \201\202 const; + + virtual const char* + what \201\202 const throw \201\202; + }; + + // Schema catalog exceptions. + // + struct unknown_schema: exception + { + const std::string& + name \201\202 const; + + virtual const char* + what \201\202 const throw \201\202; + }; + + struct unknown_schema_version: exception + { + schema_version + version \201\202 const; + + virtual const char*)WR( + what \201\202 const throw \201\202; + }; + + // Section exceptions. + // + struct section_not_loaded: exception + { + virtual const char* + what \201\202 const throw \201\202; + }; + + struct section_not_in_object: exception + { + virtual const char* + what \201\202 const throw \201\202; + }; + + // Bulk operation exceptions. + // + struct multiple_exceptions: exception + { + ... + + virtual const char* + what \201\202 const throw \201\202; + }; +})RP( + + )0 P(The )SM(null_pointer)ES( excep)HY(tion)YH( is thrown when a + pointer to a persis)HY(tent)YH( object declared non-)SM(NULL)ES( + with the )SM(db\240not_null)ES( or + )SM(db\240value_not_null)ES( pragma has the )SM(NULL)ES( + value. See )0 52 1 A(Chapter 6, "Rela)HY(tion)HY(ships)YH(")52 0 TN TL()Ec /AF f D( for details.)EP( + + )0 P(The next three excep)HY(tions)YH( \201)SM(already_in_trans)HY(ac)HY(tion)YH()ES(, + )SM(not_in_trans)HY(ac)HY(tion)YH()ES(, + )SM(trans)HY(ac)HY(tion)YH(_already_final)HY(ized)YH()ES(\202 are thrown by the + )SM(odb::trans)HY(ac)HY(tion)YH()ES( class and are discussed + in )0 28 1 A(Section 3.5, "Trans)HY(ac)HY(tions)YH(")28 0 TN TL()Ec /AF f D(.)EP( + + )0 P(The next two excep)HY(tions)YH( \201)SM(already_in_session)ES(, and + )SM(not_in_session)ES(\202 are thrown by the )SM(odb::session)ES( + class and are discussed in )0 87 1 A(Chapter 11, "Session")87 0 TN TL()Ec /AF f D(.)EP( + + )0 P(The )SM(session_required)ES( excep)HY(tion)YH( is thrown when ODB detects + that correctly loading a bidi)HY(rec)HY(tional)YH( object rela)HY(tion)HY(ship)YH( requires a + session but one is not used. See )0 56 1 A(Section 6.2, + "Bidi)HY(rec)HY(tional)YH( Rela)HY(tion)HY(ships)YH(")56 0 TN TL()Ec /AF f D( for more infor)HY(ma)HY(tion)YH( on this + excep)HY(tion)YH(.)EP( + + )0 P(The )SM(recov)HY(er)HY(able)YH()ES( excep)HY(tion)YH( serves as a common base + for all the recov)HY(er)HY(able)YH( excep)HY(tions)YH(, which are: )SM(connec)HY(tion)YH(_lost)ES(, + )SM(timeout)ES(, and )SM(dead)HY(lock)YH()ES(. The + )SM(connec)HY(tion)YH(_lost)ES( excep)HY(tion)YH( is thrown when a connec)HY(tion)YH( + to the database is lost. Simi)HY(larly)YH(, the )SM(timeout)ES( excep)HY(tion)YH( + is thrown if one of the database oper)HY(a)HY(tions)YH( or the whole trans)HY(ac)HY(tion)YH( + has timed out. The )SM(dead)HY(lock)YH()ES( excep)HY(tion)YH( is thrown when a + trans)HY(ac)HY(tion)YH( dead)HY(lock)YH( is detected by the database system. These + excep)HY(tions)YH( can be thrown by any database func)HY(tion)YH(. See + )0 30 1 A(Section 3.7, "Error Handling and Recov)HY(ery)YH(")30 0 TN TL()Ec /AF f D( + for details.)EP( + + )0 P(The )SM(object_already_persis)HY(tent)YH()ES( excep)HY(tion)YH( is thrown + by the )SM(persist\201\202)ES( database func)HY(tion)YH(. See + )0 31 1 A(Section 3.8, "Making Objects Persis)HY(tent)YH(")31 0 TN TL()Ec /AF f D( + for details.)EP( + + )0 P(The )SM(object_not_persis)HY(tent)YH()ES( excep)HY(tion)YH( is thrown + by the )SM(load\201\202)ES(, )SM(update\201\202)ES(, and + )SM(erase\201\202)ES( database func)HY(tions)YH(. Refer to + )0 32 1 A(Section 3.9, "Loading Persis)HY(tent)YH( Objects")32 0 TN TL()Ec /AF f D(, + )0 33 1 A(Section 3.10, "Updat)HY(ing)YH( Persis)HY(tent)YH( Objects")33 0 TN TL()Ec /AF f D(, and + )0 34 1 A(Section 3.11, "Delet)HY(ing)YH( Persis)HY(tent)YH( Objects")34 0 TN TL()Ec /AF f D( for + more infor)HY(ma)HY(tion)YH(.)EP( + + )0 P(The )SM(object_changed)ES( excep)HY(tion)YH( is thrown + by the )SM(update\201\202)ES( database func)HY(tion)YH( and certain + )SM(erase\201\202)ES( database func)HY(tions)YH( when + oper)HY(at)HY(ing)YH( on objects with the opti)HY(mistic)YH( concur)HY(rency)YH( model. See + )0 90 1 A(Chapter 12, "Opti)HY(mistic)YH( Concur)HY(rency)YH(")90 0 TN TL()Ec /AF f D( for details.)EP( + + )0 P(The )SM(result_not_cached)ES( excep)HY(tion)YH( is thrown by + the query result class. Refer to )0 43 1 A(Section 4.4, + "Query Result")43 0 TN TL()Ec /AF f D( for details.)EP( + + )0 P(The )SM(database_excep)HY(tion)YH()ES( excep)HY(tion)YH( is a base class for all + database system-specific excep)HY(tions)YH( that are thrown by the + database system-specific runtime library. Refer to )0 204 1 A(Part + II, "Database Systems")204 0 TN TL()Ec /AF f D( for more infor)HY(ma)HY(tion)YH(.)EP( + + )0 P(The )SM(abstract_class)ES( excep)HY(tion)YH( is thrown by the database + func)HY(tions)YH( when we attempt to persist, update, load, or erase an + instance of a poly)HY(mor)HY(phic)YH( abstract class. For more infor)HY(ma)HY(tion)YH( + on abstract classes, refer to )0 104 1 A(Section 14.1.3, + ")SM(abstract)ES(")104 0 TN TL()Ec /AF f D(.)EP( + + )0 P(The )SM(no_type_info)ES( excep)HY(tion)YH( is thrown by the database + func)HY(tions)YH( when we attempt to persist, update, load, or erase an + instance of a poly)HY(mor)HY(phic)YH( class for which no type infor)HY(ma)HY(tion)YH( + is present in the appli)HY(ca)HY(tion)YH(. This normally means that the + gener)HY(ated)YH( database support code for this class has not been + linked \201or dynam)HY(i)HY(cally)YH( loaded\202 into the appli)HY(ca)HY(tion)YH( or the + discrim)HY(i)HY(na)HY(tor)YH( value has not been mapped to a persis)HY(tent)YH( + class. For more infor)HY(ma)HY(tion)YH( on poly)HY(mor)HY(phism)YH( support, refer to + )0 71 1 A(Section 8.2, "Poly)HY(mor)HY(phism)YH( Inher)HY(i)HY(tance)YH(")71 0 TN TL()Ec /AF f D(.)EP( + + )0 P(The )SM(prepared_already_cached)ES( excep)HY(tion)YH( is thrown by the + )SM(cache_query\201\202)ES( func)HY(tion)YH( if a prepared query with the + spec)HY(i)HY(fied)YH( name is already cached. The )SM(prepared_type_mismatch)ES( + excep)HY(tion)YH( is thrown by the )SM(lookup_query\201\202)ES( func)HY(tion)YH( if + the spec)HY(i)HY(fied)YH( prepared query object type or param)HY(e)HY(ters)YH( type + does not match the one in the cache. Refer to )0 44 1 A(Section + 4.5, "Prepared Queries")44 0 TN TL()Ec /AF f D( for details.)EP( + + )0 P(The )SM(unknown_schema)ES( excep)HY(tion)YH( is thrown by the + )SM(odb::schema_catalog)ES( class if a schema with the spec)HY(i)HY(fied)YH( + name is not found. Refer to )0 27 1 A(Section 3.4, "Database")27 0 TN TL()Ec /AF f D( + for details. The )SM(unknown_schema_version)ES( excep)HY(tion)YH( is + thrown by the )SM(schema_catalog)ES( func)HY(tions)YH( that deal with + database schema evolu)HY(tion)YH( if the passed version is unknow. Refer + to )0 91 1 A(Chapter 13, "Database Schema Evolu)HY(tion)YH(")91 0 TN TL()Ec /AF f D( for + details.)EP( + + )0 P(The )SM(section_not_loaded)ES( excep)HY(tion)YH( is thrown if we + attempt to update an object section that hasn't been loaded. + The )SM(section_not_in_object)ES( excep)HY(tion)YH( is thrown if + the section instance being loaded or updated does not belong + to the corre)HY(spond)HY(ing)YH( object. See )0 74 1 A(Chapter 9, + "Sections")74 0 TN TL()Ec /AF f D( for more infor)HY(ma)HY(tion)YH( on these excep)HY(tions)YH(.)EP( + + )0 P(The )SM(multi)HY(ple)YH(_excep)HY(tions)YH()ES( excep)HY(tion)YH( is thrown by the + bulk API func)HY(tions)YH(. Refer to )0 203 1 A(Section 15.3, "Bulk + Database Oper)HY(a)HY(tions)YH(")203 0 TN TL()Ec /AF f D( for details.)EP( + + )0 P(The )SM(odb::excep)HY(tion)YH()ES( class is defined in the + )SM()ES( header file. All the + concrete ODB excep)HY(tions)YH( are defined in + )SM()ES( which also includes + )SM()ES(. Normally you don't + need to include either of these two headers because they are + auto)HY(mat)HY(i)HY(cally)YH( included by )SM()ES(. + However, if the source file that handles ODB excep)HY(tions)YH( + does not include )SM()ES(, then + you will need to explic)HY(itly)YH( include one of these headers.)EP( + + + + + + )WB NL NP( + )0 1 35 H(4)WB 360 Sn()WB 38 Sn( Query)HY(ing)YH( the Database)EA()EH( + + )0 P(If we don't know the iden)HY(ti)HY(fiers)YH( of the objects that we are looking + for, we can use queries to search the database for objects match)HY(ing)YH( + certain crite)HY(ria)YH(. The ODB query facil)HY(ity)YH( is optional and we need to + explic)HY(itly)YH( request the gener)HY(a)HY(tion)YH( of the neces)HY(sary)YH( database support + code with the )SM(--gener)HY(ate)YH(-query)ES( ODB compiler option.)EP( + + )0 P(ODB provides a flex)HY(i)HY(ble)YH( query API that offers two distinct levels of + abstrac)HY(tion)YH( from the database system query language such as SQL. + At the high level we are presented with an easy to use yet power)HY(ful)YH( + object-oriented query language, called ODB Query Language. This + query language is modeled after and is inte)HY(grated)YH( into C++ allow)HY(ing)YH( + us to write expres)HY(sive)YH( and safe queries that look and feel like + ordi)HY(nary)YH( C++. We have already seen exam)HY(ples)YH( of these queries in the + intro)HY(duc)HY(tory)YH( chap)HY(ters)YH(. Below is another, more inter)HY(est)HY(ing)YH(, example:)EP( + + ) 11 69 PR( typedef odb::query query; + typedef odb::result result; + + unsigned short age; + query q \201query::first == "John" && query::age < query::_ref \201age\202\202; + + for \201age = 10; age < 100; age += 10\202 + { + result r \201db.query \201q\202\202; + ... + })RP( + + )0 P(At the low level, queries can be written as pred)HY(i)HY(cates)YH( using + the database system-native query language such as the + )SM(WHERE)ES( pred)HY(i)HY(cate)YH( from the SQL )SM(SELECT)ES( + state)HY(ment)YH(. This language will be referred to as native query + language. At this level ODB still takes care of convert)HY(ing)YH( + query param)HY(e)HY(ters)YH( from C++ to the database system format. Below + is the re-imple)HY(men)HY(ta)HY(tion)YH( of the above example using SQL as + the native query language:)EP( + + ) 1 60 PR( query q \201"first = 'John' AND age = " + query::_ref \201age\202\202;)RP( + + )0 P(Note that at this level we lose the static typing of + query expres)HY(sions)YH(. For example, if we wrote some)HY(thing)YH( like this:)EP( + + ) 1 67 PR( query q \201query::first == 123 && query::agee < query::_ref \201age\202\202;)RP( + + )0 P(We would get two errors during the C++ compi)HY(la)HY(tion)YH(. The first would + indi)HY(cate)YH( that we cannot compare )SM(query::first)ES( to an + integer and the second would pick the misspelling in + )SM(query::agee)ES(. On the other hand, if we wrote some)HY(thing)YH( + like this:)EP( + + ) 1 58 PR( query q \201"first = 123 AND agee = " + query::_ref \201age\202\202;)RP( + + )0 P(It would compile fine and would trigger an error only when executed + by the database system.)EP( + + )0 P(We can also combine the two query languages in a single query, for + example:)EP( + + ) 1 68 PR( query q \201"first = 'John' AND" + \201query::age < query::_ref \201age\202\202\202;)RP( + + )0 2 36 H(4.1)WB 361 Sn()WB 39 Sn( ODB Query Language)EA()EH( + + )0 P(An ODB query is an expres)HY(sion)YH( that tells the database system whether + any given object matches the desired crite)HY(ria)YH(. As such, a query expres)HY(sion)YH( + always eval)HY(u)HY(ates)YH( as )SM(true)ES( or )SM(false)ES(. At + the higher level, an expres)HY(sion)YH( consists of other expres)HY(sions)YH( + combined with logical oper)HY(a)HY(tors)YH( such as )SM(&&)ES( \201AND\202, + )SM(||)ES( \201OR\202, and )SM(!)ES( \201NOT\202. For example:)EP( + + ) 3 55 PR( typedef odb::query query; + + query q \201query::first == "John" || query::age == 31\202;)RP( + + )0 P(At the core of every query expres)HY(sion)YH( lie simple expres)HY(sions)YH( which + involve one or more object members, values, or param)HY(e)HY(ters)YH(. To + refer to an object member we use an expres)HY(sion)YH( such as + )SM(query::first)ES( above. The names of members in the + )SM(query)ES( class are derived from the names of data members + in the object class by remov)HY(ing)YH( the common member name deco)HY(ra)HY(tions)YH(, + such as leading and trail)HY(ing)YH( under)HY(scores)YH(, the )SM(m_)ES( prefix, + etc.)EP( + + )0 P(In a simple expres)HY(sion)YH( an object member can be compared to a value, + param)HY(e)HY(ter)YH(, or another member using a number of prede)HY(fined)YH( oper)HY(a)HY(tors)YH( + and func)HY(tions)YH(. The follow)HY(ing)YH( table gives an overview of the avail)HY(able)YH( + expres)HY(sions)YH(:)EP( + + + )1 PT( + + )0 P(The )SM(in\201\202)ES( func)HY(tion)YH( accepts a maximum of five argu)HY(ments)YH(. + Use the )SM(in_range\201\202)ES( func)HY(tion)YH( if you need to compare + to more than five values. This func)HY(tion)YH( accepts a pair of + stan)HY(dard)YH( C++ iter)HY(a)HY(tors)YH( and compares to all the values from + the )SM(begin)ES( posi)HY(tion)YH( inclu)HY(sive)YH( and until and + exclud)HY(ing)YH( the )SM(end)ES( posi)HY(tion)YH(. The follow)HY(ing)YH( + code frag)HY(ment)YH( shows how we can use these func)HY(tions)YH(:)EP( + + ) 8 66 PR( std::vector names; + + names.push_back \201"John"\202; + names.push_back \201"Jack"\202; + names.push_back \201"Jane"\202; + + query q1 \201query::first.in \201"John", "Jack", "Jane"\202\202; + query q2 \201query::first.in_range \201names.begin \201\202, names.end \201\202\202\202;)RP( + + )0 P(Note that the )SM(like\201\202)ES( func)HY(tion)YH( does not perform any + trans)HY(la)HY(tion)YH( of the database system-specific exten)HY(sions)YH( of the + SQL )SM(LIKE)ES( oper)HY(a)HY(tor)YH(. As a result, if you would like + your appli)HY(ca)HY(tion)YH( to be portable among various database systems, + then limit the special char)HY(ac)HY(ters)YH( used in the pattern to + )SM(%)ES( \201matches zero or more char)HY(ac)HY(ters)YH(\202 and )SM(_)ES( + \201matches exactly one char)HY(ac)HY(ter)YH(\202. It is also possi)HY(ble)YH( to specify + the escape char)HY(ac)HY(ter)YH( as a second argu)HY(ment)YH( to the )SM(like\201\202)ES( + func)HY(tion)YH(. This char)HY(ac)HY(ter)YH( can then be used to escape the special + char)HY(ac)HY(ters)YH( \201)SM(%)ES( and )SM(_)ES(\202 in the pattern. + For example, the follow)HY(ing)YH( query will match any two char)HY(ac)HY(ters)YH( + sepa)HY(rated)YH( by an under)HY(score)YH(:)EP( + + ) 1 43 PR( query q \201query::name.like \201"_!__", "!"\202\202;)RP( + + )0 P(The oper)HY(a)HY(tor)YH( prece)HY(dence)YH( in the query expres)HY(sions)YH( are the same + as for equiv)HY(a)HY(lent)YH( C++ oper)HY(a)HY(tors)YH(. We can use paren)HY(the)HY(ses)YH( to + make sure the expres)HY(sion)YH( is eval)HY(u)HY(ated)YH( in the desired order. + For example:)EP( + + ) 2 64 PR( query q \201\201query::first == "John" || query::first == "Jane"\202 && + query::age < 31\202;)RP( + + + )0 2 37 H(4.2)WB 362 Sn()WB 41 Sn( Param)HY(e)HY(ter)YH( Binding)EA()EH( + + )0 P(An instance of the )SM(odb::query)ES( class encap)HY(su)HY(lates)YH( two + parts of infor)HY(ma)HY(tion)YH( about the query: the query expres)HY(sion)YH( and + the query param)HY(e)HY(ters)YH(. Param)HY(e)HY(ters)YH( can be bound to C++ vari)HY(ables)YH( + either by value or by refer)HY(ence)YH(.)EP( + + )0 P(If a param)HY(e)HY(ter)YH( is bound by value, then the value for this param)HY(e)HY(ter)YH( + is copied from the C++ vari)HY(able)YH( to the query instance at the query + construc)HY(tion)YH( time. On the other hand, if a param)HY(e)HY(ter)YH( is bound by + refer)HY(ence)YH(, then the query instance stores a refer)HY(ence)YH( to the + bound vari)HY(able)YH(. The actual value of the param)HY(e)HY(ter)YH( is only extracted + at the query execu)HY(tion)YH( time. Consider, for example, the follow)HY(ing)YH( + two queries:)EP( + + ) 9 48 PR( string name \201"John"\202; + + query q1 \201query::first == query::_val \201name\202\202; + query q2 \201query::first == query::_ref \201name\202\202; + + name = "Jane"; + + db.query \201q1\202; // Find John. + db.query \201q2\202; // Find Jane.)RP( + + )0 P(The )SM(odb::query)ES( class provides two special func)HY(tions)YH(, + )SM(_val\201\202)ES( and )SM(_ref\201\202)ES(, that allow us to + bind the param)HY(e)HY(ter)YH( either by value or by refer)HY(ence)YH(, respec)HY(tively)YH(. + In the ODB query language, if the binding is not spec)HY(i)HY(fied)YH( + explic)HY(itly)YH(, the value seman)HY(tic)YH( is used by default. In the + native query language, binding must always be spec)HY(i)HY(fied)YH( + explic)HY(itly)YH(. For example:)EP( + + ) 7 62 PR( query q1 \201query::age < age\202; // By value. + query q2 \201query::age < query::_val \201age\202\202; // By value. + query q3 \201query::age < query::_ref \201age\202\202; // By reference. + + query q4 \201"age < " + age\202; // Error. + query q5 \201"age < " + query::_val \201age\202\202; // By value. + query q6 \201"age < " + query::_ref \201age\202\202; // By reference.)RP( + + )0 P(A query that only has by-value param)HY(e)HY(ters)YH( does not depend on any + other vari)HY(ables)YH( and is self-suffi)HY(cient)YH( once constructed. A query + that has one or more by-refer)HY(ence)YH( param)HY(e)HY(ters)YH( depends on the + bound vari)HY(ables)YH( until the query is executed. If one such vari)HY(able)YH( + goes out of scope and we execute the query, the behav)HY(ior)YH( is + unde)HY(fined)YH(.)EP( + + )0 2 38 H(4.3)WB 363 Sn()WB 42 Sn( Execut)HY(ing)YH( a Query)EA()EH( + + )0 P(Once we have the query instance ready and by-refer)HY(ence)YH( param)HY(e)HY(ters)YH( + initial)HY(ized)YH(, we can execute the query using the + )SM(database::query\201\202)ES( func)HY(tion)YH( template. It has two + over)HY(loaded)YH( versions:)EP( + + ) 7 50 PR( template + result + query \201bool cache = true\202; + + template + result + query \201const odb::query&, bool cache = true\202;)RP( + + )0 P(The first )SM(query\201\202)ES( func)HY(tion)YH( is used to return all the + persis)HY(tent)YH( objects of a given type stored in the database. + The second func)HY(tion)YH( uses the passed query instance to only return + objects match)HY(ing)YH( the query crite)HY(ria)YH(. The )SM(cache)ES( argu)HY(ment)YH( + deter)HY(mines)YH( whether the objects' states should be cached in the + appli)HY(ca)HY(tion)YH('s memory or if they should be returned by the database + system one by one as the iter)HY(a)HY(tion)YH( over the result progresses. The + result caching is discussed in detail in the next section.)EP( + + )0 P(When calling the )SM(query\201\202)ES( func)HY(tion)YH(, we have to + explic)HY(itly)YH( specify the object type we are query)HY(ing)YH(. For example:)EP( + + ) 5 59 PR( typedef odb::query query; + typedef odb::result result; + + result all \201db.query \201\202\202; + result johns \201db.query \201query::first == "John"\202\202;)RP( + + )0 P(Note that it is not required to explic)HY(itly)YH( create a named + query vari)HY(able)YH( before execut)HY(ing)YH( it. For example, the follow)HY(ing)YH( + two queries are equiv)HY(a)HY(lent)YH(:)EP( + + ) 4 56 PR( query q \201query::first == "John"\202; + + result r1 \201db.query \201q\202\202; + result r1 \201db.query \201query::first == "John"\202\202;)RP( + + )0 P(Normally, we would create a named query instance if we are + plan)HY(ning)YH( to run the same query multi)HY(ple)YH( times and would use the + in-line version for those that are executed only once \201see also + )0 44 1 A(Section 4.5, "Prepared Queries")44 0 TN TL()Ec /AF f D( for a more + optimal way to re-execute the same query multi)HY(ple)YH( times\202. A named + query instance that does not have any by-refer)HY(ence)YH( param)HY(e)HY(ters)YH( is + immutable and can be shared between multi)HY(ple)YH( threads without + synchro)HY(niza)HY(tion)YH(. On the other hand, a query instance with + by-refer)HY(ence)YH( param)HY(e)HY(ters)YH( is modi)HY(fied)YH( every time it is executed. + If such a query is shared among multi)HY(ple)YH( threads, then access + to this query instance must be synchro)HY(nized)YH( from the execu)HY(tion)YH( + point and until the comple)HY(tion)YH( of the iter)HY(a)HY(tion)YH( over the result.)EP( + + )0 P(It is also possi)HY(ble)YH( to create queries from other queries by + combin)HY(ing)YH( them using logical oper)HY(a)HY(tors)YH(. For example:)EP( + + ) 7 58 PR(result +find_minors \201database& db, const query& name_query\202 +{ + return db.query \201name_query && query::age < 18\202; +} + +result r \201find_minors \201db, query::first == "John"\202\202;)RP( + + )0 P(The result of execut)HY(ing)YH( a query is zero, one, or more objects + match)HY(ing)YH( the query crite)HY(ria)YH(. The )SM(query\201\202)ES( func)HY(tion)YH( + returns this result as an instance of the )SM(odb::result)ES( + class template, which provides a stream-like inter)HY(face)YH( and is + discussed in detail in the next section.)EP( + + )0 P(In situ)HY(a)HY(tions)YH( where we know that a query produces at most one + element, we can instead use the )SM(database::query_one\201\202)ES( and + )SM(database::query_value\201\202)ES( short)HY(cut)YH( func)HY(tions)YH(, for example:)EP( + + ) 5 42 PR( typedef odb::query query; + + auto_ptr p \201 + db.query_one \201 + query::email == "jon@example.com"\202\202;)RP( + + )0 P(The short)HY(cut)YH( query func)HY(tions)YH( have the follow)HY(ing)YH( signa)HY(tures)YH(:)EP( + + ) 23 41 PR( template + typename object_traits::pointer_type + query_one \201\202; + + template + bool + query_one \201T&\202; + + template + T + query_value \201\202; + + template + typename object_traits::pointer_type + query_one \201const odb::query&\202; + + template + bool + query_one \201const odb::query&, T&\202; + + template + T + query_value \201const odb::query&\202;)RP( + + )0 P(Similar to )SM(query\201\202)ES(, the first three func)HY(tions)YH( are used + to return the only persis)HY(tent)YH( object of a given type stored in the + database. The second three versions use the passed query instance + to only return the object match)HY(ing)YH( the query crite)HY(ria)YH(.)EP( + + )0 P(Similar to the )SM(database::find\201\202)ES( func)HY(tions)YH( + \201)0 32 1 A(Section 3.9, "Loading Persis)HY(tent)YH( Objects")32 0 TN TL()Ec /AF f D(\202, + )SM(query_one\201\202)ES( can either allo)HY(cate)YH( a new instance of the + object class in the dynamic memory or it can load the object's state + into an exist)HY(ing)YH( instance. The )SM(query_value\201\202)ES( func)HY(tion)YH( + allo)HY(cates)YH( and returns the object by value.)EP( + + )0 P(The )SM(query_one\201\202)ES( func)HY(tion)YH( allows us to deter)HY(mine)YH( + if the query result contains zero or one element. If no objects + match)HY(ing)YH( the query crite)HY(ria)YH( were found in the database, the + first version of )SM(query_one\201\202)ES( returns the )SM(NULL)ES( + pointer while the second \236 )SM(false)ES(. If the second + version returns )SM(false)ES(, then the passed object + remains unchanged. For example:)EP( + + ) 11 66 PR( if \201unique_ptr p = db.query_one \201 + query::email == "jon@example.com"\202\202 + { + ... + } + + person p; + if \201db.query_one \201query::email == "jon@example.com", p\202\202 + { + ... + })RP( + + )0 P(If the query executed using )SM(query_one\201\202)ES( or + )SM(query_value\201\202)ES( returns more than one element, + then these func)HY(tions)YH( fail with an asser)HY(tion)YH(. Addi)HY(tion)HY(ally)YH(, + )SM(query_value\201\202)ES( also fails with an asser)HY(tion)YH( if + the query returned no elements.)EP( + + )0 P(Common situ)HY(a)HY(tions)YH( where we can use the short)HY(cut)YH( func)HY(tions)YH( are a + query condi)HY(tion)YH( that uses a data member with the + )SM(unique)ES( constraint \201at most one element returned; + see )0 191 1 A(Section 14.7, "Index Defi)HY(ni)HY(tion)YH( Pragmas")191 0 TN TL()Ec /AF f D(\202 + as well as aggre)HY(gate)YH( queries \201exactly one element returned; see + )0 79 1 A(Chapter 10, "Views")79 0 TN TL()Ec /AF f D(\202.)EP( + + )0 2 39 H(4.4)WB 364 Sn()WB 43 Sn( Query Result)EA()EH( + + )0 P(The )SM(database::query\201\202)ES( func)HY(tion)YH( returns the result of + execut)HY(ing)YH( a query as an instance of the )SM(odb::result)ES( + class template, for example:)EP( + + ) 4 59 PR( typedef odb::query query; + typedef odb::result result; + + result johns \201db.query \201query::first == "John"\202\202;)RP( + + )0 P(It is best to view an instance of )SM(odb::result)ES( + as a handle to a stream, such as a file stream. While we can + make a copy of a result or assign one result to another, the + two instances will refer to the same result stream. Advanc)HY(ing)YH( + the current posi)HY(tion)YH( in one instance will also advance it in + another. The result instance is only usable within the trans)HY(ac)HY(tion)YH( + it was created in. Trying to manip)HY(u)HY(late)YH( the result after the + trans)HY(ac)HY(tion)YH( has termi)HY(nated)YH( leads to unde)HY(fined)YH( behav)HY(ior)YH(.)EP( + + )0 P(The )SM(odb::result)ES( class template conforms to the + stan)HY(dard)YH( C++ sequence require)HY(ments)YH( and has the follow)HY(ing)YH( + inter)HY(face)YH(:)EP( + + ) 37 45 PR(namespace odb +{ + template + class result + { + public: + typedef odb::result_iterator iterator; + + public: + result \201\202; + + result \201const result&\202; + + result& + operator= \201const result&\202; + + void + swap \201result&\202 + + public: + iterator + begin \201\202; + + iterator + end \201\202; + + public: + void + cache \201\202; + + bool)WR( + empty \201\202 const; + + std::size_t + size \201\202 const; + }; +})RP( + + )0 P(The default construc)HY(tor)YH( creates an empty result set. The + )SM(cache\201\202)ES( func)HY(tion)YH( caches the returned objects' + state in the appli)HY(ca)HY(tion)YH('s memory. We have already mentioned + result caching when we talked about query execu)HY(tion)YH(. As you + may remem)HY(ber)YH( the )SM(database::query\201\202)ES( func)HY(tion)YH( + caches the result unless instructed not to by the caller. + The )SM(cache\201\202)ES( func)HY(tion)YH( allows us to + cache the result at a later stage if it wasn't already + cached during query execu)HY(tion)YH(.)EP( + + )0 P(If the result is cached, the database state of all the returned + objects is stored in the appli)HY(ca)HY(tion)YH('s memory. Note that + the actual objects are still only instan)HY(ti)HY(ated)YH( on demand + during result iter)HY(a)HY(tion)YH(. It is the raw database state that + is cached in memory. In contrast, for uncached results + the object's state is sent by the database system one object + at a time as the iter)HY(a)HY(tion)YH( progresses.)EP( + + )0 P(Uncached results can improve the perfor)HY(mance)YH( of both the appli)HY(ca)HY(tion)YH( + and the database system in situ)HY(a)HY(tions)YH( where we have a large + number of objects in the result or if we will only examine + a small portion of the returned objects. However, uncached + results have a number of limi)HY(ta)HY(tions)YH(. There can only be one + uncached result in a trans)HY(ac)HY(tion)YH(. Creat)HY(ing)YH( another result + \201cached or uncached\202 by calling )SM(database::query\201\202)ES( + will inval)HY(i)HY(date)YH( the exist)HY(ing)YH( uncached result. Further)HY(more)YH(, + calling any other database func)HY(tions)YH(, such as )SM(update\201\202)ES( + or )SM(erase\201\202)ES( will also inval)HY(i)HY(date)YH( the uncached result. + It also follows that uncached results cannot be used on objects + with contain)HY(ers)YH( \201)0 45 1 A(Chapter 5, "Contain)HY(ers)YH(")45 0 TN TL()Ec /AF f D(\202 since + loading a container would inval)HY(i)HY(date)YH( the uncached result.)EP( + + )0 P(The )SM(empty\201\202)ES( func)HY(tion)YH( returns )SM(true)ES( if + there are no objects in the result and )SM(false)ES( other)HY(wise)YH(. + The )SM(size\201\202)ES( func)HY(tion)YH( can only be called for cached results. + It returns the number of objects in the result. If we call this + func)HY(tion)YH( on an uncached result, the )SM(odb::result_not_cached)ES( + excep)HY(tion)YH( is thrown.)EP( + + )0 P(To iterate over the objects in a result we use the + )SM(begin\201\202)ES( and )SM(end\201\202)ES( func)HY(tions)YH( + together with the )SM(odb::result::iter)HY(a)HY(tor)YH()ES( + type, for example:)EP( + + ) 6 59 PR( result r \201db.query \201query::first == "John"\202\202; + + for \201result::iterator i \201r.begin \201\202\202; i != r.end \201\202; ++i\202 + { + ... + })RP( + + )0 P(In C++11 we can use the )SM(auto)ES(-typed variabe instead + of spelling the iter)HY(a)HY(tor)YH( type explic)HY(itly)YH(, for example:)EP( + + ) 4 47 PR( for \201auto i \201r.begin \201\202\202; i != r.end \201\202; ++i\202 + { + ... + })RP( + + )0 P(The C++11 range-based )SM(for)ES(-loop can be used to further + simplify the iter)HY(a)HY(tion)YH(:)EP( + + ) 4 20 PR( for \201person& p: r\202 + { + ... + })RP( + + )0 P(The result iter)HY(a)HY(tor)YH( is an input iter)HY(a)HY(tor)YH( which means that the + only two posi)HY(tion)YH( oper)HY(a)HY(tions)YH( that it supports are to move to the + next object and to deter)HY(mine)YH( whether the end of the result stream + has been reached. In fact, the result iter)HY(a)HY(tor)YH( can only be in two + states: the current posi)HY(tion)YH( and the end posi)HY(tion)YH(. If we have + two iter)HY(a)HY(tors)YH( point)HY(ing)YH( to the current posi)HY(tion)YH( and then we + advance one of them, the other will advance as well. This, + for example, means that it doesn't make sense to store an + iter)HY(a)HY(tor)YH( that points to some object of inter)HY(est)YH( in the result + stream with the intent of deref)HY(er)HY(enc)HY(ing)YH( it after the iter)HY(a)HY(tion)YH( + is over. Instead, we would need to store the object itself.)EP( + + )0 P(The result iter)HY(a)HY(tor)YH( has the follow)HY(ing)YH( deref)HY(er)HY(ence)YH( func)HY(tions)YH( + that can be used to access the pointed-to object:)EP( + + ) 22 43 PR(namespace odb +{ + template + class result_iterator + { + public: + T* + operator-> \201\202 const; + + T& + operator* \201\202 const; + + typename object_traits::pointer_type + load \201\202; + + void + load \201T& x\202; + + typename object_traits::id_type + id \201\202; + }; +})RP( + + )0 P(When we call the )SM(*)ES( or )SM(->)ES( oper)HY(a)HY(tor)YH(, + the iter)HY(a)HY(tor)YH( will allo)HY(cate)YH( a new instance of the object class + in the dynamic memory, load its state from the database + state, and return a refer)HY(ence)YH( or pointer to the new instance. The + iter)HY(a)HY(tor)YH( main)HY(tains)YH( the owner)HY(ship)YH( of the returned object and will + return the same pointer for subse)HY(quent)YH( calls to either of these + oper)HY(a)HY(tors)YH( until it is advanced to the next object or we call + the first )SM(load\201\202)ES( func)HY(tion)YH( \201see below\202. For example:)EP( + + ) 9 64 PR( result r \201db.query \201query::first == "John"\202\202; + + for \201result::iterator i \201r.begin \201\202\202; i != r.end \201\202;\202 + { + cout << i->last \201\202 << endl; // Create an object. + person& p \201*i\202; // Reference to the same object. + cout << p.age \201\202 << endl; + ++i; // Free the object. + })RP( + + )0 P(The over)HY(loaded)YH( )SM(result_iter)HY(a)HY(tor)YH(::load\201\202)ES( func)HY(tions)YH( are + similar to )SM(database::load\201\202)ES(. The first func)HY(tion)YH( + returns a dynam)HY(i)HY(cally)YH( allo)HY(cated)YH( instance of the current + object. As an opti)HY(miza)HY(tion)YH(, if the iter)HY(a)HY(tor)YH( already owns an object + as a result of an earlier + call to the )SM(*)ES( or )SM(->)ES( oper)HY(a)HY(tor)YH(, then it + relin)HY(quishes)YH( the owner)HY(ship)YH( of this object and returns it instead. + This allows us to write code like this without worry)HY(ing)YH( about + a double allo)HY(ca)HY(tion)YH(:)EP( + + ) 10 59 PR( result r \201db.query \201query::first == "John"\202\202; + + for \201result::iterator i \201r.begin \201\202\202; i != r.end \201\202; ++i\202 + { + if \201i->last == "Doe"\202 + { + auto_ptr p \201i.load \201\202\202; + ... + } + })RP( + + )0 P(Note, however, that because of this opti)HY(miza)HY(tion)YH(, a subse)HY(quent)YH( + to )SM(load\201\202)ES( call to the )SM(*)ES( or )SM(->)ES( + oper)HY(a)HY(tor)YH( results in the allo)HY(ca)HY(tion)YH( of a new object.)EP( + + )0 P(The second )SM(load\201\202)ES( func)HY(tion)YH( allows + us to load the current object's state into an exist)HY(ing)YH( instance. + For example:)EP( + + ) 9 59 PR( result r \201db.query \201query::first == "John"\202\202; + + person p; + for \201result::iterator i \201r.begin \201\202\202; i != r.end \201\202; ++i\202 + { + i.load \201p\202; + cout << p.last \201\202 << endl; + cout << i.age \201\202 << endl; + })RP( + + )0 P(The )SM(id\201\202)ES( func)HY(tion)YH( return the object id of the current + object. While we can achieve the same by loading the object and getting + its id, this func)HY(tion)YH( is more effi)HY(cient)YH( since it doesn't actu)HY(ally)YH( + create the object. This can be useful when all we need is the object's + iden)HY(ti)HY(fier)YH(. For example:)EP( + + ) 11 62 PR( std::set set = ...; // Persons of interest. + + result r \201db.query \201query::first == "John"\202\202; + + for \201result::iterator i \201r.begin \201\202\202; i != r.end \201\202; ++i\202 + { + if \201set.find \201i.id \201\202\202 != set.end \201\202\202 // No object loaded. + { + cout << i->first \201\202 << endl; // Object loaded. + } + })RP( + + )0 2 40 H(4.5)WB 365 Sn()WB 44 Sn( Prepared Queries)EA()EH( + + )0 P(Most modern rela)HY(tional)YH( database systems have the notion of a prepared + state)HY(ment)YH(. Prepared state)HY(ments)YH( allow us to perform the poten)HY(tially)YH( + expen)HY(sive)YH( tasks of parsing SQL, prepar)HY(ing)YH( the query execu)HY(tion)YH( + plan, etc., once and then execut)HY(ing)YH( the same query multi)HY(ple)YH( + times, poten)HY(tially)YH( using differ)HY(ent)YH( values for param)HY(e)HY(ters)YH( in + each execu)HY(tion)YH(.)EP( + + )0 P(In ODB all the non-query database oper)HY(a)HY(tions)YH( such as + )SM(persist\201\202)ES(, )SM(load\201\202)ES(, )SM(update\201\202)ES(, + etc., are imple)HY(mented)YH( in terms of prepared state)HY(ments)YH( that are cached + and reused. While the )SM(query\201\202)ES(, )SM(query_one\201\202)ES(, + and )SM(query_one\201\202)ES( database oper)HY(a)HY(tions)YH( also use prepared + state)HY(ments)YH(, these state)HY(ments)YH( are not cached or reused by default since + ODB has no knowl)HY(edge)YH( of whether a query will be executed multi)HY(ple)YH( times + or only once. Instead, ODB provides a mech)HY(a)HY(nism)YH(, called prepared queries, + that allows us to prepare a query once and execute it multi)HY(ple)YH( + times. In other words, ODB prepared queries are a thin wrapper + around the under)HY(ly)HY(ing)YH( database's prepared state)HY(ment)YH( func)HY(tion)HY(al)HY(ity)YH(.)EP( + + )0 P(In most cases ODB shields the appli)HY(ca)HY(tion)YH( devel)HY(oper)YH( from database + connec)HY(tion)YH( manage)HY(ment)YH( and multi-thread)HY(ing)YH( issues. However, when it + comes to prepared queries, a basic under)HY(stand)HY(ing)YH( of how ODB manages + these aspects is required. Concep)HY(tu)HY(ally)YH(, the )SM(odb::database)ES( + class repre)HY(sents)YH( a specific database, that is, a data store. However, + under)HY(neath)YH(, it main)HY(tains)YH( one or more connec)HY(tions)YH( to this database. + A connec)HY(tion)YH( can be used only by a single thread at a time. When + we start a trans)HY(ac)HY(tion)YH( \201by calling )SM(database::begin\201\202)ES(\202, + the trans)HY(ac)HY(tion)YH( instance obtains a connec)HY(tion)YH( and holds on to it + until the trans)HY(ac)HY(tion)YH( is commit)HY(ted)YH( or rolled back. During this time + no other thread can use this connec)HY(tion)YH(. When the trans)HY(ac)HY(tion)YH( + releases the connec)HY(tion)YH(, it may be closed or reused by another + trans)HY(ac)HY(tion)YH( in this or another thread. What exactly happens to + a connec)HY(tion)YH( after it has been released depends on the connec)HY(tion)YH( + factory that is used by the )SM(odb::database)ES( instance. + For more infor)HY(ma)HY(tion)YH( on connec)HY(tion)YH( facto)HY(ries)YH(, refer to + )0 204 1 A(Part II, "Database Systems")204 0 TN TL()Ec /AF f D(.)EP( + + )0 P(A query prepared on one connec)HY(tion)YH( cannot be executed on another. + In other words, a prepared query is asso)HY(ci)HY(ated)YH( with the connec)HY(tion)YH(. + One impor)HY(tant)YH( impli)HY(ca)HY(tion)YH( of this restric)HY(tion)YH( is that we cannot + prepare a query in one trans)HY(ac)HY(tion)YH( and then try to execute it + in another without making sure that both trans)HY(ac)HY(tions)YH( use the + same connec)HY(tion)YH(.)EP( + + )0 P(To enable the prepared query func)HY(tion)HY(al)HY(ity)YH( we need to specify + the )SM(--gener)HY(ate)YH(-prepared)ES( ODB compiler option. If + we are plan)HY(ning)YH( to always prepare our queries, then we can + disable the once-off query execu)HY(tion)YH( support by also spec)HY(i)HY(fy)HY(ing)YH( + the )SM(--omit-unpre)HY(pared)YH()ES( option.)EP( + + )0 P(To prepare a query we use the )SM(prepare_query\201\202)ES( func)HY(tion)YH( + template. This func)HY(tion)YH( can be called on both the )SM(odb::database)ES( + and )SM(odb::connec)HY(tion)YH()ES( instances. The )SM(odb::database)ES( + version simply obtains the connec)HY(tion)YH( used by the currently active + trans)HY(ac)HY(tion)YH( and calls the corre)HY(spond)HY(ing)YH( )SM(odb::connec)HY(tion)YH()ES( + version. If no trans)HY(ac)HY(tion)YH( is currently active, then this func)HY(tion)YH( + throws the )SM(odb::not_in_trans)HY(ac)HY(tion)YH()ES( excep)HY(tion)YH( + \201)0 28 1 A(Section 3.5, "Trans)HY(ac)HY(tions)YH(")28 0 TN TL()Ec /AF f D(\202. The + )SM(prepare_query\201\202)ES( func)HY(tion)YH( has the follow)HY(ing)YH( signa)HY(ture)YH(:)EP( + + ) 3 57 PR( template + prepared_query + prepare_query \201const char* name, const odb::query&\202;)RP( + + )0 P(The first argu)HY(ment)YH( to the )SM(prepare_query\201\202)ES( func)HY(tion)YH( is + the prepared query name. This name is used as a key for prepared + query caching \201discussed later\202 and must be unique. For some databases, + notably Post)HY(greSQL)YH(, it is also used as a name of the under)HY(ly)HY(ing)YH( prepared + state)HY(ment)YH(. The name )SM(")I(object)ES(_query")ES( \201for example, + )SM("person_query")ES(\202 is reserved for the once-off queries + executed by the )SM(database::query\201\202)ES( func)HY(tion)YH(. Note that + the )SM(prepare_query\201\202)ES( func)HY(tion)YH( makes only a shallow copy + of this argu)HY(ment)YH(, which means that the name must be valid for the + life)HY(time)YH( of the returned )SM(prepared_query)ES( instance.)EP( + + )0 P(The second argu)HY(ment)YH( to the )SM(prepare_query\201\202)ES( func)HY(tion)YH( + is the query crite)HY(ria)YH(. It has the same seman)HY(tics)YH( as in the + )SM(query\201\202)ES( func)HY(tion)YH( discussed in )0 42 1 A(Section + 4.3, "Execut)HY(ing)YH( a Query")42 0 TN TL()Ec /AF f D(. Similar to )SM(query\201\202)ES(, we + also have to explic)HY(itly)YH( specify the object type that we will be + query)HY(ing)YH(. For example:)EP( + + ) 5 66 PR(typedef odb::query query; +typedef odb::prepared_query prep_query; + +prep_query pq \201 + db.prepare_query \201"person-age-query", query::age > 50\202\202;)RP( + + )0 P(The result of execut)HY(ing)YH( the )SM(prepare_query\201\202)ES( func)HY(tion)YH( is + the )SM(prepared_query)ES( instance that repre)HY(sent)YH( the prepared + query. It is best to view )SM(prepared_query)ES( as a handle to + the under)HY(ly)HY(ing)YH( prepared state)HY(ment)YH(. While we can make a copy of it or + assign one )SM(prepared_query)ES( to another, the two instances + will refer to the same prepared state)HY(ment)YH(. Once the last instance of + )SM(prepared_query)ES( refer)HY(enc)HY(ing)YH( a specific prepared state)HY(ment)YH( + is destroyed, this state)HY(ment)YH( is released. The )SM(prepared_query)ES( + class template has the follow)HY(ing)YH( inter)HY(face)YH(:)EP( + + ) 31 53 PR(namespace odb +{ + template + struct prepared_query + { + prepared_query \201\202; + + prepared_query \201const prepared_query&\202 + prepared_query& operator= \201const prepared_query&\202 + + result + execute \201bool cache = true\202; + + typename object_traits::pointer_type + execute_one \201\202; + + bool + execute_one \201T& object\202; + + T + execute_value \201\202; + + const char* + name \201\202 const; + + statement& + statement \201\202 const; + + operator unspecified_bool_type \201\202 const; + }; +})WR()RP( + + )0 P(The default construc)HY(tor)YH( creates an empty )SM(prepared_query)ES( + instance, that is, an instance that does not refer)HY(ence)YH( a prepared + state)HY(ment)YH( and there)HY(fore)YH( cannot be executed. The only way to create + a non-empty prepared query is by calling the )SM(prepare_query\201\202)ES( + func)HY(tion)YH( discussed above. To test whether the prepared query is empty, + we can use the implicit conver)HY(sion)YH( oper)HY(a)HY(tor)YH( to a boolean type. For + example:)EP( + + ) 7 28 PR( prepared_query pq; + + if \201pq\202 + { + // Not empty. + ... + })RP( + + )0 P(The )SM(execute\201\202)ES( func)HY(tion)YH( executes the query and returns + the result instance. The )SM(cache)ES( argu)HY(ment)YH( indi)HY(cates)YH( + whether the result should be cached and has the same seman)HY(tics)YH( + as in the )SM(query\201\202)ES( func)HY(tion)YH(. In fact, concep)HY(tu)HY(ally)YH(, + )SM(prepare_query\201\202)ES( and )SM(execute\201\202)ES( are just + the )SM(query\201\202)ES( func)HY(tion)YH( split into two: + )SM(prepare_query\201\202)ES( takes the first + )SM(query\201\202)ES( argu)HY(ment)YH( \201the query condi)HY(tion)YH(\202 while + )SM(execute\201\202)ES( takes the second \201the cache flag\202. Note + also that re-execut)HY(ing)YH( a prepared query inval)HY(i)HY(dates)YH( the + previ)HY(ous)YH( execu)HY(tion)YH( result, whether cached or uncached. )EP( + + )0 P(The )SM(execute_one\201\202)ES( and )SM(execute_value\201\202)ES( + func)HY(tions)YH( can be used as short)HY(cuts)YH( to execute a query that is + known to return at most one or exactly one object, respec)HY(tively)YH(. + The argu)HY(ments)YH( and return values in these func)HY(tions)YH( have the same + seman)HY(tics)YH( as in )SM(query_one\201\202)ES( and )SM(query_value\201\202)ES(. + And similar to )SM(execute\201\202)ES( above, )SM(prepare_query\201\202)ES( + and )SM(execute_one/value\201\202)ES( can be seen as the + )SM(query_one/value\201\202)ES( func)HY(tion)YH( split into two: + )SM(prepare_query\201\202)ES( takes the first + )SM(query_one/value\201\202)ES( argu)HY(ment)YH( \201the query condi)HY(tion)YH(\202 while + )SM(execute_one/value\201\202)ES( takes the second argu)HY(ment)YH( \201if any\202 + and returns the result. Note also that )SM(execute_one/value\201\202)ES( + never caches its result but inval)HY(i)HY(dates)YH( the result of any previ)HY(ous)YH( + )SM(execute\201\202)ES( call on the same prepared query.)EP( + + )0 P(The )SM(name\201\202)ES( func)HY(tion)YH( returns the prepared query name. + This is the same name as was passed as the first argu)HY(ment)YH( in the + )SM(prepare_query\201\202)ES( call. The )SM(state)HY(ment)YH(\201\202)ES( + func)HY(tion)YH( returns a refer)HY(ence)YH( to the under)HY(ly)HY(ing)YH( prepared state)HY(ment)YH(. + Note also that calling any of these func)HY(tions)YH( on an empty + )SM(prepared_query)ES( instance results in unde)HY(fined)YH( behav)HY(ior)YH(.)EP( + + )0 P(The simplest use-case for a prepared query is the need to + execute the same query multi)HY(ple)YH( times within a single trans)HY(ac)HY(tion)YH(. + Consider the follow)HY(ing)YH( example that queries for people that are older + than a number of differ)HY(ent)YH( ages. This and subse)HY(quent)YH( code frag)HY(ments)YH( + are taken from the )SM(prepared)ES( example in the + )SM(odb-exam)HY(ples)YH()ES( package.)EP( + + ) 17 65 PR(typedef odb::query query; +typedef odb::prepared_query prep_query; +typedef odb::result result; + +transaction t \201db.begin \201\202\202; + +unsigned short age; +query q \201query::age > query::_ref \201age\202\202; +prep_query pq \201db.prepare_query \201"person-age-query", q\202\202; + +for \201age = 90; age > 40; age -= 10\202 +{ + result r \201pq.execute \201\202\202; + ... +} + +t.commit \201\202;)RP( + + )0 P(Another scenario is the need to reuse the same query in multi)HY(ple)YH( + trans)HY(ac)HY(tions)YH( that are executed at once. As was mentioned above, + in this case we need to make sure that the prepared query and + all the trans)HY(ac)HY(tions)YH( use the same connec)HY(tion)YH(. Consider an + alter)HY(na)HY(tive)YH( version of the above example that executes each + query in a sepa)HY(rate)YH( trans)HY(ac)HY(tion)YH(:)EP( + + ) 15 68 PR(connection_ptr conn \201db.connection \201\202\202; + +unsigned short age; +query q \201query::age > query::_ref \201age\202\202; +prep_query pq \201conn->prepare_query \201"person-age-query", q\202\202; + +for \201age = 90; age > 40; age -= 10\202 +{ + transaction t \201conn->begin \201\202\202; + + result r \201pq.execute \201\202\202; + ... + + t.commit \201\202; +})RP( + + + )0 P(Note that with this approach we hold on to the database connec)HY(tion)YH( + until all the trans)HY(ac)HY(tions)YH( involv)HY(ing)YH( the prepared query are + executed. In partic)HY(u)HY(lar)YH(, this means that while we are busy, the + connec)HY(tion)YH( cannot be reused by another thread. There)HY(fore)YH(, this + approach is only recom)HY(mended)YH( if all the trans)HY(ac)HY(tions)YH( are executed + close to each other. Also note that an uncached \201see below\202 + prepared query is inval)HY(i)HY(dated)YH( once we release the connec)HY(tion)YH( + on which it was prepared.)EP( + + )0 P(If we need to reuse a prepared query in trans)HY(ac)HY(tions)YH( that are + executed at various times, poten)HY(tially)YH( in differ)HY(ent)YH( threads, then + the recom)HY(mended)YH( approach is to cache the prepared query on the + connec)HY(tion)YH(. To support this func)HY(tion)HY(al)HY(ity)YH( the )SM(odb::database)ES( + and )SM(odb::connec)HY(tion)YH()ES( classes provide the follow)HY(ing)YH( + func)HY(tion)YH( templates. Similar to )SM(prepare_query\201\202)ES(, + the )SM(odb::database)ES( versions of the below + func)HY(tions)YH( call the corre)HY(spond)HY(ing)YH( )SM(odb::connec)HY(tion)YH()ES( + versions using the currently active trans)HY(ac)HY(tion)YH( to resolve + the connec)HY(tion)YH(.)EP( + + ) 16 52 PR( template + void + cache_query \201const prepared_query&\202; + + template + void + cache_query \201const prepared_query&, + std::[auto|unique]_ptr

params\202; + + template + prepared_query + lookup_query \201const char* name\202 const; + + template + prepared_query + lookup_query \201const char* name, P*& params\202 const;)RP( + + )0 P(The )SM(cache_query\201\202)ES( func)HY(tion)YH( caches the passed prepared + query on the connec)HY(tion)YH(. The second over)HY(loaded)YH( version of + )SM(cache_query\201\202)ES( also takes a pointer to the + by-refer)HY(ence)YH( query param)HY(e)HY(ters)YH(. In C++98/03 it should be + )SM(std::auto_ptr)ES( while in C++11 )SM(std::auto_ptr)ES( + or )SM(std::unique_ptr)ES( can be used. The + )SM(cache_query\201\202)ES( func)HY(tion)YH( assumes owner)HY(ship)YH( of the + passed )SM(params)ES( argu)HY(ment)YH(. If a prepared query + with the same name is already cached on this connec)HY(tion)YH(, + then the )SM(odb::prepared_already_cached)ES( excep)HY(tion)YH( + is thrown.)EP( + + )0 P(The )SM(lookup_query\201\202)ES( func)HY(tion)YH( looks up a previ)HY(ously)YH( + cached prepared query given its name. The second over)HY(loaded)YH( + version of )SM(lookup_query\201\202)ES( also returns a pointer + to the by-refer)HY(ence)YH( query param)HY(e)HY(ters)YH(. If a prepared query + with this name has not been cached, then an empty + )SM(prepared_query)ES( instance is returned. If a + prepared query with this name has been cached but either + the object type or the param)HY(e)HY(ters)YH( type does not match + that which was cached, then the )SM(odb::prepared_type_mismatch)ES( + excep)HY(tion)YH( is thrown.)EP( + + )0 P(As a first example of the prepared query cache func)HY(tion)HY(al)HY(ity)YH(, + consider the case that does not use any by-refer)HY(ence)YH( param)HY(e)HY(ters)YH(:)EP( + + ) 22 63 PR(for \201unsigned short i \2010\202; i < 5; ++i\202 +{ + transaction t \201db.begin \201\202\202; + + prep_query pq \201db.lookup_query \201"person-age-query"\202\202; + + if \201!pq\202 + { + pq = db.prepare_query \201 + "person-val-age-query", query::age > 50\202; + db.cache_query \201pq\202; + } + + result r \201pq.execute \201\202\202; + ... + + t.commit \201\202; + + // Do some other work. + // + ... +})RP( + + )0 P(The follow)HY(ing)YH( example shows how to do the same but for a query that + includes by-refer)HY(ence)YH( param)HY(e)HY(ters)YH(. In this case the param)HY(e)HY(ters)YH( are + cached together with the prepared query.)EP( + + ) 27 61 PR(for \201unsigned short age \20190\202; age > 40; age -= 10\202 +{ + transaction t \201db.begin \201\202\202; + + unsigned short* age_param; + prep_query pq \201 + db.lookup_query \201"person-age-query", age_param\202\202; + + if \201!pq\202 + { + auto_ptr p \201new unsigned short\202; + age_param = p.get \201\202; + query q \201query::age > query::_ref \201*age_param\202\202; + pq = db.prepare_query \201"person-age-query", q\202; + db.cache_query \201pq, p\202; // Assumes ownership of p. + } + + *age_param = age; // Initialize the parameter. + result r \201pq.execute \201\202\202; + ... + + t.commit \201\202; + + // Do some other work. + // + ... +})RP( + + )0 P(As is evident from the above exam)HY(ples)YH(, when we use a prepared + query cache, each trans)HY(ac)HY(tion)YH( that executes a query must also + include code that prepares and caches this query if it hasn't already + been done. If a prepared query is used in a single place in the + appli)HY(ca)HY(tion)YH(, then this is normally not an issue since all the + rele)HY(vant)YH( code is kept in one place. However, if the same query + is used in several differ)HY(ent)YH( places in the appli)HY(ca)HY(tion)YH(, then + we may end up dupli)HY(cat)HY(ing)YH( the same prepa)HY(ra)HY(tion)YH( and caching + code, which makes it hard to main)HY(tain)YH(.)EP( + + )0 P(To resolve this issue ODB allows us to regis)HY(ter)YH( a prepared + query factory that will be called to prepare and cache a + query during the call to )SM(lookup_query\201\202)ES(. To + regis)HY(ter)YH( a factory we use the )SM(database::query_factory\201\202)ES( + func)HY(tion)YH(. In C++98/03 it has the follow)HY(ing)YH( signa)HY(ture)YH(:)EP( + + ) 3 66 PR( void + query_factory \201const char* name, + void \201*factory\202 \201const char* name, connection&\202\202;)RP( + + )0 P(While in C++11 it uses the )SM(std::func)HY(tion)YH()ES( class + template:)EP( + + ) 3 70 PR( void + query_factory \201const char* name, + std::function\202;)RP( + + )0 P(The first argu)HY(ment)YH( to the )SM(query_factory\201\202)ES( func)HY(tion)YH( is + the prepared query name that this factory will be called to prepare + and cache. An empty name is treated as a fall)HY(back)YH( wild)HY(card)YH( factory + that is capable of prepar)HY(ing)YH( any query. The second argu)HY(ment)YH( is the + factory func)HY(tion)YH( or, in C++11, func)HY(tion)YH( object or lambda.)EP( + + )0 P(The example frag)HY(ment)YH( shows how we can use the prepared query + factory:)EP( + + ) 33 71 PR(struct params +{ + unsigned short age; + string first; +}; + +static void +query_factory \201const char* name, connection& c\202 +{ + auto_ptr p \201new params\202; + query q \201query::age > query::_ref \201p->age\202 && + query::first == query::_ref \201p->first\202\202; + prep_query pq \201c.prepare_query \201name, q\202\202; + c.cache_query \201pq, p\202; +} + +db.query_factory \201"person-age-name-query", &query_factory\202; + +for \201unsigned short age \20190\202; age > 40; age -= 10\202 +{ + transaction t \201db.begin \201\202\202; + + params* p; + prep_query pq \201db.lookup_query \201"person-age-name-query", p\202\202; + assert \201pq\202; + + p->age = age; + p->first = "John"; + result r \201pq.execute \201\202\202; + ... +)WR( + t.commit \201\202; +})RP( + + )0 P(In C++11 we could have instead used a lambda func)HY(tion)YH( as well as + )SM(unique_ptr)ES( rather than )SM(auto_ptr)ES(:)EP( + + ) 10 54 PR(db.query_factory \201 + "person-age-name-query", + [] \201const char* name, connection& c\202 + { + unique_ptr p \201new params\202; + query q \201query::age > query::_ref \201p->age\202 && + query::first == query::_ref \201p->first\202\202; + prep_query pq \201c.prepare_query \201name, q\202\202; + c.cache_query \201pq, std::move \201p\202\202; + }\202;)RP( + + + + )WB NL NP( + )0 1 41 H(5)WB 366 Sn()WB 45 Sn( Contain)HY(ers)YH()EA()EH( + + )0 P(The ODB runtime library provides built-in persis)HY(tence)YH( support for all the + commonly used stan)HY(dard)YH( C++98/03 contain)HY(ers)YH(, namely, + )SM(std::vector)ES(, )SM(std::list)ES(, )SM(std::deque)ES(, + )SM(std::set)ES(, )SM(std::multi)HY(set)YH()ES(, )SM(std::map)ES(, and + )SM(std::multimap)ES( as well as C++11 )SM(std::array)ES(, + )SM(std::forward_list)ES(, )SM(std::unordered_set)ES(, + )SM(std::unordered_multi)HY(set)YH()ES(, )SM(std::unordered_map)ES(, + and )SM(std::unordered_multimap)ES(. + Plus, ODB profile libraries, that are + avail)HY(able)YH( for commonly used frame)HY(works)YH( and libraries \201such as Boost and + Qt\202, provide persis)HY(tence)YH( support for contain)HY(ers)YH( found in these frame)HY(works)YH( + and libraries \201)0 290 1 A(Part III, "Profiles")290 0 TN TL()Ec /AF f D(\202. Both the + ODB runtime library and profile libraries also provide a number of + change-track)HY(ing)YH( container equiv)HY(a)HY(lents)YH( which can be used to mini)HY(mize)YH( + the number of database oper)HY(a)HY(tions)YH( neces)HY(sary)YH( to synchro)HY(nize)YH( the container + state with the database \201)0 49 1 A(Section 5.4, "Change-Track)HY(ing)YH( + Contain)HY(ers)YH(")49 0 TN TL()Ec /AF f D(\202. It is also easy to persist custom container types + as discussed later in )0 51 1 A(Section 5.5, "Using Custom + Contain)HY(ers)YH(")51 0 TN TL()Ec /AF f D(.)EP( + + )0 P(We don't need to do anything special to declare a member of a + container type in a persis)HY(tent)YH( class. For example:)EP( + + ) 8 38 PR(#pragma db object +class person +{ + ... +private: + std::vector nicknames_; + ... +};)RP( + + )0 P(The complete version of the above code frag)HY(ment)YH( and the other code + samples presented in this chapter can be found in the )SM(container)ES( + example in the )SM(odb-exam)HY(ples)YH()ES( package.)EP( + + )0 P(A data member in a persis)HY(tent)YH( class that is of a container type + behaves like a value type. That is, when an object is made persis)HY(tent)YH(, + the elements of the container are stored in the database. Simi)HY(larly)YH(, + when a persis)HY(tent)YH( object is loaded from the database, the contents + of the container are auto)HY(mat)HY(i)HY(cally)YH( loaded as well. A data member + of a container type can also use a smart pointer, as discussed + in )0 68 1 A(Section 7.3, "Point)HY(ers)YH( and )SM(NULL)ES( + Value Seman)HY(tics)YH(")68 0 TN TL()Ec /AF f D(.)EP( + + )0 P(While an ordi)HY(nary)YH( member is mapped to one or more columns in the + object's table, a member of a container type is mapped to a sepa)HY(rate)YH( + table. The exact schema of such a table depends on the kind of + container. ODB defines the follow)HY(ing)YH( container kinds: ordered, + set, multi)HY(set)YH(, map, and multimap. The container kinds and the + contents of the tables to which they are mapped are discussed + in detail in the follow)HY(ing)YH( sections.)EP( + + )0 P(Contain)HY(ers)YH( in ODB can contain simple value types \201)0 64 1 A(Section + 7.1, "Simple Value Types")64 0 TN TL()Ec /AF f D(\202, compos)HY(ite)YH( value types + \201)0 65 1 A(Section 7.2, "Compos)HY(ite)YH( Value Types")65 0 TN TL()Ec /AF f D(\202, and point)HY(ers)YH( + to objects \201)0 52 1 A(Chapter 6, "Rela)HY(tion)HY(ships)YH(")52 0 TN TL()Ec /AF f D(\202. Contain)HY(ers)YH( of + contain)HY(ers)YH(, either directly or indi)HY(rectly)YH( via a compos)HY(ite)YH( value + type, are not allowed. A key in a map or multimap container can + be a simple or compos)HY(ite)YH( value type but not a pointer to an object. + An index in the ordered container should be a simple integer value + type.)EP( + + )0 P(The value type in the ordered, set, and map contain)HY(ers)YH( as well as + the key type in the map contain)HY(ers)YH( should be default-constructible. + The default construc)HY(tor)YH( in these types can be made private in which + case the )SM(odb::access)ES( class should be made a friend of + the value or key type. For example:)EP( + + ) 20 48 PR(#pragma db value +class name +{ +public: + name \201const std::string&, const std::string&\202; + ... +private: + friend class odb::access; + name \201\202; + ... +}; + +#pragma db object +class person +{ + ... +private: + std::vector aliases_; + ... +};)RP( + + + )0 2 42 H(5.1)WB 367 Sn()WB 46 Sn( Ordered Contain)HY(ers)YH()EA()EH( + + )0 P(In ODB an ordered container is any container that main)HY(tains)YH( \201explic)HY(itly)YH( + or implic)HY(itly)YH(\202 an order of its elements in the form of an integer index. + Stan)HY(dard)YH( C++ contain)HY(ers)YH( that are ordered include )SM(std::vector)ES( + )SM(std::list)ES(, and )SM(std::deque)ES( as well as C++11 )SM(std::array)ES( and + )SM(std::forward_list)ES(. While elements in )SM(std::set)ES( + are also kept in a specific order, this order is not based on an + integer index but rather on the rela)HY(tion)HY(ship)YH( between elements. As + a result, )SM(std::set)ES( is not consid)HY(ered)YH( an ordered + container for the purpose of persis)HY(tence)YH(.)EP( + + )0 P(The database table for an ordered container consists of at least + three columns. The first column contains the object id of a + persis)HY(tent)YH( class instance of which the container is a member. + The second column contains the element index within a container. + And the last column contains the element value. If the object + id or element value are compos)HY(ite)YH(, then, instead of a single + column, they can occupy multi)HY(ple)YH( columns. For an ordered + container table the ODB compiler also defines two indexes: + one for the object id column\201s\202 and the other for the index + column. Refer to )0 191 1 A(Section 14.7, "Index Defi)HY(ni)HY(tion)YH( + Pragmas")191 0 TN TL()Ec /AF f D( for more infor)HY(ma)HY(tion)YH( on how to customize these + indexes.)EP( + + )0 P(Consider the follow)HY(ing)YH( persis)HY(tent)YH( object as an example:)EP( + + ) 11 38 PR(#pragma db object +class person +{ + ... +private: + #pragma db id auto + unsigned long id_; + + std::vector nicknames_; + ... +};)RP( + + )0 P(The result)HY(ing)YH( database table \201called )SM(person_nick)HY(names)YH()ES(\202 will + contain the object id column of type )SM(unsigned\240long)ES( + \201called )SM(object_id)ES(\202, the index column of an integer type + \201called )SM(index)ES(\202, and the value column of type + )SM(std::string)ES( \201called )SM(value)ES(\202.)EP( + + )0 P(A number of ODB pragmas allow us to customize the table name, column + names, and native database types of an ordered container both, on + the per-container and per-member basis. For more infor)HY(ma)HY(tion)YH( on + these pragmas, refer to )0 100 1 A(Chapter 14, "ODB Pragma + Language")100 0 TN TL()Ec /AF f D(. The follow)HY(ing)YH( example shows some of the possi)HY(ble)YH( + customiza)HY(tions)YH(:)EP( + + ) 14 46 PR(#pragma db object +class person +{ + ... +private: + #pragma db table\201"nicknames"\202 \200 + id_column\201"person_id"\202 \200 + index_type\201"SMALLINT UNSIGNED"\202 \200 + index_column\201"nickname_number"\202 \200 + value_type\201"VARCHAR\201255\202"\202 \200 + value_column\201"nickname"\202 + std::vector nicknames_; + ... +};)RP( + + )0 P(While the C++ container used in a persis)HY(tent)YH( class may be ordered, + some)HY(times)YH( we may wish to store such a container in the database without + the order infor)HY(ma)HY(tion)YH(. In the example above, for instance, the order + of person's nick)HY(names)YH( is prob)HY(a)HY(bly)YH( not impor)HY(tant)YH(. To instruct the ODB + compiler to ignore the order in ordered contain)HY(ers)YH( we can use the + )SM(db\240unordered)ES( pragma \201)0 134 1 A(Section 14.3.9, + ")SM(unordered)ES(")134 0 TN TL()Ec /AF f D(, )0 166 1 A(Section 14.4.19, + ")SM(unordered)ES(")166 0 TN TL()Ec /AF f D(\202. For example:)EP( + + ) 9 38 PR(#pragma db object +class person +{ + ... +private: + #pragma db unordered + std::vector nicknames_; + ... +};)RP( + + )0 P(The table for an ordered container that is marked unordered won't + have the index column and the order in which elements are retrieved + from the database may not be the same as the order in which they + were stored.)EP( + + )0 2 43 H(5.2)WB 368 Sn()WB 47 Sn( Set and Multi)HY(set)YH( Contain)HY(ers)YH()EA()EH( + + )0 P(In ODB set and multi)HY(set)YH( contain)HY(ers)YH( \201referred to as just set + contain)HY(ers)YH(\202 are asso)HY(cia)HY(tive)YH( contain)HY(ers)YH( that contain elements + based on some rela)HY(tion)HY(ship)YH( between them. A set container may + or may not guar)HY(an)HY(tee)YH( a partic)HY(u)HY(lar)YH( order of the elements that + it stores. Stan)HY(dard)YH( C++ contain)HY(ers)YH( that are consid)HY(ered)YH( set + contain)HY(ers)YH( for the purpose of persis)HY(tence)YH( include + )SM(std::set)ES( and )SM(std::multi)HY(set)YH()ES( as well + as C++11 )SM(std::unordered_set)ES( and + )SM(std::unordered_multi)HY(set)YH()ES(.)EP( + + )0 P(The database table for a set container consists of at least + two columns. The first column contains the object id of a + persis)HY(tent)YH( class instance of which the container is a member. + And the second column contains the element value. If the object + id or element value are compos)HY(ite)YH(, then, instead of a single + column, they can occupy multi)HY(ple)YH( columns. ODB compiler also + defines an index on a set container table for the object id + column\201s\202. Refer to )0 191 1 A(Section 14.7, "Index Defi)HY(ni)HY(tion)YH( + Pragmas")191 0 TN TL()Ec /AF f D( for more infor)HY(ma)HY(tion)YH( on how to customize this + index.)EP( + + )0 P(Consider the follow)HY(ing)YH( persis)HY(tent)YH( object as an example:)EP( + + ) 11 32 PR(#pragma db object +class person +{ + ... +private: + #pragma db id auto + unsigned long id_; + + std::set emails_; + ... +};)RP( + + )0 P(The result)HY(ing)YH( database table \201called )SM(person_emails)ES(\202 will + contain the object id column of type )SM(unsigned\240long)ES( + \201called )SM(object_id)ES(\202 and the value column of type + )SM(std::string)ES( \201called )SM(value)ES(\202.)EP( + + )0 P(A number of ODB pragmas allow us to customize the table name, + column names, and native database types of a set container, both on + the per-container and per-member basis. For more infor)HY(ma)HY(tion)YH( on + these pragmas, refer to )0 100 1 A(Chapter 14, "ODB Pragma + Language")100 0 TN TL()Ec /AF f D(. The follow)HY(ing)YH( example shows some of the possi)HY(ble)YH( + customiza)HY(tions)YH(:)EP( + + ) 12 41 PR(#pragma db object +class person +{ + ... +private: + #pragma db table\201"emails"\202 \200 + id_column\201"person_id"\202 \200 + value_type\201"VARCHAR\201255\202"\202 \200 + value_column\201"email"\202 + std::set emails_; + ... +};)RP( + + )0 2 44 H(5.3)WB 369 Sn()WB 48 Sn( Map and Multimap Contain)HY(ers)YH()EA()EH( + + )0 P(In ODB map and multimap contain)HY(ers)YH( \201referred to as just map + contain)HY(ers)YH(\202 are asso)HY(cia)HY(tive)YH( contain)HY(ers)YH( that contain key-value + elements based on some rela)HY(tion)HY(ship)YH( between keys. A map container + may or may not guar)HY(an)HY(tee)YH( a partic)HY(u)HY(lar)YH( order of the elements that + it stores. Stan)HY(dard)YH( C++ contain)HY(ers)YH( that are consid)HY(ered)YH( map + contain)HY(ers)YH( for the purpose of persis)HY(tence)YH( include + )SM(std::map)ES( and )SM(std::multimap)ES( as well + as C++11 )SM(std::unordered_map)ES( and + )SM(std::unordered_multimap)ES(.)EP( + + )0 P(The database table for a map container consists of at least + three columns. The first column contains the object id of a + persis)HY(tent)YH( class instance of which the container is a member. + The second column contains the element key. And the last column + contains the element value. If the object id, element key, or + element value are compos)HY(ite)YH(, then instead of a single column + they can occupy multi)HY(ple)YH( columns. ODB compiler also + defines an index on a map container table for the object id + column\201s\202. Refer to )0 191 1 A(Section 14.7, "Index Defi)HY(ni)HY(tion)YH( + Pragmas")191 0 TN TL()Ec /AF f D( for more infor)HY(ma)HY(tion)YH( on how to customize this + index.)EP( + + )0 P(Consider the follow)HY(ing)YH( persis)HY(tent)YH( object as an example:)EP( + + ) 11 50 PR(#pragma db object +class person +{ + ... +private: + #pragma db id auto + unsigned long id_; + + std::map age_weight_map_; + ... +};)RP( + + )0 P(The result)HY(ing)YH( database table \201called )SM(person_age_weight_map)ES(\202 + will contain the object id column of type )SM(unsigned\240long)ES( + \201called )SM(object_id)ES(\202, the key column of type + )SM(unsigned short)ES( \201called )SM(key)ES(\202, and the value + column of type )SM(float)ES( \201called )SM(value)ES(\202.)EP( + + )0 P(A number of ODB pragmas allow us to customize the table name, + column names, and native database types of a map container, both on + the per-container and per-member basis. For more infor)HY(ma)HY(tion)YH( on + these pragmas, refer to )0 100 1 A(Chapter 14, "ODB Pragma + Language")100 0 TN TL()Ec /AF f D(. The follow)HY(ing)YH( example shows some of the possi)HY(ble)YH( + customiza)HY(tions)YH(:)EP( + + ) 14 50 PR(#pragma db object +class person +{ + ... +private: + #pragma db table\201"weight_map"\202 \200 + id_column\201"person_id"\202 \200 + key_type\201"INT UNSIGNED"\202 \200 + key_column\201"age"\202 \200 + value_type\201"DOUBLE"\202 \200 + value_column\201"weight"\202 + std::map age_weight_map_; + ... +};)RP( + + )0 2 45 H(5.4)WB 370 Sn()WB 49 Sn( Change-Track)HY(ing)YH( Contain)HY(ers)YH()EA()EH( + + )0 P(When a persis)HY(tent)YH( object contain)HY(ing)YH( one of the stan)HY(dard)YH( contain)HY(ers)YH( + is updated in the database, ODB has no knowl)HY(edge)YH( of which elements + were inserted, erased, or modi)HY(fied)YH(. As a result, ODB has no choice + but to assume the whole container has changed and update the state + of every single element. This can result in a signif)HY(i)HY(cant)YH( over)HY(head)YH( + if a container contains a large number of elements and we only + changed a small subset of them.)EP( + + )0 P(To elim)HY(i)HY(nate)YH( this over)HY(head)YH(, ODB provides a notion of )EM(change-track)HY(ing)YH( + contain)HY(ers)YH()ES(. A change-track)HY(ing)YH( container, besides contain)HY(ing)YH( + its elements, just like an ordi)HY(nary)YH( container, also includes the + change state for each element. When it is time to update such a + container in the database, ODB can use this change infor)HY(ma)HY(tion)YH( to + perform a minimum number of database oper)HY(a)HY(tions)YH( neces)HY(sary)YH( to + synchro)HY(nize)YH( the container state with the database.)EP( + + )0 P(The current version of the ODB runtime library provides a change-track)HY(ing)YH( + equiv)HY(a)HY(lent)YH( of )SM(std::vector)ES( \201)0 50 1 A(Section 5.4.1, + "Change-Track)HY(ing)YH( )SM(vector)ES(")50 0 TN TL()Ec /AF f D(\202 with support for other + stan)HY(dard)YH( container equiv)HY(a)HY(lents)YH( planned for future releases. ODB + profile libraries also provide change-track)HY(ing)YH( equiv)HY(a)HY(lents)YH( for some + contain)HY(ers)YH( found in the corre)HY(spond)HY(ing)YH( frame)HY(works)YH( and libraries + \201)0 290 1 A(Part III, "Profiles")290 0 TN TL()Ec /AF f D(\202.)EP( + + )0 P(A change-track)HY(ing)YH( container equiv)HY(a)HY(lent)YH( can normally be used as a drop-in + replace)HY(ment)YH( for an ordi)HY(nary)YH( container except for a few minor + inter)HY(face)YH( differ)HY(ences)YH( \201discussed in the corre)HY(spond)HY(ing)YH( sub-sections\202. + In partic)HY(u)HY(lar)YH(, we don't need to do anything extra to effect + change track)HY(ing)YH(. ODB will auto)HY(mat)HY(i)HY(cally)YH( start, stop, and reset + change track)HY(ing)YH( when neces)HY(sary)YH(. The follow)HY(ing)YH( example illus)HY(trates)YH( + this point using )SM(odb::vector)ES( as a replace)HY(ment)YH( for + )SM(std::vector)ES(.)EP( + + ) 47 72 PR(#pragma db object +class person +{ + ... + + odb::vector names; +}; + +person p; // No change tracking \201not persistent\202. +p.names.push_back \201"John Doe"\202; + +{ + transaction t \201db.begin \201\202\202; + db.persist \201p\202; // Start change tracking \201persistent\202. + t.commit \201\202; +} + +p.names.push_back \201"Johnny Doo"\202; + +{ + transaction t \201db.begin \201\202\202; + db.update \201p\202; // One INSERT; reset change state. + t.commit \201\202; +} + +p.names.modify \2010\202 = "Doe, John"; // Instead of operator[]. +p.names.pop_back \201\202; + +{ + transaction t \201db.begin \201\202\202; + db.update \201p\202; // One UPDATE, one DELETE; reset change state.)WR( + t.commit \201\202; +} + +{ + transaction t \201db.begin \201\202\202; + auto_ptr p1 \201db.load \201...\202\202; // Start change tracking. + p1->names.insert \201p1->names.begin \201\202, "Joe Do"\202; + db.update \201*p1\202; // One UPDATE, one INSERT; reset change state. + t.commit \201\202; +} + +{ + transaction t \201db.begin \201\202\202; + db.erase \201p\202; // One DELETE; stop change tracking \201not persistent\202. + t.commit \201\202; +})RP( + + )0 P(One inter)HY(est)HY(ing)YH( aspect of change track)HY(ing)YH( is what happens when a + trans)HY(ac)HY(tion)YH( that contains an update is later rolled back. In this + case, while the change-track)HY(ing)YH( container has reset the change + state \201after update\202, actual changes were not commit)HY(ted)YH( to the + database. Change-track)HY(ing)YH( contain)HY(ers)YH( handle this case by + auto)HY(mat)HY(i)HY(cally)YH( regis)HY(ter)HY(ing)YH( a roll)HY(back)YH( call)HY(back)YH( and then, if it is + called, marking the container as "completely changed". In this + state, the container no longer tracks indi)HY(vid)HY(ual)YH( element changes + and, when updated, falls back to the complete state update, just + like an ordi)HY(nary)YH( container. The follow)HY(ing)YH( example illus)HY(trates)YH( + this point:)EP( + + ) 30 69 PR(person p; +p.names.push_back \201"John Doe"\202; + +{ + transaction t \201db.begin \201\202\202; + db.persist \201p\202; // Start change tracking \201persistent\202. + t.commit \201\202; +} + +p.names.push_back \201"Johnny Doo"\202; + +for \201;;\202 +{ + try + { + transaction t \201db.begin \201\202\202; + + // First try: one INSERT. + // Next try: one DELETE, two INSERTs. + // + db.update \201p\202; // Reset change state. + + t.commit \201\202; // If throws \201rollback\202, mark as completely changed. + break; + } + catch \201const odb::recoverable&\202 + { + continue; + } +})RP( + + )0 P(For the inter)HY(ac)HY(tion)YH( of change-track)HY(ing)YH( contain)HY(ers)YH( with change-updated + object sections, refer to )0 78 1 A(Section 9.4, "Sections and + Change-Track)HY(ing)YH( Contain)HY(ers)YH(")78 0 TN TL()Ec /AF f D(.)EP( + + )0 3 46 H(5.4.1)WB 371 Sn()WB 50 Sn( Change-Track)HY(ing)YH( )SM(vector)ES()EA()EH( + + )0 P(Class template )SM(odb::vector)ES(, defined in + )SM()ES(, is a change-track)HY(ing)YH( + equiv)HY(a)HY(lent)YH( for )SM(std::vector)ES(. It + is imple)HY(mented)YH( in terms of )SM(std::vector)ES( and is + implicit-convert)HY(ible)YH( to and implicit-constructible from + )SM(const std::vector&)ES(. In partic)HY(u)HY(lar)YH(, this + means that we can use )SM(odb::vector)ES( instance + anywhere )SM(const std::vector&)ES( is + expected. In addi)HY(tion)YH(, )SM(odb::vector)ES( constant + iter)HY(a)HY(tor)YH( \201)SM(const_iter)HY(a)HY(tor)YH()ES(\202 is the same type as + that of )SM(std::vector)ES(.)EP( + + )0 P()SM(odb::vector)ES( incurs 2-bit per element over)HY(head)YH( + in order to store the change state. It cannot + be stored unordered in the database \201)0 166 1 A(Section + 14.4.19 ")SM(unordered)ES(")166 0 TN TL()Ec /AF f D(\202 but can be used as an inverse + side of a rela)HY(tion)HY(ship)YH( \201)0 56 1 A(6.2 "Bidi)HY(rec)HY(tional)YH( + Rela)HY(tion)HY(ships)YH(")56 0 TN TL()Ec /AF f D(\202. In this case, no change track)HY(ing)YH( is performed + since no state for such a container is stored in the database.)EP( + + )0 P(The number of database oper)HY(a)HY(tions)YH( required to update the state + of )SM(odb::vector)ES( corre)HY(sponds)YH( well to the complex)HY(ity)YH( + of )SM(std::vector)ES( func)HY(tions)YH(. In partic)HY(u)HY(lar)YH(, adding or + remov)HY(ing)YH( an element from the back of the vector \201for example, + with )SM(push_back\201\202)ES( and )SM(pop_back\201\202)ES(\202, + requires only a single database state)HY(ment)YH( execu)HY(tion)YH(. In contrast, + insert)HY(ing)YH( or erasing an element some)HY(where)YH( in the middle of the + vector will require a database state)HY(ment)YH( for every element that + follows it.)EP( + + )0 P()SM(odb::vector)ES( repli)HY(cates)YH( most of the )SM(std::vector)ES( + inter)HY(face)YH( as defined in both C++98/03 and C++11 stan)HY(dards)YH(. However, + func)HY(tions)YH( and oper)HY(a)HY(tors)YH( that provide direct write access to + the elements had to be altered or disabled in order to support + change track)HY(ing)YH(. Addi)HY(tional)YH( func)HY(tions)YH( used to inter)HY(face)YH( with + )SM(std::vector)ES( and to control the change track)HY(ing)YH( state + were also added. The follow)HY(ing)YH( listing summa)HY(rizes)YH( the differ)HY(ences)YH( + between the )SM(odb::vector)ES( and )SM(std::vector)ES( + inter)HY(faces)YH(. Any )SM(std::vector)ES( func)HY(tion)YH( or oper)HY(a)HY(tor)YH( + not mentioned in this listing has exactly the same signa)HY(ture)YH( + and seman)HY(tics)YH( in )SM(odb::vector)ES(. Func)HY(tions)YH( and + oper)HY(a)HY(tors)YH( that were disabled are shown as commented out and + are followed by func)HY(tions)YH(/oper)HY(a)HY(tors)YH( that replace them.)EP( + + ) 80 70 PR(namespace odb +{ + template > + class vector + { + ... + + // Element access. + // + + //reference operator[] \201size_type\202; + reference modify \201size_type\202; + + //reference at \201size_type\202; + reference modify_at \201size_type\202; + + //reference front \201\202; + reference modify_front \201\202; + + //reference back \201\202; + reference modify_back \201\202; + + //T* data \201\202 noexcept; + T* modify_data \201\202 noexcept; // C++11 only. + + // Iterators. + // + typedef typename std::vector::const_iterator const_iterator; + + class iterator + {)WR( + ... + + // Element Access. + // + + //reference operator* \201\202 const; + const_reference operator* \201\202 const; + reference modify \201\202 const; + + //pointer operator-> \201\202 const; + const_pointer operator-> \201\202 const; + + //reference operator[] \201difference_type\202; + const_reference operator[] \201difference_type\202; + reference modify \201difference_type\202 const; + + // Interfacing with std::vector::iterator. + // + typename std::vector::iterator base \201\202 const; + }; + + // Return std::vector iterators. The begin\201\202 functions mark + // all the elements as modified. + // + typename std::vector::iterator mbegin \201\202; + typename std::vector::iterator mend \201\202; + typename std::vector::reverse_iterator mrbegin \201\202; + typename std::vector::reverse_iterator mrend \201\202; + + // Interfacing with std::vector.)WR( + // + vector \201const std::vector&\202; + vector \201std::vector&&\202; // C++11 only. + + vector& operator= \201const std::vector&\202; + vector& operator= \201std::vector&&\202; // C++11 only. + + operator const std::vector& \201\202 const; + std::vector& base \201\202; + const std::vector& base \201\202; + + // Change tracking. + // + bool _tracking \201\202 const; + void _start \201\202 const; + void _stop \201\202 const; + void _arm \201transaction&\202 const; + }; +})RP( + + )0 P(The follow)HY(ing)YH( example high)HY(lights)YH( some of the differ)HY(ences)YH( between + the two inter)HY(faces)YH(. )SM(std::vector)ES( versions are commented + out.)EP( + + ) 24 45 PR(#include +#include + +void f \201const std::vector&\202; + +odb::vector v \201{1, 2, 3}\202; + +f \201v\202; // Ok, implicit conversion. + +if \201v[1] == 2\202 // Ok, const access. + //v[1]++; + v.modify \2011\202++; + +//v.back \201\202 = 4; +v.modify_back \201\202 = 4; + +for \201auto i \201v.begin \201\202\202; i != v.end \201\202; ++i\202 +{ + if \201*i != 0\202 // Ok, const access. + //*i += 10; + i.modify \201\202 += 10; +} + +std::sort \201v.mbegin \201\202, v.mend \201\202\202;)RP( + + )0 P(Note also the subtle differ)HY(ence)YH( between copy/move construc)HY(tion)YH( + and copy/move assign)HY(ment)YH( of )SM(odb::vector)ES( instances. + While copy/move construc)HY(tor)YH( will copy/move both the elements as + well as their change state, in contrast, assign)HY(ment)YH( is tracked + as any other change to the vector content.)EP( + + )0 2 47 H(5.5)WB 372 Sn()WB 51 Sn( Using Custom Contain)HY(ers)YH()EA()EH( + + )0 P(While the ODB runtime and profile libraries provide support for + a wide range of contain)HY(ers)YH(, it is also easy to persist custom + container types or make a change-track)HY(ing)YH( version out of one.)EP( + + )0 P(To achieve this you will need to imple)HY(ment)YH( the + )SM(container_traits)ES( class template special)HY(iza)HY(tion)YH( for + your container. First, deter)HY(mine)YH( the container kind \201ordered, set, + multi)HY(set)YH(, map, or multimap\202 for your container type. Then use a + special)HY(iza)HY(tion)YH( for one of the stan)HY(dard)YH( C++ contain)HY(ers)YH( found in + the common ODB runtime library \201)SM(libodb)ES(\202 as a base + for your own imple)HY(men)HY(ta)HY(tion)YH(.)EP( + + )0 P(Once the container traits special)HY(iza)HY(tion)YH( is ready for your container, + you will need to include it into the ODB compi)HY(la)HY(tion)YH( process using + the )SM(--odb-epilogue)ES( option and into the gener)HY(ated)YH( header + files with the )SM(--hxx-prologue)ES( option. As an example, + suppose we have a hash table container for which we have the traits + special)HY(iza)HY(tion)YH( imple)HY(mented)YH( in the )SM(hashtable-traits.hxx)ES( + file. Then, we can create an ODB compiler options file for this + container and save it to )SM(hashtable.options)ES(:)EP( + + ) 4 48 PR(# Options file for the hash table container. +# +--odb-epilogue '#include "hashtable-traits.hxx"' +--hxx-prologue '#include "hashtable-traits.hxx"')RP( + + )0 P(Now, when)HY(ever)YH( we compile a header file that uses the hashtable + container, we can specify the follow)HY(ing)YH( command line option to + make sure it is recog)HY(nized)YH( by the ODB compiler as a container + and the traits file is included in the gener)HY(ated)YH( code:)EP( + + ) 1 32 PR(--options-file hashtable.options)RP( + + + + + + )WB NL NP( + )0 1 48 H(6)WB 373 Sn()WB 52 Sn( Rela)HY(tion)HY(ships)YH()EA()EH( + + )0 P(Rela)HY(tion)HY(ships)YH( between persis)HY(tent)YH( objects are expressed with point)HY(ers)YH( or + contain)HY(ers)YH( of point)HY(ers)YH(. The ODB runtime library provides built-in support + for )SM(shared_ptr)ES(/)SM(weak_ptr)ES( \201TR1 or C++11\202, + )SM(std::unique_ptr)ES( \201C++11\202, + )SM(std::auto_ptr)ES(, and raw point)HY(ers)YH(. Plus, ODB profile + libraries, that are avail)HY(able)YH( for commonly used frame)HY(works)YH( and libraries + \201such as Boost and Qt\202, provide support for smart point)HY(ers)YH( found in these + frame)HY(works)YH( and libraries \201)0 290 1 A(Part III, "Profiles")290 0 TN TL()Ec /AF f D(\202. It is + also easy to add support for a custom smart pointer as discussed later + in )0 62 1 A( Section 6.5, "Using Custom Smart Point)HY(ers)YH(")62 0 TN TL()Ec /AF f D(. Any + supported smart pointer can be used in a data member as long as it can be + explic)HY(itly)YH( constructed from the canon)HY(i)HY(cal)YH( object pointer + \201)0 26 1 A(Section 3.3, "Object and View Point)HY(ers)YH(")26 0 TN TL()Ec /AF f D(\202. For + example, we can use )SM(weak_ptr)ES( if the object pointer + is )SM(shared_ptr)ES(.)EP( + + )0 P(When an object contain)HY(ing)YH( a pointer to another object is loaded, + the pointed-to object is loaded as well. In some situ)HY(a)HY(tions)YH( this + eager loading of the rela)HY(tion)HY(ships)YH( is unde)HY(sir)HY(able)YH( since it + can lead to a large number of other)HY(wise)YH( unused objects being + instan)HY(ti)HY(ated)YH( from the database. To support finer control + over rela)HY(tion)HY(ships)YH( loading, the ODB runtime and profile + libraries provide the so-called )EM(lazy)ES( versions of + the supported point)HY(ers)YH(. An object pointed-to by a lazy pointer + is not loaded auto)HY(mat)HY(i)HY(cally)YH( when the contain)HY(ing)YH( object is loaded. + Instead, we have to explic)HY(itly)YH( request the instan)HY(ti)HY(a)HY(tion)YH( of the + pointed-to object. Lazy point)HY(ers)YH( are discussed in + detail in )0 61 1 A(Section 6.4, "Lazy Point)HY(ers)YH(")61 0 TN TL()Ec /AF f D(.)EP( + + )0 P(As a simple example, consider the follow)HY(ing)YH( employee-employer + rela)HY(tion)HY(ship)YH(. Code exam)HY(ples)YH( presented in this chapter + will use the )SM(shared_ptr)ES( and )SM(weak_ptr)ES( + smart point)HY(ers)YH( from the TR1 \201)SM(std::tr1)ES(\202 names)HY(pace)YH(.)EP( + + ) 22 33 PR(#pragma db object +class employer +{ + ... + + #pragma db id + std::string name_; +}; + +#pragma db object +class employee +{ + ... + + #pragma db id + unsigned long id_; + + std::string first_name_; + std::string last_name_; + + shared_ptr employer_; +};)RP( + + )0 P(By default, an object pointer can be )SM(NULL)ES(. To + specify that a pointer always points to a valid object we can + use the )SM(not_null)ES( pragma \201)0 153 1 A(Section + 14.4.6, ")SM(null)ES(/)SM(not_null)ES(")153 0 TN TL()Ec /AF f D(\202 for + single object point)HY(ers)YH( and the )SM(value_not_null)ES( pragma + \201)0 175 1 A(Section + 14.4.28, ")SM(value_null)ES(/)SM(value_not_null)ES(")175 0 TN TL()Ec /AF f D(\202 + for contain)HY(ers)YH( of object point)HY(ers)YH(. For example:)EP( + + ) 11 57 PR(#pragma db object +class employee +{ + ... + + #pragma db not_null + shared_ptr current_employer_; + + #pragma db value_not_null + std::vector > previous_employers_; +};)RP( + + )0 P(In this case, if we call either )SM(persist\201\202)ES( or + )SM(update\201\202)ES( database func)HY(tion)YH( on the + )SM(employee)ES( object and the )SM(current_employer_)ES( + pointer or one of the point)HY(ers)YH( stored in the + )SM(previ)HY(ous)YH(_employ)HY(ers)YH(_)ES( container is )SM(NULL)ES(, + then the )SM(odb::null_pointer)ES( excep)HY(tion)YH( will be thrown.)EP( + + )0 P(We don't need to do anything special to estab)HY(lish)YH( or navi)HY(gate)YH( a + rela)HY(tion)HY(ship)YH( between two persis)HY(tent)YH( objects, as shown in the + follow)HY(ing)YH( code frag)HY(ment)YH(:)EP( + + ) 34 59 PR(// Create an employer and a few employees. +// +unsigned long john_id, jane_id; +{ + shared_ptr er \201new employer \201"Example Inc"\202\202; + shared_ptr john \201new employee \201"John", "Doe"\202\202; + shared_ptr jane \201new employee \201"Jane", "Doe"\202\202; + + john->employer_ = er; + jane->employer_ = er; + + transaction t \201db.begin \201\202\202; + + db.persist \201er\202; + john_id = db.persist \201john\202; + jane_id = db.persist \201jane\202; + + t.commit \201\202; +} + +// Load a few employee objects and print their employer. +// +{ + session s; + transaction t \201db.begin \201\202\202; + + shared_ptr john \201db.load \201john_id\202\202; + shared_ptr jane \201db.load \201jane_id\202\202; + + cout << john->employer_->name_ << endl; + cout << jane->employer_->name_ << endl;)WR( + + t.commit \201\202; +})RP( + + )0 P(The only notable line in the above code is the creation of a + session before the second trans)HY(ac)HY(tion)YH( starts. As discussed in + )0 87 1 A(Chapter 11, "Session")87 0 TN TL()Ec /AF f D(, a session acts as a cache + of persis)HY(tent)YH( objects. + By creat)HY(ing)YH( a session before loading the )SM(employee)ES( + objects we make sure that their )SM(employer_)ES( point)HY(ers)YH( + point to the same )SM(employer)ES( object. Without a + session, each )SM(employee)ES( would have ended up point)HY(ing)YH( + to its own, private instance of the Example Inc employer.)EP( + + )0 P(As a general guide)HY(line)YH(, you should use a session when loading + objects that have point)HY(ers)YH( to other persis)HY(tent)YH( objects. A + session makes sure that for a given object id, a single instance + is shared among all other objects that relate to it.)EP( + + )0 P(We can also use data members from pointed-to + objects in database queries \201)0 38 1 A(Chapter 4, "Query)HY(ing)YH( the + Database")38 0 TN TL()Ec /AF f D(\202. For each pointer in a persis)HY(tent)YH( class, the query + class defines a smart pointer-like member that contains members + corre)HY(spond)HY(ing)YH( to the data members in the pointed-to object. We + can then use the access via a pointer syntax \201)SM(->)ES(\202 + to refer to data members in pointed-to objects. + For example, the query class for the )SM(employee)ES( object + contains the )SM(employer)ES( member \201its name is derived from the + )SM(employer_)ES( pointer\202 which in turn contains the + )SM(name)ES( member \201its name is derived from the + )SM(employer::name_)ES( data member of the pointed-to object\202. + As a result, we can use the )SM(query::employer->name)ES( + expres)HY(sion)YH( while query)HY(ing)YH( the database for the )SM(employee)ES( + objects. For example, the follow)HY(ing)YH( trans)HY(ac)HY(tion)YH( finds all the + employ)HY(ees)YH( of Example Inc that have the Doe last name:)EP( + + ) 13 67 PR(typedef odb::query query; +typedef odb::result result; + +session s; +transaction t \201db.begin \201\202\202; + +result r \201db.query \201 + query::employer->name == "Example Inc" && query::last == "Doe"\202\202; + +for \201result::iterator i \201r.begin \201\202\202; i != r.end \201\202; ++i\202 + cout << i->first_ << " " << i->last_ << endl; + +t.commit \201\202;)RP( + + )0 P(A query class member corre)HY(spond)HY(ing)YH( to a non-inverse + \201)0 56 1 A(Section 6.2, "Bidi)HY(rec)HY(tional)YH( Rela)HY(tion)HY(ships)YH(")56 0 TN TL()Ec /AF f D(\202 object + pointer can also be used as a normal member that has the id type + of the pointed-to object. For example, the follow)HY(ing)YH( query locates + all the )SM(employee)ES( objects that don't have an asso)HY(ci)HY(ated)YH( + )SM(employer)ES( object:)EP( + + ) 1 59 PR(result r \201db.query \201query::employer.is_null \201\202\202\202;)RP( + + )0 P(An impor)HY(tant)YH( concept to keep in mind when working with object + rela)HY(tion)HY(ships)YH( is the inde)HY(pen)HY(dence)YH( of persis)HY(tent)YH( objects. In partic)HY(u)HY(lar)YH(, + when an object contain)HY(ing)YH( a pointer to another object is made persis)HY(tent)YH( + or is updated, the pointed-to object is not auto)HY(mat)HY(i)HY(cally)YH( persisted + or updated. Rather, only a refer)HY(ence)YH( to the object \201in the form of the + object id\202 is stored for the pointed-to object in the database. + The pointed-to object itself is a sepa)HY(rate)YH( entity and should + be made persis)HY(tent)YH( or updated inde)HY(pen)HY(dently)YH(. By default, the + same prin)HY(ci)HY(ple)YH( also applies to erasing pointed-to objects. That + is, we have to make sure all the point)HY(ing)YH( objects are updated + accord)HY(ingly)YH(. However, in the case of erase, we can specify an + alter)HY(na)HY(tive)YH( )SM(on-delete)ES( seman)HY(tic)YH( as discussed in + )0 162 1 A(Section 14.4.15, ")SM(on_delete)ES(")162 0 TN TL()Ec /AF f D(.)EP( + + )0 P(When persist)HY(ing)YH( or updat)HY(ing)YH( an object contain)HY(ing)YH( a pointer to another + object, the pointed-to object must have a valid object id. This, + however, may not always be easy to achieve in complex rela)HY(tion)HY(ships)YH( that + involve objects with auto)HY(mat)HY(i)HY(cally)YH( assigned iden)HY(ti)HY(fiers)YH(. In such + cases it may be neces)HY(sary)YH( to first persist an object with a pointer + set to )SM(NULL)ES( and then, once the pointed-to object is + made persis)HY(tent)YH( and its iden)HY(ti)HY(fier)YH( assigned, set the pointer + to the correct value and update the object in the database.)EP( + + )0 P(Persis)HY(tent)YH( object rela)HY(tion)HY(ships)YH( can be divided into two groups: + unidi)HY(rec)HY(tional)YH( and bidi)HY(rec)HY(tional)YH(. Each group in turn contains + several config)HY(u)HY(ra)HY(tions)YH( that vary depend)HY(ing)YH( on the cardi)HY(nal)HY(ity)YH( + of the sides of the rela)HY(tion)HY(ship)YH(. All possi)HY(ble)YH( unidi)HY(rec)HY(tional)YH( + and bidi)HY(rec)HY(tional)YH( config)HY(u)HY(ra)HY(tions)YH( are discussed in the follow)HY(ing)YH( + sections.)EP( + + )0 2 49 H(6.1)WB 374 Sn()WB 53 Sn( Unidi)HY(rec)HY(tional)YH( Rela)HY(tion)HY(ships)YH()EA()EH( + + )0 P(In unidi)HY(rec)HY(tional)YH( rela)HY(tion)HY(ships)YH( we are only inter)HY(ested)YH( in navi)HY(gat)HY(ing)YH( + from object to object in one direc)HY(tion)YH(. Because there is no inter)HY(est)YH( + in navi)HY(gat)HY(ing)YH( in the oppo)HY(site)YH( direc)HY(tion)YH(, the cardi)HY(nal)HY(ity)YH( of the other + end of the rela)HY(tion)HY(ship)YH( is unim)HY(por)HY(tant)YH(. As a result, there are only + two possi)HY(ble)YH( unidi)HY(rec)HY(tional)YH( rela)HY(tion)HY(ships)YH(: to-one and to-many. Each + of these rela)HY(tion)HY(ships)YH( is described in the follow)HY(ing)YH( sections. For + sample code that shows how to work with these rela)HY(tion)HY(ships)YH(, refer + to the )SM(rela)HY(tion)HY(ship)YH()ES( example in the )SM(odb-exam)HY(ples)YH()ES( + package.)EP( + + )0 3 50 H(6.1.1)WB 375 Sn()WB 54 Sn( To-One Rela)HY(tion)HY(ships)YH()EA()EH( + + )0 P(An example of a unidi)HY(rec)HY(tional)YH( to-one rela)HY(tion)HY(ship)YH( is the + employee-employer rela)HY(tion)HY(ship)YH( \201an employee has one employer\202. + The follow)HY(ing)YH( persis)HY(tent)YH( C++ classes model this rela)HY(tion)HY(ship)YH(:)EP( + + ) 20 33 PR(#pragma db object +class employer +{ + ... + + #pragma db id + std::string name_; +}; + +#pragma db object +class employee +{ + ... + + #pragma db id + unsigned long id_; + + #pragma db not_null + shared_ptr employer_; +};)RP( + + )0 P(The corre)HY(spond)HY(ing)YH( database tables look like this:)EP( + + ) 6 62 PR(CREATE TABLE employer \201 + name VARCHAR \201255\202 NOT NULL PRIMARY KEY\202; + +CREATE TABLE employee \201 + id BIGINT UNSIGNED NOT NULL PRIMARY KEY, + employer VARCHAR \201255\202 NOT NULL REFERENCES employer \201name\202\202;)RP( + + )0 3 51 H(6.1.2)WB 376 Sn()WB 55 Sn( To-Many Rela)HY(tion)HY(ships)YH()EA()EH( + + )0 P(An example of a unidi)HY(rec)HY(tional)YH( to-many rela)HY(tion)HY(ship)YH( is the + employee-project rela)HY(tion)HY(ship)YH( \201an employee can be involved + in multi)HY(ple)YH( projects\202. The follow)HY(ing)YH( persis)HY(tent)YH( C++ classes + model this rela)HY(tion)HY(ship)YH(:)EP( + + ) 20 46 PR(#pragma db object +class project +{ + ... + + #pragma db id + std::string name_; +}; + +#pragma db object +class employee +{ + ... + + #pragma db id + unsigned long id_; + + #pragma db value_not_null unordered + std::vector > projects_; +};)RP( + + )0 P(The corre)HY(spond)HY(ing)YH( database tables look like this:)EP( + + ) 9 58 PR(CREATE TABLE project \201 + name VARCHAR \201255\202 NOT NULL PRIMARY KEY\202; + +CREATE TABLE employee \201 + id BIGINT UNSIGNED NOT NULL PRIMARY KEY\202; + +CREATE TABLE employee_projects \201 + object_id BIGINT UNSIGNED NOT NULL, + value VARCHAR \201255\202 NOT NULL REFERENCES project \201name\202\202;)RP( + + )0 P(To obtain a more canon)HY(i)HY(cal)YH( database schema, the names of tables + and columns above can be customized using ODB pragmas + \201)0 100 1 A(Chapter 14, "ODB Pragma Language")100 0 TN TL()Ec /AF f D(\202. For example:)EP( + + ) 9 66 PR(#pragma db object +class employee +{ + ... + + #pragma db value_not_null unordered \200 + id_column\201"employee_id"\202 value_column\201"project_name"\202 + std::vector > projects_; +};)RP( + + )0 P(The result)HY(ing)YH( )SM(employee_projects)ES( table would then + look like this:)EP( + + ) 3 65 PR(CREATE TABLE employee_projects \201 + employee_id BIGINT UNSIGNED NOT NULL, + project_name VARCHAR \201255\202 NOT NULL REFERENCES project \201name\202\202;)RP( + + + )0 2 52 H(6.2)WB 377 Sn()WB 56 Sn( Bidi)HY(rec)HY(tional)YH( Rela)HY(tion)HY(ships)YH()EA()EH( + + )0 P(In bidi)HY(rec)HY(tional)YH( rela)HY(tion)HY(ships)YH( we are inter)HY(ested)YH( in navi)HY(gat)HY(ing)YH( + from object to object in both direc)HY(tions)YH(. As a result, each + object class in a rela)HY(tion)HY(ship)YH( contains a pointer to the other + object. If smart point)HY(ers)YH( are used, then a weak pointer should + be used as one of the point)HY(ers)YH( to avoid owner)HY(ship)YH( cycles. For + example:)EP( + + ) 24 33 PR(class employee; + +#pragma db object +class position +{ + ... + + #pragma db id + unsigned long id_; + + weak_ptr employee_; +}; + +#pragma db object +class employee +{ + ... + + #pragma db id + unsigned long id_; + + #pragma db not_null + shared_ptr position_; +};)RP( + + )0 P(Note that when we estab)HY(lish)YH( a bidi)HY(rec)HY(tional)YH( rela)HY(tion)HY(ship)YH(, we + have to set both point)HY(ers)YH( consis)HY(tently)YH(. One way to make sure + that a rela)HY(tion)HY(ship)YH( is always in a consis)HY(tent)YH( state is to + provide a single func)HY(tion)YH( that updates both point)HY(ers)YH( at the + same time. For example:)EP( + + ) 27 56 PR(#pragma db object +class position: public enable_shared_from_this +{ + ... + + void + fill \201shared_ptr e\202 + { + employee_ = e; + e->positions_ = shared_from_this \201\202; + } + +private: + weak_ptr employee_; +}; + +#pragma db object +class employee +{ + ... + +private: + friend class position; + + #pragma db not_null + shared_ptr position_; +};)RP( + + )0 P(At the begin)HY(ning)YH( of this chapter we exam)HY(ined)YH( how to use a session + to make sure a single object is shared among all other objects point)HY(ing)YH( + to it. With bidi)HY(rec)HY(tional)YH( rela)HY(tion)HY(ships)YH( involv)HY(ing)YH( weak point)HY(ers)YH( the + use of a session becomes even more crucial. Consider the follow)HY(ing)YH( + trans)HY(ac)HY(tion)YH( that tries to load the )SM(posi)HY(tion)YH()ES( object + from the above example without using a session:)EP( + + ) 4 47 PR(transaction t \201db.begin \201\202\202 +shared_ptr p \201db.load \2011\202\202; +... +t.commit \201\202;)RP( + + )0 P(When we load the )SM(posi)HY(tion)YH()ES( object, the )SM(employee)ES( + object, which it points to, is also loaded. While )SM(employee)ES( + is initially stored as )SM(shared_ptr)ES(, it is then assigned to + the )SM(employee_)ES( member which is )SM(weak_ptr)ES(. Once + the assign)HY(ment)YH( is complete, the shared pointer goes out of scope + and the only pointer that points to the newly loaded + )SM(employee)ES( object is the )SM(employee_)ES( weak + pointer. And that means the )SM(employee)ES( object is deleted + imme)HY(di)HY(ately)YH( after being loaded. To help avoid such patho)HY(log)HY(i)HY(cal)YH( + situ)HY(a)HY(tions)YH( ODB detects cases where a newly loaded object will + imme)HY(di)HY(ately)YH( be deleted and throws the )SM(odb::session_required)ES( + excep)HY(tion)YH(.)EP( + + )0 P(As the excep)HY(tion)YH( name suggests, the easiest way to resolve this + problem is to use a session:)EP( + + ) 5 47 PR(session s; +transaction t \201db.begin \201\202\202 +shared_ptr p \201db.load \2011\202\202; +... +t.commit \201\202;)RP( + + )0 P(In our example, the session will main)HY(tain)YH( a shared pointer to the + loaded )SM(employee)ES( object prevent)HY(ing)YH( its imme)HY(di)HY(ate)YH( + dele)HY(tion)YH(. Another way to resolve this problem is to avoid + imme)HY(di)HY(ate)YH( loading of the pointed-to objects using lazy weak + point)HY(ers)YH(. Lazy point)HY(ers)YH( are discussed in )0 61 1 A(Section 6.4, + "Lazy Point)HY(ers)YH(")61 0 TN TL()Ec /AF f D( later in this chapter.)EP( + + )0 P(Above, to model a bidi)HY(rec)HY(tional)YH( rela)HY(tion)HY(ship)YH( in persis)HY(tent)YH( classes, + we used two point)HY(ers)YH(, one in each object. While this is a natural + repre)HY(sen)HY(ta)HY(tion)YH( in C++, it does not trans)HY(late)YH( to a canon)HY(i)HY(cal)YH( + rela)HY(tional)YH( model. Consider the database schema gener)HY(ated)YH( for + the above two classes:)EP( + + ) 7 62 PR(CREATE TABLE position \201 + id BIGINT UNSIGNED NOT NULL PRIMARY KEY, + employee BIGINT UNSIGNED REFERENCES employee \201id\202\202; + +CREATE TABLE employee \201 + id BIGINT UNSIGNED NOT NULL PRIMARY KEY, + position BIGINT UNSIGNED NOT NULL REFERENCES position \201id\202\202;)RP( + + )0 P(While this database schema is valid, it is uncon)HY(ven)HY(tional)YH(. We have + a refer)HY(ence)YH( from a row in the )SM(posi)HY(tion)YH()ES( table to a row + in the )SM(employee)ES( table. We also have a refer)HY(ence)YH( + from this same row in the )SM(employee)ES( table back to + the row in the )SM(posi)HY(tion)YH()ES( table. From the rela)HY(tional)YH( + point of view, one of these refer)HY(ences)YH( is redun)HY(dant)YH( since + in SQL we can easily navi)HY(gate)YH( in both direc)HY(tions)YH( using just one + of these refer)HY(ences)YH(.)EP( + + )0 P(To elim)HY(i)HY(nate)YH( redun)HY(dant)YH( database schema refer)HY(ences)YH( we can use the + )SM(inverse)ES( pragma \201)0 161 1 A(Section 14.4.14, + ")SM(inverse)ES(")161 0 TN TL()Ec /AF f D(\202 which tells the ODB compiler that + a pointer is the inverse side of a bidi)HY(rec)HY(tional)YH( rela)HY(tion)HY(ship)YH(. + Either side of a rela)HY(tion)HY(ship)YH( can be made inverse. For example:)EP( + + ) 17 33 PR(#pragma db object +class position +{ + ... + + #pragma db inverse\201position_\202 + weak_ptr employee_; +}; + +#pragma db object +class employee +{ + ... + + #pragma db not_null + shared_ptr position_; +};)RP( + + )0 P(The result)HY(ing)YH( database schema looks like this:)EP( + + ) 6 62 PR(CREATE TABLE position \201 + id BIGINT UNSIGNED NOT NULL PRIMARY KEY\202; + +CREATE TABLE employee \201 + id BIGINT UNSIGNED NOT NULL PRIMARY KEY, + position BIGINT UNSIGNED NOT NULL REFERENCES position \201id\202\202;)RP( + + )0 P(As you can see, an inverse member does not have a corre)HY(spond)HY(ing)YH( + column \201or table, in case of an inverse container of point)HY(ers)YH(\202 + and, from the point of view of database oper)HY(a)HY(tions)YH(, is effec)HY(tively)YH( + read-only. The only way to change a bidi)HY(rec)HY(tional)YH( rela)HY(tion)HY(ship)YH( + with an inverse side is to set its direct \201non-inverse\202 + pointer. Also note that an ordered container \201)0 46 1 A(Section + 5.1, "Ordered Contain)HY(ers)YH(")46 0 TN TL()Ec /AF f D(\202 of point)HY(ers)YH( that is an inverse side + of a bidi)HY(rec)HY(tional)YH( rela)HY(tion)HY(ship)YH( is always treated as unordered + \201)0 166 1 A(Section 14.4.19, ")SM(unordered)ES(")166 0 TN TL()Ec /AF f D(\202 + because the contents of such a container are implic)HY(itly)YH( built from + the direct side of the rela)HY(tion)HY(ship)YH( which does not contain the + element order \201index\202.)EP( + + )0 P(There are three distinct bidi)HY(rec)HY(tional)YH( rela)HY(tion)HY(ships)YH( that we + will cover in the follow)HY(ing)YH( sections: one-to-one, one-to-many, + and many-to-many. We will only talk about bidi)HY(rec)HY(tional)YH( + rela)HY(tion)HY(ships)YH( with inverse sides since they result in canon)HY(i)HY(cal)YH( + database schemas. For sample code that shows how to work with + these rela)HY(tion)HY(ships)YH(, refer to the )SM(inverse)ES( example + in the )SM(odb-exam)HY(ples)YH()ES( package.)EP( + + )0 3 53 H(6.2.1)WB 378 Sn()WB 57 Sn( One-to-One Rela)HY(tion)HY(ships)YH()EA()EH( + + )0 P(An example of a bidi)HY(rec)HY(tional)YH( one-to-one rela)HY(tion)HY(ship)YH( is the + presented above employee-posi)HY(tion)YH( rela)HY(tion)HY(ship)YH( \201an employee + fills one posi)HY(tion)YH( and a posi)HY(tion)YH( is filled by one employee\202. + The follow)HY(ing)YH( persis)HY(tent)YH( C++ classes model this rela)HY(tion)HY(ship)YH(:)EP( + + ) 25 33 PR(class employee; + +#pragma db object +class position +{ + ... + + #pragma db id + unsigned long id_; + + #pragma db inverse\201position_\202 + weak_ptr employee_; +}; + +#pragma db object +class employee +{ + ... + + #pragma db id + unsigned long id_; + + #pragma db not_null + shared_ptr position_; +};)RP( + + )0 P(The corre)HY(spond)HY(ing)YH( database tables look like this:)EP( + + ) 6 62 PR(CREATE TABLE position \201 + id BIGINT UNSIGNED NOT NULL PRIMARY KEY\202; + +CREATE TABLE employee \201 + id BIGINT UNSIGNED NOT NULL PRIMARY KEY, + position BIGINT UNSIGNED NOT NULL REFERENCES position \201id\202\202;)RP( + + )0 P(If instead the other side of this rela)HY(tion)HY(ship)YH( is made inverse, + then the database tables will change as follows:)EP( + + ) 6 53 PR(CREATE TABLE position \201 + id BIGINT UNSIGNED NOT NULL PRIMARY KEY, + employee BIGINT UNSIGNED REFERENCES employee \201id\202\202; + +CREATE TABLE employee \201 + id BIGINT UNSIGNED NOT NULL PRIMARY KEY\202;)RP( + + )0 3 54 H(6.2.2)WB 379 Sn()WB 58 Sn( One-to-Many Rela)HY(tion)HY(ships)YH()EA()EH( + + )0 P(An example of a bidi)HY(rec)HY(tional)YH( one-to-many rela)HY(tion)HY(ship)YH( is the + employer-employee rela)HY(tion)HY(ship)YH( \201an employer has multi)HY(ple)YH( + employ)HY(ees)YH( and an employee is employed by one employer\202. + The follow)HY(ing)YH( persis)HY(tent)YH( C++ classes model this rela)HY(tion)HY(ship)YH(:)EP( + + ) 25 46 PR(class employee; + +#pragma db object +class employer +{ + ... + + #pragma db id + std::string name_; + + #pragma db value_not_null inverse\201employer_\202 + std::vector > employees_ +}; + +#pragma db object +class employee +{ + ... + + #pragma db id + unsigned long id_; + + #pragma db not_null + shared_ptr employer_; +};)RP( + + )0 P(The corre)HY(spond)HY(ing)YH( database tables differ signif)HY(i)HY(cantly)YH( depend)HY(ing)YH( + on which side of the rela)HY(tion)HY(ship)YH( is made inverse. If the )EM(one)ES( + side \201)SM(employer)ES(\202 is inverse as in the code + above, then the result)HY(ing)YH( database schema looks like this:)EP( + + ) 6 62 PR(CREATE TABLE employer \201 + name VARCHAR \201255\202 NOT NULL PRIMARY KEY\202; + +CREATE TABLE employee \201 + id BIGINT UNSIGNED NOT NULL PRIMARY KEY, + employer VARCHAR \201255\202 NOT NULL REFERENCES employer \201name\202\202;)RP( + + )0 P(If instead the )EM(many)ES( side \201)SM(employee)ES(\202 of this + rela)HY(tion)HY(ship)YH( is made inverse, then the database tables will change + as follows:)EP( + + ) 9 59 PR(CREATE TABLE employer \201 + name VARCHAR \201255\202 NOT NULL PRIMARY KEY\202; + +CREATE TABLE employer_employees \201 + object_id VARCHAR \201255\202 NOT NULL, + value BIGINT UNSIGNED NOT NULL REFERENCES employee \201id\202\202; + +CREATE TABLE employee \201 + id BIGINT UNSIGNED NOT NULL PRIMARY KEY\202;)RP( + + )0 3 55 H(6.2.3)WB 380 Sn()WB 59 Sn( Many-to-Many Rela)HY(tion)HY(ships)YH()EA()EH( + + )0 P(An example of a bidi)HY(rec)HY(tional)YH( many-to-many rela)HY(tion)HY(ship)YH( is the + employee-project rela)HY(tion)HY(ship)YH( \201an employee can work on multi)HY(ple)YH( + projects and a project can have multi)HY(ple)YH( partic)HY(i)HY(pat)HY(ing)YH( employ)HY(ees)YH(\202. + The follow)HY(ing)YH( persis)HY(tent)YH( C++ classes model this rela)HY(tion)HY(ship)YH(:)EP( + + ) 25 46 PR(class employee; + +#pragma db object +class project +{ + ... + + #pragma db id + std::string name_; + + #pragma db value_not_null inverse\201projects_\202 + std::vector > employees_; +}; + +#pragma db object +class employee +{ + ... + + #pragma db id + unsigned long id_; + + #pragma db value_not_null unordered + std::vector > projects_; +};)RP( + + )0 P(The corre)HY(spond)HY(ing)YH( database tables look like this:)EP( + + ) 9 58 PR(CREATE TABLE project \201 + name VARCHAR \201255\202 NOT NULL PRIMARY KEY\202; + +CREATE TABLE employee \201 + id BIGINT UNSIGNED NOT NULL PRIMARY KEY\202; + +CREATE TABLE employee_projects \201 + object_id BIGINT UNSIGNED NOT NULL, + value VARCHAR \201255\202 NOT NULL REFERENCES project \201name\202\202;)RP( + + )0 P(If instead the other side of this rela)HY(tion)HY(ship)YH( is made inverse, + then the database tables will change as follows:)EP( + + ) 9 59 PR(CREATE TABLE project \201 + name VARCHAR \201255\202 NOT NULL PRIMARY KEY\202; + +CREATE TABLE project_employees \201 + object_id VARCHAR \201255\202 NOT NULL, + value BIGINT UNSIGNED NOT NULL REFERENCES employee \201id\202\202; + +CREATE TABLE employee \201 + id BIGINT UNSIGNED NOT NULL PRIMARY KEY\202;)RP( + + )0 2 56 H(6.3)WB 381 Sn()WB 60 Sn( Circu)HY(lar)YH( Rela)HY(tion)HY(ships)YH()EA()EH( + + )0 P(A rela)HY(tion)HY(ship)YH( between two persis)HY(tent)YH( classes is circu)HY(lar)YH( if each + of them refer)HY(ences)YH( the other. Bidi)HY(rec)HY(tional)YH( rela)HY(tion)HY(ships)YH( are + always circu)HY(lar)YH(. A unidi)HY(rec)HY(tional)YH( rela)HY(tion)HY(ship)YH( combined with + inher)HY(i)HY(tance)YH( \201)0 69 1 A(Chapter 8, "Inher)HY(i)HY(tance)YH(")69 0 TN TL()Ec /AF f D(\202 can also + be circu)HY(lar)YH(. For example, the )SM(employee)ES( class could + derive from )SM(person)ES( which, in turn, could contain a + pointer to )SM(employee)ES(.)EP( + + )0 P(We don't need to do anything extra if persis)HY(tent)YH( classes with + circu)HY(lar)YH( depen)HY(den)HY(cies)YH( are defined in the same header + file. Specif)HY(i)HY(cally)YH(, ODB will make sure that the database tables + and foreign key constraints are created in the correct order. As a + result, unless you have good reasons not to, it is recom)HY(mended)YH( that + you keep persis)HY(tent)YH( classes with circu)HY(lar)YH( depen)HY(den)HY(cies)YH( in the same + header file.)EP( + + )0 P(If you have to keep such classes in sepa)HY(rate)YH( header files, then + there are two extra steps that you may need to take in order to + use these classes with ODB. Consider again the example from + )0 57 1 A(Section 6.2.1, "One-to-One Rela)HY(tion)HY(ships)YH(")57 0 TN TL()Ec /AF f D( + but this time with the classes defined in sepa)HY(rate)YH( headers:)EP( + + ) 15 31 PR(// position.hxx +// +class employee; + +#pragma db object +class position +{ + ... + + #pragma db id + unsigned long id_; + + #pragma db inverse\201position_\202 + weak_ptr employee_; +};)RP( + + ) 15 33 PR(// employee.hxx +// +#include "position.hxx" + +#pragma db object +class employee +{ + ... + + #pragma db id + unsigned long id_; + + #pragma db not_null + shared_ptr position_; +};)RP( + + )0 P(Note that the )SM(posi)HY(tion)YH(.hxx)ES( header contains only the forward + decla)HY(ra)HY(tion)YH( for )SM(employee)ES(. While this is suffi)HY(cient)YH( to + define a valid, from the C++ point of view, )SM(posi)HY(tion)YH()ES( class, + the ODB compiler needs to "see" the defi)HY(ni)HY(tions)YH( of the pointed-to + persis)HY(tent)YH( classes. There are several ways we can fulfil this + require)HY(ment)YH(. The easiest is to simply include )SM(employee.hxx)ES( + at the end of )SM(posi)HY(tion)YH(.hxx)ES(:)EP( + + ) 11 23 PR(// position.hxx +// +class employee; + +#pragma db object +class position +{ + ... +}; + +#include "employee.hxx")RP( + + )0 P(We can also limit this inclu)HY(sion)YH( only to the time when + )SM(posi)HY(tion)YH(.hxx)ES( is compiled with the ODB compiler:)EP( + + ) 8 25 PR(// position.hxx +// + +... + +#ifdef ODB_COMPILER +# include "employee.hxx" +#endif)RP( + + )0 P(Finally, if we don't want to modify )SM(posi)HY(tion)YH(.hxx)ES(, + then we can add )SM(employee.hxx)ES( to the ODB compi)HY(la)HY(tion)YH( + process with the )SM(--odb-epilogue)ES( option. For example:)EP( + + ) 1 63 PR(odb ... --odb-epilogue "#include \200"employee.hxx\200"" position.hxx)RP( + + )0 P(Note also that in this example we didn't have to do anything extra + for )SM(employee.hxx)ES( because it already includes + )SM(posi)HY(tion)YH(.hxx)ES(. However, if instead it relied only + on the forward decla)HY(ra)HY(tion)YH( of the )SM(posi)HY(tion)YH()ES( class, + then we would have to handle it in the same way as + )SM(posi)HY(tion)YH(.hxx)ES(.)EP( + + )0 P(The other diffi)HY(culty)YH( with sepa)HY(rately)YH( defined classes involv)HY(ing)YH( + circu)HY(lar)YH( rela)HY(tion)HY(ships)YH( has to do with the correct order of foreign + key constraint creation in the gener)HY(ated)YH( database schema. In + the above example, if we gener)HY(ate)YH( the database schema as + stan)HY(dalone)YH( SQL files, then we will end up with two such files: + )SM(posi)HY(tion)YH(.sql)ES( and )SM(employee.sql)ES(. + If we try to execute )SM(employee.sql)ES( first, then + we will get an error indi)HY(cat)HY(ing)YH( that the table corre)HY(spond)HY(ing)YH( to + the )SM(posi)HY(tion)YH()ES( class and refer)HY(enced)YH( by the foreign + key constraint corre)HY(spond)HY(ing)YH( to the )SM(posi)HY(tion)YH(_)ES( + pointer does not yet exist.)EP( + + )0 P(Note that there is no such problem if the database schema + is embed)HY(ded)YH( in the gener)HY(ated)YH( C++ code instead of being produced + as stan)HY(dalone)YH( SQL files. In this case, the ODB compiler is + able to ensure the correct creation order even if the classes + are defined in sepa)HY(rate)YH( header files.)EP( + + )0 P(In certain cases, for example, a bidi)HY(rec)HY(tional)YH( rela)HY(tion)HY(ship)YH( + with an inverse side, this problem can be resolved by execut)HY(ing)YH( + the database schema creation files in the correct order. In our + example, this would be )SM(posi)HY(tion)YH(.sql)ES( first + and )SM(employee.sql)ES( second. However, this approach + doesn't scale beyond simple object models.)EP( + + )0 P(A more robust solu)HY(tion)YH( to this problem is to gener)HY(ate)YH( the database + schema for all the persis)HY(tent)YH( classes into a single SQL file. This + way, the ODB compiler can again ensure the correct creation order + of tables and foreign keys. To instruct the ODB compiler to produce + a combined schema file for several headers we can use the + )SM(--gener)HY(ate)YH(-schema-only)ES( and )SM(--at-once)ES( + options. For example:)EP( + + ) 2 63 PR(odb ... --generate-schema-only --at-once --input-name company \200 +position.hxx employee.hxx)RP( + + )0 P(The result of the above command is a single )SM(company.sql)ES( + file \201the name is derived from the )SM(--input-name)ES( value\202 + that contains the database creation code for both )SM(posi)HY(tion)YH()ES( + and )SM(employee)ES( classes.)EP( + + )0 2 57 H(6.4)WB 382 Sn()WB 61 Sn( Lazy Point)HY(ers)YH()EA()EH( + + )0 P(Consider again the bidi)HY(rec)HY(tional)YH(, one-to-many employer-employee + rela)HY(tion)HY(ship)YH( that was presented earlier in this chapter:)EP( + + ) 25 46 PR(class employee; + +#pragma db object +class employer +{ + ... + + #pragma db id + std::string name_; + + #pragma db value_not_null inverse\201employer_\202 + std::vector > employees_; +}; + +#pragma db object +class employee +{ + ... + + #pragma db id + unsigned long id_; + + #pragma db not_null + shared_ptr employer_; +};)RP( + + )0 P(Consider also the follow)HY(ing)YH( trans)HY(ac)HY(tion)YH( which obtains the employer + name given the employee id:)EP( + + ) 10 48 PR(unsigned long id = ... +string name; + +session s; +transaction t \201db.begin \201\202\202; + +shared_ptr e \201db.load \201id\202\202; +name = e->employer_->name_; + +t.commit \201\202;)RP( + + )0 P(While this trans)HY(ac)HY(tion)YH( looks very simple, it actu)HY(ally)YH( does a lot more + than what meets the eye and is neces)HY(sary)YH(. Consider what happens when + we load the )SM(employee)ES( object: the )SM(employer_)ES( + pointer is also auto)HY(mat)HY(i)HY(cally)YH( loaded which means the )SM(employer)ES( + object corre)HY(spond)HY(ing)YH( to this employee is also loaded. But the + )SM(employer)ES( object in turn contains the list of point)HY(ers)YH( + to all the employ)HY(ees)YH(, which are also loaded. A a result, when object + rela)HY(tion)HY(ships)YH( are involved, a simple trans)HY(ac)HY(tion)YH( like the above can + load many more objects than is neces)HY(sary)YH(.)EP( + + )0 P(To over)HY(come)YH( this problem ODB offers finer grained control over + the rela)HY(tion)HY(ship)YH( loading in the form of lazy point)HY(ers)YH(. A lazy + pointer does not auto)HY(mat)HY(i)HY(cally)YH( load the pointed-to object + when the contain)HY(ing)YH( object is loaded. Instead, we have to + explic)HY(itly)YH( load the pointed-to object if and when we need to + access it.)EP( + + )0 P(The ODB runtime library provides lazy coun)HY(ter)HY(parts)YH( for all the + supported point)HY(ers)YH(, namely: + )SM(odb::lazy_shared_ptr)ES(/)SM(lazy_weak_ptr)ES( + for C++11 )SM(std::shared_ptr)ES(/)SM(weak_ptr)ES(, + )SM(odb::tr1::lazy_shared_ptr)ES(/)SM(lazy_weak_ptr)ES( + for TR1 )SM(std::tr1::shared_ptr)ES(/)SM(weak_ptr)ES(, + )SM(odb::lazy_unique_ptr)ES( for C++11 )SM(std::unique_ptr)ES(, + )SM(odb::lazy_auto_ptr)ES( for )SM(std::auto_ptr)ES(, + and )SM(odb::lazy_ptr)ES( for raw point)HY(ers)YH(. The TR1 lazy + point)HY(ers)YH( are defined in the )SM()ES( + header while all the others \236 in + )SM()ES(. The ODB profile + libraries also provide lazy pointer imple)HY(men)HY(ta)HY(tions)YH( for smart point)HY(ers)YH( + from popular frame)HY(works)YH( and libraries \201)0 290 1 A(Part III, + "Profiles")290 0 TN TL()Ec /AF f D(\202.)EP( + + )0 P(While we will discuss the inter)HY(face)YH( of lazy point)HY(ers)YH( in more detail + shortly, the most commonly used extra func)HY(tion)YH( provided by these + point)HY(ers)YH( is )SM(load\201\202)ES(. This func)HY(tion)YH( loads the + pointed-to object if it hasn't already been loaded. After + the call to this func)HY(tion)YH(, the lazy pointer can be used + in the the same way as its eager coun)HY(ter)HY(part)YH(. The )SM(load\201\202)ES( + func)HY(tion)YH( also returns the eager pointer, in case you need to pass + it around. For a lazy weak pointer, the + )SM(load\201\202)ES( func)HY(tion)YH( also locks the pointer.)EP( + + )0 P(The follow)HY(ing)YH( example shows how we can change our employer-employee + rela)HY(tion)HY(ship)YH( to use lazy point)HY(ers)YH(. Here we choose to use lazy point)HY(ers)YH( + for both sides of the rela)HY(tion)HY(ship)YH(.)EP( + + ) 19 51 PR(class employee; + +#pragma db object +class employer +{ + ... + + #pragma db value_not_null inverse\201employer_\202 + std::vector > employees_; +}; + +#pragma db object +class employee +{ + ... + + #pragma db not_null + lazy_shared_ptr employer_; +};)RP( + + )0 P(And the trans)HY(ac)HY(tion)YH( is changed like this:)EP( + + ) 11 48 PR(unsigned long id = ... +string name; + +session s; +transaction t \201db.begin \201\202\202; + +shared_ptr e \201db.load \201id\202\202; +e->employer_.load \201\202; +name = e->employer_->name_; + +t.commit \201\202;)RP( + + + )0 P(As a general guide)HY(line)YH( we recom)HY(mend)YH( that you make at least one side + of a bidi)HY(rec)HY(tional)YH( rela)HY(tion)HY(ship)YH( lazy, espe)HY(cially)YH( for rela)HY(tion)HY(ships)YH( + with a )EM(many)ES( side.)EP( + + )0 P(A lazy pointer imple)HY(men)HY(ta)HY(tion)YH( mimics the inter)HY(face)YH( of its eager + coun)HY(ter)HY(part)YH( which can be used once the pointer is loaded. It also + adds a number of addi)HY(tional)YH( func)HY(tions)YH( that are specific to the + lazy loading func)HY(tion)HY(al)HY(ity)YH(. Overall, the inter)HY(face)YH( of a lazy + pointer follows this general outline:)EP( + + ) 60 69 PR(template +class lazy_ptr +{ +public: + // + // The eager pointer interface. + // + + // Initialization/assignment from an eager pointer. + // +public: + template lazy_ptr \201const eager_ptr&\202; + template lazy_ptr& operator= \201const eager_ptr&\202; + + // Lazy loading interface. + // +public: + // NULL loaded\201\202 + // + // true true NULL pointer to transient object + // false true valid pointer to persistent object + // true false unloaded pointer to persistent object + // false false valid pointer to transient object + // + bool loaded \201\202 const; + + eager_ptr load \201\202 const; + + // Unload the pointer. For transient objects this function is + // equivalent to reset\201\202. + //)WR( + void unload \201\202 const; + + // Get the underlying eager pointer. If this is an unloaded pointer + // to a persistent object, then the returned pointer will be NULL. + // + eager_ptr get_eager \201\202 const; + + // Initialization with a persistent loaded object. + // + template lazy_ptr \201database&, Y*\202; + template lazy_ptr \201database&, const eager_ptr&\202; + + template void reset \201database&, Y*\202; + template void reset \201database&, const eager_ptr&\202; + + // Initialization with a persistent unloaded object. + // + template lazy_ptr \201database&, const ID&\202; + + template void reset \201database&, const ID&\202; + + // Query object id and database of a persistent object. + // + template + // C++11: template + object_traits::id_type object_id \201\202 const; + + odb::database& database \201\202 const; +};)RP( + + )0 P(In a lazy weak pointer inter)HY(face)YH(, the )SM(load\201\202)ES( func)HY(tion)YH( + returns the )EM(strong)ES( \201shared\202 eager pointer. The follow)HY(ing)YH( + trans)HY(ac)HY(tion)YH( demon)HY(strates)YH( the use of a lazy weak pointer based on + the )SM(employer)ES( and )SM(employee)ES( classes + presented earlier.)EP( + + ) 24 65 PR(typedef std::vector > employees; + +session s; +transaction t \201db.begin \201\202\202; + +shared_ptr er \201db.load \201"Example Inc"\202\202; +employees& es \201er->employees \201\202\202; + +for \201employees::iterator i \201es.begin \201\202\202; i != es.end \201\202; ++i\202 +{ + // We are only interested in employees with object id less than + // 100. + // + lazy_weak_ptr& lwp \201*i\202; + + if \201lwp.object_id \201\202 < 100\202 + // C++11: if \201lwp.object_id \201\202 < 100\202 + { + shared_ptr e \201lwp.load \201\202\202; // Load and lock. + cout << e->first_ << " " << e->last_ << endl; + } +} + +t.commit \201\202;)RP( + + )0 P(Notice that inside the for-loop we use a refer)HY(ence)YH( to the lazy + weak pointer instead of making a copy. This is not merely to + avoid a copy. When a lazy pointer is loaded, all other lazy + point)HY(ers)YH( that point to the same object do not auto)HY(mat)HY(i)HY(cally)YH( + become loaded \201though an attempt to load such copies will + result in them point)HY(ing)YH( to the same object, provided the + same session is still in effect\202. By using a refer)HY(ence)YH( + in the above trans)HY(ac)HY(tion)YH( we make sure that we load the + pointer that is contained in the )SM(employer)ES( + object. This way, if we later need to re-examine this + )SM(employee)ES( object, the pointer will already + be loaded.)EP( + + )0 P(As another example, suppose we want to add an employee + to Example Inc. The straight)HY(for)HY(ward)YH( imple)HY(men)HY(ta)HY(tion)YH( of this + trans)HY(ac)HY(tion)YH( is presented below:)EP( + + ) 11 60 PR(session s; +transaction t \201db.begin \201\202\202; + +shared_ptr er \201db.load \201"Example Inc"\202\202; +shared_ptr e \201new employee \201"John", "Doe"\202\202; + +e->employer_ = er; +er->employees \201\202.push_back \201e\202; + +db.persist \201e\202; +t.commit \201\202;)RP( + + )0 P(Notice here that we didn't have to update the employer object + in the database since the )SM(employ)HY(ees)YH(_)ES( list of + point)HY(ers)YH( is an inverse side of a bidi)HY(rec)HY(tional)YH( rela)HY(tion)HY(ship)YH( + and is effec)HY(tively)YH( read-only, from the persis)HY(tence)YH( point of + view.)EP( + + )0 P(A faster imple)HY(men)HY(ta)HY(tion)YH( of this trans)HY(ac)HY(tion)YH(, that avoids loading + the employer object, relies on the ability to initial)HY(ize)YH( an + )EM(unloaded)ES( lazy pointer with the database where the object + is stored as well as its iden)HY(ti)HY(fier)YH(:)EP( + + ) 11 63 PR(lazy_shared_ptr er \201db, std::string \201"Example Inc"\202\202; +shared_ptr e \201new employee \201"John", "Doe"\202\202; + +e->employer_ = er; + +session s; +transaction t \201db.begin \201\202\202; + +db.persist \201e\202; + +t.commit \201\202;)RP( + + )0 P(For the inter)HY(ac)HY(tion)YH( of lazy point)HY(ers)YH( with lazy-loaded object + sections, refer to )0 77 1 A(Section 9.3, "Sections and + Lazy Point)HY(ers)YH(")77 0 TN TL()Ec /AF f D(.)EP( + + )0 2 58 H(6.5)WB 383 Sn()WB 62 Sn( Using Custom Smart Point)HY(ers)YH()EA()EH( + + )0 P(While the ODB runtime and profile libraries provide support for + the major)HY(ity)YH( of widely-used point)HY(ers)YH(, it is also easy to add + support for a custom smart pointer.)EP( + + )0 P(To achieve this you will need to imple)HY(ment)YH( the + )SM(pointer_traits)ES( class template special)HY(iza)HY(tion)YH( for + your pointer. The first step is to deter)HY(mine)YH( the pointer kind + since the inter)HY(face)YH( of the )SM(pointer_traits)ES( special)HY(iza)HY(tion)YH( + varies depend)HY(ing)YH( on the pointer kind. The supported pointer kinds + are: )EM(raw)ES( \201raw pointer or equiv)HY(a)HY(lent)YH(, that is, unman)HY(aged)YH(\202, + )EM(unique)ES( \201smart pointer that doesn't support sharing\202, + )EM(shared)ES( \201smart pointer that supports sharing\202, and + )EM(weak)ES( \201weak coun)HY(ter)HY(part)YH( of the shared pointer\202. Any of + these point)HY(ers)YH( can be lazy, which also affects the + inter)HY(face)YH( of the )SM(pointer_traits)ES( special)HY(iza)HY(tion)YH(.)EP( + + )0 P(Once you have deter)HY(mined)YH( the pointer kind for your smart pointer, + use a special)HY(iza)HY(tion)YH( for one of the stan)HY(dard)YH( point)HY(ers)YH( found in + the common ODB runtime library \201)SM(libodb)ES(\202 as a base + for your own imple)HY(men)HY(ta)HY(tion)YH(.)EP( + + )0 P(Once the pointer traits special)HY(iza)HY(tion)YH( is ready, you will need to + include it into the ODB compi)HY(la)HY(tion)YH( process using the + )SM(--odb-epilogue)ES( option and into the gener)HY(ated)YH( header + files with the )SM(--hxx-prologue)ES( option. As an example, + suppose we have the )SM(smart_ptr)ES( smart pointer for which + we have the traits special)HY(iza)HY(tion)YH( imple)HY(mented)YH( in the + )SM(smart-ptr-traits.hxx)ES( file. Then, we can create an ODB + compiler options file for this pointer and save it to + )SM(smart-ptr.options)ES(:)EP( + + ) 4 48 PR(# Options file for smart_ptr. +# +--odb-epilogue '#include "smart-ptr-traits.hxx"' +--hxx-prologue '#include "smart-ptr-traits.hxx"')RP( + + )0 P(Now, when)HY(ever)YH( we compile a header file that uses )SM(smart_ptr)ES(, + we can specify the follow)HY(ing)YH( command line option to make sure it is + recog)HY(nized)YH( by the ODB compiler as a smart pointer and the traits file + is included in the gener)HY(ated)YH( code:)EP( + + ) 1 32 PR(--options-file smart-ptr.options)RP( + + )0 P(It is also possi)HY(ble)YH( to imple)HY(ment)YH( a lazy coun)HY(ter)HY(part)YH( for your + smart pointer. The ODB runtime library provides a class template + that encap)HY(su)HY(lates)YH( the object id manage)HY(ment)YH( and loading + func)HY(tion)HY(al)HY(ity)YH( that is needed to imple)HY(ment)YH( a lazy pointer. All + you need to do is wrap it with an inter)HY(face)YH( that mimics + your smart pointer. Using one of the exist)HY(ing)YH( lazy pointer + imple)HY(men)HY(ta)HY(tions)YH( \201either from the ODB runtime library or one + of the profile libraries\202 as a base for your imple)HY(men)HY(ta)HY(tion)YH( + is the easiest way to get started.)EP( + + + + + )WB NL NP( + )0 1 59 H(7)WB 384 Sn()WB 63 Sn( Value Types)EA()EH( + + )0 P(In )0 24 1 A(Section 3.1, "Concepts and Termi)HY(nol)HY(ogy)YH(")24 0 TN TL()Ec /AF f D( we have + already discussed the notion of values and value types as well as the + distinc)HY(tion)YH( between simple and compos)HY(ite)YH( values. This chapter covers + simple and compos)HY(ite)YH( value types in more detail.)EP( + + )0 2 60 H(7.1)WB 385 Sn()WB 64 Sn( Simple Value Types)EA()EH( + + )0 P(A simple value type is a funda)HY(men)HY(tal)YH( C++ type or a class type that + is mapped to a single database column. For each supported database + system the ODB compiler provides a default mapping to suit)HY(able)YH( + database types for most funda)HY(men)HY(tal)YH( C++ types, such as )SM(int)ES( + or )SM(float)ES( as well as some class types, such as + )SM(std::string)ES(. For more infor)HY(ma)HY(tion)YH( about the default + mapping for each database system refer to )0 204 1 A(Part II, + Database Systems)204 0 TN TL()Ec /AF f D(. We can also provide a custom mapping for + these or our own value types using the )SM(db\240type)ES( + pragma \201)0 126 1 A(Section 14.3.1, ")SM(type)ES(")126 0 TN TL()Ec /AF f D(\202.)EP( + + )0 2 61 H(7.2)WB 386 Sn()WB 65 Sn( Compos)HY(ite)YH( Value Types)EA()EH( + + )0 P(A compos)HY(ite)YH( value type is a )SM(class)ES( or )SM(struct)ES( + type that is mapped to more than one database column. To declare + a compos)HY(ite)YH( value type we use the )SM(db\240value)ES( pragma, + for example:)EP( + + ) 8 21 PR(#pragma db value +class basic_name +{ + ... + + std::string first_; + std::string last_; +};)RP( + + )0 P(The complete version of the above code frag)HY(ment)YH( and the other code + samples presented in this section can be found in the )SM(compos)HY(ite)YH()ES( + example in the )SM(odb-exam)HY(ples)YH()ES( package.)EP( + + )0 P(A compos)HY(ite)YH( value type does not have to define a default construc)HY(tor)YH(, + unless it is used as an element of a container. In this case the + default construc)HY(tor)YH( can be made private provided we also make the + )SM(odb::access)ES( class, defined in the + )SM()ES( header, a friend of this value type. + For example:)EP( + + ) 17 66 PR(#include + +#pragma db value +class basic_name +{ +public: + basic_name \201const std::string& first, const std::string& last\202; + + ... + +private: + friend class odb::access; + + basic_name \201\202 {} // Needed for storing basic_name in containers. + + ... +};)RP( + + )0 P(The ODB compiler also needs access to the non-tran)HY(sient)YH( + \201)0 158 1 A(Section 14.4.11, ")SM(tran)HY(sient)YH()ES(")158 0 TN TL()Ec /AF f D(\202 + data members of a compos)HY(ite)YH( value type. It uses the same mech)HY(a)HY(nisms)YH( + as for persis)HY(tent)YH( classes which are discussed in + )0 25 1 A(Section 3.2, "Declar)HY(ing)YH( Persis)HY(tent)YH( Objects and + Values")25 0 TN TL()Ec /AF f D(.)EP( + + )0 P(The members of a compos)HY(ite)YH( value can be other value types \201either + simple or compos)HY(ite)YH(\202, contain)HY(ers)YH( \201)0 45 1 A(Chapter 5, + "Contain)HY(ers)YH(")45 0 TN TL()Ec /AF f D(\202, and point)HY(ers)YH( to objects \201)0 52 1 A(Chapter 6, + "Rela)HY(tion)HY(ships)YH(")52 0 TN TL()Ec /AF f D(\202. + Simi)HY(larly)YH(, a compos)HY(ite)YH( value type can be used in object members, + as an element of a container, and as a base for another compos)HY(ite)YH( + value type. In partic)HY(u)HY(lar)YH(, compos)HY(ite)YH( value types can be used as + element types in set contain)HY(ers)YH( \201)0 47 1 A(Section 5.2, "Set + and Multi)HY(set)YH( Contain)HY(ers)YH(")47 0 TN TL()Ec /AF f D(\202 and as key types in map contain)HY(ers)YH( + \201)0 48 1 A(Section 5.3, "Map and Multimap Contain)HY(ers)YH(")48 0 TN TL()Ec /AF f D(\202. + A compos)HY(ite)YH( value type that is used as an element of a container + cannot contain other contain)HY(ers)YH( since contain)HY(ers)YH( of contain)HY(ers)YH( + are not allowed. The follow)HY(ing)YH( example illus)HY(trates)YH( some of the + possi)HY(ble)YH( use cases:)EP( + + ) 36 44 PR(#pragma db value +class basic_name +{ + ... + + std::string first_; + std::string last_; +}; + +typedef std::vector basic_names; + +#pragma db value +class name_extras +{ + ... + + std::string nickname_; + basic_names aliases_; +}; + +#pragma db value +class name: public basic_name +{ + ... + + std::string title_; + name_extras extras_; +}; + +#pragma db object +class person)WR( +{ + ... + + name name_; +};)RP( + + )0 P(A compos)HY(ite)YH( value type can be defined inside a persis)HY(tent)YH( class, + view, or another compos)HY(ite)YH( value and even made private, provided + we make )SM(odb::access)ES( a friend of the contain)HY(ing)YH( class, + for example:)EP( + +) 16 23 PR(#pragma db object +class person +{ + ... + + #pragma db value + class name + { + ... + + std::string first_; + std::string last_; + }; + + name name_; +};)RP( + + )0 P(A compos)HY(ite)YH( value type can also be defined as an instan)HY(ti)HY(a)HY(tion)YH( + of a C++ class template, for example:)EP( + + ) 18 29 PR(template +struct point +{ + T x; + T y; + T z; +}; + +typedef point int_point; +#pragma db value\201int_point\202 + +#pragma db object +class object +{ + ... + + int_point center_; +};)RP( + + )0 P(Note that the database support code for such a compos)HY(ite)YH( value type + is gener)HY(ated)YH( when compil)HY(ing)YH( the header contain)HY(ing)YH( the + )SM(db\240value)ES( pragma and not the header contain)HY(ing)YH( + the template defi)HY(ni)HY(tion)YH( or the )SM(typedef)ES( name. This + allows us to use templates defined in other files, such as + )SM(std::pair)ES( defined in the )SM(utility)ES( + stan)HY(dard)YH( header file:)EP( + + ) 12 58 PR(#include // std::pair + +typedef std::pair phone_numbers; +#pragma db value\201phone_numbers\202 + +#pragma db object +class person +{ + ... + + phone_numbers phone_; +};)RP( + + )0 P(We can also use data members from compos)HY(ite)YH( value types + in database queries \201)0 38 1 A(Chapter 4, "Query)HY(ing)YH( the + Database")38 0 TN TL()Ec /AF f D(\202. For each compos)HY(ite)YH( value in a persis)HY(tent)YH( class, the + query class defines a nested member that contains members corre)HY(spond)HY(ing)YH( + to the data members in the value type. We can then use the member access + syntax \201.\202 to refer to data members in value types. For example, the + query class for the )SM(person)ES( object presented above + contains the )SM(name)ES( member \201its name is derived from + the )SM(name_)ES( data member\202 which in turn contains the + )SM(extras)ES( member \201its name is derived from the + )SM(name::extras_)ES( data member of the compos)HY(ite)YH( value type\202. + This process contin)HY(ues)YH( recur)HY(sively)YH( for nested compos)HY(ite)YH( value types + and, as a result, we can use the )SM(query::name.extras.nick)HY(name)YH()ES( + expres)HY(sion)YH( while query)HY(ing)YH( the database for the )SM(person)ES( + objects. For example:)EP( + + ) 11 45 PR(typedef odb::query query; +typedef odb::result result; + +transaction t \201db.begin \201\202\202; + +result r \201db.query \201 + query::name.extras.nickname == "Squeaky"\202\202; + +... + +t.commit \201\202;)RP( + + )0 3 62 H(7.2.1)WB 387 Sn()WB 66 Sn( Compos)HY(ite)YH( Object Ids)EA()EH( + + )0 P(An object id can be of a compos)HY(ite)YH( value type, for example:)EP( + + ) 17 21 PR(#pragma db value +class name +{ + ... + + std::string first_; + std::string last_; +}; + +#pragma db object +class person +{ + ... + + #pragma db id + name name_; +};)RP( + + )0 P(However, a value type that can be used as an object id has a number + of restric)HY(tions)YH(. Such a value type cannot have container, object + pointer, or read-only data members. It also must be + default-constructible, copy-constructible, and copy-assignable. + Further)HY(more)YH(, if the persis)HY(tent)YH( class in which + this compos)HY(ite)YH( value type is used as object id has session support + enabled \201)0 87 1 A(Chapter 11, "Session")87 0 TN TL()Ec /AF f D(\202, then it must also + imple)HY(ment)YH( the less-than compar)HY(i)HY(son)YH( oper)HY(a)HY(tor)YH( \201)SM(oper)HY(a)HY(tor)YH(<)ES(\202.)EP( + + )0 3 63 H(7.2.2)WB 388 Sn()WB 67 Sn( Compos)HY(ite)YH( Value Column and Table Names)EA()EH( + + )0 P(Customiz)HY(ing)YH( a column name for a data member of a simple value + type is straight)HY(for)HY(ward)YH(: we simply specify the desired name with + the )SM(db\240column)ES( pragma \201)0 156 1 A(Section + 14.4.9, ")SM(column)ES(")156 0 TN TL()Ec /AF f D(\202. For compos)HY(ite)YH( value + types things are slightly more complex since they are mapped to + multi)HY(ple)YH( columns. Consider the follow)HY(ing)YH( example:)EP( + + ) 19 21 PR(#pragma db value +class name +{ + ... + + std::string first_; + std::string last_; +}; + +#pragma db object +class person +{ + ... + + #pragma db id auto + unsigned long id_; + + name name_; +};)RP( + + )0 P(The column names for the )SM(first_)ES( and )SM(last_)ES( + members are constructed by using the sani)HY(tized)YH( name of the + )SM(person::name_)ES( member as a prefix and the names of the + members in the value type \201)SM(first_)ES( and )SM(last_)ES(\202 + as suffixes. As a result, the database schema for the above classes + will look like this:)EP( + + ) 4 42 PR(CREATE TABLE person \201 + id BIGINT UNSIGNED NOT NULL PRIMARY KEY, + name_first TEXT NOT NULL, + name_last TEXT NOT NULL\202;)RP( + + )0 P(We can customize both the prefix and the suffix using the + )SM(db\240column)ES( pragma as shown in the follow)HY(ing)YH( + example:)EP( + + ) 20 33 PR(#pragma db value +class name +{ + ... + + #pragma db column\201"first_name"\202 + std::string first_; + + #pragma db column\201"last_name"\202 + std::string last_; +}; + +#pragma db object +class person +{ + ... + + #pragma db column\201"person_"\202 + name name_; +};)RP( + + )0 P(The database schema changes as follows:)EP( + + ) 4 42 PR(CREATE TABLE person \201 + id BIGINT UNSIGNED NOT NULL PRIMARY KEY, + person_first_name TEXT NOT NULL, + person_last_name TEXT NOT NULL\202;)RP( + + )0 P(We can also make the column prefix empty, for example:)EP( + + ) 8 23 PR(#pragma db object +class person +{ + ... + + #pragma db column\201""\202 + name name_; +};)RP( + + )0 P(This will result in the follow)HY(ing)YH( schema:)EP( + + ) 4 42 PR(CREATE TABLE person \201 + id BIGINT UNSIGNED NOT NULL PRIMARY KEY, + first_name TEXT NOT NULL, + last_name TEXT NOT NULL\202;)RP( + + )0 P(The same prin)HY(ci)HY(ple)YH( applies when a compos)HY(ite)YH( value type is used + as an element of a container, except that instead of + )SM(db\240column)ES(, either the )SM(db\240value_column)ES( + \201)0 183 1 A(Section 14.4.36, ")SM(value_column)ES(")183 0 TN TL()Ec /AF f D(\202 or + )SM(db\240key_column)ES( + \201)0 182 1 A(Section 14.4.35, ")SM(key_column)ES(")182 0 TN TL()Ec /AF f D(\202 + pragmas are used to specify the column prefix.)EP( + + )0 P(When a compos)HY(ite)YH( value type contains a container, an extra table + is used to store its elements \201)0 45 1 A(Chapter 5, "Contain)HY(ers)YH(")45 0 TN TL()Ec /AF f D(\202. + The names of such tables are constructed in a way similar to the + column names, except that by default both the object name and the + member name are used as a prefix. For example:)EP( + + ) 17 38 PR(#pragma db value +class name +{ + ... + + std::string first_; + std::string last_; + std::vector nicknames_; +}; + +#pragma db object +class person +{ + ... + + name name_; +};)RP( + + )0 P(The corre)HY(spond)HY(ing)YH( database schema will look like this:)EP( + + ) 9 42 PR(CREATE TABLE person_name_nicknames \201 + object_id BIGINT UNSIGNED NOT NULL, + index BIGINT UNSIGNED NOT NULL, + value TEXT NOT NULL\202 + +CREATE TABLE person \201 + id BIGINT UNSIGNED NOT NULL PRIMARY KEY, + name_first TEXT NOT NULL, + name_last TEXT NOT NULL\202;)RP( + + )0 P(To customize the container table name we can use the + )SM(db\240table)ES( pragma \201)0 167 1 A(Section + 14.4.20, ")SM(table)ES(")167 0 TN TL()Ec /AF f D(\202, for example:)EP( + + ) 17 38 PR(#pragma db value +class name +{ + ... + + #pragma db table\201"nickname"\202 + std::vector nicknames_; +}; + +#pragma db object +class person +{ + ... + + #pragma db table\201"person_"\202 + name name_; +};)RP( + + )0 P(This will result in the follow)HY(ing)YH( schema changes:)EP( + + ) 4 37 PR(CREATE TABLE person_nickname \201 + object_id BIGINT UNSIGNED NOT NULL, + index BIGINT UNSIGNED NOT NULL, + value TEXT NOT NULL\202)RP( + + )0 P(Similar to columns, we can make the table prefix empty.)EP( + + + )0 2 64 H(7.3)WB 389 Sn()WB 68 Sn( Point)HY(ers)YH( and )SM(NULL)ES( Value Seman)HY(tics)YH()EA()EH( + + )0 P(Rela)HY(tional)YH( database systems have a notion of the special + )SM(NULL)ES( value that is used to indi)HY(cate)YH( the absence + of a valid value in a column. While by default ODB maps + values to columns that do not allow )SM(NULL)ES( values, + it is possi)HY(ble)YH( to change that with the )SM(db\240null)ES( + pragma \201)0 153 1 A(Section 14.4.6, + ")SM(null)ES(/)SM(not_null)ES(")153 0 TN TL()Ec /AF f D(\202.)EP( + + )0 P(To prop)HY(erly)YH( support the )SM(NULL)ES( seman)HY(tics)YH(, the + C++ value type must have a notion of a )SM(NULL)ES( + value or a similar special state concept. Most basic + C++ types, such as )SM(int)ES( or )SM(std::string)ES(, + do not have this notion and there)HY(fore)YH( cannot be used directly + for )SM(NULL)ES(-enabled data members \201in the case of a + )SM(NULL)ES( value being loaded from the database, + such data members will be default-initial)HY(ized)YH(\202.)EP( + + )0 P(To allow the easy conver)HY(sion)YH( of value types that do not support + the )SM(NULL)ES( seman)HY(tics)YH( into the ones that do, ODB + provides the )SM(odb::nullable)ES( class template. It + allows us to wrap an exist)HY(ing)YH( C++ type into a container-like + class that can either be )SM(NULL)ES( or contain a + value of the wrapped type. ODB also auto)HY(mat)HY(i)HY(cally)YH( enables + the )SM(NULL)ES( values for data members of the + )SM(odb::nullable)ES( type. For example:)EP( + + ) 11 57 PR(#include + +#pragma db object +class person +{ + ... + + std::string first_; // TEXT NOT NULL + odb::nullable middle_; // TEXT NULL + std::string last_; // TEXT NOT NULL +};)RP( + + )0 P(The )SM(odb::nullable)ES( class template is defined + in the )SM()ES( header file and + has the follow)HY(ing)YH( inter)HY(face)YH(:)EP( + + ) 41 67 PR(namespace odb +{ + template + class nullable + { + public: + typedef T value_type; + + nullable \201\202; + nullable \201const T&\202; + nullable \201const nullable&\202; + template explicit nullable \201const nullable&\202; + + nullable& operator= \201const T&\202; + nullable& operator= \201const nullable&\202; + template nullable& operator= \201const nullable&\202; + + void swap \201nullable&\202; + + // Accessor interface. + // + bool null \201\202 const; + + T& get \201\202; + const T& get \201\202 const; + + // Pointer interface. + // + operator bool_convertible \201\202 const; + + T* operator-> \201\202;)WR( + const T* operator-> \201\202 const; + + T& operator* \201\202; + const T& operator* \201\202 const; + + // Reset to the NULL state. + // + void reset \201\202; + }; +})RP( + + )0 P(The follow)HY(ing)YH( example shows how we can use this inter)HY(face)YH(:)EP( + + ) 25 42 PR( nullable ns; + + // Using the accessor interface. + // + if \201ns.null \201\202\202 + { + s = "abc"; + } + else + { + string s \201ns.get \201\202\202; + ns.reset \201\202; + } + + // The same using the pointer interface. + // + if \201ns\202 + { + s = "abc"; + } + else + { + string s \201*ns\202; + ns.reset \201\202; + })RP( + + + )0 P(The )SM(odb::nullable)ES( class template requires the wrapped + type to have public default and copy construc)HY(tors)YH( as well as the + copy assign)HY(ment)YH( oper)HY(a)HY(tor)YH(. Note also that the )SM(odb::nullable)ES( + imple)HY(men)HY(ta)HY(tion)YH( is not the most effi)HY(cient)YH( in that it always contains + a fully constructed value of the wrapped type. This is normally + not a concern for simple types such as the C++ funda)HY(men)HY(tal)YH( + types or )SM(std::string)ES(. However, it may become + an issue for more complex types. In such cases you may want to + consider using a more effi)HY(cient)YH( imple)HY(men)HY(ta)HY(tion)YH( of the + )EM(optional value)ES( concept such as the + )SM(optional)ES( class template from Boost + \201)0 296 1 A(Section 23.4, "Optional Library")296 0 TN TL()Ec /AF f D(\202.)EP( + + )0 P(Another common C++ repre)HY(sen)HY(ta)HY(tion)YH( of a value that can be + )SM(NULL)ES( is a pointer. ODB will auto)HY(mat)HY(i)HY(cally)YH( + handle data members that are point)HY(ers)YH( to values, however, + it will not auto)HY(mat)HY(i)HY(cally)YH( enable )SM(NULL)ES( values + for such data members, as is the case for )SM(odb::nullable)ES(. + Instead, if the )SM(NULL)ES( value is desired, we will + need to enable it explic)HY(itly)YH( using the )SM(db\240null)ES( + pragma. For example:)EP( + + ) 12 37 PR(#pragma db object +class person +{ + ... + + std::string first_; + + #pragma db null + std::auto_ptr middle_; + + std::string last_; +};)RP( + + )0 P(The ODB compiler includes built-in support for using + )SM(std::auto_ptr)ES(, )SM(std::unique_ptr)ES( \201C++11\202, + and )SM(shared_ptr)ES( \201TR1 or C++11\202 as point)HY(ers)YH( to values. + Plus, ODB profile libraries, that are + avail)HY(able)YH( for commonly used frame)HY(works)YH( and libraries \201such as Boost and + Qt\202, provide support for smart point)HY(ers)YH( found in these frame)HY(works)YH( + and libraries \201)0 290 1 A(Part III, "Profiles")290 0 TN TL()Ec /AF f D(\202.)EP( + + )0 P(ODB also supports the )SM(NULL)ES( seman)HY(tics)YH( for compos)HY(ite)YH( + values. In the rela)HY(tional)YH( database the )SM(NULL)ES( compos)HY(ite)YH( + value is trans)HY(lated)YH( to )SM(NULL)ES( values for all the simple + data members of this compos)HY(ite)YH( value. For example:)EP( + + ) 14 37 PR(#pragma db value +struct name +{ + std::string first_; + odb::nullable middle_; + std::string last_; +}; + +#pragma db object +class person +{ + ... + odb::nullable name_; +};)RP( + + )0 P(ODB does not support the )SM(NULL)ES( seman)HY(tics)YH( for contain)HY(ers)YH(. + This also means that a compos)HY(ite)YH( value that contains a container + cannot be )SM(NULL)ES(. With this limi)HY(ta)HY(tion)YH( in mind, we can + still use smart point)HY(ers)YH( in data members of container types. The + only restric)HY(tion)YH( is that these point)HY(ers)YH( must not be )SM(NULL)ES(. + For example:)EP( + + ) 7 52 PR(#pragma db object +class person +{ + ... + + std::auto_ptr > aliases_; +};)RP( + + + + + + )WB NL NP( + )0 1 65 H(8)WB 390 Sn()WB 69 Sn( Inher)HY(i)HY(tance)YH()EA()EH( + + )0 P(In C++ inher)HY(i)HY(tance)YH( can be used to achieve two differ)HY(ent)YH( goals. + We can employ inher)HY(i)HY(tance)YH( to reuse common data and func)HY(tion)HY(al)HY(ity)YH( + in multi)HY(ple)YH( classes. For example:)EP( + + ) 20 36 PR(class person +{ +public: + const std::string& first \201\202 const; + const std::string& last \201\202 const; + +private: + std::string first_; + std::string last_; +}; + +class employee: public person +{ + ... +}; + +class contractor: public person +{ + ... +};)RP( + + )0 P(In the above example both the )SM(employee)ES( and + )SM(contrac)HY(tor)YH()ES( classes inherit the )SM(first_)ES( + and )SM(last_)ES( data members as well as the )SM(first\201\202)ES( + and )SM(last\201\202)ES( acces)HY(sors)YH( from the )SM(person)ES( base + class.)EP( + + )0 P(A common trait of this inher)HY(i)HY(tance)YH( style, referred to as )EM(reuse + inher)HY(i)HY(tance)YH()ES( from now on, is the lack of virtual func)HY(tions)YH( and + a virtual destruc)HY(tor)YH( in the base class. Also with this style the + appli)HY(ca)HY(tion)YH( code is normally written in terms of the derived classes + instead of the base.)EP( + + )0 P(The second way to utilize inher)HY(i)HY(tance)YH( in C++ is to provide poly)HY(mor)HY(phic)YH( + behav)HY(ior)YH( through a common inter)HY(face)YH(. In this case the base class + defines a number of virtual func)HY(tions)YH( and, normally, a virtual + destruc)HY(tor)YH( while the derived classes provide specific + imple)HY(men)HY(ta)HY(tions)YH( of these virtual func)HY(tions)YH(. For example:)EP( + + ) 40 46 PR(class person +{ +public: + enum employment_status + { + unemployed, + temporary, + permanent, + self_employed + }; + + virtual employment_status + employment \201\202 const = 0; + + virtual + ~person \201\202; +}; + +class employee: public person +{ +public: + virtual employment_status + employment \201\202 const + { + return temporary_ ? temporary : permanent; + } + +private: + bool temporary_; +}; +)WR( +class contractor: public person +{ +public: + virtual employment_status + employment \201\202 const + { + return self_employed; + } +};)RP( + + )0 P(With this inher)HY(i)HY(tance)YH( style, which we will call )EM(poly)HY(mor)HY(phism)YH( + inher)HY(i)HY(tance)YH()ES(, the appli)HY(ca)HY(tion)YH( code normally works with derived + classes via the base class inter)HY(face)YH(. Note also that it is very common + to mix both styles in the same hier)HY(ar)HY(chy)YH(. For example, the above two + code frag)HY(ments)YH( can be combined so that the )SM(person)ES( base + class provides the common data members and func)HY(tions)YH( as well as + defines the poly)HY(mor)HY(phic)YH( inter)HY(face)YH(.)EP( + + )0 P(The follow)HY(ing)YH( sections describe the avail)HY(able)YH( strate)HY(gies)YH( for + mapping reuse and poly)HY(mor)HY(phism)YH( inher)HY(i)HY(tance)YH( styles to a rela)HY(tional)YH( + data model. Note also that the distinc)HY(tion)YH( between the two styles is + concep)HY(tual)YH( rather than formal. For example, it is possi)HY(ble)YH( to treat + a class hier)HY(ar)HY(chy)YH( that defines virtual func)HY(tions)YH( as a case of reuse + inher)HY(i)HY(tance)YH( if this results in the desired database mapping and + seman)HY(tics)YH(.)EP( + + )0 P(Gener)HY(ally)YH(, classes that employ reuse inher)HY(i)HY(tance)YH( are mapped to + completely inde)HY(pen)HY(dent)YH( enti)HY(ties)YH( in the database. They use differ)HY(ent)YH( + object id spaces and should always be passed to and returned from + the database oper)HY(a)HY(tions)YH( as point)HY(ers)YH( or refer)HY(ences)YH( to derived types. + In other words, from the persis)HY(tence)YH( point of view, such classes + behave as if the data members from the base classes were copied + verba)HY(tim)YH( into the derived ones.)EP( + + )0 P(In contrast, classes that employ poly)HY(mor)HY(phism)YH( inher)HY(i)HY(tance)YH( share + the object id space and can be passed to and returned from the + database oper)HY(a)HY(tions)YH( )EM(poly)HY(mor)HY(phi)HY(cally)YH()ES( as point)HY(ers)YH( or + refer)HY(ences)YH( to the base class.)EP( + + )0 P(For both inher)HY(i)HY(tance)YH( styles it is some)HY(times)YH( desir)HY(able)YH( to prevent + instances of a base class from being stored in the database. + To achieve this a persis)HY(tent)YH( + class can be declared abstract using the )SM(db\240abstract)ES( + pragma \201)0 104 1 A(Section 14.1.3, ")SM(abstract)ES(")104 0 TN TL()Ec /AF f D(\202. + Note that a )EM(C++-abstract)ES( class, or a class that + has one or more pure virtual func)HY(tions)YH( and there)HY(fore)YH( cannot be + instan)HY(ti)HY(ated)YH(, is also )EM(database-abstract)ES(. However, a + database-abstract class is not neces)HY(sar)HY(ily)YH( C++-abstract. The + ODB compiler auto)HY(mat)HY(i)HY(cally)YH( treats C++-abstract classes as + database-abstract.)EP( + + )0 2 66 H(8.1)WB 391 Sn()WB 70 Sn( Reuse Inher)HY(i)HY(tance)YH()EA()EH( + + )0 P(Each non-abstract class from the reuse inher)HY(i)HY(tance)YH( hier)HY(ar)HY(chy)YH( is + mapped to a sepa)HY(rate)YH( database table that contains all its data + members, includ)HY(ing)YH( those inher)HY(ited)YH( from base classes. An abstract + persis)HY(tent)YH( class does not have to define an object id, nor a default + construc)HY(tor)YH(, and it does not have a corre)HY(spond)HY(ing)YH( database table. + An abstract class cannot be a pointed-to object in a rela)HY(tion)HY(ship)YH(. + Multi)HY(ple)YH( inher)HY(i)HY(tance)YH( is supported as long as each base + class is only inher)HY(ited)YH( once. The follow)HY(ing)YH( example shows a + persis)HY(tent)YH( class hier)HY(ar)HY(chy)YH( employ)HY(ing)YH( reuse inher)HY(i)HY(tance)YH(:)EP( + + ) 57 65 PR(// Abstract person class. Note that it does not declare the +// object id. +// +#pragma db object abstract +class person +{ + ... + + std::string first_; + std::string last_; +}; + +// Abstract employee class. It derives from the person class and +// declares the object id for all the concrete employee types. +// +#pragma db object abstract +class employee: public person +{ + ... + + #pragma db id auto + unsigned long id_; +}; + +// Concrete permanent_employee class. Note that it doesn't define +// any data members of its own. +// +#pragma db object +class permanent_employee: public employee +{ + ...)WR( +}; + +// Concrete temporary_employee class. It adds the employment +// duration in months. +// +#pragma db object +class temporary_employee: public employee +{ + ... + + unsigned long duration_; +}; + +// Concrete contractor class. It derives from the person class +// \201and not employee; an independent contractor is not considered +// an employee\202. We use the contractor's external email address +// as the object id. +// +#pragma db object +class contractor: public person +{ + ... + + #pragma db id + std::string email_; +};)RP( + + )0 P(The sample database schema for this hier)HY(ar)HY(chy)YH( is shown below.)EP( + + ) 15 58 PR(CREATE TABLE permanent_employee \201 + first TEXT NOT NULL, + last TEXT NOT NULL, + id BIGINT UNSIGNED NOT NULL PRIMARY KEY AUTO_INCREMENT\202; + +CREATE TABLE temporary_employee \201 + first TEXT NOT NULL, + last TEXT NOT NULL, + id BIGINT UNSIGNED NOT NULL PRIMARY KEY AUTO_INCREMENT, + duration BIGINT UNSIGNED NOT NULL\202; + +CREATE TABLE contractor \201 + first TEXT NOT NULL, + last TEXT NOT NULL, + email VARCHAR \201255\202 NOT NULL PRIMARY KEY\202;)RP( + + )0 P(The complete version of the code presented in this section is + avail)HY(able)YH( in the )SM(inher)HY(i)HY(tance)YH(/reuse)ES( example in the + )SM(odb-exam)HY(ples)YH()ES( package.)EP( + + )0 2 67 H(8.2)WB 392 Sn()WB 71 Sn( Poly)HY(mor)HY(phism)YH( Inher)HY(i)HY(tance)YH()EA()EH( + + )0 P(There are three general approaches to mapping a poly)HY(mor)HY(phic)YH( + class hier)HY(ar)HY(chy)YH( to a rela)HY(tional)YH( database. These are + )EM(table-per-hier)HY(ar)HY(chy)YH()ES(, )EM(table-per-differ)HY(ence)YH()ES(, + and )EM(table-per-class)ES(. With the table-per-hier)HY(ar)HY(chy)YH( + mapping, all the classes in a hier)HY(ar)HY(chy)YH( are stored in a single, + "wide" table. )SM(NULL)ES( values are stored in columns + corre)HY(spond)HY(ing)YH( to data members of derived classes that are + not present in any partic)HY(u)HY(lar)YH( instance.)EP( + + )0 P(In the table-per-differ)HY(ence)YH( mapping, each class is mapped + to a sepa)HY(rate)YH( table. For a derived class, this table contains + only columns corre)HY(spond)HY(ing)YH( to the data members added by this + derived class.)EP( + + )0 P(Finally, in the table-per-class mapping, each class is mapped + to a sepa)HY(rate)YH( table. For a derived class, this table contains + columns corre)HY(spond)HY(ing)YH( to all the data members, from this derived + class all the way down to the root of the hier)HY(ar)HY(chy)YH(.)EP( + + )0 P(The table-per-differ)HY(ence)YH( mapping is gener)HY(ally)YH( consid)HY(ered)YH( as + having the best balance of flex)HY(i)HY(bil)HY(ity)YH(, perfor)HY(mance)YH(, and space + effi)HY(ciency)YH(. It also results in a more canon)HY(i)HY(cal)YH( rela)HY(tional)YH( + database model compared to the other two approaches. As a + result, this is the mapping currently imple)HY(mented)YH( in ODB. + Other mappings may be supported in the future.)EP( + + )0 P(A pointer or refer)HY(ence)YH( to an ordi)HY(nary)YH(, non-poly)HY(mor)HY(phic)YH( object + has just one type \236 the class type of that object. When we + start working with poly)HY(mor)HY(phic)YH( objects, there are two types + to consider: the )EM(static type)ES(, or the decla)HY(ra)HY(tion)YH( type + of a refer)HY(ence)YH( or pointer, and the object's actual or )EM(dynamic + type)ES(. An example will help illus)HY(trate)YH( the differ)HY(ence)YH(:)EP( + + ) 10 36 PR(class person {...}; +class employee: public person {...}; + +person p; +employee e; + +person& r1 \201p\202; +person& r2 \201e\202; + +auto_ptr p1 \201new employee\202;)RP( + + )0 P(In the above example, the )SM(r1)ES( refer)HY(ence)YH('s both static + and dynamic types are )SM(person)ES(. + In contrast, the )SM(r2)ES( refer)HY(ence)YH('s static type is + )SM(person)ES( while its dynamic type \201the actual object + that it refers to\202 is )SM(employee)ES(. Simi)HY(larly)YH(, + )SM(p1)ES( points to the object of the )SM(person)ES( + static type but )SM(employee)ES( dynamic type.)EP( + + )0 P(In C++, the primary mech)HY(a)HY(nisms)YH( for working with poly)HY(mor)HY(phic)YH( objects + are virtual func)HY(tions)YH(. We call a virtual func)HY(tion)YH( only knowing the + object's static type, but the version corre)HY(spond)HY(ing)YH( to the object's + dynamic type is auto)HY(mat)HY(i)HY(cally)YH( executed. This is the essence of + runtime poly)HY(mor)HY(phism)YH( support in C++: we can operate in terms of a base + class inter)HY(face)YH( but get the derived class' behav)HY(ior)YH(. Simi)HY(larly)YH(, the + essence of the runtime poly)HY(mor)HY(phism)YH( support in ODB is to allow us to + persist, load, update, and query in terms of the base class inter)HY(face)YH( + but have the derived class actu)HY(ally)YH( stored in the database.)EP( + + )0 P(To declare a persis)HY(tent)YH( class as poly)HY(mor)HY(phic)YH( we use the + )SM(db\240poly)HY(mor)HY(phic)YH()ES( pragma. We only need to + declare the root class of a hier)HY(ar)HY(chy)YH( as poly)HY(mor)HY(phic)YH(; ODB will + treat all the derived classes as poly)HY(mor)HY(phic)YH( auto)HY(mat)HY(i)HY(cally)YH(. For + example:)EP( + + ) 29 44 PR(#pragma db object polymorphic +class person +{ + ... + + virtual + ~person \201\202 = 0; // Automatically abstract. + + #pragma db id auto + unsigned long id_; + + std::string first_; + std::string last_; +}; + +#pragma db object +class employee: public person +{ + ... + + bool temporary_; +}; + +#pragma db object +class contractor: public person +{ + + std::string email_; +};)RP( + + )0 P(A persis)HY(tent)YH( class hier)HY(ar)HY(chy)YH( declared poly)HY(mor)HY(phic)YH( must also be + poly)HY(mor)HY(phic)YH( in the C++ sense, that is, the root class must + declare or inherit at least one virtual func)HY(tion)YH(. It is + recom)HY(mended)YH( that the root class also declares a virtual destruc)HY(tor)YH(. + The root class of the poly)HY(mor)HY(phic)YH( hier)HY(ar)HY(chy)YH( must contain + the data member desig)HY(nated)YH( as object id \201a persis)HY(tent)YH( class + without an object id cannot be poly)HY(mor)HY(phic)YH(\202. Note also that, + unlike reuse inher)HY(i)HY(tance)YH(, abstract poly)HY(mor)HY(phic)YH( classes have + a table in the database, just like non-abstract classes.)EP( + + )0 P(Persis)HY(tent)YH( classes in the same poly)HY(mor)HY(phic)YH( hier)HY(ar)HY(chy)YH( must use the + same kind of object pointer \201)0 26 1 A(Section 3.3, + "Object and View Point)HY(ers)YH(")26 0 TN TL()Ec /AF f D(\202. If the object pointer + for the root class is spec)HY(i)HY(fied)YH( as a template or using the + special raw pointer syntax \201)SM(*)ES(\202, then the ODB + compiler will auto)HY(mat)HY(i)HY(cally)YH( use the same object pointer + for all the derived classes. For example:)EP( + + ) 17 67 PR(#pragma db object polymorphic pointer\201std::shared_ptr\202 +class person +{ + ... +}; + +#pragma db object // Object pointer is std::shared_ptr. +class employee: public person +{ + ... +}; + +#pragma db object // Object pointer is std::shared_ptr. +class contractor: public person +{ + ... +};)RP( + + )0 P(Simi)HY(larly)YH(, if we enable or disable session support + \201)0 87 1 A(Chapter 11, "Session")87 0 TN TL()Ec /AF f D(\202 for the root class, then + the ODB compiler will auto)HY(mat)HY(i)HY(cally)YH( enable or disable it for all + the derived classes.)EP( + + )0 P(For poly)HY(mor)HY(phic)YH( persis)HY(tent)YH( classes, all the database oper)HY(a)HY(tions)YH( can + be performed on objects with differ)HY(ent)YH( static and dynamic types. + Simi)HY(larly)YH(, oper)HY(a)HY(tions)YH( that load persis)HY(tent)YH( objects from the + database \201)SM(load\201\202)ES(, )SM(query\201\202)ES(, etc.\202, can + return objects with differ)HY(ent)YH( static and dynamic types. For + example:)EP( + + ) 70 59 PR(unsigned long id1, id2; + +// Persist. +// +{ + shared_ptr p1 \201new employee \201...\202\202; + shared_ptr p2 \201new contractor \201...\202\202; + + transaction t \201db.begin \201\202\202; + id1 = db.persist \201p1\202; // Stores employee. + id2 = db.persist \201p2\202; // Stores contractor. + t.commit \201\202; +} + +// Load. +// +{ + shared_ptr p; + + transaction t \201db.begin \201\202\202; + p = db.load \201id1\202; // Loads employee. + p = db.load \201id2\202; // Loads contractor. + t.commit \201\202; +} + +// Query. +// +{ + typedef odb::query query; + typedef odb::result result; +)WR( + transaction t \201db.begin \201\202\202; + + result r \201db.query \201query::last == "Doe"\202\202; + + for \201result::iterator i \201r.begin \201\202\202; i != r.end \201\202; ++i\202 + { + person& p \201*i\202; // Can be employee or contractor. + } + + t.commit \201\202; +} + +// Update. +// +{ + shared_ptr p; + shared_ptr e; + + transaction t \201db.begin \201\202\202; + + e = db.load \201id1\202; + e->temporary \201false\202; + p = e; + db.update \201p\202; // Updates employee. + + t.commit \201\202; +} + +// Erase. +//)WR( +{ + shared_ptr p; + + transaction t \201db.begin \201\202\202; + p = db.load \201id1\202; // Loads employee. + db.erase \201p\202; // Erases employee. + db.erase \201id2\202; // Erases contractor. + t.commit \201\202; +})RP( + + + )0 P(The table-per-differ)HY(ence)YH( mapping, as supported by ODB, requires + two extra columns, in addi)HY(tion)YH( to those corre)HY(spond)HY(ing)YH( to the + data members. The first, called )EM(discrim)HY(i)HY(na)HY(tor)YH()ES(, is added + to the table corre)HY(spond)HY(ing)YH( to the root class of the hier)HY(ar)HY(chy)YH(. + This column is used to deter)HY(mine)YH( the dynamic type of each + object. The second column is added to tables corre)HY(spond)HY(ing)YH( + to the derived classes and contains the object id. This + column is used to form a foreign key constraint refer)HY(enc)HY(ing)YH( + the root class table.)EP( + + )0 P(When query)HY(ing)YH( the database for poly)HY(mor)HY(phic)YH( objects, it is + possi)HY(ble)YH( to obtain the discrim)HY(i)HY(na)HY(tor)YH( value without + instan)HY(ti)HY(at)HY(ing)YH( the object. For example:)EP( + + ) 14 57 PR(typedef odb::query query; +typedef odb::result result; + +transaction t \201db.begin \201\202\202; + +result r \201db.query \201query::last == "Doe"\202\202; + +for \201result::iterator i \201r.begin \201\202\202; i != r.end \201\202; ++i\202 +{ + std::string d \201i.discriminator \201\202\202; + ... +} + +t.commit \201\202;)RP( + + )0 P(In the current imple)HY(men)HY(ta)HY(tion)YH(, ODB has limited support for + customiz)HY(ing)YH( names, types, and values of the extra columns. + Currently, the discrim)HY(i)HY(na)HY(tor)YH( column is always called + )SM(typeid)ES( and contains a names)HY(pace)YH(-qual)HY(i)HY(fied)YH( class + name \201for example, )SM("employee")ES( or + )SM("hr::employee")ES(\202. The id column in the derived + class table has the same name as the object id column in + the root class table. Future versions of ODB will add support + for customiz)HY(ing)YH( these extra columns.)EP( + + )0 P(The sample database schema for the above poly)HY(mor)HY(phic)YH( hier)HY(ar)HY(chy)YH( + is shown below.)EP( + + ) 23 57 PR(CREATE TABLE person \201 + id BIGINT UNSIGNED NOT NULL PRIMARY KEY AUTO_INCREMENT, + typeid VARCHAR\201255\202 NOT NULL, + first TEXT NOT NULL, + last TEXT NOT NULL\202; + +CREATE TABLE employee \201 + id BIGINT UNSIGNED NOT NULL PRIMARY KEY, + temporary TINYINT\2011\202 NOT NULL, + + CONSTRAINT employee_id_fk + FOREIGN KEY \201id\202 + REFERENCES person \201id\202 + ON DELETE CASCADE\202; + +CREATE TABLE contractor \201 + id BIGINT UNSIGNED NOT NULL PRIMARY KEY, + email TEXT NOT NULL, + + CONSTRAINT contractor_id_fk + FOREIGN KEY \201id\202 + REFERENCES person \201id\202 + ON DELETE CASCADE\202;)RP( + + )0 P(The complete version of the code presented in this section is + avail)HY(able)YH( in the )SM(inher)HY(i)HY(tance)YH(/poly)HY(mor)HY(phism)YH()ES( example + in the )SM(odb-exam)HY(ples)YH()ES( package.)EP( + + )0 3 68 H(8.2.1)WB 393 Sn()WB 72 Sn( Perfor)HY(mance)YH( and Limi)HY(ta)HY(tions)YH()EA()EH( + + )0 P(A database oper)HY(a)HY(tion)YH( on a non-poly)HY(mor)HY(phic)YH( object normally trans)HY(lates)YH( + to a single database state)HY(ment)YH( execu)HY(tion)YH( \201objects with contain)HY(ers)YH( + and eager object point)HY(ers)YH( can be the excep)HY(tion)YH(\202. Because poly)HY(mor)HY(phic)YH( + objects have their data members + stored in multi)HY(ple)YH( tables, some database oper)HY(a)HY(tions)YH( on such objects + may result in multi)HY(ple)YH( database state)HY(ments)YH( being executed while others + may require more complex state)HY(ments)YH(. There is also some func)HY(tion)HY(al)HY(ity)YH( + that is not avail)HY(able)YH( to poly)HY(mor)HY(phic)YH( objects.)EP( + + )0 P(The first part of this section discusses the perfor)HY(mance)YH( impli)HY(ca)HY(tions)YH( + to keep in mind when design)HY(ing)YH( and working with poly)HY(mor)HY(phic)YH( hier)HY(ar)HY(chies)YH(. + The second part talks about limi)HY(ta)HY(tions)YH( of poly)HY(mor)HY(phic)YH( objects.)EP( + + )0 P(The most impor)HY(tant)YH( aspect of a poly)HY(mor)HY(phic)YH( hier)HY(ar)HY(chy)YH( that + affects database perfor)HY(mance)YH( is its depth. The distance between + the root of the hier)HY(ar)HY(chy)YH( and the derived class trans)HY(lates)YH( + directly to the number of database state)HY(ments)YH( that will have to + be executed in order to persist, update, or erase this derived class. + It also trans)HY(lates)YH( directly to the number of SQL )SM(JOIN)ES( + clauses that will be needed to load or query the database for this + derived class. As a result, to achieve best perfor)HY(mance)YH(, we should + try to keep our poly)HY(mor)HY(phic)YH( hier)HY(ar)HY(chies)YH( as flat as possi)HY(ble)YH(.)EP( + + )0 P(When loading an object or query)HY(ing)YH( the database for objects, + ODB will need to execute two state)HY(ments)YH( if this object's static + and dynamic types are differ)HY(ent)YH( but only one state)HY(ment)YH( if + they are the same. This example will help illus)HY(trate)YH( the + differ)HY(ence)YH(:)EP( + + ) 18 61 PR(unsigned long id; + +{ + employee e \201...\202; + + transaction t \201db.begin \201\202\202; + id = db.persist \201e\202; + t.commit \201\202; +} + +{ + shared_ptr p; + + transaction t \201db.begin \201\202\202; + p = db.load \201id\202; // Requires two statement. + p = db.load \201id\202; // Requires only one statement. + t.commit \201\202; +})RP( + + )0 P(As a result, we should try to load and query using the most + derived class possi)HY(ble)YH(.)EP( + + )0 P(Finally, for poly)HY(mor)HY(phic)YH( objects, erasing via the object instance + is faster than erasing via its object id. In the former case the + object's dynamic type can be deter)HY(mined)YH( locally in the appli)HY(ca)HY(tion)YH( + while in the latter case an extra state)HY(ment)YH( has to be executed to + achieve the same result. For example:)EP( + + ) 6 65 PR(shared_ptr p = ...; + +transaction t \201db.begin \201\202\202; +db.erase \201p.id \201\202\202; // Slower \201executes extra statement\202. +db.erase \201p\202; // Faster. +t.commit \201\202;)RP( + + )0 P(Poly)HY(mor)HY(phic)YH( objects can use all the mech)HY(a)HY(nisms)YH( that are avail)HY(able)YH( + to ordi)HY(nary)YH( objects. These include contain)HY(ers)YH( \201)0 45 1 A(Chapter 5, + "Contain)HY(ers)YH(")45 0 TN TL()Ec /AF f D(\202, object rela)HY(tion)HY(ships)YH(, includ)HY(ing)YH( to poly)HY(mor)HY(phic)YH( + objects \201)0 52 1 A(Chapter 6, "Rela)HY(tion)HY(ships)YH(")52 0 TN TL()Ec /AF f D(\202, views + \201)0 79 1 A(Chapter 10, "Views")79 0 TN TL()Ec /AF f D(\202, session \201)0 87 1 A(Chapter + 11, "Session")87 0 TN TL()Ec /AF f D(\202, and opti)HY(mistic)YH( concur)HY(rency)YH( \201)0 90 1 A(Chapter + 12, "Opti)HY(mistic)YH( Concur)HY(rency)YH(")90 0 TN TL()Ec /AF f D(\202. There are, however, a few + limi)HY(ta)HY(tions)YH(, mainly due to the under)HY(ly)HY(ing)YH( use of SQL to access the + data.)EP( + + )0 P(When a poly)HY(mor)HY(phic)YH( object is "joined" in a view, and the join + condi)HY(tion)YH( \201either in the form of an object pointer or a custom + condi)HY(tion)YH(\202 comes from the object itself \201as opposed to one of + the objects joined previ)HY(ously)YH(\202, then this condi)HY(tion)YH( must only + use data members from the derived class. For example, consider + the follow)HY(ing)YH( poly)HY(mor)HY(phic)YH( object hier)HY(ar)HY(chy)YH( and a view:)EP( + + + ) 32 56 PR(#pragma db object polymorphic +class employee +{ + ... +}; + +#pragma db object +class permanent_employee: public employee +{ + ... +}; + +#pragma db object +class temporary_employee: public employee +{ + ... + + shared_ptr manager_; +}; + +#pragma db object +class contractor: public temporary_employee +{ + shared_ptr manager_; +}; + +#pragma db view object\201permanent_employee\202 \200 + object\201contractor: contractor::manager_\202 +struct contractor_manager +{ + ...)WR( +};)RP( + + )0 P(This view will not func)HY(tion)YH( correctly because the join condi)HY(tion)YH( + \201)SM(manager_)ES(\202 comes from the base class + \201)SM(tempo)HY(rary)YH(_employee)ES(\202 instead of the derived + \201)SM(contrac)HY(tor)YH()ES(\202. The reason for this limi)HY(ta)HY(tion)YH( is the + )SM(JOIN)ES( clause order in the under)HY(ly)HY(ing)YH( SQL )SM(SELECT)ES( + state)HY(ment)YH(. In the view presented above, the table corre)HY(spond)HY(ing)YH( + to the base class \201)SM(tempo)HY(rary)YH(_employee)ES(\202 will have to + be joined first which will result in this view match)HY(ing)YH( both + the )SM(tempo)HY(rary)YH(_employee)ES( and )SM(contrac)HY(tor)YH()ES( + objects instead of just )SM(contrac)HY(tor)YH()ES(. It is usually + possi)HY(ble)YH( to resolve this issue by reorder)HY(ing)YH( the objects in the + view. Our example, for instance, can be fixed by swap)HY(ping)YH( the + two objects:)EP( + + ) 6 64 PR(#pragma db view object\201contractor\202 \200 + object\201permanent_employee: contractor::manager_\202 +struct contractor_manager +{ + ... +};)RP( + + )0 P(The )SM(erase_query\201\202)ES( database func)HY(tion)YH( \201)0 34 1 A(Section + 3.11, "Delet)HY(ing)YH( Persis)HY(tent)YH( Objects")34 0 TN TL()Ec /AF f D(\202 also has limited func)HY(tion)HY(al)HY(ity)YH( + when used on poly)HY(mor)HY(phic)YH( objects. Because many database imple)HY(men)HY(ta)HY(tions)YH( + do not support )SM(JOIN)ES( clauses in the SQL )SM(DELETE)ES( + state)HY(ment)YH(, only data members from the derived class being erased can + be used in the query condi)HY(tion)YH(. For example:)EP( + + ) 6 58 PR(typedef odb::query query; + +transaction t \201db.begin \201\202\202; +db.erase_query \201query::permanent\202; // Ok. +db.erase_query \201query::last == "Doe"\202; // Error. +t.commit \201\202;)RP( + + )0 2 69 H(8.3)WB 394 Sn()WB 73 Sn( Mixed Inher)HY(i)HY(tance)YH()EA()EH( + + )0 P(It is possi)HY(ble)YH( to mix the reuse and poly)HY(mor)HY(phism)YH( inher)HY(i)HY(tance)YH( + styles in the same hier)HY(ar)HY(chy)YH(. In this case, the reuse inher)HY(i)HY(tance)YH( + must be used for the "bottom" \201base\202 part of the hier)HY(ar)HY(chy)YH( while + the poly)HY(mor)HY(phism)YH( inher)HY(i)HY(tance)YH( \236 for the "top" \201derived\202 part. + For example:)EP( + + ) 23 70 PR(#pragma db object +class person +{ + ... +}; + +#pragma db object polymorphic +class employee: public person // Reuse inheritance. +{ + ... +}; + +#pragma db object +class temporary_employee: public employee // Polymorphism inheritance. +{ + ... +}; + +#pragma db object +class permanent_employee: public employee // Polymorphism inheritance. +{ + ... +};)RP( + + + + + + )WB NL NP( + )0 1 70 H(9)WB 395 Sn()WB 74 Sn( Sections)EA()EH( + + )0 P(ODB sections are an opti)HY(miza)HY(tion)YH( mech)HY(a)HY(nism)YH( that allows us to + parti)HY(tion)YH( data members of a persis)HY(tent)YH( class into groups that + can be sepa)HY(rately)YH( loaded and/or updated. This can be useful, + for example, if an object contains expen)HY(sive)YH( to load or update + data members \201such as )SM(BLOB)ES(s or contain)HY(ers)YH(\202 and + that are accessed or modi)HY(fied)YH( infre)HY(quently)YH(. For example:)EP( + + ) 36 67 PR(#include + +#pragma db object +class person +{ + ... + + #pragma db load\201lazy\202 update\201manual\202 + odb::section keys_; + + #pragma db section\201keys_\202 type\201"BLOB"\202 + char public_key_[1024]; + + #pragma db section\201keys_\202 type\201"BLOB"\202 + char private_key_[1024]; +}; + +transaction t \201db.begin \201\202\202; + +auto_ptr p \201db.load \201...\202\202; // Keys are not loaded. + +if \201need_keys\202 +{ + db.load \201*p, p->keys_\202; // Load keys. + ... +} + +db.update \201*p\202; // Keys are not updated. + +if \201update_keys\202 +{)WR( + ... + db.update \201*p, p->keys_\202; // Update keys. +} + +t.commit \201\202;)RP( + + )0 P(A complete example that shows how to use sections is avail)HY(able)YH( in + the )SM(section)ES( direc)HY(tory)YH( in the )SM(odb-exam)HY(ples)YH()ES( + package.)EP( + + )0 P(Why do we need to group data members into sections? Why can't + each data member be loaded and updated inde)HY(pen)HY(dently)YH( if and + when neces)HY(sary)YH(? The reason for this require)HY(ment)YH( is that loading + or updat)HY(ing)YH( a group of data members with a single database + state)HY(ment)YH( is signif)HY(i)HY(cantly)YH( more effi)HY(cient)YH( than loading or updat)HY(ing)YH( + each data member with a sepa)HY(rate)YH( state)HY(ment)YH(. Because ODB + prepares and caches state)HY(ments)YH( used to load and update + persis)HY(tent)YH( objects, gener)HY(at)HY(ing)YH( a custom state)HY(ment)YH( for + a specific set of data members that need to be loaded or + updated together is not a viable approach either. To resolve + this, ODB allows us to group data members that are + often updated and/or loaded together into sections. To + achieve the best perfor)HY(mance)YH(, we should aim to find a balance + between having too many sections with too few data + members and too few sections with too many data + members. We can use the access and modi)HY(fi)HY(ca)HY(tion)YH( patterns + of our appli)HY(ca)HY(tion)YH( as a base for this deci)HY(sion)YH(.)EP( + + )0 P(To add a new section to a persis)HY(tent)YH( class we declare a new + data member of the )SM(odb::section)ES( type. At this + point we also need to specify the loading and updat)HY(ing)YH( behav)HY(ior)YH( + of this section with the )SM(db\240load)ES( and + )SM(db\240update)ES( pragmas, respec)HY(tively)YH(.)EP( + + )0 P(The loading behav)HY(ior)YH( of a section can be either )SM(eager)ES( + or )SM(lazy)ES(. An eager-loaded section is always loaded as + part of the object load. A lazy-loaded section is not loaded + as part of the object load and has to be explic)HY(itly)YH( loaded with + the )SM(database::load\201\202)ES( func)HY(tion)YH( \201discussed below\202 if + and when neces)HY(sary)YH(.)EP( + + )0 P(The updat)HY(ing)YH( behav)HY(ior)YH( of a section can be )SM(always)ES(, + )SM(change)ES(, or )SM(manual)ES(. An always-updated + section is always updated as part of the object update, + provided it has been loaded. A change-updated section + is only updated as part of the object update if it has been loaded + and marked as changed. A manu)HY(ally)YH(-updated section is never updated + as part of the object update and has to be explic)HY(itly)YH( updated with + the )SM(database::update\201\202)ES( func)HY(tion)YH( \201discussed below\202 if + and when neces)HY(sary)YH(.)EP( + + )0 P(If no loading behav)HY(ior)YH( is spec)HY(i)HY(fied)YH( explic)HY(itly)YH(, then an eager-loaded + section is assumed. Simi)HY(larly)YH(, if no updat)HY(ing)YH( behav)HY(ior)YH( is spec)HY(i)HY(fied)YH(, + then an always-updated section is assumed. An eager-loaded, always-updated + section is point)HY(less)YH( and there)HY(fore)YH( illegal. Only persis)HY(tent)YH( classes + with an object id can have sections.)EP( + + )0 P(To specify that a data member belongs to a section we use the + )SM(db\240section)ES( pragma with the section's member + name as its single argu)HY(ment)YH(. Except for special data members + such as the object id and opti)HY(mistic)YH( concur)HY(rency)YH( version, any + direct, non-tran)HY(sient)YH( member of a persis)HY(tent)YH( class can belong + to a section, includ)HY(ing)YH( compos)HY(ite)YH( values, contain)HY(ers)YH(, and + point)HY(ers)YH( to objects. For example:)EP( + + ) 24 45 PR(#pragma db value +class text +{ + std::string data; + std::string lang; +}; + +#pragma db object +class person +{ + ... + + #pragma db load\201lazy\202 + odb::section extras_; + + #pragma db section\201extras_\202 + text bio_; + + #pragma db section\201extras_\202 + std::vector nicknames_; + + #pragma db section\201extras_\202 + std::shared_ptr emergency_contact_; +};)RP( + + )0 P(An empty section is point)HY(less)YH( and there)HY(fore)YH( illegal, except + in abstract or poly)HY(mor)HY(phic)YH( classes where data members can be + added to a section by derived classes \201see )0 75 1 A(Section + 9.1, "Sections and Inher)HY(i)HY(tance)YH(")75 0 TN TL()Ec /AF f D(\202.)EP( + + )0 P(The )SM(odb::section)ES( class is defined in the + )SM()ES( header file and has the + follow)HY(ing)YH( inter)HY(face)YH(:)EP( + + ) 30 30 PR(namespace odb +{ + class section + { + public: + // Load state. + // + bool + loaded \201\202 const; + + void + unload \201\202; + + // Change state. + // + bool + changed \201\202 const; + + void + change \201\202; + + // User data. + // + unsigned char + user_data \201\202 const; + + void + user_data \201unsigned char\202; + }; +})RP( + + )0 P(The )SM(loaded\201\202)ES( acces)HY(sor)YH( can be used to deter)HY(mine)YH( + whether a section is already loaded. The )SM(unload\201\202)ES( + modi)HY(fier)YH( marks a loaded section as not loaded. This, for example, + can be useful if you don't want the section to be reloaded during + the object reload.)EP( + + )0 P(The )SM(changed\201\202)ES( acces)HY(sor)YH( can be used to query the + section's change state. The )SM(change\201\202)ES( modi)HY(fier)YH( + marks the section as changed. It is valid to call this modi)HY(fier)YH( + for an unloaded \201or tran)HY(sient)YH(\202 section, however, the state will + be reset back to unchanged once the section \201or object\202 is loaded. + The change state is only rele)HY(vant)YH( to sections with change-updated + behav)HY(ior)YH( and is ignored for all other sections.)EP( + + )0 P(The size of the section class is one byte with four bits avail)HY(able)YH( + to store a custom state via the )SM(user_data\201\202)ES( acces)HY(sor)YH( + and modi)HY(fier)YH(.)EP( + + )0 P(The )SM(odb::database)ES( class provides special + versions of the )SM(load\201\202)ES( and )SM(update\201\202)ES( + func)HY(tions)YH( that allow us to load and update sections of a + persis)HY(tent)YH( class. Their signa)HY(tures)YH( are as follows:)EP( + + ) 7 43 PR( template + void + load \201T& object, section&\202; + + template + void + update \201const T& object, const section&\202;)RP( + + )0 P(Before calling the section )SM(load\201\202)ES( func)HY(tion)YH(, the + object itself must already be loaded. If the section is already + loaded, then the call to )SM(load\201\202)ES( will reload its + data members. It is illegal to explic)HY(itly)YH( load an eager-loaded + section.)EP( + + )0 P(Before calling the section )SM(update\201\202)ES( func)HY(tion)YH(, the + section \201and there)HY(fore)YH( the object\202 must be in the loaded state. + If the section is not loaded, the )SM(odb::section_not_loaded)ES( + excep)HY(tion)YH( is thrown. The section )SM(update\201\202)ES( func)HY(tion)YH( + does not check but does clear the section's change state. In + other words, section )SM(update\201\202)ES( will always update + section data members in the database and clear the change flag. + Note also that any section, that is, always-, change-, or + manu)HY(ally)YH(-updated, can be explic)HY(itly)YH( updated with this func)HY(tion)YH(.)EP( + + )0 P(Both section )SM(load\201\202)ES( and )SM(update\201\202)ES(, just + like the rest of the database oper)HY(a)HY(tions)YH(, must be performed within + a trans)HY(ac)HY(tion)YH(. Notice also that both )SM(load\201\202)ES( and + )SM(update\201\202)ES( expect a refer)HY(ence)YH( to the section as + their second argu)HY(ment)YH(. This refer)HY(ence)YH( must refer to the data + member in the object passed as the first argu)HY(ment)YH(. If instead + it refers to some other instance of the )SM(section)ES( + class, for example, a local copy or a tempo)HY(rary)YH(, then the + )SM(odb::section_not_in_object)ES( excep)HY(tion)YH( is thrown. + For example:)EP( + + ) 21 65 PR(#pragma db object +class person +{ +public: + ... + + odb::section + keys \201\202 const {return keys_;} + +private: + odb::section keys_; + + ... +}; + +auto_ptr p \201db.load \201...\202\202; + +section s \201p->keys \201\202\202; +db.load \201*p, s\202; // Throw section_not_in_object, copy. + +db.update \201*p, p->keys \201\202\202; // Throw section_not_in_object, copy.)RP( + + )0 P(At first glance it may seem more appro)HY(pri)HY(ate)YH( to make the + )SM(section)ES( class non-copy)HY(able)YH( in order to prevent + such errors from happen)HY(ing)YH(. However, it is perfectly reason)HY(able)YH( + to expect to be able to copy \201or assign\202 sections as part of + the object copying \201or assign)HY(ment)YH(\202. As a result, sections are + left copy)HY(able)YH( and copy-assignable, however, this func)HY(tion)HY(al)HY(ity)YH( + should not be used in acces)HY(sors)YH( or modi)HY(fiers)YH(. Instead, section + acces)HY(sors)YH( and modi)HY(fiers)YH( should always be by-refer)HY(ence)YH(. Here is + how we can fix our previ)HY(ous)YH( example:)EP( + +) 24 45 PR(#pragma db object +class person +{ +public: + ... + + const odb::section& + keys \201\202 const {return keys_;} + + odb::section& + keys \201\202 {return keys_;} + +private: + odb::section keys_; + + ... +}; + +auto_ptr p \201db.load \201...\202\202; + +section& s \201p->keys \201\202\202; +db.load \201*p, s\202; // Ok, reference. + +db.update \201*p, p->keys \201\202\202; // Ok, reference.)RP( + + )0 P(Several other database oper)HY(a)HY(tions)YH( affect sections. The state of + a section in a tran)HY(sient)YH( object is unde)HY(fined)YH(. That is, before + the call to object )SM(persist\201\202)ES( or )SM(load\201\202)ES( + func)HY(tions)YH(, or after the call to object )SM(erase\201\202)ES( + func)HY(tion)YH(, the values returned by the )SM(section::loaded\201\202)ES( and + )SM(section::changed\201\202)ES( acces)HY(sors)YH( are unde)HY(fined)YH(.)EP( + + )0 P(After the call to )SM(persist\201\202)ES(, all sections, includ)HY(ing)YH( + eager-loaded ones, are marked as loaded and unchanged. If instead we + are loading an object with the )SM(load\201\202)ES( call or as + a result of a query, then eager-loaded sections are loaded + and marked as loaded and unchanged while lazy-loaded ones are marked + as unloaded. If a lazy-loaded section is later loaded with the + section )SM(load\201\202)ES( call, then it is marked as loaded and + unchanged.)EP( + + )0 P(When we update an object with the )SM(update\201\202)ES( call, + manu)HY(ally)YH(-updated sections are ignored while always-updated + sections are updated if they are loaded. Change-updated + sections are only updated if they are both loaded and marked + as changed. After the update, such sections are reset to the + unchanged state. When we reload an object with the + )SM(reload\201\202)ES( call, sections that were loaded are + auto)HY(mat)HY(i)HY(cally)YH( reloaded and reset to the unchanged state.)EP( + + )0 P(To further illus)HY(trate)YH( the state tran)HY(si)HY(tions)YH( of a section, + consider this example:)EP( + + ) 38 72 PR(#pragma db object +class person +{ + ... + + #pragma db load\201lazy\202 update\201change\202 + odb::section keys_; + + ... +}; + +transaction t \201db.begin \201\202\202; + +person p \201"John", "Doe"\202; // Section state is undefined \201transient\202. + +db.persist \201p\202; // Section state: loaded, unchanged. + +auto_ptr l \201 + db.load \201...\202\202; // Section state: unloaded, unchanged. + +db.update \201*l\202; // Section not updated since not loaded. +db.update \201p\202; // Section not updated since not changed. + +p.keys_.change \201\202; // Section state: loaded, changed. +db.update \201p\202; // Section updated, state: loaded, unchanged. + +db.update \201*l, l->keys_\202; // Throw section_not_loaded. +db.update \201p, p.keys_\202; // Section updated even though not changed. + +db.reload \201*l\202; // Section not reloaded since not loaded. +db.reload \201p\202; // Section reloaded, state: loaded, unchanged.)WR( + +db.load \201*l, l->keys_\202; // Section loaded, state: loaded, unchanged. +db.load \201p, p.keys_\202; // Section reloaded, state: loaded, unchanged. + +db.erase \201p\202; // Section state is undefined \201transient\202. + +t.commit \201\202;)RP( + + )0 P(When using change-updated behav)HY(ior)YH(, it is our respon)HY(si)HY(bil)HY(ity)YH( to + mark the section as changed when any of the data members belong)HY(ing)YH( + to this section is modi)HY(fied)YH(. A natural place to mark the section + as changed is the modi)HY(fiers)YH( for section data members, for example:)EP( + + ) 39 45 PR(#pragma db object +class person +{ + ... + + typedef std::array key_type; + + const key_type& + public_key \201\202 const {return public_key_;} + + void + public_key \201const key_type& k\202 + { + public_key_ = k; + keys_.change \201\202; + } + + const key_type& + private_key \201\202 const {return private_key_;} + + void + private_key \201const key_type& k\202 + { + private_key_ = k; + keys_.change \201\202; + } + +private: + #pragma db load\201lazy\202 update\201change\202 + odb::section keys_; +)WR( + #pragma db section\201keys_\202 type\201"BLOB"\202 + key_type public_key_; + + #pragma db section\201keys_\202 type\201"BLOB"\202 + key_type private_key_; + + ... +};)RP( + + )0 P(One inter)HY(est)HY(ing)YH( aspect of change-updated sections is what happens + when a trans)HY(ac)HY(tion)YH( that performed an object or section update is + later rolled back. In this case, while the change state of a + section has been reset \201after update\202, actual changes were not + commit)HY(ted)YH( to the database. Change-updated sections handle this + case by auto)HY(mat)HY(i)HY(cally)YH( regis)HY(ter)HY(ing)YH( a roll)HY(back)YH( call)HY(back)YH( and then, + if it is called, restor)HY(ing)YH( the orig)HY(i)HY(nal)YH( change state. The + follow)HY(ing)YH( code illus)HY(trates)YH( this seman)HY(tics)YH( \201contin)HY(u)HY(ing)YH( with + the previ)HY(ous)YH( example\202:)EP( + + ) 18 65 PR(auto_ptr p; + +try +{ + transaction t \201db.begin \201\202\202; + p = db.load \201...\202; + db.load \201*p, p->keys_\202; + + p->private_key \201new_key\202; // The section is marked changed. + db.update \201*p\202; // The section is reset to unchanged. + + throw failed \201\202; // Triggers rollback. + t.commit \201\202; +} +catch \201const failed&\202 +{ + // The section is restored back to changed. +})RP( + + + )0 2 71 H(9.1)WB 396 Sn()WB 75 Sn( Sections and Inher)HY(i)HY(tance)YH()EA()EH( + + )0 P(With both reuse and poly)HY(mor)HY(phism)YH( inher)HY(i)HY(tance)YH( \201)0 69 1 A(Chapter 8, + "Inher)HY(i)HY(tance)YH(")69 0 TN TL()Ec /AF f D(\202 it is possi)HY(ble)YH( to add new sections to derived + classes. It is also possi)HY(ble)YH( to add data members from derived + classes to sections declared in the base. For example:)EP( + + ) 34 66 PR(#pragma db object polymorphic +class person +{ + ... + + virtual void + print \201\202; + + #pragma db load\201lazy\202 + odb::section print_; + + #pragma db section\201print_\202 + std::string bio_; +}; + +#pragma db object +class employee: public person +{ + ... + + virtual void + print \201\202; + + #pragma db section\201print_\202 + std::vector employment_history_; +}; + +transaction t \201db.begin \201\202\202; + +auto_ptr p \201db.load \201...\202\202; // Person or employee. +db.load \201*p, p->print_\202; // Load data members needed for print.)WR( +p->print \201\202; + +t.commit \201\202;)RP( + + )0 P(When data members of a section are spread over several classes in a + reuse inher)HY(i)HY(tance)YH( hier)HY(ar)HY(chy)YH(, both section load and update are + performed with a single database state)HY(ment)YH(. In contrast, with + poly)HY(mor)HY(phism)YH( inher)HY(i)HY(tance)YH(, section load is performed with a + single state)HY(ment)YH( while update requires a sepa)HY(rate)YH( state)HY(ment)YH( + for each class that adds to the section.)EP( + + )0 P(Note also that in poly)HY(mor)HY(phism)YH( inher)HY(i)HY(tance)YH( the section-to-object + asso)HY(ci)HY(a)HY(tion)YH( is static. Or, in other words, you can load a section + via an object only if its static type actu)HY(ally)YH( contains this + section. The follow)HY(ing)YH( example will help illus)HY(trate)YH( this + point further:)EP( + + ) 31 51 PR(#pragma db object polymorphic +class person +{ + ... +}; + +#pragma db object +class employee: public person +{ + ... + + #pragma db load\201lazy\202 + odb::section extras_; + + ... +}; + +#pragma db object +class manager: public employee +{ + ... +}; + +auto_ptr m \201db.load \201...\202\202; + +person& p \201*m\202; +employee& e \201*m\202; +section& s \201m->extras_\202; + +db.load \201p, s\202; // Error: extras_ is not in person. +db.load \201e, s\202; // Ok: extras_ is in employee.)WR()RP( + + )0 2 72 H(9.2)WB 397 Sn()WB 76 Sn( Sections and Opti)HY(mistic)YH( Concur)HY(rency)YH()EA()EH( + + )0 P(When sections are used in a class with the opti)HY(mistic)YH( concur)HY(rency)YH( + model \201)0 90 1 A(Chapter 12, "Opti)HY(mistic)YH( Concur)HY(rency)YH(")90 0 TN TL()Ec /AF f D(\202, + both section update and load oper)HY(a)HY(tions)YH( compare the object version + to that in the database and throw the )SM(odb::object_changed)ES( + excep)HY(tion)YH( if they do not match. In addi)HY(tion)YH(, the section update + oper)HY(a)HY(tion)YH( incre)HY(ments)YH( the version to indi)HY(cate)YH( that the object state + has changed. For example:)EP( + + ) 38 68 PR(#pragma db object optimistic +class person +{ + ... + + #pragma db version + unsigned long long version_; + + #pragma db load\201lazy\202 + odb::section extras_; + + #pragma db section\201extras_\202 + std::string bio_; +}; + +auto_ptr p; + +{ + transaction t \201db.begin \201\202\202; + p = db.load \201...\202; + t.commit \201\202; +} + +{ + transaction t \201db.begin \201\202\202; + + try + { + db.load \201*p, p->extras_\202; // Throws if object state has changed. + } + catch \201const object_changed&\202)WR( + { + db.reload \201*p\202; + db.load \201*p, p->extras_\202; // Cannot fail. + } + + t.commit \201\202; +})RP( + + )0 P(Note also that if an object update trig)HY(gers)YH( one or more + section updates, then each such update will incre)HY(ment)YH( the + object version. As a result, an update of an object that + contains sections may result in a version incre)HY(ment)YH( by + more than one.)EP( + + )0 P(When sections are used together with opti)HY(mistic)YH( concur)HY(rency)YH( and + inher)HY(i)HY(tance)YH(, an extra step may be required to enable this + func)HY(tion)HY(al)HY(ity)YH(. If you plan to add new sections to derived + classes, then the root class of the hier)HY(ar)HY(chy)YH( + \201the one that declares the version data member\202 must be + declared as section)HY(able)YH( with the )SM(db\240section)HY(able)YH()ES( + pragma. For example:)EP( + + ) 20 47 PR(#pragma db object polymorphic sectionable +class person +{ + ... + + #pragma db version + unsigned long long version_; +}; + +#pragma db object +class employee: public person +{ + ... + + #pragma db load\201lazy\202 + odb::section extras_; + + #pragma db section\201extras_\202 + std::vector employment_history_; +};)RP( + + )0 P(This require)HY(ment)YH( has to do with the need to gener)HY(ate)YH( extra + version incre)HY(ment)YH( code in the root class that will be used + by sections added in the derived classes. If you forget to + declare the root class as section)HY(able)YH( and later add a + section to one of the derived classes, the ODB compiler + will issue diag)HY(nos)HY(tics)YH(.)EP( + + )0 2 73 H(9.3)WB 398 Sn()WB 77 Sn( Sections and Lazy Point)HY(ers)YH()EA()EH( + + )0 P(If a lazy pointer \201)0 61 1 A(Section 6.4, "Lazy Point)HY(ers)YH(")61 0 TN TL()Ec /AF f D(\202 + belongs to a lazy-loaded section, then we end up with two levels of + lazy loading. Specif)HY(i)HY(cally)YH(, when the section is loaded, the lazy + pointer is initial)HY(ized)YH( with the object id but the object itself + is not loaded. For example:)EP( + + ) 21 69 PR(#pragma db object +class employee +{ + ... + + #pragma db load\201lazy\202 + odb::section extras_; + + #pragma db section\201extras_\202 + odb::lazy_shared_ptr employer_; +}; + +transaction t \201db.begin \201\202\202; + +auto_ptr e \201db.load \201...\202\202; // employer_ is NULL. + +db.load \201*e, e->extras_\202; // employer_ contains valid employer id. + +e->employer_.load \201\202; // employer_ points to employer object. + +t.commit \201\202;)RP( + + )0 2 74 H(9.4)WB 399 Sn()WB 78 Sn( Sections and Change-Track)HY(ing)YH( Contain)HY(ers)YH()EA()EH( + + )0 P(If a change-track)HY(ing)YH( container \201)0 49 1 A(Section 5.4, + "Change-Track)HY(ing)YH( Contain)HY(ers)YH(")49 0 TN TL()Ec /AF f D(\202 belongs to a change-updated + section, then prior to an object update ODB will check if the + container has been changed and if so, auto)HY(mat)HY(i)HY(cally)YH( mark the + section as changed. For example:)EP( + +) 22 56 PR(#pragma db object +class person +{ + ... + + #pragma db load\201lazy\202 update\201change\202 + odb::section extras_; + + #pragma db section\201extras_\202 + odb::vector nicknames_; +}; + +transaction t \201db.begin \201\202\202; + +auto_ptr p \201db.load \201...\202\202; +db.load \201*p, p->extras_\202; + +p->nicknames_.push_back \201"JD"\202; + +db.update \201*p\202; // Section is automatically updated even + // though it was not marked as changed. +t.commit \201\202;)RP( + + + + + + )WB NL NP( + )0 1 75 H(10)WB 400 Sn()WB 79 Sn( Views)EA()EH( + + )0 P(An ODB view is a C++ )SM(class)ES( or )SM(struct)ES( type + that embod)HY(ies)YH( a light-weight, read-only projec)HY(tion)YH( of one or more + persis)HY(tent)YH( objects or database tables or the result of a native SQL + query execu)HY(tion)YH(.)EP( + + )0 P(Some of the common appli)HY(ca)HY(tions)YH( of views include loading a subset + of data members from objects or columns from database tables, execut)HY(ing)YH( + and handling results of arbi)HY(trary)YH( SQL queries, includ)HY(ing)YH( aggre)HY(gate)YH( + queries and stored proce)HY(dure)YH( calls, as well as joining multi)HY(ple)YH( + objects and/or database tables using object rela)HY(tion)HY(ships)YH( or custom + join condi)HY(tions)YH(.)EP( + + )0 P(Many rela)HY(tional)YH( databases also define the concept of views. Note, + however, that ODB views are not mapped to database views. Rather, + by default, an ODB view is mapped to an SQL )SM(SELECT)ES( + query. However, if desired, it is easy to create an ODB view + that is based on a database view.)EP( + + )0 P(Usually, views are defined in terms of other persis)HY(tent)YH( enti)HY(ties)YH(, + such as persis)HY(tent)YH( objects, database tables, sequences, etc. + There)HY(fore)YH(, before we can examine our first view, we need to + define a few persis)HY(tent)YH( objects and a database table. We will + use this model in exam)HY(ples)YH( through)HY(out)YH( this chapter. Here we + assume that you are famil)HY(iar)YH( with ODB object rela)HY(tion)HY(ship)YH( + support \201)0 52 1 A(Chapter 6, "Rela)HY(tion)HY(ships)YH(")52 0 TN TL()Ec /AF f D(\202.)EP( + + ) 40 50 PR(#pragma db object +class country +{ + ... + + #pragma db id + std::string code_; // ISO 2-letter country code. + + std::string name_; +}; + +#pragma db object +class employer +{ + ... + + #pragma db id + unsigned long id_; + + std::string name_; +}; + +#pragma db object +class employee +{ + ... + + #pragma db id + unsigned long id_; + + std::string first_;)WR( + std::string last_; + + unsigned short age_; + + shared_ptr residence_; + shared_ptr nationality_; + + shared_ptr employed_by_; +};)RP( + + )0 P(Besides these objects, we also have the legacy + )SM(employee_extra)ES( table that is not mapped to any persis)HY(tent)YH( + class. It has the follow)HY(ing)YH( defi)HY(ni)HY(tion)YH(:)EP( + + ) 4 33 PR(CREATE TABLE employee_extra\201 + employee_id INTEGER NOT NULL, + vacation_days INTEGER NOT NULL, + previous_employer_id INTEGER\202)RP( + + )0 P(The above persis)HY(tent)YH( objects and database table as well as many of + the views shown in this chapter are based on the + )SM(view)ES( example which can be found in the + )SM(odb-exam)HY(ples)YH()ES( package of the ODB distri)HY(bu)HY(tion)YH(.)EP( + + )0 P(To declare a view we use the )SM(db\240view)ES( pragma, + for example:)EP( + + ) 6 32 PR(#pragma db view object\201employee\202 +struct employee_name +{ + std::string first; + std::string last; +};)RP( + + )0 P(The above example shows one of the simplest views that we can create. + It has a single asso)HY(ci)HY(ated)YH( object \201)SM(employee)ES(\202 and its + purpose is to extract the employee's first and last names without + loading any other data, such as the refer)HY(enced)YH( )SM(country)ES( + and )SM(employer)ES( objects.)EP( + + )0 P(Views use the same query facil)HY(ity)YH( \201)0 38 1 A(Chapter 4, "Query)HY(ing)YH( + the Database")38 0 TN TL()Ec /AF f D(\202 as persis)HY(tent)YH( objects. Because support for queries + is optional and views cannot be used without this support, you need + to compile any header that defines a view with the + )SM(--gener)HY(ate)YH(-query)ES( ODB compiler option.)EP( + + )0 P(To query the database for a view we use the + )SM(database::query\201\202)ES(, )SM(database::query_one\201\202)ES(, or + )SM(database::query_value\201\202)ES( func)HY(tions)YH( in exactly the same way + as we would use them to query the database for an object. For example, + the follow)HY(ing)YH( code frag)HY(ment)YH( shows how we can find the names of all the + employ)HY(ees)YH( that are younger than 31:)EP( + + ) 14 57 PR(typedef odb::query query; +typedef odb::result result; + +transaction t \201db.begin \201\202\202; + +result r \201db.query \201query::age < 31\202\202; + +for \201result::iterator i \201r.begin \201\202\202; i != r.end \201\202; ++i\202 +{ + const employee_name& en \201*i\202; + cout << en.first << " " << en.last << endl; +} + +t.commit \201\202;)RP( + + )0 P(A view can be defined as a projec)HY(tion)YH( of one or more objects, one + or more tables, a combi)HY(na)HY(tion)YH( of objects and tables, or it can be + the result of a custom SQL query. The follow)HY(ing)YH( sections discuss each + of these kinds of view in more detail.)EP( + + )0 2 76 H(10.1)WB 401 Sn()WB 80 Sn( Object Views)EA()EH( + + )0 P(To as)HY(so)HY(ciate)YH( one or more objects with a view we use the + )SM(db\240object)ES( pragma \201)0 118 1 A(Section + 14.2.1, ")SM(object)ES(")118 0 TN TL()Ec /AF f D(\202. We have already seen + a simple, single-object view in the intro)HY(duc)HY(tion)YH( to this chapter. + To as)HY(so)HY(ciate)YH( the second and subse)HY(quent)YH( objects we repeat the + )SM(db\240object)ES( pragma for each addi)HY(tional)YH( object, + for example:)EP( + + ) 7 49 PR(#pragma db view object\201employee\202 object\201employer\202 +struct employee_employer +{ + std::string first; + std::string last; + std::string name; +};)RP( + + )0 P(The complete syntax of the )SM(db\240object)ES( pragma is + shown below:)EP( + + )0 P()SM()BD(object\201)ES()I(name)ES( + [)BD(=)ES( )I(alias)ES(] + [)I(join-type)ES(] + [)BD(:)ES( )I(join-condi)HY(tion)YH()ES(])BD(\202)ES()ES()EP( + + )0 P(The )I(name)ES( part is a poten)HY(tially)YH( qual)HY(i)HY(fied)YH( persis)HY(tent)YH( class + name that has been defined previ)HY(ously)YH(. The optional )I(alias)ES( + part gives this object an alias. If provided, the alias is used + in several contexts instead of the object's unqual)HY(i)HY(fied)YH( name. We + will discuss aliases further as we cover each of these contexts + below. The optional )I(join-type)ES( part spec)HY(i)HY(fies)YH( the way this + object is asso)HY(ci)HY(ated)YH(. It can be )SM(left)ES(, )SM(right)ES(, + )SM(full)ES(, )SM(inner)ES(, and )SM(cross)ES( + with )SM(left)ES( being the default. + Finally, the optional )I(join-condi)HY(tion)YH()ES( part provides the + crite)HY(ria)YH( which should be used to as)HY(so)HY(ciate)YH( this object with any + of the previ)HY(ously)YH( asso)HY(ci)HY(ated)YH( objects or, as we will see in + )0 83 1 A(Section 10.4, "Mixed Views")83 0 TN TL()Ec /AF f D(, tables. Note that + while the first asso)HY(ci)HY(ated)YH( object can have an alias, it cannot + have a join type or condi)HY(tion)YH(.)EP( + + )0 P(For each subse)HY(quent)YH( asso)HY(ci)HY(ated)YH( object the ODB compiler needs + a join condi)HY(tion)YH( and there are several ways to specify + it. The easiest way is to omit it alto)HY(gether)YH( and let the ODB + compiler try to come up with a join condi)HY(tion)YH( auto)HY(mat)HY(i)HY(cally)YH(. + To do this the ODB compiler will examine each previ)HY(ously)YH( + asso)HY(ci)HY(ated)YH( object for object rela)HY(tion)HY(ships)YH( + \201)0 52 1 A(Chapter 6, "Rela)HY(tion)HY(ships)YH(")52 0 TN TL()Ec /AF f D(\202 that + may exist between these objects and the object being asso)HY(ci)HY(ated)YH(. + If such a rela)HY(tion)HY(ship)YH( exists and is unam)HY(bigu)HY(ous)YH(, that is + there is only one such rela)HY(tion)HY(ship)YH(, then the ODB compiler + will auto)HY(mat)HY(i)HY(cally)YH( use it to come up with the join condi)HY(tion)YH( for + this object. This is exactly what happens in the previ)HY(ous)YH( + example: there is a single rela)HY(tion)HY(ship)YH( + \201)SM(employee::employed_by)ES(\202 between the + )SM(employee)ES( and )SM(employer)ES( objects.)EP( + + )0 P(On the other hand, consider this view:)EP( + + ) 7 48 PR(#pragma db view object\201employee\202 object\201country\202 +struct employee_residence +{ + std::string first; + std::string last; + std::string name; +};)RP( + + )0 P(While there is a rela)HY(tion)HY(ship)YH( between )SM(country)ES( and + )SM(employee)ES(, it is ambigu)HY(ous)YH(. It can be + )SM(employee::resi)HY(dence)YH(_)ES( \201which is what we want\202 or + it can be )SM(employee::nation)HY(al)HY(ity)YH(_)ES( \201which we don't + want\202. As result, when compil)HY(ing)YH( the above view, the ODB + compiler will issue an error indi)HY(cat)HY(ing)YH( an ambigu)HY(ous)YH( object + rela)HY(tion)HY(ship)YH(. To resolve this ambi)HY(gu)HY(ity)YH(, we can explic)HY(itly)YH( + specify the object rela)HY(tion)HY(ship)YH( that should be used to create + the join condi)HY(tion)YH( as the name of the corre)HY(spond)HY(ing)YH( data member. + Here is how we can fix the )SM(employee_resi)HY(dence)YH()ES( + view:)EP( + + ) 7 70 PR(#pragma db view object\201employee\202 object\201country: employee::residence_\202 +struct employee_residence +{ + std::string first; + std::string last; + std::string name; +};)RP( + + )0 P(It is possi)HY(ble)YH( to as)HY(so)HY(ciate)YH( the same object with a single view + more than once using differ)HY(ent)YH( join condi)HY(tions)YH(. However, in + this case, we have to use aliases to assign differ)HY(ent)YH( names + for each asso)HY(ci)HY(a)HY(tion)YH(. For example:)EP( + + ) 7 55 PR(#pragma db view object\201employee\202 \200 + object\201country = res_country: employee::residence_\202 \200 + object\201country = nat_country: employee::nationality_\202 +struct employee_country +{ + ... +};)RP( + + )0 P(Note that correctly defin)HY(ing)YH( data members in this view requires + the use of a mech)HY(a)HY(nism)YH( that we haven't yet covered. We will + see how to do this shortly.)EP( + + )0 P(If we assign an alias to an object and refer to a data member of + this object in one of the join condi)HY(tions)YH(, we have to use the + unqual)HY(i)HY(fied)YH( alias name instead of the poten)HY(tially)YH( qual)HY(i)HY(fied)YH( + object name. For example:)EP( + + ) 5 69 PR(#pragma db view object\201employee = ee\202 object\201country: ee::residence_\202 +struct employee_residence +{ + ... +};)RP( + + )0 P(The last way to specify a join condi)HY(tion)YH( is to provide a custom + query expres)HY(sion)YH(. This method is primar)HY(ily)YH( useful if you would + like to as)HY(so)HY(ciate)YH( an object using a condi)HY(tion)YH( that does not + involve an object rela)HY(tion)HY(ship)YH(. Consider, for example, a + modi)HY(fied)YH( )SM(employee)ES( object from the begin)HY(ning)YH( of + the chapter with an added country of birth member. For one + reason or another we have decided not to use a rela)HY(tion)HY(ship)YH( to + the )SM(country)ES( object, as we have done with + resi)HY(dence)YH( and nation)HY(al)HY(ity)YH(.)EP( + + ) 7 44 PR(#pragma db object +class employee +{ + ... + + std::string birth_place_; // Country name. +};)RP( + + )0 P(If we now want to create a view that returns the birth country code + for an employee, then we have to use a custom join condi)HY(tion)YH( when + asso)HY(ci)HY(at)HY(ing)YH( the )SM(country)ES( object. For example:)EP( + + ) 8 59 PR(#pragma db view object\201employee\202 \200 + object\201country: employee::birth_place_ == country::name_\202 +struct employee_birth_code +{ + std::string first; + std::string last; + std::string code; +};)RP( + + )0 P(The syntax of the query expres)HY(sion)YH( in custom join condi)HY(tions)YH( + is the same as in the query facil)HY(ity)YH( used to query the database + for objects \201)0 38 1 A(Chapter 4, "Query)HY(ing)YH( the Database")38 0 TN TL()Ec /AF f D(\202 + except that for query members, instead of using + )SM(odb::query::member)ES( names, we refer directly + to object members.)EP( + + )0 P(Looking at the views we have defined so far, you may be wonder)HY(ing)YH( + how the ODB compiler knows which view data members corre)HY(spond)YH( to which + object data members. While the names are similar, they are not exactly + the same, for example )SM(employee_name::first)ES( and + )SM(employee::first_)ES(.)EP( + + )0 P(As with join condi)HY(tions)YH(, when it comes to asso)HY(ci)HY(at)HY(ing)YH( data members, + the ODB compiler tries to do this auto)HY(mat)HY(i)HY(cally)YH(. It first searches + all the asso)HY(ci)HY(ated)YH( objects for an exact name match. If no match is + found, then the ODB compiler compares the so-called public names. + A public name of a member is obtained by remov)HY(ing)YH( the common member + name deco)HY(ra)HY(tions)YH(, such as leading and trail)HY(ing)YH( under)HY(scores)YH(, the + )SM(m_)ES( prefix, etc. In both of these searches the ODB + compiler also makes sure that the types of the two members are the + same or compat)HY(i)HY(ble)YH(.)EP( + + )0 P(If one of the above searches returned a match and it is unam)HY(bigu)HY(ous)YH(, that + is there is only one match, then the ODB compiler will auto)HY(mat)HY(i)HY(cally)YH( + as)HY(so)HY(ciate)YH( the two members. On the other hand, if no match is found + or the match is ambigu)HY(ous)YH(, the ODB compiler will issue an error. + To as)HY(so)HY(ciate)YH( two differ)HY(ently)YH(-named members or to resolve an ambi)HY(gu)HY(ity)YH(, + we can explic)HY(itly)YH( specify the member asso)HY(ci)HY(a)HY(tion)YH( using the + )SM(db\240column)ES( pragma \201)0 156 1 A(Section 14.4.9, + ")SM(column)ES(")156 0 TN TL()Ec /AF f D(\202. For example:)EP( + + ) 9 49 PR(#pragma db view object\201employee\202 object\201employer\202 +struct employee_employer +{ + std::string first; + std::string last; + + #pragma db column\201employer::name_\202 + std::string employer_name; +};)RP( + + )0 P(If an object data member spec)HY(i)HY(fies)YH( the SQL type with + the )SM(db\240type)ES( pragma \201)0 150 1 A(Section + 14.4.3, ")SM(type)ES(")150 0 TN TL()Ec /AF f D(\202, then this type is also used for + the asso)HY(ci)HY(ated)YH( view data members.)EP( + + )0 P(Note also that similar to join condi)HY(tions)YH(, if we assign an alias to + an object and refer to a data member of this object in one of the + )SM(db\240column)ES( pragmas, then we have to use the + unqual)HY(i)HY(fied)YH( alias name instead of the poten)HY(tially)YH( qual)HY(i)HY(fied)YH( + object name. For example:)EP( + + ) 14 55 PR(#pragma db view object\201employee\202 \200 + object\201country = res_country: employee::residence_\202 \200 + object\201country = nat_country: employee::nationality_\202 +struct employee_country +{ + std::string first; + std::string last; + + #pragma db column\201res_country::name_\202 + std::string res_country_name; + + #pragma db column\201nat_country::name_\202 + std::string nat_country_name; +};)RP( + + )0 P(Besides spec)HY(i)HY(fy)HY(ing)YH( just the object member, we can also specify a + )EM(+-expres)HY(sion)YH()ES( in the )SM(db\240column)ES( pragma. A + +-expres)HY(sion)YH( consists of string liter)HY(als)YH( and object + member refer)HY(ences)YH( connected using the )SM(+)ES( oper)HY(a)HY(tor)YH(. + It is primar)HY(ily)YH( useful for defin)HY(ing)YH( aggre)HY(gate)YH( views based on + SQL aggre)HY(gate)YH( func)HY(tions)YH(, for example:)EP( + + ) 6 51 PR(#pragma db view object\201employee\202 +struct employee_count +{ + #pragma db column\201"count\201" + employee::id_ + "\202"\202 + std::size_t count; +};)RP( + + )0 P(When query)HY(ing)YH( the database for a view, we may want to provide + addi)HY(tional)YH( query crite)HY(ria)YH( based on the objects asso)HY(ci)HY(ated)YH( with + this view. To support this a view defines query members for all + the asso)HY(ci)HY(ated)YH( objects which allows us to refer to such objects' + members using the )SM(odb::query::member)ES( expres)HY(sions)YH(. + This is similar to how we can refer to object members using the + )SM(odb::query::member)ES( expres)HY(sions)YH( when + query)HY(ing)YH( the database for an object. For example:)EP( + + ) 14 70 PR(typedef odb::query query; + +transaction t \201db.begin \201\202\202; + +// Find the number of employees with the Doe last name. Result of this +// aggregate query contains only one element so use the query_value\201\202 +// shortcut function. +// +employee_count ec \201 + db.query_value \201query::last == "Doe"\202\202; + +cout << ec.count << endl; + +t.commit \201\202;)RP( + + )0 P(In the above query we used the last name data member from the asso)HY(ci)HY(ated)YH( + )SM(employee)ES( object to only count employ)HY(ees)YH( with the specific + name.)EP( + + )0 P(When a view has only one asso)HY(ci)HY(ated)YH( object, the query members + corre)HY(spond)HY(ing)YH( to this object are defined directly in the + )SM(odb::query)ES( scope. For instance, + in the above example, we referred to the last name member as + )SM(odb::query::last)ES(. However, if + a view has multi)HY(ple)YH( asso)HY(ci)HY(ated)YH( objects, then query members + corre)HY(spond)HY(ing)YH( to each such object are defined in a nested + scope named after the object. As an example, consider + the )SM(employee_employer)ES( view again:)EP( + + ) 9 49 PR(#pragma db view object\201employee\202 object\201employer\202 +struct employee_employer +{ + std::string first; + std::string last; + + #pragma db column\201employer::name_\202 + std::string employer_name; +};)RP( + + )0 P(Now, to refer to the last name data member from the )SM(employee)ES( + object we use the + )SM(odb::query<...>::employee::last)ES( expres)HY(sion)YH(. + Simi)HY(larly)YH(, to refer to the employer name, we use the + )SM(odb::query<...>::employer::name)ES( expres)HY(sion)YH(. + For example:)EP( + + ) 13 73 PR(typedef odb::result result; +typedef odb::query query; + +transaction t \201db.begin \201\202\202; + +result r \201db.query \201 + query::employee::last == "Doe" && + query::employer::name == "Simple Tech Ltd"\202\202; + +for \201result::iterator i \201r.begin \201\202\202; i != r.end \201\202; ++i\202 + cout << i->first << " " << i->last << " " << i->employer_name << endl; + +t.commit \201\202;)RP( + + )0 P(If we assign an alias to an object, then this alias is used to + name the query members scope instead of the object name. As an + example, consider the )SM(employee_country)ES( view again:)EP( + + ) 7 55 PR(#pragma db view object\201employee\202 \200 + object\201country = res_country: employee::residence_\202 \200 + object\201country = nat_country: employee::nationality_\202 +struct employee_country +{ + ... +};)RP( + + )0 P(And a query which returns all the employ)HY(ees)YH( that have the same + country of resi)HY(dence)YH( and nation)HY(al)HY(ity)YH(:)EP( + + ) 12 75 PR(typedef odb::query query; +typedef odb::result result; + +transaction t \201db.begin \201\202\202; + +result r \201db.query \201 + query::res_country::name == query::nat_country::name\202\202; + +for \201result::iterator i \201r.begin \201\202\202; i != r.end \201\202; ++i\202 + cout << i->first << " " << i->last << " " << i->res_country_name << endl; + +t.commit \201\202;)RP( + + )0 P(Note also that unlike object query members, view query members do + no support refer)HY(enc)HY(ing)YH( members in related objects. For example, + the follow)HY(ing)YH( query is invalid:)EP( + + ) 9 50 PR(typedef odb::query query; +typedef odb::result result; + +transaction t \201db.begin \201\202\202; + +result r \201db.query \201 + query::employed_by->name == "Simple Tech Ltd"\202\202; + +t.commit \201\202;)RP( + + )0 P(To get this behav)HY(ior)YH(, we would instead need to as)HY(so)HY(ciate)YH( the + )SM(employer)ES( object with this view and then use the + )SM(query::employer::name)ES( expres)HY(sion)YH( instead of + )SM(query::employed_by->name)ES(.)EP( + + )0 P(As we have discussed above, if spec)HY(i)HY(fied)YH(, an object alias is + used instead of the object name in the join condi)HY(tion)YH(, data + member refer)HY(ences)YH( in the )SM(db\240column)ES( pragma, + as well as to name the query members scope. The object alias + is also used as a table name alias in the under)HY(ly)HY(ing)YH( + )SM(SELECT)ES( state)HY(ment)YH( gener)HY(ated)YH( by the ODB compiler. + Normally, you would not use the table alias directly with + object views. However, if for some reason you need to refer + to a table column directly, for example, as part of a native + query expres)HY(sion)YH(, and you need to qualify the column with + the table, then you will need to use the table alias instead.)EP( + + )0 2 77 H(10.2)WB 402 Sn()WB 81 Sn( Object Loading Views)EA()EH( + + )0 P(A special variant of object views is object loading views. Object + loading views allow us to load one or more complete objects + instead of, or in addi)HY(tion)YH( to, a subset of data member. While we + can often achieve the same end result by calling + )SM(database::load\201\202)ES(, using a view has several advan)HY(tages)YH(.)EP( + + )0 P(If we need to load multi)HY(ple)YH( objects, then using a view allows us + to do this with a single )SM(SELECT)ES( state)HY(ment)YH( execu)HY(tion)YH( + instead of one for each object that would be neces)HY(sary)YH( in case of + )SM(load\201\202)ES(. A view can also be useful for loading only + a single object if the query crite)HY(rion)YH( that we would like to use + involves other, poten)HY(tially)YH( unre)HY(lated)YH(, objects. We will examine + concrete exam)HY(ples)YH( of these and other scenar)HY(ios)YH( in the rest of this + section.)EP( + + )0 P(To load a complete object as part of a view we use a data member of + the pointer to object type, just like for object rela)HY(tion)HY(ships)YH( + \201)0 52 1 A(Chapter 6, "Rela)HY(tion)HY(ships)YH(")52 0 TN TL()Ec /AF f D(\202. As an example, here + is how we can load both the )SM(employee)ES( and + )SM(employer)ES( objects from the previ)HY(ous)YH( section with a single + state)HY(ment)YH(:)EP( + + ) 6 49 PR(#pragma db view object\201employee\202 object\201employer\202 +struct employee_employer +{ + shared_ptr ee; + shared_ptr er; +};)RP( + + )0 P(We use an object loading view just like any other view. In the + result of a query, as we would expect, the pointer data members + point to the loaded objects. For example:)EP( + + ) 11 63 PR(typedef odb::query query; + +transaction t \201db.begin \201\202\202; + +for \201const employee_employer& r: + db.query \201query::employee::age < 31\202\202 +{ + cout << r.ee->age \201\202 << " " << r.er->name \201\202 << endl; +} + +t.commit \201\202;)RP( + + )0 P(As another example, consider a query that loads the )SM(employer)ES( + objects using some condi)HY(tion)YH( based on its employ)HY(ees)YH(. For instance, we + want to find all the employ)HY(ers)YH( that employ people over 65 years old. + We can use this object loading view to imple)HY(ment)YH( such a query \201notice + the )SM(distinct)ES( result modi)HY(fier)YH( discussed later in + )0 84 1 A(Section 10.5, "View Query Condi)HY(tions)YH(")84 0 TN TL()Ec /AF f D(\202:)EP( + + ) 5 65 PR(#pragma db view object\201employer\202 object\201employee\202 query\201distinct\202 +struct employer_view +{ + shared_ptr er; +};)RP( + + )0 P(And this is how we can use this view to find all the employ)HY(ers)YH( that + employ seniors:)EP( + + ) 3 51 PR(typedef odb::query query; + +db.query \201query::employee::age > 65\202)RP( + + )0 P(We can even use object loading views to load completely unre)HY(lated)YH( + \201from the ODB object rela)HY(tion)HY(ships)YH( point of view\202 objects. For example, + the follow)HY(ing)YH( view will load all the employ)HY(ers)YH( that are named the + same as a country \201notice the )SM(inner)ES( join type\202:)EP( + + ) 7 56 PR(#pragma db view object\201employer\202 \200 + object\201country inner: employer::name == country::name\202 +struct employer_named_country +{ + shared_ptr e; + shared_ptr c; +};)RP( + + )0 P(An object loading view can contain ordi)HY(nary)YH( data members + in addi)HY(tion)YH( to object point)HY(ers)YH(. For example, if we are only + inter)HY(ested)YH( in the country code in the above view, then we + can reim)HY(ple)HY(ment)YH( it like this:)EP( + + ) 7 56 PR(#pragma db view object\201employer\202 \200 + object\201country inner: employer::name == country::name\202 +struct employer_named_country +{ + shared_ptr e; + std::string code; +};)RP( + + )0 P(Object loading views also have a few rules and restric)HY(tions)YH(. + Firstly, the pointed-to object in the data member must be asso)HY(ci)HY(ated)YH( + with the view. Further)HY(more)YH(, if the asso)HY(ci)HY(ated)YH( object has an alias, + then the data member name must be the same as the alias \201more + precisely, the public name derived from the data member must + match the alias; which means we can use normal data member + deco)HY(ra)HY(tions)YH( such as trail)HY(ing)YH( under)HY(scores)YH(, etc., see the previ)HY(ous)YH( + section for more infor)HY(ma)HY(tion)YH( on public names\202. The follow)HY(ing)YH( view + illus)HY(trates)YH( the use of aliases as data member names:)EP( + + ) 8 48 PR(#pragma db view object\201employee\202 \200 + object\201country = res: employee::residence_\202 \200 + object\201country = nat: employee::nationality_\202 +struct employee_country +{ + shared_ptr res; + shared_ptr nat_; +};)RP( + + )0 P(Finally, the object point)HY(ers)YH( must be direct data members of + the view. Using, for example, a compos)HY(ite)YH( value that contains + point)HY(ers)YH( as a view data member is not supported. Note also + that depend)HY(ing)YH( on the join type you are using, some of the + result)HY(ing)YH( point)HY(ers)YH( might be )SM(NULL)ES(.)EP( + + )0 P(Up until now we have consis)HY(tently)YH( used )SM(shared_ptr)ES( + as an object pointer in our views. Can we use other point)HY(ers)YH(, + such as )SM(unique_ptr)ES( or raw point)HY(ers)YH(? To answer + this ques)HY(tion)YH( we first need to discuss what happens with + object point)HY(ers)YH( that may be inside objects that a view + loads. As a concrete example, let us revisit the + )SM(employee_employer)ES( view from the begin)HY(ning)YH( of + this section:)EP( + + ) 6 49 PR(#pragma db view object\201employee\202 object\201employer\202 +struct employee_employer +{ + shared_ptr ee; + shared_ptr er; +};)RP( + + )0 P(This view loads two objects: )SM(employee)ES( and + )SM(employer)ES(. The )SM(employee)ES( object, + however, also contains a pointer to )SM(employer)ES( + \201see the )SM(employed_by_)ES( data member\202. In fact, + this is the same object that the view loads since )SM(employer)ES( + is asso)HY(ci)HY(ated)YH( with the view using this same rela)HY(tion)HY(ship)YH( \201ODB + auto)HY(mat)HY(i)HY(cally)YH( uses it since it is the only one\202. The correct + result of loading such a view is then clear: both )SM(er)ES( and + )SM(er->employed_by_)ES( must point to \201or share\202 the + same instance.)EP( + + )0 P(Just like object loading via the )SM(database)ES( class + func)HY(tions)YH(, views achieve this correct behav)HY(ior)YH( of only loading + a single instance of the same object with the help of session's + object cache \201)0 87 1 A(Chapter 11, "Session")87 0 TN TL()Ec /AF f D(\202. In fact, + object loading views enforce this by throw)HY(ing)YH( the + )SM(session_required)ES( excep)HY(tion)YH( if there is no current + session and the view loads an object that is also indi)HY(rectly)YH( + loaded by one of the other objects. The ODB compiler will also + issue diag)HY(nos)HY(tics)YH( if such an object has session support + disabled \201)0 111 1 A(Section 14.1.10, + ")SM(session)ES(")111 0 TN TL()Ec /AF f D(\202.)EP( + + )0 P(With this under)HY(stand)HY(ing)YH( we can now provide the correct imple)HY(men)HY(ta)HY(tion)YH( + of our trans)HY(ac)HY(tion)YH( that uses the )SM(employee_employer)ES( view:)EP( + + ) 13 63 PR(typedef odb::query query; + +transaction t \201db.begin \201\202\202; +odb::session s; + +for \201const employee_employer& r: + db.query \201query::employee::age < 31\202\202 +{ + assert \201r.ee->employed_by_ == r.er\202; + cout << r.ee->age \201\202 << " " << r.er->name \201\202 << endl; +} + +t.commit \201\202;)RP( + + )0 P(It might seem logical, then, to always load all the objects from + all the eager rela)HY(tion)HY(ships)YH( with the view. After all, this will + lead to them all being loaded with a single state)HY(ment)YH(. While + this is theo)HY(ret)HY(i)HY(cally)YH( true, the reality is slightly more nuanced. + If there is a high prob)HY(a)HY(bil)HY(ity)YH( of the object already have been + loaded and sitting in the cache, then not loading the object + as part of the view \201and there)HY(fore)YH( not fetch)HY(ing)YH( all its data + from the database\202 might result in better perfor)HY(mance)YH(.)EP( + + )0 P(Now we can also answer the ques)HY(tion)YH( about which point)HY(ers)YH( we can + use in object loading views. From the above discus)HY(sion)YH( it should + be clear that if an object that we are loading is also part of a + rela)HY(tion)HY(ship)YH( inside another object that we are loading, then we + should use some form of a shared owner)HY(ship)YH( pointer. If, however, + there are no rela)HY(tion)HY(ships)YH( involved, as is the case, for example, + in our )SM(employer_named_country)ES( and + )SM(employee_country)ES( views above, then we can use a + unique owner)HY(ship)YH( pointer such as )SM(unique_ptr)ES(.)EP( + + )0 P(Note also that your choice of a pointer type can be limited by the + "offi)HY(cial)YH(" object pointer type assigned to the object + \201)0 26 1 A(Section 3.3, "Object and View Point)HY(ers)YH(")26 0 TN TL()Ec /AF f D(\202. + For example, if the object pointer type is )SM(shared_ptr)ES(, + you will not be able to use )SM(unique_ptr)ES( to load + such an object into a view since initial)HY(iz)HY(ing)YH( )SM(unique_ptr)ES( + from )SM(shared_ptr)ES( would be a mistake.)EP( + + )0 P(Unless you want to perform your own object cleanup, raw object + point)HY(ers)YH( in views are not partic)HY(u)HY(larly)YH( useful. They do have one + special seman)HY(tics)YH(, however: If a raw pointer is used as a view + member, then, before creat)HY(ing)YH( a new instance, the imple)HY(men)HY(ta)HY(tion)YH( + will check if the member is )SM(NULL)ES(. If it is not, then + it is assumed to point to an exist)HY(ing)YH( instance and the imple)HY(men)HY(ta)HY(tion)YH( + will load the data into it instead of creat)HY(ing)YH( a new one. The + primary use of this special func)HY(tion)HY(al)HY(ity)YH( is to imple)HY(ment)YH( by-value + loading with the ability to detect )SM(NULL)ES( values.)EP( + + )0 P(To illus)HY(trate)YH( this func)HY(tion)HY(al)HY(ity)YH(, consider the follow)HY(ing)YH( view that + load the employee's resi)HY(dence)YH( country by value:)EP( + + ) 12 63 PR(#pragma db view object\201employee\202 \200 + object\201country = res: employee::residence_\202 transient +struct employee_res_country +{ + typedef country* country_ptr; + + #pragma db member\201res_\202 virtual\201country_ptr\202 get\201&this.res\202 \200 + set\201this.res_null = \201\201?\202 == nullptr\202\202 + + country res; + bool res_null; +};)RP( + + )0 P(Here we are using a virtual data member + \201)0 160 1 A(Section 14.4.13, ")SM(virtual)ES(")160 0 TN TL()Ec /AF f D(\202 to + add an object pointer member to the view. Its acces)HY(sor)YH( expres)HY(sion)YH( + returns the pointer to the )SM(res)ES( member so that + the imple)HY(men)HY(ta)HY(tion)YH( can load the data into it. The modi)HY(fier)YH( + expres)HY(sion)YH( checks the passed pointer to initial)HY(ize)YH( the + )SM(NULL)ES( value indi)HY(ca)HY(tor)YH(. Here, the two possi)HY(ble)YH( + values that can be passed to the modi)HY(fier)YH( expres)HY(sion)YH( are + the address of the )SM(res)ES( member that we returned + earlier from the acces)HY(sor)YH( and )SM(NULL)ES( \201strictly + speak)HY(ing)YH(, there is a third possi)HY(bil)HY(ity)YH(: the address of an + object that was found in the session cache\202.)EP( + + )0 P(If we are not inter)HY(ested)YH( in the )SM(NULL)ES( indi)HY(ca)HY(tor)YH(, + then the above view can simpli)HY(fied)YH( to this:)EP( + + ) 10 67 PR(#pragma db view object\201employee\202 \200 + object\201country = res: employee::residence_\202 transient +struct employee_res_country +{ + typedef country* country_ptr; + + #pragma db member\201res_\202 virtual\201country_ptr\202 get\201&this.res\202 set\201\202 + + country res; +};)RP( + + )0 P(That is, we specify an empty modi)HY(fier)YH( expres)HY(sion)YH( which leads to + the value being ignored.)EP( + + )0 P(As another example of by-value loading, consider a view that allows + us to load objects into exist)HY(ing)YH( instances that have been allo)HY(cated)YH( + outside the view:)EP( + + ) 10 66 PR(#pragma db view object\201employee\202 \200 + object\201country = res: employee::residence_\202 \200 + object\201country = nat: employee::nationality_\202 +struct employee_country +{ + employee_country \201country& r, country& n\202: res \201&r\202, nat \201&n\202 {} + + country* res; + country* nat; +};)RP( + + )0 P(And here is how we can use this view:)EP( + + ) 20 57 PR(typedef odb::result result; + +transaction t \201db.begin \201\202\202; + +result r \201db.query \201...\202; + +for \201result::iterator i \201r.begin \201\202\202; i != r.end \201\202; ++i\202 +{ + country res, nat; + employee_country v \201res, nat\202; + i.load \201v\202; + + if \201v.res != nullptr\202 + ... // Result is in res. + + if \201v.nat != nullptr\202 + ... // Result is in nat. +} + +t.commit \201\202;)RP( + + )0 P(As a final example of the by-value loading, consider the follow)HY(ing)YH( + view which imple)HY(ments)YH( a slightly more advanced logic: if the object + is already in the session cache, then it sets the pointer data member + in the view \201)SM(er_p)ES(\202 to that. Other)HY(wise)YH(, it loads the data + into the by-value instance \201)SM(er)ES(\202. We can also check + whether the pointer data member points to the instance to distin)HY(guish)YH( + between the two outcomes. And we can check it for )SM(nullptr)ES( + to detect )SM(NULL)ES( values.)EP( + + ) 22 73 PR(#pragma db view object\201employer\202 +struct employer_view +{ + // Since we may be getting the pointer as both smart and raw, we + // need to create a bit of support code to use in the modifier + // expression. + // + void set_er \201employer* p\202 {er_p = p;} // &er or NULL. + void set_er \201shared_ptr p\202 {er_p = p.get \201\202;} // From cache. + + #pragma db get\201&this.er\202 set\201set_er\201?\202\202 + employer* er_p; + + #pragma db transient + employer er; + + // Return-by-value support \201e.g., query_value\201\202\202. + // + employer_view \201\202: er_p \2010\202 {} + employer_view \201const employer_view& x\202 + : er_p \201x.er_p == &x.er ? &er : x.er_p\202, er \201x.er\202 {} +};)RP( + + )0 P(We can use object loading views with poly)HY(mor)HY(phic)YH( objects + \201)0 71 1 A(Section 8.2, "Poly)HY(mor)HY(phism)YH( Inher)HY(i)HY(tance)YH(")71 0 TN TL()Ec /AF f D(\202. Note, + however, that when loading a derived object via the base pointer + in a view, a sepa)HY(rate)YH( state)HY(ment)YH( will be executed to load the + dynamic part of the object. There is no support for by-value + loading for poly)HY(mor)HY(phic)YH( objects.)EP( + + )0 P(We can also use object loading views with objects without id + \201)0 107 1 A(Section 14.1.6, ")SM(no_id)ES(")107 0 TN TL()Ec /AF f D(\202. + Note, however, that for such objects, )SM(NULL)ES( values + are not auto)HY(mat)HY(i)HY(cally)YH( detected \201since there is no primary key, + which is other)HY(wise)YH( guar)HY(an)HY(teed)YH( to be not )SM(NULL)ES(, there + might not be a column on which to base this detec)HY(tion)YH(\202. The + workaround for this limi)HY(ta)HY(tion)YH( is to load an other)HY(wise)YH( not + )SM(NULL)ES( column next to the object which will serve + as an indi)HY(ca)HY(tor)YH(. For example:)EP( + + ) 18 70 PR(#pragma db object no_id +class object +{ + ... + + int n; // NOT NULL + std::string s; +}; + +#include + +#pragma db view object\201object\202 +struct view +{ + + odb::nullable n; // If 'n' is NULL, then, logically, so is 'o'. + unique_ptr o; +};)RP( + + )0 2 78 H(10.3)WB 403 Sn()WB 82 Sn( Table Views)EA()EH( + + )0 P(A table view is similar to an object view except that it is + based on one or more database tables instead of persis)HY(tent)YH( + objects. Table views are primar)HY(ily)YH( useful when dealing with + ad-hoc tables that are not mapped to persis)HY(tent)YH( classes.)EP( + + )0 P(To as)HY(so)HY(ciate)YH( one or more tables with a view we use the + )SM(db\240table)ES( pragma \201)0 119 1 A(Section 14.2.2, + ")SM(table)ES(")119 0 TN TL()Ec /AF f D(\202. To as)HY(so)HY(ciate)YH( the second and subse)HY(quent)YH( + tables we repeat the )SM(db\240table)ES( pragma for each + addi)HY(tional)YH( table. For example, the follow)HY(ing)YH( view is based on the + )SM(employee_extra)ES( legacy table we have defined at the + begin)HY(ning)YH( of the chapter.)EP( + + ) 9 52 PR(#pragma db view table\201"employee_extra"\202 +struct employee_vacation +{ + #pragma db column\201"employee_id"\202 type\201"INTEGER"\202 + unsigned long employee_id; + + #pragma db column\201"vacation_days"\202 type\201"INTEGER"\202 + unsigned short vacation_days; +};)RP( + + )0 P(Besides the table name in the )SM(db\240table)ES( pragma + we also have to specify the column name for each view data + member. Note that unlike for object views, the ODB compiler + does not try to auto)HY(mat)HY(i)HY(cally)YH( come up with column names for + table views. Further)HY(more)YH(, we cannot use refer)HY(ences)YH( to object + members either, since there are no asso)HY(ci)HY(ated)YH( objects in table + views. Instead, the actual column name or column expres)HY(sion)YH( + must be spec)HY(i)HY(fied)YH( as a string literal. The column name can + also be qual)HY(i)HY(fied)YH( with a table name either in the + )SM("table.column")ES( form or, if either a table + or a column name contains a period, in the + )SM("table"."column")ES( form. The follow)HY(ing)YH( example + illus)HY(trates)YH( the use of a column expres)HY(sion)YH(:)EP( + + ) 6 57 PR(#pragma db view table\201"employee_extra"\202 +struct employee_max_vacation +{ + #pragma db column\201"max\201vacation_days\202"\202 type\201"INTEGER"\202 + unsigned short max_vacation_days; +};)RP( + + )0 P(Both the asoci)HY(ated)YH( table names and the column names can be qual)HY(i)HY(fied)YH( + with a database schema, for example:)EP( + + ) 6 70 PR(#pragma db view table\201"hr.employee_extra"\202 +struct employee_max_vacation +{ + #pragma db column\201"hr.employee_extra.vacation_days"\202 type\201"INTEGER"\202 + unsigned short vacation_days; +};)RP( + + )0 P(For more infor)HY(ma)HY(tion)YH( on database schemas and the format of the + qual)HY(i)HY(fied)YH( names, refer to )0 109 1 A(Section 14.1.8, + ")SM(schema)ES(")109 0 TN TL()Ec /AF f D(.)EP( + + )0 P(Note also that in the above exam)HY(ples)YH( we spec)HY(i)HY(fied)YH( the SQL type + for each of the columns to make sure that the ODB compiler + has knowl)HY(edge)YH( of the actual types as spec)HY(i)HY(fied)YH( in the database + schema. This is required to obtain correct and optimal + gener)HY(ated)YH( code.)EP( + + + )0 P(The complete syntax of the )SM(db\240table)ES( pragma + is similar to the )SM(db\240object)ES( pragma and is shown + below:)EP( + + )0 P()SM()BD(table\201")ES()I(name)ES()BD(")ES( + [)BD(=)ES( )BD(")ES()I(alias)ES()BD(")ES(] + [)I(join-type)ES(] + [)BD(:)ES( )I(join-condi)HY(tion)YH()ES(])BD(\202)ES()ES()EP( + + )0 P(The )I(name)ES( part is a database table name. The optional + )I(alias)ES( part gives this table an alias. If provided, the + alias must be used instead of the table when)HY(ever)YH( a refer)HY(ence)YH( + to a table is used. Contexts where such a refer)HY(ence)YH( may + be needed include the join condi)HY(tion)YH( \201discussed below\202, + column names, and query expres)HY(sions)YH(. The optional )I(join-type)ES( + part spec)HY(i)HY(fies)YH( the way this table is asso)HY(ci)HY(ated)YH(. It can + be )SM(left)ES(, )SM(right)ES(, )SM(full)ES(, + )SM(inner)ES(, and )SM(cross)ES( with )SM(left)ES( + being the default. Finally, the optional )I(join-condi)HY(tion)YH()ES( + part provides the crite)HY(ria)YH( which should be used to as)HY(so)HY(ciate)YH( this + table with any of the previ)HY(ously)YH( asso)HY(ci)HY(ated)YH( tables or, as we will see in + )0 83 1 A(Section 10.4, "Mixed Views")83 0 TN TL()Ec /AF f D(, objects. Note that + while the first asso)HY(ci)HY(ated)YH( table can have an alias, it cannot have + a join type or condi)HY(tion)YH(.)EP( + + )0 P(Similar to object views, for each subse)HY(quent)YH( asso)HY(ci)HY(ated)YH( table the + ODB compiler needs a join condi)HY(tion)YH(. However, unlike for object views, + for table views the ODB compiler does not try to come up with one + auto)HY(mat)HY(i)HY(cally)YH(. Further)HY(more)YH(, we cannot use refer)HY(ences)YH( to object + members corre)HY(spond)HY(ing)YH( to object rela)HY(tion)HY(ships)YH( either, since there + are no asso)HY(ci)HY(ated)YH( objects in table views. Instead, for each + subse)HY(quent)YH( asso)HY(ci)HY(ated)YH( table, a join condi)HY(tion)YH( must be + spec)HY(i)HY(fied)YH( as a custom query expres)HY(sion)YH(. While the syntax of the + query expres)HY(sion)YH( is the same as in the query facil)HY(ity)YH( used to query + the database for objects \201)0 38 1 A(Chapter 4, "Query)HY(ing)YH( the + Database")38 0 TN TL()Ec /AF f D(\202, a join condi)HY(tion)YH( for a table is normally spec)HY(i)HY(fied)YH( + as a single string literal contain)HY(ing)YH( a native SQL query expres)HY(sion)YH(.)EP( + + )0 P(As an example of a multi-table view, consider the + )SM(employee_health)ES( table that we define in addi)HY(tion)YH( + to )SM(employee_extra)ES(:)EP( + + ) 3 35 PR(CREATE TABLE employee_health\201 + employee_id INTEGER NOT NULL, + sick_leave_days INTEGER NOT NULL\202)RP( + + )0 P(Given these two tables we can now define a view that returns both + the vaca)HY(tion)YH( and sick leave infor)HY(ma)HY(tion)YH( for each employee:)EP( + + ) 14 56 PR(#pragma db view table\201"employee_extra" = "extra"\202 \200 + table\201"employee_health" = "health": \200 + "extra.employee_id = health.employee_id"\202 +struct employee_leave +{ + #pragma db column\201"extra.employee_id"\202 type\201"INTEGER"\202 + unsigned long employee_id; + + #pragma db column\201"vacation_days"\202 type\201"INTEGER"\202 + unsigned short vacation_days; + + #pragma db column\201"sick_leave_days"\202 type\201"INTEGER"\202 + unsigned short sick_leave_days; +};)RP( + + )0 P(Query)HY(ing)YH( the database for a table view is the same as for an + object view except that we can only use native query expres)HY(sions)YH(. + For example:)EP( + + ) 13 49 PR(typedef odb::query query; +typedef odb::result result; + +transaction t \201db.begin \201\202\202; + +unsigned short v_min = ... +unsigned short l_min = ... + +result r \201db.query \201 + "vacation_days > " + query::_val\201v_min\202 + "AND" + "sick_leave_days > " + query::_val\201l_min\202\202\202; + +t.commit \201\202;)RP( + + + )0 2 79 H(10.4)WB 404 Sn()WB 83 Sn( Mixed Views)EA()EH( + + )0 P(A mixed view has both asso)HY(ci)HY(ated)YH( objects and tables. As a first + example of a mixed view, let us improve )SM(employee_vaca)HY(tion)YH()ES( + from the previ)HY(ous)YH( section to return the employee's first + and last names instead of the employee id. To achieve this we + have to as)HY(so)HY(ciate)YH( both the )SM(employee)ES( object and + the )SM(employee_extra)ES( table with the view:)EP( + + ) 10 75 PR(#pragma db view object\201employee\202 \200 + table\201"employee_extra" = "extra": "extra.employee_id = " + employee::id_\202 +struct employee_vacation +{ + std::string first; + std::string last; + + #pragma db column\201"extra.vacation_days"\202 type\201"INTEGER"\202 + unsigned short vacation_days; +};)RP( + + )0 P(When query)HY(ing)YH( the database for a mixed view, we can use query members + for the parts of the query expres)HY(sion)YH( that involves object members + but have to fall back to using the native syntax for the parts that + involve table columns. For example:)EP( + + ) 12 72 PR(typedef odb::query query; +typedef odb::result result; + +transaction t \201db.begin \201\202\202; + +result r \201db.query \201 + \201query::last == "Doe"\202 + "AND extra.vacation_days <> 0"\202\202; + +for \201result::iterator i \201r.begin \201\202\202; i != r.end \201\202; ++i\202 + cout << i->first << " " << i->last << " " << i->vacation_days << endl; + +t.commit \201\202;)RP( + + )0 P(As another example, consider a more advanced view that as)HY(so)HY(ciates)YH( + two objects via a legacy table. This view allows us to find the + previ)HY(ous)YH( employer name for each employee:)EP( + + ) 14 77 PR(#pragma db view object\201employee\202 \200 + table\201"employee_extra" = "extra": "extra.employee_id = " + employee::id_\202 \200 + object\201employer: "extra.previous_employer_id = " + employer::id_\202 +struct employee_prev_employer +{ + std::string first; + std::string last; + + // If previous_employer_id is NULL, then the name will be NULL as well. + // We use the odb::nullable wrapper to handle this. + // + #pragma db column\201employer::name_\202 + odb::nullable prev_employer_name; +};)RP( + + )0 2 80 H(10.5)WB 405 Sn()WB 84 Sn( View Query Condi)HY(tions)YH()EA()EH( + + )0 P(Object, table, and mixed views can also specify an optional query + condi)HY(tion)YH( that should be used when)HY(ever)YH( the database is queried for + this view. To specify a query condi)HY(tion)YH( we use the + )SM(db\240query)ES( pragma \201)0 120 1 A(Section 14.2.3, + ")SM(query)ES(")120 0 TN TL()Ec /AF f D(\202.)EP( + + )0 P(As an example, consider a view that returns some infor)HY(ma)HY(tion)YH( about + all the employ)HY(ees)YH( that are over a prede)HY(fined)YH( retire)HY(ment)YH( age. + One way to imple)HY(ment)YH( this would be to define a stan)HY(dard)YH( object + view as we have done in the previ)HY(ous)YH( sections and then use a + query like this:)EP( + + ) 1 59 PR(result r \201db.query \201query::age > 50\202\202;)RP( + + )0 P(The problem with the above approach is that we have to keep + repeat)HY(ing)YH( the )SM(query::age > 50)ES( expres)HY(sion)YH( every + time we execute the query, even though this expres)HY(sion)YH( always + stays the same. View query condi)HY(tions)YH( allow us to solve this + problem. For example:)EP( + + ) 7 58 PR(#pragma db view object\201employee\202 query\201employee::age > 50\202 +struct employee_retirement +{ + std::string first; + std::string last; + unsigned short age; +};)RP( + + )0 P(With this improve)HY(ment)YH( we can rewrite our query like this:)EP( + + ) 1 44 PR(result r \201db.query \201\202\202;)RP( + + )0 P(But what if we may also need to restrict the result set based on + some varying crite)HY(ria)YH(, such as the employee's last name? Or, in other + words, we may need to combine a constant query expres)HY(sion)YH( spec)HY(i)HY(fied)YH( + in the )SM(db\240query)ES( pragma with the varying expres)HY(sion)YH( + spec)HY(i)HY(fied)YH( at the query execu)HY(tion)YH( time. To allow this, the + )SM(db\240query)ES( pragma syntax supports the use of the special + )SM(\201?\202)ES( place)HY(holder)YH( that indi)HY(cates)YH( the posi)HY(tion)YH( in the + constant query expres)HY(sion)YH( where the runtime expres)HY(sion)YH( should be + inserted. For example:)EP( + + ) 7 65 PR(#pragma db view object\201employee\202 query\201employee::age > 50 && \201?\202\202 +struct employee_retirement +{ + std::string first; + std::string last; + unsigned short name; +};)RP( + + )0 P(With this change we can now use addi)HY(tional)YH( query crite)HY(ria)YH( in our + view:)EP( + + ) 1 64 PR(result r \201db.query \201query::last == "Doe"\202\202;)RP( + + )0 P(The syntax of the expres)HY(sion)YH( in a query condi)HY(tion)YH( is the same as in + the query facil)HY(ity)YH( used to query the database for objects + \201)0 38 1 A(Chapter 4, "Query)HY(ing)YH( the Database")38 0 TN TL()Ec /AF f D(\202 except for + two differ)HY(ences)YH(. Firstly, for query members, instead of + using )SM(odb::query::member)ES( names, we refer + directly to object members, using the object alias instead of the + object name if an alias was assigned. Secondly, query condi)HY(tions)YH( + support the special )SM(\201?\202)ES( place)HY(holder)YH( which can be used + both in the C++-inte)HY(grated)YH( query expres)HY(sions)YH( as was shown above + and in native SQL expres)HY(sions)YH( spec)HY(i)HY(fied)YH( as string liter)HY(als)YH(. The + follow)HY(ing)YH( view is an example of the latter case:)EP( + + ) 6 41 PR(#pragma db view table\201"employee_extra"\202 \200 + query\201"vacation_days <> 0 AND \201?\202"\202 +struct employee_vacation +{ + ... +};)RP( + + )0 P(Another common use case for query condi)HY(tions)YH( are views with the + )SM(ORDER BY)ES( or )SM(GROUP BY)ES( clause. Such + clauses are normally present in the same form in every query + involv)HY(ing)YH( such views. As an example, consider an aggre)HY(gate)YH( + view which calcu)HY(late)YH( the minimum and maximum ages of employ)HY(ees)YH( + for each employer:)EP( + + ) 13 51 PR(#pragma db view object\201employee\202 object\201employer\202 \200 + query\201\201?\202 + "GROUP BY" + employer::name_\202 +struct employer_age +{ + #pragma db column\201employer::name_\202 + std::string employer_name; + + #pragma db column\201"min\201" + employee::age_ + "\202"\202 + unsigned short min_age; + + #pragma db column\201"max\201" + employee::age_ + "\202"\202 + unsigned short max_age; +};)RP( + + )0 P(The query condi)HY(tion)YH( can be option)HY(ally)YH( followed \201or replaced, + if no constant query expres)HY(sion)YH( is needed\202 by one or more + )EM(result modi)HY(fiers)YH()ES(. Currently supported result modi)HY(fiers)YH( + are )SM(distinct)ES( \201which is trans)HY(lated)YH( to )SM(SELECT + DISTINCT)ES(\202 and )SM(for_update)ES( \201which is trans)HY(lated)YH( + to )SM(FOR UPDATE)ES( or equiv)HY(a)HY(lent)YH( for database systems + that support it\202. As an example, consider a view that + allows us to get some infor)HY(ma)HY(tion)YH( about employ)HY(ers)YH( ordered + by the object id and without any dupli)HY(cates)YH(:)EP( + + ) 6 53 PR(#pragma db view object\201employer\202 object\201employee\202 \200 + query\201\201?\202 + "ORDER BY" + employer::name_, distinct\202 +struct employer_info +{ + ... +};)RP( + + )0 P(If we don't require order)HY(ing)YH(, then this view can be re-imple)HY(mented)YH( + like this:)EP( + + ) 5 65 PR(#pragma db view object\201employer\202 object\201employee\202 query\201distinct\202 +struct employer_info +{ + ... +};)RP( + + )0 2 81 H(10.6)WB 406 Sn()WB 85 Sn( Native Views)EA()EH( + + )0 P(The last kind of view supported by ODB is a native view. Native + views are a low-level mech)HY(a)HY(nism)YH( for captur)HY(ing)YH( results of native + SQL queries, stored proce)HY(dure)YH( calls, etc. Native views don't have + asso)HY(ci)HY(ated)YH( tables or objects. Instead, we use the + )SM(db\240query)ES( pragma to specify the native SQL query, + which should normally include the select-list and, if appli)HY(ca)HY(ble)YH(, + the from-list. For example, here is how we can re-imple)HY(ment)YH( the + )SM(employee_vaca)HY(tion)YH()ES( table view from Section 10.3 above + as a native view:)EP( + + ) 10 60 PR(#pragma db view query\201"SELECT employee_id, vacation_days " \200 + "FROM employee_extra"\202 +struct employee_vacation +{ + #pragma db type\201"INTEGER"\202 + unsigned long employee_id; + + #pragma db type\201"INTEGER"\202 + unsigned short vacation_days; +};)RP( + + )0 P(In native views the columns in the query select-list are + asso)HY(ci)HY(ated)YH( with the view data members in the order spec)HY(i)HY(fied)YH(. + That is, the first column is stored in the first member, the + second column \236 in the second member, and so on. The ODB compiler + does not perform any error check)HY(ing)YH( in this asso)HY(ci)HY(a)HY(tion)YH(. As a result + you must make sure that the number and order of columns in the + query select-list match the number and order of data members + in the view. This is also the reason why we are not + required to provide the column name for each data member in native + views, as is the case for object and table views.)EP( + + )0 P(Note also that while it is always possi)HY(ble)YH( to imple)HY(ment)YH( a table + view as a native view, the table views must be preferred since + they are safer. In a native view, if you add, remove, or + rear)HY(range)YH( data members without updat)HY(ing)YH( the column list in the + query, or vice versa, at best, this will result in a runtime + error. In contrast, in a table view such changes will result + in the query being auto)HY(mat)HY(i)HY(cally)YH( updated.)EP( + + )0 P(Similar to object and table views, the query spec)HY(i)HY(fied)YH( for + a native view can contain the special )SM(\201?\202)ES( + place)HY(holder)YH( which is replaced with the query expres)HY(sion)YH( + spec)HY(i)HY(fied)YH( at the query execu)HY(tion)YH( time. + If the native query does not contain a place)HY(holder)YH(, as in + the example above, then any query expres)HY(sion)YH( spec)HY(i)HY(fied)YH( at + the query execu)HY(tion)YH( time is appended to the query text + along with the )SM(WHERE)ES( keyword, if required. + The follow)HY(ing)YH( example shows the usage of the place)HY(holder)YH(:)EP( + + ) 7 60 PR(#pragma db view query\201"SELECT employee_id, vacation_days " \200 + "FROM employee_extra " \200 + "WHERE vacation_days <> 0 AND \201?\202"\202 +struct employee_vacation +{ + ... +};)RP( + + )0 P(As another example, consider a view that returns the next + value of a database sequence:)EP( + + ) 5 49 PR(#pragma db view query\201"SELECT nextval\201'my_seq'\202"\202 +struct sequence_value +{ + unsigned long long value; +};)RP( + + )0 P(While this imple)HY(men)HY(ta)HY(tion)YH( can be accept)HY(able)YH( in some cases, it has + a number of draw)HY(backs)YH(. Firstly, the name of the sequence is + fixed in the view, which means if we have a second sequence, we + will have to define another, almost iden)HY(ti)HY(cal)YH( view. Simi)HY(larly)YH(, + the oper)HY(a)HY(tion)YH( that we perform on the sequence is also fixed. + In some situ)HY(a)HY(tions)YH(, instead of return)HY(ing)YH( the next value, we may + need the last value.)EP( + + )0 P(Note that we cannot use the place)HY(holder)YH( mech)HY(a)HY(nism)YH( to resolve + these prob)HY(lems)YH( since place)HY(hold)HY(ers)YH( can only be used in the + )SM(WHERE)ES(, )SM(GROUP BY)ES(, and similar + clauses. In other words, the follow)HY(ing)YH( won't work:)EP( + + ) 7 47 PR(#pragma db view query\201"SELECT nextval\201'\201?\202'\202"\202 +struct sequence_value +{ + unsigned long long value; +}; + +result r \201db.query \201"my_seq"\202\202;)RP( + + )0 P(To support these kinds of use cases, ODB allows us to specify the + complete query for a native view at runtime rather than at the view + defi)HY(ni)HY(tion)YH(. To indi)HY(cate)YH( that a native view has a runtime query, + we can either specify the empty )SM(db\240query)ES( + pragma or omit the pragma alto)HY(gether)YH(. For example:)EP( + + ) 5 27 PR(#pragma db view +struct sequence_value +{ + unsigned long long value; +};)RP( + + )0 P(Given this view, we can perform the follow)HY(ing)YH( queries:)EP( + + ) 10 43 PR(typedef odb::query query; +typedef odb::result result; + +string seq_name = ... + +result l \201db.query \201 + "SELECT lastval\201'" + seq_name + "'\202"\202\202; + +result n \201db.query \201 + "SELECT nextval\201'" + seq_name + "'\202"\202\202;)RP( + + )0 P(Native views can also be used to call and handle results of + stored proce)HY(dures)YH(. The seman)HY(tics)YH( and limi)HY(ta)HY(tions)YH( of stored + proce)HY(dures)YH( vary greatly between database systems while some + do not support this func)HY(tion)HY(al)HY(ity)YH( at all. As a result, support + for calling stored proce)HY(dures)YH( using native views is described + for each database system in )0 204 1 A(Part II, "Database + Systems")204 0 TN TL()Ec /AF f D(.)EP( + + )0 2 82 H(10.7)WB 407 Sn()WB 86 Sn( Other View Features and Limi)HY(ta)HY(tions)YH()EA()EH( + + )0 P(Views cannot be derived from other views. However, you can derive + a view from a tran)HY(sient)YH( C++ class. View data members cannot be + object point)HY(ers)YH(. If you need to access data from a pointed-to + object, then you will need to as)HY(so)HY(ciate)YH( such an object with + the view. Simi)HY(larly)YH(, view data members cannot be contain)HY(ers)YH(. + These two limi)HY(ta)HY(tions)YH( also apply to compos)HY(ite)YH( value types that + contain object point)HY(ers)YH( or contain)HY(ers)YH(. Such compos)HY(ite)YH( values + cannot be used as view data members.)EP( + + )0 P(On the other hand, compos)HY(ite)YH( values that do not contain object + point)HY(ers)YH( or contain)HY(ers)YH( can be used in views. As an example, + consider a modi)HY(fied)YH( version of the )SM(employee)ES( persis)HY(tent)YH( + class that stores a person's name as a compos)HY(ite)YH( value:)EP( + + ) 16 21 PR(#pragma db value +class person_name +{ + std::string first_; + std::string last_; +}; + +#pragma db object +class employee +{ + ... + + person_name name_; + + ... +};)RP( + + )0 P(Given this change, we can re-imple)HY(ment)YH( the )SM(employee_name)ES( + view like this:)EP( + + ) 5 32 PR(#pragma db view object\201employee\202 +struct employee_name +{ + person_name name; +};)RP( + + )0 P(It is also possi)HY(ble)YH( to extract some or all of the nested members + of a compos)HY(ite)YH( value into indi)HY(vid)HY(ual)YH( view data members. Here is + how we could have defined the )SM(employee_name)ES( view + if we wanted to keep its orig)HY(i)HY(nal)YH( struc)HY(ture)YH(:)EP( + + ) 9 42 PR(#pragma db view object\201employee\202 +struct employee_name +{ + #pragma db column\201employee::name.first_\202 + std::string first; + + #pragma db column\201employee::name.last_\202 + std::string last; +};)RP( + + + + + + )WB NL NP( + )0 1 83 H(11)WB 408 Sn()WB 87 Sn( Session)EA()EH( + + )0 P(A session is an appli)HY(ca)HY(tion)YH('s unit of work that may encom)HY(pass)YH( several + database trans)HY(ac)HY(tions)YH(. In this version of ODB a session is just an + object cache. In future versions it may provide addi)HY(tional)YH( + func)HY(tion)HY(al)HY(ity)YH(, such as delayed database oper)HY(a)HY(tions)YH( and auto)HY(matic)YH( + object state change track)HY(ing)YH(. As discussed later in + )0 89 1 A(Section 11.2, "Custom Sessions")89 0 TN TL()Ec /AF f D(, it is also + possi)HY(ble)YH( to provide a custom session imple)HY(men)HY(ta)HY(tion)YH( that provides + these or other features.)EP( + + )0 P(Session support is optional and can be enabled or disabled on the + per object basis using the )SM(db\240session)ES( pragma, for + example:)EP( + + ) 5 25 PR(#pragma db object session +class person +{ + ... +};)RP( + + )0 P(We can also enable or disable session support for a group of + objects at the names)HY(pace)YH( level:)EP( + + ) 15 66 PR(#pragma db namespace session +namespace accounting +{ + #pragma db object // Session support is enabled. + class employee + { + ... + }; + + #pragma db object session\201false\202 // Session support is disabled. + class employer + { + ... + }; +})RP( + + )0 P(Finally, we can pass the )SM(--gener)HY(ate)YH(-session)ES( ODB compiler + option to enable session support by default. With this option session + support will be enabled for all the persis)HY(tent)YH( classes except those + for which it was explic)HY(itly)YH( disabled using the + )SM(db\240session)ES(. An alter)HY(na)HY(tive)YH( to this method with the + same effect is to enable session support for the global names)HY(pace)YH(:)EP( + + ) 1 30 PR(#pragma db namespace\201\202 session)RP( + + )0 P(Each thread of execu)HY(tion)YH( in an appli)HY(ca)HY(tion)YH( can have only one active + session at a time. A session is started by creat)HY(ing)YH( an instance of + the )SM(odb::session)ES( class and is auto)HY(mat)HY(i)HY(cally)YH( termi)HY(nated)YH( + when this instance is destroyed. You will need to include the + )SM()ES( header file to make this class + avail)HY(able)YH( in your appli)HY(ca)HY(tion)YH(. For example:)EP( + + ) 27 36 PR(#include +#include +#include + +using namespace odb::core; + +{ + session s; + + // First transaction. + // + { + transaction t \201db.begin \201\202\202; + ... + t.commit \201\202; + } + + // Second transaction. + // + { + transaction t \201db.begin \201\202\202; + ... + t.commit \201\202; + } + + // Session 's' is terminated here. +})RP( + + )0 P(The )SM(session)ES( class has the follow)HY(ing)YH( inter)HY(face)YH(:)EP( + + ) 60 67 PR(namespace odb +{ + class session + { + public: + session \201bool make_current = true\202; + ~session \201\202; + + // Copying or assignment of sessions is not supported. + // + private: + session \201const session&\202; + session& operator= \201const session&\202; + + // Current session interface. + // + public: + static session& + current \201\202; + + static bool + has_current \201\202; + + static void + current \201session&\202; + + static void + reset_current \201\202; + + static session* + current_pointer \201\202;)WR( + + static void + current_pointer \201session*\202; + + // Object cache interface. + // + public: + template + struct cache_position {...}; + + template + cache_position + cache_insert \201database&, + const object_traits::id_type&, + const object_traits::pointer_type&\202; + + template + object_traits::pointer_type + cache_find \201database&, const object_traits::id_type&\202 const; + + template + void + cache_erase \201const cache_position&\202; + + template + void + cache_erase \201database&, const object_traits::id_type&\202; + }; +})RP( + + )0 P(The session construc)HY(tor)YH( creates a new session and, if the + )SM(make_current)ES( argu)HY(ment)YH( is )SM(true)ES(, sets it as a + current session for this thread. If we try to make a session current + while there is already another session in effect for this thread, + then the construc)HY(tor)YH( throws the )SM(odb::already_in_session)ES( + excep)HY(tion)YH(. The destruc)HY(tor)YH( clears the current session for this + thread if this session is the current one.)EP( + + )0 P(The static )SM(current\201\202)ES( acces)HY(sor)YH( returns the currently active + session for this thread. If there is no active session, this func)HY(tion)YH( + throws the )SM(odb::not_in_session)ES( excep)HY(tion)YH(. We can check + whether there is a session in effect in this thread using the + )SM(has_current\201\202)ES( static func)HY(tion)YH(.)EP( + + )0 P(The static )SM(current\201\202)ES( modi)HY(fier)YH( allows us to set the + current session for this thread. The )SM(reset_current\201\202)ES( + static func)HY(tion)YH( clears the current session. These two func)HY(tions)YH( + allow for more advanced use cases, such as multi)HY(plex)HY(ing)YH( + two or more sessions on the same thread.)EP( + + )0 P(The static )SM(current_pointer\201\202)ES( over)HY(loaded)YH( func)HY(tions)YH( + provided the same func)HY(tion)HY(al)HY(ity)YH( but using point)HY(ers)YH(. Specif)HY(i)HY(cally)YH(, + the )SM(current_pointer\201\202)ES( acces)HY(sor)YH( can be used to + test whether there is a current session and get a pointer to it + all with a single call.)EP( + + )0 P(We normally don't use the object cache inter)HY(face)YH( directly. However, + it could be useful in some cases, for example, to find out whether + an object has already been loaded. Note that when calling + )SM(cache_insert\201\202)ES(, )SM(cache_find\201\202)ES(, or + the second version of )SM(cache_erase\201\202)ES(, you need to + specify the template argu)HY(ment)YH( \201object type\202 explic)HY(itly)YH(. It is + also possi)HY(ble)YH( to access the under)HY(ly)HY(ing)YH( cache data struc)HY(tures)YH( + directly. This can be useful if, for example, you want to + iterate over the objects store in the cache. Refer to the ODB + runtime header files for more details on this direct access.)EP( + + )0 2 84 H(11.1)WB 409 Sn()WB 88 Sn( Object Cache)EA()EH( + + )0 P(A session is an object cache. Every time a session-enabled object is + made persis)HY(tent)YH( by calling the )SM(database::persist\201\202)ES( func)HY(tion)YH( + \201)0 31 1 A(Section 3.8, "Making Objects Persis)HY(tent)YH(")31 0 TN TL()Ec /AF f D(\202, loaded + by calling the )SM(database::load\201\202)ES( or )SM(database::find\201\202)ES( + func)HY(tion)YH( \201)0 32 1 A(Section 3.9, "Loading Persis)HY(tent)YH( Objects")32 0 TN TL()Ec /AF f D(\202, + or loaded by iter)HY(at)HY(ing)YH( over a query result \201)0 43 1 A(Section 4.4, + "Query Result")43 0 TN TL()Ec /AF f D(\202, the pointer to the persis)HY(tent)YH( object, in the form + of the canon)HY(i)HY(cal)YH( object pointer \201)0 26 1 A(Section 3.3, "Object + and View Point)HY(ers)YH(")26 0 TN TL()Ec /AF f D(\202, is stored in the session. For as long as the + session is in effect, any subse)HY(quent)YH( calls to load the same object will + return the cached instance. When an object's state is deleted from the + database with the )SM(database::erase\201\202)ES( func)HY(tion)YH( + \201)0 34 1 A(Section 3.11, "Delet)HY(ing)YH( Persis)HY(tent)YH( Objects")34 0 TN TL()Ec /AF f D(\202, the + cached object pointer is removed from the session. For example:)EP( + + ) 9 66 PR(shared_ptr p \201new person \201"John", "Doe"\202\202; + +session s; +transaction t \201db.begin \201\202\202; + +unsigned long id \201db.persist \201p\202\202; // p is cached in s. +shared_ptr p1 \201db.load \201id\202\202; // p1 same as p. + +t.commit \201\202;)RP( + + + )0 P(The per-object caching poli)HY(cies)YH( depend on the object pointer kind + \201)0 62 1 A(Section 6.5, "Using Custom Smart Point)HY(ers)YH(")62 0 TN TL()Ec /AF f D(\202. + Objects with a unique pointer, such as )SM(std::auto_ptr)ES( + or )SM(std::unique_ptr)ES(, as an object pointer are never + cached since it is not possi)HY(ble)YH( to have two such point)HY(ers)YH( point)HY(ing)YH( + to the same object. When an object is persisted via a pointer or + loaded as a dynam)HY(i)HY(cally)YH( allo)HY(cated)YH( instance, objects with both raw + and shared point)HY(ers)YH( as object point)HY(ers)YH( are cached. If an object is + persisted as a refer)HY(ence)YH( or loaded into a pre-allo)HY(cated)YH( instance, + the object is only cached if its object pointer is a raw pointer.)EP( + + )0 P(Also note that when we persist an object as a constant refer)HY(ence)YH( + or constant pointer, the session caches such an object as + unre)HY(stricted)YH( \201non-)SM(const)ES(\202. This can lead to unde)HY(fined)YH( + behav)HY(ior)YH( if the object being persisted was actu)HY(ally)YH( created as + )SM(const)ES( and is later found in the session cache and + used as non-)SM(const)ES(. As a result, when using sessions, + it is recom)HY(mended)YH( that all persis)HY(tent)YH( objects be created as + non-)SM(const)ES( instances. The follow)HY(ing)YH( code frag)HY(ment)YH( + illus)HY(trates)YH( this point:)EP( + + ) 28 69 PR(void save \201database& db, shared_ptr p\202 +{ + transaction t \201db.begin \201\202\202; + db.persist \201p\202; // Persisted as const pointer. + t.commit \201\202; +} + +session s; + +shared_ptr p1 \201new const person \201"John", "Doe"\202\202; +unsigned long id1 \201save \201db, p1\202\202; // p1 is cached in s as non-const. + +{ + transaction t \201db.begin \201\202\202; + shared_ptr p \201db.load \201id1\202\202; // p == p1 + p->age \20130\202; // Undefined behavior since p1 was created const. + t.commit \201\202; +} + +shared_ptr p2 \201new person \201"Jane", "Doe"\202\202; +unsigned long id2 \201save \201db, p2\202\202; // p2 is cached in s as non-const. + +{ + transaction t \201db.begin \201\202\202; + shared_ptr p \201db.load \201id2\202\202; // p == p2 + p->age \20130\202; // Ok, since p2 was not created const. + t.commit \201\202; +})RP( + + )0 2 85 H(11.2)WB 410 Sn()WB 89 Sn( Custom Sessions)EA()EH( + + )0 P(ODB can use a custom session imple)HY(men)HY(ta)HY(tion)YH( instead of the + default )SM(odb::session)ES(. There could be multi)HY(ple)YH( + reasons for an appli)HY(ca)HY(tion)YH( to provide its own session. For + example, the appli)HY(ca)HY(tion)YH( may already include a notion of an + object cache or registry which ODB can re-use. A custom + session can also provide addi)HY(tional)YH( func)HY(tion)HY(al)HY(ity)YH(, such as + auto)HY(matic)YH( change track)HY(ing)YH(, delayed database oper)HY(a)HY(tions)YH(, or + object evic)HY(tion)YH(. Finally, the session-per-thread approach used + by )SM(odb::session)ES( may not be suit)HY(able)YH( for all + appli)HY(ca)HY(tions)YH(. For instance, some may need a thread-safe + session that can be shared among multi)HY(ple)YH( threads. For + an example of a custom session that imple)HY(ments)YH( auto)HY(matic)YH( + change track)HY(ing)YH( by keeping orig)HY(i)HY(nal)YH( copies of the objects, + refer to the )SM(common/session/custom)ES( test + in the )SM(odb-tests)ES( package.)EP( + + )0 P(To use a custom session we need to specify its type with + the )SM(--session-type)ES( ODB compiler command line + option. We also need to include its defi)HY(ni)HY(tion)YH( into the + gener)HY(ated)YH( header file. This can be achieved with the + )SM(--hxx-prologue)ES( option. For example, if our + custom session is called )SM(app::session)ES( and + is defined in the )SM(app/session.hxx)ES( header + file, then the corre)HY(spond)HY(ing)YH( ODB compiler options would + look like this:)EP( + + ) 2 51 PR(odb --hxx-prologue "#include \200"app/session.hxx\200"" \200 +--session-type ::app::session ...)RP( + + )0 P(A custom session should provide the follow)HY(ing)YH( inter)HY(face)YH(:)EP( + + ) 45 70 PR(class custom_session +{ +public: + template + struct cache_position + { + ... + }; + + // Cache management functions. + // + template + static cache_position + _cache_insert \201odb::database&, + const typename odb::object_traits::id_type&, + const typename odb::object_traits::pointer_type&\202; + + template + static typename odb::object_traits::pointer_type + _cache_find \201odb::database&, + const typename odb::object_traits::id_type&\202; + + template + static void + _cache_erase \201const cache_position&\202; + + // Notification functions. + // + template + static void + _cache_persist \201const cache_position&\202;)WR( + + template + static void + _cache_load \201const cache_position&\202; + + template + static void + _cache_update \201odb::database&, const T& obj\202; + + template + static void + _cache_erase \201odb::database&, + const typename odb::object_traits::id_type&\202; +};)RP( + + )0 P(The )SM(cache_posi)HY(tion)YH()ES( class template repre)HY(sents)YH( a posi)HY(tion)YH( + in the cache of the inserted object. It should be default and + copy-constructible as well as copy-assignable. The default + construc)HY(tor)YH( shall create a special empty/)SM(NULL)ES( + posi)HY(tion)YH(. A call of any of the cache manage)HY(ment)YH( or noti)HY(fi)HY(ca)HY(tion)YH( + func)HY(tions)YH( with such an empty/)SM(NULL)ES( posi)HY(tion)YH( shall be + ignored.)EP( + + )0 P(The )SM(_cache_insert\201\202)ES( func)HY(tion)YH( shall add the object into + the object cache and return its posi)HY(tion)YH(. The )SM(_cache_find\201\202)ES( + func)HY(tion)YH( looks an object up in the object cache given its id. + It returns a )SM(NULL)ES( pointer if the object is not + found. The )SM(_cache_erase\201\202)ES( cache manage)HY(ment)YH( func)HY(tion)YH( + shall remove the object from the cache. It is called + if the database oper)HY(a)HY(tion)YH( that caused the object to be inserted + \201for example, load\202 failed. Note also that after inser)HY(tion)YH( the object + state is unde)HY(fined)YH(. You can only access the object state + \201for example, make a copy or clear a flag\202 from one of the + noti)HY(fi)HY(ca)HY(tion)YH( func)HY(tions)YH( discussed below.)EP( + + )0 P(The noti)HY(fi)HY(ca)HY(tion)YH( func)HY(tions)YH( are called after an object has + been persisted, loaded, updated, or erased, respec)HY(tively)YH(. If + your session imple)HY(men)HY(ta)HY(tion)YH( does not need some of the + noti)HY(fi)HY(ca)HY(tions)YH(, you still have to provide their func)HY(tions)YH(, + however, you can leave their imple)HY(men)HY(ta)HY(tions)YH( empty.)EP( + + )0 P(Notice also that all the cache manage)HY(ment)YH( and noti)HY(fi)HY(ca)HY(tion)YH( + func)HY(tions)YH( are static. This is done in order to allow for a + custom notion of a current session. Normally, the first + step a non-empty imple)HY(men)HY(ta)HY(tion)YH( will perform is lookup the + current session.)EP( + + + + + + )WB NL NP( + )0 1 86 H(12)WB 411 Sn()WB 90 Sn( Opti)HY(mistic)YH( Concur)HY(rency)YH()EA()EH( + + )0 P(The ODB trans)HY(ac)HY(tion)YH( model \201)0 28 1 A(Section 3.5, + "Trans)HY(ac)HY(tions)YH(")28 0 TN TL()Ec /AF f D(\202 guar)HY(an)HY(tees)YH( consis)HY(tency)YH( as long as we perform all the + database oper)HY(a)HY(tions)YH( corre)HY(spond)HY(ing)YH( to a specific appli)HY(ca)HY(tion)YH( trans)HY(ac)HY(tion)YH( + in a single database trans)HY(ac)HY(tion)YH(. That is, if we load an object within a + database trans)HY(ac)HY(tion)YH( and update it in the same trans)HY(ac)HY(tion)YH(, then we are + guar)HY(an)HY(teed)YH( that the object state that we are updat)HY(ing)YH( in the database is + exactly the same as the state we have loaded. In other words, it is + impos)HY(si)HY(ble)YH( for another process or thread to modify the object state + in the database between these load and update oper)HY(a)HY(tions)YH(.)EP( + + )0 P(In this chapter we use the term )EM(appli)HY(ca)HY(tion)YH( trans)HY(ac)HY(tion)YH()ES( + to refer to a set of oper)HY(a)HY(tions)YH( on persis)HY(tent)YH( objects that an + appli)HY(ca)HY(tion)YH( needs to perform in order to imple)HY(ment)YH( some + appli)HY(ca)HY(tion)YH(-specific func)HY(tion)HY(al)HY(ity)YH(. The term )EM(database + trans)HY(ac)HY(tion)YH()ES( refers to the set of database oper)HY(a)HY(tions)YH( + performed between the ODB )SM(begin\201\202)ES( and )SM(commit\201\202)ES( + calls. Up until now we have treated appli)HY(ca)HY(tion)YH( trans)HY(ac)HY(tions)YH( and + database trans)HY(ac)HY(tions)YH( as essen)HY(tially)YH( the same thing.)EP( + + )0 P(While this model is easy to under)HY(stand)YH( and straight)HY(for)HY(ward)YH( to use, + it may not be suit)HY(able)YH( for appli)HY(ca)HY(tions)YH( that have long appli)HY(ca)HY(tion)YH( + trans)HY(ac)HY(tions)YH(. The canon)HY(i)HY(cal)YH( example of such a situ)HY(a)HY(tion)YH( is an + appli)HY(ca)HY(tion)YH( trans)HY(ac)HY(tion)YH( that requires user input between loading + an object and updat)HY(ing)YH( it. Such an oper)HY(a)HY(tion)YH( may take an arbi)HY(trary)YH( + long time to complete and perform)HY(ing)YH( it within a single database + trans)HY(ac)HY(tion)YH( will consume database resources as well as prevent + other processes/threads from updat)HY(ing)YH( the object for too long.)EP( + + )0 P(The solu)HY(tion)YH( to this problem is to break up the long-lived + appli)HY(ca)HY(tion)YH( trans)HY(ac)HY(tion)YH( into several short-lived database + trans)HY(ac)HY(tions)YH(. In our example that would mean loading the object + in one database trans)HY(ac)HY(tion)YH(, waiting for user input, and then + updat)HY(ing)YH( the object in another database trans)HY(ac)HY(tion)YH(. For example:)EP( + + ) 19 67 PR(unsigned long id = ...; +person p; + +{ + transaction t \201db.begin \201\202\202; + db.load \201id, p\202; + t.commit \201\202; +} + +cerr << "enter age for " << p.first \201\202 << " " << p.last \201\202 << endl; +unsigned short age; +cin >> age; +p.age \201age\202; + +{ + transaction t \201db.begin \201\202\202; + db.update \201p\202; + t.commit \201\202; +})RP( + + )0 P(This approach works well if we only have one process/thread that can ever + update the object. However, if we have multi)HY(ple)YH( processes/threads + modi)HY(fy)HY(ing)YH( the same object, then this approach does not guar)HY(an)HY(tee)YH( + consis)HY(tency)YH( anymore. Consider what happens in the above example if + another process updates the person's last name while we are waiting for + the user input. Since we loaded the object before this change occured, + our version of the person's data will still have the old name. Once we + receive the input from the user, we go ahead and update the object, + over)HY(writ)HY(ing)YH( both the old age with the new one \201correct\202 and the new name + with the old one \201incor)HY(rect)YH(\202.)EP( + + )0 P(While there is no way to restore the consis)HY(tency)YH( guar)HY(an)HY(tee)YH( in + an appli)HY(ca)HY(tion)YH( trans)HY(ac)HY(tion)YH( that consists of multi)HY(ple)YH( database + trans)HY(ac)HY(tions)YH(, ODB provides a mech)HY(a)HY(nism)YH(, called opti)HY(mistic)YH( + concur)HY(rency)YH(, that allows appli)HY(ca)HY(tions)YH( to detect and poten)HY(tially)YH( + recover from such incon)HY(sis)HY(ten)HY(cies)YH(.)EP( + + )0 P(In essence, the opti)HY(mistic)YH( concur)HY(rency)YH( model detects mismatches + between the current object state in the database and the state + when it was loaded into the appli)HY(ca)HY(tion)YH( memory. Such a mismatch + would mean that the object was changed by another process or + thread. There are several ways to imple)HY(ment)YH( such state mismatch + detec)HY(tion)YH(. Currently, ODB uses object version)HY(ing)YH( while other + methods, such as times)HY(tamps)YH(, may be supported in the future.)EP( + + )0 P(To declare a persis)HY(tent)YH( class with the opti)HY(mistic)YH( concur)HY(rency)YH( model we + use the )SM(opti)HY(mistic)YH()ES( pragma \201)0 106 1 A(Section 14.1.5, + ")SM(opti)HY(mistic)YH()ES(")106 0 TN TL()Ec /AF f D(\202. We also use the )SM(version)ES( + pragma \201)0 163 1 A(Section 14.4.16, ")SM(version)ES(")163 0 TN TL()Ec /AF f D(\202 + to specify which data member will store the object version. For + example:)EP( + + ) 8 28 PR(#pragma db object optimistic +class person +{ + ... + + #pragma db version + unsigned long version_; +};)RP( + + )0 P(The version data member is managed by ODB. It is initial)HY(ized)YH( to + )SM(1)ES( when the object is made persis)HY(tent)YH( and incre)HY(mented)YH( + by )SM(1)ES( with each update. The )SM(0)ES( version value + is not used by ODB and the appli)HY(ca)HY(tion)YH( can use it as a special value, + for example, to indi)HY(cate)YH( that the object is tran)HY(sient)YH(. Note that + for opti)HY(mistic)YH( concur)HY(rency)YH( to func)HY(tion)YH( prop)HY(erly)YH(, the appli)HY(ca)HY(tion)YH( + should not modify the version member after making the object persis)HY(tent)YH( + or loading it from the database and until delet)HY(ing)YH( the state of this + object from the database. To avoid any acci)HY(den)HY(tal)YH( modi)HY(fi)HY(ca)HY(tions)YH( + to the version member, we can declare it )SM(const)ES(, for + example:)EP( + + ) 8 31 PR(#pragma db object optimistic +class person +{ + ... + + #pragma db version + const unsigned long version_; +};)RP( + + )0 P(When we call the )SM(database::update\201\202)ES( func)HY(tion)YH( + \201)0 33 1 A(Section 3.10, "Updat)HY(ing)YH( Persis)HY(tent)YH( Objects")33 0 TN TL()Ec /AF f D(\202 and pass + an object that has an outdated state, the )SM(odb::object_changed)ES( + excep)HY(tion)YH( is thrown. At this point the appli)HY(ca)HY(tion)YH( has two + recov)HY(ery)YH( options: it can abort and poten)HY(tially)YH( restart the + appli)HY(ca)HY(tion)YH( trans)HY(ac)HY(tion)YH( or it can reload the new object + state from the database, re-apply or merge the changes, and call + )SM(update\201\202)ES( again. Note that abort)HY(ing)YH( an appli)HY(ca)HY(tion)YH( + trans)HY(ac)HY(tion)YH( that performs updates in multi)HY(ple)YH( database trans)HY(ac)HY(tions)YH( + may require revert)HY(ing)YH( changes that have already been commit)HY(ted)YH( to + the database. As a result, this strat)HY(egy)YH( works best if all the + updates are performed in the last database trans)HY(ac)HY(tion)YH( of the + appli)HY(ca)HY(tion)YH( trans)HY(ac)HY(tion)YH(. This way the changes can be reverted + by simply rolling back this last database trans)HY(ac)HY(tion)YH(.)EP( + + )0 P(The follow)HY(ing)YH( example shows how we can reim)HY(ple)HY(ment)YH( the above + trans)HY(ac)HY(tion)YH( using the second recov)HY(ery)YH( option:)EP( + + ) 30 67 PR(unsigned long id = ...; +person p; + +{ + transaction t \201db.begin \201\202\202; + db.load \201id, p\202; + t.commit \201\202; +} + +cerr << "enter age for " << p.first \201\202 << " " << p.last \201\202 << endl; +unsigned short age; +cin >> age; +p.age \201age\202; + +{ + transaction t \201db.begin \201\202\202; + + try + { + db.update \201p\202; + } + catch \201const object_changed&\202 + { + db.reload \201p\202; + p.age \201age\202; + db.update \201p\202; + } + + t.commit \201\202; +})RP( + + )0 P(An impor)HY(tant)YH( point to note in the above code frag)HY(ment)YH( is that the second + )SM(update\201\202)ES( call cannot throw the )SM(object_changed)ES( + excep)HY(tion)YH( because we are reload)HY(ing)YH( the state of the object + and updat)HY(ing)YH( it within the same database trans)HY(ac)HY(tion)YH(.)EP( + + )0 P(Depend)HY(ing)YH( on the recov)HY(ery)YH( strat)HY(egy)YH( employed by the appli)HY(ca)HY(tion)YH(, + an appli)HY(ca)HY(tion)YH( trans)HY(ac)HY(tion)YH( with a failed update can be signif)HY(i)HY(cantly)YH( + more expen)HY(sive)YH( than a success)HY(ful)YH( one. As a result, opti)HY(mistic)YH( + concur)HY(rency)YH( works best for situ)HY(a)HY(tions)YH( with low to medium contention + levels where the major)HY(ity)YH( of the appli)HY(ca)HY(tion)YH( trans)HY(ac)HY(tions)YH( complete + without update conflicts. This is also the reason why this concur)HY(rency)YH( + model is called opti)HY(mistic)YH(.)EP( + + )0 P(In addi)HY(tion)YH( to updates, ODB also performs state mismatch detec)HY(tion)YH( + when we are delet)HY(ing)YH( an object from the database + \201)0 34 1 A(Section 3.11, "Delet)HY(ing)YH( Persis)HY(tent)YH( Objects")34 0 TN TL()Ec /AF f D(\202. + To under)HY(stand)YH( why this can be impor)HY(tant)YH(, consider the follow)HY(ing)YH( + appli)HY(ca)HY(tion)YH( trans)HY(ac)HY(tion)YH(:)EP( + + ) 19 53 PR(unsigned long id = ...; +person p; + +{ + transaction t \201db.begin \201\202\202; + db.load \201id, p\202; + t.commit \201\202; +} + +string answer; +cerr << "age is " << p.age \201\202 << ", delete?" << endl; +getline \201cin, answer\202; + +if \201answer == "yes"\202 +{ + transaction t \201db.begin \201\202\202; + db.erase \201p\202; + t.commit \201\202; +})RP( + + )0 P(Consider again what happens if another process or thread updates + the object by chang)HY(ing)YH( the person's age while we are waiting for + the user input. In this case, the user makes the deci)HY(sion)YH( based on + a certain age while we may delete \201or not delete\202 an object that has + a completely differ)HY(ent)YH( age. Here is how we can fix this problem + using opti)HY(mistic)YH( concur)HY(rency)YH(:)EP( + + ) 38 71 PR(unsigned long id = ...; +person p; + +{ + transaction t \201db.begin \201\202\202; + db.load \201id, p\202; + t.commit \201\202; +} + +string answer; +for \201bool done \201false\202; !done; \202 +{ + if \201answer.empty \201\202\202 + cerr << "age is " << p.age \201\202 << ", delete?" << endl; + else + cerr << "age changed to " << p.age \201\202 << ", still delete?" << endl; + + getline \201cin, answer\202; + + if \201answer == "yes"\202 + { + transaction t \201db.begin \201\202\202; + + try + { + db.erase \201p\202; + done = true; + } + catch \201const object_changed&\202 + { + db.reload \201p\202;)WR( + } + + t.commit \201\202; + } + else + done = true; +})RP( + + )0 P(Note that state mismatch detec)HY(tion)YH( is performed only if we delete + an object by passing the object instance to the )SM(erase\201\202)ES( + func)HY(tion)YH(. If we want to delete an object with the opti)HY(mistic)YH( concur)HY(rency)YH( + model regard)HY(less)YH( of its state, then we need to use the )SM(erase\201\202)ES( + func)HY(tion)YH( that deletes an object given its id, for example:)EP( + + ) 5 30 PR({ + transaction t \201db.begin \201\202\202; + db.erase \201p.id \201\202\202; + t.commit \201\202; +})RP( + + )0 P(Finally, note that for persis)HY(tent)YH( classes with the opti)HY(mistic)YH( concur)HY(rency)YH( + model both the )SM(update\201\202)ES( func)HY(tion)YH( as well as the + )SM(erase\201\202)ES( func)HY(tion)YH( that accepts an object instance as its + argu)HY(ment)YH( no longer throw the )SM(object_not_persis)HY(tent)YH()ES( + excep)HY(tion)YH( if there is no such object in the database. Instead, + this condi)HY(tion)YH( is treated as a change of object state and the + )SM(object_changed)ES( excep)HY(tion)YH( is thrown instead.)EP( + + )0 P(For complete sample code that shows how to use opti)HY(mistic)YH( + concur)HY(rency)YH(, refer to the )SM(opti)HY(mistic)YH()ES( example in + the )SM(odb-exam)HY(ples)YH()ES( package.)EP( + + + + + + )WB NL NP( + )0 1 87 H(13)WB 412 Sn()WB 91 Sn( Database Schema Evolu)HY(tion)YH()EA()EH( + + )0 P(When we add new persis)HY(tent)YH( classes or change the exist)HY(ing)YH( ones, for + example, by adding or delet)HY(ing)YH( data members, the database schema + neces)HY(sary)YH( to store the new object model changes as well. At the + same time, we may have exist)HY(ing)YH( databases that contain exist)HY(ing)YH( data. + If new versions of your appli)HY(ca)HY(tion)YH( don't need to handle + old databases, then the schema creat)HY(ing)YH( func)HY(tion)HY(al)HY(ity)YH( is all that + you need. However, most appli)HY(ca)HY(tions)YH( will need to work with data + stored by older versions of the same appli)HY(ca)HY(tion)YH(.)EP( + + )0 P(We will call )EM(database schema evolu)HY(tion)YH()ES( the overall task + of updat)HY(ing)YH( the database to match the changes in the object model. + Schema evolu)HY(tion)YH( usually consists of two sub-tasks: )EM(schema + migra)HY(tion)YH()ES( and )EM(data migra)HY(tion)YH()ES(. Schema migra)HY(tion)YH( + modi)HY(fies)YH( the database schema to corre)HY(spond)YH( to the current + object model. In a rela)HY(tional)YH( database, this, for example, could + require adding or drop)HY(ping)YH( tables and columns. The data migra)HY(tion)YH( + task involves convert)HY(ing)YH( the data stored in the exist)HY(ing)YH( database + from the old format to the new one.)EP( + + )0 P(If performed manu)HY(ally)YH(, database schema evolu)HY(tion)YH( is a tedious and + error-prone task. As a result, ODB provides compre)HY(hen)HY(sive)YH( support + for auto)HY(mated)YH( or, more precisely, semi-auto)HY(mated)YH( schema + evolu)HY(tion)YH(. Specif)HY(i)HY(cally)YH(, ODB does fully-auto)HY(matic)YH( schema + migra)HY(tion)YH( and provides facil)HY(i)HY(ties)YH( to help you with data + migra)HY(tion)YH(.)EP( + + )0 P(The topic of schema evolu)HY(tion)YH( is a complex and sensi)HY(tive)YH( + issue since normally there would be valu)HY(able)YH(, produc)HY(tion)YH( data at + stake. As a result, the approach taken by ODB is to provide simple + and bullet-proof elemen)HY(tary)YH( build)HY(ing)YH( blocks \201or migra)HY(tion)YH( steps\202 + that we can under)HY(stand)YH( and trust. Using these elemen)HY(tary)YH( blocks we + can then imple)HY(ment)YH( more complex migra)HY(tion)YH( scenar)HY(ios)YH(. In partic)HY(u)HY(lar)YH(, + ODB does not try to handle data migra)HY(tion)YH( auto)HY(mat)HY(i)HY(cally)YH( since in most + cases this requires under)HY(stand)HY(ing)YH( of appli)HY(ca)HY(tion)YH(-specific seman)HY(tics)YH(. + In other words, there is no magic.)EP( + + )0 P(There are two general approaches to working with older data: the + appli)HY(ca)HY(tion)YH( can either convert it to corre)HY(spond)YH( to the new format + or it can be made capable of working with multi)HY(ple)YH( versions of this + format. There is also a hybrid approach where the appli)HY(ca)HY(tion)YH( + may convert the data to the new format grad)HY(u)HY(ally)YH( as part of its + normal func)HY(tion)HY(al)HY(ity)YH(. ODB is capable of handling all these + scenar)HY(ios)YH(. That is, there is support for working with older + models without perform)HY(ing)YH( any migra)HY(tion)YH( \201schema or data\202. + Alter)HY(na)HY(tively)YH(, we can migrate the schema after + which we have the choice of either also imme)HY(di)HY(ately)YH( migrat)HY(ing)YH( the + data \201)EM(imme)HY(di)HY(ate)YH( data migra)HY(tion)YH()ES(\202 or doing it grad)HY(u)HY(ally)YH( + \201)EM(gradual data migra)HY(tion)YH()ES(\202.)EP( + + )0 P(Schema evolu)HY(tion)YH( is already a complex task and we should not + unnec)HY(es)HY(sar)HY(ily)YH( use a more complex approach where a simpler one + would be suffi)HY(cient)YH(. From the above, the simplest approach is + the imme)HY(di)HY(ate)YH( schema migra)HY(tion)YH( that does not require any data + migra)HY(tion)YH(. An example of such a change would be adding a new + data member with the default value \201)0 129 1 A(Section + 14.3.4, ")SM(default)ES(")129 0 TN TL()Ec /AF f D(\202. This case ODB can handle + completely auto)HY(mat)HY(i)HY(cally)YH(.)EP( + + )0 P(If we do require data migra)HY(tion)YH(, then the next simplest approach + is the imme)HY(di)HY(ate)YH( schema and data migra)HY(tion)YH(. Here we have to write + custom migra)HY(tion)YH( code. However, it is sepa)HY(rate)YH( from the rest of + the core appli)HY(ca)HY(tion)YH( logic and is executed at a well defined point + \201database migra)HY(tion)YH(\202. In other words, the core appli)HY(ca)HY(tion)YH( logic + need not be aware of older model versions. The poten)HY(tial)YH( draw)HY(back)YH( + of this approach is perfor)HY(mance)YH(. It may take a lot of resources + and/or time to convert all the data upfront.)EP( + + )0 P(If the imme)HY(di)HY(ate)YH( migra)HY(tion)YH( is not possi)HY(ble)YH(, then the next option + is the imme)HY(di)HY(ate)YH( schema migra)HY(tion)YH( followed by the gradual data + migra)HY(tion)YH(. With this approach, both old and new data must co-exist + in the new database. We also have to change the appli)HY(ca)HY(tion)YH( + logic to both account for differ)HY(ent)YH( sources of the same data \201for + example, when either an old or new version of the object is loaded\202 + as well as migrate the data when appro)HY(pri)HY(ate)YH( \201for example, when + the old version of the object is updated\202. At some point, usually + when the major)HY(ity)YH( of the data has been converted, gradual migra)HY(tions)YH( + are termi)HY(nated)YH( with an imme)HY(di)HY(ate)YH( migra)HY(tion)YH(.)EP( + + )0 P(The most complex approach is working with multi)HY(ple)YH( versions of + the database without perform)HY(ing)YH( any migra)HY(tions)YH(, schema or data. + ODB does provide support for imple)HY(ment)HY(ing)YH( this approach + \201)0 97 1 A(Section 13.4, "Soft Object Model Changes")97 0 TN TL()Ec /AF f D(\202, + however we will not cover it any further in this chapter. + Gener)HY(ally)YH(, this will require embed)HY(ding)YH( knowl)HY(edge)YH( about each + version into the core appli)HY(ca)HY(tion)YH( logic which makes it hard + to main)HY(tain)YH( for any non-trivial object model.)EP( + + )0 P(Note also that when it comes to data migra)HY(tion)YH(, we can use + the imme)HY(di)HY(ate)YH( variant for some changes and gradual for others. + We will discuss various migra)HY(tion)YH( scenar)HY(ios)YH( in greater detail + in section )0 94 1 A(Section 13.3, "Data Migra)HY(tion)YH(")94 0 TN TL()Ec /AF f D(.)EP( + + )0 2 88 H(13.1)WB 413 Sn()WB 92 Sn( Object Model Version and Changelog)EA()EH( + + )0 P(To enable schema evolu)HY(tion)YH( support in ODB we need to specify + the object model version, or, more precisely, two versions. + The first is the base model version. It is the lowest + version from which we will be able to migrate. The second + version is the current model version. In ODB we can migrate + from multi)HY(ple)YH( previ)HY(ous)YH( versions by succes)HY(sively)YH( migrat)HY(ing)YH( + from one to the next until we reach the current version. + We use the )SM(db\240model\240version)ES( pragma + to specify both the base and current versions.)EP( + + )0 P(When we enable schema evolu)HY(tion)YH( for the first time, our + base and current versions will be the same, for example:)EP( + + ) 1 30 PR(#pragma db model version\2011, 1\202)RP( + + )0 P(Once we release our appli)HY(ca)HY(tion)YH(, its users may create databases + with the schema corre)HY(spond)HY(ing)YH( to this version of the object + model. This means that if we make any modi)HY(fi)HY(ca)HY(tions)YH( to our + object model that also change the schema, then we will need + to be able to migrate the old databases to this new schema. + As a result, before making any new changes after a release, + we incre)HY(ment)YH( the current version, for example:)EP( + + ) 1 30 PR(#pragma db model version\2011, 2\202)RP( + + )0 P(To put this another way, we can stay on the same version + during devel)HY(op)HY(ment)YH( and keep adding new changes to it. But + once we release it, any new changes to the object model will + have to be done in a new version.)EP( + + )0 P(It is easy to forget to incre)HY(ment)YH( the version before + making new changes to the object model. To help solve this + problem, the )SM(db\240model\240version)ES( pragma + accepts a third optional argu)HY(ment)YH( that specify whether the + current version is open or closed for changes. For example:)EP( + + ) 2 64 PR(#pragma db model version\2011, 2, open\202 // Can add new changes to + // version 2.)RP( + + ) 2 63 PR(#pragma db model version\2011, 2, closed\202 // Can no longer add new + // changes to version 2.)RP( + + )0 P(If the current version is closed, ODB will refuse to accept + any new schema changes. In this situ)HY(a)HY(tion)YH( you would + normally incre)HY(ment)YH( the current version and mark it as open + or you could re-open the exist)HY(ing)YH( version if, for example, + you need to fix some)HY(thing)YH(. Note, however, that re-opening + versions that have been released will most likely result + in migra)HY(tion)YH( malfunc)HY(tions)YH(. By default the version is open.)EP( + + )0 P(Normally, an appli)HY(ca)HY(tion)YH( will have a range of older database + versions from which it is able to migrate. When we change + this range by remov)HY(ing)YH( support for older versions, we also + need to adjust the base model version. This will make sure + that ODB does not keep unnec)HY(es)HY(sary)YH( infor)HY(ma)HY(tion)YH( around.)EP( + + )0 P(A model version \201both base and current\202 is a 64-bit unsigned + integer \201)SM(unsigned\240long\240long)ES(\202. )SM(0)ES( + is reserved to signify special situ)HY(a)HY(tions)YH(, such as the lack of + schema in the database. Other than that, we can use any values + as versions as long as they are mono)HY(ton)HY(i)HY(cally)YH( increas)HY(ing)YH(. In + partic)HY(u)HY(lar)YH(, we don't have to start with version )SM(1)ES( + and can increase the versions by any incre)HY(ment)YH(.)EP( + + )0 P(One version)HY(ing)YH( approach is to use an inde)HY(pen)HY(dent)YH( + object model version by start)HY(ing)YH( from version )SM(1)ES( + and also incre)HY(ment)HY(ing)YH( by )SM(1)ES(. The alter)HY(na)HY(tive)YH( + is to make the model version corre)HY(spond)YH( to the appli)HY(ca)HY(tion)YH( + version. For example, if our appli)HY(ca)HY(tion)YH( is using the + )SM(X.Y.Z)ES( version format, then we could encode it + as a hexadec)HY(i)HY(mal)YH( number and use that as our model version, + for example:)EP( + + ) 1 59 PR(#pragma db model version\2010x020000, 0x020306\202 // 2.0.0-2.3.6)RP( + + )0 P(Most real-world object models will be spread over multi)HY(ple)YH( + header files and it will be burden)HY(some)YH( to repeat the + )SM(db\240model\240version)ES( pragma in each of + them. The recom)HY(mended)YH( way to handle this situ)HY(a)HY(tion)YH( is to + place the )SM(version)ES( pragma into a sepa)HY(rate)YH( header + file and include it into the object model files. If your + project already has a header file that defines the + appli)HY(ca)HY(tion)YH( version, then it is natural to place this + pragma there. For example:)EP( + + ) 10 39 PR(// version.hxx +// +// Define the application version. +// + +#define MYAPP_VERSION 0x020306 // 2.3.6 + +#ifdef ODB_COMPILER +#pragma db model version\2011, 7\202 +#endif)RP( + + )0 P(Note that we can also use macros in the )SM(version)ES( + pragma which allows us to specify all the versions in a single + place. For example:)EP( + + ) 6 59 PR(#define MYAPP_VERSION 0x020306 // 2.3.6 +#define MYAPP_BASE_VERSION 0x020000 // 2.0.0 + +#ifdef ODB_COMPILER +#pragma db model version\201MYAPP_BASE_VERSION, MYAPP_VERSION\202 +#endif)RP( + + )0 P(It is also possi)HY(ble)YH( to have multi)HY(ple)YH( object models within the + same appli)HY(ca)HY(tion)YH( that have differ)HY(ent)YH( versions. Such models + must be inde)HY(pen)HY(dent)YH(, that is, no headers from one model shall + include a header from another. You will also need to assign + differ)HY(ent)YH( schema names to each model with the + )SM(--schema-name)ES( ODB compiler option.)EP( + + )0 P(Once we specify the object model version, the ODB compiler + starts track)HY(ing)YH( database schema changes in a changelog file. + Changelog has an XML-based, line-oriented format. It uses + XML in order to provide human read)HY(abil)HY(ity)YH( while also + facil)HY(i)HY(tat)HY(ing)YH(, if desired, process)HY(ing)YH( and anal)HY(y)HY(sis)YH( with + custom tools. The line orien)HY(ta)HY(tion)YH( makes it easy to review + with tools like )SM(diff)ES(.)EP( + + )0 P(The changelog is main)HY(tained)YH( by the ODB compiler. Specif)HY(i)HY(cally)YH(, + you do not need to make any manual changes to this file. You + will, however, need to keep it around from one invo)HY(ca)HY(tion)YH( of + the ODB compiler to the next. In other words, the changelog + file is both the input and the output of the ODB compiler. This, + for example, means that if your project's source code is stored + in a version control repos)HY(i)HY(tory)YH(, then you will most likely want + to store the changelog there as well. If you delete the changelog, + then any ability to do schema migra)HY(tion)YH( will be lost.)EP( + + )0 P(The only oper)HY(a)HY(tion)YH( that you may want to perform with the + changelog is to review the database schema changes that resulted + from the C++ object model changes. For this you can use a tool + like )SM(diff)ES( or, better yet, the change review facil)HY(i)HY(ties)YH( + offered by your revi)HY(sion)YH( control system. For this purpose the + contents of a changelog will be self-explana)HY(tory)YH(.)EP( + + )0 P(As an example, consider the follow)HY(ing)YH( initial object model:)EP( + + ) 18 30 PR(// person.hxx +// + +#include + +#pragma db model version\2011, 1\202 + +#pragma db object +class person +{ + ... + + #pragma db id auto + unsigned long id_; + + std::string first_; + std::string last_; +};)RP( + + )0 P(We then compile this header file with the ODB compiler \201using the + Post)HY(greSQL)YH( database as an example\202:)EP( + + ) 1 49 PR(odb --database pgsql --generate-schema person.hxx)RP( + + )0 P(If we now look at the list of gener)HY(ated)YH( files, then in addi)HY(tion)YH( to + the now famil)HY(iar)YH( )SM(person-odb.?xx)ES( and )SM(person.sql)ES(, + we will also see )SM(person.xml)ES( \236 the changelog file. + Just for illus)HY(tra)HY(tion)YH(, below are the contents of this changelog.)EP( + + ) 12 53 PR( + + + + + + + + +
+ +)RP( + + )0 P(Let's say we now would like to add another data member to the + )SM(person)ES( class \236 the middle name. We incre)HY(ment)YH( + the version and make the change:)EP( + + ) 14 30 PR(#pragma db model version\2011, 2\202 + +#pragma db object +class person +{ + ... + + #pragma db id auto + unsigned long id_; + + std::string first_; + std::string middle_; + std::string last_; +};)RP( + + )0 P(We use exactly the same command line to re-compile our file:)EP( + + ) 1 49 PR(odb --database pgsql --generate-schema person.hxx)RP( + + )0 P(This time the ODB compiler will read the old changelog, update + it, and write out the new version. Again, for illus)HY(tra)HY(tion)YH( only, + below are the updated changelog contents:)EP( + + ) 18 58 PR( + + + + + + + + + + + + + + +
+ +)RP( + + )0 P(Just to reit)HY(er)HY(ate)YH(, while the changelog may look like it could + be written by hand, it is main)HY(tained)YH( completely auto)HY(mat)HY(i)HY(cally)YH( + by the ODB compiler and the only reason you may want to look + at its contents is to review the database schema changes. For + example, if we compare the above two changel)HY(ogs)YH( with + )SM(diff)ES(, we will get the follow)HY(ing)YH( summary of the + database schema changes:)EP( + + ) 13 59 PR(--- person.xml.orig ++++ person.xml +@@ -1,4 +1,10 @@ + ++ ++ ++ ++ ++ ++ + + + )RP( + + )0 P(The changelog is only written when we gener)HY(ate)YH( the database schema, + that is, the )SM(--gener)HY(ate)YH(-schema)ES( option is spec)HY(i)HY(fied)YH(. + Invo)HY(ca)HY(tions)YH( of the ODB compiler that only produce the database + support code \201C++\202 do not read or update the changelog. To put it + another way, the changelog tracks changes in the result)HY(ing)YH( database + schema, not the C++ object model.)EP( + + )0 P(ODB ignores column order when compar)HY(ing)YH( database schemas. This means + that we can re-order data members in a class without causing any + schema changes. Member renames, however, will result in schema + changes since the column name changes as well \201unless we spec)HY(i)HY(fied)YH( + the column name explic)HY(itly)YH(\202. From ODB's perspec)HY(tive)YH( such a rename + looks like the dele)HY(tion)YH( of one data member and the addi)HY(tion)YH( of + another. If we don't want this to be treated as a schema change, + then we will need to keep the old column name by explic)HY(itly)YH( + spec)HY(i)HY(fy)HY(ing)YH( it with the )SM(db\240column)ES( pragma. For + example, here is how we can rename )SM(middle_)ES( to + )SM(middle_name_)ES( without causing any schema changes:)EP( + + ) 12 63 PR(#pragma db model version\2011, 2\202 + +#pragma db object +class person +{ + ... + + #pragma db column\201"middle"\202 // Keep the original column name. + std::string middle_name_; + + ... +};)RP( + + )0 P(If your object model consists of a large number of header files and + you gener)HY(ate)YH( the database schema for each of them indi)HY(vid)HY(u)HY(ally)YH(, then + a changelog will be created for each of your header files. This may + be what you want, however, the large number of changel)HY(ogs)YH( can quickly + become unwieldy. In fact, if you are gener)HY(at)HY(ing)YH( the database schema + as stan)HY(dalone)YH( SQL files, then you may have already expe)HY(ri)HY(enced)YH( a + similar problem caused by a large number of )SM(.sql)ES( files, + one for each header.)EP( + + )0 P(The solu)HY(tion)YH( to both of these prob)HY(lems)YH( is to gener)HY(ate)YH( a combined + database schema file and a single changelog. For example, assume + we have three header files in our object model: + )SM(person.hxx)ES(, )SM(employee.hxx)ES(, and + )SM(employer.hxx)ES(. To gener)HY(ate)YH( the database support code + we compile them as usual but without spec)HY(i)HY(fy)HY(ing)YH( the + )SM(--gener)HY(ate)YH(-schema)ES( option. In this case no changelog + is created or updated:)EP( + + ) 3 33 PR(odb --database pgsql person.hxx +odb --database pgsql employee.hxx +odb --database pgsql employer.hxx)RP( + + )0 P(To gener)HY(ate)YH( the database schema, we perform a sepa)HY(rate)YH( invo)HY(ca)HY(tion)YH( + of the ODB compiler. This time, however, we instruct it to only + gener)HY(ate)YH( the schema \201)SM(--gener)HY(ate)YH(-schema-only)ES(\202 and + produce it combined \201)SM(--at-once)ES(\202 for all the files + in our object model:)EP( + + ) 2 57 PR(odb --database pgsql --generate-schema-only --at-once \200 +--input-name company person.hxx employee.hxx employer.hxx)RP( + + )0 P(The result of the above command is a single )SM(company.sql)ES( + file \201the name is derived from the )SM(--input-name)ES( value\202 + that contains the database schema for our entire object model. There + is also a single corre)HY(spond)HY(ing)YH( changelog file \236 + )SM(company.xml)ES(.)EP( + + )0 P(The same can be achieved for the embed)HY(ded)YH( schema by instruct)HY(ing)YH( + the ODB compiler to gener)HY(ate)YH( the database creation code into a + sepa)HY(rate)YH( C++ file \201)SM(--schema-format\240sepa)HY(rate)YH()ES(\202:)EP( + + ) 2 70 PR(odb --database pgsql --generate-schema-only --schema-format separate \200 +--at-once --input-name company person.hxx employee.hxx employer.hxx)RP( + + )0 P(The result of this command is a single )SM(company-schema.cxx)ES( + file and, again, )SM(company.xml)ES(.)EP( + + )0 P(Note also that by default the changelog file is not placed into + the direc)HY(tory)YH( spec)HY(i)HY(fied)YH( with the )SM(--output-dir)ES( option. + This is due to the changelog being both an input and an output file + at the same time. As a result, by default, the ODB compiler will + place it in the direc)HY(tory)YH( of the input header file.)EP( + + )0 P(There is, however, a number of command line options \201includ)HY(ing)YH( + )SM(--changelog-dir)ES(\202 that allow us to fine-tune the name and + loca)HY(tion)YH( of the changelog file. For example, you can instruct the ODB + compiler to read the changelog from one file while writing it to + another. This, for example, can be useful if you want to review + the changes before discard)HY(ing)YH( the old file. For more infor)HY(ma)HY(tion)YH( + on these options, refer to the + )R1 2 A(ODB + Compiler Command Line Manual)EA( and search for "changelog".)EP( + + )0 P(When we were discussing version incre)HY(ments)YH( above, we used the + terms )EM(devel)HY(op)HY(ment)YH()ES( and )EM(release)ES(. Specif)HY(i)HY(cally)YH(, + we talked about keeping the same object model versions during + devel)HY(op)HY(ment)YH( periods and incre)HY(ment)HY(ing)YH( them after releases. + What is a devel)HY(op)HY(ment)YH( period and a release in this context? + These defi)HY(ni)HY(tions)YH( can vary from project to project. + Gener)HY(ally)YH(, during a devel)HY(op)HY(ment)YH( period we work on one or + more changes to the object model that result in the changes + to the database schema. A release is a point where we + make our changes avail)HY(able)YH( to someone else who may have an + older database to migrate from. In the tradi)HY(tional)YH( sense, a release + is a point where you make a new version of your appli)HY(ca)HY(tion)YH( avail)HY(able)YH( + to its users. However, for schema evolu)HY(tion)YH( purposes, a release + could also mean simply making your schema-alter)HY(ing)YH( changes + avail)HY(able)YH( to other devel)HY(op)HY(ers)YH( on your team. Let us consider + two common scenar)HY(ios)YH( to illus)HY(trate)YH( how all this fits together.)EP( + + )0 P(One way to setup a project would be to re-use the appli)HY(ca)HY(tion)YH( + devel)HY(op)HY(ment)YH( period and appli)HY(ca)HY(tion)YH( release for schema evolu)HY(tion)YH(. + That is, during a new appli)HY(ca)HY(tion)YH( version devel)HY(op)HY(ment)YH( we keep + a single object model version and when we release the appli)HY(ca)HY(tion)YH(, + we incre)HY(ment)YH( the model version. In this case it makes sense to + also reuse the appli)HY(ca)HY(tion)YH( version as a model version for + consis)HY(tency)YH(. Here is a step-by-step guide for this setup:)EP( + + )4 OL( )-1 LI(During devel)HY(op)HY(ment)YH(, keep the current object model version open. + + )-1 LI(Before the release \201for example, when enter)HY(ing)YH( a "feature freeze"\202 + close the version. + + )-1 LI(After the release, update the version and open it. + + )-1 LI(For each new feature, review the change)HY(set)YH( at the top of the + changelog, for example, with )SM(diff)ES( or your + version control facil)HY(i)HY(ties)YH(. If you are using a version + control, then this is best done just before commit)HY(ting)YH( + your changes to the repos)HY(i)HY(tory)YH(. + )LO( + + )0 P(An alter)HY(na)HY(tive)YH( way to setup schema version)HY(ing)YH( in a project would + be to define the devel)HY(op)HY(ment)YH( period as working on a single + feature and the release as making this feature avail)HY(able)YH( to + other people \201devel)HY(op)HY(ers)YH(, testers, etc.\202 on your team, for + example, by commit)HY(ting)YH( the changes to a public version control + repos)HY(i)HY(tory)YH(. In this case, the object model version will be + inde)HY(pen)HY(dent)YH( of the appli)HY(ca)HY(tion)YH( version and can simply be + a sequence that starts with )SM(1)ES( and is + incre)HY(mented)YH( by )SM(1)ES(. Here is a step-by-step guide + for this setup:)EP( + + )4 OL( )-1 LI(Keep the current model version closed. Once a change is made + that affects the database schema, the ODB compiler will refuse + to update the changelog. + + )-1 LI(If the change is legit)HY(i)HY(mate)YH(, open a new version, that is, + incre)HY(ment)YH( the current version and make it open. + + )-1 LI(Once the feature is imple)HY(mented)YH( and tested, review the final + set of database changes \201with )SM(diff)ES( or your + version control facil)HY(i)HY(ties)YH(\202, close the version, and commit + the changes to the version control repos)HY(i)HY(tory)YH( \201if using\202. + )LO( + + )0 P(If you are using a version control repos)HY(i)HY(tory)YH( that supports + pre-commit checks, then you may want to consider adding such + a check to make sure the commit)HY(ted)YH( version is always closed.)EP( + + )0 P(If we are just start)HY(ing)YH( schema evolu)HY(tion)YH( in our project, which + approach should we choose? The two approaches will work better + in differ)HY(ent)YH( situ)HY(a)HY(tions)YH( since they have a differ)HY(ent)YH( set of + advan)HY(tages)YH( and disad)HY(van)HY(tages)YH(. The first approach, which we + can call version per appli)HY(ca)HY(tion)YH( release, is best suited + for simpler projects with smaller releases since other)HY(wise)YH( + a single migra)HY(tion)YH( will bundle a large number of unre)HY(lated)YH( + actions corre)HY(spond)HY(ing)YH( to differ)HY(ent)YH( features. This can + become diffi)HY(cult)YH( to review and, if things go wrong, debug.)EP( + + )0 P(The second approach, which we can call version per feature, + is much more modular and provides a number of addi)HY(tional)YH( bene)HY(fits)YH(. + We can perform migra)HY(tions)YH( for each feature as a discreet step + which makes it easier to debug. We can also place each such + migra)HY(tion)YH( step into a sepa)HY(rate)YH( trans)HY(ac)HY(tion)YH( further improv)HY(ing)YH( + reli)HY(a)HY(bil)HY(ity)YH(. It also scales much better in larger teams + where multi)HY(ple)YH( devel)HY(op)HY(ers)YH( can work concur)HY(rently)YH( on features + that affect the database schema. For example, if you find + your)HY(self)YH( in a situ)HY(a)HY(tion)YH( where another devel)HY(oper)YH( on your + team used the same version as you and managed to commit his + changes before you \201that is, you have a merge conflict\202, + then you can simply change the version to the next avail)HY(able)YH( + one, regen)HY(er)HY(ate)YH( the changelog, and continue with your commit.)EP( + + )0 P(Overall, unless you have strong reasons to prefer the version + per appli)HY(ca)HY(tion)YH( release approach, rather choose version per + feature even though it may seem more complex at the + begin)HY(ning)YH(. Also, if you do select the first approach, consider + provi)HY(sion)HY(ing)YH( for switch)HY(ing)YH( to the second method by reserv)HY(ing)YH( + a sub-version number. For example, for an appli)HY(ca)HY(tion)YH( version + in the form )SM(2.3.4)ES( you can make the object model + version to be in the form )SM(0x0203040000)ES(, reserv)HY(ing)YH( + the last two bytes for a sub-version. Later on you can use it to + switch to the version per feature approach.)EP( + + )0 2 89 H(13.2)WB 414 Sn()WB 93 Sn( Schema Migra)HY(tion)YH()EA()EH( + + )0 P(Once we enable schema evolu)HY(tion)YH( by spec)HY(i)HY(fy)HY(ing)YH( the object model + version, in addi)HY(tion)YH( to the schema creation state)HY(ments)YH(, the + ODB compiler starts gener)HY(at)HY(ing)YH( schema migra)HY(tion)YH( state)HY(ments)YH( + for each version all the way from the base to the current. + As with schema creation, schema migra)HY(tion)YH( can be gener)HY(ated)YH( + either as a set of SQL files or embed)HY(ded)YH( into the gener)HY(ated)YH( + C++ code \201)SM(--schema-format)ES( option\202.)EP( + + )0 P(For each migra)HY(tion)YH( step, that is from one version to the next, + ODB gener)HY(ates)YH( two sets of state)HY(ments)YH(: pre-migra)HY(tion)YH( and + post-migra)HY(tion)YH(. The pre-migra)HY(tion)YH( state)HY(ments)YH( )EM("relax")ES( + the database schema so that both old and new data can co-exist. + At this stage new columns and tables are added while old + constraints are dropped. The post-migra)HY(tion)YH( state)HY(ments)YH( + )EM("tighten")ES( the database schema back so that only + data conform)HY(ing)YH( to the new format can remain. At this stage + old columns and tables are dropped and new constraints are + added. Now you can prob)HY(a)HY(bly)YH( guess where the data + migra)HY(tion)YH( fits into this \236 between the pre and post + schema migra)HY(tions)YH( where we can both access the old data + and create the new one.)EP( + + )0 P(If the schema is being gener)HY(ated)YH( as stan)HY(dalone)YH( SQL files, + then we end up with a pair of files for each step: the pre-migra)HY(tion)YH( + file and the post-migra)HY(tion)YH( file. For the )SM(person)ES( + example we started in the previ)HY(ous)YH( section we will have the + )SM(person-002-pre.sql)ES( and )SM(person-002-post.sql)ES( + files. Here )SM(002)ES( is the version )EM(to)ES( which + we are migrat)HY(ing)YH( while the )SM(pre)ES( and )SM(post)ES( + suffixes specify the migra)HY(tion)YH( stage. So if we wanted to migrate + a )SM(person)ES( database from version )SM(1)ES( + to )SM(2)ES(, then we would first execute + )SM(person-002-pre.sql)ES(, then migrate the data, if any + \201discussed in more detail in the next section\202, and finally + execute )SM(person-002-post.sql)ES(. If our database is + several versions behind, for example the database has version + )SM(1)ES( while the current version is )SM(5)ES(, + then we simply perform this set of steps for each version + until we reach the current version.)EP( + + )0 P(If we look at the contents of the )SM(person-002-pre.sql)ES( + file, we will see the follow)HY(ing)YH( \201or equiv)HY(a)HY(lent)YH(, depend)HY(ing)YH( on the + database used\202 state)HY(ment)YH(:)EP( + + ) 2 32 PR(ALTER TABLE "person" + ADD COLUMN "middle" TEXT NULL;)RP( + + )0 P(As we would expect, this state)HY(ment)YH( adds a new column corre)HY(spond)HY(ing)YH( + to the new data member. An obser)HY(vant)YH( reader would notice, + however, that the column is added as )SM(NULL)ES( + even though we never requested this seman)HY(tics)YH( in our object model. + Why is the column added as )SM(NULL)ES(? If during migra)HY(tion)YH( + the )SM(person)ES( table already contains rows \201that is, exist)HY(ing)YH( + objects\202, then an attempt to add a non-)SM(NULL)ES( column that + doesn't have a default value will fail. As a result, ODB will initially + add a new column that doesn't have a default value as )SM(NULL)ES( + but then clean this up at the post-migra)HY(tion)YH( stage. This way your data + migra)HY(tion)YH( code is given a chance to assign some mean)HY(ing)HY(ful)YH( values for + the new data member for all the exist)HY(ing)YH( objects. Here are the contents + of the )SM(person-002-post.sql)ES( file:)EP( + + ) 2 37 PR(ALTER TABLE "person" + ALTER COLUMN "middle" SET NOT NULL;)RP( + + )0 P(Currently ODB directly supports the follow)HY(ing)YH( elemen)HY(tary)YH( database + schema changes:)EP( + + )UL( )-1 LI(add table + )-1 LI(drop table + )-1 LI(add column + )-1 LI(drop column + )-1 LI(alter column, set )SM(NULL)ES(/)SM(NOT NULL)ES( + )-1 LI(add foreign key + )-1 LI(drop foreign key + )-1 LI(add index + )-1 LI(drop index + )LU( + + )0 P(More complex changes can normally be imple)HY(mented)YH( in terms of + these build)HY(ing)YH( blocks. For example, to change a type of a + data member \201which leads to a change of a column type\202, we + can add a new data member with the desired type \201add column\202, + migrate the data, and then delete the old data member \201drop + column\202. ODB will issue diag)HY(nos)HY(tics)YH( for cases that are + currently not supported directly. Note also that some database + systems \201notably SQLite\202 have a number of limi)HY(ta)HY(tions)YH( in their + support for schema changes. For more infor)HY(ma)HY(tion)YH( on these + database-specific limi)HY(ta)HY(tions)YH(, refer to the "Limi)HY(ta)HY(tions)YH(" sections + in )0 204 1 A(Part II, "Database Systems")204 0 TN TL()Ec /AF f D(.)EP( + + )0 P(How do we know what the current database version is? That is, the + version )EM(from)ES( which we need to migrate? We need to know this, + for example, in order to deter)HY(mine)YH( the set of migra)HY(tions)YH( we have to + perform. By default, when schema evolu)HY(tion)YH( is enabled, ODB main)HY(tains)YH( + this infor)HY(ma)HY(tion)YH( in a special table called )SM(schema_version)ES( + that has the follow)HY(ing)YH( \201or equiv)HY(a)HY(lent)YH(, depend)HY(ing)YH( on the database + used\202 defi)HY(ni)HY(tion)YH(:)EP( + + ) 4 35 PR(CREATE TABLE "schema_version" \201 + "name" TEXT NOT NULL PRIMARY KEY, + "version" BIGINT NOT NULL, + "migration" BOOLEAN NOT NULL\202;)RP( + + )0 P(The )SM(name)ES( column is the schema name as spec)HY(i)HY(fied)YH( with + the )SM(--schema-name)ES( option. It is empty for the default + schema. The )SM(version)ES( column contains the current database + version. And, finally, the )SM(migra)HY(tion)YH()ES( flag indi)HY(cates)YH( + whether we are in the process of migrat)HY(ing)YH( the database, that is, + between the pre and post-migra)HY(tion)YH( stages.)EP( + + )0 P(The schema creation state)HY(ments)YH( \201)SM(person.sql)ES( in our case\202 + create this table and popu)HY(late)YH( it with the initial model version. For + example, if we executed )SM(person.sql)ES( corre)HY(spond)HY(ing)YH( to + version )SM(1)ES( of our object model, then )SM(name)ES( + would have been empty \201which signi)HY(fies)YH( the default schema since we + didn't specify )SM(--schema-name)ES(\202, )SM(version)ES( will + be )SM(1)ES( and )SM(migra)HY(tion)YH()ES( will be + )SM(FALSE)ES(.)EP( + + )0 P(The pre-migra)HY(tion)YH( state)HY(ments)YH( update the version and set the migra)HY(tion)YH( + flag to )SM(TRUE)ES(. Contin)HY(u)HY(ing)YH( with our example, after execut)HY(ing)YH( + )SM(person-002-pre.sql)ES(, )SM(version)ES( will + become )SM(2)ES( and )SM(migra)HY(tion)YH()ES( will be set to + )SM(TRUE)ES(. The post-migra)HY(tion)YH( state)HY(ments)YH( simply clear the + migra)HY(tion)YH( flag. In our case, after running + )SM(person-002-post.sql)ES(, )SM(version)ES( will + remain )SM(2)ES( while )SM(migra)HY(tion)YH()ES( will be reset + to )SM(FALSE)ES(.)EP( + + )0 P(Note also that above we mentioned that the schema creation state)HY(ments)YH( + \201)SM(person.sql)ES(\202 create the )SM(schema_version)ES( table. + This means that if we enable schema evolu)HY(tion)YH( support in the middle + of a project, then we could already have exist)HY(ing)YH( databases that + don't include this table. As a result, ODB will not be able to handle + migra)HY(tions)YH( for such databases unless we manu)HY(ally)YH( add the + )SM(schema_version)ES( table and popu)HY(late)YH( it with the correct + version infor)HY(ma)HY(tion)YH(. For this reason, it is highly recom)HY(mended)YH( that + you consider whether to use schema evolu)HY(tion)YH( and, if so, enable it + from the begin)HY(ning)YH( of your project.)EP( + + )0 P(The )SM(odb::database)ES( class provides an API for access)HY(ing)YH( + and modi)HY(fy)HY(ing)YH( the current database version:)EP( + + ) 53 71 PR(namespace odb +{ + typedef unsigned long long schema_version; + + struct LIBODB_EXPORT schema_version_migration + { + schema_version_migration \201schema_version = 0, + bool migration = false\202; + + schema_version version; + bool migration; + + // This class also provides the ==, !=, <, >, <=, and >= operators. + // Version ordering is as follows: {1,f} < {2,t} < {2,f} < {3,t}. + }; + + class database + { + public: + ... + + schema_version + schema_version \201const std::string& name = ""\202 const; + + bool + schema_migration \201const std::string& name = ""\202 const; + + const schema_version_migration& + schema_version_migration \201const std::string& name = ""\202 const; + + // Set schema version and migration state manually.)WR( + // + void + schema_version_migration \201schema_version, + bool migration, + const std::string& name = ""\202; + + void + schema_version_migration \201const schema_version_migration&, + const std::string& name = ""\202; + + // Set default schema version table for all schemas. + // + void + schema_version_table \201const std::string& table_name\202; + + // Set schema version table for a specific schema. + // + void + schema_version_table \201const std::string& table_name, + const std::string& name\202; + }; +})RP( + + )0 P(The )SM(schema_version\201\202)ES( and )SM(schema_migra)HY(tion)YH(\201\202)ES( + acces)HY(sors)YH( return the current database version and migra)HY(tion)YH( flag, + respec)HY(tively)YH(. The optional )SM(name)ES( argu)HY(ment)YH( is the schema + name. If the database schema hasn't been created \201that is, there is + no corre)HY(spond)HY(ing)YH( entry in the )SM(schema_version)ES( table or + this table does not exist\202, then )SM(schema_version\201\202)ES( returns + )SM(0)ES(. The )SM(schema_version_migra)HY(tion)YH(\201\202)ES( acces)HY(sor)YH( + returns both version and migra)HY(tion)YH( flag together in the + )SM(schema_version_migra)HY(tion)YH()ES( )SM(struct)ES(.)EP( + + )0 P(You may already have a version table in your database or you \201or your + database admin)HY(is)HY(tra)HY(tor)YH(\202 may prefer to keep track of versions your own + way. You can instruct ODB not to create the )SM(schema_version)ES( + table with the )SM(--suppress-schema-version)ES( option. However, + ODB still needs to know the current database version in order for certain + schema evolu)HY(tion)YH( mech)HY(a)HY(nisms)YH( to func)HY(tion)YH( prop)HY(erly)YH(. As a result, in + this case, you will need to set the schema version on the database + instance manu)HY(ally)YH( using the schema_version_migra)HY(tion)YH(\201\202 modi)HY(fier)YH(. + Note that the modi)HY(fier)YH( API is not thread-safe. That is, you should + not modify the schema version while other threads may be access)HY(ing)YH( + or modi)HY(fy)HY(ing)YH( the same infor)HY(ma)HY(tion)YH(.)EP( + + )0 P(Note also that the acces)HY(sors)YH( we discussed above will only query the + )SM(schema_version)ES( table once and, if the version could + be deter)HY(mined)YH(, cache the result. If, however, the version could + not be deter)HY(mined)YH( \201that is, )SM(schema_version\201\202)ES( returned + 0\202, then a subse)HY(quent)YH( call will re-query the table. While it is + prob)HY(a)HY(bly)YH( a bad idea to modify the database schema while the + appli)HY(ca)HY(tion)YH( is running \201other than via the )SM(schema_catalog)ES( + API, as discussed below\202, if for some reason you need ODB to re-query + the version, then you can manu)HY(ally)YH( set it to 0 using the + )SM(schema_version_migra)HY(tion)YH(\201\202)ES( modi)HY(fier)YH(.)EP( + + )0 P(It is also possi)HY(ble)YH( to change the name of the table that stores + the schema version using the )SM(--schema-version-table)ES( + option. You will also need to specify this alter)HY(na)HY(tive)YH( name on + the )SM(database)ES( instance using the )SM(schema_version_table\201\202)ES( + modi)HY(fier)YH(. The first version spec)HY(i)HY(fies)YH( the default table that is + used for all the schema names. The second version spec)HY(i)HY(fies)YH( the + table for a specific schema. The table name should be + database-quoted, if neces)HY(sary)YH(.)EP( + + )0 P(If we are gener)HY(at)HY(ing)YH( our schema migra)HY(tions)YH( as stan)HY(dalone)YH( SQL files, + then the migra)HY(tion)YH( work)HY(flow)YH( could look like this:)EP( + + )4 OL( )-1 LI(The database admin)HY(is)HY(tra)HY(tor)YH( deter)HY(mines)YH( the current database version. + If migra)HY(tion)YH( is required, then for each migra)HY(tion)YH( step \201that + is, from one version to the next\202, he performs the follow)HY(ing)YH(: + + )-1 LI(Execute the pre-migra)HY(tion)YH( file. + + )-1 LI(Execute our appli)HY(ca)HY(tion)YH( \201or a sepa)HY(rate)YH( migra)HY(tion)YH( program\202 + to perform data migra)HY(tion)YH( \201discussed later\202. Our appli)HY(ca)HY(tion)YH( + can deter)HY(mine)YH( that is is being executed in the "migra)HY(tion)YH( mode" + by calling )SM(schema_migra)HY(tion)YH(\201\202)ES( and then which + migra)HY(tion)YH( code to run by calling )SM(schema_version\201\202)ES(. + + )-1 LI(Execute the post-migra)HY(tion)YH( file. + )LO( + + )0 P(These steps become more inte)HY(grated)YH( and auto)HY(matic)YH( if we embed the + schema creation and migra)HY(tion)YH( code into the gener)HY(ated)YH( C++ code. + Now we can perform schema creation, schema migra)HY(tion)YH(, and data + migra)HY(tion)YH( as well as deter)HY(mine)YH( when each step is neces)HY(sary)YH( + program)HY(mat)HY(i)HY(cally)YH( from within the appli)HY(ca)HY(tion)YH(.)EP( + + )0 P(Schema evolu)HY(tion)YH( support adds the follow)HY(ing)YH( extra func)HY(tions)YH( to + the )SM(odb::schema_catalog)ES( class, which we first discussed + in )0 27 1 A(Section 3.4, "Database")27 0 TN TL()Ec /AF f D(.)EP( + + ) 66 55 PR(namespace odb +{ + class schema_catalog + { + public: + ... + + + // Schema migration. + // + static void + migrate_schema_pre \201database&, + schema_version, + const std::string& name = ""\202; + + static void + migrate_schema_post \201database&, + schema_version, + const std::string& name = ""\202; + + static void + migrate_schema \201database&, + schema_version, + const std::string& name = ""\202; + + // Data migration. + // + // Discussed in the next section. + + + // Combined schema and data migration.)WR( + // + static void + migrate \201database&, + schema_version = 0, + const std::string& name = ""\202; + + // Schema version information. + // + static schema_version + base_version \201const database&, + const std::string& name = ""\202; + + static schema_version + base_version \201database_id, + const std::string& name = ""\202; + + static schema_version + current_version \201const database&, + const std::string& name = ""\202; + + static schema_version + current_version \201database_id, + const std::string& name = ""\202; + + static schema_version + next_version \201const database&, + schema_version = 0, + const std::string& name = ""\202; + + static schema_version)WR( + next_version \201database_id, + schema_version, + const std::string& name = ""\202; + }; +})RP( + + )0 P(The )SM(migrate_schema_pre\201\202)ES( and + )SM(migrate_schema_post\201\202)ES( static func)HY(tions)YH( perform + a single stage \201that is, pre or post\202 of a single migra)HY(tion)YH( + step \201that is, from one version to the next\202. The )SM(version)ES( + argu)HY(ment)YH( spec)HY(i)HY(fies)YH( the version we are migrat)HY(ing)YH( to. For + instance, in our )SM(person)ES( example, if we know that + the database version is )SM(1)ES( and the next version + is )SM(2)ES(, then we can execute code like this:)EP( + + ) 9 44 PR(transaction t \201db.begin \201\202\202; + +schema_catalog::migrate_schema_pre \201db, 2\202; + +// Data migration goes here. + +schema_catalog::migrate_schema_post \201db, 2\202; + +t.commit \201\202;)RP( + + )0 P(If you don't have any data migra)HY(tion)YH( code to run, then you can + perform both stages with a single call using the + )SM(migrate_schema\201\202)ES( static func)HY(tion)YH(.)EP( + + )0 P(The )SM(migrate\201\202)ES( static func)HY(tion)YH( perform both schema + and data migra)HY(tion)YH( \201we discuss data migra)HY(tion)YH( in the next section\202. + It can also perform several migra)HY(tion)YH( steps at once. If we don't + specify its target version, then it will migrate \201if neces)HY(sary)YH(\202 + all the way to the current model version. As an extra conve)HY(nience)YH(, + )SM(migrate\201\202)ES( will also create the database schema if + none exists. As a result, if we don't have any data migra)HY(tion)YH( + code or we have regis)HY(tered)YH( it with )SM(schema_catalog)ES( \201as + discussed later\202, then the database schema creation and migra)HY(tion)YH(, + whichever is neces)HY(sary)YH(, if at all, can be performed with a single + func)HY(tion)YH( call:)EP( + + ) 3 29 PR(transaction t \201db.begin \201\202\202; +schema_catalog::migrate \201db\202; +t.commit \201\202;)RP( + + )0 P(Note also that )SM(schema_catalog)ES( is inte)HY(grated)YH( with the + )SM(odb::database)ES( schema version API. In partic)HY(u)HY(lar)YH(, + )SM(schema_catalog)ES( func)HY(tions)YH( will query and synchro)HY(nize)YH( + the schema version on the )SM(database)ES( instance if and + when required.)EP( + + )0 P(The )SM(schema_catalog)ES( class also allows you to iterate + over known versions \201remem)HY(ber)YH(, there could be "gaps" in version + numbers\202 with the )SM(base_version\201\202)ES(, + )SM(current_version\201\202)ES( and )SM(next_version\201\202)ES( + static func)HY(tions)YH(. The )SM(base_version\201\202)ES( and + )SM(current_version\201\202)ES( func)HY(tions)YH( return the base and + current object model versions, respec)HY(tively)YH(. That is, the + lowest version from which we can migrate and the version that + we ulti)HY(mately)YH( want to migrate to. The )SM(next_version\201\202)ES( + func)HY(tion)YH( returns the next known version. If the passed version is + greater or equal to the current version, then this func)HY(tion)YH( + will return the current version plus one \201that is, one past + current\202. If we don't specify the version, then + )SM(next_version\201\202)ES( will use the current database version + as the start)HY(ing)YH( point. Note also that the schema version infor)HY(ma)HY(tion)YH( + provided by these func)HY(tions)YH( is only avail)HY(able)YH( if we embed the schema + migra)HY(tion)YH( code into the gener)HY(ated)YH( C++ code. For stan)HY(dalone)YH( SQL file + migra)HY(tions)YH( this infor)HY(ma)HY(tion)YH( is normally not needed since the migra)HY(tion)YH( + process is directed by an exter)HY(nal)YH( entity, such as a database + admin)HY(is)HY(tra)HY(tor)YH( or a script.)EP( + + )0 P(Most )SM(schema_catalog)ES( func)HY(tions)YH( presented above also + accept the optional schema name argu)HY(ment)YH(. If the passed schema + name is not found, then the )SM(odb::unknown_schema)ES( excep)HY(tion)YH( + is thrown. Simi)HY(larly)YH(, func)HY(tions)YH( that accept the schema version + argu)HY(ment)YH( will throw the )SM(odb::unknown_schema_version)ES( excep)HY(tion)YH( + if the passed version is invalid. Refer to )0 37 1 A(Section + 3.14, "ODB Excep)HY(tions)YH(")37 0 TN TL()Ec /AF f D( for more infor)HY(ma)HY(tion)YH( on these excep)HY(tions)YH(.)EP( + + )0 P(To illus)HY(trate)YH( how all these parts fit together, consider the + follow)HY(ing)YH( more real)HY(is)HY(tic)YH( database schema manage)HY(ment)YH( example. + Here we want to handle the schema creation in a special way + and perform each migra)HY(tion)YH( step in its own trans)HY(ac)HY(tion)YH(.)EP( + + ) 43 65 PR(schema_version v \201db.schema_version \201\202\202; +schema_version bv \201schema_catalog::base_version \201db\202\202; +schema_version cv \201schema_catalog::current_version \201db\202\202; + +if \201v == 0\202 +{ + // No schema in the database. Create the schema and + // initialize the database. + // + transaction t \201db.begin \201\202\202; + schema_catalog::create_schema \201db\202; + + // Populate the database with initial data, if any. + + t.commit \201\202; +} +else if \201v < cv\202 +{ + // Old schema \201and data\202 in the database, migrate them. + // + + if \201v < bv\202 + { + // Error: migration from this version is no longer supported. + } + + for \201v = schema_catalog::next_version \201db, v\202; + v <= cv; + v = schema_catalog::next_version \201db, v\202\202 + { + transaction t \201db.begin \201\202\202;)WR( + schema_catalog::migrate_schema_pre \201db, v\202; + + // Data migration goes here. + + schema_catalog::migrate_schema_post \201db, v\202; + t.commit \201\202; + } +} +else if \201v > cv\202 +{ + // Error: old application trying to access new database. +})RP( + + )0 2 90 H(13.3)WB 415 Sn()WB 94 Sn( Data Migra)HY(tion)YH()EA()EH( + + )0 P(In quite a few cases spec)HY(i)HY(fy)HY(ing)YH( the default value for new data + members will be all that's required to handle the exist)HY(ing)YH( objects. + For example, the natural default value for the new middle name + that we have added is an empty string. And we can handle + this case with the )SM(db\240default)ES( pragma and without + any extra C++ code:)EP( + + ) 11 30 PR(#pragma db model version\2011, 2\202 + +#pragma db object +class person +{ + ... + + + #pragma db default\201""\202 + std::string middle_; +};)RP( + + )0 P(However, there will be situ)HY(a)HY(tions)YH( where we would need to perform + more elab)HY(o)HY(rate)YH( data migra)HY(tions)YH(, that is, convert old data to the + new format. As an example, suppose we want to add gender to our + )SM(person)ES( class. And, instead of leaving it unas)HY(signed)YH( + for all the exist)HY(ing)YH( objects, we will try to guess it from the + first name. This is not partic)HY(u)HY(larly)YH( accu)HY(rate)YH( but it could be + suffi)HY(cient)YH( for our hypo)HY(thet)HY(i)HY(cal)YH( appli)HY(ca)HY(tion)YH(:)EP( + + ) 11 30 PR(#pragma db model version\2011, 3\202 + +enum gender {male, female}; + +#pragma db object +class person +{ + ... + + gender gender_; +};)RP( + + )0 P(As we have discussed earlier, there are two ways to perform data + migra)HY(tion)YH(: imme)HY(di)HY(ate)YH( and gradual. To recap, with imme)HY(di)HY(ate)YH( + migra)HY(tion)YH( we migrate all the exist)HY(ing)YH( objects at once, normally + after the schema pre-migra)HY(tion)YH( state)HY(ments)YH( but before the + post-migra)HY(tion)YH( state)HY(ments)YH(. With gradual migra)HY(tion)YH(, we make sure + the new object model can accom)HY(mo)HY(date)YH( both old and new data and + grad)HY(u)HY(ally)YH( migrate exist)HY(ing)YH( objects as the appli)HY(ca)HY(tion)YH( runs and + the oppor)HY(tu)HY(ni)HY(ties)YH( to do so arise, for example, an object is + updated.)EP( + + )0 P(There is also another option for data migra)HY(tion)YH( that is not + discussed further in this section. Instead of using our C++ + object model we could execute ad-hoc SQL state)HY(ments)YH( that + perform the neces)HY(sary)YH( conver)HY(sions)YH( and migra)HY(tions)YH( directly + on the database server. While in certain cases this can be + a better option from the perfor)HY(mance)YH( point of view, this + approach is often limited in terms of the migra)HY(tion)YH( logic + that we can handle.)EP( + + )0 2 91 H(13.3.1)WB 416 Sn()WB 95 Sn( Imme)HY(di)HY(ate)YH( Data Migra)HY(tion)YH()EA()EH( + + )0 P(Let's first see how we can imple)HY(ment)YH( an imme)HY(di)HY(ate)YH( migra)HY(tion)YH( for the + new )SM(gender_)ES( data member we have added above. If we + are using stan)HY(dalone)YH( SQL files for migra)HY(tion)YH(, then we could add + code along these lines some)HY(where)YH( early in )SM(main\201\202)ES(, + before the main appli)HY(ca)HY(tion)YH( logic:)EP( + + ) 33 53 PR(int +main \201\202 +{ + ... + + odb::database& db = ... + + // Migrate data if necessary. + // + if \201db.schema_migration \201\202\202 + { + switch \201db.schema_version \201\202\202 + { + case 3: + { + // Assign gender to all the existing objects. + // + transaction t \201db.begin \201\202\202; + + for \201person& p: db.query \201\202\202 + { + p.gender \201guess_gender \201p.first \201\202\202\202; + db.update \201p\202; + } + + t.commit \201\202; + break; + } + } + } +)WR( + ... +})RP( + + )0 P(If you have a large number of objects to migrate, it may also be + a good idea, from the perfor)HY(mance)YH( point of view, to break one big + trans)HY(ac)HY(tion)YH( that we now have into multi)HY(ple)YH( smaller trans)HY(ac)HY(tions)YH( + \201)0 28 1 A(Section 3.5, "Trans)HY(ac)HY(tions)YH(")28 0 TN TL()Ec /AF f D(\202. For example:)EP( + + ) 23 65 PR(case 3: + { + transaction t \201db.begin \201\202\202; + + size_t n \2010\202; + for \201person& p: db.query \201\202\202 + { + p.gender \201guess_gender \201p.first \201\202\202\202; + db.update \201p\202; + + // Commit the current transaction and start a new one after + // every 100 updates. + // + if \201n++ % 100 == 0\202 + { + t.commit \201\202; + t.reset \201db.begin \201\202\202; + } + } + + t.commit \201\202; + break; + })RP( + + )0 P(While it looks straight)HY(for)HY(ward)YH( enough, as we add more migra)HY(tion)YH( + snip)HY(pets)YH(, this approach can quickly become unmain)HY(tain)HY(able)YH(. Instead + of having all the migra)HY(tions)YH( in a single func)HY(tion)YH( and deter)HY(min)HY(ing)YH( + when to run each piece ourselves, we can package each migra)HY(tion)YH( into + a sepa)HY(rate)YH( func)HY(tion)YH(, regis)HY(ter)YH( it with the )SM(schema_catalog)ES( + class, and let ODB figure out when to run which migra)HY(tion)YH( func)HY(tions)YH(. + To support this func)HY(tion)HY(al)HY(ity)YH(, )SM(schema_catalog)ES( provides + the follow)HY(ing)YH( data migra)HY(tion)YH( API:)EP( + + ) 85 73 PR(namespace odb +{ + class schema_catalog + { + public: + ... + + // Data migration. + // + static std::size_t + migrate_data \201database&, + schema_version = 0, + const std::string& name = ""\202; + + typedef void data_migration_function_type \201database&\202; + + // Common \201for all the databases\202 data migration, C++98/03 version: + // + template + static void + data_migration_function \201data_migration_function_type*, + const std::string& name = ""\202; + + // Common \201for all the databases\202 data migration, C++11 version: + // + template + static void + data_migration_function \201std::function, + const std::string& name = ""\202; + + // Database-specific data migration, C++98/03 version:)WR( + // + template + static void + data_migration_function \201database&, + data_migration_function_type*, + const std::string& name = ""\202; + + template + static void + data_migration_function \201database_id, + data_migration_function_type*, + const std::string& name = ""\202; + + // Database-specific data migration, C++11 version: + // + template + static void + data_migration_function \201database&, + std::function, + const std::string& name = ""\202; + + template + static void + data_migration_function \201database_id, + std::function, + const std::string& name = ""\202; + }; + + // Static data migration function registration, C++98/03 version: + //)WR( + template + struct data_migration_entry + { + data_migration_entry \201data_migration_function_type*, + const std::string& name = ""\202; + + data_migration_entry \201database_id, + data_migration_function_type*, + const std::string& name = ""\202; + }; + + // Static data migration function registration, C++11 version: + // + template + struct data_migration_entry + { + data_migration_entry \201std::function, + const std::string& name = ""\202; + + data_migration_entry \201database_id, + std::function, + const std::string& name = ""\202; + }; +})RP( + + )0 P(The )SM(migrate_data\201\202)ES( static func)HY(tion)YH( performs data + migra)HY(tion)YH( for the spec)HY(i)HY(fied)YH( version. If no version is spec)HY(i)HY(fied)YH(, + then it will use the current database version and also check + whether the database is in migra)HY(tion)YH(, that is, + )SM(database::schema_migra)HY(tion)YH(\201\202)ES( returns )SM(true)ES(. + As a result, all we need to do in our )SM(main\201\202)ES( is call + this func)HY(tion)YH(. It will check if migra)HY(tion)YH( is required and if so, + call all the migra)HY(tion)YH( func)HY(tions)YH( regis)HY(tered)YH( for this version. For + example:)EP( + + ) 14 51 PR(int +main \201\202 +{ + ... + + database& db = ... + + // Check if we need to migrate any data and do so + // if that's the case. + // + schema_catalog::migrate_data \201db\202; + + ... +})RP( + + )0 P(The )SM(migrate_data\201\202)ES( func)HY(tion)YH( returns the number of + migra)HY(tion)YH( func)HY(tions)YH( called. You can use this value for debug)HY(ging)YH( + or logging.)EP( + + )0 P(The only other step that we need to perform is regis)HY(ter)YH( our data + migra)HY(tion)YH( func)HY(tions)YH( with )SM(schema_catalog)ES(. At the + lower level we can call the )SM(data_migra)HY(tion)YH(_func)HY(tion)YH(\201\202)ES( + static func)HY(tion)YH( for every migra)HY(tion)YH( func)HY(tion)YH( we have, for example, + at the begin)HY(ning)YH( of )SM(main\201\202)ES(. For each version, data + migra)HY(tion)YH( func)HY(tions)YH( are called in the order of regis)HY(tra)HY(tion)YH(.)EP( + + )0 P(A more conve)HY(nient)YH( approach, however, is to use the + )SM(data_migra)HY(tion)YH(_entry)ES( helper class template to regis)HY(ter)YH( the + migra)HY(tion)YH( func)HY(tions)YH( during static initial)HY(iza)HY(tion)YH(. This way we + can keep the migra)HY(tion)YH( func)HY(tion)YH( and its regis)HY(tra)HY(tion)YH( code next + to each other. Here is how we can reim)HY(ple)HY(ment)YH( our )SM(gender)ES( + migra)HY(tion)YH( code to use this mech)HY(a)HY(nism)YH(:)EP( + + ) 16 61 PR(static void +migrate_gender \201odb::database& db\202 +{ + transaction t \201db.begin \201\202\202; + + for \201person& p: db.query \201\202\202 + { + p.gender \201guess_gender \201p.first \201\202\202\202; + db.update \201p\202; + } + + t.commit \201\202; +} + +static const odb::data_migration_entry<3, MYAPP_BASE_VERSION> +migrate_gender_entry \201&migrate_gender\202;)RP( + + )0 P(The first template argu)HY(ment)YH( to the )SM(data_migra)HY(tion)YH(_entry)ES( + class template is the version we want this data migra)HY(tion)YH( func)HY(tion)YH( + to be called for. The second template argu)HY(ment)YH( is the base model + version. This second argu)HY(ment)YH( is neces)HY(sary)YH( to detect the situ)HY(a)HY(tion)YH( + where we no longer need this data migra)HY(tion)YH( func)HY(tion)YH(. Remem)HY(ber)YH( + that when we move the base model version forward, migra)HY(tions)YH( from + any version below the new base are no longer possi)HY(ble)YH(. We, however, + may still have migra)HY(tion)YH( func)HY(tions)YH( regis)HY(tered)YH( for those lower + versions. Since these func)HY(tions)YH( will never be called, they are + effec)HY(tively)YH( dead code and it would be useful to iden)HY(tify)YH( and + remove them. To assist with this, )SM(data_migra)HY(tion)YH(_entry)ES( + \201and lower lever )SM(data_migra)HY(tion)YH(_func)HY(tion)YH(\201\202)ES(\202 will + check at compile time \201that is, )SM(static_assert)ES(\202 that + the regis)HY(tra)HY(tion)YH( version is greater than the base model version.)EP( + + )0 P(In the above example we use the )SM(MYAPP_BASE_VERSION)ES( + macro that is presum)HY(ably)YH( defined in a central place, for example, + )SM(version.hxx)ES(. This is the recom)HY(mended)YH( approach since + we can update the base version in a single place and have the + C++ compiler auto)HY(mat)HY(i)HY(cally)YH( iden)HY(tify)YH( all the data migra)HY(tion)YH( + func)HY(tions)YH( that can be removed.)EP( + + )0 P(In C++11 we can also create a template alias so that we don't + have to repeat the base model macro in every regis)HY(tra)HY(tion)YH(, for + example:)EP( + + ) 5 73 PR(template +using migration_entry = odb::data_migration_entry; + +static const migration_entry<3> +migrate_gender_entry \201&migrate_gender\202;)RP( + + )0 P(For cases where you need to by-pass the base version check, for + example, to imple)HY(ment)YH( your own regis)HY(tra)HY(tion)YH( helper, ODB also + provides "unsafe" versions of the )SM(data_migra)HY(tion)YH(_func)HY(tion)YH(\201\202)ES( + func)HY(tions)YH( that take the version as a func)HY(tion)YH( argu)HY(ment)YH( rather than + as a template param)HY(e)HY(ter)YH(.)EP( + + )0 P(In C++11 we can also use lambdas as migra)HY(tion)YH( func)HY(tions)YH(, which makes + the migra)HY(tion)YH( code more concise:)EP( + + ) 14 43 PR(static const migration_entry<3> +migrate_gender_entry \201 + [] \201odb::database& db\202 + { + transaction t \201db.begin \201\202\202; + + for \201person& p: db.query \201\202\202 + { + p.gender \201guess_gender \201p.first \201\202\202\202; + db.update \201p\202; + } + + t.commit \201\202; + }\202;)RP( + + )0 P(If we are using embed)HY(ded)YH( schema migra)HY(tions)YH(, then both schema and + data migra)HY(tion)YH( is inte)HY(grated)YH( and can be performed with a single + call to the )SM(schema_catalog::migrate\201\202)ES( func)HY(tion)YH( that + we discussed earlier. For example:)EP( + +) 18 55 PR(int +main \201\202 +{ + ... + + database& db = ... + + // Check if we need to migrate the database and do so + // if that's the case. + // + { + transaction t \201db.begin \201\202\202; + schema_catalog::migrate \201db\202; + t.commit \201\202; + } + + ... +})RP( + + )0 P(Note, however, that in this case we call )SM(migrate\201\202)ES( + within a trans)HY(ac)HY(tion)YH( \201for the schema migra)HY(tion)YH( part\202 which means + that our migra)HY(tion)YH( func)HY(tions)YH( will also be called within this + trans)HY(ac)HY(tion)YH(. As a result, we will need to adjust our migra)HY(tion)YH( + func)HY(tions)YH( not to start their own trans)HY(ac)HY(tion)YH(:)EP( + + ) 11 44 PR(static void +migrate_gender \201odb::database& db\202 +{ + // Assume we are already in a transaction. + // + for \201person& p: db.query \201\202\202 + { + p.gender \201guess_gender \201p.first \201\202\202\202; + db.update \201p\202; + } +})RP( + + )0 P(If, however, we want more gran)HY(u)HY(lar)YH( trans)HY(ac)HY(tions)YH(, then we can + use the lower-level )SM(schema_catalog)ES( func)HY(tions)YH( to + gain more control, as we have seen at the end of the previ)HY(ous)YH( + section. Here is the rele)HY(vant)YH( part of that example with + an added data migra)HY(tion)YH( call:)EP( + + ) 12 57 PR( // Old schema \201and data\202 in the database, migrate them. + // + for \201v = schema_catalog::next_version \201db, v\202; + v <= cv; + v = schema_catalog::next_version \201db, v\202\202 + { + transaction t \201db.begin \201\202\202; + schema_catalog::migrate_schema_pre \201db, v\202; + schema_catalog::migrate_data \201db, v\202; + schema_catalog::migrate_schema_post \201db, v\202; + t.commit \201\202; + })RP( + + )0 2 92 H(13.3.2)WB 417 Sn()WB 96 Sn( Gradual Data Migra)HY(tion)YH()EA()EH( + + )0 P(If the number of exist)HY(ing)YH( objects that require migra)HY(tion)YH( is large, + then an all-at-once, imme)HY(di)HY(ate)YH( migra)HY(tion)YH(, while simple, may not + be prac)HY(ti)HY(cal)YH( from a perfor)HY(mance)YH( point of view. In this case, + we can perform a gradual migra)HY(tion)YH( as the appli)HY(ca)HY(tion)YH( does + its normal func)HY(tions)YH(.)EP( + + )0 P(With gradual migra)HY(tions)YH(, the object model must be capable of + repre)HY(sent)HY(ing)YH( data that conforms to both old and new formats at + the same time since, in general, the database will contain a + mixture of old and new objects. For example, in case of our + )SM(gender)ES( data member, we need a special value that + repre)HY(sents)YH( the "no gender assigned yet" case \201an old object\202. + We also need to assign this special value to all the exist)HY(ing)YH( + objects during the schema pre-migra)HY(tion)YH( stage. One way to do + this would be add a special value to our )SM(gender)ES( + enum and then make it the default value with the + )SM(db\240default)ES( pragma. A cleaner and easier approach, + however, is to use )SM(NULL)ES( as a special value. We + can add support for the )SM(NULL)ES( value seman)HY(tics)YH( + to any exist)HY(ing)YH( type by wrap)HY(ping)YH( it with + )SM(odb::nullable)ES(, )SM(boost::optional)ES( + or similar \201)0 68 1 A(Section 7.3, "Point)HY(ers)YH( and )SM(NULL)ES( + Value Seman)HY(tics)YH(")68 0 TN TL()Ec /AF f D(\202. We also don't need to specify the default value + explic)HY(itly)YH( since )SM(NULL)ES( is used auto)HY(mat)HY(i)HY(cally)YH(. Here + is how we can use this approach in our )SM(gender)ES( + example:)EP( + + ) 9 32 PR(#include + +#pragma db object +class person +{ + ... + + odb::nullable gender_; +};)RP( + + )0 P(A variety of strate)HY(gies)YH( can be employed to imple)HY(ment)YH( gradual + migra)HY(tions)YH(. For example, we can migrate the data when the object + is updated as part of the normal appli)HY(ca)HY(tion)YH( logic. While there + is no migra)HY(tion)YH( cost asso)HY(ci)HY(ated)YH( with this approach \201the object + is updated anyway\202, depend)HY(ing)YH( on how often objects are typi)HY(cally)YH( + updated, this strat)HY(egy)YH( can take a long time to complete. An + alter)HY(na)HY(tive)YH( strat)HY(egy)YH( would be to perform an update when)HY(ever)YH( + an old object is loaded. Yet another strat)HY(egy)YH( is to have a + sepa)HY(rate)YH( thread that slowly migrates all the old objects as + the appli)HY(ca)HY(tion)YH( runs.)EP( + + )0 P(As an example, let us imple)HY(ment)YH( the first approach for our + )SM(gender)ES( migra)HY(tion)YH(. While we could have added + the neces)HY(sary)YH( code through)HY(out)YH( the appli)HY(ca)HY(tion)YH(, from the + main)HY(te)HY(nance)YH( point of view, it is best to try and local)HY(ize)YH( + the gradual migra)HY(tion)YH( logic to the persis)HY(tent)YH( classes that + it affects. And for this database oper)HY(a)HY(tion)YH( call)HY(backs)YH( + \201)0 108 1 A(Section 14.1.7, ")SM(call)HY(back)YH()ES(")108 0 TN TL()Ec /AF f D(\202 + are a very useful mech)HY(a)HY(nism)YH(. In our case, all we have to do is handle + the )SM(post_load)ES( event where we guess the gender + if it is )SM(NULL)ES(:)EP( + + ) 23 50 PR(#include // odb::database +#include // odb::callback_event +#include + +#pragma db object callback\201migrate\202 +class person +{ + ... + + void + migrate \201odb::callback_event e, odb::database&\202 + { + if \201e == odb::callback_event::post_load\202 + { + // Guess gender if not assigned. + // + if \201gender_.null \201\202\202 + gender_ = guess_gender \201first_\202; + } + } + + odb::nullable gender_; +};)RP( + + )0 P(In partic)HY(u)HY(lar)YH(, we don't have to touch any of the acces)HY(sors)YH( + or modi)HY(fiers)YH( or the appli)HY(ca)HY(tion)YH( logic \236 all of them + can assume that the value can never be )SM(NULL)ES(. + And when the object is next updated, the new )SM(gender)ES( + value will be stored auto)HY(mat)HY(i)HY(cally)YH(.)EP( + + )0 P(All gradual migra)HY(tions)YH( normally end up with a termi)HY(nat)HY(ing)YH( + imme)HY(di)HY(ate)YH( migra)HY(tion)YH( some number of versions down the line, + when the bulk of the objects has presum)HY(ably)YH( been converted. + This way we don't have to keep the gradual migra)HY(tion)YH( code + around forever. Here is how we could imple)HY(ment)YH( a termi)HY(nat)HY(ing)YH( + migra)HY(tion)YH( for our example:)EP( + + ) 28 62 PR(// person.hxx +// +#pragma db model version\2011, 4\202 + +#pragma db object +class person +{ + ... + + gender gender_; +}; + +// person.cxx +// +static void +migrate_gender \201odb::database& db\202 +{ + typedef odb::query query; + + for \201person& p: db.query \201query::gender.is_null \201\202\202\202 + { + p.gender \201guess_gender \201p.first \201\202\202\202; + db.update \201p\202; + } +} + +static const odb::data_migration_entry<4, MYAPP_BASE_VERSION> +migrate_gender_entry \201&migrate_gender\202;)RP( + + )0 P(A couple of points to note about this code. Firstly, we + removed all the gradual migra)HY(tion)YH( logic \201the call)HY(back)YH(\202 + from the class and replaced it with the imme)HY(di)HY(ate)YH( migra)HY(tion)YH( + func)HY(tion)YH(. We also removed the )SM(odb::nullable)ES( + wrapper \201and there)HY(fore)YH( disal)HY(lowed)YH( the )SM(NULL)ES( values\202 + since after this migra)HY(tion)YH( all the objects will have been + converted. Finally, in the migra)HY(tion)YH( func)HY(tion)YH(, we only query + the database for objects that need migra)HY(tion)YH(, that is, have + )SM(NULL)ES( gender.)EP( + + )0 2 93 H(13.4)WB 418 Sn()WB 97 Sn( Soft Object Model Changes)EA()EH( + + )0 P(Let us consider another common kind of object model change: + we delete an old member, add a new one, and need to copy + the data from the old to the new, perhaps apply)HY(ing)YH( some + conver)HY(sion)YH(. For example, we may realize that in our appli)HY(ca)HY(tion)YH( + it is a better idea to store a person's name as a single string + rather than split it into three fields. So what we would like to do + is add a new data member, let's call it )SM(name_)ES(, convert + all the exist)HY(ing)YH( split names, and then delete the )SM(first_)ES(, + )SM(middle_)ES(, and )SM(last_)ES( data members.)EP( + + )0 P(While this sounds straight)HY(for)HY(ward)YH(, there is a problem. If we + delete \201that is, phys)HY(i)HY(cally)YH( remove from the source code\202 the + old data members, then we won't be able to access the old + data. The data will still be avail)HY(able)YH( in the database between + the schema pre and post-migra)HY(tions)YH(, it is just we will no longer + be able to access it through our object model. And if we keep + the old data members around, then the old data will remain + stored in the database even after the schema post-migra)HY(tion)YH(.)EP( + + )0 P(There is also a more subtle problem that has to do with exist)HY(ing)YH( + migra)HY(tions)YH( for the previ)HY(ous)YH( versions. Remem)HY(ber)YH(, in version )SM(3)ES( + of our )SM(person)ES( example we added the )SM(gender_)ES( + data member. We also have a data migra)HY(tion)YH( func)HY(tion)YH( which guesses + the gender based on the first name. Delet)HY(ing)YH( the )SM(first_)ES( + data member from our class will obvi)HY(ously)YH( break this code. But + even adding the new )SM(name_)ES( data member will cause + prob)HY(lems)YH( because when we try to update the object in order to + store the new gender, ODB will try to update )SM(name_)ES( + as well. But there is no corre)HY(spond)HY(ing)YH( column in the database + yet. When we run this migra)HY(tion)YH( func)HY(tion)YH(, we are still several + versions away from the point where the )SM(name)ES( column + will be added.)EP( + + )0 P(This is a very subtle but also very impor)HY(tant)YH( impli)HY(ca)HY(tion)YH( to + under)HY(stand)YH(. Unlike the main appli)HY(ca)HY(tion)YH( logic, which only needs + to deal with the current model version, data migra)HY(tion)YH( code works + on databases that can be multi)HY(ple)YH( versions behind the current + version.)EP( + + )0 P(How can we resolve this problem? It appears what we need is the + ability to add or delete data members start)HY(ing)YH( from a specific + version. In ODB this mech)HY(a)HY(nism)YH( is called soft member addi)HY(tions)YH( + and dele)HY(tions)YH(. A soft-added member is only treated as persis)HY(tent)YH( + start)HY(ing)YH( from the addi)HY(tion)YH( version. A soft-deleted member is + persis)HY(tent)YH( until the dele)HY(tion)YH( version \201but includ)HY(ing)YH( the migra)HY(tion)YH( + stage\202. In its essence, soft model changes allow us to main)HY(tain)YH( + multi)HY(ple)YH( versions of our object model all with a single set of + persis)HY(tent)YH( classes. Let us now see how this func)HY(tion)HY(al)HY(ity)YH( can + help imple)HY(ment)YH( our changes:)EP( + + ) 24 30 PR(#pragma db model version\2011, 4\202 + +#pragma db object +class person +{ + ... + + #pragma db id auto + unsigned long id_; + + #pragma db deleted\2014\202 + std::string first_; + + #pragma db deleted\2014\202 + std::string middle_; + + #pragma db deleted\2014\202 + std::string last_; + + #pragma db added\2014\202 + std::string name_; + + gender gender_; +};)RP( + + )0 P(The migra)HY(tion)YH( func)HY(tion)YH( for this change could then look like + this:)EP( + + ) 14 61 PR(static void +migrate_name \201odb::database& db\202 +{ + for \201person& p: db.query \201\202\202 + { + p.name \201p.first \201\202 + " " + + p.middle \201\202 + \201p.middle \201\202.empty \201\202 ? "" : " "\202 + + p.last \201\202\202; + db.update \201p\202; + } +} + +static const odb::data_migration_entry<4, MYAPP_BASE_VERSION> +migrate_name_entry \201&migrate_name\202;)RP( + + )0 P(Note also that no changes are required to the gender migra)HY(tion)YH( + func)HY(tion)YH(.)EP( + + )0 P(As you may have noticed, in the code above we assumed that the + )SM(person)ES( class still provides public acces)HY(sors)YH( for + the now deleted data members. This might not be ideal since now + they should not be used by the appli)HY(ca)HY(tion)YH( logic. The only code + that may still need to access them is the migra)HY(tion)YH( func)HY(tions)YH(. The + recom)HY(mended)YH( way to resolve this is to remove the acces)HY(sors)YH(/modi)HY(fiers)YH( + corre)HY(spond)HY(ing)YH( to the deleted data member, make migra)HY(tion)YH( func)HY(tions)YH( + static func)HY(tions)YH( of the class being migrated, and then access + the deleted data members directly. For example:)EP( + + ) 62 61 PR(#pragma db model version\2011, 4\202 + +#pragma db object +class person +{ + ... + +private: + friend class odb::access; + + #pragma db id auto + unsigned long id_; + + #pragma db deleted\2014\202 + std::string first_; + + #pragma db deleted\2014\202 + std::string middle_; + + #pragma db deleted\2014\202 + std::string last_; + + #pragma db added\2014\202 + std::string name_; + + gender gender_; + +private: + static void + migrate_gender \201odb::database&\202; +)WR( + static void + migrate_name \201odb::database&\202; +}; + +void person:: +migrate_gender \201odb::database& db\202 +{ + for \201person& p: db.query \201\202\202 + { + p.gender_ = guess_gender \201p.first_\202; + db.update \201p\202; + } +} + +static const odb::data_migration_entry<3, MYAPP_BASE_VERSION> +migrate_name_entry \201&migrate_gender\202; + +void person:: +migrate_name \201odb::database& db\202 +{ + for \201person& p: db.query \201\202\202 + { + p.name_ = p.first_ + " " + + p.middle_ + \201p.middle_.empty \201\202 ? "" : " "\202 + + p.last_; + db.update \201p\202; + } +} + +static const odb::data_migration_entry<4, MYAPP_BASE_VERSION>)WR( +migrate_name_entry \201&migrate_name\202;)RP( + + )0 P(Another poten)HY(tial)YH( issue with the soft-dele)HY(tion)YH( is the require)HY(ment)YH( + to keep the delete data members in the class. While they will not + be initial)HY(ized)YH( in the normal oper)HY(a)HY(tion)YH( of the appli)HY(ca)HY(tion)YH( \201that + is, not a migra)HY(tion)YH(\202, this can still be a problem if we need to + mini)HY(mize)YH( the memory foot)HY(print)YH( of our classes. For example, we may + cache a large number of objects in memory and having three + )SM(std::string)ES( data members can be a signif)HY(i)HY(cant)YH( + over)HY(head)YH(.)EP( + + )0 P(The recom)HY(mended)YH( way to resolve this issue is to place all the + deleted data members into a dynam)HY(i)HY(cally)YH( allo)HY(cated)YH( compos)HY(ite)YH( + value type. For example:)EP( + + ) 33 36 PR(#pragma db model version\2011, 4\202 + +#pragma db object +class person +{ + ... + + #pragma db id auto + unsigned long id_; + + #pragma db added\2014\202 + std::string name_; + + gender gender_; + + #pragma db value + struct deleted_data + { + #pragma db deleted\2014\202 + std::string first_; + + #pragma db deleted\2014\202 + std::string middle_; + + #pragma db deleted\2014\202 + std::string last_; + }; + + #pragma db column\201""\202 + std::unique_ptr dd_; +)WR( + ... +};)RP( + + )0 P(ODB will then auto)HY(mat)HY(i)HY(cally)YH( allo)HY(cate)YH( the deleted value type if + any of the deleted data members are being loaded. During the normal + oper)HY(a)HY(tion)YH(, however, the pointer will stay )SM(NULL)ES( and + there)HY(fore)YH( reduce the common case over)HY(head)YH( to a single pointer + per class. Note that we make the compos)HY(ite)YH( value column prefix + empty \201the )SM(db\240column\201""\202)ES( pragma\202 in order to + keep the same column names for the deleted data members.)EP( + + )0 P(Soft-added and deleted data members can be used in objects, + compos)HY(ite)YH( values, views, and container value types. We can + also soft-add and delete data members of simple, compos)HY(ite)YH(, + pointer to object, and container types. Only special data + members, such as the object id and the opti)HY(mistic)YH( concur)HY(rency)YH( + version, cannot be soft-added or deleted.)EP( + + )0 P(It is also possi)HY(ble)YH( to soft-delete a persis)HY(tent)YH( class. We + can still work with the exist)HY(ing)YH( objects of such a class, + however, no table is created in new databases for soft-deleted + classes. To put it another way, a soft-delete class is like an + abstract class \201no table\202 but which can still be loaded, updated, + etc. Soft-added persis)HY(tent)YH( classes do not make much sense and + are there)HY(fore)YH( not supported.)EP( + + )0 P(As an example of a soft-deleted class, suppose we want to + replace our )SM(person)ES( class with the new + )SM(employee)ES( object and migrate the data. Here is + how we could do this:)EP( + + ) 35 61 PR(#pragma db model version\2011, 5\202 + +#pragma db object deleted\2015\202 +class person +{ + ... +}; + +#pragma db object +class employee +{ + ... + + #pragma db id auto + unsigned long id_; + + std::string name_; + gender gender_; + + static void + migrate_person \201odb::database&\202; +}; + +void employee:: +migrate_person \201odb::database& db\202 +{ + for \201person& p: db.query \201\202\202 + { + employee e \201p.name \201\202, p.gender \201\202\202; + db.persist \201e\202; + })WR( +} + +static const odb::data_migration_entry<5, MYAPP_BASE_VERSION> +migrate_person_entry \201&migrate_person\202;)RP( + + )0 P(As we have seen above, hard member addi)HY(tions)YH( and dele)HY(tions)YH( can + \201and most likely will\202 break exist)HY(ing)YH( data migra)HY(tion)YH( code. Why, + then, not treat all the changes, or at least addi)HY(tions)YH(, as soft? + ODB requires you to explic)HY(itly)YH( request this seman)HY(tics)YH( because + support for soft-added and deleted data members incurs runtime + over)HY(head)YH(. And there can be plenty of cases where there is no + exist)HY(ing)YH( data migra)HY(tion)YH( and there)HY(fore)YH( hard addi)HY(tions)YH( and dele)HY(tions)YH( + are suffi)HY(cient)YH(.)EP( + + )0 P(In some cases a hard addi)HY(tion)YH( or dele)HY(tion)YH( will result in a + compile-time error. For example, one of the data migra)HY(tion)YH( + func)HY(tions)YH( may refer)HY(ence)YH( the data member we just deleted. In + many cases, however, such errors can only be detected at + runtime, and, worse yet, only when the migra)HY(tion)YH( func)HY(tion)YH( + is executed. For example, we may hard-add a new data member + that an exist)HY(ing)YH( migra)HY(tion)YH( func)HY(tion)YH( will try to indi)HY(rectly)YH( + store in the database as part of an object update. As a result, + it is highly recom)HY(mended)YH( that you always test your appli)HY(ca)HY(tion)YH( + with the database that starts at the base version so that every + data migra)HY(tion)YH( func)HY(tion)YH( is called and there)HY(fore)YH( ensured to + still work correctly.)EP( + + )0 P(To help with this problem you can also instruct ODB to warn + you about any hard addi)HY(tions)YH( or dele)HY(tions)YH( with the + )SM(--warn-hard-add)ES(, )SM(--warn-hard-delete)ES(, + and )SM(--warn-hard)ES( command line options. ODB will + only warn you about hard changes in the current version and + only for as long as it is open, which makes this mech)HY(a)HY(nism)YH( + fairly usable.)EP( + + )0 P(You may also be wonder)HY(ing)YH( why we have to specify the addi)HY(tion)YH( + and dele)HY(tion)YH( versions explic)HY(itly)YH(. It may seem like the ODB compiler + should be able to figure this out auto)HY(mat)HY(i)HY(cally)YH(. While it is + theo)HY(ret)HY(i)HY(cally)YH( possi)HY(ble)YH(, to achieve this, ODB would have to also + main)HY(tain)YH( a sepa)HY(rate)YH( changelog of the C++ object model in + addi)HY(tion)YH( to the database schema changelog it already main)HY(tains)YH(. + While being a lot more complex, such an addi)HY(tional)YH( changelog + would also compli)HY(cate)YH( the work)HY(flow)YH( signif)HY(i)HY(cantly)YH(. In this light, + main)HY(tain)HY(ing)YH( this change infor)HY(ma)HY(tion)YH( as part of the orig)HY(i)HY(nal)YH( + source files appears to be a cleaner and simpler approach.)EP( + + )0 P(As we discussed before, when we move the base model version + forward we essen)HY(tially)YH( drop support for migra)HY(tions)YH( from + versions before the new base. As a result, it is no longer + neces)HY(sary)YH( to main)HY(tain)YH( the soft seman)HY(tics)YH( of addi)HY(tions)YH( and + dele)HY(tions)YH( up to and includ)HY(ing)YH( the new base version. ODB + will issue diag)HY(nos)HY(tics)YH( for all such members and classes. + For soft dele)HY(tions)YH( we can simply remove the data member or + class entirely. For soft addi)HY(tions)YH( we only need to remove the + )SM(db\240added)ES( pragma.)EP( + + )0 2 94 H(13.4.1)WB 419 Sn()WB 98 Sn( Reuse Inher)HY(i)HY(tance)YH( Changes)EA()EH( + + )0 P(Besides adding and delet)HY(ing)YH( data members, another way to alter + the object's table is using reuse-style inher)HY(i)HY(tance)YH(. If we add + a new reuse base, then, from the database schema point of view, + this is equiv)HY(a)HY(lent)YH( to adding all its columns to the derived + object's table. Simi)HY(larly)YH(, delet)HY(ing)YH( reuse inher)HY(i)HY(tance)YH( results in + all the base's columns being deleted from the derived's table.)EP( + + )0 P(In the future ODB may provide direct support for soft addi)HY(tion)YH( + and dele)HY(tion)YH( of inher)HY(i)HY(tance)YH(. Currently, however, this seman)HY(tics)YH( + can be emulated with soft-added and deleted data members. The + follow)HY(ing)YH( table describes the most common scenar)HY(ios)YH( depend)HY(ing)YH( + on where columns are added or deleted, that is, base table, + derived table, or both.)EP( + + + )2 PT( + + + )3 PT( + + )0 2 95 H(13.4.2)WB 420 Sn()WB 99 Sn( Poly)HY(mor)HY(phism)YH( Inher)HY(i)HY(tance)YH( Changes)EA()EH( + + )0 P(Unlike reuse inher)HY(i)HY(tance)YH(, adding or delet)HY(ing)YH( a poly)HY(mor)HY(phic)YH( base + does not result in the base's data members being added or deleted + from the derived object's table because each class in a poly)HY(mor)HY(phic)YH( + hier)HY(ar)HY(chy)YH( is stored in a sepa)HY(rate)YH( table. There are, however, other + compli)HY(ca)HY(tions)YH( due to the pres)HY(ence)YH( of special columns \201discrim)HY(i)HY(na)HY(tor)YH( + in the root table and object id links in derived tables\202 which makes + alter)HY(ing)YH( the hier)HY(ar)HY(chy)YH( struc)HY(ture)YH( diffi)HY(cult)YH( to handle auto)HY(mat)HY(i)HY(cally)YH(. + Adding or delet)HY(ing)YH( \201includ)HY(ing)YH( soft-delet)HY(ing)YH(\202 of leaf classes \201or + leaf sub-hier)HY(ar)HY(chies)YH(\202 in a poly)HY(mor)HY(phic)YH( hier)HY(ar)HY(chy)YH( is fully supported. + Any more complex changes, such as adding or delet)HY(ing)YH( the root or + an inter)HY(me)HY(di)HY(ate)YH( base or getting an exist)HY(ing)YH( class into or out of + a poly)HY(mor)HY(phic)YH( hier)HY(ar)HY(chy)YH( can be handled by creat)HY(ing)YH( a new leaf class + \201or leaf sub-hier)HY(ar)HY(chy)YH(\202, soft-delet)HY(ing)YH( the old class, and migrat)HY(ing)YH( + the data.)EP( + + + + + )WB NL NP( + )0 1 96 H(14)WB 421 Sn()WB 100 Sn( ODB Pragma Language)EA()EH( + + )0 P(As we have already seen in previ)HY(ous)YH( chap)HY(ters)YH(, ODB uses a pragma-based + language to capture database-specific infor)HY(ma)HY(tion)YH( about C++ types. + This chapter describes the ODB pragma language in more detail. It + can be read together with other chap)HY(ters)YH( in the manual to get a + sense of what kind of config)HY(u)HY(ra)HY(tions)YH( and mapping fine-tuning are + possi)HY(ble)YH(. You can also use this chapter as a refer)HY(ence)YH( at a later + stage.)EP( + + )0 P(An ODB pragma has the follow)HY(ing)YH( syntax:)EP( + + )0 P()SM(#pragma db )I(qual)HY(i)HY(fier)YH()ES( [)I(spec)HY(i)HY(fier)YH()ES( )I(spec)HY(i)HY(fier)YH()ES( ...])ES()EP( + + )0 P(The )EM(qual)HY(i)HY(fier)YH()ES( tells the ODB compiler what kind of C++ construct + this pragma describes. Valid qual)HY(i)HY(fiers)YH( are )SM(object)ES(, + )SM(view)ES(, )SM(value)ES(, )SM(member)ES(, + )SM(names)HY(pace)YH()ES(, )SM(model)ES(, )SM(index)ES(, and + )SM(map)ES(. + A pragma with the )SM(object)ES( qual)HY(i)HY(fier)YH( describes a persis)HY(tent)YH( + object type. It tells the ODB compiler that the C++ class it describes + is a persis)HY(tent)YH( class. Simi)HY(larly)YH(, pragmas with the )SM(view)ES( + qual)HY(i)HY(fier)YH( describe view types, the )SM(value)ES( qual)HY(i)HY(fier)YH( + describes value types and the )SM(member)ES( qual)HY(i)HY(fier)YH( is used + to describe data members of persis)HY(tent)YH( object, view, and value types. + The )SM(names)HY(pace)YH()ES( qual)HY(i)HY(fier)YH( is used to describe common + prop)HY(er)HY(ties)YH( of objects, views, and value types that belong to + a C++ names)HY(pace)YH( while the )SM(model)ES( qual)HY(i)HY(fier)YH( describes + the whole C++ object model. The )SM(index)ES( qual)HY(i)HY(fier)YH( defines + a database index. And, finally, the )SM(map)ES( qual)HY(i)HY(fier)YH( + describes a mapping between addi)HY(tional)YH( database types and types + for which ODB provides built-in support.)EP( + + )0 P(The )EM(spec)HY(i)HY(fier)YH()ES( informs the ODB compiler about a partic)HY(u)HY(lar)YH( + database-related prop)HY(erty)YH( of the C++ decla)HY(ra)HY(tion)YH(. For example, the + )SM(id)ES( member spec)HY(i)HY(fier)YH( tells the ODB compiler that this + member contains this object's iden)HY(ti)HY(fier)YH(. Below is the decla)HY(ra)HY(tion)YH( + of the )SM(person)ES( class that shows how we can use ODB + pragmas:)EP( + + ) 9 22 PR(#pragma db object +class person +{ + ... +private: + #pragma db member id + unsigned long id_; + ... +};)RP( + + )0 P(In the above example we don't explic)HY(itly)YH( specify which C++ class or + data member the pragma belongs to. Rather, the pragma applies to + a C++ decla)HY(ra)HY(tion)YH( that imme)HY(di)HY(ately)YH( follows the pragma. Such pragmas + are called )EM(posi)HY(tioned)YH( pragmas)ES(. In posi)HY(tioned)YH( pragmas that + apply to data members, the )SM(member)ES( qual)HY(i)HY(fier)YH( can be + omitted for brevity, for example:)EP( + + ) 2 20 PR( #pragma db id + unsigned long id_;)RP( + + )0 P(Note also that if the C++ decla)HY(ra)HY(tion)YH( imme)HY(di)HY(ately)YH( follow)HY(ing)YH( a + posi)HY(tion)YH( pragma is incom)HY(pat)HY(i)HY(ble)YH( with the pragma qual)HY(i)HY(fier)YH(, an + error will be issued. For example:)EP( + + ) 2 69 PR( #pragma db object // Error: expected class instead of data member. + unsigned long id_;)RP( + + )0 P(While keeping the C++ decla)HY(ra)HY(tions)YH( and database decla)HY(ra)HY(tions)YH( close + together eases main)HY(te)HY(nance)YH( and increases read)HY(abil)HY(ity)YH(, we can also + place them in differ)HY(ent)YH( parts of the same header file or even + factor them to a sepa)HY(rate)YH( file. To achieve this we use the so called + )EM(named pragmas)ES(. Unlike posi)HY(tioned)YH( pragmas, named pragmas + explic)HY(itly)YH( specify the C++ decla)HY(ra)HY(tion)YH( to which they apply by + adding the decla)HY(ra)HY(tion)YH( name after the pragma qual)HY(i)HY(fier)YH(. For example:)EP( + + ) 10 33 PR(class person +{ + ... +private: + unsigned long id_; + ... +}; + +#pragma db object\201person\202 +#pragma db member\201person::id_\202 id)RP( + + )0 P(Note that in the named pragmas for data members the )SM(member)ES( + qual)HY(i)HY(fier)YH( is no longer optional. The C++ decla)HY(ra)HY(tion)YH( name in the + named pragmas is resolved using the stan)HY(dard)YH( C++ name reso)HY(lu)HY(tion)YH( + rules, for example:)EP( + + ) 17 52 PR(namespace db +{ + class person + { + ... + private: + unsigned long id_; + ... + }; +} + +namespace db +{ + #pragma db object\201person\202 // Resolves db::person. +} + +#pragma db member\201db::person::id_\202 id)RP( + + )0 P(As another example, the follow)HY(ing)YH( code frag)HY(ment)YH( shows how to use the + named value type pragma to map a C++ type to a native database type:)EP( + + ) 10 57 PR(#pragma db value\201bool\202 type\201"INT"\202 + +#pragma db object +class person +{ + ... +private: + bool married_; // Mapped to INT NOT NULL database type. + ... +};)RP( + + )0 P(If we would like to factor the ODB pragmas into a sepa)HY(rate)YH( file, + we can include this file into the orig)HY(i)HY(nal)YH( header file \201the one + that defines the persis)HY(tent)YH( types\202 using the )SM(#include)ES( + direc)HY(tive)YH(, for example:)EP( + + ) 10 31 PR(// person.hxx + +class person +{ + ... +}; + +#ifdef ODB_COMPILER +# include "person-pragmas.hxx" +#endif)RP( + + )0 P(Alter)HY(na)HY(tively)YH(, instead of using the )SM(#include)ES( direc)HY(tive)YH(, + we can use the )SM(--odb-epilogue)ES( option to make the pragmas + known to the ODB compiler when compil)HY(ing)YH( the orig)HY(i)HY(nal)YH( header file, + for example:)EP( + + ) 1 47 PR(--odb-epilogue '#include "person-pragmas.hxx"')RP( + + )0 P(The follow)HY(ing)YH( sections cover the spec)HY(i)HY(fiers)YH( appli)HY(ca)HY(ble)YH( to all the + qual)HY(i)HY(fiers)YH( mentioned above.)EP( + + )0 P(The C++ header file that defines our persis)HY(tent)YH( classes and + normally contains one or more ODB pragmas is compiled by both + the ODB compiler to gener)HY(ate)YH( the database support code and + the C++ compiler to build the appli)HY(ca)HY(tion)YH(. Some C++ compil)HY(ers)YH( + issue warn)HY(ings)YH( about pragmas that they do not recog)HY(nize)YH(. There + are several ways to deal with this problem which are covered + at the end of this chapter in )0 193 1 A(Section 14.9, + "C++ Compiler Warn)HY(ings)YH(")193 0 TN TL()Ec /AF f D(.)EP( + + )0 2 97 H(14.1)WB 422 Sn()WB 101 Sn( Object Type Pragmas)EA()EH( + + )0 P(A pragma with the )SM(object)ES( qual)HY(i)HY(fier)YH( declares a C++ class + as a persis)HY(tent)YH( object type. The qual)HY(i)HY(fier)YH( can be option)HY(ally)YH( followed, + in any order, by one or more spec)HY(i)HY(fiers)YH( summa)HY(rized)YH( in the table below:)EP( + + + )4 PT( + + )0 3 98 H(14.1.1)WB 423 Sn()WB 102 Sn( )SM(table)ES()EA()EH( + + )0 P(The )SM(table)ES( spec)HY(i)HY(fier)YH( spec)HY(i)HY(fies)YH( the table name that should + be used to store objects of the persis)HY(tent)YH( class in a rela)HY(tional)YH( + database. For example:)EP( + + ) 5 33 PR(#pragma db object table\201"people"\202 +class person +{ + ... +};)RP( + + )0 P(If the table name is not spec)HY(i)HY(fied)YH(, the class name is used as the + table name. The table name can be qual)HY(i)HY(fied)YH( with a database + schema, for example:)EP( + + ) 5 40 PR(#pragma db object table\201"census.people"\202 +class person +{ + ... +};)RP( + + )0 P(For more infor)HY(ma)HY(tion)YH( on database schemas and the format of the + qual)HY(i)HY(fied)YH( names, refer to )0 109 1 A(Section 14.1.8, + ")SM(schema)ES(")109 0 TN TL()Ec /AF f D(.)EP( + + )0 3 99 H(14.1.2)WB 424 Sn()WB 103 Sn( )SM(pointer)ES()EA()EH( + + )0 P(The )SM(pointer)ES( spec)HY(i)HY(fier)YH( spec)HY(i)HY(fies)YH( the object pointer type + for the persis)HY(tent)YH( class. The object pointer type is used to return, + pass, and cache dynam)HY(i)HY(cally)YH( allo)HY(cated)YH( instances of a persis)HY(tent)YH( + class. For example:)EP( + + ) 5 55 PR(#pragma db object pointer\201std::tr1::shared_ptr\202 +class person +{ + ... +};)RP( + + )0 P(There are several ways to specify an object pointer with the + )SM(pointer)ES( spec)HY(i)HY(fier)YH(. We can use a complete pointer + type as shown in the example above. Alter)HY(na)HY(tively)YH(, we can + specify only the template name of a smart pointer in which + case the ODB compiler will auto)HY(mat)HY(i)HY(cally)YH( append the class + name as a template argu)HY(ment)YH(. The follow)HY(ing)YH( example is there)HY(fore)YH( + equiv)HY(a)HY(lent)YH( to the one above:)EP( + + ) 5 47 PR(#pragma db object pointer\201std::tr1::shared_ptr\202 +class person +{ + ... +};)RP( + + )0 P(If you would like to use the raw pointer as an object pointer, + you can use )SM(*)ES( as a short)HY(cut)YH(:)EP( + + ) 5 56 PR(#pragma db object pointer\201*\202 // Same as pointer\201person*\202 +class person +{ + ... +};)RP( + + )0 P(If a pointer type is not explic)HY(itly)YH( spec)HY(i)HY(fied)YH(, the default pointer, + spec)HY(i)HY(fied)YH( at the names)HY(pace)YH( level \201)0 185 1 A(Section 14.5.1, + ")SM(pointer)ES(")185 0 TN TL()Ec /AF f D(\202 or with the )SM(--default-pointer)ES( + ODB compiler option, is used. If neither of these two mech)HY(a)HY(nisms)YH( is + used to specify the pointer, then the raw pointer is used by default.)EP( + + )0 P(For a more detailed discus)HY(sion)YH( of object point)HY(ers)YH(, refer to + )0 26 1 A(Section 3.3, "Object and View Point)HY(ers)YH(")26 0 TN TL()Ec /AF f D(.)EP( + + )0 3 100 H(14.1.3)WB 425 Sn()WB 104 Sn( )SM(abstract)ES()EA()EH( + + )0 P(The )SM(abstract)ES( spec)HY(i)HY(fier)YH( spec)HY(i)HY(fies)YH( that the persis)HY(tent)YH( class + is abstract. An instance of an abstract class cannot be stored in + the database and is normally used as a base for other persis)HY(tent)YH( + classes. For example:)EP( + + ) 17 31 PR(#pragma db object abstract +class person +{ + ... +}; + +#pragma db object +class employee: public person +{ + ... +}; + +#pragma db object +class contractor: public person +{ + ... +};)RP( + + )0 P(Persis)HY(tent)YH( classes with pure virtual func)HY(tions)YH( are auto)HY(mat)HY(i)HY(cally)YH( + treated as abstract by the ODB compiler. For a more detailed + discus)HY(sion)YH( of persis)HY(tent)YH( class inher)HY(i)HY(tance)YH(, refer to + )0 69 1 A(Chapter 8, "Inher)HY(i)HY(tance)YH(")69 0 TN TL()Ec /AF f D(.)EP( + + )0 3 101 H(14.1.4)WB 426 Sn()WB 105 Sn( )SM(read)HY(only)YH()ES()EA()EH( + + )0 P(The )SM(read)HY(only)YH()ES( spec)HY(i)HY(fier)YH( spec)HY(i)HY(fies)YH( that the persis)HY(tent)YH( class + is read-only. The database state of read-only objects cannot be + updated. In partic)HY(u)HY(lar)YH(, this means that you cannot call the + )SM(database::update\201\202)ES( func)HY(tion)YH( \201)0 33 1 A(Section 3.10, + "Updat)HY(ing)YH( Persis)HY(tent)YH( Objects")33 0 TN TL()Ec /AF f D(\202 for such objects. For example:)EP( + + ) 5 26 PR(#pragma db object readonly +class person +{ + ... +};)RP( + + )0 P(Read-only and read-write objects can derive from each other without + any restric)HY(tions)YH(. When a read-only object derives from a read-write + object, the result)HY(ing)YH( whole object is read-only, includ)HY(ing)YH( the part + corre)HY(spond)HY(ing)YH( to the read-write base. On the other hand, when a + read-write object derives from a read-only object, all the data + members that corre)HY(spond)YH( to the read-only base are treated as + read-only while the rest is treated as read-write.)EP( + + )0 P(Note that it is also possi)HY(ble)YH( to declare indi)HY(vid)HY(ual)YH( data members + \201)0 159 1 A(Section 14.4.12, ")SM(read)HY(only)YH()ES(")159 0 TN TL()Ec /AF f D(\202 + as well as compos)HY(ite)YH( value types \201)0 131 1 A(Section 14.3.6, + ")SM(read)HY(only)YH()ES(")131 0 TN TL()Ec /AF f D(\202 as read-only.)EP( + + )0 3 102 H(14.1.5)WB 427 Sn()WB 106 Sn( )SM(opti)HY(mistic)YH()ES()EA()EH( + + )0 P(The )SM(opti)HY(mistic)YH()ES( spec)HY(i)HY(fier)YH( spec)HY(i)HY(fies)YH( that the persis)HY(tent)YH( class + has the opti)HY(mistic)YH( concur)HY(rency)YH( model. A class with the opti)HY(mistic)YH( + concur)HY(rency)YH( model must also specify the data member that is used to + store the object version using the )SM(version)ES( pragma + \201)0 163 1 A(Section 14.4.16, ")SM(version)ES(")163 0 TN TL()Ec /AF f D(\202. + For example:)EP( + + ) 8 28 PR(#pragma db object optimistic +class person +{ + ... + + #pragma db version + unsigned long version_; +};)RP( + + )0 P(If a base class has the opti)HY(mistic)YH( concur)HY(rency)YH( model, then all its derived + classes will auto)HY(mat)HY(i)HY(cally)YH( have the opti)HY(mistic)YH( concur)HY(rency)YH( model. The + current imple)HY(men)HY(ta)HY(tion)YH( also requires that in any given inher)HY(i)HY(tance)YH( + hier)HY(ar)HY(chy)YH( the object id and the version data members reside in the + same class.)EP( + + )0 P(For a more detailed discus)HY(sion)YH( of opti)HY(mistic)YH( concur)HY(rency)YH(, refer to + )0 90 1 A(Chapter 12, "Opti)HY(mistic)YH( Concur)HY(rency)YH(")90 0 TN TL()Ec /AF f D(.)EP( + + )0 3 103 H(14.1.6)WB 428 Sn()WB 107 Sn( )SM(no_id)ES()EA()EH( + + )0 P(The )SM(no_id)ES( spec)HY(i)HY(fier)YH( spec)HY(i)HY(fies)YH( that the persis)HY(tent)YH( class + has no object id. For example:)EP( + + ) 5 23 PR(#pragma db object no_id +class person +{ + ... +};)RP( + + )0 P(A persis)HY(tent)YH( class without an object id has limited func)HY(tion)HY(al)HY(ity)YH(. + Such a class cannot be loaded with the )SM(database::load\201\202)ES( + or )SM(database::find\201\202)ES( func)HY(tions)YH( \201)0 32 1 A(Section 3.9, + "Loading Persis)HY(tent)YH( Objects")32 0 TN TL()Ec /AF f D(\202, updated with the + )SM(database::update\201\202)ES( func)HY(tion)YH( \201)0 33 1 A(Section 3.10, + "Updat)HY(ing)YH( Persis)HY(tent)YH( Objects")33 0 TN TL()Ec /AF f D(\202, or deleted with the + )SM(database::erase\201\202)ES( func)HY(tion)YH( \201)0 34 1 A(Section 3.11, + "Delet)HY(ing)YH( Persis)HY(tent)YH( Objects")34 0 TN TL()Ec /AF f D(\202. To load and delete + objects without ids you can use the )SM(database::query\201\202)ES( + \201)0 38 1 A(Chapter 4, "Query)HY(ing)YH( the Database")38 0 TN TL()Ec /AF f D(\202 and + )SM(database::erase_query\201\202)ES( \201)0 34 1 A(Section 3.11, + "Delet)HY(ing)YH( Persis)HY(tent)YH( Objects")34 0 TN TL()Ec /AF f D(\202 func)HY(tions)YH(, respec)HY(tively)YH(. + There is no way to update such objects except by using native SQL + state)HY(ments)YH( \201)0 35 1 A(Section 3.12, "Execut)HY(ing)YH( Native SQL + State)HY(ments)YH(")35 0 TN TL()Ec /AF f D(\202.)EP( + + )0 P(Further)HY(more)YH(, persis)HY(tent)YH( classes without object ids cannot have container + data members nor can they be used in object rela)HY(tion)HY(ships)YH(. Such objects + are not entered into the session object cache + \201)0 88 1 A(Section 11.1, "Object Cache")88 0 TN TL()Ec /AF f D(\202 either.)EP( + + )0 P(To declare a persis)HY(tent)YH( class with an object id, use the data member + )SM(id)ES( spec)HY(i)HY(fier)YH( \201)0 148 1 A(Section 14.4.1, + ")SM(id)ES(")148 0 TN TL()Ec /AF f D(\202.)EP( + + )0 3 104 H(14.1.7)WB 429 Sn()WB 108 Sn( )SM(call)HY(back)YH()ES()EA()EH( + + )0 P(The )SM(call)HY(back)YH()ES( spec)HY(i)HY(fier)YH( spec)HY(i)HY(fies)YH( the persist class + member func)HY(tion)YH( that should be called before and after a + database oper)HY(a)HY(tion)YH( is performed on an object of this class. + For example:)EP( + + ) 10 45 PR(#include + +#pragma db object callback\201init\202 +class person +{ + ... + + void + init \201odb::callback_event, odb::database&\202; +};)RP( + + )0 P(The call)HY(back)YH( func)HY(tion)YH( has the follow)HY(ing)YH( signa)HY(ture)YH( and can be + over)HY(loaded)YH( for constant objects:)EP( + + ) 5 49 PR(void +name \201odb::callback_event, odb::database&\202; + +void +name \201odb::callback_event, odb::database&\202 const;)RP( + + )0 P(The first argu)HY(ment)YH( to the call)HY(back)YH( func)HY(tion)YH( is the event that + trig)HY(gered)YH( this call. The )SM(odb::call)HY(back)YH(_event)ES( + enum-like type is defined in the )SM()ES( + header file and has the follow)HY(ing)YH( inter)HY(face)YH(:)EP( + + ) 20 29 PR(namespace odb +{ + struct callback_event + { + enum value + { + pre_persist, + post_persist, + pre_load, + post_load, + pre_update, + post_update, + pre_erase, + post_erase + }; + + callback_event \201value v\202; + operator value \201\202 const; + }; +})RP( + + )0 P(The second argu)HY(ment)YH( to the call)HY(back)YH( func)HY(tion)YH( is the database + on which the oper)HY(a)HY(tion)YH( is about to be performed or has just + been performed. A call)HY(back)YH( func)HY(tion)YH( can be inline or virtual.)EP( + + )0 P(The call)HY(back)YH( func)HY(tion)YH( for the )SM(*_persist)ES(, + )SM(*_update)ES(, and )SM(*_erase)ES( events is always + called on the constant object refer)HY(ence)YH( while for the )SM(*_load)ES( + events \236 always on the unre)HY(stricted)YH( refer)HY(ence)YH(.)EP( + + )0 P(If only the non-)SM(const)ES( version of the call)HY(back)YH( func)HY(tion)YH( + is provided, then only the )SM(*_load)ES( events will be deliv)HY(ered)YH(. + If only the )SM(const)ES( version is provided, then all the + events will be deliv)HY(ered)YH( to this func)HY(tion)YH(. Finally, if both versions + are provided, then the )SM(*_load)ES( events will be deliv)HY(ered)YH( + to the non-)SM(const)ES( version while all others \236 to the + )SM(const)ES( version. If you need to modify the object in one + of the ")SM(const)ES(" events, then you can safely cast away + )SM(const)ES(-ness using the )SM(const_cast)ES( oper)HY(a)HY(tor)YH( if + you know that none of the objects will be created const. Alter)HY(na)HY(tively)YH(, + if you cannot make this assump)HY(tion)YH(, then you can declare the data + members you wish to modify as )SM(mutable)ES(.)EP( + + )0 P(A database oper)HY(a)HY(tions)YH( call)HY(back)YH( can be used to imple)HY(ment)YH( object-specific + pre and post initial)HY(iza)HY(tions)YH(, regis)HY(tra)HY(tions)YH(, and cleanups. As an example, + the follow)HY(ing)YH( code frag)HY(ment)YH( outlines an imple)HY(men)HY(ta)HY(tion)YH( of a + )SM(person)ES( class that main)HY(tains)YH( the tran)HY(sient)YH( )SM(age)ES( + data member in addi)HY(tion)YH( to the persis)HY(tent)YH( date of birth. A call)HY(back)YH( + is used to calcu)HY(late)YH( the value of the former from the latter every + time a )SM(person)ES( object is loaded from the database.)EP( + + ) 32 46 PR(#include +#include + +#pragma db object callback\201init\202 +class person +{ + ... + +private: + friend class odb::access; + + date born_; + + #pragma db transient + unsigned short age_; + + void + init \201odb::callback_event e, odb::database&\202 + { + switch \201e\202 + { + case odb::callback_event::post_load: + { + // Calculate age from the date of birth. + ... + break; + } + default: + break; + } + })WR( +};)RP( + + )0 3 105 H(14.1.8)WB 430 Sn()WB 109 Sn( )SM(schema)ES()EA()EH( + + )0 P(The )SM(schema)ES( spec)HY(i)HY(fier)YH( spec)HY(i)HY(fies)YH( a database schema + that should be used for the persis)HY(tent)YH( class.)EP( + + )0 P(In rela)HY(tional)YH( databases the term schema can refer to two related + but ulti)HY(mately)YH( differ)HY(ent)YH( concepts. Normally it means a collec)HY(tion)YH( + of tables, indexes, sequences, etc., that are created in the + database or the actual DDL state)HY(ments)YH( that create these + database objects. Some database imple)HY(men)HY(ta)HY(tions)YH( support what + would be more accu)HY(rately)YH( called a )EM(database names)HY(pace)YH()ES( + but is also called a schema. In this sense, a schema is a + sepa)HY(rate)YH( names)HY(pace)YH( in which tables, indexes, sequences, etc., + can be created. For example, two tables that have the same + name can coexist in the same database if they belong to + differ)HY(ent)YH( schemas. In this section when we talk about a + schema, we refer to the )EM(database names)HY(pace)YH()ES( meaning + of this term. )EP( + + )0 P(When schemas are in use, a database object name is qual)HY(i)HY(fied)YH( + with a schema. For example:)EP( + + ) 3 45 PR(CREATE TABLE accounting.employee \201...\202 + +SELECT ... FROM accounting.employee WHERE ...)RP( + + )0 P(In the above example )SM(account)HY(ing)YH()ES( is the schema + and the )SM(employee)ES( table belongs to this + schema.)EP( + + )0 P(Not all database imple)HY(men)HY(ta)HY(tions)YH( support schemas. Some + imple)HY(men)HY(ta)HY(tion)YH( that don't support schemas \201for example, + MySQL, SQLite\202 allow the use of the above syntax to specify + the database name. Yet others may support several levels + of qual)HY(i)HY(fi)HY(ca)HY(tion)YH(. For example, Microsoft SQL Server has + three levels start)HY(ing)YH( with the linked database server, + followed by the database, and then followed by + the schema: + )SM(server1.company1.account)HY(ing)YH(.employee)ES(. + While the actual meaning of the qual)HY(i)HY(fier)YH( in a qual)HY(i)HY(fied)YH( name + vary from one database imple)HY(men)HY(ta)HY(tion)YH( to another, here we + refer to all of them collec)HY(tively)YH( as a schema.)EP( + + )0 P(In ODB, a schema for a table of a persis)HY(tent)YH( class can be + spec)HY(i)HY(fied)YH( at the class level, C++ names)HY(pace)YH( level, or the + file level. To assign a schema to a specific persis)HY(tent)YH( class + we can use the )SM(schema)ES( spec)HY(i)HY(fier)YH(, for example:)EP( + + ) 5 38 PR(#pragma db object schema\201"accounting"\202 +class employee +{ + ... +};)RP( + + )0 P(If we are also assign)HY(ing)YH( a table name, then we can use + a shorter nota)HY(tion)YH( by spec)HY(i)HY(fy)HY(ing)YH( both the schema and + the table name in the )SM(table)ES( spec)HY(i)HY(fier)YH(:)EP( + + ) 5 46 PR(#pragma db object table\201"accounting.employee"\202 +class employee +{ + ... +};)RP( + + )0 P(If we want to assign a schema to all the persis)HY(tent)YH( classes + in a C++ names)HY(pace)YH(, then, instead of spec)HY(i)HY(fy)HY(ing)YH( the schema + for each class, we can specify it once at the C++ names)HY(pace)YH( level. + For example:)EP( + + ) 15 41 PR(#pragma db namespace schema\201"accounting"\202 +namespace accounting +{ + #pragma db object + class employee + { + ... + }; + + #pragma db object + class employer + { + ... + }; +})RP( + + )0 P(If we want to assign a schema to all the persis)HY(tent)YH( classes in + a file, then we can use the )SM(--schema)ES( ODB compiler + option. For example:)EP( + + ) 1 31 PR(odb ... --schema accounting ...)RP( + + )0 P(An alter)HY(na)HY(tive)YH( to this approach with the same effect is to + assign a schema to the global names)HY(pace)YH(:)EP( + + ) 1 43 PR(#pragma db namespace\201\202 schema\201"accounting"\202)RP( + + )0 P(By default schema qual)HY(i)HY(fi)HY(ca)HY(tions)YH( are accu)HY(mu)HY(lated)YH( start)HY(ing)YH( from + the persis)HY(tent)YH( class, contin)HY(u)HY(ing)YH( with the names)HY(pace)YH( hier)HY(ar)HY(chy)YH( + to which this class belongs, and finish)HY(ing)YH( with the schema + spec)HY(i)HY(fied)YH( with the )SM(--schema)ES( option. For + example:)EP( + + ) 13 43 PR(#pragma db namespace schema\201"audit_db"\202 +namespace audit +{ + #pragma db namespace schema\201"accounting"\202 + namespace accounting + { + #pragma db object + class employee + { + ... + }; + } +})RP( + + )0 P(If we compile the above code frag)HY(ment)YH( with the + )SM(--schema\240server1)ES( option, then the + )SM(employee)ES( table will have the + )SM(server1.audit_db.account)HY(ing)YH(.employee)ES( qual)HY(i)HY(fied)YH( + name.)EP( + + )0 P(In some situ)HY(a)HY(tions)YH( we may want to prevent such accu)HY(mu)HY(la)HY(tion)YH( + of the qual)HY(i)HY(fi)HY(ca)HY(tions)YH(. To accom)HY(plish)YH( this we can use the + so-called fully-qual)HY(i)HY(fied)YH( names, which have the empty leading + name compo)HY(nent)YH(. This is anal)HY(o)HY(gous)YH( to the C++ fully-qual)HY(i)HY(fied)YH( + names in the )SM(::account)HY(ing)YH(::employee)ES( form. For + example:)EP( + + ) 15 41 PR(#pragma db namespace schema\201"accounting"\202 +namespace accounting +{ + #pragma db object schema\201".hr"\202 + class employee + { + ... + }; + + #pragma db object + class employer + { + ... + }; +})RP( + + )0 P(In the above code frag)HY(ment)YH(, the )SM(employee)ES( table will + have the )SM(hr.employee)ES( qual)HY(i)HY(fied)YH( name while the + )SM(employer)ES( \236 )SM(account)HY(ing)YH(.employer)ES(. + Note also that the empty leading name compo)HY(nent)YH( is a special + ODB syntax and is not prop)HY(a)HY(gated)YH( to the actual database names + \201using a name like )SM(.hr.employee)ES( to refer to a table + will most likely result in an error\202.)EP( + + )0 P(Auxil)HY(iary)YH( database objects for a persis)HY(tent)YH( class, such as indexes, + sequences, trig)HY(gers)YH(, etc., are all created in the same schema + as the class table. By default, this is also true for the + container tables. However, if you need to store a container + table in a differ)HY(ent)YH( schema, then you can provide a qual)HY(i)HY(fied)YH( + name using the )SM(table)ES( spec)HY(i)HY(fier)YH(, for example:)EP( + + ) 8 48 PR(#pragma db object table\201"accounting.employee"\202 +class employee +{ + ... + + #pragma db object table\201"operations.projects"\202 + std::vector projects_; +};)RP( + + )0 P(The stan)HY(dard)YH( syntax for qual)HY(i)HY(fied)YH( names used in the + )SM(schema)ES( and )SM(table)ES( spec)HY(i)HY(fiers)YH( as well + as the view )SM(column)ES( spec)HY(i)HY(fier)YH( \201)0 157 1 A(Section + 14.4.10, ")SM(column)ES( \201view\202")157 0 TN TL()Ec /AF f D(\202 has the + )SM(")ES()I(name)ES()SM(.)ES()I(name)ES(...)SM(")ES( + form where, as discussed above, the leading name compo)HY(nent)YH( + can be empty to denote a fully qual)HY(i)HY(fied)YH( name. This form, however, + doesn't work if one of the name compo)HY(nents)YH( contains periods. To + support such cases the alter)HY(na)HY(tive)YH( form is avail)HY(able)YH(: + )SM(")ES()I(name)ES()SM(".")ES()I(name)ES()SM(")ES(... + For example:)EP( + + ) 5 52 PR(#pragma db object table\201"accounting_1.2"."employee"\202 +class employee +{ + ... +};)RP( + + )0 P(Finally, to specify an unqual)HY(i)HY(fied)YH( name that contains periods + we can use the follow)HY(ing)YH( special syntax:)EP( + + ) 5 61 PR(#pragma db object schema\201."accounting_1.2"\202 table\201"employee"\202 +class employee +{ + ... +};)RP( + + )0 P(Table prefixes \201)0 186 1 A(Section 14.5.2, ")SM(table)ES(")186 0 TN TL()Ec /AF f D(\202 + can be used as an alter)HY(na)HY(tive)YH( to database schemas if the target + database system does not support schemas.)EP( + + )0 3 106 H(14.1.9)WB 431 Sn()WB 110 Sn( )SM(poly)HY(mor)HY(phic)YH()ES()EA()EH( + + )0 P(The )SM(poly)HY(mor)HY(phic)YH()ES( spec)HY(i)HY(fier)YH( spec)HY(i)HY(fies)YH( that the persis)HY(tent)YH( + class is poly)HY(mor)HY(phic)YH(. For more infor)HY(ma)HY(tion)YH( on poly)HY(mor)HY(phism)YH( support, + refer to )0 69 1 A(Chapter 8, "Inher)HY(i)HY(tance)YH(")69 0 TN TL()Ec /AF f D(.)EP( + + )0 3 107 H(14.1.10)WB 432 Sn()WB 111 Sn( )SM(session)ES()EA()EH( + + )0 P(The )SM(session)ES( spec)HY(i)HY(fier)YH( spec)HY(i)HY(fies)YH( whether to enable + session support for the persis)HY(tent)YH( class. For example:)EP( + + ) 17 44 PR(#pragma db object session // Enable. +class person +{ + ... +}; + +#pragma db object session\201true\202 // Enable. +class employee +{ + ... +}; + +#pragma db object session\201false\202 // Disable. +class employer +{ + ... +};)RP( + + )0 P(Session support is disabled by default unless the + )SM(--gener)HY(ate)YH(-session)ES( ODB compiler option is spec)HY(i)HY(fied)YH( + or session support is enabled at the names)HY(pace)YH( level + \201)0 188 1 A(Section 14.5.4, ")SM(session)ES(")188 0 TN TL()Ec /AF f D(\202. + For more infor)HY(ma)HY(tion)YH( on sessions, refer to )0 87 1 A(Chapter + 11, "Session")87 0 TN TL()Ec /AF f D(.)EP( + + )0 3 108 H(14.1.11)WB 433 Sn()WB 112 Sn( )SM(defi)HY(ni)HY(tion)YH()ES()EA()EH( + + )0 P(The )SM(defi)HY(ni)HY(tion)YH()ES( spec)HY(i)HY(fier)YH( spec)HY(i)HY(fies)YH( an alter)HY(na)HY(tive)YH( + )EM(defi)HY(ni)HY(tion)YH( loca)HY(tion)YH()ES( for the persis)HY(tent)YH( class. By + default, the ODB compiler gener)HY(ates)YH( the database support code for + a persis)HY(tent)YH( class when we compile the header file that + defines this class. However, if the )SM(defi)HY(ni)HY(tion)YH()ES( + spec)HY(i)HY(fier)YH( is used, then the ODB compiler will instead gener)HY(ate)YH( + the database support code when we compile the header file + contain)HY(ing)YH( this pragma.)EP( + + )0 P(For more infor)HY(ma)HY(tion)YH( on this func)HY(tion)HY(al)HY(ity)YH(, refer to + )0 132 1 A(Section 14.3.7, ")SM(defi)HY(ni)HY(tion)YH()ES(")132 0 TN TL()Ec /AF f D(.)EP( + + )0 3 109 H(14.1.12)WB 434 Sn()WB 113 Sn( )SM(tran)HY(sient)YH()ES()EA()EH( + + )0 P(The )SM(tran)HY(sient)YH()ES( spec)HY(i)HY(fier)YH( instructs the ODB compiler to + treat all non-virtual data members in the persis)HY(tent)YH( class as tran)HY(sient)YH( + \201)0 148 1 A(Section 14.4.1, ")SM(tran)HY(sient)YH()ES(")148 0 TN TL()Ec /AF f D(\202. + This spec)HY(i)HY(fier)YH( is primar)HY(ily)YH( useful when declar)HY(ing)YH( virtual data + members, as discussed in )0 160 1 A(Section 14.4.13, + ")SM(virtual)ES(")160 0 TN TL()Ec /AF f D(.)EP( + + )0 3 110 H(14.1.13)WB 435 Sn()WB 114 Sn( )SM(section)HY(able)YH()ES()EA()EH( + + )0 P(The )SM(section)HY(able)YH()ES( spec)HY(i)HY(fier)YH( instructs the ODB compiler + to gener)HY(ate)YH( support for the addi)HY(tion)YH( of new object sections in + derived classes in a hier)HY(ar)HY(chy)YH( with the opti)HY(mistic)YH( concur)HY(rency)YH( + model. For more infor)HY(ma)HY(tion)YH( on this func)HY(tion)HY(al)HY(ity)YH(, refer to + )0 76 1 A(Section 9.2, "Sections and Opti)HY(mistic)YH( + Concur)HY(rency)YH(")76 0 TN TL()Ec /AF f D(.)EP( + + )0 3 111 H(14.1.14)WB 436 Sn()WB 115 Sn( )SM(deleted)ES()EA()EH( + + )0 P(The )SM(deleted)ES( spec)HY(i)HY(fier)YH( marks the persis)HY(tent)YH( class as + soft-deleted. The single required argu)HY(ment)YH( to this spec)HY(i)HY(fier)YH( is + the dele)HY(tion)YH( version. For more infor)HY(ma)HY(tion)YH( on this func)HY(tion)HY(al)HY(ity)YH(, + refer to )0 97 1 A(Section 13.4, "Soft Object Model + Changes")97 0 TN TL()Ec /AF f D(.)EP( + + )0 3 112 H(14.1.15)WB 437 Sn()WB 116 Sn( )SM(bulk)ES()EA()EH( + + )0 P(The )SM(bulk)ES( spec)HY(i)HY(fier)YH( enables bulk oper)HY(a)HY(tion)YH( support for + the persis)HY(tent)YH( class. The single required argu)HY(ment)YH( to this spec)HY(i)HY(fier)YH( + is the batch size. For more infor)HY(ma)HY(tion)YH( on this func)HY(tion)HY(al)HY(ity)YH(, refer + to )0 203 1 A(Section 15.3, "Bulk Database Oper)HY(a)HY(tions)YH(")203 0 TN TL()Ec /AF f D(.)EP( + + )0 2 113 H(14.2)WB 438 Sn()WB 117 Sn( View Type Pragmas)EA()EH( + + )0 P(A pragma with the )SM(view)ES( qual)HY(i)HY(fier)YH( declares a C++ class + as a view type. The qual)HY(i)HY(fier)YH( can be option)HY(ally)YH( followed, + in any order, by one or more spec)HY(i)HY(fiers)YH( summa)HY(rized)YH( in the + table below:)EP( + + + )5 PT( + + )0 P(For more infor)HY(ma)HY(tion)YH( on view types refer to )0 79 1 A( Chapter 10, + "Views")79 0 TN TL()Ec /AF f D(.)EP( + + )0 3 114 H(14.2.1)WB 439 Sn()WB 118 Sn( )SM(object)ES()EA()EH( + + )0 P(The )SM(object)ES( spec)HY(i)HY(fier)YH( spec)HY(i)HY(fies)YH( a persis)HY(tent)YH( class + that should be asso)HY(ci)HY(ated)YH( with the view. For more infor)HY(ma)HY(tion)YH( + on object asso)HY(ci)HY(a)HY(tions)YH( refer to )0 80 1 A(Section 10.1, "Object + Views")80 0 TN TL()Ec /AF f D(.)EP( + + )0 3 115 H(14.2.2)WB 440 Sn()WB 119 Sn( )SM(table)ES()EA()EH( + + )0 P(The )SM(table)ES( spec)HY(i)HY(fier)YH( spec)HY(i)HY(fies)YH( a database table + that should be asso)HY(ci)HY(ated)YH( with the view. For more infor)HY(ma)HY(tion)YH( + on table asso)HY(ci)HY(a)HY(tions)YH( refer to )0 82 1 A(Section 10.3, "Table + Views")82 0 TN TL()Ec /AF f D(.)EP( + + )0 3 116 H(14.2.3)WB 441 Sn()WB 120 Sn( )SM(query)ES()EA()EH( + + )0 P(The )SM(query)ES( spec)HY(i)HY(fier)YH( spec)HY(i)HY(fies)YH( a query condi)HY(tion)YH( + and, option)HY(ally)YH(, result modi)HY(fiers)YH( for an object or table view + or a native SQL query for a native view. An empty )SM(query)ES( + spec)HY(i)HY(fier)YH( indi)HY(cates)YH( that a native SQL query is provided at runtime. + For more infor)HY(ma)HY(tion)YH( on query condi)HY(tions)YH( refer to + )0 84 1 A(Section 10.5, "View Query Condi)HY(tions)YH(")84 0 TN TL()Ec /AF f D(. For + more infor)HY(ma)HY(tion)YH( on native SQL queries, refer to + )0 85 1 A(Section 10.6, "Native Views")85 0 TN TL()Ec /AF f D(.)EP( + + )0 3 117 H(14.2.4)WB 442 Sn()WB 121 Sn( )SM(pointer)ES()EA()EH( + + )0 P(The )SM(pointer)ES( spec)HY(i)HY(fier)YH( spec)HY(i)HY(fies)YH( the view pointer type + for the view class. Similar to objects, the view pointer type is used + to return dynam)HY(i)HY(cally)YH( allo)HY(cated)YH( instances of a view class. The + seman)HY(tics)YH( of the )SM(pointer)ES( spec)HY(i)HY(fier)YH( for a view are the + same as those of the )SM(pointer)ES( spec)HY(i)HY(fier)YH( for an object + \201)0 103 1 A(Section 14.1.2, ")SM(pointer)ES(")103 0 TN TL()Ec /AF f D(\202.)EP( + + )0 3 118 H(14.2.5)WB 443 Sn()WB 122 Sn( )SM(call)HY(back)YH()ES()EA()EH( + + )0 P(The )SM(call)HY(back)YH()ES( spec)HY(i)HY(fier)YH( spec)HY(i)HY(fies)YH( the view class + member func)HY(tion)YH( that should be called before and after an + instance of this view class is created as part of the query + result iter)HY(a)HY(tion)YH(. The seman)HY(tics)YH( of the )SM(call)HY(back)YH()ES( + spec)HY(i)HY(fier)YH( for a view are similar to those of the + )SM(call)HY(back)YH()ES( spec)HY(i)HY(fier)YH( for an object + \201)0 108 1 A(Section 14.1.7, ")SM(call)HY(back)YH()ES(")108 0 TN TL()Ec /AF f D(\202 + except that the only events that can trigger a call)HY(back)YH( + call in the case of a view are )SM(pre_load)ES( and + )SM(post_load)ES(.)EP( + + )0 3 119 H(14.2.6)WB 444 Sn()WB 123 Sn( )SM(defi)HY(ni)HY(tion)YH()ES()EA()EH( + + )0 P(The )SM(defi)HY(ni)HY(tion)YH()ES( spec)HY(i)HY(fier)YH( spec)HY(i)HY(fies)YH( an alter)HY(na)HY(tive)YH( + )EM(defi)HY(ni)HY(tion)YH( loca)HY(tion)YH()ES( for the view class. By + default, the ODB compiler gener)HY(ates)YH( the database support code for + a view class when we compile the header file that + defines this class. However, if the )SM(defi)HY(ni)HY(tion)YH()ES( + spec)HY(i)HY(fier)YH( is used, then the ODB compiler will instead gener)HY(ate)YH( + the database support code when we compile the header file + contain)HY(ing)YH( this pragma.)EP( + + )0 P(For more infor)HY(ma)HY(tion)YH( on this func)HY(tion)HY(al)HY(ity)YH(, refer to + )0 132 1 A(Section 14.3.7, ")SM(defi)HY(ni)HY(tion)YH()ES(")132 0 TN TL()Ec /AF f D(.)EP( + + )0 3 120 H(14.2.7)WB 445 Sn()WB 124 Sn( )SM(tran)HY(sient)YH()ES()EA()EH( + + )0 P(The )SM(tran)HY(sient)YH()ES( spec)HY(i)HY(fier)YH( instructs the ODB compiler + to treat all non-virtual data members in the view class as tran)HY(sient)YH( + \201)0 148 1 A(Section 14.4.1, ")SM(tran)HY(sient)YH()ES(")148 0 TN TL()Ec /AF f D(\202. + This spec)HY(i)HY(fier)YH( is primar)HY(ily)YH( useful when declar)HY(ing)YH( virtual data + members, as discussed in )0 160 1 A(Section 14.4.13, + ")SM(virtual)ES(")160 0 TN TL()Ec /AF f D(.)EP( + + )0 2 121 H(14.3)WB 446 Sn()WB 125 Sn( Value Type Pragmas)EA()EH( + + )0 P(A pragma with the )SM(value)ES( qual)HY(i)HY(fier)YH( describes a value + type. It can be option)HY(ally)YH( followed, in any order, by one or more + spec)HY(i)HY(fiers)YH( summa)HY(rized)YH( in the table below:)EP( + + + )6 PT( + + )0 P(Many of the value type spec)HY(i)HY(fiers)YH( have corre)HY(spond)HY(ing)YH( member type + spec)HY(i)HY(fiers)YH( with the same names \201)0 147 1 A(Section 14.4, + "Data Member Pragmas")147 0 TN TL()Ec /AF f D(\202. The behav)HY(ior)YH( of such spec)HY(i)HY(fiers)YH( + for members is similar to that for value types. The only differ)HY(ence)YH( + is the scope. A partic)HY(u)HY(lar)YH( value type spec)HY(i)HY(fier)YH( applies to all the + members of this value type that don't have a pre-member version + of the spec)HY(i)HY(fier)YH(, while the member spec)HY(i)HY(fier)YH( always applies only + to a single member. Also, with a few excep)HY(tions)YH(, member spec)HY(i)HY(fiers)YH( + take prece)HY(dence)YH( over and over)HY(ride)YH( param)HY(e)HY(ters)YH( spec)HY(i)HY(fied)YH( with value + spec)HY(i)HY(fiers)YH(.)EP( + + )0 3 122 H(14.3.1)WB 447 Sn()WB 126 Sn( )SM(type)ES()EA()EH( + + )0 P(The )SM(type)ES( spec)HY(i)HY(fier)YH( spec)HY(i)HY(fies)YH( the native database type + that should be used for data members of this type. For example:)EP( + + ) 9 57 PR(#pragma db value\201bool\202 type\201"INT"\202 + +#pragma db object +class person +{ + ... + + bool married_; // Mapped to INT NOT NULL database type. +};)RP( + + )0 P(The ODB compiler provides the default mapping between common C++ + types, such as )SM(bool)ES(, )SM(int)ES(, and + )SM(std::string)ES( and the database types for each supported + database system. For more infor)HY(ma)HY(tion)YH( on the default mapping, + refer to )0 204 1 A(Part II, "Database Systems")204 0 TN TL()Ec /AF f D(. The + )SM(null)ES( and )SM(not_null)ES( \201)0 128 1 A(Section + 14.3.3, ")SM(null)ES(/)SM(not_null)ES(")128 0 TN TL()Ec /AF f D(\202 spec)HY(i)HY(fiers)YH( + can be used to control the )SM(NULL)ES( seman)HY(tics)YH( of a type.)EP( + + )0 P(In the above example we changed the mapping for the )SM(bool)ES( + type which is now mapped to the )SM(INT)ES( database type. In + this case, the )SM(value)ES( pragma is all that is neces)HY(sary)YH( + since the ODB compiler will be able to figure out how to store + a boolean value as an integer in the database. However, there + could be situ)HY(a)HY(tions)YH( where the ODB compiler will not know how to + handle the conver)HY(sion)YH( between the C++ and database repre)HY(sen)HY(ta)HY(tions)YH( + of a value. Consider, as an example, a situ)HY(a)HY(tion)YH( where the + boolean value is stored in the database as a string:)EP( + + ) 1 41 PR(#pragma db value\201bool\202 type\201"VARCHAR\2015\202"\202)RP( + + )0 P(The possi)HY(ble)YH( database values for the C++ )SM(true)ES( value could + be )SM("true")ES(, or )SM("TRUE")ES(, or )SM("True")ES(. + Or, maybe, all of the above could be valid. The ODB compiler has no way + of knowing how your appli)HY(ca)HY(tion)YH( wants to convert )SM(bool)ES( + to a string and back. To support such custom value type mappings, + ODB allows you to provide your own database conver)HY(sion)YH( func)HY(tions)YH( + by special)HY(iz)HY(ing)YH( the )SM(value_traits)ES( class template. The + )SM(mapping)ES( example in the )SM(odb-exam)HY(ples)YH()ES( + package shows how to do this for all the supported database systems.)EP( + + )0 3 123 H(14.3.2)WB 448 Sn()WB 127 Sn( )SM(id_type)ES()EA()EH( + + )0 P(The )SM(id_type)ES( spec)HY(i)HY(fier)YH( spec)HY(i)HY(fies)YH( the native database type + that should be used for data members of this type that are desig)HY(nated)YH( as + object iden)HY(ti)HY(fiers)YH( \201)0 148 1 A(Section 14.4.1, + ")SM(id)ES(")148 0 TN TL()Ec /AF f D(\202. In combi)HY(na)HY(tion)YH( with the )SM(type)ES( + spec)HY(i)HY(fier)YH( \201)0 126 1 A(Section 14.3.1, ")SM(type)ES(")126 0 TN TL()Ec /AF f D(\202 + )SM(id_type)ES( allows you to map a C++ type differ)HY(ently)YH( depend)HY(ing)YH( + on whether it is used in an ordi)HY(nary)YH( member or an object id. For + example:)EP( + + ) 12 66 PR(#pragma db value\201std::string\202 type\201"TEXT"\202 id_type\201"VARCHAR\201128\202"\202 + +#pragma db object +class person +{ + ... + + #pragma db id + std::string email_; // Mapped to VARCHAR\201128\202 NOT NULL. + + std::string name_; // Mapped to TEXT NOT NULL. +};)RP( + + )0 P(Note that there is no corre)HY(spond)HY(ing)YH( member type spec)HY(i)HY(fier)YH( for + )SM(id_type)ES( since the desired result can be achieved + with just the )SM(type)ES( spec)HY(i)HY(fier)YH(, for example:)EP( + + ) 8 36 PR(#pragma db object +class person +{ + ... + + #pragma db id type\201"VARCHAR\201128\202"\202 + std::string email_; +};)RP( + + )0 3 124 H(14.3.3)WB 449 Sn()WB 128 Sn( )SM(null)ES(/)SM(not_null)ES()EA()EH( + + )0 P(The )SM(null)ES( and )SM(not_null)ES( spec)HY(i)HY(fiers)YH( specify that + a value type or object pointer can or cannot be )SM(NULL)ES(, + respec)HY(tively)YH(. By default, value types are assumed not to allow + )SM(NULL)ES( values while object point)HY(ers)YH( are assumed to + allow )SM(NULL)ES( values. Data members of types that allow + )SM(NULL)ES( values are mapped in a rela)HY(tional)YH( database to + columns that allow )SM(NULL)ES( values. For example:)EP( + + ) 15 46 PR(using std::tr1::shared_ptr; + +typedef shared_ptr string_ptr; +#pragma db value\201string_ptr\202 type\201"TEXT"\202 null + +#pragma db object +class person +{ + ... + + string_ptr name_; // Mapped to TEXT NULL. +}; + +typedef shared_ptr person_ptr; +#pragma db value\201person_ptr\202 not_null)RP( + + )0 P(The )SM(NULL)ES( seman)HY(tics)YH( can also be spec)HY(i)HY(fied)YH( on the + per-member basis \201)0 153 1 A(Section 14.4.6, + ")SM(null)ES(/)SM(not_null)ES(")153 0 TN TL()Ec /AF f D(\202. If both a type and + a member have )SM(null)ES(/)SM(not_null)ES( spec)HY(i)HY(fiers)YH(, + then the member spec)HY(i)HY(fier)YH( takes prece)HY(dence)YH(. If a member spec)HY(i)HY(fier)YH( + relaxes the )SM(NULL)ES( seman)HY(tics)YH( \201that is, if a member has + the )SM(null)ES( spec)HY(i)HY(fier)YH( and the type has the explicit + )SM(not_null)ES( spec)HY(i)HY(fier)YH(\202, then a warning is issued.)EP( + + )0 P(It is also possi)HY(ble)YH( to over)HY(ride)YH( a previ)HY(ously)YH( spec)HY(i)HY(fied)YH( + )SM(null)ES(/)SM(not_null)ES( spec)HY(i)HY(fier)YH(. This is + primar)HY(ily)YH( useful if a third-party type, for example, + one provided by a profile library \201)0 290 1 A(Part III, + "Profiles")290 0 TN TL()Ec /AF f D(\202, allows )SM(NULL)ES( values but in your + object model data members of this type should never be + )SM(NULL)ES(. In this case you can use the )SM(not_null)ES( + spec)HY(i)HY(fier)YH( to disable )SM(NULL)ES( values for this type for the + entire trans)HY(la)HY(tion)YH( unit. For example:)EP( + + ) 7 60 PR(// By default, null_string allows NULL values. +// +#include + +// Disable NULL values for all the null_string data members. +// +#pragma db value\201null_string\202 not_null)RP( + + )0 P(For a more detailed discus)HY(sion)YH( of the )SM(NULL)ES( seman)HY(tics)YH( + for values, refer to )0 68 1 A(Section 7.3, "Point)HY(ers)YH( and + )SM(NULL)ES( Value Seman)HY(tics)YH(")68 0 TN TL()Ec /AF f D(. For a more detailed + discus)HY(sion)YH( of the )SM(NULL)ES( seman)HY(tics)YH( for object point)HY(ers)YH(, + refer to )0 52 1 A(Chapter 6, "Rela)HY(tion)HY(ships)YH(")52 0 TN TL()Ec /AF f D(.)EP( + + )0 3 125 H(14.3.4)WB 450 Sn()WB 129 Sn( )SM(default)ES()EA()EH( + + )0 P(The )SM(default)ES( spec)HY(i)HY(fier)YH( spec)HY(i)HY(fies)YH( the database default value + that should be used for data members of this type. For example:)EP( + + ) 9 59 PR(#pragma db value\201std::string\202 default\201""\202 + +#pragma db object +class person +{ + ... + + std::string name_; // Mapped to TEXT NOT NULL DEFAULT ''. +};)RP( + + )0 P(The seman)HY(tics)YH( of the )SM(default)ES( spec)HY(i)HY(fier)YH( for a value type + are similar to those of the )SM(default)ES( spec)HY(i)HY(fier)YH( for a + data member \201)0 154 1 A(Section 14.4.7, + ")SM(default)ES(")154 0 TN TL()Ec /AF f D(\202.)EP( + + )0 3 126 H(14.3.5)WB 451 Sn()WB 130 Sn( )SM(options)ES()EA()EH( + + )0 P(The )SM(options)ES( spec)HY(i)HY(fier)YH( spec)HY(i)HY(fies)YH( addi)HY(tional)YH( column + defi)HY(ni)HY(tion)YH( options that should be used for data members of this + type. For example:)EP( + + ) 9 63 PR(#pragma db value\201std::string\202 options\201"COLLATE binary"\202 + +#pragma db object +class person +{ + ... + + std::string name_; // Mapped to TEXT NOT NULL COLLATE binary. +};)RP( + + )0 P(The seman)HY(tics)YH( of the )SM(options)ES( spec)HY(i)HY(fier)YH( for a value type + are similar to those of the )SM(options)ES( spec)HY(i)HY(fier)YH( for a + data member \201)0 155 1 A(Section 14.4.8, + ")SM(options)ES(")155 0 TN TL()Ec /AF f D(\202.)EP( + + )0 3 127 H(14.3.6)WB 452 Sn()WB 131 Sn( )SM(read)HY(only)YH()ES()EA()EH( + + )0 P(The )SM(read)HY(only)YH()ES( spec)HY(i)HY(fier)YH( spec)HY(i)HY(fies)YH( that the compos)HY(ite)YH( + value type is read-only. Changes to data members of a read-only + compos)HY(ite)YH( value type are ignored when updat)HY(ing)YH( the database + state of an object \201)0 33 1 A(Section 3.10, "Updat)HY(ing)YH( Persis)HY(tent)YH( + Objects")33 0 TN TL()Ec /AF f D(\202 contain)HY(ing)YH( such a value type. Note that this spec)HY(i)HY(fier)YH( + is only valid for compos)HY(ite)YH( value types. For example:)EP( + + ) 5 25 PR(#pragma db value readonly +class person_name +{ + ... +};)RP( + + )0 P(Read-only and read-write compos)HY(ite)YH( values can derive from each other + without any restric)HY(tions)YH(. When a read-only value derives from a + read-write value, the result)HY(ing)YH( whole value is read-only, includ)HY(ing)YH( + the part corre)HY(spond)HY(ing)YH( to the read-write base. On the other hand, when a + read-write value derives from a read-only value, all the data + members that corre)HY(spond)YH( to the read-only base are treated as + read-only while the rest is treated as read-write.)EP( + + )0 P(Note that it is also possi)HY(ble)YH( to declare indi)HY(vid)HY(ual)YH( data members + \201)0 159 1 A(Section 14.4.12, ")SM(read)HY(only)YH()ES(")159 0 TN TL()Ec /AF f D(\202 + as well as whole objects \201)0 105 1 A(Section 14.1.4, + ")SM(read)HY(only)YH()ES(")105 0 TN TL()Ec /AF f D(\202 as read-only.)EP( + + )0 3 128 H(14.3.7)WB 453 Sn()WB 132 Sn( )SM(defi)HY(ni)HY(tion)YH()ES()EA()EH( + + )0 P(The )SM(defi)HY(ni)HY(tion)YH()ES( spec)HY(i)HY(fier)YH( spec)HY(i)HY(fies)YH( an alter)HY(na)HY(tive)YH( + )EM(defi)HY(ni)HY(tion)YH( loca)HY(tion)YH()ES( for the compos)HY(ite)YH( value type. By + default, the ODB compiler gener)HY(ates)YH( the database support code for + a compos)HY(ite)YH( value type when we compile the header file that + defines this value type. However, if the )SM(defi)HY(ni)HY(tion)YH()ES( + spec)HY(i)HY(fier)YH( is used, then the ODB compiler will instead gener)HY(ate)YH( + the database support code when we compile the header file contain)HY(ing)YH( + this pragma.)EP( + + )0 P(This mech)HY(a)HY(nism)YH( is primar)HY(ily)YH( useful for convert)HY(ing)YH( third-party + types to ODB compos)HY(ite)YH( value types. In such cases we normally + cannot modify the header files to add the neces)HY(sary)YH( pragmas. + It is also often incon)HY(ve)HY(nient)YH( to compile these header files + with the ODB compiler. With the )SM(defi)HY(ni)HY(tion)YH()ES( + spec)HY(i)HY(fier)YH( we can create a )EM(wrapper header)ES( that contains + the neces)HY(sary)YH( pragmas and instructs the ODB compiler to gener)HY(ate)YH( + the database support code for a third-party type when we compile + the wrapper header. As an example, consider )SM(struct timeval)ES( + that is defined in the )SM()ES( system header. + This type has the follow)HY(ing)YH( \201or similar\202 defi)HY(ni)HY(tion)YH(:)EP( + + ) 5 15 PR(struct timeval +{ + long tv_sec; + long tv_usec; +};)RP( + + )0 P(If we would like to make this type an ODB compos)HY(ite)YH( value type, + then we can create a wrapper header, for example + )SM(time-mapping.hxx)ES(, with the follow)HY(ing)YH( content:)EP( + + ) 10 50 PR(#ifndef TIME_MAPPING_HXX +#define TIME_MAPPING_HXX + +#include + +#pragma db value\201timeval\202 definition +#pragma db member\201timeval::tv_sec\202 column\201"sec"\202 +#pragma db member\201timeval::tv_usec\202 column\201"usec"\202 + +#endif // TIME_MAPPING_HXX)RP( + + )0 P(If we now compile this header with the ODB compiler, the + result)HY(ing)YH( )SM(time-mapping-odb.?xx)ES( files will + contain the database support code for )SM(struct timeval)ES(. + To use )SM(timeval)ES( in our persis)HY(tent)YH( classes, we simply + include the )SM(time-mapping.hxx)ES( header:)EP( + + ) 8 27 PR(#include +#include "time-mapping.hxx" + +#pragma db object +class object +{ + timeval timestamp; +};)RP( + + )0 3 129 H(14.3.8)WB 454 Sn()WB 133 Sn( )SM(tran)HY(sient)YH()ES()EA()EH( + + )0 P(The )SM(tran)HY(sient)YH()ES( spec)HY(i)HY(fier)YH( instructs the ODB compiler + to treat all non-virtual data members in the compos)HY(ite)YH( value type + as tran)HY(sient)YH( \201)0 148 1 A(Section 14.4.1, + ")SM(tran)HY(sient)YH()ES(")148 0 TN TL()Ec /AF f D(\202. This spec)HY(i)HY(fier)YH( is primar)HY(ily)YH( useful + when declar)HY(ing)YH( virtual data members, as discussed in + )0 160 1 A(Section 14.4.13, ")SM(virtual)ES(")160 0 TN TL()Ec /AF f D(.)EP( + + )0 3 130 H(14.3.9)WB 455 Sn()WB 134 Sn( )SM(unordered)ES()EA()EH( + + )0 P(The )SM(unordered)ES( spec)HY(i)HY(fier)YH( spec)HY(i)HY(fies)YH( that the ordered + container should be stored unordered in the database. The database + table for such a container will not contain the index column + and the order in which elements are retrieved from the database may + not be the same as the order in which they were stored. For example:)EP( + + ) 2 39 PR(typedef std::vector names; +#pragma db value\201names\202 unordered)RP( + + )0 P(For a more detailed discus)HY(sion)YH( of ordered contain)HY(ers)YH( and their + storage in the database, refer to )0 46 1 A(Section 5.1, + "Ordered Contain)HY(ers)YH(")46 0 TN TL()Ec /AF f D(.)EP( + + )0 3 131 H(14.3.10)WB 456 Sn()WB 135 Sn( )SM(index_type)ES()EA()EH( + + )0 P(The )SM(index_type)ES( spec)HY(i)HY(fier)YH( spec)HY(i)HY(fies)YH( the native + database type that should be used for the ordered container's + index column. The seman)HY(tics)YH( of )SM(index_type)ES( + are similar to those of the )SM(type)ES( spec)HY(i)HY(fier)YH( + \201)0 126 1 A(Section 14.3.1, ")SM(type)ES(")126 0 TN TL()Ec /AF f D(\202. The native + database type is expected to be an integer type. For example:)EP( + + ) 2 55 PR(typedef std::vector names; +#pragma db value\201names\202 index_type\201"SMALLINT UNSIGNED"\202)RP( + + )0 3 132 H(14.3.11)WB 457 Sn()WB 136 Sn( )SM(key_type)ES()EA()EH( + + )0 P(The )SM(key_type)ES( spec)HY(i)HY(fier)YH( spec)HY(i)HY(fies)YH( the native + database type that should be used for the map container's + key column. The seman)HY(tics)YH( of )SM(key_type)ES( + are similar to those of the )SM(type)ES( spec)HY(i)HY(fier)YH( + \201)0 126 1 A(Section 14.3.1, ")SM(type)ES(")126 0 TN TL()Ec /AF f D(\202. For + example:)EP( + + ) 2 57 PR(typedef std::map age_weight_map; +#pragma db value\201age_weight_map\202 key_type\201"INT UNSIGNED"\202)RP( + + )0 3 133 H(14.3.12)WB 458 Sn()WB 137 Sn( )SM(value_type)ES()EA()EH( + + )0 P(The )SM(value_type)ES( spec)HY(i)HY(fier)YH( spec)HY(i)HY(fies)YH( the native + database type that should be used for the container's + value column. The seman)HY(tics)YH( of )SM(value_type)ES( + are similar to those of the )SM(type)ES( spec)HY(i)HY(fier)YH( + \201)0 126 1 A(Section 14.3.1, ")SM(type)ES(")126 0 TN TL()Ec /AF f D(\202. For + example:)EP( + + ) 2 50 PR(typedef std::vector names; +#pragma db value\201names\202 value_type\201"VARCHAR\201255\202"\202)RP( + + )0 P(The )SM(value_null)ES( and )SM(value_not_null)ES( + \201)0 138 1 A(Section 14.3.13, + ")SM(value_null)ES(/)SM(value_not_null)ES(")138 0 TN TL()Ec /AF f D(\202 spec)HY(i)HY(fiers)YH( + can be used to control the )SM(NULL)ES( seman)HY(tics)YH( of a value + column.)EP( + + )0 3 134 H(14.3.13)WB 459 Sn()WB 138 Sn( )SM(value_null)ES(/)SM(value_not_null)ES()EA()EH( + + )0 P(The )SM(value_null)ES( and )SM(value_not_null)ES( spec)HY(i)HY(fiers)YH( + specify that the container type's element value can or cannot be + )SM(NULL)ES(, respec)HY(tively)YH(. The seman)HY(tics)YH( of )SM(value_null)ES( + and )SM(value_not_null)ES( are similar to those of the + )SM(null)ES( and )SM(not_null)ES( spec)HY(i)HY(fiers)YH( + \201)0 128 1 A(Section 14.3.3, ")SM(null)ES(/)SM(not_null)ES(")128 0 TN TL()Ec /AF f D(\202. + For example:)EP( + + ) 10 51 PR(using std::tr1::shared_ptr; + +#pragma db object +class account +{ + ... +}; + +typedef std::vector > accounts; +#pragma db value\201accounts\202 value_not_null)RP( + + )0 P(For set and multi)HY(set)YH( contain)HY(ers)YH( \201)0 47 1 A(Section 5.2, "Set and + Multi)HY(set)YH( Contain)HY(ers)YH(")47 0 TN TL()Ec /AF f D(\202 the element value is auto)HY(mat)HY(i)HY(cally)YH( treated + as not allow)HY(ing)YH( a )SM(NULL)ES( value.)EP( + + + )0 3 135 H(14.3.14)WB 460 Sn()WB 139 Sn( )SM(id_options)ES()EA()EH( + + )0 P(The )SM(id_options)ES( spec)HY(i)HY(fier)YH( spec)HY(i)HY(fies)YH( addi)HY(tional)YH( + column defi)HY(ni)HY(tion)YH( options that should be used for the container's + id column. For example:)EP( + + ) 2 56 PR(typedef std::vector nicknames; +#pragma db value\201nicknames\202 id_options\201"COLLATE binary"\202)RP( + + )0 P(The seman)HY(tics)YH( of the )SM(id_options)ES( spec)HY(i)HY(fier)YH( for a container + type are similar to those of the )SM(id_options)ES( spec)HY(i)HY(fier)YH( for + a container data member \201)0 176 1 A(Section 14.4.29, + ")SM(id_options)ES(")176 0 TN TL()Ec /AF f D(\202.)EP( + + + )0 3 136 H(14.3.15)WB 461 Sn()WB 140 Sn( )SM(index_options)ES()EA()EH( + + )0 P(The )SM(index_options)ES( spec)HY(i)HY(fier)YH( spec)HY(i)HY(fies)YH( addi)HY(tional)YH( + column defi)HY(ni)HY(tion)YH( options that should be used for the container's + index column. For example:)EP( + + ) 2 53 PR(typedef std::vector nicknames; +#pragma db value\201nicknames\202 index_options\201"ZEROFILL"\202)RP( + + )0 P(The seman)HY(tics)YH( of the )SM(index_options)ES( spec)HY(i)HY(fier)YH( for a container + type are similar to those of the )SM(index_options)ES( spec)HY(i)HY(fier)YH( for + a container data member \201)0 177 1 A(Section 14.4.30, + ")SM(index_options)ES(")177 0 TN TL()Ec /AF f D(\202.)EP( + + + )0 3 137 H(14.3.16)WB 462 Sn()WB 141 Sn( )SM(key_options)ES()EA()EH( + + )0 P(The )SM(key_options)ES( spec)HY(i)HY(fier)YH( spec)HY(i)HY(fies)YH( addi)HY(tional)YH( + column defi)HY(ni)HY(tion)YH( options that should be used for the container's + key column. For example:)EP( + + ) 2 58 PR(typedef std::map properties; +#pragma db value\201properties\202 key_options\201"COLLATE binary"\202)RP( + + )0 P(The seman)HY(tics)YH( of the )SM(key_options)ES( spec)HY(i)HY(fier)YH( for a container + type are similar to those of the )SM(key_options)ES( spec)HY(i)HY(fier)YH( for + a container data member \201)0 178 1 A(Section 14.4.31, + ")SM(key_options)ES(")178 0 TN TL()Ec /AF f D(\202.)EP( + + + )0 3 138 H(14.3.17)WB 463 Sn()WB 142 Sn( )SM(value_options)ES()EA()EH( + + )0 P(The )SM(value_options)ES( spec)HY(i)HY(fier)YH( spec)HY(i)HY(fies)YH( addi)HY(tional)YH( + column defi)HY(ni)HY(tion)YH( options that should be used for the container's + value column. For example:)EP( + + ) 2 59 PR(typedef std::set nicknames; +#pragma db value\201nicknames\202 value_options\201"COLLATE binary"\202)RP( + + )0 P(The seman)HY(tics)YH( of the )SM(value_options)ES( spec)HY(i)HY(fier)YH( for a container + type are similar to those of the )SM(value_options)ES( spec)HY(i)HY(fier)YH( for + a container data member \201)0 179 1 A(Section 14.4.32, + ")SM(value_options)ES(")179 0 TN TL()Ec /AF f D(\202.)EP( + + + )0 3 139 H(14.3.18)WB 464 Sn()WB 143 Sn( )SM(id_column)ES()EA()EH( + + )0 P(The )SM(id_column)ES( spec)HY(i)HY(fier)YH( spec)HY(i)HY(fies)YH( the column + name that should be used to store the object id in the + container's table. For example:)EP( + + ) 2 39 PR(typedef std::vector names; +#pragma db value\201names\202 id_column\201"id"\202)RP( + + )0 P(If the column name is not spec)HY(i)HY(fied)YH(, then )SM(object_id)ES( + is used by default.)EP( + + )0 3 140 H(14.3.19)WB 465 Sn()WB 144 Sn( )SM(index_column)ES()EA()EH( + + )0 P(The )SM(index_column)ES( spec)HY(i)HY(fier)YH( spec)HY(i)HY(fies)YH( the column + name that should be used to store the element index in the + ordered container's table. For example:)EP( + + ) 2 51 PR(typedef std::vector names; +#pragma db value\201names\202 index_column\201"name_number"\202)RP( + + )0 P(If the column name is not spec)HY(i)HY(fied)YH(, then )SM(index)ES( + is used by default.)EP( + + )0 3 141 H(14.3.20)WB 466 Sn()WB 145 Sn( )SM(key_column)ES()EA()EH( + + )0 P(The )SM(key_column)ES( spec)HY(i)HY(fier)YH( spec)HY(i)HY(fies)YH( the column + name that should be used to store the key in the map + container's table. For example:)EP( + + ) 2 55 PR(typedef std::map age_weight_map; +#pragma db value\201age_weight_map\202 key_column\201"age"\202)RP( + + )0 P(If the column name is not spec)HY(i)HY(fied)YH(, then )SM(key)ES( + is used by default.)EP( + + )0 3 142 H(14.3.21)WB 467 Sn()WB 146 Sn( )SM(value_column)ES()EA()EH( + + )0 P(The )SM(value_column)ES( spec)HY(i)HY(fier)YH( spec)HY(i)HY(fies)YH( the column + name that should be used to store the element value in the + container's table. For example:)EP( + + ) 2 55 PR(typedef std::map age_weight_map; +#pragma db value\201age_weight_map\202 value_column\201"weight"\202)RP( + + )0 P(If the column name is not spec)HY(i)HY(fied)YH(, then )SM(value)ES( + is used by default.)EP( + + + + + )0 2 143 H(14.4)WB 468 Sn()WB 147 Sn( Data Member Pragmas)EA()EH( + + )0 P(A pragma with the )SM(member)ES( qual)HY(i)HY(fier)YH( or a posi)HY(tioned)YH( + pragma without a qual)HY(i)HY(fier)YH( describes a data member. It can + be option)HY(ally)YH( followed, in any order, by one or more spec)HY(i)HY(fiers)YH( + summa)HY(rized)YH( in the table below:)EP( + + + )7 PT( + + )0 P(Many of the member spec)HY(i)HY(fiers)YH( have corre)HY(spond)HY(ing)YH( value type + spec)HY(i)HY(fiers)YH( with the same names \201)0 125 1 A(Section 14.3, + "Value Type Pragmas")125 0 TN TL()Ec /AF f D(\202. The behav)HY(ior)YH( of such spec)HY(i)HY(fiers)YH( + for members is similar to that for value types. The only differ)HY(ence)YH( + is the scope. A partic)HY(u)HY(lar)YH( value type spec)HY(i)HY(fier)YH( applies to all the + members of this value type that don't have a pre-member version + of the spec)HY(i)HY(fier)YH(, while the member spec)HY(i)HY(fier)YH( always applies only + to a single member. Also, with a few excep)HY(tions)YH(, member spec)HY(i)HY(fiers)YH( + take prece)HY(dence)YH( over and over)HY(ride)YH( param)HY(e)HY(ters)YH( spec)HY(i)HY(fied)YH( with value + spec)HY(i)HY(fiers)YH(.)EP( + + )0 3 144 H(14.4.1)WB 469 Sn()WB 148 Sn( )SM(id)ES()EA()EH( + + )0 P(The )SM(id)ES( spec)HY(i)HY(fier)YH( spec)HY(i)HY(fies)YH( that the data member contains + the object id. In a rela)HY(tional)YH( database, an iden)HY(ti)HY(fier)YH( member is + mapped to a primary key. For example:)EP( + + ) 8 21 PR(#pragma db object +class person +{ + ... + + #pragma db id + std::string email_; +};)RP( + + )0 P(Normally, every persis)HY(tent)YH( class has a data member desig)HY(nated)YH( as an + object's iden)HY(ti)HY(fier)YH(. However, it is possi)HY(ble)YH( to declare a + persis)HY(tent)YH( class without an id using the object )SM(no_id)ES( + spec)HY(i)HY(fier)YH( \201)0 107 1 A(Section 14.1.6, ")SM(no_id)ES(")107 0 TN TL()Ec /AF f D(\202.)EP( + + )0 P(Note also that the )SM(id)ES( spec)HY(i)HY(fier)YH( cannot be used for data + members of compos)HY(ite)YH( value types or views.)EP( + + )0 3 145 H(14.4.2)WB 470 Sn()WB 149 Sn( )SM(auto)ES()EA()EH( + + )0 P(The )SM(auto)ES( spec)HY(i)HY(fier)YH( spec)HY(i)HY(fies)YH( that the object's iden)HY(ti)HY(fier)YH( + is auto)HY(mat)HY(i)HY(cally)YH( assigned by the database. Only a member that was + desig)HY(nated)YH( as an object id can have this spec)HY(i)HY(fier)YH(. For example:)EP( + + ) 8 20 PR(#pragma db object +class person +{ + ... + + #pragma db id auto + unsigned long id_; +};)RP( + + )0 P(Note that auto)HY(mat)HY(i)HY(cally)YH(-assigned object ids are not reused. + If you have a high object turnover \201that is, objects are routinely + made persis)HY(tent)YH( and then erased\202, then care must be taken not to + run out of object ids. In such situ)HY(a)HY(tions)YH(, using + )SM(unsigned\240long\240long)ES( as the iden)HY(ti)HY(fier)YH( type + is a safe choice.)EP( + + )0 P(For addi)HY(tional)YH( infor)HY(ma)HY(tion)YH( on the auto)HY(matic)YH( iden)HY(ti)HY(fier)YH( assign)HY(ment)YH(, + refer to )0 31 1 A(Section 3.8, "Making Objects Persis)HY(tent)YH(")31 0 TN TL()Ec /AF f D(.)EP( + + )0 P(Note also that the )SM(auto)ES( spec)HY(i)HY(fier)YH( cannot be spec)HY(i)HY(fied)YH( + for data members of compos)HY(ite)YH( value types or views.)EP( + + )0 3 146 H(14.4.3)WB 471 Sn()WB 150 Sn( )SM(type)ES()EA()EH( + + )0 P(The )SM(type)ES( spec)HY(i)HY(fier)YH( spec)HY(i)HY(fies)YH( the native database type + that should be used for the data member. For example:)EP( + + ) 8 24 PR(#pragma db object +class person +{ + ... + + #pragma db type\201"INT"\202 + bool married_; +};)RP( + + )0 P(The )SM(null)ES( and )SM(not_null)ES( \201)0 153 1 A(Section + 14.4.6, ")SM(null)ES(/)SM(not_null)ES(")153 0 TN TL()Ec /AF f D(\202 spec)HY(i)HY(fiers)YH( + can be used to control the )SM(NULL)ES( seman)HY(tics)YH( of a data member. + It is also possi)HY(ble)YH( to specify the database type on the per-type instead + of the per-member basis using the value )SM(type)ES( + spec)HY(i)HY(fier)YH( \201)0 126 1 A(Section 14.3.1, ")SM(type)ES(")126 0 TN TL()Ec /AF f D(\202.)EP( + + )0 3 147 H(14.4.4)WB 472 Sn()WB 151 Sn( )SM(id_type)ES()EA()EH( + + )0 P(The )SM(id_type)ES( spec)HY(i)HY(fier)YH( spec)HY(i)HY(fies)YH( the native database type + that should be used for the data member when it is part of an + object iden)HY(ti)HY(fier)YH(. This spec)HY(i)HY(fier)YH( only makes sense when applied to + a member of a compos)HY(ite)YH( value type that is used for both id and + non-id members. For example:)EP( + + ) 22 68 PR(#pragma db value +class name +{ + ... + + #pragma db type\201"VARCHAR\201256\202"\202 id_type\201"VARCHAR\20164\202"\202 + std::string first_; + + #pragma db type\201"VARCHAR\201256\202"\202 id_type\201"VARCHAR\20164\202"\202 + std::string last_; +}; + +#pragma db object +class person +{ + ... + + #pragma db id + name name_; // name_.first_, name_.last_ mapped to VARCHAR\20164\202 + + name alias_; // alias_.first_, alias_.last_ mapped to VARCHAR\201256\202 +};)RP( + + )0 3 148 H(14.4.5)WB 473 Sn()WB 152 Sn( )SM(get)ES(/)SM(set)ES(/)SM(access)ES()EA()EH( + + )0 P(The )SM(get)ES( and )SM(set)ES( spec)HY(i)HY(fiers)YH( specify the + data member acces)HY(sor)YH( and modi)HY(fier)YH( expres)HY(sions)YH(, respec)HY(tively)YH(. If + provided, the gener)HY(ated)YH( database support code will use these + expres)HY(sions)YH( to access and modify the data member when perform)HY(ing)YH( + database oper)HY(a)HY(tions)YH(. The )SM(access)ES( spec)HY(i)HY(fier)YH( can be used + as a short)HY(cut)YH( to specify both the acces)HY(sor)YH( and modi)HY(fier)YH( if they + happen to be the same.)EP( + + )0 P(In its simplest form the acces)HY(sor)YH( or modi)HY(fier)YH( expres)HY(sion)YH( can be + just a name. Such a name should resolve either to another data + member of the same type or to a suit)HY(able)YH( acces)HY(sor)YH( or modi)HY(fier)YH( + member func)HY(tion)YH(. For example:)EP( + + ) 12 35 PR(#pragma db object +class person +{ + ... + +public: + const std::string& name \201\202 const; + void name \201const std::string&\202; +private: + #pragma db access\201name\202 + std::string name_; +};)RP( + + )0 P(A suit)HY(able)YH( acces)HY(sor)YH( func)HY(tion)YH( is a )SM(const)ES( member func)HY(tion)YH( + that takes no argu)HY(ments)YH( and whose return value can be implic)HY(itly)YH( + converted to the )SM(const)ES( refer)HY(ence)YH( to the member type + \201)SM(const\240std::string&)ES( in the example above\202. + An acces)HY(sor)YH( func)HY(tion)YH( that returns a )SM(const)ES( refer)HY(ence)YH( + to the data member is called )EM(by-refer)HY(ence)YH( acces)HY(sor)YH()ES(. + Other)HY(wise)YH(, it is called )EM(by-value acces)HY(sor)YH()ES(.)EP( + + )0 P(A suit)HY(able)YH( modi)HY(fier)YH( func)HY(tion)YH( can be of two forms. It can be the + so called )EM(by-refer)HY(ence)YH( modi)HY(fier)YH()ES( which is a member func)HY(tion)YH( + that takes no argu)HY(ments)YH( and returns a non-)SM(const)ES( refer)HY(ence)YH( + to the data member \201)SM(std::string&)ES( in the example above\202. + Alter)HY(na)HY(tively)YH(, it can be the so called )EM(by-value modi)HY(fier)YH()ES( which + is a member func)HY(tion)YH( taking a single argu)HY(ment)YH( \236 the new value + \236 that can be implic)HY(itly)YH( initial)HY(ized)YH( from a vari)HY(able)YH( of the member + type \201)SM(std::string)ES( in the example above\202. The return value + of a by-value modi)HY(fier)YH(, if any, is ignored. If both by-refer)HY(ence)YH( and + by-value modi)HY(fiers)YH( are avail)HY(able)YH(, then ODB prefers the by-refer)HY(ence)YH( + version since it is more effi)HY(cient)YH(. For example:)EP( + + ) 14 63 PR(#pragma db object +class person +{ + ... + +public: + std::string get_name \201\202 const; // By-value accessor. + std::string& set_name \201\202; // By-reference modifier. + void set_name \201std::string const&\202; // By-value modifier. +private: + #pragma db get\201get_name\202 \200 // Uses by-value accessor. + set\201set_name\202 // Uses by-reference modifier. + std::string name_; +};)RP( + + )0 P(Note that in many cases it is not neces)HY(sary)YH( to specify acces)HY(sor)YH( and + modi)HY(fier)YH( func)HY(tions)YH( explic)HY(itly)YH( since the ODB compiler will try to + discover them auto)HY(mat)HY(i)HY(cally)YH( in case the data member will be inac)HY(ces)HY(si)HY(ble)YH( + to the gener)HY(ated)YH( code. In partic)HY(u)HY(lar)YH(, in both of the above exam)HY(ples)YH( + the ODB compiler would have success)HY(fully)YH( discov)HY(ered)YH( the neces)HY(sary)YH( + func)HY(tions)YH(. For more infor)HY(ma)HY(tion)YH( on this func)HY(tion)HY(al)HY(ity)YH(, refer to + )0 25 1 A(Section 3.2, "Declar)HY(ing)YH( Persis)HY(tent)YH( Objects and + Values")25 0 TN TL()Ec /AF f D(.)EP( + + )0 P(Note also that by-value acces)HY(sors)YH( and by-value modi)HY(fiers)YH( cannot be + used for certain data members in certain situ)HY(a)HY(tions)YH(. These limi)HY(ta)HY(tions)YH( + are discussed in more detail later in this section.)EP( + + )0 P(Acces)HY(sor)YH( and modi)HY(fier)YH( expres)HY(sions)YH( can be more elab)HY(o)HY(rate)YH( than simple + names. An acces)HY(sor)YH( expres)HY(sion)YH( is any C++ expres)HY(sion)YH( that can be + used to initial)HY(ize)YH( a )SM(const)ES( refer)HY(ence)YH( to the member + type. Similar to acces)HY(sor)YH( func)HY(tions)YH(, which are just a special case + of acces)HY(sor)YH( expres)HY(sions)YH(, an acces)HY(sor)YH( expres)HY(sion)YH( that eval)HY(u)HY(ates)YH( to a + )SM(const)ES( refer)HY(ence)YH( to the data member is called + )EM(by-refer)HY(ence)YH( acces)HY(sor)YH( expres)HY(sion)YH()ES(. Other)HY(wise)YH(, it is + called )EM(by-value acces)HY(sor)YH( expres)HY(sion)YH()ES(.)EP( + + )0 P(Modi)HY(fier)YH( expres)HY(sions)YH( can also be of two forms: )EM(by-refer)HY(ence)YH( + modi)HY(fier)YH( expres)HY(sion)YH()ES( and )EM(by-value modi)HY(fier)YH( expres)HY(sion)YH()ES( + \201again, modi)HY(fier)YH( func)HY(tions)YH( are just a special case of modi)HY(fier)YH( + expres)HY(sions)YH(\202. A by-refer)HY(ence)YH( modi)HY(fier)YH( expres)HY(sion)YH( is any C++ + expres)HY(sion)YH( that eval)HY(u)HY(ates)YH( to the non-)SM(const)ES( refer)HY(ence)YH( + to the member type. A by-value modi)HY(fier)YH( expres)HY(sion)YH( can be a + single or multi)HY(ple)YH( \201sepa)HY(rated)YH( by semi)HY(colon)YH(\202 C++ state)HY(ments)YH( + with the effect of setting the new member value.)EP( + + )0 P(There are two special place)HY(hold)HY(ers)YH( that are recog)HY(nized)YH( by the + ODB compiler in acces)HY(sor)YH( and modi)HY(fier)YH( expres)HY(sions)YH(. The first + is the )SM(this)ES( keyword which denotes a refer)HY(ence)YH( + \201note: not a pointer\202 to the persis)HY(tent)YH( object. In acces)HY(sor)YH( + expres)HY(sions)YH( this refer)HY(ence)YH( is )SM(const)ES( while in + modi)HY(fier)YH( expres)HY(sions)YH( it is non-)SM(const)ES(. If an + expres)HY(sion)YH( does not contain the )SM(this)ES( place)HY(holder)YH(, + then the ODB compiler auto)HY(mat)HY(i)HY(cally)YH( prefixes it with )SM(this.)ES( + sequence.)EP( + + )0 P(The second place)HY(holder)YH(, the )SM(\201?\202)ES( sequence, is used + to denote the new value in by-value modi)HY(fier)YH( expres)HY(sions)YH(. The + ODB compiler replaces the ques)HY(tion)YH( mark with the vari)HY(able)YH( name, + keeping the surround)HY(ing)YH( paren)HY(the)HY(sis)YH(. The follow)HY(ing)YH( example shows + a few more inter)HY(est)HY(ing)YH( acces)HY(sor)YH( and modi)HY(fier)YH( expres)HY(sions)YH(:)EP( + + ) 39 71 PR(#pragma db value +struct point +{ + point \201int, int\202; + + int x; + int y; +}; + +#pragma db object +class person +{ + ... + + public: + const char* name \201\202 const; + void name \201const char*\202; + private: + #pragma db get\201std::string \201this.name \201\202\202\202 \200 + set\201name \201\201?\202.c_str \201\202\202\202 // The same as this.name \201...\202. + std::string name_; + + public: + const std::unique_ptr& acc \201\202 const; + void acc \201std::unique_ptr\202; + private: + #pragma db set\201acc \201std::move \201?\202\202\202 + std::unique_ptr acc_; + + public: + int loc_x \201\202 const)WR( + int loc_y \201\202 const + void loc_x \201int\202; + void loc_y \201int\202; + private: + #pragma db get\201point \201this.loc_x \201\202, this.loc_y \201\202\202\202 \200 + set\201this.loc_x \201\201?\202.x\202; this.loc_y \201\201?\202.y\202\202 + point loc_; +};)RP( + + )0 P(When the data member is of an array type, then the terms "refer)HY(ence)YH(" + and "member type" in the above discus)HY(sion)YH( should be replaced with + "pointer" and "array element type", respec)HY(tively)YH(. That is, the acces)HY(sor)YH( + expres)HY(sion)YH( for an array member is any C++ expres)HY(sion)YH( that can be + used to initial)HY(ize)YH( a )SM(const)ES( pointer to the array + element type, and so on. The follow)HY(ing)YH( example shows common + acces)HY(sor)YH( and modi)HY(fier)YH( signa)HY(tures)YH( for array members:)EP( + + ) 17 59 PR(#pragma db object +class person +{ + ... + + public: + const char* id \201\202 const; // By-reference accessor. + void id \201const char*\202; // By-value modifier. + private: + char id_[16]; + + public: + const char* pub_key \201\202 const; // By-reference accessor. + char* pub_key \201\202; // By-reference modifier. + private: + char pub_key_[2048]; +};)RP( + + )0 P(Acces)HY(sor)YH( and modi)HY(fier)YH( expres)HY(sions)YH( can be used with data members + of simple value, compos)HY(ite)YH( value, container, and object pointer + types. They can be used for data members in persis)HY(tent)YH( classes, + compos)HY(ite)YH( value types, and views. There is also a mech)HY(a)HY(nism)YH( + related to acces)HY(sors)YH( and modi)HY(fiers)YH( called virtual data members + and which is discussed in )0 160 1 A(Section 14.4.13, + ")SM(virtual)ES(")160 0 TN TL()Ec /AF f D(.)EP( + + )0 P(There are, however, certain limi)HY(ta)HY(tions)YH( when it comes to using + by-value acces)HY(sor)YH( and modi)HY(fier)YH( expres)HY(sions)YH(. First of all, if a + by-value modi)HY(fier)YH( is used, then the data member type should be + default-constructible. Further)HY(more)YH(, a compos)HY(ite)YH( value type that + has a container member cannot be modi)HY(fied)YH( with a by-value modi)HY(fier)YH(. + Only a by-refer)HY(ence)YH( modi)HY(fier)YH( expres)HY(sion)YH( can be used. The ODB + compiler will detect such cases and issue diag)HY(nos)HY(tics)YH(. For + example:)EP( + + ) 20 54 PR(#pragma db value +struct name +{ + std::string first_; + std::string last_; + std::vector aliases_; +}; + +#pragma db object +class person +{ + ... + +public: + const name& name \201\202 const; + void name \201const name&\202; +private: + #pragma db access\201name\202 // Error: by-value modifier. + name name_; +};)RP( + + )0 P(In certain database systems it is also not possi)HY(ble)YH( to use by-value + acces)HY(sor)YH( and modi)HY(fier)YH( expres)HY(sion)YH( with certain database types. + The ODB compiler is only able to detect such cases and issue diag)HY(nos)HY(tics)YH( + if you spec)HY(i)HY(fied)YH( acces)HY(sor)YH(/modi)HY(fier)YH( func)HY(tion)YH( names as opposed to custom + expres)HY(sions)YH(. For more infor)HY(ma)HY(tion)YH( on these database and type-specific + limi)HY(ta)HY(tions)YH(, refer to the "Limi)HY(ta)HY(tions)YH(" sections in )0 204 1 A(Part + II, "Database Systems")204 0 TN TL()Ec /AF f D(.)EP( + + )0 3 149 H(14.4.6)WB 474 Sn()WB 153 Sn( )SM(null)ES(/)SM(not_null)ES()EA()EH( + + )0 P(The )SM(null)ES( and )SM(not_null)ES( spec)HY(i)HY(fiers)YH( specify that + the data member can or cannot be )SM(NULL)ES(, respec)HY(tively)YH(. + By default, data members of basic value types for which database + mapping is provided by the ODB compiler do not allow )SM(NULL)ES( + values while data members of object point)HY(ers)YH( allow )SM(NULL)ES( + values. Other value types, such as those provided by the profile + libraries \201)0 290 1 A(Part III, "Profiles")290 0 TN TL()Ec /AF f D(\202, may or may + not allow )SM(NULL)ES( values, depend)HY(ing)YH( on the seman)HY(tics)YH( + of each value type. Consult the rele)HY(vant)YH( docu)HY(men)HY(ta)HY(tion)YH( to find + out more about the )SM(NULL)ES( seman)HY(tics)YH( for such value + types. A data member contain)HY(ing)YH( the object id \201)0 148 1 A(Section + 14.4.1, ")SM(id)ES(")148 0 TN TL()Ec /AF f D(\202 is auto)HY(mat)HY(i)HY(cally)YH( treated as not + allow)HY(ing)YH( a )SM(NULL)ES( value. Data members that + allow )SM(NULL)ES( values are mapped in a rela)HY(tional)YH( database + to columns that allow )SM(NULL)ES( values. For example:)EP( + + ) 19 29 PR(using std::tr1::shared_ptr; + +#pragma db object +class person +{ + ... + + #pragma db null + std::string name_; +}; + +#pragma db object +class account +{ + ... + + #pragma db not_null + shared_ptr holder_; +};)RP( + + )0 P(The )SM(NULL)ES( seman)HY(tics)YH( can also be spec)HY(i)HY(fied)YH( on the + per-type basis \201)0 128 1 A(Section 14.3.3, + ")SM(null)ES(/)SM(not_null)ES(")128 0 TN TL()Ec /AF f D(\202. If both a type and + a member have )SM(null)ES(/)SM(not_null)ES( spec)HY(i)HY(fiers)YH(, + then the member spec)HY(i)HY(fier)YH( takes prece)HY(dence)YH(. If a member spec)HY(i)HY(fier)YH( + relaxes the )SM(NULL)ES( seman)HY(tics)YH( \201that is, if a member has + the )SM(null)ES( spec)HY(i)HY(fier)YH( and the type has the explicit + )SM(not_null)ES( spec)HY(i)HY(fier)YH(\202, then a warning is issued.)EP( + + )0 P(For a more detailed discus)HY(sion)YH( of the )SM(NULL)ES( seman)HY(tics)YH( + for values, refer to )0 68 1 A(Section 7.3, "Point)HY(ers)YH( and + )SM(NULL)ES( Value Seman)HY(tics)YH(")68 0 TN TL()Ec /AF f D(. For a more detailed + discus)HY(sion)YH( of the )SM(NULL)ES( seman)HY(tics)YH( for object point)HY(ers)YH(, + refer to )0 52 1 A(Chapter 6, "Rela)HY(tion)HY(ships)YH(")52 0 TN TL()Ec /AF f D(.)EP( + + )0 3 150 H(14.4.7)WB 475 Sn()WB 154 Sn( )SM(default)ES()EA()EH( + + )0 P(The )SM(default)ES( spec)HY(i)HY(fier)YH( spec)HY(i)HY(fies)YH( the database default value + that should be used for the data member. For example:)EP( + + ) 8 62 PR(#pragma db object +class person +{ + ... + + #pragma db default\201-1\202 + int age_; // Mapped to INT NOT NULL DEFAULT -1. +};)RP( + + )0 P(A default value can be the special )SM(null)ES( keyword, + a )SM(bool)ES( literal \201)SM(true)ES( or )SM(false)ES(\202, + an integer literal, a float)HY(ing)YH( point literal, a string literal, or + an enumer)HY(a)HY(tor)YH( name. If you need to specify a default value that is + an expres)HY(sion)YH(, for example an SQL func)HY(tion)YH( call, then you can use + the )SM(options)ES( spec)HY(i)HY(fier)YH( \201)0 155 1 A(Section + 14.4.8, ")SM(options)ES(")155 0 TN TL()Ec /AF f D(\202 instead. For example:)EP( + + ) 25 68 PR(enum gender {male, female, undisclosed}; + +#pragma db object +class person +{ + ... + + #pragma db default\201null\202 + odb::nullable middle_; // DEFAULT NULL + + #pragma db default\201false\202 + bool married_; // DEFAULT 0/FALSE + + #pragma db default\2010.0\202 + float weight_; // DEFAULT 0.0 + + #pragma db default\201"Mr"\202 + string title_; // DEFAULT 'Mr' + + #pragma db default\201undisclosed\202 + gender gender_; // DEFAULT 2/'undisclosed' + + #pragma db options\201"DEFAULT CURRENT_TIMESTAMP\201\202"\202 + date timestamp_; // DEFAULT CURRENT_TIMESTAMP\201\202 +};)RP( + + )0 P(Default values spec)HY(i)HY(fied)YH( as enumer)HY(a)HY(tors)YH( are only supported for + members that are mapped to an )SM(ENUM)ES( or an integer + type in the database, which is the case for the auto)HY(matic)YH( + mapping of C++ enums and enum classes to suit)HY(able)YH( database + types as performed by the ODB compiler. If you have mapped + a C++ enum or enum class to another database type, then you + should use a literal corre)HY(spond)HY(ing)YH( to that type to specify + the default value. For example:)EP( + + ) 11 60 PR(enum gender {male, female, undisclosed}; +#pragma db value\201gender\202 type\201"VARCHAR\20111\202"\202 + +#pragma db object +class person +{ + ... + + #pragma db default\201"undisclosed"\202 + gender gender_; // DEFAULT 'undisclosed' +};)RP( + + )0 P(A default value can also be spec)HY(i)HY(fied)YH( on the per-type basis + \201)0 129 1 A(Section 14.3.4, ")SM(default)ES(")129 0 TN TL()Ec /AF f D(\202. + An empty )SM(default)ES( spec)HY(i)HY(fier)YH( can be used to reset + a default value that was previ)HY(ously)YH( spec)HY(i)HY(fied)YH( on the per-type + basis. For example:)EP( + + ) 10 43 PR(#pragma db value\201std::string\202 default\201""\202 + +#pragma db object +class person +{ + ... + + #pragma db default\201\202 + std::string name_; // No default value. +};)RP( + + )0 P(A data member contain)HY(ing)YH( the object id \201)0 148 1 A(Section + 14.4.1, ")SM(id)ES(")148 0 TN TL()Ec /AF f D( \202 is auto)HY(mat)HY(i)HY(cally)YH( treated as not + having a default value even if its type spec)HY(i)HY(fies)YH( a default value.)EP( + + )0 P(Note also that default values do not affect the gener)HY(ated)YH( C++ code + in any way. In partic)HY(u)HY(lar)YH(, no auto)HY(matic)YH( initial)HY(iza)HY(tion)YH( of data members + with their default values is performed at any point. If you need such + an initial)HY(iza)HY(tion)YH(, you will need to imple)HY(ment)YH( it your)HY(self)YH(, for example, + in your persis)HY(tent)YH( class construc)HY(tors)YH(. The default values only + affect the gener)HY(ated)YH( database schemas and, in the context of ODB, + are primar)HY(ily)YH( useful for schema evolu)HY(tion)YH(.)EP( + + )0 P(Addi)HY(tion)HY(ally)YH(, the )SM(default)ES( spec)HY(i)HY(fier)YH( cannot be spec)HY(i)HY(fied)YH( + for view data members.)EP( + + )0 3 151 H(14.4.8)WB 476 Sn()WB 155 Sn( )SM(options)ES()EA()EH( + + )0 P(The )SM(options)ES( spec)HY(i)HY(fier)YH( spec)HY(i)HY(fies)YH( addi)HY(tional)YH( column + defi)HY(ni)HY(tion)YH( options that should be used for the data member. For + example:)EP( + + ) 8 68 PR(#pragma db object +class person +{ + ... + + #pragma db options\201"CHECK\201email != ''\202"\202 + std::string email_; // Mapped to TEXT NOT NULL CHECK\201email != ''\202. +};)RP( + + )0 P(Options can also be spec)HY(i)HY(fied)YH( on the per-type basis + \201)0 130 1 A(Section 14.3.5, ")SM(options)ES(")130 0 TN TL()Ec /AF f D(\202. + By default, options are accu)HY(mu)HY(lat)HY(ing)YH(. That is, the ODB compiler + first adds all the options spec)HY(i)HY(fied)YH( for a value type followed + by all the options spec)HY(i)HY(fied)YH( for a data member. To clear the + accu)HY(mu)HY(lated)YH( options at any point in this sequence you can use + an empty )SM(options)ES( spec)HY(i)HY(fier)YH(. For example:)EP( + + ) 18 72 PR(#pragma db value\201std::string\202 options\201"COLLATE binary"\202 + +#pragma db object +class person +{ + ... + + std::string first_; // TEXT NOT NULL COLLATE binary + + #pragma db options\201"CHECK\201email != ''\202"\202 + std::string last_; // TEXT NOT NULL COLLATE binary CHECK\201email != ''\202 + + #pragma db options\201\202 + std::string title_; // TEXT NOT NULL + + #pragma db options\201\202 options\201"CHECK\201email != ''\202"\202 + std::string email_; // TEXT NOT NULL CHECK\201email != ''\202 +};)RP( + + )0 P(ODB provides dedi)HY(cated)YH( spec)HY(i)HY(fiers)YH( for spec)HY(i)HY(fy)HY(ing)YH( column types + \201)0 150 1 A(Section 14.4.3, ")SM(type)ES(")150 0 TN TL()Ec /AF f D(\202, + )SM(NULL)ES( constraints \201)0 153 1 A(Section 14.4.6, + ")SM(null)ES(/)SM(not_null)ES(")153 0 TN TL()Ec /AF f D(\202, and default + values \201)0 154 1 A(Section 14.4.7, ")SM(default)ES(")154 0 TN TL()Ec /AF f D(\202. + For ODB to func)HY(tion)YH( correctly these spec)HY(i)HY(fiers)YH( should always be + used instead of the opaque )SM(options)ES( spec)HY(i)HY(fier)YH( for + these compo)HY(nents)YH( of a column defi)HY(ni)HY(tion)YH(.)EP( + + )0 P(Note also that the )SM(options)ES( spec)HY(i)HY(fier)YH( cannot be spec)HY(i)HY(fied)YH( + for view data members.)EP( + + )0 3 152 H(14.4.9)WB 477 Sn()WB 156 Sn( )SM(column)ES( \201object, compos)HY(ite)YH( value\202)EA()EH( + + )0 P(The )SM(column)ES( spec)HY(i)HY(fier)YH( spec)HY(i)HY(fies)YH( the column name + that should be used to store the data member of a persis)HY(tent)YH( class + or compos)HY(ite)YH( value type in a rela)HY(tional)YH( database. For example:)EP( + + ) 8 35 PR(#pragma db object +class person +{ + ... + + #pragma db id column\201"person_id"\202 + unsigned long id_; +};)RP( + + )0 P(For a member of a compos)HY(ite)YH( value type, the )SM(column)ES( spec)HY(i)HY(fier)YH( + spec)HY(i)HY(fies)YH( the column name prefix. Refer to )0 67 1 A(Section 7.2.2, + "Compos)HY(ite)YH( Value Column and Table Names")67 0 TN TL()Ec /AF f D( for details.)EP( + + )0 P(If the column name is not spec)HY(i)HY(fied)YH(, it is derived from the member's + so-called public name. A public member name is obtained by remov)HY(ing)YH( + the common data member name deco)HY(ra)HY(tions)YH(, such as leading and trail)HY(ing)YH( + under)HY(scores)YH(, the )SM(m_)ES( prefix, etc.)EP( + + )0 3 153 H(14.4.10)WB 478 Sn()WB 157 Sn( )SM(column)ES( \201view\202)EA()EH( + + )0 P(The )SM(column)ES( spec)HY(i)HY(fier)YH( can be used to specify the asso)HY(ci)HY(ated)YH( + object data member, the poten)HY(tially)YH( qual)HY(i)HY(fied)YH( column name, or the column + expres)HY(sion)YH( for the data member of a view class. For more infor)HY(ma)HY(tion)YH(, + refer to )0 80 1 A(Section 10.1, "Object Views")80 0 TN TL()Ec /AF f D( and + )0 82 1 A(Section 10.3, "Table Views")82 0 TN TL()Ec /AF f D(.)EP( + + )0 3 154 H(14.4.11)WB 479 Sn()WB 158 Sn( )SM(tran)HY(sient)YH()ES()EA()EH( + + )0 P(The )SM(tran)HY(sient)YH()ES( spec)HY(i)HY(fier)YH( instructs the ODB compiler + not to store the data member in the database. For example:)EP( + + ) 10 46 PR(#pragma db object +class person +{ + ... + + date born_; + + #pragma db transient + unsigned short age_; // Computed from born_. +};)RP( + + )0 P(This pragma is usually used on computed members, point)HY(ers)YH( and + refer)HY(ences)YH( that are only mean)HY(ing)HY(ful)YH( in the appli)HY(ca)HY(tion)YH('s + memory, as well as utility members such as mutexes, etc.)EP( + + )0 3 155 H(14.4.12)WB 480 Sn()WB 159 Sn( )SM(read)HY(only)YH()ES()EA()EH( + + )0 P(The )SM(read)HY(only)YH()ES( spec)HY(i)HY(fier)YH( spec)HY(i)HY(fies)YH( that the data member of + an object or compos)HY(ite)YH( value type is read-only. Changes to a read-only + data member are ignored when updat)HY(ing)YH( the database state of an object + \201)0 33 1 A(Section 3.10, "Updat)HY(ing)YH( Persis)HY(tent)YH( Objects")33 0 TN TL()Ec /AF f D(\202 + contain)HY(ing)YH( such a member. Since views are read-only, it is not + neces)HY(sary)YH( to use this spec)HY(i)HY(fier)YH( for view data members. Object id + \201)0 148 1 A(Section 14.4.1, ")SM(id)ES(")148 0 TN TL()Ec /AF f D(\202 + and inverse \201)0 161 1 A(Section 14.4.14, + ")SM(inverse)ES(")161 0 TN TL()Ec /AF f D(\202 data members are auto)HY(mat)HY(i)HY(cally)YH( treated + as read-only and must not be explic)HY(itly)YH( declared as such. For + example:)EP( + + ) 8 21 PR(#pragma db object +class person +{ + ... + + #pragma db readonly + date born_; +};)RP( + + )0 P(Besides simple value members, object pointer, container, and compos)HY(ite)YH( + value members can also be declared read-only. A change of a pointed-to + object is ignored when updat)HY(ing)YH( the state of a read-only object + pointer. Simi)HY(larly)YH(, any changes to the number or order of + elements or to the element values them)HY(selves)YH( are ignored when + updat)HY(ing)YH( the state of a read-only container. Finally, any changes + to the members of a read-only compos)HY(ite)YH( value type are also ignored + when updat)HY(ing)YH( the state of such a compos)HY(ite)YH( value.)EP( + + )0 P(ODB auto)HY(mat)HY(i)HY(cally)YH( treats )SM(const)ES( data members as read-only. + For example, the follow)HY(ing)YH( )SM(person)ES( object is equiv)HY(a)HY(lent)YH( + to the above decla)HY(ra)HY(tion)YH( for the database persis)HY(tence)YH( purposes:)EP( + + ) 7 47 PR(#pragma db object +class person +{ + ... + + const date born_; // Automatically read-only. +};)RP( + + )0 P(When declar)HY(ing)YH( an object pointer )SM(const)ES(, make sure to + declare the pointer as )SM(const)ES( rather than \201or in addi)HY(tion)YH( + to\202 the object itself. For example:)EP( + + ) 8 69 PR(#pragma db object +class person +{ + ... + + const person* father_; // Read-write pointer to a read-only object. + person* const mother_; // Read-only pointer to a read-write object. +};)RP( + + )0 P(Note that in case of a wrapper type \201)0 68 1 A(Section 7.3, + "Point)HY(ers)YH( and )SM(NULL)ES( Value Seman)HY(tics)YH(")68 0 TN TL()Ec /AF f D(\202, both the + wrapper and the wrapped type must be )SM(const)ES( in + order for the ODB compiler to auto)HY(mat)HY(i)HY(cally)YH( treat the data + member as read-only. For example:)EP( + + ) 7 40 PR(#pragma db object +class person +{ + ... + + const std::auto_ptr born_; +};)RP( + + )0 P(Read-only members are useful when dealing with + asyn)HY(chronous)YH( changes to the state of a data member in the + database which should not be over)HY(writ)HY(ten)YH(. In other cases, + where the state of a data member never changes, declar)HY(ing)YH( such a member + read-only allows ODB to perform more effi)HY(cient)YH( object updates. + In such cases, however, it is concep)HY(tu)HY(ally)YH( more correct to + declare such a data member as )SM(const)ES( rather than + as read-only.)EP( + + )0 P(Note that it is also possi)HY(ble)YH( to declare compos)HY(ite)YH( value types + \201)0 131 1 A(Section 14.3.6, ")SM(read)HY(only)YH()ES(")131 0 TN TL()Ec /AF f D(\202 + as well as whole objects \201)0 105 1 A(Section 14.1.4, + ")SM(read)HY(only)YH()ES(")105 0 TN TL()Ec /AF f D(\202 as read-only.)EP( + + )0 3 156 H(14.4.13)WB 481 Sn()WB 160 Sn( )SM(virtual)ES()EA()EH( + + )0 P(The )SM(virtual)ES( spec)HY(i)HY(fier)YH( is used to declare a virtual + data member in an object, view, or compos)HY(ite)YH( value type. A virtual + data member is an )EM(imag)HY(i)HY(nary)YH()ES( data member that is only + used for the purpose of database persis)HY(tence)YH(. A virtual data + member does not actu)HY(ally)YH( exist \201that is, occupy space\202 in the + C++ class. Note also that virtual data members have nothing to + do with C++ virtual func)HY(tions)YH( or virtual inher)HY(i)HY(tance)YH(. Specif)HY(i)HY(cally)YH(, + no virtual func)HY(tion)YH( call over)HY(head)YH( is incurred when using virtual + data members.)EP( + + )0 P(To declare a virtual data member we must specify the data + member name using the )SM(member)ES( spec)HY(i)HY(fier)YH(. We must + also specify the data member type with the )SM(virtual)ES( + spec)HY(i)HY(fier)YH(. Finally, the virtual data member decla)HY(ra)HY(tion)YH( must + also specify the acces)HY(sor)YH( and modi)HY(fier)YH( expres)HY(sions)YH(, unless + suit)HY(able)YH( acces)HY(sor)YH( and modi)HY(fier)YH( func)HY(tions)YH( can auto)HY(mat)HY(i)HY(cally)YH( be + found by the ODB compiler \201)0 152 1 A(Section 14.4.5, + ")SM(get)ES(/)SM(set)ES(/)SM(access)ES(")152 0 TN TL()Ec /AF f D(\202. + For example:)EP( + + ) 14 62 PR(#pragma db object +class person +{ + ... + + // Transient real data member that actually stores the data. + // + #pragma db transient + std::string name_; + + // Virtual data member. + // + #pragma db member\201name\202 virtual\201std::string\202 access\201name_\202 +};)RP( + + )0 P(From the pragma language point of view, a virtual data member + behaves exactly like a normal data member. Specif)HY(i)HY(cally)YH(, we + can refer)HY(ence)YH( the virtual data member after it has been + declared and use posi)HY(tioned)YH( pragmas before its decla)HY(ra)HY(tion)YH(. + For example:)EP( + + ) 14 53 PR(#pragma db object +class person +{ + ... + + #pragma db transient + std::string name_; + + #pragma db access\201name_\202 + #pragma db member\201name\202 virtual\201std::string\202 +}; + +#pragma db member\201person::name\202 column\201"person_name"\202 +#pragma db index member\201person::name\202)RP( + + )0 P(We can also declare a virtual data member outside the class + scope:)EP( + + ) 10 66 PR(#pragma db object +class person +{ + ... + + std::string name_; +}; + +#pragma db member\201person::name_\202 transient +#pragma db member\201person::name\202 virtual\201std::string\202 access\201name_\202)RP( + + )0 P(While in the above exam)HY(ples)YH( using virtual data members doesn't + seem to yield any bene)HY(fits)YH(, this mech)HY(a)HY(nism)YH( can be useful in a + number of situ)HY(a)HY(tions)YH(. As one example, consider the need to + aggre)HY(gate)YH( or dis-aggre)HY(gate)YH( a data member:)EP( + + ) 11 67 PR(#pragma db object +class person +{ + ... + + #pragma db transient + std::pair name_; + + #pragma db member\201first\202 virtual\201std::string\202 access\201name_.first\202 + #pragma db member\201last\202 virtual\201std::string\202 access\201name_.second\202 +};)RP( + + )0 P(We can also use virtual data members to imple)HY(ment)YH( compos)HY(ite)YH( + object ids that are spread over multi)HY(ple)YH( data members:)EP( + + ) 26 66 PR(#pragma db value +struct name +{ + name \201\202 {} + name \201std::string const& f, std::string const& l\202 + : first \201f\202, last\201l\202 {} + + std::string first; + std::string last; +}; + +#pragma db object +class person +{ + ... + + #pragma db transient + std::string first_; + + #pragma db transient + std::string last_; + + #pragma db member\201name\202 virtual\201name\202 id \200 + get\201::name \201this.first_, this.last_\202\202 \200 + set\201this.first_ = \201?\202.first; this.last_ = \201?\202.last\202 +};)RP( + + )0 P(Another common situ)HY(a)HY(tion)YH( that calls for virtual data members is + a class that uses the pimpl idiom. While the follow)HY(ing)YH( code + frag)HY(ment)YH( outlines the idea, for details refer to the + )SM(pimpl)ES( example in the )SM(odb-exam)HY(ples)YH()ES( + package.)EP( + + ) 21 64 PR(#pragma db object +class person +{ +public: + std::string const& name \201\202 const; + void name \201std::string const&\202; + + unsigned short age \201\202 const; + void age \201unsigned short\202; + + ... + +private: + class impl; + + #pragma db transient + impl* pimpl_; + + #pragma db member\201name\202 virtual\201std::string\202 // Uses name\201\202. + #pragma db member\201age\202 virtual\201unsigned short\202 // Uses age\201\202. +};)RP( + + )0 P(The above example also shows that names used for virtual data + members \201)SM(name)ES( and )SM(age)ES( in our case\202 can + be the same as the names of acces)HY(sor)YH(/modi)HY(fier)YH( func)HY(tions)YH(. The only + names that virtual data members cannot clash with are those of + other data members, virtual or real.)EP( + + )0 P(A common pattern in the above exam)HY(ples)YH( is the need to + declare the real data member that actu)HY(ally)YH( stores the + data as tran)HY(sient)YH(. If all the real data members in a + class are treated as tran)HY(sient)YH(, then we can use the + class-level )SM(tran)HY(sient)YH()ES( spec)HY(i)HY(fier)YH( + \201)0 113 1 A(Section 14.1.12, ")SM(tran)HY(sient)YH()ES( + \201object\202")113 0 TN TL()Ec /AF f D(, + )0 133 1 A(Section 14.3.8, ")SM(tran)HY(sient)YH()ES( + \201compos)HY(ite)YH( value\202")133 0 TN TL()Ec /AF f D(, + )0 124 1 A(Section 14.2.7, ")SM(tran)HY(sient)YH()ES( + \201view\202")124 0 TN TL()Ec /AF f D(\202 + instead of doing it for each indi)HY(vid)HY(ual)YH( member. For example: )EP( + + ) 10 43 PR(#pragma db object transient +class person +{ + ... + + std::string first_; // Transient. + std::string last_; // Transient. + + #pragma db member\201name\202 virtual\201name\202 ... +};)RP( + + )0 P(The ability to treat all the real data members as tran)HY(sient)YH( + becomes more impor)HY(tant)YH( if we don't know the names of these + data members. This is often the case when we are working + with third-party types that docu)HY(ment)YH( the acces)HY(sor)YH( and + modi)HY(fier)YH( func)HY(tions)YH( but not the names of their private data + members. As an example, consider the )SM(point)ES( class + defined in a third-party )SM()ES( header file:)EP( + + ) 15 23 PR(class point +{ +public: + point \201\202; + point \201int x, int y\202; + + int x \201\202 const; + int y \201\202 const; + + void x \201int\202; + void y \201int\202; + +private: + ... +};)RP( + + )0 P(To convert this class to an ODB compos)HY(ite)YH( value type we could + create the )SM(point-mapping.hxx)ES( file with the follow)HY(ing)YH( + content:)EP( + + ) 5 44 PR(#include + +#pragma db value\201point\202 transient definition +#pragma db member\201point::x\202 virtual\201int\202 +#pragma db member\201point::y\202 virtual\201int\202)RP( + + )0 P(Virtual data members can be of simple value, compos)HY(ite)YH( value, + container, or object pointer types. They can be used in persis)HY(tent)YH( + classes, compos)HY(ite)YH( value types, and views.)EP( + + )0 3 157 H(14.4.14)WB 482 Sn()WB 161 Sn( )SM(inverse)ES()EA()EH( + + )0 P(The )SM(inverse)ES( spec)HY(i)HY(fier)YH( spec)HY(i)HY(fies)YH( that the data member of + an object pointer or a container of object point)HY(ers)YH( type is an + inverse side of a bidi)HY(rec)HY(tional)YH( object rela)HY(tion)HY(ship)YH(. The single + required argu)HY(ment)YH( to this spec)HY(i)HY(fier)YH( is the corre)HY(spond)HY(ing)YH( data + member name in the refer)HY(enced)YH( object. For example:)EP( + + ) 21 46 PR(using std::tr1::shared_ptr; +using std::tr1::weak_ptr; + +class person; + +#pragma db object pointer\201shared_ptr\202 +class employer +{ + ... + + std::vector > employees_; +}; + +#pragma db object pointer\201shared_ptr\202 +class person +{ + ... + + #pragma db inverse\201employee_\202 + weak_ptr employer_; +};)RP( + + )0 P(An inverse member does not have a corre)HY(spond)HY(ing)YH( column or, in case + of a container, table in the result)HY(ing)YH( database schema. Instead, the + column or table from the refer)HY(enced)YH( object is used to retrieve the + rela)HY(tion)HY(ship)YH( infor)HY(ma)HY(tion)YH(. Only ordered and set contain)HY(ers)YH( can be used + for inverse members. If an inverse member is of an ordered container + type, it is auto)HY(mat)HY(i)HY(cally)YH( marked as unordered + \201)0 166 1 A(Section 14.4.19, ")SM(unordered)ES(")166 0 TN TL()Ec /AF f D(\202.)EP( + + )0 P(For a more detailed discus)HY(sion)YH( of inverse members, refer to + )0 56 1 A(Section 6.2, "Bidi)HY(rec)HY(tional)YH( Rela)HY(tion)HY(ships)YH(")56 0 TN TL()Ec /AF f D(.)EP( + + )0 3 158 H(14.4.15)WB 483 Sn()WB 162 Sn( )SM(on_delete)ES()EA()EH( + + )0 P(The )SM(on_delete)ES( spec)HY(i)HY(fier)YH( spec)HY(i)HY(fies)YH( the on-delete seman)HY(tics)YH( + for a data member of an object pointer or a container of object + point)HY(ers)YH( type. The single required argu)HY(ment)YH( to this spec)HY(i)HY(fier)YH( must + be either )SM(cascade)ES( or )SM(set_null)ES(.)EP( + + )0 P(The )SM(on_delete)ES( spec)HY(i)HY(fier)YH( is trans)HY(lated)YH( directly to the + corre)HY(spond)HY(ing)YH( )SM(ON DELETE)ES( SQL clause. That is, if + )SM(cascade)ES( is spec)HY(i)HY(fied)YH(, then when a pointed-to object + is erased from the database, the database state of the point)HY(ing)YH( + object is auto)HY(mat)HY(i)HY(cally)YH( erased as well. If )SM(set_null)ES( is + spec)HY(i)HY(fied)YH(, then when a pointed-to object is erased from the database, + the database state of the point)HY(ing)YH( object is auto)HY(mat)HY(i)HY(cally)YH( updated + to set the pointer column to )SM(NULL)ES(. For example:)EP( + + ) 42 59 PR(#pragma db object +class employer +{ + ... + + #pragma db id auto + unsigned long id_; +}; + +#pragma db object +class person +{ + ... + + #pragma db on_delete\201cascade\202 + employer* employer_; +}; + +unsigned long id; + +{ + employer e; + person p; + p.employer_ = &e; + + transaction t \201db.begin \201\202\202; + + id = db.persist \201e\202; + db.persist \201p\202; + + t.commit \201\202;)WR( +} + +{ + transaction t \201db.begin \201\202\202; + + // Database state of the person object is erased as well. + // + db.erase \201id\202; + + t.commit \201\202; +})RP( + + + )0 P(Note that this is a database-level func)HY(tion)HY(al)HY(ity)YH( and care must be + taken in order not to end up with incon)HY(sis)HY(tent)YH( object states in the + appli)HY(ca)HY(tion)YH('s memory and database. The follow)HY(ing)YH( example illus)HY(trates)YH( + the kind of prob)HY(lems)YH( one may encounter:)EP( + + ) 45 59 PR(#pragma db object +class employer +{ + ... +}; + +#pragma db object +class person +{ + ... + + #pragma db on_delete\201set_null\202 + employer* employer_; +}; + +employer e; +person p; +p.employer_ = &e; + +{ + transaction t \201db.begin \201\202\202; + db.persist \201e\202; + db.persist \201p\202; + t.commit \201\202; +} + +{ + transaction t \201db.begin \201\202\202; + + // The employer column is set to NULL in the database but + // not the p.employer_ data member in the application.)WR( + // + db.erase \201e\202; + t.commit \201\202; +} + +{ + transaction t \201db.begin \201\202\202; + + // Override the employer column with an invalid pointer. + // + db.update \201p\202; + + t.commit \201\202; +})RP( + + )0 P(Note that even opti)HY(mistic)YH( concur)HY(rency)YH( will not resolve such + issues unless you are using database-level support for opti)HY(mistic)YH( + concur)HY(rency)YH( as well \201for example, )SM(ROWVER)HY(SION)YH()ES( in SQL + Server\202.)EP( + + )0 P(The )SM(on_delete)ES( spec)HY(i)HY(fier)YH( is only valid for non-inverse + object pointer data members. If the )SM(set_null)ES( seman)HY(tics)YH( + is used, then the pointer must allow the )SM(NULL)ES( value.)EP( + + )0 3 159 H(14.4.16)WB 484 Sn()WB 163 Sn( )SM(version)ES()EA()EH( + + )0 P(The )SM(version)ES( spec)HY(i)HY(fier)YH( spec)HY(i)HY(fies)YH( that the data member stores + the object version used to support opti)HY(mistic)YH( concur)HY(rency)YH(. If a class + has a version data member, then it must also be declared as having the + opti)HY(mistic)YH( concur)HY(rency)YH( model using the )SM(opti)HY(mistic)YH()ES( pragma + \201)0 106 1 A(Section 14.1.5, ")SM(opti)HY(mistic)YH()ES(")106 0 TN TL()Ec /AF f D(\202. For + example:)EP( + + ) 8 28 PR(#pragma db object optimistic +class person +{ + ... + + #pragma db version + unsigned long version_; +};)RP( + + )0 P(A version member must be of an inte)HY(gral)YH( C++ type and must map to + an integer or similar database type. Note also that object versions + are not reused. If you have a high update frequency, then care must + be taken not to run out of versions. In such situ)HY(a)HY(tions)YH(, using + )SM(unsigned\240long\240long)ES( as the version type is a safe + choice.)EP( + + )0 P(For a more detailed discus)HY(sion)YH( of opti)HY(mistic)YH( concur)HY(rency)YH(, refer to + )0 90 1 A(Chapter 12, "Opti)HY(mistic)YH( Concur)HY(rency)YH(")90 0 TN TL()Ec /AF f D(.)EP( + + )0 3 160 H(14.4.17)WB 485 Sn()WB 164 Sn( )SM(index)ES()EA()EH( + + )0 P(The )SM(index)ES( spec)HY(i)HY(fier)YH( instructs the ODB compiler to define + a database index for the data member. For example:)EP( + + ) 8 20 PR(#pragma db object +class person +{ + ... + + #pragma db index + std::string name_; +};)RP( + + )0 P(For more infor)HY(ma)HY(tion)YH( on defin)HY(ing)YH( database indexes, refer to + )0 191 1 A(Section 14.7, "Index Defi)HY(ni)HY(tion)YH( Pragmas")191 0 TN TL()Ec /AF f D(.)EP( + + )0 3 161 H(14.4.18)WB 486 Sn()WB 165 Sn( )SM(unique)ES()EA()EH( + + )0 P(The )SM(index)ES( spec)HY(i)HY(fier)YH( instructs the ODB compiler to define + a unique database index for the data member. For example:)EP( + + ) 8 20 PR(#pragma db object +class person +{ + ... + + #pragma db unique + std::string name_; +};)RP( + + )0 P(For more infor)HY(ma)HY(tion)YH( on defin)HY(ing)YH( database indexes, refer to + )0 191 1 A(Section 14.7, "Index Defi)HY(ni)HY(tion)YH( Pragmas")191 0 TN TL()Ec /AF f D(.)EP( + + )0 3 162 H(14.4.19)WB 487 Sn()WB 166 Sn( )SM(unordered)ES()EA()EH( + + )0 P(The )SM(unordered)ES( spec)HY(i)HY(fier)YH( spec)HY(i)HY(fies)YH( that the member of + an ordered container type should be stored unordered in the database. + The database table for such a member will not contain the index column + and the order in which elements are retrieved from the database may + not be the same as the order in which they were stored. For example:)EP( + + ) 8 38 PR(#pragma db object +class person +{ + ... + + #pragma db unordered + std::vector nicknames_; +};)RP( + + )0 P(For a more detailed discus)HY(sion)YH( of ordered contain)HY(ers)YH( and their + storage in the database, refer to )0 46 1 A(Section 5.1, + "Ordered Contain)HY(ers)YH(")46 0 TN TL()Ec /AF f D(.)EP( + + )0 3 163 H(14.4.20)WB 488 Sn()WB 167 Sn( )SM(table)ES()EA()EH( + + )0 P(The )SM(table)ES( spec)HY(i)HY(fier)YH( spec)HY(i)HY(fies)YH( the table name that should + be used to store the contents of the container member. For example:)EP( + + ) 8 38 PR(#pragma db object +class person +{ + ... + + #pragma db table\201"nicknames"\202 + std::vector nicknames_; +};)RP( + + )0 P(If the table name is not spec)HY(i)HY(fied)YH(, then the container table name + is constructed by concate)HY(nat)HY(ing)YH( the object's table name, under)HY(score)YH(, + and the public member name. The public member name is obtained + by remov)HY(ing)YH( the common member name deco)HY(ra)HY(tions)YH(, such as leading and + trail)HY(ing)YH( under)HY(scores)YH(, the )SM(m_)ES( prefix, etc. In the example + above, without the )SM(table)ES( spec)HY(i)HY(fier)YH(, the container's + table name would have been )SM(person_nick)HY(names)YH()ES(.)EP( + + )0 P(The )SM(table)ES( spec)HY(i)HY(fier)YH( can also be used for members of + compos)HY(ite)YH( value types. In this case it spec)HY(i)HY(fies)YH( the table name + prefix for container members inside the compos)HY(ite)YH( value type. Refer + to )0 67 1 A(Section 7.2.2, "Compos)HY(ite)YH( Value Column and Table + Names")67 0 TN TL()Ec /AF f D( for details.)EP( + + )0 P(The container table name can be qual)HY(i)HY(fied)YH( with a database + schema, for example:)EP( + + ) 8 38 PR(#pragma db object +class person +{ + ... + + #pragma db table\201"extras.nicknames"\202 + std::vector nicknames_; +};)RP( + + )0 P(For more infor)HY(ma)HY(tion)YH( on database schemas and the format of the + qual)HY(i)HY(fied)YH( names, refer to )0 109 1 A(Section 14.1.8, + ")SM(schema)ES(")109 0 TN TL()Ec /AF f D(.)EP( + + )0 3 164 H(14.4.21)WB 489 Sn()WB 168 Sn( )SM(load)ES(/)SM(update)ES()EA()EH( + + )0 P(The )SM(load)ES( and )SM(update)ES( spec)HY(i)HY(fiers)YH( specify the + loading and updat)HY(ing)YH( behav)HY(ior)YH( for an object section, respec)HY(tively)YH(. + Valid values for the )SM(load)ES( spec)HY(i)HY(fier)YH( are + )SM(eager)ES( \201default\202 and )SM(lazy)ES(. Valid values for + the )SM(update)ES( spec)HY(i)HY(fier)YH( are )SM(always)ES( \201default\202, + )SM(change)ES(, and )SM(manual)ES(. For more infor)HY(ma)HY(tion)YH( + on object sections, refer to )0 74 1 A(Chapter 9, "Sections")74 0 TN TL()Ec /AF f D(.)EP( + + )0 3 165 H(14.4.22)WB 490 Sn()WB 169 Sn( )SM(section)ES()EA()EH( + + )0 P(The )SM(section)ES( spec)HY(i)HY(fier)YH( indi)HY(cates)YH( that a data member + of a persis)HY(tent)YH( class belongs to an object section. The single + required argu)HY(ment)YH( to this spec)HY(i)HY(fier)YH( is the name of the section + data member. This spec)HY(i)HY(fier)YH( can only be used on direct data + members of a persis)HY(tent)YH( class. For more infor)HY(ma)HY(tion)YH( on object + sections, refer to )0 74 1 A(Chapter 9, "Sections")74 0 TN TL()Ec /AF f D(.)EP( + + )0 3 166 H(14.4.23)WB 491 Sn()WB 170 Sn( )SM(added)ES()EA()EH( + + )0 P(The )SM(added)ES( spec)HY(i)HY(fier)YH( marks the data member as + soft-added. The single required argu)HY(ment)YH( to this spec)HY(i)HY(fier)YH( is + the addi)HY(tion)YH( version. For more infor)HY(ma)HY(tion)YH( on this func)HY(tion)HY(al)HY(ity)YH(, + refer to )0 97 1 A(Section 13.4, "Soft Object Model + Changes")97 0 TN TL()Ec /AF f D(.)EP( + + )0 3 167 H(14.4.24)WB 492 Sn()WB 171 Sn( )SM(deleted)ES()EA()EH( + + )0 P(The )SM(deleted)ES( spec)HY(i)HY(fier)YH( marks the data member as + soft-deleted. The single required argu)HY(ment)YH( to this spec)HY(i)HY(fier)YH( is + the dele)HY(tion)YH( version. For more infor)HY(ma)HY(tion)YH( on this func)HY(tion)HY(al)HY(ity)YH(, + refer to )0 97 1 A(Section 13.4, "Soft Object Model + Changes")97 0 TN TL()Ec /AF f D(.)EP( + + )0 3 168 H(14.4.25)WB 493 Sn()WB 172 Sn( )SM(index_type)ES()EA()EH( + + )0 P(The )SM(index_type)ES( spec)HY(i)HY(fier)YH( spec)HY(i)HY(fies)YH( the native + database type that should be used for an ordered container's + index column of the data member. The seman)HY(tics)YH( of )SM(index_type)ES( + are similar to those of the )SM(type)ES( spec)HY(i)HY(fier)YH( + \201)0 150 1 A(Section 14.4.3, ")SM(type)ES(")150 0 TN TL()Ec /AF f D(\202. The native + database type is expected to be an integer type. For example:)EP( + + ) 8 44 PR(#pragma db object +class person +{ + ... + + #pragma db index_type\201"SMALLINT UNSIGNED"\202 + std::vector nicknames_; +};)RP( + + )0 3 169 H(14.4.26)WB 494 Sn()WB 173 Sn( )SM(key_type)ES()EA()EH( + + )0 P(The )SM(key_type)ES( spec)HY(i)HY(fier)YH( spec)HY(i)HY(fies)YH( the native + database type that should be used for a map container's + key column of the data member. The seman)HY(tics)YH( of )SM(key_type)ES( + are similar to those of the )SM(type)ES( spec)HY(i)HY(fier)YH( + \201)0 150 1 A(Section 14.4.3, ")SM(type)ES(")150 0 TN TL()Ec /AF f D(\202. For + example:)EP( + + ) 8 50 PR(#pragma db object +class person +{ + ... + + #pragma db key_type\201"INT UNSIGNED"\202 + std::map age_weight_map_; +};)RP( + + )0 3 170 H(14.4.27)WB 495 Sn()WB 174 Sn( )SM(value_type)ES()EA()EH( + + )0 P(The )SM(value_type)ES( spec)HY(i)HY(fier)YH( spec)HY(i)HY(fies)YH( the native + database type that should be used for a container's + value column of the data member. The seman)HY(tics)YH( of )SM(value_type)ES( + are similar to those of the )SM(type)ES( spec)HY(i)HY(fier)YH( + \201)0 150 1 A(Section 14.4.3, ")SM(type)ES(")150 0 TN TL()Ec /AF f D(\202. For + example:)EP( + + ) 8 39 PR(#pragma db object +class person +{ + ... + + #pragma db value_type\201"VARCHAR\201255\202"\202 + std::vector nicknames_; +};)RP( + + )0 P(The )SM(value_null)ES( and )SM(value_not_null)ES( + \201)0 175 1 A(Section 14.4.28, + ")SM(value_null)ES(/)SM(value_not_null)ES(")175 0 TN TL()Ec /AF f D(\202 spec)HY(i)HY(fiers)YH( + can be used to control the )SM(NULL)ES( seman)HY(tics)YH( of a value + column.)EP( + + )0 3 171 H(14.4.28)WB 496 Sn()WB 175 Sn( )SM(value_null)ES(/)SM(value_not_null)ES()EA()EH( + + )0 P(The )SM(value_null)ES( and )SM(value_not_null)ES( spec)HY(i)HY(fiers)YH( + specify that a container's element value for the data member can or + cannot be )SM(NULL)ES(, respec)HY(tively)YH(. The seman)HY(tics)YH( of + )SM(value_null)ES( and )SM(value_not_null)ES( are similar + to those of the )SM(null)ES( and )SM(not_null)ES( spec)HY(i)HY(fiers)YH( + \201)0 153 1 A(Section 14.4.6, ")SM(null)ES(/)SM(not_null)ES(")153 0 TN TL()Ec /AF f D(\202. + For example:)EP( + + ) 16 44 PR(using std::tr1::shared_ptr; + +#pragma db object +class person +{ + ... +}; + +#pragma db object +class account +{ + ... + + #pragma db value_not_null + std::vector > holders_; +};)RP( + + )0 P(For set and multi)HY(set)YH( contain)HY(ers)YH( \201)0 47 1 A(Section 5.2, "Set and + Multi)HY(set)YH( Contain)HY(ers)YH(")47 0 TN TL()Ec /AF f D(\202 the element value is auto)HY(mat)HY(i)HY(cally)YH( treated + as not allow)HY(ing)YH( a )SM(NULL)ES( value.)EP( + + )0 3 172 H(14.4.29)WB 497 Sn()WB 176 Sn( )SM(id_options)ES()EA()EH( + + )0 P(The )SM(id_options)ES( spec)HY(i)HY(fier)YH( spec)HY(i)HY(fies)YH( addi)HY(tional)YH( + column defi)HY(ni)HY(tion)YH( options that should be used for a container's + id column of the data member. For example:)EP( + + ) 11 41 PR(#pragma db object +class person +{ + ... + + #pragma db id options\201"COLLATE binary"\202 + std::string name_; + + #pragma db id_options\201"COLLATE binary"\202 + std::vector nicknames_; +};)RP( + + )0 P(The seman)HY(tics)YH( of )SM(id_options)ES( are similar to those + of the )SM(options)ES( spec)HY(i)HY(fier)YH( \201)0 155 1 A(Section + 14.4.8, ")SM(options)ES(")155 0 TN TL()Ec /AF f D(\202.)EP( + + )0 3 173 H(14.4.30)WB 498 Sn()WB 177 Sn( )SM(index_options)ES()EA()EH( + + )0 P(The )SM(index_options)ES( spec)HY(i)HY(fier)YH( spec)HY(i)HY(fies)YH( addi)HY(tional)YH( + column defi)HY(ni)HY(tion)YH( options that should be used for a container's + index column of the data member. For example:)EP( + + ) 8 38 PR(#pragma db object +class person +{ + ... + + #pragma db index_options\201"ZEROFILL"\202 + std::vector nicknames_; +};)RP( + + )0 P(The seman)HY(tics)YH( of )SM(index_options)ES( are similar to those + of the )SM(options)ES( spec)HY(i)HY(fier)YH( \201)0 155 1 A(Section + 14.4.8, ")SM(options)ES(")155 0 TN TL()Ec /AF f D(\202.)EP( + + )0 3 174 H(14.4.31)WB 499 Sn()WB 178 Sn( )SM(key_options)ES()EA()EH( + + )0 P(The )SM(key_options)ES( spec)HY(i)HY(fier)YH( spec)HY(i)HY(fies)YH( addi)HY(tional)YH( + column defi)HY(ni)HY(tion)YH( options that should be used for a container's + key column of the data member. For example:)EP( + + ) 8 49 PR(#pragma db object +class person +{ + ... + + #pragma db key_options\201"COLLATE binary"\202 + std::map properties_; +};)RP( + + )0 P(The seman)HY(tics)YH( of )SM(key_options)ES( are similar to those + of the )SM(options)ES( spec)HY(i)HY(fier)YH( \201)0 155 1 A(Section + 14.4.8, ")SM(options)ES(")155 0 TN TL()Ec /AF f D(\202.)EP( + + )0 3 175 H(14.4.32)WB 500 Sn()WB 179 Sn( )SM(value_options)ES()EA()EH( + + )0 P(The )SM(value_options)ES( spec)HY(i)HY(fier)YH( spec)HY(i)HY(fies)YH( addi)HY(tional)YH( + column defi)HY(ni)HY(tion)YH( options that should be used for a container's + value column of the data member. For example:)EP( + + ) 8 44 PR(#pragma db object +class person +{ + ... + + #pragma db value_options\201"COLLATE binary"\202 + std::set nicknames_; +};)RP( + + )0 P(The seman)HY(tics)YH( of )SM(value_options)ES( are similar to those + of the )SM(options)ES( spec)HY(i)HY(fier)YH( \201)0 155 1 A(Section + 14.4.8, ")SM(options)ES(")155 0 TN TL()Ec /AF f D(\202.)EP( + + )0 3 176 H(14.4.33)WB 501 Sn()WB 180 Sn( )SM(id_column)ES()EA()EH( + + )0 P(The )SM(id_column)ES( spec)HY(i)HY(fier)YH( spec)HY(i)HY(fies)YH( the column + name that should be used to store the object id in a + container's table for the data member. The seman)HY(tics)YH( of + )SM(id_column)ES( are similar to those of the + )SM(column)ES( spec)HY(i)HY(fier)YH( + \201)0 156 1 A(Section 14.4.9, ")SM(column)ES(")156 0 TN TL()Ec /AF f D(\202. + For example:)EP( + + ) 8 38 PR(#pragma db object +class person +{ + ... + + #pragma db id_column\201"person_id"\202 + std::vector nicknames_; +};)RP( + + )0 P(If the column name is not spec)HY(i)HY(fied)YH(, then )SM(object_id)ES( + is used by default.)EP( + + )0 3 177 H(14.4.34)WB 502 Sn()WB 181 Sn( )SM(index_column)ES()EA()EH( + + )0 P(The )SM(index_column)ES( spec)HY(i)HY(fier)YH( spec)HY(i)HY(fies)YH( the column + name that should be used to store the element index in an + ordered container's table for the data member. The seman)HY(tics)YH( of + )SM(index_column)ES( are similar to those of the + )SM(column)ES( spec)HY(i)HY(fier)YH( + \201)0 156 1 A(Section 14.4.9, ")SM(column)ES(")156 0 TN TL()Ec /AF f D(\202. + For example:)EP( + + ) 8 44 PR(#pragma db object +class person +{ + ... + + #pragma db index_column\201"nickname_number"\202 + std::vector nicknames_; +};)RP( + + )0 P(If the column name is not spec)HY(i)HY(fied)YH(, then )SM(index)ES( + is used by default.)EP( + + )0 3 178 H(14.4.35)WB 503 Sn()WB 182 Sn( )SM(key_column)ES()EA()EH( + + )0 P(The )SM(key_column)ES( spec)HY(i)HY(fier)YH( spec)HY(i)HY(fies)YH( the column + name that should be used to store the key in a map + container's table for the data member. The seman)HY(tics)YH( of + )SM(key_column)ES( are similar to those of the + )SM(column)ES( spec)HY(i)HY(fier)YH( + \201)0 156 1 A(Section 14.4.9, ")SM(column)ES(")156 0 TN TL()Ec /AF f D(\202. + For example:)EP( + + ) 8 50 PR(#pragma db object +class person +{ + ... + + #pragma db key_column\201"age"\202 + std::map age_weight_map_; +};)RP( + + )0 P(If the column name is not spec)HY(i)HY(fied)YH(, then )SM(key)ES( + is used by default.)EP( + + )0 3 179 H(14.4.36)WB 504 Sn()WB 183 Sn( )SM(value_column)ES()EA()EH( + + )0 P(The )SM(value_column)ES( spec)HY(i)HY(fier)YH( spec)HY(i)HY(fies)YH( the column + name that should be used to store the element value in a + container's table for the data member. The seman)HY(tics)YH( of + )SM(value_column)ES( are similar to those of the + )SM(column)ES( spec)HY(i)HY(fier)YH( + \201)0 156 1 A(Section 14.4.9, ")SM(column)ES(")156 0 TN TL()Ec /AF f D(\202. + For example:)EP( + + ) 8 50 PR(#pragma db object +class person +{ + ... + + #pragma db value_column\201"weight"\202 + std::map age_weight_map_; +};)RP( + + )0 P(If the column name is not spec)HY(i)HY(fied)YH(, then )SM(value)ES( + is used by default.)EP( + + )0 2 180 H(14.5)WB 505 Sn()WB 184 Sn( Names)HY(pace)YH( Pragmas)EA()EH( + + )0 P(A pragma with the )SM(names)HY(pace)YH()ES( qual)HY(i)HY(fier)YH( describes a + C++ names)HY(pace)YH(. Similar to other qual)HY(i)HY(fiers)YH(, )SM(names)HY(pace)YH()ES( + can also refer to a named C++ names)HY(pace)YH(, for example:)EP( + + ) 6 30 PR(namespace test +{ + ... +} + +#pragma db namespace\201test\202 ...)RP( + + )0 P(To refer to the global names)HY(pace)YH( in the )SM(names)HY(pace)YH()ES( + qual)HY(i)HY(fier)YH( the follow)HY(ing)YH( special syntax is used:)EP( + + ) 1 27 PR(#pragma db namespace\201\202 ....)RP( + + )0 P(The )SM(names)HY(pace)YH()ES( qual)HY(i)HY(fier)YH( can be option)HY(ally)YH( followed, + in any order, by one or more spec)HY(i)HY(fiers)YH( summa)HY(rized)YH( in the + table below:)EP( + + + )8 PT( + + )0 3 181 H(14.5.1)WB 506 Sn()WB 185 Sn( )SM(pointer)ES()EA()EH( + + )0 P(The )SM(pointer)ES( spec)HY(i)HY(fier)YH( spec)HY(i)HY(fies)YH( the default pointer + type for persis)HY(tent)YH( classes and views inside the names)HY(pace)YH(. For + example:)EP( + + ) 15 50 PR(#pragma db namespace pointer\201std::tr1::shared_ptr\202 +namespace accounting +{ + #pragma db object + class employee + { + ... + }; + + #pragma db object + class employer + { + ... + }; +})RP( + + )0 P(There are only two valid ways to specify a pointer with the + )SM(pointer)ES( spec)HY(i)HY(fier)YH( at the names)HY(pace)YH( level. We can + specify the template name of a smart pointer in which + case the ODB compiler will auto)HY(mat)HY(i)HY(cally)YH( append the class + name as a template argu)HY(ment)YH(. Or we can use )SM(*)ES( + to denote a raw pointer.)EP( + + )0 P(Note also that we can always over)HY(ride)YH( the default pointer + spec)HY(i)HY(fied)YH( at the names)HY(pace)YH( level for any persis)HY(tent)YH( class + or view inside this names)HY(pace)YH(. For example:)EP( + + ) 15 45 PR(#pragma db namespace pointer\201std::unique_ptr\202 +namespace accounting +{ + #pragma db object pointer\201std::shared_ptr\202 + class employee + { + ... + }; + + #pragma db object + class employer + { + ... + }; +})RP( + + )0 P(For a more detailed discus)HY(sion)YH( of object and view point)HY(ers)YH(, refer + to )0 26 1 A(Section 3.3, "Object and View Point)HY(ers)YH(")26 0 TN TL()Ec /AF f D(.)EP( + + )0 3 182 H(14.5.2)WB 507 Sn()WB 186 Sn( )SM(table)ES()EA()EH( + + )0 P(The )SM(table)ES( spec)HY(i)HY(fier)YH( spec)HY(i)HY(fies)YH( a table prefix + that should be added to table names of persis)HY(tent)YH( classes inside + the names)HY(pace)YH(. For example:)EP( + + ) 15 38 PR(#pragma db namespace table\201"acc_"\202 +namespace accounting +{ + #pragma db object table\201"employees"\202 + class employee + { + ... + }; + + #pragma db object table\201"employers"\202 + class employer + { + ... + }; +})RP( + + )0 P(In the above example the result)HY(ing)YH( table names will be + )SM(acc_employ)HY(ees)YH()ES( and )SM(acc_employ)HY(ers)YH()ES(.)EP( + + )0 P(The table name prefix can also be spec)HY(i)HY(fied)YH( with the + )SM(--table-prefix)ES( ODB compiler option. Note + that table prefixes spec)HY(i)HY(fied)YH( at the names)HY(pace)YH( level as well + as with the command line option are accu)HY(mu)HY(lated)YH(. For example:)EP( + + ) 17 38 PR(#pragma db namespace\201\202 table\201"audit_"\202 + +#pragma db namespace table\201"hr_"\202 +namespace hr +{ + #pragma db object table\201"employees"\202 + class employee + { + ... + }; +} + +#pragma db object table\201"employers"\202 +class employer +{ + ... +};)RP( + + )0 P(If we compile the above example with the + )SM(--table-prefix\240test_)ES( option, then the + )SM(employee)ES( class table will be called + )SM(test_audit_hr_employ)HY(ees)YH()ES( and )SM(employer)ES( \236 + )SM(test_audit_employ)HY(ers)YH()ES(.)EP( + + )0 P(Table prefixes can be used as an alter)HY(na)HY(tive)YH( to database schemas + \201)0 109 1 A(Section 14.1.8, ")SM(schema)ES(")109 0 TN TL()Ec /AF f D(\202 if + the target database system does not support schemas.)EP( + + )0 3 183 H(14.5.3)WB 508 Sn()WB 187 Sn( )SM(schema)ES()EA()EH( + + )0 P(The )SM(schema)ES( spec)HY(i)HY(fier)YH( spec)HY(i)HY(fies)YH( a database schema + that should be used for persis)HY(tent)YH( classes inside the names)HY(pace)YH(. + For more infor)HY(ma)HY(tion)YH( on spec)HY(i)HY(fy)HY(ing)YH( a database schema refer to + )0 109 1 A(Section 14.1.8, ")SM(schema)ES(")109 0 TN TL()Ec /AF f D(.)EP( + + )0 3 184 H(14.5.4)WB 509 Sn()WB 188 Sn( )SM(session)ES()EA()EH( + + )0 P(The )SM(session)ES( spec)HY(i)HY(fier)YH( spec)HY(i)HY(fies)YH( whether to enable + session support for persis)HY(tent)YH( classes inside the names)HY(pace)YH(. For + example:)EP( + + ) 15 47 PR(#pragma db namespace session +namespace hr +{ + #pragma db object // Enabled. + class employee + { + ... + }; + + #pragma db object session\201false\202 // Disabled. + class employer + { + ... + }; +})RP( + + )0 P(Session support is disabled by default unless the + )SM(--gener)HY(ate)YH(-session)ES( ODB compiler option is spec)HY(i)HY(fied)YH(. + Session support spec)HY(i)HY(fied)YH( at the names)HY(pace)YH( level can be over)HY(rid)HY(den)YH( + on the per object basis \201)0 111 1 A(Section 14.1.10, + ")SM(session)ES(")111 0 TN TL()Ec /AF f D(\202. For more infor)HY(ma)HY(tion)YH( on sessions, + refer to )0 87 1 A(Chapter 11, "Session")87 0 TN TL()Ec /AF f D(.)EP( + +)0 2 185 H(14.6)WB 510 Sn()WB 189 Sn( Object Model Pragmas)EA()EH( + + )0 P(A pragma with the )SM(model)ES( qual)HY(i)HY(fier)YH( describes the + whole C++ object model. For example:)EP( + + ) 1 20 PR(#pragma db model ...)RP( + + )0 P(The )SM(model)ES( qual)HY(i)HY(fier)YH( can be followed, in any order, + by one or more spec)HY(i)HY(fiers)YH( summa)HY(rized)YH( in the table below:)EP( + + + )9 PT( + + )0 3 186 H(14.6.1)WB 511 Sn()WB 190 Sn( )SM(version)ES()EA()EH( + + )0 P(The )SM(version)ES( spec)HY(i)HY(fier)YH( spec)HY(i)HY(fies)YH( the object model + version when schema evolu)HY(tion)YH( support is used. The first two + required argu)HY(ments)YH( to this spec)HY(i)HY(fier)YH( are the base and current + model versions, respec)HY(tively)YH(. The third optional argu)HY(ment)YH( + spec)HY(i)HY(fies)YH( whether the current version is open for changes. + Valid values for this argu)HY(ment)YH( are )SM(open)ES( \201the + default\202 and )SM(closed)ES(. For more infor)HY(ma)HY(tion)YH( on + this func)HY(tion)HY(al)HY(ity)YH(, refer to )0 91 1 A(Chapter 13, + "Database Schema Evolu)HY(tion)YH(")91 0 TN TL()Ec /AF f D(.)EP( + + + )0 2 187 H(14.7)WB 512 Sn()WB 191 Sn( Index Defi)HY(ni)HY(tion)YH( Pragmas)EA()EH( + + )0 P(While it is possi)HY(ble)YH( to manu)HY(ally)YH( add indexes to the gener)HY(ated)YH( + database schema, it is more conve)HY(nient)YH( to do this as part of + the persis)HY(tent)YH( class defi)HY(ni)HY(tions)YH(. A pragma with the )SM(index)ES( + qual)HY(i)HY(fier)YH( describes a database index. It has the follow)HY(ing)YH( + general format:)EP( + +) 6 52 PR(#pragma db index[\201""\202] \200 + [unique|type\201""\202] \200 + [method\201""\202] \200 + [options\201""\202] \200 + member\201[, ""]\202... \200 + members\201[,...]\202...)RP( + + )0 P(The )SM(index)ES( qual)HY(i)HY(fier)YH( can option)HY(ally)YH( specify the + index name. If the index name is not spec)HY(i)HY(fied)YH(, then one is + auto)HY(mat)HY(i)HY(cally)YH( derived by append)HY(ing)YH( the )SM(_i)ES( suffix + to the column name of the index member. If the name is not + spec)HY(i)HY(fied)YH( and the index contains multi)HY(ple)YH( members, then the + index defi)HY(ni)HY(tion)YH( is invalid.)EP( + + )0 P(The optional )SM(type)ES(, )SM(method)ES(, and + )SM(options)ES( clauses specify the index type, for + example )SM(UNIQUE)ES(, index method, for example + )SM(BTREE)ES(, and index options, respec)HY(tively)YH(. The + )SM(unique)ES( clause is a short)HY(cut)YH( for + )SM(type\201"UNIQUE"\202)ES(. Note that not all database + systems support spec)HY(i)HY(fy)HY(ing)YH( an index method or options. + For more infor)HY(ma)HY(tion)YH( on the database system-specific index + types, methods, and options, refer to )0 204 1 A(Part II, + "Database Systems")204 0 TN TL()Ec /AF f D(.)EP( + + )0 P(To specify index members we can use the )SM(member)ES( + or )SM(members)ES( clauses, or a mix of the two. The + )SM(member)ES( clause allows us to specify a single + index member with optional column options, for example, + )SM("ASC")ES(. If we need to create a compos)HY(ite)YH( + index that contains multi)HY(ple)YH( members, then we can repeat + the )SM(member)ES( clause several times or, if the + members don't have any column options, we can use a single + )SM(members)ES( clause instead. Similar to the index + type, method, and options, the format of column options is + database system-specific. For more details, refer to + )0 204 1 A(Part II, "Database Systems")204 0 TN TL()Ec /AF f D(.)EP( + + )0 P(The follow)HY(ing)YH( code frag)HY(ment)YH( shows some typical exam)HY(ples)YH( + of index defi)HY(ni)HY(tions)YH(:)EP( + +) 23 70 PR(#pragma db object +class object +{ + ... + + int x; + int y; + int z1; + int z2; + + // An index for member x with automatically-assigned name x_i. + // + #pragma db index member\201x\202 + + // A unique index named y_index for member y which is sorted in + // the descending order. The index is using the BTREE method. + // + #pragma db index\201"y_index"\202 unique method\201"BTREE"\202 member\201y, "DESC"\202 + + // A composite BITMAP index named z_i for members z1 and z2. + // + #pragma db index\201"z_i"\202 type\201"BITMAP"\202 members\201z1, z2\202 +};)RP( + + )0 P(ODB also offers a short)HY(cut)YH( for defin)HY(ing)YH( an index with the default + method and options for a single data member. Such an index can + be defined using the )SM(index)ES( \201)0 164 1 A(Section + 14.4.17, ")SM(index)ES(")164 0 TN TL()Ec /AF f D(\202 or )SM(unique)ES( + \201)0 165 1 A(Section 14.4.18, ")SM(unique)ES(")165 0 TN TL()Ec /AF f D(\202 + member spec)HY(i)HY(fier)YH(. For example:)EP( + +) 11 31 PR(#pragma db object +class object +{ + ... + + #pragma db index + int x; + + #pragma db type\201"INT"\202 unique + int y; +};)RP( + + )0 P(The above example is seman)HY(ti)HY(cally)YH( equiv)HY(a)HY(lent)YH( to the follow)HY(ing)YH( + more verbose version:)EP( + +) 13 35 PR(#pragma db object +class object +{ + ... + + int x; + + #pragma db type\201"INT"\202 + int y; + + #pragma db index member\201x\202 + #pragma db index unique member\201y\202 +};)RP( + + )0 P(While it is conve)HY(nient)YH( to define an index inside a persis)HY(tent)YH( + class, it is also possi)HY(ble)YH( to do that out of the class body. In this + case, the index name, if spec)HY(i)HY(fied)YH(, must be prefixed with the + poten)HY(tially)YH(-qual)HY(i)HY(fied)YH( class name. For example:)EP( + +) 20 73 PR(namespace n +{ + #pragma db object + class object + { + ... + + int x; + int y; + }; + + // An index for member x in persistent class object with automatically- + // assigned name x_i. + // + #pragma db index\201object\202 member\201x\202 +} + +// An index named y_index for member y in persistent class n::object. +// +#pragma db index\201n::object::"y_index"\202 member\201y\202)RP( + + )0 P(It is possi)HY(ble)YH( to define an index on a member that is of a + compos)HY(ite)YH( value type or on some of its nested members. For + example:)EP( + +) 22 59 PR(#pragma db value +struct point +{ + int x; + int y; + int z; +}; + +#pragma db object +class object +{ + // An index that includes all of the p1's nested members. + // + #pragma db index + point p1; + + point p2; + + // An index that includes only p2.x and p2.y. + // + #pragma db index\201"p2_xy_i"\202 members\201p2.x, p2.y\202 +};)RP( + + )0 P(When gener)HY(at)HY(ing)YH( a schema for a container member \201)0 45 1 A(Chapter 5, + "Contain)HY(ers)YH(")45 0 TN TL()Ec /AF f D(\202, ODB auto)HY(mat)HY(i)HY(cally)YH( defines two indexes on the container + table. One is for the object id that refer)HY(ences)YH( the object table and the + other is for the index column in case the container is ordered + \201)0 46 1 A(Section 5.1, "Ordered Contain)HY(ers)YH(")46 0 TN TL()Ec /AF f D(\202. By default these + indexes use the default index name, type, method, and options. The + )SM(index)ES( pragma allows us to customize these two indexes by + recog)HY(niz)HY(ing)YH( the special )SM(id)ES( and )SM(index)ES( nested + member names when spec)HY(i)HY(fied)YH( after a container member. For example:)EP( + +) 13 50 PR(#pragma db object +class object +{ + std::vector v; + + // Change the container id index name. + // + #pragma db index\201"id_index"\202 member\201v.id\202 + + // Change the container index index method. + // + #pragma db index method\201"BTREE"\202 member\201v.index\202 +};)RP( + + )0 2 188 H(14.8)WB 513 Sn()WB 192 Sn( Database Type Mapping Pragmas)EA()EH( + + )0 P(A pragma with the )SM(map)ES( qual)HY(i)HY(fier)YH( describes a + mapping between two database types. For each database system + ODB provides built-in support for a core set of database types, + such as inte)HY(gers)YH(, strings, binary, etc. However, many database + systems provide extended types such as geospa)HY(tial)YH( types, + user-defined types, and collec)HY(tions)YH( \201arrays, table types, + key-value stores, etc\202. In order to support such extended types, + ODB allows us to map them to one of the built-in types, normally + a string or a binary. Given the text or binary repre)HY(sen)HY(ta)HY(tion)YH( + of the data we can then extract it into our chosen C++ data type + and thus estab)HY(lish)YH( a mapping between an extended database type and + its C++ equiv)HY(a)HY(lent)YH(.)EP( + + )0 P(The )SM(map)ES( pragma has the follow)HY(ing)YH( format:)EP( + +) 1 70 PR(#pragma db map type\201"regex"\202 as\201"subst"\202 [to\201"subst"\202] [from\201"subst"\202])RP( + + )0 P(The )SM(type)ES( clause spec)HY(i)HY(fies)YH( the name of the database type + that we are mapping. We will refer to it as the )EM(mapped type)ES( + from now on. The name of the mapped type is a Perl-like regular + expres)HY(sion)YH( pattern that is matched in the case-insen)HY(si)HY(tive)YH( mode.)EP( + + )0 P(The )SM(as)ES( clause spec)HY(i)HY(fies)YH( the name of the database type + that we are mapping the mapped type to. We will refer to it as + the )EM(inter)HY(face)YH( type)ES( from now on. The name of the inter)HY(face)YH( + type is a regular expres)HY(sion)YH( substi)HY(tu)HY(tion)YH( and should expand to a + name of a database type for which ODB provides built-in support.)EP( + + )0 P(The optional )SM(to)ES( and )SM(from)ES( clauses specify the + database conver)HY(sion)YH( expres)HY(sions)YH( between the mapped type and the + inter)HY(face)YH( type. The )SM(to)ES( expres)HY(sion)YH( converts from the + inter)HY(face)YH( type to the mapped type and )SM(from)ES( converts + in the other direc)HY(tion)YH(. If no explicit conver)HY(sion)YH( is required for + either direc)HY(tion)YH(, then the corre)HY(spond)HY(ing)YH( clause can be omitted. + The conver)HY(sion)YH( expres)HY(sions)YH( are regular expres)HY(sion)YH( substi)HY(tu)HY(tions)YH(. + They must contain the special )SM(\201?\202)ES( place)HY(holder)YH( which will + be replaced with the actual value to be converted. Turning on SQL + state)HY(ment)YH( tracing \201)0 36 1 A(Section 3.13, "Tracing SQL + State)HY(ment)YH( Execu)HY(tion)YH(")36 0 TN TL()Ec /AF f D(\202 can be useful for debug)HY(ging)YH( conver)HY(sion)YH( + expres)HY(sions)YH(. This allows you to see the substi)HY(tuted)YH( expres)HY(sions)YH( + as used in the actual state)HY(ments)YH(.)EP( + + )0 P(As an example, the follow)HY(ing)YH( )SM(map)ES( pragma maps the + Post)HY(greSQL)YH( array of )SM(INTEGER)ES('s to )SM(TEXT)ES(:)EP( + +) 4 46 PR(#pragma db map type\201"INTEGER *\200\200[\201\200\200d*\202\200\200]"\202 \200 + as\201"TEXT"\202 \200 + to\201"\201?\202::INTEGER[$1]"\202 \200 + from\201"\201?\202::TEXT"\202)RP( + + )0 P(With the above mapping we can now have a persis)HY(tent)YH( class that + has a member of the Post)HY(greSQL)YH( array type:)EP( + +) 8 30 PR(#pragma db object +class object +{ + ... + + #pragma db type\201"INTEGER[]"\202 + std::string array_; +};)RP( + + )0 P(In Post)HY(greSQL)YH( the array literal has the )SM({n1,n2,...})ES( form. + As a result, we need to make sure that we pass the correct text + repre)HY(sen)HY(ta)HY(tion)YH( in the )SM(array_)ES( member, for example:)EP( + +) 3 21 PR(object o; +o.array_ = "{1,2,3}"; +db.persist \201o\202;)RP( + + )0 P(Of course, )SM(std::string)ES( is not the most natural + repre)HY(sen)HY(ta)HY(tion)YH( of an array of inte)HY(gers)YH( in C++. Instead, + )SM(std::vector)ES( would have been much more + appro)HY(pri)HY(ate)YH(. To add support for mapping + )SM(std::vector)ES( to Post)HY(greSQL)YH( )SM(INTEGER[])ES( + we need to provide a )SM(value_traits)ES( special)HY(iza)HY(tion)YH( + that imple)HY(ments)YH( conver)HY(sion)YH( between the Post)HY(greSQL)YH( text repre)HY(sen)HY(ta)HY(tion)YH( + of an array and )SM(std::vector)ES(. Below is a sample + imple)HY(men)HY(ta)HY(tion)YH(:)EP( + +) 68 69 PR(namespace odb +{ + namespace pgsql + { + template <> + class value_traits, id_string> + { + public: + typedef std::vector value_type; + typedef value_type query_type; + typedef details::buffer image_type; + + static void + set_value \201value_type& v, + const details::buffer& b, + std::size_t n, + bool is_null\202 + { + v.clear \201\202; + + if \201!is_null\202 + { + char c; + std::istringstream is \201std::string \201b.data \201\202, n\202\202; + + is >> c; // '{' + + for \201c = static_cast \201is.peek \201\202\202; c != '}'; is >> c\202 + { + v.push_back \201int \201\202\202; + is >> v.back \201\202;)WR( + } + } + } + + static void + set_image \201details::buffer& b, + std::size_t& n, + bool& is_null, + const value_type& v\202 + { + is_null = false; + std::ostringstream os; + + os << '{'; + + for \201value_type::const_iterator i \201v.begin \201\202\202, e \201v.end \201\202\202; + i != e;\202 + { + os << *i; + + if \201++i != e\202 + os << ','; + } + + os << '}'; + + const std::string& s \201os.str \201\202\202; + n = s.size \201\202; + + if \201n > b.capacity \201\202\202)WR( + b.capacity \201n\202; + + std::memcpy \201b.data \201\202, s.c_str \201\202, n\202; + } + }; + } +})RP( + + )0 P(Once this special)HY(iza)HY(tion)YH( is included in the gener)HY(ated)YH( code \201see + the )SM(mapping)ES( example in the )SM(odb-exam)HY(ples)YH()ES( + package for details\202, we can use )SM(std::vector)ES( + instead of )SM(std::string)ES( in our persis)HY(tent)YH( class:)EP( + +) 8 30 PR(#pragma db object +class object +{ + ... + + #pragma db type\201"INTEGER[]"\202 + std::vector array_; +};)RP( + + )0 P(If we wanted to always map )SM(std::vector)ES( + to Post)HY(greSQL)YH( )SM(INTEGER[])ES(, then we could instead + write:)EP( + +) 10 50 PR(typedef std::vector int_vector; +#pragma db value\201int_vector\202 type\201"INTEGER[]"\202 + +#pragma db object +class object +{ + ... + + std::vector array_; // Mapped to INTEGER[]. +};)RP( + + )0 P(While the above example only shows how to handle Post)HY(greSQL)YH( arrays, + other types in Post)HY(greSQL)YH( and in other databases can be supported + in a similar way. The )SM(odb-tests)ES( package contains a + set of tests in the )SM(/custom)ES( direc)HY(to)HY(ries)YH( that, + for each database, shows how to provide custom mapping for some of + the extended types.)EP( + + )0 2 189 H(14.9)WB 514 Sn()WB 193 Sn( C++ Compiler Warn)HY(ings)YH()EA()EH( + + )0 P(When a C++ header file defin)HY(ing)YH( persis)HY(tent)YH( classes and contain)HY(ing)YH( + ODB pragmas is used to build the appli)HY(ca)HY(tion)YH(, the C++ compiler may + issue warn)HY(ings)YH( about pragmas that it doesn't recog)HY(nize)YH(. There + are several ways to deal with this problem. The easiest is to + disable such warn)HY(ings)YH( using one of the compiler-specific command + line options or warning control pragmas. This method is described + in the follow)HY(ing)YH( sub-section for popular C++ compil)HY(ers)YH(.)EP( + + )0 P(There are also several C++ compiler-inde)HY(pen)HY(dent)YH( methods that we + can employ. The first is to use the )SM(PRAGMA_DB)ES( macro, + defined in )SM()ES(, instead of using + )SM(#pragma\240db)ES( directly. This macro expands to the + ODB pragma when compiled with the ODB compiler and to an empty + decla)HY(ra)HY(tion)YH( when compiled with other compil)HY(ers)YH(. The follow)HY(ing)YH( example + shows how we can use this macro:)EP( + + ) 10 23 PR(#include + +PRAGMA_DB\201object\202 +class person +{ + ... + + PRAGMA_DB\201id\202 + unsigned long id_; +};)RP( + + )0 P(An alter)HY(na)HY(tive)YH( to using the )SM(PRAGMA_DB)ES( macro is to + group the )SM(#pragma\240db)ES( direc)HY(tives)YH( in blocks that are + condi)HY(tion)HY(ally)YH( included into compi)HY(la)HY(tion)YH( only when compiled with the + ODB compiler. For example:)EP( + + ) 11 35 PR(class person +{ + ... + + unsigned long id_; +}; + +#ifdef ODB_COMPILER +# pragma db object\201person\202 +# pragma db member\201person::id_\202 id +#endif)RP( + + )0 P(The disad)HY(van)HY(tage)YH( of this approach is that it can quickly become + overly verbose when posi)HY(tioned)YH( pragmas are used.)EP( + + )0 3 190 H(14.9.1)WB 515 Sn()WB 194 Sn( GNU C++)EA()EH( + + )0 P(GNU g++ does not issue warn)HY(ings)YH( about unknown pragmas + unless requested with the )SM(-Wall)ES( command line option. + To disable only the unknown pragma warning, we can add the + )SM(-Wno-unknown-pragmas)ES( option after )SM(-Wall)ES(, + for example:)EP( + + ) 1 34 PR(g++ -Wall -Wno-unknown-pragmas ...)RP( + + )0 3 191 H(14.9.2)WB 516 Sn()WB 195 Sn( Visual C++)EA()EH( + + )0 P(Microsoft Visual C++ issues an unknown pragma warning \201C4068\202 at + warning level 1 or higher. This means that unless we have disabled + the warn)HY(ings)YH( alto)HY(gether)YH( \201level 0\202, we will see this warning.)EP( + + )0 P(To disable this warning via the compiler command line, we can add + the )SM(/wd4068)ES( C++ compiler option in Visual Studio 2008 + and earlier. In Visual Studio 2010 and later there is now a special + GUI field where we can enter warning numbers that should be disabled. + Simply enter 4068 into this field.)EP( + + )0 P(We can also disable this warning for only a specific header or + a frag)HY(ment)YH( of a header using the warning control pragma. For + example:)EP( + + ) 15 30 PR(#include + +#pragma warning \201push\202 +#pragma warning \201disable:4068\202 + +#pragma db object +class person +{ + ... + + #pragma db id + unsigned long id_; +}; + +#pragma warning \201pop\202)RP( + + )0 3 192 H(14.9.3)WB 517 Sn()WB 196 Sn( Sun C++)EA()EH( + + )0 P(The Sun C++ compiler does not issue warn)HY(ings)YH( about unknown pragmas + unless the )SM(+w)ES( or )SM(+w2)ES( option is spec)HY(i)HY(fied)YH(. + To disable only the unknown pragma warning we can add the + )SM(-erroff=unknown)HY(pragma)YH()ES( option anywhere on the + command line, for example:)EP( + + ) 1 31 PR(CC +w -erroff=unknownpragma ...)RP( + + )0 3 193 H(14.9.4)WB 518 Sn()WB 197 Sn( IBM XL C++)EA()EH( + + )0 P(IBM XL C++ issues an unknown pragma warning \2011540-1401\202 by default. + To disable this warning we can add the )SM(-qsup)HY(press)YH(=1540-1401)ES( + command line option, for example:)EP( + + ) 1 28 PR(xlC -qsuppress=1540-1401 ...)RP( + + )0 3 194 H(14.9.5)WB 519 Sn()WB 198 Sn( HP aC++)EA()EH( + + )0 P(HP aC++ \201aCC\202 issues an unknown pragma warning \2012161\202 by default. + To disable this warning we can add the )SM(+W2161)ES( + command line option, for example:)EP( + + ) 1 14 PR(aCC +W2161 ...)RP( + + )0 3 195 H(14.9.6)WB 520 Sn()WB 199 Sn( Clang)EA()EH( + + )0 P(Clang does not issue warn)HY(ings)YH( about unknown pragmas + unless requested with the )SM(-Wall)ES( command line option. + To disable only the unknown pragma warning, we can add the + )SM(-Wno-unknown-pragmas)ES( option after )SM(-Wall)ES(, + for example:)EP( + + ) 1 38 PR(clang++ -Wall -Wno-unknown-pragmas ...)RP( + + )0 P(We can also disable this warning for only a specific header or + a frag)HY(ment)YH( of a header using the warning control pragma. For + example:)EP( + + ) 15 52 PR(#include + +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wunknown-pragmas" + +#pragma db object +class person +{ + ... + + #pragma db id + unsigned long id_; +}; + +#pragma clang diagnostic pop)RP( + + + + + + )WB NL NP( + )0 1 196 H(15)WB 521 Sn()WB 200 Sn( Advanced Tech)HY(niques)YH( and Mech)HY(a)HY(nisms)YH()EA()EH( + + )0 P(This chapter covers more advanced tech)HY(niques)YH( and mech)HY(a)HY(nisms)YH( + provided by ODB that may be useful in certain situ)HY(a)HY(tions)YH(.)EP( + + )0 2 197 H(15.1)WB 522 Sn()WB 201 Sn( Trans)HY(ac)HY(tion)YH( Call)HY(backs)YH()EA()EH( + + )0 P(The ODB trans)HY(ac)HY(tion)YH( class \201)SM(odb::trans)HY(ac)HY(tion)YH()ES(\202 allows + an appli)HY(ca)HY(tion)YH( to regis)HY(ter)YH( a call)HY(back)YH( that will be called after + the trans)HY(ac)HY(tion)YH( is final)HY(ized)YH(, that is, commit)HY(ted)YH( or rolled back. + This mech)HY(a)HY(nism)YH( can be used, for example, to restore values that + were updated during the trans)HY(ac)HY(tion)YH( execu)HY(tion)YH( to their orig)HY(i)HY(nal)YH( + states if the trans)HY(ac)HY(tion)YH( is rolled back.)EP( + + )0 P(The call)HY(back)YH( manage)HY(ment)YH( inter)HY(face)YH( of the )SM(trans)HY(ac)HY(tion)YH()ES( + class is shown below.)EP( + + ) 32 74 PR(namespace odb +{ + class transaction + { + ... + + public: + static const unsigned short event_commit = 0x01; + static const unsigned short event_rollback = 0x02; + static const unsigned short event_all = event_commit | event_rollback; + + typedef void \201*callback_type\202 \201 + unsigned short event, void* key, unsigned long long data\202; + + void + callback_register \201callback_type callback, + void* key, + unsigned short event = event_all, + unsigned long long data = 0, + transaction** state = 0\202; + + + void + callback_unregister \201void* key\202; + + void + callback_update \201void* key, + unsigned short event, + unsigned long long data = 0, + transaction** state = 0\202; + })WR( +})RP( + + )0 P(The )SM(call)HY(back)YH(_regis)HY(ter)YH(\201\202)ES( func)HY(tion)YH( regis)HY(ters)YH( a + post-commit/roll)HY(back)YH( call)HY(back)YH(. The )SM(call)HY(back)YH()ES( + argu)HY(ment)YH( is the func)HY(tion)YH( that should be called. The + )SM(key)ES( argu)HY(ment)YH( is used by the trans)HY(ac)HY(tion)YH( + to iden)HY(tify)YH( this call)HY(back)YH(. It is also normally used + to pass an address of the data object on which the + call)HY(back)YH( func)HY(tion)YH( will work. The )SM(event)ES( + argu)HY(ment)YH( is the bitwise-or of the events that should + trigger the call)HY(back)YH(.)EP( + + )0 P(The optional data argu)HY(ment)YH( can be used to store any POD + user data that doesn't exceed 8 bytes in size and doesn't require + align)HY(ment)YH( greater than )SM(unsigned long long)ES(. For + example, we could store an old value of a flag or a counter + that needs to be restored in case of a roll back.)EP( + + )0 P(The optional )SM(state)ES( argu)HY(ment)YH( can be used to + indi)HY(cate)YH( that the call)HY(back)YH( has been unreg)HY(is)HY(tered)YH( because + the trans)HY(ac)HY(tion)YH( was final)HY(ized)YH(. In this case the trans)HY(ac)HY(tion)YH( + auto)HY(mat)HY(i)HY(cally)YH( resets the passed pointer to 0. This is + primar)HY(ily)YH( useful if we are inter)HY(ested)YH( in only one of + the events \201commit or roll)HY(back)YH(\202.)EP( + + )0 P(The )SM(call)HY(back)YH(_unreg)HY(is)HY(ter)YH(\201\202)ES( func)HY(tion)YH( unreg)HY(is)HY(ters)YH( a previ)HY(ously)YH( + regis)HY(tered)YH( call)HY(back)YH(. If the number of regis)HY(tered)YH( call)HY(backs)YH( is + large, then this can be a slow oper)HY(a)HY(tion)YH(. Gener)HY(ally)YH(, the call)HY(back)YH( + mech)HY(a)HY(nism)YH( is opti)HY(mized)YH( for cases where the call)HY(backs)YH( stay + regis)HY(tered)YH( until the trans)HY(ac)HY(tion)YH( is final)HY(ized)YH(.)EP( + + )0 P(Note also that you don't need to unreg)HY(is)HY(ter)YH( a call)HY(back)YH( that has + been called or auto-reset using the )SM(state)ES( argu)HY(ment)YH( + passed to )SM(call)HY(back)YH(_regis)HY(ter)YH(\201\202)ES(. This func)HY(tion)YH( does nothing + if the key is not found.)EP( + + )0 P(The )SM(call)HY(back)YH(_update\201\202)ES( func)HY(tion)YH( can be used to update + the )SM(event)ES(, )SM(data)ES(, and )SM(state)ES( + values of a previ)HY(ously)YH( regis)HY(tered)YH( call)HY(back)YH(. Similar to + )SM(call)HY(back)YH(_unreg)HY(is)HY(ter)YH(\201\202)ES(, this is a poten)HY(tially)YH( slow + oper)HY(a)HY(tion)YH(.)EP( + + )0 P(When the call)HY(back)YH( is called, it is passed the event that + trig)HY(gered)YH( it, as well as the )SM(key)ES( and + )SM(data)ES( values that were passed to the + )SM(call)HY(back)YH(_regis)HY(ter)YH(\201\202)ES( func)HY(tion)YH(. Note also that the order + in which the call)HY(backs)YH( are called is unspec)HY(i)HY(fied)YH(. The roll)HY(back)YH( + event can be trig)HY(gered)YH( by an excep)HY(tion)YH(. In this case, if the + call)HY(back)YH( throws, the program will be termi)HY(nated)YH(.)EP( + + )0 P(The follow)HY(ing)YH( example shows how we can use trans)HY(ac)HY(tion)YH( + call)HY(backs)YH( together with database oper)HY(a)HY(tion)YH( call)HY(backs)YH( + \201)0 108 1 A(Section 14.1.7, ")SM(call)HY(back)YH()ES(")108 0 TN TL()Ec /AF f D(\202 + to manage the object's "dirty" flag.)EP( + + ) 57 58 PR(#include +#include + +#pragma db object callback\201update\202 +class object +{ + ... + + #pragma db transient + mutable bool dirty_; + + // Non-NULL value indicates that we are registered + // with this transaction. + // + #pragma db transient + mutable odb::transaction* tran_; + + void + update \201odb::callback_event e, odb::database&\202 const + { + using namespace odb::core; + + if \201e == callback_event::post_update\202 + return; + + // Mark the object as clean again but register a + // transaction callback in case the update is rolled + // back. + // + tran_ = &transaction::current \201\202; + tran_->callback_register \201&rollback,)WR( + const_cast \201this\202, + transaction::event_rollback, + 0, + &tran_\202; + dirty_ = false; + } + + static void + rollback \201unsigned short, void* key, unsigned long long\202 + { + // Restore the dirty flag since the changes have been + // rolled back. + // + object& o \201*static_cast \201key\202\202; + o.dirty_ = true; + } + + ~object \201\202 + { + // Unregister the callback if we are going away before + // the transaction. + // + if \201tran_ != 0\202 + tran_->callback_unregister \201this\202; + } +};)RP( + + )0 2 198 H(15.2)WB 523 Sn()WB 202 Sn( Persis)HY(tent)YH( Class Template Instan)HY(ti)HY(a)HY(tions)YH()EA()EH( + + )0 P(Similar to compos)HY(ite)YH( value types \201)0 65 1 A(Section 7.2, "Compos)HY(ite)YH( + Value Types")65 0 TN TL()Ec /AF f D(\202, a persis)HY(tent)YH( object can be defined as an instan)HY(ti)HY(a)HY(tion)YH( + of a C++ class template, for example:)EP( + + ) 13 39 PR(template +class person +{ + ... + + T first_; + T last_; +}; + +typedef person std_person; + +#pragma db object\201std_person\202 +#pragma db member\201std_person::last_\202 id)RP( + + )0 P(Note that the database support code for such a persis)HY(tent)YH( object + is gener)HY(ated)YH( when compil)HY(ing)YH( the header contain)HY(ing)YH( the + )SM(db\240object)ES( pragma and not the header contain)HY(ing)YH( + the template defi)HY(ni)HY(tion)YH( or the )SM(typedef)ES( name. This + allows us to use templates defined in other files, for example:)EP( + + ) 6 53 PR(#include // std::pair + +typedef std::pair person; +#pragma db object\201person\202 +#pragma db member\201person::first\202 id auto column\201"id"\202 +#pragma db member\201person::second\202 column\201"name"\202)RP( + + )0 P(You may also have to explic)HY(itly)YH( specify the object type in + calls to certain )SM(database)ES( class func)HY(tions)YH( due + to the inabil)HY(ity)YH( do distin)HY(guish)YH(, at the API level, between + smart point)HY(ers)YH( and persis)HY(tent)YH( objects defined as class + template instan)HY(ti)HY(a)HY(tions)YH(. For example:)EP( + + ) 9 29 PR(person p; + +db.update \201p\202; // Error. +db.reload \201p\202; // Error. +db.erase \201p\202; // Error. + +db.update \201p\202; // Ok. +db.reload \201p\202; // Ok. +db.erase \201p\202; // Ok.)RP( + + )0 P(It also makes sense to factor persis)HY(tent)YH( data members that do not + depend on template argu)HY(ments)YH( into a common, non-template base class. + The follow)HY(ing)YH( more real)HY(is)HY(tic)YH( example illus)HY(trates)YH( this approach:)EP( + + ) 25 39 PR(#pragma db object abstract +class base_common +{ + ... + + #pragma db id auto + unsigned long id; +}; + +template +class base: public base_common +{ + ... + + T value; +}; + +typedef base string_base; +#pragma db object\201string_base\202 abstract + +#pragma db object +class derived: public string_base +{ + ... +};)RP( + + )0 2 199 H(15.3)WB 524 Sn()WB 203 Sn( Bulk Database Oper)HY(a)HY(tions)YH()EA()EH( + + )0 P(Some database systems supported by ODB provide a mech)HY(a)HY(nism)YH(, often + called bulk or batch state)HY(ment)YH( execu)HY(tion)YH(, that allows us to execute + the same SQL state)HY(ment)YH( on multi)HY(ple)YH( sets of data at once and with a + single database API call. This often results in signif)HY(i)HY(cantly)YH( + better perfor)HY(mance)YH( if we need to execute the same state)HY(ment)YH( for a + large number of data sets \201thou)HY(sands)YH( to millions\202.)EP( + + )0 P(ODB trans)HY(lates)YH( this mech)HY(a)HY(nism)YH( to bulk oper)HY(a)HY(tions)YH( which allow + us to persist, update, or erase a range of objects in the database. + Currently, from all the database systems supported by ODB, only + Oracle and Microsoft SQL Server are capable of bulk oper)HY(a)HY(tions)YH(. + There is also currently no emula)HY(tion)YH( of the bulk API for other + databases nor dynamic multi-database support. As a result, if + you are using dynamic multi-database support, you will need to + "drop down" to static support in order to access the bulk API. + Refer to )0 205 1 A(Chapter 16, "Multi-Database Support")205 0 TN TL()Ec /AF f D( + for details.)EP( + + )0 P(As we will discuss later in this section, bulk oper)HY(a)HY(tions)YH( have + complex failure seman)HY(tics)YH( that is dictated by the under)HY(ly)HY(ing)YH( + database API. As a result, support for bulk persist, update, + and erase is limited to persis)HY(tent)YH( classes for which these + oper)HY(a)HY(tions)YH( can be performed with a single database state)HY(ment)YH( + execu)HY(tion)YH(. In partic)HY(u)HY(lar)YH(, bulk oper)HY(a)HY(tions)YH( are not avail)HY(able)YH( + for poly)HY(mor)HY(phic)YH( objects \201)0 71 1 A(Section 8.2, + "Poly)HY(mor)HY(phism)YH( Inher)HY(i)HY(tance)YH(")71 0 TN TL()Ec /AF f D(\202 or objects that have + contain)HY(ers)YH( \201inverse contain)HY(ers)YH( of object point)HY(ers)YH( are an + excep)HY(tion)YH(\202. Further)HY(more)YH(, for objects that have sections + \201)0 74 1 A(Chapter 9, "Sections")74 0 TN TL()Ec /AF f D(\202 the bulk update oper)HY(a)HY(tion)YH( + will only be avail)HY(able)YH( if all the sections are manu)HY(ally)YH(-updated. + On the other hand, bulk oper)HY(a)HY(tions)YH( are supported for objects + that use opti)HY(mistic)YH( concur)HY(rency)YH( \201)0 90 1 A(Chapter 12, + "Opti)HY(mistic)YH( Concur)HY(rency)YH(")90 0 TN TL()Ec /AF f D(\202 or have no object id + \201)0 107 1 A(Section 14.1.6, ")SM(no_id)ES(")107 0 TN TL()Ec /AF f D(\202.)EP( + + )0 P(To enable the gener)HY(a)HY(tion)YH( of bulk oper)HY(a)HY(tion)YH( support for a persis)HY(tent)YH( + class we use the )SM(bulk)ES( pragma. For example:)EP( + + ) 8 28 PR(#pragma db object bulk\2015000\202 +class person +{ + ... + + #pragma db id auto + unsigned long id; +};)RP( + + )0 P(The single argu)HY(ment)YH( to the )SM(bulk)ES( pragma is the batch + size. The batch size spec)HY(i)HY(fies)YH( the maximum number of data sets + that should be handled with a single under)HY(ly)HY(ing)YH( state)HY(ment)YH( execu)HY(tion)YH(. + If the range that we want to perform the bulk oper)HY(a)HY(tion)YH( on contains + more objects than the batch size, then ODB will split this oper)HY(a)HY(tion)YH( + into multi)HY(ple)YH( under)HY(ly)HY(ing)YH( state)HY(ment)YH( execu)HY(tions)YH( \201batches\202. To illus)HY(trate)YH( + this point with an example, suppose we want to persist 53,000 objects + and the batch size is 5,000. ODB will then execute the state)HY(ment)YH( + 11 times, the first 10 times with 5,000 data sets each, and the + last time with the remain)HY(ing)YH( 3,000 data sets.)EP( + + )0 P(The commonly used batch sizes are in the 2,000-5,000 range, though + smaller or larger batches could provide better perfor)HY(mance)YH(, + depend)HY(ing)YH( on the situ)HY(a)HY(tion)YH(. As a result, it is recom)HY(mended)YH( to + exper)HY(i)HY(ment)YH( with differ)HY(ent)YH( batch sizes to deter)HY(mine)YH( the optimum + number for a partic)HY(u)HY(lar)YH( object and its use-cases. Note also that + you may achieve better perfor)HY(mance)YH( by also split)HY(ting)YH( a large bulk + oper)HY(a)HY(tion)YH( into multi)HY(ple)YH( trans)HY(ac)HY(tions)YH( \201)0 28 1 A(Section 3.5, + "Trans)HY(ac)HY(tions)YH(")28 0 TN TL()Ec /AF f D(\202.)EP( + + )0 P(For database systems that do not support bulk oper)HY(a)HY(tions)YH( the + )SM(bulk)ES( pragma is ignored. It is also possi)HY(ble)YH( to + specify differ)HY(ent)YH( batch sizes for differ)HY(ent)YH( database systems + by using the database prefix, for example:)EP( + + ) 5 52 PR(#pragma db object mssql:bulk\2013000\202 oracle:bulk\2014000\202 +class person +{ + ... +};)RP( + + )0 P(Note that while spec)HY(i)HY(fy)HY(ing)YH( the batch size at compile time might + seem inflex)HY(i)HY(ble)YH(, this approach allows ODB to place inter)HY(nal)YH( + arrays of the fixed batch size on the stack rather than + allo)HY(cat)HY(ing)YH( them in the dynamic memory. However, spec)HY(i)HY(fy)HY(ing)YH( the + batch size at runtime may be supported in the future.)EP( + + )0 P(Once the bulk support is enabled for a partic)HY(u)HY(lar)YH( object, we can + use the follow)HY(ing)YH( )SM(database)ES( func)HY(tions)YH( to perform bulk + oper)HY(a)HY(tions)YH(:)EP( + + ) 15 60 PR(template +void +persist \201I begin, I end, bool continue_failed = true\202; + +template +void +update \201I begin, I end, bool continue_failed = true\202; + +template +void +erase \201I obj_begin, I obj_end, bool continue_failed = true\202; + +template +void +erase \201I id_begin, I id_end, bool continue_failed = true\202;)RP( + + )0 P(Every bulk API func)HY(tion)YH( expects a range of elements, passed in + the canon)HY(i)HY(cal)YH( C++ form as a pair of input iter)HY(a)HY(tors)YH(. In case of + )SM(persist\201\202)ES(, )SM(update\201\202)ES(, and the first + )SM(erase\201\202)ES( over)HY(load)YH(, we pass a range of objects, + either as refer)HY(ences)YH( or as point)HY(ers)YH(, raw or smart. The follow)HY(ing)YH( + example illus)HY(trates)YH( the most common scenar)HY(ios)YH( using the + )SM(persist\201\202)ES( call:)EP( + + ) 37 57 PR(// C array of objects. +// +person a[2] {{"John", "Doe"}, {"Jane", "Doe"}}; + +db.persist \201a, a + sizeof\201a\202 / sizeof\201a[0]\202\202; + + +// Vector of objects. +// +std::vector v {{"John", "Doe"}, {"Jane", "Doe"}}; + +db.persist \201v.begin \201\202, v.end \201\202\202; + + +// C array of raw pointers to objects. +// +person p1 \201"John", "Doe"\202; +person p2 \201"Jane", "Doe"\202; +person* pa[2] {&p1, &p2}; + +db.persist \201pa, pa + sizeof\201pa\202 / sizeof\201pa[0]\202\202; + + +// Vector of raw pointers to objects. +// +std::vector pv {&p1, &p2}; + +db.persist \201pv.begin \201\202, pv.end \201\202\202; + + +// Vector of smart \201shared\202 pointers to objects.)WR( +// +std::vector> sv { + std::make_shared \201"John", "Doe"\202, + std::make_shared \201"Jane", "Doe"\202}; + +db.persist \201sv.begin \201\202, sv.end \201\202\202;)RP( + + )0 P(The ability to perform a bulk oper)HY(a)HY(tion)YH( on a range of raw point)HY(ers)YH( + to objects can be espe)HY(cially)YH( useful when the appli)HY(ca)HY(tion)YH( stores + objects in a way that does not easily conform to the pair of + iter)HY(a)HY(tors)YH( inter)HY(face)YH(. In such cases we can create a tempo)HY(rary)YH( + container of shallow point)HY(ers)YH( to objects and use that to perform + the bulk oper)HY(a)HY(tion)YH(, for example:)EP( + + ) 25 43 PR(struct person_entry +{ + person obj; + + // Some additional data. + ... +}; + +typedef std::vector people; + +void +persist \201odb::database& db, people& p\202 +{ + std::vector tmp; + tmp.reserve \201p.size \201\202\202; + std::for_each \201p.begin \201\202, + p.end \201\202, + [&tmp] \201person_entry& pe\202 + { + tmp.push_back \201&pe.obj\202; + }\202; + + + db.persist \201tmp.begin \201\202, tmp.end \201\202\202; +})RP( + + )0 P(The second over)HY(load)YH( of the bulk )SM(erase\201\202)ES( func)HY(tion)YH( + allows us to pass a range of object ids rather than objects + them)HY(selves)YH(. As with the corre)HY(spond)HY(ing)YH( non-bulk version, we + have to specify the object type explic)HY(itly)YH(, for example:)EP( + + ) 3 44 PR(std::vector ids {1, 2}; + +db.erase \201ids.begin \201\202, ids.end \201\202\202;)RP( + + )0 P(Concep)HY(tu)HY(ally)YH(, a bulk oper)HY(a)HY(tion)YH( is equiv)HY(a)HY(lent)YH( to perform)HY(ing)YH( the + corre)HY(spond)HY(ing)YH( non-bulk version in a loop, except when it comes to the + failure seman)HY(tics)YH(. Both databases that currently are capable of + bulk oper)HY(a)HY(tions)YH( \201Oracle and SQL Server\202 do not stop when a data + set in a batch fails \201for example, because of a unique constraint + viola)HY(tion)YH(\202. Instead, they continue execut)HY(ing)YH( subse)HY(quent)YH( data + sets until every element in the batch has been attempted. The + )SM(continue_failed)ES( argu)HY(ment)YH( in the bulk func)HY(tions)YH( listed + above spec)HY(i)HY(fies)YH( whether ODB should extend this behav)HY(ior)YH( and continue + with subse)HY(quent)YH( batches if the one it has tried to execute has failed + elements. The default behav)HY(ior)YH( is to continue.)EP( + + )0 P(The conse)HY(quence)YH( of this failure seman)HY(tics)YH( is that we may have + multi)HY(ple)YH( elements in the range failed for differ)HY(ent)YH( reasons. + For example, if we tried to persist a number of objects, some + of them might have failed because they are already persis)HY(tent)YH( + while others \236 because of a unique constraint viola)HY(tion)YH(. + As a result, ODB uses the special )SM(odb::multi)HY(ple)YH(_excep)HY(tions)YH()ES( + class to report fail)HY(ures)YH( in the bulk API func)HY(tions)YH(. This + excep)HY(tion)YH( is thrown if one or more elements in the range have + failed and it contains the error infor)HY(ma)HY(tion)YH( in the form of other + ODB excep)HY(tion)YH( for each failed posi)HY(tion)YH(. The + )SM(multi)HY(ple)YH(_excep)HY(tions)YH()ES( class has the follow)HY(ing)YH( inter)HY(face)YH(:)EP( + + ) 58 50 PR(struct multiple_exceptions: odb::exception +{ + // Element type. + // + struct value_type + { + std::size_t + position \201\202 const; + + const odb::exception& + exception \201\202 const; + + bool + maybe \201\202 const; + }; + + // Iteration. + // + typedef std::set set_type; + + typedef set_type::const_iterator iterator; + typedef set_type::const_iterator const_iterator; + + iterator + begin \201\202 const; + + iterator + end \201\202 const; + + // Lookup. + //)WR( + const value_type* + operator[] \201std::size_t\202 const; + + // Severity, failed and attempted counts. + // + std::size_t + attempted \201\202 const; + + std::size_t + failed \201\202 const; + + bool + fatal \201\202 const; + + void + fatal \201bool\202; + + // Direct data access. + // + const set_type& + set \201\202 const; + + // odb::exception interface. + // + virtual const char* + what \201\202 const throw \201\202; +};)RP( + + )0 P(The )SM(multi)HY(ple)YH(_excep)HY(tions)YH()ES( class has a map-like inter)HY(face)YH( + with the key being the posi)HY(tion)YH( in the range and the value being + the excep)HY(tion)YH( plus the )SM(maybe)ES( flag \201discussed below\202. + As a result, we can either iterate over the failed posi)HY(tions)YH( or + we can check whether a specific posi)HY(tion)YH( in the range has failed. + The follow)HY(ing)YH( example shows what a )SM(catch)ES(-handler for + this excep)HY(tion)YH( might look like:)EP( + + ) 26 63 PR(std::vector objs {{"John", "Doe"}, {"Jane", "Doe"}}; + +try +{ + db.persist \201objs.begin \201\202, objs.end \201\202\202; +} +catch \201const odb::multiple_exceptions& me\202 +{ + for \201const auto& v: me\202 + { + size_t p \201v.position \201\202\202; + + try + { + throw v.exception \201\202; + } + catch \201const odb::object_already_persistent&\202 + { + cerr << p << ": duplicate id: " << objs[p].id \201\202 << endl; + } + catch \201const odb::exception& e\202 + { + cerr << p << ": " << e.what \201\202 << endl; + } + } +})RP( + + )0 P(If, however, all we want is to show the diag)HY(nos)HY(tics)YH( to the user, + then the string returned by the )SM(what\201\202)ES( func)HY(tion)YH( + will contain the error infor)HY(ma)HY(tion)YH( for each failed posi)HY(tion)YH(. + Here is what it might look like \201using Oracle as an example\202:)EP( + + ) 3 69 PR(multiple exceptions, 4 elements attempted, 2 failed: +[0] object already persistent +[3] 1: ORA-00001: unique constraint \201ODB_TEST.person_last_i\202 violated)RP( + + )0 P(Both databases that currently are capable of bulk oper)HY(a)HY(tions)YH( return + a total count of affected rows rather than indi)HY(vid)HY(ual)YH( counts for + each data set. This limi)HY(ta)HY(tion)YH( prevents ODB from being able to + always deter)HY(mine)YH( which elements in the batch haven't affected + any rows and, for the update and erase oper)HY(a)HY(tions)YH(, trans)HY(late)YH( + this to the )SM(object_not_persis)HY(tent)YH()ES( excep)HY(tions)YH(. As + a result, if some elements in the batch haven't affected any + rows and ODB is unable to deter)HY(mine)YH( exactly which ones, it will mark + all the elements in this batch as "maybe not persis)HY(tent)YH(". That + is, it will insert the )SM(object_not_persis)HY(tent)YH()ES( excep)HY(tion)YH( + and set the )SM(maybe)ES( flag for every posi)HY(tion)YH( in the + batch. The diag)HY(nos)HY(tics)YH( string returned by )SM(what\201\202)ES( + will also reflect this situ)HY(a)HY(tion)YH(, for example \201assum)HY(ing)YH( batch + size of 3\202:)EP( + + ) 3 52 PR(multiple exceptions, 4 elements attempted, 4 failed: +[0-2] \201some\202 object not persistent +[3] object not persistent)RP( + + )0 P(The way to handle and recover from such "maybe fail)HY(ures)YH(" will have + to be appli)HY(ca)HY(tion)YH(-specific. For example, for some appli)HY(ca)HY(tions)YH( the + fact that some objects no longer exist in the database when + perform)HY(ing)YH( bulk erase might be an ignor)HY(able)YH( error. If, however, + the appli)HY(ca)HY(tion)YH( needs to deter)HY(mine)YH( exactly which elements in the batch + have failed, then a )SM(load\201\202)ES( call will be required for each + element in the batch \201or a query using a view to avoid loading all + the data members; )0 79 1 A(Chapter 10, "Views")79 0 TN TL()Ec /AF f D(\202. This is also + some)HY(thing)YH( to keep in mind when select)HY(ing)YH( the batch size since for + larger sizes it will be more expen)HY(sive)YH( \201more loads to perform\202 to + handle such "maybe fail)HY(ures)YH(". If the fail)HY(ures)YH( are not uncom)HY(mon)YH(, as + is the case, for example, when using opti)HY(mistic)YH( concur)HY(rency)YH(, then + it may make sense to use a smaller batch.)EP( + + )0 P(The lookup oper)HY(a)HY(tor)YH( \201)SM(oper)HY(a)HY(tor)YH([])ES(\202 returns )SM(NULL)ES( + if the element at this posi)HY(tion)YH( has no excep)HY(tion)YH(. Note also that the + returned value is )SM(value_type*)ES( and not + )SM(odb::excep)HY(tion)YH(*)ES( in order to provide access to the + )SM(maybe)ES( flag discussed above.)EP( + + )0 P(The )SM(multi)HY(ple)YH(_excep)HY(tions)YH()ES( class also provides access + to the number of posi)HY(tions)YH( attempted \201the )SM(attempted\201\202)ES( + acces)HY(sor)YH(\202 and failed \201the )SM(failed\201\202)ES( acces)HY(sor)YH(\202. Note + that the failed count includes the "maybe failed" posi)HY(tions)YH(.)EP( + + )0 P(The )SM(multi)HY(ple)YH(_excep)HY(tions)YH()ES( excep)HY(tion)YH( can also be fatal. + If the )SM(fatal\201\202)ES( acces)HY(sor)YH( returns )SM(true)ES(, then + \201some of\202 the excep)HY(tions)YH( were fatal. In this case, even for posi)HY(tions)YH( + that did not fail, no attempts were made to complete the oper)HY(a)HY(tion)YH( + and the trans)HY(ac)HY(tion)YH( must be aborted.)EP( + + )0 P(If )SM(fatal\201\202)ES( returns false, then the oper)HY(a)HY(tion)YH( on the + elements that don't have an excep)HY(tion)YH( has succeeded. The appli)HY(ca)HY(tion)YH( + can ignore the errors or try to correct the errors and re-attempt + the oper)HY(a)HY(tion)YH( on the elements that did fail. In either case, the + trans)HY(ac)HY(tion)YH( can be commit)HY(ted)YH(.)EP( + + )0 P(An example of a fatal excep)HY(tion)YH( would be the situ)HY(a)HY(tion)YH( where the + execu)HY(tion)YH( of the under)HY(ly)HY(ing)YH( state)HY(ment)YH( failed summar)HY(ily)YH(, without + attempt)HY(ing)YH( any data sets, for instance, because of an error in + the state)HY(ment)YH( itself.)EP( + + )0 P(The )SM(fatal\201\202)ES( modi)HY(fier)YH( allows you to "upgrade" an + excep)HY(tion)YH( to fatal, for example, for specific database error + codes.)EP( + + + + + + )WB NL NP( + )0 1 200 H(PART)WB 525 Sn()WB 204 Sn( II\240\240 + DATABASE SYSTEMS)EA()EH( + + )0 P(Part II covers topics specific to the database system + imple)HY(men)HY(ta)HY(tions)YH( and their support in ODB. The first chapter in + Part II discusses how to use multi)HY(ple)YH( database systems in the + same appli)HY(ca)HY(tion)YH(. The subse)HY(quent)YH( chap)HY(ters)YH( describe the system-specific + )SM(database)ES( classes as well as the default mapping + between basic C++ value types and native database types. Part + II consists of the follow)HY(ing)YH( chap)HY(ters)YH(.)EP( + + )10 PT( + + + + + + )WB NL NP( + )0 1 201 H(16)WB 526 Sn()WB 205 Sn( Multi-Database Support)EA()EH( + + )0 P(Some appli)HY(ca)HY(tions)YH( may need to access multi)HY(ple)YH( database systems, either + simul)HY(ta)HY(ne)HY(ously)YH( or one at a time. For example, an appli)HY(ca)HY(tion)YH( may + utilize an embed)HY(ded)YH( database such as SQLite as a local cache and use + a client-server database such as Post)HY(greSQL)YH( for more perma)HY(nent)YH( + but slower to access remote storage. Or an appli)HY(ca)HY(tion)YH( may need + to be able to store its data in any database selected at runtime + by the user. Yet another scenario is the data migra)HY(tion)YH( from one + database system to another. In this case, multi-database support + is only required for a short period. It is also plau)HY(si)HY(ble)YH( that an + appli)HY(ca)HY(tion)YH( imple)HY(ments)YH( all three of these scenar)HY(ios)YH(, that is, it + uses SQLite as a local cache, allows the user to select the remote + database system, and supports data migra)HY(tion)YH( from one remote database + system to another.)EP( + + )0 P(ODB provides two types of multi-database support: )EM(static)ES( + and )EM(dynamic)ES(. With static support we use the + database system-specific inter)HY(faces)YH( to perform database + oper)HY(a)HY(tions)YH(. That is, instead of using )SM(odb::database)ES(, + )SM(odb::trans)HY(ac)HY(tion)YH()ES(, or )SM(odb::query)ES(, we + would use, for example, )SM(odb::sqlite::database)ES(, + )SM(odb::sqlite::trans)HY(ac)HY(tion)YH()ES(, or + )SM(odb::sqlite::query)ES( to access an SQLite database.)EP( + + )0 P(In contrast, with )EM(dynamic)ES( multi-database support we can + use the common inter)HY(face)YH( to access any database without having to + know which one it is. At runtime, ODB will auto)HY(mat)HY(i)HY(cally)YH( dispatch + a call on the common inter)HY(face)YH( to the specific database imple)HY(men)HY(ta)HY(tion)YH( + based on the actual )SM(database)ES( instance being + used. In fact, this mech)HY(a)HY(nism)YH( is very similar to C++ virtual + func)HY(tions)YH(.)EP( + + )0 P(Both static and dynamic multi-database support have a differ)HY(ent)YH( set + of advan)HY(tages)YH( and disad)HY(van)HY(tages)YH( which makes them more or less suit)HY(able)YH( + for differ)HY(ent)YH( use cases. Static support has zero over)HY(head)YH( compared + to single-database support and allows us to use database + system-specific features, exten)HY(sions)YH(, etc. At the same time, the + code that we write will be tied to the specific database system. + As a result, this type of multi-database support is more + suit)HY(able)YH( for situ)HY(a)HY(tions)YH( where differ)HY(ent)YH( parts of an appli)HY(ca)HY(tion)YH( + access differ)HY(ent)YH( but specific database systems. For example, + using SQLite as a local cache most likely falls into this + cate)HY(gory)YH( since we are using a specific database system \201SQLite\202 + and the code that will check the cache will most likely \201but + not neces)HY(sar)HY(ily)YH(\202 be sepa)HY(rate)YH( from the code that inter)HY(act)YH( with + the remote database. Another example where static multi-database + support might be more suit)HY(able)YH( is a once-off data migra)HY(tion)YH( from + one database system to another. In this case both the source and + target are specific database systems. In contrast, if data migra)HY(tion)YH( + from one database system to another is a general feature in an + appli)HY(ca)HY(tion)YH(, then dynamic multi-database support might be more + suit)HY(able)YH(.)EP( + + )0 P(The main advan)HY(tage)YH( of dynamic multi-database support is the + database system-inde)HY(pen)HY(dence)YH( of the code that we write. The same + appli)HY(ca)HY(tion)YH( code will work with any database system supported by + ODB and the gener)HY(ated)YH( database support code can be pack)HY(aged)YH( into + sepa)HY(rate)YH( libraries and loaded dynam)HY(i)HY(cally)YH( by the appli)HY(ca)HY(tion)YH(. The + disad)HY(van)HY(tages)YH( of dynamic support are slight over)HY(head)YH( and certain + limi)HY(ta)HY(tions)YH( in func)HY(tion)HY(al)HY(ity)YH( compared to static support \201see + )0 207 1 A(Section 16.2, "Dynamic Multi-Database Support")207 0 TN TL()Ec /AF f D( + for details\202. As a result, dynamic multi-database support is most + suit)HY(able)YH( to situ)HY(a)HY(tions)YH( where we need the same code to + work with a range of database systems. For example, if your + appli)HY(ca)HY(tion)YH( must be able to store its data in any database + selected by the user, then dynamic support is prob)HY(a)HY(bly)YH( the + best option.)EP( + + )0 P(Note also that it is possi)HY(ble)YH( to mix and match static and dynamic + support in the same appli)HY(ca)HY(tion)YH(. In fact, dynamic support is built + on top of static support so it is possi)HY(ble)YH( to use the same database + system both "stat)HY(i)HY(cally)YH(" and "dynam)HY(i)HY(cally)YH(". In partic)HY(u)HY(lar)YH(, the ability + to "drop down" from dynamic to static support can be used to over)HY(come)YH( + the func)HY(tion)HY(al)HY(ity)YH( limi)HY(ta)HY(tions)YH( mentioned above. Finally, + single-database support is just a special case of static + multi-database support with a single database system.)EP( + + )0 P(By default ODB assumes single-database support. To enable + multi-database support we use the )SM(--multi-database)ES( + \201or )SM(-m)ES(\202 ODB compiler option. This option is also used to + specify the support type: )SM(static)ES( or )SM(dynamic)ES(. + For example:)EP( + + ) 1 28 PR(odb -m static ... person.hxx)RP( + + )0 P(With multi-database support enabled, we can now gener)HY(ate)YH( the database + support code for several database systems. This can be accom)HY(plished)YH( + either with a single ODB compiler invo)HY(ca)HY(tion)YH( by spec)HY(i)HY(fy)HY(ing)YH( multi)HY(ple)YH( + )SM(--database)ES( \201or )SM(-d)ES(\202 options or with multi)HY(ple)YH( + ODB compiler invo)HY(ca)HY(tions)YH(. Both approaches produce the same result, + for example:)EP( + + ) 1 53 PR(odb -m static -d common -d sqlite -d pgsql person.hxx)RP( + + )0 P(Is equiv)HY(a)HY(lent)YH( to:)EP( + + ) 3 34 PR(odb -m static -d common person.hxx +odb -m static -d sqlite person.hxx +odb -m static -d pgsql person.hxx)RP( + + )0 P(Notice that the first )SM(-d)ES( option has )SM(common)ES( + as its value. This is not a real database system. Rather, it instructs + the ODB compiler to gener)HY(ate)YH( code that is common to all the database + systems and, in case of dynamic support, is also the common + inter)HY(faces)YH(.)EP( + + )0 P(If you look at the result of the above commands, you will also notice + changes in the output file names. In the single-database mode the ODB + compiler produces a single set of the )SM(person-odb.?xx)ES( files + which contain both the common as well as the database specific + gener)HY(ated)YH( code \201since there is only one database system in use, + there is no reason to split the two\202. In contrast, in the + multi-database mode, the )SM(person-odb.?xx)ES( set of files + contains the common code while the database system-specific code is + written to files in the form )SM(person-odb-.?xx)ES(. + That is, )SM(person-odb-sqlite.?xx)ES( for SQLite, + )SM(person-odb-pgsql.?xx)ES( for Post)HY(greSQL)YH(, etc.)EP( + + )0 P(If we need dynamic support for some databases and static for + others, then the )SM(common)ES( code must be gener)HY(ated)YH( + in the dynamic mode. For example, if we need static support + for SQLite and dynamic support for Post)HY(greSQL)YH( and Oracle, then + the ODB compiler invo)HY(ca)HY(tions)YH( could look like this:)EP( + + ) 4 35 PR(odb -m dynamic -d common person.hxx +odb -m static -d sqlite person.hxx +odb -m dynamic -d pgsql person.hxx +odb -m dynamic -d oracle person.hxx)RP( + + )0 P(With multi-database support enabled, it is possi)HY(ble)YH( to restrict ODB + pragmas to apply only to a specific database system \201unre)HY(stricted)YH( + pragmas apply to all the databases\202. For example:)EP( + + ) 12 59 PR(#pragma db object +class person +{ + ... + + #pragma db pgsql:type\201"VARCHAR\201128\202"\202 sqlite:type\201"TEXT"\202 + std::string name_; + + unsigned short age_; + + #pragma db pgsql index member\201age_\202 +};)RP( + + )0 P(Above, the pragma for the )SM(name_)ES( data member shows the + use of a database prefix \201for example, )SM(pgsql:)ES(\202 that + only applies to the spec)HY(i)HY(fier)YH( that follows. The pragma that defines + an index on the )SM(age_)ES( data member shows the use of a + database prefix that applies to the whole pragma. In this case the + database name must imme)HY(di)HY(ately)YH( follow the )SM(db)ES( keyword.)EP( + + + )0 P(Similar to pragmas, ODB compiler options that deter)HY(mine)YH( the kind + \201for example, )SM(--schema-format)ES(\202, names \201for example, + )SM(--odb-file-suffix)ES(\202, or content \201for example, prologue + and epilogue options\202 of the output files can be prefixed with the + database name. For example:)EP( + + ) 1 44 PR(odb --odb-file-suffix common:-odb-common ...)RP( + + )0 P(Dynamic multi-database support requires consis)HY(tent)YH( mapping across + all the databases. That is, the same classes and data members + should be mapped to objects, simple/compos)HY(ite)YH( values, etc., for + all the databases. In contrast, static multi-database support + does not have this restric)HY(tion)YH(. Specif)HY(i)HY(cally)YH(, with static support, + some data members can be tran)HY(sient)YH( for some database systems. + Simi)HY(larly)YH(, the same class \201for example, )SM(point)ES(\202 can + be mapped to a simple value in one database \201for example, to the + )SM(POINT)ES( Post)HY(greSQL)YH( type\202 and to a compos)HY(ite)YH( value + in another \201for example, in SQLite, which does not have a + built-in point type\202.)EP( + + )0 P(The follow)HY(ing)YH( sections discuss static and dynamic multi-database + support in more detail.)EP( + + + )0 2 202 H(16.1)WB 527 Sn()WB 206 Sn( Static Multi-Database Support)EA()EH( + + )0 P(With static multi-database support, instead of includ)HY(ing)YH( + )SM(person-odb.hxx)ES(, appli)HY(ca)HY(tion)YH( source code has + to include )SM(person-odb-.hxx)ES( header files + corre)HY(spond)HY(ing)YH( to the database systems that will be used.)EP( + + )0 P(The appli)HY(ca)HY(tion)YH( code has to also use database system-specific + inter)HY(faces)YH( when perform)HY(ing)YH( database oper)HY(a)HY(tions)YH(. As an example, + consider the follow)HY(ing)YH( trans)HY(ac)HY(tion)YH( in a single-database + appli)HY(ca)HY(tion)YH(. It uses the common inter)HY(faces)YH(, that is, classes + from the )SM(odb)ES( names)HY(pace)YH(.)EP( + + ) 11 46 PR(#include "person-odb.hxx" + +odb::database& db = ... + +typedef odb::query query; +typedef odb::result result; + +odb::transaction t \201db.begin \201\202\202; +result r \201db.query \201query::age < 30\202\202; +... +t.commit \201\202;)RP( + + )0 P(In an appli)HY(ca)HY(tion)YH( that employs static multi-database support + the same trans)HY(ac)HY(tion)YH( for SQLite would be rewrit)HY(ten)YH( like this:)EP( + + ) 11 67 PR(#include "person-odb-sqlite.hxx" + +odb::sqlite::database& db = ... + +typedef odb::sqlite::query query; +typedef odb::result result; // odb:: not odb::sqlite:: + +odb::sqlite::transaction t \201db.begin \201\202\202; +result r \201db.query \201query::age < 30\202\202; +... +t.commit \201\202;)RP( + + )0 P(That is, the )SM(database)ES(, )SM(trans)HY(ac)HY(tion)YH()ES(, and + )SM(query)ES( classes now come from the )SM(odb::sqlite)ES( + names)HY(pace)YH( instead of )SM(odb)ES(. Other classes that have + database system-specific inter)HY(faces)YH( are )SM(connec)HY(tion)YH()ES(, + )SM(state)HY(ment)YH()ES(, and )SM(tracer)ES(. Note that + all of them derive from the corre)HY(spond)HY(ing)YH( common versions. It + is also possi)HY(ble)YH( to use common )SM(trans)HY(ac)HY(tion)YH()ES(, + )SM(connec)HY(tion)YH()ES(, and )SM(state)HY(ment)YH()ES( classes + with static support, if desired.)EP( + + )0 P(Notice that we didn't use the )SM(odb::sqlite)ES( names)HY(pace)YH( + for the )SM(result)ES( class template. This is because + )SM(result)ES( is database system-inde)HY(pen)HY(dent)YH(. All other + classes defined in names)HY(pace)YH( )SM(odb)ES(, except those + specif)HY(i)HY(cally)YH( mentioned above, are database system-inde)HY(pen)HY(dent)YH(. + In partic)HY(u)HY(lar)YH(, )SM(result)ES(, )SM(prepared_query)ES(, + )SM(session)ES(, )SM(schema_catalog)ES(, and all the + excep)HY(tions)YH( are database system-inde)HY(pen)HY(dent)YH(.)EP( + + )0 P(Writing )SM(odb::sqlite::)ES( before every name can quickly + become burden)HY(some)YH(. As we have seen before, in single-database + appli)HY(ca)HY(tions)YH( that use the common inter)HY(face)YH( we can add the + )SM(using names)HY(pace)YH()ES( direc)HY(tive)YH( to avoid qual)HY(i)HY(fy)HY(ing)YH( + each name. For example:)EP( + + ) 15 62 PR(#include "person-odb.hxx" + +odb::database& db = ... + +{ + using namespace odb::core; + + typedef query person_query; + typedef result person_result; + + transaction t \201db.begin \201\202\202; + person_result r \201db.query \201person_query::age < 30\202\202; + ... + t.commit \201\202; +})RP( + + )0 P(A similar mech)HY(a)HY(nism)YH( is avail)HY(able)YH( in multi-database support. Each + database runtime defines the )SM(odb::::core)ES( + names)HY(pace)YH( that contains all the database system-inde)HY(pen)HY(dent)YH( + names as well as the database system-specific ones for this + database. Here is how we can rewire the above trans)HY(ac)HY(tion)YH( + using this approach:)EP( + + ) 15 62 PR(#include "person-odb-sqlite.hxx" + +odb::sqlite::database& db = ... + +{ + using namespace odb::sqlite::core; + + typedef query person_query; + typedef result person_result; + + transaction t \201db.begin \201\202\202; + person_result r \201db.query \201person_query::age < 30\202\202; + ... + t.commit \201\202; +})RP( + + )0 P(If the )SM(using names)HY(pace)YH()ES( direc)HY(tive)YH( cannot be used, for + example, because the same code frag)HY(ment)YH( accesses several databases, + then we can still make the names)HY(pace)YH( qual)HY(i)HY(fi)HY(ca)HY(tions)YH( more concise + by assign)HY(ing)YH( shorter aliases to database names)HY(paces)YH(. For example:)EP( + + ) 33 71 PR(#include "person-odb-pgsql.hxx" +#include "person-odb-sqlite.hxx" + +namespace pg = odb::pgsql; +namespace sl = odb::sqlite; + +pg::database& pg_db = ... +sl::database& sl_db = ... + +typedef pg::query pg_query; +typedef sl::query sl_query; +typedef odb::result result; + +// First check the local cache. +// +odb::transaction t \201sl_db.begin \201\202\202; // Note: using common transaction. +result r \201sl_db.query \201sl_query::age < 30\202\202; + +// If no hits, try the remote database. +// +if \201r.empty \201\202\202 +{ + t.commit \201\202; // End the SQLite transaction. + t.reset \201pg_db.begin \201\202\202; // Start the PostgreSQL transaction. + + r = pg_db.query \201pg_query::age < 30\202; +} + +// Handle the result. +// +...)WR( + +t.commit \201\202;)RP( + + )0 P(With static multi-database support we can make one of the databases + the default database with the )SM(--default-database)ES( option. + The default database can be accessed via the common inter)HY(face)YH(, just + like with single-database support. For example:)EP( + + ) 1 71 PR(odb -m static -d common -d pgsql -d sqlite --default-database pgsql ...)RP( + + )0 P(The default database mech)HY(a)HY(nism)YH( can be useful when one of the + databases is primary or when retrofitting multi-database support + into an exist)HY(ing)YH( single-database appli)HY(ca)HY(tion)YH(. For example, if + we are adding SQLite as a local cache into an exist)HY(ing)YH( + appli)HY(ca)HY(tion)YH( that uses Post)HY(greSQL)YH( as its only database, then + by making Post)HY(greSQL)YH( the default database we avoid having to + change all the exist)HY(ing)YH( code. Note that if dynamic multi-database + support is enabled, then the common \201dynamic\202 inter)HY(face)YH( is always + made the default database.)EP( + + )0 2 203 H(16.2)WB 528 Sn()WB 207 Sn( Dynamic Multi-Database Support)EA()EH( + + )0 P(With dynamic multi-database support, appli)HY(ca)HY(tion)YH( source code only + needs to include the )SM(person-odb.hxx)ES( header file, just + like with single-database support. In partic)HY(u)HY(lar)YH(, we don't need + to include any of the )SM(person-odb-.hxx)ES( files + unless we would also like to use certain database systems in the + static multi-database mode.)EP( + + )0 P(When perform)HY(ing)YH( database oper)HY(a)HY(tions)YH(, the appli)HY(ca)HY(tion)YH( code + uses the common inter)HY(faces)YH( from the )SM(odb)ES( names)HY(pace)YH(, + just like with single-database support. As an example, consider + a func)HY(tion)YH( that can be used to load an object either from a local + SQLite cache or a remote Post)HY(greSQL)YH( database \201in reality, this + func)HY(tion)YH( can be used with any database system support by ODB + provided we gener)HY(ated)YH( the database support code for this database + and linked it into our appli)HY(ca)HY(tion)YH(\202:)EP( + + ) 24 53 PR(#include "person-odb.hxx" + +std::unique_ptr +load \201odb::database& db, const std::string& name\202 +{ + odb::transaction t \201db.begin \201\202\202; + std::unique_ptr p \201db.find \201name\202\202; + t.commit \201\202; + return p; +} + +odb::pgsql::database& pg_db = ... +odb::sqlite::database& sl_db = ... + +// First try the local cache. +// +std::unique_ptr p \201load \201sl_db, "John Doe"\202\202; + +// If not found, try the remote database. +// +if \201p == 0\202 + p = load \201pg_db, "John Doe"\202; + +...)RP( + + )0 P(As you can see, we can use dynamic multi-database support just like + single-database support except that now our code can work with + differ)HY(ent)YH( database systems. Note, however, one differ)HY(ence)YH(: with + single-database support we could perform database oper)HY(a)HY(tions)YH( using + either the common )SM(odb::database)ES( or a database system-specific + \201for example, )SM(odb::sqlite::database)ES(\202 inter)HY(face)YH( + with the same effect. In contrast, with dynamic multi-database support, + the use of the database system-specific inter)HY(face)YH( results in the + switch to the static mode \201for which, as was mentioned earlier, we would + need to include the corre)HY(spond)HY(ing)YH( )SM(person-odb-.hxx)ES( + header file\202. As we will discuss shortly, switch)HY(ing)YH( from dynamic to + static mode can be used to over)HY(come)YH( limi)HY(ta)HY(tions)YH( imposed by dynamic + multi-database support.)EP( + + )0 P(Dynamic multi-database support has certain over)HY(heads)YH( and limi)HY(ta)HY(tions)YH( + compared to static support. For database oper)HY(a)HY(tions)YH(, the gener)HY(ated)YH( code + main)HY(tains)YH( func)HY(tion)YH( tables that are used to dispatch calls to the database + system-specific imple)HY(men)HY(ta)HY(tions)YH(. In single-database and static + multi-database support, the )SM(query)ES( type imple)HY(ments)YH( a thin + wrapper around the under)HY(ly)HY(ing)YH( database system's )SM(SELECT)ES( + state)HY(ment)YH(. With dynamic multi-database support, because the + under)HY(ly)HY(ing)YH( database system is only known at query execu)HY(tion)YH( + \201or prepa)HY(ra)HY(tion)YH(\202 time, the )SM(query)ES( type stores a + database system-inde)HY(pen)HY(dent)YH( repre)HY(sen)HY(ta)HY(tion)YH( of the query that + is then trans)HY(lated)YH( to the database system-specific form. Because + of this database system-inde)HY(pen)HY(dent)YH( repre)HY(sen)HY(ta)HY(tion)YH(, dynamic + support queries have a number of limi)HY(ta)HY(tions)YH(. Specif)HY(i)HY(cally)YH(, dynamic + queries do not support param)HY(e)HY(ter)YH( binding in native query frag)HY(ments)YH(. + They also make copies of by-value param)HY(e)HY(terd)YH( \201by-refer)HY(ence)YH( param)HY(e)HY(ters)YH( + can be used to remove this over)HY(head)YH(\202. Finally, param)HY(e)HY(ters)YH( of array + types \201for example, )SM(char[256])ES(\202 can only be bound + by-refer)HY(ence)YH(.)EP( + + )0 P(As we mentioned earlier, switch)HY(ing)YH( from dynamic to static mode + can be an effec)HY(tive)YH( way to over)HY(come)YH( these limi)HY(ta)HY(tions)YH(. As an + example, consider a func)HY(tion)YH( that prints the list of people of + a certain age. The caller also spec)HY(i)HY(fied)YH( the limit on the number + of entries to print. Some database systems, for example, Post)HY(greSQL)YH(, + allow us to prop)HY(a)HY(gate)YH( this limit to the database server with the + )SM(LIMIT)ES( clause. To add this clause we would need to + construct a native query frag)HY(ment)YH( and, as we discussed above, we + won't be able to bind a param)HY(e)HY(ter)YH( \201the limit\202 while in the dynamic + mode. The follow)HY(ing)YH( imple)HY(men)HY(ta)HY(tion)YH( shows how we can over)HY(come)YH( this + by switch)HY(ing)YH( to the static mode and using the Post)HY(greSQL)YH(-specific + inter)HY(face)YH(:)EP( + + ) 41 68 PR(#include "person-odb.hxx" +#include "person-odb-pgsql.hxx" // Needed for static mode. + +void +print \201odb::database& db, unsigned short age, unsigned long limit\202 +{ + typedef odb::query query; + typedef odb::result result; + + odb::transaction t \201db.begin \201\202\202; + + query q \201query::age == age\202; + result r; + + if \201db.id \201\202 == odb::id_pgsql\202 + { + // We are using PostgreSQL. Drop down to the static mode and + // add the LIMIT clause to the query. + // + namespace pg = odb::pgsql; + typedef pg::query pg_query; + + pg::database& pg_db \201static_cast \201db\202\202; + pg_query pg_q \201pg_query \201q\202 + "LIMIT" + pg_query::_val \201limit\202\202; + r = pg_db.query \201pg_q\202; + } + else + r = db.query \201q\202; + + // Handle the result up to the limit elements. + //)WR( + ... + + t.commit \201\202; +} + +odb::pgsql::database& pg_db = ... +odb::sqlite::database& sl_db = ... + +print \201sl_db, 30, 100\202; +print \201sl_db, 30, 100\202;)RP( + + )0 P(A few things to note about this example. First, we use the + )SM(database::id\201\202)ES( func)HY(tion)YH( to deter)HY(mine)YH( the actual database + system we use. This func)HY(tion)YH( has the follow)HY(ing)YH( signa)HY(ture)YH(:)EP( + + ) 21 18 PR(namespace odb +{ + enum database_id + { + id_mysql, + id_sqlite, + id_pgsql, + id_oracle, + id_mssql, + id_common + }; + + class database + { + public: + ... + + database_id + id \201\202 const; + } +})RP( + + )0 P(Note that )SM(database::id\201\202)ES( can never return the + )SM(id_common)ES( value.)EP( + + )0 P(The other thing to note is how we trans)HY(late)YH( the dynamic query + to the database system-specific one \201the )SM(pg_query \201q\202)ES( + expres)HY(sion)YH(\202. Every )SM(odb::::query)ES( class provides + such a trans)HY(la)HY(tion)YH( construc)HY(tor)YH(.)EP( + + )0 3 204 H(16.2.2)WB 529 Sn()WB 208 Sn( Dynamic Loading of Database Support Code)EA()EH( + + )0 P(With dynamic multi-database support, the gener)HY(ated)YH( database support + code auto)HY(mat)HY(i)HY(cally)YH( regis)HY(ters)YH( itself with the func)HY(tion)YH( tables that + we mentioned earlier. This makes it possi)HY(ble)YH( to package the gener)HY(ated)YH( + code for each database into a sepa)HY(rate)YH( dynamic-link library \201Windows + DLL\202 or dynamic shared object \201Unix DSO; collec)HY(tively)YH( referred to as + DLLs from now on\202 and load/unload them from the appli)HY(ca)HY(tion)YH( + dynam)HY(i)HY(cally)YH( using APIs such as Win32 )SM(Load)HY(Li)HY(brary)YH(\201\202)ES( or + POSIX )SM(dlopen\201\202)ES(. This allows the appli)HY(ca)HY(tion)YH( address + space to contain code only for database systems that are actu)HY(ally)YH( + needed in any partic)HY(u)HY(lar)YH( moment. Another advan)HY(tage)YH( of this approach + is the ability to distribute indi)HY(vid)HY(ual)YH( database system support + sepa)HY(rately)YH(.)EP( + + )0 P(This section provides an overview of how to package the gener)HY(ated)YH( + database support code into DLLs for both Windows and Unix using + GNU/Linux as an example. Note also that if static multi-database + support is used for a partic)HY(u)HY(lar)YH( database system, then the dynamic + loading cannot be used for this database. It is, however, still + possi)HY(ble)YH( to package the gener)HY(ated)YH( code into a DLL but this DLL + will have to be linked to the executable at link-time rather + than at runtime. If dynamic loading is desir)HY(able)YH( in this situ)HY(a)HY(tion)YH(, + then another alter)HY(na)HY(tive)YH( would be to package the func)HY(tion)HY(al)HY(ity)YH( + that requires static support together with the database support + code into the DLL and import this func)HY(tion)HY(al)HY(ity)YH( dynam)HY(i)HY(cally)YH( + using the )SM(GetP)HY(ro)HY(cAd)HY(dress)YH(\201\202)ES( \201Win32\202 or )SM(dlsym\201\202)ES( + \201Unix\202 func)HY(tion)YH(.)EP( + + )0 P(The first step in pack)HY(ag)HY(ing)YH( the gener)HY(ated)YH( code into DLLs is to + set up the symbol export)HY(ing)YH(. This step is required for + Windows DLLs but is optional for Unix DSOs. Most modern Unix + systems \201such as GNU/Linux\202 provide control over symbol + visi)HY(bil)HY(ity)YH(, which is a mech)HY(a)HY(nism)YH( similar to Windows symbol + export)HY(ing)YH(. Notable advan)HY(tages)YH( of using this mech)HY(a)HY(nism)YH( to + explic)HY(itly)YH( specify which symbols are visible include + smaller Unix DSOs and faster load times. If, however, you are + not plan)HY(ning)YH( to control symbol visi)HY(bil)HY(ity)YH( on Unix, then you can + skip directly to the second step below.)EP( + + )0 P(An impor)HY(tant)YH( point to under)HY(stand)YH( is that we only need to export + the common inter)HY(face)YH(, that is, the classes defined in the + )SM(person-odb.hxx)ES( header. In partic)HY(u)HY(lar)YH(, we don't need + to export the database system-specific classes defined in + the )SM(person-odb-.hxx)ES(, unless we are also using + this database in the static mode \201in which case, the proce)HY(dure)YH( + described below will need to be repeated for that database as + well\202.)EP( + + )0 P(The ODB compiler provides two command line options, + )SM(--export-symbol)ES( and )SM(--extern-symbol)ES(, + which can be used to insert the export and extern + macros in all the neces)HY(sary)YH( places in the gener)HY(ated)YH( header file. + You are prob)HY(a)HY(bly)YH( famil)HY(iar)YH( with the concept of export macro which + expands to an export direc)HY(tive)YH( if we are build)HY(ing)YH( the DLL and to + an import direc)HY(tive)YH( if we are build)HY(ing)YH( client code. The + extern macro is a supple)HY(men)HY(tary)YH( mech)HY(a)HY(nism)YH( which is neces)HY(sary)YH( to + export explicit template instan)HY(ti)HY(a)HY(tions)YH( used by the gener)HY(ated)YH( + code when query support is enabled. As we will see shortly, the + extern macro must expand into the )SM(extern)ES( C++ keyword + in certain situ)HY(a)HY(tions)YH( and must be left unde)HY(fined)YH( in others. To + manage all these macro defi)HY(ni)HY(tions)YH(, it is custom)HY(ary)YH( to create the + so called export header. Based on a single macro that is normally + defined in the project file or on the command line and which + indi)HY(cates)YH( whether we are build)HY(ing)YH( the DLL or client code, the + export header file sets the export and extern macros to their + appro)HY(pri)HY(ate)YH( values. Contin)HY(u)HY(ing)YH( with our person example, on Windows + the export header, which we will call )SM(person-export.hxx)ES(, + could look like this:)EP( + + ) 16 63 PR(// person-export.hxx +// +// Define PERSON_BUILD_DLL if we are building the DLL. Leave it +// undefined in client code. +// +#ifndef PERSON_EXPORT_HXX +#define PERSON_EXPORT_HXX + +#ifdef PERSON_BUILD_DLL +# define PERSON_EXPORT __declspec\201dllexport\202 +#else +# define PERSON_EXPORT __declspec\201dllimport\202 +# define PERSON_EXTERN extern +#endif + +#endif // PERSON_EXPORT_HXX)RP( + + )0 P(The equiv)HY(a)HY(lent)YH( export header for GCC on GNU/Linux is shown below. + Note also that on GNU/Linux, by default, all symbols are visible + and we need to add the GCC )SM(-fvis)HY(i)HY(bil)HY(ity)YH(=hidden)ES( option to + make them hidden by default.)EP( + + ) 9 62 PR(// person-export.hxx +// +#ifndef PERSON_EXPORT_HXX +#define PERSON_EXPORT_HXX + +#define PERSON_EXPORT __attribute__ \201\201visibility \201"default"\202\202\202 +#define PERSON_EXTERN extern + +#endif // PERSON_EXPORT_HXX)RP( + + )0 P(Next we need to export the )SM(person)ES( persis)HY(tent)YH( class + using the export macro and re-compile our )SM(person.hxx)ES( file + with the )SM(--export-symbol)ES( and )SM(--extern-symbol)ES( + options. We will also need to include )SM(person-export.hxx)ES( + into the gener)HY(ated)YH( )SM(person-odb.hxx)ES( file. For that we use + the )SM(--hxx-prologue)ES( option. Here is how we can do + this with multi)HY(ple)YH( invo)HY(ca)HY(tions)YH( of the ODB compiler:)EP( + + ) 5 74 PR(odb -m dynamic -d common --hxx-prologue "#include \200"person-export.hxx\200"" \200 +--export-symbol PERSON_EXPORT --extern-symbol PERSON_EXTERN person.hxx + +odb -m dynamic -d sqlite person.hxx +odb -m dynamic -d pgsql person.hxx)RP( + + )0 P(It is also possi)HY(ble)YH( to achieve the same with a single invo)HY(ca)HY(tion)YH(. + Here we need to restrict some option values to apply only to the + )SM(common)ES( database:)EP( + + ) 4 75 PR(odb -m dynamic -d common -d sqlite -d pgsql \200 +--hxx-prologue "common:#include \200"person-export.hxx\200"" \200 +--export-symbol common:PERSON_EXPORT --extern-symbol common:PERSON_EXTERN \200 +person.hxx)RP( + + )0 P(The second step in pack)HY(ag)HY(ing)YH( the gener)HY(ated)YH( code into DLLs is to + decide where to place the gener)HY(ated)YH( common inter)HY(face)YH( code. One + option is to place it into a DLL of its own so that we will end + up with \201replace )SM(*.dll)ES( with )SM(lib*.so)ES( for + Unix\202: )SM(person.dll)ES( plus )SM(person-sqlite.dll)ES( and + )SM(person-pgsql.dll)ES(, which both link to )SM(person.dll)ES(, + as well as )SM(person.exe)ES(, which links to )SM(person.dll)ES( + and dynam)HY(i)HY(cally)YH( loads )SM(person-sqlite.dll)ES( + and/or )SM(person-pgsql.dll)ES(. If this is the orga)HY(ni)HY(za)HY(tion)YH( + that you prefer, then the next step is to build all the DLLs as you + normally would any other DLL, placing )SM(person-odb.cxx)ES( + and )SM(person.cxx)ES( into )SM(person.dll)ES(, + )SM(person-odb-sqlite.cxx)ES( into )SM(person-sqlite.dll)ES(, + etc. Note that in the pure dynamic multi-database support, + )SM(person-sqlite.dll)ES( and )SM(person-pgsql.dll)ES( + do not export any symbols.)EP( + + )0 P(We can improve on the above orga)HY(ni)HY(za)HY(tion)YH( by getting rid of + )SM(person.dll)ES(, which is not really neces)HY(sary)YH( unless + we have multi)HY(ple)YH( executa)HY(bles)YH( sharing the same database support. + To achieve this, we will place )SM(person-odb.cxx)ES( into + )SM(person.exe)ES( and export its symbols from the executable + instead of a DLL. Export)HY(ing)YH( symbols from an executable is a seldom + used func)HY(tion)HY(al)HY(ity)YH(, espe)HY(cially)YH( on Windows, however, it is well + supported on both Windows and most Unix plat)HY(forms)YH(. Note also that + this approach won't work if we also use one of the databases in the + static mode.)EP( + + )0 P(On Windows all we have to do is place )SM(person-odb.cxx)ES( + into the executable and compile it as we would in a DLL \201that is, + with the )SM(PERSON_BUILD_DLL)ES( macro defined\202. If Windows + linker detects that an executable exports any symbols, then it + will auto)HY(mat)HY(i)HY(cally)YH( create the corre)HY(spond)HY(ing)YH( import library + \201)SM(person.lib)ES( in our case\202. We then use this import + library to build )SM(person-sqlite.dll)ES( and + )SM(person-pgsql.dll)ES( as before.)EP( + + )0 P(To export symbols from an executable on GNU/Linux all we need to + do is add the )SM(-rdynamic)ES( option when linking our + executable.)EP( + + + + + )WB NL NP( + )0 1 205 H(17)WB 530 Sn()WB 209 Sn( MySQL Database)EA()EH( + + )0 P(To gener)HY(ate)YH( support code for the MySQL database you will need + to pass the ")SM(--database\240mysql)ES(" + \201or ")SM(-d\240mysql)ES("\202 option to the ODB compiler. + Your appli)HY(ca)HY(tion)YH( will also need to link to the MySQL ODB runtime + library \201)SM(libodb-mysql)ES(\202. All MySQL-specific ODB + classes are defined in the )SM(odb::mysql)ES( names)HY(pace)YH(.)EP( + + )0 2 206 H(17.1)WB 531 Sn()WB 210 Sn( MySQL Type Mapping)EA()EH( + + )0 P(The follow)HY(ing)YH( table summa)HY(rizes)YH( the default mapping between basic + C++ value types and MySQL database types. This mapping can be + customized on the per-type and per-member basis using the ODB + Pragma Language \201)0 100 1 A(Chapter 14, "ODB Pragma + Language")100 0 TN TL()Ec /AF f D(\202.)EP( + + + )11 PT( + + )0 P(It is possi)HY(ble)YH( to map the )SM(char)ES( C++ type to an integer + database type \201for example, )SM(TINYINT)ES(\202 using the + )SM(db\240type)ES( pragma \201)0 150 1 A(Section 14.4.3, + ")SM(type)ES(")150 0 TN TL()Ec /AF f D(\202.)EP( + + )0 P(Note that the )SM(std::string)ES( type is mapped + differ)HY(ently)YH( depend)HY(ing)YH( on whether a member of this type + is an object id or not. If the member is an object id, + then for this member )SM(std::string)ES( is mapped + to the )SM(VARCHAR\201255\202)ES( MySQL type. Other)HY(wise)YH(, + it is mapped to )SM(TEXT)ES(.)EP( + + )0 P(Addi)HY(tion)HY(ally)YH(, by default, C++ enums and C++11 enum classes are + auto)HY(mat)HY(i)HY(cally)YH( mapped to suit)HY(able)YH( MySQL types. Contigu)HY(ous)YH( + enumer)HY(a)HY(tions)YH( with the zero first enumer)HY(a)HY(tor)YH( are mapped to + the MySQL )SM(ENUM)ES( type. All other enumer)HY(a)HY(tions)YH( + are mapped to the MySQL types corre)HY(spond)HY(ing)YH( to their + under)HY(ly)HY(ing)YH( inte)HY(gral)YH( types \201see table above\202. In both + cases the default )SM(NULL)ES( seman)HY(tics)YH( is + )SM(NOT NULL)ES(. For example:)EP( + + ) 17 68 PR(enum color {red, green, blue}; +enum class taste: unsigned char +{ + bitter = 1, // Non-zero first enumerator. + sweet, + sour = 4, // Non-contiguous. + salty +}; + +#pragma db object +class object +{ + ... + + color color_; // Mapped to ENUM \201'red', 'green', 'blue'\202 NOT NULL. + taste taste_; // Mapped to TINYNT UNSIGNED NOT NULL. +};)RP( + + )0 P(It is also possi)HY(ble)YH( to add support for addi)HY(tional)YH( MySQL types, + such as geospa)HY(tial)YH( types. For more infor)HY(ma)HY(tion)YH(, refer to + )0 192 1 A(Section 14.8, "Database Type Mapping + Pragmas")192 0 TN TL()Ec /AF f D(.)EP( + + )0 3 207 H(17.1.1)WB 532 Sn()WB 212 Sn( String Type Mapping)EA()EH( + + )0 P(The MySQL ODB runtime library provides support for mapping the + )SM(std::string)ES(, )SM(char[N])ES(, and + )SM(std::array)ES( types to the MySQL )SM(CHAR)ES(, + )SM(VARCHAR)ES(, )SM(TEXT)ES(, )SM(NCHAR)ES(, and + )SM(NVAR)HY(CHAR)YH()ES( types. However, these mappings are not enabled + by default \201in partic)HY(u)HY(lar)YH(, by default, )SM(std::array)ES( will + be treated as a container\202. To enable the alter)HY(na)HY(tive)YH( mappings for + these types we need to specify the database type explic)HY(itly)YH( using + the )SM(db\240type)ES( pragma \201)0 150 1 A(Section + 14.4.3, ")SM(type)ES(")150 0 TN TL()Ec /AF f D(\202, for example:)EP( + + ) 11 33 PR(#pragma db object +class object +{ + ... + + #pragma db type\201"CHAR\2012\202"\202 + char state_[2]; + + #pragma db type\201"VARCHAR\201128\202"\202 + std::string name_; +};)RP( + + )0 P(Alter)HY(na)HY(tively)YH(, this can be done on the per-type basis, for example:)EP( + + ) 9 50 PR(#pragma db value\201std::string\202 type\201"VARCHAR\201128\202"\202 + +#pragma db object +class object +{ + ... + + std::string name_; // Mapped to VARCHAR\201128\202. +};)RP( + + )0 P(The )SM(char[N])ES( and )SM(std::array)ES( values + may or may not be zero-termi)HY(nated)YH(. When extract)HY(ing)YH( such values from the + database, ODB will append the zero termi)HY(na)HY(tor)YH( if there is enough + space.)EP( + + )0 3 208 H(17.1.2)WB 533 Sn()WB 213 Sn( Binary Type Mapping)EA()EH( + + )0 P(The MySQL ODB runtime library provides support for mapping the + )SM(std::vector)ES(, + )SM(std::vector)ES(, + )SM(char[N])ES(, )SM(unsigned\240char[N])ES(, + )SM(std::array)ES(, and + )SM(std::array)ES( + types to the MySQL )SM(BINARY)ES(, )SM(VARBINARY)ES(, + and )SM(BLOB)ES( types. However, these mappings are not enabled + by default \201in partic)HY(u)HY(lar)YH(, by default, )SM(std::vector)ES( and + )SM(std::array)ES( will be treated as contain)HY(ers)YH(\202. To enable the + alter)HY(na)HY(tive)YH( mappings for these types we need to specify the database + type explic)HY(itly)YH( using the )SM(db\240type)ES( pragma + \201)0 150 1 A(Section 14.4.3, ")SM(type)ES(")150 0 TN TL()Ec /AF f D(\202, for + example:)EP( + + ) 11 31 PR(#pragma db object +class object +{ + ... + + #pragma db type\201"BLOB"\202 + std::vector buf_; + + #pragma db type\201"BINARY\20116\202"\202 + unsigned char uuid_[16]; +};)RP( + + )0 P(Alter)HY(na)HY(tively)YH(, this can be done on the per-type basis, for example:)EP( + + ) 10 37 PR(typedef std::vector buffer; +#pragma db value\201buffer\202 type\201"BLOB"\202 + +#pragma db object +class object +{ + ... + + buffer buf_; // Mapped to BLOB. +};)RP( + + )0 P(Note also that in native queries \201)0 38 1 A(Chapter 4, "Query)HY(ing)YH( + the Database")38 0 TN TL()Ec /AF f D(\202 )SM(char[N])ES( and + )SM(std::array)ES( param)HY(e)HY(ters)YH( are by default passed + as a string rather than a binary. To pass such param)HY(e)HY(ters)YH( as a binary, + we need to specify the database type explic)HY(itly)YH( in the + )SM(_val\201\202)ES(/)SM(_ref\201\202)ES( calls. Note also that we + don't need to do this for the inte)HY(grated)YH( queries, for example:)EP( + + ) 4 68 PR(char u[16] = {...}; + +db.query \201"uuid = " + query::_val \201u\202\202; +db.query \201query::uuid == query::_ref \201u\202\202;)RP( + + )0 2 209 H(17.2)WB 534 Sn()WB 214 Sn( MySQL Database Class)EA()EH( + + )0 P(The MySQL )SM(database)ES( class has the follow)HY(ing)YH( + inter)HY(face)YH(:)EP( + + ) 98 64 PR(namespace odb +{ + namespace mysql + { + class database: public odb::database + { + public: + database \201const char* user, + const char* passwd, + const char* db, + const char* host = 0, + unsigned int port = 0, + const char* socket = 0, + const char* charset = 0, + unsigned long client_flags = 0, + std::[auto|unique]_ptr = 0\202; + + database \201const std::string& user, + const std::string& passwd, + const std::string& db, + const std::string& host = "", + unsigned int port = 0, + const std::string* socket = 0, + const std::string& charset = "", + unsigned long client_flags = 0, + std::[auto|unique]_ptr = 0\202; + + database \201const std::string& user, + const std::string* passwd, + const std::string& db, + const std::string& host = "",)WR( + unsigned int port = 0, + const std::string* socket = 0, + const std::string& charset = "", + unsigned long client_flags = 0, + std::[auto|unique]_ptr = 0\202; + + database \201const std::string& user, + const std::string& passwd, + const std::string& db, + const std::string& host, + unsigned int port, + const std::string& socket, + const std::string& charset = "", + unsigned long client_flags = 0, + std::[auto|unique]_ptr = 0\202; + + database \201const std::string& user, + const std::string* passwd, + const std::string& db, + const std::string& host, + unsigned int port, + const std::string& socket, + const std::string& charset = "", + unsigned long client_flags = 0, + std::[auto|unique]_ptr = 0\202; + + database \201int& argc, + char* argv[], + bool erase = false, + const std::string& charset = "",)WR( + unsigned long client_flags = 0, + std::[auto|unique]_ptr = 0\202; + + static void + print_usage \201std::ostream&\202; + + public: + const char* + user \201\202 const; + + const char* + password \201\202 const; + + const char* + db \201\202 const; + + const char* + host \201\202 const; + + unsigned int + port \201\202 const; + + const char* + socket \201\202 const; + + const char* + charset \201\202 const; + + unsigned long + client_flags \201\202 const;)WR( + + public: + connection_ptr + connection \201\202; + }; + } +})RP( + + )0 P(You will need to include the )SM()ES( + header file to make this class avail)HY(able)YH( in your appli)HY(ca)HY(tion)YH(.)EP( + + )0 P(The over)HY(loaded)YH( )SM(database)ES( construc)HY(tors)YH( allow us + to specify MySQL database param)HY(e)HY(ters)YH( that should be used when + connect)HY(ing)YH( to the database. In MySQL )SM(NULL)ES( and an + empty string are treated as the same values for all the + string param)HY(e)HY(ters)YH( except )SM(pass)HY(word)YH()ES( and + )SM(socket)ES(.)EP( + + )0 P(The )SM(charset)ES( argu)HY(ment)YH( allows us to specify the client + char)HY(ac)HY(ter)YH( set, that is, the char)HY(ac)HY(ter)YH( set in which the appli)HY(ca)HY(tion)YH( + will encode its text data. Note that this can be differ)HY(ent)YH( from + the MySQL server char)HY(ac)HY(ter)YH( set. If this argu)HY(ment)YH( is not spec)HY(i)HY(fied)YH( or + is empty, then the default MySQL client char)HY(ac)HY(ter)YH( set is used, normally + )SM(latin1)ES(. Commonly used values for this argu)HY(ment)YH( are + )SM(latin1)ES( \201equiv)HY(a)HY(lent)YH( to Windows cp1252 and similar to + ISO-8859-1\202 and )SM(utf8)ES(. For other possi)HY(ble)YH( values + as well as more infor)HY(ma)HY(tion)YH( on char)HY(ac)HY(ter)YH( set support in MySQL, + refer to the MySQL docu)HY(men)HY(ta)HY(tion)YH(.)EP( + + )0 P(The )SM(client_flags)ES( argu)HY(ment)YH( allows us to specify various + MySQL client library flags. For more infor)HY(ma)HY(tion)YH( on the possi)HY(ble)YH( + values, refer to the MySQL C API docu)HY(men)HY(ta)HY(tion)YH(. The + )SM(CLIENT_FOUND_ROWS)ES( flag is always set by the MySQL ODB + runtime regard)HY(less)YH( of whether it was passed in the + )SM(client_flags)ES( argu)HY(ment)YH(.)EP( + + )0 P(The last construc)HY(tor)YH( extracts the database param)HY(e)HY(ters)YH( + from the command line. The follow)HY(ing)YH( options are recog)HY(nized)YH(:)EP( + + ) 7 23 PR( --user + --password + --database + --host + --port + --socket + --options-file )RP( + + )0 P(The )SM(--options-file)ES( option allows us to specify some + or all of the database options in a file with each option appear)HY(ing)YH( + on a sepa)HY(rate)YH( line followed by a space and an option value.)EP( + + )0 P(If the )SM(erase)ES( argu)HY(ment)YH( to this construc)HY(tor)YH( is true, + then the above options are removed from the )SM(argv)ES( + array and the )SM(argc)ES( count is updated accord)HY(ingly)YH(. + This is primar)HY(ily)YH( useful if your appli)HY(ca)HY(tion)YH( accepts other + options or argu)HY(ments)YH( and you would like to get the MySQL + options out of the )SM(argv)ES( array.)EP( + + )0 P(This construc)HY(tor)YH( throws the )SM(odb::mysql::cli_excep)HY(tion)YH()ES( + excep)HY(tion)YH( if the MySQL option values are missing or invalid. + See section )0 216 1 A(Section 17.4, "MySQL Excep)HY(tions)YH(")216 0 TN TL()Ec /AF f D( + for more infor)HY(ma)HY(tion)YH( on this excep)HY(tion)YH(.)EP( + + )0 P(The static )SM(print_usage\201\202)ES( func)HY(tion)YH( prints the list of options + with short descrip)HY(tions)YH( that are recog)HY(nized)YH( by this construc)HY(tor)YH(.)EP( + + )0 P(The last argu)HY(ment)YH( to all of the construc)HY(tors)YH( is a pointer to the + connec)HY(tion)YH( factory. In C++98/03, it is )SM(std::auto_ptr)ES( while + in C++11 )SM(std::unique_ptr)ES( is used instead. If we pass a + non-)SM(NULL)ES( value, the database instance assumes owner)HY(ship)YH( + of the factory instance. The connec)HY(tion)YH( factory inter)HY(face)YH( as well as + the avail)HY(able)YH( imple)HY(men)HY(ta)HY(tions)YH( are described in the next section.)EP( + + )0 P(The set of acces)HY(sor)YH( func)HY(tions)YH( follow)HY(ing)YH( the construc)HY(tors)YH( allows us + to query the param)HY(e)HY(ters)YH( of the )SM(database)ES( instance.)EP( + + )0 P(The )SM(connec)HY(tion)YH(\201\202)ES( func)HY(tion)YH( returns a pointer to the + MySQL database connec)HY(tion)YH( encap)HY(su)HY(lated)YH( by the + )SM(odb::mysql::connec)HY(tion)YH()ES( class. For more infor)HY(ma)HY(tion)YH( + on )SM(mysql::connec)HY(tion)YH()ES(, refer to )0 215 1 A(Section + 17.3, "MySQL Connec)HY(tion)YH( and Connec)HY(tion)YH( Factory")215 0 TN TL()Ec /AF f D(.)EP( + + )0 2 210 H(17.3)WB 535 Sn()WB 215 Sn( MySQL Connec)HY(tion)YH( and Connec)HY(tion)YH( Factory)EA()EH( + + )0 P(The )SM(mysql::connec)HY(tion)YH()ES( class has the follow)HY(ing)YH( inter)HY(face)YH(:)EP( + + ) 17 59 PR(namespace odb +{ + namespace mysql + { + class connection: public odb::connection + { + public: + connection \201database&\202; + connection \201database&, MYSQL*\202; + + MYSQL* + handle \201\202; + }; + + typedef details::shared_ptr connection_ptr; + } +})RP( + + )0 P(For more infor)HY(ma)HY(tion)YH( on the )SM(odb::connec)HY(tion)YH()ES( inter)HY(face)YH(, + refer to )0 29 1 A(Section 3.6, "Connec)HY(tions)YH(")29 0 TN TL()Ec /AF f D(. The first + over)HY(loaded)YH( )SM(mysql::connec)HY(tion)YH()ES( construc)HY(tor)YH( estab)HY(lishes)YH( a + new MySQL connec)HY(tion)YH(. The second construc)HY(tor)YH( allows us to create + a )SM(connec)HY(tion)YH()ES( instance by provid)HY(ing)YH( an already connected + native MySQL handle. Note that the )SM(connec)HY(tion)YH()ES( + instance assumes owner)HY(ship)YH( of this handle. The )SM(handle\201\202)ES( + acces)HY(sor)YH( returns the MySQL handle corre)HY(spond)HY(ing)YH( to the connec)HY(tion)YH(.)EP( + + )0 P(The )SM(mysql::connec)HY(tion)YH(_factory)ES( abstract class has the + follow)HY(ing)YH( inter)HY(face)YH(:)EP( + + ) 15 31 PR(namespace odb +{ + namespace mysql + { + class connection_factory + { + public: + virtual void + database \201database&\202 = 0; + + virtual connection_ptr + connect \201\202 = 0; + }; + } +})RP( + + )0 P(The )SM(database\201\202)ES( func)HY(tion)YH( is called when a connec)HY(tion)YH( + factory is asso)HY(ci)HY(ated)YH( with a database instance. This happens in + the )SM(odb::mysql::database)ES( class construc)HY(tors)YH(. The + )SM(connect\201\202)ES( func)HY(tion)YH( is called when)HY(ever)YH( a database + connec)HY(tion)YH( is requested.)EP( + + )0 P(The two imple)HY(men)HY(ta)HY(tions)YH( of the )SM(connec)HY(tion)YH(_factory)ES( + inter)HY(face)YH( provided by the MySQL ODB runtime are + )SM(new_connec)HY(tion)YH(_factory)ES( and + )SM(connec)HY(tion)YH(_pool_factory)ES(. You will need to include + the )SM()ES( + header file to make the )SM(connec)HY(tion)YH(_factory)ES( inter)HY(face)YH( + and these imple)HY(men)HY(ta)HY(tion)YH( classes avail)HY(able)YH( in your appli)HY(ca)HY(tion)YH(.)EP( + + )0 P(The )SM(new_connec)HY(tion)YH(_factory)ES( class creates a new + connec)HY(tion)YH( when)HY(ever)YH( one is requested. When a connec)HY(tion)YH( is no + longer needed, it is released and closed. The + )SM(new_connec)HY(tion)YH(_factory)ES( class has the follow)HY(ing)YH( + inter)HY(face)YH(:)EP( + + ) 10 59 PR(namespace odb +{ + namespace mysql + { + class new_connection_factory: public connection_factory + { + public: + new_connection_factory \201\202; + }; +};)RP( + + )0 P(The )SM(connec)HY(tion)YH(_pool_factory)ES( class imple)HY(ments)YH( a + connec)HY(tion)YH( pool. It has the follow)HY(ing)YH( inter)HY(face)YH(:)EP( + + ) 25 75 PR(namespace odb +{ + namespace mysql + { + class connection_pool_factory: public connection_factory + { + public: + connection_pool_factory \201std::size_t max_connections = 0, + std::size_t min_connections = 0, + bool ping = true\202; + + protected: + class pooled_connection: public connection + { + public: + pooled_connection \201database_type&\202; + pooled_connection \201database_type&, MYSQL*\202; + }; + + typedef details::shared_ptr pooled_connection_ptr; + + virtual pooled_connection_ptr + create \201\202; + }; +};)RP( + + )0 P(The )SM(max_connec)HY(tions)YH()ES( argu)HY(ment)YH( in the + )SM(connec)HY(tion)YH(_pool_factory)ES( construc)HY(tor)YH( spec)HY(i)HY(fies)YH( the maximum + number of concur)HY(rent)YH( connec)HY(tions)YH( that this pool factory will + main)HY(tain)YH(. Simi)HY(larly)YH(, the )SM(min_connec)HY(tions)YH()ES( argu)HY(ment)YH( + spec)HY(i)HY(fies)YH( the minimum number of avail)HY(able)YH( connec)HY(tions)YH( that + should be kept open. The )SM(ping)ES( argu)HY(ment)YH( spec)HY(i)HY(fies)YH( + whether the factory should vali)HY(date)YH( the connec)HY(tion)YH( before + return)HY(ing)YH( it to the caller.)EP( + + )0 P(When)HY(ever)YH( a connec)HY(tion)YH( is requested, the pool factory first + checks if there is an unused connec)HY(tion)YH( that can be returned. + If there is none, the pool factory checks the + )SM(max_connec)HY(tions)YH()ES( value to see if a new connec)HY(tion)YH( + can be created. If the total number of connec)HY(tions)YH( main)HY(tained)YH( + by the pool is less than this value, then a new connec)HY(tion)YH( is + created and returned. Other)HY(wise)YH(, the caller is blocked until + a connec)HY(tion)YH( becomes avail)HY(able)YH(.)EP( + + )0 P(When a connec)HY(tion)YH( is released, the pool factory first checks + if there are blocked callers waiting for a connec)HY(tion)YH(. If so, then + one of them is unblocked and is given the connec)HY(tion)YH(. Other)HY(wise)YH(, + the pool factory checks whether the total number of connec)HY(tions)YH( + main)HY(tained)YH( by the pool is greater than the )SM(min_connec)HY(tions)YH()ES( + value. If that's the case, the connec)HY(tion)YH( is closed. Other)HY(wise)YH(, the + connec)HY(tion)YH( is added to the pool of avail)HY(able)YH( connec)HY(tions)YH( to be + returned on the next request. In other words, if the number of + connec)HY(tions)YH( main)HY(tained)YH( by the pool exceeds )SM(min_connec)HY(tions)YH()ES( + and there are no callers waiting for a new connec)HY(tion)YH(, + then the pool will close the excess connec)HY(tions)YH(.)EP( + + )0 P(If the )SM(max_connec)HY(tions)YH()ES( value is 0, then the pool will + create a new connec)HY(tion)YH( when)HY(ever)YH( all of the exist)HY(ing)YH( connec)HY(tions)YH( + are in use. If the )SM(min_connec)HY(tions)YH()ES( value is 0, then + the pool will never close a connec)HY(tion)YH( and instead main)HY(tain)YH( all + the connec)HY(tions)YH( that were ever created.)EP( + + )0 P(Connec)HY(tion)YH( vali)HY(da)HY(tion)YH( \201the )SM(ping)ES( argu)HY(ment)YH(\202 is useful + if your appli)HY(ca)HY(tion)YH( may expe)HY(ri)HY(ence)YH( long periods of inac)HY(tiv)HY(ity)YH(. In + such cases the MySQL server may close network connec)HY(tions)YH( that have + been inac)HY(tive)YH( for too long. If during connec)HY(tion)YH( vali)HY(da)HY(tion)YH( the pool + factory detects that the connec)HY(tion)YH( has been termi)HY(nated)YH(, it silently + closes it and tries to find or create another connec)HY(tion)YH( instead.)EP( + + )0 P(The )SM(create\201\202)ES( virtual func)HY(tion)YH( is called when)HY(ever)YH( the + pool needs to create a new connec)HY(tion)YH(. By deriv)HY(ing)YH( from the + )SM(connec)HY(tion)YH(_pool_factory)ES( class and over)HY(rid)HY(ing)YH( this + func)HY(tion)YH( we can imple)HY(ment)YH( custom connec)HY(tion)YH( estab)HY(lish)HY(ment)YH( + and config)HY(u)HY(ra)HY(tion)YH(.)EP( + + )0 P(If you pass )SM(NULL)ES( as the connec)HY(tion)YH( factory to + one of the )SM(database)ES( construc)HY(tors)YH(, then the + )SM(connec)HY(tion)YH(_pool_factory)ES( instance will be + created by default with the min and max connec)HY(tions)YH( values + set to )SM(0)ES( and connec)HY(tion)YH( vali)HY(da)HY(tion)YH( enabled. + The follow)HY(ing)YH( code frag)HY(ment)YH( shows how we can pass our own + connec)HY(tion)YH( factory instance:)EP( + + ) 14 51 PR(#include + +#include +#include + +int +main \201int argc, char* argv[]\202 +{ + auto_ptr f \201 + new odb::mysql::connection_pool_factory \20120\202\202; + + auto_ptr db \201 + new mysql::database \201argc, argv, false, 0, f\202\202; +})RP( + + )0 2 211 H(17.4)WB 536 Sn()WB 216 Sn( MySQL Excep)HY(tions)YH()EA()EH( + + )0 P(The MySQL ODB runtime library defines the follow)HY(ing)YH( MySQL-specific + excep)HY(tions)YH(:)EP( + + ) 28 53 PR(namespace odb +{ + namespace mysql + { + class database_exception: odb::database_exception + { + public: + unsigned int + error \201\202 const; + + const std::string& + sqlstate \201\202 const; + + const std::string& + message \201\202 const; + + virtual const char* + what \201\202 const throw \201\202; + }; + + class cli_exception: odb::exception + { + public: + virtual const char* + what \201\202 const throw \201\202; + }; + } +})RP( + + )0 P(You will need to include the )SM()ES( + header file to make these excep)HY(tions)YH( avail)HY(able)YH( in your appli)HY(ca)HY(tion)YH(.)EP( + + )0 P(The )SM(odb::mysql::database_excep)HY(tion)YH()ES( is thrown if + a MySQL database oper)HY(a)HY(tion)YH( fails. The MySQL-specific error + infor)HY(ma)HY(tion)YH( is acces)HY(si)HY(ble)YH( via the )SM(error\201\202)ES(, + )SM(sqlstate\201\202)ES(, and )SM(message\201\202)ES( func)HY(tions)YH(. + All this infor)HY(ma)HY(tion)YH( is also combined and returned in a + human-read)HY(able)YH( form by the )SM(what\201\202)ES( func)HY(tion)YH(.)EP( + + )0 P(The )SM(odb::mysql::cli_excep)HY(tion)YH()ES( is thrown by the + command line parsing construc)HY(tor)YH( of the )SM(odb::mysql::database)ES( + class if the MySQL option values are missing or invalid. The + )SM(what\201\202)ES( func)HY(tion)YH( returns a human-read)HY(able)YH( descrip)HY(tion)YH( + of an error.)EP( + + )0 2 212 H(17.5)WB 537 Sn()WB 217 Sn( MySQL Limi)HY(ta)HY(tions)YH()EA()EH( + + )0 P(The follow)HY(ing)YH( sections describe MySQL-specific limi)HY(ta)HY(tions)YH( imposed + by the current MySQL and ODB runtime versions.)EP( + + )0 3 213 H(17.5.1)WB 538 Sn()WB 218 Sn( Foreign Key Constraints)EA()EH( + + )0 P(ODB relies on stan)HY(dard)YH( SQL behav)HY(ior)YH( which requires that foreign + key constraints check)HY(ing)YH( is deferred until the trans)HY(ac)HY(tion)YH( is + commit)HY(ted)YH(. The only behav)HY(iors)YH( supported by MySQL are to either + check such constraints imme)HY(di)HY(ately)YH( \201InnoDB engine\202 or to ignore + foreign key constraints alto)HY(gether)YH( \201all other engines\202. As a + result, by default, schemas gener)HY(ated)YH( by the ODB compiler for + MySQL have foreign key defi)HY(ni)HY(tions)YH( commented out. They are + retained only for docu)HY(men)HY(ta)HY(tion)YH(.)EP( + + )0 P(You can over)HY(ride)YH( the default behav)HY(ior)YH( and instruct the ODB + compiler to gener)HY(ate)YH( non-deferrable foreign keys by spec)HY(i)HY(fy)HY(ing)YH( + the )SM(--fkeys-deferrable-mode not_deferrable)ES( ODB + compiler option. Note, however, that in this case the order in + which you persist, update, and erase objects within a trans)HY(ac)HY(tion)YH( + becomes impor)HY(tant)YH(.)EP( + + )0 2 214 H(17.6)WB 539 Sn()WB 219 Sn( MySQL Index Defi)HY(ni)HY(tions)YH()EA()EH( + + )0 P(When the )SM(index)ES( pragma \201)0 191 1 A(Section 14.7, + "Index Defi)HY(ni)HY(tion)YH( Pragmas")191 0 TN TL()Ec /AF f D(\202 is used to define a MySQL index, + the )SM(type)ES( clause spec)HY(i)HY(fies)YH( the index type \201for example, + )SM(UNIQUE)ES(, )SM(FULL)HY(TEXT)YH()ES(, )SM(SPATIAL)ES(\202, + the )SM(method)ES( clause spec)HY(i)HY(fies)YH( the index method \201for + example, )SM(BTREE)ES(, )SM(HASH)ES(\202, and the + )SM(options)ES( clause is not used. The column options + can be used to specify column length limits and the sort order. + For example:)EP( + + ) 9 61 PR(#pragma db object +class object +{ + ... + + std::string name_; + + #pragma db index method\201"HASH"\202 member\201name_, "\201100\202 DESC"\202 +};)RP( + + )0 2 215 H(17.7)WB 540 Sn()WB 220 Sn( MySQL Stored Proce)HY(dures)YH()EA()EH( + + )0 P(ODB native views \201)0 85 1 A(Section 10.6, "Native Views")85 0 TN TL()Ec /AF f D(\202 + can be used to call MySQL stored proce)HY(dures)YH(. For example, assum)HY(ing)YH( + we are using the )SM(person)ES( class from )0 11 1 A(Chapter + 2, "Hello World Example")11 0 TN TL()Ec /AF f D( \201and the corre)HY(spond)HY(ing)YH( )SM(person)ES( + table\202, we can create a stored proce)HY(dure)YH( that given the min and max + ages returns some infor)HY(ma)HY(tion)YH( about all the people in that range:)EP( + + ) 7 44 PR(CREATE PROCEDURE person_range \201 + IN min_age SMALLINT, + IN max_age SMALLINT\202 +BEGIN + SELECT age, first, last FROM person + WHERE age >= min_age AND age <= max_age; +END)RP( + + )0 P(Given the above stored proce)HY(dure)YH( we can then define an ODB view + that can be used to call it and retrieve its result:)EP( + + ) 7 47 PR(#pragma db view query\201"CALL person_range\201\201?\202\202"\202 +struct person_range +{ + unsigned short age; + std::string first; + std::string last; +};)RP( + + )0 P(The follow)HY(ing)YH( example shows how we can use the above view to + print the list of people in a specific age range:)EP( + + ) 13 62 PR(typedef odb::query query; +typedef odb::result result; + +transaction t \201db.begin \201\202\202; + +result r \201 + db.query \201 + query::_val \2011\202 + "," + query::_val \20118\202\202\202; + +for \201result::iterator i \201r.begin \201\202\202; i != r.end \201\202; ++i\202 + cerr << i->first << " " << i->last << " " << i->age << endl; + +t.commit \201\202;)RP( + + )0 P(Note that as with all native views, the order and types of data members + must match those of columns in the )SM(SELECT)ES( list inside + the stored proce)HY(dure)YH(.)EP( + + )0 P(There are also a number of limi)HY(ta)HY(tions)YH( when it comes to support for + MySQL stored proce)HY(dures)YH( in ODB views. First of all, you have to use + MySQL server and client libraries version 5.5.3 or later since this + is the version in which support for calling stored proce)HY(dures)YH( with + prepared state)HY(ments)YH( was first added \201the + )SM(mysql_stmt_next_result\201\202)ES( func)HY(tion)YH(\202.)EP( + + )0 P(In MySQL, a stored proce)HY(dure)YH( can produce multi)HY(ple)YH( results. + For example, if a stored proce)HY(dure)YH( executes several + )SM(SELECT)ES( state)HY(ments)YH(, then the result of calling such + a proce)HY(dure)YH( consists of two row sets, one for each )SM(SELECT)ES( + state)HY(ment)YH(. Addi)HY(tion)HY(ally)YH(, if the proce)HY(dure)YH( has any )SM(OUT)ES( + or )SM(INOUT)ES( param)HY(e)HY(ters)YH(, then their values are returned as + an addi)HY(tional)YH( special row set contain)HY(ing)YH( only a single row. + Because such multi)HY(ple)YH( row sets can contain varying number + and type of columns, they cannot be all extracted into a + single view. As a result, an ODB view will only extract the + data from the first row set and ignore all the subse)HY(quent)YH( + ones.)EP( + + )0 P(In partic)HY(u)HY(lar)YH(, this means that we can use an ODB view to extract + the values of the )SM(OUT)ES( and )SM(INOUT)ES( + param)HY(e)HY(ters)YH( provided that the stored proce)HY(dure)YH( does not gener)HY(ate)YH( + any other row sets. For example:)EP( + + ) 6 62 PR(CREATE PROCEDURE person_min_max_age \201 + OUT min_age SMALLINT, + OUT max_age SMALLINT\202 +BEGIN + SELECT MIN\201age\202, MAX\201age\202 INTO min_age, max_age FROM person; +END)RP( + + ) 6 53 PR(#pragma db view query\201"CALL person_min_max_age\201\201?\202\202"\202 +struct person_min_max_age +{ + unsigned short min_age; + unsigned short max_age; +};)RP( + + ) 14 72 PR(typedef odb::query query; + +transaction t \201db.begin \201\202\202; + +// We know this query always returns a single row, so use query_value\201\202. +// We have to pass dummy values for OUT parameters. +// +person_min_max_age mma \201 + db.query_value \201 + query::_val \2010\202 + "," + query::_val \2010\202\202\202; + +cerr << mma.min_age << " " << mma.max_age << endl; + +t.commit \201\202;)RP( + + )0 P(Another limi)HY(ta)HY(tion)YH( that stems from having multi)HY(ple)YH( results is the + inabil)HY(ity)YH( to cache the result of a stored proce)HY(dure)YH( call. In + other words, a MySQL stored proce)HY(dure)YH( call always produces an + uncached query result \201)0 43 1 A(Section 4.4, "Query + Result")43 0 TN TL()Ec /AF f D(\202.)EP( + + )WB NL NP( + )0 1 216 H(18)WB 541 Sn()WB 221 Sn( SQLite Database)EA()EH( + + )0 P(To gener)HY(ate)YH( support code for the SQLite database you will need + to pass the ")SM(--database\240sqlite)ES(" + \201or ")SM(-d\240sqlite)ES("\202 option to the ODB compiler. + Your appli)HY(ca)HY(tion)YH( will also need to link to the SQLite ODB runtime + library \201)SM(libodb-sqlite)ES(\202. All SQLite-specific ODB + classes are defined in the )SM(odb::sqlite)ES( names)HY(pace)YH(.)EP( + + )0 2 217 H(18.1)WB 542 Sn()WB 222 Sn( SQLite Type Mapping)EA()EH( + + )0 P(The follow)HY(ing)YH( table summa)HY(rizes)YH( the default mapping between basic + C++ value types and SQLite database types. This mapping can be + customized on the per-type and per-member basis using the ODB + Pragma Language \201)0 100 1 A(Chapter 14, "ODB Pragma + Language")100 0 TN TL()Ec /AF f D(\202.)EP( + + + )12 PT( + + )0 P(It is possi)HY(ble)YH( to map the )SM(char)ES( C++ type to the + )SM(INTEGER)ES( SQLite type using the )SM(db\240type)ES( + pragma \201)0 150 1 A(Section 14.4.3, ")SM(type)ES(")150 0 TN TL()Ec /AF f D(\202.)EP( + + )0 P(SQLite repre)HY(sents)YH( the )SM(NaN)ES( )SM(FLOAT)ES( value + as a )SM(NULL)ES( value. As a result, columns of the + )SM(float)ES( and )SM(double)ES( types are by default + declared as )SM(NULL)ES(. However, you can over)HY(ride)YH( this by + explic)HY(itly)YH( declar)HY(ing)YH( them as )SM(NOT NULL)ES( with the + )SM(db\240not_null)ES( pragma \201)0 153 1 A(Section + 14.4.6, ")SM(null/not_null)ES(")153 0 TN TL()Ec /AF f D(\202.)EP( + + )0 P(Addi)HY(tion)HY(ally)YH(, by default, C++ enums and C++11 enum classes are + auto)HY(mat)HY(i)HY(cally)YH( mapped to the SQLite )SM(INTEGER)ES( type with + the default )SM(NULL)ES( seman)HY(tics)YH( being )SM(NOT NULL)ES(. + For example:)EP( + + ) 17 51 PR(enum color {red, green, blue}; +enum class taste: unsigned char +{ + bitter = 1, + sweet, + sour = 4, + salty +}; + +#pragma db object +class object +{ + ... + + color color_; // Automatically mapped to INTEGER. + taste taste_; // Automatically mapped to INTEGER. +};)RP( + + )0 P(Note also that SQLite only oper)HY(ates)YH( with signed inte)HY(gers)YH( and the largest + value that an SQLite database can store is a signed 64-bit integer. As + a result, greater )SM(unsigned\240long)ES( and + )SM(unsigned\240long\240long)ES( values will be repre)HY(sented)YH( in + the database as nega)HY(tive)YH( values.)EP( + + )0 P(It is also possi)HY(ble)YH( to add support for addi)HY(tional)YH( SQLite types, + such as )SM(NUMERIC)ES(. For more infor)HY(ma)HY(tion)YH(, refer to + )0 192 1 A(Section 14.8, "Database Type Mapping + Pragmas")192 0 TN TL()Ec /AF f D(.)EP( + + )0 3 218 H(18.1.1)WB 543 Sn()WB 223 Sn( String Type Mapping)EA()EH( + + )0 P(The SQLite ODB runtime library provides support for mapping the + )SM(std::array)ES( and, on Windows, + )SM(std::array)ES( types to the SQLite + )SM(TEXT)ES( type. However, this mapping is not enabled by + default \201in partic)HY(u)HY(lar)YH(, by default, )SM(std::array)ES( will + be treated as a container\202. To enable the alter)HY(na)HY(tive)YH( mapping for + this type we need to specify the database type explic)HY(itly)YH( using + the )SM(db\240type)ES( pragma \201)0 150 1 A(Section + 14.4.3, ")SM(type)ES(")150 0 TN TL()Ec /AF f D(\202, for example:)EP( + + ) 8 30 PR(#pragma db object +class object +{ + ... + + #pragma db type\201"TEXT"\202 + std::array name_; +};)RP( + + )0 P(Alter)HY(na)HY(tively)YH(, this can be done on the per-type basis, for example:)EP( + + ) 10 40 PR(typedef std::array name_type; +#pragma db value\201name_type\202 type\201"TEXT"\202 + +#pragma db object +class object +{ + ... + + name_type name_; // Mapped to TEXT. +};)RP( + + )0 P(The )SM(char[N])ES(, )SM(std::array)ES(, + )SM(wchar_t[N])ES(, and )SM(std::array)ES( + values may or may not be zero-termi)HY(nated)YH(. When extract)HY(ing)YH( such values + from the database, ODB will append the zero termi)HY(na)HY(tor)YH( if there is + enough space.)EP( + + )0 3 219 H(18.1.2)WB 544 Sn()WB 224 Sn( Binary Type Mapping)EA()EH( + + )0 P(The SQLite ODB runtime library provides support for mapping the + )SM(std::vector)ES(, + )SM(std::vector)ES(, + )SM(char[N])ES(, )SM(unsigned\240char[N])ES(, + )SM(std::array)ES(, and + )SM(std::array)ES( + types to the SQLite )SM(BLOB)ES( type. However, these mappings + are not enabled by default \201in partic)HY(u)HY(lar)YH(, by default, + )SM(std::vector)ES( and )SM(std::array)ES( will be treated + as contain)HY(ers)YH(\202. To enable the alter)HY(na)HY(tive)YH( mappings for these types + we need to specify the database type explic)HY(itly)YH( using the + )SM(db\240type)ES( pragma \201)0 150 1 A(Section 14.4.3, + ")SM(type)ES(")150 0 TN TL()Ec /AF f D(\202, for example:)EP( + + ) 11 26 PR(#pragma db object +class object +{ + ... + + #pragma db type\201"BLOB"\202 + std::vector buf_; + + #pragma db type\201"BLOB"\202 + unsigned char uuid_[16]; +};)RP( + + )0 P(Alter)HY(na)HY(tively)YH(, this can be done on the per-type basis, for example:)EP( + + ) 10 37 PR(typedef std::vector buffer; +#pragma db value\201buffer\202 type\201"BLOB"\202 + +#pragma db object +class object +{ + ... + + buffer buf_; // Mapped to BLOB. +};)RP( + + )0 P(Note also that in native queries \201)0 38 1 A(Chapter 4, "Query)HY(ing)YH( + the Database")38 0 TN TL()Ec /AF f D(\202 )SM(char[N])ES( and + )SM(std::array)ES( param)HY(e)HY(ters)YH( are by default passed + as a string rather than a binary. To pass such param)HY(e)HY(ters)YH( as a binary, + we need to specify the database type explic)HY(itly)YH( in the + )SM(_val\201\202)ES(/)SM(_ref\201\202)ES( calls. Note also that we + don't need to do this for the inte)HY(grated)YH( queries, for example:)EP( + + ) 4 69 PR(char u[16] = {...}; + +db.query \201"uuid = " + query::_val \201u\202\202; +db.query \201query::uuid == query::_ref \201u\202\202;)RP( + + )0 2 220 H(18.2)WB 545 Sn()WB 225 Sn( SQLite Database Class)EA()EH( + + )0 P(The SQLite )SM(database)ES( class has the follow)HY(ing)YH( + inter)HY(face)YH(:)EP( + + ) 52 64 PR(namespace odb +{ + namespace sqlite + { + class database: public odb::database + { + public: + database \201const std::string& name, + int flags = SQLITE_OPEN_READWRITE, + bool foreign_keys = true, + const std::string& vfs = "", + std::[auto|unique]_ptr = 0\202; + +#ifdef _WIN32 + database \201const std::wstring& name, + int flags = SQLITE_OPEN_READWRITE, + bool foreign_keys = true, + const std::string& vfs = "", + std::[auto|unique]_ptr = 0\202; +#endif + + database \201int& argc, + char* argv[], + bool erase = false, + int flags = SQLITE_OPEN_READWRITE, + bool foreign_keys = true, + const std::string& vfs = "", + std::[auto|unique]_ptr = 0\202; + + static void + print_usage \201std::ostream&\202;)WR( + + public: + const std::string& + name \201\202 const; + + int + flags \201\202 const; + + public: + transaction + begin_immediate \201\202; + + transaction + begin_exclusive \201\202; + + public: + connection_ptr + connection \201\202; + }; + } +})RP( + + )0 P(You will need to include the )SM()ES( + header file to make this class avail)HY(able)YH( in your appli)HY(ca)HY(tion)YH(.)EP( + + )0 P(The first construc)HY(tor)YH( opens the spec)HY(i)HY(fied)YH( SQLite database. The + )SM(name)ES( argu)HY(ment)YH( is the database file name to open in + the UTF-8 encod)HY(ing)YH(. If this argu)HY(ment)YH( is empty, then a tempo)HY(rary)YH(, + on-disk database is created. If this argu)HY(ment)YH( is the + )SM(:memory:)ES( special value, then a tempo)HY(rary)YH(, in-memory + database is created. The )SM(flags)ES( argu)HY(ment)YH( allows us to + specify SQLite opening flags. For more infor)HY(ma)HY(tion)YH( on the possi)HY(ble)YH( + values, refer to the )SM(sqlite3_open_v2\201\202)ES( func)HY(tion)YH( descrip)HY(tion)YH( + in the SQLite C API docu)HY(men)HY(ta)HY(tion)YH(. The )SM(foreign_keys)ES( + argu)HY(ment)YH( spec)HY(i)HY(fies)YH( whether foreign key constraints check)HY(ing)YH( + should be enabled. See )0 231 1 A(Section 18.5.3, + "Foreign Key Constraints")231 0 TN TL()Ec /AF f D( for more infor)HY(ma)HY(tion)YH( on foreign + keys. The )SM(vfs)ES( argu)HY(ment)YH( spec)HY(i)HY(fies)YH( the SQLite + virtual file system module that should be used to access the + database. If this argu)HY(ment)YH( is empty, then the default vfs module + is used. Again, refer to the )SM(sqlite3_open_v2\201\202)ES( func)HY(tion)YH( + docu)HY(men)HY(ta)HY(tion)YH( for detail.)EP( + + )0 P(The follow)HY(ing)YH( example shows how we can open the )SM(test.db)ES( + database in the read-write mode and create it if it does not exist:)EP( + + ) 4 49 PR(auto_ptr db \201 + new odb::sqlite::database \201 + "test.db", + SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE\202\202;)RP( + + )0 P(The second construc)HY(tor)YH( is the same as the first except that the database + name is passes as )SM(std::wstring)ES( in the UTF-16 encod)HY(ing)YH(. This + construc)HY(tor)YH( is only avail)HY(able)YH( when compil)HY(ing)YH( for Windows.)EP( + + )0 P(The third construc)HY(tor)YH( extracts the database param)HY(e)HY(ters)YH( from the + command line. The follow)HY(ing)YH( options are recog)HY(nized)YH(:)EP( + + ) 4 23 PR( --database + --create + --read-only + --options-file )RP( + + )0 P(By default, this construc)HY(tor)YH( opens the database in the read-write mode + \201)SM(SQLITE_OPEN_READ)HY(WRITE)YH()ES( flag\202. If the )SM(--create)ES( + flag is spec)HY(i)HY(fied)YH(, then the database file is created if it does + not already exist \201)SM(SQLITE_OPEN_CREATE)ES( flag\202. If the + )SM(--read-only)ES( flag is spec)HY(i)HY(fied)YH(, then the database is + opened in the read-only mode \201)SM(SQLITE_OPEN_READ)HY(ONLY)YH()ES( + flag instead of )SM(SQLITE_OPEN_READ)HY(WRITE)YH()ES(\202. The + )SM(--options-file)ES( option allows us to specify some + or all of the database options in a file with each option appear)HY(ing)YH( + on a sepa)HY(rate)YH( line followed by a space and an option value.)EP( + + )0 P(If the )SM(erase)ES( argu)HY(ment)YH( to this construc)HY(tor)YH( is true, + then the above options are removed from the )SM(argv)ES( + array and the )SM(argc)ES( count is updated accord)HY(ingly)YH(. + This is primar)HY(ily)YH( useful if your appli)HY(ca)HY(tion)YH( accepts other + options or argu)HY(ments)YH( and you would like to get the SQLite + options out of the )SM(argv)ES( array.)EP( + + )0 P(The )SM(flags)ES( argu)HY(ment)YH( has the same seman)HY(tics)YH( as in + the first construc)HY(tor)YH(. Flags from the command line always over)HY(ride)YH( + the corre)HY(spond)HY(ing)YH( values spec)HY(i)HY(fied)YH( with this argu)HY(ment)YH(.)EP( + + )0 P(The third construc)HY(tor)YH( throws the )SM(odb::sqlite::cli_excep)HY(tion)YH()ES( + excep)HY(tion)YH( if the SQLite option values are missing or invalid. + See )0 227 1 A(Section 18.4, "SQLite Excep)HY(tions)YH(")227 0 TN TL()Ec /AF f D( + for more infor)HY(ma)HY(tion)YH( on this excep)HY(tion)YH(.)EP( + + )0 P(The static )SM(print_usage\201\202)ES( func)HY(tion)YH( prints the list of options + with short descrip)HY(tions)YH( that are recog)HY(nized)YH( by the third construc)HY(tor)YH(.)EP( + + )0 P(The last argu)HY(ment)YH( to all of the construc)HY(tors)YH( is a pointer to the + connec)HY(tion)YH( factory. In C++98/03, it is )SM(std::auto_ptr)ES( while + in C++11 )SM(std::unique_ptr)ES( is used instead. If we pass a + non-)SM(NULL)ES( value, the database instance assumes owner)HY(ship)YH( + of the factory instance. The connec)HY(tion)YH( factory inter)HY(face)YH( as well as + the avail)HY(able)YH( imple)HY(men)HY(ta)HY(tions)YH( are described in the next section.)EP( + + )0 P(The set of acces)HY(sor)YH( func)HY(tions)YH( follow)HY(ing)YH( the construc)HY(tors)YH( allows us + to query the param)HY(e)HY(ters)YH( of the )SM(database)ES( instance.)EP( + + )0 P(The )SM(begin_imme)HY(di)HY(ate)YH(\201\202)ES( and )SM(begin_exclu)HY(sive)YH(\201\202)ES( + func)HY(tions)YH( are the SQLite-specific exten)HY(sions)YH( to the stan)HY(dard)YH( + )SM(odb::database::begin\201\202)ES( func)HY(tion)YH( \201see + )0 28 1 A(Section 3.5, "Trans)HY(ac)HY(tions)YH(")28 0 TN TL()Ec /AF f D(\202. They allow us + to start an imme)HY(di)HY(ate)YH( \201)SM(BEGIN IMME)HY(DI)HY(ATE)YH()ES(\202 and an exclu)HY(sive)YH( + \201)SM(BEGIN EXCLU)HY(SIVE)YH()ES(\202 SQLite trans)HY(ac)HY(tion)YH(, respec)HY(tively)YH(. + For more infor)HY(ma)HY(tion)YH( on the seman)HY(tics)YH( of the imme)HY(di)HY(ate)YH( and exclu)HY(sive)YH( + trans)HY(ac)HY(tions)YH(, refer to the )SM(BEGIN)ES( state)HY(ment)YH( descrip)HY(tion)YH( + in the SQLite docu)HY(men)HY(ta)HY(tion)YH(.)EP( + + )0 P(The )SM(connec)HY(tion)YH(\201\202)ES( func)HY(tion)YH( returns a pointer to the + SQLite database connec)HY(tion)YH( encap)HY(su)HY(lated)YH( by the + )SM(odb::sqlite::connec)HY(tion)YH()ES( class. For more infor)HY(ma)HY(tion)YH( + on )SM(sqlite::connec)HY(tion)YH()ES(, refer to )0 226 1 A(Section + 18.3, "SQLite Connec)HY(tion)YH( and Connec)HY(tion)YH( Factory")226 0 TN TL()Ec /AF f D(.)EP( + + )0 2 221 H(18.3)WB 546 Sn()WB 226 Sn( SQLite Connec)HY(tion)YH( and Connec)HY(tion)YH( Factory)EA()EH( + + )0 P(The )SM(sqlite::connec)HY(tion)YH()ES( class has the follow)HY(ing)YH( inter)HY(face)YH(:)EP( + + ) 23 59 PR(namespace odb +{ + namespace sqlite + { + class connection: public odb::connection + { + public: + connection \201database&, int extra_flags = 0\202; + connection \201database&, sqlite3*\202; + + transaction + begin_immediate \201\202; + + transaction + begin_exclusive \201\202; + + sqlite3* + handle \201\202; + }; + + typedef details::shared_ptr connection_ptr; + } +})RP( + + )0 P(For more infor)HY(ma)HY(tion)YH( on the )SM(odb::connec)HY(tion)YH()ES( inter)HY(face)YH(, + refer to )0 29 1 A(Section 3.6, "Connec)HY(tions)YH(")29 0 TN TL()Ec /AF f D(. The first + over)HY(loaded)YH( )SM(sqlite::connec)HY(tion)YH()ES( construc)HY(tor)YH( opens + a new SQLite connec)HY(tion)YH(. The )SM(extra_flags)ES( argu)HY(ment)YH( can + be used to specify extra )SM(sqlite3_open_v2\201\202)ES( flags + that are combined with the flags spec)HY(i)HY(fied)YH( in the + )SM(sqlite::database)ES( construc)HY(tor)YH(. The second construc)HY(tor)YH( + allows us to create a )SM(connec)HY(tion)YH()ES( instance by provid)HY(ing)YH( + an already open native SQLite handle. Note that the + )SM(connec)HY(tion)YH()ES( instance assumes owner)HY(ship)YH( of this handle.)EP( + + )0 P(The )SM(begin_imme)HY(di)HY(ate)YH(\201\202)ES( and )SM(begin_exclu)HY(sive)YH(\201\202)ES( + func)HY(tions)YH( allow us to start an imme)HY(di)HY(ate)YH( and an exclu)HY(sive)YH( SQLite + trans)HY(ac)HY(tion)YH( on the connec)HY(tion)YH(, respec)HY(tively)YH(. Their seman)HY(tics)YH( are + equiv)HY(a)HY(lent)YH( to the corre)HY(spond)HY(ing)YH( func)HY(tions)YH( defined in the + )SM(sqlite::database)ES( class \201)0 225 1 A(Section 18.2, + "SQLite Database Class")225 0 TN TL()Ec /AF f D(\202. The )SM(handle\201\202)ES( acces)HY(sor)YH( + returns the SQLite handle corre)HY(spond)HY(ing)YH( to the connec)HY(tion)YH(.)EP( + + )0 P(The )SM(sqlite::connec)HY(tion)YH(_factory)ES( abstract class has the + follow)HY(ing)YH( inter)HY(face)YH(:)EP( + + ) 15 31 PR(namespace odb +{ + namespace sqlite + { + class connection_factory + { + public: + virtual void + database \201database&\202 = 0; + + virtual connection_ptr + connect \201\202 = 0; + }; + } +})RP( + + )0 P(The )SM(database\201\202)ES( func)HY(tion)YH( is called when a connec)HY(tion)YH( + factory is asso)HY(ci)HY(ated)YH( with a database instance. This happens in + the )SM(odb::sqlite::database)ES( class construc)HY(tors)YH(. The + )SM(connect\201\202)ES( func)HY(tion)YH( is called when)HY(ever)YH( a database + connec)HY(tion)YH( is requested.)EP( + + )0 P(The three imple)HY(men)HY(ta)HY(tions)YH( of the )SM(connec)HY(tion)YH(_factory)ES( + inter)HY(face)YH( provided by the SQLite ODB runtime library are + )SM(single_connec)HY(tion)YH(_factory)ES(, + )SM(new_connec)HY(tion)YH(_factory)ES(, and + )SM(connec)HY(tion)YH(_pool_factory)ES(. You will need to include + the )SM()ES( + header file to make the )SM(connec)HY(tion)YH(_factory)ES( inter)HY(face)YH( + and these imple)HY(men)HY(ta)HY(tion)YH( classes avail)HY(able)YH( in your appli)HY(ca)HY(tion)YH(.)EP( + + )0 P(The )SM(single_connec)HY(tion)YH(_factory)ES( class creates a + single connec)HY(tion)YH( that is shared between all the threads in + an appli)HY(ca)HY(tion)YH(. If the connec)HY(tion)YH( is currently not in use, + then it is returned to the caller. Other)HY(wise)YH(, the caller is + blocked until the connec)HY(tion)YH( becomes avail)HY(able)YH(. The + )SM(single_connec)HY(tion)YH(_factory)ES( class has the follow)HY(ing)YH( + inter)HY(face)YH(:)EP( + + ) 23 75 PR(namespace odb +{ + namespace sqlite + { + class single_connection_factory: public connection_factory + { + public: + single_connection_factory \201\202; + + protected: + class single_connection: public connection + { + public: + single_connection \201database_type&\202; + single_connection \201database_type&, MYSQL*\202; + }; + + typedef details::shared_ptr single_connection_ptr; + + virtual single_connection_ptr + create \201\202; + }; +};)RP( + + )0 P(The )SM(create\201\202)ES( virtual func)HY(tion)YH( is called when the + factory needs to create the connec)HY(tion)YH(. By deriv)HY(ing)YH( from the + )SM(single_connec)HY(tion)YH(_factory)ES( class and over)HY(rid)HY(ing)YH( this + func)HY(tion)YH( we can imple)HY(ment)YH( custom connec)HY(tion)YH( estab)HY(lish)HY(ment)YH( + and config)HY(u)HY(ra)HY(tion)YH(.)EP( + + )0 P(The )SM(new_connec)HY(tion)YH(_factory)ES( class creates a new + connec)HY(tion)YH( when)HY(ever)YH( one is requested. When a connec)HY(tion)YH( is no + longer needed, it is released and closed. The + )SM(new_connec)HY(tion)YH(_factory)ES( class has the follow)HY(ing)YH( + inter)HY(face)YH(:)EP( + + ) 10 59 PR(namespace odb +{ + namespace sqlite + { + class new_connection_factory: public connection_factory + { + public: + new_connection_factory \201\202; + }; +};)RP( + + )0 P(The )SM(connec)HY(tion)YH(_pool_factory)ES( class imple)HY(ments)YH( a + connec)HY(tion)YH( pool. It has the follow)HY(ing)YH( inter)HY(face)YH(:)EP( + + ) 24 75 PR(namespace odb +{ + namespace sqlite + { + class connection_pool_factory: public connection_factory + { + public: + connection_pool_factory \201std::size_t max_connections = 0, + std::size_t min_connections = 0\202; + + protected: + class pooled_connection: public connection + { + public: + pooled_connection \201database_type&, int extra_flags = 0\202; + pooled_connection \201database_type&, sqlite3*\202; + }; + + typedef details::shared_ptr pooled_connection_ptr; + + virtual pooled_connection_ptr + create \201\202; + }; +};)RP( + + )0 P(The )SM(max_connec)HY(tions)YH()ES( argu)HY(ment)YH( in the + )SM(connec)HY(tion)YH(_pool_factory)ES( construc)HY(tor)YH( spec)HY(i)HY(fies)YH( the maximum + number of concur)HY(rent)YH( connec)HY(tions)YH( that this pool factory will + main)HY(tain)YH(. Simi)HY(larly)YH(, the )SM(min_connec)HY(tions)YH()ES( argu)HY(ment)YH( + spec)HY(i)HY(fies)YH( the minimum number of avail)HY(able)YH( connec)HY(tions)YH( that + should be kept open.)EP( + + )0 P(When)HY(ever)YH( a connec)HY(tion)YH( is requested, the pool factory first + checks if there is an unused connec)HY(tion)YH( that can be returned. + If there is none, the pool factory checks the + )SM(max_connec)HY(tions)YH()ES( value to see if a new connec)HY(tion)YH( + can be created. If the total number of connec)HY(tions)YH( main)HY(tained)YH( + by the pool is less than this value, then a new connec)HY(tion)YH( is + created and returned. Other)HY(wise)YH(, the caller is blocked until + a connec)HY(tion)YH( becomes avail)HY(able)YH(.)EP( + + )0 P(When a connec)HY(tion)YH( is released, the pool factory first checks + if there are blocked callers waiting for a connec)HY(tion)YH(. If so, then + one of them is unblocked and is given the connec)HY(tion)YH(. Other)HY(wise)YH(, + the pool factory checks whether the total number of connec)HY(tions)YH( + main)HY(tained)YH( by the pool is greater than the )SM(min_connec)HY(tions)YH()ES( + value. If that's the case, the connec)HY(tion)YH( is closed. Other)HY(wise)YH(, the + connec)HY(tion)YH( is added to the pool of avail)HY(able)YH( connec)HY(tions)YH( to be + returned on the next request. In other words, if the number of + connec)HY(tions)YH( main)HY(tained)YH( by the pool exceeds )SM(min_connec)HY(tions)YH()ES( + and there are no callers waiting for a new connec)HY(tion)YH(, + then the pool will close the excess connec)HY(tions)YH(.)EP( + + )0 P(If the )SM(max_connec)HY(tions)YH()ES( value is 0, then the pool will + create a new connec)HY(tion)YH( when)HY(ever)YH( all of the exist)HY(ing)YH( connec)HY(tions)YH( + are in use. If the )SM(min_connec)HY(tions)YH()ES( value is 0, then + the pool will never close a connec)HY(tion)YH( and instead main)HY(tain)YH( all + the connec)HY(tions)YH( that were ever created.)EP( + + )0 P(The )SM(create\201\202)ES( virtual func)HY(tion)YH( is called when)HY(ever)YH( the + pool needs to create a new connec)HY(tion)YH(. By deriv)HY(ing)YH( from the + )SM(connec)HY(tion)YH(_pool_factory)ES( class and over)HY(rid)HY(ing)YH( this + func)HY(tion)YH( we can imple)HY(ment)YH( custom connec)HY(tion)YH( estab)HY(lish)HY(ment)YH( + and config)HY(u)HY(ra)HY(tion)YH(.)EP( + + )0 P(By default, connec)HY(tions)YH( created by )SM(new_connec)HY(tion)YH(_factory)ES( + and )SM(connec)HY(tion)YH(_pool_factory)ES( enable the SQLite shared cache + mode and use the unlock notify func)HY(tion)HY(al)HY(ity)YH( to aid concur)HY(rency)YH(. To + disable the shared cache mode you can pass the + )SM(SQLITE_OPEN_PRIVATE)HY(CACHE)YH()ES( flag when creat)HY(ing)YH( the database + instance. For more infor)HY(ma)HY(tion)YH( on the shared cache mode refer to the + SQLite docu)HY(men)HY(ta)HY(tion)YH(.)EP( + + )0 P(If you pass )SM(NULL)ES( as the connec)HY(tion)YH( factory to one of the + )SM(database)ES( construc)HY(tors)YH(, then the )SM(connec)HY(tion)YH(_pool_factory)ES( + instance will be created by default with the min and max connec)HY(tions)YH( + values set to )SM(0)ES(. The follow)HY(ing)YH( code frag)HY(ment)YH( shows how we + can pass our own connec)HY(tion)YH( factory instance:)EP( + + ) 14 72 PR(#include + +#include +#include + +int +main \201int argc, char* argv[]\202 +{ + auto_ptr f \201 + new odb::sqlite::connection_pool_factory \20120\202\202; + + auto_ptr db \201 + new sqlite::database \201argc, argv, false, SQLITE_OPEN_READWRITE, f\202\202; +})RP( + + )0 2 222 H(18.4)WB 547 Sn()WB 227 Sn( SQLite Excep)HY(tions)YH()EA()EH( + + )0 P(The SQLite ODB runtime library defines the follow)HY(ing)YH( SQLite-specific + excep)HY(tions)YH(:)EP( + + ) 35 53 PR(namespace odb +{ + namespace sqlite + { + class forced_rollback: odb::recoverable + { + public: + virtual const char* + what \201\202 const throw \201\202; + }; + + class database_exception: odb::database_exception + { + public: + int + error \201\202 const + + int + extended_error \201\202 const; + + const std::string& + message \201\202 const; + + virtual const char* + what \201\202 const throw \201\202; + }; + + class cli_exception: odb::exception + { + public: + virtual const char*)WR( + what \201\202 const throw \201\202; + }; + } +})RP( + + )0 P(You will need to include the )SM()ES( + header file to make these excep)HY(tions)YH( avail)HY(able)YH( in your appli)HY(ca)HY(tion)YH(.)EP( + + )0 P(The )SM(odb::sqlite::forced_roll)HY(back)YH()ES( excep)HY(tion)YH( is thrown if + SQLite is forcing the current trans)HY(ac)HY(tion)YH( to roll back. For more + infor)HY(ma)HY(tion)YH( on this behav)HY(ior)YH( refer to )0 234 1 A(Section 18.5.6, + "Forced Roll)HY(back)YH(")234 0 TN TL()Ec /AF f D(.)EP( + + )0 P(The )SM(odb::sqlite::database_excep)HY(tion)YH()ES( is thrown if + an SQLite database oper)HY(a)HY(tion)YH( fails. The SQLite-specific error + infor)HY(ma)HY(tion)YH( is acces)HY(si)HY(ble)YH( via the )SM(error\201\202)ES(, + )SM(extended_error\201\202)ES(, and )SM(message\201\202)ES( func)HY(tions)YH(. + All this infor)HY(ma)HY(tion)YH( is also combined and returned in a + human-read)HY(able)YH( form by the )SM(what\201\202)ES( func)HY(tion)YH(.)EP( + + )0 P(The )SM(odb::sqlite::cli_excep)HY(tion)YH()ES( is thrown by the + command line parsing construc)HY(tor)YH( of the )SM(odb::sqlite::database)ES( + class if the SQLite option values are missing or invalid. The + )SM(what\201\202)ES( func)HY(tion)YH( returns a human-read)HY(able)YH( descrip)HY(tion)YH( + of an error.)EP( + + + )0 2 223 H(18.5)WB 548 Sn()WB 228 Sn( SQLite Limi)HY(ta)HY(tions)YH()EA()EH( + + )0 P(The follow)HY(ing)YH( sections describe SQLite-specific limi)HY(ta)HY(tions)YH( imposed by + the current SQLite and ODB runtime versions.)EP( + + )0 3 224 H(18.5.1)WB 549 Sn()WB 229 Sn( Query Result Caching)EA()EH( + + )0 P(SQLite ODB runtime imple)HY(men)HY(ta)HY(tion)YH( does not perform query result caching + \201)0 43 1 A(Section 4.4, "Query Result")43 0 TN TL()Ec /AF f D(\202 even when explic)HY(itly)YH( + requested. The SQLite API supports inter)HY(leav)HY(ing)YH( execu)HY(tion)YH( of multi)HY(ple)YH( + prepared state)HY(ments)YH( on a single connec)HY(tion)YH(. As a result, with SQLite, it + is possi)HY(ble)YH( to have multi)HY(ple)YH( uncached results and calls to other database + func)HY(tions)YH( do not inval)HY(i)HY(date)YH( them. The only limi)HY(ta)HY(tion)YH( of the uncached + SQLite results is the unavail)HY(abil)HY(ity)YH( of the )SM(result::size\201\202)ES( + func)HY(tion)YH(. If you call this func)HY(tion)YH( on an SQLite query result, then + the )SM(odb::result_not_cached)ES( excep)HY(tion)YH( + \201)0 37 1 A(Section 3.14, "ODB Excep)HY(tions)YH(")37 0 TN TL()Ec /AF f D(\202 is always + thrown. Future versions of the SQLite ODB runtime library may add support + for result caching.)EP( + + )0 3 225 H(18.5.2)WB 550 Sn()WB 230 Sn( Auto)HY(matic)YH( Assign)HY(ment)YH( of Object Ids)EA()EH( + + )0 P(Due to SQLite API limi)HY(ta)HY(tions)YH(, every auto)HY(mat)HY(i)HY(cally)YH( assigned object id + \201)0 149 1 A(Section 14.4.2, ")SM(auto)ES(")149 0 TN TL()Ec /AF f D(\202 should have + the )SM(INTEGER)ES( SQLite type. While SQLite will treat other + integer type names \201such as )SM(INT)ES(, )SM(BIGINT)ES(, etc.\202 + as )SM(INTEGER)ES(, auto)HY(matic)YH( id assign)HY(ment)YH( will not work. By default, + ODB maps all C++ inte)HY(gral)YH( types to )SM(INTEGER)ES(. This means that + the only situ)HY(a)HY(tion)YH( that requires consid)HY(er)HY(a)HY(tion)YH( is the assign)HY(ment)YH( of a + custom database type using the )SM(db\240type)ES( pragma + \201)0 150 1 A(Section 14.4.3, ")SM(type)ES(")150 0 TN TL()Ec /AF f D(\202. For + example:)EP( + + ) 10 64 PR(#pragma db object +class person +{ + ... + + //#pragma db id auto type\201"INT"\202 // Will not work. + //#pragma db id auto type\201"INTEGER"\202 // Ok. + #pragma db id auto // Ok, Mapped to INTEGER. + unsigned int id_; +};)RP( + + )0 3 226 H(18.5.3)WB 551 Sn()WB 231 Sn( Foreign Key Constraints)EA()EH( + + )0 P(By default the SQLite ODB runtime enables foreign key constraints + check)HY(ing)YH( \201)SM(PRAGMA foreign_keys=ON)ES(\202. You can disable foreign + keys by passing )SM(false)ES( as the )SM(foreign_keys)ES( + argu)HY(ment)YH( to one of the )SM(odb::sqlite::database)ES( construc)HY(tors)YH(. + Foreign keys will also be disabled if the SQLite library is built without + support for foreign keys \201)SM(SQLITE_OMIT_FOREIGN_KEY)ES( and + )SM(SQLITE_OMIT_TRIGGER)ES( macros\202 or if you are using + an SQLite version prior to 3.6.19, which does not support foreign + key constraints check)HY(ing)YH(.)EP( + + )0 P(If foreign key constraints check)HY(ing)YH( is disabled or not avail)HY(able)YH(, + then incon)HY(sis)HY(ten)HY(cies)YH( in object rela)HY(tion)HY(ships)YH( will not be detected. + Further)HY(more)YH(, using the )SM(erase_query\201\202)ES( func)HY(tion)YH( + \201)0 34 1 A(Section 3.11, "Delet)HY(ing)YH( Persis)HY(tent)YH( Objects")34 0 TN TL()Ec /AF f D(\202 + to delete persis)HY(tent)YH( objects that contain contain)HY(ers)YH( will not work + correctly. Container data for such objects will not be deleted.)EP( + + )0 P(When foreign key constraints check)HY(ing)YH( is enabled, then you may + get the "foreign key constraint failed" error while re-creat)HY(ing)YH( the + database schema. This error is due to bugs in the SQLite DDL foreign + keys support. The recom)HY(mended)YH( work-around for this problem is to + temporar)HY(ily)YH( disable foreign key constraints check)HY(ing)YH( while + re-creat)HY(ing)YH( the schema. The follow)HY(ing)YH( code frag)HY(ment)YH( shows how + this can be done:)EP( + + ) 17 43 PR(#include +#include +#include + +odb::database& db = ... + +{ + odb::connection_ptr c \201db.connection \201\202\202; + + c->execute \201"PRAGMA foreign_keys=OFF"\202; + + odb::transaction t \201c->begin \201\202\202; + odb::schema_catalog::create_schema \201db\202; + t.commit \201\202; + + c->execute \201"PRAGMA foreign_keys=ON"\202; +})RP( + + )0 P(Finally, ODB assumes the stan)HY(dard)YH( SQL behav)HY(ior)YH( which requires + that foreign key constraints check)HY(ing)YH( is deferred until the + trans)HY(ac)HY(tion)YH( is commit)HY(ted)YH(. Default SQLite behav)HY(ior)YH( is to check such + constraints imme)HY(di)HY(ately)YH(. As a result, when used with ODB, a custom + database schema that defines foreign key constraints may need to + declare such constraints as )SM(DEFERRABLE INITIALLY DEFERRED)ES(, + as shown in the follow)HY(ing)YH( example. By default, schemas gener)HY(ated)YH( by + the ODB compiler meet this require)HY(ment)YH( auto)HY(mat)HY(i)HY(cally)YH(.)EP( + + ) 4 42 PR(CREATE TABLE Employee \201 + ... + employer INTEGER REFERENCES Employer\201id\202 + DEFERRABLE INITIALLY DEFERRED\202;)RP( + + )0 P(You can over)HY(ride)YH( the default behav)HY(ior)YH( and instruct the ODB + compiler to gener)HY(ate)YH( non-deferrable foreign keys by spec)HY(i)HY(fy)HY(ing)YH( + the )SM(--fkeys-deferrable-mode not_deferrable)ES( ODB + compiler option. Note, however, that in this case the order in + which you persist, update, and erase objects within a trans)HY(ac)HY(tion)YH( + becomes impor)HY(tant)YH(.)EP( + + )0 3 227 H(18.5.4)WB 552 Sn()WB 232 Sn( Constraint Viola)HY(tions)YH()EA()EH( + + )0 P(Due to the gran)HY(u)HY(lar)HY(ity)YH( of the SQLite error codes, it is impos)HY(si)HY(ble)YH( + to distin)HY(guish)YH( between the dupli)HY(cate)YH( primary key and other constraint + viola)HY(tions)YH(. As a result, when making an object persis)HY(tent)YH(, the SQLite + ODB runtime will trans)HY(late)YH( all constraint viola)HY(tion)YH( errors to the + )SM(object_already_persis)HY(tent)YH()ES( excep)HY(tion)YH( \201)0 37 1 A(Section + 3.14, "ODB Excep)HY(tions)YH(")37 0 TN TL()Ec /AF f D(\202.)EP( + + )0 3 228 H(18.5.5)WB 553 Sn()WB 233 Sn( Sharing of Queries)EA()EH( + + )0 P(As discussed in )0 42 1 A(Section 4.3, "Execut)HY(ing)YH( a Query")42 0 TN TL()Ec /AF f D(, a + query instance that does not have any by-refer)HY(ence)YH( param)HY(e)HY(ters)YH( is + immutable and can be shared between multi)HY(ple)YH( threads without + synchro)HY(niza)HY(tion)YH(. Currently, the SQLite ODB runtime does not support this + func)HY(tion)HY(al)HY(ity)YH(. Future versions of the library will remove this + limi)HY(ta)HY(tion)YH(.)EP( + + )0 3 229 H(18.5.6)WB 554 Sn()WB 234 Sn( Forced Roll)HY(back)YH()EA()EH( + + )0 P(In SQLite 3.7.11 or later, if one of the connec)HY(tions)YH( partic)HY(i)HY(pat)HY(ing)YH( in + the shared cache rolls back a trans)HY(ac)HY(tion)YH(, then ongoing trans)HY(ac)HY(tions)YH( + on other connec)HY(tions)YH( in the shared cache may also be forced to roll back. + An example of such behav)HY(ior)YH( would be a read-only trans)HY(ac)HY(tion)YH( that is + forced to roll back while iter)HY(at)HY(ing)YH( over the query result because another + trans)HY(ac)HY(tion)YH( on another connec)HY(tion)YH( was rolled back.)EP( + + )0 P(If a trans)HY(ac)HY(tion)YH( is being forced to roll back by SQLite, then ODB + throws )SM(odb::sqlite::forced_roll)HY(back)YH()ES( + \201)0 227 1 A(Section 18.4, "SQLite Excep)HY(tions)YH(")227 0 TN TL()Ec /AF f D(\202 which is + a recov)HY(er)HY(able)YH( excep)HY(tion)YH( \201)0 30 1 A(3.7 Error Handling and + Recov)HY(ery)YH()30 0 TN TL()Ec /AF f D(\202. As a result, the recom)HY(mended)YH( way to handle this + excep)HY(tion)YH( is to re-execute the affected trans)HY(ac)HY(tion)YH(.)EP( + + )0 3 230 H(18.5.7)WB 555 Sn()WB 235 Sn( Database Schema Evolu)HY(tion)YH()EA()EH( + + )0 P(From the list of schema migra)HY(tion)YH( changes supported by ODB + \201)0 93 1 A(Section 13.2, "Schema Migra)HY(tion)YH(")93 0 TN TL()Ec /AF f D(\202, the + follow)HY(ing)YH( are not supported by SQLite:)EP( + + )UL( )-1 LI(drop column + )-1 LI(alter column, set )SM(NULL)ES(/)SM(NOT NULL)ES( + )-1 LI(add foreign key + )-1 LI(drop foreign key + )LU( + + )0 P(The biggest problem is the lack of support for drop)HY(ping)YH( columns. + This means that it would be impos)HY(si)HY(ble)YH( to delete a data member + in a persis)HY(tent)YH( class. To work around this limi)HY(ta)HY(tion)YH( ODB + imple)HY(ments)YH( )EM(logical delete)ES( for columns that allow + )SM(NULL)ES( values. In this case, instead of drop)HY(ping)YH( + the column \201in the post-migra)HY(tion)YH( stage\202, the schema migra)HY(tion)YH( + state)HY(ments)YH( will auto)HY(mat)HY(i)HY(cally)YH( reset this column in all the + exist)HY(ing)YH( rows to )SM(NULL)ES(. Any new rows that are + inserted later will also auto)HY(mat)HY(i)HY(cally)YH( have this column set + to )SM(NULL)ES( \201unless the column spec)HY(i)HY(fies)YH( a default + value\202.)EP( + + )0 P(Since it is also impos)HY(si)HY(ble)YH( to change the column's + )SM(NULL)ES(/)SM(NOT NULL)ES( attribute after it + has been added, to make schema evolu)HY(tion)YH( support usable in + SQLite, all the columns should be added as )SM(NULL)ES( + even if seman)HY(ti)HY(cally)YH( they should not allow )SM(NULL)ES( + values. We should also normally refrain from assign)HY(ing)YH( + default values to columns \201)0 154 1 A(Section 14.4.7, + )SM(default)ES()154 0 TN TL()Ec /AF f D(\202, unless the space over)HY(head)YH( of + a default value is not a concern. Explic)HY(itly)YH( making all + the data members )SM(NULL)ES( would be burden)HY(some)YH( + and ODB provides the )SM(--sqlite-over)HY(ride)YH(-null)ES( + command line option that forces all the columns, even those + that were explic)HY(itly)YH( marked )SM(NOT NULL)ES(, to be + )SM(NULL)ES( in SQLite.)EP( + + )0 P(SQLite only supports adding foreign keys as part of the + column addi)HY(tion)YH(. As a result, we can only add a new + data member of an object pointer type if it points + to an object with a simple \201single-column\202 object id.)EP( + + )0 P(SQLite also doesn't support drop)HY(ping)YH( foreign keys. + Leaving a foreign key around works well with logical + delete unless we also want to delete the pointed-to + object. In this case we will have to leave an + empty table corre)HY(spond)HY(ing)YH( to the pointed-to object + around. An alter)HY(na)HY(tive)YH( would be to make a copy of the + point)HY(ing)YH( object without the object pointer, migrate the + data, and then delete both the old point)HY(ing)YH( and the + pointed-to objects. Since this will result in drop)HY(ping)YH( + the point)HY(ing)YH( table, the foreign key will be dropped + as well. Yet another, more radical, solu)HY(tion)YH( to this + problem is to disable foreign keys check)HY(ing)YH( alto)HY(gether)YH( + \201see the )SM(foreign_keys)ES( SQLite pragma\202.)EP( + + )0 P(To summa)HY(rize)YH(, to make schema evolu)HY(tion)YH( support usable + in SQLite we should pass the )SM(--sqlite-over)HY(ride)YH(-null)ES( + option when compil)HY(ing)YH( our persis)HY(tent)YH( classes and also refrain + from assign)HY(ing)YH( default values to data members. Note also that + this has to be done from the start so that every column is added + as )SM(NULL)ES( and there)HY(fore)YH( can be logi)HY(cally)YH( deleted later. + In partic)HY(u)HY(lar)YH(, you cannot add the )SM(--sqlite-over)HY(ride)YH(-null)ES( + option when you realize you need to delete a data member. At this + point it is too late since the column has already been added + as )SM(NOT NULL)ES( in exist)HY(ing)YH( databases. We should also + avoid compos)HY(ite)YH( object ids if we are plan)HY(ning)YH( to use object + rela)HY(tion)HY(ships)YH(.)EP( + + )0 2 231 H(18.6)WB 556 Sn()WB 236 Sn( SQLite Index Defi)HY(ni)HY(tions)YH()EA()EH( + + )0 P(When the )SM(index)ES( pragma \201)0 191 1 A(Section 14.7, + "Index Defi)HY(ni)HY(tion)YH( Pragmas")191 0 TN TL()Ec /AF f D(\202 is used to define an SQLite index, + the )SM(type)ES( clause spec)HY(i)HY(fies)YH( the index type \201for example, + )SM(UNIQUE)ES(\202 while the )SM(method)ES( and + )SM(options)ES( clauses are not used. The column options + can be used to specify colla)HY(tions)YH( and the sort order. For example:)EP( + + ) 9 55 PR(#pragma db object +class object +{ + ... + + std::string name_; + + #pragma db index member\201name_, "COLLATE binary DESC"\202 +};)RP( + + )0 P(Index names in SQLite are database-global. To avoid name clashes, + ODB auto)HY(mat)HY(i)HY(cally)YH( prefixes each index name with the table name on + which it is defined.)EP( + + + + + )WB NL NP( + )0 1 232 H(19)WB 557 Sn()WB 237 Sn( Post)HY(greSQL)YH( Database)EA()EH( + + )0 P(To gener)HY(ate)YH( support code for the Post)HY(greSQL)YH( database you will need + to pass the ")SM(--database\240pgsql)ES(" + \201or ")SM(-d\240pgsql)ES("\202 option to the ODB compiler. + Your appli)HY(ca)HY(tion)YH( will also need to link to the Post)HY(greSQL)YH( ODB runtime + library \201)SM(libodb-pgsql)ES(\202. All Post)HY(greSQL)YH(-specific ODB + classes are defined in the )SM(odb::pgsql)ES( names)HY(pace)YH(.)EP( + + )0 P(ODB utilizes prepared state)HY(ments)YH( exten)HY(sively)YH(. Support for prepared + state)HY(ments)YH( was added in Post)HY(greSQL)YH( version 7.4 with the intro)HY(duc)HY(tion)YH( + of the messag)HY(ing)YH( proto)HY(col)YH( version 3.0. For this reason, ODB supports + only Post)HY(greSQL)YH( version 7.4 and later.)EP( + + )0 2 233 H(19.1)WB 558 Sn()WB 238 Sn( Post)HY(greSQL)YH( Type Mapping)EA()EH( + + )0 P(The follow)HY(ing)YH( table summa)HY(rizes)YH( the default mapping between basic + C++ value types and Post)HY(greSQL)YH( database types. This mapping can be + customized on the per-type and per-member basis using the ODB + Pragma Language \201)0 100 1 A(Chapter 14, "ODB Pragma + Language")100 0 TN TL()Ec /AF f D(\202.)EP( + + + )13 PT( + + )0 P(It is possi)HY(ble)YH( to map the )SM(char)ES( C++ type to an integer + database type \201for example, )SM(SMALL)HY(INT)YH()ES(\202 using the + )SM(db\240type)ES( pragma \201)0 150 1 A(Section 14.4.3, + ")SM(type)ES(")150 0 TN TL()Ec /AF f D(\202.)EP( + + )0 P(Addi)HY(tion)HY(ally)YH(, by default, C++ enums and C++11 enum classes are + auto)HY(mat)HY(i)HY(cally)YH( mapped to the Post)HY(greSQL)YH( types corre)HY(spond)HY(ing)YH( to their + under)HY(ly)HY(ing)YH( inte)HY(gral)YH( types \201see table above\202. The default + )SM(NULL)ES( seman)HY(tics)YH( is )SM(NOT NULL)ES(. For + example:)EP( + + ) 17 52 PR(enum color {red, green, blue}; +enum class taste: unsigned char +{ + bitter = 1, + sweet, + sour = 4, + salty +}; + +#pragma db object +class object +{ + ... + + color color_; // Automatically mapped to INTEGER. + taste taste_; // Automatically mapped to SMALLINT. +};)RP( + + )0 P(Note also that because Post)HY(greSQL)YH( does not support unsigned inte)HY(gers)YH(, + the )SM(unsigned\240short)ES(, )SM(unsigned\240int)ES(, and + )SM(unsigned\240long)ES(/)SM(unsigned\240long\240long)ES( C++ types + are by default mapped to the )SM(SMALL)HY(INT)YH()ES(, )SM(INTEGER)ES(, + and )SM(BIGINT)ES( Post)HY(greSQL)YH( types, respec)HY(tively)YH(. The sign bit + of the value stored by the database for these types will contain + the most signif)HY(i)HY(cant)YH( bit of the actual unsigned value being + persisted.)EP( + + )0 P(It is also possi)HY(ble)YH( to add support for addi)HY(tional)YH( Post)HY(greSQL)YH( types, + such as )SM(NUMERIC)ES(, geom)HY(e)HY(try)YH( types, )SM(XML)ES(, + )SM(JSON)ES(, enumer)HY(a)HY(tion)YH( types, compos)HY(ite)YH( types, arrays, + geospa)HY(tial)YH( types, and the key-value store \201)SM(HSTORE)ES(\202. + For more infor)HY(ma)HY(tion)YH(, refer to )0 192 1 A(Section 14.8, + "Database Type Mapping Pragmas")192 0 TN TL()Ec /AF f D(.)EP( + + )0 3 234 H(19.1.1)WB 559 Sn()WB 239 Sn( String Type Mapping)EA()EH( + + )0 P(The Post)HY(greSQL)YH( ODB runtime library provides support for mapping the + )SM(std::string)ES(, )SM(char[N])ES(, and + )SM(std::array)ES( types to the Post)HY(greSQL)YH( + )SM(CHAR)ES(, )SM(VARCHAR)ES(, and )SM(TEXT)ES( + types. However, these mappings are not enabled by default \201in + partic)HY(u)HY(lar)YH(, by default, )SM(std::array)ES( will be treated + as a container\202. To enable the alter)HY(na)HY(tive)YH( mappings for these + types we need to specify the database type explic)HY(itly)YH( using the + )SM(db\240type)ES( pragma \201)0 150 1 A(Section 14.4.3, + ")SM(type)ES(")150 0 TN TL()Ec /AF f D(\202, for example:)EP( + + ) 11 33 PR(#pragma db object +class object +{ + ... + + #pragma db type\201"CHAR\2012\202"\202 + char state_[2]; + + #pragma db type\201"VARCHAR\201128\202"\202 + std::string name_; +};)RP( + + )0 P(Alter)HY(na)HY(tively)YH(, this can be done on the per-type basis, for example:)EP( + + ) 9 50 PR(#pragma db value\201std::string\202 type\201"VARCHAR\201128\202"\202 + +#pragma db object +class object +{ + ... + + std::string name_; // Mapped to VARCHAR\201128\202. +};)RP( + + )0 P(The )SM(char[N])ES( and )SM(std::array)ES( values + may or may not be zero-termi)HY(nated)YH(. When extract)HY(ing)YH( such values from the + database, ODB will append the zero termi)HY(na)HY(tor)YH( if there is enough + space.)EP( + + )0 3 235 H(19.1.2)WB 560 Sn()WB 240 Sn( Binary Type and )SM(UUID)ES( Mapping)EA()EH( + + )0 P(The Post)HY(greSQL)YH( ODB runtime library provides support for mapping the + )SM(std::vector)ES(, + )SM(std::vector)ES(, + )SM(char[N])ES(, )SM(unsigned\240char[N])ES(, + )SM(std::array)ES(, and + )SM(std::array)ES( types to the Post)HY(greSQL)YH( + )SM(BYTEA)ES( type. There is also support for mapping the + )SM(char[16])ES( array to the Post)HY(greSQL)YH( )SM(UUID)ES( type. + However, these mappings are not enabled by default \201in partic)HY(u)HY(lar)YH(, by + default, )SM(std::vector)ES( and )SM(std::array)ES( will be + treated as contain)HY(ers)YH(\202. To enable the alter)HY(na)HY(tive)YH( mappings for these + types we need to specify the database type explic)HY(itly)YH( using the + )SM(db\240type)ES( pragma \201)0 150 1 A(Section 14.4.3, + ")SM(type)ES(")150 0 TN TL()Ec /AF f D(\202, for example:)EP( + + ) 14 27 PR(#pragma db object +class object +{ + ... + + #pragma db type\201"UUID"\202 + char uuid_[16]; + + #pragma db type\201"BYTEA"\202 + std::vector buf_; + + #pragma db type\201"BYTEA"\202 + unsigned char data_[256]; +};)RP( + + )0 P(Alter)HY(na)HY(tively)YH(, this can be done on the per-type basis, for example:)EP( + + ) 10 38 PR(typedef std::vector buffer; +#pragma db value\201buffer\202 type\201"BYTEA"\202 + +#pragma db object +class object +{ + ... + + buffer buf_; // Mapped to BYTEA. +};)RP( + + )0 P(Note also that in native queries \201)0 38 1 A(Chapter 4, "Query)HY(ing)YH( + the Database")38 0 TN TL()Ec /AF f D(\202 )SM(char[N])ES( and + )SM(std::array)ES( param)HY(e)HY(ters)YH( are by default passed + as a string rather than a binary. To pass such param)HY(e)HY(ters)YH( as a binary, + we need to specify the database type explic)HY(itly)YH( in the + )SM(_val\201\202)ES(/)SM(_ref\201\202)ES( calls. Note also that we + don't need to do this for the inte)HY(grated)YH( queries, for example:)EP( + + ) 5 68 PR(char u[16] = {...}; + +db.query \201"uuid = " + query::_val \201u\202\202; +db.query \201"buf = " + query::_val \201u\202\202; +db.query \201query::uuid == query::_ref \201u\202\202;)RP( + + )0 2 236 H(19.2)WB 561 Sn()WB 241 Sn( Post)HY(greSQL)YH( Database Class)EA()EH( + + )0 P(The Post)HY(greSQL)YH( )SM(database)ES( class has the follow)HY(ing)YH( + inter)HY(face)YH(:)EP( + + ) 66 64 PR(namespace odb +{ + namespace pgsql + { + class database: public odb::database + { + public: + database \201const std::string& user, + const std::string& password, + const std::string& db, + const std::string& host = "", + unsigned int port = 0, + const std::string& extra_conninfo = "", + std::[auto|unique]_ptr = 0\202; + + database \201const std::string& user, + const std::string& password, + const std::string& db, + const std::string& host, + const std::string& socket_ext, + const std::string& extra_conninfo = "", + std::[auto|unique]_ptr = 0\202; + + database \201const std::string& conninfo, + std::[auto|unique]_ptr = 0\202; + + database \201int& argc, + char* argv[], + bool erase = false, + const std::string& extra_conninfo = "", + std::[auto|unique]_ptr = 0\202;)WR( + + static void + print_usage \201std::ostream&\202; + + public: + const std::string& + user \201\202 const; + + const std::string& + password \201\202 const; + + const std::string& + db \201\202 const; + + const std::string& + host \201\202 const; + + unsigned int + port \201\202 const; + + const std::string& + socket_ext \201\202 const; + + const std::string& + extra_conninfo \201\202 const; + + const std::string& + conninfo \201\202 const; + + public:)WR( + connection_ptr + connection \201\202; + }; + } +})RP( + + )0 P(You will need to include the )SM()ES( + header file to make this class avail)HY(able)YH( in your appli)HY(ca)HY(tion)YH(.)EP( + + )0 P(The over)HY(loaded)YH( )SM(database)ES( construc)HY(tors)YH( allow us to specify + the Post)HY(greSQL)YH( database param)HY(e)HY(ters)YH( that should be used when connect)HY(ing)YH( + to the database. The )SM(port)ES( argu)HY(ment)YH( in the first construc)HY(tor)YH( + is an integer value spec)HY(i)HY(fy)HY(ing)YH( the TCP/IP port number to connect to. A + zero port number indi)HY(cates)YH( that the default port should be used. + The )SM(socket_ext)ES( argu)HY(ment)YH( in the second construc)HY(tor)YH( is a + string value spec)HY(i)HY(fy)HY(ing)YH( the UNIX-domain socket file name exten)HY(sion)YH(.)EP( + + )0 P(The third construc)HY(tor)YH( allows us to specify all the database param)HY(e)HY(ters)YH( + as a single )SM(conninfo)ES( string. All other construc)HY(tors)YH( + accept addi)HY(tional)YH( database connec)HY(tion)YH( param)HY(e)HY(ters)YH( as the + )SM(extra_conninfo)ES( argu)HY(ment)YH(. For more infor)HY(ma)HY(tion)YH( + about the format of the )SM(conninfo)ES( string, refer to + the )SM(PQcon)HY(nectdb)YH(\201\202)ES( func)HY(tion)YH( descrip)HY(tion)YH( in the Post)HY(greSQL)YH( + docu)HY(men)HY(ta)HY(tion)YH(. In the case of )SM(extra_conninfo)ES(, all the + database param)HY(e)HY(ters)YH( provided in this string will take prece)HY(dence)YH( + over those explic)HY(itly)YH( spec)HY(i)HY(fied)YH( with other construc)HY(tor)YH( argu)HY(ments)YH(.)EP( + + )0 P(The last construc)HY(tor)YH( extracts the database param)HY(e)HY(ters)YH( + from the command line. The follow)HY(ing)YH( options are recog)HY(nized)YH(:)EP( + + ) 6 37 PR( --user | --username + --password + --database | --dbname + --host + --port + --options-file )RP( + + )0 P(The )SM(--options-file)ES( option allows us to specify some + or all of the database options in a file with each option appear)HY(ing)YH( + on a sepa)HY(rate)YH( line followed by a space and an option value.)EP( + + )0 P(If the )SM(erase)ES( argu)HY(ment)YH( to this construc)HY(tor)YH( is true, + then the above options are removed from the )SM(argv)ES( + array and the )SM(argc)ES( count is updated accord)HY(ingly)YH(. + This is primar)HY(ily)YH( useful if your appli)HY(ca)HY(tion)YH( accepts other + options or argu)HY(ments)YH( and you would like to get the Post)HY(greSQL)YH( + options out of the )SM(argv)ES( array.)EP( + + )0 P(This construc)HY(tor)YH( throws the )SM(odb::pgsql::cli_excep)HY(tion)YH()ES( + excep)HY(tion)YH( if the Post)HY(greSQL)YH( option values are missing or invalid. + See section )0 243 1 A(Section 19.4, "Post)HY(greSQL)YH( Excep)HY(tions)YH(")243 0 TN TL()Ec /AF f D( + for more infor)HY(ma)HY(tion)YH( on this excep)HY(tion)YH(.)EP( + + )0 P(The static )SM(print_usage\201\202)ES( func)HY(tion)YH( prints the list of options + with short descrip)HY(tions)YH( that are recog)HY(nized)YH( by this construc)HY(tor)YH(.)EP( + + )0 P(The last argu)HY(ment)YH( to all of the construc)HY(tors)YH( is a pointer to the + connec)HY(tion)YH( factory. In C++98/03, it is )SM(std::auto_ptr)ES( while + in C++11 )SM(std::unique_ptr)ES( is used instead. If we pass a + non-)SM(NULL)ES( value, the database instance assumes owner)HY(ship)YH( + of the factory instance. The connec)HY(tion)YH( factory inter)HY(face)YH( as well as + the avail)HY(able)YH( imple)HY(men)HY(ta)HY(tions)YH( are described in the next section.)EP( + + )0 P(The set of acces)HY(sor)YH( func)HY(tions)YH( follow)HY(ing)YH( the construc)HY(tors)YH( allows us + to query the param)HY(e)HY(ters)YH( of the )SM(database)ES( instance. Note that + the )SM(conninfo\201\202)ES( acces)HY(sor)YH( returns a complete + )SM(conninfo)ES( string which includes param)HY(e)HY(ters)YH( that were + explic)HY(itly)YH( spec)HY(i)HY(fied)YH( with the various construc)HY(tor)YH( argu)HY(ments)YH(, as well as + the extra param)HY(e)HY(ters)YH( passed in the )SM(extra_conninfo)ES( argu)HY(ment)YH(. + The )SM(extra_conninfo\201\202)ES( acces)HY(sor)YH( will return the + )SM(conninfo)ES( string as passed in the )SM(extra_conninfo)ES( + argu)HY(ment)YH(.)EP( + + )0 P(The )SM(connec)HY(tion)YH(\201\202)ES( func)HY(tion)YH( returns a pointer to the + Post)HY(greSQL)YH( database connec)HY(tion)YH( encap)HY(su)HY(lated)YH( by the + )SM(odb::pgsql::connec)HY(tion)YH()ES( class. For more infor)HY(ma)HY(tion)YH( + on )SM(pgsql::connec)HY(tion)YH()ES(, refer to )0 242 1 A(Section + 19.3, "Post)HY(greSQL)YH( Connec)HY(tion)YH( and Connec)HY(tion)YH( Factory")242 0 TN TL()Ec /AF f D(.)EP( + + )0 2 237 H(19.3)WB 562 Sn()WB 242 Sn( Post)HY(greSQL)YH( Connec)HY(tion)YH( and Connec)HY(tion)YH( Factory)EA()EH( + + )0 P(The )SM(pgsql::connec)HY(tion)YH()ES( class has the follow)HY(ing)YH( inter)HY(face)YH(:)EP( + + ) 17 59 PR(namespace odb +{ + namespace pgsql + { + class connection: public odb::connection + { + public: + connection \201database&\202; + connection \201database&, PGconn*\202; + + PGconn* + handle \201\202; + }; + + typedef details::shared_ptr connection_ptr; + } +})RP( + + )0 P(For more infor)HY(ma)HY(tion)YH( on the )SM(odb::connec)HY(tion)YH()ES( inter)HY(face)YH(, + refer to )0 29 1 A(Section 3.6, "Connec)HY(tions)YH(")29 0 TN TL()Ec /AF f D(. The first + over)HY(loaded)YH( )SM(pgsql::connec)HY(tion)YH()ES( construc)HY(tor)YH( estab)HY(lishes)YH( a + new Post)HY(greSQL)YH( connec)HY(tion)YH(. The second construc)HY(tor)YH( allows us to create + a )SM(connec)HY(tion)YH()ES( instance by provid)HY(ing)YH( an already connected + native Post)HY(greSQL)YH( handle. Note that the )SM(connec)HY(tion)YH()ES( + instance assumes owner)HY(ship)YH( of this handle. The )SM(handle\201\202)ES( + acces)HY(sor)YH( returns the Post)HY(greSQL)YH( handle corre)HY(spond)HY(ing)YH( to the connec)HY(tion)YH(.)EP( + + )0 P(The )SM(pgsql::connec)HY(tion)YH(_factory)ES( abstract class has the + follow)HY(ing)YH( inter)HY(face)YH(:)EP( + + ) 15 31 PR(namespace odb +{ + namespace pgsql + { + class connection_factory + { + public: + virtual void + database \201database&\202 = 0; + + virtual connection_ptr + connect \201\202 = 0; + }; + } +})RP( + + )0 P(The )SM(database\201\202)ES( func)HY(tion)YH( is called when a connec)HY(tion)YH( + factory is asso)HY(ci)HY(ated)YH( with a database instance. This happens in + the )SM(odb::pgsql::database)ES( class construc)HY(tors)YH(. The + )SM(connect\201\202)ES( func)HY(tion)YH( is called when)HY(ever)YH( a database + connec)HY(tion)YH( is requested.)EP( + + )0 P(The two imple)HY(men)HY(ta)HY(tions)YH( of the )SM(connec)HY(tion)YH(_factory)ES( + inter)HY(face)YH( provided by the Post)HY(greSQL)YH( ODB runtime are + )SM(new_connec)HY(tion)YH(_factory)ES( and + )SM(connec)HY(tion)YH(_pool_factory)ES(. You will need to include + the )SM()ES( + header file to make the )SM(connec)HY(tion)YH(_factory)ES( inter)HY(face)YH( + and these imple)HY(men)HY(ta)HY(tion)YH( classes avail)HY(able)YH( in your appli)HY(ca)HY(tion)YH(.)EP( + + )0 P(The )SM(new_connec)HY(tion)YH(_factory)ES( class creates a new + connec)HY(tion)YH( when)HY(ever)YH( one is requested. When a connec)HY(tion)YH( is no + longer needed, it is released and closed. The + )SM(new_connec)HY(tion)YH(_factory)ES( class has the follow)HY(ing)YH( + inter)HY(face)YH(:)EP( + + ) 10 59 PR(namespace odb +{ + namespace pgsql + { + class new_connection_factory: public connection_factory + { + public: + new_connection_factory \201\202; + }; +};)RP( + + )0 P(The )SM(connec)HY(tion)YH(_pool_factory)ES( class imple)HY(ments)YH( a + connec)HY(tion)YH( pool. It has the follow)HY(ing)YH( inter)HY(face)YH(:)EP( + + ) 24 75 PR(namespace odb +{ + namespace pgsql + { + class connection_pool_factory: public connection_factory + { + public: + connection_pool_factory \201std::size_t max_connections = 0, + std::size_t min_connections = 0\202; + + protected: + class pooled_connection: public connection + { + public: + pooled_connection \201database_type&\202; + pooled_connection \201database_type&, PGconn*\202; + }; + + typedef details::shared_ptr pooled_connection_ptr; + + virtual pooled_connection_ptr + create \201\202; + }; +};)RP( + + )0 P(The )SM(max_connec)HY(tions)YH()ES( argu)HY(ment)YH( in the + )SM(connec)HY(tion)YH(_pool_factory)ES( construc)HY(tor)YH( spec)HY(i)HY(fies)YH( the maximum + number of concur)HY(rent)YH( connec)HY(tions)YH( that this pool factory will + main)HY(tain)YH(. Simi)HY(larly)YH(, the )SM(min_connec)HY(tions)YH()ES( argu)HY(ment)YH( + spec)HY(i)HY(fies)YH( the minimum number of avail)HY(able)YH( connec)HY(tions)YH( that + should be kept open.)EP( + + )0 P(When)HY(ever)YH( a connec)HY(tion)YH( is requested, the pool factory first + checks if there is an unused connec)HY(tion)YH( that can be returned. + If there is none, the pool factory checks the + )SM(max_connec)HY(tions)YH()ES( value to see if a new connec)HY(tion)YH( + can be created. If the total number of connec)HY(tions)YH( main)HY(tained)YH( + by the pool is less than this value, then a new connec)HY(tion)YH( is + created and returned. Other)HY(wise)YH(, the caller is blocked until + a connec)HY(tion)YH( becomes avail)HY(able)YH(.)EP( + + )0 P(When a connec)HY(tion)YH( is released, the pool factory first checks + if there are blocked callers waiting for a connec)HY(tion)YH(. If so, then + one of them is unblocked and is given the connec)HY(tion)YH(. Other)HY(wise)YH(, + the pool factory checks whether the total number of connec)HY(tions)YH( + main)HY(tained)YH( by the pool is greater than the )SM(min_connec)HY(tions)YH()ES( + value. If that's the case, the connec)HY(tion)YH( is closed. Other)HY(wise)YH(, the + connec)HY(tion)YH( is added to the pool of avail)HY(able)YH( connec)HY(tions)YH( to be + returned on the next request. In other words, if the number of + connec)HY(tions)YH( main)HY(tained)YH( by the pool exceeds )SM(min_connec)HY(tions)YH()ES( + and there are no callers waiting for a new connec)HY(tion)YH(, + the pool will close the excess connec)HY(tions)YH(.)EP( + + )0 P(If the )SM(max_connec)HY(tions)YH()ES( value is 0, then the pool will + create a new connec)HY(tion)YH( when)HY(ever)YH( all of the exist)HY(ing)YH( connec)HY(tions)YH( + are in use. If the )SM(min_connec)HY(tions)YH()ES( value is 0, then + the pool will never close a connec)HY(tion)YH( and instead main)HY(tain)YH( all + the connec)HY(tions)YH( that were ever created.)EP( + + )0 P(The )SM(create\201\202)ES( virtual func)HY(tion)YH( is called when)HY(ever)YH( the + pool needs to create a new connec)HY(tion)YH(. By deriv)HY(ing)YH( from the + )SM(connec)HY(tion)YH(_pool_factory)ES( class and over)HY(rid)HY(ing)YH( this + func)HY(tion)YH( we can imple)HY(ment)YH( custom connec)HY(tion)YH( estab)HY(lish)HY(ment)YH( + and config)HY(u)HY(ra)HY(tion)YH(.)EP( + + )0 P(If you pass )SM(NULL)ES( as the connec)HY(tion)YH( factory to one of the + )SM(database)ES( construc)HY(tors)YH(, then the + )SM(connec)HY(tion)YH(_pool_factory)ES( instance will be created by default + with the min and max connec)HY(tions)YH( values set to )SM(0)ES(. The + follow)HY(ing)YH( code frag)HY(ment)YH( shows how we can pass our own connec)HY(tion)YH( factory + instance:)EP( + + ) 14 52 PR(#include + +#include +#include + +int +main \201int argc, char* argv[]\202 +{ + auto_ptr f \201 + new odb::pgsql::connection_pool_factory \20120\202\202; + + auto_ptr db \201 + new pgsql::database \201argc, argv, false, "", f\202\202; +})RP( + + )0 2 238 H(19.4)WB 563 Sn()WB 243 Sn( Post)HY(greSQL)YH( Excep)HY(tions)YH()EA()EH( + + )0 P(The Post)HY(greSQL)YH( ODB runtime library defines the follow)HY(ing)YH( + Post)HY(greSQL)YH(-specific excep)HY(tions)YH(:)EP( + + ) 25 53 PR(namespace odb +{ + namespace pgsql + { + class database_exception: odb::database_exception + { + public: + const std::string& + message \201\202 const; + + const std::string& + sqlstate \201\202 const; + + virtual const char* + what \201\202 const throw \201\202; + }; + + class cli_exception: odb::exception + { + public: + virtual const char* + what \201\202 const throw \201\202; + }; + } +})RP( + + )0 P(You will need to include the )SM()ES( + header file to make these excep)HY(tions)YH( avail)HY(able)YH( in your appli)HY(ca)HY(tion)YH(.)EP( + + )0 P(The )SM(odb::pgsql::database_excep)HY(tion)YH()ES( is thrown if + a Post)HY(greSQL)YH( database oper)HY(a)HY(tion)YH( fails. The Post)HY(greSQL)YH(-specific error + infor)HY(ma)HY(tion)YH( is acces)HY(si)HY(ble)YH( via the )SM(message\201\202)ES( and + )SM(sqlstate\201\202)ES( func)HY(tions)YH(. All this infor)HY(ma)HY(tion)YH( is also + combined and returned in a human-read)HY(able)YH( form by the )SM(what\201\202)ES( + func)HY(tion)YH(.)EP( + + )0 P(The )SM(odb::pgsql::cli_excep)HY(tion)YH()ES( is thrown by the + command line parsing construc)HY(tor)YH( of the )SM(odb::pgsql::database)ES( + class if the Post)HY(greSQL)YH( option values are missing or invalid. The + )SM(what\201\202)ES( func)HY(tion)YH( returns a human-read)HY(able)YH( descrip)HY(tion)YH( + of an error.)EP( + + )0 2 239 H(19.5)WB 564 Sn()WB 244 Sn( Post)HY(greSQL)YH( Limi)HY(ta)HY(tions)YH()EA()EH( + + )0 P(The follow)HY(ing)YH( sections describe Post)HY(greSQL)YH(-specific limi)HY(ta)HY(tions)YH( imposed + by the current Post)HY(greSQL)YH( and ODB runtime versions.)EP( + + )0 3 240 H(19.5.1)WB 565 Sn()WB 245 Sn( Query Result Caching)EA()EH( + + )0 P(The Post)HY(greSQL)YH( ODB runtime imple)HY(men)HY(ta)HY(tion)YH( will always return a + cached query result \201)0 43 1 A(Section 4.4, "Query Result")43 0 TN TL()Ec /AF f D(\202 + even when explic)HY(itly)YH( requested not to. This is a limi)HY(ta)HY(tion)YH( of the + Post)HY(greSQL)YH( client library \201)SM(libpq)ES(\202 which does not + support uncached \201stream)HY(ing)YH(\202 query results.)EP( + + )0 3 241 H(19.5.2)WB 566 Sn()WB 246 Sn( Foreign Key Constraints)EA()EH( + + )0 P(ODB assumes the stan)HY(dard)YH( SQL behav)HY(ior)YH( which requires that + foreign key constraints check)HY(ing)YH( is deferred until the + trans)HY(ac)HY(tion)YH( is commit)HY(ted)YH(. Default Post)HY(greSQL)YH( behav)HY(ior)YH( is + to check such constraints imme)HY(di)HY(ately)YH(. As a result, when + used with ODB, a custom database schema that defines foreign + key constraints may need to declare such constraints as + )SM(INITIALLY DEFERRED)ES(, as shown in the follow)HY(ing)YH( example. + By default, schemas gener)HY(ated)YH( by the ODB compiler meet this require)HY(ment)YH( + auto)HY(mat)HY(i)HY(cally)YH(.)EP( + + ) 3 62 PR(CREATE TABLE Employee \201 + ... + employer BIGINT REFERENCES Employer\201id\202 INITIALLY DEFERRED\202;)RP( + + )0 P(You can over)HY(ride)YH( the default behav)HY(ior)YH( and instruct the ODB + compiler to gener)HY(ate)YH( non-deferrable foreign keys by spec)HY(i)HY(fy)HY(ing)YH( + the )SM(--fkeys-deferrable-mode not_deferrable)ES( ODB + compiler option. Note, however, that in this case the order in + which you persist, update, and erase objects within a trans)HY(ac)HY(tion)YH( + becomes impor)HY(tant)YH(.)EP( + + )0 3 242 H(19.5.3)WB 567 Sn()WB 247 Sn( Unique Constraint Viola)HY(tions)YH()EA()EH( + + )0 P(Due to the gran)HY(u)HY(lar)HY(ity)YH( of the Post)HY(greSQL)YH( error codes, it is impos)HY(si)HY(ble)YH( + to distin)HY(guish)YH( between the dupli)HY(cate)YH( primary key and other unique + constraint viola)HY(tions)YH(. As a result, when making an object persis)HY(tent)YH(, + the Post)HY(greSQL)YH( ODB runtime will trans)HY(late)YH( all unique constraint viola)HY(tion)YH( + errors to the )SM(object_already_persis)HY(tent)YH()ES( excep)HY(tion)YH( + \201)0 37 1 A(Section 3.14, "ODB Excep)HY(tions)YH(")37 0 TN TL()Ec /AF f D(\202.)EP( + + )0 3 243 H(19.5.4)WB 568 Sn()WB 248 Sn( Date-Time Format)EA()EH( + + )0 P(ODB expects the Post)HY(greSQL)YH( server to use inte)HY(gers)YH( as a binary + format for the date-time types, which is the default for most + Post)HY(greSQL)YH( config)HY(u)HY(ra)HY(tions)YH(. When creat)HY(ing)YH( a connec)HY(tion)YH(, ODB + exam)HY(ines)YH( the )SM(integer_date)HY(times)YH()ES( Post)HY(greSQL)YH( server + param)HY(e)HY(ter)YH( and if it is )SM(false)ES(, + )SM(odb::pgsql::database_excep)HY(tion)YH()ES( is thrown. You may + check the value of this param)HY(e)HY(ter)YH( for your server by execut)HY(ing)YH( + the follow)HY(ing)YH( SQL query:)EP( + + ) 1 22 PR(SHOW integer_datetimes)RP( + + )0 3 244 H(19.5.5)WB 569 Sn()WB 249 Sn( Time)HY(zones)YH()EA()EH( + + )0 P(ODB does not currently natively support the Post)HY(greSQL)YH( date-time types + with time)HY(zone)YH( infor)HY(ma)HY(tion)YH(. However, these types can be accessed by + mapping them to one of the natively supported types, as discussed + in )0 192 1 A(Section 14.8, "Database Type Mapping Pragmas")192 0 TN TL()Ec /AF f D(.)EP( + + )0 3 245 H(19.5.6)WB 570 Sn()WB 250 Sn( )SM(NUMERIC)ES( Type Support)EA()EH( + + )0 P(Support for the Post)HY(greSQL)YH( )SM(NUMERIC)ES( type is limited + to provid)HY(ing)YH( a binary buffer contain)HY(ing)YH( the binary repre)HY(sen)HY(ta)HY(tion)YH( + of the value. For more infor)HY(ma)HY(tion)YH( on the binary format used to + store )SM(NUMERIC)ES( values refer to the Post)HY(greSQL)YH( + docu)HY(men)HY(ta)HY(tion)YH(. An alter)HY(na)HY(tive)YH( approach to access)HY(ing)YH( )SM(NUMERIC)ES( + values is to map this type to one of the natively supported + ones, as discussed in )0 192 1 A(Section 14.8, "Database + Type Mapping Pragmas")192 0 TN TL()Ec /AF f D(.)EP( + + + )0 2 246 H(19.6)WB 571 Sn()WB 251 Sn( Post)HY(greSQL)YH( Index Defi)HY(ni)HY(tions)YH()EA()EH( + + )0 P(When the )SM(index)ES( pragma \201)0 191 1 A(Section 14.7, + "Index Defi)HY(ni)HY(tion)YH( Pragmas")191 0 TN TL()Ec /AF f D(\202 is used to define a Post)HY(greSQL)YH( index, + the )SM(type)ES( clause spec)HY(i)HY(fies)YH( the index type \201for example, + )SM(UNIQUE)ES(\202, the )SM(method)ES( clause spec)HY(i)HY(fies)YH( the + index method \201for example, )SM(BTREE)ES(, )SM(HASH)ES(, + )SM(GIN)ES(, etc.\202, and the )SM(options)ES( clause + spec)HY(i)HY(fies)YH( addi)HY(tional)YH( index options, such as storage param)HY(e)HY(ters)YH(, + table spaces, and the )SM(WHERE)ES( pred)HY(i)HY(cate)YH(. To support + the defi)HY(ni)HY(tion)YH( of concur)HY(rent)YH( indexes, the )SM(type)ES( + clause can end with the word )SM(CONCUR)HY(RENTLY)YH()ES( \201upper and + lower cases are recog)HY(nized)YH(\202. The column options can be used to + specify colla)HY(tions)YH(, oper)HY(a)HY(tor)YH( classes, and the sort order. For example:)EP( + + ) 13 47 PR(#pragma db object +class object +{ + ... + + std::string name_; + + #pragma db index \200 + type\201"UNIQUE CONCURRENTLY"\202 \200 + method\201"HASH"\202 \200 + member\201name_, "DESC"\202 \200 + options\201"WITH\201FILLFACTOR = 80\202"\202 +};)RP( + + )0 P(Index names in Post)HY(greSQL)YH( are schema-global. To avoid name clashes, + ODB auto)HY(mat)HY(i)HY(cally)YH( prefixes each index name with the table name on + which it is defined.)EP( + + + + + )WB NL NP( + )0 1 247 H(20)WB 572 Sn()WB 252 Sn( Oracle Database)EA()EH( + + )0 P(To gener)HY(ate)YH( support code for the Oracle database you will need + to pass the ")SM(--database\240oracle)ES(" + \201or ")SM(-d\240oracle)ES("\202 option to the ODB compiler. + Your appli)HY(ca)HY(tion)YH( will also need to link to the Oracle ODB runtime + library \201)SM(libodb-oracle)ES(\202. All Oracle-specific ODB + classes are defined in the )SM(odb::oracle)ES( names)HY(pace)YH(.)EP( + + )0 2 248 H(20.1)WB 573 Sn()WB 253 Sn( Oracle Type Mapping)EA()EH( + + )0 P(The follow)HY(ing)YH( table summa)HY(rizes)YH( the default mapping between basic + C++ value types and Oracle database types. This mapping can be + customized on the per-type and per-member basis using the ODB + Pragma Language \201)0 100 1 A(Chapter 14, "ODB Pragma + Language")100 0 TN TL()Ec /AF f D(\202.)EP( + + + )14 PT( + + )0 P(It is possi)HY(ble)YH( to map the )SM(char)ES( C++ type to an integer + database type \201for example, )SM(NUMBER\2013\202)ES(\202 using the + )SM(db\240type)ES( pragma \201)0 150 1 A(Section 14.4.3, + ")SM(type)ES(")150 0 TN TL()Ec /AF f D(\202.)EP( + + )0 P(In Oracle empty )SM(VARCHAR2)ES( and )SM(NVAR)HY(CHAR)YH(2)ES( + strings are repre)HY(sented)YH( as a )SM(NULL)ES( value. As a result, + columns of the )SM(std::string)ES( and )SM(char[N])ES( + types are by default declared as )SM(NULL)ES( except for + primary key columns. However, you can over)HY(ride)YH( this by explic)HY(itly)YH( + declar)HY(ing)YH( such columns as )SM(NOT NULL)ES( with the + )SM(db\240not_null)ES( pragma \201)0 153 1 A(Section + 14.4.6, ")SM(null/not_null)ES(")153 0 TN TL()Ec /AF f D(\202. This also means that for + object ids that are mapped to these Oracle types, an empty string is + an invalid value.)EP( + + )0 P(Addi)HY(tion)HY(ally)YH(, by default, C++ enums and C++11 enum classes are + auto)HY(mat)HY(i)HY(cally)YH( mapped to the Oracle types corre)HY(spond)HY(ing)YH( to their + under)HY(ly)HY(ing)YH( inte)HY(gral)YH( types \201see table above\202. The default + )SM(NULL)ES( seman)HY(tics)YH( is )SM(NOT NULL)ES(. For + example:)EP( + + ) 17 54 PR(enum color {red, green, blue}; +enum class taste: unsigned char +{ + bitter = 1, + sweet, + sour = 4, + salty +}; + +#pragma db object +class object +{ + ... + + color color_; // Automatically mapped to NUMBER\20110\202. + taste taste_; // Automatically mapped to NUMBER\2013\202. +};)RP( + + )0 P(It is also possi)HY(ble)YH( to add support for addi)HY(tional)YH( Oracle types, + such as )SM(XML)ES(, geospa)HY(tial)YH( types, user-defined types, + and collec)HY(tions)YH( \201arrays, table types\202. For more infor)HY(ma)HY(tion)YH(, refer to + )0 192 1 A(Section 14.8, "Database Type Mapping + Pragmas")192 0 TN TL()Ec /AF f D(.)EP( + + )0 3 249 H(20.1.1)WB 574 Sn()WB 254 Sn( String Type Mapping)EA()EH( + + )0 P(The Oracle ODB runtime library provides support for mapping the + )SM(std::string)ES(, )SM(char[N])ES(, and + )SM(std::array)ES( types to the Oracle )SM(CHAR)ES(, + )SM(VARCHAR2)ES(, )SM(CLOB)ES(, )SM(NCHAR)ES(, + )SM(NVAR)HY(CHAR)YH(2)ES(, and )SM(NCLOB)ES( types. However, + these mappings are not enabled by default \201in partic)HY(u)HY(lar)YH(, by + default, )SM(std::array)ES( will be treated as a container\202. + To enable the alter)HY(na)HY(tive)YH( mappings for these types we need to + specify the database type explic)HY(itly)YH( using the )SM(db\240type)ES( + pragma \201)0 150 1 A(Section 14.4.3, ")SM(type)ES(")150 0 TN TL()Ec /AF f D(\202, + for example:)EP( + + ) 14 39 PR(#pragma db object +class object +{ + ... + + #pragma db type \201"CHAR\2012\202"\202 + char state_[2]; + + #pragma db type \201"VARCHAR\201128\202"\202 null + std::string name_; + + #pragma db type \201"CLOB"\202 + std::string text_; +};)RP( + + )0 P(Alter)HY(na)HY(tively)YH(, this can be done on the per-type basis, for example:)EP( + + ) 12 55 PR(#pragma db value\201std::string\202 type\201"VARCHAR\201128\202"\202 null + +#pragma db object +class object +{ + ... + + std::string name_; // Mapped to VARCHAR\201128\202. + + #pragma db type \201"CLOB"\202 + std::string text_; // Mapped to CLOB. +};)RP( + + )0 P(The )SM(char[N])ES( and )SM(std::array)ES( values + may or may not be zero-termi)HY(nated)YH(. When extract)HY(ing)YH( such values from the + database, ODB will append the zero termi)HY(na)HY(tor)YH( if there is enough + space.)EP( + + )0 3 250 H(20.1.2)WB 575 Sn()WB 255 Sn( Binary Type Mapping)EA()EH( + + )0 P(The Oracle ODB runtime library provides support for mapping the + )SM(std::vector)ES(, + )SM(std::vector)ES(, + )SM(char[N])ES(, )SM(unsigned\240char[N])ES(, + )SM(std::array)ES(, and + )SM(std::array)ES( + types to the Oracle )SM(BLOB)ES( and )SM(RAW)ES( types. + However, these mappings are not enabled by default \201in partic)HY(u)HY(lar)YH(, by + default, )SM(std::vector)ES( and )SM(std::array)ES( will be + treated as contain)HY(ers)YH(\202. To enable the alter)HY(na)HY(tive)YH( mappings for these + types we need to specify the database type explic)HY(itly)YH( using the + )SM(db\240type)ES( pragma \201)0 150 1 A(Section 14.4.3, + ")SM(type)ES(")150 0 TN TL()Ec /AF f D(\202, for example:)EP( + + ) 11 28 PR(#pragma db object +class object +{ + ... + + #pragma db type\201"BLOB"\202 + std::vector buf_; + + #pragma db type\201"RAW\20116\202"\202 + unsigned char uuid_[16]; +};)RP( + + )0 P(Alter)HY(na)HY(tively)YH(, this can be done on the per-type basis, for example:)EP( + + ) 10 37 PR(typedef std::vector buffer; +#pragma db value\201buffer\202 type\201"BLOB"\202 + +#pragma db object +class object +{ + ... + + buffer buf_; // Mapped to BLOB. +};)RP( + + )0 P(Note also that in native queries \201)0 38 1 A(Chapter 4, "Query)HY(ing)YH( + the Database")38 0 TN TL()Ec /AF f D(\202 )SM(char[N])ES( and + )SM(std::array)ES( param)HY(e)HY(ters)YH( are by default passed + as a string rather than a binary. To pass such param)HY(e)HY(ters)YH( as a binary, + we need to specify the database type explic)HY(itly)YH( in the + )SM(_val\201\202)ES(/)SM(_ref\201\202)ES( calls. Note also that we + don't need to do this for the inte)HY(grated)YH( queries, for example:)EP( + + ) 4 68 PR(char u[16] = {...}; + +db.query \201"uuid = " + query::_val \201u\202\202; +db.query \201query::uuid == query::_ref \201u\202\202;)RP( + + )0 2 251 H(20.2)WB 576 Sn()WB 256 Sn( Oracle Database Class)EA()EH( + + )0 P(The Oracle )SM(database)ES( class encap)HY(su)HY(lates)YH( the OCI envi)HY(ron)HY(ment)YH( + handle as well as the database connec)HY(tion)YH( string and user creden)HY(tials)YH( + that are used to estab)HY(lish)YH( connec)HY(tions)YH( to the database. It has the + follow)HY(ing)YH( inter)HY(face)YH(:)EP( + + ) 70 64 PR(namespace odb +{ + namespace oracle + { + class database: public odb::database + { + public: + database \201const std::string& user, + const std::string& password, + const std::string& db, + ub2 charset = 0, + ub2 ncharset = 0, + OCIEnv* environment = 0, + std::[auto|unique]_ptr = 0\202; + + database \201const std::string& user, + const std::string& password, + const std::string& service, + const std::string& host, + unsigned int port = 0, + ub2 charset = 0, + ub2 ncharset = 0, + OCIEnv* environment = 0, + std::[auto|unique]_ptr = 0\202; + + database \201int& argc, + char* argv[], + bool erase = false, + ub2 charset = 0, + ub2 ncharset = 0, + OCIEnv* environment = 0,)WR( + std::[auto|unique]_ptr = 0\202; + + static void + print_usage \201std::ostream&\202; + + public: + const std::string& + user \201\202 const; + + const std::string& + password \201\202 const; + + const std::string& + db \201\202 const; + + const std::string& + service \201\202 const; + + const std::string& + host \201\202 const; + + unsigned int + port \201\202 const; + + ub2 + charset \201\202 const; + + ub2 + ncharset \201\202 const; +)WR( + OCIEnv* + environment \201\202; + + public: + connection_ptr + connection \201\202; + }; + } +})RP( + + )0 P(You will need to include the )SM()ES( + header file to make this class avail)HY(able)YH( in your appli)HY(ca)HY(tion)YH(.)EP( + + )0 P(The over)HY(loaded)YH( )SM(database)ES( construc)HY(tors)YH( allow us to specify the + Oracle database param)HY(e)HY(ters)YH( that should be used when connect)HY(ing)YH( to the + database. The )SM(db)ES( argu)HY(ment)YH( in the first construc)HY(tor)YH( is a + connec)HY(tion)YH( iden)HY(ti)HY(fier)YH( that spec)HY(i)HY(fies)YH( the database to connect to. For more + infor)HY(ma)HY(tion)YH( on the format of the connec)HY(tion)YH( iden)HY(ti)HY(fier)YH(, refer to the + Oracle docu)HY(men)HY(ta)HY(tion)YH(.)EP( + + )0 P(The second construc)HY(tor)YH( allows us to specify the indi)HY(vid)HY(ual)YH( compo)HY(nents)YH( + of a connec)HY(tion)YH( iden)HY(ti)HY(fier)YH( as the )SM(service)ES(, )SM(host)ES(, + and )SM(port)ES( argu)HY(ments)YH(. If the )SM(host)ES( argu)HY(ment)YH( is + empty, then local)HY(host)YH( is used by default. Simi)HY(larly)YH(, if the + )SM(port)ES( argu)HY(ment)YH( is zero, then the default port is used.)EP( + + )0 P(The last construc)HY(tor)YH( extracts the database param)HY(e)HY(ters)YH( + from the command line. The follow)HY(ing)YH( options are recog)HY(nized)YH(:)EP( + + ) 7 25 PR( --user + --password + --database + --service + --host + --port + --options-file )RP( + + )0 P(The )SM(--options-file)ES( option allows us to specify some + or all of the database options in a file with each option appear)HY(ing)YH( + on a sepa)HY(rate)YH( line followed by a space and an option value. Note that it + is invalid to specify the )SM(--database)ES( option + together with )SM(--service)ES(, )SM(--host)ES(, or + )SM(--port)ES( options.)EP( + + )0 P(If the )SM(erase)ES( argu)HY(ment)YH( to this construc)HY(tor)YH( is true, + then the above options are removed from the )SM(argv)ES( + array and the )SM(argc)ES( count is updated accord)HY(ingly)YH(. + This is primar)HY(ily)YH( useful if your appli)HY(ca)HY(tion)YH( accepts other + options or argu)HY(ments)YH( and you would like to get the Oracle + options out of the )SM(argv)ES( array.)EP( + + )0 P(This construc)HY(tor)YH( throws the )SM(odb::oracle::cli_excep)HY(tion)YH()ES( + excep)HY(tion)YH( if the Oracle option values are missing or invalid. See section + )0 258 1 A(Section 20.4, "Oracle Excep)HY(tions)YH(")258 0 TN TL()Ec /AF f D( for more + infor)HY(ma)HY(tion)YH( on this excep)HY(tion)YH(.)EP( + + )0 P(The static )SM(print_usage\201\202)ES( func)HY(tion)YH( prints the list of options + with short descrip)HY(tions)YH( that are recog)HY(nized)YH( by this construc)HY(tor)YH(.)EP( + + )0 P(Addi)HY(tion)HY(ally)YH(, all the construc)HY(tors)YH( have the )SM(charset)ES(, + )SM(ncharset)ES(, and )SM(envi)HY(ron)HY(ment)YH()ES( argu)HY(ments)YH(. + The )SM(charset)ES( argu)HY(ment)YH( spec)HY(i)HY(fies)YH( the client-side database + char)HY(ac)HY(ter)YH( encod)HY(ing)YH(. Char)HY(ac)HY(ter)YH( data corre)HY(spond)HY(ing)YH( to the )SM(CHAR)ES(, + )SM(VARCHAR2)ES(, and )SM(CLOB)ES( types will be deliv)HY(ered)YH( + to and received from the appli)HY(ca)HY(tion)YH( in this encod)HY(ing)YH(. Simi)HY(larly)YH(, + the )SM(ncharset)ES( argu)HY(ment)YH( spec)HY(i)HY(fies)YH( the client-side national + char)HY(ac)HY(ter)YH( encod)HY(ing)YH(. Char)HY(ac)HY(ter)YH( data corre)HY(spond)HY(ing)YH( to the )SM(NCHAR)ES(, + )SM(NVAR)HY(CHAR)YH(2)ES(, and )SM(NCLOB)ES( types will be deliv)HY(ered)YH( + to and received from the appli)HY(ca)HY(tion)YH( in this encod)HY(ing)YH(. For the complete + list of avail)HY(able)YH( char)HY(ac)HY(ter)YH( encod)HY(ing)YH( values, refer to the Oracle + docu)HY(men)HY(ta)HY(tion)YH(. Commonly used encod)HY(ing)YH( values are )SM(873)ES( + \201UTF-8\202, )SM(31)ES( \201ISO-8859-1\202, and )SM(1000)ES( \201UTF-16\202. + If the database char)HY(ac)HY(ter)YH( encod)HY(ing)YH( is not spec)HY(i)HY(fied)YH(, then the + )SM(NLS_LANG)ES( envi)HY(ron)HY(ment)YH(/registry vari)HY(able)YH( is used. Simi)HY(larly)YH(, + if the national char)HY(ac)HY(ter)YH( encod)HY(ing)YH( is not spec)HY(i)HY(fied)YH(, then the + )SM(NLS_NCHAR)ES( envi)HY(ron)HY(ment)YH(/registry vari)HY(able)YH( is used. For more + infor)HY(ma)HY(tion)YH( on char)HY(ac)HY(ter)YH( encod)HY(ings)YH(, refer to the + )SM(OCIEn)HY(vNlsCre)HY(ate)YH(\201\202)ES( func)HY(tion)YH( in the Oracle Call Inter)HY(face)YH( + \201OCI\202 docu)HY(men)HY(ta)HY(tion)YH(.)EP( + + )0 P(The )SM(envi)HY(ron)HY(ment)YH()ES( argu)HY(ment)YH( allows us to provide a custom + OCI envi)HY(ron)HY(ment)YH( handle. If this argu)HY(ment)YH( is not )SM(NULL)ES(, + then the passed handle is used in all the OCI func)HY(tion)YH( calls made + by this )SM(database)ES( class instance. Note also that the + )SM(database)ES( instance does not assume owner)HY(ship)YH( of the + passed envi)HY(ron)HY(ment)YH( handle and this handle should be valid for + the life)HY(time)YH( of the )SM(database)ES( instance. If a custom + envi)HY(ron)HY(ment)YH( handle is used, then the )SM(charset)ES( and + )SM(ncharset)ES( argu)HY(ments)YH( have no effect.)EP( + + )0 P(The last argu)HY(ment)YH( to all of the construc)HY(tors)YH( is a pointer to the + connec)HY(tion)YH( factory. In C++98/03, it is )SM(std::auto_ptr)ES( while + in C++11 )SM(std::unique_ptr)ES( is used instead. If we pass a + non-)SM(NULL)ES( value, the database instance assumes owner)HY(ship)YH( + of the factory instance. The connec)HY(tion)YH( factory inter)HY(face)YH( as well as + the avail)HY(able)YH( imple)HY(men)HY(ta)HY(tions)YH( are described in the next section.)EP( + + )0 P(The set of acces)HY(sor)YH( func)HY(tions)YH( follow)HY(ing)YH( the construc)HY(tors)YH( allows us + to query the param)HY(e)HY(ters)YH( of the )SM(database)ES( instance.)EP( + + )0 P(The )SM(connec)HY(tion)YH(\201\202)ES( func)HY(tion)YH( returns a pointer to the + Oracle database connec)HY(tion)YH( encap)HY(su)HY(lated)YH( by the + )SM(odb::oracle::connec)HY(tion)YH()ES( class. For more infor)HY(ma)HY(tion)YH( + on )SM(oracle::connec)HY(tion)YH()ES(, refer to )0 257 1 A(Section + 20.3, "Oracle Connec)HY(tion)YH( and Connec)HY(tion)YH( Factory")257 0 TN TL()Ec /AF f D(.)EP( + + )0 2 252 H(20.3)WB 577 Sn()WB 257 Sn( Oracle Connec)HY(tion)YH( and Connec)HY(tion)YH( Factory)EA()EH( + + )0 P(The )SM(oracle::connec)HY(tion)YH()ES( class has the follow)HY(ing)YH( inter)HY(face)YH(:)EP( + + ) 23 59 PR(namespace odb +{ + namespace oracle + { + class connection: public odb::connection + { + public: + connection \201database&\202; + connection \201database&, OCISvcCtx*\202; + + OCISvcCtx* + handle \201\202; + + OCIError* + error_handle \201\202; + + details::buffer& + lob_buffer \201\202; + }; + + typedef details::shared_ptr connection_ptr; + } +})RP( + + )0 P(For more infor)HY(ma)HY(tion)YH( on the )SM(odb::connec)HY(tion)YH()ES( inter)HY(face)YH(, refer + to )0 29 1 A(Section 3.6, "Connec)HY(tions)YH(")29 0 TN TL()Ec /AF f D(. The first over)HY(loaded)YH( + )SM(oracle::connec)HY(tion)YH()ES( construc)HY(tor)YH( creates a new OCI service + context. The OCI state)HY(ment)YH( caching is enabled for the under)HY(ly)HY(ing)YH( session + while the OCI connec)HY(tion)YH( pooling and session pooling are not used. The + second construc)HY(tor)YH( allows us to create a )SM(connec)HY(tion)YH()ES( instance by + provid)HY(ing)YH( an already connected Oracle service context. Note that the + )SM(connec)HY(tion)YH()ES( instance assumes owner)HY(ship)YH( of this handle. The + )SM(handle\201\202)ES( acces)HY(sor)YH( returns the OCI service context handle + asso)HY(ci)HY(ated)YH( with the )SM(connec)HY(tion)YH()ES( instance.)EP( + + )0 P(An OCI error handle is allo)HY(cated)YH( for each )SM(connec)HY(tion)YH()ES( + instance and is avail)HY(able)YH( via the )SM(error_handle\201\202)ES( acces)HY(sor)YH( + func)HY(tion)YH(.)EP( + + )0 P(Addi)HY(tion)HY(ally)YH(, each )SM(connec)HY(tion)YH()ES( instance main)HY(tains)YH( a large + object \201LOB\202 buffer. This buffer is used by the Oracle ODB runtime + as an inter)HY(me)HY(di)HY(ate)YH( storage for piece)HY(wise)YH( handling of LOB data. + By default, the LOB buffer has zero initial capac)HY(ity)YH( and is + expanded to 4096 bytes when the first LOB oper)HY(a)HY(tion)YH( is performed. + If your appli)HY(ca)HY(tion)YH( requires a bigger or smaller LOB buffer, you can + specify a custom capac)HY(ity)YH( using the )SM(lob_buffer\201\202)ES( + acces)HY(sor)YH(.)EP( + + )0 P(The )SM(oracle::connec)HY(tion)YH(_factory)ES( abstract class has the + follow)HY(ing)YH( inter)HY(face)YH(:)EP( + + ) 15 31 PR(namespace odb +{ + namespace oracle + { + class connection_factory + { + public: + virtual void + database \201database&\202 = 0; + + virtual connection_ptr + connect \201\202 = 0; + }; + } +})RP( + + )0 P(The )SM(database\201\202)ES( func)HY(tion)YH( is called when a connec)HY(tion)YH( + factory is asso)HY(ci)HY(ated)YH( with a database instance. This happens in + the )SM(odb::oracle::database)ES( class construc)HY(tors)YH(. The + )SM(connect\201\202)ES( func)HY(tion)YH( is called when)HY(ever)YH( a database + connec)HY(tion)YH( is requested.)EP( + + )0 P(The two imple)HY(men)HY(ta)HY(tions)YH( of the )SM(connec)HY(tion)YH(_factory)ES( + inter)HY(face)YH( provided by the Oracle ODB runtime are + )SM(new_connec)HY(tion)YH(_factory)ES( and + )SM(connec)HY(tion)YH(_pool_factory)ES(. You will need to include + the )SM()ES( + header file to make the )SM(connec)HY(tion)YH(_factory)ES( inter)HY(face)YH( + and these imple)HY(men)HY(ta)HY(tion)YH( classes avail)HY(able)YH( in your appli)HY(ca)HY(tion)YH(.)EP( + + )0 P(The )SM(new_connec)HY(tion)YH(_factory)ES( class creates a new + connec)HY(tion)YH( when)HY(ever)YH( one is requested. When a connec)HY(tion)YH( is no + longer needed, it is released and closed. The + )SM(new_connec)HY(tion)YH(_factory)ES( class has the follow)HY(ing)YH( + inter)HY(face)YH(:)EP( + + ) 10 59 PR(namespace odb +{ + namespace oracle + { + class new_connection_factory: public connection_factory + { + public: + new_connection_factory \201\202; + }; +};)RP( + + )0 P(The )SM(connec)HY(tion)YH(_pool_factory)ES( class imple)HY(ments)YH( a + connec)HY(tion)YH( pool. It has the follow)HY(ing)YH( inter)HY(face)YH(:)EP( + + ) 24 75 PR(namespace odb +{ + namespace oracle + { + class connection_pool_factory: public connection_factory + { + public: + connection_pool_factory \201std::size_t max_connections = 0, + std::size_t min_connections = 0\202; + + protected: + class pooled_connection: public connection + { + public: + pooled_connection \201database_type&\202; + pooled_connection \201database_type&, OCISvcCtx*\202; + }; + + typedef details::shared_ptr pooled_connection_ptr; + + virtual pooled_connection_ptr + create \201\202; + }; +};)RP( + + )0 P(The )SM(max_connec)HY(tions)YH()ES( argu)HY(ment)YH( in the + )SM(connec)HY(tion)YH(_pool_factory)ES( construc)HY(tor)YH( spec)HY(i)HY(fies)YH( the maximum + number of concur)HY(rent)YH( connec)HY(tions)YH( that this pool factory will + main)HY(tain)YH(. Simi)HY(larly)YH(, the )SM(min_connec)HY(tions)YH()ES( argu)HY(ment)YH( + spec)HY(i)HY(fies)YH( the minimum number of avail)HY(able)YH( connec)HY(tions)YH( that + should be kept open.)EP( + + )0 P(When)HY(ever)YH( a connec)HY(tion)YH( is requested, the pool factory first + checks if there is an unused connec)HY(tion)YH( that can be returned. + If there is none, the pool factory checks the + )SM(max_connec)HY(tions)YH()ES( value to see if a new connec)HY(tion)YH( + can be created. If the total number of connec)HY(tions)YH( main)HY(tained)YH( + by the pool is less than this value, then a new connec)HY(tion)YH( is + created and returned. Other)HY(wise)YH(, the caller is blocked until + a connec)HY(tion)YH( becomes avail)HY(able)YH(.)EP( + + )0 P(When a connec)HY(tion)YH( is released, the pool factory first checks + if there are blocked callers waiting for a connec)HY(tion)YH(. If so, then + one of them is unblocked and is given the connec)HY(tion)YH(. Other)HY(wise)YH(, + the pool factory checks whether the total number of connec)HY(tions)YH( + main)HY(tained)YH( by the pool is greater than the )SM(min_connec)HY(tions)YH()ES( + value. If that's the case, the connec)HY(tion)YH( is closed. Other)HY(wise)YH(, the + connec)HY(tion)YH( is added to the pool of avail)HY(able)YH( connec)HY(tions)YH( to be + returned on the next request. In other words, if the number of + connec)HY(tions)YH( main)HY(tained)YH( by the pool exceeds )SM(min_connec)HY(tions)YH()ES( + and there are no callers waiting for a new connec)HY(tion)YH(, + the pool will close the excess connec)HY(tions)YH(.)EP( + + )0 P(If the )SM(max_connec)HY(tions)YH()ES( value is 0, then the pool will + create a new connec)HY(tion)YH( when)HY(ever)YH( all of the exist)HY(ing)YH( connec)HY(tions)YH( + are in use. If the )SM(min_connec)HY(tions)YH()ES( value is 0, then + the pool will never close a connec)HY(tion)YH( and instead main)HY(tain)YH( all + the connec)HY(tions)YH( that were ever created.)EP( + + )0 P(The )SM(create\201\202)ES( virtual func)HY(tion)YH( is called when)HY(ever)YH( the + pool needs to create a new connec)HY(tion)YH(. By deriv)HY(ing)YH( from the + )SM(connec)HY(tion)YH(_pool_factory)ES( class and over)HY(rid)HY(ing)YH( this + func)HY(tion)YH( we can imple)HY(ment)YH( custom connec)HY(tion)YH( estab)HY(lish)HY(ment)YH( + and config)HY(u)HY(ra)HY(tion)YH(.)EP( + + )0 P(If you pass )SM(NULL)ES( as the connec)HY(tion)YH( factory to one of the + )SM(database)ES( construc)HY(tors)YH(, then the + )SM(connec)HY(tion)YH(_pool_factory)ES( instance will be created by default + with the min and max connec)HY(tions)YH( values set to )SM(0)ES(. The + follow)HY(ing)YH( code frag)HY(ment)YH( shows how we can pass our own connec)HY(tion)YH( factory + instance:)EP( + + ) 14 58 PR(#include + +#include +#include + +int +main \201int argc, char* argv[]\202 +{ + auto_ptr f \201 + new odb::oracle::connection_pool_factory \20120\202\202; + + auto_ptr db \201 + new oracle::database \201argc, argv, false, 0, 0, 0, f\202\202; +})RP( + + )0 2 253 H(20.4)WB 578 Sn()WB 258 Sn( Oracle Excep)HY(tions)YH()EA()EH( + + )0 P(The Oracle ODB runtime library defines the follow)HY(ing)YH( + Oracle-specific excep)HY(tions)YH(:)EP( + + ) 50 53 PR(namespace odb +{ + namespace oracle + { + class database_exception: odb::database_exception + { + public: + class record + { + public: + sb4 + error \201\202 const; + + const std::string& + message \201\202 const; + }; + + typedef std::vector records; + + typedef records::size_type size_type; + typedef records::const_iterator iterator; + + iterator + begin \201\202 const; + + iterator + end \201\202 const; + + size_type + size \201\202 const; +)WR( + virtual const char* + what \201\202 const throw \201\202; + }; + + class cli_exception: odb::exception + { + public: + virtual const char* + what \201\202 const throw \201\202; + }; + + class invalid_oci_handle: odb::exception + { + public: + virtual const char* + what \201\202 const throw \201\202; + }; + } +})RP( + + )0 P(You will need to include the )SM()ES( + header file to make these excep)HY(tions)YH( avail)HY(able)YH( in your appli)HY(ca)HY(tion)YH(.)EP( + + )0 P(The )SM(odb::oracle::database_excep)HY(tion)YH()ES( is thrown if + an Oracle database oper)HY(a)HY(tion)YH( fails. The Oracle-specific error + infor)HY(ma)HY(tion)YH( is stored as a series of records, each contain)HY(ing)YH( + the error code as a signed 4-byte integer and the message string. + All this infor)HY(ma)HY(tion)YH( is also combined and returned in a + human-read)HY(able)YH( form by the )SM(what\201\202)ES( func)HY(tion)YH(.)EP( + + )0 P(The )SM(odb::oracle::cli_excep)HY(tion)YH()ES( is thrown by the + command line parsing construc)HY(tor)YH( of the )SM(odb::oracle::database)ES( + class if the Oracle option values are missing or invalid. The + )SM(what\201\202)ES( func)HY(tion)YH( returns a human-read)HY(able)YH( descrip)HY(tion)YH( + of an error.)EP( + + )0 P(The )SM(odb::oracle::invalid_oci_handle)ES( is thrown if an + invalid handle is passed to an OCI func)HY(tion)YH( or if an OCI func)HY(tion)YH( + was unable to allo)HY(cate)YH( a handle. The former normally indi)HY(cates)YH( + a program)HY(ming)YH( error while the latter indi)HY(cates)YH( an out of memory + condi)HY(tion)YH(. The )SM(what\201\202)ES( func)HY(tion)YH( returns a human-read)HY(able)YH( + descrip)HY(tion)YH( of an error.)EP( + + )0 2 254 H(20.5)WB 579 Sn()WB 259 Sn( Oracle Limi)HY(ta)HY(tions)YH()EA()EH( + + )0 P(The follow)HY(ing)YH( sections describe Oracle-specific limi)HY(ta)HY(tions)YH( imposed + by the current Oracle and ODB runtime versions.)EP( + + )0 3 255 H(20.5.1)WB 580 Sn()WB 260 Sn( Iden)HY(ti)HY(fier)YH( Trun)HY(ca)HY(tion)YH()EA()EH( + + )0 P(Oracle limits the length of database iden)HY(ti)HY(fiers)YH( \201table, column, etc., + names\202 to 30 char)HY(ac)HY(ters)YH(. The ODB compiler auto)HY(mat)HY(i)HY(cally)YH( trun)HY(cates)YH( + any iden)HY(ti)HY(fier)YH( that is longer than 30 char)HY(ac)HY(ters)YH(. This, however, + can lead to dupli)HY(cate)YH( names. A common symptom of this problem + are errors during the database schema creation indi)HY(cat)HY(ing)YH( + that a database object with the same name already exists. To + resolve this problem we can assign custom, shorter iden)HY(ti)HY(fiers)YH( + using the )SM(db\240table)ES( and )SM(db\240column)ES( + pragmas \201)0 100 1 A(Chapter 14, "ODB Pragma Language"\202)100 0 TN TL()Ec /AF f D(. For + example:)EP( + + ) 8 37 PR(#pragma db object +class long_class_name +{ + ... + + std::vector long_container_x_; + std::vector long_container_y_; +};)RP( + + )0 P(In the above example, the names of the two container tables will be + )SM(long_class_name_long_container_x_)ES( and + )SM(long_class_name_long_container_y_)ES(. However, when + trun)HY(cated)YH( to 30 char)HY(ac)HY(ters)YH(, they both become + )SM(long_class_name_long_container)ES(. To resolve this + colli)HY(sion)YH( we can assign a custom table name for each container:)EP( + + ) 11 44 PR(#pragma db object +class long_class_name +{ + ... + + #pragma db table\201"long_class_name_cont_x"\202 + std::vector long_container_x_; + + #pragma db table\201"long_class_name_cont_y"\202 + std::vector long_container_y_; +};)RP( + + )0 3 256 H(20.5.2)WB 581 Sn()WB 261 Sn( Query Result Caching)EA()EH( + + )0 P(Oracle ODB runtime imple)HY(men)HY(ta)HY(tion)YH( does not perform query result caching + \201)0 43 1 A(Section 4.4, "Query Result")43 0 TN TL()Ec /AF f D(\202 even when explic)HY(itly)YH( + requested. The OCI API supports inter)HY(leav)HY(ing)YH( execu)HY(tion)YH( of multi)HY(ple)YH( + prepared state)HY(ments)YH( on a single connec)HY(tion)YH(. As a result, with OCI, + it is possi)HY(ble)YH( to have multi)HY(ple)YH( uncached results and calls to other + database func)HY(tions)YH( do not inval)HY(i)HY(date)YH( them. The only limi)HY(ta)HY(tion)YH( of + the uncached Oracle results is the unavail)HY(abil)HY(ity)YH( of the + )SM(result::size\201\202)ES( func)HY(tion)YH(. If you call this func)HY(tion)YH( on + an Oracle query result, then the )SM(odb::result_not_cached)ES( + excep)HY(tion)YH( \201)0 37 1 A(Section 3.14, "ODB Excep)HY(tions)YH(")37 0 TN TL()Ec /AF f D(\202 is + always thrown. Future versions of the Oracle ODB runtime library + may add support for result caching.)EP( + + )0 3 257 H(20.5.3)WB 582 Sn()WB 262 Sn( Foreign Key Constraints)EA()EH( + + )0 P(ODB assumes the stan)HY(dard)YH( SQL behav)HY(ior)YH( which requires that + foreign key constraints check)HY(ing)YH( is deferred until the + trans)HY(ac)HY(tion)YH( is commit)HY(ted)YH(. Default Oracle behav)HY(ior)YH( is + to check such constraints imme)HY(di)HY(ately)YH(. As a result, when + used with ODB, a custom database schema that defines foreign + key constraints may need to declare such constraints as + )SM(INITIALLY DEFERRED)ES(, as shown in the follow)HY(ing)YH( example. + By default, schemas gener)HY(ated)YH( by the ODB compiler meet this require)HY(ment)YH( + auto)HY(mat)HY(i)HY(cally)YH(.)EP( + + ) 4 45 PR(CREATE TABLE Employee \201 + ... + employer NUMBER\20120\202 REFERENCES Employer\201id\202 + DEFERRABLE INITIALLY DEFERRED\202;)RP( + + )0 P(You can over)HY(ride)YH( the default behav)HY(ior)YH( and instruct the ODB + compiler to gener)HY(ate)YH( non-deferrable foreign keys by spec)HY(i)HY(fy)HY(ing)YH( + the )SM(--fkeys-deferrable-mode not_deferrable)ES( ODB + compiler option. Note, however, that in this case the order in + which you persist, update, and erase objects within a trans)HY(ac)HY(tion)YH( + becomes impor)HY(tant)YH(.)EP( + + )0 3 258 H(20.5.4)WB 583 Sn()WB 263 Sn( Unique Constraint Viola)HY(tions)YH()EA()EH( + + )0 P(Due to the gran)HY(u)HY(lar)HY(ity)YH( of the Oracle error codes, it is impos)HY(si)HY(ble)YH( + to distin)HY(guish)YH( between the dupli)HY(cate)YH( primary key and other unique + constraint viola)HY(tions)YH(. As a result, when making an object persis)HY(tent)YH(, + the Oracle ODB runtime will trans)HY(late)YH( all unique constraint viola)HY(tion)YH( + errors to the )SM(object_already_persis)HY(tent)YH()ES( excep)HY(tion)YH( + \201)0 37 1 A(Section 3.14, "ODB Excep)HY(tions)YH(")37 0 TN TL()Ec /AF f D(\202.)EP( + + )0 3 259 H(20.5.5)WB 584 Sn()WB 264 Sn( Large )SM(FLOAT)ES( and + )SM(NUMBER)ES( Types)EA()EH( + + )0 P(The Oracle )SM(FLOAT)ES( type with a binary preci)HY(sion)YH( greater + than 53 and fixed-point )SM(NUMBER)ES( type with a decimal + preci)HY(sion)YH( greater than 15 cannot be auto)HY(mat)HY(i)HY(cally)YH( extracted + into the C++ )SM(float)ES( and )SM(double)ES( types. + Instead, the Oracle ODB runtime uses a 21-byte buffer contain)HY(ing)YH( + the binary repre)HY(sen)HY(ta)HY(tion)YH( of a value as an image type for such + )SM(FLOAT)ES( and )SM(NUMBER)ES( types. In order to + convert them into an appli)HY(ca)HY(tion)YH(-specific large number repre)HY(sen)HY(ta)HY(tion)YH(, + you will need to provide a suit)HY(able)YH( )SM(value_traits)ES( + template special)HY(iza)HY(tion)YH(. For more infor)HY(ma)HY(tion)YH( on the binary format + used to store the )SM(FLOAT)ES( and )SM(NUMBER)ES( values, + refer to the Oracle Call Inter)HY(face)YH( \201OCI\202 docu)HY(men)HY(ta)HY(tion)YH(.)EP( + + )0 P(An alter)HY(na)HY(tive)YH( approach to access)HY(ing)YH( large )SM(FLOAT)ES( and + )SM(NUMBER)ES( values is to map these type to one of the + natively supported ones, as discussed in )0 192 1 A(Section + 14.8, "Database Type Mapping Pragmas")192 0 TN TL()Ec /AF f D(.)EP( + + )0 P(Note that a )SM(NUMBER)ES( type that is used to repre)HY(sent)YH( a + float)HY(ing)YH( point number \201declared by spec)HY(i)HY(fy)HY(ing)YH( )SM(NUMBER)ES( + without any range and scale\202 can be extracted into the C++ + )SM(float)ES( and )SM(double)ES( types.)EP( + + )0 3 260 H(20.5.6)WB 585 Sn()WB 265 Sn( Time)HY(zones)YH()EA()EH( + + )0 P(ODB does not currently support the Oracle date-time types with time)HY(zone)YH( + infor)HY(ma)HY(tion)YH(. However, these types can be accessed by mapping them to + one of the natively supported types, as discussed in + )0 192 1 A(Section 14.8, "Database Type Mapping Pragmas")192 0 TN TL()Ec /AF f D(.)EP( + + )0 3 261 H(20.5.7)WB 586 Sn()WB 266 Sn( )SM(LONG)ES( Types)EA()EH( + + )0 P(ODB does not support the depre)HY(cated)YH( Oracle )SM(LONG)ES( and + )SM(LONG RAW)ES( data types. However, these types can be accessed + by mapping them to one of the natively supported types, as discussed + in )0 192 1 A(Section 14.8, "Database Type Mapping Pragmas")192 0 TN TL()Ec /AF f D(.)EP( + + )0 3 262 H(20.5.8)WB 587 Sn()WB 267 Sn( LOB Types and By-Value Acces)HY(sors)YH(/Modi)HY(fiers)YH()EA()EH( + + )0 P(As discussed in )0 152 1 A(Section 14.4.5, + ")SM(get)ES(/)SM(set)ES(/)SM(access)ES(")152 0 TN TL()Ec /AF f D(, by-value + acces)HY(sor)YH( and modi)HY(fier)YH( expres)HY(sions)YH( cannot be used with data members + of Oracle large object \201LOB\202 data types: )SM(BLOB)ES(, + )SM(CLOB)ES(, and )SM(NCLOB)ES(. The Oracle ODB runtime + uses stream)HY(ing)YH( for reading/writing LOB data directly from/to + data members. As a result, by-refer)HY(ence)YH( acces)HY(sors)YH( and modi)HY(fiers)YH( + should be used for these data types.)EP( + + )0 3 263 H(20.5.9)WB 588 Sn()WB 268 Sn( Database Schema Evolu)HY(tion)YH()EA()EH( + + )0 P(In Oracle, the type of the )SM(name)ES( column in the + )SM(schema_version)ES( table is )SM(VARCHAR2\201512\202)ES(. + Because this column is a primary key and )SM(VARCHAR2)ES( + repre)HY(sents)YH( empty strings as )SM(NULL)ES( values, it is + impos)HY(si)HY(ble)YH( to store an empty string in this column, which + is what is used to repre)HY(sent)YH( the default schema name. As a + result, in Oracle, the empty schema name is stored as a + string contain)HY(ing)YH( a single space char)HY(ac)HY(ter)YH(. ODB performs + all the neces)HY(sary)YH( trans)HY(la)HY(tions)YH( auto)HY(mat)HY(i)HY(cally)YH( and normally + you do not need to worry about this imple)HY(men)HY(ta)HY(tion)YH( detail + unless you are query)HY(ing)YH( or modi)HY(fy)HY(ing)YH( the )SM(schema_version)ES( + table directly.)EP( + + )0 2 264 H(20.6)WB 589 Sn()WB 269 Sn( Oracle Index Defi)HY(ni)HY(tions)YH()EA()EH( + + )0 P(When the )SM(index)ES( pragma \201)0 191 1 A(Section 14.7, + "Index Defi)HY(ni)HY(tion)YH( Pragmas")191 0 TN TL()Ec /AF f D(\202 is used to define an Oracle index, + the )SM(type)ES( clause spec)HY(i)HY(fies)YH( the index type \201for example, + )SM(UNIQUE)ES(, )SM(BITMAP)ES(\202, the )SM(method)ES( + clause is not used, and the )SM(options)ES( clause spec)HY(i)HY(fies)YH( + addi)HY(tional)YH( index prop)HY(er)HY(ties)YH(, such as parti)HY(tion)HY(ing)YH(, table spaces, etc. + The column options can be used to specify the sort order. For example:)EP( + + ) 12 40 PR(#pragma db object +class object +{ + ... + + std::string name_; + + #pragma db index \200 + type\201"BITMAP"\202 \200 + member\201name_, "DESC"\202 \200 + options\201"TABLESPACE TBS1"\202 +};)RP( + + )0 P(Index names in Oracle are schema-global. To avoid name clashes, + ODB auto)HY(mat)HY(i)HY(cally)YH( prefixes each index name with the table name on + which it is defined.)EP( + + + + + + )WB NL NP( + )0 1 265 H(21)WB 590 Sn()WB 270 Sn( Microsoft SQL Server Database)EA()EH( + + )0 P(To gener)HY(ate)YH( support code for the SQL Server database you will need + to pass the ")SM(--database\240mssql)ES(" + \201or ")SM(-d\240mssql)ES("\202 option to the ODB compiler. + Your appli)HY(ca)HY(tion)YH( will also need to link to the SQL Server ODB runtime + library \201)SM(libodb-mssql)ES(\202. All SQL Server-specific ODB + classes are defined in the )SM(odb::mssql)ES( names)HY(pace)YH(.)EP( + + )0 2 266 H(21.1)WB 591 Sn()WB 271 Sn( SQL Server Type Mapping)EA()EH( + + )0 P(The follow)HY(ing)YH( table summa)HY(rizes)YH( the default mapping between basic + C++ value types and SQL Server database types. This mapping can be + customized on the per-type and per-member basis using the ODB + Pragma Language \201)0 100 1 A(Chapter 14, "ODB Pragma Language")100 0 TN TL()Ec /AF f D(\202.)EP( + + + )15 PT( + + )0 P(It is possi)HY(ble)YH( to map the )SM(char)ES( C++ type to an integer + database type \201for example, )SM(TINYINT)ES(\202 using the + )SM(db\240type)ES( pragma \201)0 150 1 A(Section 14.4.3, + ")SM(type)ES(")150 0 TN TL()Ec /AF f D(\202.)EP( + + )0 P(Note that the )SM(std::string)ES( and )SM(std::wstring)ES( + types are mapped differ)HY(ently)YH( depend)HY(ing)YH( on whether a member of one of + these types is an object id or not. If the member is an object id, + then for this member )SM(std::string)ES( is mapped + to )SM(VARCHAR\201256\202)ES( and )SM(std::wstring)ES( \236 + to )SM(NVAR)HY(CHAR)YH(\201256\202)ES(. Other)HY(wise)YH(, )SM(std::string)ES( + is mapped to )SM(VARCHAR\201512\202)ES( and )SM(std::wstring)ES( + \236 to )SM(NVAR)HY(CHAR)YH(\201512\202)ES(. Note also that you can + always change this mapping using the )SM(db\240type)ES( pragma + \201)0 150 1 A(Section 14.4.3, ")SM(type)ES(")150 0 TN TL()Ec /AF f D(\202.)EP( + + )0 P(Addi)HY(tion)HY(ally)YH(, by default, C++ enums and C++11 enum classes are + auto)HY(mat)HY(i)HY(cally)YH( mapped to the SQL Server types corre)HY(spond)HY(ing)YH( to their + under)HY(ly)HY(ing)YH( inte)HY(gral)YH( types \201see table above\202. The default + )SM(NULL)ES( seman)HY(tics)YH( is )SM(NOT NULL)ES(. For + example:)EP( + + ) 17 51 PR(enum color {red, green, blue}; +enum class taste: unsigned char +{ + bitter = 1, + sweet, + sour = 4, + salty +}; + +#pragma db object +class object +{ + ... + + color color_; // Automatically mapped to INT. + taste taste_; // Automatically mapped to TINYINT. +};)RP( + + )0 P(Note also that because SQL Server does not support unsigned inte)HY(gers)YH(, + the )SM(unsigned\240short)ES(, )SM(unsigned\240int)ES(, and + )SM(unsigned\240long)ES(/)SM(unsigned\240long\240long)ES( C++ types + are by default mapped to the )SM(SMALL)HY(INT)YH()ES(, )SM(INT)ES(, + and )SM(BIGINT)ES( SQL Server types, respec)HY(tively)YH(. The sign bit + of the value stored by the database for these types will contain + the most signif)HY(i)HY(cant)YH( bit of the actual unsigned value being + persisted. Simi)HY(larly)YH(, because there is no signed version of the + )SM(TINYINT)ES( SQL Server type, by default, the + )SM(signed char)ES( C++ type is mapped to )SM(TINYINT)ES(. + As a result, the most signif)HY(i)HY(cant)YH( bit of the value stored by the + database for this type will contain the sign bit of the actual + signed value being persisted.)EP( + + )0 P(It is also possi)HY(ble)YH( to add support for addi)HY(tional)YH( SQL Server types, + such as geospa)HY(tial)YH( types, )SM(XML)ES(, and user-defined types. + For more infor)HY(ma)HY(tion)YH(, refer to )0 192 1 A(Section 14.8, "Database + Type Mapping Pragmas")192 0 TN TL()Ec /AF f D(.)EP( + + )0 3 267 H(21.1.1)WB 592 Sn()WB 272 Sn( String Type Mapping)EA()EH( + + )0 P(The SQL Server ODB runtime library provides support for mapping the + )SM(std::string)ES(, )SM(char[N])ES(, and + )SM(std::array)ES( types to the SQL Server + )SM(CHAR)ES(, )SM(VARCHAR)ES(, and )SM(TEXT)ES( + types as well as the )SM(std::wstring)ES(, )SM(wchar_t[N])ES(, + and )SM(std::array)ES( types to )SM(NCHAR)ES(, + )SM(NVAR)HY(CHAR)YH()ES(, and )SM(NTEXT)ES(. However, these mappings + are not enabled by default \201in partic)HY(u)HY(lar)YH(, by default, + )SM(std::array)ES( will be treated as a container\202. To enable the + alter)HY(na)HY(tive)YH( mappings for these types we need to specify the database + type explic)HY(itly)YH( using the )SM(db\240type)ES( pragma + \201)0 150 1 A(Section 14.4.3, ")SM(type)ES(")150 0 TN TL()Ec /AF f D(\202, for + example:)EP( + + ) 11 35 PR(#pragma db object +class object +{ + ... + + #pragma db type \201"CHAR\2012\202"\202 + char state_[2]; + + #pragma db type \201"NVARCHAR\201max\202"\202 + std::wstring text_; +};)RP( + + )0 P(Alter)HY(na)HY(tively)YH(, this can be done on the per-type basis, for example:)EP( + + ) 9 52 PR(#pragma db value\201std::wstring\202 type\201"NVARCHAR\201max\202"\202 + +#pragma db object +class object +{ + ... + + std::wstring text_; // Mapped to NVARCHAR\201max\202. +};)RP( + + )0 P(The )SM(char[N])ES(, )SM(std::array)ES(, + )SM(wchar_t[N])ES(, and )SM(std::array)ES( + values may or may not be zero-termi)HY(nated)YH(. When extract)HY(ing)YH( such values + from the database, ODB will append the zero termi)HY(na)HY(tor)YH( if there is + enough space.)EP( + + )0 P(See also )0 275 1 A(Section 21.1.4, "Long String and Binary + Types")275 0 TN TL()Ec /AF f D( for certain limi)HY(ta)HY(tions)YH( of long string types.)EP( + + )0 3 268 H(21.1.2)WB 593 Sn()WB 273 Sn( Binary Type and )SM(UNIQUEI)HY(DEN)HY(TI)HY(FIER)YH()ES( Mapping)EA()EH( + + )0 P(The SQL Server ODB runtime library also provides support for mapping the + )SM(std::vector)ES(, + )SM(std::vector)ES(, + )SM(char[N])ES(, )SM(unsigned\240char[N])ES(, + )SM(std::array)ES(, and )SM(std::array)ES( + types to the SQL Server )SM(BINARY)ES(, )SM(VARBINARY)ES(, and + )SM(IMAGE)ES( types. There is also support for mapping the + )SM(char[16])ES( array to the SQL Server )SM(UNIQUEI)HY(DEN)HY(TI)HY(FIER)YH()ES( + type. However, these mappings are not enabled by default \201in partic)HY(u)HY(lar)YH(, + by default, )SM(std::vector)ES( and )SM(std::array)ES( will + be treated as contain)HY(ers)YH(\202. To enable the alter)HY(na)HY(tive)YH( mappings for these + types we need to specify the database type explic)HY(itly)YH( using the + )SM(db\240type)ES( pragma \201)0 150 1 A(Section 14.4.3, + ")SM(type)ES(")150 0 TN TL()Ec /AF f D(\202, for example:)EP( + + ) 14 37 PR(#pragma db object +class object +{ + ... + + #pragma db type\201"UNIQUEIDENTIFIER"\202 + char uuid_[16]; + + #pragma db type\201"VARBINARY\201max\202"\202 + std::vector buf_; + + #pragma db type\201"BINARY\201256\202"\202 + unsigned char data_[256]; +};)RP( + + )0 P(Alter)HY(na)HY(tively)YH(, this can be done on the per-type basis, for example:)EP( + + ) 10 47 PR(typedef std::vector buffer; +#pragma db value\201buffer\202 type\201"VARBINARY\201max\202"\202 + +#pragma db object +class object +{ + ... + + buffer buf_; // Mapped to VARBINARY\201max\202. +};)RP( + + )0 P(Note also that in native queries \201)0 38 1 A(Chapter 4, "Query)HY(ing)YH( + the Database")38 0 TN TL()Ec /AF f D(\202 )SM(char[N])ES( and + )SM(std::array)ES( param)HY(e)HY(ters)YH( are by default passed + as a string rather than a binary. To pass such param)HY(e)HY(ters)YH( as a binary, + we need to specify the database type explic)HY(itly)YH( in the + )SM(_val\201\202)ES(/)SM(_ref\201\202)ES( calls. Note also that we + don't need to do this for the inte)HY(grated)YH( queries, for example:)EP( + + ) 6 70 PR(char u[16] = {...}; + +db.query \201"uuid = " + query::_val \201u\202\202; +db.query \201 + "uuid = " + query::_val \201u\202\202; +db.query \201query::uuid == query::_ref \201u\202\202;)RP( + + )0 P(See also )0 275 1 A(Section 21.1.4, "Long String and Binary + Types")275 0 TN TL()Ec /AF f D( for certain limi)HY(ta)HY(tions)YH( of long binary types.)EP( + + )0 3 269 H(21.1.3)WB 594 Sn()WB 274 Sn( )SM(ROWVER)HY(SION)YH()ES( Mapping)EA()EH( + + )0 P()SM(ROWVER)HY(SION)YH()ES( is a special SQL Server data type that is + auto)HY(mat)HY(i)HY(cally)YH( incre)HY(mented)YH( by the database server when)HY(ever)YH( a row + is inserted or updated. As such, it is normally used to imple)HY(ment)YH( + opti)HY(mistic)YH( concur)HY(rency)YH( and ODB provides support for using + )SM(ROWVER)HY(SION)YH()ES( instead of the more portable approach + for opti)HY(mistic)YH( concur)HY(rency)YH( \201)0 90 1 A(Chapter 12, "Opti)HY(mistic)YH( + Concur)HY(rency)YH(")90 0 TN TL()Ec /AF f D(\202.)EP( + + )0 P()SM(ROWVER)HY(SION)YH()ES( is a 64-bit value which is mapped by ODB + to )SM(unsigned long long)ES(. As a result, to use + )SM(ROWVER)HY(SION)YH()ES( for opti)HY(mistic)YH( concur)HY(rency)YH( we need to + make sure that the version column is of the )SM(unsigned long + long)ES( type. We also need to explic)HY(itly)YH( specify that it + should be mapped to the )SM(ROWVER)HY(SION)YH()ES( data type. For + example:)EP( + + ) 8 39 PR(#pragma db object optimistic +class person +{ + ... + + #pragma db version type\201"ROWVERSION"\202 + unsigned long long version_; +};)RP( + + )0 3 270 H(21.1.4)WB 595 Sn()WB 275 Sn( Long String and Binary Types)EA()EH( + + )0 P(For SQL Server, ODB handles char)HY(ac)HY(ter)YH(, national char)HY(ac)HY(ter)YH(, and + binary data in two differ)HY(ent)YH( ways depend)HY(ing)YH( on its maximum length. + If the maximum length \201in bytes\202 is less than or equal to the limit + spec)HY(i)HY(fied)YH( with the )SM(--mssql-short-limit)ES( ODB compiler + option \2011024 by default\202, then it is treated as )I(short data)ES(, + other)HY(wise)YH( \236 )I(long data)ES(. For short data ODB pre-allo)HY(cates)YH( + an inter)HY(me)HY(di)HY(ate)YH( buffer of the maximum size and binds it directly + to a param)HY(e)HY(ter)YH( or result column. This way the under)HY(ly)HY(ing)YH( database + API \201ODBC\202 can read/write directly from/to this buffer. In the case + of long data, the data is read/written in chunks using the + )SM(SQLGet)HY(Data)YH(\201\202)ES(/)SM(SQLPut)HY(Data)YH(\201\202)ES( ODBC func)HY(tions)YH(. + While the long data approach reduces the amount of memory used by + the appli)HY(ca)HY(tion)YH(, it may require greater CPU resources.)EP( + + )0 P(Long data has a number of limi)HY(ta)HY(tions)YH(. In partic)HY(u)HY(lar)YH(, when setting + a custom short data limit, make sure that it is suffi)HY(ciently)YH( large + so that no object id in the appli)HY(ca)HY(tion)YH( is treated as long data. + It is also impos)HY(si)HY(ble)YH( to load an object or view with long data more + than once as part of a query result iter)HY(a)HY(tion)YH( \201)0 43 1 A(Section + 4.4, "Query Result")43 0 TN TL()Ec /AF f D(\202. Any such attempt will result in the + )SM(odb::mssql::long_data_reload)ES( excep)HY(tion)YH( + \201)0 278 1 A(Section 21.4, "SQL Server Excep)HY(tions)YH(")278 0 TN TL()Ec /AF f D(\202. For + example:)EP( + + ) 28 66 PR(#pragma db object +class object +{ + ... + + int num_; + + #pragma db type\201"VARCHAR\201max\202"\202 // Long data. + std::string str_; +}; + +typedef odb::query query; +typedef odb::result result; + +transaction t \201db.begin \201\202\202; + +result r \201db.query \201query::num < 100\202\202; + +for \201result::iterator i \201r.begin \201\202\202; i != r.end \201\202; ++i\202 +{ + if \201!i->str_.empty \201\202\202 // First load. + { + object o; + i.load \201o\202; // Error: second load, long_data_reload is thrown. + } +} + +t.commit \201\202;)RP( + + )0 P(Finally, if a native view \201)0 85 1 A(Section 10.6, "Native + Views")85 0 TN TL()Ec /AF f D(\202 contains one or more long data members, then such + members should come last both in the select-list of the native + SQL query and the list of data members in the C++ class.)EP( + + )0 2 271 H(21.2)WB 596 Sn()WB 276 Sn( SQL Server Database Class)EA()EH( + + )0 P(The SQL Server )SM(database)ES( class encap)HY(su)HY(lates)YH( the ODBC + envi)HY(ron)HY(ment)YH( handle as well as the server instance address and + user creden)HY(tials)YH( that are used to estab)HY(lish)YH( connec)HY(tions)YH( to the + database. It has the follow)HY(ing)YH( inter)HY(face)YH(:)EP( + + ) 122 70 PR(namespace odb +{ + namespace mssql + { + enum protocol + { + protocol_auto, + protocol_tcp, // TCP/IP. + protocol_lpc, // Shared memory \201local procedure call\202. + protocol_np // Named pipes. + }; + + enum transaction_isolation + { + isolation_read_uncommitted, + isolation_read_committed, // SQL Server default. + isolation_repeatable_read, + isolation_snapshot, + isolation_serializable + }; + + class database: public odb::database + { + public: + typedef protocol protocol_type; + typedef transaction_isolation transaction_isolation_type; + + database \201const std::string& user, + const std::string& password, + const std::string& db, + const std::string& server,)WR( + const std::string& driver = "", + const std::string& extra_connect_string = "", + transaction_isolation_type = isolation_read_committed, + SQLHENV environment = 0, + std::[auto|unique]_ptr = 0\202; + + database \201const std::string& user, + const std::string& password, + const std::string& db, + protocol_type protocol = protocol_auto, + const std::string& host = "", + const std::string& instance = "", + const std::string& driver = "", + const std::string& extra_connect_string = "", + transaction_isolation_type = isolation_read_committed, + SQLHENV environment = 0, + std::[auto|unique]_ptr = 0\202; + + database \201const std::string& user, + const std::string& password, + const std::string& db, + const std::string& host, + unsigned int port, + const std::string& driver = "", + const std::string& extra_connect_string = "", + transaction_isolation_type = isolation_read_committed, + SQLHENV environment = 0, + std::[auto|unique]_ptr = 0\202; + + database \201const std::string& connect_string,)WR( + transaction_isolation_type = isolation_read_committed, + SQLHENV environment = 0, + std::[auto|unique]_ptr = 0\202; + + database \201int& argc, + char* argv[], + bool erase = false, + const std::string& extra_connect_string = "", + transaction_isolation_type = isolation_read_committed, + SQLHENV environment = 0, + std::[auto|unique]_ptr = 0\202; + + static void + print_usage \201std::ostream&\202; + + public: + const std::string& + user \201\202 const; + + const std::string& + password \201\202 const; + + const std::string& + db \201\202 const; + + protocol_type + protocol \201\202 const; + + const std::string& + host \201\202 const;)WR( + + const std::string& + instance \201\202 const; + + unsigned int + port \201\202 const; + + const std::string& + server \201\202 const; + + const std::string& + driver \201\202 const; + + const std::string& + extra_connect_string \201\202 const; + + transaction_isolation_type + transaction_isolation \201\202 const; + + const std::string& + connect_string \201\202 const; + + SQLHENV + environment \201\202; + + public: + connection_ptr + connection \201\202; + }; + })WR( +})RP( + + )0 P(You will need to include the )SM()ES( + header file to make this class avail)HY(able)YH( in your appli)HY(ca)HY(tion)YH(.)EP( + + )0 P(The over)HY(loaded)YH( )SM(database)ES( construc)HY(tors)YH( allow us to specify the + SQL Server database param)HY(e)HY(ters)YH( that should be used when connect)HY(ing)YH( to the + database. The )SM(user)ES( and )SM(pass)HY(word)YH()ES( argu)HY(ments)YH( + specify the login name and pass)HY(word)YH(. If )SM(user)ES( is empty, + then Windows authen)HY(ti)HY(ca)HY(tion)YH( is used and the )SM(pass)HY(word)YH()ES( + argu)HY(ment)YH( is ignored. The )SM(db)ES( argu)HY(ment)YH( spec)HY(i)HY(fies)YH( the + database name to open. If it is empty, then the default database for + the user is used.)EP( + + )0 P(The )SM(server)ES( argu)HY(ment)YH( in the first construc)HY(tor)YH( spec)HY(i)HY(fies)YH( + the SQL Server instance address in the stan)HY(dard)YH( SQL Server address + format:)EP( + + )0 P( )SM([)I(proto)HY(col)YH()ES()BD(:)ES(])I(host)ES([)BD(\200)ES()I(instance)ES(][)BD(,)ES()I(port)ES(])ES( + )EP( + + )0 P(Where )SM()I(proto)HY(col)YH()ES()ES( can be )SM(tcp)ES( + \201TCP/IP\202, )SM(lpc)ES( \201shared memory\202, or + )SM(np)ES( \201named pipe\202. If proto)HY(col)YH( is not spec)HY(i)HY(fied)YH(, then a + suit)HY(able)YH( proto)HY(col)YH( is auto)HY(mat)HY(i)HY(cally)YH( selected based on the SQL Server + Native Client config)HY(u)HY(ra)HY(tion)YH(. The )SM()I(host)ES()ES( compo)HY(nent)YH( + can be a host name or an IP address. If )SM()I(instance)ES()ES( + is not spec)HY(i)HY(fied)YH(, then the default SQL Server instance is assumed. + If port is not spec)HY(i)HY(fied)YH(, then the default SQL Server port is + used \2011433\202. Note that you would normally specify either the + instance name or the port, but not both. If both are spec)HY(i)HY(fied)YH(, + then the instance name is ignored by the SQL Server Native Client + ODBC driver. For more infor)HY(ma)HY(tion)YH( on the format of the SQL + Server address, refer to the SQL Server Native Client ODBC + driver docu)HY(men)HY(ta)HY(tion)YH(.)EP( + + )0 P(The second and third construc)HY(tors)YH( allow us to specify all these address + compo)HY(nents)YH( \201proto)HY(col)YH(, host, instance, and port\202 as sepa)HY(rate)YH( + argu)HY(ments)YH(. The third construc)HY(tor)YH( always connects using TCP/IP + to the spec)HY(i)HY(fied)YH( host and port.)EP( + + )0 P(The )SM(driver)ES( argu)HY(ment)YH( spec)HY(i)HY(fies)YH( the SQL Server Native + Client ODBC driver that should be used to connect to the database. + If not spec)HY(i)HY(fied)YH(, then the latest avail)HY(able)YH( version is used. The + follow)HY(ing)YH( exam)HY(ples)YH( show common ways of connect)HY(ing)YH( to the database + using the first three construc)HY(tors)YH(:)EP( + + ) 82 69 PR(// Connect to the default SQL Server instance on the local machine +// using the default protocol. Login as 'test' with password 'secret' +// and open the 'example_db' database. +// +odb::mssql::database db1 \201"test", + "secret", + "example_db"\202; + +// As above except use Windows authentication and open the default +// database for this user. +// +odb::mssql::database db2 \201"", + "", + ""\202; + +// Connect to the default SQL Server instance on 'onega' using the +// default protocol. Login as 'test' with password 'secret' and open +// the 'example_db' database. +// +odb::mssql::database db3 \201"test", + "secret", + "example_db" + "onega"\202; + +// As above but connect to the 'production' SQL Server instance. +// +odb::mssql::database db4 \201"test", + "secret", + "example_db" + "onega\200\200production"\202; +)WR( +// Same as above but specify protocol, host, and instance as separate +// arguments. +// +odb::mssql::database db5 \201"test", + "secret", + "example_db", + odb::mssql::protocol_auto, + "onega", + "production"\202; + +// As above, but use TCP/IP as the protocol. +// +odb::mssql::database db6 \201"test", + "secret", + "example_db" + "tcp:onega\200\200production"\202; + +// Same as above but using separate arguments. +// +odb::mssql::database db7 \201"test", + "secret", + "example_db", + odb::mssql::protocol_tcp, + "onega", + "production"\202; + +// As above, but use TCP/IP port instead of the instance name. +// +odb::mssql::database db8 \201"test", + "secret",)WR( + "example_db" + "tcp:onega,1435"\202; + +// Same as above but using separate arguments. Note that here we +// don't need to specify protocol explicitly since it can only +// be TCP/IP. +// +odb::mssql::database db9 \201"test", + "secret", + "example_db", + "onega", + 1435\202; + +// As above but use the specific SQL Server Native Client ODBC +// driver version. +// +odb::mssql::database dbA \201"test", + "secret", + "example_db" + "tcp:onega,1435", + "SQL Server Native Client 10.0"\202;)RP( + + + )0 P(The fourth construc)HY(tor)YH( allows us to pass a custom ODBC connec)HY(tion)YH( + string that provides all the infor)HY(ma)HY(tion)YH( neces)HY(sary)YH( to connect to + the database. Note also that all the other construc)HY(tors)YH( have the + )SM(extra_connect_string)ES( argu)HY(ment)YH( which can be used to + specify addi)HY(tional)YH( ODBC connec)HY(tion)YH( attributes. For more infor)HY(ma)HY(tion)YH( + on the format of the ODBC connec)HY(tion)YH( string, refer to the SQL + Server Native Client ODBC driver docu)HY(men)HY(ta)HY(tion)YH(.)EP( + + )0 P(The last construc)HY(tor)YH( extracts the database param)HY(e)HY(ters)YH( + from the command line. The follow)HY(ing)YH( options are recog)HY(nized)YH(:)EP( + + ) 6 28 PR( --user | -U + --password | -P + --database | -d + --server | -S
+ --driver + --options-file )RP( + + )0 P(The )SM(--options-file)ES( option allows us to specify some + or all of the database options in a file with each option appear)HY(ing)YH( + on a sepa)HY(rate)YH( line followed by a space and an option value.)EP( + + )0 P(If the )SM(erase)ES( argu)HY(ment)YH( to this construc)HY(tor)YH( is true, + then the above options are removed from the )SM(argv)ES( + array and the )SM(argc)ES( count is updated accord)HY(ingly)YH(. + This is primar)HY(ily)YH( useful if your appli)HY(ca)HY(tion)YH( accepts other + options or argu)HY(ments)YH( and you would like to get the SQL Server + options out of the )SM(argv)ES( array.)EP( + + )0 P(This construc)HY(tor)YH( throws the )SM(odb::mssql::cli_excep)HY(tion)YH()ES( + excep)HY(tion)YH( if the SQL Server option values are missing or invalid. See + section )0 278 1 A(Section 21.4, "SQL Server Excep)HY(tions)YH(")278 0 TN TL()Ec /AF f D( for + more infor)HY(ma)HY(tion)YH( on this excep)HY(tion)YH(.)EP( + + )0 P(The static )SM(print_usage\201\202)ES( func)HY(tion)YH( prints the list of options + with short descrip)HY(tions)YH( that are recog)HY(nized)YH( by this construc)HY(tor)YH(.)EP( + + )0 P(Addi)HY(tion)HY(ally)YH(, all the construc)HY(tors)YH( have the )SM(trans)HY(ac)HY(tion)YH(_isola)HY(tion)YH()ES( + and )SM(envi)HY(ron)HY(ment)YH()ES( argu)HY(ments)YH(. The )SM(trans)HY(ac)HY(tion)YH(_isola)HY(tion)YH()ES( + argu)HY(ment)YH( allows us to specify an alter)HY(na)HY(tive)YH( trans)HY(ac)HY(tion)YH( isola)HY(tion)YH( level + that should be used by all the connec)HY(tions)YH( created by this database instance. + The )SM(envi)HY(ron)HY(ment)YH()ES( argu)HY(ment)YH( allows us to provide a custom ODBC + envi)HY(ron)HY(ment)YH( handle. If this argu)HY(ment)YH( is not )SM(NULL)ES(, then the + passed handle is used in all the ODBC func)HY(tion)YH( calls made by this + )SM(database)ES( instance. Note also that the )SM(database)ES( + instance does not assume owner)HY(ship)YH( of the passed envi)HY(ron)HY(ment)YH( handle and + this handle should be valid for the life)HY(time)YH( of the )SM(database)ES( + instance.)EP( + + )0 P(The last argu)HY(ment)YH( to all of the construc)HY(tors)YH( is a pointer to the + connec)HY(tion)YH( factory. In C++98/03, it is )SM(std::auto_ptr)ES( while + in C++11 )SM(std::unique_ptr)ES( is used instead. If we pass a + non-)SM(NULL)ES( value, the database instance assumes owner)HY(ship)YH( + of the factory instance. The connec)HY(tion)YH( factory inter)HY(face)YH( as well as + the avail)HY(able)YH( imple)HY(men)HY(ta)HY(tions)YH( are described in the next section.)EP( + + )0 P(The set of acces)HY(sor)YH( func)HY(tions)YH( follow)HY(ing)YH( the construc)HY(tors)YH( allows us + to query the param)HY(e)HY(ters)YH( of the )SM(database)ES( instance.)EP( + + )0 P(The )SM(connec)HY(tion)YH(\201\202)ES( func)HY(tion)YH( returns a pointer to the + SQL Server database connec)HY(tion)YH( encap)HY(su)HY(lated)YH( by the + )SM(odb::mssql::connec)HY(tion)YH()ES( class. For more infor)HY(ma)HY(tion)YH( + on )SM(mssql::connec)HY(tion)YH()ES(, refer to )0 277 1 A(Section + 21.3, "SQL Server Connec)HY(tion)YH( and Connec)HY(tion)YH( Factory")277 0 TN TL()Ec /AF f D(.)EP( + + )0 2 272 H(21.3)WB 597 Sn()WB 277 Sn( SQL Server Connec)HY(tion)YH( and Connec)HY(tion)YH( Factory)EA()EH( + + )0 P(The )SM(mssql::connec)HY(tion)YH()ES( class has the follow)HY(ing)YH( inter)HY(face)YH(:)EP( + + ) 20 59 PR(namespace odb +{ + namespace mssql + { + class connection: public odb::connection + { + public: + connection \201database&\202; + connection \201database&, SQLHDBC handle\202; + + SQLHDBC + handle \201\202; + + details::buffer& + long_data_buffer \201\202; + }; + + typedef details::shared_ptr connection_ptr; + } +})RP( + + )0 P(For more infor)HY(ma)HY(tion)YH( on the )SM(odb::connec)HY(tion)YH()ES( inter)HY(face)YH(, refer + to )0 29 1 A(Section 3.6, "Connec)HY(tions)YH(")29 0 TN TL()Ec /AF f D(. The first over)HY(loaded)YH( + )SM(mssql::connec)HY(tion)YH()ES( construc)HY(tor)YH( creates a new ODBC connec)HY(tion)YH(. + The created connec)HY(tion)YH( is config)HY(ured)YH( to use the manual commit mode with + multi)HY(ple)YH( active result sets \201MARS\202 enabled. The second construc)HY(tor)YH( allows + us to create a )SM(connec)HY(tion)YH()ES( instance by provid)HY(ing)YH( an already + estab)HY(lished)YH( ODBC connec)HY(tion)YH(. Note that the )SM(connec)HY(tion)YH()ES( + instance assumes owner)HY(ship)YH( of this handle. The )SM(handle\201\202)ES( + acces)HY(sor)YH( returns the under)HY(ly)HY(ing)YH( ODBC connec)HY(tion)YH( handle asso)HY(ci)HY(ated)YH( with + the )SM(connec)HY(tion)YH()ES( instance.)EP( + + )0 P(Addi)HY(tion)HY(ally)YH(, each )SM(connec)HY(tion)YH()ES( instance main)HY(tains)YH( a long + data buffer. This buffer is used by the SQL Server ODB runtime + as an inter)HY(me)HY(di)HY(ate)YH( storage for piece)HY(wise)YH( handling of long data. + By default, the long data buffer has zero initial capac)HY(ity)YH( and is + expanded to 4096 bytes when the first long data oper)HY(a)HY(tion)YH( is performed. + If your appli)HY(ca)HY(tion)YH( requires a bigger or smaller long data buffer, + you can specify a custom capac)HY(ity)YH( using the )SM(long_data_buffer\201\202)ES( + acces)HY(sor)YH(.)EP( + + )0 P(The )SM(mssql::connec)HY(tion)YH(_factory)ES( abstract class has the + follow)HY(ing)YH( inter)HY(face)YH(:)EP( + + ) 15 31 PR(namespace odb +{ + namespace mssql + { + class connection_factory + { + public: + virtual void + database \201database&\202 = 0; + + virtual connection_ptr + connect \201\202 = 0; + }; + } +})RP( + + )0 P(The )SM(database\201\202)ES( func)HY(tion)YH( is called when a connec)HY(tion)YH( + factory is asso)HY(ci)HY(ated)YH( with a database instance. This happens in + the )SM(odb::mssql::database)ES( class construc)HY(tors)YH(. The + )SM(connect\201\202)ES( func)HY(tion)YH( is called when)HY(ever)YH( a database + connec)HY(tion)YH( is requested.)EP( + + )0 P(The two imple)HY(men)HY(ta)HY(tions)YH( of the )SM(connec)HY(tion)YH(_factory)ES( + inter)HY(face)YH( provided by the SQL Server ODB runtime are + )SM(new_connec)HY(tion)YH(_factory)ES( and + )SM(connec)HY(tion)YH(_pool_factory)ES(. You will need to include + the )SM()ES( + header file to make the )SM(connec)HY(tion)YH(_factory)ES( inter)HY(face)YH( + and these imple)HY(men)HY(ta)HY(tion)YH( classes avail)HY(able)YH( in your appli)HY(ca)HY(tion)YH(.)EP( + + )0 P(The )SM(new_connec)HY(tion)YH(_factory)ES( class creates a new + connec)HY(tion)YH( when)HY(ever)YH( one is requested. When a connec)HY(tion)YH( is no + longer needed, it is released and closed. The + )SM(new_connec)HY(tion)YH(_factory)ES( class has the follow)HY(ing)YH( + inter)HY(face)YH(:)EP( + + ) 10 59 PR(namespace odb +{ + namespace mssql + { + class new_connection_factory: public connection_factory + { + public: + new_connection_factory \201\202; + }; +};)RP( + + )0 P(The )SM(connec)HY(tion)YH(_pool_factory)ES( class imple)HY(ments)YH( a + connec)HY(tion)YH( pool. It has the follow)HY(ing)YH( inter)HY(face)YH(:)EP( + + ) 24 75 PR(namespace odb +{ + namespace mssql + { + class connection_pool_factory: public connection_factory + { + public: + connection_pool_factory \201std::size_t max_connections = 0, + std::size_t min_connections = 0\202; + + protected: + class pooled_connection: public connection + { + public: + pooled_connection \201database_type&\202; + pooled_connection \201database_type&, SQLHDBC handle\202; + }; + + typedef details::shared_ptr pooled_connection_ptr; + + virtual pooled_connection_ptr + create \201\202; + }; +};)RP( + + )0 P(The )SM(max_connec)HY(tions)YH()ES( argu)HY(ment)YH( in the + )SM(connec)HY(tion)YH(_pool_factory)ES( construc)HY(tor)YH( spec)HY(i)HY(fies)YH( the maximum + number of concur)HY(rent)YH( connec)HY(tions)YH( that this pool factory will + main)HY(tain)YH(. Simi)HY(larly)YH(, the )SM(min_connec)HY(tions)YH()ES( argu)HY(ment)YH( + spec)HY(i)HY(fies)YH( the minimum number of avail)HY(able)YH( connec)HY(tions)YH( that + should be kept open.)EP( + + )0 P(When)HY(ever)YH( a connec)HY(tion)YH( is requested, the pool factory first + checks if there is an unused connec)HY(tion)YH( that can be returned. + If there is none, the pool factory checks the + )SM(max_connec)HY(tions)YH()ES( value to see if a new connec)HY(tion)YH( + can be created. If the total number of connec)HY(tions)YH( main)HY(tained)YH( + by the pool is less than this value, then a new connec)HY(tion)YH( is + created and returned. Other)HY(wise)YH(, the caller is blocked until + a connec)HY(tion)YH( becomes avail)HY(able)YH(.)EP( + + )0 P(When a connec)HY(tion)YH( is released, the pool factory first checks + if there are blocked callers waiting for a connec)HY(tion)YH(. If so, then + one of them is unblocked and is given the connec)HY(tion)YH(. Other)HY(wise)YH(, + the pool factory checks whether the total number of connec)HY(tions)YH( + main)HY(tained)YH( by the pool is greater than the )SM(min_connec)HY(tions)YH()ES( + value. If that's the case, the connec)HY(tion)YH( is closed. Other)HY(wise)YH(, the + connec)HY(tion)YH( is added to the pool of avail)HY(able)YH( connec)HY(tions)YH( to be + returned on the next request. In other words, if the number of + connec)HY(tions)YH( main)HY(tained)YH( by the pool exceeds )SM(min_connec)HY(tions)YH()ES( + and there are no callers waiting for a new connec)HY(tion)YH(, + the pool will close the excess connec)HY(tions)YH(.)EP( + + )0 P(If the )SM(max_connec)HY(tions)YH()ES( value is 0, then the pool will + create a new connec)HY(tion)YH( when)HY(ever)YH( all of the exist)HY(ing)YH( connec)HY(tions)YH( + are in use. If the )SM(min_connec)HY(tions)YH()ES( value is 0, then + the pool will never close a connec)HY(tion)YH( and instead main)HY(tain)YH( all + the connec)HY(tions)YH( that were ever created.)EP( + + )0 P(The )SM(create\201\202)ES( virtual func)HY(tion)YH( is called when)HY(ever)YH( the + pool needs to create a new connec)HY(tion)YH(. By deriv)HY(ing)YH( from the + )SM(connec)HY(tion)YH(_pool_factory)ES( class and over)HY(rid)HY(ing)YH( this + func)HY(tion)YH( we can imple)HY(ment)YH( custom connec)HY(tion)YH( estab)HY(lish)HY(ment)YH( + and config)HY(u)HY(ra)HY(tion)YH(.)EP( + + )0 P(If you pass )SM(NULL)ES( as the connec)HY(tion)YH( factory to one of the + )SM(database)ES( construc)HY(tors)YH(, then the + )SM(connec)HY(tion)YH(_pool_factory)ES( instance will be created by default + with the min and max connec)HY(tions)YH( values set to )SM(0)ES(. The + follow)HY(ing)YH( code frag)HY(ment)YH( shows how we can pass our own connec)HY(tion)YH( factory + instance:)EP( + + ) 14 55 PR(#include + +#include +#include + +int +main \201int argc, char* argv[]\202 +{ + auto_ptr f \201 + new odb::mssql::connection_pool_factory \20120\202\202; + + auto_ptr db \201 + new mssql::database \201argc, argv, false, "", 0, f\202\202; +})RP( + + )0 2 273 H(21.4)WB 598 Sn()WB 278 Sn( SQL Server Excep)HY(tions)YH()EA()EH( + + )0 P(The SQL Server ODB runtime library defines the follow)HY(ing)YH( + SQL Server-specific excep)HY(tions)YH(:)EP( + + ) 53 53 PR(namespace odb +{ + namespace mssql + { + class database_exception: odb::database_exception + { + public: + class record + { + public: + SQLINTEGER + error \201\202 const; + + const std::string& + sqlstate \201\202 const; + + const std::string& + message \201\202 const; + }; + + typedef std::vector records; + + typedef records::size_type size_type; + typedef records::const_iterator iterator; + + iterator + begin \201\202 const; + + iterator + end \201\202 const; +)WR( + size_type + size \201\202 const; + + virtual const char* + what \201\202 const throw \201\202; + }; + + class cli_exception: odb::exception + { + public: + virtual const char* + what \201\202 const throw \201\202; + }; + + class long_data_reload: odb::exception + { + public: + virtual const char* + what \201\202 const throw \201\202; + }; + } +})RP( + + )0 P(You will need to include the )SM()ES( + header file to make these excep)HY(tions)YH( avail)HY(able)YH( in your appli)HY(ca)HY(tion)YH(.)EP( + + )0 P(The )SM(odb::mssql::database_excep)HY(tion)YH()ES( is thrown if + an SQL Server database oper)HY(a)HY(tion)YH( fails. The SQL Server-specific error + infor)HY(ma)HY(tion)YH( is stored as a series of records, each contain)HY(ing)YH( + the error code as a signed 4-byte integer, the SQLSTATE code, + and the message string. All this infor)HY(ma)HY(tion)YH( is also combined + and returned in a human-read)HY(able)YH( form by the )SM(what\201\202)ES( + func)HY(tion)YH(.)EP( + + )0 P(The )SM(odb::mssql::cli_excep)HY(tion)YH()ES( is thrown by the + command line parsing construc)HY(tor)YH( of the )SM(odb::mssql::database)ES( + class if the SQL Server option values are missing or invalid. The + )SM(what\201\202)ES( func)HY(tion)YH( returns a human-read)HY(able)YH( descrip)HY(tion)YH( + of an error.)EP( + + )0 P(The )SM(odb::mssql::long_data_reload)ES( is thrown if an + attempt is made to re-load an object or view with long data as + part of a query result iter)HY(a)HY(tion)YH(. For more infor)HY(ma)HY(tion)YH(, refer + to )0 271 1 A(Section 21.1, "SQL Server Type Mapping")271 0 TN TL()Ec /AF f D(.)EP( + + )0 2 274 H(21.5)WB 599 Sn()WB 279 Sn( SQL Server Limi)HY(ta)HY(tions)YH()EA()EH( + + )0 P(The follow)HY(ing)YH( sections describe SQL Server-specific limi)HY(ta)HY(tions)YH( imposed + by the current SQL Server and ODB runtime versions.)EP( + + )0 3 275 H(21.5.1)WB 600 Sn()WB 280 Sn( Query Result Caching)EA()EH( + + )0 P(SQL Server ODB runtime imple)HY(men)HY(ta)HY(tion)YH( does not perform query result + caching \201)0 43 1 A(Section 4.4, "Query Result")43 0 TN TL()Ec /AF f D(\202 even when + explic)HY(itly)YH( requested. The ODBC API and the SQL Server Native Client ODBC + driver support inter)HY(leav)HY(ing)YH( execu)HY(tion)YH( of multi)HY(ple)YH( prepared state)HY(ments)YH( + on a single connec)HY(tion)YH(. As a result, it is possi)HY(ble)YH( to have multi)HY(ple)YH( + uncached results and calls to other database func)HY(tions)YH( do not inval)HY(i)HY(date)YH( + them. The only limi)HY(ta)HY(tion)YH( of the uncached SQL Server results is the + unavail)HY(abil)HY(ity)YH( of the )SM(result::size\201\202)ES( func)HY(tion)YH(. If you + call this func)HY(tion)YH( on an SQL Server query result, then the + )SM(odb::result_not_cached)ES( excep)HY(tion)YH( \201)0 37 1 A(Section + 3.14, "ODB Excep)HY(tions)YH(")37 0 TN TL()Ec /AF f D(\202 is always thrown. Future versions of the + SQL Server ODB runtime library may add support for result caching.)EP( + + )0 3 276 H(21.5.2)WB 601 Sn()WB 281 Sn( Foreign Key Constraints)EA()EH( + + )0 P(ODB assumes the stan)HY(dard)YH( SQL behav)HY(ior)YH( which requires that foreign + key constraints check)HY(ing)YH( is deferred until the trans)HY(ac)HY(tion)YH( is + commit)HY(ted)YH(. The only behav)HY(ior)YH( supported by SQL Server is to check + such constraints imme)HY(di)HY(ately)YH(. As a result, by default, schemas + gener)HY(ated)YH( by the ODB compiler for SQL Server have foreign key + defi)HY(ni)HY(tions)YH( commented out. They are retained only for docu)HY(men)HY(ta)HY(tion)YH(.)EP( + + )0 P(You can over)HY(ride)YH( the default behav)HY(ior)YH( and instruct the ODB + compiler to gener)HY(ate)YH( non-deferrable foreign keys by spec)HY(i)HY(fy)HY(ing)YH( + the )SM(--fkeys-deferrable-mode not_deferrable)ES( ODB + compiler option. Note, however, that in this case the order in + which you persist, update, and erase objects within a trans)HY(ac)HY(tion)YH( + becomes impor)HY(tant)YH(.)EP( + + )0 3 277 H(21.5.3)WB 602 Sn()WB 282 Sn( Unique Constraint Viola)HY(tions)YH()EA()EH( + + )0 P(Due to the gran)HY(u)HY(lar)HY(ity)YH( of the ODBC error codes, it is impos)HY(si)HY(ble)YH( + to distin)HY(guish)YH( between the dupli)HY(cate)YH( primary key and other unique + constraint viola)HY(tions)YH(. As a result, when making an object persis)HY(tent)YH(, + the SQL Server ODB runtime will trans)HY(late)YH( all unique constraint viola)HY(tion)YH( + errors to the )SM(object_already_persis)HY(tent)YH()ES( excep)HY(tion)YH( + \201)0 37 1 A(Section 3.14, "ODB Excep)HY(tions)YH(")37 0 TN TL()Ec /AF f D(\202.)EP( + + )0 3 278 H(21.5.4)WB 603 Sn()WB 283 Sn( Multi-threaded Windows Appli)HY(ca)HY(tions)YH()EA()EH( + + )0 P(Multi-threaded Windows appli)HY(ca)HY(tions)YH( must use the + )SM(_beginthread\201\202)ES(/)SM(_beginthreadex\201\202)ES( and + )SM(_endthread\201\202)ES(/)SM(_endthreadex\201\202)ES( CRT func)HY(tions)YH( + instead of the )SM(CreateThread\201\202)ES( and )SM(EndThread\201\202)ES( + Win32 func)HY(tions)YH( to start and termi)HY(nate)YH( threads. This is a limi)HY(ta)HY(tion)YH( of + the ODBC imple)HY(men)HY(ta)HY(tion)YH( on Windows.)EP( + + )0 3 279 H(21.5.5)WB 604 Sn()WB 284 Sn( Affected Row Count and DDL State)HY(ments)YH()EA()EH( + + )0 P(SQL Server always returns zero as the number of affected rows + for DDL state)HY(ments)YH(. In partic)HY(u)HY(lar)YH(, this means that the + )SM(database::execute\201\202)ES( \201)0 35 1 A(Section 3.12, + "Execut)HY(ing)YH( Native SQL State)HY(ments)YH(")35 0 TN TL()Ec /AF f D(\202 func)HY(tion)YH( will always + return zero for such state)HY(ments)YH(.)EP( + + )0 3 280 H(21.5.6)WB 605 Sn()WB 285 Sn( Long Data and Auto Object Ids, )SM(ROWVER)HY(SION)YH()ES()EA()EH( + + )0 P(SQL Server 2005 has a bug that causes it to fail on an )SM(INSERT)ES( + or )SM(UPDATE)ES( state)HY(ment)YH( with the )SM(OUTPUT)ES( clause + \201used to return auto)HY(mat)HY(i)HY(cally)YH( assigned object ids as well as + )SM(ROWVER)HY(SION)YH()ES( values\202 if one of the inserted columns + is long data. The symptom of this bug in ODB is an excep)HY(tion)YH( thrown + by the )SM(database::persist\201\202)ES( or )SM(database::update\201\202)ES( + func)HY(tion)YH( when used on an object that contains long data and has an + auto)HY(mat)HY(i)HY(cally)YH( assigned object id or uses )SM(ROWVER)HY(SION)YH()ES(-based + opti)HY(mistic)YH( concur)HY(rency)YH( \201)0 272 1 A(Section 21.1.1, + ")SM(ROWVER)HY(SION)YH()ES( Support")272 0 TN TL()Ec /AF f D(\202. The error message reads "This + oper)HY(a)HY(tion)YH( conflicts with another pending oper)HY(a)HY(tion)YH( on this trans)HY(ac)HY(tion)YH(. + The oper)HY(a)HY(tion)YH( failed.")EP( + + )0 P(For auto)HY(mat)HY(i)HY(cally)YH( assigned object ids ODB includes a workaround for + this bug which uses a less effi)HY(cient)YH( method to obtain id values for + objects that contain long data. To enable this workaround you need + to specify that the gener)HY(ated)YH( code will be used with SQL Server 2005 + or later by passing the )SM(--mssql-server-version\2409.0)ES( + ODB compiler option.)EP( + + )0 P(For )SM(ROWVER)HY(SION)YH()ES(-based opti)HY(mistic)YH( concur)HY(rency)YH( no workaround + is currently provided. The ODB compiler will issue an error for + objects that use )SM(ROWVER)HY(SION)YH()ES( for opti)HY(mistic)YH( concur)HY(rency)YH( + and contain)HY(ing)YH( long data.)EP( + + )0 3 281 H(21.5.7)WB 606 Sn()WB 286 Sn( Long Data and By-Value Acces)HY(sors)YH(/Modi)HY(fiers)YH()EA()EH( + + )0 P(As discussed in )0 152 1 A(Section 14.4.5, + ")SM(get)ES(/)SM(set)ES(/)SM(access)ES(")152 0 TN TL()Ec /AF f D(, by-value + acces)HY(sor)YH( and modi)HY(fier)YH( expres)HY(sions)YH( cannot be used with data members + of long data types. The SQL Server ODB runtime uses stream)HY(ing)YH( for + reading/writing long data directly from/to data members. As a result, + by-refer)HY(ence)YH( acces)HY(sors)YH( and modi)HY(fiers)YH( should be used for these data + types.)EP( + + )0 3 282 H(21.5.8)WB 607 Sn()WB 287 Sn( Bulk Update and )SM(ROWVER)HY(SION)YH()ES()EA()EH( + + )0 P(The bulk update oper)HY(a)HY(tion)YH( \201)0 203 1 A(Section 15.3, "Bulk Database + Oper)HY(a)HY(tions)YH(")203 0 TN TL()Ec /AF f D(\202 is not yet supported for persis)HY(tent)YH( classes that use + )SM(ROWVER)HY(SION)YH()ES(-based opti)HY(mistic)YH( concur)HY(rency)YH(. For such classes + the bulk )SM(update\201\202)ES( func)HY(tion)YH( is not avail)HY(able)YH(. The bulk + persist and erase support is still provided.)EP( + + )0 2 283 H(21.6)WB 608 Sn()WB 288 Sn( SQL Server Index Defi)HY(ni)HY(tions)YH()EA()EH( + + )0 P(When the )SM(index)ES( pragma \201)0 191 1 A(Section 14.7, + "Index Defi)HY(ni)HY(tion)YH( Pragmas")191 0 TN TL()Ec /AF f D(\202 is used to define an SQL Server index, + the )SM(type)ES( clause spec)HY(i)HY(fies)YH( the index type \201for example, + )SM(UNIQUE)ES(, )SM(CLUS)HY(TERED)YH()ES(\202, the )SM(method)ES( + clause is not used, and the )SM(options)ES( clause spec)HY(i)HY(fies)YH( + addi)HY(tional)YH( index prop)HY(er)HY(ties)YH(. The column options can be used to specify + the sort order. For example:)EP( + + ) 12 48 PR(#pragma db object +class object +{ + ... + + std::string name_; + + #pragma db index \200 + type\201"UNIQUE CLUSTERED"\202 \200 + member\201name_, "DESC"\202 \200 + options\201"WITH\201FILLFACTOR = 80\202"\202 +};)RP( + + )0 2 284 H(21.7)WB 609 Sn()WB 289 Sn( SQL Server Stored Proce)HY(dures)YH()EA()EH( + + )0 P(ODB native views \201)0 85 1 A(Section 10.6, "Native Views")85 0 TN TL()Ec /AF f D(\202 + can be used to call SQL Server stored proce)HY(dures)YH(. For example, assum)HY(ing)YH( + we are using the )SM(person)ES( class from )0 11 1 A(Chapter + 2, "Hello World Example")11 0 TN TL()Ec /AF f D( \201and the corre)HY(spond)HY(ing)YH( )SM(person)ES( + table\202, we can create a stored proce)HY(dure)YH( that given the min and max + ages returns some infor)HY(ma)HY(tion)YH( about all the people in that range:)EP( + + ) 6 46 PR(CREATE PROCEDURE dbo.person_range \201 + @min_age SMALLINT, + @max_age SMALLINT\202 +AS + SELECT age, first, last FROM person + WHERE age >= @min_age AND age <= @max_age;)RP( + + )0 P(Given the above stored proce)HY(dure)YH( we can then define an ODB view + that can be used to call it and retrieve its result:)EP( + + ) 7 46 PR(#pragma db view query\201"EXEC person_range \201?\202"\202 +struct person_range +{ + unsigned short age; + std::string first; + std::string last; +};)RP( + + )0 P(The follow)HY(ing)YH( example shows how we can use the above view to + print the list of people in a specific age range:)EP( + + ) 13 62 PR(typedef odb::query query; +typedef odb::result result; + +transaction t \201db.begin \201\202\202; + +result r \201 + db.query \201 + query::_val \2011\202 + "," + query::_val \20118\202\202\202; + +for \201result::iterator i \201r.begin \201\202\202; i != r.end \201\202; ++i\202 + cerr << i->first << " " << i->last << " " << i->age << endl; + +t.commit \201\202;)RP( + + )0 P(Note that as with all native views, the order and types of data members + must match those of columns in the )SM(SELECT)ES( list inside + the stored proce)HY(dure)YH(.)EP( + + )0 P(There are also a number of limi)HY(ta)HY(tions)YH( when it comes to calling + SQL Server stored proce)HY(dures)YH( with ODB views. There is currently + no support for output param)HY(e)HY(ters)YH(, however, this is planned for + a future version. In the mean)HY(time)YH(, to call a stored proce)HY(dure)YH( + that has output param)HY(e)HY(ters)YH( we have to use a wrapper proce)HY(dure)YH( + that converts such param)HY(e)HY(ters)YH( to a )SM(SELECT)ES( + result. For example, given the follow)HY(ing)YH( proce)HY(dure)YH( that + calcu)HY(lates)YH( the age range of the people in our database:)EP( + + ) 5 62 PR(CREATE PROCEDURE dbo.person_age_range \201 + @min_age SMALLINT = NULL OUTPUT, + @max_age SMALLINT = NULL OUTPUT\202 +AS + SELECT @min_age = MIN\201age\202, @max_age = MAX\201max\202 FROM person;)RP( + + )0 P(We can create a wrapper proce)HY(dure)YH( like this:)EP( + + ) 5 57 PR(CREATE PROCEDURE dbo.person_age_range_odb +AS + DECLARE @min_age SMALLINT, @max_age SMALLINT; + EXEC person_age_range @min_age OUTPUT, @max_age OUTPUT; + SELECT @min_age, @max_age;)RP( + + )0 P(And a view like this:)EP( + + ) 6 50 PR(#pragma db view query\201"EXEC person_age_range_odb"\202 +struct person_age_range +{ + unsigned short min_age; + unsigned short max_age; +};)RP( + + )0 P(Which we can then use to call the stored proce)HY(dure)YH(:)EP( + + ) 6 58 PR(transaction t \201db.begin \201\202\202; + +person_age_range ar \201db.query_value \201\202\202; +cerr << ar.min_age << " " << ar.max_age << endl; + +t.commit \201\202;)RP( + + )0 P(In SQL Server, a stored proce)HY(dure)YH( can produce multi)HY(ple)YH( results. + For example, if a stored proce)HY(dure)YH( executes several + )SM(SELECT)ES( state)HY(ments)YH(, then the result of calling such + a proce)HY(dure)YH( consists of two row sets, one for each )SM(SELECT)ES( + state)HY(ment)YH(. Because such multi)HY(ple)YH( row sets can contain varying number + and type of columns, they cannot be all extracted into a + single view. Conse)HY(quently)YH(, these kind of stored proce)HY(dures)YH( are + currently not supported.)EP( + + )0 P(A stored proce)HY(dure)YH( may also produce no row sets at all. For + example, a stored proce)HY(dure)YH( that only executes DML state)HY(ments)YH( + would exhibit this behav)HY(ior)YH(. To call such a proce)HY(dure)YH( we use + an empty view, for example:)EP( + + ) 7 38 PR(CREATE PROCEDURE dbo.insert_person \201 + @first VARCHAR\201512\202, + @last VARCHAR\201512\202, + @age SMALLINT\202 +AS + INSERT INTO person\201first, last, age\202 + VALUES\201@first, @last, @age\202;)RP( + + ) 12 32 PR(#pragma db view +struct no_result {}; + +transaction t \201db.begin \201\202\202; + +db.query_one \201 + "EXEC insert_person" + + query::_val \201"John"\202 + "," + + query::_val \201"Doe"\202 + "," + + query::_val \20121\202\202; + +t.commit \201\202;)RP( + + )0 P(Finally, an SQL Server stored proce)HY(dure)YH( can also return an + integer status code. Similar to output param)HY(e)HY(ters)YH(, this code + can only be observed by an ODB view if it is converted to a + )SM(SELECT)ES( result. For more infor)HY(ma)HY(tion)YH( on how to + do this and for other exam)HY(ples)YH( of stored proce)HY(dure)YH( calls, + refer to the )SM(mssql/stored-proc)ES( test in the + )SM(odb-tests)ES( package.)EP( + + + + + )WB NL NP( + )0 1 285 H(PART)WB 610 Sn()WB 290 Sn( III\240\240 + PROFILES)EA()EH( + + )0 P(Part III covers the inte)HY(gra)HY(tion)YH( of ODB with popular C++ frame)HY(works)YH( + and libraries. It consists of the follow)HY(ing)YH( chap)HY(ters)YH(.)EP( + + )16 PT( + + + + + + )WB NL NP( + )0 1 286 H(22)WB 611 Sn()WB 291 Sn( Profiles Intro)HY(duc)HY(tion)YH()EA()EH( + + )0 P(ODB profiles are a generic mech)HY(a)HY(nism)YH( for inte)HY(grat)HY(ing)YH( ODB with + widely-used C++ frame)HY(works)YH( and libraries. A profile provides glue + code which allows you to seam)HY(lessly)YH( persist various compo)HY(nents)YH(, such + as smart point)HY(ers)YH(, contain)HY(ers)YH(, and value types found in these + frame)HY(works)YH( or libraries. The code neces)HY(sary)YH( to imple)HY(ment)YH( a profile + is pack)HY(aged)YH( into the so called profile library. For example, the + Boost profile imple)HY(men)HY(ta)HY(tion)YH( is provided by the )SM(libodb-boost)ES( + profile library.)EP( + + )0 P(Besides linking the profile library to our appli)HY(ca)HY(tion)YH(, it is also + neces)HY(sary)YH( to let the ODB compiler know which profiles we + are using. This is accom)HY(plished)YH( with the )SM(--profile)ES( + \201or )SM(-p)ES( alias\202 option. For example:)EP( + + ) 1 23 PR(odb --profile boost ...)RP( + + )0 P(Some profiles, espe)HY(cially)YH( those cover)HY(ing)YH( frame)HY(works)YH( or libraries that + consist of multi)HY(ple)YH( sub-libraries, provide sub-profiles that allow you + to pick and choose which compo)HY(nents)YH( you would like to use in your + appli)HY(ca)HY(tion)YH(. For example, the )SM(boost)ES( profile contains + the )SM(boost/data-time)ES( sub-profile. If we are only + inter)HY(ested)YH( in the )SM(date_time)ES( types, then we can + pass )SM(boost/data-time)ES( instead of )SM(boost)ES( + to the )SM(--profile)ES( option, for example:)EP( + + ) 1 33 PR(odb --profile boost/date-time ...)RP( + + )0 P(To summa)HY(rize)YH(, you will need to perform the follow)HY(ing)YH( steps in order + to make use of a profile in your appli)HY(ca)HY(tion)YH(:)EP( + + )4 OL( )-1 LI(ODB compiler: if neces)HY(sary)YH(, specify the path to the profile library + headers \201)SM(-I)ES( option\202. + )-1 LI(ODB compiler: specify the profile you would like to use with + the )SM(--profile)ES( option. + )-1 LI(C++ compiler: if neces)HY(sary)YH(, specify the path to the profile library + headers \201normally )SM(-I)ES( option\202. + )-1 LI(Linker: link the profile library to the appli)HY(ca)HY(tion)YH(. + )LO( + + )0 P(The remain)HY(ing)YH( chap)HY(ters)YH( in this part of the manual describe the + stan)HY(dard)YH( profiles provided by ODB.)EP( + + + + + + )WB NL NP( + )0 1 287 H(23)WB 612 Sn()WB 292 Sn( Boost Profile)EA()EH( + + )0 P(The ODB profile imple)HY(men)HY(ta)HY(tion)YH( for Boost is provided by the + )SM(libodb-boost)ES( library and consists of multi)HY(ple)YH( sub-profiles + corre)HY(spond)HY(ing)YH( to the indi)HY(vid)HY(ual)YH( Boost libraries. To enable all the + avail)HY(able)YH( Boost sub-profiles, pass )SM(boost)ES( as the profile + name to the )SM(--profile)ES( ODB compiler option. Alter)HY(na)HY(tively)YH(, + you can enable only specific sub-profiles by passing indi)HY(vid)HY(ual)YH( + sub-profile names to )SM(--profile)ES(. The follow)HY(ing)YH( sections in + this chapter discuss each Boost sub-profile in detail. The + )SM(boost)ES( example in the )SM(odb-exam)HY(ples)YH()ES( + package shows how to enable and use the Boost profile.)EP( + + )0 P(Some sub-profiles may throw excep)HY(tions)YH( to indi)HY(cate)YH( error condi)HY(tions)YH(, + such as the inabil)HY(ity)YH( to store a specific value in a partic)HY(u)HY(lar)YH( database + system. All such excep)HY(tions)YH( derive from the + )SM(odb::boost::excep)HY(tion)YH()ES( class which in turn derives from + the root of the ODB excep)HY(tion)YH( hier)HY(ar)HY(chy)YH(, class )SM(odb::excep)HY(tion)YH()ES( + \201)0 37 1 A(Section 3.14, "ODB Excep)HY(tions)YH(")37 0 TN TL()Ec /AF f D(\202. The + )SM(odb::boost::excep)HY(tion)YH()ES( class is defined in the + )SM()ES( header file and has the + same inter)HY(face)YH( as )SM(odb::excep)HY(tion)YH()ES(. Concrete excep)HY(tions)YH( + that can be thrown by the Boost sub-profiles are described in the + follow)HY(ing)YH( sections.)EP( + + )0 2 288 H(23.1)WB 613 Sn()WB 293 Sn( Smart Point)HY(ers)YH( Library)EA()EH( + + )0 P(The )SM(smart-ptr)ES( sub-profile provides persis)HY(tence)YH( + support for a subset of smart point)HY(ers)YH( from the Boost + )SM(smart_ptr)ES( library. To enable only this profile, + pass )SM(boost/smart-ptr)ES( to the )SM(--profile)ES( + ODB compiler option.)EP( + + )0 P(The currently supported smart point)HY(ers)YH( are + )SM(boost::shared_ptr)ES( and )SM(boost::weak_ptr)ES(. For + more infor)HY(ma)HY(tion)YH( on using smart point)HY(ers)YH( as point)HY(ers)YH( to objects and + views, refer to )0 26 1 A(Section 3.3, "Object and View Point)HY(ers)YH(")26 0 TN TL()Ec /AF f D( + and )0 52 1 A(Chapter 6, "Rela)HY(tion)HY(ships)YH(")52 0 TN TL()Ec /AF f D(. For more infor)HY(ma)HY(tion)YH( + on using smart point)HY(ers)YH( as point)HY(ers)YH( to values, refer to + )0 68 1 A(Section 7.3, "Point)HY(ers)YH( and )SM(NULL)ES( Value + Seman)HY(tics)YH(")68 0 TN TL()Ec /AF f D(. When used as a pointer to a value, only + )SM(boost::shared_ptr)ES( is supported. For example:)EP( + + ) 8 46 PR(#pragma db object +class person +{ + ... + + #pragma db null + boost::shared_ptr middle_name_; +};)RP( + + )0 P(To provide finer grained control over object rela)HY(tion)HY(ship)YH( loading, + the )SM(smart-ptr)ES( sub-profile also provides the lazy + coun)HY(ter)HY(parts)YH( for the above point)HY(ers)YH(: )SM(odb::boost::lazy_shared_ptr)ES( and + )SM(odb::boost::lazy_weak_ptr)ES(. You will need to include the + )SM()ES( header file to make the lazy + vari)HY(ants)YH( avail)HY(able)YH( in your appli)HY(ca)HY(tion)YH(. For a descrip)HY(tion)YH( of the lazy + pointer inter)HY(face)YH( and seman)HY(tics)YH( refer to )0 61 1 A(Section 6.4, + "Lazy Point)HY(ers)YH(")61 0 TN TL()Ec /AF f D(. The follow)HY(ing)YH( example shows how we can use these + smart point)HY(ers)YH( to estab)HY(lish)YH( a rela)HY(tion)HY(ship)YH( between persis)HY(tent)YH( objects.)EP( + + ) 19 48 PR(class employee; + +#pragma db object +class position +{ + ... + + #pragma db inverse\201position_\202 + odb::boost::lazy_weak_ptr employee_; +}; + +#pragma db object +class employee +{ + ... + + #pragma db not_null + boost::shared_ptr position_; +};)RP( + + )0 P(Besides provid)HY(ing)YH( persis)HY(tence)YH( support for the above smart point)HY(ers)YH(, + the )SM(smart-ptr)ES( sub-profile also changes the default + pointer \201)0 26 1 A(Section 3.3, "Object and View Point)HY(ers)YH(")26 0 TN TL()Ec /AF f D(\202 + to )SM(boost::shared_ptr)ES(. In partic)HY(u)HY(lar)YH(, this means that + database func)HY(tions)YH( that return dynam)HY(i)HY(cally)YH( allo)HY(cated)YH( objects and views + will return them as )SM(boost::shared_ptr)ES( point)HY(ers)YH(. To over)HY(ride)YH( + this behav)HY(ior)YH(, add the )SM(--default-pointer)ES( option spec)HY(i)HY(fy)HY(ing)YH( + the alter)HY(na)HY(tive)YH( pointer type after the )SM(--profile)ES( option.)EP( + + )0 2 289 H(23.2)WB 614 Sn()WB 294 Sn( Unordered Contain)HY(ers)YH( Library)EA()EH( + + )0 P(The )SM(unordered)ES( sub-profile provides persis)HY(tence)YH( support for + the contain)HY(ers)YH( from the Boost )SM(unordered)ES( library. To enable + only this profile, pass )SM(boost/unordered)ES( to + the )SM(--profile)ES( ODB compiler option.)EP( + + )0 P(The supported contain)HY(ers)YH( are )SM(boost::unordered_set)ES(, + )SM(boost::unordered_map)ES(, )SM(boost::unordered_multi)HY(set)YH()ES(, + and )SM(boost::unordered_multimap)ES(. For more infor)HY(ma)HY(tion)YH( on using + the set and multi)HY(set)YH( contain)HY(ers)YH( with ODB, refer to )0 47 1 A(Section + 5.2, "Set and Multi)HY(set)YH( Contain)HY(ers)YH(")47 0 TN TL()Ec /AF f D(. For more infor)HY(ma)HY(tion)YH( on using the + map and multimap contain)HY(ers)YH( with ODB, refer to )0 48 1 A( Section + 5.3, "Map and Multimap Contain)HY(ers)YH(")48 0 TN TL()Ec /AF f D(. The follow)HY(ing)YH( example shows how + the )SM(unordered_set)ES( container may be used within a persis)HY(tent)YH( + object.)EP( + + ) 6 44 PR(#pragma db object +class person +{ + ... + boost::unordered_set emails_; +};)RP( + + )0 2 290 H(23.3)WB 615 Sn()WB 295 Sn( Multi-Index Container Library)EA()EH( + + )0 P(The )SM(multi-index)ES( sub-profile provides persis)HY(tence)YH( support for + )SM(boost::multi_index_container)ES( from the Boost Multi-Index + library. To enable only this profile, pass )SM(boost/multi-index)ES( + to the )SM(--profile)ES( ODB compiler option. The follow)HY(ing)YH( example + shows how )SM(multi_index_container)ES( may be used within a + persis)HY(tent)YH( object.)EP( + + ) 18 52 PR(namespace mi = boost::multi_index; + +#pragma db object +class person +{ + ... + + typedef + mi::multi_index_container< + std::string, + mi::indexed_by< + mi::sequenced<>, + mi::ordered_unique > + > + > emails; + + emails emails_; +};)RP( + + )0 P(Note that a )SM(multi_index_container)ES( instan)HY(ti)HY(a)HY(tion)YH( is + stored differ)HY(ently)YH( in the database depend)HY(ing)YH( on whether it has + any )SM(sequenced)ES( or )SM(random_access)ES( indexes. + If it does, then it is treated as an ordered container + \201)0 46 1 A(Section 5.1, "Ordered Contain)HY(ers)YH(")46 0 TN TL()Ec /AF f D(\202 with the + first such index estab)HY(lish)HY(ing)YH( the order. Other)HY(wise)YH(, it is treated + as a set container \201)0 47 1 A(Section 5.2, "Set and Multi)HY(set)YH( + Contain)HY(ers)YH(")47 0 TN TL()Ec /AF f D(\202.)EP( + + )0 P(Note also that there is a termi)HY(nol)HY(ogy)YH( clash between ODB and Boost + Multi-Index. The ODB term )EM(ordered container)ES( trans)HY(lates)YH( + to Multi-Index terms )EM(sequenced index)ES( and )EM(random access + index)ES( while the ODB term )EM(set container)ES( trans)HY(lates)YH( + to Multi-Index terms )EM(ordered index)ES( and )EM(hashed + index)ES(.)EP( + + )0 P(The )SM(emails)ES( container from the above example is stored + as an ordered container. In contrast, the follow)HY(ing)YH( )SM(aliases)ES( + container is stored as a set.)EP( + + ) 32 51 PR(namespace mi = boost::multi_index; + +#pragma db value +struct name +{ + std::string first; + std::string last; +}; + +bool operator< \201const name&, const name&\202; + +#pragma db object +class person +{ + ... + + typedef + mi::multi_index_container< + name, + mi::indexed_by< + mi::ordered_unique > + mi::ordered_non_unique< + mi::member + >, + mi::ordered_non_unique< + mi::member + > + > + > aliases; + + aliases aliases_;)WR( +};)RP( + + )0 2 291 H(23.4)WB 616 Sn()WB 296 Sn( Optional Library)EA()EH( + + )0 P(The )SM(optional)ES( sub-profile provides persis)HY(tence)YH( support for + the )SM(boost::optional)ES( container from the Boost + )SM(optional)ES( library. To enable only this profile, pass + )SM(boost/optional)ES( to the )SM(--profile)ES( ODB compiler + option.)EP( + + )0 P(In a rela)HY(tional)YH( database )SM(boost::optional)ES( is mapped to + a column that can have a )SM(NULL)ES( value. Similar to + )SM(odb::nullable)ES( \201)0 68 1 A(Section 7.3, "Point)HY(ers)YH( and + )SM(NULL)ES( Value Seman)HY(tics)YH(")68 0 TN TL()Ec /AF f D(\202, it can be used to add the + )SM(NULL)ES( seman)HY(tics)YH( to exist)HY(ing)YH( C++ types. For example:)EP( + + ) 11 57 PR(#include + +#pragma db object +class person +{ + ... + + std::string first_; // TEXT NOT NULL + boost::optional middle_; // TEXT NULL + std::string last_; // TEXT NOT NULL +};)RP( + + )0 P(Note also that similar to )SM(odb::nullable)ES(, when + this profile is used, the )SM(NULL)ES( values are auto)HY(mat)HY(i)HY(cally)YH( + enabled for data members of the )SM(boost::optional)ES( type.)EP( + + )0 2 292 H(23.5)WB 617 Sn()WB 297 Sn( Date Time Library)EA()EH( + + )0 P(The )SM(date-time)ES( sub-profile provides persis)HY(tence)YH( support for a + subset of types from the Boost )SM(date_time)ES( library. It is + further subdi)HY(vided)YH( into two sub-profiles, )SM(grego)HY(rian)YH()ES( + and )SM(posix_time)ES(. The )SM(grego)HY(rian)YH()ES( sub-profile + provides support for types from the )SM(boost::grego)HY(rian)YH()ES( + names)HY(pace)YH(, while the )SM(posix-time)ES( sub-profile provides support + for types from the )SM(boost::posix_time)ES( names)HY(pace)YH(. To enable + the entire )SM(date-time)ES( sub-profile, pass + )SM(boost/date-time)ES( to the )SM(--profile)ES( ODB compiler + option. To enable only the )SM(grego)HY(rian)YH()ES( sub-profile, pass + )SM(boost/date-time/grego)HY(rian)YH()ES(, and to enable only the + )SM(posix-time)ES( sub-profile, pass + )SM(boost/date-time/posix-time)ES(.)EP( + + )0 P(The only type that the )SM(grego)HY(rian)YH()ES( sub-profile currently + supports is )SM(grego)HY(rian)YH(::date)ES(. The types currently supported + by the )SM(posix-time)ES( sub-profile are + )SM(posix_time::ptime)ES( and + )SM(posix_time::time_dura)HY(tion)YH()ES(. The manner in which these types + are persisted is database system depen)HY(dent)YH( and is discussed in the + sub-sections that follow. The example below shows how + )SM(grego)HY(rian)YH(::date)ES( may be used within a persis)HY(tent)YH( object.)EP( + + ) 6 40 PR(#pragma db object +class person +{ + ... + boost::gregorian::date date_of_birth_; +};)RP( + + )0 P(Concrete excep)HY(tions)YH( that can be thrown by the )SM(date-time)ES( + sub-profile imple)HY(men)HY(ta)HY(tion)YH( are presented below.)EP( + + + ) 20 54 PR(namespace odb +{ + namespace boost + { + namespace date_time + { + struct special_value: odb::boost::exception + { + virtual const char* + what \201\202 const throw \201\202; + }; + + struct value_out_of_range: odb::boost::exception + { + virtual const char* + what \201\202 const throw \201\202; + }; + } + } +})RP( + + )0 P(You will need to include the + )SM()ES( header file to + make these excep)HY(tions)YH( avail)HY(able)YH( in your appli)HY(ca)HY(tion)YH(.)EP( + + )0 P(The )SM(special_value)ES( excep)HY(tion)YH( is thrown if an attempt is made + to store a Boost date-time special value that cannot be repre)HY(sented)YH( in + the target database. The )SM(value_out_of_range)ES( excep)HY(tion)YH( is + thrown if an attempt is made to store a date-time value that is out of + the target database range. The specific condi)HY(tions)YH( under which these + excep)HY(tions)YH( are thrown are database system depen)HY(dent)YH( and are discussed in + more detail in the follow)HY(ing)YH( sub-sections.)EP( + + )0 3 293 H(23.5.1)WB 618 Sn()WB 298 Sn( MySQL Database Type Mapping)EA()EH( + + )0 P(The follow)HY(ing)YH( table summa)HY(rizes)YH( the default mapping between the currently + supported Boost )SM(date_time)ES( types and the MySQL database + types.)EP( + + + )17 PT( + + )0 P(The Boost special value )SM(date_time::not_a_date_time)ES( is stored + as a )SM(NULL)ES( value in a MySQL database.)EP( + + )0 P(The )SM(posix-time)ES( sub-profile imple)HY(men)HY(ta)HY(tion)YH( also provides + support for mapping )SM(posix_time::ptime)ES( to the + )SM(TIMES)HY(TAMP)YH()ES( MySQL type. However, this mapping has to be + explic)HY(itly)YH( requested using the )SM(db\240type)ES( pragma + \201)0 150 1 A(Section 14.4.3, ")SM(type)ES(")150 0 TN TL()Ec /AF f D(\202, as shown in + the follow)HY(ing)YH( example:)EP( + + ) 7 39 PR(#pragma db object +class person +{ + ... + #pragma db type\201"TIMESTAMP"\202 not_null + boost::posix_time::ptime updated_; +};)RP( + + )0 P(Start)HY(ing)YH( with MySQL version 5.6.4 it is possi)HY(ble)YH( to store frac)HY(tional)YH( + seconds up to microsec)HY(ond)YH( preci)HY(sion)YH( in )SM(TIME)ES(, + )SM(DATE)HY(TIME)YH()ES(, and )SM(TIMES)HY(TAMP)YH()ES( columns. However, + to enable sub-second preci)HY(sion)YH(, the corre)HY(spond)HY(ing)YH( type with the + desired preci)HY(sion)YH( has to be spec)HY(i)HY(fied)YH( explic)HY(itly)YH(, as shown in the + follow)HY(ing)YH( example:)EP( + + ) 7 62 PR(#pragma db object +class person +{ + ... + #pragma db type\201"DATETIME\2016\202"\202 // Microsecond precision. + boost::posix_time::ptime updated_; +};)RP( + + )0 P(Alter)HY(na)HY(tively)YH(, you can enable sub-second preci)HY(sion)YH( on the per-type + basis, for example:)EP( + + ) 9 62 PR(#pragma db value\201boost::posix_time::ptime\202 type\201"DATETIME\2016\202"\202 + +#pragma db object +class person +{ + ... + boost::posix_time::ptime created_; // Microsecond precision. + boost::posix_time::ptime updated_; // Microsecond precision. +};)RP( + + )0 P(Some valid Boost date-time values cannot be stored in a MySQL database. + An attempt to persist any Boost date-time special value other than + )SM(date_time::not_a_date_time)ES( will result in the + )SM(special_value)ES( excep)HY(tion)YH(. An attempt to persist a Boost + date-time value that is out of the MySQL type range will result in + the )SM(out_of_range)ES( excep)HY(tion)YH(. Refer to the MySQL + docu)HY(men)HY(ta)HY(tion)YH( for more infor)HY(ma)HY(tion)YH( on the MySQL data type ranges.)EP( + + )0 3 294 H(23.5.2)WB 619 Sn()WB 299 Sn( SQLite Database Type Mapping)EA()EH( + + )0 P(The follow)HY(ing)YH( table summa)HY(rizes)YH( the default mapping between the currently + supported Boost )SM(date_time)ES( types and the SQLite database + types.)EP( + + + )18 PT( + + )0 P(The Boost special value )SM(date_time::not_a_date_time)ES( is stored + as a )SM(NULL)ES( value in an SQLite database.)EP( + + )0 P(The )SM(date-time)ES( sub-profile imple)HY(men)HY(ta)HY(tion)YH( also provides + support for mapping )SM(grego)HY(rian)YH(::date)ES( and + )SM(posix_time::ptime)ES( to the )SM(INTEGER)ES( SQLite type, + with the integer value repre)HY(sent)HY(ing)YH( the UNIX time. Simi)HY(larly)YH(, an + alter)HY(na)HY(tive)YH( mapping for )SM(posix_time::time_dura)HY(tion)YH()ES( to the + )SM(INTEGER)ES( type repre)HY(sents)YH( the dura)HY(tion)YH( as a number of + seconds. These mappings have to be explic)HY(itly)YH( requested using the + )SM(db\240type)ES( pragma \201)0 150 1 A(Section 14.4.3, + ")SM(type)ES(")150 0 TN TL()Ec /AF f D(\202, as shown in the follow)HY(ing)YH( example:)EP( + + ) 7 31 PR(#pragma db object +class person +{ + ... + #pragma db type\201"INTEGER"\202 + boost::gregorian::date born_; +};)RP( + + + + )0 P(Some valid Boost date-time values cannot be stored in an SQLite database. + An attempt to persist any Boost date-time special value other than + )SM(date_time::not_a_date_time)ES( will result in the + )SM(special_value)ES( excep)HY(tion)YH(. An attempt to persist a nega)HY(tive)YH( + )SM(posix_time::time_dura)HY(tion)YH()ES( value as SQLite )SM(TEXT)ES( + will result in the )SM(out_of_range)ES( excep)HY(tion)YH(.)EP( + + + )0 3 295 H(23.5.3)WB 620 Sn()WB 300 Sn( Post)HY(greSQL)YH( Database Type Mapping)EA()EH( + + )0 P(The follow)HY(ing)YH( table summa)HY(rizes)YH( the default mapping between the currently + supported Boost )SM(date_time)ES( types and the Post)HY(greSQL)YH( database + types.)EP( + + + )19 PT( + + )0 P(The Boost special value )SM(date_time::not_a_date_time)ES( is stored + as a )SM(NULL)ES( value in a Post)HY(greSQL)YH( database. + )SM(posix_time::ptime)ES( values repre)HY(sent)HY(ing)YH( the special values + )SM(date_time::pos_infin)ES( and )SM(date_time::neg_infin)ES( + are stored as the special Post)HY(greSQL)YH( TIMES)HY(TAMP)YH( values + )SM(infin)HY(ity)YH()ES( and )SM(-infin)HY(ity)YH()ES(, respec)HY(tively)YH(.)EP( + + )0 P(Some valid Boost date-time values cannot be stored in a Post)HY(greSQL)YH( + database. The Post)HY(greSQL)YH( TIME type repre)HY(sents)YH( a clock time, and can + there)HY(fore)YH( only store posi)HY(tive)YH( dura)HY(tions)YH( with a total length of time less + than 24 hours. An attempt to persist a + )SM(posix_time::time_dura)HY(tion)YH()ES( value outside of this range will + result in the )SM(value_out_of_range)ES( excep)HY(tion)YH(. An attempt to + persist a )SM(posix_time::time_dura)HY(tion)YH()ES( value repre)HY(sent)HY(ing)YH( any + special value other than )SM(date_time::not_a_date_time)ES( will + result in the )SM(special_value)ES( excep)HY(tion)YH(.)EP( + + + )0 3 296 H(23.5.4)WB 621 Sn()WB 301 Sn( Oracle Database Type Mapping)EA()EH( + + )0 P(The follow)HY(ing)YH( table summa)HY(rizes)YH( the default mapping between the currently + supported Boost )SM(date_time)ES( types and the Oracle database + types.)EP( + + + )20 PT( + + )0 P(The Boost special value )SM(date_time::not_a_date_time)ES( is stored + as a )SM(NULL)ES( value in an Oracle database.)EP( + + )0 P(The )SM(date-time)ES( sub-profile imple)HY(men)HY(ta)HY(tion)YH( also provides + support for mapping )SM(posix_time::ptime)ES( to the + )SM(DATE)ES( Oracle type with frac)HY(tional)YH( seconds that may be + stored in a )SM(ptime)ES( instance being ignored. This + alter)HY(na)HY(tive)YH( mapping has to be explic)HY(itly)YH( requested using the + )SM(db\240type)ES( pragma \201)0 150 1 A(Section 14.4.3, + ")SM(type)ES(")150 0 TN TL()Ec /AF f D(\202, as shown in the follow)HY(ing)YH( example:)EP( + + ) 7 36 PR(#pragma db object +class person +{ + ... + #pragma db type\201"DATE"\202 + boost::posix_time::ptime updated_; +};)RP( + + )0 P(Some valid Boost date-time values cannot be stored in an Oracle database. + An attempt to persist a )SM(grego)HY(rian)YH(::date)ES(, + )SM(posix_time::ptime)ES(, or + )SM(posix_time::time_dura)HY(tion)YH()ES( value repre)HY(sent)HY(ing)YH( any special + value other than )SM(date_time::not_a_date_time)ES( will result in + the )SM(special_value)ES( excep)HY(tion)YH(.)EP( + + + )0 3 297 H(23.5.5)WB 622 Sn()WB 302 Sn( SQL Server Database Type Mapping)EA()EH( + + )0 P(The follow)HY(ing)YH( table summa)HY(rizes)YH( the default mapping between the currently + supported Boost )SM(date_time)ES( types and the SQL Server database + types.)EP( + + + )21 PT( + + )0 P(The Boost special value )SM(date_time::not_a_date_time)ES( is stored + as a )SM(NULL)ES( value in an SQL Server database.)EP( + + )0 P(Note that the )SM(DATE)ES(, )SM(TIME)ES(, and + )SM(DATE)HY(TIME)YH(2)ES( types are only avail)HY(able)YH( in SQL Server 2008 and + later. SQL Server 2005 only supports the )SM(DATE)HY(TIME)YH()ES( and + )SM(SMALL)HY(DATE)HY(TIME)YH()ES( date-time types. The new types are + also unavail)HY(able)YH( when connect)HY(ing)YH( to an SQL Server 2008 or + later with the SQL Server 2005 Native Client ODBC driver.)EP( + + )0 P(The )SM(date-time)ES( sub-profile imple)HY(men)HY(ta)HY(tion)YH( provides + support for mapping )SM(posix_time::ptime)ES( to the + )SM(DATE)HY(TIME)YH()ES( and )SM(SMALL)HY(DATE)HY(TIME)YH()ES( types, + however, this mapping has to be explic)HY(itly)YH( requested using the + )SM(db\240type)ES( pragma \201)0 150 1 A(Section 14.4.3, + ")SM(type)ES(")150 0 TN TL()Ec /AF f D(\202, as shown in the follow)HY(ing)YH( example:)EP( + + ) 7 36 PR(#pragma db object +class person +{ + ... + #pragma db type\201"DATETIME"\202 + boost::posix_time::ptime updated_; +};)RP( + + )0 P(Some valid Boost date-time values cannot be stored in an SQL Server + database. An attempt to persist a )SM(grego)HY(rian)YH(::date)ES(, + )SM(posix_time::ptime)ES(, or )SM(posix_time::time_dura)HY(tion)YH()ES( + value repre)HY(sent)HY(ing)YH( any special value other than + )SM(date_time::not_a_date_time)ES( will result in the + )SM(special_value)ES( excep)HY(tion)YH(. The range of the )SM(TIME)ES( + type in SQL server is from )SM(00:00:00.0000000)ES( to + )SM(23:59:59.9999999)ES(. An attempt to persist a + )SM(posix_time::time_dura)HY(tion)YH()ES( value out of this range will + result in the )SM(value_out_of_range)ES( excep)HY(tion)YH(.)EP( + + )0 2 298 H(23.6)WB 623 Sn()WB 303 Sn( Uuid Library)EA()EH( + + )0 P(The )SM(uuid)ES( sub-profile provides persis)HY(tence)YH( support for the + )SM(uuid)ES( type from the Boost )SM(uuid)ES( library. To + enable only this profile, pass )SM(boost/uuid)ES( to the + )SM(--profile)ES( ODB compiler option.)EP( + + )0 P(The manner in which these types are persisted is database system + depen)HY(dent)YH( and is discussed in the sub-sections that follow. By + default a data member of the )SM(uuid)ES( type is mapped to a + database column with )SM(NULL)ES( enabled and nil )SM(uuid)ES( + instances are stored as a )SM(NULL)ES( value. However, you can + change this behav)HY(ior)YH( by declar)HY(ing)YH( the data member )SM(NOT NULL)ES( + with the )SM(not_null)ES( pragma \201)0 153 1 A(Section + 14.4.6, ")SM(null)ES(/)SM(not_null)ES(")153 0 TN TL()Ec /AF f D(\202. In this + case, or if the data member is an object id, the imple)HY(men)HY(ta)HY(tion)YH( + will store nil )SM(uuid)ES( instances as zero UUID values + \201)SM({00000000-0000-0000-0000-000000000000})ES(\202. For example:)EP( + + ) 10 54 PR(#pragma db object +class object +{ + ... + + boost::uuids::uuid x_; // Nil values stored as NULL. + + #pragma db not_null + boost::uuids::uuid y_; // Nil values stored as zero. +};)RP( + + )0 3 299 H(23.6.1)WB 624 Sn()WB 304 Sn( MySQL Database Type Mapping)EA()EH( + + )0 P(The follow)HY(ing)YH( table summa)HY(rizes)YH( the default mapping between the Boost + )SM(uuid)ES( type and the MySQL database type.)EP( + + + )22 PT( + + )0 3 300 H(23.6.2)WB 625 Sn()WB 305 Sn( SQLite Database Type Mapping)EA()EH( + + )0 P(The follow)HY(ing)YH( table summa)HY(rizes)YH( the default mapping between the Boost + )SM(uuid)ES( type and the SQLite database type.)EP( + + + )23 PT( + + )0 3 301 H(23.6.3)WB 626 Sn()WB 306 Sn( Post)HY(greSQL)YH( Database Type Mapping)EA()EH( + + )0 P(The follow)HY(ing)YH( table summa)HY(rizes)YH( the default mapping between the Boost + )SM(uuid)ES( type and the Post)HY(greSQL)YH( database type.)EP( + + + )24 PT( + + )0 3 302 H(23.6.4)WB 627 Sn()WB 307 Sn( Oracle Database Type Mapping)EA()EH( + + )0 P(The follow)HY(ing)YH( table summa)HY(rizes)YH( the default mapping between the Boost + )SM(uuid)ES( type and the Oracle database type.)EP( + + + )25 PT( + + )0 3 303 H(23.6.5)WB 628 Sn()WB 308 Sn( SQL Server Database Type Mapping)EA()EH( + + )0 P(The follow)HY(ing)YH( table summa)HY(rizes)YH( the default mapping between the Boost + )SM(uuid)ES( type and the SQL Server database type.)EP( + + + )26 PT( + + + + + + )WB NL NP( + )0 1 304 H(24)WB 629 Sn()WB 309 Sn( Qt Profile)EA()EH( + + )0 P(The ODB profile imple)HY(men)HY(ta)HY(tion)YH( for Qt is provided by the + )SM(libodb-qt)ES( library. Both Qt4 and Qt5 as well + as C++98/03 and C++11 are supported.)EP( + + )0 P(The Qt profile consists of multi)HY(ple)YH( sub-profiles + corre)HY(spond)HY(ing)YH( to the common type groups within Qt. Currently, + only types from the )SM(QtCore)ES( module are supported. To + enable all the avail)HY(able)YH( Qt sub-profiles, pass )SM(qt)ES( as the + profile name to the )SM(--profile)ES( ODB compiler option. + Alter)HY(na)HY(tively)YH(, you can enable only specific sub-profiles by passing + indi)HY(vid)HY(ual)YH( sub-profile names to )SM(--profile)ES(. The follow)HY(ing)YH( + sections in this chapter discuss each Qt sub-profile in detail. The + )SM(qt)ES( example in the )SM(odb-exam)HY(ples)YH()ES( + package shows how to enable and use the Qt profile.)EP( + + )0 P(Some sub-profiles may throw excep)HY(tions)YH( to indi)HY(cate)YH( error condi)HY(tions)YH(, + such as the inabil)HY(ity)YH( to store a specific value in a partic)HY(u)HY(lar)YH( database + system. All such excep)HY(tions)YH( derive from the + )SM(odb::qt::excep)HY(tion)YH()ES( class which in turn derives from + the root of the ODB excep)HY(tion)YH( hier)HY(ar)HY(chy)YH(, class )SM(odb::excep)HY(tion)YH()ES( + \201)0 37 1 A(Section 3.14, "ODB Excep)HY(tions)YH(")37 0 TN TL()Ec /AF f D(\202. The + )SM(odb::qt::excep)HY(tion)YH()ES( class is defined in the + )SM()ES( header file and has the + same inter)HY(face)YH( as )SM(odb::excep)HY(tion)YH()ES(. Concrete excep)HY(tions)YH( + that can be thrown by the Qt sub-profiles are described in the + follow)HY(ing)YH( sections.)EP( + + )0 2 305 H(24.1)WB 630 Sn()WB 310 Sn( Basic Types Library)EA()EH( + + )0 P(The )SM(basic)ES( sub-profile provides persis)HY(tence)YH( support for basic + types defined by Qt. To enable only this profile, pass + )SM(qt/basic)ES( to the )SM(--profile)ES( ODB compiler + option.)EP( + + )0 P(The currently supported basic types are )SM(QString)ES(, + )SM(QByteAr)HY(ray)YH()ES(, and )SM(QUuid)ES(. The manner in + which these types are persisted is database system depen)HY(dent)YH( + and is discussed in the sub-sections that follow. The example + below shows how )SM(QString)ES( may be used within a + persis)HY(tent)YH( object.)EP( + + ) 6 17 PR(#pragma db object +class Person +{ + ... + QString name_; +};)RP( + + )0 P(By default a data member of the )SM(QUuid)ES( type is mapped to a + database column with )SM(NULL)ES( enabled and null )SM(QUuid)ES( + instances are stored as a )SM(NULL)ES( value. However, you can + change this behav)HY(ior)YH( by declar)HY(ing)YH( the data member )SM(NOT NULL)ES( + with the )SM(not_null)ES( pragma \201)0 153 1 A(Section + 14.4.6, ")SM(null)ES(/)SM(not_null)ES(")153 0 TN TL()Ec /AF f D(\202. In this + case, or if the data member is an object id, the imple)HY(men)HY(ta)HY(tion)YH( + will store null )SM(QUuid)ES( instances as zero UUID values + \201)SM({00000000-0000-0000-0000-000000000000})ES(\202. For example:)EP( + + ) 10 42 PR(#pragma db object +class object +{ + ... + + QUuid x_; // Null values stored as NULL. + + #pragma db not_null + QUuid y_; // Null values stored as zero. +};)RP( + + )0 3 306 H(24.1.1)WB 631 Sn()WB 311 Sn( MySQL Database Type Mapping)EA()EH( + + )0 P(The follow)HY(ing)YH( table summa)HY(rizes)YH( the default mapping between the currently + supported basic Qt types and the MySQL database types.)EP( + + + )27 PT( + + )0 P(Instances of the )SM(QString)ES( and )SM(QByteAr)HY(ray)YH()ES( + types are stored as a )SM(NULL)ES( value if their + )SM(isNull\201\202)ES( member func)HY(tion)YH( returns )SM(true)ES(.)EP( + + )0 P(Note also that the )SM(QString)ES( type is mapped + differ)HY(ently)YH( depend)HY(ing)YH( on whether a member of this type + is an object id or not. If the member is an object id, + then for this member )SM(QString)ES( is mapped + to the )SM(VARCHAR\201255\202)ES( MySQL type. Other)HY(wise)YH(, + it is mapped to )SM(TEXT)ES(.)EP( + + )0 P(The )SM(basic)ES( sub-profile also provides support + for mapping )SM(QString)ES( to the )SM(CHAR)ES(, + )SM(NCHAR)ES(, and )SM(NVAR)HY(CHAR)YH()ES( MySQL types. + However, these alter)HY(na)HY(tive)YH( mappings have to be explic)HY(itly)YH( + requested using the )SM(db\240type)ES( pragma + \201)0 150 1 A(Section 14.4.3, "type")150 0 TN TL()Ec /AF f D(\202, as shown in + the follow)HY(ing)YH( example:)EP( + + ) 8 37 PR(#pragma db object +class Person +{ + ... + + #pragma db type\201"CHAR\2012\202"\202 not_null + QString licenseState_; +};)RP( + + + )0 3 307 H(24.1.2)WB 632 Sn()WB 312 Sn( SQLite Database Type Mapping)EA()EH( + + )0 P(The follow)HY(ing)YH( table summa)HY(rizes)YH( the default mapping between the currently + supported basic Qt types and the SQLite database types.)EP( + + + )28 PT( + + )0 P(Instances of the )SM(QString)ES( and )SM(QByteAr)HY(ray)YH()ES( types + are stored as a )SM(NULL)ES( value if their )SM(isNull\201\202)ES( + member func)HY(tion)YH( returns )SM(true)ES(.)EP( + + )0 3 308 H(24.1.3)WB 633 Sn()WB 313 Sn( Post)HY(greSQL)YH( Database Type Mapping)EA()EH( + + )0 P(The follow)HY(ing)YH( table summa)HY(rizes)YH( the default mapping between the currently + supported basic Qt types and the Post)HY(greSQL)YH( database types.)EP( + + + )29 PT( + + )0 P(Instances of the )SM(QString)ES( and )SM(QByteAr)HY(ray)YH()ES( types + are stored as a )SM(NULL)ES( value if their )SM(isNull\201\202)ES( + member func)HY(tion)YH( returns )SM(true)ES(.)EP( + + )0 P(The )SM(basic)ES( sub-profile also provides support + for mapping )SM(QString)ES( to the )SM(CHAR)ES( + and )SM(VARCHAR)ES( Post)HY(greSQL)YH( types. + However, these alter)HY(na)HY(tive)YH( mappings have to be explic)HY(itly)YH( + requested using the )SM(db\240type)ES( pragma + \201)0 150 1 A(Section 14.4.3, "type")150 0 TN TL()Ec /AF f D(\202, as shown in + the follow)HY(ing)YH( example:)EP( + + ) 8 37 PR(#pragma db object +class Person +{ + ... + + #pragma db type\201"CHAR\2012\202"\202 not_null + QString licenseState_; +};)RP( + + )0 3 309 H(24.1.4)WB 634 Sn()WB 314 Sn( Oracle Database Type Mapping)EA()EH( + + )0 P(The follow)HY(ing)YH( table summa)HY(rizes)YH( the default mapping between the currently + supported basic Qt types and the Oracle database types.)EP( + + + )30 PT( + + )0 P(Instances of the )SM(QString)ES( and )SM(QByteAr)HY(ray)YH()ES( types + are stored as a )SM(NULL)ES( value if their )SM(isNull\201\202)ES( + member func)HY(tion)YH( returns )SM(true)ES(.)EP( + + )0 P(The )SM(basic)ES( sub-profile also provides support + for mapping )SM(QString)ES( to the )SM(CHAR)ES(, + )SM(NCHAR)ES(, )SM(NVAR)HY(CHAR)YH()ES(, )SM(CLOB)ES(, and + )SM(NCLOB)ES( Oracle types, and for mapping )SM(QByteAr)HY(ray)YH()ES( + to the )SM(RAW)ES( Oracle type. However, these alter)HY(na)HY(tive)YH( + mappings have to be explic)HY(itly)YH( requested using the )SM(db\240type)ES( + pragma \201)0 150 1 A(Section 14.4.3, "type")150 0 TN TL()Ec /AF f D(\202, as shown in the + follow)HY(ing)YH( example:)EP( + + ) 11 34 PR(#pragma db object +class Person +{ + ... + + #pragma db type\201"CLOB"\202 not_null + QString firstName_; + + #pragma db type\201"RAW\20116\202"\202 null + QByteArray uuid_; +};)RP( + + )0 3 310 H(24.1.5)WB 635 Sn()WB 315 Sn( SQL Server Database Type Mapping)EA()EH( + + )0 P(The follow)HY(ing)YH( table summa)HY(rizes)YH( the default mapping between the currently + supported basic Qt types and the SQL Server database types.)EP( + + + )31 PT( + + )0 P(Instances of the )SM(QString)ES( and )SM(QByteAr)HY(ray)YH()ES( types + are stored as a )SM(NULL)ES( value if their )SM(isNull\201\202)ES( + member func)HY(tion)YH( returns )SM(true)ES(.)EP( + + )0 P(Note also that the )SM(QString)ES( type is mapped + differ)HY(ently)YH( depend)HY(ing)YH( on whether a member of this type + is an object id or not. If the member is an object id, + then for this member )SM(QString)ES( is mapped + to the )SM(VARCHAR\201256\202)ES( SQL Server type. Other)HY(wise)YH(, + it is mapped to )SM(VARCHAR\201512\202)ES(.)EP( + + )0 P(The )SM(basic)ES( sub-profile also provides support + for mapping )SM(QString)ES( to the )SM(CHAR)ES(, + )SM(NCHAR)ES(, )SM(NVAR)HY(CHAR)YH()ES(, )SM(TEXT)ES(, and + )SM(NTEXT)ES( SQL Server types, and for mapping + )SM(QByteAr)HY(ray)YH()ES( to the )SM(BINARY)ES( and + )SM(IMAGE)ES( SQL Server types. However, these alter)HY(na)HY(tive)YH( + mappings have to be explic)HY(itly)YH( requested using the )SM(db\240type)ES( + pragma \201)0 150 1 A(Section 14.4.3, "type")150 0 TN TL()Ec /AF f D(\202, as shown in the + follow)HY(ing)YH( example:)EP( + + ) 11 43 PR(#pragma db object +class Person +{ + ... + + #pragma db type\201"NVARCHAR\201256\202"\202 not_null + QString firstName_; + + #pragma db type\201"BINARY\20116\202"\202 null + QByteArray uuid_; +};)RP( + + )0 2 311 H(24.2)WB 636 Sn()WB 316 Sn( Smart Point)HY(ers)YH( Library)EA()EH( + + )0 P(The )SM(smart-ptr)ES( sub-profile provides persis)HY(tence)YH( support the + Qt smart point)HY(ers)YH(. To enable only this profile, pass + )SM(qt/smart-ptr)ES( to the )SM(--profile)ES( ODB compiler + option.)EP( + + )0 P(The currently supported smart point)HY(ers)YH( are + )SM(QShared)HY(Pointer)YH()ES( and )SM(QWeak)HY(Pointer)YH()ES(. + For more infor)HY(ma)HY(tion)YH( on using smart point)HY(ers)YH( as point)HY(ers)YH( to objects + and views, refer to )0 26 1 A(Section 3.3, "Object and View + Point)HY(ers)YH(")26 0 TN TL()Ec /AF f D( and )0 52 1 A(Chapter 6, "Rela)HY(tion)HY(ships)YH(")52 0 TN TL()Ec /AF f D(. For + more infor)HY(ma)HY(tion)YH( on using smart point)HY(ers)YH( as point)HY(ers)YH( to values, refer + to )0 68 1 A(Section 7.3, "Point)HY(ers)YH( and )SM(NULL)ES( Value + Seman)HY(tics)YH(")68 0 TN TL()Ec /AF f D(. When used as a pointer to a value, only + )SM(QShared)HY(Pointer)YH()ES( is supported. For example:)EP( + + ) 8 39 PR(#pragma db object +class person +{ + ... + + #pragma db null + QSharedPointer middle_name_; +};)RP( + + )0 P(To provide finer grained control over object rela)HY(tion)HY(ship)YH( loading, + the )SM(smart-ptr)ES( sub-profile also provides the lazy + coun)HY(ter)HY(parts)YH( for the above point)HY(ers)YH(: )SM(QLazyShared)HY(Pointer)YH()ES( + and )SM(QLazy)HY(Weak)HY(Pointer)YH()ES(. You will need to include the + )SM()ES( header file to make the lazy + vari)HY(ants)YH( avail)HY(able)YH( in your appli)HY(ca)HY(tion)YH(. For a descrip)HY(tion)YH( of the lazy + pointer inter)HY(face)YH( and seman)HY(tics)YH( refer to )0 61 1 A(Section 6.4, + "Lazy Point)HY(ers)YH(")61 0 TN TL()Ec /AF f D(. The follow)HY(ing)YH( example shows how we can use these + smart point)HY(ers)YH( to estab)HY(lish)YH( a rela)HY(tion)HY(ship)YH( between persis)HY(tent)YH( objects.)EP( + + ) 19 39 PR(class Employee; + +#pragma db object +class Position +{ + ... + + #pragma db inverse\201position_\202 + QLazyWeakPointer employee_; +}; + +#pragma db object +class Employee +{ + ... + + #pragma db not_null + QSharedPointer position_; +};)RP( + + )0 P(Besides provid)HY(ing)YH( persis)HY(tence)YH( support for the above smart point)HY(ers)YH(, + the )SM(smart-ptr)ES( sub-profile also changes the default + pointer \201)0 26 1 A(Section 3.3, "Object and View Point)HY(ers)YH(")26 0 TN TL()Ec /AF f D(\202 + to )SM(QShared)HY(Pointer)YH()ES(. In partic)HY(u)HY(lar)YH(, this means that + database func)HY(tions)YH( that return dynam)HY(i)HY(cally)YH( allo)HY(cated)YH( objects and views + will return them as )SM(QShared)HY(Pointer)YH()ES( point)HY(ers)YH(. To over)HY(ride)YH( + this behav)HY(ior)YH(, add the )SM(--default-pointer)ES( option spec)HY(i)HY(fy)HY(ing)YH( + the alter)HY(na)HY(tive)YH( pointer type after the )SM(--profile)ES( option.)EP( + + )0 2 312 H(24.3)WB 637 Sn()WB 317 Sn( Contain)HY(ers)YH( Library)EA()EH( + + )0 P(The )SM(contain)HY(ers)YH()ES( sub-profile provides persis)HY(tence)YH( support for + Qt contain)HY(ers)YH(. To enable only this profile, pass + )SM(qt/contain)HY(ers)YH()ES( to the )SM(--profile)ES( ODB compiler + option.)EP( + + )0 P(The currently supported ordered contain)HY(ers)YH( are )SM(QVector)ES(, + )SM(QList)ES(, and )SM(QLinkedList)ES(. Supported map + contain)HY(ers)YH( are )SM(QMap)ES(, )SM(QMul)HY(tiMap)YH()ES(, + )SM(QHash)ES(, and )SM(QMul)HY(ti)HY(Hash)YH()ES(. The supported set + container is )SM(QSet)ES(. For more infor)HY(ma)HY(tion)YH( on using + contain)HY(ers)YH( with ODB, refer to )0 45 1 A(Chapter 5, "Contain)HY(ers)YH(")45 0 TN TL()Ec /AF f D(. + The follow)HY(ing)YH( example shows how the )SM(QSet)ES( container may + be used within a persis)HY(tent)YH( object.)EP( + + ) 6 24 PR(#pragma db object +class Person +{ + ... + QSet emails_; +};)RP( + + )0 P(The )SM(contain)HY(ers)YH()ES( sub-profile also provide a change-track)HY(ing)YH( + equiv)HY(a)HY(lent)YH( for )SM(QList)ES( \201)0 318 1 A(Section 24.3.1, + "Change-Track)HY(ing)YH( )SM(QList)ES(")318 0 TN TL()Ec /AF f D(\202 with support for other Qt + container equiv)HY(a)HY(lents)YH( planned for future releases. For general infor)HY(ma)HY(tion)YH( + on change-track)HY(ing)YH( contain)HY(ers)YH( refer to )0 49 1 A(Section 5.4, + "Change-Track)HY(ing)YH( Contain)HY(ers)YH(")49 0 TN TL()Ec /AF f D(.)EP( + + )0 3 313 H(24.3.1)WB 638 Sn()WB 318 Sn( Change-Track)HY(ing)YH( )SM(QList)ES()EA()EH( + + )0 P(Class template )SM(QOdb)HY(List)YH()ES(, defined in + )SM()ES(, is a change-track)HY(ing)YH( + equiv)HY(a)HY(lent)YH( for )SM(QList)ES(. It + is imple)HY(mented)YH( in terms of )SM(QList)ES( and is + implicit-convert)HY(ible)YH( to and implicit-constructible from + )SM(const QList&)ES(. In partic)HY(u)HY(lar)YH(, this + means that we can use )SM(QOdb)HY(List)YH()ES( instance + anywhere )SM(const QList&)ES( is + expected. In addi)HY(tion)YH(, )SM(QOdb)HY(List)YH()ES( constant + iter)HY(a)HY(tor)YH( \201)SM(const_iter)HY(a)HY(tor)YH()ES(\202 is the same type as + that of )SM(QList)ES(.)EP( + + )0 P()SM(QOdb)HY(List)YH()ES( incurs 2-bit per element over)HY(head)YH( + in order to store the change state. It cannot + be stored unordered in the database \201)0 166 1 A(Section + 14.4.19 ")SM(unordered)ES(")166 0 TN TL()Ec /AF f D(\202 but can be used as an inverse + side of a rela)HY(tion)HY(ship)YH( \201)0 56 1 A(6.2 "Bidi)HY(rec)HY(tional)YH( + Rela)HY(tion)HY(ships)YH(")56 0 TN TL()Ec /AF f D(\202. In this case, no change track)HY(ing)YH( is performed + since no state for such a container is stored in the database.)EP( + + )0 P(The number of database oper)HY(a)HY(tions)YH( required to update the state + of )SM(QOdb)HY(List)YH()ES( corre)HY(sponds)YH( well to the complex)HY(ity)YH( + of )SM(QList)ES( func)HY(tions)YH(, except for + )SM(prepend\201\202)ES(/)SM(push_front\201\202)ES(. In partic)HY(u)HY(lar)YH(, adding + or remov)HY(ing)YH( an element from the back of the list \201for example, + with )SM(append\201\202)ES(/)SM(push_back\201\202)ES( and + )SM(remove)HY(Last)YH(\201\202)ES(/)SM(pop_back\201\202)ES(\202, + requires only a single database state)HY(ment)YH( execu)HY(tion)YH(. In contrast, + insert)HY(ing)YH( or erasing an element at the begin)HY(ning)YH( or in the middle + of the list will require a database state)HY(ment)YH( for every element that + follows it.)EP( + + )0 P()SM(QOdb)HY(List)YH()ES( repli)HY(cates)YH( most of the )SM(QList)ES( + inter)HY(face)YH( as defined in both Qt4 and Qt5 and includes support for + C++11. However, func)HY(tions)YH( and oper)HY(a)HY(tors)YH( that provide direct write + access to the elements had to be altered or disabled in order to + support change track)HY(ing)YH(. Addi)HY(tional)YH( func)HY(tions)YH( used to inter)HY(face)YH( with + )SM(QList)ES( and to control the change track)HY(ing)YH( state + were also added. The follow)HY(ing)YH( listing summa)HY(rizes)YH( the differ)HY(ences)YH( + between the )SM(QOdb)HY(List)YH()ES( and )SM(QList)ES( + inter)HY(faces)YH(. Any )SM(QList)ES( func)HY(tion)YH( or oper)HY(a)HY(tor)YH( + not mentioned in this listing has exactly the same signa)HY(ture)YH( + and seman)HY(tics)YH( in )SM(QOdb)HY(List)YH()ES(. Func)HY(tions)YH( and + oper)HY(a)HY(tors)YH( that were disabled are shown as commented out and + are followed by func)HY(tions)YH(/oper)HY(a)HY(tors)YH( that replace them.)EP( + + ) 77 59 PR(template +class QOdbList +{ + ... + + // Element access. + // + + //T& operator[] \201int\202; + T& modify \201int\202; + + //T& first\201\202; + T& modifyFirst\201\202; + + //T& last\201\202; + T& modifyLast\201\202; + + //T& front\201\202; + T& modify_front\201\202; + + //T& back\201\202; + T& modify_back\201\202; + + // Iterators. + // + typedef typename QList::const_iterator const_iterator; + + class iterator + { + ... +)WR( + // Element Access. + // + + //reference operator* \201\202 const; + const_reference operator* \201\202 const; + reference modify \201\202 const; + + //pointer operator-> \201\202 const; + const_pointer operator-> \201\202 const; + + //reference operator[] \201difference_type\202; + const_reference operator[] \201difference_type\202; + reference modify \201difference_type\202 const; + + // Interfacing with QList::iterator. + // + typename QList::iterator base \201\202 const; + }; + + // Return QList iterators. The begin\201\202 functions mark all + // the elements as modified. + // + typename QList::iterator mbegin \201\202; + typename QList::iterator modifyBegin \201\202; + typename QList::iterator mend \201\202; + typename QList::iterator modifyEnd \201\202; + + // Interfacing with QList. + // + QOdbList \201const QList&\202;)WR( + QOdbList \201QList&&\202; // C++11 only. + + QOdbList& operator= \201const QList&\202; + QOdbList& operator= \201QList&&\202; + + operator const QList& \201\202 const; + QList& base \201\202; + const QList& base \201\202 const; + + // Change tracking. + // + bool _tracking \201\202 const; + void _start \201\202 const; + void _stop \201\202 const; + void _arm \201transaction&\202 const; +};)RP( + + )0 P(The follow)HY(ing)YH( example high)HY(lights)YH( some of the differ)HY(ences)YH( between + the two inter)HY(faces)YH(. )SM(QList)ES( versions are commented + out.)EP( + + ) 24 45 PR(#include +#include + +void f \201const QList&\202; + +QOdbList l \201{1, 2, 3}\202; + +f \201l\202; // Ok, implicit conversion. + +if \201l[1] == 2\202 // Ok, const access. + //l[1]++; + l.modify \2011\202++; + +//l.last \201\202 = 4; +l.modifyLast \201\202 = 4; + +for \201auto i \201l.begin \201\202\202; i != l.end \201\202; ++i\202 +{ + if \201*i != 0\202 // Ok, const access. + //*i += 10; + i.modify \201\202 += 10; +} + +qSort \201l.modifyBegin \201\202, l.modifyEnd \201\202\202;)RP( + + )0 P(Note also the subtle differ)HY(ence)YH( between copy/move construc)HY(tion)YH( + and copy/move assign)HY(ment)YH( of )SM(QOdb)HY(List)YH()ES( instances. + While copy/move construc)HY(tor)YH( will copy/move both the elements as + well as their change state, in contrast, assign)HY(ment)YH( is tracked + as any other change to the vector content.)EP( + + )0 P(The )SM(QLis)HY(tIt)HY(er)HY(a)HY(tor)YH()ES( and )SM(QMutableLis)HY(tIt)HY(er)HY(a)HY(tor)YH()ES( + equiv)HY(a)HY(lents)YH( are also provided. These are )SM(QOdb)HY(Lis)HY(tIt)HY(er)HY(a)HY(tor)YH()ES( + and )SM(QMutableOd)HY(b)HY(Lis)HY(tIt)HY(er)HY(a)HY(tor)YH()ES( and are defined in + )SM()ES( and + )SM()ES(, respec)HY(tively)YH(.)EP( + + )0 P()SM(QOdb)HY(Lis)HY(tIt)HY(er)HY(a)HY(tor)YH()ES( has exactly the same inter)HY(face)YH( and + seman)HY(tics)YH( as )SM(QLis)HY(tIt)HY(er)HY(a)HY(tor)YH()ES(. In fact, we can use + )SM(QLis)HY(tIt)HY(er)HY(a)HY(tor)YH()ES( to iterate over a )SM(QOdb)HY(List)YH()ES( + instance.)EP( + + )0 P()SM(QMutableOd)HY(b)HY(Lis)HY(tIt)HY(er)HY(a)HY(tor)YH()ES( also has exactly the same + inter)HY(face)YH( as )SM(QMutableLis)HY(tIt)HY(er)HY(a)HY(tor)YH()ES(. Note, however, + that any element that such an iter)HY(a)HY(tor)YH( passes over with the + call to )SM(next\201\202)ES( is marked as modi)HY(fied)YH(.)EP( + + )0 2 314 H(24.4)WB 639 Sn()WB 319 Sn( Date Time Library)EA()EH( + + )0 P(The )SM(date-time)ES( sub-profile provides persis)HY(tence)YH( support for + the Qt date-time types. To enable only this profile, pass + )SM(qt/date-time)ES( to the )SM(--profile)ES( ODB compiler + option.)EP( + + )0 P(The currently supported date-time types are )SM(QDate)ES(, + )SM(QTime)ES(, and )SM(QDate)HY(Time)YH()ES(. The manner in which + these types are persisted is database system depen)HY(dent)YH( and is + discussed in the sub-sections that follow. The example below shows how + )SM(QDate)ES( may be used within a persis)HY(tent)YH( object.)EP( + + ) 6 21 PR(#pragma db object +class Person +{ + ... + QDate dateOfBirth_; +};)RP( + + )0 P(The single concrete excep)HY(tion)YH( that can be thrown by the + )SM(date-time)ES( sub-profile imple)HY(men)HY(ta)HY(tion)YH( is presented below.)EP( + + + ) 14 51 PR(namespace odb +{ + namespace qt + { + namespace date_time + { + struct value_out_of_range: odb::qt::exception + { + virtual const char* + what \201\202 const throw \201\202; + }; + } + } +})RP( + + )0 P(You will need to include the + )SM()ES( header file to + make this excep)HY(tion)YH( avail)HY(able)YH( in your appli)HY(ca)HY(tion)YH(.)EP( + + )0 P(The )SM(value_out_of_range)ES( excep)HY(tion)YH( is thrown if an attempt + is made to store a date-time value that is out of the target database + range. The specific condi)HY(tions)YH( under which it is thrown is database + system depen)HY(dent)YH( and is discussed in more detail in the + follow)HY(ing)YH( sub-sections.)EP( + + )0 3 315 H(24.4.1)WB 640 Sn()WB 320 Sn( MySQL Database Type Mapping)EA()EH( + + )0 P(The follow)HY(ing)YH( table summa)HY(rizes)YH( the default mapping between the currently + supported Qt date-time types and the MySQL database types.)EP( + + + )32 PT( + + )0 P(Instances of the )SM(QDate)ES(, )SM(QTime)ES(, and + )SM(QDate)HY(Time)YH()ES( types are stored as a )SM(NULL)ES( value + if their )SM(isNull\201\202)ES( member func)HY(tion)YH( returns true.)EP( + + )0 P(The )SM(date-time)ES( sub-profile imple)HY(men)HY(ta)HY(tion)YH( also provides + support for mapping )SM(QDate)HY(Time)YH()ES( to the )SM(TIMES)HY(TAMP)YH()ES( + MySQL type. However, this mapping has to be explic)HY(itly)YH( requested using + the )SM(db\240type)ES( pragma + \201)0 150 1 A(Section 14.4.3, ")SM(type)ES(")150 0 TN TL()Ec /AF f D(\202, as shown in + the follow)HY(ing)YH( example:)EP( + + ) 7 39 PR(#pragma db object +class Person +{ + ... + #pragma db type\201"TIMESTAMP"\202 not_null + QDateTime updated_; +};)RP( + + )0 P(Start)HY(ing)YH( with MySQL version 5.6.4 it is possi)HY(ble)YH( to store frac)HY(tional)YH( + seconds up to microsec)HY(ond)YH( preci)HY(sion)YH( in )SM(TIME)ES(, + )SM(DATE)HY(TIME)YH()ES(, and )SM(TIMES)HY(TAMP)YH()ES( columns. However, + to enable sub-second preci)HY(sion)YH(, the corre)HY(spond)HY(ing)YH( type with the + desired preci)HY(sion)YH( has to be spec)HY(i)HY(fied)YH( explic)HY(itly)YH(, as shown in the + follow)HY(ing)YH( example:)EP( + + ) 7 58 PR(#pragma db object +class Person +{ + ... + #pragma db type\201"DATETIME\2013\202"\202 // Millisecond precision. + QDateTime updated_; +};)RP( + + )0 P(Alter)HY(na)HY(tively)YH(, you can enable sub-second preci)HY(sion)YH( on the per-type + basis, for example:)EP( + + ) 9 47 PR(#pragma db value\201QDateTime\202 type\201"DATETIME\2013\202"\202 + +#pragma db object +class Person +{ + ... + QDateTime created_; // Millisecond precision. + QDateTime updated_; // Millisecond precision. +};)RP( + + )0 P(Some valid Qt date-time values cannot be stored in a MySQL database. An + attempt to persist a Qt date-time value that is out of the MySQL type + range will result in the )SM(out_of_range)ES( excep)HY(tion)YH(. Refer to + the MySQL docu)HY(men)HY(ta)HY(tion)YH( for more infor)HY(ma)HY(tion)YH( on the MySQL data type + ranges.)EP( + + )0 3 316 H(24.4.2)WB 641 Sn()WB 321 Sn( SQLite Database Type Mapping)EA()EH( + + )0 P(The follow)HY(ing)YH( table summa)HY(rizes)YH( the default mapping between the currently + supported Qt date-time types and the SQLite database types.)EP( + + + )33 PT( + + )0 P(Instances of the )SM(QDate)ES(, )SM(QTime)ES(, and + )SM(QDate)HY(Time)YH()ES( types are stored as a )SM(NULL)ES( value + if their )SM(isNull\201\202)ES( member func)HY(tion)YH( returns true.)EP( + + )0 P(The )SM(date-time)ES( sub-profile imple)HY(men)HY(ta)HY(tion)YH( also provides + support for mapping )SM(QDate)ES( and )SM(QDate)HY(Time)YH()ES( to the + SQLite )SM(INTEGER)ES( type, with the integer value repre)HY(sent)HY(ing)YH( the + UNIX time. Simi)HY(larly)YH(, an alter)HY(na)HY(tive)YH( mapping for )SM(QTime)ES( to + the )SM(INTEGER)ES( type repre)HY(sents)YH( a clock time as the number of + seconds since midnight. These mappings have to be explic)HY(itly)YH( requested + using the )SM(db\240type)ES( pragma + \201)0 150 1 A(Section 14.4.3, ")SM(type)ES(")150 0 TN TL()Ec /AF f D(\202, as shown + in the follow)HY(ing)YH( example:)EP( + + ) 7 28 PR(#pragma db object +class Person +{ + ... + #pragma db type\201"INTEGER"\202 + QDate born_; +};)RP( + + )0 P(Some valid Qt date-time values cannot be stored in an SQLite database. + An attempt to persist any Qt date-time value repre)HY(sent)HY(ing)YH( a nega)HY(tive)YH( UNIX + time \201any point in time prior to the 1970-01-01\24000:00:00 UNIX time + epoch\202 as an SQLite )SM(INTEGER)ES( will result in the + )SM(out_of_range)ES( excep)HY(tion)YH(.)EP( + + )0 3 317 H(24.4.3)WB 642 Sn()WB 322 Sn( Post)HY(greSQL)YH( Database Type Mapping)EA()EH( + + )0 P(The follow)HY(ing)YH( table summa)HY(rizes)YH( the default mapping between the currently + supported Qt date-time types and the Post)HY(greSQL)YH( database types.)EP( + + + )34 PT( + + )0 P(Instances of the )SM(QDate)ES(, )SM(QTime)ES(, and + )SM(QDate)HY(Time)YH()ES( types are stored as a )SM(NULL)ES( value + if their )SM(isNull\201\202)ES( member func)HY(tion)YH( returns true.)EP( + + )0 3 318 H(24.4.4)WB 643 Sn()WB 323 Sn( Oracle Database Type Mapping)EA()EH( + + )0 P(The follow)HY(ing)YH( table summa)HY(rizes)YH( the default mapping between the currently + supported Qt date-time types and the Oracle database types.)EP( + + + )35 PT( + + )0 P(Instances of the )SM(QDate)ES(, )SM(QTime)ES(, and + )SM(QDate)HY(Time)YH()ES( types are stored as a )SM(NULL)ES( value + if their )SM(isNull\201\202)ES( member func)HY(tion)YH( returns true.)EP( + + )0 P(The )SM(date-time)ES( sub-profile imple)HY(men)HY(ta)HY(tion)YH( also provides + support for mapping )SM(QDate)HY(Time)YH()ES( to the + )SM(DATE)ES( Oracle type with frac)HY(tional)YH( seconds that may be + stored in a )SM(QDate)HY(Time)YH()ES( instance being ignored. This + alter)HY(na)HY(tive)YH( mapping has to be explic)HY(itly)YH( requested using the + )SM(db\240type)ES( pragma \201)0 150 1 A(Section 14.4.3, + ")SM(type)ES(")150 0 TN TL()Ec /AF f D(\202, as shown in the follow)HY(ing)YH( example:)EP( + + ) 7 25 PR(#pragma db object +class person +{ + ... + #pragma db type\201"DATE"\202 + QDateTime updated_; +};)RP( + + )0 3 319 H(24.4.5)WB 644 Sn()WB 324 Sn( SQL Server Database Type Mapping)EA()EH( + + )0 P(The follow)HY(ing)YH( table summa)HY(rizes)YH( the default mapping between the currently + supported Qt date-time types and the SQL Server database types.)EP( + + + )36 PT( + + )0 P(Instances of the )SM(QDate)ES(, )SM(QTime)ES(, and + )SM(QDate)HY(Time)YH()ES( types are stored as a )SM(NULL)ES( value + if their )SM(isNull\201\202)ES( member func)HY(tion)YH( returns true.)EP( + + )0 P(Note that the )SM(DATE)ES(, )SM(TIME)ES(, and + )SM(DATE)HY(TIME)YH(2)ES( types are only avail)HY(able)YH( in SQL Server 2008 and + later. SQL Server 2005 only supports the )SM(DATE)HY(TIME)YH()ES( and + )SM(SMALL)HY(DATE)HY(TIME)YH()ES( date-time types. The new types are + also unavail)HY(able)YH( when connect)HY(ing)YH( to an SQL Server 2008 or + later with the SQL Server 2005 Native Client ODBC driver.)EP( + + )0 P(The )SM(date-time)ES( sub-profile imple)HY(men)HY(ta)HY(tion)YH( provides + support for mapping )SM(QDate)HY(Time)YH()ES( to the )SM(DATE)HY(TIME)YH()ES( + and )SM(SMALL)HY(DATE)HY(TIME)YH()ES( types, however, this mapping has to + be explic)HY(itly)YH( requested using the )SM(db\240type)ES( pragma + \201)0 150 1 A(Section 14.4.3, ")SM(type)ES(")150 0 TN TL()Ec /AF f D(\202, as + shown in the follow)HY(ing)YH( example:)EP( + + ) 7 29 PR(#pragma db object +class person +{ + ... + #pragma db type\201"DATETIME"\202 + QDateTime updated_; +};)RP( + + )BR( +)BR( + +)WB NL +/TE t D NP /OU t D TU PM 1 eq and{/Pn () D showpage}if end restore diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/doc/odb.xhtml b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/doc/odb.xhtml new file mode 100755 index 0000000..0b014b7 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/doc/odb.xhtml @@ -0,0 +1,952 @@ + + + + + ODB 2.4.0 Compiler Command Line Manual + + + + + + + + + + + +
+
+ +

NAME

+ +

odb - object-relational mapping (ORM) compiler for C++

+ +

SYNOPSIS

+ +
+
odb [options] file [file...]
+
+ +

DESCRIPTION

+ +

Given a set of C++ classes in a header file, odb + generates C++ code that allows you to persist, query, and update objects + of these classes in a relational database (RDBMS). The relational + database that the generated code should target is specified with the + required --database option (see below).

+ +

For an input file in the form name.hxx (other + file extensions can be used instead of .hxx), + in the single-database mode (the default), the generated C++ files + by default have the following names: + name-odb.hxx (header file), + name-odb.ixx (inline file), and + name-odb.cxx (source file). + + Additionally, if the --generate-schema option is + specified and the sql schema format is requested (see + --schema-format), the name.sql + database schema file is generated. If the separate + schema format is requested, the database creation code is generated + into the separate name-schema.cxx file.

+ +

In the multi-database mode (see the --multi-database + option below), the generated files corresponding to the + common database have the same names as in the + single-database mode. For other databases, the file names include + the database name: + name-odb-db.hxx, + name-odb-db.ixx, + name-odb-db.cxx, + name-db.sql, and + name-schema-db.cxx + (where db is the database name).

+ +

OPTIONS

+ + + +
+
--help
+
Print usage information and exit.
+ +
--version
+
Print version and exit.
+ +
-I dir
+
Add dir to the beginning of the list of directories to be searched + for included header files.
+ +
-D name[=def]
+
Define macro name with definition def. If definition is + omitted, define name to be 1.
+ +
-U name
+
Cancel any previous definitions of macro name, either built-in or + provided with the -D option.
+ +
--database|-d db
+
Generate code for the db database. Valid values are + mssql, mysql, + oracle, pgsql, + sqlite, and common (multi-database + mode only).
+ +
--multi-database|-m type
+
Enable multi-database support and specify its type. Valid values for this + option are static and dynamic. + +

In the multi-database mode, options that determine the kind (for example, + --schema-format), names (for example, + --odb-file-suffix), or content (for example, prologue + and epilogue options) of the output files can be prefixed with the database + name followed by a colon, for example, mysql:value. This + restricts the value of such an option to only apply to generated files + corresponding to this database.

+ +
--default-database db
+
When static multi-database support is used, specify the database that should + be made the default. When dynamic multi-database support is used, + common is always made the default database.
+ +
--generate-query|-q
+
Generate query support code. Without this support you cannot use views and + can only load objects via their ids.
+ +
--generate-prepared
+
Generate prepared query execution support code.
+ +
--omit-unprepared
+
Omit un-prepared (once-off) query execution support code.
+ +
--generate-session|-e
+
Generate session support code. With this option session support will be + enabled by default for all the persistent classes except those for which it + was explicitly disabled using the db session pragma.
+ +
--generate-schema|-s
+
Generate the database schema. The database schema contains SQL statements + that create database tables necessary to store persistent classes defined in + the file being compiled. Note that by applying this schema, all the existing + information stored in such tables will be lost. + +

Depending on the database being used (--database + option), the schema is generated either as a standalone SQL file or embedded + into the generated C++ code. By default the SQL file is generated for the + MySQL, PostgreSQL, Oracle, and Microsoft SQL Server databases and the schema + is embedded into the C++ code for the SQLite database. Use the + --schema-format option to alter the default schema + format.

+ +

If database schema evolution support is enabled (that is, the object + model version is specified), then this option also triggers the generation + of database schema migration statements, again either as standalong SQL + files or embedded into the generated C++ code. You can suppress the + generation of schema migration statements by specifying the + --suppress-migration option.

+ +
--generate-schema-only
+
Generate only the database schema. Note that this option is only valid when + generating schema as a standalone SQL file (see + --schema-format for details).
+ +
--suppress-migration
+
Suppress the generation of database schema migration statements.
+ +
--suppress-schema-version
+
Suppress the generation of schema version table. If you specify this option + then you are also expected to manually specify the database schema version + and migration state at runtime using the + odb::database::schema_version() function.
+ +
--schema-version-table name
+
Specify the alternative schema version table name instead of the default + schema_version. If you specify this option then you are + also expected to manually specify the schema version table name at runtime + using the odb::database::schema_version_table() + function. The table name can be qualified.
+ +
--schema-format format
+
Generate the database schema in the specified format. Pass + sql as format to generate the database schema as + a standalone SQL file or pass embedded to embed the + schema into the generated C++ code. The separate value + is similar to embedded except the schema creation code + is generated into a separate C++ file (name-schema.cxx + by default). This value is primarily useful if you want to place the schema + creation functionality into a separate program or library. Repeat this + option to generate the same database schema in multiple formats.
+ +
--omit-drop
+
Omit DROP statements from the generated database schema.
+ +
--omit-create
+
Omit CREATE statements from the generated database + schema.
+ +
--schema-name name
+
Use name as the database schema name. Schema names are primarily used + to distinguish between multiple embedded schemas in the schema catalog. They + are not to be confused with database schemas (database namespaces) which are + specified with the --schema option. If this option is + not specified, the empty name, which is the default schema name, is used.
+ +
--fkeys-deferrable-mode m
+
Use constraint checking mode m in foreign keys generated for object + relationships. Valid values for this option are + not_deferrable, immediate, and + deferred (default). MySQL and SQL Server do not support + deferrable foreign keys and for these databases such keys are generated + commented out. Other foreign keys generated by the ODB compiler (such as the + ones used to support containers and polymorphic hierarchies) are always + generated as not deferrable. + +

Note also that if you use either not_deferrable or + immediate mode, then the order in which you persist, + update, and erase objects within a transaction becomes important.

+ +
--default-pointer ptr
+
Use ptr as the default pointer for persistent objects and views. + Objects and views that do not have a pointer assigned with the db + pointer pragma will use this pointer by default. The value of + this option can be * which denotes the raw pointer and + is the default, or qualified name of a smart pointer class template, for + example, std::auto_ptr. In the latter case, the ODB + compiler constructs the object or view pointer by adding a single template + argument of the object or view type to the qualified name, for example + std::auto_ptr<object>. The ODB runtime uses object + and view pointers to return, and, in case of objects, pass and cache + dynamically allocated instances of object and view types. + +

Except for the raw pointer and the standard smart pointers defined in the + <memory> header file, you are expected to include the + definition of the default pointer at the beginning of the generated header + file. There are two common ways to achieve this: you can either include the + necessary header in the file being compiled or you can use the + --hxx-prologue option to add the necessary + #include directive to the generated code.

+ +
--session-type type
+
Use type as the alternative session type instead of the default + odb::session. This option can be used to specify a + custom session implementation to be use by the persistent classes. Note that + you will also need to include the definition of the custom session type into + the generated header file. This is normally achieved with the + --hxx-prologue* options.
+ +
--profile|-p name
+
Specify a profile that should be used during compilation. A profile is an + options file. The ODB compiler first looks for a database-specific version + with the name constructed by appending the + -database.options + suffix to name, where database is the database + name as specified with the --database option. If this + file is not found, then the ODB compiler looks for a database-independant + version with the name constructed by appending just the + .options suffix. + +

The profile options files are searched for in the same set of directories + as C++ headers included with the #include <...> + directive (built-in paths plus those specified with the + -I options). The options file is first searched for in + the directory itself and then in its odb/ + subdirectory.

+ +

For the format of the options file refer to the + --options-file option below. You can repeat this option + to specify more than one profile.

+ +
--at-once
+
Generate code for all the input files as well as for all the files that they + include at once. The result is a single set of source/schema files that + contain all the generated code. If more than one input file is specified + together with this option, then the --input-name option + must also be specified in order to provide the base name for the output + files. In this case, the directory part of such a base name is used as the + location of the combined file. This can be important for the + #include directive resolution.
+ +
--schema schema
+
Specify a database schema (database namespace) that should be assigned to + the persistent classes in the file being compiled. Database schemas are not + to be confused with database schema names (schema catalog names) which are + specified with the --schema-name option.
+ +
--export-symbol symbol
+
Insert symbol in places where DLL export/import control statements + (__declspec(dllexport/dllimport)) are necessary. See + also the --extern-symbol option below.
+ +
--extern-symbol symbol
+
If symbol is defined, insert it in places where a template + instantiation must be declared extern. This option is + normally used together with --export-symbol when both + multi-database support and queries are enabled.
+ +
--std version
+
Specify the C++ standard that should be used during compilation. Valid + values are c++98 (default), c++11, + and c++14.
+ +
--warn-hard-add
+
Warn about hard-added data members.
+ +
--warn-hard-delete
+
Warn about hard-deleted data members and persistent classes.
+ +
--warn-hard
+
Warn about both hard-added and hard-deleted data members and persistent + classes.
+ +
--output-dir|-o dir
+
Write the generated files to dir instead of the current directory.
+ +
--input-name name
+
Use name instead of the input file to derive the names of the + generated files. If the --at-once option is specified, + then the directory part of name is used as the location of the + combined file. Refer to the --at-once option for + details.
+ +
--changelog file
+
Read/write changelog from/to file instead of the default changelog + file. The default changelog file name is derived from the input file name + and it is placed into the same directory as the input file. Note that the + --output-dir option does not affect the changelog file + location. In other words, by default, the changelog file is treated as + another input rather than output even though the ODB compiler may modify it. + Use the --changelog-in and + --changelog-out options to specify different input and + output chaneglog files.
+ +
--changelog-in file
+
Read changelog from file instead of the default changelog file. If + this option is specified, then you must also specify the output chanegelog + file with --changelog-out.
+ +
--changelog-out file
+
Write changelog to file instead of the default changelog file. If + this option is specified, then you must also specify the input chanegelog + file with --changelog-in.
+ +
--changelog-dir dir
+
Use dir instead of the input file directory as the changelog file + directory. This directory is also added to changelog files specified with + the --changelog, --changelog-in, and + --changelog-in options unless they are absolute paths.
+ +
--init-changelog
+
Force re-initialization of the changelog even if one exists (all the + existing change history will be lost). This option is primarily useful for + automated testing.
+ +
--odb-file-suffix suffix
+
Use suffix to construct the names of the generated C++ files. In the + single-database mode the default value for this option is + -odb. In the multi-database mode it is + -odb for the files corresponding to the + common database and -odb-db + (where db is the database name) for other databases.
+ +
--sql-file-suffix suffix
+
Use suffix to construct the name of the generated schema SQL file. In + the single-database mode by default no suffix is used. In the multi-database + mode the default value for this option is -db + (where db is the database name).
+ +
--schema-file-suffix suffix
+
Use suffix to construct the name of the generated schema C++ source + file. In the single-database mode the default value for this option is + -schema. In the multi-database mode it is + -schema-db (where db is the + database name). See the --schema-format option for + details.
+ +
--changelog-file-suffix sfx
+
Use sfx to construct the name of the changelog file. In the + single-database mode by default no suffix is used. In the multi-database + mode the default value for this option is -db + (where db is the database name).
+ +
--hxx-suffix suffix
+
Use suffix instead of the default .hxx to + construct the name of the generated C++ header file.
+ +
--ixx-suffix suffix
+
Use suffix instead of the default .ixx to + construct the name of the generated C++ inline file.
+ +
--cxx-suffix suffix
+
Use suffix instead of the default .cxx to + construct the name of the generated C++ source file.
+ +
--sql-suffix suffix
+
Use suffix instead of the default .sql to + construct the name of the generated database schema file.
+ +
--changelog-suffix suffix
+
Use suffix instead of the default .xml to + construct the name of the changelog file.
+ +
--hxx-prologue text
+
Insert text at the beginning of the generated C++ header file.
+ +
--ixx-prologue text
+
Insert text at the beginning of the generated C++ inline file.
+ +
--cxx-prologue text
+
Insert text at the beginning of the generated C++ source file.
+ +
--schema-prologue text
+
Insert text at the beginning of the generated schema C++ source file.
+ +
--sql-prologue text
+
Insert text at the beginning of the generated database schema file.
+ +
--migration-prologue text
+
Insert text at the beginning of the generated database migration + file.
+ +
--sql-interlude text
+
Insert text after all the DROP and before any + CREATE statements in the generated database schema file.
+ +
--hxx-epilogue text
+
Insert text at the end of the generated C++ header file.
+ +
--ixx-epilogue text
+
Insert text at the end of the generated C++ inline file.
+ +
--cxx-epilogue text
+
Insert text at the end of the generated C++ source file.
+ +
--schema-epilogue text
+
Insert text at the end of the generated schema C++ source file.
+ +
--sql-epilogue text
+
Insert text at the end of the generated database schema file.
+ +
--migration-epilogue text
+
Insert text at the end of the generated database migration file.
+ +
--hxx-prologue-file file
+
Insert the content of file at the beginning of the generated C++ + header file.
+ +
--ixx-prologue-file file
+
Insert the content of file at the beginning of the generated C++ + inline file.
+ +
--cxx-prologue-file file
+
Insert the content of file at the beginning of the generated C++ + source file.
+ +
--schema-prologue-file file
+
Insert the content of file at the beginning of the generated schema + C++ source file.
+ +
--sql-prologue-file file
+
Insert the content of file at the beginning of the generated database + schema file.
+ +
--migration-prologue-file f
+
Insert the content of file f at the beginning of the generated + database migration file.
+ +
--sql-interlude-file file
+
Insert the content of file after all the DROP and + before any CREATE statements in the generated database + schema file.
+ +
--hxx-epilogue-file file
+
Insert the content of file at the end of the generated C++ header + file.
+ +
--ixx-epilogue-file file
+
Insert the content of file at the end of the generated C++ inline + file.
+ +
--cxx-epilogue-file file
+
Insert the content of file at the end of the generated C++ source + file.
+ +
--schema-epilogue-file file
+
Insert the content of file at the end of the generated schema C++ + source file.
+ +
--sql-epilogue-file file
+
Insert the content of file at the end of the generated database + schema file.
+ +
--migration-epilogue-file f
+
Insert the content of file f at the end of the generated database + migration file.
+ +
--odb-prologue text
+
Compile text before the input header file. This option allows you to + add additional declarations, such as custom traits specializations, to the + ODB compilation process.
+ +
--odb-prologue-file file
+
Compile file contents before the input header file. Prologue files + are compiled after all the prologue text fragments + (--odb-prologue option).
+ +
--odb-epilogue text
+
Compile text after the input header file. This option allows you to + add additional declarations, such as custom traits specializations, to the + ODB compilation process.
+ +
--odb-epilogue-file file
+
Compile file contents after the input header file. Epilogue files are + compiled after all the epilogue text fragments + (--odb-epilogue option).
+ +
--table-prefix prefix
+
Add prefix to table names and, for databases that have global index + and/or foreign key names, to those names as well. The prefix is added to + both names that were specified with the db table and + db index pragmas and those that were automatically + derived from class and data member names. If you require a separator, such + as an underscore, between the prefix and the name, then you should include + it into the prefix value.
+ +
--index-suffix suffix
+
Use suffix instead of the default _i to construct + index names. The suffix is only added to names that were automatically + derived from data member names. If you require a separator, such as an + underscore, between the name and the suffix, then you should include it into + the suffix value.
+ +
--fkey-suffix suffix
+
Use suffix instead of the default _fk to + construct foreign key names. If you require a separator, such as an + underscore, between the name and the suffix, then you should include it into + the suffix value.
+ +
--sequence-suffix suffix
+
Use suffix instead of the default _seq to + construct sequence names. If you require a separator, such as an underscore, + between the name and the suffix, then you should include it into the suffix + value.
+ +
--sql-name-case case
+
Convert all automatically-derived SQL names to upper or lower case. Valid + values for this option are upper and + lower.
+ +
--table-regex regex
+
Add regex to the list of regular expressions that is used to + transform automatically-derived table names. See the SQL NAME + TRANSFORMATIONS section below for details.
+ +
--column-regex regex
+
Add regex to the list of regular expressions that is used to + transform automatically-derived column names. See the SQL NAME + TRANSFORMATIONS section below for details.
+ +
--index-regex regex
+
Add regex to the list of regular expressions that is used to + transform automatically-derived index names. See the SQL NAME + TRANSFORMATIONS section below for details.
+ +
--fkey-regex regex
+
Add regex to the list of regular expressions that is used to + transform automatically-derived foreign key names. See the SQL NAME + TRANSFORMATIONS section below for details.
+ +
--sequence-regex regex
+
Add regex to the list of regular expressions that is used to + transform automatically-derived sequence names. See the SQL NAME + TRANSFORMATIONS section below for details.
+ +
--statement-regex regex
+
Add regex to the list of regular expressions that is used to + transform automatically-derived prepared statement names. See the SQL NAME + TRANSFORMATIONS section below for details.
+ +
--sql-name-regex regex
+
Add regex to the list of regular expressions that is used to + transform all automatically-derived SQL names. See the SQL NAME + TRANSFORMATIONS section below for details.
+ +
--sql-name-regex-trace
+
Trace the process of applying regular expressions specified with the SQL + name --*-regex options. Use this option to find out why + your regular expressions don't do what you expected them to do.
+ +
--accessor-regex regex
+
Add regex to the list of regular expressions used to transform data + member names to function names when searching for a suitable accessor + function. The argument to this option is a Perl-like regular expression in + the form + /pattern/replacement/. Any + character can be used as a delimiter instead of / and + the delimiter can be escaped inside pattern and + replacement with a backslash (\). + You can specify multiple regular expressions by repeating this option. + +

All the regular expressions are tried in the order specified and the + first expression that produces a suitable accessor function is used. Each + expression is tried twice: first with the actual member name and then with + the member's public name which is obtained by removing the common + member name decorations, such as leading and trailing underscores, the + m_ prefix, etc. The ODB compiler also includes a number + of built-in expressions for commonly used accessor names, such as + get_foo, getFoo, + getfoo, and just foo. The built-in + expressions are tried last.

+ +

As an example, the following expression transforms data members with + public names in the form foo to accessor names in the + form GetFoo:

+ +

/(.+)/Get\u$1/

+ +

See also the REGEX AND SHELL QUOTING section below.

+ +
--accessor-regex-trace
+
Trace the process of applying regular expressions specified with the + --accessor-regex option. Use this option to find out why + your regular expressions don't do what you expected them to do.
+ +
--modifier-regex regex
+
Add regex to the list of regular expressions used to transform data + member names to function names when searching for a suitable modifier + function. The argument to this option is a Perl-like regular expression in + the form + /pattern/replacement/. Any + character can be used as a delimiter instead of / and + the delimiter can be escaped inside pattern and + replacement with a backslash (\). + You can specify multiple regular expressions by repeating this option. + +

All the regular expressions are tried in the order specified and the + first expression that produces a suitable modifier function is used. Each + expression is tried twice: first with the actual member name and then with + the member's public name which is obtained by removing the common + member name decorations, such as leading and trailing underscores, the + m_ prefix, etc. The ODB compiler also includes a number + of built-in expressions for commonly used modifier names, such as + set_foo, setFoo, + setfoo, and just foo. The built-in + expressions are tried last.

+ +

As an example, the following expression transforms data members with + public names in the form foo to modifier names in the + form SetFoo:

+ +

/(.+)/Set\u$1/

+ +

See also the REGEX AND SHELL QUOTING section below.

+ +
--modifier-regex-trace
+
Trace the process of applying regular expressions specified with the + --modifier-regex option. Use this option to find out why + your regular expressions don't do what you expected them to do.
+ +
--include-with-brackets
+
Use angle brackets (<>) instead of quotes ("") in the generated + #include directives.
+ +
--include-prefix prefix
+
Add prefix to the generated #include directive + paths.
+ +
--include-regex regex
+
Add regex to the list of regular expressions used to transform + generated #include directive paths. The argument to this + option is a Perl-like regular expression in the form + /pattern/replacement/. Any + character can be used as a delimiter instead of / and + the delimiter can be escaped inside pattern and + replacement with a backslash (\). + You can specify multiple regular expressions by repeating this option. All + the regular expressions are tried in the order specified and the first + expression that matches is used. + +

As an example, the following expression transforms include paths in the + form foo/bar-odb.h to paths in the form + foo/generated/bar-odb.h:

+ +

%foo/(.+)-odb.h%foo/generated/$1-odb.h%

+ +

See also the REGEX AND SHELL QUOTING section below.

+ +
--include-regex-trace
+
Trace the process of applying regular expressions specified with the + --include-regex option. Use this option to find out why + your regular expressions don't do what you expected them to do.
+ +
--guard-prefix prefix
+
Add prefix to the generated header inclusion guards. The prefix is + transformed to upper case and characters that are illegal in a preprocessor + macro name are replaced with underscores.
+ +
--show-sloc
+
Print the number of generated physical source lines of code (SLOC).
+ +
--sloc-limit num
+
Check that the number of generated physical source lines of code (SLOC) does + not exceed num.
+ +
--options-file file
+
Read additional options from file with each option appearing on a + separate line optionally followed by space and an option value. Empty lines + and lines starting with # are ignored. Option values can + be enclosed in double (") or single + (') quotes to preserve leading and trailing whitespaces + as well as to specify empty values. If the value itself contains trailing or + leading quotes, enclose it with an extra pair of quotes, for example + '"x"'. Non-leading and non-trailing quotes are + interpreted as being part of the option value. + +

The semantics of providing options in a file is equivalent to providing + the same set of options in the same order on the command line at the point + where the --options-file option is specified except that + the shell escaping and quoting is not required. You can repeat this option + to specify more than one options file.

+ +
-x option
+
Pass option to the underlying C++ compiler (g++). + The option value that doesn't start with - is + considered the g++ executable name.
+ +
-v
+
Print the commands executed to run the stages of compilation.
+ +
--trace
+
Trace the compilation process.
+ +
--mysql-engine engine
+
Use engine instead of the default InnoDB in the + generated database schema file. For more information on the storage engine + options see the MySQL documentation. If you would like to use the + database-default engine, pass default as the value for + this option.
+ +
--sqlite-override-null
+
Make all columns in the generated database schema allow + NULL values. This is primarily useful in schema + migration since SQLite does not support dropping of columns. By making all + columns NULL we can later "delete" them by setting their + values to NULL. Note that this option overrides even the + not_null pragma.
+ +
--sqlite-lax-auto-id
+
Do not force monotonically increasing automatically-assigned object ids. In + this mode the generated database schema omits the + AUTOINCREMENT keyword which results in faster object + persistence but may lead to automatically-assigned ids not being in a + strictly ascending order. Refer to the SQLite documentation for details.
+ +
--pgsql-server-version ver
+
Specify the minimum PostgreSQL server version with which the generated C++ + code and schema will be used. This information is used to enable + version-specific optimizations and workarounds in the generated C++ code and + schema. The version must be in the + major.minor form, for example, + 9.1. If this option is not specified, then + 7.4 or later is assumed.
+ +
--oracle-client-version ver
+
Specify the minimum Oracle client library (OCI) version with which the + generated C++ code will be linked. This information is used to enable + version-specific optimizations and workarounds in the generated C++ code. + The version must be in the major.minor + form, for example, 11.2. If this option is not + specified, then 10.1 or later is assumed.
+ +
--oracle-warn-truncation
+
Warn about SQL names that are longer than 30 characters and are therefore + truncated. Note that during database schema generation + (--generate-schema) ODB detects when such truncations + lead to name conflicts and issues diagnostics even without this option + specified.
+ +
--mssql-server-version ver
+
Specify the minimum SQL Server server version with which the generated C++ + code and schema will be used. This information is used to enable + version-specific optimizations and workarounds in the generated C++ code and + schema. The version must be in the + major.minor form, for example, + 9.0 (SQL Server 2005), 10.5 + (2008R2), or 11.0 (2012). If this option is not + specified, then 10.0 (SQL Server 2008) or later is + assumed.
+ +
--mssql-short-limit size
+
Specify the short data size limit. If a character, national character, or + binary data type has a maximum length (in bytes) less than or equal to this + limit, then it is treated as short data, otherwise it is long + data. For short data ODB pre-allocates an intermediate buffer of the + maximum size and binds it directly to a parameter or result column. This way + the underlying API (ODBC) can read/write directly from/to this buffer. In + the case of long data, the data is read/written in chunks using the + SQLGetData()/SQLPutData() ODBC + functions. While the long data approach reduces the amount of memory used by + the application, it may require greater CPU resources. The default short + data limit is 1024 bytes. When setting a custom short data limit, make sure + that it is sufficiently large so that no object id in the application is + treated as long data.
+ +
+

SQL NAME TRANSFORMATIONS

+ +

The ODB compiler provides a number of mechanisms for transforming + automatically-derived SQL names, such as tables, columns, etc., + to match a specific naming convention. At the higher level, we can + add a prefix to global names (tables and, for some databases, + indexes and/or foreign keys) with the --table-prefix + option. Similarly, we can specify custom suffixes for + automatically-derived + index (--index-suffix; default is _i), + foreign key (--fkey-suffix; default is _fk), and + sequence (--sequence-suffix; default is _seq) + names. Finally, we can also convert all the names to upper or lower + case with the --sql-name-case option (valid values + are upper and lower).

+ +

At the lower level we can specify a set of regular expressions to + implement arbitrary transformations of the automatically-derived SQL + names. If we want a particular regular expression only to apply to + a specific name, for example, table or column, then we use one of the + --kind-regex options, where + kind can be table, + column, index, + fkey, sequence, or + statement. On the other hand, if we want our + regular expressions to apply to all SQL names, then we use the + --sql-name-regex option.

+ +

The interaction between the higher and lower level transformations + is as follows. Prefixes and suffixes are added first. Then the + regular expression transformations are applied. Finally, if requested, + the name is converted to upper or lower case. Note also that all of + these transformations except for --table-prefix + only apply to automatically-derived names. In other words, if a table, + column, etc., name was explicitly specified with a pragma, then it + is used as is, without applying any (except for the table prefix) + transformations.

+ +

The value for the --*-regex options is a Perl-like + regular expression in the form + /pattern/replacement/. + Any character can be used as a delimiter instead of / + and the delimiter can be escaped inside pattern and + replacement with a backslash (\). + You can also specify multiple regular expressions by repeating these + options.

+ +

All the regular expressions are tried in the order specified with the + name-specific expressions (for example, --table-regex) + tried first followed by the generic expressions + (--sql-name-regex). The first expression that + matches is used.

+ +

As an example, consider a regular expression that transforms a class + name in the form CFoo to a table name in the + form FOO:

+ +

--table-regex '/C(.+)/\U$1/'

+ +

As a more interesting example, consider the transformation of class + names that follow the upper camel case convention (for example, + FooBar) to table names that follow the + underscore-separated, all upper case convention (for example, + FOO_BAR). For this case we have to use + separate expressions to handle one-word, two-word, etc., + names:

+ +

--table-regex '/([A-z][a-z]+)/\U$1/'

+

--table-regex '/([A-z][a-z]+)([A-z][a-z]+)/\U$1_$2/'

+ +

See also the REGEX AND SHELL QUOTING section below.

+ +

REGEX AND SHELL QUOTING

+ +

When entering a regular expression argument in the shell + command line it is often necessary to use quoting (enclosing + the argument in " " or + ' ') in order to prevent the shell + from interpreting certain characters, for example, spaces as + argument separators and $ as variable + expansions.

+ +

Unfortunately it is hard to achieve this in a manner that is + portable across POSIX shells, such as those found on + GNU/Linux and UNIX, and Windows shell. For example, if you + use " " for quoting you will get a + wrong result with POSIX shells if your expression contains + $. The standard way of dealing with this + on POSIX systems is to use ' ' instead. + Unfortunately, Windows shell does not remove ' ' + from arguments when they are passed to applications. As a result you + may have to use ' ' for POSIX and + " " for Windows ($ is + not treated as a special character on Windows).

+ +

Alternatively, you can save regular expression options into + a file, one option per line, and use this file with the + --options-file option. With this approach + you don't need to worry about shell quoting.

+ +

DIAGNOSTICS

+ +

If the input file is not valid C++, odb + will issue diagnostic messages to STDERR and exit with non-zero exit + code.

+ +

BUGS

+ +

Send bug reports to the + odb-users@codesynthesis.com mailing list.

+ +
+ +
+ + diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/doc/version b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/doc/version new file mode 100755 index 0000000..197c4d5 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/doc/version @@ -0,0 +1 @@ +2.4.0 diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/etc/odb/default.options b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/etc/odb/default.options new file mode 100755 index 0000000..e20786c --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/etc/odb/default.options @@ -0,0 +1,12 @@ +# Default ODB options file. This file is automatically loaded by the ODB +# compiler and can be used for installation-wide customizations, such as +# adding an include search path for a commonly used library. For example: +# +# -I /opt/boost_1_45_0 +# + +# Debian/Ubuntu new multiarch support places certain headers into +# /usr/include/. Add that path to the search list but use +# -idirafter to make sure it is used as a last resort only. +# +-idirafter /usr/include/x86_64-linux-gnu diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/odb.so b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/odb.so new file mode 100755 index 0000000..e5c398e Binary files /dev/null and b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/odb.so differ diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/bin/addr2line b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/bin/addr2line new file mode 100755 index 0000000..940d2c5 Binary files /dev/null and b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/bin/addr2line differ diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/bin/ar b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/bin/ar new file mode 100755 index 0000000..2cf695d Binary files /dev/null and b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/bin/ar differ diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/bin/as b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/bin/as new file mode 100755 index 0000000..86432b8 Binary files /dev/null and b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/bin/as differ diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/bin/c++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/bin/c++ new file mode 100755 index 0000000..d2e3847 Binary files /dev/null and b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/bin/c++ differ diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/bin/c++filt b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/bin/c++filt new file mode 100755 index 0000000..9780e85 Binary files /dev/null and b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/bin/c++filt differ diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/bin/cpp b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/bin/cpp new file mode 100755 index 0000000..9f1696d Binary files /dev/null and b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/bin/cpp differ diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/bin/elfedit b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/bin/elfedit new file mode 100755 index 0000000..8e79f8e Binary files /dev/null and b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/bin/elfedit differ diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/bin/g++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/bin/g++ new file mode 100755 index 0000000..d2e3847 Binary files /dev/null and b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/bin/g++ differ diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/bin/gcc b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/bin/gcc new file mode 100755 index 0000000..d1581b6 Binary files /dev/null and b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/bin/gcc differ diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/bin/gcc-ar b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/bin/gcc-ar new file mode 100755 index 0000000..50552f5 Binary files /dev/null and b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/bin/gcc-ar differ diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/bin/gcc-nm b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/bin/gcc-nm new file mode 100755 index 0000000..0c06b1e Binary files /dev/null and b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/bin/gcc-nm differ diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/bin/gcc-ranlib b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/bin/gcc-ranlib new file mode 100755 index 0000000..f719e94 Binary files /dev/null and b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/bin/gcc-ranlib differ diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/bin/gcov b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/bin/gcov new file mode 100755 index 0000000..689caf0 Binary files /dev/null and b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/bin/gcov differ diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/bin/gprof b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/bin/gprof new file mode 100755 index 0000000..f392224 Binary files /dev/null and b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/bin/gprof differ diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/bin/ld b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/bin/ld new file mode 100755 index 0000000..2e5b6ef Binary files /dev/null and b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/bin/ld differ diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/bin/nm b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/bin/nm new file mode 100755 index 0000000..3b9dae1 Binary files /dev/null and b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/bin/nm differ diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/bin/objcopy b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/bin/objcopy new file mode 100755 index 0000000..6462d49 Binary files /dev/null and b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/bin/objcopy differ diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/bin/objdump b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/bin/objdump new file mode 100755 index 0000000..b85bfc6 Binary files /dev/null and b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/bin/objdump differ diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/bin/ranlib b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/bin/ranlib new file mode 100755 index 0000000..e41053b Binary files /dev/null and b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/bin/ranlib differ diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/bin/readelf b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/bin/readelf new file mode 100755 index 0000000..6e87845 Binary files /dev/null and b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/bin/readelf differ diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/bin/size b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/bin/size new file mode 100755 index 0000000..5fcd742 Binary files /dev/null and b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/bin/size differ diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/bin/strings b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/bin/strings new file mode 100755 index 0000000..0afb5d8 Binary files /dev/null and b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/bin/strings differ diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/bin/strip b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/bin/strip new file mode 100755 index 0000000..7d37d5a Binary files /dev/null and b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/bin/strip differ diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/algorithm b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/algorithm new file mode 100755 index 0000000..ee1cd94 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/algorithm @@ -0,0 +1,68 @@ +// -*- C++ -*- + +// Copyright (C) 2001-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/* + * + * Copyright (c) 1994 + * Hewlett-Packard Company + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Hewlett-Packard Company makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + * + * + * Copyright (c) 1996,1997 + * Silicon Graphics Computer Systems, Inc. + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Silicon Graphics makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + */ + +/** @file include/algorithm + * This is a Standard C++ Library header. + */ + +#ifndef _GLIBCXX_ALGORITHM +#define _GLIBCXX_ALGORITHM 1 + +#pragma GCC system_header + +#include // UK-300. +#include +#include + +#ifdef _GLIBCXX_PARALLEL +# include +#endif + +#endif /* _GLIBCXX_ALGORITHM */ diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/array b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/array new file mode 100755 index 0000000..67680d6 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/array @@ -0,0 +1,337 @@ +// -*- C++ -*- + +// Copyright (C) 2007-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file include/array + * This is a Standard C++ Library header. + */ + +#ifndef _GLIBCXX_ARRAY +#define _GLIBCXX_ARRAY 1 + +#pragma GCC system_header + +#if __cplusplus < 201103L +# include +#else + +#include +#include +#include + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_CONTAINER + + template + struct __array_traits + { + typedef _Tp _Type[_Nm]; + + static constexpr _Tp& + _S_ref(const _Type& __t, std::size_t __n) noexcept + { return const_cast<_Tp&>(__t[__n]); } + }; + + template + struct __array_traits<_Tp, 0> + { + struct _Type { }; + + static constexpr _Tp& + _S_ref(const _Type&, std::size_t) noexcept + { return *static_cast<_Tp*>(nullptr); } + }; + + /** + * @brief A standard container for storing a fixed size sequence of elements. + * + * @ingroup sequences + * + * Meets the requirements of a container, a + * reversible container, and a + * sequence. + * + * Sets support random access iterators. + * + * @tparam Tp Type of element. Required to be a complete type. + * @tparam N Number of elements. + */ + template + struct array + { + typedef _Tp value_type; + typedef value_type* pointer; + typedef const value_type* const_pointer; + typedef value_type& reference; + typedef const value_type& const_reference; + typedef value_type* iterator; + typedef const value_type* const_iterator; + typedef std::size_t size_type; + typedef std::ptrdiff_t difference_type; + typedef std::reverse_iterator reverse_iterator; + typedef std::reverse_iterator const_reverse_iterator; + + // Support for zero-sized arrays mandatory. + typedef _GLIBCXX_STD_C::__array_traits<_Tp, _Nm> _AT_Type; + typename _AT_Type::_Type _M_elems; + + // No explicit construct/copy/destroy for aggregate type. + + // DR 776. + void + fill(const value_type& __u) + { std::fill_n(begin(), size(), __u); } + + void + swap(array& __other) + noexcept(noexcept(swap(std::declval<_Tp&>(), std::declval<_Tp&>()))) + { std::swap_ranges(begin(), end(), __other.begin()); } + + // Iterators. + iterator + begin() noexcept + { return iterator(data()); } + + const_iterator + begin() const noexcept + { return const_iterator(data()); } + + iterator + end() noexcept + { return iterator(data() + _Nm); } + + const_iterator + end() const noexcept + { return const_iterator(data() + _Nm); } + + reverse_iterator + rbegin() noexcept + { return reverse_iterator(end()); } + + const_reverse_iterator + rbegin() const noexcept + { return const_reverse_iterator(end()); } + + reverse_iterator + rend() noexcept + { return reverse_iterator(begin()); } + + const_reverse_iterator + rend() const noexcept + { return const_reverse_iterator(begin()); } + + const_iterator + cbegin() const noexcept + { return const_iterator(data()); } + + const_iterator + cend() const noexcept + { return const_iterator(data() + _Nm); } + + const_reverse_iterator + crbegin() const noexcept + { return const_reverse_iterator(end()); } + + const_reverse_iterator + crend() const noexcept + { return const_reverse_iterator(begin()); } + + // Capacity. + constexpr size_type + size() const noexcept { return _Nm; } + + constexpr size_type + max_size() const noexcept { return _Nm; } + + constexpr bool + empty() const noexcept { return size() == 0; } + + // Element access. + reference + operator[](size_type __n) noexcept + { return _AT_Type::_S_ref(_M_elems, __n); } + + constexpr const_reference + operator[](size_type __n) const noexcept + { return _AT_Type::_S_ref(_M_elems, __n); } + + reference + at(size_type __n) + { + if (__n >= _Nm) + std::__throw_out_of_range_fmt(__N("array::at: __n (which is %zu) " + ">= _Nm (which is %zu)"), + __n, _Nm); + return _AT_Type::_S_ref(_M_elems, __n); + } + + constexpr const_reference + at(size_type __n) const + { + // Result of conditional expression must be an lvalue so use + // boolean ? lvalue : (throw-expr, lvalue) + return __n < _Nm ? _AT_Type::_S_ref(_M_elems, __n) + : (std::__throw_out_of_range_fmt(__N("array::at: __n (which is %zu) " + ">= _Nm (which is %zu)"), + __n, _Nm), + _AT_Type::_S_ref(_M_elems, 0)); + } + + reference + front() noexcept + { return *begin(); } + + constexpr const_reference + front() const noexcept + { return _AT_Type::_S_ref(_M_elems, 0); } + + reference + back() noexcept + { return _Nm ? *(end() - 1) : *end(); } + + constexpr const_reference + back() const noexcept + { + return _Nm ? _AT_Type::_S_ref(_M_elems, _Nm - 1) + : _AT_Type::_S_ref(_M_elems, 0); + } + + pointer + data() noexcept + { return std::__addressof(_AT_Type::_S_ref(_M_elems, 0)); } + + const_pointer + data() const noexcept + { return std::__addressof(_AT_Type::_S_ref(_M_elems, 0)); } + }; + + // Array comparisons. + template + inline bool + operator==(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two) + { return std::equal(__one.begin(), __one.end(), __two.begin()); } + + template + inline bool + operator!=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two) + { return !(__one == __two); } + + template + inline bool + operator<(const array<_Tp, _Nm>& __a, const array<_Tp, _Nm>& __b) + { + return std::lexicographical_compare(__a.begin(), __a.end(), + __b.begin(), __b.end()); + } + + template + inline bool + operator>(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two) + { return __two < __one; } + + template + inline bool + operator<=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two) + { return !(__one > __two); } + + template + inline bool + operator>=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two) + { return !(__one < __two); } + + // Specialized algorithms. + template + inline void + swap(array<_Tp, _Nm>& __one, array<_Tp, _Nm>& __two) + noexcept(noexcept(__one.swap(__two))) + { __one.swap(__two); } + + template + constexpr _Tp& + get(array<_Tp, _Nm>& __arr) noexcept + { + static_assert(_Int < _Nm, "index is out of bounds"); + return _GLIBCXX_STD_C::__array_traits<_Tp, _Nm>:: + _S_ref(__arr._M_elems, _Int); + } + + template + constexpr _Tp&& + get(array<_Tp, _Nm>&& __arr) noexcept + { + static_assert(_Int < _Nm, "index is out of bounds"); + return std::move(get<_Int>(__arr)); + } + + template + constexpr const _Tp& + get(const array<_Tp, _Nm>& __arr) noexcept + { + static_assert(_Int < _Nm, "index is out of bounds"); + return _GLIBCXX_STD_C::__array_traits<_Tp, _Nm>:: + _S_ref(__arr._M_elems, _Int); + } + +_GLIBCXX_END_NAMESPACE_CONTAINER +} // namespace std + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + // Tuple interface to class template array. + + /// tuple_size + template + class tuple_size; + + template + struct tuple_size<_GLIBCXX_STD_C::array<_Tp, _Nm>> + : public integral_constant { }; + + /// tuple_element + template + class tuple_element; + + template + struct tuple_element<_Int, _GLIBCXX_STD_C::array<_Tp, _Nm>> + { + static_assert(_Int < _Nm, "index is out of bounds"); + typedef _Tp type; + }; + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace std + +#ifdef _GLIBCXX_DEBUG +# include +#endif + +#ifdef _GLIBCXX_PROFILE +# include +#endif + +#endif // C++11 + +#endif // _GLIBCXX_ARRAY diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/atomic b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/atomic new file mode 100755 index 0000000..ece75a4 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/atomic @@ -0,0 +1,1126 @@ +// -*- C++ -*- header. + +// Copyright (C) 2008-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file include/atomic + * This is a Standard C++ Library header. + */ + +// Based on "C++ Atomic Types and Operations" by Hans Boehm and Lawrence Crowl. +// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2427.html + +#ifndef _GLIBCXX_ATOMIC +#define _GLIBCXX_ATOMIC 1 + +#pragma GCC system_header + +#if __cplusplus < 201103L +# include +#endif + +#include + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /** + * @addtogroup atomics + * @{ + */ + + /// atomic_bool + // NB: No operators or fetch-operations for this type. + struct atomic_bool + { + private: + __atomic_base _M_base; + + public: + atomic_bool() noexcept = default; + ~atomic_bool() noexcept = default; + atomic_bool(const atomic_bool&) = delete; + atomic_bool& operator=(const atomic_bool&) = delete; + atomic_bool& operator=(const atomic_bool&) volatile = delete; + + constexpr atomic_bool(bool __i) noexcept : _M_base(__i) { } + + bool + operator=(bool __i) noexcept + { return _M_base.operator=(__i); } + + bool + operator=(bool __i) volatile noexcept + { return _M_base.operator=(__i); } + + operator bool() const noexcept + { return _M_base.load(); } + + operator bool() const volatile noexcept + { return _M_base.load(); } + + bool + is_lock_free() const noexcept { return _M_base.is_lock_free(); } + + bool + is_lock_free() const volatile noexcept { return _M_base.is_lock_free(); } + + void + store(bool __i, memory_order __m = memory_order_seq_cst) noexcept + { _M_base.store(__i, __m); } + + void + store(bool __i, memory_order __m = memory_order_seq_cst) volatile noexcept + { _M_base.store(__i, __m); } + + bool + load(memory_order __m = memory_order_seq_cst) const noexcept + { return _M_base.load(__m); } + + bool + load(memory_order __m = memory_order_seq_cst) const volatile noexcept + { return _M_base.load(__m); } + + bool + exchange(bool __i, memory_order __m = memory_order_seq_cst) noexcept + { return _M_base.exchange(__i, __m); } + + bool + exchange(bool __i, + memory_order __m = memory_order_seq_cst) volatile noexcept + { return _M_base.exchange(__i, __m); } + + bool + compare_exchange_weak(bool& __i1, bool __i2, memory_order __m1, + memory_order __m2) noexcept + { return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); } + + bool + compare_exchange_weak(bool& __i1, bool __i2, memory_order __m1, + memory_order __m2) volatile noexcept + { return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); } + + bool + compare_exchange_weak(bool& __i1, bool __i2, + memory_order __m = memory_order_seq_cst) noexcept + { return _M_base.compare_exchange_weak(__i1, __i2, __m); } + + bool + compare_exchange_weak(bool& __i1, bool __i2, + memory_order __m = memory_order_seq_cst) volatile noexcept + { return _M_base.compare_exchange_weak(__i1, __i2, __m); } + + bool + compare_exchange_strong(bool& __i1, bool __i2, memory_order __m1, + memory_order __m2) noexcept + { return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); } + + bool + compare_exchange_strong(bool& __i1, bool __i2, memory_order __m1, + memory_order __m2) volatile noexcept + { return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); } + + bool + compare_exchange_strong(bool& __i1, bool __i2, + memory_order __m = memory_order_seq_cst) noexcept + { return _M_base.compare_exchange_strong(__i1, __i2, __m); } + + bool + compare_exchange_strong(bool& __i1, bool __i2, + memory_order __m = memory_order_seq_cst) volatile noexcept + { return _M_base.compare_exchange_strong(__i1, __i2, __m); } + }; + + + /** + * @brief Generic atomic type, primary class template. + * + * @tparam _Tp Type to be made atomic, must be trivally copyable. + */ + template + struct atomic + { + private: + _Tp _M_i; + + public: + atomic() noexcept = default; + ~atomic() noexcept = default; + atomic(const atomic&) = delete; + atomic& operator=(const atomic&) = delete; + atomic& operator=(const atomic&) volatile = delete; + + constexpr atomic(_Tp __i) noexcept : _M_i(__i) { } + + operator _Tp() const noexcept + { return load(); } + + operator _Tp() const volatile noexcept + { return load(); } + + _Tp + operator=(_Tp __i) noexcept + { store(__i); return __i; } + + _Tp + operator=(_Tp __i) volatile noexcept + { store(__i); return __i; } + + bool + is_lock_free() const noexcept + { return __atomic_is_lock_free(sizeof(_M_i), nullptr); } + + bool + is_lock_free() const volatile noexcept + { return __atomic_is_lock_free(sizeof(_M_i), nullptr); } + + void + store(_Tp __i, memory_order _m = memory_order_seq_cst) noexcept + { __atomic_store(&_M_i, &__i, _m); } + + void + store(_Tp __i, memory_order _m = memory_order_seq_cst) volatile noexcept + { __atomic_store(&_M_i, &__i, _m); } + + _Tp + load(memory_order _m = memory_order_seq_cst) const noexcept + { + _Tp tmp; + __atomic_load(&_M_i, &tmp, _m); + return tmp; + } + + _Tp + load(memory_order _m = memory_order_seq_cst) const volatile noexcept + { + _Tp tmp; + __atomic_load(&_M_i, &tmp, _m); + return tmp; + } + + _Tp + exchange(_Tp __i, memory_order _m = memory_order_seq_cst) noexcept + { + _Tp tmp; + __atomic_exchange(&_M_i, &__i, &tmp, _m); + return tmp; + } + + _Tp + exchange(_Tp __i, + memory_order _m = memory_order_seq_cst) volatile noexcept + { + _Tp tmp; + __atomic_exchange(&_M_i, &__i, &tmp, _m); + return tmp; + } + + bool + compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __s, + memory_order __f) noexcept + { + return __atomic_compare_exchange(&_M_i, &__e, &__i, true, __s, __f); + } + + bool + compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __s, + memory_order __f) volatile noexcept + { + return __atomic_compare_exchange(&_M_i, &__e, &__i, true, __s, __f); + } + + bool + compare_exchange_weak(_Tp& __e, _Tp __i, + memory_order __m = memory_order_seq_cst) noexcept + { return compare_exchange_weak(__e, __i, __m, + __cmpexch_failure_order(__m)); } + + bool + compare_exchange_weak(_Tp& __e, _Tp __i, + memory_order __m = memory_order_seq_cst) volatile noexcept + { return compare_exchange_weak(__e, __i, __m, + __cmpexch_failure_order(__m)); } + + bool + compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __s, + memory_order __f) noexcept + { + return __atomic_compare_exchange(&_M_i, &__e, &__i, false, __s, __f); + } + + bool + compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __s, + memory_order __f) volatile noexcept + { + return __atomic_compare_exchange(&_M_i, &__e, &__i, false, __s, __f); + } + + bool + compare_exchange_strong(_Tp& __e, _Tp __i, + memory_order __m = memory_order_seq_cst) noexcept + { return compare_exchange_strong(__e, __i, __m, + __cmpexch_failure_order(__m)); } + + bool + compare_exchange_strong(_Tp& __e, _Tp __i, + memory_order __m = memory_order_seq_cst) volatile noexcept + { return compare_exchange_strong(__e, __i, __m, + __cmpexch_failure_order(__m)); } + }; + + + /// Partial specialization for pointer types. + template + struct atomic<_Tp*> + { + typedef _Tp* __pointer_type; + typedef __atomic_base<_Tp*> __base_type; + __base_type _M_b; + + atomic() noexcept = default; + ~atomic() noexcept = default; + atomic(const atomic&) = delete; + atomic& operator=(const atomic&) = delete; + atomic& operator=(const atomic&) volatile = delete; + + constexpr atomic(__pointer_type __p) noexcept : _M_b(__p) { } + + operator __pointer_type() const noexcept + { return __pointer_type(_M_b); } + + operator __pointer_type() const volatile noexcept + { return __pointer_type(_M_b); } + + __pointer_type + operator=(__pointer_type __p) noexcept + { return _M_b.operator=(__p); } + + __pointer_type + operator=(__pointer_type __p) volatile noexcept + { return _M_b.operator=(__p); } + + __pointer_type + operator++(int) noexcept + { return _M_b++; } + + __pointer_type + operator++(int) volatile noexcept + { return _M_b++; } + + __pointer_type + operator--(int) noexcept + { return _M_b--; } + + __pointer_type + operator--(int) volatile noexcept + { return _M_b--; } + + __pointer_type + operator++() noexcept + { return ++_M_b; } + + __pointer_type + operator++() volatile noexcept + { return ++_M_b; } + + __pointer_type + operator--() noexcept + { return --_M_b; } + + __pointer_type + operator--() volatile noexcept + { return --_M_b; } + + __pointer_type + operator+=(ptrdiff_t __d) noexcept + { return _M_b.operator+=(__d); } + + __pointer_type + operator+=(ptrdiff_t __d) volatile noexcept + { return _M_b.operator+=(__d); } + + __pointer_type + operator-=(ptrdiff_t __d) noexcept + { return _M_b.operator-=(__d); } + + __pointer_type + operator-=(ptrdiff_t __d) volatile noexcept + { return _M_b.operator-=(__d); } + + bool + is_lock_free() const noexcept + { return _M_b.is_lock_free(); } + + bool + is_lock_free() const volatile noexcept + { return _M_b.is_lock_free(); } + + void + store(__pointer_type __p, + memory_order __m = memory_order_seq_cst) noexcept + { return _M_b.store(__p, __m); } + + void + store(__pointer_type __p, + memory_order __m = memory_order_seq_cst) volatile noexcept + { return _M_b.store(__p, __m); } + + __pointer_type + load(memory_order __m = memory_order_seq_cst) const noexcept + { return _M_b.load(__m); } + + __pointer_type + load(memory_order __m = memory_order_seq_cst) const volatile noexcept + { return _M_b.load(__m); } + + __pointer_type + exchange(__pointer_type __p, + memory_order __m = memory_order_seq_cst) noexcept + { return _M_b.exchange(__p, __m); } + + __pointer_type + exchange(__pointer_type __p, + memory_order __m = memory_order_seq_cst) volatile noexcept + { return _M_b.exchange(__p, __m); } + + bool + compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2, + memory_order __m1, memory_order __m2) noexcept + { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); } + + bool + compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2, + memory_order __m1, + memory_order __m2) volatile noexcept + { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); } + + bool + compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2, + memory_order __m = memory_order_seq_cst) noexcept + { + return compare_exchange_weak(__p1, __p2, __m, + __cmpexch_failure_order(__m)); + } + + bool + compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2, + memory_order __m = memory_order_seq_cst) volatile noexcept + { + return compare_exchange_weak(__p1, __p2, __m, + __cmpexch_failure_order(__m)); + } + + bool + compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, + memory_order __m1, memory_order __m2) noexcept + { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); } + + bool + compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, + memory_order __m1, + memory_order __m2) volatile noexcept + { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); } + + bool + compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, + memory_order __m = memory_order_seq_cst) noexcept + { + return _M_b.compare_exchange_strong(__p1, __p2, __m, + __cmpexch_failure_order(__m)); + } + + bool + compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, + memory_order __m = memory_order_seq_cst) volatile noexcept + { + return _M_b.compare_exchange_strong(__p1, __p2, __m, + __cmpexch_failure_order(__m)); + } + + __pointer_type + fetch_add(ptrdiff_t __d, + memory_order __m = memory_order_seq_cst) noexcept + { return _M_b.fetch_add(__d, __m); } + + __pointer_type + fetch_add(ptrdiff_t __d, + memory_order __m = memory_order_seq_cst) volatile noexcept + { return _M_b.fetch_add(__d, __m); } + + __pointer_type + fetch_sub(ptrdiff_t __d, + memory_order __m = memory_order_seq_cst) noexcept + { return _M_b.fetch_sub(__d, __m); } + + __pointer_type + fetch_sub(ptrdiff_t __d, + memory_order __m = memory_order_seq_cst) volatile noexcept + { return _M_b.fetch_sub(__d, __m); } + }; + + + /// Explicit specialization for bool. + template<> + struct atomic : public atomic_bool + { + typedef bool __integral_type; + typedef atomic_bool __base_type; + + atomic() noexcept = default; + ~atomic() noexcept = default; + atomic(const atomic&) = delete; + atomic& operator=(const atomic&) = delete; + atomic& operator=(const atomic&) volatile = delete; + + constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } + + using __base_type::operator __integral_type; + using __base_type::operator=; + }; + + /// Explicit specialization for char. + template<> + struct atomic : public atomic_char + { + typedef char __integral_type; + typedef atomic_char __base_type; + + atomic() noexcept = default; + ~atomic() noexcept = default; + atomic(const atomic&) = delete; + atomic& operator=(const atomic&) = delete; + atomic& operator=(const atomic&) volatile = delete; + + constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } + + using __base_type::operator __integral_type; + using __base_type::operator=; + }; + + /// Explicit specialization for signed char. + template<> + struct atomic : public atomic_schar + { + typedef signed char __integral_type; + typedef atomic_schar __base_type; + + atomic() noexcept= default; + ~atomic() noexcept = default; + atomic(const atomic&) = delete; + atomic& operator=(const atomic&) = delete; + atomic& operator=(const atomic&) volatile = delete; + + constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } + + using __base_type::operator __integral_type; + using __base_type::operator=; + }; + + /// Explicit specialization for unsigned char. + template<> + struct atomic : public atomic_uchar + { + typedef unsigned char __integral_type; + typedef atomic_uchar __base_type; + + atomic() noexcept= default; + ~atomic() noexcept = default; + atomic(const atomic&) = delete; + atomic& operator=(const atomic&) = delete; + atomic& operator=(const atomic&) volatile = delete; + + constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } + + using __base_type::operator __integral_type; + using __base_type::operator=; + }; + + /// Explicit specialization for short. + template<> + struct atomic : public atomic_short + { + typedef short __integral_type; + typedef atomic_short __base_type; + + atomic() noexcept = default; + ~atomic() noexcept = default; + atomic(const atomic&) = delete; + atomic& operator=(const atomic&) = delete; + atomic& operator=(const atomic&) volatile = delete; + + constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } + + using __base_type::operator __integral_type; + using __base_type::operator=; + }; + + /// Explicit specialization for unsigned short. + template<> + struct atomic : public atomic_ushort + { + typedef unsigned short __integral_type; + typedef atomic_ushort __base_type; + + atomic() noexcept = default; + ~atomic() noexcept = default; + atomic(const atomic&) = delete; + atomic& operator=(const atomic&) = delete; + atomic& operator=(const atomic&) volatile = delete; + + constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } + + using __base_type::operator __integral_type; + using __base_type::operator=; + }; + + /// Explicit specialization for int. + template<> + struct atomic : atomic_int + { + typedef int __integral_type; + typedef atomic_int __base_type; + + atomic() noexcept = default; + ~atomic() noexcept = default; + atomic(const atomic&) = delete; + atomic& operator=(const atomic&) = delete; + atomic& operator=(const atomic&) volatile = delete; + + constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } + + using __base_type::operator __integral_type; + using __base_type::operator=; + }; + + /// Explicit specialization for unsigned int. + template<> + struct atomic : public atomic_uint + { + typedef unsigned int __integral_type; + typedef atomic_uint __base_type; + + atomic() noexcept = default; + ~atomic() noexcept = default; + atomic(const atomic&) = delete; + atomic& operator=(const atomic&) = delete; + atomic& operator=(const atomic&) volatile = delete; + + constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } + + using __base_type::operator __integral_type; + using __base_type::operator=; + }; + + /// Explicit specialization for long. + template<> + struct atomic : public atomic_long + { + typedef long __integral_type; + typedef atomic_long __base_type; + + atomic() noexcept = default; + ~atomic() noexcept = default; + atomic(const atomic&) = delete; + atomic& operator=(const atomic&) = delete; + atomic& operator=(const atomic&) volatile = delete; + + constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } + + using __base_type::operator __integral_type; + using __base_type::operator=; + }; + + /// Explicit specialization for unsigned long. + template<> + struct atomic : public atomic_ulong + { + typedef unsigned long __integral_type; + typedef atomic_ulong __base_type; + + atomic() noexcept = default; + ~atomic() noexcept = default; + atomic(const atomic&) = delete; + atomic& operator=(const atomic&) = delete; + atomic& operator=(const atomic&) volatile = delete; + + constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } + + using __base_type::operator __integral_type; + using __base_type::operator=; + }; + + /// Explicit specialization for long long. + template<> + struct atomic : public atomic_llong + { + typedef long long __integral_type; + typedef atomic_llong __base_type; + + atomic() noexcept = default; + ~atomic() noexcept = default; + atomic(const atomic&) = delete; + atomic& operator=(const atomic&) = delete; + atomic& operator=(const atomic&) volatile = delete; + + constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } + + using __base_type::operator __integral_type; + using __base_type::operator=; + }; + + /// Explicit specialization for unsigned long long. + template<> + struct atomic : public atomic_ullong + { + typedef unsigned long long __integral_type; + typedef atomic_ullong __base_type; + + atomic() noexcept = default; + ~atomic() noexcept = default; + atomic(const atomic&) = delete; + atomic& operator=(const atomic&) = delete; + atomic& operator=(const atomic&) volatile = delete; + + constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } + + using __base_type::operator __integral_type; + using __base_type::operator=; + }; + + /// Explicit specialization for wchar_t. + template<> + struct atomic : public atomic_wchar_t + { + typedef wchar_t __integral_type; + typedef atomic_wchar_t __base_type; + + atomic() noexcept = default; + ~atomic() noexcept = default; + atomic(const atomic&) = delete; + atomic& operator=(const atomic&) = delete; + atomic& operator=(const atomic&) volatile = delete; + + constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } + + using __base_type::operator __integral_type; + using __base_type::operator=; + }; + + /// Explicit specialization for char16_t. + template<> + struct atomic : public atomic_char16_t + { + typedef char16_t __integral_type; + typedef atomic_char16_t __base_type; + + atomic() noexcept = default; + ~atomic() noexcept = default; + atomic(const atomic&) = delete; + atomic& operator=(const atomic&) = delete; + atomic& operator=(const atomic&) volatile = delete; + + constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } + + using __base_type::operator __integral_type; + using __base_type::operator=; + }; + + /// Explicit specialization for char32_t. + template<> + struct atomic : public atomic_char32_t + { + typedef char32_t __integral_type; + typedef atomic_char32_t __base_type; + + atomic() noexcept = default; + ~atomic() noexcept = default; + atomic(const atomic&) = delete; + atomic& operator=(const atomic&) = delete; + atomic& operator=(const atomic&) volatile = delete; + + constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { } + + using __base_type::operator __integral_type; + using __base_type::operator=; + }; + + + // Function definitions, atomic_flag operations. + inline bool + atomic_flag_test_and_set_explicit(atomic_flag* __a, + memory_order __m) noexcept + { return __a->test_and_set(__m); } + + inline bool + atomic_flag_test_and_set_explicit(volatile atomic_flag* __a, + memory_order __m) noexcept + { return __a->test_and_set(__m); } + + inline void + atomic_flag_clear_explicit(atomic_flag* __a, memory_order __m) noexcept + { __a->clear(__m); } + + inline void + atomic_flag_clear_explicit(volatile atomic_flag* __a, + memory_order __m) noexcept + { __a->clear(__m); } + + inline bool + atomic_flag_test_and_set(atomic_flag* __a) noexcept + { return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); } + + inline bool + atomic_flag_test_and_set(volatile atomic_flag* __a) noexcept + { return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); } + + inline void + atomic_flag_clear(atomic_flag* __a) noexcept + { atomic_flag_clear_explicit(__a, memory_order_seq_cst); } + + inline void + atomic_flag_clear(volatile atomic_flag* __a) noexcept + { atomic_flag_clear_explicit(__a, memory_order_seq_cst); } + + + // Function templates generally applicable to atomic types. + template + inline bool + atomic_is_lock_free(const atomic<_ITp>* __a) noexcept + { return __a->is_lock_free(); } + + template + inline bool + atomic_is_lock_free(const volatile atomic<_ITp>* __a) noexcept + { return __a->is_lock_free(); } + + template + inline void + atomic_init(atomic<_ITp>* __a, _ITp __i) noexcept; + + template + inline void + atomic_init(volatile atomic<_ITp>* __a, _ITp __i) noexcept; + + template + inline void + atomic_store_explicit(atomic<_ITp>* __a, _ITp __i, + memory_order __m) noexcept + { __a->store(__i, __m); } + + template + inline void + atomic_store_explicit(volatile atomic<_ITp>* __a, _ITp __i, + memory_order __m) noexcept + { __a->store(__i, __m); } + + template + inline _ITp + atomic_load_explicit(const atomic<_ITp>* __a, memory_order __m) noexcept + { return __a->load(__m); } + + template + inline _ITp + atomic_load_explicit(const volatile atomic<_ITp>* __a, + memory_order __m) noexcept + { return __a->load(__m); } + + template + inline _ITp + atomic_exchange_explicit(atomic<_ITp>* __a, _ITp __i, + memory_order __m) noexcept + { return __a->exchange(__i, __m); } + + template + inline _ITp + atomic_exchange_explicit(volatile atomic<_ITp>* __a, _ITp __i, + memory_order __m) noexcept + { return __a->exchange(__i, __m); } + + template + inline bool + atomic_compare_exchange_weak_explicit(atomic<_ITp>* __a, + _ITp* __i1, _ITp __i2, + memory_order __m1, + memory_order __m2) noexcept + { return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); } + + template + inline bool + atomic_compare_exchange_weak_explicit(volatile atomic<_ITp>* __a, + _ITp* __i1, _ITp __i2, + memory_order __m1, + memory_order __m2) noexcept + { return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); } + + template + inline bool + atomic_compare_exchange_strong_explicit(atomic<_ITp>* __a, + _ITp* __i1, _ITp __i2, + memory_order __m1, + memory_order __m2) noexcept + { return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); } + + template + inline bool + atomic_compare_exchange_strong_explicit(volatile atomic<_ITp>* __a, + _ITp* __i1, _ITp __i2, + memory_order __m1, + memory_order __m2) noexcept + { return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); } + + + template + inline void + atomic_store(atomic<_ITp>* __a, _ITp __i) noexcept + { atomic_store_explicit(__a, __i, memory_order_seq_cst); } + + template + inline void + atomic_store(volatile atomic<_ITp>* __a, _ITp __i) noexcept + { atomic_store_explicit(__a, __i, memory_order_seq_cst); } + + template + inline _ITp + atomic_load(const atomic<_ITp>* __a) noexcept + { return atomic_load_explicit(__a, memory_order_seq_cst); } + + template + inline _ITp + atomic_load(const volatile atomic<_ITp>* __a) noexcept + { return atomic_load_explicit(__a, memory_order_seq_cst); } + + template + inline _ITp + atomic_exchange(atomic<_ITp>* __a, _ITp __i) noexcept + { return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); } + + template + inline _ITp + atomic_exchange(volatile atomic<_ITp>* __a, _ITp __i) noexcept + { return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); } + + template + inline bool + atomic_compare_exchange_weak(atomic<_ITp>* __a, + _ITp* __i1, _ITp __i2) noexcept + { + return atomic_compare_exchange_weak_explicit(__a, __i1, __i2, + memory_order_seq_cst, + memory_order_seq_cst); + } + + template + inline bool + atomic_compare_exchange_weak(volatile atomic<_ITp>* __a, + _ITp* __i1, _ITp __i2) noexcept + { + return atomic_compare_exchange_weak_explicit(__a, __i1, __i2, + memory_order_seq_cst, + memory_order_seq_cst); + } + + template + inline bool + atomic_compare_exchange_strong(atomic<_ITp>* __a, + _ITp* __i1, _ITp __i2) noexcept + { + return atomic_compare_exchange_strong_explicit(__a, __i1, __i2, + memory_order_seq_cst, + memory_order_seq_cst); + } + + template + inline bool + atomic_compare_exchange_strong(volatile atomic<_ITp>* __a, + _ITp* __i1, _ITp __i2) noexcept + { + return atomic_compare_exchange_strong_explicit(__a, __i1, __i2, + memory_order_seq_cst, + memory_order_seq_cst); + } + + // Function templates for atomic_integral operations only, using + // __atomic_base. Template argument should be constricted to + // intergral types as specified in the standard, excluding address + // types. + template + inline _ITp + atomic_fetch_add_explicit(__atomic_base<_ITp>* __a, _ITp __i, + memory_order __m) noexcept + { return __a->fetch_add(__i, __m); } + + template + inline _ITp + atomic_fetch_add_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i, + memory_order __m) noexcept + { return __a->fetch_add(__i, __m); } + + template + inline _ITp + atomic_fetch_sub_explicit(__atomic_base<_ITp>* __a, _ITp __i, + memory_order __m) noexcept + { return __a->fetch_sub(__i, __m); } + + template + inline _ITp + atomic_fetch_sub_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i, + memory_order __m) noexcept + { return __a->fetch_sub(__i, __m); } + + template + inline _ITp + atomic_fetch_and_explicit(__atomic_base<_ITp>* __a, _ITp __i, + memory_order __m) noexcept + { return __a->fetch_and(__i, __m); } + + template + inline _ITp + atomic_fetch_and_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i, + memory_order __m) noexcept + { return __a->fetch_and(__i, __m); } + + template + inline _ITp + atomic_fetch_or_explicit(__atomic_base<_ITp>* __a, _ITp __i, + memory_order __m) noexcept + { return __a->fetch_or(__i, __m); } + + template + inline _ITp + atomic_fetch_or_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i, + memory_order __m) noexcept + { return __a->fetch_or(__i, __m); } + + template + inline _ITp + atomic_fetch_xor_explicit(__atomic_base<_ITp>* __a, _ITp __i, + memory_order __m) noexcept + { return __a->fetch_xor(__i, __m); } + + template + inline _ITp + atomic_fetch_xor_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i, + memory_order __m) noexcept + { return __a->fetch_xor(__i, __m); } + + template + inline _ITp + atomic_fetch_add(__atomic_base<_ITp>* __a, _ITp __i) noexcept + { return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); } + + template + inline _ITp + atomic_fetch_add(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept + { return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); } + + template + inline _ITp + atomic_fetch_sub(__atomic_base<_ITp>* __a, _ITp __i) noexcept + { return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); } + + template + inline _ITp + atomic_fetch_sub(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept + { return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); } + + template + inline _ITp + atomic_fetch_and(__atomic_base<_ITp>* __a, _ITp __i) noexcept + { return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); } + + template + inline _ITp + atomic_fetch_and(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept + { return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); } + + template + inline _ITp + atomic_fetch_or(__atomic_base<_ITp>* __a, _ITp __i) noexcept + { return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); } + + template + inline _ITp + atomic_fetch_or(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept + { return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); } + + template + inline _ITp + atomic_fetch_xor(__atomic_base<_ITp>* __a, _ITp __i) noexcept + { return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); } + + template + inline _ITp + atomic_fetch_xor(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept + { return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); } + + + // Partial specializations for pointers. + template + inline _ITp* + atomic_fetch_add_explicit(atomic<_ITp*>* __a, ptrdiff_t __d, + memory_order __m) noexcept + { return __a->fetch_add(__d, __m); } + + template + inline _ITp* + atomic_fetch_add_explicit(volatile atomic<_ITp*>* __a, ptrdiff_t __d, + memory_order __m) noexcept + { return __a->fetch_add(__d, __m); } + + template + inline _ITp* + atomic_fetch_add(volatile atomic<_ITp*>* __a, ptrdiff_t __d) noexcept + { return __a->fetch_add(__d); } + + template + inline _ITp* + atomic_fetch_add(atomic<_ITp*>* __a, ptrdiff_t __d) noexcept + { return __a->fetch_add(__d); } + + template + inline _ITp* + atomic_fetch_sub_explicit(volatile atomic<_ITp*>* __a, + ptrdiff_t __d, memory_order __m) noexcept + { return __a->fetch_sub(__d, __m); } + + template + inline _ITp* + atomic_fetch_sub_explicit(atomic<_ITp*>* __a, ptrdiff_t __d, + memory_order __m) noexcept + { return __a->fetch_sub(__d, __m); } + + template + inline _ITp* + atomic_fetch_sub(volatile atomic<_ITp*>* __a, ptrdiff_t __d) noexcept + { return __a->fetch_sub(__d); } + + template + inline _ITp* + atomic_fetch_sub(atomic<_ITp*>* __a, ptrdiff_t __d) noexcept + { return __a->fetch_sub(__d); } + // @} group atomics + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/backward/auto_ptr.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/backward/auto_ptr.h new file mode 100755 index 0000000..d7ae487 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/backward/auto_ptr.h @@ -0,0 +1,329 @@ +// auto_ptr implementation -*- C++ -*- + +// Copyright (C) 2007-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file backward/auto_ptr.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{memory} + */ + +#ifndef _BACKWARD_AUTO_PTR_H +#define _BACKWARD_AUTO_PTR_H 1 + +#include +#include + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /** + * A wrapper class to provide auto_ptr with reference semantics. + * For example, an auto_ptr can be assigned (or constructed from) + * the result of a function which returns an auto_ptr by value. + * + * All the auto_ptr_ref stuff should happen behind the scenes. + */ + template + struct auto_ptr_ref + { + _Tp1* _M_ptr; + + explicit + auto_ptr_ref(_Tp1* __p): _M_ptr(__p) { } + } _GLIBCXX_DEPRECATED; + + + /** + * @brief A simple smart pointer providing strict ownership semantics. + * + * The Standard says: + * 
+   *  An @c auto_ptr owns the object it holds a pointer to.  Copying
+   *  an @c auto_ptr copies the pointer and transfers ownership to the
+   *  destination.  If more than one @c auto_ptr owns the same object
+   *  at the same time the behavior of the program is undefined.
+   *
+   *  The uses of @c auto_ptr include providing temporary
+   *  exception-safety for dynamically allocated memory, passing
+   *  ownership of dynamically allocated memory to a function, and
+   *  returning dynamically allocated memory from a function.  @c
+   *  auto_ptr does not meet the CopyConstructible and Assignable
+   *  requirements for Standard Library container elements and thus
+   *  instantiating a Standard Library container with an @c auto_ptr
+   *  results in undefined behavior.
+   *
+ * Quoted from [20.4.5]/3. + * + * Good examples of what can and cannot be done with auto_ptr can + * be found in the libstdc++ testsuite. + * + * _GLIBCXX_RESOLVE_LIB_DEFECTS + * 127. auto_ptr<> conversion issues + * These resolutions have all been incorporated. + */ + template + class auto_ptr + { + private: + _Tp* _M_ptr; + + public: + /// The pointed-to type. + typedef _Tp element_type; + + /** + * @brief An %auto_ptr is usually constructed from a raw pointer. + * @param __p A pointer (defaults to NULL). + * + * This object now @e owns the object pointed to by @a __p. + */ + explicit + auto_ptr(element_type* __p = 0) throw() : _M_ptr(__p) { } + + /** + * @brief An %auto_ptr can be constructed from another %auto_ptr. + * @param __a Another %auto_ptr of the same type. + * + * This object now @e owns the object previously owned by @a __a, + * which has given up ownership. + */ + auto_ptr(auto_ptr& __a) throw() : _M_ptr(__a.release()) { } + + /** + * @brief An %auto_ptr can be constructed from another %auto_ptr. + * @param __a Another %auto_ptr of a different but related type. + * + * A pointer-to-Tp1 must be convertible to a + * pointer-to-Tp/element_type. + * + * This object now @e owns the object previously owned by @a __a, + * which has given up ownership. + */ + template + auto_ptr(auto_ptr<_Tp1>& __a) throw() : _M_ptr(__a.release()) { } + + /** + * @brief %auto_ptr assignment operator. + * @param __a Another %auto_ptr of the same type. + * + * This object now @e owns the object previously owned by @a __a, + * which has given up ownership. The object that this one @e + * used to own and track has been deleted. + */ + auto_ptr& + operator=(auto_ptr& __a) throw() + { + reset(__a.release()); + return *this; + } + + /** + * @brief %auto_ptr assignment operator. + * @param __a Another %auto_ptr of a different but related type. + * + * A pointer-to-Tp1 must be convertible to a pointer-to-Tp/element_type. + * + * This object now @e owns the object previously owned by @a __a, + * which has given up ownership. The object that this one @e + * used to own and track has been deleted. + */ + template + auto_ptr& + operator=(auto_ptr<_Tp1>& __a) throw() + { + reset(__a.release()); + return *this; + } + + /** + * When the %auto_ptr goes out of scope, the object it owns is + * deleted. If it no longer owns anything (i.e., @c get() is + * @c NULL), then this has no effect. + * + * The C++ standard says there is supposed to be an empty throw + * specification here, but omitting it is standard conforming. Its + * presence can be detected only if _Tp::~_Tp() throws, but this is + * prohibited. [17.4.3.6]/2 + */ + ~auto_ptr() { delete _M_ptr; } + + /** + * @brief Smart pointer dereferencing. + * + * If this %auto_ptr no longer owns anything, then this + * operation will crash. (For a smart pointer, no longer owns + * anything is the same as being a null pointer, and you know + * what happens when you dereference one of those...) + */ + element_type& + operator*() const throw() + { + _GLIBCXX_DEBUG_ASSERT(_M_ptr != 0); + return *_M_ptr; + } + + /** + * @brief Smart pointer dereferencing. + * + * This returns the pointer itself, which the language then will + * automatically cause to be dereferenced. + */ + element_type* + operator->() const throw() + { + _GLIBCXX_DEBUG_ASSERT(_M_ptr != 0); + return _M_ptr; + } + + /** + * @brief Bypassing the smart pointer. + * @return The raw pointer being managed. + * + * You can get a copy of the pointer that this object owns, for + * situations such as passing to a function which only accepts + * a raw pointer. + * + * @note This %auto_ptr still owns the memory. + */ + element_type* + get() const throw() { return _M_ptr; } + + /** + * @brief Bypassing the smart pointer. + * @return The raw pointer being managed. + * + * You can get a copy of the pointer that this object owns, for + * situations such as passing to a function which only accepts + * a raw pointer. + * + * @note This %auto_ptr no longer owns the memory. When this object + * goes out of scope, nothing will happen. + */ + element_type* + release() throw() + { + element_type* __tmp = _M_ptr; + _M_ptr = 0; + return __tmp; + } + + /** + * @brief Forcibly deletes the managed object. + * @param __p A pointer (defaults to NULL). + * + * This object now @e owns the object pointed to by @a __p. The + * previous object has been deleted. + */ + void + reset(element_type* __p = 0) throw() + { + if (__p != _M_ptr) + { + delete _M_ptr; + _M_ptr = __p; + } + } + + /** + * @brief Automatic conversions + * + * These operations convert an %auto_ptr into and from an auto_ptr_ref + * automatically as needed. This allows constructs such as + * @code + * auto_ptr func_returning_auto_ptr(.....); + * ... + * auto_ptr ptr = func_returning_auto_ptr(.....); + * @endcode + */ + auto_ptr(auto_ptr_ref __ref) throw() + : _M_ptr(__ref._M_ptr) { } + + auto_ptr& + operator=(auto_ptr_ref __ref) throw() + { + if (__ref._M_ptr != this->get()) + { + delete _M_ptr; + _M_ptr = __ref._M_ptr; + } + return *this; + } + + template + operator auto_ptr_ref<_Tp1>() throw() + { return auto_ptr_ref<_Tp1>(this->release()); } + + template + operator auto_ptr<_Tp1>() throw() + { return auto_ptr<_Tp1>(this->release()); } + } _GLIBCXX_DEPRECATED; + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 541. shared_ptr template assignment and void + template<> + class auto_ptr + { + public: + typedef void element_type; + } _GLIBCXX_DEPRECATED; + +#if __cplusplus >= 201103L + template<_Lock_policy _Lp> + template + inline + __shared_count<_Lp>::__shared_count(std::auto_ptr<_Tp>&& __r) + : _M_pi(new _Sp_counted_ptr<_Tp*, _Lp>(__r.get())) + { __r.release(); } + + template + template + inline + __shared_ptr<_Tp, _Lp>::__shared_ptr(std::auto_ptr<_Tp1>&& __r) + : _M_ptr(__r.get()), _M_refcount() + { + __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>) + static_assert( sizeof(_Tp1) > 0, "incomplete type" ); + _Tp1* __tmp = __r.get(); + _M_refcount = __shared_count<_Lp>(std::move(__r)); + __enable_shared_from_this_helper(_M_refcount, __tmp, __tmp); + } + + template + template + inline + shared_ptr<_Tp>::shared_ptr(std::auto_ptr<_Tp1>&& __r) + : __shared_ptr<_Tp>(std::move(__r)) { } + + template + template + inline + unique_ptr<_Tp, _Dp>::unique_ptr(auto_ptr<_Up>&& __u) noexcept + : _M_t(__u.release(), deleter_type()) { } +#endif + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif /* _BACKWARD_AUTO_PTR_H */ diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/backward/backward_warning.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/backward/backward_warning.h new file mode 100755 index 0000000..d1afed3 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/backward/backward_warning.h @@ -0,0 +1,60 @@ +// Copyright (C) 2001-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file backward/backward_warning.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{iosfwd} + */ + +#ifndef _BACKWARD_BACKWARD_WARNING_H +#define _BACKWARD_BACKWARD_WARNING_H 1 + +#ifdef __DEPRECATED +#warning \ + This file includes at least one deprecated or antiquated header which \ + may be removed without further notice at a future date. Please use a \ + non-deprecated interface with equivalent functionality instead. For a \ + listing of replacement headers and interfaces, consult the file \ + backward_warning.h. To disable this warning use -Wno-deprecated. + +/* + A list of valid replacements is as follows: + + Use: Instead of: + , basic_stringbuf , strstreambuf + , basic_istringstream , istrstream + , basic_ostringstream , ostrstream + , basic_stringstream , strstream + , unordered_set , hash_set + , unordered_multiset , hash_multiset + , unordered_map , hash_map + , unordered_multimap , hash_multimap + , bind , binder1st + , bind , binder2nd + , bind , bind1st + , bind , bind2nd + , unique_ptr , auto_ptr +*/ + +#endif + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/backward/binders.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/backward/binders.h new file mode 100755 index 0000000..bda52ed --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/backward/binders.h @@ -0,0 +1,176 @@ +// Functor implementations -*- C++ -*- + +// Copyright (C) 2001-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/* + * + * Copyright (c) 1994 + * Hewlett-Packard Company + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Hewlett-Packard Company makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + * + * + * Copyright (c) 1996-1998 + * Silicon Graphics Computer Systems, Inc. + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Silicon Graphics makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + */ + +/** @file backward/binders.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{functional} + */ + +#ifndef _BACKWARD_BINDERS_H +#define _BACKWARD_BINDERS_H 1 + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + // 20.3.6 binders + /** @defgroup binders Binder Classes + * @ingroup functors + * + * Binders turn functions/functors with two arguments into functors + * with a single argument, storing an argument to be applied later. + * For example, a variable @c B of type @c binder1st is constructed + * from a functor @c f and an argument @c x. Later, B's @c + * operator() is called with a single argument @c y. The return + * value is the value of @c f(x,y). @c B can be @a called with + * various arguments (y1, y2, ...) and will in turn call @c + * f(x,y1), @c f(x,y2), ... + * + * The function @c bind1st is provided to save some typing. It takes the + * function and an argument as parameters, and returns an instance of + * @c binder1st. + * + * The type @c binder2nd and its creator function @c bind2nd do the same + * thing, but the stored argument is passed as the second parameter instead + * of the first, e.g., @c bind2nd(std::minus(),1.3) will create a + * functor whose @c operator() accepts a floating-point number, subtracts + * 1.3 from it, and returns the result. (If @c bind1st had been used, + * the functor would perform 1.3 - x instead. + * + * Creator-wrapper functions like @c bind1st are intended to be used in + * calling algorithms. Their return values will be temporary objects. + * (The goal is to not require you to type names like + * @c std::binder1st> for declaring a variable to hold the + * return value from @c bind1st(std::plus(),5). + * + * These become more useful when combined with the composition functions. + * + * These functions are deprecated in C++11 and can be replaced by + * @c std::bind (or @c std::tr1::bind) which is more powerful and flexible, + * supporting functions with any number of arguments. Uses of @c bind1st + * can be replaced by @c std::bind(f, x, std::placeholders::_1) and + * @c bind2nd by @c std::bind(f, std::placeholders::_1, x). + * @{ + */ + /// One of the @link binders binder functors@endlink. + template + class binder1st + : public unary_function + { + protected: + _Operation op; + typename _Operation::first_argument_type value; + + public: + binder1st(const _Operation& __x, + const typename _Operation::first_argument_type& __y) + : op(__x), value(__y) { } + + typename _Operation::result_type + operator()(const typename _Operation::second_argument_type& __x) const + { return op(value, __x); } + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 109. Missing binders for non-const sequence elements + typename _Operation::result_type + operator()(typename _Operation::second_argument_type& __x) const + { return op(value, __x); } + } _GLIBCXX_DEPRECATED; + + /// One of the @link binders binder functors@endlink. + template + inline binder1st<_Operation> + bind1st(const _Operation& __fn, const _Tp& __x) + { + typedef typename _Operation::first_argument_type _Arg1_type; + return binder1st<_Operation>(__fn, _Arg1_type(__x)); + } + + /// One of the @link binders binder functors@endlink. + template + class binder2nd + : public unary_function + { + protected: + _Operation op; + typename _Operation::second_argument_type value; + + public: + binder2nd(const _Operation& __x, + const typename _Operation::second_argument_type& __y) + : op(__x), value(__y) { } + + typename _Operation::result_type + operator()(const typename _Operation::first_argument_type& __x) const + { return op(__x, value); } + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 109. Missing binders for non-const sequence elements + typename _Operation::result_type + operator()(typename _Operation::first_argument_type& __x) const + { return op(__x, value); } + } _GLIBCXX_DEPRECATED; + + /// One of the @link binders binder functors@endlink. + template + inline binder2nd<_Operation> + bind2nd(const _Operation& __fn, const _Tp& __x) + { + typedef typename _Operation::second_argument_type _Arg2_type; + return binder2nd<_Operation>(__fn, _Arg2_type(__x)); + } + /** @} */ + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif /* _BACKWARD_BINDERS_H */ diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/backward/hash_fun.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/backward/hash_fun.h new file mode 100755 index 0000000..473babc --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/backward/hash_fun.h @@ -0,0 +1,170 @@ +// 'struct hash' from SGI -*- C++ -*- + +// Copyright (C) 2001-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/* + * Copyright (c) 1996-1998 + * Silicon Graphics Computer Systems, Inc. + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Silicon Graphics makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + * + * + * Copyright (c) 1994 + * Hewlett-Packard Company + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Hewlett-Packard Company makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + * + */ + +/** @file backward/hash_fun.h + * This file is a GNU extension to the Standard C++ Library (possibly + * containing extensions from the HP/SGI STL subset). + */ + +#ifndef _BACKWARD_HASH_FUN_H +#define _BACKWARD_HASH_FUN_H 1 + +#include + +namespace __gnu_cxx _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + using std::size_t; + + template + struct hash { }; + + inline size_t + __stl_hash_string(const char* __s) + { + unsigned long __h = 0; + for ( ; *__s; ++__s) + __h = 5 * __h + *__s; + return size_t(__h); + } + + template<> + struct hash + { + size_t + operator()(const char* __s) const + { return __stl_hash_string(__s); } + }; + + template<> + struct hash + { + size_t + operator()(const char* __s) const + { return __stl_hash_string(__s); } + }; + + template<> + struct hash + { + size_t + operator()(char __x) const + { return __x; } + }; + + template<> + struct hash + { + size_t + operator()(unsigned char __x) const + { return __x; } + }; + + template<> + struct hash + { + size_t + operator()(unsigned char __x) const + { return __x; } + }; + + template<> + struct hash + { + size_t + operator()(short __x) const + { return __x; } + }; + + template<> + struct hash + { + size_t + operator()(unsigned short __x) const + { return __x; } + }; + + template<> + struct hash + { + size_t + operator()(int __x) const + { return __x; } + }; + + template<> + struct hash + { + size_t + operator()(unsigned int __x) const + { return __x; } + }; + + template<> + struct hash + { + size_t + operator()(long __x) const + { return __x; } + }; + + template<> + struct hash + { + size_t + operator()(unsigned long __x) const + { return __x; } + }; + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/backward/hash_map b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/backward/hash_map new file mode 100755 index 0000000..90019cf --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/backward/hash_map @@ -0,0 +1,599 @@ +// Hashing map implementation -*- C++ -*- + +// Copyright (C) 2001-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/* + * Copyright (c) 1996 + * Silicon Graphics Computer Systems, Inc. + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Silicon Graphics makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + * + * + * Copyright (c) 1994 + * Hewlett-Packard Company + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Hewlett-Packard Company makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + * + */ + +/** @file backward/hash_map + * This file is a GNU extension to the Standard C++ Library (possibly + * containing extensions from the HP/SGI STL subset). + */ + +#ifndef _BACKWARD_HASH_MAP +#define _BACKWARD_HASH_MAP 1 + +#ifndef _GLIBCXX_PERMIT_BACKWARD_HASH +#include "backward_warning.h" +#endif + +#include +#include +#include + +namespace __gnu_cxx _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + using std::equal_to; + using std::allocator; + using std::pair; + using std::_Select1st; + + /** + * This is an SGI extension. + * @ingroup SGIextensions + * @doctodo + */ + template, + class _EqualKey = equal_to<_Key>, class _Alloc = allocator<_Tp> > + class hash_map + { + private: + typedef hashtable,_Key, _HashFn, + _Select1st >, + _EqualKey, _Alloc> _Ht; + + _Ht _M_ht; + + public: + typedef typename _Ht::key_type key_type; + typedef _Tp data_type; + typedef _Tp mapped_type; + typedef typename _Ht::value_type value_type; + typedef typename _Ht::hasher hasher; + typedef typename _Ht::key_equal key_equal; + + typedef typename _Ht::size_type size_type; + typedef typename _Ht::difference_type difference_type; + typedef typename _Ht::pointer pointer; + typedef typename _Ht::const_pointer const_pointer; + typedef typename _Ht::reference reference; + typedef typename _Ht::const_reference const_reference; + + typedef typename _Ht::iterator iterator; + typedef typename _Ht::const_iterator const_iterator; + + typedef typename _Ht::allocator_type allocator_type; + + hasher + hash_funct() const + { return _M_ht.hash_funct(); } + + key_equal + key_eq() const + { return _M_ht.key_eq(); } + + allocator_type + get_allocator() const + { return _M_ht.get_allocator(); } + + hash_map() + : _M_ht(100, hasher(), key_equal(), allocator_type()) {} + + explicit + hash_map(size_type __n) + : _M_ht(__n, hasher(), key_equal(), allocator_type()) {} + + hash_map(size_type __n, const hasher& __hf) + : _M_ht(__n, __hf, key_equal(), allocator_type()) {} + + hash_map(size_type __n, const hasher& __hf, const key_equal& __eql, + const allocator_type& __a = allocator_type()) + : _M_ht(__n, __hf, __eql, __a) {} + + template + hash_map(_InputIterator __f, _InputIterator __l) + : _M_ht(100, hasher(), key_equal(), allocator_type()) + { _M_ht.insert_unique(__f, __l); } + + template + hash_map(_InputIterator __f, _InputIterator __l, size_type __n) + : _M_ht(__n, hasher(), key_equal(), allocator_type()) + { _M_ht.insert_unique(__f, __l); } + + template + hash_map(_InputIterator __f, _InputIterator __l, size_type __n, + const hasher& __hf) + : _M_ht(__n, __hf, key_equal(), allocator_type()) + { _M_ht.insert_unique(__f, __l); } + + template + hash_map(_InputIterator __f, _InputIterator __l, size_type __n, + const hasher& __hf, const key_equal& __eql, + const allocator_type& __a = allocator_type()) + : _M_ht(__n, __hf, __eql, __a) + { _M_ht.insert_unique(__f, __l); } + + size_type + size() const + { return _M_ht.size(); } + + size_type + max_size() const + { return _M_ht.max_size(); } + + bool + empty() const + { return _M_ht.empty(); } + + void + swap(hash_map& __hs) + { _M_ht.swap(__hs._M_ht); } + + template + friend bool + operator== (const hash_map<_K1, _T1, _HF, _EqK, _Al>&, + const hash_map<_K1, _T1, _HF, _EqK, _Al>&); + + iterator + begin() + { return _M_ht.begin(); } + + iterator + end() + { return _M_ht.end(); } + + const_iterator + begin() const + { return _M_ht.begin(); } + + const_iterator + end() const + { return _M_ht.end(); } + + pair + insert(const value_type& __obj) + { return _M_ht.insert_unique(__obj); } + + template + void + insert(_InputIterator __f, _InputIterator __l) + { _M_ht.insert_unique(__f, __l); } + + pair + insert_noresize(const value_type& __obj) + { return _M_ht.insert_unique_noresize(__obj); } + + iterator + find(const key_type& __key) + { return _M_ht.find(__key); } + + const_iterator + find(const key_type& __key) const + { return _M_ht.find(__key); } + + _Tp& + operator[](const key_type& __key) + { return _M_ht.find_or_insert(value_type(__key, _Tp())).second; } + + size_type + count(const key_type& __key) const + { return _M_ht.count(__key); } + + pair + equal_range(const key_type& __key) + { return _M_ht.equal_range(__key); } + + pair + equal_range(const key_type& __key) const + { return _M_ht.equal_range(__key); } + + size_type + erase(const key_type& __key) + {return _M_ht.erase(__key); } + + void + erase(iterator __it) + { _M_ht.erase(__it); } + + void + erase(iterator __f, iterator __l) + { _M_ht.erase(__f, __l); } + + void + clear() + { _M_ht.clear(); } + + void + resize(size_type __hint) + { _M_ht.resize(__hint); } + + size_type + bucket_count() const + { return _M_ht.bucket_count(); } + + size_type + max_bucket_count() const + { return _M_ht.max_bucket_count(); } + + size_type + elems_in_bucket(size_type __n) const + { return _M_ht.elems_in_bucket(__n); } + }; + + template + inline bool + operator==(const hash_map<_Key, _Tp, _HashFn, _EqlKey, _Alloc>& __hm1, + const hash_map<_Key, _Tp, _HashFn, _EqlKey, _Alloc>& __hm2) + { return __hm1._M_ht == __hm2._M_ht; } + + template + inline bool + operator!=(const hash_map<_Key, _Tp, _HashFn, _EqlKey, _Alloc>& __hm1, + const hash_map<_Key, _Tp, _HashFn, _EqlKey, _Alloc>& __hm2) + { return !(__hm1 == __hm2); } + + template + inline void + swap(hash_map<_Key, _Tp, _HashFn, _EqlKey, _Alloc>& __hm1, + hash_map<_Key, _Tp, _HashFn, _EqlKey, _Alloc>& __hm2) + { __hm1.swap(__hm2); } + + + /** + * This is an SGI extension. + * @ingroup SGIextensions + * @doctodo + */ + template, + class _EqualKey = equal_to<_Key>, + class _Alloc = allocator<_Tp> > + class hash_multimap + { + // concept requirements + __glibcxx_class_requires(_Key, _SGIAssignableConcept) + __glibcxx_class_requires(_Tp, _SGIAssignableConcept) + __glibcxx_class_requires3(_HashFn, size_t, _Key, _UnaryFunctionConcept) + __glibcxx_class_requires3(_EqualKey, _Key, _Key, _BinaryPredicateConcept) + + private: + typedef hashtable, _Key, _HashFn, + _Select1st >, _EqualKey, _Alloc> + _Ht; + + _Ht _M_ht; + + public: + typedef typename _Ht::key_type key_type; + typedef _Tp data_type; + typedef _Tp mapped_type; + typedef typename _Ht::value_type value_type; + typedef typename _Ht::hasher hasher; + typedef typename _Ht::key_equal key_equal; + + typedef typename _Ht::size_type size_type; + typedef typename _Ht::difference_type difference_type; + typedef typename _Ht::pointer pointer; + typedef typename _Ht::const_pointer const_pointer; + typedef typename _Ht::reference reference; + typedef typename _Ht::const_reference const_reference; + + typedef typename _Ht::iterator iterator; + typedef typename _Ht::const_iterator const_iterator; + + typedef typename _Ht::allocator_type allocator_type; + + hasher + hash_funct() const + { return _M_ht.hash_funct(); } + + key_equal + key_eq() const + { return _M_ht.key_eq(); } + + allocator_type + get_allocator() const + { return _M_ht.get_allocator(); } + + hash_multimap() + : _M_ht(100, hasher(), key_equal(), allocator_type()) {} + + explicit + hash_multimap(size_type __n) + : _M_ht(__n, hasher(), key_equal(), allocator_type()) {} + + hash_multimap(size_type __n, const hasher& __hf) + : _M_ht(__n, __hf, key_equal(), allocator_type()) {} + + hash_multimap(size_type __n, const hasher& __hf, const key_equal& __eql, + const allocator_type& __a = allocator_type()) + : _M_ht(__n, __hf, __eql, __a) {} + + template + hash_multimap(_InputIterator __f, _InputIterator __l) + : _M_ht(100, hasher(), key_equal(), allocator_type()) + { _M_ht.insert_equal(__f, __l); } + + template + hash_multimap(_InputIterator __f, _InputIterator __l, size_type __n) + : _M_ht(__n, hasher(), key_equal(), allocator_type()) + { _M_ht.insert_equal(__f, __l); } + + template + hash_multimap(_InputIterator __f, _InputIterator __l, size_type __n, + const hasher& __hf) + : _M_ht(__n, __hf, key_equal(), allocator_type()) + { _M_ht.insert_equal(__f, __l); } + + template + hash_multimap(_InputIterator __f, _InputIterator __l, size_type __n, + const hasher& __hf, const key_equal& __eql, + const allocator_type& __a = allocator_type()) + : _M_ht(__n, __hf, __eql, __a) + { _M_ht.insert_equal(__f, __l); } + + size_type + size() const + { return _M_ht.size(); } + + size_type + max_size() const + { return _M_ht.max_size(); } + + bool + empty() const + { return _M_ht.empty(); } + + void + swap(hash_multimap& __hs) + { _M_ht.swap(__hs._M_ht); } + + template + friend bool + operator==(const hash_multimap<_K1, _T1, _HF, _EqK, _Al>&, + const hash_multimap<_K1, _T1, _HF, _EqK, _Al>&); + + iterator + begin() + { return _M_ht.begin(); } + + iterator + end() + { return _M_ht.end(); } + + const_iterator + begin() const + { return _M_ht.begin(); } + + const_iterator + end() const + { return _M_ht.end(); } + + iterator + insert(const value_type& __obj) + { return _M_ht.insert_equal(__obj); } + + template + void + insert(_InputIterator __f, _InputIterator __l) + { _M_ht.insert_equal(__f,__l); } + + iterator + insert_noresize(const value_type& __obj) + { return _M_ht.insert_equal_noresize(__obj); } + + iterator + find(const key_type& __key) + { return _M_ht.find(__key); } + + const_iterator + find(const key_type& __key) const + { return _M_ht.find(__key); } + + size_type + count(const key_type& __key) const + { return _M_ht.count(__key); } + + pair + equal_range(const key_type& __key) + { return _M_ht.equal_range(__key); } + + pair + equal_range(const key_type& __key) const + { return _M_ht.equal_range(__key); } + + size_type + erase(const key_type& __key) + { return _M_ht.erase(__key); } + + void + erase(iterator __it) + { _M_ht.erase(__it); } + + void + erase(iterator __f, iterator __l) + { _M_ht.erase(__f, __l); } + + void + clear() + { _M_ht.clear(); } + + void + resize(size_type __hint) + { _M_ht.resize(__hint); } + + size_type + bucket_count() const + { return _M_ht.bucket_count(); } + + size_type + max_bucket_count() const + { return _M_ht.max_bucket_count(); } + + size_type + elems_in_bucket(size_type __n) const + { return _M_ht.elems_in_bucket(__n); } + }; + + template + inline bool + operator==(const hash_multimap<_Key, _Tp, _HF, _EqKey, _Alloc>& __hm1, + const hash_multimap<_Key, _Tp, _HF, _EqKey, _Alloc>& __hm2) + { return __hm1._M_ht == __hm2._M_ht; } + + template + inline bool + operator!=(const hash_multimap<_Key, _Tp, _HF, _EqKey, _Alloc>& __hm1, + const hash_multimap<_Key, _Tp, _HF, _EqKey, _Alloc>& __hm2) + { return !(__hm1 == __hm2); } + + template + inline void + swap(hash_multimap<_Key, _Tp, _HashFn, _EqlKey, _Alloc>& __hm1, + hash_multimap<_Key, _Tp, _HashFn, _EqlKey, _Alloc>& __hm2) + { __hm1.swap(__hm2); } + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + // Specialization of insert_iterator so that it will work for hash_map + // and hash_multimap. + template + class insert_iterator<__gnu_cxx::hash_map<_Key, _Tp, _HashFn, + _EqKey, _Alloc> > + { + protected: + typedef __gnu_cxx::hash_map<_Key, _Tp, _HashFn, _EqKey, _Alloc> + _Container; + _Container* container; + + public: + typedef _Container container_type; + typedef output_iterator_tag iterator_category; + typedef void value_type; + typedef void difference_type; + typedef void pointer; + typedef void reference; + + insert_iterator(_Container& __x) + : container(&__x) {} + + insert_iterator(_Container& __x, typename _Container::iterator) + : container(&__x) {} + + insert_iterator<_Container>& + operator=(const typename _Container::value_type& __value) + { + container->insert(__value); + return *this; + } + + insert_iterator<_Container>& + operator*() + { return *this; } + + insert_iterator<_Container>& + operator++() { return *this; } + + insert_iterator<_Container>& + operator++(int) + { return *this; } + }; + + template + class insert_iterator<__gnu_cxx::hash_multimap<_Key, _Tp, _HashFn, + _EqKey, _Alloc> > + { + protected: + typedef __gnu_cxx::hash_multimap<_Key, _Tp, _HashFn, _EqKey, _Alloc> + _Container; + _Container* container; + typename _Container::iterator iter; + + public: + typedef _Container container_type; + typedef output_iterator_tag iterator_category; + typedef void value_type; + typedef void difference_type; + typedef void pointer; + typedef void reference; + + insert_iterator(_Container& __x) + : container(&__x) {} + + insert_iterator(_Container& __x, typename _Container::iterator) + : container(&__x) {} + + insert_iterator<_Container>& + operator=(const typename _Container::value_type& __value) + { + container->insert(__value); + return *this; + } + + insert_iterator<_Container>& + operator*() + { return *this; } + + insert_iterator<_Container>& + operator++() + { return *this; } + + insert_iterator<_Container>& + operator++(int) + { return *this; } + }; + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/backward/hash_set b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/backward/hash_set new file mode 100755 index 0000000..3e834db --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/backward/hash_set @@ -0,0 +1,567 @@ +// Hashing set implementation -*- C++ -*- + +// Copyright (C) 2001-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/* + * Copyright (c) 1996 + * Silicon Graphics Computer Systems, Inc. + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Silicon Graphics makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + * + * + * Copyright (c) 1994 + * Hewlett-Packard Company + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Hewlett-Packard Company makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + * + */ + +/** @file backward/hash_set + * This file is a GNU extension to the Standard C++ Library (possibly + * containing extensions from the HP/SGI STL subset). + */ + +#ifndef _BACKWARD_HASH_SET +#define _BACKWARD_HASH_SET 1 + +#ifndef _GLIBCXX_PERMIT_BACKWARD_HASH +#include "backward_warning.h" +#endif + +#include +#include +#include + +namespace __gnu_cxx _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + using std::equal_to; + using std::allocator; + using std::pair; + using std::_Identity; + + /** + * This is an SGI extension. + * @ingroup SGIextensions + * @doctodo + */ + template, + class _EqualKey = equal_to<_Value>, + class _Alloc = allocator<_Value> > + class hash_set + { + // concept requirements + __glibcxx_class_requires(_Value, _SGIAssignableConcept) + __glibcxx_class_requires3(_HashFcn, size_t, _Value, _UnaryFunctionConcept) + __glibcxx_class_requires3(_EqualKey, _Value, _Value, _BinaryPredicateConcept) + + private: + typedef hashtable<_Value, _Value, _HashFcn, _Identity<_Value>, + _EqualKey, _Alloc> _Ht; + _Ht _M_ht; + + public: + typedef typename _Ht::key_type key_type; + typedef typename _Ht::value_type value_type; + typedef typename _Ht::hasher hasher; + typedef typename _Ht::key_equal key_equal; + + typedef typename _Ht::size_type size_type; + typedef typename _Ht::difference_type difference_type; + typedef typename _Alloc::pointer pointer; + typedef typename _Alloc::const_pointer const_pointer; + typedef typename _Alloc::reference reference; + typedef typename _Alloc::const_reference const_reference; + + typedef typename _Ht::const_iterator iterator; + typedef typename _Ht::const_iterator const_iterator; + + typedef typename _Ht::allocator_type allocator_type; + + hasher + hash_funct() const + { return _M_ht.hash_funct(); } + + key_equal + key_eq() const + { return _M_ht.key_eq(); } + + allocator_type + get_allocator() const + { return _M_ht.get_allocator(); } + + hash_set() + : _M_ht(100, hasher(), key_equal(), allocator_type()) {} + + explicit + hash_set(size_type __n) + : _M_ht(__n, hasher(), key_equal(), allocator_type()) {} + + hash_set(size_type __n, const hasher& __hf) + : _M_ht(__n, __hf, key_equal(), allocator_type()) {} + + hash_set(size_type __n, const hasher& __hf, const key_equal& __eql, + const allocator_type& __a = allocator_type()) + : _M_ht(__n, __hf, __eql, __a) {} + + template + hash_set(_InputIterator __f, _InputIterator __l) + : _M_ht(100, hasher(), key_equal(), allocator_type()) + { _M_ht.insert_unique(__f, __l); } + + template + hash_set(_InputIterator __f, _InputIterator __l, size_type __n) + : _M_ht(__n, hasher(), key_equal(), allocator_type()) + { _M_ht.insert_unique(__f, __l); } + + template + hash_set(_InputIterator __f, _InputIterator __l, size_type __n, + const hasher& __hf) + : _M_ht(__n, __hf, key_equal(), allocator_type()) + { _M_ht.insert_unique(__f, __l); } + + template + hash_set(_InputIterator __f, _InputIterator __l, size_type __n, + const hasher& __hf, const key_equal& __eql, + const allocator_type& __a = allocator_type()) + : _M_ht(__n, __hf, __eql, __a) + { _M_ht.insert_unique(__f, __l); } + + size_type + size() const + { return _M_ht.size(); } + + size_type + max_size() const + { return _M_ht.max_size(); } + + bool + empty() const + { return _M_ht.empty(); } + + void + swap(hash_set& __hs) + { _M_ht.swap(__hs._M_ht); } + + template + friend bool + operator==(const hash_set<_Val, _HF, _EqK, _Al>&, + const hash_set<_Val, _HF, _EqK, _Al>&); + + iterator + begin() const + { return _M_ht.begin(); } + + iterator + end() const + { return _M_ht.end(); } + + pair + insert(const value_type& __obj) + { + pair __p = _M_ht.insert_unique(__obj); + return pair(__p.first, __p.second); + } + + template + void + insert(_InputIterator __f, _InputIterator __l) + { _M_ht.insert_unique(__f, __l); } + + pair + insert_noresize(const value_type& __obj) + { + pair __p + = _M_ht.insert_unique_noresize(__obj); + return pair(__p.first, __p.second); + } + + iterator + find(const key_type& __key) const + { return _M_ht.find(__key); } + + size_type + count(const key_type& __key) const + { return _M_ht.count(__key); } + + pair + equal_range(const key_type& __key) const + { return _M_ht.equal_range(__key); } + + size_type + erase(const key_type& __key) + {return _M_ht.erase(__key); } + + void + erase(iterator __it) + { _M_ht.erase(__it); } + + void + erase(iterator __f, iterator __l) + { _M_ht.erase(__f, __l); } + + void + clear() + { _M_ht.clear(); } + + void + resize(size_type __hint) + { _M_ht.resize(__hint); } + + size_type + bucket_count() const + { return _M_ht.bucket_count(); } + + size_type + max_bucket_count() const + { return _M_ht.max_bucket_count(); } + + size_type + elems_in_bucket(size_type __n) const + { return _M_ht.elems_in_bucket(__n); } + }; + + template + inline bool + operator==(const hash_set<_Value, _HashFcn, _EqualKey, _Alloc>& __hs1, + const hash_set<_Value, _HashFcn, _EqualKey, _Alloc>& __hs2) + { return __hs1._M_ht == __hs2._M_ht; } + + template + inline bool + operator!=(const hash_set<_Value, _HashFcn, _EqualKey, _Alloc>& __hs1, + const hash_set<_Value, _HashFcn, _EqualKey, _Alloc>& __hs2) + { return !(__hs1 == __hs2); } + + template + inline void + swap(hash_set<_Val, _HashFcn, _EqualKey, _Alloc>& __hs1, + hash_set<_Val, _HashFcn, _EqualKey, _Alloc>& __hs2) + { __hs1.swap(__hs2); } + + + /** + * This is an SGI extension. + * @ingroup SGIextensions + * @doctodo + */ + template, + class _EqualKey = equal_to<_Value>, + class _Alloc = allocator<_Value> > + class hash_multiset + { + // concept requirements + __glibcxx_class_requires(_Value, _SGIAssignableConcept) + __glibcxx_class_requires3(_HashFcn, size_t, _Value, _UnaryFunctionConcept) + __glibcxx_class_requires3(_EqualKey, _Value, _Value, _BinaryPredicateConcept) + + private: + typedef hashtable<_Value, _Value, _HashFcn, _Identity<_Value>, + _EqualKey, _Alloc> _Ht; + _Ht _M_ht; + + public: + typedef typename _Ht::key_type key_type; + typedef typename _Ht::value_type value_type; + typedef typename _Ht::hasher hasher; + typedef typename _Ht::key_equal key_equal; + + typedef typename _Ht::size_type size_type; + typedef typename _Ht::difference_type difference_type; + typedef typename _Alloc::pointer pointer; + typedef typename _Alloc::const_pointer const_pointer; + typedef typename _Alloc::reference reference; + typedef typename _Alloc::const_reference const_reference; + + typedef typename _Ht::const_iterator iterator; + typedef typename _Ht::const_iterator const_iterator; + + typedef typename _Ht::allocator_type allocator_type; + + hasher + hash_funct() const + { return _M_ht.hash_funct(); } + + key_equal + key_eq() const + { return _M_ht.key_eq(); } + + allocator_type + get_allocator() const + { return _M_ht.get_allocator(); } + + hash_multiset() + : _M_ht(100, hasher(), key_equal(), allocator_type()) {} + + explicit + hash_multiset(size_type __n) + : _M_ht(__n, hasher(), key_equal(), allocator_type()) {} + + hash_multiset(size_type __n, const hasher& __hf) + : _M_ht(__n, __hf, key_equal(), allocator_type()) {} + + hash_multiset(size_type __n, const hasher& __hf, const key_equal& __eql, + const allocator_type& __a = allocator_type()) + : _M_ht(__n, __hf, __eql, __a) {} + + template + hash_multiset(_InputIterator __f, _InputIterator __l) + : _M_ht(100, hasher(), key_equal(), allocator_type()) + { _M_ht.insert_equal(__f, __l); } + + template + hash_multiset(_InputIterator __f, _InputIterator __l, size_type __n) + : _M_ht(__n, hasher(), key_equal(), allocator_type()) + { _M_ht.insert_equal(__f, __l); } + + template + hash_multiset(_InputIterator __f, _InputIterator __l, size_type __n, + const hasher& __hf) + : _M_ht(__n, __hf, key_equal(), allocator_type()) + { _M_ht.insert_equal(__f, __l); } + + template + hash_multiset(_InputIterator __f, _InputIterator __l, size_type __n, + const hasher& __hf, const key_equal& __eql, + const allocator_type& __a = allocator_type()) + : _M_ht(__n, __hf, __eql, __a) + { _M_ht.insert_equal(__f, __l); } + + size_type + size() const + { return _M_ht.size(); } + + size_type + max_size() const + { return _M_ht.max_size(); } + + bool + empty() const + { return _M_ht.empty(); } + + void + swap(hash_multiset& hs) + { _M_ht.swap(hs._M_ht); } + + template + friend bool + operator==(const hash_multiset<_Val, _HF, _EqK, _Al>&, + const hash_multiset<_Val, _HF, _EqK, _Al>&); + + iterator + begin() const + { return _M_ht.begin(); } + + iterator + end() const + { return _M_ht.end(); } + + iterator + insert(const value_type& __obj) + { return _M_ht.insert_equal(__obj); } + + template + void + insert(_InputIterator __f, _InputIterator __l) + { _M_ht.insert_equal(__f,__l); } + + iterator + insert_noresize(const value_type& __obj) + { return _M_ht.insert_equal_noresize(__obj); } + + iterator + find(const key_type& __key) const + { return _M_ht.find(__key); } + + size_type + count(const key_type& __key) const + { return _M_ht.count(__key); } + + pair + equal_range(const key_type& __key) const + { return _M_ht.equal_range(__key); } + + size_type + erase(const key_type& __key) + { return _M_ht.erase(__key); } + + void + erase(iterator __it) + { _M_ht.erase(__it); } + + void + erase(iterator __f, iterator __l) + { _M_ht.erase(__f, __l); } + + void + clear() + { _M_ht.clear(); } + + void + resize(size_type __hint) + { _M_ht.resize(__hint); } + + size_type + bucket_count() const + { return _M_ht.bucket_count(); } + + size_type + max_bucket_count() const + { return _M_ht.max_bucket_count(); } + + size_type + elems_in_bucket(size_type __n) const + { return _M_ht.elems_in_bucket(__n); } + }; + + template + inline bool + operator==(const hash_multiset<_Val, _HashFcn, _EqualKey, _Alloc>& __hs1, + const hash_multiset<_Val, _HashFcn, _EqualKey, _Alloc>& __hs2) + { return __hs1._M_ht == __hs2._M_ht; } + + template + inline bool + operator!=(const hash_multiset<_Val, _HashFcn, _EqualKey, _Alloc>& __hs1, + const hash_multiset<_Val, _HashFcn, _EqualKey, _Alloc>& __hs2) + { return !(__hs1 == __hs2); } + + template + inline void + swap(hash_multiset<_Val, _HashFcn, _EqualKey, _Alloc>& __hs1, + hash_multiset<_Val, _HashFcn, _EqualKey, _Alloc>& __hs2) + { __hs1.swap(__hs2); } + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + // Specialization of insert_iterator so that it will work for hash_set + // and hash_multiset. + template + class insert_iterator<__gnu_cxx::hash_set<_Value, _HashFcn, + _EqualKey, _Alloc> > + { + protected: + typedef __gnu_cxx::hash_set<_Value, _HashFcn, _EqualKey, _Alloc> + _Container; + _Container* container; + + public: + typedef _Container container_type; + typedef output_iterator_tag iterator_category; + typedef void value_type; + typedef void difference_type; + typedef void pointer; + typedef void reference; + + insert_iterator(_Container& __x) + : container(&__x) {} + + insert_iterator(_Container& __x, typename _Container::iterator) + : container(&__x) {} + + insert_iterator<_Container>& + operator=(const typename _Container::value_type& __value) + { + container->insert(__value); + return *this; + } + + insert_iterator<_Container>& + operator*() + { return *this; } + + insert_iterator<_Container>& + operator++() + { return *this; } + + insert_iterator<_Container>& + operator++(int) + { return *this; } + }; + + template + class insert_iterator<__gnu_cxx::hash_multiset<_Value, _HashFcn, + _EqualKey, _Alloc> > + { + protected: + typedef __gnu_cxx::hash_multiset<_Value, _HashFcn, _EqualKey, _Alloc> + _Container; + _Container* container; + typename _Container::iterator iter; + + public: + typedef _Container container_type; + typedef output_iterator_tag iterator_category; + typedef void value_type; + typedef void difference_type; + typedef void pointer; + typedef void reference; + + insert_iterator(_Container& __x) + : container(&__x) {} + + insert_iterator(_Container& __x, typename _Container::iterator) + : container(&__x) {} + + insert_iterator<_Container>& + operator=(const typename _Container::value_type& __value) + { + container->insert(__value); + return *this; + } + + insert_iterator<_Container>& + operator*() + { return *this; } + + insert_iterator<_Container>& + operator++() + { return *this; } + + insert_iterator<_Container>& + operator++(int) { return *this; } + }; + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/backward/hashtable.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/backward/hashtable.h new file mode 100755 index 0000000..86121af --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/backward/hashtable.h @@ -0,0 +1,1167 @@ +// Hashtable implementation used by containers -*- C++ -*- + +// Copyright (C) 2001-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/* + * Copyright (c) 1996,1997 + * Silicon Graphics Computer Systems, Inc. + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Silicon Graphics makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + * + * + * Copyright (c) 1994 + * Hewlett-Packard Company + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Hewlett-Packard Company makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + * + */ + +/** @file backward/hashtable.h + * This file is a GNU extension to the Standard C++ Library (possibly + * containing extensions from the HP/SGI STL subset). + */ + +#ifndef _BACKWARD_HASHTABLE_H +#define _BACKWARD_HASHTABLE_H 1 + +// Hashtable class, used to implement the hashed associative containers +// hash_set, hash_map, hash_multiset, and hash_multimap. + +#include +#include +#include +#include +#include + +namespace __gnu_cxx _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + using std::size_t; + using std::ptrdiff_t; + using std::forward_iterator_tag; + using std::input_iterator_tag; + using std::_Construct; + using std::_Destroy; + using std::distance; + using std::vector; + using std::pair; + using std::__iterator_category; + + template + struct _Hashtable_node + { + _Hashtable_node* _M_next; + _Val _M_val; + }; + + template > + class hashtable; + + template + struct _Hashtable_iterator; + + template + struct _Hashtable_const_iterator; + + template + struct _Hashtable_iterator + { + typedef hashtable<_Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc> + _Hashtable; + typedef _Hashtable_iterator<_Val, _Key, _HashFcn, + _ExtractKey, _EqualKey, _Alloc> + iterator; + typedef _Hashtable_const_iterator<_Val, _Key, _HashFcn, + _ExtractKey, _EqualKey, _Alloc> + const_iterator; + typedef _Hashtable_node<_Val> _Node; + typedef forward_iterator_tag iterator_category; + typedef _Val value_type; + typedef ptrdiff_t difference_type; + typedef size_t size_type; + typedef _Val& reference; + typedef _Val* pointer; + + _Node* _M_cur; + _Hashtable* _M_ht; + + _Hashtable_iterator(_Node* __n, _Hashtable* __tab) + : _M_cur(__n), _M_ht(__tab) { } + + _Hashtable_iterator() { } + + reference + operator*() const + { return _M_cur->_M_val; } + + pointer + operator->() const + { return &(operator*()); } + + iterator& + operator++(); + + iterator + operator++(int); + + bool + operator==(const iterator& __it) const + { return _M_cur == __it._M_cur; } + + bool + operator!=(const iterator& __it) const + { return _M_cur != __it._M_cur; } + }; + + template + struct _Hashtable_const_iterator + { + typedef hashtable<_Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc> + _Hashtable; + typedef _Hashtable_iterator<_Val,_Key,_HashFcn, + _ExtractKey,_EqualKey,_Alloc> + iterator; + typedef _Hashtable_const_iterator<_Val, _Key, _HashFcn, + _ExtractKey, _EqualKey, _Alloc> + const_iterator; + typedef _Hashtable_node<_Val> _Node; + + typedef forward_iterator_tag iterator_category; + typedef _Val value_type; + typedef ptrdiff_t difference_type; + typedef size_t size_type; + typedef const _Val& reference; + typedef const _Val* pointer; + + const _Node* _M_cur; + const _Hashtable* _M_ht; + + _Hashtable_const_iterator(const _Node* __n, const _Hashtable* __tab) + : _M_cur(__n), _M_ht(__tab) { } + + _Hashtable_const_iterator() { } + + _Hashtable_const_iterator(const iterator& __it) + : _M_cur(__it._M_cur), _M_ht(__it._M_ht) { } + + reference + operator*() const + { return _M_cur->_M_val; } + + pointer + operator->() const + { return &(operator*()); } + + const_iterator& + operator++(); + + const_iterator + operator++(int); + + bool + operator==(const const_iterator& __it) const + { return _M_cur == __it._M_cur; } + + bool + operator!=(const const_iterator& __it) const + { return _M_cur != __it._M_cur; } + }; + + // Note: assumes long is at least 32 bits. + enum { _S_num_primes = 29 }; + + template + struct _Hashtable_prime_list + { + static const _PrimeType __stl_prime_list[_S_num_primes]; + + static const _PrimeType* + _S_get_prime_list(); + }; + + template const _PrimeType + _Hashtable_prime_list<_PrimeType>::__stl_prime_list[_S_num_primes] = + { + 5ul, 53ul, 97ul, 193ul, 389ul, + 769ul, 1543ul, 3079ul, 6151ul, 12289ul, + 24593ul, 49157ul, 98317ul, 196613ul, 393241ul, + 786433ul, 1572869ul, 3145739ul, 6291469ul, 12582917ul, + 25165843ul, 50331653ul, 100663319ul, 201326611ul, 402653189ul, + 805306457ul, 1610612741ul, 3221225473ul, 4294967291ul + }; + + template inline const _PrimeType* + _Hashtable_prime_list<_PrimeType>::_S_get_prime_list() + { + return __stl_prime_list; + } + + inline unsigned long + __stl_next_prime(unsigned long __n) + { + const unsigned long* __first = _Hashtable_prime_list::_S_get_prime_list(); + const unsigned long* __last = __first + (int)_S_num_primes; + const unsigned long* pos = std::lower_bound(__first, __last, __n); + return pos == __last ? *(__last - 1) : *pos; + } + + // Forward declaration of operator==. + template + class hashtable; + + template + bool + operator==(const hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>& __ht1, + const hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>& __ht2); + + // Hashtables handle allocators a bit differently than other + // containers do. If we're using standard-conforming allocators, then + // a hashtable unconditionally has a member variable to hold its + // allocator, even if it so happens that all instances of the + // allocator type are identical. This is because, for hashtables, + // this extra storage is negligible. Additionally, a base class + // wouldn't serve any other purposes; it wouldn't, for example, + // simplify the exception-handling code. + template + class hashtable + { + public: + typedef _Key key_type; + typedef _Val value_type; + typedef _HashFcn hasher; + typedef _EqualKey key_equal; + + typedef size_t size_type; + typedef ptrdiff_t difference_type; + typedef value_type* pointer; + typedef const value_type* const_pointer; + typedef value_type& reference; + typedef const value_type& const_reference; + + hasher + hash_funct() const + { return _M_hash; } + + key_equal + key_eq() const + { return _M_equals; } + + private: + typedef _Hashtable_node<_Val> _Node; + + public: + typedef typename _Alloc::template rebind::other allocator_type; + allocator_type + get_allocator() const + { return _M_node_allocator; } + + private: + typedef typename _Alloc::template rebind<_Node>::other _Node_Alloc; + typedef typename _Alloc::template rebind<_Node*>::other _Nodeptr_Alloc; + typedef vector<_Node*, _Nodeptr_Alloc> _Vector_type; + + _Node_Alloc _M_node_allocator; + + _Node* + _M_get_node() + { return _M_node_allocator.allocate(1); } + + void + _M_put_node(_Node* __p) + { _M_node_allocator.deallocate(__p, 1); } + + private: + hasher _M_hash; + key_equal _M_equals; + _ExtractKey _M_get_key; + _Vector_type _M_buckets; + size_type _M_num_elements; + + public: + typedef _Hashtable_iterator<_Val, _Key, _HashFcn, _ExtractKey, + _EqualKey, _Alloc> + iterator; + typedef _Hashtable_const_iterator<_Val, _Key, _HashFcn, _ExtractKey, + _EqualKey, _Alloc> + const_iterator; + + friend struct + _Hashtable_iterator<_Val, _Key, _HashFcn, _ExtractKey, _EqualKey, _Alloc>; + + friend struct + _Hashtable_const_iterator<_Val, _Key, _HashFcn, _ExtractKey, + _EqualKey, _Alloc>; + + public: + hashtable(size_type __n, const _HashFcn& __hf, + const _EqualKey& __eql, const _ExtractKey& __ext, + const allocator_type& __a = allocator_type()) + : _M_node_allocator(__a), _M_hash(__hf), _M_equals(__eql), + _M_get_key(__ext), _M_buckets(__a), _M_num_elements(0) + { _M_initialize_buckets(__n); } + + hashtable(size_type __n, const _HashFcn& __hf, + const _EqualKey& __eql, + const allocator_type& __a = allocator_type()) + : _M_node_allocator(__a), _M_hash(__hf), _M_equals(__eql), + _M_get_key(_ExtractKey()), _M_buckets(__a), _M_num_elements(0) + { _M_initialize_buckets(__n); } + + hashtable(const hashtable& __ht) + : _M_node_allocator(__ht.get_allocator()), _M_hash(__ht._M_hash), + _M_equals(__ht._M_equals), _M_get_key(__ht._M_get_key), + _M_buckets(__ht.get_allocator()), _M_num_elements(0) + { _M_copy_from(__ht); } + + hashtable& + operator= (const hashtable& __ht) + { + if (&__ht != this) + { + clear(); + _M_hash = __ht._M_hash; + _M_equals = __ht._M_equals; + _M_get_key = __ht._M_get_key; + _M_copy_from(__ht); + } + return *this; + } + + ~hashtable() + { clear(); } + + size_type + size() const + { return _M_num_elements; } + + size_type + max_size() const + { return size_type(-1); } + + bool + empty() const + { return size() == 0; } + + void + swap(hashtable& __ht) + { + std::swap(_M_hash, __ht._M_hash); + std::swap(_M_equals, __ht._M_equals); + std::swap(_M_get_key, __ht._M_get_key); + _M_buckets.swap(__ht._M_buckets); + std::swap(_M_num_elements, __ht._M_num_elements); + } + + iterator + begin() + { + for (size_type __n = 0; __n < _M_buckets.size(); ++__n) + if (_M_buckets[__n]) + return iterator(_M_buckets[__n], this); + return end(); + } + + iterator + end() + { return iterator(0, this); } + + const_iterator + begin() const + { + for (size_type __n = 0; __n < _M_buckets.size(); ++__n) + if (_M_buckets[__n]) + return const_iterator(_M_buckets[__n], this); + return end(); + } + + const_iterator + end() const + { return const_iterator(0, this); } + + template + friend bool + operator==(const hashtable<_Vl, _Ky, _HF, _Ex, _Eq, _Al>&, + const hashtable<_Vl, _Ky, _HF, _Ex, _Eq, _Al>&); + + public: + size_type + bucket_count() const + { return _M_buckets.size(); } + + size_type + max_bucket_count() const + { return _Hashtable_prime_list:: + _S_get_prime_list()[(int)_S_num_primes - 1]; + } + + size_type + elems_in_bucket(size_type __bucket) const + { + size_type __result = 0; + for (_Node* __n = _M_buckets[__bucket]; __n; __n = __n->_M_next) + __result += 1; + return __result; + } + + pair + insert_unique(const value_type& __obj) + { + resize(_M_num_elements + 1); + return insert_unique_noresize(__obj); + } + + iterator + insert_equal(const value_type& __obj) + { + resize(_M_num_elements + 1); + return insert_equal_noresize(__obj); + } + + pair + insert_unique_noresize(const value_type& __obj); + + iterator + insert_equal_noresize(const value_type& __obj); + + template + void + insert_unique(_InputIterator __f, _InputIterator __l) + { insert_unique(__f, __l, __iterator_category(__f)); } + + template + void + insert_equal(_InputIterator __f, _InputIterator __l) + { insert_equal(__f, __l, __iterator_category(__f)); } + + template + void + insert_unique(_InputIterator __f, _InputIterator __l, + input_iterator_tag) + { + for ( ; __f != __l; ++__f) + insert_unique(*__f); + } + + template + void + insert_equal(_InputIterator __f, _InputIterator __l, + input_iterator_tag) + { + for ( ; __f != __l; ++__f) + insert_equal(*__f); + } + + template + void + insert_unique(_ForwardIterator __f, _ForwardIterator __l, + forward_iterator_tag) + { + size_type __n = distance(__f, __l); + resize(_M_num_elements + __n); + for ( ; __n > 0; --__n, ++__f) + insert_unique_noresize(*__f); + } + + template + void + insert_equal(_ForwardIterator __f, _ForwardIterator __l, + forward_iterator_tag) + { + size_type __n = distance(__f, __l); + resize(_M_num_elements + __n); + for ( ; __n > 0; --__n, ++__f) + insert_equal_noresize(*__f); + } + + reference + find_or_insert(const value_type& __obj); + + iterator + find(const key_type& __key) + { + size_type __n = _M_bkt_num_key(__key); + _Node* __first; + for (__first = _M_buckets[__n]; + __first && !_M_equals(_M_get_key(__first->_M_val), __key); + __first = __first->_M_next) + { } + return iterator(__first, this); + } + + const_iterator + find(const key_type& __key) const + { + size_type __n = _M_bkt_num_key(__key); + const _Node* __first; + for (__first = _M_buckets[__n]; + __first && !_M_equals(_M_get_key(__first->_M_val), __key); + __first = __first->_M_next) + { } + return const_iterator(__first, this); + } + + size_type + count(const key_type& __key) const + { + const size_type __n = _M_bkt_num_key(__key); + size_type __result = 0; + + for (const _Node* __cur = _M_buckets[__n]; __cur; + __cur = __cur->_M_next) + if (_M_equals(_M_get_key(__cur->_M_val), __key)) + ++__result; + return __result; + } + + pair + equal_range(const key_type& __key); + + pair + equal_range(const key_type& __key) const; + + size_type + erase(const key_type& __key); + + void + erase(const iterator& __it); + + void + erase(iterator __first, iterator __last); + + void + erase(const const_iterator& __it); + + void + erase(const_iterator __first, const_iterator __last); + + void + resize(size_type __num_elements_hint); + + void + clear(); + + private: + size_type + _M_next_size(size_type __n) const + { return __stl_next_prime(__n); } + + void + _M_initialize_buckets(size_type __n) + { + const size_type __n_buckets = _M_next_size(__n); + _M_buckets.reserve(__n_buckets); + _M_buckets.insert(_M_buckets.end(), __n_buckets, (_Node*) 0); + _M_num_elements = 0; + } + + size_type + _M_bkt_num_key(const key_type& __key) const + { return _M_bkt_num_key(__key, _M_buckets.size()); } + + size_type + _M_bkt_num(const value_type& __obj) const + { return _M_bkt_num_key(_M_get_key(__obj)); } + + size_type + _M_bkt_num_key(const key_type& __key, size_t __n) const + { return _M_hash(__key) % __n; } + + size_type + _M_bkt_num(const value_type& __obj, size_t __n) const + { return _M_bkt_num_key(_M_get_key(__obj), __n); } + + _Node* + _M_new_node(const value_type& __obj) + { + _Node* __n = _M_get_node(); + __n->_M_next = 0; + __try + { + this->get_allocator().construct(&__n->_M_val, __obj); + return __n; + } + __catch(...) + { + _M_put_node(__n); + __throw_exception_again; + } + } + + void + _M_delete_node(_Node* __n) + { + this->get_allocator().destroy(&__n->_M_val); + _M_put_node(__n); + } + + void + _M_erase_bucket(const size_type __n, _Node* __first, _Node* __last); + + void + _M_erase_bucket(const size_type __n, _Node* __last); + + void + _M_copy_from(const hashtable& __ht); + }; + + template + _Hashtable_iterator<_Val, _Key, _HF, _ExK, _EqK, _All>& + _Hashtable_iterator<_Val, _Key, _HF, _ExK, _EqK, _All>:: + operator++() + { + const _Node* __old = _M_cur; + _M_cur = _M_cur->_M_next; + if (!_M_cur) + { + size_type __bucket = _M_ht->_M_bkt_num(__old->_M_val); + while (!_M_cur && ++__bucket < _M_ht->_M_buckets.size()) + _M_cur = _M_ht->_M_buckets[__bucket]; + } + return *this; + } + + template + inline _Hashtable_iterator<_Val, _Key, _HF, _ExK, _EqK, _All> + _Hashtable_iterator<_Val, _Key, _HF, _ExK, _EqK, _All>:: + operator++(int) + { + iterator __tmp = *this; + ++*this; + return __tmp; + } + + template + _Hashtable_const_iterator<_Val, _Key, _HF, _ExK, _EqK, _All>& + _Hashtable_const_iterator<_Val, _Key, _HF, _ExK, _EqK, _All>:: + operator++() + { + const _Node* __old = _M_cur; + _M_cur = _M_cur->_M_next; + if (!_M_cur) + { + size_type __bucket = _M_ht->_M_bkt_num(__old->_M_val); + while (!_M_cur && ++__bucket < _M_ht->_M_buckets.size()) + _M_cur = _M_ht->_M_buckets[__bucket]; + } + return *this; + } + + template + inline _Hashtable_const_iterator<_Val, _Key, _HF, _ExK, _EqK, _All> + _Hashtable_const_iterator<_Val, _Key, _HF, _ExK, _EqK, _All>:: + operator++(int) + { + const_iterator __tmp = *this; + ++*this; + return __tmp; + } + + template + bool + operator==(const hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>& __ht1, + const hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>& __ht2) + { + typedef typename hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>::_Node _Node; + + if (__ht1._M_buckets.size() != __ht2._M_buckets.size()) + return false; + + for (size_t __n = 0; __n < __ht1._M_buckets.size(); ++__n) + { + _Node* __cur1 = __ht1._M_buckets[__n]; + _Node* __cur2 = __ht2._M_buckets[__n]; + // Check same length of lists + for (; __cur1 && __cur2; + __cur1 = __cur1->_M_next, __cur2 = __cur2->_M_next) + { } + if (__cur1 || __cur2) + return false; + // Now check one's elements are in the other + for (__cur1 = __ht1._M_buckets[__n] ; __cur1; + __cur1 = __cur1->_M_next) + { + bool _found__cur1 = false; + for (__cur2 = __ht2._M_buckets[__n]; + __cur2; __cur2 = __cur2->_M_next) + { + if (__cur1->_M_val == __cur2->_M_val) + { + _found__cur1 = true; + break; + } + } + if (!_found__cur1) + return false; + } + } + return true; + } + + template + inline bool + operator!=(const hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>& __ht1, + const hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>& __ht2) + { return !(__ht1 == __ht2); } + + template + inline void + swap(hashtable<_Val, _Key, _HF, _Extract, _EqKey, _All>& __ht1, + hashtable<_Val, _Key, _HF, _Extract, _EqKey, _All>& __ht2) + { __ht1.swap(__ht2); } + + template + pair::iterator, bool> + hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>:: + insert_unique_noresize(const value_type& __obj) + { + const size_type __n = _M_bkt_num(__obj); + _Node* __first = _M_buckets[__n]; + + for (_Node* __cur = __first; __cur; __cur = __cur->_M_next) + if (_M_equals(_M_get_key(__cur->_M_val), _M_get_key(__obj))) + return pair(iterator(__cur, this), false); + + _Node* __tmp = _M_new_node(__obj); + __tmp->_M_next = __first; + _M_buckets[__n] = __tmp; + ++_M_num_elements; + return pair(iterator(__tmp, this), true); + } + + template + typename hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>::iterator + hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>:: + insert_equal_noresize(const value_type& __obj) + { + const size_type __n = _M_bkt_num(__obj); + _Node* __first = _M_buckets[__n]; + + for (_Node* __cur = __first; __cur; __cur = __cur->_M_next) + if (_M_equals(_M_get_key(__cur->_M_val), _M_get_key(__obj))) + { + _Node* __tmp = _M_new_node(__obj); + __tmp->_M_next = __cur->_M_next; + __cur->_M_next = __tmp; + ++_M_num_elements; + return iterator(__tmp, this); + } + + _Node* __tmp = _M_new_node(__obj); + __tmp->_M_next = __first; + _M_buckets[__n] = __tmp; + ++_M_num_elements; + return iterator(__tmp, this); + } + + template + typename hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>::reference + hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>:: + find_or_insert(const value_type& __obj) + { + resize(_M_num_elements + 1); + + size_type __n = _M_bkt_num(__obj); + _Node* __first = _M_buckets[__n]; + + for (_Node* __cur = __first; __cur; __cur = __cur->_M_next) + if (_M_equals(_M_get_key(__cur->_M_val), _M_get_key(__obj))) + return __cur->_M_val; + + _Node* __tmp = _M_new_node(__obj); + __tmp->_M_next = __first; + _M_buckets[__n] = __tmp; + ++_M_num_elements; + return __tmp->_M_val; + } + + template + pair::iterator, + typename hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>::iterator> + hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>:: + equal_range(const key_type& __key) + { + typedef pair _Pii; + const size_type __n = _M_bkt_num_key(__key); + + for (_Node* __first = _M_buckets[__n]; __first; + __first = __first->_M_next) + if (_M_equals(_M_get_key(__first->_M_val), __key)) + { + for (_Node* __cur = __first->_M_next; __cur; + __cur = __cur->_M_next) + if (!_M_equals(_M_get_key(__cur->_M_val), __key)) + return _Pii(iterator(__first, this), iterator(__cur, this)); + for (size_type __m = __n + 1; __m < _M_buckets.size(); ++__m) + if (_M_buckets[__m]) + return _Pii(iterator(__first, this), + iterator(_M_buckets[__m], this)); + return _Pii(iterator(__first, this), end()); + } + return _Pii(end(), end()); + } + + template + pair::const_iterator, + typename hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>::const_iterator> + hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>:: + equal_range(const key_type& __key) const + { + typedef pair _Pii; + const size_type __n = _M_bkt_num_key(__key); + + for (const _Node* __first = _M_buckets[__n]; __first; + __first = __first->_M_next) + { + if (_M_equals(_M_get_key(__first->_M_val), __key)) + { + for (const _Node* __cur = __first->_M_next; __cur; + __cur = __cur->_M_next) + if (!_M_equals(_M_get_key(__cur->_M_val), __key)) + return _Pii(const_iterator(__first, this), + const_iterator(__cur, this)); + for (size_type __m = __n + 1; __m < _M_buckets.size(); ++__m) + if (_M_buckets[__m]) + return _Pii(const_iterator(__first, this), + const_iterator(_M_buckets[__m], this)); + return _Pii(const_iterator(__first, this), end()); + } + } + return _Pii(end(), end()); + } + + template + typename hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>::size_type + hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>:: + erase(const key_type& __key) + { + const size_type __n = _M_bkt_num_key(__key); + _Node* __first = _M_buckets[__n]; + _Node* __saved_slot = 0; + size_type __erased = 0; + + if (__first) + { + _Node* __cur = __first; + _Node* __next = __cur->_M_next; + while (__next) + { + if (_M_equals(_M_get_key(__next->_M_val), __key)) + { + if (&_M_get_key(__next->_M_val) != &__key) + { + __cur->_M_next = __next->_M_next; + _M_delete_node(__next); + __next = __cur->_M_next; + ++__erased; + --_M_num_elements; + } + else + { + __saved_slot = __cur; + __cur = __next; + __next = __cur->_M_next; + } + } + else + { + __cur = __next; + __next = __cur->_M_next; + } + } + bool __delete_first = _M_equals(_M_get_key(__first->_M_val), __key); + if (__saved_slot) + { + __next = __saved_slot->_M_next; + __saved_slot->_M_next = __next->_M_next; + _M_delete_node(__next); + ++__erased; + --_M_num_elements; + } + if (__delete_first) + { + _M_buckets[__n] = __first->_M_next; + _M_delete_node(__first); + ++__erased; + --_M_num_elements; + } + } + return __erased; + } + + template + void hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>:: + erase(const iterator& __it) + { + _Node* __p = __it._M_cur; + if (__p) + { + const size_type __n = _M_bkt_num(__p->_M_val); + _Node* __cur = _M_buckets[__n]; + + if (__cur == __p) + { + _M_buckets[__n] = __cur->_M_next; + _M_delete_node(__cur); + --_M_num_elements; + } + else + { + _Node* __next = __cur->_M_next; + while (__next) + { + if (__next == __p) + { + __cur->_M_next = __next->_M_next; + _M_delete_node(__next); + --_M_num_elements; + break; + } + else + { + __cur = __next; + __next = __cur->_M_next; + } + } + } + } + } + + template + void + hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>:: + erase(iterator __first, iterator __last) + { + size_type __f_bucket = __first._M_cur ? _M_bkt_num(__first._M_cur->_M_val) + : _M_buckets.size(); + + size_type __l_bucket = __last._M_cur ? _M_bkt_num(__last._M_cur->_M_val) + : _M_buckets.size(); + + if (__first._M_cur == __last._M_cur) + return; + else if (__f_bucket == __l_bucket) + _M_erase_bucket(__f_bucket, __first._M_cur, __last._M_cur); + else + { + _M_erase_bucket(__f_bucket, __first._M_cur, 0); + for (size_type __n = __f_bucket + 1; __n < __l_bucket; ++__n) + _M_erase_bucket(__n, 0); + if (__l_bucket != _M_buckets.size()) + _M_erase_bucket(__l_bucket, __last._M_cur); + } + } + + template + inline void + hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>:: + erase(const_iterator __first, const_iterator __last) + { + erase(iterator(const_cast<_Node*>(__first._M_cur), + const_cast(__first._M_ht)), + iterator(const_cast<_Node*>(__last._M_cur), + const_cast(__last._M_ht))); + } + + template + inline void + hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>:: + erase(const const_iterator& __it) + { erase(iterator(const_cast<_Node*>(__it._M_cur), + const_cast(__it._M_ht))); } + + template + void + hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>:: + resize(size_type __num_elements_hint) + { + const size_type __old_n = _M_buckets.size(); + if (__num_elements_hint > __old_n) + { + const size_type __n = _M_next_size(__num_elements_hint); + if (__n > __old_n) + { + _Vector_type __tmp(__n, (_Node*)(0), _M_buckets.get_allocator()); + __try + { + for (size_type __bucket = 0; __bucket < __old_n; ++__bucket) + { + _Node* __first = _M_buckets[__bucket]; + while (__first) + { + size_type __new_bucket = _M_bkt_num(__first->_M_val, + __n); + _M_buckets[__bucket] = __first->_M_next; + __first->_M_next = __tmp[__new_bucket]; + __tmp[__new_bucket] = __first; + __first = _M_buckets[__bucket]; + } + } + _M_buckets.swap(__tmp); + } + __catch(...) + { + for (size_type __bucket = 0; __bucket < __tmp.size(); + ++__bucket) + { + while (__tmp[__bucket]) + { + _Node* __next = __tmp[__bucket]->_M_next; + _M_delete_node(__tmp[__bucket]); + __tmp[__bucket] = __next; + } + } + __throw_exception_again; + } + } + } + } + + template + void + hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>:: + _M_erase_bucket(const size_type __n, _Node* __first, _Node* __last) + { + _Node* __cur = _M_buckets[__n]; + if (__cur == __first) + _M_erase_bucket(__n, __last); + else + { + _Node* __next; + for (__next = __cur->_M_next; + __next != __first; + __cur = __next, __next = __cur->_M_next) + ; + while (__next != __last) + { + __cur->_M_next = __next->_M_next; + _M_delete_node(__next); + __next = __cur->_M_next; + --_M_num_elements; + } + } + } + + template + void + hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>:: + _M_erase_bucket(const size_type __n, _Node* __last) + { + _Node* __cur = _M_buckets[__n]; + while (__cur != __last) + { + _Node* __next = __cur->_M_next; + _M_delete_node(__cur); + __cur = __next; + _M_buckets[__n] = __cur; + --_M_num_elements; + } + } + + template + void + hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>:: + clear() + { + if (_M_num_elements == 0) + return; + + for (size_type __i = 0; __i < _M_buckets.size(); ++__i) + { + _Node* __cur = _M_buckets[__i]; + while (__cur != 0) + { + _Node* __next = __cur->_M_next; + _M_delete_node(__cur); + __cur = __next; + } + _M_buckets[__i] = 0; + } + _M_num_elements = 0; + } + + template + void + hashtable<_Val, _Key, _HF, _Ex, _Eq, _All>:: + _M_copy_from(const hashtable& __ht) + { + _M_buckets.clear(); + _M_buckets.reserve(__ht._M_buckets.size()); + _M_buckets.insert(_M_buckets.end(), __ht._M_buckets.size(), (_Node*) 0); + __try + { + for (size_type __i = 0; __i < __ht._M_buckets.size(); ++__i) { + const _Node* __cur = __ht._M_buckets[__i]; + if (__cur) + { + _Node* __local_copy = _M_new_node(__cur->_M_val); + _M_buckets[__i] = __local_copy; + + for (_Node* __next = __cur->_M_next; + __next; + __cur = __next, __next = __cur->_M_next) + { + __local_copy->_M_next = _M_new_node(__next->_M_val); + __local_copy = __local_copy->_M_next; + } + } + } + _M_num_elements = __ht._M_num_elements; + } + __catch(...) + { + clear(); + __throw_exception_again; + } + } + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/backward/strstream b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/backward/strstream new file mode 100755 index 0000000..6d126a5 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/backward/strstream @@ -0,0 +1,184 @@ +// Backward-compat support -*- C++ -*- + +// Copyright (C) 2001-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/* + * Copyright (c) 1998 + * Silicon Graphics Computer Systems, Inc. + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Silicon Graphics makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + */ + +// WARNING: The classes defined in this header are DEPRECATED. This +// header is defined in section D.7.1 of the C++ standard, and it +// MAY BE REMOVED in a future standard revision. One should use the +// header instead. + +/** @file backward/strstream + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{sstream} + */ + +#ifndef _BACKWARD_STRSTREAM +#define _BACKWARD_STRSTREAM + +#include "backward_warning.h" +#include +#include +#include +#include +#include + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + // Class strstreambuf, a streambuf class that manages an array of char. + // Note that this class is not a template. + class strstreambuf : public basic_streambuf > + { + public: + // Types. + typedef char_traits _Traits; + typedef basic_streambuf _Base; + + public: + // Constructor, destructor + explicit strstreambuf(streamsize __initial_capacity = 0); + strstreambuf(void* (*__alloc)(size_t), void (*__free)(void*)); + + strstreambuf(char* __get, streamsize __n, char* __put = 0) throw (); + strstreambuf(signed char* __get, streamsize __n, signed char* __put = 0) throw (); + strstreambuf(unsigned char* __get, streamsize __n, unsigned char* __put=0) throw (); + + strstreambuf(const char* __get, streamsize __n) throw (); + strstreambuf(const signed char* __get, streamsize __n) throw (); + strstreambuf(const unsigned char* __get, streamsize __n) throw (); + + virtual ~strstreambuf(); + + public: + void freeze(bool = true) throw (); + char* str() throw (); + _GLIBCXX_PURE int pcount() const throw (); + + protected: + virtual int_type overflow(int_type __c = _Traits::eof()); + virtual int_type pbackfail(int_type __c = _Traits::eof()); + virtual int_type underflow(); + virtual _Base* setbuf(char* __buf, streamsize __n); + virtual pos_type seekoff(off_type __off, ios_base::seekdir __dir, + ios_base::openmode __mode + = ios_base::in | ios_base::out); + virtual pos_type seekpos(pos_type __pos, ios_base::openmode __mode + = ios_base::in | ios_base::out); + + private: + strstreambuf& + operator=(const strstreambuf&); + + strstreambuf(const strstreambuf&); + + // Dynamic allocation, possibly using _M_alloc_fun and _M_free_fun. + char* _M_alloc(size_t); + void _M_free(char*); + + // Helper function used in constructors. + void _M_setup(char* __get, char* __put, streamsize __n) throw (); + + private: + // Data members. + void* (*_M_alloc_fun)(size_t); + void (*_M_free_fun)(void*); + + bool _M_dynamic : 1; + bool _M_frozen : 1; + bool _M_constant : 1; + }; + + // Class istrstream, an istream that manages a strstreambuf. + class istrstream : public basic_istream + { + public: + explicit istrstream(char*); + explicit istrstream(const char*); + istrstream(char* , streamsize); + istrstream(const char*, streamsize); + virtual ~istrstream(); + + _GLIBCXX_CONST strstreambuf* rdbuf() const throw (); + char* str() throw (); + + private: + strstreambuf _M_buf; + }; + + // Class ostrstream + class ostrstream : public basic_ostream + { + public: + ostrstream(); + ostrstream(char*, int, ios_base::openmode = ios_base::out); + virtual ~ostrstream(); + + _GLIBCXX_CONST strstreambuf* rdbuf() const throw (); + void freeze(bool = true) throw(); + char* str() throw (); + _GLIBCXX_PURE int pcount() const throw (); + + private: + strstreambuf _M_buf; + }; + + // Class strstream + class strstream : public basic_iostream + { + public: + typedef char char_type; + typedef char_traits::int_type int_type; + typedef char_traits::pos_type pos_type; + typedef char_traits::off_type off_type; + + strstream(); + strstream(char*, int, ios_base::openmode = ios_base::in | ios_base::out); + virtual ~strstream(); + + _GLIBCXX_CONST strstreambuf* rdbuf() const throw (); + void freeze(bool = true) throw (); + _GLIBCXX_PURE int pcount() const throw (); + char* str() throw (); + + private: + strstreambuf _M_buf; + }; + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/algorithmfwd.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/algorithmfwd.h new file mode 100755 index 0000000..aee1eec --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/algorithmfwd.h @@ -0,0 +1,826 @@ +// Forward declarations -*- C++ -*- + +// Copyright (C) 2007-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file bits/algorithmfwd.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{algorithm} + */ + +#ifndef _GLIBCXX_ALGORITHMFWD_H +#define _GLIBCXX_ALGORITHMFWD_H 1 + +#pragma GCC system_header + +#include +#include +#include +#if __cplusplus >= 201103L +#include +#endif + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /* + adjacent_find + all_of (C++0x) + any_of (C++0x) + binary_search + copy + copy_backward + copy_if (C++0x) + copy_n (C++0x) + count + count_if + equal + equal_range + fill + fill_n + find + find_end + find_first_of + find_if + find_if_not (C++0x) + for_each + generate + generate_n + includes + inplace_merge + is_heap (C++0x) + is_heap_until (C++0x) + is_partitioned (C++0x) + is_sorted (C++0x) + is_sorted_until (C++0x) + iter_swap + lexicographical_compare + lower_bound + make_heap + max + max_element + merge + min + min_element + minmax (C++0x) + minmax_element (C++0x) + mismatch + next_permutation + none_of (C++0x) + nth_element + partial_sort + partial_sort_copy + partition + partition_copy (C++0x) + partition_point (C++0x) + pop_heap + prev_permutation + push_heap + random_shuffle + remove + remove_copy + remove_copy_if + remove_if + replace + replace_copy + replace_copy_if + replace_if + reverse + reverse_copy + rotate + rotate_copy + search + search_n + set_difference + set_intersection + set_symmetric_difference + set_union + shuffle (C++0x) + sort + sort_heap + stable_partition + stable_sort + swap + swap_ranges + transform + unique + unique_copy + upper_bound + */ + + /** + * @defgroup algorithms Algorithms + * + * Components for performing algorithmic operations. Includes + * non-modifying sequence, modifying (mutating) sequence, sorting, + * searching, merge, partition, heap, set, minima, maxima, and + * permutation operations. + */ + + /** + * @defgroup mutating_algorithms Mutating + * @ingroup algorithms + */ + + /** + * @defgroup non_mutating_algorithms Non-Mutating + * @ingroup algorithms + */ + + /** + * @defgroup sorting_algorithms Sorting + * @ingroup algorithms + */ + + /** + * @defgroup set_algorithms Set Operation + * @ingroup sorting_algorithms + * + * These algorithms are common set operations performed on sequences + * that are already sorted. The number of comparisons will be + * linear. + */ + + /** + * @defgroup binary_search_algorithms Binary Search + * @ingroup sorting_algorithms + * + * These algorithms are variations of a classic binary search, and + * all assume that the sequence being searched is already sorted. + * + * The number of comparisons will be logarithmic (and as few as + * possible). The number of steps through the sequence will be + * logarithmic for random-access iterators (e.g., pointers), and + * linear otherwise. + * + * The LWG has passed Defect Report 270, which notes: The + * proposed resolution reinterprets binary search. Instead of + * thinking about searching for a value in a sorted range, we view + * that as an important special case of a more general algorithm: + * searching for the partition point in a partitioned range. We + * also add a guarantee that the old wording did not: we ensure that + * the upper bound is no earlier than the lower bound, that the pair + * returned by equal_range is a valid range, and that the first part + * of that pair is the lower bound. + * + * The actual effect of the first sentence is that a comparison + * functor passed by the user doesn't necessarily need to induce a + * strict weak ordering relation. Rather, it partitions the range. + */ + + // adjacent_find + +#if __cplusplus >= 201103L + template + bool + all_of(_IIter, _IIter, _Predicate); + + template + bool + any_of(_IIter, _IIter, _Predicate); +#endif + + template + bool + binary_search(_FIter, _FIter, const _Tp&); + + template + bool + binary_search(_FIter, _FIter, const _Tp&, _Compare); + + template + _OIter + copy(_IIter, _IIter, _OIter); + + template + _BIter2 + copy_backward(_BIter1, _BIter1, _BIter2); + +#if __cplusplus >= 201103L + template + _OIter + copy_if(_IIter, _IIter, _OIter, _Predicate); + + template + _OIter + copy_n(_IIter, _Size, _OIter); +#endif + + // count + // count_if + + template + pair<_FIter, _FIter> + equal_range(_FIter, _FIter, const _Tp&); + + template + pair<_FIter, _FIter> + equal_range(_FIter, _FIter, const _Tp&, _Compare); + + template + void + fill(_FIter, _FIter, const _Tp&); + + template + _OIter + fill_n(_OIter, _Size, const _Tp&); + + // find + + template + _FIter1 + find_end(_FIter1, _FIter1, _FIter2, _FIter2); + + template + _FIter1 + find_end(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate); + + // find_first_of + // find_if + +#if __cplusplus >= 201103L + template + _IIter + find_if_not(_IIter, _IIter, _Predicate); +#endif + + // for_each + // generate + // generate_n + + template + bool + includes(_IIter1, _IIter1, _IIter2, _IIter2); + + template + bool + includes(_IIter1, _IIter1, _IIter2, _IIter2, _Compare); + + template + void + inplace_merge(_BIter, _BIter, _BIter); + + template + void + inplace_merge(_BIter, _BIter, _BIter, _Compare); + +#if __cplusplus >= 201103L + template + bool + is_heap(_RAIter, _RAIter); + + template + bool + is_heap(_RAIter, _RAIter, _Compare); + + template + _RAIter + is_heap_until(_RAIter, _RAIter); + + template + _RAIter + is_heap_until(_RAIter, _RAIter, _Compare); + + template + bool + is_partitioned(_IIter, _IIter, _Predicate); + + template + bool + is_permutation(_FIter1, _FIter1, _FIter2); + + template + bool + is_permutation(_FIter1, _FIter1, _FIter2, _BinaryPredicate); + + template + bool + is_sorted(_FIter, _FIter); + + template + bool + is_sorted(_FIter, _FIter, _Compare); + + template + _FIter + is_sorted_until(_FIter, _FIter); + + template + _FIter + is_sorted_until(_FIter, _FIter, _Compare); +#endif + + template + void + iter_swap(_FIter1, _FIter2); + + template + _FIter + lower_bound(_FIter, _FIter, const _Tp&); + + template + _FIter + lower_bound(_FIter, _FIter, const _Tp&, _Compare); + + template + void + make_heap(_RAIter, _RAIter); + + template + void + make_heap(_RAIter, _RAIter, _Compare); + + template + const _Tp& + max(const _Tp&, const _Tp&); + + template + const _Tp& + max(const _Tp&, const _Tp&, _Compare); + + // max_element + // merge + + template + const _Tp& + min(const _Tp&, const _Tp&); + + template + const _Tp& + min(const _Tp&, const _Tp&, _Compare); + + // min_element + +#if __cplusplus >= 201103L + template + pair + minmax(const _Tp&, const _Tp&); + + template + pair + minmax(const _Tp&, const _Tp&, _Compare); + + template + pair<_FIter, _FIter> + minmax_element(_FIter, _FIter); + + template + pair<_FIter, _FIter> + minmax_element(_FIter, _FIter, _Compare); + + template + _Tp + min(initializer_list<_Tp>); + + template + _Tp + min(initializer_list<_Tp>, _Compare); + + template + _Tp + max(initializer_list<_Tp>); + + template + _Tp + max(initializer_list<_Tp>, _Compare); + + template + pair<_Tp, _Tp> + minmax(initializer_list<_Tp>); + + template + pair<_Tp, _Tp> + minmax(initializer_list<_Tp>, _Compare); +#endif + + // mismatch + + template + bool + next_permutation(_BIter, _BIter); + + template + bool + next_permutation(_BIter, _BIter, _Compare); + +#if __cplusplus >= 201103L + template + bool + none_of(_IIter, _IIter, _Predicate); +#endif + + // nth_element + // partial_sort + + template + _RAIter + partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter); + + template + _RAIter + partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter, _Compare); + + // partition + +#if __cplusplus >= 201103L + template + pair<_OIter1, _OIter2> + partition_copy(_IIter, _IIter, _OIter1, _OIter2, _Predicate); + + template + _FIter + partition_point(_FIter, _FIter, _Predicate); +#endif + + template + void + pop_heap(_RAIter, _RAIter); + + template + void + pop_heap(_RAIter, _RAIter, _Compare); + + template + bool + prev_permutation(_BIter, _BIter); + + template + bool + prev_permutation(_BIter, _BIter, _Compare); + + template + void + push_heap(_RAIter, _RAIter); + + template + void + push_heap(_RAIter, _RAIter, _Compare); + + // random_shuffle + + template + _FIter + remove(_FIter, _FIter, const _Tp&); + + template + _FIter + remove_if(_FIter, _FIter, _Predicate); + + template + _OIter + remove_copy(_IIter, _IIter, _OIter, const _Tp&); + + template + _OIter + remove_copy_if(_IIter, _IIter, _OIter, _Predicate); + + // replace + + template + _OIter + replace_copy(_IIter, _IIter, _OIter, const _Tp&, const _Tp&); + + template + _OIter + replace_copy_if(_Iter, _Iter, _OIter, _Predicate, const _Tp&); + + // replace_if + + template + void + reverse(_BIter, _BIter); + + template + _OIter + reverse_copy(_BIter, _BIter, _OIter); + + template + void + rotate(_FIter, _FIter, _FIter); + + template + _OIter + rotate_copy(_FIter, _FIter, _FIter, _OIter); + + // search + // search_n + // set_difference + // set_intersection + // set_symmetric_difference + // set_union + +#if (__cplusplus >= 201103L) && defined(_GLIBCXX_USE_C99_STDINT_TR1) + template + void + shuffle(_RAIter, _RAIter, _UGenerator&&); +#endif + + template + void + sort_heap(_RAIter, _RAIter); + + template + void + sort_heap(_RAIter, _RAIter, _Compare); + + template + _BIter + stable_partition(_BIter, _BIter, _Predicate); + + template + void + swap(_Tp&, _Tp&) +#if __cplusplus >= 201103L + noexcept(__and_, + is_nothrow_move_assignable<_Tp>>::value) +#endif + ; + + template + void + swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm]) +#if __cplusplus >= 201103L + noexcept(noexcept(swap(*__a, *__b))) +#endif + ; + + template + _FIter2 + swap_ranges(_FIter1, _FIter1, _FIter2); + + // transform + + template + _FIter + unique(_FIter, _FIter); + + template + _FIter + unique(_FIter, _FIter, _BinaryPredicate); + + // unique_copy + + template + _FIter + upper_bound(_FIter, _FIter, const _Tp&); + + template + _FIter + upper_bound(_FIter, _FIter, const _Tp&, _Compare); + +_GLIBCXX_END_NAMESPACE_VERSION + +_GLIBCXX_BEGIN_NAMESPACE_ALGO + + template + _FIter + adjacent_find(_FIter, _FIter); + + template + _FIter + adjacent_find(_FIter, _FIter, _BinaryPredicate); + + template + typename iterator_traits<_IIter>::difference_type + count(_IIter, _IIter, const _Tp&); + + template + typename iterator_traits<_IIter>::difference_type + count_if(_IIter, _IIter, _Predicate); + + template + bool + equal(_IIter1, _IIter1, _IIter2); + + template + bool + equal(_IIter1, _IIter1, _IIter2, _BinaryPredicate); + + template + _IIter + find(_IIter, _IIter, const _Tp&); + + template + _FIter1 + find_first_of(_FIter1, _FIter1, _FIter2, _FIter2); + + template + _FIter1 + find_first_of(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate); + + template + _IIter + find_if(_IIter, _IIter, _Predicate); + + template + _Funct + for_each(_IIter, _IIter, _Funct); + + template + void + generate(_FIter, _FIter, _Generator); + + template + _OIter + generate_n(_OIter, _Size, _Generator); + + template + bool + lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2); + + template + bool + lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, _Compare); + + template + _FIter + max_element(_FIter, _FIter); + + template + _FIter + max_element(_FIter, _FIter, _Compare); + + template + _OIter + merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); + + template + _OIter + merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare); + + template + _FIter + min_element(_FIter, _FIter); + + template + _FIter + min_element(_FIter, _FIter, _Compare); + + template + pair<_IIter1, _IIter2> + mismatch(_IIter1, _IIter1, _IIter2); + + template + pair<_IIter1, _IIter2> + mismatch(_IIter1, _IIter1, _IIter2, _BinaryPredicate); + + template + void + nth_element(_RAIter, _RAIter, _RAIter); + + template + void + nth_element(_RAIter, _RAIter, _RAIter, _Compare); + + template + void + partial_sort(_RAIter, _RAIter, _RAIter); + + template + void + partial_sort(_RAIter, _RAIter, _RAIter, _Compare); + + template + _BIter + partition(_BIter, _BIter, _Predicate); + + template + void + random_shuffle(_RAIter, _RAIter); + + template + void + random_shuffle(_RAIter, _RAIter, +#if __cplusplus >= 201103L + _Generator&&); +#else + _Generator&); +#endif + + template + void + replace(_FIter, _FIter, const _Tp&, const _Tp&); + + template + void + replace_if(_FIter, _FIter, _Predicate, const _Tp&); + + template + _FIter1 + search(_FIter1, _FIter1, _FIter2, _FIter2); + + template + _FIter1 + search(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate); + + template + _FIter + search_n(_FIter, _FIter, _Size, const _Tp&); + + template + _FIter + search_n(_FIter, _FIter, _Size, const _Tp&, _BinaryPredicate); + + template + _OIter + set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); + + template + _OIter + set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare); + + template + _OIter + set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); + + template + _OIter + set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare); + + template + _OIter + set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); + + template + _OIter + set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, + _OIter, _Compare); + + template + _OIter + set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); + + template + _OIter + set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare); + + template + void + sort(_RAIter, _RAIter); + + template + void + sort(_RAIter, _RAIter, _Compare); + + template + void + stable_sort(_RAIter, _RAIter); + + template + void + stable_sort(_RAIter, _RAIter, _Compare); + + template + _OIter + transform(_IIter, _IIter, _OIter, _UnaryOperation); + + template + _OIter + transform(_IIter1, _IIter1, _IIter2, _OIter, _BinaryOperation); + + template + _OIter + unique_copy(_IIter, _IIter, _OIter); + + template + _OIter + unique_copy(_IIter, _IIter, _OIter, _BinaryPredicate); + +_GLIBCXX_END_NAMESPACE_ALGO +} // namespace std + +#ifdef _GLIBCXX_PARALLEL +# include +#endif + +#endif + diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/alloc_traits.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/alloc_traits.h new file mode 100755 index 0000000..23fe8de --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/alloc_traits.h @@ -0,0 +1,533 @@ +// Allocator traits -*- C++ -*- + +// Copyright (C) 2011-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file bits/alloc_traits.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{memory} + */ + +#ifndef _ALLOC_TRAITS_H +#define _ALLOC_TRAITS_H 1 + +#if __cplusplus >= 201103L + +#include +#include +#include + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + template + class __alloctr_rebind_helper + { + template + static constexpr true_type + _S_chk(typename _Alloc2::template rebind<_Tp2>::other*); + + template + static constexpr false_type + _S_chk(...); + + public: + using __type = decltype(_S_chk<_Alloc, _Tp>(nullptr)); + }; + + template::__type::value> + struct __alloctr_rebind; + + template + struct __alloctr_rebind<_Alloc, _Tp, true> + { + typedef typename _Alloc::template rebind<_Tp>::other __type; + }; + + template class _Alloc, typename _Tp, + typename _Up, typename... _Args> + struct __alloctr_rebind<_Alloc<_Up, _Args...>, _Tp, false> + { + typedef _Alloc<_Tp, _Args...> __type; + }; + + /** + * @brief Uniform interface to all allocator types. + * @ingroup allocators + */ + template + struct allocator_traits + { + /// The allocator type + typedef _Alloc allocator_type; + /// The allocated type + typedef typename _Alloc::value_type value_type; + +#define _GLIBCXX_ALLOC_TR_NESTED_TYPE(_NTYPE, _ALT) \ + private: \ + template \ + static typename _Tp::_NTYPE _S_##_NTYPE##_helper(_Tp*); \ + static _ALT _S_##_NTYPE##_helper(...); \ + typedef decltype(_S_##_NTYPE##_helper((_Alloc*)0)) __##_NTYPE; \ + public: + +_GLIBCXX_ALLOC_TR_NESTED_TYPE(pointer, value_type*) + + /** + * @brief The allocator's pointer type. + * + * @c Alloc::pointer if that type exists, otherwise @c value_type* + */ + typedef __pointer pointer; + +_GLIBCXX_ALLOC_TR_NESTED_TYPE(const_pointer, + typename pointer_traits::template rebind) + + /** + * @brief The allocator's const pointer type. + * + * @c Alloc::const_pointer if that type exists, otherwise + * pointer_traits::rebind + */ + typedef __const_pointer const_pointer; + +_GLIBCXX_ALLOC_TR_NESTED_TYPE(void_pointer, + typename pointer_traits::template rebind) + + /** + * @brief The allocator's void pointer type. + * + * @c Alloc::void_pointer if that type exists, otherwise + * pointer_traits::rebind + */ + typedef __void_pointer void_pointer; + +_GLIBCXX_ALLOC_TR_NESTED_TYPE(const_void_pointer, + typename pointer_traits::template rebind) + + /** + * @brief The allocator's const void pointer type. + * + * @c Alloc::const_void_pointer if that type exists, otherwise + * pointer_traits::rebind + */ + typedef __const_void_pointer const_void_pointer; + +_GLIBCXX_ALLOC_TR_NESTED_TYPE(difference_type, + typename pointer_traits::difference_type) + + /** + * @brief The allocator's difference type + * + * @c Alloc::difference_type if that type exists, otherwise + * pointer_traits::difference_type + */ + typedef __difference_type difference_type; + +_GLIBCXX_ALLOC_TR_NESTED_TYPE(size_type, + typename make_unsigned::type) + + /** + * @brief The allocator's size type + * + * @c Alloc::size_type if that type exists, otherwise + * make_unsigned::type + */ + typedef __size_type size_type; + +_GLIBCXX_ALLOC_TR_NESTED_TYPE(propagate_on_container_copy_assignment, + false_type) + + /** + * @brief How the allocator is propagated on copy assignment + * + * @c Alloc::propagate_on_container_copy_assignment if that type exists, + * otherwise @c false_type + */ + typedef __propagate_on_container_copy_assignment + propagate_on_container_copy_assignment; + +_GLIBCXX_ALLOC_TR_NESTED_TYPE(propagate_on_container_move_assignment, + false_type) + + /** + * @brief How the allocator is propagated on move assignment + * + * @c Alloc::propagate_on_container_move_assignment if that type exists, + * otherwise @c false_type + */ + typedef __propagate_on_container_move_assignment + propagate_on_container_move_assignment; + +_GLIBCXX_ALLOC_TR_NESTED_TYPE(propagate_on_container_swap, + false_type) + + /** + * @brief How the allocator is propagated on swap + * + * @c Alloc::propagate_on_container_swap if that type exists, + * otherwise @c false_type + */ + typedef __propagate_on_container_swap propagate_on_container_swap; + +#undef _GLIBCXX_ALLOC_TR_NESTED_TYPE + + template + using rebind_alloc = typename __alloctr_rebind<_Alloc, _Tp>::__type; + template + using rebind_traits = allocator_traits>; + + private: + template + struct __allocate_helper + { + template()->allocate( + std::declval(), + std::declval()))> + static true_type __test(int); + + template + static false_type __test(...); + + using type = decltype(__test<_Alloc>(0)); + }; + + template + using __has_allocate = typename __allocate_helper<_Alloc2>::type; + + template>> + static pointer + _S_allocate(_Alloc2& __a, size_type __n, const_void_pointer __hint) + { return __a.allocate(__n, __hint); } + + template>>> + static pointer + _S_allocate(_Alloc2& __a, size_type __n, _UnusedHint) + { return __a.allocate(__n); } + + template + struct __construct_helper + { + template()->construct( + std::declval<_Tp*>(), std::declval<_Args>()...))> + static true_type __test(int); + + template + static false_type __test(...); + + using type = decltype(__test<_Alloc>(0)); + }; + + template + using __has_construct + = typename __construct_helper<_Tp, _Args...>::type; + + template + static _Require<__has_construct<_Tp, _Args...>> + _S_construct(_Alloc& __a, _Tp* __p, _Args&&... __args) + { __a.construct(__p, std::forward<_Args>(__args)...); } + + template + static + _Require<__and_<__not_<__has_construct<_Tp, _Args...>>, + is_constructible<_Tp, _Args...>>> + _S_construct(_Alloc&, _Tp* __p, _Args&&... __args) + { ::new((void*)__p) _Tp(std::forward<_Args>(__args)...); } + + template + struct __destroy_helper + { + template()->destroy( + std::declval<_Tp*>()))> + static true_type __test(int); + + template + static false_type __test(...); + + using type = decltype(__test<_Alloc>(0)); + }; + + template + using __has_destroy = typename __destroy_helper<_Tp>::type; + + template + static _Require<__has_destroy<_Tp>> + _S_destroy(_Alloc& __a, _Tp* __p) + { __a.destroy(__p); } + + template + static _Require<__not_<__has_destroy<_Tp>>> + _S_destroy(_Alloc&, _Tp* __p) + { __p->~_Tp(); } + + template + struct __maxsize_helper + { + template()->max_size())> + static true_type __test(int); + + template + static false_type __test(...); + + using type = decltype(__test<_Alloc2>(0)); + }; + + template + using __has_max_size = typename __maxsize_helper<_Alloc2>::type; + + template>> + static size_type + _S_max_size(_Alloc2& __a, int) + { return __a.max_size(); } + + template>>> + static size_type + _S_max_size(_Alloc2&, ...) + { return __gnu_cxx::__numeric_traits::__max; } + + template + struct __select_helper + { + template() + ->select_on_container_copy_construction())> + static true_type __test(int); + + template + static false_type __test(...); + + using type = decltype(__test<_Alloc2>(0)); + }; + + template + using __has_soccc = typename __select_helper<_Alloc2>::type; + + template>> + static _Alloc2 + _S_select(_Alloc2& __a, int) + { return __a.select_on_container_copy_construction(); } + + template>>> + static _Alloc2 + _S_select(_Alloc2& __a, ...) + { return __a; } + + public: + + /** + * @brief Allocate memory. + * @param __a An allocator. + * @param __n The number of objects to allocate space for. + * + * Calls @c a.allocate(n) + */ + static pointer + allocate(_Alloc& __a, size_type __n) + { return __a.allocate(__n); } + + /** + * @brief Allocate memory. + * @param __a An allocator. + * @param __n The number of objects to allocate space for. + * @param __hint Aid to locality. + * @return Memory of suitable size and alignment for @a n objects + * of type @c value_type + * + * Returns a.allocate(n, hint) if that expression is + * well-formed, otherwise returns @c a.allocate(n) + */ + static pointer + allocate(_Alloc& __a, size_type __n, const_void_pointer __hint) + { return _S_allocate(__a, __n, __hint); } + + /** + * @brief Deallocate memory. + * @param __a An allocator. + * @param __p Pointer to the memory to deallocate. + * @param __n The number of objects space was allocated for. + * + * Calls a.deallocate(p, n) + */ + static void deallocate(_Alloc& __a, pointer __p, size_type __n) + { __a.deallocate(__p, __n); } + + /** + * @brief Construct an object of type @a _Tp + * @param __a An allocator. + * @param __p Pointer to memory of suitable size and alignment for Tp + * @param __args Constructor arguments. + * + * Calls __a.construct(__p, std::forward(__args)...) + * if that expression is well-formed, otherwise uses placement-new + * to construct an object of type @a _Tp at location @a __p from the + * arguments @a __args... + */ + template + static auto construct(_Alloc& __a, _Tp* __p, _Args&&... __args) + -> decltype(_S_construct(__a, __p, std::forward<_Args>(__args)...)) + { _S_construct(__a, __p, std::forward<_Args>(__args)...); } + + /** + * @brief Destroy an object of type @a _Tp + * @param __a An allocator. + * @param __p Pointer to the object to destroy + * + * Calls @c __a.destroy(__p) if that expression is well-formed, + * otherwise calls @c __p->~_Tp() + */ + template + static void destroy(_Alloc& __a, _Tp* __p) + { _S_destroy(__a, __p); } + + /** + * @brief The maximum supported allocation size + * @param __a An allocator. + * @return @c __a.max_size() or @c numeric_limits::max() + * + * Returns @c __a.max_size() if that expression is well-formed, + * otherwise returns @c numeric_limits::max() + */ + static size_type max_size(const _Alloc& __a) noexcept + { return _S_max_size(__a, 0); } + + /** + * @brief Obtain an allocator to use when copying a container. + * @param __rhs An allocator. + * @return @c __rhs.select_on_container_copy_construction() or @a __rhs + * + * Returns @c __rhs.select_on_container_copy_construction() if that + * expression is well-formed, otherwise returns @a __rhs + */ + static _Alloc + select_on_container_copy_construction(const _Alloc& __rhs) + { return _S_select(__rhs, 0); } + }; + + template + inline void + __do_alloc_on_copy(_Alloc& __one, const _Alloc& __two, true_type) + { __one = __two; } + + template + inline void + __do_alloc_on_copy(_Alloc&, const _Alloc&, false_type) + { } + + template + inline void __alloc_on_copy(_Alloc& __one, const _Alloc& __two) + { + typedef allocator_traits<_Alloc> __traits; + typedef typename __traits::propagate_on_container_copy_assignment __pocca; + __do_alloc_on_copy(__one, __two, __pocca()); + } + + template + inline _Alloc __alloc_on_copy(const _Alloc& __a) + { + typedef allocator_traits<_Alloc> __traits; + return __traits::select_on_container_copy_construction(__a); + } + + template + inline void __do_alloc_on_move(_Alloc& __one, _Alloc& __two, true_type) + { __one = std::move(__two); } + + template + inline void __do_alloc_on_move(_Alloc&, _Alloc&, false_type) + { } + + template + inline void __alloc_on_move(_Alloc& __one, _Alloc& __two) + { + typedef allocator_traits<_Alloc> __traits; + typedef typename __traits::propagate_on_container_move_assignment __pocma; + __do_alloc_on_move(__one, __two, __pocma()); + } + + template + inline void __do_alloc_on_swap(_Alloc& __one, _Alloc& __two, true_type) + { + using std::swap; + swap(__one, __two); + } + + template + inline void __do_alloc_on_swap(_Alloc&, _Alloc&, false_type) + { } + + template + inline void __alloc_on_swap(_Alloc& __one, _Alloc& __two) + { + typedef allocator_traits<_Alloc> __traits; + typedef typename __traits::propagate_on_container_swap __pocs; + __do_alloc_on_swap(__one, __two, __pocs()); + } + + template + class __is_copy_insertable_impl + { + typedef allocator_traits<_Alloc> _Traits; + + template(), + std::declval<_Up*>(), + std::declval()))> + static true_type + _M_select(int); + + template + static false_type + _M_select(...); + + public: + typedef decltype(_M_select(0)) type; + }; + + // true if _Alloc::value_type is CopyInsertable into containers using _Alloc + template + struct __is_copy_insertable + : __is_copy_insertable_impl<_Alloc>::type + { }; + + // std::allocator<_Tp> just requires CopyConstructible + template + struct __is_copy_insertable> + : is_copy_constructible<_Tp> + { }; + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace std + +#endif +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/allocator.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/allocator.h new file mode 100755 index 0000000..e293c54 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/allocator.h @@ -0,0 +1,221 @@ +// Allocators -*- C++ -*- + +// Copyright (C) 2001-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/* + * Copyright (c) 1996-1997 + * Silicon Graphics Computer Systems, Inc. + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Silicon Graphics makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + */ + +/** @file bits/allocator.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{memory} + */ + +#ifndef _ALLOCATOR_H +#define _ALLOCATOR_H 1 + +#include // Define the base class to std::allocator. +#include +#if __cplusplus >= 201103L +#include +#endif + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /** + * @addtogroup allocators + * @{ + */ + + /// allocator specialization. + template<> + class allocator + { + public: + typedef size_t size_type; + typedef ptrdiff_t difference_type; + typedef void* pointer; + typedef const void* const_pointer; + typedef void value_type; + + template + struct rebind + { typedef allocator<_Tp1> other; }; + +#if __cplusplus >= 201103L + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 2103. std::allocator propagate_on_container_move_assignment + typedef true_type propagate_on_container_move_assignment; +#endif + }; + + /** + * @brief The @a standard allocator, as per [20.4]. + * + * See http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt04ch11.html + * for further details. + * + * @tparam _Tp Type of allocated object. + */ + template + class allocator: public __allocator_base<_Tp> + { + public: + typedef size_t size_type; + typedef ptrdiff_t difference_type; + typedef _Tp* pointer; + typedef const _Tp* const_pointer; + typedef _Tp& reference; + typedef const _Tp& const_reference; + typedef _Tp value_type; + + template + struct rebind + { typedef allocator<_Tp1> other; }; + +#if __cplusplus >= 201103L + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 2103. std::allocator propagate_on_container_move_assignment + typedef true_type propagate_on_container_move_assignment; +#endif + + allocator() throw() { } + + allocator(const allocator& __a) throw() + : __allocator_base<_Tp>(__a) { } + + template + allocator(const allocator<_Tp1>&) throw() { } + + ~allocator() throw() { } + + // Inherit everything else. + }; + + template + inline bool + operator==(const allocator<_T1>&, const allocator<_T2>&) + { return true; } + + template + inline bool + operator==(const allocator<_Tp>&, const allocator<_Tp>&) + { return true; } + + template + inline bool + operator!=(const allocator<_T1>&, const allocator<_T2>&) + { return false; } + + template + inline bool + operator!=(const allocator<_Tp>&, const allocator<_Tp>&) + { return false; } + + /// @} group allocator + + // Inhibit implicit instantiations for required instantiations, + // which are defined via explicit instantiations elsewhere. +#if _GLIBCXX_EXTERN_TEMPLATE + extern template class allocator; + extern template class allocator; +#endif + + // Undefine. +#undef __allocator_base + + // To implement Option 3 of DR 431. + template + struct __alloc_swap + { static void _S_do_it(_Alloc&, _Alloc&) _GLIBCXX_NOEXCEPT { } }; + + template + struct __alloc_swap<_Alloc, false> + { + static void + _S_do_it(_Alloc& __one, _Alloc& __two) _GLIBCXX_NOEXCEPT + { + // Precondition: swappable allocators. + if (__one != __two) + swap(__one, __two); + } + }; + + // Optimize for stateless allocators. + template + struct __alloc_neq + { + static bool + _S_do_it(const _Alloc&, const _Alloc&) + { return false; } + }; + + template + struct __alloc_neq<_Alloc, false> + { + static bool + _S_do_it(const _Alloc& __one, const _Alloc& __two) + { return __one != __two; } + }; + +#if __cplusplus >= 201103L + template, + is_nothrow_move_constructible>::value> + struct __shrink_to_fit_aux + { static bool _S_do_it(_Tp&) noexcept { return false; } }; + + template + struct __shrink_to_fit_aux<_Tp, true> + { + static bool + _S_do_it(_Tp& __c) noexcept + { + __try + { + _Tp(__make_move_if_noexcept_iterator(__c.begin()), + __make_move_if_noexcept_iterator(__c.end()), + __c.get_allocator()).swap(__c); + return true; + } + __catch(...) + { return false; } + } + }; +#endif + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace std + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/atomic_base.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/atomic_base.h new file mode 100755 index 0000000..1fc0ebb --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/atomic_base.h @@ -0,0 +1,892 @@ +// -*- C++ -*- header. + +// Copyright (C) 2008-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file bits/atomic_base.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{atomic} + */ + +#ifndef _GLIBCXX_ATOMIC_BASE_H +#define _GLIBCXX_ATOMIC_BASE_H 1 + +#pragma GCC system_header + +#include +#include +#include +#include + +#ifndef _GLIBCXX_ALWAYS_INLINE +#define _GLIBCXX_ALWAYS_INLINE inline __attribute__((always_inline)) +#endif + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /** + * @defgroup atomics Atomics + * + * Components for performing atomic operations. + * @{ + */ + + /// Enumeration for memory_order + typedef enum memory_order + { + memory_order_relaxed, + memory_order_consume, + memory_order_acquire, + memory_order_release, + memory_order_acq_rel, + memory_order_seq_cst + } memory_order; + + enum __memory_order_modifier + { + __memory_order_mask = 0x0ffff, + __memory_order_modifier_mask = 0xffff0000, + __memory_order_hle_acquire = 0x10000, + __memory_order_hle_release = 0x20000 + }; + + constexpr memory_order + operator|(memory_order __m, __memory_order_modifier __mod) + { + return memory_order(__m | int(__mod)); + } + + constexpr memory_order + operator&(memory_order __m, __memory_order_modifier __mod) + { + return memory_order(__m & int(__mod)); + } + + // Drop release ordering as per [atomics.types.operations.req]/21 + constexpr memory_order + __cmpexch_failure_order2(memory_order __m) noexcept + { + return __m == memory_order_acq_rel ? memory_order_acquire + : __m == memory_order_release ? memory_order_relaxed : __m; + } + + constexpr memory_order + __cmpexch_failure_order(memory_order __m) noexcept + { + return memory_order(__cmpexch_failure_order2(__m & __memory_order_mask) + | (__m & __memory_order_modifier_mask)); + } + + _GLIBCXX_ALWAYS_INLINE void + atomic_thread_fence(memory_order __m) noexcept + { __atomic_thread_fence(__m); } + + _GLIBCXX_ALWAYS_INLINE void + atomic_signal_fence(memory_order __m) noexcept + { __atomic_signal_fence(__m); } + + /// kill_dependency + template + inline _Tp + kill_dependency(_Tp __y) noexcept + { + _Tp __ret(__y); + return __ret; + } + + + // Base types for atomics. + template + struct __atomic_base; + + /// atomic_char + typedef __atomic_base atomic_char; + + /// atomic_schar + typedef __atomic_base atomic_schar; + + /// atomic_uchar + typedef __atomic_base atomic_uchar; + + /// atomic_short + typedef __atomic_base atomic_short; + + /// atomic_ushort + typedef __atomic_base atomic_ushort; + + /// atomic_int + typedef __atomic_base atomic_int; + + /// atomic_uint + typedef __atomic_base atomic_uint; + + /// atomic_long + typedef __atomic_base atomic_long; + + /// atomic_ulong + typedef __atomic_base atomic_ulong; + + /// atomic_llong + typedef __atomic_base atomic_llong; + + /// atomic_ullong + typedef __atomic_base atomic_ullong; + + /// atomic_wchar_t + typedef __atomic_base atomic_wchar_t; + + /// atomic_char16_t + typedef __atomic_base atomic_char16_t; + + /// atomic_char32_t + typedef __atomic_base atomic_char32_t; + + /// atomic_char32_t + typedef __atomic_base atomic_char32_t; + + + /// atomic_int_least8_t + typedef __atomic_base atomic_int_least8_t; + + /// atomic_uint_least8_t + typedef __atomic_base atomic_uint_least8_t; + + /// atomic_int_least16_t + typedef __atomic_base atomic_int_least16_t; + + /// atomic_uint_least16_t + typedef __atomic_base atomic_uint_least16_t; + + /// atomic_int_least32_t + typedef __atomic_base atomic_int_least32_t; + + /// atomic_uint_least32_t + typedef __atomic_base atomic_uint_least32_t; + + /// atomic_int_least64_t + typedef __atomic_base atomic_int_least64_t; + + /// atomic_uint_least64_t + typedef __atomic_base atomic_uint_least64_t; + + + /// atomic_int_fast8_t + typedef __atomic_base atomic_int_fast8_t; + + /// atomic_uint_fast8_t + typedef __atomic_base atomic_uint_fast8_t; + + /// atomic_int_fast16_t + typedef __atomic_base atomic_int_fast16_t; + + /// atomic_uint_fast16_t + typedef __atomic_base atomic_uint_fast16_t; + + /// atomic_int_fast32_t + typedef __atomic_base atomic_int_fast32_t; + + /// atomic_uint_fast32_t + typedef __atomic_base atomic_uint_fast32_t; + + /// atomic_int_fast64_t + typedef __atomic_base atomic_int_fast64_t; + + /// atomic_uint_fast64_t + typedef __atomic_base atomic_uint_fast64_t; + + + /// atomic_intptr_t + typedef __atomic_base atomic_intptr_t; + + /// atomic_uintptr_t + typedef __atomic_base atomic_uintptr_t; + + /// atomic_size_t + typedef __atomic_base atomic_size_t; + + /// atomic_intmax_t + typedef __atomic_base atomic_intmax_t; + + /// atomic_uintmax_t + typedef __atomic_base atomic_uintmax_t; + + /// atomic_ptrdiff_t + typedef __atomic_base atomic_ptrdiff_t; + + +#define ATOMIC_VAR_INIT(_VI) { _VI } + + template + struct atomic; + + template + struct atomic<_Tp*>; + + /* The target's "set" value for test-and-set may not be exactly 1. */ +#if __GCC_ATOMIC_TEST_AND_SET_TRUEVAL == 1 + typedef bool __atomic_flag_data_type; +#else + typedef unsigned char __atomic_flag_data_type; +#endif + + /** + * @brief Base type for atomic_flag. + * + * Base type is POD with data, allowing atomic_flag to derive from + * it and meet the standard layout type requirement. In addition to + * compatibility with a C interface, this allows different + * implementations of atomic_flag to use the same atomic operation + * functions, via a standard conversion to the __atomic_flag_base + * argument. + */ + _GLIBCXX_BEGIN_EXTERN_C + + struct __atomic_flag_base + { + __atomic_flag_data_type _M_i; + }; + + _GLIBCXX_END_EXTERN_C + +#define ATOMIC_FLAG_INIT { 0 } + + /// atomic_flag + struct atomic_flag : public __atomic_flag_base + { + atomic_flag() noexcept = default; + ~atomic_flag() noexcept = default; + atomic_flag(const atomic_flag&) = delete; + atomic_flag& operator=(const atomic_flag&) = delete; + atomic_flag& operator=(const atomic_flag&) volatile = delete; + + // Conversion to ATOMIC_FLAG_INIT. + constexpr atomic_flag(bool __i) noexcept + : __atomic_flag_base{ _S_init(__i) } + { } + + _GLIBCXX_ALWAYS_INLINE bool + test_and_set(memory_order __m = memory_order_seq_cst) noexcept + { + return __atomic_test_and_set (&_M_i, __m); + } + + _GLIBCXX_ALWAYS_INLINE bool + test_and_set(memory_order __m = memory_order_seq_cst) volatile noexcept + { + return __atomic_test_and_set (&_M_i, __m); + } + + _GLIBCXX_ALWAYS_INLINE void + clear(memory_order __m = memory_order_seq_cst) noexcept + { + memory_order __b = __m & __memory_order_mask; + __glibcxx_assert(__b != memory_order_consume); + __glibcxx_assert(__b != memory_order_acquire); + __glibcxx_assert(__b != memory_order_acq_rel); + + __atomic_clear (&_M_i, __m); + } + + _GLIBCXX_ALWAYS_INLINE void + clear(memory_order __m = memory_order_seq_cst) volatile noexcept + { + memory_order __b = __m & __memory_order_mask; + __glibcxx_assert(__b != memory_order_consume); + __glibcxx_assert(__b != memory_order_acquire); + __glibcxx_assert(__b != memory_order_acq_rel); + + __atomic_clear (&_M_i, __m); + } + + private: + static constexpr __atomic_flag_data_type + _S_init(bool __i) + { return __i ? __GCC_ATOMIC_TEST_AND_SET_TRUEVAL : 0; } + }; + + + /// Base class for atomic integrals. + // + // For each of the integral types, define atomic_[integral type] struct + // + // atomic_bool bool + // atomic_char char + // atomic_schar signed char + // atomic_uchar unsigned char + // atomic_short short + // atomic_ushort unsigned short + // atomic_int int + // atomic_uint unsigned int + // atomic_long long + // atomic_ulong unsigned long + // atomic_llong long long + // atomic_ullong unsigned long long + // atomic_char16_t char16_t + // atomic_char32_t char32_t + // atomic_wchar_t wchar_t + // + // NB: Assuming _ITp is an integral scalar type that is 1, 2, 4, or + // 8 bytes, since that is what GCC built-in functions for atomic + // memory access expect. + template + struct __atomic_base + { + private: + typedef _ITp __int_type; + + __int_type _M_i; + + public: + __atomic_base() noexcept = default; + ~__atomic_base() noexcept = default; + __atomic_base(const __atomic_base&) = delete; + __atomic_base& operator=(const __atomic_base&) = delete; + __atomic_base& operator=(const __atomic_base&) volatile = delete; + + // Requires __int_type convertible to _M_i. + constexpr __atomic_base(__int_type __i) noexcept : _M_i (__i) { } + + operator __int_type() const noexcept + { return load(); } + + operator __int_type() const volatile noexcept + { return load(); } + + __int_type + operator=(__int_type __i) noexcept + { + store(__i); + return __i; + } + + __int_type + operator=(__int_type __i) volatile noexcept + { + store(__i); + return __i; + } + + __int_type + operator++(int) noexcept + { return fetch_add(1); } + + __int_type + operator++(int) volatile noexcept + { return fetch_add(1); } + + __int_type + operator--(int) noexcept + { return fetch_sub(1); } + + __int_type + operator--(int) volatile noexcept + { return fetch_sub(1); } + + __int_type + operator++() noexcept + { return __atomic_add_fetch(&_M_i, 1, memory_order_seq_cst); } + + __int_type + operator++() volatile noexcept + { return __atomic_add_fetch(&_M_i, 1, memory_order_seq_cst); } + + __int_type + operator--() noexcept + { return __atomic_sub_fetch(&_M_i, 1, memory_order_seq_cst); } + + __int_type + operator--() volatile noexcept + { return __atomic_sub_fetch(&_M_i, 1, memory_order_seq_cst); } + + __int_type + operator+=(__int_type __i) noexcept + { return __atomic_add_fetch(&_M_i, __i, memory_order_seq_cst); } + + __int_type + operator+=(__int_type __i) volatile noexcept + { return __atomic_add_fetch(&_M_i, __i, memory_order_seq_cst); } + + __int_type + operator-=(__int_type __i) noexcept + { return __atomic_sub_fetch(&_M_i, __i, memory_order_seq_cst); } + + __int_type + operator-=(__int_type __i) volatile noexcept + { return __atomic_sub_fetch(&_M_i, __i, memory_order_seq_cst); } + + __int_type + operator&=(__int_type __i) noexcept + { return __atomic_and_fetch(&_M_i, __i, memory_order_seq_cst); } + + __int_type + operator&=(__int_type __i) volatile noexcept + { return __atomic_and_fetch(&_M_i, __i, memory_order_seq_cst); } + + __int_type + operator|=(__int_type __i) noexcept + { return __atomic_or_fetch(&_M_i, __i, memory_order_seq_cst); } + + __int_type + operator|=(__int_type __i) volatile noexcept + { return __atomic_or_fetch(&_M_i, __i, memory_order_seq_cst); } + + __int_type + operator^=(__int_type __i) noexcept + { return __atomic_xor_fetch(&_M_i, __i, memory_order_seq_cst); } + + __int_type + operator^=(__int_type __i) volatile noexcept + { return __atomic_xor_fetch(&_M_i, __i, memory_order_seq_cst); } + + bool + is_lock_free() const noexcept + { return __atomic_is_lock_free(sizeof(_M_i), nullptr); } + + bool + is_lock_free() const volatile noexcept + { return __atomic_is_lock_free(sizeof(_M_i), nullptr); } + + _GLIBCXX_ALWAYS_INLINE void + store(__int_type __i, memory_order __m = memory_order_seq_cst) noexcept + { + memory_order __b = __m & __memory_order_mask; + __glibcxx_assert(__b != memory_order_acquire); + __glibcxx_assert(__b != memory_order_acq_rel); + __glibcxx_assert(__b != memory_order_consume); + + __atomic_store_n(&_M_i, __i, __m); + } + + _GLIBCXX_ALWAYS_INLINE void + store(__int_type __i, + memory_order __m = memory_order_seq_cst) volatile noexcept + { + memory_order __b = __m & __memory_order_mask; + __glibcxx_assert(__b != memory_order_acquire); + __glibcxx_assert(__b != memory_order_acq_rel); + __glibcxx_assert(__b != memory_order_consume); + + __atomic_store_n(&_M_i, __i, __m); + } + + _GLIBCXX_ALWAYS_INLINE __int_type + load(memory_order __m = memory_order_seq_cst) const noexcept + { + memory_order __b = __m & __memory_order_mask; + __glibcxx_assert(__b != memory_order_release); + __glibcxx_assert(__b != memory_order_acq_rel); + + return __atomic_load_n(&_M_i, __m); + } + + _GLIBCXX_ALWAYS_INLINE __int_type + load(memory_order __m = memory_order_seq_cst) const volatile noexcept + { + memory_order __b = __m & __memory_order_mask; + __glibcxx_assert(__b != memory_order_release); + __glibcxx_assert(__b != memory_order_acq_rel); + + return __atomic_load_n(&_M_i, __m); + } + + _GLIBCXX_ALWAYS_INLINE __int_type + exchange(__int_type __i, + memory_order __m = memory_order_seq_cst) noexcept + { + return __atomic_exchange_n(&_M_i, __i, __m); + } + + + _GLIBCXX_ALWAYS_INLINE __int_type + exchange(__int_type __i, + memory_order __m = memory_order_seq_cst) volatile noexcept + { + return __atomic_exchange_n(&_M_i, __i, __m); + } + + _GLIBCXX_ALWAYS_INLINE bool + compare_exchange_weak(__int_type& __i1, __int_type __i2, + memory_order __m1, memory_order __m2) noexcept + { + memory_order __b2 = __m2 & __memory_order_mask; + memory_order __b1 = __m1 & __memory_order_mask; + __glibcxx_assert(__b2 != memory_order_release); + __glibcxx_assert(__b2 != memory_order_acq_rel); + __glibcxx_assert(__b2 <= __b1); + + return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 1, __m1, __m2); + } + + _GLIBCXX_ALWAYS_INLINE bool + compare_exchange_weak(__int_type& __i1, __int_type __i2, + memory_order __m1, + memory_order __m2) volatile noexcept + { + memory_order __b2 = __m2 & __memory_order_mask; + memory_order __b1 = __m1 & __memory_order_mask; + __glibcxx_assert(__b2 != memory_order_release); + __glibcxx_assert(__b2 != memory_order_acq_rel); + __glibcxx_assert(__b2 <= __b1); + + return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 1, __m1, __m2); + } + + _GLIBCXX_ALWAYS_INLINE bool + compare_exchange_weak(__int_type& __i1, __int_type __i2, + memory_order __m = memory_order_seq_cst) noexcept + { + return compare_exchange_weak(__i1, __i2, __m, + __cmpexch_failure_order(__m)); + } + + _GLIBCXX_ALWAYS_INLINE bool + compare_exchange_weak(__int_type& __i1, __int_type __i2, + memory_order __m = memory_order_seq_cst) volatile noexcept + { + return compare_exchange_weak(__i1, __i2, __m, + __cmpexch_failure_order(__m)); + } + + _GLIBCXX_ALWAYS_INLINE bool + compare_exchange_strong(__int_type& __i1, __int_type __i2, + memory_order __m1, memory_order __m2) noexcept + { + memory_order __b2 = __m2 & __memory_order_mask; + memory_order __b1 = __m1 & __memory_order_mask; + __glibcxx_assert(__b2 != memory_order_release); + __glibcxx_assert(__b2 != memory_order_acq_rel); + __glibcxx_assert(__b2 <= __b1); + + return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 0, __m1, __m2); + } + + _GLIBCXX_ALWAYS_INLINE bool + compare_exchange_strong(__int_type& __i1, __int_type __i2, + memory_order __m1, + memory_order __m2) volatile noexcept + { + memory_order __b2 = __m2 & __memory_order_mask; + memory_order __b1 = __m1 & __memory_order_mask; + + __glibcxx_assert(__b2 != memory_order_release); + __glibcxx_assert(__b2 != memory_order_acq_rel); + __glibcxx_assert(__b2 <= __b1); + + return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 0, __m1, __m2); + } + + _GLIBCXX_ALWAYS_INLINE bool + compare_exchange_strong(__int_type& __i1, __int_type __i2, + memory_order __m = memory_order_seq_cst) noexcept + { + return compare_exchange_strong(__i1, __i2, __m, + __cmpexch_failure_order(__m)); + } + + _GLIBCXX_ALWAYS_INLINE bool + compare_exchange_strong(__int_type& __i1, __int_type __i2, + memory_order __m = memory_order_seq_cst) volatile noexcept + { + return compare_exchange_strong(__i1, __i2, __m, + __cmpexch_failure_order(__m)); + } + + _GLIBCXX_ALWAYS_INLINE __int_type + fetch_add(__int_type __i, + memory_order __m = memory_order_seq_cst) noexcept + { return __atomic_fetch_add(&_M_i, __i, __m); } + + _GLIBCXX_ALWAYS_INLINE __int_type + fetch_add(__int_type __i, + memory_order __m = memory_order_seq_cst) volatile noexcept + { return __atomic_fetch_add(&_M_i, __i, __m); } + + _GLIBCXX_ALWAYS_INLINE __int_type + fetch_sub(__int_type __i, + memory_order __m = memory_order_seq_cst) noexcept + { return __atomic_fetch_sub(&_M_i, __i, __m); } + + _GLIBCXX_ALWAYS_INLINE __int_type + fetch_sub(__int_type __i, + memory_order __m = memory_order_seq_cst) volatile noexcept + { return __atomic_fetch_sub(&_M_i, __i, __m); } + + _GLIBCXX_ALWAYS_INLINE __int_type + fetch_and(__int_type __i, + memory_order __m = memory_order_seq_cst) noexcept + { return __atomic_fetch_and(&_M_i, __i, __m); } + + _GLIBCXX_ALWAYS_INLINE __int_type + fetch_and(__int_type __i, + memory_order __m = memory_order_seq_cst) volatile noexcept + { return __atomic_fetch_and(&_M_i, __i, __m); } + + _GLIBCXX_ALWAYS_INLINE __int_type + fetch_or(__int_type __i, + memory_order __m = memory_order_seq_cst) noexcept + { return __atomic_fetch_or(&_M_i, __i, __m); } + + _GLIBCXX_ALWAYS_INLINE __int_type + fetch_or(__int_type __i, + memory_order __m = memory_order_seq_cst) volatile noexcept + { return __atomic_fetch_or(&_M_i, __i, __m); } + + _GLIBCXX_ALWAYS_INLINE __int_type + fetch_xor(__int_type __i, + memory_order __m = memory_order_seq_cst) noexcept + { return __atomic_fetch_xor(&_M_i, __i, __m); } + + _GLIBCXX_ALWAYS_INLINE __int_type + fetch_xor(__int_type __i, + memory_order __m = memory_order_seq_cst) volatile noexcept + { return __atomic_fetch_xor(&_M_i, __i, __m); } + }; + + + /// Partial specialization for pointer types. + template + struct __atomic_base<_PTp*> + { + private: + typedef _PTp* __pointer_type; + + __pointer_type _M_p; + + // Factored out to facilitate explicit specialization. + constexpr ptrdiff_t + _M_type_size(ptrdiff_t __d) const { return __d * sizeof(_PTp); } + + constexpr ptrdiff_t + _M_type_size(ptrdiff_t __d) const volatile { return __d * sizeof(_PTp); } + + public: + __atomic_base() noexcept = default; + ~__atomic_base() noexcept = default; + __atomic_base(const __atomic_base&) = delete; + __atomic_base& operator=(const __atomic_base&) = delete; + __atomic_base& operator=(const __atomic_base&) volatile = delete; + + // Requires __pointer_type convertible to _M_p. + constexpr __atomic_base(__pointer_type __p) noexcept : _M_p (__p) { } + + operator __pointer_type() const noexcept + { return load(); } + + operator __pointer_type() const volatile noexcept + { return load(); } + + __pointer_type + operator=(__pointer_type __p) noexcept + { + store(__p); + return __p; + } + + __pointer_type + operator=(__pointer_type __p) volatile noexcept + { + store(__p); + return __p; + } + + __pointer_type + operator++(int) noexcept + { return fetch_add(1); } + + __pointer_type + operator++(int) volatile noexcept + { return fetch_add(1); } + + __pointer_type + operator--(int) noexcept + { return fetch_sub(1); } + + __pointer_type + operator--(int) volatile noexcept + { return fetch_sub(1); } + + __pointer_type + operator++() noexcept + { return __atomic_add_fetch(&_M_p, _M_type_size(1), + memory_order_seq_cst); } + + __pointer_type + operator++() volatile noexcept + { return __atomic_add_fetch(&_M_p, _M_type_size(1), + memory_order_seq_cst); } + + __pointer_type + operator--() noexcept + { return __atomic_sub_fetch(&_M_p, _M_type_size(1), + memory_order_seq_cst); } + + __pointer_type + operator--() volatile noexcept + { return __atomic_sub_fetch(&_M_p, _M_type_size(1), + memory_order_seq_cst); } + + __pointer_type + operator+=(ptrdiff_t __d) noexcept + { return __atomic_add_fetch(&_M_p, _M_type_size(__d), + memory_order_seq_cst); } + + __pointer_type + operator+=(ptrdiff_t __d) volatile noexcept + { return __atomic_add_fetch(&_M_p, _M_type_size(__d), + memory_order_seq_cst); } + + __pointer_type + operator-=(ptrdiff_t __d) noexcept + { return __atomic_sub_fetch(&_M_p, _M_type_size(__d), + memory_order_seq_cst); } + + __pointer_type + operator-=(ptrdiff_t __d) volatile noexcept + { return __atomic_sub_fetch(&_M_p, _M_type_size(__d), + memory_order_seq_cst); } + + bool + is_lock_free() const noexcept + { return __atomic_is_lock_free(sizeof(__pointer_type), nullptr); } + + bool + is_lock_free() const volatile noexcept + { return __atomic_is_lock_free(sizeof(__pointer_type), nullptr); } + + _GLIBCXX_ALWAYS_INLINE void + store(__pointer_type __p, + memory_order __m = memory_order_seq_cst) noexcept + { + memory_order __b = __m & __memory_order_mask; + + __glibcxx_assert(__b != memory_order_acquire); + __glibcxx_assert(__b != memory_order_acq_rel); + __glibcxx_assert(__b != memory_order_consume); + + __atomic_store_n(&_M_p, __p, __m); + } + + _GLIBCXX_ALWAYS_INLINE void + store(__pointer_type __p, + memory_order __m = memory_order_seq_cst) volatile noexcept + { + memory_order __b = __m & __memory_order_mask; + __glibcxx_assert(__b != memory_order_acquire); + __glibcxx_assert(__b != memory_order_acq_rel); + __glibcxx_assert(__b != memory_order_consume); + + __atomic_store_n(&_M_p, __p, __m); + } + + _GLIBCXX_ALWAYS_INLINE __pointer_type + load(memory_order __m = memory_order_seq_cst) const noexcept + { + memory_order __b = __m & __memory_order_mask; + __glibcxx_assert(__b != memory_order_release); + __glibcxx_assert(__b != memory_order_acq_rel); + + return __atomic_load_n(&_M_p, __m); + } + + _GLIBCXX_ALWAYS_INLINE __pointer_type + load(memory_order __m = memory_order_seq_cst) const volatile noexcept + { + memory_order __b = __m & __memory_order_mask; + __glibcxx_assert(__b != memory_order_release); + __glibcxx_assert(__b != memory_order_acq_rel); + + return __atomic_load_n(&_M_p, __m); + } + + _GLIBCXX_ALWAYS_INLINE __pointer_type + exchange(__pointer_type __p, + memory_order __m = memory_order_seq_cst) noexcept + { + return __atomic_exchange_n(&_M_p, __p, __m); + } + + + _GLIBCXX_ALWAYS_INLINE __pointer_type + exchange(__pointer_type __p, + memory_order __m = memory_order_seq_cst) volatile noexcept + { + return __atomic_exchange_n(&_M_p, __p, __m); + } + + _GLIBCXX_ALWAYS_INLINE bool + compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, + memory_order __m1, + memory_order __m2) noexcept + { + memory_order __b2 = __m2 & __memory_order_mask; + memory_order __b1 = __m1 & __memory_order_mask; + __glibcxx_assert(__b2 != memory_order_release); + __glibcxx_assert(__b2 != memory_order_acq_rel); + __glibcxx_assert(__b2 <= __b1); + + return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 0, __m1, __m2); + } + + _GLIBCXX_ALWAYS_INLINE bool + compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, + memory_order __m1, + memory_order __m2) volatile noexcept + { + memory_order __b2 = __m2 & __memory_order_mask; + memory_order __b1 = __m1 & __memory_order_mask; + + __glibcxx_assert(__b2 != memory_order_release); + __glibcxx_assert(__b2 != memory_order_acq_rel); + __glibcxx_assert(__b2 <= __b1); + + return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 0, __m1, __m2); + } + + _GLIBCXX_ALWAYS_INLINE __pointer_type + fetch_add(ptrdiff_t __d, + memory_order __m = memory_order_seq_cst) noexcept + { return __atomic_fetch_add(&_M_p, _M_type_size(__d), __m); } + + _GLIBCXX_ALWAYS_INLINE __pointer_type + fetch_add(ptrdiff_t __d, + memory_order __m = memory_order_seq_cst) volatile noexcept + { return __atomic_fetch_add(&_M_p, _M_type_size(__d), __m); } + + _GLIBCXX_ALWAYS_INLINE __pointer_type + fetch_sub(ptrdiff_t __d, + memory_order __m = memory_order_seq_cst) noexcept + { return __atomic_fetch_sub(&_M_p, _M_type_size(__d), __m); } + + _GLIBCXX_ALWAYS_INLINE __pointer_type + fetch_sub(ptrdiff_t __d, + memory_order __m = memory_order_seq_cst) volatile noexcept + { return __atomic_fetch_sub(&_M_p, _M_type_size(__d), __m); } + }; + + // @} group atomics + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace std + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/atomic_lockfree_defines.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/atomic_lockfree_defines.h new file mode 100755 index 0000000..5c6fd55 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/atomic_lockfree_defines.h @@ -0,0 +1,63 @@ +// -*- C++ -*- header. + +// Copyright (C) 2008-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file bits/atomic_lockfree_defines.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{atomic} + */ + +#ifndef _GLIBCXX_ATOMIC_LOCK_FREE_H +#define _GLIBCXX_ATOMIC_LOCK_FREE_H 1 + +#pragma GCC system_header + +/** + * @addtogroup atomics + * @{ + */ + +/** + * Lock-free property. + * + * 0 indicates that the types are never lock-free. + * 1 indicates that the types are sometimes lock-free. + * 2 indicates that the types are always lock-free. + */ + +#if __cplusplus >= 201103L +#define ATOMIC_BOOL_LOCK_FREE __GCC_ATOMIC_BOOL_LOCK_FREE +#define ATOMIC_CHAR_LOCK_FREE __GCC_ATOMIC_CHAR_LOCK_FREE +#define ATOMIC_WCHAR_T_LOCK_FREE __GCC_ATOMIC_WCHAR_T_LOCK_FREE +#define ATOMIC_CHAR16_T_LOCK_FREE __GCC_ATOMIC_CHAR16_T_LOCK_FREE +#define ATOMIC_CHAR32_T_LOCK_FREE __GCC_ATOMIC_CHAR32_T_LOCK_FREE +#define ATOMIC_SHORT_LOCK_FREE __GCC_ATOMIC_SHORT_LOCK_FREE +#define ATOMIC_INT_LOCK_FREE __GCC_ATOMIC_INT_LOCK_FREE +#define ATOMIC_LONG_LOCK_FREE __GCC_ATOMIC_LONG_LOCK_FREE +#define ATOMIC_LLONG_LOCK_FREE __GCC_ATOMIC_LLONG_LOCK_FREE +#define ATOMIC_POINTER_LOCK_FREE __GCC_ATOMIC_POINTER_LOCK_FREE +#endif + +// @} group atomics + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/basic_ios.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/basic_ios.h new file mode 100755 index 0000000..58bede4 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/basic_ios.h @@ -0,0 +1,477 @@ +// Iostreams base classes -*- C++ -*- + +// Copyright (C) 1997-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file bits/basic_ios.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{ios} + */ + +#ifndef _BASIC_IOS_H +#define _BASIC_IOS_H 1 + +#pragma GCC system_header + +#include +#include +#include +#include + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + template + inline const _Facet& + __check_facet(const _Facet* __f) + { + if (!__f) + __throw_bad_cast(); + return *__f; + } + + /** + * @brief Template class basic_ios, virtual base class for all + * stream classes. + * @ingroup io + * + * @tparam _CharT Type of character stream. + * @tparam _Traits Traits for character type, defaults to + * char_traits<_CharT>. + * + * Most of the member functions called dispatched on stream objects + * (e.g., @c std::cout.foo(bar);) are consolidated in this class. + */ + template + class basic_ios : public ios_base + { + public: + //@{ + /** + * These are standard types. They permit a standardized way of + * referring to names of (or names dependent on) the template + * parameters, which are specific to the implementation. + */ + typedef _CharT char_type; + typedef typename _Traits::int_type int_type; + typedef typename _Traits::pos_type pos_type; + typedef typename _Traits::off_type off_type; + typedef _Traits traits_type; + //@} + + //@{ + /** + * These are non-standard types. + */ + typedef ctype<_CharT> __ctype_type; + typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> > + __num_put_type; + typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> > + __num_get_type; + //@} + + // Data members: + protected: + basic_ostream<_CharT, _Traits>* _M_tie; + mutable char_type _M_fill; + mutable bool _M_fill_init; + basic_streambuf<_CharT, _Traits>* _M_streambuf; + + // Cached use_facet, which is based on the current locale info. + const __ctype_type* _M_ctype; + // For ostream. + const __num_put_type* _M_num_put; + // For istream. + const __num_get_type* _M_num_get; + + public: + //@{ + /** + * @brief The quick-and-easy status check. + * + * This allows you to write constructs such as + * if (!a_stream) ... and while (a_stream) ... + */ + operator void*() const + { return this->fail() ? 0 : const_cast(this); } + + bool + operator!() const + { return this->fail(); } + //@} + + /** + * @brief Returns the error state of the stream buffer. + * @return A bit pattern (well, isn't everything?) + * + * See std::ios_base::iostate for the possible bit values. Most + * users will call one of the interpreting wrappers, e.g., good(). + */ + iostate + rdstate() const + { return _M_streambuf_state; } + + /** + * @brief [Re]sets the error state. + * @param __state The new state flag(s) to set. + * + * See std::ios_base::iostate for the possible bit values. Most + * users will not need to pass an argument. + */ + void + clear(iostate __state = goodbit); + + /** + * @brief Sets additional flags in the error state. + * @param __state The additional state flag(s) to set. + * + * See std::ios_base::iostate for the possible bit values. + */ + void + setstate(iostate __state) + { this->clear(this->rdstate() | __state); } + + // Flip the internal state on for the proper state bits, then re + // throws the propagated exception if bit also set in + // exceptions(). + void + _M_setstate(iostate __state) + { + // 27.6.1.2.1 Common requirements. + // Turn this on without causing an ios::failure to be thrown. + _M_streambuf_state |= __state; + if (this->exceptions() & __state) + __throw_exception_again; + } + + /** + * @brief Fast error checking. + * @return True if no error flags are set. + * + * A wrapper around rdstate. + */ + bool + good() const + { return this->rdstate() == 0; } + + /** + * @brief Fast error checking. + * @return True if the eofbit is set. + * + * Note that other iostate flags may also be set. + */ + bool + eof() const + { return (this->rdstate() & eofbit) != 0; } + + /** + * @brief Fast error checking. + * @return True if either the badbit or the failbit is set. + * + * Checking the badbit in fail() is historical practice. + * Note that other iostate flags may also be set. + */ + bool + fail() const + { return (this->rdstate() & (badbit | failbit)) != 0; } + + /** + * @brief Fast error checking. + * @return True if the badbit is set. + * + * Note that other iostate flags may also be set. + */ + bool + bad() const + { return (this->rdstate() & badbit) != 0; } + + /** + * @brief Throwing exceptions on errors. + * @return The current exceptions mask. + * + * This changes nothing in the stream. See the one-argument version + * of exceptions(iostate) for the meaning of the return value. + */ + iostate + exceptions() const + { return _M_exception; } + + /** + * @brief Throwing exceptions on errors. + * @param __except The new exceptions mask. + * + * By default, error flags are set silently. You can set an + * exceptions mask for each stream; if a bit in the mask becomes set + * in the error flags, then an exception of type + * std::ios_base::failure is thrown. + * + * If the error flag is already set when the exceptions mask is + * added, the exception is immediately thrown. Try running the + * following under GCC 3.1 or later: + * @code + * #include + * #include + * #include + * + * int main() + * { + * std::set_terminate (__gnu_cxx::__verbose_terminate_handler); + * + * std::ifstream f ("/etc/motd"); + * + * std::cerr << "Setting badbit\n"; + * f.setstate (std::ios_base::badbit); + * + * std::cerr << "Setting exception mask\n"; + * f.exceptions (std::ios_base::badbit); + * } + * @endcode + */ + void + exceptions(iostate __except) + { + _M_exception = __except; + this->clear(_M_streambuf_state); + } + + // Constructor/destructor: + /** + * @brief Constructor performs initialization. + * + * The parameter is passed by derived streams. + */ + explicit + basic_ios(basic_streambuf<_CharT, _Traits>* __sb) + : ios_base(), _M_tie(0), _M_fill(), _M_fill_init(false), _M_streambuf(0), + _M_ctype(0), _M_num_put(0), _M_num_get(0) + { this->init(__sb); } + + /** + * @brief Empty. + * + * The destructor does nothing. More specifically, it does not + * destroy the streambuf held by rdbuf(). + */ + virtual + ~basic_ios() { } + + // Members: + /** + * @brief Fetches the current @e tied stream. + * @return A pointer to the tied stream, or NULL if the stream is + * not tied. + * + * A stream may be @e tied (or synchronized) to a second output + * stream. When this stream performs any I/O, the tied stream is + * first flushed. For example, @c std::cin is tied to @c std::cout. + */ + basic_ostream<_CharT, _Traits>* + tie() const + { return _M_tie; } + + /** + * @brief Ties this stream to an output stream. + * @param __tiestr The output stream. + * @return The previously tied output stream, or NULL if the stream + * was not tied. + * + * This sets up a new tie; see tie() for more. + */ + basic_ostream<_CharT, _Traits>* + tie(basic_ostream<_CharT, _Traits>* __tiestr) + { + basic_ostream<_CharT, _Traits>* __old = _M_tie; + _M_tie = __tiestr; + return __old; + } + + /** + * @brief Accessing the underlying buffer. + * @return The current stream buffer. + * + * This does not change the state of the stream. + */ + basic_streambuf<_CharT, _Traits>* + rdbuf() const + { return _M_streambuf; } + + /** + * @brief Changing the underlying buffer. + * @param __sb The new stream buffer. + * @return The previous stream buffer. + * + * Associates a new buffer with the current stream, and clears the + * error state. + * + * Due to historical accidents which the LWG refuses to correct, the + * I/O library suffers from a design error: this function is hidden + * in derived classes by overrides of the zero-argument @c rdbuf(), + * which is non-virtual for hysterical raisins. As a result, you + * must use explicit qualifications to access this function via any + * derived class. For example: + * + * @code + * std::fstream foo; // or some other derived type + * std::streambuf* p = .....; + * + * foo.ios::rdbuf(p); // ios == basic_ios + * @endcode + */ + basic_streambuf<_CharT, _Traits>* + rdbuf(basic_streambuf<_CharT, _Traits>* __sb); + + /** + * @brief Copies fields of __rhs into this. + * @param __rhs The source values for the copies. + * @return Reference to this object. + * + * All fields of __rhs are copied into this object except that rdbuf() + * and rdstate() remain unchanged. All values in the pword and iword + * arrays are copied. Before copying, each callback is invoked with + * erase_event. After copying, each (new) callback is invoked with + * copyfmt_event. The final step is to copy exceptions(). + */ + basic_ios& + copyfmt(const basic_ios& __rhs); + + /** + * @brief Retrieves the @a empty character. + * @return The current fill character. + * + * It defaults to a space (' ') in the current locale. + */ + char_type + fill() const + { + if (!_M_fill_init) + { + _M_fill = this->widen(' '); + _M_fill_init = true; + } + return _M_fill; + } + + /** + * @brief Sets a new @a empty character. + * @param __ch The new character. + * @return The previous fill character. + * + * The fill character is used to fill out space when P+ characters + * have been requested (e.g., via setw), Q characters are actually + * used, and Qfill(); + _M_fill = __ch; + return __old; + } + + // Locales: + /** + * @brief Moves to a new locale. + * @param __loc The new locale. + * @return The previous locale. + * + * Calls @c ios_base::imbue(loc), and if a stream buffer is associated + * with this stream, calls that buffer's @c pubimbue(loc). + * + * Additional l10n notes are at + * http://gcc.gnu.org/onlinedocs/libstdc++/manual/localization.html + */ + locale + imbue(const locale& __loc); + + /** + * @brief Squeezes characters. + * @param __c The character to narrow. + * @param __dfault The character to narrow. + * @return The narrowed character. + * + * Maps a character of @c char_type to a character of @c char, + * if possible. + * + * Returns the result of + * @code + * std::use_facet >(getloc()).narrow(c,dfault) + * @endcode + * + * Additional l10n notes are at + * http://gcc.gnu.org/onlinedocs/libstdc++/manual/localization.html + */ + char + narrow(char_type __c, char __dfault) const + { return __check_facet(_M_ctype).narrow(__c, __dfault); } + + /** + * @brief Widens characters. + * @param __c The character to widen. + * @return The widened character. + * + * Maps a character of @c char to a character of @c char_type. + * + * Returns the result of + * @code + * std::use_facet >(getloc()).widen(c) + * @endcode + * + * Additional l10n notes are at + * http://gcc.gnu.org/onlinedocs/libstdc++/manual/localization.html + */ + char_type + widen(char __c) const + { return __check_facet(_M_ctype).widen(__c); } + + protected: + // 27.4.5.1 basic_ios constructors + /** + * @brief Empty. + * + * The default constructor does nothing and is not normally + * accessible to users. + */ + basic_ios() + : ios_base(), _M_tie(0), _M_fill(char_type()), _M_fill_init(false), + _M_streambuf(0), _M_ctype(0), _M_num_put(0), _M_num_get(0) + { } + + /** + * @brief All setup is performed here. + * + * This is called from the public constructor. It is not virtual and + * cannot be redefined. + */ + void + init(basic_streambuf<_CharT, _Traits>* __sb); + + void + _M_cache_locale(const locale& __loc); + }; + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#include + +#endif /* _BASIC_IOS_H */ diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/basic_ios.tcc b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/basic_ios.tcc new file mode 100755 index 0000000..3cf4289 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/basic_ios.tcc @@ -0,0 +1,188 @@ +// basic_ios member functions -*- C++ -*- + +// Copyright (C) 1999-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file bits/basic_ios.tcc + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{ios} + */ + +#ifndef _BASIC_IOS_TCC +#define _BASIC_IOS_TCC 1 + +#pragma GCC system_header + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + template + void + basic_ios<_CharT, _Traits>::clear(iostate __state) + { + if (this->rdbuf()) + _M_streambuf_state = __state; + else + _M_streambuf_state = __state | badbit; + if (this->exceptions() & this->rdstate()) + __throw_ios_failure(__N("basic_ios::clear")); + } + + template + basic_streambuf<_CharT, _Traits>* + basic_ios<_CharT, _Traits>::rdbuf(basic_streambuf<_CharT, _Traits>* __sb) + { + basic_streambuf<_CharT, _Traits>* __old = _M_streambuf; + _M_streambuf = __sb; + this->clear(); + return __old; + } + + template + basic_ios<_CharT, _Traits>& + basic_ios<_CharT, _Traits>::copyfmt(const basic_ios& __rhs) + { + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 292. effects of a.copyfmt (a) + if (this != &__rhs) + { + // Per 27.1.1, do not call imbue, yet must trash all caches + // associated with imbue() + + // Alloc any new word array first, so if it fails we have "rollback". + _Words* __words = (__rhs._M_word_size <= _S_local_word_size) ? + _M_local_word : new _Words[__rhs._M_word_size]; + + // Bump refs before doing callbacks, for safety. + _Callback_list* __cb = __rhs._M_callbacks; + if (__cb) + __cb->_M_add_reference(); + _M_call_callbacks(erase_event); + if (_M_word != _M_local_word) + { + delete [] _M_word; + _M_word = 0; + } + _M_dispose_callbacks(); + + // NB: Don't want any added during above. + _M_callbacks = __cb; + for (int __i = 0; __i < __rhs._M_word_size; ++__i) + __words[__i] = __rhs._M_word[__i]; + _M_word = __words; + _M_word_size = __rhs._M_word_size; + + this->flags(__rhs.flags()); + this->width(__rhs.width()); + this->precision(__rhs.precision()); + this->tie(__rhs.tie()); + this->fill(__rhs.fill()); + _M_ios_locale = __rhs.getloc(); + _M_cache_locale(_M_ios_locale); + + _M_call_callbacks(copyfmt_event); + + // The next is required to be the last assignment. + this->exceptions(__rhs.exceptions()); + } + return *this; + } + + // Locales: + template + locale + basic_ios<_CharT, _Traits>::imbue(const locale& __loc) + { + locale __old(this->getloc()); + ios_base::imbue(__loc); + _M_cache_locale(__loc); + if (this->rdbuf() != 0) + this->rdbuf()->pubimbue(__loc); + return __old; + } + + template + void + basic_ios<_CharT, _Traits>::init(basic_streambuf<_CharT, _Traits>* __sb) + { + // NB: This may be called more than once on the same object. + ios_base::_M_init(); + + // Cache locale data and specific facets used by iostreams. + _M_cache_locale(_M_ios_locale); + + // NB: The 27.4.4.1 Postconditions Table specifies requirements + // after basic_ios::init() has been called. As part of this, + // fill() must return widen(' ') any time after init() has been + // called, which needs an imbued ctype facet of char_type to + // return without throwing an exception. Unfortunately, + // ctype is not necessarily a required facet, so + // streams with char_type != [char, wchar_t] will not have it by + // default. Because of this, the correct value for _M_fill is + // constructed on the first call of fill(). That way, + // unformatted input and output with non-required basic_ios + // instantiations is possible even without imbuing the expected + // ctype facet. + _M_fill = _CharT(); + _M_fill_init = false; + + _M_tie = 0; + _M_exception = goodbit; + _M_streambuf = __sb; + _M_streambuf_state = __sb ? goodbit : badbit; + } + + template + void + basic_ios<_CharT, _Traits>::_M_cache_locale(const locale& __loc) + { + if (__builtin_expect(has_facet<__ctype_type>(__loc), true)) + _M_ctype = &use_facet<__ctype_type>(__loc); + else + _M_ctype = 0; + + if (__builtin_expect(has_facet<__num_put_type>(__loc), true)) + _M_num_put = &use_facet<__num_put_type>(__loc); + else + _M_num_put = 0; + + if (__builtin_expect(has_facet<__num_get_type>(__loc), true)) + _M_num_get = &use_facet<__num_get_type>(__loc); + else + _M_num_get = 0; + } + + // Inhibit implicit instantiations for required instantiations, + // which are defined via explicit instantiations elsewhere. +#if _GLIBCXX_EXTERN_TEMPLATE + extern template class basic_ios; + +#ifdef _GLIBCXX_USE_WCHAR_T + extern template class basic_ios; +#endif +#endif + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace std + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/basic_string.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/basic_string.h new file mode 100755 index 0000000..8918965 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/basic_string.h @@ -0,0 +1,3180 @@ +// Components for manipulating sequences of characters -*- C++ -*- + +// Copyright (C) 1997-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file bits/basic_string.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{string} + */ + +// +// ISO C++ 14882: 21 Strings library +// + +#ifndef _BASIC_STRING_H +#define _BASIC_STRING_H 1 + +#pragma GCC system_header + +#include +#include +#if __cplusplus >= 201103L +#include +#endif + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /** + * @class basic_string basic_string.h + * @brief Managing sequences of characters and character-like objects. + * + * @ingroup strings + * @ingroup sequences + * + * @tparam _CharT Type of character + * @tparam _Traits Traits for character type, defaults to + * char_traits<_CharT>. + * @tparam _Alloc Allocator type, defaults to allocator<_CharT>. + * + * Meets the requirements of a container, a + * reversible container, and a + * sequence. Of the + * optional sequence requirements, only + * @c push_back, @c at, and @c %array access are supported. + * + * @doctodo + * + * + * Documentation? What's that? + * Nathan Myers . + * + * A string looks like this: + * + * @code + * [_Rep] + * _M_length + * [basic_string] _M_capacity + * _M_dataplus _M_refcount + * _M_p ----------------> unnamed array of char_type + * @endcode + * + * Where the _M_p points to the first character in the string, and + * you cast it to a pointer-to-_Rep and subtract 1 to get a + * pointer to the header. + * + * This approach has the enormous advantage that a string object + * requires only one allocation. All the ugliness is confined + * within a single %pair of inline functions, which each compile to + * a single @a add instruction: _Rep::_M_data(), and + * string::_M_rep(); and the allocation function which gets a + * block of raw bytes and with room enough and constructs a _Rep + * object at the front. + * + * The reason you want _M_data pointing to the character %array and + * not the _Rep is so that the debugger can see the string + * contents. (Probably we should add a non-inline member to get + * the _Rep for the debugger to use, so users can check the actual + * string length.) + * + * Note that the _Rep object is a POD so that you can have a + * static empty string _Rep object already @a constructed before + * static constructors have run. The reference-count encoding is + * chosen so that a 0 indicates one reference, so you never try to + * destroy the empty-string _Rep object. + * + * All but the last paragraph is considered pretty conventional + * for a C++ string implementation. + */ + // 21.3 Template class basic_string + template + class basic_string + { + typedef typename _Alloc::template rebind<_CharT>::other _CharT_alloc_type; + + // Types: + public: + typedef _Traits traits_type; + typedef typename _Traits::char_type value_type; + typedef _Alloc allocator_type; + typedef typename _CharT_alloc_type::size_type size_type; + typedef typename _CharT_alloc_type::difference_type difference_type; + typedef typename _CharT_alloc_type::reference reference; + typedef typename _CharT_alloc_type::const_reference const_reference; + typedef typename _CharT_alloc_type::pointer pointer; + typedef typename _CharT_alloc_type::const_pointer const_pointer; + typedef __gnu_cxx::__normal_iterator iterator; + typedef __gnu_cxx::__normal_iterator + const_iterator; + typedef std::reverse_iterator const_reverse_iterator; + typedef std::reverse_iterator reverse_iterator; + + private: + // _Rep: string representation + // Invariants: + // 1. String really contains _M_length + 1 characters: due to 21.3.4 + // must be kept null-terminated. + // 2. _M_capacity >= _M_length + // Allocated memory is always (_M_capacity + 1) * sizeof(_CharT). + // 3. _M_refcount has three states: + // -1: leaked, one reference, no ref-copies allowed, non-const. + // 0: one reference, non-const. + // n>0: n + 1 references, operations require a lock, const. + // 4. All fields==0 is an empty string, given the extra storage + // beyond-the-end for a null terminator; thus, the shared + // empty string representation needs no constructor. + + struct _Rep_base + { + size_type _M_length; + size_type _M_capacity; + _Atomic_word _M_refcount; + }; + + struct _Rep : _Rep_base + { + // Types: + typedef typename _Alloc::template rebind::other _Raw_bytes_alloc; + + // (Public) Data members: + + // The maximum number of individual char_type elements of an + // individual string is determined by _S_max_size. This is the + // value that will be returned by max_size(). (Whereas npos + // is the maximum number of bytes the allocator can allocate.) + // If one was to divvy up the theoretical largest size string, + // with a terminating character and m _CharT elements, it'd + // look like this: + // npos = sizeof(_Rep) + (m * sizeof(_CharT)) + sizeof(_CharT) + // Solving for m: + // m = ((npos - sizeof(_Rep))/sizeof(CharT)) - 1 + // In addition, this implementation quarters this amount. + static const size_type _S_max_size; + static const _CharT _S_terminal; + + // The following storage is init'd to 0 by the linker, resulting + // (carefully) in an empty string with one reference. + static size_type _S_empty_rep_storage[]; + + static _Rep& + _S_empty_rep() _GLIBCXX_NOEXCEPT + { + // NB: Mild hack to avoid strict-aliasing warnings. Note that + // _S_empty_rep_storage is never modified and the punning should + // be reasonably safe in this case. + void* __p = reinterpret_cast(&_S_empty_rep_storage); + return *reinterpret_cast<_Rep*>(__p); + } + + bool + _M_is_leaked() const _GLIBCXX_NOEXCEPT + { return this->_M_refcount < 0; } + + bool + _M_is_shared() const _GLIBCXX_NOEXCEPT + { return this->_M_refcount > 0; } + + void + _M_set_leaked() _GLIBCXX_NOEXCEPT + { this->_M_refcount = -1; } + + void + _M_set_sharable() _GLIBCXX_NOEXCEPT + { this->_M_refcount = 0; } + + void + _M_set_length_and_sharable(size_type __n) _GLIBCXX_NOEXCEPT + { +#if _GLIBCXX_FULLY_DYNAMIC_STRING == 0 + if (__builtin_expect(this != &_S_empty_rep(), false)) +#endif + { + this->_M_set_sharable(); // One reference. + this->_M_length = __n; + traits_type::assign(this->_M_refdata()[__n], _S_terminal); + // grrr. (per 21.3.4) + // You cannot leave those LWG people alone for a second. + } + } + + _CharT* + _M_refdata() throw() + { return reinterpret_cast<_CharT*>(this + 1); } + + _CharT* + _M_grab(const _Alloc& __alloc1, const _Alloc& __alloc2) + { + return (!_M_is_leaked() && __alloc1 == __alloc2) + ? _M_refcopy() : _M_clone(__alloc1); + } + + // Create & Destroy + static _Rep* + _S_create(size_type, size_type, const _Alloc&); + + void + _M_dispose(const _Alloc& __a) _GLIBCXX_NOEXCEPT + { +#if _GLIBCXX_FULLY_DYNAMIC_STRING == 0 + if (__builtin_expect(this != &_S_empty_rep(), false)) +#endif + { + // Be race-detector-friendly. For more info see bits/c++config. + _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&this->_M_refcount); + if (__gnu_cxx::__exchange_and_add_dispatch(&this->_M_refcount, + -1) <= 0) + { + _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&this->_M_refcount); + _M_destroy(__a); + } + } + } // XXX MT + + void + _M_destroy(const _Alloc&) throw(); + + _CharT* + _M_refcopy() throw() + { +#if _GLIBCXX_FULLY_DYNAMIC_STRING == 0 + if (__builtin_expect(this != &_S_empty_rep(), false)) +#endif + __gnu_cxx::__atomic_add_dispatch(&this->_M_refcount, 1); + return _M_refdata(); + } // XXX MT + + _CharT* + _M_clone(const _Alloc&, size_type __res = 0); + }; + + // Use empty-base optimization: http://www.cantrip.org/emptyopt.html + struct _Alloc_hider : _Alloc + { + _Alloc_hider(_CharT* __dat, const _Alloc& __a) _GLIBCXX_NOEXCEPT + : _Alloc(__a), _M_p(__dat) { } + + _CharT* _M_p; // The actual data. + }; + + public: + // Data Members (public): + // NB: This is an unsigned type, and thus represents the maximum + // size that the allocator can hold. + /// Value returned by various member functions when they fail. + static const size_type npos = static_cast(-1); + + private: + // Data Members (private): + mutable _Alloc_hider _M_dataplus; + + _CharT* + _M_data() const _GLIBCXX_NOEXCEPT + { return _M_dataplus._M_p; } + + _CharT* + _M_data(_CharT* __p) _GLIBCXX_NOEXCEPT + { return (_M_dataplus._M_p = __p); } + + _Rep* + _M_rep() const _GLIBCXX_NOEXCEPT + { return &((reinterpret_cast<_Rep*> (_M_data()))[-1]); } + + // For the internal use we have functions similar to `begin'/`end' + // but they do not call _M_leak. + iterator + _M_ibegin() const _GLIBCXX_NOEXCEPT + { return iterator(_M_data()); } + + iterator + _M_iend() const _GLIBCXX_NOEXCEPT + { return iterator(_M_data() + this->size()); } + + void + _M_leak() // for use in begin() & non-const op[] + { + if (!_M_rep()->_M_is_leaked()) + _M_leak_hard(); + } + + size_type + _M_check(size_type __pos, const char* __s) const + { + if (__pos > this->size()) + __throw_out_of_range_fmt(__N("%s: __pos (which is %zu) > " + "this->size() (which is %zu)"), + __s, __pos, this->size()); + return __pos; + } + + void + _M_check_length(size_type __n1, size_type __n2, const char* __s) const + { + if (this->max_size() - (this->size() - __n1) < __n2) + __throw_length_error(__N(__s)); + } + + // NB: _M_limit doesn't check for a bad __pos value. + size_type + _M_limit(size_type __pos, size_type __off) const _GLIBCXX_NOEXCEPT + { + const bool __testoff = __off < this->size() - __pos; + return __testoff ? __off : this->size() - __pos; + } + + // True if _Rep and source do not overlap. + bool + _M_disjunct(const _CharT* __s) const _GLIBCXX_NOEXCEPT + { + return (less()(__s, _M_data()) + || less()(_M_data() + this->size(), __s)); + } + + // When __n = 1 way faster than the general multichar + // traits_type::copy/move/assign. + static void + _M_copy(_CharT* __d, const _CharT* __s, size_type __n) _GLIBCXX_NOEXCEPT + { + if (__n == 1) + traits_type::assign(*__d, *__s); + else + traits_type::copy(__d, __s, __n); + } + + static void + _M_move(_CharT* __d, const _CharT* __s, size_type __n) _GLIBCXX_NOEXCEPT + { + if (__n == 1) + traits_type::assign(*__d, *__s); + else + traits_type::move(__d, __s, __n); + } + + static void + _M_assign(_CharT* __d, size_type __n, _CharT __c) _GLIBCXX_NOEXCEPT + { + if (__n == 1) + traits_type::assign(*__d, __c); + else + traits_type::assign(__d, __n, __c); + } + + // _S_copy_chars is a separate template to permit specialization + // to optimize for the common case of pointers as iterators. + template + static void + _S_copy_chars(_CharT* __p, _Iterator __k1, _Iterator __k2) + _GLIBCXX_NOEXCEPT + { + for (; __k1 != __k2; ++__k1, ++__p) + traits_type::assign(*__p, *__k1); // These types are off. + } + + static void + _S_copy_chars(_CharT* __p, iterator __k1, iterator __k2) _GLIBCXX_NOEXCEPT + { _S_copy_chars(__p, __k1.base(), __k2.base()); } + + static void + _S_copy_chars(_CharT* __p, const_iterator __k1, const_iterator __k2) + _GLIBCXX_NOEXCEPT + { _S_copy_chars(__p, __k1.base(), __k2.base()); } + + static void + _S_copy_chars(_CharT* __p, _CharT* __k1, _CharT* __k2) _GLIBCXX_NOEXCEPT + { _M_copy(__p, __k1, __k2 - __k1); } + + static void + _S_copy_chars(_CharT* __p, const _CharT* __k1, const _CharT* __k2) + _GLIBCXX_NOEXCEPT + { _M_copy(__p, __k1, __k2 - __k1); } + + static int + _S_compare(size_type __n1, size_type __n2) _GLIBCXX_NOEXCEPT + { + const difference_type __d = difference_type(__n1 - __n2); + + if (__d > __gnu_cxx::__numeric_traits::__max) + return __gnu_cxx::__numeric_traits::__max; + else if (__d < __gnu_cxx::__numeric_traits::__min) + return __gnu_cxx::__numeric_traits::__min; + else + return int(__d); + } + + void + _M_mutate(size_type __pos, size_type __len1, size_type __len2); + + void + _M_leak_hard(); + + static _Rep& + _S_empty_rep() _GLIBCXX_NOEXCEPT + { return _Rep::_S_empty_rep(); } + + public: + // Construct/copy/destroy: + // NB: We overload ctors in some cases instead of using default + // arguments, per 17.4.4.4 para. 2 item 2. + + /** + * @brief Default constructor creates an empty string. + */ + basic_string() +#if _GLIBCXX_FULLY_DYNAMIC_STRING == 0 + : _M_dataplus(_S_empty_rep()._M_refdata(), _Alloc()) { } +#else + : _M_dataplus(_S_construct(size_type(), _CharT(), _Alloc()), _Alloc()){ } +#endif + + /** + * @brief Construct an empty string using allocator @a a. + */ + explicit + basic_string(const _Alloc& __a); + + // NB: per LWG issue 42, semantics different from IS: + /** + * @brief Construct string with copy of value of @a str. + * @param __str Source string. + */ + basic_string(const basic_string& __str); + /** + * @brief Construct string as copy of a substring. + * @param __str Source string. + * @param __pos Index of first character to copy from. + * @param __n Number of characters to copy (default remainder). + */ + basic_string(const basic_string& __str, size_type __pos, + size_type __n = npos); + /** + * @brief Construct string as copy of a substring. + * @param __str Source string. + * @param __pos Index of first character to copy from. + * @param __n Number of characters to copy. + * @param __a Allocator to use. + */ + basic_string(const basic_string& __str, size_type __pos, + size_type __n, const _Alloc& __a); + + /** + * @brief Construct string initialized by a character %array. + * @param __s Source character %array. + * @param __n Number of characters to copy. + * @param __a Allocator to use (default is default allocator). + * + * NB: @a __s must have at least @a __n characters, '\\0' + * has no special meaning. + */ + basic_string(const _CharT* __s, size_type __n, + const _Alloc& __a = _Alloc()); + /** + * @brief Construct string as copy of a C string. + * @param __s Source C string. + * @param __a Allocator to use (default is default allocator). + */ + basic_string(const _CharT* __s, const _Alloc& __a = _Alloc()); + /** + * @brief Construct string as multiple characters. + * @param __n Number of characters. + * @param __c Character to use. + * @param __a Allocator to use (default is default allocator). + */ + basic_string(size_type __n, _CharT __c, const _Alloc& __a = _Alloc()); + +#if __cplusplus >= 201103L + /** + * @brief Move construct string. + * @param __str Source string. + * + * The newly-created string contains the exact contents of @a __str. + * @a __str is a valid, but unspecified string. + **/ + basic_string(basic_string&& __str) +#if _GLIBCXX_FULLY_DYNAMIC_STRING == 0 + noexcept // FIXME C++11: should always be noexcept. +#endif + : _M_dataplus(__str._M_dataplus) + { +#if _GLIBCXX_FULLY_DYNAMIC_STRING == 0 + __str._M_data(_S_empty_rep()._M_refdata()); +#else + __str._M_data(_S_construct(size_type(), _CharT(), get_allocator())); +#endif + } + + /** + * @brief Construct string from an initializer %list. + * @param __l std::initializer_list of characters. + * @param __a Allocator to use (default is default allocator). + */ + basic_string(initializer_list<_CharT> __l, const _Alloc& __a = _Alloc()); +#endif // C++11 + + /** + * @brief Construct string as copy of a range. + * @param __beg Start of range. + * @param __end End of range. + * @param __a Allocator to use (default is default allocator). + */ + template + basic_string(_InputIterator __beg, _InputIterator __end, + const _Alloc& __a = _Alloc()); + + /** + * @brief Destroy the string instance. + */ + ~basic_string() _GLIBCXX_NOEXCEPT + { _M_rep()->_M_dispose(this->get_allocator()); } + + /** + * @brief Assign the value of @a str to this string. + * @param __str Source string. + */ + basic_string& + operator=(const basic_string& __str) + { return this->assign(__str); } + + /** + * @brief Copy contents of @a s into this string. + * @param __s Source null-terminated string. + */ + basic_string& + operator=(const _CharT* __s) + { return this->assign(__s); } + + /** + * @brief Set value to string of length 1. + * @param __c Source character. + * + * Assigning to a character makes this string length 1 and + * (*this)[0] == @a c. + */ + basic_string& + operator=(_CharT __c) + { + this->assign(1, __c); + return *this; + } + +#if __cplusplus >= 201103L + /** + * @brief Move assign the value of @a str to this string. + * @param __str Source string. + * + * The contents of @a str are moved into this string (without copying). + * @a str is a valid, but unspecified string. + **/ + // PR 58265, this should be noexcept. + basic_string& + operator=(basic_string&& __str) + { + // NB: DR 1204. + this->swap(__str); + return *this; + } + + /** + * @brief Set value to string constructed from initializer %list. + * @param __l std::initializer_list. + */ + basic_string& + operator=(initializer_list<_CharT> __l) + { + this->assign(__l.begin(), __l.size()); + return *this; + } +#endif // C++11 + + // Iterators: + /** + * Returns a read/write iterator that points to the first character in + * the %string. Unshares the string. + */ + iterator + begin() // FIXME C++11: should be noexcept. + { + _M_leak(); + return iterator(_M_data()); + } + + /** + * Returns a read-only (constant) iterator that points to the first + * character in the %string. + */ + const_iterator + begin() const _GLIBCXX_NOEXCEPT + { return const_iterator(_M_data()); } + + /** + * Returns a read/write iterator that points one past the last + * character in the %string. Unshares the string. + */ + iterator + end() // FIXME C++11: should be noexcept. + { + _M_leak(); + return iterator(_M_data() + this->size()); + } + + /** + * Returns a read-only (constant) iterator that points one past the + * last character in the %string. + */ + const_iterator + end() const _GLIBCXX_NOEXCEPT + { return const_iterator(_M_data() + this->size()); } + + /** + * Returns a read/write reverse iterator that points to the last + * character in the %string. Iteration is done in reverse element + * order. Unshares the string. + */ + reverse_iterator + rbegin() // FIXME C++11: should be noexcept. + { return reverse_iterator(this->end()); } + + /** + * Returns a read-only (constant) reverse iterator that points + * to the last character in the %string. Iteration is done in + * reverse element order. + */ + const_reverse_iterator + rbegin() const _GLIBCXX_NOEXCEPT + { return const_reverse_iterator(this->end()); } + + /** + * Returns a read/write reverse iterator that points to one before the + * first character in the %string. Iteration is done in reverse + * element order. Unshares the string. + */ + reverse_iterator + rend() // FIXME C++11: should be noexcept. + { return reverse_iterator(this->begin()); } + + /** + * Returns a read-only (constant) reverse iterator that points + * to one before the first character in the %string. Iteration + * is done in reverse element order. + */ + const_reverse_iterator + rend() const _GLIBCXX_NOEXCEPT + { return const_reverse_iterator(this->begin()); } + +#if __cplusplus >= 201103L + /** + * Returns a read-only (constant) iterator that points to the first + * character in the %string. + */ + const_iterator + cbegin() const noexcept + { return const_iterator(this->_M_data()); } + + /** + * Returns a read-only (constant) iterator that points one past the + * last character in the %string. + */ + const_iterator + cend() const noexcept + { return const_iterator(this->_M_data() + this->size()); } + + /** + * Returns a read-only (constant) reverse iterator that points + * to the last character in the %string. Iteration is done in + * reverse element order. + */ + const_reverse_iterator + crbegin() const noexcept + { return const_reverse_iterator(this->end()); } + + /** + * Returns a read-only (constant) reverse iterator that points + * to one before the first character in the %string. Iteration + * is done in reverse element order. + */ + const_reverse_iterator + crend() const noexcept + { return const_reverse_iterator(this->begin()); } +#endif + + public: + // Capacity: + /// Returns the number of characters in the string, not including any + /// null-termination. + size_type + size() const _GLIBCXX_NOEXCEPT + { return _M_rep()->_M_length; } + + /// Returns the number of characters in the string, not including any + /// null-termination. + size_type + length() const _GLIBCXX_NOEXCEPT + { return _M_rep()->_M_length; } + + /// Returns the size() of the largest possible %string. + size_type + max_size() const _GLIBCXX_NOEXCEPT + { return _Rep::_S_max_size; } + + /** + * @brief Resizes the %string to the specified number of characters. + * @param __n Number of characters the %string should contain. + * @param __c Character to fill any new elements. + * + * This function will %resize the %string to the specified + * number of characters. If the number is smaller than the + * %string's current size the %string is truncated, otherwise + * the %string is extended and new elements are %set to @a __c. + */ + void + resize(size_type __n, _CharT __c); + + /** + * @brief Resizes the %string to the specified number of characters. + * @param __n Number of characters the %string should contain. + * + * This function will resize the %string to the specified length. If + * the new size is smaller than the %string's current size the %string + * is truncated, otherwise the %string is extended and new characters + * are default-constructed. For basic types such as char, this means + * setting them to 0. + */ + void + resize(size_type __n) + { this->resize(__n, _CharT()); } + +#if __cplusplus >= 201103L + /// A non-binding request to reduce capacity() to size(). + void + shrink_to_fit() _GLIBCXX_NOEXCEPT + { + if (capacity() > size()) + { + __try + { reserve(0); } + __catch(...) + { } + } + } +#endif + + /** + * Returns the total number of characters that the %string can hold + * before needing to allocate more memory. + */ + size_type + capacity() const _GLIBCXX_NOEXCEPT + { return _M_rep()->_M_capacity; } + + /** + * @brief Attempt to preallocate enough memory for specified number of + * characters. + * @param __res_arg Number of characters required. + * @throw std::length_error If @a __res_arg exceeds @c max_size(). + * + * This function attempts to reserve enough memory for the + * %string to hold the specified number of characters. If the + * number requested is more than max_size(), length_error is + * thrown. + * + * The advantage of this function is that if optimal code is a + * necessity and the user can determine the string length that will be + * required, the user can reserve the memory in %advance, and thus + * prevent a possible reallocation of memory and copying of %string + * data. + */ + void + reserve(size_type __res_arg = 0); + + /** + * Erases the string, making it empty. + */ + // PR 56166: this should not throw. + void + clear() + { _M_mutate(0, this->size(), 0); } + + /** + * Returns true if the %string is empty. Equivalent to + * *this == "". + */ + bool + empty() const _GLIBCXX_NOEXCEPT + { return this->size() == 0; } + + // Element access: + /** + * @brief Subscript access to the data contained in the %string. + * @param __pos The index of the character to access. + * @return Read-only (constant) reference to the character. + * + * This operator allows for easy, array-style, data access. + * Note that data access with this operator is unchecked and + * out_of_range lookups are not defined. (For checked lookups + * see at().) + */ + const_reference + operator[] (size_type __pos) const _GLIBCXX_NOEXCEPT + { + _GLIBCXX_DEBUG_ASSERT(__pos <= size()); + return _M_data()[__pos]; + } + + /** + * @brief Subscript access to the data contained in the %string. + * @param __pos The index of the character to access. + * @return Read/write reference to the character. + * + * This operator allows for easy, array-style, data access. + * Note that data access with this operator is unchecked and + * out_of_range lookups are not defined. (For checked lookups + * see at().) Unshares the string. + */ + reference + operator[](size_type __pos) + { + // Allow pos == size() both in C++98 mode, as v3 extension, + // and in C++11 mode. + _GLIBCXX_DEBUG_ASSERT(__pos <= size()); + // In pedantic mode be strict in C++98 mode. + _GLIBCXX_DEBUG_PEDASSERT(__cplusplus >= 201103L || __pos < size()); + _M_leak(); + return _M_data()[__pos]; + } + + /** + * @brief Provides access to the data contained in the %string. + * @param __n The index of the character to access. + * @return Read-only (const) reference to the character. + * @throw std::out_of_range If @a n is an invalid index. + * + * This function provides for safer data access. The parameter is + * first checked that it is in the range of the string. The function + * throws out_of_range if the check fails. + */ + const_reference + at(size_type __n) const + { + if (__n >= this->size()) + __throw_out_of_range_fmt(__N("basic_string::at: __n " + "(which is %zu) >= this->size() " + "(which is %zu)"), + __n, this->size()); + return _M_data()[__n]; + } + + /** + * @brief Provides access to the data contained in the %string. + * @param __n The index of the character to access. + * @return Read/write reference to the character. + * @throw std::out_of_range If @a n is an invalid index. + * + * This function provides for safer data access. The parameter is + * first checked that it is in the range of the string. The function + * throws out_of_range if the check fails. Success results in + * unsharing the string. + */ + reference + at(size_type __n) + { + if (__n >= size()) + __throw_out_of_range_fmt(__N("basic_string::at: __n " + "(which is %zu) >= this->size() " + "(which is %zu)"), + __n, this->size()); + _M_leak(); + return _M_data()[__n]; + } + +#if __cplusplus >= 201103L + /** + * Returns a read/write reference to the data at the first + * element of the %string. + */ + reference + front() + { return operator[](0); } + + /** + * Returns a read-only (constant) reference to the data at the first + * element of the %string. + */ + const_reference + front() const _GLIBCXX_NOEXCEPT + { return operator[](0); } + + /** + * Returns a read/write reference to the data at the last + * element of the %string. + */ + reference + back() + { return operator[](this->size() - 1); } + + /** + * Returns a read-only (constant) reference to the data at the + * last element of the %string. + */ + const_reference + back() const _GLIBCXX_NOEXCEPT + { return operator[](this->size() - 1); } +#endif + + // Modifiers: + /** + * @brief Append a string to this string. + * @param __str The string to append. + * @return Reference to this string. + */ + basic_string& + operator+=(const basic_string& __str) + { return this->append(__str); } + + /** + * @brief Append a C string. + * @param __s The C string to append. + * @return Reference to this string. + */ + basic_string& + operator+=(const _CharT* __s) + { return this->append(__s); } + + /** + * @brief Append a character. + * @param __c The character to append. + * @return Reference to this string. + */ + basic_string& + operator+=(_CharT __c) + { + this->push_back(__c); + return *this; + } + +#if __cplusplus >= 201103L + /** + * @brief Append an initializer_list of characters. + * @param __l The initializer_list of characters to be appended. + * @return Reference to this string. + */ + basic_string& + operator+=(initializer_list<_CharT> __l) + { return this->append(__l.begin(), __l.size()); } +#endif // C++11 + + /** + * @brief Append a string to this string. + * @param __str The string to append. + * @return Reference to this string. + */ + basic_string& + append(const basic_string& __str); + + /** + * @brief Append a substring. + * @param __str The string to append. + * @param __pos Index of the first character of str to append. + * @param __n The number of characters to append. + * @return Reference to this string. + * @throw std::out_of_range if @a __pos is not a valid index. + * + * This function appends @a __n characters from @a __str + * starting at @a __pos to this string. If @a __n is is larger + * than the number of available characters in @a __str, the + * remainder of @a __str is appended. + */ + basic_string& + append(const basic_string& __str, size_type __pos, size_type __n); + + /** + * @brief Append a C substring. + * @param __s The C string to append. + * @param __n The number of characters to append. + * @return Reference to this string. + */ + basic_string& + append(const _CharT* __s, size_type __n); + + /** + * @brief Append a C string. + * @param __s The C string to append. + * @return Reference to this string. + */ + basic_string& + append(const _CharT* __s) + { + __glibcxx_requires_string(__s); + return this->append(__s, traits_type::length(__s)); + } + + /** + * @brief Append multiple characters. + * @param __n The number of characters to append. + * @param __c The character to use. + * @return Reference to this string. + * + * Appends __n copies of __c to this string. + */ + basic_string& + append(size_type __n, _CharT __c); + +#if __cplusplus >= 201103L + /** + * @brief Append an initializer_list of characters. + * @param __l The initializer_list of characters to append. + * @return Reference to this string. + */ + basic_string& + append(initializer_list<_CharT> __l) + { return this->append(__l.begin(), __l.size()); } +#endif // C++11 + + /** + * @brief Append a range of characters. + * @param __first Iterator referencing the first character to append. + * @param __last Iterator marking the end of the range. + * @return Reference to this string. + * + * Appends characters in the range [__first,__last) to this string. + */ + template + basic_string& + append(_InputIterator __first, _InputIterator __last) + { return this->replace(_M_iend(), _M_iend(), __first, __last); } + + /** + * @brief Append a single character. + * @param __c Character to append. + */ + void + push_back(_CharT __c) + { + const size_type __len = 1 + this->size(); + if (__len > this->capacity() || _M_rep()->_M_is_shared()) + this->reserve(__len); + traits_type::assign(_M_data()[this->size()], __c); + _M_rep()->_M_set_length_and_sharable(__len); + } + + /** + * @brief Set value to contents of another string. + * @param __str Source string to use. + * @return Reference to this string. + */ + basic_string& + assign(const basic_string& __str); + +#if __cplusplus >= 201103L + /** + * @brief Set value to contents of another string. + * @param __str Source string to use. + * @return Reference to this string. + * + * This function sets this string to the exact contents of @a __str. + * @a __str is a valid, but unspecified string. + */ + // PR 58265, this should be noexcept. + basic_string& + assign(basic_string&& __str) + { + this->swap(__str); + return *this; + } +#endif // C++11 + + /** + * @brief Set value to a substring of a string. + * @param __str The string to use. + * @param __pos Index of the first character of str. + * @param __n Number of characters to use. + * @return Reference to this string. + * @throw std::out_of_range if @a pos is not a valid index. + * + * This function sets this string to the substring of @a __str + * consisting of @a __n characters at @a __pos. If @a __n is + * is larger than the number of available characters in @a + * __str, the remainder of @a __str is used. + */ + basic_string& + assign(const basic_string& __str, size_type __pos, size_type __n) + { return this->assign(__str._M_data() + + __str._M_check(__pos, "basic_string::assign"), + __str._M_limit(__pos, __n)); } + + /** + * @brief Set value to a C substring. + * @param __s The C string to use. + * @param __n Number of characters to use. + * @return Reference to this string. + * + * This function sets the value of this string to the first @a __n + * characters of @a __s. If @a __n is is larger than the number of + * available characters in @a __s, the remainder of @a __s is used. + */ + basic_string& + assign(const _CharT* __s, size_type __n); + + /** + * @brief Set value to contents of a C string. + * @param __s The C string to use. + * @return Reference to this string. + * + * This function sets the value of this string to the value of @a __s. + * The data is copied, so there is no dependence on @a __s once the + * function returns. + */ + basic_string& + assign(const _CharT* __s) + { + __glibcxx_requires_string(__s); + return this->assign(__s, traits_type::length(__s)); + } + + /** + * @brief Set value to multiple characters. + * @param __n Length of the resulting string. + * @param __c The character to use. + * @return Reference to this string. + * + * This function sets the value of this string to @a __n copies of + * character @a __c. + */ + basic_string& + assign(size_type __n, _CharT __c) + { return _M_replace_aux(size_type(0), this->size(), __n, __c); } + + /** + * @brief Set value to a range of characters. + * @param __first Iterator referencing the first character to append. + * @param __last Iterator marking the end of the range. + * @return Reference to this string. + * + * Sets value of string to characters in the range [__first,__last). + */ + template + basic_string& + assign(_InputIterator __first, _InputIterator __last) + { return this->replace(_M_ibegin(), _M_iend(), __first, __last); } + +#if __cplusplus >= 201103L + /** + * @brief Set value to an initializer_list of characters. + * @param __l The initializer_list of characters to assign. + * @return Reference to this string. + */ + basic_string& + assign(initializer_list<_CharT> __l) + { return this->assign(__l.begin(), __l.size()); } +#endif // C++11 + + /** + * @brief Insert multiple characters. + * @param __p Iterator referencing location in string to insert at. + * @param __n Number of characters to insert + * @param __c The character to insert. + * @throw std::length_error If new length exceeds @c max_size(). + * + * Inserts @a __n copies of character @a __c starting at the + * position referenced by iterator @a __p. If adding + * characters causes the length to exceed max_size(), + * length_error is thrown. The value of the string doesn't + * change if an error is thrown. + */ + void + insert(iterator __p, size_type __n, _CharT __c) + { this->replace(__p, __p, __n, __c); } + + /** + * @brief Insert a range of characters. + * @param __p Iterator referencing location in string to insert at. + * @param __beg Start of range. + * @param __end End of range. + * @throw std::length_error If new length exceeds @c max_size(). + * + * Inserts characters in range [__beg,__end). If adding + * characters causes the length to exceed max_size(), + * length_error is thrown. The value of the string doesn't + * change if an error is thrown. + */ + template + void + insert(iterator __p, _InputIterator __beg, _InputIterator __end) + { this->replace(__p, __p, __beg, __end); } + +#if __cplusplus >= 201103L + /** + * @brief Insert an initializer_list of characters. + * @param __p Iterator referencing location in string to insert at. + * @param __l The initializer_list of characters to insert. + * @throw std::length_error If new length exceeds @c max_size(). + */ + void + insert(iterator __p, initializer_list<_CharT> __l) + { + _GLIBCXX_DEBUG_PEDASSERT(__p >= _M_ibegin() && __p <= _M_iend()); + this->insert(__p - _M_ibegin(), __l.begin(), __l.size()); + } +#endif // C++11 + + /** + * @brief Insert value of a string. + * @param __pos1 Iterator referencing location in string to insert at. + * @param __str The string to insert. + * @return Reference to this string. + * @throw std::length_error If new length exceeds @c max_size(). + * + * Inserts value of @a __str starting at @a __pos1. If adding + * characters causes the length to exceed max_size(), + * length_error is thrown. The value of the string doesn't + * change if an error is thrown. + */ + basic_string& + insert(size_type __pos1, const basic_string& __str) + { return this->insert(__pos1, __str, size_type(0), __str.size()); } + + /** + * @brief Insert a substring. + * @param __pos1 Iterator referencing location in string to insert at. + * @param __str The string to insert. + * @param __pos2 Start of characters in str to insert. + * @param __n Number of characters to insert. + * @return Reference to this string. + * @throw std::length_error If new length exceeds @c max_size(). + * @throw std::out_of_range If @a pos1 > size() or + * @a __pos2 > @a str.size(). + * + * Starting at @a pos1, insert @a __n character of @a __str + * beginning with @a __pos2. If adding characters causes the + * length to exceed max_size(), length_error is thrown. If @a + * __pos1 is beyond the end of this string or @a __pos2 is + * beyond the end of @a __str, out_of_range is thrown. The + * value of the string doesn't change if an error is thrown. + */ + basic_string& + insert(size_type __pos1, const basic_string& __str, + size_type __pos2, size_type __n) + { return this->insert(__pos1, __str._M_data() + + __str._M_check(__pos2, "basic_string::insert"), + __str._M_limit(__pos2, __n)); } + + /** + * @brief Insert a C substring. + * @param __pos Iterator referencing location in string to insert at. + * @param __s The C string to insert. + * @param __n The number of characters to insert. + * @return Reference to this string. + * @throw std::length_error If new length exceeds @c max_size(). + * @throw std::out_of_range If @a __pos is beyond the end of this + * string. + * + * Inserts the first @a __n characters of @a __s starting at @a + * __pos. If adding characters causes the length to exceed + * max_size(), length_error is thrown. If @a __pos is beyond + * end(), out_of_range is thrown. The value of the string + * doesn't change if an error is thrown. + */ + basic_string& + insert(size_type __pos, const _CharT* __s, size_type __n); + + /** + * @brief Insert a C string. + * @param __pos Iterator referencing location in string to insert at. + * @param __s The C string to insert. + * @return Reference to this string. + * @throw std::length_error If new length exceeds @c max_size(). + * @throw std::out_of_range If @a pos is beyond the end of this + * string. + * + * Inserts the first @a n characters of @a __s starting at @a __pos. If + * adding characters causes the length to exceed max_size(), + * length_error is thrown. If @a __pos is beyond end(), out_of_range is + * thrown. The value of the string doesn't change if an error is + * thrown. + */ + basic_string& + insert(size_type __pos, const _CharT* __s) + { + __glibcxx_requires_string(__s); + return this->insert(__pos, __s, traits_type::length(__s)); + } + + /** + * @brief Insert multiple characters. + * @param __pos Index in string to insert at. + * @param __n Number of characters to insert + * @param __c The character to insert. + * @return Reference to this string. + * @throw std::length_error If new length exceeds @c max_size(). + * @throw std::out_of_range If @a __pos is beyond the end of this + * string. + * + * Inserts @a __n copies of character @a __c starting at index + * @a __pos. If adding characters causes the length to exceed + * max_size(), length_error is thrown. If @a __pos > length(), + * out_of_range is thrown. The value of the string doesn't + * change if an error is thrown. + */ + basic_string& + insert(size_type __pos, size_type __n, _CharT __c) + { return _M_replace_aux(_M_check(__pos, "basic_string::insert"), + size_type(0), __n, __c); } + + /** + * @brief Insert one character. + * @param __p Iterator referencing position in string to insert at. + * @param __c The character to insert. + * @return Iterator referencing newly inserted char. + * @throw std::length_error If new length exceeds @c max_size(). + * + * Inserts character @a __c at position referenced by @a __p. + * If adding character causes the length to exceed max_size(), + * length_error is thrown. If @a __p is beyond end of string, + * out_of_range is thrown. The value of the string doesn't + * change if an error is thrown. + */ + iterator + insert(iterator __p, _CharT __c) + { + _GLIBCXX_DEBUG_PEDASSERT(__p >= _M_ibegin() && __p <= _M_iend()); + const size_type __pos = __p - _M_ibegin(); + _M_replace_aux(__pos, size_type(0), size_type(1), __c); + _M_rep()->_M_set_leaked(); + return iterator(_M_data() + __pos); + } + + /** + * @brief Remove characters. + * @param __pos Index of first character to remove (default 0). + * @param __n Number of characters to remove (default remainder). + * @return Reference to this string. + * @throw std::out_of_range If @a pos is beyond the end of this + * string. + * + * Removes @a __n characters from this string starting at @a + * __pos. The length of the string is reduced by @a __n. If + * there are < @a __n characters to remove, the remainder of + * the string is truncated. If @a __p is beyond end of string, + * out_of_range is thrown. The value of the string doesn't + * change if an error is thrown. + */ + basic_string& + erase(size_type __pos = 0, size_type __n = npos) + { + _M_mutate(_M_check(__pos, "basic_string::erase"), + _M_limit(__pos, __n), size_type(0)); + return *this; + } + + /** + * @brief Remove one character. + * @param __position Iterator referencing the character to remove. + * @return iterator referencing same location after removal. + * + * Removes the character at @a __position from this string. The value + * of the string doesn't change if an error is thrown. + */ + iterator + erase(iterator __position) + { + _GLIBCXX_DEBUG_PEDASSERT(__position >= _M_ibegin() + && __position < _M_iend()); + const size_type __pos = __position - _M_ibegin(); + _M_mutate(__pos, size_type(1), size_type(0)); + _M_rep()->_M_set_leaked(); + return iterator(_M_data() + __pos); + } + + /** + * @brief Remove a range of characters. + * @param __first Iterator referencing the first character to remove. + * @param __last Iterator referencing the end of the range. + * @return Iterator referencing location of first after removal. + * + * Removes the characters in the range [first,last) from this string. + * The value of the string doesn't change if an error is thrown. + */ + iterator + erase(iterator __first, iterator __last); + +#if __cplusplus >= 201103L + /** + * @brief Remove the last character. + * + * The string must be non-empty. + */ + void + pop_back() // FIXME C++11: should be noexcept. + { erase(size()-1, 1); } +#endif // C++11 + + /** + * @brief Replace characters with value from another string. + * @param __pos Index of first character to replace. + * @param __n Number of characters to be replaced. + * @param __str String to insert. + * @return Reference to this string. + * @throw std::out_of_range If @a pos is beyond the end of this + * string. + * @throw std::length_error If new length exceeds @c max_size(). + * + * Removes the characters in the range [__pos,__pos+__n) from + * this string. In place, the value of @a __str is inserted. + * If @a __pos is beyond end of string, out_of_range is thrown. + * If the length of the result exceeds max_size(), length_error + * is thrown. The value of the string doesn't change if an + * error is thrown. + */ + basic_string& + replace(size_type __pos, size_type __n, const basic_string& __str) + { return this->replace(__pos, __n, __str._M_data(), __str.size()); } + + /** + * @brief Replace characters with value from another string. + * @param __pos1 Index of first character to replace. + * @param __n1 Number of characters to be replaced. + * @param __str String to insert. + * @param __pos2 Index of first character of str to use. + * @param __n2 Number of characters from str to use. + * @return Reference to this string. + * @throw std::out_of_range If @a __pos1 > size() or @a __pos2 > + * __str.size(). + * @throw std::length_error If new length exceeds @c max_size(). + * + * Removes the characters in the range [__pos1,__pos1 + n) from this + * string. In place, the value of @a __str is inserted. If @a __pos is + * beyond end of string, out_of_range is thrown. If the length of the + * result exceeds max_size(), length_error is thrown. The value of the + * string doesn't change if an error is thrown. + */ + basic_string& + replace(size_type __pos1, size_type __n1, const basic_string& __str, + size_type __pos2, size_type __n2) + { return this->replace(__pos1, __n1, __str._M_data() + + __str._M_check(__pos2, "basic_string::replace"), + __str._M_limit(__pos2, __n2)); } + + /** + * @brief Replace characters with value of a C substring. + * @param __pos Index of first character to replace. + * @param __n1 Number of characters to be replaced. + * @param __s C string to insert. + * @param __n2 Number of characters from @a s to use. + * @return Reference to this string. + * @throw std::out_of_range If @a pos1 > size(). + * @throw std::length_error If new length exceeds @c max_size(). + * + * Removes the characters in the range [__pos,__pos + __n1) + * from this string. In place, the first @a __n2 characters of + * @a __s are inserted, or all of @a __s if @a __n2 is too large. If + * @a __pos is beyond end of string, out_of_range is thrown. If + * the length of result exceeds max_size(), length_error is + * thrown. The value of the string doesn't change if an error + * is thrown. + */ + basic_string& + replace(size_type __pos, size_type __n1, const _CharT* __s, + size_type __n2); + + /** + * @brief Replace characters with value of a C string. + * @param __pos Index of first character to replace. + * @param __n1 Number of characters to be replaced. + * @param __s C string to insert. + * @return Reference to this string. + * @throw std::out_of_range If @a pos > size(). + * @throw std::length_error If new length exceeds @c max_size(). + * + * Removes the characters in the range [__pos,__pos + __n1) + * from this string. In place, the characters of @a __s are + * inserted. If @a __pos is beyond end of string, out_of_range + * is thrown. If the length of result exceeds max_size(), + * length_error is thrown. The value of the string doesn't + * change if an error is thrown. + */ + basic_string& + replace(size_type __pos, size_type __n1, const _CharT* __s) + { + __glibcxx_requires_string(__s); + return this->replace(__pos, __n1, __s, traits_type::length(__s)); + } + + /** + * @brief Replace characters with multiple characters. + * @param __pos Index of first character to replace. + * @param __n1 Number of characters to be replaced. + * @param __n2 Number of characters to insert. + * @param __c Character to insert. + * @return Reference to this string. + * @throw std::out_of_range If @a __pos > size(). + * @throw std::length_error If new length exceeds @c max_size(). + * + * Removes the characters in the range [pos,pos + n1) from this + * string. In place, @a __n2 copies of @a __c are inserted. + * If @a __pos is beyond end of string, out_of_range is thrown. + * If the length of result exceeds max_size(), length_error is + * thrown. The value of the string doesn't change if an error + * is thrown. + */ + basic_string& + replace(size_type __pos, size_type __n1, size_type __n2, _CharT __c) + { return _M_replace_aux(_M_check(__pos, "basic_string::replace"), + _M_limit(__pos, __n1), __n2, __c); } + + /** + * @brief Replace range of characters with string. + * @param __i1 Iterator referencing start of range to replace. + * @param __i2 Iterator referencing end of range to replace. + * @param __str String value to insert. + * @return Reference to this string. + * @throw std::length_error If new length exceeds @c max_size(). + * + * Removes the characters in the range [__i1,__i2). In place, + * the value of @a __str is inserted. If the length of result + * exceeds max_size(), length_error is thrown. The value of + * the string doesn't change if an error is thrown. + */ + basic_string& + replace(iterator __i1, iterator __i2, const basic_string& __str) + { return this->replace(__i1, __i2, __str._M_data(), __str.size()); } + + /** + * @brief Replace range of characters with C substring. + * @param __i1 Iterator referencing start of range to replace. + * @param __i2 Iterator referencing end of range to replace. + * @param __s C string value to insert. + * @param __n Number of characters from s to insert. + * @return Reference to this string. + * @throw std::length_error If new length exceeds @c max_size(). + * + * Removes the characters in the range [__i1,__i2). In place, + * the first @a __n characters of @a __s are inserted. If the + * length of result exceeds max_size(), length_error is thrown. + * The value of the string doesn't change if an error is + * thrown. + */ + basic_string& + replace(iterator __i1, iterator __i2, const _CharT* __s, size_type __n) + { + _GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1 && __i1 <= __i2 + && __i2 <= _M_iend()); + return this->replace(__i1 - _M_ibegin(), __i2 - __i1, __s, __n); + } + + /** + * @brief Replace range of characters with C string. + * @param __i1 Iterator referencing start of range to replace. + * @param __i2 Iterator referencing end of range to replace. + * @param __s C string value to insert. + * @return Reference to this string. + * @throw std::length_error If new length exceeds @c max_size(). + * + * Removes the characters in the range [__i1,__i2). In place, + * the characters of @a __s are inserted. If the length of + * result exceeds max_size(), length_error is thrown. The + * value of the string doesn't change if an error is thrown. + */ + basic_string& + replace(iterator __i1, iterator __i2, const _CharT* __s) + { + __glibcxx_requires_string(__s); + return this->replace(__i1, __i2, __s, traits_type::length(__s)); + } + + /** + * @brief Replace range of characters with multiple characters + * @param __i1 Iterator referencing start of range to replace. + * @param __i2 Iterator referencing end of range to replace. + * @param __n Number of characters to insert. + * @param __c Character to insert. + * @return Reference to this string. + * @throw std::length_error If new length exceeds @c max_size(). + * + * Removes the characters in the range [__i1,__i2). In place, + * @a __n copies of @a __c are inserted. If the length of + * result exceeds max_size(), length_error is thrown. The + * value of the string doesn't change if an error is thrown. + */ + basic_string& + replace(iterator __i1, iterator __i2, size_type __n, _CharT __c) + { + _GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1 && __i1 <= __i2 + && __i2 <= _M_iend()); + return _M_replace_aux(__i1 - _M_ibegin(), __i2 - __i1, __n, __c); + } + + /** + * @brief Replace range of characters with range. + * @param __i1 Iterator referencing start of range to replace. + * @param __i2 Iterator referencing end of range to replace. + * @param __k1 Iterator referencing start of range to insert. + * @param __k2 Iterator referencing end of range to insert. + * @return Reference to this string. + * @throw std::length_error If new length exceeds @c max_size(). + * + * Removes the characters in the range [__i1,__i2). In place, + * characters in the range [__k1,__k2) are inserted. If the + * length of result exceeds max_size(), length_error is thrown. + * The value of the string doesn't change if an error is + * thrown. + */ + template + basic_string& + replace(iterator __i1, iterator __i2, + _InputIterator __k1, _InputIterator __k2) + { + _GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1 && __i1 <= __i2 + && __i2 <= _M_iend()); + __glibcxx_requires_valid_range(__k1, __k2); + typedef typename std::__is_integer<_InputIterator>::__type _Integral; + return _M_replace_dispatch(__i1, __i2, __k1, __k2, _Integral()); + } + + // Specializations for the common case of pointer and iterator: + // useful to avoid the overhead of temporary buffering in _M_replace. + basic_string& + replace(iterator __i1, iterator __i2, _CharT* __k1, _CharT* __k2) + { + _GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1 && __i1 <= __i2 + && __i2 <= _M_iend()); + __glibcxx_requires_valid_range(__k1, __k2); + return this->replace(__i1 - _M_ibegin(), __i2 - __i1, + __k1, __k2 - __k1); + } + + basic_string& + replace(iterator __i1, iterator __i2, + const _CharT* __k1, const _CharT* __k2) + { + _GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1 && __i1 <= __i2 + && __i2 <= _M_iend()); + __glibcxx_requires_valid_range(__k1, __k2); + return this->replace(__i1 - _M_ibegin(), __i2 - __i1, + __k1, __k2 - __k1); + } + + basic_string& + replace(iterator __i1, iterator __i2, iterator __k1, iterator __k2) + { + _GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1 && __i1 <= __i2 + && __i2 <= _M_iend()); + __glibcxx_requires_valid_range(__k1, __k2); + return this->replace(__i1 - _M_ibegin(), __i2 - __i1, + __k1.base(), __k2 - __k1); + } + + basic_string& + replace(iterator __i1, iterator __i2, + const_iterator __k1, const_iterator __k2) + { + _GLIBCXX_DEBUG_PEDASSERT(_M_ibegin() <= __i1 && __i1 <= __i2 + && __i2 <= _M_iend()); + __glibcxx_requires_valid_range(__k1, __k2); + return this->replace(__i1 - _M_ibegin(), __i2 - __i1, + __k1.base(), __k2 - __k1); + } + +#if __cplusplus >= 201103L + /** + * @brief Replace range of characters with initializer_list. + * @param __i1 Iterator referencing start of range to replace. + * @param __i2 Iterator referencing end of range to replace. + * @param __l The initializer_list of characters to insert. + * @return Reference to this string. + * @throw std::length_error If new length exceeds @c max_size(). + * + * Removes the characters in the range [__i1,__i2). In place, + * characters in the range [__k1,__k2) are inserted. If the + * length of result exceeds max_size(), length_error is thrown. + * The value of the string doesn't change if an error is + * thrown. + */ + basic_string& replace(iterator __i1, iterator __i2, + initializer_list<_CharT> __l) + { return this->replace(__i1, __i2, __l.begin(), __l.end()); } +#endif // C++11 + + private: + template + basic_string& + _M_replace_dispatch(iterator __i1, iterator __i2, _Integer __n, + _Integer __val, __true_type) + { return _M_replace_aux(__i1 - _M_ibegin(), __i2 - __i1, __n, __val); } + + template + basic_string& + _M_replace_dispatch(iterator __i1, iterator __i2, _InputIterator __k1, + _InputIterator __k2, __false_type); + + basic_string& + _M_replace_aux(size_type __pos1, size_type __n1, size_type __n2, + _CharT __c); + + basic_string& + _M_replace_safe(size_type __pos1, size_type __n1, const _CharT* __s, + size_type __n2); + + // _S_construct_aux is used to implement the 21.3.1 para 15 which + // requires special behaviour if _InIter is an integral type + template + static _CharT* + _S_construct_aux(_InIterator __beg, _InIterator __end, + const _Alloc& __a, __false_type) + { + typedef typename iterator_traits<_InIterator>::iterator_category _Tag; + return _S_construct(__beg, __end, __a, _Tag()); + } + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 438. Ambiguity in the "do the right thing" clause + template + static _CharT* + _S_construct_aux(_Integer __beg, _Integer __end, + const _Alloc& __a, __true_type) + { return _S_construct_aux_2(static_cast(__beg), + __end, __a); } + + static _CharT* + _S_construct_aux_2(size_type __req, _CharT __c, const _Alloc& __a) + { return _S_construct(__req, __c, __a); } + + template + static _CharT* + _S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a) + { + typedef typename std::__is_integer<_InIterator>::__type _Integral; + return _S_construct_aux(__beg, __end, __a, _Integral()); + } + + // For Input Iterators, used in istreambuf_iterators, etc. + template + static _CharT* + _S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a, + input_iterator_tag); + + // For forward_iterators up to random_access_iterators, used for + // string::iterator, _CharT*, etc. + template + static _CharT* + _S_construct(_FwdIterator __beg, _FwdIterator __end, const _Alloc& __a, + forward_iterator_tag); + + static _CharT* + _S_construct(size_type __req, _CharT __c, const _Alloc& __a); + + public: + + /** + * @brief Copy substring into C string. + * @param __s C string to copy value into. + * @param __n Number of characters to copy. + * @param __pos Index of first character to copy. + * @return Number of characters actually copied + * @throw std::out_of_range If __pos > size(). + * + * Copies up to @a __n characters starting at @a __pos into the + * C string @a __s. If @a __pos is %greater than size(), + * out_of_range is thrown. + */ + size_type + copy(_CharT* __s, size_type __n, size_type __pos = 0) const; + + /** + * @brief Swap contents with another string. + * @param __s String to swap with. + * + * Exchanges the contents of this string with that of @a __s in constant + * time. + */ + // PR 58265, this should be noexcept. + void + swap(basic_string& __s); + + // String operations: + /** + * @brief Return const pointer to null-terminated contents. + * + * This is a handle to internal data. Do not modify or dire things may + * happen. + */ + const _CharT* + c_str() const _GLIBCXX_NOEXCEPT + { return _M_data(); } + + /** + * @brief Return const pointer to contents. + * + * This is a handle to internal data. Do not modify or dire things may + * happen. + */ + const _CharT* + data() const _GLIBCXX_NOEXCEPT + { return _M_data(); } + + /** + * @brief Return copy of allocator used to construct this string. + */ + allocator_type + get_allocator() const _GLIBCXX_NOEXCEPT + { return _M_dataplus; } + + /** + * @brief Find position of a C substring. + * @param __s C string to locate. + * @param __pos Index of character to search from. + * @param __n Number of characters from @a s to search for. + * @return Index of start of first occurrence. + * + * Starting from @a __pos, searches forward for the first @a + * __n characters in @a __s within this string. If found, + * returns the index where it begins. If not found, returns + * npos. + */ + size_type + find(const _CharT* __s, size_type __pos, size_type __n) const; + + /** + * @brief Find position of a string. + * @param __str String to locate. + * @param __pos Index of character to search from (default 0). + * @return Index of start of first occurrence. + * + * Starting from @a __pos, searches forward for value of @a __str within + * this string. If found, returns the index where it begins. If not + * found, returns npos. + */ + size_type + find(const basic_string& __str, size_type __pos = 0) const + _GLIBCXX_NOEXCEPT + { return this->find(__str.data(), __pos, __str.size()); } + + /** + * @brief Find position of a C string. + * @param __s C string to locate. + * @param __pos Index of character to search from (default 0). + * @return Index of start of first occurrence. + * + * Starting from @a __pos, searches forward for the value of @a + * __s within this string. If found, returns the index where + * it begins. If not found, returns npos. + */ + size_type + find(const _CharT* __s, size_type __pos = 0) const + { + __glibcxx_requires_string(__s); + return this->find(__s, __pos, traits_type::length(__s)); + } + + /** + * @brief Find position of a character. + * @param __c Character to locate. + * @param __pos Index of character to search from (default 0). + * @return Index of first occurrence. + * + * Starting from @a __pos, searches forward for @a __c within + * this string. If found, returns the index where it was + * found. If not found, returns npos. + */ + size_type + find(_CharT __c, size_type __pos = 0) const _GLIBCXX_NOEXCEPT; + + /** + * @brief Find last position of a string. + * @param __str String to locate. + * @param __pos Index of character to search back from (default end). + * @return Index of start of last occurrence. + * + * Starting from @a __pos, searches backward for value of @a + * __str within this string. If found, returns the index where + * it begins. If not found, returns npos. + */ + size_type + rfind(const basic_string& __str, size_type __pos = npos) const + _GLIBCXX_NOEXCEPT + { return this->rfind(__str.data(), __pos, __str.size()); } + + /** + * @brief Find last position of a C substring. + * @param __s C string to locate. + * @param __pos Index of character to search back from. + * @param __n Number of characters from s to search for. + * @return Index of start of last occurrence. + * + * Starting from @a __pos, searches backward for the first @a + * __n characters in @a __s within this string. If found, + * returns the index where it begins. If not found, returns + * npos. + */ + size_type + rfind(const _CharT* __s, size_type __pos, size_type __n) const; + + /** + * @brief Find last position of a C string. + * @param __s C string to locate. + * @param __pos Index of character to start search at (default end). + * @return Index of start of last occurrence. + * + * Starting from @a __pos, searches backward for the value of + * @a __s within this string. If found, returns the index + * where it begins. If not found, returns npos. + */ + size_type + rfind(const _CharT* __s, size_type __pos = npos) const + { + __glibcxx_requires_string(__s); + return this->rfind(__s, __pos, traits_type::length(__s)); + } + + /** + * @brief Find last position of a character. + * @param __c Character to locate. + * @param __pos Index of character to search back from (default end). + * @return Index of last occurrence. + * + * Starting from @a __pos, searches backward for @a __c within + * this string. If found, returns the index where it was + * found. If not found, returns npos. + */ + size_type + rfind(_CharT __c, size_type __pos = npos) const _GLIBCXX_NOEXCEPT; + + /** + * @brief Find position of a character of string. + * @param __str String containing characters to locate. + * @param __pos Index of character to search from (default 0). + * @return Index of first occurrence. + * + * Starting from @a __pos, searches forward for one of the + * characters of @a __str within this string. If found, + * returns the index where it was found. If not found, returns + * npos. + */ + size_type + find_first_of(const basic_string& __str, size_type __pos = 0) const + _GLIBCXX_NOEXCEPT + { return this->find_first_of(__str.data(), __pos, __str.size()); } + + /** + * @brief Find position of a character of C substring. + * @param __s String containing characters to locate. + * @param __pos Index of character to search from. + * @param __n Number of characters from s to search for. + * @return Index of first occurrence. + * + * Starting from @a __pos, searches forward for one of the + * first @a __n characters of @a __s within this string. If + * found, returns the index where it was found. If not found, + * returns npos. + */ + size_type + find_first_of(const _CharT* __s, size_type __pos, size_type __n) const; + + /** + * @brief Find position of a character of C string. + * @param __s String containing characters to locate. + * @param __pos Index of character to search from (default 0). + * @return Index of first occurrence. + * + * Starting from @a __pos, searches forward for one of the + * characters of @a __s within this string. If found, returns + * the index where it was found. If not found, returns npos. + */ + size_type + find_first_of(const _CharT* __s, size_type __pos = 0) const + { + __glibcxx_requires_string(__s); + return this->find_first_of(__s, __pos, traits_type::length(__s)); + } + + /** + * @brief Find position of a character. + * @param __c Character to locate. + * @param __pos Index of character to search from (default 0). + * @return Index of first occurrence. + * + * Starting from @a __pos, searches forward for the character + * @a __c within this string. If found, returns the index + * where it was found. If not found, returns npos. + * + * Note: equivalent to find(__c, __pos). + */ + size_type + find_first_of(_CharT __c, size_type __pos = 0) const _GLIBCXX_NOEXCEPT + { return this->find(__c, __pos); } + + /** + * @brief Find last position of a character of string. + * @param __str String containing characters to locate. + * @param __pos Index of character to search back from (default end). + * @return Index of last occurrence. + * + * Starting from @a __pos, searches backward for one of the + * characters of @a __str within this string. If found, + * returns the index where it was found. If not found, returns + * npos. + */ + size_type + find_last_of(const basic_string& __str, size_type __pos = npos) const + _GLIBCXX_NOEXCEPT + { return this->find_last_of(__str.data(), __pos, __str.size()); } + + /** + * @brief Find last position of a character of C substring. + * @param __s C string containing characters to locate. + * @param __pos Index of character to search back from. + * @param __n Number of characters from s to search for. + * @return Index of last occurrence. + * + * Starting from @a __pos, searches backward for one of the + * first @a __n characters of @a __s within this string. If + * found, returns the index where it was found. If not found, + * returns npos. + */ + size_type + find_last_of(const _CharT* __s, size_type __pos, size_type __n) const; + + /** + * @brief Find last position of a character of C string. + * @param __s C string containing characters to locate. + * @param __pos Index of character to search back from (default end). + * @return Index of last occurrence. + * + * Starting from @a __pos, searches backward for one of the + * characters of @a __s within this string. If found, returns + * the index where it was found. If not found, returns npos. + */ + size_type + find_last_of(const _CharT* __s, size_type __pos = npos) const + { + __glibcxx_requires_string(__s); + return this->find_last_of(__s, __pos, traits_type::length(__s)); + } + + /** + * @brief Find last position of a character. + * @param __c Character to locate. + * @param __pos Index of character to search back from (default end). + * @return Index of last occurrence. + * + * Starting from @a __pos, searches backward for @a __c within + * this string. If found, returns the index where it was + * found. If not found, returns npos. + * + * Note: equivalent to rfind(__c, __pos). + */ + size_type + find_last_of(_CharT __c, size_type __pos = npos) const _GLIBCXX_NOEXCEPT + { return this->rfind(__c, __pos); } + + /** + * @brief Find position of a character not in string. + * @param __str String containing characters to avoid. + * @param __pos Index of character to search from (default 0). + * @return Index of first occurrence. + * + * Starting from @a __pos, searches forward for a character not contained + * in @a __str within this string. If found, returns the index where it + * was found. If not found, returns npos. + */ + size_type + find_first_not_of(const basic_string& __str, size_type __pos = 0) const + _GLIBCXX_NOEXCEPT + { return this->find_first_not_of(__str.data(), __pos, __str.size()); } + + /** + * @brief Find position of a character not in C substring. + * @param __s C string containing characters to avoid. + * @param __pos Index of character to search from. + * @param __n Number of characters from __s to consider. + * @return Index of first occurrence. + * + * Starting from @a __pos, searches forward for a character not + * contained in the first @a __n characters of @a __s within + * this string. If found, returns the index where it was + * found. If not found, returns npos. + */ + size_type + find_first_not_of(const _CharT* __s, size_type __pos, + size_type __n) const; + + /** + * @brief Find position of a character not in C string. + * @param __s C string containing characters to avoid. + * @param __pos Index of character to search from (default 0). + * @return Index of first occurrence. + * + * Starting from @a __pos, searches forward for a character not + * contained in @a __s within this string. If found, returns + * the index where it was found. If not found, returns npos. + */ + size_type + find_first_not_of(const _CharT* __s, size_type __pos = 0) const + { + __glibcxx_requires_string(__s); + return this->find_first_not_of(__s, __pos, traits_type::length(__s)); + } + + /** + * @brief Find position of a different character. + * @param __c Character to avoid. + * @param __pos Index of character to search from (default 0). + * @return Index of first occurrence. + * + * Starting from @a __pos, searches forward for a character + * other than @a __c within this string. If found, returns the + * index where it was found. If not found, returns npos. + */ + size_type + find_first_not_of(_CharT __c, size_type __pos = 0) const + _GLIBCXX_NOEXCEPT; + + /** + * @brief Find last position of a character not in string. + * @param __str String containing characters to avoid. + * @param __pos Index of character to search back from (default end). + * @return Index of last occurrence. + * + * Starting from @a __pos, searches backward for a character + * not contained in @a __str within this string. If found, + * returns the index where it was found. If not found, returns + * npos. + */ + size_type + find_last_not_of(const basic_string& __str, size_type __pos = npos) const + _GLIBCXX_NOEXCEPT + { return this->find_last_not_of(__str.data(), __pos, __str.size()); } + + /** + * @brief Find last position of a character not in C substring. + * @param __s C string containing characters to avoid. + * @param __pos Index of character to search back from. + * @param __n Number of characters from s to consider. + * @return Index of last occurrence. + * + * Starting from @a __pos, searches backward for a character not + * contained in the first @a __n characters of @a __s within this string. + * If found, returns the index where it was found. If not found, + * returns npos. + */ + size_type + find_last_not_of(const _CharT* __s, size_type __pos, + size_type __n) const; + /** + * @brief Find last position of a character not in C string. + * @param __s C string containing characters to avoid. + * @param __pos Index of character to search back from (default end). + * @return Index of last occurrence. + * + * Starting from @a __pos, searches backward for a character + * not contained in @a __s within this string. If found, + * returns the index where it was found. If not found, returns + * npos. + */ + size_type + find_last_not_of(const _CharT* __s, size_type __pos = npos) const + { + __glibcxx_requires_string(__s); + return this->find_last_not_of(__s, __pos, traits_type::length(__s)); + } + + /** + * @brief Find last position of a different character. + * @param __c Character to avoid. + * @param __pos Index of character to search back from (default end). + * @return Index of last occurrence. + * + * Starting from @a __pos, searches backward for a character other than + * @a __c within this string. If found, returns the index where it was + * found. If not found, returns npos. + */ + size_type + find_last_not_of(_CharT __c, size_type __pos = npos) const + _GLIBCXX_NOEXCEPT; + + /** + * @brief Get a substring. + * @param __pos Index of first character (default 0). + * @param __n Number of characters in substring (default remainder). + * @return The new string. + * @throw std::out_of_range If __pos > size(). + * + * Construct and return a new string using the @a __n + * characters starting at @a __pos. If the string is too + * short, use the remainder of the characters. If @a __pos is + * beyond the end of the string, out_of_range is thrown. + */ + basic_string + substr(size_type __pos = 0, size_type __n = npos) const + { return basic_string(*this, + _M_check(__pos, "basic_string::substr"), __n); } + + /** + * @brief Compare to a string. + * @param __str String to compare against. + * @return Integer < 0, 0, or > 0. + * + * Returns an integer < 0 if this string is ordered before @a + * __str, 0 if their values are equivalent, or > 0 if this + * string is ordered after @a __str. Determines the effective + * length rlen of the strings to compare as the smallest of + * size() and str.size(). The function then compares the two + * strings by calling traits::compare(data(), str.data(),rlen). + * If the result of the comparison is nonzero returns it, + * otherwise the shorter one is ordered first. + */ + int + compare(const basic_string& __str) const + { + const size_type __size = this->size(); + const size_type __osize = __str.size(); + const size_type __len = std::min(__size, __osize); + + int __r = traits_type::compare(_M_data(), __str.data(), __len); + if (!__r) + __r = _S_compare(__size, __osize); + return __r; + } + + /** + * @brief Compare substring to a string. + * @param __pos Index of first character of substring. + * @param __n Number of characters in substring. + * @param __str String to compare against. + * @return Integer < 0, 0, or > 0. + * + * Form the substring of this string from the @a __n characters + * starting at @a __pos. Returns an integer < 0 if the + * substring is ordered before @a __str, 0 if their values are + * equivalent, or > 0 if the substring is ordered after @a + * __str. Determines the effective length rlen of the strings + * to compare as the smallest of the length of the substring + * and @a __str.size(). The function then compares the two + * strings by calling + * traits::compare(substring.data(),str.data(),rlen). If the + * result of the comparison is nonzero returns it, otherwise + * the shorter one is ordered first. + */ + int + compare(size_type __pos, size_type __n, const basic_string& __str) const; + + /** + * @brief Compare substring to a substring. + * @param __pos1 Index of first character of substring. + * @param __n1 Number of characters in substring. + * @param __str String to compare against. + * @param __pos2 Index of first character of substring of str. + * @param __n2 Number of characters in substring of str. + * @return Integer < 0, 0, or > 0. + * + * Form the substring of this string from the @a __n1 + * characters starting at @a __pos1. Form the substring of @a + * __str from the @a __n2 characters starting at @a __pos2. + * Returns an integer < 0 if this substring is ordered before + * the substring of @a __str, 0 if their values are equivalent, + * or > 0 if this substring is ordered after the substring of + * @a __str. Determines the effective length rlen of the + * strings to compare as the smallest of the lengths of the + * substrings. The function then compares the two strings by + * calling + * traits::compare(substring.data(),str.substr(pos2,n2).data(),rlen). + * If the result of the comparison is nonzero returns it, + * otherwise the shorter one is ordered first. + */ + int + compare(size_type __pos1, size_type __n1, const basic_string& __str, + size_type __pos2, size_type __n2) const; + + /** + * @brief Compare to a C string. + * @param __s C string to compare against. + * @return Integer < 0, 0, or > 0. + * + * Returns an integer < 0 if this string is ordered before @a __s, 0 if + * their values are equivalent, or > 0 if this string is ordered after + * @a __s. Determines the effective length rlen of the strings to + * compare as the smallest of size() and the length of a string + * constructed from @a __s. The function then compares the two strings + * by calling traits::compare(data(),s,rlen). If the result of the + * comparison is nonzero returns it, otherwise the shorter one is + * ordered first. + */ + int + compare(const _CharT* __s) const; + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 5 String::compare specification questionable + /** + * @brief Compare substring to a C string. + * @param __pos Index of first character of substring. + * @param __n1 Number of characters in substring. + * @param __s C string to compare against. + * @return Integer < 0, 0, or > 0. + * + * Form the substring of this string from the @a __n1 + * characters starting at @a pos. Returns an integer < 0 if + * the substring is ordered before @a __s, 0 if their values + * are equivalent, or > 0 if the substring is ordered after @a + * __s. Determines the effective length rlen of the strings to + * compare as the smallest of the length of the substring and + * the length of a string constructed from @a __s. The + * function then compares the two string by calling + * traits::compare(substring.data(),__s,rlen). If the result of + * the comparison is nonzero returns it, otherwise the shorter + * one is ordered first. + */ + int + compare(size_type __pos, size_type __n1, const _CharT* __s) const; + + /** + * @brief Compare substring against a character %array. + * @param __pos Index of first character of substring. + * @param __n1 Number of characters in substring. + * @param __s character %array to compare against. + * @param __n2 Number of characters of s. + * @return Integer < 0, 0, or > 0. + * + * Form the substring of this string from the @a __n1 + * characters starting at @a __pos. Form a string from the + * first @a __n2 characters of @a __s. Returns an integer < 0 + * if this substring is ordered before the string from @a __s, + * 0 if their values are equivalent, or > 0 if this substring + * is ordered after the string from @a __s. Determines the + * effective length rlen of the strings to compare as the + * smallest of the length of the substring and @a __n2. The + * function then compares the two strings by calling + * traits::compare(substring.data(),s,rlen). If the result of + * the comparison is nonzero returns it, otherwise the shorter + * one is ordered first. + * + * NB: s must have at least n2 characters, '\\0' has + * no special meaning. + */ + int + compare(size_type __pos, size_type __n1, const _CharT* __s, + size_type __n2) const; + }; + + // operator+ + /** + * @brief Concatenate two strings. + * @param __lhs First string. + * @param __rhs Last string. + * @return New string with value of @a __lhs followed by @a __rhs. + */ + template + basic_string<_CharT, _Traits, _Alloc> + operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, + const basic_string<_CharT, _Traits, _Alloc>& __rhs) + { + basic_string<_CharT, _Traits, _Alloc> __str(__lhs); + __str.append(__rhs); + return __str; + } + + /** + * @brief Concatenate C string and string. + * @param __lhs First string. + * @param __rhs Last string. + * @return New string with value of @a __lhs followed by @a __rhs. + */ + template + basic_string<_CharT,_Traits,_Alloc> + operator+(const _CharT* __lhs, + const basic_string<_CharT,_Traits,_Alloc>& __rhs); + + /** + * @brief Concatenate character and string. + * @param __lhs First string. + * @param __rhs Last string. + * @return New string with @a __lhs followed by @a __rhs. + */ + template + basic_string<_CharT,_Traits,_Alloc> + operator+(_CharT __lhs, const basic_string<_CharT,_Traits,_Alloc>& __rhs); + + /** + * @brief Concatenate string and C string. + * @param __lhs First string. + * @param __rhs Last string. + * @return New string with @a __lhs followed by @a __rhs. + */ + template + inline basic_string<_CharT, _Traits, _Alloc> + operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, + const _CharT* __rhs) + { + basic_string<_CharT, _Traits, _Alloc> __str(__lhs); + __str.append(__rhs); + return __str; + } + + /** + * @brief Concatenate string and character. + * @param __lhs First string. + * @param __rhs Last string. + * @return New string with @a __lhs followed by @a __rhs. + */ + template + inline basic_string<_CharT, _Traits, _Alloc> + operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, _CharT __rhs) + { + typedef basic_string<_CharT, _Traits, _Alloc> __string_type; + typedef typename __string_type::size_type __size_type; + __string_type __str(__lhs); + __str.append(__size_type(1), __rhs); + return __str; + } + +#if __cplusplus >= 201103L + template + inline basic_string<_CharT, _Traits, _Alloc> + operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs, + const basic_string<_CharT, _Traits, _Alloc>& __rhs) + { return std::move(__lhs.append(__rhs)); } + + template + inline basic_string<_CharT, _Traits, _Alloc> + operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, + basic_string<_CharT, _Traits, _Alloc>&& __rhs) + { return std::move(__rhs.insert(0, __lhs)); } + + template + inline basic_string<_CharT, _Traits, _Alloc> + operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs, + basic_string<_CharT, _Traits, _Alloc>&& __rhs) + { + const auto __size = __lhs.size() + __rhs.size(); + const bool __cond = (__size > __lhs.capacity() + && __size <= __rhs.capacity()); + return __cond ? std::move(__rhs.insert(0, __lhs)) + : std::move(__lhs.append(__rhs)); + } + + template + inline basic_string<_CharT, _Traits, _Alloc> + operator+(const _CharT* __lhs, + basic_string<_CharT, _Traits, _Alloc>&& __rhs) + { return std::move(__rhs.insert(0, __lhs)); } + + template + inline basic_string<_CharT, _Traits, _Alloc> + operator+(_CharT __lhs, + basic_string<_CharT, _Traits, _Alloc>&& __rhs) + { return std::move(__rhs.insert(0, 1, __lhs)); } + + template + inline basic_string<_CharT, _Traits, _Alloc> + operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs, + const _CharT* __rhs) + { return std::move(__lhs.append(__rhs)); } + + template + inline basic_string<_CharT, _Traits, _Alloc> + operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs, + _CharT __rhs) + { return std::move(__lhs.append(1, __rhs)); } +#endif + + // operator == + /** + * @brief Test equivalence of two strings. + * @param __lhs First string. + * @param __rhs Second string. + * @return True if @a __lhs.compare(@a __rhs) == 0. False otherwise. + */ + template + inline bool + operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs, + const basic_string<_CharT, _Traits, _Alloc>& __rhs) + { return __lhs.compare(__rhs) == 0; } + + template + inline + typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, bool>::__type + operator==(const basic_string<_CharT>& __lhs, + const basic_string<_CharT>& __rhs) + { return (__lhs.size() == __rhs.size() + && !std::char_traits<_CharT>::compare(__lhs.data(), __rhs.data(), + __lhs.size())); } + + /** + * @brief Test equivalence of C string and string. + * @param __lhs C string. + * @param __rhs String. + * @return True if @a __rhs.compare(@a __lhs) == 0. False otherwise. + */ + template + inline bool + operator==(const _CharT* __lhs, + const basic_string<_CharT, _Traits, _Alloc>& __rhs) + { return __rhs.compare(__lhs) == 0; } + + /** + * @brief Test equivalence of string and C string. + * @param __lhs String. + * @param __rhs C string. + * @return True if @a __lhs.compare(@a __rhs) == 0. False otherwise. + */ + template + inline bool + operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs, + const _CharT* __rhs) + { return __lhs.compare(__rhs) == 0; } + + // operator != + /** + * @brief Test difference of two strings. + * @param __lhs First string. + * @param __rhs Second string. + * @return True if @a __lhs.compare(@a __rhs) != 0. False otherwise. + */ + template + inline bool + operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs, + const basic_string<_CharT, _Traits, _Alloc>& __rhs) + { return !(__lhs == __rhs); } + + /** + * @brief Test difference of C string and string. + * @param __lhs C string. + * @param __rhs String. + * @return True if @a __rhs.compare(@a __lhs) != 0. False otherwise. + */ + template + inline bool + operator!=(const _CharT* __lhs, + const basic_string<_CharT, _Traits, _Alloc>& __rhs) + { return !(__lhs == __rhs); } + + /** + * @brief Test difference of string and C string. + * @param __lhs String. + * @param __rhs C string. + * @return True if @a __lhs.compare(@a __rhs) != 0. False otherwise. + */ + template + inline bool + operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs, + const _CharT* __rhs) + { return !(__lhs == __rhs); } + + // operator < + /** + * @brief Test if string precedes string. + * @param __lhs First string. + * @param __rhs Second string. + * @return True if @a __lhs precedes @a __rhs. False otherwise. + */ + template + inline bool + operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs, + const basic_string<_CharT, _Traits, _Alloc>& __rhs) + { return __lhs.compare(__rhs) < 0; } + + /** + * @brief Test if string precedes C string. + * @param __lhs String. + * @param __rhs C string. + * @return True if @a __lhs precedes @a __rhs. False otherwise. + */ + template + inline bool + operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs, + const _CharT* __rhs) + { return __lhs.compare(__rhs) < 0; } + + /** + * @brief Test if C string precedes string. + * @param __lhs C string. + * @param __rhs String. + * @return True if @a __lhs precedes @a __rhs. False otherwise. + */ + template + inline bool + operator<(const _CharT* __lhs, + const basic_string<_CharT, _Traits, _Alloc>& __rhs) + { return __rhs.compare(__lhs) > 0; } + + // operator > + /** + * @brief Test if string follows string. + * @param __lhs First string. + * @param __rhs Second string. + * @return True if @a __lhs follows @a __rhs. False otherwise. + */ + template + inline bool + operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs, + const basic_string<_CharT, _Traits, _Alloc>& __rhs) + { return __lhs.compare(__rhs) > 0; } + + /** + * @brief Test if string follows C string. + * @param __lhs String. + * @param __rhs C string. + * @return True if @a __lhs follows @a __rhs. False otherwise. + */ + template + inline bool + operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs, + const _CharT* __rhs) + { return __lhs.compare(__rhs) > 0; } + + /** + * @brief Test if C string follows string. + * @param __lhs C string. + * @param __rhs String. + * @return True if @a __lhs follows @a __rhs. False otherwise. + */ + template + inline bool + operator>(const _CharT* __lhs, + const basic_string<_CharT, _Traits, _Alloc>& __rhs) + { return __rhs.compare(__lhs) < 0; } + + // operator <= + /** + * @brief Test if string doesn't follow string. + * @param __lhs First string. + * @param __rhs Second string. + * @return True if @a __lhs doesn't follow @a __rhs. False otherwise. + */ + template + inline bool + operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs, + const basic_string<_CharT, _Traits, _Alloc>& __rhs) + { return __lhs.compare(__rhs) <= 0; } + + /** + * @brief Test if string doesn't follow C string. + * @param __lhs String. + * @param __rhs C string. + * @return True if @a __lhs doesn't follow @a __rhs. False otherwise. + */ + template + inline bool + operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs, + const _CharT* __rhs) + { return __lhs.compare(__rhs) <= 0; } + + /** + * @brief Test if C string doesn't follow string. + * @param __lhs C string. + * @param __rhs String. + * @return True if @a __lhs doesn't follow @a __rhs. False otherwise. + */ + template + inline bool + operator<=(const _CharT* __lhs, + const basic_string<_CharT, _Traits, _Alloc>& __rhs) + { return __rhs.compare(__lhs) >= 0; } + + // operator >= + /** + * @brief Test if string doesn't precede string. + * @param __lhs First string. + * @param __rhs Second string. + * @return True if @a __lhs doesn't precede @a __rhs. False otherwise. + */ + template + inline bool + operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs, + const basic_string<_CharT, _Traits, _Alloc>& __rhs) + { return __lhs.compare(__rhs) >= 0; } + + /** + * @brief Test if string doesn't precede C string. + * @param __lhs String. + * @param __rhs C string. + * @return True if @a __lhs doesn't precede @a __rhs. False otherwise. + */ + template + inline bool + operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs, + const _CharT* __rhs) + { return __lhs.compare(__rhs) >= 0; } + + /** + * @brief Test if C string doesn't precede string. + * @param __lhs C string. + * @param __rhs String. + * @return True if @a __lhs doesn't precede @a __rhs. False otherwise. + */ + template + inline bool + operator>=(const _CharT* __lhs, + const basic_string<_CharT, _Traits, _Alloc>& __rhs) + { return __rhs.compare(__lhs) <= 0; } + + /** + * @brief Swap contents of two strings. + * @param __lhs First string. + * @param __rhs Second string. + * + * Exchanges the contents of @a __lhs and @a __rhs in constant time. + */ + template + inline void + swap(basic_string<_CharT, _Traits, _Alloc>& __lhs, + basic_string<_CharT, _Traits, _Alloc>& __rhs) + { __lhs.swap(__rhs); } + + /** + * @brief Read stream into a string. + * @param __is Input stream. + * @param __str Buffer to store into. + * @return Reference to the input stream. + * + * Stores characters from @a __is into @a __str until whitespace is + * found, the end of the stream is encountered, or str.max_size() + * is reached. If is.width() is non-zero, that is the limit on the + * number of characters stored into @a __str. Any previous + * contents of @a __str are erased. + */ + template + basic_istream<_CharT, _Traits>& + operator>>(basic_istream<_CharT, _Traits>& __is, + basic_string<_CharT, _Traits, _Alloc>& __str); + + template<> + basic_istream& + operator>>(basic_istream& __is, basic_string& __str); + + /** + * @brief Write string to a stream. + * @param __os Output stream. + * @param __str String to write out. + * @return Reference to the output stream. + * + * Output characters of @a __str into os following the same rules as for + * writing a C string. + */ + template + inline basic_ostream<_CharT, _Traits>& + operator<<(basic_ostream<_CharT, _Traits>& __os, + const basic_string<_CharT, _Traits, _Alloc>& __str) + { + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 586. string inserter not a formatted function + return __ostream_insert(__os, __str.data(), __str.size()); + } + + /** + * @brief Read a line from stream into a string. + * @param __is Input stream. + * @param __str Buffer to store into. + * @param __delim Character marking end of line. + * @return Reference to the input stream. + * + * Stores characters from @a __is into @a __str until @a __delim is + * found, the end of the stream is encountered, or str.max_size() + * is reached. Any previous contents of @a __str are erased. If + * @a __delim is encountered, it is extracted but not stored into + * @a __str. + */ + template + basic_istream<_CharT, _Traits>& + getline(basic_istream<_CharT, _Traits>& __is, + basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim); + + /** + * @brief Read a line from stream into a string. + * @param __is Input stream. + * @param __str Buffer to store into. + * @return Reference to the input stream. + * + * Stores characters from is into @a __str until '\n' is + * found, the end of the stream is encountered, or str.max_size() + * is reached. Any previous contents of @a __str are erased. If + * end of line is encountered, it is extracted but not stored into + * @a __str. + */ + template + inline basic_istream<_CharT, _Traits>& + getline(basic_istream<_CharT, _Traits>& __is, + basic_string<_CharT, _Traits, _Alloc>& __str) + { return std::getline(__is, __str, __is.widen('\n')); } + +#if __cplusplus >= 201103L + /// Read a line from an rvalue stream into a string. + template + inline basic_istream<_CharT, _Traits>& + getline(basic_istream<_CharT, _Traits>&& __is, + basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim) + { return std::getline(__is, __str, __delim); } + + /// Read a line from an rvalue stream into a string. + template + inline basic_istream<_CharT, _Traits>& + getline(basic_istream<_CharT, _Traits>&& __is, + basic_string<_CharT, _Traits, _Alloc>& __str) + { return std::getline(__is, __str); } +#endif + + template<> + basic_istream& + getline(basic_istream& __in, basic_string& __str, + char __delim); + +#ifdef _GLIBCXX_USE_WCHAR_T + template<> + basic_istream& + getline(basic_istream& __in, basic_string& __str, + wchar_t __delim); +#endif + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#if ((__cplusplus >= 201103L) && defined(_GLIBCXX_USE_C99) \ + && !defined(_GLIBCXX_HAVE_BROKEN_VSWPRINTF)) + +#include + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + // 21.4 Numeric Conversions [string.conversions]. + inline int + stoi(const string& __str, size_t* __idx = 0, int __base = 10) + { return __gnu_cxx::__stoa(&std::strtol, "stoi", __str.c_str(), + __idx, __base); } + + inline long + stol(const string& __str, size_t* __idx = 0, int __base = 10) + { return __gnu_cxx::__stoa(&std::strtol, "stol", __str.c_str(), + __idx, __base); } + + inline unsigned long + stoul(const string& __str, size_t* __idx = 0, int __base = 10) + { return __gnu_cxx::__stoa(&std::strtoul, "stoul", __str.c_str(), + __idx, __base); } + + inline long long + stoll(const string& __str, size_t* __idx = 0, int __base = 10) + { return __gnu_cxx::__stoa(&std::strtoll, "stoll", __str.c_str(), + __idx, __base); } + + inline unsigned long long + stoull(const string& __str, size_t* __idx = 0, int __base = 10) + { return __gnu_cxx::__stoa(&std::strtoull, "stoull", __str.c_str(), + __idx, __base); } + + // NB: strtof vs strtod. + inline float + stof(const string& __str, size_t* __idx = 0) + { return __gnu_cxx::__stoa(&std::strtof, "stof", __str.c_str(), __idx); } + + inline double + stod(const string& __str, size_t* __idx = 0) + { return __gnu_cxx::__stoa(&std::strtod, "stod", __str.c_str(), __idx); } + + inline long double + stold(const string& __str, size_t* __idx = 0) + { return __gnu_cxx::__stoa(&std::strtold, "stold", __str.c_str(), __idx); } + + // NB: (v)snprintf vs sprintf. + + // DR 1261. + inline string + to_string(int __val) + { return __gnu_cxx::__to_xstring(&std::vsnprintf, 4 * sizeof(int), + "%d", __val); } + + inline string + to_string(unsigned __val) + { return __gnu_cxx::__to_xstring(&std::vsnprintf, + 4 * sizeof(unsigned), + "%u", __val); } + + inline string + to_string(long __val) + { return __gnu_cxx::__to_xstring(&std::vsnprintf, 4 * sizeof(long), + "%ld", __val); } + + inline string + to_string(unsigned long __val) + { return __gnu_cxx::__to_xstring(&std::vsnprintf, + 4 * sizeof(unsigned long), + "%lu", __val); } + + inline string + to_string(long long __val) + { return __gnu_cxx::__to_xstring(&std::vsnprintf, + 4 * sizeof(long long), + "%lld", __val); } + + inline string + to_string(unsigned long long __val) + { return __gnu_cxx::__to_xstring(&std::vsnprintf, + 4 * sizeof(unsigned long long), + "%llu", __val); } + + inline string + to_string(float __val) + { + const int __n = + __gnu_cxx::__numeric_traits::__max_exponent10 + 20; + return __gnu_cxx::__to_xstring(&std::vsnprintf, __n, + "%f", __val); + } + + inline string + to_string(double __val) + { + const int __n = + __gnu_cxx::__numeric_traits::__max_exponent10 + 20; + return __gnu_cxx::__to_xstring(&std::vsnprintf, __n, + "%f", __val); + } + + inline string + to_string(long double __val) + { + const int __n = + __gnu_cxx::__numeric_traits::__max_exponent10 + 20; + return __gnu_cxx::__to_xstring(&std::vsnprintf, __n, + "%Lf", __val); + } + +#ifdef _GLIBCXX_USE_WCHAR_T + inline int + stoi(const wstring& __str, size_t* __idx = 0, int __base = 10) + { return __gnu_cxx::__stoa(&std::wcstol, "stoi", __str.c_str(), + __idx, __base); } + + inline long + stol(const wstring& __str, size_t* __idx = 0, int __base = 10) + { return __gnu_cxx::__stoa(&std::wcstol, "stol", __str.c_str(), + __idx, __base); } + + inline unsigned long + stoul(const wstring& __str, size_t* __idx = 0, int __base = 10) + { return __gnu_cxx::__stoa(&std::wcstoul, "stoul", __str.c_str(), + __idx, __base); } + + inline long long + stoll(const wstring& __str, size_t* __idx = 0, int __base = 10) + { return __gnu_cxx::__stoa(&std::wcstoll, "stoll", __str.c_str(), + __idx, __base); } + + inline unsigned long long + stoull(const wstring& __str, size_t* __idx = 0, int __base = 10) + { return __gnu_cxx::__stoa(&std::wcstoull, "stoull", __str.c_str(), + __idx, __base); } + + // NB: wcstof vs wcstod. + inline float + stof(const wstring& __str, size_t* __idx = 0) + { return __gnu_cxx::__stoa(&std::wcstof, "stof", __str.c_str(), __idx); } + + inline double + stod(const wstring& __str, size_t* __idx = 0) + { return __gnu_cxx::__stoa(&std::wcstod, "stod", __str.c_str(), __idx); } + + inline long double + stold(const wstring& __str, size_t* __idx = 0) + { return __gnu_cxx::__stoa(&std::wcstold, "stold", __str.c_str(), __idx); } + + // DR 1261. + inline wstring + to_wstring(int __val) + { return __gnu_cxx::__to_xstring(&std::vswprintf, 4 * sizeof(int), + L"%d", __val); } + + inline wstring + to_wstring(unsigned __val) + { return __gnu_cxx::__to_xstring(&std::vswprintf, + 4 * sizeof(unsigned), + L"%u", __val); } + + inline wstring + to_wstring(long __val) + { return __gnu_cxx::__to_xstring(&std::vswprintf, 4 * sizeof(long), + L"%ld", __val); } + + inline wstring + to_wstring(unsigned long __val) + { return __gnu_cxx::__to_xstring(&std::vswprintf, + 4 * sizeof(unsigned long), + L"%lu", __val); } + + inline wstring + to_wstring(long long __val) + { return __gnu_cxx::__to_xstring(&std::vswprintf, + 4 * sizeof(long long), + L"%lld", __val); } + + inline wstring + to_wstring(unsigned long long __val) + { return __gnu_cxx::__to_xstring(&std::vswprintf, + 4 * sizeof(unsigned long long), + L"%llu", __val); } + + inline wstring + to_wstring(float __val) + { + const int __n = + __gnu_cxx::__numeric_traits::__max_exponent10 + 20; + return __gnu_cxx::__to_xstring(&std::vswprintf, __n, + L"%f", __val); + } + + inline wstring + to_wstring(double __val) + { + const int __n = + __gnu_cxx::__numeric_traits::__max_exponent10 + 20; + return __gnu_cxx::__to_xstring(&std::vswprintf, __n, + L"%f", __val); + } + + inline wstring + to_wstring(long double __val) + { + const int __n = + __gnu_cxx::__numeric_traits::__max_exponent10 + 20; + return __gnu_cxx::__to_xstring(&std::vswprintf, __n, + L"%Lf", __val); + } +#endif + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif /* C++11 && _GLIBCXX_USE_C99 ... */ + +#if __cplusplus >= 201103L + +#include + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + // DR 1182. + +#ifndef _GLIBCXX_COMPATIBILITY_CXX0X + /// std::hash specialization for string. + template<> + struct hash + : public __hash_base + { + size_t + operator()(const string& __s) const noexcept + { return std::_Hash_impl::hash(__s.data(), __s.length()); } + }; + + template<> + struct __is_fast_hash> : std::false_type + { }; + +#ifdef _GLIBCXX_USE_WCHAR_T + /// std::hash specialization for wstring. + template<> + struct hash + : public __hash_base + { + size_t + operator()(const wstring& __s) const noexcept + { return std::_Hash_impl::hash(__s.data(), + __s.length() * sizeof(wchar_t)); } + }; + + template<> + struct __is_fast_hash> : std::false_type + { }; +#endif +#endif /* _GLIBCXX_COMPATIBILITY_CXX0X */ + +#ifdef _GLIBCXX_USE_C99_STDINT_TR1 + /// std::hash specialization for u16string. + template<> + struct hash + : public __hash_base + { + size_t + operator()(const u16string& __s) const noexcept + { return std::_Hash_impl::hash(__s.data(), + __s.length() * sizeof(char16_t)); } + }; + + template<> + struct __is_fast_hash> : std::false_type + { }; + + /// std::hash specialization for u32string. + template<> + struct hash + : public __hash_base + { + size_t + operator()(const u32string& __s) const noexcept + { return std::_Hash_impl::hash(__s.data(), + __s.length() * sizeof(char32_t)); } + }; + + template<> + struct __is_fast_hash> : std::false_type + { }; +#endif + +#if __cplusplus > 201103L + +#define __cpp_lib_string_udls 201304 + + inline namespace literals + { + inline namespace string_literals + { + + inline basic_string + operator""s(const char* __str, size_t __len) + { return basic_string{__str, __len}; } + +#ifdef _GLIBCXX_USE_WCHAR_T + inline basic_string + operator""s(const wchar_t* __str, size_t __len) + { return basic_string{__str, __len}; } +#endif + +#ifdef _GLIBCXX_USE_C99_STDINT_TR1 + inline basic_string + operator""s(const char16_t* __str, size_t __len) + { return basic_string{__str, __len}; } + + inline basic_string + operator""s(const char32_t* __str, size_t __len) + { return basic_string{__str, __len}; } +#endif + + } // inline namespace string_literals + } // inline namespace literals + +#endif // __cplusplus > 201103L + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace std + +#endif // C++11 + +#endif /* _BASIC_STRING_H */ diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/basic_string.tcc b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/basic_string.tcc new file mode 100755 index 0000000..f8907c0 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/basic_string.tcc @@ -0,0 +1,1166 @@ +// Components for manipulating sequences of characters -*- C++ -*- + +// Copyright (C) 1997-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file bits/basic_string.tcc + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{string} + */ + +// +// ISO C++ 14882: 21 Strings library +// + +// Written by Jason Merrill based upon the specification by Takanori Adachi +// in ANSI X3J16/94-0013R2. Rewritten by Nathan Myers to ISO-14882. + +#ifndef _BASIC_STRING_TCC +#define _BASIC_STRING_TCC 1 + +#pragma GCC system_header + +#include + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + template + const typename basic_string<_CharT, _Traits, _Alloc>::size_type + basic_string<_CharT, _Traits, _Alloc>:: + _Rep::_S_max_size = (((npos - sizeof(_Rep_base))/sizeof(_CharT)) - 1) / 4; + + template + const _CharT + basic_string<_CharT, _Traits, _Alloc>:: + _Rep::_S_terminal = _CharT(); + + template + const typename basic_string<_CharT, _Traits, _Alloc>::size_type + basic_string<_CharT, _Traits, _Alloc>::npos; + + // Linker sets _S_empty_rep_storage to all 0s (one reference, empty string) + // at static init time (before static ctors are run). + template + typename basic_string<_CharT, _Traits, _Alloc>::size_type + basic_string<_CharT, _Traits, _Alloc>::_Rep::_S_empty_rep_storage[ + (sizeof(_Rep_base) + sizeof(_CharT) + sizeof(size_type) - 1) / + sizeof(size_type)]; + + // NB: This is the special case for Input Iterators, used in + // istreambuf_iterators, etc. + // Input Iterators have a cost structure very different from + // pointers, calling for a different coding style. + template + template + _CharT* + basic_string<_CharT, _Traits, _Alloc>:: + _S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a, + input_iterator_tag) + { +#if _GLIBCXX_FULLY_DYNAMIC_STRING == 0 + if (__beg == __end && __a == _Alloc()) + return _S_empty_rep()._M_refdata(); +#endif + // Avoid reallocation for common case. + _CharT __buf[128]; + size_type __len = 0; + while (__beg != __end && __len < sizeof(__buf) / sizeof(_CharT)) + { + __buf[__len++] = *__beg; + ++__beg; + } + _Rep* __r = _Rep::_S_create(__len, size_type(0), __a); + _M_copy(__r->_M_refdata(), __buf, __len); + __try + { + while (__beg != __end) + { + if (__len == __r->_M_capacity) + { + // Allocate more space. + _Rep* __another = _Rep::_S_create(__len + 1, __len, __a); + _M_copy(__another->_M_refdata(), __r->_M_refdata(), __len); + __r->_M_destroy(__a); + __r = __another; + } + __r->_M_refdata()[__len++] = *__beg; + ++__beg; + } + } + __catch(...) + { + __r->_M_destroy(__a); + __throw_exception_again; + } + __r->_M_set_length_and_sharable(__len); + return __r->_M_refdata(); + } + + template + template + _CharT* + basic_string<_CharT, _Traits, _Alloc>:: + _S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a, + forward_iterator_tag) + { +#if _GLIBCXX_FULLY_DYNAMIC_STRING == 0 + if (__beg == __end && __a == _Alloc()) + return _S_empty_rep()._M_refdata(); +#endif + // NB: Not required, but considered best practice. + if (__gnu_cxx::__is_null_pointer(__beg) && __beg != __end) + __throw_logic_error(__N("basic_string::_S_construct null not valid")); + + const size_type __dnew = static_cast(std::distance(__beg, + __end)); + // Check for out_of_range and length_error exceptions. + _Rep* __r = _Rep::_S_create(__dnew, size_type(0), __a); + __try + { _S_copy_chars(__r->_M_refdata(), __beg, __end); } + __catch(...) + { + __r->_M_destroy(__a); + __throw_exception_again; + } + __r->_M_set_length_and_sharable(__dnew); + return __r->_M_refdata(); + } + + template + _CharT* + basic_string<_CharT, _Traits, _Alloc>:: + _S_construct(size_type __n, _CharT __c, const _Alloc& __a) + { +#if _GLIBCXX_FULLY_DYNAMIC_STRING == 0 + if (__n == 0 && __a == _Alloc()) + return _S_empty_rep()._M_refdata(); +#endif + // Check for out_of_range and length_error exceptions. + _Rep* __r = _Rep::_S_create(__n, size_type(0), __a); + if (__n) + _M_assign(__r->_M_refdata(), __n, __c); + + __r->_M_set_length_and_sharable(__n); + return __r->_M_refdata(); + } + + template + basic_string<_CharT, _Traits, _Alloc>:: + basic_string(const basic_string& __str) + : _M_dataplus(__str._M_rep()->_M_grab(_Alloc(__str.get_allocator()), + __str.get_allocator()), + __str.get_allocator()) + { } + + template + basic_string<_CharT, _Traits, _Alloc>:: + basic_string(const _Alloc& __a) + : _M_dataplus(_S_construct(size_type(), _CharT(), __a), __a) + { } + + template + basic_string<_CharT, _Traits, _Alloc>:: + basic_string(const basic_string& __str, size_type __pos, size_type __n) + : _M_dataplus(_S_construct(__str._M_data() + + __str._M_check(__pos, + "basic_string::basic_string"), + __str._M_data() + __str._M_limit(__pos, __n) + + __pos, _Alloc()), _Alloc()) + { } + + template + basic_string<_CharT, _Traits, _Alloc>:: + basic_string(const basic_string& __str, size_type __pos, + size_type __n, const _Alloc& __a) + : _M_dataplus(_S_construct(__str._M_data() + + __str._M_check(__pos, + "basic_string::basic_string"), + __str._M_data() + __str._M_limit(__pos, __n) + + __pos, __a), __a) + { } + + // TBD: DPG annotate + template + basic_string<_CharT, _Traits, _Alloc>:: + basic_string(const _CharT* __s, size_type __n, const _Alloc& __a) + : _M_dataplus(_S_construct(__s, __s + __n, __a), __a) + { } + + // TBD: DPG annotate + template + basic_string<_CharT, _Traits, _Alloc>:: + basic_string(const _CharT* __s, const _Alloc& __a) + : _M_dataplus(_S_construct(__s, __s ? __s + traits_type::length(__s) : + __s + npos, __a), __a) + { } + + template + basic_string<_CharT, _Traits, _Alloc>:: + basic_string(size_type __n, _CharT __c, const _Alloc& __a) + : _M_dataplus(_S_construct(__n, __c, __a), __a) + { } + + // TBD: DPG annotate + template + template + basic_string<_CharT, _Traits, _Alloc>:: + basic_string(_InputIterator __beg, _InputIterator __end, const _Alloc& __a) + : _M_dataplus(_S_construct(__beg, __end, __a), __a) + { } + +#if __cplusplus >= 201103L + template + basic_string<_CharT, _Traits, _Alloc>:: + basic_string(initializer_list<_CharT> __l, const _Alloc& __a) + : _M_dataplus(_S_construct(__l.begin(), __l.end(), __a), __a) + { } +#endif + + template + basic_string<_CharT, _Traits, _Alloc>& + basic_string<_CharT, _Traits, _Alloc>:: + assign(const basic_string& __str) + { + if (_M_rep() != __str._M_rep()) + { + // XXX MT + const allocator_type __a = this->get_allocator(); + _CharT* __tmp = __str._M_rep()->_M_grab(__a, __str.get_allocator()); + _M_rep()->_M_dispose(__a); + _M_data(__tmp); + } + return *this; + } + + template + basic_string<_CharT, _Traits, _Alloc>& + basic_string<_CharT, _Traits, _Alloc>:: + assign(const _CharT* __s, size_type __n) + { + __glibcxx_requires_string_len(__s, __n); + _M_check_length(this->size(), __n, "basic_string::assign"); + if (_M_disjunct(__s) || _M_rep()->_M_is_shared()) + return _M_replace_safe(size_type(0), this->size(), __s, __n); + else + { + // Work in-place. + const size_type __pos = __s - _M_data(); + if (__pos >= __n) + _M_copy(_M_data(), __s, __n); + else if (__pos) + _M_move(_M_data(), __s, __n); + _M_rep()->_M_set_length_and_sharable(__n); + return *this; + } + } + + template + basic_string<_CharT, _Traits, _Alloc>& + basic_string<_CharT, _Traits, _Alloc>:: + append(size_type __n, _CharT __c) + { + if (__n) + { + _M_check_length(size_type(0), __n, "basic_string::append"); + const size_type __len = __n + this->size(); + if (__len > this->capacity() || _M_rep()->_M_is_shared()) + this->reserve(__len); + _M_assign(_M_data() + this->size(), __n, __c); + _M_rep()->_M_set_length_and_sharable(__len); + } + return *this; + } + + template + basic_string<_CharT, _Traits, _Alloc>& + basic_string<_CharT, _Traits, _Alloc>:: + append(const _CharT* __s, size_type __n) + { + __glibcxx_requires_string_len(__s, __n); + if (__n) + { + _M_check_length(size_type(0), __n, "basic_string::append"); + const size_type __len = __n + this->size(); + if (__len > this->capacity() || _M_rep()->_M_is_shared()) + { + if (_M_disjunct(__s)) + this->reserve(__len); + else + { + const size_type __off = __s - _M_data(); + this->reserve(__len); + __s = _M_data() + __off; + } + } + _M_copy(_M_data() + this->size(), __s, __n); + _M_rep()->_M_set_length_and_sharable(__len); + } + return *this; + } + + template + basic_string<_CharT, _Traits, _Alloc>& + basic_string<_CharT, _Traits, _Alloc>:: + append(const basic_string& __str) + { + const size_type __size = __str.size(); + if (__size) + { + const size_type __len = __size + this->size(); + if (__len > this->capacity() || _M_rep()->_M_is_shared()) + this->reserve(__len); + _M_copy(_M_data() + this->size(), __str._M_data(), __size); + _M_rep()->_M_set_length_and_sharable(__len); + } + return *this; + } + + template + basic_string<_CharT, _Traits, _Alloc>& + basic_string<_CharT, _Traits, _Alloc>:: + append(const basic_string& __str, size_type __pos, size_type __n) + { + __str._M_check(__pos, "basic_string::append"); + __n = __str._M_limit(__pos, __n); + if (__n) + { + const size_type __len = __n + this->size(); + if (__len > this->capacity() || _M_rep()->_M_is_shared()) + this->reserve(__len); + _M_copy(_M_data() + this->size(), __str._M_data() + __pos, __n); + _M_rep()->_M_set_length_and_sharable(__len); + } + return *this; + } + + template + basic_string<_CharT, _Traits, _Alloc>& + basic_string<_CharT, _Traits, _Alloc>:: + insert(size_type __pos, const _CharT* __s, size_type __n) + { + __glibcxx_requires_string_len(__s, __n); + _M_check(__pos, "basic_string::insert"); + _M_check_length(size_type(0), __n, "basic_string::insert"); + if (_M_disjunct(__s) || _M_rep()->_M_is_shared()) + return _M_replace_safe(__pos, size_type(0), __s, __n); + else + { + // Work in-place. + const size_type __off = __s - _M_data(); + _M_mutate(__pos, 0, __n); + __s = _M_data() + __off; + _CharT* __p = _M_data() + __pos; + if (__s + __n <= __p) + _M_copy(__p, __s, __n); + else if (__s >= __p) + _M_copy(__p, __s + __n, __n); + else + { + const size_type __nleft = __p - __s; + _M_copy(__p, __s, __nleft); + _M_copy(__p + __nleft, __p + __n, __n - __nleft); + } + return *this; + } + } + + template + typename basic_string<_CharT, _Traits, _Alloc>::iterator + basic_string<_CharT, _Traits, _Alloc>:: + erase(iterator __first, iterator __last) + { + _GLIBCXX_DEBUG_PEDASSERT(__first >= _M_ibegin() && __first <= __last + && __last <= _M_iend()); + + // NB: This isn't just an optimization (bail out early when + // there is nothing to do, really), it's also a correctness + // issue vs MT, see libstdc++/40518. + const size_type __size = __last - __first; + if (__size) + { + const size_type __pos = __first - _M_ibegin(); + _M_mutate(__pos, __size, size_type(0)); + _M_rep()->_M_set_leaked(); + return iterator(_M_data() + __pos); + } + else + return __first; + } + + template + basic_string<_CharT, _Traits, _Alloc>& + basic_string<_CharT, _Traits, _Alloc>:: + replace(size_type __pos, size_type __n1, const _CharT* __s, + size_type __n2) + { + __glibcxx_requires_string_len(__s, __n2); + _M_check(__pos, "basic_string::replace"); + __n1 = _M_limit(__pos, __n1); + _M_check_length(__n1, __n2, "basic_string::replace"); + bool __left; + if (_M_disjunct(__s) || _M_rep()->_M_is_shared()) + return _M_replace_safe(__pos, __n1, __s, __n2); + else if ((__left = __s + __n2 <= _M_data() + __pos) + || _M_data() + __pos + __n1 <= __s) + { + // Work in-place: non-overlapping case. + size_type __off = __s - _M_data(); + __left ? __off : (__off += __n2 - __n1); + _M_mutate(__pos, __n1, __n2); + _M_copy(_M_data() + __pos, _M_data() + __off, __n2); + return *this; + } + else + { + // Todo: overlapping case. + const basic_string __tmp(__s, __n2); + return _M_replace_safe(__pos, __n1, __tmp._M_data(), __n2); + } + } + + template + void + basic_string<_CharT, _Traits, _Alloc>::_Rep:: + _M_destroy(const _Alloc& __a) throw () + { + const size_type __size = sizeof(_Rep_base) + + (this->_M_capacity + 1) * sizeof(_CharT); + _Raw_bytes_alloc(__a).deallocate(reinterpret_cast(this), __size); + } + + template + void + basic_string<_CharT, _Traits, _Alloc>:: + _M_leak_hard() + { +#if _GLIBCXX_FULLY_DYNAMIC_STRING == 0 + if (_M_rep() == &_S_empty_rep()) + return; +#endif + if (_M_rep()->_M_is_shared()) + _M_mutate(0, 0, 0); + _M_rep()->_M_set_leaked(); + } + + template + void + basic_string<_CharT, _Traits, _Alloc>:: + _M_mutate(size_type __pos, size_type __len1, size_type __len2) + { + const size_type __old_size = this->size(); + const size_type __new_size = __old_size + __len2 - __len1; + const size_type __how_much = __old_size - __pos - __len1; + + if (__new_size > this->capacity() || _M_rep()->_M_is_shared()) + { + // Must reallocate. + const allocator_type __a = get_allocator(); + _Rep* __r = _Rep::_S_create(__new_size, this->capacity(), __a); + + if (__pos) + _M_copy(__r->_M_refdata(), _M_data(), __pos); + if (__how_much) + _M_copy(__r->_M_refdata() + __pos + __len2, + _M_data() + __pos + __len1, __how_much); + + _M_rep()->_M_dispose(__a); + _M_data(__r->_M_refdata()); + } + else if (__how_much && __len1 != __len2) + { + // Work in-place. + _M_move(_M_data() + __pos + __len2, + _M_data() + __pos + __len1, __how_much); + } + _M_rep()->_M_set_length_and_sharable(__new_size); + } + + template + void + basic_string<_CharT, _Traits, _Alloc>:: + reserve(size_type __res) + { + if (__res != this->capacity() || _M_rep()->_M_is_shared()) + { + // Make sure we don't shrink below the current size + if (__res < this->size()) + __res = this->size(); + const allocator_type __a = get_allocator(); + _CharT* __tmp = _M_rep()->_M_clone(__a, __res - this->size()); + _M_rep()->_M_dispose(__a); + _M_data(__tmp); + } + } + + template + void + basic_string<_CharT, _Traits, _Alloc>:: + swap(basic_string& __s) + { + if (_M_rep()->_M_is_leaked()) + _M_rep()->_M_set_sharable(); + if (__s._M_rep()->_M_is_leaked()) + __s._M_rep()->_M_set_sharable(); + if (this->get_allocator() == __s.get_allocator()) + { + _CharT* __tmp = _M_data(); + _M_data(__s._M_data()); + __s._M_data(__tmp); + } + // The code below can usually be optimized away. + else + { + const basic_string __tmp1(_M_ibegin(), _M_iend(), + __s.get_allocator()); + const basic_string __tmp2(__s._M_ibegin(), __s._M_iend(), + this->get_allocator()); + *this = __tmp2; + __s = __tmp1; + } + } + + template + typename basic_string<_CharT, _Traits, _Alloc>::_Rep* + basic_string<_CharT, _Traits, _Alloc>::_Rep:: + _S_create(size_type __capacity, size_type __old_capacity, + const _Alloc& __alloc) + { + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 83. String::npos vs. string::max_size() + if (__capacity > _S_max_size) + __throw_length_error(__N("basic_string::_S_create")); + + // The standard places no restriction on allocating more memory + // than is strictly needed within this layer at the moment or as + // requested by an explicit application call to reserve(). + + // Many malloc implementations perform quite poorly when an + // application attempts to allocate memory in a stepwise fashion + // growing each allocation size by only 1 char. Additionally, + // it makes little sense to allocate less linear memory than the + // natural blocking size of the malloc implementation. + // Unfortunately, we would need a somewhat low-level calculation + // with tuned parameters to get this perfect for any particular + // malloc implementation. Fortunately, generalizations about + // common features seen among implementations seems to suffice. + + // __pagesize need not match the actual VM page size for good + // results in practice, thus we pick a common value on the low + // side. __malloc_header_size is an estimate of the amount of + // overhead per memory allocation (in practice seen N * sizeof + // (void*) where N is 0, 2 or 4). According to folklore, + // picking this value on the high side is better than + // low-balling it (especially when this algorithm is used with + // malloc implementations that allocate memory blocks rounded up + // to a size which is a power of 2). + const size_type __pagesize = 4096; + const size_type __malloc_header_size = 4 * sizeof(void*); + + // The below implements an exponential growth policy, necessary to + // meet amortized linear time requirements of the library: see + // http://gcc.gnu.org/ml/libstdc++/2001-07/msg00085.html. + // It's active for allocations requiring an amount of memory above + // system pagesize. This is consistent with the requirements of the + // standard: http://gcc.gnu.org/ml/libstdc++/2001-07/msg00130.html + if (__capacity > __old_capacity && __capacity < 2 * __old_capacity) + __capacity = 2 * __old_capacity; + + // NB: Need an array of char_type[__capacity], plus a terminating + // null char_type() element, plus enough for the _Rep data structure. + // Whew. Seemingly so needy, yet so elemental. + size_type __size = (__capacity + 1) * sizeof(_CharT) + sizeof(_Rep); + + const size_type __adj_size = __size + __malloc_header_size; + if (__adj_size > __pagesize && __capacity > __old_capacity) + { + const size_type __extra = __pagesize - __adj_size % __pagesize; + __capacity += __extra / sizeof(_CharT); + // Never allocate a string bigger than _S_max_size. + if (__capacity > _S_max_size) + __capacity = _S_max_size; + __size = (__capacity + 1) * sizeof(_CharT) + sizeof(_Rep); + } + + // NB: Might throw, but no worries about a leak, mate: _Rep() + // does not throw. + void* __place = _Raw_bytes_alloc(__alloc).allocate(__size); + _Rep *__p = new (__place) _Rep; + __p->_M_capacity = __capacity; + // ABI compatibility - 3.4.x set in _S_create both + // _M_refcount and _M_length. All callers of _S_create + // in basic_string.tcc then set just _M_length. + // In 4.0.x and later both _M_refcount and _M_length + // are initialized in the callers, unfortunately we can + // have 3.4.x compiled code with _S_create callers inlined + // calling 4.0.x+ _S_create. + __p->_M_set_sharable(); + return __p; + } + + template + _CharT* + basic_string<_CharT, _Traits, _Alloc>::_Rep:: + _M_clone(const _Alloc& __alloc, size_type __res) + { + // Requested capacity of the clone. + const size_type __requested_cap = this->_M_length + __res; + _Rep* __r = _Rep::_S_create(__requested_cap, this->_M_capacity, + __alloc); + if (this->_M_length) + _M_copy(__r->_M_refdata(), _M_refdata(), this->_M_length); + + __r->_M_set_length_and_sharable(this->_M_length); + return __r->_M_refdata(); + } + + template + void + basic_string<_CharT, _Traits, _Alloc>:: + resize(size_type __n, _CharT __c) + { + const size_type __size = this->size(); + _M_check_length(__size, __n, "basic_string::resize"); + if (__size < __n) + this->append(__n - __size, __c); + else if (__n < __size) + this->erase(__n); + // else nothing (in particular, avoid calling _M_mutate() unnecessarily.) + } + + template + template + basic_string<_CharT, _Traits, _Alloc>& + basic_string<_CharT, _Traits, _Alloc>:: + _M_replace_dispatch(iterator __i1, iterator __i2, _InputIterator __k1, + _InputIterator __k2, __false_type) + { + const basic_string __s(__k1, __k2); + const size_type __n1 = __i2 - __i1; + _M_check_length(__n1, __s.size(), "basic_string::_M_replace_dispatch"); + return _M_replace_safe(__i1 - _M_ibegin(), __n1, __s._M_data(), + __s.size()); + } + + template + basic_string<_CharT, _Traits, _Alloc>& + basic_string<_CharT, _Traits, _Alloc>:: + _M_replace_aux(size_type __pos1, size_type __n1, size_type __n2, + _CharT __c) + { + _M_check_length(__n1, __n2, "basic_string::_M_replace_aux"); + _M_mutate(__pos1, __n1, __n2); + if (__n2) + _M_assign(_M_data() + __pos1, __n2, __c); + return *this; + } + + template + basic_string<_CharT, _Traits, _Alloc>& + basic_string<_CharT, _Traits, _Alloc>:: + _M_replace_safe(size_type __pos1, size_type __n1, const _CharT* __s, + size_type __n2) + { + _M_mutate(__pos1, __n1, __n2); + if (__n2) + _M_copy(_M_data() + __pos1, __s, __n2); + return *this; + } + + template + basic_string<_CharT, _Traits, _Alloc> + operator+(const _CharT* __lhs, + const basic_string<_CharT, _Traits, _Alloc>& __rhs) + { + __glibcxx_requires_string(__lhs); + typedef basic_string<_CharT, _Traits, _Alloc> __string_type; + typedef typename __string_type::size_type __size_type; + const __size_type __len = _Traits::length(__lhs); + __string_type __str; + __str.reserve(__len + __rhs.size()); + __str.append(__lhs, __len); + __str.append(__rhs); + return __str; + } + + template + basic_string<_CharT, _Traits, _Alloc> + operator+(_CharT __lhs, const basic_string<_CharT, _Traits, _Alloc>& __rhs) + { + typedef basic_string<_CharT, _Traits, _Alloc> __string_type; + typedef typename __string_type::size_type __size_type; + __string_type __str; + const __size_type __len = __rhs.size(); + __str.reserve(__len + 1); + __str.append(__size_type(1), __lhs); + __str.append(__rhs); + return __str; + } + + template + typename basic_string<_CharT, _Traits, _Alloc>::size_type + basic_string<_CharT, _Traits, _Alloc>:: + copy(_CharT* __s, size_type __n, size_type __pos) const + { + _M_check(__pos, "basic_string::copy"); + __n = _M_limit(__pos, __n); + __glibcxx_requires_string_len(__s, __n); + if (__n) + _M_copy(__s, _M_data() + __pos, __n); + // 21.3.5.7 par 3: do not append null. (good.) + return __n; + } + + template + typename basic_string<_CharT, _Traits, _Alloc>::size_type + basic_string<_CharT, _Traits, _Alloc>:: + find(const _CharT* __s, size_type __pos, size_type __n) const + { + __glibcxx_requires_string_len(__s, __n); + const size_type __size = this->size(); + const _CharT* __data = _M_data(); + + if (__n == 0) + return __pos <= __size ? __pos : npos; + + if (__n <= __size) + { + for (; __pos <= __size - __n; ++__pos) + if (traits_type::eq(__data[__pos], __s[0]) + && traits_type::compare(__data + __pos + 1, + __s + 1, __n - 1) == 0) + return __pos; + } + return npos; + } + + template + typename basic_string<_CharT, _Traits, _Alloc>::size_type + basic_string<_CharT, _Traits, _Alloc>:: + find(_CharT __c, size_type __pos) const _GLIBCXX_NOEXCEPT + { + size_type __ret = npos; + const size_type __size = this->size(); + if (__pos < __size) + { + const _CharT* __data = _M_data(); + const size_type __n = __size - __pos; + const _CharT* __p = traits_type::find(__data + __pos, __n, __c); + if (__p) + __ret = __p - __data; + } + return __ret; + } + + template + typename basic_string<_CharT, _Traits, _Alloc>::size_type + basic_string<_CharT, _Traits, _Alloc>:: + rfind(const _CharT* __s, size_type __pos, size_type __n) const + { + __glibcxx_requires_string_len(__s, __n); + const size_type __size = this->size(); + if (__n <= __size) + { + __pos = std::min(size_type(__size - __n), __pos); + const _CharT* __data = _M_data(); + do + { + if (traits_type::compare(__data + __pos, __s, __n) == 0) + return __pos; + } + while (__pos-- > 0); + } + return npos; + } + + template + typename basic_string<_CharT, _Traits, _Alloc>::size_type + basic_string<_CharT, _Traits, _Alloc>:: + rfind(_CharT __c, size_type __pos) const _GLIBCXX_NOEXCEPT + { + size_type __size = this->size(); + if (__size) + { + if (--__size > __pos) + __size = __pos; + for (++__size; __size-- > 0; ) + if (traits_type::eq(_M_data()[__size], __c)) + return __size; + } + return npos; + } + + template + typename basic_string<_CharT, _Traits, _Alloc>::size_type + basic_string<_CharT, _Traits, _Alloc>:: + find_first_of(const _CharT* __s, size_type __pos, size_type __n) const + { + __glibcxx_requires_string_len(__s, __n); + for (; __n && __pos < this->size(); ++__pos) + { + const _CharT* __p = traits_type::find(__s, __n, _M_data()[__pos]); + if (__p) + return __pos; + } + return npos; + } + + template + typename basic_string<_CharT, _Traits, _Alloc>::size_type + basic_string<_CharT, _Traits, _Alloc>:: + find_last_of(const _CharT* __s, size_type __pos, size_type __n) const + { + __glibcxx_requires_string_len(__s, __n); + size_type __size = this->size(); + if (__size && __n) + { + if (--__size > __pos) + __size = __pos; + do + { + if (traits_type::find(__s, __n, _M_data()[__size])) + return __size; + } + while (__size-- != 0); + } + return npos; + } + + template + typename basic_string<_CharT, _Traits, _Alloc>::size_type + basic_string<_CharT, _Traits, _Alloc>:: + find_first_not_of(const _CharT* __s, size_type __pos, size_type __n) const + { + __glibcxx_requires_string_len(__s, __n); + for (; __pos < this->size(); ++__pos) + if (!traits_type::find(__s, __n, _M_data()[__pos])) + return __pos; + return npos; + } + + template + typename basic_string<_CharT, _Traits, _Alloc>::size_type + basic_string<_CharT, _Traits, _Alloc>:: + find_first_not_of(_CharT __c, size_type __pos) const _GLIBCXX_NOEXCEPT + { + for (; __pos < this->size(); ++__pos) + if (!traits_type::eq(_M_data()[__pos], __c)) + return __pos; + return npos; + } + + template + typename basic_string<_CharT, _Traits, _Alloc>::size_type + basic_string<_CharT, _Traits, _Alloc>:: + find_last_not_of(const _CharT* __s, size_type __pos, size_type __n) const + { + __glibcxx_requires_string_len(__s, __n); + size_type __size = this->size(); + if (__size) + { + if (--__size > __pos) + __size = __pos; + do + { + if (!traits_type::find(__s, __n, _M_data()[__size])) + return __size; + } + while (__size--); + } + return npos; + } + + template + typename basic_string<_CharT, _Traits, _Alloc>::size_type + basic_string<_CharT, _Traits, _Alloc>:: + find_last_not_of(_CharT __c, size_type __pos) const _GLIBCXX_NOEXCEPT + { + size_type __size = this->size(); + if (__size) + { + if (--__size > __pos) + __size = __pos; + do + { + if (!traits_type::eq(_M_data()[__size], __c)) + return __size; + } + while (__size--); + } + return npos; + } + + template + int + basic_string<_CharT, _Traits, _Alloc>:: + compare(size_type __pos, size_type __n, const basic_string& __str) const + { + _M_check(__pos, "basic_string::compare"); + __n = _M_limit(__pos, __n); + const size_type __osize = __str.size(); + const size_type __len = std::min(__n, __osize); + int __r = traits_type::compare(_M_data() + __pos, __str.data(), __len); + if (!__r) + __r = _S_compare(__n, __osize); + return __r; + } + + template + int + basic_string<_CharT, _Traits, _Alloc>:: + compare(size_type __pos1, size_type __n1, const basic_string& __str, + size_type __pos2, size_type __n2) const + { + _M_check(__pos1, "basic_string::compare"); + __str._M_check(__pos2, "basic_string::compare"); + __n1 = _M_limit(__pos1, __n1); + __n2 = __str._M_limit(__pos2, __n2); + const size_type __len = std::min(__n1, __n2); + int __r = traits_type::compare(_M_data() + __pos1, + __str.data() + __pos2, __len); + if (!__r) + __r = _S_compare(__n1, __n2); + return __r; + } + + template + int + basic_string<_CharT, _Traits, _Alloc>:: + compare(const _CharT* __s) const + { + __glibcxx_requires_string(__s); + const size_type __size = this->size(); + const size_type __osize = traits_type::length(__s); + const size_type __len = std::min(__size, __osize); + int __r = traits_type::compare(_M_data(), __s, __len); + if (!__r) + __r = _S_compare(__size, __osize); + return __r; + } + + template + int + basic_string <_CharT, _Traits, _Alloc>:: + compare(size_type __pos, size_type __n1, const _CharT* __s) const + { + __glibcxx_requires_string(__s); + _M_check(__pos, "basic_string::compare"); + __n1 = _M_limit(__pos, __n1); + const size_type __osize = traits_type::length(__s); + const size_type __len = std::min(__n1, __osize); + int __r = traits_type::compare(_M_data() + __pos, __s, __len); + if (!__r) + __r = _S_compare(__n1, __osize); + return __r; + } + + template + int + basic_string <_CharT, _Traits, _Alloc>:: + compare(size_type __pos, size_type __n1, const _CharT* __s, + size_type __n2) const + { + __glibcxx_requires_string_len(__s, __n2); + _M_check(__pos, "basic_string::compare"); + __n1 = _M_limit(__pos, __n1); + const size_type __len = std::min(__n1, __n2); + int __r = traits_type::compare(_M_data() + __pos, __s, __len); + if (!__r) + __r = _S_compare(__n1, __n2); + return __r; + } + + // 21.3.7.9 basic_string::getline and operators + template + basic_istream<_CharT, _Traits>& + operator>>(basic_istream<_CharT, _Traits>& __in, + basic_string<_CharT, _Traits, _Alloc>& __str) + { + typedef basic_istream<_CharT, _Traits> __istream_type; + typedef basic_string<_CharT, _Traits, _Alloc> __string_type; + typedef typename __istream_type::ios_base __ios_base; + typedef typename __istream_type::int_type __int_type; + typedef typename __string_type::size_type __size_type; + typedef ctype<_CharT> __ctype_type; + typedef typename __ctype_type::ctype_base __ctype_base; + + __size_type __extracted = 0; + typename __ios_base::iostate __err = __ios_base::goodbit; + typename __istream_type::sentry __cerb(__in, false); + if (__cerb) + { + __try + { + // Avoid reallocation for common case. + __str.erase(); + _CharT __buf[128]; + __size_type __len = 0; + const streamsize __w = __in.width(); + const __size_type __n = __w > 0 ? static_cast<__size_type>(__w) + : __str.max_size(); + const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc()); + const __int_type __eof = _Traits::eof(); + __int_type __c = __in.rdbuf()->sgetc(); + + while (__extracted < __n + && !_Traits::eq_int_type(__c, __eof) + && !__ct.is(__ctype_base::space, + _Traits::to_char_type(__c))) + { + if (__len == sizeof(__buf) / sizeof(_CharT)) + { + __str.append(__buf, sizeof(__buf) / sizeof(_CharT)); + __len = 0; + } + __buf[__len++] = _Traits::to_char_type(__c); + ++__extracted; + __c = __in.rdbuf()->snextc(); + } + __str.append(__buf, __len); + + if (_Traits::eq_int_type(__c, __eof)) + __err |= __ios_base::eofbit; + __in.width(0); + } + __catch(__cxxabiv1::__forced_unwind&) + { + __in._M_setstate(__ios_base::badbit); + __throw_exception_again; + } + __catch(...) + { + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 91. Description of operator>> and getline() for string<> + // might cause endless loop + __in._M_setstate(__ios_base::badbit); + } + } + // 211. operator>>(istream&, string&) doesn't set failbit + if (!__extracted) + __err |= __ios_base::failbit; + if (__err) + __in.setstate(__err); + return __in; + } + + template + basic_istream<_CharT, _Traits>& + getline(basic_istream<_CharT, _Traits>& __in, + basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim) + { + typedef basic_istream<_CharT, _Traits> __istream_type; + typedef basic_string<_CharT, _Traits, _Alloc> __string_type; + typedef typename __istream_type::ios_base __ios_base; + typedef typename __istream_type::int_type __int_type; + typedef typename __string_type::size_type __size_type; + + __size_type __extracted = 0; + const __size_type __n = __str.max_size(); + typename __ios_base::iostate __err = __ios_base::goodbit; + typename __istream_type::sentry __cerb(__in, true); + if (__cerb) + { + __try + { + __str.erase(); + const __int_type __idelim = _Traits::to_int_type(__delim); + const __int_type __eof = _Traits::eof(); + __int_type __c = __in.rdbuf()->sgetc(); + + while (__extracted < __n + && !_Traits::eq_int_type(__c, __eof) + && !_Traits::eq_int_type(__c, __idelim)) + { + __str += _Traits::to_char_type(__c); + ++__extracted; + __c = __in.rdbuf()->snextc(); + } + + if (_Traits::eq_int_type(__c, __eof)) + __err |= __ios_base::eofbit; + else if (_Traits::eq_int_type(__c, __idelim)) + { + ++__extracted; + __in.rdbuf()->sbumpc(); + } + else + __err |= __ios_base::failbit; + } + __catch(__cxxabiv1::__forced_unwind&) + { + __in._M_setstate(__ios_base::badbit); + __throw_exception_again; + } + __catch(...) + { + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 91. Description of operator>> and getline() for string<> + // might cause endless loop + __in._M_setstate(__ios_base::badbit); + } + } + if (!__extracted) + __err |= __ios_base::failbit; + if (__err) + __in.setstate(__err); + return __in; + } + + // Inhibit implicit instantiations for required instantiations, + // which are defined via explicit instantiations elsewhere. +#if _GLIBCXX_EXTERN_TEMPLATE > 0 + extern template class basic_string; + extern template + basic_istream& + operator>>(basic_istream&, string&); + extern template + basic_ostream& + operator<<(basic_ostream&, const string&); + extern template + basic_istream& + getline(basic_istream&, string&, char); + extern template + basic_istream& + getline(basic_istream&, string&); + +#ifdef _GLIBCXX_USE_WCHAR_T + extern template class basic_string; + extern template + basic_istream& + operator>>(basic_istream&, wstring&); + extern template + basic_ostream& + operator<<(basic_ostream&, const wstring&); + extern template + basic_istream& + getline(basic_istream&, wstring&, wchar_t); + extern template + basic_istream& + getline(basic_istream&, wstring&); +#endif +#endif + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace std + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/boost_concept_check.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/boost_concept_check.h new file mode 100755 index 0000000..79e2d5a --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/boost_concept_check.h @@ -0,0 +1,790 @@ +// -*- C++ -*- + +// Copyright (C) 2004-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +// (C) Copyright Jeremy Siek 2000. Permission to copy, use, modify, +// sell and distribute this software is granted provided this +// copyright notice appears in all copies. This software is provided +// "as is" without express or implied warranty, and with no claim as +// to its suitability for any purpose. +// + +/** @file bits/boost_concept_check.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{iterator} + */ + +// GCC Note: based on version 1.12.0 of the Boost library. + +#ifndef _BOOST_CONCEPT_CHECK_H +#define _BOOST_CONCEPT_CHECK_H 1 + +#pragma GCC system_header + +#include +#include // for traits and tags + +namespace __gnu_cxx _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + +#define _IsUnused __attribute__ ((__unused__)) + +// When the C-C code is in use, we would like this function to do as little +// as possible at runtime, use as few resources as possible, and hopefully +// be elided out of existence... hmmm. +template +inline void __function_requires() +{ + void (_Concept::*__x)() _IsUnused = &_Concept::__constraints; +} + +// No definition: if this is referenced, there's a problem with +// the instantiating type not being one of the required integer types. +// Unfortunately, this results in a link-time error, not a compile-time error. +void __error_type_must_be_an_integer_type(); +void __error_type_must_be_an_unsigned_integer_type(); +void __error_type_must_be_a_signed_integer_type(); + +// ??? Should the "concept_checking*" structs begin with more than _ ? +#define _GLIBCXX_CLASS_REQUIRES(_type_var, _ns, _concept) \ + typedef void (_ns::_concept <_type_var>::* _func##_type_var##_concept)(); \ + template <_func##_type_var##_concept _Tp1> \ + struct _concept_checking##_type_var##_concept { }; \ + typedef _concept_checking##_type_var##_concept< \ + &_ns::_concept <_type_var>::__constraints> \ + _concept_checking_typedef##_type_var##_concept + +#define _GLIBCXX_CLASS_REQUIRES2(_type_var1, _type_var2, _ns, _concept) \ + typedef void (_ns::_concept <_type_var1,_type_var2>::* _func##_type_var1##_type_var2##_concept)(); \ + template <_func##_type_var1##_type_var2##_concept _Tp1> \ + struct _concept_checking##_type_var1##_type_var2##_concept { }; \ + typedef _concept_checking##_type_var1##_type_var2##_concept< \ + &_ns::_concept <_type_var1,_type_var2>::__constraints> \ + _concept_checking_typedef##_type_var1##_type_var2##_concept + +#define _GLIBCXX_CLASS_REQUIRES3(_type_var1, _type_var2, _type_var3, _ns, _concept) \ + typedef void (_ns::_concept <_type_var1,_type_var2,_type_var3>::* _func##_type_var1##_type_var2##_type_var3##_concept)(); \ + template <_func##_type_var1##_type_var2##_type_var3##_concept _Tp1> \ + struct _concept_checking##_type_var1##_type_var2##_type_var3##_concept { }; \ + typedef _concept_checking##_type_var1##_type_var2##_type_var3##_concept< \ + &_ns::_concept <_type_var1,_type_var2,_type_var3>::__constraints> \ + _concept_checking_typedef##_type_var1##_type_var2##_type_var3##_concept + +#define _GLIBCXX_CLASS_REQUIRES4(_type_var1, _type_var2, _type_var3, _type_var4, _ns, _concept) \ + typedef void (_ns::_concept <_type_var1,_type_var2,_type_var3,_type_var4>::* _func##_type_var1##_type_var2##_type_var3##_type_var4##_concept)(); \ + template <_func##_type_var1##_type_var2##_type_var3##_type_var4##_concept _Tp1> \ + struct _concept_checking##_type_var1##_type_var2##_type_var3##_type_var4##_concept { }; \ + typedef _concept_checking##_type_var1##_type_var2##_type_var3##_type_var4##_concept< \ + &_ns::_concept <_type_var1,_type_var2,_type_var3,_type_var4>::__constraints> \ + _concept_checking_typedef##_type_var1##_type_var2##_type_var3##_type_var4##_concept + + +template +struct _Aux_require_same { }; + +template +struct _Aux_require_same<_Tp,_Tp> { typedef _Tp _Type; }; + + template + struct _SameTypeConcept + { + void __constraints() { + typedef typename _Aux_require_same<_Tp1, _Tp2>::_Type _Required; + } + }; + + template + struct _IntegerConcept { + void __constraints() { + __error_type_must_be_an_integer_type(); + } + }; + template <> struct _IntegerConcept { void __constraints() {} }; + template <> struct _IntegerConcept { void __constraints(){} }; + template <> struct _IntegerConcept { void __constraints() {} }; + template <> struct _IntegerConcept { void __constraints() {} }; + template <> struct _IntegerConcept { void __constraints() {} }; + template <> struct _IntegerConcept { void __constraints() {} }; + template <> struct _IntegerConcept { void __constraints() {} }; + template <> struct _IntegerConcept + { void __constraints() {} }; + + template + struct _SignedIntegerConcept { + void __constraints() { + __error_type_must_be_a_signed_integer_type(); + } + }; + template <> struct _SignedIntegerConcept { void __constraints() {} }; + template <> struct _SignedIntegerConcept { void __constraints() {} }; + template <> struct _SignedIntegerConcept { void __constraints() {} }; + template <> struct _SignedIntegerConcept { void __constraints(){}}; + + template + struct _UnsignedIntegerConcept { + void __constraints() { + __error_type_must_be_an_unsigned_integer_type(); + } + }; + template <> struct _UnsignedIntegerConcept + { void __constraints() {} }; + template <> struct _UnsignedIntegerConcept + { void __constraints() {} }; + template <> struct _UnsignedIntegerConcept + { void __constraints() {} }; + template <> struct _UnsignedIntegerConcept + { void __constraints() {} }; + + //=========================================================================== + // Basic Concepts + + template + struct _DefaultConstructibleConcept + { + void __constraints() { + _Tp __a _IsUnused; // require default constructor + } + }; + + template + struct _AssignableConcept + { + void __constraints() { + __a = __a; // require assignment operator + __const_constraints(__a); + } + void __const_constraints(const _Tp& __b) { + __a = __b; // const required for argument to assignment + } + _Tp __a; + // possibly should be "Tp* a;" and then dereference "a" in constraint + // functions? present way would require a default ctor, i think... + }; + + template + struct _CopyConstructibleConcept + { + void __constraints() { + _Tp __a(__b); // require copy constructor + _Tp* __ptr _IsUnused = &__a; // require address of operator + __const_constraints(__a); + } + void __const_constraints(const _Tp& __a) { + _Tp __c _IsUnused(__a); // require const copy constructor + const _Tp* __ptr _IsUnused = &__a; // require const address of operator + } + _Tp __b; + }; + + // The SGI STL version of Assignable requires copy constructor and operator= + template + struct _SGIAssignableConcept + { + void __constraints() { + _Tp __b _IsUnused(__a); + __a = __a; // require assignment operator + __const_constraints(__a); + } + void __const_constraints(const _Tp& __b) { + _Tp __c _IsUnused(__b); + __a = __b; // const required for argument to assignment + } + _Tp __a; + }; + + template + struct _ConvertibleConcept + { + void __constraints() { + _To __y _IsUnused = __x; + } + _From __x; + }; + + // The C++ standard requirements for many concepts talk about return + // types that must be "convertible to bool". The problem with this + // requirement is that it leaves the door open for evil proxies that + // define things like operator|| with strange return types. Two + // possible solutions are: + // 1) require the return type to be exactly bool + // 2) stay with convertible to bool, and also + // specify stuff about all the logical operators. + // For now we just test for convertible to bool. + template + void __aux_require_boolean_expr(const _Tp& __t) { + bool __x _IsUnused = __t; + } + +// FIXME + template + struct _EqualityComparableConcept + { + void __constraints() { + __aux_require_boolean_expr(__a == __b); + } + _Tp __a, __b; + }; + + template + struct _LessThanComparableConcept + { + void __constraints() { + __aux_require_boolean_expr(__a < __b); + } + _Tp __a, __b; + }; + + // This is equivalent to SGI STL's LessThanComparable. + template + struct _ComparableConcept + { + void __constraints() { + __aux_require_boolean_expr(__a < __b); + __aux_require_boolean_expr(__a > __b); + __aux_require_boolean_expr(__a <= __b); + __aux_require_boolean_expr(__a >= __b); + } + _Tp __a, __b; + }; + +#define _GLIBCXX_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(_OP,_NAME) \ + template \ + struct _NAME { \ + void __constraints() { (void)__constraints_(); } \ + bool __constraints_() { \ + return __a _OP __b; \ + } \ + _First __a; \ + _Second __b; \ + } + +#define _GLIBCXX_DEFINE_BINARY_OPERATOR_CONSTRAINT(_OP,_NAME) \ + template \ + struct _NAME { \ + void __constraints() { (void)__constraints_(); } \ + _Ret __constraints_() { \ + return __a _OP __b; \ + } \ + _First __a; \ + _Second __b; \ + } + + _GLIBCXX_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(==, _EqualOpConcept); + _GLIBCXX_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(!=, _NotEqualOpConcept); + _GLIBCXX_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(<, _LessThanOpConcept); + _GLIBCXX_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(<=, _LessEqualOpConcept); + _GLIBCXX_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(>, _GreaterThanOpConcept); + _GLIBCXX_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(>=, _GreaterEqualOpConcept); + + _GLIBCXX_DEFINE_BINARY_OPERATOR_CONSTRAINT(+, _PlusOpConcept); + _GLIBCXX_DEFINE_BINARY_OPERATOR_CONSTRAINT(*, _TimesOpConcept); + _GLIBCXX_DEFINE_BINARY_OPERATOR_CONSTRAINT(/, _DivideOpConcept); + _GLIBCXX_DEFINE_BINARY_OPERATOR_CONSTRAINT(-, _SubtractOpConcept); + _GLIBCXX_DEFINE_BINARY_OPERATOR_CONSTRAINT(%, _ModOpConcept); + +#undef _GLIBCXX_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT +#undef _GLIBCXX_DEFINE_BINARY_OPERATOR_CONSTRAINT + + //=========================================================================== + // Function Object Concepts + + template + struct _GeneratorConcept + { + void __constraints() { + const _Return& __r _IsUnused = __f();// require operator() member function + } + _Func __f; + }; + + + template + struct _GeneratorConcept<_Func,void> + { + void __constraints() { + __f(); // require operator() member function + } + _Func __f; + }; + + template + struct _UnaryFunctionConcept + { + void __constraints() { + __r = __f(__arg); // require operator() + } + _Func __f; + _Arg __arg; + _Return __r; + }; + + template + struct _UnaryFunctionConcept<_Func, void, _Arg> { + void __constraints() { + __f(__arg); // require operator() + } + _Func __f; + _Arg __arg; + }; + + template + struct _BinaryFunctionConcept + { + void __constraints() { + __r = __f(__first, __second); // require operator() + } + _Func __f; + _First __first; + _Second __second; + _Return __r; + }; + + template + struct _BinaryFunctionConcept<_Func, void, _First, _Second> + { + void __constraints() { + __f(__first, __second); // require operator() + } + _Func __f; + _First __first; + _Second __second; + }; + + template + struct _UnaryPredicateConcept + { + void __constraints() { + __aux_require_boolean_expr(__f(__arg)); // require op() returning bool + } + _Func __f; + _Arg __arg; + }; + + template + struct _BinaryPredicateConcept + { + void __constraints() { + __aux_require_boolean_expr(__f(__a, __b)); // require op() returning bool + } + _Func __f; + _First __a; + _Second __b; + }; + + // use this when functor is used inside a container class like std::set + template + struct _Const_BinaryPredicateConcept { + void __constraints() { + __const_constraints(__f); + } + void __const_constraints(const _Func& __fun) { + __function_requires<_BinaryPredicateConcept<_Func, _First, _Second> >(); + // operator() must be a const member function + __aux_require_boolean_expr(__fun(__a, __b)); + } + _Func __f; + _First __a; + _Second __b; + }; + + //=========================================================================== + // Iterator Concepts + + template + struct _TrivialIteratorConcept + { + void __constraints() { +// __function_requires< _DefaultConstructibleConcept<_Tp> >(); + __function_requires< _AssignableConcept<_Tp> >(); + __function_requires< _EqualityComparableConcept<_Tp> >(); +// typedef typename std::iterator_traits<_Tp>::value_type _V; + (void)*__i; // require dereference operator + } + _Tp __i; + }; + + template + struct _Mutable_TrivialIteratorConcept + { + void __constraints() { + __function_requires< _TrivialIteratorConcept<_Tp> >(); + *__i = *__j; // require dereference and assignment + } + _Tp __i, __j; + }; + + template + struct _InputIteratorConcept + { + void __constraints() { + __function_requires< _TrivialIteratorConcept<_Tp> >(); + // require iterator_traits typedef's + typedef typename std::iterator_traits<_Tp>::difference_type _Diff; +// __function_requires< _SignedIntegerConcept<_Diff> >(); + typedef typename std::iterator_traits<_Tp>::reference _Ref; + typedef typename std::iterator_traits<_Tp>::pointer _Pt; + typedef typename std::iterator_traits<_Tp>::iterator_category _Cat; + __function_requires< _ConvertibleConcept< + typename std::iterator_traits<_Tp>::iterator_category, + std::input_iterator_tag> >(); + ++__i; // require preincrement operator + __i++; // require postincrement operator + } + _Tp __i; + }; + + template + struct _OutputIteratorConcept + { + void __constraints() { + __function_requires< _AssignableConcept<_Tp> >(); + ++__i; // require preincrement operator + __i++; // require postincrement operator + *__i++ = __t; // require postincrement and assignment + } + _Tp __i; + _ValueT __t; + }; + + template + struct _ForwardIteratorConcept + { + void __constraints() { + __function_requires< _InputIteratorConcept<_Tp> >(); + __function_requires< _DefaultConstructibleConcept<_Tp> >(); + __function_requires< _ConvertibleConcept< + typename std::iterator_traits<_Tp>::iterator_category, + std::forward_iterator_tag> >(); + typedef typename std::iterator_traits<_Tp>::reference _Ref; + _Ref __r _IsUnused = *__i; + } + _Tp __i; + }; + + template + struct _Mutable_ForwardIteratorConcept + { + void __constraints() { + __function_requires< _ForwardIteratorConcept<_Tp> >(); + *__i++ = *__i; // require postincrement and assignment + } + _Tp __i; + }; + + template + struct _BidirectionalIteratorConcept + { + void __constraints() { + __function_requires< _ForwardIteratorConcept<_Tp> >(); + __function_requires< _ConvertibleConcept< + typename std::iterator_traits<_Tp>::iterator_category, + std::bidirectional_iterator_tag> >(); + --__i; // require predecrement operator + __i--; // require postdecrement operator + } + _Tp __i; + }; + + template + struct _Mutable_BidirectionalIteratorConcept + { + void __constraints() { + __function_requires< _BidirectionalIteratorConcept<_Tp> >(); + __function_requires< _Mutable_ForwardIteratorConcept<_Tp> >(); + *__i-- = *__i; // require postdecrement and assignment + } + _Tp __i; + }; + + + template + struct _RandomAccessIteratorConcept + { + void __constraints() { + __function_requires< _BidirectionalIteratorConcept<_Tp> >(); + __function_requires< _ComparableConcept<_Tp> >(); + __function_requires< _ConvertibleConcept< + typename std::iterator_traits<_Tp>::iterator_category, + std::random_access_iterator_tag> >(); + // ??? We don't use _Ref, are we just checking for "referenceability"? + typedef typename std::iterator_traits<_Tp>::reference _Ref; + + __i += __n; // require assignment addition operator + __i = __i + __n; __i = __n + __i; // require addition with difference type + __i -= __n; // require assignment subtraction op + __i = __i - __n; // require subtraction with + // difference type + __n = __i - __j; // require difference operator + (void)__i[__n]; // require element access operator + } + _Tp __a, __b; + _Tp __i, __j; + typename std::iterator_traits<_Tp>::difference_type __n; + }; + + template + struct _Mutable_RandomAccessIteratorConcept + { + void __constraints() { + __function_requires< _RandomAccessIteratorConcept<_Tp> >(); + __function_requires< _Mutable_BidirectionalIteratorConcept<_Tp> >(); + __i[__n] = *__i; // require element access and assignment + } + _Tp __i; + typename std::iterator_traits<_Tp>::difference_type __n; + }; + + //=========================================================================== + // Container Concepts + + template + struct _ContainerConcept + { + typedef typename _Container::value_type _Value_type; + typedef typename _Container::difference_type _Difference_type; + typedef typename _Container::size_type _Size_type; + typedef typename _Container::const_reference _Const_reference; + typedef typename _Container::const_pointer _Const_pointer; + typedef typename _Container::const_iterator _Const_iterator; + + void __constraints() { + __function_requires< _InputIteratorConcept<_Const_iterator> >(); + __function_requires< _AssignableConcept<_Container> >(); + const _Container __c; + __i = __c.begin(); + __i = __c.end(); + __n = __c.size(); + __n = __c.max_size(); + __b = __c.empty(); + } + bool __b; + _Const_iterator __i; + _Size_type __n; + }; + + template + struct _Mutable_ContainerConcept + { + typedef typename _Container::value_type _Value_type; + typedef typename _Container::reference _Reference; + typedef typename _Container::iterator _Iterator; + typedef typename _Container::pointer _Pointer; + + void __constraints() { + __function_requires< _ContainerConcept<_Container> >(); + __function_requires< _AssignableConcept<_Value_type> >(); + __function_requires< _InputIteratorConcept<_Iterator> >(); + + __i = __c.begin(); + __i = __c.end(); + __c.swap(__c2); + } + _Iterator __i; + _Container __c, __c2; + }; + + template + struct _ForwardContainerConcept + { + void __constraints() { + __function_requires< _ContainerConcept<_ForwardContainer> >(); + typedef typename _ForwardContainer::const_iterator _Const_iterator; + __function_requires< _ForwardIteratorConcept<_Const_iterator> >(); + } + }; + + template + struct _Mutable_ForwardContainerConcept + { + void __constraints() { + __function_requires< _ForwardContainerConcept<_ForwardContainer> >(); + __function_requires< _Mutable_ContainerConcept<_ForwardContainer> >(); + typedef typename _ForwardContainer::iterator _Iterator; + __function_requires< _Mutable_ForwardIteratorConcept<_Iterator> >(); + } + }; + + template + struct _ReversibleContainerConcept + { + typedef typename _ReversibleContainer::const_iterator _Const_iterator; + typedef typename _ReversibleContainer::const_reverse_iterator + _Const_reverse_iterator; + + void __constraints() { + __function_requires< _ForwardContainerConcept<_ReversibleContainer> >(); + __function_requires< _BidirectionalIteratorConcept<_Const_iterator> >(); + __function_requires< + _BidirectionalIteratorConcept<_Const_reverse_iterator> >(); + + const _ReversibleContainer __c; + _Const_reverse_iterator __i = __c.rbegin(); + __i = __c.rend(); + } + }; + + template + struct _Mutable_ReversibleContainerConcept + { + typedef typename _ReversibleContainer::iterator _Iterator; + typedef typename _ReversibleContainer::reverse_iterator _Reverse_iterator; + + void __constraints() { + __function_requires<_ReversibleContainerConcept<_ReversibleContainer> >(); + __function_requires< + _Mutable_ForwardContainerConcept<_ReversibleContainer> >(); + __function_requires<_Mutable_BidirectionalIteratorConcept<_Iterator> >(); + __function_requires< + _Mutable_BidirectionalIteratorConcept<_Reverse_iterator> >(); + + _Reverse_iterator __i = __c.rbegin(); + __i = __c.rend(); + } + _ReversibleContainer __c; + }; + + template + struct _RandomAccessContainerConcept + { + typedef typename _RandomAccessContainer::size_type _Size_type; + typedef typename _RandomAccessContainer::const_reference _Const_reference; + typedef typename _RandomAccessContainer::const_iterator _Const_iterator; + typedef typename _RandomAccessContainer::const_reverse_iterator + _Const_reverse_iterator; + + void __constraints() { + __function_requires< + _ReversibleContainerConcept<_RandomAccessContainer> >(); + __function_requires< _RandomAccessIteratorConcept<_Const_iterator> >(); + __function_requires< + _RandomAccessIteratorConcept<_Const_reverse_iterator> >(); + + const _RandomAccessContainer __c; + _Const_reference __r _IsUnused = __c[__n]; + } + _Size_type __n; + }; + + template + struct _Mutable_RandomAccessContainerConcept + { + typedef typename _RandomAccessContainer::size_type _Size_type; + typedef typename _RandomAccessContainer::reference _Reference; + typedef typename _RandomAccessContainer::iterator _Iterator; + typedef typename _RandomAccessContainer::reverse_iterator _Reverse_iterator; + + void __constraints() { + __function_requires< + _RandomAccessContainerConcept<_RandomAccessContainer> >(); + __function_requires< + _Mutable_ReversibleContainerConcept<_RandomAccessContainer> >(); + __function_requires< _Mutable_RandomAccessIteratorConcept<_Iterator> >(); + __function_requires< + _Mutable_RandomAccessIteratorConcept<_Reverse_iterator> >(); + + _Reference __r _IsUnused = __c[__i]; + } + _Size_type __i; + _RandomAccessContainer __c; + }; + + // A Sequence is inherently mutable + template + struct _SequenceConcept + { + typedef typename _Sequence::reference _Reference; + typedef typename _Sequence::const_reference _Const_reference; + + void __constraints() { + // Matt Austern's book puts DefaultConstructible here, the C++ + // standard places it in Container + // function_requires< DefaultConstructible >(); + __function_requires< _Mutable_ForwardContainerConcept<_Sequence> >(); + __function_requires< _DefaultConstructibleConcept<_Sequence> >(); + + _Sequence + __c _IsUnused(__n, __t), + __c2 _IsUnused(__first, __last); + + __c.insert(__p, __t); + __c.insert(__p, __n, __t); + __c.insert(__p, __first, __last); + + __c.erase(__p); + __c.erase(__p, __q); + + _Reference __r _IsUnused = __c.front(); + + __const_constraints(__c); + } + void __const_constraints(const _Sequence& __c) { + _Const_reference __r _IsUnused = __c.front(); + } + typename _Sequence::value_type __t; + typename _Sequence::size_type __n; + typename _Sequence::value_type *__first, *__last; + typename _Sequence::iterator __p, __q; + }; + + template + struct _FrontInsertionSequenceConcept + { + void __constraints() { + __function_requires< _SequenceConcept<_FrontInsertionSequence> >(); + + __c.push_front(__t); + __c.pop_front(); + } + _FrontInsertionSequence __c; + typename _FrontInsertionSequence::value_type __t; + }; + + template + struct _BackInsertionSequenceConcept + { + typedef typename _BackInsertionSequence::reference _Reference; + typedef typename _BackInsertionSequence::const_reference _Const_reference; + + void __constraints() { + __function_requires< _SequenceConcept<_BackInsertionSequence> >(); + + __c.push_back(__t); + __c.pop_back(); + _Reference __r _IsUnused = __c.back(); + } + void __const_constraints(const _BackInsertionSequence& __c) { + _Const_reference __r _IsUnused = __c.back(); + }; + _BackInsertionSequence __c; + typename _BackInsertionSequence::value_type __t; + }; + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#undef _IsUnused + +#endif // _GLIBCXX_BOOST_CONCEPT_CHECK + + diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/c++0x_warning.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/c++0x_warning.h new file mode 100755 index 0000000..3bfba48 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/c++0x_warning.h @@ -0,0 +1,37 @@ +// Copyright (C) 2007-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file bits/c++0x_warning.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{iosfwd} + */ + +#ifndef _CXX0X_WARNING_H +#define _CXX0X_WARNING_H 1 + +#if __cplusplus < 201103L +#error This file requires compiler and library support for the \ +ISO C++ 2011 standard. This support is currently experimental, and must be \ +enabled with the -std=c++11 or -std=gnu++11 compiler options. +#endif + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/c++14_warning.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/c++14_warning.h new file mode 100755 index 0000000..6bfe435 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/c++14_warning.h @@ -0,0 +1,37 @@ +// Copyright (C) 2013-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file bits/c++14_warning.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{iosfwd} + */ + +#ifndef _CXX14_WARNING_H +#define _CXX14_WARNING_H 1 + +#if __cplusplus <= 201103L +#error This file requires compiler and library support for the forthcoming \ +ISO C++ 2014 standard. This support is currently experimental, and must be \ +enabled with the -std=c++1y or -std=gnu++1y compiler options. +#endif + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/char_traits.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/char_traits.h new file mode 100755 index 0000000..8c3bf96 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/char_traits.h @@ -0,0 +1,577 @@ +// Character Traits for use by standard string and iostream -*- C++ -*- + +// Copyright (C) 1997-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file bits/char_traits.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{string} + */ + +// +// ISO C++ 14882: 21 Strings library +// + +#ifndef _CHAR_TRAITS_H +#define _CHAR_TRAITS_H 1 + +#pragma GCC system_header + +#include // std::copy, std::fill_n +#include // For streampos +#include // For WEOF, wmemmove, wmemset, etc. + +namespace __gnu_cxx _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /** + * @brief Mapping from character type to associated types. + * + * @note This is an implementation class for the generic version + * of char_traits. It defines int_type, off_type, pos_type, and + * state_type. By default these are unsigned long, streamoff, + * streampos, and mbstate_t. Users who need a different set of + * types, but who don't need to change the definitions of any function + * defined in char_traits, can specialize __gnu_cxx::_Char_types + * while leaving __gnu_cxx::char_traits alone. */ + template + struct _Char_types + { + typedef unsigned long int_type; + typedef std::streampos pos_type; + typedef std::streamoff off_type; + typedef std::mbstate_t state_type; + }; + + + /** + * @brief Base class used to implement std::char_traits. + * + * @note For any given actual character type, this definition is + * probably wrong. (Most of the member functions are likely to be + * right, but the int_type and state_type typedefs, and the eof() + * member function, are likely to be wrong.) The reason this class + * exists is so users can specialize it. Classes in namespace std + * may not be specialized for fundamental types, but classes in + * namespace __gnu_cxx may be. + * + * See http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt05ch13s03.html + * for advice on how to make use of this class for @a unusual character + * types. Also, check out include/ext/pod_char_traits.h. + */ + template + struct char_traits + { + typedef _CharT char_type; + typedef typename _Char_types<_CharT>::int_type int_type; + typedef typename _Char_types<_CharT>::pos_type pos_type; + typedef typename _Char_types<_CharT>::off_type off_type; + typedef typename _Char_types<_CharT>::state_type state_type; + + static void + assign(char_type& __c1, const char_type& __c2) + { __c1 = __c2; } + + static _GLIBCXX_CONSTEXPR bool + eq(const char_type& __c1, const char_type& __c2) + { return __c1 == __c2; } + + static _GLIBCXX_CONSTEXPR bool + lt(const char_type& __c1, const char_type& __c2) + { return __c1 < __c2; } + + static int + compare(const char_type* __s1, const char_type* __s2, std::size_t __n); + + static std::size_t + length(const char_type* __s); + + static const char_type* + find(const char_type* __s, std::size_t __n, const char_type& __a); + + static char_type* + move(char_type* __s1, const char_type* __s2, std::size_t __n); + + static char_type* + copy(char_type* __s1, const char_type* __s2, std::size_t __n); + + static char_type* + assign(char_type* __s, std::size_t __n, char_type __a); + + static _GLIBCXX_CONSTEXPR char_type + to_char_type(const int_type& __c) + { return static_cast(__c); } + + static _GLIBCXX_CONSTEXPR int_type + to_int_type(const char_type& __c) + { return static_cast(__c); } + + static _GLIBCXX_CONSTEXPR bool + eq_int_type(const int_type& __c1, const int_type& __c2) + { return __c1 == __c2; } + + static _GLIBCXX_CONSTEXPR int_type + eof() + { return static_cast(_GLIBCXX_STDIO_EOF); } + + static _GLIBCXX_CONSTEXPR int_type + not_eof(const int_type& __c) + { return !eq_int_type(__c, eof()) ? __c : to_int_type(char_type()); } + }; + + template + int + char_traits<_CharT>:: + compare(const char_type* __s1, const char_type* __s2, std::size_t __n) + { + for (std::size_t __i = 0; __i < __n; ++__i) + if (lt(__s1[__i], __s2[__i])) + return -1; + else if (lt(__s2[__i], __s1[__i])) + return 1; + return 0; + } + + template + std::size_t + char_traits<_CharT>:: + length(const char_type* __p) + { + std::size_t __i = 0; + while (!eq(__p[__i], char_type())) + ++__i; + return __i; + } + + template + const typename char_traits<_CharT>::char_type* + char_traits<_CharT>:: + find(const char_type* __s, std::size_t __n, const char_type& __a) + { + for (std::size_t __i = 0; __i < __n; ++__i) + if (eq(__s[__i], __a)) + return __s + __i; + return 0; + } + + template + typename char_traits<_CharT>::char_type* + char_traits<_CharT>:: + move(char_type* __s1, const char_type* __s2, std::size_t __n) + { + return static_cast<_CharT*>(__builtin_memmove(__s1, __s2, + __n * sizeof(char_type))); + } + + template + typename char_traits<_CharT>::char_type* + char_traits<_CharT>:: + copy(char_type* __s1, const char_type* __s2, std::size_t __n) + { + // NB: Inline std::copy so no recursive dependencies. + std::copy(__s2, __s2 + __n, __s1); + return __s1; + } + + template + typename char_traits<_CharT>::char_type* + char_traits<_CharT>:: + assign(char_type* __s, std::size_t __n, char_type __a) + { + // NB: Inline std::fill_n so no recursive dependencies. + std::fill_n(__s, __n, __a); + return __s; + } + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + // 21.1 + /** + * @brief Basis for explicit traits specializations. + * + * @note For any given actual character type, this definition is + * probably wrong. Since this is just a thin wrapper around + * __gnu_cxx::char_traits, it is possible to achieve a more + * appropriate definition by specializing __gnu_cxx::char_traits. + * + * See http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt05ch13s03.html + * for advice on how to make use of this class for @a unusual character + * types. Also, check out include/ext/pod_char_traits.h. + */ + template + struct char_traits : public __gnu_cxx::char_traits<_CharT> + { }; + + + /// 21.1.3.1 char_traits specializations + template<> + struct char_traits + { + typedef char char_type; + typedef int int_type; + typedef streampos pos_type; + typedef streamoff off_type; + typedef mbstate_t state_type; + + static void + assign(char_type& __c1, const char_type& __c2) _GLIBCXX_NOEXCEPT + { __c1 = __c2; } + + static _GLIBCXX_CONSTEXPR bool + eq(const char_type& __c1, const char_type& __c2) _GLIBCXX_NOEXCEPT + { return __c1 == __c2; } + + static _GLIBCXX_CONSTEXPR bool + lt(const char_type& __c1, const char_type& __c2) _GLIBCXX_NOEXCEPT + { + // LWG 467. + return (static_cast(__c1) + < static_cast(__c2)); + } + + static int + compare(const char_type* __s1, const char_type* __s2, size_t __n) + { return __builtin_memcmp(__s1, __s2, __n); } + + static size_t + length(const char_type* __s) + { return __builtin_strlen(__s); } + + static const char_type* + find(const char_type* __s, size_t __n, const char_type& __a) + { return static_cast(__builtin_memchr(__s, __a, __n)); } + + static char_type* + move(char_type* __s1, const char_type* __s2, size_t __n) + { return static_cast(__builtin_memmove(__s1, __s2, __n)); } + + static char_type* + copy(char_type* __s1, const char_type* __s2, size_t __n) + { return static_cast(__builtin_memcpy(__s1, __s2, __n)); } + + static char_type* + assign(char_type* __s, size_t __n, char_type __a) + { return static_cast(__builtin_memset(__s, __a, __n)); } + + static _GLIBCXX_CONSTEXPR char_type + to_char_type(const int_type& __c) _GLIBCXX_NOEXCEPT + { return static_cast(__c); } + + // To keep both the byte 0xff and the eof symbol 0xffffffff + // from ending up as 0xffffffff. + static _GLIBCXX_CONSTEXPR int_type + to_int_type(const char_type& __c) _GLIBCXX_NOEXCEPT + { return static_cast(static_cast(__c)); } + + static _GLIBCXX_CONSTEXPR bool + eq_int_type(const int_type& __c1, const int_type& __c2) _GLIBCXX_NOEXCEPT + { return __c1 == __c2; } + + static _GLIBCXX_CONSTEXPR int_type + eof() _GLIBCXX_NOEXCEPT + { return static_cast(_GLIBCXX_STDIO_EOF); } + + static _GLIBCXX_CONSTEXPR int_type + not_eof(const int_type& __c) _GLIBCXX_NOEXCEPT + { return (__c == eof()) ? 0 : __c; } + }; + + +#ifdef _GLIBCXX_USE_WCHAR_T + /// 21.1.3.2 char_traits specializations + template<> + struct char_traits + { + typedef wchar_t char_type; + typedef wint_t int_type; + typedef streamoff off_type; + typedef wstreampos pos_type; + typedef mbstate_t state_type; + + static void + assign(char_type& __c1, const char_type& __c2) _GLIBCXX_NOEXCEPT + { __c1 = __c2; } + + static _GLIBCXX_CONSTEXPR bool + eq(const char_type& __c1, const char_type& __c2) _GLIBCXX_NOEXCEPT + { return __c1 == __c2; } + + static _GLIBCXX_CONSTEXPR bool + lt(const char_type& __c1, const char_type& __c2) _GLIBCXX_NOEXCEPT + { return __c1 < __c2; } + + static int + compare(const char_type* __s1, const char_type* __s2, size_t __n) + { return wmemcmp(__s1, __s2, __n); } + + static size_t + length(const char_type* __s) + { return wcslen(__s); } + + static const char_type* + find(const char_type* __s, size_t __n, const char_type& __a) + { return wmemchr(__s, __a, __n); } + + static char_type* + move(char_type* __s1, const char_type* __s2, size_t __n) + { return wmemmove(__s1, __s2, __n); } + + static char_type* + copy(char_type* __s1, const char_type* __s2, size_t __n) + { return wmemcpy(__s1, __s2, __n); } + + static char_type* + assign(char_type* __s, size_t __n, char_type __a) + { return wmemset(__s, __a, __n); } + + static _GLIBCXX_CONSTEXPR char_type + to_char_type(const int_type& __c) _GLIBCXX_NOEXCEPT + { return char_type(__c); } + + static _GLIBCXX_CONSTEXPR int_type + to_int_type(const char_type& __c) _GLIBCXX_NOEXCEPT + { return int_type(__c); } + + static _GLIBCXX_CONSTEXPR bool + eq_int_type(const int_type& __c1, const int_type& __c2) _GLIBCXX_NOEXCEPT + { return __c1 == __c2; } + + static _GLIBCXX_CONSTEXPR int_type + eof() _GLIBCXX_NOEXCEPT + { return static_cast(WEOF); } + + static _GLIBCXX_CONSTEXPR int_type + not_eof(const int_type& __c) _GLIBCXX_NOEXCEPT + { return eq_int_type(__c, eof()) ? 0 : __c; } + }; +#endif //_GLIBCXX_USE_WCHAR_T + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#if ((__cplusplus >= 201103L) \ + && defined(_GLIBCXX_USE_C99_STDINT_TR1)) + +#include + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + template<> + struct char_traits + { + typedef char16_t char_type; + typedef uint_least16_t int_type; + typedef streamoff off_type; + typedef u16streampos pos_type; + typedef mbstate_t state_type; + + static void + assign(char_type& __c1, const char_type& __c2) noexcept + { __c1 = __c2; } + + static constexpr bool + eq(const char_type& __c1, const char_type& __c2) noexcept + { return __c1 == __c2; } + + static constexpr bool + lt(const char_type& __c1, const char_type& __c2) noexcept + { return __c1 < __c2; } + + static int + compare(const char_type* __s1, const char_type* __s2, size_t __n) + { + for (size_t __i = 0; __i < __n; ++__i) + if (lt(__s1[__i], __s2[__i])) + return -1; + else if (lt(__s2[__i], __s1[__i])) + return 1; + return 0; + } + + static size_t + length(const char_type* __s) + { + size_t __i = 0; + while (!eq(__s[__i], char_type())) + ++__i; + return __i; + } + + static const char_type* + find(const char_type* __s, size_t __n, const char_type& __a) + { + for (size_t __i = 0; __i < __n; ++__i) + if (eq(__s[__i], __a)) + return __s + __i; + return 0; + } + + static char_type* + move(char_type* __s1, const char_type* __s2, size_t __n) + { + return (static_cast + (__builtin_memmove(__s1, __s2, __n * sizeof(char_type)))); + } + + static char_type* + copy(char_type* __s1, const char_type* __s2, size_t __n) + { + return (static_cast + (__builtin_memcpy(__s1, __s2, __n * sizeof(char_type)))); + } + + static char_type* + assign(char_type* __s, size_t __n, char_type __a) + { + for (size_t __i = 0; __i < __n; ++__i) + assign(__s[__i], __a); + return __s; + } + + static constexpr char_type + to_char_type(const int_type& __c) noexcept + { return char_type(__c); } + + static constexpr int_type + to_int_type(const char_type& __c) noexcept + { return int_type(__c); } + + static constexpr bool + eq_int_type(const int_type& __c1, const int_type& __c2) noexcept + { return __c1 == __c2; } + + static constexpr int_type + eof() noexcept + { return static_cast(-1); } + + static constexpr int_type + not_eof(const int_type& __c) noexcept + { return eq_int_type(__c, eof()) ? 0 : __c; } + }; + + template<> + struct char_traits + { + typedef char32_t char_type; + typedef uint_least32_t int_type; + typedef streamoff off_type; + typedef u32streampos pos_type; + typedef mbstate_t state_type; + + static void + assign(char_type& __c1, const char_type& __c2) noexcept + { __c1 = __c2; } + + static constexpr bool + eq(const char_type& __c1, const char_type& __c2) noexcept + { return __c1 == __c2; } + + static constexpr bool + lt(const char_type& __c1, const char_type& __c2) noexcept + { return __c1 < __c2; } + + static int + compare(const char_type* __s1, const char_type* __s2, size_t __n) + { + for (size_t __i = 0; __i < __n; ++__i) + if (lt(__s1[__i], __s2[__i])) + return -1; + else if (lt(__s2[__i], __s1[__i])) + return 1; + return 0; + } + + static size_t + length(const char_type* __s) + { + size_t __i = 0; + while (!eq(__s[__i], char_type())) + ++__i; + return __i; + } + + static const char_type* + find(const char_type* __s, size_t __n, const char_type& __a) + { + for (size_t __i = 0; __i < __n; ++__i) + if (eq(__s[__i], __a)) + return __s + __i; + return 0; + } + + static char_type* + move(char_type* __s1, const char_type* __s2, size_t __n) + { + return (static_cast + (__builtin_memmove(__s1, __s2, __n * sizeof(char_type)))); + } + + static char_type* + copy(char_type* __s1, const char_type* __s2, size_t __n) + { + return (static_cast + (__builtin_memcpy(__s1, __s2, __n * sizeof(char_type)))); + } + + static char_type* + assign(char_type* __s, size_t __n, char_type __a) + { + for (size_t __i = 0; __i < __n; ++__i) + assign(__s[__i], __a); + return __s; + } + + static constexpr char_type + to_char_type(const int_type& __c) noexcept + { return char_type(__c); } + + static constexpr int_type + to_int_type(const char_type& __c) noexcept + { return int_type(__c); } + + static constexpr bool + eq_int_type(const int_type& __c1, const int_type& __c2) noexcept + { return __c1 == __c2; } + + static constexpr int_type + eof() noexcept + { return static_cast(-1); } + + static constexpr int_type + not_eof(const int_type& __c) noexcept + { return eq_int_type(__c, eof()) ? 0 : __c; } + }; + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif + +#endif // _CHAR_TRAITS_H diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/codecvt.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/codecvt.h new file mode 100755 index 0000000..5002a55 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/codecvt.h @@ -0,0 +1,507 @@ +// Locale support (codecvt) -*- C++ -*- + +// Copyright (C) 2000-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file bits/codecvt.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{locale} + */ + +// +// ISO C++ 14882: 22.2.1.5 Template class codecvt +// + +// Written by Benjamin Kosnik + +#ifndef _CODECVT_H +#define _CODECVT_H 1 + +#pragma GCC system_header + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /// Empty base class for codecvt facet [22.2.1.5]. + class codecvt_base + { + public: + enum result + { + ok, + partial, + error, + noconv + }; + }; + + /** + * @brief Common base for codecvt functions. + * + * This template class provides implementations of the public functions + * that forward to the protected virtual functions. + * + * This template also provides abstract stubs for the protected virtual + * functions. + */ + template + class __codecvt_abstract_base + : public locale::facet, public codecvt_base + { + public: + // Types: + typedef codecvt_base::result result; + typedef _InternT intern_type; + typedef _ExternT extern_type; + typedef _StateT state_type; + + // 22.2.1.5.1 codecvt members + /** + * @brief Convert from internal to external character set. + * + * Converts input string of intern_type to output string of + * extern_type. This is analogous to wcsrtombs. It does this by + * calling codecvt::do_out. + * + * The source and destination character sets are determined by the + * facet's locale, internal and external types. + * + * The characters in [from,from_end) are converted and written to + * [to,to_end). from_next and to_next are set to point to the + * character following the last successfully converted character, + * respectively. If the result needed no conversion, from_next and + * to_next are not affected. + * + * The @a state argument should be initialized if the input is at the + * beginning and carried from a previous call if continuing + * conversion. There are no guarantees about how @a state is used. + * + * The result returned is a member of codecvt_base::result. If + * all the input is converted, returns codecvt_base::ok. If no + * conversion is necessary, returns codecvt_base::noconv. If + * the input ends early or there is insufficient space in the + * output, returns codecvt_base::partial. Otherwise the + * conversion failed and codecvt_base::error is returned. + * + * @param __state Persistent conversion state data. + * @param __from Start of input. + * @param __from_end End of input. + * @param __from_next Returns start of unconverted data. + * @param __to Start of output buffer. + * @param __to_end End of output buffer. + * @param __to_next Returns start of unused output area. + * @return codecvt_base::result. + */ + result + out(state_type& __state, const intern_type* __from, + const intern_type* __from_end, const intern_type*& __from_next, + extern_type* __to, extern_type* __to_end, + extern_type*& __to_next) const + { + return this->do_out(__state, __from, __from_end, __from_next, + __to, __to_end, __to_next); + } + + /** + * @brief Reset conversion state. + * + * Writes characters to output that would restore @a state to initial + * conditions. The idea is that if a partial conversion occurs, then + * the converting the characters written by this function would leave + * the state in initial conditions, rather than partial conversion + * state. It does this by calling codecvt::do_unshift(). + * + * For example, if 4 external characters always converted to 1 internal + * character, and input to in() had 6 external characters with state + * saved, this function would write two characters to the output and + * set the state to initialized conditions. + * + * The source and destination character sets are determined by the + * facet's locale, internal and external types. + * + * The result returned is a member of codecvt_base::result. If the + * state could be reset and data written, returns codecvt_base::ok. If + * no conversion is necessary, returns codecvt_base::noconv. If the + * output has insufficient space, returns codecvt_base::partial. + * Otherwise the reset failed and codecvt_base::error is returned. + * + * @param __state Persistent conversion state data. + * @param __to Start of output buffer. + * @param __to_end End of output buffer. + * @param __to_next Returns start of unused output area. + * @return codecvt_base::result. + */ + result + unshift(state_type& __state, extern_type* __to, extern_type* __to_end, + extern_type*& __to_next) const + { return this->do_unshift(__state, __to,__to_end,__to_next); } + + /** + * @brief Convert from external to internal character set. + * + * Converts input string of extern_type to output string of + * intern_type. This is analogous to mbsrtowcs. It does this by + * calling codecvt::do_in. + * + * The source and destination character sets are determined by the + * facet's locale, internal and external types. + * + * The characters in [from,from_end) are converted and written to + * [to,to_end). from_next and to_next are set to point to the + * character following the last successfully converted character, + * respectively. If the result needed no conversion, from_next and + * to_next are not affected. + * + * The @a state argument should be initialized if the input is at the + * beginning and carried from a previous call if continuing + * conversion. There are no guarantees about how @a state is used. + * + * The result returned is a member of codecvt_base::result. If + * all the input is converted, returns codecvt_base::ok. If no + * conversion is necessary, returns codecvt_base::noconv. If + * the input ends early or there is insufficient space in the + * output, returns codecvt_base::partial. Otherwise the + * conversion failed and codecvt_base::error is returned. + * + * @param __state Persistent conversion state data. + * @param __from Start of input. + * @param __from_end End of input. + * @param __from_next Returns start of unconverted data. + * @param __to Start of output buffer. + * @param __to_end End of output buffer. + * @param __to_next Returns start of unused output area. + * @return codecvt_base::result. + */ + result + in(state_type& __state, const extern_type* __from, + const extern_type* __from_end, const extern_type*& __from_next, + intern_type* __to, intern_type* __to_end, + intern_type*& __to_next) const + { + return this->do_in(__state, __from, __from_end, __from_next, + __to, __to_end, __to_next); + } + + int + encoding() const throw() + { return this->do_encoding(); } + + bool + always_noconv() const throw() + { return this->do_always_noconv(); } + + int + length(state_type& __state, const extern_type* __from, + const extern_type* __end, size_t __max) const + { return this->do_length(__state, __from, __end, __max); } + + int + max_length() const throw() + { return this->do_max_length(); } + + protected: + explicit + __codecvt_abstract_base(size_t __refs = 0) : locale::facet(__refs) { } + + virtual + ~__codecvt_abstract_base() { } + + /** + * @brief Convert from internal to external character set. + * + * Converts input string of intern_type to output string of + * extern_type. This function is a hook for derived classes to change + * the value returned. @see out for more information. + */ + virtual result + do_out(state_type& __state, const intern_type* __from, + const intern_type* __from_end, const intern_type*& __from_next, + extern_type* __to, extern_type* __to_end, + extern_type*& __to_next) const = 0; + + virtual result + do_unshift(state_type& __state, extern_type* __to, + extern_type* __to_end, extern_type*& __to_next) const = 0; + + virtual result + do_in(state_type& __state, const extern_type* __from, + const extern_type* __from_end, const extern_type*& __from_next, + intern_type* __to, intern_type* __to_end, + intern_type*& __to_next) const = 0; + + virtual int + do_encoding() const throw() = 0; + + virtual bool + do_always_noconv() const throw() = 0; + + virtual int + do_length(state_type&, const extern_type* __from, + const extern_type* __end, size_t __max) const = 0; + + virtual int + do_max_length() const throw() = 0; + }; + + + + /** + * @brief Primary class template codecvt. + * @ingroup locales + * + * NB: Generic, mostly useless implementation. + * + */ + template + class codecvt + : public __codecvt_abstract_base<_InternT, _ExternT, _StateT> + { + public: + // Types: + typedef codecvt_base::result result; + typedef _InternT intern_type; + typedef _ExternT extern_type; + typedef _StateT state_type; + + protected: + __c_locale _M_c_locale_codecvt; + + public: + static locale::id id; + + explicit + codecvt(size_t __refs = 0) + : __codecvt_abstract_base<_InternT, _ExternT, _StateT> (__refs), + _M_c_locale_codecvt(0) + { } + + explicit + codecvt(__c_locale __cloc, size_t __refs = 0); + + protected: + virtual + ~codecvt() { } + + virtual result + do_out(state_type& __state, const intern_type* __from, + const intern_type* __from_end, const intern_type*& __from_next, + extern_type* __to, extern_type* __to_end, + extern_type*& __to_next) const; + + virtual result + do_unshift(state_type& __state, extern_type* __to, + extern_type* __to_end, extern_type*& __to_next) const; + + virtual result + do_in(state_type& __state, const extern_type* __from, + const extern_type* __from_end, const extern_type*& __from_next, + intern_type* __to, intern_type* __to_end, + intern_type*& __to_next) const; + + virtual int + do_encoding() const throw(); + + virtual bool + do_always_noconv() const throw(); + + virtual int + do_length(state_type&, const extern_type* __from, + const extern_type* __end, size_t __max) const; + + virtual int + do_max_length() const throw(); + }; + + template + locale::id codecvt<_InternT, _ExternT, _StateT>::id; + + /// class codecvt specialization. + template<> + class codecvt + : public __codecvt_abstract_base + { + public: + // Types: + typedef char intern_type; + typedef char extern_type; + typedef mbstate_t state_type; + + protected: + __c_locale _M_c_locale_codecvt; + + public: + static locale::id id; + + explicit + codecvt(size_t __refs = 0); + + explicit + codecvt(__c_locale __cloc, size_t __refs = 0); + + protected: + virtual + ~codecvt(); + + virtual result + do_out(state_type& __state, const intern_type* __from, + const intern_type* __from_end, const intern_type*& __from_next, + extern_type* __to, extern_type* __to_end, + extern_type*& __to_next) const; + + virtual result + do_unshift(state_type& __state, extern_type* __to, + extern_type* __to_end, extern_type*& __to_next) const; + + virtual result + do_in(state_type& __state, const extern_type* __from, + const extern_type* __from_end, const extern_type*& __from_next, + intern_type* __to, intern_type* __to_end, + intern_type*& __to_next) const; + + virtual int + do_encoding() const throw(); + + virtual bool + do_always_noconv() const throw(); + + virtual int + do_length(state_type&, const extern_type* __from, + const extern_type* __end, size_t __max) const; + + virtual int + do_max_length() const throw(); + }; + +#ifdef _GLIBCXX_USE_WCHAR_T + /// class codecvt specialization. + template<> + class codecvt + : public __codecvt_abstract_base + { + public: + // Types: + typedef wchar_t intern_type; + typedef char extern_type; + typedef mbstate_t state_type; + + protected: + __c_locale _M_c_locale_codecvt; + + public: + static locale::id id; + + explicit + codecvt(size_t __refs = 0); + + explicit + codecvt(__c_locale __cloc, size_t __refs = 0); + + protected: + virtual + ~codecvt(); + + virtual result + do_out(state_type& __state, const intern_type* __from, + const intern_type* __from_end, const intern_type*& __from_next, + extern_type* __to, extern_type* __to_end, + extern_type*& __to_next) const; + + virtual result + do_unshift(state_type& __state, + extern_type* __to, extern_type* __to_end, + extern_type*& __to_next) const; + + virtual result + do_in(state_type& __state, + const extern_type* __from, const extern_type* __from_end, + const extern_type*& __from_next, + intern_type* __to, intern_type* __to_end, + intern_type*& __to_next) const; + + virtual + int do_encoding() const throw(); + + virtual + bool do_always_noconv() const throw(); + + virtual + int do_length(state_type&, const extern_type* __from, + const extern_type* __end, size_t __max) const; + + virtual int + do_max_length() const throw(); + }; +#endif //_GLIBCXX_USE_WCHAR_T + + /// class codecvt_byname [22.2.1.6]. + template + class codecvt_byname : public codecvt<_InternT, _ExternT, _StateT> + { + public: + explicit + codecvt_byname(const char* __s, size_t __refs = 0) + : codecvt<_InternT, _ExternT, _StateT>(__refs) + { + if (__builtin_strcmp(__s, "C") != 0 + && __builtin_strcmp(__s, "POSIX") != 0) + { + this->_S_destroy_c_locale(this->_M_c_locale_codecvt); + this->_S_create_c_locale(this->_M_c_locale_codecvt, __s); + } + } + + protected: + virtual + ~codecvt_byname() { } + }; + + // Inhibit implicit instantiations for required instantiations, + // which are defined via explicit instantiations elsewhere. +#if _GLIBCXX_EXTERN_TEMPLATE + extern template class codecvt_byname; + + extern template + const codecvt& + use_facet >(const locale&); + + extern template + bool + has_facet >(const locale&); + +#ifdef _GLIBCXX_USE_WCHAR_T + extern template class codecvt_byname; + + extern template + const codecvt& + use_facet >(const locale&); + + extern template + bool + has_facet >(const locale&); +#endif +#endif + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace std + +#endif // _CODECVT_H diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/concept_check.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/concept_check.h new file mode 100755 index 0000000..eb5b794 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/concept_check.h @@ -0,0 +1,80 @@ +// Concept-checking control -*- C++ -*- + +// Copyright (C) 2001-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file bits/concept_check.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{iterator} + */ + +#ifndef _CONCEPT_CHECK_H +#define _CONCEPT_CHECK_H 1 + +#pragma GCC system_header + +#include + +// All places in libstdc++-v3 where these are used, or /might/ be used, or +// don't need to be used, or perhaps /should/ be used, are commented with +// "concept requirements" (and maybe some more text). So grep like crazy +// if you're looking for additional places to use these. + +// Concept-checking code is off by default unless users turn it on via +// configure options or editing c++config.h. + +#ifndef _GLIBCXX_CONCEPT_CHECKS + +#define __glibcxx_function_requires(...) +#define __glibcxx_class_requires(_a,_b) +#define __glibcxx_class_requires2(_a,_b,_c) +#define __glibcxx_class_requires3(_a,_b,_c,_d) +#define __glibcxx_class_requires4(_a,_b,_c,_d,_e) + +#else // the checks are on + +#include + +// Note that the obvious and elegant approach of +// +//#define glibcxx_function_requires(C) debug::function_requires< debug::C >() +// +// won't work due to concept templates with more than one parameter, e.g., +// BinaryPredicateConcept. The preprocessor tries to split things up on +// the commas in the template argument list. We can't use an inner pair of +// parenthesis to hide the commas, because "debug::(Temp)" isn't +// a valid instantiation pattern. Thus, we steal a feature from C99. + +#define __glibcxx_function_requires(...) \ + __gnu_cxx::__function_requires< __gnu_cxx::__VA_ARGS__ >(); +#define __glibcxx_class_requires(_a,_C) \ + _GLIBCXX_CLASS_REQUIRES(_a, __gnu_cxx, _C); +#define __glibcxx_class_requires2(_a,_b,_C) \ + _GLIBCXX_CLASS_REQUIRES2(_a, _b, __gnu_cxx, _C); +#define __glibcxx_class_requires3(_a,_b,_c,_C) \ + _GLIBCXX_CLASS_REQUIRES3(_a, _b, _c, __gnu_cxx, _C); +#define __glibcxx_class_requires4(_a,_b,_c,_d,_C) \ + _GLIBCXX_CLASS_REQUIRES4(_a, _b, _c, _d, __gnu_cxx, _C); + +#endif // enable/disable + +#endif // _GLIBCXX_CONCEPT_CHECK diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/cpp_type_traits.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/cpp_type_traits.h new file mode 100755 index 0000000..8df81a7 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/cpp_type_traits.h @@ -0,0 +1,416 @@ +// The -*- C++ -*- type traits classes for internal use in libstdc++ + +// Copyright (C) 2000-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file bits/cpp_type_traits.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{ext/type_traits} + */ + +// Written by Gabriel Dos Reis + +#ifndef _CPP_TYPE_TRAITS_H +#define _CPP_TYPE_TRAITS_H 1 + +#pragma GCC system_header + +#include + +// +// This file provides some compile-time information about various types. +// These representations were designed, on purpose, to be constant-expressions +// and not types as found in . In particular, they +// can be used in control structures and the optimizer hopefully will do +// the obvious thing. +// +// Why integral expressions, and not functions nor types? +// Firstly, these compile-time entities are used as template-arguments +// so function return values won't work: We need compile-time entities. +// We're left with types and constant integral expressions. +// Secondly, from the point of view of ease of use, type-based compile-time +// information is -not- *that* convenient. On has to write lots of +// overloaded functions and to hope that the compiler will select the right +// one. As a net effect, the overall structure isn't very clear at first +// glance. +// Thirdly, partial ordering and overload resolution (of function templates) +// is highly costly in terms of compiler-resource. It is a Good Thing to +// keep these resource consumption as least as possible. +// +// See valarray_array.h for a case use. +// +// -- Gaby (dosreis@cmla.ens-cachan.fr) 2000-03-06. +// +// Update 2005: types are also provided and has been +// removed. +// + +// Forward declaration hack, should really include this from somewhere. +namespace __gnu_cxx _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + template + class __normal_iterator; + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + struct __true_type { }; + struct __false_type { }; + + template + struct __truth_type + { typedef __false_type __type; }; + + template<> + struct __truth_type + { typedef __true_type __type; }; + + // N.B. The conversions to bool are needed due to the issue + // explained in c++/19404. + template + struct __traitor + { + enum { __value = bool(_Sp::__value) || bool(_Tp::__value) }; + typedef typename __truth_type<__value>::__type __type; + }; + + // Compare for equality of types. + template + struct __are_same + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + template + struct __are_same<_Tp, _Tp> + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + // Holds if the template-argument is a void type. + template + struct __is_void + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + template<> + struct __is_void + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + // + // Integer types + // + template + struct __is_integer + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + // Thirteen specializations (yes there are eleven standard integer + // types; long long and unsigned long long are + // supported as extensions) + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + +# ifdef _GLIBCXX_USE_WCHAR_T + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; +# endif + +#if __cplusplus >= 201103L + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; +#endif + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + // + // Floating point types + // + template + struct __is_floating + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + // three specializations (float, double and 'long double') + template<> + struct __is_floating + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_floating + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_floating + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + // + // Pointer types + // + template + struct __is_pointer + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + template + struct __is_pointer<_Tp*> + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + // + // Normal iterator type + // + template + struct __is_normal_iterator + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + template + struct __is_normal_iterator< __gnu_cxx::__normal_iterator<_Iterator, + _Container> > + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + // + // An arithmetic type is an integer type or a floating point type + // + template + struct __is_arithmetic + : public __traitor<__is_integer<_Tp>, __is_floating<_Tp> > + { }; + + // + // A scalar type is an arithmetic type or a pointer type + // + template + struct __is_scalar + : public __traitor<__is_arithmetic<_Tp>, __is_pointer<_Tp> > + { }; + + // + // For use in std::copy and std::find overloads for streambuf iterators. + // + template + struct __is_char + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + template<> + struct __is_char + { + enum { __value = 1 }; + typedef __true_type __type; + }; + +#ifdef _GLIBCXX_USE_WCHAR_T + template<> + struct __is_char + { + enum { __value = 1 }; + typedef __true_type __type; + }; +#endif + + template + struct __is_byte + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + template<> + struct __is_byte + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_byte + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_byte + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + // + // Move iterator type + // + template + struct __is_move_iterator + { + enum { __value = 0 }; + typedef __false_type __type; + }; + +#if __cplusplus >= 201103L + template + class move_iterator; + + template + struct __is_move_iterator< move_iterator<_Iterator> > + { + enum { __value = 1 }; + typedef __true_type __type; + }; +#endif + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif //_CPP_TYPE_TRAITS_H diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/cxxabi_forced.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/cxxabi_forced.h new file mode 100755 index 0000000..4133c9f --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/cxxabi_forced.h @@ -0,0 +1,60 @@ +// cxxabi.h subset for cancellation -*- C++ -*- + +// Copyright (C) 2007-2014 Free Software Foundation, Inc. +// +// This file is part of GCC. +// +// GCC is free software; you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation; either version 3, or (at your option) +// any later version. +// +// GCC is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file bits/cxxabi_forced.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{cxxabi.h} + */ + +#ifndef _CXXABI_FORCED_H +#define _CXXABI_FORCED_H 1 + +#pragma GCC system_header + +#pragma GCC visibility push(default) + +#ifdef __cplusplus +namespace __cxxabiv1 +{ + /** + * @brief Thrown as part of forced unwinding. + * @ingroup exceptions + * + * A magic placeholder class that can be caught by reference to + * recognize forced unwinding. + */ + class __forced_unwind + { + virtual ~__forced_unwind() throw(); + + // Prevent catch by value. + virtual void __pure_dummy() = 0; + }; +} +#endif // __cplusplus + +#pragma GCC visibility pop + +#endif // __CXXABI_FORCED_H diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/deque.tcc b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/deque.tcc new file mode 100755 index 0000000..ebf5d3a --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/deque.tcc @@ -0,0 +1,1073 @@ +// Deque implementation (out of line) -*- C++ -*- + +// Copyright (C) 2001-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/* + * + * Copyright (c) 1994 + * Hewlett-Packard Company + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Hewlett-Packard Company makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + * + * + * Copyright (c) 1997 + * Silicon Graphics Computer Systems, Inc. + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Silicon Graphics makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + */ + +/** @file bits/deque.tcc + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{deque} + */ + +#ifndef _DEQUE_TCC +#define _DEQUE_TCC 1 + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_CONTAINER + +#if __cplusplus >= 201103L + template + void + deque<_Tp, _Alloc>:: + _M_default_initialize() + { + _Map_pointer __cur; + __try + { + for (__cur = this->_M_impl._M_start._M_node; + __cur < this->_M_impl._M_finish._M_node; + ++__cur) + std::__uninitialized_default_a(*__cur, *__cur + _S_buffer_size(), + _M_get_Tp_allocator()); + std::__uninitialized_default_a(this->_M_impl._M_finish._M_first, + this->_M_impl._M_finish._M_cur, + _M_get_Tp_allocator()); + } + __catch(...) + { + std::_Destroy(this->_M_impl._M_start, iterator(*__cur, __cur), + _M_get_Tp_allocator()); + __throw_exception_again; + } + } +#endif + + template + deque<_Tp, _Alloc>& + deque<_Tp, _Alloc>:: + operator=(const deque& __x) + { + const size_type __len = size(); + if (&__x != this) + { + if (__len >= __x.size()) + _M_erase_at_end(std::copy(__x.begin(), __x.end(), + this->_M_impl._M_start)); + else + { + const_iterator __mid = __x.begin() + difference_type(__len); + std::copy(__x.begin(), __mid, this->_M_impl._M_start); + insert(this->_M_impl._M_finish, __mid, __x.end()); + } + } + return *this; + } + +#if __cplusplus >= 201103L + template + template + void + deque<_Tp, _Alloc>:: + emplace_front(_Args&&... __args) + { + if (this->_M_impl._M_start._M_cur != this->_M_impl._M_start._M_first) + { + this->_M_impl.construct(this->_M_impl._M_start._M_cur - 1, + std::forward<_Args>(__args)...); + --this->_M_impl._M_start._M_cur; + } + else + _M_push_front_aux(std::forward<_Args>(__args)...); + } + + template + template + void + deque<_Tp, _Alloc>:: + emplace_back(_Args&&... __args) + { + if (this->_M_impl._M_finish._M_cur + != this->_M_impl._M_finish._M_last - 1) + { + this->_M_impl.construct(this->_M_impl._M_finish._M_cur, + std::forward<_Args>(__args)...); + ++this->_M_impl._M_finish._M_cur; + } + else + _M_push_back_aux(std::forward<_Args>(__args)...); + } +#endif + +#if __cplusplus >= 201103L + template + template + typename deque<_Tp, _Alloc>::iterator + deque<_Tp, _Alloc>:: + emplace(const_iterator __position, _Args&&... __args) + { + if (__position._M_cur == this->_M_impl._M_start._M_cur) + { + emplace_front(std::forward<_Args>(__args)...); + return this->_M_impl._M_start; + } + else if (__position._M_cur == this->_M_impl._M_finish._M_cur) + { + emplace_back(std::forward<_Args>(__args)...); + iterator __tmp = this->_M_impl._M_finish; + --__tmp; + return __tmp; + } + else + return _M_insert_aux(__position._M_const_cast(), + std::forward<_Args>(__args)...); + } +#endif + + template + typename deque<_Tp, _Alloc>::iterator + deque<_Tp, _Alloc>:: +#if __cplusplus >= 201103L + insert(const_iterator __position, const value_type& __x) +#else + insert(iterator __position, const value_type& __x) +#endif + { + if (__position._M_cur == this->_M_impl._M_start._M_cur) + { + push_front(__x); + return this->_M_impl._M_start; + } + else if (__position._M_cur == this->_M_impl._M_finish._M_cur) + { + push_back(__x); + iterator __tmp = this->_M_impl._M_finish; + --__tmp; + return __tmp; + } + else + return _M_insert_aux(__position._M_const_cast(), __x); + } + + template + typename deque<_Tp, _Alloc>::iterator + deque<_Tp, _Alloc>:: + _M_erase(iterator __position) + { + iterator __next = __position; + ++__next; + const difference_type __index = __position - begin(); + if (static_cast(__index) < (size() >> 1)) + { + if (__position != begin()) + _GLIBCXX_MOVE_BACKWARD3(begin(), __position, __next); + pop_front(); + } + else + { + if (__next != end()) + _GLIBCXX_MOVE3(__next, end(), __position); + pop_back(); + } + return begin() + __index; + } + + template + typename deque<_Tp, _Alloc>::iterator + deque<_Tp, _Alloc>:: + _M_erase(iterator __first, iterator __last) + { + if (__first == __last) + return __first; + else if (__first == begin() && __last == end()) + { + clear(); + return end(); + } + else + { + const difference_type __n = __last - __first; + const difference_type __elems_before = __first - begin(); + if (static_cast(__elems_before) <= (size() - __n) / 2) + { + if (__first != begin()) + _GLIBCXX_MOVE_BACKWARD3(begin(), __first, __last); + _M_erase_at_begin(begin() + __n); + } + else + { + if (__last != end()) + _GLIBCXX_MOVE3(__last, end(), __first); + _M_erase_at_end(end() - __n); + } + return begin() + __elems_before; + } + } + + template + template + void + deque<_Tp, _Alloc>:: + _M_assign_aux(_InputIterator __first, _InputIterator __last, + std::input_iterator_tag) + { + iterator __cur = begin(); + for (; __first != __last && __cur != end(); ++__cur, ++__first) + *__cur = *__first; + if (__first == __last) + _M_erase_at_end(__cur); + else + insert(end(), __first, __last); + } + + template + void + deque<_Tp, _Alloc>:: + _M_fill_insert(iterator __pos, size_type __n, const value_type& __x) + { + if (__pos._M_cur == this->_M_impl._M_start._M_cur) + { + iterator __new_start = _M_reserve_elements_at_front(__n); + __try + { + std::__uninitialized_fill_a(__new_start, this->_M_impl._M_start, + __x, _M_get_Tp_allocator()); + this->_M_impl._M_start = __new_start; + } + __catch(...) + { + _M_destroy_nodes(__new_start._M_node, + this->_M_impl._M_start._M_node); + __throw_exception_again; + } + } + else if (__pos._M_cur == this->_M_impl._M_finish._M_cur) + { + iterator __new_finish = _M_reserve_elements_at_back(__n); + __try + { + std::__uninitialized_fill_a(this->_M_impl._M_finish, + __new_finish, __x, + _M_get_Tp_allocator()); + this->_M_impl._M_finish = __new_finish; + } + __catch(...) + { + _M_destroy_nodes(this->_M_impl._M_finish._M_node + 1, + __new_finish._M_node + 1); + __throw_exception_again; + } + } + else + _M_insert_aux(__pos, __n, __x); + } + +#if __cplusplus >= 201103L + template + void + deque<_Tp, _Alloc>:: + _M_default_append(size_type __n) + { + if (__n) + { + iterator __new_finish = _M_reserve_elements_at_back(__n); + __try + { + std::__uninitialized_default_a(this->_M_impl._M_finish, + __new_finish, + _M_get_Tp_allocator()); + this->_M_impl._M_finish = __new_finish; + } + __catch(...) + { + _M_destroy_nodes(this->_M_impl._M_finish._M_node + 1, + __new_finish._M_node + 1); + __throw_exception_again; + } + } + } + + template + bool + deque<_Tp, _Alloc>:: + _M_shrink_to_fit() + { + const difference_type __front_capacity + = (this->_M_impl._M_start._M_cur - this->_M_impl._M_start._M_first); + if (__front_capacity == 0) + return false; + + const difference_type __back_capacity + = (this->_M_impl._M_finish._M_last - this->_M_impl._M_finish._M_cur); + if (__front_capacity + __back_capacity < _S_buffer_size()) + return false; + + return std::__shrink_to_fit_aux::_S_do_it(*this); + } +#endif + + template + void + deque<_Tp, _Alloc>:: + _M_fill_initialize(const value_type& __value) + { + _Map_pointer __cur; + __try + { + for (__cur = this->_M_impl._M_start._M_node; + __cur < this->_M_impl._M_finish._M_node; + ++__cur) + std::__uninitialized_fill_a(*__cur, *__cur + _S_buffer_size(), + __value, _M_get_Tp_allocator()); + std::__uninitialized_fill_a(this->_M_impl._M_finish._M_first, + this->_M_impl._M_finish._M_cur, + __value, _M_get_Tp_allocator()); + } + __catch(...) + { + std::_Destroy(this->_M_impl._M_start, iterator(*__cur, __cur), + _M_get_Tp_allocator()); + __throw_exception_again; + } + } + + template + template + void + deque<_Tp, _Alloc>:: + _M_range_initialize(_InputIterator __first, _InputIterator __last, + std::input_iterator_tag) + { + this->_M_initialize_map(0); + __try + { + for (; __first != __last; ++__first) +#if __cplusplus >= 201103L + emplace_back(*__first); +#else + push_back(*__first); +#endif + } + __catch(...) + { + clear(); + __throw_exception_again; + } + } + + template + template + void + deque<_Tp, _Alloc>:: + _M_range_initialize(_ForwardIterator __first, _ForwardIterator __last, + std::forward_iterator_tag) + { + const size_type __n = std::distance(__first, __last); + this->_M_initialize_map(__n); + + _Map_pointer __cur_node; + __try + { + for (__cur_node = this->_M_impl._M_start._M_node; + __cur_node < this->_M_impl._M_finish._M_node; + ++__cur_node) + { + _ForwardIterator __mid = __first; + std::advance(__mid, _S_buffer_size()); + std::__uninitialized_copy_a(__first, __mid, *__cur_node, + _M_get_Tp_allocator()); + __first = __mid; + } + std::__uninitialized_copy_a(__first, __last, + this->_M_impl._M_finish._M_first, + _M_get_Tp_allocator()); + } + __catch(...) + { + std::_Destroy(this->_M_impl._M_start, + iterator(*__cur_node, __cur_node), + _M_get_Tp_allocator()); + __throw_exception_again; + } + } + + // Called only if _M_impl._M_finish._M_cur == _M_impl._M_finish._M_last - 1. + template +#if __cplusplus >= 201103L + template + void + deque<_Tp, _Alloc>:: + _M_push_back_aux(_Args&&... __args) +#else + void + deque<_Tp, _Alloc>:: + _M_push_back_aux(const value_type& __t) +#endif + { + _M_reserve_map_at_back(); + *(this->_M_impl._M_finish._M_node + 1) = this->_M_allocate_node(); + __try + { +#if __cplusplus >= 201103L + this->_M_impl.construct(this->_M_impl._M_finish._M_cur, + std::forward<_Args>(__args)...); +#else + this->_M_impl.construct(this->_M_impl._M_finish._M_cur, __t); +#endif + this->_M_impl._M_finish._M_set_node(this->_M_impl._M_finish._M_node + + 1); + this->_M_impl._M_finish._M_cur = this->_M_impl._M_finish._M_first; + } + __catch(...) + { + _M_deallocate_node(*(this->_M_impl._M_finish._M_node + 1)); + __throw_exception_again; + } + } + + // Called only if _M_impl._M_start._M_cur == _M_impl._M_start._M_first. + template +#if __cplusplus >= 201103L + template + void + deque<_Tp, _Alloc>:: + _M_push_front_aux(_Args&&... __args) +#else + void + deque<_Tp, _Alloc>:: + _M_push_front_aux(const value_type& __t) +#endif + { + _M_reserve_map_at_front(); + *(this->_M_impl._M_start._M_node - 1) = this->_M_allocate_node(); + __try + { + this->_M_impl._M_start._M_set_node(this->_M_impl._M_start._M_node + - 1); + this->_M_impl._M_start._M_cur = this->_M_impl._M_start._M_last - 1; +#if __cplusplus >= 201103L + this->_M_impl.construct(this->_M_impl._M_start._M_cur, + std::forward<_Args>(__args)...); +#else + this->_M_impl.construct(this->_M_impl._M_start._M_cur, __t); +#endif + } + __catch(...) + { + ++this->_M_impl._M_start; + _M_deallocate_node(*(this->_M_impl._M_start._M_node - 1)); + __throw_exception_again; + } + } + + // Called only if _M_impl._M_finish._M_cur == _M_impl._M_finish._M_first. + template + void deque<_Tp, _Alloc>:: + _M_pop_back_aux() + { + _M_deallocate_node(this->_M_impl._M_finish._M_first); + this->_M_impl._M_finish._M_set_node(this->_M_impl._M_finish._M_node - 1); + this->_M_impl._M_finish._M_cur = this->_M_impl._M_finish._M_last - 1; + this->_M_impl.destroy(this->_M_impl._M_finish._M_cur); + } + + // Called only if _M_impl._M_start._M_cur == _M_impl._M_start._M_last - 1. + // Note that if the deque has at least one element (a precondition for this + // member function), and if + // _M_impl._M_start._M_cur == _M_impl._M_start._M_last, + // then the deque must have at least two nodes. + template + void deque<_Tp, _Alloc>:: + _M_pop_front_aux() + { + this->_M_impl.destroy(this->_M_impl._M_start._M_cur); + _M_deallocate_node(this->_M_impl._M_start._M_first); + this->_M_impl._M_start._M_set_node(this->_M_impl._M_start._M_node + 1); + this->_M_impl._M_start._M_cur = this->_M_impl._M_start._M_first; + } + + template + template + void + deque<_Tp, _Alloc>:: + _M_range_insert_aux(iterator __pos, + _InputIterator __first, _InputIterator __last, + std::input_iterator_tag) + { std::copy(__first, __last, std::inserter(*this, __pos)); } + + template + template + void + deque<_Tp, _Alloc>:: + _M_range_insert_aux(iterator __pos, + _ForwardIterator __first, _ForwardIterator __last, + std::forward_iterator_tag) + { + const size_type __n = std::distance(__first, __last); + if (__pos._M_cur == this->_M_impl._M_start._M_cur) + { + iterator __new_start = _M_reserve_elements_at_front(__n); + __try + { + std::__uninitialized_copy_a(__first, __last, __new_start, + _M_get_Tp_allocator()); + this->_M_impl._M_start = __new_start; + } + __catch(...) + { + _M_destroy_nodes(__new_start._M_node, + this->_M_impl._M_start._M_node); + __throw_exception_again; + } + } + else if (__pos._M_cur == this->_M_impl._M_finish._M_cur) + { + iterator __new_finish = _M_reserve_elements_at_back(__n); + __try + { + std::__uninitialized_copy_a(__first, __last, + this->_M_impl._M_finish, + _M_get_Tp_allocator()); + this->_M_impl._M_finish = __new_finish; + } + __catch(...) + { + _M_destroy_nodes(this->_M_impl._M_finish._M_node + 1, + __new_finish._M_node + 1); + __throw_exception_again; + } + } + else + _M_insert_aux(__pos, __first, __last, __n); + } + + template +#if __cplusplus >= 201103L + template + typename deque<_Tp, _Alloc>::iterator + deque<_Tp, _Alloc>:: + _M_insert_aux(iterator __pos, _Args&&... __args) + { + value_type __x_copy(std::forward<_Args>(__args)...); // XXX copy +#else + typename deque<_Tp, _Alloc>::iterator + deque<_Tp, _Alloc>:: + _M_insert_aux(iterator __pos, const value_type& __x) + { + value_type __x_copy = __x; // XXX copy +#endif + difference_type __index = __pos - this->_M_impl._M_start; + if (static_cast(__index) < size() / 2) + { + push_front(_GLIBCXX_MOVE(front())); + iterator __front1 = this->_M_impl._M_start; + ++__front1; + iterator __front2 = __front1; + ++__front2; + __pos = this->_M_impl._M_start + __index; + iterator __pos1 = __pos; + ++__pos1; + _GLIBCXX_MOVE3(__front2, __pos1, __front1); + } + else + { + push_back(_GLIBCXX_MOVE(back())); + iterator __back1 = this->_M_impl._M_finish; + --__back1; + iterator __back2 = __back1; + --__back2; + __pos = this->_M_impl._M_start + __index; + _GLIBCXX_MOVE_BACKWARD3(__pos, __back2, __back1); + } + *__pos = _GLIBCXX_MOVE(__x_copy); + return __pos; + } + + template + void + deque<_Tp, _Alloc>:: + _M_insert_aux(iterator __pos, size_type __n, const value_type& __x) + { + const difference_type __elems_before = __pos - this->_M_impl._M_start; + const size_type __length = this->size(); + value_type __x_copy = __x; + if (__elems_before < difference_type(__length / 2)) + { + iterator __new_start = _M_reserve_elements_at_front(__n); + iterator __old_start = this->_M_impl._M_start; + __pos = this->_M_impl._M_start + __elems_before; + __try + { + if (__elems_before >= difference_type(__n)) + { + iterator __start_n = (this->_M_impl._M_start + + difference_type(__n)); + std::__uninitialized_move_a(this->_M_impl._M_start, + __start_n, __new_start, + _M_get_Tp_allocator()); + this->_M_impl._M_start = __new_start; + _GLIBCXX_MOVE3(__start_n, __pos, __old_start); + std::fill(__pos - difference_type(__n), __pos, __x_copy); + } + else + { + std::__uninitialized_move_fill(this->_M_impl._M_start, + __pos, __new_start, + this->_M_impl._M_start, + __x_copy, + _M_get_Tp_allocator()); + this->_M_impl._M_start = __new_start; + std::fill(__old_start, __pos, __x_copy); + } + } + __catch(...) + { + _M_destroy_nodes(__new_start._M_node, + this->_M_impl._M_start._M_node); + __throw_exception_again; + } + } + else + { + iterator __new_finish = _M_reserve_elements_at_back(__n); + iterator __old_finish = this->_M_impl._M_finish; + const difference_type __elems_after = + difference_type(__length) - __elems_before; + __pos = this->_M_impl._M_finish - __elems_after; + __try + { + if (__elems_after > difference_type(__n)) + { + iterator __finish_n = (this->_M_impl._M_finish + - difference_type(__n)); + std::__uninitialized_move_a(__finish_n, + this->_M_impl._M_finish, + this->_M_impl._M_finish, + _M_get_Tp_allocator()); + this->_M_impl._M_finish = __new_finish; + _GLIBCXX_MOVE_BACKWARD3(__pos, __finish_n, __old_finish); + std::fill(__pos, __pos + difference_type(__n), __x_copy); + } + else + { + std::__uninitialized_fill_move(this->_M_impl._M_finish, + __pos + difference_type(__n), + __x_copy, __pos, + this->_M_impl._M_finish, + _M_get_Tp_allocator()); + this->_M_impl._M_finish = __new_finish; + std::fill(__pos, __old_finish, __x_copy); + } + } + __catch(...) + { + _M_destroy_nodes(this->_M_impl._M_finish._M_node + 1, + __new_finish._M_node + 1); + __throw_exception_again; + } + } + } + + template + template + void + deque<_Tp, _Alloc>:: + _M_insert_aux(iterator __pos, + _ForwardIterator __first, _ForwardIterator __last, + size_type __n) + { + const difference_type __elemsbefore = __pos - this->_M_impl._M_start; + const size_type __length = size(); + if (static_cast(__elemsbefore) < __length / 2) + { + iterator __new_start = _M_reserve_elements_at_front(__n); + iterator __old_start = this->_M_impl._M_start; + __pos = this->_M_impl._M_start + __elemsbefore; + __try + { + if (__elemsbefore >= difference_type(__n)) + { + iterator __start_n = (this->_M_impl._M_start + + difference_type(__n)); + std::__uninitialized_move_a(this->_M_impl._M_start, + __start_n, __new_start, + _M_get_Tp_allocator()); + this->_M_impl._M_start = __new_start; + _GLIBCXX_MOVE3(__start_n, __pos, __old_start); + std::copy(__first, __last, __pos - difference_type(__n)); + } + else + { + _ForwardIterator __mid = __first; + std::advance(__mid, difference_type(__n) - __elemsbefore); + std::__uninitialized_move_copy(this->_M_impl._M_start, + __pos, __first, __mid, + __new_start, + _M_get_Tp_allocator()); + this->_M_impl._M_start = __new_start; + std::copy(__mid, __last, __old_start); + } + } + __catch(...) + { + _M_destroy_nodes(__new_start._M_node, + this->_M_impl._M_start._M_node); + __throw_exception_again; + } + } + else + { + iterator __new_finish = _M_reserve_elements_at_back(__n); + iterator __old_finish = this->_M_impl._M_finish; + const difference_type __elemsafter = + difference_type(__length) - __elemsbefore; + __pos = this->_M_impl._M_finish - __elemsafter; + __try + { + if (__elemsafter > difference_type(__n)) + { + iterator __finish_n = (this->_M_impl._M_finish + - difference_type(__n)); + std::__uninitialized_move_a(__finish_n, + this->_M_impl._M_finish, + this->_M_impl._M_finish, + _M_get_Tp_allocator()); + this->_M_impl._M_finish = __new_finish; + _GLIBCXX_MOVE_BACKWARD3(__pos, __finish_n, __old_finish); + std::copy(__first, __last, __pos); + } + else + { + _ForwardIterator __mid = __first; + std::advance(__mid, __elemsafter); + std::__uninitialized_copy_move(__mid, __last, __pos, + this->_M_impl._M_finish, + this->_M_impl._M_finish, + _M_get_Tp_allocator()); + this->_M_impl._M_finish = __new_finish; + std::copy(__first, __mid, __pos); + } + } + __catch(...) + { + _M_destroy_nodes(this->_M_impl._M_finish._M_node + 1, + __new_finish._M_node + 1); + __throw_exception_again; + } + } + } + + template + void + deque<_Tp, _Alloc>:: + _M_destroy_data_aux(iterator __first, iterator __last) + { + for (_Map_pointer __node = __first._M_node + 1; + __node < __last._M_node; ++__node) + std::_Destroy(*__node, *__node + _S_buffer_size(), + _M_get_Tp_allocator()); + + if (__first._M_node != __last._M_node) + { + std::_Destroy(__first._M_cur, __first._M_last, + _M_get_Tp_allocator()); + std::_Destroy(__last._M_first, __last._M_cur, + _M_get_Tp_allocator()); + } + else + std::_Destroy(__first._M_cur, __last._M_cur, + _M_get_Tp_allocator()); + } + + template + void + deque<_Tp, _Alloc>:: + _M_new_elements_at_front(size_type __new_elems) + { + if (this->max_size() - this->size() < __new_elems) + __throw_length_error(__N("deque::_M_new_elements_at_front")); + + const size_type __new_nodes = ((__new_elems + _S_buffer_size() - 1) + / _S_buffer_size()); + _M_reserve_map_at_front(__new_nodes); + size_type __i; + __try + { + for (__i = 1; __i <= __new_nodes; ++__i) + *(this->_M_impl._M_start._M_node - __i) = this->_M_allocate_node(); + } + __catch(...) + { + for (size_type __j = 1; __j < __i; ++__j) + _M_deallocate_node(*(this->_M_impl._M_start._M_node - __j)); + __throw_exception_again; + } + } + + template + void + deque<_Tp, _Alloc>:: + _M_new_elements_at_back(size_type __new_elems) + { + if (this->max_size() - this->size() < __new_elems) + __throw_length_error(__N("deque::_M_new_elements_at_back")); + + const size_type __new_nodes = ((__new_elems + _S_buffer_size() - 1) + / _S_buffer_size()); + _M_reserve_map_at_back(__new_nodes); + size_type __i; + __try + { + for (__i = 1; __i <= __new_nodes; ++__i) + *(this->_M_impl._M_finish._M_node + __i) = this->_M_allocate_node(); + } + __catch(...) + { + for (size_type __j = 1; __j < __i; ++__j) + _M_deallocate_node(*(this->_M_impl._M_finish._M_node + __j)); + __throw_exception_again; + } + } + + template + void + deque<_Tp, _Alloc>:: + _M_reallocate_map(size_type __nodes_to_add, bool __add_at_front) + { + const size_type __old_num_nodes + = this->_M_impl._M_finish._M_node - this->_M_impl._M_start._M_node + 1; + const size_type __new_num_nodes = __old_num_nodes + __nodes_to_add; + + _Map_pointer __new_nstart; + if (this->_M_impl._M_map_size > 2 * __new_num_nodes) + { + __new_nstart = this->_M_impl._M_map + (this->_M_impl._M_map_size + - __new_num_nodes) / 2 + + (__add_at_front ? __nodes_to_add : 0); + if (__new_nstart < this->_M_impl._M_start._M_node) + std::copy(this->_M_impl._M_start._M_node, + this->_M_impl._M_finish._M_node + 1, + __new_nstart); + else + std::copy_backward(this->_M_impl._M_start._M_node, + this->_M_impl._M_finish._M_node + 1, + __new_nstart + __old_num_nodes); + } + else + { + size_type __new_map_size = this->_M_impl._M_map_size + + std::max(this->_M_impl._M_map_size, + __nodes_to_add) + 2; + + _Map_pointer __new_map = this->_M_allocate_map(__new_map_size); + __new_nstart = __new_map + (__new_map_size - __new_num_nodes) / 2 + + (__add_at_front ? __nodes_to_add : 0); + std::copy(this->_M_impl._M_start._M_node, + this->_M_impl._M_finish._M_node + 1, + __new_nstart); + _M_deallocate_map(this->_M_impl._M_map, this->_M_impl._M_map_size); + + this->_M_impl._M_map = __new_map; + this->_M_impl._M_map_size = __new_map_size; + } + + this->_M_impl._M_start._M_set_node(__new_nstart); + this->_M_impl._M_finish._M_set_node(__new_nstart + __old_num_nodes - 1); + } + + // Overload for deque::iterators, exploiting the "segmented-iterator + // optimization". + template + void + fill(const _Deque_iterator<_Tp, _Tp&, _Tp*>& __first, + const _Deque_iterator<_Tp, _Tp&, _Tp*>& __last, const _Tp& __value) + { + typedef typename _Deque_iterator<_Tp, _Tp&, _Tp*>::_Self _Self; + + for (typename _Self::_Map_pointer __node = __first._M_node + 1; + __node < __last._M_node; ++__node) + std::fill(*__node, *__node + _Self::_S_buffer_size(), __value); + + if (__first._M_node != __last._M_node) + { + std::fill(__first._M_cur, __first._M_last, __value); + std::fill(__last._M_first, __last._M_cur, __value); + } + else + std::fill(__first._M_cur, __last._M_cur, __value); + } + + template + _Deque_iterator<_Tp, _Tp&, _Tp*> + copy(_Deque_iterator<_Tp, const _Tp&, const _Tp*> __first, + _Deque_iterator<_Tp, const _Tp&, const _Tp*> __last, + _Deque_iterator<_Tp, _Tp&, _Tp*> __result) + { + typedef typename _Deque_iterator<_Tp, _Tp&, _Tp*>::_Self _Self; + typedef typename _Self::difference_type difference_type; + + difference_type __len = __last - __first; + while (__len > 0) + { + const difference_type __clen + = std::min(__len, std::min(__first._M_last - __first._M_cur, + __result._M_last - __result._M_cur)); + std::copy(__first._M_cur, __first._M_cur + __clen, __result._M_cur); + __first += __clen; + __result += __clen; + __len -= __clen; + } + return __result; + } + + template + _Deque_iterator<_Tp, _Tp&, _Tp*> + copy_backward(_Deque_iterator<_Tp, const _Tp&, const _Tp*> __first, + _Deque_iterator<_Tp, const _Tp&, const _Tp*> __last, + _Deque_iterator<_Tp, _Tp&, _Tp*> __result) + { + typedef typename _Deque_iterator<_Tp, _Tp&, _Tp*>::_Self _Self; + typedef typename _Self::difference_type difference_type; + + difference_type __len = __last - __first; + while (__len > 0) + { + difference_type __llen = __last._M_cur - __last._M_first; + _Tp* __lend = __last._M_cur; + + difference_type __rlen = __result._M_cur - __result._M_first; + _Tp* __rend = __result._M_cur; + + if (!__llen) + { + __llen = _Self::_S_buffer_size(); + __lend = *(__last._M_node - 1) + __llen; + } + if (!__rlen) + { + __rlen = _Self::_S_buffer_size(); + __rend = *(__result._M_node - 1) + __rlen; + } + + const difference_type __clen = std::min(__len, + std::min(__llen, __rlen)); + std::copy_backward(__lend - __clen, __lend, __rend); + __last -= __clen; + __result -= __clen; + __len -= __clen; + } + return __result; + } + +#if __cplusplus >= 201103L + template + _Deque_iterator<_Tp, _Tp&, _Tp*> + move(_Deque_iterator<_Tp, const _Tp&, const _Tp*> __first, + _Deque_iterator<_Tp, const _Tp&, const _Tp*> __last, + _Deque_iterator<_Tp, _Tp&, _Tp*> __result) + { + typedef typename _Deque_iterator<_Tp, _Tp&, _Tp*>::_Self _Self; + typedef typename _Self::difference_type difference_type; + + difference_type __len = __last - __first; + while (__len > 0) + { + const difference_type __clen + = std::min(__len, std::min(__first._M_last - __first._M_cur, + __result._M_last - __result._M_cur)); + std::move(__first._M_cur, __first._M_cur + __clen, __result._M_cur); + __first += __clen; + __result += __clen; + __len -= __clen; + } + return __result; + } + + template + _Deque_iterator<_Tp, _Tp&, _Tp*> + move_backward(_Deque_iterator<_Tp, const _Tp&, const _Tp*> __first, + _Deque_iterator<_Tp, const _Tp&, const _Tp*> __last, + _Deque_iterator<_Tp, _Tp&, _Tp*> __result) + { + typedef typename _Deque_iterator<_Tp, _Tp&, _Tp*>::_Self _Self; + typedef typename _Self::difference_type difference_type; + + difference_type __len = __last - __first; + while (__len > 0) + { + difference_type __llen = __last._M_cur - __last._M_first; + _Tp* __lend = __last._M_cur; + + difference_type __rlen = __result._M_cur - __result._M_first; + _Tp* __rend = __result._M_cur; + + if (!__llen) + { + __llen = _Self::_S_buffer_size(); + __lend = *(__last._M_node - 1) + __llen; + } + if (!__rlen) + { + __rlen = _Self::_S_buffer_size(); + __rend = *(__result._M_node - 1) + __rlen; + } + + const difference_type __clen = std::min(__len, + std::min(__llen, __rlen)); + std::move_backward(__lend - __clen, __lend, __rend); + __last -= __clen; + __result -= __clen; + __len -= __clen; + } + return __result; + } +#endif + +_GLIBCXX_END_NAMESPACE_CONTAINER +} // namespace std + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/enable_special_members.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/enable_special_members.h new file mode 100755 index 0000000..b1822a4 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/enable_special_members.h @@ -0,0 +1,278 @@ +// -*- C++ -*- + +// Copyright (C) 2013-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file bits/enable_special_members.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. + */ + +#ifndef _ENABLE_SPECIAL_MEMBERS_H +#define _ENABLE_SPECIAL_MEMBERS_H 1 + +#pragma GCC system_header + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + +/** + * @brief A mixin helper to conditionally enable or disable the default + * constructor. + * @sa _Enable_special_members + */ +template + struct _Enable_default_constructor { }; + + +/** + * @brief A mixin helper to conditionally enable or disable the default + * destructor. + * @sa _Enable_special_members + */ +template + struct _Enable_destructor { }; + +/** + * @brief A mixin helper to conditionally enable or disable the copy/move + * special members. + * @sa _Enable_special_members + */ +template + struct _Enable_copy_move { }; + +/** + * @brief A mixin helper to conditionally enable or disable the special + * members. + * + * The @c _Tag type parameter is to make mixin bases unique and thus avoid + * ambiguities. + */ +template + struct _Enable_special_members + : private _Enable_default_constructor<_Default, _Tag>, + private _Enable_destructor<_Destructor, _Tag>, + private _Enable_copy_move<_Copy, _CopyAssignment, + _Move, _MoveAssignment, + _Tag> + { }; + +// Boilerplate follows. + +template + struct _Enable_default_constructor + { constexpr _Enable_default_constructor() noexcept = delete; }; + +template + struct _Enable_destructor + { ~_Enable_destructor() noexcept = delete; }; + +template + struct _Enable_copy_move + { + constexpr _Enable_copy_move() noexcept = default; + constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete; + constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = default; + _Enable_copy_move& + operator=(_Enable_copy_move const&) noexcept = default; + _Enable_copy_move& + operator=(_Enable_copy_move&&) noexcept = default; + }; + +template + struct _Enable_copy_move + { + constexpr _Enable_copy_move() noexcept = default; + constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = default; + constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = default; + _Enable_copy_move& + operator=(_Enable_copy_move const&) noexcept = delete; + _Enable_copy_move& + operator=(_Enable_copy_move&&) noexcept = default; + }; + +template + struct _Enable_copy_move + { + constexpr _Enable_copy_move() noexcept = default; + constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete; + constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = default; + _Enable_copy_move& + operator=(_Enable_copy_move const&) noexcept = delete; + _Enable_copy_move& + operator=(_Enable_copy_move&&) noexcept = default; + }; + +template + struct _Enable_copy_move + { + constexpr _Enable_copy_move() noexcept = default; + constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = default; + constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete; + _Enable_copy_move& + operator=(_Enable_copy_move const&) noexcept = default; + _Enable_copy_move& + operator=(_Enable_copy_move&&) noexcept = default; + }; + +template + struct _Enable_copy_move + { + constexpr _Enable_copy_move() noexcept = default; + constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete; + constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete; + _Enable_copy_move& + operator=(_Enable_copy_move const&) noexcept = default; + _Enable_copy_move& + operator=(_Enable_copy_move&&) noexcept = default; + }; + +template + struct _Enable_copy_move + { + constexpr _Enable_copy_move() noexcept = default; + constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = default; + constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete; + _Enable_copy_move& + operator=(_Enable_copy_move const&) noexcept = delete; + _Enable_copy_move& + operator=(_Enable_copy_move&&) noexcept = default; + }; + +template + struct _Enable_copy_move + { + constexpr _Enable_copy_move() noexcept = default; + constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete; + constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete; + _Enable_copy_move& + operator=(_Enable_copy_move const&) noexcept = delete; + _Enable_copy_move& + operator=(_Enable_copy_move&&) noexcept = default; + }; + +template + struct _Enable_copy_move + { + constexpr _Enable_copy_move() noexcept = default; + constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = default; + constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = default; + _Enable_copy_move& + operator=(_Enable_copy_move const&) noexcept = default; + _Enable_copy_move& + operator=(_Enable_copy_move&&) noexcept = delete; + }; + +template + struct _Enable_copy_move + { + constexpr _Enable_copy_move() noexcept = default; + constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete; + constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = default; + _Enable_copy_move& + operator=(_Enable_copy_move const&) noexcept = default; + _Enable_copy_move& + operator=(_Enable_copy_move&&) noexcept = delete; + }; + +template + struct _Enable_copy_move + { + constexpr _Enable_copy_move() noexcept = default; + constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = default; + constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = default; + _Enable_copy_move& + operator=(_Enable_copy_move const&) noexcept = delete; + _Enable_copy_move& + operator=(_Enable_copy_move&&) noexcept = delete; + }; + +template + struct _Enable_copy_move + { + constexpr _Enable_copy_move() noexcept = default; + constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete; + constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = default; + _Enable_copy_move& + operator=(_Enable_copy_move const&) noexcept = delete; + _Enable_copy_move& + operator=(_Enable_copy_move&&) noexcept = delete; + }; + +template + struct _Enable_copy_move + { + constexpr _Enable_copy_move() noexcept = default; + constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = default; + constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete; + _Enable_copy_move& + operator=(_Enable_copy_move const&) noexcept = default; + _Enable_copy_move& + operator=(_Enable_copy_move&&) noexcept = delete; + }; + +template + struct _Enable_copy_move + { + constexpr _Enable_copy_move() noexcept = default; + constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete; + constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete; + _Enable_copy_move& + operator=(_Enable_copy_move const&) noexcept = default; + _Enable_copy_move& + operator=(_Enable_copy_move&&) noexcept = delete; + }; + +template + struct _Enable_copy_move + { + constexpr _Enable_copy_move() noexcept = default; + constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = default; + constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete; + _Enable_copy_move& + operator=(_Enable_copy_move const&) noexcept = delete; + _Enable_copy_move& + operator=(_Enable_copy_move&&) noexcept = delete; + }; + +template + struct _Enable_copy_move + { + constexpr _Enable_copy_move() noexcept = default; + constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete; + constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete; + _Enable_copy_move& + operator=(_Enable_copy_move const&) noexcept = delete; + _Enable_copy_move& + operator=(_Enable_copy_move&&) noexcept = delete; + }; + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace std + +#endif // _ENABLE_SPECIAL_MEMBERS_H diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/exception_defines.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/exception_defines.h new file mode 100755 index 0000000..89ea52a --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/exception_defines.h @@ -0,0 +1,45 @@ +// -fno-exceptions Support -*- C++ -*- + +// Copyright (C) 2001-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file bits/exception_defines.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{exception} + */ + +#ifndef _EXCEPTION_DEFINES_H +#define _EXCEPTION_DEFINES_H 1 + +#ifndef __EXCEPTIONS +// Iff -fno-exceptions, transform error handling code to work without it. +# define __try if (true) +# define __catch(X) if (false) +# define __throw_exception_again +#else +// Else proceed normally. +# define __try try +# define __catch(X) catch(X) +# define __throw_exception_again throw +#endif + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/exception_ptr.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/exception_ptr.h new file mode 100755 index 0000000..9ba0de4 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/exception_ptr.h @@ -0,0 +1,203 @@ +// Exception Handling support header (exception_ptr class) for -*- C++ -*- + +// Copyright (C) 2008-2014 Free Software Foundation, Inc. +// +// This file is part of GCC. +// +// GCC is free software; you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation; either version 3, or (at your option) +// any later version. +// +// GCC is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file bits/exception_ptr.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{exception} + */ + +#ifndef _EXCEPTION_PTR_H +#define _EXCEPTION_PTR_H + +#pragma GCC visibility push(default) + +#include +#include + +#if ATOMIC_INT_LOCK_FREE < 2 +# error This platform does not support exception propagation. +#endif + +extern "C++" { + +namespace std +{ + class type_info; + + /** + * @addtogroup exceptions + * @{ + */ + namespace __exception_ptr + { + class exception_ptr; + } + + using __exception_ptr::exception_ptr; + + /** Obtain an exception_ptr to the currently handled exception. If there + * is none, or the currently handled exception is foreign, return the null + * value. + */ + exception_ptr current_exception() _GLIBCXX_USE_NOEXCEPT; + + /// Throw the object pointed to by the exception_ptr. + void rethrow_exception(exception_ptr) __attribute__ ((__noreturn__)); + + namespace __exception_ptr + { + /** + * @brief An opaque pointer to an arbitrary exception. + * @ingroup exceptions + */ + class exception_ptr + { + void* _M_exception_object; + + explicit exception_ptr(void* __e) _GLIBCXX_USE_NOEXCEPT; + + void _M_addref() _GLIBCXX_USE_NOEXCEPT; + void _M_release() _GLIBCXX_USE_NOEXCEPT; + + void *_M_get() const _GLIBCXX_NOEXCEPT __attribute__ ((__pure__)); + + friend exception_ptr std::current_exception() _GLIBCXX_USE_NOEXCEPT; + friend void std::rethrow_exception(exception_ptr); + + public: + exception_ptr() _GLIBCXX_USE_NOEXCEPT; + + exception_ptr(const exception_ptr&) _GLIBCXX_USE_NOEXCEPT; + +#if __cplusplus >= 201103L + exception_ptr(nullptr_t) noexcept + : _M_exception_object(0) + { } + + exception_ptr(exception_ptr&& __o) noexcept + : _M_exception_object(__o._M_exception_object) + { __o._M_exception_object = 0; } +#endif + +#if (__cplusplus < 201103L) || defined (_GLIBCXX_EH_PTR_COMPAT) + typedef void (exception_ptr::*__safe_bool)(); + + // For construction from nullptr or 0. + exception_ptr(__safe_bool) _GLIBCXX_USE_NOEXCEPT; +#endif + + exception_ptr& + operator=(const exception_ptr&) _GLIBCXX_USE_NOEXCEPT; + +#if __cplusplus >= 201103L + exception_ptr& + operator=(exception_ptr&& __o) noexcept + { + exception_ptr(static_cast(__o)).swap(*this); + return *this; + } +#endif + + ~exception_ptr() _GLIBCXX_USE_NOEXCEPT; + + void + swap(exception_ptr&) _GLIBCXX_USE_NOEXCEPT; + +#ifdef _GLIBCXX_EH_PTR_COMPAT + // Retained for compatibility with CXXABI_1.3. + void _M_safe_bool_dummy() _GLIBCXX_USE_NOEXCEPT + __attribute__ ((__const__)); + bool operator!() const _GLIBCXX_USE_NOEXCEPT + __attribute__ ((__pure__)); + operator __safe_bool() const _GLIBCXX_USE_NOEXCEPT; +#endif + +#if __cplusplus >= 201103L + explicit operator bool() const + { return _M_exception_object; } +#endif + + friend bool + operator==(const exception_ptr&, const exception_ptr&) + _GLIBCXX_USE_NOEXCEPT __attribute__ ((__pure__)); + + const class std::type_info* + __cxa_exception_type() const _GLIBCXX_USE_NOEXCEPT + __attribute__ ((__pure__)); + }; + + bool + operator==(const exception_ptr&, const exception_ptr&) + _GLIBCXX_USE_NOEXCEPT __attribute__ ((__pure__)); + + bool + operator!=(const exception_ptr&, const exception_ptr&) + _GLIBCXX_USE_NOEXCEPT __attribute__ ((__pure__)); + + inline void + swap(exception_ptr& __lhs, exception_ptr& __rhs) + { __lhs.swap(__rhs); } + + } // namespace __exception_ptr + + + /// Obtain an exception_ptr pointing to a copy of the supplied object. + template + exception_ptr + make_exception_ptr(_Ex __ex) _GLIBCXX_USE_NOEXCEPT + { + __try + { +#ifdef __EXCEPTIONS + throw __ex; +#endif + } + __catch(...) + { + return current_exception(); + } + } + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 1130. copy_exception name misleading + /// Obtain an exception_ptr pointing to a copy of the supplied object. + /// This function is deprecated, use std::make_exception_ptr instead. + template + exception_ptr + copy_exception(_Ex __ex) _GLIBCXX_USE_NOEXCEPT _GLIBCXX_DEPRECATED; + + template + exception_ptr + copy_exception(_Ex __ex) _GLIBCXX_USE_NOEXCEPT + { return std::make_exception_ptr<_Ex>(__ex); } + + // @} group exceptions +} // namespace std + +} // extern "C++" + +#pragma GCC visibility pop + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/forward_list.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/forward_list.h new file mode 100755 index 0000000..524fad1 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/forward_list.h @@ -0,0 +1,1408 @@ +// -*- C++ -*- + +// Copyright (C) 2008-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file bits/forward_list.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{forward_list} + */ + +#ifndef _FORWARD_LIST_H +#define _FORWARD_LIST_H 1 + +#pragma GCC system_header + +#include +#include +#include +#include +#include +#include +#include +#include + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_CONTAINER + + /** + * @brief A helper basic node class for %forward_list. + * This is just a linked list with nothing inside it. + * There are purely list shuffling utility methods here. + */ + struct _Fwd_list_node_base + { + _Fwd_list_node_base() = default; + + _Fwd_list_node_base* _M_next = nullptr; + + _Fwd_list_node_base* + _M_transfer_after(_Fwd_list_node_base* __begin, + _Fwd_list_node_base* __end) noexcept + { + _Fwd_list_node_base* __keep = __begin->_M_next; + if (__end) + { + __begin->_M_next = __end->_M_next; + __end->_M_next = _M_next; + } + else + __begin->_M_next = 0; + _M_next = __keep; + return __end; + } + + void + _M_reverse_after() noexcept + { + _Fwd_list_node_base* __tail = _M_next; + if (!__tail) + return; + while (_Fwd_list_node_base* __temp = __tail->_M_next) + { + _Fwd_list_node_base* __keep = _M_next; + _M_next = __temp; + __tail->_M_next = __temp->_M_next; + _M_next->_M_next = __keep; + } + } + }; + + /** + * @brief A helper node class for %forward_list. + * This is just a linked list with uninitialized storage for a + * data value in each node. + * There is a sorting utility method. + */ + template + struct _Fwd_list_node + : public _Fwd_list_node_base + { + _Fwd_list_node() = default; + + __gnu_cxx::__aligned_buffer<_Tp> _M_storage; + + _Tp* + _M_valptr() noexcept + { return _M_storage._M_ptr(); } + + const _Tp* + _M_valptr() const noexcept + { return _M_storage._M_ptr(); } + }; + + /** + * @brief A forward_list::iterator. + * + * All the functions are op overloads. + */ + template + struct _Fwd_list_iterator + { + typedef _Fwd_list_iterator<_Tp> _Self; + typedef _Fwd_list_node<_Tp> _Node; + + typedef _Tp value_type; + typedef _Tp* pointer; + typedef _Tp& reference; + typedef ptrdiff_t difference_type; + typedef std::forward_iterator_tag iterator_category; + + _Fwd_list_iterator() noexcept + : _M_node() { } + + explicit + _Fwd_list_iterator(_Fwd_list_node_base* __n) noexcept + : _M_node(__n) { } + + reference + operator*() const noexcept + { return *static_cast<_Node*>(this->_M_node)->_M_valptr(); } + + pointer + operator->() const noexcept + { return static_cast<_Node*>(this->_M_node)->_M_valptr(); } + + _Self& + operator++() noexcept + { + _M_node = _M_node->_M_next; + return *this; + } + + _Self + operator++(int) noexcept + { + _Self __tmp(*this); + _M_node = _M_node->_M_next; + return __tmp; + } + + bool + operator==(const _Self& __x) const noexcept + { return _M_node == __x._M_node; } + + bool + operator!=(const _Self& __x) const noexcept + { return _M_node != __x._M_node; } + + _Self + _M_next() const noexcept + { + if (_M_node) + return _Fwd_list_iterator(_M_node->_M_next); + else + return _Fwd_list_iterator(0); + } + + _Fwd_list_node_base* _M_node; + }; + + /** + * @brief A forward_list::const_iterator. + * + * All the functions are op overloads. + */ + template + struct _Fwd_list_const_iterator + { + typedef _Fwd_list_const_iterator<_Tp> _Self; + typedef const _Fwd_list_node<_Tp> _Node; + typedef _Fwd_list_iterator<_Tp> iterator; + + typedef _Tp value_type; + typedef const _Tp* pointer; + typedef const _Tp& reference; + typedef ptrdiff_t difference_type; + typedef std::forward_iterator_tag iterator_category; + + _Fwd_list_const_iterator() noexcept + : _M_node() { } + + explicit + _Fwd_list_const_iterator(const _Fwd_list_node_base* __n) noexcept + : _M_node(__n) { } + + _Fwd_list_const_iterator(const iterator& __iter) noexcept + : _M_node(__iter._M_node) { } + + reference + operator*() const noexcept + { return *static_cast<_Node*>(this->_M_node)->_M_valptr(); } + + pointer + operator->() const noexcept + { return static_cast<_Node*>(this->_M_node)->_M_valptr(); } + + _Self& + operator++() noexcept + { + _M_node = _M_node->_M_next; + return *this; + } + + _Self + operator++(int) noexcept + { + _Self __tmp(*this); + _M_node = _M_node->_M_next; + return __tmp; + } + + bool + operator==(const _Self& __x) const noexcept + { return _M_node == __x._M_node; } + + bool + operator!=(const _Self& __x) const noexcept + { return _M_node != __x._M_node; } + + _Self + _M_next() const noexcept + { + if (this->_M_node) + return _Fwd_list_const_iterator(_M_node->_M_next); + else + return _Fwd_list_const_iterator(0); + } + + const _Fwd_list_node_base* _M_node; + }; + + /** + * @brief Forward list iterator equality comparison. + */ + template + inline bool + operator==(const _Fwd_list_iterator<_Tp>& __x, + const _Fwd_list_const_iterator<_Tp>& __y) noexcept + { return __x._M_node == __y._M_node; } + + /** + * @brief Forward list iterator inequality comparison. + */ + template + inline bool + operator!=(const _Fwd_list_iterator<_Tp>& __x, + const _Fwd_list_const_iterator<_Tp>& __y) noexcept + { return __x._M_node != __y._M_node; } + + /** + * @brief Base class for %forward_list. + */ + template + struct _Fwd_list_base + { + protected: + typedef typename __gnu_cxx::__alloc_traits<_Alloc> _Alloc_traits; + typedef typename _Alloc_traits::template rebind<_Tp>::other + _Tp_alloc_type; + + typedef typename _Alloc_traits::template + rebind<_Fwd_list_node<_Tp>>::other _Node_alloc_type; + + typedef __gnu_cxx::__alloc_traits<_Node_alloc_type> _Node_alloc_traits; + + struct _Fwd_list_impl + : public _Node_alloc_type + { + _Fwd_list_node_base _M_head; + + _Fwd_list_impl() + : _Node_alloc_type(), _M_head() + { } + + _Fwd_list_impl(const _Node_alloc_type& __a) + : _Node_alloc_type(__a), _M_head() + { } + + _Fwd_list_impl(_Node_alloc_type&& __a) + : _Node_alloc_type(std::move(__a)), _M_head() + { } + }; + + _Fwd_list_impl _M_impl; + + public: + typedef _Fwd_list_iterator<_Tp> iterator; + typedef _Fwd_list_const_iterator<_Tp> const_iterator; + typedef _Fwd_list_node<_Tp> _Node; + + _Node_alloc_type& + _M_get_Node_allocator() noexcept + { return *static_cast<_Node_alloc_type*>(&this->_M_impl); } + + const _Node_alloc_type& + _M_get_Node_allocator() const noexcept + { return *static_cast(&this->_M_impl); } + + _Fwd_list_base() + : _M_impl() { } + + _Fwd_list_base(const _Node_alloc_type& __a) + : _M_impl(__a) { } + + _Fwd_list_base(_Fwd_list_base&& __lst, const _Node_alloc_type& __a); + + _Fwd_list_base(_Fwd_list_base&& __lst) + : _M_impl(std::move(__lst._M_get_Node_allocator())) + { + this->_M_impl._M_head._M_next = __lst._M_impl._M_head._M_next; + __lst._M_impl._M_head._M_next = 0; + } + + ~_Fwd_list_base() + { _M_erase_after(&_M_impl._M_head, 0); } + + protected: + + _Node* + _M_get_node() + { + auto __ptr = _Node_alloc_traits::allocate(_M_get_Node_allocator(), 1); + return std::__addressof(*__ptr); + } + + template + _Node* + _M_create_node(_Args&&... __args) + { + _Node* __node = this->_M_get_node(); + __try + { + _Tp_alloc_type __a(_M_get_Node_allocator()); + typedef allocator_traits<_Tp_alloc_type> _Alloc_traits; + ::new ((void*)__node) _Node; + _Alloc_traits::construct(__a, __node->_M_valptr(), + std::forward<_Args>(__args)...); + } + __catch(...) + { + this->_M_put_node(__node); + __throw_exception_again; + } + return __node; + } + + template + _Fwd_list_node_base* + _M_insert_after(const_iterator __pos, _Args&&... __args); + + void + _M_put_node(_Node* __p) + { + typedef typename _Node_alloc_traits::pointer _Ptr; + auto __ptr = std::pointer_traits<_Ptr>::pointer_to(*__p); + _Node_alloc_traits::deallocate(_M_get_Node_allocator(), __ptr, 1); + } + + _Fwd_list_node_base* + _M_erase_after(_Fwd_list_node_base* __pos); + + _Fwd_list_node_base* + _M_erase_after(_Fwd_list_node_base* __pos, + _Fwd_list_node_base* __last); + }; + + /** + * @brief A standard container with linear time access to elements, + * and fixed time insertion/deletion at any point in the sequence. + * + * @ingroup sequences + * + * @tparam _Tp Type of element. + * @tparam _Alloc Allocator type, defaults to allocator<_Tp>. + * + * Meets the requirements of a container, a + * sequence, including the + * optional sequence requirements with the + * %exception of @c at and @c operator[]. + * + * This is a @e singly @e linked %list. Traversal up the + * %list requires linear time, but adding and removing elements (or + * @e nodes) is done in constant time, regardless of where the + * change takes place. Unlike std::vector and std::deque, + * random-access iterators are not provided, so subscripting ( @c + * [] ) access is not allowed. For algorithms which only need + * sequential access, this lack makes no difference. + * + * Also unlike the other standard containers, std::forward_list provides + * specialized algorithms %unique to linked lists, such as + * splicing, sorting, and in-place reversal. + */ + template > + class forward_list : private _Fwd_list_base<_Tp, _Alloc> + { + private: + typedef _Fwd_list_base<_Tp, _Alloc> _Base; + typedef _Fwd_list_node<_Tp> _Node; + typedef _Fwd_list_node_base _Node_base; + typedef typename _Base::_Tp_alloc_type _Tp_alloc_type; + typedef typename _Base::_Node_alloc_type _Node_alloc_type; + typedef typename _Base::_Node_alloc_traits _Node_alloc_traits; + typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Alloc_traits; + + public: + // types: + typedef _Tp value_type; + typedef typename _Alloc_traits::pointer pointer; + typedef typename _Alloc_traits::const_pointer const_pointer; + typedef value_type& reference; + typedef const value_type& const_reference; + + typedef _Fwd_list_iterator<_Tp> iterator; + typedef _Fwd_list_const_iterator<_Tp> const_iterator; + typedef std::size_t size_type; + typedef std::ptrdiff_t difference_type; + typedef _Alloc allocator_type; + + // 23.3.4.2 construct/copy/destroy: + + /** + * @brief Creates a %forward_list with no elements. + * @param __al An allocator object. + */ + explicit + forward_list(const _Alloc& __al = _Alloc()) + : _Base(_Node_alloc_type(__al)) + { } + + /** + * @brief Copy constructor with allocator argument. + * @param __list Input list to copy. + * @param __al An allocator object. + */ + forward_list(const forward_list& __list, const _Alloc& __al) + : _Base(_Node_alloc_type(__al)) + { _M_range_initialize(__list.begin(), __list.end()); } + + /** + * @brief Move constructor with allocator argument. + * @param __list Input list to move. + * @param __al An allocator object. + */ + forward_list(forward_list&& __list, const _Alloc& __al) + noexcept(_Node_alloc_traits::_S_always_equal()) + : _Base(std::move(__list), _Node_alloc_type(__al)) + { } + + /** + * @brief Creates a %forward_list with default constructed elements. + * @param __n The number of elements to initially create. + * + * This constructor creates the %forward_list with @a __n default + * constructed elements. + */ + explicit + forward_list(size_type __n, const _Alloc& __al = _Alloc()) + : _Base(_Node_alloc_type(__al)) + { _M_default_initialize(__n); } + + /** + * @brief Creates a %forward_list with copies of an exemplar element. + * @param __n The number of elements to initially create. + * @param __value An element to copy. + * @param __al An allocator object. + * + * This constructor fills the %forward_list with @a __n copies of + * @a __value. + */ + forward_list(size_type __n, const _Tp& __value, + const _Alloc& __al = _Alloc()) + : _Base(_Node_alloc_type(__al)) + { _M_fill_initialize(__n, __value); } + + /** + * @brief Builds a %forward_list from a range. + * @param __first An input iterator. + * @param __last An input iterator. + * @param __al An allocator object. + * + * Create a %forward_list consisting of copies of the elements from + * [@a __first,@a __last). This is linear in N (where N is + * distance(@a __first,@a __last)). + */ + template> + forward_list(_InputIterator __first, _InputIterator __last, + const _Alloc& __al = _Alloc()) + : _Base(_Node_alloc_type(__al)) + { _M_range_initialize(__first, __last); } + + /** + * @brief The %forward_list copy constructor. + * @param __list A %forward_list of identical element and allocator + * types. + */ + forward_list(const forward_list& __list) + : _Base(_Node_alloc_traits::_S_select_on_copy( + __list._M_get_Node_allocator())) + { _M_range_initialize(__list.begin(), __list.end()); } + + /** + * @brief The %forward_list move constructor. + * @param __list A %forward_list of identical element and allocator + * types. + * + * The newly-created %forward_list contains the exact contents of @a + * __list. The contents of @a __list are a valid, but unspecified + * %forward_list. + */ + forward_list(forward_list&& __list) noexcept + : _Base(std::move(__list)) { } + + /** + * @brief Builds a %forward_list from an initializer_list + * @param __il An initializer_list of value_type. + * @param __al An allocator object. + * + * Create a %forward_list consisting of copies of the elements + * in the initializer_list @a __il. This is linear in __il.size(). + */ + forward_list(std::initializer_list<_Tp> __il, + const _Alloc& __al = _Alloc()) + : _Base(_Node_alloc_type(__al)) + { _M_range_initialize(__il.begin(), __il.end()); } + + /** + * @brief The forward_list dtor. + */ + ~forward_list() noexcept + { } + + /** + * @brief The %forward_list assignment operator. + * @param __list A %forward_list of identical element and allocator + * types. + * + * All the elements of @a __list are copied, but unlike the copy + * constructor, the allocator object is not copied. + */ + forward_list& + operator=(const forward_list& __list); + + /** + * @brief The %forward_list move assignment operator. + * @param __list A %forward_list of identical element and allocator + * types. + * + * The contents of @a __list are moved into this %forward_list + * (without copying, if the allocators permit it). + * @a __list is a valid, but unspecified %forward_list + */ + forward_list& + operator=(forward_list&& __list) + noexcept(_Node_alloc_traits::_S_nothrow_move()) + { + constexpr bool __move_storage = + _Node_alloc_traits::_S_propagate_on_move_assign() + || _Node_alloc_traits::_S_always_equal(); + _M_move_assign(std::move(__list), + integral_constant()); + return *this; + } + + /** + * @brief The %forward_list initializer list assignment operator. + * @param __il An initializer_list of value_type. + * + * Replace the contents of the %forward_list with copies of the + * elements in the initializer_list @a __il. This is linear in + * __il.size(). + */ + forward_list& + operator=(std::initializer_list<_Tp> __il) + { + assign(__il); + return *this; + } + + /** + * @brief Assigns a range to a %forward_list. + * @param __first An input iterator. + * @param __last An input iterator. + * + * This function fills a %forward_list with copies of the elements + * in the range [@a __first,@a __last). + * + * Note that the assignment completely changes the %forward_list and + * that the number of elements of the resulting %forward_list is the + * same as the number of elements assigned. Old data is lost. + */ + template> + void + assign(_InputIterator __first, _InputIterator __last) + { + typedef is_assignable<_Tp, decltype(*__first)> __assignable; + _M_assign(__first, __last, __assignable()); + } + + /** + * @brief Assigns a given value to a %forward_list. + * @param __n Number of elements to be assigned. + * @param __val Value to be assigned. + * + * This function fills a %forward_list with @a __n copies of the + * given value. Note that the assignment completely changes the + * %forward_list, and that the resulting %forward_list has __n + * elements. Old data is lost. + */ + void + assign(size_type __n, const _Tp& __val) + { _M_assign_n(__n, __val, is_copy_assignable<_Tp>()); } + + /** + * @brief Assigns an initializer_list to a %forward_list. + * @param __il An initializer_list of value_type. + * + * Replace the contents of the %forward_list with copies of the + * elements in the initializer_list @a __il. This is linear in + * il.size(). + */ + void + assign(std::initializer_list<_Tp> __il) + { assign(__il.begin(), __il.end()); } + + /// Get a copy of the memory allocation object. + allocator_type + get_allocator() const noexcept + { return allocator_type(this->_M_get_Node_allocator()); } + + // 23.3.4.3 iterators: + + /** + * Returns a read/write iterator that points before the first element + * in the %forward_list. Iteration is done in ordinary element order. + */ + iterator + before_begin() noexcept + { return iterator(&this->_M_impl._M_head); } + + /** + * Returns a read-only (constant) iterator that points before the + * first element in the %forward_list. Iteration is done in ordinary + * element order. + */ + const_iterator + before_begin() const noexcept + { return const_iterator(&this->_M_impl._M_head); } + + /** + * Returns a read/write iterator that points to the first element + * in the %forward_list. Iteration is done in ordinary element order. + */ + iterator + begin() noexcept + { return iterator(this->_M_impl._M_head._M_next); } + + /** + * Returns a read-only (constant) iterator that points to the first + * element in the %forward_list. Iteration is done in ordinary + * element order. + */ + const_iterator + begin() const noexcept + { return const_iterator(this->_M_impl._M_head._M_next); } + + /** + * Returns a read/write iterator that points one past the last + * element in the %forward_list. Iteration is done in ordinary + * element order. + */ + iterator + end() noexcept + { return iterator(0); } + + /** + * Returns a read-only iterator that points one past the last + * element in the %forward_list. Iteration is done in ordinary + * element order. + */ + const_iterator + end() const noexcept + { return const_iterator(0); } + + /** + * Returns a read-only (constant) iterator that points to the + * first element in the %forward_list. Iteration is done in ordinary + * element order. + */ + const_iterator + cbegin() const noexcept + { return const_iterator(this->_M_impl._M_head._M_next); } + + /** + * Returns a read-only (constant) iterator that points before the + * first element in the %forward_list. Iteration is done in ordinary + * element order. + */ + const_iterator + cbefore_begin() const noexcept + { return const_iterator(&this->_M_impl._M_head); } + + /** + * Returns a read-only (constant) iterator that points one past + * the last element in the %forward_list. Iteration is done in + * ordinary element order. + */ + const_iterator + cend() const noexcept + { return const_iterator(0); } + + /** + * Returns true if the %forward_list is empty. (Thus begin() would + * equal end().) + */ + bool + empty() const noexcept + { return this->_M_impl._M_head._M_next == 0; } + + /** + * Returns the largest possible number of elements of %forward_list. + */ + size_type + max_size() const noexcept + { return _Node_alloc_traits::max_size(this->_M_get_Node_allocator()); } + + // 23.3.4.4 element access: + + /** + * Returns a read/write reference to the data at the first + * element of the %forward_list. + */ + reference + front() + { + _Node* __front = static_cast<_Node*>(this->_M_impl._M_head._M_next); + return *__front->_M_valptr(); + } + + /** + * Returns a read-only (constant) reference to the data at the first + * element of the %forward_list. + */ + const_reference + front() const + { + _Node* __front = static_cast<_Node*>(this->_M_impl._M_head._M_next); + return *__front->_M_valptr(); + } + + // 23.3.4.5 modiï¬ers: + + /** + * @brief Constructs object in %forward_list at the front of the + * list. + * @param __args Arguments. + * + * This function will insert an object of type Tp constructed + * with Tp(std::forward(args)...) at the front of the list + * Due to the nature of a %forward_list this operation can + * be done in constant time, and does not invalidate iterators + * and references. + */ + template + void + emplace_front(_Args&&... __args) + { this->_M_insert_after(cbefore_begin(), + std::forward<_Args>(__args)...); } + + /** + * @brief Add data to the front of the %forward_list. + * @param __val Data to be added. + * + * This is a typical stack operation. The function creates an + * element at the front of the %forward_list and assigns the given + * data to it. Due to the nature of a %forward_list this operation + * can be done in constant time, and does not invalidate iterators + * and references. + */ + void + push_front(const _Tp& __val) + { this->_M_insert_after(cbefore_begin(), __val); } + + /** + * + */ + void + push_front(_Tp&& __val) + { this->_M_insert_after(cbefore_begin(), std::move(__val)); } + + /** + * @brief Removes first element. + * + * This is a typical stack operation. It shrinks the %forward_list + * by one. Due to the nature of a %forward_list this operation can + * be done in constant time, and only invalidates iterators/references + * to the element being removed. + * + * Note that no data is returned, and if the first element's data + * is needed, it should be retrieved before pop_front() is + * called. + */ + void + pop_front() + { this->_M_erase_after(&this->_M_impl._M_head); } + + /** + * @brief Constructs object in %forward_list after the specified + * iterator. + * @param __pos A const_iterator into the %forward_list. + * @param __args Arguments. + * @return An iterator that points to the inserted data. + * + * This function will insert an object of type T constructed + * with T(std::forward(args)...) after the specified + * location. Due to the nature of a %forward_list this operation can + * be done in constant time, and does not invalidate iterators + * and references. + */ + template + iterator + emplace_after(const_iterator __pos, _Args&&... __args) + { return iterator(this->_M_insert_after(__pos, + std::forward<_Args>(__args)...)); } + + /** + * @brief Inserts given value into %forward_list after specified + * iterator. + * @param __pos An iterator into the %forward_list. + * @param __val Data to be inserted. + * @return An iterator that points to the inserted data. + * + * This function will insert a copy of the given value after + * the specified location. Due to the nature of a %forward_list this + * operation can be done in constant time, and does not + * invalidate iterators and references. + */ + iterator + insert_after(const_iterator __pos, const _Tp& __val) + { return iterator(this->_M_insert_after(__pos, __val)); } + + /** + * + */ + iterator + insert_after(const_iterator __pos, _Tp&& __val) + { return iterator(this->_M_insert_after(__pos, std::move(__val))); } + + /** + * @brief Inserts a number of copies of given data into the + * %forward_list. + * @param __pos An iterator into the %forward_list. + * @param __n Number of elements to be inserted. + * @param __val Data to be inserted. + * @return An iterator pointing to the last inserted copy of + * @a val or @a pos if @a n == 0. + * + * This function will insert a specified number of copies of the + * given data after the location specified by @a pos. + * + * This operation is linear in the number of elements inserted and + * does not invalidate iterators and references. + */ + iterator + insert_after(const_iterator __pos, size_type __n, const _Tp& __val); + + /** + * @brief Inserts a range into the %forward_list. + * @param __pos An iterator into the %forward_list. + * @param __first An input iterator. + * @param __last An input iterator. + * @return An iterator pointing to the last inserted element or + * @a __pos if @a __first == @a __last. + * + * This function will insert copies of the data in the range + * [@a __first,@a __last) into the %forward_list after the + * location specified by @a __pos. + * + * This operation is linear in the number of elements inserted and + * does not invalidate iterators and references. + */ + template> + iterator + insert_after(const_iterator __pos, + _InputIterator __first, _InputIterator __last); + + /** + * @brief Inserts the contents of an initializer_list into + * %forward_list after the specified iterator. + * @param __pos An iterator into the %forward_list. + * @param __il An initializer_list of value_type. + * @return An iterator pointing to the last inserted element + * or @a __pos if @a __il is empty. + * + * This function will insert copies of the data in the + * initializer_list @a __il into the %forward_list before the location + * specified by @a __pos. + * + * This operation is linear in the number of elements inserted and + * does not invalidate iterators and references. + */ + iterator + insert_after(const_iterator __pos, std::initializer_list<_Tp> __il) + { return insert_after(__pos, __il.begin(), __il.end()); } + + /** + * @brief Removes the element pointed to by the iterator following + * @c pos. + * @param __pos Iterator pointing before element to be erased. + * @return An iterator pointing to the element following the one + * that was erased, or end() if no such element exists. + * + * This function will erase the element at the given position and + * thus shorten the %forward_list by one. + * + * Due to the nature of a %forward_list this operation can be done + * in constant time, and only invalidates iterators/references to + * the element being removed. The user is also cautioned that + * this function only erases the element, and that if the element + * is itself a pointer, the pointed-to memory is not touched in + * any way. Managing the pointer is the user's responsibility. + */ + iterator + erase_after(const_iterator __pos) + { return iterator(this->_M_erase_after(const_cast<_Node_base*> + (__pos._M_node))); } + + /** + * @brief Remove a range of elements. + * @param __pos Iterator pointing before the first element to be + * erased. + * @param __last Iterator pointing to one past the last element to be + * erased. + * @return @ __last. + * + * This function will erase the elements in the range + * @a (__pos,__last) and shorten the %forward_list accordingly. + * + * This operation is linear time in the size of the range and only + * invalidates iterators/references to the element being removed. + * The user is also cautioned that this function only erases the + * elements, and that if the elements themselves are pointers, the + * pointed-to memory is not touched in any way. Managing the pointer + * is the user's responsibility. + */ + iterator + erase_after(const_iterator __pos, const_iterator __last) + { return iterator(this->_M_erase_after(const_cast<_Node_base*> + (__pos._M_node), + const_cast<_Node_base*> + (__last._M_node))); } + + /** + * @brief Swaps data with another %forward_list. + * @param __list A %forward_list of the same element and allocator + * types. + * + * This exchanges the elements between two lists in constant + * time. Note that the global std::swap() function is + * specialized such that std::swap(l1,l2) will feed to this + * function. + */ + void + swap(forward_list& __list) + noexcept(_Node_alloc_traits::_S_nothrow_swap()) + { + std::swap(this->_M_impl._M_head._M_next, + __list._M_impl._M_head._M_next); + _Node_alloc_traits::_S_on_swap(this->_M_get_Node_allocator(), + __list._M_get_Node_allocator()); + } + + /** + * @brief Resizes the %forward_list to the specified number of + * elements. + * @param __sz Number of elements the %forward_list should contain. + * + * This function will %resize the %forward_list to the specified + * number of elements. If the number is smaller than the + * %forward_list's current number of elements the %forward_list + * is truncated, otherwise the %forward_list is extended and the + * new elements are default constructed. + */ + void + resize(size_type __sz); + + /** + * @brief Resizes the %forward_list to the specified number of + * elements. + * @param __sz Number of elements the %forward_list should contain. + * @param __val Data with which new elements should be populated. + * + * This function will %resize the %forward_list to the specified + * number of elements. If the number is smaller than the + * %forward_list's current number of elements the %forward_list + * is truncated, otherwise the %forward_list is extended and new + * elements are populated with given data. + */ + void + resize(size_type __sz, const value_type& __val); + + /** + * @brief Erases all the elements. + * + * Note that this function only erases + * the elements, and that if the elements themselves are + * pointers, the pointed-to memory is not touched in any way. + * Managing the pointer is the user's responsibility. + */ + void + clear() noexcept + { this->_M_erase_after(&this->_M_impl._M_head, 0); } + + // 23.3.4.6 forward_list operations: + + /** + * @brief Insert contents of another %forward_list. + * @param __pos Iterator referencing the element to insert after. + * @param __list Source list. + * + * The elements of @a list are inserted in constant time after + * the element referenced by @a pos. @a list becomes an empty + * list. + * + * Requires this != @a x. + */ + void + splice_after(const_iterator __pos, forward_list&& __list) + { + if (!__list.empty()) + _M_splice_after(__pos, __list.before_begin(), __list.end()); + } + + void + splice_after(const_iterator __pos, forward_list& __list) + { splice_after(__pos, std::move(__list)); } + + /** + * @brief Insert element from another %forward_list. + * @param __pos Iterator referencing the element to insert after. + * @param __list Source list. + * @param __i Iterator referencing the element before the element + * to move. + * + * Removes the element in list @a list referenced by @a i and + * inserts it into the current list after @a pos. + */ + void + splice_after(const_iterator __pos, forward_list&& __list, + const_iterator __i); + + void + splice_after(const_iterator __pos, forward_list& __list, + const_iterator __i) + { splice_after(__pos, std::move(__list), __i); } + + /** + * @brief Insert range from another %forward_list. + * @param __pos Iterator referencing the element to insert after. + * @param __list Source list. + * @param __before Iterator referencing before the start of range + * in list. + * @param __last Iterator referencing the end of range in list. + * + * Removes elements in the range (__before,__last) and inserts them + * after @a __pos in constant time. + * + * Undefined if @a __pos is in (__before,__last). + */ + void + splice_after(const_iterator __pos, forward_list&&, + const_iterator __before, const_iterator __last) + { _M_splice_after(__pos, __before, __last); } + + void + splice_after(const_iterator __pos, forward_list&, + const_iterator __before, const_iterator __last) + { _M_splice_after(__pos, __before, __last); } + + /** + * @brief Remove all elements equal to value. + * @param __val The value to remove. + * + * Removes every element in the list equal to @a __val. + * Remaining elements stay in list order. Note that this + * function only erases the elements, and that if the elements + * themselves are pointers, the pointed-to memory is not + * touched in any way. Managing the pointer is the user's + * responsibility. + */ + void + remove(const _Tp& __val); + + /** + * @brief Remove all elements satisfying a predicate. + * @param __pred Unary predicate function or object. + * + * Removes every element in the list for which the predicate + * returns true. Remaining elements stay in list order. Note + * that this function only erases the elements, and that if the + * elements themselves are pointers, the pointed-to memory is + * not touched in any way. Managing the pointer is the user's + * responsibility. + */ + template + void + remove_if(_Pred __pred); + + /** + * @brief Remove consecutive duplicate elements. + * + * For each consecutive set of elements with the same value, + * remove all but the first one. Remaining elements stay in + * list order. Note that this function only erases the + * elements, and that if the elements themselves are pointers, + * the pointed-to memory is not touched in any way. Managing + * the pointer is the user's responsibility. + */ + void + unique() + { unique(std::equal_to<_Tp>()); } + + /** + * @brief Remove consecutive elements satisfying a predicate. + * @param __binary_pred Binary predicate function or object. + * + * For each consecutive set of elements [first,last) that + * satisfy predicate(first,i) where i is an iterator in + * [first,last), remove all but the first one. Remaining + * elements stay in list order. Note that this function only + * erases the elements, and that if the elements themselves are + * pointers, the pointed-to memory is not touched in any way. + * Managing the pointer is the user's responsibility. + */ + template + void + unique(_BinPred __binary_pred); + + /** + * @brief Merge sorted lists. + * @param __list Sorted list to merge. + * + * Assumes that both @a list and this list are sorted according to + * operator<(). Merges elements of @a __list into this list in + * sorted order, leaving @a __list empty when complete. Elements in + * this list precede elements in @a __list that are equal. + */ + void + merge(forward_list&& __list) + { merge(std::move(__list), std::less<_Tp>()); } + + void + merge(forward_list& __list) + { merge(std::move(__list)); } + + /** + * @brief Merge sorted lists according to comparison function. + * @param __list Sorted list to merge. + * @param __comp Comparison function defining sort order. + * + * Assumes that both @a __list and this list are sorted according to + * comp. Merges elements of @a __list into this list + * in sorted order, leaving @a __list empty when complete. Elements + * in this list precede elements in @a __list that are equivalent + * according to comp(). + */ + template + void + merge(forward_list&& __list, _Comp __comp); + + template + void + merge(forward_list& __list, _Comp __comp) + { merge(std::move(__list), __comp); } + + /** + * @brief Sort the elements of the list. + * + * Sorts the elements of this list in NlogN time. Equivalent + * elements remain in list order. + */ + void + sort() + { sort(std::less<_Tp>()); } + + /** + * @brief Sort the forward_list using a comparison function. + * + * Sorts the elements of this list in NlogN time. Equivalent + * elements remain in list order. + */ + template + void + sort(_Comp __comp); + + /** + * @brief Reverse the elements in list. + * + * Reverse the order of elements in the list in linear time. + */ + void + reverse() noexcept + { this->_M_impl._M_head._M_reverse_after(); } + + private: + // Called by the range constructor to implement [23.3.4.2]/9 + template + void + _M_range_initialize(_InputIterator __first, _InputIterator __last); + + // Called by forward_list(n,v,a), and the range constructor when it + // turns out to be the same thing. + void + _M_fill_initialize(size_type __n, const value_type& __value); + + // Called by splice_after and insert_after. + iterator + _M_splice_after(const_iterator __pos, const_iterator __before, + const_iterator __last); + + // Called by forward_list(n). + void + _M_default_initialize(size_type __n); + + // Called by resize(sz). + void + _M_default_insert_after(const_iterator __pos, size_type __n); + + // Called by operator=(forward_list&&) + void + _M_move_assign(forward_list&& __list, std::true_type) noexcept + { + clear(); + std::swap(this->_M_impl._M_head._M_next, + __list._M_impl._M_head._M_next); + std::__alloc_on_move(this->_M_get_Node_allocator(), + __list._M_get_Node_allocator()); + } + + // Called by operator=(forward_list&&) + void + _M_move_assign(forward_list&& __list, std::false_type) + { + if (__list._M_get_Node_allocator() == this->_M_get_Node_allocator()) + _M_move_assign(std::move(__list), std::true_type()); + else + // The rvalue's allocator cannot be moved, or is not equal, + // so we need to individually move each element. + this->assign(std::__make_move_if_noexcept_iterator(__list.begin()), + std::__make_move_if_noexcept_iterator(__list.end())); + } + + // Called by assign(_InputIterator, _InputIterator) if _Tp is + // CopyAssignable. + template + void + _M_assign(_InputIterator __first, _InputIterator __last, true_type) + { + auto __prev = before_begin(); + auto __curr = begin(); + auto __end = end(); + while (__curr != __end && __first != __last) + { + *__curr = *__first; + ++__prev; + ++__curr; + ++__first; + } + if (__first != __last) + insert_after(__prev, __first, __last); + else if (__curr != __end) + erase_after(__prev, __end); + } + + // Called by assign(_InputIterator, _InputIterator) if _Tp is not + // CopyAssignable. + template + void + _M_assign(_InputIterator __first, _InputIterator __last, false_type) + { + clear(); + insert_after(cbefore_begin(), __first, __last); + } + + // Called by assign(size_type, const _Tp&) if Tp is CopyAssignable + void + _M_assign_n(size_type __n, const _Tp& __val, true_type) + { + auto __prev = before_begin(); + auto __curr = begin(); + auto __end = end(); + while (__curr != __end && __n > 0) + { + *__curr = __val; + ++__prev; + ++__curr; + --__n; + } + if (__n > 0) + insert_after(__prev, __n, __val); + else if (__curr != __end) + erase_after(__prev, __end); + } + + // Called by assign(size_type, const _Tp&) if Tp is non-CopyAssignable + void + _M_assign_n(size_type __n, const _Tp& __val, false_type) + { + clear(); + insert_after(cbefore_begin(), __n, __val); + } + }; + + /** + * @brief Forward list equality comparison. + * @param __lx A %forward_list + * @param __ly A %forward_list of the same type as @a __lx. + * @return True iff the elements of the forward lists are equal. + * + * This is an equivalence relation. It is linear in the number of + * elements of the forward lists. Deques are considered equivalent + * if corresponding elements compare equal. + */ + template + bool + operator==(const forward_list<_Tp, _Alloc>& __lx, + const forward_list<_Tp, _Alloc>& __ly); + + /** + * @brief Forward list ordering relation. + * @param __lx A %forward_list. + * @param __ly A %forward_list of the same type as @a __lx. + * @return True iff @a __lx is lexicographically less than @a __ly. + * + * This is a total ordering relation. It is linear in the number of + * elements of the forward lists. The elements must be comparable + * with @c <. + * + * See std::lexicographical_compare() for how the determination is made. + */ + template + inline bool + operator<(const forward_list<_Tp, _Alloc>& __lx, + const forward_list<_Tp, _Alloc>& __ly) + { return std::lexicographical_compare(__lx.cbegin(), __lx.cend(), + __ly.cbegin(), __ly.cend()); } + + /// Based on operator== + template + inline bool + operator!=(const forward_list<_Tp, _Alloc>& __lx, + const forward_list<_Tp, _Alloc>& __ly) + { return !(__lx == __ly); } + + /// Based on operator< + template + inline bool + operator>(const forward_list<_Tp, _Alloc>& __lx, + const forward_list<_Tp, _Alloc>& __ly) + { return (__ly < __lx); } + + /// Based on operator< + template + inline bool + operator>=(const forward_list<_Tp, _Alloc>& __lx, + const forward_list<_Tp, _Alloc>& __ly) + { return !(__lx < __ly); } + + /// Based on operator< + template + inline bool + operator<=(const forward_list<_Tp, _Alloc>& __lx, + const forward_list<_Tp, _Alloc>& __ly) + { return !(__ly < __lx); } + + /// See std::forward_list::swap(). + template + inline void + swap(forward_list<_Tp, _Alloc>& __lx, + forward_list<_Tp, _Alloc>& __ly) + { __lx.swap(__ly); } + +_GLIBCXX_END_NAMESPACE_CONTAINER +} // namespace std + +#endif // _FORWARD_LIST_H diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/forward_list.tcc b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/forward_list.tcc new file mode 100755 index 0000000..2d83171 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/forward_list.tcc @@ -0,0 +1,511 @@ +// -*- C++ -*- + +// Copyright (C) 2008-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file bits/forward_list.tcc + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{forward_list} + */ + +#ifndef _FORWARD_LIST_TCC +#define _FORWARD_LIST_TCC 1 + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_CONTAINER + + template + _Fwd_list_base<_Tp, _Alloc>:: + _Fwd_list_base(_Fwd_list_base&& __lst, const _Node_alloc_type& __a) + : _M_impl(__a) + { + if (__lst._M_get_Node_allocator() == __a) + { + this->_M_impl._M_head._M_next = __lst._M_impl._M_head._M_next; + __lst._M_impl._M_head._M_next = 0; + } + else + { + this->_M_impl._M_head._M_next = 0; + _Fwd_list_node_base* __to = &this->_M_impl._M_head; + _Node* __curr = static_cast<_Node*>(__lst._M_impl._M_head._M_next); + + while (__curr) + { + __to->_M_next = + _M_create_node(std::move_if_noexcept(*__curr->_M_valptr())); + __to = __to->_M_next; + __curr = static_cast<_Node*>(__curr->_M_next); + } + } + } + + template + template + _Fwd_list_node_base* + _Fwd_list_base<_Tp, _Alloc>:: + _M_insert_after(const_iterator __pos, _Args&&... __args) + { + _Fwd_list_node_base* __to + = const_cast<_Fwd_list_node_base*>(__pos._M_node); + _Node* __thing = _M_create_node(std::forward<_Args>(__args)...); + __thing->_M_next = __to->_M_next; + __to->_M_next = __thing; + return __to->_M_next; + } + + template + _Fwd_list_node_base* + _Fwd_list_base<_Tp, _Alloc>:: + _M_erase_after(_Fwd_list_node_base* __pos) + { + _Node* __curr = static_cast<_Node*>(__pos->_M_next); + __pos->_M_next = __curr->_M_next; + _Tp_alloc_type __a(_M_get_Node_allocator()); + allocator_traits<_Tp_alloc_type>::destroy(__a, __curr->_M_valptr()); + __curr->~_Node(); + _M_put_node(__curr); + return __pos->_M_next; + } + + template + _Fwd_list_node_base* + _Fwd_list_base<_Tp, _Alloc>:: + _M_erase_after(_Fwd_list_node_base* __pos, + _Fwd_list_node_base* __last) + { + _Node* __curr = static_cast<_Node*>(__pos->_M_next); + while (__curr != __last) + { + _Node* __temp = __curr; + __curr = static_cast<_Node*>(__curr->_M_next); + _Tp_alloc_type __a(_M_get_Node_allocator()); + allocator_traits<_Tp_alloc_type>::destroy(__a, __temp->_M_valptr()); + __temp->~_Node(); + _M_put_node(__temp); + } + __pos->_M_next = __last; + return __last; + } + + // Called by the range constructor to implement [23.3.4.2]/9 + template + template + void + forward_list<_Tp, _Alloc>:: + _M_range_initialize(_InputIterator __first, _InputIterator __last) + { + _Node_base* __to = &this->_M_impl._M_head; + for (; __first != __last; ++__first) + { + __to->_M_next = this->_M_create_node(*__first); + __to = __to->_M_next; + } + } + + // Called by forward_list(n,v,a). + template + void + forward_list<_Tp, _Alloc>:: + _M_fill_initialize(size_type __n, const value_type& __value) + { + _Node_base* __to = &this->_M_impl._M_head; + for (; __n; --__n) + { + __to->_M_next = this->_M_create_node(__value); + __to = __to->_M_next; + } + } + + template + void + forward_list<_Tp, _Alloc>:: + _M_default_initialize(size_type __n) + { + _Node_base* __to = &this->_M_impl._M_head; + for (; __n; --__n) + { + __to->_M_next = this->_M_create_node(); + __to = __to->_M_next; + } + } + + template + forward_list<_Tp, _Alloc>& + forward_list<_Tp, _Alloc>:: + operator=(const forward_list& __list) + { + if (&__list != this) + { + if (_Node_alloc_traits::_S_propagate_on_copy_assign()) + { + auto& __this_alloc = this->_M_get_Node_allocator(); + auto& __that_alloc = __list._M_get_Node_allocator(); + if (!_Node_alloc_traits::_S_always_equal() + && __this_alloc != __that_alloc) + { + // replacement allocator cannot free existing storage + clear(); + } + std::__alloc_on_copy(__this_alloc, __that_alloc); + } + assign(__list.cbegin(), __list.cend()); + } + return *this; + } + + template + void + forward_list<_Tp, _Alloc>:: + _M_default_insert_after(const_iterator __pos, size_type __n) + { + const_iterator __saved_pos = __pos; + __try + { + for (; __n; --__n) + __pos = emplace_after(__pos); + } + __catch(...) + { + erase_after(__saved_pos, ++__pos); + __throw_exception_again; + } + } + + template + void + forward_list<_Tp, _Alloc>:: + resize(size_type __sz) + { + iterator __k = before_begin(); + + size_type __len = 0; + while (__k._M_next() != end() && __len < __sz) + { + ++__k; + ++__len; + } + if (__len == __sz) + erase_after(__k, end()); + else + _M_default_insert_after(__k, __sz - __len); + } + + template + void + forward_list<_Tp, _Alloc>:: + resize(size_type __sz, const value_type& __val) + { + iterator __k = before_begin(); + + size_type __len = 0; + while (__k._M_next() != end() && __len < __sz) + { + ++__k; + ++__len; + } + if (__len == __sz) + erase_after(__k, end()); + else + insert_after(__k, __sz - __len, __val); + } + + template + typename forward_list<_Tp, _Alloc>::iterator + forward_list<_Tp, _Alloc>:: + _M_splice_after(const_iterator __pos, + const_iterator __before, const_iterator __last) + { + _Node_base* __tmp = const_cast<_Node_base*>(__pos._M_node); + _Node_base* __b = const_cast<_Node_base*>(__before._M_node); + _Node_base* __end = __b; + + while (__end && __end->_M_next != __last._M_node) + __end = __end->_M_next; + + if (__b != __end) + return iterator(__tmp->_M_transfer_after(__b, __end)); + else + return iterator(__tmp); + } + + template + void + forward_list<_Tp, _Alloc>:: + splice_after(const_iterator __pos, forward_list&&, + const_iterator __i) + { + const_iterator __j = __i; + ++__j; + + if (__pos == __i || __pos == __j) + return; + + _Node_base* __tmp = const_cast<_Node_base*>(__pos._M_node); + __tmp->_M_transfer_after(const_cast<_Node_base*>(__i._M_node), + const_cast<_Node_base*>(__j._M_node)); + } + + template + typename forward_list<_Tp, _Alloc>::iterator + forward_list<_Tp, _Alloc>:: + insert_after(const_iterator __pos, size_type __n, const _Tp& __val) + { + if (__n) + { + forward_list __tmp(__n, __val, get_allocator()); + return _M_splice_after(__pos, __tmp.before_begin(), __tmp.end()); + } + else + return iterator(const_cast<_Node_base*>(__pos._M_node)); + } + + template + template + typename forward_list<_Tp, _Alloc>::iterator + forward_list<_Tp, _Alloc>:: + insert_after(const_iterator __pos, + _InputIterator __first, _InputIterator __last) + { + forward_list __tmp(__first, __last, get_allocator()); + if (!__tmp.empty()) + return _M_splice_after(__pos, __tmp.before_begin(), __tmp.end()); + else + return iterator(const_cast<_Node_base*>(__pos._M_node)); + } + + template + void + forward_list<_Tp, _Alloc>:: + remove(const _Tp& __val) + { + _Node* __curr = static_cast<_Node*>(&this->_M_impl._M_head); + _Node* __extra = 0; + + while (_Node* __tmp = static_cast<_Node*>(__curr->_M_next)) + { + if (*__tmp->_M_valptr() == __val) + { + if (__tmp->_M_valptr() != std::__addressof(__val)) + { + this->_M_erase_after(__curr); + continue; + } + else + __extra = __curr; + } + __curr = static_cast<_Node*>(__curr->_M_next); + } + + if (__extra) + this->_M_erase_after(__extra); + } + + template + template + void + forward_list<_Tp, _Alloc>:: + remove_if(_Pred __pred) + { + _Node* __curr = static_cast<_Node*>(&this->_M_impl._M_head); + while (_Node* __tmp = static_cast<_Node*>(__curr->_M_next)) + { + if (__pred(*__tmp->_M_valptr())) + this->_M_erase_after(__curr); + else + __curr = static_cast<_Node*>(__curr->_M_next); + } + } + + template + template + void + forward_list<_Tp, _Alloc>:: + unique(_BinPred __binary_pred) + { + iterator __first = begin(); + iterator __last = end(); + if (__first == __last) + return; + iterator __next = __first; + while (++__next != __last) + { + if (__binary_pred(*__first, *__next)) + erase_after(__first); + else + __first = __next; + __next = __first; + } + } + + template + template + void + forward_list<_Tp, _Alloc>:: + merge(forward_list&& __list, _Comp __comp) + { + _Node_base* __node = &this->_M_impl._M_head; + while (__node->_M_next && __list._M_impl._M_head._M_next) + { + if (__comp(*static_cast<_Node*> + (__list._M_impl._M_head._M_next)->_M_valptr(), + *static_cast<_Node*> + (__node->_M_next)->_M_valptr())) + __node->_M_transfer_after(&__list._M_impl._M_head, + __list._M_impl._M_head._M_next); + __node = __node->_M_next; + } + if (__list._M_impl._M_head._M_next) + { + __node->_M_next = __list._M_impl._M_head._M_next; + __list._M_impl._M_head._M_next = 0; + } + } + + template + bool + operator==(const forward_list<_Tp, _Alloc>& __lx, + const forward_list<_Tp, _Alloc>& __ly) + { + // We don't have size() so we need to walk through both lists + // making sure both iterators are valid. + auto __ix = __lx.cbegin(); + auto __iy = __ly.cbegin(); + while (__ix != __lx.cend() && __iy != __ly.cend()) + { + if (*__ix != *__iy) + return false; + ++__ix; + ++__iy; + } + if (__ix == __lx.cend() && __iy == __ly.cend()) + return true; + else + return false; + } + + template + template + void + forward_list<_Tp, _Alloc>:: + sort(_Comp __comp) + { + // If `next' is 0, return immediately. + _Node* __list = static_cast<_Node*>(this->_M_impl._M_head._M_next); + if (!__list) + return; + + unsigned long __insize = 1; + + while (1) + { + _Node* __p = __list; + __list = 0; + _Node* __tail = 0; + + // Count number of merges we do in this pass. + unsigned long __nmerges = 0; + + while (__p) + { + ++__nmerges; + // There exists a merge to be done. + // Step `insize' places along from p. + _Node* __q = __p; + unsigned long __psize = 0; + for (unsigned long __i = 0; __i < __insize; ++__i) + { + ++__psize; + __q = static_cast<_Node*>(__q->_M_next); + if (!__q) + break; + } + + // If q hasn't fallen off end, we have two lists to merge. + unsigned long __qsize = __insize; + + // Now we have two lists; merge them. + while (__psize > 0 || (__qsize > 0 && __q)) + { + // Decide whether next node of merge comes from p or q. + _Node* __e; + if (__psize == 0) + { + // p is empty; e must come from q. + __e = __q; + __q = static_cast<_Node*>(__q->_M_next); + --__qsize; + } + else if (__qsize == 0 || !__q) + { + // q is empty; e must come from p. + __e = __p; + __p = static_cast<_Node*>(__p->_M_next); + --__psize; + } + else if (__comp(*__p->_M_valptr(), *__q->_M_valptr())) + { + // First node of p is lower; e must come from p. + __e = __p; + __p = static_cast<_Node*>(__p->_M_next); + --__psize; + } + else + { + // First node of q is lower; e must come from q. + __e = __q; + __q = static_cast<_Node*>(__q->_M_next); + --__qsize; + } + + // Add the next node to the merged list. + if (__tail) + __tail->_M_next = __e; + else + __list = __e; + __tail = __e; + } + + // Now p has stepped `insize' places along, and q has too. + __p = __q; + } + __tail->_M_next = 0; + + // If we have done only one merge, we're finished. + // Allow for nmerges == 0, the empty list case. + if (__nmerges <= 1) + { + this->_M_impl._M_head._M_next = __list; + return; + } + + // Otherwise repeat, merging lists twice the size. + __insize *= 2; + } + } + +_GLIBCXX_END_NAMESPACE_CONTAINER +} // namespace std + +#endif /* _FORWARD_LIST_TCC */ + diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/fstream.tcc b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/fstream.tcc new file mode 100755 index 0000000..21a67cd --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/fstream.tcc @@ -0,0 +1,984 @@ +// File based streams -*- C++ -*- + +// Copyright (C) 1997-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file bits/fstream.tcc + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{fstream} + */ + +// +// ISO C++ 14882: 27.8 File-based streams +// + +#ifndef _FSTREAM_TCC +#define _FSTREAM_TCC 1 + +#pragma GCC system_header + +#include + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + template + void + basic_filebuf<_CharT, _Traits>:: + _M_allocate_internal_buffer() + { + // Allocate internal buffer only if one doesn't already exist + // (either allocated or provided by the user via setbuf). + if (!_M_buf_allocated && !_M_buf) + { + _M_buf = new char_type[_M_buf_size]; + _M_buf_allocated = true; + } + } + + template + void + basic_filebuf<_CharT, _Traits>:: + _M_destroy_internal_buffer() throw() + { + if (_M_buf_allocated) + { + delete [] _M_buf; + _M_buf = 0; + _M_buf_allocated = false; + } + delete [] _M_ext_buf; + _M_ext_buf = 0; + _M_ext_buf_size = 0; + _M_ext_next = 0; + _M_ext_end = 0; + } + + template + basic_filebuf<_CharT, _Traits>:: + basic_filebuf() : __streambuf_type(), _M_lock(), _M_file(&_M_lock), + _M_mode(ios_base::openmode(0)), _M_state_beg(), _M_state_cur(), + _M_state_last(), _M_buf(0), _M_buf_size(BUFSIZ), + _M_buf_allocated(false), _M_reading(false), _M_writing(false), _M_pback(), + _M_pback_cur_save(0), _M_pback_end_save(0), _M_pback_init(false), + _M_codecvt(0), _M_ext_buf(0), _M_ext_buf_size(0), _M_ext_next(0), + _M_ext_end(0) + { + if (has_facet<__codecvt_type>(this->_M_buf_locale)) + _M_codecvt = &use_facet<__codecvt_type>(this->_M_buf_locale); + } + + template + typename basic_filebuf<_CharT, _Traits>::__filebuf_type* + basic_filebuf<_CharT, _Traits>:: + open(const char* __s, ios_base::openmode __mode) + { + __filebuf_type *__ret = 0; + if (!this->is_open()) + { + _M_file.open(__s, __mode); + if (this->is_open()) + { + _M_allocate_internal_buffer(); + _M_mode = __mode; + + // Setup initial buffer to 'uncommitted' mode. + _M_reading = false; + _M_writing = false; + _M_set_buffer(-1); + + // Reset to initial state. + _M_state_last = _M_state_cur = _M_state_beg; + + // 27.8.1.3,4 + if ((__mode & ios_base::ate) + && this->seekoff(0, ios_base::end, __mode) + == pos_type(off_type(-1))) + this->close(); + else + __ret = this; + } + } + return __ret; + } + + template + typename basic_filebuf<_CharT, _Traits>::__filebuf_type* + basic_filebuf<_CharT, _Traits>:: + close() + { + if (!this->is_open()) + return 0; + + bool __testfail = false; + { + // NB: Do this here so that re-opened filebufs will be cool... + struct __close_sentry + { + basic_filebuf *__fb; + __close_sentry (basic_filebuf *__fbi): __fb(__fbi) { } + ~__close_sentry () + { + __fb->_M_mode = ios_base::openmode(0); + __fb->_M_pback_init = false; + __fb->_M_destroy_internal_buffer(); + __fb->_M_reading = false; + __fb->_M_writing = false; + __fb->_M_set_buffer(-1); + __fb->_M_state_last = __fb->_M_state_cur = __fb->_M_state_beg; + } + } __cs (this); + + __try + { + if (!_M_terminate_output()) + __testfail = true; + } + __catch(__cxxabiv1::__forced_unwind&) + { + _M_file.close(); + __throw_exception_again; + } + __catch(...) + { __testfail = true; } + } + + if (!_M_file.close()) + __testfail = true; + + if (__testfail) + return 0; + else + return this; + } + + template + streamsize + basic_filebuf<_CharT, _Traits>:: + showmanyc() + { + streamsize __ret = -1; + const bool __testin = _M_mode & ios_base::in; + if (__testin && this->is_open()) + { + // For a stateful encoding (-1) the pending sequence might be just + // shift and unshift prefixes with no actual character. + __ret = this->egptr() - this->gptr(); + +#if _GLIBCXX_HAVE_DOS_BASED_FILESYSTEM + // About this workaround, see libstdc++/20806. + const bool __testbinary = _M_mode & ios_base::binary; + if (__check_facet(_M_codecvt).encoding() >= 0 + && __testbinary) +#else + if (__check_facet(_M_codecvt).encoding() >= 0) +#endif + __ret += _M_file.showmanyc() / _M_codecvt->max_length(); + } + return __ret; + } + + template + typename basic_filebuf<_CharT, _Traits>::int_type + basic_filebuf<_CharT, _Traits>:: + underflow() + { + int_type __ret = traits_type::eof(); + const bool __testin = _M_mode & ios_base::in; + if (__testin) + { + if (_M_writing) + { + if (overflow() == traits_type::eof()) + return __ret; + _M_set_buffer(-1); + _M_writing = false; + } + // Check for pback madness, and if so switch back to the + // normal buffers and jet outta here before expensive + // fileops happen... + _M_destroy_pback(); + + if (this->gptr() < this->egptr()) + return traits_type::to_int_type(*this->gptr()); + + // Get and convert input sequence. + const size_t __buflen = _M_buf_size > 1 ? _M_buf_size - 1 : 1; + + // Will be set to true if ::read() returns 0 indicating EOF. + bool __got_eof = false; + // Number of internal characters produced. + streamsize __ilen = 0; + codecvt_base::result __r = codecvt_base::ok; + if (__check_facet(_M_codecvt).always_noconv()) + { + __ilen = _M_file.xsgetn(reinterpret_cast(this->eback()), + __buflen); + if (__ilen == 0) + __got_eof = true; + } + else + { + // Worst-case number of external bytes. + // XXX Not done encoding() == -1. + const int __enc = _M_codecvt->encoding(); + streamsize __blen; // Minimum buffer size. + streamsize __rlen; // Number of chars to read. + if (__enc > 0) + __blen = __rlen = __buflen * __enc; + else + { + __blen = __buflen + _M_codecvt->max_length() - 1; + __rlen = __buflen; + } + const streamsize __remainder = _M_ext_end - _M_ext_next; + __rlen = __rlen > __remainder ? __rlen - __remainder : 0; + + // An imbue in 'read' mode implies first converting the external + // chars already present. + if (_M_reading && this->egptr() == this->eback() && __remainder) + __rlen = 0; + + // Allocate buffer if necessary and move unconverted + // bytes to front. + if (_M_ext_buf_size < __blen) + { + char* __buf = new char[__blen]; + if (__remainder) + __builtin_memcpy(__buf, _M_ext_next, __remainder); + + delete [] _M_ext_buf; + _M_ext_buf = __buf; + _M_ext_buf_size = __blen; + } + else if (__remainder) + __builtin_memmove(_M_ext_buf, _M_ext_next, __remainder); + + _M_ext_next = _M_ext_buf; + _M_ext_end = _M_ext_buf + __remainder; + _M_state_last = _M_state_cur; + + do + { + if (__rlen > 0) + { + // Sanity check! + // This may fail if the return value of + // codecvt::max_length() is bogus. + if (_M_ext_end - _M_ext_buf + __rlen > _M_ext_buf_size) + { + __throw_ios_failure(__N("basic_filebuf::underflow " + "codecvt::max_length() " + "is not valid")); + } + streamsize __elen = _M_file.xsgetn(_M_ext_end, __rlen); + if (__elen == 0) + __got_eof = true; + else if (__elen == -1) + break; + _M_ext_end += __elen; + } + + char_type* __iend = this->eback(); + if (_M_ext_next < _M_ext_end) + __r = _M_codecvt->in(_M_state_cur, _M_ext_next, + _M_ext_end, _M_ext_next, + this->eback(), + this->eback() + __buflen, __iend); + if (__r == codecvt_base::noconv) + { + size_t __avail = _M_ext_end - _M_ext_buf; + __ilen = std::min(__avail, __buflen); + traits_type::copy(this->eback(), + reinterpret_cast + (_M_ext_buf), __ilen); + _M_ext_next = _M_ext_buf + __ilen; + } + else + __ilen = __iend - this->eback(); + + // _M_codecvt->in may return error while __ilen > 0: this is + // ok, and actually occurs in case of mixed encodings (e.g., + // XML files). + if (__r == codecvt_base::error) + break; + + __rlen = 1; + } + while (__ilen == 0 && !__got_eof); + } + + if (__ilen > 0) + { + _M_set_buffer(__ilen); + _M_reading = true; + __ret = traits_type::to_int_type(*this->gptr()); + } + else if (__got_eof) + { + // If the actual end of file is reached, set 'uncommitted' + // mode, thus allowing an immediate write without an + // intervening seek. + _M_set_buffer(-1); + _M_reading = false; + // However, reaching it while looping on partial means that + // the file has got an incomplete character. + if (__r == codecvt_base::partial) + __throw_ios_failure(__N("basic_filebuf::underflow " + "incomplete character in file")); + } + else if (__r == codecvt_base::error) + __throw_ios_failure(__N("basic_filebuf::underflow " + "invalid byte sequence in file")); + else + __throw_ios_failure(__N("basic_filebuf::underflow " + "error reading the file")); + } + return __ret; + } + + template + typename basic_filebuf<_CharT, _Traits>::int_type + basic_filebuf<_CharT, _Traits>:: + pbackfail(int_type __i) + { + int_type __ret = traits_type::eof(); + const bool __testin = _M_mode & ios_base::in; + if (__testin) + { + if (_M_writing) + { + if (overflow() == traits_type::eof()) + return __ret; + _M_set_buffer(-1); + _M_writing = false; + } + // Remember whether the pback buffer is active, otherwise below + // we may try to store in it a second char (libstdc++/9761). + const bool __testpb = _M_pback_init; + const bool __testeof = traits_type::eq_int_type(__i, __ret); + int_type __tmp; + if (this->eback() < this->gptr()) + { + this->gbump(-1); + __tmp = traits_type::to_int_type(*this->gptr()); + } + else if (this->seekoff(-1, ios_base::cur) != pos_type(off_type(-1))) + { + __tmp = this->underflow(); + if (traits_type::eq_int_type(__tmp, __ret)) + return __ret; + } + else + { + // At the beginning of the buffer, need to make a + // putback position available. But the seek may fail + // (f.i., at the beginning of a file, see + // libstdc++/9439) and in that case we return + // traits_type::eof(). + return __ret; + } + + // Try to put back __i into input sequence in one of three ways. + // Order these tests done in is unspecified by the standard. + if (!__testeof && traits_type::eq_int_type(__i, __tmp)) + __ret = __i; + else if (__testeof) + __ret = traits_type::not_eof(__i); + else if (!__testpb) + { + _M_create_pback(); + _M_reading = true; + *this->gptr() = traits_type::to_char_type(__i); + __ret = __i; + } + } + return __ret; + } + + template + typename basic_filebuf<_CharT, _Traits>::int_type + basic_filebuf<_CharT, _Traits>:: + overflow(int_type __c) + { + int_type __ret = traits_type::eof(); + const bool __testeof = traits_type::eq_int_type(__c, __ret); + const bool __testout = (_M_mode & ios_base::out + || _M_mode & ios_base::app); + if (__testout) + { + if (_M_reading) + { + _M_destroy_pback(); + const int __gptr_off = _M_get_ext_pos(_M_state_last); + if (_M_seek(__gptr_off, ios_base::cur, _M_state_last) + == pos_type(off_type(-1))) + return __ret; + } + if (this->pbase() < this->pptr()) + { + // If appropriate, append the overflow char. + if (!__testeof) + { + *this->pptr() = traits_type::to_char_type(__c); + this->pbump(1); + } + + // Convert pending sequence to external representation, + // and output. + if (_M_convert_to_external(this->pbase(), + this->pptr() - this->pbase())) + { + _M_set_buffer(0); + __ret = traits_type::not_eof(__c); + } + } + else if (_M_buf_size > 1) + { + // Overflow in 'uncommitted' mode: set _M_writing, set + // the buffer to the initial 'write' mode, and put __c + // into the buffer. + _M_set_buffer(0); + _M_writing = true; + if (!__testeof) + { + *this->pptr() = traits_type::to_char_type(__c); + this->pbump(1); + } + __ret = traits_type::not_eof(__c); + } + else + { + // Unbuffered. + char_type __conv = traits_type::to_char_type(__c); + if (__testeof || _M_convert_to_external(&__conv, 1)) + { + _M_writing = true; + __ret = traits_type::not_eof(__c); + } + } + } + return __ret; + } + + template + bool + basic_filebuf<_CharT, _Traits>:: + _M_convert_to_external(_CharT* __ibuf, streamsize __ilen) + { + // Sizes of external and pending output. + streamsize __elen; + streamsize __plen; + if (__check_facet(_M_codecvt).always_noconv()) + { + __elen = _M_file.xsputn(reinterpret_cast(__ibuf), __ilen); + __plen = __ilen; + } + else + { + // Worst-case number of external bytes needed. + // XXX Not done encoding() == -1. + streamsize __blen = __ilen * _M_codecvt->max_length(); + char* __buf = static_cast(__builtin_alloca(__blen)); + + char* __bend; + const char_type* __iend; + codecvt_base::result __r; + __r = _M_codecvt->out(_M_state_cur, __ibuf, __ibuf + __ilen, + __iend, __buf, __buf + __blen, __bend); + + if (__r == codecvt_base::ok || __r == codecvt_base::partial) + __blen = __bend - __buf; + else if (__r == codecvt_base::noconv) + { + // Same as the always_noconv case above. + __buf = reinterpret_cast(__ibuf); + __blen = __ilen; + } + else + __throw_ios_failure(__N("basic_filebuf::_M_convert_to_external " + "conversion error")); + + __elen = _M_file.xsputn(__buf, __blen); + __plen = __blen; + + // Try once more for partial conversions. + if (__r == codecvt_base::partial && __elen == __plen) + { + const char_type* __iresume = __iend; + streamsize __rlen = this->pptr() - __iend; + __r = _M_codecvt->out(_M_state_cur, __iresume, + __iresume + __rlen, __iend, __buf, + __buf + __blen, __bend); + if (__r != codecvt_base::error) + { + __rlen = __bend - __buf; + __elen = _M_file.xsputn(__buf, __rlen); + __plen = __rlen; + } + else + __throw_ios_failure(__N("basic_filebuf::_M_convert_to_external " + "conversion error")); + } + } + return __elen == __plen; + } + + template + streamsize + basic_filebuf<_CharT, _Traits>:: + xsgetn(_CharT* __s, streamsize __n) + { + // Clear out pback buffer before going on to the real deal... + streamsize __ret = 0; + if (_M_pback_init) + { + if (__n > 0 && this->gptr() == this->eback()) + { + *__s++ = *this->gptr(); // emulate non-underflowing sbumpc + this->gbump(1); + __ret = 1; + --__n; + } + _M_destroy_pback(); + } + else if (_M_writing) + { + if (overflow() == traits_type::eof()) + return __ret; + _M_set_buffer(-1); + _M_writing = false; + } + + // Optimization in the always_noconv() case, to be generalized in the + // future: when __n > __buflen we read directly instead of using the + // buffer repeatedly. + const bool __testin = _M_mode & ios_base::in; + const streamsize __buflen = _M_buf_size > 1 ? _M_buf_size - 1 : 1; + + if (__n > __buflen && __check_facet(_M_codecvt).always_noconv() + && __testin) + { + // First, copy the chars already present in the buffer. + const streamsize __avail = this->egptr() - this->gptr(); + if (__avail != 0) + { + traits_type::copy(__s, this->gptr(), __avail); + __s += __avail; + this->setg(this->eback(), this->gptr() + __avail, + this->egptr()); + __ret += __avail; + __n -= __avail; + } + + // Need to loop in case of short reads (relatively common + // with pipes). + streamsize __len; + for (;;) + { + __len = _M_file.xsgetn(reinterpret_cast(__s), + __n); + if (__len == -1) + __throw_ios_failure(__N("basic_filebuf::xsgetn " + "error reading the file")); + if (__len == 0) + break; + + __n -= __len; + __ret += __len; + if (__n == 0) + break; + + __s += __len; + } + + if (__n == 0) + { + _M_set_buffer(0); + _M_reading = true; + } + else if (__len == 0) + { + // If end of file is reached, set 'uncommitted' + // mode, thus allowing an immediate write without + // an intervening seek. + _M_set_buffer(-1); + _M_reading = false; + } + } + else + __ret += __streambuf_type::xsgetn(__s, __n); + + return __ret; + } + + template + streamsize + basic_filebuf<_CharT, _Traits>:: + xsputn(const _CharT* __s, streamsize __n) + { + streamsize __ret = 0; + // Optimization in the always_noconv() case, to be generalized in the + // future: when __n is sufficiently large we write directly instead of + // using the buffer. + const bool __testout = (_M_mode & ios_base::out + || _M_mode & ios_base::app); + if (__check_facet(_M_codecvt).always_noconv() + && __testout && !_M_reading) + { + // Measurement would reveal the best choice. + const streamsize __chunk = 1ul << 10; + streamsize __bufavail = this->epptr() - this->pptr(); + + // Don't mistake 'uncommitted' mode buffered with unbuffered. + if (!_M_writing && _M_buf_size > 1) + __bufavail = _M_buf_size - 1; + + const streamsize __limit = std::min(__chunk, __bufavail); + if (__n >= __limit) + { + const streamsize __buffill = this->pptr() - this->pbase(); + const char* __buf = reinterpret_cast(this->pbase()); + __ret = _M_file.xsputn_2(__buf, __buffill, + reinterpret_cast(__s), + __n); + if (__ret == __buffill + __n) + { + _M_set_buffer(0); + _M_writing = true; + } + if (__ret > __buffill) + __ret -= __buffill; + else + __ret = 0; + } + else + __ret = __streambuf_type::xsputn(__s, __n); + } + else + __ret = __streambuf_type::xsputn(__s, __n); + return __ret; + } + + template + typename basic_filebuf<_CharT, _Traits>::__streambuf_type* + basic_filebuf<_CharT, _Traits>:: + setbuf(char_type* __s, streamsize __n) + { + if (!this->is_open()) + { + if (__s == 0 && __n == 0) + _M_buf_size = 1; + else if (__s && __n > 0) + { + // This is implementation-defined behavior, and assumes that + // an external char_type array of length __n exists and has + // been pre-allocated. If this is not the case, things will + // quickly blow up. When __n > 1, __n - 1 positions will be + // used for the get area, __n - 1 for the put area and 1 + // position to host the overflow char of a full put area. + // When __n == 1, 1 position will be used for the get area + // and 0 for the put area, as in the unbuffered case above. + _M_buf = __s; + _M_buf_size = __n; + } + } + return this; + } + + + // According to 27.8.1.4 p11 - 13, seekoff should ignore the last + // argument (of type openmode). + template + typename basic_filebuf<_CharT, _Traits>::pos_type + basic_filebuf<_CharT, _Traits>:: + seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode) + { + int __width = 0; + if (_M_codecvt) + __width = _M_codecvt->encoding(); + if (__width < 0) + __width = 0; + + pos_type __ret = pos_type(off_type(-1)); + const bool __testfail = __off != 0 && __width <= 0; + if (this->is_open() && !__testfail) + { + // tellg and tellp queries do not affect any state, unless + // ! always_noconv and the put sequence is not empty. + // In that case, determining the position requires converting the + // put sequence. That doesn't use ext_buf, so requires a flush. + bool __no_movement = __way == ios_base::cur && __off == 0 + && (!_M_writing || _M_codecvt->always_noconv()); + + // Ditch any pback buffers to avoid confusion. + if (!__no_movement) + _M_destroy_pback(); + + // Correct state at destination. Note that this is the correct + // state for the current position during output, because + // codecvt::unshift() returns the state to the initial state. + // This is also the correct state at the end of the file because + // an unshift sequence should have been written at the end. + __state_type __state = _M_state_beg; + off_type __computed_off = __off * __width; + if (_M_reading && __way == ios_base::cur) + { + __state = _M_state_last; + __computed_off += _M_get_ext_pos(__state); + } + if (!__no_movement) + __ret = _M_seek(__computed_off, __way, __state); + else + { + if (_M_writing) + __computed_off = this->pptr() - this->pbase(); + + off_type __file_off = _M_file.seekoff(0, ios_base::cur); + if (__file_off != off_type(-1)) + { + __ret = __file_off + __computed_off; + __ret.state(__state); + } + } + } + return __ret; + } + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 171. Strange seekpos() semantics due to joint position + // According to the resolution of DR 171, seekpos should ignore the last + // argument (of type openmode). + template + typename basic_filebuf<_CharT, _Traits>::pos_type + basic_filebuf<_CharT, _Traits>:: + seekpos(pos_type __pos, ios_base::openmode) + { + pos_type __ret = pos_type(off_type(-1)); + if (this->is_open()) + { + // Ditch any pback buffers to avoid confusion. + _M_destroy_pback(); + __ret = _M_seek(off_type(__pos), ios_base::beg, __pos.state()); + } + return __ret; + } + + template + typename basic_filebuf<_CharT, _Traits>::pos_type + basic_filebuf<_CharT, _Traits>:: + _M_seek(off_type __off, ios_base::seekdir __way, __state_type __state) + { + pos_type __ret = pos_type(off_type(-1)); + if (_M_terminate_output()) + { + off_type __file_off = _M_file.seekoff(__off, __way); + if (__file_off != off_type(-1)) + { + _M_reading = false; + _M_writing = false; + _M_ext_next = _M_ext_end = _M_ext_buf; + _M_set_buffer(-1); + _M_state_cur = __state; + __ret = __file_off; + __ret.state(_M_state_cur); + } + } + return __ret; + } + + // Returns the distance from the end of the ext buffer to the point + // corresponding to gptr(). This is a negative value. Updates __state + // from eback() correspondence to gptr(). + template + int basic_filebuf<_CharT, _Traits>:: + _M_get_ext_pos(__state_type& __state) + { + if (_M_codecvt->always_noconv()) + return this->gptr() - this->egptr(); + else + { + // Calculate offset from _M_ext_buf that corresponds to + // gptr(). Precondition: __state == _M_state_last, which + // corresponds to eback(). + const int __gptr_off = + _M_codecvt->length(__state, _M_ext_buf, _M_ext_next, + this->gptr() - this->eback()); + return _M_ext_buf + __gptr_off - _M_ext_end; + } + } + + template + bool + basic_filebuf<_CharT, _Traits>:: + _M_terminate_output() + { + // Part one: update the output sequence. + bool __testvalid = true; + if (this->pbase() < this->pptr()) + { + const int_type __tmp = this->overflow(); + if (traits_type::eq_int_type(__tmp, traits_type::eof())) + __testvalid = false; + } + + // Part two: output unshift sequence. + if (_M_writing && !__check_facet(_M_codecvt).always_noconv() + && __testvalid) + { + // Note: this value is arbitrary, since there is no way to + // get the length of the unshift sequence from codecvt, + // without calling unshift. + const size_t __blen = 128; + char __buf[__blen]; + codecvt_base::result __r; + streamsize __ilen = 0; + + do + { + char* __next; + __r = _M_codecvt->unshift(_M_state_cur, __buf, + __buf + __blen, __next); + if (__r == codecvt_base::error) + __testvalid = false; + else if (__r == codecvt_base::ok || + __r == codecvt_base::partial) + { + __ilen = __next - __buf; + if (__ilen > 0) + { + const streamsize __elen = _M_file.xsputn(__buf, __ilen); + if (__elen != __ilen) + __testvalid = false; + } + } + } + while (__r == codecvt_base::partial && __ilen > 0 && __testvalid); + + if (__testvalid) + { + // This second call to overflow() is required by the standard, + // but it's not clear why it's needed, since the output buffer + // should be empty by this point (it should have been emptied + // in the first call to overflow()). + const int_type __tmp = this->overflow(); + if (traits_type::eq_int_type(__tmp, traits_type::eof())) + __testvalid = false; + } + } + return __testvalid; + } + + template + int + basic_filebuf<_CharT, _Traits>:: + sync() + { + // Make sure that the internal buffer resyncs its idea of + // the file position with the external file. + int __ret = 0; + if (this->pbase() < this->pptr()) + { + const int_type __tmp = this->overflow(); + if (traits_type::eq_int_type(__tmp, traits_type::eof())) + __ret = -1; + } + return __ret; + } + + template + void + basic_filebuf<_CharT, _Traits>:: + imbue(const locale& __loc) + { + bool __testvalid = true; + + const __codecvt_type* _M_codecvt_tmp = 0; + if (__builtin_expect(has_facet<__codecvt_type>(__loc), true)) + _M_codecvt_tmp = &use_facet<__codecvt_type>(__loc); + + if (this->is_open()) + { + // encoding() == -1 is ok only at the beginning. + if ((_M_reading || _M_writing) + && __check_facet(_M_codecvt).encoding() == -1) + __testvalid = false; + else + { + if (_M_reading) + { + if (__check_facet(_M_codecvt).always_noconv()) + { + if (_M_codecvt_tmp + && !__check_facet(_M_codecvt_tmp).always_noconv()) + __testvalid = this->seekoff(0, ios_base::cur, _M_mode) + != pos_type(off_type(-1)); + } + else + { + // External position corresponding to gptr(). + _M_ext_next = _M_ext_buf + + _M_codecvt->length(_M_state_last, _M_ext_buf, + _M_ext_next, + this->gptr() - this->eback()); + const streamsize __remainder = _M_ext_end - _M_ext_next; + if (__remainder) + __builtin_memmove(_M_ext_buf, _M_ext_next, __remainder); + + _M_ext_next = _M_ext_buf; + _M_ext_end = _M_ext_buf + __remainder; + _M_set_buffer(-1); + _M_state_last = _M_state_cur = _M_state_beg; + } + } + else if (_M_writing && (__testvalid = _M_terminate_output())) + _M_set_buffer(-1); + } + } + + if (__testvalid) + _M_codecvt = _M_codecvt_tmp; + else + _M_codecvt = 0; + } + + // Inhibit implicit instantiations for required instantiations, + // which are defined via explicit instantiations elsewhere. +#if _GLIBCXX_EXTERN_TEMPLATE + extern template class basic_filebuf; + extern template class basic_ifstream; + extern template class basic_ofstream; + extern template class basic_fstream; + +#ifdef _GLIBCXX_USE_WCHAR_T + extern template class basic_filebuf; + extern template class basic_ifstream; + extern template class basic_ofstream; + extern template class basic_fstream; +#endif +#endif + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace std + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/functexcept.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/functexcept.h new file mode 100755 index 0000000..b8359f9 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/functexcept.h @@ -0,0 +1,110 @@ +// Function-Based Exception Support -*- C++ -*- + +// Copyright (C) 2001-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file bits/functexcept.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{exception} + * + * This header provides support for -fno-exceptions. + */ + +// +// ISO C++ 14882: 19.1 Exception classes +// + +#ifndef _FUNCTEXCEPT_H +#define _FUNCTEXCEPT_H 1 + +#include +#include + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + // Helper for exception objects in + void + __throw_bad_exception(void) __attribute__((__noreturn__)); + + // Helper for exception objects in + void + __throw_bad_alloc(void) __attribute__((__noreturn__)); + + // Helper for exception objects in + void + __throw_bad_cast(void) __attribute__((__noreturn__)); + + void + __throw_bad_typeid(void) __attribute__((__noreturn__)); + + // Helpers for exception objects in + void + __throw_logic_error(const char*) __attribute__((__noreturn__)); + + void + __throw_domain_error(const char*) __attribute__((__noreturn__)); + + void + __throw_invalid_argument(const char*) __attribute__((__noreturn__)); + + void + __throw_length_error(const char*) __attribute__((__noreturn__)); + + void + __throw_out_of_range(const char*) __attribute__((__noreturn__)); + + void + __throw_out_of_range_fmt(const char*, ...) __attribute__((__noreturn__)) + __attribute__((__format__(__printf__, 1, 2))); + + void + __throw_runtime_error(const char*) __attribute__((__noreturn__)); + + void + __throw_range_error(const char*) __attribute__((__noreturn__)); + + void + __throw_overflow_error(const char*) __attribute__((__noreturn__)); + + void + __throw_underflow_error(const char*) __attribute__((__noreturn__)); + + // Helpers for exception objects in + void + __throw_ios_failure(const char*) __attribute__((__noreturn__)); + + void + __throw_system_error(int) __attribute__((__noreturn__)); + + void + __throw_future_error(int) __attribute__((__noreturn__)); + + // Helpers for exception objects in + void + __throw_bad_function_call() __attribute__((__noreturn__)); + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/functional_hash.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/functional_hash.h new file mode 100755 index 0000000..d46e0a3 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/functional_hash.h @@ -0,0 +1,212 @@ +// functional_hash.h header -*- C++ -*- + +// Copyright (C) 2007-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file bits/functional_hash.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{functional} + */ + +#ifndef _FUNCTIONAL_HASH_H +#define _FUNCTIONAL_HASH_H 1 + +#pragma GCC system_header + +#include + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /** @defgroup hashes Hashes + * @ingroup functors + * + * Hashing functors taking a variable type and returning a @c std::size_t. + * + * @{ + */ + + template + struct __hash_base + { + typedef _Result result_type; + typedef _Arg argument_type; + }; + + /// Primary class template hash. + template + struct hash; + + /// Partial specializations for pointer types. + template + struct hash<_Tp*> : public __hash_base + { + size_t + operator()(_Tp* __p) const noexcept + { return reinterpret_cast(__p); } + }; + + // Explicit specializations for integer types. +#define _Cxx_hashtable_define_trivial_hash(_Tp) \ + template<> \ + struct hash<_Tp> : public __hash_base \ + { \ + size_t \ + operator()(_Tp __val) const noexcept \ + { return static_cast(__val); } \ + }; + + /// Explicit specialization for bool. + _Cxx_hashtable_define_trivial_hash(bool) + + /// Explicit specialization for char. + _Cxx_hashtable_define_trivial_hash(char) + + /// Explicit specialization for signed char. + _Cxx_hashtable_define_trivial_hash(signed char) + + /// Explicit specialization for unsigned char. + _Cxx_hashtable_define_trivial_hash(unsigned char) + + /// Explicit specialization for wchar_t. + _Cxx_hashtable_define_trivial_hash(wchar_t) + + /// Explicit specialization for char16_t. + _Cxx_hashtable_define_trivial_hash(char16_t) + + /// Explicit specialization for char32_t. + _Cxx_hashtable_define_trivial_hash(char32_t) + + /// Explicit specialization for short. + _Cxx_hashtable_define_trivial_hash(short) + + /// Explicit specialization for int. + _Cxx_hashtable_define_trivial_hash(int) + + /// Explicit specialization for long. + _Cxx_hashtable_define_trivial_hash(long) + + /// Explicit specialization for long long. + _Cxx_hashtable_define_trivial_hash(long long) + + /// Explicit specialization for unsigned short. + _Cxx_hashtable_define_trivial_hash(unsigned short) + + /// Explicit specialization for unsigned int. + _Cxx_hashtable_define_trivial_hash(unsigned int) + + /// Explicit specialization for unsigned long. + _Cxx_hashtable_define_trivial_hash(unsigned long) + + /// Explicit specialization for unsigned long long. + _Cxx_hashtable_define_trivial_hash(unsigned long long) + +#undef _Cxx_hashtable_define_trivial_hash + + struct _Hash_impl + { + static size_t + hash(const void* __ptr, size_t __clength, + size_t __seed = static_cast(0xc70f6907UL)) + { return _Hash_bytes(__ptr, __clength, __seed); } + + template + static size_t + hash(const _Tp& __val) + { return hash(&__val, sizeof(__val)); } + + template + static size_t + __hash_combine(const _Tp& __val, size_t __hash) + { return hash(&__val, sizeof(__val), __hash); } + }; + + struct _Fnv_hash_impl + { + static size_t + hash(const void* __ptr, size_t __clength, + size_t __seed = static_cast(2166136261UL)) + { return _Fnv_hash_bytes(__ptr, __clength, __seed); } + + template + static size_t + hash(const _Tp& __val) + { return hash(&__val, sizeof(__val)); } + + template + static size_t + __hash_combine(const _Tp& __val, size_t __hash) + { return hash(&__val, sizeof(__val), __hash); } + }; + + /// Specialization for float. + template<> + struct hash : public __hash_base + { + size_t + operator()(float __val) const noexcept + { + // 0 and -0 both hash to zero. + return __val != 0.0f ? std::_Hash_impl::hash(__val) : 0; + } + }; + + /// Specialization for double. + template<> + struct hash : public __hash_base + { + size_t + operator()(double __val) const noexcept + { + // 0 and -0 both hash to zero. + return __val != 0.0 ? std::_Hash_impl::hash(__val) : 0; + } + }; + + /// Specialization for long double. + template<> + struct hash + : public __hash_base + { + _GLIBCXX_PURE size_t + operator()(long double __val) const noexcept; + }; + + // @} group hashes + + // Hint about performance of hash functor. If not fast the hash based + // containers will cache the hash code. + // Default behavior is to consider that hasher are fast unless specified + // otherwise. + template + struct __is_fast_hash : public std::true_type + { }; + + template<> + struct __is_fast_hash> : public std::false_type + { }; + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif // _FUNCTIONAL_HASH_H diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/gslice.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/gslice.h new file mode 100755 index 0000000..8e8ff2f --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/gslice.h @@ -0,0 +1,185 @@ +// The template and inlines for the -*- C++ -*- gslice class. + +// Copyright (C) 1997-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file bits/gslice.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{valarray} + */ + +// Written by Gabriel Dos Reis + +#ifndef _GSLICE_H +#define _GSLICE_H 1 + +#pragma GCC system_header + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /** + * @addtogroup numeric_arrays + * @{ + */ + + /** + * @brief Class defining multi-dimensional subset of an array. + * + * The slice class represents a multi-dimensional subset of an array, + * specified by three parameter sets: start offset, size array, and stride + * array. The start offset is the index of the first element of the array + * that is part of the subset. The size and stride array describe each + * dimension of the slice. Size is the number of elements in that + * dimension, and stride is the distance in the array between successive + * elements in that dimension. Each dimension's size and stride is taken + * to begin at an array element described by the previous dimension. The + * size array and stride array must be the same size. + * + * For example, if you have offset==3, stride[0]==11, size[1]==3, + * stride[1]==3, then slice[0,0]==array[3], slice[0,1]==array[6], + * slice[0,2]==array[9], slice[1,0]==array[14], slice[1,1]==array[17], + * slice[1,2]==array[20]. + */ + class gslice + { + public: + /// Construct an empty slice. + gslice(); + + /** + * @brief Construct a slice. + * + * Constructs a slice with as many dimensions as the length of the @a l + * and @a s arrays. + * + * @param __o Offset in array of first element. + * @param __l Array of dimension lengths. + * @param __s Array of dimension strides between array elements. + */ + gslice(size_t __o, const valarray& __l, + const valarray& __s); + + // XXX: the IS says the copy-ctor and copy-assignment operators are + // synthesized by the compiler but they are just unsuitable + // for a ref-counted semantic + /// Copy constructor. + gslice(const gslice&); + + /// Destructor. + ~gslice(); + + // XXX: See the note above. + /// Assignment operator. + gslice& operator=(const gslice&); + + /// Return array offset of first slice element. + size_t start() const; + + /// Return array of sizes of slice dimensions. + valarray size() const; + + /// Return array of array strides for each dimension. + valarray stride() const; + + private: + struct _Indexer + { + size_t _M_count; + size_t _M_start; + valarray _M_size; + valarray _M_stride; + valarray _M_index; // Linear array of referenced indices + + _Indexer() + : _M_count(1), _M_start(0), _M_size(), _M_stride(), _M_index() {} + + _Indexer(size_t, const valarray&, + const valarray&); + + void + _M_increment_use() + { ++_M_count; } + + size_t + _M_decrement_use() + { return --_M_count; } + }; + + _Indexer* _M_index; + + template friend class valarray; + }; + + inline size_t + gslice::start() const + { return _M_index ? _M_index->_M_start : 0; } + + inline valarray + gslice::size() const + { return _M_index ? _M_index->_M_size : valarray(); } + + inline valarray + gslice::stride() const + { return _M_index ? _M_index->_M_stride : valarray(); } + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 543. valarray slice default constructor + inline + gslice::gslice() + : _M_index(new gslice::_Indexer()) {} + + inline + gslice::gslice(size_t __o, const valarray& __l, + const valarray& __s) + : _M_index(new gslice::_Indexer(__o, __l, __s)) {} + + inline + gslice::gslice(const gslice& __g) + : _M_index(__g._M_index) + { if (_M_index) _M_index->_M_increment_use(); } + + inline + gslice::~gslice() + { + if (_M_index && _M_index->_M_decrement_use() == 0) + delete _M_index; + } + + inline gslice& + gslice::operator=(const gslice& __g) + { + if (__g._M_index) + __g._M_index->_M_increment_use(); + if (_M_index && _M_index->_M_decrement_use() == 0) + delete _M_index; + _M_index = __g._M_index; + return *this; + } + + // @} group numeric_arrays + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif /* _GSLICE_H */ diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/gslice_array.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/gslice_array.h new file mode 100755 index 0000000..f46b9df --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/gslice_array.h @@ -0,0 +1,218 @@ +// The template and inlines for the -*- C++ -*- gslice_array class. + +// Copyright (C) 1997-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file bits/gslice_array.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{valarray} + */ + +// Written by Gabriel Dos Reis + +#ifndef _GSLICE_ARRAY_H +#define _GSLICE_ARRAY_H 1 + +#pragma GCC system_header + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /** + * @addtogroup numeric_arrays + * @{ + */ + + /** + * @brief Reference to multi-dimensional subset of an array. + * + * A gslice_array is a reference to the actual elements of an array + * specified by a gslice. The way to get a gslice_array is to call + * operator[](gslice) on a valarray. The returned gslice_array then + * permits carrying operations out on the referenced subset of elements in + * the original valarray. For example, operator+=(valarray) will add + * values to the subset of elements in the underlying valarray this + * gslice_array refers to. + * + * @param Tp Element type. + */ + template + class gslice_array + { + public: + typedef _Tp value_type; + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 253. valarray helper functions are almost entirely useless + + /// Copy constructor. Both slices refer to the same underlying array. + gslice_array(const gslice_array&); + + /// Assignment operator. Assigns slice elements to corresponding + /// elements of @a a. + gslice_array& operator=(const gslice_array&); + + /// Assign slice elements to corresponding elements of @a v. + void operator=(const valarray<_Tp>&) const; + /// Multiply slice elements by corresponding elements of @a v. + void operator*=(const valarray<_Tp>&) const; + /// Divide slice elements by corresponding elements of @a v. + void operator/=(const valarray<_Tp>&) const; + /// Modulo slice elements by corresponding elements of @a v. + void operator%=(const valarray<_Tp>&) const; + /// Add corresponding elements of @a v to slice elements. + void operator+=(const valarray<_Tp>&) const; + /// Subtract corresponding elements of @a v from slice elements. + void operator-=(const valarray<_Tp>&) const; + /// Logical xor slice elements with corresponding elements of @a v. + void operator^=(const valarray<_Tp>&) const; + /// Logical and slice elements with corresponding elements of @a v. + void operator&=(const valarray<_Tp>&) const; + /// Logical or slice elements with corresponding elements of @a v. + void operator|=(const valarray<_Tp>&) const; + /// Left shift slice elements by corresponding elements of @a v. + void operator<<=(const valarray<_Tp>&) const; + /// Right shift slice elements by corresponding elements of @a v. + void operator>>=(const valarray<_Tp>&) const; + /// Assign all slice elements to @a t. + void operator=(const _Tp&) const; + + template + void operator=(const _Expr<_Dom, _Tp>&) const; + template + void operator*=(const _Expr<_Dom, _Tp>&) const; + template + void operator/=(const _Expr<_Dom, _Tp>&) const; + template + void operator%=(const _Expr<_Dom, _Tp>&) const; + template + void operator+=(const _Expr<_Dom, _Tp>&) const; + template + void operator-=(const _Expr<_Dom, _Tp>&) const; + template + void operator^=(const _Expr<_Dom, _Tp>&) const; + template + void operator&=(const _Expr<_Dom, _Tp>&) const; + template + void operator|=(const _Expr<_Dom, _Tp>&) const; + template + void operator<<=(const _Expr<_Dom, _Tp>&) const; + template + void operator>>=(const _Expr<_Dom, _Tp>&) const; + + private: + _Array<_Tp> _M_array; + const valarray& _M_index; + + friend class valarray<_Tp>; + + gslice_array(_Array<_Tp>, const valarray&); + + // not implemented + gslice_array(); + }; + + template + inline + gslice_array<_Tp>::gslice_array(_Array<_Tp> __a, + const valarray& __i) + : _M_array(__a), _M_index(__i) {} + + template + inline + gslice_array<_Tp>::gslice_array(const gslice_array<_Tp>& __a) + : _M_array(__a._M_array), _M_index(__a._M_index) {} + + template + inline gslice_array<_Tp>& + gslice_array<_Tp>::operator=(const gslice_array<_Tp>& __a) + { + std::__valarray_copy(_Array<_Tp>(__a._M_array), + _Array(__a._M_index), _M_index.size(), + _M_array, _Array(_M_index)); + return *this; + } + + template + inline void + gslice_array<_Tp>::operator=(const _Tp& __t) const + { + std::__valarray_fill(_M_array, _Array(_M_index), + _M_index.size(), __t); + } + + template + inline void + gslice_array<_Tp>::operator=(const valarray<_Tp>& __v) const + { + std::__valarray_copy(_Array<_Tp>(__v), __v.size(), + _M_array, _Array(_M_index)); + } + + template + template + inline void + gslice_array<_Tp>::operator=(const _Expr<_Dom, _Tp>& __e) const + { + std::__valarray_copy (__e, _M_index.size(), _M_array, + _Array(_M_index)); + } + +#undef _DEFINE_VALARRAY_OPERATOR +#define _DEFINE_VALARRAY_OPERATOR(_Op, _Name) \ + template \ + inline void \ + gslice_array<_Tp>::operator _Op##=(const valarray<_Tp>& __v) const \ + { \ + _Array_augmented_##_Name(_M_array, _Array(_M_index), \ + _Array<_Tp>(__v), __v.size()); \ + } \ + \ + template \ + template \ + inline void \ + gslice_array<_Tp>::operator _Op##= (const _Expr<_Dom, _Tp>& __e) const\ + { \ + _Array_augmented_##_Name(_M_array, _Array(_M_index), __e,\ + _M_index.size()); \ + } + +_DEFINE_VALARRAY_OPERATOR(*, __multiplies) +_DEFINE_VALARRAY_OPERATOR(/, __divides) +_DEFINE_VALARRAY_OPERATOR(%, __modulus) +_DEFINE_VALARRAY_OPERATOR(+, __plus) +_DEFINE_VALARRAY_OPERATOR(-, __minus) +_DEFINE_VALARRAY_OPERATOR(^, __bitwise_xor) +_DEFINE_VALARRAY_OPERATOR(&, __bitwise_and) +_DEFINE_VALARRAY_OPERATOR(|, __bitwise_or) +_DEFINE_VALARRAY_OPERATOR(<<, __shift_left) +_DEFINE_VALARRAY_OPERATOR(>>, __shift_right) + +#undef _DEFINE_VALARRAY_OPERATOR + + // @} group numeric_arrays + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif /* _GSLICE_ARRAY_H */ diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/hash_bytes.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/hash_bytes.h new file mode 100755 index 0000000..401dd87 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/hash_bytes.h @@ -0,0 +1,59 @@ +// Declarations for hash functions. -*- C++ -*- + +// Copyright (C) 2010-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file bits/hash_bytes.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{functional} + */ + +#ifndef _HASH_BYTES_H +#define _HASH_BYTES_H 1 + +#pragma GCC system_header + +#include + +namespace std +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + // Hash function implementation for the nontrivial specialization. + // All of them are based on a primitive that hashes a pointer to a + // byte array. The actual hash algorithm is not guaranteed to stay + // the same from release to release -- it may be updated or tuned to + // improve hash quality or speed. + size_t + _Hash_bytes(const void* __ptr, size_t __len, size_t __seed); + + // A similar hash primitive, using the FNV hash algorithm. This + // algorithm is guaranteed to stay the same from release to release. + // (although it might not produce the same values on different + // machines.) + size_t + _Fnv_hash_bytes(const void* __ptr, size_t __len, size_t __seed); + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/hashtable.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/hashtable.h new file mode 100755 index 0000000..894e526 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/hashtable.h @@ -0,0 +1,2124 @@ +// hashtable.h header -*- C++ -*- + +// Copyright (C) 2007-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file bits/hashtable.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{unordered_map, unordered_set} + */ + +#ifndef _HASHTABLE_H +#define _HASHTABLE_H 1 + +#pragma GCC system_header + +#include + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + template + using __cache_default + = __not_<__and_, + // Mandatory to have erase not throwing. + __detail::__is_noexcept_hash<_Tp, _Hash>>>; + + /** + * Primary class template _Hashtable. + * + * @ingroup hashtable-detail + * + * @tparam _Value CopyConstructible type. + * + * @tparam _Key CopyConstructible type. + * + * @tparam _Alloc An allocator type + * ([lib.allocator.requirements]) whose _Alloc::value_type is + * _Value. As a conforming extension, we allow for + * _Alloc::value_type != _Value. + * + * @tparam _ExtractKey Function object that takes an object of type + * _Value and returns a value of type _Key. + * + * @tparam _Equal Function object that takes two objects of type k + * and returns a bool-like value that is true if the two objects + * are considered equal. + * + * @tparam _H1 The hash function. A unary function object with + * argument type _Key and result type size_t. Return values should + * be distributed over the entire range [0, numeric_limits:::max()]. + * + * @tparam _H2 The range-hashing function (in the terminology of + * Tavori and Dreizin). A binary function object whose argument + * types and result type are all size_t. Given arguments r and N, + * the return value is in the range [0, N). + * + * @tparam _Hash The ranged hash function (Tavori and Dreizin). A + * binary function whose argument types are _Key and size_t and + * whose result type is size_t. Given arguments k and N, the + * return value is in the range [0, N). Default: hash(k, N) = + * h2(h1(k), N). If _Hash is anything other than the default, _H1 + * and _H2 are ignored. + * + * @tparam _RehashPolicy Policy class with three members, all of + * which govern the bucket count. _M_next_bkt(n) returns a bucket + * count no smaller than n. _M_bkt_for_elements(n) returns a + * bucket count appropriate for an element count of n. + * _M_need_rehash(n_bkt, n_elt, n_ins) determines whether, if the + * current bucket count is n_bkt and the current element count is + * n_elt, we need to increase the bucket count. If so, returns + * make_pair(true, n), where n is the new bucket count. If not, + * returns make_pair(false, ) + * + * @tparam _Traits Compile-time class with three boolean + * std::integral_constant members: __cache_hash_code, __constant_iterators, + * __unique_keys. + * + * Each _Hashtable data structure has: + * + * - _Bucket[] _M_buckets + * - _Hash_node_base _M_before_begin + * - size_type _M_bucket_count + * - size_type _M_element_count + * + * with _Bucket being _Hash_node* and _Hash_node containing: + * + * - _Hash_node* _M_next + * - Tp _M_value + * - size_t _M_hash_code if cache_hash_code is true + * + * In terms of Standard containers the hashtable is like the aggregation of: + * + * - std::forward_list<_Node> containing the elements + * - std::vector::iterator> representing the buckets + * + * The non-empty buckets contain the node before the first node in the + * bucket. This design makes it possible to implement something like a + * std::forward_list::insert_after on container insertion and + * std::forward_list::erase_after on container erase + * calls. _M_before_begin is equivalent to + * std::forward_list::before_begin. Empty buckets contain + * nullptr. Note that one of the non-empty buckets contains + * &_M_before_begin which is not a dereferenceable node so the + * node pointer in a bucket shall never be dereferenced, only its + * next node can be. + * + * Walking through a bucket's nodes requires a check on the hash code to + * see if each node is still in the bucket. Such a design assumes a + * quite efficient hash functor and is one of the reasons it is + * highly advisable to set __cache_hash_code to true. + * + * The container iterators are simply built from nodes. This way + * incrementing the iterator is perfectly efficient independent of + * how many empty buckets there are in the container. + * + * On insert we compute the element's hash code and use it to find the + * bucket index. If the element must be inserted in an empty bucket + * we add it at the beginning of the singly linked list and make the + * bucket point to _M_before_begin. The bucket that used to point to + * _M_before_begin, if any, is updated to point to its new before + * begin node. + * + * On erase, the simple iterator design requires using the hash + * functor to get the index of the bucket to update. For this + * reason, when __cache_hash_code is set to false the hash functor must + * not throw and this is enforced by a static assertion. + * + * Functionality is implemented by decomposition into base classes, + * where the derived _Hashtable class is used in _Map_base, + * _Insert, _Rehash_base, and _Equality base classes to access the + * "this" pointer. _Hashtable_base is used in the base classes as a + * non-recursive, fully-completed-type so that detailed nested type + * information, such as iterator type and node type, can be + * used. This is similar to the "Curiously Recurring Template + * Pattern" (CRTP) technique, but uses a reconstructed, not + * explicitly passed, template pattern. + * + * Base class templates are: + * - __detail::_Hashtable_base + * - __detail::_Map_base + * - __detail::_Insert + * - __detail::_Rehash_base + * - __detail::_Equality + */ + template + class _Hashtable + : public __detail::_Hashtable_base<_Key, _Value, _ExtractKey, _Equal, + _H1, _H2, _Hash, _Traits>, + public __detail::_Map_base<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _H1, _H2, _Hash, _RehashPolicy, _Traits>, + public __detail::_Insert<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _H1, _H2, _Hash, _RehashPolicy, _Traits>, + public __detail::_Rehash_base<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _H1, _H2, _Hash, _RehashPolicy, _Traits>, + public __detail::_Equality<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _H1, _H2, _Hash, _RehashPolicy, _Traits>, + private __detail::_Hashtable_alloc< + typename __alloctr_rebind<_Alloc, + __detail::_Hash_node<_Value, + _Traits::__hash_cached::value> >::__type> + { + using __traits_type = _Traits; + using __hash_cached = typename __traits_type::__hash_cached; + using __node_type = __detail::_Hash_node<_Value, __hash_cached::value>; + using __node_alloc_type = + typename __alloctr_rebind<_Alloc, __node_type>::__type; + + using __hashtable_alloc = __detail::_Hashtable_alloc<__node_alloc_type>; + + using __value_alloc_traits = + typename __hashtable_alloc::__value_alloc_traits; + using __node_alloc_traits = + typename __hashtable_alloc::__node_alloc_traits; + using __node_base = typename __hashtable_alloc::__node_base; + using __bucket_type = typename __hashtable_alloc::__bucket_type; + + public: + typedef _Key key_type; + typedef _Value value_type; + typedef _Alloc allocator_type; + typedef _Equal key_equal; + + // mapped_type, if present, comes from _Map_base. + // hasher, if present, comes from _Hash_code_base/_Hashtable_base. + typedef typename __value_alloc_traits::pointer pointer; + typedef typename __value_alloc_traits::const_pointer const_pointer; + typedef value_type& reference; + typedef const value_type& const_reference; + + private: + using __rehash_type = _RehashPolicy; + using __rehash_state = typename __rehash_type::_State; + + using __constant_iterators = typename __traits_type::__constant_iterators; + using __unique_keys = typename __traits_type::__unique_keys; + + using __key_extract = typename std::conditional< + __constant_iterators::value, + __detail::_Identity, + __detail::_Select1st>::type; + + using __hashtable_base = __detail:: + _Hashtable_base<_Key, _Value, _ExtractKey, + _Equal, _H1, _H2, _Hash, _Traits>; + + using __hash_code_base = typename __hashtable_base::__hash_code_base; + using __hash_code = typename __hashtable_base::__hash_code; + using __ireturn_type = typename __hashtable_base::__ireturn_type; + + using __map_base = __detail::_Map_base<_Key, _Value, _Alloc, _ExtractKey, + _Equal, _H1, _H2, _Hash, + _RehashPolicy, _Traits>; + + using __rehash_base = __detail::_Rehash_base<_Key, _Value, _Alloc, + _ExtractKey, _Equal, + _H1, _H2, _Hash, + _RehashPolicy, _Traits>; + + using __eq_base = __detail::_Equality<_Key, _Value, _Alloc, _ExtractKey, + _Equal, _H1, _H2, _Hash, + _RehashPolicy, _Traits>; + + using __reuse_or_alloc_node_type = + __detail::_ReuseOrAllocNode<__node_alloc_type>; + + // Metaprogramming for picking apart hash caching. + template + using __if_hash_cached = __or_<__not_<__hash_cached>, _Cond>; + + template + using __if_hash_not_cached = __or_<__hash_cached, _Cond>; + + // Compile-time diagnostics. + + // _Hash_code_base has everything protected, so use this derived type to + // access it. + struct __hash_code_base_access : __hash_code_base + { using __hash_code_base::_M_bucket_index; }; + + // Getting a bucket index from a node shall not throw because it is used + // in methods (erase, swap...) that shall not throw. + static_assert(noexcept(declval() + ._M_bucket_index((const __node_type*)nullptr, + (std::size_t)0)), + "Cache the hash code or qualify your functors involved" + " in hash code and bucket index computation with noexcept"); + + // Following two static assertions are necessary to guarantee + // that local_iterator will be default constructible. + + // When hash codes are cached local iterator inherits from H2 functor + // which must then be default constructible. + static_assert(__if_hash_cached>::value, + "Functor used to map hash code to bucket index" + " must be default constructible"); + + template + friend struct __detail::_Map_base; + + template + friend struct __detail::_Insert_base; + + template + friend struct __detail::_Insert; + + public: + using size_type = typename __hashtable_base::size_type; + using difference_type = typename __hashtable_base::difference_type; + + using iterator = typename __hashtable_base::iterator; + using const_iterator = typename __hashtable_base::const_iterator; + + using local_iterator = typename __hashtable_base::local_iterator; + using const_local_iterator = typename __hashtable_base:: + const_local_iterator; + + private: + __bucket_type* _M_buckets; + size_type _M_bucket_count; + __node_base _M_before_begin; + size_type _M_element_count; + _RehashPolicy _M_rehash_policy; + + // A single bucket used when only need for 1 bucket. Especially + // interesting in move semantic to leave hashtable with only 1 buckets + // which is not allocated so that we can have those operations noexcept + // qualified. + // Note that we can't leave hashtable with 0 bucket without adding + // numerous checks in the code to avoid 0 modulus. + __bucket_type _M_single_bucket; + + bool + _M_uses_single_bucket(__bucket_type* __bkts) const + { return __builtin_expect(__bkts == &_M_single_bucket, false); } + + bool + _M_uses_single_bucket() const + { return _M_uses_single_bucket(_M_buckets); } + + __hashtable_alloc& + _M_base_alloc() { return *this; } + + __bucket_type* + _M_allocate_buckets(size_type __n) + { + if (__builtin_expect(__n == 1, false)) + { + _M_single_bucket = nullptr; + return &_M_single_bucket; + } + + return __hashtable_alloc::_M_allocate_buckets(__n); + } + + void + _M_deallocate_buckets(__bucket_type* __bkts, size_type __n) + { + if (_M_uses_single_bucket(__bkts)) + return; + + __hashtable_alloc::_M_deallocate_buckets(__bkts, __n); + } + + void + _M_deallocate_buckets() + { _M_deallocate_buckets(_M_buckets, _M_bucket_count); } + + // Gets bucket begin, deals with the fact that non-empty buckets contain + // their before begin node. + __node_type* + _M_bucket_begin(size_type __bkt) const; + + __node_type* + _M_begin() const + { return static_cast<__node_type*>(_M_before_begin._M_nxt); } + + template + void + _M_assign(const _Hashtable&, const _NodeGenerator&); + + void + _M_move_assign(_Hashtable&&, std::true_type); + + void + _M_move_assign(_Hashtable&&, std::false_type); + + void + _M_reset() noexcept; + + public: + // Constructor, destructor, assignment, swap + _Hashtable(size_type __bucket_hint, + const _H1&, const _H2&, const _Hash&, + const _Equal&, const _ExtractKey&, + const allocator_type&); + + template + _Hashtable(_InputIterator __first, _InputIterator __last, + size_type __bucket_hint, + const _H1&, const _H2&, const _Hash&, + const _Equal&, const _ExtractKey&, + const allocator_type&); + + _Hashtable(const _Hashtable&); + + _Hashtable(_Hashtable&&) noexcept; + + _Hashtable(const _Hashtable&, const allocator_type&); + + _Hashtable(_Hashtable&&, const allocator_type&); + + // Use delegating constructors. + explicit + _Hashtable(const allocator_type& __a) + : _Hashtable(10, _H1(), _H2(), _Hash(), key_equal(), + __key_extract(), __a) + { } + + explicit + _Hashtable(size_type __n = 10, + const _H1& __hf = _H1(), + const key_equal& __eql = key_equal(), + const allocator_type& __a = allocator_type()) + : _Hashtable(__n, __hf, _H2(), _Hash(), __eql, + __key_extract(), __a) + { } + + template + _Hashtable(_InputIterator __f, _InputIterator __l, + size_type __n = 0, + const _H1& __hf = _H1(), + const key_equal& __eql = key_equal(), + const allocator_type& __a = allocator_type()) + : _Hashtable(__f, __l, __n, __hf, _H2(), _Hash(), __eql, + __key_extract(), __a) + { } + + _Hashtable(initializer_list __l, + size_type __n = 0, + const _H1& __hf = _H1(), + const key_equal& __eql = key_equal(), + const allocator_type& __a = allocator_type()) + : _Hashtable(__l.begin(), __l.end(), __n, __hf, _H2(), _Hash(), __eql, + __key_extract(), __a) + { } + + _Hashtable& + operator=(const _Hashtable& __ht); + + _Hashtable& + operator=(_Hashtable&& __ht) + noexcept(__node_alloc_traits::_S_nothrow_move()) + { + constexpr bool __move_storage = + __node_alloc_traits::_S_propagate_on_move_assign() + || __node_alloc_traits::_S_always_equal(); + _M_move_assign(std::move(__ht), + integral_constant()); + return *this; + } + + _Hashtable& + operator=(initializer_list __l) + { + __reuse_or_alloc_node_type __roan(_M_begin(), *this); + _M_before_begin._M_nxt = nullptr; + clear(); + this->_M_insert_range(__l.begin(), __l.end(), __roan); + return *this; + } + + ~_Hashtable() noexcept; + + void + swap(_Hashtable&) + noexcept(__node_alloc_traits::_S_nothrow_swap()); + + // Basic container operations + iterator + begin() noexcept + { return iterator(_M_begin()); } + + const_iterator + begin() const noexcept + { return const_iterator(_M_begin()); } + + iterator + end() noexcept + { return iterator(nullptr); } + + const_iterator + end() const noexcept + { return const_iterator(nullptr); } + + const_iterator + cbegin() const noexcept + { return const_iterator(_M_begin()); } + + const_iterator + cend() const noexcept + { return const_iterator(nullptr); } + + size_type + size() const noexcept + { return _M_element_count; } + + bool + empty() const noexcept + { return size() == 0; } + + allocator_type + get_allocator() const noexcept + { return allocator_type(this->_M_node_allocator()); } + + size_type + max_size() const noexcept + { return __node_alloc_traits::max_size(this->_M_node_allocator()); } + + // Observers + key_equal + key_eq() const + { return this->_M_eq(); } + + // hash_function, if present, comes from _Hash_code_base. + + // Bucket operations + size_type + bucket_count() const noexcept + { return _M_bucket_count; } + + size_type + max_bucket_count() const noexcept + { return max_size(); } + + size_type + bucket_size(size_type __n) const + { return std::distance(begin(__n), end(__n)); } + + size_type + bucket(const key_type& __k) const + { return _M_bucket_index(__k, this->_M_hash_code(__k)); } + + local_iterator + begin(size_type __n) + { + return local_iterator(*this, _M_bucket_begin(__n), + __n, _M_bucket_count); + } + + local_iterator + end(size_type __n) + { return local_iterator(*this, nullptr, __n, _M_bucket_count); } + + const_local_iterator + begin(size_type __n) const + { + return const_local_iterator(*this, _M_bucket_begin(__n), + __n, _M_bucket_count); + } + + const_local_iterator + end(size_type __n) const + { return const_local_iterator(*this, nullptr, __n, _M_bucket_count); } + + // DR 691. + const_local_iterator + cbegin(size_type __n) const + { + return const_local_iterator(*this, _M_bucket_begin(__n), + __n, _M_bucket_count); + } + + const_local_iterator + cend(size_type __n) const + { return const_local_iterator(*this, nullptr, __n, _M_bucket_count); } + + float + load_factor() const noexcept + { + return static_cast(size()) / static_cast(bucket_count()); + } + + // max_load_factor, if present, comes from _Rehash_base. + + // Generalization of max_load_factor. Extension, not found in + // TR1. Only useful if _RehashPolicy is something other than + // the default. + const _RehashPolicy& + __rehash_policy() const + { return _M_rehash_policy; } + + void + __rehash_policy(const _RehashPolicy&); + + // Lookup. + iterator + find(const key_type& __k); + + const_iterator + find(const key_type& __k) const; + + size_type + count(const key_type& __k) const; + + std::pair + equal_range(const key_type& __k); + + std::pair + equal_range(const key_type& __k) const; + + protected: + // Bucket index computation helpers. + size_type + _M_bucket_index(__node_type* __n) const noexcept + { return __hash_code_base::_M_bucket_index(__n, _M_bucket_count); } + + size_type + _M_bucket_index(const key_type& __k, __hash_code __c) const + { return __hash_code_base::_M_bucket_index(__k, __c, _M_bucket_count); } + + // Find and insert helper functions and types + // Find the node before the one matching the criteria. + __node_base* + _M_find_before_node(size_type, const key_type&, __hash_code) const; + + __node_type* + _M_find_node(size_type __bkt, const key_type& __key, + __hash_code __c) const + { + __node_base* __before_n = _M_find_before_node(__bkt, __key, __c); + if (__before_n) + return static_cast<__node_type*>(__before_n->_M_nxt); + return nullptr; + } + + // Insert a node at the beginning of a bucket. + void + _M_insert_bucket_begin(size_type, __node_type*); + + // Remove the bucket first node + void + _M_remove_bucket_begin(size_type __bkt, __node_type* __next_n, + size_type __next_bkt); + + // Get the node before __n in the bucket __bkt + __node_base* + _M_get_previous_node(size_type __bkt, __node_base* __n); + + // Insert node with hash code __code, in bucket bkt if no rehash (assumes + // no element with its key already present). Take ownership of the node, + // deallocate it on exception. + iterator + _M_insert_unique_node(size_type __bkt, __hash_code __code, + __node_type* __n); + + // Insert node with hash code __code. Take ownership of the node, + // deallocate it on exception. + iterator + _M_insert_multi_node(__node_type* __hint, + __hash_code __code, __node_type* __n); + + template + std::pair + _M_emplace(std::true_type, _Args&&... __args); + + template + iterator + _M_emplace(std::false_type __uk, _Args&&... __args) + { return _M_emplace(cend(), __uk, std::forward<_Args>(__args)...); } + + // Emplace with hint, useless when keys are unique. + template + iterator + _M_emplace(const_iterator, std::true_type __uk, _Args&&... __args) + { return _M_emplace(__uk, std::forward<_Args>(__args)...).first; } + + template + iterator + _M_emplace(const_iterator, std::false_type, _Args&&... __args); + + template + std::pair + _M_insert(_Arg&&, const _NodeGenerator&, std::true_type); + + template + iterator + _M_insert(_Arg&& __arg, const _NodeGenerator& __node_gen, + std::false_type __uk) + { + return _M_insert(cend(), std::forward<_Arg>(__arg), __node_gen, + __uk); + } + + // Insert with hint, not used when keys are unique. + template + iterator + _M_insert(const_iterator, _Arg&& __arg, const _NodeGenerator& __node_gen, + std::true_type __uk) + { + return + _M_insert(std::forward<_Arg>(__arg), __node_gen, __uk).first; + } + + // Insert with hint when keys are not unique. + template + iterator + _M_insert(const_iterator, _Arg&&, const _NodeGenerator&, std::false_type); + + size_type + _M_erase(std::true_type, const key_type&); + + size_type + _M_erase(std::false_type, const key_type&); + + iterator + _M_erase(size_type __bkt, __node_base* __prev_n, __node_type* __n); + + public: + // Emplace + template + __ireturn_type + emplace(_Args&&... __args) + { return _M_emplace(__unique_keys(), std::forward<_Args>(__args)...); } + + template + iterator + emplace_hint(const_iterator __hint, _Args&&... __args) + { + return _M_emplace(__hint, __unique_keys(), + std::forward<_Args>(__args)...); + } + + // Insert member functions via inheritance. + + // Erase + iterator + erase(const_iterator); + + // LWG 2059. + iterator + erase(iterator __it) + { return erase(const_iterator(__it)); } + + size_type + erase(const key_type& __k) + { return _M_erase(__unique_keys(), __k); } + + iterator + erase(const_iterator, const_iterator); + + void + clear() noexcept; + + // Set number of buckets to be appropriate for container of n element. + void rehash(size_type __n); + + // DR 1189. + // reserve, if present, comes from _Rehash_base. + + private: + // Helper rehash method used when keys are unique. + void _M_rehash_aux(size_type __n, std::true_type); + + // Helper rehash method used when keys can be non-unique. + void _M_rehash_aux(size_type __n, std::false_type); + + // Unconditionally change size of bucket array to n, restore + // hash policy state to __state on exception. + void _M_rehash(size_type __n, const __rehash_state& __state); + }; + + + // Definitions of class template _Hashtable's out-of-line member functions. + template + typename _Hashtable<_Key, _Value, _Alloc, _ExtractKey, + _Equal, _H1, _H2, _Hash, _RehashPolicy, + _Traits>::__node_type* + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _H1, _H2, _Hash, _RehashPolicy, _Traits>:: + _M_bucket_begin(size_type __bkt) const + { + __node_base* __n = _M_buckets[__bkt]; + return __n ? static_cast<__node_type*>(__n->_M_nxt) : nullptr; + } + + template + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _H1, _H2, _Hash, _RehashPolicy, _Traits>:: + _Hashtable(size_type __bucket_hint, + const _H1& __h1, const _H2& __h2, const _Hash& __h, + const _Equal& __eq, const _ExtractKey& __exk, + const allocator_type& __a) + : __hashtable_base(__exk, __h1, __h2, __h, __eq), + __map_base(), + __rehash_base(), + __hashtable_alloc(__node_alloc_type(__a)), + _M_element_count(0), + _M_rehash_policy() + { + _M_bucket_count = _M_rehash_policy._M_next_bkt(__bucket_hint); + _M_buckets = _M_allocate_buckets(_M_bucket_count); + } + + template + template + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _H1, _H2, _Hash, _RehashPolicy, _Traits>:: + _Hashtable(_InputIterator __f, _InputIterator __l, + size_type __bucket_hint, + const _H1& __h1, const _H2& __h2, const _Hash& __h, + const _Equal& __eq, const _ExtractKey& __exk, + const allocator_type& __a) + : __hashtable_base(__exk, __h1, __h2, __h, __eq), + __map_base(), + __rehash_base(), + __hashtable_alloc(__node_alloc_type(__a)), + _M_element_count(0), + _M_rehash_policy() + { + auto __nb_elems = __detail::__distance_fw(__f, __l); + _M_bucket_count = + _M_rehash_policy._M_next_bkt( + std::max(_M_rehash_policy._M_bkt_for_elements(__nb_elems), + __bucket_hint)); + + _M_buckets = _M_allocate_buckets(_M_bucket_count); + __try + { + for (; __f != __l; ++__f) + this->insert(*__f); + } + __catch(...) + { + clear(); + _M_deallocate_buckets(); + __throw_exception_again; + } + } + + template + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _H1, _H2, _Hash, _RehashPolicy, _Traits>& + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _H1, _H2, _Hash, _RehashPolicy, _Traits>::operator=( + const _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _H1, _H2, _Hash, _RehashPolicy, _Traits>& __ht) + { + if (&__ht == this) + return *this; + + if (__node_alloc_traits::_S_propagate_on_copy_assign()) + { + auto& __this_alloc = this->_M_node_allocator(); + auto& __that_alloc = __ht._M_node_allocator(); + if (!__node_alloc_traits::_S_always_equal() + && __this_alloc != __that_alloc) + { + // Replacement allocator cannot free existing storage. + this->_M_deallocate_nodes(_M_begin()); + _M_before_begin._M_nxt = nullptr; + _M_deallocate_buckets(); + _M_buckets = nullptr; + std::__alloc_on_copy(__this_alloc, __that_alloc); + __hashtable_base::operator=(__ht); + _M_bucket_count = __ht._M_bucket_count; + _M_element_count = __ht._M_element_count; + _M_rehash_policy = __ht._M_rehash_policy; + __try + { + _M_assign(__ht, + [this](const __node_type* __n) + { return this->_M_allocate_node(__n->_M_v()); }); + } + __catch(...) + { + // _M_assign took care of deallocating all memory. Now we + // must make sure this instance remains in a usable state. + _M_reset(); + __throw_exception_again; + } + return *this; + } + std::__alloc_on_copy(__this_alloc, __that_alloc); + } + + // Reuse allocated buckets and nodes. + __bucket_type* __former_buckets = nullptr; + std::size_t __former_bucket_count = _M_bucket_count; + const __rehash_state& __former_state = _M_rehash_policy._M_state(); + + if (_M_bucket_count != __ht._M_bucket_count) + { + __former_buckets = _M_buckets; + _M_buckets = _M_allocate_buckets(__ht._M_bucket_count); + _M_bucket_count = __ht._M_bucket_count; + } + else + __builtin_memset(_M_buckets, 0, + _M_bucket_count * sizeof(__bucket_type)); + + __try + { + __hashtable_base::operator=(__ht); + _M_element_count = __ht._M_element_count; + _M_rehash_policy = __ht._M_rehash_policy; + __reuse_or_alloc_node_type __roan(_M_begin(), *this); + _M_before_begin._M_nxt = nullptr; + _M_assign(__ht, + [&__roan](const __node_type* __n) + { return __roan(__n->_M_v()); }); + if (__former_buckets) + _M_deallocate_buckets(__former_buckets, __former_bucket_count); + } + __catch(...) + { + if (__former_buckets) + { + // Restore previous buckets. + _M_deallocate_buckets(); + _M_rehash_policy._M_reset(__former_state); + _M_buckets = __former_buckets; + _M_bucket_count = __former_bucket_count; + } + __builtin_memset(_M_buckets, 0, + _M_bucket_count * sizeof(__bucket_type)); + __throw_exception_again; + } + return *this; + } + + template + template + void + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _H1, _H2, _Hash, _RehashPolicy, _Traits>:: + _M_assign(const _Hashtable& __ht, const _NodeGenerator& __node_gen) + { + __bucket_type* __buckets = nullptr; + if (!_M_buckets) + _M_buckets = __buckets = _M_allocate_buckets(_M_bucket_count); + + __try + { + if (!__ht._M_before_begin._M_nxt) + return; + + // First deal with the special first node pointed to by + // _M_before_begin. + __node_type* __ht_n = __ht._M_begin(); + __node_type* __this_n = __node_gen(__ht_n); + this->_M_copy_code(__this_n, __ht_n); + _M_before_begin._M_nxt = __this_n; + _M_buckets[_M_bucket_index(__this_n)] = &_M_before_begin; + + // Then deal with other nodes. + __node_base* __prev_n = __this_n; + for (__ht_n = __ht_n->_M_next(); __ht_n; __ht_n = __ht_n->_M_next()) + { + __this_n = __node_gen(__ht_n); + __prev_n->_M_nxt = __this_n; + this->_M_copy_code(__this_n, __ht_n); + size_type __bkt = _M_bucket_index(__this_n); + if (!_M_buckets[__bkt]) + _M_buckets[__bkt] = __prev_n; + __prev_n = __this_n; + } + } + __catch(...) + { + clear(); + if (__buckets) + _M_deallocate_buckets(); + __throw_exception_again; + } + } + + template + void + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _H1, _H2, _Hash, _RehashPolicy, _Traits>:: + _M_reset() noexcept + { + _M_rehash_policy._M_reset(); + _M_bucket_count = 1; + _M_single_bucket = nullptr; + _M_buckets = &_M_single_bucket; + _M_before_begin._M_nxt = nullptr; + _M_element_count = 0; + } + + template + void + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _H1, _H2, _Hash, _RehashPolicy, _Traits>:: + _M_move_assign(_Hashtable&& __ht, std::true_type) + { + this->_M_deallocate_nodes(_M_begin()); + _M_deallocate_buckets(); + __hashtable_base::operator=(std::move(__ht)); + _M_rehash_policy = __ht._M_rehash_policy; + if (!__ht._M_uses_single_bucket()) + _M_buckets = __ht._M_buckets; + else + { + _M_buckets = &_M_single_bucket; + _M_single_bucket = __ht._M_single_bucket; + } + _M_bucket_count = __ht._M_bucket_count; + _M_before_begin._M_nxt = __ht._M_before_begin._M_nxt; + _M_element_count = __ht._M_element_count; + std::__alloc_on_move(this->_M_node_allocator(), __ht._M_node_allocator()); + + // Fix buckets containing the _M_before_begin pointers that can't be + // moved. + if (_M_begin()) + _M_buckets[_M_bucket_index(_M_begin())] = &_M_before_begin; + __ht._M_reset(); + } + + template + void + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _H1, _H2, _Hash, _RehashPolicy, _Traits>:: + _M_move_assign(_Hashtable&& __ht, std::false_type) + { + if (__ht._M_node_allocator() == this->_M_node_allocator()) + _M_move_assign(std::move(__ht), std::true_type()); + else + { + // Can't move memory, move elements then. + __bucket_type* __former_buckets = nullptr; + size_type __former_bucket_count = _M_bucket_count; + const __rehash_state& __former_state = _M_rehash_policy._M_state(); + + if (_M_bucket_count != __ht._M_bucket_count) + { + __former_buckets = _M_buckets; + _M_buckets = _M_allocate_buckets(__ht._M_bucket_count); + _M_bucket_count = __ht._M_bucket_count; + } + else + __builtin_memset(_M_buckets, 0, + _M_bucket_count * sizeof(__bucket_type)); + + __try + { + __hashtable_base::operator=(std::move(__ht)); + _M_element_count = __ht._M_element_count; + _M_rehash_policy = __ht._M_rehash_policy; + __reuse_or_alloc_node_type __roan(_M_begin(), *this); + _M_before_begin._M_nxt = nullptr; + _M_assign(__ht, + [&__roan](__node_type* __n) + { return __roan(std::move_if_noexcept(__n->_M_v())); }); + __ht.clear(); + } + __catch(...) + { + if (__former_buckets) + { + _M_deallocate_buckets(); + _M_rehash_policy._M_reset(__former_state); + _M_buckets = __former_buckets; + _M_bucket_count = __former_bucket_count; + } + __builtin_memset(_M_buckets, 0, + _M_bucket_count * sizeof(__bucket_type)); + __throw_exception_again; + } + } + } + + template + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _H1, _H2, _Hash, _RehashPolicy, _Traits>:: + _Hashtable(const _Hashtable& __ht) + : __hashtable_base(__ht), + __map_base(__ht), + __rehash_base(__ht), + __hashtable_alloc( + __node_alloc_traits::_S_select_on_copy(__ht._M_node_allocator())), + _M_buckets(), + _M_bucket_count(__ht._M_bucket_count), + _M_element_count(__ht._M_element_count), + _M_rehash_policy(__ht._M_rehash_policy) + { + _M_assign(__ht, + [this](const __node_type* __n) + { return this->_M_allocate_node(__n->_M_v()); }); + } + + template + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _H1, _H2, _Hash, _RehashPolicy, _Traits>:: + _Hashtable(_Hashtable&& __ht) noexcept + : __hashtable_base(__ht), + __map_base(__ht), + __rehash_base(__ht), + __hashtable_alloc(std::move(__ht._M_base_alloc())), + _M_buckets(__ht._M_buckets), + _M_bucket_count(__ht._M_bucket_count), + _M_before_begin(__ht._M_before_begin._M_nxt), + _M_element_count(__ht._M_element_count), + _M_rehash_policy(__ht._M_rehash_policy) + { + // Update, if necessary, buckets if __ht is using its single bucket. + if (__ht._M_uses_single_bucket()) + { + _M_buckets = &_M_single_bucket; + _M_single_bucket = __ht._M_single_bucket; + } + + // Update, if necessary, bucket pointing to before begin that hasn't + // moved. + if (_M_begin()) + _M_buckets[_M_bucket_index(_M_begin())] = &_M_before_begin; + + __ht._M_reset(); + } + + template + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _H1, _H2, _Hash, _RehashPolicy, _Traits>:: + _Hashtable(const _Hashtable& __ht, const allocator_type& __a) + : __hashtable_base(__ht), + __map_base(__ht), + __rehash_base(__ht), + __hashtable_alloc(__node_alloc_type(__a)), + _M_buckets(), + _M_bucket_count(__ht._M_bucket_count), + _M_element_count(__ht._M_element_count), + _M_rehash_policy(__ht._M_rehash_policy) + { + _M_assign(__ht, + [this](const __node_type* __n) + { return this->_M_allocate_node(__n->_M_v()); }); + } + + template + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _H1, _H2, _Hash, _RehashPolicy, _Traits>:: + _Hashtable(_Hashtable&& __ht, const allocator_type& __a) + : __hashtable_base(__ht), + __map_base(__ht), + __rehash_base(__ht), + __hashtable_alloc(__node_alloc_type(__a)), + _M_buckets(), + _M_bucket_count(__ht._M_bucket_count), + _M_element_count(__ht._M_element_count), + _M_rehash_policy(__ht._M_rehash_policy) + { + if (__ht._M_node_allocator() == this->_M_node_allocator()) + { + if (__ht._M_uses_single_bucket()) + { + _M_buckets = &_M_single_bucket; + _M_single_bucket = __ht._M_single_bucket; + } + else + _M_buckets = __ht._M_buckets; + + _M_before_begin._M_nxt = __ht._M_before_begin._M_nxt; + // Update, if necessary, bucket pointing to before begin that hasn't + // moved. + if (_M_begin()) + _M_buckets[_M_bucket_index(_M_begin())] = &_M_before_begin; + __ht._M_reset(); + } + else + { + _M_assign(__ht, + [this](__node_type* __n) + { + return this->_M_allocate_node( + std::move_if_noexcept(__n->_M_v())); + }); + __ht.clear(); + } + } + + template + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _H1, _H2, _Hash, _RehashPolicy, _Traits>:: + ~_Hashtable() noexcept + { + clear(); + if (_M_buckets) + _M_deallocate_buckets(); + } + + template + void + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _H1, _H2, _Hash, _RehashPolicy, _Traits>:: + swap(_Hashtable& __x) + noexcept(__node_alloc_traits::_S_nothrow_swap()) + { + // The only base class with member variables is hash_code_base. + // We define _Hash_code_base::_M_swap because different + // specializations have different members. + this->_M_swap(__x); + + std::__alloc_on_swap(this->_M_node_allocator(), __x._M_node_allocator()); + std::swap(_M_rehash_policy, __x._M_rehash_policy); + + // Deal properly with potentially moved instances. + if (this->_M_uses_single_bucket()) + { + if (!__x._M_uses_single_bucket()) + { + _M_buckets = __x._M_buckets; + __x._M_buckets = &__x._M_single_bucket; + } + } + else if (__x._M_uses_single_bucket()) + { + __x._M_buckets = _M_buckets; + _M_buckets = &_M_single_bucket; + } + else + std::swap(_M_buckets, __x._M_buckets); + + std::swap(_M_bucket_count, __x._M_bucket_count); + std::swap(_M_before_begin._M_nxt, __x._M_before_begin._M_nxt); + std::swap(_M_element_count, __x._M_element_count); + std::swap(_M_single_bucket, __x._M_single_bucket); + + // Fix buckets containing the _M_before_begin pointers that can't be + // swapped. + if (_M_begin()) + _M_buckets[_M_bucket_index(_M_begin())] = &_M_before_begin; + + if (__x._M_begin()) + __x._M_buckets[__x._M_bucket_index(__x._M_begin())] + = &__x._M_before_begin; + } + + template + void + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _H1, _H2, _Hash, _RehashPolicy, _Traits>:: + __rehash_policy(const _RehashPolicy& __pol) + { + auto __do_rehash = + __pol._M_need_rehash(_M_bucket_count, _M_element_count, 0); + if (__do_rehash.first) + _M_rehash(__do_rehash.second, _M_rehash_policy._M_state()); + _M_rehash_policy = __pol; + } + + template + typename _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _H1, _H2, _Hash, _RehashPolicy, + _Traits>::iterator + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _H1, _H2, _Hash, _RehashPolicy, _Traits>:: + find(const key_type& __k) + { + __hash_code __code = this->_M_hash_code(__k); + std::size_t __n = _M_bucket_index(__k, __code); + __node_type* __p = _M_find_node(__n, __k, __code); + return __p ? iterator(__p) : end(); + } + + template + typename _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _H1, _H2, _Hash, _RehashPolicy, + _Traits>::const_iterator + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _H1, _H2, _Hash, _RehashPolicy, _Traits>:: + find(const key_type& __k) const + { + __hash_code __code = this->_M_hash_code(__k); + std::size_t __n = _M_bucket_index(__k, __code); + __node_type* __p = _M_find_node(__n, __k, __code); + return __p ? const_iterator(__p) : end(); + } + + template + typename _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _H1, _H2, _Hash, _RehashPolicy, + _Traits>::size_type + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _H1, _H2, _Hash, _RehashPolicy, _Traits>:: + count(const key_type& __k) const + { + __hash_code __code = this->_M_hash_code(__k); + std::size_t __n = _M_bucket_index(__k, __code); + __node_type* __p = _M_bucket_begin(__n); + if (!__p) + return 0; + + std::size_t __result = 0; + for (;; __p = __p->_M_next()) + { + if (this->_M_equals(__k, __code, __p)) + ++__result; + else if (__result) + // All equivalent values are next to each other, if we + // found a non-equivalent value after an equivalent one it + // means that we won't find any new equivalent value. + break; + if (!__p->_M_nxt || _M_bucket_index(__p->_M_next()) != __n) + break; + } + return __result; + } + + template + std::pair::iterator, + typename _Hashtable<_Key, _Value, _Alloc, + _ExtractKey, _Equal, _H1, + _H2, _Hash, _RehashPolicy, + _Traits>::iterator> + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _H1, _H2, _Hash, _RehashPolicy, _Traits>:: + equal_range(const key_type& __k) + { + __hash_code __code = this->_M_hash_code(__k); + std::size_t __n = _M_bucket_index(__k, __code); + __node_type* __p = _M_find_node(__n, __k, __code); + + if (__p) + { + __node_type* __p1 = __p->_M_next(); + while (__p1 && _M_bucket_index(__p1) == __n + && this->_M_equals(__k, __code, __p1)) + __p1 = __p1->_M_next(); + + return std::make_pair(iterator(__p), iterator(__p1)); + } + else + return std::make_pair(end(), end()); + } + + template + std::pair::const_iterator, + typename _Hashtable<_Key, _Value, _Alloc, + _ExtractKey, _Equal, _H1, + _H2, _Hash, _RehashPolicy, + _Traits>::const_iterator> + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _H1, _H2, _Hash, _RehashPolicy, _Traits>:: + equal_range(const key_type& __k) const + { + __hash_code __code = this->_M_hash_code(__k); + std::size_t __n = _M_bucket_index(__k, __code); + __node_type* __p = _M_find_node(__n, __k, __code); + + if (__p) + { + __node_type* __p1 = __p->_M_next(); + while (__p1 && _M_bucket_index(__p1) == __n + && this->_M_equals(__k, __code, __p1)) + __p1 = __p1->_M_next(); + + return std::make_pair(const_iterator(__p), const_iterator(__p1)); + } + else + return std::make_pair(end(), end()); + } + + // Find the node whose key compares equal to k in the bucket n. + // Return nullptr if no node is found. + template + typename _Hashtable<_Key, _Value, _Alloc, _ExtractKey, + _Equal, _H1, _H2, _Hash, _RehashPolicy, + _Traits>::__node_base* + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _H1, _H2, _Hash, _RehashPolicy, _Traits>:: + _M_find_before_node(size_type __n, const key_type& __k, + __hash_code __code) const + { + __node_base* __prev_p = _M_buckets[__n]; + if (!__prev_p) + return nullptr; + + for (__node_type* __p = static_cast<__node_type*>(__prev_p->_M_nxt);; + __p = __p->_M_next()) + { + if (this->_M_equals(__k, __code, __p)) + return __prev_p; + + if (!__p->_M_nxt || _M_bucket_index(__p->_M_next()) != __n) + break; + __prev_p = __p; + } + return nullptr; + } + + template + void + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _H1, _H2, _Hash, _RehashPolicy, _Traits>:: + _M_insert_bucket_begin(size_type __bkt, __node_type* __node) + { + if (_M_buckets[__bkt]) + { + // Bucket is not empty, we just need to insert the new node + // after the bucket before begin. + __node->_M_nxt = _M_buckets[__bkt]->_M_nxt; + _M_buckets[__bkt]->_M_nxt = __node; + } + else + { + // The bucket is empty, the new node is inserted at the + // beginning of the singly-linked list and the bucket will + // contain _M_before_begin pointer. + __node->_M_nxt = _M_before_begin._M_nxt; + _M_before_begin._M_nxt = __node; + if (__node->_M_nxt) + // We must update former begin bucket that is pointing to + // _M_before_begin. + _M_buckets[_M_bucket_index(__node->_M_next())] = __node; + _M_buckets[__bkt] = &_M_before_begin; + } + } + + template + void + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _H1, _H2, _Hash, _RehashPolicy, _Traits>:: + _M_remove_bucket_begin(size_type __bkt, __node_type* __next, + size_type __next_bkt) + { + if (!__next || __next_bkt != __bkt) + { + // Bucket is now empty + // First update next bucket if any + if (__next) + _M_buckets[__next_bkt] = _M_buckets[__bkt]; + + // Second update before begin node if necessary + if (&_M_before_begin == _M_buckets[__bkt]) + _M_before_begin._M_nxt = __next; + _M_buckets[__bkt] = nullptr; + } + } + + template + typename _Hashtable<_Key, _Value, _Alloc, _ExtractKey, + _Equal, _H1, _H2, _Hash, _RehashPolicy, + _Traits>::__node_base* + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _H1, _H2, _Hash, _RehashPolicy, _Traits>:: + _M_get_previous_node(size_type __bkt, __node_base* __n) + { + __node_base* __prev_n = _M_buckets[__bkt]; + while (__prev_n->_M_nxt != __n) + __prev_n = __prev_n->_M_nxt; + return __prev_n; + } + + template + template + std::pair::iterator, bool> + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _H1, _H2, _Hash, _RehashPolicy, _Traits>:: + _M_emplace(std::true_type, _Args&&... __args) + { + // First build the node to get access to the hash code + __node_type* __node = this->_M_allocate_node(std::forward<_Args>(__args)...); + const key_type& __k = this->_M_extract()(__node->_M_v()); + __hash_code __code; + __try + { + __code = this->_M_hash_code(__k); + } + __catch(...) + { + this->_M_deallocate_node(__node); + __throw_exception_again; + } + + size_type __bkt = _M_bucket_index(__k, __code); + if (__node_type* __p = _M_find_node(__bkt, __k, __code)) + { + // There is already an equivalent node, no insertion + this->_M_deallocate_node(__node); + return std::make_pair(iterator(__p), false); + } + + // Insert the node + return std::make_pair(_M_insert_unique_node(__bkt, __code, __node), + true); + } + + template + template + typename _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _H1, _H2, _Hash, _RehashPolicy, + _Traits>::iterator + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _H1, _H2, _Hash, _RehashPolicy, _Traits>:: + _M_emplace(const_iterator __hint, std::false_type, _Args&&... __args) + { + // First build the node to get its hash code. + __node_type* __node = + this->_M_allocate_node(std::forward<_Args>(__args)...); + + __hash_code __code; + __try + { + __code = this->_M_hash_code(this->_M_extract()(__node->_M_v())); + } + __catch(...) + { + this->_M_deallocate_node(__node); + __throw_exception_again; + } + + return _M_insert_multi_node(__hint._M_cur, __code, __node); + } + + template + typename _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _H1, _H2, _Hash, _RehashPolicy, + _Traits>::iterator + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _H1, _H2, _Hash, _RehashPolicy, _Traits>:: + _M_insert_unique_node(size_type __bkt, __hash_code __code, + __node_type* __node) + { + const __rehash_state& __saved_state = _M_rehash_policy._M_state(); + std::pair __do_rehash + = _M_rehash_policy._M_need_rehash(_M_bucket_count, _M_element_count, 1); + + __try + { + if (__do_rehash.first) + { + _M_rehash(__do_rehash.second, __saved_state); + __bkt = _M_bucket_index(this->_M_extract()(__node->_M_v()), __code); + } + + this->_M_store_code(__node, __code); + + // Always insert at the beginning of the bucket. + _M_insert_bucket_begin(__bkt, __node); + ++_M_element_count; + return iterator(__node); + } + __catch(...) + { + this->_M_deallocate_node(__node); + __throw_exception_again; + } + } + + // Insert node, in bucket bkt if no rehash (assumes no element with its key + // already present). Take ownership of the node, deallocate it on exception. + template + typename _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _H1, _H2, _Hash, _RehashPolicy, + _Traits>::iterator + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _H1, _H2, _Hash, _RehashPolicy, _Traits>:: + _M_insert_multi_node(__node_type* __hint, __hash_code __code, + __node_type* __node) + { + const __rehash_state& __saved_state = _M_rehash_policy._M_state(); + std::pair __do_rehash + = _M_rehash_policy._M_need_rehash(_M_bucket_count, _M_element_count, 1); + + __try + { + if (__do_rehash.first) + _M_rehash(__do_rehash.second, __saved_state); + + this->_M_store_code(__node, __code); + const key_type& __k = this->_M_extract()(__node->_M_v()); + size_type __bkt = _M_bucket_index(__k, __code); + + // Find the node before an equivalent one or use hint if it exists and + // if it is equivalent. + __node_base* __prev + = __builtin_expect(__hint != nullptr, false) + && this->_M_equals(__k, __code, __hint) + ? __hint + : _M_find_before_node(__bkt, __k, __code); + if (__prev) + { + // Insert after the node before the equivalent one. + __node->_M_nxt = __prev->_M_nxt; + __prev->_M_nxt = __node; + if (__builtin_expect(__prev == __hint, false)) + // hint might be the last bucket node, in this case we need to + // update next bucket. + if (__node->_M_nxt + && !this->_M_equals(__k, __code, __node->_M_next())) + { + size_type __next_bkt = _M_bucket_index(__node->_M_next()); + if (__next_bkt != __bkt) + _M_buckets[__next_bkt] = __node; + } + } + else + // The inserted node has no equivalent in the + // hashtable. We must insert the new node at the + // beginning of the bucket to preserve equivalent + // elements' relative positions. + _M_insert_bucket_begin(__bkt, __node); + ++_M_element_count; + return iterator(__node); + } + __catch(...) + { + this->_M_deallocate_node(__node); + __throw_exception_again; + } + } + + // Insert v if no element with its key is already present. + template + template + std::pair::iterator, bool> + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _H1, _H2, _Hash, _RehashPolicy, _Traits>:: + _M_insert(_Arg&& __v, const _NodeGenerator& __node_gen, std::true_type) + { + const key_type& __k = this->_M_extract()(__v); + __hash_code __code = this->_M_hash_code(__k); + size_type __bkt = _M_bucket_index(__k, __code); + + __node_type* __n = _M_find_node(__bkt, __k, __code); + if (__n) + return std::make_pair(iterator(__n), false); + + __n = __node_gen(std::forward<_Arg>(__v)); + return std::make_pair(_M_insert_unique_node(__bkt, __code, __n), true); + } + + // Insert v unconditionally. + template + template + typename _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _H1, _H2, _Hash, _RehashPolicy, + _Traits>::iterator + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _H1, _H2, _Hash, _RehashPolicy, _Traits>:: + _M_insert(const_iterator __hint, _Arg&& __v, + const _NodeGenerator& __node_gen, + std::false_type) + { + // First compute the hash code so that we don't do anything if it + // throws. + __hash_code __code = this->_M_hash_code(this->_M_extract()(__v)); + + // Second allocate new node so that we don't rehash if it throws. + __node_type* __node = __node_gen(std::forward<_Arg>(__v)); + + return _M_insert_multi_node(__hint._M_cur, __code, __node); + } + + template + typename _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _H1, _H2, _Hash, _RehashPolicy, + _Traits>::iterator + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _H1, _H2, _Hash, _RehashPolicy, _Traits>:: + erase(const_iterator __it) + { + __node_type* __n = __it._M_cur; + std::size_t __bkt = _M_bucket_index(__n); + + // Look for previous node to unlink it from the erased one, this + // is why we need buckets to contain the before begin to make + // this search fast. + __node_base* __prev_n = _M_get_previous_node(__bkt, __n); + return _M_erase(__bkt, __prev_n, __n); + } + + template + typename _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _H1, _H2, _Hash, _RehashPolicy, + _Traits>::iterator + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _H1, _H2, _Hash, _RehashPolicy, _Traits>:: + _M_erase(size_type __bkt, __node_base* __prev_n, __node_type* __n) + { + if (__prev_n == _M_buckets[__bkt]) + _M_remove_bucket_begin(__bkt, __n->_M_next(), + __n->_M_nxt ? _M_bucket_index(__n->_M_next()) : 0); + else if (__n->_M_nxt) + { + size_type __next_bkt = _M_bucket_index(__n->_M_next()); + if (__next_bkt != __bkt) + _M_buckets[__next_bkt] = __prev_n; + } + + __prev_n->_M_nxt = __n->_M_nxt; + iterator __result(__n->_M_next()); + this->_M_deallocate_node(__n); + --_M_element_count; + + return __result; + } + + template + typename _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _H1, _H2, _Hash, _RehashPolicy, + _Traits>::size_type + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _H1, _H2, _Hash, _RehashPolicy, _Traits>:: + _M_erase(std::true_type, const key_type& __k) + { + __hash_code __code = this->_M_hash_code(__k); + std::size_t __bkt = _M_bucket_index(__k, __code); + + // Look for the node before the first matching node. + __node_base* __prev_n = _M_find_before_node(__bkt, __k, __code); + if (!__prev_n) + return 0; + + // We found a matching node, erase it. + __node_type* __n = static_cast<__node_type*>(__prev_n->_M_nxt); + _M_erase(__bkt, __prev_n, __n); + return 1; + } + + template + typename _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _H1, _H2, _Hash, _RehashPolicy, + _Traits>::size_type + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _H1, _H2, _Hash, _RehashPolicy, _Traits>:: + _M_erase(std::false_type, const key_type& __k) + { + __hash_code __code = this->_M_hash_code(__k); + std::size_t __bkt = _M_bucket_index(__k, __code); + + // Look for the node before the first matching node. + __node_base* __prev_n = _M_find_before_node(__bkt, __k, __code); + if (!__prev_n) + return 0; + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 526. Is it undefined if a function in the standard changes + // in parameters? + // We use one loop to find all matching nodes and another to deallocate + // them so that the key stays valid during the first loop. It might be + // invalidated indirectly when destroying nodes. + __node_type* __n = static_cast<__node_type*>(__prev_n->_M_nxt); + __node_type* __n_last = __n; + std::size_t __n_last_bkt = __bkt; + do + { + __n_last = __n_last->_M_next(); + if (!__n_last) + break; + __n_last_bkt = _M_bucket_index(__n_last); + } + while (__n_last_bkt == __bkt && this->_M_equals(__k, __code, __n_last)); + + // Deallocate nodes. + size_type __result = 0; + do + { + __node_type* __p = __n->_M_next(); + this->_M_deallocate_node(__n); + __n = __p; + ++__result; + --_M_element_count; + } + while (__n != __n_last); + + if (__prev_n == _M_buckets[__bkt]) + _M_remove_bucket_begin(__bkt, __n_last, __n_last_bkt); + else if (__n_last && __n_last_bkt != __bkt) + _M_buckets[__n_last_bkt] = __prev_n; + __prev_n->_M_nxt = __n_last; + return __result; + } + + template + typename _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _H1, _H2, _Hash, _RehashPolicy, + _Traits>::iterator + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _H1, _H2, _Hash, _RehashPolicy, _Traits>:: + erase(const_iterator __first, const_iterator __last) + { + __node_type* __n = __first._M_cur; + __node_type* __last_n = __last._M_cur; + if (__n == __last_n) + return iterator(__n); + + std::size_t __bkt = _M_bucket_index(__n); + + __node_base* __prev_n = _M_get_previous_node(__bkt, __n); + bool __is_bucket_begin = __n == _M_bucket_begin(__bkt); + std::size_t __n_bkt = __bkt; + for (;;) + { + do + { + __node_type* __tmp = __n; + __n = __n->_M_next(); + this->_M_deallocate_node(__tmp); + --_M_element_count; + if (!__n) + break; + __n_bkt = _M_bucket_index(__n); + } + while (__n != __last_n && __n_bkt == __bkt); + if (__is_bucket_begin) + _M_remove_bucket_begin(__bkt, __n, __n_bkt); + if (__n == __last_n) + break; + __is_bucket_begin = true; + __bkt = __n_bkt; + } + + if (__n && (__n_bkt != __bkt || __is_bucket_begin)) + _M_buckets[__n_bkt] = __prev_n; + __prev_n->_M_nxt = __n; + return iterator(__n); + } + + template + void + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _H1, _H2, _Hash, _RehashPolicy, _Traits>:: + clear() noexcept + { + this->_M_deallocate_nodes(_M_begin()); + __builtin_memset(_M_buckets, 0, _M_bucket_count * sizeof(__bucket_type)); + _M_element_count = 0; + _M_before_begin._M_nxt = nullptr; + } + + template + void + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _H1, _H2, _Hash, _RehashPolicy, _Traits>:: + rehash(size_type __n) + { + const __rehash_state& __saved_state = _M_rehash_policy._M_state(); + std::size_t __buckets + = std::max(_M_rehash_policy._M_bkt_for_elements(_M_element_count + 1), + __n); + __buckets = _M_rehash_policy._M_next_bkt(__buckets); + + if (__buckets != _M_bucket_count) + _M_rehash(__buckets, __saved_state); + else + // No rehash, restore previous state to keep a consistent state. + _M_rehash_policy._M_reset(__saved_state); + } + + template + void + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _H1, _H2, _Hash, _RehashPolicy, _Traits>:: + _M_rehash(size_type __n, const __rehash_state& __state) + { + __try + { + _M_rehash_aux(__n, __unique_keys()); + } + __catch(...) + { + // A failure here means that buckets allocation failed. We only + // have to restore hash policy previous state. + _M_rehash_policy._M_reset(__state); + __throw_exception_again; + } + } + + // Rehash when there is no equivalent elements. + template + void + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _H1, _H2, _Hash, _RehashPolicy, _Traits>:: + _M_rehash_aux(size_type __n, std::true_type) + { + __bucket_type* __new_buckets = _M_allocate_buckets(__n); + __node_type* __p = _M_begin(); + _M_before_begin._M_nxt = nullptr; + std::size_t __bbegin_bkt = 0; + while (__p) + { + __node_type* __next = __p->_M_next(); + std::size_t __bkt = __hash_code_base::_M_bucket_index(__p, __n); + if (!__new_buckets[__bkt]) + { + __p->_M_nxt = _M_before_begin._M_nxt; + _M_before_begin._M_nxt = __p; + __new_buckets[__bkt] = &_M_before_begin; + if (__p->_M_nxt) + __new_buckets[__bbegin_bkt] = __p; + __bbegin_bkt = __bkt; + } + else + { + __p->_M_nxt = __new_buckets[__bkt]->_M_nxt; + __new_buckets[__bkt]->_M_nxt = __p; + } + __p = __next; + } + + _M_deallocate_buckets(); + _M_bucket_count = __n; + _M_buckets = __new_buckets; + } + + // Rehash when there can be equivalent elements, preserve their relative + // order. + template + void + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _H1, _H2, _Hash, _RehashPolicy, _Traits>:: + _M_rehash_aux(size_type __n, std::false_type) + { + __bucket_type* __new_buckets = _M_allocate_buckets(__n); + + __node_type* __p = _M_begin(); + _M_before_begin._M_nxt = nullptr; + std::size_t __bbegin_bkt = 0; + std::size_t __prev_bkt = 0; + __node_type* __prev_p = nullptr; + bool __check_bucket = false; + + while (__p) + { + __node_type* __next = __p->_M_next(); + std::size_t __bkt = __hash_code_base::_M_bucket_index(__p, __n); + + if (__prev_p && __prev_bkt == __bkt) + { + // Previous insert was already in this bucket, we insert after + // the previously inserted one to preserve equivalent elements + // relative order. + __p->_M_nxt = __prev_p->_M_nxt; + __prev_p->_M_nxt = __p; + + // Inserting after a node in a bucket require to check that we + // haven't change the bucket last node, in this case next + // bucket containing its before begin node must be updated. We + // schedule a check as soon as we move out of the sequence of + // equivalent nodes to limit the number of checks. + __check_bucket = true; + } + else + { + if (__check_bucket) + { + // Check if we shall update the next bucket because of + // insertions into __prev_bkt bucket. + if (__prev_p->_M_nxt) + { + std::size_t __next_bkt + = __hash_code_base::_M_bucket_index(__prev_p->_M_next(), + __n); + if (__next_bkt != __prev_bkt) + __new_buckets[__next_bkt] = __prev_p; + } + __check_bucket = false; + } + + if (!__new_buckets[__bkt]) + { + __p->_M_nxt = _M_before_begin._M_nxt; + _M_before_begin._M_nxt = __p; + __new_buckets[__bkt] = &_M_before_begin; + if (__p->_M_nxt) + __new_buckets[__bbegin_bkt] = __p; + __bbegin_bkt = __bkt; + } + else + { + __p->_M_nxt = __new_buckets[__bkt]->_M_nxt; + __new_buckets[__bkt]->_M_nxt = __p; + } + } + __prev_p = __p; + __prev_bkt = __bkt; + __p = __next; + } + + if (__check_bucket && __prev_p->_M_nxt) + { + std::size_t __next_bkt + = __hash_code_base::_M_bucket_index(__prev_p->_M_next(), __n); + if (__next_bkt != __prev_bkt) + __new_buckets[__next_bkt] = __prev_p; + } + + _M_deallocate_buckets(); + _M_bucket_count = __n; + _M_buckets = __new_buckets; + } + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace std + +#endif // _HASHTABLE_H diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/hashtable_policy.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/hashtable_policy.h new file mode 100755 index 0000000..ef15b0e --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/hashtable_policy.h @@ -0,0 +1,2020 @@ +// Internal policy header for unordered_set and unordered_map -*- C++ -*- + +// Copyright (C) 2010-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file bits/hashtable_policy.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. + * @headername{unordered_map,unordered_set} + */ + +#ifndef _HASHTABLE_POLICY_H +#define _HASHTABLE_POLICY_H 1 + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + template + class _Hashtable; + +_GLIBCXX_END_NAMESPACE_VERSION + +namespace __detail +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /** + * @defgroup hashtable-detail Base and Implementation Classes + * @ingroup unordered_associative_containers + * @{ + */ + template + struct _Hashtable_base; + + // Helper function: return distance(first, last) for forward + // iterators, or 0 for input iterators. + template + inline typename std::iterator_traits<_Iterator>::difference_type + __distance_fw(_Iterator __first, _Iterator __last, + std::input_iterator_tag) + { return 0; } + + template + inline typename std::iterator_traits<_Iterator>::difference_type + __distance_fw(_Iterator __first, _Iterator __last, + std::forward_iterator_tag) + { return std::distance(__first, __last); } + + template + inline typename std::iterator_traits<_Iterator>::difference_type + __distance_fw(_Iterator __first, _Iterator __last) + { + typedef typename std::iterator_traits<_Iterator>::iterator_category _Tag; + return __distance_fw(__first, __last, _Tag()); + } + + // Helper type used to detect whether the hash functor is noexcept. + template + struct __is_noexcept_hash : std::integral_constant()(declval()))> + { }; + + struct _Identity + { + template + _Tp&& + operator()(_Tp&& __x) const + { return std::forward<_Tp>(__x); } + }; + + struct _Select1st + { + template + auto + operator()(_Tp&& __x) const + -> decltype(std::get<0>(std::forward<_Tp>(__x))) + { return std::get<0>(std::forward<_Tp>(__x)); } + }; + + template + struct _Hashtable_alloc; + + // Functor recycling a pool of nodes and using allocation once the pool is + // empty. + template + struct _ReuseOrAllocNode + { + private: + using __node_alloc_type = _NodeAlloc; + using __hashtable_alloc = _Hashtable_alloc<__node_alloc_type>; + using __value_alloc_type = typename __hashtable_alloc::__value_alloc_type; + using __value_alloc_traits = + typename __hashtable_alloc::__value_alloc_traits; + using __node_alloc_traits = + typename __hashtable_alloc::__node_alloc_traits; + using __node_type = typename __hashtable_alloc::__node_type; + + public: + _ReuseOrAllocNode(__node_type* __nodes, __hashtable_alloc& __h) + : _M_nodes(__nodes), _M_h(__h) { } + _ReuseOrAllocNode(const _ReuseOrAllocNode&) = delete; + + ~_ReuseOrAllocNode() + { _M_h._M_deallocate_nodes(_M_nodes); } + + template + __node_type* + operator()(_Arg&& __arg) const + { + if (_M_nodes) + { + __node_type* __node = _M_nodes; + _M_nodes = _M_nodes->_M_next(); + __node->_M_nxt = nullptr; + __value_alloc_type __a(_M_h._M_node_allocator()); + __value_alloc_traits::destroy(__a, __node->_M_valptr()); + __try + { + __value_alloc_traits::construct(__a, __node->_M_valptr(), + std::forward<_Arg>(__arg)); + } + __catch(...) + { + __node->~__node_type(); + __node_alloc_traits::deallocate(_M_h._M_node_allocator(), + __node, 1); + __throw_exception_again; + } + return __node; + } + return _M_h._M_allocate_node(std::forward<_Arg>(__arg)); + } + + private: + mutable __node_type* _M_nodes; + __hashtable_alloc& _M_h; + }; + + // Functor similar to the previous one but without any pool of nodes to + // recycle. + template + struct _AllocNode + { + private: + using __hashtable_alloc = _Hashtable_alloc<_NodeAlloc>; + using __node_type = typename __hashtable_alloc::__node_type; + + public: + _AllocNode(__hashtable_alloc& __h) + : _M_h(__h) { } + + template + __node_type* + operator()(_Arg&& __arg) const + { return _M_h._M_allocate_node(std::forward<_Arg>(__arg)); } + + private: + __hashtable_alloc& _M_h; + }; + + // Auxiliary types used for all instantiations of _Hashtable nodes + // and iterators. + + /** + * struct _Hashtable_traits + * + * Important traits for hash tables. + * + * @tparam _Cache_hash_code Boolean value. True if the value of + * the hash function is stored along with the value. This is a + * time-space tradeoff. Storing it may improve lookup speed by + * reducing the number of times we need to call the _Equal + * function. + * + * @tparam _Constant_iterators Boolean value. True if iterator and + * const_iterator are both constant iterator types. This is true + * for unordered_set and unordered_multiset, false for + * unordered_map and unordered_multimap. + * + * @tparam _Unique_keys Boolean value. True if the return value + * of _Hashtable::count(k) is always at most one, false if it may + * be an arbitrary number. This is true for unordered_set and + * unordered_map, false for unordered_multiset and + * unordered_multimap. + */ + template + struct _Hashtable_traits + { + template + using __bool_constant = integral_constant; + + using __hash_cached = __bool_constant<_Cache_hash_code>; + using __constant_iterators = __bool_constant<_Constant_iterators>; + using __unique_keys = __bool_constant<_Unique_keys>; + }; + + /** + * struct _Hash_node_base + * + * Nodes, used to wrap elements stored in the hash table. A policy + * template parameter of class template _Hashtable controls whether + * nodes also store a hash code. In some cases (e.g. strings) this + * may be a performance win. + */ + struct _Hash_node_base + { + _Hash_node_base* _M_nxt; + + _Hash_node_base() noexcept : _M_nxt() { } + + _Hash_node_base(_Hash_node_base* __next) noexcept : _M_nxt(__next) { } + }; + + /** + * struct _Hash_node_value_base + * + * Node type with the value to store. + */ + template + struct _Hash_node_value_base : _Hash_node_base + { + typedef _Value value_type; + + __gnu_cxx::__aligned_buffer<_Value> _M_storage; + + _Value* + _M_valptr() noexcept + { return _M_storage._M_ptr(); } + + const _Value* + _M_valptr() const noexcept + { return _M_storage._M_ptr(); } + + _Value& + _M_v() noexcept + { return *_M_valptr(); } + + const _Value& + _M_v() const noexcept + { return *_M_valptr(); } + }; + + /** + * Primary template struct _Hash_node. + */ + template + struct _Hash_node; + + /** + * Specialization for nodes with caches, struct _Hash_node. + * + * Base class is __detail::_Hash_node_value_base. + */ + template + struct _Hash_node<_Value, true> : _Hash_node_value_base<_Value> + { + std::size_t _M_hash_code; + + _Hash_node* + _M_next() const noexcept + { return static_cast<_Hash_node*>(this->_M_nxt); } + }; + + /** + * Specialization for nodes without caches, struct _Hash_node. + * + * Base class is __detail::_Hash_node_value_base. + */ + template + struct _Hash_node<_Value, false> : _Hash_node_value_base<_Value> + { + _Hash_node* + _M_next() const noexcept + { return static_cast<_Hash_node*>(this->_M_nxt); } + }; + + /// Base class for node iterators. + template + struct _Node_iterator_base + { + using __node_type = _Hash_node<_Value, _Cache_hash_code>; + + __node_type* _M_cur; + + _Node_iterator_base(__node_type* __p) noexcept + : _M_cur(__p) { } + + void + _M_incr() noexcept + { _M_cur = _M_cur->_M_next(); } + }; + + template + inline bool + operator==(const _Node_iterator_base<_Value, _Cache_hash_code>& __x, + const _Node_iterator_base<_Value, _Cache_hash_code >& __y) + noexcept + { return __x._M_cur == __y._M_cur; } + + template + inline bool + operator!=(const _Node_iterator_base<_Value, _Cache_hash_code>& __x, + const _Node_iterator_base<_Value, _Cache_hash_code>& __y) + noexcept + { return __x._M_cur != __y._M_cur; } + + /// Node iterators, used to iterate through all the hashtable. + template + struct _Node_iterator + : public _Node_iterator_base<_Value, __cache> + { + private: + using __base_type = _Node_iterator_base<_Value, __cache>; + using __node_type = typename __base_type::__node_type; + + public: + typedef _Value value_type; + typedef std::ptrdiff_t difference_type; + typedef std::forward_iterator_tag iterator_category; + + using pointer = typename std::conditional<__constant_iterators, + const _Value*, _Value*>::type; + + using reference = typename std::conditional<__constant_iterators, + const _Value&, _Value&>::type; + + _Node_iterator() noexcept + : __base_type(0) { } + + explicit + _Node_iterator(__node_type* __p) noexcept + : __base_type(__p) { } + + reference + operator*() const noexcept + { return this->_M_cur->_M_v(); } + + pointer + operator->() const noexcept + { return this->_M_cur->_M_valptr(); } + + _Node_iterator& + operator++() noexcept + { + this->_M_incr(); + return *this; + } + + _Node_iterator + operator++(int) noexcept + { + _Node_iterator __tmp(*this); + this->_M_incr(); + return __tmp; + } + }; + + /// Node const_iterators, used to iterate through all the hashtable. + template + struct _Node_const_iterator + : public _Node_iterator_base<_Value, __cache> + { + private: + using __base_type = _Node_iterator_base<_Value, __cache>; + using __node_type = typename __base_type::__node_type; + + public: + typedef _Value value_type; + typedef std::ptrdiff_t difference_type; + typedef std::forward_iterator_tag iterator_category; + + typedef const _Value* pointer; + typedef const _Value& reference; + + _Node_const_iterator() noexcept + : __base_type(0) { } + + explicit + _Node_const_iterator(__node_type* __p) noexcept + : __base_type(__p) { } + + _Node_const_iterator(const _Node_iterator<_Value, __constant_iterators, + __cache>& __x) noexcept + : __base_type(__x._M_cur) { } + + reference + operator*() const noexcept + { return this->_M_cur->_M_v(); } + + pointer + operator->() const noexcept + { return this->_M_cur->_M_valptr(); } + + _Node_const_iterator& + operator++() noexcept + { + this->_M_incr(); + return *this; + } + + _Node_const_iterator + operator++(int) noexcept + { + _Node_const_iterator __tmp(*this); + this->_M_incr(); + return __tmp; + } + }; + + // Many of class template _Hashtable's template parameters are policy + // classes. These are defaults for the policies. + + /// Default range hashing function: use division to fold a large number + /// into the range [0, N). + struct _Mod_range_hashing + { + typedef std::size_t first_argument_type; + typedef std::size_t second_argument_type; + typedef std::size_t result_type; + + result_type + operator()(first_argument_type __num, + second_argument_type __den) const noexcept + { return __num % __den; } + }; + + /// Default ranged hash function H. In principle it should be a + /// function object composed from objects of type H1 and H2 such that + /// h(k, N) = h2(h1(k), N), but that would mean making extra copies of + /// h1 and h2. So instead we'll just use a tag to tell class template + /// hashtable to do that composition. + struct _Default_ranged_hash { }; + + /// Default value for rehash policy. Bucket size is (usually) the + /// smallest prime that keeps the load factor small enough. + struct _Prime_rehash_policy + { + _Prime_rehash_policy(float __z = 1.0) + : _M_max_load_factor(__z), _M_next_resize(0) { } + + float + max_load_factor() const noexcept + { return _M_max_load_factor; } + + // Return a bucket size no smaller than n. + std::size_t + _M_next_bkt(std::size_t __n) const; + + // Return a bucket count appropriate for n elements + std::size_t + _M_bkt_for_elements(std::size_t __n) const + { return __builtin_ceil(__n / (long double)_M_max_load_factor); } + + // __n_bkt is current bucket count, __n_elt is current element count, + // and __n_ins is number of elements to be inserted. Do we need to + // increase bucket count? If so, return make_pair(true, n), where n + // is the new bucket count. If not, return make_pair(false, 0). + std::pair + _M_need_rehash(std::size_t __n_bkt, std::size_t __n_elt, + std::size_t __n_ins) const; + + typedef std::size_t _State; + + _State + _M_state() const + { return _M_next_resize; } + + void + _M_reset() noexcept + { _M_next_resize = 0; } + + void + _M_reset(_State __state) + { _M_next_resize = __state; } + + enum { _S_n_primes = sizeof(unsigned long) != 8 ? 256 : 256 + 48 }; + + static const std::size_t _S_growth_factor = 2; + + float _M_max_load_factor; + mutable std::size_t _M_next_resize; + }; + + // Base classes for std::_Hashtable. We define these base classes + // because in some cases we want to do different things depending on + // the value of a policy class. In some cases the policy class + // affects which member functions and nested typedefs are defined; + // we handle that by specializing base class templates. Several of + // the base class templates need to access other members of class + // template _Hashtable, so we use a variant of the "Curiously + // Recurring Template Pattern" (CRTP) technique. + + /** + * Primary class template _Map_base. + * + * If the hashtable has a value type of the form pair and a + * key extraction policy (_ExtractKey) that returns the first part + * of the pair, the hashtable gets a mapped_type typedef. If it + * satisfies those criteria and also has unique keys, then it also + * gets an operator[]. + */ + template + struct _Map_base { }; + + /// Partial specialization, __unique_keys set to false. + template + struct _Map_base<_Key, _Pair, _Alloc, _Select1st, _Equal, + _H1, _H2, _Hash, _RehashPolicy, _Traits, false> + { + using mapped_type = typename std::tuple_element<1, _Pair>::type; + }; + + /// Partial specialization, __unique_keys set to true. + template + struct _Map_base<_Key, _Pair, _Alloc, _Select1st, _Equal, + _H1, _H2, _Hash, _RehashPolicy, _Traits, true> + { + private: + using __hashtable_base = __detail::_Hashtable_base<_Key, _Pair, + _Select1st, + _Equal, _H1, _H2, _Hash, + _Traits>; + + using __hashtable = _Hashtable<_Key, _Pair, _Alloc, + _Select1st, _Equal, + _H1, _H2, _Hash, _RehashPolicy, _Traits>; + + using __hash_code = typename __hashtable_base::__hash_code; + using __node_type = typename __hashtable_base::__node_type; + + public: + using key_type = typename __hashtable_base::key_type; + using iterator = typename __hashtable_base::iterator; + using mapped_type = typename std::tuple_element<1, _Pair>::type; + + mapped_type& + operator[](const key_type& __k); + + mapped_type& + operator[](key_type&& __k); + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR 761. unordered_map needs an at() member function. + mapped_type& + at(const key_type& __k); + + const mapped_type& + at(const key_type& __k) const; + }; + + template + typename _Map_base<_Key, _Pair, _Alloc, _Select1st, _Equal, + _H1, _H2, _Hash, _RehashPolicy, _Traits, true> + ::mapped_type& + _Map_base<_Key, _Pair, _Alloc, _Select1st, _Equal, + _H1, _H2, _Hash, _RehashPolicy, _Traits, true>:: + operator[](const key_type& __k) + { + __hashtable* __h = static_cast<__hashtable*>(this); + __hash_code __code = __h->_M_hash_code(__k); + std::size_t __n = __h->_M_bucket_index(__k, __code); + __node_type* __p = __h->_M_find_node(__n, __k, __code); + + if (!__p) + { + __p = __h->_M_allocate_node(std::piecewise_construct, + std::tuple(__k), + std::tuple<>()); + return __h->_M_insert_unique_node(__n, __code, __p)->second; + } + + return __p->_M_v().second; + } + + template + typename _Map_base<_Key, _Pair, _Alloc, _Select1st, _Equal, + _H1, _H2, _Hash, _RehashPolicy, _Traits, true> + ::mapped_type& + _Map_base<_Key, _Pair, _Alloc, _Select1st, _Equal, + _H1, _H2, _Hash, _RehashPolicy, _Traits, true>:: + operator[](key_type&& __k) + { + __hashtable* __h = static_cast<__hashtable*>(this); + __hash_code __code = __h->_M_hash_code(__k); + std::size_t __n = __h->_M_bucket_index(__k, __code); + __node_type* __p = __h->_M_find_node(__n, __k, __code); + + if (!__p) + { + __p = __h->_M_allocate_node(std::piecewise_construct, + std::forward_as_tuple(std::move(__k)), + std::tuple<>()); + return __h->_M_insert_unique_node(__n, __code, __p)->second; + } + + return __p->_M_v().second; + } + + template + typename _Map_base<_Key, _Pair, _Alloc, _Select1st, _Equal, + _H1, _H2, _Hash, _RehashPolicy, _Traits, true> + ::mapped_type& + _Map_base<_Key, _Pair, _Alloc, _Select1st, _Equal, + _H1, _H2, _Hash, _RehashPolicy, _Traits, true>:: + at(const key_type& __k) + { + __hashtable* __h = static_cast<__hashtable*>(this); + __hash_code __code = __h->_M_hash_code(__k); + std::size_t __n = __h->_M_bucket_index(__k, __code); + __node_type* __p = __h->_M_find_node(__n, __k, __code); + + if (!__p) + __throw_out_of_range(__N("_Map_base::at")); + return __p->_M_v().second; + } + + template + const typename _Map_base<_Key, _Pair, _Alloc, _Select1st, + _Equal, _H1, _H2, _Hash, _RehashPolicy, + _Traits, true>::mapped_type& + _Map_base<_Key, _Pair, _Alloc, _Select1st, _Equal, + _H1, _H2, _Hash, _RehashPolicy, _Traits, true>:: + at(const key_type& __k) const + { + const __hashtable* __h = static_cast(this); + __hash_code __code = __h->_M_hash_code(__k); + std::size_t __n = __h->_M_bucket_index(__k, __code); + __node_type* __p = __h->_M_find_node(__n, __k, __code); + + if (!__p) + __throw_out_of_range(__N("_Map_base::at")); + return __p->_M_v().second; + } + + /** + * Primary class template _Insert_base. + * + * insert member functions appropriate to all _Hashtables. + */ + template + struct _Insert_base + { + protected: + using __hashtable = _Hashtable<_Key, _Value, _Alloc, _ExtractKey, + _Equal, _H1, _H2, _Hash, + _RehashPolicy, _Traits>; + + using __hashtable_base = _Hashtable_base<_Key, _Value, _ExtractKey, + _Equal, _H1, _H2, _Hash, + _Traits>; + + using value_type = typename __hashtable_base::value_type; + using iterator = typename __hashtable_base::iterator; + using const_iterator = typename __hashtable_base::const_iterator; + using size_type = typename __hashtable_base::size_type; + + using __unique_keys = typename __hashtable_base::__unique_keys; + using __ireturn_type = typename __hashtable_base::__ireturn_type; + using __node_type = _Hash_node<_Value, _Traits::__hash_cached::value>; + using __node_alloc_type = + typename __alloctr_rebind<_Alloc, __node_type>::__type; + using __node_gen_type = _AllocNode<__node_alloc_type>; + + __hashtable& + _M_conjure_hashtable() + { return *(static_cast<__hashtable*>(this)); } + + template + void + _M_insert_range(_InputIterator __first, _InputIterator __last, + const _NodeGetter&); + + public: + __ireturn_type + insert(const value_type& __v) + { + __hashtable& __h = _M_conjure_hashtable(); + __node_gen_type __node_gen(__h); + return __h._M_insert(__v, __node_gen, __unique_keys()); + } + + iterator + insert(const_iterator __hint, const value_type& __v) + { + __hashtable& __h = _M_conjure_hashtable(); + __node_gen_type __node_gen(__h); + return __h._M_insert(__hint, __v, __node_gen, __unique_keys()); + } + + void + insert(initializer_list __l) + { this->insert(__l.begin(), __l.end()); } + + template + void + insert(_InputIterator __first, _InputIterator __last) + { + __hashtable& __h = _M_conjure_hashtable(); + __node_gen_type __node_gen(__h); + return _M_insert_range(__first, __last, __node_gen); + } + }; + + template + template + void + _Insert_base<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, + _RehashPolicy, _Traits>:: + _M_insert_range(_InputIterator __first, _InputIterator __last, + const _NodeGetter& __node_gen) + { + using __rehash_type = typename __hashtable::__rehash_type; + using __rehash_state = typename __hashtable::__rehash_state; + using pair_type = std::pair; + + size_type __n_elt = __detail::__distance_fw(__first, __last); + + __hashtable& __h = _M_conjure_hashtable(); + __rehash_type& __rehash = __h._M_rehash_policy; + const __rehash_state& __saved_state = __rehash._M_state(); + pair_type __do_rehash = __rehash._M_need_rehash(__h._M_bucket_count, + __h._M_element_count, + __n_elt); + + if (__do_rehash.first) + __h._M_rehash(__do_rehash.second, __saved_state); + + for (; __first != __last; ++__first) + __h._M_insert(*__first, __node_gen, __unique_keys()); + } + + /** + * Primary class template _Insert. + * + * Select insert member functions appropriate to _Hashtable policy choices. + */ + template + struct _Insert; + + /// Specialization. + template + struct _Insert<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, + _RehashPolicy, _Traits, true, true> + : public _Insert_base<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _H1, _H2, _Hash, _RehashPolicy, _Traits> + { + using __base_type = _Insert_base<_Key, _Value, _Alloc, _ExtractKey, + _Equal, _H1, _H2, _Hash, + _RehashPolicy, _Traits>; + using value_type = typename __base_type::value_type; + using iterator = typename __base_type::iterator; + using const_iterator = typename __base_type::const_iterator; + + using __unique_keys = typename __base_type::__unique_keys; + using __hashtable = typename __base_type::__hashtable; + using __node_gen_type = typename __base_type::__node_gen_type; + + using __base_type::insert; + + std::pair + insert(value_type&& __v) + { + __hashtable& __h = this->_M_conjure_hashtable(); + __node_gen_type __node_gen(__h); + return __h._M_insert(std::move(__v), __node_gen, __unique_keys()); + } + + iterator + insert(const_iterator __hint, value_type&& __v) + { + __hashtable& __h = this->_M_conjure_hashtable(); + __node_gen_type __node_gen(__h); + return __h._M_insert(__hint, std::move(__v), __node_gen, + __unique_keys()); + } + }; + + /// Specialization. + template + struct _Insert<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, + _RehashPolicy, _Traits, true, false> + : public _Insert_base<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _H1, _H2, _Hash, _RehashPolicy, _Traits> + { + using __base_type = _Insert_base<_Key, _Value, _Alloc, _ExtractKey, + _Equal, _H1, _H2, _Hash, + _RehashPolicy, _Traits>; + using value_type = typename __base_type::value_type; + using iterator = typename __base_type::iterator; + using const_iterator = typename __base_type::const_iterator; + + using __unique_keys = typename __base_type::__unique_keys; + using __hashtable = typename __base_type::__hashtable; + using __node_gen_type = typename __base_type::__node_gen_type; + + using __base_type::insert; + + iterator + insert(value_type&& __v) + { + __hashtable& __h = this->_M_conjure_hashtable(); + __node_gen_type __node_gen(__h); + return __h._M_insert(std::move(__v), __node_gen, __unique_keys()); + } + + iterator + insert(const_iterator __hint, value_type&& __v) + { + __hashtable& __h = this->_M_conjure_hashtable(); + __node_gen_type __node_gen(__h); + return __h._M_insert(__hint, std::move(__v), __node_gen, + __unique_keys()); + } + }; + + /// Specialization. + template + struct _Insert<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash, + _RehashPolicy, _Traits, false, _Unique_keys> + : public _Insert_base<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _H1, _H2, _Hash, _RehashPolicy, _Traits> + { + using __base_type = _Insert_base<_Key, _Value, _Alloc, _ExtractKey, + _Equal, _H1, _H2, _Hash, + _RehashPolicy, _Traits>; + using value_type = typename __base_type::value_type; + using iterator = typename __base_type::iterator; + using const_iterator = typename __base_type::const_iterator; + + using __unique_keys = typename __base_type::__unique_keys; + using __hashtable = typename __base_type::__hashtable; + using __ireturn_type = typename __base_type::__ireturn_type; + + using __base_type::insert; + + template + using __is_cons = std::is_constructible; + + template + using _IFcons = std::enable_if<__is_cons<_Pair>::value>; + + template + using _IFconsp = typename _IFcons<_Pair>::type; + + template> + __ireturn_type + insert(_Pair&& __v) + { + __hashtable& __h = this->_M_conjure_hashtable(); + return __h._M_emplace(__unique_keys(), std::forward<_Pair>(__v)); + } + + template> + iterator + insert(const_iterator __hint, _Pair&& __v) + { + __hashtable& __h = this->_M_conjure_hashtable(); + return __h._M_emplace(__hint, __unique_keys(), + std::forward<_Pair>(__v)); + } + }; + + /** + * Primary class template _Rehash_base. + * + * Give hashtable the max_load_factor functions and reserve iff the + * rehash policy is _Prime_rehash_policy. + */ + template + struct _Rehash_base; + + /// Specialization. + template + struct _Rehash_base<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _H1, _H2, _Hash, _Prime_rehash_policy, _Traits> + { + using __hashtable = _Hashtable<_Key, _Value, _Alloc, _ExtractKey, + _Equal, _H1, _H2, _Hash, + _Prime_rehash_policy, _Traits>; + + float + max_load_factor() const noexcept + { + const __hashtable* __this = static_cast(this); + return __this->__rehash_policy().max_load_factor(); + } + + void + max_load_factor(float __z) + { + __hashtable* __this = static_cast<__hashtable*>(this); + __this->__rehash_policy(_Prime_rehash_policy(__z)); + } + + void + reserve(std::size_t __n) + { + __hashtable* __this = static_cast<__hashtable*>(this); + __this->rehash(__builtin_ceil(__n / max_load_factor())); + } + }; + + /** + * Primary class template _Hashtable_ebo_helper. + * + * Helper class using EBO when it is not forbidden (the type is not + * final) and when it is worth it (the type is empty.) + */ + template + struct _Hashtable_ebo_helper; + + /// Specialization using EBO. + template + struct _Hashtable_ebo_helper<_Nm, _Tp, true> + : private _Tp + { + _Hashtable_ebo_helper() = default; + + template + _Hashtable_ebo_helper(_OtherTp&& __tp) + : _Tp(std::forward<_OtherTp>(__tp)) + { } + + static const _Tp& + _S_cget(const _Hashtable_ebo_helper& __eboh) + { return static_cast(__eboh); } + + static _Tp& + _S_get(_Hashtable_ebo_helper& __eboh) + { return static_cast<_Tp&>(__eboh); } + }; + + /// Specialization not using EBO. + template + struct _Hashtable_ebo_helper<_Nm, _Tp, false> + { + _Hashtable_ebo_helper() = default; + + template + _Hashtable_ebo_helper(_OtherTp&& __tp) + : _M_tp(std::forward<_OtherTp>(__tp)) + { } + + static const _Tp& + _S_cget(const _Hashtable_ebo_helper& __eboh) + { return __eboh._M_tp; } + + static _Tp& + _S_get(_Hashtable_ebo_helper& __eboh) + { return __eboh._M_tp; } + + private: + _Tp _M_tp; + }; + + /** + * Primary class template _Local_iterator_base. + * + * Base class for local iterators, used to iterate within a bucket + * but not between buckets. + */ + template + struct _Local_iterator_base; + + /** + * Primary class template _Hash_code_base. + * + * Encapsulates two policy issues that aren't quite orthogonal. + * (1) the difference between using a ranged hash function and using + * the combination of a hash function and a range-hashing function. + * In the former case we don't have such things as hash codes, so + * we have a dummy type as placeholder. + * (2) Whether or not we cache hash codes. Caching hash codes is + * meaningless if we have a ranged hash function. + * + * We also put the key extraction objects here, for convenience. + * Each specialization derives from one or more of the template + * parameters to benefit from Ebo. This is important as this type + * is inherited in some cases by the _Local_iterator_base type used + * to implement local_iterator and const_local_iterator. As with + * any iterator type we prefer to make it as small as possible. + * + * Primary template is unused except as a hook for specializations. + */ + template + struct _Hash_code_base; + + /// Specialization: ranged hash function, no caching hash codes. H1 + /// and H2 are provided but ignored. We define a dummy hash code type. + template + struct _Hash_code_base<_Key, _Value, _ExtractKey, _H1, _H2, _Hash, false> + : private _Hashtable_ebo_helper<0, _ExtractKey>, + private _Hashtable_ebo_helper<1, _Hash> + { + private: + using __ebo_extract_key = _Hashtable_ebo_helper<0, _ExtractKey>; + using __ebo_hash = _Hashtable_ebo_helper<1, _Hash>; + + protected: + typedef void* __hash_code; + typedef _Hash_node<_Value, false> __node_type; + + // We need the default constructor for the local iterators. + _Hash_code_base() = default; + + _Hash_code_base(const _ExtractKey& __ex, const _H1&, const _H2&, + const _Hash& __h) + : __ebo_extract_key(__ex), __ebo_hash(__h) { } + + __hash_code + _M_hash_code(const _Key& __key) const + { return 0; } + + std::size_t + _M_bucket_index(const _Key& __k, __hash_code, std::size_t __n) const + { return _M_ranged_hash()(__k, __n); } + + std::size_t + _M_bucket_index(const __node_type* __p, std::size_t __n) const + noexcept( noexcept(declval()(declval(), + (std::size_t)0)) ) + { return _M_ranged_hash()(_M_extract()(__p->_M_v()), __n); } + + void + _M_store_code(__node_type*, __hash_code) const + { } + + void + _M_copy_code(__node_type*, const __node_type*) const + { } + + void + _M_swap(_Hash_code_base& __x) + { + std::swap(_M_extract(), __x._M_extract()); + std::swap(_M_ranged_hash(), __x._M_ranged_hash()); + } + + const _ExtractKey& + _M_extract() const { return __ebo_extract_key::_S_cget(*this); } + + _ExtractKey& + _M_extract() { return __ebo_extract_key::_S_get(*this); } + + const _Hash& + _M_ranged_hash() const { return __ebo_hash::_S_cget(*this); } + + _Hash& + _M_ranged_hash() { return __ebo_hash::_S_get(*this); } + }; + + // No specialization for ranged hash function while caching hash codes. + // That combination is meaningless, and trying to do it is an error. + + /// Specialization: ranged hash function, cache hash codes. This + /// combination is meaningless, so we provide only a declaration + /// and no definition. + template + struct _Hash_code_base<_Key, _Value, _ExtractKey, _H1, _H2, _Hash, true>; + + /// Specialization: hash function and range-hashing function, no + /// caching of hash codes. + /// Provides typedef and accessor required by C++ 11. + template + struct _Hash_code_base<_Key, _Value, _ExtractKey, _H1, _H2, + _Default_ranged_hash, false> + : private _Hashtable_ebo_helper<0, _ExtractKey>, + private _Hashtable_ebo_helper<1, _H1>, + private _Hashtable_ebo_helper<2, _H2> + { + private: + using __ebo_extract_key = _Hashtable_ebo_helper<0, _ExtractKey>; + using __ebo_h1 = _Hashtable_ebo_helper<1, _H1>; + using __ebo_h2 = _Hashtable_ebo_helper<2, _H2>; + + // Gives the local iterator implementation access to _M_bucket_index(). + friend struct _Local_iterator_base<_Key, _Value, _ExtractKey, _H1, _H2, + _Default_ranged_hash, false>; + + public: + typedef _H1 hasher; + + hasher + hash_function() const + { return _M_h1(); } + + protected: + typedef std::size_t __hash_code; + typedef _Hash_node<_Value, false> __node_type; + + // We need the default constructor for the local iterators. + _Hash_code_base() = default; + + _Hash_code_base(const _ExtractKey& __ex, + const _H1& __h1, const _H2& __h2, + const _Default_ranged_hash&) + : __ebo_extract_key(__ex), __ebo_h1(__h1), __ebo_h2(__h2) { } + + __hash_code + _M_hash_code(const _Key& __k) const + { return _M_h1()(__k); } + + std::size_t + _M_bucket_index(const _Key&, __hash_code __c, std::size_t __n) const + { return _M_h2()(__c, __n); } + + std::size_t + _M_bucket_index(const __node_type* __p, std::size_t __n) const + noexcept( noexcept(declval()(declval())) + && noexcept(declval()((__hash_code)0, + (std::size_t)0)) ) + { return _M_h2()(_M_h1()(_M_extract()(__p->_M_v())), __n); } + + void + _M_store_code(__node_type*, __hash_code) const + { } + + void + _M_copy_code(__node_type*, const __node_type*) const + { } + + void + _M_swap(_Hash_code_base& __x) + { + std::swap(_M_extract(), __x._M_extract()); + std::swap(_M_h1(), __x._M_h1()); + std::swap(_M_h2(), __x._M_h2()); + } + + const _ExtractKey& + _M_extract() const { return __ebo_extract_key::_S_cget(*this); } + + _ExtractKey& + _M_extract() { return __ebo_extract_key::_S_get(*this); } + + const _H1& + _M_h1() const { return __ebo_h1::_S_cget(*this); } + + _H1& + _M_h1() { return __ebo_h1::_S_get(*this); } + + const _H2& + _M_h2() const { return __ebo_h2::_S_cget(*this); } + + _H2& + _M_h2() { return __ebo_h2::_S_get(*this); } + }; + + /// Specialization: hash function and range-hashing function, + /// caching hash codes. H is provided but ignored. Provides + /// typedef and accessor required by C++ 11. + template + struct _Hash_code_base<_Key, _Value, _ExtractKey, _H1, _H2, + _Default_ranged_hash, true> + : private _Hashtable_ebo_helper<0, _ExtractKey>, + private _Hashtable_ebo_helper<1, _H1>, + private _Hashtable_ebo_helper<2, _H2> + { + private: + // Gives the local iterator implementation access to _M_h2(). + friend struct _Local_iterator_base<_Key, _Value, _ExtractKey, _H1, _H2, + _Default_ranged_hash, true>; + + using __ebo_extract_key = _Hashtable_ebo_helper<0, _ExtractKey>; + using __ebo_h1 = _Hashtable_ebo_helper<1, _H1>; + using __ebo_h2 = _Hashtable_ebo_helper<2, _H2>; + + public: + typedef _H1 hasher; + + hasher + hash_function() const + { return _M_h1(); } + + protected: + typedef std::size_t __hash_code; + typedef _Hash_node<_Value, true> __node_type; + + _Hash_code_base(const _ExtractKey& __ex, + const _H1& __h1, const _H2& __h2, + const _Default_ranged_hash&) + : __ebo_extract_key(__ex), __ebo_h1(__h1), __ebo_h2(__h2) { } + + __hash_code + _M_hash_code(const _Key& __k) const + { return _M_h1()(__k); } + + std::size_t + _M_bucket_index(const _Key&, __hash_code __c, + std::size_t __n) const + { return _M_h2()(__c, __n); } + + std::size_t + _M_bucket_index(const __node_type* __p, std::size_t __n) const + noexcept( noexcept(declval()((__hash_code)0, + (std::size_t)0)) ) + { return _M_h2()(__p->_M_hash_code, __n); } + + void + _M_store_code(__node_type* __n, __hash_code __c) const + { __n->_M_hash_code = __c; } + + void + _M_copy_code(__node_type* __to, const __node_type* __from) const + { __to->_M_hash_code = __from->_M_hash_code; } + + void + _M_swap(_Hash_code_base& __x) + { + std::swap(_M_extract(), __x._M_extract()); + std::swap(_M_h1(), __x._M_h1()); + std::swap(_M_h2(), __x._M_h2()); + } + + const _ExtractKey& + _M_extract() const { return __ebo_extract_key::_S_cget(*this); } + + _ExtractKey& + _M_extract() { return __ebo_extract_key::_S_get(*this); } + + const _H1& + _M_h1() const { return __ebo_h1::_S_cget(*this); } + + _H1& + _M_h1() { return __ebo_h1::_S_get(*this); } + + const _H2& + _M_h2() const { return __ebo_h2::_S_cget(*this); } + + _H2& + _M_h2() { return __ebo_h2::_S_get(*this); } + }; + + /** + * Primary class template _Equal_helper. + * + */ + template + struct _Equal_helper; + + /// Specialization. + template + struct _Equal_helper<_Key, _Value, _ExtractKey, _Equal, _HashCodeType, true> + { + static bool + _S_equals(const _Equal& __eq, const _ExtractKey& __extract, + const _Key& __k, _HashCodeType __c, _Hash_node<_Value, true>* __n) + { return __c == __n->_M_hash_code && __eq(__k, __extract(__n->_M_v())); } + }; + + /// Specialization. + template + struct _Equal_helper<_Key, _Value, _ExtractKey, _Equal, _HashCodeType, false> + { + static bool + _S_equals(const _Equal& __eq, const _ExtractKey& __extract, + const _Key& __k, _HashCodeType, _Hash_node<_Value, false>* __n) + { return __eq(__k, __extract(__n->_M_v())); } + }; + + + /// Partial specialization used when nodes contain a cached hash code. + template + struct _Local_iterator_base<_Key, _Value, _ExtractKey, + _H1, _H2, _Hash, true> + : private _Hashtable_ebo_helper<0, _H2> + { + protected: + using __base_type = _Hashtable_ebo_helper<0, _H2>; + using __hash_code_base = _Hash_code_base<_Key, _Value, _ExtractKey, + _H1, _H2, _Hash, true>; + + _Local_iterator_base() = default; + _Local_iterator_base(const __hash_code_base& __base, + _Hash_node<_Value, true>* __p, + std::size_t __bkt, std::size_t __bkt_count) + : __base_type(__base._M_h2()), + _M_cur(__p), _M_bucket(__bkt), _M_bucket_count(__bkt_count) { } + + void + _M_incr() + { + _M_cur = _M_cur->_M_next(); + if (_M_cur) + { + std::size_t __bkt + = __base_type::_S_get(*this)(_M_cur->_M_hash_code, + _M_bucket_count); + if (__bkt != _M_bucket) + _M_cur = nullptr; + } + } + + _Hash_node<_Value, true>* _M_cur; + std::size_t _M_bucket; + std::size_t _M_bucket_count; + + public: + const void* + _M_curr() const { return _M_cur; } // for equality ops + + std::size_t + _M_get_bucket() const { return _M_bucket; } // for debug mode + }; + + // Uninitialized storage for a _Hash_code_base. + // This type is DefaultConstructible and Assignable even if the + // _Hash_code_base type isn't, so that _Local_iterator_base<..., false> + // can be DefaultConstructible and Assignable. + template::value> + struct _Hash_code_storage + { + __gnu_cxx::__aligned_buffer<_Tp> _M_storage; + + _Tp* + _M_h() { return _M_storage._M_ptr(); } + + const _Tp* + _M_h() const { return _M_storage._M_ptr(); } + }; + + // Empty partial specialization for empty _Hash_code_base types. + template + struct _Hash_code_storage<_Tp, true> + { + static_assert( std::is_empty<_Tp>::value, "Type must be empty" ); + + // As _Tp is an empty type there will be no bytes written/read through + // the cast pointer, so no strict-aliasing violation. + _Tp* + _M_h() { return reinterpret_cast<_Tp*>(this); } + + const _Tp* + _M_h() const { return reinterpret_cast(this); } + }; + + template + using __hash_code_for_local_iter + = _Hash_code_storage<_Hash_code_base<_Key, _Value, _ExtractKey, + _H1, _H2, _Hash, false>>; + + // Partial specialization used when hash codes are not cached + template + struct _Local_iterator_base<_Key, _Value, _ExtractKey, + _H1, _H2, _Hash, false> + : __hash_code_for_local_iter<_Key, _Value, _ExtractKey, _H1, _H2, _Hash> + { + protected: + using __hash_code_base = _Hash_code_base<_Key, _Value, _ExtractKey, + _H1, _H2, _Hash, false>; + + _Local_iterator_base() : _M_bucket_count(-1) { } + + _Local_iterator_base(const __hash_code_base& __base, + _Hash_node<_Value, false>* __p, + std::size_t __bkt, std::size_t __bkt_count) + : _M_cur(__p), _M_bucket(__bkt), _M_bucket_count(__bkt_count) + { _M_init(__base); } + + ~_Local_iterator_base() + { + if (_M_bucket_count != -1) + _M_destroy(); + } + + _Local_iterator_base(const _Local_iterator_base& __iter) + : _M_cur(__iter._M_cur), _M_bucket(__iter._M_bucket), + _M_bucket_count(__iter._M_bucket_count) + { + if (_M_bucket_count != -1) + _M_init(*__iter._M_h()); + } + + _Local_iterator_base& + operator=(const _Local_iterator_base& __iter) + { + if (_M_bucket_count != -1) + _M_destroy(); + _M_cur = __iter._M_cur; + _M_bucket = __iter._M_bucket; + _M_bucket_count = __iter._M_bucket_count; + if (_M_bucket_count != -1) + _M_init(*__iter._M_h()); + return *this; + } + + void + _M_incr() + { + _M_cur = _M_cur->_M_next(); + if (_M_cur) + { + std::size_t __bkt = this->_M_h()->_M_bucket_index(_M_cur, + _M_bucket_count); + if (__bkt != _M_bucket) + _M_cur = nullptr; + } + } + + _Hash_node<_Value, false>* _M_cur; + std::size_t _M_bucket; + std::size_t _M_bucket_count; + + void + _M_init(const __hash_code_base& __base) + { ::new(this->_M_h()) __hash_code_base(__base); } + + void + _M_destroy() { this->_M_h()->~__hash_code_base(); } + + public: + const void* + _M_curr() const { return _M_cur; } // for equality ops and debug mode + + std::size_t + _M_get_bucket() const { return _M_bucket; } // for debug mode + }; + + template + inline bool + operator==(const _Local_iterator_base<_Key, _Value, _ExtractKey, + _H1, _H2, _Hash, __cache>& __x, + const _Local_iterator_base<_Key, _Value, _ExtractKey, + _H1, _H2, _Hash, __cache>& __y) + { return __x._M_curr() == __y._M_curr(); } + + template + inline bool + operator!=(const _Local_iterator_base<_Key, _Value, _ExtractKey, + _H1, _H2, _Hash, __cache>& __x, + const _Local_iterator_base<_Key, _Value, _ExtractKey, + _H1, _H2, _Hash, __cache>& __y) + { return __x._M_curr() != __y._M_curr(); } + + /// local iterators + template + struct _Local_iterator + : public _Local_iterator_base<_Key, _Value, _ExtractKey, + _H1, _H2, _Hash, __cache> + { + private: + using __base_type = _Local_iterator_base<_Key, _Value, _ExtractKey, + _H1, _H2, _Hash, __cache>; + using __hash_code_base = typename __base_type::__hash_code_base; + public: + typedef _Value value_type; + typedef typename std::conditional<__constant_iterators, + const _Value*, _Value*>::type + pointer; + typedef typename std::conditional<__constant_iterators, + const _Value&, _Value&>::type + reference; + typedef std::ptrdiff_t difference_type; + typedef std::forward_iterator_tag iterator_category; + + _Local_iterator() = default; + + _Local_iterator(const __hash_code_base& __base, + _Hash_node<_Value, __cache>* __p, + std::size_t __bkt, std::size_t __bkt_count) + : __base_type(__base, __p, __bkt, __bkt_count) + { } + + reference + operator*() const + { return this->_M_cur->_M_v(); } + + pointer + operator->() const + { return this->_M_cur->_M_valptr(); } + + _Local_iterator& + operator++() + { + this->_M_incr(); + return *this; + } + + _Local_iterator + operator++(int) + { + _Local_iterator __tmp(*this); + this->_M_incr(); + return __tmp; + } + }; + + /// local const_iterators + template + struct _Local_const_iterator + : public _Local_iterator_base<_Key, _Value, _ExtractKey, + _H1, _H2, _Hash, __cache> + { + private: + using __base_type = _Local_iterator_base<_Key, _Value, _ExtractKey, + _H1, _H2, _Hash, __cache>; + using __hash_code_base = typename __base_type::__hash_code_base; + + public: + typedef _Value value_type; + typedef const _Value* pointer; + typedef const _Value& reference; + typedef std::ptrdiff_t difference_type; + typedef std::forward_iterator_tag iterator_category; + + _Local_const_iterator() = default; + + _Local_const_iterator(const __hash_code_base& __base, + _Hash_node<_Value, __cache>* __p, + std::size_t __bkt, std::size_t __bkt_count) + : __base_type(__base, __p, __bkt, __bkt_count) + { } + + _Local_const_iterator(const _Local_iterator<_Key, _Value, _ExtractKey, + _H1, _H2, _Hash, + __constant_iterators, + __cache>& __x) + : __base_type(__x) + { } + + reference + operator*() const + { return this->_M_cur->_M_v(); } + + pointer + operator->() const + { return this->_M_cur->_M_valptr(); } + + _Local_const_iterator& + operator++() + { + this->_M_incr(); + return *this; + } + + _Local_const_iterator + operator++(int) + { + _Local_const_iterator __tmp(*this); + this->_M_incr(); + return __tmp; + } + }; + + /** + * Primary class template _Hashtable_base. + * + * Helper class adding management of _Equal functor to + * _Hash_code_base type. + * + * Base class templates are: + * - __detail::_Hash_code_base + * - __detail::_Hashtable_ebo_helper + */ + template + struct _Hashtable_base + : public _Hash_code_base<_Key, _Value, _ExtractKey, _H1, _H2, _Hash, + _Traits::__hash_cached::value>, + private _Hashtable_ebo_helper<0, _Equal> + { + public: + typedef _Key key_type; + typedef _Value value_type; + typedef _Equal key_equal; + typedef std::size_t size_type; + typedef std::ptrdiff_t difference_type; + + using __traits_type = _Traits; + using __hash_cached = typename __traits_type::__hash_cached; + using __constant_iterators = typename __traits_type::__constant_iterators; + using __unique_keys = typename __traits_type::__unique_keys; + + using __hash_code_base = _Hash_code_base<_Key, _Value, _ExtractKey, + _H1, _H2, _Hash, + __hash_cached::value>; + + using __hash_code = typename __hash_code_base::__hash_code; + using __node_type = typename __hash_code_base::__node_type; + + using iterator = __detail::_Node_iterator; + + using const_iterator = __detail::_Node_const_iterator; + + using local_iterator = __detail::_Local_iterator; + + using const_local_iterator = __detail::_Local_const_iterator; + + using __ireturn_type = typename std::conditional<__unique_keys::value, + std::pair, + iterator>::type; + private: + using _EqualEBO = _Hashtable_ebo_helper<0, _Equal>; + using _EqualHelper = _Equal_helper<_Key, _Value, _ExtractKey, _Equal, + __hash_code, __hash_cached::value>; + + protected: + _Hashtable_base(const _ExtractKey& __ex, const _H1& __h1, const _H2& __h2, + const _Hash& __hash, const _Equal& __eq) + : __hash_code_base(__ex, __h1, __h2, __hash), _EqualEBO(__eq) + { } + + bool + _M_equals(const _Key& __k, __hash_code __c, __node_type* __n) const + { + return _EqualHelper::_S_equals(_M_eq(), this->_M_extract(), + __k, __c, __n); + } + + void + _M_swap(_Hashtable_base& __x) + { + __hash_code_base::_M_swap(__x); + std::swap(_M_eq(), __x._M_eq()); + } + + const _Equal& + _M_eq() const { return _EqualEBO::_S_cget(*this); } + + _Equal& + _M_eq() { return _EqualEBO::_S_get(*this); } + }; + + /** + * struct _Equality_base. + * + * Common types and functions for class _Equality. + */ + struct _Equality_base + { + protected: + template + static bool + _S_is_permutation(_Uiterator, _Uiterator, _Uiterator); + }; + + // See std::is_permutation in N3068. + template + bool + _Equality_base:: + _S_is_permutation(_Uiterator __first1, _Uiterator __last1, + _Uiterator __first2) + { + for (; __first1 != __last1; ++__first1, ++__first2) + if (!(*__first1 == *__first2)) + break; + + if (__first1 == __last1) + return true; + + _Uiterator __last2 = __first2; + std::advance(__last2, std::distance(__first1, __last1)); + + for (_Uiterator __it1 = __first1; __it1 != __last1; ++__it1) + { + _Uiterator __tmp = __first1; + while (__tmp != __it1 && !bool(*__tmp == *__it1)) + ++__tmp; + + // We've seen this one before. + if (__tmp != __it1) + continue; + + std::ptrdiff_t __n2 = 0; + for (__tmp = __first2; __tmp != __last2; ++__tmp) + if (*__tmp == *__it1) + ++__n2; + + if (!__n2) + return false; + + std::ptrdiff_t __n1 = 0; + for (__tmp = __it1; __tmp != __last1; ++__tmp) + if (*__tmp == *__it1) + ++__n1; + + if (__n1 != __n2) + return false; + } + return true; + } + + /** + * Primary class template _Equality. + * + * This is for implementing equality comparison for unordered + * containers, per N3068, by John Lakos and Pablo Halpern. + * Algorithmically, we follow closely the reference implementations + * therein. + */ + template + struct _Equality; + + /// Specialization. + template + struct _Equality<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _H1, _H2, _Hash, _RehashPolicy, _Traits, true> + { + using __hashtable = _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _H1, _H2, _Hash, _RehashPolicy, _Traits>; + + bool + _M_equal(const __hashtable&) const; + }; + + template + bool + _Equality<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _H1, _H2, _Hash, _RehashPolicy, _Traits, true>:: + _M_equal(const __hashtable& __other) const + { + const __hashtable* __this = static_cast(this); + + if (__this->size() != __other.size()) + return false; + + for (auto __itx = __this->begin(); __itx != __this->end(); ++__itx) + { + const auto __ity = __other.find(_ExtractKey()(*__itx)); + if (__ity == __other.end() || !bool(*__ity == *__itx)) + return false; + } + return true; + } + + /// Specialization. + template + struct _Equality<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _H1, _H2, _Hash, _RehashPolicy, _Traits, false> + : public _Equality_base + { + using __hashtable = _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _H1, _H2, _Hash, _RehashPolicy, _Traits>; + + bool + _M_equal(const __hashtable&) const; + }; + + template + bool + _Equality<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _H1, _H2, _Hash, _RehashPolicy, _Traits, false>:: + _M_equal(const __hashtable& __other) const + { + const __hashtable* __this = static_cast(this); + + if (__this->size() != __other.size()) + return false; + + for (auto __itx = __this->begin(); __itx != __this->end();) + { + const auto __xrange = __this->equal_range(_ExtractKey()(*__itx)); + const auto __yrange = __other.equal_range(_ExtractKey()(*__itx)); + + if (std::distance(__xrange.first, __xrange.second) + != std::distance(__yrange.first, __yrange.second)) + return false; + + if (!_S_is_permutation(__xrange.first, __xrange.second, + __yrange.first)) + return false; + + __itx = __xrange.second; + } + return true; + } + + /** + * This type deals with all allocation and keeps an allocator instance through + * inheritance to benefit from EBO when possible. + */ + template + struct _Hashtable_alloc : private _Hashtable_ebo_helper<0, _NodeAlloc> + { + private: + using __ebo_node_alloc = _Hashtable_ebo_helper<0, _NodeAlloc>; + public: + using __node_type = typename _NodeAlloc::value_type; + using __node_alloc_type = _NodeAlloc; + // Use __gnu_cxx to benefit from _S_always_equal and al. + using __node_alloc_traits = __gnu_cxx::__alloc_traits<__node_alloc_type>; + + using __value_type = typename __node_type::value_type; + using __value_alloc_type = + typename __alloctr_rebind<__node_alloc_type, __value_type>::__type; + using __value_alloc_traits = std::allocator_traits<__value_alloc_type>; + + using __node_base = __detail::_Hash_node_base; + using __bucket_type = __node_base*; + using __bucket_alloc_type = + typename __alloctr_rebind<__node_alloc_type, __bucket_type>::__type; + using __bucket_alloc_traits = std::allocator_traits<__bucket_alloc_type>; + + _Hashtable_alloc(const _Hashtable_alloc&) = default; + _Hashtable_alloc(_Hashtable_alloc&&) = default; + + template + _Hashtable_alloc(_Alloc&& __a) + : __ebo_node_alloc(std::forward<_Alloc>(__a)) + { } + + __node_alloc_type& + _M_node_allocator() + { return __ebo_node_alloc::_S_get(*this); } + + const __node_alloc_type& + _M_node_allocator() const + { return __ebo_node_alloc::_S_cget(*this); } + + template + __node_type* + _M_allocate_node(_Args&&... __args); + + void + _M_deallocate_node(__node_type* __n); + + // Deallocate the linked list of nodes pointed to by __n + void + _M_deallocate_nodes(__node_type* __n); + + __bucket_type* + _M_allocate_buckets(std::size_t __n); + + void + _M_deallocate_buckets(__bucket_type*, std::size_t __n); + }; + + // Definitions of class template _Hashtable_alloc's out-of-line member + // functions. + template + template + typename _Hashtable_alloc<_NodeAlloc>::__node_type* + _Hashtable_alloc<_NodeAlloc>::_M_allocate_node(_Args&&... __args) + { + auto __nptr = __node_alloc_traits::allocate(_M_node_allocator(), 1); + __node_type* __n = std::__addressof(*__nptr); + __try + { + __value_alloc_type __a(_M_node_allocator()); + ::new ((void*)__n) __node_type; + __value_alloc_traits::construct(__a, __n->_M_valptr(), + std::forward<_Args>(__args)...); + return __n; + } + __catch(...) + { + __node_alloc_traits::deallocate(_M_node_allocator(), __nptr, 1); + __throw_exception_again; + } + } + + template + void + _Hashtable_alloc<_NodeAlloc>::_M_deallocate_node(__node_type* __n) + { + typedef typename __node_alloc_traits::pointer _Ptr; + auto __ptr = std::pointer_traits<_Ptr>::pointer_to(*__n); + __value_alloc_type __a(_M_node_allocator()); + __value_alloc_traits::destroy(__a, __n->_M_valptr()); + __n->~__node_type(); + __node_alloc_traits::deallocate(_M_node_allocator(), __ptr, 1); + } + + template + void + _Hashtable_alloc<_NodeAlloc>::_M_deallocate_nodes(__node_type* __n) + { + while (__n) + { + __node_type* __tmp = __n; + __n = __n->_M_next(); + _M_deallocate_node(__tmp); + } + } + + template + typename _Hashtable_alloc<_NodeAlloc>::__bucket_type* + _Hashtable_alloc<_NodeAlloc>::_M_allocate_buckets(std::size_t __n) + { + __bucket_alloc_type __alloc(_M_node_allocator()); + + auto __ptr = __bucket_alloc_traits::allocate(__alloc, __n); + __bucket_type* __p = std::__addressof(*__ptr); + __builtin_memset(__p, 0, __n * sizeof(__bucket_type)); + return __p; + } + + template + void + _Hashtable_alloc<_NodeAlloc>::_M_deallocate_buckets(__bucket_type* __bkts, + std::size_t __n) + { + typedef typename __bucket_alloc_traits::pointer _Ptr; + auto __ptr = std::pointer_traits<_Ptr>::pointer_to(*__bkts); + __bucket_alloc_type __alloc(_M_node_allocator()); + __bucket_alloc_traits::deallocate(__alloc, __ptr, __n); + } + + //@} hashtable-detail +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace __detail +} // namespace std + +#endif // _HASHTABLE_POLICY_H diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/indirect_array.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/indirect_array.h new file mode 100755 index 0000000..a9afe64 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/indirect_array.h @@ -0,0 +1,212 @@ +// The template and inlines for the -*- C++ -*- indirect_array class. + +// Copyright (C) 1997-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file bits/indirect_array.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{valarray} + */ + +// Written by Gabriel Dos Reis + +#ifndef _INDIRECT_ARRAY_H +#define _INDIRECT_ARRAY_H 1 + +#pragma GCC system_header + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /** + * @addtogroup numeric_arrays + * @{ + */ + + /** + * @brief Reference to arbitrary subset of an array. + * + * An indirect_array is a reference to the actual elements of an array + * specified by an ordered array of indices. The way to get an + * indirect_array is to call operator[](valarray) on a valarray. + * The returned indirect_array then permits carrying operations out on the + * referenced subset of elements in the original valarray. + * + * For example, if an indirect_array is obtained using the array (4,2,0) as + * an argument, and then assigned to an array containing (1,2,3), then the + * underlying array will have array[0]==3, array[2]==2, and array[4]==1. + * + * @param Tp Element type. + */ + template + class indirect_array + { + public: + typedef _Tp value_type; + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 253. valarray helper functions are almost entirely useless + + /// Copy constructor. Both slices refer to the same underlying array. + indirect_array(const indirect_array&); + + /// Assignment operator. Assigns elements to corresponding elements + /// of @a a. + indirect_array& operator=(const indirect_array&); + + /// Assign slice elements to corresponding elements of @a v. + void operator=(const valarray<_Tp>&) const; + /// Multiply slice elements by corresponding elements of @a v. + void operator*=(const valarray<_Tp>&) const; + /// Divide slice elements by corresponding elements of @a v. + void operator/=(const valarray<_Tp>&) const; + /// Modulo slice elements by corresponding elements of @a v. + void operator%=(const valarray<_Tp>&) const; + /// Add corresponding elements of @a v to slice elements. + void operator+=(const valarray<_Tp>&) const; + /// Subtract corresponding elements of @a v from slice elements. + void operator-=(const valarray<_Tp>&) const; + /// Logical xor slice elements with corresponding elements of @a v. + void operator^=(const valarray<_Tp>&) const; + /// Logical and slice elements with corresponding elements of @a v. + void operator&=(const valarray<_Tp>&) const; + /// Logical or slice elements with corresponding elements of @a v. + void operator|=(const valarray<_Tp>&) const; + /// Left shift slice elements by corresponding elements of @a v. + void operator<<=(const valarray<_Tp>&) const; + /// Right shift slice elements by corresponding elements of @a v. + void operator>>=(const valarray<_Tp>&) const; + /// Assign all slice elements to @a t. + void operator= (const _Tp&) const; + // ~indirect_array(); + + template + void operator=(const _Expr<_Dom, _Tp>&) const; + template + void operator*=(const _Expr<_Dom, _Tp>&) const; + template + void operator/=(const _Expr<_Dom, _Tp>&) const; + template + void operator%=(const _Expr<_Dom, _Tp>&) const; + template + void operator+=(const _Expr<_Dom, _Tp>&) const; + template + void operator-=(const _Expr<_Dom, _Tp>&) const; + template + void operator^=(const _Expr<_Dom, _Tp>&) const; + template + void operator&=(const _Expr<_Dom, _Tp>&) const; + template + void operator|=(const _Expr<_Dom, _Tp>&) const; + template + void operator<<=(const _Expr<_Dom, _Tp>&) const; + template + void operator>>=(const _Expr<_Dom, _Tp>&) const; + + private: + /// Copy constructor. Both slices refer to the same underlying array. + indirect_array(_Array<_Tp>, size_t, _Array); + + friend class valarray<_Tp>; + friend class gslice_array<_Tp>; + + const size_t _M_sz; + const _Array _M_index; + const _Array<_Tp> _M_array; + + // not implemented + indirect_array(); + }; + + template + inline + indirect_array<_Tp>::indirect_array(const indirect_array<_Tp>& __a) + : _M_sz(__a._M_sz), _M_index(__a._M_index), _M_array(__a._M_array) {} + + template + inline + indirect_array<_Tp>::indirect_array(_Array<_Tp> __a, size_t __s, + _Array __i) + : _M_sz(__s), _M_index(__i), _M_array(__a) {} + + template + inline indirect_array<_Tp>& + indirect_array<_Tp>::operator=(const indirect_array<_Tp>& __a) + { + std::__valarray_copy(__a._M_array, _M_sz, __a._M_index, _M_array, + _M_index); + return *this; + } + + template + inline void + indirect_array<_Tp>::operator=(const _Tp& __t) const + { std::__valarray_fill(_M_array, _M_index, _M_sz, __t); } + + template + inline void + indirect_array<_Tp>::operator=(const valarray<_Tp>& __v) const + { std::__valarray_copy(_Array<_Tp>(__v), _M_sz, _M_array, _M_index); } + + template + template + inline void + indirect_array<_Tp>::operator=(const _Expr<_Dom, _Tp>& __e) const + { std::__valarray_copy(__e, _M_sz, _M_array, _M_index); } + +#undef _DEFINE_VALARRAY_OPERATOR +#define _DEFINE_VALARRAY_OPERATOR(_Op, _Name) \ + template \ + inline void \ + indirect_array<_Tp>::operator _Op##=(const valarray<_Tp>& __v) const\ + { \ + _Array_augmented_##_Name(_M_array, _M_index, _Array<_Tp>(__v), _M_sz); \ + } \ + \ + template \ + template \ + inline void \ + indirect_array<_Tp>::operator _Op##=(const _Expr<_Dom,_Tp>& __e) const\ + { \ + _Array_augmented_##_Name(_M_array, _M_index, __e, _M_sz); \ + } + +_DEFINE_VALARRAY_OPERATOR(*, __multiplies) +_DEFINE_VALARRAY_OPERATOR(/, __divides) +_DEFINE_VALARRAY_OPERATOR(%, __modulus) +_DEFINE_VALARRAY_OPERATOR(+, __plus) +_DEFINE_VALARRAY_OPERATOR(-, __minus) +_DEFINE_VALARRAY_OPERATOR(^, __bitwise_xor) +_DEFINE_VALARRAY_OPERATOR(&, __bitwise_and) +_DEFINE_VALARRAY_OPERATOR(|, __bitwise_or) +_DEFINE_VALARRAY_OPERATOR(<<, __shift_left) +_DEFINE_VALARRAY_OPERATOR(>>, __shift_right) + +#undef _DEFINE_VALARRAY_OPERATOR + + // @} group numeric_arrays + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif /* _INDIRECT_ARRAY_H */ diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/ios_base.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/ios_base.h new file mode 100755 index 0000000..ae856de --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/ios_base.h @@ -0,0 +1,975 @@ +// Iostreams base classes -*- C++ -*- + +// Copyright (C) 1997-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file bits/ios_base.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{ios} + */ + +// +// ISO C++ 14882: 27.4 Iostreams base classes +// + +#ifndef _IOS_BASE_H +#define _IOS_BASE_H 1 + +#pragma GCC system_header + +#include +#include +#include + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + // The following definitions of bitmask types are enums, not ints, + // as permitted (but not required) in the standard, in order to provide + // better type safety in iostream calls. A side effect is that + // expressions involving them are no longer compile-time constants. + enum _Ios_Fmtflags + { + _S_boolalpha = 1L << 0, + _S_dec = 1L << 1, + _S_fixed = 1L << 2, + _S_hex = 1L << 3, + _S_internal = 1L << 4, + _S_left = 1L << 5, + _S_oct = 1L << 6, + _S_right = 1L << 7, + _S_scientific = 1L << 8, + _S_showbase = 1L << 9, + _S_showpoint = 1L << 10, + _S_showpos = 1L << 11, + _S_skipws = 1L << 12, + _S_unitbuf = 1L << 13, + _S_uppercase = 1L << 14, + _S_adjustfield = _S_left | _S_right | _S_internal, + _S_basefield = _S_dec | _S_oct | _S_hex, + _S_floatfield = _S_scientific | _S_fixed, + _S_ios_fmtflags_end = 1L << 16 + }; + + inline _GLIBCXX_CONSTEXPR _Ios_Fmtflags + operator&(_Ios_Fmtflags __a, _Ios_Fmtflags __b) + { return _Ios_Fmtflags(static_cast(__a) & static_cast(__b)); } + + inline _GLIBCXX_CONSTEXPR _Ios_Fmtflags + operator|(_Ios_Fmtflags __a, _Ios_Fmtflags __b) + { return _Ios_Fmtflags(static_cast(__a) | static_cast(__b)); } + + inline _GLIBCXX_CONSTEXPR _Ios_Fmtflags + operator^(_Ios_Fmtflags __a, _Ios_Fmtflags __b) + { return _Ios_Fmtflags(static_cast(__a) ^ static_cast(__b)); } + + inline _GLIBCXX_CONSTEXPR _Ios_Fmtflags + operator~(_Ios_Fmtflags __a) + { return _Ios_Fmtflags(~static_cast(__a)); } + + inline const _Ios_Fmtflags& + operator|=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b) + { return __a = __a | __b; } + + inline const _Ios_Fmtflags& + operator&=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b) + { return __a = __a & __b; } + + inline const _Ios_Fmtflags& + operator^=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b) + { return __a = __a ^ __b; } + + + enum _Ios_Openmode + { + _S_app = 1L << 0, + _S_ate = 1L << 1, + _S_bin = 1L << 2, + _S_in = 1L << 3, + _S_out = 1L << 4, + _S_trunc = 1L << 5, + _S_ios_openmode_end = 1L << 16 + }; + + inline _GLIBCXX_CONSTEXPR _Ios_Openmode + operator&(_Ios_Openmode __a, _Ios_Openmode __b) + { return _Ios_Openmode(static_cast(__a) & static_cast(__b)); } + + inline _GLIBCXX_CONSTEXPR _Ios_Openmode + operator|(_Ios_Openmode __a, _Ios_Openmode __b) + { return _Ios_Openmode(static_cast(__a) | static_cast(__b)); } + + inline _GLIBCXX_CONSTEXPR _Ios_Openmode + operator^(_Ios_Openmode __a, _Ios_Openmode __b) + { return _Ios_Openmode(static_cast(__a) ^ static_cast(__b)); } + + inline _GLIBCXX_CONSTEXPR _Ios_Openmode + operator~(_Ios_Openmode __a) + { return _Ios_Openmode(~static_cast(__a)); } + + inline const _Ios_Openmode& + operator|=(_Ios_Openmode& __a, _Ios_Openmode __b) + { return __a = __a | __b; } + + inline const _Ios_Openmode& + operator&=(_Ios_Openmode& __a, _Ios_Openmode __b) + { return __a = __a & __b; } + + inline const _Ios_Openmode& + operator^=(_Ios_Openmode& __a, _Ios_Openmode __b) + { return __a = __a ^ __b; } + + + enum _Ios_Iostate + { + _S_goodbit = 0, + _S_badbit = 1L << 0, + _S_eofbit = 1L << 1, + _S_failbit = 1L << 2, + _S_ios_iostate_end = 1L << 16 + }; + + inline _GLIBCXX_CONSTEXPR _Ios_Iostate + operator&(_Ios_Iostate __a, _Ios_Iostate __b) + { return _Ios_Iostate(static_cast(__a) & static_cast(__b)); } + + inline _GLIBCXX_CONSTEXPR _Ios_Iostate + operator|(_Ios_Iostate __a, _Ios_Iostate __b) + { return _Ios_Iostate(static_cast(__a) | static_cast(__b)); } + + inline _GLIBCXX_CONSTEXPR _Ios_Iostate + operator^(_Ios_Iostate __a, _Ios_Iostate __b) + { return _Ios_Iostate(static_cast(__a) ^ static_cast(__b)); } + + inline _GLIBCXX_CONSTEXPR _Ios_Iostate + operator~(_Ios_Iostate __a) + { return _Ios_Iostate(~static_cast(__a)); } + + inline const _Ios_Iostate& + operator|=(_Ios_Iostate& __a, _Ios_Iostate __b) + { return __a = __a | __b; } + + inline const _Ios_Iostate& + operator&=(_Ios_Iostate& __a, _Ios_Iostate __b) + { return __a = __a & __b; } + + inline const _Ios_Iostate& + operator^=(_Ios_Iostate& __a, _Ios_Iostate __b) + { return __a = __a ^ __b; } + + + enum _Ios_Seekdir + { + _S_beg = 0, + _S_cur = _GLIBCXX_STDIO_SEEK_CUR, + _S_end = _GLIBCXX_STDIO_SEEK_END, + _S_ios_seekdir_end = 1L << 16 + }; + + // 27.4.2 Class ios_base + /** + * @brief The base of the I/O class hierarchy. + * @ingroup io + * + * This class defines everything that can be defined about I/O that does + * not depend on the type of characters being input or output. Most + * people will only see @c ios_base when they need to specify the full + * name of the various I/O flags (e.g., the openmodes). + */ + class ios_base + { + public: + + /** + * @brief These are thrown to indicate problems with io. + * @ingroup exceptions + * + * 27.4.2.1.1 Class ios_base::failure + */ + class failure : public exception + { + public: + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 48. Use of non-existent exception constructor + explicit + failure(const string& __str) throw(); + + // This declaration is not useless: + // http://gcc.gnu.org/onlinedocs/gcc-4.3.2/gcc/Vague-Linkage.html + virtual + ~failure() throw(); + + virtual const char* + what() const throw(); + + private: + string _M_msg; + }; + + // 27.4.2.1.2 Type ios_base::fmtflags + /** + * @brief This is a bitmask type. + * + * @c @a _Ios_Fmtflags is implementation-defined, but it is valid to + * perform bitwise operations on these values and expect the Right + * Thing to happen. Defined objects of type fmtflags are: + * - boolalpha + * - dec + * - fixed + * - hex + * - internal + * - left + * - oct + * - right + * - scientific + * - showbase + * - showpoint + * - showpos + * - skipws + * - unitbuf + * - uppercase + * - adjustfield + * - basefield + * - floatfield + */ + typedef _Ios_Fmtflags fmtflags; + + /// Insert/extract @c bool in alphabetic rather than numeric format. + static const fmtflags boolalpha = _S_boolalpha; + + /// Converts integer input or generates integer output in decimal base. + static const fmtflags dec = _S_dec; + + /// Generate floating-point output in fixed-point notation. + static const fmtflags fixed = _S_fixed; + + /// Converts integer input or generates integer output in hexadecimal base. + static const fmtflags hex = _S_hex; + + /// Adds fill characters at a designated internal point in certain + /// generated output, or identical to @c right if no such point is + /// designated. + static const fmtflags internal = _S_internal; + + /// Adds fill characters on the right (final positions) of certain + /// generated output. (I.e., the thing you print is flush left.) + static const fmtflags left = _S_left; + + /// Converts integer input or generates integer output in octal base. + static const fmtflags oct = _S_oct; + + /// Adds fill characters on the left (initial positions) of certain + /// generated output. (I.e., the thing you print is flush right.) + static const fmtflags right = _S_right; + + /// Generates floating-point output in scientific notation. + static const fmtflags scientific = _S_scientific; + + /// Generates a prefix indicating the numeric base of generated integer + /// output. + static const fmtflags showbase = _S_showbase; + + /// Generates a decimal-point character unconditionally in generated + /// floating-point output. + static const fmtflags showpoint = _S_showpoint; + + /// Generates a + sign in non-negative generated numeric output. + static const fmtflags showpos = _S_showpos; + + /// Skips leading white space before certain input operations. + static const fmtflags skipws = _S_skipws; + + /// Flushes output after each output operation. + static const fmtflags unitbuf = _S_unitbuf; + + /// Replaces certain lowercase letters with their uppercase equivalents + /// in generated output. + static const fmtflags uppercase = _S_uppercase; + + /// A mask of left|right|internal. Useful for the 2-arg form of @c setf. + static const fmtflags adjustfield = _S_adjustfield; + + /// A mask of dec|oct|hex. Useful for the 2-arg form of @c setf. + static const fmtflags basefield = _S_basefield; + + /// A mask of scientific|fixed. Useful for the 2-arg form of @c setf. + static const fmtflags floatfield = _S_floatfield; + + // 27.4.2.1.3 Type ios_base::iostate + /** + * @brief This is a bitmask type. + * + * @c @a _Ios_Iostate is implementation-defined, but it is valid to + * perform bitwise operations on these values and expect the Right + * Thing to happen. Defined objects of type iostate are: + * - badbit + * - eofbit + * - failbit + * - goodbit + */ + typedef _Ios_Iostate iostate; + + /// Indicates a loss of integrity in an input or output sequence (such + /// as an irrecoverable read error from a file). + static const iostate badbit = _S_badbit; + + /// Indicates that an input operation reached the end of an input sequence. + static const iostate eofbit = _S_eofbit; + + /// Indicates that an input operation failed to read the expected + /// characters, or that an output operation failed to generate the + /// desired characters. + static const iostate failbit = _S_failbit; + + /// Indicates all is well. + static const iostate goodbit = _S_goodbit; + + // 27.4.2.1.4 Type ios_base::openmode + /** + * @brief This is a bitmask type. + * + * @c @a _Ios_Openmode is implementation-defined, but it is valid to + * perform bitwise operations on these values and expect the Right + * Thing to happen. Defined objects of type openmode are: + * - app + * - ate + * - binary + * - in + * - out + * - trunc + */ + typedef _Ios_Openmode openmode; + + /// Seek to end before each write. + static const openmode app = _S_app; + + /// Open and seek to end immediately after opening. + static const openmode ate = _S_ate; + + /// Perform input and output in binary mode (as opposed to text mode). + /// This is probably not what you think it is; see + /// http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt11ch27s02.html + static const openmode binary = _S_bin; + + /// Open for input. Default for @c ifstream and fstream. + static const openmode in = _S_in; + + /// Open for output. Default for @c ofstream and fstream. + static const openmode out = _S_out; + + /// Open for input. Default for @c ofstream. + static const openmode trunc = _S_trunc; + + // 27.4.2.1.5 Type ios_base::seekdir + /** + * @brief This is an enumerated type. + * + * @c @a _Ios_Seekdir is implementation-defined. Defined values + * of type seekdir are: + * - beg + * - cur, equivalent to @c SEEK_CUR in the C standard library. + * - end, equivalent to @c SEEK_END in the C standard library. + */ + typedef _Ios_Seekdir seekdir; + + /// Request a seek relative to the beginning of the stream. + static const seekdir beg = _S_beg; + + /// Request a seek relative to the current position within the sequence. + static const seekdir cur = _S_cur; + + /// Request a seek relative to the current end of the sequence. + static const seekdir end = _S_end; + + // Annex D.6 + typedef int io_state; + typedef int open_mode; + typedef int seek_dir; + + typedef std::streampos streampos; + typedef std::streamoff streamoff; + + // Callbacks; + /** + * @brief The set of events that may be passed to an event callback. + * + * erase_event is used during ~ios() and copyfmt(). imbue_event is used + * during imbue(). copyfmt_event is used during copyfmt(). + */ + enum event + { + erase_event, + imbue_event, + copyfmt_event + }; + + /** + * @brief The type of an event callback function. + * @param __e One of the members of the event enum. + * @param __b Reference to the ios_base object. + * @param __i The integer provided when the callback was registered. + * + * Event callbacks are user defined functions that get called during + * several ios_base and basic_ios functions, specifically imbue(), + * copyfmt(), and ~ios(). + */ + typedef void (*event_callback) (event __e, ios_base& __b, int __i); + + /** + * @brief Add the callback __fn with parameter __index. + * @param __fn The function to add. + * @param __index The integer to pass to the function when invoked. + * + * Registers a function as an event callback with an integer parameter to + * be passed to the function when invoked. Multiple copies of the + * function are allowed. If there are multiple callbacks, they are + * invoked in the order they were registered. + */ + void + register_callback(event_callback __fn, int __index); + + protected: + streamsize _M_precision; + streamsize _M_width; + fmtflags _M_flags; + iostate _M_exception; + iostate _M_streambuf_state; + + // 27.4.2.6 Members for callbacks + // 27.4.2.6 ios_base callbacks + struct _Callback_list + { + // Data Members + _Callback_list* _M_next; + ios_base::event_callback _M_fn; + int _M_index; + _Atomic_word _M_refcount; // 0 means one reference. + + _Callback_list(ios_base::event_callback __fn, int __index, + _Callback_list* __cb) + : _M_next(__cb), _M_fn(__fn), _M_index(__index), _M_refcount(0) { } + + void + _M_add_reference() { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); } + + // 0 => OK to delete. + int + _M_remove_reference() + { + // Be race-detector-friendly. For more info see bits/c++config. + _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_refcount); + int __res = __gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1); + if (__res == 0) + { + _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_refcount); + } + return __res; + } + }; + + _Callback_list* _M_callbacks; + + void + _M_call_callbacks(event __ev) throw(); + + void + _M_dispose_callbacks(void) throw(); + + // 27.4.2.5 Members for iword/pword storage + struct _Words + { + void* _M_pword; + long _M_iword; + _Words() : _M_pword(0), _M_iword(0) { } + }; + + // Only for failed iword/pword calls. + _Words _M_word_zero; + + // Guaranteed storage. + // The first 5 iword and pword slots are reserved for internal use. + enum { _S_local_word_size = 8 }; + _Words _M_local_word[_S_local_word_size]; + + // Allocated storage. + int _M_word_size; + _Words* _M_word; + + _Words& + _M_grow_words(int __index, bool __iword); + + // Members for locale and locale caching. + locale _M_ios_locale; + + void + _M_init() throw(); + + public: + + // 27.4.2.1.6 Class ios_base::Init + // Used to initialize standard streams. In theory, g++ could use + // -finit-priority to order this stuff correctly without going + // through these machinations. + class Init + { + friend class ios_base; + public: + Init(); + ~Init(); + + private: + static _Atomic_word _S_refcount; + static bool _S_synced_with_stdio; + }; + + // [27.4.2.2] fmtflags state functions + /** + * @brief Access to format flags. + * @return The format control flags for both input and output. + */ + fmtflags + flags() const + { return _M_flags; } + + /** + * @brief Setting new format flags all at once. + * @param __fmtfl The new flags to set. + * @return The previous format control flags. + * + * This function overwrites all the format flags with @a __fmtfl. + */ + fmtflags + flags(fmtflags __fmtfl) + { + fmtflags __old = _M_flags; + _M_flags = __fmtfl; + return __old; + } + + /** + * @brief Setting new format flags. + * @param __fmtfl Additional flags to set. + * @return The previous format control flags. + * + * This function sets additional flags in format control. Flags that + * were previously set remain set. + */ + fmtflags + setf(fmtflags __fmtfl) + { + fmtflags __old = _M_flags; + _M_flags |= __fmtfl; + return __old; + } + + /** + * @brief Setting new format flags. + * @param __fmtfl Additional flags to set. + * @param __mask The flags mask for @a fmtfl. + * @return The previous format control flags. + * + * This function clears @a mask in the format flags, then sets + * @a fmtfl @c & @a mask. An example mask is @c ios_base::adjustfield. + */ + fmtflags + setf(fmtflags __fmtfl, fmtflags __mask) + { + fmtflags __old = _M_flags; + _M_flags &= ~__mask; + _M_flags |= (__fmtfl & __mask); + return __old; + } + + /** + * @brief Clearing format flags. + * @param __mask The flags to unset. + * + * This function clears @a __mask in the format flags. + */ + void + unsetf(fmtflags __mask) + { _M_flags &= ~__mask; } + + /** + * @brief Flags access. + * @return The precision to generate on certain output operations. + * + * Be careful if you try to give a definition of @a precision here; see + * DR 189. + */ + streamsize + precision() const + { return _M_precision; } + + /** + * @brief Changing flags. + * @param __prec The new precision value. + * @return The previous value of precision(). + */ + streamsize + precision(streamsize __prec) + { + streamsize __old = _M_precision; + _M_precision = __prec; + return __old; + } + + /** + * @brief Flags access. + * @return The minimum field width to generate on output operations. + * + * Minimum field width refers to the number of characters. + */ + streamsize + width() const + { return _M_width; } + + /** + * @brief Changing flags. + * @param __wide The new width value. + * @return The previous value of width(). + */ + streamsize + width(streamsize __wide) + { + streamsize __old = _M_width; + _M_width = __wide; + return __old; + } + + // [27.4.2.4] ios_base static members + /** + * @brief Interaction with the standard C I/O objects. + * @param __sync Whether to synchronize or not. + * @return True if the standard streams were previously synchronized. + * + * The synchronization referred to is @e only that between the standard + * C facilities (e.g., stdout) and the standard C++ objects (e.g., + * cout). User-declared streams are unaffected. See + * http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt11ch28s02.html + */ + static bool + sync_with_stdio(bool __sync = true); + + // [27.4.2.3] ios_base locale functions + /** + * @brief Setting a new locale. + * @param __loc The new locale. + * @return The previous locale. + * + * Sets the new locale for this stream, and then invokes each callback + * with imbue_event. + */ + locale + imbue(const locale& __loc) throw(); + + /** + * @brief Locale access + * @return A copy of the current locale. + * + * If @c imbue(loc) has previously been called, then this function + * returns @c loc. Otherwise, it returns a copy of @c std::locale(), + * the global C++ locale. + */ + locale + getloc() const + { return _M_ios_locale; } + + /** + * @brief Locale access + * @return A reference to the current locale. + * + * Like getloc above, but returns a reference instead of + * generating a copy. + */ + const locale& + _M_getloc() const + { return _M_ios_locale; } + + // [27.4.2.5] ios_base storage functions + /** + * @brief Access to unique indices. + * @return An integer different from all previous calls. + * + * This function returns a unique integer every time it is called. It + * can be used for any purpose, but is primarily intended to be a unique + * index for the iword and pword functions. The expectation is that an + * application calls xalloc in order to obtain an index in the iword and + * pword arrays that can be used without fear of conflict. + * + * The implementation maintains a static variable that is incremented and + * returned on each invocation. xalloc is guaranteed to return an index + * that is safe to use in the iword and pword arrays. + */ + static int + xalloc() throw(); + + /** + * @brief Access to integer array. + * @param __ix Index into the array. + * @return A reference to an integer associated with the index. + * + * The iword function provides access to an array of integers that can be + * used for any purpose. The array grows as required to hold the + * supplied index. All integers in the array are initialized to 0. + * + * The implementation reserves several indices. You should use xalloc to + * obtain an index that is safe to use. Also note that since the array + * can grow dynamically, it is not safe to hold onto the reference. + */ + long& + iword(int __ix) + { + _Words& __word = (__ix < _M_word_size) + ? _M_word[__ix] : _M_grow_words(__ix, true); + return __word._M_iword; + } + + /** + * @brief Access to void pointer array. + * @param __ix Index into the array. + * @return A reference to a void* associated with the index. + * + * The pword function provides access to an array of pointers that can be + * used for any purpose. The array grows as required to hold the + * supplied index. All pointers in the array are initialized to 0. + * + * The implementation reserves several indices. You should use xalloc to + * obtain an index that is safe to use. Also note that since the array + * can grow dynamically, it is not safe to hold onto the reference. + */ + void*& + pword(int __ix) + { + _Words& __word = (__ix < _M_word_size) + ? _M_word[__ix] : _M_grow_words(__ix, false); + return __word._M_pword; + } + + // Destructor + /** + * Invokes each callback with erase_event. Destroys local storage. + * + * Note that the ios_base object for the standard streams never gets + * destroyed. As a result, any callbacks registered with the standard + * streams will not get invoked with erase_event (unless copyfmt is + * used). + */ + virtual ~ios_base(); + + protected: + ios_base() throw (); + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 50. Copy constructor and assignment operator of ios_base + private: + ios_base(const ios_base&); + + ios_base& + operator=(const ios_base&); + }; + + // [27.4.5.1] fmtflags manipulators + /// Calls base.setf(ios_base::boolalpha). + inline ios_base& + boolalpha(ios_base& __base) + { + __base.setf(ios_base::boolalpha); + return __base; + } + + /// Calls base.unsetf(ios_base::boolalpha). + inline ios_base& + noboolalpha(ios_base& __base) + { + __base.unsetf(ios_base::boolalpha); + return __base; + } + + /// Calls base.setf(ios_base::showbase). + inline ios_base& + showbase(ios_base& __base) + { + __base.setf(ios_base::showbase); + return __base; + } + + /// Calls base.unsetf(ios_base::showbase). + inline ios_base& + noshowbase(ios_base& __base) + { + __base.unsetf(ios_base::showbase); + return __base; + } + + /// Calls base.setf(ios_base::showpoint). + inline ios_base& + showpoint(ios_base& __base) + { + __base.setf(ios_base::showpoint); + return __base; + } + + /// Calls base.unsetf(ios_base::showpoint). + inline ios_base& + noshowpoint(ios_base& __base) + { + __base.unsetf(ios_base::showpoint); + return __base; + } + + /// Calls base.setf(ios_base::showpos). + inline ios_base& + showpos(ios_base& __base) + { + __base.setf(ios_base::showpos); + return __base; + } + + /// Calls base.unsetf(ios_base::showpos). + inline ios_base& + noshowpos(ios_base& __base) + { + __base.unsetf(ios_base::showpos); + return __base; + } + + /// Calls base.setf(ios_base::skipws). + inline ios_base& + skipws(ios_base& __base) + { + __base.setf(ios_base::skipws); + return __base; + } + + /// Calls base.unsetf(ios_base::skipws). + inline ios_base& + noskipws(ios_base& __base) + { + __base.unsetf(ios_base::skipws); + return __base; + } + + /// Calls base.setf(ios_base::uppercase). + inline ios_base& + uppercase(ios_base& __base) + { + __base.setf(ios_base::uppercase); + return __base; + } + + /// Calls base.unsetf(ios_base::uppercase). + inline ios_base& + nouppercase(ios_base& __base) + { + __base.unsetf(ios_base::uppercase); + return __base; + } + + /// Calls base.setf(ios_base::unitbuf). + inline ios_base& + unitbuf(ios_base& __base) + { + __base.setf(ios_base::unitbuf); + return __base; + } + + /// Calls base.unsetf(ios_base::unitbuf). + inline ios_base& + nounitbuf(ios_base& __base) + { + __base.unsetf(ios_base::unitbuf); + return __base; + } + + // [27.4.5.2] adjustfield manipulators + /// Calls base.setf(ios_base::internal, ios_base::adjustfield). + inline ios_base& + internal(ios_base& __base) + { + __base.setf(ios_base::internal, ios_base::adjustfield); + return __base; + } + + /// Calls base.setf(ios_base::left, ios_base::adjustfield). + inline ios_base& + left(ios_base& __base) + { + __base.setf(ios_base::left, ios_base::adjustfield); + return __base; + } + + /// Calls base.setf(ios_base::right, ios_base::adjustfield). + inline ios_base& + right(ios_base& __base) + { + __base.setf(ios_base::right, ios_base::adjustfield); + return __base; + } + + // [27.4.5.3] basefield manipulators + /// Calls base.setf(ios_base::dec, ios_base::basefield). + inline ios_base& + dec(ios_base& __base) + { + __base.setf(ios_base::dec, ios_base::basefield); + return __base; + } + + /// Calls base.setf(ios_base::hex, ios_base::basefield). + inline ios_base& + hex(ios_base& __base) + { + __base.setf(ios_base::hex, ios_base::basefield); + return __base; + } + + /// Calls base.setf(ios_base::oct, ios_base::basefield). + inline ios_base& + oct(ios_base& __base) + { + __base.setf(ios_base::oct, ios_base::basefield); + return __base; + } + + // [27.4.5.4] floatfield manipulators + /// Calls base.setf(ios_base::fixed, ios_base::floatfield). + inline ios_base& + fixed(ios_base& __base) + { + __base.setf(ios_base::fixed, ios_base::floatfield); + return __base; + } + + /// Calls base.setf(ios_base::scientific, ios_base::floatfield). + inline ios_base& + scientific(ios_base& __base) + { + __base.setf(ios_base::scientific, ios_base::floatfield); + return __base; + } + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif /* _IOS_BASE_H */ diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/istream.tcc b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/istream.tcc new file mode 100755 index 0000000..f50d7b3 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/istream.tcc @@ -0,0 +1,1092 @@ +// istream classes -*- C++ -*- + +// Copyright (C) 1997-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file bits/istream.tcc + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{istream} + */ + +// +// ISO C++ 14882: 27.6.1 Input streams +// + +#ifndef _ISTREAM_TCC +#define _ISTREAM_TCC 1 + +#pragma GCC system_header + +#include + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + template + basic_istream<_CharT, _Traits>::sentry:: + sentry(basic_istream<_CharT, _Traits>& __in, bool __noskip) : _M_ok(false) + { + ios_base::iostate __err = ios_base::goodbit; + if (__in.good()) + { + if (__in.tie()) + __in.tie()->flush(); + if (!__noskip && bool(__in.flags() & ios_base::skipws)) + { + const __int_type __eof = traits_type::eof(); + __streambuf_type* __sb = __in.rdbuf(); + __int_type __c = __sb->sgetc(); + + const __ctype_type& __ct = __check_facet(__in._M_ctype); + while (!traits_type::eq_int_type(__c, __eof) + && __ct.is(ctype_base::space, + traits_type::to_char_type(__c))) + __c = __sb->snextc(); + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 195. Should basic_istream::sentry's constructor ever + // set eofbit? + if (traits_type::eq_int_type(__c, __eof)) + __err |= ios_base::eofbit; + } + } + + if (__in.good() && __err == ios_base::goodbit) + _M_ok = true; + else + { + __err |= ios_base::failbit; + __in.setstate(__err); + } + } + + template + template + basic_istream<_CharT, _Traits>& + basic_istream<_CharT, _Traits>:: + _M_extract(_ValueT& __v) + { + sentry __cerb(*this, false); + if (__cerb) + { + ios_base::iostate __err = ios_base::goodbit; + __try + { + const __num_get_type& __ng = __check_facet(this->_M_num_get); + __ng.get(*this, 0, *this, __err, __v); + } + __catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + __throw_exception_again; + } + __catch(...) + { this->_M_setstate(ios_base::badbit); } + if (__err) + this->setstate(__err); + } + return *this; + } + + template + basic_istream<_CharT, _Traits>& + basic_istream<_CharT, _Traits>:: + operator>>(short& __n) + { + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 118. basic_istream uses nonexistent num_get member functions. + sentry __cerb(*this, false); + if (__cerb) + { + ios_base::iostate __err = ios_base::goodbit; + __try + { + long __l; + const __num_get_type& __ng = __check_facet(this->_M_num_get); + __ng.get(*this, 0, *this, __err, __l); + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 696. istream::operator>>(int&) broken. + if (__l < __gnu_cxx::__numeric_traits::__min) + { + __err |= ios_base::failbit; + __n = __gnu_cxx::__numeric_traits::__min; + } + else if (__l > __gnu_cxx::__numeric_traits::__max) + { + __err |= ios_base::failbit; + __n = __gnu_cxx::__numeric_traits::__max; + } + else + __n = short(__l); + } + __catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + __throw_exception_again; + } + __catch(...) + { this->_M_setstate(ios_base::badbit); } + if (__err) + this->setstate(__err); + } + return *this; + } + + template + basic_istream<_CharT, _Traits>& + basic_istream<_CharT, _Traits>:: + operator>>(int& __n) + { + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 118. basic_istream uses nonexistent num_get member functions. + sentry __cerb(*this, false); + if (__cerb) + { + ios_base::iostate __err = ios_base::goodbit; + __try + { + long __l; + const __num_get_type& __ng = __check_facet(this->_M_num_get); + __ng.get(*this, 0, *this, __err, __l); + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 696. istream::operator>>(int&) broken. + if (__l < __gnu_cxx::__numeric_traits::__min) + { + __err |= ios_base::failbit; + __n = __gnu_cxx::__numeric_traits::__min; + } + else if (__l > __gnu_cxx::__numeric_traits::__max) + { + __err |= ios_base::failbit; + __n = __gnu_cxx::__numeric_traits::__max; + } + else + __n = int(__l); + } + __catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + __throw_exception_again; + } + __catch(...) + { this->_M_setstate(ios_base::badbit); } + if (__err) + this->setstate(__err); + } + return *this; + } + + template + basic_istream<_CharT, _Traits>& + basic_istream<_CharT, _Traits>:: + operator>>(__streambuf_type* __sbout) + { + ios_base::iostate __err = ios_base::goodbit; + sentry __cerb(*this, false); + if (__cerb && __sbout) + { + __try + { + bool __ineof; + if (!__copy_streambufs_eof(this->rdbuf(), __sbout, __ineof)) + __err |= ios_base::failbit; + if (__ineof) + __err |= ios_base::eofbit; + } + __catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::failbit); + __throw_exception_again; + } + __catch(...) + { this->_M_setstate(ios_base::failbit); } + } + else if (!__sbout) + __err |= ios_base::failbit; + if (__err) + this->setstate(__err); + return *this; + } + + template + typename basic_istream<_CharT, _Traits>::int_type + basic_istream<_CharT, _Traits>:: + get(void) + { + const int_type __eof = traits_type::eof(); + int_type __c = __eof; + _M_gcount = 0; + ios_base::iostate __err = ios_base::goodbit; + sentry __cerb(*this, true); + if (__cerb) + { + __try + { + __c = this->rdbuf()->sbumpc(); + // 27.6.1.1 paragraph 3 + if (!traits_type::eq_int_type(__c, __eof)) + _M_gcount = 1; + else + __err |= ios_base::eofbit; + } + __catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + __throw_exception_again; + } + __catch(...) + { this->_M_setstate(ios_base::badbit); } + } + if (!_M_gcount) + __err |= ios_base::failbit; + if (__err) + this->setstate(__err); + return __c; + } + + template + basic_istream<_CharT, _Traits>& + basic_istream<_CharT, _Traits>:: + get(char_type& __c) + { + _M_gcount = 0; + ios_base::iostate __err = ios_base::goodbit; + sentry __cerb(*this, true); + if (__cerb) + { + __try + { + const int_type __cb = this->rdbuf()->sbumpc(); + // 27.6.1.1 paragraph 3 + if (!traits_type::eq_int_type(__cb, traits_type::eof())) + { + _M_gcount = 1; + __c = traits_type::to_char_type(__cb); + } + else + __err |= ios_base::eofbit; + } + __catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + __throw_exception_again; + } + __catch(...) + { this->_M_setstate(ios_base::badbit); } + } + if (!_M_gcount) + __err |= ios_base::failbit; + if (__err) + this->setstate(__err); + return *this; + } + + template + basic_istream<_CharT, _Traits>& + basic_istream<_CharT, _Traits>:: + get(char_type* __s, streamsize __n, char_type __delim) + { + _M_gcount = 0; + ios_base::iostate __err = ios_base::goodbit; + sentry __cerb(*this, true); + if (__cerb) + { + __try + { + const int_type __idelim = traits_type::to_int_type(__delim); + const int_type __eof = traits_type::eof(); + __streambuf_type* __sb = this->rdbuf(); + int_type __c = __sb->sgetc(); + + while (_M_gcount + 1 < __n + && !traits_type::eq_int_type(__c, __eof) + && !traits_type::eq_int_type(__c, __idelim)) + { + *__s++ = traits_type::to_char_type(__c); + ++_M_gcount; + __c = __sb->snextc(); + } + if (traits_type::eq_int_type(__c, __eof)) + __err |= ios_base::eofbit; + } + __catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + __throw_exception_again; + } + __catch(...) + { this->_M_setstate(ios_base::badbit); } + } + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 243. get and getline when sentry reports failure. + if (__n > 0) + *__s = char_type(); + if (!_M_gcount) + __err |= ios_base::failbit; + if (__err) + this->setstate(__err); + return *this; + } + + template + basic_istream<_CharT, _Traits>& + basic_istream<_CharT, _Traits>:: + get(__streambuf_type& __sb, char_type __delim) + { + _M_gcount = 0; + ios_base::iostate __err = ios_base::goodbit; + sentry __cerb(*this, true); + if (__cerb) + { + __try + { + const int_type __idelim = traits_type::to_int_type(__delim); + const int_type __eof = traits_type::eof(); + __streambuf_type* __this_sb = this->rdbuf(); + int_type __c = __this_sb->sgetc(); + char_type __c2 = traits_type::to_char_type(__c); + + while (!traits_type::eq_int_type(__c, __eof) + && !traits_type::eq_int_type(__c, __idelim) + && !traits_type::eq_int_type(__sb.sputc(__c2), __eof)) + { + ++_M_gcount; + __c = __this_sb->snextc(); + __c2 = traits_type::to_char_type(__c); + } + if (traits_type::eq_int_type(__c, __eof)) + __err |= ios_base::eofbit; + } + __catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + __throw_exception_again; + } + __catch(...) + { this->_M_setstate(ios_base::badbit); } + } + if (!_M_gcount) + __err |= ios_base::failbit; + if (__err) + this->setstate(__err); + return *this; + } + + template + basic_istream<_CharT, _Traits>& + basic_istream<_CharT, _Traits>:: + getline(char_type* __s, streamsize __n, char_type __delim) + { + _M_gcount = 0; + ios_base::iostate __err = ios_base::goodbit; + sentry __cerb(*this, true); + if (__cerb) + { + __try + { + const int_type __idelim = traits_type::to_int_type(__delim); + const int_type __eof = traits_type::eof(); + __streambuf_type* __sb = this->rdbuf(); + int_type __c = __sb->sgetc(); + + while (_M_gcount + 1 < __n + && !traits_type::eq_int_type(__c, __eof) + && !traits_type::eq_int_type(__c, __idelim)) + { + *__s++ = traits_type::to_char_type(__c); + __c = __sb->snextc(); + ++_M_gcount; + } + if (traits_type::eq_int_type(__c, __eof)) + __err |= ios_base::eofbit; + else + { + if (traits_type::eq_int_type(__c, __idelim)) + { + __sb->sbumpc(); + ++_M_gcount; + } + else + __err |= ios_base::failbit; + } + } + __catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + __throw_exception_again; + } + __catch(...) + { this->_M_setstate(ios_base::badbit); } + } + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 243. get and getline when sentry reports failure. + if (__n > 0) + *__s = char_type(); + if (!_M_gcount) + __err |= ios_base::failbit; + if (__err) + this->setstate(__err); + return *this; + } + + // We provide three overloads, since the first two are much simpler + // than the general case. Also, the latter two can thus adopt the + // same "batchy" strategy used by getline above. + template + basic_istream<_CharT, _Traits>& + basic_istream<_CharT, _Traits>:: + ignore(void) + { + _M_gcount = 0; + sentry __cerb(*this, true); + if (__cerb) + { + ios_base::iostate __err = ios_base::goodbit; + __try + { + const int_type __eof = traits_type::eof(); + __streambuf_type* __sb = this->rdbuf(); + + if (traits_type::eq_int_type(__sb->sbumpc(), __eof)) + __err |= ios_base::eofbit; + else + _M_gcount = 1; + } + __catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + __throw_exception_again; + } + __catch(...) + { this->_M_setstate(ios_base::badbit); } + if (__err) + this->setstate(__err); + } + return *this; + } + + template + basic_istream<_CharT, _Traits>& + basic_istream<_CharT, _Traits>:: + ignore(streamsize __n) + { + _M_gcount = 0; + sentry __cerb(*this, true); + if (__cerb && __n > 0) + { + ios_base::iostate __err = ios_base::goodbit; + __try + { + const int_type __eof = traits_type::eof(); + __streambuf_type* __sb = this->rdbuf(); + int_type __c = __sb->sgetc(); + + // N.B. On LFS-enabled platforms streamsize is still 32 bits + // wide: if we want to implement the standard mandated behavior + // for n == max() (see 27.6.1.3/24) we are at risk of signed + // integer overflow: thus these contortions. Also note that, + // by definition, when more than 2G chars are actually ignored, + // _M_gcount (the return value of gcount, that is) cannot be + // really correct, being unavoidably too small. + bool __large_ignore = false; + while (true) + { + while (_M_gcount < __n + && !traits_type::eq_int_type(__c, __eof)) + { + ++_M_gcount; + __c = __sb->snextc(); + } + if (__n == __gnu_cxx::__numeric_traits::__max + && !traits_type::eq_int_type(__c, __eof)) + { + _M_gcount = + __gnu_cxx::__numeric_traits::__min; + __large_ignore = true; + } + else + break; + } + + if (__large_ignore) + _M_gcount = __gnu_cxx::__numeric_traits::__max; + + if (traits_type::eq_int_type(__c, __eof)) + __err |= ios_base::eofbit; + } + __catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + __throw_exception_again; + } + __catch(...) + { this->_M_setstate(ios_base::badbit); } + if (__err) + this->setstate(__err); + } + return *this; + } + + template + basic_istream<_CharT, _Traits>& + basic_istream<_CharT, _Traits>:: + ignore(streamsize __n, int_type __delim) + { + _M_gcount = 0; + sentry __cerb(*this, true); + if (__cerb && __n > 0) + { + ios_base::iostate __err = ios_base::goodbit; + __try + { + const int_type __eof = traits_type::eof(); + __streambuf_type* __sb = this->rdbuf(); + int_type __c = __sb->sgetc(); + + // See comment above. + bool __large_ignore = false; + while (true) + { + while (_M_gcount < __n + && !traits_type::eq_int_type(__c, __eof) + && !traits_type::eq_int_type(__c, __delim)) + { + ++_M_gcount; + __c = __sb->snextc(); + } + if (__n == __gnu_cxx::__numeric_traits::__max + && !traits_type::eq_int_type(__c, __eof) + && !traits_type::eq_int_type(__c, __delim)) + { + _M_gcount = + __gnu_cxx::__numeric_traits::__min; + __large_ignore = true; + } + else + break; + } + + if (__large_ignore) + _M_gcount = __gnu_cxx::__numeric_traits::__max; + + if (traits_type::eq_int_type(__c, __eof)) + __err |= ios_base::eofbit; + else if (traits_type::eq_int_type(__c, __delim)) + { + if (_M_gcount + < __gnu_cxx::__numeric_traits::__max) + ++_M_gcount; + __sb->sbumpc(); + } + } + __catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + __throw_exception_again; + } + __catch(...) + { this->_M_setstate(ios_base::badbit); } + if (__err) + this->setstate(__err); + } + return *this; + } + + template + typename basic_istream<_CharT, _Traits>::int_type + basic_istream<_CharT, _Traits>:: + peek(void) + { + int_type __c = traits_type::eof(); + _M_gcount = 0; + sentry __cerb(*this, true); + if (__cerb) + { + ios_base::iostate __err = ios_base::goodbit; + __try + { + __c = this->rdbuf()->sgetc(); + if (traits_type::eq_int_type(__c, traits_type::eof())) + __err |= ios_base::eofbit; + } + __catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + __throw_exception_again; + } + __catch(...) + { this->_M_setstate(ios_base::badbit); } + if (__err) + this->setstate(__err); + } + return __c; + } + + template + basic_istream<_CharT, _Traits>& + basic_istream<_CharT, _Traits>:: + read(char_type* __s, streamsize __n) + { + _M_gcount = 0; + sentry __cerb(*this, true); + if (__cerb) + { + ios_base::iostate __err = ios_base::goodbit; + __try + { + _M_gcount = this->rdbuf()->sgetn(__s, __n); + if (_M_gcount != __n) + __err |= (ios_base::eofbit | ios_base::failbit); + } + __catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + __throw_exception_again; + } + __catch(...) + { this->_M_setstate(ios_base::badbit); } + if (__err) + this->setstate(__err); + } + return *this; + } + + template + streamsize + basic_istream<_CharT, _Traits>:: + readsome(char_type* __s, streamsize __n) + { + _M_gcount = 0; + sentry __cerb(*this, true); + if (__cerb) + { + ios_base::iostate __err = ios_base::goodbit; + __try + { + // Cannot compare int_type with streamsize generically. + const streamsize __num = this->rdbuf()->in_avail(); + if (__num > 0) + _M_gcount = this->rdbuf()->sgetn(__s, std::min(__num, __n)); + else if (__num == -1) + __err |= ios_base::eofbit; + } + __catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + __throw_exception_again; + } + __catch(...) + { this->_M_setstate(ios_base::badbit); } + if (__err) + this->setstate(__err); + } + return _M_gcount; + } + + template + basic_istream<_CharT, _Traits>& + basic_istream<_CharT, _Traits>:: + putback(char_type __c) + { + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 60. What is a formatted input function? + _M_gcount = 0; + // Clear eofbit per N3168. + this->clear(this->rdstate() & ~ios_base::eofbit); + sentry __cerb(*this, true); + if (__cerb) + { + ios_base::iostate __err = ios_base::goodbit; + __try + { + const int_type __eof = traits_type::eof(); + __streambuf_type* __sb = this->rdbuf(); + if (!__sb + || traits_type::eq_int_type(__sb->sputbackc(__c), __eof)) + __err |= ios_base::badbit; + } + __catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + __throw_exception_again; + } + __catch(...) + { this->_M_setstate(ios_base::badbit); } + if (__err) + this->setstate(__err); + } + return *this; + } + + template + basic_istream<_CharT, _Traits>& + basic_istream<_CharT, _Traits>:: + unget(void) + { + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 60. What is a formatted input function? + _M_gcount = 0; + // Clear eofbit per N3168. + this->clear(this->rdstate() & ~ios_base::eofbit); + sentry __cerb(*this, true); + if (__cerb) + { + ios_base::iostate __err = ios_base::goodbit; + __try + { + const int_type __eof = traits_type::eof(); + __streambuf_type* __sb = this->rdbuf(); + if (!__sb + || traits_type::eq_int_type(__sb->sungetc(), __eof)) + __err |= ios_base::badbit; + } + __catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + __throw_exception_again; + } + __catch(...) + { this->_M_setstate(ios_base::badbit); } + if (__err) + this->setstate(__err); + } + return *this; + } + + template + int + basic_istream<_CharT, _Traits>:: + sync(void) + { + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR60. Do not change _M_gcount. + int __ret = -1; + sentry __cerb(*this, true); + if (__cerb) + { + ios_base::iostate __err = ios_base::goodbit; + __try + { + __streambuf_type* __sb = this->rdbuf(); + if (__sb) + { + if (__sb->pubsync() == -1) + __err |= ios_base::badbit; + else + __ret = 0; + } + } + __catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + __throw_exception_again; + } + __catch(...) + { this->_M_setstate(ios_base::badbit); } + if (__err) + this->setstate(__err); + } + return __ret; + } + + template + typename basic_istream<_CharT, _Traits>::pos_type + basic_istream<_CharT, _Traits>:: + tellg(void) + { + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR60. Do not change _M_gcount. + pos_type __ret = pos_type(-1); + sentry __cerb(*this, true); + if (__cerb) + { + __try + { + if (!this->fail()) + __ret = this->rdbuf()->pubseekoff(0, ios_base::cur, + ios_base::in); + } + __catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + __throw_exception_again; + } + __catch(...) + { this->_M_setstate(ios_base::badbit); } + } + return __ret; + } + + template + basic_istream<_CharT, _Traits>& + basic_istream<_CharT, _Traits>:: + seekg(pos_type __pos) + { + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR60. Do not change _M_gcount. + // Clear eofbit per N3168. + this->clear(this->rdstate() & ~ios_base::eofbit); + sentry __cerb(*this, true); + if (__cerb) + { + ios_base::iostate __err = ios_base::goodbit; + __try + { + if (!this->fail()) + { + // 136. seekp, seekg setting wrong streams? + const pos_type __p = this->rdbuf()->pubseekpos(__pos, + ios_base::in); + + // 129. Need error indication from seekp() and seekg() + if (__p == pos_type(off_type(-1))) + __err |= ios_base::failbit; + } + } + __catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + __throw_exception_again; + } + __catch(...) + { this->_M_setstate(ios_base::badbit); } + if (__err) + this->setstate(__err); + } + return *this; + } + + template + basic_istream<_CharT, _Traits>& + basic_istream<_CharT, _Traits>:: + seekg(off_type __off, ios_base::seekdir __dir) + { + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR60. Do not change _M_gcount. + // Clear eofbit per N3168. + this->clear(this->rdstate() & ~ios_base::eofbit); + sentry __cerb(*this, true); + if (__cerb) + { + ios_base::iostate __err = ios_base::goodbit; + __try + { + if (!this->fail()) + { + // 136. seekp, seekg setting wrong streams? + const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir, + ios_base::in); + + // 129. Need error indication from seekp() and seekg() + if (__p == pos_type(off_type(-1))) + __err |= ios_base::failbit; + } + } + __catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + __throw_exception_again; + } + __catch(...) + { this->_M_setstate(ios_base::badbit); } + if (__err) + this->setstate(__err); + } + return *this; + } + + // 27.6.1.2.3 Character extraction templates + template + basic_istream<_CharT, _Traits>& + operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c) + { + typedef basic_istream<_CharT, _Traits> __istream_type; + typedef typename __istream_type::int_type __int_type; + + typename __istream_type::sentry __cerb(__in, false); + if (__cerb) + { + ios_base::iostate __err = ios_base::goodbit; + __try + { + const __int_type __cb = __in.rdbuf()->sbumpc(); + if (!_Traits::eq_int_type(__cb, _Traits::eof())) + __c = _Traits::to_char_type(__cb); + else + __err |= (ios_base::eofbit | ios_base::failbit); + } + __catch(__cxxabiv1::__forced_unwind&) + { + __in._M_setstate(ios_base::badbit); + __throw_exception_again; + } + __catch(...) + { __in._M_setstate(ios_base::badbit); } + if (__err) + __in.setstate(__err); + } + return __in; + } + + template + basic_istream<_CharT, _Traits>& + operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s) + { + typedef basic_istream<_CharT, _Traits> __istream_type; + typedef basic_streambuf<_CharT, _Traits> __streambuf_type; + typedef typename _Traits::int_type int_type; + typedef _CharT char_type; + typedef ctype<_CharT> __ctype_type; + + streamsize __extracted = 0; + ios_base::iostate __err = ios_base::goodbit; + typename __istream_type::sentry __cerb(__in, false); + if (__cerb) + { + __try + { + // Figure out how many characters to extract. + streamsize __num = __in.width(); + if (__num <= 0) + __num = __gnu_cxx::__numeric_traits::__max; + + const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc()); + + const int_type __eof = _Traits::eof(); + __streambuf_type* __sb = __in.rdbuf(); + int_type __c = __sb->sgetc(); + + while (__extracted < __num - 1 + && !_Traits::eq_int_type(__c, __eof) + && !__ct.is(ctype_base::space, + _Traits::to_char_type(__c))) + { + *__s++ = _Traits::to_char_type(__c); + ++__extracted; + __c = __sb->snextc(); + } + if (_Traits::eq_int_type(__c, __eof)) + __err |= ios_base::eofbit; + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 68. Extractors for char* should store null at end + *__s = char_type(); + __in.width(0); + } + __catch(__cxxabiv1::__forced_unwind&) + { + __in._M_setstate(ios_base::badbit); + __throw_exception_again; + } + __catch(...) + { __in._M_setstate(ios_base::badbit); } + } + if (!__extracted) + __err |= ios_base::failbit; + if (__err) + __in.setstate(__err); + return __in; + } + + // 27.6.1.4 Standard basic_istream manipulators + template + basic_istream<_CharT, _Traits>& + ws(basic_istream<_CharT, _Traits>& __in) + { + typedef basic_istream<_CharT, _Traits> __istream_type; + typedef basic_streambuf<_CharT, _Traits> __streambuf_type; + typedef typename __istream_type::int_type __int_type; + typedef ctype<_CharT> __ctype_type; + + const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc()); + const __int_type __eof = _Traits::eof(); + __streambuf_type* __sb = __in.rdbuf(); + __int_type __c = __sb->sgetc(); + + while (!_Traits::eq_int_type(__c, __eof) + && __ct.is(ctype_base::space, _Traits::to_char_type(__c))) + __c = __sb->snextc(); + + if (_Traits::eq_int_type(__c, __eof)) + __in.setstate(ios_base::eofbit); + return __in; + } + + // Inhibit implicit instantiations for required instantiations, + // which are defined via explicit instantiations elsewhere. +#if _GLIBCXX_EXTERN_TEMPLATE + extern template class basic_istream; + extern template istream& ws(istream&); + extern template istream& operator>>(istream&, char&); + extern template istream& operator>>(istream&, char*); + extern template istream& operator>>(istream&, unsigned char&); + extern template istream& operator>>(istream&, signed char&); + extern template istream& operator>>(istream&, unsigned char*); + extern template istream& operator>>(istream&, signed char*); + + extern template istream& istream::_M_extract(unsigned short&); + extern template istream& istream::_M_extract(unsigned int&); + extern template istream& istream::_M_extract(long&); + extern template istream& istream::_M_extract(unsigned long&); + extern template istream& istream::_M_extract(bool&); +#ifdef _GLIBCXX_USE_LONG_LONG + extern template istream& istream::_M_extract(long long&); + extern template istream& istream::_M_extract(unsigned long long&); +#endif + extern template istream& istream::_M_extract(float&); + extern template istream& istream::_M_extract(double&); + extern template istream& istream::_M_extract(long double&); + extern template istream& istream::_M_extract(void*&); + + extern template class basic_iostream; + +#ifdef _GLIBCXX_USE_WCHAR_T + extern template class basic_istream; + extern template wistream& ws(wistream&); + extern template wistream& operator>>(wistream&, wchar_t&); + extern template wistream& operator>>(wistream&, wchar_t*); + + extern template wistream& wistream::_M_extract(unsigned short&); + extern template wistream& wistream::_M_extract(unsigned int&); + extern template wistream& wistream::_M_extract(long&); + extern template wistream& wistream::_M_extract(unsigned long&); + extern template wistream& wistream::_M_extract(bool&); +#ifdef _GLIBCXX_USE_LONG_LONG + extern template wistream& wistream::_M_extract(long long&); + extern template wistream& wistream::_M_extract(unsigned long long&); +#endif + extern template wistream& wistream::_M_extract(float&); + extern template wistream& wistream::_M_extract(double&); + extern template wistream& wistream::_M_extract(long double&); + extern template wistream& wistream::_M_extract(void*&); + + extern template class basic_iostream; +#endif +#endif + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace std + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/list.tcc b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/list.tcc new file mode 100755 index 0000000..42855a4 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/list.tcc @@ -0,0 +1,511 @@ +// List implementation (out of line) -*- C++ -*- + +// Copyright (C) 2001-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/* + * + * Copyright (c) 1994 + * Hewlett-Packard Company + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Hewlett-Packard Company makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + * + * + * Copyright (c) 1996,1997 + * Silicon Graphics Computer Systems, Inc. + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Silicon Graphics makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + */ + +/** @file bits/list.tcc + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{list} + */ + +#ifndef _LIST_TCC +#define _LIST_TCC 1 + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_CONTAINER + + template + void + _List_base<_Tp, _Alloc>:: + _M_clear() _GLIBCXX_NOEXCEPT + { + typedef _List_node<_Tp> _Node; + _Node* __cur = static_cast<_Node*>(_M_impl._M_node._M_next); + while (__cur != &_M_impl._M_node) + { + _Node* __tmp = __cur; + __cur = static_cast<_Node*>(__cur->_M_next); +#if __cplusplus >= 201103L + _M_get_Node_allocator().destroy(__tmp); +#else + _M_get_Tp_allocator().destroy(std::__addressof(__tmp->_M_data)); +#endif + _M_put_node(__tmp); + } + } + +#if __cplusplus >= 201103L + template + template + typename list<_Tp, _Alloc>::iterator + list<_Tp, _Alloc>:: + emplace(const_iterator __position, _Args&&... __args) + { + _Node* __tmp = _M_create_node(std::forward<_Args>(__args)...); + __tmp->_M_hook(__position._M_const_cast()._M_node); + return iterator(__tmp); + } +#endif + + template + typename list<_Tp, _Alloc>::iterator + list<_Tp, _Alloc>:: +#if __cplusplus >= 201103L + insert(const_iterator __position, const value_type& __x) +#else + insert(iterator __position, const value_type& __x) +#endif + { + _Node* __tmp = _M_create_node(__x); + __tmp->_M_hook(__position._M_const_cast()._M_node); + return iterator(__tmp); + } + +#if __cplusplus >= 201103L + template + typename list<_Tp, _Alloc>::iterator + list<_Tp, _Alloc>:: + insert(const_iterator __position, size_type __n, const value_type& __x) + { + if (__n) + { + list __tmp(__n, __x, get_allocator()); + iterator __it = __tmp.begin(); + splice(__position, __tmp); + return __it; + } + return __position._M_const_cast(); + } + + template + template + typename list<_Tp, _Alloc>::iterator + list<_Tp, _Alloc>:: + insert(const_iterator __position, _InputIterator __first, + _InputIterator __last) + { + list __tmp(__first, __last, get_allocator()); + if (!__tmp.empty()) + { + iterator __it = __tmp.begin(); + splice(__position, __tmp); + return __it; + } + return __position._M_const_cast(); + } +#endif + + template + typename list<_Tp, _Alloc>::iterator + list<_Tp, _Alloc>:: +#if __cplusplus >= 201103L + erase(const_iterator __position) noexcept +#else + erase(iterator __position) +#endif + { + iterator __ret = iterator(__position._M_node->_M_next); + _M_erase(__position._M_const_cast()); + return __ret; + } + +#if __cplusplus >= 201103L + template + void + list<_Tp, _Alloc>:: + _M_default_append(size_type __n) + { + size_type __i = 0; + __try + { + for (; __i < __n; ++__i) + emplace_back(); + } + __catch(...) + { + for (; __i; --__i) + pop_back(); + __throw_exception_again; + } + } + + template + void + list<_Tp, _Alloc>:: + resize(size_type __new_size) + { + iterator __i = begin(); + size_type __len = 0; + for (; __i != end() && __len < __new_size; ++__i, ++__len) + ; + if (__len == __new_size) + erase(__i, end()); + else // __i == end() + _M_default_append(__new_size - __len); + } + + template + void + list<_Tp, _Alloc>:: + resize(size_type __new_size, const value_type& __x) + { + iterator __i = begin(); + size_type __len = 0; + for (; __i != end() && __len < __new_size; ++__i, ++__len) + ; + if (__len == __new_size) + erase(__i, end()); + else // __i == end() + insert(end(), __new_size - __len, __x); + } +#else + template + void + list<_Tp, _Alloc>:: + resize(size_type __new_size, value_type __x) + { + iterator __i = begin(); + size_type __len = 0; + for (; __i != end() && __len < __new_size; ++__i, ++__len) + ; + if (__len == __new_size) + erase(__i, end()); + else // __i == end() + insert(end(), __new_size - __len, __x); + } +#endif + + template + list<_Tp, _Alloc>& + list<_Tp, _Alloc>:: + operator=(const list& __x) + { + if (this != &__x) + { + iterator __first1 = begin(); + iterator __last1 = end(); + const_iterator __first2 = __x.begin(); + const_iterator __last2 = __x.end(); + for (; __first1 != __last1 && __first2 != __last2; + ++__first1, ++__first2) + *__first1 = *__first2; + if (__first2 == __last2) + erase(__first1, __last1); + else + insert(__last1, __first2, __last2); + } + return *this; + } + + template + void + list<_Tp, _Alloc>:: + _M_fill_assign(size_type __n, const value_type& __val) + { + iterator __i = begin(); + for (; __i != end() && __n > 0; ++__i, --__n) + *__i = __val; + if (__n > 0) + insert(end(), __n, __val); + else + erase(__i, end()); + } + + template + template + void + list<_Tp, _Alloc>:: + _M_assign_dispatch(_InputIterator __first2, _InputIterator __last2, + __false_type) + { + iterator __first1 = begin(); + iterator __last1 = end(); + for (; __first1 != __last1 && __first2 != __last2; + ++__first1, ++__first2) + *__first1 = *__first2; + if (__first2 == __last2) + erase(__first1, __last1); + else + insert(__last1, __first2, __last2); + } + + template + void + list<_Tp, _Alloc>:: + remove(const value_type& __value) + { + iterator __first = begin(); + iterator __last = end(); + iterator __extra = __last; + while (__first != __last) + { + iterator __next = __first; + ++__next; + if (*__first == __value) + { + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 526. Is it undefined if a function in the standard changes + // in parameters? + if (std::__addressof(*__first) != std::__addressof(__value)) + _M_erase(__first); + else + __extra = __first; + } + __first = __next; + } + if (__extra != __last) + _M_erase(__extra); + } + + template + void + list<_Tp, _Alloc>:: + unique() + { + iterator __first = begin(); + iterator __last = end(); + if (__first == __last) + return; + iterator __next = __first; + while (++__next != __last) + { + if (*__first == *__next) + _M_erase(__next); + else + __first = __next; + __next = __first; + } + } + + template + void + list<_Tp, _Alloc>:: +#if __cplusplus >= 201103L + merge(list&& __x) +#else + merge(list& __x) +#endif + { + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 300. list::merge() specification incomplete + if (this != &__x) + { + _M_check_equal_allocators(__x); + + iterator __first1 = begin(); + iterator __last1 = end(); + iterator __first2 = __x.begin(); + iterator __last2 = __x.end(); + while (__first1 != __last1 && __first2 != __last2) + if (*__first2 < *__first1) + { + iterator __next = __first2; + _M_transfer(__first1, __first2, ++__next); + __first2 = __next; + } + else + ++__first1; + if (__first2 != __last2) + _M_transfer(__last1, __first2, __last2); + } + } + + template + template + void + list<_Tp, _Alloc>:: +#if __cplusplus >= 201103L + merge(list&& __x, _StrictWeakOrdering __comp) +#else + merge(list& __x, _StrictWeakOrdering __comp) +#endif + { + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 300. list::merge() specification incomplete + if (this != &__x) + { + _M_check_equal_allocators(__x); + + iterator __first1 = begin(); + iterator __last1 = end(); + iterator __first2 = __x.begin(); + iterator __last2 = __x.end(); + while (__first1 != __last1 && __first2 != __last2) + if (__comp(*__first2, *__first1)) + { + iterator __next = __first2; + _M_transfer(__first1, __first2, ++__next); + __first2 = __next; + } + else + ++__first1; + if (__first2 != __last2) + _M_transfer(__last1, __first2, __last2); + } + } + + template + void + list<_Tp, _Alloc>:: + sort() + { + // Do nothing if the list has length 0 or 1. + if (this->_M_impl._M_node._M_next != &this->_M_impl._M_node + && this->_M_impl._M_node._M_next->_M_next != &this->_M_impl._M_node) + { + list __carry; + list __tmp[64]; + list * __fill = &__tmp[0]; + list * __counter; + + do + { + __carry.splice(__carry.begin(), *this, begin()); + + for(__counter = &__tmp[0]; + __counter != __fill && !__counter->empty(); + ++__counter) + { + __counter->merge(__carry); + __carry.swap(*__counter); + } + __carry.swap(*__counter); + if (__counter == __fill) + ++__fill; + } + while ( !empty() ); + + for (__counter = &__tmp[1]; __counter != __fill; ++__counter) + __counter->merge(*(__counter - 1)); + swap( *(__fill - 1) ); + } + } + + template + template + void + list<_Tp, _Alloc>:: + remove_if(_Predicate __pred) + { + iterator __first = begin(); + iterator __last = end(); + while (__first != __last) + { + iterator __next = __first; + ++__next; + if (__pred(*__first)) + _M_erase(__first); + __first = __next; + } + } + + template + template + void + list<_Tp, _Alloc>:: + unique(_BinaryPredicate __binary_pred) + { + iterator __first = begin(); + iterator __last = end(); + if (__first == __last) + return; + iterator __next = __first; + while (++__next != __last) + { + if (__binary_pred(*__first, *__next)) + _M_erase(__next); + else + __first = __next; + __next = __first; + } + } + + template + template + void + list<_Tp, _Alloc>:: + sort(_StrictWeakOrdering __comp) + { + // Do nothing if the list has length 0 or 1. + if (this->_M_impl._M_node._M_next != &this->_M_impl._M_node + && this->_M_impl._M_node._M_next->_M_next != &this->_M_impl._M_node) + { + list __carry; + list __tmp[64]; + list * __fill = &__tmp[0]; + list * __counter; + + do + { + __carry.splice(__carry.begin(), *this, begin()); + + for(__counter = &__tmp[0]; + __counter != __fill && !__counter->empty(); + ++__counter) + { + __counter->merge(__carry, __comp); + __carry.swap(*__counter); + } + __carry.swap(*__counter); + if (__counter == __fill) + ++__fill; + } + while ( !empty() ); + + for (__counter = &__tmp[1]; __counter != __fill; ++__counter) + __counter->merge(*(__counter - 1), __comp); + swap(*(__fill - 1)); + } + } + +_GLIBCXX_END_NAMESPACE_CONTAINER +} // namespace std + +#endif /* _LIST_TCC */ + diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/locale_classes.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/locale_classes.h new file mode 100755 index 0000000..6dd452a --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/locale_classes.h @@ -0,0 +1,789 @@ +// Locale support -*- C++ -*- + +// Copyright (C) 1997-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file bits/locale_classes.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{locale} + */ + +// +// ISO C++ 14882: 22.1 Locales +// + +#ifndef _LOCALE_CLASSES_H +#define _LOCALE_CLASSES_H 1 + +#pragma GCC system_header + +#include +#include +#include + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + // 22.1.1 Class locale + /** + * @brief Container class for localization functionality. + * @ingroup locales + * + * The locale class is first a class wrapper for C library locales. It is + * also an extensible container for user-defined localization. A locale is + * a collection of facets that implement various localization features such + * as money, time, and number printing. + * + * Constructing C++ locales does not change the C library locale. + * + * This library supports efficient construction and copying of locales + * through a reference counting implementation of the locale class. + */ + class locale + { + public: + // Types: + /// Definition of locale::category. + typedef int category; + + // Forward decls and friends: + class facet; + class id; + class _Impl; + + friend class facet; + friend class _Impl; + + template + friend bool + has_facet(const locale&) throw(); + + template + friend const _Facet& + use_facet(const locale&); + + template + friend struct __use_cache; + + //@{ + /** + * @brief Category values. + * + * The standard category values are none, ctype, numeric, collate, time, + * monetary, and messages. They form a bitmask that supports union and + * intersection. The category all is the union of these values. + * + * NB: Order must match _S_facet_categories definition in locale.cc + */ + static const category none = 0; + static const category ctype = 1L << 0; + static const category numeric = 1L << 1; + static const category collate = 1L << 2; + static const category time = 1L << 3; + static const category monetary = 1L << 4; + static const category messages = 1L << 5; + static const category all = (ctype | numeric | collate | + time | monetary | messages); + //@} + + // Construct/copy/destroy: + + /** + * @brief Default constructor. + * + * Constructs a copy of the global locale. If no locale has been + * explicitly set, this is the C locale. + */ + locale() throw(); + + /** + * @brief Copy constructor. + * + * Constructs a copy of @a other. + * + * @param __other The locale to copy. + */ + locale(const locale& __other) throw(); + + /** + * @brief Named locale constructor. + * + * Constructs a copy of the named C library locale. + * + * @param __s Name of the locale to construct. + * @throw std::runtime_error if __s is null or an undefined locale. + */ + explicit + locale(const char* __s); + + /** + * @brief Construct locale with facets from another locale. + * + * Constructs a copy of the locale @a base. The facets specified by @a + * cat are replaced with those from the locale named by @a s. If base is + * named, this locale instance will also be named. + * + * @param __base The locale to copy. + * @param __s Name of the locale to use facets from. + * @param __cat Set of categories defining the facets to use from __s. + * @throw std::runtime_error if __s is null or an undefined locale. + */ + locale(const locale& __base, const char* __s, category __cat); + + /** + * @brief Construct locale with facets from another locale. + * + * Constructs a copy of the locale @a base. The facets specified by @a + * cat are replaced with those from the locale @a add. If @a base and @a + * add are named, this locale instance will also be named. + * + * @param __base The locale to copy. + * @param __add The locale to use facets from. + * @param __cat Set of categories defining the facets to use from add. + */ + locale(const locale& __base, const locale& __add, category __cat); + + /** + * @brief Construct locale with another facet. + * + * Constructs a copy of the locale @a __other. The facet @a __f + * is added to @a __other, replacing an existing facet of type + * Facet if there is one. If @a __f is null, this locale is a + * copy of @a __other. + * + * @param __other The locale to copy. + * @param __f The facet to add in. + */ + template + locale(const locale& __other, _Facet* __f); + + /// Locale destructor. + ~locale() throw(); + + /** + * @brief Assignment operator. + * + * Set this locale to be a copy of @a other. + * + * @param __other The locale to copy. + * @return A reference to this locale. + */ + const locale& + operator=(const locale& __other) throw(); + + /** + * @brief Construct locale with another facet. + * + * Constructs and returns a new copy of this locale. Adds or replaces an + * existing facet of type Facet from the locale @a other into the new + * locale. + * + * @tparam _Facet The facet type to copy from other + * @param __other The locale to copy from. + * @return Newly constructed locale. + * @throw std::runtime_error if __other has no facet of type _Facet. + */ + template + locale + combine(const locale& __other) const; + + // Locale operations: + /** + * @brief Return locale name. + * @return Locale name or "*" if unnamed. + */ + string + name() const; + + /** + * @brief Locale equality. + * + * @param __other The locale to compare against. + * @return True if other and this refer to the same locale instance, are + * copies, or have the same name. False otherwise. + */ + bool + operator==(const locale& __other) const throw(); + + /** + * @brief Locale inequality. + * + * @param __other The locale to compare against. + * @return ! (*this == __other) + */ + bool + operator!=(const locale& __other) const throw() + { return !(this->operator==(__other)); } + + /** + * @brief Compare two strings according to collate. + * + * Template operator to compare two strings using the compare function of + * the collate facet in this locale. One use is to provide the locale to + * the sort function. For example, a vector v of strings could be sorted + * according to locale loc by doing: + * @code + * std::sort(v.begin(), v.end(), loc); + * @endcode + * + * @param __s1 First string to compare. + * @param __s2 Second string to compare. + * @return True if collate<_Char> facet compares __s1 < __s2, else false. + */ + template + bool + operator()(const basic_string<_Char, _Traits, _Alloc>& __s1, + const basic_string<_Char, _Traits, _Alloc>& __s2) const; + + // Global locale objects: + /** + * @brief Set global locale + * + * This function sets the global locale to the argument and returns a + * copy of the previous global locale. If the argument has a name, it + * will also call std::setlocale(LC_ALL, loc.name()). + * + * @param __loc The new locale to make global. + * @return Copy of the old global locale. + */ + static locale + global(const locale& __loc); + + /** + * @brief Return reference to the C locale. + */ + static const locale& + classic(); + + private: + // The (shared) implementation + _Impl* _M_impl; + + // The "C" reference locale + static _Impl* _S_classic; + + // Current global locale + static _Impl* _S_global; + + // Names of underlying locale categories. + // NB: locale::global() has to know how to modify all the + // underlying categories, not just the ones required by the C++ + // standard. + static const char* const* const _S_categories; + + // Number of standard categories. For C++, these categories are + // collate, ctype, monetary, numeric, time, and messages. These + // directly correspond to ISO C99 macros LC_COLLATE, LC_CTYPE, + // LC_MONETARY, LC_NUMERIC, and LC_TIME. In addition, POSIX (IEEE + // 1003.1-2001) specifies LC_MESSAGES. + // In addition to the standard categories, the underlying + // operating system is allowed to define extra LC_* + // macros. For GNU systems, the following are also valid: + // LC_PAPER, LC_NAME, LC_ADDRESS, LC_TELEPHONE, LC_MEASUREMENT, + // and LC_IDENTIFICATION. + enum { _S_categories_size = 6 + _GLIBCXX_NUM_CATEGORIES }; + +#ifdef __GTHREADS + static __gthread_once_t _S_once; +#endif + + explicit + locale(_Impl*) throw(); + + static void + _S_initialize(); + + static void + _S_initialize_once() throw(); + + static category + _S_normalize_category(category); + + void + _M_coalesce(const locale& __base, const locale& __add, category __cat); + }; + + + // 22.1.1.1.2 Class locale::facet + /** + * @brief Localization functionality base class. + * @ingroup locales + * + * The facet class is the base class for a localization feature, such as + * money, time, and number printing. It provides common support for facets + * and reference management. + * + * Facets may not be copied or assigned. + */ + class locale::facet + { + private: + friend class locale; + friend class locale::_Impl; + + mutable _Atomic_word _M_refcount; + + // Contains data from the underlying "C" library for the classic locale. + static __c_locale _S_c_locale; + + // String literal for the name of the classic locale. + static const char _S_c_name[2]; + +#ifdef __GTHREADS + static __gthread_once_t _S_once; +#endif + + static void + _S_initialize_once(); + + protected: + /** + * @brief Facet constructor. + * + * This is the constructor provided by the standard. If refs is 0, the + * facet is destroyed when the last referencing locale is destroyed. + * Otherwise the facet will never be destroyed. + * + * @param __refs The initial value for reference count. + */ + explicit + facet(size_t __refs = 0) throw() : _M_refcount(__refs ? 1 : 0) + { } + + /// Facet destructor. + virtual + ~facet(); + + static void + _S_create_c_locale(__c_locale& __cloc, const char* __s, + __c_locale __old = 0); + + static __c_locale + _S_clone_c_locale(__c_locale& __cloc) throw(); + + static void + _S_destroy_c_locale(__c_locale& __cloc); + + static __c_locale + _S_lc_ctype_c_locale(__c_locale __cloc, const char* __s); + + // Returns data from the underlying "C" library data for the + // classic locale. + static __c_locale + _S_get_c_locale(); + + _GLIBCXX_CONST static const char* + _S_get_c_name() throw(); + + private: + void + _M_add_reference() const throw() + { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); } + + void + _M_remove_reference() const throw() + { + // Be race-detector-friendly. For more info see bits/c++config. + _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_refcount); + if (__gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1) == 1) + { + _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_refcount); + __try + { delete this; } + __catch(...) + { } + } + } + + facet(const facet&); // Not defined. + + facet& + operator=(const facet&); // Not defined. + }; + + + // 22.1.1.1.3 Class locale::id + /** + * @brief Facet ID class. + * @ingroup locales + * + * The ID class provides facets with an index used to identify them. + * Every facet class must define a public static member locale::id, or be + * derived from a facet that provides this member, otherwise the facet + * cannot be used in a locale. The locale::id ensures that each class + * type gets a unique identifier. + */ + class locale::id + { + private: + friend class locale; + friend class locale::_Impl; + + template + friend const _Facet& + use_facet(const locale&); + + template + friend bool + has_facet(const locale&) throw(); + + // NB: There is no accessor for _M_index because it may be used + // before the constructor is run; the effect of calling a member + // function (even an inline) would be undefined. + mutable size_t _M_index; + + // Last id number assigned. + static _Atomic_word _S_refcount; + + void + operator=(const id&); // Not defined. + + id(const id&); // Not defined. + + public: + // NB: This class is always a static data member, and thus can be + // counted on to be zero-initialized. + /// Constructor. + id() { } + + size_t + _M_id() const throw(); + }; + + + // Implementation object for locale. + class locale::_Impl + { + public: + // Friends. + friend class locale; + friend class locale::facet; + + template + friend bool + has_facet(const locale&) throw(); + + template + friend const _Facet& + use_facet(const locale&); + + template + friend struct __use_cache; + + private: + // Data Members. + _Atomic_word _M_refcount; + const facet** _M_facets; + size_t _M_facets_size; + const facet** _M_caches; + char** _M_names; + static const locale::id* const _S_id_ctype[]; + static const locale::id* const _S_id_numeric[]; + static const locale::id* const _S_id_collate[]; + static const locale::id* const _S_id_time[]; + static const locale::id* const _S_id_monetary[]; + static const locale::id* const _S_id_messages[]; + static const locale::id* const* const _S_facet_categories[]; + + void + _M_add_reference() throw() + { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); } + + void + _M_remove_reference() throw() + { + // Be race-detector-friendly. For more info see bits/c++config. + _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_refcount); + if (__gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1) == 1) + { + _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_refcount); + __try + { delete this; } + __catch(...) + { } + } + } + + _Impl(const _Impl&, size_t); + _Impl(const char*, size_t); + _Impl(size_t) throw(); + + ~_Impl() throw(); + + _Impl(const _Impl&); // Not defined. + + void + operator=(const _Impl&); // Not defined. + + bool + _M_check_same_name() + { + bool __ret = true; + if (_M_names[1]) + // We must actually compare all the _M_names: can be all equal! + for (size_t __i = 0; __ret && __i < _S_categories_size - 1; ++__i) + __ret = __builtin_strcmp(_M_names[__i], _M_names[__i + 1]) == 0; + return __ret; + } + + void + _M_replace_categories(const _Impl*, category); + + void + _M_replace_category(const _Impl*, const locale::id* const*); + + void + _M_replace_facet(const _Impl*, const locale::id*); + + void + _M_install_facet(const locale::id*, const facet*); + + template + void + _M_init_facet(_Facet* __facet) + { _M_install_facet(&_Facet::id, __facet); } + + void + _M_install_cache(const facet*, size_t); + }; + + + /** + * @brief Facet for localized string comparison. + * + * This facet encapsulates the code to compare strings in a localized + * manner. + * + * The collate template uses protected virtual functions to provide + * the actual results. The public accessors forward the call to + * the virtual functions. These virtual functions are hooks for + * developers to implement the behavior they require from the + * collate facet. + */ + template + class collate : public locale::facet + { + public: + // Types: + //@{ + /// Public typedefs + typedef _CharT char_type; + typedef basic_string<_CharT> string_type; + //@} + + protected: + // Underlying "C" library locale information saved from + // initialization, needed by collate_byname as well. + __c_locale _M_c_locale_collate; + + public: + /// Numpunct facet id. + static locale::id id; + + /** + * @brief Constructor performs initialization. + * + * This is the constructor provided by the standard. + * + * @param __refs Passed to the base facet class. + */ + explicit + collate(size_t __refs = 0) + : facet(__refs), _M_c_locale_collate(_S_get_c_locale()) + { } + + /** + * @brief Internal constructor. Not for general use. + * + * This is a constructor for use by the library itself to set up new + * locales. + * + * @param __cloc The C locale. + * @param __refs Passed to the base facet class. + */ + explicit + collate(__c_locale __cloc, size_t __refs = 0) + : facet(__refs), _M_c_locale_collate(_S_clone_c_locale(__cloc)) + { } + + /** + * @brief Compare two strings. + * + * This function compares two strings and returns the result by calling + * collate::do_compare(). + * + * @param __lo1 Start of string 1. + * @param __hi1 End of string 1. + * @param __lo2 Start of string 2. + * @param __hi2 End of string 2. + * @return 1 if string1 > string2, -1 if string1 < string2, else 0. + */ + int + compare(const _CharT* __lo1, const _CharT* __hi1, + const _CharT* __lo2, const _CharT* __hi2) const + { return this->do_compare(__lo1, __hi1, __lo2, __hi2); } + + /** + * @brief Transform string to comparable form. + * + * This function is a wrapper for strxfrm functionality. It takes the + * input string and returns a modified string that can be directly + * compared to other transformed strings. In the C locale, this + * function just returns a copy of the input string. In some other + * locales, it may replace two chars with one, change a char for + * another, etc. It does so by returning collate::do_transform(). + * + * @param __lo Start of string. + * @param __hi End of string. + * @return Transformed string_type. + */ + string_type + transform(const _CharT* __lo, const _CharT* __hi) const + { return this->do_transform(__lo, __hi); } + + /** + * @brief Return hash of a string. + * + * This function computes and returns a hash on the input string. It + * does so by returning collate::do_hash(). + * + * @param __lo Start of string. + * @param __hi End of string. + * @return Hash value. + */ + long + hash(const _CharT* __lo, const _CharT* __hi) const + { return this->do_hash(__lo, __hi); } + + // Used to abstract out _CharT bits in virtual member functions, below. + int + _M_compare(const _CharT*, const _CharT*) const throw(); + + size_t + _M_transform(_CharT*, const _CharT*, size_t) const throw(); + + protected: + /// Destructor. + virtual + ~collate() + { _S_destroy_c_locale(_M_c_locale_collate); } + + /** + * @brief Compare two strings. + * + * This function is a hook for derived classes to change the value + * returned. @see compare(). + * + * @param __lo1 Start of string 1. + * @param __hi1 End of string 1. + * @param __lo2 Start of string 2. + * @param __hi2 End of string 2. + * @return 1 if string1 > string2, -1 if string1 < string2, else 0. + */ + virtual int + do_compare(const _CharT* __lo1, const _CharT* __hi1, + const _CharT* __lo2, const _CharT* __hi2) const; + + /** + * @brief Transform string to comparable form. + * + * This function is a hook for derived classes to change the value + * returned. + * + * @param __lo Start. + * @param __hi End. + * @return transformed string. + */ + virtual string_type + do_transform(const _CharT* __lo, const _CharT* __hi) const; + + /** + * @brief Return hash of a string. + * + * This function computes and returns a hash on the input string. This + * function is a hook for derived classes to change the value returned. + * + * @param __lo Start of string. + * @param __hi End of string. + * @return Hash value. + */ + virtual long + do_hash(const _CharT* __lo, const _CharT* __hi) const; + }; + + template + locale::id collate<_CharT>::id; + + // Specializations. + template<> + int + collate::_M_compare(const char*, const char*) const throw(); + + template<> + size_t + collate::_M_transform(char*, const char*, size_t) const throw(); + +#ifdef _GLIBCXX_USE_WCHAR_T + template<> + int + collate::_M_compare(const wchar_t*, const wchar_t*) const throw(); + + template<> + size_t + collate::_M_transform(wchar_t*, const wchar_t*, size_t) const throw(); +#endif + + /// class collate_byname [22.2.4.2]. + template + class collate_byname : public collate<_CharT> + { + public: + //@{ + /// Public typedefs + typedef _CharT char_type; + typedef basic_string<_CharT> string_type; + //@} + + explicit + collate_byname(const char* __s, size_t __refs = 0) + : collate<_CharT>(__refs) + { + if (__builtin_strcmp(__s, "C") != 0 + && __builtin_strcmp(__s, "POSIX") != 0) + { + this->_S_destroy_c_locale(this->_M_c_locale_collate); + this->_S_create_c_locale(this->_M_c_locale_collate, __s); + } + } + + protected: + virtual + ~collate_byname() { } + }; + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +# include + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/locale_classes.tcc b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/locale_classes.tcc new file mode 100755 index 0000000..f0188ef --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/locale_classes.tcc @@ -0,0 +1,298 @@ +// Locale support -*- C++ -*- + +// Copyright (C) 2007-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file bits/locale_classes.tcc + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{locale} + */ + +// +// ISO C++ 14882: 22.1 Locales +// + +#ifndef _LOCALE_CLASSES_TCC +#define _LOCALE_CLASSES_TCC 1 + +#pragma GCC system_header + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + template + locale:: + locale(const locale& __other, _Facet* __f) + { + _M_impl = new _Impl(*__other._M_impl, 1); + + __try + { _M_impl->_M_install_facet(&_Facet::id, __f); } + __catch(...) + { + _M_impl->_M_remove_reference(); + __throw_exception_again; + } + delete [] _M_impl->_M_names[0]; + _M_impl->_M_names[0] = 0; // Unnamed. + } + + template + locale + locale:: + combine(const locale& __other) const + { + _Impl* __tmp = new _Impl(*_M_impl, 1); + __try + { + __tmp->_M_replace_facet(__other._M_impl, &_Facet::id); + } + __catch(...) + { + __tmp->_M_remove_reference(); + __throw_exception_again; + } + return locale(__tmp); + } + + template + bool + locale:: + operator()(const basic_string<_CharT, _Traits, _Alloc>& __s1, + const basic_string<_CharT, _Traits, _Alloc>& __s2) const + { + typedef std::collate<_CharT> __collate_type; + const __collate_type& __collate = use_facet<__collate_type>(*this); + return (__collate.compare(__s1.data(), __s1.data() + __s1.length(), + __s2.data(), __s2.data() + __s2.length()) < 0); + } + + /** + * @brief Test for the presence of a facet. + * @ingroup locales + * + * has_facet tests the locale argument for the presence of the facet type + * provided as the template parameter. Facets derived from the facet + * parameter will also return true. + * + * @tparam _Facet The facet type to test the presence of. + * @param __loc The locale to test. + * @return true if @p __loc contains a facet of type _Facet, else false. + */ + template + bool + has_facet(const locale& __loc) throw() + { + const size_t __i = _Facet::id._M_id(); + const locale::facet** __facets = __loc._M_impl->_M_facets; + return (__i < __loc._M_impl->_M_facets_size +#ifdef __GXX_RTTI + && dynamic_cast(__facets[__i])); +#else + && static_cast(__facets[__i])); +#endif + } + + /** + * @brief Return a facet. + * @ingroup locales + * + * use_facet looks for and returns a reference to a facet of type Facet + * where Facet is the template parameter. If has_facet(locale) is true, + * there is a suitable facet to return. It throws std::bad_cast if the + * locale doesn't contain a facet of type Facet. + * + * @tparam _Facet The facet type to access. + * @param __loc The locale to use. + * @return Reference to facet of type Facet. + * @throw std::bad_cast if @p __loc doesn't contain a facet of type _Facet. + */ + template + const _Facet& + use_facet(const locale& __loc) + { + const size_t __i = _Facet::id._M_id(); + const locale::facet** __facets = __loc._M_impl->_M_facets; + if (__i >= __loc._M_impl->_M_facets_size || !__facets[__i]) + __throw_bad_cast(); +#ifdef __GXX_RTTI + return dynamic_cast(*__facets[__i]); +#else + return static_cast(*__facets[__i]); +#endif + } + + + // Generic version does nothing. + template + int + collate<_CharT>::_M_compare(const _CharT*, const _CharT*) const throw () + { return 0; } + + // Generic version does nothing. + template + size_t + collate<_CharT>::_M_transform(_CharT*, const _CharT*, size_t) const throw () + { return 0; } + + template + int + collate<_CharT>:: + do_compare(const _CharT* __lo1, const _CharT* __hi1, + const _CharT* __lo2, const _CharT* __hi2) const + { + // strcoll assumes zero-terminated strings so we make a copy + // and then put a zero at the end. + const string_type __one(__lo1, __hi1); + const string_type __two(__lo2, __hi2); + + const _CharT* __p = __one.c_str(); + const _CharT* __pend = __one.data() + __one.length(); + const _CharT* __q = __two.c_str(); + const _CharT* __qend = __two.data() + __two.length(); + + // strcoll stops when it sees a nul character so we break + // the strings into zero-terminated substrings and pass those + // to strcoll. + for (;;) + { + const int __res = _M_compare(__p, __q); + if (__res) + return __res; + + __p += char_traits<_CharT>::length(__p); + __q += char_traits<_CharT>::length(__q); + if (__p == __pend && __q == __qend) + return 0; + else if (__p == __pend) + return -1; + else if (__q == __qend) + return 1; + + __p++; + __q++; + } + } + + template + typename collate<_CharT>::string_type + collate<_CharT>:: + do_transform(const _CharT* __lo, const _CharT* __hi) const + { + string_type __ret; + + // strxfrm assumes zero-terminated strings so we make a copy + const string_type __str(__lo, __hi); + + const _CharT* __p = __str.c_str(); + const _CharT* __pend = __str.data() + __str.length(); + + size_t __len = (__hi - __lo) * 2; + + _CharT* __c = new _CharT[__len]; + + __try + { + // strxfrm stops when it sees a nul character so we break + // the string into zero-terminated substrings and pass those + // to strxfrm. + for (;;) + { + // First try a buffer perhaps big enough. + size_t __res = _M_transform(__c, __p, __len); + // If the buffer was not large enough, try again with the + // correct size. + if (__res >= __len) + { + __len = __res + 1; + delete [] __c, __c = 0; + __c = new _CharT[__len]; + __res = _M_transform(__c, __p, __len); + } + + __ret.append(__c, __res); + __p += char_traits<_CharT>::length(__p); + if (__p == __pend) + break; + + __p++; + __ret.push_back(_CharT()); + } + } + __catch(...) + { + delete [] __c; + __throw_exception_again; + } + + delete [] __c; + + return __ret; + } + + template + long + collate<_CharT>:: + do_hash(const _CharT* __lo, const _CharT* __hi) const + { + unsigned long __val = 0; + for (; __lo < __hi; ++__lo) + __val = + *__lo + ((__val << 7) + | (__val >> (__gnu_cxx::__numeric_traits:: + __digits - 7))); + return static_cast(__val); + } + + // Inhibit implicit instantiations for required instantiations, + // which are defined via explicit instantiations elsewhere. +#if _GLIBCXX_EXTERN_TEMPLATE + extern template class collate; + extern template class collate_byname; + + extern template + const collate& + use_facet >(const locale&); + + extern template + bool + has_facet >(const locale&); + +#ifdef _GLIBCXX_USE_WCHAR_T + extern template class collate; + extern template class collate_byname; + + extern template + const collate& + use_facet >(const locale&); + + extern template + bool + has_facet >(const locale&); +#endif +#endif + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace std + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/locale_facets.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/locale_facets.h new file mode 100755 index 0000000..453bbed --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/locale_facets.h @@ -0,0 +1,2610 @@ +// Locale support -*- C++ -*- + +// Copyright (C) 1997-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file bits/locale_facets.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{locale} + */ + +// +// ISO C++ 14882: 22.1 Locales +// + +#ifndef _LOCALE_FACETS_H +#define _LOCALE_FACETS_H 1 + +#pragma GCC system_header + +#include // For wctype_t +#include +#include +#include +#include // For ios_base, ios_base::iostate +#include +#include +#include +#include +#include + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + // NB: Don't instantiate required wchar_t facets if no wchar_t support. +#ifdef _GLIBCXX_USE_WCHAR_T +# define _GLIBCXX_NUM_FACETS 28 +#else +# define _GLIBCXX_NUM_FACETS 14 +#endif + + // Convert string to numeric value of type _Tp and store results. + // NB: This is specialized for all required types, there is no + // generic definition. + template + void + __convert_to_v(const char*, _Tp&, ios_base::iostate&, + const __c_locale&) throw(); + + // Explicit specializations for required types. + template<> + void + __convert_to_v(const char*, float&, ios_base::iostate&, + const __c_locale&) throw(); + + template<> + void + __convert_to_v(const char*, double&, ios_base::iostate&, + const __c_locale&) throw(); + + template<> + void + __convert_to_v(const char*, long double&, ios_base::iostate&, + const __c_locale&) throw(); + + // NB: __pad is a struct, rather than a function, so it can be + // partially-specialized. + template + struct __pad + { + static void + _S_pad(ios_base& __io, _CharT __fill, _CharT* __news, + const _CharT* __olds, streamsize __newlen, streamsize __oldlen); + }; + + // Used by both numeric and monetary facets. + // Inserts "group separator" characters into an array of characters. + // It's recursive, one iteration per group. It moves the characters + // in the buffer this way: "xxxx12345" -> "12,345xxx". Call this + // only with __gsize != 0. + template + _CharT* + __add_grouping(_CharT* __s, _CharT __sep, + const char* __gbeg, size_t __gsize, + const _CharT* __first, const _CharT* __last); + + // This template permits specializing facet output code for + // ostreambuf_iterator. For ostreambuf_iterator, sputn is + // significantly more efficient than incrementing iterators. + template + inline + ostreambuf_iterator<_CharT> + __write(ostreambuf_iterator<_CharT> __s, const _CharT* __ws, int __len) + { + __s._M_put(__ws, __len); + return __s; + } + + // This is the unspecialized form of the template. + template + inline + _OutIter + __write(_OutIter __s, const _CharT* __ws, int __len) + { + for (int __j = 0; __j < __len; __j++, ++__s) + *__s = __ws[__j]; + return __s; + } + + + // 22.2.1.1 Template class ctype + // Include host and configuration specific ctype enums for ctype_base. + + /** + * @brief Common base for ctype facet + * + * This template class provides implementations of the public functions + * that forward to the protected virtual functions. + * + * This template also provides abstract stubs for the protected virtual + * functions. + */ + template + class __ctype_abstract_base : public locale::facet, public ctype_base + { + public: + // Types: + /// Typedef for the template parameter + typedef _CharT char_type; + + /** + * @brief Test char_type classification. + * + * This function finds a mask M for @a __c and compares it to + * mask @a __m. It does so by returning the value of + * ctype::do_is(). + * + * @param __c The char_type to compare the mask of. + * @param __m The mask to compare against. + * @return (M & __m) != 0. + */ + bool + is(mask __m, char_type __c) const + { return this->do_is(__m, __c); } + + /** + * @brief Return a mask array. + * + * This function finds the mask for each char_type in the range [lo,hi) + * and successively writes it to vec. vec must have as many elements + * as the char array. It does so by returning the value of + * ctype::do_is(). + * + * @param __lo Pointer to start of range. + * @param __hi Pointer to end of range. + * @param __vec Pointer to an array of mask storage. + * @return @a __hi. + */ + const char_type* + is(const char_type *__lo, const char_type *__hi, mask *__vec) const + { return this->do_is(__lo, __hi, __vec); } + + /** + * @brief Find char_type matching a mask + * + * This function searches for and returns the first char_type c in + * [lo,hi) for which is(m,c) is true. It does so by returning + * ctype::do_scan_is(). + * + * @param __m The mask to compare against. + * @param __lo Pointer to start of range. + * @param __hi Pointer to end of range. + * @return Pointer to matching char_type if found, else @a __hi. + */ + const char_type* + scan_is(mask __m, const char_type* __lo, const char_type* __hi) const + { return this->do_scan_is(__m, __lo, __hi); } + + /** + * @brief Find char_type not matching a mask + * + * This function searches for and returns the first char_type c in + * [lo,hi) for which is(m,c) is false. It does so by returning + * ctype::do_scan_not(). + * + * @param __m The mask to compare against. + * @param __lo Pointer to first char in range. + * @param __hi Pointer to end of range. + * @return Pointer to non-matching char if found, else @a __hi. + */ + const char_type* + scan_not(mask __m, const char_type* __lo, const char_type* __hi) const + { return this->do_scan_not(__m, __lo, __hi); } + + /** + * @brief Convert to uppercase. + * + * This function converts the argument to uppercase if possible. + * If not possible (for example, '2'), returns the argument. It does + * so by returning ctype::do_toupper(). + * + * @param __c The char_type to convert. + * @return The uppercase char_type if convertible, else @a __c. + */ + char_type + toupper(char_type __c) const + { return this->do_toupper(__c); } + + /** + * @brief Convert array to uppercase. + * + * This function converts each char_type in the range [lo,hi) to + * uppercase if possible. Other elements remain untouched. It does so + * by returning ctype:: do_toupper(lo, hi). + * + * @param __lo Pointer to start of range. + * @param __hi Pointer to end of range. + * @return @a __hi. + */ + const char_type* + toupper(char_type *__lo, const char_type* __hi) const + { return this->do_toupper(__lo, __hi); } + + /** + * @brief Convert to lowercase. + * + * This function converts the argument to lowercase if possible. If + * not possible (for example, '2'), returns the argument. It does so + * by returning ctype::do_tolower(c). + * + * @param __c The char_type to convert. + * @return The lowercase char_type if convertible, else @a __c. + */ + char_type + tolower(char_type __c) const + { return this->do_tolower(__c); } + + /** + * @brief Convert array to lowercase. + * + * This function converts each char_type in the range [__lo,__hi) to + * lowercase if possible. Other elements remain untouched. It does so + * by returning ctype:: do_tolower(__lo, __hi). + * + * @param __lo Pointer to start of range. + * @param __hi Pointer to end of range. + * @return @a __hi. + */ + const char_type* + tolower(char_type* __lo, const char_type* __hi) const + { return this->do_tolower(__lo, __hi); } + + /** + * @brief Widen char to char_type + * + * This function converts the char argument to char_type using the + * simplest reasonable transformation. It does so by returning + * ctype::do_widen(c). + * + * Note: this is not what you want for codepage conversions. See + * codecvt for that. + * + * @param __c The char to convert. + * @return The converted char_type. + */ + char_type + widen(char __c) const + { return this->do_widen(__c); } + + /** + * @brief Widen array to char_type + * + * This function converts each char in the input to char_type using the + * simplest reasonable transformation. It does so by returning + * ctype::do_widen(c). + * + * Note: this is not what you want for codepage conversions. See + * codecvt for that. + * + * @param __lo Pointer to start of range. + * @param __hi Pointer to end of range. + * @param __to Pointer to the destination array. + * @return @a __hi. + */ + const char* + widen(const char* __lo, const char* __hi, char_type* __to) const + { return this->do_widen(__lo, __hi, __to); } + + /** + * @brief Narrow char_type to char + * + * This function converts the char_type to char using the simplest + * reasonable transformation. If the conversion fails, dfault is + * returned instead. It does so by returning + * ctype::do_narrow(__c). + * + * Note: this is not what you want for codepage conversions. See + * codecvt for that. + * + * @param __c The char_type to convert. + * @param __dfault Char to return if conversion fails. + * @return The converted char. + */ + char + narrow(char_type __c, char __dfault) const + { return this->do_narrow(__c, __dfault); } + + /** + * @brief Narrow array to char array + * + * This function converts each char_type in the input to char using the + * simplest reasonable transformation and writes the results to the + * destination array. For any char_type in the input that cannot be + * converted, @a dfault is used instead. It does so by returning + * ctype::do_narrow(__lo, __hi, __dfault, __to). + * + * Note: this is not what you want for codepage conversions. See + * codecvt for that. + * + * @param __lo Pointer to start of range. + * @param __hi Pointer to end of range. + * @param __dfault Char to use if conversion fails. + * @param __to Pointer to the destination array. + * @return @a __hi. + */ + const char_type* + narrow(const char_type* __lo, const char_type* __hi, + char __dfault, char* __to) const + { return this->do_narrow(__lo, __hi, __dfault, __to); } + + protected: + explicit + __ctype_abstract_base(size_t __refs = 0): facet(__refs) { } + + virtual + ~__ctype_abstract_base() { } + + /** + * @brief Test char_type classification. + * + * This function finds a mask M for @a c and compares it to mask @a m. + * + * do_is() is a hook for a derived facet to change the behavior of + * classifying. do_is() must always return the same result for the + * same input. + * + * @param __c The char_type to find the mask of. + * @param __m The mask to compare against. + * @return (M & __m) != 0. + */ + virtual bool + do_is(mask __m, char_type __c) const = 0; + + /** + * @brief Return a mask array. + * + * This function finds the mask for each char_type in the range [lo,hi) + * and successively writes it to vec. vec must have as many elements + * as the input. + * + * do_is() is a hook for a derived facet to change the behavior of + * classifying. do_is() must always return the same result for the + * same input. + * + * @param __lo Pointer to start of range. + * @param __hi Pointer to end of range. + * @param __vec Pointer to an array of mask storage. + * @return @a __hi. + */ + virtual const char_type* + do_is(const char_type* __lo, const char_type* __hi, + mask* __vec) const = 0; + + /** + * @brief Find char_type matching mask + * + * This function searches for and returns the first char_type c in + * [__lo,__hi) for which is(__m,c) is true. + * + * do_scan_is() is a hook for a derived facet to change the behavior of + * match searching. do_is() must always return the same result for the + * same input. + * + * @param __m The mask to compare against. + * @param __lo Pointer to start of range. + * @param __hi Pointer to end of range. + * @return Pointer to a matching char_type if found, else @a __hi. + */ + virtual const char_type* + do_scan_is(mask __m, const char_type* __lo, + const char_type* __hi) const = 0; + + /** + * @brief Find char_type not matching mask + * + * This function searches for and returns a pointer to the first + * char_type c of [lo,hi) for which is(m,c) is false. + * + * do_scan_is() is a hook for a derived facet to change the behavior of + * match searching. do_is() must always return the same result for the + * same input. + * + * @param __m The mask to compare against. + * @param __lo Pointer to start of range. + * @param __hi Pointer to end of range. + * @return Pointer to a non-matching char_type if found, else @a __hi. + */ + virtual const char_type* + do_scan_not(mask __m, const char_type* __lo, + const char_type* __hi) const = 0; + + /** + * @brief Convert to uppercase. + * + * This virtual function converts the char_type argument to uppercase + * if possible. If not possible (for example, '2'), returns the + * argument. + * + * do_toupper() is a hook for a derived facet to change the behavior of + * uppercasing. do_toupper() must always return the same result for + * the same input. + * + * @param __c The char_type to convert. + * @return The uppercase char_type if convertible, else @a __c. + */ + virtual char_type + do_toupper(char_type __c) const = 0; + + /** + * @brief Convert array to uppercase. + * + * This virtual function converts each char_type in the range [__lo,__hi) + * to uppercase if possible. Other elements remain untouched. + * + * do_toupper() is a hook for a derived facet to change the behavior of + * uppercasing. do_toupper() must always return the same result for + * the same input. + * + * @param __lo Pointer to start of range. + * @param __hi Pointer to end of range. + * @return @a __hi. + */ + virtual const char_type* + do_toupper(char_type* __lo, const char_type* __hi) const = 0; + + /** + * @brief Convert to lowercase. + * + * This virtual function converts the argument to lowercase if + * possible. If not possible (for example, '2'), returns the argument. + * + * do_tolower() is a hook for a derived facet to change the behavior of + * lowercasing. do_tolower() must always return the same result for + * the same input. + * + * @param __c The char_type to convert. + * @return The lowercase char_type if convertible, else @a __c. + */ + virtual char_type + do_tolower(char_type __c) const = 0; + + /** + * @brief Convert array to lowercase. + * + * This virtual function converts each char_type in the range [__lo,__hi) + * to lowercase if possible. Other elements remain untouched. + * + * do_tolower() is a hook for a derived facet to change the behavior of + * lowercasing. do_tolower() must always return the same result for + * the same input. + * + * @param __lo Pointer to start of range. + * @param __hi Pointer to end of range. + * @return @a __hi. + */ + virtual const char_type* + do_tolower(char_type* __lo, const char_type* __hi) const = 0; + + /** + * @brief Widen char + * + * This virtual function converts the char to char_type using the + * simplest reasonable transformation. + * + * do_widen() is a hook for a derived facet to change the behavior of + * widening. do_widen() must always return the same result for the + * same input. + * + * Note: this is not what you want for codepage conversions. See + * codecvt for that. + * + * @param __c The char to convert. + * @return The converted char_type + */ + virtual char_type + do_widen(char __c) const = 0; + + /** + * @brief Widen char array + * + * This function converts each char in the input to char_type using the + * simplest reasonable transformation. + * + * do_widen() is a hook for a derived facet to change the behavior of + * widening. do_widen() must always return the same result for the + * same input. + * + * Note: this is not what you want for codepage conversions. See + * codecvt for that. + * + * @param __lo Pointer to start range. + * @param __hi Pointer to end of range. + * @param __to Pointer to the destination array. + * @return @a __hi. + */ + virtual const char* + do_widen(const char* __lo, const char* __hi, char_type* __to) const = 0; + + /** + * @brief Narrow char_type to char + * + * This virtual function converts the argument to char using the + * simplest reasonable transformation. If the conversion fails, dfault + * is returned instead. + * + * do_narrow() is a hook for a derived facet to change the behavior of + * narrowing. do_narrow() must always return the same result for the + * same input. + * + * Note: this is not what you want for codepage conversions. See + * codecvt for that. + * + * @param __c The char_type to convert. + * @param __dfault Char to return if conversion fails. + * @return The converted char. + */ + virtual char + do_narrow(char_type __c, char __dfault) const = 0; + + /** + * @brief Narrow char_type array to char + * + * This virtual function converts each char_type in the range + * [__lo,__hi) to char using the simplest reasonable + * transformation and writes the results to the destination + * array. For any element in the input that cannot be + * converted, @a __dfault is used instead. + * + * do_narrow() is a hook for a derived facet to change the behavior of + * narrowing. do_narrow() must always return the same result for the + * same input. + * + * Note: this is not what you want for codepage conversions. See + * codecvt for that. + * + * @param __lo Pointer to start of range. + * @param __hi Pointer to end of range. + * @param __dfault Char to use if conversion fails. + * @param __to Pointer to the destination array. + * @return @a __hi. + */ + virtual const char_type* + do_narrow(const char_type* __lo, const char_type* __hi, + char __dfault, char* __to) const = 0; + }; + + /** + * @brief Primary class template ctype facet. + * @ingroup locales + * + * This template class defines classification and conversion functions for + * character sets. It wraps cctype functionality. Ctype gets used by + * streams for many I/O operations. + * + * This template provides the protected virtual functions the developer + * will have to replace in a derived class or specialization to make a + * working facet. The public functions that access them are defined in + * __ctype_abstract_base, to allow for implementation flexibility. See + * ctype for an example. The functions are documented in + * __ctype_abstract_base. + * + * Note: implementations are provided for all the protected virtual + * functions, but will likely not be useful. + */ + template + class ctype : public __ctype_abstract_base<_CharT> + { + public: + // Types: + typedef _CharT char_type; + typedef typename __ctype_abstract_base<_CharT>::mask mask; + + /// The facet id for ctype + static locale::id id; + + explicit + ctype(size_t __refs = 0) : __ctype_abstract_base<_CharT>(__refs) { } + + protected: + virtual + ~ctype(); + + virtual bool + do_is(mask __m, char_type __c) const; + + virtual const char_type* + do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const; + + virtual const char_type* + do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const; + + virtual const char_type* + do_scan_not(mask __m, const char_type* __lo, + const char_type* __hi) const; + + virtual char_type + do_toupper(char_type __c) const; + + virtual const char_type* + do_toupper(char_type* __lo, const char_type* __hi) const; + + virtual char_type + do_tolower(char_type __c) const; + + virtual const char_type* + do_tolower(char_type* __lo, const char_type* __hi) const; + + virtual char_type + do_widen(char __c) const; + + virtual const char* + do_widen(const char* __lo, const char* __hi, char_type* __dest) const; + + virtual char + do_narrow(char_type, char __dfault) const; + + virtual const char_type* + do_narrow(const char_type* __lo, const char_type* __hi, + char __dfault, char* __to) const; + }; + + template + locale::id ctype<_CharT>::id; + + /** + * @brief The ctype specialization. + * @ingroup locales + * + * This class defines classification and conversion functions for + * the char type. It gets used by char streams for many I/O + * operations. The char specialization provides a number of + * optimizations as well. + */ + template<> + class ctype : public locale::facet, public ctype_base + { + public: + // Types: + /// Typedef for the template parameter char. + typedef char char_type; + + protected: + // Data Members: + __c_locale _M_c_locale_ctype; + bool _M_del; + __to_type _M_toupper; + __to_type _M_tolower; + const mask* _M_table; + mutable char _M_widen_ok; + mutable char _M_widen[1 + static_cast(-1)]; + mutable char _M_narrow[1 + static_cast(-1)]; + mutable char _M_narrow_ok; // 0 uninitialized, 1 init, + // 2 memcpy can't be used + + public: + /// The facet id for ctype + static locale::id id; + /// The size of the mask table. It is SCHAR_MAX + 1. + static const size_t table_size = 1 + static_cast(-1); + + /** + * @brief Constructor performs initialization. + * + * This is the constructor provided by the standard. + * + * @param __table If non-zero, table is used as the per-char mask. + * Else classic_table() is used. + * @param __del If true, passes ownership of table to this facet. + * @param __refs Passed to the base facet class. + */ + explicit + ctype(const mask* __table = 0, bool __del = false, size_t __refs = 0); + + /** + * @brief Constructor performs static initialization. + * + * This constructor is used to construct the initial C locale facet. + * + * @param __cloc Handle to C locale data. + * @param __table If non-zero, table is used as the per-char mask. + * @param __del If true, passes ownership of table to this facet. + * @param __refs Passed to the base facet class. + */ + explicit + ctype(__c_locale __cloc, const mask* __table = 0, bool __del = false, + size_t __refs = 0); + + /** + * @brief Test char classification. + * + * This function compares the mask table[c] to @a __m. + * + * @param __c The char to compare the mask of. + * @param __m The mask to compare against. + * @return True if __m & table[__c] is true, false otherwise. + */ + inline bool + is(mask __m, char __c) const; + + /** + * @brief Return a mask array. + * + * This function finds the mask for each char in the range [lo, hi) and + * successively writes it to vec. vec must have as many elements as + * the char array. + * + * @param __lo Pointer to start of range. + * @param __hi Pointer to end of range. + * @param __vec Pointer to an array of mask storage. + * @return @a __hi. + */ + inline const char* + is(const char* __lo, const char* __hi, mask* __vec) const; + + /** + * @brief Find char matching a mask + * + * This function searches for and returns the first char in [lo,hi) for + * which is(m,char) is true. + * + * @param __m The mask to compare against. + * @param __lo Pointer to start of range. + * @param __hi Pointer to end of range. + * @return Pointer to a matching char if found, else @a __hi. + */ + inline const char* + scan_is(mask __m, const char* __lo, const char* __hi) const; + + /** + * @brief Find char not matching a mask + * + * This function searches for and returns a pointer to the first char + * in [__lo,__hi) for which is(m,char) is false. + * + * @param __m The mask to compare against. + * @param __lo Pointer to start of range. + * @param __hi Pointer to end of range. + * @return Pointer to a non-matching char if found, else @a __hi. + */ + inline const char* + scan_not(mask __m, const char* __lo, const char* __hi) const; + + /** + * @brief Convert to uppercase. + * + * This function converts the char argument to uppercase if possible. + * If not possible (for example, '2'), returns the argument. + * + * toupper() acts as if it returns ctype::do_toupper(c). + * do_toupper() must always return the same result for the same input. + * + * @param __c The char to convert. + * @return The uppercase char if convertible, else @a __c. + */ + char_type + toupper(char_type __c) const + { return this->do_toupper(__c); } + + /** + * @brief Convert array to uppercase. + * + * This function converts each char in the range [__lo,__hi) to uppercase + * if possible. Other chars remain untouched. + * + * toupper() acts as if it returns ctype:: do_toupper(__lo, __hi). + * do_toupper() must always return the same result for the same input. + * + * @param __lo Pointer to first char in range. + * @param __hi Pointer to end of range. + * @return @a __hi. + */ + const char_type* + toupper(char_type *__lo, const char_type* __hi) const + { return this->do_toupper(__lo, __hi); } + + /** + * @brief Convert to lowercase. + * + * This function converts the char argument to lowercase if possible. + * If not possible (for example, '2'), returns the argument. + * + * tolower() acts as if it returns ctype::do_tolower(__c). + * do_tolower() must always return the same result for the same input. + * + * @param __c The char to convert. + * @return The lowercase char if convertible, else @a __c. + */ + char_type + tolower(char_type __c) const + { return this->do_tolower(__c); } + + /** + * @brief Convert array to lowercase. + * + * This function converts each char in the range [lo,hi) to lowercase + * if possible. Other chars remain untouched. + * + * tolower() acts as if it returns ctype:: do_tolower(__lo, __hi). + * do_tolower() must always return the same result for the same input. + * + * @param __lo Pointer to first char in range. + * @param __hi Pointer to end of range. + * @return @a __hi. + */ + const char_type* + tolower(char_type* __lo, const char_type* __hi) const + { return this->do_tolower(__lo, __hi); } + + /** + * @brief Widen char + * + * This function converts the char to char_type using the simplest + * reasonable transformation. For an underived ctype facet, the + * argument will be returned unchanged. + * + * This function works as if it returns ctype::do_widen(c). + * do_widen() must always return the same result for the same input. + * + * Note: this is not what you want for codepage conversions. See + * codecvt for that. + * + * @param __c The char to convert. + * @return The converted character. + */ + char_type + widen(char __c) const + { + if (_M_widen_ok) + return _M_widen[static_cast(__c)]; + this->_M_widen_init(); + return this->do_widen(__c); + } + + /** + * @brief Widen char array + * + * This function converts each char in the input to char using the + * simplest reasonable transformation. For an underived ctype + * facet, the argument will be copied unchanged. + * + * This function works as if it returns ctype::do_widen(c). + * do_widen() must always return the same result for the same input. + * + * Note: this is not what you want for codepage conversions. See + * codecvt for that. + * + * @param __lo Pointer to first char in range. + * @param __hi Pointer to end of range. + * @param __to Pointer to the destination array. + * @return @a __hi. + */ + const char* + widen(const char* __lo, const char* __hi, char_type* __to) const + { + if (_M_widen_ok == 1) + { + __builtin_memcpy(__to, __lo, __hi - __lo); + return __hi; + } + if (!_M_widen_ok) + _M_widen_init(); + return this->do_widen(__lo, __hi, __to); + } + + /** + * @brief Narrow char + * + * This function converts the char to char using the simplest + * reasonable transformation. If the conversion fails, dfault is + * returned instead. For an underived ctype facet, @a c + * will be returned unchanged. + * + * This function works as if it returns ctype::do_narrow(c). + * do_narrow() must always return the same result for the same input. + * + * Note: this is not what you want for codepage conversions. See + * codecvt for that. + * + * @param __c The char to convert. + * @param __dfault Char to return if conversion fails. + * @return The converted character. + */ + char + narrow(char_type __c, char __dfault) const + { + if (_M_narrow[static_cast(__c)]) + return _M_narrow[static_cast(__c)]; + const char __t = do_narrow(__c, __dfault); + if (__t != __dfault) + _M_narrow[static_cast(__c)] = __t; + return __t; + } + + /** + * @brief Narrow char array + * + * This function converts each char in the input to char using the + * simplest reasonable transformation and writes the results to the + * destination array. For any char in the input that cannot be + * converted, @a dfault is used instead. For an underived ctype + * facet, the argument will be copied unchanged. + * + * This function works as if it returns ctype::do_narrow(lo, hi, + * dfault, to). do_narrow() must always return the same result for the + * same input. + * + * Note: this is not what you want for codepage conversions. See + * codecvt for that. + * + * @param __lo Pointer to start of range. + * @param __hi Pointer to end of range. + * @param __dfault Char to use if conversion fails. + * @param __to Pointer to the destination array. + * @return @a __hi. + */ + const char_type* + narrow(const char_type* __lo, const char_type* __hi, + char __dfault, char* __to) const + { + if (__builtin_expect(_M_narrow_ok == 1, true)) + { + __builtin_memcpy(__to, __lo, __hi - __lo); + return __hi; + } + if (!_M_narrow_ok) + _M_narrow_init(); + return this->do_narrow(__lo, __hi, __dfault, __to); + } + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR 695. ctype::classic_table() not accessible. + /// Returns a pointer to the mask table provided to the constructor, or + /// the default from classic_table() if none was provided. + const mask* + table() const throw() + { return _M_table; } + + /// Returns a pointer to the C locale mask table. + static const mask* + classic_table() throw(); + protected: + + /** + * @brief Destructor. + * + * This function deletes table() if @a del was true in the + * constructor. + */ + virtual + ~ctype(); + + /** + * @brief Convert to uppercase. + * + * This virtual function converts the char argument to uppercase if + * possible. If not possible (for example, '2'), returns the argument. + * + * do_toupper() is a hook for a derived facet to change the behavior of + * uppercasing. do_toupper() must always return the same result for + * the same input. + * + * @param __c The char to convert. + * @return The uppercase char if convertible, else @a __c. + */ + virtual char_type + do_toupper(char_type __c) const; + + /** + * @brief Convert array to uppercase. + * + * This virtual function converts each char in the range [lo,hi) to + * uppercase if possible. Other chars remain untouched. + * + * do_toupper() is a hook for a derived facet to change the behavior of + * uppercasing. do_toupper() must always return the same result for + * the same input. + * + * @param __lo Pointer to start of range. + * @param __hi Pointer to end of range. + * @return @a __hi. + */ + virtual const char_type* + do_toupper(char_type* __lo, const char_type* __hi) const; + + /** + * @brief Convert to lowercase. + * + * This virtual function converts the char argument to lowercase if + * possible. If not possible (for example, '2'), returns the argument. + * + * do_tolower() is a hook for a derived facet to change the behavior of + * lowercasing. do_tolower() must always return the same result for + * the same input. + * + * @param __c The char to convert. + * @return The lowercase char if convertible, else @a __c. + */ + virtual char_type + do_tolower(char_type __c) const; + + /** + * @brief Convert array to lowercase. + * + * This virtual function converts each char in the range [lo,hi) to + * lowercase if possible. Other chars remain untouched. + * + * do_tolower() is a hook for a derived facet to change the behavior of + * lowercasing. do_tolower() must always return the same result for + * the same input. + * + * @param __lo Pointer to first char in range. + * @param __hi Pointer to end of range. + * @return @a __hi. + */ + virtual const char_type* + do_tolower(char_type* __lo, const char_type* __hi) const; + + /** + * @brief Widen char + * + * This virtual function converts the char to char using the simplest + * reasonable transformation. For an underived ctype facet, the + * argument will be returned unchanged. + * + * do_widen() is a hook for a derived facet to change the behavior of + * widening. do_widen() must always return the same result for the + * same input. + * + * Note: this is not what you want for codepage conversions. See + * codecvt for that. + * + * @param __c The char to convert. + * @return The converted character. + */ + virtual char_type + do_widen(char __c) const + { return __c; } + + /** + * @brief Widen char array + * + * This function converts each char in the range [lo,hi) to char using + * the simplest reasonable transformation. For an underived + * ctype facet, the argument will be copied unchanged. + * + * do_widen() is a hook for a derived facet to change the behavior of + * widening. do_widen() must always return the same result for the + * same input. + * + * Note: this is not what you want for codepage conversions. See + * codecvt for that. + * + * @param __lo Pointer to start of range. + * @param __hi Pointer to end of range. + * @param __to Pointer to the destination array. + * @return @a __hi. + */ + virtual const char* + do_widen(const char* __lo, const char* __hi, char_type* __to) const + { + __builtin_memcpy(__to, __lo, __hi - __lo); + return __hi; + } + + /** + * @brief Narrow char + * + * This virtual function converts the char to char using the simplest + * reasonable transformation. If the conversion fails, dfault is + * returned instead. For an underived ctype facet, @a c will be + * returned unchanged. + * + * do_narrow() is a hook for a derived facet to change the behavior of + * narrowing. do_narrow() must always return the same result for the + * same input. + * + * Note: this is not what you want for codepage conversions. See + * codecvt for that. + * + * @param __c The char to convert. + * @param __dfault Char to return if conversion fails. + * @return The converted char. + */ + virtual char + do_narrow(char_type __c, char __dfault) const + { return __c; } + + /** + * @brief Narrow char array to char array + * + * This virtual function converts each char in the range [lo,hi) to + * char using the simplest reasonable transformation and writes the + * results to the destination array. For any char in the input that + * cannot be converted, @a dfault is used instead. For an underived + * ctype facet, the argument will be copied unchanged. + * + * do_narrow() is a hook for a derived facet to change the behavior of + * narrowing. do_narrow() must always return the same result for the + * same input. + * + * Note: this is not what you want for codepage conversions. See + * codecvt for that. + * + * @param __lo Pointer to start of range. + * @param __hi Pointer to end of range. + * @param __dfault Char to use if conversion fails. + * @param __to Pointer to the destination array. + * @return @a __hi. + */ + virtual const char_type* + do_narrow(const char_type* __lo, const char_type* __hi, + char __dfault, char* __to) const + { + __builtin_memcpy(__to, __lo, __hi - __lo); + return __hi; + } + + private: + void _M_narrow_init() const; + void _M_widen_init() const; + }; + +#ifdef _GLIBCXX_USE_WCHAR_T + /** + * @brief The ctype specialization. + * @ingroup locales + * + * This class defines classification and conversion functions for the + * wchar_t type. It gets used by wchar_t streams for many I/O operations. + * The wchar_t specialization provides a number of optimizations as well. + * + * ctype inherits its public methods from + * __ctype_abstract_base. + */ + template<> + class ctype : public __ctype_abstract_base + { + public: + // Types: + /// Typedef for the template parameter wchar_t. + typedef wchar_t char_type; + typedef wctype_t __wmask_type; + + protected: + __c_locale _M_c_locale_ctype; + + // Pre-computed narrowed and widened chars. + bool _M_narrow_ok; + char _M_narrow[128]; + wint_t _M_widen[1 + static_cast(-1)]; + + // Pre-computed elements for do_is. + mask _M_bit[16]; + __wmask_type _M_wmask[16]; + + public: + // Data Members: + /// The facet id for ctype + static locale::id id; + + /** + * @brief Constructor performs initialization. + * + * This is the constructor provided by the standard. + * + * @param __refs Passed to the base facet class. + */ + explicit + ctype(size_t __refs = 0); + + /** + * @brief Constructor performs static initialization. + * + * This constructor is used to construct the initial C locale facet. + * + * @param __cloc Handle to C locale data. + * @param __refs Passed to the base facet class. + */ + explicit + ctype(__c_locale __cloc, size_t __refs = 0); + + protected: + __wmask_type + _M_convert_to_wmask(const mask __m) const throw(); + + /// Destructor + virtual + ~ctype(); + + /** + * @brief Test wchar_t classification. + * + * This function finds a mask M for @a c and compares it to mask @a m. + * + * do_is() is a hook for a derived facet to change the behavior of + * classifying. do_is() must always return the same result for the + * same input. + * + * @param __c The wchar_t to find the mask of. + * @param __m The mask to compare against. + * @return (M & __m) != 0. + */ + virtual bool + do_is(mask __m, char_type __c) const; + + /** + * @brief Return a mask array. + * + * This function finds the mask for each wchar_t in the range [lo,hi) + * and successively writes it to vec. vec must have as many elements + * as the input. + * + * do_is() is a hook for a derived facet to change the behavior of + * classifying. do_is() must always return the same result for the + * same input. + * + * @param __lo Pointer to start of range. + * @param __hi Pointer to end of range. + * @param __vec Pointer to an array of mask storage. + * @return @a __hi. + */ + virtual const char_type* + do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const; + + /** + * @brief Find wchar_t matching mask + * + * This function searches for and returns the first wchar_t c in + * [__lo,__hi) for which is(__m,c) is true. + * + * do_scan_is() is a hook for a derived facet to change the behavior of + * match searching. do_is() must always return the same result for the + * same input. + * + * @param __m The mask to compare against. + * @param __lo Pointer to start of range. + * @param __hi Pointer to end of range. + * @return Pointer to a matching wchar_t if found, else @a __hi. + */ + virtual const char_type* + do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const; + + /** + * @brief Find wchar_t not matching mask + * + * This function searches for and returns a pointer to the first + * wchar_t c of [__lo,__hi) for which is(__m,c) is false. + * + * do_scan_is() is a hook for a derived facet to change the behavior of + * match searching. do_is() must always return the same result for the + * same input. + * + * @param __m The mask to compare against. + * @param __lo Pointer to start of range. + * @param __hi Pointer to end of range. + * @return Pointer to a non-matching wchar_t if found, else @a __hi. + */ + virtual const char_type* + do_scan_not(mask __m, const char_type* __lo, + const char_type* __hi) const; + + /** + * @brief Convert to uppercase. + * + * This virtual function converts the wchar_t argument to uppercase if + * possible. If not possible (for example, '2'), returns the argument. + * + * do_toupper() is a hook for a derived facet to change the behavior of + * uppercasing. do_toupper() must always return the same result for + * the same input. + * + * @param __c The wchar_t to convert. + * @return The uppercase wchar_t if convertible, else @a __c. + */ + virtual char_type + do_toupper(char_type __c) const; + + /** + * @brief Convert array to uppercase. + * + * This virtual function converts each wchar_t in the range [lo,hi) to + * uppercase if possible. Other elements remain untouched. + * + * do_toupper() is a hook for a derived facet to change the behavior of + * uppercasing. do_toupper() must always return the same result for + * the same input. + * + * @param __lo Pointer to start of range. + * @param __hi Pointer to end of range. + * @return @a __hi. + */ + virtual const char_type* + do_toupper(char_type* __lo, const char_type* __hi) const; + + /** + * @brief Convert to lowercase. + * + * This virtual function converts the argument to lowercase if + * possible. If not possible (for example, '2'), returns the argument. + * + * do_tolower() is a hook for a derived facet to change the behavior of + * lowercasing. do_tolower() must always return the same result for + * the same input. + * + * @param __c The wchar_t to convert. + * @return The lowercase wchar_t if convertible, else @a __c. + */ + virtual char_type + do_tolower(char_type __c) const; + + /** + * @brief Convert array to lowercase. + * + * This virtual function converts each wchar_t in the range [lo,hi) to + * lowercase if possible. Other elements remain untouched. + * + * do_tolower() is a hook for a derived facet to change the behavior of + * lowercasing. do_tolower() must always return the same result for + * the same input. + * + * @param __lo Pointer to start of range. + * @param __hi Pointer to end of range. + * @return @a __hi. + */ + virtual const char_type* + do_tolower(char_type* __lo, const char_type* __hi) const; + + /** + * @brief Widen char to wchar_t + * + * This virtual function converts the char to wchar_t using the + * simplest reasonable transformation. For an underived ctype + * facet, the argument will be cast to wchar_t. + * + * do_widen() is a hook for a derived facet to change the behavior of + * widening. do_widen() must always return the same result for the + * same input. + * + * Note: this is not what you want for codepage conversions. See + * codecvt for that. + * + * @param __c The char to convert. + * @return The converted wchar_t. + */ + virtual char_type + do_widen(char __c) const; + + /** + * @brief Widen char array to wchar_t array + * + * This function converts each char in the input to wchar_t using the + * simplest reasonable transformation. For an underived ctype + * facet, the argument will be copied, casting each element to wchar_t. + * + * do_widen() is a hook for a derived facet to change the behavior of + * widening. do_widen() must always return the same result for the + * same input. + * + * Note: this is not what you want for codepage conversions. See + * codecvt for that. + * + * @param __lo Pointer to start range. + * @param __hi Pointer to end of range. + * @param __to Pointer to the destination array. + * @return @a __hi. + */ + virtual const char* + do_widen(const char* __lo, const char* __hi, char_type* __to) const; + + /** + * @brief Narrow wchar_t to char + * + * This virtual function converts the argument to char using + * the simplest reasonable transformation. If the conversion + * fails, dfault is returned instead. For an underived + * ctype facet, @a c will be cast to char and + * returned. + * + * do_narrow() is a hook for a derived facet to change the + * behavior of narrowing. do_narrow() must always return the + * same result for the same input. + * + * Note: this is not what you want for codepage conversions. See + * codecvt for that. + * + * @param __c The wchar_t to convert. + * @param __dfault Char to return if conversion fails. + * @return The converted char. + */ + virtual char + do_narrow(char_type __c, char __dfault) const; + + /** + * @brief Narrow wchar_t array to char array + * + * This virtual function converts each wchar_t in the range [lo,hi) to + * char using the simplest reasonable transformation and writes the + * results to the destination array. For any wchar_t in the input that + * cannot be converted, @a dfault is used instead. For an underived + * ctype facet, the argument will be copied, casting each + * element to char. + * + * do_narrow() is a hook for a derived facet to change the behavior of + * narrowing. do_narrow() must always return the same result for the + * same input. + * + * Note: this is not what you want for codepage conversions. See + * codecvt for that. + * + * @param __lo Pointer to start of range. + * @param __hi Pointer to end of range. + * @param __dfault Char to use if conversion fails. + * @param __to Pointer to the destination array. + * @return @a __hi. + */ + virtual const char_type* + do_narrow(const char_type* __lo, const char_type* __hi, + char __dfault, char* __to) const; + + // For use at construction time only. + void + _M_initialize_ctype() throw(); + }; +#endif //_GLIBCXX_USE_WCHAR_T + + /// class ctype_byname [22.2.1.2]. + template + class ctype_byname : public ctype<_CharT> + { + public: + typedef typename ctype<_CharT>::mask mask; + + explicit + ctype_byname(const char* __s, size_t __refs = 0); + + protected: + virtual + ~ctype_byname() { }; + }; + + /// 22.2.1.4 Class ctype_byname specializations. + template<> + class ctype_byname : public ctype + { + public: + explicit + ctype_byname(const char* __s, size_t __refs = 0); + + protected: + virtual + ~ctype_byname(); + }; + +#ifdef _GLIBCXX_USE_WCHAR_T + template<> + class ctype_byname : public ctype + { + public: + explicit + ctype_byname(const char* __s, size_t __refs = 0); + + protected: + virtual + ~ctype_byname(); + }; +#endif + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +// Include host and configuration specific ctype inlines. +#include + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + // 22.2.2 The numeric category. + class __num_base + { + public: + // NB: Code depends on the order of _S_atoms_out elements. + // Below are the indices into _S_atoms_out. + enum + { + _S_ominus, + _S_oplus, + _S_ox, + _S_oX, + _S_odigits, + _S_odigits_end = _S_odigits + 16, + _S_oudigits = _S_odigits_end, + _S_oudigits_end = _S_oudigits + 16, + _S_oe = _S_odigits + 14, // For scientific notation, 'e' + _S_oE = _S_oudigits + 14, // For scientific notation, 'E' + _S_oend = _S_oudigits_end + }; + + // A list of valid numeric literals for output. This array + // contains chars that will be passed through the current locale's + // ctype<_CharT>.widen() and then used to render numbers. + // For the standard "C" locale, this is + // "-+xX0123456789abcdef0123456789ABCDEF". + static const char* _S_atoms_out; + + // String literal of acceptable (narrow) input, for num_get. + // "-+xX0123456789abcdefABCDEF" + static const char* _S_atoms_in; + + enum + { + _S_iminus, + _S_iplus, + _S_ix, + _S_iX, + _S_izero, + _S_ie = _S_izero + 14, + _S_iE = _S_izero + 20, + _S_iend = 26 + }; + + // num_put + // Construct and return valid scanf format for floating point types. + static void + _S_format_float(const ios_base& __io, char* __fptr, char __mod) throw(); + }; + + template + struct __numpunct_cache : public locale::facet + { + const char* _M_grouping; + size_t _M_grouping_size; + bool _M_use_grouping; + const _CharT* _M_truename; + size_t _M_truename_size; + const _CharT* _M_falsename; + size_t _M_falsename_size; + _CharT _M_decimal_point; + _CharT _M_thousands_sep; + + // A list of valid numeric literals for output: in the standard + // "C" locale, this is "-+xX0123456789abcdef0123456789ABCDEF". + // This array contains the chars after having been passed + // through the current locale's ctype<_CharT>.widen(). + _CharT _M_atoms_out[__num_base::_S_oend]; + + // A list of valid numeric literals for input: in the standard + // "C" locale, this is "-+xX0123456789abcdefABCDEF" + // This array contains the chars after having been passed + // through the current locale's ctype<_CharT>.widen(). + _CharT _M_atoms_in[__num_base::_S_iend]; + + bool _M_allocated; + + __numpunct_cache(size_t __refs = 0) + : facet(__refs), _M_grouping(0), _M_grouping_size(0), + _M_use_grouping(false), + _M_truename(0), _M_truename_size(0), _M_falsename(0), + _M_falsename_size(0), _M_decimal_point(_CharT()), + _M_thousands_sep(_CharT()), _M_allocated(false) + { } + + ~__numpunct_cache(); + + void + _M_cache(const locale& __loc); + + private: + __numpunct_cache& + operator=(const __numpunct_cache&); + + explicit + __numpunct_cache(const __numpunct_cache&); + }; + + template + __numpunct_cache<_CharT>::~__numpunct_cache() + { + if (_M_allocated) + { + delete [] _M_grouping; + delete [] _M_truename; + delete [] _M_falsename; + } + } + + /** + * @brief Primary class template numpunct. + * @ingroup locales + * + * This facet stores several pieces of information related to printing and + * scanning numbers, such as the decimal point character. It takes a + * template parameter specifying the char type. The numpunct facet is + * used by streams for many I/O operations involving numbers. + * + * The numpunct template uses protected virtual functions to provide the + * actual results. The public accessors forward the call to the virtual + * functions. These virtual functions are hooks for developers to + * implement the behavior they require from a numpunct facet. + */ + template + class numpunct : public locale::facet + { + public: + // Types: + //@{ + /// Public typedefs + typedef _CharT char_type; + typedef basic_string<_CharT> string_type; + //@} + typedef __numpunct_cache<_CharT> __cache_type; + + protected: + __cache_type* _M_data; + + public: + /// Numpunct facet id. + static locale::id id; + + /** + * @brief Numpunct constructor. + * + * @param __refs Refcount to pass to the base class. + */ + explicit + numpunct(size_t __refs = 0) + : facet(__refs), _M_data(0) + { _M_initialize_numpunct(); } + + /** + * @brief Internal constructor. Not for general use. + * + * This is a constructor for use by the library itself to set up the + * predefined locale facets. + * + * @param __cache __numpunct_cache object. + * @param __refs Refcount to pass to the base class. + */ + explicit + numpunct(__cache_type* __cache, size_t __refs = 0) + : facet(__refs), _M_data(__cache) + { _M_initialize_numpunct(); } + + /** + * @brief Internal constructor. Not for general use. + * + * This is a constructor for use by the library itself to set up new + * locales. + * + * @param __cloc The C locale. + * @param __refs Refcount to pass to the base class. + */ + explicit + numpunct(__c_locale __cloc, size_t __refs = 0) + : facet(__refs), _M_data(0) + { _M_initialize_numpunct(__cloc); } + + /** + * @brief Return decimal point character. + * + * This function returns a char_type to use as a decimal point. It + * does so by returning returning + * numpunct::do_decimal_point(). + * + * @return @a char_type representing a decimal point. + */ + char_type + decimal_point() const + { return this->do_decimal_point(); } + + /** + * @brief Return thousands separator character. + * + * This function returns a char_type to use as a thousands + * separator. It does so by returning returning + * numpunct::do_thousands_sep(). + * + * @return char_type representing a thousands separator. + */ + char_type + thousands_sep() const + { return this->do_thousands_sep(); } + + /** + * @brief Return grouping specification. + * + * This function returns a string representing groupings for the + * integer part of a number. Groupings indicate where thousands + * separators should be inserted in the integer part of a number. + * + * Each char in the return string is interpret as an integer + * rather than a character. These numbers represent the number + * of digits in a group. The first char in the string + * represents the number of digits in the least significant + * group. If a char is negative, it indicates an unlimited + * number of digits for the group. If more chars from the + * string are required to group a number, the last char is used + * repeatedly. + * + * For example, if the grouping() returns "\003\002" and is + * applied to the number 123456789, this corresponds to + * 12,34,56,789. Note that if the string was "32", this would + * put more than 50 digits into the least significant group if + * the character set is ASCII. + * + * The string is returned by calling + * numpunct::do_grouping(). + * + * @return string representing grouping specification. + */ + string + grouping() const + { return this->do_grouping(); } + + /** + * @brief Return string representation of bool true. + * + * This function returns a string_type containing the text + * representation for true bool variables. It does so by calling + * numpunct::do_truename(). + * + * @return string_type representing printed form of true. + */ + string_type + truename() const + { return this->do_truename(); } + + /** + * @brief Return string representation of bool false. + * + * This function returns a string_type containing the text + * representation for false bool variables. It does so by calling + * numpunct::do_falsename(). + * + * @return string_type representing printed form of false. + */ + string_type + falsename() const + { return this->do_falsename(); } + + protected: + /// Destructor. + virtual + ~numpunct(); + + /** + * @brief Return decimal point character. + * + * Returns a char_type to use as a decimal point. This function is a + * hook for derived classes to change the value returned. + * + * @return @a char_type representing a decimal point. + */ + virtual char_type + do_decimal_point() const + { return _M_data->_M_decimal_point; } + + /** + * @brief Return thousands separator character. + * + * Returns a char_type to use as a thousands separator. This function + * is a hook for derived classes to change the value returned. + * + * @return @a char_type representing a thousands separator. + */ + virtual char_type + do_thousands_sep() const + { return _M_data->_M_thousands_sep; } + + /** + * @brief Return grouping specification. + * + * Returns a string representing groupings for the integer part of a + * number. This function is a hook for derived classes to change the + * value returned. @see grouping() for details. + * + * @return String representing grouping specification. + */ + virtual string + do_grouping() const + { return _M_data->_M_grouping; } + + /** + * @brief Return string representation of bool true. + * + * Returns a string_type containing the text representation for true + * bool variables. This function is a hook for derived classes to + * change the value returned. + * + * @return string_type representing printed form of true. + */ + virtual string_type + do_truename() const + { return _M_data->_M_truename; } + + /** + * @brief Return string representation of bool false. + * + * Returns a string_type containing the text representation for false + * bool variables. This function is a hook for derived classes to + * change the value returned. + * + * @return string_type representing printed form of false. + */ + virtual string_type + do_falsename() const + { return _M_data->_M_falsename; } + + // For use at construction time only. + void + _M_initialize_numpunct(__c_locale __cloc = 0); + }; + + template + locale::id numpunct<_CharT>::id; + + template<> + numpunct::~numpunct(); + + template<> + void + numpunct::_M_initialize_numpunct(__c_locale __cloc); + +#ifdef _GLIBCXX_USE_WCHAR_T + template<> + numpunct::~numpunct(); + + template<> + void + numpunct::_M_initialize_numpunct(__c_locale __cloc); +#endif + + /// class numpunct_byname [22.2.3.2]. + template + class numpunct_byname : public numpunct<_CharT> + { + public: + typedef _CharT char_type; + typedef basic_string<_CharT> string_type; + + explicit + numpunct_byname(const char* __s, size_t __refs = 0) + : numpunct<_CharT>(__refs) + { + if (__builtin_strcmp(__s, "C") != 0 + && __builtin_strcmp(__s, "POSIX") != 0) + { + __c_locale __tmp; + this->_S_create_c_locale(__tmp, __s); + this->_M_initialize_numpunct(__tmp); + this->_S_destroy_c_locale(__tmp); + } + } + + protected: + virtual + ~numpunct_byname() { } + }; + +_GLIBCXX_BEGIN_NAMESPACE_LDBL + + /** + * @brief Primary class template num_get. + * @ingroup locales + * + * This facet encapsulates the code to parse and return a number + * from a string. It is used by the istream numeric extraction + * operators. + * + * The num_get template uses protected virtual functions to provide the + * actual results. The public accessors forward the call to the virtual + * functions. These virtual functions are hooks for developers to + * implement the behavior they require from the num_get facet. + */ + template + class num_get : public locale::facet + { + public: + // Types: + //@{ + /// Public typedefs + typedef _CharT char_type; + typedef _InIter iter_type; + //@} + + /// Numpunct facet id. + static locale::id id; + + /** + * @brief Constructor performs initialization. + * + * This is the constructor provided by the standard. + * + * @param __refs Passed to the base facet class. + */ + explicit + num_get(size_t __refs = 0) : facet(__refs) { } + + /** + * @brief Numeric parsing. + * + * Parses the input stream into the bool @a v. It does so by calling + * num_get::do_get(). + * + * If ios_base::boolalpha is set, attempts to read + * ctype::truename() or ctype::falsename(). Sets + * @a v to true or false if successful. Sets err to + * ios_base::failbit if reading the string fails. Sets err to + * ios_base::eofbit if the stream is emptied. + * + * If ios_base::boolalpha is not set, proceeds as with reading a long, + * except if the value is 1, sets @a v to true, if the value is 0, sets + * @a v to false, and otherwise set err to ios_base::failbit. + * + * @param __in Start of input stream. + * @param __end End of input stream. + * @param __io Source of locale and flags. + * @param __err Error flags to set. + * @param __v Value to format and insert. + * @return Iterator after reading. + */ + iter_type + get(iter_type __in, iter_type __end, ios_base& __io, + ios_base::iostate& __err, bool& __v) const + { return this->do_get(__in, __end, __io, __err, __v); } + + //@{ + /** + * @brief Numeric parsing. + * + * Parses the input stream into the integral variable @a v. It does so + * by calling num_get::do_get(). + * + * Parsing is affected by the flag settings in @a io. + * + * The basic parse is affected by the value of io.flags() & + * ios_base::basefield. If equal to ios_base::oct, parses like the + * scanf %o specifier. Else if equal to ios_base::hex, parses like %X + * specifier. Else if basefield equal to 0, parses like the %i + * specifier. Otherwise, parses like %d for signed and %u for unsigned + * types. The matching type length modifier is also used. + * + * Digit grouping is interpreted according to + * numpunct::grouping() and numpunct::thousands_sep(). If the + * pattern of digit groups isn't consistent, sets err to + * ios_base::failbit. + * + * If parsing the string yields a valid value for @a v, @a v is set. + * Otherwise, sets err to ios_base::failbit and leaves @a v unaltered. + * Sets err to ios_base::eofbit if the stream is emptied. + * + * @param __in Start of input stream. + * @param __end End of input stream. + * @param __io Source of locale and flags. + * @param __err Error flags to set. + * @param __v Value to format and insert. + * @return Iterator after reading. + */ + iter_type + get(iter_type __in, iter_type __end, ios_base& __io, + ios_base::iostate& __err, long& __v) const + { return this->do_get(__in, __end, __io, __err, __v); } + + iter_type + get(iter_type __in, iter_type __end, ios_base& __io, + ios_base::iostate& __err, unsigned short& __v) const + { return this->do_get(__in, __end, __io, __err, __v); } + + iter_type + get(iter_type __in, iter_type __end, ios_base& __io, + ios_base::iostate& __err, unsigned int& __v) const + { return this->do_get(__in, __end, __io, __err, __v); } + + iter_type + get(iter_type __in, iter_type __end, ios_base& __io, + ios_base::iostate& __err, unsigned long& __v) const + { return this->do_get(__in, __end, __io, __err, __v); } + +#ifdef _GLIBCXX_USE_LONG_LONG + iter_type + get(iter_type __in, iter_type __end, ios_base& __io, + ios_base::iostate& __err, long long& __v) const + { return this->do_get(__in, __end, __io, __err, __v); } + + iter_type + get(iter_type __in, iter_type __end, ios_base& __io, + ios_base::iostate& __err, unsigned long long& __v) const + { return this->do_get(__in, __end, __io, __err, __v); } +#endif + //@} + + //@{ + /** + * @brief Numeric parsing. + * + * Parses the input stream into the integral variable @a v. It does so + * by calling num_get::do_get(). + * + * The input characters are parsed like the scanf %g specifier. The + * matching type length modifier is also used. + * + * The decimal point character used is numpunct::decimal_point(). + * Digit grouping is interpreted according to + * numpunct::grouping() and numpunct::thousands_sep(). If the + * pattern of digit groups isn't consistent, sets err to + * ios_base::failbit. + * + * If parsing the string yields a valid value for @a v, @a v is set. + * Otherwise, sets err to ios_base::failbit and leaves @a v unaltered. + * Sets err to ios_base::eofbit if the stream is emptied. + * + * @param __in Start of input stream. + * @param __end End of input stream. + * @param __io Source of locale and flags. + * @param __err Error flags to set. + * @param __v Value to format and insert. + * @return Iterator after reading. + */ + iter_type + get(iter_type __in, iter_type __end, ios_base& __io, + ios_base::iostate& __err, float& __v) const + { return this->do_get(__in, __end, __io, __err, __v); } + + iter_type + get(iter_type __in, iter_type __end, ios_base& __io, + ios_base::iostate& __err, double& __v) const + { return this->do_get(__in, __end, __io, __err, __v); } + + iter_type + get(iter_type __in, iter_type __end, ios_base& __io, + ios_base::iostate& __err, long double& __v) const + { return this->do_get(__in, __end, __io, __err, __v); } + //@} + + /** + * @brief Numeric parsing. + * + * Parses the input stream into the pointer variable @a v. It does so + * by calling num_get::do_get(). + * + * The input characters are parsed like the scanf %p specifier. + * + * Digit grouping is interpreted according to + * numpunct::grouping() and numpunct::thousands_sep(). If the + * pattern of digit groups isn't consistent, sets err to + * ios_base::failbit. + * + * Note that the digit grouping effect for pointers is a bit ambiguous + * in the standard and shouldn't be relied on. See DR 344. + * + * If parsing the string yields a valid value for @a v, @a v is set. + * Otherwise, sets err to ios_base::failbit and leaves @a v unaltered. + * Sets err to ios_base::eofbit if the stream is emptied. + * + * @param __in Start of input stream. + * @param __end End of input stream. + * @param __io Source of locale and flags. + * @param __err Error flags to set. + * @param __v Value to format and insert. + * @return Iterator after reading. + */ + iter_type + get(iter_type __in, iter_type __end, ios_base& __io, + ios_base::iostate& __err, void*& __v) const + { return this->do_get(__in, __end, __io, __err, __v); } + + protected: + /// Destructor. + virtual ~num_get() { } + + iter_type + _M_extract_float(iter_type, iter_type, ios_base&, ios_base::iostate&, + string&) const; + + template + iter_type + _M_extract_int(iter_type, iter_type, ios_base&, ios_base::iostate&, + _ValueT&) const; + + template + typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, int>::__type + _M_find(const _CharT2*, size_t __len, _CharT2 __c) const + { + int __ret = -1; + if (__len <= 10) + { + if (__c >= _CharT2('0') && __c < _CharT2(_CharT2('0') + __len)) + __ret = __c - _CharT2('0'); + } + else + { + if (__c >= _CharT2('0') && __c <= _CharT2('9')) + __ret = __c - _CharT2('0'); + else if (__c >= _CharT2('a') && __c <= _CharT2('f')) + __ret = 10 + (__c - _CharT2('a')); + else if (__c >= _CharT2('A') && __c <= _CharT2('F')) + __ret = 10 + (__c - _CharT2('A')); + } + return __ret; + } + + template + typename __gnu_cxx::__enable_if::__value, + int>::__type + _M_find(const _CharT2* __zero, size_t __len, _CharT2 __c) const + { + int __ret = -1; + const char_type* __q = char_traits<_CharT2>::find(__zero, __len, __c); + if (__q) + { + __ret = __q - __zero; + if (__ret > 15) + __ret -= 6; + } + return __ret; + } + + //@{ + /** + * @brief Numeric parsing. + * + * Parses the input stream into the variable @a v. This function is a + * hook for derived classes to change the value returned. @see get() + * for more details. + * + * @param __beg Start of input stream. + * @param __end End of input stream. + * @param __io Source of locale and flags. + * @param __err Error flags to set. + * @param __v Value to format and insert. + * @return Iterator after reading. + */ + virtual iter_type + do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, bool&) const; + + virtual iter_type + do_get(iter_type __beg, iter_type __end, ios_base& __io, + ios_base::iostate& __err, long& __v) const + { return _M_extract_int(__beg, __end, __io, __err, __v); } + + virtual iter_type + do_get(iter_type __beg, iter_type __end, ios_base& __io, + ios_base::iostate& __err, unsigned short& __v) const + { return _M_extract_int(__beg, __end, __io, __err, __v); } + + virtual iter_type + do_get(iter_type __beg, iter_type __end, ios_base& __io, + ios_base::iostate& __err, unsigned int& __v) const + { return _M_extract_int(__beg, __end, __io, __err, __v); } + + virtual iter_type + do_get(iter_type __beg, iter_type __end, ios_base& __io, + ios_base::iostate& __err, unsigned long& __v) const + { return _M_extract_int(__beg, __end, __io, __err, __v); } + +#ifdef _GLIBCXX_USE_LONG_LONG + virtual iter_type + do_get(iter_type __beg, iter_type __end, ios_base& __io, + ios_base::iostate& __err, long long& __v) const + { return _M_extract_int(__beg, __end, __io, __err, __v); } + + virtual iter_type + do_get(iter_type __beg, iter_type __end, ios_base& __io, + ios_base::iostate& __err, unsigned long long& __v) const + { return _M_extract_int(__beg, __end, __io, __err, __v); } +#endif + + virtual iter_type + do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, float&) const; + + virtual iter_type + do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, + double&) const; + + // XXX GLIBCXX_ABI Deprecated +#if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__ + virtual iter_type + __do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, + double&) const; +#else + virtual iter_type + do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, + long double&) const; +#endif + + virtual iter_type + do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, void*&) const; + + // XXX GLIBCXX_ABI Deprecated +#if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__ + virtual iter_type + do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, + long double&) const; +#endif + //@} + }; + + template + locale::id num_get<_CharT, _InIter>::id; + + + /** + * @brief Primary class template num_put. + * @ingroup locales + * + * This facet encapsulates the code to convert a number to a string. It is + * used by the ostream numeric insertion operators. + * + * The num_put template uses protected virtual functions to provide the + * actual results. The public accessors forward the call to the virtual + * functions. These virtual functions are hooks for developers to + * implement the behavior they require from the num_put facet. + */ + template + class num_put : public locale::facet + { + public: + // Types: + //@{ + /// Public typedefs + typedef _CharT char_type; + typedef _OutIter iter_type; + //@} + + /// Numpunct facet id. + static locale::id id; + + /** + * @brief Constructor performs initialization. + * + * This is the constructor provided by the standard. + * + * @param __refs Passed to the base facet class. + */ + explicit + num_put(size_t __refs = 0) : facet(__refs) { } + + /** + * @brief Numeric formatting. + * + * Formats the boolean @a v and inserts it into a stream. It does so + * by calling num_put::do_put(). + * + * If ios_base::boolalpha is set, writes ctype::truename() or + * ctype::falsename(). Otherwise formats @a v as an int. + * + * @param __s Stream to write to. + * @param __io Source of locale and flags. + * @param __fill Char_type to use for filling. + * @param __v Value to format and insert. + * @return Iterator after writing. + */ + iter_type + put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const + { return this->do_put(__s, __io, __fill, __v); } + + //@{ + /** + * @brief Numeric formatting. + * + * Formats the integral value @a v and inserts it into a + * stream. It does so by calling num_put::do_put(). + * + * Formatting is affected by the flag settings in @a io. + * + * The basic format is affected by the value of io.flags() & + * ios_base::basefield. If equal to ios_base::oct, formats like the + * printf %o specifier. Else if equal to ios_base::hex, formats like + * %x or %X with ios_base::uppercase unset or set respectively. + * Otherwise, formats like %d, %ld, %lld for signed and %u, %lu, %llu + * for unsigned values. Note that if both oct and hex are set, neither + * will take effect. + * + * If ios_base::showpos is set, '+' is output before positive values. + * If ios_base::showbase is set, '0' precedes octal values (except 0) + * and '0[xX]' precedes hex values. + * + * The decimal point character used is numpunct::decimal_point(). + * Thousands separators are inserted according to + * numpunct::grouping() and numpunct::thousands_sep(). + * + * If io.width() is non-zero, enough @a fill characters are inserted to + * make the result at least that wide. If + * (io.flags() & ios_base::adjustfield) == ios_base::left, result is + * padded at the end. If ios_base::internal, then padding occurs + * immediately after either a '+' or '-' or after '0x' or '0X'. + * Otherwise, padding occurs at the beginning. + * + * @param __s Stream to write to. + * @param __io Source of locale and flags. + * @param __fill Char_type to use for filling. + * @param __v Value to format and insert. + * @return Iterator after writing. + */ + iter_type + put(iter_type __s, ios_base& __io, char_type __fill, long __v) const + { return this->do_put(__s, __io, __fill, __v); } + + iter_type + put(iter_type __s, ios_base& __io, char_type __fill, + unsigned long __v) const + { return this->do_put(__s, __io, __fill, __v); } + +#ifdef _GLIBCXX_USE_LONG_LONG + iter_type + put(iter_type __s, ios_base& __io, char_type __fill, long long __v) const + { return this->do_put(__s, __io, __fill, __v); } + + iter_type + put(iter_type __s, ios_base& __io, char_type __fill, + unsigned long long __v) const + { return this->do_put(__s, __io, __fill, __v); } +#endif + //@} + + //@{ + /** + * @brief Numeric formatting. + * + * Formats the floating point value @a v and inserts it into a stream. + * It does so by calling num_put::do_put(). + * + * Formatting is affected by the flag settings in @a io. + * + * The basic format is affected by the value of io.flags() & + * ios_base::floatfield. If equal to ios_base::fixed, formats like the + * printf %f specifier. Else if equal to ios_base::scientific, formats + * like %e or %E with ios_base::uppercase unset or set respectively. + * Otherwise, formats like %g or %G depending on uppercase. Note that + * if both fixed and scientific are set, the effect will also be like + * %g or %G. + * + * The output precision is given by io.precision(). This precision is + * capped at numeric_limits::digits10 + 2 (different for double and + * long double). The default precision is 6. + * + * If ios_base::showpos is set, '+' is output before positive values. + * If ios_base::showpoint is set, a decimal point will always be + * output. + * + * The decimal point character used is numpunct::decimal_point(). + * Thousands separators are inserted according to + * numpunct::grouping() and numpunct::thousands_sep(). + * + * If io.width() is non-zero, enough @a fill characters are inserted to + * make the result at least that wide. If + * (io.flags() & ios_base::adjustfield) == ios_base::left, result is + * padded at the end. If ios_base::internal, then padding occurs + * immediately after either a '+' or '-' or after '0x' or '0X'. + * Otherwise, padding occurs at the beginning. + * + * @param __s Stream to write to. + * @param __io Source of locale and flags. + * @param __fill Char_type to use for filling. + * @param __v Value to format and insert. + * @return Iterator after writing. + */ + iter_type + put(iter_type __s, ios_base& __io, char_type __fill, double __v) const + { return this->do_put(__s, __io, __fill, __v); } + + iter_type + put(iter_type __s, ios_base& __io, char_type __fill, + long double __v) const + { return this->do_put(__s, __io, __fill, __v); } + //@} + + /** + * @brief Numeric formatting. + * + * Formats the pointer value @a v and inserts it into a stream. It + * does so by calling num_put::do_put(). + * + * This function formats @a v as an unsigned long with ios_base::hex + * and ios_base::showbase set. + * + * @param __s Stream to write to. + * @param __io Source of locale and flags. + * @param __fill Char_type to use for filling. + * @param __v Value to format and insert. + * @return Iterator after writing. + */ + iter_type + put(iter_type __s, ios_base& __io, char_type __fill, + const void* __v) const + { return this->do_put(__s, __io, __fill, __v); } + + protected: + template + iter_type + _M_insert_float(iter_type, ios_base& __io, char_type __fill, + char __mod, _ValueT __v) const; + + void + _M_group_float(const char* __grouping, size_t __grouping_size, + char_type __sep, const char_type* __p, char_type* __new, + char_type* __cs, int& __len) const; + + template + iter_type + _M_insert_int(iter_type, ios_base& __io, char_type __fill, + _ValueT __v) const; + + void + _M_group_int(const char* __grouping, size_t __grouping_size, + char_type __sep, ios_base& __io, char_type* __new, + char_type* __cs, int& __len) const; + + void + _M_pad(char_type __fill, streamsize __w, ios_base& __io, + char_type* __new, const char_type* __cs, int& __len) const; + + /// Destructor. + virtual + ~num_put() { }; + + //@{ + /** + * @brief Numeric formatting. + * + * These functions do the work of formatting numeric values and + * inserting them into a stream. This function is a hook for derived + * classes to change the value returned. + * + * @param __s Stream to write to. + * @param __io Source of locale and flags. + * @param __fill Char_type to use for filling. + * @param __v Value to format and insert. + * @return Iterator after writing. + */ + virtual iter_type + do_put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const; + + virtual iter_type + do_put(iter_type __s, ios_base& __io, char_type __fill, long __v) const + { return _M_insert_int(__s, __io, __fill, __v); } + + virtual iter_type + do_put(iter_type __s, ios_base& __io, char_type __fill, + unsigned long __v) const + { return _M_insert_int(__s, __io, __fill, __v); } + +#ifdef _GLIBCXX_USE_LONG_LONG + virtual iter_type + do_put(iter_type __s, ios_base& __io, char_type __fill, + long long __v) const + { return _M_insert_int(__s, __io, __fill, __v); } + + virtual iter_type + do_put(iter_type __s, ios_base& __io, char_type __fill, + unsigned long long __v) const + { return _M_insert_int(__s, __io, __fill, __v); } +#endif + + virtual iter_type + do_put(iter_type, ios_base&, char_type, double) const; + + // XXX GLIBCXX_ABI Deprecated +#if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__ + virtual iter_type + __do_put(iter_type, ios_base&, char_type, double) const; +#else + virtual iter_type + do_put(iter_type, ios_base&, char_type, long double) const; +#endif + + virtual iter_type + do_put(iter_type, ios_base&, char_type, const void*) const; + + // XXX GLIBCXX_ABI Deprecated +#if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__ + virtual iter_type + do_put(iter_type, ios_base&, char_type, long double) const; +#endif + //@} + }; + + template + locale::id num_put<_CharT, _OutIter>::id; + +_GLIBCXX_END_NAMESPACE_LDBL + + // Subclause convenience interfaces, inlines. + // NB: These are inline because, when used in a loop, some compilers + // can hoist the body out of the loop; then it's just as fast as the + // C is*() function. + + /// Convenience interface to ctype.is(ctype_base::space, __c). + template + inline bool + isspace(_CharT __c, const locale& __loc) + { return use_facet >(__loc).is(ctype_base::space, __c); } + + /// Convenience interface to ctype.is(ctype_base::print, __c). + template + inline bool + isprint(_CharT __c, const locale& __loc) + { return use_facet >(__loc).is(ctype_base::print, __c); } + + /// Convenience interface to ctype.is(ctype_base::cntrl, __c). + template + inline bool + iscntrl(_CharT __c, const locale& __loc) + { return use_facet >(__loc).is(ctype_base::cntrl, __c); } + + /// Convenience interface to ctype.is(ctype_base::upper, __c). + template + inline bool + isupper(_CharT __c, const locale& __loc) + { return use_facet >(__loc).is(ctype_base::upper, __c); } + + /// Convenience interface to ctype.is(ctype_base::lower, __c). + template + inline bool + islower(_CharT __c, const locale& __loc) + { return use_facet >(__loc).is(ctype_base::lower, __c); } + + /// Convenience interface to ctype.is(ctype_base::alpha, __c). + template + inline bool + isalpha(_CharT __c, const locale& __loc) + { return use_facet >(__loc).is(ctype_base::alpha, __c); } + + /// Convenience interface to ctype.is(ctype_base::digit, __c). + template + inline bool + isdigit(_CharT __c, const locale& __loc) + { return use_facet >(__loc).is(ctype_base::digit, __c); } + + /// Convenience interface to ctype.is(ctype_base::punct, __c). + template + inline bool + ispunct(_CharT __c, const locale& __loc) + { return use_facet >(__loc).is(ctype_base::punct, __c); } + + /// Convenience interface to ctype.is(ctype_base::xdigit, __c). + template + inline bool + isxdigit(_CharT __c, const locale& __loc) + { return use_facet >(__loc).is(ctype_base::xdigit, __c); } + + /// Convenience interface to ctype.is(ctype_base::alnum, __c). + template + inline bool + isalnum(_CharT __c, const locale& __loc) + { return use_facet >(__loc).is(ctype_base::alnum, __c); } + + /// Convenience interface to ctype.is(ctype_base::graph, __c). + template + inline bool + isgraph(_CharT __c, const locale& __loc) + { return use_facet >(__loc).is(ctype_base::graph, __c); } + + /// Convenience interface to ctype.toupper(__c). + template + inline _CharT + toupper(_CharT __c, const locale& __loc) + { return use_facet >(__loc).toupper(__c); } + + /// Convenience interface to ctype.tolower(__c). + template + inline _CharT + tolower(_CharT __c, const locale& __loc) + { return use_facet >(__loc).tolower(__c); } + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace std + +# include + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/locale_facets.tcc b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/locale_facets.tcc new file mode 100755 index 0000000..cf12a08 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/locale_facets.tcc @@ -0,0 +1,1360 @@ +// Locale support -*- C++ -*- + +// Copyright (C) 1997-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file bits/locale_facets.tcc + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{locale} + */ + +#ifndef _LOCALE_FACETS_TCC +#define _LOCALE_FACETS_TCC 1 + +#pragma GCC system_header + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + // Routine to access a cache for the facet. If the cache didn't + // exist before, it gets constructed on the fly. + template + struct __use_cache + { + const _Facet* + operator() (const locale& __loc) const; + }; + + // Specializations. + template + struct __use_cache<__numpunct_cache<_CharT> > + { + const __numpunct_cache<_CharT>* + operator() (const locale& __loc) const + { + const size_t __i = numpunct<_CharT>::id._M_id(); + const locale::facet** __caches = __loc._M_impl->_M_caches; + if (!__caches[__i]) + { + __numpunct_cache<_CharT>* __tmp = 0; + __try + { + __tmp = new __numpunct_cache<_CharT>; + __tmp->_M_cache(__loc); + } + __catch(...) + { + delete __tmp; + __throw_exception_again; + } + __loc._M_impl->_M_install_cache(__tmp, __i); + } + return static_cast*>(__caches[__i]); + } + }; + + template + void + __numpunct_cache<_CharT>::_M_cache(const locale& __loc) + { + _M_allocated = true; + + const numpunct<_CharT>& __np = use_facet >(__loc); + + char* __grouping = 0; + _CharT* __truename = 0; + _CharT* __falsename = 0; + __try + { + _M_grouping_size = __np.grouping().size(); + __grouping = new char[_M_grouping_size]; + __np.grouping().copy(__grouping, _M_grouping_size); + _M_grouping = __grouping; + _M_use_grouping = (_M_grouping_size + && static_cast(_M_grouping[0]) > 0 + && (_M_grouping[0] + != __gnu_cxx::__numeric_traits::__max)); + + _M_truename_size = __np.truename().size(); + __truename = new _CharT[_M_truename_size]; + __np.truename().copy(__truename, _M_truename_size); + _M_truename = __truename; + + _M_falsename_size = __np.falsename().size(); + __falsename = new _CharT[_M_falsename_size]; + __np.falsename().copy(__falsename, _M_falsename_size); + _M_falsename = __falsename; + + _M_decimal_point = __np.decimal_point(); + _M_thousands_sep = __np.thousands_sep(); + + const ctype<_CharT>& __ct = use_facet >(__loc); + __ct.widen(__num_base::_S_atoms_out, + __num_base::_S_atoms_out + + __num_base::_S_oend, _M_atoms_out); + __ct.widen(__num_base::_S_atoms_in, + __num_base::_S_atoms_in + + __num_base::_S_iend, _M_atoms_in); + } + __catch(...) + { + delete [] __grouping; + delete [] __truename; + delete [] __falsename; + __throw_exception_again; + } + } + + // Used by both numeric and monetary facets. + // Check to make sure that the __grouping_tmp string constructed in + // money_get or num_get matches the canonical grouping for a given + // locale. + // __grouping_tmp is parsed L to R + // 1,222,444 == __grouping_tmp of "\1\3\3" + // __grouping is parsed R to L + // 1,222,444 == __grouping of "\3" == "\3\3\3" + _GLIBCXX_PURE bool + __verify_grouping(const char* __grouping, size_t __grouping_size, + const string& __grouping_tmp) throw (); + +_GLIBCXX_BEGIN_NAMESPACE_LDBL + + template + _InIter + num_get<_CharT, _InIter>:: + _M_extract_float(_InIter __beg, _InIter __end, ios_base& __io, + ios_base::iostate& __err, string& __xtrc) const + { + typedef char_traits<_CharT> __traits_type; + typedef __numpunct_cache<_CharT> __cache_type; + __use_cache<__cache_type> __uc; + const locale& __loc = __io._M_getloc(); + const __cache_type* __lc = __uc(__loc); + const _CharT* __lit = __lc->_M_atoms_in; + char_type __c = char_type(); + + // True if __beg becomes equal to __end. + bool __testeof = __beg == __end; + + // First check for sign. + if (!__testeof) + { + __c = *__beg; + const bool __plus = __c == __lit[__num_base::_S_iplus]; + if ((__plus || __c == __lit[__num_base::_S_iminus]) + && !(__lc->_M_use_grouping && __c == __lc->_M_thousands_sep) + && !(__c == __lc->_M_decimal_point)) + { + __xtrc += __plus ? '+' : '-'; + if (++__beg != __end) + __c = *__beg; + else + __testeof = true; + } + } + + // Next, look for leading zeros. + bool __found_mantissa = false; + int __sep_pos = 0; + while (!__testeof) + { + if ((__lc->_M_use_grouping && __c == __lc->_M_thousands_sep) + || __c == __lc->_M_decimal_point) + break; + else if (__c == __lit[__num_base::_S_izero]) + { + if (!__found_mantissa) + { + __xtrc += '0'; + __found_mantissa = true; + } + ++__sep_pos; + + if (++__beg != __end) + __c = *__beg; + else + __testeof = true; + } + else + break; + } + + // Only need acceptable digits for floating point numbers. + bool __found_dec = false; + bool __found_sci = false; + string __found_grouping; + if (__lc->_M_use_grouping) + __found_grouping.reserve(32); + const char_type* __lit_zero = __lit + __num_base::_S_izero; + + if (!__lc->_M_allocated) + // "C" locale + while (!__testeof) + { + const int __digit = _M_find(__lit_zero, 10, __c); + if (__digit != -1) + { + __xtrc += '0' + __digit; + __found_mantissa = true; + } + else if (__c == __lc->_M_decimal_point + && !__found_dec && !__found_sci) + { + __xtrc += '.'; + __found_dec = true; + } + else if ((__c == __lit[__num_base::_S_ie] + || __c == __lit[__num_base::_S_iE]) + && !__found_sci && __found_mantissa) + { + // Scientific notation. + __xtrc += 'e'; + __found_sci = true; + + // Remove optional plus or minus sign, if they exist. + if (++__beg != __end) + { + __c = *__beg; + const bool __plus = __c == __lit[__num_base::_S_iplus]; + if (__plus || __c == __lit[__num_base::_S_iminus]) + __xtrc += __plus ? '+' : '-'; + else + continue; + } + else + { + __testeof = true; + break; + } + } + else + break; + + if (++__beg != __end) + __c = *__beg; + else + __testeof = true; + } + else + while (!__testeof) + { + // According to 22.2.2.1.2, p8-9, first look for thousands_sep + // and decimal_point. + if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep) + { + if (!__found_dec && !__found_sci) + { + // NB: Thousands separator at the beginning of a string + // is a no-no, as is two consecutive thousands separators. + if (__sep_pos) + { + __found_grouping += static_cast(__sep_pos); + __sep_pos = 0; + } + else + { + // NB: __convert_to_v will not assign __v and will + // set the failbit. + __xtrc.clear(); + break; + } + } + else + break; + } + else if (__c == __lc->_M_decimal_point) + { + if (!__found_dec && !__found_sci) + { + // If no grouping chars are seen, no grouping check + // is applied. Therefore __found_grouping is adjusted + // only if decimal_point comes after some thousands_sep. + if (__found_grouping.size()) + __found_grouping += static_cast(__sep_pos); + __xtrc += '.'; + __found_dec = true; + } + else + break; + } + else + { + const char_type* __q = + __traits_type::find(__lit_zero, 10, __c); + if (__q) + { + __xtrc += '0' + (__q - __lit_zero); + __found_mantissa = true; + ++__sep_pos; + } + else if ((__c == __lit[__num_base::_S_ie] + || __c == __lit[__num_base::_S_iE]) + && !__found_sci && __found_mantissa) + { + // Scientific notation. + if (__found_grouping.size() && !__found_dec) + __found_grouping += static_cast(__sep_pos); + __xtrc += 'e'; + __found_sci = true; + + // Remove optional plus or minus sign, if they exist. + if (++__beg != __end) + { + __c = *__beg; + const bool __plus = __c == __lit[__num_base::_S_iplus]; + if ((__plus || __c == __lit[__num_base::_S_iminus]) + && !(__lc->_M_use_grouping + && __c == __lc->_M_thousands_sep) + && !(__c == __lc->_M_decimal_point)) + __xtrc += __plus ? '+' : '-'; + else + continue; + } + else + { + __testeof = true; + break; + } + } + else + break; + } + + if (++__beg != __end) + __c = *__beg; + else + __testeof = true; + } + + // Digit grouping is checked. If grouping and found_grouping don't + // match, then get very very upset, and set failbit. + if (__found_grouping.size()) + { + // Add the ending grouping if a decimal or 'e'/'E' wasn't found. + if (!__found_dec && !__found_sci) + __found_grouping += static_cast(__sep_pos); + + if (!std::__verify_grouping(__lc->_M_grouping, + __lc->_M_grouping_size, + __found_grouping)) + __err = ios_base::failbit; + } + + return __beg; + } + + template + template + _InIter + num_get<_CharT, _InIter>:: + _M_extract_int(_InIter __beg, _InIter __end, ios_base& __io, + ios_base::iostate& __err, _ValueT& __v) const + { + typedef char_traits<_CharT> __traits_type; + using __gnu_cxx::__add_unsigned; + typedef typename __add_unsigned<_ValueT>::__type __unsigned_type; + typedef __numpunct_cache<_CharT> __cache_type; + __use_cache<__cache_type> __uc; + const locale& __loc = __io._M_getloc(); + const __cache_type* __lc = __uc(__loc); + const _CharT* __lit = __lc->_M_atoms_in; + char_type __c = char_type(); + + // NB: Iff __basefield == 0, __base can change based on contents. + const ios_base::fmtflags __basefield = __io.flags() + & ios_base::basefield; + const bool __oct = __basefield == ios_base::oct; + int __base = __oct ? 8 : (__basefield == ios_base::hex ? 16 : 10); + + // True if __beg becomes equal to __end. + bool __testeof = __beg == __end; + + // First check for sign. + bool __negative = false; + if (!__testeof) + { + __c = *__beg; + __negative = __c == __lit[__num_base::_S_iminus]; + if ((__negative || __c == __lit[__num_base::_S_iplus]) + && !(__lc->_M_use_grouping && __c == __lc->_M_thousands_sep) + && !(__c == __lc->_M_decimal_point)) + { + if (++__beg != __end) + __c = *__beg; + else + __testeof = true; + } + } + + // Next, look for leading zeros and check required digits + // for base formats. + bool __found_zero = false; + int __sep_pos = 0; + while (!__testeof) + { + if ((__lc->_M_use_grouping && __c == __lc->_M_thousands_sep) + || __c == __lc->_M_decimal_point) + break; + else if (__c == __lit[__num_base::_S_izero] + && (!__found_zero || __base == 10)) + { + __found_zero = true; + ++__sep_pos; + if (__basefield == 0) + __base = 8; + if (__base == 8) + __sep_pos = 0; + } + else if (__found_zero + && (__c == __lit[__num_base::_S_ix] + || __c == __lit[__num_base::_S_iX])) + { + if (__basefield == 0) + __base = 16; + if (__base == 16) + { + __found_zero = false; + __sep_pos = 0; + } + else + break; + } + else + break; + + if (++__beg != __end) + { + __c = *__beg; + if (!__found_zero) + break; + } + else + __testeof = true; + } + + // At this point, base is determined. If not hex, only allow + // base digits as valid input. + const size_t __len = (__base == 16 ? __num_base::_S_iend + - __num_base::_S_izero : __base); + + // Extract. + string __found_grouping; + if (__lc->_M_use_grouping) + __found_grouping.reserve(32); + bool __testfail = false; + bool __testoverflow = false; + const __unsigned_type __max = + (__negative && __gnu_cxx::__numeric_traits<_ValueT>::__is_signed) + ? -__gnu_cxx::__numeric_traits<_ValueT>::__min + : __gnu_cxx::__numeric_traits<_ValueT>::__max; + const __unsigned_type __smax = __max / __base; + __unsigned_type __result = 0; + int __digit = 0; + const char_type* __lit_zero = __lit + __num_base::_S_izero; + + if (!__lc->_M_allocated) + // "C" locale + while (!__testeof) + { + __digit = _M_find(__lit_zero, __len, __c); + if (__digit == -1) + break; + + if (__result > __smax) + __testoverflow = true; + else + { + __result *= __base; + __testoverflow |= __result > __max - __digit; + __result += __digit; + ++__sep_pos; + } + + if (++__beg != __end) + __c = *__beg; + else + __testeof = true; + } + else + while (!__testeof) + { + // According to 22.2.2.1.2, p8-9, first look for thousands_sep + // and decimal_point. + if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep) + { + // NB: Thousands separator at the beginning of a string + // is a no-no, as is two consecutive thousands separators. + if (__sep_pos) + { + __found_grouping += static_cast(__sep_pos); + __sep_pos = 0; + } + else + { + __testfail = true; + break; + } + } + else if (__c == __lc->_M_decimal_point) + break; + else + { + const char_type* __q = + __traits_type::find(__lit_zero, __len, __c); + if (!__q) + break; + + __digit = __q - __lit_zero; + if (__digit > 15) + __digit -= 6; + if (__result > __smax) + __testoverflow = true; + else + { + __result *= __base; + __testoverflow |= __result > __max - __digit; + __result += __digit; + ++__sep_pos; + } + } + + if (++__beg != __end) + __c = *__beg; + else + __testeof = true; + } + + // Digit grouping is checked. If grouping and found_grouping don't + // match, then get very very upset, and set failbit. + if (__found_grouping.size()) + { + // Add the ending grouping. + __found_grouping += static_cast(__sep_pos); + + if (!std::__verify_grouping(__lc->_M_grouping, + __lc->_M_grouping_size, + __found_grouping)) + __err = ios_base::failbit; + } + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 23. Num_get overflow result. + if ((!__sep_pos && !__found_zero && !__found_grouping.size()) + || __testfail) + { + __v = 0; + __err = ios_base::failbit; + } + else if (__testoverflow) + { + if (__negative + && __gnu_cxx::__numeric_traits<_ValueT>::__is_signed) + __v = __gnu_cxx::__numeric_traits<_ValueT>::__min; + else + __v = __gnu_cxx::__numeric_traits<_ValueT>::__max; + __err = ios_base::failbit; + } + else + __v = __negative ? -__result : __result; + + if (__testeof) + __err |= ios_base::eofbit; + return __beg; + } + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 17. Bad bool parsing + template + _InIter + num_get<_CharT, _InIter>:: + do_get(iter_type __beg, iter_type __end, ios_base& __io, + ios_base::iostate& __err, bool& __v) const + { + if (!(__io.flags() & ios_base::boolalpha)) + { + // Parse bool values as long. + // NB: We can't just call do_get(long) here, as it might + // refer to a derived class. + long __l = -1; + __beg = _M_extract_int(__beg, __end, __io, __err, __l); + if (__l == 0 || __l == 1) + __v = bool(__l); + else + { + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 23. Num_get overflow result. + __v = true; + __err = ios_base::failbit; + if (__beg == __end) + __err |= ios_base::eofbit; + } + } + else + { + // Parse bool values as alphanumeric. + typedef __numpunct_cache<_CharT> __cache_type; + __use_cache<__cache_type> __uc; + const locale& __loc = __io._M_getloc(); + const __cache_type* __lc = __uc(__loc); + + bool __testf = true; + bool __testt = true; + bool __donef = __lc->_M_falsename_size == 0; + bool __donet = __lc->_M_truename_size == 0; + bool __testeof = false; + size_t __n = 0; + while (!__donef || !__donet) + { + if (__beg == __end) + { + __testeof = true; + break; + } + + const char_type __c = *__beg; + + if (!__donef) + __testf = __c == __lc->_M_falsename[__n]; + + if (!__testf && __donet) + break; + + if (!__donet) + __testt = __c == __lc->_M_truename[__n]; + + if (!__testt && __donef) + break; + + if (!__testt && !__testf) + break; + + ++__n; + ++__beg; + + __donef = !__testf || __n >= __lc->_M_falsename_size; + __donet = !__testt || __n >= __lc->_M_truename_size; + } + if (__testf && __n == __lc->_M_falsename_size && __n) + { + __v = false; + if (__testt && __n == __lc->_M_truename_size) + __err = ios_base::failbit; + else + __err = __testeof ? ios_base::eofbit : ios_base::goodbit; + } + else if (__testt && __n == __lc->_M_truename_size && __n) + { + __v = true; + __err = __testeof ? ios_base::eofbit : ios_base::goodbit; + } + else + { + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 23. Num_get overflow result. + __v = false; + __err = ios_base::failbit; + if (__testeof) + __err |= ios_base::eofbit; + } + } + return __beg; + } + + template + _InIter + num_get<_CharT, _InIter>:: + do_get(iter_type __beg, iter_type __end, ios_base& __io, + ios_base::iostate& __err, float& __v) const + { + string __xtrc; + __xtrc.reserve(32); + __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc); + std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale()); + if (__beg == __end) + __err |= ios_base::eofbit; + return __beg; + } + + template + _InIter + num_get<_CharT, _InIter>:: + do_get(iter_type __beg, iter_type __end, ios_base& __io, + ios_base::iostate& __err, double& __v) const + { + string __xtrc; + __xtrc.reserve(32); + __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc); + std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale()); + if (__beg == __end) + __err |= ios_base::eofbit; + return __beg; + } + +#if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__ + template + _InIter + num_get<_CharT, _InIter>:: + __do_get(iter_type __beg, iter_type __end, ios_base& __io, + ios_base::iostate& __err, double& __v) const + { + string __xtrc; + __xtrc.reserve(32); + __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc); + std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale()); + if (__beg == __end) + __err |= ios_base::eofbit; + return __beg; + } +#endif + + template + _InIter + num_get<_CharT, _InIter>:: + do_get(iter_type __beg, iter_type __end, ios_base& __io, + ios_base::iostate& __err, long double& __v) const + { + string __xtrc; + __xtrc.reserve(32); + __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc); + std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale()); + if (__beg == __end) + __err |= ios_base::eofbit; + return __beg; + } + + template + _InIter + num_get<_CharT, _InIter>:: + do_get(iter_type __beg, iter_type __end, ios_base& __io, + ios_base::iostate& __err, void*& __v) const + { + // Prepare for hex formatted input. + typedef ios_base::fmtflags fmtflags; + const fmtflags __fmt = __io.flags(); + __io.flags((__fmt & ~ios_base::basefield) | ios_base::hex); + + typedef __gnu_cxx::__conditional_type<(sizeof(void*) + <= sizeof(unsigned long)), + unsigned long, unsigned long long>::__type _UIntPtrType; + + _UIntPtrType __ul; + __beg = _M_extract_int(__beg, __end, __io, __err, __ul); + + // Reset from hex formatted input. + __io.flags(__fmt); + + __v = reinterpret_cast(__ul); + return __beg; + } + + // For use by integer and floating-point types after they have been + // converted into a char_type string. + template + void + num_put<_CharT, _OutIter>:: + _M_pad(_CharT __fill, streamsize __w, ios_base& __io, + _CharT* __new, const _CharT* __cs, int& __len) const + { + // [22.2.2.2.2] Stage 3. + // If necessary, pad. + __pad<_CharT, char_traits<_CharT> >::_S_pad(__io, __fill, __new, + __cs, __w, __len); + __len = static_cast(__w); + } + +_GLIBCXX_END_NAMESPACE_LDBL + + template + int + __int_to_char(_CharT* __bufend, _ValueT __v, const _CharT* __lit, + ios_base::fmtflags __flags, bool __dec) + { + _CharT* __buf = __bufend; + if (__builtin_expect(__dec, true)) + { + // Decimal. + do + { + *--__buf = __lit[(__v % 10) + __num_base::_S_odigits]; + __v /= 10; + } + while (__v != 0); + } + else if ((__flags & ios_base::basefield) == ios_base::oct) + { + // Octal. + do + { + *--__buf = __lit[(__v & 0x7) + __num_base::_S_odigits]; + __v >>= 3; + } + while (__v != 0); + } + else + { + // Hex. + const bool __uppercase = __flags & ios_base::uppercase; + const int __case_offset = __uppercase ? __num_base::_S_oudigits + : __num_base::_S_odigits; + do + { + *--__buf = __lit[(__v & 0xf) + __case_offset]; + __v >>= 4; + } + while (__v != 0); + } + return __bufend - __buf; + } + +_GLIBCXX_BEGIN_NAMESPACE_LDBL + + template + void + num_put<_CharT, _OutIter>:: + _M_group_int(const char* __grouping, size_t __grouping_size, _CharT __sep, + ios_base&, _CharT* __new, _CharT* __cs, int& __len) const + { + _CharT* __p = std::__add_grouping(__new, __sep, __grouping, + __grouping_size, __cs, __cs + __len); + __len = __p - __new; + } + + template + template + _OutIter + num_put<_CharT, _OutIter>:: + _M_insert_int(_OutIter __s, ios_base& __io, _CharT __fill, + _ValueT __v) const + { + using __gnu_cxx::__add_unsigned; + typedef typename __add_unsigned<_ValueT>::__type __unsigned_type; + typedef __numpunct_cache<_CharT> __cache_type; + __use_cache<__cache_type> __uc; + const locale& __loc = __io._M_getloc(); + const __cache_type* __lc = __uc(__loc); + const _CharT* __lit = __lc->_M_atoms_out; + const ios_base::fmtflags __flags = __io.flags(); + + // Long enough to hold hex, dec, and octal representations. + const int __ilen = 5 * sizeof(_ValueT); + _CharT* __cs = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) + * __ilen)); + + // [22.2.2.2.2] Stage 1, numeric conversion to character. + // Result is returned right-justified in the buffer. + const ios_base::fmtflags __basefield = __flags & ios_base::basefield; + const bool __dec = (__basefield != ios_base::oct + && __basefield != ios_base::hex); + const __unsigned_type __u = ((__v > 0 || !__dec) + ? __unsigned_type(__v) + : -__unsigned_type(__v)); + int __len = __int_to_char(__cs + __ilen, __u, __lit, __flags, __dec); + __cs += __ilen - __len; + + // Add grouping, if necessary. + if (__lc->_M_use_grouping) + { + // Grouping can add (almost) as many separators as the number + // of digits + space is reserved for numeric base or sign. + _CharT* __cs2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) + * (__len + 1) + * 2)); + _M_group_int(__lc->_M_grouping, __lc->_M_grouping_size, + __lc->_M_thousands_sep, __io, __cs2 + 2, __cs, __len); + __cs = __cs2 + 2; + } + + // Complete Stage 1, prepend numeric base or sign. + if (__builtin_expect(__dec, true)) + { + // Decimal. + if (__v >= 0) + { + if (bool(__flags & ios_base::showpos) + && __gnu_cxx::__numeric_traits<_ValueT>::__is_signed) + *--__cs = __lit[__num_base::_S_oplus], ++__len; + } + else + *--__cs = __lit[__num_base::_S_ominus], ++__len; + } + else if (bool(__flags & ios_base::showbase) && __v) + { + if (__basefield == ios_base::oct) + *--__cs = __lit[__num_base::_S_odigits], ++__len; + else + { + // 'x' or 'X' + const bool __uppercase = __flags & ios_base::uppercase; + *--__cs = __lit[__num_base::_S_ox + __uppercase]; + // '0' + *--__cs = __lit[__num_base::_S_odigits]; + __len += 2; + } + } + + // Pad. + const streamsize __w = __io.width(); + if (__w > static_cast(__len)) + { + _CharT* __cs3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) + * __w)); + _M_pad(__fill, __w, __io, __cs3, __cs, __len); + __cs = __cs3; + } + __io.width(0); + + // [22.2.2.2.2] Stage 4. + // Write resulting, fully-formatted string to output iterator. + return std::__write(__s, __cs, __len); + } + + template + void + num_put<_CharT, _OutIter>:: + _M_group_float(const char* __grouping, size_t __grouping_size, + _CharT __sep, const _CharT* __p, _CharT* __new, + _CharT* __cs, int& __len) const + { + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 282. What types does numpunct grouping refer to? + // Add grouping, if necessary. + const int __declen = __p ? __p - __cs : __len; + _CharT* __p2 = std::__add_grouping(__new, __sep, __grouping, + __grouping_size, + __cs, __cs + __declen); + + // Tack on decimal part. + int __newlen = __p2 - __new; + if (__p) + { + char_traits<_CharT>::copy(__p2, __p, __len - __declen); + __newlen += __len - __declen; + } + __len = __newlen; + } + + // The following code uses vsnprintf (or vsprintf(), when + // _GLIBCXX_USE_C99 is not defined) to convert floating point values + // for insertion into a stream. An optimization would be to replace + // them with code that works directly on a wide buffer and then use + // __pad to do the padding. It would be good to replace them anyway + // to gain back the efficiency that C++ provides by knowing up front + // the type of the values to insert. Also, sprintf is dangerous + // since may lead to accidental buffer overruns. This + // implementation follows the C++ standard fairly directly as + // outlined in 22.2.2.2 [lib.locale.num.put] + template + template + _OutIter + num_put<_CharT, _OutIter>:: + _M_insert_float(_OutIter __s, ios_base& __io, _CharT __fill, char __mod, + _ValueT __v) const + { + typedef __numpunct_cache<_CharT> __cache_type; + __use_cache<__cache_type> __uc; + const locale& __loc = __io._M_getloc(); + const __cache_type* __lc = __uc(__loc); + + // Use default precision if out of range. + const streamsize __prec = __io.precision() < 0 ? 6 : __io.precision(); + + const int __max_digits = + __gnu_cxx::__numeric_traits<_ValueT>::__digits10; + + // [22.2.2.2.2] Stage 1, numeric conversion to character. + int __len; + // Long enough for the max format spec. + char __fbuf[16]; + __num_base::_S_format_float(__io, __fbuf, __mod); + +#ifdef _GLIBCXX_USE_C99 + // First try a buffer perhaps big enough (most probably sufficient + // for non-ios_base::fixed outputs) + int __cs_size = __max_digits * 3; + char* __cs = static_cast(__builtin_alloca(__cs_size)); + __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size, + __fbuf, __prec, __v); + + // If the buffer was not large enough, try again with the correct size. + if (__len >= __cs_size) + { + __cs_size = __len + 1; + __cs = static_cast(__builtin_alloca(__cs_size)); + __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size, + __fbuf, __prec, __v); + } +#else + // Consider the possibility of long ios_base::fixed outputs + const bool __fixed = __io.flags() & ios_base::fixed; + const int __max_exp = + __gnu_cxx::__numeric_traits<_ValueT>::__max_exponent10; + + // The size of the output string is computed as follows. + // ios_base::fixed outputs may need up to __max_exp + 1 chars + // for the integer part + __prec chars for the fractional part + // + 3 chars for sign, decimal point, '\0'. On the other hand, + // for non-fixed outputs __max_digits * 2 + __prec chars are + // largely sufficient. + const int __cs_size = __fixed ? __max_exp + __prec + 4 + : __max_digits * 2 + __prec; + char* __cs = static_cast(__builtin_alloca(__cs_size)); + __len = std::__convert_from_v(_S_get_c_locale(), __cs, 0, __fbuf, + __prec, __v); +#endif + + // [22.2.2.2.2] Stage 2, convert to char_type, using correct + // numpunct.decimal_point() values for '.' and adding grouping. + const ctype<_CharT>& __ctype = use_facet >(__loc); + + _CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) + * __len)); + __ctype.widen(__cs, __cs + __len, __ws); + + // Replace decimal point. + _CharT* __wp = 0; + const char* __p = char_traits::find(__cs, __len, '.'); + if (__p) + { + __wp = __ws + (__p - __cs); + *__wp = __lc->_M_decimal_point; + } + + // Add grouping, if necessary. + // N.B. Make sure to not group things like 2e20, i.e., no decimal + // point, scientific notation. + if (__lc->_M_use_grouping + && (__wp || __len < 3 || (__cs[1] <= '9' && __cs[2] <= '9' + && __cs[1] >= '0' && __cs[2] >= '0'))) + { + // Grouping can add (almost) as many separators as the + // number of digits, but no more. + _CharT* __ws2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) + * __len * 2)); + + streamsize __off = 0; + if (__cs[0] == '-' || __cs[0] == '+') + { + __off = 1; + __ws2[0] = __ws[0]; + __len -= 1; + } + + _M_group_float(__lc->_M_grouping, __lc->_M_grouping_size, + __lc->_M_thousands_sep, __wp, __ws2 + __off, + __ws + __off, __len); + __len += __off; + + __ws = __ws2; + } + + // Pad. + const streamsize __w = __io.width(); + if (__w > static_cast(__len)) + { + _CharT* __ws3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) + * __w)); + _M_pad(__fill, __w, __io, __ws3, __ws, __len); + __ws = __ws3; + } + __io.width(0); + + // [22.2.2.2.2] Stage 4. + // Write resulting, fully-formatted string to output iterator. + return std::__write(__s, __ws, __len); + } + + template + _OutIter + num_put<_CharT, _OutIter>:: + do_put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const + { + const ios_base::fmtflags __flags = __io.flags(); + if ((__flags & ios_base::boolalpha) == 0) + { + const long __l = __v; + __s = _M_insert_int(__s, __io, __fill, __l); + } + else + { + typedef __numpunct_cache<_CharT> __cache_type; + __use_cache<__cache_type> __uc; + const locale& __loc = __io._M_getloc(); + const __cache_type* __lc = __uc(__loc); + + const _CharT* __name = __v ? __lc->_M_truename + : __lc->_M_falsename; + int __len = __v ? __lc->_M_truename_size + : __lc->_M_falsename_size; + + const streamsize __w = __io.width(); + if (__w > static_cast(__len)) + { + const streamsize __plen = __w - __len; + _CharT* __ps + = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) + * __plen)); + + char_traits<_CharT>::assign(__ps, __plen, __fill); + __io.width(0); + + if ((__flags & ios_base::adjustfield) == ios_base::left) + { + __s = std::__write(__s, __name, __len); + __s = std::__write(__s, __ps, __plen); + } + else + { + __s = std::__write(__s, __ps, __plen); + __s = std::__write(__s, __name, __len); + } + return __s; + } + __io.width(0); + __s = std::__write(__s, __name, __len); + } + return __s; + } + + template + _OutIter + num_put<_CharT, _OutIter>:: + do_put(iter_type __s, ios_base& __io, char_type __fill, double __v) const + { return _M_insert_float(__s, __io, __fill, char(), __v); } + +#if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__ + template + _OutIter + num_put<_CharT, _OutIter>:: + __do_put(iter_type __s, ios_base& __io, char_type __fill, double __v) const + { return _M_insert_float(__s, __io, __fill, char(), __v); } +#endif + + template + _OutIter + num_put<_CharT, _OutIter>:: + do_put(iter_type __s, ios_base& __io, char_type __fill, + long double __v) const + { return _M_insert_float(__s, __io, __fill, 'L', __v); } + + template + _OutIter + num_put<_CharT, _OutIter>:: + do_put(iter_type __s, ios_base& __io, char_type __fill, + const void* __v) const + { + const ios_base::fmtflags __flags = __io.flags(); + const ios_base::fmtflags __fmt = ~(ios_base::basefield + | ios_base::uppercase); + __io.flags((__flags & __fmt) | (ios_base::hex | ios_base::showbase)); + + typedef __gnu_cxx::__conditional_type<(sizeof(const void*) + <= sizeof(unsigned long)), + unsigned long, unsigned long long>::__type _UIntPtrType; + + __s = _M_insert_int(__s, __io, __fill, + reinterpret_cast<_UIntPtrType>(__v)); + __io.flags(__flags); + return __s; + } + +_GLIBCXX_END_NAMESPACE_LDBL + + // Construct correctly padded string, as per 22.2.2.2.2 + // Assumes + // __newlen > __oldlen + // __news is allocated for __newlen size + + // NB: Of the two parameters, _CharT can be deduced from the + // function arguments. The other (_Traits) has to be explicitly specified. + template + void + __pad<_CharT, _Traits>::_S_pad(ios_base& __io, _CharT __fill, + _CharT* __news, const _CharT* __olds, + streamsize __newlen, streamsize __oldlen) + { + const size_t __plen = static_cast(__newlen - __oldlen); + const ios_base::fmtflags __adjust = __io.flags() & ios_base::adjustfield; + + // Padding last. + if (__adjust == ios_base::left) + { + _Traits::copy(__news, __olds, __oldlen); + _Traits::assign(__news + __oldlen, __plen, __fill); + return; + } + + size_t __mod = 0; + if (__adjust == ios_base::internal) + { + // Pad after the sign, if there is one. + // Pad after 0[xX], if there is one. + // Who came up with these rules, anyway? Jeeze. + const locale& __loc = __io._M_getloc(); + const ctype<_CharT>& __ctype = use_facet >(__loc); + + if (__ctype.widen('-') == __olds[0] + || __ctype.widen('+') == __olds[0]) + { + __news[0] = __olds[0]; + __mod = 1; + ++__news; + } + else if (__ctype.widen('0') == __olds[0] + && __oldlen > 1 + && (__ctype.widen('x') == __olds[1] + || __ctype.widen('X') == __olds[1])) + { + __news[0] = __olds[0]; + __news[1] = __olds[1]; + __mod = 2; + __news += 2; + } + // else Padding first. + } + _Traits::assign(__news, __plen, __fill); + _Traits::copy(__news + __plen, __olds + __mod, __oldlen - __mod); + } + + template + _CharT* + __add_grouping(_CharT* __s, _CharT __sep, + const char* __gbeg, size_t __gsize, + const _CharT* __first, const _CharT* __last) + { + size_t __idx = 0; + size_t __ctr = 0; + + while (__last - __first > __gbeg[__idx] + && static_cast(__gbeg[__idx]) > 0 + && __gbeg[__idx] != __gnu_cxx::__numeric_traits::__max) + { + __last -= __gbeg[__idx]; + __idx < __gsize - 1 ? ++__idx : ++__ctr; + } + + while (__first != __last) + *__s++ = *__first++; + + while (__ctr--) + { + *__s++ = __sep; + for (char __i = __gbeg[__idx]; __i > 0; --__i) + *__s++ = *__first++; + } + + while (__idx--) + { + *__s++ = __sep; + for (char __i = __gbeg[__idx]; __i > 0; --__i) + *__s++ = *__first++; + } + + return __s; + } + + // Inhibit implicit instantiations for required instantiations, + // which are defined via explicit instantiations elsewhere. +#if _GLIBCXX_EXTERN_TEMPLATE + extern template class numpunct; + extern template class numpunct_byname; + extern template class _GLIBCXX_NAMESPACE_LDBL num_get; + extern template class _GLIBCXX_NAMESPACE_LDBL num_put; + extern template class ctype_byname; + + extern template + const ctype& + use_facet >(const locale&); + + extern template + const numpunct& + use_facet >(const locale&); + + extern template + const num_put& + use_facet >(const locale&); + + extern template + const num_get& + use_facet >(const locale&); + + extern template + bool + has_facet >(const locale&); + + extern template + bool + has_facet >(const locale&); + + extern template + bool + has_facet >(const locale&); + + extern template + bool + has_facet >(const locale&); + +#ifdef _GLIBCXX_USE_WCHAR_T + extern template class numpunct; + extern template class numpunct_byname; + extern template class _GLIBCXX_NAMESPACE_LDBL num_get; + extern template class _GLIBCXX_NAMESPACE_LDBL num_put; + extern template class ctype_byname; + + extern template + const ctype& + use_facet >(const locale&); + + extern template + const numpunct& + use_facet >(const locale&); + + extern template + const num_put& + use_facet >(const locale&); + + extern template + const num_get& + use_facet >(const locale&); + + extern template + bool + has_facet >(const locale&); + + extern template + bool + has_facet >(const locale&); + + extern template + bool + has_facet >(const locale&); + + extern template + bool + has_facet >(const locale&); +#endif +#endif + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/locale_facets_nonio.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/locale_facets_nonio.h new file mode 100755 index 0000000..3e2cc7f --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/locale_facets_nonio.h @@ -0,0 +1,1905 @@ +// Locale support -*- C++ -*- + +// Copyright (C) 2007-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file bits/locale_facets_nonio.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{locale} + */ + +// +// ISO C++ 14882: 22.1 Locales +// + +#ifndef _LOCALE_FACETS_NONIO_H +#define _LOCALE_FACETS_NONIO_H 1 + +#pragma GCC system_header + +#include // For struct tm + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /** + * @brief Time format ordering data. + * @ingroup locales + * + * This class provides an enum representing different orderings of + * time: day, month, and year. + */ + class time_base + { + public: + enum dateorder { no_order, dmy, mdy, ymd, ydm }; + }; + + template + struct __timepunct_cache : public locale::facet + { + // List of all known timezones, with GMT first. + static const _CharT* _S_timezones[14]; + + const _CharT* _M_date_format; + const _CharT* _M_date_era_format; + const _CharT* _M_time_format; + const _CharT* _M_time_era_format; + const _CharT* _M_date_time_format; + const _CharT* _M_date_time_era_format; + const _CharT* _M_am; + const _CharT* _M_pm; + const _CharT* _M_am_pm_format; + + // Day names, starting with "C"'s Sunday. + const _CharT* _M_day1; + const _CharT* _M_day2; + const _CharT* _M_day3; + const _CharT* _M_day4; + const _CharT* _M_day5; + const _CharT* _M_day6; + const _CharT* _M_day7; + + // Abbreviated day names, starting with "C"'s Sun. + const _CharT* _M_aday1; + const _CharT* _M_aday2; + const _CharT* _M_aday3; + const _CharT* _M_aday4; + const _CharT* _M_aday5; + const _CharT* _M_aday6; + const _CharT* _M_aday7; + + // Month names, starting with "C"'s January. + const _CharT* _M_month01; + const _CharT* _M_month02; + const _CharT* _M_month03; + const _CharT* _M_month04; + const _CharT* _M_month05; + const _CharT* _M_month06; + const _CharT* _M_month07; + const _CharT* _M_month08; + const _CharT* _M_month09; + const _CharT* _M_month10; + const _CharT* _M_month11; + const _CharT* _M_month12; + + // Abbreviated month names, starting with "C"'s Jan. + const _CharT* _M_amonth01; + const _CharT* _M_amonth02; + const _CharT* _M_amonth03; + const _CharT* _M_amonth04; + const _CharT* _M_amonth05; + const _CharT* _M_amonth06; + const _CharT* _M_amonth07; + const _CharT* _M_amonth08; + const _CharT* _M_amonth09; + const _CharT* _M_amonth10; + const _CharT* _M_amonth11; + const _CharT* _M_amonth12; + + bool _M_allocated; + + __timepunct_cache(size_t __refs = 0) : facet(__refs), + _M_date_format(0), _M_date_era_format(0), _M_time_format(0), + _M_time_era_format(0), _M_date_time_format(0), + _M_date_time_era_format(0), _M_am(0), _M_pm(0), + _M_am_pm_format(0), _M_day1(0), _M_day2(0), _M_day3(0), + _M_day4(0), _M_day5(0), _M_day6(0), _M_day7(0), + _M_aday1(0), _M_aday2(0), _M_aday3(0), _M_aday4(0), + _M_aday5(0), _M_aday6(0), _M_aday7(0), _M_month01(0), + _M_month02(0), _M_month03(0), _M_month04(0), _M_month05(0), + _M_month06(0), _M_month07(0), _M_month08(0), _M_month09(0), + _M_month10(0), _M_month11(0), _M_month12(0), _M_amonth01(0), + _M_amonth02(0), _M_amonth03(0), _M_amonth04(0), + _M_amonth05(0), _M_amonth06(0), _M_amonth07(0), + _M_amonth08(0), _M_amonth09(0), _M_amonth10(0), + _M_amonth11(0), _M_amonth12(0), _M_allocated(false) + { } + + ~__timepunct_cache(); + + void + _M_cache(const locale& __loc); + + private: + __timepunct_cache& + operator=(const __timepunct_cache&); + + explicit + __timepunct_cache(const __timepunct_cache&); + }; + + template + __timepunct_cache<_CharT>::~__timepunct_cache() + { + if (_M_allocated) + { + // Unused. + } + } + + // Specializations. + template<> + const char* + __timepunct_cache::_S_timezones[14]; + +#ifdef _GLIBCXX_USE_WCHAR_T + template<> + const wchar_t* + __timepunct_cache::_S_timezones[14]; +#endif + + // Generic. + template + const _CharT* __timepunct_cache<_CharT>::_S_timezones[14]; + + template + class __timepunct : public locale::facet + { + public: + // Types: + typedef _CharT __char_type; + typedef basic_string<_CharT> __string_type; + typedef __timepunct_cache<_CharT> __cache_type; + + protected: + __cache_type* _M_data; + __c_locale _M_c_locale_timepunct; + const char* _M_name_timepunct; + + public: + /// Numpunct facet id. + static locale::id id; + + explicit + __timepunct(size_t __refs = 0); + + explicit + __timepunct(__cache_type* __cache, size_t __refs = 0); + + /** + * @brief Internal constructor. Not for general use. + * + * This is a constructor for use by the library itself to set up new + * locales. + * + * @param __cloc The C locale. + * @param __s The name of a locale. + * @param refs Passed to the base facet class. + */ + explicit + __timepunct(__c_locale __cloc, const char* __s, size_t __refs = 0); + + // FIXME: for error checking purposes _M_put should return the return + // value of strftime/wcsftime. + void + _M_put(_CharT* __s, size_t __maxlen, const _CharT* __format, + const tm* __tm) const throw (); + + void + _M_date_formats(const _CharT** __date) const + { + // Always have default first. + __date[0] = _M_data->_M_date_format; + __date[1] = _M_data->_M_date_era_format; + } + + void + _M_time_formats(const _CharT** __time) const + { + // Always have default first. + __time[0] = _M_data->_M_time_format; + __time[1] = _M_data->_M_time_era_format; + } + + void + _M_date_time_formats(const _CharT** __dt) const + { + // Always have default first. + __dt[0] = _M_data->_M_date_time_format; + __dt[1] = _M_data->_M_date_time_era_format; + } + + void + _M_am_pm_format(const _CharT* __ampm) const + { __ampm = _M_data->_M_am_pm_format; } + + void + _M_am_pm(const _CharT** __ampm) const + { + __ampm[0] = _M_data->_M_am; + __ampm[1] = _M_data->_M_pm; + } + + void + _M_days(const _CharT** __days) const + { + __days[0] = _M_data->_M_day1; + __days[1] = _M_data->_M_day2; + __days[2] = _M_data->_M_day3; + __days[3] = _M_data->_M_day4; + __days[4] = _M_data->_M_day5; + __days[5] = _M_data->_M_day6; + __days[6] = _M_data->_M_day7; + } + + void + _M_days_abbreviated(const _CharT** __days) const + { + __days[0] = _M_data->_M_aday1; + __days[1] = _M_data->_M_aday2; + __days[2] = _M_data->_M_aday3; + __days[3] = _M_data->_M_aday4; + __days[4] = _M_data->_M_aday5; + __days[5] = _M_data->_M_aday6; + __days[6] = _M_data->_M_aday7; + } + + void + _M_months(const _CharT** __months) const + { + __months[0] = _M_data->_M_month01; + __months[1] = _M_data->_M_month02; + __months[2] = _M_data->_M_month03; + __months[3] = _M_data->_M_month04; + __months[4] = _M_data->_M_month05; + __months[5] = _M_data->_M_month06; + __months[6] = _M_data->_M_month07; + __months[7] = _M_data->_M_month08; + __months[8] = _M_data->_M_month09; + __months[9] = _M_data->_M_month10; + __months[10] = _M_data->_M_month11; + __months[11] = _M_data->_M_month12; + } + + void + _M_months_abbreviated(const _CharT** __months) const + { + __months[0] = _M_data->_M_amonth01; + __months[1] = _M_data->_M_amonth02; + __months[2] = _M_data->_M_amonth03; + __months[3] = _M_data->_M_amonth04; + __months[4] = _M_data->_M_amonth05; + __months[5] = _M_data->_M_amonth06; + __months[6] = _M_data->_M_amonth07; + __months[7] = _M_data->_M_amonth08; + __months[8] = _M_data->_M_amonth09; + __months[9] = _M_data->_M_amonth10; + __months[10] = _M_data->_M_amonth11; + __months[11] = _M_data->_M_amonth12; + } + + protected: + virtual + ~__timepunct(); + + // For use at construction time only. + void + _M_initialize_timepunct(__c_locale __cloc = 0); + }; + + template + locale::id __timepunct<_CharT>::id; + + // Specializations. + template<> + void + __timepunct::_M_initialize_timepunct(__c_locale __cloc); + + template<> + void + __timepunct::_M_put(char*, size_t, const char*, const tm*) const throw (); + +#ifdef _GLIBCXX_USE_WCHAR_T + template<> + void + __timepunct::_M_initialize_timepunct(__c_locale __cloc); + + template<> + void + __timepunct::_M_put(wchar_t*, size_t, const wchar_t*, + const tm*) const throw (); +#endif + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + + // Include host and configuration specific timepunct functions. + #include + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /** + * @brief Primary class template time_get. + * @ingroup locales + * + * This facet encapsulates the code to parse and return a date or + * time from a string. It is used by the istream numeric + * extraction operators. + * + * The time_get template uses protected virtual functions to provide the + * actual results. The public accessors forward the call to the virtual + * functions. These virtual functions are hooks for developers to + * implement the behavior they require from the time_get facet. + */ + template + class time_get : public locale::facet, public time_base + { + public: + // Types: + //@{ + /// Public typedefs + typedef _CharT char_type; + typedef _InIter iter_type; + //@} + typedef basic_string<_CharT> __string_type; + + /// Numpunct facet id. + static locale::id id; + + /** + * @brief Constructor performs initialization. + * + * This is the constructor provided by the standard. + * + * @param __refs Passed to the base facet class. + */ + explicit + time_get(size_t __refs = 0) + : facet (__refs) { } + + /** + * @brief Return preferred order of month, day, and year. + * + * This function returns an enum from timebase::dateorder giving the + * preferred ordering if the format @a x given to time_put::put() only + * uses month, day, and year. If the format @a x for the associated + * locale uses other fields, this function returns + * timebase::dateorder::noorder. + * + * NOTE: The library always returns noorder at the moment. + * + * @return A member of timebase::dateorder. + */ + dateorder + date_order() const + { return this->do_date_order(); } + + /** + * @brief Parse input time string. + * + * This function parses a time according to the format @a X and puts the + * results into a user-supplied struct tm. The result is returned by + * calling time_get::do_get_time(). + * + * If there is a valid time string according to format @a X, @a tm will + * be filled in accordingly and the returned iterator will point to the + * first character beyond the time string. If an error occurs before + * the end, err |= ios_base::failbit. If parsing reads all the + * characters, err |= ios_base::eofbit. + * + * @param __beg Start of string to parse. + * @param __end End of string to parse. + * @param __io Source of the locale. + * @param __err Error flags to set. + * @param __tm Pointer to struct tm to fill in. + * @return Iterator to first char beyond time string. + */ + iter_type + get_time(iter_type __beg, iter_type __end, ios_base& __io, + ios_base::iostate& __err, tm* __tm) const + { return this->do_get_time(__beg, __end, __io, __err, __tm); } + + /** + * @brief Parse input date string. + * + * This function parses a date according to the format @a x and puts the + * results into a user-supplied struct tm. The result is returned by + * calling time_get::do_get_date(). + * + * If there is a valid date string according to format @a x, @a tm will + * be filled in accordingly and the returned iterator will point to the + * first character beyond the date string. If an error occurs before + * the end, err |= ios_base::failbit. If parsing reads all the + * characters, err |= ios_base::eofbit. + * + * @param __beg Start of string to parse. + * @param __end End of string to parse. + * @param __io Source of the locale. + * @param __err Error flags to set. + * @param __tm Pointer to struct tm to fill in. + * @return Iterator to first char beyond date string. + */ + iter_type + get_date(iter_type __beg, iter_type __end, ios_base& __io, + ios_base::iostate& __err, tm* __tm) const + { return this->do_get_date(__beg, __end, __io, __err, __tm); } + + /** + * @brief Parse input weekday string. + * + * This function parses a weekday name and puts the results into a + * user-supplied struct tm. The result is returned by calling + * time_get::do_get_weekday(). + * + * Parsing starts by parsing an abbreviated weekday name. If a valid + * abbreviation is followed by a character that would lead to the full + * weekday name, parsing continues until the full name is found or an + * error occurs. Otherwise parsing finishes at the end of the + * abbreviated name. + * + * If an error occurs before the end, err |= ios_base::failbit. If + * parsing reads all the characters, err |= ios_base::eofbit. + * + * @param __beg Start of string to parse. + * @param __end End of string to parse. + * @param __io Source of the locale. + * @param __err Error flags to set. + * @param __tm Pointer to struct tm to fill in. + * @return Iterator to first char beyond weekday name. + */ + iter_type + get_weekday(iter_type __beg, iter_type __end, ios_base& __io, + ios_base::iostate& __err, tm* __tm) const + { return this->do_get_weekday(__beg, __end, __io, __err, __tm); } + + /** + * @brief Parse input month string. + * + * This function parses a month name and puts the results into a + * user-supplied struct tm. The result is returned by calling + * time_get::do_get_monthname(). + * + * Parsing starts by parsing an abbreviated month name. If a valid + * abbreviation is followed by a character that would lead to the full + * month name, parsing continues until the full name is found or an + * error occurs. Otherwise parsing finishes at the end of the + * abbreviated name. + * + * If an error occurs before the end, err |= ios_base::failbit. If + * parsing reads all the characters, err |= + * ios_base::eofbit. + * + * @param __beg Start of string to parse. + * @param __end End of string to parse. + * @param __io Source of the locale. + * @param __err Error flags to set. + * @param __tm Pointer to struct tm to fill in. + * @return Iterator to first char beyond month name. + */ + iter_type + get_monthname(iter_type __beg, iter_type __end, ios_base& __io, + ios_base::iostate& __err, tm* __tm) const + { return this->do_get_monthname(__beg, __end, __io, __err, __tm); } + + /** + * @brief Parse input year string. + * + * This function reads up to 4 characters to parse a year string and + * puts the results into a user-supplied struct tm. The result is + * returned by calling time_get::do_get_year(). + * + * 4 consecutive digits are interpreted as a full year. If there are + * exactly 2 consecutive digits, the library interprets this as the + * number of years since 1900. + * + * If an error occurs before the end, err |= ios_base::failbit. If + * parsing reads all the characters, err |= ios_base::eofbit. + * + * @param __beg Start of string to parse. + * @param __end End of string to parse. + * @param __io Source of the locale. + * @param __err Error flags to set. + * @param __tm Pointer to struct tm to fill in. + * @return Iterator to first char beyond year. + */ + iter_type + get_year(iter_type __beg, iter_type __end, ios_base& __io, + ios_base::iostate& __err, tm* __tm) const + { return this->do_get_year(__beg, __end, __io, __err, __tm); } + + protected: + /// Destructor. + virtual + ~time_get() { } + + /** + * @brief Return preferred order of month, day, and year. + * + * This function returns an enum from timebase::dateorder giving the + * preferred ordering if the format @a x given to time_put::put() only + * uses month, day, and year. This function is a hook for derived + * classes to change the value returned. + * + * @return A member of timebase::dateorder. + */ + virtual dateorder + do_date_order() const; + + /** + * @brief Parse input time string. + * + * This function parses a time according to the format @a x and puts the + * results into a user-supplied struct tm. This function is a hook for + * derived classes to change the value returned. @see get_time() for + * details. + * + * @param __beg Start of string to parse. + * @param __end End of string to parse. + * @param __io Source of the locale. + * @param __err Error flags to set. + * @param __tm Pointer to struct tm to fill in. + * @return Iterator to first char beyond time string. + */ + virtual iter_type + do_get_time(iter_type __beg, iter_type __end, ios_base& __io, + ios_base::iostate& __err, tm* __tm) const; + + /** + * @brief Parse input date string. + * + * This function parses a date according to the format @a X and puts the + * results into a user-supplied struct tm. This function is a hook for + * derived classes to change the value returned. @see get_date() for + * details. + * + * @param __beg Start of string to parse. + * @param __end End of string to parse. + * @param __io Source of the locale. + * @param __err Error flags to set. + * @param __tm Pointer to struct tm to fill in. + * @return Iterator to first char beyond date string. + */ + virtual iter_type + do_get_date(iter_type __beg, iter_type __end, ios_base& __io, + ios_base::iostate& __err, tm* __tm) const; + + /** + * @brief Parse input weekday string. + * + * This function parses a weekday name and puts the results into a + * user-supplied struct tm. This function is a hook for derived + * classes to change the value returned. @see get_weekday() for + * details. + * + * @param __beg Start of string to parse. + * @param __end End of string to parse. + * @param __io Source of the locale. + * @param __err Error flags to set. + * @param __tm Pointer to struct tm to fill in. + * @return Iterator to first char beyond weekday name. + */ + virtual iter_type + do_get_weekday(iter_type __beg, iter_type __end, ios_base&, + ios_base::iostate& __err, tm* __tm) const; + + /** + * @brief Parse input month string. + * + * This function parses a month name and puts the results into a + * user-supplied struct tm. This function is a hook for derived + * classes to change the value returned. @see get_monthname() for + * details. + * + * @param __beg Start of string to parse. + * @param __end End of string to parse. + * @param __io Source of the locale. + * @param __err Error flags to set. + * @param __tm Pointer to struct tm to fill in. + * @return Iterator to first char beyond month name. + */ + virtual iter_type + do_get_monthname(iter_type __beg, iter_type __end, ios_base&, + ios_base::iostate& __err, tm* __tm) const; + + /** + * @brief Parse input year string. + * + * This function reads up to 4 characters to parse a year string and + * puts the results into a user-supplied struct tm. This function is a + * hook for derived classes to change the value returned. @see + * get_year() for details. + * + * @param __beg Start of string to parse. + * @param __end End of string to parse. + * @param __io Source of the locale. + * @param __err Error flags to set. + * @param __tm Pointer to struct tm to fill in. + * @return Iterator to first char beyond year. + */ + virtual iter_type + do_get_year(iter_type __beg, iter_type __end, ios_base& __io, + ios_base::iostate& __err, tm* __tm) const; + + // Extract numeric component of length __len. + iter_type + _M_extract_num(iter_type __beg, iter_type __end, int& __member, + int __min, int __max, size_t __len, + ios_base& __io, ios_base::iostate& __err) const; + + // Extract any unique array of string literals in a const _CharT* array. + iter_type + _M_extract_name(iter_type __beg, iter_type __end, int& __member, + const _CharT** __names, size_t __indexlen, + ios_base& __io, ios_base::iostate& __err) const; + + // Extract day or month name in a const _CharT* array. + iter_type + _M_extract_wday_or_month(iter_type __beg, iter_type __end, int& __member, + const _CharT** __names, size_t __indexlen, + ios_base& __io, ios_base::iostate& __err) const; + + // Extract on a component-by-component basis, via __format argument. + iter_type + _M_extract_via_format(iter_type __beg, iter_type __end, ios_base& __io, + ios_base::iostate& __err, tm* __tm, + const _CharT* __format) const; + }; + + template + locale::id time_get<_CharT, _InIter>::id; + + /// class time_get_byname [22.2.5.2]. + template + class time_get_byname : public time_get<_CharT, _InIter> + { + public: + // Types: + typedef _CharT char_type; + typedef _InIter iter_type; + + explicit + time_get_byname(const char*, size_t __refs = 0) + : time_get<_CharT, _InIter>(__refs) { } + + protected: + virtual + ~time_get_byname() { } + }; + + /** + * @brief Primary class template time_put. + * @ingroup locales + * + * This facet encapsulates the code to format and output dates and times + * according to formats used by strftime(). + * + * The time_put template uses protected virtual functions to provide the + * actual results. The public accessors forward the call to the virtual + * functions. These virtual functions are hooks for developers to + * implement the behavior they require from the time_put facet. + */ + template + class time_put : public locale::facet + { + public: + // Types: + //@{ + /// Public typedefs + typedef _CharT char_type; + typedef _OutIter iter_type; + //@} + + /// Numpunct facet id. + static locale::id id; + + /** + * @brief Constructor performs initialization. + * + * This is the constructor provided by the standard. + * + * @param __refs Passed to the base facet class. + */ + explicit + time_put(size_t __refs = 0) + : facet(__refs) { } + + /** + * @brief Format and output a time or date. + * + * This function formats the data in struct tm according to the + * provided format string. The format string is interpreted as by + * strftime(). + * + * @param __s The stream to write to. + * @param __io Source of locale. + * @param __fill char_type to use for padding. + * @param __tm Struct tm with date and time info to format. + * @param __beg Start of format string. + * @param __end End of format string. + * @return Iterator after writing. + */ + iter_type + put(iter_type __s, ios_base& __io, char_type __fill, const tm* __tm, + const _CharT* __beg, const _CharT* __end) const; + + /** + * @brief Format and output a time or date. + * + * This function formats the data in struct tm according to the + * provided format char and optional modifier. The format and modifier + * are interpreted as by strftime(). It does so by returning + * time_put::do_put(). + * + * @param __s The stream to write to. + * @param __io Source of locale. + * @param __fill char_type to use for padding. + * @param __tm Struct tm with date and time info to format. + * @param __format Format char. + * @param __mod Optional modifier char. + * @return Iterator after writing. + */ + iter_type + put(iter_type __s, ios_base& __io, char_type __fill, + const tm* __tm, char __format, char __mod = 0) const + { return this->do_put(__s, __io, __fill, __tm, __format, __mod); } + + protected: + /// Destructor. + virtual + ~time_put() + { } + + /** + * @brief Format and output a time or date. + * + * This function formats the data in struct tm according to the + * provided format char and optional modifier. This function is a hook + * for derived classes to change the value returned. @see put() for + * more details. + * + * @param __s The stream to write to. + * @param __io Source of locale. + * @param __fill char_type to use for padding. + * @param __tm Struct tm with date and time info to format. + * @param __format Format char. + * @param __mod Optional modifier char. + * @return Iterator after writing. + */ + virtual iter_type + do_put(iter_type __s, ios_base& __io, char_type __fill, const tm* __tm, + char __format, char __mod) const; + }; + + template + locale::id time_put<_CharT, _OutIter>::id; + + /// class time_put_byname [22.2.5.4]. + template + class time_put_byname : public time_put<_CharT, _OutIter> + { + public: + // Types: + typedef _CharT char_type; + typedef _OutIter iter_type; + + explicit + time_put_byname(const char*, size_t __refs = 0) + : time_put<_CharT, _OutIter>(__refs) + { }; + + protected: + virtual + ~time_put_byname() { } + }; + + + /** + * @brief Money format ordering data. + * @ingroup locales + * + * This class contains an ordered array of 4 fields to represent the + * pattern for formatting a money amount. Each field may contain one entry + * from the part enum. symbol, sign, and value must be present and the + * remaining field must contain either none or space. @see + * moneypunct::pos_format() and moneypunct::neg_format() for details of how + * these fields are interpreted. + */ + class money_base + { + public: + enum part { none, space, symbol, sign, value }; + struct pattern { char field[4]; }; + + static const pattern _S_default_pattern; + + enum + { + _S_minus, + _S_zero, + _S_end = 11 + }; + + // String literal of acceptable (narrow) input/output, for + // money_get/money_put. "-0123456789" + static const char* _S_atoms; + + // Construct and return valid pattern consisting of some combination of: + // space none symbol sign value + _GLIBCXX_CONST static pattern + _S_construct_pattern(char __precedes, char __space, char __posn) throw (); + }; + + template + struct __moneypunct_cache : public locale::facet + { + const char* _M_grouping; + size_t _M_grouping_size; + bool _M_use_grouping; + _CharT _M_decimal_point; + _CharT _M_thousands_sep; + const _CharT* _M_curr_symbol; + size_t _M_curr_symbol_size; + const _CharT* _M_positive_sign; + size_t _M_positive_sign_size; + const _CharT* _M_negative_sign; + size_t _M_negative_sign_size; + int _M_frac_digits; + money_base::pattern _M_pos_format; + money_base::pattern _M_neg_format; + + // A list of valid numeric literals for input and output: in the standard + // "C" locale, this is "-0123456789". This array contains the chars after + // having been passed through the current locale's ctype<_CharT>.widen(). + _CharT _M_atoms[money_base::_S_end]; + + bool _M_allocated; + + __moneypunct_cache(size_t __refs = 0) : facet(__refs), + _M_grouping(0), _M_grouping_size(0), _M_use_grouping(false), + _M_decimal_point(_CharT()), _M_thousands_sep(_CharT()), + _M_curr_symbol(0), _M_curr_symbol_size(0), + _M_positive_sign(0), _M_positive_sign_size(0), + _M_negative_sign(0), _M_negative_sign_size(0), + _M_frac_digits(0), + _M_pos_format(money_base::pattern()), + _M_neg_format(money_base::pattern()), _M_allocated(false) + { } + + ~__moneypunct_cache(); + + void + _M_cache(const locale& __loc); + + private: + __moneypunct_cache& + operator=(const __moneypunct_cache&); + + explicit + __moneypunct_cache(const __moneypunct_cache&); + }; + + template + __moneypunct_cache<_CharT, _Intl>::~__moneypunct_cache() + { + if (_M_allocated) + { + delete [] _M_grouping; + delete [] _M_curr_symbol; + delete [] _M_positive_sign; + delete [] _M_negative_sign; + } + } + + /** + * @brief Primary class template moneypunct. + * @ingroup locales + * + * This facet encapsulates the punctuation, grouping and other formatting + * features of money amount string representations. + */ + template + class moneypunct : public locale::facet, public money_base + { + public: + // Types: + //@{ + /// Public typedefs + typedef _CharT char_type; + typedef basic_string<_CharT> string_type; + //@} + typedef __moneypunct_cache<_CharT, _Intl> __cache_type; + + private: + __cache_type* _M_data; + + public: + /// This value is provided by the standard, but no reason for its + /// existence. + static const bool intl = _Intl; + /// Numpunct facet id. + static locale::id id; + + /** + * @brief Constructor performs initialization. + * + * This is the constructor provided by the standard. + * + * @param __refs Passed to the base facet class. + */ + explicit + moneypunct(size_t __refs = 0) + : facet(__refs), _M_data(0) + { _M_initialize_moneypunct(); } + + /** + * @brief Constructor performs initialization. + * + * This is an internal constructor. + * + * @param __cache Cache for optimization. + * @param __refs Passed to the base facet class. + */ + explicit + moneypunct(__cache_type* __cache, size_t __refs = 0) + : facet(__refs), _M_data(__cache) + { _M_initialize_moneypunct(); } + + /** + * @brief Internal constructor. Not for general use. + * + * This is a constructor for use by the library itself to set up new + * locales. + * + * @param __cloc The C locale. + * @param __s The name of a locale. + * @param __refs Passed to the base facet class. + */ + explicit + moneypunct(__c_locale __cloc, const char* __s, size_t __refs = 0) + : facet(__refs), _M_data(0) + { _M_initialize_moneypunct(__cloc, __s); } + + /** + * @brief Return decimal point character. + * + * This function returns a char_type to use as a decimal point. It + * does so by returning returning + * moneypunct::do_decimal_point(). + * + * @return @a char_type representing a decimal point. + */ + char_type + decimal_point() const + { return this->do_decimal_point(); } + + /** + * @brief Return thousands separator character. + * + * This function returns a char_type to use as a thousands + * separator. It does so by returning returning + * moneypunct::do_thousands_sep(). + * + * @return char_type representing a thousands separator. + */ + char_type + thousands_sep() const + { return this->do_thousands_sep(); } + + /** + * @brief Return grouping specification. + * + * This function returns a string representing groupings for the + * integer part of an amount. Groupings indicate where thousands + * separators should be inserted. + * + * Each char in the return string is interpret as an integer rather + * than a character. These numbers represent the number of digits in a + * group. The first char in the string represents the number of digits + * in the least significant group. If a char is negative, it indicates + * an unlimited number of digits for the group. If more chars from the + * string are required to group a number, the last char is used + * repeatedly. + * + * For example, if the grouping() returns \003\002 + * and is applied to the number 123456789, this corresponds to + * 12,34,56,789. Note that if the string was 32, this would + * put more than 50 digits into the least significant group if + * the character set is ASCII. + * + * The string is returned by calling + * moneypunct::do_grouping(). + * + * @return string representing grouping specification. + */ + string + grouping() const + { return this->do_grouping(); } + + /** + * @brief Return currency symbol string. + * + * This function returns a string_type to use as a currency symbol. It + * does so by returning returning + * moneypunct::do_curr_symbol(). + * + * @return @a string_type representing a currency symbol. + */ + string_type + curr_symbol() const + { return this->do_curr_symbol(); } + + /** + * @brief Return positive sign string. + * + * This function returns a string_type to use as a sign for positive + * amounts. It does so by returning returning + * moneypunct::do_positive_sign(). + * + * If the return value contains more than one character, the first + * character appears in the position indicated by pos_format() and the + * remainder appear at the end of the formatted string. + * + * @return @a string_type representing a positive sign. + */ + string_type + positive_sign() const + { return this->do_positive_sign(); } + + /** + * @brief Return negative sign string. + * + * This function returns a string_type to use as a sign for negative + * amounts. It does so by returning returning + * moneypunct::do_negative_sign(). + * + * If the return value contains more than one character, the first + * character appears in the position indicated by neg_format() and the + * remainder appear at the end of the formatted string. + * + * @return @a string_type representing a negative sign. + */ + string_type + negative_sign() const + { return this->do_negative_sign(); } + + /** + * @brief Return number of digits in fraction. + * + * This function returns the exact number of digits that make up the + * fractional part of a money amount. It does so by returning + * returning moneypunct::do_frac_digits(). + * + * The fractional part of a money amount is optional. But if it is + * present, there must be frac_digits() digits. + * + * @return Number of digits in amount fraction. + */ + int + frac_digits() const + { return this->do_frac_digits(); } + + //@{ + /** + * @brief Return pattern for money values. + * + * This function returns a pattern describing the formatting of a + * positive or negative valued money amount. It does so by returning + * returning moneypunct::do_pos_format() or + * moneypunct::do_neg_format(). + * + * The pattern has 4 fields describing the ordering of symbol, sign, + * value, and none or space. There must be one of each in the pattern. + * The none and space enums may not appear in the first field and space + * may not appear in the final field. + * + * The parts of a money string must appear in the order indicated by + * the fields of the pattern. The symbol field indicates that the + * value of curr_symbol() may be present. The sign field indicates + * that the value of positive_sign() or negative_sign() must be + * present. The value field indicates that the absolute value of the + * money amount is present. none indicates 0 or more whitespace + * characters, except at the end, where it permits no whitespace. + * space indicates that 1 or more whitespace characters must be + * present. + * + * For example, for the US locale and pos_format() pattern + * {symbol,sign,value,none}, curr_symbol() == '$' + * positive_sign() == '+', and value 10.01, and + * options set to force the symbol, the corresponding string is + * $+10.01. + * + * @return Pattern for money values. + */ + pattern + pos_format() const + { return this->do_pos_format(); } + + pattern + neg_format() const + { return this->do_neg_format(); } + //@} + + protected: + /// Destructor. + virtual + ~moneypunct(); + + /** + * @brief Return decimal point character. + * + * Returns a char_type to use as a decimal point. This function is a + * hook for derived classes to change the value returned. + * + * @return @a char_type representing a decimal point. + */ + virtual char_type + do_decimal_point() const + { return _M_data->_M_decimal_point; } + + /** + * @brief Return thousands separator character. + * + * Returns a char_type to use as a thousands separator. This function + * is a hook for derived classes to change the value returned. + * + * @return @a char_type representing a thousands separator. + */ + virtual char_type + do_thousands_sep() const + { return _M_data->_M_thousands_sep; } + + /** + * @brief Return grouping specification. + * + * Returns a string representing groupings for the integer part of a + * number. This function is a hook for derived classes to change the + * value returned. @see grouping() for details. + * + * @return String representing grouping specification. + */ + virtual string + do_grouping() const + { return _M_data->_M_grouping; } + + /** + * @brief Return currency symbol string. + * + * This function returns a string_type to use as a currency symbol. + * This function is a hook for derived classes to change the value + * returned. @see curr_symbol() for details. + * + * @return @a string_type representing a currency symbol. + */ + virtual string_type + do_curr_symbol() const + { return _M_data->_M_curr_symbol; } + + /** + * @brief Return positive sign string. + * + * This function returns a string_type to use as a sign for positive + * amounts. This function is a hook for derived classes to change the + * value returned. @see positive_sign() for details. + * + * @return @a string_type representing a positive sign. + */ + virtual string_type + do_positive_sign() const + { return _M_data->_M_positive_sign; } + + /** + * @brief Return negative sign string. + * + * This function returns a string_type to use as a sign for negative + * amounts. This function is a hook for derived classes to change the + * value returned. @see negative_sign() for details. + * + * @return @a string_type representing a negative sign. + */ + virtual string_type + do_negative_sign() const + { return _M_data->_M_negative_sign; } + + /** + * @brief Return number of digits in fraction. + * + * This function returns the exact number of digits that make up the + * fractional part of a money amount. This function is a hook for + * derived classes to change the value returned. @see frac_digits() + * for details. + * + * @return Number of digits in amount fraction. + */ + virtual int + do_frac_digits() const + { return _M_data->_M_frac_digits; } + + /** + * @brief Return pattern for money values. + * + * This function returns a pattern describing the formatting of a + * positive valued money amount. This function is a hook for derived + * classes to change the value returned. @see pos_format() for + * details. + * + * @return Pattern for money values. + */ + virtual pattern + do_pos_format() const + { return _M_data->_M_pos_format; } + + /** + * @brief Return pattern for money values. + * + * This function returns a pattern describing the formatting of a + * negative valued money amount. This function is a hook for derived + * classes to change the value returned. @see neg_format() for + * details. + * + * @return Pattern for money values. + */ + virtual pattern + do_neg_format() const + { return _M_data->_M_neg_format; } + + // For use at construction time only. + void + _M_initialize_moneypunct(__c_locale __cloc = 0, + const char* __name = 0); + }; + + template + locale::id moneypunct<_CharT, _Intl>::id; + + template + const bool moneypunct<_CharT, _Intl>::intl; + + template<> + moneypunct::~moneypunct(); + + template<> + moneypunct::~moneypunct(); + + template<> + void + moneypunct::_M_initialize_moneypunct(__c_locale, const char*); + + template<> + void + moneypunct::_M_initialize_moneypunct(__c_locale, const char*); + +#ifdef _GLIBCXX_USE_WCHAR_T + template<> + moneypunct::~moneypunct(); + + template<> + moneypunct::~moneypunct(); + + template<> + void + moneypunct::_M_initialize_moneypunct(__c_locale, + const char*); + + template<> + void + moneypunct::_M_initialize_moneypunct(__c_locale, + const char*); +#endif + + /// class moneypunct_byname [22.2.6.4]. + template + class moneypunct_byname : public moneypunct<_CharT, _Intl> + { + public: + typedef _CharT char_type; + typedef basic_string<_CharT> string_type; + + static const bool intl = _Intl; + + explicit + moneypunct_byname(const char* __s, size_t __refs = 0) + : moneypunct<_CharT, _Intl>(__refs) + { + if (__builtin_strcmp(__s, "C") != 0 + && __builtin_strcmp(__s, "POSIX") != 0) + { + __c_locale __tmp; + this->_S_create_c_locale(__tmp, __s); + this->_M_initialize_moneypunct(__tmp); + this->_S_destroy_c_locale(__tmp); + } + } + + protected: + virtual + ~moneypunct_byname() { } + }; + + template + const bool moneypunct_byname<_CharT, _Intl>::intl; + +_GLIBCXX_BEGIN_NAMESPACE_LDBL + + /** + * @brief Primary class template money_get. + * @ingroup locales + * + * This facet encapsulates the code to parse and return a monetary + * amount from a string. + * + * The money_get template uses protected virtual functions to + * provide the actual results. The public accessors forward the + * call to the virtual functions. These virtual functions are + * hooks for developers to implement the behavior they require from + * the money_get facet. + */ + template + class money_get : public locale::facet + { + public: + // Types: + //@{ + /// Public typedefs + typedef _CharT char_type; + typedef _InIter iter_type; + typedef basic_string<_CharT> string_type; + //@} + + /// Numpunct facet id. + static locale::id id; + + /** + * @brief Constructor performs initialization. + * + * This is the constructor provided by the standard. + * + * @param __refs Passed to the base facet class. + */ + explicit + money_get(size_t __refs = 0) : facet(__refs) { } + + /** + * @brief Read and parse a monetary value. + * + * This function reads characters from @a __s, interprets them as a + * monetary value according to moneypunct and ctype facets retrieved + * from io.getloc(), and returns the result in @a units as an integral + * value moneypunct::frac_digits() * the actual amount. For example, + * the string $10.01 in a US locale would store 1001 in @a units. + * + * Any characters not part of a valid money amount are not consumed. + * + * If a money value cannot be parsed from the input stream, sets + * err=(err|io.failbit). If the stream is consumed before finishing + * parsing, sets err=(err|io.failbit|io.eofbit). @a units is + * unchanged if parsing fails. + * + * This function works by returning the result of do_get(). + * + * @param __s Start of characters to parse. + * @param __end End of characters to parse. + * @param __intl Parameter to use_facet >. + * @param __io Source of facets and io state. + * @param __err Error field to set if parsing fails. + * @param __units Place to store result of parsing. + * @return Iterator referencing first character beyond valid money + * amount. + */ + iter_type + get(iter_type __s, iter_type __end, bool __intl, ios_base& __io, + ios_base::iostate& __err, long double& __units) const + { return this->do_get(__s, __end, __intl, __io, __err, __units); } + + /** + * @brief Read and parse a monetary value. + * + * This function reads characters from @a __s, interprets them as + * a monetary value according to moneypunct and ctype facets + * retrieved from io.getloc(), and returns the result in @a + * digits. For example, the string $10.01 in a US locale would + * store 1001 in @a digits. + * + * Any characters not part of a valid money amount are not consumed. + * + * If a money value cannot be parsed from the input stream, sets + * err=(err|io.failbit). If the stream is consumed before finishing + * parsing, sets err=(err|io.failbit|io.eofbit). + * + * This function works by returning the result of do_get(). + * + * @param __s Start of characters to parse. + * @param __end End of characters to parse. + * @param __intl Parameter to use_facet >. + * @param __io Source of facets and io state. + * @param __err Error field to set if parsing fails. + * @param __digits Place to store result of parsing. + * @return Iterator referencing first character beyond valid money + * amount. + */ + iter_type + get(iter_type __s, iter_type __end, bool __intl, ios_base& __io, + ios_base::iostate& __err, string_type& __digits) const + { return this->do_get(__s, __end, __intl, __io, __err, __digits); } + + protected: + /// Destructor. + virtual + ~money_get() { } + + /** + * @brief Read and parse a monetary value. + * + * This function reads and parses characters representing a monetary + * value. This function is a hook for derived classes to change the + * value returned. @see get() for details. + */ + // XXX GLIBCXX_ABI Deprecated +#if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__ + virtual iter_type + __do_get(iter_type __s, iter_type __end, bool __intl, ios_base& __io, + ios_base::iostate& __err, double& __units) const; +#else + virtual iter_type + do_get(iter_type __s, iter_type __end, bool __intl, ios_base& __io, + ios_base::iostate& __err, long double& __units) const; +#endif + + /** + * @brief Read and parse a monetary value. + * + * This function reads and parses characters representing a monetary + * value. This function is a hook for derived classes to change the + * value returned. @see get() for details. + */ + virtual iter_type + do_get(iter_type __s, iter_type __end, bool __intl, ios_base& __io, + ios_base::iostate& __err, string_type& __digits) const; + + // XXX GLIBCXX_ABI Deprecated +#if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__ + virtual iter_type + do_get(iter_type __s, iter_type __end, bool __intl, ios_base& __io, + ios_base::iostate& __err, long double& __units) const; +#endif + + template + iter_type + _M_extract(iter_type __s, iter_type __end, ios_base& __io, + ios_base::iostate& __err, string& __digits) const; + }; + + template + locale::id money_get<_CharT, _InIter>::id; + + /** + * @brief Primary class template money_put. + * @ingroup locales + * + * This facet encapsulates the code to format and output a monetary + * amount. + * + * The money_put template uses protected virtual functions to + * provide the actual results. The public accessors forward the + * call to the virtual functions. These virtual functions are + * hooks for developers to implement the behavior they require from + * the money_put facet. + */ + template + class money_put : public locale::facet + { + public: + //@{ + /// Public typedefs + typedef _CharT char_type; + typedef _OutIter iter_type; + typedef basic_string<_CharT> string_type; + //@} + + /// Numpunct facet id. + static locale::id id; + + /** + * @brief Constructor performs initialization. + * + * This is the constructor provided by the standard. + * + * @param __refs Passed to the base facet class. + */ + explicit + money_put(size_t __refs = 0) : facet(__refs) { } + + /** + * @brief Format and output a monetary value. + * + * This function formats @a units as a monetary value according to + * moneypunct and ctype facets retrieved from io.getloc(), and writes + * the resulting characters to @a __s. For example, the value 1001 in a + * US locale would write $10.01 to @a __s. + * + * This function works by returning the result of do_put(). + * + * @param __s The stream to write to. + * @param __intl Parameter to use_facet >. + * @param __io Source of facets and io state. + * @param __fill char_type to use for padding. + * @param __units Place to store result of parsing. + * @return Iterator after writing. + */ + iter_type + put(iter_type __s, bool __intl, ios_base& __io, + char_type __fill, long double __units) const + { return this->do_put(__s, __intl, __io, __fill, __units); } + + /** + * @brief Format and output a monetary value. + * + * This function formats @a digits as a monetary value + * according to moneypunct and ctype facets retrieved from + * io.getloc(), and writes the resulting characters to @a __s. + * For example, the string 1001 in a US locale + * would write $10.01 to @a __s. + * + * This function works by returning the result of do_put(). + * + * @param __s The stream to write to. + * @param __intl Parameter to use_facet >. + * @param __io Source of facets and io state. + * @param __fill char_type to use for padding. + * @param __digits Place to store result of parsing. + * @return Iterator after writing. + */ + iter_type + put(iter_type __s, bool __intl, ios_base& __io, + char_type __fill, const string_type& __digits) const + { return this->do_put(__s, __intl, __io, __fill, __digits); } + + protected: + /// Destructor. + virtual + ~money_put() { } + + /** + * @brief Format and output a monetary value. + * + * This function formats @a units as a monetary value according to + * moneypunct and ctype facets retrieved from io.getloc(), and writes + * the resulting characters to @a __s. For example, the value 1001 in a + * US locale would write $10.01 to @a __s. + * + * This function is a hook for derived classes to change the value + * returned. @see put(). + * + * @param __s The stream to write to. + * @param __intl Parameter to use_facet >. + * @param __io Source of facets and io state. + * @param __fill char_type to use for padding. + * @param __units Place to store result of parsing. + * @return Iterator after writing. + */ + // XXX GLIBCXX_ABI Deprecated +#if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__ + virtual iter_type + __do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill, + double __units) const; +#else + virtual iter_type + do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill, + long double __units) const; +#endif + + /** + * @brief Format and output a monetary value. + * + * This function formats @a digits as a monetary value + * according to moneypunct and ctype facets retrieved from + * io.getloc(), and writes the resulting characters to @a __s. + * For example, the string 1001 in a US locale + * would write $10.01 to @a __s. + * + * This function is a hook for derived classes to change the value + * returned. @see put(). + * + * @param __s The stream to write to. + * @param __intl Parameter to use_facet >. + * @param __io Source of facets and io state. + * @param __fill char_type to use for padding. + * @param __digits Place to store result of parsing. + * @return Iterator after writing. + */ + virtual iter_type + do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill, + const string_type& __digits) const; + + // XXX GLIBCXX_ABI Deprecated +#if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__ + virtual iter_type + do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill, + long double __units) const; +#endif + + template + iter_type + _M_insert(iter_type __s, ios_base& __io, char_type __fill, + const string_type& __digits) const; + }; + + template + locale::id money_put<_CharT, _OutIter>::id; + +_GLIBCXX_END_NAMESPACE_LDBL + + /** + * @brief Messages facet base class providing catalog typedef. + * @ingroup locales + */ + struct messages_base + { + typedef int catalog; + }; + + /** + * @brief Primary class template messages. + * @ingroup locales + * + * This facet encapsulates the code to retrieve messages from + * message catalogs. The only thing defined by the standard for this facet + * is the interface. All underlying functionality is + * implementation-defined. + * + * This library currently implements 3 versions of the message facet. The + * first version (gnu) is a wrapper around gettext, provided by libintl. + * The second version (ieee) is a wrapper around catgets. The final + * version (default) does no actual translation. These implementations are + * only provided for char and wchar_t instantiations. + * + * The messages template uses protected virtual functions to + * provide the actual results. The public accessors forward the + * call to the virtual functions. These virtual functions are + * hooks for developers to implement the behavior they require from + * the messages facet. + */ + template + class messages : public locale::facet, public messages_base + { + public: + // Types: + //@{ + /// Public typedefs + typedef _CharT char_type; + typedef basic_string<_CharT> string_type; + //@} + + protected: + // Underlying "C" library locale information saved from + // initialization, needed by messages_byname as well. + __c_locale _M_c_locale_messages; + const char* _M_name_messages; + + public: + /// Numpunct facet id. + static locale::id id; + + /** + * @brief Constructor performs initialization. + * + * This is the constructor provided by the standard. + * + * @param __refs Passed to the base facet class. + */ + explicit + messages(size_t __refs = 0); + + // Non-standard. + /** + * @brief Internal constructor. Not for general use. + * + * This is a constructor for use by the library itself to set up new + * locales. + * + * @param __cloc The C locale. + * @param __s The name of a locale. + * @param __refs Refcount to pass to the base class. + */ + explicit + messages(__c_locale __cloc, const char* __s, size_t __refs = 0); + + /* + * @brief Open a message catalog. + * + * This function opens and returns a handle to a message catalog by + * returning do_open(__s, __loc). + * + * @param __s The catalog to open. + * @param __loc Locale to use for character set conversions. + * @return Handle to the catalog or value < 0 if open fails. + */ + catalog + open(const basic_string& __s, const locale& __loc) const + { return this->do_open(__s, __loc); } + + // Non-standard and unorthodox, yet effective. + /* + * @brief Open a message catalog. + * + * This non-standard function opens and returns a handle to a message + * catalog by returning do_open(s, loc). The third argument provides a + * message catalog root directory for gnu gettext and is ignored + * otherwise. + * + * @param __s The catalog to open. + * @param __loc Locale to use for character set conversions. + * @param __dir Message catalog root directory. + * @return Handle to the catalog or value < 0 if open fails. + */ + catalog + open(const basic_string&, const locale&, const char*) const; + + /* + * @brief Look up a string in a message catalog. + * + * This function retrieves and returns a message from a catalog by + * returning do_get(c, set, msgid, s). + * + * For gnu, @a __set and @a msgid are ignored. Returns gettext(s). + * For default, returns s. For ieee, returns catgets(c,set,msgid,s). + * + * @param __c The catalog to access. + * @param __set Implementation-defined. + * @param __msgid Implementation-defined. + * @param __s Default return value if retrieval fails. + * @return Retrieved message or @a __s if get fails. + */ + string_type + get(catalog __c, int __set, int __msgid, const string_type& __s) const + { return this->do_get(__c, __set, __msgid, __s); } + + /* + * @brief Close a message catalog. + * + * Closes catalog @a c by calling do_close(c). + * + * @param __c The catalog to close. + */ + void + close(catalog __c) const + { return this->do_close(__c); } + + protected: + /// Destructor. + virtual + ~messages(); + + /* + * @brief Open a message catalog. + * + * This function opens and returns a handle to a message catalog in an + * implementation-defined manner. This function is a hook for derived + * classes to change the value returned. + * + * @param __s The catalog to open. + * @param __loc Locale to use for character set conversions. + * @return Handle to the opened catalog, value < 0 if open failed. + */ + virtual catalog + do_open(const basic_string&, const locale&) const; + + /* + * @brief Look up a string in a message catalog. + * + * This function retrieves and returns a message from a catalog in an + * implementation-defined manner. This function is a hook for derived + * classes to change the value returned. + * + * For gnu, @a __set and @a __msgid are ignored. Returns gettext(s). + * For default, returns s. For ieee, returns catgets(c,set,msgid,s). + * + * @param __c The catalog to access. + * @param __set Implementation-defined. + * @param __msgid Implementation-defined. + * @param __s Default return value if retrieval fails. + * @return Retrieved message or @a __s if get fails. + */ + virtual string_type + do_get(catalog, int, int, const string_type& __dfault) const; + + /* + * @brief Close a message catalog. + * + * @param __c The catalog to close. + */ + virtual void + do_close(catalog) const; + + // Returns a locale and codeset-converted string, given a char* message. + char* + _M_convert_to_char(const string_type& __msg) const + { + // XXX + return reinterpret_cast(const_cast<_CharT*>(__msg.c_str())); + } + + // Returns a locale and codeset-converted string, given a char* message. + string_type + _M_convert_from_char(char*) const + { + // XXX + return string_type(); + } + }; + + template + locale::id messages<_CharT>::id; + + /// Specializations for required instantiations. + template<> + string + messages::do_get(catalog, int, int, const string&) const; + +#ifdef _GLIBCXX_USE_WCHAR_T + template<> + wstring + messages::do_get(catalog, int, int, const wstring&) const; +#endif + + /// class messages_byname [22.2.7.2]. + template + class messages_byname : public messages<_CharT> + { + public: + typedef _CharT char_type; + typedef basic_string<_CharT> string_type; + + explicit + messages_byname(const char* __s, size_t __refs = 0); + + protected: + virtual + ~messages_byname() + { } + }; + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +// Include host and configuration specific messages functions. +#include + +// 22.2.1.5 Template class codecvt +#include + +#include + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/locale_facets_nonio.tcc b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/locale_facets_nonio.tcc new file mode 100755 index 0000000..41d944d --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/locale_facets_nonio.tcc @@ -0,0 +1,1373 @@ +// Locale support -*- C++ -*- + +// Copyright (C) 2007-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file bits/locale_facets_nonio.tcc + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{locale} + */ + +#ifndef _LOCALE_FACETS_NONIO_TCC +#define _LOCALE_FACETS_NONIO_TCC 1 + +#pragma GCC system_header + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + template + struct __use_cache<__moneypunct_cache<_CharT, _Intl> > + { + const __moneypunct_cache<_CharT, _Intl>* + operator() (const locale& __loc) const + { + const size_t __i = moneypunct<_CharT, _Intl>::id._M_id(); + const locale::facet** __caches = __loc._M_impl->_M_caches; + if (!__caches[__i]) + { + __moneypunct_cache<_CharT, _Intl>* __tmp = 0; + __try + { + __tmp = new __moneypunct_cache<_CharT, _Intl>; + __tmp->_M_cache(__loc); + } + __catch(...) + { + delete __tmp; + __throw_exception_again; + } + __loc._M_impl->_M_install_cache(__tmp, __i); + } + return static_cast< + const __moneypunct_cache<_CharT, _Intl>*>(__caches[__i]); + } + }; + + template + void + __moneypunct_cache<_CharT, _Intl>::_M_cache(const locale& __loc) + { + _M_allocated = true; + + const moneypunct<_CharT, _Intl>& __mp = + use_facet >(__loc); + + _M_decimal_point = __mp.decimal_point(); + _M_thousands_sep = __mp.thousands_sep(); + _M_frac_digits = __mp.frac_digits(); + + char* __grouping = 0; + _CharT* __curr_symbol = 0; + _CharT* __positive_sign = 0; + _CharT* __negative_sign = 0; + __try + { + _M_grouping_size = __mp.grouping().size(); + __grouping = new char[_M_grouping_size]; + __mp.grouping().copy(__grouping, _M_grouping_size); + _M_grouping = __grouping; + _M_use_grouping = (_M_grouping_size + && static_cast(_M_grouping[0]) > 0 + && (_M_grouping[0] + != __gnu_cxx::__numeric_traits::__max)); + + _M_curr_symbol_size = __mp.curr_symbol().size(); + __curr_symbol = new _CharT[_M_curr_symbol_size]; + __mp.curr_symbol().copy(__curr_symbol, _M_curr_symbol_size); + _M_curr_symbol = __curr_symbol; + + _M_positive_sign_size = __mp.positive_sign().size(); + __positive_sign = new _CharT[_M_positive_sign_size]; + __mp.positive_sign().copy(__positive_sign, _M_positive_sign_size); + _M_positive_sign = __positive_sign; + + _M_negative_sign_size = __mp.negative_sign().size(); + __negative_sign = new _CharT[_M_negative_sign_size]; + __mp.negative_sign().copy(__negative_sign, _M_negative_sign_size); + _M_negative_sign = __negative_sign; + + _M_pos_format = __mp.pos_format(); + _M_neg_format = __mp.neg_format(); + + const ctype<_CharT>& __ct = use_facet >(__loc); + __ct.widen(money_base::_S_atoms, + money_base::_S_atoms + money_base::_S_end, _M_atoms); + } + __catch(...) + { + delete [] __grouping; + delete [] __curr_symbol; + delete [] __positive_sign; + delete [] __negative_sign; + __throw_exception_again; + } + } + +_GLIBCXX_BEGIN_NAMESPACE_LDBL + + template + template + _InIter + money_get<_CharT, _InIter>:: + _M_extract(iter_type __beg, iter_type __end, ios_base& __io, + ios_base::iostate& __err, string& __units) const + { + typedef char_traits<_CharT> __traits_type; + typedef typename string_type::size_type size_type; + typedef money_base::part part; + typedef __moneypunct_cache<_CharT, _Intl> __cache_type; + + const locale& __loc = __io._M_getloc(); + const ctype<_CharT>& __ctype = use_facet >(__loc); + + __use_cache<__cache_type> __uc; + const __cache_type* __lc = __uc(__loc); + const char_type* __lit = __lc->_M_atoms; + + // Deduced sign. + bool __negative = false; + // Sign size. + size_type __sign_size = 0; + // True if sign is mandatory. + const bool __mandatory_sign = (__lc->_M_positive_sign_size + && __lc->_M_negative_sign_size); + // String of grouping info from thousands_sep plucked from __units. + string __grouping_tmp; + if (__lc->_M_use_grouping) + __grouping_tmp.reserve(32); + // Last position before the decimal point. + int __last_pos = 0; + // Separator positions, then, possibly, fractional digits. + int __n = 0; + // If input iterator is in a valid state. + bool __testvalid = true; + // Flag marking when a decimal point is found. + bool __testdecfound = false; + + // The tentative returned string is stored here. + string __res; + __res.reserve(32); + + const char_type* __lit_zero = __lit + money_base::_S_zero; + const money_base::pattern __p = __lc->_M_neg_format; + for (int __i = 0; __i < 4 && __testvalid; ++__i) + { + const part __which = static_cast(__p.field[__i]); + switch (__which) + { + case money_base::symbol: + // According to 22.2.6.1.2, p2, symbol is required + // if (__io.flags() & ios_base::showbase), otherwise + // is optional and consumed only if other characters + // are needed to complete the format. + if (__io.flags() & ios_base::showbase || __sign_size > 1 + || __i == 0 + || (__i == 1 && (__mandatory_sign + || (static_cast(__p.field[0]) + == money_base::sign) + || (static_cast(__p.field[2]) + == money_base::space))) + || (__i == 2 && ((static_cast(__p.field[3]) + == money_base::value) + || (__mandatory_sign + && (static_cast(__p.field[3]) + == money_base::sign))))) + { + const size_type __len = __lc->_M_curr_symbol_size; + size_type __j = 0; + for (; __beg != __end && __j < __len + && *__beg == __lc->_M_curr_symbol[__j]; + ++__beg, ++__j); + if (__j != __len + && (__j || __io.flags() & ios_base::showbase)) + __testvalid = false; + } + break; + case money_base::sign: + // Sign might not exist, or be more than one character long. + if (__lc->_M_positive_sign_size && __beg != __end + && *__beg == __lc->_M_positive_sign[0]) + { + __sign_size = __lc->_M_positive_sign_size; + ++__beg; + } + else if (__lc->_M_negative_sign_size && __beg != __end + && *__beg == __lc->_M_negative_sign[0]) + { + __negative = true; + __sign_size = __lc->_M_negative_sign_size; + ++__beg; + } + else if (__lc->_M_positive_sign_size + && !__lc->_M_negative_sign_size) + // "... if no sign is detected, the result is given the sign + // that corresponds to the source of the empty string" + __negative = true; + else if (__mandatory_sign) + __testvalid = false; + break; + case money_base::value: + // Extract digits, remove and stash away the + // grouping of found thousands separators. + for (; __beg != __end; ++__beg) + { + const char_type __c = *__beg; + const char_type* __q = __traits_type::find(__lit_zero, + 10, __c); + if (__q != 0) + { + __res += money_base::_S_atoms[__q - __lit]; + ++__n; + } + else if (__c == __lc->_M_decimal_point + && !__testdecfound) + { + if (__lc->_M_frac_digits <= 0) + break; + + __last_pos = __n; + __n = 0; + __testdecfound = true; + } + else if (__lc->_M_use_grouping + && __c == __lc->_M_thousands_sep + && !__testdecfound) + { + if (__n) + { + // Mark position for later analysis. + __grouping_tmp += static_cast(__n); + __n = 0; + } + else + { + __testvalid = false; + break; + } + } + else + break; + } + if (__res.empty()) + __testvalid = false; + break; + case money_base::space: + // At least one space is required. + if (__beg != __end && __ctype.is(ctype_base::space, *__beg)) + ++__beg; + else + __testvalid = false; + case money_base::none: + // Only if not at the end of the pattern. + if (__i != 3) + for (; __beg != __end + && __ctype.is(ctype_base::space, *__beg); ++__beg); + break; + } + } + + // Need to get the rest of the sign characters, if they exist. + if (__sign_size > 1 && __testvalid) + { + const char_type* __sign = __negative ? __lc->_M_negative_sign + : __lc->_M_positive_sign; + size_type __i = 1; + for (; __beg != __end && __i < __sign_size + && *__beg == __sign[__i]; ++__beg, ++__i); + + if (__i != __sign_size) + __testvalid = false; + } + + if (__testvalid) + { + // Strip leading zeros. + if (__res.size() > 1) + { + const size_type __first = __res.find_first_not_of('0'); + const bool __only_zeros = __first == string::npos; + if (__first) + __res.erase(0, __only_zeros ? __res.size() - 1 : __first); + } + + // 22.2.6.1.2, p4 + if (__negative && __res[0] != '0') + __res.insert(__res.begin(), '-'); + + // Test for grouping fidelity. + if (__grouping_tmp.size()) + { + // Add the ending grouping. + __grouping_tmp += static_cast(__testdecfound ? __last_pos + : __n); + if (!std::__verify_grouping(__lc->_M_grouping, + __lc->_M_grouping_size, + __grouping_tmp)) + __err |= ios_base::failbit; + } + + // Iff not enough digits were supplied after the decimal-point. + if (__testdecfound && __n != __lc->_M_frac_digits) + __testvalid = false; + } + + // Iff valid sequence is not recognized. + if (!__testvalid) + __err |= ios_base::failbit; + else + __units.swap(__res); + + // Iff no more characters are available. + if (__beg == __end) + __err |= ios_base::eofbit; + return __beg; + } + +#if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__ + template + _InIter + money_get<_CharT, _InIter>:: + __do_get(iter_type __beg, iter_type __end, bool __intl, ios_base& __io, + ios_base::iostate& __err, double& __units) const + { + string __str; + __beg = __intl ? _M_extract(__beg, __end, __io, __err, __str) + : _M_extract(__beg, __end, __io, __err, __str); + std::__convert_to_v(__str.c_str(), __units, __err, _S_get_c_locale()); + return __beg; + } +#endif + + template + _InIter + money_get<_CharT, _InIter>:: + do_get(iter_type __beg, iter_type __end, bool __intl, ios_base& __io, + ios_base::iostate& __err, long double& __units) const + { + string __str; + __beg = __intl ? _M_extract(__beg, __end, __io, __err, __str) + : _M_extract(__beg, __end, __io, __err, __str); + std::__convert_to_v(__str.c_str(), __units, __err, _S_get_c_locale()); + return __beg; + } + + template + _InIter + money_get<_CharT, _InIter>:: + do_get(iter_type __beg, iter_type __end, bool __intl, ios_base& __io, + ios_base::iostate& __err, string_type& __digits) const + { + typedef typename string::size_type size_type; + + const locale& __loc = __io._M_getloc(); + const ctype<_CharT>& __ctype = use_facet >(__loc); + + string __str; + __beg = __intl ? _M_extract(__beg, __end, __io, __err, __str) + : _M_extract(__beg, __end, __io, __err, __str); + const size_type __len = __str.size(); + if (__len) + { + __digits.resize(__len); + __ctype.widen(__str.data(), __str.data() + __len, &__digits[0]); + } + return __beg; + } + + template + template + _OutIter + money_put<_CharT, _OutIter>:: + _M_insert(iter_type __s, ios_base& __io, char_type __fill, + const string_type& __digits) const + { + typedef typename string_type::size_type size_type; + typedef money_base::part part; + typedef __moneypunct_cache<_CharT, _Intl> __cache_type; + + const locale& __loc = __io._M_getloc(); + const ctype<_CharT>& __ctype = use_facet >(__loc); + + __use_cache<__cache_type> __uc; + const __cache_type* __lc = __uc(__loc); + const char_type* __lit = __lc->_M_atoms; + + // Determine if negative or positive formats are to be used, and + // discard leading negative_sign if it is present. + const char_type* __beg = __digits.data(); + + money_base::pattern __p; + const char_type* __sign; + size_type __sign_size; + if (!(*__beg == __lit[money_base::_S_minus])) + { + __p = __lc->_M_pos_format; + __sign = __lc->_M_positive_sign; + __sign_size = __lc->_M_positive_sign_size; + } + else + { + __p = __lc->_M_neg_format; + __sign = __lc->_M_negative_sign; + __sign_size = __lc->_M_negative_sign_size; + if (__digits.size()) + ++__beg; + } + + // Look for valid numbers in the ctype facet within input digits. + size_type __len = __ctype.scan_not(ctype_base::digit, __beg, + __beg + __digits.size()) - __beg; + if (__len) + { + // Assume valid input, and attempt to format. + // Break down input numbers into base components, as follows: + // final_value = grouped units + (decimal point) + (digits) + string_type __value; + __value.reserve(2 * __len); + + // Add thousands separators to non-decimal digits, per + // grouping rules. + long __paddec = __len - __lc->_M_frac_digits; + if (__paddec > 0) + { + if (__lc->_M_frac_digits < 0) + __paddec = __len; + if (__lc->_M_grouping_size) + { + __value.assign(2 * __paddec, char_type()); + _CharT* __vend = + std::__add_grouping(&__value[0], __lc->_M_thousands_sep, + __lc->_M_grouping, + __lc->_M_grouping_size, + __beg, __beg + __paddec); + __value.erase(__vend - &__value[0]); + } + else + __value.assign(__beg, __paddec); + } + + // Deal with decimal point, decimal digits. + if (__lc->_M_frac_digits > 0) + { + __value += __lc->_M_decimal_point; + if (__paddec >= 0) + __value.append(__beg + __paddec, __lc->_M_frac_digits); + else + { + // Have to pad zeros in the decimal position. + __value.append(-__paddec, __lit[money_base::_S_zero]); + __value.append(__beg, __len); + } + } + + // Calculate length of resulting string. + const ios_base::fmtflags __f = __io.flags() + & ios_base::adjustfield; + __len = __value.size() + __sign_size; + __len += ((__io.flags() & ios_base::showbase) + ? __lc->_M_curr_symbol_size : 0); + + string_type __res; + __res.reserve(2 * __len); + + const size_type __width = static_cast(__io.width()); + const bool __testipad = (__f == ios_base::internal + && __len < __width); + // Fit formatted digits into the required pattern. + for (int __i = 0; __i < 4; ++__i) + { + const part __which = static_cast(__p.field[__i]); + switch (__which) + { + case money_base::symbol: + if (__io.flags() & ios_base::showbase) + __res.append(__lc->_M_curr_symbol, + __lc->_M_curr_symbol_size); + break; + case money_base::sign: + // Sign might not exist, or be more than one + // character long. In that case, add in the rest + // below. + if (__sign_size) + __res += __sign[0]; + break; + case money_base::value: + __res += __value; + break; + case money_base::space: + // At least one space is required, but if internal + // formatting is required, an arbitrary number of + // fill spaces will be necessary. + if (__testipad) + __res.append(__width - __len, __fill); + else + __res += __fill; + break; + case money_base::none: + if (__testipad) + __res.append(__width - __len, __fill); + break; + } + } + + // Special case of multi-part sign parts. + if (__sign_size > 1) + __res.append(__sign + 1, __sign_size - 1); + + // Pad, if still necessary. + __len = __res.size(); + if (__width > __len) + { + if (__f == ios_base::left) + // After. + __res.append(__width - __len, __fill); + else + // Before. + __res.insert(0, __width - __len, __fill); + __len = __width; + } + + // Write resulting, fully-formatted string to output iterator. + __s = std::__write(__s, __res.data(), __len); + } + __io.width(0); + return __s; + } + +#if defined _GLIBCXX_LONG_DOUBLE_COMPAT && defined __LONG_DOUBLE_128__ + template + _OutIter + money_put<_CharT, _OutIter>:: + __do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill, + double __units) const + { return this->do_put(__s, __intl, __io, __fill, (long double) __units); } +#endif + + template + _OutIter + money_put<_CharT, _OutIter>:: + do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill, + long double __units) const + { + const locale __loc = __io.getloc(); + const ctype<_CharT>& __ctype = use_facet >(__loc); +#ifdef _GLIBCXX_USE_C99 + // First try a buffer perhaps big enough. + int __cs_size = 64; + char* __cs = static_cast(__builtin_alloca(__cs_size)); + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 328. Bad sprintf format modifier in money_put<>::do_put() + int __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size, + "%.*Lf", 0, __units); + // If the buffer was not large enough, try again with the correct size. + if (__len >= __cs_size) + { + __cs_size = __len + 1; + __cs = static_cast(__builtin_alloca(__cs_size)); + __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size, + "%.*Lf", 0, __units); + } +#else + // max_exponent10 + 1 for the integer part, + 2 for sign and '\0'. + const int __cs_size = + __gnu_cxx::__numeric_traits::__max_exponent10 + 3; + char* __cs = static_cast(__builtin_alloca(__cs_size)); + int __len = std::__convert_from_v(_S_get_c_locale(), __cs, 0, "%.*Lf", + 0, __units); +#endif + string_type __digits(__len, char_type()); + __ctype.widen(__cs, __cs + __len, &__digits[0]); + return __intl ? _M_insert(__s, __io, __fill, __digits) + : _M_insert(__s, __io, __fill, __digits); + } + + template + _OutIter + money_put<_CharT, _OutIter>:: + do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill, + const string_type& __digits) const + { return __intl ? _M_insert(__s, __io, __fill, __digits) + : _M_insert(__s, __io, __fill, __digits); } + +_GLIBCXX_END_NAMESPACE_LDBL + + // NB: Not especially useful. Without an ios_base object or some + // kind of locale reference, we are left clawing at the air where + // the side of the mountain used to be... + template + time_base::dateorder + time_get<_CharT, _InIter>::do_date_order() const + { return time_base::no_order; } + + // Expand a strftime format string and parse it. E.g., do_get_date() may + // pass %m/%d/%Y => extracted characters. + template + _InIter + time_get<_CharT, _InIter>:: + _M_extract_via_format(iter_type __beg, iter_type __end, ios_base& __io, + ios_base::iostate& __err, tm* __tm, + const _CharT* __format) const + { + const locale& __loc = __io._M_getloc(); + const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc); + const ctype<_CharT>& __ctype = use_facet >(__loc); + const size_t __len = char_traits<_CharT>::length(__format); + + ios_base::iostate __tmperr = ios_base::goodbit; + size_t __i = 0; + for (; __beg != __end && __i < __len && !__tmperr; ++__i) + { + if (__ctype.narrow(__format[__i], 0) == '%') + { + // Verify valid formatting code, attempt to extract. + char __c = __ctype.narrow(__format[++__i], 0); + int __mem = 0; + if (__c == 'E' || __c == 'O') + __c = __ctype.narrow(__format[++__i], 0); + switch (__c) + { + const char* __cs; + _CharT __wcs[10]; + case 'a': + // Abbreviated weekday name [tm_wday] + const char_type* __days1[7]; + __tp._M_days_abbreviated(__days1); + __beg = _M_extract_name(__beg, __end, __tm->tm_wday, __days1, + 7, __io, __tmperr); + break; + case 'A': + // Weekday name [tm_wday]. + const char_type* __days2[7]; + __tp._M_days(__days2); + __beg = _M_extract_name(__beg, __end, __tm->tm_wday, __days2, + 7, __io, __tmperr); + break; + case 'h': + case 'b': + // Abbreviated month name [tm_mon] + const char_type* __months1[12]; + __tp._M_months_abbreviated(__months1); + __beg = _M_extract_name(__beg, __end, __tm->tm_mon, + __months1, 12, __io, __tmperr); + break; + case 'B': + // Month name [tm_mon]. + const char_type* __months2[12]; + __tp._M_months(__months2); + __beg = _M_extract_name(__beg, __end, __tm->tm_mon, + __months2, 12, __io, __tmperr); + break; + case 'c': + // Default time and date representation. + const char_type* __dt[2]; + __tp._M_date_time_formats(__dt); + __beg = _M_extract_via_format(__beg, __end, __io, __tmperr, + __tm, __dt[0]); + break; + case 'd': + // Day [01, 31]. [tm_mday] + __beg = _M_extract_num(__beg, __end, __tm->tm_mday, 1, 31, 2, + __io, __tmperr); + break; + case 'e': + // Day [1, 31], with single digits preceded by + // space. [tm_mday] + if (__ctype.is(ctype_base::space, *__beg)) + __beg = _M_extract_num(++__beg, __end, __tm->tm_mday, 1, 9, + 1, __io, __tmperr); + else + __beg = _M_extract_num(__beg, __end, __tm->tm_mday, 10, 31, + 2, __io, __tmperr); + break; + case 'D': + // Equivalent to %m/%d/%y.[tm_mon, tm_mday, tm_year] + __cs = "%m/%d/%y"; + __ctype.widen(__cs, __cs + 9, __wcs); + __beg = _M_extract_via_format(__beg, __end, __io, __tmperr, + __tm, __wcs); + break; + case 'H': + // Hour [00, 23]. [tm_hour] + __beg = _M_extract_num(__beg, __end, __tm->tm_hour, 0, 23, 2, + __io, __tmperr); + break; + case 'I': + // Hour [01, 12]. [tm_hour] + __beg = _M_extract_num(__beg, __end, __tm->tm_hour, 1, 12, 2, + __io, __tmperr); + break; + case 'm': + // Month [01, 12]. [tm_mon] + __beg = _M_extract_num(__beg, __end, __mem, 1, 12, 2, + __io, __tmperr); + if (!__tmperr) + __tm->tm_mon = __mem - 1; + break; + case 'M': + // Minute [00, 59]. [tm_min] + __beg = _M_extract_num(__beg, __end, __tm->tm_min, 0, 59, 2, + __io, __tmperr); + break; + case 'n': + if (__ctype.narrow(*__beg, 0) == '\n') + ++__beg; + else + __tmperr |= ios_base::failbit; + break; + case 'R': + // Equivalent to (%H:%M). + __cs = "%H:%M"; + __ctype.widen(__cs, __cs + 6, __wcs); + __beg = _M_extract_via_format(__beg, __end, __io, __tmperr, + __tm, __wcs); + break; + case 'S': + // Seconds. [tm_sec] + // [00, 60] in C99 (one leap-second), [00, 61] in C89. +#ifdef _GLIBCXX_USE_C99 + __beg = _M_extract_num(__beg, __end, __tm->tm_sec, 0, 60, 2, +#else + __beg = _M_extract_num(__beg, __end, __tm->tm_sec, 0, 61, 2, +#endif + __io, __tmperr); + break; + case 't': + if (__ctype.narrow(*__beg, 0) == '\t') + ++__beg; + else + __tmperr |= ios_base::failbit; + break; + case 'T': + // Equivalent to (%H:%M:%S). + __cs = "%H:%M:%S"; + __ctype.widen(__cs, __cs + 9, __wcs); + __beg = _M_extract_via_format(__beg, __end, __io, __tmperr, + __tm, __wcs); + break; + case 'x': + // Locale's date. + const char_type* __dates[2]; + __tp._M_date_formats(__dates); + __beg = _M_extract_via_format(__beg, __end, __io, __tmperr, + __tm, __dates[0]); + break; + case 'X': + // Locale's time. + const char_type* __times[2]; + __tp._M_time_formats(__times); + __beg = _M_extract_via_format(__beg, __end, __io, __tmperr, + __tm, __times[0]); + break; + case 'y': + case 'C': // C99 + // Two digit year. + case 'Y': + // Year [1900). + // NB: We parse either two digits, implicitly years since + // 1900, or 4 digits, full year. In both cases we can + // reconstruct [tm_year]. See also libstdc++/26701. + __beg = _M_extract_num(__beg, __end, __mem, 0, 9999, 4, + __io, __tmperr); + if (!__tmperr) + __tm->tm_year = __mem < 0 ? __mem + 100 : __mem - 1900; + break; + case 'Z': + // Timezone info. + if (__ctype.is(ctype_base::upper, *__beg)) + { + int __tmp; + __beg = _M_extract_name(__beg, __end, __tmp, + __timepunct_cache<_CharT>::_S_timezones, + 14, __io, __tmperr); + + // GMT requires special effort. + if (__beg != __end && !__tmperr && __tmp == 0 + && (*__beg == __ctype.widen('-') + || *__beg == __ctype.widen('+'))) + { + __beg = _M_extract_num(__beg, __end, __tmp, 0, 23, 2, + __io, __tmperr); + __beg = _M_extract_num(__beg, __end, __tmp, 0, 59, 2, + __io, __tmperr); + } + } + else + __tmperr |= ios_base::failbit; + break; + default: + // Not recognized. + __tmperr |= ios_base::failbit; + } + } + else + { + // Verify format and input match, extract and discard. + if (__format[__i] == *__beg) + ++__beg; + else + __tmperr |= ios_base::failbit; + } + } + + if (__tmperr || __i != __len) + __err |= ios_base::failbit; + + return __beg; + } + + template + _InIter + time_get<_CharT, _InIter>:: + _M_extract_num(iter_type __beg, iter_type __end, int& __member, + int __min, int __max, size_t __len, + ios_base& __io, ios_base::iostate& __err) const + { + const locale& __loc = __io._M_getloc(); + const ctype<_CharT>& __ctype = use_facet >(__loc); + + // As-is works for __len = 1, 2, 4, the values actually used. + int __mult = __len == 2 ? 10 : (__len == 4 ? 1000 : 1); + + ++__min; + size_t __i = 0; + int __value = 0; + for (; __beg != __end && __i < __len; ++__beg, ++__i) + { + const char __c = __ctype.narrow(*__beg, '*'); + if (__c >= '0' && __c <= '9') + { + __value = __value * 10 + (__c - '0'); + const int __valuec = __value * __mult; + if (__valuec > __max || __valuec + __mult < __min) + break; + __mult /= 10; + } + else + break; + } + if (__i == __len) + __member = __value; + // Special encoding for do_get_year, 'y', and 'Y' above. + else if (__len == 4 && __i == 2) + __member = __value - 100; + else + __err |= ios_base::failbit; + + return __beg; + } + + // Assumptions: + // All elements in __names are unique. + template + _InIter + time_get<_CharT, _InIter>:: + _M_extract_name(iter_type __beg, iter_type __end, int& __member, + const _CharT** __names, size_t __indexlen, + ios_base& __io, ios_base::iostate& __err) const + { + typedef char_traits<_CharT> __traits_type; + const locale& __loc = __io._M_getloc(); + const ctype<_CharT>& __ctype = use_facet >(__loc); + + int* __matches = static_cast(__builtin_alloca(sizeof(int) + * __indexlen)); + size_t __nmatches = 0; + size_t __pos = 0; + bool __testvalid = true; + const char_type* __name; + + // Look for initial matches. + // NB: Some of the locale data is in the form of all lowercase + // names, and some is in the form of initially-capitalized + // names. Look for both. + if (__beg != __end) + { + const char_type __c = *__beg; + for (size_t __i1 = 0; __i1 < __indexlen; ++__i1) + if (__c == __names[__i1][0] + || __c == __ctype.toupper(__names[__i1][0])) + __matches[__nmatches++] = __i1; + } + + while (__nmatches > 1) + { + // Find smallest matching string. + size_t __minlen = __traits_type::length(__names[__matches[0]]); + for (size_t __i2 = 1; __i2 < __nmatches; ++__i2) + __minlen = std::min(__minlen, + __traits_type::length(__names[__matches[__i2]])); + ++__beg, ++__pos; + if (__pos < __minlen && __beg != __end) + for (size_t __i3 = 0; __i3 < __nmatches;) + { + __name = __names[__matches[__i3]]; + if (!(__name[__pos] == *__beg)) + __matches[__i3] = __matches[--__nmatches]; + else + ++__i3; + } + else + break; + } + + if (__nmatches == 1) + { + // Make sure found name is completely extracted. + ++__beg, ++__pos; + __name = __names[__matches[0]]; + const size_t __len = __traits_type::length(__name); + while (__pos < __len && __beg != __end && __name[__pos] == *__beg) + ++__beg, ++__pos; + + if (__len == __pos) + __member = __matches[0]; + else + __testvalid = false; + } + else + __testvalid = false; + if (!__testvalid) + __err |= ios_base::failbit; + + return __beg; + } + + template + _InIter + time_get<_CharT, _InIter>:: + _M_extract_wday_or_month(iter_type __beg, iter_type __end, int& __member, + const _CharT** __names, size_t __indexlen, + ios_base& __io, ios_base::iostate& __err) const + { + typedef char_traits<_CharT> __traits_type; + const locale& __loc = __io._M_getloc(); + const ctype<_CharT>& __ctype = use_facet >(__loc); + + int* __matches = static_cast(__builtin_alloca(2 * sizeof(int) + * __indexlen)); + size_t __nmatches = 0; + size_t* __matches_lengths = 0; + size_t __pos = 0; + + if (__beg != __end) + { + const char_type __c = *__beg; + for (size_t __i = 0; __i < 2 * __indexlen; ++__i) + if (__c == __names[__i][0] + || __c == __ctype.toupper(__names[__i][0])) + __matches[__nmatches++] = __i; + } + + if (__nmatches) + { + ++__beg, ++__pos; + + __matches_lengths + = static_cast(__builtin_alloca(sizeof(size_t) + * __nmatches)); + for (size_t __i = 0; __i < __nmatches; ++__i) + __matches_lengths[__i] + = __traits_type::length(__names[__matches[__i]]); + } + + for (; __beg != __end; ++__beg, ++__pos) + { + size_t __nskipped = 0; + const char_type __c = *__beg; + for (size_t __i = 0; __i < __nmatches;) + { + const char_type* __name = __names[__matches[__i]]; + if (__pos >= __matches_lengths[__i]) + ++__nskipped, ++__i; + else if (!(__name[__pos] == __c)) + { + --__nmatches; + __matches[__i] = __matches[__nmatches]; + __matches_lengths[__i] = __matches_lengths[__nmatches]; + } + else + ++__i; + } + if (__nskipped == __nmatches) + break; + } + + if ((__nmatches == 1 && __matches_lengths[0] == __pos) + || (__nmatches == 2 && (__matches_lengths[0] == __pos + || __matches_lengths[1] == __pos))) + __member = (__matches[0] >= __indexlen + ? __matches[0] - __indexlen : __matches[0]); + else + __err |= ios_base::failbit; + + return __beg; + } + + template + _InIter + time_get<_CharT, _InIter>:: + do_get_time(iter_type __beg, iter_type __end, ios_base& __io, + ios_base::iostate& __err, tm* __tm) const + { + const locale& __loc = __io._M_getloc(); + const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc); + const char_type* __times[2]; + __tp._M_time_formats(__times); + __beg = _M_extract_via_format(__beg, __end, __io, __err, + __tm, __times[0]); + if (__beg == __end) + __err |= ios_base::eofbit; + return __beg; + } + + template + _InIter + time_get<_CharT, _InIter>:: + do_get_date(iter_type __beg, iter_type __end, ios_base& __io, + ios_base::iostate& __err, tm* __tm) const + { + const locale& __loc = __io._M_getloc(); + const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc); + const char_type* __dates[2]; + __tp._M_date_formats(__dates); + __beg = _M_extract_via_format(__beg, __end, __io, __err, + __tm, __dates[0]); + if (__beg == __end) + __err |= ios_base::eofbit; + return __beg; + } + + template + _InIter + time_get<_CharT, _InIter>:: + do_get_weekday(iter_type __beg, iter_type __end, ios_base& __io, + ios_base::iostate& __err, tm* __tm) const + { + typedef char_traits<_CharT> __traits_type; + const locale& __loc = __io._M_getloc(); + const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc); + const ctype<_CharT>& __ctype = use_facet >(__loc); + const char_type* __days[14]; + __tp._M_days_abbreviated(__days); + __tp._M_days(__days + 7); + int __tmpwday; + ios_base::iostate __tmperr = ios_base::goodbit; + + __beg = _M_extract_wday_or_month(__beg, __end, __tmpwday, __days, 7, + __io, __tmperr); + if (!__tmperr) + __tm->tm_wday = __tmpwday; + else + __err |= ios_base::failbit; + + if (__beg == __end) + __err |= ios_base::eofbit; + return __beg; + } + + template + _InIter + time_get<_CharT, _InIter>:: + do_get_monthname(iter_type __beg, iter_type __end, + ios_base& __io, ios_base::iostate& __err, tm* __tm) const + { + typedef char_traits<_CharT> __traits_type; + const locale& __loc = __io._M_getloc(); + const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc); + const ctype<_CharT>& __ctype = use_facet >(__loc); + const char_type* __months[24]; + __tp._M_months_abbreviated(__months); + __tp._M_months(__months + 12); + int __tmpmon; + ios_base::iostate __tmperr = ios_base::goodbit; + + __beg = _M_extract_wday_or_month(__beg, __end, __tmpmon, __months, 12, + __io, __tmperr); + if (!__tmperr) + __tm->tm_mon = __tmpmon; + else + __err |= ios_base::failbit; + + if (__beg == __end) + __err |= ios_base::eofbit; + return __beg; + } + + template + _InIter + time_get<_CharT, _InIter>:: + do_get_year(iter_type __beg, iter_type __end, ios_base& __io, + ios_base::iostate& __err, tm* __tm) const + { + const locale& __loc = __io._M_getloc(); + const ctype<_CharT>& __ctype = use_facet >(__loc); + int __tmpyear; + ios_base::iostate __tmperr = ios_base::goodbit; + + __beg = _M_extract_num(__beg, __end, __tmpyear, 0, 9999, 4, + __io, __tmperr); + if (!__tmperr) + __tm->tm_year = __tmpyear < 0 ? __tmpyear + 100 : __tmpyear - 1900; + else + __err |= ios_base::failbit; + + if (__beg == __end) + __err |= ios_base::eofbit; + return __beg; + } + + template + _OutIter + time_put<_CharT, _OutIter>:: + put(iter_type __s, ios_base& __io, char_type __fill, const tm* __tm, + const _CharT* __beg, const _CharT* __end) const + { + const locale& __loc = __io._M_getloc(); + ctype<_CharT> const& __ctype = use_facet >(__loc); + for (; __beg != __end; ++__beg) + if (__ctype.narrow(*__beg, 0) != '%') + { + *__s = *__beg; + ++__s; + } + else if (++__beg != __end) + { + char __format; + char __mod = 0; + const char __c = __ctype.narrow(*__beg, 0); + if (__c != 'E' && __c != 'O') + __format = __c; + else if (++__beg != __end) + { + __mod = __c; + __format = __ctype.narrow(*__beg, 0); + } + else + break; + __s = this->do_put(__s, __io, __fill, __tm, __format, __mod); + } + else + break; + return __s; + } + + template + _OutIter + time_put<_CharT, _OutIter>:: + do_put(iter_type __s, ios_base& __io, char_type, const tm* __tm, + char __format, char __mod) const + { + const locale& __loc = __io._M_getloc(); + ctype<_CharT> const& __ctype = use_facet >(__loc); + __timepunct<_CharT> const& __tp = use_facet<__timepunct<_CharT> >(__loc); + + // NB: This size is arbitrary. Should this be a data member, + // initialized at construction? + const size_t __maxlen = 128; + char_type __res[__maxlen]; + + // NB: In IEE 1003.1-200x, and perhaps other locale models, it + // is possible that the format character will be longer than one + // character. Possibilities include 'E' or 'O' followed by a + // format character: if __mod is not the default argument, assume + // it's a valid modifier. + char_type __fmt[4]; + __fmt[0] = __ctype.widen('%'); + if (!__mod) + { + __fmt[1] = __format; + __fmt[2] = char_type(); + } + else + { + __fmt[1] = __mod; + __fmt[2] = __format; + __fmt[3] = char_type(); + } + + __tp._M_put(__res, __maxlen, __fmt, __tm); + + // Write resulting, fully-formatted string to output iterator. + return std::__write(__s, __res, char_traits::length(__res)); + } + + + // Inhibit implicit instantiations for required instantiations, + // which are defined via explicit instantiations elsewhere. +#if _GLIBCXX_EXTERN_TEMPLATE + extern template class moneypunct; + extern template class moneypunct; + extern template class moneypunct_byname; + extern template class moneypunct_byname; + extern template class _GLIBCXX_NAMESPACE_LDBL money_get; + extern template class _GLIBCXX_NAMESPACE_LDBL money_put; + extern template class __timepunct; + extern template class time_put; + extern template class time_put_byname; + extern template class time_get; + extern template class time_get_byname; + extern template class messages; + extern template class messages_byname; + + extern template + const moneypunct& + use_facet >(const locale&); + + extern template + const moneypunct& + use_facet >(const locale&); + + extern template + const money_put& + use_facet >(const locale&); + + extern template + const money_get& + use_facet >(const locale&); + + extern template + const __timepunct& + use_facet<__timepunct >(const locale&); + + extern template + const time_put& + use_facet >(const locale&); + + extern template + const time_get& + use_facet >(const locale&); + + extern template + const messages& + use_facet >(const locale&); + + extern template + bool + has_facet >(const locale&); + + extern template + bool + has_facet >(const locale&); + + extern template + bool + has_facet >(const locale&); + + extern template + bool + has_facet<__timepunct >(const locale&); + + extern template + bool + has_facet >(const locale&); + + extern template + bool + has_facet >(const locale&); + + extern template + bool + has_facet >(const locale&); + +#ifdef _GLIBCXX_USE_WCHAR_T + extern template class moneypunct; + extern template class moneypunct; + extern template class moneypunct_byname; + extern template class moneypunct_byname; + extern template class _GLIBCXX_NAMESPACE_LDBL money_get; + extern template class _GLIBCXX_NAMESPACE_LDBL money_put; + extern template class __timepunct; + extern template class time_put; + extern template class time_put_byname; + extern template class time_get; + extern template class time_get_byname; + extern template class messages; + extern template class messages_byname; + + extern template + const moneypunct& + use_facet >(const locale&); + + extern template + const moneypunct& + use_facet >(const locale&); + + extern template + const money_put& + use_facet >(const locale&); + + extern template + const money_get& + use_facet >(const locale&); + + extern template + const __timepunct& + use_facet<__timepunct >(const locale&); + + extern template + const time_put& + use_facet >(const locale&); + + extern template + const time_get& + use_facet >(const locale&); + + extern template + const messages& + use_facet >(const locale&); + + extern template + bool + has_facet >(const locale&); + + extern template + bool + has_facet >(const locale&); + + extern template + bool + has_facet >(const locale&); + + extern template + bool + has_facet<__timepunct >(const locale&); + + extern template + bool + has_facet >(const locale&); + + extern template + bool + has_facet >(const locale&); + + extern template + bool + has_facet >(const locale&); +#endif +#endif + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace std + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/localefwd.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/localefwd.h new file mode 100755 index 0000000..f9983c9 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/localefwd.h @@ -0,0 +1,190 @@ +// Forward declarations -*- C++ -*- + +// Copyright (C) 1997-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file bits/localefwd.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{locale} + */ + +// +// ISO C++ 14882: 22.1 Locales +// + +#ifndef _LOCALE_FWD_H +#define _LOCALE_FWD_H 1 + +#pragma GCC system_header + +#include +#include // Defines __c_locale, config-specific include +#include // For ostreambuf_iterator, istreambuf_iterator +#include + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /** + * @defgroup locales Locales + * + * Classes and functions for internationalization and localization. + */ + + // 22.1.1 Locale + class locale; + + template + bool + has_facet(const locale&) throw(); + + template + const _Facet& + use_facet(const locale&); + + // 22.1.3 Convenience interfaces + template + bool + isspace(_CharT, const locale&); + + template + bool + isprint(_CharT, const locale&); + + template + bool + iscntrl(_CharT, const locale&); + + template + bool + isupper(_CharT, const locale&); + + template + bool + islower(_CharT, const locale&); + + template + bool + isalpha(_CharT, const locale&); + + template + bool + isdigit(_CharT, const locale&); + + template + bool + ispunct(_CharT, const locale&); + + template + bool + isxdigit(_CharT, const locale&); + + template + bool + isalnum(_CharT, const locale&); + + template + bool + isgraph(_CharT, const locale&); + + template + _CharT + toupper(_CharT, const locale&); + + template + _CharT + tolower(_CharT, const locale&); + + // 22.2.1 and 22.2.1.3 ctype + class ctype_base; + template + class ctype; + template<> class ctype; +#ifdef _GLIBCXX_USE_WCHAR_T + template<> class ctype; +#endif + template + class ctype_byname; + // NB: Specialized for char and wchar_t in locale_facets.h. + + class codecvt_base; + template + class codecvt; + template<> class codecvt; +#ifdef _GLIBCXX_USE_WCHAR_T + template<> class codecvt; +#endif + template + class codecvt_byname; + + // 22.2.2 and 22.2.3 numeric +_GLIBCXX_BEGIN_NAMESPACE_LDBL + template > + class num_get; + template > + class num_put; +_GLIBCXX_END_NAMESPACE_LDBL + template class numpunct; + template class numpunct_byname; + + // 22.2.4 collation + template + class collate; + template class + collate_byname; + + // 22.2.5 date and time + class time_base; + template > + class time_get; + template > + class time_get_byname; + template > + class time_put; + template > + class time_put_byname; + + // 22.2.6 money + class money_base; +_GLIBCXX_BEGIN_NAMESPACE_LDBL + template > + class money_get; + template > + class money_put; +_GLIBCXX_END_NAMESPACE_LDBL + template + class moneypunct; + template + class moneypunct_byname; + + // 22.2.7 message retrieval + class messages_base; + template + class messages; + template + class messages_byname; + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace std + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/mask_array.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/mask_array.h new file mode 100755 index 0000000..d1b6793 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/mask_array.h @@ -0,0 +1,208 @@ +// The template and inlines for the -*- C++ -*- mask_array class. + +// Copyright (C) 1997-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file bits/mask_array.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{valarray} + */ + +// Written by Gabriel Dos Reis + +#ifndef _MASK_ARRAY_H +#define _MASK_ARRAY_H 1 + +#pragma GCC system_header + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /** + * @addtogroup numeric_arrays + * @{ + */ + + /** + * @brief Reference to selected subset of an array. + * + * A mask_array is a reference to the actual elements of an array specified + * by a bitmask in the form of an array of bool. The way to get a + * mask_array is to call operator[](valarray) on a valarray. The + * returned mask_array then permits carrying operations out on the + * referenced subset of elements in the original valarray. + * + * For example, if a mask_array is obtained using the array (false, true, + * false, true) as an argument, the mask array has two elements referring + * to array[1] and array[3] in the underlying array. + * + * @param Tp Element type. + */ + template + class mask_array + { + public: + typedef _Tp value_type; + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 253. valarray helper functions are almost entirely useless + + /// Copy constructor. Both slices refer to the same underlying array. + mask_array (const mask_array&); + + /// Assignment operator. Assigns elements to corresponding elements + /// of @a a. + mask_array& operator=(const mask_array&); + + void operator=(const valarray<_Tp>&) const; + /// Multiply slice elements by corresponding elements of @a v. + void operator*=(const valarray<_Tp>&) const; + /// Divide slice elements by corresponding elements of @a v. + void operator/=(const valarray<_Tp>&) const; + /// Modulo slice elements by corresponding elements of @a v. + void operator%=(const valarray<_Tp>&) const; + /// Add corresponding elements of @a v to slice elements. + void operator+=(const valarray<_Tp>&) const; + /// Subtract corresponding elements of @a v from slice elements. + void operator-=(const valarray<_Tp>&) const; + /// Logical xor slice elements with corresponding elements of @a v. + void operator^=(const valarray<_Tp>&) const; + /// Logical and slice elements with corresponding elements of @a v. + void operator&=(const valarray<_Tp>&) const; + /// Logical or slice elements with corresponding elements of @a v. + void operator|=(const valarray<_Tp>&) const; + /// Left shift slice elements by corresponding elements of @a v. + void operator<<=(const valarray<_Tp>&) const; + /// Right shift slice elements by corresponding elements of @a v. + void operator>>=(const valarray<_Tp>&) const; + /// Assign all slice elements to @a t. + void operator=(const _Tp&) const; + + // ~mask_array (); + + template + void operator=(const _Expr<_Dom,_Tp>&) const; + template + void operator*=(const _Expr<_Dom,_Tp>&) const; + template + void operator/=(const _Expr<_Dom,_Tp>&) const; + template + void operator%=(const _Expr<_Dom,_Tp>&) const; + template + void operator+=(const _Expr<_Dom,_Tp>&) const; + template + void operator-=(const _Expr<_Dom,_Tp>&) const; + template + void operator^=(const _Expr<_Dom,_Tp>&) const; + template + void operator&=(const _Expr<_Dom,_Tp>&) const; + template + void operator|=(const _Expr<_Dom,_Tp>&) const; + template + void operator<<=(const _Expr<_Dom,_Tp>&) const; + template + void operator>>=(const _Expr<_Dom,_Tp>&) const; + + private: + mask_array(_Array<_Tp>, size_t, _Array); + friend class valarray<_Tp>; + + const size_t _M_sz; + const _Array _M_mask; + const _Array<_Tp> _M_array; + + // not implemented + mask_array(); + }; + + template + inline mask_array<_Tp>::mask_array(const mask_array<_Tp>& a) + : _M_sz(a._M_sz), _M_mask(a._M_mask), _M_array(a._M_array) {} + + template + inline + mask_array<_Tp>::mask_array(_Array<_Tp> __a, size_t __s, _Array __m) + : _M_sz(__s), _M_mask(__m), _M_array(__a) {} + + template + inline mask_array<_Tp>& + mask_array<_Tp>::operator=(const mask_array<_Tp>& __a) + { + std::__valarray_copy(__a._M_array, __a._M_mask, + _M_sz, _M_array, _M_mask); + return *this; + } + + template + inline void + mask_array<_Tp>::operator=(const _Tp& __t) const + { std::__valarray_fill(_M_array, _M_sz, _M_mask, __t); } + + template + inline void + mask_array<_Tp>::operator=(const valarray<_Tp>& __v) const + { std::__valarray_copy(_Array<_Tp>(__v), __v.size(), _M_array, _M_mask); } + + template + template + inline void + mask_array<_Tp>::operator=(const _Expr<_Ex, _Tp>& __e) const + { std::__valarray_copy(__e, __e.size(), _M_array, _M_mask); } + +#undef _DEFINE_VALARRAY_OPERATOR +#define _DEFINE_VALARRAY_OPERATOR(_Op, _Name) \ + template \ + inline void \ + mask_array<_Tp>::operator _Op##=(const valarray<_Tp>& __v) const \ + { \ + _Array_augmented_##_Name(_M_array, _M_mask, \ + _Array<_Tp>(__v), __v.size()); \ + } \ + \ + template \ + template \ + inline void \ + mask_array<_Tp>::operator _Op##=(const _Expr<_Dom, _Tp>& __e) const\ + { \ + _Array_augmented_##_Name(_M_array, _M_mask, __e, __e.size()); \ + } + +_DEFINE_VALARRAY_OPERATOR(*, __multiplies) +_DEFINE_VALARRAY_OPERATOR(/, __divides) +_DEFINE_VALARRAY_OPERATOR(%, __modulus) +_DEFINE_VALARRAY_OPERATOR(+, __plus) +_DEFINE_VALARRAY_OPERATOR(-, __minus) +_DEFINE_VALARRAY_OPERATOR(^, __bitwise_xor) +_DEFINE_VALARRAY_OPERATOR(&, __bitwise_and) +_DEFINE_VALARRAY_OPERATOR(|, __bitwise_or) +_DEFINE_VALARRAY_OPERATOR(<<, __shift_left) +_DEFINE_VALARRAY_OPERATOR(>>, __shift_right) + +#undef _DEFINE_VALARRAY_OPERATOR + + // @} group numeric_arrays + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif /* _MASK_ARRAY_H */ diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/memoryfwd.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/memoryfwd.h new file mode 100755 index 0000000..65d8bd6 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/memoryfwd.h @@ -0,0 +1,78 @@ +// Forward declarations -*- C++ -*- + +// Copyright (C) 2001-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/* + * Copyright (c) 1996-1997 + * Silicon Graphics Computer Systems, Inc. + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Silicon Graphics makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + */ + +/** @file bits/memoryfwd.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{memory} + */ + +#ifndef _MEMORYFWD_H +#define _MEMORYFWD_H 1 + +#pragma GCC system_header + +#include + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /** + * @defgroup allocators Allocators + * @ingroup memory + * + * Classes encapsulating memory operations. + * + * @{ + */ + + template + class allocator; + + template<> + class allocator; + + /// Declare uses_allocator so it can be specialized in \ etc. + template + struct uses_allocator; + + /// @} group memory + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace std + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/move.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/move.h new file mode 100755 index 0000000..dc4ac0f --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/move.h @@ -0,0 +1,198 @@ +// Move, forward and identity for C++0x + swap -*- C++ -*- + +// Copyright (C) 2007-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file bits/move.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{utility} + */ + +#ifndef _MOVE_H +#define _MOVE_H 1 + +#include +#include + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + // Used, in C++03 mode too, by allocators, etc. + /** + * @brief Same as C++11 std::addressof + * @ingroup utilities + */ + template + inline _Tp* + __addressof(_Tp& __r) _GLIBCXX_NOEXCEPT + { + return reinterpret_cast<_Tp*> + (&const_cast(reinterpret_cast(__r))); + } + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#if __cplusplus >= 201103L +#include // Brings in std::declval too. + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /** + * @addtogroup utilities + * @{ + */ + + /** + * @brief Forward an lvalue. + * @return The parameter cast to the specified type. + * + * This function is used to implement "perfect forwarding". + */ + template + constexpr _Tp&& + forward(typename std::remove_reference<_Tp>::type& __t) noexcept + { return static_cast<_Tp&&>(__t); } + + /** + * @brief Forward an rvalue. + * @return The parameter cast to the specified type. + * + * This function is used to implement "perfect forwarding". + */ + template + constexpr _Tp&& + forward(typename std::remove_reference<_Tp>::type&& __t) noexcept + { + static_assert(!std::is_lvalue_reference<_Tp>::value, "template argument" + " substituting _Tp is an lvalue reference type"); + return static_cast<_Tp&&>(__t); + } + + /** + * @brief Convert a value to an rvalue. + * @param __t A thing of arbitrary type. + * @return The parameter cast to an rvalue-reference to allow moving it. + */ + template + constexpr typename std::remove_reference<_Tp>::type&& + move(_Tp&& __t) noexcept + { return static_cast::type&&>(__t); } + + + template + struct __move_if_noexcept_cond + : public __and_<__not_>, + is_copy_constructible<_Tp>>::type { }; + + /** + * @brief Conditionally convert a value to an rvalue. + * @param __x A thing of arbitrary type. + * @return The parameter, possibly cast to an rvalue-reference. + * + * Same as std::move unless the type's move constructor could throw and the + * type is copyable, in which case an lvalue-reference is returned instead. + */ + template + constexpr typename + conditional<__move_if_noexcept_cond<_Tp>::value, const _Tp&, _Tp&&>::type + move_if_noexcept(_Tp& __x) noexcept + { return std::move(__x); } + + // declval, from type_traits. + + /** + * @brief Returns the actual address of the object or function + * referenced by r, even in the presence of an overloaded + * operator&. + * @param __r Reference to an object or function. + * @return The actual address. + */ + template + inline _Tp* + addressof(_Tp& __r) noexcept + { return std::__addressof(__r); } + + /// @} group utilities +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#define _GLIBCXX_MOVE(__val) std::move(__val) +#define _GLIBCXX_FORWARD(_Tp, __val) std::forward<_Tp>(__val) +#else +#define _GLIBCXX_MOVE(__val) (__val) +#define _GLIBCXX_FORWARD(_Tp, __val) (__val) +#endif + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /** + * @addtogroup utilities + * @{ + */ + + /** + * @brief Swaps two values. + * @param __a A thing of arbitrary type. + * @param __b Another thing of arbitrary type. + * @return Nothing. + */ + template + inline void + swap(_Tp& __a, _Tp& __b) +#if __cplusplus >= 201103L + noexcept(__and_, + is_nothrow_move_assignable<_Tp>>::value) +#endif + { + // concept requirements + __glibcxx_function_requires(_SGIAssignableConcept<_Tp>) + + _Tp __tmp = _GLIBCXX_MOVE(__a); + __a = _GLIBCXX_MOVE(__b); + __b = _GLIBCXX_MOVE(__tmp); + } + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR 809. std::swap should be overloaded for array types. + /// Swap the contents of two arrays. + template + inline void + swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm]) +#if __cplusplus >= 201103L + noexcept(noexcept(swap(*__a, *__b))) +#endif + { + for (size_t __n = 0; __n < _Nm; ++__n) + swap(__a[__n], __b[__n]); + } + + /// @} group utilities +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif /* _MOVE_H */ diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/nested_exception.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/nested_exception.h new file mode 100755 index 0000000..7e2b2f2 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/nested_exception.h @@ -0,0 +1,166 @@ +// Nested Exception support header (nested_exception class) for -*- C++ -*- + +// Copyright (C) 2009-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file bits/nested_exception.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{exception} + */ + +#ifndef _GLIBCXX_NESTED_EXCEPTION_H +#define _GLIBCXX_NESTED_EXCEPTION_H 1 + +#pragma GCC visibility push(default) + +#if __cplusplus < 201103L +# include +#else + +#include + +#if ATOMIC_INT_LOCK_FREE < 2 +# error This platform does not support exception propagation. +#endif + +extern "C++" { + +namespace std +{ + /** + * @addtogroup exceptions + * @{ + */ + + /// Exception class with exception_ptr data member. + class nested_exception + { + exception_ptr _M_ptr; + + public: + nested_exception() noexcept : _M_ptr(current_exception()) { } + + nested_exception(const nested_exception&) = default; + + nested_exception& operator=(const nested_exception&) = default; + + virtual ~nested_exception() noexcept; + + void + rethrow_nested() const __attribute__ ((__noreturn__)) + { rethrow_exception(_M_ptr); } + + exception_ptr + nested_ptr() const + { return _M_ptr; } + }; + + template + struct _Nested_exception : public _Except, public nested_exception + { + explicit _Nested_exception(_Except&& __ex) + : _Except(static_cast<_Except&&>(__ex)) + { } + }; + + template + struct __get_nested_helper + { + static const nested_exception* + _S_get(const _Ex& __ex) + { return dynamic_cast(&__ex); } + }; + + template + struct __get_nested_helper<_Ex*> + { + static const nested_exception* + _S_get(const _Ex* __ex) + { return dynamic_cast(__ex); } + }; + + template + inline const nested_exception* + __get_nested_exception(const _Ex& __ex) + { return __get_nested_helper<_Ex>::_S_get(__ex); } + + template + void + __throw_with_nested(_Ex&&, const nested_exception* = 0) + __attribute__ ((__noreturn__)); + + template + void + __throw_with_nested(_Ex&&, ...) __attribute__ ((__noreturn__)); + + // This function should never be called, but is needed to avoid a warning + // about ambiguous base classes when instantiating throw_with_nested<_Ex>() + // with a type that has an accessible nested_exception base. + template + inline void + __throw_with_nested(_Ex&& __ex, const nested_exception*) + { throw __ex; } + + template + inline void + __throw_with_nested(_Ex&& __ex, ...) + { throw _Nested_exception<_Ex>(static_cast<_Ex&&>(__ex)); } + + template + void + throw_with_nested(_Ex __ex) __attribute__ ((__noreturn__)); + + /// If @p __ex is derived from nested_exception, @p __ex. + /// Else, an implementation-defined object derived from both. + template + inline void + throw_with_nested(_Ex __ex) + { + if (__get_nested_exception(__ex)) + throw __ex; + __throw_with_nested(static_cast<_Ex&&>(__ex), &__ex); + } + + /// If @p __ex is derived from nested_exception, @p __ex.rethrow_nested(). + template + inline void + rethrow_if_nested(const _Ex& __ex) + { + if (const nested_exception* __nested = __get_nested_exception(__ex)) + __nested->rethrow_nested(); + } + + /// Overload, See N2619 + inline void + rethrow_if_nested(const nested_exception& __ex) + { __ex.rethrow_nested(); } + + // @} group exceptions +} // namespace std + +} // extern "C++" + +#endif // C++11 + +#pragma GCC visibility pop + +#endif // _GLIBCXX_NESTED_EXCEPTION_H diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/ostream.tcc b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/ostream.tcc new file mode 100755 index 0000000..a3a8695 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/ostream.tcc @@ -0,0 +1,407 @@ +// ostream classes -*- C++ -*- + +// Copyright (C) 1997-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file bits/ostream.tcc + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{ostream} + */ + +// +// ISO C++ 14882: 27.6.2 Output streams +// + +#ifndef _OSTREAM_TCC +#define _OSTREAM_TCC 1 + +#pragma GCC system_header + +#include + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + template + basic_ostream<_CharT, _Traits>::sentry:: + sentry(basic_ostream<_CharT, _Traits>& __os) + : _M_ok(false), _M_os(__os) + { + // XXX MT + if (__os.tie() && __os.good()) + __os.tie()->flush(); + + if (__os.good()) + _M_ok = true; + else + __os.setstate(ios_base::failbit); + } + + template + template + basic_ostream<_CharT, _Traits>& + basic_ostream<_CharT, _Traits>:: + _M_insert(_ValueT __v) + { + sentry __cerb(*this); + if (__cerb) + { + ios_base::iostate __err = ios_base::goodbit; + __try + { + const __num_put_type& __np = __check_facet(this->_M_num_put); + if (__np.put(*this, *this, this->fill(), __v).failed()) + __err |= ios_base::badbit; + } + __catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + __throw_exception_again; + } + __catch(...) + { this->_M_setstate(ios_base::badbit); } + if (__err) + this->setstate(__err); + } + return *this; + } + + template + basic_ostream<_CharT, _Traits>& + basic_ostream<_CharT, _Traits>:: + operator<<(short __n) + { + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 117. basic_ostream uses nonexistent num_put member functions. + const ios_base::fmtflags __fmt = this->flags() & ios_base::basefield; + if (__fmt == ios_base::oct || __fmt == ios_base::hex) + return _M_insert(static_cast(static_cast(__n))); + else + return _M_insert(static_cast(__n)); + } + + template + basic_ostream<_CharT, _Traits>& + basic_ostream<_CharT, _Traits>:: + operator<<(int __n) + { + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 117. basic_ostream uses nonexistent num_put member functions. + const ios_base::fmtflags __fmt = this->flags() & ios_base::basefield; + if (__fmt == ios_base::oct || __fmt == ios_base::hex) + return _M_insert(static_cast(static_cast(__n))); + else + return _M_insert(static_cast(__n)); + } + + template + basic_ostream<_CharT, _Traits>& + basic_ostream<_CharT, _Traits>:: + operator<<(__streambuf_type* __sbin) + { + ios_base::iostate __err = ios_base::goodbit; + sentry __cerb(*this); + if (__cerb && __sbin) + { + __try + { + if (!__copy_streambufs(__sbin, this->rdbuf())) + __err |= ios_base::failbit; + } + __catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + __throw_exception_again; + } + __catch(...) + { this->_M_setstate(ios_base::failbit); } + } + else if (!__sbin) + __err |= ios_base::badbit; + if (__err) + this->setstate(__err); + return *this; + } + + template + basic_ostream<_CharT, _Traits>& + basic_ostream<_CharT, _Traits>:: + put(char_type __c) + { + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR 60. What is a formatted input function? + // basic_ostream::put(char_type) is an unformatted output function. + // DR 63. Exception-handling policy for unformatted output. + // Unformatted output functions should catch exceptions thrown + // from streambuf members. + sentry __cerb(*this); + if (__cerb) + { + ios_base::iostate __err = ios_base::goodbit; + __try + { + const int_type __put = this->rdbuf()->sputc(__c); + if (traits_type::eq_int_type(__put, traits_type::eof())) + __err |= ios_base::badbit; + } + __catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + __throw_exception_again; + } + __catch(...) + { this->_M_setstate(ios_base::badbit); } + if (__err) + this->setstate(__err); + } + return *this; + } + + template + basic_ostream<_CharT, _Traits>& + basic_ostream<_CharT, _Traits>:: + write(const _CharT* __s, streamsize __n) + { + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR 60. What is a formatted input function? + // basic_ostream::write(const char_type*, streamsize) is an + // unformatted output function. + // DR 63. Exception-handling policy for unformatted output. + // Unformatted output functions should catch exceptions thrown + // from streambuf members. + sentry __cerb(*this); + if (__cerb) + { + __try + { _M_write(__s, __n); } + __catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + __throw_exception_again; + } + __catch(...) + { this->_M_setstate(ios_base::badbit); } + } + return *this; + } + + template + basic_ostream<_CharT, _Traits>& + basic_ostream<_CharT, _Traits>:: + flush() + { + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR 60. What is a formatted input function? + // basic_ostream::flush() is *not* an unformatted output function. + ios_base::iostate __err = ios_base::goodbit; + __try + { + if (this->rdbuf() && this->rdbuf()->pubsync() == -1) + __err |= ios_base::badbit; + } + __catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + __throw_exception_again; + } + __catch(...) + { this->_M_setstate(ios_base::badbit); } + if (__err) + this->setstate(__err); + return *this; + } + + template + typename basic_ostream<_CharT, _Traits>::pos_type + basic_ostream<_CharT, _Traits>:: + tellp() + { + pos_type __ret = pos_type(-1); + __try + { + if (!this->fail()) + __ret = this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::out); + } + __catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + __throw_exception_again; + } + __catch(...) + { this->_M_setstate(ios_base::badbit); } + return __ret; + } + + template + basic_ostream<_CharT, _Traits>& + basic_ostream<_CharT, _Traits>:: + seekp(pos_type __pos) + { + ios_base::iostate __err = ios_base::goodbit; + __try + { + if (!this->fail()) + { + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 136. seekp, seekg setting wrong streams? + const pos_type __p = this->rdbuf()->pubseekpos(__pos, + ios_base::out); + + // 129. Need error indication from seekp() and seekg() + if (__p == pos_type(off_type(-1))) + __err |= ios_base::failbit; + } + } + __catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + __throw_exception_again; + } + __catch(...) + { this->_M_setstate(ios_base::badbit); } + if (__err) + this->setstate(__err); + return *this; + } + + template + basic_ostream<_CharT, _Traits>& + basic_ostream<_CharT, _Traits>:: + seekp(off_type __off, ios_base::seekdir __dir) + { + ios_base::iostate __err = ios_base::goodbit; + __try + { + if (!this->fail()) + { + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 136. seekp, seekg setting wrong streams? + const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir, + ios_base::out); + + // 129. Need error indication from seekp() and seekg() + if (__p == pos_type(off_type(-1))) + __err |= ios_base::failbit; + } + } + __catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + __throw_exception_again; + } + __catch(...) + { this->_M_setstate(ios_base::badbit); } + if (__err) + this->setstate(__err); + return *this; + } + + template + basic_ostream<_CharT, _Traits>& + operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s) + { + if (!__s) + __out.setstate(ios_base::badbit); + else + { + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 167. Improper use of traits_type::length() + const size_t __clen = char_traits::length(__s); + __try + { + struct __ptr_guard + { + _CharT *__p; + __ptr_guard (_CharT *__ip): __p(__ip) { } + ~__ptr_guard() { delete[] __p; } + _CharT* __get() { return __p; } + } __pg (new _CharT[__clen]); + + _CharT *__ws = __pg.__get(); + for (size_t __i = 0; __i < __clen; ++__i) + __ws[__i] = __out.widen(__s[__i]); + __ostream_insert(__out, __ws, __clen); + } + __catch(__cxxabiv1::__forced_unwind&) + { + __out._M_setstate(ios_base::badbit); + __throw_exception_again; + } + __catch(...) + { __out._M_setstate(ios_base::badbit); } + } + return __out; + } + + // Inhibit implicit instantiations for required instantiations, + // which are defined via explicit instantiations elsewhere. +#if _GLIBCXX_EXTERN_TEMPLATE + extern template class basic_ostream; + extern template ostream& endl(ostream&); + extern template ostream& ends(ostream&); + extern template ostream& flush(ostream&); + extern template ostream& operator<<(ostream&, char); + extern template ostream& operator<<(ostream&, unsigned char); + extern template ostream& operator<<(ostream&, signed char); + extern template ostream& operator<<(ostream&, const char*); + extern template ostream& operator<<(ostream&, const unsigned char*); + extern template ostream& operator<<(ostream&, const signed char*); + + extern template ostream& ostream::_M_insert(long); + extern template ostream& ostream::_M_insert(unsigned long); + extern template ostream& ostream::_M_insert(bool); +#ifdef _GLIBCXX_USE_LONG_LONG + extern template ostream& ostream::_M_insert(long long); + extern template ostream& ostream::_M_insert(unsigned long long); +#endif + extern template ostream& ostream::_M_insert(double); + extern template ostream& ostream::_M_insert(long double); + extern template ostream& ostream::_M_insert(const void*); + +#ifdef _GLIBCXX_USE_WCHAR_T + extern template class basic_ostream; + extern template wostream& endl(wostream&); + extern template wostream& ends(wostream&); + extern template wostream& flush(wostream&); + extern template wostream& operator<<(wostream&, wchar_t); + extern template wostream& operator<<(wostream&, char); + extern template wostream& operator<<(wostream&, const wchar_t*); + extern template wostream& operator<<(wostream&, const char*); + + extern template wostream& wostream::_M_insert(long); + extern template wostream& wostream::_M_insert(unsigned long); + extern template wostream& wostream::_M_insert(bool); +#ifdef _GLIBCXX_USE_LONG_LONG + extern template wostream& wostream::_M_insert(long long); + extern template wostream& wostream::_M_insert(unsigned long long); +#endif + extern template wostream& wostream::_M_insert(double); + extern template wostream& wostream::_M_insert(long double); + extern template wostream& wostream::_M_insert(const void*); +#endif +#endif + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace std + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/ostream_insert.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/ostream_insert.h new file mode 100755 index 0000000..4447586 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/ostream_insert.h @@ -0,0 +1,129 @@ +// Helpers for ostream inserters -*- C++ -*- + +// Copyright (C) 2007-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file bits/ostream_insert.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{ostream} + */ + +#ifndef _OSTREAM_INSERT_H +#define _OSTREAM_INSERT_H 1 + +#pragma GCC system_header + +#include +#include + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + template + inline void + __ostream_write(basic_ostream<_CharT, _Traits>& __out, + const _CharT* __s, streamsize __n) + { + typedef basic_ostream<_CharT, _Traits> __ostream_type; + typedef typename __ostream_type::ios_base __ios_base; + + const streamsize __put = __out.rdbuf()->sputn(__s, __n); + if (__put != __n) + __out.setstate(__ios_base::badbit); + } + + template + inline void + __ostream_fill(basic_ostream<_CharT, _Traits>& __out, streamsize __n) + { + typedef basic_ostream<_CharT, _Traits> __ostream_type; + typedef typename __ostream_type::ios_base __ios_base; + + const _CharT __c = __out.fill(); + for (; __n > 0; --__n) + { + const typename _Traits::int_type __put = __out.rdbuf()->sputc(__c); + if (_Traits::eq_int_type(__put, _Traits::eof())) + { + __out.setstate(__ios_base::badbit); + break; + } + } + } + + template + basic_ostream<_CharT, _Traits>& + __ostream_insert(basic_ostream<_CharT, _Traits>& __out, + const _CharT* __s, streamsize __n) + { + typedef basic_ostream<_CharT, _Traits> __ostream_type; + typedef typename __ostream_type::ios_base __ios_base; + + typename __ostream_type::sentry __cerb(__out); + if (__cerb) + { + __try + { + const streamsize __w = __out.width(); + if (__w > __n) + { + const bool __left = ((__out.flags() + & __ios_base::adjustfield) + == __ios_base::left); + if (!__left) + __ostream_fill(__out, __w - __n); + if (__out.good()) + __ostream_write(__out, __s, __n); + if (__left && __out.good()) + __ostream_fill(__out, __w - __n); + } + else + __ostream_write(__out, __s, __n); + __out.width(0); + } + __catch(__cxxabiv1::__forced_unwind&) + { + __out._M_setstate(__ios_base::badbit); + __throw_exception_again; + } + __catch(...) + { __out._M_setstate(__ios_base::badbit); } + } + return __out; + } + + // Inhibit implicit instantiations for required instantiations, + // which are defined via explicit instantiations elsewhere. +#if _GLIBCXX_EXTERN_TEMPLATE + extern template ostream& __ostream_insert(ostream&, const char*, streamsize); + +#ifdef _GLIBCXX_USE_WCHAR_T + extern template wostream& __ostream_insert(wostream&, const wchar_t*, + streamsize); +#endif +#endif + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace std + +#endif /* _OSTREAM_INSERT_H */ diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/parse_numbers.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/parse_numbers.h new file mode 100755 index 0000000..91a127c --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/parse_numbers.h @@ -0,0 +1,417 @@ +// Components for compile-time parsing of numbers -*- C++ -*- + +// Copyright (C) 2013-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file bits/parse_numbers.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{chrono} + */ + +#ifndef _PARSE_NUMBERS_H +#define _PARSE_NUMBERS_H 1 + +#pragma GCC system_header + +// From n3642.pdf except I added binary literals and digit separator '\''. + +#if __cplusplus > 201103L + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + +namespace __parse_int { + + template + struct _Digit; + + template + struct _Digit<_Base, '0'> + { + static constexpr bool valid{true}; + static constexpr unsigned value{0}; + }; + + template + struct _Digit<_Base, '1'> + { + static constexpr bool valid{true}; + static constexpr unsigned value{1}; + }; + + template + struct _Digit<_Base, '2'> + { + static_assert(_Base > 2, "invalid digit"); + static constexpr bool valid{true}; + static constexpr unsigned value{2}; + }; + + template + struct _Digit<_Base, '3'> + { + static_assert(_Base > 3, "invalid digit"); + static constexpr bool valid{true}; + static constexpr unsigned value{3}; + }; + + template + struct _Digit<_Base, '4'> + { + static_assert(_Base > 4, "invalid digit"); + static constexpr bool valid{true}; + static constexpr unsigned value{4}; + }; + + template + struct _Digit<_Base, '5'> + { + static_assert(_Base > 5, "invalid digit"); + static constexpr bool valid{true}; + static constexpr unsigned value{5}; + }; + + template + struct _Digit<_Base, '6'> + { + static_assert(_Base > 6, "invalid digit"); + static constexpr bool valid{true}; + static constexpr unsigned value{6}; + }; + + template + struct _Digit<_Base, '7'> + { + static_assert(_Base > 7, "invalid digit"); + static constexpr bool valid{true}; + static constexpr unsigned value{7}; + }; + + template + struct _Digit<_Base, '8'> + { + static_assert(_Base > 8, "invalid digit"); + static constexpr bool valid{true}; + static constexpr unsigned value{8}; + }; + + template + struct _Digit<_Base, '9'> + { + static_assert(_Base > 9, "invalid digit"); + static constexpr bool valid{true}; + static constexpr unsigned value{9}; + }; + + template + struct _Digit<_Base, 'a'> + { + static_assert(_Base > 0xa, "invalid digit"); + static constexpr bool valid{true}; + static constexpr unsigned value{0xa}; + }; + + template + struct _Digit<_Base, 'A'> + { + static_assert(_Base > 0xa, "invalid digit"); + static constexpr bool valid{true}; + static constexpr unsigned value{0xa}; + }; + + template + struct _Digit<_Base, 'b'> + { + static_assert(_Base > 0xb, "invalid digit"); + static constexpr bool valid{true}; + static constexpr unsigned value{0xb}; + }; + + template + struct _Digit<_Base, 'B'> + { + static_assert(_Base > 0xb, "invalid digit"); + static constexpr bool valid{true}; + static constexpr unsigned value{0xb}; + }; + + template + struct _Digit<_Base, 'c'> + { + static_assert(_Base > 0xc, "invalid digit"); + static constexpr bool valid{true}; + static constexpr unsigned value{0xc}; + }; + + template + struct _Digit<_Base, 'C'> + { + static_assert(_Base > 0xc, "invalid digit"); + static constexpr bool valid{true}; + static constexpr unsigned value{0xc}; + }; + + template + struct _Digit<_Base, 'd'> + { + static_assert(_Base > 0xd, "invalid digit"); + static constexpr bool valid{true}; + static constexpr unsigned value{0xd}; + }; + + template + struct _Digit<_Base, 'D'> + { + static_assert(_Base > 0xd, "invalid digit"); + static constexpr bool valid{true}; + static constexpr unsigned value{0xd}; + }; + + template + struct _Digit<_Base, 'e'> + { + static_assert(_Base > 0xe, "invalid digit"); + static constexpr bool valid{true}; + static constexpr unsigned value{0xe}; + }; + + template + struct _Digit<_Base, 'E'> + { + static_assert(_Base > 0xe, "invalid digit"); + static constexpr bool valid{true}; + static constexpr unsigned value{0xe}; + }; + + template + struct _Digit<_Base, 'f'> + { + static_assert(_Base > 0xf, "invalid digit"); + static constexpr bool valid{true}; + static constexpr unsigned value{0xf}; + }; + + template + struct _Digit<_Base, 'F'> + { + static_assert(_Base > 0xf, "invalid digit"); + static constexpr bool valid{true}; + static constexpr unsigned value{0xf}; + }; + + // Digit separator + template + struct _Digit<_Base, '\''> + { + static constexpr bool valid{false}; + static constexpr unsigned value{0}; + }; + + +//------------------------------------------------------------------------------ + + template + struct _Digits_help + { + static constexpr unsigned + value{_Digit<_Base, _Dig>::valid ? + 1U + _Digits_help<_Base, _Digs...>::value : + _Digits_help<_Base, _Digs...>::value}; + }; + + template + struct _Digits_help<_Base, _Dig> + { + static constexpr unsigned value{_Digit<_Base, _Dig>::valid ? 1U : 0U}; + }; + + template + struct _Digits + { + static constexpr unsigned value{_Digits_help<_Base, _Digs...>::value}; + }; + + template + struct _Digits<_Base> + { + static constexpr unsigned value{0U}; + }; + +//------------------------------------------------------------------------------ + + template + struct _Power_help + { + static constexpr unsigned + value{_Digit<_Base, _Dig>::valid ? + _Base * _Power_help<_Base, _Digs...>::value : + _Power_help<_Base, _Digs...>::value}; + }; + + template + struct _Power_help<_Base, _Dig> + { + static constexpr unsigned value{_Digit<_Base, _Dig>::valid ? 1U : 0U}; + }; + + template + struct _Power + { + static constexpr unsigned value{_Power_help<_Base, _Digs...>::value}; + }; + + template + struct _Power<_Base> + { + static constexpr unsigned value{0U}; + }; + +//------------------------------------------------------------------------------ + + template + struct _Number_help + { + static constexpr unsigned + value{_Digit<_Base, _Dig>::valid ? + _Pow * _Digit<_Base, _Dig>::value + + _Number_help<_Base, _Pow / _Base, _Digs...>::value : + _Number_help<_Base, _Pow, _Digs...>::value}; + }; + + template + struct _Number_help<_Base, _Pow, _Dig> + { + //static_assert(_Pow == 1U, "power should be one"); + static constexpr unsigned + value{_Digit<_Base, _Dig>::valid ? _Digit<_Base, _Dig>::value : 0U}; + }; + + template + struct _Number + { + static constexpr unsigned + value{_Number_help<_Base, _Power<_Base, _Digs...>::value, + _Digs...>::value}; + }; + + template + struct _Number<_Base> + { + static constexpr unsigned value{0U}; + }; + +//------------------------------------------------------------------------------ +// This _Parse_int is the same 'level' as the old _Base_dispatch. + + template + struct _Parse_int; + + template + struct _Parse_int<'0', 'b', _Digs...> + { + static constexpr unsigned long long + value{_Number<2U, _Digs...>::value}; + }; + + template + struct _Parse_int<'0', 'B', _Digs...> + { + static constexpr unsigned long long + value{_Number<2U, _Digs...>::value}; + }; + + template + struct _Parse_int<'0', 'x', _Digs...> + { + static constexpr unsigned long long + value{_Number<16U, _Digs...>::value}; + }; + + template + struct _Parse_int<'0', 'X', _Digs...> + { + static constexpr unsigned long long + value{_Number<16U, _Digs...>::value}; + }; + + template + struct _Parse_int<'0', _Digs...> + { + static constexpr unsigned long long + value{_Number<8U, _Digs...>::value}; + }; + + template + struct _Parse_int + { + static constexpr unsigned long long + value{_Number<10U, _Digs...>::value}; + }; + +} // namespace __parse_int + + +namespace __select_int { + + template + struct _Select_int_base; + + template + struct _Select_int_base<_Val, _IntType, _Ints...> + : integral_constant + < + typename conditional + < + _Val <= static_cast + (std::numeric_limits<_IntType>::max()), + _IntType, + typename _Select_int_base<_Val, _Ints...>::value_type + >::type, + _Val + > + { }; + + template + struct _Select_int_base<_Val> : integral_constant + { }; + + template + struct _Select_int + : _Select_int_base< + __parse_int::_Parse_int<_Digs...>::value, + unsigned char, + unsigned short, + unsigned int, + unsigned long, + unsigned long long + > + { }; + +} // namespace __select_int + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace std + +#endif // __cplusplus > 201103L + +#endif // _PARSE_NUMBERS_H diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/postypes.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/postypes.h new file mode 100755 index 0000000..158f5d0 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/postypes.h @@ -0,0 +1,242 @@ +// Position types -*- C++ -*- + +// Copyright (C) 1997-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file bits/postypes.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{iosfwd} + */ + +// +// ISO C++ 14882: 27.4.1 - Types +// ISO C++ 14882: 27.4.3 - Template class fpos +// + +#ifndef _GLIBCXX_POSTYPES_H +#define _GLIBCXX_POSTYPES_H 1 + +#pragma GCC system_header + +#include // For mbstate_t + +// XXX If is really needed, make sure to define the macros +// before including it, in order not to break (and +// in C++0x). Reconsider all this as soon as possible... +#if (defined(_GLIBCXX_HAVE_INT64_T) && !defined(_GLIBCXX_HAVE_INT64_T_LONG) \ + && !defined(_GLIBCXX_HAVE_INT64_T_LONG_LONG)) + +#ifndef __STDC_LIMIT_MACROS +# define _UNDEF__STDC_LIMIT_MACROS +# define __STDC_LIMIT_MACROS +#endif +#ifndef __STDC_CONSTANT_MACROS +# define _UNDEF__STDC_CONSTANT_MACROS +# define __STDC_CONSTANT_MACROS +#endif +#include // For int64_t +#ifdef _UNDEF__STDC_LIMIT_MACROS +# undef __STDC_LIMIT_MACROS +# undef _UNDEF__STDC_LIMIT_MACROS +#endif +#ifdef _UNDEF__STDC_CONSTANT_MACROS +# undef __STDC_CONSTANT_MACROS +# undef _UNDEF__STDC_CONSTANT_MACROS +#endif + +#endif + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + // The types streamoff, streampos and wstreampos and the class + // template fpos<> are described in clauses 21.1.2, 21.1.3, 27.1.2, + // 27.2, 27.4.1, 27.4.3 and D.6. Despite all this verbiage, the + // behaviour of these types is mostly implementation defined or + // unspecified. The behaviour in this implementation is as noted + // below. + + /** + * @brief Type used by fpos, char_traits, and char_traits. + * + * In clauses 21.1.3.1 and 27.4.1 streamoff is described as an + * implementation defined type. + * Note: In versions of GCC up to and including GCC 3.3, streamoff + * was typedef long. + */ +#ifdef _GLIBCXX_HAVE_INT64_T_LONG + typedef long streamoff; +#elif defined(_GLIBCXX_HAVE_INT64_T_LONG_LONG) + typedef long long streamoff; +#elif defined(_GLIBCXX_HAVE_INT64_T) + typedef int64_t streamoff; +#else + typedef long long streamoff; +#endif + + /// Integral type for I/O operation counts and buffer sizes. + typedef ptrdiff_t streamsize; // Signed integral type + + /** + * @brief Class representing stream positions. + * + * The standard places no requirements upon the template parameter StateT. + * In this implementation StateT must be DefaultConstructible, + * CopyConstructible and Assignable. The standard only requires that fpos + * should contain a member of type StateT. In this implementation it also + * contains an offset stored as a signed integer. + * + * @param StateT Type passed to and returned from state(). + */ + template + class fpos + { + private: + streamoff _M_off; + _StateT _M_state; + + public: + // The standard doesn't require that fpos objects can be default + // constructed. This implementation provides a default + // constructor that initializes the offset to 0 and default + // constructs the state. + fpos() + : _M_off(0), _M_state() { } + + // The standard requires that fpos objects can be constructed + // from streamoff objects using the constructor syntax, and + // fails to give any meaningful semantics. In this + // implementation implicit conversion is also allowed, and this + // constructor stores the streamoff as the offset and default + // constructs the state. + /// Construct position from offset. + fpos(streamoff __off) + : _M_off(__off), _M_state() { } + + /// Convert to streamoff. + operator streamoff() const { return _M_off; } + + /// Remember the value of @a st. + void + state(_StateT __st) + { _M_state = __st; } + + /// Return the last set value of @a st. + _StateT + state() const + { return _M_state; } + + // The standard requires that this operator must be defined, but + // gives no semantics. In this implementation it just adds its + // argument to the stored offset and returns *this. + /// Add offset to this position. + fpos& + operator+=(streamoff __off) + { + _M_off += __off; + return *this; + } + + // The standard requires that this operator must be defined, but + // gives no semantics. In this implementation it just subtracts + // its argument from the stored offset and returns *this. + /// Subtract offset from this position. + fpos& + operator-=(streamoff __off) + { + _M_off -= __off; + return *this; + } + + // The standard requires that this operator must be defined, but + // defines its semantics only in terms of operator-. In this + // implementation it constructs a copy of *this, adds the + // argument to that copy using operator+= and then returns the + // copy. + /// Add position and offset. + fpos + operator+(streamoff __off) const + { + fpos __pos(*this); + __pos += __off; + return __pos; + } + + // The standard requires that this operator must be defined, but + // defines its semantics only in terms of operator+. In this + // implementation it constructs a copy of *this, subtracts the + // argument from that copy using operator-= and then returns the + // copy. + /// Subtract offset from position. + fpos + operator-(streamoff __off) const + { + fpos __pos(*this); + __pos -= __off; + return __pos; + } + + // The standard requires that this operator must be defined, but + // defines its semantics only in terms of operator+. In this + // implementation it returns the difference between the offset + // stored in *this and in the argument. + /// Subtract position to return offset. + streamoff + operator-(const fpos& __other) const + { return _M_off - __other._M_off; } + }; + + // The standard only requires that operator== must be an + // equivalence relation. In this implementation two fpos + // objects belong to the same equivalence class if the contained + // offsets compare equal. + /// Test if equivalent to another position. + template + inline bool + operator==(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs) + { return streamoff(__lhs) == streamoff(__rhs); } + + template + inline bool + operator!=(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs) + { return streamoff(__lhs) != streamoff(__rhs); } + + // Clauses 21.1.3.1 and 21.1.3.2 describe streampos and wstreampos + // as implementation defined types, but clause 27.2 requires that + // they must both be typedefs for fpos + /// File position for char streams. + typedef fpos streampos; + /// File position for wchar_t streams. + typedef fpos wstreampos; + +#if __cplusplus >= 201103L + /// File position for char16_t streams. + typedef fpos u16streampos; + /// File position for char32_t streams. + typedef fpos u32streampos; +#endif + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/predefined_ops.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/predefined_ops.h new file mode 100755 index 0000000..78f5e37 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/predefined_ops.h @@ -0,0 +1,304 @@ +// Default predicates for internal use -*- C++ -*- + +// Copyright (C) 2013-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file predefined_ops.h + * This is an internal header file, included by other library headers. + * You should not attempt to use it directly. + */ + +#ifndef _GLIBCXX_PREDEFINED_OPS_H +#define _GLIBCXX_PREDEFINED_OPS_H 1 + +namespace __gnu_cxx +{ +namespace __ops +{ + struct _Iter_less_iter + { + template + bool + operator()(_Iterator1 __it1, _Iterator2 __it2) const + { return *__it1 < *__it2; } + }; + + inline _Iter_less_iter + __iter_less_iter() + { return _Iter_less_iter(); } + + struct _Iter_less_val + { + template + bool + operator()(_Iterator __it, _Value& __val) const + { return *__it < __val; } + }; + + inline _Iter_less_val + __iter_less_val() + { return _Iter_less_val(); } + + inline _Iter_less_val + __iter_comp_val(_Iter_less_iter) + { return _Iter_less_val(); } + + struct _Val_less_iter + { + template + bool + operator()(_Value& __val, _Iterator __it) const + { return __val < *__it; } + }; + + inline _Val_less_iter + __val_less_iter() + { return _Val_less_iter(); } + + inline _Val_less_iter + __val_comp_iter(_Iter_less_iter) + { return _Val_less_iter(); } + + struct _Iter_equal_to_iter + { + template + bool + operator()(_Iterator1 __it1, _Iterator2 __it2) const + { return *__it1 == *__it2; } + }; + + inline _Iter_equal_to_iter + __iter_equal_to_iter() + { return _Iter_equal_to_iter(); } + + struct _Iter_equal_to_val + { + template + bool + operator()(_Iterator __it, _Value& __val) const + { return *__it == __val; } + }; + + inline _Iter_equal_to_val + __iter_equal_to_val() + { return _Iter_equal_to_val(); } + + inline _Iter_equal_to_val + __iter_comp_val(_Iter_equal_to_iter) + { return _Iter_equal_to_val(); } + + template + struct _Iter_comp_iter + { + _Compare _M_comp; + + _Iter_comp_iter(_Compare __comp) + : _M_comp(__comp) + { } + + template + bool + operator()(_Iterator1 __it1, _Iterator2 __it2) + { return bool(_M_comp(*__it1, *__it2)); } + }; + + template + inline _Iter_comp_iter<_Compare> + __iter_comp_iter(_Compare __comp) + { return _Iter_comp_iter<_Compare>(__comp); } + + template + struct _Iter_comp_val + { + _Compare _M_comp; + + _Iter_comp_val(_Compare __comp) + : _M_comp(__comp) + { } + + template + bool + operator()(_Iterator __it, _Value& __val) + { return bool(_M_comp(*__it, __val)); } + }; + + template + inline _Iter_comp_val<_Compare> + __iter_comp_val(_Compare __comp) + { return _Iter_comp_val<_Compare>(__comp); } + + template + inline _Iter_comp_val<_Compare> + __iter_comp_val(_Iter_comp_iter<_Compare> __comp) + { return _Iter_comp_val<_Compare>(__comp._M_comp); } + + template + struct _Val_comp_iter + { + _Compare _M_comp; + + _Val_comp_iter(_Compare __comp) + : _M_comp(__comp) + { } + + template + bool + operator()(_Value& __val, _Iterator __it) + { return bool(_M_comp(__val, *__it)); } + }; + + template + inline _Val_comp_iter<_Compare> + __val_comp_iter(_Compare __comp) + { return _Val_comp_iter<_Compare>(__comp); } + + template + inline _Val_comp_iter<_Compare> + __val_comp_iter(_Iter_comp_iter<_Compare> __comp) + { return _Val_comp_iter<_Compare>(__comp._M_comp); } + + template + struct _Iter_equals_val + { + _Value& _M_value; + + _Iter_equals_val(_Value& __value) + : _M_value(__value) + { } + + template + bool + operator()(_Iterator __it) + { return *__it == _M_value; } + }; + + template + inline _Iter_equals_val<_Value> + __iter_equals_val(_Value& __val) + { return _Iter_equals_val<_Value>(__val); } + + template + struct _Iter_equals_iter + { + typename std::iterator_traits<_Iterator1>::reference _M_ref; + + _Iter_equals_iter(_Iterator1 __it1) + : _M_ref(*__it1) + { } + + template + bool + operator()(_Iterator2 __it2) + { return *__it2 == _M_ref; } + }; + + template + inline _Iter_equals_iter<_Iterator> + __iter_comp_iter(_Iter_equal_to_iter, _Iterator __it) + { return _Iter_equals_iter<_Iterator>(__it); } + + template + struct _Iter_pred + { + _Predicate _M_pred; + + _Iter_pred(_Predicate __pred) + : _M_pred(__pred) + { } + + template + bool + operator()(_Iterator __it) + { return bool(_M_pred(*__it)); } + }; + + template + inline _Iter_pred<_Predicate> + __pred_iter(_Predicate __pred) + { return _Iter_pred<_Predicate>(__pred); } + + template + struct _Iter_comp_to_val + { + _Compare _M_comp; + _Value& _M_value; + + _Iter_comp_to_val(_Compare __comp, _Value& __value) + : _M_comp(__comp), _M_value(__value) + { } + + template + bool + operator()(_Iterator __it) + { return bool(_M_comp(*__it, _M_value)); } + }; + + template + _Iter_comp_to_val<_Compare, _Value> + __iter_comp_val(_Compare __comp, _Value &__val) + { return _Iter_comp_to_val<_Compare, _Value>(__comp, __val); } + + template + struct _Iter_comp_to_iter + { + _Compare _M_comp; + typename std::iterator_traits<_Iterator1>::reference _M_ref; + + _Iter_comp_to_iter(_Compare __comp, _Iterator1 __it1) + : _M_comp(__comp), _M_ref(*__it1) + { } + + template + bool + operator()(_Iterator2 __it2) + { return bool(_M_comp(*__it2, _M_ref)); } + }; + + template + inline _Iter_comp_to_iter<_Compare, _Iterator> + __iter_comp_iter(_Iter_comp_iter<_Compare> __comp, _Iterator __it) + { return _Iter_comp_to_iter<_Compare, _Iterator>(__comp._M_comp, __it); } + + template + struct _Iter_negate + { + _Predicate _M_pred; + + _Iter_negate(_Predicate __pred) + : _M_pred(__pred) + { } + + template + bool + operator()(_Iterator __it) + { return !bool(_M_pred(*__it)); } + }; + + template + inline _Iter_negate<_Predicate> + __negate(_Iter_pred<_Predicate> __pred) + { return _Iter_negate<_Predicate>(__pred._M_pred); } + +} // namespace __ops +} // namespace __gnu_cxx + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/ptr_traits.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/ptr_traits.h new file mode 100755 index 0000000..94995c8 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/ptr_traits.h @@ -0,0 +1,177 @@ +// Pointer Traits -*- C++ -*- + +// Copyright (C) 2011-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file bits/ptr_traits.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{memory} + */ + +#ifndef _PTR_TRAITS_H +#define _PTR_TRAITS_H 1 + +#if __cplusplus >= 201103L + +#include // For _GLIBCXX_HAS_NESTED_TYPE + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + +_GLIBCXX_HAS_NESTED_TYPE(element_type) +_GLIBCXX_HAS_NESTED_TYPE(difference_type) + + template::value> + struct __ptrtr_elt_type; + + template + struct __ptrtr_elt_type<_Tp, true> + { + typedef typename _Tp::element_type __type; + }; + + template class _SomePtr, typename _Tp, + typename... _Args> + struct __ptrtr_elt_type<_SomePtr<_Tp, _Args...>, false> + { + typedef _Tp __type; + }; + + template::value> + struct __ptrtr_diff_type + { + typedef typename _Tp::difference_type __type; + }; + + template + struct __ptrtr_diff_type<_Tp, false> + { + typedef ptrdiff_t __type; + }; + + template + class __ptrtr_rebind_helper + { + template + static constexpr true_type + _S_chk(typename _Ptr2::template rebind<_Up2>*); + + template + static constexpr false_type + _S_chk(...); + + public: + using __type = decltype(_S_chk<_Ptr, _Up>(nullptr)); + }; + + template::__type::value> + struct __ptrtr_rebind; + + template + struct __ptrtr_rebind<_Tp, _Up, true> + { + typedef typename _Tp::template rebind<_Up> __type; + }; + + template class _SomePtr, typename _Up, + typename _Tp, typename... _Args> + struct __ptrtr_rebind<_SomePtr<_Tp, _Args...>, _Up, false> + { + typedef _SomePtr<_Up, _Args...> __type; + }; + + template::type> + struct __ptrtr_not_void + { + typedef _Tp __type; + }; + + template + struct __ptrtr_not_void<_Tp, void> + { + struct __type { }; + }; + + template + class __ptrtr_pointer_to + { + typedef typename __ptrtr_elt_type<_Ptr>::__type __orig_type; + typedef typename __ptrtr_not_void<__orig_type>::__type __element_type; + + public: + static _Ptr pointer_to(__element_type& __e) + { return _Ptr::pointer_to(__e); } + }; + + /** + * @brief Uniform interface to all pointer-like types + * @ingroup pointer_abstractions + */ + template + struct pointer_traits : __ptrtr_pointer_to<_Ptr> + { + /// The pointer type + typedef _Ptr pointer; + /// The type pointed to + typedef typename __ptrtr_elt_type<_Ptr>::__type element_type; + /// Type used to represent the difference between two pointers + typedef typename __ptrtr_diff_type<_Ptr>::__type difference_type; + + template + using rebind = typename __ptrtr_rebind<_Ptr, _Up>::__type; + }; + + /** + * @brief Partial specialization for built-in pointers. + * @ingroup pointer_abstractions + */ + template + struct pointer_traits<_Tp*> + { + /// The pointer type + typedef _Tp* pointer; + /// The type pointed to + typedef _Tp element_type; + /// Type used to represent the difference between two pointers + typedef ptrdiff_t difference_type; + + template + using rebind = _Up*; + + /** + * @brief Obtain a pointer to an object + * @param __r A reference to an object of type @c element_type + * @return @c addressof(__r) + */ + static pointer + pointer_to(typename __ptrtr_not_void::__type& __r) noexcept + { return std::addressof(__r); } + }; + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace std + +#endif + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/random.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/random.h new file mode 100755 index 0000000..b34dbe6 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/random.h @@ -0,0 +1,6071 @@ +// random number generation -*- C++ -*- + +// Copyright (C) 2009-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** + * @file bits/random.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{random} + */ + +#ifndef _RANDOM_H +#define _RANDOM_H 1 + +#include + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + // [26.4] Random number generation + + /** + * @defgroup random Random Number Generation + * @ingroup numerics + * + * A facility for generating random numbers on selected distributions. + * @{ + */ + + /** + * @brief A function template for converting the output of a (integral) + * uniform random number generator to a floatng point result in the range + * [0-1). + */ + template + _RealType + generate_canonical(_UniformRandomNumberGenerator& __g); + +_GLIBCXX_END_NAMESPACE_VERSION + + /* + * Implementation-space details. + */ + namespace __detail + { + _GLIBCXX_BEGIN_NAMESPACE_VERSION + + template + (std::numeric_limits<_UIntType>::digits)> + struct _Shift + { static const _UIntType __value = 0; }; + + template + struct _Shift<_UIntType, __w, true> + { static const _UIntType __value = _UIntType(1) << __w; }; + + template + struct _Select_uint_least_t + { + static_assert(__which < 0, /* needs to be dependent */ + "sorry, would be too much trouble for a slow result"); + }; + + template + struct _Select_uint_least_t<__s, 4> + { typedef unsigned int type; }; + + template + struct _Select_uint_least_t<__s, 3> + { typedef unsigned long type; }; + + template + struct _Select_uint_least_t<__s, 2> + { typedef unsigned long long type; }; + +#ifdef _GLIBCXX_USE_INT128 + template + struct _Select_uint_least_t<__s, 1> + { typedef unsigned __int128 type; }; +#endif + + // Assume a != 0, a < m, c < m, x < m. + template= __m - 1), + bool __schrage_ok = __m % __a < __m / __a> + struct _Mod + { + typedef typename _Select_uint_least_t::type _Tp2; + static _Tp + __calc(_Tp __x) + { return static_cast<_Tp>((_Tp2(__a) * __x + __c) % __m); } + }; + + // Schrage. + template + struct _Mod<_Tp, __m, __a, __c, false, true> + { + static _Tp + __calc(_Tp __x); + }; + + // Special cases: + // - for m == 2^n or m == 0, unsigned integer overflow is safe. + // - a * (m - 1) + c fits in _Tp, there is no overflow. + template + struct _Mod<_Tp, __m, __a, __c, true, __s> + { + static _Tp + __calc(_Tp __x) + { + _Tp __res = __a * __x + __c; + if (__m) + __res %= __m; + return __res; + } + }; + + template + inline _Tp + __mod(_Tp __x) + { return _Mod<_Tp, __m, __a, __c>::__calc(__x); } + + /* Determine whether number is a power of 2. */ + template + inline bool + _Power_of_2(_Tp __x) + { + return ((__x - 1) & __x) == 0; + }; + + /* + * An adaptor class for converting the output of any Generator into + * the input for a specific Distribution. + */ + template + struct _Adaptor + { + static_assert(std::is_floating_point<_DInputType>::value, + "template argument not a floating point type"); + + public: + _Adaptor(_Engine& __g) + : _M_g(__g) { } + + _DInputType + min() const + { return _DInputType(0); } + + _DInputType + max() const + { return _DInputType(1); } + + /* + * Converts a value generated by the adapted random number generator + * into a value in the input domain for the dependent random number + * distribution. + */ + _DInputType + operator()() + { + return std::generate_canonical<_DInputType, + std::numeric_limits<_DInputType>::digits, + _Engine>(_M_g); + } + + private: + _Engine& _M_g; + }; + + _GLIBCXX_END_NAMESPACE_VERSION + } // namespace __detail + +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /** + * @addtogroup random_generators Random Number Generators + * @ingroup random + * + * These classes define objects which provide random or pseudorandom + * numbers, either from a discrete or a continuous interval. The + * random number generator supplied as a part of this library are + * all uniform random number generators which provide a sequence of + * random number uniformly distributed over their range. + * + * A number generator is a function object with an operator() that + * takes zero arguments and returns a number. + * + * A compliant random number generator must satisfy the following + * requirements.
+ * + *
Random Number Generator Requirements
To be documented.
+ * + * @{ + */ + + /** + * @brief A model of a linear congruential random number generator. + * + * A random number generator that produces pseudorandom numbers via + * linear function: + * @f[ + * x_{i+1}\leftarrow(ax_{i} + c) \bmod m + * @f] + * + * The template parameter @p _UIntType must be an unsigned integral type + * large enough to store values up to (__m-1). If the template parameter + * @p __m is 0, the modulus @p __m used is + * std::numeric_limits<_UIntType>::max() plus 1. Otherwise, the template + * parameters @p __a and @p __c must be less than @p __m. + * + * The size of the state is @f$1@f$. + */ + template + class linear_congruential_engine + { + static_assert(std::is_unsigned<_UIntType>::value, "template argument " + "substituting _UIntType not an unsigned integral type"); + static_assert(__m == 0u || (__a < __m && __c < __m), + "template argument substituting __m out of bounds"); + + public: + /** The type of the generated random value. */ + typedef _UIntType result_type; + + /** The multiplier. */ + static constexpr result_type multiplier = __a; + /** An increment. */ + static constexpr result_type increment = __c; + /** The modulus. */ + static constexpr result_type modulus = __m; + static constexpr result_type default_seed = 1u; + + /** + * @brief Constructs a %linear_congruential_engine random number + * generator engine with seed @p __s. The default seed value + * is 1. + * + * @param __s The initial seed value. + */ + explicit + linear_congruential_engine(result_type __s = default_seed) + { seed(__s); } + + /** + * @brief Constructs a %linear_congruential_engine random number + * generator engine seeded from the seed sequence @p __q. + * + * @param __q the seed sequence. + */ + template::value> + ::type> + explicit + linear_congruential_engine(_Sseq& __q) + { seed(__q); } + + /** + * @brief Reseeds the %linear_congruential_engine random number generator + * engine sequence to the seed @p __s. + * + * @param __s The new seed. + */ + void + seed(result_type __s = default_seed); + + /** + * @brief Reseeds the %linear_congruential_engine random number generator + * engine + * sequence using values from the seed sequence @p __q. + * + * @param __q the seed sequence. + */ + template + typename std::enable_if::value>::type + seed(_Sseq& __q); + + /** + * @brief Gets the smallest possible value in the output range. + * + * The minimum depends on the @p __c parameter: if it is zero, the + * minimum generated must be > 0, otherwise 0 is allowed. + */ + static constexpr result_type + min() + { return __c == 0u ? 1u : 0u; } + + /** + * @brief Gets the largest possible value in the output range. + */ + static constexpr result_type + max() + { return __m - 1u; } + + /** + * @brief Discard a sequence of random numbers. + */ + void + discard(unsigned long long __z) + { + for (; __z != 0ULL; --__z) + (*this)(); + } + + /** + * @brief Gets the next random number in the sequence. + */ + result_type + operator()() + { + _M_x = __detail::__mod<_UIntType, __m, __a, __c>(_M_x); + return _M_x; + } + + /** + * @brief Compares two linear congruential random number generator + * objects of the same type for equality. + * + * @param __lhs A linear congruential random number generator object. + * @param __rhs Another linear congruential random number generator + * object. + * + * @returns true if the infinite sequences of generated values + * would be equal, false otherwise. + */ + friend bool + operator==(const linear_congruential_engine& __lhs, + const linear_congruential_engine& __rhs) + { return __lhs._M_x == __rhs._M_x; } + + /** + * @brief Writes the textual representation of the state x(i) of x to + * @p __os. + * + * @param __os The output stream. + * @param __lcr A % linear_congruential_engine random number generator. + * @returns __os. + */ + template + friend std::basic_ostream<_CharT, _Traits>& + operator<<(std::basic_ostream<_CharT, _Traits>& __os, + const std::linear_congruential_engine<_UIntType1, + __a1, __c1, __m1>& __lcr); + + /** + * @brief Sets the state of the engine by reading its textual + * representation from @p __is. + * + * The textual representation must have been previously written using + * an output stream whose imbued locale and whose type's template + * specialization arguments _CharT and _Traits were the same as those + * of @p __is. + * + * @param __is The input stream. + * @param __lcr A % linear_congruential_engine random number generator. + * @returns __is. + */ + template + friend std::basic_istream<_CharT, _Traits>& + operator>>(std::basic_istream<_CharT, _Traits>& __is, + std::linear_congruential_engine<_UIntType1, __a1, + __c1, __m1>& __lcr); + + private: + _UIntType _M_x; + }; + + /** + * @brief Compares two linear congruential random number generator + * objects of the same type for inequality. + * + * @param __lhs A linear congruential random number generator object. + * @param __rhs Another linear congruential random number generator + * object. + * + * @returns true if the infinite sequences of generated values + * would be different, false otherwise. + */ + template + inline bool + operator!=(const std::linear_congruential_engine<_UIntType, __a, + __c, __m>& __lhs, + const std::linear_congruential_engine<_UIntType, __a, + __c, __m>& __rhs) + { return !(__lhs == __rhs); } + + + /** + * A generalized feedback shift register discrete random number generator. + * + * This algorithm avoids multiplication and division and is designed to be + * friendly to a pipelined architecture. If the parameters are chosen + * correctly, this generator will produce numbers with a very long period and + * fairly good apparent entropy, although still not cryptographically strong. + * + * The best way to use this generator is with the predefined mt19937 class. + * + * This algorithm was originally invented by Makoto Matsumoto and + * Takuji Nishimura. + * + * @tparam __w Word size, the number of bits in each element of + * the state vector. + * @tparam __n The degree of recursion. + * @tparam __m The period parameter. + * @tparam __r The separation point bit index. + * @tparam __a The last row of the twist matrix. + * @tparam __u The first right-shift tempering matrix parameter. + * @tparam __d The first right-shift tempering matrix mask. + * @tparam __s The first left-shift tempering matrix parameter. + * @tparam __b The first left-shift tempering matrix mask. + * @tparam __t The second left-shift tempering matrix parameter. + * @tparam __c The second left-shift tempering matrix mask. + * @tparam __l The second right-shift tempering matrix parameter. + * @tparam __f Initialization multiplier. + */ + template + class mersenne_twister_engine + { + static_assert(std::is_unsigned<_UIntType>::value, "template argument " + "substituting _UIntType not an unsigned integral type"); + static_assert(1u <= __m && __m <= __n, + "template argument substituting __m out of bounds"); + static_assert(__r <= __w, "template argument substituting " + "__r out of bound"); + static_assert(__u <= __w, "template argument substituting " + "__u out of bound"); + static_assert(__s <= __w, "template argument substituting " + "__s out of bound"); + static_assert(__t <= __w, "template argument substituting " + "__t out of bound"); + static_assert(__l <= __w, "template argument substituting " + "__l out of bound"); + static_assert(__w <= std::numeric_limits<_UIntType>::digits, + "template argument substituting __w out of bound"); + static_assert(__a <= (__detail::_Shift<_UIntType, __w>::__value - 1), + "template argument substituting __a out of bound"); + static_assert(__b <= (__detail::_Shift<_UIntType, __w>::__value - 1), + "template argument substituting __b out of bound"); + static_assert(__c <= (__detail::_Shift<_UIntType, __w>::__value - 1), + "template argument substituting __c out of bound"); + static_assert(__d <= (__detail::_Shift<_UIntType, __w>::__value - 1), + "template argument substituting __d out of bound"); + static_assert(__f <= (__detail::_Shift<_UIntType, __w>::__value - 1), + "template argument substituting __f out of bound"); + + public: + /** The type of the generated random value. */ + typedef _UIntType result_type; + + // parameter values + static constexpr size_t word_size = __w; + static constexpr size_t state_size = __n; + static constexpr size_t shift_size = __m; + static constexpr size_t mask_bits = __r; + static constexpr result_type xor_mask = __a; + static constexpr size_t tempering_u = __u; + static constexpr result_type tempering_d = __d; + static constexpr size_t tempering_s = __s; + static constexpr result_type tempering_b = __b; + static constexpr size_t tempering_t = __t; + static constexpr result_type tempering_c = __c; + static constexpr size_t tempering_l = __l; + static constexpr result_type initialization_multiplier = __f; + static constexpr result_type default_seed = 5489u; + + // constructors and member function + explicit + mersenne_twister_engine(result_type __sd = default_seed) + { seed(__sd); } + + /** + * @brief Constructs a %mersenne_twister_engine random number generator + * engine seeded from the seed sequence @p __q. + * + * @param __q the seed sequence. + */ + template::value> + ::type> + explicit + mersenne_twister_engine(_Sseq& __q) + { seed(__q); } + + void + seed(result_type __sd = default_seed); + + template + typename std::enable_if::value>::type + seed(_Sseq& __q); + + /** + * @brief Gets the smallest possible value in the output range. + */ + static constexpr result_type + min() + { return 0; }; + + /** + * @brief Gets the largest possible value in the output range. + */ + static constexpr result_type + max() + { return __detail::_Shift<_UIntType, __w>::__value - 1; } + + /** + * @brief Discard a sequence of random numbers. + */ + void + discard(unsigned long long __z); + + result_type + operator()(); + + /** + * @brief Compares two % mersenne_twister_engine random number generator + * objects of the same type for equality. + * + * @param __lhs A % mersenne_twister_engine random number generator + * object. + * @param __rhs Another % mersenne_twister_engine random number + * generator object. + * + * @returns true if the infinite sequences of generated values + * would be equal, false otherwise. + */ + friend bool + operator==(const mersenne_twister_engine& __lhs, + const mersenne_twister_engine& __rhs) + { return (std::equal(__lhs._M_x, __lhs._M_x + state_size, __rhs._M_x) + && __lhs._M_p == __rhs._M_p); } + + /** + * @brief Inserts the current state of a % mersenne_twister_engine + * random number generator engine @p __x into the output stream + * @p __os. + * + * @param __os An output stream. + * @param __x A % mersenne_twister_engine random number generator + * engine. + * + * @returns The output stream with the state of @p __x inserted or in + * an error state. + */ + template + friend std::basic_ostream<_CharT, _Traits>& + operator<<(std::basic_ostream<_CharT, _Traits>& __os, + const std::mersenne_twister_engine<_UIntType1, __w1, __n1, + __m1, __r1, __a1, __u1, __d1, __s1, __b1, __t1, __c1, + __l1, __f1>& __x); + + /** + * @brief Extracts the current state of a % mersenne_twister_engine + * random number generator engine @p __x from the input stream + * @p __is. + * + * @param __is An input stream. + * @param __x A % mersenne_twister_engine random number generator + * engine. + * + * @returns The input stream with the state of @p __x extracted or in + * an error state. + */ + template + friend std::basic_istream<_CharT, _Traits>& + operator>>(std::basic_istream<_CharT, _Traits>& __is, + std::mersenne_twister_engine<_UIntType1, __w1, __n1, __m1, + __r1, __a1, __u1, __d1, __s1, __b1, __t1, __c1, + __l1, __f1>& __x); + + private: + void _M_gen_rand(); + + _UIntType _M_x[state_size]; + size_t _M_p; + }; + + /** + * @brief Compares two % mersenne_twister_engine random number generator + * objects of the same type for inequality. + * + * @param __lhs A % mersenne_twister_engine random number generator + * object. + * @param __rhs Another % mersenne_twister_engine random number + * generator object. + * + * @returns true if the infinite sequences of generated values + * would be different, false otherwise. + */ + template + inline bool + operator!=(const std::mersenne_twister_engine<_UIntType, __w, __n, __m, + __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>& __lhs, + const std::mersenne_twister_engine<_UIntType, __w, __n, __m, + __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>& __rhs) + { return !(__lhs == __rhs); } + + + /** + * @brief The Marsaglia-Zaman generator. + * + * This is a model of a Generalized Fibonacci discrete random number + * generator, sometimes referred to as the SWC generator. + * + * A discrete random number generator that produces pseudorandom + * numbers using: + * @f[ + * x_{i}\leftarrow(x_{i - s} - x_{i - r} - carry_{i-1}) \bmod m + * @f] + * + * The size of the state is @f$r@f$ + * and the maximum period of the generator is @f$(m^r - m^s - 1)@f$. + * + * @var _M_x The state of the generator. This is a ring buffer. + * @var _M_carry The carry. + * @var _M_p Current index of x(i - r). + */ + template + class subtract_with_carry_engine + { + static_assert(std::is_unsigned<_UIntType>::value, "template argument " + "substituting _UIntType not an unsigned integral type"); + static_assert(0u < __s && __s < __r, + "template argument substituting __s out of bounds"); + static_assert(0u < __w && __w <= std::numeric_limits<_UIntType>::digits, + "template argument substituting __w out of bounds"); + + public: + /** The type of the generated random value. */ + typedef _UIntType result_type; + + // parameter values + static constexpr size_t word_size = __w; + static constexpr size_t short_lag = __s; + static constexpr size_t long_lag = __r; + static constexpr result_type default_seed = 19780503u; + + /** + * @brief Constructs an explicitly seeded % subtract_with_carry_engine + * random number generator. + */ + explicit + subtract_with_carry_engine(result_type __sd = default_seed) + { seed(__sd); } + + /** + * @brief Constructs a %subtract_with_carry_engine random number engine + * seeded from the seed sequence @p __q. + * + * @param __q the seed sequence. + */ + template::value> + ::type> + explicit + subtract_with_carry_engine(_Sseq& __q) + { seed(__q); } + + /** + * @brief Seeds the initial state @f$x_0@f$ of the random number + * generator. + * + * N1688[4.19] modifies this as follows. If @p __value == 0, + * sets value to 19780503. In any case, with a linear + * congruential generator lcg(i) having parameters @f$ m_{lcg} = + * 2147483563, a_{lcg} = 40014, c_{lcg} = 0, and lcg(0) = value + * @f$, sets @f$ x_{-r} \dots x_{-1} @f$ to @f$ lcg(1) \bmod m + * \dots lcg(r) \bmod m @f$ respectively. If @f$ x_{-1} = 0 @f$ + * set carry to 1, otherwise sets carry to 0. + */ + void + seed(result_type __sd = default_seed); + + /** + * @brief Seeds the initial state @f$x_0@f$ of the + * % subtract_with_carry_engine random number generator. + */ + template + typename std::enable_if::value>::type + seed(_Sseq& __q); + + /** + * @brief Gets the inclusive minimum value of the range of random + * integers returned by this generator. + */ + static constexpr result_type + min() + { return 0; } + + /** + * @brief Gets the inclusive maximum value of the range of random + * integers returned by this generator. + */ + static constexpr result_type + max() + { return __detail::_Shift<_UIntType, __w>::__value - 1; } + + /** + * @brief Discard a sequence of random numbers. + */ + void + discard(unsigned long long __z) + { + for (; __z != 0ULL; --__z) + (*this)(); + } + + /** + * @brief Gets the next random number in the sequence. + */ + result_type + operator()(); + + /** + * @brief Compares two % subtract_with_carry_engine random number + * generator objects of the same type for equality. + * + * @param __lhs A % subtract_with_carry_engine random number generator + * object. + * @param __rhs Another % subtract_with_carry_engine random number + * generator object. + * + * @returns true if the infinite sequences of generated values + * would be equal, false otherwise. + */ + friend bool + operator==(const subtract_with_carry_engine& __lhs, + const subtract_with_carry_engine& __rhs) + { return (std::equal(__lhs._M_x, __lhs._M_x + long_lag, __rhs._M_x) + && __lhs._M_carry == __rhs._M_carry + && __lhs._M_p == __rhs._M_p); } + + /** + * @brief Inserts the current state of a % subtract_with_carry_engine + * random number generator engine @p __x into the output stream + * @p __os. + * + * @param __os An output stream. + * @param __x A % subtract_with_carry_engine random number generator + * engine. + * + * @returns The output stream with the state of @p __x inserted or in + * an error state. + */ + template + friend std::basic_ostream<_CharT, _Traits>& + operator<<(std::basic_ostream<_CharT, _Traits>&, + const std::subtract_with_carry_engine<_UIntType1, __w1, + __s1, __r1>&); + + /** + * @brief Extracts the current state of a % subtract_with_carry_engine + * random number generator engine @p __x from the input stream + * @p __is. + * + * @param __is An input stream. + * @param __x A % subtract_with_carry_engine random number generator + * engine. + * + * @returns The input stream with the state of @p __x extracted or in + * an error state. + */ + template + friend std::basic_istream<_CharT, _Traits>& + operator>>(std::basic_istream<_CharT, _Traits>&, + std::subtract_with_carry_engine<_UIntType1, __w1, + __s1, __r1>&); + + private: + _UIntType _M_x[long_lag]; + _UIntType _M_carry; + size_t _M_p; + }; + + /** + * @brief Compares two % subtract_with_carry_engine random number + * generator objects of the same type for inequality. + * + * @param __lhs A % subtract_with_carry_engine random number generator + * object. + * @param __rhs Another % subtract_with_carry_engine random number + * generator object. + * + * @returns true if the infinite sequences of generated values + * would be different, false otherwise. + */ + template + inline bool + operator!=(const std::subtract_with_carry_engine<_UIntType, __w, + __s, __r>& __lhs, + const std::subtract_with_carry_engine<_UIntType, __w, + __s, __r>& __rhs) + { return !(__lhs == __rhs); } + + + /** + * Produces random numbers from some base engine by discarding blocks of + * data. + * + * 0 <= @p __r <= @p __p + */ + template + class discard_block_engine + { + static_assert(1 <= __r && __r <= __p, + "template argument substituting __r out of bounds"); + + public: + /** The type of the generated random value. */ + typedef typename _RandomNumberEngine::result_type result_type; + + // parameter values + static constexpr size_t block_size = __p; + static constexpr size_t used_block = __r; + + /** + * @brief Constructs a default %discard_block_engine engine. + * + * The underlying engine is default constructed as well. + */ + discard_block_engine() + : _M_b(), _M_n(0) { } + + /** + * @brief Copy constructs a %discard_block_engine engine. + * + * Copies an existing base class random number generator. + * @param __rng An existing (base class) engine object. + */ + explicit + discard_block_engine(const _RandomNumberEngine& __rng) + : _M_b(__rng), _M_n(0) { } + + /** + * @brief Move constructs a %discard_block_engine engine. + * + * Copies an existing base class random number generator. + * @param __rng An existing (base class) engine object. + */ + explicit + discard_block_engine(_RandomNumberEngine&& __rng) + : _M_b(std::move(__rng)), _M_n(0) { } + + /** + * @brief Seed constructs a %discard_block_engine engine. + * + * Constructs the underlying generator engine seeded with @p __s. + * @param __s A seed value for the base class engine. + */ + explicit + discard_block_engine(result_type __s) + : _M_b(__s), _M_n(0) { } + + /** + * @brief Generator construct a %discard_block_engine engine. + * + * @param __q A seed sequence. + */ + template::value + && !std::is_same<_Sseq, _RandomNumberEngine>::value> + ::type> + explicit + discard_block_engine(_Sseq& __q) + : _M_b(__q), _M_n(0) + { } + + /** + * @brief Reseeds the %discard_block_engine object with the default + * seed for the underlying base class generator engine. + */ + void + seed() + { + _M_b.seed(); + _M_n = 0; + } + + /** + * @brief Reseeds the %discard_block_engine object with the default + * seed for the underlying base class generator engine. + */ + void + seed(result_type __s) + { + _M_b.seed(__s); + _M_n = 0; + } + + /** + * @brief Reseeds the %discard_block_engine object with the given seed + * sequence. + * @param __q A seed generator function. + */ + template + void + seed(_Sseq& __q) + { + _M_b.seed(__q); + _M_n = 0; + } + + /** + * @brief Gets a const reference to the underlying generator engine + * object. + */ + const _RandomNumberEngine& + base() const noexcept + { return _M_b; } + + /** + * @brief Gets the minimum value in the generated random number range. + */ + static constexpr result_type + min() + { return _RandomNumberEngine::min(); } + + /** + * @brief Gets the maximum value in the generated random number range. + */ + static constexpr result_type + max() + { return _RandomNumberEngine::max(); } + + /** + * @brief Discard a sequence of random numbers. + */ + void + discard(unsigned long long __z) + { + for (; __z != 0ULL; --__z) + (*this)(); + } + + /** + * @brief Gets the next value in the generated random number sequence. + */ + result_type + operator()(); + + /** + * @brief Compares two %discard_block_engine random number generator + * objects of the same type for equality. + * + * @param __lhs A %discard_block_engine random number generator object. + * @param __rhs Another %discard_block_engine random number generator + * object. + * + * @returns true if the infinite sequences of generated values + * would be equal, false otherwise. + */ + friend bool + operator==(const discard_block_engine& __lhs, + const discard_block_engine& __rhs) + { return __lhs._M_b == __rhs._M_b && __lhs._M_n == __rhs._M_n; } + + /** + * @brief Inserts the current state of a %discard_block_engine random + * number generator engine @p __x into the output stream + * @p __os. + * + * @param __os An output stream. + * @param __x A %discard_block_engine random number generator engine. + * + * @returns The output stream with the state of @p __x inserted or in + * an error state. + */ + template + friend std::basic_ostream<_CharT, _Traits>& + operator<<(std::basic_ostream<_CharT, _Traits>& __os, + const std::discard_block_engine<_RandomNumberEngine1, + __p1, __r1>& __x); + + /** + * @brief Extracts the current state of a % subtract_with_carry_engine + * random number generator engine @p __x from the input stream + * @p __is. + * + * @param __is An input stream. + * @param __x A %discard_block_engine random number generator engine. + * + * @returns The input stream with the state of @p __x extracted or in + * an error state. + */ + template + friend std::basic_istream<_CharT, _Traits>& + operator>>(std::basic_istream<_CharT, _Traits>& __is, + std::discard_block_engine<_RandomNumberEngine1, + __p1, __r1>& __x); + + private: + _RandomNumberEngine _M_b; + size_t _M_n; + }; + + /** + * @brief Compares two %discard_block_engine random number generator + * objects of the same type for inequality. + * + * @param __lhs A %discard_block_engine random number generator object. + * @param __rhs Another %discard_block_engine random number generator + * object. + * + * @returns true if the infinite sequences of generated values + * would be different, false otherwise. + */ + template + inline bool + operator!=(const std::discard_block_engine<_RandomNumberEngine, __p, + __r>& __lhs, + const std::discard_block_engine<_RandomNumberEngine, __p, + __r>& __rhs) + { return !(__lhs == __rhs); } + + + /** + * Produces random numbers by combining random numbers from some base + * engine to produce random numbers with a specifies number of bits @p __w. + */ + template + class independent_bits_engine + { + static_assert(std::is_unsigned<_UIntType>::value, "template argument " + "substituting _UIntType not an unsigned integral type"); + static_assert(0u < __w && __w <= std::numeric_limits<_UIntType>::digits, + "template argument substituting __w out of bounds"); + + public: + /** The type of the generated random value. */ + typedef _UIntType result_type; + + /** + * @brief Constructs a default %independent_bits_engine engine. + * + * The underlying engine is default constructed as well. + */ + independent_bits_engine() + : _M_b() { } + + /** + * @brief Copy constructs a %independent_bits_engine engine. + * + * Copies an existing base class random number generator. + * @param __rng An existing (base class) engine object. + */ + explicit + independent_bits_engine(const _RandomNumberEngine& __rng) + : _M_b(__rng) { } + + /** + * @brief Move constructs a %independent_bits_engine engine. + * + * Copies an existing base class random number generator. + * @param __rng An existing (base class) engine object. + */ + explicit + independent_bits_engine(_RandomNumberEngine&& __rng) + : _M_b(std::move(__rng)) { } + + /** + * @brief Seed constructs a %independent_bits_engine engine. + * + * Constructs the underlying generator engine seeded with @p __s. + * @param __s A seed value for the base class engine. + */ + explicit + independent_bits_engine(result_type __s) + : _M_b(__s) { } + + /** + * @brief Generator construct a %independent_bits_engine engine. + * + * @param __q A seed sequence. + */ + template::value + && !std::is_same<_Sseq, _RandomNumberEngine>::value> + ::type> + explicit + independent_bits_engine(_Sseq& __q) + : _M_b(__q) + { } + + /** + * @brief Reseeds the %independent_bits_engine object with the default + * seed for the underlying base class generator engine. + */ + void + seed() + { _M_b.seed(); } + + /** + * @brief Reseeds the %independent_bits_engine object with the default + * seed for the underlying base class generator engine. + */ + void + seed(result_type __s) + { _M_b.seed(__s); } + + /** + * @brief Reseeds the %independent_bits_engine object with the given + * seed sequence. + * @param __q A seed generator function. + */ + template + void + seed(_Sseq& __q) + { _M_b.seed(__q); } + + /** + * @brief Gets a const reference to the underlying generator engine + * object. + */ + const _RandomNumberEngine& + base() const noexcept + { return _M_b; } + + /** + * @brief Gets the minimum value in the generated random number range. + */ + static constexpr result_type + min() + { return 0U; } + + /** + * @brief Gets the maximum value in the generated random number range. + */ + static constexpr result_type + max() + { return __detail::_Shift<_UIntType, __w>::__value - 1; } + + /** + * @brief Discard a sequence of random numbers. + */ + void + discard(unsigned long long __z) + { + for (; __z != 0ULL; --__z) + (*this)(); + } + + /** + * @brief Gets the next value in the generated random number sequence. + */ + result_type + operator()(); + + /** + * @brief Compares two %independent_bits_engine random number generator + * objects of the same type for equality. + * + * @param __lhs A %independent_bits_engine random number generator + * object. + * @param __rhs Another %independent_bits_engine random number generator + * object. + * + * @returns true if the infinite sequences of generated values + * would be equal, false otherwise. + */ + friend bool + operator==(const independent_bits_engine& __lhs, + const independent_bits_engine& __rhs) + { return __lhs._M_b == __rhs._M_b; } + + /** + * @brief Extracts the current state of a % subtract_with_carry_engine + * random number generator engine @p __x from the input stream + * @p __is. + * + * @param __is An input stream. + * @param __x A %independent_bits_engine random number generator + * engine. + * + * @returns The input stream with the state of @p __x extracted or in + * an error state. + */ + template + friend std::basic_istream<_CharT, _Traits>& + operator>>(std::basic_istream<_CharT, _Traits>& __is, + std::independent_bits_engine<_RandomNumberEngine, + __w, _UIntType>& __x) + { + __is >> __x._M_b; + return __is; + } + + private: + _RandomNumberEngine _M_b; + }; + + /** + * @brief Compares two %independent_bits_engine random number generator + * objects of the same type for inequality. + * + * @param __lhs A %independent_bits_engine random number generator + * object. + * @param __rhs Another %independent_bits_engine random number generator + * object. + * + * @returns true if the infinite sequences of generated values + * would be different, false otherwise. + */ + template + inline bool + operator!=(const std::independent_bits_engine<_RandomNumberEngine, __w, + _UIntType>& __lhs, + const std::independent_bits_engine<_RandomNumberEngine, __w, + _UIntType>& __rhs) + { return !(__lhs == __rhs); } + + /** + * @brief Inserts the current state of a %independent_bits_engine random + * number generator engine @p __x into the output stream @p __os. + * + * @param __os An output stream. + * @param __x A %independent_bits_engine random number generator engine. + * + * @returns The output stream with the state of @p __x inserted or in + * an error state. + */ + template + std::basic_ostream<_CharT, _Traits>& + operator<<(std::basic_ostream<_CharT, _Traits>& __os, + const std::independent_bits_engine<_RandomNumberEngine, + __w, _UIntType>& __x) + { + __os << __x.base(); + return __os; + } + + + /** + * @brief Produces random numbers by combining random numbers from some + * base engine to produce random numbers with a specifies number of bits + * @p __w. + */ + template + class shuffle_order_engine + { + static_assert(1u <= __k, "template argument substituting " + "__k out of bound"); + + public: + /** The type of the generated random value. */ + typedef typename _RandomNumberEngine::result_type result_type; + + static constexpr size_t table_size = __k; + + /** + * @brief Constructs a default %shuffle_order_engine engine. + * + * The underlying engine is default constructed as well. + */ + shuffle_order_engine() + : _M_b() + { _M_initialize(); } + + /** + * @brief Copy constructs a %shuffle_order_engine engine. + * + * Copies an existing base class random number generator. + * @param __rng An existing (base class) engine object. + */ + explicit + shuffle_order_engine(const _RandomNumberEngine& __rng) + : _M_b(__rng) + { _M_initialize(); } + + /** + * @brief Move constructs a %shuffle_order_engine engine. + * + * Copies an existing base class random number generator. + * @param __rng An existing (base class) engine object. + */ + explicit + shuffle_order_engine(_RandomNumberEngine&& __rng) + : _M_b(std::move(__rng)) + { _M_initialize(); } + + /** + * @brief Seed constructs a %shuffle_order_engine engine. + * + * Constructs the underlying generator engine seeded with @p __s. + * @param __s A seed value for the base class engine. + */ + explicit + shuffle_order_engine(result_type __s) + : _M_b(__s) + { _M_initialize(); } + + /** + * @brief Generator construct a %shuffle_order_engine engine. + * + * @param __q A seed sequence. + */ + template::value + && !std::is_same<_Sseq, _RandomNumberEngine>::value> + ::type> + explicit + shuffle_order_engine(_Sseq& __q) + : _M_b(__q) + { _M_initialize(); } + + /** + * @brief Reseeds the %shuffle_order_engine object with the default seed + for the underlying base class generator engine. + */ + void + seed() + { + _M_b.seed(); + _M_initialize(); + } + + /** + * @brief Reseeds the %shuffle_order_engine object with the default seed + * for the underlying base class generator engine. + */ + void + seed(result_type __s) + { + _M_b.seed(__s); + _M_initialize(); + } + + /** + * @brief Reseeds the %shuffle_order_engine object with the given seed + * sequence. + * @param __q A seed generator function. + */ + template + void + seed(_Sseq& __q) + { + _M_b.seed(__q); + _M_initialize(); + } + + /** + * Gets a const reference to the underlying generator engine object. + */ + const _RandomNumberEngine& + base() const noexcept + { return _M_b; } + + /** + * Gets the minimum value in the generated random number range. + */ + static constexpr result_type + min() + { return _RandomNumberEngine::min(); } + + /** + * Gets the maximum value in the generated random number range. + */ + static constexpr result_type + max() + { return _RandomNumberEngine::max(); } + + /** + * Discard a sequence of random numbers. + */ + void + discard(unsigned long long __z) + { + for (; __z != 0ULL; --__z) + (*this)(); + } + + /** + * Gets the next value in the generated random number sequence. + */ + result_type + operator()(); + + /** + * Compares two %shuffle_order_engine random number generator objects + * of the same type for equality. + * + * @param __lhs A %shuffle_order_engine random number generator object. + * @param __rhs Another %shuffle_order_engine random number generator + * object. + * + * @returns true if the infinite sequences of generated values + * would be equal, false otherwise. + */ + friend bool + operator==(const shuffle_order_engine& __lhs, + const shuffle_order_engine& __rhs) + { return (__lhs._M_b == __rhs._M_b + && std::equal(__lhs._M_v, __lhs._M_v + __k, __rhs._M_v) + && __lhs._M_y == __rhs._M_y); } + + /** + * @brief Inserts the current state of a %shuffle_order_engine random + * number generator engine @p __x into the output stream + @p __os. + * + * @param __os An output stream. + * @param __x A %shuffle_order_engine random number generator engine. + * + * @returns The output stream with the state of @p __x inserted or in + * an error state. + */ + template + friend std::basic_ostream<_CharT, _Traits>& + operator<<(std::basic_ostream<_CharT, _Traits>& __os, + const std::shuffle_order_engine<_RandomNumberEngine1, + __k1>& __x); + + /** + * @brief Extracts the current state of a % subtract_with_carry_engine + * random number generator engine @p __x from the input stream + * @p __is. + * + * @param __is An input stream. + * @param __x A %shuffle_order_engine random number generator engine. + * + * @returns The input stream with the state of @p __x extracted or in + * an error state. + */ + template + friend std::basic_istream<_CharT, _Traits>& + operator>>(std::basic_istream<_CharT, _Traits>& __is, + std::shuffle_order_engine<_RandomNumberEngine1, __k1>& __x); + + private: + void _M_initialize() + { + for (size_t __i = 0; __i < __k; ++__i) + _M_v[__i] = _M_b(); + _M_y = _M_b(); + } + + _RandomNumberEngine _M_b; + result_type _M_v[__k]; + result_type _M_y; + }; + + /** + * Compares two %shuffle_order_engine random number generator objects + * of the same type for inequality. + * + * @param __lhs A %shuffle_order_engine random number generator object. + * @param __rhs Another %shuffle_order_engine random number generator + * object. + * + * @returns true if the infinite sequences of generated values + * would be different, false otherwise. + */ + template + inline bool + operator!=(const std::shuffle_order_engine<_RandomNumberEngine, + __k>& __lhs, + const std::shuffle_order_engine<_RandomNumberEngine, + __k>& __rhs) + { return !(__lhs == __rhs); } + + + /** + * The classic Minimum Standard rand0 of Lewis, Goodman, and Miller. + */ + typedef linear_congruential_engine + minstd_rand0; + + /** + * An alternative LCR (Lehmer Generator function). + */ + typedef linear_congruential_engine + minstd_rand; + + /** + * The classic Mersenne Twister. + * + * Reference: + * M. Matsumoto and T. Nishimura, Mersenne Twister: A 623-Dimensionally + * Equidistributed Uniform Pseudo-Random Number Generator, ACM Transactions + * on Modeling and Computer Simulation, Vol. 8, No. 1, January 1998, pp 3-30. + */ + typedef mersenne_twister_engine< + uint_fast32_t, + 32, 624, 397, 31, + 0x9908b0dfUL, 11, + 0xffffffffUL, 7, + 0x9d2c5680UL, 15, + 0xefc60000UL, 18, 1812433253UL> mt19937; + + /** + * An alternative Mersenne Twister. + */ + typedef mersenne_twister_engine< + uint_fast64_t, + 64, 312, 156, 31, + 0xb5026f5aa96619e9ULL, 29, + 0x5555555555555555ULL, 17, + 0x71d67fffeda60000ULL, 37, + 0xfff7eee000000000ULL, 43, + 6364136223846793005ULL> mt19937_64; + + typedef subtract_with_carry_engine + ranlux24_base; + + typedef subtract_with_carry_engine + ranlux48_base; + + typedef discard_block_engine ranlux24; + + typedef discard_block_engine ranlux48; + + typedef shuffle_order_engine knuth_b; + + typedef minstd_rand0 default_random_engine; + + /** + * A standard interface to a platform-specific non-deterministic + * random number generator (if any are available). + */ + class random_device + { + public: + /** The type of the generated random value. */ + typedef unsigned int result_type; + + // constructors, destructors and member functions + +#ifdef _GLIBCXX_USE_RANDOM_TR1 + + explicit + random_device(const std::string& __token = "default") + { + _M_init(__token); + } + + ~random_device() + { _M_fini(); } + +#else + + explicit + random_device(const std::string& __token = "mt19937") + { _M_init_pretr1(__token); } + + public: + +#endif + + static constexpr result_type + min() + { return std::numeric_limits::min(); } + + static constexpr result_type + max() + { return std::numeric_limits::max(); } + + double + entropy() const noexcept + { return 0.0; } + + result_type + operator()() + { +#ifdef _GLIBCXX_USE_RANDOM_TR1 + return this->_M_getval(); +#else + return this->_M_getval_pretr1(); +#endif + } + + // No copy functions. + random_device(const random_device&) = delete; + void operator=(const random_device&) = delete; + + private: + + void _M_init(const std::string& __token); + void _M_init_pretr1(const std::string& __token); + void _M_fini(); + + result_type _M_getval(); + result_type _M_getval_pretr1(); + + union + { + void* _M_file; + mt19937 _M_mt; + }; + }; + + /* @} */ // group random_generators + + /** + * @addtogroup random_distributions Random Number Distributions + * @ingroup random + * @{ + */ + + /** + * @addtogroup random_distributions_uniform Uniform Distributions + * @ingroup random_distributions + * @{ + */ + + /** + * @brief Uniform discrete distribution for random numbers. + * A discrete random distribution on the range @f$[min, max]@f$ with equal + * probability throughout the range. + */ + template + class uniform_int_distribution + { + static_assert(std::is_integral<_IntType>::value, + "template argument not an integral type"); + + public: + /** The type of the range of the distribution. */ + typedef _IntType result_type; + /** Parameter type. */ + struct param_type + { + typedef uniform_int_distribution<_IntType> distribution_type; + + explicit + param_type(_IntType __a = 0, + _IntType __b = std::numeric_limits<_IntType>::max()) + : _M_a(__a), _M_b(__b) + { + _GLIBCXX_DEBUG_ASSERT(_M_a <= _M_b); + } + + result_type + a() const + { return _M_a; } + + result_type + b() const + { return _M_b; } + + friend bool + operator==(const param_type& __p1, const param_type& __p2) + { return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; } + + private: + _IntType _M_a; + _IntType _M_b; + }; + + public: + /** + * @brief Constructs a uniform distribution object. + */ + explicit + uniform_int_distribution(_IntType __a = 0, + _IntType __b = std::numeric_limits<_IntType>::max()) + : _M_param(__a, __b) + { } + + explicit + uniform_int_distribution(const param_type& __p) + : _M_param(__p) + { } + + /** + * @brief Resets the distribution state. + * + * Does nothing for the uniform integer distribution. + */ + void + reset() { } + + result_type + a() const + { return _M_param.a(); } + + result_type + b() const + { return _M_param.b(); } + + /** + * @brief Returns the parameter set of the distribution. + */ + param_type + param() const + { return _M_param; } + + /** + * @brief Sets the parameter set of the distribution. + * @param __param The new parameter set of the distribution. + */ + void + param(const param_type& __param) + { _M_param = __param; } + + /** + * @brief Returns the inclusive lower bound of the distribution range. + */ + result_type + min() const + { return this->a(); } + + /** + * @brief Returns the inclusive upper bound of the distribution range. + */ + result_type + max() const + { return this->b(); } + + /** + * @brief Generating functions. + */ + template + result_type + operator()(_UniformRandomNumberGenerator& __urng) + { return this->operator()(__urng, _M_param); } + + template + result_type + operator()(_UniformRandomNumberGenerator& __urng, + const param_type& __p); + + template + void + __generate(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng) + { this->__generate(__f, __t, __urng, _M_param); } + + template + void + __generate(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __p) + { this->__generate_impl(__f, __t, __urng, __p); } + + template + void + __generate(result_type* __f, result_type* __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __p) + { this->__generate_impl(__f, __t, __urng, __p); } + + /** + * @brief Return true if two uniform integer distributions have + * the same parameters. + */ + friend bool + operator==(const uniform_int_distribution& __d1, + const uniform_int_distribution& __d2) + { return __d1._M_param == __d2._M_param; } + + private: + template + void + __generate_impl(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __p); + + param_type _M_param; + }; + + /** + * @brief Return true if two uniform integer distributions have + * different parameters. + */ + template + inline bool + operator!=(const std::uniform_int_distribution<_IntType>& __d1, + const std::uniform_int_distribution<_IntType>& __d2) + { return !(__d1 == __d2); } + + /** + * @brief Inserts a %uniform_int_distribution random number + * distribution @p __x into the output stream @p os. + * + * @param __os An output stream. + * @param __x A %uniform_int_distribution random number distribution. + * + * @returns The output stream with the state of @p __x inserted or in + * an error state. + */ + template + std::basic_ostream<_CharT, _Traits>& + operator<<(std::basic_ostream<_CharT, _Traits>&, + const std::uniform_int_distribution<_IntType>&); + + /** + * @brief Extracts a %uniform_int_distribution random number distribution + * @p __x from the input stream @p __is. + * + * @param __is An input stream. + * @param __x A %uniform_int_distribution random number generator engine. + * + * @returns The input stream with @p __x extracted or in an error state. + */ + template + std::basic_istream<_CharT, _Traits>& + operator>>(std::basic_istream<_CharT, _Traits>&, + std::uniform_int_distribution<_IntType>&); + + + /** + * @brief Uniform continuous distribution for random numbers. + * + * A continuous random distribution on the range [min, max) with equal + * probability throughout the range. The URNG should be real-valued and + * deliver number in the range [0, 1). + */ + template + class uniform_real_distribution + { + static_assert(std::is_floating_point<_RealType>::value, + "template argument not a floating point type"); + + public: + /** The type of the range of the distribution. */ + typedef _RealType result_type; + /** Parameter type. */ + struct param_type + { + typedef uniform_real_distribution<_RealType> distribution_type; + + explicit + param_type(_RealType __a = _RealType(0), + _RealType __b = _RealType(1)) + : _M_a(__a), _M_b(__b) + { + _GLIBCXX_DEBUG_ASSERT(_M_a <= _M_b); + } + + result_type + a() const + { return _M_a; } + + result_type + b() const + { return _M_b; } + + friend bool + operator==(const param_type& __p1, const param_type& __p2) + { return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; } + + private: + _RealType _M_a; + _RealType _M_b; + }; + + public: + /** + * @brief Constructs a uniform_real_distribution object. + * + * @param __a [IN] The lower bound of the distribution. + * @param __b [IN] The upper bound of the distribution. + */ + explicit + uniform_real_distribution(_RealType __a = _RealType(0), + _RealType __b = _RealType(1)) + : _M_param(__a, __b) + { } + + explicit + uniform_real_distribution(const param_type& __p) + : _M_param(__p) + { } + + /** + * @brief Resets the distribution state. + * + * Does nothing for the uniform real distribution. + */ + void + reset() { } + + result_type + a() const + { return _M_param.a(); } + + result_type + b() const + { return _M_param.b(); } + + /** + * @brief Returns the parameter set of the distribution. + */ + param_type + param() const + { return _M_param; } + + /** + * @brief Sets the parameter set of the distribution. + * @param __param The new parameter set of the distribution. + */ + void + param(const param_type& __param) + { _M_param = __param; } + + /** + * @brief Returns the inclusive lower bound of the distribution range. + */ + result_type + min() const + { return this->a(); } + + /** + * @brief Returns the inclusive upper bound of the distribution range. + */ + result_type + max() const + { return this->b(); } + + /** + * @brief Generating functions. + */ + template + result_type + operator()(_UniformRandomNumberGenerator& __urng) + { return this->operator()(__urng, _M_param); } + + template + result_type + operator()(_UniformRandomNumberGenerator& __urng, + const param_type& __p) + { + __detail::_Adaptor<_UniformRandomNumberGenerator, result_type> + __aurng(__urng); + return (__aurng() * (__p.b() - __p.a())) + __p.a(); + } + + template + void + __generate(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng) + { this->__generate(__f, __t, __urng, _M_param); } + + template + void + __generate(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __p) + { this->__generate_impl(__f, __t, __urng, __p); } + + template + void + __generate(result_type* __f, result_type* __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __p) + { this->__generate_impl(__f, __t, __urng, __p); } + + /** + * @brief Return true if two uniform real distributions have + * the same parameters. + */ + friend bool + operator==(const uniform_real_distribution& __d1, + const uniform_real_distribution& __d2) + { return __d1._M_param == __d2._M_param; } + + private: + template + void + __generate_impl(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __p); + + param_type _M_param; + }; + + /** + * @brief Return true if two uniform real distributions have + * different parameters. + */ + template + inline bool + operator!=(const std::uniform_real_distribution<_IntType>& __d1, + const std::uniform_real_distribution<_IntType>& __d2) + { return !(__d1 == __d2); } + + /** + * @brief Inserts a %uniform_real_distribution random number + * distribution @p __x into the output stream @p __os. + * + * @param __os An output stream. + * @param __x A %uniform_real_distribution random number distribution. + * + * @returns The output stream with the state of @p __x inserted or in + * an error state. + */ + template + std::basic_ostream<_CharT, _Traits>& + operator<<(std::basic_ostream<_CharT, _Traits>&, + const std::uniform_real_distribution<_RealType>&); + + /** + * @brief Extracts a %uniform_real_distribution random number distribution + * @p __x from the input stream @p __is. + * + * @param __is An input stream. + * @param __x A %uniform_real_distribution random number generator engine. + * + * @returns The input stream with @p __x extracted or in an error state. + */ + template + std::basic_istream<_CharT, _Traits>& + operator>>(std::basic_istream<_CharT, _Traits>&, + std::uniform_real_distribution<_RealType>&); + + /* @} */ // group random_distributions_uniform + + /** + * @addtogroup random_distributions_normal Normal Distributions + * @ingroup random_distributions + * @{ + */ + + /** + * @brief A normal continuous distribution for random numbers. + * + * The formula for the normal probability density function is + * @f[ + * p(x|\mu,\sigma) = \frac{1}{\sigma \sqrt{2 \pi}} + * e^{- \frac{{x - \mu}^ {2}}{2 \sigma ^ {2}} } + * @f] + */ + template + class normal_distribution + { + static_assert(std::is_floating_point<_RealType>::value, + "template argument not a floating point type"); + + public: + /** The type of the range of the distribution. */ + typedef _RealType result_type; + /** Parameter type. */ + struct param_type + { + typedef normal_distribution<_RealType> distribution_type; + + explicit + param_type(_RealType __mean = _RealType(0), + _RealType __stddev = _RealType(1)) + : _M_mean(__mean), _M_stddev(__stddev) + { + _GLIBCXX_DEBUG_ASSERT(_M_stddev > _RealType(0)); + } + + _RealType + mean() const + { return _M_mean; } + + _RealType + stddev() const + { return _M_stddev; } + + friend bool + operator==(const param_type& __p1, const param_type& __p2) + { return (__p1._M_mean == __p2._M_mean + && __p1._M_stddev == __p2._M_stddev); } + + private: + _RealType _M_mean; + _RealType _M_stddev; + }; + + public: + /** + * Constructs a normal distribution with parameters @f$mean@f$ and + * standard deviation. + */ + explicit + normal_distribution(result_type __mean = result_type(0), + result_type __stddev = result_type(1)) + : _M_param(__mean, __stddev), _M_saved_available(false) + { } + + explicit + normal_distribution(const param_type& __p) + : _M_param(__p), _M_saved_available(false) + { } + + /** + * @brief Resets the distribution state. + */ + void + reset() + { _M_saved_available = false; } + + /** + * @brief Returns the mean of the distribution. + */ + _RealType + mean() const + { return _M_param.mean(); } + + /** + * @brief Returns the standard deviation of the distribution. + */ + _RealType + stddev() const + { return _M_param.stddev(); } + + /** + * @brief Returns the parameter set of the distribution. + */ + param_type + param() const + { return _M_param; } + + /** + * @brief Sets the parameter set of the distribution. + * @param __param The new parameter set of the distribution. + */ + void + param(const param_type& __param) + { _M_param = __param; } + + /** + * @brief Returns the greatest lower bound value of the distribution. + */ + result_type + min() const + { return std::numeric_limits::lowest(); } + + /** + * @brief Returns the least upper bound value of the distribution. + */ + result_type + max() const + { return std::numeric_limits::max(); } + + /** + * @brief Generating functions. + */ + template + result_type + operator()(_UniformRandomNumberGenerator& __urng) + { return this->operator()(__urng, _M_param); } + + template + result_type + operator()(_UniformRandomNumberGenerator& __urng, + const param_type& __p); + + template + void + __generate(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng) + { this->__generate(__f, __t, __urng, _M_param); } + + template + void + __generate(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __p) + { this->__generate_impl(__f, __t, __urng, __p); } + + template + void + __generate(result_type* __f, result_type* __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __p) + { this->__generate_impl(__f, __t, __urng, __p); } + + /** + * @brief Return true if two normal distributions have + * the same parameters and the sequences that would + * be generated are equal. + */ + template + friend bool + operator==(const std::normal_distribution<_RealType1>& __d1, + const std::normal_distribution<_RealType1>& __d2); + + /** + * @brief Inserts a %normal_distribution random number distribution + * @p __x into the output stream @p __os. + * + * @param __os An output stream. + * @param __x A %normal_distribution random number distribution. + * + * @returns The output stream with the state of @p __x inserted or in + * an error state. + */ + template + friend std::basic_ostream<_CharT, _Traits>& + operator<<(std::basic_ostream<_CharT, _Traits>& __os, + const std::normal_distribution<_RealType1>& __x); + + /** + * @brief Extracts a %normal_distribution random number distribution + * @p __x from the input stream @p __is. + * + * @param __is An input stream. + * @param __x A %normal_distribution random number generator engine. + * + * @returns The input stream with @p __x extracted or in an error + * state. + */ + template + friend std::basic_istream<_CharT, _Traits>& + operator>>(std::basic_istream<_CharT, _Traits>& __is, + std::normal_distribution<_RealType1>& __x); + + private: + template + void + __generate_impl(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __p); + + param_type _M_param; + result_type _M_saved; + bool _M_saved_available; + }; + + /** + * @brief Return true if two normal distributions are different. + */ + template + inline bool + operator!=(const std::normal_distribution<_RealType>& __d1, + const std::normal_distribution<_RealType>& __d2) + { return !(__d1 == __d2); } + + + /** + * @brief A lognormal_distribution random number distribution. + * + * The formula for the normal probability mass function is + * @f[ + * p(x|m,s) = \frac{1}{sx\sqrt{2\pi}} + * \exp{-\frac{(\ln{x} - m)^2}{2s^2}} + * @f] + */ + template + class lognormal_distribution + { + static_assert(std::is_floating_point<_RealType>::value, + "template argument not a floating point type"); + + public: + /** The type of the range of the distribution. */ + typedef _RealType result_type; + /** Parameter type. */ + struct param_type + { + typedef lognormal_distribution<_RealType> distribution_type; + + explicit + param_type(_RealType __m = _RealType(0), + _RealType __s = _RealType(1)) + : _M_m(__m), _M_s(__s) + { } + + _RealType + m() const + { return _M_m; } + + _RealType + s() const + { return _M_s; } + + friend bool + operator==(const param_type& __p1, const param_type& __p2) + { return __p1._M_m == __p2._M_m && __p1._M_s == __p2._M_s; } + + private: + _RealType _M_m; + _RealType _M_s; + }; + + explicit + lognormal_distribution(_RealType __m = _RealType(0), + _RealType __s = _RealType(1)) + : _M_param(__m, __s), _M_nd() + { } + + explicit + lognormal_distribution(const param_type& __p) + : _M_param(__p), _M_nd() + { } + + /** + * Resets the distribution state. + */ + void + reset() + { _M_nd.reset(); } + + /** + * + */ + _RealType + m() const + { return _M_param.m(); } + + _RealType + s() const + { return _M_param.s(); } + + /** + * @brief Returns the parameter set of the distribution. + */ + param_type + param() const + { return _M_param; } + + /** + * @brief Sets the parameter set of the distribution. + * @param __param The new parameter set of the distribution. + */ + void + param(const param_type& __param) + { _M_param = __param; } + + /** + * @brief Returns the greatest lower bound value of the distribution. + */ + result_type + min() const + { return result_type(0); } + + /** + * @brief Returns the least upper bound value of the distribution. + */ + result_type + max() const + { return std::numeric_limits::max(); } + + /** + * @brief Generating functions. + */ + template + result_type + operator()(_UniformRandomNumberGenerator& __urng) + { return this->operator()(__urng, _M_param); } + + template + result_type + operator()(_UniformRandomNumberGenerator& __urng, + const param_type& __p) + { return std::exp(__p.s() * _M_nd(__urng) + __p.m()); } + + template + void + __generate(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng) + { this->__generate(__f, __t, __urng, _M_param); } + + template + void + __generate(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __p) + { this->__generate_impl(__f, __t, __urng, __p); } + + template + void + __generate(result_type* __f, result_type* __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __p) + { this->__generate_impl(__f, __t, __urng, __p); } + + /** + * @brief Return true if two lognormal distributions have + * the same parameters and the sequences that would + * be generated are equal. + */ + friend bool + operator==(const lognormal_distribution& __d1, + const lognormal_distribution& __d2) + { return (__d1._M_param == __d2._M_param + && __d1._M_nd == __d2._M_nd); } + + /** + * @brief Inserts a %lognormal_distribution random number distribution + * @p __x into the output stream @p __os. + * + * @param __os An output stream. + * @param __x A %lognormal_distribution random number distribution. + * + * @returns The output stream with the state of @p __x inserted or in + * an error state. + */ + template + friend std::basic_ostream<_CharT, _Traits>& + operator<<(std::basic_ostream<_CharT, _Traits>& __os, + const std::lognormal_distribution<_RealType1>& __x); + + /** + * @brief Extracts a %lognormal_distribution random number distribution + * @p __x from the input stream @p __is. + * + * @param __is An input stream. + * @param __x A %lognormal_distribution random number + * generator engine. + * + * @returns The input stream with @p __x extracted or in an error state. + */ + template + friend std::basic_istream<_CharT, _Traits>& + operator>>(std::basic_istream<_CharT, _Traits>& __is, + std::lognormal_distribution<_RealType1>& __x); + + private: + template + void + __generate_impl(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __p); + + param_type _M_param; + + std::normal_distribution _M_nd; + }; + + /** + * @brief Return true if two lognormal distributions are different. + */ + template + inline bool + operator!=(const std::lognormal_distribution<_RealType>& __d1, + const std::lognormal_distribution<_RealType>& __d2) + { return !(__d1 == __d2); } + + + /** + * @brief A gamma continuous distribution for random numbers. + * + * The formula for the gamma probability density function is: + * @f[ + * p(x|\alpha,\beta) = \frac{1}{\beta\Gamma(\alpha)} + * (x/\beta)^{\alpha - 1} e^{-x/\beta} + * @f] + */ + template + class gamma_distribution + { + static_assert(std::is_floating_point<_RealType>::value, + "template argument not a floating point type"); + + public: + /** The type of the range of the distribution. */ + typedef _RealType result_type; + /** Parameter type. */ + struct param_type + { + typedef gamma_distribution<_RealType> distribution_type; + friend class gamma_distribution<_RealType>; + + explicit + param_type(_RealType __alpha_val = _RealType(1), + _RealType __beta_val = _RealType(1)) + : _M_alpha(__alpha_val), _M_beta(__beta_val) + { + _GLIBCXX_DEBUG_ASSERT(_M_alpha > _RealType(0)); + _M_initialize(); + } + + _RealType + alpha() const + { return _M_alpha; } + + _RealType + beta() const + { return _M_beta; } + + friend bool + operator==(const param_type& __p1, const param_type& __p2) + { return (__p1._M_alpha == __p2._M_alpha + && __p1._M_beta == __p2._M_beta); } + + private: + void + _M_initialize(); + + _RealType _M_alpha; + _RealType _M_beta; + + _RealType _M_malpha, _M_a2; + }; + + public: + /** + * @brief Constructs a gamma distribution with parameters + * @f$\alpha@f$ and @f$\beta@f$. + */ + explicit + gamma_distribution(_RealType __alpha_val = _RealType(1), + _RealType __beta_val = _RealType(1)) + : _M_param(__alpha_val, __beta_val), _M_nd() + { } + + explicit + gamma_distribution(const param_type& __p) + : _M_param(__p), _M_nd() + { } + + /** + * @brief Resets the distribution state. + */ + void + reset() + { _M_nd.reset(); } + + /** + * @brief Returns the @f$\alpha@f$ of the distribution. + */ + _RealType + alpha() const + { return _M_param.alpha(); } + + /** + * @brief Returns the @f$\beta@f$ of the distribution. + */ + _RealType + beta() const + { return _M_param.beta(); } + + /** + * @brief Returns the parameter set of the distribution. + */ + param_type + param() const + { return _M_param; } + + /** + * @brief Sets the parameter set of the distribution. + * @param __param The new parameter set of the distribution. + */ + void + param(const param_type& __param) + { _M_param = __param; } + + /** + * @brief Returns the greatest lower bound value of the distribution. + */ + result_type + min() const + { return result_type(0); } + + /** + * @brief Returns the least upper bound value of the distribution. + */ + result_type + max() const + { return std::numeric_limits::max(); } + + /** + * @brief Generating functions. + */ + template + result_type + operator()(_UniformRandomNumberGenerator& __urng) + { return this->operator()(__urng, _M_param); } + + template + result_type + operator()(_UniformRandomNumberGenerator& __urng, + const param_type& __p); + + template + void + __generate(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng) + { this->__generate(__f, __t, __urng, _M_param); } + + template + void + __generate(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __p) + { this->__generate_impl(__f, __t, __urng, __p); } + + template + void + __generate(result_type* __f, result_type* __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __p) + { this->__generate_impl(__f, __t, __urng, __p); } + + /** + * @brief Return true if two gamma distributions have the same + * parameters and the sequences that would be generated + * are equal. + */ + friend bool + operator==(const gamma_distribution& __d1, + const gamma_distribution& __d2) + { return (__d1._M_param == __d2._M_param + && __d1._M_nd == __d2._M_nd); } + + /** + * @brief Inserts a %gamma_distribution random number distribution + * @p __x into the output stream @p __os. + * + * @param __os An output stream. + * @param __x A %gamma_distribution random number distribution. + * + * @returns The output stream with the state of @p __x inserted or in + * an error state. + */ + template + friend std::basic_ostream<_CharT, _Traits>& + operator<<(std::basic_ostream<_CharT, _Traits>& __os, + const std::gamma_distribution<_RealType1>& __x); + + /** + * @brief Extracts a %gamma_distribution random number distribution + * @p __x from the input stream @p __is. + * + * @param __is An input stream. + * @param __x A %gamma_distribution random number generator engine. + * + * @returns The input stream with @p __x extracted or in an error state. + */ + template + friend std::basic_istream<_CharT, _Traits>& + operator>>(std::basic_istream<_CharT, _Traits>& __is, + std::gamma_distribution<_RealType1>& __x); + + private: + template + void + __generate_impl(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __p); + + param_type _M_param; + + std::normal_distribution _M_nd; + }; + + /** + * @brief Return true if two gamma distributions are different. + */ + template + inline bool + operator!=(const std::gamma_distribution<_RealType>& __d1, + const std::gamma_distribution<_RealType>& __d2) + { return !(__d1 == __d2); } + + + /** + * @brief A chi_squared_distribution random number distribution. + * + * The formula for the normal probability mass function is + * @f$p(x|n) = \frac{x^{(n/2) - 1}e^{-x/2}}{\Gamma(n/2) 2^{n/2}}@f$ + */ + template + class chi_squared_distribution + { + static_assert(std::is_floating_point<_RealType>::value, + "template argument not a floating point type"); + + public: + /** The type of the range of the distribution. */ + typedef _RealType result_type; + /** Parameter type. */ + struct param_type + { + typedef chi_squared_distribution<_RealType> distribution_type; + + explicit + param_type(_RealType __n = _RealType(1)) + : _M_n(__n) + { } + + _RealType + n() const + { return _M_n; } + + friend bool + operator==(const param_type& __p1, const param_type& __p2) + { return __p1._M_n == __p2._M_n; } + + private: + _RealType _M_n; + }; + + explicit + chi_squared_distribution(_RealType __n = _RealType(1)) + : _M_param(__n), _M_gd(__n / 2) + { } + + explicit + chi_squared_distribution(const param_type& __p) + : _M_param(__p), _M_gd(__p.n() / 2) + { } + + /** + * @brief Resets the distribution state. + */ + void + reset() + { _M_gd.reset(); } + + /** + * + */ + _RealType + n() const + { return _M_param.n(); } + + /** + * @brief Returns the parameter set of the distribution. + */ + param_type + param() const + { return _M_param; } + + /** + * @brief Sets the parameter set of the distribution. + * @param __param The new parameter set of the distribution. + */ + void + param(const param_type& __param) + { _M_param = __param; } + + /** + * @brief Returns the greatest lower bound value of the distribution. + */ + result_type + min() const + { return result_type(0); } + + /** + * @brief Returns the least upper bound value of the distribution. + */ + result_type + max() const + { return std::numeric_limits::max(); } + + /** + * @brief Generating functions. + */ + template + result_type + operator()(_UniformRandomNumberGenerator& __urng) + { return 2 * _M_gd(__urng); } + + template + result_type + operator()(_UniformRandomNumberGenerator& __urng, + const param_type& __p) + { + typedef typename std::gamma_distribution::param_type + param_type; + return 2 * _M_gd(__urng, param_type(__p.n() / 2)); + } + + template + void + __generate(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng) + { this->__generate_impl(__f, __t, __urng); } + + template + void + __generate(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __p) + { typename std::gamma_distribution::param_type + __p2(__p.n() / 2); + this->__generate_impl(__f, __t, __urng, __p2); } + + template + void + __generate(result_type* __f, result_type* __t, + _UniformRandomNumberGenerator& __urng) + { this->__generate_impl(__f, __t, __urng); } + + template + void + __generate(result_type* __f, result_type* __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __p) + { typename std::gamma_distribution::param_type + __p2(__p.n() / 2); + this->__generate_impl(__f, __t, __urng, __p2); } + + /** + * @brief Return true if two Chi-squared distributions have + * the same parameters and the sequences that would be + * generated are equal. + */ + friend bool + operator==(const chi_squared_distribution& __d1, + const chi_squared_distribution& __d2) + { return __d1._M_param == __d2._M_param && __d1._M_gd == __d2._M_gd; } + + /** + * @brief Inserts a %chi_squared_distribution random number distribution + * @p __x into the output stream @p __os. + * + * @param __os An output stream. + * @param __x A %chi_squared_distribution random number distribution. + * + * @returns The output stream with the state of @p __x inserted or in + * an error state. + */ + template + friend std::basic_ostream<_CharT, _Traits>& + operator<<(std::basic_ostream<_CharT, _Traits>& __os, + const std::chi_squared_distribution<_RealType1>& __x); + + /** + * @brief Extracts a %chi_squared_distribution random number distribution + * @p __x from the input stream @p __is. + * + * @param __is An input stream. + * @param __x A %chi_squared_distribution random number + * generator engine. + * + * @returns The input stream with @p __x extracted or in an error state. + */ + template + friend std::basic_istream<_CharT, _Traits>& + operator>>(std::basic_istream<_CharT, _Traits>& __is, + std::chi_squared_distribution<_RealType1>& __x); + + private: + template + void + __generate_impl(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng); + + template + void + __generate_impl(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng, + const typename + std::gamma_distribution::param_type& __p); + + param_type _M_param; + + std::gamma_distribution _M_gd; + }; + + /** + * @brief Return true if two Chi-squared distributions are different. + */ + template + inline bool + operator!=(const std::chi_squared_distribution<_RealType>& __d1, + const std::chi_squared_distribution<_RealType>& __d2) + { return !(__d1 == __d2); } + + + /** + * @brief A cauchy_distribution random number distribution. + * + * The formula for the normal probability mass function is + * @f$p(x|a,b) = (\pi b (1 + (\frac{x-a}{b})^2))^{-1}@f$ + */ + template + class cauchy_distribution + { + static_assert(std::is_floating_point<_RealType>::value, + "template argument not a floating point type"); + + public: + /** The type of the range of the distribution. */ + typedef _RealType result_type; + /** Parameter type. */ + struct param_type + { + typedef cauchy_distribution<_RealType> distribution_type; + + explicit + param_type(_RealType __a = _RealType(0), + _RealType __b = _RealType(1)) + : _M_a(__a), _M_b(__b) + { } + + _RealType + a() const + { return _M_a; } + + _RealType + b() const + { return _M_b; } + + friend bool + operator==(const param_type& __p1, const param_type& __p2) + { return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; } + + private: + _RealType _M_a; + _RealType _M_b; + }; + + explicit + cauchy_distribution(_RealType __a = _RealType(0), + _RealType __b = _RealType(1)) + : _M_param(__a, __b) + { } + + explicit + cauchy_distribution(const param_type& __p) + : _M_param(__p) + { } + + /** + * @brief Resets the distribution state. + */ + void + reset() + { } + + /** + * + */ + _RealType + a() const + { return _M_param.a(); } + + _RealType + b() const + { return _M_param.b(); } + + /** + * @brief Returns the parameter set of the distribution. + */ + param_type + param() const + { return _M_param; } + + /** + * @brief Sets the parameter set of the distribution. + * @param __param The new parameter set of the distribution. + */ + void + param(const param_type& __param) + { _M_param = __param; } + + /** + * @brief Returns the greatest lower bound value of the distribution. + */ + result_type + min() const + { return std::numeric_limits::lowest(); } + + /** + * @brief Returns the least upper bound value of the distribution. + */ + result_type + max() const + { return std::numeric_limits::max(); } + + /** + * @brief Generating functions. + */ + template + result_type + operator()(_UniformRandomNumberGenerator& __urng) + { return this->operator()(__urng, _M_param); } + + template + result_type + operator()(_UniformRandomNumberGenerator& __urng, + const param_type& __p); + + template + void + __generate(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng) + { this->__generate(__f, __t, __urng, _M_param); } + + template + void + __generate(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __p) + { this->__generate_impl(__f, __t, __urng, __p); } + + template + void + __generate(result_type* __f, result_type* __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __p) + { this->__generate_impl(__f, __t, __urng, __p); } + + /** + * @brief Return true if two Cauchy distributions have + * the same parameters. + */ + friend bool + operator==(const cauchy_distribution& __d1, + const cauchy_distribution& __d2) + { return __d1._M_param == __d2._M_param; } + + private: + template + void + __generate_impl(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __p); + + param_type _M_param; + }; + + /** + * @brief Return true if two Cauchy distributions have + * different parameters. + */ + template + inline bool + operator!=(const std::cauchy_distribution<_RealType>& __d1, + const std::cauchy_distribution<_RealType>& __d2) + { return !(__d1 == __d2); } + + /** + * @brief Inserts a %cauchy_distribution random number distribution + * @p __x into the output stream @p __os. + * + * @param __os An output stream. + * @param __x A %cauchy_distribution random number distribution. + * + * @returns The output stream with the state of @p __x inserted or in + * an error state. + */ + template + std::basic_ostream<_CharT, _Traits>& + operator<<(std::basic_ostream<_CharT, _Traits>& __os, + const std::cauchy_distribution<_RealType>& __x); + + /** + * @brief Extracts a %cauchy_distribution random number distribution + * @p __x from the input stream @p __is. + * + * @param __is An input stream. + * @param __x A %cauchy_distribution random number + * generator engine. + * + * @returns The input stream with @p __x extracted or in an error state. + */ + template + std::basic_istream<_CharT, _Traits>& + operator>>(std::basic_istream<_CharT, _Traits>& __is, + std::cauchy_distribution<_RealType>& __x); + + + /** + * @brief A fisher_f_distribution random number distribution. + * + * The formula for the normal probability mass function is + * @f[ + * p(x|m,n) = \frac{\Gamma((m+n)/2)}{\Gamma(m/2)\Gamma(n/2)} + * (\frac{m}{n})^{m/2} x^{(m/2)-1} + * (1 + \frac{mx}{n})^{-(m+n)/2} + * @f] + */ + template + class fisher_f_distribution + { + static_assert(std::is_floating_point<_RealType>::value, + "template argument not a floating point type"); + + public: + /** The type of the range of the distribution. */ + typedef _RealType result_type; + /** Parameter type. */ + struct param_type + { + typedef fisher_f_distribution<_RealType> distribution_type; + + explicit + param_type(_RealType __m = _RealType(1), + _RealType __n = _RealType(1)) + : _M_m(__m), _M_n(__n) + { } + + _RealType + m() const + { return _M_m; } + + _RealType + n() const + { return _M_n; } + + friend bool + operator==(const param_type& __p1, const param_type& __p2) + { return __p1._M_m == __p2._M_m && __p1._M_n == __p2._M_n; } + + private: + _RealType _M_m; + _RealType _M_n; + }; + + explicit + fisher_f_distribution(_RealType __m = _RealType(1), + _RealType __n = _RealType(1)) + : _M_param(__m, __n), _M_gd_x(__m / 2), _M_gd_y(__n / 2) + { } + + explicit + fisher_f_distribution(const param_type& __p) + : _M_param(__p), _M_gd_x(__p.m() / 2), _M_gd_y(__p.n() / 2) + { } + + /** + * @brief Resets the distribution state. + */ + void + reset() + { + _M_gd_x.reset(); + _M_gd_y.reset(); + } + + /** + * + */ + _RealType + m() const + { return _M_param.m(); } + + _RealType + n() const + { return _M_param.n(); } + + /** + * @brief Returns the parameter set of the distribution. + */ + param_type + param() const + { return _M_param; } + + /** + * @brief Sets the parameter set of the distribution. + * @param __param The new parameter set of the distribution. + */ + void + param(const param_type& __param) + { _M_param = __param; } + + /** + * @brief Returns the greatest lower bound value of the distribution. + */ + result_type + min() const + { return result_type(0); } + + /** + * @brief Returns the least upper bound value of the distribution. + */ + result_type + max() const + { return std::numeric_limits::max(); } + + /** + * @brief Generating functions. + */ + template + result_type + operator()(_UniformRandomNumberGenerator& __urng) + { return (_M_gd_x(__urng) * n()) / (_M_gd_y(__urng) * m()); } + + template + result_type + operator()(_UniformRandomNumberGenerator& __urng, + const param_type& __p) + { + typedef typename std::gamma_distribution::param_type + param_type; + return ((_M_gd_x(__urng, param_type(__p.m() / 2)) * n()) + / (_M_gd_y(__urng, param_type(__p.n() / 2)) * m())); + } + + template + void + __generate(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng) + { this->__generate_impl(__f, __t, __urng); } + + template + void + __generate(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __p) + { this->__generate_impl(__f, __t, __urng, __p); } + + template + void + __generate(result_type* __f, result_type* __t, + _UniformRandomNumberGenerator& __urng) + { this->__generate_impl(__f, __t, __urng); } + + template + void + __generate(result_type* __f, result_type* __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __p) + { this->__generate_impl(__f, __t, __urng, __p); } + + /** + * @brief Return true if two Fisher f distributions have + * the same parameters and the sequences that would + * be generated are equal. + */ + friend bool + operator==(const fisher_f_distribution& __d1, + const fisher_f_distribution& __d2) + { return (__d1._M_param == __d2._M_param + && __d1._M_gd_x == __d2._M_gd_x + && __d1._M_gd_y == __d2._M_gd_y); } + + /** + * @brief Inserts a %fisher_f_distribution random number distribution + * @p __x into the output stream @p __os. + * + * @param __os An output stream. + * @param __x A %fisher_f_distribution random number distribution. + * + * @returns The output stream with the state of @p __x inserted or in + * an error state. + */ + template + friend std::basic_ostream<_CharT, _Traits>& + operator<<(std::basic_ostream<_CharT, _Traits>& __os, + const std::fisher_f_distribution<_RealType1>& __x); + + /** + * @brief Extracts a %fisher_f_distribution random number distribution + * @p __x from the input stream @p __is. + * + * @param __is An input stream. + * @param __x A %fisher_f_distribution random number + * generator engine. + * + * @returns The input stream with @p __x extracted or in an error state. + */ + template + friend std::basic_istream<_CharT, _Traits>& + operator>>(std::basic_istream<_CharT, _Traits>& __is, + std::fisher_f_distribution<_RealType1>& __x); + + private: + template + void + __generate_impl(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng); + + template + void + __generate_impl(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __p); + + param_type _M_param; + + std::gamma_distribution _M_gd_x, _M_gd_y; + }; + + /** + * @brief Return true if two Fisher f distributions are different. + */ + template + inline bool + operator!=(const std::fisher_f_distribution<_RealType>& __d1, + const std::fisher_f_distribution<_RealType>& __d2) + { return !(__d1 == __d2); } + + /** + * @brief A student_t_distribution random number distribution. + * + * The formula for the normal probability mass function is: + * @f[ + * p(x|n) = \frac{1}{\sqrt(n\pi)} \frac{\Gamma((n+1)/2)}{\Gamma(n/2)} + * (1 + \frac{x^2}{n}) ^{-(n+1)/2} + * @f] + */ + template + class student_t_distribution + { + static_assert(std::is_floating_point<_RealType>::value, + "template argument not a floating point type"); + + public: + /** The type of the range of the distribution. */ + typedef _RealType result_type; + /** Parameter type. */ + struct param_type + { + typedef student_t_distribution<_RealType> distribution_type; + + explicit + param_type(_RealType __n = _RealType(1)) + : _M_n(__n) + { } + + _RealType + n() const + { return _M_n; } + + friend bool + operator==(const param_type& __p1, const param_type& __p2) + { return __p1._M_n == __p2._M_n; } + + private: + _RealType _M_n; + }; + + explicit + student_t_distribution(_RealType __n = _RealType(1)) + : _M_param(__n), _M_nd(), _M_gd(__n / 2, 2) + { } + + explicit + student_t_distribution(const param_type& __p) + : _M_param(__p), _M_nd(), _M_gd(__p.n() / 2, 2) + { } + + /** + * @brief Resets the distribution state. + */ + void + reset() + { + _M_nd.reset(); + _M_gd.reset(); + } + + /** + * + */ + _RealType + n() const + { return _M_param.n(); } + + /** + * @brief Returns the parameter set of the distribution. + */ + param_type + param() const + { return _M_param; } + + /** + * @brief Sets the parameter set of the distribution. + * @param __param The new parameter set of the distribution. + */ + void + param(const param_type& __param) + { _M_param = __param; } + + /** + * @brief Returns the greatest lower bound value of the distribution. + */ + result_type + min() const + { return std::numeric_limits::lowest(); } + + /** + * @brief Returns the least upper bound value of the distribution. + */ + result_type + max() const + { return std::numeric_limits::max(); } + + /** + * @brief Generating functions. + */ + template + result_type + operator()(_UniformRandomNumberGenerator& __urng) + { return _M_nd(__urng) * std::sqrt(n() / _M_gd(__urng)); } + + template + result_type + operator()(_UniformRandomNumberGenerator& __urng, + const param_type& __p) + { + typedef typename std::gamma_distribution::param_type + param_type; + + const result_type __g = _M_gd(__urng, param_type(__p.n() / 2, 2)); + return _M_nd(__urng) * std::sqrt(__p.n() / __g); + } + + template + void + __generate(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng) + { this->__generate_impl(__f, __t, __urng); } + + template + void + __generate(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __p) + { this->__generate_impl(__f, __t, __urng, __p); } + + template + void + __generate(result_type* __f, result_type* __t, + _UniformRandomNumberGenerator& __urng) + { this->__generate_impl(__f, __t, __urng); } + + template + void + __generate(result_type* __f, result_type* __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __p) + { this->__generate_impl(__f, __t, __urng, __p); } + + /** + * @brief Return true if two Student t distributions have + * the same parameters and the sequences that would + * be generated are equal. + */ + friend bool + operator==(const student_t_distribution& __d1, + const student_t_distribution& __d2) + { return (__d1._M_param == __d2._M_param + && __d1._M_nd == __d2._M_nd && __d1._M_gd == __d2._M_gd); } + + /** + * @brief Inserts a %student_t_distribution random number distribution + * @p __x into the output stream @p __os. + * + * @param __os An output stream. + * @param __x A %student_t_distribution random number distribution. + * + * @returns The output stream with the state of @p __x inserted or in + * an error state. + */ + template + friend std::basic_ostream<_CharT, _Traits>& + operator<<(std::basic_ostream<_CharT, _Traits>& __os, + const std::student_t_distribution<_RealType1>& __x); + + /** + * @brief Extracts a %student_t_distribution random number distribution + * @p __x from the input stream @p __is. + * + * @param __is An input stream. + * @param __x A %student_t_distribution random number + * generator engine. + * + * @returns The input stream with @p __x extracted or in an error state. + */ + template + friend std::basic_istream<_CharT, _Traits>& + operator>>(std::basic_istream<_CharT, _Traits>& __is, + std::student_t_distribution<_RealType1>& __x); + + private: + template + void + __generate_impl(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng); + template + void + __generate_impl(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __p); + + param_type _M_param; + + std::normal_distribution _M_nd; + std::gamma_distribution _M_gd; + }; + + /** + * @brief Return true if two Student t distributions are different. + */ + template + inline bool + operator!=(const std::student_t_distribution<_RealType>& __d1, + const std::student_t_distribution<_RealType>& __d2) + { return !(__d1 == __d2); } + + + /* @} */ // group random_distributions_normal + + /** + * @addtogroup random_distributions_bernoulli Bernoulli Distributions + * @ingroup random_distributions + * @{ + */ + + /** + * @brief A Bernoulli random number distribution. + * + * Generates a sequence of true and false values with likelihood @f$p@f$ + * that true will come up and @f$(1 - p)@f$ that false will appear. + */ + class bernoulli_distribution + { + public: + /** The type of the range of the distribution. */ + typedef bool result_type; + /** Parameter type. */ + struct param_type + { + typedef bernoulli_distribution distribution_type; + + explicit + param_type(double __p = 0.5) + : _M_p(__p) + { + _GLIBCXX_DEBUG_ASSERT((_M_p >= 0.0) && (_M_p <= 1.0)); + } + + double + p() const + { return _M_p; } + + friend bool + operator==(const param_type& __p1, const param_type& __p2) + { return __p1._M_p == __p2._M_p; } + + private: + double _M_p; + }; + + public: + /** + * @brief Constructs a Bernoulli distribution with likelihood @p p. + * + * @param __p [IN] The likelihood of a true result being returned. + * Must be in the interval @f$[0, 1]@f$. + */ + explicit + bernoulli_distribution(double __p = 0.5) + : _M_param(__p) + { } + + explicit + bernoulli_distribution(const param_type& __p) + : _M_param(__p) + { } + + /** + * @brief Resets the distribution state. + * + * Does nothing for a Bernoulli distribution. + */ + void + reset() { } + + /** + * @brief Returns the @p p parameter of the distribution. + */ + double + p() const + { return _M_param.p(); } + + /** + * @brief Returns the parameter set of the distribution. + */ + param_type + param() const + { return _M_param; } + + /** + * @brief Sets the parameter set of the distribution. + * @param __param The new parameter set of the distribution. + */ + void + param(const param_type& __param) + { _M_param = __param; } + + /** + * @brief Returns the greatest lower bound value of the distribution. + */ + result_type + min() const + { return std::numeric_limits::min(); } + + /** + * @brief Returns the least upper bound value of the distribution. + */ + result_type + max() const + { return std::numeric_limits::max(); } + + /** + * @brief Generating functions. + */ + template + result_type + operator()(_UniformRandomNumberGenerator& __urng) + { return this->operator()(__urng, _M_param); } + + template + result_type + operator()(_UniformRandomNumberGenerator& __urng, + const param_type& __p) + { + __detail::_Adaptor<_UniformRandomNumberGenerator, double> + __aurng(__urng); + if ((__aurng() - __aurng.min()) + < __p.p() * (__aurng.max() - __aurng.min())) + return true; + return false; + } + + template + void + __generate(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng) + { this->__generate(__f, __t, __urng, _M_param); } + + template + void + __generate(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng, const param_type& __p) + { this->__generate_impl(__f, __t, __urng, __p); } + + template + void + __generate(result_type* __f, result_type* __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __p) + { this->__generate_impl(__f, __t, __urng, __p); } + + /** + * @brief Return true if two Bernoulli distributions have + * the same parameters. + */ + friend bool + operator==(const bernoulli_distribution& __d1, + const bernoulli_distribution& __d2) + { return __d1._M_param == __d2._M_param; } + + private: + template + void + __generate_impl(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __p); + + param_type _M_param; + }; + + /** + * @brief Return true if two Bernoulli distributions have + * different parameters. + */ + inline bool + operator!=(const std::bernoulli_distribution& __d1, + const std::bernoulli_distribution& __d2) + { return !(__d1 == __d2); } + + /** + * @brief Inserts a %bernoulli_distribution random number distribution + * @p __x into the output stream @p __os. + * + * @param __os An output stream. + * @param __x A %bernoulli_distribution random number distribution. + * + * @returns The output stream with the state of @p __x inserted or in + * an error state. + */ + template + std::basic_ostream<_CharT, _Traits>& + operator<<(std::basic_ostream<_CharT, _Traits>& __os, + const std::bernoulli_distribution& __x); + + /** + * @brief Extracts a %bernoulli_distribution random number distribution + * @p __x from the input stream @p __is. + * + * @param __is An input stream. + * @param __x A %bernoulli_distribution random number generator engine. + * + * @returns The input stream with @p __x extracted or in an error state. + */ + template + std::basic_istream<_CharT, _Traits>& + operator>>(std::basic_istream<_CharT, _Traits>& __is, + std::bernoulli_distribution& __x) + { + double __p; + __is >> __p; + __x.param(bernoulli_distribution::param_type(__p)); + return __is; + } + + + /** + * @brief A discrete binomial random number distribution. + * + * The formula for the binomial probability density function is + * @f$p(i|t,p) = \binom{t}{i} p^i (1 - p)^{t - i}@f$ where @f$t@f$ + * and @f$p@f$ are the parameters of the distribution. + */ + template + class binomial_distribution + { + static_assert(std::is_integral<_IntType>::value, + "template argument not an integral type"); + + public: + /** The type of the range of the distribution. */ + typedef _IntType result_type; + /** Parameter type. */ + struct param_type + { + typedef binomial_distribution<_IntType> distribution_type; + friend class binomial_distribution<_IntType>; + + explicit + param_type(_IntType __t = _IntType(1), double __p = 0.5) + : _M_t(__t), _M_p(__p) + { + _GLIBCXX_DEBUG_ASSERT((_M_t >= _IntType(0)) + && (_M_p >= 0.0) + && (_M_p <= 1.0)); + _M_initialize(); + } + + _IntType + t() const + { return _M_t; } + + double + p() const + { return _M_p; } + + friend bool + operator==(const param_type& __p1, const param_type& __p2) + { return __p1._M_t == __p2._M_t && __p1._M_p == __p2._M_p; } + + private: + void + _M_initialize(); + + _IntType _M_t; + double _M_p; + + double _M_q; +#if _GLIBCXX_USE_C99_MATH_TR1 + double _M_d1, _M_d2, _M_s1, _M_s2, _M_c, + _M_a1, _M_a123, _M_s, _M_lf, _M_lp1p; +#endif + bool _M_easy; + }; + + // constructors and member function + explicit + binomial_distribution(_IntType __t = _IntType(1), + double __p = 0.5) + : _M_param(__t, __p), _M_nd() + { } + + explicit + binomial_distribution(const param_type& __p) + : _M_param(__p), _M_nd() + { } + + /** + * @brief Resets the distribution state. + */ + void + reset() + { _M_nd.reset(); } + + /** + * @brief Returns the distribution @p t parameter. + */ + _IntType + t() const + { return _M_param.t(); } + + /** + * @brief Returns the distribution @p p parameter. + */ + double + p() const + { return _M_param.p(); } + + /** + * @brief Returns the parameter set of the distribution. + */ + param_type + param() const + { return _M_param; } + + /** + * @brief Sets the parameter set of the distribution. + * @param __param The new parameter set of the distribution. + */ + void + param(const param_type& __param) + { _M_param = __param; } + + /** + * @brief Returns the greatest lower bound value of the distribution. + */ + result_type + min() const + { return 0; } + + /** + * @brief Returns the least upper bound value of the distribution. + */ + result_type + max() const + { return _M_param.t(); } + + /** + * @brief Generating functions. + */ + template + result_type + operator()(_UniformRandomNumberGenerator& __urng) + { return this->operator()(__urng, _M_param); } + + template + result_type + operator()(_UniformRandomNumberGenerator& __urng, + const param_type& __p); + + template + void + __generate(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng) + { this->__generate(__f, __t, __urng, _M_param); } + + template + void + __generate(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __p) + { this->__generate_impl(__f, __t, __urng, __p); } + + template + void + __generate(result_type* __f, result_type* __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __p) + { this->__generate_impl(__f, __t, __urng, __p); } + + /** + * @brief Return true if two binomial distributions have + * the same parameters and the sequences that would + * be generated are equal. + */ + friend bool + operator==(const binomial_distribution& __d1, + const binomial_distribution& __d2) +#ifdef _GLIBCXX_USE_C99_MATH_TR1 + { return __d1._M_param == __d2._M_param && __d1._M_nd == __d2._M_nd; } +#else + { return __d1._M_param == __d2._M_param; } +#endif + + /** + * @brief Inserts a %binomial_distribution random number distribution + * @p __x into the output stream @p __os. + * + * @param __os An output stream. + * @param __x A %binomial_distribution random number distribution. + * + * @returns The output stream with the state of @p __x inserted or in + * an error state. + */ + template + friend std::basic_ostream<_CharT, _Traits>& + operator<<(std::basic_ostream<_CharT, _Traits>& __os, + const std::binomial_distribution<_IntType1>& __x); + + /** + * @brief Extracts a %binomial_distribution random number distribution + * @p __x from the input stream @p __is. + * + * @param __is An input stream. + * @param __x A %binomial_distribution random number generator engine. + * + * @returns The input stream with @p __x extracted or in an error + * state. + */ + template + friend std::basic_istream<_CharT, _Traits>& + operator>>(std::basic_istream<_CharT, _Traits>& __is, + std::binomial_distribution<_IntType1>& __x); + + private: + template + void + __generate_impl(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __p); + + template + result_type + _M_waiting(_UniformRandomNumberGenerator& __urng, + _IntType __t, double __q); + + param_type _M_param; + + // NB: Unused when _GLIBCXX_USE_C99_MATH_TR1 is undefined. + std::normal_distribution _M_nd; + }; + + /** + * @brief Return true if two binomial distributions are different. + */ + template + inline bool + operator!=(const std::binomial_distribution<_IntType>& __d1, + const std::binomial_distribution<_IntType>& __d2) + { return !(__d1 == __d2); } + + + /** + * @brief A discrete geometric random number distribution. + * + * The formula for the geometric probability density function is + * @f$p(i|p) = p(1 - p)^{i}@f$ where @f$p@f$ is the parameter of the + * distribution. + */ + template + class geometric_distribution + { + static_assert(std::is_integral<_IntType>::value, + "template argument not an integral type"); + + public: + /** The type of the range of the distribution. */ + typedef _IntType result_type; + /** Parameter type. */ + struct param_type + { + typedef geometric_distribution<_IntType> distribution_type; + friend class geometric_distribution<_IntType>; + + explicit + param_type(double __p = 0.5) + : _M_p(__p) + { + _GLIBCXX_DEBUG_ASSERT((_M_p > 0.0) && (_M_p < 1.0)); + _M_initialize(); + } + + double + p() const + { return _M_p; } + + friend bool + operator==(const param_type& __p1, const param_type& __p2) + { return __p1._M_p == __p2._M_p; } + + private: + void + _M_initialize() + { _M_log_1_p = std::log(1.0 - _M_p); } + + double _M_p; + + double _M_log_1_p; + }; + + // constructors and member function + explicit + geometric_distribution(double __p = 0.5) + : _M_param(__p) + { } + + explicit + geometric_distribution(const param_type& __p) + : _M_param(__p) + { } + + /** + * @brief Resets the distribution state. + * + * Does nothing for the geometric distribution. + */ + void + reset() { } + + /** + * @brief Returns the distribution parameter @p p. + */ + double + p() const + { return _M_param.p(); } + + /** + * @brief Returns the parameter set of the distribution. + */ + param_type + param() const + { return _M_param; } + + /** + * @brief Sets the parameter set of the distribution. + * @param __param The new parameter set of the distribution. + */ + void + param(const param_type& __param) + { _M_param = __param; } + + /** + * @brief Returns the greatest lower bound value of the distribution. + */ + result_type + min() const + { return 0; } + + /** + * @brief Returns the least upper bound value of the distribution. + */ + result_type + max() const + { return std::numeric_limits::max(); } + + /** + * @brief Generating functions. + */ + template + result_type + operator()(_UniformRandomNumberGenerator& __urng) + { return this->operator()(__urng, _M_param); } + + template + result_type + operator()(_UniformRandomNumberGenerator& __urng, + const param_type& __p); + + template + void + __generate(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng) + { this->__generate(__f, __t, __urng, _M_param); } + + template + void + __generate(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __p) + { this->__generate_impl(__f, __t, __urng, __p); } + + template + void + __generate(result_type* __f, result_type* __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __p) + { this->__generate_impl(__f, __t, __urng, __p); } + + /** + * @brief Return true if two geometric distributions have + * the same parameters. + */ + friend bool + operator==(const geometric_distribution& __d1, + const geometric_distribution& __d2) + { return __d1._M_param == __d2._M_param; } + + private: + template + void + __generate_impl(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __p); + + param_type _M_param; + }; + + /** + * @brief Return true if two geometric distributions have + * different parameters. + */ + template + inline bool + operator!=(const std::geometric_distribution<_IntType>& __d1, + const std::geometric_distribution<_IntType>& __d2) + { return !(__d1 == __d2); } + + /** + * @brief Inserts a %geometric_distribution random number distribution + * @p __x into the output stream @p __os. + * + * @param __os An output stream. + * @param __x A %geometric_distribution random number distribution. + * + * @returns The output stream with the state of @p __x inserted or in + * an error state. + */ + template + std::basic_ostream<_CharT, _Traits>& + operator<<(std::basic_ostream<_CharT, _Traits>& __os, + const std::geometric_distribution<_IntType>& __x); + + /** + * @brief Extracts a %geometric_distribution random number distribution + * @p __x from the input stream @p __is. + * + * @param __is An input stream. + * @param __x A %geometric_distribution random number generator engine. + * + * @returns The input stream with @p __x extracted or in an error state. + */ + template + std::basic_istream<_CharT, _Traits>& + operator>>(std::basic_istream<_CharT, _Traits>& __is, + std::geometric_distribution<_IntType>& __x); + + + /** + * @brief A negative_binomial_distribution random number distribution. + * + * The formula for the negative binomial probability mass function is + * @f$p(i) = \binom{n}{i} p^i (1 - p)^{t - i}@f$ where @f$t@f$ + * and @f$p@f$ are the parameters of the distribution. + */ + template + class negative_binomial_distribution + { + static_assert(std::is_integral<_IntType>::value, + "template argument not an integral type"); + + public: + /** The type of the range of the distribution. */ + typedef _IntType result_type; + /** Parameter type. */ + struct param_type + { + typedef negative_binomial_distribution<_IntType> distribution_type; + + explicit + param_type(_IntType __k = 1, double __p = 0.5) + : _M_k(__k), _M_p(__p) + { + _GLIBCXX_DEBUG_ASSERT((_M_k > 0) && (_M_p > 0.0) && (_M_p <= 1.0)); + } + + _IntType + k() const + { return _M_k; } + + double + p() const + { return _M_p; } + + friend bool + operator==(const param_type& __p1, const param_type& __p2) + { return __p1._M_k == __p2._M_k && __p1._M_p == __p2._M_p; } + + private: + _IntType _M_k; + double _M_p; + }; + + explicit + negative_binomial_distribution(_IntType __k = 1, double __p = 0.5) + : _M_param(__k, __p), _M_gd(__k, (1.0 - __p) / __p) + { } + + explicit + negative_binomial_distribution(const param_type& __p) + : _M_param(__p), _M_gd(__p.k(), (1.0 - __p.p()) / __p.p()) + { } + + /** + * @brief Resets the distribution state. + */ + void + reset() + { _M_gd.reset(); } + + /** + * @brief Return the @f$k@f$ parameter of the distribution. + */ + _IntType + k() const + { return _M_param.k(); } + + /** + * @brief Return the @f$p@f$ parameter of the distribution. + */ + double + p() const + { return _M_param.p(); } + + /** + * @brief Returns the parameter set of the distribution. + */ + param_type + param() const + { return _M_param; } + + /** + * @brief Sets the parameter set of the distribution. + * @param __param The new parameter set of the distribution. + */ + void + param(const param_type& __param) + { _M_param = __param; } + + /** + * @brief Returns the greatest lower bound value of the distribution. + */ + result_type + min() const + { return result_type(0); } + + /** + * @brief Returns the least upper bound value of the distribution. + */ + result_type + max() const + { return std::numeric_limits::max(); } + + /** + * @brief Generating functions. + */ + template + result_type + operator()(_UniformRandomNumberGenerator& __urng); + + template + result_type + operator()(_UniformRandomNumberGenerator& __urng, + const param_type& __p); + + template + void + __generate(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng) + { this->__generate_impl(__f, __t, __urng); } + + template + void + __generate(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __p) + { this->__generate_impl(__f, __t, __urng, __p); } + + template + void + __generate(result_type* __f, result_type* __t, + _UniformRandomNumberGenerator& __urng) + { this->__generate_impl(__f, __t, __urng); } + + template + void + __generate(result_type* __f, result_type* __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __p) + { this->__generate_impl(__f, __t, __urng, __p); } + + /** + * @brief Return true if two negative binomial distributions have + * the same parameters and the sequences that would be + * generated are equal. + */ + friend bool + operator==(const negative_binomial_distribution& __d1, + const negative_binomial_distribution& __d2) + { return __d1._M_param == __d2._M_param && __d1._M_gd == __d2._M_gd; } + + /** + * @brief Inserts a %negative_binomial_distribution random + * number distribution @p __x into the output stream @p __os. + * + * @param __os An output stream. + * @param __x A %negative_binomial_distribution random number + * distribution. + * + * @returns The output stream with the state of @p __x inserted or in + * an error state. + */ + template + friend std::basic_ostream<_CharT, _Traits>& + operator<<(std::basic_ostream<_CharT, _Traits>& __os, + const std::negative_binomial_distribution<_IntType1>& __x); + + /** + * @brief Extracts a %negative_binomial_distribution random number + * distribution @p __x from the input stream @p __is. + * + * @param __is An input stream. + * @param __x A %negative_binomial_distribution random number + * generator engine. + * + * @returns The input stream with @p __x extracted or in an error state. + */ + template + friend std::basic_istream<_CharT, _Traits>& + operator>>(std::basic_istream<_CharT, _Traits>& __is, + std::negative_binomial_distribution<_IntType1>& __x); + + private: + template + void + __generate_impl(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng); + template + void + __generate_impl(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __p); + + param_type _M_param; + + std::gamma_distribution _M_gd; + }; + + /** + * @brief Return true if two negative binomial distributions are different. + */ + template + inline bool + operator!=(const std::negative_binomial_distribution<_IntType>& __d1, + const std::negative_binomial_distribution<_IntType>& __d2) + { return !(__d1 == __d2); } + + + /* @} */ // group random_distributions_bernoulli + + /** + * @addtogroup random_distributions_poisson Poisson Distributions + * @ingroup random_distributions + * @{ + */ + + /** + * @brief A discrete Poisson random number distribution. + * + * The formula for the Poisson probability density function is + * @f$p(i|\mu) = \frac{\mu^i}{i!} e^{-\mu}@f$ where @f$\mu@f$ is the + * parameter of the distribution. + */ + template + class poisson_distribution + { + static_assert(std::is_integral<_IntType>::value, + "template argument not an integral type"); + + public: + /** The type of the range of the distribution. */ + typedef _IntType result_type; + /** Parameter type. */ + struct param_type + { + typedef poisson_distribution<_IntType> distribution_type; + friend class poisson_distribution<_IntType>; + + explicit + param_type(double __mean = 1.0) + : _M_mean(__mean) + { + _GLIBCXX_DEBUG_ASSERT(_M_mean > 0.0); + _M_initialize(); + } + + double + mean() const + { return _M_mean; } + + friend bool + operator==(const param_type& __p1, const param_type& __p2) + { return __p1._M_mean == __p2._M_mean; } + + private: + // Hosts either log(mean) or the threshold of the simple method. + void + _M_initialize(); + + double _M_mean; + + double _M_lm_thr; +#if _GLIBCXX_USE_C99_MATH_TR1 + double _M_lfm, _M_sm, _M_d, _M_scx, _M_1cx, _M_c2b, _M_cb; +#endif + }; + + // constructors and member function + explicit + poisson_distribution(double __mean = 1.0) + : _M_param(__mean), _M_nd() + { } + + explicit + poisson_distribution(const param_type& __p) + : _M_param(__p), _M_nd() + { } + + /** + * @brief Resets the distribution state. + */ + void + reset() + { _M_nd.reset(); } + + /** + * @brief Returns the distribution parameter @p mean. + */ + double + mean() const + { return _M_param.mean(); } + + /** + * @brief Returns the parameter set of the distribution. + */ + param_type + param() const + { return _M_param; } + + /** + * @brief Sets the parameter set of the distribution. + * @param __param The new parameter set of the distribution. + */ + void + param(const param_type& __param) + { _M_param = __param; } + + /** + * @brief Returns the greatest lower bound value of the distribution. + */ + result_type + min() const + { return 0; } + + /** + * @brief Returns the least upper bound value of the distribution. + */ + result_type + max() const + { return std::numeric_limits::max(); } + + /** + * @brief Generating functions. + */ + template + result_type + operator()(_UniformRandomNumberGenerator& __urng) + { return this->operator()(__urng, _M_param); } + + template + result_type + operator()(_UniformRandomNumberGenerator& __urng, + const param_type& __p); + + template + void + __generate(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng) + { this->__generate(__f, __t, __urng, _M_param); } + + template + void + __generate(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __p) + { this->__generate_impl(__f, __t, __urng, __p); } + + template + void + __generate(result_type* __f, result_type* __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __p) + { this->__generate_impl(__f, __t, __urng, __p); } + + /** + * @brief Return true if two Poisson distributions have the same + * parameters and the sequences that would be generated + * are equal. + */ + friend bool + operator==(const poisson_distribution& __d1, + const poisson_distribution& __d2) +#ifdef _GLIBCXX_USE_C99_MATH_TR1 + { return __d1._M_param == __d2._M_param && __d1._M_nd == __d2._M_nd; } +#else + { return __d1._M_param == __d2._M_param; } +#endif + + /** + * @brief Inserts a %poisson_distribution random number distribution + * @p __x into the output stream @p __os. + * + * @param __os An output stream. + * @param __x A %poisson_distribution random number distribution. + * + * @returns The output stream with the state of @p __x inserted or in + * an error state. + */ + template + friend std::basic_ostream<_CharT, _Traits>& + operator<<(std::basic_ostream<_CharT, _Traits>& __os, + const std::poisson_distribution<_IntType1>& __x); + + /** + * @brief Extracts a %poisson_distribution random number distribution + * @p __x from the input stream @p __is. + * + * @param __is An input stream. + * @param __x A %poisson_distribution random number generator engine. + * + * @returns The input stream with @p __x extracted or in an error + * state. + */ + template + friend std::basic_istream<_CharT, _Traits>& + operator>>(std::basic_istream<_CharT, _Traits>& __is, + std::poisson_distribution<_IntType1>& __x); + + private: + template + void + __generate_impl(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __p); + + param_type _M_param; + + // NB: Unused when _GLIBCXX_USE_C99_MATH_TR1 is undefined. + std::normal_distribution _M_nd; + }; + + /** + * @brief Return true if two Poisson distributions are different. + */ + template + inline bool + operator!=(const std::poisson_distribution<_IntType>& __d1, + const std::poisson_distribution<_IntType>& __d2) + { return !(__d1 == __d2); } + + + /** + * @brief An exponential continuous distribution for random numbers. + * + * The formula for the exponential probability density function is + * @f$p(x|\lambda) = \lambda e^{-\lambda x}@f$. + * + * + * + * + * + * + * + * + *
Distribution Statistics
Mean@f$\frac{1}{\lambda}@f$
Median@f$\frac{\ln 2}{\lambda}@f$
Mode@f$zero@f$
Range@f$[0, \infty]@f$
Standard Deviation@f$\frac{1}{\lambda}@f$
+ */ + template + class exponential_distribution + { + static_assert(std::is_floating_point<_RealType>::value, + "template argument not a floating point type"); + + public: + /** The type of the range of the distribution. */ + typedef _RealType result_type; + /** Parameter type. */ + struct param_type + { + typedef exponential_distribution<_RealType> distribution_type; + + explicit + param_type(_RealType __lambda = _RealType(1)) + : _M_lambda(__lambda) + { + _GLIBCXX_DEBUG_ASSERT(_M_lambda > _RealType(0)); + } + + _RealType + lambda() const + { return _M_lambda; } + + friend bool + operator==(const param_type& __p1, const param_type& __p2) + { return __p1._M_lambda == __p2._M_lambda; } + + private: + _RealType _M_lambda; + }; + + public: + /** + * @brief Constructs an exponential distribution with inverse scale + * parameter @f$\lambda@f$. + */ + explicit + exponential_distribution(const result_type& __lambda = result_type(1)) + : _M_param(__lambda) + { } + + explicit + exponential_distribution(const param_type& __p) + : _M_param(__p) + { } + + /** + * @brief Resets the distribution state. + * + * Has no effect on exponential distributions. + */ + void + reset() { } + + /** + * @brief Returns the inverse scale parameter of the distribution. + */ + _RealType + lambda() const + { return _M_param.lambda(); } + + /** + * @brief Returns the parameter set of the distribution. + */ + param_type + param() const + { return _M_param; } + + /** + * @brief Sets the parameter set of the distribution. + * @param __param The new parameter set of the distribution. + */ + void + param(const param_type& __param) + { _M_param = __param; } + + /** + * @brief Returns the greatest lower bound value of the distribution. + */ + result_type + min() const + { return result_type(0); } + + /** + * @brief Returns the least upper bound value of the distribution. + */ + result_type + max() const + { return std::numeric_limits::max(); } + + /** + * @brief Generating functions. + */ + template + result_type + operator()(_UniformRandomNumberGenerator& __urng) + { return this->operator()(__urng, _M_param); } + + template + result_type + operator()(_UniformRandomNumberGenerator& __urng, + const param_type& __p) + { + __detail::_Adaptor<_UniformRandomNumberGenerator, result_type> + __aurng(__urng); + return -std::log(result_type(1) - __aurng()) / __p.lambda(); + } + + template + void + __generate(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng) + { this->__generate(__f, __t, __urng, _M_param); } + + template + void + __generate(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __p) + { this->__generate_impl(__f, __t, __urng, __p); } + + template + void + __generate(result_type* __f, result_type* __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __p) + { this->__generate_impl(__f, __t, __urng, __p); } + + /** + * @brief Return true if two exponential distributions have the same + * parameters. + */ + friend bool + operator==(const exponential_distribution& __d1, + const exponential_distribution& __d2) + { return __d1._M_param == __d2._M_param; } + + private: + template + void + __generate_impl(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __p); + + param_type _M_param; + }; + + /** + * @brief Return true if two exponential distributions have different + * parameters. + */ + template + inline bool + operator!=(const std::exponential_distribution<_RealType>& __d1, + const std::exponential_distribution<_RealType>& __d2) + { return !(__d1 == __d2); } + + /** + * @brief Inserts a %exponential_distribution random number distribution + * @p __x into the output stream @p __os. + * + * @param __os An output stream. + * @param __x A %exponential_distribution random number distribution. + * + * @returns The output stream with the state of @p __x inserted or in + * an error state. + */ + template + std::basic_ostream<_CharT, _Traits>& + operator<<(std::basic_ostream<_CharT, _Traits>& __os, + const std::exponential_distribution<_RealType>& __x); + + /** + * @brief Extracts a %exponential_distribution random number distribution + * @p __x from the input stream @p __is. + * + * @param __is An input stream. + * @param __x A %exponential_distribution random number + * generator engine. + * + * @returns The input stream with @p __x extracted or in an error state. + */ + template + std::basic_istream<_CharT, _Traits>& + operator>>(std::basic_istream<_CharT, _Traits>& __is, + std::exponential_distribution<_RealType>& __x); + + + /** + * @brief A weibull_distribution random number distribution. + * + * The formula for the normal probability density function is: + * @f[ + * p(x|\alpha,\beta) = \frac{\alpha}{\beta} (\frac{x}{\beta})^{\alpha-1} + * \exp{(-(\frac{x}{\beta})^\alpha)} + * @f] + */ + template + class weibull_distribution + { + static_assert(std::is_floating_point<_RealType>::value, + "template argument not a floating point type"); + + public: + /** The type of the range of the distribution. */ + typedef _RealType result_type; + /** Parameter type. */ + struct param_type + { + typedef weibull_distribution<_RealType> distribution_type; + + explicit + param_type(_RealType __a = _RealType(1), + _RealType __b = _RealType(1)) + : _M_a(__a), _M_b(__b) + { } + + _RealType + a() const + { return _M_a; } + + _RealType + b() const + { return _M_b; } + + friend bool + operator==(const param_type& __p1, const param_type& __p2) + { return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; } + + private: + _RealType _M_a; + _RealType _M_b; + }; + + explicit + weibull_distribution(_RealType __a = _RealType(1), + _RealType __b = _RealType(1)) + : _M_param(__a, __b) + { } + + explicit + weibull_distribution(const param_type& __p) + : _M_param(__p) + { } + + /** + * @brief Resets the distribution state. + */ + void + reset() + { } + + /** + * @brief Return the @f$a@f$ parameter of the distribution. + */ + _RealType + a() const + { return _M_param.a(); } + + /** + * @brief Return the @f$b@f$ parameter of the distribution. + */ + _RealType + b() const + { return _M_param.b(); } + + /** + * @brief Returns the parameter set of the distribution. + */ + param_type + param() const + { return _M_param; } + + /** + * @brief Sets the parameter set of the distribution. + * @param __param The new parameter set of the distribution. + */ + void + param(const param_type& __param) + { _M_param = __param; } + + /** + * @brief Returns the greatest lower bound value of the distribution. + */ + result_type + min() const + { return result_type(0); } + + /** + * @brief Returns the least upper bound value of the distribution. + */ + result_type + max() const + { return std::numeric_limits::max(); } + + /** + * @brief Generating functions. + */ + template + result_type + operator()(_UniformRandomNumberGenerator& __urng) + { return this->operator()(__urng, _M_param); } + + template + result_type + operator()(_UniformRandomNumberGenerator& __urng, + const param_type& __p); + + template + void + __generate(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng) + { this->__generate(__f, __t, __urng, _M_param); } + + template + void + __generate(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __p) + { this->__generate_impl(__f, __t, __urng, __p); } + + template + void + __generate(result_type* __f, result_type* __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __p) + { this->__generate_impl(__f, __t, __urng, __p); } + + /** + * @brief Return true if two Weibull distributions have the same + * parameters. + */ + friend bool + operator==(const weibull_distribution& __d1, + const weibull_distribution& __d2) + { return __d1._M_param == __d2._M_param; } + + private: + template + void + __generate_impl(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __p); + + param_type _M_param; + }; + + /** + * @brief Return true if two Weibull distributions have different + * parameters. + */ + template + inline bool + operator!=(const std::weibull_distribution<_RealType>& __d1, + const std::weibull_distribution<_RealType>& __d2) + { return !(__d1 == __d2); } + + /** + * @brief Inserts a %weibull_distribution random number distribution + * @p __x into the output stream @p __os. + * + * @param __os An output stream. + * @param __x A %weibull_distribution random number distribution. + * + * @returns The output stream with the state of @p __x inserted or in + * an error state. + */ + template + std::basic_ostream<_CharT, _Traits>& + operator<<(std::basic_ostream<_CharT, _Traits>& __os, + const std::weibull_distribution<_RealType>& __x); + + /** + * @brief Extracts a %weibull_distribution random number distribution + * @p __x from the input stream @p __is. + * + * @param __is An input stream. + * @param __x A %weibull_distribution random number + * generator engine. + * + * @returns The input stream with @p __x extracted or in an error state. + */ + template + std::basic_istream<_CharT, _Traits>& + operator>>(std::basic_istream<_CharT, _Traits>& __is, + std::weibull_distribution<_RealType>& __x); + + + /** + * @brief A extreme_value_distribution random number distribution. + * + * The formula for the normal probability mass function is + * @f[ + * p(x|a,b) = \frac{1}{b} + * \exp( \frac{a-x}{b} - \exp(\frac{a-x}{b})) + * @f] + */ + template + class extreme_value_distribution + { + static_assert(std::is_floating_point<_RealType>::value, + "template argument not a floating point type"); + + public: + /** The type of the range of the distribution. */ + typedef _RealType result_type; + /** Parameter type. */ + struct param_type + { + typedef extreme_value_distribution<_RealType> distribution_type; + + explicit + param_type(_RealType __a = _RealType(0), + _RealType __b = _RealType(1)) + : _M_a(__a), _M_b(__b) + { } + + _RealType + a() const + { return _M_a; } + + _RealType + b() const + { return _M_b; } + + friend bool + operator==(const param_type& __p1, const param_type& __p2) + { return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; } + + private: + _RealType _M_a; + _RealType _M_b; + }; + + explicit + extreme_value_distribution(_RealType __a = _RealType(0), + _RealType __b = _RealType(1)) + : _M_param(__a, __b) + { } + + explicit + extreme_value_distribution(const param_type& __p) + : _M_param(__p) + { } + + /** + * @brief Resets the distribution state. + */ + void + reset() + { } + + /** + * @brief Return the @f$a@f$ parameter of the distribution. + */ + _RealType + a() const + { return _M_param.a(); } + + /** + * @brief Return the @f$b@f$ parameter of the distribution. + */ + _RealType + b() const + { return _M_param.b(); } + + /** + * @brief Returns the parameter set of the distribution. + */ + param_type + param() const + { return _M_param; } + + /** + * @brief Sets the parameter set of the distribution. + * @param __param The new parameter set of the distribution. + */ + void + param(const param_type& __param) + { _M_param = __param; } + + /** + * @brief Returns the greatest lower bound value of the distribution. + */ + result_type + min() const + { return std::numeric_limits::lowest(); } + + /** + * @brief Returns the least upper bound value of the distribution. + */ + result_type + max() const + { return std::numeric_limits::max(); } + + /** + * @brief Generating functions. + */ + template + result_type + operator()(_UniformRandomNumberGenerator& __urng) + { return this->operator()(__urng, _M_param); } + + template + result_type + operator()(_UniformRandomNumberGenerator& __urng, + const param_type& __p); + + template + void + __generate(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng) + { this->__generate(__f, __t, __urng, _M_param); } + + template + void + __generate(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __p) + { this->__generate_impl(__f, __t, __urng, __p); } + + template + void + __generate(result_type* __f, result_type* __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __p) + { this->__generate_impl(__f, __t, __urng, __p); } + + /** + * @brief Return true if two extreme value distributions have the same + * parameters. + */ + friend bool + operator==(const extreme_value_distribution& __d1, + const extreme_value_distribution& __d2) + { return __d1._M_param == __d2._M_param; } + + private: + template + void + __generate_impl(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __p); + + param_type _M_param; + }; + + /** + * @brief Return true if two extreme value distributions have different + * parameters. + */ + template + inline bool + operator!=(const std::extreme_value_distribution<_RealType>& __d1, + const std::extreme_value_distribution<_RealType>& __d2) + { return !(__d1 == __d2); } + + /** + * @brief Inserts a %extreme_value_distribution random number distribution + * @p __x into the output stream @p __os. + * + * @param __os An output stream. + * @param __x A %extreme_value_distribution random number distribution. + * + * @returns The output stream with the state of @p __x inserted or in + * an error state. + */ + template + std::basic_ostream<_CharT, _Traits>& + operator<<(std::basic_ostream<_CharT, _Traits>& __os, + const std::extreme_value_distribution<_RealType>& __x); + + /** + * @brief Extracts a %extreme_value_distribution random number + * distribution @p __x from the input stream @p __is. + * + * @param __is An input stream. + * @param __x A %extreme_value_distribution random number + * generator engine. + * + * @returns The input stream with @p __x extracted or in an error state. + */ + template + std::basic_istream<_CharT, _Traits>& + operator>>(std::basic_istream<_CharT, _Traits>& __is, + std::extreme_value_distribution<_RealType>& __x); + + + /** + * @brief A discrete_distribution random number distribution. + * + * The formula for the discrete probability mass function is + * + */ + template + class discrete_distribution + { + static_assert(std::is_integral<_IntType>::value, + "template argument not an integral type"); + + public: + /** The type of the range of the distribution. */ + typedef _IntType result_type; + /** Parameter type. */ + struct param_type + { + typedef discrete_distribution<_IntType> distribution_type; + friend class discrete_distribution<_IntType>; + + param_type() + : _M_prob(), _M_cp() + { } + + template + param_type(_InputIterator __wbegin, + _InputIterator __wend) + : _M_prob(__wbegin, __wend), _M_cp() + { _M_initialize(); } + + param_type(initializer_list __wil) + : _M_prob(__wil.begin(), __wil.end()), _M_cp() + { _M_initialize(); } + + template + param_type(size_t __nw, double __xmin, double __xmax, + _Func __fw); + + // See: http://cpp-next.com/archive/2010/10/implicit-move-must-go/ + param_type(const param_type&) = default; + param_type& operator=(const param_type&) = default; + + std::vector + probabilities() const + { return _M_prob.empty() ? std::vector(1, 1.0) : _M_prob; } + + friend bool + operator==(const param_type& __p1, const param_type& __p2) + { return __p1._M_prob == __p2._M_prob; } + + private: + void + _M_initialize(); + + std::vector _M_prob; + std::vector _M_cp; + }; + + discrete_distribution() + : _M_param() + { } + + template + discrete_distribution(_InputIterator __wbegin, + _InputIterator __wend) + : _M_param(__wbegin, __wend) + { } + + discrete_distribution(initializer_list __wl) + : _M_param(__wl) + { } + + template + discrete_distribution(size_t __nw, double __xmin, double __xmax, + _Func __fw) + : _M_param(__nw, __xmin, __xmax, __fw) + { } + + explicit + discrete_distribution(const param_type& __p) + : _M_param(__p) + { } + + /** + * @brief Resets the distribution state. + */ + void + reset() + { } + + /** + * @brief Returns the probabilities of the distribution. + */ + std::vector + probabilities() const + { + return _M_param._M_prob.empty() + ? std::vector(1, 1.0) : _M_param._M_prob; + } + + /** + * @brief Returns the parameter set of the distribution. + */ + param_type + param() const + { return _M_param; } + + /** + * @brief Sets the parameter set of the distribution. + * @param __param The new parameter set of the distribution. + */ + void + param(const param_type& __param) + { _M_param = __param; } + + /** + * @brief Returns the greatest lower bound value of the distribution. + */ + result_type + min() const + { return result_type(0); } + + /** + * @brief Returns the least upper bound value of the distribution. + */ + result_type + max() const + { + return _M_param._M_prob.empty() + ? result_type(0) : result_type(_M_param._M_prob.size() - 1); + } + + /** + * @brief Generating functions. + */ + template + result_type + operator()(_UniformRandomNumberGenerator& __urng) + { return this->operator()(__urng, _M_param); } + + template + result_type + operator()(_UniformRandomNumberGenerator& __urng, + const param_type& __p); + + template + void + __generate(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng) + { this->__generate(__f, __t, __urng, _M_param); } + + template + void + __generate(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __p) + { this->__generate_impl(__f, __t, __urng, __p); } + + template + void + __generate(result_type* __f, result_type* __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __p) + { this->__generate_impl(__f, __t, __urng, __p); } + + /** + * @brief Return true if two discrete distributions have the same + * parameters. + */ + friend bool + operator==(const discrete_distribution& __d1, + const discrete_distribution& __d2) + { return __d1._M_param == __d2._M_param; } + + /** + * @brief Inserts a %discrete_distribution random number distribution + * @p __x into the output stream @p __os. + * + * @param __os An output stream. + * @param __x A %discrete_distribution random number distribution. + * + * @returns The output stream with the state of @p __x inserted or in + * an error state. + */ + template + friend std::basic_ostream<_CharT, _Traits>& + operator<<(std::basic_ostream<_CharT, _Traits>& __os, + const std::discrete_distribution<_IntType1>& __x); + + /** + * @brief Extracts a %discrete_distribution random number distribution + * @p __x from the input stream @p __is. + * + * @param __is An input stream. + * @param __x A %discrete_distribution random number + * generator engine. + * + * @returns The input stream with @p __x extracted or in an error + * state. + */ + template + friend std::basic_istream<_CharT, _Traits>& + operator>>(std::basic_istream<_CharT, _Traits>& __is, + std::discrete_distribution<_IntType1>& __x); + + private: + template + void + __generate_impl(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __p); + + param_type _M_param; + }; + + /** + * @brief Return true if two discrete distributions have different + * parameters. + */ + template + inline bool + operator!=(const std::discrete_distribution<_IntType>& __d1, + const std::discrete_distribution<_IntType>& __d2) + { return !(__d1 == __d2); } + + + /** + * @brief A piecewise_constant_distribution random number distribution. + * + * The formula for the piecewise constant probability mass function is + * + */ + template + class piecewise_constant_distribution + { + static_assert(std::is_floating_point<_RealType>::value, + "template argument not a floating point type"); + + public: + /** The type of the range of the distribution. */ + typedef _RealType result_type; + /** Parameter type. */ + struct param_type + { + typedef piecewise_constant_distribution<_RealType> distribution_type; + friend class piecewise_constant_distribution<_RealType>; + + param_type() + : _M_int(), _M_den(), _M_cp() + { } + + template + param_type(_InputIteratorB __bfirst, + _InputIteratorB __bend, + _InputIteratorW __wbegin); + + template + param_type(initializer_list<_RealType> __bi, _Func __fw); + + template + param_type(size_t __nw, _RealType __xmin, _RealType __xmax, + _Func __fw); + + // See: http://cpp-next.com/archive/2010/10/implicit-move-must-go/ + param_type(const param_type&) = default; + param_type& operator=(const param_type&) = default; + + std::vector<_RealType> + intervals() const + { + if (_M_int.empty()) + { + std::vector<_RealType> __tmp(2); + __tmp[1] = _RealType(1); + return __tmp; + } + else + return _M_int; + } + + std::vector + densities() const + { return _M_den.empty() ? std::vector(1, 1.0) : _M_den; } + + friend bool + operator==(const param_type& __p1, const param_type& __p2) + { return __p1._M_int == __p2._M_int && __p1._M_den == __p2._M_den; } + + private: + void + _M_initialize(); + + std::vector<_RealType> _M_int; + std::vector _M_den; + std::vector _M_cp; + }; + + explicit + piecewise_constant_distribution() + : _M_param() + { } + + template + piecewise_constant_distribution(_InputIteratorB __bfirst, + _InputIteratorB __bend, + _InputIteratorW __wbegin) + : _M_param(__bfirst, __bend, __wbegin) + { } + + template + piecewise_constant_distribution(initializer_list<_RealType> __bl, + _Func __fw) + : _M_param(__bl, __fw) + { } + + template + piecewise_constant_distribution(size_t __nw, + _RealType __xmin, _RealType __xmax, + _Func __fw) + : _M_param(__nw, __xmin, __xmax, __fw) + { } + + explicit + piecewise_constant_distribution(const param_type& __p) + : _M_param(__p) + { } + + /** + * @brief Resets the distribution state. + */ + void + reset() + { } + + /** + * @brief Returns a vector of the intervals. + */ + std::vector<_RealType> + intervals() const + { + if (_M_param._M_int.empty()) + { + std::vector<_RealType> __tmp(2); + __tmp[1] = _RealType(1); + return __tmp; + } + else + return _M_param._M_int; + } + + /** + * @brief Returns a vector of the probability densities. + */ + std::vector + densities() const + { + return _M_param._M_den.empty() + ? std::vector(1, 1.0) : _M_param._M_den; + } + + /** + * @brief Returns the parameter set of the distribution. + */ + param_type + param() const + { return _M_param; } + + /** + * @brief Sets the parameter set of the distribution. + * @param __param The new parameter set of the distribution. + */ + void + param(const param_type& __param) + { _M_param = __param; } + + /** + * @brief Returns the greatest lower bound value of the distribution. + */ + result_type + min() const + { + return _M_param._M_int.empty() + ? result_type(0) : _M_param._M_int.front(); + } + + /** + * @brief Returns the least upper bound value of the distribution. + */ + result_type + max() const + { + return _M_param._M_int.empty() + ? result_type(1) : _M_param._M_int.back(); + } + + /** + * @brief Generating functions. + */ + template + result_type + operator()(_UniformRandomNumberGenerator& __urng) + { return this->operator()(__urng, _M_param); } + + template + result_type + operator()(_UniformRandomNumberGenerator& __urng, + const param_type& __p); + + template + void + __generate(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng) + { this->__generate(__f, __t, __urng, _M_param); } + + template + void + __generate(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __p) + { this->__generate_impl(__f, __t, __urng, __p); } + + template + void + __generate(result_type* __f, result_type* __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __p) + { this->__generate_impl(__f, __t, __urng, __p); } + + /** + * @brief Return true if two piecewise constant distributions have the + * same parameters. + */ + friend bool + operator==(const piecewise_constant_distribution& __d1, + const piecewise_constant_distribution& __d2) + { return __d1._M_param == __d2._M_param; } + + /** + * @brief Inserts a %piecewise_constant_distribution random + * number distribution @p __x into the output stream @p __os. + * + * @param __os An output stream. + * @param __x A %piecewise_constant_distribution random number + * distribution. + * + * @returns The output stream with the state of @p __x inserted or in + * an error state. + */ + template + friend std::basic_ostream<_CharT, _Traits>& + operator<<(std::basic_ostream<_CharT, _Traits>& __os, + const std::piecewise_constant_distribution<_RealType1>& __x); + + /** + * @brief Extracts a %piecewise_constant_distribution random + * number distribution @p __x from the input stream @p __is. + * + * @param __is An input stream. + * @param __x A %piecewise_constant_distribution random number + * generator engine. + * + * @returns The input stream with @p __x extracted or in an error + * state. + */ + template + friend std::basic_istream<_CharT, _Traits>& + operator>>(std::basic_istream<_CharT, _Traits>& __is, + std::piecewise_constant_distribution<_RealType1>& __x); + + private: + template + void + __generate_impl(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __p); + + param_type _M_param; + }; + + /** + * @brief Return true if two piecewise constant distributions have + * different parameters. + */ + template + inline bool + operator!=(const std::piecewise_constant_distribution<_RealType>& __d1, + const std::piecewise_constant_distribution<_RealType>& __d2) + { return !(__d1 == __d2); } + + + /** + * @brief A piecewise_linear_distribution random number distribution. + * + * The formula for the piecewise linear probability mass function is + * + */ + template + class piecewise_linear_distribution + { + static_assert(std::is_floating_point<_RealType>::value, + "template argument not a floating point type"); + + public: + /** The type of the range of the distribution. */ + typedef _RealType result_type; + /** Parameter type. */ + struct param_type + { + typedef piecewise_linear_distribution<_RealType> distribution_type; + friend class piecewise_linear_distribution<_RealType>; + + param_type() + : _M_int(), _M_den(), _M_cp(), _M_m() + { } + + template + param_type(_InputIteratorB __bfirst, + _InputIteratorB __bend, + _InputIteratorW __wbegin); + + template + param_type(initializer_list<_RealType> __bl, _Func __fw); + + template + param_type(size_t __nw, _RealType __xmin, _RealType __xmax, + _Func __fw); + + // See: http://cpp-next.com/archive/2010/10/implicit-move-must-go/ + param_type(const param_type&) = default; + param_type& operator=(const param_type&) = default; + + std::vector<_RealType> + intervals() const + { + if (_M_int.empty()) + { + std::vector<_RealType> __tmp(2); + __tmp[1] = _RealType(1); + return __tmp; + } + else + return _M_int; + } + + std::vector + densities() const + { return _M_den.empty() ? std::vector(2, 1.0) : _M_den; } + + friend bool + operator==(const param_type& __p1, const param_type& __p2) + { return (__p1._M_int == __p2._M_int + && __p1._M_den == __p2._M_den); } + + private: + void + _M_initialize(); + + std::vector<_RealType> _M_int; + std::vector _M_den; + std::vector _M_cp; + std::vector _M_m; + }; + + explicit + piecewise_linear_distribution() + : _M_param() + { } + + template + piecewise_linear_distribution(_InputIteratorB __bfirst, + _InputIteratorB __bend, + _InputIteratorW __wbegin) + : _M_param(__bfirst, __bend, __wbegin) + { } + + template + piecewise_linear_distribution(initializer_list<_RealType> __bl, + _Func __fw) + : _M_param(__bl, __fw) + { } + + template + piecewise_linear_distribution(size_t __nw, + _RealType __xmin, _RealType __xmax, + _Func __fw) + : _M_param(__nw, __xmin, __xmax, __fw) + { } + + explicit + piecewise_linear_distribution(const param_type& __p) + : _M_param(__p) + { } + + /** + * Resets the distribution state. + */ + void + reset() + { } + + /** + * @brief Return the intervals of the distribution. + */ + std::vector<_RealType> + intervals() const + { + if (_M_param._M_int.empty()) + { + std::vector<_RealType> __tmp(2); + __tmp[1] = _RealType(1); + return __tmp; + } + else + return _M_param._M_int; + } + + /** + * @brief Return a vector of the probability densities of the + * distribution. + */ + std::vector + densities() const + { + return _M_param._M_den.empty() + ? std::vector(2, 1.0) : _M_param._M_den; + } + + /** + * @brief Returns the parameter set of the distribution. + */ + param_type + param() const + { return _M_param; } + + /** + * @brief Sets the parameter set of the distribution. + * @param __param The new parameter set of the distribution. + */ + void + param(const param_type& __param) + { _M_param = __param; } + + /** + * @brief Returns the greatest lower bound value of the distribution. + */ + result_type + min() const + { + return _M_param._M_int.empty() + ? result_type(0) : _M_param._M_int.front(); + } + + /** + * @brief Returns the least upper bound value of the distribution. + */ + result_type + max() const + { + return _M_param._M_int.empty() + ? result_type(1) : _M_param._M_int.back(); + } + + /** + * @brief Generating functions. + */ + template + result_type + operator()(_UniformRandomNumberGenerator& __urng) + { return this->operator()(__urng, _M_param); } + + template + result_type + operator()(_UniformRandomNumberGenerator& __urng, + const param_type& __p); + + template + void + __generate(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng) + { this->__generate(__f, __t, __urng, _M_param); } + + template + void + __generate(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __p) + { this->__generate_impl(__f, __t, __urng, __p); } + + template + void + __generate(result_type* __f, result_type* __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __p) + { this->__generate_impl(__f, __t, __urng, __p); } + + /** + * @brief Return true if two piecewise linear distributions have the + * same parameters. + */ + friend bool + operator==(const piecewise_linear_distribution& __d1, + const piecewise_linear_distribution& __d2) + { return __d1._M_param == __d2._M_param; } + + /** + * @brief Inserts a %piecewise_linear_distribution random number + * distribution @p __x into the output stream @p __os. + * + * @param __os An output stream. + * @param __x A %piecewise_linear_distribution random number + * distribution. + * + * @returns The output stream with the state of @p __x inserted or in + * an error state. + */ + template + friend std::basic_ostream<_CharT, _Traits>& + operator<<(std::basic_ostream<_CharT, _Traits>& __os, + const std::piecewise_linear_distribution<_RealType1>& __x); + + /** + * @brief Extracts a %piecewise_linear_distribution random number + * distribution @p __x from the input stream @p __is. + * + * @param __is An input stream. + * @param __x A %piecewise_linear_distribution random number + * generator engine. + * + * @returns The input stream with @p __x extracted or in an error + * state. + */ + template + friend std::basic_istream<_CharT, _Traits>& + operator>>(std::basic_istream<_CharT, _Traits>& __is, + std::piecewise_linear_distribution<_RealType1>& __x); + + private: + template + void + __generate_impl(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __p); + + param_type _M_param; + }; + + /** + * @brief Return true if two piecewise linear distributions have + * different parameters. + */ + template + inline bool + operator!=(const std::piecewise_linear_distribution<_RealType>& __d1, + const std::piecewise_linear_distribution<_RealType>& __d2) + { return !(__d1 == __d2); } + + + /* @} */ // group random_distributions_poisson + + /* @} */ // group random_distributions + + /** + * @addtogroup random_utilities Random Number Utilities + * @ingroup random + * @{ + */ + + /** + * @brief The seed_seq class generates sequences of seeds for random + * number generators. + */ + class seed_seq + { + + public: + /** The type of the seed vales. */ + typedef uint_least32_t result_type; + + /** Default constructor. */ + seed_seq() + : _M_v() + { } + + template + seed_seq(std::initializer_list<_IntType> il); + + template + seed_seq(_InputIterator __begin, _InputIterator __end); + + // generating functions + template + void + generate(_RandomAccessIterator __begin, _RandomAccessIterator __end); + + // property functions + size_t size() const + { return _M_v.size(); } + + template + void + param(OutputIterator __dest) const + { std::copy(_M_v.begin(), _M_v.end(), __dest); } + + private: + /// + std::vector _M_v; + }; + + /* @} */ // group random_utilities + + /* @} */ // group random + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace std + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/random.tcc b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/random.tcc new file mode 100755 index 0000000..8849ee9 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/random.tcc @@ -0,0 +1,3489 @@ +// random number generation (out of line) -*- C++ -*- + +// Copyright (C) 2009-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file bits/random.tcc + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{random} + */ + +#ifndef _RANDOM_TCC +#define _RANDOM_TCC 1 + +#include // std::accumulate and std::partial_sum + +namespace std _GLIBCXX_VISIBILITY(default) +{ + /* + * (Further) implementation-space details. + */ + namespace __detail + { + _GLIBCXX_BEGIN_NAMESPACE_VERSION + + // General case for x = (ax + c) mod m -- use Schrage's algorithm + // to avoid integer overflow. + // + // Preconditions: a > 0, m > 0. + // + // Note: only works correctly for __m % __a < __m / __a. + template + _Tp + _Mod<_Tp, __m, __a, __c, false, true>:: + __calc(_Tp __x) + { + if (__a == 1) + __x %= __m; + else + { + static const _Tp __q = __m / __a; + static const _Tp __r = __m % __a; + + _Tp __t1 = __a * (__x % __q); + _Tp __t2 = __r * (__x / __q); + if (__t1 >= __t2) + __x = __t1 - __t2; + else + __x = __m - __t2 + __t1; + } + + if (__c != 0) + { + const _Tp __d = __m - __x; + if (__d > __c) + __x += __c; + else + __x = __c - __d; + } + return __x; + } + + template + _OutputIterator + __normalize(_InputIterator __first, _InputIterator __last, + _OutputIterator __result, const _Tp& __factor) + { + for (; __first != __last; ++__first, ++__result) + *__result = *__first / __factor; + return __result; + } + + _GLIBCXX_END_NAMESPACE_VERSION + } // namespace __detail + +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + template + constexpr _UIntType + linear_congruential_engine<_UIntType, __a, __c, __m>::multiplier; + + template + constexpr _UIntType + linear_congruential_engine<_UIntType, __a, __c, __m>::increment; + + template + constexpr _UIntType + linear_congruential_engine<_UIntType, __a, __c, __m>::modulus; + + template + constexpr _UIntType + linear_congruential_engine<_UIntType, __a, __c, __m>::default_seed; + + /** + * Seeds the LCR with integral value @p __s, adjusted so that the + * ring identity is never a member of the convergence set. + */ + template + void + linear_congruential_engine<_UIntType, __a, __c, __m>:: + seed(result_type __s) + { + if ((__detail::__mod<_UIntType, __m>(__c) == 0) + && (__detail::__mod<_UIntType, __m>(__s) == 0)) + _M_x = 1; + else + _M_x = __detail::__mod<_UIntType, __m>(__s); + } + + /** + * Seeds the LCR engine with a value generated by @p __q. + */ + template + template + typename std::enable_if::value>::type + linear_congruential_engine<_UIntType, __a, __c, __m>:: + seed(_Sseq& __q) + { + const _UIntType __k0 = __m == 0 ? std::numeric_limits<_UIntType>::digits + : std::__lg(__m); + const _UIntType __k = (__k0 + 31) / 32; + uint_least32_t __arr[__k + 3]; + __q.generate(__arr + 0, __arr + __k + 3); + _UIntType __factor = 1u; + _UIntType __sum = 0u; + for (size_t __j = 0; __j < __k; ++__j) + { + __sum += __arr[__j + 3] * __factor; + __factor *= __detail::_Shift<_UIntType, 32>::__value; + } + seed(__sum); + } + + template + std::basic_ostream<_CharT, _Traits>& + operator<<(std::basic_ostream<_CharT, _Traits>& __os, + const linear_congruential_engine<_UIntType, + __a, __c, __m>& __lcr) + { + typedef std::basic_ostream<_CharT, _Traits> __ostream_type; + typedef typename __ostream_type::ios_base __ios_base; + + const typename __ios_base::fmtflags __flags = __os.flags(); + const _CharT __fill = __os.fill(); + __os.flags(__ios_base::dec | __ios_base::fixed | __ios_base::left); + __os.fill(__os.widen(' ')); + + __os << __lcr._M_x; + + __os.flags(__flags); + __os.fill(__fill); + return __os; + } + + template + std::basic_istream<_CharT, _Traits>& + operator>>(std::basic_istream<_CharT, _Traits>& __is, + linear_congruential_engine<_UIntType, __a, __c, __m>& __lcr) + { + typedef std::basic_istream<_CharT, _Traits> __istream_type; + typedef typename __istream_type::ios_base __ios_base; + + const typename __ios_base::fmtflags __flags = __is.flags(); + __is.flags(__ios_base::dec); + + __is >> __lcr._M_x; + + __is.flags(__flags); + return __is; + } + + + template + constexpr size_t + mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, + __s, __b, __t, __c, __l, __f>::word_size; + + template + constexpr size_t + mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, + __s, __b, __t, __c, __l, __f>::state_size; + + template + constexpr size_t + mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, + __s, __b, __t, __c, __l, __f>::shift_size; + + template + constexpr size_t + mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, + __s, __b, __t, __c, __l, __f>::mask_bits; + + template + constexpr _UIntType + mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, + __s, __b, __t, __c, __l, __f>::xor_mask; + + template + constexpr size_t + mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, + __s, __b, __t, __c, __l, __f>::tempering_u; + + template + constexpr _UIntType + mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, + __s, __b, __t, __c, __l, __f>::tempering_d; + + template + constexpr size_t + mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, + __s, __b, __t, __c, __l, __f>::tempering_s; + + template + constexpr _UIntType + mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, + __s, __b, __t, __c, __l, __f>::tempering_b; + + template + constexpr size_t + mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, + __s, __b, __t, __c, __l, __f>::tempering_t; + + template + constexpr _UIntType + mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, + __s, __b, __t, __c, __l, __f>::tempering_c; + + template + constexpr size_t + mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, + __s, __b, __t, __c, __l, __f>::tempering_l; + + template + constexpr _UIntType + mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, + __s, __b, __t, __c, __l, __f>:: + initialization_multiplier; + + template + constexpr _UIntType + mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, + __s, __b, __t, __c, __l, __f>::default_seed; + + template + void + mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, + __s, __b, __t, __c, __l, __f>:: + seed(result_type __sd) + { + _M_x[0] = __detail::__mod<_UIntType, + __detail::_Shift<_UIntType, __w>::__value>(__sd); + + for (size_t __i = 1; __i < state_size; ++__i) + { + _UIntType __x = _M_x[__i - 1]; + __x ^= __x >> (__w - 2); + __x *= __f; + __x += __detail::__mod<_UIntType, __n>(__i); + _M_x[__i] = __detail::__mod<_UIntType, + __detail::_Shift<_UIntType, __w>::__value>(__x); + } + _M_p = state_size; + } + + template + template + typename std::enable_if::value>::type + mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, + __s, __b, __t, __c, __l, __f>:: + seed(_Sseq& __q) + { + const _UIntType __upper_mask = (~_UIntType()) << __r; + const size_t __k = (__w + 31) / 32; + uint_least32_t __arr[__n * __k]; + __q.generate(__arr + 0, __arr + __n * __k); + + bool __zero = true; + for (size_t __i = 0; __i < state_size; ++__i) + { + _UIntType __factor = 1u; + _UIntType __sum = 0u; + for (size_t __j = 0; __j < __k; ++__j) + { + __sum += __arr[__k * __i + __j] * __factor; + __factor *= __detail::_Shift<_UIntType, 32>::__value; + } + _M_x[__i] = __detail::__mod<_UIntType, + __detail::_Shift<_UIntType, __w>::__value>(__sum); + + if (__zero) + { + if (__i == 0) + { + if ((_M_x[0] & __upper_mask) != 0u) + __zero = false; + } + else if (_M_x[__i] != 0u) + __zero = false; + } + } + if (__zero) + _M_x[0] = __detail::_Shift<_UIntType, __w - 1>::__value; + _M_p = state_size; + } + + template + void + mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, + __s, __b, __t, __c, __l, __f>:: + _M_gen_rand(void) + { + const _UIntType __upper_mask = (~_UIntType()) << __r; + const _UIntType __lower_mask = ~__upper_mask; + + for (size_t __k = 0; __k < (__n - __m); ++__k) + { + _UIntType __y = ((_M_x[__k] & __upper_mask) + | (_M_x[__k + 1] & __lower_mask)); + _M_x[__k] = (_M_x[__k + __m] ^ (__y >> 1) + ^ ((__y & 0x01) ? __a : 0)); + } + + for (size_t __k = (__n - __m); __k < (__n - 1); ++__k) + { + _UIntType __y = ((_M_x[__k] & __upper_mask) + | (_M_x[__k + 1] & __lower_mask)); + _M_x[__k] = (_M_x[__k + (__m - __n)] ^ (__y >> 1) + ^ ((__y & 0x01) ? __a : 0)); + } + + _UIntType __y = ((_M_x[__n - 1] & __upper_mask) + | (_M_x[0] & __lower_mask)); + _M_x[__n - 1] = (_M_x[__m - 1] ^ (__y >> 1) + ^ ((__y & 0x01) ? __a : 0)); + _M_p = 0; + } + + template + void + mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, + __s, __b, __t, __c, __l, __f>:: + discard(unsigned long long __z) + { + while (__z > state_size - _M_p) + { + __z -= state_size - _M_p; + _M_gen_rand(); + } + _M_p += __z; + } + + template + typename + mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, + __s, __b, __t, __c, __l, __f>::result_type + mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, + __s, __b, __t, __c, __l, __f>:: + operator()() + { + // Reload the vector - cost is O(n) amortized over n calls. + if (_M_p >= state_size) + _M_gen_rand(); + + // Calculate o(x(i)). + result_type __z = _M_x[_M_p++]; + __z ^= (__z >> __u) & __d; + __z ^= (__z << __s) & __b; + __z ^= (__z << __t) & __c; + __z ^= (__z >> __l); + + return __z; + } + + template + std::basic_ostream<_CharT, _Traits>& + operator<<(std::basic_ostream<_CharT, _Traits>& __os, + const mersenne_twister_engine<_UIntType, __w, __n, __m, + __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>& __x) + { + typedef std::basic_ostream<_CharT, _Traits> __ostream_type; + typedef typename __ostream_type::ios_base __ios_base; + + const typename __ios_base::fmtflags __flags = __os.flags(); + const _CharT __fill = __os.fill(); + const _CharT __space = __os.widen(' '); + __os.flags(__ios_base::dec | __ios_base::fixed | __ios_base::left); + __os.fill(__space); + + for (size_t __i = 0; __i < __n; ++__i) + __os << __x._M_x[__i] << __space; + __os << __x._M_p; + + __os.flags(__flags); + __os.fill(__fill); + return __os; + } + + template + std::basic_istream<_CharT, _Traits>& + operator>>(std::basic_istream<_CharT, _Traits>& __is, + mersenne_twister_engine<_UIntType, __w, __n, __m, + __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>& __x) + { + typedef std::basic_istream<_CharT, _Traits> __istream_type; + typedef typename __istream_type::ios_base __ios_base; + + const typename __ios_base::fmtflags __flags = __is.flags(); + __is.flags(__ios_base::dec | __ios_base::skipws); + + for (size_t __i = 0; __i < __n; ++__i) + __is >> __x._M_x[__i]; + __is >> __x._M_p; + + __is.flags(__flags); + return __is; + } + + + template + constexpr size_t + subtract_with_carry_engine<_UIntType, __w, __s, __r>::word_size; + + template + constexpr size_t + subtract_with_carry_engine<_UIntType, __w, __s, __r>::short_lag; + + template + constexpr size_t + subtract_with_carry_engine<_UIntType, __w, __s, __r>::long_lag; + + template + constexpr _UIntType + subtract_with_carry_engine<_UIntType, __w, __s, __r>::default_seed; + + template + void + subtract_with_carry_engine<_UIntType, __w, __s, __r>:: + seed(result_type __value) + { + std::linear_congruential_engine + __lcg(__value == 0u ? default_seed : __value); + + const size_t __n = (__w + 31) / 32; + + for (size_t __i = 0; __i < long_lag; ++__i) + { + _UIntType __sum = 0u; + _UIntType __factor = 1u; + for (size_t __j = 0; __j < __n; ++__j) + { + __sum += __detail::__mod::__value> + (__lcg()) * __factor; + __factor *= __detail::_Shift<_UIntType, 32>::__value; + } + _M_x[__i] = __detail::__mod<_UIntType, + __detail::_Shift<_UIntType, __w>::__value>(__sum); + } + _M_carry = (_M_x[long_lag - 1] == 0) ? 1 : 0; + _M_p = 0; + } + + template + template + typename std::enable_if::value>::type + subtract_with_carry_engine<_UIntType, __w, __s, __r>:: + seed(_Sseq& __q) + { + const size_t __k = (__w + 31) / 32; + uint_least32_t __arr[__r * __k]; + __q.generate(__arr + 0, __arr + __r * __k); + + for (size_t __i = 0; __i < long_lag; ++__i) + { + _UIntType __sum = 0u; + _UIntType __factor = 1u; + for (size_t __j = 0; __j < __k; ++__j) + { + __sum += __arr[__k * __i + __j] * __factor; + __factor *= __detail::_Shift<_UIntType, 32>::__value; + } + _M_x[__i] = __detail::__mod<_UIntType, + __detail::_Shift<_UIntType, __w>::__value>(__sum); + } + _M_carry = (_M_x[long_lag - 1] == 0) ? 1 : 0; + _M_p = 0; + } + + template + typename subtract_with_carry_engine<_UIntType, __w, __s, __r>:: + result_type + subtract_with_carry_engine<_UIntType, __w, __s, __r>:: + operator()() + { + // Derive short lag index from current index. + long __ps = _M_p - short_lag; + if (__ps < 0) + __ps += long_lag; + + // Calculate new x(i) without overflow or division. + // NB: Thanks to the requirements for _UIntType, _M_x[_M_p] + _M_carry + // cannot overflow. + _UIntType __xi; + if (_M_x[__ps] >= _M_x[_M_p] + _M_carry) + { + __xi = _M_x[__ps] - _M_x[_M_p] - _M_carry; + _M_carry = 0; + } + else + { + __xi = (__detail::_Shift<_UIntType, __w>::__value + - _M_x[_M_p] - _M_carry + _M_x[__ps]); + _M_carry = 1; + } + _M_x[_M_p] = __xi; + + // Adjust current index to loop around in ring buffer. + if (++_M_p >= long_lag) + _M_p = 0; + + return __xi; + } + + template + std::basic_ostream<_CharT, _Traits>& + operator<<(std::basic_ostream<_CharT, _Traits>& __os, + const subtract_with_carry_engine<_UIntType, + __w, __s, __r>& __x) + { + typedef std::basic_ostream<_CharT, _Traits> __ostream_type; + typedef typename __ostream_type::ios_base __ios_base; + + const typename __ios_base::fmtflags __flags = __os.flags(); + const _CharT __fill = __os.fill(); + const _CharT __space = __os.widen(' '); + __os.flags(__ios_base::dec | __ios_base::fixed | __ios_base::left); + __os.fill(__space); + + for (size_t __i = 0; __i < __r; ++__i) + __os << __x._M_x[__i] << __space; + __os << __x._M_carry << __space << __x._M_p; + + __os.flags(__flags); + __os.fill(__fill); + return __os; + } + + template + std::basic_istream<_CharT, _Traits>& + operator>>(std::basic_istream<_CharT, _Traits>& __is, + subtract_with_carry_engine<_UIntType, __w, __s, __r>& __x) + { + typedef std::basic_ostream<_CharT, _Traits> __istream_type; + typedef typename __istream_type::ios_base __ios_base; + + const typename __ios_base::fmtflags __flags = __is.flags(); + __is.flags(__ios_base::dec | __ios_base::skipws); + + for (size_t __i = 0; __i < __r; ++__i) + __is >> __x._M_x[__i]; + __is >> __x._M_carry; + __is >> __x._M_p; + + __is.flags(__flags); + return __is; + } + + + template + constexpr size_t + discard_block_engine<_RandomNumberEngine, __p, __r>::block_size; + + template + constexpr size_t + discard_block_engine<_RandomNumberEngine, __p, __r>::used_block; + + template + typename discard_block_engine<_RandomNumberEngine, + __p, __r>::result_type + discard_block_engine<_RandomNumberEngine, __p, __r>:: + operator()() + { + if (_M_n >= used_block) + { + _M_b.discard(block_size - _M_n); + _M_n = 0; + } + ++_M_n; + return _M_b(); + } + + template + std::basic_ostream<_CharT, _Traits>& + operator<<(std::basic_ostream<_CharT, _Traits>& __os, + const discard_block_engine<_RandomNumberEngine, + __p, __r>& __x) + { + typedef std::basic_ostream<_CharT, _Traits> __ostream_type; + typedef typename __ostream_type::ios_base __ios_base; + + const typename __ios_base::fmtflags __flags = __os.flags(); + const _CharT __fill = __os.fill(); + const _CharT __space = __os.widen(' '); + __os.flags(__ios_base::dec | __ios_base::fixed | __ios_base::left); + __os.fill(__space); + + __os << __x.base() << __space << __x._M_n; + + __os.flags(__flags); + __os.fill(__fill); + return __os; + } + + template + std::basic_istream<_CharT, _Traits>& + operator>>(std::basic_istream<_CharT, _Traits>& __is, + discard_block_engine<_RandomNumberEngine, __p, __r>& __x) + { + typedef std::basic_istream<_CharT, _Traits> __istream_type; + typedef typename __istream_type::ios_base __ios_base; + + const typename __ios_base::fmtflags __flags = __is.flags(); + __is.flags(__ios_base::dec | __ios_base::skipws); + + __is >> __x._M_b >> __x._M_n; + + __is.flags(__flags); + return __is; + } + + + template + typename independent_bits_engine<_RandomNumberEngine, __w, _UIntType>:: + result_type + independent_bits_engine<_RandomNumberEngine, __w, _UIntType>:: + operator()() + { + typedef typename _RandomNumberEngine::result_type _Eresult_type; + const _Eresult_type __r + = (_M_b.max() - _M_b.min() < std::numeric_limits<_Eresult_type>::max() + ? _M_b.max() - _M_b.min() + 1 : 0); + const unsigned __edig = std::numeric_limits<_Eresult_type>::digits; + const unsigned __m = __r ? std::__lg(__r) : __edig; + + typedef typename std::common_type<_Eresult_type, result_type>::type + __ctype; + const unsigned __cdig = std::numeric_limits<__ctype>::digits; + + unsigned __n, __n0; + __ctype __s0, __s1, __y0, __y1; + + for (size_t __i = 0; __i < 2; ++__i) + { + __n = (__w + __m - 1) / __m + __i; + __n0 = __n - __w % __n; + const unsigned __w0 = __w / __n; // __w0 <= __m + + __s0 = 0; + __s1 = 0; + if (__w0 < __cdig) + { + __s0 = __ctype(1) << __w0; + __s1 = __s0 << 1; + } + + __y0 = 0; + __y1 = 0; + if (__r) + { + __y0 = __s0 * (__r / __s0); + if (__s1) + __y1 = __s1 * (__r / __s1); + + if (__r - __y0 <= __y0 / __n) + break; + } + else + break; + } + + result_type __sum = 0; + for (size_t __k = 0; __k < __n0; ++__k) + { + __ctype __u; + do + __u = _M_b() - _M_b.min(); + while (__y0 && __u >= __y0); + __sum = __s0 * __sum + (__s0 ? __u % __s0 : __u); + } + for (size_t __k = __n0; __k < __n; ++__k) + { + __ctype __u; + do + __u = _M_b() - _M_b.min(); + while (__y1 && __u >= __y1); + __sum = __s1 * __sum + (__s1 ? __u % __s1 : __u); + } + return __sum; + } + + + template + constexpr size_t + shuffle_order_engine<_RandomNumberEngine, __k>::table_size; + + template + typename shuffle_order_engine<_RandomNumberEngine, __k>::result_type + shuffle_order_engine<_RandomNumberEngine, __k>:: + operator()() + { + size_t __j = __k * ((_M_y - _M_b.min()) + / (_M_b.max() - _M_b.min() + 1.0L)); + _M_y = _M_v[__j]; + _M_v[__j] = _M_b(); + + return _M_y; + } + + template + std::basic_ostream<_CharT, _Traits>& + operator<<(std::basic_ostream<_CharT, _Traits>& __os, + const shuffle_order_engine<_RandomNumberEngine, __k>& __x) + { + typedef std::basic_ostream<_CharT, _Traits> __ostream_type; + typedef typename __ostream_type::ios_base __ios_base; + + const typename __ios_base::fmtflags __flags = __os.flags(); + const _CharT __fill = __os.fill(); + const _CharT __space = __os.widen(' '); + __os.flags(__ios_base::dec | __ios_base::fixed | __ios_base::left); + __os.fill(__space); + + __os << __x.base(); + for (size_t __i = 0; __i < __k; ++__i) + __os << __space << __x._M_v[__i]; + __os << __space << __x._M_y; + + __os.flags(__flags); + __os.fill(__fill); + return __os; + } + + template + std::basic_istream<_CharT, _Traits>& + operator>>(std::basic_istream<_CharT, _Traits>& __is, + shuffle_order_engine<_RandomNumberEngine, __k>& __x) + { + typedef std::basic_istream<_CharT, _Traits> __istream_type; + typedef typename __istream_type::ios_base __ios_base; + + const typename __ios_base::fmtflags __flags = __is.flags(); + __is.flags(__ios_base::dec | __ios_base::skipws); + + __is >> __x._M_b; + for (size_t __i = 0; __i < __k; ++__i) + __is >> __x._M_v[__i]; + __is >> __x._M_y; + + __is.flags(__flags); + return __is; + } + + + template + template + typename uniform_int_distribution<_IntType>::result_type + uniform_int_distribution<_IntType>:: + operator()(_UniformRandomNumberGenerator& __urng, + const param_type& __param) + { + typedef typename _UniformRandomNumberGenerator::result_type + _Gresult_type; + typedef typename std::make_unsigned::type __utype; + typedef typename std::common_type<_Gresult_type, __utype>::type + __uctype; + + const __uctype __urngmin = __urng.min(); + const __uctype __urngmax = __urng.max(); + const __uctype __urngrange = __urngmax - __urngmin; + const __uctype __urange + = __uctype(__param.b()) - __uctype(__param.a()); + + __uctype __ret; + + if (__urngrange > __urange) + { + // downscaling + const __uctype __uerange = __urange + 1; // __urange can be zero + const __uctype __scaling = __urngrange / __uerange; + const __uctype __past = __uerange * __scaling; + do + __ret = __uctype(__urng()) - __urngmin; + while (__ret >= __past); + __ret /= __scaling; + } + else if (__urngrange < __urange) + { + // upscaling + /* + Note that every value in [0, urange] + can be written uniquely as + + (urngrange + 1) * high + low + + where + + high in [0, urange / (urngrange + 1)] + + and + + low in [0, urngrange]. + */ + __uctype __tmp; // wraparound control + do + { + const __uctype __uerngrange = __urngrange + 1; + __tmp = (__uerngrange * operator() + (__urng, param_type(0, __urange / __uerngrange))); + __ret = __tmp + (__uctype(__urng()) - __urngmin); + } + while (__ret > __urange || __ret < __tmp); + } + else + __ret = __uctype(__urng()) - __urngmin; + + return __ret + __param.a(); + } + + + template + template + void + uniform_int_distribution<_IntType>:: + __generate_impl(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __param) + { + __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>) + typedef typename _UniformRandomNumberGenerator::result_type + _Gresult_type; + typedef typename std::make_unsigned::type __utype; + typedef typename std::common_type<_Gresult_type, __utype>::type + __uctype; + + const __uctype __urngmin = __urng.min(); + const __uctype __urngmax = __urng.max(); + const __uctype __urngrange = __urngmax - __urngmin; + const __uctype __urange + = __uctype(__param.b()) - __uctype(__param.a()); + + __uctype __ret; + + if (__urngrange > __urange) + { + if (__detail::_Power_of_2(__urngrange + 1) + && __detail::_Power_of_2(__urange + 1)) + { + while (__f != __t) + { + __ret = __uctype(__urng()) - __urngmin; + *__f++ = (__ret & __urange) + __param.a(); + } + } + else + { + // downscaling + const __uctype __uerange = __urange + 1; // __urange can be zero + const __uctype __scaling = __urngrange / __uerange; + const __uctype __past = __uerange * __scaling; + while (__f != __t) + { + do + __ret = __uctype(__urng()) - __urngmin; + while (__ret >= __past); + *__f++ = __ret / __scaling + __param.a(); + } + } + } + else if (__urngrange < __urange) + { + // upscaling + /* + Note that every value in [0, urange] + can be written uniquely as + + (urngrange + 1) * high + low + + where + + high in [0, urange / (urngrange + 1)] + + and + + low in [0, urngrange]. + */ + __uctype __tmp; // wraparound control + while (__f != __t) + { + do + { + const __uctype __uerngrange = __urngrange + 1; + __tmp = (__uerngrange * operator() + (__urng, param_type(0, __urange / __uerngrange))); + __ret = __tmp + (__uctype(__urng()) - __urngmin); + } + while (__ret > __urange || __ret < __tmp); + *__f++ = __ret; + } + } + else + while (__f != __t) + *__f++ = __uctype(__urng()) - __urngmin + __param.a(); + } + + template + std::basic_ostream<_CharT, _Traits>& + operator<<(std::basic_ostream<_CharT, _Traits>& __os, + const uniform_int_distribution<_IntType>& __x) + { + typedef std::basic_ostream<_CharT, _Traits> __ostream_type; + typedef typename __ostream_type::ios_base __ios_base; + + const typename __ios_base::fmtflags __flags = __os.flags(); + const _CharT __fill = __os.fill(); + const _CharT __space = __os.widen(' '); + __os.flags(__ios_base::scientific | __ios_base::left); + __os.fill(__space); + + __os << __x.a() << __space << __x.b(); + + __os.flags(__flags); + __os.fill(__fill); + return __os; + } + + template + std::basic_istream<_CharT, _Traits>& + operator>>(std::basic_istream<_CharT, _Traits>& __is, + uniform_int_distribution<_IntType>& __x) + { + typedef std::basic_istream<_CharT, _Traits> __istream_type; + typedef typename __istream_type::ios_base __ios_base; + + const typename __ios_base::fmtflags __flags = __is.flags(); + __is.flags(__ios_base::dec | __ios_base::skipws); + + _IntType __a, __b; + __is >> __a >> __b; + __x.param(typename uniform_int_distribution<_IntType>:: + param_type(__a, __b)); + + __is.flags(__flags); + return __is; + } + + + template + template + void + uniform_real_distribution<_RealType>:: + __generate_impl(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __p) + { + __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>) + __detail::_Adaptor<_UniformRandomNumberGenerator, result_type> + __aurng(__urng); + auto __range = __p.b() - __p.a(); + while (__f != __t) + *__f++ = __aurng() * __range + __p.a(); + } + + template + std::basic_ostream<_CharT, _Traits>& + operator<<(std::basic_ostream<_CharT, _Traits>& __os, + const uniform_real_distribution<_RealType>& __x) + { + typedef std::basic_ostream<_CharT, _Traits> __ostream_type; + typedef typename __ostream_type::ios_base __ios_base; + + const typename __ios_base::fmtflags __flags = __os.flags(); + const _CharT __fill = __os.fill(); + const std::streamsize __precision = __os.precision(); + const _CharT __space = __os.widen(' '); + __os.flags(__ios_base::scientific | __ios_base::left); + __os.fill(__space); + __os.precision(std::numeric_limits<_RealType>::max_digits10); + + __os << __x.a() << __space << __x.b(); + + __os.flags(__flags); + __os.fill(__fill); + __os.precision(__precision); + return __os; + } + + template + std::basic_istream<_CharT, _Traits>& + operator>>(std::basic_istream<_CharT, _Traits>& __is, + uniform_real_distribution<_RealType>& __x) + { + typedef std::basic_istream<_CharT, _Traits> __istream_type; + typedef typename __istream_type::ios_base __ios_base; + + const typename __ios_base::fmtflags __flags = __is.flags(); + __is.flags(__ios_base::skipws); + + _RealType __a, __b; + __is >> __a >> __b; + __x.param(typename uniform_real_distribution<_RealType>:: + param_type(__a, __b)); + + __is.flags(__flags); + return __is; + } + + + template + void + std::bernoulli_distribution:: + __generate_impl(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __p) + { + __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>) + __detail::_Adaptor<_UniformRandomNumberGenerator, double> + __aurng(__urng); + auto __limit = __p.p() * (__aurng.max() - __aurng.min()); + + while (__f != __t) + *__f++ = (__aurng() - __aurng.min()) < __limit; + } + + template + std::basic_ostream<_CharT, _Traits>& + operator<<(std::basic_ostream<_CharT, _Traits>& __os, + const bernoulli_distribution& __x) + { + typedef std::basic_ostream<_CharT, _Traits> __ostream_type; + typedef typename __ostream_type::ios_base __ios_base; + + const typename __ios_base::fmtflags __flags = __os.flags(); + const _CharT __fill = __os.fill(); + const std::streamsize __precision = __os.precision(); + __os.flags(__ios_base::scientific | __ios_base::left); + __os.fill(__os.widen(' ')); + __os.precision(std::numeric_limits::max_digits10); + + __os << __x.p(); + + __os.flags(__flags); + __os.fill(__fill); + __os.precision(__precision); + return __os; + } + + + template + template + typename geometric_distribution<_IntType>::result_type + geometric_distribution<_IntType>:: + operator()(_UniformRandomNumberGenerator& __urng, + const param_type& __param) + { + // About the epsilon thing see this thread: + // http://gcc.gnu.org/ml/gcc-patches/2006-10/msg00971.html + const double __naf = + (1 - std::numeric_limits::epsilon()) / 2; + // The largest _RealType convertible to _IntType. + const double __thr = + std::numeric_limits<_IntType>::max() + __naf; + __detail::_Adaptor<_UniformRandomNumberGenerator, double> + __aurng(__urng); + + double __cand; + do + __cand = std::floor(std::log(1.0 - __aurng()) / __param._M_log_1_p); + while (__cand >= __thr); + + return result_type(__cand + __naf); + } + + template + template + void + geometric_distribution<_IntType>:: + __generate_impl(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __param) + { + __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>) + // About the epsilon thing see this thread: + // http://gcc.gnu.org/ml/gcc-patches/2006-10/msg00971.html + const double __naf = + (1 - std::numeric_limits::epsilon()) / 2; + // The largest _RealType convertible to _IntType. + const double __thr = + std::numeric_limits<_IntType>::max() + __naf; + __detail::_Adaptor<_UniformRandomNumberGenerator, double> + __aurng(__urng); + + while (__f != __t) + { + double __cand; + do + __cand = std::floor(std::log(1.0 - __aurng()) + / __param._M_log_1_p); + while (__cand >= __thr); + + *__f++ = __cand + __naf; + } + } + + template + std::basic_ostream<_CharT, _Traits>& + operator<<(std::basic_ostream<_CharT, _Traits>& __os, + const geometric_distribution<_IntType>& __x) + { + typedef std::basic_ostream<_CharT, _Traits> __ostream_type; + typedef typename __ostream_type::ios_base __ios_base; + + const typename __ios_base::fmtflags __flags = __os.flags(); + const _CharT __fill = __os.fill(); + const std::streamsize __precision = __os.precision(); + __os.flags(__ios_base::scientific | __ios_base::left); + __os.fill(__os.widen(' ')); + __os.precision(std::numeric_limits::max_digits10); + + __os << __x.p(); + + __os.flags(__flags); + __os.fill(__fill); + __os.precision(__precision); + return __os; + } + + template + std::basic_istream<_CharT, _Traits>& + operator>>(std::basic_istream<_CharT, _Traits>& __is, + geometric_distribution<_IntType>& __x) + { + typedef std::basic_istream<_CharT, _Traits> __istream_type; + typedef typename __istream_type::ios_base __ios_base; + + const typename __ios_base::fmtflags __flags = __is.flags(); + __is.flags(__ios_base::skipws); + + double __p; + __is >> __p; + __x.param(typename geometric_distribution<_IntType>::param_type(__p)); + + __is.flags(__flags); + return __is; + } + + // This is Leger's algorithm, also in Devroye, Ch. X, Example 1.5. + template + template + typename negative_binomial_distribution<_IntType>::result_type + negative_binomial_distribution<_IntType>:: + operator()(_UniformRandomNumberGenerator& __urng) + { + const double __y = _M_gd(__urng); + + // XXX Is the constructor too slow? + std::poisson_distribution __poisson(__y); + return __poisson(__urng); + } + + template + template + typename negative_binomial_distribution<_IntType>::result_type + negative_binomial_distribution<_IntType>:: + operator()(_UniformRandomNumberGenerator& __urng, + const param_type& __p) + { + typedef typename std::gamma_distribution::param_type + param_type; + + const double __y = + _M_gd(__urng, param_type(__p.k(), (1.0 - __p.p()) / __p.p())); + + std::poisson_distribution __poisson(__y); + return __poisson(__urng); + } + + template + template + void + negative_binomial_distribution<_IntType>:: + __generate_impl(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng) + { + __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>) + while (__f != __t) + { + const double __y = _M_gd(__urng); + + // XXX Is the constructor too slow? + std::poisson_distribution __poisson(__y); + *__f++ = __poisson(__urng); + } + } + + template + template + void + negative_binomial_distribution<_IntType>:: + __generate_impl(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __p) + { + __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>) + typename std::gamma_distribution::param_type + __p2(__p.k(), (1.0 - __p.p()) / __p.p()); + + while (__f != __t) + { + const double __y = _M_gd(__urng, __p2); + + std::poisson_distribution __poisson(__y); + *__f++ = __poisson(__urng); + } + } + + template + std::basic_ostream<_CharT, _Traits>& + operator<<(std::basic_ostream<_CharT, _Traits>& __os, + const negative_binomial_distribution<_IntType>& __x) + { + typedef std::basic_ostream<_CharT, _Traits> __ostream_type; + typedef typename __ostream_type::ios_base __ios_base; + + const typename __ios_base::fmtflags __flags = __os.flags(); + const _CharT __fill = __os.fill(); + const std::streamsize __precision = __os.precision(); + const _CharT __space = __os.widen(' '); + __os.flags(__ios_base::scientific | __ios_base::left); + __os.fill(__os.widen(' ')); + __os.precision(std::numeric_limits::max_digits10); + + __os << __x.k() << __space << __x.p() + << __space << __x._M_gd; + + __os.flags(__flags); + __os.fill(__fill); + __os.precision(__precision); + return __os; + } + + template + std::basic_istream<_CharT, _Traits>& + operator>>(std::basic_istream<_CharT, _Traits>& __is, + negative_binomial_distribution<_IntType>& __x) + { + typedef std::basic_istream<_CharT, _Traits> __istream_type; + typedef typename __istream_type::ios_base __ios_base; + + const typename __ios_base::fmtflags __flags = __is.flags(); + __is.flags(__ios_base::skipws); + + _IntType __k; + double __p; + __is >> __k >> __p >> __x._M_gd; + __x.param(typename negative_binomial_distribution<_IntType>:: + param_type(__k, __p)); + + __is.flags(__flags); + return __is; + } + + + template + void + poisson_distribution<_IntType>::param_type:: + _M_initialize() + { +#if _GLIBCXX_USE_C99_MATH_TR1 + if (_M_mean >= 12) + { + const double __m = std::floor(_M_mean); + _M_lm_thr = std::log(_M_mean); + _M_lfm = std::lgamma(__m + 1); + _M_sm = std::sqrt(__m); + + const double __pi_4 = 0.7853981633974483096156608458198757L; + const double __dx = std::sqrt(2 * __m * std::log(32 * __m + / __pi_4)); + _M_d = std::round(std::max(6.0, std::min(__m, __dx))); + const double __cx = 2 * __m + _M_d; + _M_scx = std::sqrt(__cx / 2); + _M_1cx = 1 / __cx; + + _M_c2b = std::sqrt(__pi_4 * __cx) * std::exp(_M_1cx); + _M_cb = 2 * __cx * std::exp(-_M_d * _M_1cx * (1 + _M_d / 2)) + / _M_d; + } + else +#endif + _M_lm_thr = std::exp(-_M_mean); + } + + /** + * A rejection algorithm when mean >= 12 and a simple method based + * upon the multiplication of uniform random variates otherwise. + * NB: The former is available only if _GLIBCXX_USE_C99_MATH_TR1 + * is defined. + * + * Reference: + * Devroye, L. Non-Uniform Random Variates Generation. Springer-Verlag, + * New York, 1986, Ch. X, Sects. 3.3 & 3.4 (+ Errata!). + */ + template + template + typename poisson_distribution<_IntType>::result_type + poisson_distribution<_IntType>:: + operator()(_UniformRandomNumberGenerator& __urng, + const param_type& __param) + { + __detail::_Adaptor<_UniformRandomNumberGenerator, double> + __aurng(__urng); +#if _GLIBCXX_USE_C99_MATH_TR1 + if (__param.mean() >= 12) + { + double __x; + + // See comments above... + const double __naf = + (1 - std::numeric_limits::epsilon()) / 2; + const double __thr = + std::numeric_limits<_IntType>::max() + __naf; + + const double __m = std::floor(__param.mean()); + // sqrt(pi / 2) + const double __spi_2 = 1.2533141373155002512078826424055226L; + const double __c1 = __param._M_sm * __spi_2; + const double __c2 = __param._M_c2b + __c1; + const double __c3 = __c2 + 1; + const double __c4 = __c3 + 1; + // e^(1 / 78) + const double __e178 = 1.0129030479320018583185514777512983L; + const double __c5 = __c4 + __e178; + const double __c = __param._M_cb + __c5; + const double __2cx = 2 * (2 * __m + __param._M_d); + + bool __reject = true; + do + { + const double __u = __c * __aurng(); + const double __e = -std::log(1.0 - __aurng()); + + double __w = 0.0; + + if (__u <= __c1) + { + const double __n = _M_nd(__urng); + const double __y = -std::abs(__n) * __param._M_sm - 1; + __x = std::floor(__y); + __w = -__n * __n / 2; + if (__x < -__m) + continue; + } + else if (__u <= __c2) + { + const double __n = _M_nd(__urng); + const double __y = 1 + std::abs(__n) * __param._M_scx; + __x = std::ceil(__y); + __w = __y * (2 - __y) * __param._M_1cx; + if (__x > __param._M_d) + continue; + } + else if (__u <= __c3) + // NB: This case not in the book, nor in the Errata, + // but should be ok... + __x = -1; + else if (__u <= __c4) + __x = 0; + else if (__u <= __c5) + __x = 1; + else + { + const double __v = -std::log(1.0 - __aurng()); + const double __y = __param._M_d + + __v * __2cx / __param._M_d; + __x = std::ceil(__y); + __w = -__param._M_d * __param._M_1cx * (1 + __y / 2); + } + + __reject = (__w - __e - __x * __param._M_lm_thr + > __param._M_lfm - std::lgamma(__x + __m + 1)); + + __reject |= __x + __m >= __thr; + + } while (__reject); + + return result_type(__x + __m + __naf); + } + else +#endif + { + _IntType __x = 0; + double __prod = 1.0; + + do + { + __prod *= __aurng(); + __x += 1; + } + while (__prod > __param._M_lm_thr); + + return __x - 1; + } + } + + template + template + void + poisson_distribution<_IntType>:: + __generate_impl(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __param) + { + __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>) + // We could duplicate everything from operator()... + while (__f != __t) + *__f++ = this->operator()(__urng, __param); + } + + template + std::basic_ostream<_CharT, _Traits>& + operator<<(std::basic_ostream<_CharT, _Traits>& __os, + const poisson_distribution<_IntType>& __x) + { + typedef std::basic_ostream<_CharT, _Traits> __ostream_type; + typedef typename __ostream_type::ios_base __ios_base; + + const typename __ios_base::fmtflags __flags = __os.flags(); + const _CharT __fill = __os.fill(); + const std::streamsize __precision = __os.precision(); + const _CharT __space = __os.widen(' '); + __os.flags(__ios_base::scientific | __ios_base::left); + __os.fill(__space); + __os.precision(std::numeric_limits::max_digits10); + + __os << __x.mean() << __space << __x._M_nd; + + __os.flags(__flags); + __os.fill(__fill); + __os.precision(__precision); + return __os; + } + + template + std::basic_istream<_CharT, _Traits>& + operator>>(std::basic_istream<_CharT, _Traits>& __is, + poisson_distribution<_IntType>& __x) + { + typedef std::basic_istream<_CharT, _Traits> __istream_type; + typedef typename __istream_type::ios_base __ios_base; + + const typename __ios_base::fmtflags __flags = __is.flags(); + __is.flags(__ios_base::skipws); + + double __mean; + __is >> __mean >> __x._M_nd; + __x.param(typename poisson_distribution<_IntType>::param_type(__mean)); + + __is.flags(__flags); + return __is; + } + + + template + void + binomial_distribution<_IntType>::param_type:: + _M_initialize() + { + const double __p12 = _M_p <= 0.5 ? _M_p : 1.0 - _M_p; + + _M_easy = true; + +#if _GLIBCXX_USE_C99_MATH_TR1 + if (_M_t * __p12 >= 8) + { + _M_easy = false; + const double __np = std::floor(_M_t * __p12); + const double __pa = __np / _M_t; + const double __1p = 1 - __pa; + + const double __pi_4 = 0.7853981633974483096156608458198757L; + const double __d1x = + std::sqrt(__np * __1p * std::log(32 * __np + / (81 * __pi_4 * __1p))); + _M_d1 = std::round(std::max(1.0, __d1x)); + const double __d2x = + std::sqrt(__np * __1p * std::log(32 * _M_t * __1p + / (__pi_4 * __pa))); + _M_d2 = std::round(std::max(1.0, __d2x)); + + // sqrt(pi / 2) + const double __spi_2 = 1.2533141373155002512078826424055226L; + _M_s1 = std::sqrt(__np * __1p) * (1 + _M_d1 / (4 * __np)); + _M_s2 = std::sqrt(__np * __1p) * (1 + _M_d2 / (4 * _M_t * __1p)); + _M_c = 2 * _M_d1 / __np; + _M_a1 = std::exp(_M_c) * _M_s1 * __spi_2; + const double __a12 = _M_a1 + _M_s2 * __spi_2; + const double __s1s = _M_s1 * _M_s1; + _M_a123 = __a12 + (std::exp(_M_d1 / (_M_t * __1p)) + * 2 * __s1s / _M_d1 + * std::exp(-_M_d1 * _M_d1 / (2 * __s1s))); + const double __s2s = _M_s2 * _M_s2; + _M_s = (_M_a123 + 2 * __s2s / _M_d2 + * std::exp(-_M_d2 * _M_d2 / (2 * __s2s))); + _M_lf = (std::lgamma(__np + 1) + + std::lgamma(_M_t - __np + 1)); + _M_lp1p = std::log(__pa / __1p); + + _M_q = -std::log(1 - (__p12 - __pa) / __1p); + } + else +#endif + _M_q = -std::log(1 - __p12); + } + + template + template + typename binomial_distribution<_IntType>::result_type + binomial_distribution<_IntType>:: + _M_waiting(_UniformRandomNumberGenerator& __urng, + _IntType __t, double __q) + { + _IntType __x = 0; + double __sum = 0.0; + __detail::_Adaptor<_UniformRandomNumberGenerator, double> + __aurng(__urng); + + do + { + if (__t == __x) + return __x; + const double __e = -std::log(1.0 - __aurng()); + __sum += __e / (__t - __x); + __x += 1; + } + while (__sum <= __q); + + return __x - 1; + } + + /** + * A rejection algorithm when t * p >= 8 and a simple waiting time + * method - the second in the referenced book - otherwise. + * NB: The former is available only if _GLIBCXX_USE_C99_MATH_TR1 + * is defined. + * + * Reference: + * Devroye, L. Non-Uniform Random Variates Generation. Springer-Verlag, + * New York, 1986, Ch. X, Sect. 4 (+ Errata!). + */ + template + template + typename binomial_distribution<_IntType>::result_type + binomial_distribution<_IntType>:: + operator()(_UniformRandomNumberGenerator& __urng, + const param_type& __param) + { + result_type __ret; + const _IntType __t = __param.t(); + const double __p = __param.p(); + const double __p12 = __p <= 0.5 ? __p : 1.0 - __p; + __detail::_Adaptor<_UniformRandomNumberGenerator, double> + __aurng(__urng); + +#if _GLIBCXX_USE_C99_MATH_TR1 + if (!__param._M_easy) + { + double __x; + + // See comments above... + const double __naf = + (1 - std::numeric_limits::epsilon()) / 2; + const double __thr = + std::numeric_limits<_IntType>::max() + __naf; + + const double __np = std::floor(__t * __p12); + + // sqrt(pi / 2) + const double __spi_2 = 1.2533141373155002512078826424055226L; + const double __a1 = __param._M_a1; + const double __a12 = __a1 + __param._M_s2 * __spi_2; + const double __a123 = __param._M_a123; + const double __s1s = __param._M_s1 * __param._M_s1; + const double __s2s = __param._M_s2 * __param._M_s2; + + bool __reject; + do + { + const double __u = __param._M_s * __aurng(); + + double __v; + + if (__u <= __a1) + { + const double __n = _M_nd(__urng); + const double __y = __param._M_s1 * std::abs(__n); + __reject = __y >= __param._M_d1; + if (!__reject) + { + const double __e = -std::log(1.0 - __aurng()); + __x = std::floor(__y); + __v = -__e - __n * __n / 2 + __param._M_c; + } + } + else if (__u <= __a12) + { + const double __n = _M_nd(__urng); + const double __y = __param._M_s2 * std::abs(__n); + __reject = __y >= __param._M_d2; + if (!__reject) + { + const double __e = -std::log(1.0 - __aurng()); + __x = std::floor(-__y); + __v = -__e - __n * __n / 2; + } + } + else if (__u <= __a123) + { + const double __e1 = -std::log(1.0 - __aurng()); + const double __e2 = -std::log(1.0 - __aurng()); + + const double __y = __param._M_d1 + + 2 * __s1s * __e1 / __param._M_d1; + __x = std::floor(__y); + __v = (-__e2 + __param._M_d1 * (1 / (__t - __np) + -__y / (2 * __s1s))); + __reject = false; + } + else + { + const double __e1 = -std::log(1.0 - __aurng()); + const double __e2 = -std::log(1.0 - __aurng()); + + const double __y = __param._M_d2 + + 2 * __s2s * __e1 / __param._M_d2; + __x = std::floor(-__y); + __v = -__e2 - __param._M_d2 * __y / (2 * __s2s); + __reject = false; + } + + __reject = __reject || __x < -__np || __x > __t - __np; + if (!__reject) + { + const double __lfx = + std::lgamma(__np + __x + 1) + + std::lgamma(__t - (__np + __x) + 1); + __reject = __v > __param._M_lf - __lfx + + __x * __param._M_lp1p; + } + + __reject |= __x + __np >= __thr; + } + while (__reject); + + __x += __np + __naf; + + const _IntType __z = _M_waiting(__urng, __t - _IntType(__x), + __param._M_q); + __ret = _IntType(__x) + __z; + } + else +#endif + __ret = _M_waiting(__urng, __t, __param._M_q); + + if (__p12 != __p) + __ret = __t - __ret; + return __ret; + } + + template + template + void + binomial_distribution<_IntType>:: + __generate_impl(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __param) + { + __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>) + // We could duplicate everything from operator()... + while (__f != __t) + *__f++ = this->operator()(__urng, __param); + } + + template + std::basic_ostream<_CharT, _Traits>& + operator<<(std::basic_ostream<_CharT, _Traits>& __os, + const binomial_distribution<_IntType>& __x) + { + typedef std::basic_ostream<_CharT, _Traits> __ostream_type; + typedef typename __ostream_type::ios_base __ios_base; + + const typename __ios_base::fmtflags __flags = __os.flags(); + const _CharT __fill = __os.fill(); + const std::streamsize __precision = __os.precision(); + const _CharT __space = __os.widen(' '); + __os.flags(__ios_base::scientific | __ios_base::left); + __os.fill(__space); + __os.precision(std::numeric_limits::max_digits10); + + __os << __x.t() << __space << __x.p() + << __space << __x._M_nd; + + __os.flags(__flags); + __os.fill(__fill); + __os.precision(__precision); + return __os; + } + + template + std::basic_istream<_CharT, _Traits>& + operator>>(std::basic_istream<_CharT, _Traits>& __is, + binomial_distribution<_IntType>& __x) + { + typedef std::basic_istream<_CharT, _Traits> __istream_type; + typedef typename __istream_type::ios_base __ios_base; + + const typename __ios_base::fmtflags __flags = __is.flags(); + __is.flags(__ios_base::dec | __ios_base::skipws); + + _IntType __t; + double __p; + __is >> __t >> __p >> __x._M_nd; + __x.param(typename binomial_distribution<_IntType>:: + param_type(__t, __p)); + + __is.flags(__flags); + return __is; + } + + + template + template + void + std::exponential_distribution<_RealType>:: + __generate_impl(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __p) + { + __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>) + __detail::_Adaptor<_UniformRandomNumberGenerator, result_type> + __aurng(__urng); + while (__f != __t) + *__f++ = -std::log(result_type(1) - __aurng()) / __p.lambda(); + } + + template + std::basic_ostream<_CharT, _Traits>& + operator<<(std::basic_ostream<_CharT, _Traits>& __os, + const exponential_distribution<_RealType>& __x) + { + typedef std::basic_ostream<_CharT, _Traits> __ostream_type; + typedef typename __ostream_type::ios_base __ios_base; + + const typename __ios_base::fmtflags __flags = __os.flags(); + const _CharT __fill = __os.fill(); + const std::streamsize __precision = __os.precision(); + __os.flags(__ios_base::scientific | __ios_base::left); + __os.fill(__os.widen(' ')); + __os.precision(std::numeric_limits<_RealType>::max_digits10); + + __os << __x.lambda(); + + __os.flags(__flags); + __os.fill(__fill); + __os.precision(__precision); + return __os; + } + + template + std::basic_istream<_CharT, _Traits>& + operator>>(std::basic_istream<_CharT, _Traits>& __is, + exponential_distribution<_RealType>& __x) + { + typedef std::basic_istream<_CharT, _Traits> __istream_type; + typedef typename __istream_type::ios_base __ios_base; + + const typename __ios_base::fmtflags __flags = __is.flags(); + __is.flags(__ios_base::dec | __ios_base::skipws); + + _RealType __lambda; + __is >> __lambda; + __x.param(typename exponential_distribution<_RealType>:: + param_type(__lambda)); + + __is.flags(__flags); + return __is; + } + + + /** + * Polar method due to Marsaglia. + * + * Devroye, L. Non-Uniform Random Variates Generation. Springer-Verlag, + * New York, 1986, Ch. V, Sect. 4.4. + */ + template + template + typename normal_distribution<_RealType>::result_type + normal_distribution<_RealType>:: + operator()(_UniformRandomNumberGenerator& __urng, + const param_type& __param) + { + result_type __ret; + __detail::_Adaptor<_UniformRandomNumberGenerator, result_type> + __aurng(__urng); + + if (_M_saved_available) + { + _M_saved_available = false; + __ret = _M_saved; + } + else + { + result_type __x, __y, __r2; + do + { + __x = result_type(2.0) * __aurng() - 1.0; + __y = result_type(2.0) * __aurng() - 1.0; + __r2 = __x * __x + __y * __y; + } + while (__r2 > 1.0 || __r2 == 0.0); + + const result_type __mult = std::sqrt(-2 * std::log(__r2) / __r2); + _M_saved = __x * __mult; + _M_saved_available = true; + __ret = __y * __mult; + } + + __ret = __ret * __param.stddev() + __param.mean(); + return __ret; + } + + template + template + void + normal_distribution<_RealType>:: + __generate_impl(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __param) + { + __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>) + + if (__f == __t) + return; + + if (_M_saved_available) + { + _M_saved_available = false; + *__f++ = _M_saved * __param.stddev() + __param.mean(); + + if (__f == __t) + return; + } + + __detail::_Adaptor<_UniformRandomNumberGenerator, result_type> + __aurng(__urng); + + while (__f + 1 < __t) + { + result_type __x, __y, __r2; + do + { + __x = result_type(2.0) * __aurng() - 1.0; + __y = result_type(2.0) * __aurng() - 1.0; + __r2 = __x * __x + __y * __y; + } + while (__r2 > 1.0 || __r2 == 0.0); + + const result_type __mult = std::sqrt(-2 * std::log(__r2) / __r2); + *__f++ = __y * __mult * __param.stddev() + __param.mean(); + *__f++ = __x * __mult * __param.stddev() + __param.mean(); + } + + if (__f != __t) + { + result_type __x, __y, __r2; + do + { + __x = result_type(2.0) * __aurng() - 1.0; + __y = result_type(2.0) * __aurng() - 1.0; + __r2 = __x * __x + __y * __y; + } + while (__r2 > 1.0 || __r2 == 0.0); + + const result_type __mult = std::sqrt(-2 * std::log(__r2) / __r2); + _M_saved = __x * __mult; + _M_saved_available = true; + *__f = __y * __mult * __param.stddev() + __param.mean(); + } + } + + template + bool + operator==(const std::normal_distribution<_RealType>& __d1, + const std::normal_distribution<_RealType>& __d2) + { + if (__d1._M_param == __d2._M_param + && __d1._M_saved_available == __d2._M_saved_available) + { + if (__d1._M_saved_available + && __d1._M_saved == __d2._M_saved) + return true; + else if(!__d1._M_saved_available) + return true; + else + return false; + } + else + return false; + } + + template + std::basic_ostream<_CharT, _Traits>& + operator<<(std::basic_ostream<_CharT, _Traits>& __os, + const normal_distribution<_RealType>& __x) + { + typedef std::basic_ostream<_CharT, _Traits> __ostream_type; + typedef typename __ostream_type::ios_base __ios_base; + + const typename __ios_base::fmtflags __flags = __os.flags(); + const _CharT __fill = __os.fill(); + const std::streamsize __precision = __os.precision(); + const _CharT __space = __os.widen(' '); + __os.flags(__ios_base::scientific | __ios_base::left); + __os.fill(__space); + __os.precision(std::numeric_limits<_RealType>::max_digits10); + + __os << __x.mean() << __space << __x.stddev() + << __space << __x._M_saved_available; + if (__x._M_saved_available) + __os << __space << __x._M_saved; + + __os.flags(__flags); + __os.fill(__fill); + __os.precision(__precision); + return __os; + } + + template + std::basic_istream<_CharT, _Traits>& + operator>>(std::basic_istream<_CharT, _Traits>& __is, + normal_distribution<_RealType>& __x) + { + typedef std::basic_istream<_CharT, _Traits> __istream_type; + typedef typename __istream_type::ios_base __ios_base; + + const typename __ios_base::fmtflags __flags = __is.flags(); + __is.flags(__ios_base::dec | __ios_base::skipws); + + double __mean, __stddev; + __is >> __mean >> __stddev + >> __x._M_saved_available; + if (__x._M_saved_available) + __is >> __x._M_saved; + __x.param(typename normal_distribution<_RealType>:: + param_type(__mean, __stddev)); + + __is.flags(__flags); + return __is; + } + + + template + template + void + lognormal_distribution<_RealType>:: + __generate_impl(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __p) + { + __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>) + while (__f != __t) + *__f++ = std::exp(__p.s() * _M_nd(__urng) + __p.m()); + } + + template + std::basic_ostream<_CharT, _Traits>& + operator<<(std::basic_ostream<_CharT, _Traits>& __os, + const lognormal_distribution<_RealType>& __x) + { + typedef std::basic_ostream<_CharT, _Traits> __ostream_type; + typedef typename __ostream_type::ios_base __ios_base; + + const typename __ios_base::fmtflags __flags = __os.flags(); + const _CharT __fill = __os.fill(); + const std::streamsize __precision = __os.precision(); + const _CharT __space = __os.widen(' '); + __os.flags(__ios_base::scientific | __ios_base::left); + __os.fill(__space); + __os.precision(std::numeric_limits<_RealType>::max_digits10); + + __os << __x.m() << __space << __x.s() + << __space << __x._M_nd; + + __os.flags(__flags); + __os.fill(__fill); + __os.precision(__precision); + return __os; + } + + template + std::basic_istream<_CharT, _Traits>& + operator>>(std::basic_istream<_CharT, _Traits>& __is, + lognormal_distribution<_RealType>& __x) + { + typedef std::basic_istream<_CharT, _Traits> __istream_type; + typedef typename __istream_type::ios_base __ios_base; + + const typename __ios_base::fmtflags __flags = __is.flags(); + __is.flags(__ios_base::dec | __ios_base::skipws); + + _RealType __m, __s; + __is >> __m >> __s >> __x._M_nd; + __x.param(typename lognormal_distribution<_RealType>:: + param_type(__m, __s)); + + __is.flags(__flags); + return __is; + } + + template + template + void + std::chi_squared_distribution<_RealType>:: + __generate_impl(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng) + { + __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>) + while (__f != __t) + *__f++ = 2 * _M_gd(__urng); + } + + template + template + void + std::chi_squared_distribution<_RealType>:: + __generate_impl(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng, + const typename + std::gamma_distribution::param_type& __p) + { + __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>) + while (__f != __t) + *__f++ = 2 * _M_gd(__urng, __p); + } + + template + std::basic_ostream<_CharT, _Traits>& + operator<<(std::basic_ostream<_CharT, _Traits>& __os, + const chi_squared_distribution<_RealType>& __x) + { + typedef std::basic_ostream<_CharT, _Traits> __ostream_type; + typedef typename __ostream_type::ios_base __ios_base; + + const typename __ios_base::fmtflags __flags = __os.flags(); + const _CharT __fill = __os.fill(); + const std::streamsize __precision = __os.precision(); + const _CharT __space = __os.widen(' '); + __os.flags(__ios_base::scientific | __ios_base::left); + __os.fill(__space); + __os.precision(std::numeric_limits<_RealType>::max_digits10); + + __os << __x.n() << __space << __x._M_gd; + + __os.flags(__flags); + __os.fill(__fill); + __os.precision(__precision); + return __os; + } + + template + std::basic_istream<_CharT, _Traits>& + operator>>(std::basic_istream<_CharT, _Traits>& __is, + chi_squared_distribution<_RealType>& __x) + { + typedef std::basic_istream<_CharT, _Traits> __istream_type; + typedef typename __istream_type::ios_base __ios_base; + + const typename __ios_base::fmtflags __flags = __is.flags(); + __is.flags(__ios_base::dec | __ios_base::skipws); + + _RealType __n; + __is >> __n >> __x._M_gd; + __x.param(typename chi_squared_distribution<_RealType>:: + param_type(__n)); + + __is.flags(__flags); + return __is; + } + + + template + template + typename cauchy_distribution<_RealType>::result_type + cauchy_distribution<_RealType>:: + operator()(_UniformRandomNumberGenerator& __urng, + const param_type& __p) + { + __detail::_Adaptor<_UniformRandomNumberGenerator, result_type> + __aurng(__urng); + _RealType __u; + do + __u = __aurng(); + while (__u == 0.5); + + const _RealType __pi = 3.1415926535897932384626433832795029L; + return __p.a() + __p.b() * std::tan(__pi * __u); + } + + template + template + void + cauchy_distribution<_RealType>:: + __generate_impl(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __p) + { + __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>) + const _RealType __pi = 3.1415926535897932384626433832795029L; + __detail::_Adaptor<_UniformRandomNumberGenerator, result_type> + __aurng(__urng); + while (__f != __t) + { + _RealType __u; + do + __u = __aurng(); + while (__u == 0.5); + + *__f++ = __p.a() + __p.b() * std::tan(__pi * __u); + } + } + + template + std::basic_ostream<_CharT, _Traits>& + operator<<(std::basic_ostream<_CharT, _Traits>& __os, + const cauchy_distribution<_RealType>& __x) + { + typedef std::basic_ostream<_CharT, _Traits> __ostream_type; + typedef typename __ostream_type::ios_base __ios_base; + + const typename __ios_base::fmtflags __flags = __os.flags(); + const _CharT __fill = __os.fill(); + const std::streamsize __precision = __os.precision(); + const _CharT __space = __os.widen(' '); + __os.flags(__ios_base::scientific | __ios_base::left); + __os.fill(__space); + __os.precision(std::numeric_limits<_RealType>::max_digits10); + + __os << __x.a() << __space << __x.b(); + + __os.flags(__flags); + __os.fill(__fill); + __os.precision(__precision); + return __os; + } + + template + std::basic_istream<_CharT, _Traits>& + operator>>(std::basic_istream<_CharT, _Traits>& __is, + cauchy_distribution<_RealType>& __x) + { + typedef std::basic_istream<_CharT, _Traits> __istream_type; + typedef typename __istream_type::ios_base __ios_base; + + const typename __ios_base::fmtflags __flags = __is.flags(); + __is.flags(__ios_base::dec | __ios_base::skipws); + + _RealType __a, __b; + __is >> __a >> __b; + __x.param(typename cauchy_distribution<_RealType>:: + param_type(__a, __b)); + + __is.flags(__flags); + return __is; + } + + + template + template + void + std::fisher_f_distribution<_RealType>:: + __generate_impl(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng) + { + __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>) + while (__f != __t) + *__f++ = ((_M_gd_x(__urng) * n()) / (_M_gd_y(__urng) * m())); + } + + template + template + void + std::fisher_f_distribution<_RealType>:: + __generate_impl(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __p) + { + __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>) + typedef typename std::gamma_distribution::param_type + param_type; + param_type __p1(__p.m() / 2); + param_type __p2(__p.n() / 2); + while (__f != __t) + *__f++ = ((_M_gd_x(__urng, __p1) * n()) + / (_M_gd_y(__urng, __p2) * m())); + } + + template + std::basic_ostream<_CharT, _Traits>& + operator<<(std::basic_ostream<_CharT, _Traits>& __os, + const fisher_f_distribution<_RealType>& __x) + { + typedef std::basic_ostream<_CharT, _Traits> __ostream_type; + typedef typename __ostream_type::ios_base __ios_base; + + const typename __ios_base::fmtflags __flags = __os.flags(); + const _CharT __fill = __os.fill(); + const std::streamsize __precision = __os.precision(); + const _CharT __space = __os.widen(' '); + __os.flags(__ios_base::scientific | __ios_base::left); + __os.fill(__space); + __os.precision(std::numeric_limits<_RealType>::max_digits10); + + __os << __x.m() << __space << __x.n() + << __space << __x._M_gd_x << __space << __x._M_gd_y; + + __os.flags(__flags); + __os.fill(__fill); + __os.precision(__precision); + return __os; + } + + template + std::basic_istream<_CharT, _Traits>& + operator>>(std::basic_istream<_CharT, _Traits>& __is, + fisher_f_distribution<_RealType>& __x) + { + typedef std::basic_istream<_CharT, _Traits> __istream_type; + typedef typename __istream_type::ios_base __ios_base; + + const typename __ios_base::fmtflags __flags = __is.flags(); + __is.flags(__ios_base::dec | __ios_base::skipws); + + _RealType __m, __n; + __is >> __m >> __n >> __x._M_gd_x >> __x._M_gd_y; + __x.param(typename fisher_f_distribution<_RealType>:: + param_type(__m, __n)); + + __is.flags(__flags); + return __is; + } + + + template + template + void + std::student_t_distribution<_RealType>:: + __generate_impl(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng) + { + __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>) + while (__f != __t) + *__f++ = _M_nd(__urng) * std::sqrt(n() / _M_gd(__urng)); + } + + template + template + void + std::student_t_distribution<_RealType>:: + __generate_impl(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __p) + { + __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>) + typename std::gamma_distribution::param_type + __p2(__p.n() / 2, 2); + while (__f != __t) + *__f++ = _M_nd(__urng) * std::sqrt(__p.n() / _M_gd(__urng, __p2)); + } + + template + std::basic_ostream<_CharT, _Traits>& + operator<<(std::basic_ostream<_CharT, _Traits>& __os, + const student_t_distribution<_RealType>& __x) + { + typedef std::basic_ostream<_CharT, _Traits> __ostream_type; + typedef typename __ostream_type::ios_base __ios_base; + + const typename __ios_base::fmtflags __flags = __os.flags(); + const _CharT __fill = __os.fill(); + const std::streamsize __precision = __os.precision(); + const _CharT __space = __os.widen(' '); + __os.flags(__ios_base::scientific | __ios_base::left); + __os.fill(__space); + __os.precision(std::numeric_limits<_RealType>::max_digits10); + + __os << __x.n() << __space << __x._M_nd << __space << __x._M_gd; + + __os.flags(__flags); + __os.fill(__fill); + __os.precision(__precision); + return __os; + } + + template + std::basic_istream<_CharT, _Traits>& + operator>>(std::basic_istream<_CharT, _Traits>& __is, + student_t_distribution<_RealType>& __x) + { + typedef std::basic_istream<_CharT, _Traits> __istream_type; + typedef typename __istream_type::ios_base __ios_base; + + const typename __ios_base::fmtflags __flags = __is.flags(); + __is.flags(__ios_base::dec | __ios_base::skipws); + + _RealType __n; + __is >> __n >> __x._M_nd >> __x._M_gd; + __x.param(typename student_t_distribution<_RealType>::param_type(__n)); + + __is.flags(__flags); + return __is; + } + + + template + void + gamma_distribution<_RealType>::param_type:: + _M_initialize() + { + _M_malpha = _M_alpha < 1.0 ? _M_alpha + _RealType(1.0) : _M_alpha; + + const _RealType __a1 = _M_malpha - _RealType(1.0) / _RealType(3.0); + _M_a2 = _RealType(1.0) / std::sqrt(_RealType(9.0) * __a1); + } + + /** + * Marsaglia, G. and Tsang, W. W. + * "A Simple Method for Generating Gamma Variables" + * ACM Transactions on Mathematical Software, 26, 3, 363-372, 2000. + */ + template + template + typename gamma_distribution<_RealType>::result_type + gamma_distribution<_RealType>:: + operator()(_UniformRandomNumberGenerator& __urng, + const param_type& __param) + { + __detail::_Adaptor<_UniformRandomNumberGenerator, result_type> + __aurng(__urng); + + result_type __u, __v, __n; + const result_type __a1 = (__param._M_malpha + - _RealType(1.0) / _RealType(3.0)); + + do + { + do + { + __n = _M_nd(__urng); + __v = result_type(1.0) + __param._M_a2 * __n; + } + while (__v <= 0.0); + + __v = __v * __v * __v; + __u = __aurng(); + } + while (__u > result_type(1.0) - 0.331 * __n * __n * __n * __n + && (std::log(__u) > (0.5 * __n * __n + __a1 + * (1.0 - __v + std::log(__v))))); + + if (__param.alpha() == __param._M_malpha) + return __a1 * __v * __param.beta(); + else + { + do + __u = __aurng(); + while (__u == 0.0); + + return (std::pow(__u, result_type(1.0) / __param.alpha()) + * __a1 * __v * __param.beta()); + } + } + + template + template + void + gamma_distribution<_RealType>:: + __generate_impl(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __param) + { + __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>) + __detail::_Adaptor<_UniformRandomNumberGenerator, result_type> + __aurng(__urng); + + result_type __u, __v, __n; + const result_type __a1 = (__param._M_malpha + - _RealType(1.0) / _RealType(3.0)); + + if (__param.alpha() == __param._M_malpha) + while (__f != __t) + { + do + { + do + { + __n = _M_nd(__urng); + __v = result_type(1.0) + __param._M_a2 * __n; + } + while (__v <= 0.0); + + __v = __v * __v * __v; + __u = __aurng(); + } + while (__u > result_type(1.0) - 0.331 * __n * __n * __n * __n + && (std::log(__u) > (0.5 * __n * __n + __a1 + * (1.0 - __v + std::log(__v))))); + + *__f++ = __a1 * __v * __param.beta(); + } + else + while (__f != __t) + { + do + { + do + { + __n = _M_nd(__urng); + __v = result_type(1.0) + __param._M_a2 * __n; + } + while (__v <= 0.0); + + __v = __v * __v * __v; + __u = __aurng(); + } + while (__u > result_type(1.0) - 0.331 * __n * __n * __n * __n + && (std::log(__u) > (0.5 * __n * __n + __a1 + * (1.0 - __v + std::log(__v))))); + + do + __u = __aurng(); + while (__u == 0.0); + + *__f++ = (std::pow(__u, result_type(1.0) / __param.alpha()) + * __a1 * __v * __param.beta()); + } + } + + template + std::basic_ostream<_CharT, _Traits>& + operator<<(std::basic_ostream<_CharT, _Traits>& __os, + const gamma_distribution<_RealType>& __x) + { + typedef std::basic_ostream<_CharT, _Traits> __ostream_type; + typedef typename __ostream_type::ios_base __ios_base; + + const typename __ios_base::fmtflags __flags = __os.flags(); + const _CharT __fill = __os.fill(); + const std::streamsize __precision = __os.precision(); + const _CharT __space = __os.widen(' '); + __os.flags(__ios_base::scientific | __ios_base::left); + __os.fill(__space); + __os.precision(std::numeric_limits<_RealType>::max_digits10); + + __os << __x.alpha() << __space << __x.beta() + << __space << __x._M_nd; + + __os.flags(__flags); + __os.fill(__fill); + __os.precision(__precision); + return __os; + } + + template + std::basic_istream<_CharT, _Traits>& + operator>>(std::basic_istream<_CharT, _Traits>& __is, + gamma_distribution<_RealType>& __x) + { + typedef std::basic_istream<_CharT, _Traits> __istream_type; + typedef typename __istream_type::ios_base __ios_base; + + const typename __ios_base::fmtflags __flags = __is.flags(); + __is.flags(__ios_base::dec | __ios_base::skipws); + + _RealType __alpha_val, __beta_val; + __is >> __alpha_val >> __beta_val >> __x._M_nd; + __x.param(typename gamma_distribution<_RealType>:: + param_type(__alpha_val, __beta_val)); + + __is.flags(__flags); + return __is; + } + + + template + template + typename weibull_distribution<_RealType>::result_type + weibull_distribution<_RealType>:: + operator()(_UniformRandomNumberGenerator& __urng, + const param_type& __p) + { + __detail::_Adaptor<_UniformRandomNumberGenerator, result_type> + __aurng(__urng); + return __p.b() * std::pow(-std::log(result_type(1) - __aurng()), + result_type(1) / __p.a()); + } + + template + template + void + weibull_distribution<_RealType>:: + __generate_impl(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __p) + { + __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>) + __detail::_Adaptor<_UniformRandomNumberGenerator, result_type> + __aurng(__urng); + auto __inv_a = result_type(1) / __p.a(); + + while (__f != __t) + *__f++ = __p.b() * std::pow(-std::log(result_type(1) - __aurng()), + __inv_a); + } + + template + std::basic_ostream<_CharT, _Traits>& + operator<<(std::basic_ostream<_CharT, _Traits>& __os, + const weibull_distribution<_RealType>& __x) + { + typedef std::basic_ostream<_CharT, _Traits> __ostream_type; + typedef typename __ostream_type::ios_base __ios_base; + + const typename __ios_base::fmtflags __flags = __os.flags(); + const _CharT __fill = __os.fill(); + const std::streamsize __precision = __os.precision(); + const _CharT __space = __os.widen(' '); + __os.flags(__ios_base::scientific | __ios_base::left); + __os.fill(__space); + __os.precision(std::numeric_limits<_RealType>::max_digits10); + + __os << __x.a() << __space << __x.b(); + + __os.flags(__flags); + __os.fill(__fill); + __os.precision(__precision); + return __os; + } + + template + std::basic_istream<_CharT, _Traits>& + operator>>(std::basic_istream<_CharT, _Traits>& __is, + weibull_distribution<_RealType>& __x) + { + typedef std::basic_istream<_CharT, _Traits> __istream_type; + typedef typename __istream_type::ios_base __ios_base; + + const typename __ios_base::fmtflags __flags = __is.flags(); + __is.flags(__ios_base::dec | __ios_base::skipws); + + _RealType __a, __b; + __is >> __a >> __b; + __x.param(typename weibull_distribution<_RealType>:: + param_type(__a, __b)); + + __is.flags(__flags); + return __is; + } + + + template + template + typename extreme_value_distribution<_RealType>::result_type + extreme_value_distribution<_RealType>:: + operator()(_UniformRandomNumberGenerator& __urng, + const param_type& __p) + { + __detail::_Adaptor<_UniformRandomNumberGenerator, result_type> + __aurng(__urng); + return __p.a() - __p.b() * std::log(-std::log(result_type(1) + - __aurng())); + } + + template + template + void + extreme_value_distribution<_RealType>:: + __generate_impl(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __p) + { + __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>) + __detail::_Adaptor<_UniformRandomNumberGenerator, result_type> + __aurng(__urng); + + while (__f != __t) + *__f++ = __p.a() - __p.b() * std::log(-std::log(result_type(1) + - __aurng())); + } + + template + std::basic_ostream<_CharT, _Traits>& + operator<<(std::basic_ostream<_CharT, _Traits>& __os, + const extreme_value_distribution<_RealType>& __x) + { + typedef std::basic_ostream<_CharT, _Traits> __ostream_type; + typedef typename __ostream_type::ios_base __ios_base; + + const typename __ios_base::fmtflags __flags = __os.flags(); + const _CharT __fill = __os.fill(); + const std::streamsize __precision = __os.precision(); + const _CharT __space = __os.widen(' '); + __os.flags(__ios_base::scientific | __ios_base::left); + __os.fill(__space); + __os.precision(std::numeric_limits<_RealType>::max_digits10); + + __os << __x.a() << __space << __x.b(); + + __os.flags(__flags); + __os.fill(__fill); + __os.precision(__precision); + return __os; + } + + template + std::basic_istream<_CharT, _Traits>& + operator>>(std::basic_istream<_CharT, _Traits>& __is, + extreme_value_distribution<_RealType>& __x) + { + typedef std::basic_istream<_CharT, _Traits> __istream_type; + typedef typename __istream_type::ios_base __ios_base; + + const typename __ios_base::fmtflags __flags = __is.flags(); + __is.flags(__ios_base::dec | __ios_base::skipws); + + _RealType __a, __b; + __is >> __a >> __b; + __x.param(typename extreme_value_distribution<_RealType>:: + param_type(__a, __b)); + + __is.flags(__flags); + return __is; + } + + + template + void + discrete_distribution<_IntType>::param_type:: + _M_initialize() + { + if (_M_prob.size() < 2) + { + _M_prob.clear(); + return; + } + + const double __sum = std::accumulate(_M_prob.begin(), + _M_prob.end(), 0.0); + // Now normalize the probabilites. + __detail::__normalize(_M_prob.begin(), _M_prob.end(), _M_prob.begin(), + __sum); + // Accumulate partial sums. + _M_cp.reserve(_M_prob.size()); + std::partial_sum(_M_prob.begin(), _M_prob.end(), + std::back_inserter(_M_cp)); + // Make sure the last cumulative probability is one. + _M_cp[_M_cp.size() - 1] = 1.0; + } + + template + template + discrete_distribution<_IntType>::param_type:: + param_type(size_t __nw, double __xmin, double __xmax, _Func __fw) + : _M_prob(), _M_cp() + { + const size_t __n = __nw == 0 ? 1 : __nw; + const double __delta = (__xmax - __xmin) / __n; + + _M_prob.reserve(__n); + for (size_t __k = 0; __k < __nw; ++__k) + _M_prob.push_back(__fw(__xmin + __k * __delta + 0.5 * __delta)); + + _M_initialize(); + } + + template + template + typename discrete_distribution<_IntType>::result_type + discrete_distribution<_IntType>:: + operator()(_UniformRandomNumberGenerator& __urng, + const param_type& __param) + { + if (__param._M_cp.empty()) + return result_type(0); + + __detail::_Adaptor<_UniformRandomNumberGenerator, double> + __aurng(__urng); + + const double __p = __aurng(); + auto __pos = std::lower_bound(__param._M_cp.begin(), + __param._M_cp.end(), __p); + + return __pos - __param._M_cp.begin(); + } + + template + template + void + discrete_distribution<_IntType>:: + __generate_impl(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __param) + { + __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>) + + if (__param._M_cp.empty()) + { + while (__f != __t) + *__f++ = result_type(0); + return; + } + + __detail::_Adaptor<_UniformRandomNumberGenerator, double> + __aurng(__urng); + + while (__f != __t) + { + const double __p = __aurng(); + auto __pos = std::lower_bound(__param._M_cp.begin(), + __param._M_cp.end(), __p); + + *__f++ = __pos - __param._M_cp.begin(); + } + } + + template + std::basic_ostream<_CharT, _Traits>& + operator<<(std::basic_ostream<_CharT, _Traits>& __os, + const discrete_distribution<_IntType>& __x) + { + typedef std::basic_ostream<_CharT, _Traits> __ostream_type; + typedef typename __ostream_type::ios_base __ios_base; + + const typename __ios_base::fmtflags __flags = __os.flags(); + const _CharT __fill = __os.fill(); + const std::streamsize __precision = __os.precision(); + const _CharT __space = __os.widen(' '); + __os.flags(__ios_base::scientific | __ios_base::left); + __os.fill(__space); + __os.precision(std::numeric_limits::max_digits10); + + std::vector __prob = __x.probabilities(); + __os << __prob.size(); + for (auto __dit = __prob.begin(); __dit != __prob.end(); ++__dit) + __os << __space << *__dit; + + __os.flags(__flags); + __os.fill(__fill); + __os.precision(__precision); + return __os; + } + + template + std::basic_istream<_CharT, _Traits>& + operator>>(std::basic_istream<_CharT, _Traits>& __is, + discrete_distribution<_IntType>& __x) + { + typedef std::basic_istream<_CharT, _Traits> __istream_type; + typedef typename __istream_type::ios_base __ios_base; + + const typename __ios_base::fmtflags __flags = __is.flags(); + __is.flags(__ios_base::dec | __ios_base::skipws); + + size_t __n; + __is >> __n; + + std::vector __prob_vec; + __prob_vec.reserve(__n); + for (; __n != 0; --__n) + { + double __prob; + __is >> __prob; + __prob_vec.push_back(__prob); + } + + __x.param(typename discrete_distribution<_IntType>:: + param_type(__prob_vec.begin(), __prob_vec.end())); + + __is.flags(__flags); + return __is; + } + + + template + void + piecewise_constant_distribution<_RealType>::param_type:: + _M_initialize() + { + if (_M_int.size() < 2 + || (_M_int.size() == 2 + && _M_int[0] == _RealType(0) + && _M_int[1] == _RealType(1))) + { + _M_int.clear(); + _M_den.clear(); + return; + } + + const double __sum = std::accumulate(_M_den.begin(), + _M_den.end(), 0.0); + + __detail::__normalize(_M_den.begin(), _M_den.end(), _M_den.begin(), + __sum); + + _M_cp.reserve(_M_den.size()); + std::partial_sum(_M_den.begin(), _M_den.end(), + std::back_inserter(_M_cp)); + + // Make sure the last cumulative probability is one. + _M_cp[_M_cp.size() - 1] = 1.0; + + for (size_t __k = 0; __k < _M_den.size(); ++__k) + _M_den[__k] /= _M_int[__k + 1] - _M_int[__k]; + } + + template + template + piecewise_constant_distribution<_RealType>::param_type:: + param_type(_InputIteratorB __bbegin, + _InputIteratorB __bend, + _InputIteratorW __wbegin) + : _M_int(), _M_den(), _M_cp() + { + if (__bbegin != __bend) + { + for (;;) + { + _M_int.push_back(*__bbegin); + ++__bbegin; + if (__bbegin == __bend) + break; + + _M_den.push_back(*__wbegin); + ++__wbegin; + } + } + + _M_initialize(); + } + + template + template + piecewise_constant_distribution<_RealType>::param_type:: + param_type(initializer_list<_RealType> __bl, _Func __fw) + : _M_int(), _M_den(), _M_cp() + { + _M_int.reserve(__bl.size()); + for (auto __biter = __bl.begin(); __biter != __bl.end(); ++__biter) + _M_int.push_back(*__biter); + + _M_den.reserve(_M_int.size() - 1); + for (size_t __k = 0; __k < _M_int.size() - 1; ++__k) + _M_den.push_back(__fw(0.5 * (_M_int[__k + 1] + _M_int[__k]))); + + _M_initialize(); + } + + template + template + piecewise_constant_distribution<_RealType>::param_type:: + param_type(size_t __nw, _RealType __xmin, _RealType __xmax, _Func __fw) + : _M_int(), _M_den(), _M_cp() + { + const size_t __n = __nw == 0 ? 1 : __nw; + const _RealType __delta = (__xmax - __xmin) / __n; + + _M_int.reserve(__n + 1); + for (size_t __k = 0; __k <= __nw; ++__k) + _M_int.push_back(__xmin + __k * __delta); + + _M_den.reserve(__n); + for (size_t __k = 0; __k < __nw; ++__k) + _M_den.push_back(__fw(_M_int[__k] + 0.5 * __delta)); + + _M_initialize(); + } + + template + template + typename piecewise_constant_distribution<_RealType>::result_type + piecewise_constant_distribution<_RealType>:: + operator()(_UniformRandomNumberGenerator& __urng, + const param_type& __param) + { + __detail::_Adaptor<_UniformRandomNumberGenerator, double> + __aurng(__urng); + + const double __p = __aurng(); + if (__param._M_cp.empty()) + return __p; + + auto __pos = std::lower_bound(__param._M_cp.begin(), + __param._M_cp.end(), __p); + const size_t __i = __pos - __param._M_cp.begin(); + + const double __pref = __i > 0 ? __param._M_cp[__i - 1] : 0.0; + + return __param._M_int[__i] + (__p - __pref) / __param._M_den[__i]; + } + + template + template + void + piecewise_constant_distribution<_RealType>:: + __generate_impl(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __param) + { + __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>) + __detail::_Adaptor<_UniformRandomNumberGenerator, double> + __aurng(__urng); + + if (__param._M_cp.empty()) + { + while (__f != __t) + *__f++ = __aurng(); + return; + } + + while (__f != __t) + { + const double __p = __aurng(); + + auto __pos = std::lower_bound(__param._M_cp.begin(), + __param._M_cp.end(), __p); + const size_t __i = __pos - __param._M_cp.begin(); + + const double __pref = __i > 0 ? __param._M_cp[__i - 1] : 0.0; + + *__f++ = (__param._M_int[__i] + + (__p - __pref) / __param._M_den[__i]); + } + } + + template + std::basic_ostream<_CharT, _Traits>& + operator<<(std::basic_ostream<_CharT, _Traits>& __os, + const piecewise_constant_distribution<_RealType>& __x) + { + typedef std::basic_ostream<_CharT, _Traits> __ostream_type; + typedef typename __ostream_type::ios_base __ios_base; + + const typename __ios_base::fmtflags __flags = __os.flags(); + const _CharT __fill = __os.fill(); + const std::streamsize __precision = __os.precision(); + const _CharT __space = __os.widen(' '); + __os.flags(__ios_base::scientific | __ios_base::left); + __os.fill(__space); + __os.precision(std::numeric_limits<_RealType>::max_digits10); + + std::vector<_RealType> __int = __x.intervals(); + __os << __int.size() - 1; + + for (auto __xit = __int.begin(); __xit != __int.end(); ++__xit) + __os << __space << *__xit; + + std::vector __den = __x.densities(); + for (auto __dit = __den.begin(); __dit != __den.end(); ++__dit) + __os << __space << *__dit; + + __os.flags(__flags); + __os.fill(__fill); + __os.precision(__precision); + return __os; + } + + template + std::basic_istream<_CharT, _Traits>& + operator>>(std::basic_istream<_CharT, _Traits>& __is, + piecewise_constant_distribution<_RealType>& __x) + { + typedef std::basic_istream<_CharT, _Traits> __istream_type; + typedef typename __istream_type::ios_base __ios_base; + + const typename __ios_base::fmtflags __flags = __is.flags(); + __is.flags(__ios_base::dec | __ios_base::skipws); + + size_t __n; + __is >> __n; + + std::vector<_RealType> __int_vec; + __int_vec.reserve(__n + 1); + for (size_t __i = 0; __i <= __n; ++__i) + { + _RealType __int; + __is >> __int; + __int_vec.push_back(__int); + } + + std::vector __den_vec; + __den_vec.reserve(__n); + for (size_t __i = 0; __i < __n; ++__i) + { + double __den; + __is >> __den; + __den_vec.push_back(__den); + } + + __x.param(typename piecewise_constant_distribution<_RealType>:: + param_type(__int_vec.begin(), __int_vec.end(), __den_vec.begin())); + + __is.flags(__flags); + return __is; + } + + + template + void + piecewise_linear_distribution<_RealType>::param_type:: + _M_initialize() + { + if (_M_int.size() < 2 + || (_M_int.size() == 2 + && _M_int[0] == _RealType(0) + && _M_int[1] == _RealType(1) + && _M_den[0] == _M_den[1])) + { + _M_int.clear(); + _M_den.clear(); + return; + } + + double __sum = 0.0; + _M_cp.reserve(_M_int.size() - 1); + _M_m.reserve(_M_int.size() - 1); + for (size_t __k = 0; __k < _M_int.size() - 1; ++__k) + { + const _RealType __delta = _M_int[__k + 1] - _M_int[__k]; + __sum += 0.5 * (_M_den[__k + 1] + _M_den[__k]) * __delta; + _M_cp.push_back(__sum); + _M_m.push_back((_M_den[__k + 1] - _M_den[__k]) / __delta); + } + + // Now normalize the densities... + __detail::__normalize(_M_den.begin(), _M_den.end(), _M_den.begin(), + __sum); + // ... and partial sums... + __detail::__normalize(_M_cp.begin(), _M_cp.end(), _M_cp.begin(), __sum); + // ... and slopes. + __detail::__normalize(_M_m.begin(), _M_m.end(), _M_m.begin(), __sum); + + // Make sure the last cumulative probablility is one. + _M_cp[_M_cp.size() - 1] = 1.0; + } + + template + template + piecewise_linear_distribution<_RealType>::param_type:: + param_type(_InputIteratorB __bbegin, + _InputIteratorB __bend, + _InputIteratorW __wbegin) + : _M_int(), _M_den(), _M_cp(), _M_m() + { + for (; __bbegin != __bend; ++__bbegin, ++__wbegin) + { + _M_int.push_back(*__bbegin); + _M_den.push_back(*__wbegin); + } + + _M_initialize(); + } + + template + template + piecewise_linear_distribution<_RealType>::param_type:: + param_type(initializer_list<_RealType> __bl, _Func __fw) + : _M_int(), _M_den(), _M_cp(), _M_m() + { + _M_int.reserve(__bl.size()); + _M_den.reserve(__bl.size()); + for (auto __biter = __bl.begin(); __biter != __bl.end(); ++__biter) + { + _M_int.push_back(*__biter); + _M_den.push_back(__fw(*__biter)); + } + + _M_initialize(); + } + + template + template + piecewise_linear_distribution<_RealType>::param_type:: + param_type(size_t __nw, _RealType __xmin, _RealType __xmax, _Func __fw) + : _M_int(), _M_den(), _M_cp(), _M_m() + { + const size_t __n = __nw == 0 ? 1 : __nw; + const _RealType __delta = (__xmax - __xmin) / __n; + + _M_int.reserve(__n + 1); + _M_den.reserve(__n + 1); + for (size_t __k = 0; __k <= __nw; ++__k) + { + _M_int.push_back(__xmin + __k * __delta); + _M_den.push_back(__fw(_M_int[__k] + __delta)); + } + + _M_initialize(); + } + + template + template + typename piecewise_linear_distribution<_RealType>::result_type + piecewise_linear_distribution<_RealType>:: + operator()(_UniformRandomNumberGenerator& __urng, + const param_type& __param) + { + __detail::_Adaptor<_UniformRandomNumberGenerator, double> + __aurng(__urng); + + const double __p = __aurng(); + if (__param._M_cp.empty()) + return __p; + + auto __pos = std::lower_bound(__param._M_cp.begin(), + __param._M_cp.end(), __p); + const size_t __i = __pos - __param._M_cp.begin(); + + const double __pref = __i > 0 ? __param._M_cp[__i - 1] : 0.0; + + const double __a = 0.5 * __param._M_m[__i]; + const double __b = __param._M_den[__i]; + const double __cm = __p - __pref; + + _RealType __x = __param._M_int[__i]; + if (__a == 0) + __x += __cm / __b; + else + { + const double __d = __b * __b + 4.0 * __a * __cm; + __x += 0.5 * (std::sqrt(__d) - __b) / __a; + } + + return __x; + } + + template + template + void + piecewise_linear_distribution<_RealType>:: + __generate_impl(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomNumberGenerator& __urng, + const param_type& __param) + { + __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>) + // We could duplicate everything from operator()... + while (__f != __t) + *__f++ = this->operator()(__urng, __param); + } + + template + std::basic_ostream<_CharT, _Traits>& + operator<<(std::basic_ostream<_CharT, _Traits>& __os, + const piecewise_linear_distribution<_RealType>& __x) + { + typedef std::basic_ostream<_CharT, _Traits> __ostream_type; + typedef typename __ostream_type::ios_base __ios_base; + + const typename __ios_base::fmtflags __flags = __os.flags(); + const _CharT __fill = __os.fill(); + const std::streamsize __precision = __os.precision(); + const _CharT __space = __os.widen(' '); + __os.flags(__ios_base::scientific | __ios_base::left); + __os.fill(__space); + __os.precision(std::numeric_limits<_RealType>::max_digits10); + + std::vector<_RealType> __int = __x.intervals(); + __os << __int.size() - 1; + + for (auto __xit = __int.begin(); __xit != __int.end(); ++__xit) + __os << __space << *__xit; + + std::vector __den = __x.densities(); + for (auto __dit = __den.begin(); __dit != __den.end(); ++__dit) + __os << __space << *__dit; + + __os.flags(__flags); + __os.fill(__fill); + __os.precision(__precision); + return __os; + } + + template + std::basic_istream<_CharT, _Traits>& + operator>>(std::basic_istream<_CharT, _Traits>& __is, + piecewise_linear_distribution<_RealType>& __x) + { + typedef std::basic_istream<_CharT, _Traits> __istream_type; + typedef typename __istream_type::ios_base __ios_base; + + const typename __ios_base::fmtflags __flags = __is.flags(); + __is.flags(__ios_base::dec | __ios_base::skipws); + + size_t __n; + __is >> __n; + + std::vector<_RealType> __int_vec; + __int_vec.reserve(__n + 1); + for (size_t __i = 0; __i <= __n; ++__i) + { + _RealType __int; + __is >> __int; + __int_vec.push_back(__int); + } + + std::vector __den_vec; + __den_vec.reserve(__n + 1); + for (size_t __i = 0; __i <= __n; ++__i) + { + double __den; + __is >> __den; + __den_vec.push_back(__den); + } + + __x.param(typename piecewise_linear_distribution<_RealType>:: + param_type(__int_vec.begin(), __int_vec.end(), __den_vec.begin())); + + __is.flags(__flags); + return __is; + } + + + template + seed_seq::seed_seq(std::initializer_list<_IntType> __il) + { + for (auto __iter = __il.begin(); __iter != __il.end(); ++__iter) + _M_v.push_back(__detail::__mod::__value>(*__iter)); + } + + template + seed_seq::seed_seq(_InputIterator __begin, _InputIterator __end) + { + for (_InputIterator __iter = __begin; __iter != __end; ++__iter) + _M_v.push_back(__detail::__mod::__value>(*__iter)); + } + + template + void + seed_seq::generate(_RandomAccessIterator __begin, + _RandomAccessIterator __end) + { + typedef typename iterator_traits<_RandomAccessIterator>::value_type + _Type; + + if (__begin == __end) + return; + + std::fill(__begin, __end, _Type(0x8b8b8b8bu)); + + const size_t __n = __end - __begin; + const size_t __s = _M_v.size(); + const size_t __t = (__n >= 623) ? 11 + : (__n >= 68) ? 7 + : (__n >= 39) ? 5 + : (__n >= 7) ? 3 + : (__n - 1) / 2; + const size_t __p = (__n - __t) / 2; + const size_t __q = __p + __t; + const size_t __m = std::max(size_t(__s + 1), __n); + + for (size_t __k = 0; __k < __m; ++__k) + { + _Type __arg = (__begin[__k % __n] + ^ __begin[(__k + __p) % __n] + ^ __begin[(__k - 1) % __n]); + _Type __r1 = __arg ^ (__arg >> 27); + __r1 = __detail::__mod<_Type, + __detail::_Shift<_Type, 32>::__value>(1664525u * __r1); + _Type __r2 = __r1; + if (__k == 0) + __r2 += __s; + else if (__k <= __s) + __r2 += __k % __n + _M_v[__k - 1]; + else + __r2 += __k % __n; + __r2 = __detail::__mod<_Type, + __detail::_Shift<_Type, 32>::__value>(__r2); + __begin[(__k + __p) % __n] += __r1; + __begin[(__k + __q) % __n] += __r2; + __begin[__k % __n] = __r2; + } + + for (size_t __k = __m; __k < __m + __n; ++__k) + { + _Type __arg = (__begin[__k % __n] + + __begin[(__k + __p) % __n] + + __begin[(__k - 1) % __n]); + _Type __r3 = __arg ^ (__arg >> 27); + __r3 = __detail::__mod<_Type, + __detail::_Shift<_Type, 32>::__value>(1566083941u * __r3); + _Type __r4 = __r3 - __k % __n; + __r4 = __detail::__mod<_Type, + __detail::_Shift<_Type, 32>::__value>(__r4); + __begin[(__k + __p) % __n] ^= __r3; + __begin[(__k + __q) % __n] ^= __r4; + __begin[__k % __n] = __r4; + } + } + + template + _RealType + generate_canonical(_UniformRandomNumberGenerator& __urng) + { + static_assert(std::is_floating_point<_RealType>::value, + "template argument not a floating point type"); + + const size_t __b + = std::min(static_cast(std::numeric_limits<_RealType>::digits), + __bits); + const long double __r = static_cast(__urng.max()) + - static_cast(__urng.min()) + 1.0L; + const size_t __log2r = std::log(__r) / std::log(2.0L); + size_t __k = std::max(1UL, (__b + __log2r - 1UL) / __log2r); + _RealType __sum = _RealType(0); + _RealType __tmp = _RealType(1); + for (; __k != 0; --__k) + { + __sum += _RealType(__urng() - __urng.min()) * __tmp; + __tmp *= __r; + } + return __sum / __tmp; + } + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/range_access.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/range_access.h new file mode 100755 index 0000000..b70f997 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/range_access.h @@ -0,0 +1,105 @@ +// -*- C++ -*- + +// Copyright (C) 2010-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file bits/range_access.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{iterator} + */ + +#ifndef _GLIBCXX_RANGE_ACCESS_H +#define _GLIBCXX_RANGE_ACCESS_H 1 + +#pragma GCC system_header + +#if __cplusplus >= 201103L + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /** + * @brief Return an iterator pointing to the first element of + * the container. + * @param __cont Container. + */ + template + inline auto + begin(_Container& __cont) -> decltype(__cont.begin()) + { return __cont.begin(); } + + /** + * @brief Return an iterator pointing to the first element of + * the const container. + * @param __cont Container. + */ + template + inline auto + begin(const _Container& __cont) -> decltype(__cont.begin()) + { return __cont.begin(); } + + /** + * @brief Return an iterator pointing to one past the last element of + * the container. + * @param __cont Container. + */ + template + inline auto + end(_Container& __cont) -> decltype(__cont.end()) + { return __cont.end(); } + + /** + * @brief Return an iterator pointing to one past the last element of + * the const container. + * @param __cont Container. + */ + template + inline auto + end(const _Container& __cont) -> decltype(__cont.end()) + { return __cont.end(); } + + /** + * @brief Return an iterator pointing to the first element of the array. + * @param __arr Array. + */ + template + inline _Tp* + begin(_Tp (&__arr)[_Nm]) + { return __arr; } + + /** + * @brief Return an iterator pointing to one past the last element + * of the array. + * @param __arr Array. + */ + template + inline _Tp* + end(_Tp (&__arr)[_Nm]) + { return __arr + _Nm; } + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif // C++11 + +#endif // _GLIBCXX_RANGE_ACCESS_H diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/regex.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/regex.h new file mode 100755 index 0000000..ea70679 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/regex.h @@ -0,0 +1,2754 @@ +// class template regex -*- C++ -*- + +// Copyright (C) 2010-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** + * @file bits/regex.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{regex} + */ + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + template + class basic_regex; + + template + class match_results; + +_GLIBCXX_END_NAMESPACE_VERSION + +namespace __detail +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + enum class _RegexExecutorPolicy : int + { _S_auto, _S_alternate }; + + template + bool + __regex_algo_impl(_BiIter __s, + _BiIter __e, + match_results<_BiIter, _Alloc>& __m, + const basic_regex<_CharT, _TraitsT>& __re, + regex_constants::match_flag_type __flags); + + template + class _Executor; + + template + inline std::shared_ptr<_NFA<_TraitsT>> + __compile_nfa(const typename _TraitsT::char_type* __first, + const typename _TraitsT::char_type* __last, + const _TraitsT& __traits, + regex_constants::syntax_option_type __flags); + +_GLIBCXX_END_NAMESPACE_VERSION +} + +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /** + * @addtogroup regex + * @{ + */ + + /** + * @brief Describes aspects of a regular expression. + * + * A regular expression traits class that satisfies the requirements of + * section [28.7]. + * + * The class %regex is parameterized around a set of related types and + * functions used to complete the definition of its semantics. This class + * satisfies the requirements of such a traits class. + */ + template + struct regex_traits + { + public: + typedef _Ch_type char_type; + typedef std::basic_string string_type; + typedef std::locale locale_type; + private: + struct _RegexMask + { + typedef typename std::ctype::mask _BaseType; + _BaseType _M_base; + unsigned char _M_extended; + static constexpr unsigned char _S_under = 1 << 0; + // FIXME: _S_blank should be removed in the future, + // when locale's complete. + static constexpr unsigned char _S_blank = 1 << 1; + static constexpr unsigned char _S_valid_mask = 0x3; + + constexpr _RegexMask(_BaseType __base = 0, + unsigned char __extended = 0) + : _M_base(__base), _M_extended(__extended) + { } + + constexpr _RegexMask + operator&(_RegexMask __other) const + { + return _RegexMask(_M_base & __other._M_base, + _M_extended & __other._M_extended); + } + + constexpr _RegexMask + operator|(_RegexMask __other) const + { + return _RegexMask(_M_base | __other._M_base, + _M_extended | __other._M_extended); + } + + constexpr _RegexMask + operator^(_RegexMask __other) const + { + return _RegexMask(_M_base ^ __other._M_base, + _M_extended ^ __other._M_extended); + } + + constexpr _RegexMask + operator~() const + { return _RegexMask(~_M_base, ~_M_extended); } + + _RegexMask& + operator&=(_RegexMask __other) + { return *this = (*this) & __other; } + + _RegexMask& + operator|=(_RegexMask __other) + { return *this = (*this) | __other; } + + _RegexMask& + operator^=(_RegexMask __other) + { return *this = (*this) ^ __other; } + + constexpr bool + operator==(_RegexMask __other) const + { + return (_M_extended & _S_valid_mask) + == (__other._M_extended & _S_valid_mask) + && _M_base == __other._M_base; + } + + constexpr bool + operator!=(_RegexMask __other) const + { return !((*this) == __other); } + + }; + public: + typedef _RegexMask char_class_type; + + public: + /** + * @brief Constructs a default traits object. + */ + regex_traits() { } + + /** + * @brief Gives the length of a C-style string starting at @p __p. + * + * @param __p a pointer to the start of a character sequence. + * + * @returns the number of characters between @p *__p and the first + * default-initialized value of type @p char_type. In other words, uses + * the C-string algorithm for determining the length of a sequence of + * characters. + */ + static std::size_t + length(const char_type* __p) + { return string_type::traits_type::length(__p); } + + /** + * @brief Performs the identity translation. + * + * @param __c A character to the locale-specific character set. + * + * @returns __c. + */ + char_type + translate(char_type __c) const + { return __c; } + + /** + * @brief Translates a character into a case-insensitive equivalent. + * + * @param __c A character to the locale-specific character set. + * + * @returns the locale-specific lower-case equivalent of __c. + * @throws std::bad_cast if the imbued locale does not support the ctype + * facet. + */ + char_type + translate_nocase(char_type __c) const + { + typedef std::ctype __ctype_type; + const __ctype_type& __fctyp(use_facet<__ctype_type>(_M_locale)); + return __fctyp.tolower(__c); + } + + /** + * @brief Gets a sort key for a character sequence. + * + * @param __first beginning of the character sequence. + * @param __last one-past-the-end of the character sequence. + * + * Returns a sort key for the character sequence designated by the + * iterator range [F1, F2) such that if the character sequence [G1, G2) + * sorts before the character sequence [H1, H2) then + * v.transform(G1, G2) < v.transform(H1, H2). + * + * What this really does is provide a more efficient way to compare a + * string to multiple other strings in locales with fancy collation + * rules and equivalence classes. + * + * @returns a locale-specific sort key equivalent to the input range. + * + * @throws std::bad_cast if the current locale does not have a collate + * facet. + */ + template + string_type + transform(_Fwd_iter __first, _Fwd_iter __last) const + { + typedef std::collate __collate_type; + const __collate_type& __fclt(use_facet<__collate_type>(_M_locale)); + string_type __s(__first, __last); + return __fclt.transform(__s.data(), __s.data() + __s.size()); + } + + /** + * @brief Gets a sort key for a character sequence, independent of case. + * + * @param __first beginning of the character sequence. + * @param __last one-past-the-end of the character sequence. + * + * Effects: if typeid(use_facet >) == + * typeid(collate_byname<_Ch_type>) and the form of the sort key + * returned by collate_byname<_Ch_type>::transform(__first, __last) + * is known and can be converted into a primary sort key + * then returns that key, otherwise returns an empty string. + * + * @todo Implement this function correctly. + */ + template + string_type + transform_primary(_Fwd_iter __first, _Fwd_iter __last) const + { + // TODO : this is not entirely correct. + // This function requires extra support from the platform. + // + // Read http://gcc.gnu.org/ml/libstdc++/2013-09/msg00117.html and + // http://www.open-std.org/Jtc1/sc22/wg21/docs/papers/2003/n1429.htm + // for details. + typedef std::ctype __ctype_type; + const __ctype_type& __fctyp(use_facet<__ctype_type>(_M_locale)); + std::vector __s(__first, __last); + __fctyp.tolower(__s.data(), __s.data() + __s.size()); + return this->transform(__s.data(), __s.data() + __s.size()); + } + + /** + * @brief Gets a collation element by name. + * + * @param __first beginning of the collation element name. + * @param __last one-past-the-end of the collation element name. + * + * @returns a sequence of one or more characters that represents the + * collating element consisting of the character sequence designated by + * the iterator range [__first, __last). Returns an empty string if the + * character sequence is not a valid collating element. + */ + template + string_type + lookup_collatename(_Fwd_iter __first, _Fwd_iter __last) const; + + /** + * @brief Maps one or more characters to a named character + * classification. + * + * @param __first beginning of the character sequence. + * @param __last one-past-the-end of the character sequence. + * @param __icase ignores the case of the classification name. + * + * @returns an unspecified value that represents the character + * classification named by the character sequence designated by + * the iterator range [__first, __last). If @p icase is true, + * the returned mask identifies the classification regardless of + * the case of the characters to be matched (for example, + * [[:lower:]] is the same as [[:alpha:]]), otherwise a + * case-dependent classification is returned. The value + * returned shall be independent of the case of the characters + * in the character sequence. If the name is not recognized then + * returns a value that compares equal to 0. + * + * At least the following names (or their wide-character equivalent) are + * supported. + * - d + * - w + * - s + * - alnum + * - alpha + * - blank + * - cntrl + * - digit + * - graph + * - lower + * - print + * - punct + * - space + * - upper + * - xdigit + */ + template + char_class_type + lookup_classname(_Fwd_iter __first, _Fwd_iter __last, + bool __icase = false) const; + + /** + * @brief Determines if @p c is a member of an identified class. + * + * @param __c a character. + * @param __f a class type (as returned from lookup_classname). + * + * @returns true if the character @p __c is a member of the classification + * represented by @p __f, false otherwise. + * + * @throws std::bad_cast if the current locale does not have a ctype + * facet. + */ + bool + isctype(_Ch_type __c, char_class_type __f) const; + + /** + * @brief Converts a digit to an int. + * + * @param __ch a character representing a digit. + * @param __radix the radix if the numeric conversion (limited to 8, 10, + * or 16). + * + * @returns the value represented by the digit __ch in base radix if the + * character __ch is a valid digit in base radix; otherwise returns -1. + */ + int + value(_Ch_type __ch, int __radix) const; + + /** + * @brief Imbues the regex_traits object with a copy of a new locale. + * + * @param __loc A locale. + * + * @returns a copy of the previous locale in use by the regex_traits + * object. + * + * @note Calling imbue with a different locale than the one currently in + * use invalidates all cached data held by *this. + */ + locale_type + imbue(locale_type __loc) + { + std::swap(_M_locale, __loc); + return __loc; + } + + /** + * @brief Gets a copy of the current locale in use by the regex_traits + * object. + */ + locale_type + getloc() const + { return _M_locale; } + + protected: + locale_type _M_locale; + }; + + // [7.8] Class basic_regex + /** + * Objects of specializations of this class represent regular expressions + * constructed from sequences of character type @p _Ch_type. + * + * Storage for the regular expression is allocated and deallocated as + * necessary by the member functions of this class. + */ + template> + class basic_regex + { + public: + static_assert(is_same<_Ch_type, typename _Rx_traits::char_type>::value, + "regex traits class must have the same char_type"); + + // types: + typedef _Ch_type value_type; + typedef _Rx_traits traits_type; + typedef typename traits_type::string_type string_type; + typedef regex_constants::syntax_option_type flag_type; + typedef typename traits_type::locale_type locale_type; + + /** + * @name Constants + * std [28.8.1](1) + */ + //@{ + static constexpr flag_type icase = regex_constants::icase; + static constexpr flag_type nosubs = regex_constants::nosubs; + static constexpr flag_type optimize = regex_constants::optimize; + static constexpr flag_type collate = regex_constants::collate; + static constexpr flag_type ECMAScript = regex_constants::ECMAScript; + static constexpr flag_type basic = regex_constants::basic; + static constexpr flag_type extended = regex_constants::extended; + static constexpr flag_type awk = regex_constants::awk; + static constexpr flag_type grep = regex_constants::grep; + static constexpr flag_type egrep = regex_constants::egrep; + //@} + + // [7.8.2] construct/copy/destroy + /** + * Constructs a basic regular expression that does not match any + * character sequence. + */ + basic_regex() + : _M_flags(ECMAScript), _M_automaton(nullptr) + { } + + /** + * @brief Constructs a basic regular expression from the + * sequence [__p, __p + char_traits<_Ch_type>::length(__p)) + * interpreted according to the flags in @p __f. + * + * @param __p A pointer to the start of a C-style null-terminated string + * containing a regular expression. + * @param __f Flags indicating the syntax rules and options. + * + * @throws regex_error if @p __p is not a valid regular expression. + */ + explicit + basic_regex(const _Ch_type* __p, flag_type __f = ECMAScript) + : basic_regex(__p, __p + char_traits<_Ch_type>::length(__p), __f) + { } + + /** + * @brief Constructs a basic regular expression from the sequence + * [p, p + len) interpreted according to the flags in @p f. + * + * @param __p A pointer to the start of a string containing a regular + * expression. + * @param __len The length of the string containing the regular + * expression. + * @param __f Flags indicating the syntax rules and options. + * + * @throws regex_error if @p __p is not a valid regular expression. + */ + basic_regex(const _Ch_type* __p, std::size_t __len, + flag_type __f = ECMAScript) + : basic_regex(__p, __p + __len, __f) + { } + + /** + * @brief Copy-constructs a basic regular expression. + * + * @param __rhs A @p regex object. + */ + basic_regex(const basic_regex& __rhs) + : _M_flags(__rhs._M_flags), _M_original_str(__rhs._M_original_str) + { + _M_traits.imbue(__rhs.getloc()); + this->assign(_M_original_str, _M_flags); + } + + /** + * @brief Move-constructs a basic regular expression. + * + * @param __rhs A @p regex object. + * + * The implementation is a workaround concerning ABI compatibility. See: + * https://gcc.gnu.org/ml/libstdc++/2014-09/msg00067.html + */ + basic_regex(basic_regex&& __rhs) + : _M_flags(__rhs._M_flags), + _M_original_str(std::move(__rhs._M_original_str)) + { + _M_traits.imbue(__rhs.getloc()); + this->assign(_M_original_str, _M_flags); + __rhs._M_automaton.reset(); + } + + /** + * @brief Constructs a basic regular expression from the string + * @p s interpreted according to the flags in @p f. + * + * @param __s A string containing a regular expression. + * @param __f Flags indicating the syntax rules and options. + * + * @throws regex_error if @p __s is not a valid regular expression. + */ + template + explicit + basic_regex(const std::basic_string<_Ch_type, _Ch_traits, + _Ch_alloc>& __s, + flag_type __f = ECMAScript) + : basic_regex(__s.begin(), __s.end(), __f) + { } + + /** + * @brief Constructs a basic regular expression from the range + * [first, last) interpreted according to the flags in @p f. + * + * @param __first The start of a range containing a valid regular + * expression. + * @param __last The end of a range containing a valid regular + * expression. + * @param __f The format flags of the regular expression. + * + * @throws regex_error if @p [__first, __last) is not a valid regular + * expression. + */ + template + basic_regex(_FwdIter __first, _FwdIter __last, + flag_type __f = ECMAScript) + : _M_flags(__f), + _M_original_str(__first, __last), + _M_automaton(__detail::__compile_nfa(_M_original_str.c_str(), + _M_original_str.c_str() + + _M_original_str.size(), + _M_traits, + _M_flags)) + { } + + /** + * @brief Constructs a basic regular expression from an initializer list. + * + * @param __l The initializer list. + * @param __f The format flags of the regular expression. + * + * @throws regex_error if @p __l is not a valid regular expression. + */ + basic_regex(initializer_list<_Ch_type> __l, flag_type __f = ECMAScript) + : basic_regex(__l.begin(), __l.end(), __f) + { } + + /** + * @brief Destroys a basic regular expression. + */ + ~basic_regex() + { } + + /** + * @brief Assigns one regular expression to another. + */ + basic_regex& + operator=(const basic_regex& __rhs) + { return this->assign(__rhs); } + + /** + * @brief Move-assigns one regular expression to another. + * + * The implementation is a workaround concerning ABI compatibility. See: + * https://gcc.gnu.org/ml/libstdc++/2014-09/msg00067.html + */ + basic_regex& + operator=(basic_regex&& __rhs) + { return this->assign(std::move(__rhs)); } + + /** + * @brief Replaces a regular expression with a new one constructed from + * a C-style null-terminated string. + * + * @param __p A pointer to the start of a null-terminated C-style string + * containing a regular expression. + */ + basic_regex& + operator=(const _Ch_type* __p) + { return this->assign(__p); } + + /** + * @brief Replaces a regular expression with a new one constructed from + * an initializer list. + * + * @param __l The initializer list. + * + * @throws regex_error if @p __l is not a valid regular expression. + */ + basic_regex& + operator=(initializer_list<_Ch_type> __l) + { return this->assign(__l.begin(), __l.end()); } + + /** + * @brief Replaces a regular expression with a new one constructed from + * a string. + * + * @param __s A pointer to a string containing a regular expression. + */ + template + basic_regex& + operator=(const basic_string<_Ch_type, _Ch_typeraits, _Alloc>& __s) + { return this->assign(__s); } + + // [7.8.3] assign + /** + * @brief the real assignment operator. + * + * @param __rhs Another regular expression object. + */ + basic_regex& + assign(const basic_regex& __rhs) + { + _M_flags = __rhs._M_flags; + _M_original_str = __rhs._M_original_str; + _M_traits.imbue(__rhs.getloc()); + this->assign(_M_original_str, _M_flags); + return *this; + } + + /** + * @brief The move-assignment operator. + * + * @param __rhs Another regular expression object. + * + * The implementation is a workaround concerning ABI compatibility. See: + * https://gcc.gnu.org/ml/libstdc++/2014-09/msg00067.html + */ + basic_regex& + assign(basic_regex&& __rhs) + { + _M_flags = __rhs._M_flags; + _M_original_str = std::move(__rhs._M_original_str); + __rhs._M_automaton.reset(); + _M_traits.imbue(__rhs.getloc()); + this->assign(_M_original_str, _M_flags); + return *this; + } + + /** + * @brief Assigns a new regular expression to a regex object from a + * C-style null-terminated string containing a regular expression + * pattern. + * + * @param __p A pointer to a C-style null-terminated string containing + * a regular expression pattern. + * @param __flags Syntax option flags. + * + * @throws regex_error if __p does not contain a valid regular + * expression pattern interpreted according to @p __flags. If + * regex_error is thrown, *this remains unchanged. + */ + basic_regex& + assign(const _Ch_type* __p, flag_type __flags = ECMAScript) + { return this->assign(string_type(__p), __flags); } + + /** + * @brief Assigns a new regular expression to a regex object from a + * C-style string containing a regular expression pattern. + * + * @param __p A pointer to a C-style string containing a + * regular expression pattern. + * @param __len The length of the regular expression pattern string. + * @param __flags Syntax option flags. + * + * @throws regex_error if p does not contain a valid regular + * expression pattern interpreted according to @p __flags. If + * regex_error is thrown, *this remains unchanged. + */ + basic_regex& + assign(const _Ch_type* __p, std::size_t __len, flag_type __flags) + { return this->assign(string_type(__p, __len), __flags); } + + /** + * @brief Assigns a new regular expression to a regex object from a + * string containing a regular expression pattern. + * + * @param __s A string containing a regular expression pattern. + * @param __flags Syntax option flags. + * + * @throws regex_error if __s does not contain a valid regular + * expression pattern interpreted according to @p __flags. If + * regex_error is thrown, *this remains unchanged. + */ + template + basic_regex& + assign(const basic_string<_Ch_type, _Ch_typeraits, _Alloc>& __s, + flag_type __flags = ECMAScript) + { + _M_automaton = __detail::__compile_nfa( + __s.data(), __s.data() + __s.size(), _M_traits, __flags); + _M_original_str = __s; + _M_flags = __flags; + return *this; + } + + /** + * @brief Assigns a new regular expression to a regex object. + * + * @param __first The start of a range containing a valid regular + * expression. + * @param __last The end of a range containing a valid regular + * expression. + * @param __flags Syntax option flags. + * + * @throws regex_error if p does not contain a valid regular + * expression pattern interpreted according to @p __flags. If + * regex_error is thrown, the object remains unchanged. + */ + template + basic_regex& + assign(_InputIterator __first, _InputIterator __last, + flag_type __flags = ECMAScript) + { return this->assign(string_type(__first, __last), __flags); } + + /** + * @brief Assigns a new regular expression to a regex object. + * + * @param __l An initializer list representing a regular expression. + * @param __flags Syntax option flags. + * + * @throws regex_error if @p __l does not contain a valid + * regular expression pattern interpreted according to @p + * __flags. If regex_error is thrown, the object remains + * unchanged. + */ + basic_regex& + assign(initializer_list<_Ch_type> __l, flag_type __flags = ECMAScript) + { return this->assign(__l.begin(), __l.end(), __flags); } + + // [7.8.4] const operations + /** + * @brief Gets the number of marked subexpressions within the regular + * expression. + */ + unsigned int + mark_count() const + { + if (_M_automaton) + return _M_automaton->_M_sub_count() - 1; + return 0; + } + + /** + * @brief Gets the flags used to construct the regular expression + * or in the last call to assign(). + */ + flag_type + flags() const + { return _M_flags; } + + // [7.8.5] locale + /** + * @brief Imbues the regular expression object with the given locale. + * + * @param __loc A locale. + */ + locale_type + imbue(locale_type __loc) + { + _M_automaton.reset(); + return _M_traits.imbue(__loc); + } + + /** + * @brief Gets the locale currently imbued in the regular expression + * object. + */ + locale_type + getloc() const + { return _M_traits.getloc(); } + + // [7.8.6] swap + /** + * @brief Swaps the contents of two regular expression objects. + * + * @param __rhs Another regular expression object. + */ + void + swap(basic_regex& __rhs) + { + std::swap(_M_flags, __rhs._M_flags); + std::swap(_M_traits, __rhs._M_traits); + auto __tmp = std::move(_M_original_str); + this->assign(__rhs._M_original_str, _M_flags); + __rhs.assign(__tmp, __rhs._M_flags); + } + +#ifdef _GLIBCXX_DEBUG + void + _M_dot(std::ostream& __ostr) + { _M_automaton->_M_dot(__ostr); } +#endif + + private: + typedef std::shared_ptr<__detail::_NFA<_Rx_traits>> _AutomatonPtr; + + template + friend bool + __detail::__regex_algo_impl(_Bp, _Bp, match_results<_Bp, _Ap>&, + const basic_regex<_Cp, _Rp>&, + regex_constants::match_flag_type); + + template + friend class __detail::_Executor; + + flag_type _M_flags; + _Rx_traits _M_traits; + basic_string<_Ch_type> _M_original_str; + _AutomatonPtr _M_automaton; + }; + + /** @brief Standard regular expressions. */ + typedef basic_regex regex; + +#ifdef _GLIBCXX_USE_WCHAR_T + /** @brief Standard wide-character regular expressions. */ + typedef basic_regex wregex; +#endif + + + // [7.8.6] basic_regex swap + /** + * @brief Swaps the contents of two regular expression objects. + * @param __lhs First regular expression. + * @param __rhs Second regular expression. + */ + template + inline void + swap(basic_regex<_Ch_type, _Rx_traits>& __lhs, + basic_regex<_Ch_type, _Rx_traits>& __rhs) + { __lhs.swap(__rhs); } + + + // [7.9] Class template sub_match + /** + * A sequence of characters matched by a particular marked sub-expression. + * + * An object of this class is essentially a pair of iterators marking a + * matched subexpression within a regular expression pattern match. Such + * objects can be converted to and compared with std::basic_string objects + * of a similar base character type as the pattern matched by the regular + * expression. + * + * The iterators that make up the pair are the usual half-open interval + * referencing the actual original pattern matched. + */ + template + class sub_match : public std::pair<_BiIter, _BiIter> + { + typedef iterator_traits<_BiIter> __iter_traits; + + public: + typedef typename __iter_traits::value_type value_type; + typedef typename __iter_traits::difference_type difference_type; + typedef _BiIter iterator; + typedef std::basic_string string_type; + + bool matched; + + constexpr sub_match() : matched() { } + + /** + * Gets the length of the matching sequence. + */ + difference_type + length() const + { return this->matched ? std::distance(this->first, this->second) : 0; } + + /** + * @brief Gets the matching sequence as a string. + * + * @returns the matching sequence as a string. + * + * This is the implicit conversion operator. It is identical to the + * str() member function except that it will want to pop up in + * unexpected places and cause a great deal of confusion and cursing + * from the unwary. + */ + operator string_type() const + { + return this->matched + ? string_type(this->first, this->second) + : string_type(); + } + + /** + * @brief Gets the matching sequence as a string. + * + * @returns the matching sequence as a string. + */ + string_type + str() const + { + return this->matched + ? string_type(this->first, this->second) + : string_type(); + } + + /** + * @brief Compares this and another matched sequence. + * + * @param __s Another matched sequence to compare to this one. + * + * @retval <0 this matched sequence will collate before @p __s. + * @retval =0 this matched sequence is equivalent to @p __s. + * @retval <0 this matched sequence will collate after @p __s. + */ + int + compare(const sub_match& __s) const + { return this->str().compare(__s.str()); } + + /** + * @brief Compares this sub_match to a string. + * + * @param __s A string to compare to this sub_match. + * + * @retval <0 this matched sequence will collate before @p __s. + * @retval =0 this matched sequence is equivalent to @p __s. + * @retval <0 this matched sequence will collate after @p __s. + */ + int + compare(const string_type& __s) const + { return this->str().compare(__s); } + + /** + * @brief Compares this sub_match to a C-style string. + * + * @param __s A C-style string to compare to this sub_match. + * + * @retval <0 this matched sequence will collate before @p __s. + * @retval =0 this matched sequence is equivalent to @p __s. + * @retval <0 this matched sequence will collate after @p __s. + */ + int + compare(const value_type* __s) const + { return this->str().compare(__s); } + }; + + + /** @brief Standard regex submatch over a C-style null-terminated string. */ + typedef sub_match csub_match; + + /** @brief Standard regex submatch over a standard string. */ + typedef sub_match ssub_match; + +#ifdef _GLIBCXX_USE_WCHAR_T + /** @brief Regex submatch over a C-style null-terminated wide string. */ + typedef sub_match wcsub_match; + + /** @brief Regex submatch over a standard wide string. */ + typedef sub_match wssub_match; +#endif + + // [7.9.2] sub_match non-member operators + + /** + * @brief Tests the equivalence of two regular expression submatches. + * @param __lhs First regular expression submatch. + * @param __rhs Second regular expression submatch. + * @returns true if @a __lhs is equivalent to @a __rhs, false otherwise. + */ + template + inline bool + operator==(const sub_match<_BiIter>& __lhs, const sub_match<_BiIter>& __rhs) + { return __lhs.compare(__rhs) == 0; } + + /** + * @brief Tests the inequivalence of two regular expression submatches. + * @param __lhs First regular expression submatch. + * @param __rhs Second regular expression submatch. + * @returns true if @a __lhs is not equivalent to @a __rhs, false otherwise. + */ + template + inline bool + operator!=(const sub_match<_BiIter>& __lhs, const sub_match<_BiIter>& __rhs) + { return __lhs.compare(__rhs) != 0; } + + /** + * @brief Tests the ordering of two regular expression submatches. + * @param __lhs First regular expression submatch. + * @param __rhs Second regular expression submatch. + * @returns true if @a __lhs precedes @a __rhs, false otherwise. + */ + template + inline bool + operator<(const sub_match<_BiIter>& __lhs, const sub_match<_BiIter>& __rhs) + { return __lhs.compare(__rhs) < 0; } + + /** + * @brief Tests the ordering of two regular expression submatches. + * @param __lhs First regular expression submatch. + * @param __rhs Second regular expression submatch. + * @returns true if @a __lhs does not succeed @a __rhs, false otherwise. + */ + template + inline bool + operator<=(const sub_match<_BiIter>& __lhs, const sub_match<_BiIter>& __rhs) + { return __lhs.compare(__rhs) <= 0; } + + /** + * @brief Tests the ordering of two regular expression submatches. + * @param __lhs First regular expression submatch. + * @param __rhs Second regular expression submatch. + * @returns true if @a __lhs does not precede @a __rhs, false otherwise. + */ + template + inline bool + operator>=(const sub_match<_BiIter>& __lhs, const sub_match<_BiIter>& __rhs) + { return __lhs.compare(__rhs) >= 0; } + + /** + * @brief Tests the ordering of two regular expression submatches. + * @param __lhs First regular expression submatch. + * @param __rhs Second regular expression submatch. + * @returns true if @a __lhs succeeds @a __rhs, false otherwise. + */ + template + inline bool + operator>(const sub_match<_BiIter>& __lhs, const sub_match<_BiIter>& __rhs) + { return __lhs.compare(__rhs) > 0; } + + // Alias for sub_match'd string. + template + using __sub_match_string = basic_string< + typename iterator_traits<_Bi_iter>::value_type, + _Ch_traits, _Ch_alloc>; + + /** + * @brief Tests the equivalence of a string and a regular expression + * submatch. + * @param __lhs A string. + * @param __rhs A regular expression submatch. + * @returns true if @a __lhs is equivalent to @a __rhs, false otherwise. + */ + template + inline bool + operator==(const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __lhs, + const sub_match<_Bi_iter>& __rhs) + { return __rhs.compare(__lhs.c_str()) == 0; } + + /** + * @brief Tests the inequivalence of a string and a regular expression + * submatch. + * @param __lhs A string. + * @param __rhs A regular expression submatch. + * @returns true if @a __lhs is not equivalent to @a __rhs, false otherwise. + */ + template + inline bool + operator!=(const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __lhs, + const sub_match<_Bi_iter>& __rhs) + { return !(__lhs == __rhs); } + + /** + * @brief Tests the ordering of a string and a regular expression submatch. + * @param __lhs A string. + * @param __rhs A regular expression submatch. + * @returns true if @a __lhs precedes @a __rhs, false otherwise. + */ + template + inline bool + operator<(const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __lhs, + const sub_match<_Bi_iter>& __rhs) + { return __rhs.compare(__lhs.c_str()) > 0; } + + /** + * @brief Tests the ordering of a string and a regular expression submatch. + * @param __lhs A string. + * @param __rhs A regular expression submatch. + * @returns true if @a __lhs succeeds @a __rhs, false otherwise. + */ + template + inline bool + operator>(const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __lhs, + const sub_match<_Bi_iter>& __rhs) + { return __rhs < __lhs; } + + /** + * @brief Tests the ordering of a string and a regular expression submatch. + * @param __lhs A string. + * @param __rhs A regular expression submatch. + * @returns true if @a __lhs does not precede @a __rhs, false otherwise. + */ + template + inline bool + operator>=(const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __lhs, + const sub_match<_Bi_iter>& __rhs) + { return !(__lhs < __rhs); } + + /** + * @brief Tests the ordering of a string and a regular expression submatch. + * @param __lhs A string. + * @param __rhs A regular expression submatch. + * @returns true if @a __lhs does not succeed @a __rhs, false otherwise. + */ + template + inline bool + operator<=(const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __lhs, + const sub_match<_Bi_iter>& __rhs) + { return !(__rhs < __lhs); } + + /** + * @brief Tests the equivalence of a regular expression submatch and a + * string. + * @param __lhs A regular expression submatch. + * @param __rhs A string. + * @returns true if @a __lhs is equivalent to @a __rhs, false otherwise. + */ + template + inline bool + operator==(const sub_match<_Bi_iter>& __lhs, + const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __rhs) + { return __lhs.compare(__rhs.c_str()) == 0; } + + /** + * @brief Tests the inequivalence of a regular expression submatch and a + * string. + * @param __lhs A regular expression submatch. + * @param __rhs A string. + * @returns true if @a __lhs is not equivalent to @a __rhs, false otherwise. + */ + template + inline bool + operator!=(const sub_match<_Bi_iter>& __lhs, + const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __rhs) + { return !(__lhs == __rhs); } + + /** + * @brief Tests the ordering of a regular expression submatch and a string. + * @param __lhs A regular expression submatch. + * @param __rhs A string. + * @returns true if @a __lhs precedes @a __rhs, false otherwise. + */ + template + inline bool + operator<(const sub_match<_Bi_iter>& __lhs, + const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __rhs) + { return __lhs.compare(__rhs.c_str()) < 0; } + + /** + * @brief Tests the ordering of a regular expression submatch and a string. + * @param __lhs A regular expression submatch. + * @param __rhs A string. + * @returns true if @a __lhs succeeds @a __rhs, false otherwise. + */ + template + inline bool + operator>(const sub_match<_Bi_iter>& __lhs, + const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __rhs) + { return __rhs < __lhs; } + + /** + * @brief Tests the ordering of a regular expression submatch and a string. + * @param __lhs A regular expression submatch. + * @param __rhs A string. + * @returns true if @a __lhs does not precede @a __rhs, false otherwise. + */ + template + inline bool + operator>=(const sub_match<_Bi_iter>& __lhs, + const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __rhs) + { return !(__lhs < __rhs); } + + /** + * @brief Tests the ordering of a regular expression submatch and a string. + * @param __lhs A regular expression submatch. + * @param __rhs A string. + * @returns true if @a __lhs does not succeed @a __rhs, false otherwise. + */ + template + inline bool + operator<=(const sub_match<_Bi_iter>& __lhs, + const __sub_match_string<_Bi_iter, _Ch_traits, _Ch_alloc>& __rhs) + { return !(__rhs < __lhs); } + + /** + * @brief Tests the equivalence of a C string and a regular expression + * submatch. + * @param __lhs A C string. + * @param __rhs A regular expression submatch. + * @returns true if @a __lhs is equivalent to @a __rhs, false otherwise. + */ + template + inline bool + operator==(typename iterator_traits<_Bi_iter>::value_type const* __lhs, + const sub_match<_Bi_iter>& __rhs) + { return __rhs.compare(__lhs) == 0; } + + /** + * @brief Tests the inequivalence of an iterator value and a regular + * expression submatch. + * @param __lhs A regular expression submatch. + * @param __rhs A string. + * @returns true if @a __lhs is not equivalent to @a __rhs, false otherwise. + */ + template + inline bool + operator!=(typename iterator_traits<_Bi_iter>::value_type const* __lhs, + const sub_match<_Bi_iter>& __rhs) + { return !(__lhs == __rhs); } + + /** + * @brief Tests the ordering of a string and a regular expression submatch. + * @param __lhs A string. + * @param __rhs A regular expression submatch. + * @returns true if @a __lhs precedes @a __rhs, false otherwise. + */ + template + inline bool + operator<(typename iterator_traits<_Bi_iter>::value_type const* __lhs, + const sub_match<_Bi_iter>& __rhs) + { return __rhs.compare(__lhs) > 0; } + + /** + * @brief Tests the ordering of a string and a regular expression submatch. + * @param __lhs A string. + * @param __rhs A regular expression submatch. + * @returns true if @a __lhs succeeds @a __rhs, false otherwise. + */ + template + inline bool + operator>(typename iterator_traits<_Bi_iter>::value_type const* __lhs, + const sub_match<_Bi_iter>& __rhs) + { return __rhs < __lhs; } + + /** + * @brief Tests the ordering of a string and a regular expression submatch. + * @param __lhs A string. + * @param __rhs A regular expression submatch. + * @returns true if @a __lhs does not precede @a __rhs, false otherwise. + */ + template + inline bool + operator>=(typename iterator_traits<_Bi_iter>::value_type const* __lhs, + const sub_match<_Bi_iter>& __rhs) + { return !(__lhs < __rhs); } + + /** + * @brief Tests the ordering of a string and a regular expression submatch. + * @param __lhs A string. + * @param __rhs A regular expression submatch. + * @returns true if @a __lhs does not succeed @a __rhs, false otherwise. + */ + template + inline bool + operator<=(typename iterator_traits<_Bi_iter>::value_type const* __lhs, + const sub_match<_Bi_iter>& __rhs) + { return !(__rhs < __lhs); } + + /** + * @brief Tests the equivalence of a regular expression submatch and a + * string. + * @param __lhs A regular expression submatch. + * @param __rhs A pointer to a string? + * @returns true if @a __lhs is equivalent to @a __rhs, false otherwise. + */ + template + inline bool + operator==(const sub_match<_Bi_iter>& __lhs, + typename iterator_traits<_Bi_iter>::value_type const* __rhs) + { return __lhs.compare(__rhs) == 0; } + + /** + * @brief Tests the inequivalence of a regular expression submatch and a + * string. + * @param __lhs A regular expression submatch. + * @param __rhs A pointer to a string. + * @returns true if @a __lhs is not equivalent to @a __rhs, false otherwise. + */ + template + inline bool + operator!=(const sub_match<_Bi_iter>& __lhs, + typename iterator_traits<_Bi_iter>::value_type const* __rhs) + { return !(__lhs == __rhs); } + + /** + * @brief Tests the ordering of a regular expression submatch and a string. + * @param __lhs A regular expression submatch. + * @param __rhs A string. + * @returns true if @a __lhs precedes @a __rhs, false otherwise. + */ + template + inline bool + operator<(const sub_match<_Bi_iter>& __lhs, + typename iterator_traits<_Bi_iter>::value_type const* __rhs) + { return __lhs.compare(__rhs) < 0; } + + /** + * @brief Tests the ordering of a regular expression submatch and a string. + * @param __lhs A regular expression submatch. + * @param __rhs A string. + * @returns true if @a __lhs succeeds @a __rhs, false otherwise. + */ + template + inline bool + operator>(const sub_match<_Bi_iter>& __lhs, + typename iterator_traits<_Bi_iter>::value_type const* __rhs) + { return __rhs < __lhs; } + + /** + * @brief Tests the ordering of a regular expression submatch and a string. + * @param __lhs A regular expression submatch. + * @param __rhs A string. + * @returns true if @a __lhs does not precede @a __rhs, false otherwise. + */ + template + inline bool + operator>=(const sub_match<_Bi_iter>& __lhs, + typename iterator_traits<_Bi_iter>::value_type const* __rhs) + { return !(__lhs < __rhs); } + + /** + * @brief Tests the ordering of a regular expression submatch and a string. + * @param __lhs A regular expression submatch. + * @param __rhs A string. + * @returns true if @a __lhs does not succeed @a __rhs, false otherwise. + */ + template + inline bool + operator<=(const sub_match<_Bi_iter>& __lhs, + typename iterator_traits<_Bi_iter>::value_type const* __rhs) + { return !(__rhs < __lhs); } + + /** + * @brief Tests the equivalence of a string and a regular expression + * submatch. + * @param __lhs A string. + * @param __rhs A regular expression submatch. + * @returns true if @a __lhs is equivalent to @a __rhs, false otherwise. + */ + template + inline bool + operator==(typename iterator_traits<_Bi_iter>::value_type const& __lhs, + const sub_match<_Bi_iter>& __rhs) + { + typedef typename sub_match<_Bi_iter>::string_type string_type; + return __rhs.compare(string_type(1, __lhs)) == 0; + } + + /** + * @brief Tests the inequivalence of a string and a regular expression + * submatch. + * @param __lhs A string. + * @param __rhs A regular expression submatch. + * @returns true if @a __lhs is not equivalent to @a __rhs, false otherwise. + */ + template + inline bool + operator!=(typename iterator_traits<_Bi_iter>::value_type const& __lhs, + const sub_match<_Bi_iter>& __rhs) + { return !(__lhs == __rhs); } + + /** + * @brief Tests the ordering of a string and a regular expression submatch. + * @param __lhs A string. + * @param __rhs A regular expression submatch. + * @returns true if @a __lhs precedes @a __rhs, false otherwise. + */ + template + inline bool + operator<(typename iterator_traits<_Bi_iter>::value_type const& __lhs, + const sub_match<_Bi_iter>& __rhs) + { + typedef typename sub_match<_Bi_iter>::string_type string_type; + return __rhs.compare(string_type(1, __lhs)) > 0; + } + + /** + * @brief Tests the ordering of a string and a regular expression submatch. + * @param __lhs A string. + * @param __rhs A regular expression submatch. + * @returns true if @a __lhs succeeds @a __rhs, false otherwise. + */ + template + inline bool + operator>(typename iterator_traits<_Bi_iter>::value_type const& __lhs, + const sub_match<_Bi_iter>& __rhs) + { return __rhs < __lhs; } + + /** + * @brief Tests the ordering of a string and a regular expression submatch. + * @param __lhs A string. + * @param __rhs A regular expression submatch. + * @returns true if @a __lhs does not precede @a __rhs, false otherwise. + */ + template + inline bool + operator>=(typename iterator_traits<_Bi_iter>::value_type const& __lhs, + const sub_match<_Bi_iter>& __rhs) + { return !(__lhs < __rhs); } + + /** + * @brief Tests the ordering of a string and a regular expression submatch. + * @param __lhs A string. + * @param __rhs A regular expression submatch. + * @returns true if @a __lhs does not succeed @a __rhs, false otherwise. + */ + template + inline bool + operator<=(typename iterator_traits<_Bi_iter>::value_type const& __lhs, + const sub_match<_Bi_iter>& __rhs) + { return !(__rhs < __lhs); } + + /** + * @brief Tests the equivalence of a regular expression submatch and a + * string. + * @param __lhs A regular expression submatch. + * @param __rhs A const string reference. + * @returns true if @a __lhs is equivalent to @a __rhs, false otherwise. + */ + template + inline bool + operator==(const sub_match<_Bi_iter>& __lhs, + typename iterator_traits<_Bi_iter>::value_type const& __rhs) + { + typedef typename sub_match<_Bi_iter>::string_type string_type; + return __lhs.compare(string_type(1, __rhs)) == 0; + } + + /** + * @brief Tests the inequivalence of a regular expression submatch and a + * string. + * @param __lhs A regular expression submatch. + * @param __rhs A const string reference. + * @returns true if @a __lhs is not equivalent to @a __rhs, false otherwise. + */ + template + inline bool + operator!=(const sub_match<_Bi_iter>& __lhs, + typename iterator_traits<_Bi_iter>::value_type const& __rhs) + { return !(__lhs == __rhs); } + + /** + * @brief Tests the ordering of a regular expression submatch and a string. + * @param __lhs A regular expression submatch. + * @param __rhs A const string reference. + * @returns true if @a __lhs precedes @a __rhs, false otherwise. + */ + template + inline bool + operator<(const sub_match<_Bi_iter>& __lhs, + typename iterator_traits<_Bi_iter>::value_type const& __rhs) + { + typedef typename sub_match<_Bi_iter>::string_type string_type; + return __lhs.compare(string_type(1, __rhs)) < 0; + } + + /** + * @brief Tests the ordering of a regular expression submatch and a string. + * @param __lhs A regular expression submatch. + * @param __rhs A const string reference. + * @returns true if @a __lhs succeeds @a __rhs, false otherwise. + */ + template + inline bool + operator>(const sub_match<_Bi_iter>& __lhs, + typename iterator_traits<_Bi_iter>::value_type const& __rhs) + { return __rhs < __lhs; } + + /** + * @brief Tests the ordering of a regular expression submatch and a string. + * @param __lhs A regular expression submatch. + * @param __rhs A const string reference. + * @returns true if @a __lhs does not precede @a __rhs, false otherwise. + */ + template + inline bool + operator>=(const sub_match<_Bi_iter>& __lhs, + typename iterator_traits<_Bi_iter>::value_type const& __rhs) + { return !(__lhs < __rhs); } + + /** + * @brief Tests the ordering of a regular expression submatch and a string. + * @param __lhs A regular expression submatch. + * @param __rhs A const string reference. + * @returns true if @a __lhs does not succeed @a __rhs, false otherwise. + */ + template + inline bool + operator<=(const sub_match<_Bi_iter>& __lhs, + typename iterator_traits<_Bi_iter>::value_type const& __rhs) + { return !(__rhs < __lhs); } + + /** + * @brief Inserts a matched string into an output stream. + * + * @param __os The output stream. + * @param __m A submatch string. + * + * @returns the output stream with the submatch string inserted. + */ + template + inline + basic_ostream<_Ch_type, _Ch_traits>& + operator<<(basic_ostream<_Ch_type, _Ch_traits>& __os, + const sub_match<_Bi_iter>& __m) + { return __os << __m.str(); } + + // [7.10] Class template match_results + + /* + * Special sub_match object representing an unmatched sub-expression. + */ + template + inline const sub_match<_Bi_iter>& + __unmatched_sub() + { + static const sub_match<_Bi_iter> __unmatched = sub_match<_Bi_iter>(); + return __unmatched; + } + + /** + * @brief The results of a match or search operation. + * + * A collection of character sequences representing the result of a regular + * expression match. Storage for the collection is allocated and freed as + * necessary by the member functions of class template match_results. + * + * This class satisfies the Sequence requirements, with the exception that + * only the operations defined for a const-qualified Sequence are supported. + * + * The sub_match object stored at index 0 represents sub-expression 0, i.e. + * the whole match. In this case the %sub_match member matched is always true. + * The sub_match object stored at index n denotes what matched the marked + * sub-expression n within the matched expression. If the sub-expression n + * participated in a regular expression match then the %sub_match member + * matched evaluates to true, and members first and second denote the range + * of characters [first, second) which formed that match. Otherwise matched + * is false, and members first and second point to the end of the sequence + * that was searched. + * + * @nosubgrouping + */ + template > > + class match_results + : private std::vector, _Alloc> + { + private: + /* + * The vector base is empty if this does not represent a successful match. + * Otherwise it contains n+3 elements where n is the number of marked + * sub-expressions: + * [0] entire match + * [1] 1st marked subexpression + * ... + * [n] nth marked subexpression + * [n+1] prefix + * [n+2] suffix + */ + typedef std::vector, _Alloc> _Base_type; + typedef std::iterator_traits<_Bi_iter> __iter_traits; + typedef regex_constants::match_flag_type match_flag_type; + + public: + /** + * @name 10.? Public Types + */ + //@{ + typedef sub_match<_Bi_iter> value_type; + typedef const value_type& const_reference; + typedef const_reference reference; + typedef typename _Base_type::const_iterator const_iterator; + typedef const_iterator iterator; + typedef typename __iter_traits::difference_type difference_type; + typedef typename allocator_traits<_Alloc>::size_type size_type; + typedef _Alloc allocator_type; + typedef typename __iter_traits::value_type char_type; + typedef std::basic_string string_type; + //@} + + public: + /** + * @name 28.10.1 Construction, Copying, and Destruction + */ + //@{ + + /** + * @brief Constructs a default %match_results container. + * @post size() returns 0 and str() returns an empty string. + */ + explicit + match_results(const _Alloc& __a = _Alloc()) + : _Base_type(__a) + { } + + /** + * @brief Copy constructs a %match_results. + */ + match_results(const match_results& __rhs) = default; + + /** + * @brief Move constructs a %match_results. + */ + match_results(match_results&& __rhs) noexcept = default; + + /** + * @brief Assigns rhs to *this. + */ + match_results& + operator=(const match_results& __rhs) = default; + + /** + * @brief Move-assigns rhs to *this. + */ + match_results& + operator=(match_results&& __rhs) = default; + + /** + * @brief Destroys a %match_results object. + */ + ~match_results() + { } + + //@} + + // 28.10.2, state: + /** + * @brief Indicates if the %match_results is ready. + * @retval true The object has a fully-established result state. + * @retval false The object is not ready. + */ + bool ready() const { return !_Base_type::empty(); } + + /** + * @name 28.10.2 Size + */ + //@{ + + /** + * @brief Gets the number of matches and submatches. + * + * The number of matches for a given regular expression will be either 0 + * if there was no match or mark_count() + 1 if a match was successful. + * Some matches may be empty. + * + * @returns the number of matches found. + */ + size_type + size() const + { + size_type __size = _Base_type::size(); + return (__size && _Base_type::operator[](0).matched) ? __size - 2 : 0; + } + + size_type + max_size() const + { return _Base_type::max_size(); } + + /** + * @brief Indicates if the %match_results contains no results. + * @retval true The %match_results object is empty. + * @retval false The %match_results object is not empty. + */ + bool + empty() const + { return size() == 0; } + + //@} + + /** + * @name 10.3 Element Access + */ + //@{ + + /** + * @brief Gets the length of the indicated submatch. + * @param __sub indicates the submatch. + * @pre ready() == true + * + * This function returns the length of the indicated submatch, or the + * length of the entire match if @p __sub is zero (the default). + */ + difference_type + length(size_type __sub = 0) const + { return (*this)[__sub].length(); } + + /** + * @brief Gets the offset of the beginning of the indicated submatch. + * @param __sub indicates the submatch. + * @pre ready() == true + * + * This function returns the offset from the beginning of the target + * sequence to the beginning of the submatch, unless the value of @p __sub + * is zero (the default), in which case this function returns the offset + * from the beginning of the target sequence to the beginning of the + * match. + * + * Returns -1 if @p __sub is out of range. + */ + difference_type + position(size_type __sub = 0) const + { + return __sub < size() ? std::distance(_M_begin, + (*this)[__sub].first) : -1; + } + + /** + * @brief Gets the match or submatch converted to a string type. + * @param __sub indicates the submatch. + * @pre ready() == true + * + * This function gets the submatch (or match, if @p __sub is + * zero) extracted from the target range and converted to the + * associated string type. + */ + string_type + str(size_type __sub = 0) const + { return (*this)[__sub].str(); } + + /** + * @brief Gets a %sub_match reference for the match or submatch. + * @param __sub indicates the submatch. + * @pre ready() == true + * + * This function gets a reference to the indicated submatch, or + * the entire match if @p __sub is zero. + * + * If @p __sub >= size() then this function returns a %sub_match with a + * special value indicating no submatch. + */ + const_reference + operator[](size_type __sub) const + { + _GLIBCXX_DEBUG_ASSERT( ready() ); + return __sub < size() + ? _Base_type::operator[](__sub) + : __unmatched_sub<_Bi_iter>(); + } + + /** + * @brief Gets a %sub_match representing the match prefix. + * @pre ready() == true + * + * This function gets a reference to a %sub_match object representing the + * part of the target range between the start of the target range and the + * start of the match. + */ + const_reference + prefix() const + { + _GLIBCXX_DEBUG_ASSERT( ready() ); + return !empty() + ? _Base_type::operator[](_Base_type::size() - 2) + : __unmatched_sub<_Bi_iter>(); + } + + /** + * @brief Gets a %sub_match representing the match suffix. + * @pre ready() == true + * + * This function gets a reference to a %sub_match object representing the + * part of the target range between the end of the match and the end of + * the target range. + */ + const_reference + suffix() const + { + _GLIBCXX_DEBUG_ASSERT( ready() ); + return !empty() + ? _Base_type::operator[](_Base_type::size() - 1) + : __unmatched_sub<_Bi_iter>(); + } + + /** + * @brief Gets an iterator to the start of the %sub_match collection. + */ + const_iterator + begin() const + { return _Base_type::begin(); } + + /** + * @brief Gets an iterator to the start of the %sub_match collection. + */ + const_iterator + cbegin() const + { return this->begin(); } + + /** + * @brief Gets an iterator to one-past-the-end of the collection. + */ + const_iterator + end() const + { return _Base_type::end() - 2; } + + /** + * @brief Gets an iterator to one-past-the-end of the collection. + */ + const_iterator + cend() const + { return this->end(); } + + //@} + + /** + * @name 10.4 Formatting + * + * These functions perform formatted substitution of the matched + * character sequences into their target. The format specifiers and + * escape sequences accepted by these functions are determined by + * their @p flags parameter as documented above. + */ + //@{ + + /** + * @pre ready() == true + */ + template + _Out_iter + format(_Out_iter __out, const char_type* __fmt_first, + const char_type* __fmt_last, + match_flag_type __flags = regex_constants::format_default) const; + + /** + * @pre ready() == true + */ + template + _Out_iter + format(_Out_iter __out, const basic_string& __fmt, + match_flag_type __flags = regex_constants::format_default) const + { + return format(__out, __fmt.data(), __fmt.data() + __fmt.size(), + __flags); + } + + /** + * @pre ready() == true + */ + template + basic_string + format(const basic_string& __fmt, + match_flag_type __flags = regex_constants::format_default) const + { + basic_string __result; + format(std::back_inserter(__result), __fmt, __flags); + return __result; + } + + /** + * @pre ready() == true + */ + string_type + format(const char_type* __fmt, + match_flag_type __flags = regex_constants::format_default) const + { + string_type __result; + format(std::back_inserter(__result), + __fmt, + __fmt + char_traits::length(__fmt), + __flags); + return __result; + } + + //@} + + /** + * @name 10.5 Allocator + */ + //@{ + + /** + * @brief Gets a copy of the allocator. + */ + allocator_type + get_allocator() const + { return _Base_type::get_allocator(); } + + //@} + + /** + * @name 10.6 Swap + */ + //@{ + + /** + * @brief Swaps the contents of two match_results. + */ + void + swap(match_results& __that) + { + using std::swap; + _Base_type::swap(__that); + swap(_M_begin, __that._M_begin); + } + //@} + + private: + template + friend class __detail::_Executor; + + template + friend class regex_iterator; + + template + friend bool + __detail::__regex_algo_impl(_Bp, _Bp, match_results<_Bp, _Ap>&, + const basic_regex<_Cp, _Rp>&, + regex_constants::match_flag_type); + + _Bi_iter _M_begin; + bool _M_in_iterator; + }; + + typedef match_results cmatch; + typedef match_results smatch; +#ifdef _GLIBCXX_USE_WCHAR_T + typedef match_results wcmatch; + typedef match_results wsmatch; +#endif + + // match_results comparisons + /** + * @brief Compares two match_results for equality. + * @returns true if the two objects refer to the same match, + * false otherwise. + */ + template + inline bool + operator==(const match_results<_Bi_iter, _Alloc>& __m1, + const match_results<_Bi_iter, _Alloc>& __m2) + { + if (__m1.ready() != __m2.ready()) + return false; + if (!__m1.ready()) // both are not ready + return true; + if (__m1.empty() != __m2.empty()) + return false; + if (__m1.empty()) // both are empty + return true; + return __m1.prefix() == __m2.prefix() + && __m1.size() == __m2.size() + && std::equal(__m1.begin(), __m1.end(), __m2.begin()) + && __m1.suffix() == __m2.suffix(); + } + + /** + * @brief Compares two match_results for inequality. + * @returns true if the two objects do not refer to the same match, + * false otherwise. + */ + template + inline bool + operator!=(const match_results<_Bi_iter, _Alloc>& __m1, + const match_results<_Bi_iter, _Alloc>& __m2) + { return !(__m1 == __m2); } + + // [7.10.6] match_results swap + /** + * @brief Swaps two match results. + * @param __lhs A match result. + * @param __rhs A match result. + * + * The contents of the two match_results objects are swapped. + */ + template + inline void + swap(match_results<_Bi_iter, _Alloc>& __lhs, + match_results<_Bi_iter, _Alloc>& __rhs) + { __lhs.swap(__rhs); } + + // [7.11.2] Function template regex_match + /** + * @name Matching, Searching, and Replacing + */ + //@{ + + /** + * @brief Determines if there is a match between the regular expression @p e + * and all of the character sequence [first, last). + * + * @param __s Start of the character sequence to match. + * @param __e One-past-the-end of the character sequence to match. + * @param __m The match results. + * @param __re The regular expression. + * @param __flags Controls how the regular expression is matched. + * + * @retval true A match exists. + * @retval false Otherwise. + * + * @throws an exception of type regex_error. + */ + template + inline bool + regex_match(_Bi_iter __s, + _Bi_iter __e, + match_results<_Bi_iter, _Alloc>& __m, + const basic_regex<_Ch_type, _Rx_traits>& __re, + regex_constants::match_flag_type __flags + = regex_constants::match_default) + { + return __detail::__regex_algo_impl<_Bi_iter, _Alloc, _Ch_type, _Rx_traits, + __detail::_RegexExecutorPolicy::_S_auto, true> + (__s, __e, __m, __re, __flags); + } + + /** + * @brief Indicates if there is a match between the regular expression @p e + * and all of the character sequence [first, last). + * + * @param __first Beginning of the character sequence to match. + * @param __last One-past-the-end of the character sequence to match. + * @param __re The regular expression. + * @param __flags Controls how the regular expression is matched. + * + * @retval true A match exists. + * @retval false Otherwise. + * + * @throws an exception of type regex_error. + */ + template + inline bool + regex_match(_Bi_iter __first, _Bi_iter __last, + const basic_regex<_Ch_type, _Rx_traits>& __re, + regex_constants::match_flag_type __flags + = regex_constants::match_default) + { + match_results<_Bi_iter> __what; + return regex_match(__first, __last, __what, __re, __flags); + } + + /** + * @brief Determines if there is a match between the regular expression @p e + * and a C-style null-terminated string. + * + * @param __s The C-style null-terminated string to match. + * @param __m The match results. + * @param __re The regular expression. + * @param __f Controls how the regular expression is matched. + * + * @retval true A match exists. + * @retval false Otherwise. + * + * @throws an exception of type regex_error. + */ + template + inline bool + regex_match(const _Ch_type* __s, + match_results& __m, + const basic_regex<_Ch_type, _Rx_traits>& __re, + regex_constants::match_flag_type __f + = regex_constants::match_default) + { return regex_match(__s, __s + _Rx_traits::length(__s), __m, __re, __f); } + + /** + * @brief Determines if there is a match between the regular expression @p e + * and a string. + * + * @param __s The string to match. + * @param __m The match results. + * @param __re The regular expression. + * @param __flags Controls how the regular expression is matched. + * + * @retval true A match exists. + * @retval false Otherwise. + * + * @throws an exception of type regex_error. + */ + template + inline bool + regex_match(const basic_string<_Ch_type, _Ch_traits, _Ch_alloc>& __s, + match_results::const_iterator, _Alloc>& __m, + const basic_regex<_Ch_type, _Rx_traits>& __re, + regex_constants::match_flag_type __flags + = regex_constants::match_default) + { return regex_match(__s.begin(), __s.end(), __m, __re, __flags); } + + /** + * @brief Indicates if there is a match between the regular expression @p e + * and a C-style null-terminated string. + * + * @param __s The C-style null-terminated string to match. + * @param __re The regular expression. + * @param __f Controls how the regular expression is matched. + * + * @retval true A match exists. + * @retval false Otherwise. + * + * @throws an exception of type regex_error. + */ + template + inline bool + regex_match(const _Ch_type* __s, + const basic_regex<_Ch_type, _Rx_traits>& __re, + regex_constants::match_flag_type __f + = regex_constants::match_default) + { return regex_match(__s, __s + _Rx_traits::length(__s), __re, __f); } + + /** + * @brief Indicates if there is a match between the regular expression @p e + * and a string. + * + * @param __s [IN] The string to match. + * @param __re [IN] The regular expression. + * @param __flags [IN] Controls how the regular expression is matched. + * + * @retval true A match exists. + * @retval false Otherwise. + * + * @throws an exception of type regex_error. + */ + template + inline bool + regex_match(const basic_string<_Ch_type, _Ch_traits, _Str_allocator>& __s, + const basic_regex<_Ch_type, _Rx_traits>& __re, + regex_constants::match_flag_type __flags + = regex_constants::match_default) + { return regex_match(__s.begin(), __s.end(), __re, __flags); } + + // [7.11.3] Function template regex_search + /** + * Searches for a regular expression within a range. + * @param __s [IN] The start of the string to search. + * @param __e [IN] One-past-the-end of the string to search. + * @param __m [OUT] The match results. + * @param __re [IN] The regular expression to search for. + * @param __flags [IN] Search policy flags. + * @retval true A match was found within the string. + * @retval false No match was found within the string, the content of %m is + * undefined. + * + * @throws an exception of type regex_error. + */ + template + inline bool + regex_search(_Bi_iter __s, _Bi_iter __e, + match_results<_Bi_iter, _Alloc>& __m, + const basic_regex<_Ch_type, _Rx_traits>& __re, + regex_constants::match_flag_type __flags + = regex_constants::match_default) + { + return __detail::__regex_algo_impl<_Bi_iter, _Alloc, _Ch_type, _Rx_traits, + __detail::_RegexExecutorPolicy::_S_auto, false> + (__s, __e, __m, __re, __flags); + } + + /** + * Searches for a regular expression within a range. + * @param __first [IN] The start of the string to search. + * @param __last [IN] One-past-the-end of the string to search. + * @param __re [IN] The regular expression to search for. + * @param __flags [IN] Search policy flags. + * @retval true A match was found within the string. + * @retval false No match was found within the string. + * + * @throws an exception of type regex_error. + */ + template + inline bool + regex_search(_Bi_iter __first, _Bi_iter __last, + const basic_regex<_Ch_type, _Rx_traits>& __re, + regex_constants::match_flag_type __flags + = regex_constants::match_default) + { + match_results<_Bi_iter> __what; + return regex_search(__first, __last, __what, __re, __flags); + } + + /** + * @brief Searches for a regular expression within a C-string. + * @param __s [IN] A C-string to search for the regex. + * @param __m [OUT] The set of regex matches. + * @param __e [IN] The regex to search for in @p s. + * @param __f [IN] The search flags. + * @retval true A match was found within the string. + * @retval false No match was found within the string, the content of %m is + * undefined. + * + * @throws an exception of type regex_error. + */ + template + inline bool + regex_search(const _Ch_type* __s, + match_results& __m, + const basic_regex<_Ch_type, _Rx_traits>& __e, + regex_constants::match_flag_type __f + = regex_constants::match_default) + { return regex_search(__s, __s + _Rx_traits::length(__s), __m, __e, __f); } + + /** + * @brief Searches for a regular expression within a C-string. + * @param __s [IN] The C-string to search. + * @param __e [IN] The regular expression to search for. + * @param __f [IN] Search policy flags. + * @retval true A match was found within the string. + * @retval false No match was found within the string. + * + * @throws an exception of type regex_error. + */ + template + inline bool + regex_search(const _Ch_type* __s, + const basic_regex<_Ch_type, _Rx_traits>& __e, + regex_constants::match_flag_type __f + = regex_constants::match_default) + { return regex_search(__s, __s + _Rx_traits::length(__s), __e, __f); } + + /** + * @brief Searches for a regular expression within a string. + * @param __s [IN] The string to search. + * @param __e [IN] The regular expression to search for. + * @param __flags [IN] Search policy flags. + * @retval true A match was found within the string. + * @retval false No match was found within the string. + * + * @throws an exception of type regex_error. + */ + template + inline bool + regex_search(const basic_string<_Ch_type, _Ch_traits, + _String_allocator>& __s, + const basic_regex<_Ch_type, _Rx_traits>& __e, + regex_constants::match_flag_type __flags + = regex_constants::match_default) + { return regex_search(__s.begin(), __s.end(), __e, __flags); } + + /** + * @brief Searches for a regular expression within a string. + * @param __s [IN] A C++ string to search for the regex. + * @param __m [OUT] The set of regex matches. + * @param __e [IN] The regex to search for in @p s. + * @param __f [IN] The search flags. + * @retval true A match was found within the string. + * @retval false No match was found within the string, the content of %m is + * undefined. + * + * @throws an exception of type regex_error. + */ + template + inline bool + regex_search(const basic_string<_Ch_type, _Ch_traits, _Ch_alloc>& __s, + match_results::const_iterator, _Alloc>& __m, + const basic_regex<_Ch_type, _Rx_traits>& __e, + regex_constants::match_flag_type __f + = regex_constants::match_default) + { return regex_search(__s.begin(), __s.end(), __m, __e, __f); } + + // std [28.11.4] Function template regex_replace + /** + * @brief Search for a regular expression within a range for multiple times, + and replace the matched parts through filling a format string. + * @param __out [OUT] The output iterator. + * @param __first [IN] The start of the string to search. + * @param __last [IN] One-past-the-end of the string to search. + * @param __e [IN] The regular expression to search for. + * @param __fmt [IN] The format string. + * @param __flags [IN] Search and replace policy flags. + * + * @returns __out + * @throws an exception of type regex_error. + */ + template + inline _Out_iter + regex_replace(_Out_iter __out, _Bi_iter __first, _Bi_iter __last, + const basic_regex<_Ch_type, _Rx_traits>& __e, + const basic_string<_Ch_type, _St, _Sa>& __fmt, + regex_constants::match_flag_type __flags + = regex_constants::match_default) + { + return regex_replace(__out, __first, __last, __e, __fmt.c_str(), __flags); + } + + /** + * @brief Search for a regular expression within a range for multiple times, + and replace the matched parts through filling a format C-string. + * @param __out [OUT] The output iterator. + * @param __first [IN] The start of the string to search. + * @param __last [IN] One-past-the-end of the string to search. + * @param __e [IN] The regular expression to search for. + * @param __fmt [IN] The format C-string. + * @param __flags [IN] Search and replace policy flags. + * + * @returns __out + * @throws an exception of type regex_error. + */ + template + _Out_iter + regex_replace(_Out_iter __out, _Bi_iter __first, _Bi_iter __last, + const basic_regex<_Ch_type, _Rx_traits>& __e, + const _Ch_type* __fmt, + regex_constants::match_flag_type __flags + = regex_constants::match_default); + + /** + * @brief Search for a regular expression within a string for multiple times, + and replace the matched parts through filling a format string. + * @param __s [IN] The string to search and replace. + * @param __e [IN] The regular expression to search for. + * @param __fmt [IN] The format string. + * @param __flags [IN] Search and replace policy flags. + * + * @returns The string after replacing. + * @throws an exception of type regex_error. + */ + template + inline basic_string<_Ch_type, _St, _Sa> + regex_replace(const basic_string<_Ch_type, _St, _Sa>& __s, + const basic_regex<_Ch_type, _Rx_traits>& __e, + const basic_string<_Ch_type, _Fst, _Fsa>& __fmt, + regex_constants::match_flag_type __flags + = regex_constants::match_default) + { + basic_string<_Ch_type, _St, _Sa> __result; + regex_replace(std::back_inserter(__result), + __s.begin(), __s.end(), __e, __fmt, __flags); + return __result; + } + + /** + * @brief Search for a regular expression within a string for multiple times, + and replace the matched parts through filling a format C-string. + * @param __s [IN] The string to search and replace. + * @param __e [IN] The regular expression to search for. + * @param __fmt [IN] The format C-string. + * @param __flags [IN] Search and replace policy flags. + * + * @returns The string after replacing. + * @throws an exception of type regex_error. + */ + template + inline basic_string<_Ch_type, _St, _Sa> + regex_replace(const basic_string<_Ch_type, _St, _Sa>& __s, + const basic_regex<_Ch_type, _Rx_traits>& __e, + const _Ch_type* __fmt, + regex_constants::match_flag_type __flags + = regex_constants::match_default) + { + basic_string<_Ch_type, _St, _Sa> __result; + regex_replace(std::back_inserter(__result), + __s.begin(), __s.end(), __e, __fmt, __flags); + return __result; + } + + /** + * @brief Search for a regular expression within a C-string for multiple + times, and replace the matched parts through filling a format string. + * @param __s [IN] The C-string to search and replace. + * @param __e [IN] The regular expression to search for. + * @param __fmt [IN] The format string. + * @param __flags [IN] Search and replace policy flags. + * + * @returns The string after replacing. + * @throws an exception of type regex_error. + */ + template + inline basic_string<_Ch_type> + regex_replace(const _Ch_type* __s, + const basic_regex<_Ch_type, _Rx_traits>& __e, + const basic_string<_Ch_type, _St, _Sa>& __fmt, + regex_constants::match_flag_type __flags + = regex_constants::match_default) + { + basic_string<_Ch_type> __result; + regex_replace(std::back_inserter(__result), __s, + __s + char_traits<_Ch_type>::length(__s), + __e, __fmt, __flags); + return __result; + } + + /** + * @brief Search for a regular expression within a C-string for multiple + times, and replace the matched parts through filling a format C-string. + * @param __s [IN] The C-string to search and replace. + * @param __e [IN] The regular expression to search for. + * @param __fmt [IN] The format C-string. + * @param __flags [IN] Search and replace policy flags. + * + * @returns The string after replacing. + * @throws an exception of type regex_error. + */ + template + inline basic_string<_Ch_type> + regex_replace(const _Ch_type* __s, + const basic_regex<_Ch_type, _Rx_traits>& __e, + const _Ch_type* __fmt, + regex_constants::match_flag_type __flags + = regex_constants::match_default) + { + basic_string<_Ch_type> __result; + regex_replace(std::back_inserter(__result), __s, + __s + char_traits<_Ch_type>::length(__s), + __e, __fmt, __flags); + return __result; + } + + //@} + + // std [28.12] Class template regex_iterator + /** + * An iterator adaptor that will provide repeated calls of regex_search over + * a range until no more matches remain. + */ + template::value_type, + typename _Rx_traits = regex_traits<_Ch_type> > + class regex_iterator + { + public: + typedef basic_regex<_Ch_type, _Rx_traits> regex_type; + typedef match_results<_Bi_iter> value_type; + typedef std::ptrdiff_t difference_type; + typedef const value_type* pointer; + typedef const value_type& reference; + typedef std::forward_iterator_tag iterator_category; + + /** + * @brief Provides a singular iterator, useful for indicating + * one-past-the-end of a range. + */ + regex_iterator() + : _M_match() + { } + + /** + * Constructs a %regex_iterator... + * @param __a [IN] The start of a text range to search. + * @param __b [IN] One-past-the-end of the text range to search. + * @param __re [IN] The regular expression to match. + * @param __m [IN] Policy flags for match rules. + */ + regex_iterator(_Bi_iter __a, _Bi_iter __b, const regex_type& __re, + regex_constants::match_flag_type __m + = regex_constants::match_default) + : _M_begin(__a), _M_end(__b), _M_pregex(&__re), _M_flags(__m), _M_match() + { + if (!regex_search(_M_begin, _M_end, _M_match, *_M_pregex, _M_flags)) + *this = regex_iterator(); + } + + /** + * Copy constructs a %regex_iterator. + */ + regex_iterator(const regex_iterator& __rhs) = default; + + /** + * @brief Assigns one %regex_iterator to another. + */ + regex_iterator& + operator=(const regex_iterator& __rhs) = default; + + /** + * @brief Tests the equivalence of two regex iterators. + */ + bool + operator==(const regex_iterator& __rhs) const; + + /** + * @brief Tests the inequivalence of two regex iterators. + */ + bool + operator!=(const regex_iterator& __rhs) const + { return !(*this == __rhs); } + + /** + * @brief Dereferences a %regex_iterator. + */ + const value_type& + operator*() const + { return _M_match; } + + /** + * @brief Selects a %regex_iterator member. + */ + const value_type* + operator->() const + { return &_M_match; } + + /** + * @brief Increments a %regex_iterator. + */ + regex_iterator& + operator++(); + + /** + * @brief Postincrements a %regex_iterator. + */ + regex_iterator + operator++(int) + { + auto __tmp = *this; + ++(*this); + return __tmp; + } + + private: + _Bi_iter _M_begin; + _Bi_iter _M_end; + const regex_type* _M_pregex; + regex_constants::match_flag_type _M_flags; + match_results<_Bi_iter> _M_match; + }; + + typedef regex_iterator cregex_iterator; + typedef regex_iterator sregex_iterator; +#ifdef _GLIBCXX_USE_WCHAR_T + typedef regex_iterator wcregex_iterator; + typedef regex_iterator wsregex_iterator; +#endif + + // [7.12.2] Class template regex_token_iterator + /** + * Iterates over submatches in a range (or @a splits a text string). + * + * The purpose of this iterator is to enumerate all, or all specified, + * matches of a regular expression within a text range. The dereferenced + * value of an iterator of this class is a std::sub_match object. + */ + template::value_type, + typename _Rx_traits = regex_traits<_Ch_type> > + class regex_token_iterator + { + public: + typedef basic_regex<_Ch_type, _Rx_traits> regex_type; + typedef sub_match<_Bi_iter> value_type; + typedef std::ptrdiff_t difference_type; + typedef const value_type* pointer; + typedef const value_type& reference; + typedef std::forward_iterator_tag iterator_category; + + public: + /** + * @brief Default constructs a %regex_token_iterator. + * + * A default-constructed %regex_token_iterator is a singular iterator + * that will compare equal to the one-past-the-end value for any + * iterator of the same type. + */ + regex_token_iterator() + : _M_position(), _M_subs(), _M_suffix(), _M_n(0), _M_result(nullptr), + _M_has_m1(false) + { } + + /** + * Constructs a %regex_token_iterator... + * @param __a [IN] The start of the text to search. + * @param __b [IN] One-past-the-end of the text to search. + * @param __re [IN] The regular expression to search for. + * @param __submatch [IN] Which submatch to return. There are some + * special values for this parameter: + * - -1 each enumerated subexpression does NOT + * match the regular expression (aka field + * splitting) + * - 0 the entire string matching the + * subexpression is returned for each match + * within the text. + * - >0 enumerates only the indicated + * subexpression from a match within the text. + * @param __m [IN] Policy flags for match rules. + */ + regex_token_iterator(_Bi_iter __a, _Bi_iter __b, const regex_type& __re, + int __submatch = 0, + regex_constants::match_flag_type __m + = regex_constants::match_default) + : _M_position(__a, __b, __re, __m), _M_subs(1, __submatch), _M_n(0) + { _M_init(__a, __b); } + + /** + * Constructs a %regex_token_iterator... + * @param __a [IN] The start of the text to search. + * @param __b [IN] One-past-the-end of the text to search. + * @param __re [IN] The regular expression to search for. + * @param __submatches [IN] A list of subexpressions to return for each + * regular expression match within the text. + * @param __m [IN] Policy flags for match rules. + */ + regex_token_iterator(_Bi_iter __a, _Bi_iter __b, + const regex_type& __re, + const std::vector& __submatches, + regex_constants::match_flag_type __m + = regex_constants::match_default) + : _M_position(__a, __b, __re, __m), _M_subs(__submatches), _M_n(0) + { _M_init(__a, __b); } + + /** + * Constructs a %regex_token_iterator... + * @param __a [IN] The start of the text to search. + * @param __b [IN] One-past-the-end of the text to search. + * @param __re [IN] The regular expression to search for. + * @param __submatches [IN] A list of subexpressions to return for each + * regular expression match within the text. + * @param __m [IN] Policy flags for match rules. + */ + regex_token_iterator(_Bi_iter __a, _Bi_iter __b, + const regex_type& __re, + initializer_list __submatches, + regex_constants::match_flag_type __m + = regex_constants::match_default) + : _M_position(__a, __b, __re, __m), _M_subs(__submatches), _M_n(0) + { _M_init(__a, __b); } + + /** + * Constructs a %regex_token_iterator... + * @param __a [IN] The start of the text to search. + * @param __b [IN] One-past-the-end of the text to search. + * @param __re [IN] The regular expression to search for. + * @param __submatches [IN] A list of subexpressions to return for each + * regular expression match within the text. + * @param __m [IN] Policy flags for match rules. + */ + template + regex_token_iterator(_Bi_iter __a, _Bi_iter __b, + const regex_type& __re, + const int (&__submatches)[_Nm], + regex_constants::match_flag_type __m + = regex_constants::match_default) + : _M_position(__a, __b, __re, __m), + _M_subs(__submatches, __submatches + _Nm), _M_n(0) + { _M_init(__a, __b); } + + /** + * @brief Copy constructs a %regex_token_iterator. + * @param __rhs [IN] A %regex_token_iterator to copy. + */ + regex_token_iterator(const regex_token_iterator& __rhs) + : _M_position(__rhs._M_position), _M_subs(__rhs._M_subs), + _M_suffix(__rhs._M_suffix), _M_n(__rhs._M_n), _M_has_m1(__rhs._M_has_m1) + { _M_normalize_result(); } + + /** + * @brief Assigns a %regex_token_iterator to another. + * @param __rhs [IN] A %regex_token_iterator to copy. + */ + regex_token_iterator& + operator=(const regex_token_iterator& __rhs); + + /** + * @brief Compares a %regex_token_iterator to another for equality. + */ + bool + operator==(const regex_token_iterator& __rhs) const; + + /** + * @brief Compares a %regex_token_iterator to another for inequality. + */ + bool + operator!=(const regex_token_iterator& __rhs) const + { return !(*this == __rhs); } + + /** + * @brief Dereferences a %regex_token_iterator. + */ + const value_type& + operator*() const + { return *_M_result; } + + /** + * @brief Selects a %regex_token_iterator member. + */ + const value_type* + operator->() const + { return _M_result; } + + /** + * @brief Increments a %regex_token_iterator. + */ + regex_token_iterator& + operator++(); + + /** + * @brief Postincrements a %regex_token_iterator. + */ + regex_token_iterator + operator++(int) + { + auto __tmp = *this; + ++(*this); + return __tmp; + } + + private: + typedef regex_iterator<_Bi_iter, _Ch_type, _Rx_traits> _Position; + + void + _M_init(_Bi_iter __a, _Bi_iter __b); + + const value_type& + _M_current_match() const + { + if (_M_subs[_M_n] == -1) + return (*_M_position).prefix(); + else + return (*_M_position)[_M_subs[_M_n]]; + } + + constexpr bool + _M_end_of_seq() const + { return _M_result == nullptr; } + + // [28.12.2.2.4] + void + _M_normalize_result() + { + if (_M_position != _Position()) + _M_result = &_M_current_match(); + else if (_M_has_m1) + _M_result = &_M_suffix; + else + _M_result = nullptr; + } + + _Position _M_position; + std::vector _M_subs; + value_type _M_suffix; + std::size_t _M_n; + const value_type* _M_result; + + // Show whether _M_subs contains -1 + bool _M_has_m1; + }; + + /** @brief Token iterator for C-style NULL-terminated strings. */ + typedef regex_token_iterator cregex_token_iterator; + + /** @brief Token iterator for standard strings. */ + typedef regex_token_iterator sregex_token_iterator; + +#ifdef _GLIBCXX_USE_WCHAR_T + /** @brief Token iterator for C-style NULL-terminated wide strings. */ + typedef regex_token_iterator wcregex_token_iterator; + + /** @brief Token iterator for standard wide-character strings. */ + typedef regex_token_iterator wsregex_token_iterator; +#endif + + //@} // group regex +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#include diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/regex.tcc b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/regex.tcc new file mode 100755 index 0000000..792ed92 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/regex.tcc @@ -0,0 +1,673 @@ +// class template regex -*- C++ -*- + +// Copyright (C) 2013-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** + * @file bits/regex.tcc + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{regex} + */ + +// See below __regex_algo_impl to get what this is talking about. The default +// value 1 indicated a conservative optimization without giving up worst case +// performance. +#ifndef _GLIBCXX_REGEX_DFS_QUANTIFIERS_LIMIT +#define _GLIBCXX_REGEX_DFS_QUANTIFIERS_LIMIT 1 +#endif + +namespace std _GLIBCXX_VISIBILITY(default) +{ +namespace __detail +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + // Result of merging regex_match and regex_search. + // + // __policy now can be _S_auto (auto dispatch) and _S_alternate (use + // the other one if possible, for test purpose). + // + // That __match_mode is true means regex_match, else regex_search. + template + bool + __regex_algo_impl(_BiIter __s, + _BiIter __e, + match_results<_BiIter, _Alloc>& __m, + const basic_regex<_CharT, _TraitsT>& __re, + regex_constants::match_flag_type __flags) + { + if (__re._M_automaton == nullptr) + return false; + + typename match_results<_BiIter, _Alloc>::_Base_type& __res = __m; + __m._M_begin = __s; + __res.resize(__re._M_automaton->_M_sub_count() + 2); + for (auto& __it : __res) + __it.matched = false; + + // This function decide which executor to use under given circumstances. + // The _S_auto policy now is the following: if a NFA has no + // back-references and has more than _GLIBCXX_REGEX_DFS_QUANTIFIERS_LIMIT + // quantifiers (*, +, ?), the BFS executor will be used, other wise + // DFS executor. This is because DFS executor has a exponential upper + // bound, but better best-case performace. Meanwhile, BFS executor can + // effectively prevent from exponential-long time matching (which must + // contains many quantifiers), but it's slower in average. + // + // For simple regex, BFS executor could be 2 or more times slower than + // DFS executor. + // + // Of course, BFS executor cannot handle back-references. + bool __ret; + if (!__re._M_automaton->_M_has_backref + && (__policy == _RegexExecutorPolicy::_S_alternate + || __re._M_automaton->_M_quant_count + > _GLIBCXX_REGEX_DFS_QUANTIFIERS_LIMIT)) + { + _Executor<_BiIter, _Alloc, _TraitsT, false> + __executor(__s, __e, __m, __re, __flags); + if (__match_mode) + __ret = __executor._M_match(); + else + __ret = __executor._M_search(); + } + else + { + _Executor<_BiIter, _Alloc, _TraitsT, true> + __executor(__s, __e, __m, __re, __flags); + if (__match_mode) + __ret = __executor._M_match(); + else + __ret = __executor._M_search(); + } + if (__ret) + { + for (auto __it : __res) + if (!__it.matched) + __it.first = __it.second = __e; + auto& __pre = __res[__res.size()-2]; + auto& __suf = __res[__res.size()-1]; + if (__match_mode) + { + __pre.matched = false; + __pre.first = __s; + __pre.second = __s; + __suf.matched = false; + __suf.first = __e; + __suf.second = __e; + } + else + { + __pre.first = __s; + __pre.second = __res[0].first; + __pre.matched = (__pre.first != __pre.second); + __suf.first = __res[0].second; + __suf.second = __e; + __suf.matched = (__suf.first != __suf.second); + } + } + return __ret; + } + +_GLIBCXX_END_NAMESPACE_VERSION +} + +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + template + template + typename regex_traits<_Ch_type>::string_type + regex_traits<_Ch_type>:: + lookup_collatename(_Fwd_iter __first, _Fwd_iter __last) const + { + typedef std::ctype __ctype_type; + const __ctype_type& __fctyp(use_facet<__ctype_type>(_M_locale)); + + static const char* __collatenames[] = + { + "NUL", + "SOH", + "STX", + "ETX", + "EOT", + "ENQ", + "ACK", + "alert", + "backspace", + "tab", + "newline", + "vertical-tab", + "form-feed", + "carriage-return", + "SO", + "SI", + "DLE", + "DC1", + "DC2", + "DC3", + "DC4", + "NAK", + "SYN", + "ETB", + "CAN", + "EM", + "SUB", + "ESC", + "IS4", + "IS3", + "IS2", + "IS1", + "space", + "exclamation-mark", + "quotation-mark", + "number-sign", + "dollar-sign", + "percent-sign", + "ampersand", + "apostrophe", + "left-parenthesis", + "right-parenthesis", + "asterisk", + "plus-sign", + "comma", + "hyphen", + "period", + "slash", + "zero", + "one", + "two", + "three", + "four", + "five", + "six", + "seven", + "eight", + "nine", + "colon", + "semicolon", + "less-than-sign", + "equals-sign", + "greater-than-sign", + "question-mark", + "commercial-at", + "A", + "B", + "C", + "D", + "E", + "F", + "G", + "H", + "I", + "J", + "K", + "L", + "M", + "N", + "O", + "P", + "Q", + "R", + "S", + "T", + "U", + "V", + "W", + "X", + "Y", + "Z", + "left-square-bracket", + "backslash", + "right-square-bracket", + "circumflex", + "underscore", + "grave-accent", + "a", + "b", + "c", + "d", + "e", + "f", + "g", + "h", + "i", + "j", + "k", + "l", + "m", + "n", + "o", + "p", + "q", + "r", + "s", + "t", + "u", + "v", + "w", + "x", + "y", + "z", + "left-curly-bracket", + "vertical-line", + "right-curly-bracket", + "tilde", + "DEL", + }; + + string __s; + for (; __first != __last; ++__first) + __s += __fctyp.narrow(*__first, 0); + + for (const auto& __it : __collatenames) + if (__s == __it) + return string_type(1, __fctyp.widen( + static_cast(&__it - __collatenames))); + + // TODO Add digraph support: + // http://boost.sourceforge.net/libs/regex/doc/collating_names.html + + return string_type(); + } + + template + template + typename regex_traits<_Ch_type>::char_class_type + regex_traits<_Ch_type>:: + lookup_classname(_Fwd_iter __first, _Fwd_iter __last, bool __icase) const + { + typedef std::ctype __ctype_type; + const __ctype_type& __fctyp(use_facet<__ctype_type>(_M_locale)); + + // Mappings from class name to class mask. + static const pair __classnames[] = + { + {"d", ctype_base::digit}, + {"w", {ctype_base::alnum, _RegexMask::_S_under}}, + {"s", ctype_base::space}, + {"alnum", ctype_base::alnum}, + {"alpha", ctype_base::alpha}, + {"blank", {0, _RegexMask::_S_blank}}, + {"cntrl", ctype_base::cntrl}, + {"digit", ctype_base::digit}, + {"graph", ctype_base::graph}, + {"lower", ctype_base::lower}, + {"print", ctype_base::print}, + {"punct", ctype_base::punct}, + {"space", ctype_base::space}, + {"upper", ctype_base::upper}, + {"xdigit", ctype_base::xdigit}, + }; + + string __s; + for (; __first != __last; ++__first) + __s += __fctyp.narrow(__fctyp.tolower(*__first), 0); + + for (const auto& __it : __classnames) + if (__s == __it.first) + { + if (__icase + && ((__it.second + & (ctype_base::lower | ctype_base::upper)) != 0)) + return ctype_base::alpha; + return __it.second; + } + return 0; + } + + template + bool + regex_traits<_Ch_type>:: + isctype(_Ch_type __c, char_class_type __f) const + { + typedef std::ctype __ctype_type; + const __ctype_type& __fctyp(use_facet<__ctype_type>(_M_locale)); + + return __fctyp.is(__f._M_base, __c) + // [[:w:]] + || ((__f._M_extended & _RegexMask::_S_under) + && __c == __fctyp.widen('_')) + // [[:blank:]] + || ((__f._M_extended & _RegexMask::_S_blank) + && (__c == __fctyp.widen(' ') + || __c == __fctyp.widen('\t'))); + } + + template + int + regex_traits<_Ch_type>:: + value(_Ch_type __ch, int __radix) const + { + std::basic_istringstream __is(string_type(1, __ch)); + long __v; + if (__radix == 8) + __is >> std::oct; + else if (__radix == 16) + __is >> std::hex; + __is >> __v; + return __is.fail() ? -1 : __v; + } + + template + template + _Out_iter match_results<_Bi_iter, _Alloc>:: + format(_Out_iter __out, + const match_results<_Bi_iter, _Alloc>::char_type* __fmt_first, + const match_results<_Bi_iter, _Alloc>::char_type* __fmt_last, + match_flag_type __flags) const + { + _GLIBCXX_DEBUG_ASSERT( ready() ); + regex_traits __traits; + typedef std::ctype __ctype_type; + const __ctype_type& + __fctyp(use_facet<__ctype_type>(__traits.getloc())); + + auto __output = [&](size_t __idx) + { + auto& __sub = _Base_type::operator[](__idx); + if (__sub.matched) + __out = std::copy(__sub.first, __sub.second, __out); + }; + + if (__flags & regex_constants::format_sed) + { + for (; __fmt_first != __fmt_last;) + if (*__fmt_first == '&') + { + __output(0); + ++__fmt_first; + } + else if (*__fmt_first == '\\') + { + if (++__fmt_first != __fmt_last + && __fctyp.is(__ctype_type::digit, *__fmt_first)) + __output(__traits.value(*__fmt_first++, 10)); + else + *__out++ = '\\'; + } + else + *__out++ = *__fmt_first++; + } + else + { + while (1) + { + auto __next = std::find(__fmt_first, __fmt_last, '$'); + if (__next == __fmt_last) + break; + + __out = std::copy(__fmt_first, __next, __out); + + auto __eat = [&](char __ch) -> bool + { + if (*__next == __ch) + { + ++__next; + return true; + } + return false; + }; + + if (++__next == __fmt_last) + *__out++ = '$'; + else if (__eat('$')) + *__out++ = '$'; + else if (__eat('&')) + __output(0); + else if (__eat('`')) + __output(_Base_type::size()-2); + else if (__eat('\'')) + __output(_Base_type::size()-1); + else if (__fctyp.is(__ctype_type::digit, *__next)) + { + long __num = __traits.value(*__next, 10); + if (++__next != __fmt_last + && __fctyp.is(__ctype_type::digit, *__next)) + { + __num *= 10; + __num += __traits.value(*__next++, 10); + } + if (0 <= __num && __num < this->size()) + __output(__num); + } + else + *__out++ = '$'; + __fmt_first = __next; + } + __out = std::copy(__fmt_first, __fmt_last, __out); + } + return __out; + } + + template + _Out_iter + regex_replace(_Out_iter __out, _Bi_iter __first, _Bi_iter __last, + const basic_regex<_Ch_type, _Rx_traits>& __e, + const _Ch_type* __fmt, + regex_constants::match_flag_type __flags) + { + typedef regex_iterator<_Bi_iter, _Ch_type, _Rx_traits> _IterT; + _IterT __i(__first, __last, __e, __flags); + _IterT __end; + if (__i == __end) + { + if (!(__flags & regex_constants::format_no_copy)) + __out = std::copy(__first, __last, __out); + } + else + { + sub_match<_Bi_iter> __last; + auto __len = char_traits<_Ch_type>::length(__fmt); + for (; __i != __end; ++__i) + { + if (!(__flags & regex_constants::format_no_copy)) + __out = std::copy(__i->prefix().first, __i->prefix().second, + __out); + __out = __i->format(__out, __fmt, __fmt + __len, __flags); + __last = __i->suffix(); + if (__flags & regex_constants::format_first_only) + break; + } + if (!(__flags & regex_constants::format_no_copy)) + __out = std::copy(__last.first, __last.second, __out); + } + return __out; + } + + template + bool + regex_iterator<_Bi_iter, _Ch_type, _Rx_traits>:: + operator==(const regex_iterator& __rhs) const + { + return (_M_match.empty() && __rhs._M_match.empty()) + || (_M_begin == __rhs._M_begin + && _M_end == __rhs._M_end + && _M_pregex == __rhs._M_pregex + && _M_flags == __rhs._M_flags + && _M_match[0] == __rhs._M_match[0]); + } + + template + regex_iterator<_Bi_iter, _Ch_type, _Rx_traits>& + regex_iterator<_Bi_iter, _Ch_type, _Rx_traits>:: + operator++() + { + // In all cases in which the call to regex_search returns true, + // match.prefix().first shall be equal to the previous value of + // match[0].second, and for each index i in the half-open range + // [0, match.size()) for which match[i].matched is true, + // match[i].position() shall return distance(begin, match[i].first). + // [28.12.1.4.5] + if (_M_match[0].matched) + { + auto __start = _M_match[0].second; + auto __prefix_first = _M_match[0].second; + if (_M_match[0].first == _M_match[0].second) + { + if (__start == _M_end) + { + _M_match = value_type(); + return *this; + } + else + { + if (regex_search(__start, _M_end, _M_match, *_M_pregex, + _M_flags + | regex_constants::match_not_null + | regex_constants::match_continuous)) + { + _GLIBCXX_DEBUG_ASSERT(_M_match[0].matched); + auto& __prefix = _M_match.at(_M_match.size()); + __prefix.first = __prefix_first; + __prefix.matched = __prefix.first != __prefix.second; + // [28.12.1.4.5] + _M_match._M_begin = _M_begin; + return *this; + } + else + ++__start; + } + } + _M_flags |= regex_constants::match_prev_avail; + if (regex_search(__start, _M_end, _M_match, *_M_pregex, _M_flags)) + { + _GLIBCXX_DEBUG_ASSERT(_M_match[0].matched); + auto& __prefix = _M_match.at(_M_match.size()); + __prefix.first = __prefix_first; + __prefix.matched = __prefix.first != __prefix.second; + // [28.12.1.4.5] + _M_match._M_begin = _M_begin; + } + else + _M_match = value_type(); + } + return *this; + } + + template + regex_token_iterator<_Bi_iter, _Ch_type, _Rx_traits>& + regex_token_iterator<_Bi_iter, _Ch_type, _Rx_traits>:: + operator=(const regex_token_iterator& __rhs) + { + _M_position = __rhs._M_position; + _M_subs = __rhs._M_subs; + _M_n = __rhs._M_n; + _M_suffix = __rhs._M_suffix; + _M_has_m1 = __rhs._M_has_m1; + _M_normalize_result(); + return *this; + } + + template + bool + regex_token_iterator<_Bi_iter, _Ch_type, _Rx_traits>:: + operator==(const regex_token_iterator& __rhs) const + { + if (_M_end_of_seq() && __rhs._M_end_of_seq()) + return true; + if (_M_suffix.matched && __rhs._M_suffix.matched + && _M_suffix == __rhs._M_suffix) + return true; + if (_M_end_of_seq() || _M_suffix.matched + || __rhs._M_end_of_seq() || __rhs._M_suffix.matched) + return false; + return _M_position == __rhs._M_position + && _M_n == __rhs._M_n + && _M_subs == __rhs._M_subs; + } + + template + regex_token_iterator<_Bi_iter, _Ch_type, _Rx_traits>& + regex_token_iterator<_Bi_iter, _Ch_type, _Rx_traits>:: + operator++() + { + _Position __prev = _M_position; + if (_M_suffix.matched) + *this = regex_token_iterator(); + else if (_M_n + 1 < _M_subs.size()) + { + _M_n++; + _M_result = &_M_current_match(); + } + else + { + _M_n = 0; + ++_M_position; + if (_M_position != _Position()) + _M_result = &_M_current_match(); + else if (_M_has_m1 && __prev->suffix().length() != 0) + { + _M_suffix.matched = true; + _M_suffix.first = __prev->suffix().first; + _M_suffix.second = __prev->suffix().second; + _M_result = &_M_suffix; + } + else + *this = regex_token_iterator(); + } + return *this; + } + + template + void + regex_token_iterator<_Bi_iter, _Ch_type, _Rx_traits>:: + _M_init(_Bi_iter __a, _Bi_iter __b) + { + _M_has_m1 = false; + for (auto __it : _M_subs) + if (__it == -1) + { + _M_has_m1 = true; + break; + } + if (_M_position != _Position()) + _M_result = &_M_current_match(); + else if (_M_has_m1) + { + _M_suffix.matched = true; + _M_suffix.first = __a; + _M_suffix.second = __b; + _M_result = &_M_suffix; + } + else + _M_result = nullptr; + } + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/regex_automaton.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/regex_automaton.h new file mode 100755 index 0000000..a442cfe --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/regex_automaton.h @@ -0,0 +1,310 @@ +// class template regex -*- C++ -*- + +// Copyright (C) 2013-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** + * @file bits/regex_automaton.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{regex} + */ + +namespace std _GLIBCXX_VISIBILITY(default) +{ +namespace __detail +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /** + * @defgroup regex-detail Base and Implementation Classes + * @ingroup regex + * @{ + */ + + typedef long _StateIdT; + static const _StateIdT _S_invalid_state_id = -1; + + template + using _Matcher = std::function; + + /// Operation codes that define the type of transitions within the base NFA + /// that represents the regular expression. + enum _Opcode : int + { + _S_opcode_unknown, + _S_opcode_alternative, + _S_opcode_backref, + _S_opcode_line_begin_assertion, + _S_opcode_line_end_assertion, + _S_opcode_word_boundary, + _S_opcode_subexpr_lookahead, + _S_opcode_subexpr_begin, + _S_opcode_subexpr_end, + _S_opcode_dummy, + _S_opcode_match, + _S_opcode_accept, + }; + + struct _State_base + { + _Opcode _M_opcode; // type of outgoing transition + _StateIdT _M_next; // outgoing transition + union // Since they are mutually exclusive. + { + size_t _M_subexpr; // for _S_opcode_subexpr_* + size_t _M_backref_index; // for _S_opcode_backref + struct + { + // for _S_opcode_alternative. + _StateIdT _M_quant_index; + // for _S_opcode_alternative or _S_opcode_subexpr_lookahead + _StateIdT _M_alt; + // for _S_opcode_word_boundary or _S_opcode_subexpr_lookahead or + // quantifiers (ungreedy if set true) + bool _M_neg; + }; + }; + + explicit _State_base(_Opcode __opcode) + : _M_opcode(__opcode), _M_next(_S_invalid_state_id) + { } + + protected: + ~_State_base() = default; + + public: +#ifdef _GLIBCXX_DEBUG + std::ostream& + _M_print(std::ostream& ostr) const; + + // Prints graphviz dot commands for state. + std::ostream& + _M_dot(std::ostream& __ostr, _StateIdT __id) const; +#endif + }; + + template + struct _State : _State_base + { + typedef _Matcher _MatcherT; + + _MatcherT _M_matches; // for _S_opcode_match + + explicit _State(_Opcode __opcode) : _State_base(__opcode) { } + }; + + struct _NFA_base + { + typedef size_t _SizeT; + typedef regex_constants::syntax_option_type _FlagT; + + explicit + _NFA_base(_FlagT __f) + : _M_flags(__f), _M_start_state(0), _M_subexpr_count(0), + _M_quant_count(0), _M_has_backref(false) + { } + + _NFA_base(_NFA_base&&) = default; + + protected: + ~_NFA_base() = default; + + public: + _FlagT + _M_options() const + { return _M_flags; } + + _StateIdT + _M_start() const + { return _M_start_state; } + + _SizeT + _M_sub_count() const + { return _M_subexpr_count; } + + std::vector _M_paren_stack; + _FlagT _M_flags; + _StateIdT _M_start_state; + _SizeT _M_subexpr_count; + _SizeT _M_quant_count; + bool _M_has_backref; + }; + + template + struct _NFA + : _NFA_base, std::vector<_State<_TraitsT>> + { + typedef _State<_TraitsT> _StateT; + typedef _Matcher _MatcherT; + + using _NFA_base::_NFA_base; + + // for performance reasons _NFA objects should only be moved not copied + _NFA(const _NFA&) = delete; + _NFA(_NFA&&) = default; + + _StateIdT + _M_insert_accept() + { + auto __ret = _M_insert_state(_StateT(_S_opcode_accept)); + return __ret; + } + + _StateIdT + _M_insert_alt(_StateIdT __next, _StateIdT __alt, bool __neg) + { + _StateT __tmp(_S_opcode_alternative); + // It labels every quantifier to make greedy comparison easier in BFS + // approach. + __tmp._M_quant_index = this->_M_quant_count++; + __tmp._M_next = __next; + __tmp._M_alt = __alt; + __tmp._M_neg = __neg; + return _M_insert_state(std::move(__tmp)); + } + + _StateIdT + _M_insert_matcher(_MatcherT __m) + { + _StateT __tmp(_S_opcode_match); + __tmp._M_matches = std::move(__m); + return _M_insert_state(std::move(__tmp)); + } + + _StateIdT + _M_insert_subexpr_begin() + { + auto __id = this->_M_subexpr_count++; + this->_M_paren_stack.push_back(__id); + _StateT __tmp(_S_opcode_subexpr_begin); + __tmp._M_subexpr = __id; + return _M_insert_state(std::move(__tmp)); + } + + _StateIdT + _M_insert_subexpr_end() + { + _StateT __tmp(_S_opcode_subexpr_end); + __tmp._M_subexpr = this->_M_paren_stack.back(); + this->_M_paren_stack.pop_back(); + return _M_insert_state(std::move(__tmp)); + } + + _StateIdT + _M_insert_backref(size_t __index); + + _StateIdT + _M_insert_line_begin() + { return _M_insert_state(_StateT(_S_opcode_line_begin_assertion)); } + + _StateIdT + _M_insert_line_end() + { return _M_insert_state(_StateT(_S_opcode_line_end_assertion)); } + + _StateIdT + _M_insert_word_bound(bool __neg) + { + _StateT __tmp(_S_opcode_word_boundary); + __tmp._M_neg = __neg; + return _M_insert_state(std::move(__tmp)); + } + + _StateIdT + _M_insert_lookahead(_StateIdT __alt, bool __neg) + { + _StateT __tmp(_S_opcode_subexpr_lookahead); + __tmp._M_alt = __alt; + __tmp._M_neg = __neg; + return _M_insert_state(std::move(__tmp)); + } + + _StateIdT + _M_insert_dummy() + { return _M_insert_state(_StateT(_S_opcode_dummy)); } + + _StateIdT + _M_insert_state(_StateT __s) + { + this->push_back(std::move(__s)); + return this->size()-1; + } + + // Eliminate dummy node in this NFA to make it compact. + void + _M_eliminate_dummy(); + +#ifdef _GLIBCXX_DEBUG + std::ostream& + _M_dot(std::ostream& __ostr) const; +#endif + }; + + /// Describes a sequence of one or more %_State, its current start + /// and end(s). This structure contains fragments of an NFA during + /// construction. + template + class _StateSeq + { + public: + typedef _NFA<_TraitsT> _RegexT; + + public: + _StateSeq(_RegexT& __nfa, _StateIdT __s) + : _M_nfa(__nfa), _M_start(__s), _M_end(__s) + { } + + _StateSeq(_RegexT& __nfa, _StateIdT __s, _StateIdT __end) + : _M_nfa(__nfa), _M_start(__s), _M_end(__end) + { } + + // Append a state on *this and change *this to the new sequence. + void + _M_append(_StateIdT __id) + { + _M_nfa[_M_end]._M_next = __id; + _M_end = __id; + } + + // Append a sequence on *this and change *this to the new sequence. + void + _M_append(const _StateSeq& __s) + { + _M_nfa[_M_end]._M_next = __s._M_start; + _M_end = __s._M_end; + } + + // Clones an entire sequence. + _StateSeq + _M_clone(); + + public: + _RegexT& _M_nfa; + _StateIdT _M_start; + _StateIdT _M_end; + }; + + //@} regex-detail +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace __detail +} // namespace std + +#include diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/regex_automaton.tcc b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/regex_automaton.tcc new file mode 100755 index 0000000..6e68fca --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/regex_automaton.tcc @@ -0,0 +1,232 @@ +// class template regex -*- C++ -*- + +// Copyright (C) 2013-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** + * @file bits/regex_automaton.tcc + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{regex} + */ + +namespace std _GLIBCXX_VISIBILITY(default) +{ +namespace __detail +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + +#ifdef _GLIBCXX_DEBUG + inline std::ostream& + _State_base::_M_print(std::ostream& ostr) const + { + switch (_M_opcode) + { + case _S_opcode_alternative: + ostr << "alt next=" << _M_next << " alt=" << _M_alt; + break; + case _S_opcode_subexpr_begin: + ostr << "subexpr begin next=" << _M_next << " index=" << _M_subexpr; + break; + case _S_opcode_subexpr_end: + ostr << "subexpr end next=" << _M_next << " index=" << _M_subexpr; + break; + case _S_opcode_backref: + ostr << "backref next=" << _M_next << " index=" << _M_backref_index; + break; + case _S_opcode_match: + ostr << "match next=" << _M_next; + break; + case _S_opcode_accept: + ostr << "accept next=" << _M_next; + break; + default: + ostr << "unknown next=" << _M_next; + break; + } + return ostr; + } + + // Prints graphviz dot commands for state. + inline std::ostream& + _State_base::_M_dot(std::ostream& __ostr, _StateIdT __id) const + { + switch (_M_opcode) + { + case _S_opcode_alternative: + __ostr << __id << " [label=\"" << __id << "\\nALT\"];\n" + << __id << " -> " << _M_next + << " [label=\"epsilon\", tailport=\"s\"];\n" + << __id << " -> " << _M_alt + << " [label=\"epsilon\", tailport=\"n\"];\n"; + break; + case _S_opcode_backref: + __ostr << __id << " [label=\"" << __id << "\\nBACKREF " + << _M_subexpr << "\"];\n" + << __id << " -> " << _M_next << " [label=\"\"];\n"; + break; + case _S_opcode_line_begin_assertion: + __ostr << __id << " [label=\"" << __id << "\\nLINE_BEGIN \"];\n" + << __id << " -> " << _M_next << " [label=\"epsilon\"];\n"; + break; + case _S_opcode_line_end_assertion: + __ostr << __id << " [label=\"" << __id << "\\nLINE_END \"];\n" + << __id << " -> " << _M_next << " [label=\"epsilon\"];\n"; + break; + case _S_opcode_word_boundary: + __ostr << __id << " [label=\"" << __id << "\\nWORD_BOUNDRY " + << _M_neg << "\"];\n" + << __id << " -> " << _M_next << " [label=\"epsilon\"];\n"; + break; + case _S_opcode_subexpr_lookahead: + __ostr << __id << " [label=\"" << __id << "\\nLOOK_AHEAD\"];\n" + << __id << " -> " << _M_next + << " [label=\"epsilon\", tailport=\"s\"];\n" + << __id << " -> " << _M_alt + << " [label=\"\", tailport=\"n\"];\n"; + break; + case _S_opcode_subexpr_begin: + __ostr << __id << " [label=\"" << __id << "\\nSBEGIN " + << _M_subexpr << "\"];\n" + << __id << " -> " << _M_next << " [label=\"epsilon\"];\n"; + break; + case _S_opcode_subexpr_end: + __ostr << __id << " [label=\"" << __id << "\\nSEND " + << _M_subexpr << "\"];\n" + << __id << " -> " << _M_next << " [label=\"epsilon\"];\n"; + break; + case _S_opcode_dummy: + break; + case _S_opcode_match: + __ostr << __id << " [label=\"" << __id << "\\nMATCH\"];\n" + << __id << " -> " << _M_next << " [label=\"\"];\n"; + break; + case _S_opcode_accept: + __ostr << __id << " [label=\"" << __id << "\\nACC\"];\n" ; + break; + default: + _GLIBCXX_DEBUG_ASSERT(false); + break; + } + return __ostr; + } + + template + std::ostream& + _NFA<_TraitsT>::_M_dot(std::ostream& __ostr) const + { + __ostr << "digraph _Nfa {\n" + " rankdir=LR;\n"; + for (size_t __i = 0; __i < this->size(); ++__i) + (*this)[__i]._M_dot(__ostr, __i); + __ostr << "}\n"; + return __ostr; + } +#endif + + template + _StateIdT + _NFA<_TraitsT>::_M_insert_backref(size_t __index) + { + // To figure out whether a backref is valid, a stack is used to store + // unfinished sub-expressions. For example, when parsing + // "(a(b)(c\\1(d)))" at '\\1', _M_subexpr_count is 3, indicating that 3 + // sub expressions are parsed or partially parsed(in the stack), aka, + // "(a..", "(b)" and "(c.."). + // _M_paren_stack is {1, 3}, for incomplete "(a.." and "(c..". At this + // time, "\\2" is valid, but "\\1" and "\\3" are not. + if (__index >= _M_subexpr_count) + __throw_regex_error(regex_constants::error_backref); + for (auto __it : this->_M_paren_stack) + if (__index == __it) + __throw_regex_error(regex_constants::error_backref); + this->_M_has_backref = true; + _StateT __tmp(_S_opcode_backref); + __tmp._M_backref_index = __index; + return _M_insert_state(std::move(__tmp)); + } + + template + void + _NFA<_TraitsT>::_M_eliminate_dummy() + { + for (auto& __it : *this) + { + while (__it._M_next >= 0 && (*this)[__it._M_next]._M_opcode + == _S_opcode_dummy) + __it._M_next = (*this)[__it._M_next]._M_next; + if (__it._M_opcode == _S_opcode_alternative + || __it._M_opcode == _S_opcode_subexpr_lookahead) + while (__it._M_alt >= 0 && (*this)[__it._M_alt]._M_opcode + == _S_opcode_dummy) + __it._M_alt = (*this)[__it._M_alt]._M_next; + } + } + + // Just apply DFS on the sequence and re-link their links. + template + _StateSeq<_TraitsT> + _StateSeq<_TraitsT>::_M_clone() + { + std::vector<_StateIdT> __m(_M_nfa.size(), -1); + std::stack<_StateIdT> __stack; + __stack.push(_M_start); + while (!__stack.empty()) + { + auto __u = __stack.top(); + __stack.pop(); + auto __dup = _M_nfa[__u]; + // _M_insert_state() never return -1 + auto __id = _M_nfa._M_insert_state(__dup); + __m[__u] = __id; + if (__dup._M_opcode == _S_opcode_alternative + || __dup._M_opcode == _S_opcode_subexpr_lookahead) + if (__dup._M_alt != _S_invalid_state_id && __m[__dup._M_alt] == -1) + __stack.push(__dup._M_alt); + if (__u == _M_end) + continue; + if (__dup._M_next != _S_invalid_state_id && __m[__dup._M_next] == -1) + __stack.push(__dup._M_next); + } + for (auto __v : __m) + { + if (__v == -1) + continue; + auto& __ref = _M_nfa[__v]; + if (__ref._M_next != _S_invalid_state_id) + { + _GLIBCXX_DEBUG_ASSERT(__m[__ref._M_next] != -1); + __ref._M_next = __m[__ref._M_next]; + } + if (__ref._M_opcode == _S_opcode_alternative + || __ref._M_opcode == _S_opcode_subexpr_lookahead) + if (__ref._M_alt != _S_invalid_state_id) + { + _GLIBCXX_DEBUG_ASSERT(__m[__ref._M_alt] != -1); + __ref._M_alt = __m[__ref._M_alt]; + } + } + return _StateSeq(_M_nfa, __m[_M_start], __m[_M_end]); + } + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace __detail +} // namespace diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/regex_compiler.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/regex_compiler.h new file mode 100755 index 0000000..af76f55 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/regex_compiler.h @@ -0,0 +1,457 @@ +// class template regex -*- C++ -*- + +// Copyright (C) 2010-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** + * @file bits/regex_compiler.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{regex} + */ + +namespace std _GLIBCXX_VISIBILITY(default) +{ +namespace __detail +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /** + * @addtogroup regex-detail + * @{ + */ + + template + struct _BracketMatcher; + + /** + * @brief Builds an NFA from an input iterator interval. + * + * The %_TraitsT type should fulfill requirements [28.3]. + */ + template + class _Compiler + { + public: + typedef typename _TraitsT::char_type _CharT; + typedef const _CharT* _IterT; + typedef _NFA<_TraitsT> _RegexT; + typedef regex_constants::syntax_option_type _FlagT; + + _Compiler(_IterT __b, _IterT __e, + const _TraitsT& __traits, _FlagT __flags); + + std::shared_ptr<_RegexT> + _M_get_nfa() + { return make_shared<_RegexT>(std::move(_M_nfa)); } + + private: + typedef _Scanner<_CharT> _ScannerT; + typedef typename _TraitsT::string_type _StringT; + typedef typename _ScannerT::_TokenT _TokenT; + typedef _StateSeq<_TraitsT> _StateSeqT; + typedef std::stack<_StateSeqT> _StackT; + typedef std::ctype<_CharT> _CtypeT; + + // accepts a specific token or returns false. + bool + _M_match_token(_TokenT __token); + + void + _M_disjunction(); + + void + _M_alternative(); + + bool + _M_term(); + + bool + _M_assertion(); + + bool + _M_quantifier(); + + bool + _M_atom(); + + bool + _M_bracket_expression(); + + template + void + _M_insert_any_matcher_ecma(); + + template + void + _M_insert_any_matcher_posix(); + + template + void + _M_insert_char_matcher(); + + template + void + _M_insert_character_class_matcher(); + + template + void + _M_insert_bracket_matcher(bool __neg); + + template + void + _M_expression_term(_BracketMatcher<_TraitsT, __icase, __collate>& + __matcher); + + int + _M_cur_int_value(int __radix); + + bool + _M_try_char(); + + _StateSeqT + _M_pop() + { + auto ret = _M_stack.top(); + _M_stack.pop(); + return ret; + } + + _FlagT _M_flags; + const _TraitsT& _M_traits; + const _CtypeT& _M_ctype; + _ScannerT _M_scanner; + _RegexT _M_nfa; + _StringT _M_value; + _StackT _M_stack; + }; + + template + inline std::shared_ptr<_NFA<_TraitsT>> + __compile_nfa(const typename _TraitsT::char_type* __first, + const typename _TraitsT::char_type* __last, + const _TraitsT& __traits, + regex_constants::syntax_option_type __flags) + { + using _Cmplr = _Compiler<_TraitsT>; + return _Cmplr(__first, __last, __traits, __flags)._M_get_nfa(); + } + + // [28.13.14] + template + class _RegexTranslator + { + public: + typedef typename _TraitsT::char_type _CharT; + typedef typename _TraitsT::string_type _StringT; + typedef typename std::conditional<__collate, + _StringT, + _CharT>::type _StrTransT; + + explicit + _RegexTranslator(const _TraitsT& __traits) + : _M_traits(__traits) + { } + + _CharT + _M_translate(_CharT __ch) const + { + if (__icase) + return _M_traits.translate_nocase(__ch); + else if (__collate) + return _M_traits.translate(__ch); + else + return __ch; + } + + _StrTransT + _M_transform(_CharT __ch) const + { + return _M_transform_impl(__ch, typename integral_constant::type()); + } + + private: + _StrTransT + _M_transform_impl(_CharT __ch, false_type) const + { return __ch; } + + _StrTransT + _M_transform_impl(_CharT __ch, true_type) const + { + _StrTransT __str = _StrTransT(1, _M_translate(__ch)); + return _M_traits.transform(__str.begin(), __str.end()); + } + + const _TraitsT& _M_traits; + }; + + template + class _RegexTranslator<_TraitsT, false, false> + { + public: + typedef typename _TraitsT::char_type _CharT; + typedef _CharT _StrTransT; + + explicit + _RegexTranslator(const _TraitsT& __traits) + { } + + _CharT + _M_translate(_CharT __ch) const + { return __ch; } + + _StrTransT + _M_transform(_CharT __ch) const + { return __ch; } + }; + + template + struct _AnyMatcher; + + template + struct _AnyMatcher<_TraitsT, false, __icase, __collate> + { + typedef _RegexTranslator<_TraitsT, __icase, __collate> _TransT; + typedef typename _TransT::_CharT _CharT; + + explicit + _AnyMatcher(const _TraitsT& __traits) + : _M_translator(__traits) + { } + + bool + operator()(_CharT __ch) const + { + static auto __nul = _M_translator._M_translate('\0'); + return _M_translator._M_translate(__ch) != __nul; + } + + _TransT _M_translator; + }; + + template + struct _AnyMatcher<_TraitsT, true, __icase, __collate> + { + typedef _RegexTranslator<_TraitsT, __icase, __collate> _TransT; + typedef typename _TransT::_CharT _CharT; + + explicit + _AnyMatcher(const _TraitsT& __traits) + : _M_translator(__traits) + { } + + bool + operator()(_CharT __ch) const + { return _M_apply(__ch, typename is_same<_CharT, char>::type()); } + + bool + _M_apply(_CharT __ch, true_type) const + { + auto __c = _M_translator._M_translate(__ch); + auto __n = _M_translator._M_translate('\n'); + auto __r = _M_translator._M_translate('\r'); + return __c != __n && __c != __r; + } + + bool + _M_apply(_CharT __ch, false_type) const + { + auto __c = _M_translator._M_translate(__ch); + auto __n = _M_translator._M_translate('\n'); + auto __r = _M_translator._M_translate('\r'); + auto __u2028 = _M_translator._M_translate(u'\u2028'); + auto __u2029 = _M_translator._M_translate(u'\u2029'); + return __c != __n && __c != __r && __c != __u2028 && __c != __u2029; + } + + _TransT _M_translator; + }; + + template + struct _CharMatcher + { + typedef _RegexTranslator<_TraitsT, __icase, __collate> _TransT; + typedef typename _TransT::_CharT _CharT; + + _CharMatcher(_CharT __ch, const _TraitsT& __traits) + : _M_translator(__traits), _M_ch(_M_translator._M_translate(__ch)) + { } + + bool + operator()(_CharT __ch) const + { return _M_ch == _M_translator._M_translate(__ch); } + + _TransT _M_translator; + _CharT _M_ch; + }; + + /// Matches a character range (bracket expression) + template + struct _BracketMatcher + { + public: + typedef _RegexTranslator<_TraitsT, __icase, __collate> _TransT; + typedef typename _TransT::_CharT _CharT; + typedef typename _TransT::_StrTransT _StrTransT; + typedef typename _TraitsT::string_type _StringT; + typedef typename _TraitsT::char_class_type _CharClassT; + + public: + _BracketMatcher(bool __is_non_matching, + const _TraitsT& __traits) + : _M_class_set(0), _M_translator(__traits), _M_traits(__traits), + _M_is_non_matching(__is_non_matching) +#ifdef _GLIBCXX_DEBUG + , _M_is_ready(false) +#endif + { } + + bool + operator()(_CharT __ch) const + { + _GLIBCXX_DEBUG_ASSERT(_M_is_ready); + return _M_apply(__ch, _IsChar()); + } + + void + _M_add_char(_CharT __c) + { + _M_char_set.push_back(_M_translator._M_translate(__c)); +#ifdef _GLIBCXX_DEBUG + _M_is_ready = false; +#endif + } + + void + _M_add_collating_element(const _StringT& __s) + { + auto __st = _M_traits.lookup_collatename(__s.data(), + __s.data() + __s.size()); + if (__st.empty()) + __throw_regex_error(regex_constants::error_collate); + _M_char_set.push_back(_M_translator._M_translate(__st[0])); +#ifdef _GLIBCXX_DEBUG + _M_is_ready = false; +#endif + } + + void + _M_add_equivalence_class(const _StringT& __s) + { + auto __st = _M_traits.lookup_collatename(__s.data(), + __s.data() + __s.size()); + if (__st.empty()) + __throw_regex_error(regex_constants::error_collate); + __st = _M_traits.transform_primary(__st.data(), + __st.data() + __st.size()); + _M_equiv_set.push_back(__st); +#ifdef _GLIBCXX_DEBUG + _M_is_ready = false; +#endif + } + + // __neg should be true for \D, \S and \W only. + void + _M_add_character_class(const _StringT& __s, bool __neg) + { + auto __mask = _M_traits.lookup_classname(__s.data(), + __s.data() + __s.size(), + __icase); + if (__mask == 0) + __throw_regex_error(regex_constants::error_ctype); + if (!__neg) + _M_class_set |= __mask; + else + _M_neg_class_set.push_back(__mask); +#ifdef _GLIBCXX_DEBUG + _M_is_ready = false; +#endif + } + + void + _M_make_range(_CharT __l, _CharT __r) + { + _M_range_set.push_back(make_pair(_M_translator._M_transform(__l), + _M_translator._M_transform(__r))); +#ifdef _GLIBCXX_DEBUG + _M_is_ready = false; +#endif + } + + void + _M_ready() + { + _M_make_cache(_IsChar()); +#ifdef _GLIBCXX_DEBUG + _M_is_ready = true; +#endif + } + + private: + typedef typename is_same<_CharT, char>::type _IsChar; + struct _Dummy { }; + typedef typename conditional<_IsChar::value, + std::bitset<1 << (8 * sizeof(_CharT))>, + _Dummy>::type _CacheT; + typedef typename make_unsigned<_CharT>::type _UnsignedCharT; + + private: + bool + _M_apply(_CharT __ch, false_type) const; + + bool + _M_apply(_CharT __ch, true_type) const + { return _M_cache[static_cast<_UnsignedCharT>(__ch)]; } + + void + _M_make_cache(true_type) + { + for (int __i = 0; __i < _M_cache.size(); __i++) + _M_cache[static_cast<_UnsignedCharT>(__i)] = + _M_apply(__i, false_type()); + } + + void + _M_make_cache(false_type) + { } + + private: + _CacheT _M_cache; + std::vector<_CharT> _M_char_set; + std::vector<_StringT> _M_equiv_set; + std::vector> _M_range_set; + std::vector<_CharClassT> _M_neg_class_set; + _CharClassT _M_class_set; + _TransT _M_translator; + const _TraitsT& _M_traits; + bool _M_is_non_matching; +#ifdef _GLIBCXX_DEBUG + bool _M_is_ready; +#endif + }; + + //@} regex-detail +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace __detail +} // namespace std + +#include diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/regex_compiler.tcc b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/regex_compiler.tcc new file mode 100755 index 0000000..ffe0170 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/regex_compiler.tcc @@ -0,0 +1,552 @@ +// class template regex -*- C++ -*- + +// Copyright (C) 2013-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** + * @file bits/regex_compiler.tcc + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{regex} + */ + +// FIXME make comments doxygen format. + +// This compiler refers to "Regular Expression Matching Can Be Simple And Fast" +// (http://swtch.com/~rsc/regexp/regexp1.html"), +// but doesn't strictly follow it. +// +// When compiling, states are *chained* instead of tree- or graph-constructed. +// It's more like structured programs: there's if statement and loop statement. +// +// For alternative structure(say "a|b"), aka "if statement", two branchs should +// be constructed. However, these two shall merge to an "end_tag" at the end of +// this operator: +// +// branch1 +// / \ +// => begin_tag end_tag => +// \ / +// branch2 +// +// This is the difference between this implementation and that in Russ's +// article. +// +// That's why we introduced dummy node here ------ "end_tag" is a dummy node. +// All dummy node will be eliminated at the end of compiling process. + +namespace std _GLIBCXX_VISIBILITY(default) +{ +namespace __detail +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + template + _Compiler<_TraitsT>:: + _Compiler(_IterT __b, _IterT __e, + const _TraitsT& __traits, _FlagT __flags) + : _M_flags((__flags + & (regex_constants::ECMAScript + | regex_constants::basic + | regex_constants::extended + | regex_constants::grep + | regex_constants::egrep + | regex_constants::awk)) + ? __flags + : __flags | regex_constants::ECMAScript), + _M_traits(__traits), + _M_ctype(std::use_facet<_CtypeT>(_M_traits.getloc())), + _M_scanner(__b, __e, _M_flags, _M_traits.getloc()), + _M_nfa(_M_flags) + { + _StateSeqT __r(_M_nfa, _M_nfa._M_start()); + __r._M_append(_M_nfa._M_insert_subexpr_begin()); + this->_M_disjunction(); + if (!_M_match_token(_ScannerT::_S_token_eof)) + __throw_regex_error(regex_constants::error_paren); + __r._M_append(_M_pop()); + _GLIBCXX_DEBUG_ASSERT(_M_stack.empty()); + __r._M_append(_M_nfa._M_insert_subexpr_end()); + __r._M_append(_M_nfa._M_insert_accept()); + _M_nfa._M_eliminate_dummy(); + } + + template + void + _Compiler<_TraitsT>:: + _M_disjunction() + { + this->_M_alternative(); + while (_M_match_token(_ScannerT::_S_token_or)) + { + _StateSeqT __alt1 = _M_pop(); + this->_M_alternative(); + _StateSeqT __alt2 = _M_pop(); + auto __end = _M_nfa._M_insert_dummy(); + __alt1._M_append(__end); + __alt2._M_append(__end); + _M_stack.push(_StateSeqT(_M_nfa, + _M_nfa._M_insert_alt(__alt1._M_start, + __alt2._M_start, false), + __end)); + } + } + + template + void + _Compiler<_TraitsT>:: + _M_alternative() + { + if (this->_M_term()) + { + _StateSeqT __re = _M_pop(); + this->_M_alternative(); + __re._M_append(_M_pop()); + _M_stack.push(__re); + } + else + _M_stack.push(_StateSeqT(_M_nfa, _M_nfa._M_insert_dummy())); + } + + template + bool + _Compiler<_TraitsT>:: + _M_term() + { + if (this->_M_assertion()) + return true; + if (this->_M_atom()) + { + while (this->_M_quantifier()); + return true; + } + return false; + } + + template + bool + _Compiler<_TraitsT>:: + _M_assertion() + { + if (_M_match_token(_ScannerT::_S_token_line_begin)) + _M_stack.push(_StateSeqT(_M_nfa, _M_nfa._M_insert_line_begin())); + else if (_M_match_token(_ScannerT::_S_token_line_end)) + _M_stack.push(_StateSeqT(_M_nfa, _M_nfa._M_insert_line_end())); + else if (_M_match_token(_ScannerT::_S_token_word_bound)) + // _M_value[0] == 'n' means it's negtive, say "not word boundary". + _M_stack.push(_StateSeqT(_M_nfa, _M_nfa. + _M_insert_word_bound(_M_value[0] == 'n'))); + else if (_M_match_token(_ScannerT::_S_token_subexpr_lookahead_begin)) + { + auto __neg = _M_value[0] == 'n'; + this->_M_disjunction(); + if (!_M_match_token(_ScannerT::_S_token_subexpr_end)) + __throw_regex_error(regex_constants::error_paren); + auto __tmp = _M_pop(); + __tmp._M_append(_M_nfa._M_insert_accept()); + _M_stack.push( + _StateSeqT( + _M_nfa, + _M_nfa._M_insert_lookahead(__tmp._M_start, __neg))); + } + else + return false; + return true; + } + + template + bool + _Compiler<_TraitsT>:: + _M_quantifier() + { + bool __neg = (_M_flags & regex_constants::ECMAScript); + auto __init = [this, &__neg]() + { + if (_M_stack.empty()) + __throw_regex_error(regex_constants::error_badrepeat); + __neg = __neg && _M_match_token(_ScannerT::_S_token_opt); + }; + if (_M_match_token(_ScannerT::_S_token_closure0)) + { + __init(); + auto __e = _M_pop(); + _StateSeqT __r(_M_nfa, _M_nfa._M_insert_alt(_S_invalid_state_id, + __e._M_start, __neg)); + __e._M_append(__r); + _M_stack.push(__r); + } + else if (_M_match_token(_ScannerT::_S_token_closure1)) + { + __init(); + auto __e = _M_pop(); + __e._M_append(_M_nfa._M_insert_alt(_S_invalid_state_id, __e._M_start, + __neg)); + _M_stack.push(__e); + } + else if (_M_match_token(_ScannerT::_S_token_opt)) + { + __init(); + auto __e = _M_pop(); + auto __end = _M_nfa._M_insert_dummy(); + _StateSeqT __r(_M_nfa, _M_nfa._M_insert_alt(_S_invalid_state_id, + __e._M_start, __neg)); + __e._M_append(__end); + __r._M_append(__end); + _M_stack.push(__r); + } + else if (_M_match_token(_ScannerT::_S_token_interval_begin)) + { + if (_M_stack.empty()) + __throw_regex_error(regex_constants::error_badrepeat); + if (!_M_match_token(_ScannerT::_S_token_dup_count)) + __throw_regex_error(regex_constants::error_badbrace); + _StateSeqT __r(_M_pop()); + _StateSeqT __e(_M_nfa, _M_nfa._M_insert_dummy()); + long __min_rep = _M_cur_int_value(10); + bool __infi = false; + long __n; + + // {3 + if (_M_match_token(_ScannerT::_S_token_comma)) + if (_M_match_token(_ScannerT::_S_token_dup_count)) // {3,7} + __n = _M_cur_int_value(10) - __min_rep; + else + __infi = true; + else + __n = 0; + if (!_M_match_token(_ScannerT::_S_token_interval_end)) + __throw_regex_error(regex_constants::error_brace); + + __neg = __neg && _M_match_token(_ScannerT::_S_token_opt); + + for (long __i = 0; __i < __min_rep; ++__i) + __e._M_append(__r._M_clone()); + + if (__infi) + { + auto __tmp = __r._M_clone(); + _StateSeqT __s(_M_nfa, + _M_nfa._M_insert_alt(_S_invalid_state_id, + __tmp._M_start, __neg)); + __tmp._M_append(__s); + __e._M_append(__s); + } + else + { + if (__n < 0) + __throw_regex_error(regex_constants::error_badbrace); + auto __end = _M_nfa._M_insert_dummy(); + // _M_alt is the "match more" branch, and _M_next is the + // "match less" one. Switch _M_alt and _M_next of all created + // nodes. This is a hacking but IMO works well. + std::stack<_StateIdT> __stack; + for (long __i = 0; __i < __n; ++__i) + { + auto __tmp = __r._M_clone(); + auto __alt = _M_nfa._M_insert_alt(__tmp._M_start, + __end, __neg); + __stack.push(__alt); + __e._M_append(_StateSeqT(_M_nfa, __alt, __tmp._M_end)); + } + __e._M_append(__end); + while (!__stack.empty()) + { + auto& __tmp = _M_nfa[__stack.top()]; + __stack.pop(); + std::swap(__tmp._M_next, __tmp._M_alt); + } + } + _M_stack.push(__e); + } + else + return false; + return true; + } + +#define __INSERT_REGEX_MATCHER(__func, args...)\ + do\ + if (!(_M_flags & regex_constants::icase))\ + if (!(_M_flags & regex_constants::collate))\ + __func(args);\ + else\ + __func(args);\ + else\ + if (!(_M_flags & regex_constants::collate))\ + __func(args);\ + else\ + __func(args);\ + while (false) + + template + bool + _Compiler<_TraitsT>:: + _M_atom() + { + if (_M_match_token(_ScannerT::_S_token_anychar)) + { + if (!(_M_flags & regex_constants::ECMAScript)) + __INSERT_REGEX_MATCHER(_M_insert_any_matcher_posix); + else + __INSERT_REGEX_MATCHER(_M_insert_any_matcher_ecma); + } + else if (_M_try_char()) + __INSERT_REGEX_MATCHER(_M_insert_char_matcher); + else if (_M_match_token(_ScannerT::_S_token_backref)) + _M_stack.push(_StateSeqT(_M_nfa, _M_nfa. + _M_insert_backref(_M_cur_int_value(10)))); + else if (_M_match_token(_ScannerT::_S_token_quoted_class)) + __INSERT_REGEX_MATCHER(_M_insert_character_class_matcher); + else if (_M_match_token(_ScannerT::_S_token_subexpr_no_group_begin)) + { + _StateSeqT __r(_M_nfa, _M_nfa._M_insert_dummy()); + this->_M_disjunction(); + if (!_M_match_token(_ScannerT::_S_token_subexpr_end)) + __throw_regex_error(regex_constants::error_paren); + __r._M_append(_M_pop()); + _M_stack.push(__r); + } + else if (_M_match_token(_ScannerT::_S_token_subexpr_begin)) + { + _StateSeqT __r(_M_nfa, _M_nfa._M_insert_subexpr_begin()); + this->_M_disjunction(); + if (!_M_match_token(_ScannerT::_S_token_subexpr_end)) + __throw_regex_error(regex_constants::error_paren); + __r._M_append(_M_pop()); + __r._M_append(_M_nfa._M_insert_subexpr_end()); + _M_stack.push(__r); + } + else if (!_M_bracket_expression()) + return false; + return true; + } + + template + bool + _Compiler<_TraitsT>:: + _M_bracket_expression() + { + bool __neg = + _M_match_token(_ScannerT::_S_token_bracket_neg_begin); + if (!(__neg || _M_match_token(_ScannerT::_S_token_bracket_begin))) + return false; + __INSERT_REGEX_MATCHER(_M_insert_bracket_matcher, __neg); + return true; + } +#undef __INSERT_REGEX_MATCHER + + template + template + void + _Compiler<_TraitsT>:: + _M_insert_any_matcher_ecma() + { + _M_stack.push(_StateSeqT(_M_nfa, + _M_nfa._M_insert_matcher + (_AnyMatcher<_TraitsT, true, __icase, __collate> + (_M_traits)))); + } + + template + template + void + _Compiler<_TraitsT>:: + _M_insert_any_matcher_posix() + { + _M_stack.push(_StateSeqT(_M_nfa, + _M_nfa._M_insert_matcher + (_AnyMatcher<_TraitsT, false, __icase, __collate> + (_M_traits)))); + } + + template + template + void + _Compiler<_TraitsT>:: + _M_insert_char_matcher() + { + _M_stack.push(_StateSeqT(_M_nfa, + _M_nfa._M_insert_matcher + (_CharMatcher<_TraitsT, __icase, __collate> + (_M_value[0], _M_traits)))); + } + + template + template + void + _Compiler<_TraitsT>:: + _M_insert_character_class_matcher() + { + _GLIBCXX_DEBUG_ASSERT(_M_value.size() == 1); + _BracketMatcher<_TraitsT, __icase, __collate> __matcher + (_M_ctype.is(_CtypeT::upper, _M_value[0]), _M_traits); + __matcher._M_add_character_class(_M_value, false); + __matcher._M_ready(); + _M_stack.push(_StateSeqT(_M_nfa, + _M_nfa._M_insert_matcher(std::move(__matcher)))); + } + + template + template + void + _Compiler<_TraitsT>:: + _M_insert_bracket_matcher(bool __neg) + { + _BracketMatcher<_TraitsT, __icase, __collate> __matcher(__neg, _M_traits); + while (!_M_match_token(_ScannerT::_S_token_bracket_end)) + _M_expression_term(__matcher); + __matcher._M_ready(); + _M_stack.push(_StateSeqT(_M_nfa, + _M_nfa._M_insert_matcher(std::move(__matcher)))); + } + + template + template + void + _Compiler<_TraitsT>:: + _M_expression_term(_BracketMatcher<_TraitsT, __icase, __collate>& __matcher) + { + if (_M_match_token(_ScannerT::_S_token_collsymbol)) + __matcher._M_add_collating_element(_M_value); + else if (_M_match_token(_ScannerT::_S_token_equiv_class_name)) + __matcher._M_add_equivalence_class(_M_value); + else if (_M_match_token(_ScannerT::_S_token_char_class_name)) + __matcher._M_add_character_class(_M_value, false); + else if (_M_try_char()) // [a + { + auto __ch = _M_value[0]; + if (_M_try_char()) + { + if (_M_value[0] == '-') // [a- + { + if (_M_try_char()) // [a-z] + { + __matcher._M_make_range(__ch, _M_value[0]); + return; + } + // If the dash is the last character in the bracket + // expression, it is not special. + if (_M_scanner._M_get_token() + != _ScannerT::_S_token_bracket_end) + __throw_regex_error(regex_constants::error_range); + } + __matcher._M_add_char(_M_value[0]); + } + __matcher._M_add_char(__ch); + } + else if (_M_match_token(_ScannerT::_S_token_quoted_class)) + __matcher._M_add_character_class(_M_value, + _M_ctype.is(_CtypeT::upper, + _M_value[0])); + else + __throw_regex_error(regex_constants::error_brack); + } + + template + bool + _Compiler<_TraitsT>:: + _M_try_char() + { + bool __is_char = false; + if (_M_match_token(_ScannerT::_S_token_oct_num)) + { + __is_char = true; + _M_value.assign(1, _M_cur_int_value(8)); + } + else if (_M_match_token(_ScannerT::_S_token_hex_num)) + { + __is_char = true; + _M_value.assign(1, _M_cur_int_value(16)); + } + else if (_M_match_token(_ScannerT::_S_token_ord_char)) + __is_char = true; + return __is_char; + } + + template + bool + _Compiler<_TraitsT>:: + _M_match_token(_TokenT token) + { + if (token == _M_scanner._M_get_token()) + { + _M_value = _M_scanner._M_get_value(); + _M_scanner._M_advance(); + return true; + } + return false; + } + + template + int + _Compiler<_TraitsT>:: + _M_cur_int_value(int __radix) + { + long __v = 0; + for (typename _StringT::size_type __i = 0; + __i < _M_value.length(); ++__i) + __v =__v * __radix + _M_traits.value(_M_value[__i], __radix); + return __v; + } + + template + bool + _BracketMatcher<_TraitsT, __icase, __collate>:: + _M_apply(_CharT __ch, false_type) const + { + bool __ret = false; + if (std::find(_M_char_set.begin(), _M_char_set.end(), + _M_translator._M_translate(__ch)) + != _M_char_set.end()) + __ret = true; + else + { + auto __s = _M_translator._M_transform(__ch); + for (auto& __it : _M_range_set) + if (__it.first <= __s && __s <= __it.second) + { + __ret = true; + break; + } + if (_M_traits.isctype(__ch, _M_class_set)) + __ret = true; + else if (std::find(_M_equiv_set.begin(), _M_equiv_set.end(), + _M_traits.transform_primary(&__ch, &__ch+1)) + != _M_equiv_set.end()) + __ret = true; + else + { + for (auto& __it : _M_neg_class_set) + if (!_M_traits.isctype(__ch, __it)) + { + __ret = true; + break; + } + } + } + if (_M_is_non_matching) + return !__ret; + else + return __ret; + } + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace __detail +} // namespace diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/regex_constants.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/regex_constants.h new file mode 100755 index 0000000..b5705ba --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/regex_constants.h @@ -0,0 +1,386 @@ +// class template regex -*- C++ -*- + +// Copyright (C) 2010-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** + * @file bits/regex_constants.h + * @brief Constant definitions for the std regex library. + * + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{regex} + */ + +namespace std _GLIBCXX_VISIBILITY(default) +{ +/** + * @defgroup regex Regular Expressions + * + * A facility for performing regular expression pattern matching. + * @{ + */ + +/** + * @namespace std::regex_constants + * @brief ISO C++-0x entities sub namespace for regex. + */ +namespace regex_constants +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /** + * @name 5.1 Regular Expression Syntax Options + */ + //@{ + enum __syntax_option + { + _S_icase, + _S_nosubs, + _S_optimize, + _S_collate, + _S_ECMAScript, + _S_basic, + _S_extended, + _S_awk, + _S_grep, + _S_egrep, + _S_syntax_last + }; + + /** + * @brief This is a bitmask type indicating how to interpret the regex. + * + * The @c syntax_option_type is implementation defined but it is valid to + * perform bitwise operations on these values and expect the right thing to + * happen. + * + * A valid value of type syntax_option_type shall have exactly one of the + * elements @c ECMAScript, @c basic, @c extended, @c awk, @c grep, @c egrep + * %set. + */ + enum syntax_option_type : unsigned int + { + /** + * Specifies that the matching of regular expressions against a character + * sequence shall be performed without regard to case. + */ + icase = 1 << _S_icase, + + /** + * Specifies that when a regular expression is matched against a character + * container sequence, no sub-expression matches are to be stored in the + * supplied match_results structure. + */ + nosubs = 1 << _S_nosubs, + + /** + * Specifies that the regular expression engine should pay more attention to + * the speed with which regular expressions are matched, and less to the + * speed with which regular expression objects are constructed. Otherwise + * it has no detectable effect on the program output. + */ + optimize = 1 << _S_optimize, + + /** + * Specifies that character ranges of the form [a-b] should be locale + * sensitive. + */ + collate = 1 << _S_collate, + + /** + * Specifies that the grammar recognized by the regular expression engine is + * that used by ECMAScript in ECMA-262 [Ecma International, ECMAScript + * Language Specification, Standard Ecma-262, third edition, 1999], as + * modified in section [28.13]. This grammar is similar to that defined + * in the PERL scripting language but extended with elements found in the + * POSIX regular expression grammar. + */ + ECMAScript = 1 << _S_ECMAScript, + + /** + * Specifies that the grammar recognized by the regular expression engine is + * that used by POSIX basic regular expressions in IEEE Std 1003.1-2001, + * Portable Operating System Interface (POSIX), Base Definitions and + * Headers, Section 9, Regular Expressions [IEEE, Information Technology -- + * Portable Operating System Interface (POSIX), IEEE Standard 1003.1-2001]. + */ + basic = 1 << _S_basic, + + /** + * Specifies that the grammar recognized by the regular expression engine is + * that used by POSIX extended regular expressions in IEEE Std 1003.1-2001, + * Portable Operating System Interface (POSIX), Base Definitions and + * Headers, Section 9, Regular Expressions. + */ + extended = 1 << _S_extended, + + /** + * Specifies that the grammar recognized by the regular expression engine is + * that used by POSIX utility awk in IEEE Std 1003.1-2001. This option is + * identical to syntax_option_type extended, except that C-style escape + * sequences are supported. These sequences are: + * \\\\, \\a, \\b, \\f, \\n, \\r, \\t , \\v, \\&apos,, &apos,, + * and \\ddd (where ddd is one, two, or three octal digits). + */ + awk = 1 << _S_awk, + + /** + * Specifies that the grammar recognized by the regular expression engine is + * that used by POSIX utility grep in IEEE Std 1003.1-2001. This option is + * identical to syntax_option_type basic, except that newlines are treated + * as whitespace. + */ + grep = 1 << _S_grep, + + /** + * Specifies that the grammar recognized by the regular expression engine is + * that used by POSIX utility grep when given the -E option in + * IEEE Std 1003.1-2001. This option is identical to syntax_option_type + * extended, except that newlines are treated as whitespace. + */ + egrep = 1 << _S_egrep, + }; + + constexpr inline syntax_option_type + operator&(syntax_option_type __a, syntax_option_type __b) + { + return (syntax_option_type)(static_cast(__a) + & static_cast(__b)); + } + + constexpr inline syntax_option_type + operator|(syntax_option_type __a, syntax_option_type __b) + { + return (syntax_option_type)(static_cast(__a) + | static_cast(__b)); + } + + constexpr inline syntax_option_type + operator^(syntax_option_type __a, syntax_option_type __b) + { + return (syntax_option_type)(static_cast(__a) + ^ static_cast(__b)); + } + + constexpr inline syntax_option_type + operator~(syntax_option_type __a) + { return (syntax_option_type)(~static_cast(__a)); } + + inline syntax_option_type& + operator&=(syntax_option_type& __a, syntax_option_type __b) + { return __a = __a & __b; } + + inline syntax_option_type& + operator|=(syntax_option_type& __a, syntax_option_type __b) + { return __a = __a | __b; } + + inline syntax_option_type& + operator^=(syntax_option_type& __a, syntax_option_type __b) + { return __a = __a ^ __b; } + + //@} + + /** + * @name 5.2 Matching Rules + * + * Matching a regular expression against a sequence of characters [first, + * last) proceeds according to the rules of the grammar specified for the + * regular expression object, modified according to the effects listed + * below for any bitmask elements set. + * + */ + //@{ + + enum __match_flag + { + _S_not_bol, + _S_not_eol, + _S_not_bow, + _S_not_eow, + _S_any, + _S_not_null, + _S_continuous, + _S_prev_avail, + _S_sed, + _S_no_copy, + _S_first_only, + _S_match_flag_last + }; + + /** + * @brief This is a bitmask type indicating regex matching rules. + * + * The @c match_flag_type is implementation defined but it is valid to + * perform bitwise operations on these values and expect the right thing to + * happen. + */ + enum match_flag_type : unsigned int + { + /** + * The default matching rules. + */ + match_default = 0, + + /** + * The first character in the sequence [first, last) is treated as though it + * is not at the beginning of a line, so the character (^) in the regular + * expression shall not match [first, first). + */ + match_not_bol = 1 << _S_not_bol, + + /** + * The last character in the sequence [first, last) is treated as though it + * is not at the end of a line, so the character ($) in the regular + * expression shall not match [last, last). + */ + match_not_eol = 1 << _S_not_eol, + + /** + * The expression \\b is not matched against the sub-sequence + * [first,first). + */ + match_not_bow = 1 << _S_not_bow, + + /** + * The expression \\b should not be matched against the sub-sequence + * [last,last). + */ + match_not_eow = 1 << _S_not_eow, + + /** + * If more than one match is possible then any match is an acceptable + * result. + */ + match_any = 1 << _S_any, + + /** + * The expression does not match an empty sequence. + */ + match_not_null = 1 << _S_not_null, + + /** + * The expression only matches a sub-sequence that begins at first . + */ + match_continuous = 1 << _S_continuous, + + /** + * --first is a valid iterator position. When this flag is set then the + * flags match_not_bol and match_not_bow are ignored by the regular + * expression algorithms 28.11 and iterators 28.12. + */ + match_prev_avail = 1 << _S_prev_avail, + + /** + * When a regular expression match is to be replaced by a new string, the + * new string is constructed using the rules used by the ECMAScript replace + * function in ECMA- 262 [Ecma International, ECMAScript Language + * Specification, Standard Ecma-262, third edition, 1999], part 15.5.4.11 + * String.prototype.replace. In addition, during search and replace + * operations all non-overlapping occurrences of the regular expression + * are located and replaced, and sections of the input that did not match + * the expression are copied unchanged to the output string. + * + * Format strings (from ECMA-262 [15.5.4.11]): + * @li $$ The dollar-sign itself ($) + * @li $& The matched substring. + * @li $` The portion of @a string that precedes the matched substring. + * This would be match_results::prefix(). + * @li $' The portion of @a string that follows the matched substring. + * This would be match_results::suffix(). + * @li $n The nth capture, where n is in [1,9] and $n is not followed by a + * decimal digit. If n <= match_results::size() and the nth capture + * is undefined, use the empty string instead. If n > + * match_results::size(), the result is implementation-defined. + * @li $nn The nnth capture, where nn is a two-digit decimal number on + * [01, 99]. If nn <= match_results::size() and the nth capture is + * undefined, use the empty string instead. If + * nn > match_results::size(), the result is implementation-defined. + */ + format_default = 0, + + /** + * When a regular expression match is to be replaced by a new string, the + * new string is constructed using the rules used by the POSIX sed utility + * in IEEE Std 1003.1- 2001 [IEEE, Information Technology -- Portable + * Operating System Interface (POSIX), IEEE Standard 1003.1-2001]. + */ + format_sed = 1 << _S_sed, + + /** + * During a search and replace operation, sections of the character + * container sequence being searched that do not match the regular + * expression shall not be copied to the output string. + */ + format_no_copy = 1 << _S_no_copy, + + /** + * When specified during a search and replace operation, only the first + * occurrence of the regular expression shall be replaced. + */ + format_first_only = 1 << _S_first_only, + }; + + constexpr inline match_flag_type + operator&(match_flag_type __a, match_flag_type __b) + { + return (match_flag_type)(static_cast(__a) + & static_cast(__b)); + } + + constexpr inline match_flag_type + operator|(match_flag_type __a, match_flag_type __b) + { + return (match_flag_type)(static_cast(__a) + | static_cast(__b)); + } + + constexpr inline match_flag_type + operator^(match_flag_type __a, match_flag_type __b) + { + return (match_flag_type)(static_cast(__a) + ^ static_cast(__b)); + } + + constexpr inline match_flag_type + operator~(match_flag_type __a) + { return (match_flag_type)(~static_cast(__a)); } + + inline match_flag_type& + operator&=(match_flag_type& __a, match_flag_type __b) + { return __a = __a & __b; } + + inline match_flag_type& + operator|=(match_flag_type& __a, match_flag_type __b) + { return __a = __a | __b; } + + inline match_flag_type& + operator^=(match_flag_type& __a, match_flag_type __b) + { return __a = __a ^ __b; } + + //@} + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace regex_constants + +/* @} */ // group regex +} // namespace std + diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/regex_error.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/regex_error.h new file mode 100755 index 0000000..58dbeb1 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/regex_error.h @@ -0,0 +1,166 @@ +// class template regex -*- C++ -*- + +// Copyright (C) 2010-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** + * @file bits/regex_error.h + * @brief Error and exception objects for the std regex library. + * + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{regex} + */ + +namespace std _GLIBCXX_VISIBILITY(default) +{ +/** + * @addtogroup regex + * @{ + */ + +namespace regex_constants +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /** + * @name 5.3 Error Types + */ + //@{ + + enum error_type + { + _S_error_collate, + _S_error_ctype, + _S_error_escape, + _S_error_backref, + _S_error_brack, + _S_error_paren, + _S_error_brace, + _S_error_badbrace, + _S_error_range, + _S_error_space, + _S_error_badrepeat, + _S_error_complexity, + _S_error_stack, + }; + + /** The expression contained an invalid collating element name. */ + constexpr error_type error_collate(_S_error_collate); + + /** The expression contained an invalid character class name. */ + constexpr error_type error_ctype(_S_error_ctype); + + /** + * The expression contained an invalid escaped character, or a trailing + * escape. + */ + constexpr error_type error_escape(_S_error_escape); + + /** The expression contained an invalid back reference. */ + constexpr error_type error_backref(_S_error_backref); + + /** The expression contained mismatched [ and ]. */ + constexpr error_type error_brack(_S_error_brack); + + /** The expression contained mismatched ( and ). */ + constexpr error_type error_paren(_S_error_paren); + + /** The expression contained mismatched { and } */ + constexpr error_type error_brace(_S_error_brace); + + /** The expression contained an invalid range in a {} expression. */ + constexpr error_type error_badbrace(_S_error_badbrace); + + /** + * The expression contained an invalid character range, + * such as [b-a] in most encodings. + */ + constexpr error_type error_range(_S_error_range); + + /** + * There was insufficient memory to convert the expression into a + * finite state machine. + */ + constexpr error_type error_space(_S_error_space); + + /** + * One of *?+{ was not preceded by a valid regular expression. + */ + constexpr error_type error_badrepeat(_S_error_badrepeat); + + /** + * The complexity of an attempted match against a regular expression + * exceeded a pre-set level. + */ + constexpr error_type error_complexity(_S_error_complexity); + + /** + * There was insufficient memory to determine whether the + * regular expression could match the specified character sequence. + */ + constexpr error_type error_stack(_S_error_stack); + + //@} +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace regex_constants + +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + // [7.8] Class regex_error + /** + * @brief A regular expression exception class. + * @ingroup exceptions + * + * The regular expression library throws objects of this class on error. + */ + class regex_error : public std::runtime_error + { + regex_constants::error_type _M_code; + + public: + /** + * @brief Constructs a regex_error object. + * + * @param __ecode the regex error code. + */ + explicit + regex_error(regex_constants::error_type __ecode); + + virtual ~regex_error() throw(); + + /** + * @brief Gets the regex error code. + * + * @returns the regex error code. + */ + regex_constants::error_type + code() const + { return _M_code; } + }; + + //@} // group regex + + void + __throw_regex_error(regex_constants::error_type __ecode); + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace std diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/regex_executor.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/regex_executor.h new file mode 100755 index 0000000..708c78e --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/regex_executor.h @@ -0,0 +1,167 @@ +// class template regex -*- C++ -*- + +// Copyright (C) 2013-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** + * @file bits/regex_executor.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{regex} + */ + +// FIXME convert comments to doxygen format. + +namespace std _GLIBCXX_VISIBILITY(default) +{ +namespace __detail +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /** + * @addtogroup regex-detail + * @{ + */ + + /** + * @brief Takes a regex and an input string in and + * do the matching. + * + * The %_Executor class has two modes: DFS mode and BFS mode, controlled + * by the template parameter %__dfs_mode. + */ + template + class _Executor + { + public: + typedef typename iterator_traits<_BiIter>::value_type _CharT; + typedef basic_regex<_CharT, _TraitsT> _RegexT; + typedef std::vector, _Alloc> _ResultsVec; + typedef regex_constants::match_flag_type _FlagT; + typedef typename _TraitsT::char_class_type _ClassT; + typedef _NFA<_TraitsT> _NFAT; + + public: + _Executor(_BiIter __begin, + _BiIter __end, + _ResultsVec& __results, + const _RegexT& __re, + _FlagT __flags) + : _M_begin(__begin), + _M_end(__end), + _M_re(__re), + _M_nfa(*__re._M_automaton), + _M_results(__results), + _M_match_queue(__dfs_mode ? nullptr + : new vector>()), + _M_visited(__dfs_mode ? nullptr : new vector(_M_nfa.size())), + _M_flags((__flags & regex_constants::match_prev_avail) + ? (__flags + & ~regex_constants::match_not_bol + & ~regex_constants::match_not_bow) + : __flags), + _M_start_state(_M_nfa._M_start()) + { } + + // Set matched when string exactly match the pattern. + bool + _M_match() + { + _M_current = _M_begin; + return _M_main(); + } + + // Set matched when some prefix of the string matches the pattern. + bool + _M_search_from_first() + { + _M_current = _M_begin; + return _M_main(); + } + + bool + _M_search(); + + private: + template + void + _M_dfs(_StateIdT __start); + + template + bool + _M_main(); + + bool + _M_is_word(_CharT __ch) const + { + static const _CharT __s[2] = { 'w' }; + return _M_re._M_traits.isctype + (__ch, _M_re._M_traits.lookup_classname(__s, __s+1)); + } + + bool + _M_at_begin() const + { + return _M_current == _M_begin + && !(_M_flags & (regex_constants::match_not_bol + | regex_constants::match_prev_avail)); + } + + bool + _M_at_end() const + { + return _M_current == _M_end + && !(_M_flags & regex_constants::match_not_eol); + } + + bool + _M_word_boundary(_State<_TraitsT> __state) const; + + bool + _M_lookahead(_State<_TraitsT> __state); + + public: + _ResultsVec _M_cur_results; + _BiIter _M_current; + const _BiIter _M_begin; + const _BiIter _M_end; + const _RegexT& _M_re; + const _NFAT& _M_nfa; + _ResultsVec& _M_results; + // Used in BFS, saving states that need to be considered for the next + // character. + std::unique_ptr>> _M_match_queue; + // Used in BFS, indicating that which state is already visited. + std::unique_ptr> _M_visited; + _FlagT _M_flags; + // To record current solution. + _StateIdT _M_start_state; + // Do we have a solution so far? + bool _M_has_sol; + }; + + //@} regex-detail +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace __detail +} // namespace std + +#include diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/regex_executor.tcc b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/regex_executor.tcc new file mode 100755 index 0000000..1dc6543 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/regex_executor.tcc @@ -0,0 +1,377 @@ +// class template regex -*- C++ -*- + +// Copyright (C) 2013-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** + * @file bits/regex_executor.tcc + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{regex} + */ + +namespace std _GLIBCXX_VISIBILITY(default) +{ +namespace __detail +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + template + bool _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>:: + _M_search() + { + if (_M_flags & regex_constants::match_continuous) + return _M_search_from_first(); + auto __cur = _M_begin; + do + { + _M_current = __cur; + if (_M_main()) + return true; + } + // Continue when __cur == _M_end + while (__cur++ != _M_end); + return false; + } + + // This function operates in different modes, DFS mode or BFS mode, indicated + // by template parameter __dfs_mode. See _M_main for details. + // + // ------------------------------------------------------------ + // + // DFS mode: + // + // It applies a Depth-First-Search (aka backtracking) on given NFA and input + // string. + // At the very beginning the executor stands in the start state, then it tries + // every possible state transition in current state recursively. Some state + // transitions consume input string, say, a single-char-matcher or a + // back-reference matcher; some don't, like assertion or other anchor nodes. + // When the input is exhausted and/or the current state is an accepting state, + // the whole executor returns true. + // + // TODO: This approach is exponentially slow for certain input. + // Try to compile the NFA to a DFA. + // + // Time complexity: \Omega(match_length), O(2^(_M_nfa.size())) + // Space complexity: \theta(match_results.size() + match_length) + // + // ------------------------------------------------------------ + // + // BFS mode: + // + // Russ Cox's article (http://swtch.com/~rsc/regexp/regexp1.html) + // explained this algorithm clearly. + // + // It first computes epsilon closure (states that can be achieved without + // consuming characters) for every state that's still matching, + // using the same DFS algorithm, but doesn't re-enter states (find a true in + // _M_visited), nor follows _S_opcode_match. + // + // Then apply DFS using every _S_opcode_match (in _M_match_queue) as the start + // state. + // + // It significantly reduces potential duplicate states, so has a better + // upper bound; but it requires more overhead. + // + // Time complexity: \Omega(match_length * match_results.size()) + // O(match_length * _M_nfa.size() * match_results.size()) + // Space complexity: \Omega(_M_nfa.size() + match_results.size()) + // O(_M_nfa.size() * match_results.size()) + template + template + bool _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>:: + _M_main() + { + if (__dfs_mode) + { + _M_has_sol = false; + _M_cur_results = _M_results; + _M_dfs<__match_mode>(_M_start_state); + return _M_has_sol; + } + else + { + _M_match_queue->push_back(make_pair(_M_start_state, _M_results)); + bool __ret = false; + while (1) + { + _M_has_sol = false; + if (_M_match_queue->empty()) + break; + _M_visited->assign(_M_visited->size(), false); + auto __old_queue = std::move(*_M_match_queue); + for (auto& __task : __old_queue) + { + _M_cur_results = std::move(__task.second); + _M_dfs<__match_mode>(__task.first); + } + if (!__match_mode) + __ret |= _M_has_sol; + if (_M_current == _M_end) + break; + ++_M_current; + } + if (__match_mode) + __ret = _M_has_sol; + return __ret; + } + } + + // Return whether now match the given sub-NFA. + template + bool _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>:: + _M_lookahead(_State<_TraitsT> __state) + { + _ResultsVec __what(_M_cur_results.size()); + auto __sub = std::unique_ptr<_Executor>(new _Executor(_M_current, + _M_end, + __what, + _M_re, + _M_flags)); + __sub->_M_start_state = __state._M_alt; + if (__sub->_M_search_from_first()) + { + for (size_t __i = 0; __i < __what.size(); __i++) + if (__what[__i].matched) + _M_cur_results[__i] = __what[__i]; + return true; + } + return false; + } + + // TODO: Use a function vector to dispatch, instead of using switch-case. + template + template + void _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>:: + _M_dfs(_StateIdT __i) + { + if (!__dfs_mode) + { + if ((*_M_visited)[__i]) + return; + (*_M_visited)[__i] = true; + } + + const auto& __state = _M_nfa[__i]; + // Every change on _M_cur_results and _M_current will be rolled back after + // finishing the recursion step. + switch (__state._M_opcode) + { + // _M_alt branch is "match once more", while _M_next is "get me out + // of this quantifier". Executing _M_next first or _M_alt first don't + // mean the same thing, and we need to choose the correct order under + // given greedy mode. + case _S_opcode_alternative: + // Greedy. + if (!__state._M_neg) + { + // "Once more" is preferred in greedy mode. + _M_dfs<__match_mode>(__state._M_alt); + // If it's DFS executor and already accepted, we're done. + if (!__dfs_mode || !_M_has_sol) + _M_dfs<__match_mode>(__state._M_next); + } + else // Non-greedy mode + { + if (__dfs_mode) + { + // vice-versa. + _M_dfs<__match_mode>(__state._M_next); + if (!_M_has_sol) + _M_dfs<__match_mode>(__state._M_alt); + } + else + { + // DON'T attempt anything, because there's already another + // state with higher priority accepted. This state cannot be + // better by attempting its next node. + if (!_M_has_sol) + { + _M_dfs<__match_mode>(__state._M_next); + // DON'T attempt anything if it's already accepted. An + // accepted state *must* be better than a solution that + // matches a non-greedy quantifier one more time. + if (!_M_has_sol) + _M_dfs<__match_mode>(__state._M_alt); + } + } + } + break; + case _S_opcode_subexpr_begin: + // If there's nothing changed since last visit, do NOT continue. + // This prevents the executor from get into infinite loop when using + // "()*" to match "". + if (!_M_cur_results[__state._M_subexpr].matched + || _M_cur_results[__state._M_subexpr].first != _M_current) + { + auto& __res = _M_cur_results[__state._M_subexpr]; + auto __back = __res.first; + __res.first = _M_current; + _M_dfs<__match_mode>(__state._M_next); + __res.first = __back; + } + break; + case _S_opcode_subexpr_end: + if (_M_cur_results[__state._M_subexpr].second != _M_current + || _M_cur_results[__state._M_subexpr].matched != true) + { + auto& __res = _M_cur_results[__state._M_subexpr]; + auto __back = __res; + __res.second = _M_current; + __res.matched = true; + _M_dfs<__match_mode>(__state._M_next); + __res = __back; + } + else + _M_dfs<__match_mode>(__state._M_next); + break; + case _S_opcode_line_begin_assertion: + if (_M_at_begin()) + _M_dfs<__match_mode>(__state._M_next); + break; + case _S_opcode_line_end_assertion: + if (_M_at_end()) + _M_dfs<__match_mode>(__state._M_next); + break; + case _S_opcode_word_boundary: + if (_M_word_boundary(__state) == !__state._M_neg) + _M_dfs<__match_mode>(__state._M_next); + break; + // Here __state._M_alt offers a single start node for a sub-NFA. + // We recursively invoke our algorithm to match the sub-NFA. + case _S_opcode_subexpr_lookahead: + if (_M_lookahead(__state) == !__state._M_neg) + _M_dfs<__match_mode>(__state._M_next); + break; + case _S_opcode_match: + if (_M_current == _M_end) + break; + if (__dfs_mode) + { + if (__state._M_matches(*_M_current)) + { + ++_M_current; + _M_dfs<__match_mode>(__state._M_next); + --_M_current; + } + } + else + if (__state._M_matches(*_M_current)) + _M_match_queue->push_back(make_pair(__state._M_next, + _M_cur_results)); + break; + // First fetch the matched result from _M_cur_results as __submatch; + // then compare it with + // (_M_current, _M_current + (__submatch.second - __submatch.first)). + // If matched, keep going; else just return and try another state. + case _S_opcode_backref: + { + _GLIBCXX_DEBUG_ASSERT(__dfs_mode); + auto& __submatch = _M_cur_results[__state._M_backref_index]; + if (!__submatch.matched) + break; + auto __last = _M_current; + for (auto __tmp = __submatch.first; + __last != _M_end && __tmp != __submatch.second; + ++__tmp) + ++__last; + if (_M_re._M_traits.transform(__submatch.first, + __submatch.second) + == _M_re._M_traits.transform(_M_current, __last)) + { + if (__last != _M_current) + { + auto __backup = _M_current; + _M_current = __last; + _M_dfs<__match_mode>(__state._M_next); + _M_current = __backup; + } + else + _M_dfs<__match_mode>(__state._M_next); + } + } + break; + case _S_opcode_accept: + if (__dfs_mode) + { + _GLIBCXX_DEBUG_ASSERT(!_M_has_sol); + if (__match_mode) + _M_has_sol = _M_current == _M_end; + else + _M_has_sol = true; + if (_M_current == _M_begin + && (_M_flags & regex_constants::match_not_null)) + _M_has_sol = false; + if (_M_has_sol) + _M_results = _M_cur_results; + } + else + { + if (_M_current == _M_begin + && (_M_flags & regex_constants::match_not_null)) + break; + if (!__match_mode || _M_current == _M_end) + if (!_M_has_sol) + { + _M_has_sol = true; + _M_results = _M_cur_results; + } + } + break; + default: + _GLIBCXX_DEBUG_ASSERT(false); + } + } + + // Return whether now is at some word boundary. + template + bool _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>:: + _M_word_boundary(_State<_TraitsT> __state) const + { + bool __left_is_word = false; + if (_M_current != _M_begin + || (_M_flags & regex_constants::match_prev_avail)) + { + auto __prev = _M_current; + if (_M_is_word(*std::prev(__prev))) + __left_is_word = true; + } + bool __right_is_word = + _M_current != _M_end && _M_is_word(*_M_current); + + if (__left_is_word == __right_is_word) + return false; + if (__left_is_word && !(_M_flags & regex_constants::match_not_eow)) + return true; + if (__right_is_word && !(_M_flags & regex_constants::match_not_bow)) + return true; + return false; + } + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace __detail +} // namespace diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/regex_scanner.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/regex_scanner.h new file mode 100755 index 0000000..6627db9 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/regex_scanner.h @@ -0,0 +1,263 @@ +// class template regex -*- C++ -*- + +// Copyright (C) 2013-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** + * @file bits/regex_scanner.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{regex} + */ + +namespace std _GLIBCXX_VISIBILITY(default) +{ +namespace __detail +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /** + * @addtogroup regex-detail + * @{ + */ + + struct _ScannerBase + { + public: + /// Token types returned from the scanner. + enum _TokenT + { + _S_token_anychar, + _S_token_ord_char, + _S_token_oct_num, + _S_token_hex_num, + _S_token_backref, + _S_token_subexpr_begin, + _S_token_subexpr_no_group_begin, + _S_token_subexpr_lookahead_begin, // neg if _M_value[0] == 'n' + _S_token_subexpr_end, + _S_token_bracket_begin, + _S_token_bracket_neg_begin, + _S_token_bracket_end, + _S_token_interval_begin, + _S_token_interval_end, + _S_token_quoted_class, + _S_token_char_class_name, + _S_token_collsymbol, + _S_token_equiv_class_name, + _S_token_opt, + _S_token_or, + _S_token_closure0, + _S_token_closure1, + _S_token_ungreedy, + _S_token_line_begin, + _S_token_line_end, + _S_token_word_bound, // neg if _M_value[0] == 'n' + _S_token_comma, + _S_token_dup_count, + _S_token_eof, + _S_token_unknown + }; + + protected: + typedef regex_constants::syntax_option_type _FlagT; + + enum _StateT + { + _S_state_normal, + _S_state_in_brace, + _S_state_in_bracket, + }; + + protected: + _ScannerBase(_FlagT __flags) + : _M_state(_S_state_normal), + _M_flags(__flags), + _M_escape_tbl(_M_is_ecma() + ? _M_ecma_escape_tbl + : _M_awk_escape_tbl), + _M_spec_char(_M_is_ecma() + ? _M_ecma_spec_char + : _M_is_basic() + ? _M_basic_spec_char + : _M_extended_spec_char), + _M_at_bracket_start(false) + { } + + protected: + const char* + _M_find_escape(char __c) + { + auto __it = _M_escape_tbl; + for (; __it->first != '\0'; ++__it) + if (__it->first == __c) + return &__it->second; + return nullptr; + } + + bool + _M_is_ecma() const + { return _M_flags & regex_constants::ECMAScript; } + + bool + _M_is_basic() const + { return _M_flags & (regex_constants::basic | regex_constants::grep); } + + bool + _M_is_extended() const + { + return _M_flags & (regex_constants::extended + | regex_constants::egrep + | regex_constants::awk); + } + + bool + _M_is_grep() const + { return _M_flags & (regex_constants::grep | regex_constants::egrep); } + + bool + _M_is_awk() const + { return _M_flags & regex_constants::awk; } + + protected: + const std::pair _M_token_tbl[9] = + { + {'^', _S_token_line_begin}, + {'$', _S_token_line_end}, + {'.', _S_token_anychar}, + {'*', _S_token_closure0}, + {'+', _S_token_closure1}, + {'?', _S_token_opt}, + {'|', _S_token_or}, + {'\n', _S_token_or}, // grep and egrep + {'\0', _S_token_or}, + }; + const std::pair _M_ecma_escape_tbl[8] = + { + {'0', '\0'}, + {'b', '\b'}, + {'f', '\f'}, + {'n', '\n'}, + {'r', '\r'}, + {'t', '\t'}, + {'v', '\v'}, + {'\0', '\0'}, + }; + const std::pair _M_awk_escape_tbl[11] = + { + {'"', '"'}, + {'/', '/'}, + {'\\', '\\'}, + {'a', '\a'}, + {'b', '\b'}, + {'f', '\f'}, + {'n', '\n'}, + {'r', '\r'}, + {'t', '\t'}, + {'v', '\v'}, + {'\0', '\0'}, + }; + const char* _M_ecma_spec_char = "^$\\.*+?()[]{}|"; + const char* _M_basic_spec_char = ".[\\*^$"; + const char* _M_extended_spec_char = ".[\\()*+?{|^$"; + + _StateT _M_state; + _FlagT _M_flags; + _TokenT _M_token; + const std::pair* _M_escape_tbl; + const char* _M_spec_char; + bool _M_at_bracket_start; + }; + + /** + * @brief Scans an input range for regex tokens. + * + * The %_Scanner class interprets the regular expression pattern in + * the input range passed to its constructor as a sequence of parse + * tokens passed to the regular expression compiler. The sequence + * of tokens provided depends on the flag settings passed to the + * constructor: different regular expression grammars will interpret + * the same input pattern in syntactically different ways. + */ + template + class _Scanner + : public _ScannerBase + { + public: + typedef const _CharT* _IterT; + typedef std::basic_string<_CharT> _StringT; + typedef regex_constants::syntax_option_type _FlagT; + typedef const std::ctype<_CharT> _CtypeT; + + _Scanner(_IterT __begin, _IterT __end, + _FlagT __flags, std::locale __loc); + + void + _M_advance(); + + _TokenT + _M_get_token() const + { return _M_token; } + + const _StringT& + _M_get_value() const + { return _M_value; } + +#ifdef _GLIBCXX_DEBUG + std::ostream& + _M_print(std::ostream&); +#endif + + private: + void + _M_scan_normal(); + + void + _M_scan_in_bracket(); + + void + _M_scan_in_brace(); + + void + _M_eat_escape_ecma(); + + void + _M_eat_escape_posix(); + + void + _M_eat_escape_awk(); + + void + _M_eat_class(char); + + _IterT _M_current; + _IterT _M_end; + _CtypeT& _M_ctype; + _StringT _M_value; + void (_Scanner::* _M_eat_escape)(); + }; + + //@} regex-detail +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace __detail +} // namespace std + +#include diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/regex_scanner.tcc b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/regex_scanner.tcc new file mode 100755 index 0000000..5332d2e --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/regex_scanner.tcc @@ -0,0 +1,561 @@ +// class template regex -*- C++ -*- + +// Copyright (C) 2013-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** + * @file bits/regex_scanner.tcc + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{regex} + */ + +// FIXME make comments doxygen format. + +// N3376 specified 6 regex styles: ECMAScript, basic, extended, grep, egrep +// and awk +// 1) grep is basic except '\n' is treated as '|' +// 2) egrep is extended except '\n' is treated as '|' +// 3) awk is extended except special escaping rules, and there's no +// back-reference. +// +// References: +// +// ECMAScript: ECMA-262 15.10 +// +// basic, extended: +// http://pubs.opengroup.org/onlinepubs/009695399/basedefs/xbd_chap09.html +// +// awk: http://pubs.opengroup.org/onlinepubs/000095399/utilities/awk.html + +namespace std _GLIBCXX_VISIBILITY(default) +{ +namespace __detail +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + template + _Scanner<_CharT>:: + _Scanner(typename _Scanner::_IterT __begin, + typename _Scanner::_IterT __end, + _FlagT __flags, std::locale __loc) + : _ScannerBase(__flags), + _M_current(__begin), _M_end(__end), + _M_ctype(std::use_facet<_CtypeT>(__loc)), + _M_eat_escape(_M_is_ecma() + ? &_Scanner::_M_eat_escape_ecma + : &_Scanner::_M_eat_escape_posix) + { _M_advance(); } + + template + void + _Scanner<_CharT>:: + _M_advance() + { + if (_M_current == _M_end) + { + _M_token = _S_token_eof; + return; + } + + if (_M_state == _S_state_normal) + _M_scan_normal(); + else if (_M_state == _S_state_in_bracket) + _M_scan_in_bracket(); + else if (_M_state == _S_state_in_brace) + _M_scan_in_brace(); + else + _GLIBCXX_DEBUG_ASSERT(false); + } + + // Differences between styles: + // 1) "\(", "\)", "\{" in basic. It's not escaping. + // 2) "(?:", "(?=", "(?!" in ECMAScript. + template + void + _Scanner<_CharT>:: + _M_scan_normal() + { + auto __c = *_M_current++; + const char* __pos; + + if (__c == '\\') + { + if (_M_current == _M_end) + __throw_regex_error(regex_constants::error_escape); + + if (!_M_is_basic() + || (*_M_current != '(' + && *_M_current != ')' + && *_M_current != '{')) + { + (this->*_M_eat_escape)(); + return; + } + __c = *_M_current++; + } + if (__c == '(') + { + if (_M_is_ecma() && *_M_current == '?') + { + if (++_M_current == _M_end) + __throw_regex_error(regex_constants::error_paren); + + if (*_M_current == ':') + { + ++_M_current; + _M_token = _S_token_subexpr_no_group_begin; + } + else if (*_M_current == '=') + { + ++_M_current; + _M_token = _S_token_subexpr_lookahead_begin; + _M_value.assign(1, 'p'); + } + else if (*_M_current == '!') + { + ++_M_current; + _M_token = _S_token_subexpr_lookahead_begin; + _M_value.assign(1, 'n'); + } + else + __throw_regex_error(regex_constants::error_paren); + } + else if (_M_flags & regex_constants::nosubs) + _M_token = _S_token_subexpr_no_group_begin; + else + _M_token = _S_token_subexpr_begin; + } + else if (__c == ')') + _M_token = _S_token_subexpr_end; + else if (__c == '[') + { + _M_state = _S_state_in_bracket; + _M_at_bracket_start = true; + if (_M_current != _M_end && *_M_current == '^') + { + _M_token = _S_token_bracket_neg_begin; + ++_M_current; + } + else + _M_token = _S_token_bracket_begin; + } + else if (__c == '{') + { + _M_state = _S_state_in_brace; + _M_token = _S_token_interval_begin; + } + else if (((__pos = std::strchr(_M_spec_char, _M_ctype.narrow(__c, '\0'))) + != nullptr + && *__pos != '\0' + && __c != ']' + && __c != '}') + || (_M_is_grep() && __c == '\n')) + { + auto __it = _M_token_tbl; + auto __narrowc = _M_ctype.narrow(__c, '\0'); + for (; __it->first != '\0'; ++__it) + if (__it->first == __narrowc) + { + _M_token = __it->second; + return; + } + _GLIBCXX_DEBUG_ASSERT(false); + } + else + { + _M_token = _S_token_ord_char; + _M_value.assign(1, __c); + } + } + + // Differences between styles: + // 1) different semantics of "[]" and "[^]". + // 2) Escaping in bracket expr. + template + void + _Scanner<_CharT>:: + _M_scan_in_bracket() + { + if (_M_current == _M_end) + __throw_regex_error(regex_constants::error_brack); + + auto __c = *_M_current++; + + if (__c == '[') + { + if (_M_current == _M_end) + __throw_regex_error(regex_constants::error_brack); + + if (*_M_current == '.') + { + _M_token = _S_token_collsymbol; + _M_eat_class(*_M_current++); + } + else if (*_M_current == ':') + { + _M_token = _S_token_char_class_name; + _M_eat_class(*_M_current++); + } + else if (*_M_current == '=') + { + _M_token = _S_token_equiv_class_name; + _M_eat_class(*_M_current++); + } + else + { + _M_token = _S_token_ord_char; + _M_value.assign(1, __c); + } + } + // In POSIX, when encountering "[]" or "[^]", the ']' is interpreted + // literally. So "[]]" or "[^]]" is valid regex. See the testcases + // `*/empty_range.cc`. + else if (__c == ']' && (_M_is_ecma() || !_M_at_bracket_start)) + { + _M_token = _S_token_bracket_end; + _M_state = _S_state_normal; + } + // ECMAScirpt and awk permmits escaping in bracket. + else if (__c == '\\' && (_M_is_ecma() || _M_is_awk())) + (this->*_M_eat_escape)(); + else + { + _M_token = _S_token_ord_char; + _M_value.assign(1, __c); + } + _M_at_bracket_start = false; + } + + // Differences between styles: + // 1) "\}" in basic style. + template + void + _Scanner<_CharT>:: + _M_scan_in_brace() + { + if (_M_current == _M_end) + __throw_regex_error(regex_constants::error_brace); + + auto __c = *_M_current++; + + if (_M_ctype.is(_CtypeT::digit, __c)) + { + _M_token = _S_token_dup_count; + _M_value.assign(1, __c); + while (_M_current != _M_end + && _M_ctype.is(_CtypeT::digit, *_M_current)) + _M_value += *_M_current++; + } + else if (__c == ',') + _M_token = _S_token_comma; + // basic use \}. + else if (_M_is_basic()) + { + if (__c == '\\' && _M_current != _M_end && *_M_current == '}') + { + _M_state = _S_state_normal; + _M_token = _S_token_interval_end; + ++_M_current; + } + else + __throw_regex_error(regex_constants::error_badbrace); + } + else if (__c == '}') + { + _M_state = _S_state_normal; + _M_token = _S_token_interval_end; + } + else + __throw_regex_error(regex_constants::error_badbrace); + } + + template + void + _Scanner<_CharT>:: + _M_eat_escape_ecma() + { + if (_M_current == _M_end) + __throw_regex_error(regex_constants::error_escape); + + auto __c = *_M_current++; + auto __pos = _M_find_escape(_M_ctype.narrow(__c, '\0')); + + if (__pos != nullptr && (__c != 'b' || _M_state == _S_state_in_bracket)) + { + _M_token = _S_token_ord_char; + _M_value.assign(1, *__pos); + } + else if (__c == 'b') + { + _M_token = _S_token_word_bound; + _M_value.assign(1, 'p'); + } + else if (__c == 'B') + { + _M_token = _S_token_word_bound; + _M_value.assign(1, 'n'); + } + // N3376 28.13 + else if (__c == 'd' + || __c == 'D' + || __c == 's' + || __c == 'S' + || __c == 'w' + || __c == 'W') + { + _M_token = _S_token_quoted_class; + _M_value.assign(1, __c); + } + else if (__c == 'c') + { + if (_M_current == _M_end) + __throw_regex_error(regex_constants::error_escape); + _M_token = _S_token_ord_char; + _M_value.assign(1, *_M_current++); + } + else if (__c == 'x' || __c == 'u') + { + _M_value.erase(); + for (int i = 0; i < (__c == 'x' ? 2 : 4); i++) + { + if (_M_current == _M_end + || !_M_ctype.is(_CtypeT::xdigit, *_M_current)) + __throw_regex_error(regex_constants::error_escape); + _M_value += *_M_current++; + } + _M_token = _S_token_hex_num; + } + // ECMAScript recongnizes multi-digit back-references. + else if (_M_ctype.is(_CtypeT::digit, __c)) + { + _M_value.assign(1, __c); + while (_M_current != _M_end + && _M_ctype.is(_CtypeT::digit, *_M_current)) + _M_value += *_M_current++; + _M_token = _S_token_backref; + } + else + { + _M_token = _S_token_ord_char; + _M_value.assign(1, __c); + } + } + + // Differences between styles: + // 1) Extended doesn't support backref, but basic does. + template + void + _Scanner<_CharT>:: + _M_eat_escape_posix() + { + if (_M_current == _M_end) + __throw_regex_error(regex_constants::error_escape); + + auto __c = *_M_current; + auto __pos = std::strchr(_M_spec_char, _M_ctype.narrow(__c, '\0')); + + if (__pos != nullptr && *__pos != '\0') + { + _M_token = _S_token_ord_char; + _M_value.assign(1, __c); + } + // We MUST judge awk before handling backrefs. There's no backref in awk. + else if (_M_is_awk()) + { + _M_eat_escape_awk(); + return; + } + else if (_M_is_basic() && _M_ctype.is(_CtypeT::digit, __c) && __c != '0') + { + _M_token = _S_token_backref; + _M_value.assign(1, __c); + } + else + { +#ifdef __STRICT_ANSI__ + __throw_regex_error(regex_constants::error_escape); +#else + _M_token = _S_token_ord_char; + _M_value.assign(1, __c); +#endif + } + ++_M_current; + } + + template + void + _Scanner<_CharT>:: + _M_eat_escape_awk() + { + auto __c = *_M_current++; + auto __pos = _M_find_escape(_M_ctype.narrow(__c, '\0')); + + if (__pos != nullptr) + { + _M_token = _S_token_ord_char; + _M_value.assign(1, *__pos); + } + // \ddd for oct representation + else if (_M_ctype.is(_CtypeT::digit, __c) + && __c != '8' + && __c != '9') + { + _M_value.assign(1, __c); + for (int __i = 0; + __i < 2 + && _M_current != _M_end + && _M_ctype.is(_CtypeT::digit, *_M_current) + && *_M_current != '8' + && *_M_current != '9'; + __i++) + _M_value += *_M_current++; + _M_token = _S_token_oct_num; + return; + } + else + __throw_regex_error(regex_constants::error_escape); + } + + // Eats a character class or throwns an exception. + // __ch cound be ':', '.' or '=', _M_current is the char after ']' when + // returning. + template + void + _Scanner<_CharT>:: + _M_eat_class(char __ch) + { + for (_M_value.clear(); _M_current != _M_end && *_M_current != __ch;) + _M_value += *_M_current++; + if (_M_current == _M_end + || *_M_current++ != __ch + || _M_current == _M_end // skip __ch + || *_M_current++ != ']') // skip ']' + { + if (__ch == ':') + __throw_regex_error(regex_constants::error_ctype); + else + __throw_regex_error(regex_constants::error_collate); + } + } + +#ifdef _GLIBCXX_DEBUG + template + std::ostream& + _Scanner<_CharT>:: + _M_print(std::ostream& ostr) + { + switch (_M_token) + { + case _S_token_anychar: + ostr << "any-character\n"; + break; + case _S_token_backref: + ostr << "backref\n"; + break; + case _S_token_bracket_begin: + ostr << "bracket-begin\n"; + break; + case _S_token_bracket_neg_begin: + ostr << "bracket-neg-begin\n"; + break; + case _S_token_bracket_end: + ostr << "bracket-end\n"; + break; + case _S_token_char_class_name: + ostr << "char-class-name \"" << _M_value << "\"\n"; + break; + case _S_token_closure0: + ostr << "closure0\n"; + break; + case _S_token_closure1: + ostr << "closure1\n"; + break; + case _S_token_collsymbol: + ostr << "collsymbol \"" << _M_value << "\"\n"; + break; + case _S_token_comma: + ostr << "comma\n"; + break; + case _S_token_dup_count: + ostr << "dup count: " << _M_value << "\n"; + break; + case _S_token_eof: + ostr << "EOF\n"; + break; + case _S_token_equiv_class_name: + ostr << "equiv-class-name \"" << _M_value << "\"\n"; + break; + case _S_token_interval_begin: + ostr << "interval begin\n"; + break; + case _S_token_interval_end: + ostr << "interval end\n"; + break; + case _S_token_line_begin: + ostr << "line begin\n"; + break; + case _S_token_line_end: + ostr << "line end\n"; + break; + case _S_token_opt: + ostr << "opt\n"; + break; + case _S_token_or: + ostr << "or\n"; + break; + case _S_token_ord_char: + ostr << "ordinary character: \"" << _M_value << "\"\n"; + break; + case _S_token_subexpr_begin: + ostr << "subexpr begin\n"; + break; + case _S_token_subexpr_no_group_begin: + ostr << "no grouping subexpr begin\n"; + break; + case _S_token_subexpr_lookahead_begin: + ostr << "lookahead subexpr begin\n"; + break; + case _S_token_subexpr_end: + ostr << "subexpr end\n"; + break; + case _S_token_unknown: + ostr << "-- unknown token --\n"; + break; + case _S_token_oct_num: + ostr << "oct number " << _M_value << "\n"; + break; + case _S_token_hex_num: + ostr << "hex number " << _M_value << "\n"; + break; + case _S_token_quoted_class: + ostr << "quoted class " << "\\" << _M_value << "\n"; + break; + default: + _GLIBCXX_DEBUG_ASSERT(false); + } + return ostr; + } +#endif + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace __detail +} // namespace diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/shared_ptr.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/shared_ptr.h new file mode 100755 index 0000000..081d3bd --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/shared_ptr.h @@ -0,0 +1,622 @@ +// shared_ptr and weak_ptr implementation -*- C++ -*- + +// Copyright (C) 2007-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +// GCC Note: Based on files from version 1.32.0 of the Boost library. + +// shared_count.hpp +// Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd. + +// shared_ptr.hpp +// Copyright (C) 1998, 1999 Greg Colvin and Beman Dawes. +// Copyright (C) 2001, 2002, 2003 Peter Dimov + +// weak_ptr.hpp +// Copyright (C) 2001, 2002, 2003 Peter Dimov + +// enable_shared_from_this.hpp +// Copyright (C) 2002 Peter Dimov + +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +/** @file bits/shared_ptr.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{memory} + */ + +#ifndef _SHARED_PTR_H +#define _SHARED_PTR_H 1 + +#include + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /** + * @addtogroup pointer_abstractions + * @{ + */ + + /// 20.7.2.2.11 shared_ptr I/O + template + inline std::basic_ostream<_Ch, _Tr>& + operator<<(std::basic_ostream<_Ch, _Tr>& __os, + const __shared_ptr<_Tp, _Lp>& __p) + { + __os << __p.get(); + return __os; + } + + /// 20.7.2.2.10 shared_ptr get_deleter + template + inline _Del* + get_deleter(const __shared_ptr<_Tp, _Lp>& __p) noexcept + { +#ifdef __GXX_RTTI + return static_cast<_Del*>(__p._M_get_deleter(typeid(_Del))); +#else + return 0; +#endif + } + + + /** + * @brief A smart pointer with reference-counted copy semantics. + * + * The object pointed to is deleted when the last shared_ptr pointing to + * it is destroyed or reset. + */ + template + class shared_ptr : public __shared_ptr<_Tp> + { + public: + /** + * @brief Construct an empty %shared_ptr. + * @post use_count()==0 && get()==0 + */ + constexpr shared_ptr() noexcept + : __shared_ptr<_Tp>() { } + + shared_ptr(const shared_ptr&) noexcept = default; + + /** + * @brief Construct a %shared_ptr that owns the pointer @a __p. + * @param __p A pointer that is convertible to element_type*. + * @post use_count() == 1 && get() == __p + * @throw std::bad_alloc, in which case @c delete @a __p is called. + */ + template + explicit shared_ptr(_Tp1* __p) + : __shared_ptr<_Tp>(__p) { } + + /** + * @brief Construct a %shared_ptr that owns the pointer @a __p + * and the deleter @a __d. + * @param __p A pointer. + * @param __d A deleter. + * @post use_count() == 1 && get() == __p + * @throw std::bad_alloc, in which case @a __d(__p) is called. + * + * Requirements: _Deleter's copy constructor and destructor must + * not throw + * + * __shared_ptr will release __p by calling __d(__p) + */ + template + shared_ptr(_Tp1* __p, _Deleter __d) + : __shared_ptr<_Tp>(__p, __d) { } + + /** + * @brief Construct a %shared_ptr that owns a null pointer + * and the deleter @a __d. + * @param __p A null pointer constant. + * @param __d A deleter. + * @post use_count() == 1 && get() == __p + * @throw std::bad_alloc, in which case @a __d(__p) is called. + * + * Requirements: _Deleter's copy constructor and destructor must + * not throw + * + * The last owner will call __d(__p) + */ + template + shared_ptr(nullptr_t __p, _Deleter __d) + : __shared_ptr<_Tp>(__p, __d) { } + + /** + * @brief Construct a %shared_ptr that owns the pointer @a __p + * and the deleter @a __d. + * @param __p A pointer. + * @param __d A deleter. + * @param __a An allocator. + * @post use_count() == 1 && get() == __p + * @throw std::bad_alloc, in which case @a __d(__p) is called. + * + * Requirements: _Deleter's copy constructor and destructor must + * not throw _Alloc's copy constructor and destructor must not + * throw. + * + * __shared_ptr will release __p by calling __d(__p) + */ + template + shared_ptr(_Tp1* __p, _Deleter __d, _Alloc __a) + : __shared_ptr<_Tp>(__p, __d, std::move(__a)) { } + + /** + * @brief Construct a %shared_ptr that owns a null pointer + * and the deleter @a __d. + * @param __p A null pointer constant. + * @param __d A deleter. + * @param __a An allocator. + * @post use_count() == 1 && get() == __p + * @throw std::bad_alloc, in which case @a __d(__p) is called. + * + * Requirements: _Deleter's copy constructor and destructor must + * not throw _Alloc's copy constructor and destructor must not + * throw. + * + * The last owner will call __d(__p) + */ + template + shared_ptr(nullptr_t __p, _Deleter __d, _Alloc __a) + : __shared_ptr<_Tp>(__p, __d, std::move(__a)) { } + + // Aliasing constructor + + /** + * @brief Constructs a %shared_ptr instance that stores @a __p + * and shares ownership with @a __r. + * @param __r A %shared_ptr. + * @param __p A pointer that will remain valid while @a *__r is valid. + * @post get() == __p && use_count() == __r.use_count() + * + * This can be used to construct a @c shared_ptr to a sub-object + * of an object managed by an existing @c shared_ptr. + * + * @code + * shared_ptr< pair > pii(new pair()); + * shared_ptr pi(pii, &pii->first); + * assert(pii.use_count() == 2); + * @endcode + */ + template + shared_ptr(const shared_ptr<_Tp1>& __r, _Tp* __p) noexcept + : __shared_ptr<_Tp>(__r, __p) { } + + /** + * @brief If @a __r is empty, constructs an empty %shared_ptr; + * otherwise construct a %shared_ptr that shares ownership + * with @a __r. + * @param __r A %shared_ptr. + * @post get() == __r.get() && use_count() == __r.use_count() + */ + template::value>::type> + shared_ptr(const shared_ptr<_Tp1>& __r) noexcept + : __shared_ptr<_Tp>(__r) { } + + /** + * @brief Move-constructs a %shared_ptr instance from @a __r. + * @param __r A %shared_ptr rvalue. + * @post *this contains the old value of @a __r, @a __r is empty. + */ + shared_ptr(shared_ptr&& __r) noexcept + : __shared_ptr<_Tp>(std::move(__r)) { } + + /** + * @brief Move-constructs a %shared_ptr instance from @a __r. + * @param __r A %shared_ptr rvalue. + * @post *this contains the old value of @a __r, @a __r is empty. + */ + template::value>::type> + shared_ptr(shared_ptr<_Tp1>&& __r) noexcept + : __shared_ptr<_Tp>(std::move(__r)) { } + + /** + * @brief Constructs a %shared_ptr that shares ownership with @a __r + * and stores a copy of the pointer stored in @a __r. + * @param __r A weak_ptr. + * @post use_count() == __r.use_count() + * @throw bad_weak_ptr when __r.expired(), + * in which case the constructor has no effect. + */ + template + explicit shared_ptr(const weak_ptr<_Tp1>& __r) + : __shared_ptr<_Tp>(__r) { } + +#if _GLIBCXX_USE_DEPRECATED + template + shared_ptr(std::auto_ptr<_Tp1>&& __r); +#endif + + template + shared_ptr(std::unique_ptr<_Tp1, _Del>&& __r) + : __shared_ptr<_Tp>(std::move(__r)) { } + + /** + * @brief Construct an empty %shared_ptr. + * @param __p A null pointer constant. + * @post use_count() == 0 && get() == nullptr + */ + constexpr shared_ptr(nullptr_t __p) noexcept + : __shared_ptr<_Tp>(__p) { } + + shared_ptr& operator=(const shared_ptr&) noexcept = default; + + template + shared_ptr& + operator=(const shared_ptr<_Tp1>& __r) noexcept + { + this->__shared_ptr<_Tp>::operator=(__r); + return *this; + } + +#if _GLIBCXX_USE_DEPRECATED + template + shared_ptr& + operator=(std::auto_ptr<_Tp1>&& __r) + { + this->__shared_ptr<_Tp>::operator=(std::move(__r)); + return *this; + } +#endif + + shared_ptr& + operator=(shared_ptr&& __r) noexcept + { + this->__shared_ptr<_Tp>::operator=(std::move(__r)); + return *this; + } + + template + shared_ptr& + operator=(shared_ptr<_Tp1>&& __r) noexcept + { + this->__shared_ptr<_Tp>::operator=(std::move(__r)); + return *this; + } + + template + shared_ptr& + operator=(std::unique_ptr<_Tp1, _Del>&& __r) + { + this->__shared_ptr<_Tp>::operator=(std::move(__r)); + return *this; + } + + private: + // This constructor is non-standard, it is used by allocate_shared. + template + shared_ptr(_Sp_make_shared_tag __tag, const _Alloc& __a, + _Args&&... __args) + : __shared_ptr<_Tp>(__tag, __a, std::forward<_Args>(__args)...) + { } + + template + friend shared_ptr<_Tp1> + allocate_shared(const _Alloc& __a, _Args&&... __args); + + // This constructor is non-standard, it is used by weak_ptr::lock(). + shared_ptr(const weak_ptr<_Tp>& __r, std::nothrow_t) + : __shared_ptr<_Tp>(__r, std::nothrow) { } + + friend class weak_ptr<_Tp>; + }; + + // 20.7.2.2.7 shared_ptr comparisons + template + inline bool + operator==(const shared_ptr<_Tp1>& __a, + const shared_ptr<_Tp2>& __b) noexcept + { return __a.get() == __b.get(); } + + template + inline bool + operator==(const shared_ptr<_Tp>& __a, nullptr_t) noexcept + { return !__a; } + + template + inline bool + operator==(nullptr_t, const shared_ptr<_Tp>& __a) noexcept + { return !__a; } + + template + inline bool + operator!=(const shared_ptr<_Tp1>& __a, + const shared_ptr<_Tp2>& __b) noexcept + { return __a.get() != __b.get(); } + + template + inline bool + operator!=(const shared_ptr<_Tp>& __a, nullptr_t) noexcept + { return (bool)__a; } + + template + inline bool + operator!=(nullptr_t, const shared_ptr<_Tp>& __a) noexcept + { return (bool)__a; } + + template + inline bool + operator<(const shared_ptr<_Tp1>& __a, + const shared_ptr<_Tp2>& __b) noexcept + { + typedef typename std::common_type<_Tp1*, _Tp2*>::type _CT; + return std::less<_CT>()(__a.get(), __b.get()); + } + + template + inline bool + operator<(const shared_ptr<_Tp>& __a, nullptr_t) noexcept + { return std::less<_Tp*>()(__a.get(), nullptr); } + + template + inline bool + operator<(nullptr_t, const shared_ptr<_Tp>& __a) noexcept + { return std::less<_Tp*>()(nullptr, __a.get()); } + + template + inline bool + operator<=(const shared_ptr<_Tp1>& __a, + const shared_ptr<_Tp2>& __b) noexcept + { return !(__b < __a); } + + template + inline bool + operator<=(const shared_ptr<_Tp>& __a, nullptr_t) noexcept + { return !(nullptr < __a); } + + template + inline bool + operator<=(nullptr_t, const shared_ptr<_Tp>& __a) noexcept + { return !(__a < nullptr); } + + template + inline bool + operator>(const shared_ptr<_Tp1>& __a, + const shared_ptr<_Tp2>& __b) noexcept + { return (__b < __a); } + + template + inline bool + operator>(const shared_ptr<_Tp>& __a, nullptr_t) noexcept + { return std::less<_Tp*>()(nullptr, __a.get()); } + + template + inline bool + operator>(nullptr_t, const shared_ptr<_Tp>& __a) noexcept + { return std::less<_Tp*>()(__a.get(), nullptr); } + + template + inline bool + operator>=(const shared_ptr<_Tp1>& __a, + const shared_ptr<_Tp2>& __b) noexcept + { return !(__a < __b); } + + template + inline bool + operator>=(const shared_ptr<_Tp>& __a, nullptr_t) noexcept + { return !(__a < nullptr); } + + template + inline bool + operator>=(nullptr_t, const shared_ptr<_Tp>& __a) noexcept + { return !(nullptr < __a); } + + template + struct less> : public _Sp_less> + { }; + + // 20.7.2.2.8 shared_ptr specialized algorithms. + template + inline void + swap(shared_ptr<_Tp>& __a, shared_ptr<_Tp>& __b) noexcept + { __a.swap(__b); } + + // 20.7.2.2.9 shared_ptr casts. + template + inline shared_ptr<_Tp> + static_pointer_cast(const shared_ptr<_Tp1>& __r) noexcept + { return shared_ptr<_Tp>(__r, static_cast<_Tp*>(__r.get())); } + + template + inline shared_ptr<_Tp> + const_pointer_cast(const shared_ptr<_Tp1>& __r) noexcept + { return shared_ptr<_Tp>(__r, const_cast<_Tp*>(__r.get())); } + + template + inline shared_ptr<_Tp> + dynamic_pointer_cast(const shared_ptr<_Tp1>& __r) noexcept + { + if (_Tp* __p = dynamic_cast<_Tp*>(__r.get())) + return shared_ptr<_Tp>(__r, __p); + return shared_ptr<_Tp>(); + } + + + /** + * @brief A smart pointer with weak semantics. + * + * With forwarding constructors and assignment operators. + */ + template + class weak_ptr : public __weak_ptr<_Tp> + { + public: + constexpr weak_ptr() noexcept + : __weak_ptr<_Tp>() { } + + template::value>::type> + weak_ptr(const weak_ptr<_Tp1>& __r) noexcept + : __weak_ptr<_Tp>(__r) { } + + template::value>::type> + weak_ptr(const shared_ptr<_Tp1>& __r) noexcept + : __weak_ptr<_Tp>(__r) { } + + template + weak_ptr& + operator=(const weak_ptr<_Tp1>& __r) noexcept + { + this->__weak_ptr<_Tp>::operator=(__r); + return *this; + } + + template + weak_ptr& + operator=(const shared_ptr<_Tp1>& __r) noexcept + { + this->__weak_ptr<_Tp>::operator=(__r); + return *this; + } + + shared_ptr<_Tp> + lock() const noexcept + { return shared_ptr<_Tp>(*this, std::nothrow); } + }; + + // 20.7.2.3.6 weak_ptr specialized algorithms. + template + inline void + swap(weak_ptr<_Tp>& __a, weak_ptr<_Tp>& __b) noexcept + { __a.swap(__b); } + + + /// Primary template owner_less + template + struct owner_less; + + /// Partial specialization of owner_less for shared_ptr. + template + struct owner_less> + : public _Sp_owner_less, weak_ptr<_Tp>> + { }; + + /// Partial specialization of owner_less for weak_ptr. + template + struct owner_less> + : public _Sp_owner_less, shared_ptr<_Tp>> + { }; + + /** + * @brief Base class allowing use of member function shared_from_this. + */ + template + class enable_shared_from_this + { + protected: + constexpr enable_shared_from_this() noexcept { } + + enable_shared_from_this(const enable_shared_from_this&) noexcept { } + + enable_shared_from_this& + operator=(const enable_shared_from_this&) noexcept + { return *this; } + + ~enable_shared_from_this() { } + + public: + shared_ptr<_Tp> + shared_from_this() + { return shared_ptr<_Tp>(this->_M_weak_this); } + + shared_ptr + shared_from_this() const + { return shared_ptr(this->_M_weak_this); } + + private: + template + void + _M_weak_assign(_Tp1* __p, const __shared_count<>& __n) const noexcept + { _M_weak_this._M_assign(__p, __n); } + + template + friend void + __enable_shared_from_this_helper(const __shared_count<>& __pn, + const enable_shared_from_this* __pe, + const _Tp1* __px) noexcept + { + if (__pe != 0) + __pe->_M_weak_assign(const_cast<_Tp1*>(__px), __pn); + } + + mutable weak_ptr<_Tp> _M_weak_this; + }; + + /** + * @brief Create an object that is owned by a shared_ptr. + * @param __a An allocator. + * @param __args Arguments for the @a _Tp object's constructor. + * @return A shared_ptr that owns the newly created object. + * @throw An exception thrown from @a _Alloc::allocate or from the + * constructor of @a _Tp. + * + * A copy of @a __a will be used to allocate memory for the shared_ptr + * and the new object. + */ + template + inline shared_ptr<_Tp> + allocate_shared(const _Alloc& __a, _Args&&... __args) + { + return shared_ptr<_Tp>(_Sp_make_shared_tag(), __a, + std::forward<_Args>(__args)...); + } + + /** + * @brief Create an object that is owned by a shared_ptr. + * @param __args Arguments for the @a _Tp object's constructor. + * @return A shared_ptr that owns the newly created object. + * @throw std::bad_alloc, or an exception thrown from the + * constructor of @a _Tp. + */ + template + inline shared_ptr<_Tp> + make_shared(_Args&&... __args) + { + typedef typename std::remove_const<_Tp>::type _Tp_nc; + return std::allocate_shared<_Tp>(std::allocator<_Tp_nc>(), + std::forward<_Args>(__args)...); + } + + /// std::hash specialization for shared_ptr. + template + struct hash> + : public __hash_base> + { + size_t + operator()(const shared_ptr<_Tp>& __s) const noexcept + { return std::hash<_Tp*>()(__s.get()); } + }; + + // @} group pointer_abstractions + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif // _SHARED_PTR_H diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/shared_ptr_base.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/shared_ptr_base.h new file mode 100755 index 0000000..026c597 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/shared_ptr_base.h @@ -0,0 +1,1553 @@ +// shared_ptr and weak_ptr implementation details -*- C++ -*- + +// Copyright (C) 2007-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +// GCC Note: Based on files from version 1.32.0 of the Boost library. + +// shared_count.hpp +// Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd. + +// shared_ptr.hpp +// Copyright (C) 1998, 1999 Greg Colvin and Beman Dawes. +// Copyright (C) 2001, 2002, 2003 Peter Dimov + +// weak_ptr.hpp +// Copyright (C) 2001, 2002, 2003 Peter Dimov + +// enable_shared_from_this.hpp +// Copyright (C) 2002 Peter Dimov + +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +/** @file bits/shared_ptr_base.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{memory} + */ + +#ifndef _SHARED_PTR_BASE_H +#define _SHARED_PTR_BASE_H 1 + +#include + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + +#if _GLIBCXX_USE_DEPRECATED + template class auto_ptr; +#endif + + /** + * @brief Exception possibly thrown by @c shared_ptr. + * @ingroup exceptions + */ + class bad_weak_ptr : public std::exception + { + public: + virtual char const* + what() const noexcept; + + virtual ~bad_weak_ptr() noexcept; + }; + + // Substitute for bad_weak_ptr object in the case of -fno-exceptions. + inline void + __throw_bad_weak_ptr() + { _GLIBCXX_THROW_OR_ABORT(bad_weak_ptr()); } + + using __gnu_cxx::_Lock_policy; + using __gnu_cxx::__default_lock_policy; + using __gnu_cxx::_S_single; + using __gnu_cxx::_S_mutex; + using __gnu_cxx::_S_atomic; + + // Empty helper class except when the template argument is _S_mutex. + template<_Lock_policy _Lp> + class _Mutex_base + { + protected: + // The atomic policy uses fully-fenced builtins, single doesn't care. + enum { _S_need_barriers = 0 }; + }; + + template<> + class _Mutex_base<_S_mutex> + : public __gnu_cxx::__mutex + { + protected: + // This policy is used when atomic builtins are not available. + // The replacement atomic operations might not have the necessary + // memory barriers. + enum { _S_need_barriers = 1 }; + }; + + template<_Lock_policy _Lp = __default_lock_policy> + class _Sp_counted_base + : public _Mutex_base<_Lp> + { + public: + _Sp_counted_base() noexcept + : _M_use_count(1), _M_weak_count(1) { } + + virtual + ~_Sp_counted_base() noexcept + { } + + // Called when _M_use_count drops to zero, to release the resources + // managed by *this. + virtual void + _M_dispose() noexcept = 0; + + // Called when _M_weak_count drops to zero. + virtual void + _M_destroy() noexcept + { delete this; } + + virtual void* + _M_get_deleter(const std::type_info&) noexcept = 0; + + void + _M_add_ref_copy() + { __gnu_cxx::__atomic_add_dispatch(&_M_use_count, 1); } + + void + _M_add_ref_lock(); + + bool + _M_add_ref_lock_nothrow(); + + void + _M_release() noexcept + { + // Be race-detector-friendly. For more info see bits/c++config. + _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_use_count); + if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, -1) == 1) + { + _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_use_count); + _M_dispose(); + // There must be a memory barrier between dispose() and destroy() + // to ensure that the effects of dispose() are observed in the + // thread that runs destroy(). + // See http://gcc.gnu.org/ml/libstdc++/2005-11/msg00136.html + if (_Mutex_base<_Lp>::_S_need_barriers) + { + _GLIBCXX_READ_MEM_BARRIER; + _GLIBCXX_WRITE_MEM_BARRIER; + } + + // Be race-detector-friendly. For more info see bits/c++config. + _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_weak_count); + if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count, + -1) == 1) + { + _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_weak_count); + _M_destroy(); + } + } + } + + void + _M_weak_add_ref() noexcept + { __gnu_cxx::__atomic_add_dispatch(&_M_weak_count, 1); } + + void + _M_weak_release() noexcept + { + // Be race-detector-friendly. For more info see bits/c++config. + _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_weak_count); + if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count, -1) == 1) + { + _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_weak_count); + if (_Mutex_base<_Lp>::_S_need_barriers) + { + // See _M_release(), + // destroy() must observe results of dispose() + _GLIBCXX_READ_MEM_BARRIER; + _GLIBCXX_WRITE_MEM_BARRIER; + } + _M_destroy(); + } + } + + long + _M_get_use_count() const noexcept + { + // No memory barrier is used here so there is no synchronization + // with other threads. + return __atomic_load_n(&_M_use_count, __ATOMIC_RELAXED); + } + + private: + _Sp_counted_base(_Sp_counted_base const&) = delete; + _Sp_counted_base& operator=(_Sp_counted_base const&) = delete; + + _Atomic_word _M_use_count; // #shared + _Atomic_word _M_weak_count; // #weak + (#shared != 0) + }; + + template<> + inline void + _Sp_counted_base<_S_single>:: + _M_add_ref_lock() + { + if (_M_use_count == 0) + __throw_bad_weak_ptr(); + ++_M_use_count; + } + + template<> + inline void + _Sp_counted_base<_S_mutex>:: + _M_add_ref_lock() + { + __gnu_cxx::__scoped_lock sentry(*this); + if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, 1) == 0) + { + _M_use_count = 0; + __throw_bad_weak_ptr(); + } + } + + template<> + inline void + _Sp_counted_base<_S_atomic>:: + _M_add_ref_lock() + { + // Perform lock-free add-if-not-zero operation. + _Atomic_word __count = _M_get_use_count(); + do + { + if (__count == 0) + __throw_bad_weak_ptr(); + // Replace the current counter value with the old value + 1, as + // long as it's not changed meanwhile. + } + while (!__atomic_compare_exchange_n(&_M_use_count, &__count, __count + 1, + true, __ATOMIC_ACQ_REL, + __ATOMIC_RELAXED)); + } + + template<> + inline bool + _Sp_counted_base<_S_single>:: + _M_add_ref_lock_nothrow() + { + if (_M_use_count == 0) + return false; + ++_M_use_count; + return true; + } + + template<> + inline bool + _Sp_counted_base<_S_mutex>:: + _M_add_ref_lock_nothrow() + { + __gnu_cxx::__scoped_lock sentry(*this); + if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, 1) == 0) + { + _M_use_count = 0; + return false; + } + return true; + } + + template<> + inline bool + _Sp_counted_base<_S_atomic>:: + _M_add_ref_lock_nothrow() + { + // Perform lock-free add-if-not-zero operation. + _Atomic_word __count = _M_get_use_count(); + do + { + if (__count == 0) + return false; + // Replace the current counter value with the old value + 1, as + // long as it's not changed meanwhile. + } + while (!__atomic_compare_exchange_n(&_M_use_count, &__count, __count + 1, + true, __ATOMIC_ACQ_REL, + __ATOMIC_RELAXED)); + return true; + } + + template<> + inline void + _Sp_counted_base<_S_single>::_M_add_ref_copy() + { ++_M_use_count; } + + template<> + inline void + _Sp_counted_base<_S_single>::_M_release() noexcept + { + if (--_M_use_count == 0) + { + _M_dispose(); + if (--_M_weak_count == 0) + _M_destroy(); + } + } + + template<> + inline void + _Sp_counted_base<_S_single>::_M_weak_add_ref() noexcept + { ++_M_weak_count; } + + template<> + inline void + _Sp_counted_base<_S_single>::_M_weak_release() noexcept + { + if (--_M_weak_count == 0) + _M_destroy(); + } + + template<> + inline long + _Sp_counted_base<_S_single>::_M_get_use_count() const noexcept + { return _M_use_count; } + + + // Forward declarations. + template + class __shared_ptr; + + template + class __weak_ptr; + + template + class __enable_shared_from_this; + + template + class shared_ptr; + + template + class weak_ptr; + + template + struct owner_less; + + template + class enable_shared_from_this; + + template<_Lock_policy _Lp = __default_lock_policy> + class __weak_count; + + template<_Lock_policy _Lp = __default_lock_policy> + class __shared_count; + + + // Counted ptr with no deleter or allocator support + template + class _Sp_counted_ptr final : public _Sp_counted_base<_Lp> + { + public: + explicit + _Sp_counted_ptr(_Ptr __p) noexcept + : _M_ptr(__p) { } + + virtual void + _M_dispose() noexcept + { delete _M_ptr; } + + virtual void + _M_destroy() noexcept + { delete this; } + + virtual void* + _M_get_deleter(const std::type_info&) noexcept + { return nullptr; } + + _Sp_counted_ptr(const _Sp_counted_ptr&) = delete; + _Sp_counted_ptr& operator=(const _Sp_counted_ptr&) = delete; + + private: + _Ptr _M_ptr; + }; + + template<> + inline void + _Sp_counted_ptr::_M_dispose() noexcept { } + + template<> + inline void + _Sp_counted_ptr::_M_dispose() noexcept { } + + template<> + inline void + _Sp_counted_ptr::_M_dispose() noexcept { } + + template + struct _Sp_ebo_helper; + + /// Specialization using EBO. + template + struct _Sp_ebo_helper<_Nm, _Tp, true> : private _Tp + { + explicit _Sp_ebo_helper(const _Tp& __tp) : _Tp(__tp) { } + + static _Tp& + _S_get(_Sp_ebo_helper& __eboh) { return static_cast<_Tp&>(__eboh); } + }; + + /// Specialization not using EBO. + template + struct _Sp_ebo_helper<_Nm, _Tp, false> + { + explicit _Sp_ebo_helper(const _Tp& __tp) : _M_tp(__tp) { } + + static _Tp& + _S_get(_Sp_ebo_helper& __eboh) + { return __eboh._M_tp; } + + private: + _Tp _M_tp; + }; + + // Support for custom deleter and/or allocator + template + class _Sp_counted_deleter final : public _Sp_counted_base<_Lp> + { + class _Impl : _Sp_ebo_helper<0, _Deleter>, _Sp_ebo_helper<1, _Alloc> + { + typedef _Sp_ebo_helper<0, _Deleter> _Del_base; + typedef _Sp_ebo_helper<1, _Alloc> _Alloc_base; + + public: + _Impl(_Ptr __p, _Deleter __d, const _Alloc& __a) noexcept + : _M_ptr(__p), _Del_base(__d), _Alloc_base(__a) + { } + + _Deleter& _M_del() noexcept { return _Del_base::_S_get(*this); } + _Alloc& _M_alloc() noexcept { return _Alloc_base::_S_get(*this); } + + _Ptr _M_ptr; + }; + + public: + // __d(__p) must not throw. + _Sp_counted_deleter(_Ptr __p, _Deleter __d) noexcept + : _M_impl(__p, __d, _Alloc()) { } + + // __d(__p) must not throw. + _Sp_counted_deleter(_Ptr __p, _Deleter __d, const _Alloc& __a) noexcept + : _M_impl(__p, __d, __a) { } + + ~_Sp_counted_deleter() noexcept { } + + virtual void + _M_dispose() noexcept + { _M_impl._M_del()(_M_impl._M_ptr); } + + virtual void + _M_destroy() noexcept + { + typedef typename allocator_traits<_Alloc>::template + rebind_traits<_Sp_counted_deleter> _Alloc_traits; + typename _Alloc_traits::allocator_type __a(_M_impl._M_alloc()); + _Alloc_traits::destroy(__a, this); + _Alloc_traits::deallocate(__a, this, 1); + } + + virtual void* + _M_get_deleter(const std::type_info& __ti) noexcept + { +#ifdef __GXX_RTTI + return __ti == typeid(_Deleter) ? &_M_impl._M_del() : nullptr; +#else + return nullptr; +#endif + } + + private: + _Impl _M_impl; + }; + + // helpers for make_shared / allocate_shared + + struct _Sp_make_shared_tag { }; + + template + class _Sp_counted_ptr_inplace final : public _Sp_counted_base<_Lp> + { + class _Impl : _Sp_ebo_helper<0, _Alloc> + { + typedef _Sp_ebo_helper<0, _Alloc> _A_base; + + public: + explicit _Impl(_Alloc __a) noexcept : _A_base(__a) { } + + _Alloc& _M_alloc() noexcept { return _A_base::_S_get(*this); } + + __gnu_cxx::__aligned_buffer<_Tp> _M_storage; + }; + + public: + template + _Sp_counted_ptr_inplace(_Alloc __a, _Args&&... __args) + : _M_impl(__a) + { + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 2070. allocate_shared should use allocator_traits::construct + allocator_traits<_Alloc>::construct(__a, _M_ptr(), + std::forward<_Args>(__args)...); // might throw + } + + ~_Sp_counted_ptr_inplace() noexcept { } + + virtual void + _M_dispose() noexcept + { + allocator_traits<_Alloc>::destroy(_M_impl._M_alloc(), _M_ptr()); + } + + // Override because the allocator needs to know the dynamic type + virtual void + _M_destroy() noexcept + { + typedef typename allocator_traits<_Alloc>::template + rebind_traits<_Sp_counted_ptr_inplace> _Alloc_traits; + typename _Alloc_traits::allocator_type __a(_M_impl._M_alloc()); + _Alloc_traits::destroy(__a, this); + _Alloc_traits::deallocate(__a, this, 1); + } + + // Sneaky trick so __shared_ptr can get the managed pointer + virtual void* + _M_get_deleter(const std::type_info& __ti) noexcept + { +#ifdef __GXX_RTTI + if (__ti == typeid(_Sp_make_shared_tag)) + return const_cast::type*>(_M_ptr()); +#endif + return nullptr; + } + + private: + _Tp* _M_ptr() noexcept { return _M_impl._M_storage._M_ptr(); } + + _Impl _M_impl; + }; + + + template<_Lock_policy _Lp> + class __shared_count + { + public: + constexpr __shared_count() noexcept : _M_pi(0) + { } + + template + explicit + __shared_count(_Ptr __p) : _M_pi(0) + { + __try + { + _M_pi = new _Sp_counted_ptr<_Ptr, _Lp>(__p); + } + __catch(...) + { + delete __p; + __throw_exception_again; + } + } + + template + __shared_count(_Ptr __p, _Deleter __d) + : __shared_count(__p, std::move(__d), allocator()) + { } + + template + __shared_count(_Ptr __p, _Deleter __d, _Alloc __a) : _M_pi(0) + { + typedef _Sp_counted_deleter<_Ptr, _Deleter, _Alloc, _Lp> _Sp_cd_type; + typedef typename allocator_traits<_Alloc>::template + rebind_traits<_Sp_cd_type> _Alloc_traits; + typename _Alloc_traits::allocator_type __a2(__a); + _Sp_cd_type* __mem = 0; + __try + { + __mem = _Alloc_traits::allocate(__a2, 1); + _Alloc_traits::construct(__a2, __mem, + __p, std::move(__d), std::move(__a)); + _M_pi = __mem; + } + __catch(...) + { + __d(__p); // Call _Deleter on __p. + if (__mem) + _Alloc_traits::deallocate(__a2, __mem, 1); + __throw_exception_again; + } + } + + template + __shared_count(_Sp_make_shared_tag, _Tp*, const _Alloc& __a, + _Args&&... __args) + : _M_pi(0) + { + typedef _Sp_counted_ptr_inplace<_Tp, _Alloc, _Lp> _Sp_cp_type; + typedef typename allocator_traits<_Alloc>::template + rebind_traits<_Sp_cp_type> _Alloc_traits; + typename _Alloc_traits::allocator_type __a2(__a); + _Sp_cp_type* __mem = _Alloc_traits::allocate(__a2, 1); + __try + { + _Alloc_traits::construct(__a2, __mem, std::move(__a), + std::forward<_Args>(__args)...); + _M_pi = __mem; + } + __catch(...) + { + _Alloc_traits::deallocate(__a2, __mem, 1); + __throw_exception_again; + } + } + +#if _GLIBCXX_USE_DEPRECATED + // Special case for auto_ptr<_Tp> to provide the strong guarantee. + template + explicit + __shared_count(std::auto_ptr<_Tp>&& __r); +#endif + + // Special case for unique_ptr<_Tp,_Del> to provide the strong guarantee. + template + explicit + __shared_count(std::unique_ptr<_Tp, _Del>&& __r) : _M_pi(0) + { + using _Ptr = typename unique_ptr<_Tp, _Del>::pointer; + using _Del2 = typename conditional::value, + reference_wrapper::type>, + _Del>::type; + using _Sp_cd_type + = _Sp_counted_deleter<_Ptr, _Del2, allocator, _Lp>; + using _Alloc = allocator<_Sp_cd_type>; + using _Alloc_traits = allocator_traits<_Alloc>; + _Alloc __a; + _Sp_cd_type* __mem = _Alloc_traits::allocate(__a, 1); + _Alloc_traits::construct(__a, __mem, __r.release(), + __r.get_deleter()); // non-throwing + _M_pi = __mem; + } + + // Throw bad_weak_ptr when __r._M_get_use_count() == 0. + explicit __shared_count(const __weak_count<_Lp>& __r); + + // Does not throw if __r._M_get_use_count() == 0, caller must check. + explicit __shared_count(const __weak_count<_Lp>& __r, std::nothrow_t); + + ~__shared_count() noexcept + { + if (_M_pi != nullptr) + _M_pi->_M_release(); + } + + __shared_count(const __shared_count& __r) noexcept + : _M_pi(__r._M_pi) + { + if (_M_pi != 0) + _M_pi->_M_add_ref_copy(); + } + + __shared_count& + operator=(const __shared_count& __r) noexcept + { + _Sp_counted_base<_Lp>* __tmp = __r._M_pi; + if (__tmp != _M_pi) + { + if (__tmp != 0) + __tmp->_M_add_ref_copy(); + if (_M_pi != 0) + _M_pi->_M_release(); + _M_pi = __tmp; + } + return *this; + } + + void + _M_swap(__shared_count& __r) noexcept + { + _Sp_counted_base<_Lp>* __tmp = __r._M_pi; + __r._M_pi = _M_pi; + _M_pi = __tmp; + } + + long + _M_get_use_count() const noexcept + { return _M_pi != 0 ? _M_pi->_M_get_use_count() : 0; } + + bool + _M_unique() const noexcept + { return this->_M_get_use_count() == 1; } + + void* + _M_get_deleter(const std::type_info& __ti) const noexcept + { return _M_pi ? _M_pi->_M_get_deleter(__ti) : nullptr; } + + bool + _M_less(const __shared_count& __rhs) const noexcept + { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); } + + bool + _M_less(const __weak_count<_Lp>& __rhs) const noexcept + { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); } + + // Friend function injected into enclosing namespace and found by ADL + friend inline bool + operator==(const __shared_count& __a, const __shared_count& __b) noexcept + { return __a._M_pi == __b._M_pi; } + + private: + friend class __weak_count<_Lp>; + + _Sp_counted_base<_Lp>* _M_pi; + }; + + + template<_Lock_policy _Lp> + class __weak_count + { + public: + constexpr __weak_count() noexcept : _M_pi(0) + { } + + __weak_count(const __shared_count<_Lp>& __r) noexcept + : _M_pi(__r._M_pi) + { + if (_M_pi != 0) + _M_pi->_M_weak_add_ref(); + } + + __weak_count(const __weak_count<_Lp>& __r) noexcept + : _M_pi(__r._M_pi) + { + if (_M_pi != 0) + _M_pi->_M_weak_add_ref(); + } + + ~__weak_count() noexcept + { + if (_M_pi != 0) + _M_pi->_M_weak_release(); + } + + __weak_count<_Lp>& + operator=(const __shared_count<_Lp>& __r) noexcept + { + _Sp_counted_base<_Lp>* __tmp = __r._M_pi; + if (__tmp != 0) + __tmp->_M_weak_add_ref(); + if (_M_pi != 0) + _M_pi->_M_weak_release(); + _M_pi = __tmp; + return *this; + } + + __weak_count<_Lp>& + operator=(const __weak_count<_Lp>& __r) noexcept + { + _Sp_counted_base<_Lp>* __tmp = __r._M_pi; + if (__tmp != 0) + __tmp->_M_weak_add_ref(); + if (_M_pi != 0) + _M_pi->_M_weak_release(); + _M_pi = __tmp; + return *this; + } + + void + _M_swap(__weak_count<_Lp>& __r) noexcept + { + _Sp_counted_base<_Lp>* __tmp = __r._M_pi; + __r._M_pi = _M_pi; + _M_pi = __tmp; + } + + long + _M_get_use_count() const noexcept + { return _M_pi != 0 ? _M_pi->_M_get_use_count() : 0; } + + bool + _M_less(const __weak_count& __rhs) const noexcept + { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); } + + bool + _M_less(const __shared_count<_Lp>& __rhs) const noexcept + { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); } + + // Friend function injected into enclosing namespace and found by ADL + friend inline bool + operator==(const __weak_count& __a, const __weak_count& __b) noexcept + { return __a._M_pi == __b._M_pi; } + + private: + friend class __shared_count<_Lp>; + + _Sp_counted_base<_Lp>* _M_pi; + }; + + // Now that __weak_count is defined we can define this constructor: + template<_Lock_policy _Lp> + inline + __shared_count<_Lp>::__shared_count(const __weak_count<_Lp>& __r) + : _M_pi(__r._M_pi) + { + if (_M_pi != nullptr) + _M_pi->_M_add_ref_lock(); + else + __throw_bad_weak_ptr(); + } + + // Now that __weak_count is defined we can define this constructor: + template<_Lock_policy _Lp> + inline + __shared_count<_Lp>:: + __shared_count(const __weak_count<_Lp>& __r, std::nothrow_t) + : _M_pi(__r._M_pi) + { + if (_M_pi != nullptr) + if (!_M_pi->_M_add_ref_lock_nothrow()) + _M_pi = nullptr; + } + + // Support for enable_shared_from_this. + + // Friend of __enable_shared_from_this. + template<_Lock_policy _Lp, typename _Tp1, typename _Tp2> + void + __enable_shared_from_this_helper(const __shared_count<_Lp>&, + const __enable_shared_from_this<_Tp1, + _Lp>*, const _Tp2*) noexcept; + + // Friend of enable_shared_from_this. + template + void + __enable_shared_from_this_helper(const __shared_count<>&, + const enable_shared_from_this<_Tp1>*, + const _Tp2*) noexcept; + + template<_Lock_policy _Lp> + inline void + __enable_shared_from_this_helper(const __shared_count<_Lp>&, ...) noexcept + { } + + + template + class __shared_ptr + { + public: + typedef _Tp element_type; + + constexpr __shared_ptr() noexcept + : _M_ptr(0), _M_refcount() + { } + + template + explicit __shared_ptr(_Tp1* __p) + : _M_ptr(__p), _M_refcount(__p) + { + __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>) + static_assert( !is_void<_Tp1>::value, "incomplete type" ); + static_assert( sizeof(_Tp1) > 0, "incomplete type" ); + __enable_shared_from_this_helper(_M_refcount, __p, __p); + } + + template + __shared_ptr(_Tp1* __p, _Deleter __d) + : _M_ptr(__p), _M_refcount(__p, __d) + { + __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>) + // TODO requires _Deleter CopyConstructible and __d(__p) well-formed + __enable_shared_from_this_helper(_M_refcount, __p, __p); + } + + template + __shared_ptr(_Tp1* __p, _Deleter __d, _Alloc __a) + : _M_ptr(__p), _M_refcount(__p, __d, std::move(__a)) + { + __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>) + // TODO requires _Deleter CopyConstructible and __d(__p) well-formed + __enable_shared_from_this_helper(_M_refcount, __p, __p); + } + + template + __shared_ptr(nullptr_t __p, _Deleter __d) + : _M_ptr(0), _M_refcount(__p, __d) + { } + + template + __shared_ptr(nullptr_t __p, _Deleter __d, _Alloc __a) + : _M_ptr(0), _M_refcount(__p, __d, std::move(__a)) + { } + + template + __shared_ptr(const __shared_ptr<_Tp1, _Lp>& __r, _Tp* __p) noexcept + : _M_ptr(__p), _M_refcount(__r._M_refcount) // never throws + { } + + __shared_ptr(const __shared_ptr&) noexcept = default; + __shared_ptr& operator=(const __shared_ptr&) noexcept = default; + ~__shared_ptr() = default; + + template::value>::type> + __shared_ptr(const __shared_ptr<_Tp1, _Lp>& __r) noexcept + : _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount) + { } + + __shared_ptr(__shared_ptr&& __r) noexcept + : _M_ptr(__r._M_ptr), _M_refcount() + { + _M_refcount._M_swap(__r._M_refcount); + __r._M_ptr = 0; + } + + template::value>::type> + __shared_ptr(__shared_ptr<_Tp1, _Lp>&& __r) noexcept + : _M_ptr(__r._M_ptr), _M_refcount() + { + _M_refcount._M_swap(__r._M_refcount); + __r._M_ptr = 0; + } + + template + explicit __shared_ptr(const __weak_ptr<_Tp1, _Lp>& __r) + : _M_refcount(__r._M_refcount) // may throw + { + __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>) + + // It is now safe to copy __r._M_ptr, as + // _M_refcount(__r._M_refcount) did not throw. + _M_ptr = __r._M_ptr; + } + + // If an exception is thrown this constructor has no effect. + template + __shared_ptr(std::unique_ptr<_Tp1, _Del>&& __r) + : _M_ptr(__r.get()), _M_refcount() + { + __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>) + auto __raw = _S_raw_ptr(__r.get()); + _M_refcount = __shared_count<_Lp>(std::move(__r)); + __enable_shared_from_this_helper(_M_refcount, __raw, __raw); + } + +#if _GLIBCXX_USE_DEPRECATED + // Postcondition: use_count() == 1 and __r.get() == 0 + template + __shared_ptr(std::auto_ptr<_Tp1>&& __r); +#endif + + /* TODO: use delegating constructor */ + constexpr __shared_ptr(nullptr_t) noexcept + : _M_ptr(0), _M_refcount() + { } + + template + __shared_ptr& + operator=(const __shared_ptr<_Tp1, _Lp>& __r) noexcept + { + _M_ptr = __r._M_ptr; + _M_refcount = __r._M_refcount; // __shared_count::op= doesn't throw + return *this; + } + +#if _GLIBCXX_USE_DEPRECATED + template + __shared_ptr& + operator=(std::auto_ptr<_Tp1>&& __r) + { + __shared_ptr(std::move(__r)).swap(*this); + return *this; + } +#endif + + __shared_ptr& + operator=(__shared_ptr&& __r) noexcept + { + __shared_ptr(std::move(__r)).swap(*this); + return *this; + } + + template + __shared_ptr& + operator=(__shared_ptr<_Tp1, _Lp>&& __r) noexcept + { + __shared_ptr(std::move(__r)).swap(*this); + return *this; + } + + template + __shared_ptr& + operator=(std::unique_ptr<_Tp1, _Del>&& __r) + { + __shared_ptr(std::move(__r)).swap(*this); + return *this; + } + + void + reset() noexcept + { __shared_ptr().swap(*this); } + + template + void + reset(_Tp1* __p) // _Tp1 must be complete. + { + // Catch self-reset errors. + _GLIBCXX_DEBUG_ASSERT(__p == 0 || __p != _M_ptr); + __shared_ptr(__p).swap(*this); + } + + template + void + reset(_Tp1* __p, _Deleter __d) + { __shared_ptr(__p, __d).swap(*this); } + + template + void + reset(_Tp1* __p, _Deleter __d, _Alloc __a) + { __shared_ptr(__p, __d, std::move(__a)).swap(*this); } + + // Allow class instantiation when _Tp is [cv-qual] void. + typename std::add_lvalue_reference<_Tp>::type + operator*() const noexcept + { + _GLIBCXX_DEBUG_ASSERT(_M_ptr != 0); + return *_M_ptr; + } + + _Tp* + operator->() const noexcept + { + _GLIBCXX_DEBUG_ASSERT(_M_ptr != 0); + return _M_ptr; + } + + _Tp* + get() const noexcept + { return _M_ptr; } + + explicit operator bool() const // never throws + { return _M_ptr == 0 ? false : true; } + + bool + unique() const noexcept + { return _M_refcount._M_unique(); } + + long + use_count() const noexcept + { return _M_refcount._M_get_use_count(); } + + void + swap(__shared_ptr<_Tp, _Lp>& __other) noexcept + { + std::swap(_M_ptr, __other._M_ptr); + _M_refcount._M_swap(__other._M_refcount); + } + + template + bool + owner_before(__shared_ptr<_Tp1, _Lp> const& __rhs) const + { return _M_refcount._M_less(__rhs._M_refcount); } + + template + bool + owner_before(__weak_ptr<_Tp1, _Lp> const& __rhs) const + { return _M_refcount._M_less(__rhs._M_refcount); } + +#ifdef __GXX_RTTI + protected: + // This constructor is non-standard, it is used by allocate_shared. + template + __shared_ptr(_Sp_make_shared_tag __tag, const _Alloc& __a, + _Args&&... __args) + : _M_ptr(), _M_refcount(__tag, (_Tp*)0, __a, + std::forward<_Args>(__args)...) + { + // _M_ptr needs to point to the newly constructed object. + // This relies on _Sp_counted_ptr_inplace::_M_get_deleter. + void* __p = _M_refcount._M_get_deleter(typeid(__tag)); + _M_ptr = static_cast<_Tp*>(__p); + __enable_shared_from_this_helper(_M_refcount, _M_ptr, _M_ptr); + } +#else + template + struct _Deleter + { + void operator()(_Tp* __ptr) + { + typedef allocator_traits<_Alloc> _Alloc_traits; + _Alloc_traits::destroy(_M_alloc, __ptr); + _Alloc_traits::deallocate(_M_alloc, __ptr, 1); + } + _Alloc _M_alloc; + }; + + template + __shared_ptr(_Sp_make_shared_tag __tag, const _Alloc& __a, + _Args&&... __args) + : _M_ptr(), _M_refcount() + { + typedef typename _Alloc::template rebind<_Tp>::other _Alloc2; + _Deleter<_Alloc2> __del = { _Alloc2(__a) }; + typedef allocator_traits<_Alloc2> __traits; + _M_ptr = __traits::allocate(__del._M_alloc, 1); + __try + { + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 2070. allocate_shared should use allocator_traits::construct + __traits::construct(__del._M_alloc, _M_ptr, + std::forward<_Args>(__args)...); + } + __catch(...) + { + __traits::deallocate(__del._M_alloc, _M_ptr, 1); + __throw_exception_again; + } + __shared_count<_Lp> __count(_M_ptr, __del, __del._M_alloc); + _M_refcount._M_swap(__count); + __enable_shared_from_this_helper(_M_refcount, _M_ptr, _M_ptr); + } +#endif + + template + friend __shared_ptr<_Tp1, _Lp1> + __allocate_shared(const _Alloc& __a, _Args&&... __args); + + // This constructor is used by __weak_ptr::lock() and + // shared_ptr::shared_ptr(const weak_ptr&, std::nothrow_t). + __shared_ptr(const __weak_ptr<_Tp, _Lp>& __r, std::nothrow_t) + : _M_refcount(__r._M_refcount, std::nothrow) + { + _M_ptr = _M_refcount._M_get_use_count() ? __r._M_ptr : nullptr; + } + + friend class __weak_ptr<_Tp, _Lp>; + + private: + void* + _M_get_deleter(const std::type_info& __ti) const noexcept + { return _M_refcount._M_get_deleter(__ti); } + + template + static _Tp1* + _S_raw_ptr(_Tp1* __ptr) + { return __ptr; } + + template + static auto + _S_raw_ptr(_Tp1 __ptr) -> decltype(std::__addressof(*__ptr)) + { return std::__addressof(*__ptr); } + + template friend class __shared_ptr; + template friend class __weak_ptr; + + template + friend _Del* get_deleter(const __shared_ptr<_Tp1, _Lp1>&) noexcept; + + _Tp* _M_ptr; // Contained pointer. + __shared_count<_Lp> _M_refcount; // Reference counter. + }; + + + // 20.7.2.2.7 shared_ptr comparisons + template + inline bool + operator==(const __shared_ptr<_Tp1, _Lp>& __a, + const __shared_ptr<_Tp2, _Lp>& __b) noexcept + { return __a.get() == __b.get(); } + + template + inline bool + operator==(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept + { return !__a; } + + template + inline bool + operator==(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept + { return !__a; } + + template + inline bool + operator!=(const __shared_ptr<_Tp1, _Lp>& __a, + const __shared_ptr<_Tp2, _Lp>& __b) noexcept + { return __a.get() != __b.get(); } + + template + inline bool + operator!=(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept + { return (bool)__a; } + + template + inline bool + operator!=(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept + { return (bool)__a; } + + template + inline bool + operator<(const __shared_ptr<_Tp1, _Lp>& __a, + const __shared_ptr<_Tp2, _Lp>& __b) noexcept + { + typedef typename std::common_type<_Tp1*, _Tp2*>::type _CT; + return std::less<_CT>()(__a.get(), __b.get()); + } + + template + inline bool + operator<(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept + { return std::less<_Tp*>()(__a.get(), nullptr); } + + template + inline bool + operator<(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept + { return std::less<_Tp*>()(nullptr, __a.get()); } + + template + inline bool + operator<=(const __shared_ptr<_Tp1, _Lp>& __a, + const __shared_ptr<_Tp2, _Lp>& __b) noexcept + { return !(__b < __a); } + + template + inline bool + operator<=(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept + { return !(nullptr < __a); } + + template + inline bool + operator<=(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept + { return !(__a < nullptr); } + + template + inline bool + operator>(const __shared_ptr<_Tp1, _Lp>& __a, + const __shared_ptr<_Tp2, _Lp>& __b) noexcept + { return (__b < __a); } + + template + inline bool + operator>(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept + { return std::less<_Tp*>()(nullptr, __a.get()); } + + template + inline bool + operator>(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept + { return std::less<_Tp*>()(__a.get(), nullptr); } + + template + inline bool + operator>=(const __shared_ptr<_Tp1, _Lp>& __a, + const __shared_ptr<_Tp2, _Lp>& __b) noexcept + { return !(__a < __b); } + + template + inline bool + operator>=(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept + { return !(__a < nullptr); } + + template + inline bool + operator>=(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept + { return !(nullptr < __a); } + + template + struct _Sp_less : public binary_function<_Sp, _Sp, bool> + { + bool + operator()(const _Sp& __lhs, const _Sp& __rhs) const noexcept + { + typedef typename _Sp::element_type element_type; + return std::less()(__lhs.get(), __rhs.get()); + } + }; + + template + struct less<__shared_ptr<_Tp, _Lp>> + : public _Sp_less<__shared_ptr<_Tp, _Lp>> + { }; + + // 20.7.2.2.8 shared_ptr specialized algorithms. + template + inline void + swap(__shared_ptr<_Tp, _Lp>& __a, __shared_ptr<_Tp, _Lp>& __b) noexcept + { __a.swap(__b); } + + // 20.7.2.2.9 shared_ptr casts + + // The seemingly equivalent code: + // shared_ptr<_Tp, _Lp>(static_cast<_Tp*>(__r.get())) + // will eventually result in undefined behaviour, attempting to + // delete the same object twice. + /// static_pointer_cast + template + inline __shared_ptr<_Tp, _Lp> + static_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept + { return __shared_ptr<_Tp, _Lp>(__r, static_cast<_Tp*>(__r.get())); } + + // The seemingly equivalent code: + // shared_ptr<_Tp, _Lp>(const_cast<_Tp*>(__r.get())) + // will eventually result in undefined behaviour, attempting to + // delete the same object twice. + /// const_pointer_cast + template + inline __shared_ptr<_Tp, _Lp> + const_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept + { return __shared_ptr<_Tp, _Lp>(__r, const_cast<_Tp*>(__r.get())); } + + // The seemingly equivalent code: + // shared_ptr<_Tp, _Lp>(dynamic_cast<_Tp*>(__r.get())) + // will eventually result in undefined behaviour, attempting to + // delete the same object twice. + /// dynamic_pointer_cast + template + inline __shared_ptr<_Tp, _Lp> + dynamic_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept + { + if (_Tp* __p = dynamic_cast<_Tp*>(__r.get())) + return __shared_ptr<_Tp, _Lp>(__r, __p); + return __shared_ptr<_Tp, _Lp>(); + } + + + template + class __weak_ptr + { + public: + typedef _Tp element_type; + + constexpr __weak_ptr() noexcept + : _M_ptr(0), _M_refcount() + { } + + __weak_ptr(const __weak_ptr&) noexcept = default; + __weak_ptr& operator=(const __weak_ptr&) noexcept = default; + ~__weak_ptr() = default; + + // The "obvious" converting constructor implementation: + // + // template + // __weak_ptr(const __weak_ptr<_Tp1, _Lp>& __r) + // : _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount) // never throws + // { } + // + // has a serious problem. + // + // __r._M_ptr may already have been invalidated. The _M_ptr(__r._M_ptr) + // conversion may require access to *__r._M_ptr (virtual inheritance). + // + // It is not possible to avoid spurious access violations since + // in multithreaded programs __r._M_ptr may be invalidated at any point. + template::value>::type> + __weak_ptr(const __weak_ptr<_Tp1, _Lp>& __r) noexcept + : _M_refcount(__r._M_refcount) + { _M_ptr = __r.lock().get(); } + + template::value>::type> + __weak_ptr(const __shared_ptr<_Tp1, _Lp>& __r) noexcept + : _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount) + { } + + template + __weak_ptr& + operator=(const __weak_ptr<_Tp1, _Lp>& __r) noexcept + { + _M_ptr = __r.lock().get(); + _M_refcount = __r._M_refcount; + return *this; + } + + template + __weak_ptr& + operator=(const __shared_ptr<_Tp1, _Lp>& __r) noexcept + { + _M_ptr = __r._M_ptr; + _M_refcount = __r._M_refcount; + return *this; + } + + __shared_ptr<_Tp, _Lp> + lock() const noexcept + { return __shared_ptr(*this, std::nothrow); } + + long + use_count() const noexcept + { return _M_refcount._M_get_use_count(); } + + bool + expired() const noexcept + { return _M_refcount._M_get_use_count() == 0; } + + template + bool + owner_before(const __shared_ptr<_Tp1, _Lp>& __rhs) const + { return _M_refcount._M_less(__rhs._M_refcount); } + + template + bool + owner_before(const __weak_ptr<_Tp1, _Lp>& __rhs) const + { return _M_refcount._M_less(__rhs._M_refcount); } + + void + reset() noexcept + { __weak_ptr().swap(*this); } + + void + swap(__weak_ptr& __s) noexcept + { + std::swap(_M_ptr, __s._M_ptr); + _M_refcount._M_swap(__s._M_refcount); + } + + private: + // Used by __enable_shared_from_this. + void + _M_assign(_Tp* __ptr, const __shared_count<_Lp>& __refcount) noexcept + { + _M_ptr = __ptr; + _M_refcount = __refcount; + } + + template friend class __shared_ptr; + template friend class __weak_ptr; + friend class __enable_shared_from_this<_Tp, _Lp>; + friend class enable_shared_from_this<_Tp>; + + _Tp* _M_ptr; // Contained pointer. + __weak_count<_Lp> _M_refcount; // Reference counter. + }; + + // 20.7.2.3.6 weak_ptr specialized algorithms. + template + inline void + swap(__weak_ptr<_Tp, _Lp>& __a, __weak_ptr<_Tp, _Lp>& __b) noexcept + { __a.swap(__b); } + + template + struct _Sp_owner_less : public binary_function<_Tp, _Tp, bool> + { + bool + operator()(const _Tp& __lhs, const _Tp& __rhs) const + { return __lhs.owner_before(__rhs); } + + bool + operator()(const _Tp& __lhs, const _Tp1& __rhs) const + { return __lhs.owner_before(__rhs); } + + bool + operator()(const _Tp1& __lhs, const _Tp& __rhs) const + { return __lhs.owner_before(__rhs); } + }; + + template + struct owner_less<__shared_ptr<_Tp, _Lp>> + : public _Sp_owner_less<__shared_ptr<_Tp, _Lp>, __weak_ptr<_Tp, _Lp>> + { }; + + template + struct owner_less<__weak_ptr<_Tp, _Lp>> + : public _Sp_owner_less<__weak_ptr<_Tp, _Lp>, __shared_ptr<_Tp, _Lp>> + { }; + + + template + class __enable_shared_from_this + { + protected: + constexpr __enable_shared_from_this() noexcept { } + + __enable_shared_from_this(const __enable_shared_from_this&) noexcept { } + + __enable_shared_from_this& + operator=(const __enable_shared_from_this&) noexcept + { return *this; } + + ~__enable_shared_from_this() { } + + public: + __shared_ptr<_Tp, _Lp> + shared_from_this() + { return __shared_ptr<_Tp, _Lp>(this->_M_weak_this); } + + __shared_ptr + shared_from_this() const + { return __shared_ptr(this->_M_weak_this); } + + private: + template + void + _M_weak_assign(_Tp1* __p, const __shared_count<_Lp>& __n) const noexcept + { _M_weak_this._M_assign(__p, __n); } + + template + friend void + __enable_shared_from_this_helper(const __shared_count<_Lp>& __pn, + const __enable_shared_from_this* __pe, + const _Tp1* __px) noexcept + { + if (__pe != 0) + __pe->_M_weak_assign(const_cast<_Tp1*>(__px), __pn); + } + + mutable __weak_ptr<_Tp, _Lp> _M_weak_this; + }; + + + template + inline __shared_ptr<_Tp, _Lp> + __allocate_shared(const _Alloc& __a, _Args&&... __args) + { + return __shared_ptr<_Tp, _Lp>(_Sp_make_shared_tag(), __a, + std::forward<_Args>(__args)...); + } + + template + inline __shared_ptr<_Tp, _Lp> + __make_shared(_Args&&... __args) + { + typedef typename std::remove_const<_Tp>::type _Tp_nc; + return std::__allocate_shared<_Tp, _Lp>(std::allocator<_Tp_nc>(), + std::forward<_Args>(__args)...); + } + + /// std::hash specialization for __shared_ptr. + template + struct hash<__shared_ptr<_Tp, _Lp>> + : public __hash_base> + { + size_t + operator()(const __shared_ptr<_Tp, _Lp>& __s) const noexcept + { return std::hash<_Tp*>()(__s.get()); } + }; + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif // _SHARED_PTR_BASE_H diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/slice_array.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/slice_array.h new file mode 100755 index 0000000..c98dfec --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/slice_array.h @@ -0,0 +1,274 @@ +// The template and inlines for the -*- C++ -*- slice_array class. + +// Copyright (C) 1997-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file bits/slice_array.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{valarray} + */ + +// Written by Gabriel Dos Reis + +#ifndef _SLICE_ARRAY_H +#define _SLICE_ARRAY_H 1 + +#pragma GCC system_header + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /** + * @addtogroup numeric_arrays + * @{ + */ + + /** + * @brief Class defining one-dimensional subset of an array. + * + * The slice class represents a one-dimensional subset of an array, + * specified by three parameters: start offset, size, and stride. The + * start offset is the index of the first element of the array that is part + * of the subset. The size is the total number of elements in the subset. + * Stride is the distance between each successive array element to include + * in the subset. + * + * For example, with an array of size 10, and a slice with offset 1, size 3 + * and stride 2, the subset consists of array elements 1, 3, and 5. + */ + class slice + { + public: + /// Construct an empty slice. + slice(); + + /** + * @brief Construct a slice. + * + * @param __o Offset in array of first element. + * @param __d Number of elements in slice. + * @param __s Stride between array elements. + */ + slice(size_t __o, size_t __d, size_t __s); + + /// Return array offset of first slice element. + size_t start() const; + /// Return size of slice. + size_t size() const; + /// Return array stride of slice. + size_t stride() const; + + private: + size_t _M_off; // offset + size_t _M_sz; // size + size_t _M_st; // stride unit + }; + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 543. valarray slice default constructor + inline + slice::slice() + : _M_off(0), _M_sz(0), _M_st(0) {} + + inline + slice::slice(size_t __o, size_t __d, size_t __s) + : _M_off(__o), _M_sz(__d), _M_st(__s) {} + + inline size_t + slice::start() const + { return _M_off; } + + inline size_t + slice::size() const + { return _M_sz; } + + inline size_t + slice::stride() const + { return _M_st; } + + /** + * @brief Reference to one-dimensional subset of an array. + * + * A slice_array is a reference to the actual elements of an array + * specified by a slice. The way to get a slice_array is to call + * operator[](slice) on a valarray. The returned slice_array then permits + * carrying operations out on the referenced subset of elements in the + * original valarray. For example, operator+=(valarray) will add values + * to the subset of elements in the underlying valarray this slice_array + * refers to. + * + * @param Tp Element type. + */ + template + class slice_array + { + public: + typedef _Tp value_type; + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 253. valarray helper functions are almost entirely useless + + /// Copy constructor. Both slices refer to the same underlying array. + slice_array(const slice_array&); + + /// Assignment operator. Assigns slice elements to corresponding + /// elements of @a a. + slice_array& operator=(const slice_array&); + + /// Assign slice elements to corresponding elements of @a v. + void operator=(const valarray<_Tp>&) const; + /// Multiply slice elements by corresponding elements of @a v. + void operator*=(const valarray<_Tp>&) const; + /// Divide slice elements by corresponding elements of @a v. + void operator/=(const valarray<_Tp>&) const; + /// Modulo slice elements by corresponding elements of @a v. + void operator%=(const valarray<_Tp>&) const; + /// Add corresponding elements of @a v to slice elements. + void operator+=(const valarray<_Tp>&) const; + /// Subtract corresponding elements of @a v from slice elements. + void operator-=(const valarray<_Tp>&) const; + /// Logical xor slice elements with corresponding elements of @a v. + void operator^=(const valarray<_Tp>&) const; + /// Logical and slice elements with corresponding elements of @a v. + void operator&=(const valarray<_Tp>&) const; + /// Logical or slice elements with corresponding elements of @a v. + void operator|=(const valarray<_Tp>&) const; + /// Left shift slice elements by corresponding elements of @a v. + void operator<<=(const valarray<_Tp>&) const; + /// Right shift slice elements by corresponding elements of @a v. + void operator>>=(const valarray<_Tp>&) const; + /// Assign all slice elements to @a t. + void operator=(const _Tp &) const; + // ~slice_array (); + + template + void operator=(const _Expr<_Dom, _Tp>&) const; + template + void operator*=(const _Expr<_Dom, _Tp>&) const; + template + void operator/=(const _Expr<_Dom, _Tp>&) const; + template + void operator%=(const _Expr<_Dom, _Tp>&) const; + template + void operator+=(const _Expr<_Dom, _Tp>&) const; + template + void operator-=(const _Expr<_Dom, _Tp>&) const; + template + void operator^=(const _Expr<_Dom, _Tp>&) const; + template + void operator&=(const _Expr<_Dom, _Tp>&) const; + template + void operator|=(const _Expr<_Dom, _Tp>&) const; + template + void operator<<=(const _Expr<_Dom, _Tp>&) const; + template + void operator>>=(const _Expr<_Dom, _Tp>&) const; + + private: + friend class valarray<_Tp>; + slice_array(_Array<_Tp>, const slice&); + + const size_t _M_sz; + const size_t _M_stride; + const _Array<_Tp> _M_array; + + // not implemented + slice_array(); + }; + + template + inline + slice_array<_Tp>::slice_array(_Array<_Tp> __a, const slice& __s) + : _M_sz(__s.size()), _M_stride(__s.stride()), + _M_array(__a.begin() + __s.start()) {} + + template + inline + slice_array<_Tp>::slice_array(const slice_array<_Tp>& a) + : _M_sz(a._M_sz), _M_stride(a._M_stride), _M_array(a._M_array) {} + + // template + // inline slice_array<_Tp>::~slice_array () {} + + template + inline slice_array<_Tp>& + slice_array<_Tp>::operator=(const slice_array<_Tp>& __a) + { + std::__valarray_copy(__a._M_array, __a._M_sz, __a._M_stride, + _M_array, _M_stride); + return *this; + } + + template + inline void + slice_array<_Tp>::operator=(const _Tp& __t) const + { std::__valarray_fill(_M_array, _M_sz, _M_stride, __t); } + + template + inline void + slice_array<_Tp>::operator=(const valarray<_Tp>& __v) const + { std::__valarray_copy(_Array<_Tp>(__v), _M_array, _M_sz, _M_stride); } + + template + template + inline void + slice_array<_Tp>::operator=(const _Expr<_Dom,_Tp>& __e) const + { std::__valarray_copy(__e, _M_sz, _M_array, _M_stride); } + +#undef _DEFINE_VALARRAY_OPERATOR +#define _DEFINE_VALARRAY_OPERATOR(_Op,_Name) \ + template \ + inline void \ + slice_array<_Tp>::operator _Op##=(const valarray<_Tp>& __v) const \ + { \ + _Array_augmented_##_Name(_M_array, _M_sz, _M_stride, _Array<_Tp>(__v));\ + } \ + \ + template \ + template \ + inline void \ + slice_array<_Tp>::operator _Op##=(const _Expr<_Dom,_Tp>& __e) const\ + { \ + _Array_augmented_##_Name(_M_array, _M_stride, __e, _M_sz); \ + } + + +_DEFINE_VALARRAY_OPERATOR(*, __multiplies) +_DEFINE_VALARRAY_OPERATOR(/, __divides) +_DEFINE_VALARRAY_OPERATOR(%, __modulus) +_DEFINE_VALARRAY_OPERATOR(+, __plus) +_DEFINE_VALARRAY_OPERATOR(-, __minus) +_DEFINE_VALARRAY_OPERATOR(^, __bitwise_xor) +_DEFINE_VALARRAY_OPERATOR(&, __bitwise_and) +_DEFINE_VALARRAY_OPERATOR(|, __bitwise_or) +_DEFINE_VALARRAY_OPERATOR(<<, __shift_left) +_DEFINE_VALARRAY_OPERATOR(>>, __shift_right) + +#undef _DEFINE_VALARRAY_OPERATOR + + // @} group numeric_arrays + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif /* _SLICE_ARRAY_H */ diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/sstream.tcc b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/sstream.tcc new file mode 100755 index 0000000..736466e --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/sstream.tcc @@ -0,0 +1,288 @@ +// String based streams -*- C++ -*- + +// Copyright (C) 1997-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file bits/sstream.tcc + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{sstream} + */ + +// +// ISO C++ 14882: 27.7 String-based streams +// + +#ifndef _SSTREAM_TCC +#define _SSTREAM_TCC 1 + +#pragma GCC system_header + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + template + typename basic_stringbuf<_CharT, _Traits, _Alloc>::int_type + basic_stringbuf<_CharT, _Traits, _Alloc>:: + pbackfail(int_type __c) + { + int_type __ret = traits_type::eof(); + if (this->eback() < this->gptr()) + { + // Try to put back __c into input sequence in one of three ways. + // Order these tests done in is unspecified by the standard. + const bool __testeof = traits_type::eq_int_type(__c, __ret); + if (!__testeof) + { + const bool __testeq = traits_type::eq(traits_type:: + to_char_type(__c), + this->gptr()[-1]); + const bool __testout = this->_M_mode & ios_base::out; + if (__testeq || __testout) + { + this->gbump(-1); + if (!__testeq) + *this->gptr() = traits_type::to_char_type(__c); + __ret = __c; + } + } + else + { + this->gbump(-1); + __ret = traits_type::not_eof(__c); + } + } + return __ret; + } + + template + typename basic_stringbuf<_CharT, _Traits, _Alloc>::int_type + basic_stringbuf<_CharT, _Traits, _Alloc>:: + overflow(int_type __c) + { + const bool __testout = this->_M_mode & ios_base::out; + if (__builtin_expect(!__testout, false)) + return traits_type::eof(); + + const bool __testeof = traits_type::eq_int_type(__c, traits_type::eof()); + if (__builtin_expect(__testeof, false)) + return traits_type::not_eof(__c); + + const __size_type __capacity = _M_string.capacity(); + const __size_type __max_size = _M_string.max_size(); + const bool __testput = this->pptr() < this->epptr(); + if (__builtin_expect(!__testput && __capacity == __max_size, false)) + return traits_type::eof(); + + // Try to append __c into output sequence in one of two ways. + // Order these tests done in is unspecified by the standard. + const char_type __conv = traits_type::to_char_type(__c); + if (!__testput) + { + // NB: Start ostringstream buffers at 512 chars. This is an + // experimental value (pronounced "arbitrary" in some of the + // hipper English-speaking countries), and can be changed to + // suit particular needs. + // + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 169. Bad efficiency of overflow() mandated + // 432. stringbuf::overflow() makes only one write position + // available + const __size_type __opt_len = std::max(__size_type(2 * __capacity), + __size_type(512)); + const __size_type __len = std::min(__opt_len, __max_size); + __string_type __tmp; + __tmp.reserve(__len); + if (this->pbase()) + __tmp.assign(this->pbase(), this->epptr() - this->pbase()); + __tmp.push_back(__conv); + _M_string.swap(__tmp); + _M_sync(const_cast(_M_string.data()), + this->gptr() - this->eback(), this->pptr() - this->pbase()); + } + else + *this->pptr() = __conv; + this->pbump(1); + return __c; + } + + template + typename basic_stringbuf<_CharT, _Traits, _Alloc>::int_type + basic_stringbuf<_CharT, _Traits, _Alloc>:: + underflow() + { + int_type __ret = traits_type::eof(); + const bool __testin = this->_M_mode & ios_base::in; + if (__testin) + { + // Update egptr() to match the actual string end. + _M_update_egptr(); + + if (this->gptr() < this->egptr()) + __ret = traits_type::to_int_type(*this->gptr()); + } + return __ret; + } + + template + typename basic_stringbuf<_CharT, _Traits, _Alloc>::pos_type + basic_stringbuf<_CharT, _Traits, _Alloc>:: + seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode __mode) + { + pos_type __ret = pos_type(off_type(-1)); + bool __testin = (ios_base::in & this->_M_mode & __mode) != 0; + bool __testout = (ios_base::out & this->_M_mode & __mode) != 0; + const bool __testboth = __testin && __testout && __way != ios_base::cur; + __testin &= !(__mode & ios_base::out); + __testout &= !(__mode & ios_base::in); + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 453. basic_stringbuf::seekoff need not always fail for an empty stream. + const char_type* __beg = __testin ? this->eback() : this->pbase(); + if ((__beg || !__off) && (__testin || __testout || __testboth)) + { + _M_update_egptr(); + + off_type __newoffi = __off; + off_type __newoffo = __newoffi; + if (__way == ios_base::cur) + { + __newoffi += this->gptr() - __beg; + __newoffo += this->pptr() - __beg; + } + else if (__way == ios_base::end) + __newoffo = __newoffi += this->egptr() - __beg; + + if ((__testin || __testboth) + && __newoffi >= 0 + && this->egptr() - __beg >= __newoffi) + { + this->setg(this->eback(), this->eback() + __newoffi, + this->egptr()); + __ret = pos_type(__newoffi); + } + if ((__testout || __testboth) + && __newoffo >= 0 + && this->egptr() - __beg >= __newoffo) + { + _M_pbump(this->pbase(), this->epptr(), __newoffo); + __ret = pos_type(__newoffo); + } + } + return __ret; + } + + template + typename basic_stringbuf<_CharT, _Traits, _Alloc>::pos_type + basic_stringbuf<_CharT, _Traits, _Alloc>:: + seekpos(pos_type __sp, ios_base::openmode __mode) + { + pos_type __ret = pos_type(off_type(-1)); + const bool __testin = (ios_base::in & this->_M_mode & __mode) != 0; + const bool __testout = (ios_base::out & this->_M_mode & __mode) != 0; + + const char_type* __beg = __testin ? this->eback() : this->pbase(); + if ((__beg || !off_type(__sp)) && (__testin || __testout)) + { + _M_update_egptr(); + + const off_type __pos(__sp); + const bool __testpos = (0 <= __pos + && __pos <= this->egptr() - __beg); + if (__testpos) + { + if (__testin) + this->setg(this->eback(), this->eback() + __pos, + this->egptr()); + if (__testout) + _M_pbump(this->pbase(), this->epptr(), __pos); + __ret = __sp; + } + } + return __ret; + } + + template + void + basic_stringbuf<_CharT, _Traits, _Alloc>:: + _M_sync(char_type* __base, __size_type __i, __size_type __o) + { + const bool __testin = _M_mode & ios_base::in; + const bool __testout = _M_mode & ios_base::out; + char_type* __endg = __base + _M_string.size(); + char_type* __endp = __base + _M_string.capacity(); + + if (__base != _M_string.data()) + { + // setbuf: __i == size of buffer area (_M_string.size() == 0). + __endg += __i; + __i = 0; + __endp = __endg; + } + + if (__testin) + this->setg(__base, __base + __i, __endg); + if (__testout) + { + _M_pbump(__base, __endp, __o); + // egptr() always tracks the string end. When !__testin, + // for the correct functioning of the streambuf inlines + // the other get area pointers are identical. + if (!__testin) + this->setg(__endg, __endg, __endg); + } + } + + template + void + basic_stringbuf<_CharT, _Traits, _Alloc>:: + _M_pbump(char_type* __pbeg, char_type* __pend, off_type __off) + { + this->setp(__pbeg, __pend); + while (__off > __gnu_cxx::__numeric_traits::__max) + { + this->pbump(__gnu_cxx::__numeric_traits::__max); + __off -= __gnu_cxx::__numeric_traits::__max; + } + this->pbump(__off); + } + + // Inhibit implicit instantiations for required instantiations, + // which are defined via explicit instantiations elsewhere. +#if _GLIBCXX_EXTERN_TEMPLATE + extern template class basic_stringbuf; + extern template class basic_istringstream; + extern template class basic_ostringstream; + extern template class basic_stringstream; + +#ifdef _GLIBCXX_USE_WCHAR_T + extern template class basic_stringbuf; + extern template class basic_istringstream; + extern template class basic_ostringstream; + extern template class basic_stringstream; +#endif +#endif + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace std + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stl_algo.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stl_algo.h new file mode 100755 index 0000000..c9980e5 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stl_algo.h @@ -0,0 +1,5528 @@ +// Algorithm implementation -*- C++ -*- + +// Copyright (C) 2001-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/* + * + * Copyright (c) 1994 + * Hewlett-Packard Company + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Hewlett-Packard Company makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + * + * + * Copyright (c) 1996 + * Silicon Graphics Computer Systems, Inc. + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Silicon Graphics makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + */ + +/** @file bits/stl_algo.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{algorithm} + */ + +#ifndef _STL_ALGO_H +#define _STL_ALGO_H 1 + +#include // for rand +#include +#include +#include // for _Temporary_buffer +#include + +#if __cplusplus >= 201103L +#include // for std::uniform_int_distribution +#endif + +// See concept_check.h for the __glibcxx_*_requires macros. + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /// Swaps the median value of *__a, *__b and *__c under __comp to *__result + template + void + __move_median_to_first(_Iterator __result,_Iterator __a, _Iterator __b, + _Iterator __c, _Compare __comp) + { + if (__comp(__a, __b)) + { + if (__comp(__b, __c)) + std::iter_swap(__result, __b); + else if (__comp(__a, __c)) + std::iter_swap(__result, __c); + else + std::iter_swap(__result, __a); + } + else if (__comp(__a, __c)) + std::iter_swap(__result, __a); + else if (__comp(__b, __c)) + std::iter_swap(__result, __c); + else + std::iter_swap(__result, __b); + } + + /// This is an overload used by find algos for the Input Iterator case. + template + inline _InputIterator + __find_if(_InputIterator __first, _InputIterator __last, + _Predicate __pred, input_iterator_tag) + { + while (__first != __last && !__pred(__first)) + ++__first; + return __first; + } + + /// This is an overload used by find algos for the RAI case. + template + _RandomAccessIterator + __find_if(_RandomAccessIterator __first, _RandomAccessIterator __last, + _Predicate __pred, random_access_iterator_tag) + { + typename iterator_traits<_RandomAccessIterator>::difference_type + __trip_count = (__last - __first) >> 2; + + for (; __trip_count > 0; --__trip_count) + { + if (__pred(__first)) + return __first; + ++__first; + + if (__pred(__first)) + return __first; + ++__first; + + if (__pred(__first)) + return __first; + ++__first; + + if (__pred(__first)) + return __first; + ++__first; + } + + switch (__last - __first) + { + case 3: + if (__pred(__first)) + return __first; + ++__first; + case 2: + if (__pred(__first)) + return __first; + ++__first; + case 1: + if (__pred(__first)) + return __first; + ++__first; + case 0: + default: + return __last; + } + } + + template + inline _Iterator + __find_if(_Iterator __first, _Iterator __last, _Predicate __pred) + { + return __find_if(__first, __last, __pred, + std::__iterator_category(__first)); + } + + /// Provided for stable_partition to use. + template + inline _InputIterator + __find_if_not(_InputIterator __first, _InputIterator __last, + _Predicate __pred) + { + return std::__find_if(__first, __last, + __gnu_cxx::__ops::__negate(__pred), + std::__iterator_category(__first)); + } + + /// Like find_if_not(), but uses and updates a count of the + /// remaining range length instead of comparing against an end + /// iterator. + template + _InputIterator + __find_if_not_n(_InputIterator __first, _Distance& __len, _Predicate __pred) + { + for (; __len; --__len, ++__first) + if (!__pred(__first)) + break; + return __first; + } + + // set_difference + // set_intersection + // set_symmetric_difference + // set_union + // for_each + // find + // find_if + // find_first_of + // adjacent_find + // count + // count_if + // search + + template + _ForwardIterator1 + __search(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2, + _BinaryPredicate __predicate) + { + // Test for empty ranges + if (__first1 == __last1 || __first2 == __last2) + return __first1; + + // Test for a pattern of length 1. + _ForwardIterator2 __p1(__first2); + if (++__p1 == __last2) + return std::__find_if(__first1, __last1, + __gnu_cxx::__ops::__iter_comp_iter(__predicate, __first2)); + + // General case. + _ForwardIterator2 __p; + _ForwardIterator1 __current = __first1; + + for (;;) + { + __first1 = + std::__find_if(__first1, __last1, + __gnu_cxx::__ops::__iter_comp_iter(__predicate, __first2)); + + if (__first1 == __last1) + return __last1; + + __p = __p1; + __current = __first1; + if (++__current == __last1) + return __last1; + + while (__predicate(__current, __p)) + { + if (++__p == __last2) + return __first1; + if (++__current == __last1) + return __last1; + } + ++__first1; + } + return __first1; + } + + // search_n + + /** + * This is an helper function for search_n overloaded for forward iterators. + */ + template + _ForwardIterator + __search_n_aux(_ForwardIterator __first, _ForwardIterator __last, + _Integer __count, _UnaryPredicate __unary_pred, + std::forward_iterator_tag) + { + __first = std::__find_if(__first, __last, __unary_pred); + while (__first != __last) + { + typename iterator_traits<_ForwardIterator>::difference_type + __n = __count; + _ForwardIterator __i = __first; + ++__i; + while (__i != __last && __n != 1 && __unary_pred(__i)) + { + ++__i; + --__n; + } + if (__n == 1) + return __first; + if (__i == __last) + return __last; + __first = std::__find_if(++__i, __last, __unary_pred); + } + return __last; + } + + /** + * This is an helper function for search_n overloaded for random access + * iterators. + */ + template + _RandomAccessIter + __search_n_aux(_RandomAccessIter __first, _RandomAccessIter __last, + _Integer __count, _UnaryPredicate __unary_pred, + std::random_access_iterator_tag) + { + typedef typename std::iterator_traits<_RandomAccessIter>::difference_type + _DistanceType; + + _DistanceType __tailSize = __last - __first; + _DistanceType __remainder = __count; + + while (__remainder <= __tailSize) // the main loop... + { + __first += __remainder; + __tailSize -= __remainder; + // __first here is always pointing to one past the last element of + // next possible match. + _RandomAccessIter __backTrack = __first; + while (__unary_pred(--__backTrack)) + { + if (--__remainder == 0) + return (__first - __count); // Success + } + __remainder = __count + 1 - (__first - __backTrack); + } + return __last; // Failure + } + + template + _ForwardIterator + __search_n(_ForwardIterator __first, _ForwardIterator __last, + _Integer __count, + _UnaryPredicate __unary_pred) + { + if (__count <= 0) + return __first; + + if (__count == 1) + return std::__find_if(__first, __last, __unary_pred); + + return std::__search_n_aux(__first, __last, __count, __unary_pred, + std::__iterator_category(__first)); + } + + // find_end for forward iterators. + template + _ForwardIterator1 + __find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2, + forward_iterator_tag, forward_iterator_tag, + _BinaryPredicate __comp) + { + if (__first2 == __last2) + return __last1; + + _ForwardIterator1 __result = __last1; + while (1) + { + _ForwardIterator1 __new_result + = std::__search(__first1, __last1, __first2, __last2, __comp); + if (__new_result == __last1) + return __result; + else + { + __result = __new_result; + __first1 = __new_result; + ++__first1; + } + } + } + + // find_end for bidirectional iterators (much faster). + template + _BidirectionalIterator1 + __find_end(_BidirectionalIterator1 __first1, + _BidirectionalIterator1 __last1, + _BidirectionalIterator2 __first2, + _BidirectionalIterator2 __last2, + bidirectional_iterator_tag, bidirectional_iterator_tag, + _BinaryPredicate __comp) + { + // concept requirements + __glibcxx_function_requires(_BidirectionalIteratorConcept< + _BidirectionalIterator1>) + __glibcxx_function_requires(_BidirectionalIteratorConcept< + _BidirectionalIterator2>) + + typedef reverse_iterator<_BidirectionalIterator1> _RevIterator1; + typedef reverse_iterator<_BidirectionalIterator2> _RevIterator2; + + _RevIterator1 __rlast1(__first1); + _RevIterator2 __rlast2(__first2); + _RevIterator1 __rresult = std::__search(_RevIterator1(__last1), __rlast1, + _RevIterator2(__last2), __rlast2, + __comp); + + if (__rresult == __rlast1) + return __last1; + else + { + _BidirectionalIterator1 __result = __rresult.base(); + std::advance(__result, -std::distance(__first2, __last2)); + return __result; + } + } + + /** + * @brief Find last matching subsequence in a sequence. + * @ingroup non_mutating_algorithms + * @param __first1 Start of range to search. + * @param __last1 End of range to search. + * @param __first2 Start of sequence to match. + * @param __last2 End of sequence to match. + * @return The last iterator @c i in the range + * @p [__first1,__last1-(__last2-__first2)) such that @c *(i+N) == + * @p *(__first2+N) for each @c N in the range @p + * [0,__last2-__first2), or @p __last1 if no such iterator exists. + * + * Searches the range @p [__first1,__last1) for a sub-sequence that + * compares equal value-by-value with the sequence given by @p + * [__first2,__last2) and returns an iterator to the __first + * element of the sub-sequence, or @p __last1 if the sub-sequence + * is not found. The sub-sequence will be the last such + * subsequence contained in [__first1,__last1). + * + * Because the sub-sequence must lie completely within the range @p + * [__first1,__last1) it must start at a position less than @p + * __last1-(__last2-__first2) where @p __last2-__first2 is the + * length of the sub-sequence. This means that the returned + * iterator @c i will be in the range @p + * [__first1,__last1-(__last2-__first2)) + */ + template + inline _ForwardIterator1 + find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2) + { + // concept requirements + __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator1>) + __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator2>) + __glibcxx_function_requires(_EqualOpConcept< + typename iterator_traits<_ForwardIterator1>::value_type, + typename iterator_traits<_ForwardIterator2>::value_type>) + __glibcxx_requires_valid_range(__first1, __last1); + __glibcxx_requires_valid_range(__first2, __last2); + + return std::__find_end(__first1, __last1, __first2, __last2, + std::__iterator_category(__first1), + std::__iterator_category(__first2), + __gnu_cxx::__ops::__iter_equal_to_iter()); + } + + /** + * @brief Find last matching subsequence in a sequence using a predicate. + * @ingroup non_mutating_algorithms + * @param __first1 Start of range to search. + * @param __last1 End of range to search. + * @param __first2 Start of sequence to match. + * @param __last2 End of sequence to match. + * @param __comp The predicate to use. + * @return The last iterator @c i in the range @p + * [__first1,__last1-(__last2-__first2)) such that @c + * predicate(*(i+N), @p (__first2+N)) is true for each @c N in the + * range @p [0,__last2-__first2), or @p __last1 if no such iterator + * exists. + * + * Searches the range @p [__first1,__last1) for a sub-sequence that + * compares equal value-by-value with the sequence given by @p + * [__first2,__last2) using comp as a predicate and returns an + * iterator to the first element of the sub-sequence, or @p __last1 + * if the sub-sequence is not found. The sub-sequence will be the + * last such subsequence contained in [__first,__last1). + * + * Because the sub-sequence must lie completely within the range @p + * [__first1,__last1) it must start at a position less than @p + * __last1-(__last2-__first2) where @p __last2-__first2 is the + * length of the sub-sequence. This means that the returned + * iterator @c i will be in the range @p + * [__first1,__last1-(__last2-__first2)) + */ + template + inline _ForwardIterator1 + find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2, + _BinaryPredicate __comp) + { + // concept requirements + __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator1>) + __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator2>) + __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate, + typename iterator_traits<_ForwardIterator1>::value_type, + typename iterator_traits<_ForwardIterator2>::value_type>) + __glibcxx_requires_valid_range(__first1, __last1); + __glibcxx_requires_valid_range(__first2, __last2); + + return std::__find_end(__first1, __last1, __first2, __last2, + std::__iterator_category(__first1), + std::__iterator_category(__first2), + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } + +#if __cplusplus >= 201103L + /** + * @brief Checks that a predicate is true for all the elements + * of a sequence. + * @ingroup non_mutating_algorithms + * @param __first An input iterator. + * @param __last An input iterator. + * @param __pred A predicate. + * @return True if the check is true, false otherwise. + * + * Returns true if @p __pred is true for each element in the range + * @p [__first,__last), and false otherwise. + */ + template + inline bool + all_of(_InputIterator __first, _InputIterator __last, _Predicate __pred) + { return __last == std::find_if_not(__first, __last, __pred); } + + /** + * @brief Checks that a predicate is false for all the elements + * of a sequence. + * @ingroup non_mutating_algorithms + * @param __first An input iterator. + * @param __last An input iterator. + * @param __pred A predicate. + * @return True if the check is true, false otherwise. + * + * Returns true if @p __pred is false for each element in the range + * @p [__first,__last), and false otherwise. + */ + template + inline bool + none_of(_InputIterator __first, _InputIterator __last, _Predicate __pred) + { return __last == _GLIBCXX_STD_A::find_if(__first, __last, __pred); } + + /** + * @brief Checks that a predicate is false for at least an element + * of a sequence. + * @ingroup non_mutating_algorithms + * @param __first An input iterator. + * @param __last An input iterator. + * @param __pred A predicate. + * @return True if the check is true, false otherwise. + * + * Returns true if an element exists in the range @p + * [__first,__last) such that @p __pred is true, and false + * otherwise. + */ + template + inline bool + any_of(_InputIterator __first, _InputIterator __last, _Predicate __pred) + { return !std::none_of(__first, __last, __pred); } + + /** + * @brief Find the first element in a sequence for which a + * predicate is false. + * @ingroup non_mutating_algorithms + * @param __first An input iterator. + * @param __last An input iterator. + * @param __pred A predicate. + * @return The first iterator @c i in the range @p [__first,__last) + * such that @p __pred(*i) is false, or @p __last if no such iterator exists. + */ + template + inline _InputIterator + find_if_not(_InputIterator __first, _InputIterator __last, + _Predicate __pred) + { + // concept requirements + __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>) + __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate, + typename iterator_traits<_InputIterator>::value_type>) + __glibcxx_requires_valid_range(__first, __last); + return std::__find_if_not(__first, __last, + __gnu_cxx::__ops::__pred_iter(__pred)); + } + + /** + * @brief Checks whether the sequence is partitioned. + * @ingroup mutating_algorithms + * @param __first An input iterator. + * @param __last An input iterator. + * @param __pred A predicate. + * @return True if the range @p [__first,__last) is partioned by @p __pred, + * i.e. if all elements that satisfy @p __pred appear before those that + * do not. + */ + template + inline bool + is_partitioned(_InputIterator __first, _InputIterator __last, + _Predicate __pred) + { + __first = std::find_if_not(__first, __last, __pred); + return std::none_of(__first, __last, __pred); + } + + /** + * @brief Find the partition point of a partitioned range. + * @ingroup mutating_algorithms + * @param __first An iterator. + * @param __last Another iterator. + * @param __pred A predicate. + * @return An iterator @p mid such that @p all_of(__first, mid, __pred) + * and @p none_of(mid, __last, __pred) are both true. + */ + template + _ForwardIterator + partition_point(_ForwardIterator __first, _ForwardIterator __last, + _Predicate __pred) + { + // concept requirements + __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>) + __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate, + typename iterator_traits<_ForwardIterator>::value_type>) + + // A specific debug-mode test will be necessary... + __glibcxx_requires_valid_range(__first, __last); + + typedef typename iterator_traits<_ForwardIterator>::difference_type + _DistanceType; + + _DistanceType __len = std::distance(__first, __last); + _DistanceType __half; + _ForwardIterator __middle; + + while (__len > 0) + { + __half = __len >> 1; + __middle = __first; + std::advance(__middle, __half); + if (__pred(*__middle)) + { + __first = __middle; + ++__first; + __len = __len - __half - 1; + } + else + __len = __half; + } + return __first; + } +#endif + + template + _OutputIterator + __remove_copy_if(_InputIterator __first, _InputIterator __last, + _OutputIterator __result, _Predicate __pred) + { + for (; __first != __last; ++__first) + if (!__pred(__first)) + { + *__result = *__first; + ++__result; + } + return __result; + } + + /** + * @brief Copy a sequence, removing elements of a given value. + * @ingroup mutating_algorithms + * @param __first An input iterator. + * @param __last An input iterator. + * @param __result An output iterator. + * @param __value The value to be removed. + * @return An iterator designating the end of the resulting sequence. + * + * Copies each element in the range @p [__first,__last) not equal + * to @p __value to the range beginning at @p __result. + * remove_copy() is stable, so the relative order of elements that + * are copied is unchanged. + */ + template + inline _OutputIterator + remove_copy(_InputIterator __first, _InputIterator __last, + _OutputIterator __result, const _Tp& __value) + { + // concept requirements + __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>) + __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator, + typename iterator_traits<_InputIterator>::value_type>) + __glibcxx_function_requires(_EqualOpConcept< + typename iterator_traits<_InputIterator>::value_type, _Tp>) + __glibcxx_requires_valid_range(__first, __last); + + return std::__remove_copy_if(__first, __last, __result, + __gnu_cxx::__ops::__iter_equals_val(__value)); + } + + /** + * @brief Copy a sequence, removing elements for which a predicate is true. + * @ingroup mutating_algorithms + * @param __first An input iterator. + * @param __last An input iterator. + * @param __result An output iterator. + * @param __pred A predicate. + * @return An iterator designating the end of the resulting sequence. + * + * Copies each element in the range @p [__first,__last) for which + * @p __pred returns false to the range beginning at @p __result. + * + * remove_copy_if() is stable, so the relative order of elements that are + * copied is unchanged. + */ + template + inline _OutputIterator + remove_copy_if(_InputIterator __first, _InputIterator __last, + _OutputIterator __result, _Predicate __pred) + { + // concept requirements + __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>) + __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator, + typename iterator_traits<_InputIterator>::value_type>) + __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate, + typename iterator_traits<_InputIterator>::value_type>) + __glibcxx_requires_valid_range(__first, __last); + + return std::__remove_copy_if(__first, __last, __result, + __gnu_cxx::__ops::__pred_iter(__pred)); + } + +#if __cplusplus >= 201103L + /** + * @brief Copy the elements of a sequence for which a predicate is true. + * @ingroup mutating_algorithms + * @param __first An input iterator. + * @param __last An input iterator. + * @param __result An output iterator. + * @param __pred A predicate. + * @return An iterator designating the end of the resulting sequence. + * + * Copies each element in the range @p [__first,__last) for which + * @p __pred returns true to the range beginning at @p __result. + * + * copy_if() is stable, so the relative order of elements that are + * copied is unchanged. + */ + template + _OutputIterator + copy_if(_InputIterator __first, _InputIterator __last, + _OutputIterator __result, _Predicate __pred) + { + // concept requirements + __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>) + __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator, + typename iterator_traits<_InputIterator>::value_type>) + __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate, + typename iterator_traits<_InputIterator>::value_type>) + __glibcxx_requires_valid_range(__first, __last); + + for (; __first != __last; ++__first) + if (__pred(*__first)) + { + *__result = *__first; + ++__result; + } + return __result; + } + + template + _OutputIterator + __copy_n(_InputIterator __first, _Size __n, + _OutputIterator __result, input_iterator_tag) + { + if (__n > 0) + { + while (true) + { + *__result = *__first; + ++__result; + if (--__n > 0) + ++__first; + else + break; + } + } + return __result; + } + + template + inline _OutputIterator + __copy_n(_RandomAccessIterator __first, _Size __n, + _OutputIterator __result, random_access_iterator_tag) + { return std::copy(__first, __first + __n, __result); } + + /** + * @brief Copies the range [first,first+n) into [result,result+n). + * @ingroup mutating_algorithms + * @param __first An input iterator. + * @param __n The number of elements to copy. + * @param __result An output iterator. + * @return result+n. + * + * This inline function will boil down to a call to @c memmove whenever + * possible. Failing that, if random access iterators are passed, then the + * loop count will be known (and therefore a candidate for compiler + * optimizations such as unrolling). + */ + template + inline _OutputIterator + copy_n(_InputIterator __first, _Size __n, _OutputIterator __result) + { + // concept requirements + __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>) + __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator, + typename iterator_traits<_InputIterator>::value_type>) + + return std::__copy_n(__first, __n, __result, + std::__iterator_category(__first)); + } + + /** + * @brief Copy the elements of a sequence to separate output sequences + * depending on the truth value of a predicate. + * @ingroup mutating_algorithms + * @param __first An input iterator. + * @param __last An input iterator. + * @param __out_true An output iterator. + * @param __out_false An output iterator. + * @param __pred A predicate. + * @return A pair designating the ends of the resulting sequences. + * + * Copies each element in the range @p [__first,__last) for which + * @p __pred returns true to the range beginning at @p out_true + * and each element for which @p __pred returns false to @p __out_false. + */ + template + pair<_OutputIterator1, _OutputIterator2> + partition_copy(_InputIterator __first, _InputIterator __last, + _OutputIterator1 __out_true, _OutputIterator2 __out_false, + _Predicate __pred) + { + // concept requirements + __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>) + __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator1, + typename iterator_traits<_InputIterator>::value_type>) + __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator2, + typename iterator_traits<_InputIterator>::value_type>) + __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate, + typename iterator_traits<_InputIterator>::value_type>) + __glibcxx_requires_valid_range(__first, __last); + + for (; __first != __last; ++__first) + if (__pred(*__first)) + { + *__out_true = *__first; + ++__out_true; + } + else + { + *__out_false = *__first; + ++__out_false; + } + + return pair<_OutputIterator1, _OutputIterator2>(__out_true, __out_false); + } +#endif + + template + _ForwardIterator + __remove_if(_ForwardIterator __first, _ForwardIterator __last, + _Predicate __pred) + { + __first = std::__find_if(__first, __last, __pred); + if (__first == __last) + return __first; + _ForwardIterator __result = __first; + ++__first; + for (; __first != __last; ++__first) + if (!__pred(__first)) + { + *__result = _GLIBCXX_MOVE(*__first); + ++__result; + } + return __result; + } + + /** + * @brief Remove elements from a sequence. + * @ingroup mutating_algorithms + * @param __first An input iterator. + * @param __last An input iterator. + * @param __value The value to be removed. + * @return An iterator designating the end of the resulting sequence. + * + * All elements equal to @p __value are removed from the range + * @p [__first,__last). + * + * remove() is stable, so the relative order of elements that are + * not removed is unchanged. + * + * Elements between the end of the resulting sequence and @p __last + * are still present, but their value is unspecified. + */ + template + inline _ForwardIterator + remove(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __value) + { + // concept requirements + __glibcxx_function_requires(_Mutable_ForwardIteratorConcept< + _ForwardIterator>) + __glibcxx_function_requires(_EqualOpConcept< + typename iterator_traits<_ForwardIterator>::value_type, _Tp>) + __glibcxx_requires_valid_range(__first, __last); + + return std::__remove_if(__first, __last, + __gnu_cxx::__ops::__iter_equals_val(__value)); + } + + /** + * @brief Remove elements from a sequence using a predicate. + * @ingroup mutating_algorithms + * @param __first A forward iterator. + * @param __last A forward iterator. + * @param __pred A predicate. + * @return An iterator designating the end of the resulting sequence. + * + * All elements for which @p __pred returns true are removed from the range + * @p [__first,__last). + * + * remove_if() is stable, so the relative order of elements that are + * not removed is unchanged. + * + * Elements between the end of the resulting sequence and @p __last + * are still present, but their value is unspecified. + */ + template + inline _ForwardIterator + remove_if(_ForwardIterator __first, _ForwardIterator __last, + _Predicate __pred) + { + // concept requirements + __glibcxx_function_requires(_Mutable_ForwardIteratorConcept< + _ForwardIterator>) + __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate, + typename iterator_traits<_ForwardIterator>::value_type>) + __glibcxx_requires_valid_range(__first, __last); + + return std::__remove_if(__first, __last, + __gnu_cxx::__ops::__pred_iter(__pred)); + } + + template + _ForwardIterator + __adjacent_find(_ForwardIterator __first, _ForwardIterator __last, + _BinaryPredicate __binary_pred) + { + if (__first == __last) + return __last; + _ForwardIterator __next = __first; + while (++__next != __last) + { + if (__binary_pred(__first, __next)) + return __first; + __first = __next; + } + return __last; + } + + template + _ForwardIterator + __unique(_ForwardIterator __first, _ForwardIterator __last, + _BinaryPredicate __binary_pred) + { + // Skip the beginning, if already unique. + __first = std::__adjacent_find(__first, __last, __binary_pred); + if (__first == __last) + return __last; + + // Do the real copy work. + _ForwardIterator __dest = __first; + ++__first; + while (++__first != __last) + if (!__binary_pred(__dest, __first)) + *++__dest = _GLIBCXX_MOVE(*__first); + return ++__dest; + } + + /** + * @brief Remove consecutive duplicate values from a sequence. + * @ingroup mutating_algorithms + * @param __first A forward iterator. + * @param __last A forward iterator. + * @return An iterator designating the end of the resulting sequence. + * + * Removes all but the first element from each group of consecutive + * values that compare equal. + * unique() is stable, so the relative order of elements that are + * not removed is unchanged. + * Elements between the end of the resulting sequence and @p __last + * are still present, but their value is unspecified. + */ + template + inline _ForwardIterator + unique(_ForwardIterator __first, _ForwardIterator __last) + { + // concept requirements + __glibcxx_function_requires(_Mutable_ForwardIteratorConcept< + _ForwardIterator>) + __glibcxx_function_requires(_EqualityComparableConcept< + typename iterator_traits<_ForwardIterator>::value_type>) + __glibcxx_requires_valid_range(__first, __last); + + return std::__unique(__first, __last, + __gnu_cxx::__ops::__iter_equal_to_iter()); + } + + /** + * @brief Remove consecutive values from a sequence using a predicate. + * @ingroup mutating_algorithms + * @param __first A forward iterator. + * @param __last A forward iterator. + * @param __binary_pred A binary predicate. + * @return An iterator designating the end of the resulting sequence. + * + * Removes all but the first element from each group of consecutive + * values for which @p __binary_pred returns true. + * unique() is stable, so the relative order of elements that are + * not removed is unchanged. + * Elements between the end of the resulting sequence and @p __last + * are still present, but their value is unspecified. + */ + template + inline _ForwardIterator + unique(_ForwardIterator __first, _ForwardIterator __last, + _BinaryPredicate __binary_pred) + { + // concept requirements + __glibcxx_function_requires(_Mutable_ForwardIteratorConcept< + _ForwardIterator>) + __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate, + typename iterator_traits<_ForwardIterator>::value_type, + typename iterator_traits<_ForwardIterator>::value_type>) + __glibcxx_requires_valid_range(__first, __last); + + return std::__unique(__first, __last, + __gnu_cxx::__ops::__iter_comp_iter(__binary_pred)); + } + + /** + * This is an uglified + * unique_copy(_InputIterator, _InputIterator, _OutputIterator, + * _BinaryPredicate) + * overloaded for forward iterators and output iterator as result. + */ + template + _OutputIterator + __unique_copy(_ForwardIterator __first, _ForwardIterator __last, + _OutputIterator __result, _BinaryPredicate __binary_pred, + forward_iterator_tag, output_iterator_tag) + { + // concept requirements -- iterators already checked + __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate, + typename iterator_traits<_ForwardIterator>::value_type, + typename iterator_traits<_ForwardIterator>::value_type>) + + _ForwardIterator __next = __first; + *__result = *__first; + while (++__next != __last) + if (!__binary_pred(__first, __next)) + { + __first = __next; + *++__result = *__first; + } + return ++__result; + } + + /** + * This is an uglified + * unique_copy(_InputIterator, _InputIterator, _OutputIterator, + * _BinaryPredicate) + * overloaded for input iterators and output iterator as result. + */ + template + _OutputIterator + __unique_copy(_InputIterator __first, _InputIterator __last, + _OutputIterator __result, _BinaryPredicate __binary_pred, + input_iterator_tag, output_iterator_tag) + { + // concept requirements -- iterators already checked + __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate, + typename iterator_traits<_InputIterator>::value_type, + typename iterator_traits<_InputIterator>::value_type>) + + typename iterator_traits<_InputIterator>::value_type __value = *__first; + __decltype(__gnu_cxx::__ops::__iter_comp_val(__binary_pred)) + __rebound_pred + = __gnu_cxx::__ops::__iter_comp_val(__binary_pred); + *__result = __value; + while (++__first != __last) + if (!__rebound_pred(__first, __value)) + { + __value = *__first; + *++__result = __value; + } + return ++__result; + } + + /** + * This is an uglified + * unique_copy(_InputIterator, _InputIterator, _OutputIterator, + * _BinaryPredicate) + * overloaded for input iterators and forward iterator as result. + */ + template + _ForwardIterator + __unique_copy(_InputIterator __first, _InputIterator __last, + _ForwardIterator __result, _BinaryPredicate __binary_pred, + input_iterator_tag, forward_iterator_tag) + { + // concept requirements -- iterators already checked + __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate, + typename iterator_traits<_ForwardIterator>::value_type, + typename iterator_traits<_InputIterator>::value_type>) + *__result = *__first; + while (++__first != __last) + if (!__binary_pred(__result, __first)) + *++__result = *__first; + return ++__result; + } + + /** + * This is an uglified reverse(_BidirectionalIterator, + * _BidirectionalIterator) + * overloaded for bidirectional iterators. + */ + template + void + __reverse(_BidirectionalIterator __first, _BidirectionalIterator __last, + bidirectional_iterator_tag) + { + while (true) + if (__first == __last || __first == --__last) + return; + else + { + std::iter_swap(__first, __last); + ++__first; + } + } + + /** + * This is an uglified reverse(_BidirectionalIterator, + * _BidirectionalIterator) + * overloaded for random access iterators. + */ + template + void + __reverse(_RandomAccessIterator __first, _RandomAccessIterator __last, + random_access_iterator_tag) + { + if (__first == __last) + return; + --__last; + while (__first < __last) + { + std::iter_swap(__first, __last); + ++__first; + --__last; + } + } + + /** + * @brief Reverse a sequence. + * @ingroup mutating_algorithms + * @param __first A bidirectional iterator. + * @param __last A bidirectional iterator. + * @return reverse() returns no value. + * + * Reverses the order of the elements in the range @p [__first,__last), + * so that the first element becomes the last etc. + * For every @c i such that @p 0<=i<=(__last-__first)/2), @p reverse() + * swaps @p *(__first+i) and @p *(__last-(i+1)) + */ + template + inline void + reverse(_BidirectionalIterator __first, _BidirectionalIterator __last) + { + // concept requirements + __glibcxx_function_requires(_Mutable_BidirectionalIteratorConcept< + _BidirectionalIterator>) + __glibcxx_requires_valid_range(__first, __last); + std::__reverse(__first, __last, std::__iterator_category(__first)); + } + + /** + * @brief Copy a sequence, reversing its elements. + * @ingroup mutating_algorithms + * @param __first A bidirectional iterator. + * @param __last A bidirectional iterator. + * @param __result An output iterator. + * @return An iterator designating the end of the resulting sequence. + * + * Copies the elements in the range @p [__first,__last) to the + * range @p [__result,__result+(__last-__first)) such that the + * order of the elements is reversed. For every @c i such that @p + * 0<=i<=(__last-__first), @p reverse_copy() performs the + * assignment @p *(__result+(__last-__first)-1-i) = *(__first+i). + * The ranges @p [__first,__last) and @p + * [__result,__result+(__last-__first)) must not overlap. + */ + template + _OutputIterator + reverse_copy(_BidirectionalIterator __first, _BidirectionalIterator __last, + _OutputIterator __result) + { + // concept requirements + __glibcxx_function_requires(_BidirectionalIteratorConcept< + _BidirectionalIterator>) + __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator, + typename iterator_traits<_BidirectionalIterator>::value_type>) + __glibcxx_requires_valid_range(__first, __last); + + while (__first != __last) + { + --__last; + *__result = *__last; + ++__result; + } + return __result; + } + + /** + * This is a helper function for the rotate algorithm specialized on RAIs. + * It returns the greatest common divisor of two integer values. + */ + template + _EuclideanRingElement + __gcd(_EuclideanRingElement __m, _EuclideanRingElement __n) + { + while (__n != 0) + { + _EuclideanRingElement __t = __m % __n; + __m = __n; + __n = __t; + } + return __m; + } + + /// This is a helper function for the rotate algorithm. + template + void + __rotate(_ForwardIterator __first, + _ForwardIterator __middle, + _ForwardIterator __last, + forward_iterator_tag) + { + if (__first == __middle || __last == __middle) + return; + + _ForwardIterator __first2 = __middle; + do + { + std::iter_swap(__first, __first2); + ++__first; + ++__first2; + if (__first == __middle) + __middle = __first2; + } + while (__first2 != __last); + + __first2 = __middle; + + while (__first2 != __last) + { + std::iter_swap(__first, __first2); + ++__first; + ++__first2; + if (__first == __middle) + __middle = __first2; + else if (__first2 == __last) + __first2 = __middle; + } + } + + /// This is a helper function for the rotate algorithm. + template + void + __rotate(_BidirectionalIterator __first, + _BidirectionalIterator __middle, + _BidirectionalIterator __last, + bidirectional_iterator_tag) + { + // concept requirements + __glibcxx_function_requires(_Mutable_BidirectionalIteratorConcept< + _BidirectionalIterator>) + + if (__first == __middle || __last == __middle) + return; + + std::__reverse(__first, __middle, bidirectional_iterator_tag()); + std::__reverse(__middle, __last, bidirectional_iterator_tag()); + + while (__first != __middle && __middle != __last) + { + std::iter_swap(__first, --__last); + ++__first; + } + + if (__first == __middle) + std::__reverse(__middle, __last, bidirectional_iterator_tag()); + else + std::__reverse(__first, __middle, bidirectional_iterator_tag()); + } + + /// This is a helper function for the rotate algorithm. + template + void + __rotate(_RandomAccessIterator __first, + _RandomAccessIterator __middle, + _RandomAccessIterator __last, + random_access_iterator_tag) + { + // concept requirements + __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept< + _RandomAccessIterator>) + + if (__first == __middle || __last == __middle) + return; + + typedef typename iterator_traits<_RandomAccessIterator>::difference_type + _Distance; + typedef typename iterator_traits<_RandomAccessIterator>::value_type + _ValueType; + + _Distance __n = __last - __first; + _Distance __k = __middle - __first; + + if (__k == __n - __k) + { + std::swap_ranges(__first, __middle, __middle); + return; + } + + _RandomAccessIterator __p = __first; + + for (;;) + { + if (__k < __n - __k) + { + if (__is_pod(_ValueType) && __k == 1) + { + _ValueType __t = _GLIBCXX_MOVE(*__p); + _GLIBCXX_MOVE3(__p + 1, __p + __n, __p); + *(__p + __n - 1) = _GLIBCXX_MOVE(__t); + return; + } + _RandomAccessIterator __q = __p + __k; + for (_Distance __i = 0; __i < __n - __k; ++ __i) + { + std::iter_swap(__p, __q); + ++__p; + ++__q; + } + __n %= __k; + if (__n == 0) + return; + std::swap(__n, __k); + __k = __n - __k; + } + else + { + __k = __n - __k; + if (__is_pod(_ValueType) && __k == 1) + { + _ValueType __t = _GLIBCXX_MOVE(*(__p + __n - 1)); + _GLIBCXX_MOVE_BACKWARD3(__p, __p + __n - 1, __p + __n); + *__p = _GLIBCXX_MOVE(__t); + return; + } + _RandomAccessIterator __q = __p + __n; + __p = __q - __k; + for (_Distance __i = 0; __i < __n - __k; ++ __i) + { + --__p; + --__q; + std::iter_swap(__p, __q); + } + __n %= __k; + if (__n == 0) + return; + std::swap(__n, __k); + } + } + } + + /** + * @brief Rotate the elements of a sequence. + * @ingroup mutating_algorithms + * @param __first A forward iterator. + * @param __middle A forward iterator. + * @param __last A forward iterator. + * @return Nothing. + * + * Rotates the elements of the range @p [__first,__last) by + * @p (__middle - __first) positions so that the element at @p __middle + * is moved to @p __first, the element at @p __middle+1 is moved to + * @p __first+1 and so on for each element in the range + * @p [__first,__last). + * + * This effectively swaps the ranges @p [__first,__middle) and + * @p [__middle,__last). + * + * Performs + * @p *(__first+(n+(__last-__middle))%(__last-__first))=*(__first+n) + * for each @p n in the range @p [0,__last-__first). + */ + template + inline void + rotate(_ForwardIterator __first, _ForwardIterator __middle, + _ForwardIterator __last) + { + // concept requirements + __glibcxx_function_requires(_Mutable_ForwardIteratorConcept< + _ForwardIterator>) + __glibcxx_requires_valid_range(__first, __middle); + __glibcxx_requires_valid_range(__middle, __last); + + std::__rotate(__first, __middle, __last, + std::__iterator_category(__first)); + } + + /** + * @brief Copy a sequence, rotating its elements. + * @ingroup mutating_algorithms + * @param __first A forward iterator. + * @param __middle A forward iterator. + * @param __last A forward iterator. + * @param __result An output iterator. + * @return An iterator designating the end of the resulting sequence. + * + * Copies the elements of the range @p [__first,__last) to the + * range beginning at @result, rotating the copied elements by + * @p (__middle-__first) positions so that the element at @p __middle + * is moved to @p __result, the element at @p __middle+1 is moved + * to @p __result+1 and so on for each element in the range @p + * [__first,__last). + * + * Performs + * @p *(__result+(n+(__last-__middle))%(__last-__first))=*(__first+n) + * for each @p n in the range @p [0,__last-__first). + */ + template + inline _OutputIterator + rotate_copy(_ForwardIterator __first, _ForwardIterator __middle, + _ForwardIterator __last, _OutputIterator __result) + { + // concept requirements + __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>) + __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator, + typename iterator_traits<_ForwardIterator>::value_type>) + __glibcxx_requires_valid_range(__first, __middle); + __glibcxx_requires_valid_range(__middle, __last); + + return std::copy(__first, __middle, + std::copy(__middle, __last, __result)); + } + + /// This is a helper function... + template + _ForwardIterator + __partition(_ForwardIterator __first, _ForwardIterator __last, + _Predicate __pred, forward_iterator_tag) + { + if (__first == __last) + return __first; + + while (__pred(*__first)) + if (++__first == __last) + return __first; + + _ForwardIterator __next = __first; + + while (++__next != __last) + if (__pred(*__next)) + { + std::iter_swap(__first, __next); + ++__first; + } + + return __first; + } + + /// This is a helper function... + template + _BidirectionalIterator + __partition(_BidirectionalIterator __first, _BidirectionalIterator __last, + _Predicate __pred, bidirectional_iterator_tag) + { + while (true) + { + while (true) + if (__first == __last) + return __first; + else if (__pred(*__first)) + ++__first; + else + break; + --__last; + while (true) + if (__first == __last) + return __first; + else if (!bool(__pred(*__last))) + --__last; + else + break; + std::iter_swap(__first, __last); + ++__first; + } + } + + // partition + + /// This is a helper function... + /// Requires __len != 0 and !__pred(*__first), + /// same as __stable_partition_adaptive. + template + _ForwardIterator + __inplace_stable_partition(_ForwardIterator __first, + _Predicate __pred, _Distance __len) + { + if (__len == 1) + return __first; + _ForwardIterator __middle = __first; + std::advance(__middle, __len / 2); + _ForwardIterator __left_split = + std::__inplace_stable_partition(__first, __pred, __len / 2); + // Advance past true-predicate values to satisfy this + // function's preconditions. + _Distance __right_len = __len - __len / 2; + _ForwardIterator __right_split = + std::__find_if_not_n(__middle, __right_len, __pred); + if (__right_len) + __right_split = std::__inplace_stable_partition(__middle, + __pred, + __right_len); + std::rotate(__left_split, __middle, __right_split); + std::advance(__left_split, std::distance(__middle, __right_split)); + return __left_split; + } + + /// This is a helper function... + /// Requires __first != __last and !__pred(__first) + /// and __len == distance(__first, __last). + /// + /// !__pred(__first) allows us to guarantee that we don't + /// move-assign an element onto itself. + template + _ForwardIterator + __stable_partition_adaptive(_ForwardIterator __first, + _ForwardIterator __last, + _Predicate __pred, _Distance __len, + _Pointer __buffer, + _Distance __buffer_size) + { + if (__len <= __buffer_size) + { + _ForwardIterator __result1 = __first; + _Pointer __result2 = __buffer; + // The precondition guarantees that !__pred(__first), so + // move that element to the buffer before starting the loop. + // This ensures that we only call __pred once per element. + *__result2 = _GLIBCXX_MOVE(*__first); + ++__result2; + ++__first; + for (; __first != __last; ++__first) + if (__pred(__first)) + { + *__result1 = _GLIBCXX_MOVE(*__first); + ++__result1; + } + else + { + *__result2 = _GLIBCXX_MOVE(*__first); + ++__result2; + } + _GLIBCXX_MOVE3(__buffer, __result2, __result1); + return __result1; + } + else + { + _ForwardIterator __middle = __first; + std::advance(__middle, __len / 2); + _ForwardIterator __left_split = + std::__stable_partition_adaptive(__first, __middle, __pred, + __len / 2, __buffer, + __buffer_size); + // Advance past true-predicate values to satisfy this + // function's preconditions. + _Distance __right_len = __len - __len / 2; + _ForwardIterator __right_split = + std::__find_if_not_n(__middle, __right_len, __pred); + if (__right_len) + __right_split = + std::__stable_partition_adaptive(__right_split, __last, __pred, + __right_len, + __buffer, __buffer_size); + std::rotate(__left_split, __middle, __right_split); + std::advance(__left_split, std::distance(__middle, __right_split)); + return __left_split; + } + } + + template + _ForwardIterator + __stable_partition(_ForwardIterator __first, _ForwardIterator __last, + _Predicate __pred) + { + __first = std::__find_if_not(__first, __last, __pred); + + if (__first == __last) + return __first; + + typedef typename iterator_traits<_ForwardIterator>::value_type + _ValueType; + typedef typename iterator_traits<_ForwardIterator>::difference_type + _DistanceType; + + _Temporary_buffer<_ForwardIterator, _ValueType> __buf(__first, __last); + if (__buf.size() > 0) + return + std::__stable_partition_adaptive(__first, __last, __pred, + _DistanceType(__buf.requested_size()), + __buf.begin(), + _DistanceType(__buf.size())); + else + return + std::__inplace_stable_partition(__first, __pred, + _DistanceType(__buf.requested_size())); + } + + /** + * @brief Move elements for which a predicate is true to the beginning + * of a sequence, preserving relative ordering. + * @ingroup mutating_algorithms + * @param __first A forward iterator. + * @param __last A forward iterator. + * @param __pred A predicate functor. + * @return An iterator @p middle such that @p __pred(i) is true for each + * iterator @p i in the range @p [first,middle) and false for each @p i + * in the range @p [middle,last). + * + * Performs the same function as @p partition() with the additional + * guarantee that the relative ordering of elements in each group is + * preserved, so any two elements @p x and @p y in the range + * @p [__first,__last) such that @p __pred(x)==__pred(y) will have the same + * relative ordering after calling @p stable_partition(). + */ + template + inline _ForwardIterator + stable_partition(_ForwardIterator __first, _ForwardIterator __last, + _Predicate __pred) + { + // concept requirements + __glibcxx_function_requires(_Mutable_ForwardIteratorConcept< + _ForwardIterator>) + __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate, + typename iterator_traits<_ForwardIterator>::value_type>) + __glibcxx_requires_valid_range(__first, __last); + + return std::__stable_partition(__first, __last, + __gnu_cxx::__ops::__pred_iter(__pred)); + } + + /// This is a helper function for the sort routines. + template + void + __heap_select(_RandomAccessIterator __first, + _RandomAccessIterator __middle, + _RandomAccessIterator __last, _Compare __comp) + { + std::__make_heap(__first, __middle, __comp); + for (_RandomAccessIterator __i = __middle; __i < __last; ++__i) + if (__comp(__i, __first)) + std::__pop_heap(__first, __middle, __i, __comp); + } + + // partial_sort + + template + _RandomAccessIterator + __partial_sort_copy(_InputIterator __first, _InputIterator __last, + _RandomAccessIterator __result_first, + _RandomAccessIterator __result_last, + _Compare __comp) + { + typedef typename iterator_traits<_InputIterator>::value_type + _InputValueType; + typedef iterator_traits<_RandomAccessIterator> _RItTraits; + typedef typename _RItTraits::difference_type _DistanceType; + + if (__result_first == __result_last) + return __result_last; + _RandomAccessIterator __result_real_last = __result_first; + while (__first != __last && __result_real_last != __result_last) + { + *__result_real_last = *__first; + ++__result_real_last; + ++__first; + } + + std::__make_heap(__result_first, __result_real_last, __comp); + while (__first != __last) + { + if (__comp(__first, __result_first)) + std::__adjust_heap(__result_first, _DistanceType(0), + _DistanceType(__result_real_last + - __result_first), + _InputValueType(*__first), __comp); + ++__first; + } + std::__sort_heap(__result_first, __result_real_last, __comp); + return __result_real_last; + } + + /** + * @brief Copy the smallest elements of a sequence. + * @ingroup sorting_algorithms + * @param __first An iterator. + * @param __last Another iterator. + * @param __result_first A random-access iterator. + * @param __result_last Another random-access iterator. + * @return An iterator indicating the end of the resulting sequence. + * + * Copies and sorts the smallest N values from the range @p [__first,__last) + * to the range beginning at @p __result_first, where the number of + * elements to be copied, @p N, is the smaller of @p (__last-__first) and + * @p (__result_last-__result_first). + * After the sort if @e i and @e j are iterators in the range + * @p [__result_first,__result_first+N) such that i precedes j then + * *j<*i is false. + * The value returned is @p __result_first+N. + */ + template + inline _RandomAccessIterator + partial_sort_copy(_InputIterator __first, _InputIterator __last, + _RandomAccessIterator __result_first, + _RandomAccessIterator __result_last) + { + typedef typename iterator_traits<_InputIterator>::value_type + _InputValueType; + typedef typename iterator_traits<_RandomAccessIterator>::value_type + _OutputValueType; + typedef typename iterator_traits<_RandomAccessIterator>::difference_type + _DistanceType; + + // concept requirements + __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>) + __glibcxx_function_requires(_ConvertibleConcept<_InputValueType, + _OutputValueType>) + __glibcxx_function_requires(_LessThanOpConcept<_InputValueType, + _OutputValueType>) + __glibcxx_function_requires(_LessThanComparableConcept<_OutputValueType>) + __glibcxx_requires_valid_range(__first, __last); + __glibcxx_requires_valid_range(__result_first, __result_last); + + return std::__partial_sort_copy(__first, __last, + __result_first, __result_last, + __gnu_cxx::__ops::__iter_less_iter()); + } + + /** + * @brief Copy the smallest elements of a sequence using a predicate for + * comparison. + * @ingroup sorting_algorithms + * @param __first An input iterator. + * @param __last Another input iterator. + * @param __result_first A random-access iterator. + * @param __result_last Another random-access iterator. + * @param __comp A comparison functor. + * @return An iterator indicating the end of the resulting sequence. + * + * Copies and sorts the smallest N values from the range @p [__first,__last) + * to the range beginning at @p result_first, where the number of + * elements to be copied, @p N, is the smaller of @p (__last-__first) and + * @p (__result_last-__result_first). + * After the sort if @e i and @e j are iterators in the range + * @p [__result_first,__result_first+N) such that i precedes j then + * @p __comp(*j,*i) is false. + * The value returned is @p __result_first+N. + */ + template + inline _RandomAccessIterator + partial_sort_copy(_InputIterator __first, _InputIterator __last, + _RandomAccessIterator __result_first, + _RandomAccessIterator __result_last, + _Compare __comp) + { + typedef typename iterator_traits<_InputIterator>::value_type + _InputValueType; + typedef typename iterator_traits<_RandomAccessIterator>::value_type + _OutputValueType; + typedef typename iterator_traits<_RandomAccessIterator>::difference_type + _DistanceType; + + // concept requirements + __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>) + __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept< + _RandomAccessIterator>) + __glibcxx_function_requires(_ConvertibleConcept<_InputValueType, + _OutputValueType>) + __glibcxx_function_requires(_BinaryPredicateConcept<_Compare, + _InputValueType, _OutputValueType>) + __glibcxx_function_requires(_BinaryPredicateConcept<_Compare, + _OutputValueType, _OutputValueType>) + __glibcxx_requires_valid_range(__first, __last); + __glibcxx_requires_valid_range(__result_first, __result_last); + + return std::__partial_sort_copy(__first, __last, + __result_first, __result_last, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } + + /// This is a helper function for the sort routine. + template + void + __unguarded_linear_insert(_RandomAccessIterator __last, + _Compare __comp) + { + typename iterator_traits<_RandomAccessIterator>::value_type + __val = _GLIBCXX_MOVE(*__last); + _RandomAccessIterator __next = __last; + --__next; + while (__comp(__val, __next)) + { + *__last = _GLIBCXX_MOVE(*__next); + __last = __next; + --__next; + } + *__last = _GLIBCXX_MOVE(__val); + } + + /// This is a helper function for the sort routine. + template + void + __insertion_sort(_RandomAccessIterator __first, + _RandomAccessIterator __last, _Compare __comp) + { + if (__first == __last) return; + + for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i) + { + if (__comp(__i, __first)) + { + typename iterator_traits<_RandomAccessIterator>::value_type + __val = _GLIBCXX_MOVE(*__i); + _GLIBCXX_MOVE_BACKWARD3(__first, __i, __i + 1); + *__first = _GLIBCXX_MOVE(__val); + } + else + std::__unguarded_linear_insert(__i, + __gnu_cxx::__ops::__val_comp_iter(__comp)); + } + } + + /// This is a helper function for the sort routine. + template + inline void + __unguarded_insertion_sort(_RandomAccessIterator __first, + _RandomAccessIterator __last, _Compare __comp) + { + for (_RandomAccessIterator __i = __first; __i != __last; ++__i) + std::__unguarded_linear_insert(__i, + __gnu_cxx::__ops::__val_comp_iter(__comp)); + } + + /** + * @doctodo + * This controls some aspect of the sort routines. + */ + enum { _S_threshold = 16 }; + + /// This is a helper function for the sort routine. + template + void + __final_insertion_sort(_RandomAccessIterator __first, + _RandomAccessIterator __last, _Compare __comp) + { + if (__last - __first > int(_S_threshold)) + { + std::__insertion_sort(__first, __first + int(_S_threshold), __comp); + std::__unguarded_insertion_sort(__first + int(_S_threshold), __last, + __comp); + } + else + std::__insertion_sort(__first, __last, __comp); + } + + /// This is a helper function... + template + _RandomAccessIterator + __unguarded_partition(_RandomAccessIterator __first, + _RandomAccessIterator __last, + _RandomAccessIterator __pivot, _Compare __comp) + { + while (true) + { + while (__comp(__first, __pivot)) + ++__first; + --__last; + while (__comp(__pivot, __last)) + --__last; + if (!(__first < __last)) + return __first; + std::iter_swap(__first, __last); + ++__first; + } + } + + /// This is a helper function... + template + inline _RandomAccessIterator + __unguarded_partition_pivot(_RandomAccessIterator __first, + _RandomAccessIterator __last, _Compare __comp) + { + _RandomAccessIterator __mid = __first + (__last - __first) / 2; + std::__move_median_to_first(__first, __first + 1, __mid, __last - 1, + __comp); + return std::__unguarded_partition(__first + 1, __last, __first, __comp); + } + + template + inline void + __partial_sort(_RandomAccessIterator __first, + _RandomAccessIterator __middle, + _RandomAccessIterator __last, + _Compare __comp) + { + std::__heap_select(__first, __middle, __last, __comp); + std::__sort_heap(__first, __middle, __comp); + } + + /// This is a helper function for the sort routine. + template + void + __introsort_loop(_RandomAccessIterator __first, + _RandomAccessIterator __last, + _Size __depth_limit, _Compare __comp) + { + while (__last - __first > int(_S_threshold)) + { + if (__depth_limit == 0) + { + std::__partial_sort(__first, __last, __last, __comp); + return; + } + --__depth_limit; + _RandomAccessIterator __cut = + std::__unguarded_partition_pivot(__first, __last, __comp); + std::__introsort_loop(__cut, __last, __depth_limit, __comp); + __last = __cut; + } + } + + // sort + + template + inline void + __sort(_RandomAccessIterator __first, _RandomAccessIterator __last, + _Compare __comp) + { + if (__first != __last) + { + std::__introsort_loop(__first, __last, + std::__lg(__last - __first) * 2, + __comp); + std::__final_insertion_sort(__first, __last, __comp); + } + } + + template + void + __introselect(_RandomAccessIterator __first, _RandomAccessIterator __nth, + _RandomAccessIterator __last, _Size __depth_limit, + _Compare __comp) + { + while (__last - __first > 3) + { + if (__depth_limit == 0) + { + std::__heap_select(__first, __nth + 1, __last, __comp); + // Place the nth largest element in its final position. + std::iter_swap(__first, __nth); + return; + } + --__depth_limit; + _RandomAccessIterator __cut = + std::__unguarded_partition_pivot(__first, __last, __comp); + if (__cut <= __nth) + __first = __cut; + else + __last = __cut; + } + std::__insertion_sort(__first, __last, __comp); + } + + // nth_element + + // lower_bound moved to stl_algobase.h + + /** + * @brief Finds the first position in which @p __val could be inserted + * without changing the ordering. + * @ingroup binary_search_algorithms + * @param __first An iterator. + * @param __last Another iterator. + * @param __val The search term. + * @param __comp A functor to use for comparisons. + * @return An iterator pointing to the first element not less + * than @p __val, or end() if every element is less + * than @p __val. + * @ingroup binary_search_algorithms + * + * The comparison function should have the same effects on ordering as + * the function used for the initial sort. + */ + template + inline _ForwardIterator + lower_bound(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __val, _Compare __comp) + { + typedef typename iterator_traits<_ForwardIterator>::value_type + _ValueType; + + // concept requirements + __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>) + __glibcxx_function_requires(_BinaryPredicateConcept<_Compare, + _ValueType, _Tp>) + __glibcxx_requires_partitioned_lower_pred(__first, __last, + __val, __comp); + + return std::__lower_bound(__first, __last, __val, + __gnu_cxx::__ops::__iter_comp_val(__comp)); + } + + template + _ForwardIterator + __upper_bound(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __val, _Compare __comp) + { + typedef typename iterator_traits<_ForwardIterator>::difference_type + _DistanceType; + + _DistanceType __len = std::distance(__first, __last); + + while (__len > 0) + { + _DistanceType __half = __len >> 1; + _ForwardIterator __middle = __first; + std::advance(__middle, __half); + if (__comp(__val, __middle)) + __len = __half; + else + { + __first = __middle; + ++__first; + __len = __len - __half - 1; + } + } + return __first; + } + + /** + * @brief Finds the last position in which @p __val could be inserted + * without changing the ordering. + * @ingroup binary_search_algorithms + * @param __first An iterator. + * @param __last Another iterator. + * @param __val The search term. + * @return An iterator pointing to the first element greater than @p __val, + * or end() if no elements are greater than @p __val. + * @ingroup binary_search_algorithms + */ + template + inline _ForwardIterator + upper_bound(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __val) + { + typedef typename iterator_traits<_ForwardIterator>::value_type + _ValueType; + + // concept requirements + __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>) + __glibcxx_function_requires(_LessThanOpConcept<_Tp, _ValueType>) + __glibcxx_requires_partitioned_upper(__first, __last, __val); + + return std::__upper_bound(__first, __last, __val, + __gnu_cxx::__ops::__val_less_iter()); + } + + /** + * @brief Finds the last position in which @p __val could be inserted + * without changing the ordering. + * @ingroup binary_search_algorithms + * @param __first An iterator. + * @param __last Another iterator. + * @param __val The search term. + * @param __comp A functor to use for comparisons. + * @return An iterator pointing to the first element greater than @p __val, + * or end() if no elements are greater than @p __val. + * @ingroup binary_search_algorithms + * + * The comparison function should have the same effects on ordering as + * the function used for the initial sort. + */ + template + inline _ForwardIterator + upper_bound(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __val, _Compare __comp) + { + typedef typename iterator_traits<_ForwardIterator>::value_type + _ValueType; + + // concept requirements + __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>) + __glibcxx_function_requires(_BinaryPredicateConcept<_Compare, + _Tp, _ValueType>) + __glibcxx_requires_partitioned_upper_pred(__first, __last, + __val, __comp); + + return std::__upper_bound(__first, __last, __val, + __gnu_cxx::__ops::__val_comp_iter(__comp)); + } + + template + pair<_ForwardIterator, _ForwardIterator> + __equal_range(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __val, + _CompareItTp __comp_it_val, _CompareTpIt __comp_val_it) + { + typedef typename iterator_traits<_ForwardIterator>::difference_type + _DistanceType; + + _DistanceType __len = std::distance(__first, __last); + + while (__len > 0) + { + _DistanceType __half = __len >> 1; + _ForwardIterator __middle = __first; + std::advance(__middle, __half); + if (__comp_it_val(__middle, __val)) + { + __first = __middle; + ++__first; + __len = __len - __half - 1; + } + else if (__comp_val_it(__val, __middle)) + __len = __half; + else + { + _ForwardIterator __left + = std::__lower_bound(__first, __middle, __val, __comp_it_val); + std::advance(__first, __len); + _ForwardIterator __right + = std::__upper_bound(++__middle, __first, __val, __comp_val_it); + return pair<_ForwardIterator, _ForwardIterator>(__left, __right); + } + } + return pair<_ForwardIterator, _ForwardIterator>(__first, __first); + } + + /** + * @brief Finds the largest subrange in which @p __val could be inserted + * at any place in it without changing the ordering. + * @ingroup binary_search_algorithms + * @param __first An iterator. + * @param __last Another iterator. + * @param __val The search term. + * @return An pair of iterators defining the subrange. + * @ingroup binary_search_algorithms + * + * This is equivalent to + * @code + * std::make_pair(lower_bound(__first, __last, __val), + * upper_bound(__first, __last, __val)) + * @endcode + * but does not actually call those functions. + */ + template + inline pair<_ForwardIterator, _ForwardIterator> + equal_range(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __val) + { + typedef typename iterator_traits<_ForwardIterator>::value_type + _ValueType; + + // concept requirements + __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>) + __glibcxx_function_requires(_LessThanOpConcept<_ValueType, _Tp>) + __glibcxx_function_requires(_LessThanOpConcept<_Tp, _ValueType>) + __glibcxx_requires_partitioned_lower(__first, __last, __val); + __glibcxx_requires_partitioned_upper(__first, __last, __val); + + return std::__equal_range(__first, __last, __val, + __gnu_cxx::__ops::__iter_less_val(), + __gnu_cxx::__ops::__val_less_iter()); + } + + /** + * @brief Finds the largest subrange in which @p __val could be inserted + * at any place in it without changing the ordering. + * @param __first An iterator. + * @param __last Another iterator. + * @param __val The search term. + * @param __comp A functor to use for comparisons. + * @return An pair of iterators defining the subrange. + * @ingroup binary_search_algorithms + * + * This is equivalent to + * @code + * std::make_pair(lower_bound(__first, __last, __val, __comp), + * upper_bound(__first, __last, __val, __comp)) + * @endcode + * but does not actually call those functions. + */ + template + inline pair<_ForwardIterator, _ForwardIterator> + equal_range(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __val, _Compare __comp) + { + typedef typename iterator_traits<_ForwardIterator>::value_type + _ValueType; + + // concept requirements + __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>) + __glibcxx_function_requires(_BinaryPredicateConcept<_Compare, + _ValueType, _Tp>) + __glibcxx_function_requires(_BinaryPredicateConcept<_Compare, + _Tp, _ValueType>) + __glibcxx_requires_partitioned_lower_pred(__first, __last, + __val, __comp); + __glibcxx_requires_partitioned_upper_pred(__first, __last, + __val, __comp); + + return std::__equal_range(__first, __last, __val, + __gnu_cxx::__ops::__iter_comp_val(__comp), + __gnu_cxx::__ops::__val_comp_iter(__comp)); + } + + /** + * @brief Determines whether an element exists in a range. + * @ingroup binary_search_algorithms + * @param __first An iterator. + * @param __last Another iterator. + * @param __val The search term. + * @return True if @p __val (or its equivalent) is in [@p + * __first,@p __last ]. + * + * Note that this does not actually return an iterator to @p __val. For + * that, use std::find or a container's specialized find member functions. + */ + template + bool + binary_search(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __val) + { + typedef typename iterator_traits<_ForwardIterator>::value_type + _ValueType; + + // concept requirements + __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>) + __glibcxx_function_requires(_LessThanOpConcept<_Tp, _ValueType>) + __glibcxx_requires_partitioned_lower(__first, __last, __val); + __glibcxx_requires_partitioned_upper(__first, __last, __val); + + _ForwardIterator __i + = std::__lower_bound(__first, __last, __val, + __gnu_cxx::__ops::__iter_less_val()); + return __i != __last && !(__val < *__i); + } + + /** + * @brief Determines whether an element exists in a range. + * @ingroup binary_search_algorithms + * @param __first An iterator. + * @param __last Another iterator. + * @param __val The search term. + * @param __comp A functor to use for comparisons. + * @return True if @p __val (or its equivalent) is in @p [__first,__last]. + * + * Note that this does not actually return an iterator to @p __val. For + * that, use std::find or a container's specialized find member functions. + * + * The comparison function should have the same effects on ordering as + * the function used for the initial sort. + */ + template + bool + binary_search(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __val, _Compare __comp) + { + typedef typename iterator_traits<_ForwardIterator>::value_type + _ValueType; + + // concept requirements + __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>) + __glibcxx_function_requires(_BinaryPredicateConcept<_Compare, + _Tp, _ValueType>) + __glibcxx_requires_partitioned_lower_pred(__first, __last, + __val, __comp); + __glibcxx_requires_partitioned_upper_pred(__first, __last, + __val, __comp); + + _ForwardIterator __i + = std::__lower_bound(__first, __last, __val, + __gnu_cxx::__ops::__iter_comp_val(__comp)); + return __i != __last && !bool(__comp(__val, *__i)); + } + + // merge + + /// This is a helper function for the __merge_adaptive routines. + template + void + __move_merge_adaptive(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _OutputIterator __result, _Compare __comp) + { + while (__first1 != __last1 && __first2 != __last2) + { + if (__comp(__first2, __first1)) + { + *__result = _GLIBCXX_MOVE(*__first2); + ++__first2; + } + else + { + *__result = _GLIBCXX_MOVE(*__first1); + ++__first1; + } + ++__result; + } + if (__first1 != __last1) + _GLIBCXX_MOVE3(__first1, __last1, __result); + } + + /// This is a helper function for the __merge_adaptive routines. + template + void + __move_merge_adaptive_backward(_BidirectionalIterator1 __first1, + _BidirectionalIterator1 __last1, + _BidirectionalIterator2 __first2, + _BidirectionalIterator2 __last2, + _BidirectionalIterator3 __result, + _Compare __comp) + { + if (__first1 == __last1) + { + _GLIBCXX_MOVE_BACKWARD3(__first2, __last2, __result); + return; + } + else if (__first2 == __last2) + return; + + --__last1; + --__last2; + while (true) + { + if (__comp(__last2, __last1)) + { + *--__result = _GLIBCXX_MOVE(*__last1); + if (__first1 == __last1) + { + _GLIBCXX_MOVE_BACKWARD3(__first2, ++__last2, __result); + return; + } + --__last1; + } + else + { + *--__result = _GLIBCXX_MOVE(*__last2); + if (__first2 == __last2) + return; + --__last2; + } + } + } + + /// This is a helper function for the merge routines. + template + _BidirectionalIterator1 + __rotate_adaptive(_BidirectionalIterator1 __first, + _BidirectionalIterator1 __middle, + _BidirectionalIterator1 __last, + _Distance __len1, _Distance __len2, + _BidirectionalIterator2 __buffer, + _Distance __buffer_size) + { + _BidirectionalIterator2 __buffer_end; + if (__len1 > __len2 && __len2 <= __buffer_size) + { + if (__len2) + { + __buffer_end = _GLIBCXX_MOVE3(__middle, __last, __buffer); + _GLIBCXX_MOVE_BACKWARD3(__first, __middle, __last); + return _GLIBCXX_MOVE3(__buffer, __buffer_end, __first); + } + else + return __first; + } + else if (__len1 <= __buffer_size) + { + if (__len1) + { + __buffer_end = _GLIBCXX_MOVE3(__first, __middle, __buffer); + _GLIBCXX_MOVE3(__middle, __last, __first); + return _GLIBCXX_MOVE_BACKWARD3(__buffer, __buffer_end, __last); + } + else + return __last; + } + else + { + std::rotate(__first, __middle, __last); + std::advance(__first, std::distance(__middle, __last)); + return __first; + } + } + + /// This is a helper function for the merge routines. + template + void + __merge_adaptive(_BidirectionalIterator __first, + _BidirectionalIterator __middle, + _BidirectionalIterator __last, + _Distance __len1, _Distance __len2, + _Pointer __buffer, _Distance __buffer_size, + _Compare __comp) + { + if (__len1 <= __len2 && __len1 <= __buffer_size) + { + _Pointer __buffer_end = _GLIBCXX_MOVE3(__first, __middle, __buffer); + std::__move_merge_adaptive(__buffer, __buffer_end, __middle, __last, + __first, __comp); + } + else if (__len2 <= __buffer_size) + { + _Pointer __buffer_end = _GLIBCXX_MOVE3(__middle, __last, __buffer); + std::__move_merge_adaptive_backward(__first, __middle, __buffer, + __buffer_end, __last, __comp); + } + else + { + _BidirectionalIterator __first_cut = __first; + _BidirectionalIterator __second_cut = __middle; + _Distance __len11 = 0; + _Distance __len22 = 0; + if (__len1 > __len2) + { + __len11 = __len1 / 2; + std::advance(__first_cut, __len11); + __second_cut + = std::__lower_bound(__middle, __last, *__first_cut, + __gnu_cxx::__ops::__iter_comp_val(__comp)); + __len22 = std::distance(__middle, __second_cut); + } + else + { + __len22 = __len2 / 2; + std::advance(__second_cut, __len22); + __first_cut + = std::__upper_bound(__first, __middle, *__second_cut, + __gnu_cxx::__ops::__val_comp_iter(__comp)); + __len11 = std::distance(__first, __first_cut); + } + _BidirectionalIterator __new_middle + = std::__rotate_adaptive(__first_cut, __middle, __second_cut, + __len1 - __len11, __len22, __buffer, + __buffer_size); + std::__merge_adaptive(__first, __first_cut, __new_middle, __len11, + __len22, __buffer, __buffer_size, __comp); + std::__merge_adaptive(__new_middle, __second_cut, __last, + __len1 - __len11, + __len2 - __len22, __buffer, + __buffer_size, __comp); + } + } + + /// This is a helper function for the merge routines. + template + void + __merge_without_buffer(_BidirectionalIterator __first, + _BidirectionalIterator __middle, + _BidirectionalIterator __last, + _Distance __len1, _Distance __len2, + _Compare __comp) + { + if (__len1 == 0 || __len2 == 0) + return; + if (__len1 + __len2 == 2) + { + if (__comp(__middle, __first)) + std::iter_swap(__first, __middle); + return; + } + _BidirectionalIterator __first_cut = __first; + _BidirectionalIterator __second_cut = __middle; + _Distance __len11 = 0; + _Distance __len22 = 0; + if (__len1 > __len2) + { + __len11 = __len1 / 2; + std::advance(__first_cut, __len11); + __second_cut + = std::__lower_bound(__middle, __last, *__first_cut, + __gnu_cxx::__ops::__iter_comp_val(__comp)); + __len22 = std::distance(__middle, __second_cut); + } + else + { + __len22 = __len2 / 2; + std::advance(__second_cut, __len22); + __first_cut + = std::__upper_bound(__first, __middle, *__second_cut, + __gnu_cxx::__ops::__val_comp_iter(__comp)); + __len11 = std::distance(__first, __first_cut); + } + std::rotate(__first_cut, __middle, __second_cut); + _BidirectionalIterator __new_middle = __first_cut; + std::advance(__new_middle, std::distance(__middle, __second_cut)); + std::__merge_without_buffer(__first, __first_cut, __new_middle, + __len11, __len22, __comp); + std::__merge_without_buffer(__new_middle, __second_cut, __last, + __len1 - __len11, __len2 - __len22, __comp); + } + + template + void + __inplace_merge(_BidirectionalIterator __first, + _BidirectionalIterator __middle, + _BidirectionalIterator __last, + _Compare __comp) + { + typedef typename iterator_traits<_BidirectionalIterator>::value_type + _ValueType; + typedef typename iterator_traits<_BidirectionalIterator>::difference_type + _DistanceType; + + if (__first == __middle || __middle == __last) + return; + + const _DistanceType __len1 = std::distance(__first, __middle); + const _DistanceType __len2 = std::distance(__middle, __last); + + typedef _Temporary_buffer<_BidirectionalIterator, _ValueType> _TmpBuf; + _TmpBuf __buf(__first, __last); + + if (__buf.begin() == 0) + std::__merge_without_buffer + (__first, __middle, __last, __len1, __len2, __comp); + else + std::__merge_adaptive + (__first, __middle, __last, __len1, __len2, __buf.begin(), + _DistanceType(__buf.size()), __comp); + } + + /** + * @brief Merges two sorted ranges in place. + * @ingroup sorting_algorithms + * @param __first An iterator. + * @param __middle Another iterator. + * @param __last Another iterator. + * @return Nothing. + * + * Merges two sorted and consecutive ranges, [__first,__middle) and + * [__middle,__last), and puts the result in [__first,__last). The + * output will be sorted. The sort is @e stable, that is, for + * equivalent elements in the two ranges, elements from the first + * range will always come before elements from the second. + * + * If enough additional memory is available, this takes (__last-__first)-1 + * comparisons. Otherwise an NlogN algorithm is used, where N is + * distance(__first,__last). + */ + template + inline void + inplace_merge(_BidirectionalIterator __first, + _BidirectionalIterator __middle, + _BidirectionalIterator __last) + { + // concept requirements + __glibcxx_function_requires(_Mutable_BidirectionalIteratorConcept< + _BidirectionalIterator>) + __glibcxx_function_requires(_LessThanComparableConcept< + typename iterator_traits<_BidirectionalIterator>::value_type>) + __glibcxx_requires_sorted(__first, __middle); + __glibcxx_requires_sorted(__middle, __last); + + std::__inplace_merge(__first, __middle, __last, + __gnu_cxx::__ops::__iter_less_iter()); + } + + /** + * @brief Merges two sorted ranges in place. + * @ingroup sorting_algorithms + * @param __first An iterator. + * @param __middle Another iterator. + * @param __last Another iterator. + * @param __comp A functor to use for comparisons. + * @return Nothing. + * + * Merges two sorted and consecutive ranges, [__first,__middle) and + * [middle,last), and puts the result in [__first,__last). The output will + * be sorted. The sort is @e stable, that is, for equivalent + * elements in the two ranges, elements from the first range will always + * come before elements from the second. + * + * If enough additional memory is available, this takes (__last-__first)-1 + * comparisons. Otherwise an NlogN algorithm is used, where N is + * distance(__first,__last). + * + * The comparison function should have the same effects on ordering as + * the function used for the initial sort. + */ + template + inline void + inplace_merge(_BidirectionalIterator __first, + _BidirectionalIterator __middle, + _BidirectionalIterator __last, + _Compare __comp) + { + // concept requirements + __glibcxx_function_requires(_Mutable_BidirectionalIteratorConcept< + _BidirectionalIterator>) + __glibcxx_function_requires(_BinaryPredicateConcept<_Compare, + typename iterator_traits<_BidirectionalIterator>::value_type, + typename iterator_traits<_BidirectionalIterator>::value_type>) + __glibcxx_requires_sorted_pred(__first, __middle, __comp); + __glibcxx_requires_sorted_pred(__middle, __last, __comp); + + std::__inplace_merge(__first, __middle, __last, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } + + + /// This is a helper function for the __merge_sort_loop routines. + template + _OutputIterator + __move_merge(_InputIterator __first1, _InputIterator __last1, + _InputIterator __first2, _InputIterator __last2, + _OutputIterator __result, _Compare __comp) + { + while (__first1 != __last1 && __first2 != __last2) + { + if (__comp(__first2, __first1)) + { + *__result = _GLIBCXX_MOVE(*__first2); + ++__first2; + } + else + { + *__result = _GLIBCXX_MOVE(*__first1); + ++__first1; + } + ++__result; + } + return _GLIBCXX_MOVE3(__first2, __last2, + _GLIBCXX_MOVE3(__first1, __last1, + __result)); + } + + template + void + __merge_sort_loop(_RandomAccessIterator1 __first, + _RandomAccessIterator1 __last, + _RandomAccessIterator2 __result, _Distance __step_size, + _Compare __comp) + { + const _Distance __two_step = 2 * __step_size; + + while (__last - __first >= __two_step) + { + __result = std::__move_merge(__first, __first + __step_size, + __first + __step_size, + __first + __two_step, + __result, __comp); + __first += __two_step; + } + __step_size = std::min(_Distance(__last - __first), __step_size); + + std::__move_merge(__first, __first + __step_size, + __first + __step_size, __last, __result, __comp); + } + + template + void + __chunk_insertion_sort(_RandomAccessIterator __first, + _RandomAccessIterator __last, + _Distance __chunk_size, _Compare __comp) + { + while (__last - __first >= __chunk_size) + { + std::__insertion_sort(__first, __first + __chunk_size, __comp); + __first += __chunk_size; + } + std::__insertion_sort(__first, __last, __comp); + } + + enum { _S_chunk_size = 7 }; + + template + void + __merge_sort_with_buffer(_RandomAccessIterator __first, + _RandomAccessIterator __last, + _Pointer __buffer, _Compare __comp) + { + typedef typename iterator_traits<_RandomAccessIterator>::difference_type + _Distance; + + const _Distance __len = __last - __first; + const _Pointer __buffer_last = __buffer + __len; + + _Distance __step_size = _S_chunk_size; + std::__chunk_insertion_sort(__first, __last, __step_size, __comp); + + while (__step_size < __len) + { + std::__merge_sort_loop(__first, __last, __buffer, + __step_size, __comp); + __step_size *= 2; + std::__merge_sort_loop(__buffer, __buffer_last, __first, + __step_size, __comp); + __step_size *= 2; + } + } + + template + void + __stable_sort_adaptive(_RandomAccessIterator __first, + _RandomAccessIterator __last, + _Pointer __buffer, _Distance __buffer_size, + _Compare __comp) + { + const _Distance __len = (__last - __first + 1) / 2; + const _RandomAccessIterator __middle = __first + __len; + if (__len > __buffer_size) + { + std::__stable_sort_adaptive(__first, __middle, __buffer, + __buffer_size, __comp); + std::__stable_sort_adaptive(__middle, __last, __buffer, + __buffer_size, __comp); + } + else + { + std::__merge_sort_with_buffer(__first, __middle, __buffer, __comp); + std::__merge_sort_with_buffer(__middle, __last, __buffer, __comp); + } + std::__merge_adaptive(__first, __middle, __last, + _Distance(__middle - __first), + _Distance(__last - __middle), + __buffer, __buffer_size, + __comp); + } + + /// This is a helper function for the stable sorting routines. + template + void + __inplace_stable_sort(_RandomAccessIterator __first, + _RandomAccessIterator __last, _Compare __comp) + { + if (__last - __first < 15) + { + std::__insertion_sort(__first, __last, __comp); + return; + } + _RandomAccessIterator __middle = __first + (__last - __first) / 2; + std::__inplace_stable_sort(__first, __middle, __comp); + std::__inplace_stable_sort(__middle, __last, __comp); + std::__merge_without_buffer(__first, __middle, __last, + __middle - __first, + __last - __middle, + __comp); + } + + // stable_sort + + // Set algorithms: includes, set_union, set_intersection, set_difference, + // set_symmetric_difference. All of these algorithms have the precondition + // that their input ranges are sorted and the postcondition that their output + // ranges are sorted. + + template + bool + __includes(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _Compare __comp) + { + while (__first1 != __last1 && __first2 != __last2) + if (__comp(__first2, __first1)) + return false; + else if (__comp(__first1, __first2)) + ++__first1; + else + ++__first1, ++__first2; + + return __first2 == __last2; + } + + /** + * @brief Determines whether all elements of a sequence exists in a range. + * @param __first1 Start of search range. + * @param __last1 End of search range. + * @param __first2 Start of sequence + * @param __last2 End of sequence. + * @return True if each element in [__first2,__last2) is contained in order + * within [__first1,__last1). False otherwise. + * @ingroup set_algorithms + * + * This operation expects both [__first1,__last1) and + * [__first2,__last2) to be sorted. Searches for the presence of + * each element in [__first2,__last2) within [__first1,__last1). + * The iterators over each range only move forward, so this is a + * linear algorithm. If an element in [__first2,__last2) is not + * found before the search iterator reaches @p __last2, false is + * returned. + */ + template + inline bool + includes(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2) + { + // concept requirements + __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>) + __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>) + __glibcxx_function_requires(_LessThanOpConcept< + typename iterator_traits<_InputIterator1>::value_type, + typename iterator_traits<_InputIterator2>::value_type>) + __glibcxx_function_requires(_LessThanOpConcept< + typename iterator_traits<_InputIterator2>::value_type, + typename iterator_traits<_InputIterator1>::value_type>) + __glibcxx_requires_sorted_set(__first1, __last1, __first2); + __glibcxx_requires_sorted_set(__first2, __last2, __first1); + + return std::__includes(__first1, __last1, __first2, __last2, + __gnu_cxx::__ops::__iter_less_iter()); + } + + /** + * @brief Determines whether all elements of a sequence exists in a range + * using comparison. + * @ingroup set_algorithms + * @param __first1 Start of search range. + * @param __last1 End of search range. + * @param __first2 Start of sequence + * @param __last2 End of sequence. + * @param __comp Comparison function to use. + * @return True if each element in [__first2,__last2) is contained + * in order within [__first1,__last1) according to comp. False + * otherwise. @ingroup set_algorithms + * + * This operation expects both [__first1,__last1) and + * [__first2,__last2) to be sorted. Searches for the presence of + * each element in [__first2,__last2) within [__first1,__last1), + * using comp to decide. The iterators over each range only move + * forward, so this is a linear algorithm. If an element in + * [__first2,__last2) is not found before the search iterator + * reaches @p __last2, false is returned. + */ + template + inline bool + includes(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _Compare __comp) + { + // concept requirements + __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>) + __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>) + __glibcxx_function_requires(_BinaryPredicateConcept<_Compare, + typename iterator_traits<_InputIterator1>::value_type, + typename iterator_traits<_InputIterator2>::value_type>) + __glibcxx_function_requires(_BinaryPredicateConcept<_Compare, + typename iterator_traits<_InputIterator2>::value_type, + typename iterator_traits<_InputIterator1>::value_type>) + __glibcxx_requires_sorted_set_pred(__first1, __last1, __first2, __comp); + __glibcxx_requires_sorted_set_pred(__first2, __last2, __first1, __comp); + + return std::__includes(__first1, __last1, __first2, __last2, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } + + // nth_element + // merge + // set_difference + // set_intersection + // set_union + // stable_sort + // set_symmetric_difference + // min_element + // max_element + + template + bool + __next_permutation(_BidirectionalIterator __first, + _BidirectionalIterator __last, _Compare __comp) + { + if (__first == __last) + return false; + _BidirectionalIterator __i = __first; + ++__i; + if (__i == __last) + return false; + __i = __last; + --__i; + + for(;;) + { + _BidirectionalIterator __ii = __i; + --__i; + if (__comp(__i, __ii)) + { + _BidirectionalIterator __j = __last; + while (!__comp(__i, --__j)) + {} + std::iter_swap(__i, __j); + std::__reverse(__ii, __last, + std::__iterator_category(__first)); + return true; + } + if (__i == __first) + { + std::__reverse(__first, __last, + std::__iterator_category(__first)); + return false; + } + } + } + + /** + * @brief Permute range into the next @e dictionary ordering. + * @ingroup sorting_algorithms + * @param __first Start of range. + * @param __last End of range. + * @return False if wrapped to first permutation, true otherwise. + * + * Treats all permutations of the range as a set of @e dictionary sorted + * sequences. Permutes the current sequence into the next one of this set. + * Returns true if there are more sequences to generate. If the sequence + * is the largest of the set, the smallest is generated and false returned. + */ + template + inline bool + next_permutation(_BidirectionalIterator __first, + _BidirectionalIterator __last) + { + // concept requirements + __glibcxx_function_requires(_BidirectionalIteratorConcept< + _BidirectionalIterator>) + __glibcxx_function_requires(_LessThanComparableConcept< + typename iterator_traits<_BidirectionalIterator>::value_type>) + __glibcxx_requires_valid_range(__first, __last); + + return std::__next_permutation + (__first, __last, __gnu_cxx::__ops::__iter_less_iter()); + } + + /** + * @brief Permute range into the next @e dictionary ordering using + * comparison functor. + * @ingroup sorting_algorithms + * @param __first Start of range. + * @param __last End of range. + * @param __comp A comparison functor. + * @return False if wrapped to first permutation, true otherwise. + * + * Treats all permutations of the range [__first,__last) as a set of + * @e dictionary sorted sequences ordered by @p __comp. Permutes the current + * sequence into the next one of this set. Returns true if there are more + * sequences to generate. If the sequence is the largest of the set, the + * smallest is generated and false returned. + */ + template + inline bool + next_permutation(_BidirectionalIterator __first, + _BidirectionalIterator __last, _Compare __comp) + { + // concept requirements + __glibcxx_function_requires(_BidirectionalIteratorConcept< + _BidirectionalIterator>) + __glibcxx_function_requires(_BinaryPredicateConcept<_Compare, + typename iterator_traits<_BidirectionalIterator>::value_type, + typename iterator_traits<_BidirectionalIterator>::value_type>) + __glibcxx_requires_valid_range(__first, __last); + + return std::__next_permutation + (__first, __last, __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } + + template + bool + __prev_permutation(_BidirectionalIterator __first, + _BidirectionalIterator __last, _Compare __comp) + { + if (__first == __last) + return false; + _BidirectionalIterator __i = __first; + ++__i; + if (__i == __last) + return false; + __i = __last; + --__i; + + for(;;) + { + _BidirectionalIterator __ii = __i; + --__i; + if (__comp(__ii, __i)) + { + _BidirectionalIterator __j = __last; + while (!__comp(--__j, __i)) + {} + std::iter_swap(__i, __j); + std::__reverse(__ii, __last, + std::__iterator_category(__first)); + return true; + } + if (__i == __first) + { + std::__reverse(__first, __last, + std::__iterator_category(__first)); + return false; + } + } + } + + /** + * @brief Permute range into the previous @e dictionary ordering. + * @ingroup sorting_algorithms + * @param __first Start of range. + * @param __last End of range. + * @return False if wrapped to last permutation, true otherwise. + * + * Treats all permutations of the range as a set of @e dictionary sorted + * sequences. Permutes the current sequence into the previous one of this + * set. Returns true if there are more sequences to generate. If the + * sequence is the smallest of the set, the largest is generated and false + * returned. + */ + template + inline bool + prev_permutation(_BidirectionalIterator __first, + _BidirectionalIterator __last) + { + // concept requirements + __glibcxx_function_requires(_BidirectionalIteratorConcept< + _BidirectionalIterator>) + __glibcxx_function_requires(_LessThanComparableConcept< + typename iterator_traits<_BidirectionalIterator>::value_type>) + __glibcxx_requires_valid_range(__first, __last); + + return std::__prev_permutation(__first, __last, + __gnu_cxx::__ops::__iter_less_iter()); + } + + /** + * @brief Permute range into the previous @e dictionary ordering using + * comparison functor. + * @ingroup sorting_algorithms + * @param __first Start of range. + * @param __last End of range. + * @param __comp A comparison functor. + * @return False if wrapped to last permutation, true otherwise. + * + * Treats all permutations of the range [__first,__last) as a set of + * @e dictionary sorted sequences ordered by @p __comp. Permutes the current + * sequence into the previous one of this set. Returns true if there are + * more sequences to generate. If the sequence is the smallest of the set, + * the largest is generated and false returned. + */ + template + inline bool + prev_permutation(_BidirectionalIterator __first, + _BidirectionalIterator __last, _Compare __comp) + { + // concept requirements + __glibcxx_function_requires(_BidirectionalIteratorConcept< + _BidirectionalIterator>) + __glibcxx_function_requires(_BinaryPredicateConcept<_Compare, + typename iterator_traits<_BidirectionalIterator>::value_type, + typename iterator_traits<_BidirectionalIterator>::value_type>) + __glibcxx_requires_valid_range(__first, __last); + + return std::__prev_permutation(__first, __last, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } + + // replace + // replace_if + + template + _OutputIterator + __replace_copy_if(_InputIterator __first, _InputIterator __last, + _OutputIterator __result, + _Predicate __pred, const _Tp& __new_value) + { + for (; __first != __last; ++__first, ++__result) + if (__pred(__first)) + *__result = __new_value; + else + *__result = *__first; + return __result; + } + + /** + * @brief Copy a sequence, replacing each element of one value with another + * value. + * @param __first An input iterator. + * @param __last An input iterator. + * @param __result An output iterator. + * @param __old_value The value to be replaced. + * @param __new_value The replacement value. + * @return The end of the output sequence, @p result+(last-first). + * + * Copies each element in the input range @p [__first,__last) to the + * output range @p [__result,__result+(__last-__first)) replacing elements + * equal to @p __old_value with @p __new_value. + */ + template + inline _OutputIterator + replace_copy(_InputIterator __first, _InputIterator __last, + _OutputIterator __result, + const _Tp& __old_value, const _Tp& __new_value) + { + // concept requirements + __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>) + __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator, + typename iterator_traits<_InputIterator>::value_type>) + __glibcxx_function_requires(_EqualOpConcept< + typename iterator_traits<_InputIterator>::value_type, _Tp>) + __glibcxx_requires_valid_range(__first, __last); + + return std::__replace_copy_if(__first, __last, __result, + __gnu_cxx::__ops::__iter_equals_val(__old_value), + __new_value); + } + + /** + * @brief Copy a sequence, replacing each value for which a predicate + * returns true with another value. + * @ingroup mutating_algorithms + * @param __first An input iterator. + * @param __last An input iterator. + * @param __result An output iterator. + * @param __pred A predicate. + * @param __new_value The replacement value. + * @return The end of the output sequence, @p __result+(__last-__first). + * + * Copies each element in the range @p [__first,__last) to the range + * @p [__result,__result+(__last-__first)) replacing elements for which + * @p __pred returns true with @p __new_value. + */ + template + inline _OutputIterator + replace_copy_if(_InputIterator __first, _InputIterator __last, + _OutputIterator __result, + _Predicate __pred, const _Tp& __new_value) + { + // concept requirements + __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>) + __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator, + typename iterator_traits<_InputIterator>::value_type>) + __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate, + typename iterator_traits<_InputIterator>::value_type>) + __glibcxx_requires_valid_range(__first, __last); + + return std::__replace_copy_if(__first, __last, __result, + __gnu_cxx::__ops::__pred_iter(__pred), + __new_value); + } + + template + typename iterator_traits<_InputIterator>::difference_type + __count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred) + { + typename iterator_traits<_InputIterator>::difference_type __n = 0; + for (; __first != __last; ++__first) + if (__pred(__first)) + ++__n; + return __n; + } + +#if __cplusplus >= 201103L + /** + * @brief Determines whether the elements of a sequence are sorted. + * @ingroup sorting_algorithms + * @param __first An iterator. + * @param __last Another iterator. + * @return True if the elements are sorted, false otherwise. + */ + template + inline bool + is_sorted(_ForwardIterator __first, _ForwardIterator __last) + { return std::is_sorted_until(__first, __last) == __last; } + + /** + * @brief Determines whether the elements of a sequence are sorted + * according to a comparison functor. + * @ingroup sorting_algorithms + * @param __first An iterator. + * @param __last Another iterator. + * @param __comp A comparison functor. + * @return True if the elements are sorted, false otherwise. + */ + template + inline bool + is_sorted(_ForwardIterator __first, _ForwardIterator __last, + _Compare __comp) + { return std::is_sorted_until(__first, __last, __comp) == __last; } + + template + _ForwardIterator + __is_sorted_until(_ForwardIterator __first, _ForwardIterator __last, + _Compare __comp) + { + if (__first == __last) + return __last; + + _ForwardIterator __next = __first; + for (++__next; __next != __last; __first = __next, ++__next) + if (__comp(__next, __first)) + return __next; + return __next; + } + + /** + * @brief Determines the end of a sorted sequence. + * @ingroup sorting_algorithms + * @param __first An iterator. + * @param __last Another iterator. + * @return An iterator pointing to the last iterator i in [__first, __last) + * for which the range [__first, i) is sorted. + */ + template + inline _ForwardIterator + is_sorted_until(_ForwardIterator __first, _ForwardIterator __last) + { + // concept requirements + __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>) + __glibcxx_function_requires(_LessThanComparableConcept< + typename iterator_traits<_ForwardIterator>::value_type>) + __glibcxx_requires_valid_range(__first, __last); + + return std::__is_sorted_until(__first, __last, + __gnu_cxx::__ops::__iter_less_iter()); + } + + /** + * @brief Determines the end of a sorted sequence using comparison functor. + * @ingroup sorting_algorithms + * @param __first An iterator. + * @param __last Another iterator. + * @param __comp A comparison functor. + * @return An iterator pointing to the last iterator i in [__first, __last) + * for which the range [__first, i) is sorted. + */ + template + inline _ForwardIterator + is_sorted_until(_ForwardIterator __first, _ForwardIterator __last, + _Compare __comp) + { + // concept requirements + __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>) + __glibcxx_function_requires(_BinaryPredicateConcept<_Compare, + typename iterator_traits<_ForwardIterator>::value_type, + typename iterator_traits<_ForwardIterator>::value_type>) + __glibcxx_requires_valid_range(__first, __last); + + return std::__is_sorted_until(__first, __last, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } + + /** + * @brief Determines min and max at once as an ordered pair. + * @ingroup sorting_algorithms + * @param __a A thing of arbitrary type. + * @param __b Another thing of arbitrary type. + * @return A pair(__b, __a) if __b is smaller than __a, pair(__a, + * __b) otherwise. + */ + template + inline pair + minmax(const _Tp& __a, const _Tp& __b) + { + // concept requirements + __glibcxx_function_requires(_LessThanComparableConcept<_Tp>) + + return __b < __a ? pair(__b, __a) + : pair(__a, __b); + } + + /** + * @brief Determines min and max at once as an ordered pair. + * @ingroup sorting_algorithms + * @param __a A thing of arbitrary type. + * @param __b Another thing of arbitrary type. + * @param __comp A @link comparison_functors comparison functor @endlink. + * @return A pair(__b, __a) if __b is smaller than __a, pair(__a, + * __b) otherwise. + */ + template + inline pair + minmax(const _Tp& __a, const _Tp& __b, _Compare __comp) + { + return __comp(__b, __a) ? pair(__b, __a) + : pair(__a, __b); + } + + template + pair<_ForwardIterator, _ForwardIterator> + __minmax_element(_ForwardIterator __first, _ForwardIterator __last, + _Compare __comp) + { + _ForwardIterator __next = __first; + if (__first == __last + || ++__next == __last) + return std::make_pair(__first, __first); + + _ForwardIterator __min, __max; + if (__comp(__next, __first)) + { + __min = __next; + __max = __first; + } + else + { + __min = __first; + __max = __next; + } + + __first = __next; + ++__first; + + while (__first != __last) + { + __next = __first; + if (++__next == __last) + { + if (__comp(__first, __min)) + __min = __first; + else if (!__comp(__first, __max)) + __max = __first; + break; + } + + if (__comp(__next, __first)) + { + if (__comp(__next, __min)) + __min = __next; + if (!__comp(__first, __max)) + __max = __first; + } + else + { + if (__comp(__first, __min)) + __min = __first; + if (!__comp(__next, __max)) + __max = __next; + } + + __first = __next; + ++__first; + } + + return std::make_pair(__min, __max); + } + + /** + * @brief Return a pair of iterators pointing to the minimum and maximum + * elements in a range. + * @ingroup sorting_algorithms + * @param __first Start of range. + * @param __last End of range. + * @return make_pair(m, M), where m is the first iterator i in + * [__first, __last) such that no other element in the range is + * smaller, and where M is the last iterator i in [__first, __last) + * such that no other element in the range is larger. + */ + template + inline pair<_ForwardIterator, _ForwardIterator> + minmax_element(_ForwardIterator __first, _ForwardIterator __last) + { + // concept requirements + __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>) + __glibcxx_function_requires(_LessThanComparableConcept< + typename iterator_traits<_ForwardIterator>::value_type>) + __glibcxx_requires_valid_range(__first, __last); + + return std::__minmax_element(__first, __last, + __gnu_cxx::__ops::__iter_less_iter()); + } + + /** + * @brief Return a pair of iterators pointing to the minimum and maximum + * elements in a range. + * @ingroup sorting_algorithms + * @param __first Start of range. + * @param __last End of range. + * @param __comp Comparison functor. + * @return make_pair(m, M), where m is the first iterator i in + * [__first, __last) such that no other element in the range is + * smaller, and where M is the last iterator i in [__first, __last) + * such that no other element in the range is larger. + */ + template + inline pair<_ForwardIterator, _ForwardIterator> + minmax_element(_ForwardIterator __first, _ForwardIterator __last, + _Compare __comp) + { + // concept requirements + __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>) + __glibcxx_function_requires(_BinaryPredicateConcept<_Compare, + typename iterator_traits<_ForwardIterator>::value_type, + typename iterator_traits<_ForwardIterator>::value_type>) + __glibcxx_requires_valid_range(__first, __last); + + return std::__minmax_element(__first, __last, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } + + // N2722 + DR 915. + template + inline _Tp + min(initializer_list<_Tp> __l) + { return *std::min_element(__l.begin(), __l.end()); } + + template + inline _Tp + min(initializer_list<_Tp> __l, _Compare __comp) + { return *std::min_element(__l.begin(), __l.end(), __comp); } + + template + inline _Tp + max(initializer_list<_Tp> __l) + { return *std::max_element(__l.begin(), __l.end()); } + + template + inline _Tp + max(initializer_list<_Tp> __l, _Compare __comp) + { return *std::max_element(__l.begin(), __l.end(), __comp); } + + template + inline pair<_Tp, _Tp> + minmax(initializer_list<_Tp> __l) + { + pair __p = + std::minmax_element(__l.begin(), __l.end()); + return std::make_pair(*__p.first, *__p.second); + } + + template + inline pair<_Tp, _Tp> + minmax(initializer_list<_Tp> __l, _Compare __comp) + { + pair __p = + std::minmax_element(__l.begin(), __l.end(), __comp); + return std::make_pair(*__p.first, *__p.second); + } + + template + bool + __is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _BinaryPredicate __pred) + { + // Efficiently compare identical prefixes: O(N) if sequences + // have the same elements in the same order. + for (; __first1 != __last1; ++__first1, ++__first2) + if (!__pred(__first1, __first2)) + break; + + if (__first1 == __last1) + return true; + + // Establish __last2 assuming equal ranges by iterating over the + // rest of the list. + _ForwardIterator2 __last2 = __first2; + std::advance(__last2, std::distance(__first1, __last1)); + for (_ForwardIterator1 __scan = __first1; __scan != __last1; ++__scan) + { + if (__scan != std::__find_if(__first1, __scan, + __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan))) + continue; // We've seen this one before. + + auto __matches + = std::__count_if(__first2, __last2, + __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)); + if (0 == __matches || + std::__count_if(__scan, __last1, + __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)) + != __matches) + return false; + } + return true; + } + + /** + * @brief Checks whether a permutation of the second sequence is equal + * to the first sequence. + * @ingroup non_mutating_algorithms + * @param __first1 Start of first range. + * @param __last1 End of first range. + * @param __first2 Start of second range. + * @return true if there exists a permutation of the elements in the range + * [__first2, __first2 + (__last1 - __first1)), beginning with + * ForwardIterator2 begin, such that equal(__first1, __last1, begin) + * returns true; otherwise, returns false. + */ + template + inline bool + is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2) + { + // concept requirements + __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator1>) + __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator2>) + __glibcxx_function_requires(_EqualOpConcept< + typename iterator_traits<_ForwardIterator1>::value_type, + typename iterator_traits<_ForwardIterator2>::value_type>) + __glibcxx_requires_valid_range(__first1, __last1); + + return std::__is_permutation(__first1, __last1, __first2, + __gnu_cxx::__ops::__iter_equal_to_iter()); + } + + /** + * @brief Checks whether a permutation of the second sequence is equal + * to the first sequence. + * @ingroup non_mutating_algorithms + * @param __first1 Start of first range. + * @param __last1 End of first range. + * @param __first2 Start of second range. + * @param __pred A binary predicate. + * @return true if there exists a permutation of the elements in + * the range [__first2, __first2 + (__last1 - __first1)), + * beginning with ForwardIterator2 begin, such that + * equal(__first1, __last1, __begin, __pred) returns true; + * otherwise, returns false. + */ + template + inline bool + is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _BinaryPredicate __pred) + { + // concept requirements + __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator1>) + __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator2>) + __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate, + typename iterator_traits<_ForwardIterator1>::value_type, + typename iterator_traits<_ForwardIterator2>::value_type>) + __glibcxx_requires_valid_range(__first1, __last1); + + return std::__is_permutation(__first1, __last1, __first2, + __gnu_cxx::__ops::__iter_comp_iter(__pred)); + } + +#if __cplusplus > 201103L + template + bool + __is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2, + _BinaryPredicate __pred) + { + using _Cat1 + = typename iterator_traits<_ForwardIterator1>::iterator_category; + using _Cat2 + = typename iterator_traits<_ForwardIterator2>::iterator_category; + using _It1_is_RA = is_same<_Cat1, random_access_iterator_tag>; + using _It2_is_RA = is_same<_Cat2, random_access_iterator_tag>; + constexpr bool __ra_iters = _It1_is_RA() && _It2_is_RA(); + if (__ra_iters) + { + auto __d1 = std::distance(__first1, __last1); + auto __d2 = std::distance(__first2, __last2); + if (__d1 != __d2) + return false; + } + + // Efficiently compare identical prefixes: O(N) if sequences + // have the same elements in the same order. + for (; __first1 != __last1 && __first2 != __last2; + ++__first1, ++__first2) + if (!__pred(__first1, __first2)) + break; + + if (__ra_iters) + { + if (__first1 == __last1) + return true; + } + else + { + auto __d1 = std::distance(__first1, __last1); + auto __d2 = std::distance(__first2, __last2); + if (__d1 == 0 && __d2 == 0) + return true; + if (__d1 != __d2) + return false; + } + + for (_ForwardIterator1 __scan = __first1; __scan != __last1; ++__scan) + { + if (__scan != std::__find_if(__first1, __scan, + __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan))) + continue; // We've seen this one before. + + auto __matches = std::__count_if(__first2, __last2, + __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)); + if (0 == __matches + || std::__count_if(__scan, __last1, + __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)) + != __matches) + return false; + } + return true; + } + + /** + * @brief Checks whether a permutaion of the second sequence is equal + * to the first sequence. + * @ingroup non_mutating_algorithms + * @param __first1 Start of first range. + * @param __last1 End of first range. + * @param __first2 Start of second range. + * @param __last2 End of first range. + * @return true if there exists a permutation of the elements in the range + * [__first2, __last2), beginning with ForwardIterator2 begin, + * such that equal(__first1, __last1, begin) returns true; + * otherwise, returns false. + */ + template + inline bool + is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2) + { + __glibcxx_requires_valid_range(__first1, __last1); + __glibcxx_requires_valid_range(__first2, __last2); + + return + std::__is_permutation(__first1, __last1, __first2, __last2, + __gnu_cxx::__ops::__iter_equal_to_iter()); + } + + /** + * @brief Checks whether a permutation of the second sequence is equal + * to the first sequence. + * @ingroup non_mutating_algorithms + * @param __first1 Start of first range. + * @param __last1 End of first range. + * @param __first2 Start of second range. + * @param __last2 End of first range. + * @param __pred A binary predicate. + * @return true if there exists a permutation of the elements in the range + * [__first2, __last2), beginning with ForwardIterator2 begin, + * such that equal(__first1, __last1, __begin, __pred) returns true; + * otherwise, returns false. + */ + template + inline bool + is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2, + _BinaryPredicate __pred) + { + __glibcxx_requires_valid_range(__first1, __last1); + __glibcxx_requires_valid_range(__first2, __last2); + + return std::__is_permutation(__first1, __last1, __first2, __last2, + __gnu_cxx::__ops::__iter_comp_iter(__pred)); + } +#endif + +#ifdef _GLIBCXX_USE_C99_STDINT_TR1 + /** + * @brief Shuffle the elements of a sequence using a uniform random + * number generator. + * @ingroup mutating_algorithms + * @param __first A forward iterator. + * @param __last A forward iterator. + * @param __g A UniformRandomNumberGenerator (26.5.1.3). + * @return Nothing. + * + * Reorders the elements in the range @p [__first,__last) using @p __g to + * provide random numbers. + */ + template + void + shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last, + _UniformRandomNumberGenerator&& __g) + { + // concept requirements + __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept< + _RandomAccessIterator>) + __glibcxx_requires_valid_range(__first, __last); + + if (__first == __last) + return; + + typedef typename iterator_traits<_RandomAccessIterator>::difference_type + _DistanceType; + + typedef typename std::make_unsigned<_DistanceType>::type __ud_type; + typedef typename std::uniform_int_distribution<__ud_type> __distr_type; + typedef typename __distr_type::param_type __p_type; + __distr_type __d; + + for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i) + std::iter_swap(__i, __first + __d(__g, __p_type(0, __i - __first))); + } +#endif + +#endif // C++11 + +_GLIBCXX_END_NAMESPACE_VERSION + +_GLIBCXX_BEGIN_NAMESPACE_ALGO + + /** + * @brief Apply a function to every element of a sequence. + * @ingroup non_mutating_algorithms + * @param __first An input iterator. + * @param __last An input iterator. + * @param __f A unary function object. + * @return @p __f (std::move(@p __f) in C++0x). + * + * Applies the function object @p __f to each element in the range + * @p [first,last). @p __f must not modify the order of the sequence. + * If @p __f has a return value it is ignored. + */ + template + _Function + for_each(_InputIterator __first, _InputIterator __last, _Function __f) + { + // concept requirements + __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>) + __glibcxx_requires_valid_range(__first, __last); + for (; __first != __last; ++__first) + __f(*__first); + return _GLIBCXX_MOVE(__f); + } + + /** + * @brief Find the first occurrence of a value in a sequence. + * @ingroup non_mutating_algorithms + * @param __first An input iterator. + * @param __last An input iterator. + * @param __val The value to find. + * @return The first iterator @c i in the range @p [__first,__last) + * such that @c *i == @p __val, or @p __last if no such iterator exists. + */ + template + inline _InputIterator + find(_InputIterator __first, _InputIterator __last, + const _Tp& __val) + { + // concept requirements + __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>) + __glibcxx_function_requires(_EqualOpConcept< + typename iterator_traits<_InputIterator>::value_type, _Tp>) + __glibcxx_requires_valid_range(__first, __last); + return std::__find_if(__first, __last, + __gnu_cxx::__ops::__iter_equals_val(__val)); + } + + /** + * @brief Find the first element in a sequence for which a + * predicate is true. + * @ingroup non_mutating_algorithms + * @param __first An input iterator. + * @param __last An input iterator. + * @param __pred A predicate. + * @return The first iterator @c i in the range @p [__first,__last) + * such that @p __pred(*i) is true, or @p __last if no such iterator exists. + */ + template + inline _InputIterator + find_if(_InputIterator __first, _InputIterator __last, + _Predicate __pred) + { + // concept requirements + __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>) + __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate, + typename iterator_traits<_InputIterator>::value_type>) + __glibcxx_requires_valid_range(__first, __last); + + return std::__find_if(__first, __last, + __gnu_cxx::__ops::__pred_iter(__pred)); + } + + /** + * @brief Find element from a set in a sequence. + * @ingroup non_mutating_algorithms + * @param __first1 Start of range to search. + * @param __last1 End of range to search. + * @param __first2 Start of match candidates. + * @param __last2 End of match candidates. + * @return The first iterator @c i in the range + * @p [__first1,__last1) such that @c *i == @p *(i2) such that i2 is an + * iterator in [__first2,__last2), or @p __last1 if no such iterator exists. + * + * Searches the range @p [__first1,__last1) for an element that is + * equal to some element in the range [__first2,__last2). If + * found, returns an iterator in the range [__first1,__last1), + * otherwise returns @p __last1. + */ + template + _InputIterator + find_first_of(_InputIterator __first1, _InputIterator __last1, + _ForwardIterator __first2, _ForwardIterator __last2) + { + // concept requirements + __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>) + __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>) + __glibcxx_function_requires(_EqualOpConcept< + typename iterator_traits<_InputIterator>::value_type, + typename iterator_traits<_ForwardIterator>::value_type>) + __glibcxx_requires_valid_range(__first1, __last1); + __glibcxx_requires_valid_range(__first2, __last2); + + for (; __first1 != __last1; ++__first1) + for (_ForwardIterator __iter = __first2; __iter != __last2; ++__iter) + if (*__first1 == *__iter) + return __first1; + return __last1; + } + + /** + * @brief Find element from a set in a sequence using a predicate. + * @ingroup non_mutating_algorithms + * @param __first1 Start of range to search. + * @param __last1 End of range to search. + * @param __first2 Start of match candidates. + * @param __last2 End of match candidates. + * @param __comp Predicate to use. + * @return The first iterator @c i in the range + * @p [__first1,__last1) such that @c comp(*i, @p *(i2)) is true + * and i2 is an iterator in [__first2,__last2), or @p __last1 if no + * such iterator exists. + * + + * Searches the range @p [__first1,__last1) for an element that is + * equal to some element in the range [__first2,__last2). If + * found, returns an iterator in the range [__first1,__last1), + * otherwise returns @p __last1. + */ + template + _InputIterator + find_first_of(_InputIterator __first1, _InputIterator __last1, + _ForwardIterator __first2, _ForwardIterator __last2, + _BinaryPredicate __comp) + { + // concept requirements + __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>) + __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>) + __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate, + typename iterator_traits<_InputIterator>::value_type, + typename iterator_traits<_ForwardIterator>::value_type>) + __glibcxx_requires_valid_range(__first1, __last1); + __glibcxx_requires_valid_range(__first2, __last2); + + for (; __first1 != __last1; ++__first1) + for (_ForwardIterator __iter = __first2; __iter != __last2; ++__iter) + if (__comp(*__first1, *__iter)) + return __first1; + return __last1; + } + + /** + * @brief Find two adjacent values in a sequence that are equal. + * @ingroup non_mutating_algorithms + * @param __first A forward iterator. + * @param __last A forward iterator. + * @return The first iterator @c i such that @c i and @c i+1 are both + * valid iterators in @p [__first,__last) and such that @c *i == @c *(i+1), + * or @p __last if no such iterator exists. + */ + template + inline _ForwardIterator + adjacent_find(_ForwardIterator __first, _ForwardIterator __last) + { + // concept requirements + __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>) + __glibcxx_function_requires(_EqualityComparableConcept< + typename iterator_traits<_ForwardIterator>::value_type>) + __glibcxx_requires_valid_range(__first, __last); + + return std::__adjacent_find(__first, __last, + __gnu_cxx::__ops::__iter_equal_to_iter()); + } + + /** + * @brief Find two adjacent values in a sequence using a predicate. + * @ingroup non_mutating_algorithms + * @param __first A forward iterator. + * @param __last A forward iterator. + * @param __binary_pred A binary predicate. + * @return The first iterator @c i such that @c i and @c i+1 are both + * valid iterators in @p [__first,__last) and such that + * @p __binary_pred(*i,*(i+1)) is true, or @p __last if no such iterator + * exists. + */ + template + inline _ForwardIterator + adjacent_find(_ForwardIterator __first, _ForwardIterator __last, + _BinaryPredicate __binary_pred) + { + // concept requirements + __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>) + __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate, + typename iterator_traits<_ForwardIterator>::value_type, + typename iterator_traits<_ForwardIterator>::value_type>) + __glibcxx_requires_valid_range(__first, __last); + + return std::__adjacent_find(__first, __last, + __gnu_cxx::__ops::__iter_comp_iter(__binary_pred)); + } + + /** + * @brief Count the number of copies of a value in a sequence. + * @ingroup non_mutating_algorithms + * @param __first An input iterator. + * @param __last An input iterator. + * @param __value The value to be counted. + * @return The number of iterators @c i in the range @p [__first,__last) + * for which @c *i == @p __value + */ + template + inline typename iterator_traits<_InputIterator>::difference_type + count(_InputIterator __first, _InputIterator __last, const _Tp& __value) + { + // concept requirements + __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>) + __glibcxx_function_requires(_EqualOpConcept< + typename iterator_traits<_InputIterator>::value_type, _Tp>) + __glibcxx_requires_valid_range(__first, __last); + + return std::__count_if(__first, __last, + __gnu_cxx::__ops::__iter_equals_val(__value)); + } + + /** + * @brief Count the elements of a sequence for which a predicate is true. + * @ingroup non_mutating_algorithms + * @param __first An input iterator. + * @param __last An input iterator. + * @param __pred A predicate. + * @return The number of iterators @c i in the range @p [__first,__last) + * for which @p __pred(*i) is true. + */ + template + inline typename iterator_traits<_InputIterator>::difference_type + count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred) + { + // concept requirements + __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>) + __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate, + typename iterator_traits<_InputIterator>::value_type>) + __glibcxx_requires_valid_range(__first, __last); + + return std::__count_if(__first, __last, + __gnu_cxx::__ops::__pred_iter(__pred)); + } + + /** + * @brief Search a sequence for a matching sub-sequence. + * @ingroup non_mutating_algorithms + * @param __first1 A forward iterator. + * @param __last1 A forward iterator. + * @param __first2 A forward iterator. + * @param __last2 A forward iterator. + * @return The first iterator @c i in the range @p + * [__first1,__last1-(__last2-__first2)) such that @c *(i+N) == @p + * *(__first2+N) for each @c N in the range @p + * [0,__last2-__first2), or @p __last1 if no such iterator exists. + * + * Searches the range @p [__first1,__last1) for a sub-sequence that + * compares equal value-by-value with the sequence given by @p + * [__first2,__last2) and returns an iterator to the first element + * of the sub-sequence, or @p __last1 if the sub-sequence is not + * found. + * + * Because the sub-sequence must lie completely within the range @p + * [__first1,__last1) it must start at a position less than @p + * __last1-(__last2-__first2) where @p __last2-__first2 is the + * length of the sub-sequence. + * + * This means that the returned iterator @c i will be in the range + * @p [__first1,__last1-(__last2-__first2)) + */ + template + inline _ForwardIterator1 + search(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2) + { + // concept requirements + __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator1>) + __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator2>) + __glibcxx_function_requires(_EqualOpConcept< + typename iterator_traits<_ForwardIterator1>::value_type, + typename iterator_traits<_ForwardIterator2>::value_type>) + __glibcxx_requires_valid_range(__first1, __last1); + __glibcxx_requires_valid_range(__first2, __last2); + + return std::__search(__first1, __last1, __first2, __last2, + __gnu_cxx::__ops::__iter_equal_to_iter()); + } + + /** + * @brief Search a sequence for a matching sub-sequence using a predicate. + * @ingroup non_mutating_algorithms + * @param __first1 A forward iterator. + * @param __last1 A forward iterator. + * @param __first2 A forward iterator. + * @param __last2 A forward iterator. + * @param __predicate A binary predicate. + * @return The first iterator @c i in the range + * @p [__first1,__last1-(__last2-__first2)) such that + * @p __predicate(*(i+N),*(__first2+N)) is true for each @c N in the range + * @p [0,__last2-__first2), or @p __last1 if no such iterator exists. + * + * Searches the range @p [__first1,__last1) for a sub-sequence that + * compares equal value-by-value with the sequence given by @p + * [__first2,__last2), using @p __predicate to determine equality, + * and returns an iterator to the first element of the + * sub-sequence, or @p __last1 if no such iterator exists. + * + * @see search(_ForwardIter1, _ForwardIter1, _ForwardIter2, _ForwardIter2) + */ + template + inline _ForwardIterator1 + search(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2, + _BinaryPredicate __predicate) + { + // concept requirements + __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator1>) + __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator2>) + __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate, + typename iterator_traits<_ForwardIterator1>::value_type, + typename iterator_traits<_ForwardIterator2>::value_type>) + __glibcxx_requires_valid_range(__first1, __last1); + __glibcxx_requires_valid_range(__first2, __last2); + + return std::__search(__first1, __last1, __first2, __last2, + __gnu_cxx::__ops::__iter_comp_iter(__predicate)); + } + + /** + * @brief Search a sequence for a number of consecutive values. + * @ingroup non_mutating_algorithms + * @param __first A forward iterator. + * @param __last A forward iterator. + * @param __count The number of consecutive values. + * @param __val The value to find. + * @return The first iterator @c i in the range @p + * [__first,__last-__count) such that @c *(i+N) == @p __val for + * each @c N in the range @p [0,__count), or @p __last if no such + * iterator exists. + * + * Searches the range @p [__first,__last) for @p count consecutive elements + * equal to @p __val. + */ + template + inline _ForwardIterator + search_n(_ForwardIterator __first, _ForwardIterator __last, + _Integer __count, const _Tp& __val) + { + // concept requirements + __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>) + __glibcxx_function_requires(_EqualOpConcept< + typename iterator_traits<_ForwardIterator>::value_type, _Tp>) + __glibcxx_requires_valid_range(__first, __last); + + return std::__search_n(__first, __last, __count, + __gnu_cxx::__ops::__iter_equals_val(__val)); + } + + + /** + * @brief Search a sequence for a number of consecutive values using a + * predicate. + * @ingroup non_mutating_algorithms + * @param __first A forward iterator. + * @param __last A forward iterator. + * @param __count The number of consecutive values. + * @param __val The value to find. + * @param __binary_pred A binary predicate. + * @return The first iterator @c i in the range @p + * [__first,__last-__count) such that @p + * __binary_pred(*(i+N),__val) is true for each @c N in the range + * @p [0,__count), or @p __last if no such iterator exists. + * + * Searches the range @p [__first,__last) for @p __count + * consecutive elements for which the predicate returns true. + */ + template + inline _ForwardIterator + search_n(_ForwardIterator __first, _ForwardIterator __last, + _Integer __count, const _Tp& __val, + _BinaryPredicate __binary_pred) + { + // concept requirements + __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>) + __glibcxx_function_requires(_BinaryPredicateConcept<_BinaryPredicate, + typename iterator_traits<_ForwardIterator>::value_type, _Tp>) + __glibcxx_requires_valid_range(__first, __last); + + return std::__search_n(__first, __last, __count, + __gnu_cxx::__ops::__iter_comp_val(__binary_pred, __val)); + } + + + /** + * @brief Perform an operation on a sequence. + * @ingroup mutating_algorithms + * @param __first An input iterator. + * @param __last An input iterator. + * @param __result An output iterator. + * @param __unary_op A unary operator. + * @return An output iterator equal to @p __result+(__last-__first). + * + * Applies the operator to each element in the input range and assigns + * the results to successive elements of the output sequence. + * Evaluates @p *(__result+N)=unary_op(*(__first+N)) for each @c N in the + * range @p [0,__last-__first). + * + * @p unary_op must not alter its argument. + */ + template + _OutputIterator + transform(_InputIterator __first, _InputIterator __last, + _OutputIterator __result, _UnaryOperation __unary_op) + { + // concept requirements + __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>) + __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator, + // "the type returned by a _UnaryOperation" + __typeof__(__unary_op(*__first))>) + __glibcxx_requires_valid_range(__first, __last); + + for (; __first != __last; ++__first, ++__result) + *__result = __unary_op(*__first); + return __result; + } + + /** + * @brief Perform an operation on corresponding elements of two sequences. + * @ingroup mutating_algorithms + * @param __first1 An input iterator. + * @param __last1 An input iterator. + * @param __first2 An input iterator. + * @param __result An output iterator. + * @param __binary_op A binary operator. + * @return An output iterator equal to @p result+(last-first). + * + * Applies the operator to the corresponding elements in the two + * input ranges and assigns the results to successive elements of the + * output sequence. + * Evaluates @p + * *(__result+N)=__binary_op(*(__first1+N),*(__first2+N)) for each + * @c N in the range @p [0,__last1-__first1). + * + * @p binary_op must not alter either of its arguments. + */ + template + _OutputIterator + transform(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _OutputIterator __result, + _BinaryOperation __binary_op) + { + // concept requirements + __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>) + __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>) + __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator, + // "the type returned by a _BinaryOperation" + __typeof__(__binary_op(*__first1,*__first2))>) + __glibcxx_requires_valid_range(__first1, __last1); + + for (; __first1 != __last1; ++__first1, ++__first2, ++__result) + *__result = __binary_op(*__first1, *__first2); + return __result; + } + + /** + * @brief Replace each occurrence of one value in a sequence with another + * value. + * @ingroup mutating_algorithms + * @param __first A forward iterator. + * @param __last A forward iterator. + * @param __old_value The value to be replaced. + * @param __new_value The replacement value. + * @return replace() returns no value. + * + * For each iterator @c i in the range @p [__first,__last) if @c *i == + * @p __old_value then the assignment @c *i = @p __new_value is performed. + */ + template + void + replace(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __old_value, const _Tp& __new_value) + { + // concept requirements + __glibcxx_function_requires(_Mutable_ForwardIteratorConcept< + _ForwardIterator>) + __glibcxx_function_requires(_EqualOpConcept< + typename iterator_traits<_ForwardIterator>::value_type, _Tp>) + __glibcxx_function_requires(_ConvertibleConcept<_Tp, + typename iterator_traits<_ForwardIterator>::value_type>) + __glibcxx_requires_valid_range(__first, __last); + + for (; __first != __last; ++__first) + if (*__first == __old_value) + *__first = __new_value; + } + + /** + * @brief Replace each value in a sequence for which a predicate returns + * true with another value. + * @ingroup mutating_algorithms + * @param __first A forward iterator. + * @param __last A forward iterator. + * @param __pred A predicate. + * @param __new_value The replacement value. + * @return replace_if() returns no value. + * + * For each iterator @c i in the range @p [__first,__last) if @p __pred(*i) + * is true then the assignment @c *i = @p __new_value is performed. + */ + template + void + replace_if(_ForwardIterator __first, _ForwardIterator __last, + _Predicate __pred, const _Tp& __new_value) + { + // concept requirements + __glibcxx_function_requires(_Mutable_ForwardIteratorConcept< + _ForwardIterator>) + __glibcxx_function_requires(_ConvertibleConcept<_Tp, + typename iterator_traits<_ForwardIterator>::value_type>) + __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate, + typename iterator_traits<_ForwardIterator>::value_type>) + __glibcxx_requires_valid_range(__first, __last); + + for (; __first != __last; ++__first) + if (__pred(*__first)) + *__first = __new_value; + } + + /** + * @brief Assign the result of a function object to each value in a + * sequence. + * @ingroup mutating_algorithms + * @param __first A forward iterator. + * @param __last A forward iterator. + * @param __gen A function object taking no arguments and returning + * std::iterator_traits<_ForwardIterator>::value_type + * @return generate() returns no value. + * + * Performs the assignment @c *i = @p __gen() for each @c i in the range + * @p [__first,__last). + */ + template + void + generate(_ForwardIterator __first, _ForwardIterator __last, + _Generator __gen) + { + // concept requirements + __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>) + __glibcxx_function_requires(_GeneratorConcept<_Generator, + typename iterator_traits<_ForwardIterator>::value_type>) + __glibcxx_requires_valid_range(__first, __last); + + for (; __first != __last; ++__first) + *__first = __gen(); + } + + /** + * @brief Assign the result of a function object to each value in a + * sequence. + * @ingroup mutating_algorithms + * @param __first A forward iterator. + * @param __n The length of the sequence. + * @param __gen A function object taking no arguments and returning + * std::iterator_traits<_ForwardIterator>::value_type + * @return The end of the sequence, @p __first+__n + * + * Performs the assignment @c *i = @p __gen() for each @c i in the range + * @p [__first,__first+__n). + * + * _GLIBCXX_RESOLVE_LIB_DEFECTS + * DR 865. More algorithms that throw away information + */ + template + _OutputIterator + generate_n(_OutputIterator __first, _Size __n, _Generator __gen) + { + // concept requirements + __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator, + // "the type returned by a _Generator" + __typeof__(__gen())>) + + for (__decltype(__n + 0) __niter = __n; + __niter > 0; --__niter, ++__first) + *__first = __gen(); + return __first; + } + + /** + * @brief Copy a sequence, removing consecutive duplicate values. + * @ingroup mutating_algorithms + * @param __first An input iterator. + * @param __last An input iterator. + * @param __result An output iterator. + * @return An iterator designating the end of the resulting sequence. + * + * Copies each element in the range @p [__first,__last) to the range + * beginning at @p __result, except that only the first element is copied + * from groups of consecutive elements that compare equal. + * unique_copy() is stable, so the relative order of elements that are + * copied is unchanged. + * + * _GLIBCXX_RESOLVE_LIB_DEFECTS + * DR 241. Does unique_copy() require CopyConstructible and Assignable? + * + * _GLIBCXX_RESOLVE_LIB_DEFECTS + * DR 538. 241 again: Does unique_copy() require CopyConstructible and + * Assignable? + */ + template + inline _OutputIterator + unique_copy(_InputIterator __first, _InputIterator __last, + _OutputIterator __result) + { + // concept requirements + __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>) + __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator, + typename iterator_traits<_InputIterator>::value_type>) + __glibcxx_function_requires(_EqualityComparableConcept< + typename iterator_traits<_InputIterator>::value_type>) + __glibcxx_requires_valid_range(__first, __last); + + if (__first == __last) + return __result; + return std::__unique_copy(__first, __last, __result, + __gnu_cxx::__ops::__iter_equal_to_iter(), + std::__iterator_category(__first), + std::__iterator_category(__result)); + } + + /** + * @brief Copy a sequence, removing consecutive values using a predicate. + * @ingroup mutating_algorithms + * @param __first An input iterator. + * @param __last An input iterator. + * @param __result An output iterator. + * @param __binary_pred A binary predicate. + * @return An iterator designating the end of the resulting sequence. + * + * Copies each element in the range @p [__first,__last) to the range + * beginning at @p __result, except that only the first element is copied + * from groups of consecutive elements for which @p __binary_pred returns + * true. + * unique_copy() is stable, so the relative order of elements that are + * copied is unchanged. + * + * _GLIBCXX_RESOLVE_LIB_DEFECTS + * DR 241. Does unique_copy() require CopyConstructible and Assignable? + */ + template + inline _OutputIterator + unique_copy(_InputIterator __first, _InputIterator __last, + _OutputIterator __result, + _BinaryPredicate __binary_pred) + { + // concept requirements -- predicates checked later + __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>) + __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator, + typename iterator_traits<_InputIterator>::value_type>) + __glibcxx_requires_valid_range(__first, __last); + + if (__first == __last) + return __result; + return std::__unique_copy(__first, __last, __result, + __gnu_cxx::__ops::__iter_comp_iter(__binary_pred), + std::__iterator_category(__first), + std::__iterator_category(__result)); + } + + /** + * @brief Randomly shuffle the elements of a sequence. + * @ingroup mutating_algorithms + * @param __first A forward iterator. + * @param __last A forward iterator. + * @return Nothing. + * + * Reorder the elements in the range @p [__first,__last) using a random + * distribution, so that every possible ordering of the sequence is + * equally likely. + */ + template + inline void + random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last) + { + // concept requirements + __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept< + _RandomAccessIterator>) + __glibcxx_requires_valid_range(__first, __last); + + if (__first != __last) + for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i) + { + _RandomAccessIterator __j = __first + + std::rand() % ((__i - __first) + 1); + if (__i != __j) + std::iter_swap(__i, __j); + } + } + + /** + * @brief Shuffle the elements of a sequence using a random number + * generator. + * @ingroup mutating_algorithms + * @param __first A forward iterator. + * @param __last A forward iterator. + * @param __rand The RNG functor or function. + * @return Nothing. + * + * Reorders the elements in the range @p [__first,__last) using @p __rand to + * provide a random distribution. Calling @p __rand(N) for a positive + * integer @p N should return a randomly chosen integer from the + * range [0,N). + */ + template + void + random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last, +#if __cplusplus >= 201103L + _RandomNumberGenerator&& __rand) +#else + _RandomNumberGenerator& __rand) +#endif + { + // concept requirements + __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept< + _RandomAccessIterator>) + __glibcxx_requires_valid_range(__first, __last); + + if (__first == __last) + return; + for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i) + { + _RandomAccessIterator __j = __first + __rand((__i - __first) + 1); + if (__i != __j) + std::iter_swap(__i, __j); + } + } + + + /** + * @brief Move elements for which a predicate is true to the beginning + * of a sequence. + * @ingroup mutating_algorithms + * @param __first A forward iterator. + * @param __last A forward iterator. + * @param __pred A predicate functor. + * @return An iterator @p middle such that @p __pred(i) is true for each + * iterator @p i in the range @p [__first,middle) and false for each @p i + * in the range @p [middle,__last). + * + * @p __pred must not modify its operand. @p partition() does not preserve + * the relative ordering of elements in each group, use + * @p stable_partition() if this is needed. + */ + template + inline _ForwardIterator + partition(_ForwardIterator __first, _ForwardIterator __last, + _Predicate __pred) + { + // concept requirements + __glibcxx_function_requires(_Mutable_ForwardIteratorConcept< + _ForwardIterator>) + __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate, + typename iterator_traits<_ForwardIterator>::value_type>) + __glibcxx_requires_valid_range(__first, __last); + + return std::__partition(__first, __last, __pred, + std::__iterator_category(__first)); + } + + + /** + * @brief Sort the smallest elements of a sequence. + * @ingroup sorting_algorithms + * @param __first An iterator. + * @param __middle Another iterator. + * @param __last Another iterator. + * @return Nothing. + * + * Sorts the smallest @p (__middle-__first) elements in the range + * @p [first,last) and moves them to the range @p [__first,__middle). The + * order of the remaining elements in the range @p [__middle,__last) is + * undefined. + * After the sort if @e i and @e j are iterators in the range + * @p [__first,__middle) such that i precedes j and @e k is an iterator in + * the range @p [__middle,__last) then *j<*i and *k<*i are both false. + */ + template + inline void + partial_sort(_RandomAccessIterator __first, + _RandomAccessIterator __middle, + _RandomAccessIterator __last) + { + // concept requirements + __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept< + _RandomAccessIterator>) + __glibcxx_function_requires(_LessThanComparableConcept< + typename iterator_traits<_RandomAccessIterator>::value_type>) + __glibcxx_requires_valid_range(__first, __middle); + __glibcxx_requires_valid_range(__middle, __last); + + std::__partial_sort(__first, __middle, __last, + __gnu_cxx::__ops::__iter_less_iter()); + } + + /** + * @brief Sort the smallest elements of a sequence using a predicate + * for comparison. + * @ingroup sorting_algorithms + * @param __first An iterator. + * @param __middle Another iterator. + * @param __last Another iterator. + * @param __comp A comparison functor. + * @return Nothing. + * + * Sorts the smallest @p (__middle-__first) elements in the range + * @p [__first,__last) and moves them to the range @p [__first,__middle). The + * order of the remaining elements in the range @p [__middle,__last) is + * undefined. + * After the sort if @e i and @e j are iterators in the range + * @p [__first,__middle) such that i precedes j and @e k is an iterator in + * the range @p [__middle,__last) then @p *__comp(j,*i) and @p __comp(*k,*i) + * are both false. + */ + template + inline void + partial_sort(_RandomAccessIterator __first, + _RandomAccessIterator __middle, + _RandomAccessIterator __last, + _Compare __comp) + { + // concept requirements + __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept< + _RandomAccessIterator>) + __glibcxx_function_requires(_BinaryPredicateConcept<_Compare, + typename iterator_traits<_RandomAccessIterator>::value_type, + typename iterator_traits<_RandomAccessIterator>::value_type>) + __glibcxx_requires_valid_range(__first, __middle); + __glibcxx_requires_valid_range(__middle, __last); + + std::__partial_sort(__first, __middle, __last, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } + + /** + * @brief Sort a sequence just enough to find a particular position. + * @ingroup sorting_algorithms + * @param __first An iterator. + * @param __nth Another iterator. + * @param __last Another iterator. + * @return Nothing. + * + * Rearranges the elements in the range @p [__first,__last) so that @p *__nth + * is the same element that would have been in that position had the + * whole sequence been sorted. The elements either side of @p *__nth are + * not completely sorted, but for any iterator @e i in the range + * @p [__first,__nth) and any iterator @e j in the range @p [__nth,__last) it + * holds that *j < *i is false. + */ + template + inline void + nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth, + _RandomAccessIterator __last) + { + // concept requirements + __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept< + _RandomAccessIterator>) + __glibcxx_function_requires(_LessThanComparableConcept< + typename iterator_traits<_RandomAccessIterator>::value_type>) + __glibcxx_requires_valid_range(__first, __nth); + __glibcxx_requires_valid_range(__nth, __last); + + if (__first == __last || __nth == __last) + return; + + std::__introselect(__first, __nth, __last, + std::__lg(__last - __first) * 2, + __gnu_cxx::__ops::__iter_less_iter()); + } + + /** + * @brief Sort a sequence just enough to find a particular position + * using a predicate for comparison. + * @ingroup sorting_algorithms + * @param __first An iterator. + * @param __nth Another iterator. + * @param __last Another iterator. + * @param __comp A comparison functor. + * @return Nothing. + * + * Rearranges the elements in the range @p [__first,__last) so that @p *__nth + * is the same element that would have been in that position had the + * whole sequence been sorted. The elements either side of @p *__nth are + * not completely sorted, but for any iterator @e i in the range + * @p [__first,__nth) and any iterator @e j in the range @p [__nth,__last) it + * holds that @p __comp(*j,*i) is false. + */ + template + inline void + nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth, + _RandomAccessIterator __last, _Compare __comp) + { + // concept requirements + __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept< + _RandomAccessIterator>) + __glibcxx_function_requires(_BinaryPredicateConcept<_Compare, + typename iterator_traits<_RandomAccessIterator>::value_type, + typename iterator_traits<_RandomAccessIterator>::value_type>) + __glibcxx_requires_valid_range(__first, __nth); + __glibcxx_requires_valid_range(__nth, __last); + + if (__first == __last || __nth == __last) + return; + + std::__introselect(__first, __nth, __last, + std::__lg(__last - __first) * 2, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } + + /** + * @brief Sort the elements of a sequence. + * @ingroup sorting_algorithms + * @param __first An iterator. + * @param __last Another iterator. + * @return Nothing. + * + * Sorts the elements in the range @p [__first,__last) in ascending order, + * such that for each iterator @e i in the range @p [__first,__last-1), + * *(i+1)<*i is false. + * + * The relative ordering of equivalent elements is not preserved, use + * @p stable_sort() if this is needed. + */ + template + inline void + sort(_RandomAccessIterator __first, _RandomAccessIterator __last) + { + // concept requirements + __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept< + _RandomAccessIterator>) + __glibcxx_function_requires(_LessThanComparableConcept< + typename iterator_traits<_RandomAccessIterator>::value_type>) + __glibcxx_requires_valid_range(__first, __last); + + std::__sort(__first, __last, __gnu_cxx::__ops::__iter_less_iter()); + } + + /** + * @brief Sort the elements of a sequence using a predicate for comparison. + * @ingroup sorting_algorithms + * @param __first An iterator. + * @param __last Another iterator. + * @param __comp A comparison functor. + * @return Nothing. + * + * Sorts the elements in the range @p [__first,__last) in ascending order, + * such that @p __comp(*(i+1),*i) is false for every iterator @e i in the + * range @p [__first,__last-1). + * + * The relative ordering of equivalent elements is not preserved, use + * @p stable_sort() if this is needed. + */ + template + inline void + sort(_RandomAccessIterator __first, _RandomAccessIterator __last, + _Compare __comp) + { + // concept requirements + __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept< + _RandomAccessIterator>) + __glibcxx_function_requires(_BinaryPredicateConcept<_Compare, + typename iterator_traits<_RandomAccessIterator>::value_type, + typename iterator_traits<_RandomAccessIterator>::value_type>) + __glibcxx_requires_valid_range(__first, __last); + + std::__sort(__first, __last, __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } + + template + _OutputIterator + __merge(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _OutputIterator __result, _Compare __comp) + { + while (__first1 != __last1 && __first2 != __last2) + { + if (__comp(__first2, __first1)) + { + *__result = *__first2; + ++__first2; + } + else + { + *__result = *__first1; + ++__first1; + } + ++__result; + } + return std::copy(__first2, __last2, + std::copy(__first1, __last1, __result)); + } + + /** + * @brief Merges two sorted ranges. + * @ingroup sorting_algorithms + * @param __first1 An iterator. + * @param __first2 Another iterator. + * @param __last1 Another iterator. + * @param __last2 Another iterator. + * @param __result An iterator pointing to the end of the merged range. + * @return An iterator pointing to the first element not less + * than @e val. + * + * Merges the ranges @p [__first1,__last1) and @p [__first2,__last2) into + * the sorted range @p [__result, __result + (__last1-__first1) + + * (__last2-__first2)). Both input ranges must be sorted, and the + * output range must not overlap with either of the input ranges. + * The sort is @e stable, that is, for equivalent elements in the + * two ranges, elements from the first range will always come + * before elements from the second. + */ + template + inline _OutputIterator + merge(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _OutputIterator __result) + { + // concept requirements + __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>) + __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>) + __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator, + typename iterator_traits<_InputIterator1>::value_type>) + __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator, + typename iterator_traits<_InputIterator2>::value_type>) + __glibcxx_function_requires(_LessThanOpConcept< + typename iterator_traits<_InputIterator2>::value_type, + typename iterator_traits<_InputIterator1>::value_type>) + __glibcxx_requires_sorted_set(__first1, __last1, __first2); + __glibcxx_requires_sorted_set(__first2, __last2, __first1); + + return _GLIBCXX_STD_A::__merge(__first1, __last1, + __first2, __last2, __result, + __gnu_cxx::__ops::__iter_less_iter()); + } + + /** + * @brief Merges two sorted ranges. + * @ingroup sorting_algorithms + * @param __first1 An iterator. + * @param __first2 Another iterator. + * @param __last1 Another iterator. + * @param __last2 Another iterator. + * @param __result An iterator pointing to the end of the merged range. + * @param __comp A functor to use for comparisons. + * @return An iterator pointing to the first element "not less + * than" @e val. + * + * Merges the ranges @p [__first1,__last1) and @p [__first2,__last2) into + * the sorted range @p [__result, __result + (__last1-__first1) + + * (__last2-__first2)). Both input ranges must be sorted, and the + * output range must not overlap with either of the input ranges. + * The sort is @e stable, that is, for equivalent elements in the + * two ranges, elements from the first range will always come + * before elements from the second. + * + * The comparison function should have the same effects on ordering as + * the function used for the initial sort. + */ + template + inline _OutputIterator + merge(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _OutputIterator __result, _Compare __comp) + { + // concept requirements + __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>) + __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>) + __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator, + typename iterator_traits<_InputIterator1>::value_type>) + __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator, + typename iterator_traits<_InputIterator2>::value_type>) + __glibcxx_function_requires(_BinaryPredicateConcept<_Compare, + typename iterator_traits<_InputIterator2>::value_type, + typename iterator_traits<_InputIterator1>::value_type>) + __glibcxx_requires_sorted_set_pred(__first1, __last1, __first2, __comp); + __glibcxx_requires_sorted_set_pred(__first2, __last2, __first1, __comp); + + return _GLIBCXX_STD_A::__merge(__first1, __last1, + __first2, __last2, __result, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } + + template + inline void + __stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last, + _Compare __comp) + { + typedef typename iterator_traits<_RandomAccessIterator>::value_type + _ValueType; + typedef typename iterator_traits<_RandomAccessIterator>::difference_type + _DistanceType; + + typedef _Temporary_buffer<_RandomAccessIterator, _ValueType> _TmpBuf; + _TmpBuf __buf(__first, __last); + + if (__buf.begin() == 0) + std::__inplace_stable_sort(__first, __last, __comp); + else + std::__stable_sort_adaptive(__first, __last, __buf.begin(), + _DistanceType(__buf.size()), __comp); + } + + /** + * @brief Sort the elements of a sequence, preserving the relative order + * of equivalent elements. + * @ingroup sorting_algorithms + * @param __first An iterator. + * @param __last Another iterator. + * @return Nothing. + * + * Sorts the elements in the range @p [__first,__last) in ascending order, + * such that for each iterator @p i in the range @p [__first,__last-1), + * @p *(i+1)<*i is false. + * + * The relative ordering of equivalent elements is preserved, so any two + * elements @p x and @p y in the range @p [__first,__last) such that + * @p x + inline void + stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last) + { + // concept requirements + __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept< + _RandomAccessIterator>) + __glibcxx_function_requires(_LessThanComparableConcept< + typename iterator_traits<_RandomAccessIterator>::value_type>) + __glibcxx_requires_valid_range(__first, __last); + + _GLIBCXX_STD_A::__stable_sort(__first, __last, + __gnu_cxx::__ops::__iter_less_iter()); + } + + /** + * @brief Sort the elements of a sequence using a predicate for comparison, + * preserving the relative order of equivalent elements. + * @ingroup sorting_algorithms + * @param __first An iterator. + * @param __last Another iterator. + * @param __comp A comparison functor. + * @return Nothing. + * + * Sorts the elements in the range @p [__first,__last) in ascending order, + * such that for each iterator @p i in the range @p [__first,__last-1), + * @p __comp(*(i+1),*i) is false. + * + * The relative ordering of equivalent elements is preserved, so any two + * elements @p x and @p y in the range @p [__first,__last) such that + * @p __comp(x,y) is false and @p __comp(y,x) is false will have the same + * relative ordering after calling @p stable_sort(). + */ + template + inline void + stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last, + _Compare __comp) + { + // concept requirements + __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept< + _RandomAccessIterator>) + __glibcxx_function_requires(_BinaryPredicateConcept<_Compare, + typename iterator_traits<_RandomAccessIterator>::value_type, + typename iterator_traits<_RandomAccessIterator>::value_type>) + __glibcxx_requires_valid_range(__first, __last); + + _GLIBCXX_STD_A::__stable_sort(__first, __last, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } + + template + _OutputIterator + __set_union(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _OutputIterator __result, _Compare __comp) + { + while (__first1 != __last1 && __first2 != __last2) + { + if (__comp(__first1, __first2)) + { + *__result = *__first1; + ++__first1; + } + else if (__comp(__first2, __first1)) + { + *__result = *__first2; + ++__first2; + } + else + { + *__result = *__first1; + ++__first1; + ++__first2; + } + ++__result; + } + return std::copy(__first2, __last2, + std::copy(__first1, __last1, __result)); + } + + /** + * @brief Return the union of two sorted ranges. + * @ingroup set_algorithms + * @param __first1 Start of first range. + * @param __last1 End of first range. + * @param __first2 Start of second range. + * @param __last2 End of second range. + * @return End of the output range. + * @ingroup set_algorithms + * + * This operation iterates over both ranges, copying elements present in + * each range in order to the output range. Iterators increment for each + * range. When the current element of one range is less than the other, + * that element is copied and the iterator advanced. If an element is + * contained in both ranges, the element from the first range is copied and + * both ranges advance. The output range may not overlap either input + * range. + */ + template + inline _OutputIterator + set_union(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _OutputIterator __result) + { + // concept requirements + __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>) + __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>) + __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator, + typename iterator_traits<_InputIterator1>::value_type>) + __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator, + typename iterator_traits<_InputIterator2>::value_type>) + __glibcxx_function_requires(_LessThanOpConcept< + typename iterator_traits<_InputIterator1>::value_type, + typename iterator_traits<_InputIterator2>::value_type>) + __glibcxx_function_requires(_LessThanOpConcept< + typename iterator_traits<_InputIterator2>::value_type, + typename iterator_traits<_InputIterator1>::value_type>) + __glibcxx_requires_sorted_set(__first1, __last1, __first2); + __glibcxx_requires_sorted_set(__first2, __last2, __first1); + + return _GLIBCXX_STD_A::__set_union(__first1, __last1, + __first2, __last2, __result, + __gnu_cxx::__ops::__iter_less_iter()); + } + + /** + * @brief Return the union of two sorted ranges using a comparison functor. + * @ingroup set_algorithms + * @param __first1 Start of first range. + * @param __last1 End of first range. + * @param __first2 Start of second range. + * @param __last2 End of second range. + * @param __comp The comparison functor. + * @return End of the output range. + * @ingroup set_algorithms + * + * This operation iterates over both ranges, copying elements present in + * each range in order to the output range. Iterators increment for each + * range. When the current element of one range is less than the other + * according to @p __comp, that element is copied and the iterator advanced. + * If an equivalent element according to @p __comp is contained in both + * ranges, the element from the first range is copied and both ranges + * advance. The output range may not overlap either input range. + */ + template + inline _OutputIterator + set_union(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _OutputIterator __result, _Compare __comp) + { + // concept requirements + __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>) + __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>) + __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator, + typename iterator_traits<_InputIterator1>::value_type>) + __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator, + typename iterator_traits<_InputIterator2>::value_type>) + __glibcxx_function_requires(_BinaryPredicateConcept<_Compare, + typename iterator_traits<_InputIterator1>::value_type, + typename iterator_traits<_InputIterator2>::value_type>) + __glibcxx_function_requires(_BinaryPredicateConcept<_Compare, + typename iterator_traits<_InputIterator2>::value_type, + typename iterator_traits<_InputIterator1>::value_type>) + __glibcxx_requires_sorted_set_pred(__first1, __last1, __first2, __comp); + __glibcxx_requires_sorted_set_pred(__first2, __last2, __first1, __comp); + + return _GLIBCXX_STD_A::__set_union(__first1, __last1, + __first2, __last2, __result, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } + + template + _OutputIterator + __set_intersection(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _OutputIterator __result, _Compare __comp) + { + while (__first1 != __last1 && __first2 != __last2) + if (__comp(__first1, __first2)) + ++__first1; + else if (__comp(__first2, __first1)) + ++__first2; + else + { + *__result = *__first1; + ++__first1; + ++__first2; + ++__result; + } + return __result; + } + + /** + * @brief Return the intersection of two sorted ranges. + * @ingroup set_algorithms + * @param __first1 Start of first range. + * @param __last1 End of first range. + * @param __first2 Start of second range. + * @param __last2 End of second range. + * @return End of the output range. + * @ingroup set_algorithms + * + * This operation iterates over both ranges, copying elements present in + * both ranges in order to the output range. Iterators increment for each + * range. When the current element of one range is less than the other, + * that iterator advances. If an element is contained in both ranges, the + * element from the first range is copied and both ranges advance. The + * output range may not overlap either input range. + */ + template + inline _OutputIterator + set_intersection(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _OutputIterator __result) + { + // concept requirements + __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>) + __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>) + __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator, + typename iterator_traits<_InputIterator1>::value_type>) + __glibcxx_function_requires(_LessThanOpConcept< + typename iterator_traits<_InputIterator1>::value_type, + typename iterator_traits<_InputIterator2>::value_type>) + __glibcxx_function_requires(_LessThanOpConcept< + typename iterator_traits<_InputIterator2>::value_type, + typename iterator_traits<_InputIterator1>::value_type>) + __glibcxx_requires_sorted_set(__first1, __last1, __first2); + __glibcxx_requires_sorted_set(__first2, __last2, __first1); + + return _GLIBCXX_STD_A::__set_intersection(__first1, __last1, + __first2, __last2, __result, + __gnu_cxx::__ops::__iter_less_iter()); + } + + /** + * @brief Return the intersection of two sorted ranges using comparison + * functor. + * @ingroup set_algorithms + * @param __first1 Start of first range. + * @param __last1 End of first range. + * @param __first2 Start of second range. + * @param __last2 End of second range. + * @param __comp The comparison functor. + * @return End of the output range. + * @ingroup set_algorithms + * + * This operation iterates over both ranges, copying elements present in + * both ranges in order to the output range. Iterators increment for each + * range. When the current element of one range is less than the other + * according to @p __comp, that iterator advances. If an element is + * contained in both ranges according to @p __comp, the element from the + * first range is copied and both ranges advance. The output range may not + * overlap either input range. + */ + template + inline _OutputIterator + set_intersection(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _OutputIterator __result, _Compare __comp) + { + // concept requirements + __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>) + __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>) + __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator, + typename iterator_traits<_InputIterator1>::value_type>) + __glibcxx_function_requires(_BinaryPredicateConcept<_Compare, + typename iterator_traits<_InputIterator1>::value_type, + typename iterator_traits<_InputIterator2>::value_type>) + __glibcxx_function_requires(_BinaryPredicateConcept<_Compare, + typename iterator_traits<_InputIterator2>::value_type, + typename iterator_traits<_InputIterator1>::value_type>) + __glibcxx_requires_sorted_set_pred(__first1, __last1, __first2, __comp); + __glibcxx_requires_sorted_set_pred(__first2, __last2, __first1, __comp); + + return _GLIBCXX_STD_A::__set_intersection(__first1, __last1, + __first2, __last2, __result, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } + + template + _OutputIterator + __set_difference(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _OutputIterator __result, _Compare __comp) + { + while (__first1 != __last1 && __first2 != __last2) + if (__comp(__first1, __first2)) + { + *__result = *__first1; + ++__first1; + ++__result; + } + else if (__comp(__first2, __first1)) + ++__first2; + else + { + ++__first1; + ++__first2; + } + return std::copy(__first1, __last1, __result); + } + + /** + * @brief Return the difference of two sorted ranges. + * @ingroup set_algorithms + * @param __first1 Start of first range. + * @param __last1 End of first range. + * @param __first2 Start of second range. + * @param __last2 End of second range. + * @return End of the output range. + * @ingroup set_algorithms + * + * This operation iterates over both ranges, copying elements present in + * the first range but not the second in order to the output range. + * Iterators increment for each range. When the current element of the + * first range is less than the second, that element is copied and the + * iterator advances. If the current element of the second range is less, + * the iterator advances, but no element is copied. If an element is + * contained in both ranges, no elements are copied and both ranges + * advance. The output range may not overlap either input range. + */ + template + inline _OutputIterator + set_difference(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _OutputIterator __result) + { + // concept requirements + __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>) + __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>) + __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator, + typename iterator_traits<_InputIterator1>::value_type>) + __glibcxx_function_requires(_LessThanOpConcept< + typename iterator_traits<_InputIterator1>::value_type, + typename iterator_traits<_InputIterator2>::value_type>) + __glibcxx_function_requires(_LessThanOpConcept< + typename iterator_traits<_InputIterator2>::value_type, + typename iterator_traits<_InputIterator1>::value_type>) + __glibcxx_requires_sorted_set(__first1, __last1, __first2); + __glibcxx_requires_sorted_set(__first2, __last2, __first1); + + return _GLIBCXX_STD_A::__set_difference(__first1, __last1, + __first2, __last2, __result, + __gnu_cxx::__ops::__iter_less_iter()); + } + + /** + * @brief Return the difference of two sorted ranges using comparison + * functor. + * @ingroup set_algorithms + * @param __first1 Start of first range. + * @param __last1 End of first range. + * @param __first2 Start of second range. + * @param __last2 End of second range. + * @param __comp The comparison functor. + * @return End of the output range. + * @ingroup set_algorithms + * + * This operation iterates over both ranges, copying elements present in + * the first range but not the second in order to the output range. + * Iterators increment for each range. When the current element of the + * first range is less than the second according to @p __comp, that element + * is copied and the iterator advances. If the current element of the + * second range is less, no element is copied and the iterator advances. + * If an element is contained in both ranges according to @p __comp, no + * elements are copied and both ranges advance. The output range may not + * overlap either input range. + */ + template + inline _OutputIterator + set_difference(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _OutputIterator __result, _Compare __comp) + { + // concept requirements + __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>) + __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>) + __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator, + typename iterator_traits<_InputIterator1>::value_type>) + __glibcxx_function_requires(_BinaryPredicateConcept<_Compare, + typename iterator_traits<_InputIterator1>::value_type, + typename iterator_traits<_InputIterator2>::value_type>) + __glibcxx_function_requires(_BinaryPredicateConcept<_Compare, + typename iterator_traits<_InputIterator2>::value_type, + typename iterator_traits<_InputIterator1>::value_type>) + __glibcxx_requires_sorted_set_pred(__first1, __last1, __first2, __comp); + __glibcxx_requires_sorted_set_pred(__first2, __last2, __first1, __comp); + + return _GLIBCXX_STD_A::__set_difference(__first1, __last1, + __first2, __last2, __result, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } + + template + _OutputIterator + __set_symmetric_difference(_InputIterator1 __first1, + _InputIterator1 __last1, + _InputIterator2 __first2, + _InputIterator2 __last2, + _OutputIterator __result, + _Compare __comp) + { + while (__first1 != __last1 && __first2 != __last2) + if (__comp(__first1, __first2)) + { + *__result = *__first1; + ++__first1; + ++__result; + } + else if (__comp(__first2, __first1)) + { + *__result = *__first2; + ++__first2; + ++__result; + } + else + { + ++__first1; + ++__first2; + } + return std::copy(__first2, __last2, + std::copy(__first1, __last1, __result)); + } + + /** + * @brief Return the symmetric difference of two sorted ranges. + * @ingroup set_algorithms + * @param __first1 Start of first range. + * @param __last1 End of first range. + * @param __first2 Start of second range. + * @param __last2 End of second range. + * @return End of the output range. + * @ingroup set_algorithms + * + * This operation iterates over both ranges, copying elements present in + * one range but not the other in order to the output range. Iterators + * increment for each range. When the current element of one range is less + * than the other, that element is copied and the iterator advances. If an + * element is contained in both ranges, no elements are copied and both + * ranges advance. The output range may not overlap either input range. + */ + template + inline _OutputIterator + set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _OutputIterator __result) + { + // concept requirements + __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>) + __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>) + __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator, + typename iterator_traits<_InputIterator1>::value_type>) + __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator, + typename iterator_traits<_InputIterator2>::value_type>) + __glibcxx_function_requires(_LessThanOpConcept< + typename iterator_traits<_InputIterator1>::value_type, + typename iterator_traits<_InputIterator2>::value_type>) + __glibcxx_function_requires(_LessThanOpConcept< + typename iterator_traits<_InputIterator2>::value_type, + typename iterator_traits<_InputIterator1>::value_type>) + __glibcxx_requires_sorted_set(__first1, __last1, __first2); + __glibcxx_requires_sorted_set(__first2, __last2, __first1); + + return _GLIBCXX_STD_A::__set_symmetric_difference(__first1, __last1, + __first2, __last2, __result, + __gnu_cxx::__ops::__iter_less_iter()); + } + + /** + * @brief Return the symmetric difference of two sorted ranges using + * comparison functor. + * @ingroup set_algorithms + * @param __first1 Start of first range. + * @param __last1 End of first range. + * @param __first2 Start of second range. + * @param __last2 End of second range. + * @param __comp The comparison functor. + * @return End of the output range. + * @ingroup set_algorithms + * + * This operation iterates over both ranges, copying elements present in + * one range but not the other in order to the output range. Iterators + * increment for each range. When the current element of one range is less + * than the other according to @p comp, that element is copied and the + * iterator advances. If an element is contained in both ranges according + * to @p __comp, no elements are copied and both ranges advance. The output + * range may not overlap either input range. + */ + template + inline _OutputIterator + set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _OutputIterator __result, + _Compare __comp) + { + // concept requirements + __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>) + __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>) + __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator, + typename iterator_traits<_InputIterator1>::value_type>) + __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator, + typename iterator_traits<_InputIterator2>::value_type>) + __glibcxx_function_requires(_BinaryPredicateConcept<_Compare, + typename iterator_traits<_InputIterator1>::value_type, + typename iterator_traits<_InputIterator2>::value_type>) + __glibcxx_function_requires(_BinaryPredicateConcept<_Compare, + typename iterator_traits<_InputIterator2>::value_type, + typename iterator_traits<_InputIterator1>::value_type>) + __glibcxx_requires_sorted_set_pred(__first1, __last1, __first2, __comp); + __glibcxx_requires_sorted_set_pred(__first2, __last2, __first1, __comp); + + return _GLIBCXX_STD_A::__set_symmetric_difference(__first1, __last1, + __first2, __last2, __result, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } + + template + _ForwardIterator + __min_element(_ForwardIterator __first, _ForwardIterator __last, + _Compare __comp) + { + if (__first == __last) + return __first; + _ForwardIterator __result = __first; + while (++__first != __last) + if (__comp(__first, __result)) + __result = __first; + return __result; + } + + /** + * @brief Return the minimum element in a range. + * @ingroup sorting_algorithms + * @param __first Start of range. + * @param __last End of range. + * @return Iterator referencing the first instance of the smallest value. + */ + template + _ForwardIterator + inline min_element(_ForwardIterator __first, _ForwardIterator __last) + { + // concept requirements + __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>) + __glibcxx_function_requires(_LessThanComparableConcept< + typename iterator_traits<_ForwardIterator>::value_type>) + __glibcxx_requires_valid_range(__first, __last); + + return _GLIBCXX_STD_A::__min_element(__first, __last, + __gnu_cxx::__ops::__iter_less_iter()); + } + + /** + * @brief Return the minimum element in a range using comparison functor. + * @ingroup sorting_algorithms + * @param __first Start of range. + * @param __last End of range. + * @param __comp Comparison functor. + * @return Iterator referencing the first instance of the smallest value + * according to __comp. + */ + template + inline _ForwardIterator + min_element(_ForwardIterator __first, _ForwardIterator __last, + _Compare __comp) + { + // concept requirements + __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>) + __glibcxx_function_requires(_BinaryPredicateConcept<_Compare, + typename iterator_traits<_ForwardIterator>::value_type, + typename iterator_traits<_ForwardIterator>::value_type>) + __glibcxx_requires_valid_range(__first, __last); + + return _GLIBCXX_STD_A::__min_element(__first, __last, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } + + template + _ForwardIterator + __max_element(_ForwardIterator __first, _ForwardIterator __last, + _Compare __comp) + { + if (__first == __last) return __first; + _ForwardIterator __result = __first; + while (++__first != __last) + if (__comp(__result, __first)) + __result = __first; + return __result; + } + + /** + * @brief Return the maximum element in a range. + * @ingroup sorting_algorithms + * @param __first Start of range. + * @param __last End of range. + * @return Iterator referencing the first instance of the largest value. + */ + template + inline _ForwardIterator + max_element(_ForwardIterator __first, _ForwardIterator __last) + { + // concept requirements + __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>) + __glibcxx_function_requires(_LessThanComparableConcept< + typename iterator_traits<_ForwardIterator>::value_type>) + __glibcxx_requires_valid_range(__first, __last); + + return _GLIBCXX_STD_A::__max_element(__first, __last, + __gnu_cxx::__ops::__iter_less_iter()); + } + + /** + * @brief Return the maximum element in a range using comparison functor. + * @ingroup sorting_algorithms + * @param __first Start of range. + * @param __last End of range. + * @param __comp Comparison functor. + * @return Iterator referencing the first instance of the largest value + * according to __comp. + */ + template + inline _ForwardIterator + max_element(_ForwardIterator __first, _ForwardIterator __last, + _Compare __comp) + { + // concept requirements + __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>) + __glibcxx_function_requires(_BinaryPredicateConcept<_Compare, + typename iterator_traits<_ForwardIterator>::value_type, + typename iterator_traits<_ForwardIterator>::value_type>) + __glibcxx_requires_valid_range(__first, __last); + + return _GLIBCXX_STD_A::__max_element(__first, __last, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } + +_GLIBCXX_END_NAMESPACE_ALGO +} // namespace std + +#endif /* _STL_ALGO_H */ diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stl_algobase.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stl_algobase.h new file mode 100755 index 0000000..f7c11e9 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stl_algobase.h @@ -0,0 +1,1427 @@ +// Core algorithmic facilities -*- C++ -*- + +// Copyright (C) 2001-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/* + * + * Copyright (c) 1994 + * Hewlett-Packard Company + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Hewlett-Packard Company makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + * + * + * Copyright (c) 1996-1998 + * Silicon Graphics Computer Systems, Inc. + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Silicon Graphics makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + */ + +/** @file bits/stl_algobase.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{algorithm} + */ + +#ifndef _STL_ALGOBASE_H +#define _STL_ALGOBASE_H 1 + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include // For std::swap and _GLIBCXX_MOVE +#include + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + +#if __cplusplus < 201103L + // See http://gcc.gnu.org/ml/libstdc++/2004-08/msg00167.html: in a + // nutshell, we are partially implementing the resolution of DR 187, + // when it's safe, i.e., the value_types are equal. + template + struct __iter_swap + { + template + static void + iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b) + { + typedef typename iterator_traits<_ForwardIterator1>::value_type + _ValueType1; + _ValueType1 __tmp = _GLIBCXX_MOVE(*__a); + *__a = _GLIBCXX_MOVE(*__b); + *__b = _GLIBCXX_MOVE(__tmp); + } + }; + + template<> + struct __iter_swap + { + template + static void + iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b) + { + swap(*__a, *__b); + } + }; +#endif + + /** + * @brief Swaps the contents of two iterators. + * @ingroup mutating_algorithms + * @param __a An iterator. + * @param __b Another iterator. + * @return Nothing. + * + * This function swaps the values pointed to by two iterators, not the + * iterators themselves. + */ + template + inline void + iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b) + { + // concept requirements + __glibcxx_function_requires(_Mutable_ForwardIteratorConcept< + _ForwardIterator1>) + __glibcxx_function_requires(_Mutable_ForwardIteratorConcept< + _ForwardIterator2>) + +#if __cplusplus < 201103L + typedef typename iterator_traits<_ForwardIterator1>::value_type + _ValueType1; + typedef typename iterator_traits<_ForwardIterator2>::value_type + _ValueType2; + + __glibcxx_function_requires(_ConvertibleConcept<_ValueType1, + _ValueType2>) + __glibcxx_function_requires(_ConvertibleConcept<_ValueType2, + _ValueType1>) + + typedef typename iterator_traits<_ForwardIterator1>::reference + _ReferenceType1; + typedef typename iterator_traits<_ForwardIterator2>::reference + _ReferenceType2; + std::__iter_swap<__are_same<_ValueType1, _ValueType2>::__value + && __are_same<_ValueType1&, _ReferenceType1>::__value + && __are_same<_ValueType2&, _ReferenceType2>::__value>:: + iter_swap(__a, __b); +#else + swap(*__a, *__b); +#endif + } + + /** + * @brief Swap the elements of two sequences. + * @ingroup mutating_algorithms + * @param __first1 A forward iterator. + * @param __last1 A forward iterator. + * @param __first2 A forward iterator. + * @return An iterator equal to @p first2+(last1-first1). + * + * Swaps each element in the range @p [first1,last1) with the + * corresponding element in the range @p [first2,(last1-first1)). + * The ranges must not overlap. + */ + template + _ForwardIterator2 + swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2) + { + // concept requirements + __glibcxx_function_requires(_Mutable_ForwardIteratorConcept< + _ForwardIterator1>) + __glibcxx_function_requires(_Mutable_ForwardIteratorConcept< + _ForwardIterator2>) + __glibcxx_requires_valid_range(__first1, __last1); + + for (; __first1 != __last1; ++__first1, ++__first2) + std::iter_swap(__first1, __first2); + return __first2; + } + + /** + * @brief This does what you think it does. + * @ingroup sorting_algorithms + * @param __a A thing of arbitrary type. + * @param __b Another thing of arbitrary type. + * @return The lesser of the parameters. + * + * This is the simple classic generic implementation. It will work on + * temporary expressions, since they are only evaluated once, unlike a + * preprocessor macro. + */ + template + inline const _Tp& + min(const _Tp& __a, const _Tp& __b) + { + // concept requirements + __glibcxx_function_requires(_LessThanComparableConcept<_Tp>) + //return __b < __a ? __b : __a; + if (__b < __a) + return __b; + return __a; + } + + /** + * @brief This does what you think it does. + * @ingroup sorting_algorithms + * @param __a A thing of arbitrary type. + * @param __b Another thing of arbitrary type. + * @return The greater of the parameters. + * + * This is the simple classic generic implementation. It will work on + * temporary expressions, since they are only evaluated once, unlike a + * preprocessor macro. + */ + template + inline const _Tp& + max(const _Tp& __a, const _Tp& __b) + { + // concept requirements + __glibcxx_function_requires(_LessThanComparableConcept<_Tp>) + //return __a < __b ? __b : __a; + if (__a < __b) + return __b; + return __a; + } + + /** + * @brief This does what you think it does. + * @ingroup sorting_algorithms + * @param __a A thing of arbitrary type. + * @param __b Another thing of arbitrary type. + * @param __comp A @link comparison_functors comparison functor@endlink. + * @return The lesser of the parameters. + * + * This will work on temporary expressions, since they are only evaluated + * once, unlike a preprocessor macro. + */ + template + inline const _Tp& + min(const _Tp& __a, const _Tp& __b, _Compare __comp) + { + //return __comp(__b, __a) ? __b : __a; + if (__comp(__b, __a)) + return __b; + return __a; + } + + /** + * @brief This does what you think it does. + * @ingroup sorting_algorithms + * @param __a A thing of arbitrary type. + * @param __b Another thing of arbitrary type. + * @param __comp A @link comparison_functors comparison functor@endlink. + * @return The greater of the parameters. + * + * This will work on temporary expressions, since they are only evaluated + * once, unlike a preprocessor macro. + */ + template + inline const _Tp& + max(const _Tp& __a, const _Tp& __b, _Compare __comp) + { + //return __comp(__a, __b) ? __b : __a; + if (__comp(__a, __b)) + return __b; + return __a; + } + + // If _Iterator is a __normal_iterator return its base (a plain pointer, + // normally) otherwise return it untouched. See copy, fill, ... + template + struct _Niter_base + : _Iter_base<_Iterator, __is_normal_iterator<_Iterator>::__value> + { }; + + template + inline typename _Niter_base<_Iterator>::iterator_type + __niter_base(_Iterator __it) + { return std::_Niter_base<_Iterator>::_S_base(__it); } + + // Likewise, for move_iterator. + template + struct _Miter_base + : _Iter_base<_Iterator, __is_move_iterator<_Iterator>::__value> + { }; + + template + inline typename _Miter_base<_Iterator>::iterator_type + __miter_base(_Iterator __it) + { return std::_Miter_base<_Iterator>::_S_base(__it); } + + // All of these auxiliary structs serve two purposes. (1) Replace + // calls to copy with memmove whenever possible. (Memmove, not memcpy, + // because the input and output ranges are permitted to overlap.) + // (2) If we're using random access iterators, then write the loop as + // a for loop with an explicit count. + + template + struct __copy_move + { + template + static _OI + __copy_m(_II __first, _II __last, _OI __result) + { + for (; __first != __last; ++__result, ++__first) + *__result = *__first; + return __result; + } + }; + +#if __cplusplus >= 201103L + template + struct __copy_move + { + template + static _OI + __copy_m(_II __first, _II __last, _OI __result) + { + for (; __first != __last; ++__result, ++__first) + *__result = std::move(*__first); + return __result; + } + }; +#endif + + template<> + struct __copy_move + { + template + static _OI + __copy_m(_II __first, _II __last, _OI __result) + { + typedef typename iterator_traits<_II>::difference_type _Distance; + for(_Distance __n = __last - __first; __n > 0; --__n) + { + *__result = *__first; + ++__first; + ++__result; + } + return __result; + } + }; + +#if __cplusplus >= 201103L + template<> + struct __copy_move + { + template + static _OI + __copy_m(_II __first, _II __last, _OI __result) + { + typedef typename iterator_traits<_II>::difference_type _Distance; + for(_Distance __n = __last - __first; __n > 0; --__n) + { + *__result = std::move(*__first); + ++__first; + ++__result; + } + return __result; + } + }; +#endif + + template + struct __copy_move<_IsMove, true, random_access_iterator_tag> + { + template + static _Tp* + __copy_m(const _Tp* __first, const _Tp* __last, _Tp* __result) + { +#if __cplusplus >= 201103L + // trivial types can have deleted assignment + static_assert( is_copy_assignable<_Tp>::value, + "type is not assignable" ); +#endif + const ptrdiff_t _Num = __last - __first; + if (_Num) + __builtin_memmove(__result, __first, sizeof(_Tp) * _Num); + return __result + _Num; + } + }; + + template + inline _OI + __copy_move_a(_II __first, _II __last, _OI __result) + { + typedef typename iterator_traits<_II>::value_type _ValueTypeI; + typedef typename iterator_traits<_OI>::value_type _ValueTypeO; + typedef typename iterator_traits<_II>::iterator_category _Category; + const bool __simple = (__is_trivial(_ValueTypeI) + && __is_pointer<_II>::__value + && __is_pointer<_OI>::__value + && __are_same<_ValueTypeI, _ValueTypeO>::__value); + + return std::__copy_move<_IsMove, __simple, + _Category>::__copy_m(__first, __last, __result); + } + + // Helpers for streambuf iterators (either istream or ostream). + // NB: avoid including , relatively large. + template + struct char_traits; + + template + class istreambuf_iterator; + + template + class ostreambuf_iterator; + + template + typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, + ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type + __copy_move_a2(_CharT*, _CharT*, + ostreambuf_iterator<_CharT, char_traits<_CharT> >); + + template + typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, + ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type + __copy_move_a2(const _CharT*, const _CharT*, + ostreambuf_iterator<_CharT, char_traits<_CharT> >); + + template + typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, + _CharT*>::__type + __copy_move_a2(istreambuf_iterator<_CharT, char_traits<_CharT> >, + istreambuf_iterator<_CharT, char_traits<_CharT> >, _CharT*); + + template + inline _OI + __copy_move_a2(_II __first, _II __last, _OI __result) + { + return _OI(std::__copy_move_a<_IsMove>(std::__niter_base(__first), + std::__niter_base(__last), + std::__niter_base(__result))); + } + + /** + * @brief Copies the range [first,last) into result. + * @ingroup mutating_algorithms + * @param __first An input iterator. + * @param __last An input iterator. + * @param __result An output iterator. + * @return result + (first - last) + * + * This inline function will boil down to a call to @c memmove whenever + * possible. Failing that, if random access iterators are passed, then the + * loop count will be known (and therefore a candidate for compiler + * optimizations such as unrolling). Result may not be contained within + * [first,last); the copy_backward function should be used instead. + * + * Note that the end of the output range is permitted to be contained + * within [first,last). + */ + template + inline _OI + copy(_II __first, _II __last, _OI __result) + { + // concept requirements + __glibcxx_function_requires(_InputIteratorConcept<_II>) + __glibcxx_function_requires(_OutputIteratorConcept<_OI, + typename iterator_traits<_II>::value_type>) + __glibcxx_requires_valid_range(__first, __last); + + return (std::__copy_move_a2<__is_move_iterator<_II>::__value> + (std::__miter_base(__first), std::__miter_base(__last), + __result)); + } + +#if __cplusplus >= 201103L + /** + * @brief Moves the range [first,last) into result. + * @ingroup mutating_algorithms + * @param __first An input iterator. + * @param __last An input iterator. + * @param __result An output iterator. + * @return result + (first - last) + * + * This inline function will boil down to a call to @c memmove whenever + * possible. Failing that, if random access iterators are passed, then the + * loop count will be known (and therefore a candidate for compiler + * optimizations such as unrolling). Result may not be contained within + * [first,last); the move_backward function should be used instead. + * + * Note that the end of the output range is permitted to be contained + * within [first,last). + */ + template + inline _OI + move(_II __first, _II __last, _OI __result) + { + // concept requirements + __glibcxx_function_requires(_InputIteratorConcept<_II>) + __glibcxx_function_requires(_OutputIteratorConcept<_OI, + typename iterator_traits<_II>::value_type>) + __glibcxx_requires_valid_range(__first, __last); + + return std::__copy_move_a2(std::__miter_base(__first), + std::__miter_base(__last), __result); + } + +#define _GLIBCXX_MOVE3(_Tp, _Up, _Vp) std::move(_Tp, _Up, _Vp) +#else +#define _GLIBCXX_MOVE3(_Tp, _Up, _Vp) std::copy(_Tp, _Up, _Vp) +#endif + + template + struct __copy_move_backward + { + template + static _BI2 + __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) + { + while (__first != __last) + *--__result = *--__last; + return __result; + } + }; + +#if __cplusplus >= 201103L + template + struct __copy_move_backward + { + template + static _BI2 + __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) + { + while (__first != __last) + *--__result = std::move(*--__last); + return __result; + } + }; +#endif + + template<> + struct __copy_move_backward + { + template + static _BI2 + __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) + { + typename iterator_traits<_BI1>::difference_type __n; + for (__n = __last - __first; __n > 0; --__n) + *--__result = *--__last; + return __result; + } + }; + +#if __cplusplus >= 201103L + template<> + struct __copy_move_backward + { + template + static _BI2 + __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) + { + typename iterator_traits<_BI1>::difference_type __n; + for (__n = __last - __first; __n > 0; --__n) + *--__result = std::move(*--__last); + return __result; + } + }; +#endif + + template + struct __copy_move_backward<_IsMove, true, random_access_iterator_tag> + { + template + static _Tp* + __copy_move_b(const _Tp* __first, const _Tp* __last, _Tp* __result) + { +#if __cplusplus >= 201103L + // trivial types can have deleted assignment + static_assert( is_copy_assignable<_Tp>::value, + "type is not assignable" ); +#endif + const ptrdiff_t _Num = __last - __first; + if (_Num) + __builtin_memmove(__result - _Num, __first, sizeof(_Tp) * _Num); + return __result - _Num; + } + }; + + template + inline _BI2 + __copy_move_backward_a(_BI1 __first, _BI1 __last, _BI2 __result) + { + typedef typename iterator_traits<_BI1>::value_type _ValueType1; + typedef typename iterator_traits<_BI2>::value_type _ValueType2; + typedef typename iterator_traits<_BI1>::iterator_category _Category; + const bool __simple = (__is_trivial(_ValueType1) + && __is_pointer<_BI1>::__value + && __is_pointer<_BI2>::__value + && __are_same<_ValueType1, _ValueType2>::__value); + + return std::__copy_move_backward<_IsMove, __simple, + _Category>::__copy_move_b(__first, + __last, + __result); + } + + template + inline _BI2 + __copy_move_backward_a2(_BI1 __first, _BI1 __last, _BI2 __result) + { + return _BI2(std::__copy_move_backward_a<_IsMove> + (std::__niter_base(__first), std::__niter_base(__last), + std::__niter_base(__result))); + } + + /** + * @brief Copies the range [first,last) into result. + * @ingroup mutating_algorithms + * @param __first A bidirectional iterator. + * @param __last A bidirectional iterator. + * @param __result A bidirectional iterator. + * @return result - (first - last) + * + * The function has the same effect as copy, but starts at the end of the + * range and works its way to the start, returning the start of the result. + * This inline function will boil down to a call to @c memmove whenever + * possible. Failing that, if random access iterators are passed, then the + * loop count will be known (and therefore a candidate for compiler + * optimizations such as unrolling). + * + * Result may not be in the range (first,last]. Use copy instead. Note + * that the start of the output range may overlap [first,last). + */ + template + inline _BI2 + copy_backward(_BI1 __first, _BI1 __last, _BI2 __result) + { + // concept requirements + __glibcxx_function_requires(_BidirectionalIteratorConcept<_BI1>) + __glibcxx_function_requires(_Mutable_BidirectionalIteratorConcept<_BI2>) + __glibcxx_function_requires(_ConvertibleConcept< + typename iterator_traits<_BI1>::value_type, + typename iterator_traits<_BI2>::value_type>) + __glibcxx_requires_valid_range(__first, __last); + + return (std::__copy_move_backward_a2<__is_move_iterator<_BI1>::__value> + (std::__miter_base(__first), std::__miter_base(__last), + __result)); + } + +#if __cplusplus >= 201103L + /** + * @brief Moves the range [first,last) into result. + * @ingroup mutating_algorithms + * @param __first A bidirectional iterator. + * @param __last A bidirectional iterator. + * @param __result A bidirectional iterator. + * @return result - (first - last) + * + * The function has the same effect as move, but starts at the end of the + * range and works its way to the start, returning the start of the result. + * This inline function will boil down to a call to @c memmove whenever + * possible. Failing that, if random access iterators are passed, then the + * loop count will be known (and therefore a candidate for compiler + * optimizations such as unrolling). + * + * Result may not be in the range (first,last]. Use move instead. Note + * that the start of the output range may overlap [first,last). + */ + template + inline _BI2 + move_backward(_BI1 __first, _BI1 __last, _BI2 __result) + { + // concept requirements + __glibcxx_function_requires(_BidirectionalIteratorConcept<_BI1>) + __glibcxx_function_requires(_Mutable_BidirectionalIteratorConcept<_BI2>) + __glibcxx_function_requires(_ConvertibleConcept< + typename iterator_traits<_BI1>::value_type, + typename iterator_traits<_BI2>::value_type>) + __glibcxx_requires_valid_range(__first, __last); + + return std::__copy_move_backward_a2(std::__miter_base(__first), + std::__miter_base(__last), + __result); + } + +#define _GLIBCXX_MOVE_BACKWARD3(_Tp, _Up, _Vp) std::move_backward(_Tp, _Up, _Vp) +#else +#define _GLIBCXX_MOVE_BACKWARD3(_Tp, _Up, _Vp) std::copy_backward(_Tp, _Up, _Vp) +#endif + + template + inline typename + __gnu_cxx::__enable_if::__value, void>::__type + __fill_a(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __value) + { + for (; __first != __last; ++__first) + *__first = __value; + } + + template + inline typename + __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, void>::__type + __fill_a(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __value) + { + const _Tp __tmp = __value; + for (; __first != __last; ++__first) + *__first = __tmp; + } + + // Specialization: for char types we can use memset. + template + inline typename + __gnu_cxx::__enable_if<__is_byte<_Tp>::__value, void>::__type + __fill_a(_Tp* __first, _Tp* __last, const _Tp& __c) + { + const _Tp __tmp = __c; + __builtin_memset(__first, static_cast(__tmp), + __last - __first); + } + + /** + * @brief Fills the range [first,last) with copies of value. + * @ingroup mutating_algorithms + * @param __first A forward iterator. + * @param __last A forward iterator. + * @param __value A reference-to-const of arbitrary type. + * @return Nothing. + * + * This function fills a range with copies of the same value. For char + * types filling contiguous areas of memory, this becomes an inline call + * to @c memset or @c wmemset. + */ + template + inline void + fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) + { + // concept requirements + __glibcxx_function_requires(_Mutable_ForwardIteratorConcept< + _ForwardIterator>) + __glibcxx_requires_valid_range(__first, __last); + + std::__fill_a(std::__niter_base(__first), std::__niter_base(__last), + __value); + } + + template + inline typename + __gnu_cxx::__enable_if::__value, _OutputIterator>::__type + __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value) + { + for (__decltype(__n + 0) __niter = __n; + __niter > 0; --__niter, ++__first) + *__first = __value; + return __first; + } + + template + inline typename + __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, _OutputIterator>::__type + __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value) + { + const _Tp __tmp = __value; + for (__decltype(__n + 0) __niter = __n; + __niter > 0; --__niter, ++__first) + *__first = __tmp; + return __first; + } + + template + inline typename + __gnu_cxx::__enable_if<__is_byte<_Tp>::__value, _Tp*>::__type + __fill_n_a(_Tp* __first, _Size __n, const _Tp& __c) + { + std::__fill_a(__first, __first + __n, __c); + return __first + __n; + } + + /** + * @brief Fills the range [first,first+n) with copies of value. + * @ingroup mutating_algorithms + * @param __first An output iterator. + * @param __n The count of copies to perform. + * @param __value A reference-to-const of arbitrary type. + * @return The iterator at first+n. + * + * This function fills a range with copies of the same value. For char + * types filling contiguous areas of memory, this becomes an inline call + * to @c memset or @ wmemset. + * + * _GLIBCXX_RESOLVE_LIB_DEFECTS + * DR 865. More algorithms that throw away information + */ + template + inline _OI + fill_n(_OI __first, _Size __n, const _Tp& __value) + { + // concept requirements + __glibcxx_function_requires(_OutputIteratorConcept<_OI, _Tp>) + + return _OI(std::__fill_n_a(std::__niter_base(__first), __n, __value)); + } + + template + struct __equal + { + template + static bool + equal(_II1 __first1, _II1 __last1, _II2 __first2) + { + for (; __first1 != __last1; ++__first1, ++__first2) + if (!(*__first1 == *__first2)) + return false; + return true; + } + }; + + template<> + struct __equal + { + template + static bool + equal(const _Tp* __first1, const _Tp* __last1, const _Tp* __first2) + { + return !__builtin_memcmp(__first1, __first2, sizeof(_Tp) + * (__last1 - __first1)); + } + }; + + template + inline bool + __equal_aux(_II1 __first1, _II1 __last1, _II2 __first2) + { + typedef typename iterator_traits<_II1>::value_type _ValueType1; + typedef typename iterator_traits<_II2>::value_type _ValueType2; + const bool __simple = ((__is_integer<_ValueType1>::__value + || __is_pointer<_ValueType1>::__value) + && __is_pointer<_II1>::__value + && __is_pointer<_II2>::__value + && __are_same<_ValueType1, _ValueType2>::__value); + + return std::__equal<__simple>::equal(__first1, __last1, __first2); + } + + template + struct __lc_rai + { + template + static _II1 + __newlast1(_II1, _II1 __last1, _II2, _II2) + { return __last1; } + + template + static bool + __cnd2(_II __first, _II __last) + { return __first != __last; } + }; + + template<> + struct __lc_rai + { + template + static _RAI1 + __newlast1(_RAI1 __first1, _RAI1 __last1, + _RAI2 __first2, _RAI2 __last2) + { + const typename iterator_traits<_RAI1>::difference_type + __diff1 = __last1 - __first1; + const typename iterator_traits<_RAI2>::difference_type + __diff2 = __last2 - __first2; + return __diff2 < __diff1 ? __first1 + __diff2 : __last1; + } + + template + static bool + __cnd2(_RAI, _RAI) + { return true; } + }; + + template + bool + __lexicographical_compare_impl(_II1 __first1, _II1 __last1, + _II2 __first2, _II2 __last2, + _Compare __comp) + { + typedef typename iterator_traits<_II1>::iterator_category _Category1; + typedef typename iterator_traits<_II2>::iterator_category _Category2; + typedef std::__lc_rai<_Category1, _Category2> __rai_type; + + __last1 = __rai_type::__newlast1(__first1, __last1, __first2, __last2); + for (; __first1 != __last1 && __rai_type::__cnd2(__first2, __last2); + ++__first1, ++__first2) + { + if (__comp(__first1, __first2)) + return true; + if (__comp(__first2, __first1)) + return false; + } + return __first1 == __last1 && __first2 != __last2; + } + + template + struct __lexicographical_compare + { + template + static bool __lc(_II1, _II1, _II2, _II2); + }; + + template + template + bool + __lexicographical_compare<_BoolType>:: + __lc(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) + { + return std::__lexicographical_compare_impl(__first1, __last1, + __first2, __last2, + __gnu_cxx::__ops::__iter_less_iter()); + } + + template<> + struct __lexicographical_compare + { + template + static bool + __lc(const _Tp* __first1, const _Tp* __last1, + const _Up* __first2, const _Up* __last2) + { + const size_t __len1 = __last1 - __first1; + const size_t __len2 = __last2 - __first2; + const int __result = __builtin_memcmp(__first1, __first2, + std::min(__len1, __len2)); + return __result != 0 ? __result < 0 : __len1 < __len2; + } + }; + + template + inline bool + __lexicographical_compare_aux(_II1 __first1, _II1 __last1, + _II2 __first2, _II2 __last2) + { + typedef typename iterator_traits<_II1>::value_type _ValueType1; + typedef typename iterator_traits<_II2>::value_type _ValueType2; + const bool __simple = + (__is_byte<_ValueType1>::__value && __is_byte<_ValueType2>::__value + && !__gnu_cxx::__numeric_traits<_ValueType1>::__is_signed + && !__gnu_cxx::__numeric_traits<_ValueType2>::__is_signed + && __is_pointer<_II1>::__value + && __is_pointer<_II2>::__value); + + return std::__lexicographical_compare<__simple>::__lc(__first1, __last1, + __first2, __last2); + } + + template + _ForwardIterator + __lower_bound(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __val, _Compare __comp) + { + typedef typename iterator_traits<_ForwardIterator>::difference_type + _DistanceType; + + _DistanceType __len = std::distance(__first, __last); + + while (__len > 0) + { + _DistanceType __half = __len >> 1; + _ForwardIterator __middle = __first; + std::advance(__middle, __half); + if (__comp(__middle, __val)) + { + __first = __middle; + ++__first; + __len = __len - __half - 1; + } + else + __len = __half; + } + return __first; + } + + /** + * @brief Finds the first position in which @a val could be inserted + * without changing the ordering. + * @param __first An iterator. + * @param __last Another iterator. + * @param __val The search term. + * @return An iterator pointing to the first element not less + * than @a val, or end() if every element is less than + * @a val. + * @ingroup binary_search_algorithms + */ + template + inline _ForwardIterator + lower_bound(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __val) + { + // concept requirements + __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>) + __glibcxx_function_requires(_LessThanOpConcept< + typename iterator_traits<_ForwardIterator>::value_type, _Tp>) + __glibcxx_requires_partitioned_lower(__first, __last, __val); + + return std::__lower_bound(__first, __last, __val, + __gnu_cxx::__ops::__iter_less_val()); + } + + /// This is a helper function for the sort routines and for random.tcc. + // Precondition: __n > 0. + inline _GLIBCXX_CONSTEXPR int + __lg(int __n) + { return sizeof(int) * __CHAR_BIT__ - 1 - __builtin_clz(__n); } + + inline _GLIBCXX_CONSTEXPR unsigned + __lg(unsigned __n) + { return sizeof(int) * __CHAR_BIT__ - 1 - __builtin_clz(__n); } + + inline _GLIBCXX_CONSTEXPR long + __lg(long __n) + { return sizeof(long) * __CHAR_BIT__ - 1 - __builtin_clzl(__n); } + + inline _GLIBCXX_CONSTEXPR unsigned long + __lg(unsigned long __n) + { return sizeof(long) * __CHAR_BIT__ - 1 - __builtin_clzl(__n); } + + inline _GLIBCXX_CONSTEXPR long long + __lg(long long __n) + { return sizeof(long long) * __CHAR_BIT__ - 1 - __builtin_clzll(__n); } + + inline _GLIBCXX_CONSTEXPR unsigned long long + __lg(unsigned long long __n) + { return sizeof(long long) * __CHAR_BIT__ - 1 - __builtin_clzll(__n); } + +_GLIBCXX_END_NAMESPACE_VERSION + +_GLIBCXX_BEGIN_NAMESPACE_ALGO + + /** + * @brief Tests a range for element-wise equality. + * @ingroup non_mutating_algorithms + * @param __first1 An input iterator. + * @param __last1 An input iterator. + * @param __first2 An input iterator. + * @return A boolean true or false. + * + * This compares the elements of two ranges using @c == and returns true or + * false depending on whether all of the corresponding elements of the + * ranges are equal. + */ + template + inline bool + equal(_II1 __first1, _II1 __last1, _II2 __first2) + { + // concept requirements + __glibcxx_function_requires(_InputIteratorConcept<_II1>) + __glibcxx_function_requires(_InputIteratorConcept<_II2>) + __glibcxx_function_requires(_EqualOpConcept< + typename iterator_traits<_II1>::value_type, + typename iterator_traits<_II2>::value_type>) + __glibcxx_requires_valid_range(__first1, __last1); + + return std::__equal_aux(std::__niter_base(__first1), + std::__niter_base(__last1), + std::__niter_base(__first2)); + } + + /** + * @brief Tests a range for element-wise equality. + * @ingroup non_mutating_algorithms + * @param __first1 An input iterator. + * @param __last1 An input iterator. + * @param __first2 An input iterator. + * @param __binary_pred A binary predicate @link functors + * functor@endlink. + * @return A boolean true or false. + * + * This compares the elements of two ranges using the binary_pred + * parameter, and returns true or + * false depending on whether all of the corresponding elements of the + * ranges are equal. + */ + template + inline bool + equal(_IIter1 __first1, _IIter1 __last1, + _IIter2 __first2, _BinaryPredicate __binary_pred) + { + // concept requirements + __glibcxx_function_requires(_InputIteratorConcept<_IIter1>) + __glibcxx_function_requires(_InputIteratorConcept<_IIter2>) + __glibcxx_requires_valid_range(__first1, __last1); + + for (; __first1 != __last1; ++__first1, ++__first2) + if (!bool(__binary_pred(*__first1, *__first2))) + return false; + return true; + } + +#if __cplusplus > 201103L + +#define __cpp_lib_robust_nonmodifying_seq_ops 201304 + + /** + * @brief Tests a range for element-wise equality. + * @ingroup non_mutating_algorithms + * @param __first1 An input iterator. + * @param __last1 An input iterator. + * @param __first2 An input iterator. + * @param __last2 An input iterator. + * @return A boolean true or false. + * + * This compares the elements of two ranges using @c == and returns true or + * false depending on whether all of the corresponding elements of the + * ranges are equal. + */ + template + inline bool + equal(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) + { + // concept requirements + __glibcxx_function_requires(_InputIteratorConcept<_II1>) + __glibcxx_function_requires(_InputIteratorConcept<_II2>) + __glibcxx_function_requires(_EqualOpConcept< + typename iterator_traits<_II1>::value_type, + typename iterator_traits<_II2>::value_type>) + __glibcxx_requires_valid_range(__first1, __last1); + __glibcxx_requires_valid_range(__first2, __last2); + + using _RATag = random_access_iterator_tag; + using _Cat1 = typename iterator_traits<_II1>::iterator_category; + using _Cat2 = typename iterator_traits<_II2>::iterator_category; + using _RAIters = __and_, is_same<_Cat2, _RATag>>; + if (_RAIters()) + { + auto __d1 = std::distance(__first1, __last1); + auto __d2 = std::distance(__first2, __last2); + if (__d1 != __d2) + return false; + return _GLIBCXX_STD_A::equal(__first1, __last1, __first2); + } + + for (; __first1 != __last1 && __first2 != __last2; ++__first1, ++__first2) + if (!(*__first1 == *__first2)) + return false; + return __first1 == __last1 && __first2 == __last2; + } + + /** + * @brief Tests a range for element-wise equality. + * @ingroup non_mutating_algorithms + * @param __first1 An input iterator. + * @param __last1 An input iterator. + * @param __first2 An input iterator. + * @param __last2 An input iterator. + * @param __binary_pred A binary predicate @link functors + * functor@endlink. + * @return A boolean true or false. + * + * This compares the elements of two ranges using the binary_pred + * parameter, and returns true or + * false depending on whether all of the corresponding elements of the + * ranges are equal. + */ + template + inline bool + equal(_IIter1 __first1, _IIter1 __last1, + _IIter2 __first2, _IIter2 __last2, _BinaryPredicate __binary_pred) + { + // concept requirements + __glibcxx_function_requires(_InputIteratorConcept<_IIter1>) + __glibcxx_function_requires(_InputIteratorConcept<_IIter2>) + __glibcxx_requires_valid_range(__first1, __last1); + __glibcxx_requires_valid_range(__first2, __last2); + + using _RATag = random_access_iterator_tag; + using _Cat1 = typename iterator_traits<_IIter1>::iterator_category; + using _Cat2 = typename iterator_traits<_IIter2>::iterator_category; + using _RAIters = __and_, is_same<_Cat2, _RATag>>; + if (_RAIters()) + { + auto __d1 = std::distance(__first1, __last1); + auto __d2 = std::distance(__first2, __last2); + if (__d1 != __d2) + return false; + return _GLIBCXX_STD_A::equal(__first1, __last1, __first2, + __binary_pred); + } + + for (; __first1 != __last1 && __first2 != __last2; ++__first1, ++__first2) + if (!bool(__binary_pred(*__first1, *__first2))) + return false; + return __first1 == __last1 && __first2 == __last2; + } +#endif + + /** + * @brief Performs @b dictionary comparison on ranges. + * @ingroup sorting_algorithms + * @param __first1 An input iterator. + * @param __last1 An input iterator. + * @param __first2 An input iterator. + * @param __last2 An input iterator. + * @return A boolean true or false. + * + * Returns true if the sequence of elements defined by the range + * [first1,last1) is lexicographically less than the sequence of elements + * defined by the range [first2,last2). Returns false otherwise. + * (Quoted from [25.3.8]/1.) If the iterators are all character pointers, + * then this is an inline call to @c memcmp. + */ + template + inline bool + lexicographical_compare(_II1 __first1, _II1 __last1, + _II2 __first2, _II2 __last2) + { +#ifdef _GLIBCXX_CONCEPT_CHECKS + // concept requirements + typedef typename iterator_traits<_II1>::value_type _ValueType1; + typedef typename iterator_traits<_II2>::value_type _ValueType2; +#endif + __glibcxx_function_requires(_InputIteratorConcept<_II1>) + __glibcxx_function_requires(_InputIteratorConcept<_II2>) + __glibcxx_function_requires(_LessThanOpConcept<_ValueType1, _ValueType2>) + __glibcxx_function_requires(_LessThanOpConcept<_ValueType2, _ValueType1>) + __glibcxx_requires_valid_range(__first1, __last1); + __glibcxx_requires_valid_range(__first2, __last2); + + return std::__lexicographical_compare_aux(std::__niter_base(__first1), + std::__niter_base(__last1), + std::__niter_base(__first2), + std::__niter_base(__last2)); + } + + /** + * @brief Performs @b dictionary comparison on ranges. + * @ingroup sorting_algorithms + * @param __first1 An input iterator. + * @param __last1 An input iterator. + * @param __first2 An input iterator. + * @param __last2 An input iterator. + * @param __comp A @link comparison_functors comparison functor@endlink. + * @return A boolean true or false. + * + * The same as the four-parameter @c lexicographical_compare, but uses the + * comp parameter instead of @c <. + */ + template + inline bool + lexicographical_compare(_II1 __first1, _II1 __last1, + _II2 __first2, _II2 __last2, _Compare __comp) + { + // concept requirements + __glibcxx_function_requires(_InputIteratorConcept<_II1>) + __glibcxx_function_requires(_InputIteratorConcept<_II2>) + __glibcxx_requires_valid_range(__first1, __last1); + __glibcxx_requires_valid_range(__first2, __last2); + + return std::__lexicographical_compare_impl + (__first1, __last1, __first2, __last2, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } + + template + pair<_InputIterator1, _InputIterator2> + __mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _BinaryPredicate __binary_pred) + { + while (__first1 != __last1 && __binary_pred(__first1, __first2)) + { + ++__first1; + ++__first2; + } + return pair<_InputIterator1, _InputIterator2>(__first1, __first2); + } + + /** + * @brief Finds the places in ranges which don't match. + * @ingroup non_mutating_algorithms + * @param __first1 An input iterator. + * @param __last1 An input iterator. + * @param __first2 An input iterator. + * @return A pair of iterators pointing to the first mismatch. + * + * This compares the elements of two ranges using @c == and returns a pair + * of iterators. The first iterator points into the first range, the + * second iterator points into the second range, and the elements pointed + * to by the iterators are not equal. + */ + template + inline pair<_InputIterator1, _InputIterator2> + mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2) + { + // concept requirements + __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>) + __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>) + __glibcxx_function_requires(_EqualOpConcept< + typename iterator_traits<_InputIterator1>::value_type, + typename iterator_traits<_InputIterator2>::value_type>) + __glibcxx_requires_valid_range(__first1, __last1); + + return _GLIBCXX_STD_A::__mismatch(__first1, __last1, __first2, + __gnu_cxx::__ops::__iter_equal_to_iter()); + } + + /** + * @brief Finds the places in ranges which don't match. + * @ingroup non_mutating_algorithms + * @param __first1 An input iterator. + * @param __last1 An input iterator. + * @param __first2 An input iterator. + * @param __binary_pred A binary predicate @link functors + * functor@endlink. + * @return A pair of iterators pointing to the first mismatch. + * + * This compares the elements of two ranges using the binary_pred + * parameter, and returns a pair + * of iterators. The first iterator points into the first range, the + * second iterator points into the second range, and the elements pointed + * to by the iterators are not equal. + */ + template + inline pair<_InputIterator1, _InputIterator2> + mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _BinaryPredicate __binary_pred) + { + // concept requirements + __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>) + __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>) + __glibcxx_requires_valid_range(__first1, __last1); + + return _GLIBCXX_STD_A::__mismatch(__first1, __last1, __first2, + __gnu_cxx::__ops::__iter_comp_iter(__binary_pred)); + } + +#if __cplusplus > 201103L + + template + pair<_InputIterator1, _InputIterator2> + __mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _BinaryPredicate __binary_pred) + { + while (__first1 != __last1 && __first2 != __last2 + && __binary_pred(__first1, __first2)) + { + ++__first1; + ++__first2; + } + return pair<_InputIterator1, _InputIterator2>(__first1, __first2); + } + + /** + * @brief Finds the places in ranges which don't match. + * @ingroup non_mutating_algorithms + * @param __first1 An input iterator. + * @param __last1 An input iterator. + * @param __first2 An input iterator. + * @param __last2 An input iterator. + * @return A pair of iterators pointing to the first mismatch. + * + * This compares the elements of two ranges using @c == and returns a pair + * of iterators. The first iterator points into the first range, the + * second iterator points into the second range, and the elements pointed + * to by the iterators are not equal. + */ + template + inline pair<_InputIterator1, _InputIterator2> + mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2) + { + // concept requirements + __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>) + __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>) + __glibcxx_function_requires(_EqualOpConcept< + typename iterator_traits<_InputIterator1>::value_type, + typename iterator_traits<_InputIterator2>::value_type>) + __glibcxx_requires_valid_range(__first1, __last1); + __glibcxx_requires_valid_range(__first2, __last2); + + return _GLIBCXX_STD_A::__mismatch(__first1, __last1, __first2, __last2, + __gnu_cxx::__ops::__iter_equal_to_iter()); + } + + /** + * @brief Finds the places in ranges which don't match. + * @ingroup non_mutating_algorithms + * @param __first1 An input iterator. + * @param __last1 An input iterator. + * @param __first2 An input iterator. + * @param __last2 An input iterator. + * @param __binary_pred A binary predicate @link functors + * functor@endlink. + * @return A pair of iterators pointing to the first mismatch. + * + * This compares the elements of two ranges using the binary_pred + * parameter, and returns a pair + * of iterators. The first iterator points into the first range, the + * second iterator points into the second range, and the elements pointed + * to by the iterators are not equal. + */ + template + inline pair<_InputIterator1, _InputIterator2> + mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _BinaryPredicate __binary_pred) + { + // concept requirements + __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>) + __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>) + __glibcxx_requires_valid_range(__first1, __last1); + __glibcxx_requires_valid_range(__first2, __last2); + + return _GLIBCXX_STD_A::__mismatch(__first1, __last1, __first2, __last2, + __gnu_cxx::__ops::__iter_comp_iter(__binary_pred)); + } +#endif + +_GLIBCXX_END_NAMESPACE_ALGO +} // namespace std + +// NB: This file is included within many other C++ includes, as a way +// of getting the base algorithms. So, make sure that parallel bits +// come in too if requested. +#ifdef _GLIBCXX_PARALLEL +# include +#endif + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stl_bvector.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stl_bvector.h new file mode 100755 index 0000000..996eb1a --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stl_bvector.h @@ -0,0 +1,1202 @@ +// vector specialization -*- C++ -*- + +// Copyright (C) 2001-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/* + * + * Copyright (c) 1994 + * Hewlett-Packard Company + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Hewlett-Packard Company makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + * + * + * Copyright (c) 1996-1999 + * Silicon Graphics Computer Systems, Inc. + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Silicon Graphics makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + */ + +/** @file bits/stl_bvector.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{vector} + */ + +#ifndef _STL_BVECTOR_H +#define _STL_BVECTOR_H 1 + +#if __cplusplus >= 201103L +#include +#endif + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_CONTAINER + + typedef unsigned long _Bit_type; + enum { _S_word_bit = int(__CHAR_BIT__ * sizeof(_Bit_type)) }; + + struct _Bit_reference + { + _Bit_type * _M_p; + _Bit_type _M_mask; + + _Bit_reference(_Bit_type * __x, _Bit_type __y) + : _M_p(__x), _M_mask(__y) { } + + _Bit_reference() _GLIBCXX_NOEXCEPT : _M_p(0), _M_mask(0) { } + + operator bool() const _GLIBCXX_NOEXCEPT + { return !!(*_M_p & _M_mask); } + + _Bit_reference& + operator=(bool __x) _GLIBCXX_NOEXCEPT + { + if (__x) + *_M_p |= _M_mask; + else + *_M_p &= ~_M_mask; + return *this; + } + + _Bit_reference& + operator=(const _Bit_reference& __x) _GLIBCXX_NOEXCEPT + { return *this = bool(__x); } + + bool + operator==(const _Bit_reference& __x) const + { return bool(*this) == bool(__x); } + + bool + operator<(const _Bit_reference& __x) const + { return !bool(*this) && bool(__x); } + + void + flip() _GLIBCXX_NOEXCEPT + { *_M_p ^= _M_mask; } + }; + +#if __cplusplus >= 201103L + inline void + swap(_Bit_reference __x, _Bit_reference __y) noexcept + { + bool __tmp = __x; + __x = __y; + __y = __tmp; + } + + inline void + swap(_Bit_reference __x, bool& __y) noexcept + { + bool __tmp = __x; + __x = __y; + __y = __tmp; + } + + inline void + swap(bool& __x, _Bit_reference __y) noexcept + { + bool __tmp = __x; + __x = __y; + __y = __tmp; + } +#endif + + struct _Bit_iterator_base + : public std::iterator + { + _Bit_type * _M_p; + unsigned int _M_offset; + + _Bit_iterator_base(_Bit_type * __x, unsigned int __y) + : _M_p(__x), _M_offset(__y) { } + + void + _M_bump_up() + { + if (_M_offset++ == int(_S_word_bit) - 1) + { + _M_offset = 0; + ++_M_p; + } + } + + void + _M_bump_down() + { + if (_M_offset-- == 0) + { + _M_offset = int(_S_word_bit) - 1; + --_M_p; + } + } + + void + _M_incr(ptrdiff_t __i) + { + difference_type __n = __i + _M_offset; + _M_p += __n / int(_S_word_bit); + __n = __n % int(_S_word_bit); + if (__n < 0) + { + __n += int(_S_word_bit); + --_M_p; + } + _M_offset = static_cast(__n); + } + + bool + operator==(const _Bit_iterator_base& __i) const + { return _M_p == __i._M_p && _M_offset == __i._M_offset; } + + bool + operator<(const _Bit_iterator_base& __i) const + { + return _M_p < __i._M_p + || (_M_p == __i._M_p && _M_offset < __i._M_offset); + } + + bool + operator!=(const _Bit_iterator_base& __i) const + { return !(*this == __i); } + + bool + operator>(const _Bit_iterator_base& __i) const + { return __i < *this; } + + bool + operator<=(const _Bit_iterator_base& __i) const + { return !(__i < *this); } + + bool + operator>=(const _Bit_iterator_base& __i) const + { return !(*this < __i); } + }; + + inline ptrdiff_t + operator-(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y) + { + return (int(_S_word_bit) * (__x._M_p - __y._M_p) + + __x._M_offset - __y._M_offset); + } + + struct _Bit_iterator : public _Bit_iterator_base + { + typedef _Bit_reference reference; + typedef _Bit_reference* pointer; + typedef _Bit_iterator iterator; + + _Bit_iterator() : _Bit_iterator_base(0, 0) { } + + _Bit_iterator(_Bit_type * __x, unsigned int __y) + : _Bit_iterator_base(__x, __y) { } + + iterator + _M_const_cast() const + { return *this; } + + reference + operator*() const + { return reference(_M_p, 1UL << _M_offset); } + + iterator& + operator++() + { + _M_bump_up(); + return *this; + } + + iterator + operator++(int) + { + iterator __tmp = *this; + _M_bump_up(); + return __tmp; + } + + iterator& + operator--() + { + _M_bump_down(); + return *this; + } + + iterator + operator--(int) + { + iterator __tmp = *this; + _M_bump_down(); + return __tmp; + } + + iterator& + operator+=(difference_type __i) + { + _M_incr(__i); + return *this; + } + + iterator& + operator-=(difference_type __i) + { + *this += -__i; + return *this; + } + + iterator + operator+(difference_type __i) const + { + iterator __tmp = *this; + return __tmp += __i; + } + + iterator + operator-(difference_type __i) const + { + iterator __tmp = *this; + return __tmp -= __i; + } + + reference + operator[](difference_type __i) const + { return *(*this + __i); } + }; + + inline _Bit_iterator + operator+(ptrdiff_t __n, const _Bit_iterator& __x) + { return __x + __n; } + + struct _Bit_const_iterator : public _Bit_iterator_base + { + typedef bool reference; + typedef bool const_reference; + typedef const bool* pointer; + typedef _Bit_const_iterator const_iterator; + + _Bit_const_iterator() : _Bit_iterator_base(0, 0) { } + + _Bit_const_iterator(_Bit_type * __x, unsigned int __y) + : _Bit_iterator_base(__x, __y) { } + + _Bit_const_iterator(const _Bit_iterator& __x) + : _Bit_iterator_base(__x._M_p, __x._M_offset) { } + + _Bit_iterator + _M_const_cast() const + { return _Bit_iterator(_M_p, _M_offset); } + + const_reference + operator*() const + { return _Bit_reference(_M_p, 1UL << _M_offset); } + + const_iterator& + operator++() + { + _M_bump_up(); + return *this; + } + + const_iterator + operator++(int) + { + const_iterator __tmp = *this; + _M_bump_up(); + return __tmp; + } + + const_iterator& + operator--() + { + _M_bump_down(); + return *this; + } + + const_iterator + operator--(int) + { + const_iterator __tmp = *this; + _M_bump_down(); + return __tmp; + } + + const_iterator& + operator+=(difference_type __i) + { + _M_incr(__i); + return *this; + } + + const_iterator& + operator-=(difference_type __i) + { + *this += -__i; + return *this; + } + + const_iterator + operator+(difference_type __i) const + { + const_iterator __tmp = *this; + return __tmp += __i; + } + + const_iterator + operator-(difference_type __i) const + { + const_iterator __tmp = *this; + return __tmp -= __i; + } + + const_reference + operator[](difference_type __i) const + { return *(*this + __i); } + }; + + inline _Bit_const_iterator + operator+(ptrdiff_t __n, const _Bit_const_iterator& __x) + { return __x + __n; } + + inline void + __fill_bvector(_Bit_iterator __first, _Bit_iterator __last, bool __x) + { + for (; __first != __last; ++__first) + *__first = __x; + } + + inline void + fill(_Bit_iterator __first, _Bit_iterator __last, const bool& __x) + { + if (__first._M_p != __last._M_p) + { + std::fill(__first._M_p + 1, __last._M_p, __x ? ~0 : 0); + __fill_bvector(__first, _Bit_iterator(__first._M_p + 1, 0), __x); + __fill_bvector(_Bit_iterator(__last._M_p, 0), __last, __x); + } + else + __fill_bvector(__first, __last, __x); + } + + template + struct _Bvector_base + { + typedef typename _Alloc::template rebind<_Bit_type>::other + _Bit_alloc_type; + + struct _Bvector_impl + : public _Bit_alloc_type + { + _Bit_iterator _M_start; + _Bit_iterator _M_finish; + _Bit_type* _M_end_of_storage; + + _Bvector_impl() + : _Bit_alloc_type(), _M_start(), _M_finish(), _M_end_of_storage(0) + { } + + _Bvector_impl(const _Bit_alloc_type& __a) + : _Bit_alloc_type(__a), _M_start(), _M_finish(), _M_end_of_storage(0) + { } + +#if __cplusplus >= 201103L + _Bvector_impl(_Bit_alloc_type&& __a) + : _Bit_alloc_type(std::move(__a)), _M_start(), _M_finish(), + _M_end_of_storage(0) + { } +#endif + }; + + public: + typedef _Alloc allocator_type; + + _Bit_alloc_type& + _M_get_Bit_allocator() _GLIBCXX_NOEXCEPT + { return *static_cast<_Bit_alloc_type*>(&this->_M_impl); } + + const _Bit_alloc_type& + _M_get_Bit_allocator() const _GLIBCXX_NOEXCEPT + { return *static_cast(&this->_M_impl); } + + allocator_type + get_allocator() const _GLIBCXX_NOEXCEPT + { return allocator_type(_M_get_Bit_allocator()); } + + _Bvector_base() + : _M_impl() { } + + _Bvector_base(const allocator_type& __a) + : _M_impl(__a) { } + +#if __cplusplus >= 201103L + _Bvector_base(_Bvector_base&& __x) noexcept + : _M_impl(std::move(__x._M_get_Bit_allocator())) + { + this->_M_impl._M_start = __x._M_impl._M_start; + this->_M_impl._M_finish = __x._M_impl._M_finish; + this->_M_impl._M_end_of_storage = __x._M_impl._M_end_of_storage; + __x._M_impl._M_start = _Bit_iterator(); + __x._M_impl._M_finish = _Bit_iterator(); + __x._M_impl._M_end_of_storage = 0; + } +#endif + + ~_Bvector_base() + { this->_M_deallocate(); } + + protected: + _Bvector_impl _M_impl; + + _Bit_type* + _M_allocate(size_t __n) + { return _M_impl.allocate(_S_nword(__n)); } + + void + _M_deallocate() + { + if (_M_impl._M_start._M_p) + _M_impl.deallocate(_M_impl._M_start._M_p, + _M_impl._M_end_of_storage - _M_impl._M_start._M_p); + } + + static size_t + _S_nword(size_t __n) + { return (__n + int(_S_word_bit) - 1) / int(_S_word_bit); } + }; + +_GLIBCXX_END_NAMESPACE_CONTAINER +} // namespace std + +// Declare a partial specialization of vector. +#include + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_CONTAINER + + /** + * @brief A specialization of vector for booleans which offers fixed time + * access to individual elements in any order. + * + * @ingroup sequences + * + * @tparam _Alloc Allocator type. + * + * Note that vector does not actually meet the requirements for being + * a container. This is because the reference and pointer types are not + * really references and pointers to bool. See DR96 for details. @see + * vector for function documentation. + * + * In some terminology a %vector can be described as a dynamic + * C-style array, it offers fast and efficient access to individual + * elements in any order and saves the user from worrying about + * memory and size allocation. Subscripting ( @c [] ) access is + * also provided as with C-style arrays. + */ +template + class vector : protected _Bvector_base<_Alloc> + { + typedef _Bvector_base<_Alloc> _Base; + +#if __cplusplus >= 201103L + template friend struct hash; +#endif + + public: + typedef bool value_type; + typedef size_t size_type; + typedef ptrdiff_t difference_type; + typedef _Bit_reference reference; + typedef bool const_reference; + typedef _Bit_reference* pointer; + typedef const bool* const_pointer; + typedef _Bit_iterator iterator; + typedef _Bit_const_iterator const_iterator; + typedef std::reverse_iterator const_reverse_iterator; + typedef std::reverse_iterator reverse_iterator; + typedef _Alloc allocator_type; + + allocator_type get_allocator() const + { return _Base::get_allocator(); } + + protected: + using _Base::_M_allocate; + using _Base::_M_deallocate; + using _Base::_S_nword; + using _Base::_M_get_Bit_allocator; + + public: + vector() + : _Base() { } + + explicit + vector(const allocator_type& __a) + : _Base(__a) { } + +#if __cplusplus >= 201103L + explicit + vector(size_type __n, const allocator_type& __a = allocator_type()) + : vector(__n, false, __a) + { } + + vector(size_type __n, const bool& __value, + const allocator_type& __a = allocator_type()) + : _Base(__a) + { + _M_initialize(__n); + std::fill(this->_M_impl._M_start._M_p, this->_M_impl._M_end_of_storage, + __value ? ~0 : 0); + } +#else + explicit + vector(size_type __n, const bool& __value = bool(), + const allocator_type& __a = allocator_type()) + : _Base(__a) + { + _M_initialize(__n); + std::fill(this->_M_impl._M_start._M_p, this->_M_impl._M_end_of_storage, + __value ? ~0 : 0); + } +#endif + + vector(const vector& __x) + : _Base(__x._M_get_Bit_allocator()) + { + _M_initialize(__x.size()); + _M_copy_aligned(__x.begin(), __x.end(), this->_M_impl._M_start); + } + +#if __cplusplus >= 201103L + vector(vector&& __x) noexcept + : _Base(std::move(__x)) { } + + vector(initializer_list __l, + const allocator_type& __a = allocator_type()) + : _Base(__a) + { + _M_initialize_range(__l.begin(), __l.end(), + random_access_iterator_tag()); + } +#endif + +#if __cplusplus >= 201103L + template> + vector(_InputIterator __first, _InputIterator __last, + const allocator_type& __a = allocator_type()) + : _Base(__a) + { _M_initialize_dispatch(__first, __last, __false_type()); } +#else + template + vector(_InputIterator __first, _InputIterator __last, + const allocator_type& __a = allocator_type()) + : _Base(__a) + { + typedef typename std::__is_integer<_InputIterator>::__type _Integral; + _M_initialize_dispatch(__first, __last, _Integral()); + } +#endif + + ~vector() _GLIBCXX_NOEXCEPT { } + + vector& + operator=(const vector& __x) + { + if (&__x == this) + return *this; + if (__x.size() > capacity()) + { + this->_M_deallocate(); + _M_initialize(__x.size()); + } + this->_M_impl._M_finish = _M_copy_aligned(__x.begin(), __x.end(), + begin()); + return *this; + } + +#if __cplusplus >= 201103L + vector& + operator=(vector&& __x) + { + // NB: DR 1204. + // NB: DR 675. + this->clear(); + this->swap(__x); + return *this; + } + + vector& + operator=(initializer_list __l) + { + this->assign (__l.begin(), __l.end()); + return *this; + } +#endif + + // assign(), a generalized assignment member function. Two + // versions: one that takes a count, and one that takes a range. + // The range version is a member template, so we dispatch on whether + // or not the type is an integer. + void + assign(size_type __n, const bool& __x) + { _M_fill_assign(__n, __x); } + +#if __cplusplus >= 201103L + template> + void + assign(_InputIterator __first, _InputIterator __last) + { _M_assign_dispatch(__first, __last, __false_type()); } +#else + template + void + assign(_InputIterator __first, _InputIterator __last) + { + typedef typename std::__is_integer<_InputIterator>::__type _Integral; + _M_assign_dispatch(__first, __last, _Integral()); + } +#endif + +#if __cplusplus >= 201103L + void + assign(initializer_list __l) + { this->assign(__l.begin(), __l.end()); } +#endif + + iterator + begin() _GLIBCXX_NOEXCEPT + { return this->_M_impl._M_start; } + + const_iterator + begin() const _GLIBCXX_NOEXCEPT + { return this->_M_impl._M_start; } + + iterator + end() _GLIBCXX_NOEXCEPT + { return this->_M_impl._M_finish; } + + const_iterator + end() const _GLIBCXX_NOEXCEPT + { return this->_M_impl._M_finish; } + + reverse_iterator + rbegin() _GLIBCXX_NOEXCEPT + { return reverse_iterator(end()); } + + const_reverse_iterator + rbegin() const _GLIBCXX_NOEXCEPT + { return const_reverse_iterator(end()); } + + reverse_iterator + rend() _GLIBCXX_NOEXCEPT + { return reverse_iterator(begin()); } + + const_reverse_iterator + rend() const _GLIBCXX_NOEXCEPT + { return const_reverse_iterator(begin()); } + +#if __cplusplus >= 201103L + const_iterator + cbegin() const noexcept + { return this->_M_impl._M_start; } + + const_iterator + cend() const noexcept + { return this->_M_impl._M_finish; } + + const_reverse_iterator + crbegin() const noexcept + { return const_reverse_iterator(end()); } + + const_reverse_iterator + crend() const noexcept + { return const_reverse_iterator(begin()); } +#endif + + size_type + size() const _GLIBCXX_NOEXCEPT + { return size_type(end() - begin()); } + + size_type + max_size() const _GLIBCXX_NOEXCEPT + { + const size_type __isize = + __gnu_cxx::__numeric_traits::__max + - int(_S_word_bit) + 1; + const size_type __asize = _M_get_Bit_allocator().max_size(); + return (__asize <= __isize / int(_S_word_bit) + ? __asize * int(_S_word_bit) : __isize); + } + + size_type + capacity() const _GLIBCXX_NOEXCEPT + { return size_type(const_iterator(this->_M_impl._M_end_of_storage, 0) + - begin()); } + + bool + empty() const _GLIBCXX_NOEXCEPT + { return begin() == end(); } + + reference + operator[](size_type __n) + { + return *iterator(this->_M_impl._M_start._M_p + + __n / int(_S_word_bit), __n % int(_S_word_bit)); + } + + const_reference + operator[](size_type __n) const + { + return *const_iterator(this->_M_impl._M_start._M_p + + __n / int(_S_word_bit), __n % int(_S_word_bit)); + } + + protected: + void + _M_range_check(size_type __n) const + { + if (__n >= this->size()) + __throw_out_of_range_fmt(__N("vector::_M_range_check: __n " + "(which is %zu) >= this->size() " + "(which is %zu)"), + __n, this->size()); + } + + public: + reference + at(size_type __n) + { _M_range_check(__n); return (*this)[__n]; } + + const_reference + at(size_type __n) const + { _M_range_check(__n); return (*this)[__n]; } + + void + reserve(size_type __n) + { + if (__n > max_size()) + __throw_length_error(__N("vector::reserve")); + if (capacity() < __n) + _M_reallocate(__n); + } + + reference + front() + { return *begin(); } + + const_reference + front() const + { return *begin(); } + + reference + back() + { return *(end() - 1); } + + const_reference + back() const + { return *(end() - 1); } + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR 464. Suggestion for new member functions in standard containers. + // N.B. DR 464 says nothing about vector but we need something + // here due to the way we are implementing DR 464 in the debug-mode + // vector class. + void + data() _GLIBCXX_NOEXCEPT { } + + void + push_back(bool __x) + { + if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_of_storage) + *this->_M_impl._M_finish++ = __x; + else + _M_insert_aux(end(), __x); + } + + void + swap(vector& __x) + { + std::swap(this->_M_impl._M_start, __x._M_impl._M_start); + std::swap(this->_M_impl._M_finish, __x._M_impl._M_finish); + std::swap(this->_M_impl._M_end_of_storage, + __x._M_impl._M_end_of_storage); + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 431. Swapping containers with unequal allocators. + std::__alloc_swap:: + _S_do_it(_M_get_Bit_allocator(), __x._M_get_Bit_allocator()); + } + + // [23.2.5]/1, third-to-last entry in synopsis listing + static void + swap(reference __x, reference __y) _GLIBCXX_NOEXCEPT + { + bool __tmp = __x; + __x = __y; + __y = __tmp; + } + + iterator +#if __cplusplus >= 201103L + insert(const_iterator __position, const bool& __x = bool()) +#else + insert(iterator __position, const bool& __x = bool()) +#endif + { + const difference_type __n = __position - begin(); + if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_of_storage + && __position == end()) + *this->_M_impl._M_finish++ = __x; + else + _M_insert_aux(__position._M_const_cast(), __x); + return begin() + __n; + } + +#if __cplusplus >= 201103L + template> + iterator + insert(const_iterator __position, + _InputIterator __first, _InputIterator __last) + { + difference_type __offset = __position - cbegin(); + _M_insert_dispatch(__position._M_const_cast(), + __first, __last, __false_type()); + return begin() + __offset; + } +#else + template + void + insert(iterator __position, + _InputIterator __first, _InputIterator __last) + { + typedef typename std::__is_integer<_InputIterator>::__type _Integral; + _M_insert_dispatch(__position, __first, __last, _Integral()); + } +#endif + +#if __cplusplus >= 201103L + iterator + insert(const_iterator __position, size_type __n, const bool& __x) + { + difference_type __offset = __position - cbegin(); + _M_fill_insert(__position._M_const_cast(), __n, __x); + return begin() + __offset; + } +#else + void + insert(iterator __position, size_type __n, const bool& __x) + { _M_fill_insert(__position, __n, __x); } +#endif + +#if __cplusplus >= 201103L + iterator + insert(const_iterator __p, initializer_list __l) + { return this->insert(__p, __l.begin(), __l.end()); } +#endif + + void + pop_back() + { --this->_M_impl._M_finish; } + + iterator +#if __cplusplus >= 201103L + erase(const_iterator __position) +#else + erase(iterator __position) +#endif + { return _M_erase(__position._M_const_cast()); } + + iterator +#if __cplusplus >= 201103L + erase(const_iterator __first, const_iterator __last) +#else + erase(iterator __first, iterator __last) +#endif + { return _M_erase(__first._M_const_cast(), __last._M_const_cast()); } + + void + resize(size_type __new_size, bool __x = bool()) + { + if (__new_size < size()) + _M_erase_at_end(begin() + difference_type(__new_size)); + else + insert(end(), __new_size - size(), __x); + } + +#if __cplusplus >= 201103L + void + shrink_to_fit() + { _M_shrink_to_fit(); } +#endif + + void + flip() _GLIBCXX_NOEXCEPT + { + for (_Bit_type * __p = this->_M_impl._M_start._M_p; + __p != this->_M_impl._M_end_of_storage; ++__p) + *__p = ~*__p; + } + + void + clear() _GLIBCXX_NOEXCEPT + { _M_erase_at_end(begin()); } + +#if __cplusplus >= 201103L + template + void + emplace_back(_Args&&... __args) + { push_back(bool(__args...)); } + + template + iterator + emplace(const_iterator __pos, _Args&&... __args) + { return insert(__pos, bool(__args...)); } +#endif + + protected: + // Precondition: __first._M_offset == 0 && __result._M_offset == 0. + iterator + _M_copy_aligned(const_iterator __first, const_iterator __last, + iterator __result) + { + _Bit_type* __q = std::copy(__first._M_p, __last._M_p, __result._M_p); + return std::copy(const_iterator(__last._M_p, 0), __last, + iterator(__q, 0)); + } + + void + _M_initialize(size_type __n) + { + _Bit_type* __q = this->_M_allocate(__n); + this->_M_impl._M_end_of_storage = __q + _S_nword(__n); + this->_M_impl._M_start = iterator(__q, 0); + this->_M_impl._M_finish = this->_M_impl._M_start + difference_type(__n); + } + + void + _M_reallocate(size_type __n); + +#if __cplusplus >= 201103L + bool + _M_shrink_to_fit(); +#endif + + // Check whether it's an integral type. If so, it's not an iterator. + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 438. Ambiguity in the "do the right thing" clause + template + void + _M_initialize_dispatch(_Integer __n, _Integer __x, __true_type) + { + _M_initialize(static_cast(__n)); + std::fill(this->_M_impl._M_start._M_p, + this->_M_impl._M_end_of_storage, __x ? ~0 : 0); + } + + template + void + _M_initialize_dispatch(_InputIterator __first, _InputIterator __last, + __false_type) + { _M_initialize_range(__first, __last, + std::__iterator_category(__first)); } + + template + void + _M_initialize_range(_InputIterator __first, _InputIterator __last, + std::input_iterator_tag) + { + for (; __first != __last; ++__first) + push_back(*__first); + } + + template + void + _M_initialize_range(_ForwardIterator __first, _ForwardIterator __last, + std::forward_iterator_tag) + { + const size_type __n = std::distance(__first, __last); + _M_initialize(__n); + std::copy(__first, __last, this->_M_impl._M_start); + } + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 438. Ambiguity in the "do the right thing" clause + template + void + _M_assign_dispatch(_Integer __n, _Integer __val, __true_type) + { _M_fill_assign(__n, __val); } + + template + void + _M_assign_dispatch(_InputIterator __first, _InputIterator __last, + __false_type) + { _M_assign_aux(__first, __last, std::__iterator_category(__first)); } + + void + _M_fill_assign(size_t __n, bool __x) + { + if (__n > size()) + { + std::fill(this->_M_impl._M_start._M_p, + this->_M_impl._M_end_of_storage, __x ? ~0 : 0); + insert(end(), __n - size(), __x); + } + else + { + _M_erase_at_end(begin() + __n); + std::fill(this->_M_impl._M_start._M_p, + this->_M_impl._M_end_of_storage, __x ? ~0 : 0); + } + } + + template + void + _M_assign_aux(_InputIterator __first, _InputIterator __last, + std::input_iterator_tag) + { + iterator __cur = begin(); + for (; __first != __last && __cur != end(); ++__cur, ++__first) + *__cur = *__first; + if (__first == __last) + _M_erase_at_end(__cur); + else + insert(end(), __first, __last); + } + + template + void + _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last, + std::forward_iterator_tag) + { + const size_type __len = std::distance(__first, __last); + if (__len < size()) + _M_erase_at_end(std::copy(__first, __last, begin())); + else + { + _ForwardIterator __mid = __first; + std::advance(__mid, size()); + std::copy(__first, __mid, begin()); + insert(end(), __mid, __last); + } + } + + // Check whether it's an integral type. If so, it's not an iterator. + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 438. Ambiguity in the "do the right thing" clause + template + void + _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __x, + __true_type) + { _M_fill_insert(__pos, __n, __x); } + + template + void + _M_insert_dispatch(iterator __pos, + _InputIterator __first, _InputIterator __last, + __false_type) + { _M_insert_range(__pos, __first, __last, + std::__iterator_category(__first)); } + + void + _M_fill_insert(iterator __position, size_type __n, bool __x); + + template + void + _M_insert_range(iterator __pos, _InputIterator __first, + _InputIterator __last, std::input_iterator_tag) + { + for (; __first != __last; ++__first) + { + __pos = insert(__pos, *__first); + ++__pos; + } + } + + template + void + _M_insert_range(iterator __position, _ForwardIterator __first, + _ForwardIterator __last, std::forward_iterator_tag); + + void + _M_insert_aux(iterator __position, bool __x); + + size_type + _M_check_len(size_type __n, const char* __s) const + { + if (max_size() - size() < __n) + __throw_length_error(__N(__s)); + + const size_type __len = size() + std::max(size(), __n); + return (__len < size() || __len > max_size()) ? max_size() : __len; + } + + void + _M_erase_at_end(iterator __pos) + { this->_M_impl._M_finish = __pos; } + + iterator + _M_erase(iterator __pos); + + iterator + _M_erase(iterator __first, iterator __last); + }; + +_GLIBCXX_END_NAMESPACE_CONTAINER +} // namespace std + +#if __cplusplus >= 201103L + +#include + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + // DR 1182. + /// std::hash specialization for vector. + template + struct hash<_GLIBCXX_STD_C::vector> + : public __hash_base> + { + size_t + operator()(const _GLIBCXX_STD_C::vector&) const noexcept; + }; + +_GLIBCXX_END_NAMESPACE_VERSION +}// namespace std + +#endif // C++11 + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stl_construct.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stl_construct.h new file mode 100755 index 0000000..df245c7 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stl_construct.h @@ -0,0 +1,158 @@ +// nonstandard construct and destroy functions -*- C++ -*- + +// Copyright (C) 2001-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/* + * + * Copyright (c) 1994 + * Hewlett-Packard Company + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Hewlett-Packard Company makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + * + * + * Copyright (c) 1996,1997 + * Silicon Graphics Computer Systems, Inc. + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Silicon Graphics makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + */ + +/** @file bits/stl_construct.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{memory} + */ + +#ifndef _STL_CONSTRUCT_H +#define _STL_CONSTRUCT_H 1 + +#include +#include +#include + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /** + * Constructs an object in existing memory by invoking an allocated + * object's constructor with an initializer. + */ +#if __cplusplus >= 201103L + template + inline void + _Construct(_T1* __p, _Args&&... __args) + { ::new(static_cast(__p)) _T1(std::forward<_Args>(__args)...); } +#else + template + inline void + _Construct(_T1* __p, const _T2& __value) + { + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 402. wrong new expression in [some_]allocator::construct + ::new(static_cast(__p)) _T1(__value); + } +#endif + + /** + * Destroy the object pointed to by a pointer type. + */ + template + inline void + _Destroy(_Tp* __pointer) + { __pointer->~_Tp(); } + + template + struct _Destroy_aux + { + template + static void + __destroy(_ForwardIterator __first, _ForwardIterator __last) + { + for (; __first != __last; ++__first) + std::_Destroy(std::__addressof(*__first)); + } + }; + + template<> + struct _Destroy_aux + { + template + static void + __destroy(_ForwardIterator, _ForwardIterator) { } + }; + + /** + * Destroy a range of objects. If the value_type of the object has + * a trivial destructor, the compiler should optimize all of this + * away, otherwise the objects' destructors must be invoked. + */ + template + inline void + _Destroy(_ForwardIterator __first, _ForwardIterator __last) + { + typedef typename iterator_traits<_ForwardIterator>::value_type + _Value_type; + std::_Destroy_aux<__has_trivial_destructor(_Value_type)>:: + __destroy(__first, __last); + } + + /** + * Destroy a range of objects using the supplied allocator. For + * nondefault allocators we do not optimize away invocation of + * destroy() even if _Tp has a trivial destructor. + */ + + template + void + _Destroy(_ForwardIterator __first, _ForwardIterator __last, + _Allocator& __alloc) + { + typedef __gnu_cxx::__alloc_traits<_Allocator> __traits; + for (; __first != __last; ++__first) + __traits::destroy(__alloc, std::__addressof(*__first)); + } + + template + inline void + _Destroy(_ForwardIterator __first, _ForwardIterator __last, + allocator<_Tp>&) + { + _Destroy(__first, __last); + } + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace std + +#endif /* _STL_CONSTRUCT_H */ + diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stl_deque.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stl_deque.h new file mode 100755 index 0000000..add8742 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stl_deque.h @@ -0,0 +1,2091 @@ +// Deque implementation -*- C++ -*- + +// Copyright (C) 2001-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/* + * + * Copyright (c) 1994 + * Hewlett-Packard Company + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Hewlett-Packard Company makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + * + * + * Copyright (c) 1997 + * Silicon Graphics Computer Systems, Inc. + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Silicon Graphics makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + */ + +/** @file bits/stl_deque.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{deque} + */ + +#ifndef _STL_DEQUE_H +#define _STL_DEQUE_H 1 + +#include +#include +#include +#if __cplusplus >= 201103L +#include +#endif + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_CONTAINER + + /** + * @brief This function controls the size of memory nodes. + * @param __size The size of an element. + * @return The number (not byte size) of elements per node. + * + * This function started off as a compiler kludge from SGI, but + * seems to be a useful wrapper around a repeated constant + * expression. The @b 512 is tunable (and no other code needs to + * change), but no investigation has been done since inheriting the + * SGI code. Touch _GLIBCXX_DEQUE_BUF_SIZE only if you know what + * you are doing, however: changing it breaks the binary + * compatibility!! + */ + +#ifndef _GLIBCXX_DEQUE_BUF_SIZE +#define _GLIBCXX_DEQUE_BUF_SIZE 512 +#endif + + inline size_t + __deque_buf_size(size_t __size) + { return (__size < _GLIBCXX_DEQUE_BUF_SIZE + ? size_t(_GLIBCXX_DEQUE_BUF_SIZE / __size) : size_t(1)); } + + + /** + * @brief A deque::iterator. + * + * Quite a bit of intelligence here. Much of the functionality of + * deque is actually passed off to this class. A deque holds two + * of these internally, marking its valid range. Access to + * elements is done as offsets of either of those two, relying on + * operator overloading in this class. + * + * All the functions are op overloads except for _M_set_node. + */ + template + struct _Deque_iterator + { + typedef _Deque_iterator<_Tp, _Tp&, _Tp*> iterator; + typedef _Deque_iterator<_Tp, const _Tp&, const _Tp*> const_iterator; + + static size_t _S_buffer_size() _GLIBCXX_NOEXCEPT + { return __deque_buf_size(sizeof(_Tp)); } + + typedef std::random_access_iterator_tag iterator_category; + typedef _Tp value_type; + typedef _Ptr pointer; + typedef _Ref reference; + typedef size_t size_type; + typedef ptrdiff_t difference_type; + typedef _Tp** _Map_pointer; + typedef _Deque_iterator _Self; + + _Tp* _M_cur; + _Tp* _M_first; + _Tp* _M_last; + _Map_pointer _M_node; + + _Deque_iterator(_Tp* __x, _Map_pointer __y) _GLIBCXX_NOEXCEPT + : _M_cur(__x), _M_first(*__y), + _M_last(*__y + _S_buffer_size()), _M_node(__y) { } + + _Deque_iterator() _GLIBCXX_NOEXCEPT + : _M_cur(0), _M_first(0), _M_last(0), _M_node(0) { } + + _Deque_iterator(const iterator& __x) _GLIBCXX_NOEXCEPT + : _M_cur(__x._M_cur), _M_first(__x._M_first), + _M_last(__x._M_last), _M_node(__x._M_node) { } + + iterator + _M_const_cast() const _GLIBCXX_NOEXCEPT + { return iterator(_M_cur, _M_node); } + + reference + operator*() const _GLIBCXX_NOEXCEPT + { return *_M_cur; } + + pointer + operator->() const _GLIBCXX_NOEXCEPT + { return _M_cur; } + + _Self& + operator++() _GLIBCXX_NOEXCEPT + { + ++_M_cur; + if (_M_cur == _M_last) + { + _M_set_node(_M_node + 1); + _M_cur = _M_first; + } + return *this; + } + + _Self + operator++(int) _GLIBCXX_NOEXCEPT + { + _Self __tmp = *this; + ++*this; + return __tmp; + } + + _Self& + operator--() _GLIBCXX_NOEXCEPT + { + if (_M_cur == _M_first) + { + _M_set_node(_M_node - 1); + _M_cur = _M_last; + } + --_M_cur; + return *this; + } + + _Self + operator--(int) _GLIBCXX_NOEXCEPT + { + _Self __tmp = *this; + --*this; + return __tmp; + } + + _Self& + operator+=(difference_type __n) _GLIBCXX_NOEXCEPT + { + const difference_type __offset = __n + (_M_cur - _M_first); + if (__offset >= 0 && __offset < difference_type(_S_buffer_size())) + _M_cur += __n; + else + { + const difference_type __node_offset = + __offset > 0 ? __offset / difference_type(_S_buffer_size()) + : -difference_type((-__offset - 1) + / _S_buffer_size()) - 1; + _M_set_node(_M_node + __node_offset); + _M_cur = _M_first + (__offset - __node_offset + * difference_type(_S_buffer_size())); + } + return *this; + } + + _Self + operator+(difference_type __n) const _GLIBCXX_NOEXCEPT + { + _Self __tmp = *this; + return __tmp += __n; + } + + _Self& + operator-=(difference_type __n) _GLIBCXX_NOEXCEPT + { return *this += -__n; } + + _Self + operator-(difference_type __n) const _GLIBCXX_NOEXCEPT + { + _Self __tmp = *this; + return __tmp -= __n; + } + + reference + operator[](difference_type __n) const _GLIBCXX_NOEXCEPT + { return *(*this + __n); } + + /** + * Prepares to traverse new_node. Sets everything except + * _M_cur, which should therefore be set by the caller + * immediately afterwards, based on _M_first and _M_last. + */ + void + _M_set_node(_Map_pointer __new_node) _GLIBCXX_NOEXCEPT + { + _M_node = __new_node; + _M_first = *__new_node; + _M_last = _M_first + difference_type(_S_buffer_size()); + } + }; + + // Note: we also provide overloads whose operands are of the same type in + // order to avoid ambiguous overload resolution when std::rel_ops operators + // are in scope (for additional details, see libstdc++/3628) + template + inline bool + operator==(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x, + const _Deque_iterator<_Tp, _Ref, _Ptr>& __y) _GLIBCXX_NOEXCEPT + { return __x._M_cur == __y._M_cur; } + + template + inline bool + operator==(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x, + const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) _GLIBCXX_NOEXCEPT + { return __x._M_cur == __y._M_cur; } + + template + inline bool + operator!=(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x, + const _Deque_iterator<_Tp, _Ref, _Ptr>& __y) _GLIBCXX_NOEXCEPT + { return !(__x == __y); } + + template + inline bool + operator!=(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x, + const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) _GLIBCXX_NOEXCEPT + { return !(__x == __y); } + + template + inline bool + operator<(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x, + const _Deque_iterator<_Tp, _Ref, _Ptr>& __y) _GLIBCXX_NOEXCEPT + { return (__x._M_node == __y._M_node) ? (__x._M_cur < __y._M_cur) + : (__x._M_node < __y._M_node); } + + template + inline bool + operator<(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x, + const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) _GLIBCXX_NOEXCEPT + { return (__x._M_node == __y._M_node) ? (__x._M_cur < __y._M_cur) + : (__x._M_node < __y._M_node); } + + template + inline bool + operator>(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x, + const _Deque_iterator<_Tp, _Ref, _Ptr>& __y) _GLIBCXX_NOEXCEPT + { return __y < __x; } + + template + inline bool + operator>(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x, + const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) _GLIBCXX_NOEXCEPT + { return __y < __x; } + + template + inline bool + operator<=(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x, + const _Deque_iterator<_Tp, _Ref, _Ptr>& __y) _GLIBCXX_NOEXCEPT + { return !(__y < __x); } + + template + inline bool + operator<=(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x, + const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) _GLIBCXX_NOEXCEPT + { return !(__y < __x); } + + template + inline bool + operator>=(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x, + const _Deque_iterator<_Tp, _Ref, _Ptr>& __y) _GLIBCXX_NOEXCEPT + { return !(__x < __y); } + + template + inline bool + operator>=(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x, + const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) _GLIBCXX_NOEXCEPT + { return !(__x < __y); } + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // According to the resolution of DR179 not only the various comparison + // operators but also operator- must accept mixed iterator/const_iterator + // parameters. + template + inline typename _Deque_iterator<_Tp, _Ref, _Ptr>::difference_type + operator-(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x, + const _Deque_iterator<_Tp, _Ref, _Ptr>& __y) _GLIBCXX_NOEXCEPT + { + return typename _Deque_iterator<_Tp, _Ref, _Ptr>::difference_type + (_Deque_iterator<_Tp, _Ref, _Ptr>::_S_buffer_size()) + * (__x._M_node - __y._M_node - 1) + (__x._M_cur - __x._M_first) + + (__y._M_last - __y._M_cur); + } + + template + inline typename _Deque_iterator<_Tp, _RefL, _PtrL>::difference_type + operator-(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x, + const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) _GLIBCXX_NOEXCEPT + { + return typename _Deque_iterator<_Tp, _RefL, _PtrL>::difference_type + (_Deque_iterator<_Tp, _RefL, _PtrL>::_S_buffer_size()) + * (__x._M_node - __y._M_node - 1) + (__x._M_cur - __x._M_first) + + (__y._M_last - __y._M_cur); + } + + template + inline _Deque_iterator<_Tp, _Ref, _Ptr> + operator+(ptrdiff_t __n, const _Deque_iterator<_Tp, _Ref, _Ptr>& __x) + _GLIBCXX_NOEXCEPT + { return __x + __n; } + + template + void + fill(const _Deque_iterator<_Tp, _Tp&, _Tp*>&, + const _Deque_iterator<_Tp, _Tp&, _Tp*>&, const _Tp&); + + template + _Deque_iterator<_Tp, _Tp&, _Tp*> + copy(_Deque_iterator<_Tp, const _Tp&, const _Tp*>, + _Deque_iterator<_Tp, const _Tp&, const _Tp*>, + _Deque_iterator<_Tp, _Tp&, _Tp*>); + + template + inline _Deque_iterator<_Tp, _Tp&, _Tp*> + copy(_Deque_iterator<_Tp, _Tp&, _Tp*> __first, + _Deque_iterator<_Tp, _Tp&, _Tp*> __last, + _Deque_iterator<_Tp, _Tp&, _Tp*> __result) + { return std::copy(_Deque_iterator<_Tp, const _Tp&, const _Tp*>(__first), + _Deque_iterator<_Tp, const _Tp&, const _Tp*>(__last), + __result); } + + template + _Deque_iterator<_Tp, _Tp&, _Tp*> + copy_backward(_Deque_iterator<_Tp, const _Tp&, const _Tp*>, + _Deque_iterator<_Tp, const _Tp&, const _Tp*>, + _Deque_iterator<_Tp, _Tp&, _Tp*>); + + template + inline _Deque_iterator<_Tp, _Tp&, _Tp*> + copy_backward(_Deque_iterator<_Tp, _Tp&, _Tp*> __first, + _Deque_iterator<_Tp, _Tp&, _Tp*> __last, + _Deque_iterator<_Tp, _Tp&, _Tp*> __result) + { return std::copy_backward(_Deque_iterator<_Tp, + const _Tp&, const _Tp*>(__first), + _Deque_iterator<_Tp, + const _Tp&, const _Tp*>(__last), + __result); } + +#if __cplusplus >= 201103L + template + _Deque_iterator<_Tp, _Tp&, _Tp*> + move(_Deque_iterator<_Tp, const _Tp&, const _Tp*>, + _Deque_iterator<_Tp, const _Tp&, const _Tp*>, + _Deque_iterator<_Tp, _Tp&, _Tp*>); + + template + inline _Deque_iterator<_Tp, _Tp&, _Tp*> + move(_Deque_iterator<_Tp, _Tp&, _Tp*> __first, + _Deque_iterator<_Tp, _Tp&, _Tp*> __last, + _Deque_iterator<_Tp, _Tp&, _Tp*> __result) + { return std::move(_Deque_iterator<_Tp, const _Tp&, const _Tp*>(__first), + _Deque_iterator<_Tp, const _Tp&, const _Tp*>(__last), + __result); } + + template + _Deque_iterator<_Tp, _Tp&, _Tp*> + move_backward(_Deque_iterator<_Tp, const _Tp&, const _Tp*>, + _Deque_iterator<_Tp, const _Tp&, const _Tp*>, + _Deque_iterator<_Tp, _Tp&, _Tp*>); + + template + inline _Deque_iterator<_Tp, _Tp&, _Tp*> + move_backward(_Deque_iterator<_Tp, _Tp&, _Tp*> __first, + _Deque_iterator<_Tp, _Tp&, _Tp*> __last, + _Deque_iterator<_Tp, _Tp&, _Tp*> __result) + { return std::move_backward(_Deque_iterator<_Tp, + const _Tp&, const _Tp*>(__first), + _Deque_iterator<_Tp, + const _Tp&, const _Tp*>(__last), + __result); } +#endif + + /** + * Deque base class. This class provides the unified face for %deque's + * allocation. This class's constructor and destructor allocate and + * deallocate (but do not initialize) storage. This makes %exception + * safety easier. + * + * Nothing in this class ever constructs or destroys an actual Tp element. + * (Deque handles that itself.) Only/All memory management is performed + * here. + */ + template + class _Deque_base + { + public: + typedef _Alloc allocator_type; + + allocator_type + get_allocator() const _GLIBCXX_NOEXCEPT + { return allocator_type(_M_get_Tp_allocator()); } + + typedef _Deque_iterator<_Tp, _Tp&, _Tp*> iterator; + typedef _Deque_iterator<_Tp, const _Tp&, const _Tp*> const_iterator; + + _Deque_base() + : _M_impl() + { _M_initialize_map(0); } + + _Deque_base(size_t __num_elements) + : _M_impl() + { _M_initialize_map(__num_elements); } + + _Deque_base(const allocator_type& __a, size_t __num_elements) + : _M_impl(__a) + { _M_initialize_map(__num_elements); } + + _Deque_base(const allocator_type& __a) + : _M_impl(__a) + { } + +#if __cplusplus >= 201103L + _Deque_base(_Deque_base&& __x) + : _M_impl(std::move(__x._M_get_Tp_allocator())) + { + _M_initialize_map(0); + if (__x._M_impl._M_map) + { + std::swap(this->_M_impl._M_start, __x._M_impl._M_start); + std::swap(this->_M_impl._M_finish, __x._M_impl._M_finish); + std::swap(this->_M_impl._M_map, __x._M_impl._M_map); + std::swap(this->_M_impl._M_map_size, __x._M_impl._M_map_size); + } + } +#endif + + ~_Deque_base() _GLIBCXX_NOEXCEPT; + + protected: + typedef typename _Alloc::template rebind<_Tp*>::other _Map_alloc_type; + + typedef typename _Alloc::template rebind<_Tp>::other _Tp_alloc_type; + + //This struct encapsulates the implementation of the std::deque + //standard container and at the same time makes use of the EBO + //for empty allocators. + struct _Deque_impl + : public _Tp_alloc_type + { + _Tp** _M_map; + size_t _M_map_size; + iterator _M_start; + iterator _M_finish; + + _Deque_impl() + : _Tp_alloc_type(), _M_map(0), _M_map_size(0), + _M_start(), _M_finish() + { } + + _Deque_impl(const _Tp_alloc_type& __a) _GLIBCXX_NOEXCEPT + : _Tp_alloc_type(__a), _M_map(0), _M_map_size(0), + _M_start(), _M_finish() + { } + +#if __cplusplus >= 201103L + _Deque_impl(_Tp_alloc_type&& __a) _GLIBCXX_NOEXCEPT + : _Tp_alloc_type(std::move(__a)), _M_map(0), _M_map_size(0), + _M_start(), _M_finish() + { } +#endif + }; + + _Tp_alloc_type& + _M_get_Tp_allocator() _GLIBCXX_NOEXCEPT + { return *static_cast<_Tp_alloc_type*>(&this->_M_impl); } + + const _Tp_alloc_type& + _M_get_Tp_allocator() const _GLIBCXX_NOEXCEPT + { return *static_cast(&this->_M_impl); } + + _Map_alloc_type + _M_get_map_allocator() const _GLIBCXX_NOEXCEPT + { return _Map_alloc_type(_M_get_Tp_allocator()); } + + _Tp* + _M_allocate_node() + { + return _M_impl._Tp_alloc_type::allocate(__deque_buf_size(sizeof(_Tp))); + } + + void + _M_deallocate_node(_Tp* __p) _GLIBCXX_NOEXCEPT + { + _M_impl._Tp_alloc_type::deallocate(__p, __deque_buf_size(sizeof(_Tp))); + } + + _Tp** + _M_allocate_map(size_t __n) + { return _M_get_map_allocator().allocate(__n); } + + void + _M_deallocate_map(_Tp** __p, size_t __n) _GLIBCXX_NOEXCEPT + { _M_get_map_allocator().deallocate(__p, __n); } + + protected: + void _M_initialize_map(size_t); + void _M_create_nodes(_Tp** __nstart, _Tp** __nfinish); + void _M_destroy_nodes(_Tp** __nstart, _Tp** __nfinish) _GLIBCXX_NOEXCEPT; + enum { _S_initial_map_size = 8 }; + + _Deque_impl _M_impl; + }; + + template + _Deque_base<_Tp, _Alloc>:: + ~_Deque_base() _GLIBCXX_NOEXCEPT + { + if (this->_M_impl._M_map) + { + _M_destroy_nodes(this->_M_impl._M_start._M_node, + this->_M_impl._M_finish._M_node + 1); + _M_deallocate_map(this->_M_impl._M_map, this->_M_impl._M_map_size); + } + } + + /** + * @brief Layout storage. + * @param __num_elements The count of T's for which to allocate space + * at first. + * @return Nothing. + * + * The initial underlying memory layout is a bit complicated... + */ + template + void + _Deque_base<_Tp, _Alloc>:: + _M_initialize_map(size_t __num_elements) + { + const size_t __num_nodes = (__num_elements/ __deque_buf_size(sizeof(_Tp)) + + 1); + + this->_M_impl._M_map_size = std::max((size_t) _S_initial_map_size, + size_t(__num_nodes + 2)); + this->_M_impl._M_map = _M_allocate_map(this->_M_impl._M_map_size); + + // For "small" maps (needing less than _M_map_size nodes), allocation + // starts in the middle elements and grows outwards. So nstart may be + // the beginning of _M_map, but for small maps it may be as far in as + // _M_map+3. + + _Tp** __nstart = (this->_M_impl._M_map + + (this->_M_impl._M_map_size - __num_nodes) / 2); + _Tp** __nfinish = __nstart + __num_nodes; + + __try + { _M_create_nodes(__nstart, __nfinish); } + __catch(...) + { + _M_deallocate_map(this->_M_impl._M_map, this->_M_impl._M_map_size); + this->_M_impl._M_map = 0; + this->_M_impl._M_map_size = 0; + __throw_exception_again; + } + + this->_M_impl._M_start._M_set_node(__nstart); + this->_M_impl._M_finish._M_set_node(__nfinish - 1); + this->_M_impl._M_start._M_cur = _M_impl._M_start._M_first; + this->_M_impl._M_finish._M_cur = (this->_M_impl._M_finish._M_first + + __num_elements + % __deque_buf_size(sizeof(_Tp))); + } + + template + void + _Deque_base<_Tp, _Alloc>:: + _M_create_nodes(_Tp** __nstart, _Tp** __nfinish) + { + _Tp** __cur; + __try + { + for (__cur = __nstart; __cur < __nfinish; ++__cur) + *__cur = this->_M_allocate_node(); + } + __catch(...) + { + _M_destroy_nodes(__nstart, __cur); + __throw_exception_again; + } + } + + template + void + _Deque_base<_Tp, _Alloc>:: + _M_destroy_nodes(_Tp** __nstart, _Tp** __nfinish) _GLIBCXX_NOEXCEPT + { + for (_Tp** __n = __nstart; __n < __nfinish; ++__n) + _M_deallocate_node(*__n); + } + + /** + * @brief A standard container using fixed-size memory allocation and + * constant-time manipulation of elements at either end. + * + * @ingroup sequences + * + * @tparam _Tp Type of element. + * @tparam _Alloc Allocator type, defaults to allocator<_Tp>. + * + * Meets the requirements of a container, a + * reversible container, and a + * sequence, including the + * optional sequence requirements. + * + * In previous HP/SGI versions of deque, there was an extra template + * parameter so users could control the node size. This extension turned + * out to violate the C++ standard (it can be detected using template + * template parameters), and it was removed. + * + * Here's how a deque manages memory. Each deque has 4 members: + * + * - Tp** _M_map + * - size_t _M_map_size + * - iterator _M_start, _M_finish + * + * map_size is at least 8. %map is an array of map_size + * pointers-to-@a nodes. (The name %map has nothing to do with the + * std::map class, and @b nodes should not be confused with + * std::list's usage of @a node.) + * + * A @a node has no specific type name as such, but it is referred + * to as @a node in this file. It is a simple array-of-Tp. If Tp + * is very large, there will be one Tp element per node (i.e., an + * @a array of one). For non-huge Tp's, node size is inversely + * related to Tp size: the larger the Tp, the fewer Tp's will fit + * in a node. The goal here is to keep the total size of a node + * relatively small and constant over different Tp's, to improve + * allocator efficiency. + * + * Not every pointer in the %map array will point to a node. If + * the initial number of elements in the deque is small, the + * /middle/ %map pointers will be valid, and the ones at the edges + * will be unused. This same situation will arise as the %map + * grows: available %map pointers, if any, will be on the ends. As + * new nodes are created, only a subset of the %map's pointers need + * to be copied @a outward. + * + * Class invariants: + * - For any nonsingular iterator i: + * - i.node points to a member of the %map array. (Yes, you read that + * correctly: i.node does not actually point to a node.) The member of + * the %map array is what actually points to the node. + * - i.first == *(i.node) (This points to the node (first Tp element).) + * - i.last == i.first + node_size + * - i.cur is a pointer in the range [i.first, i.last). NOTE: + * the implication of this is that i.cur is always a dereferenceable + * pointer, even if i is a past-the-end iterator. + * - Start and Finish are always nonsingular iterators. NOTE: this + * means that an empty deque must have one node, a deque with > + class deque : protected _Deque_base<_Tp, _Alloc> + { + // concept requirements + typedef typename _Alloc::value_type _Alloc_value_type; + __glibcxx_class_requires(_Tp, _SGIAssignableConcept) + __glibcxx_class_requires2(_Tp, _Alloc_value_type, _SameTypeConcept) + + typedef _Deque_base<_Tp, _Alloc> _Base; + typedef typename _Base::_Tp_alloc_type _Tp_alloc_type; + + public: + typedef _Tp value_type; + typedef typename _Tp_alloc_type::pointer pointer; + typedef typename _Tp_alloc_type::const_pointer const_pointer; + typedef typename _Tp_alloc_type::reference reference; + typedef typename _Tp_alloc_type::const_reference const_reference; + typedef typename _Base::iterator iterator; + typedef typename _Base::const_iterator const_iterator; + typedef std::reverse_iterator const_reverse_iterator; + typedef std::reverse_iterator reverse_iterator; + typedef size_t size_type; + typedef ptrdiff_t difference_type; + typedef _Alloc allocator_type; + + protected: + typedef pointer* _Map_pointer; + + static size_t _S_buffer_size() _GLIBCXX_NOEXCEPT + { return __deque_buf_size(sizeof(_Tp)); } + + // Functions controlling memory layout, and nothing else. + using _Base::_M_initialize_map; + using _Base::_M_create_nodes; + using _Base::_M_destroy_nodes; + using _Base::_M_allocate_node; + using _Base::_M_deallocate_node; + using _Base::_M_allocate_map; + using _Base::_M_deallocate_map; + using _Base::_M_get_Tp_allocator; + + /** + * A total of four data members accumulated down the hierarchy. + * May be accessed via _M_impl.* + */ + using _Base::_M_impl; + + public: + // [23.2.1.1] construct/copy/destroy + // (assign() and get_allocator() are also listed in this section) + + /** + * @brief Creates a %deque with no elements. + */ + deque() : _Base() { } + + /** + * @brief Creates a %deque with no elements. + * @param __a An allocator object. + */ + explicit + deque(const allocator_type& __a) + : _Base(__a, 0) { } + +#if __cplusplus >= 201103L + /** + * @brief Creates a %deque with default constructed elements. + * @param __n The number of elements to initially create. + * + * This constructor fills the %deque with @a n default + * constructed elements. + */ + explicit + deque(size_type __n) + : _Base(__n) + { _M_default_initialize(); } + + /** + * @brief Creates a %deque with copies of an exemplar element. + * @param __n The number of elements to initially create. + * @param __value An element to copy. + * @param __a An allocator. + * + * This constructor fills the %deque with @a __n copies of @a __value. + */ + deque(size_type __n, const value_type& __value, + const allocator_type& __a = allocator_type()) + : _Base(__a, __n) + { _M_fill_initialize(__value); } +#else + /** + * @brief Creates a %deque with copies of an exemplar element. + * @param __n The number of elements to initially create. + * @param __value An element to copy. + * @param __a An allocator. + * + * This constructor fills the %deque with @a __n copies of @a __value. + */ + explicit + deque(size_type __n, const value_type& __value = value_type(), + const allocator_type& __a = allocator_type()) + : _Base(__a, __n) + { _M_fill_initialize(__value); } +#endif + + /** + * @brief %Deque copy constructor. + * @param __x A %deque of identical element and allocator types. + * + * The newly-created %deque uses a copy of the allocation object used + * by @a __x. + */ + deque(const deque& __x) + : _Base(__x._M_get_Tp_allocator(), __x.size()) + { std::__uninitialized_copy_a(__x.begin(), __x.end(), + this->_M_impl._M_start, + _M_get_Tp_allocator()); } + +#if __cplusplus >= 201103L + /** + * @brief %Deque move constructor. + * @param __x A %deque of identical element and allocator types. + * + * The newly-created %deque contains the exact contents of @a __x. + * The contents of @a __x are a valid, but unspecified %deque. + */ + deque(deque&& __x) + : _Base(std::move(__x)) { } + + /** + * @brief Builds a %deque from an initializer list. + * @param __l An initializer_list. + * @param __a An allocator object. + * + * Create a %deque consisting of copies of the elements in the + * initializer_list @a __l. + * + * This will call the element type's copy constructor N times + * (where N is __l.size()) and do no memory reallocation. + */ + deque(initializer_list __l, + const allocator_type& __a = allocator_type()) + : _Base(__a) + { + _M_range_initialize(__l.begin(), __l.end(), + random_access_iterator_tag()); + } +#endif + + /** + * @brief Builds a %deque from a range. + * @param __first An input iterator. + * @param __last An input iterator. + * @param __a An allocator object. + * + * Create a %deque consisting of copies of the elements from [__first, + * __last). + * + * If the iterators are forward, bidirectional, or random-access, then + * this will call the elements' copy constructor N times (where N is + * distance(__first,__last)) and do no memory reallocation. But if only + * input iterators are used, then this will do at most 2N calls to the + * copy constructor, and logN memory reallocations. + */ +#if __cplusplus >= 201103L + template> + deque(_InputIterator __first, _InputIterator __last, + const allocator_type& __a = allocator_type()) + : _Base(__a) + { _M_initialize_dispatch(__first, __last, __false_type()); } +#else + template + deque(_InputIterator __first, _InputIterator __last, + const allocator_type& __a = allocator_type()) + : _Base(__a) + { + // Check whether it's an integral type. If so, it's not an iterator. + typedef typename std::__is_integer<_InputIterator>::__type _Integral; + _M_initialize_dispatch(__first, __last, _Integral()); + } +#endif + + /** + * The dtor only erases the elements, and note that if the elements + * themselves are pointers, the pointed-to memory is not touched in any + * way. Managing the pointer is the user's responsibility. + */ + ~deque() _GLIBCXX_NOEXCEPT + { _M_destroy_data(begin(), end(), _M_get_Tp_allocator()); } + + /** + * @brief %Deque assignment operator. + * @param __x A %deque of identical element and allocator types. + * + * All the elements of @a x are copied, but unlike the copy constructor, + * the allocator object is not copied. + */ + deque& + operator=(const deque& __x); + +#if __cplusplus >= 201103L + /** + * @brief %Deque move assignment operator. + * @param __x A %deque of identical element and allocator types. + * + * The contents of @a __x are moved into this deque (without copying). + * @a __x is a valid, but unspecified %deque. + */ + deque& + operator=(deque&& __x) noexcept + { + // NB: DR 1204. + // NB: DR 675. + this->clear(); + this->swap(__x); + return *this; + } + + /** + * @brief Assigns an initializer list to a %deque. + * @param __l An initializer_list. + * + * This function fills a %deque with copies of the elements in the + * initializer_list @a __l. + * + * Note that the assignment completely changes the %deque and that the + * resulting %deque's size is the same as the number of elements + * assigned. Old data may be lost. + */ + deque& + operator=(initializer_list __l) + { + this->assign(__l.begin(), __l.end()); + return *this; + } +#endif + + /** + * @brief Assigns a given value to a %deque. + * @param __n Number of elements to be assigned. + * @param __val Value to be assigned. + * + * This function fills a %deque with @a n copies of the given + * value. Note that the assignment completely changes the + * %deque and that the resulting %deque's size is the same as + * the number of elements assigned. Old data may be lost. + */ + void + assign(size_type __n, const value_type& __val) + { _M_fill_assign(__n, __val); } + + /** + * @brief Assigns a range to a %deque. + * @param __first An input iterator. + * @param __last An input iterator. + * + * This function fills a %deque with copies of the elements in the + * range [__first,__last). + * + * Note that the assignment completely changes the %deque and that the + * resulting %deque's size is the same as the number of elements + * assigned. Old data may be lost. + */ +#if __cplusplus >= 201103L + template> + void + assign(_InputIterator __first, _InputIterator __last) + { _M_assign_dispatch(__first, __last, __false_type()); } +#else + template + void + assign(_InputIterator __first, _InputIterator __last) + { + typedef typename std::__is_integer<_InputIterator>::__type _Integral; + _M_assign_dispatch(__first, __last, _Integral()); + } +#endif + +#if __cplusplus >= 201103L + /** + * @brief Assigns an initializer list to a %deque. + * @param __l An initializer_list. + * + * This function fills a %deque with copies of the elements in the + * initializer_list @a __l. + * + * Note that the assignment completely changes the %deque and that the + * resulting %deque's size is the same as the number of elements + * assigned. Old data may be lost. + */ + void + assign(initializer_list __l) + { this->assign(__l.begin(), __l.end()); } +#endif + + /// Get a copy of the memory allocation object. + allocator_type + get_allocator() const _GLIBCXX_NOEXCEPT + { return _Base::get_allocator(); } + + // iterators + /** + * Returns a read/write iterator that points to the first element in the + * %deque. Iteration is done in ordinary element order. + */ + iterator + begin() _GLIBCXX_NOEXCEPT + { return this->_M_impl._M_start; } + + /** + * Returns a read-only (constant) iterator that points to the first + * element in the %deque. Iteration is done in ordinary element order. + */ + const_iterator + begin() const _GLIBCXX_NOEXCEPT + { return this->_M_impl._M_start; } + + /** + * Returns a read/write iterator that points one past the last + * element in the %deque. Iteration is done in ordinary + * element order. + */ + iterator + end() _GLIBCXX_NOEXCEPT + { return this->_M_impl._M_finish; } + + /** + * Returns a read-only (constant) iterator that points one past + * the last element in the %deque. Iteration is done in + * ordinary element order. + */ + const_iterator + end() const _GLIBCXX_NOEXCEPT + { return this->_M_impl._M_finish; } + + /** + * Returns a read/write reverse iterator that points to the + * last element in the %deque. Iteration is done in reverse + * element order. + */ + reverse_iterator + rbegin() _GLIBCXX_NOEXCEPT + { return reverse_iterator(this->_M_impl._M_finish); } + + /** + * Returns a read-only (constant) reverse iterator that points + * to the last element in the %deque. Iteration is done in + * reverse element order. + */ + const_reverse_iterator + rbegin() const _GLIBCXX_NOEXCEPT + { return const_reverse_iterator(this->_M_impl._M_finish); } + + /** + * Returns a read/write reverse iterator that points to one + * before the first element in the %deque. Iteration is done + * in reverse element order. + */ + reverse_iterator + rend() _GLIBCXX_NOEXCEPT + { return reverse_iterator(this->_M_impl._M_start); } + + /** + * Returns a read-only (constant) reverse iterator that points + * to one before the first element in the %deque. Iteration is + * done in reverse element order. + */ + const_reverse_iterator + rend() const _GLIBCXX_NOEXCEPT + { return const_reverse_iterator(this->_M_impl._M_start); } + +#if __cplusplus >= 201103L + /** + * Returns a read-only (constant) iterator that points to the first + * element in the %deque. Iteration is done in ordinary element order. + */ + const_iterator + cbegin() const noexcept + { return this->_M_impl._M_start; } + + /** + * Returns a read-only (constant) iterator that points one past + * the last element in the %deque. Iteration is done in + * ordinary element order. + */ + const_iterator + cend() const noexcept + { return this->_M_impl._M_finish; } + + /** + * Returns a read-only (constant) reverse iterator that points + * to the last element in the %deque. Iteration is done in + * reverse element order. + */ + const_reverse_iterator + crbegin() const noexcept + { return const_reverse_iterator(this->_M_impl._M_finish); } + + /** + * Returns a read-only (constant) reverse iterator that points + * to one before the first element in the %deque. Iteration is + * done in reverse element order. + */ + const_reverse_iterator + crend() const noexcept + { return const_reverse_iterator(this->_M_impl._M_start); } +#endif + + // [23.2.1.2] capacity + /** Returns the number of elements in the %deque. */ + size_type + size() const _GLIBCXX_NOEXCEPT + { return this->_M_impl._M_finish - this->_M_impl._M_start; } + + /** Returns the size() of the largest possible %deque. */ + size_type + max_size() const _GLIBCXX_NOEXCEPT + { return _M_get_Tp_allocator().max_size(); } + +#if __cplusplus >= 201103L + /** + * @brief Resizes the %deque to the specified number of elements. + * @param __new_size Number of elements the %deque should contain. + * + * This function will %resize the %deque to the specified + * number of elements. If the number is smaller than the + * %deque's current size the %deque is truncated, otherwise + * default constructed elements are appended. + */ + void + resize(size_type __new_size) + { + const size_type __len = size(); + if (__new_size > __len) + _M_default_append(__new_size - __len); + else if (__new_size < __len) + _M_erase_at_end(this->_M_impl._M_start + + difference_type(__new_size)); + } + + /** + * @brief Resizes the %deque to the specified number of elements. + * @param __new_size Number of elements the %deque should contain. + * @param __x Data with which new elements should be populated. + * + * This function will %resize the %deque to the specified + * number of elements. If the number is smaller than the + * %deque's current size the %deque is truncated, otherwise the + * %deque is extended and new elements are populated with given + * data. + */ + void + resize(size_type __new_size, const value_type& __x) + { + const size_type __len = size(); + if (__new_size > __len) + insert(this->_M_impl._M_finish, __new_size - __len, __x); + else if (__new_size < __len) + _M_erase_at_end(this->_M_impl._M_start + + difference_type(__new_size)); + } +#else + /** + * @brief Resizes the %deque to the specified number of elements. + * @param __new_size Number of elements the %deque should contain. + * @param __x Data with which new elements should be populated. + * + * This function will %resize the %deque to the specified + * number of elements. If the number is smaller than the + * %deque's current size the %deque is truncated, otherwise the + * %deque is extended and new elements are populated with given + * data. + */ + void + resize(size_type __new_size, value_type __x = value_type()) + { + const size_type __len = size(); + if (__new_size > __len) + insert(this->_M_impl._M_finish, __new_size - __len, __x); + else if (__new_size < __len) + _M_erase_at_end(this->_M_impl._M_start + + difference_type(__new_size)); + } +#endif + +#if __cplusplus >= 201103L + /** A non-binding request to reduce memory use. */ + void + shrink_to_fit() noexcept + { _M_shrink_to_fit(); } +#endif + + /** + * Returns true if the %deque is empty. (Thus begin() would + * equal end().) + */ + bool + empty() const _GLIBCXX_NOEXCEPT + { return this->_M_impl._M_finish == this->_M_impl._M_start; } + + // element access + /** + * @brief Subscript access to the data contained in the %deque. + * @param __n The index of the element for which data should be + * accessed. + * @return Read/write reference to data. + * + * This operator allows for easy, array-style, data access. + * Note that data access with this operator is unchecked and + * out_of_range lookups are not defined. (For checked lookups + * see at().) + */ + reference + operator[](size_type __n) _GLIBCXX_NOEXCEPT + { return this->_M_impl._M_start[difference_type(__n)]; } + + /** + * @brief Subscript access to the data contained in the %deque. + * @param __n The index of the element for which data should be + * accessed. + * @return Read-only (constant) reference to data. + * + * This operator allows for easy, array-style, data access. + * Note that data access with this operator is unchecked and + * out_of_range lookups are not defined. (For checked lookups + * see at().) + */ + const_reference + operator[](size_type __n) const _GLIBCXX_NOEXCEPT + { return this->_M_impl._M_start[difference_type(__n)]; } + + protected: + /// Safety check used only from at(). + void + _M_range_check(size_type __n) const + { + if (__n >= this->size()) + __throw_out_of_range_fmt(__N("deque::_M_range_check: __n " + "(which is %zu)>= this->size() " + "(which is %zu)"), + __n, this->size()); + } + + public: + /** + * @brief Provides access to the data contained in the %deque. + * @param __n The index of the element for which data should be + * accessed. + * @return Read/write reference to data. + * @throw std::out_of_range If @a __n is an invalid index. + * + * This function provides for safer data access. The parameter + * is first checked that it is in the range of the deque. The + * function throws out_of_range if the check fails. + */ + reference + at(size_type __n) + { + _M_range_check(__n); + return (*this)[__n]; + } + + /** + * @brief Provides access to the data contained in the %deque. + * @param __n The index of the element for which data should be + * accessed. + * @return Read-only (constant) reference to data. + * @throw std::out_of_range If @a __n is an invalid index. + * + * This function provides for safer data access. The parameter is first + * checked that it is in the range of the deque. The function throws + * out_of_range if the check fails. + */ + const_reference + at(size_type __n) const + { + _M_range_check(__n); + return (*this)[__n]; + } + + /** + * Returns a read/write reference to the data at the first + * element of the %deque. + */ + reference + front() _GLIBCXX_NOEXCEPT + { return *begin(); } + + /** + * Returns a read-only (constant) reference to the data at the first + * element of the %deque. + */ + const_reference + front() const _GLIBCXX_NOEXCEPT + { return *begin(); } + + /** + * Returns a read/write reference to the data at the last element of the + * %deque. + */ + reference + back() _GLIBCXX_NOEXCEPT + { + iterator __tmp = end(); + --__tmp; + return *__tmp; + } + + /** + * Returns a read-only (constant) reference to the data at the last + * element of the %deque. + */ + const_reference + back() const _GLIBCXX_NOEXCEPT + { + const_iterator __tmp = end(); + --__tmp; + return *__tmp; + } + + // [23.2.1.2] modifiers + /** + * @brief Add data to the front of the %deque. + * @param __x Data to be added. + * + * This is a typical stack operation. The function creates an + * element at the front of the %deque and assigns the given + * data to it. Due to the nature of a %deque this operation + * can be done in constant time. + */ + void + push_front(const value_type& __x) + { + if (this->_M_impl._M_start._M_cur != this->_M_impl._M_start._M_first) + { + this->_M_impl.construct(this->_M_impl._M_start._M_cur - 1, __x); + --this->_M_impl._M_start._M_cur; + } + else + _M_push_front_aux(__x); + } + +#if __cplusplus >= 201103L + void + push_front(value_type&& __x) + { emplace_front(std::move(__x)); } + + template + void + emplace_front(_Args&&... __args); +#endif + + /** + * @brief Add data to the end of the %deque. + * @param __x Data to be added. + * + * This is a typical stack operation. The function creates an + * element at the end of the %deque and assigns the given data + * to it. Due to the nature of a %deque this operation can be + * done in constant time. + */ + void + push_back(const value_type& __x) + { + if (this->_M_impl._M_finish._M_cur + != this->_M_impl._M_finish._M_last - 1) + { + this->_M_impl.construct(this->_M_impl._M_finish._M_cur, __x); + ++this->_M_impl._M_finish._M_cur; + } + else + _M_push_back_aux(__x); + } + +#if __cplusplus >= 201103L + void + push_back(value_type&& __x) + { emplace_back(std::move(__x)); } + + template + void + emplace_back(_Args&&... __args); +#endif + + /** + * @brief Removes first element. + * + * This is a typical stack operation. It shrinks the %deque by one. + * + * Note that no data is returned, and if the first element's data is + * needed, it should be retrieved before pop_front() is called. + */ + void + pop_front() _GLIBCXX_NOEXCEPT + { + if (this->_M_impl._M_start._M_cur + != this->_M_impl._M_start._M_last - 1) + { + this->_M_impl.destroy(this->_M_impl._M_start._M_cur); + ++this->_M_impl._M_start._M_cur; + } + else + _M_pop_front_aux(); + } + + /** + * @brief Removes last element. + * + * This is a typical stack operation. It shrinks the %deque by one. + * + * Note that no data is returned, and if the last element's data is + * needed, it should be retrieved before pop_back() is called. + */ + void + pop_back() _GLIBCXX_NOEXCEPT + { + if (this->_M_impl._M_finish._M_cur + != this->_M_impl._M_finish._M_first) + { + --this->_M_impl._M_finish._M_cur; + this->_M_impl.destroy(this->_M_impl._M_finish._M_cur); + } + else + _M_pop_back_aux(); + } + +#if __cplusplus >= 201103L + /** + * @brief Inserts an object in %deque before specified iterator. + * @param __position A const_iterator into the %deque. + * @param __args Arguments. + * @return An iterator that points to the inserted data. + * + * This function will insert an object of type T constructed + * with T(std::forward(args)...) before the specified location. + */ + template + iterator + emplace(const_iterator __position, _Args&&... __args); + + /** + * @brief Inserts given value into %deque before specified iterator. + * @param __position A const_iterator into the %deque. + * @param __x Data to be inserted. + * @return An iterator that points to the inserted data. + * + * This function will insert a copy of the given value before the + * specified location. + */ + iterator + insert(const_iterator __position, const value_type& __x); +#else + /** + * @brief Inserts given value into %deque before specified iterator. + * @param __position An iterator into the %deque. + * @param __x Data to be inserted. + * @return An iterator that points to the inserted data. + * + * This function will insert a copy of the given value before the + * specified location. + */ + iterator + insert(iterator __position, const value_type& __x); +#endif + +#if __cplusplus >= 201103L + /** + * @brief Inserts given rvalue into %deque before specified iterator. + * @param __position A const_iterator into the %deque. + * @param __x Data to be inserted. + * @return An iterator that points to the inserted data. + * + * This function will insert a copy of the given rvalue before the + * specified location. + */ + iterator + insert(const_iterator __position, value_type&& __x) + { return emplace(__position, std::move(__x)); } + + /** + * @brief Inserts an initializer list into the %deque. + * @param __p An iterator into the %deque. + * @param __l An initializer_list. + * + * This function will insert copies of the data in the + * initializer_list @a __l into the %deque before the location + * specified by @a __p. This is known as list insert. + */ + iterator + insert(const_iterator __p, initializer_list __l) + { return this->insert(__p, __l.begin(), __l.end()); } +#endif + +#if __cplusplus >= 201103L + /** + * @brief Inserts a number of copies of given data into the %deque. + * @param __position A const_iterator into the %deque. + * @param __n Number of elements to be inserted. + * @param __x Data to be inserted. + * @return An iterator that points to the inserted data. + * + * This function will insert a specified number of copies of the given + * data before the location specified by @a __position. + */ + iterator + insert(const_iterator __position, size_type __n, const value_type& __x) + { + difference_type __offset = __position - cbegin(); + _M_fill_insert(__position._M_const_cast(), __n, __x); + return begin() + __offset; + } +#else + /** + * @brief Inserts a number of copies of given data into the %deque. + * @param __position An iterator into the %deque. + * @param __n Number of elements to be inserted. + * @param __x Data to be inserted. + * + * This function will insert a specified number of copies of the given + * data before the location specified by @a __position. + */ + void + insert(iterator __position, size_type __n, const value_type& __x) + { _M_fill_insert(__position, __n, __x); } +#endif + +#if __cplusplus >= 201103L + /** + * @brief Inserts a range into the %deque. + * @param __position A const_iterator into the %deque. + * @param __first An input iterator. + * @param __last An input iterator. + * @return An iterator that points to the inserted data. + * + * This function will insert copies of the data in the range + * [__first,__last) into the %deque before the location specified + * by @a __position. This is known as range insert. + */ + template> + iterator + insert(const_iterator __position, _InputIterator __first, + _InputIterator __last) + { + difference_type __offset = __position - cbegin(); + _M_insert_dispatch(__position._M_const_cast(), + __first, __last, __false_type()); + return begin() + __offset; + } +#else + /** + * @brief Inserts a range into the %deque. + * @param __position An iterator into the %deque. + * @param __first An input iterator. + * @param __last An input iterator. + * + * This function will insert copies of the data in the range + * [__first,__last) into the %deque before the location specified + * by @a __position. This is known as range insert. + */ + template + void + insert(iterator __position, _InputIterator __first, + _InputIterator __last) + { + // Check whether it's an integral type. If so, it's not an iterator. + typedef typename std::__is_integer<_InputIterator>::__type _Integral; + _M_insert_dispatch(__position, __first, __last, _Integral()); + } +#endif + + /** + * @brief Remove element at given position. + * @param __position Iterator pointing to element to be erased. + * @return An iterator pointing to the next element (or end()). + * + * This function will erase the element at the given position and thus + * shorten the %deque by one. + * + * The user is cautioned that + * this function only erases the element, and that if the element is + * itself a pointer, the pointed-to memory is not touched in any way. + * Managing the pointer is the user's responsibility. + */ + iterator +#if __cplusplus >= 201103L + erase(const_iterator __position) +#else + erase(iterator __position) +#endif + { return _M_erase(__position._M_const_cast()); } + + /** + * @brief Remove a range of elements. + * @param __first Iterator pointing to the first element to be erased. + * @param __last Iterator pointing to one past the last element to be + * erased. + * @return An iterator pointing to the element pointed to by @a last + * prior to erasing (or end()). + * + * This function will erase the elements in the range + * [__first,__last) and shorten the %deque accordingly. + * + * The user is cautioned that + * this function only erases the elements, and that if the elements + * themselves are pointers, the pointed-to memory is not touched in any + * way. Managing the pointer is the user's responsibility. + */ + iterator +#if __cplusplus >= 201103L + erase(const_iterator __first, const_iterator __last) +#else + erase(iterator __first, iterator __last) +#endif + { return _M_erase(__first._M_const_cast(), __last._M_const_cast()); } + + /** + * @brief Swaps data with another %deque. + * @param __x A %deque of the same element and allocator types. + * + * This exchanges the elements between two deques in constant time. + * (Four pointers, so it should be quite fast.) + * Note that the global std::swap() function is specialized such that + * std::swap(d1,d2) will feed to this function. + */ + void + swap(deque& __x) _GLIBCXX_NOEXCEPT + { + std::swap(this->_M_impl._M_start, __x._M_impl._M_start); + std::swap(this->_M_impl._M_finish, __x._M_impl._M_finish); + std::swap(this->_M_impl._M_map, __x._M_impl._M_map); + std::swap(this->_M_impl._M_map_size, __x._M_impl._M_map_size); + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 431. Swapping containers with unequal allocators. + std::__alloc_swap<_Tp_alloc_type>::_S_do_it(_M_get_Tp_allocator(), + __x._M_get_Tp_allocator()); + } + + /** + * Erases all the elements. Note that this function only erases the + * elements, and that if the elements themselves are pointers, the + * pointed-to memory is not touched in any way. Managing the pointer is + * the user's responsibility. + */ + void + clear() _GLIBCXX_NOEXCEPT + { _M_erase_at_end(begin()); } + + protected: + // Internal constructor functions follow. + + // called by the range constructor to implement [23.1.1]/9 + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 438. Ambiguity in the "do the right thing" clause + template + void + _M_initialize_dispatch(_Integer __n, _Integer __x, __true_type) + { + _M_initialize_map(static_cast(__n)); + _M_fill_initialize(__x); + } + + // called by the range constructor to implement [23.1.1]/9 + template + void + _M_initialize_dispatch(_InputIterator __first, _InputIterator __last, + __false_type) + { + typedef typename std::iterator_traits<_InputIterator>:: + iterator_category _IterCategory; + _M_range_initialize(__first, __last, _IterCategory()); + } + + // called by the second initialize_dispatch above + //@{ + /** + * @brief Fills the deque with whatever is in [first,last). + * @param __first An input iterator. + * @param __last An input iterator. + * @return Nothing. + * + * If the iterators are actually forward iterators (or better), then the + * memory layout can be done all at once. Else we move forward using + * push_back on each value from the iterator. + */ + template + void + _M_range_initialize(_InputIterator __first, _InputIterator __last, + std::input_iterator_tag); + + // called by the second initialize_dispatch above + template + void + _M_range_initialize(_ForwardIterator __first, _ForwardIterator __last, + std::forward_iterator_tag); + //@} + + /** + * @brief Fills the %deque with copies of value. + * @param __value Initial value. + * @return Nothing. + * @pre _M_start and _M_finish have already been initialized, + * but none of the %deque's elements have yet been constructed. + * + * This function is called only when the user provides an explicit size + * (with or without an explicit exemplar value). + */ + void + _M_fill_initialize(const value_type& __value); + +#if __cplusplus >= 201103L + // called by deque(n). + void + _M_default_initialize(); +#endif + + // Internal assign functions follow. The *_aux functions do the actual + // assignment work for the range versions. + + // called by the range assign to implement [23.1.1]/9 + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 438. Ambiguity in the "do the right thing" clause + template + void + _M_assign_dispatch(_Integer __n, _Integer __val, __true_type) + { _M_fill_assign(__n, __val); } + + // called by the range assign to implement [23.1.1]/9 + template + void + _M_assign_dispatch(_InputIterator __first, _InputIterator __last, + __false_type) + { + typedef typename std::iterator_traits<_InputIterator>:: + iterator_category _IterCategory; + _M_assign_aux(__first, __last, _IterCategory()); + } + + // called by the second assign_dispatch above + template + void + _M_assign_aux(_InputIterator __first, _InputIterator __last, + std::input_iterator_tag); + + // called by the second assign_dispatch above + template + void + _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last, + std::forward_iterator_tag) + { + const size_type __len = std::distance(__first, __last); + if (__len > size()) + { + _ForwardIterator __mid = __first; + std::advance(__mid, size()); + std::copy(__first, __mid, begin()); + insert(end(), __mid, __last); + } + else + _M_erase_at_end(std::copy(__first, __last, begin())); + } + + // Called by assign(n,t), and the range assign when it turns out + // to be the same thing. + void + _M_fill_assign(size_type __n, const value_type& __val) + { + if (__n > size()) + { + std::fill(begin(), end(), __val); + insert(end(), __n - size(), __val); + } + else + { + _M_erase_at_end(begin() + difference_type(__n)); + std::fill(begin(), end(), __val); + } + } + + //@{ + /// Helper functions for push_* and pop_*. +#if __cplusplus < 201103L + void _M_push_back_aux(const value_type&); + + void _M_push_front_aux(const value_type&); +#else + template + void _M_push_back_aux(_Args&&... __args); + + template + void _M_push_front_aux(_Args&&... __args); +#endif + + void _M_pop_back_aux(); + + void _M_pop_front_aux(); + //@} + + // Internal insert functions follow. The *_aux functions do the actual + // insertion work when all shortcuts fail. + + // called by the range insert to implement [23.1.1]/9 + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 438. Ambiguity in the "do the right thing" clause + template + void + _M_insert_dispatch(iterator __pos, + _Integer __n, _Integer __x, __true_type) + { _M_fill_insert(__pos, __n, __x); } + + // called by the range insert to implement [23.1.1]/9 + template + void + _M_insert_dispatch(iterator __pos, + _InputIterator __first, _InputIterator __last, + __false_type) + { + typedef typename std::iterator_traits<_InputIterator>:: + iterator_category _IterCategory; + _M_range_insert_aux(__pos, __first, __last, _IterCategory()); + } + + // called by the second insert_dispatch above + template + void + _M_range_insert_aux(iterator __pos, _InputIterator __first, + _InputIterator __last, std::input_iterator_tag); + + // called by the second insert_dispatch above + template + void + _M_range_insert_aux(iterator __pos, _ForwardIterator __first, + _ForwardIterator __last, std::forward_iterator_tag); + + // Called by insert(p,n,x), and the range insert when it turns out to be + // the same thing. Can use fill functions in optimal situations, + // otherwise passes off to insert_aux(p,n,x). + void + _M_fill_insert(iterator __pos, size_type __n, const value_type& __x); + + // called by insert(p,x) +#if __cplusplus < 201103L + iterator + _M_insert_aux(iterator __pos, const value_type& __x); +#else + template + iterator + _M_insert_aux(iterator __pos, _Args&&... __args); +#endif + + // called by insert(p,n,x) via fill_insert + void + _M_insert_aux(iterator __pos, size_type __n, const value_type& __x); + + // called by range_insert_aux for forward iterators + template + void + _M_insert_aux(iterator __pos, + _ForwardIterator __first, _ForwardIterator __last, + size_type __n); + + + // Internal erase functions follow. + + void + _M_destroy_data_aux(iterator __first, iterator __last); + + // Called by ~deque(). + // NB: Doesn't deallocate the nodes. + template + void + _M_destroy_data(iterator __first, iterator __last, const _Alloc1&) + { _M_destroy_data_aux(__first, __last); } + + void + _M_destroy_data(iterator __first, iterator __last, + const std::allocator<_Tp>&) + { + if (!__has_trivial_destructor(value_type)) + _M_destroy_data_aux(__first, __last); + } + + // Called by erase(q1, q2). + void + _M_erase_at_begin(iterator __pos) + { + _M_destroy_data(begin(), __pos, _M_get_Tp_allocator()); + _M_destroy_nodes(this->_M_impl._M_start._M_node, __pos._M_node); + this->_M_impl._M_start = __pos; + } + + // Called by erase(q1, q2), resize(), clear(), _M_assign_aux, + // _M_fill_assign, operator=. + void + _M_erase_at_end(iterator __pos) + { + _M_destroy_data(__pos, end(), _M_get_Tp_allocator()); + _M_destroy_nodes(__pos._M_node + 1, + this->_M_impl._M_finish._M_node + 1); + this->_M_impl._M_finish = __pos; + } + + iterator + _M_erase(iterator __pos); + + iterator + _M_erase(iterator __first, iterator __last); + +#if __cplusplus >= 201103L + // Called by resize(sz). + void + _M_default_append(size_type __n); + + bool + _M_shrink_to_fit(); +#endif + + //@{ + /// Memory-handling helpers for the previous internal insert functions. + iterator + _M_reserve_elements_at_front(size_type __n) + { + const size_type __vacancies = this->_M_impl._M_start._M_cur + - this->_M_impl._M_start._M_first; + if (__n > __vacancies) + _M_new_elements_at_front(__n - __vacancies); + return this->_M_impl._M_start - difference_type(__n); + } + + iterator + _M_reserve_elements_at_back(size_type __n) + { + const size_type __vacancies = (this->_M_impl._M_finish._M_last + - this->_M_impl._M_finish._M_cur) - 1; + if (__n > __vacancies) + _M_new_elements_at_back(__n - __vacancies); + return this->_M_impl._M_finish + difference_type(__n); + } + + void + _M_new_elements_at_front(size_type __new_elements); + + void + _M_new_elements_at_back(size_type __new_elements); + //@} + + + //@{ + /** + * @brief Memory-handling helpers for the major %map. + * + * Makes sure the _M_map has space for new nodes. Does not + * actually add the nodes. Can invalidate _M_map pointers. + * (And consequently, %deque iterators.) + */ + void + _M_reserve_map_at_back(size_type __nodes_to_add = 1) + { + if (__nodes_to_add + 1 > this->_M_impl._M_map_size + - (this->_M_impl._M_finish._M_node - this->_M_impl._M_map)) + _M_reallocate_map(__nodes_to_add, false); + } + + void + _M_reserve_map_at_front(size_type __nodes_to_add = 1) + { + if (__nodes_to_add > size_type(this->_M_impl._M_start._M_node + - this->_M_impl._M_map)) + _M_reallocate_map(__nodes_to_add, true); + } + + void + _M_reallocate_map(size_type __nodes_to_add, bool __add_at_front); + //@} + }; + + + /** + * @brief Deque equality comparison. + * @param __x A %deque. + * @param __y A %deque of the same type as @a __x. + * @return True iff the size and elements of the deques are equal. + * + * This is an equivalence relation. It is linear in the size of the + * deques. Deques are considered equivalent if their sizes are equal, + * and if corresponding elements compare equal. + */ + template + inline bool + operator==(const deque<_Tp, _Alloc>& __x, + const deque<_Tp, _Alloc>& __y) + { return __x.size() == __y.size() + && std::equal(__x.begin(), __x.end(), __y.begin()); } + + /** + * @brief Deque ordering relation. + * @param __x A %deque. + * @param __y A %deque of the same type as @a __x. + * @return True iff @a x is lexicographically less than @a __y. + * + * This is a total ordering relation. It is linear in the size of the + * deques. The elements must be comparable with @c <. + * + * See std::lexicographical_compare() for how the determination is made. + */ + template + inline bool + operator<(const deque<_Tp, _Alloc>& __x, + const deque<_Tp, _Alloc>& __y) + { return std::lexicographical_compare(__x.begin(), __x.end(), + __y.begin(), __y.end()); } + + /// Based on operator== + template + inline bool + operator!=(const deque<_Tp, _Alloc>& __x, + const deque<_Tp, _Alloc>& __y) + { return !(__x == __y); } + + /// Based on operator< + template + inline bool + operator>(const deque<_Tp, _Alloc>& __x, + const deque<_Tp, _Alloc>& __y) + { return __y < __x; } + + /// Based on operator< + template + inline bool + operator<=(const deque<_Tp, _Alloc>& __x, + const deque<_Tp, _Alloc>& __y) + { return !(__y < __x); } + + /// Based on operator< + template + inline bool + operator>=(const deque<_Tp, _Alloc>& __x, + const deque<_Tp, _Alloc>& __y) + { return !(__x < __y); } + + /// See std::deque::swap(). + template + inline void + swap(deque<_Tp,_Alloc>& __x, deque<_Tp,_Alloc>& __y) + { __x.swap(__y); } + +#undef _GLIBCXX_DEQUE_BUF_SIZE + +_GLIBCXX_END_NAMESPACE_CONTAINER +} // namespace std + +#endif /* _STL_DEQUE_H */ diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stl_function.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stl_function.h new file mode 100755 index 0000000..71215b8 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stl_function.h @@ -0,0 +1,1087 @@ +// Functor implementations -*- C++ -*- + +// Copyright (C) 2001-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/* + * + * Copyright (c) 1994 + * Hewlett-Packard Company + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Hewlett-Packard Company makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + * + * + * Copyright (c) 1996-1998 + * Silicon Graphics Computer Systems, Inc. + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Silicon Graphics makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + */ + +/** @file bits/stl_function.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{functional} + */ + +#ifndef _STL_FUNCTION_H +#define _STL_FUNCTION_H 1 + +#if __cplusplus > 201103L +#include +#endif + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + // 20.3.1 base classes + /** @defgroup functors Function Objects + * @ingroup utilities + * + * Function objects, or @e functors, are objects with an @c operator() + * defined and accessible. They can be passed as arguments to algorithm + * templates and used in place of a function pointer. Not only is the + * resulting expressiveness of the library increased, but the generated + * code can be more efficient than what you might write by hand. When we + * refer to @a functors, then, generally we include function pointers in + * the description as well. + * + * Often, functors are only created as temporaries passed to algorithm + * calls, rather than being created as named variables. + * + * Two examples taken from the standard itself follow. To perform a + * by-element addition of two vectors @c a and @c b containing @c double, + * and put the result in @c a, use + * \code + * transform (a.begin(), a.end(), b.begin(), a.begin(), plus()); + * \endcode + * To negate every element in @c a, use + * \code + * transform(a.begin(), a.end(), a.begin(), negate()); + * \endcode + * The addition and negation functions will be inlined directly. + * + * The standard functors are derived from structs named @c unary_function + * and @c binary_function. These two classes contain nothing but typedefs, + * to aid in generic (template) programming. If you write your own + * functors, you might consider doing the same. + * + * @{ + */ + /** + * This is one of the @link functors functor base classes@endlink. + */ + template + struct unary_function + { + /// @c argument_type is the type of the argument + typedef _Arg argument_type; + + /// @c result_type is the return type + typedef _Result result_type; + }; + + /** + * This is one of the @link functors functor base classes@endlink. + */ + template + struct binary_function + { + /// @c first_argument_type is the type of the first argument + typedef _Arg1 first_argument_type; + + /// @c second_argument_type is the type of the second argument + typedef _Arg2 second_argument_type; + + /// @c result_type is the return type + typedef _Result result_type; + }; + /** @} */ + + // 20.3.2 arithmetic + /** @defgroup arithmetic_functors Arithmetic Classes + * @ingroup functors + * + * Because basic math often needs to be done during an algorithm, + * the library provides functors for those operations. See the + * documentation for @link functors the base classes@endlink + * for examples of their use. + * + * @{ + */ + +#if __cplusplus > 201103L + struct __is_transparent; // undefined + + template + struct plus; + + template + struct minus; + + template + struct multiplies; + + template + struct divides; + + template + struct modulus; + + template + struct negate; +#endif + + /// One of the @link arithmetic_functors math functors@endlink. + template + struct plus : public binary_function<_Tp, _Tp, _Tp> + { + _Tp + operator()(const _Tp& __x, const _Tp& __y) const + { return __x + __y; } + }; + + /// One of the @link arithmetic_functors math functors@endlink. + template + struct minus : public binary_function<_Tp, _Tp, _Tp> + { + _Tp + operator()(const _Tp& __x, const _Tp& __y) const + { return __x - __y; } + }; + + /// One of the @link arithmetic_functors math functors@endlink. + template + struct multiplies : public binary_function<_Tp, _Tp, _Tp> + { + _Tp + operator()(const _Tp& __x, const _Tp& __y) const + { return __x * __y; } + }; + + /// One of the @link arithmetic_functors math functors@endlink. + template + struct divides : public binary_function<_Tp, _Tp, _Tp> + { + _Tp + operator()(const _Tp& __x, const _Tp& __y) const + { return __x / __y; } + }; + + /// One of the @link arithmetic_functors math functors@endlink. + template + struct modulus : public binary_function<_Tp, _Tp, _Tp> + { + _Tp + operator()(const _Tp& __x, const _Tp& __y) const + { return __x % __y; } + }; + + /// One of the @link arithmetic_functors math functors@endlink. + template + struct negate : public unary_function<_Tp, _Tp> + { + _Tp + operator()(const _Tp& __x) const + { return -__x; } + }; + +#if __cplusplus > 201103L + +#define __cpp_lib_transparent_operators 201210 +//#define __cpp_lib_generic_associative_lookup 201304 + + template<> + struct plus + { + template + auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) + std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) + std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) + std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + /// One of the @link arithmetic_functors math functors@endlink. + template<> + struct minus + { + template + auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) - std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) - std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) - std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + /// One of the @link arithmetic_functors math functors@endlink. + template<> + struct multiplies + { + template + auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) * std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) * std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) * std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + /// One of the @link arithmetic_functors math functors@endlink. + template<> + struct divides + { + template + auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) / std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) / std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) / std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + /// One of the @link arithmetic_functors math functors@endlink. + template<> + struct modulus + { + template + auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) % std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) % std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) % std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + /// One of the @link arithmetic_functors math functors@endlink. + template<> + struct negate + { + template + auto + operator()(_Tp&& __t) const + noexcept(noexcept(-std::forward<_Tp>(__t))) + -> decltype(-std::forward<_Tp>(__t)) + { return -std::forward<_Tp>(__t); } + + typedef __is_transparent is_transparent; + }; +#endif + /** @} */ + + // 20.3.3 comparisons + /** @defgroup comparison_functors Comparison Classes + * @ingroup functors + * + * The library provides six wrapper functors for all the basic comparisons + * in C++, like @c <. + * + * @{ + */ +#if __cplusplus > 201103L + template + struct equal_to; + + template + struct not_equal_to; + + template + struct greater; + + template + struct less; + + template + struct greater_equal; + + template + struct less_equal; +#endif + + /// One of the @link comparison_functors comparison functors@endlink. + template + struct equal_to : public binary_function<_Tp, _Tp, bool> + { + bool + operator()(const _Tp& __x, const _Tp& __y) const + { return __x == __y; } + }; + + /// One of the @link comparison_functors comparison functors@endlink. + template + struct not_equal_to : public binary_function<_Tp, _Tp, bool> + { + bool + operator()(const _Tp& __x, const _Tp& __y) const + { return __x != __y; } + }; + + /// One of the @link comparison_functors comparison functors@endlink. + template + struct greater : public binary_function<_Tp, _Tp, bool> + { + bool + operator()(const _Tp& __x, const _Tp& __y) const + { return __x > __y; } + }; + + /// One of the @link comparison_functors comparison functors@endlink. + template + struct less : public binary_function<_Tp, _Tp, bool> + { + bool + operator()(const _Tp& __x, const _Tp& __y) const + { return __x < __y; } + }; + + /// One of the @link comparison_functors comparison functors@endlink. + template + struct greater_equal : public binary_function<_Tp, _Tp, bool> + { + bool + operator()(const _Tp& __x, const _Tp& __y) const + { return __x >= __y; } + }; + + /// One of the @link comparison_functors comparison functors@endlink. + template + struct less_equal : public binary_function<_Tp, _Tp, bool> + { + bool + operator()(const _Tp& __x, const _Tp& __y) const + { return __x <= __y; } + }; + +#if __cplusplus > 201103L + /// One of the @link comparison_functors comparison functors@endlink. + template<> + struct equal_to + { + template + auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) == std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) == std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) == std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + /// One of the @link comparison_functors comparison functors@endlink. + template<> + struct not_equal_to + { + template + auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) != std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) != std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) != std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + /// One of the @link comparison_functors comparison functors@endlink. + template<> + struct greater + { + template + auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) > std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) > std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) > std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + /// One of the @link comparison_functors comparison functors@endlink. + template<> + struct less + { + template + auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) < std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) < std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) < std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + /// One of the @link comparison_functors comparison functors@endlink. + template<> + struct greater_equal + { + template + auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) >= std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) >= std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) >= std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + /// One of the @link comparison_functors comparison functors@endlink. + template<> + struct less_equal + { + template + auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) <= std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) <= std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) <= std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; +#endif + /** @} */ + + // 20.3.4 logical operations + /** @defgroup logical_functors Boolean Operations Classes + * @ingroup functors + * + * Here are wrapper functors for Boolean operations: @c &&, @c ||, + * and @c !. + * + * @{ + */ +#if __cplusplus > 201103L + template + struct logical_and; + + template + struct logical_or; + + template + struct logical_not; +#endif + + /// One of the @link logical_functors Boolean operations functors@endlink. + template + struct logical_and : public binary_function<_Tp, _Tp, bool> + { + bool + operator()(const _Tp& __x, const _Tp& __y) const + { return __x && __y; } + }; + + /// One of the @link logical_functors Boolean operations functors@endlink. + template + struct logical_or : public binary_function<_Tp, _Tp, bool> + { + bool + operator()(const _Tp& __x, const _Tp& __y) const + { return __x || __y; } + }; + + /// One of the @link logical_functors Boolean operations functors@endlink. + template + struct logical_not : public unary_function<_Tp, bool> + { + bool + operator()(const _Tp& __x) const + { return !__x; } + }; + +#if __cplusplus > 201103L + /// One of the @link logical_functors Boolean operations functors@endlink. + template<> + struct logical_and + { + template + auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) && std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) && std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) && std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + /// One of the @link logical_functors Boolean operations functors@endlink. + template<> + struct logical_or + { + template + auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) || std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) || std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) || std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + /// One of the @link logical_functors Boolean operations functors@endlink. + template<> + struct logical_not + { + template + auto + operator()(_Tp&& __t) const + noexcept(noexcept(!std::forward<_Tp>(__t))) + -> decltype(!std::forward<_Tp>(__t)) + { return !std::forward<_Tp>(__t); } + + typedef __is_transparent is_transparent; + }; +#endif + /** @} */ + +#if __cplusplus > 201103L + template + struct bit_and; + + template + struct bit_or; + + template + struct bit_xor; + + template + struct bit_not; +#endif + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR 660. Missing Bitwise Operations. + template + struct bit_and : public binary_function<_Tp, _Tp, _Tp> + { + _Tp + operator()(const _Tp& __x, const _Tp& __y) const + { return __x & __y; } + }; + + template + struct bit_or : public binary_function<_Tp, _Tp, _Tp> + { + _Tp + operator()(const _Tp& __x, const _Tp& __y) const + { return __x | __y; } + }; + + template + struct bit_xor : public binary_function<_Tp, _Tp, _Tp> + { + _Tp + operator()(const _Tp& __x, const _Tp& __y) const + { return __x ^ __y; } + }; + + template + struct bit_not : public unary_function<_Tp, _Tp> + { + _Tp + operator()(const _Tp& __x) const + { return ~__x; } + }; + +#if __cplusplus > 201103L + template <> + struct bit_and + { + template + auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) & std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) & std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) & std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + template <> + struct bit_or + { + template + auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) | std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) | std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) | std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + template <> + struct bit_xor + { + template + auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) ^ std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + template <> + struct bit_not + { + template + auto + operator()(_Tp&& __t) const + noexcept(noexcept(~std::forward<_Tp>(__t))) + -> decltype(~std::forward<_Tp>(__t)) + { return ~std::forward<_Tp>(__t); } + + typedef __is_transparent is_transparent; + }; +#endif + + // 20.3.5 negators + /** @defgroup negators Negators + * @ingroup functors + * + * The functions @c not1 and @c not2 each take a predicate functor + * and return an instance of @c unary_negate or + * @c binary_negate, respectively. These classes are functors whose + * @c operator() performs the stored predicate function and then returns + * the negation of the result. + * + * For example, given a vector of integers and a trivial predicate, + * \code + * struct IntGreaterThanThree + * : public std::unary_function + * { + * bool operator() (int x) { return x > 3; } + * }; + * + * std::find_if (v.begin(), v.end(), not1(IntGreaterThanThree())); + * \endcode + * The call to @c find_if will locate the first index (i) of @c v for which + * !(v[i] > 3) is true. + * + * The not1/unary_negate combination works on predicates taking a single + * argument. The not2/binary_negate combination works on predicates which + * take two arguments. + * + * @{ + */ + /// One of the @link negators negation functors@endlink. + template + class unary_negate + : public unary_function + { + protected: + _Predicate _M_pred; + + public: + explicit + unary_negate(const _Predicate& __x) : _M_pred(__x) { } + + bool + operator()(const typename _Predicate::argument_type& __x) const + { return !_M_pred(__x); } + }; + + /// One of the @link negators negation functors@endlink. + template + inline unary_negate<_Predicate> + not1(const _Predicate& __pred) + { return unary_negate<_Predicate>(__pred); } + + /// One of the @link negators negation functors@endlink. + template + class binary_negate + : public binary_function + { + protected: + _Predicate _M_pred; + + public: + explicit + binary_negate(const _Predicate& __x) : _M_pred(__x) { } + + bool + operator()(const typename _Predicate::first_argument_type& __x, + const typename _Predicate::second_argument_type& __y) const + { return !_M_pred(__x, __y); } + }; + + /// One of the @link negators negation functors@endlink. + template + inline binary_negate<_Predicate> + not2(const _Predicate& __pred) + { return binary_negate<_Predicate>(__pred); } + /** @} */ + + // 20.3.7 adaptors pointers functions + /** @defgroup pointer_adaptors Adaptors for pointers to functions + * @ingroup functors + * + * The advantage of function objects over pointers to functions is that + * the objects in the standard library declare nested typedefs describing + * their argument and result types with uniform names (e.g., @c result_type + * from the base classes @c unary_function and @c binary_function). + * Sometimes those typedefs are required, not just optional. + * + * Adaptors are provided to turn pointers to unary (single-argument) and + * binary (double-argument) functions into function objects. The + * long-winded functor @c pointer_to_unary_function is constructed with a + * function pointer @c f, and its @c operator() called with argument @c x + * returns @c f(x). The functor @c pointer_to_binary_function does the same + * thing, but with a double-argument @c f and @c operator(). + * + * The function @c ptr_fun takes a pointer-to-function @c f and constructs + * an instance of the appropriate functor. + * + * @{ + */ + /// One of the @link pointer_adaptors adaptors for function pointers@endlink. + template + class pointer_to_unary_function : public unary_function<_Arg, _Result> + { + protected: + _Result (*_M_ptr)(_Arg); + + public: + pointer_to_unary_function() { } + + explicit + pointer_to_unary_function(_Result (*__x)(_Arg)) + : _M_ptr(__x) { } + + _Result + operator()(_Arg __x) const + { return _M_ptr(__x); } + }; + + /// One of the @link pointer_adaptors adaptors for function pointers@endlink. + template + inline pointer_to_unary_function<_Arg, _Result> + ptr_fun(_Result (*__x)(_Arg)) + { return pointer_to_unary_function<_Arg, _Result>(__x); } + + /// One of the @link pointer_adaptors adaptors for function pointers@endlink. + template + class pointer_to_binary_function + : public binary_function<_Arg1, _Arg2, _Result> + { + protected: + _Result (*_M_ptr)(_Arg1, _Arg2); + + public: + pointer_to_binary_function() { } + + explicit + pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2)) + : _M_ptr(__x) { } + + _Result + operator()(_Arg1 __x, _Arg2 __y) const + { return _M_ptr(__x, __y); } + }; + + /// One of the @link pointer_adaptors adaptors for function pointers@endlink. + template + inline pointer_to_binary_function<_Arg1, _Arg2, _Result> + ptr_fun(_Result (*__x)(_Arg1, _Arg2)) + { return pointer_to_binary_function<_Arg1, _Arg2, _Result>(__x); } + /** @} */ + + template + struct _Identity + : public unary_function<_Tp,_Tp> + { + _Tp& + operator()(_Tp& __x) const + { return __x; } + + const _Tp& + operator()(const _Tp& __x) const + { return __x; } + }; + + template + struct _Select1st + : public unary_function<_Pair, typename _Pair::first_type> + { + typename _Pair::first_type& + operator()(_Pair& __x) const + { return __x.first; } + + const typename _Pair::first_type& + operator()(const _Pair& __x) const + { return __x.first; } + +#if __cplusplus >= 201103L + template + typename _Pair2::first_type& + operator()(_Pair2& __x) const + { return __x.first; } + + template + const typename _Pair2::first_type& + operator()(const _Pair2& __x) const + { return __x.first; } +#endif + }; + + template + struct _Select2nd + : public unary_function<_Pair, typename _Pair::second_type> + { + typename _Pair::second_type& + operator()(_Pair& __x) const + { return __x.second; } + + const typename _Pair::second_type& + operator()(const _Pair& __x) const + { return __x.second; } + }; + + // 20.3.8 adaptors pointers members + /** @defgroup memory_adaptors Adaptors for pointers to members + * @ingroup functors + * + * There are a total of 8 = 2^3 function objects in this family. + * (1) Member functions taking no arguments vs member functions taking + * one argument. + * (2) Call through pointer vs call through reference. + * (3) Const vs non-const member function. + * + * All of this complexity is in the function objects themselves. You can + * ignore it by using the helper function mem_fun and mem_fun_ref, + * which create whichever type of adaptor is appropriate. + * + * @{ + */ + /// One of the @link memory_adaptors adaptors for member + /// pointers@endlink. + template + class mem_fun_t : public unary_function<_Tp*, _Ret> + { + public: + explicit + mem_fun_t(_Ret (_Tp::*__pf)()) + : _M_f(__pf) { } + + _Ret + operator()(_Tp* __p) const + { return (__p->*_M_f)(); } + + private: + _Ret (_Tp::*_M_f)(); + }; + + /// One of the @link memory_adaptors adaptors for member + /// pointers@endlink. + template + class const_mem_fun_t : public unary_function + { + public: + explicit + const_mem_fun_t(_Ret (_Tp::*__pf)() const) + : _M_f(__pf) { } + + _Ret + operator()(const _Tp* __p) const + { return (__p->*_M_f)(); } + + private: + _Ret (_Tp::*_M_f)() const; + }; + + /// One of the @link memory_adaptors adaptors for member + /// pointers@endlink. + template + class mem_fun_ref_t : public unary_function<_Tp, _Ret> + { + public: + explicit + mem_fun_ref_t(_Ret (_Tp::*__pf)()) + : _M_f(__pf) { } + + _Ret + operator()(_Tp& __r) const + { return (__r.*_M_f)(); } + + private: + _Ret (_Tp::*_M_f)(); + }; + + /// One of the @link memory_adaptors adaptors for member + /// pointers@endlink. + template + class const_mem_fun_ref_t : public unary_function<_Tp, _Ret> + { + public: + explicit + const_mem_fun_ref_t(_Ret (_Tp::*__pf)() const) + : _M_f(__pf) { } + + _Ret + operator()(const _Tp& __r) const + { return (__r.*_M_f)(); } + + private: + _Ret (_Tp::*_M_f)() const; + }; + + /// One of the @link memory_adaptors adaptors for member + /// pointers@endlink. + template + class mem_fun1_t : public binary_function<_Tp*, _Arg, _Ret> + { + public: + explicit + mem_fun1_t(_Ret (_Tp::*__pf)(_Arg)) + : _M_f(__pf) { } + + _Ret + operator()(_Tp* __p, _Arg __x) const + { return (__p->*_M_f)(__x); } + + private: + _Ret (_Tp::*_M_f)(_Arg); + }; + + /// One of the @link memory_adaptors adaptors for member + /// pointers@endlink. + template + class const_mem_fun1_t : public binary_function + { + public: + explicit + const_mem_fun1_t(_Ret (_Tp::*__pf)(_Arg) const) + : _M_f(__pf) { } + + _Ret + operator()(const _Tp* __p, _Arg __x) const + { return (__p->*_M_f)(__x); } + + private: + _Ret (_Tp::*_M_f)(_Arg) const; + }; + + /// One of the @link memory_adaptors adaptors for member + /// pointers@endlink. + template + class mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret> + { + public: + explicit + mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg)) + : _M_f(__pf) { } + + _Ret + operator()(_Tp& __r, _Arg __x) const + { return (__r.*_M_f)(__x); } + + private: + _Ret (_Tp::*_M_f)(_Arg); + }; + + /// One of the @link memory_adaptors adaptors for member + /// pointers@endlink. + template + class const_mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret> + { + public: + explicit + const_mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg) const) + : _M_f(__pf) { } + + _Ret + operator()(const _Tp& __r, _Arg __x) const + { return (__r.*_M_f)(__x); } + + private: + _Ret (_Tp::*_M_f)(_Arg) const; + }; + + // Mem_fun adaptor helper functions. There are only two: + // mem_fun and mem_fun_ref. + template + inline mem_fun_t<_Ret, _Tp> + mem_fun(_Ret (_Tp::*__f)()) + { return mem_fun_t<_Ret, _Tp>(__f); } + + template + inline const_mem_fun_t<_Ret, _Tp> + mem_fun(_Ret (_Tp::*__f)() const) + { return const_mem_fun_t<_Ret, _Tp>(__f); } + + template + inline mem_fun_ref_t<_Ret, _Tp> + mem_fun_ref(_Ret (_Tp::*__f)()) + { return mem_fun_ref_t<_Ret, _Tp>(__f); } + + template + inline const_mem_fun_ref_t<_Ret, _Tp> + mem_fun_ref(_Ret (_Tp::*__f)() const) + { return const_mem_fun_ref_t<_Ret, _Tp>(__f); } + + template + inline mem_fun1_t<_Ret, _Tp, _Arg> + mem_fun(_Ret (_Tp::*__f)(_Arg)) + { return mem_fun1_t<_Ret, _Tp, _Arg>(__f); } + + template + inline const_mem_fun1_t<_Ret, _Tp, _Arg> + mem_fun(_Ret (_Tp::*__f)(_Arg) const) + { return const_mem_fun1_t<_Ret, _Tp, _Arg>(__f); } + + template + inline mem_fun1_ref_t<_Ret, _Tp, _Arg> + mem_fun_ref(_Ret (_Tp::*__f)(_Arg)) + { return mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); } + + template + inline const_mem_fun1_ref_t<_Ret, _Tp, _Arg> + mem_fun_ref(_Ret (_Tp::*__f)(_Arg) const) + { return const_mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); } + + /** @} */ + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#if (__cplusplus < 201103L) || _GLIBCXX_USE_DEPRECATED +# include +#endif + +#endif /* _STL_FUNCTION_H */ diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stl_heap.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stl_heap.h new file mode 100755 index 0000000..2e1768b --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stl_heap.h @@ -0,0 +1,532 @@ +// Heap implementation -*- C++ -*- + +// Copyright (C) 2001-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/* + * + * Copyright (c) 1994 + * Hewlett-Packard Company + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Hewlett-Packard Company makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + * + * Copyright (c) 1997 + * Silicon Graphics Computer Systems, Inc. + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Silicon Graphics makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + */ + +/** @file bits/stl_heap.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{queue} + */ + +#ifndef _STL_HEAP_H +#define _STL_HEAP_H 1 + +#include +#include +#include + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /** + * @defgroup heap_algorithms Heap + * @ingroup sorting_algorithms + */ + + template + _Distance + __is_heap_until(_RandomAccessIterator __first, _Distance __n, + _Compare __comp) + { + _Distance __parent = 0; + for (_Distance __child = 1; __child < __n; ++__child) + { + if (__comp(__first + __parent, __first + __child)) + return __child; + if ((__child & 1) == 0) + ++__parent; + } + return __n; + } + + // __is_heap, a predicate testing whether or not a range is a heap. + // This function is an extension, not part of the C++ standard. + template + inline bool + __is_heap(_RandomAccessIterator __first, _Distance __n) + { + return std::__is_heap_until(__first, __n, + __gnu_cxx::__ops::__iter_less_iter()) == __n; + } + + template + inline bool + __is_heap(_RandomAccessIterator __first, _Compare __comp, _Distance __n) + { + return std::__is_heap_until(__first, __n, + __gnu_cxx::__ops::__iter_comp_iter(__comp)) == __n; + } + + template + inline bool + __is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) + { return std::__is_heap(__first, std::distance(__first, __last)); } + + template + inline bool + __is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, + _Compare __comp) + { return std::__is_heap(__first, __comp, std::distance(__first, __last)); } + + // Heap-manipulation functions: push_heap, pop_heap, make_heap, sort_heap, + // + is_heap and is_heap_until in C++0x. + + template + void + __push_heap(_RandomAccessIterator __first, + _Distance __holeIndex, _Distance __topIndex, _Tp __value, + _Compare __comp) + { + _Distance __parent = (__holeIndex - 1) / 2; + while (__holeIndex > __topIndex && __comp(__first + __parent, __value)) + { + *(__first + __holeIndex) = _GLIBCXX_MOVE(*(__first + __parent)); + __holeIndex = __parent; + __parent = (__holeIndex - 1) / 2; + } + *(__first + __holeIndex) = _GLIBCXX_MOVE(__value); + } + + /** + * @brief Push an element onto a heap. + * @param __first Start of heap. + * @param __last End of heap + element. + * @ingroup heap_algorithms + * + * This operation pushes the element at last-1 onto the valid heap + * over the range [__first,__last-1). After completion, + * [__first,__last) is a valid heap. + */ + template + inline void + push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) + { + typedef typename iterator_traits<_RandomAccessIterator>::value_type + _ValueType; + typedef typename iterator_traits<_RandomAccessIterator>::difference_type + _DistanceType; + + // concept requirements + __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept< + _RandomAccessIterator>) + __glibcxx_function_requires(_LessThanComparableConcept<_ValueType>) + __glibcxx_requires_valid_range(__first, __last); + __glibcxx_requires_heap(__first, __last - 1); + + _ValueType __value = _GLIBCXX_MOVE(*(__last - 1)); + std::__push_heap(__first, _DistanceType((__last - __first) - 1), + _DistanceType(0), _GLIBCXX_MOVE(__value), + __gnu_cxx::__ops::__iter_less_val()); + } + + /** + * @brief Push an element onto a heap using comparison functor. + * @param __first Start of heap. + * @param __last End of heap + element. + * @param __comp Comparison functor. + * @ingroup heap_algorithms + * + * This operation pushes the element at __last-1 onto the valid + * heap over the range [__first,__last-1). After completion, + * [__first,__last) is a valid heap. Compare operations are + * performed using comp. + */ + template + inline void + push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, + _Compare __comp) + { + typedef typename iterator_traits<_RandomAccessIterator>::value_type + _ValueType; + typedef typename iterator_traits<_RandomAccessIterator>::difference_type + _DistanceType; + + // concept requirements + __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept< + _RandomAccessIterator>) + __glibcxx_requires_valid_range(__first, __last); + __glibcxx_requires_heap_pred(__first, __last - 1, __comp); + + _ValueType __value = _GLIBCXX_MOVE(*(__last - 1)); + std::__push_heap(__first, _DistanceType((__last - __first) - 1), + _DistanceType(0), _GLIBCXX_MOVE(__value), + __gnu_cxx::__ops::__iter_comp_val(__comp)); + } + + template + void + __adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex, + _Distance __len, _Tp __value, _Compare __comp) + { + const _Distance __topIndex = __holeIndex; + _Distance __secondChild = __holeIndex; + while (__secondChild < (__len - 1) / 2) + { + __secondChild = 2 * (__secondChild + 1); + if (__comp(__first + __secondChild, + __first + (__secondChild - 1))) + __secondChild--; + *(__first + __holeIndex) = _GLIBCXX_MOVE(*(__first + __secondChild)); + __holeIndex = __secondChild; + } + if ((__len & 1) == 0 && __secondChild == (__len - 2) / 2) + { + __secondChild = 2 * (__secondChild + 1); + *(__first + __holeIndex) = _GLIBCXX_MOVE(*(__first + + (__secondChild - 1))); + __holeIndex = __secondChild - 1; + } + std::__push_heap(__first, __holeIndex, __topIndex, + _GLIBCXX_MOVE(__value), + __gnu_cxx::__ops::__iter_comp_val(__comp)); + } + + template + inline void + __pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, + _RandomAccessIterator __result, _Compare __comp) + { + typedef typename iterator_traits<_RandomAccessIterator>::value_type + _ValueType; + typedef typename iterator_traits<_RandomAccessIterator>::difference_type + _DistanceType; + + _ValueType __value = _GLIBCXX_MOVE(*__result); + *__result = _GLIBCXX_MOVE(*__first); + std::__adjust_heap(__first, _DistanceType(0), + _DistanceType(__last - __first), + _GLIBCXX_MOVE(__value), __comp); + } + + /** + * @brief Pop an element off a heap. + * @param __first Start of heap. + * @param __last End of heap. + * @pre [__first, __last) is a valid, non-empty range. + * @ingroup heap_algorithms + * + * This operation pops the top of the heap. The elements __first + * and __last-1 are swapped and [__first,__last-1) is made into a + * heap. + */ + template + inline void + pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) + { + typedef typename iterator_traits<_RandomAccessIterator>::value_type + _ValueType; + + // concept requirements + __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept< + _RandomAccessIterator>) + __glibcxx_function_requires(_LessThanComparableConcept<_ValueType>) + __glibcxx_requires_non_empty_range(__first, __last); + __glibcxx_requires_valid_range(__first, __last); + __glibcxx_requires_heap(__first, __last); + + if (__last - __first > 1) + { + --__last; + std::__pop_heap(__first, __last, __last, + __gnu_cxx::__ops::__iter_less_iter()); + } + } + + /** + * @brief Pop an element off a heap using comparison functor. + * @param __first Start of heap. + * @param __last End of heap. + * @param __comp Comparison functor to use. + * @ingroup heap_algorithms + * + * This operation pops the top of the heap. The elements __first + * and __last-1 are swapped and [__first,__last-1) is made into a + * heap. Comparisons are made using comp. + */ + template + inline void + pop_heap(_RandomAccessIterator __first, + _RandomAccessIterator __last, _Compare __comp) + { + // concept requirements + __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept< + _RandomAccessIterator>) + __glibcxx_requires_valid_range(__first, __last); + __glibcxx_requires_non_empty_range(__first, __last); + __glibcxx_requires_heap_pred(__first, __last, __comp); + + if (__last - __first > 1) + { + --__last; + std::__pop_heap(__first, __last, __last, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } + } + + template + void + __make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, + _Compare __comp) + { + typedef typename iterator_traits<_RandomAccessIterator>::value_type + _ValueType; + typedef typename iterator_traits<_RandomAccessIterator>::difference_type + _DistanceType; + + if (__last - __first < 2) + return; + + const _DistanceType __len = __last - __first; + _DistanceType __parent = (__len - 2) / 2; + while (true) + { + _ValueType __value = _GLIBCXX_MOVE(*(__first + __parent)); + std::__adjust_heap(__first, __parent, __len, _GLIBCXX_MOVE(__value), + __comp); + if (__parent == 0) + return; + __parent--; + } + } + + /** + * @brief Construct a heap over a range. + * @param __first Start of heap. + * @param __last End of heap. + * @ingroup heap_algorithms + * + * This operation makes the elements in [__first,__last) into a heap. + */ + template + inline void + make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) + { + // concept requirements + __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept< + _RandomAccessIterator>) + __glibcxx_function_requires(_LessThanComparableConcept< + typename iterator_traits<_RandomAccessIterator>::value_type>) + __glibcxx_requires_valid_range(__first, __last); + + std::__make_heap(__first, __last, + __gnu_cxx::__ops::__iter_less_iter()); + } + + /** + * @brief Construct a heap over a range using comparison functor. + * @param __first Start of heap. + * @param __last End of heap. + * @param __comp Comparison functor to use. + * @ingroup heap_algorithms + * + * This operation makes the elements in [__first,__last) into a heap. + * Comparisons are made using __comp. + */ + template + inline void + make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, + _Compare __comp) + { + // concept requirements + __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept< + _RandomAccessIterator>) + __glibcxx_requires_valid_range(__first, __last); + + std::__make_heap(__first, __last, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } + + template + void + __sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, + _Compare __comp) + { + while (__last - __first > 1) + { + --__last; + std::__pop_heap(__first, __last, __last, __comp); + } + } + + /** + * @brief Sort a heap. + * @param __first Start of heap. + * @param __last End of heap. + * @ingroup heap_algorithms + * + * This operation sorts the valid heap in the range [__first,__last). + */ + template + inline void + sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) + { + // concept requirements + __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept< + _RandomAccessIterator>) + __glibcxx_function_requires(_LessThanComparableConcept< + typename iterator_traits<_RandomAccessIterator>::value_type>) + __glibcxx_requires_valid_range(__first, __last); + __glibcxx_requires_heap(__first, __last); + + std::__sort_heap(__first, __last, + __gnu_cxx::__ops::__iter_less_iter()); + } + + /** + * @brief Sort a heap using comparison functor. + * @param __first Start of heap. + * @param __last End of heap. + * @param __comp Comparison functor to use. + * @ingroup heap_algorithms + * + * This operation sorts the valid heap in the range [__first,__last). + * Comparisons are made using __comp. + */ + template + inline void + sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, + _Compare __comp) + { + // concept requirements + __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept< + _RandomAccessIterator>) + __glibcxx_requires_valid_range(__first, __last); + __glibcxx_requires_heap_pred(__first, __last, __comp); + + std::__sort_heap(__first, __last, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } + +#if __cplusplus >= 201103L + /** + * @brief Search the end of a heap. + * @param __first Start of range. + * @param __last End of range. + * @return An iterator pointing to the first element not in the heap. + * @ingroup heap_algorithms + * + * This operation returns the last iterator i in [__first, __last) for which + * the range [__first, i) is a heap. + */ + template + inline _RandomAccessIterator + is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last) + { + // concept requirements + __glibcxx_function_requires(_RandomAccessIteratorConcept< + _RandomAccessIterator>) + __glibcxx_function_requires(_LessThanComparableConcept< + typename iterator_traits<_RandomAccessIterator>::value_type>) + __glibcxx_requires_valid_range(__first, __last); + + return __first + + std::__is_heap_until(__first, std::distance(__first, __last), + __gnu_cxx::__ops::__iter_less_iter()); + } + + /** + * @brief Search the end of a heap using comparison functor. + * @param __first Start of range. + * @param __last End of range. + * @param __comp Comparison functor to use. + * @return An iterator pointing to the first element not in the heap. + * @ingroup heap_algorithms + * + * This operation returns the last iterator i in [__first, __last) for which + * the range [__first, i) is a heap. Comparisons are made using __comp. + */ + template + inline _RandomAccessIterator + is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last, + _Compare __comp) + { + // concept requirements + __glibcxx_function_requires(_RandomAccessIteratorConcept< + _RandomAccessIterator>) + __glibcxx_requires_valid_range(__first, __last); + + return __first + + std::__is_heap_until(__first, std::distance(__first, __last), + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } + + /** + * @brief Determines whether a range is a heap. + * @param __first Start of range. + * @param __last End of range. + * @return True if range is a heap, false otherwise. + * @ingroup heap_algorithms + */ + template + inline bool + is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) + { return std::is_heap_until(__first, __last) == __last; } + + /** + * @brief Determines whether a range is a heap using comparison functor. + * @param __first Start of range. + * @param __last End of range. + * @param __comp Comparison functor to use. + * @return True if range is a heap, false otherwise. + * @ingroup heap_algorithms + */ + template + inline bool + is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, + _Compare __comp) + { return std::is_heap_until(__first, __last, __comp) == __last; } +#endif + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif /* _STL_HEAP_H */ diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stl_iterator.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stl_iterator.h new file mode 100755 index 0000000..aa3581e --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stl_iterator.h @@ -0,0 +1,1165 @@ +// Iterators -*- C++ -*- + +// Copyright (C) 2001-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/* + * + * Copyright (c) 1994 + * Hewlett-Packard Company + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Hewlett-Packard Company makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + * + * + * Copyright (c) 1996-1998 + * Silicon Graphics Computer Systems, Inc. + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Silicon Graphics makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + */ + +/** @file bits/stl_iterator.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{iterator} + * + * This file implements reverse_iterator, back_insert_iterator, + * front_insert_iterator, insert_iterator, __normal_iterator, and their + * supporting functions and overloaded operators. + */ + +#ifndef _STL_ITERATOR_H +#define _STL_ITERATOR_H 1 + +#include +#include +#include +#include + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /** + * @addtogroup iterators + * @{ + */ + + // 24.4.1 Reverse iterators + /** + * Bidirectional and random access iterators have corresponding reverse + * %iterator adaptors that iterate through the data structure in the + * opposite direction. They have the same signatures as the corresponding + * iterators. The fundamental relation between a reverse %iterator and its + * corresponding %iterator @c i is established by the identity: + * @code + * &*(reverse_iterator(i)) == &*(i - 1) + * @endcode + * + * This mapping is dictated by the fact that while there is always a + * pointer past the end of an array, there might not be a valid pointer + * before the beginning of an array. [24.4.1]/1,2 + * + * Reverse iterators can be tricky and surprising at first. Their + * semantics make sense, however, and the trickiness is a side effect of + * the requirement that the iterators must be safe. + */ + template + class reverse_iterator + : public iterator::iterator_category, + typename iterator_traits<_Iterator>::value_type, + typename iterator_traits<_Iterator>::difference_type, + typename iterator_traits<_Iterator>::pointer, + typename iterator_traits<_Iterator>::reference> + { + protected: + _Iterator current; + + typedef iterator_traits<_Iterator> __traits_type; + + public: + typedef _Iterator iterator_type; + typedef typename __traits_type::difference_type difference_type; + typedef typename __traits_type::pointer pointer; + typedef typename __traits_type::reference reference; + + /** + * The default constructor value-initializes member @p current. + * If it is a pointer, that means it is zero-initialized. + */ + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 235 No specification of default ctor for reverse_iterator + reverse_iterator() : current() { } + + /** + * This %iterator will move in the opposite direction that @p x does. + */ + explicit + reverse_iterator(iterator_type __x) : current(__x) { } + + /** + * The copy constructor is normal. + */ + reverse_iterator(const reverse_iterator& __x) + : current(__x.current) { } + + /** + * A %reverse_iterator across other types can be copied if the + * underlying %iterator can be converted to the type of @c current. + */ + template + reverse_iterator(const reverse_iterator<_Iter>& __x) + : current(__x.base()) { } + + /** + * @return @c current, the %iterator used for underlying work. + */ + iterator_type + base() const + { return current; } + + /** + * @return A reference to the value at @c --current + * + * This requires that @c --current is dereferenceable. + * + * @warning This implementation requires that for an iterator of the + * underlying iterator type, @c x, a reference obtained by + * @c *x remains valid after @c x has been modified or + * destroyed. This is a bug: http://gcc.gnu.org/PR51823 + */ + reference + operator*() const + { + _Iterator __tmp = current; + return *--__tmp; + } + + /** + * @return A pointer to the value at @c --current + * + * This requires that @c --current is dereferenceable. + */ + pointer + operator->() const + { return &(operator*()); } + + /** + * @return @c *this + * + * Decrements the underlying iterator. + */ + reverse_iterator& + operator++() + { + --current; + return *this; + } + + /** + * @return The original value of @c *this + * + * Decrements the underlying iterator. + */ + reverse_iterator + operator++(int) + { + reverse_iterator __tmp = *this; + --current; + return __tmp; + } + + /** + * @return @c *this + * + * Increments the underlying iterator. + */ + reverse_iterator& + operator--() + { + ++current; + return *this; + } + + /** + * @return A reverse_iterator with the previous value of @c *this + * + * Increments the underlying iterator. + */ + reverse_iterator + operator--(int) + { + reverse_iterator __tmp = *this; + ++current; + return __tmp; + } + + /** + * @return A reverse_iterator that refers to @c current - @a __n + * + * The underlying iterator must be a Random Access Iterator. + */ + reverse_iterator + operator+(difference_type __n) const + { return reverse_iterator(current - __n); } + + /** + * @return *this + * + * Moves the underlying iterator backwards @a __n steps. + * The underlying iterator must be a Random Access Iterator. + */ + reverse_iterator& + operator+=(difference_type __n) + { + current -= __n; + return *this; + } + + /** + * @return A reverse_iterator that refers to @c current - @a __n + * + * The underlying iterator must be a Random Access Iterator. + */ + reverse_iterator + operator-(difference_type __n) const + { return reverse_iterator(current + __n); } + + /** + * @return *this + * + * Moves the underlying iterator forwards @a __n steps. + * The underlying iterator must be a Random Access Iterator. + */ + reverse_iterator& + operator-=(difference_type __n) + { + current += __n; + return *this; + } + + /** + * @return The value at @c current - @a __n - 1 + * + * The underlying iterator must be a Random Access Iterator. + */ + reference + operator[](difference_type __n) const + { return *(*this + __n); } + }; + + //@{ + /** + * @param __x A %reverse_iterator. + * @param __y A %reverse_iterator. + * @return A simple bool. + * + * Reverse iterators forward many operations to their underlying base() + * iterators. Others are implemented in terms of one another. + * + */ + template + inline bool + operator==(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return __x.base() == __y.base(); } + + template + inline bool + operator<(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return __y.base() < __x.base(); } + + template + inline bool + operator!=(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return !(__x == __y); } + + template + inline bool + operator>(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return __y < __x; } + + template + inline bool + operator<=(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return !(__y < __x); } + + template + inline bool + operator>=(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return !(__x < __y); } + + template + inline typename reverse_iterator<_Iterator>::difference_type + operator-(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return __y.base() - __x.base(); } + + template + inline reverse_iterator<_Iterator> + operator+(typename reverse_iterator<_Iterator>::difference_type __n, + const reverse_iterator<_Iterator>& __x) + { return reverse_iterator<_Iterator>(__x.base() - __n); } + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR 280. Comparison of reverse_iterator to const reverse_iterator. + template + inline bool + operator==(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __x.base() == __y.base(); } + + template + inline bool + operator<(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __y.base() < __x.base(); } + + template + inline bool + operator!=(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return !(__x == __y); } + + template + inline bool + operator>(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __y < __x; } + + template + inline bool + operator<=(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return !(__y < __x); } + + template + inline bool + operator>=(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return !(__x < __y); } + + template +#if __cplusplus >= 201103L + // DR 685. + inline auto + operator-(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + -> decltype(__y.base() - __x.base()) +#else + inline typename reverse_iterator<_IteratorL>::difference_type + operator-(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) +#endif + { return __y.base() - __x.base(); } + //@} + + // 24.4.2.2.1 back_insert_iterator + /** + * @brief Turns assignment into insertion. + * + * These are output iterators, constructed from a container-of-T. + * Assigning a T to the iterator appends it to the container using + * push_back. + * + * Tip: Using the back_inserter function to create these iterators can + * save typing. + */ + template + class back_insert_iterator + : public iterator + { + protected: + _Container* container; + + public: + /// A nested typedef for the type of whatever container you used. + typedef _Container container_type; + + /// The only way to create this %iterator is with a container. + explicit + back_insert_iterator(_Container& __x) : container(&__x) { } + + /** + * @param __value An instance of whatever type + * container_type::const_reference is; presumably a + * reference-to-const T for container. + * @return This %iterator, for chained operations. + * + * This kind of %iterator doesn't really have a @a position in the + * container (you can think of the position as being permanently at + * the end, if you like). Assigning a value to the %iterator will + * always append the value to the end of the container. + */ +#if __cplusplus < 201103L + back_insert_iterator& + operator=(typename _Container::const_reference __value) + { + container->push_back(__value); + return *this; + } +#else + back_insert_iterator& + operator=(const typename _Container::value_type& __value) + { + container->push_back(__value); + return *this; + } + + back_insert_iterator& + operator=(typename _Container::value_type&& __value) + { + container->push_back(std::move(__value)); + return *this; + } +#endif + + /// Simply returns *this. + back_insert_iterator& + operator*() + { return *this; } + + /// Simply returns *this. (This %iterator does not @a move.) + back_insert_iterator& + operator++() + { return *this; } + + /// Simply returns *this. (This %iterator does not @a move.) + back_insert_iterator + operator++(int) + { return *this; } + }; + + /** + * @param __x A container of arbitrary type. + * @return An instance of back_insert_iterator working on @p __x. + * + * This wrapper function helps in creating back_insert_iterator instances. + * Typing the name of the %iterator requires knowing the precise full + * type of the container, which can be tedious and impedes generic + * programming. Using this function lets you take advantage of automatic + * template parameter deduction, making the compiler match the correct + * types for you. + */ + template + inline back_insert_iterator<_Container> + back_inserter(_Container& __x) + { return back_insert_iterator<_Container>(__x); } + + /** + * @brief Turns assignment into insertion. + * + * These are output iterators, constructed from a container-of-T. + * Assigning a T to the iterator prepends it to the container using + * push_front. + * + * Tip: Using the front_inserter function to create these iterators can + * save typing. + */ + template + class front_insert_iterator + : public iterator + { + protected: + _Container* container; + + public: + /// A nested typedef for the type of whatever container you used. + typedef _Container container_type; + + /// The only way to create this %iterator is with a container. + explicit front_insert_iterator(_Container& __x) : container(&__x) { } + + /** + * @param __value An instance of whatever type + * container_type::const_reference is; presumably a + * reference-to-const T for container. + * @return This %iterator, for chained operations. + * + * This kind of %iterator doesn't really have a @a position in the + * container (you can think of the position as being permanently at + * the front, if you like). Assigning a value to the %iterator will + * always prepend the value to the front of the container. + */ +#if __cplusplus < 201103L + front_insert_iterator& + operator=(typename _Container::const_reference __value) + { + container->push_front(__value); + return *this; + } +#else + front_insert_iterator& + operator=(const typename _Container::value_type& __value) + { + container->push_front(__value); + return *this; + } + + front_insert_iterator& + operator=(typename _Container::value_type&& __value) + { + container->push_front(std::move(__value)); + return *this; + } +#endif + + /// Simply returns *this. + front_insert_iterator& + operator*() + { return *this; } + + /// Simply returns *this. (This %iterator does not @a move.) + front_insert_iterator& + operator++() + { return *this; } + + /// Simply returns *this. (This %iterator does not @a move.) + front_insert_iterator + operator++(int) + { return *this; } + }; + + /** + * @param __x A container of arbitrary type. + * @return An instance of front_insert_iterator working on @p x. + * + * This wrapper function helps in creating front_insert_iterator instances. + * Typing the name of the %iterator requires knowing the precise full + * type of the container, which can be tedious and impedes generic + * programming. Using this function lets you take advantage of automatic + * template parameter deduction, making the compiler match the correct + * types for you. + */ + template + inline front_insert_iterator<_Container> + front_inserter(_Container& __x) + { return front_insert_iterator<_Container>(__x); } + + /** + * @brief Turns assignment into insertion. + * + * These are output iterators, constructed from a container-of-T. + * Assigning a T to the iterator inserts it in the container at the + * %iterator's position, rather than overwriting the value at that + * position. + * + * (Sequences will actually insert a @e copy of the value before the + * %iterator's position.) + * + * Tip: Using the inserter function to create these iterators can + * save typing. + */ + template + class insert_iterator + : public iterator + { + protected: + _Container* container; + typename _Container::iterator iter; + + public: + /// A nested typedef for the type of whatever container you used. + typedef _Container container_type; + + /** + * The only way to create this %iterator is with a container and an + * initial position (a normal %iterator into the container). + */ + insert_iterator(_Container& __x, typename _Container::iterator __i) + : container(&__x), iter(__i) {} + + /** + * @param __value An instance of whatever type + * container_type::const_reference is; presumably a + * reference-to-const T for container. + * @return This %iterator, for chained operations. + * + * This kind of %iterator maintains its own position in the + * container. Assigning a value to the %iterator will insert the + * value into the container at the place before the %iterator. + * + * The position is maintained such that subsequent assignments will + * insert values immediately after one another. For example, + * @code + * // vector v contains A and Z + * + * insert_iterator i (v, ++v.begin()); + * i = 1; + * i = 2; + * i = 3; + * + * // vector v contains A, 1, 2, 3, and Z + * @endcode + */ +#if __cplusplus < 201103L + insert_iterator& + operator=(typename _Container::const_reference __value) + { + iter = container->insert(iter, __value); + ++iter; + return *this; + } +#else + insert_iterator& + operator=(const typename _Container::value_type& __value) + { + iter = container->insert(iter, __value); + ++iter; + return *this; + } + + insert_iterator& + operator=(typename _Container::value_type&& __value) + { + iter = container->insert(iter, std::move(__value)); + ++iter; + return *this; + } +#endif + + /// Simply returns *this. + insert_iterator& + operator*() + { return *this; } + + /// Simply returns *this. (This %iterator does not @a move.) + insert_iterator& + operator++() + { return *this; } + + /// Simply returns *this. (This %iterator does not @a move.) + insert_iterator& + operator++(int) + { return *this; } + }; + + /** + * @param __x A container of arbitrary type. + * @return An instance of insert_iterator working on @p __x. + * + * This wrapper function helps in creating insert_iterator instances. + * Typing the name of the %iterator requires knowing the precise full + * type of the container, which can be tedious and impedes generic + * programming. Using this function lets you take advantage of automatic + * template parameter deduction, making the compiler match the correct + * types for you. + */ + template + inline insert_iterator<_Container> + inserter(_Container& __x, _Iterator __i) + { + return insert_iterator<_Container>(__x, + typename _Container::iterator(__i)); + } + + // @} group iterators + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +namespace __gnu_cxx _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + // This iterator adapter is @a normal in the sense that it does not + // change the semantics of any of the operators of its iterator + // parameter. Its primary purpose is to convert an iterator that is + // not a class, e.g. a pointer, into an iterator that is a class. + // The _Container parameter exists solely so that different containers + // using this template can instantiate different types, even if the + // _Iterator parameter is the same. + using std::iterator_traits; + using std::iterator; + template + class __normal_iterator + { + protected: + _Iterator _M_current; + + typedef iterator_traits<_Iterator> __traits_type; + + public: + typedef _Iterator iterator_type; + typedef typename __traits_type::iterator_category iterator_category; + typedef typename __traits_type::value_type value_type; + typedef typename __traits_type::difference_type difference_type; + typedef typename __traits_type::reference reference; + typedef typename __traits_type::pointer pointer; + + _GLIBCXX_CONSTEXPR __normal_iterator() _GLIBCXX_NOEXCEPT + : _M_current(_Iterator()) { } + + explicit + __normal_iterator(const _Iterator& __i) _GLIBCXX_NOEXCEPT + : _M_current(__i) { } + + // Allow iterator to const_iterator conversion + template + __normal_iterator(const __normal_iterator<_Iter, + typename __enable_if< + (std::__are_same<_Iter, typename _Container::pointer>::__value), + _Container>::__type>& __i) _GLIBCXX_NOEXCEPT + : _M_current(__i.base()) { } + + // Forward iterator requirements + reference + operator*() const _GLIBCXX_NOEXCEPT + { return *_M_current; } + + pointer + operator->() const _GLIBCXX_NOEXCEPT + { return _M_current; } + + __normal_iterator& + operator++() _GLIBCXX_NOEXCEPT + { + ++_M_current; + return *this; + } + + __normal_iterator + operator++(int) _GLIBCXX_NOEXCEPT + { return __normal_iterator(_M_current++); } + + // Bidirectional iterator requirements + __normal_iterator& + operator--() _GLIBCXX_NOEXCEPT + { + --_M_current; + return *this; + } + + __normal_iterator + operator--(int) _GLIBCXX_NOEXCEPT + { return __normal_iterator(_M_current--); } + + // Random access iterator requirements + reference + operator[](difference_type __n) const _GLIBCXX_NOEXCEPT + { return _M_current[__n]; } + + __normal_iterator& + operator+=(difference_type __n) _GLIBCXX_NOEXCEPT + { _M_current += __n; return *this; } + + __normal_iterator + operator+(difference_type __n) const _GLIBCXX_NOEXCEPT + { return __normal_iterator(_M_current + __n); } + + __normal_iterator& + operator-=(difference_type __n) _GLIBCXX_NOEXCEPT + { _M_current -= __n; return *this; } + + __normal_iterator + operator-(difference_type __n) const _GLIBCXX_NOEXCEPT + { return __normal_iterator(_M_current - __n); } + + const _Iterator& + base() const _GLIBCXX_NOEXCEPT + { return _M_current; } + }; + + // Note: In what follows, the left- and right-hand-side iterators are + // allowed to vary in types (conceptually in cv-qualification) so that + // comparison between cv-qualified and non-cv-qualified iterators be + // valid. However, the greedy and unfriendly operators in std::rel_ops + // will make overload resolution ambiguous (when in scope) if we don't + // provide overloads whose operands are of the same type. Can someone + // remind me what generic programming is about? -- Gaby + + // Forward iterator requirements + template + inline bool + operator==(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + _GLIBCXX_NOEXCEPT + { return __lhs.base() == __rhs.base(); } + + template + inline bool + operator==(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + _GLIBCXX_NOEXCEPT + { return __lhs.base() == __rhs.base(); } + + template + inline bool + operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + _GLIBCXX_NOEXCEPT + { return __lhs.base() != __rhs.base(); } + + template + inline bool + operator!=(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + _GLIBCXX_NOEXCEPT + { return __lhs.base() != __rhs.base(); } + + // Random access iterator requirements + template + inline bool + operator<(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + _GLIBCXX_NOEXCEPT + { return __lhs.base() < __rhs.base(); } + + template + inline bool + operator<(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + _GLIBCXX_NOEXCEPT + { return __lhs.base() < __rhs.base(); } + + template + inline bool + operator>(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + _GLIBCXX_NOEXCEPT + { return __lhs.base() > __rhs.base(); } + + template + inline bool + operator>(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + _GLIBCXX_NOEXCEPT + { return __lhs.base() > __rhs.base(); } + + template + inline bool + operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + _GLIBCXX_NOEXCEPT + { return __lhs.base() <= __rhs.base(); } + + template + inline bool + operator<=(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + _GLIBCXX_NOEXCEPT + { return __lhs.base() <= __rhs.base(); } + + template + inline bool + operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + _GLIBCXX_NOEXCEPT + { return __lhs.base() >= __rhs.base(); } + + template + inline bool + operator>=(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + _GLIBCXX_NOEXCEPT + { return __lhs.base() >= __rhs.base(); } + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // According to the resolution of DR179 not only the various comparison + // operators but also operator- must accept mixed iterator/const_iterator + // parameters. + template +#if __cplusplus >= 201103L + // DR 685. + inline auto + operator-(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) noexcept + -> decltype(__lhs.base() - __rhs.base()) +#else + inline typename __normal_iterator<_IteratorL, _Container>::difference_type + operator-(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) +#endif + { return __lhs.base() - __rhs.base(); } + + template + inline typename __normal_iterator<_Iterator, _Container>::difference_type + operator-(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + _GLIBCXX_NOEXCEPT + { return __lhs.base() - __rhs.base(); } + + template + inline __normal_iterator<_Iterator, _Container> + operator+(typename __normal_iterator<_Iterator, _Container>::difference_type + __n, const __normal_iterator<_Iterator, _Container>& __i) + _GLIBCXX_NOEXCEPT + { return __normal_iterator<_Iterator, _Container>(__i.base() + __n); } + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#if __cplusplus >= 201103L + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /** + * @addtogroup iterators + * @{ + */ + + // 24.4.3 Move iterators + /** + * Class template move_iterator is an iterator adapter with the same + * behavior as the underlying iterator except that its dereference + * operator implicitly converts the value returned by the underlying + * iterator's dereference operator to an rvalue reference. Some + * generic algorithms can be called with move iterators to replace + * copying with moving. + */ + template + class move_iterator + { + protected: + _Iterator _M_current; + + typedef iterator_traits<_Iterator> __traits_type; + + public: + typedef _Iterator iterator_type; + typedef typename __traits_type::iterator_category iterator_category; + typedef typename __traits_type::value_type value_type; + typedef typename __traits_type::difference_type difference_type; + // NB: DR 680. + typedef _Iterator pointer; + typedef value_type&& reference; + + move_iterator() + : _M_current() { } + + explicit + move_iterator(iterator_type __i) + : _M_current(__i) { } + + template + move_iterator(const move_iterator<_Iter>& __i) + : _M_current(__i.base()) { } + + iterator_type + base() const + { return _M_current; } + + reference + operator*() const + { return std::move(*_M_current); } + + pointer + operator->() const + { return _M_current; } + + move_iterator& + operator++() + { + ++_M_current; + return *this; + } + + move_iterator + operator++(int) + { + move_iterator __tmp = *this; + ++_M_current; + return __tmp; + } + + move_iterator& + operator--() + { + --_M_current; + return *this; + } + + move_iterator + operator--(int) + { + move_iterator __tmp = *this; + --_M_current; + return __tmp; + } + + move_iterator + operator+(difference_type __n) const + { return move_iterator(_M_current + __n); } + + move_iterator& + operator+=(difference_type __n) + { + _M_current += __n; + return *this; + } + + move_iterator + operator-(difference_type __n) const + { return move_iterator(_M_current - __n); } + + move_iterator& + operator-=(difference_type __n) + { + _M_current -= __n; + return *this; + } + + reference + operator[](difference_type __n) const + { return std::move(_M_current[__n]); } + }; + + // Note: See __normal_iterator operators note from Gaby to understand + // why there are always 2 versions for most of the move_iterator + // operators. + template + inline bool + operator==(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + { return __x.base() == __y.base(); } + + template + inline bool + operator==(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return __x.base() == __y.base(); } + + template + inline bool + operator!=(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + { return !(__x == __y); } + + template + inline bool + operator!=(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return !(__x == __y); } + + template + inline bool + operator<(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + { return __x.base() < __y.base(); } + + template + inline bool + operator<(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return __x.base() < __y.base(); } + + template + inline bool + operator<=(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + { return !(__y < __x); } + + template + inline bool + operator<=(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return !(__y < __x); } + + template + inline bool + operator>(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + { return __y < __x; } + + template + inline bool + operator>(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return __y < __x; } + + template + inline bool + operator>=(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + { return !(__x < __y); } + + template + inline bool + operator>=(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return !(__x < __y); } + + // DR 685. + template + inline auto + operator-(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + -> decltype(__x.base() - __y.base()) + { return __x.base() - __y.base(); } + + template + inline auto + operator-(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + -> decltype(__x.base() - __y.base()) + { return __x.base() - __y.base(); } + + template + inline move_iterator<_Iterator> + operator+(typename move_iterator<_Iterator>::difference_type __n, + const move_iterator<_Iterator>& __x) + { return __x + __n; } + + template + inline move_iterator<_Iterator> + make_move_iterator(_Iterator __i) + { return move_iterator<_Iterator>(__i); } + + template::value_type>::value, + _Iterator, move_iterator<_Iterator>>::type> + inline _ReturnType + __make_move_if_noexcept_iterator(_Iterator __i) + { return _ReturnType(__i); } + + // @} group iterators + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#define _GLIBCXX_MAKE_MOVE_ITERATOR(_Iter) std::make_move_iterator(_Iter) +#define _GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(_Iter) \ + std::__make_move_if_noexcept_iterator(_Iter) +#else +#define _GLIBCXX_MAKE_MOVE_ITERATOR(_Iter) (_Iter) +#define _GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(_Iter) (_Iter) +#endif // C++11 + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stl_iterator_base_funcs.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stl_iterator_base_funcs.h new file mode 100755 index 0000000..6183a25 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stl_iterator_base_funcs.h @@ -0,0 +1,205 @@ +// Functions used by iterators -*- C++ -*- + +// Copyright (C) 2001-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/* + * + * Copyright (c) 1994 + * Hewlett-Packard Company + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Hewlett-Packard Company makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + * + * + * Copyright (c) 1996-1998 + * Silicon Graphics Computer Systems, Inc. + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Silicon Graphics makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + */ + +/** @file bits/stl_iterator_base_funcs.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{iterator} + * + * This file contains all of the general iterator-related utility + * functions, such as distance() and advance(). + */ + +#ifndef _STL_ITERATOR_BASE_FUNCS_H +#define _STL_ITERATOR_BASE_FUNCS_H 1 + +#pragma GCC system_header + +#include +#include + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + template + inline typename iterator_traits<_InputIterator>::difference_type + __distance(_InputIterator __first, _InputIterator __last, + input_iterator_tag) + { + // concept requirements + __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>) + + typename iterator_traits<_InputIterator>::difference_type __n = 0; + while (__first != __last) + { + ++__first; + ++__n; + } + return __n; + } + + template + inline typename iterator_traits<_RandomAccessIterator>::difference_type + __distance(_RandomAccessIterator __first, _RandomAccessIterator __last, + random_access_iterator_tag) + { + // concept requirements + __glibcxx_function_requires(_RandomAccessIteratorConcept< + _RandomAccessIterator>) + return __last - __first; + } + + /** + * @brief A generalization of pointer arithmetic. + * @param __first An input iterator. + * @param __last An input iterator. + * @return The distance between them. + * + * Returns @c n such that __first + n == __last. This requires + * that @p __last must be reachable from @p __first. Note that @c + * n may be negative. + * + * For random access iterators, this uses their @c + and @c - operations + * and are constant time. For other %iterator classes they are linear time. + */ + template + inline typename iterator_traits<_InputIterator>::difference_type + distance(_InputIterator __first, _InputIterator __last) + { + // concept requirements -- taken care of in __distance + return std::__distance(__first, __last, + std::__iterator_category(__first)); + } + + template + inline void + __advance(_InputIterator& __i, _Distance __n, input_iterator_tag) + { + // concept requirements + __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>) + _GLIBCXX_DEBUG_ASSERT(__n >= 0); + while (__n--) + ++__i; + } + + template + inline void + __advance(_BidirectionalIterator& __i, _Distance __n, + bidirectional_iterator_tag) + { + // concept requirements + __glibcxx_function_requires(_BidirectionalIteratorConcept< + _BidirectionalIterator>) + if (__n > 0) + while (__n--) + ++__i; + else + while (__n++) + --__i; + } + + template + inline void + __advance(_RandomAccessIterator& __i, _Distance __n, + random_access_iterator_tag) + { + // concept requirements + __glibcxx_function_requires(_RandomAccessIteratorConcept< + _RandomAccessIterator>) + __i += __n; + } + + /** + * @brief A generalization of pointer arithmetic. + * @param __i An input iterator. + * @param __n The @a delta by which to change @p __i. + * @return Nothing. + * + * This increments @p i by @p n. For bidirectional and random access + * iterators, @p __n may be negative, in which case @p __i is decremented. + * + * For random access iterators, this uses their @c + and @c - operations + * and are constant time. For other %iterator classes they are linear time. + */ + template + inline void + advance(_InputIterator& __i, _Distance __n) + { + // concept requirements -- taken care of in __advance + typename iterator_traits<_InputIterator>::difference_type __d = __n; + std::__advance(__i, __d, std::__iterator_category(__i)); + } + +#if __cplusplus >= 201103L + + template + inline _ForwardIterator + next(_ForwardIterator __x, typename + iterator_traits<_ForwardIterator>::difference_type __n = 1) + { + std::advance(__x, __n); + return __x; + } + + template + inline _BidirectionalIterator + prev(_BidirectionalIterator __x, typename + iterator_traits<_BidirectionalIterator>::difference_type __n = 1) + { + std::advance(__x, -__n); + return __x; + } + +#endif // C++11 + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif /* _STL_ITERATOR_BASE_FUNCS_H */ diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stl_iterator_base_types.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stl_iterator_base_types.h new file mode 100755 index 0000000..bd55987 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stl_iterator_base_types.h @@ -0,0 +1,236 @@ +// Types used in iterator implementation -*- C++ -*- + +// Copyright (C) 2001-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/* + * + * Copyright (c) 1994 + * Hewlett-Packard Company + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Hewlett-Packard Company makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + * + * + * Copyright (c) 1996-1998 + * Silicon Graphics Computer Systems, Inc. + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Silicon Graphics makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + */ + +/** @file bits/stl_iterator_base_types.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{iterator} + * + * This file contains all of the general iterator-related utility types, + * such as iterator_traits and struct iterator. + */ + +#ifndef _STL_ITERATOR_BASE_TYPES_H +#define _STL_ITERATOR_BASE_TYPES_H 1 + +#pragma GCC system_header + +#include + +#if __cplusplus >= 201103L +# include // For _GLIBCXX_HAS_NESTED_TYPE, is_convertible +#endif + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /** + * @defgroup iterators Iterators + * Abstractions for uniform iterating through various underlying types. + */ + //@{ + + /** + * @defgroup iterator_tags Iterator Tags + * These are empty types, used to distinguish different iterators. The + * distinction is not made by what they contain, but simply by what they + * are. Different underlying algorithms can then be used based on the + * different operations supported by different iterator types. + */ + //@{ + /// Marking input iterators. + struct input_iterator_tag { }; + + /// Marking output iterators. + struct output_iterator_tag { }; + + /// Forward iterators support a superset of input iterator operations. + struct forward_iterator_tag : public input_iterator_tag { }; + + /// Bidirectional iterators support a superset of forward iterator + /// operations. + struct bidirectional_iterator_tag : public forward_iterator_tag { }; + + /// Random-access iterators support a superset of bidirectional + /// iterator operations. + struct random_access_iterator_tag : public bidirectional_iterator_tag { }; + //@} + + /** + * @brief Common %iterator class. + * + * This class does nothing but define nested typedefs. %Iterator classes + * can inherit from this class to save some work. The typedefs are then + * used in specializations and overloading. + * + * In particular, there are no default implementations of requirements + * such as @c operator++ and the like. (How could there be?) + */ + template + struct iterator + { + /// One of the @link iterator_tags tag types@endlink. + typedef _Category iterator_category; + /// The type "pointed to" by the iterator. + typedef _Tp value_type; + /// Distance between iterators is represented as this type. + typedef _Distance difference_type; + /// This type represents a pointer-to-value_type. + typedef _Pointer pointer; + /// This type represents a reference-to-value_type. + typedef _Reference reference; + }; + + /** + * @brief Traits class for iterators. + * + * This class does nothing but define nested typedefs. The general + * version simply @a forwards the nested typedefs from the Iterator + * argument. Specialized versions for pointers and pointers-to-const + * provide tighter, more correct semantics. + */ +#if __cplusplus >= 201103L + +_GLIBCXX_HAS_NESTED_TYPE(iterator_category) + + template::value> + struct __iterator_traits { }; + + template + struct __iterator_traits<_Iterator, true> + { + typedef typename _Iterator::iterator_category iterator_category; + typedef typename _Iterator::value_type value_type; + typedef typename _Iterator::difference_type difference_type; + typedef typename _Iterator::pointer pointer; + typedef typename _Iterator::reference reference; + }; + + template + struct iterator_traits + : public __iterator_traits<_Iterator> { }; +#else + template + struct iterator_traits + { + typedef typename _Iterator::iterator_category iterator_category; + typedef typename _Iterator::value_type value_type; + typedef typename _Iterator::difference_type difference_type; + typedef typename _Iterator::pointer pointer; + typedef typename _Iterator::reference reference; + }; +#endif + + /// Partial specialization for pointer types. + template + struct iterator_traits<_Tp*> + { + typedef random_access_iterator_tag iterator_category; + typedef _Tp value_type; + typedef ptrdiff_t difference_type; + typedef _Tp* pointer; + typedef _Tp& reference; + }; + + /// Partial specialization for const pointer types. + template + struct iterator_traits + { + typedef random_access_iterator_tag iterator_category; + typedef _Tp value_type; + typedef ptrdiff_t difference_type; + typedef const _Tp* pointer; + typedef const _Tp& reference; + }; + + /** + * This function is not a part of the C++ standard but is syntactic + * sugar for internal library use only. + */ + template + inline typename iterator_traits<_Iter>::iterator_category + __iterator_category(const _Iter&) + { return typename iterator_traits<_Iter>::iterator_category(); } + + //@} + + // If _Iterator has a base returns it otherwise _Iterator is returned + // untouched + template + struct _Iter_base + { + typedef _Iterator iterator_type; + static iterator_type _S_base(_Iterator __it) + { return __it; } + }; + + template + struct _Iter_base<_Iterator, true> + { + typedef typename _Iterator::iterator_type iterator_type; + static iterator_type _S_base(_Iterator __it) + { return __it.base(); } + }; + +#if __cplusplus >= 201103L + template + using _RequireInputIter = typename + enable_if::iterator_category, + input_iterator_tag>::value>::type; +#endif + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif /* _STL_ITERATOR_BASE_TYPES_H */ + diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stl_list.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stl_list.h new file mode 100755 index 0000000..e014fbc --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stl_list.h @@ -0,0 +1,1795 @@ +// List implementation -*- C++ -*- + +// Copyright (C) 2001-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/* + * + * Copyright (c) 1994 + * Hewlett-Packard Company + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Hewlett-Packard Company makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + * + * + * Copyright (c) 1996,1997 + * Silicon Graphics Computer Systems, Inc. + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Silicon Graphics makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + */ + +/** @file bits/stl_list.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{list} + */ + +#ifndef _STL_LIST_H +#define _STL_LIST_H 1 + +#include +#if __cplusplus >= 201103L +#include +#endif + +namespace std _GLIBCXX_VISIBILITY(default) +{ + namespace __detail + { + _GLIBCXX_BEGIN_NAMESPACE_VERSION + + // Supporting structures are split into common and templated + // types; the latter publicly inherits from the former in an + // effort to reduce code duplication. This results in some + // "needless" static_cast'ing later on, but it's all safe + // downcasting. + + /// Common part of a node in the %list. + struct _List_node_base + { + _List_node_base* _M_next; + _List_node_base* _M_prev; + + static void + swap(_List_node_base& __x, _List_node_base& __y) _GLIBCXX_USE_NOEXCEPT; + + void + _M_transfer(_List_node_base* const __first, + _List_node_base* const __last) _GLIBCXX_USE_NOEXCEPT; + + void + _M_reverse() _GLIBCXX_USE_NOEXCEPT; + + void + _M_hook(_List_node_base* const __position) _GLIBCXX_USE_NOEXCEPT; + + void + _M_unhook() _GLIBCXX_USE_NOEXCEPT; + }; + + _GLIBCXX_END_NAMESPACE_VERSION + } // namespace detail + +_GLIBCXX_BEGIN_NAMESPACE_CONTAINER + + /// An actual node in the %list. + template + struct _List_node : public __detail::_List_node_base + { + ///< User's data. + _Tp _M_data; + +#if __cplusplus >= 201103L + template + _List_node(_Args&&... __args) + : __detail::_List_node_base(), _M_data(std::forward<_Args>(__args)...) + { } +#endif + }; + + /** + * @brief A list::iterator. + * + * All the functions are op overloads. + */ + template + struct _List_iterator + { + typedef _List_iterator<_Tp> _Self; + typedef _List_node<_Tp> _Node; + + typedef ptrdiff_t difference_type; + typedef std::bidirectional_iterator_tag iterator_category; + typedef _Tp value_type; + typedef _Tp* pointer; + typedef _Tp& reference; + + _List_iterator() _GLIBCXX_NOEXCEPT + : _M_node() { } + + explicit + _List_iterator(__detail::_List_node_base* __x) _GLIBCXX_NOEXCEPT + : _M_node(__x) { } + + _Self + _M_const_cast() const _GLIBCXX_NOEXCEPT + { return *this; } + + // Must downcast from _List_node_base to _List_node to get to _M_data. + reference + operator*() const _GLIBCXX_NOEXCEPT + { return static_cast<_Node*>(_M_node)->_M_data; } + + pointer + operator->() const _GLIBCXX_NOEXCEPT + { return std::__addressof(static_cast<_Node*>(_M_node)->_M_data); } + + _Self& + operator++() _GLIBCXX_NOEXCEPT + { + _M_node = _M_node->_M_next; + return *this; + } + + _Self + operator++(int) _GLIBCXX_NOEXCEPT + { + _Self __tmp = *this; + _M_node = _M_node->_M_next; + return __tmp; + } + + _Self& + operator--() _GLIBCXX_NOEXCEPT + { + _M_node = _M_node->_M_prev; + return *this; + } + + _Self + operator--(int) _GLIBCXX_NOEXCEPT + { + _Self __tmp = *this; + _M_node = _M_node->_M_prev; + return __tmp; + } + + bool + operator==(const _Self& __x) const _GLIBCXX_NOEXCEPT + { return _M_node == __x._M_node; } + + bool + operator!=(const _Self& __x) const _GLIBCXX_NOEXCEPT + { return _M_node != __x._M_node; } + + // The only member points to the %list element. + __detail::_List_node_base* _M_node; + }; + + /** + * @brief A list::const_iterator. + * + * All the functions are op overloads. + */ + template + struct _List_const_iterator + { + typedef _List_const_iterator<_Tp> _Self; + typedef const _List_node<_Tp> _Node; + typedef _List_iterator<_Tp> iterator; + + typedef ptrdiff_t difference_type; + typedef std::bidirectional_iterator_tag iterator_category; + typedef _Tp value_type; + typedef const _Tp* pointer; + typedef const _Tp& reference; + + _List_const_iterator() _GLIBCXX_NOEXCEPT + : _M_node() { } + + explicit + _List_const_iterator(const __detail::_List_node_base* __x) + _GLIBCXX_NOEXCEPT + : _M_node(__x) { } + + _List_const_iterator(const iterator& __x) _GLIBCXX_NOEXCEPT + : _M_node(__x._M_node) { } + + iterator + _M_const_cast() const _GLIBCXX_NOEXCEPT + { return iterator(const_cast<__detail::_List_node_base*>(_M_node)); } + + // Must downcast from List_node_base to _List_node to get to + // _M_data. + reference + operator*() const _GLIBCXX_NOEXCEPT + { return static_cast<_Node*>(_M_node)->_M_data; } + + pointer + operator->() const _GLIBCXX_NOEXCEPT + { return std::__addressof(static_cast<_Node*>(_M_node)->_M_data); } + + _Self& + operator++() _GLIBCXX_NOEXCEPT + { + _M_node = _M_node->_M_next; + return *this; + } + + _Self + operator++(int) _GLIBCXX_NOEXCEPT + { + _Self __tmp = *this; + _M_node = _M_node->_M_next; + return __tmp; + } + + _Self& + operator--() _GLIBCXX_NOEXCEPT + { + _M_node = _M_node->_M_prev; + return *this; + } + + _Self + operator--(int) _GLIBCXX_NOEXCEPT + { + _Self __tmp = *this; + _M_node = _M_node->_M_prev; + return __tmp; + } + + bool + operator==(const _Self& __x) const _GLIBCXX_NOEXCEPT + { return _M_node == __x._M_node; } + + bool + operator!=(const _Self& __x) const _GLIBCXX_NOEXCEPT + { return _M_node != __x._M_node; } + + // The only member points to the %list element. + const __detail::_List_node_base* _M_node; + }; + + template + inline bool + operator==(const _List_iterator<_Val>& __x, + const _List_const_iterator<_Val>& __y) _GLIBCXX_NOEXCEPT + { return __x._M_node == __y._M_node; } + + template + inline bool + operator!=(const _List_iterator<_Val>& __x, + const _List_const_iterator<_Val>& __y) _GLIBCXX_NOEXCEPT + { return __x._M_node != __y._M_node; } + + + /// See bits/stl_deque.h's _Deque_base for an explanation. + template + class _List_base + { + protected: + // NOTA BENE + // The stored instance is not actually of "allocator_type"'s + // type. Instead we rebind the type to + // Allocator>, which according to [20.1.5]/4 + // should probably be the same. List_node is not the same + // size as Tp (it's two pointers larger), and specializations on + // Tp may go unused because List_node is being bound + // instead. + // + // We put this to the test in the constructors and in + // get_allocator, where we use conversions between + // allocator_type and _Node_alloc_type. The conversion is + // required by table 32 in [20.1.5]. + typedef typename _Alloc::template rebind<_List_node<_Tp> >::other + _Node_alloc_type; + + typedef typename _Alloc::template rebind<_Tp>::other _Tp_alloc_type; + + struct _List_impl + : public _Node_alloc_type + { + __detail::_List_node_base _M_node; + + _List_impl() + : _Node_alloc_type(), _M_node() + { } + + _List_impl(const _Node_alloc_type& __a) _GLIBCXX_NOEXCEPT + : _Node_alloc_type(__a), _M_node() + { } + +#if __cplusplus >= 201103L + _List_impl(_Node_alloc_type&& __a) _GLIBCXX_NOEXCEPT + : _Node_alloc_type(std::move(__a)), _M_node() + { } +#endif + }; + + _List_impl _M_impl; + + _List_node<_Tp>* + _M_get_node() + { return _M_impl._Node_alloc_type::allocate(1); } + + void + _M_put_node(_List_node<_Tp>* __p) _GLIBCXX_NOEXCEPT + { _M_impl._Node_alloc_type::deallocate(__p, 1); } + + public: + typedef _Alloc allocator_type; + + _Node_alloc_type& + _M_get_Node_allocator() _GLIBCXX_NOEXCEPT + { return *static_cast<_Node_alloc_type*>(&_M_impl); } + + const _Node_alloc_type& + _M_get_Node_allocator() const _GLIBCXX_NOEXCEPT + { return *static_cast(&_M_impl); } + + _Tp_alloc_type + _M_get_Tp_allocator() const _GLIBCXX_NOEXCEPT + { return _Tp_alloc_type(_M_get_Node_allocator()); } + + allocator_type + get_allocator() const _GLIBCXX_NOEXCEPT + { return allocator_type(_M_get_Node_allocator()); } + + _List_base() + : _M_impl() + { _M_init(); } + + _List_base(const _Node_alloc_type& __a) _GLIBCXX_NOEXCEPT + : _M_impl(__a) + { _M_init(); } + +#if __cplusplus >= 201103L + _List_base(_List_base&& __x) noexcept + : _M_impl(std::move(__x._M_get_Node_allocator())) + { + _M_init(); + __detail::_List_node_base::swap(_M_impl._M_node, __x._M_impl._M_node); + } +#endif + + // This is what actually destroys the list. + ~_List_base() _GLIBCXX_NOEXCEPT + { _M_clear(); } + + void + _M_clear() _GLIBCXX_NOEXCEPT; + + void + _M_init() _GLIBCXX_NOEXCEPT + { + this->_M_impl._M_node._M_next = &this->_M_impl._M_node; + this->_M_impl._M_node._M_prev = &this->_M_impl._M_node; + } + }; + + /** + * @brief A standard container with linear time access to elements, + * and fixed time insertion/deletion at any point in the sequence. + * + * @ingroup sequences + * + * @tparam _Tp Type of element. + * @tparam _Alloc Allocator type, defaults to allocator<_Tp>. + * + * Meets the requirements of a container, a + * reversible container, and a + * sequence, including the + * optional sequence requirements with the + * %exception of @c at and @c operator[]. + * + * This is a @e doubly @e linked %list. Traversal up and down the + * %list requires linear time, but adding and removing elements (or + * @e nodes) is done in constant time, regardless of where the + * change takes place. Unlike std::vector and std::deque, + * random-access iterators are not provided, so subscripting ( @c + * [] ) access is not allowed. For algorithms which only need + * sequential access, this lack makes no difference. + * + * Also unlike the other standard containers, std::list provides + * specialized algorithms %unique to linked lists, such as + * splicing, sorting, and in-place reversal. + * + * A couple points on memory allocation for list: + * + * First, we never actually allocate a Tp, we allocate + * List_node's and trust [20.1.5]/4 to DTRT. This is to ensure + * that after elements from %list are spliced into + * %list, destroying the memory of the second %list is a + * valid operation, i.e., Alloc1 giveth and Alloc2 taketh away. + * + * Second, a %list conceptually represented as + * @code + * A <---> B <---> C <---> D + * @endcode + * is actually circular; a link exists between A and D. The %list + * class holds (as its only data member) a private list::iterator + * pointing to @e D, not to @e A! To get to the head of the %list, + * we start at the tail and move forward by one. When this member + * iterator's next/previous pointers refer to itself, the %list is + * %empty. + */ + template > + class list : protected _List_base<_Tp, _Alloc> + { + // concept requirements + typedef typename _Alloc::value_type _Alloc_value_type; + __glibcxx_class_requires(_Tp, _SGIAssignableConcept) + __glibcxx_class_requires2(_Tp, _Alloc_value_type, _SameTypeConcept) + + typedef _List_base<_Tp, _Alloc> _Base; + typedef typename _Base::_Tp_alloc_type _Tp_alloc_type; + typedef typename _Base::_Node_alloc_type _Node_alloc_type; + + public: + typedef _Tp value_type; + typedef typename _Tp_alloc_type::pointer pointer; + typedef typename _Tp_alloc_type::const_pointer const_pointer; + typedef typename _Tp_alloc_type::reference reference; + typedef typename _Tp_alloc_type::const_reference const_reference; + typedef _List_iterator<_Tp> iterator; + typedef _List_const_iterator<_Tp> const_iterator; + typedef std::reverse_iterator const_reverse_iterator; + typedef std::reverse_iterator reverse_iterator; + typedef size_t size_type; + typedef ptrdiff_t difference_type; + typedef _Alloc allocator_type; + + protected: + // Note that pointers-to-_Node's can be ctor-converted to + // iterator types. + typedef _List_node<_Tp> _Node; + + using _Base::_M_impl; + using _Base::_M_put_node; + using _Base::_M_get_node; + using _Base::_M_get_Tp_allocator; + using _Base::_M_get_Node_allocator; + + /** + * @param __args An instance of user data. + * + * Allocates space for a new node and constructs a copy of + * @a __args in it. + */ +#if __cplusplus < 201103L + _Node* + _M_create_node(const value_type& __x) + { + _Node* __p = this->_M_get_node(); + __try + { + _M_get_Tp_allocator().construct + (std::__addressof(__p->_M_data), __x); + } + __catch(...) + { + _M_put_node(__p); + __throw_exception_again; + } + return __p; + } +#else + template + _Node* + _M_create_node(_Args&&... __args) + { + _Node* __p = this->_M_get_node(); + __try + { + _M_get_Node_allocator().construct(__p, + std::forward<_Args>(__args)...); + } + __catch(...) + { + _M_put_node(__p); + __throw_exception_again; + } + return __p; + } +#endif + + public: + // [23.2.2.1] construct/copy/destroy + // (assign() and get_allocator() are also listed in this section) + + /** + * @brief Creates a %list with no elements. + */ + list() +#if __cplusplus >= 201103L + noexcept(is_nothrow_default_constructible<_Node_alloc_type>::value) +#endif + : _Base() { } + + /** + * @brief Creates a %list with no elements. + * @param __a An allocator object. + */ + explicit + list(const allocator_type& __a) _GLIBCXX_NOEXCEPT + : _Base(_Node_alloc_type(__a)) { } + +#if __cplusplus >= 201103L + /** + * @brief Creates a %list with default constructed elements. + * @param __n The number of elements to initially create. + * + * This constructor fills the %list with @a __n default + * constructed elements. + */ + explicit + list(size_type __n) + : _Base() + { _M_default_initialize(__n); } + + /** + * @brief Creates a %list with copies of an exemplar element. + * @param __n The number of elements to initially create. + * @param __value An element to copy. + * @param __a An allocator object. + * + * This constructor fills the %list with @a __n copies of @a __value. + */ + list(size_type __n, const value_type& __value, + const allocator_type& __a = allocator_type()) + : _Base(_Node_alloc_type(__a)) + { _M_fill_initialize(__n, __value); } +#else + /** + * @brief Creates a %list with copies of an exemplar element. + * @param __n The number of elements to initially create. + * @param __value An element to copy. + * @param __a An allocator object. + * + * This constructor fills the %list with @a __n copies of @a __value. + */ + explicit + list(size_type __n, const value_type& __value = value_type(), + const allocator_type& __a = allocator_type()) + : _Base(_Node_alloc_type(__a)) + { _M_fill_initialize(__n, __value); } +#endif + + /** + * @brief %List copy constructor. + * @param __x A %list of identical element and allocator types. + * + * The newly-created %list uses a copy of the allocation object used + * by @a __x. + */ + list(const list& __x) + : _Base(__x._M_get_Node_allocator()) + { _M_initialize_dispatch(__x.begin(), __x.end(), __false_type()); } + +#if __cplusplus >= 201103L + /** + * @brief %List move constructor. + * @param __x A %list of identical element and allocator types. + * + * The newly-created %list contains the exact contents of @a __x. + * The contents of @a __x are a valid, but unspecified %list. + */ + list(list&& __x) noexcept + : _Base(std::move(__x)) { } + + /** + * @brief Builds a %list from an initializer_list + * @param __l An initializer_list of value_type. + * @param __a An allocator object. + * + * Create a %list consisting of copies of the elements in the + * initializer_list @a __l. This is linear in __l.size(). + */ + list(initializer_list __l, + const allocator_type& __a = allocator_type()) + : _Base(_Node_alloc_type(__a)) + { _M_initialize_dispatch(__l.begin(), __l.end(), __false_type()); } +#endif + + /** + * @brief Builds a %list from a range. + * @param __first An input iterator. + * @param __last An input iterator. + * @param __a An allocator object. + * + * Create a %list consisting of copies of the elements from + * [@a __first,@a __last). This is linear in N (where N is + * distance(@a __first,@a __last)). + */ +#if __cplusplus >= 201103L + template> + list(_InputIterator __first, _InputIterator __last, + const allocator_type& __a = allocator_type()) + : _Base(_Node_alloc_type(__a)) + { _M_initialize_dispatch(__first, __last, __false_type()); } +#else + template + list(_InputIterator __first, _InputIterator __last, + const allocator_type& __a = allocator_type()) + : _Base(_Node_alloc_type(__a)) + { + // Check whether it's an integral type. If so, it's not an iterator. + typedef typename std::__is_integer<_InputIterator>::__type _Integral; + _M_initialize_dispatch(__first, __last, _Integral()); + } +#endif + + /** + * No explicit dtor needed as the _Base dtor takes care of + * things. The _Base dtor only erases the elements, and note + * that if the elements themselves are pointers, the pointed-to + * memory is not touched in any way. Managing the pointer is + * the user's responsibility. + */ + + /** + * @brief %List assignment operator. + * @param __x A %list of identical element and allocator types. + * + * All the elements of @a __x are copied, but unlike the copy + * constructor, the allocator object is not copied. + */ + list& + operator=(const list& __x); + +#if __cplusplus >= 201103L + /** + * @brief %List move assignment operator. + * @param __x A %list of identical element and allocator types. + * + * The contents of @a __x are moved into this %list (without copying). + * @a __x is a valid, but unspecified %list + */ + list& + operator=(list&& __x) + { + // NB: DR 1204. + // NB: DR 675. + this->clear(); + this->swap(__x); + return *this; + } + + /** + * @brief %List initializer list assignment operator. + * @param __l An initializer_list of value_type. + * + * Replace the contents of the %list with copies of the elements + * in the initializer_list @a __l. This is linear in l.size(). + */ + list& + operator=(initializer_list __l) + { + this->assign(__l.begin(), __l.end()); + return *this; + } +#endif + + /** + * @brief Assigns a given value to a %list. + * @param __n Number of elements to be assigned. + * @param __val Value to be assigned. + * + * This function fills a %list with @a __n copies of the given + * value. Note that the assignment completely changes the %list + * and that the resulting %list's size is the same as the number + * of elements assigned. Old data may be lost. + */ + void + assign(size_type __n, const value_type& __val) + { _M_fill_assign(__n, __val); } + + /** + * @brief Assigns a range to a %list. + * @param __first An input iterator. + * @param __last An input iterator. + * + * This function fills a %list with copies of the elements in the + * range [@a __first,@a __last). + * + * Note that the assignment completely changes the %list and + * that the resulting %list's size is the same as the number of + * elements assigned. Old data may be lost. + */ +#if __cplusplus >= 201103L + template> + void + assign(_InputIterator __first, _InputIterator __last) + { _M_assign_dispatch(__first, __last, __false_type()); } +#else + template + void + assign(_InputIterator __first, _InputIterator __last) + { + // Check whether it's an integral type. If so, it's not an iterator. + typedef typename std::__is_integer<_InputIterator>::__type _Integral; + _M_assign_dispatch(__first, __last, _Integral()); + } +#endif + +#if __cplusplus >= 201103L + /** + * @brief Assigns an initializer_list to a %list. + * @param __l An initializer_list of value_type. + * + * Replace the contents of the %list with copies of the elements + * in the initializer_list @a __l. This is linear in __l.size(). + */ + void + assign(initializer_list __l) + { this->assign(__l.begin(), __l.end()); } +#endif + + /// Get a copy of the memory allocation object. + allocator_type + get_allocator() const _GLIBCXX_NOEXCEPT + { return _Base::get_allocator(); } + + // iterators + /** + * Returns a read/write iterator that points to the first element in the + * %list. Iteration is done in ordinary element order. + */ + iterator + begin() _GLIBCXX_NOEXCEPT + { return iterator(this->_M_impl._M_node._M_next); } + + /** + * Returns a read-only (constant) iterator that points to the + * first element in the %list. Iteration is done in ordinary + * element order. + */ + const_iterator + begin() const _GLIBCXX_NOEXCEPT + { return const_iterator(this->_M_impl._M_node._M_next); } + + /** + * Returns a read/write iterator that points one past the last + * element in the %list. Iteration is done in ordinary element + * order. + */ + iterator + end() _GLIBCXX_NOEXCEPT + { return iterator(&this->_M_impl._M_node); } + + /** + * Returns a read-only (constant) iterator that points one past + * the last element in the %list. Iteration is done in ordinary + * element order. + */ + const_iterator + end() const _GLIBCXX_NOEXCEPT + { return const_iterator(&this->_M_impl._M_node); } + + /** + * Returns a read/write reverse iterator that points to the last + * element in the %list. Iteration is done in reverse element + * order. + */ + reverse_iterator + rbegin() _GLIBCXX_NOEXCEPT + { return reverse_iterator(end()); } + + /** + * Returns a read-only (constant) reverse iterator that points to + * the last element in the %list. Iteration is done in reverse + * element order. + */ + const_reverse_iterator + rbegin() const _GLIBCXX_NOEXCEPT + { return const_reverse_iterator(end()); } + + /** + * Returns a read/write reverse iterator that points to one + * before the first element in the %list. Iteration is done in + * reverse element order. + */ + reverse_iterator + rend() _GLIBCXX_NOEXCEPT + { return reverse_iterator(begin()); } + + /** + * Returns a read-only (constant) reverse iterator that points to one + * before the first element in the %list. Iteration is done in reverse + * element order. + */ + const_reverse_iterator + rend() const _GLIBCXX_NOEXCEPT + { return const_reverse_iterator(begin()); } + +#if __cplusplus >= 201103L + /** + * Returns a read-only (constant) iterator that points to the + * first element in the %list. Iteration is done in ordinary + * element order. + */ + const_iterator + cbegin() const noexcept + { return const_iterator(this->_M_impl._M_node._M_next); } + + /** + * Returns a read-only (constant) iterator that points one past + * the last element in the %list. Iteration is done in ordinary + * element order. + */ + const_iterator + cend() const noexcept + { return const_iterator(&this->_M_impl._M_node); } + + /** + * Returns a read-only (constant) reverse iterator that points to + * the last element in the %list. Iteration is done in reverse + * element order. + */ + const_reverse_iterator + crbegin() const noexcept + { return const_reverse_iterator(end()); } + + /** + * Returns a read-only (constant) reverse iterator that points to one + * before the first element in the %list. Iteration is done in reverse + * element order. + */ + const_reverse_iterator + crend() const noexcept + { return const_reverse_iterator(begin()); } +#endif + + // [23.2.2.2] capacity + /** + * Returns true if the %list is empty. (Thus begin() would equal + * end().) + */ + bool + empty() const _GLIBCXX_NOEXCEPT + { return this->_M_impl._M_node._M_next == &this->_M_impl._M_node; } + + /** Returns the number of elements in the %list. */ + size_type + size() const _GLIBCXX_NOEXCEPT + { return std::distance(begin(), end()); } + + /** Returns the size() of the largest possible %list. */ + size_type + max_size() const _GLIBCXX_NOEXCEPT + { return _M_get_Node_allocator().max_size(); } + +#if __cplusplus >= 201103L + /** + * @brief Resizes the %list to the specified number of elements. + * @param __new_size Number of elements the %list should contain. + * + * This function will %resize the %list to the specified number + * of elements. If the number is smaller than the %list's + * current size the %list is truncated, otherwise default + * constructed elements are appended. + */ + void + resize(size_type __new_size); + + /** + * @brief Resizes the %list to the specified number of elements. + * @param __new_size Number of elements the %list should contain. + * @param __x Data with which new elements should be populated. + * + * This function will %resize the %list to the specified number + * of elements. If the number is smaller than the %list's + * current size the %list is truncated, otherwise the %list is + * extended and new elements are populated with given data. + */ + void + resize(size_type __new_size, const value_type& __x); +#else + /** + * @brief Resizes the %list to the specified number of elements. + * @param __new_size Number of elements the %list should contain. + * @param __x Data with which new elements should be populated. + * + * This function will %resize the %list to the specified number + * of elements. If the number is smaller than the %list's + * current size the %list is truncated, otherwise the %list is + * extended and new elements are populated with given data. + */ + void + resize(size_type __new_size, value_type __x = value_type()); +#endif + + // element access + /** + * Returns a read/write reference to the data at the first + * element of the %list. + */ + reference + front() _GLIBCXX_NOEXCEPT + { return *begin(); } + + /** + * Returns a read-only (constant) reference to the data at the first + * element of the %list. + */ + const_reference + front() const _GLIBCXX_NOEXCEPT + { return *begin(); } + + /** + * Returns a read/write reference to the data at the last element + * of the %list. + */ + reference + back() _GLIBCXX_NOEXCEPT + { + iterator __tmp = end(); + --__tmp; + return *__tmp; + } + + /** + * Returns a read-only (constant) reference to the data at the last + * element of the %list. + */ + const_reference + back() const _GLIBCXX_NOEXCEPT + { + const_iterator __tmp = end(); + --__tmp; + return *__tmp; + } + + // [23.2.2.3] modifiers + /** + * @brief Add data to the front of the %list. + * @param __x Data to be added. + * + * This is a typical stack operation. The function creates an + * element at the front of the %list and assigns the given data + * to it. Due to the nature of a %list this operation can be + * done in constant time, and does not invalidate iterators and + * references. + */ + void + push_front(const value_type& __x) + { this->_M_insert(begin(), __x); } + +#if __cplusplus >= 201103L + void + push_front(value_type&& __x) + { this->_M_insert(begin(), std::move(__x)); } + + template + void + emplace_front(_Args&&... __args) + { this->_M_insert(begin(), std::forward<_Args>(__args)...); } +#endif + + /** + * @brief Removes first element. + * + * This is a typical stack operation. It shrinks the %list by + * one. Due to the nature of a %list this operation can be done + * in constant time, and only invalidates iterators/references to + * the element being removed. + * + * Note that no data is returned, and if the first element's data + * is needed, it should be retrieved before pop_front() is + * called. + */ + void + pop_front() _GLIBCXX_NOEXCEPT + { this->_M_erase(begin()); } + + /** + * @brief Add data to the end of the %list. + * @param __x Data to be added. + * + * This is a typical stack operation. The function creates an + * element at the end of the %list and assigns the given data to + * it. Due to the nature of a %list this operation can be done + * in constant time, and does not invalidate iterators and + * references. + */ + void + push_back(const value_type& __x) + { this->_M_insert(end(), __x); } + +#if __cplusplus >= 201103L + void + push_back(value_type&& __x) + { this->_M_insert(end(), std::move(__x)); } + + template + void + emplace_back(_Args&&... __args) + { this->_M_insert(end(), std::forward<_Args>(__args)...); } +#endif + + /** + * @brief Removes last element. + * + * This is a typical stack operation. It shrinks the %list by + * one. Due to the nature of a %list this operation can be done + * in constant time, and only invalidates iterators/references to + * the element being removed. + * + * Note that no data is returned, and if the last element's data + * is needed, it should be retrieved before pop_back() is called. + */ + void + pop_back() _GLIBCXX_NOEXCEPT + { this->_M_erase(iterator(this->_M_impl._M_node._M_prev)); } + +#if __cplusplus >= 201103L + /** + * @brief Constructs object in %list before specified iterator. + * @param __position A const_iterator into the %list. + * @param __args Arguments. + * @return An iterator that points to the inserted data. + * + * This function will insert an object of type T constructed + * with T(std::forward(args)...) before the specified + * location. Due to the nature of a %list this operation can + * be done in constant time, and does not invalidate iterators + * and references. + */ + template + iterator + emplace(const_iterator __position, _Args&&... __args); + + /** + * @brief Inserts given value into %list before specified iterator. + * @param __position A const_iterator into the %list. + * @param __x Data to be inserted. + * @return An iterator that points to the inserted data. + * + * This function will insert a copy of the given value before + * the specified location. Due to the nature of a %list this + * operation can be done in constant time, and does not + * invalidate iterators and references. + */ + iterator + insert(const_iterator __position, const value_type& __x); +#else + /** + * @brief Inserts given value into %list before specified iterator. + * @param __position An iterator into the %list. + * @param __x Data to be inserted. + * @return An iterator that points to the inserted data. + * + * This function will insert a copy of the given value before + * the specified location. Due to the nature of a %list this + * operation can be done in constant time, and does not + * invalidate iterators and references. + */ + iterator + insert(iterator __position, const value_type& __x); +#endif + +#if __cplusplus >= 201103L + /** + * @brief Inserts given rvalue into %list before specified iterator. + * @param __position A const_iterator into the %list. + * @param __x Data to be inserted. + * @return An iterator that points to the inserted data. + * + * This function will insert a copy of the given rvalue before + * the specified location. Due to the nature of a %list this + * operation can be done in constant time, and does not + * invalidate iterators and references. + */ + iterator + insert(const_iterator __position, value_type&& __x) + { return emplace(__position, std::move(__x)); } + + /** + * @brief Inserts the contents of an initializer_list into %list + * before specified const_iterator. + * @param __p A const_iterator into the %list. + * @param __l An initializer_list of value_type. + * @return An iterator pointing to the first element inserted + * (or __position). + * + * This function will insert copies of the data in the + * initializer_list @a l into the %list before the location + * specified by @a p. + * + * This operation is linear in the number of elements inserted and + * does not invalidate iterators and references. + */ + iterator + insert(const_iterator __p, initializer_list __l) + { return this->insert(__p, __l.begin(), __l.end()); } +#endif + +#if __cplusplus >= 201103L + /** + * @brief Inserts a number of copies of given data into the %list. + * @param __position A const_iterator into the %list. + * @param __n Number of elements to be inserted. + * @param __x Data to be inserted. + * @return An iterator pointing to the first element inserted + * (or __position). + * + * This function will insert a specified number of copies of the + * given data before the location specified by @a position. + * + * This operation is linear in the number of elements inserted and + * does not invalidate iterators and references. + */ + iterator + insert(const_iterator __position, size_type __n, const value_type& __x); +#else + /** + * @brief Inserts a number of copies of given data into the %list. + * @param __position An iterator into the %list. + * @param __n Number of elements to be inserted. + * @param __x Data to be inserted. + * + * This function will insert a specified number of copies of the + * given data before the location specified by @a position. + * + * This operation is linear in the number of elements inserted and + * does not invalidate iterators and references. + */ + void + insert(iterator __position, size_type __n, const value_type& __x) + { + list __tmp(__n, __x, get_allocator()); + splice(__position, __tmp); + } +#endif + +#if __cplusplus >= 201103L + /** + * @brief Inserts a range into the %list. + * @param __position A const_iterator into the %list. + * @param __first An input iterator. + * @param __last An input iterator. + * @return An iterator pointing to the first element inserted + * (or __position). + * + * This function will insert copies of the data in the range [@a + * first,@a last) into the %list before the location specified by + * @a position. + * + * This operation is linear in the number of elements inserted and + * does not invalidate iterators and references. + */ + template> + iterator + insert(const_iterator __position, _InputIterator __first, + _InputIterator __last); +#else + /** + * @brief Inserts a range into the %list. + * @param __position An iterator into the %list. + * @param __first An input iterator. + * @param __last An input iterator. + * + * This function will insert copies of the data in the range [@a + * first,@a last) into the %list before the location specified by + * @a position. + * + * This operation is linear in the number of elements inserted and + * does not invalidate iterators and references. + */ + template + void + insert(iterator __position, _InputIterator __first, + _InputIterator __last) + { + list __tmp(__first, __last, get_allocator()); + splice(__position, __tmp); + } +#endif + + /** + * @brief Remove element at given position. + * @param __position Iterator pointing to element to be erased. + * @return An iterator pointing to the next element (or end()). + * + * This function will erase the element at the given position and thus + * shorten the %list by one. + * + * Due to the nature of a %list this operation can be done in + * constant time, and only invalidates iterators/references to + * the element being removed. The user is also cautioned that + * this function only erases the element, and that if the element + * is itself a pointer, the pointed-to memory is not touched in + * any way. Managing the pointer is the user's responsibility. + */ + iterator +#if __cplusplus >= 201103L + erase(const_iterator __position) noexcept; +#else + erase(iterator __position); +#endif + + /** + * @brief Remove a range of elements. + * @param __first Iterator pointing to the first element to be erased. + * @param __last Iterator pointing to one past the last element to be + * erased. + * @return An iterator pointing to the element pointed to by @a last + * prior to erasing (or end()). + * + * This function will erase the elements in the range @a + * [first,last) and shorten the %list accordingly. + * + * This operation is linear time in the size of the range and only + * invalidates iterators/references to the element being removed. + * The user is also cautioned that this function only erases the + * elements, and that if the elements themselves are pointers, the + * pointed-to memory is not touched in any way. Managing the pointer + * is the user's responsibility. + */ + iterator +#if __cplusplus >= 201103L + erase(const_iterator __first, const_iterator __last) noexcept +#else + erase(iterator __first, iterator __last) +#endif + { + while (__first != __last) + __first = erase(__first); + return __last._M_const_cast(); + } + + /** + * @brief Swaps data with another %list. + * @param __x A %list of the same element and allocator types. + * + * This exchanges the elements between two lists in constant + * time. Note that the global std::swap() function is + * specialized such that std::swap(l1,l2) will feed to this + * function. + */ + void + swap(list& __x) + { + __detail::_List_node_base::swap(this->_M_impl._M_node, + __x._M_impl._M_node); + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 431. Swapping containers with unequal allocators. + std::__alloc_swap:: + _S_do_it(_M_get_Node_allocator(), __x._M_get_Node_allocator()); + } + + /** + * Erases all the elements. Note that this function only erases + * the elements, and that if the elements themselves are + * pointers, the pointed-to memory is not touched in any way. + * Managing the pointer is the user's responsibility. + */ + void + clear() _GLIBCXX_NOEXCEPT + { + _Base::_M_clear(); + _Base::_M_init(); + } + + // [23.2.2.4] list operations + /** + * @brief Insert contents of another %list. + * @param __position Iterator referencing the element to insert before. + * @param __x Source list. + * + * The elements of @a __x are inserted in constant time in front of + * the element referenced by @a __position. @a __x becomes an empty + * list. + * + * Requires this != @a __x. + */ + void +#if __cplusplus >= 201103L + splice(const_iterator __position, list&& __x) noexcept +#else + splice(iterator __position, list& __x) +#endif + { + if (!__x.empty()) + { + _M_check_equal_allocators(__x); + + this->_M_transfer(__position._M_const_cast(), + __x.begin(), __x.end()); + } + } + +#if __cplusplus >= 201103L + void + splice(const_iterator __position, list& __x) noexcept + { splice(__position, std::move(__x)); } +#endif + +#if __cplusplus >= 201103L + /** + * @brief Insert element from another %list. + * @param __position Const_iterator referencing the element to + * insert before. + * @param __x Source list. + * @param __i Const_iterator referencing the element to move. + * + * Removes the element in list @a __x referenced by @a __i and + * inserts it into the current list before @a __position. + */ + void + splice(const_iterator __position, list&& __x, const_iterator __i) noexcept +#else + /** + * @brief Insert element from another %list. + * @param __position Iterator referencing the element to insert before. + * @param __x Source list. + * @param __i Iterator referencing the element to move. + * + * Removes the element in list @a __x referenced by @a __i and + * inserts it into the current list before @a __position. + */ + void + splice(iterator __position, list& __x, iterator __i) +#endif + { + iterator __j = __i._M_const_cast(); + ++__j; + if (__position == __i || __position == __j) + return; + + if (this != &__x) + _M_check_equal_allocators(__x); + + this->_M_transfer(__position._M_const_cast(), + __i._M_const_cast(), __j); + } + +#if __cplusplus >= 201103L + /** + * @brief Insert element from another %list. + * @param __position Const_iterator referencing the element to + * insert before. + * @param __x Source list. + * @param __i Const_iterator referencing the element to move. + * + * Removes the element in list @a __x referenced by @a __i and + * inserts it into the current list before @a __position. + */ + void + splice(const_iterator __position, list& __x, const_iterator __i) noexcept + { splice(__position, std::move(__x), __i); } +#endif + +#if __cplusplus >= 201103L + /** + * @brief Insert range from another %list. + * @param __position Const_iterator referencing the element to + * insert before. + * @param __x Source list. + * @param __first Const_iterator referencing the start of range in x. + * @param __last Const_iterator referencing the end of range in x. + * + * Removes elements in the range [__first,__last) and inserts them + * before @a __position in constant time. + * + * Undefined if @a __position is in [__first,__last). + */ + void + splice(const_iterator __position, list&& __x, const_iterator __first, + const_iterator __last) noexcept +#else + /** + * @brief Insert range from another %list. + * @param __position Iterator referencing the element to insert before. + * @param __x Source list. + * @param __first Iterator referencing the start of range in x. + * @param __last Iterator referencing the end of range in x. + * + * Removes elements in the range [__first,__last) and inserts them + * before @a __position in constant time. + * + * Undefined if @a __position is in [__first,__last). + */ + void + splice(iterator __position, list& __x, iterator __first, + iterator __last) +#endif + { + if (__first != __last) + { + if (this != &__x) + _M_check_equal_allocators(__x); + + this->_M_transfer(__position._M_const_cast(), + __first._M_const_cast(), + __last._M_const_cast()); + } + } + +#if __cplusplus >= 201103L + /** + * @brief Insert range from another %list. + * @param __position Const_iterator referencing the element to + * insert before. + * @param __x Source list. + * @param __first Const_iterator referencing the start of range in x. + * @param __last Const_iterator referencing the end of range in x. + * + * Removes elements in the range [__first,__last) and inserts them + * before @a __position in constant time. + * + * Undefined if @a __position is in [__first,__last). + */ + void + splice(const_iterator __position, list& __x, const_iterator __first, + const_iterator __last) noexcept + { splice(__position, std::move(__x), __first, __last); } +#endif + + /** + * @brief Remove all elements equal to value. + * @param __value The value to remove. + * + * Removes every element in the list equal to @a value. + * Remaining elements stay in list order. Note that this + * function only erases the elements, and that if the elements + * themselves are pointers, the pointed-to memory is not + * touched in any way. Managing the pointer is the user's + * responsibility. + */ + void + remove(const _Tp& __value); + + /** + * @brief Remove all elements satisfying a predicate. + * @tparam _Predicate Unary predicate function or object. + * + * Removes every element in the list for which the predicate + * returns true. Remaining elements stay in list order. Note + * that this function only erases the elements, and that if the + * elements themselves are pointers, the pointed-to memory is + * not touched in any way. Managing the pointer is the user's + * responsibility. + */ + template + void + remove_if(_Predicate); + + /** + * @brief Remove consecutive duplicate elements. + * + * For each consecutive set of elements with the same value, + * remove all but the first one. Remaining elements stay in + * list order. Note that this function only erases the + * elements, and that if the elements themselves are pointers, + * the pointed-to memory is not touched in any way. Managing + * the pointer is the user's responsibility. + */ + void + unique(); + + /** + * @brief Remove consecutive elements satisfying a predicate. + * @tparam _BinaryPredicate Binary predicate function or object. + * + * For each consecutive set of elements [first,last) that + * satisfy predicate(first,i) where i is an iterator in + * [first,last), remove all but the first one. Remaining + * elements stay in list order. Note that this function only + * erases the elements, and that if the elements themselves are + * pointers, the pointed-to memory is not touched in any way. + * Managing the pointer is the user's responsibility. + */ + template + void + unique(_BinaryPredicate); + + /** + * @brief Merge sorted lists. + * @param __x Sorted list to merge. + * + * Assumes that both @a __x and this list are sorted according to + * operator<(). Merges elements of @a __x into this list in + * sorted order, leaving @a __x empty when complete. Elements in + * this list precede elements in @a __x that are equal. + */ +#if __cplusplus >= 201103L + void + merge(list&& __x); + + void + merge(list& __x) + { merge(std::move(__x)); } +#else + void + merge(list& __x); +#endif + + /** + * @brief Merge sorted lists according to comparison function. + * @tparam _StrictWeakOrdering Comparison function defining + * sort order. + * @param __x Sorted list to merge. + * @param __comp Comparison functor. + * + * Assumes that both @a __x and this list are sorted according to + * StrictWeakOrdering. Merges elements of @a __x into this list + * in sorted order, leaving @a __x empty when complete. Elements + * in this list precede elements in @a __x that are equivalent + * according to StrictWeakOrdering(). + */ +#if __cplusplus >= 201103L + template + void + merge(list&& __x, _StrictWeakOrdering __comp); + + template + void + merge(list& __x, _StrictWeakOrdering __comp) + { merge(std::move(__x), __comp); } +#else + template + void + merge(list& __x, _StrictWeakOrdering __comp); +#endif + + /** + * @brief Reverse the elements in list. + * + * Reverse the order of elements in the list in linear time. + */ + void + reverse() _GLIBCXX_NOEXCEPT + { this->_M_impl._M_node._M_reverse(); } + + /** + * @brief Sort the elements. + * + * Sorts the elements of this list in NlogN time. Equivalent + * elements remain in list order. + */ + void + sort(); + + /** + * @brief Sort the elements according to comparison function. + * + * Sorts the elements of this list in NlogN time. Equivalent + * elements remain in list order. + */ + template + void + sort(_StrictWeakOrdering); + + protected: + // Internal constructor functions follow. + + // Called by the range constructor to implement [23.1.1]/9 + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 438. Ambiguity in the "do the right thing" clause + template + void + _M_initialize_dispatch(_Integer __n, _Integer __x, __true_type) + { _M_fill_initialize(static_cast(__n), __x); } + + // Called by the range constructor to implement [23.1.1]/9 + template + void + _M_initialize_dispatch(_InputIterator __first, _InputIterator __last, + __false_type) + { + for (; __first != __last; ++__first) +#if __cplusplus >= 201103L + emplace_back(*__first); +#else + push_back(*__first); +#endif + } + + // Called by list(n,v,a), and the range constructor when it turns out + // to be the same thing. + void + _M_fill_initialize(size_type __n, const value_type& __x) + { + for (; __n; --__n) + push_back(__x); + } + +#if __cplusplus >= 201103L + // Called by list(n). + void + _M_default_initialize(size_type __n) + { + for (; __n; --__n) + emplace_back(); + } + + // Called by resize(sz). + void + _M_default_append(size_type __n); +#endif + + // Internal assign functions follow. + + // Called by the range assign to implement [23.1.1]/9 + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 438. Ambiguity in the "do the right thing" clause + template + void + _M_assign_dispatch(_Integer __n, _Integer __val, __true_type) + { _M_fill_assign(__n, __val); } + + // Called by the range assign to implement [23.1.1]/9 + template + void + _M_assign_dispatch(_InputIterator __first, _InputIterator __last, + __false_type); + + // Called by assign(n,t), and the range assign when it turns out + // to be the same thing. + void + _M_fill_assign(size_type __n, const value_type& __val); + + + // Moves the elements from [first,last) before position. + void + _M_transfer(iterator __position, iterator __first, iterator __last) + { __position._M_node->_M_transfer(__first._M_node, __last._M_node); } + + // Inserts new element at position given and with value given. +#if __cplusplus < 201103L + void + _M_insert(iterator __position, const value_type& __x) + { + _Node* __tmp = _M_create_node(__x); + __tmp->_M_hook(__position._M_node); + } +#else + template + void + _M_insert(iterator __position, _Args&&... __args) + { + _Node* __tmp = _M_create_node(std::forward<_Args>(__args)...); + __tmp->_M_hook(__position._M_node); + } +#endif + + // Erases element at position given. + void + _M_erase(iterator __position) _GLIBCXX_NOEXCEPT + { + __position._M_node->_M_unhook(); + _Node* __n = static_cast<_Node*>(__position._M_node); +#if __cplusplus >= 201103L + _M_get_Node_allocator().destroy(__n); +#else + _M_get_Tp_allocator().destroy(std::__addressof(__n->_M_data)); +#endif + _M_put_node(__n); + } + + // To implement the splice (and merge) bits of N1599. + void + _M_check_equal_allocators(list& __x) _GLIBCXX_NOEXCEPT + { + if (std::__alloc_neq:: + _S_do_it(_M_get_Node_allocator(), __x._M_get_Node_allocator())) + __builtin_abort(); + } + }; + + /** + * @brief List equality comparison. + * @param __x A %list. + * @param __y A %list of the same type as @a __x. + * @return True iff the size and elements of the lists are equal. + * + * This is an equivalence relation. It is linear in the size of + * the lists. Lists are considered equivalent if their sizes are + * equal, and if corresponding elements compare equal. + */ + template + inline bool + operator==(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y) + { + typedef typename list<_Tp, _Alloc>::const_iterator const_iterator; + const_iterator __end1 = __x.end(); + const_iterator __end2 = __y.end(); + + const_iterator __i1 = __x.begin(); + const_iterator __i2 = __y.begin(); + while (__i1 != __end1 && __i2 != __end2 && *__i1 == *__i2) + { + ++__i1; + ++__i2; + } + return __i1 == __end1 && __i2 == __end2; + } + + /** + * @brief List ordering relation. + * @param __x A %list. + * @param __y A %list of the same type as @a __x. + * @return True iff @a __x is lexicographically less than @a __y. + * + * This is a total ordering relation. It is linear in the size of the + * lists. The elements must be comparable with @c <. + * + * See std::lexicographical_compare() for how the determination is made. + */ + template + inline bool + operator<(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y) + { return std::lexicographical_compare(__x.begin(), __x.end(), + __y.begin(), __y.end()); } + + /// Based on operator== + template + inline bool + operator!=(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y) + { return !(__x == __y); } + + /// Based on operator< + template + inline bool + operator>(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y) + { return __y < __x; } + + /// Based on operator< + template + inline bool + operator<=(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y) + { return !(__y < __x); } + + /// Based on operator< + template + inline bool + operator>=(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y) + { return !(__x < __y); } + + /// See std::list::swap(). + template + inline void + swap(list<_Tp, _Alloc>& __x, list<_Tp, _Alloc>& __y) + { __x.swap(__y); } + +_GLIBCXX_END_NAMESPACE_CONTAINER +} // namespace std + +#endif /* _STL_LIST_H */ diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stl_map.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stl_map.h new file mode 100755 index 0000000..334c54f --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stl_map.h @@ -0,0 +1,1059 @@ +// Map implementation -*- C++ -*- + +// Copyright (C) 2001-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/* + * + * Copyright (c) 1994 + * Hewlett-Packard Company + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Hewlett-Packard Company makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + * + * + * Copyright (c) 1996,1997 + * Silicon Graphics Computer Systems, Inc. + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Silicon Graphics makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + */ + +/** @file bits/stl_map.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{map} + */ + +#ifndef _STL_MAP_H +#define _STL_MAP_H 1 + +#include +#include +#if __cplusplus >= 201103L +#include +#include +#endif + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_CONTAINER + + /** + * @brief A standard container made up of (key,value) pairs, which can be + * retrieved based on a key, in logarithmic time. + * + * @ingroup associative_containers + * + * @tparam _Key Type of key objects. + * @tparam _Tp Type of mapped objects. + * @tparam _Compare Comparison function object type, defaults to less<_Key>. + * @tparam _Alloc Allocator type, defaults to + * allocator. + * + * Meets the requirements of a container, a + * reversible container, and an + * associative container (using unique keys). + * For a @c map the key_type is Key, the mapped_type is T, and the + * value_type is std::pair. + * + * Maps support bidirectional iterators. + * + * The private tree data is declared exactly the same way for map and + * multimap; the distinction is made entirely in how the tree functions are + * called (*_unique versus *_equal, same as the standard). + */ + template , + typename _Alloc = std::allocator > > + class map + { + public: + typedef _Key key_type; + typedef _Tp mapped_type; + typedef std::pair value_type; + typedef _Compare key_compare; + typedef _Alloc allocator_type; + + private: + // concept requirements + typedef typename _Alloc::value_type _Alloc_value_type; + __glibcxx_class_requires(_Tp, _SGIAssignableConcept) + __glibcxx_class_requires4(_Compare, bool, _Key, _Key, + _BinaryFunctionConcept) + __glibcxx_class_requires2(value_type, _Alloc_value_type, _SameTypeConcept) + + public: + class value_compare + : public std::binary_function + { + friend class map<_Key, _Tp, _Compare, _Alloc>; + protected: + _Compare comp; + + value_compare(_Compare __c) + : comp(__c) { } + + public: + bool operator()(const value_type& __x, const value_type& __y) const + { return comp(__x.first, __y.first); } + }; + + private: + /// This turns a red-black tree into a [multi]map. + typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template + rebind::other _Pair_alloc_type; + + typedef _Rb_tree, + key_compare, _Pair_alloc_type> _Rep_type; + + /// The actual tree structure. + _Rep_type _M_t; + + typedef __gnu_cxx::__alloc_traits<_Pair_alloc_type> _Alloc_traits; + + public: + // many of these are specified differently in ISO, but the following are + // "functionally equivalent" + typedef typename _Alloc_traits::pointer pointer; + typedef typename _Alloc_traits::const_pointer const_pointer; + typedef typename _Alloc_traits::reference reference; + typedef typename _Alloc_traits::const_reference const_reference; + typedef typename _Rep_type::iterator iterator; + typedef typename _Rep_type::const_iterator const_iterator; + typedef typename _Rep_type::size_type size_type; + typedef typename _Rep_type::difference_type difference_type; + typedef typename _Rep_type::reverse_iterator reverse_iterator; + typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator; + + // [23.3.1.1] construct/copy/destroy + // (get_allocator() is also listed in this section) + + /** + * @brief Default constructor creates no elements. + */ + map() + : _M_t() { } + + /** + * @brief Creates a %map with no elements. + * @param __comp A comparison object. + * @param __a An allocator object. + */ + explicit + map(const _Compare& __comp, + const allocator_type& __a = allocator_type()) + : _M_t(__comp, _Pair_alloc_type(__a)) { } + + /** + * @brief %Map copy constructor. + * @param __x A %map of identical element and allocator types. + * + * The newly-created %map uses a copy of the allocation object + * used by @a __x. + */ + map(const map& __x) + : _M_t(__x._M_t) { } + +#if __cplusplus >= 201103L + /** + * @brief %Map move constructor. + * @param __x A %map of identical element and allocator types. + * + * The newly-created %map contains the exact contents of @a __x. + * The contents of @a __x are a valid, but unspecified %map. + */ + map(map&& __x) + noexcept(is_nothrow_copy_constructible<_Compare>::value) + : _M_t(std::move(__x._M_t)) { } + + /** + * @brief Builds a %map from an initializer_list. + * @param __l An initializer_list. + * @param __comp A comparison object. + * @param __a An allocator object. + * + * Create a %map consisting of copies of the elements in the + * initializer_list @a __l. + * This is linear in N if the range is already sorted, and NlogN + * otherwise (where N is @a __l.size()). + */ + map(initializer_list __l, + const _Compare& __comp = _Compare(), + const allocator_type& __a = allocator_type()) + : _M_t(__comp, _Pair_alloc_type(__a)) + { _M_t._M_insert_unique(__l.begin(), __l.end()); } + + /// Allocator-extended default constructor. + explicit + map(const allocator_type& __a) + : _M_t(_Compare(), _Pair_alloc_type(__a)) { } + + /// Allocator-extended copy constructor. + map(const map& __m, const allocator_type& __a) + : _M_t(__m._M_t, _Pair_alloc_type(__a)) { } + + /// Allocator-extended move constructor. + map(map&& __m, const allocator_type& __a) + noexcept(is_nothrow_copy_constructible<_Compare>::value + && _Alloc_traits::_S_always_equal()) + : _M_t(std::move(__m._M_t), _Pair_alloc_type(__a)) { } + + /// Allocator-extended initialier-list constructor. + map(initializer_list __l, const allocator_type& __a) + : _M_t(_Compare(), _Pair_alloc_type(__a)) + { _M_t._M_insert_unique(__l.begin(), __l.end()); } + + /// Allocator-extended range constructor. + template + map(_InputIterator __first, _InputIterator __last, + const allocator_type& __a) + : _M_t(_Compare(), _Pair_alloc_type(__a)) + { _M_t._M_insert_unique(__first, __last); } +#endif + + /** + * @brief Builds a %map from a range. + * @param __first An input iterator. + * @param __last An input iterator. + * + * Create a %map consisting of copies of the elements from + * [__first,__last). This is linear in N if the range is + * already sorted, and NlogN otherwise (where N is + * distance(__first,__last)). + */ + template + map(_InputIterator __first, _InputIterator __last) + : _M_t() + { _M_t._M_insert_unique(__first, __last); } + + /** + * @brief Builds a %map from a range. + * @param __first An input iterator. + * @param __last An input iterator. + * @param __comp A comparison functor. + * @param __a An allocator object. + * + * Create a %map consisting of copies of the elements from + * [__first,__last). This is linear in N if the range is + * already sorted, and NlogN otherwise (where N is + * distance(__first,__last)). + */ + template + map(_InputIterator __first, _InputIterator __last, + const _Compare& __comp, + const allocator_type& __a = allocator_type()) + : _M_t(__comp, _Pair_alloc_type(__a)) + { _M_t._M_insert_unique(__first, __last); } + + // FIXME There is no dtor declared, but we should have something + // generated by Doxygen. I don't know what tags to add to this + // paragraph to make that happen: + /** + * The dtor only erases the elements, and note that if the elements + * themselves are pointers, the pointed-to memory is not touched in any + * way. Managing the pointer is the user's responsibility. + */ + + /** + * @brief %Map assignment operator. + * @param __x A %map of identical element and allocator types. + * + * All the elements of @a __x are copied, but unlike the copy + * constructor, the allocator object is not copied. + */ + map& + operator=(const map& __x) + { + _M_t = __x._M_t; + return *this; + } + +#if __cplusplus >= 201103L + /** + * @brief %Map move assignment operator. + * @param __x A %map of identical element and allocator types. + * + * The contents of @a __x are moved into this map (without copying + * if the allocators compare equal or get moved on assignment). + * Afterwards @a __x is in a valid, but unspecified state. + */ + map& + operator=(map&& __x) noexcept(_Alloc_traits::_S_nothrow_move()) + { + if (!_M_t._M_move_assign(__x._M_t)) + { + // The rvalue's allocator cannot be moved and is not equal, + // so we need to individually move each element. + clear(); + insert(std::__make_move_if_noexcept_iterator(__x.begin()), + std::__make_move_if_noexcept_iterator(__x.end())); + __x.clear(); + } + return *this; + } + + /** + * @brief %Map list assignment operator. + * @param __l An initializer_list. + * + * This function fills a %map with copies of the elements in the + * initializer list @a __l. + * + * Note that the assignment completely changes the %map and + * that the resulting %map's size is the same as the number + * of elements assigned. Old data may be lost. + */ + map& + operator=(initializer_list __l) + { + this->clear(); + this->insert(__l.begin(), __l.end()); + return *this; + } +#endif + + /// Get a copy of the memory allocation object. + allocator_type + get_allocator() const _GLIBCXX_NOEXCEPT + { return allocator_type(_M_t.get_allocator()); } + + // iterators + /** + * Returns a read/write iterator that points to the first pair in the + * %map. + * Iteration is done in ascending order according to the keys. + */ + iterator + begin() _GLIBCXX_NOEXCEPT + { return _M_t.begin(); } + + /** + * Returns a read-only (constant) iterator that points to the first pair + * in the %map. Iteration is done in ascending order according to the + * keys. + */ + const_iterator + begin() const _GLIBCXX_NOEXCEPT + { return _M_t.begin(); } + + /** + * Returns a read/write iterator that points one past the last + * pair in the %map. Iteration is done in ascending order + * according to the keys. + */ + iterator + end() _GLIBCXX_NOEXCEPT + { return _M_t.end(); } + + /** + * Returns a read-only (constant) iterator that points one past the last + * pair in the %map. Iteration is done in ascending order according to + * the keys. + */ + const_iterator + end() const _GLIBCXX_NOEXCEPT + { return _M_t.end(); } + + /** + * Returns a read/write reverse iterator that points to the last pair in + * the %map. Iteration is done in descending order according to the + * keys. + */ + reverse_iterator + rbegin() _GLIBCXX_NOEXCEPT + { return _M_t.rbegin(); } + + /** + * Returns a read-only (constant) reverse iterator that points to the + * last pair in the %map. Iteration is done in descending order + * according to the keys. + */ + const_reverse_iterator + rbegin() const _GLIBCXX_NOEXCEPT + { return _M_t.rbegin(); } + + /** + * Returns a read/write reverse iterator that points to one before the + * first pair in the %map. Iteration is done in descending order + * according to the keys. + */ + reverse_iterator + rend() _GLIBCXX_NOEXCEPT + { return _M_t.rend(); } + + /** + * Returns a read-only (constant) reverse iterator that points to one + * before the first pair in the %map. Iteration is done in descending + * order according to the keys. + */ + const_reverse_iterator + rend() const _GLIBCXX_NOEXCEPT + { return _M_t.rend(); } + +#if __cplusplus >= 201103L + /** + * Returns a read-only (constant) iterator that points to the first pair + * in the %map. Iteration is done in ascending order according to the + * keys. + */ + const_iterator + cbegin() const noexcept + { return _M_t.begin(); } + + /** + * Returns a read-only (constant) iterator that points one past the last + * pair in the %map. Iteration is done in ascending order according to + * the keys. + */ + const_iterator + cend() const noexcept + { return _M_t.end(); } + + /** + * Returns a read-only (constant) reverse iterator that points to the + * last pair in the %map. Iteration is done in descending order + * according to the keys. + */ + const_reverse_iterator + crbegin() const noexcept + { return _M_t.rbegin(); } + + /** + * Returns a read-only (constant) reverse iterator that points to one + * before the first pair in the %map. Iteration is done in descending + * order according to the keys. + */ + const_reverse_iterator + crend() const noexcept + { return _M_t.rend(); } +#endif + + // capacity + /** Returns true if the %map is empty. (Thus begin() would equal + * end().) + */ + bool + empty() const _GLIBCXX_NOEXCEPT + { return _M_t.empty(); } + + /** Returns the size of the %map. */ + size_type + size() const _GLIBCXX_NOEXCEPT + { return _M_t.size(); } + + /** Returns the maximum size of the %map. */ + size_type + max_size() const _GLIBCXX_NOEXCEPT + { return _M_t.max_size(); } + + // [23.3.1.2] element access + /** + * @brief Subscript ( @c [] ) access to %map data. + * @param __k The key for which data should be retrieved. + * @return A reference to the data of the (key,data) %pair. + * + * Allows for easy lookup with the subscript ( @c [] ) + * operator. Returns data associated with the key specified in + * subscript. If the key does not exist, a pair with that key + * is created using default values, which is then returned. + * + * Lookup requires logarithmic time. + */ + mapped_type& + operator[](const key_type& __k) + { + // concept requirements + __glibcxx_function_requires(_DefaultConstructibleConcept) + + iterator __i = lower_bound(__k); + // __i->first is greater than or equivalent to __k. + if (__i == end() || key_comp()(__k, (*__i).first)) +#if __cplusplus >= 201103L + __i = _M_t._M_emplace_hint_unique(__i, std::piecewise_construct, + std::tuple(__k), + std::tuple<>()); +#else + __i = insert(__i, value_type(__k, mapped_type())); +#endif + return (*__i).second; + } + +#if __cplusplus >= 201103L + mapped_type& + operator[](key_type&& __k) + { + // concept requirements + __glibcxx_function_requires(_DefaultConstructibleConcept) + + iterator __i = lower_bound(__k); + // __i->first is greater than or equivalent to __k. + if (__i == end() || key_comp()(__k, (*__i).first)) + __i = _M_t._M_emplace_hint_unique(__i, std::piecewise_construct, + std::forward_as_tuple(std::move(__k)), + std::tuple<>()); + return (*__i).second; + } +#endif + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR 464. Suggestion for new member functions in standard containers. + /** + * @brief Access to %map data. + * @param __k The key for which data should be retrieved. + * @return A reference to the data whose key is equivalent to @a __k, if + * such a data is present in the %map. + * @throw std::out_of_range If no such data is present. + */ + mapped_type& + at(const key_type& __k) + { + iterator __i = lower_bound(__k); + if (__i == end() || key_comp()(__k, (*__i).first)) + __throw_out_of_range(__N("map::at")); + return (*__i).second; + } + + const mapped_type& + at(const key_type& __k) const + { + const_iterator __i = lower_bound(__k); + if (__i == end() || key_comp()(__k, (*__i).first)) + __throw_out_of_range(__N("map::at")); + return (*__i).second; + } + + // modifiers +#if __cplusplus >= 201103L + /** + * @brief Attempts to build and insert a std::pair into the %map. + * + * @param __args Arguments used to generate a new pair instance (see + * std::piecewise_contruct for passing arguments to each + * part of the pair constructor). + * + * @return A pair, of which the first element is an iterator that points + * to the possibly inserted pair, and the second is a bool that + * is true if the pair was actually inserted. + * + * This function attempts to build and insert a (key, value) %pair into + * the %map. + * A %map relies on unique keys and thus a %pair is only inserted if its + * first element (the key) is not already present in the %map. + * + * Insertion requires logarithmic time. + */ + template + std::pair + emplace(_Args&&... __args) + { return _M_t._M_emplace_unique(std::forward<_Args>(__args)...); } + + /** + * @brief Attempts to build and insert a std::pair into the %map. + * + * @param __pos An iterator that serves as a hint as to where the pair + * should be inserted. + * @param __args Arguments used to generate a new pair instance (see + * std::piecewise_contruct for passing arguments to each + * part of the pair constructor). + * @return An iterator that points to the element with key of the + * std::pair built from @a __args (may or may not be that + * std::pair). + * + * This function is not concerned about whether the insertion took place, + * and thus does not return a boolean like the single-argument emplace() + * does. + * Note that the first parameter is only a hint and can potentially + * improve the performance of the insertion process. A bad hint would + * cause no gains in efficiency. + * + * See + * http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt07ch17.html + * for more on @a hinting. + * + * Insertion requires logarithmic time (if the hint is not taken). + */ + template + iterator + emplace_hint(const_iterator __pos, _Args&&... __args) + { + return _M_t._M_emplace_hint_unique(__pos, + std::forward<_Args>(__args)...); + } +#endif + + /** + * @brief Attempts to insert a std::pair into the %map. + + * @param __x Pair to be inserted (see std::make_pair for easy + * creation of pairs). + * + * @return A pair, of which the first element is an iterator that + * points to the possibly inserted pair, and the second is + * a bool that is true if the pair was actually inserted. + * + * This function attempts to insert a (key, value) %pair into the %map. + * A %map relies on unique keys and thus a %pair is only inserted if its + * first element (the key) is not already present in the %map. + * + * Insertion requires logarithmic time. + */ + std::pair + insert(const value_type& __x) + { return _M_t._M_insert_unique(__x); } + +#if __cplusplus >= 201103L + template::value>::type> + std::pair + insert(_Pair&& __x) + { return _M_t._M_insert_unique(std::forward<_Pair>(__x)); } +#endif + +#if __cplusplus >= 201103L + /** + * @brief Attempts to insert a list of std::pairs into the %map. + * @param __list A std::initializer_list of pairs to be + * inserted. + * + * Complexity similar to that of the range constructor. + */ + void + insert(std::initializer_list __list) + { insert(__list.begin(), __list.end()); } +#endif + + /** + * @brief Attempts to insert a std::pair into the %map. + * @param __position An iterator that serves as a hint as to where the + * pair should be inserted. + * @param __x Pair to be inserted (see std::make_pair for easy creation + * of pairs). + * @return An iterator that points to the element with key of + * @a __x (may or may not be the %pair passed in). + * + + * This function is not concerned about whether the insertion + * took place, and thus does not return a boolean like the + * single-argument insert() does. Note that the first + * parameter is only a hint and can potentially improve the + * performance of the insertion process. A bad hint would + * cause no gains in efficiency. + * + * See + * http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt07ch17.html + * for more on @a hinting. + * + * Insertion requires logarithmic time (if the hint is not taken). + */ + iterator +#if __cplusplus >= 201103L + insert(const_iterator __position, const value_type& __x) +#else + insert(iterator __position, const value_type& __x) +#endif + { return _M_t._M_insert_unique_(__position, __x); } + +#if __cplusplus >= 201103L + template::value>::type> + iterator + insert(const_iterator __position, _Pair&& __x) + { return _M_t._M_insert_unique_(__position, + std::forward<_Pair>(__x)); } +#endif + + /** + * @brief Template function that attempts to insert a range of elements. + * @param __first Iterator pointing to the start of the range to be + * inserted. + * @param __last Iterator pointing to the end of the range. + * + * Complexity similar to that of the range constructor. + */ + template + void + insert(_InputIterator __first, _InputIterator __last) + { _M_t._M_insert_unique(__first, __last); } + +#if __cplusplus >= 201103L + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR 130. Associative erase should return an iterator. + /** + * @brief Erases an element from a %map. + * @param __position An iterator pointing to the element to be erased. + * @return An iterator pointing to the element immediately following + * @a position prior to the element being erased. If no such + * element exists, end() is returned. + * + * This function erases an element, pointed to by the given + * iterator, from a %map. Note that this function only erases + * the element, and that if the element is itself a pointer, + * the pointed-to memory is not touched in any way. Managing + * the pointer is the user's responsibility. + */ + iterator + erase(const_iterator __position) + { return _M_t.erase(__position); } + + // LWG 2059 + _GLIBCXX_ABI_TAG_CXX11 + iterator + erase(iterator __position) + { return _M_t.erase(__position); } +#else + /** + * @brief Erases an element from a %map. + * @param __position An iterator pointing to the element to be erased. + * + * This function erases an element, pointed to by the given + * iterator, from a %map. Note that this function only erases + * the element, and that if the element is itself a pointer, + * the pointed-to memory is not touched in any way. Managing + * the pointer is the user's responsibility. + */ + void + erase(iterator __position) + { _M_t.erase(__position); } +#endif + + /** + * @brief Erases elements according to the provided key. + * @param __x Key of element to be erased. + * @return The number of elements erased. + * + * This function erases all the elements located by the given key from + * a %map. + * Note that this function only erases the element, and that if + * the element is itself a pointer, the pointed-to memory is not touched + * in any way. Managing the pointer is the user's responsibility. + */ + size_type + erase(const key_type& __x) + { return _M_t.erase(__x); } + +#if __cplusplus >= 201103L + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR 130. Associative erase should return an iterator. + /** + * @brief Erases a [first,last) range of elements from a %map. + * @param __first Iterator pointing to the start of the range to be + * erased. + * @param __last Iterator pointing to the end of the range to + * be erased. + * @return The iterator @a __last. + * + * This function erases a sequence of elements from a %map. + * Note that this function only erases the element, and that if + * the element is itself a pointer, the pointed-to memory is not touched + * in any way. Managing the pointer is the user's responsibility. + */ + iterator + erase(const_iterator __first, const_iterator __last) + { return _M_t.erase(__first, __last); } +#else + /** + * @brief Erases a [__first,__last) range of elements from a %map. + * @param __first Iterator pointing to the start of the range to be + * erased. + * @param __last Iterator pointing to the end of the range to + * be erased. + * + * This function erases a sequence of elements from a %map. + * Note that this function only erases the element, and that if + * the element is itself a pointer, the pointed-to memory is not touched + * in any way. Managing the pointer is the user's responsibility. + */ + void + erase(iterator __first, iterator __last) + { _M_t.erase(__first, __last); } +#endif + + /** + * @brief Swaps data with another %map. + * @param __x A %map of the same element and allocator types. + * + * This exchanges the elements between two maps in constant + * time. (It is only swapping a pointer, an integer, and an + * instance of the @c Compare type (which itself is often + * stateless and empty), so it should be quite fast.) Note + * that the global std::swap() function is specialized such + * that std::swap(m1,m2) will feed to this function. + */ + void + swap(map& __x) +#if __cplusplus >= 201103L + noexcept(_Alloc_traits::_S_nothrow_swap()) +#endif + { _M_t.swap(__x._M_t); } + + /** + * Erases all elements in a %map. Note that this function only + * erases the elements, and that if the elements themselves are + * pointers, the pointed-to memory is not touched in any way. + * Managing the pointer is the user's responsibility. + */ + void + clear() _GLIBCXX_NOEXCEPT + { _M_t.clear(); } + + // observers + /** + * Returns the key comparison object out of which the %map was + * constructed. + */ + key_compare + key_comp() const + { return _M_t.key_comp(); } + + /** + * Returns a value comparison object, built from the key comparison + * object out of which the %map was constructed. + */ + value_compare + value_comp() const + { return value_compare(_M_t.key_comp()); } + + // [23.3.1.3] map operations + /** + * @brief Tries to locate an element in a %map. + * @param __x Key of (key, value) %pair to be located. + * @return Iterator pointing to sought-after element, or end() if not + * found. + * + * This function takes a key and tries to locate the element with which + * the key matches. If successful the function returns an iterator + * pointing to the sought after %pair. If unsuccessful it returns the + * past-the-end ( @c end() ) iterator. + */ + iterator + find(const key_type& __x) + { return _M_t.find(__x); } + + /** + * @brief Tries to locate an element in a %map. + * @param __x Key of (key, value) %pair to be located. + * @return Read-only (constant) iterator pointing to sought-after + * element, or end() if not found. + * + * This function takes a key and tries to locate the element with which + * the key matches. If successful the function returns a constant + * iterator pointing to the sought after %pair. If unsuccessful it + * returns the past-the-end ( @c end() ) iterator. + */ + const_iterator + find(const key_type& __x) const + { return _M_t.find(__x); } + + /** + * @brief Finds the number of elements with given key. + * @param __x Key of (key, value) pairs to be located. + * @return Number of elements with specified key. + * + * This function only makes sense for multimaps; for map the result will + * either be 0 (not present) or 1 (present). + */ + size_type + count(const key_type& __x) const + { return _M_t.find(__x) == _M_t.end() ? 0 : 1; } + + /** + * @brief Finds the beginning of a subsequence matching given key. + * @param __x Key of (key, value) pair to be located. + * @return Iterator pointing to first element equal to or greater + * than key, or end(). + * + * This function returns the first element of a subsequence of elements + * that matches the given key. If unsuccessful it returns an iterator + * pointing to the first element that has a greater value than given key + * or end() if no such element exists. + */ + iterator + lower_bound(const key_type& __x) + { return _M_t.lower_bound(__x); } + + /** + * @brief Finds the beginning of a subsequence matching given key. + * @param __x Key of (key, value) pair to be located. + * @return Read-only (constant) iterator pointing to first element + * equal to or greater than key, or end(). + * + * This function returns the first element of a subsequence of elements + * that matches the given key. If unsuccessful it returns an iterator + * pointing to the first element that has a greater value than given key + * or end() if no such element exists. + */ + const_iterator + lower_bound(const key_type& __x) const + { return _M_t.lower_bound(__x); } + + /** + * @brief Finds the end of a subsequence matching given key. + * @param __x Key of (key, value) pair to be located. + * @return Iterator pointing to the first element + * greater than key, or end(). + */ + iterator + upper_bound(const key_type& __x) + { return _M_t.upper_bound(__x); } + + /** + * @brief Finds the end of a subsequence matching given key. + * @param __x Key of (key, value) pair to be located. + * @return Read-only (constant) iterator pointing to first iterator + * greater than key, or end(). + */ + const_iterator + upper_bound(const key_type& __x) const + { return _M_t.upper_bound(__x); } + + /** + * @brief Finds a subsequence matching given key. + * @param __x Key of (key, value) pairs to be located. + * @return Pair of iterators that possibly points to the subsequence + * matching given key. + * + * This function is equivalent to + * @code + * std::make_pair(c.lower_bound(val), + * c.upper_bound(val)) + * @endcode + * (but is faster than making the calls separately). + * + * This function probably only makes sense for multimaps. + */ + std::pair + equal_range(const key_type& __x) + { return _M_t.equal_range(__x); } + + /** + * @brief Finds a subsequence matching given key. + * @param __x Key of (key, value) pairs to be located. + * @return Pair of read-only (constant) iterators that possibly points + * to the subsequence matching given key. + * + * This function is equivalent to + * @code + * std::make_pair(c.lower_bound(val), + * c.upper_bound(val)) + * @endcode + * (but is faster than making the calls separately). + * + * This function probably only makes sense for multimaps. + */ + std::pair + equal_range(const key_type& __x) const + { return _M_t.equal_range(__x); } + + template + friend bool + operator==(const map<_K1, _T1, _C1, _A1>&, + const map<_K1, _T1, _C1, _A1>&); + + template + friend bool + operator<(const map<_K1, _T1, _C1, _A1>&, + const map<_K1, _T1, _C1, _A1>&); + }; + + /** + * @brief Map equality comparison. + * @param __x A %map. + * @param __y A %map of the same type as @a x. + * @return True iff the size and elements of the maps are equal. + * + * This is an equivalence relation. It is linear in the size of the + * maps. Maps are considered equivalent if their sizes are equal, + * and if corresponding elements compare equal. + */ + template + inline bool + operator==(const map<_Key, _Tp, _Compare, _Alloc>& __x, + const map<_Key, _Tp, _Compare, _Alloc>& __y) + { return __x._M_t == __y._M_t; } + + /** + * @brief Map ordering relation. + * @param __x A %map. + * @param __y A %map of the same type as @a x. + * @return True iff @a x is lexicographically less than @a y. + * + * This is a total ordering relation. It is linear in the size of the + * maps. The elements must be comparable with @c <. + * + * See std::lexicographical_compare() for how the determination is made. + */ + template + inline bool + operator<(const map<_Key, _Tp, _Compare, _Alloc>& __x, + const map<_Key, _Tp, _Compare, _Alloc>& __y) + { return __x._M_t < __y._M_t; } + + /// Based on operator== + template + inline bool + operator!=(const map<_Key, _Tp, _Compare, _Alloc>& __x, + const map<_Key, _Tp, _Compare, _Alloc>& __y) + { return !(__x == __y); } + + /// Based on operator< + template + inline bool + operator>(const map<_Key, _Tp, _Compare, _Alloc>& __x, + const map<_Key, _Tp, _Compare, _Alloc>& __y) + { return __y < __x; } + + /// Based on operator< + template + inline bool + operator<=(const map<_Key, _Tp, _Compare, _Alloc>& __x, + const map<_Key, _Tp, _Compare, _Alloc>& __y) + { return !(__y < __x); } + + /// Based on operator< + template + inline bool + operator>=(const map<_Key, _Tp, _Compare, _Alloc>& __x, + const map<_Key, _Tp, _Compare, _Alloc>& __y) + { return !(__x < __y); } + + /// See std::map::swap(). + template + inline void + swap(map<_Key, _Tp, _Compare, _Alloc>& __x, + map<_Key, _Tp, _Compare, _Alloc>& __y) + { __x.swap(__y); } + +_GLIBCXX_END_NAMESPACE_CONTAINER +} // namespace std + +#endif /* _STL_MAP_H */ diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stl_multimap.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stl_multimap.h new file mode 100755 index 0000000..c7b80c9 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stl_multimap.h @@ -0,0 +1,962 @@ +// Multimap implementation -*- C++ -*- + +// Copyright (C) 2001-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/* + * + * Copyright (c) 1994 + * Hewlett-Packard Company + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Hewlett-Packard Company makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + * + * + * Copyright (c) 1996,1997 + * Silicon Graphics Computer Systems, Inc. + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Silicon Graphics makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + */ + +/** @file bits/stl_multimap.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{map} + */ + +#ifndef _STL_MULTIMAP_H +#define _STL_MULTIMAP_H 1 + +#include +#if __cplusplus >= 201103L +#include +#endif + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_CONTAINER + + /** + * @brief A standard container made up of (key,value) pairs, which can be + * retrieved based on a key, in logarithmic time. + * + * @ingroup associative_containers + * + * @tparam _Key Type of key objects. + * @tparam _Tp Type of mapped objects. + * @tparam _Compare Comparison function object type, defaults to less<_Key>. + * @tparam _Alloc Allocator type, defaults to + * allocator. + * + * Meets the requirements of a container, a + * reversible container, and an + * associative container (using equivalent + * keys). For a @c multimap the key_type is Key, the mapped_type + * is T, and the value_type is std::pair. + * + * Multimaps support bidirectional iterators. + * + * The private tree data is declared exactly the same way for map and + * multimap; the distinction is made entirely in how the tree functions are + * called (*_unique versus *_equal, same as the standard). + */ + template , + typename _Alloc = std::allocator > > + class multimap + { + public: + typedef _Key key_type; + typedef _Tp mapped_type; + typedef std::pair value_type; + typedef _Compare key_compare; + typedef _Alloc allocator_type; + + private: + // concept requirements + typedef typename _Alloc::value_type _Alloc_value_type; + __glibcxx_class_requires(_Tp, _SGIAssignableConcept) + __glibcxx_class_requires4(_Compare, bool, _Key, _Key, + _BinaryFunctionConcept) + __glibcxx_class_requires2(value_type, _Alloc_value_type, _SameTypeConcept) + + public: + class value_compare + : public std::binary_function + { + friend class multimap<_Key, _Tp, _Compare, _Alloc>; + protected: + _Compare comp; + + value_compare(_Compare __c) + : comp(__c) { } + + public: + bool operator()(const value_type& __x, const value_type& __y) const + { return comp(__x.first, __y.first); } + }; + + private: + /// This turns a red-black tree into a [multi]map. + typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template + rebind::other _Pair_alloc_type; + + typedef _Rb_tree, + key_compare, _Pair_alloc_type> _Rep_type; + /// The actual tree structure. + _Rep_type _M_t; + + typedef __gnu_cxx::__alloc_traits<_Pair_alloc_type> _Alloc_traits; + + public: + // many of these are specified differently in ISO, but the following are + // "functionally equivalent" + typedef typename _Alloc_traits::pointer pointer; + typedef typename _Alloc_traits::const_pointer const_pointer; + typedef typename _Alloc_traits::reference reference; + typedef typename _Alloc_traits::const_reference const_reference; + typedef typename _Rep_type::iterator iterator; + typedef typename _Rep_type::const_iterator const_iterator; + typedef typename _Rep_type::size_type size_type; + typedef typename _Rep_type::difference_type difference_type; + typedef typename _Rep_type::reverse_iterator reverse_iterator; + typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator; + + // [23.3.2] construct/copy/destroy + // (get_allocator() is also listed in this section) + + /** + * @brief Default constructor creates no elements. + */ + multimap() + : _M_t() { } + + /** + * @brief Creates a %multimap with no elements. + * @param __comp A comparison object. + * @param __a An allocator object. + */ + explicit + multimap(const _Compare& __comp, + const allocator_type& __a = allocator_type()) + : _M_t(__comp, _Pair_alloc_type(__a)) { } + + /** + * @brief %Multimap copy constructor. + * @param __x A %multimap of identical element and allocator types. + * + * The newly-created %multimap uses a copy of the allocation object + * used by @a __x. + */ + multimap(const multimap& __x) + : _M_t(__x._M_t) { } + +#if __cplusplus >= 201103L + /** + * @brief %Multimap move constructor. + * @param __x A %multimap of identical element and allocator types. + * + * The newly-created %multimap contains the exact contents of @a __x. + * The contents of @a __x are a valid, but unspecified %multimap. + */ + multimap(multimap&& __x) + noexcept(is_nothrow_copy_constructible<_Compare>::value) + : _M_t(std::move(__x._M_t)) { } + + /** + * @brief Builds a %multimap from an initializer_list. + * @param __l An initializer_list. + * @param __comp A comparison functor. + * @param __a An allocator object. + * + * Create a %multimap consisting of copies of the elements from + * the initializer_list. This is linear in N if the list is already + * sorted, and NlogN otherwise (where N is @a __l.size()). + */ + multimap(initializer_list __l, + const _Compare& __comp = _Compare(), + const allocator_type& __a = allocator_type()) + : _M_t(__comp, _Pair_alloc_type(__a)) + { _M_t._M_insert_equal(__l.begin(), __l.end()); } + + /// Allocator-extended default constructor. + explicit + multimap(const allocator_type& __a) + : _M_t(_Compare(), _Pair_alloc_type(__a)) { } + + /// Allocator-extended copy constructor. + multimap(const multimap& __m, const allocator_type& __a) + : _M_t(__m._M_t, _Pair_alloc_type(__a)) { } + + /// Allocator-extended move constructor. + multimap(multimap&& __m, const allocator_type& __a) + noexcept(is_nothrow_copy_constructible<_Compare>::value + && _Alloc_traits::_S_always_equal()) + : _M_t(std::move(__m._M_t), _Pair_alloc_type(__a)) { } + + /// Allocator-extended initialier-list constructor. + multimap(initializer_list __l, const allocator_type& __a) + : _M_t(_Compare(), _Pair_alloc_type(__a)) + { _M_t._M_insert_equal(__l.begin(), __l.end()); } + + /// Allocator-extended range constructor. + template + multimap(_InputIterator __first, _InputIterator __last, + const allocator_type& __a) + : _M_t(_Compare(), _Pair_alloc_type(__a)) + { _M_t._M_insert_equal(__first, __last); } +#endif + + /** + * @brief Builds a %multimap from a range. + * @param __first An input iterator. + * @param __last An input iterator. + * + * Create a %multimap consisting of copies of the elements from + * [__first,__last). This is linear in N if the range is already sorted, + * and NlogN otherwise (where N is distance(__first,__last)). + */ + template + multimap(_InputIterator __first, _InputIterator __last) + : _M_t() + { _M_t._M_insert_equal(__first, __last); } + + /** + * @brief Builds a %multimap from a range. + * @param __first An input iterator. + * @param __last An input iterator. + * @param __comp A comparison functor. + * @param __a An allocator object. + * + * Create a %multimap consisting of copies of the elements from + * [__first,__last). This is linear in N if the range is already sorted, + * and NlogN otherwise (where N is distance(__first,__last)). + */ + template + multimap(_InputIterator __first, _InputIterator __last, + const _Compare& __comp, + const allocator_type& __a = allocator_type()) + : _M_t(__comp, _Pair_alloc_type(__a)) + { _M_t._M_insert_equal(__first, __last); } + + // FIXME There is no dtor declared, but we should have something generated + // by Doxygen. I don't know what tags to add to this paragraph to make + // that happen: + /** + * The dtor only erases the elements, and note that if the elements + * themselves are pointers, the pointed-to memory is not touched in any + * way. Managing the pointer is the user's responsibility. + */ + + /** + * @brief %Multimap assignment operator. + * @param __x A %multimap of identical element and allocator types. + * + * All the elements of @a __x are copied, but unlike the copy + * constructor, the allocator object is not copied. + */ + multimap& + operator=(const multimap& __x) + { + _M_t = __x._M_t; + return *this; + } + +#if __cplusplus >= 201103L + /** + * @brief %Multimap move assignment operator. + * @param __x A %multimap of identical element and allocator types. + * + * The contents of @a __x are moved into this multimap (without copying + * if the allocators compare equal or get moved on assignment). + * Afterwards @a __x is in a valid, but unspecified state. + */ + multimap& + operator=(multimap&& __x) noexcept(_Alloc_traits::_S_nothrow_move()) + { + if (!_M_t._M_move_assign(__x._M_t)) + { + // The rvalue's allocator cannot be moved and is not equal, + // so we need to individually move each element. + clear(); + insert(std::__make_move_if_noexcept_iterator(__x.begin()), + std::__make_move_if_noexcept_iterator(__x.end())); + __x.clear(); + } + return *this; + } + + /** + * @brief %Multimap list assignment operator. + * @param __l An initializer_list. + * + * This function fills a %multimap with copies of the elements + * in the initializer list @a __l. + * + * Note that the assignment completely changes the %multimap and + * that the resulting %multimap's size is the same as the number + * of elements assigned. Old data may be lost. + */ + multimap& + operator=(initializer_list __l) + { + this->clear(); + this->insert(__l.begin(), __l.end()); + return *this; + } +#endif + + /// Get a copy of the memory allocation object. + allocator_type + get_allocator() const _GLIBCXX_NOEXCEPT + { return allocator_type(_M_t.get_allocator()); } + + // iterators + /** + * Returns a read/write iterator that points to the first pair in the + * %multimap. Iteration is done in ascending order according to the + * keys. + */ + iterator + begin() _GLIBCXX_NOEXCEPT + { return _M_t.begin(); } + + /** + * Returns a read-only (constant) iterator that points to the first pair + * in the %multimap. Iteration is done in ascending order according to + * the keys. + */ + const_iterator + begin() const _GLIBCXX_NOEXCEPT + { return _M_t.begin(); } + + /** + * Returns a read/write iterator that points one past the last pair in + * the %multimap. Iteration is done in ascending order according to the + * keys. + */ + iterator + end() _GLIBCXX_NOEXCEPT + { return _M_t.end(); } + + /** + * Returns a read-only (constant) iterator that points one past the last + * pair in the %multimap. Iteration is done in ascending order according + * to the keys. + */ + const_iterator + end() const _GLIBCXX_NOEXCEPT + { return _M_t.end(); } + + /** + * Returns a read/write reverse iterator that points to the last pair in + * the %multimap. Iteration is done in descending order according to the + * keys. + */ + reverse_iterator + rbegin() _GLIBCXX_NOEXCEPT + { return _M_t.rbegin(); } + + /** + * Returns a read-only (constant) reverse iterator that points to the + * last pair in the %multimap. Iteration is done in descending order + * according to the keys. + */ + const_reverse_iterator + rbegin() const _GLIBCXX_NOEXCEPT + { return _M_t.rbegin(); } + + /** + * Returns a read/write reverse iterator that points to one before the + * first pair in the %multimap. Iteration is done in descending order + * according to the keys. + */ + reverse_iterator + rend() _GLIBCXX_NOEXCEPT + { return _M_t.rend(); } + + /** + * Returns a read-only (constant) reverse iterator that points to one + * before the first pair in the %multimap. Iteration is done in + * descending order according to the keys. + */ + const_reverse_iterator + rend() const _GLIBCXX_NOEXCEPT + { return _M_t.rend(); } + +#if __cplusplus >= 201103L + /** + * Returns a read-only (constant) iterator that points to the first pair + * in the %multimap. Iteration is done in ascending order according to + * the keys. + */ + const_iterator + cbegin() const noexcept + { return _M_t.begin(); } + + /** + * Returns a read-only (constant) iterator that points one past the last + * pair in the %multimap. Iteration is done in ascending order according + * to the keys. + */ + const_iterator + cend() const noexcept + { return _M_t.end(); } + + /** + * Returns a read-only (constant) reverse iterator that points to the + * last pair in the %multimap. Iteration is done in descending order + * according to the keys. + */ + const_reverse_iterator + crbegin() const noexcept + { return _M_t.rbegin(); } + + /** + * Returns a read-only (constant) reverse iterator that points to one + * before the first pair in the %multimap. Iteration is done in + * descending order according to the keys. + */ + const_reverse_iterator + crend() const noexcept + { return _M_t.rend(); } +#endif + + // capacity + /** Returns true if the %multimap is empty. */ + bool + empty() const _GLIBCXX_NOEXCEPT + { return _M_t.empty(); } + + /** Returns the size of the %multimap. */ + size_type + size() const _GLIBCXX_NOEXCEPT + { return _M_t.size(); } + + /** Returns the maximum size of the %multimap. */ + size_type + max_size() const _GLIBCXX_NOEXCEPT + { return _M_t.max_size(); } + + // modifiers +#if __cplusplus >= 201103L + /** + * @brief Build and insert a std::pair into the %multimap. + * + * @param __args Arguments used to generate a new pair instance (see + * std::piecewise_contruct for passing arguments to each + * part of the pair constructor). + * + * @return An iterator that points to the inserted (key,value) pair. + * + * This function builds and inserts a (key, value) %pair into the + * %multimap. + * Contrary to a std::map the %multimap does not rely on unique keys and + * thus multiple pairs with the same key can be inserted. + * + * Insertion requires logarithmic time. + */ + template + iterator + emplace(_Args&&... __args) + { return _M_t._M_emplace_equal(std::forward<_Args>(__args)...); } + + /** + * @brief Builds and inserts a std::pair into the %multimap. + * + * @param __pos An iterator that serves as a hint as to where the pair + * should be inserted. + * @param __args Arguments used to generate a new pair instance (see + * std::piecewise_contruct for passing arguments to each + * part of the pair constructor). + * @return An iterator that points to the inserted (key,value) pair. + * + * This function inserts a (key, value) pair into the %multimap. + * Contrary to a std::map the %multimap does not rely on unique keys and + * thus multiple pairs with the same key can be inserted. + * Note that the first parameter is only a hint and can potentially + * improve the performance of the insertion process. A bad hint would + * cause no gains in efficiency. + * + * For more on @a hinting, see: + * http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt07ch17.html + * + * Insertion requires logarithmic time (if the hint is not taken). + */ + template + iterator + emplace_hint(const_iterator __pos, _Args&&... __args) + { + return _M_t._M_emplace_hint_equal(__pos, + std::forward<_Args>(__args)...); + } +#endif + + /** + * @brief Inserts a std::pair into the %multimap. + * @param __x Pair to be inserted (see std::make_pair for easy creation + * of pairs). + * @return An iterator that points to the inserted (key,value) pair. + * + * This function inserts a (key, value) pair into the %multimap. + * Contrary to a std::map the %multimap does not rely on unique keys and + * thus multiple pairs with the same key can be inserted. + * + * Insertion requires logarithmic time. + */ + iterator + insert(const value_type& __x) + { return _M_t._M_insert_equal(__x); } + +#if __cplusplus >= 201103L + template::value>::type> + iterator + insert(_Pair&& __x) + { return _M_t._M_insert_equal(std::forward<_Pair>(__x)); } +#endif + + /** + * @brief Inserts a std::pair into the %multimap. + * @param __position An iterator that serves as a hint as to where the + * pair should be inserted. + * @param __x Pair to be inserted (see std::make_pair for easy creation + * of pairs). + * @return An iterator that points to the inserted (key,value) pair. + * + * This function inserts a (key, value) pair into the %multimap. + * Contrary to a std::map the %multimap does not rely on unique keys and + * thus multiple pairs with the same key can be inserted. + * Note that the first parameter is only a hint and can potentially + * improve the performance of the insertion process. A bad hint would + * cause no gains in efficiency. + * + * For more on @a hinting, see: + * http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt07ch17.html + * + * Insertion requires logarithmic time (if the hint is not taken). + */ + iterator +#if __cplusplus >= 201103L + insert(const_iterator __position, const value_type& __x) +#else + insert(iterator __position, const value_type& __x) +#endif + { return _M_t._M_insert_equal_(__position, __x); } + +#if __cplusplus >= 201103L + template::value>::type> + iterator + insert(const_iterator __position, _Pair&& __x) + { return _M_t._M_insert_equal_(__position, + std::forward<_Pair>(__x)); } +#endif + + /** + * @brief A template function that attempts to insert a range + * of elements. + * @param __first Iterator pointing to the start of the range to be + * inserted. + * @param __last Iterator pointing to the end of the range. + * + * Complexity similar to that of the range constructor. + */ + template + void + insert(_InputIterator __first, _InputIterator __last) + { _M_t._M_insert_equal(__first, __last); } + +#if __cplusplus >= 201103L + /** + * @brief Attempts to insert a list of std::pairs into the %multimap. + * @param __l A std::initializer_list of pairs to be + * inserted. + * + * Complexity similar to that of the range constructor. + */ + void + insert(initializer_list __l) + { this->insert(__l.begin(), __l.end()); } +#endif + +#if __cplusplus >= 201103L + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR 130. Associative erase should return an iterator. + /** + * @brief Erases an element from a %multimap. + * @param __position An iterator pointing to the element to be erased. + * @return An iterator pointing to the element immediately following + * @a position prior to the element being erased. If no such + * element exists, end() is returned. + * + * This function erases an element, pointed to by the given iterator, + * from a %multimap. Note that this function only erases the element, + * and that if the element is itself a pointer, the pointed-to memory is + * not touched in any way. Managing the pointer is the user's + * responsibility. + */ + iterator + erase(const_iterator __position) + { return _M_t.erase(__position); } + + // LWG 2059. + _GLIBCXX_ABI_TAG_CXX11 + iterator + erase(iterator __position) + { return _M_t.erase(__position); } +#else + /** + * @brief Erases an element from a %multimap. + * @param __position An iterator pointing to the element to be erased. + * + * This function erases an element, pointed to by the given iterator, + * from a %multimap. Note that this function only erases the element, + * and that if the element is itself a pointer, the pointed-to memory is + * not touched in any way. Managing the pointer is the user's + * responsibility. + */ + void + erase(iterator __position) + { _M_t.erase(__position); } +#endif + + /** + * @brief Erases elements according to the provided key. + * @param __x Key of element to be erased. + * @return The number of elements erased. + * + * This function erases all elements located by the given key from a + * %multimap. + * Note that this function only erases the element, and that if + * the element is itself a pointer, the pointed-to memory is not touched + * in any way. Managing the pointer is the user's responsibility. + */ + size_type + erase(const key_type& __x) + { return _M_t.erase(__x); } + +#if __cplusplus >= 201103L + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR 130. Associative erase should return an iterator. + /** + * @brief Erases a [first,last) range of elements from a %multimap. + * @param __first Iterator pointing to the start of the range to be + * erased. + * @param __last Iterator pointing to the end of the range to be + * erased . + * @return The iterator @a __last. + * + * This function erases a sequence of elements from a %multimap. + * Note that this function only erases the elements, and that if + * the elements themselves are pointers, the pointed-to memory is not + * touched in any way. Managing the pointer is the user's + * responsibility. + */ + iterator + erase(const_iterator __first, const_iterator __last) + { return _M_t.erase(__first, __last); } +#else + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR 130. Associative erase should return an iterator. + /** + * @brief Erases a [first,last) range of elements from a %multimap. + * @param __first Iterator pointing to the start of the range to be + * erased. + * @param __last Iterator pointing to the end of the range to + * be erased. + * + * This function erases a sequence of elements from a %multimap. + * Note that this function only erases the elements, and that if + * the elements themselves are pointers, the pointed-to memory is not + * touched in any way. Managing the pointer is the user's + * responsibility. + */ + void + erase(iterator __first, iterator __last) + { _M_t.erase(__first, __last); } +#endif + + /** + * @brief Swaps data with another %multimap. + * @param __x A %multimap of the same element and allocator types. + * + * This exchanges the elements between two multimaps in constant time. + * (It is only swapping a pointer, an integer, and an instance of + * the @c Compare type (which itself is often stateless and empty), so it + * should be quite fast.) + * Note that the global std::swap() function is specialized such that + * std::swap(m1,m2) will feed to this function. + */ + void + swap(multimap& __x) +#if __cplusplus >= 201103L + noexcept(_Alloc_traits::_S_nothrow_swap()) +#endif + { _M_t.swap(__x._M_t); } + + /** + * Erases all elements in a %multimap. Note that this function only + * erases the elements, and that if the elements themselves are pointers, + * the pointed-to memory is not touched in any way. Managing the pointer + * is the user's responsibility. + */ + void + clear() _GLIBCXX_NOEXCEPT + { _M_t.clear(); } + + // observers + /** + * Returns the key comparison object out of which the %multimap + * was constructed. + */ + key_compare + key_comp() const + { return _M_t.key_comp(); } + + /** + * Returns a value comparison object, built from the key comparison + * object out of which the %multimap was constructed. + */ + value_compare + value_comp() const + { return value_compare(_M_t.key_comp()); } + + // multimap operations + /** + * @brief Tries to locate an element in a %multimap. + * @param __x Key of (key, value) pair to be located. + * @return Iterator pointing to sought-after element, + * or end() if not found. + * + * This function takes a key and tries to locate the element with which + * the key matches. If successful the function returns an iterator + * pointing to the sought after %pair. If unsuccessful it returns the + * past-the-end ( @c end() ) iterator. + */ + iterator + find(const key_type& __x) + { return _M_t.find(__x); } + + /** + * @brief Tries to locate an element in a %multimap. + * @param __x Key of (key, value) pair to be located. + * @return Read-only (constant) iterator pointing to sought-after + * element, or end() if not found. + * + * This function takes a key and tries to locate the element with which + * the key matches. If successful the function returns a constant + * iterator pointing to the sought after %pair. If unsuccessful it + * returns the past-the-end ( @c end() ) iterator. + */ + const_iterator + find(const key_type& __x) const + { return _M_t.find(__x); } + + /** + * @brief Finds the number of elements with given key. + * @param __x Key of (key, value) pairs to be located. + * @return Number of elements with specified key. + */ + size_type + count(const key_type& __x) const + { return _M_t.count(__x); } + + /** + * @brief Finds the beginning of a subsequence matching given key. + * @param __x Key of (key, value) pair to be located. + * @return Iterator pointing to first element equal to or greater + * than key, or end(). + * + * This function returns the first element of a subsequence of elements + * that matches the given key. If unsuccessful it returns an iterator + * pointing to the first element that has a greater value than given key + * or end() if no such element exists. + */ + iterator + lower_bound(const key_type& __x) + { return _M_t.lower_bound(__x); } + + /** + * @brief Finds the beginning of a subsequence matching given key. + * @param __x Key of (key, value) pair to be located. + * @return Read-only (constant) iterator pointing to first element + * equal to or greater than key, or end(). + * + * This function returns the first element of a subsequence of + * elements that matches the given key. If unsuccessful the + * iterator will point to the next greatest element or, if no + * such greater element exists, to end(). + */ + const_iterator + lower_bound(const key_type& __x) const + { return _M_t.lower_bound(__x); } + + /** + * @brief Finds the end of a subsequence matching given key. + * @param __x Key of (key, value) pair to be located. + * @return Iterator pointing to the first element + * greater than key, or end(). + */ + iterator + upper_bound(const key_type& __x) + { return _M_t.upper_bound(__x); } + + /** + * @brief Finds the end of a subsequence matching given key. + * @param __x Key of (key, value) pair to be located. + * @return Read-only (constant) iterator pointing to first iterator + * greater than key, or end(). + */ + const_iterator + upper_bound(const key_type& __x) const + { return _M_t.upper_bound(__x); } + + /** + * @brief Finds a subsequence matching given key. + * @param __x Key of (key, value) pairs to be located. + * @return Pair of iterators that possibly points to the subsequence + * matching given key. + * + * This function is equivalent to + * @code + * std::make_pair(c.lower_bound(val), + * c.upper_bound(val)) + * @endcode + * (but is faster than making the calls separately). + */ + std::pair + equal_range(const key_type& __x) + { return _M_t.equal_range(__x); } + + /** + * @brief Finds a subsequence matching given key. + * @param __x Key of (key, value) pairs to be located. + * @return Pair of read-only (constant) iterators that possibly points + * to the subsequence matching given key. + * + * This function is equivalent to + * @code + * std::make_pair(c.lower_bound(val), + * c.upper_bound(val)) + * @endcode + * (but is faster than making the calls separately). + */ + std::pair + equal_range(const key_type& __x) const + { return _M_t.equal_range(__x); } + + template + friend bool + operator==(const multimap<_K1, _T1, _C1, _A1>&, + const multimap<_K1, _T1, _C1, _A1>&); + + template + friend bool + operator<(const multimap<_K1, _T1, _C1, _A1>&, + const multimap<_K1, _T1, _C1, _A1>&); + }; + + /** + * @brief Multimap equality comparison. + * @param __x A %multimap. + * @param __y A %multimap of the same type as @a __x. + * @return True iff the size and elements of the maps are equal. + * + * This is an equivalence relation. It is linear in the size of the + * multimaps. Multimaps are considered equivalent if their sizes are equal, + * and if corresponding elements compare equal. + */ + template + inline bool + operator==(const multimap<_Key, _Tp, _Compare, _Alloc>& __x, + const multimap<_Key, _Tp, _Compare, _Alloc>& __y) + { return __x._M_t == __y._M_t; } + + /** + * @brief Multimap ordering relation. + * @param __x A %multimap. + * @param __y A %multimap of the same type as @a __x. + * @return True iff @a x is lexicographically less than @a y. + * + * This is a total ordering relation. It is linear in the size of the + * multimaps. The elements must be comparable with @c <. + * + * See std::lexicographical_compare() for how the determination is made. + */ + template + inline bool + operator<(const multimap<_Key, _Tp, _Compare, _Alloc>& __x, + const multimap<_Key, _Tp, _Compare, _Alloc>& __y) + { return __x._M_t < __y._M_t; } + + /// Based on operator== + template + inline bool + operator!=(const multimap<_Key, _Tp, _Compare, _Alloc>& __x, + const multimap<_Key, _Tp, _Compare, _Alloc>& __y) + { return !(__x == __y); } + + /// Based on operator< + template + inline bool + operator>(const multimap<_Key, _Tp, _Compare, _Alloc>& __x, + const multimap<_Key, _Tp, _Compare, _Alloc>& __y) + { return __y < __x; } + + /// Based on operator< + template + inline bool + operator<=(const multimap<_Key, _Tp, _Compare, _Alloc>& __x, + const multimap<_Key, _Tp, _Compare, _Alloc>& __y) + { return !(__y < __x); } + + /// Based on operator< + template + inline bool + operator>=(const multimap<_Key, _Tp, _Compare, _Alloc>& __x, + const multimap<_Key, _Tp, _Compare, _Alloc>& __y) + { return !(__x < __y); } + + /// See std::multimap::swap(). + template + inline void + swap(multimap<_Key, _Tp, _Compare, _Alloc>& __x, + multimap<_Key, _Tp, _Compare, _Alloc>& __y) + { __x.swap(__y); } + +_GLIBCXX_END_NAMESPACE_CONTAINER +} // namespace std + +#endif /* _STL_MULTIMAP_H */ diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stl_multiset.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stl_multiset.h new file mode 100755 index 0000000..6d71c1b --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stl_multiset.h @@ -0,0 +1,836 @@ +// Multiset implementation -*- C++ -*- + +// Copyright (C) 2001-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/* + * + * Copyright (c) 1994 + * Hewlett-Packard Company + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Hewlett-Packard Company makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + * + * + * Copyright (c) 1996 + * Silicon Graphics Computer Systems, Inc. + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Silicon Graphics makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + */ + +/** @file bits/stl_multiset.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{set} + */ + +#ifndef _STL_MULTISET_H +#define _STL_MULTISET_H 1 + +#include +#if __cplusplus >= 201103L +#include +#endif + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_CONTAINER + + /** + * @brief A standard container made up of elements, which can be retrieved + * in logarithmic time. + * + * @ingroup associative_containers + * + * + * @tparam _Key Type of key objects. + * @tparam _Compare Comparison function object type, defaults to less<_Key>. + * @tparam _Alloc Allocator type, defaults to allocator<_Key>. + * + * Meets the requirements of a container, a + * reversible container, and an + * associative container (using equivalent + * keys). For a @c multiset the key_type and value_type are Key. + * + * Multisets support bidirectional iterators. + * + * The private tree data is declared exactly the same way for set and + * multiset; the distinction is made entirely in how the tree functions are + * called (*_unique versus *_equal, same as the standard). + */ + template , + typename _Alloc = std::allocator<_Key> > + class multiset + { + // concept requirements + typedef typename _Alloc::value_type _Alloc_value_type; + __glibcxx_class_requires(_Key, _SGIAssignableConcept) + __glibcxx_class_requires4(_Compare, bool, _Key, _Key, + _BinaryFunctionConcept) + __glibcxx_class_requires2(_Key, _Alloc_value_type, _SameTypeConcept) + + public: + // typedefs: + typedef _Key key_type; + typedef _Key value_type; + typedef _Compare key_compare; + typedef _Compare value_compare; + typedef _Alloc allocator_type; + + private: + /// This turns a red-black tree into a [multi]set. + typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template + rebind<_Key>::other _Key_alloc_type; + + typedef _Rb_tree, + key_compare, _Key_alloc_type> _Rep_type; + /// The actual tree structure. + _Rep_type _M_t; + + typedef __gnu_cxx::__alloc_traits<_Key_alloc_type> _Alloc_traits; + + public: + typedef typename _Alloc_traits::pointer pointer; + typedef typename _Alloc_traits::const_pointer const_pointer; + typedef typename _Alloc_traits::reference reference; + typedef typename _Alloc_traits::const_reference const_reference; + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR 103. set::iterator is required to be modifiable, + // but this allows modification of keys. + typedef typename _Rep_type::const_iterator iterator; + typedef typename _Rep_type::const_iterator const_iterator; + typedef typename _Rep_type::const_reverse_iterator reverse_iterator; + typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator; + typedef typename _Rep_type::size_type size_type; + typedef typename _Rep_type::difference_type difference_type; + + // allocation/deallocation + /** + * @brief Default constructor creates no elements. + */ + multiset() + : _M_t() { } + + /** + * @brief Creates a %multiset with no elements. + * @param __comp Comparator to use. + * @param __a An allocator object. + */ + explicit + multiset(const _Compare& __comp, + const allocator_type& __a = allocator_type()) + : _M_t(__comp, _Key_alloc_type(__a)) { } + + /** + * @brief Builds a %multiset from a range. + * @param __first An input iterator. + * @param __last An input iterator. + * + * Create a %multiset consisting of copies of the elements from + * [first,last). This is linear in N if the range is already sorted, + * and NlogN otherwise (where N is distance(__first,__last)). + */ + template + multiset(_InputIterator __first, _InputIterator __last) + : _M_t() + { _M_t._M_insert_equal(__first, __last); } + + /** + * @brief Builds a %multiset from a range. + * @param __first An input iterator. + * @param __last An input iterator. + * @param __comp A comparison functor. + * @param __a An allocator object. + * + * Create a %multiset consisting of copies of the elements from + * [__first,__last). This is linear in N if the range is already sorted, + * and NlogN otherwise (where N is distance(__first,__last)). + */ + template + multiset(_InputIterator __first, _InputIterator __last, + const _Compare& __comp, + const allocator_type& __a = allocator_type()) + : _M_t(__comp, _Key_alloc_type(__a)) + { _M_t._M_insert_equal(__first, __last); } + + /** + * @brief %Multiset copy constructor. + * @param __x A %multiset of identical element and allocator types. + * + * The newly-created %multiset uses a copy of the allocation object used + * by @a __x. + */ + multiset(const multiset& __x) + : _M_t(__x._M_t) { } + +#if __cplusplus >= 201103L + /** + * @brief %Multiset move constructor. + * @param __x A %multiset of identical element and allocator types. + * + * The newly-created %multiset contains the exact contents of @a __x. + * The contents of @a __x are a valid, but unspecified %multiset. + */ + multiset(multiset&& __x) + noexcept(is_nothrow_copy_constructible<_Compare>::value) + : _M_t(std::move(__x._M_t)) { } + + /** + * @brief Builds a %multiset from an initializer_list. + * @param __l An initializer_list. + * @param __comp A comparison functor. + * @param __a An allocator object. + * + * Create a %multiset consisting of copies of the elements from + * the list. This is linear in N if the list is already sorted, + * and NlogN otherwise (where N is @a __l.size()). + */ + multiset(initializer_list __l, + const _Compare& __comp = _Compare(), + const allocator_type& __a = allocator_type()) + : _M_t(__comp, _Key_alloc_type(__a)) + { _M_t._M_insert_equal(__l.begin(), __l.end()); } + + /// Allocator-extended default constructor. + explicit + multiset(const allocator_type& __a) + : _M_t(_Compare(), _Key_alloc_type(__a)) { } + + /// Allocator-extended copy constructor. + multiset(const multiset& __m, const allocator_type& __a) + : _M_t(__m._M_t, _Key_alloc_type(__a)) { } + + /// Allocator-extended move constructor. + multiset(multiset&& __m, const allocator_type& __a) + noexcept(is_nothrow_copy_constructible<_Compare>::value + && _Alloc_traits::_S_always_equal()) + : _M_t(std::move(__m._M_t), _Key_alloc_type(__a)) { } + + /// Allocator-extended initialier-list constructor. + multiset(initializer_list __l, const allocator_type& __a) + : _M_t(_Compare(), _Key_alloc_type(__a)) + { _M_t._M_insert_equal(__l.begin(), __l.end()); } + + /// Allocator-extended range constructor. + template + multiset(_InputIterator __first, _InputIterator __last, + const allocator_type& __a) + : _M_t(_Compare(), _Key_alloc_type(__a)) + { _M_t._M_insert_equal(__first, __last); } +#endif + + /** + * @brief %Multiset assignment operator. + * @param __x A %multiset of identical element and allocator types. + * + * All the elements of @a __x are copied, but unlike the copy + * constructor, the allocator object is not copied. + */ + multiset& + operator=(const multiset& __x) + { + _M_t = __x._M_t; + return *this; + } + +#if __cplusplus >= 201103L + /** + * @brief %Multiset move assignment operator. + * @param __x A %multiset of identical element and allocator types. + * + * The contents of @a __x are moved into this %multiset (without + * copying if the allocators compare equal or get moved on assignment). + * Afterwards @a __x is in a valid, but unspecified state. + */ + multiset& + operator=(multiset&& __x) noexcept(_Alloc_traits::_S_nothrow_move()) + { + if (!_M_t._M_move_assign(__x._M_t)) + { + // The rvalue's allocator cannot be moved and is not equal, + // so we need to individually move each element. + clear(); + insert(std::__make_move_if_noexcept_iterator(__x._M_t.begin()), + std::__make_move_if_noexcept_iterator(__x._M_t.end())); + __x.clear(); + } + return *this; + } + + /** + * @brief %Multiset list assignment operator. + * @param __l An initializer_list. + * + * This function fills a %multiset with copies of the elements in the + * initializer list @a __l. + * + * Note that the assignment completely changes the %multiset and + * that the resulting %multiset's size is the same as the number + * of elements assigned. Old data may be lost. + */ + multiset& + operator=(initializer_list __l) + { + this->clear(); + this->insert(__l.begin(), __l.end()); + return *this; + } +#endif + + // accessors: + + /// Returns the comparison object. + key_compare + key_comp() const + { return _M_t.key_comp(); } + /// Returns the comparison object. + value_compare + value_comp() const + { return _M_t.key_comp(); } + /// Returns the memory allocation object. + allocator_type + get_allocator() const _GLIBCXX_NOEXCEPT + { return allocator_type(_M_t.get_allocator()); } + + /** + * Returns a read-only (constant) iterator that points to the first + * element in the %multiset. Iteration is done in ascending order + * according to the keys. + */ + iterator + begin() const _GLIBCXX_NOEXCEPT + { return _M_t.begin(); } + + /** + * Returns a read-only (constant) iterator that points one past the last + * element in the %multiset. Iteration is done in ascending order + * according to the keys. + */ + iterator + end() const _GLIBCXX_NOEXCEPT + { return _M_t.end(); } + + /** + * Returns a read-only (constant) reverse iterator that points to the + * last element in the %multiset. Iteration is done in descending order + * according to the keys. + */ + reverse_iterator + rbegin() const _GLIBCXX_NOEXCEPT + { return _M_t.rbegin(); } + + /** + * Returns a read-only (constant) reverse iterator that points to the + * last element in the %multiset. Iteration is done in descending order + * according to the keys. + */ + reverse_iterator + rend() const _GLIBCXX_NOEXCEPT + { return _M_t.rend(); } + +#if __cplusplus >= 201103L + /** + * Returns a read-only (constant) iterator that points to the first + * element in the %multiset. Iteration is done in ascending order + * according to the keys. + */ + iterator + cbegin() const noexcept + { return _M_t.begin(); } + + /** + * Returns a read-only (constant) iterator that points one past the last + * element in the %multiset. Iteration is done in ascending order + * according to the keys. + */ + iterator + cend() const noexcept + { return _M_t.end(); } + + /** + * Returns a read-only (constant) reverse iterator that points to the + * last element in the %multiset. Iteration is done in descending order + * according to the keys. + */ + reverse_iterator + crbegin() const noexcept + { return _M_t.rbegin(); } + + /** + * Returns a read-only (constant) reverse iterator that points to the + * last element in the %multiset. Iteration is done in descending order + * according to the keys. + */ + reverse_iterator + crend() const noexcept + { return _M_t.rend(); } +#endif + + /// Returns true if the %set is empty. + bool + empty() const _GLIBCXX_NOEXCEPT + { return _M_t.empty(); } + + /// Returns the size of the %set. + size_type + size() const _GLIBCXX_NOEXCEPT + { return _M_t.size(); } + + /// Returns the maximum size of the %set. + size_type + max_size() const _GLIBCXX_NOEXCEPT + { return _M_t.max_size(); } + + /** + * @brief Swaps data with another %multiset. + * @param __x A %multiset of the same element and allocator types. + * + * This exchanges the elements between two multisets in constant time. + * (It is only swapping a pointer, an integer, and an instance of the @c + * Compare type (which itself is often stateless and empty), so it should + * be quite fast.) + * Note that the global std::swap() function is specialized such that + * std::swap(s1,s2) will feed to this function. + */ + void + swap(multiset& __x) +#if __cplusplus >= 201103L + noexcept(_Alloc_traits::_S_nothrow_swap()) +#endif + { _M_t.swap(__x._M_t); } + + // insert/erase +#if __cplusplus >= 201103L + /** + * @brief Builds and inserts an element into the %multiset. + * @param __args Arguments used to generate the element instance to be + * inserted. + * @return An iterator that points to the inserted element. + * + * This function inserts an element into the %multiset. Contrary + * to a std::set the %multiset does not rely on unique keys and thus + * multiple copies of the same element can be inserted. + * + * Insertion requires logarithmic time. + */ + template + iterator + emplace(_Args&&... __args) + { return _M_t._M_emplace_equal(std::forward<_Args>(__args)...); } + + /** + * @brief Builds and inserts an element into the %multiset. + * @param __pos An iterator that serves as a hint as to where the + * element should be inserted. + * @param __args Arguments used to generate the element instance to be + * inserted. + * @return An iterator that points to the inserted element. + * + * This function inserts an element into the %multiset. Contrary + * to a std::set the %multiset does not rely on unique keys and thus + * multiple copies of the same element can be inserted. + * + * Note that the first parameter is only a hint and can potentially + * improve the performance of the insertion process. A bad hint would + * cause no gains in efficiency. + * + * See http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt07ch17.html + * for more on @a hinting. + * + * Insertion requires logarithmic time (if the hint is not taken). + */ + template + iterator + emplace_hint(const_iterator __pos, _Args&&... __args) + { + return _M_t._M_emplace_hint_equal(__pos, + std::forward<_Args>(__args)...); + } +#endif + + /** + * @brief Inserts an element into the %multiset. + * @param __x Element to be inserted. + * @return An iterator that points to the inserted element. + * + * This function inserts an element into the %multiset. Contrary + * to a std::set the %multiset does not rely on unique keys and thus + * multiple copies of the same element can be inserted. + * + * Insertion requires logarithmic time. + */ + iterator + insert(const value_type& __x) + { return _M_t._M_insert_equal(__x); } + +#if __cplusplus >= 201103L + iterator + insert(value_type&& __x) + { return _M_t._M_insert_equal(std::move(__x)); } +#endif + + /** + * @brief Inserts an element into the %multiset. + * @param __position An iterator that serves as a hint as to where the + * element should be inserted. + * @param __x Element to be inserted. + * @return An iterator that points to the inserted element. + * + * This function inserts an element into the %multiset. Contrary + * to a std::set the %multiset does not rely on unique keys and thus + * multiple copies of the same element can be inserted. + * + * Note that the first parameter is only a hint and can potentially + * improve the performance of the insertion process. A bad hint would + * cause no gains in efficiency. + * + * See http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt07ch17.html + * for more on @a hinting. + * + * Insertion requires logarithmic time (if the hint is not taken). + */ + iterator + insert(const_iterator __position, const value_type& __x) + { return _M_t._M_insert_equal_(__position, __x); } + +#if __cplusplus >= 201103L + iterator + insert(const_iterator __position, value_type&& __x) + { return _M_t._M_insert_equal_(__position, std::move(__x)); } +#endif + + /** + * @brief A template function that tries to insert a range of elements. + * @param __first Iterator pointing to the start of the range to be + * inserted. + * @param __last Iterator pointing to the end of the range. + * + * Complexity similar to that of the range constructor. + */ + template + void + insert(_InputIterator __first, _InputIterator __last) + { _M_t._M_insert_equal(__first, __last); } + +#if __cplusplus >= 201103L + /** + * @brief Attempts to insert a list of elements into the %multiset. + * @param __l A std::initializer_list of elements + * to be inserted. + * + * Complexity similar to that of the range constructor. + */ + void + insert(initializer_list __l) + { this->insert(__l.begin(), __l.end()); } +#endif + +#if __cplusplus >= 201103L + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR 130. Associative erase should return an iterator. + /** + * @brief Erases an element from a %multiset. + * @param __position An iterator pointing to the element to be erased. + * @return An iterator pointing to the element immediately following + * @a position prior to the element being erased. If no such + * element exists, end() is returned. + * + * This function erases an element, pointed to by the given iterator, + * from a %multiset. Note that this function only erases the element, + * and that if the element is itself a pointer, the pointed-to memory is + * not touched in any way. Managing the pointer is the user's + * responsibility. + */ + _GLIBCXX_ABI_TAG_CXX11 + iterator + erase(const_iterator __position) + { return _M_t.erase(__position); } +#else + /** + * @brief Erases an element from a %multiset. + * @param __position An iterator pointing to the element to be erased. + * + * This function erases an element, pointed to by the given iterator, + * from a %multiset. Note that this function only erases the element, + * and that if the element is itself a pointer, the pointed-to memory is + * not touched in any way. Managing the pointer is the user's + * responsibility. + */ + void + erase(iterator __position) + { _M_t.erase(__position); } +#endif + + /** + * @brief Erases elements according to the provided key. + * @param __x Key of element to be erased. + * @return The number of elements erased. + * + * This function erases all elements located by the given key from a + * %multiset. + * Note that this function only erases the element, and that if + * the element is itself a pointer, the pointed-to memory is not touched + * in any way. Managing the pointer is the user's responsibility. + */ + size_type + erase(const key_type& __x) + { return _M_t.erase(__x); } + +#if __cplusplus >= 201103L + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR 130. Associative erase should return an iterator. + /** + * @brief Erases a [first,last) range of elements from a %multiset. + * @param __first Iterator pointing to the start of the range to be + * erased. + * @param __last Iterator pointing to the end of the range to + * be erased. + * @return The iterator @a last. + * + * This function erases a sequence of elements from a %multiset. + * Note that this function only erases the elements, and that if + * the elements themselves are pointers, the pointed-to memory is not + * touched in any way. Managing the pointer is the user's + * responsibility. + */ + _GLIBCXX_ABI_TAG_CXX11 + iterator + erase(const_iterator __first, const_iterator __last) + { return _M_t.erase(__first, __last); } +#else + /** + * @brief Erases a [first,last) range of elements from a %multiset. + * @param first Iterator pointing to the start of the range to be + * erased. + * @param last Iterator pointing to the end of the range to be erased. + * + * This function erases a sequence of elements from a %multiset. + * Note that this function only erases the elements, and that if + * the elements themselves are pointers, the pointed-to memory is not + * touched in any way. Managing the pointer is the user's + * responsibility. + */ + void + erase(iterator __first, iterator __last) + { _M_t.erase(__first, __last); } +#endif + + /** + * Erases all elements in a %multiset. Note that this function only + * erases the elements, and that if the elements themselves are pointers, + * the pointed-to memory is not touched in any way. Managing the pointer + * is the user's responsibility. + */ + void + clear() _GLIBCXX_NOEXCEPT + { _M_t.clear(); } + + // multiset operations: + + /** + * @brief Finds the number of elements with given key. + * @param __x Key of elements to be located. + * @return Number of elements with specified key. + */ + size_type + count(const key_type& __x) const + { return _M_t.count(__x); } + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 214. set::find() missing const overload + //@{ + /** + * @brief Tries to locate an element in a %set. + * @param __x Element to be located. + * @return Iterator pointing to sought-after element, or end() if not + * found. + * + * This function takes a key and tries to locate the element with which + * the key matches. If successful the function returns an iterator + * pointing to the sought after element. If unsuccessful it returns the + * past-the-end ( @c end() ) iterator. + */ + iterator + find(const key_type& __x) + { return _M_t.find(__x); } + + const_iterator + find(const key_type& __x) const + { return _M_t.find(__x); } + //@} + + //@{ + /** + * @brief Finds the beginning of a subsequence matching given key. + * @param __x Key to be located. + * @return Iterator pointing to first element equal to or greater + * than key, or end(). + * + * This function returns the first element of a subsequence of elements + * that matches the given key. If unsuccessful it returns an iterator + * pointing to the first element that has a greater value than given key + * or end() if no such element exists. + */ + iterator + lower_bound(const key_type& __x) + { return _M_t.lower_bound(__x); } + + const_iterator + lower_bound(const key_type& __x) const + { return _M_t.lower_bound(__x); } + //@} + + //@{ + /** + * @brief Finds the end of a subsequence matching given key. + * @param __x Key to be located. + * @return Iterator pointing to the first element + * greater than key, or end(). + */ + iterator + upper_bound(const key_type& __x) + { return _M_t.upper_bound(__x); } + + const_iterator + upper_bound(const key_type& __x) const + { return _M_t.upper_bound(__x); } + //@} + + //@{ + /** + * @brief Finds a subsequence matching given key. + * @param __x Key to be located. + * @return Pair of iterators that possibly points to the subsequence + * matching given key. + * + * This function is equivalent to + * @code + * std::make_pair(c.lower_bound(val), + * c.upper_bound(val)) + * @endcode + * (but is faster than making the calls separately). + * + * This function probably only makes sense for multisets. + */ + std::pair + equal_range(const key_type& __x) + { return _M_t.equal_range(__x); } + + std::pair + equal_range(const key_type& __x) const + { return _M_t.equal_range(__x); } + //@} + + template + friend bool + operator==(const multiset<_K1, _C1, _A1>&, + const multiset<_K1, _C1, _A1>&); + + template + friend bool + operator< (const multiset<_K1, _C1, _A1>&, + const multiset<_K1, _C1, _A1>&); + }; + + /** + * @brief Multiset equality comparison. + * @param __x A %multiset. + * @param __y A %multiset of the same type as @a __x. + * @return True iff the size and elements of the multisets are equal. + * + * This is an equivalence relation. It is linear in the size of the + * multisets. + * Multisets are considered equivalent if their sizes are equal, and if + * corresponding elements compare equal. + */ + template + inline bool + operator==(const multiset<_Key, _Compare, _Alloc>& __x, + const multiset<_Key, _Compare, _Alloc>& __y) + { return __x._M_t == __y._M_t; } + + /** + * @brief Multiset ordering relation. + * @param __x A %multiset. + * @param __y A %multiset of the same type as @a __x. + * @return True iff @a __x is lexicographically less than @a __y. + * + * This is a total ordering relation. It is linear in the size of the + * sets. The elements must be comparable with @c <. + * + * See std::lexicographical_compare() for how the determination is made. + */ + template + inline bool + operator<(const multiset<_Key, _Compare, _Alloc>& __x, + const multiset<_Key, _Compare, _Alloc>& __y) + { return __x._M_t < __y._M_t; } + + /// Returns !(x == y). + template + inline bool + operator!=(const multiset<_Key, _Compare, _Alloc>& __x, + const multiset<_Key, _Compare, _Alloc>& __y) + { return !(__x == __y); } + + /// Returns y < x. + template + inline bool + operator>(const multiset<_Key,_Compare,_Alloc>& __x, + const multiset<_Key,_Compare,_Alloc>& __y) + { return __y < __x; } + + /// Returns !(y < x) + template + inline bool + operator<=(const multiset<_Key, _Compare, _Alloc>& __x, + const multiset<_Key, _Compare, _Alloc>& __y) + { return !(__y < __x); } + + /// Returns !(x < y) + template + inline bool + operator>=(const multiset<_Key, _Compare, _Alloc>& __x, + const multiset<_Key, _Compare, _Alloc>& __y) + { return !(__x < __y); } + + /// See std::multiset::swap(). + template + inline void + swap(multiset<_Key, _Compare, _Alloc>& __x, + multiset<_Key, _Compare, _Alloc>& __y) + { __x.swap(__y); } + +_GLIBCXX_END_NAMESPACE_CONTAINER +} // namespace std + +#endif /* _STL_MULTISET_H */ diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stl_numeric.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stl_numeric.h new file mode 100755 index 0000000..666391b --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stl_numeric.h @@ -0,0 +1,387 @@ +// Numeric functions implementation -*- C++ -*- + +// Copyright (C) 2001-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/* + * + * Copyright (c) 1994 + * Hewlett-Packard Company + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Hewlett-Packard Company makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + * + * + * Copyright (c) 1996,1997 + * Silicon Graphics Computer Systems, Inc. + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Silicon Graphics makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + */ + +/** @file bits/stl_numeric.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{numeric} + */ + +#ifndef _STL_NUMERIC_H +#define _STL_NUMERIC_H 1 + +#include +#include +#include // For _GLIBCXX_MOVE + +#if __cplusplus >= 201103L + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /** + * @brief Create a range of sequentially increasing values. + * + * For each element in the range @p [first,last) assigns @p value and + * increments @p value as if by @p ++value. + * + * @param __first Start of range. + * @param __last End of range. + * @param __value Starting value. + * @return Nothing. + */ + template + void + iota(_ForwardIterator __first, _ForwardIterator __last, _Tp __value) + { + // concept requirements + __glibcxx_function_requires(_Mutable_ForwardIteratorConcept< + _ForwardIterator>) + __glibcxx_function_requires(_ConvertibleConcept<_Tp, + typename iterator_traits<_ForwardIterator>::value_type>) + __glibcxx_requires_valid_range(__first, __last); + + for (; __first != __last; ++__first) + { + *__first = __value; + ++__value; + } + } + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace std + +#endif + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_ALGO + + /** + * @brief Accumulate values in a range. + * + * Accumulates the values in the range [first,last) using operator+(). The + * initial value is @a init. The values are processed in order. + * + * @param __first Start of range. + * @param __last End of range. + * @param __init Starting value to add other values to. + * @return The final sum. + */ + template + inline _Tp + accumulate(_InputIterator __first, _InputIterator __last, _Tp __init) + { + // concept requirements + __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>) + __glibcxx_requires_valid_range(__first, __last); + + for (; __first != __last; ++__first) + __init = __init + *__first; + return __init; + } + + /** + * @brief Accumulate values in a range with operation. + * + * Accumulates the values in the range [first,last) using the function + * object @p __binary_op. The initial value is @p __init. The values are + * processed in order. + * + * @param __first Start of range. + * @param __last End of range. + * @param __init Starting value to add other values to. + * @param __binary_op Function object to accumulate with. + * @return The final sum. + */ + template + inline _Tp + accumulate(_InputIterator __first, _InputIterator __last, _Tp __init, + _BinaryOperation __binary_op) + { + // concept requirements + __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>) + __glibcxx_requires_valid_range(__first, __last); + + for (; __first != __last; ++__first) + __init = __binary_op(__init, *__first); + return __init; + } + + /** + * @brief Compute inner product of two ranges. + * + * Starting with an initial value of @p __init, multiplies successive + * elements from the two ranges and adds each product into the accumulated + * value using operator+(). The values in the ranges are processed in + * order. + * + * @param __first1 Start of range 1. + * @param __last1 End of range 1. + * @param __first2 Start of range 2. + * @param __init Starting value to add other values to. + * @return The final inner product. + */ + template + inline _Tp + inner_product(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _Tp __init) + { + // concept requirements + __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>) + __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>) + __glibcxx_requires_valid_range(__first1, __last1); + + for (; __first1 != __last1; ++__first1, ++__first2) + __init = __init + (*__first1 * *__first2); + return __init; + } + + /** + * @brief Compute inner product of two ranges. + * + * Starting with an initial value of @p __init, applies @p __binary_op2 to + * successive elements from the two ranges and accumulates each result into + * the accumulated value using @p __binary_op1. The values in the ranges are + * processed in order. + * + * @param __first1 Start of range 1. + * @param __last1 End of range 1. + * @param __first2 Start of range 2. + * @param __init Starting value to add other values to. + * @param __binary_op1 Function object to accumulate with. + * @param __binary_op2 Function object to apply to pairs of input values. + * @return The final inner product. + */ + template + inline _Tp + inner_product(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _Tp __init, + _BinaryOperation1 __binary_op1, + _BinaryOperation2 __binary_op2) + { + // concept requirements + __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>) + __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>) + __glibcxx_requires_valid_range(__first1, __last1); + + for (; __first1 != __last1; ++__first1, ++__first2) + __init = __binary_op1(__init, __binary_op2(*__first1, *__first2)); + return __init; + } + + /** + * @brief Return list of partial sums + * + * Accumulates the values in the range [first,last) using the @c + operator. + * As each successive input value is added into the total, that partial sum + * is written to @p __result. Therefore, the first value in @p __result is + * the first value of the input, the second value in @p __result is the sum + * of the first and second input values, and so on. + * + * @param __first Start of input range. + * @param __last End of input range. + * @param __result Output sum. + * @return Iterator pointing just beyond the values written to __result. + */ + template + _OutputIterator + partial_sum(_InputIterator __first, _InputIterator __last, + _OutputIterator __result) + { + typedef typename iterator_traits<_InputIterator>::value_type _ValueType; + + // concept requirements + __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>) + __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator, + _ValueType>) + __glibcxx_requires_valid_range(__first, __last); + + if (__first == __last) + return __result; + _ValueType __value = *__first; + *__result = __value; + while (++__first != __last) + { + __value = __value + *__first; + *++__result = __value; + } + return ++__result; + } + + /** + * @brief Return list of partial sums + * + * Accumulates the values in the range [first,last) using @p __binary_op. + * As each successive input value is added into the total, that partial sum + * is written to @p __result. Therefore, the first value in @p __result is + * the first value of the input, the second value in @p __result is the sum + * of the first and second input values, and so on. + * + * @param __first Start of input range. + * @param __last End of input range. + * @param __result Output sum. + * @param __binary_op Function object. + * @return Iterator pointing just beyond the values written to __result. + */ + template + _OutputIterator + partial_sum(_InputIterator __first, _InputIterator __last, + _OutputIterator __result, _BinaryOperation __binary_op) + { + typedef typename iterator_traits<_InputIterator>::value_type _ValueType; + + // concept requirements + __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>) + __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator, + _ValueType>) + __glibcxx_requires_valid_range(__first, __last); + + if (__first == __last) + return __result; + _ValueType __value = *__first; + *__result = __value; + while (++__first != __last) + { + __value = __binary_op(__value, *__first); + *++__result = __value; + } + return ++__result; + } + + /** + * @brief Return differences between adjacent values. + * + * Computes the difference between adjacent values in the range + * [first,last) using operator-() and writes the result to @p __result. + * + * @param __first Start of input range. + * @param __last End of input range. + * @param __result Output sums. + * @return Iterator pointing just beyond the values written to result. + * + * _GLIBCXX_RESOLVE_LIB_DEFECTS + * DR 539. partial_sum and adjacent_difference should mention requirements + */ + template + _OutputIterator + adjacent_difference(_InputIterator __first, + _InputIterator __last, _OutputIterator __result) + { + typedef typename iterator_traits<_InputIterator>::value_type _ValueType; + + // concept requirements + __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>) + __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator, + _ValueType>) + __glibcxx_requires_valid_range(__first, __last); + + if (__first == __last) + return __result; + _ValueType __value = *__first; + *__result = __value; + while (++__first != __last) + { + _ValueType __tmp = *__first; + *++__result = __tmp - __value; + __value = _GLIBCXX_MOVE(__tmp); + } + return ++__result; + } + + /** + * @brief Return differences between adjacent values. + * + * Computes the difference between adjacent values in the range + * [__first,__last) using the function object @p __binary_op and writes the + * result to @p __result. + * + * @param __first Start of input range. + * @param __last End of input range. + * @param __result Output sum. + * @param __binary_op Function object. + * @return Iterator pointing just beyond the values written to result. + * + * _GLIBCXX_RESOLVE_LIB_DEFECTS + * DR 539. partial_sum and adjacent_difference should mention requirements + */ + template + _OutputIterator + adjacent_difference(_InputIterator __first, _InputIterator __last, + _OutputIterator __result, _BinaryOperation __binary_op) + { + typedef typename iterator_traits<_InputIterator>::value_type _ValueType; + + // concept requirements + __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>) + __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator, + _ValueType>) + __glibcxx_requires_valid_range(__first, __last); + + if (__first == __last) + return __result; + _ValueType __value = *__first; + *__result = __value; + while (++__first != __last) + { + _ValueType __tmp = *__first; + *++__result = __binary_op(__tmp, __value); + __value = _GLIBCXX_MOVE(__tmp); + } + return ++__result; + } + +_GLIBCXX_END_NAMESPACE_ALGO +} // namespace std + +#endif /* _STL_NUMERIC_H */ diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stl_pair.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stl_pair.h new file mode 100755 index 0000000..2bcf7bf --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stl_pair.h @@ -0,0 +1,295 @@ +// Pair implementation -*- C++ -*- + +// Copyright (C) 2001-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/* + * + * Copyright (c) 1994 + * Hewlett-Packard Company + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Hewlett-Packard Company makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + * + * + * Copyright (c) 1996,1997 + * Silicon Graphics Computer Systems, Inc. + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Silicon Graphics makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + */ + +/** @file bits/stl_pair.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{utility} + */ + +#ifndef _STL_PAIR_H +#define _STL_PAIR_H 1 + +#include // for std::move / std::forward, and std::swap + +#if __cplusplus >= 201103L +#include // for std::__decay_and_strip too +#endif + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /** + * @addtogroup utilities + * @{ + */ + +#if __cplusplus >= 201103L + /// piecewise_construct_t + struct piecewise_construct_t { }; + + /// piecewise_construct + constexpr piecewise_construct_t piecewise_construct = piecewise_construct_t(); + + // Forward declarations. + template + class tuple; + + template + struct _Index_tuple; +#endif + + /** + * @brief Struct holding two objects of arbitrary type. + * + * @tparam _T1 Type of first object. + * @tparam _T2 Type of second object. + */ + template + struct pair + { + typedef _T1 first_type; /// @c first_type is the first bound type + typedef _T2 second_type; /// @c second_type is the second bound type + + _T1 first; /// @c first is a copy of the first object + _T2 second; /// @c second is a copy of the second object + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 265. std::pair::pair() effects overly restrictive + /** The default constructor creates @c first and @c second using their + * respective default constructors. */ + _GLIBCXX_CONSTEXPR pair() + : first(), second() { } + + /** Two objects may be passed to a @c pair constructor to be copied. */ + _GLIBCXX_CONSTEXPR pair(const _T1& __a, const _T2& __b) + : first(__a), second(__b) { } + + /** There is also a templated copy ctor for the @c pair class itself. */ +#if __cplusplus < 201103L + template + pair(const pair<_U1, _U2>& __p) + : first(__p.first), second(__p.second) { } +#else + template, + is_convertible>::value>::type> + constexpr pair(const pair<_U1, _U2>& __p) + : first(__p.first), second(__p.second) { } + + constexpr pair(const pair&) = default; + constexpr pair(pair&&) = default; + + // DR 811. + template::value>::type> + constexpr pair(_U1&& __x, const _T2& __y) + : first(std::forward<_U1>(__x)), second(__y) { } + + template::value>::type> + constexpr pair(const _T1& __x, _U2&& __y) + : first(__x), second(std::forward<_U2>(__y)) { } + + template, + is_convertible<_U2, _T2>>::value>::type> + constexpr pair(_U1&& __x, _U2&& __y) + : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) { } + + template, + is_convertible<_U2, _T2>>::value>::type> + constexpr pair(pair<_U1, _U2>&& __p) + : first(std::forward<_U1>(__p.first)), + second(std::forward<_U2>(__p.second)) { } + + template + pair(piecewise_construct_t, tuple<_Args1...>, tuple<_Args2...>); + + pair& + operator=(const pair& __p) + { + first = __p.first; + second = __p.second; + return *this; + } + + pair& + operator=(pair&& __p) + noexcept(__and_, + is_nothrow_move_assignable<_T2>>::value) + { + first = std::forward(__p.first); + second = std::forward(__p.second); + return *this; + } + + template + pair& + operator=(const pair<_U1, _U2>& __p) + { + first = __p.first; + second = __p.second; + return *this; + } + + template + pair& + operator=(pair<_U1, _U2>&& __p) + { + first = std::forward<_U1>(__p.first); + second = std::forward<_U2>(__p.second); + return *this; + } + + void + swap(pair& __p) + noexcept(noexcept(swap(first, __p.first)) + && noexcept(swap(second, __p.second))) + { + using std::swap; + swap(first, __p.first); + swap(second, __p.second); + } + + private: + template + pair(tuple<_Args1...>&, tuple<_Args2...>&, + _Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>); +#endif + }; + + /// Two pairs of the same type are equal iff their members are equal. + template + inline _GLIBCXX_CONSTEXPR bool + operator==(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return __x.first == __y.first && __x.second == __y.second; } + + /// + template + inline _GLIBCXX_CONSTEXPR bool + operator<(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return __x.first < __y.first + || (!(__y.first < __x.first) && __x.second < __y.second); } + + /// Uses @c operator== to find the result. + template + inline _GLIBCXX_CONSTEXPR bool + operator!=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return !(__x == __y); } + + /// Uses @c operator< to find the result. + template + inline _GLIBCXX_CONSTEXPR bool + operator>(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return __y < __x; } + + /// Uses @c operator< to find the result. + template + inline _GLIBCXX_CONSTEXPR bool + operator<=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return !(__y < __x); } + + /// Uses @c operator< to find the result. + template + inline _GLIBCXX_CONSTEXPR bool + operator>=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return !(__x < __y); } + +#if __cplusplus >= 201103L + /// See std::pair::swap(). + // Note: no std::swap overloads in C++03 mode, this has performance + // implications, see, eg, libstdc++/38466. + template + inline void + swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y) + noexcept(noexcept(__x.swap(__y))) + { __x.swap(__y); } +#endif + + /** + * @brief A convenience wrapper for creating a pair from two objects. + * @param __x The first object. + * @param __y The second object. + * @return A newly-constructed pair<> object of the appropriate type. + * + * The standard requires that the objects be passed by reference-to-const, + * but LWG issue #181 says they should be passed by const value. We follow + * the LWG by default. + */ + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 181. make_pair() unintended behavior +#if __cplusplus >= 201103L + // NB: DR 706. + template + constexpr pair::__type, + typename __decay_and_strip<_T2>::__type> + make_pair(_T1&& __x, _T2&& __y) + { + typedef typename __decay_and_strip<_T1>::__type __ds_type1; + typedef typename __decay_and_strip<_T2>::__type __ds_type2; + typedef pair<__ds_type1, __ds_type2> __pair_type; + return __pair_type(std::forward<_T1>(__x), std::forward<_T2>(__y)); + } +#else + template + inline pair<_T1, _T2> + make_pair(_T1 __x, _T2 __y) + { return pair<_T1, _T2>(__x, __y); } +#endif + + /// @} + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace std + +#endif /* _STL_PAIR_H */ diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stl_queue.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stl_queue.h new file mode 100755 index 0000000..32124e3 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stl_queue.h @@ -0,0 +1,572 @@ +// Queue implementation -*- C++ -*- + +// Copyright (C) 2001-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/* + * + * Copyright (c) 1994 + * Hewlett-Packard Company + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Hewlett-Packard Company makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + * + * + * Copyright (c) 1996,1997 + * Silicon Graphics Computer Systems, Inc. + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Silicon Graphics makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + */ + +/** @file bits/stl_queue.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{queue} + */ + +#ifndef _STL_QUEUE_H +#define _STL_QUEUE_H 1 + +#include +#include +#if __cplusplus >= 201103L +# include +#endif + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /** + * @brief A standard container giving FIFO behavior. + * + * @ingroup sequences + * + * @tparam _Tp Type of element. + * @tparam _Sequence Type of underlying sequence, defaults to deque<_Tp>. + * + * Meets many of the requirements of a + * container, + * but does not define anything to do with iterators. Very few of the + * other standard container interfaces are defined. + * + * This is not a true container, but an @e adaptor. It holds another + * container, and provides a wrapper interface to that container. The + * wrapper is what enforces strict first-in-first-out %queue behavior. + * + * The second template parameter defines the type of the underlying + * sequence/container. It defaults to std::deque, but it can be any type + * that supports @c front, @c back, @c push_back, and @c pop_front, + * such as std::list or an appropriate user-defined type. + * + * Members not found in @a normal containers are @c container_type, + * which is a typedef for the second Sequence parameter, and @c push and + * @c pop, which are standard %queue/FIFO operations. + */ + template > + class queue + { + // concept requirements + typedef typename _Sequence::value_type _Sequence_value_type; + __glibcxx_class_requires(_Tp, _SGIAssignableConcept) + __glibcxx_class_requires(_Sequence, _FrontInsertionSequenceConcept) + __glibcxx_class_requires(_Sequence, _BackInsertionSequenceConcept) + __glibcxx_class_requires2(_Tp, _Sequence_value_type, _SameTypeConcept) + + template + friend bool + operator==(const queue<_Tp1, _Seq1>&, const queue<_Tp1, _Seq1>&); + + template + friend bool + operator<(const queue<_Tp1, _Seq1>&, const queue<_Tp1, _Seq1>&); + + public: + typedef typename _Sequence::value_type value_type; + typedef typename _Sequence::reference reference; + typedef typename _Sequence::const_reference const_reference; + typedef typename _Sequence::size_type size_type; + typedef _Sequence container_type; + + protected: + /** + * 'c' is the underlying container. Maintainers wondering why + * this isn't uglified as per style guidelines should note that + * this name is specified in the standard, [23.2.3.1]. (Why? + * Presumably for the same reason that it's protected instead + * of private: to allow derivation. But none of the other + * containers allow for derivation. Odd.) + */ + _Sequence c; + + public: + /** + * @brief Default constructor creates no elements. + */ +#if __cplusplus < 201103L + explicit + queue(const _Sequence& __c = _Sequence()) + : c(__c) { } +#else + explicit + queue(const _Sequence& __c) + : c(__c) { } + + explicit + queue(_Sequence&& __c = _Sequence()) + : c(std::move(__c)) { } +#endif + + /** + * Returns true if the %queue is empty. + */ + bool + empty() const + { return c.empty(); } + + /** Returns the number of elements in the %queue. */ + size_type + size() const + { return c.size(); } + + /** + * Returns a read/write reference to the data at the first + * element of the %queue. + */ + reference + front() + { + __glibcxx_requires_nonempty(); + return c.front(); + } + + /** + * Returns a read-only (constant) reference to the data at the first + * element of the %queue. + */ + const_reference + front() const + { + __glibcxx_requires_nonempty(); + return c.front(); + } + + /** + * Returns a read/write reference to the data at the last + * element of the %queue. + */ + reference + back() + { + __glibcxx_requires_nonempty(); + return c.back(); + } + + /** + * Returns a read-only (constant) reference to the data at the last + * element of the %queue. + */ + const_reference + back() const + { + __glibcxx_requires_nonempty(); + return c.back(); + } + + /** + * @brief Add data to the end of the %queue. + * @param __x Data to be added. + * + * This is a typical %queue operation. The function creates an + * element at the end of the %queue and assigns the given data + * to it. The time complexity of the operation depends on the + * underlying sequence. + */ + void + push(const value_type& __x) + { c.push_back(__x); } + +#if __cplusplus >= 201103L + void + push(value_type&& __x) + { c.push_back(std::move(__x)); } + + template + void + emplace(_Args&&... __args) + { c.emplace_back(std::forward<_Args>(__args)...); } +#endif + + /** + * @brief Removes first element. + * + * This is a typical %queue operation. It shrinks the %queue by one. + * The time complexity of the operation depends on the underlying + * sequence. + * + * Note that no data is returned, and if the first element's + * data is needed, it should be retrieved before pop() is + * called. + */ + void + pop() + { + __glibcxx_requires_nonempty(); + c.pop_front(); + } + +#if __cplusplus >= 201103L + void + swap(queue& __q) + noexcept(noexcept(swap(c, __q.c))) + { + using std::swap; + swap(c, __q.c); + } +#endif + }; + + /** + * @brief Queue equality comparison. + * @param __x A %queue. + * @param __y A %queue of the same type as @a __x. + * @return True iff the size and elements of the queues are equal. + * + * This is an equivalence relation. Complexity and semantics depend on the + * underlying sequence type, but the expected rules are: this relation is + * linear in the size of the sequences, and queues are considered equivalent + * if their sequences compare equal. + */ + template + inline bool + operator==(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y) + { return __x.c == __y.c; } + + /** + * @brief Queue ordering relation. + * @param __x A %queue. + * @param __y A %queue of the same type as @a x. + * @return True iff @a __x is lexicographically less than @a __y. + * + * This is an total ordering relation. Complexity and semantics + * depend on the underlying sequence type, but the expected rules + * are: this relation is linear in the size of the sequences, the + * elements must be comparable with @c <, and + * std::lexicographical_compare() is usually used to make the + * determination. + */ + template + inline bool + operator<(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y) + { return __x.c < __y.c; } + + /// Based on operator== + template + inline bool + operator!=(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y) + { return !(__x == __y); } + + /// Based on operator< + template + inline bool + operator>(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y) + { return __y < __x; } + + /// Based on operator< + template + inline bool + operator<=(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y) + { return !(__y < __x); } + + /// Based on operator< + template + inline bool + operator>=(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y) + { return !(__x < __y); } + +#if __cplusplus >= 201103L + template + inline void + swap(queue<_Tp, _Seq>& __x, queue<_Tp, _Seq>& __y) + noexcept(noexcept(__x.swap(__y))) + { __x.swap(__y); } + + template + struct uses_allocator, _Alloc> + : public uses_allocator<_Seq, _Alloc>::type { }; +#endif + + /** + * @brief A standard container automatically sorting its contents. + * + * @ingroup sequences + * + * @tparam _Tp Type of element. + * @tparam _Sequence Type of underlying sequence, defaults to vector<_Tp>. + * @tparam _Compare Comparison function object type, defaults to + * less<_Sequence::value_type>. + * + * This is not a true container, but an @e adaptor. It holds + * another container, and provides a wrapper interface to that + * container. The wrapper is what enforces priority-based sorting + * and %queue behavior. Very few of the standard container/sequence + * interface requirements are met (e.g., iterators). + * + * The second template parameter defines the type of the underlying + * sequence/container. It defaults to std::vector, but it can be + * any type that supports @c front(), @c push_back, @c pop_back, + * and random-access iterators, such as std::deque or an + * appropriate user-defined type. + * + * The third template parameter supplies the means of making + * priority comparisons. It defaults to @c less but + * can be anything defining a strict weak ordering. + * + * Members not found in @a normal containers are @c container_type, + * which is a typedef for the second Sequence parameter, and @c + * push, @c pop, and @c top, which are standard %queue operations. + * + * @note No equality/comparison operators are provided for + * %priority_queue. + * + * @note Sorting of the elements takes place as they are added to, + * and removed from, the %priority_queue using the + * %priority_queue's member functions. If you access the elements + * by other means, and change their data such that the sorting + * order would be different, the %priority_queue will not re-sort + * the elements for you. (How could it know to do so?) + */ + template, + typename _Compare = less > + class priority_queue + { + // concept requirements + typedef typename _Sequence::value_type _Sequence_value_type; + __glibcxx_class_requires(_Tp, _SGIAssignableConcept) + __glibcxx_class_requires(_Sequence, _SequenceConcept) + __glibcxx_class_requires(_Sequence, _RandomAccessContainerConcept) + __glibcxx_class_requires2(_Tp, _Sequence_value_type, _SameTypeConcept) + __glibcxx_class_requires4(_Compare, bool, _Tp, _Tp, + _BinaryFunctionConcept) + + public: + typedef typename _Sequence::value_type value_type; + typedef typename _Sequence::reference reference; + typedef typename _Sequence::const_reference const_reference; + typedef typename _Sequence::size_type size_type; + typedef _Sequence container_type; + + protected: + // See queue::c for notes on these names. + _Sequence c; + _Compare comp; + + public: + /** + * @brief Default constructor creates no elements. + */ +#if __cplusplus < 201103L + explicit + priority_queue(const _Compare& __x = _Compare(), + const _Sequence& __s = _Sequence()) + : c(__s), comp(__x) + { std::make_heap(c.begin(), c.end(), comp); } +#else + explicit + priority_queue(const _Compare& __x, + const _Sequence& __s) + : c(__s), comp(__x) + { std::make_heap(c.begin(), c.end(), comp); } + + explicit + priority_queue(const _Compare& __x = _Compare(), + _Sequence&& __s = _Sequence()) + : c(std::move(__s)), comp(__x) + { std::make_heap(c.begin(), c.end(), comp); } +#endif + + /** + * @brief Builds a %queue from a range. + * @param __first An input iterator. + * @param __last An input iterator. + * @param __x A comparison functor describing a strict weak ordering. + * @param __s An initial sequence with which to start. + * + * Begins by copying @a __s, inserting a copy of the elements + * from @a [first,last) into the copy of @a __s, then ordering + * the copy according to @a __x. + * + * For more information on function objects, see the + * documentation on @link functors functor base + * classes@endlink. + */ +#if __cplusplus < 201103L + template + priority_queue(_InputIterator __first, _InputIterator __last, + const _Compare& __x = _Compare(), + const _Sequence& __s = _Sequence()) + : c(__s), comp(__x) + { + __glibcxx_requires_valid_range(__first, __last); + c.insert(c.end(), __first, __last); + std::make_heap(c.begin(), c.end(), comp); + } +#else + template + priority_queue(_InputIterator __first, _InputIterator __last, + const _Compare& __x, + const _Sequence& __s) + : c(__s), comp(__x) + { + __glibcxx_requires_valid_range(__first, __last); + c.insert(c.end(), __first, __last); + std::make_heap(c.begin(), c.end(), comp); + } + + template + priority_queue(_InputIterator __first, _InputIterator __last, + const _Compare& __x = _Compare(), + _Sequence&& __s = _Sequence()) + : c(std::move(__s)), comp(__x) + { + __glibcxx_requires_valid_range(__first, __last); + c.insert(c.end(), __first, __last); + std::make_heap(c.begin(), c.end(), comp); + } +#endif + + /** + * Returns true if the %queue is empty. + */ + bool + empty() const + { return c.empty(); } + + /** Returns the number of elements in the %queue. */ + size_type + size() const + { return c.size(); } + + /** + * Returns a read-only (constant) reference to the data at the first + * element of the %queue. + */ + const_reference + top() const + { + __glibcxx_requires_nonempty(); + return c.front(); + } + + /** + * @brief Add data to the %queue. + * @param __x Data to be added. + * + * This is a typical %queue operation. + * The time complexity of the operation depends on the underlying + * sequence. + */ + void + push(const value_type& __x) + { + c.push_back(__x); + std::push_heap(c.begin(), c.end(), comp); + } + +#if __cplusplus >= 201103L + void + push(value_type&& __x) + { + c.push_back(std::move(__x)); + std::push_heap(c.begin(), c.end(), comp); + } + + template + void + emplace(_Args&&... __args) + { + c.emplace_back(std::forward<_Args>(__args)...); + std::push_heap(c.begin(), c.end(), comp); + } +#endif + + /** + * @brief Removes first element. + * + * This is a typical %queue operation. It shrinks the %queue + * by one. The time complexity of the operation depends on the + * underlying sequence. + * + * Note that no data is returned, and if the first element's + * data is needed, it should be retrieved before pop() is + * called. + */ + void + pop() + { + __glibcxx_requires_nonempty(); + std::pop_heap(c.begin(), c.end(), comp); + c.pop_back(); + } + +#if __cplusplus >= 201103L + void + swap(priority_queue& __pq) + noexcept(noexcept(swap(c, __pq.c)) && noexcept(swap(comp, __pq.comp))) + { + using std::swap; + swap(c, __pq.c); + swap(comp, __pq.comp); + } +#endif + }; + + // No equality/comparison operators are provided for priority_queue. + +#if __cplusplus >= 201103L + template + inline void + swap(priority_queue<_Tp, _Sequence, _Compare>& __x, + priority_queue<_Tp, _Sequence, _Compare>& __y) + noexcept(noexcept(__x.swap(__y))) + { __x.swap(__y); } + + template + struct uses_allocator, _Alloc> + : public uses_allocator<_Sequence, _Alloc>::type { }; +#endif + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif /* _STL_QUEUE_H */ diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stl_raw_storage_iter.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stl_raw_storage_iter.h new file mode 100755 index 0000000..6a4014b --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stl_raw_storage_iter.h @@ -0,0 +1,108 @@ +// -*- C++ -*- + +// Copyright (C) 2001-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/* + * + * Copyright (c) 1994 + * Hewlett-Packard Company + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Hewlett-Packard Company makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + * + * + * Copyright (c) 1996 + * Silicon Graphics Computer Systems, Inc. + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Silicon Graphics makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + */ + +/** @file bits/stl_raw_storage_iter.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{memory} + */ + +#ifndef _STL_RAW_STORAGE_ITERATOR_H +#define _STL_RAW_STORAGE_ITERATOR_H 1 + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /** + * This iterator class lets algorithms store their results into + * uninitialized memory. + */ + template + class raw_storage_iterator + : public iterator + { + protected: + _OutputIterator _M_iter; + + public: + explicit + raw_storage_iterator(_OutputIterator __x) + : _M_iter(__x) {} + + raw_storage_iterator& + operator*() { return *this; } + + raw_storage_iterator& + operator=(const _Tp& __element) + { + std::_Construct(std::__addressof(*_M_iter), __element); + return *this; + } + + raw_storage_iterator<_OutputIterator, _Tp>& + operator++() + { + ++_M_iter; + return *this; + } + + raw_storage_iterator<_OutputIterator, _Tp> + operator++(int) + { + raw_storage_iterator<_OutputIterator, _Tp> __tmp = *this; + ++_M_iter; + return __tmp; + } + }; + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stl_relops.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stl_relops.h new file mode 100755 index 0000000..fbd2493 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stl_relops.h @@ -0,0 +1,134 @@ +// std::rel_ops implementation -*- C++ -*- + +// Copyright (C) 2001-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the, 2009 Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/* + * + * Copyright (c) 1994 + * Hewlett-Packard Company + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Hewlett-Packard Company makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + * + * Copyright (c) 1996,1997 + * Silicon Graphics + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Silicon Graphics makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + * + */ + +/** @file bits/stl_relops.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{utility} + * + * Inclusion of this file has been removed from + * all of the other STL headers for safety reasons, except std_utility.h. + * For more information, see the thread of about twenty messages starting + * with http://gcc.gnu.org/ml/libstdc++/2001-01/msg00223.html, or + * http://gcc.gnu.org/onlinedocs/libstdc++/faq.html#faq.ambiguous_overloads + * + * Short summary: the rel_ops operators should be avoided for the present. + */ + +#ifndef _STL_RELOPS_H +#define _STL_RELOPS_H 1 + +namespace std _GLIBCXX_VISIBILITY(default) +{ + namespace rel_ops + { + _GLIBCXX_BEGIN_NAMESPACE_VERSION + + /** @namespace std::rel_ops + * @brief The generated relational operators are sequestered here. + */ + + /** + * @brief Defines @c != for arbitrary types, in terms of @c ==. + * @param __x A thing. + * @param __y Another thing. + * @return __x != __y + * + * This function uses @c == to determine its result. + */ + template + inline bool + operator!=(const _Tp& __x, const _Tp& __y) + { return !(__x == __y); } + + /** + * @brief Defines @c > for arbitrary types, in terms of @c <. + * @param __x A thing. + * @param __y Another thing. + * @return __x > __y + * + * This function uses @c < to determine its result. + */ + template + inline bool + operator>(const _Tp& __x, const _Tp& __y) + { return __y < __x; } + + /** + * @brief Defines @c <= for arbitrary types, in terms of @c <. + * @param __x A thing. + * @param __y Another thing. + * @return __x <= __y + * + * This function uses @c < to determine its result. + */ + template + inline bool + operator<=(const _Tp& __x, const _Tp& __y) + { return !(__y < __x); } + + /** + * @brief Defines @c >= for arbitrary types, in terms of @c <. + * @param __x A thing. + * @param __y Another thing. + * @return __x >= __y + * + * This function uses @c < to determine its result. + */ + template + inline bool + operator>=(const _Tp& __x, const _Tp& __y) + { return !(__x < __y); } + + _GLIBCXX_END_NAMESPACE_VERSION + } // namespace rel_ops + +} // namespace std + +#endif /* _STL_RELOPS_H */ diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stl_set.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stl_set.h new file mode 100755 index 0000000..3a39154 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stl_set.h @@ -0,0 +1,850 @@ +// Set implementation -*- C++ -*- + +// Copyright (C) 2001-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/* + * + * Copyright (c) 1994 + * Hewlett-Packard Company + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Hewlett-Packard Company makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + * + * + * Copyright (c) 1996,1997 + * Silicon Graphics Computer Systems, Inc. + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Silicon Graphics makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + */ + +/** @file bits/stl_set.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{set} + */ + +#ifndef _STL_SET_H +#define _STL_SET_H 1 + +#include +#if __cplusplus >= 201103L +#include +#endif + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_CONTAINER + + /** + * @brief A standard container made up of unique keys, which can be + * retrieved in logarithmic time. + * + * @ingroup associative_containers + * + * @tparam _Key Type of key objects. + * @tparam _Compare Comparison function object type, defaults to less<_Key>. + * @tparam _Alloc Allocator type, defaults to allocator<_Key>. + * + * Meets the requirements of a container, a + * reversible container, and an + * associative container (using unique keys). + * + * Sets support bidirectional iterators. + * + * The private tree data is declared exactly the same way for set and + * multiset; the distinction is made entirely in how the tree functions are + * called (*_unique versus *_equal, same as the standard). + */ + template, + typename _Alloc = std::allocator<_Key> > + class set + { + // concept requirements + typedef typename _Alloc::value_type _Alloc_value_type; + __glibcxx_class_requires(_Key, _SGIAssignableConcept) + __glibcxx_class_requires4(_Compare, bool, _Key, _Key, + _BinaryFunctionConcept) + __glibcxx_class_requires2(_Key, _Alloc_value_type, _SameTypeConcept) + + public: + // typedefs: + //@{ + /// Public typedefs. + typedef _Key key_type; + typedef _Key value_type; + typedef _Compare key_compare; + typedef _Compare value_compare; + typedef _Alloc allocator_type; + //@} + + private: + typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template + rebind<_Key>::other _Key_alloc_type; + + typedef _Rb_tree, + key_compare, _Key_alloc_type> _Rep_type; + _Rep_type _M_t; // Red-black tree representing set. + + typedef __gnu_cxx::__alloc_traits<_Key_alloc_type> _Alloc_traits; + + public: + //@{ + /// Iterator-related typedefs. + typedef typename _Alloc_traits::pointer pointer; + typedef typename _Alloc_traits::const_pointer const_pointer; + typedef typename _Alloc_traits::reference reference; + typedef typename _Alloc_traits::const_reference const_reference; + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR 103. set::iterator is required to be modifiable, + // but this allows modification of keys. + typedef typename _Rep_type::const_iterator iterator; + typedef typename _Rep_type::const_iterator const_iterator; + typedef typename _Rep_type::const_reverse_iterator reverse_iterator; + typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator; + typedef typename _Rep_type::size_type size_type; + typedef typename _Rep_type::difference_type difference_type; + //@} + + // allocation/deallocation + /** + * @brief Default constructor creates no elements. + */ + set() + : _M_t() { } + + /** + * @brief Creates a %set with no elements. + * @param __comp Comparator to use. + * @param __a An allocator object. + */ + explicit + set(const _Compare& __comp, + const allocator_type& __a = allocator_type()) + : _M_t(__comp, _Key_alloc_type(__a)) { } + + /** + * @brief Builds a %set from a range. + * @param __first An input iterator. + * @param __last An input iterator. + * + * Create a %set consisting of copies of the elements from + * [__first,__last). This is linear in N if the range is + * already sorted, and NlogN otherwise (where N is + * distance(__first,__last)). + */ + template + set(_InputIterator __first, _InputIterator __last) + : _M_t() + { _M_t._M_insert_unique(__first, __last); } + + /** + * @brief Builds a %set from a range. + * @param __first An input iterator. + * @param __last An input iterator. + * @param __comp A comparison functor. + * @param __a An allocator object. + * + * Create a %set consisting of copies of the elements from + * [__first,__last). This is linear in N if the range is + * already sorted, and NlogN otherwise (where N is + * distance(__first,__last)). + */ + template + set(_InputIterator __first, _InputIterator __last, + const _Compare& __comp, + const allocator_type& __a = allocator_type()) + : _M_t(__comp, _Key_alloc_type(__a)) + { _M_t._M_insert_unique(__first, __last); } + + /** + * @brief %Set copy constructor. + * @param __x A %set of identical element and allocator types. + * + * The newly-created %set uses a copy of the allocation object used + * by @a __x. + */ + set(const set& __x) + : _M_t(__x._M_t) { } + +#if __cplusplus >= 201103L + /** + * @brief %Set move constructor + * @param __x A %set of identical element and allocator types. + * + * The newly-created %set contains the exact contents of @a x. + * The contents of @a x are a valid, but unspecified %set. + */ + set(set&& __x) + noexcept(is_nothrow_copy_constructible<_Compare>::value) + : _M_t(std::move(__x._M_t)) { } + + /** + * @brief Builds a %set from an initializer_list. + * @param __l An initializer_list. + * @param __comp A comparison functor. + * @param __a An allocator object. + * + * Create a %set consisting of copies of the elements in the list. + * This is linear in N if the list is already sorted, and NlogN + * otherwise (where N is @a __l.size()). + */ + set(initializer_list __l, + const _Compare& __comp = _Compare(), + const allocator_type& __a = allocator_type()) + : _M_t(__comp, _Key_alloc_type(__a)) + { _M_t._M_insert_unique(__l.begin(), __l.end()); } + + /// Allocator-extended default constructor. + explicit + set(const allocator_type& __a) + : _M_t(_Compare(), _Key_alloc_type(__a)) { } + + /// Allocator-extended copy constructor. + set(const set& __x, const allocator_type& __a) + : _M_t(__x._M_t, _Key_alloc_type(__a)) { } + + /// Allocator-extended move constructor. + set(set&& __x, const allocator_type& __a) + noexcept(is_nothrow_copy_constructible<_Compare>::value + && _Alloc_traits::_S_always_equal()) + : _M_t(std::move(__x._M_t), _Key_alloc_type(__a)) { } + + /// Allocator-extended initialier-list constructor. + set(initializer_list __l, const allocator_type& __a) + : _M_t(_Compare(), _Key_alloc_type(__a)) + { _M_t._M_insert_unique(__l.begin(), __l.end()); } + + /// Allocator-extended range constructor. + template + set(_InputIterator __first, _InputIterator __last, + const allocator_type& __a) + : _M_t(_Compare(), _Key_alloc_type(__a)) + { _M_t._M_insert_unique(__first, __last); } +#endif + + /** + * @brief %Set assignment operator. + * @param __x A %set of identical element and allocator types. + * + * All the elements of @a __x are copied, but unlike the copy + * constructor, the allocator object is not copied. + */ + set& + operator=(const set& __x) + { + _M_t = __x._M_t; + return *this; + } + +#if __cplusplus >= 201103L + /** + * @brief %Set move assignment operator. + * @param __x A %set of identical element and allocator types. + * + * The contents of @a __x are moved into this %set (without copying + * if the allocators compare equal or get moved on assignment). + * Afterwards @a __x is in a valid, but unspecified state. + */ + set& + operator=(set&& __x) noexcept(_Alloc_traits::_S_nothrow_move()) + { + if (!_M_t._M_move_assign(__x._M_t)) + { + // The rvalue's allocator cannot be moved and is not equal, + // so we need to individually move each element. + clear(); + insert(std::__make_move_if_noexcept_iterator(__x._M_t.begin()), + std::__make_move_if_noexcept_iterator(__x._M_t.end())); + __x.clear(); + } + return *this; + } + + /** + * @brief %Set list assignment operator. + * @param __l An initializer_list. + * + * This function fills a %set with copies of the elements in the + * initializer list @a __l. + * + * Note that the assignment completely changes the %set and + * that the resulting %set's size is the same as the number + * of elements assigned. Old data may be lost. + */ + set& + operator=(initializer_list __l) + { + this->clear(); + this->insert(__l.begin(), __l.end()); + return *this; + } +#endif + + // accessors: + + /// Returns the comparison object with which the %set was constructed. + key_compare + key_comp() const + { return _M_t.key_comp(); } + /// Returns the comparison object with which the %set was constructed. + value_compare + value_comp() const + { return _M_t.key_comp(); } + /// Returns the allocator object with which the %set was constructed. + allocator_type + get_allocator() const _GLIBCXX_NOEXCEPT + { return allocator_type(_M_t.get_allocator()); } + + /** + * Returns a read-only (constant) iterator that points to the first + * element in the %set. Iteration is done in ascending order according + * to the keys. + */ + iterator + begin() const _GLIBCXX_NOEXCEPT + { return _M_t.begin(); } + + /** + * Returns a read-only (constant) iterator that points one past the last + * element in the %set. Iteration is done in ascending order according + * to the keys. + */ + iterator + end() const _GLIBCXX_NOEXCEPT + { return _M_t.end(); } + + /** + * Returns a read-only (constant) iterator that points to the last + * element in the %set. Iteration is done in descending order according + * to the keys. + */ + reverse_iterator + rbegin() const _GLIBCXX_NOEXCEPT + { return _M_t.rbegin(); } + + /** + * Returns a read-only (constant) reverse iterator that points to the + * last pair in the %set. Iteration is done in descending order + * according to the keys. + */ + reverse_iterator + rend() const _GLIBCXX_NOEXCEPT + { return _M_t.rend(); } + +#if __cplusplus >= 201103L + /** + * Returns a read-only (constant) iterator that points to the first + * element in the %set. Iteration is done in ascending order according + * to the keys. + */ + iterator + cbegin() const noexcept + { return _M_t.begin(); } + + /** + * Returns a read-only (constant) iterator that points one past the last + * element in the %set. Iteration is done in ascending order according + * to the keys. + */ + iterator + cend() const noexcept + { return _M_t.end(); } + + /** + * Returns a read-only (constant) iterator that points to the last + * element in the %set. Iteration is done in descending order according + * to the keys. + */ + reverse_iterator + crbegin() const noexcept + { return _M_t.rbegin(); } + + /** + * Returns a read-only (constant) reverse iterator that points to the + * last pair in the %set. Iteration is done in descending order + * according to the keys. + */ + reverse_iterator + crend() const noexcept + { return _M_t.rend(); } +#endif + + /// Returns true if the %set is empty. + bool + empty() const _GLIBCXX_NOEXCEPT + { return _M_t.empty(); } + + /// Returns the size of the %set. + size_type + size() const _GLIBCXX_NOEXCEPT + { return _M_t.size(); } + + /// Returns the maximum size of the %set. + size_type + max_size() const _GLIBCXX_NOEXCEPT + { return _M_t.max_size(); } + + /** + * @brief Swaps data with another %set. + * @param __x A %set of the same element and allocator types. + * + * This exchanges the elements between two sets in constant + * time. (It is only swapping a pointer, an integer, and an + * instance of the @c Compare type (which itself is often + * stateless and empty), so it should be quite fast.) Note + * that the global std::swap() function is specialized such + * that std::swap(s1,s2) will feed to this function. + */ + void + swap(set& __x) +#if __cplusplus >= 201103L + noexcept(_Alloc_traits::_S_nothrow_swap()) +#endif + { _M_t.swap(__x._M_t); } + + // insert/erase +#if __cplusplus >= 201103L + /** + * @brief Attempts to build and insert an element into the %set. + * @param __args Arguments used to generate an element. + * @return A pair, of which the first element is an iterator that points + * to the possibly inserted element, and the second is a bool + * that is true if the element was actually inserted. + * + * This function attempts to build and insert an element into the %set. + * A %set relies on unique keys and thus an element is only inserted if + * it is not already present in the %set. + * + * Insertion requires logarithmic time. + */ + template + std::pair + emplace(_Args&&... __args) + { return _M_t._M_emplace_unique(std::forward<_Args>(__args)...); } + + /** + * @brief Attempts to insert an element into the %set. + * @param __pos An iterator that serves as a hint as to where the + * element should be inserted. + * @param __args Arguments used to generate the element to be + * inserted. + * @return An iterator that points to the element with key equivalent to + * the one generated from @a __args (may or may not be the + * element itself). + * + * This function is not concerned about whether the insertion took place, + * and thus does not return a boolean like the single-argument emplace() + * does. Note that the first parameter is only a hint and can + * potentially improve the performance of the insertion process. A bad + * hint would cause no gains in efficiency. + * + * For more on @a hinting, see: + * http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt07ch17.html + * + * Insertion requires logarithmic time (if the hint is not taken). + */ + template + iterator + emplace_hint(const_iterator __pos, _Args&&... __args) + { + return _M_t._M_emplace_hint_unique(__pos, + std::forward<_Args>(__args)...); + } +#endif + + /** + * @brief Attempts to insert an element into the %set. + * @param __x Element to be inserted. + * @return A pair, of which the first element is an iterator that points + * to the possibly inserted element, and the second is a bool + * that is true if the element was actually inserted. + * + * This function attempts to insert an element into the %set. A %set + * relies on unique keys and thus an element is only inserted if it is + * not already present in the %set. + * + * Insertion requires logarithmic time. + */ + std::pair + insert(const value_type& __x) + { + std::pair __p = + _M_t._M_insert_unique(__x); + return std::pair(__p.first, __p.second); + } + +#if __cplusplus >= 201103L + std::pair + insert(value_type&& __x) + { + std::pair __p = + _M_t._M_insert_unique(std::move(__x)); + return std::pair(__p.first, __p.second); + } +#endif + + /** + * @brief Attempts to insert an element into the %set. + * @param __position An iterator that serves as a hint as to where the + * element should be inserted. + * @param __x Element to be inserted. + * @return An iterator that points to the element with key of + * @a __x (may or may not be the element passed in). + * + * This function is not concerned about whether the insertion took place, + * and thus does not return a boolean like the single-argument insert() + * does. Note that the first parameter is only a hint and can + * potentially improve the performance of the insertion process. A bad + * hint would cause no gains in efficiency. + * + * For more on @a hinting, see: + * http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt07ch17.html + * + * Insertion requires logarithmic time (if the hint is not taken). + */ + iterator + insert(const_iterator __position, const value_type& __x) + { return _M_t._M_insert_unique_(__position, __x); } + +#if __cplusplus >= 201103L + iterator + insert(const_iterator __position, value_type&& __x) + { return _M_t._M_insert_unique_(__position, std::move(__x)); } +#endif + + /** + * @brief A template function that attempts to insert a range + * of elements. + * @param __first Iterator pointing to the start of the range to be + * inserted. + * @param __last Iterator pointing to the end of the range. + * + * Complexity similar to that of the range constructor. + */ + template + void + insert(_InputIterator __first, _InputIterator __last) + { _M_t._M_insert_unique(__first, __last); } + +#if __cplusplus >= 201103L + /** + * @brief Attempts to insert a list of elements into the %set. + * @param __l A std::initializer_list of elements + * to be inserted. + * + * Complexity similar to that of the range constructor. + */ + void + insert(initializer_list __l) + { this->insert(__l.begin(), __l.end()); } +#endif + +#if __cplusplus >= 201103L + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR 130. Associative erase should return an iterator. + /** + * @brief Erases an element from a %set. + * @param __position An iterator pointing to the element to be erased. + * @return An iterator pointing to the element immediately following + * @a __position prior to the element being erased. If no such + * element exists, end() is returned. + * + * This function erases an element, pointed to by the given iterator, + * from a %set. Note that this function only erases the element, and + * that if the element is itself a pointer, the pointed-to memory is not + * touched in any way. Managing the pointer is the user's + * responsibility. + */ + _GLIBCXX_ABI_TAG_CXX11 + iterator + erase(const_iterator __position) + { return _M_t.erase(__position); } +#else + /** + * @brief Erases an element from a %set. + * @param position An iterator pointing to the element to be erased. + * + * This function erases an element, pointed to by the given iterator, + * from a %set. Note that this function only erases the element, and + * that if the element is itself a pointer, the pointed-to memory is not + * touched in any way. Managing the pointer is the user's + * responsibility. + */ + void + erase(iterator __position) + { _M_t.erase(__position); } +#endif + + /** + * @brief Erases elements according to the provided key. + * @param __x Key of element to be erased. + * @return The number of elements erased. + * + * This function erases all the elements located by the given key from + * a %set. + * Note that this function only erases the element, and that if + * the element is itself a pointer, the pointed-to memory is not touched + * in any way. Managing the pointer is the user's responsibility. + */ + size_type + erase(const key_type& __x) + { return _M_t.erase(__x); } + +#if __cplusplus >= 201103L + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR 130. Associative erase should return an iterator. + /** + * @brief Erases a [__first,__last) range of elements from a %set. + * @param __first Iterator pointing to the start of the range to be + * erased. + + * @param __last Iterator pointing to the end of the range to + * be erased. + * @return The iterator @a __last. + * + * This function erases a sequence of elements from a %set. + * Note that this function only erases the element, and that if + * the element is itself a pointer, the pointed-to memory is not touched + * in any way. Managing the pointer is the user's responsibility. + */ + _GLIBCXX_ABI_TAG_CXX11 + iterator + erase(const_iterator __first, const_iterator __last) + { return _M_t.erase(__first, __last); } +#else + /** + * @brief Erases a [first,last) range of elements from a %set. + * @param __first Iterator pointing to the start of the range to be + * erased. + * @param __last Iterator pointing to the end of the range to + * be erased. + * + * This function erases a sequence of elements from a %set. + * Note that this function only erases the element, and that if + * the element is itself a pointer, the pointed-to memory is not touched + * in any way. Managing the pointer is the user's responsibility. + */ + void + erase(iterator __first, iterator __last) + { _M_t.erase(__first, __last); } +#endif + + /** + * Erases all elements in a %set. Note that this function only erases + * the elements, and that if the elements themselves are pointers, the + * pointed-to memory is not touched in any way. Managing the pointer is + * the user's responsibility. + */ + void + clear() _GLIBCXX_NOEXCEPT + { _M_t.clear(); } + + // set operations: + + /** + * @brief Finds the number of elements. + * @param __x Element to located. + * @return Number of elements with specified key. + * + * This function only makes sense for multisets; for set the result will + * either be 0 (not present) or 1 (present). + */ + size_type + count(const key_type& __x) const + { return _M_t.find(__x) == _M_t.end() ? 0 : 1; } + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 214. set::find() missing const overload + //@{ + /** + * @brief Tries to locate an element in a %set. + * @param __x Element to be located. + * @return Iterator pointing to sought-after element, or end() if not + * found. + * + * This function takes a key and tries to locate the element with which + * the key matches. If successful the function returns an iterator + * pointing to the sought after element. If unsuccessful it returns the + * past-the-end ( @c end() ) iterator. + */ + iterator + find(const key_type& __x) + { return _M_t.find(__x); } + + const_iterator + find(const key_type& __x) const + { return _M_t.find(__x); } + //@} + + //@{ + /** + * @brief Finds the beginning of a subsequence matching given key. + * @param __x Key to be located. + * @return Iterator pointing to first element equal to or greater + * than key, or end(). + * + * This function returns the first element of a subsequence of elements + * that matches the given key. If unsuccessful it returns an iterator + * pointing to the first element that has a greater value than given key + * or end() if no such element exists. + */ + iterator + lower_bound(const key_type& __x) + { return _M_t.lower_bound(__x); } + + const_iterator + lower_bound(const key_type& __x) const + { return _M_t.lower_bound(__x); } + //@} + + //@{ + /** + * @brief Finds the end of a subsequence matching given key. + * @param __x Key to be located. + * @return Iterator pointing to the first element + * greater than key, or end(). + */ + iterator + upper_bound(const key_type& __x) + { return _M_t.upper_bound(__x); } + + const_iterator + upper_bound(const key_type& __x) const + { return _M_t.upper_bound(__x); } + //@} + + //@{ + /** + * @brief Finds a subsequence matching given key. + * @param __x Key to be located. + * @return Pair of iterators that possibly points to the subsequence + * matching given key. + * + * This function is equivalent to + * @code + * std::make_pair(c.lower_bound(val), + * c.upper_bound(val)) + * @endcode + * (but is faster than making the calls separately). + * + * This function probably only makes sense for multisets. + */ + std::pair + equal_range(const key_type& __x) + { return _M_t.equal_range(__x); } + + std::pair + equal_range(const key_type& __x) const + { return _M_t.equal_range(__x); } + //@} + + template + friend bool + operator==(const set<_K1, _C1, _A1>&, const set<_K1, _C1, _A1>&); + + template + friend bool + operator<(const set<_K1, _C1, _A1>&, const set<_K1, _C1, _A1>&); + }; + + + /** + * @brief Set equality comparison. + * @param __x A %set. + * @param __y A %set of the same type as @a x. + * @return True iff the size and elements of the sets are equal. + * + * This is an equivalence relation. It is linear in the size of the sets. + * Sets are considered equivalent if their sizes are equal, and if + * corresponding elements compare equal. + */ + template + inline bool + operator==(const set<_Key, _Compare, _Alloc>& __x, + const set<_Key, _Compare, _Alloc>& __y) + { return __x._M_t == __y._M_t; } + + /** + * @brief Set ordering relation. + * @param __x A %set. + * @param __y A %set of the same type as @a x. + * @return True iff @a __x is lexicographically less than @a __y. + * + * This is a total ordering relation. It is linear in the size of the + * sets. The elements must be comparable with @c <. + * + * See std::lexicographical_compare() for how the determination is made. + */ + template + inline bool + operator<(const set<_Key, _Compare, _Alloc>& __x, + const set<_Key, _Compare, _Alloc>& __y) + { return __x._M_t < __y._M_t; } + + /// Returns !(x == y). + template + inline bool + operator!=(const set<_Key, _Compare, _Alloc>& __x, + const set<_Key, _Compare, _Alloc>& __y) + { return !(__x == __y); } + + /// Returns y < x. + template + inline bool + operator>(const set<_Key, _Compare, _Alloc>& __x, + const set<_Key, _Compare, _Alloc>& __y) + { return __y < __x; } + + /// Returns !(y < x) + template + inline bool + operator<=(const set<_Key, _Compare, _Alloc>& __x, + const set<_Key, _Compare, _Alloc>& __y) + { return !(__y < __x); } + + /// Returns !(x < y) + template + inline bool + operator>=(const set<_Key, _Compare, _Alloc>& __x, + const set<_Key, _Compare, _Alloc>& __y) + { return !(__x < __y); } + + /// See std::set::swap(). + template + inline void + swap(set<_Key, _Compare, _Alloc>& __x, set<_Key, _Compare, _Alloc>& __y) + { __x.swap(__y); } + +_GLIBCXX_END_NAMESPACE_CONTAINER +} //namespace std +#endif /* _STL_SET_H */ diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stl_stack.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stl_stack.h new file mode 100755 index 0000000..f4bb72c --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stl_stack.h @@ -0,0 +1,306 @@ +// Stack implementation -*- C++ -*- + +// Copyright (C) 2001-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/* + * + * Copyright (c) 1994 + * Hewlett-Packard Company + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Hewlett-Packard Company makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + * + * + * Copyright (c) 1996,1997 + * Silicon Graphics Computer Systems, Inc. + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Silicon Graphics makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + */ + +/** @file bits/stl_stack.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{stack} + */ + +#ifndef _STL_STACK_H +#define _STL_STACK_H 1 + +#include +#include +#if __cplusplus >= 201103L +# include +#endif + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /** + * @brief A standard container giving FILO behavior. + * + * @ingroup sequences + * + * @tparam _Tp Type of element. + * @tparam _Sequence Type of underlying sequence, defaults to deque<_Tp>. + * + * Meets many of the requirements of a + * container, + * but does not define anything to do with iterators. Very few of the + * other standard container interfaces are defined. + * + * This is not a true container, but an @e adaptor. It holds + * another container, and provides a wrapper interface to that + * container. The wrapper is what enforces strict + * first-in-last-out %stack behavior. + * + * The second template parameter defines the type of the underlying + * sequence/container. It defaults to std::deque, but it can be + * any type that supports @c back, @c push_back, and @c pop_front, + * such as std::list, std::vector, or an appropriate user-defined + * type. + * + * Members not found in @a normal containers are @c container_type, + * which is a typedef for the second Sequence parameter, and @c + * push, @c pop, and @c top, which are standard %stack/FILO + * operations. + */ + template > + class stack + { + // concept requirements + typedef typename _Sequence::value_type _Sequence_value_type; + __glibcxx_class_requires(_Tp, _SGIAssignableConcept) + __glibcxx_class_requires(_Sequence, _BackInsertionSequenceConcept) + __glibcxx_class_requires2(_Tp, _Sequence_value_type, _SameTypeConcept) + + template + friend bool + operator==(const stack<_Tp1, _Seq1>&, const stack<_Tp1, _Seq1>&); + + template + friend bool + operator<(const stack<_Tp1, _Seq1>&, const stack<_Tp1, _Seq1>&); + + public: + typedef typename _Sequence::value_type value_type; + typedef typename _Sequence::reference reference; + typedef typename _Sequence::const_reference const_reference; + typedef typename _Sequence::size_type size_type; + typedef _Sequence container_type; + + protected: + // See queue::c for notes on this name. + _Sequence c; + + public: + // XXX removed old def ctor, added def arg to this one to match 14882 + /** + * @brief Default constructor creates no elements. + */ +#if __cplusplus < 201103L + explicit + stack(const _Sequence& __c = _Sequence()) + : c(__c) { } +#else + explicit + stack(const _Sequence& __c) + : c(__c) { } + + explicit + stack(_Sequence&& __c = _Sequence()) + : c(std::move(__c)) { } +#endif + + /** + * Returns true if the %stack is empty. + */ + bool + empty() const + { return c.empty(); } + + /** Returns the number of elements in the %stack. */ + size_type + size() const + { return c.size(); } + + /** + * Returns a read/write reference to the data at the first + * element of the %stack. + */ + reference + top() + { + __glibcxx_requires_nonempty(); + return c.back(); + } + + /** + * Returns a read-only (constant) reference to the data at the first + * element of the %stack. + */ + const_reference + top() const + { + __glibcxx_requires_nonempty(); + return c.back(); + } + + /** + * @brief Add data to the top of the %stack. + * @param __x Data to be added. + * + * This is a typical %stack operation. The function creates an + * element at the top of the %stack and assigns the given data + * to it. The time complexity of the operation depends on the + * underlying sequence. + */ + void + push(const value_type& __x) + { c.push_back(__x); } + +#if __cplusplus >= 201103L + void + push(value_type&& __x) + { c.push_back(std::move(__x)); } + + template + void + emplace(_Args&&... __args) + { c.emplace_back(std::forward<_Args>(__args)...); } +#endif + + /** + * @brief Removes first element. + * + * This is a typical %stack operation. It shrinks the %stack + * by one. The time complexity of the operation depends on the + * underlying sequence. + * + * Note that no data is returned, and if the first element's + * data is needed, it should be retrieved before pop() is + * called. + */ + void + pop() + { + __glibcxx_requires_nonempty(); + c.pop_back(); + } + +#if __cplusplus >= 201103L + void + swap(stack& __s) + noexcept(noexcept(swap(c, __s.c))) + { + using std::swap; + swap(c, __s.c); + } +#endif + }; + + /** + * @brief Stack equality comparison. + * @param __x A %stack. + * @param __y A %stack of the same type as @a __x. + * @return True iff the size and elements of the stacks are equal. + * + * This is an equivalence relation. Complexity and semantics + * depend on the underlying sequence type, but the expected rules + * are: this relation is linear in the size of the sequences, and + * stacks are considered equivalent if their sequences compare + * equal. + */ + template + inline bool + operator==(const stack<_Tp, _Seq>& __x, const stack<_Tp, _Seq>& __y) + { return __x.c == __y.c; } + + /** + * @brief Stack ordering relation. + * @param __x A %stack. + * @param __y A %stack of the same type as @a x. + * @return True iff @a x is lexicographically less than @a __y. + * + * This is an total ordering relation. Complexity and semantics + * depend on the underlying sequence type, but the expected rules + * are: this relation is linear in the size of the sequences, the + * elements must be comparable with @c <, and + * std::lexicographical_compare() is usually used to make the + * determination. + */ + template + inline bool + operator<(const stack<_Tp, _Seq>& __x, const stack<_Tp, _Seq>& __y) + { return __x.c < __y.c; } + + /// Based on operator== + template + inline bool + operator!=(const stack<_Tp, _Seq>& __x, const stack<_Tp, _Seq>& __y) + { return !(__x == __y); } + + /// Based on operator< + template + inline bool + operator>(const stack<_Tp, _Seq>& __x, const stack<_Tp, _Seq>& __y) + { return __y < __x; } + + /// Based on operator< + template + inline bool + operator<=(const stack<_Tp, _Seq>& __x, const stack<_Tp, _Seq>& __y) + { return !(__y < __x); } + + /// Based on operator< + template + inline bool + operator>=(const stack<_Tp, _Seq>& __x, const stack<_Tp, _Seq>& __y) + { return !(__x < __y); } + +#if __cplusplus >= 201103L + template + inline void + swap(stack<_Tp, _Seq>& __x, stack<_Tp, _Seq>& __y) + noexcept(noexcept(__x.swap(__y))) + { __x.swap(__y); } + + template + struct uses_allocator, _Alloc> + : public uses_allocator<_Seq, _Alloc>::type { }; +#endif + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif /* _STL_STACK_H */ diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stl_tempbuf.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stl_tempbuf.h new file mode 100755 index 0000000..ff5ab44 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stl_tempbuf.h @@ -0,0 +1,271 @@ +// Temporary buffer implementation -*- C++ -*- + +// Copyright (C) 2001-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/* + * + * Copyright (c) 1994 + * Hewlett-Packard Company + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Hewlett-Packard Company makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + * + * + * Copyright (c) 1996,1997 + * Silicon Graphics Computer Systems, Inc. + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Silicon Graphics makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + */ + +/** @file bits/stl_tempbuf.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{memory} + */ + +#ifndef _STL_TEMPBUF_H +#define _STL_TEMPBUF_H 1 + +#include +#include + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /** + * @brief Allocates a temporary buffer. + * @param __len The number of objects of type Tp. + * @return See full description. + * + * Reinventing the wheel, but this time with prettier spokes! + * + * This function tries to obtain storage for @c __len adjacent Tp + * objects. The objects themselves are not constructed, of course. + * A pair<> is returned containing the buffer s address and + * capacity (in the units of sizeof(_Tp)), or a pair of 0 values if + * no storage can be obtained. Note that the capacity obtained + * may be less than that requested if the memory is unavailable; + * you should compare len with the .second return value. + * + * Provides the nothrow exception guarantee. + */ + template + pair<_Tp*, ptrdiff_t> + get_temporary_buffer(ptrdiff_t __len) _GLIBCXX_NOEXCEPT + { + const ptrdiff_t __max = + __gnu_cxx::__numeric_traits::__max / sizeof(_Tp); + if (__len > __max) + __len = __max; + + while (__len > 0) + { + _Tp* __tmp = static_cast<_Tp*>(::operator new(__len * sizeof(_Tp), + std::nothrow)); + if (__tmp != 0) + return std::pair<_Tp*, ptrdiff_t>(__tmp, __len); + __len /= 2; + } + return std::pair<_Tp*, ptrdiff_t>(static_cast<_Tp*>(0), 0); + } + + /** + * @brief The companion to get_temporary_buffer(). + * @param __p A buffer previously allocated by get_temporary_buffer. + * @return None. + * + * Frees the memory pointed to by __p. + */ + template + inline void + return_temporary_buffer(_Tp* __p) + { ::operator delete(__p, std::nothrow); } + + + /** + * This class is used in two places: stl_algo.h and ext/memory, + * where it is wrapped as the temporary_buffer class. See + * temporary_buffer docs for more notes. + */ + template + class _Temporary_buffer + { + // concept requirements + __glibcxx_class_requires(_ForwardIterator, _ForwardIteratorConcept) + + public: + typedef _Tp value_type; + typedef value_type* pointer; + typedef pointer iterator; + typedef ptrdiff_t size_type; + + protected: + size_type _M_original_len; + size_type _M_len; + pointer _M_buffer; + + public: + /// As per Table mumble. + size_type + size() const + { return _M_len; } + + /// Returns the size requested by the constructor; may be >size(). + size_type + requested_size() const + { return _M_original_len; } + + /// As per Table mumble. + iterator + begin() + { return _M_buffer; } + + /// As per Table mumble. + iterator + end() + { return _M_buffer + _M_len; } + + /** + * Constructs a temporary buffer of a size somewhere between + * zero and the size of the given range. + */ + _Temporary_buffer(_ForwardIterator __first, _ForwardIterator __last); + + ~_Temporary_buffer() + { + std::_Destroy(_M_buffer, _M_buffer + _M_len); + std::return_temporary_buffer(_M_buffer); + } + + private: + // Disable copy constructor and assignment operator. + _Temporary_buffer(const _Temporary_buffer&); + + void + operator=(const _Temporary_buffer&); + }; + + + template + struct __uninitialized_construct_buf_dispatch + { + template + static void + __ucr(_Pointer __first, _Pointer __last, + _ForwardIterator __seed) + { + if(__first == __last) + return; + + _Pointer __cur = __first; + __try + { + std::_Construct(std::__addressof(*__first), + _GLIBCXX_MOVE(*__seed)); + _Pointer __prev = __cur; + ++__cur; + for(; __cur != __last; ++__cur, ++__prev) + std::_Construct(std::__addressof(*__cur), + _GLIBCXX_MOVE(*__prev)); + *__seed = _GLIBCXX_MOVE(*__prev); + } + __catch(...) + { + std::_Destroy(__first, __cur); + __throw_exception_again; + } + } + }; + + template<> + struct __uninitialized_construct_buf_dispatch + { + template + static void + __ucr(_Pointer, _Pointer, _ForwardIterator) { } + }; + + // Constructs objects in the range [first, last). + // Note that while these new objects will take valid values, + // their exact value is not defined. In particular they may + // be 'moved from'. + // + // While *__seed may be altered during this algorithm, it will have + // the same value when the algorithm finishes, unless one of the + // constructions throws. + // + // Requirements: _Pointer::value_type(_Tp&&) is valid. + template + inline void + __uninitialized_construct_buf(_Pointer __first, _Pointer __last, + _ForwardIterator __seed) + { + typedef typename std::iterator_traits<_Pointer>::value_type + _ValueType; + + std::__uninitialized_construct_buf_dispatch< + __has_trivial_constructor(_ValueType)>:: + __ucr(__first, __last, __seed); + } + + template + _Temporary_buffer<_ForwardIterator, _Tp>:: + _Temporary_buffer(_ForwardIterator __first, _ForwardIterator __last) + : _M_original_len(std::distance(__first, __last)), + _M_len(0), _M_buffer(0) + { + __try + { + std::pair __p(std::get_temporary_buffer< + value_type>(_M_original_len)); + _M_buffer = __p.first; + _M_len = __p.second; + if (_M_buffer) + std::__uninitialized_construct_buf(_M_buffer, _M_buffer + _M_len, + __first); + } + __catch(...) + { + std::return_temporary_buffer(_M_buffer); + _M_buffer = 0; + _M_len = 0; + __throw_exception_again; + } + } + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif /* _STL_TEMPBUF_H */ + diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stl_tree.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stl_tree.h new file mode 100755 index 0000000..ce43ab8 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stl_tree.h @@ -0,0 +1,1988 @@ +// RB tree implementation -*- C++ -*- + +// Copyright (C) 2001-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/* + * + * Copyright (c) 1996,1997 + * Silicon Graphics Computer Systems, Inc. + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Silicon Graphics makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + * + * + * Copyright (c) 1994 + * Hewlett-Packard Company + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Hewlett-Packard Company makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + * + * + */ + +/** @file bits/stl_tree.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{map,set} + */ + +#ifndef _STL_TREE_H +#define _STL_TREE_H 1 + +#include +#include +#include +#include +#include +#if __cplusplus >= 201103L +#include +#endif + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + // Red-black tree class, designed for use in implementing STL + // associative containers (set, multiset, map, and multimap). The + // insertion and deletion algorithms are based on those in Cormen, + // Leiserson, and Rivest, Introduction to Algorithms (MIT Press, + // 1990), except that + // + // (1) the header cell is maintained with links not only to the root + // but also to the leftmost node of the tree, to enable constant + // time begin(), and to the rightmost node of the tree, to enable + // linear time performance when used with the generic set algorithms + // (set_union, etc.) + // + // (2) when a node being deleted has two children its successor node + // is relinked into its place, rather than copied, so that the only + // iterators invalidated are those referring to the deleted node. + + enum _Rb_tree_color { _S_red = false, _S_black = true }; + + struct _Rb_tree_node_base + { + typedef _Rb_tree_node_base* _Base_ptr; + typedef const _Rb_tree_node_base* _Const_Base_ptr; + + _Rb_tree_color _M_color; + _Base_ptr _M_parent; + _Base_ptr _M_left; + _Base_ptr _M_right; + + static _Base_ptr + _S_minimum(_Base_ptr __x) _GLIBCXX_NOEXCEPT + { + while (__x->_M_left != 0) __x = __x->_M_left; + return __x; + } + + static _Const_Base_ptr + _S_minimum(_Const_Base_ptr __x) _GLIBCXX_NOEXCEPT + { + while (__x->_M_left != 0) __x = __x->_M_left; + return __x; + } + + static _Base_ptr + _S_maximum(_Base_ptr __x) _GLIBCXX_NOEXCEPT + { + while (__x->_M_right != 0) __x = __x->_M_right; + return __x; + } + + static _Const_Base_ptr + _S_maximum(_Const_Base_ptr __x) _GLIBCXX_NOEXCEPT + { + while (__x->_M_right != 0) __x = __x->_M_right; + return __x; + } + }; + + template + struct _Rb_tree_node : public _Rb_tree_node_base + { + typedef _Rb_tree_node<_Val>* _Link_type; + +#if __cplusplus < 201103L + _Val _M_value_field; + + _Val* + _M_valptr() + { return std::__addressof(_M_value_field); } + + const _Val* + _M_valptr() const + { return std::__addressof(_M_value_field); } +#else + __gnu_cxx::__aligned_buffer<_Val> _M_storage; + + _Val* + _M_valptr() + { return _M_storage._M_ptr(); } + + const _Val* + _M_valptr() const + { return _M_storage._M_ptr(); } +#endif + }; + + _GLIBCXX_PURE _Rb_tree_node_base* + _Rb_tree_increment(_Rb_tree_node_base* __x) throw (); + + _GLIBCXX_PURE const _Rb_tree_node_base* + _Rb_tree_increment(const _Rb_tree_node_base* __x) throw (); + + _GLIBCXX_PURE _Rb_tree_node_base* + _Rb_tree_decrement(_Rb_tree_node_base* __x) throw (); + + _GLIBCXX_PURE const _Rb_tree_node_base* + _Rb_tree_decrement(const _Rb_tree_node_base* __x) throw (); + + template + struct _Rb_tree_iterator + { + typedef _Tp value_type; + typedef _Tp& reference; + typedef _Tp* pointer; + + typedef bidirectional_iterator_tag iterator_category; + typedef ptrdiff_t difference_type; + + typedef _Rb_tree_iterator<_Tp> _Self; + typedef _Rb_tree_node_base::_Base_ptr _Base_ptr; + typedef _Rb_tree_node<_Tp>* _Link_type; + + _Rb_tree_iterator() _GLIBCXX_NOEXCEPT + : _M_node() { } + + explicit + _Rb_tree_iterator(_Link_type __x) _GLIBCXX_NOEXCEPT + : _M_node(__x) { } + + reference + operator*() const _GLIBCXX_NOEXCEPT + { return *static_cast<_Link_type>(_M_node)->_M_valptr(); } + + pointer + operator->() const _GLIBCXX_NOEXCEPT + { return static_cast<_Link_type> (_M_node)->_M_valptr(); } + + _Self& + operator++() _GLIBCXX_NOEXCEPT + { + _M_node = _Rb_tree_increment(_M_node); + return *this; + } + + _Self + operator++(int) _GLIBCXX_NOEXCEPT + { + _Self __tmp = *this; + _M_node = _Rb_tree_increment(_M_node); + return __tmp; + } + + _Self& + operator--() _GLIBCXX_NOEXCEPT + { + _M_node = _Rb_tree_decrement(_M_node); + return *this; + } + + _Self + operator--(int) _GLIBCXX_NOEXCEPT + { + _Self __tmp = *this; + _M_node = _Rb_tree_decrement(_M_node); + return __tmp; + } + + bool + operator==(const _Self& __x) const _GLIBCXX_NOEXCEPT + { return _M_node == __x._M_node; } + + bool + operator!=(const _Self& __x) const _GLIBCXX_NOEXCEPT + { return _M_node != __x._M_node; } + + _Base_ptr _M_node; + }; + + template + struct _Rb_tree_const_iterator + { + typedef _Tp value_type; + typedef const _Tp& reference; + typedef const _Tp* pointer; + + typedef _Rb_tree_iterator<_Tp> iterator; + + typedef bidirectional_iterator_tag iterator_category; + typedef ptrdiff_t difference_type; + + typedef _Rb_tree_const_iterator<_Tp> _Self; + typedef _Rb_tree_node_base::_Const_Base_ptr _Base_ptr; + typedef const _Rb_tree_node<_Tp>* _Link_type; + + _Rb_tree_const_iterator() _GLIBCXX_NOEXCEPT + : _M_node() { } + + explicit + _Rb_tree_const_iterator(_Link_type __x) _GLIBCXX_NOEXCEPT + : _M_node(__x) { } + + _Rb_tree_const_iterator(const iterator& __it) _GLIBCXX_NOEXCEPT + : _M_node(__it._M_node) { } + + iterator + _M_const_cast() const _GLIBCXX_NOEXCEPT + { return iterator(static_cast + (const_cast(_M_node))); } + + reference + operator*() const _GLIBCXX_NOEXCEPT + { return *static_cast<_Link_type>(_M_node)->_M_valptr(); } + + pointer + operator->() const _GLIBCXX_NOEXCEPT + { return static_cast<_Link_type>(_M_node)->_M_valptr(); } + + _Self& + operator++() _GLIBCXX_NOEXCEPT + { + _M_node = _Rb_tree_increment(_M_node); + return *this; + } + + _Self + operator++(int) _GLIBCXX_NOEXCEPT + { + _Self __tmp = *this; + _M_node = _Rb_tree_increment(_M_node); + return __tmp; + } + + _Self& + operator--() _GLIBCXX_NOEXCEPT + { + _M_node = _Rb_tree_decrement(_M_node); + return *this; + } + + _Self + operator--(int) _GLIBCXX_NOEXCEPT + { + _Self __tmp = *this; + _M_node = _Rb_tree_decrement(_M_node); + return __tmp; + } + + bool + operator==(const _Self& __x) const _GLIBCXX_NOEXCEPT + { return _M_node == __x._M_node; } + + bool + operator!=(const _Self& __x) const _GLIBCXX_NOEXCEPT + { return _M_node != __x._M_node; } + + _Base_ptr _M_node; + }; + + template + inline bool + operator==(const _Rb_tree_iterator<_Val>& __x, + const _Rb_tree_const_iterator<_Val>& __y) _GLIBCXX_NOEXCEPT + { return __x._M_node == __y._M_node; } + + template + inline bool + operator!=(const _Rb_tree_iterator<_Val>& __x, + const _Rb_tree_const_iterator<_Val>& __y) _GLIBCXX_NOEXCEPT + { return __x._M_node != __y._M_node; } + + void + _Rb_tree_insert_and_rebalance(const bool __insert_left, + _Rb_tree_node_base* __x, + _Rb_tree_node_base* __p, + _Rb_tree_node_base& __header) throw (); + + _Rb_tree_node_base* + _Rb_tree_rebalance_for_erase(_Rb_tree_node_base* const __z, + _Rb_tree_node_base& __header) throw (); + + + template > + class _Rb_tree + { + typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template + rebind<_Rb_tree_node<_Val> >::other _Node_allocator; + + typedef __gnu_cxx::__alloc_traits<_Node_allocator> _Alloc_traits; + + protected: + typedef _Rb_tree_node_base* _Base_ptr; + typedef const _Rb_tree_node_base* _Const_Base_ptr; + + public: + typedef _Key key_type; + typedef _Val value_type; + typedef value_type* pointer; + typedef const value_type* const_pointer; + typedef value_type& reference; + typedef const value_type& const_reference; + typedef _Rb_tree_node<_Val>* _Link_type; + typedef const _Rb_tree_node<_Val>* _Const_Link_type; + typedef size_t size_type; + typedef ptrdiff_t difference_type; + typedef _Alloc allocator_type; + + _Node_allocator& + _M_get_Node_allocator() _GLIBCXX_NOEXCEPT + { return *static_cast<_Node_allocator*>(&this->_M_impl); } + + const _Node_allocator& + _M_get_Node_allocator() const _GLIBCXX_NOEXCEPT + { return *static_cast(&this->_M_impl); } + + allocator_type + get_allocator() const _GLIBCXX_NOEXCEPT + { return allocator_type(_M_get_Node_allocator()); } + + protected: + _Link_type + _M_get_node() + { return _Alloc_traits::allocate(_M_get_Node_allocator(), 1); } + + void + _M_put_node(_Link_type __p) _GLIBCXX_NOEXCEPT + { _Alloc_traits::deallocate(_M_get_Node_allocator(), __p, 1); } + +#if __cplusplus < 201103L + _Link_type + _M_create_node(const value_type& __x) + { + _Link_type __tmp = _M_get_node(); + __try + { get_allocator().construct(__tmp->_M_valptr(), __x); } + __catch(...) + { + _M_put_node(__tmp); + __throw_exception_again; + } + return __tmp; + } + + void + _M_destroy_node(_Link_type __p) + { + get_allocator().destroy(__p->_M_valptr()); + _M_put_node(__p); + } +#else + template + _Link_type + _M_create_node(_Args&&... __args) + { + _Link_type __tmp = _M_get_node(); + __try + { + ::new(__tmp) _Rb_tree_node<_Val>; + _Alloc_traits::construct(_M_get_Node_allocator(), + __tmp->_M_valptr(), + std::forward<_Args>(__args)...); + } + __catch(...) + { + _M_put_node(__tmp); + __throw_exception_again; + } + return __tmp; + } + + void + _M_destroy_node(_Link_type __p) noexcept + { + _Alloc_traits::destroy(_M_get_Node_allocator(), __p->_M_valptr()); + __p->~_Rb_tree_node<_Val>(); + _M_put_node(__p); + } +#endif + + _Link_type + _M_clone_node(_Const_Link_type __x) + { + _Link_type __tmp = _M_create_node(*__x->_M_valptr()); + __tmp->_M_color = __x->_M_color; + __tmp->_M_left = 0; + __tmp->_M_right = 0; + return __tmp; + } + + protected: + template + struct _Rb_tree_impl : public _Node_allocator + { + _Key_compare _M_key_compare; + _Rb_tree_node_base _M_header; + size_type _M_node_count; // Keeps track of size of tree. + + _Rb_tree_impl() + : _Node_allocator(), _M_key_compare(), _M_header(), + _M_node_count(0) + { _M_initialize(); } + + _Rb_tree_impl(const _Key_compare& __comp, const _Node_allocator& __a) + : _Node_allocator(__a), _M_key_compare(__comp), _M_header(), + _M_node_count(0) + { _M_initialize(); } + +#if __cplusplus >= 201103L + _Rb_tree_impl(const _Key_compare& __comp, _Node_allocator&& __a) + : _Node_allocator(std::move(__a)), _M_key_compare(__comp), + _M_header(), _M_node_count(0) + { _M_initialize(); } +#endif + + private: + void + _M_initialize() + { + this->_M_header._M_color = _S_red; + this->_M_header._M_parent = 0; + this->_M_header._M_left = &this->_M_header; + this->_M_header._M_right = &this->_M_header; + } + }; + + _Rb_tree_impl<_Compare> _M_impl; + + protected: + _Base_ptr& + _M_root() _GLIBCXX_NOEXCEPT + { return this->_M_impl._M_header._M_parent; } + + _Const_Base_ptr + _M_root() const _GLIBCXX_NOEXCEPT + { return this->_M_impl._M_header._M_parent; } + + _Base_ptr& + _M_leftmost() _GLIBCXX_NOEXCEPT + { return this->_M_impl._M_header._M_left; } + + _Const_Base_ptr + _M_leftmost() const _GLIBCXX_NOEXCEPT + { return this->_M_impl._M_header._M_left; } + + _Base_ptr& + _M_rightmost() _GLIBCXX_NOEXCEPT + { return this->_M_impl._M_header._M_right; } + + _Const_Base_ptr + _M_rightmost() const _GLIBCXX_NOEXCEPT + { return this->_M_impl._M_header._M_right; } + + _Link_type + _M_begin() _GLIBCXX_NOEXCEPT + { return static_cast<_Link_type>(this->_M_impl._M_header._M_parent); } + + _Const_Link_type + _M_begin() const _GLIBCXX_NOEXCEPT + { + return static_cast<_Const_Link_type> + (this->_M_impl._M_header._M_parent); + } + + _Link_type + _M_end() _GLIBCXX_NOEXCEPT + { return reinterpret_cast<_Link_type>(&this->_M_impl._M_header); } + + _Const_Link_type + _M_end() const _GLIBCXX_NOEXCEPT + { return reinterpret_cast<_Const_Link_type>(&this->_M_impl._M_header); } + + static const_reference + _S_value(_Const_Link_type __x) + { return *__x->_M_valptr(); } + + static const _Key& + _S_key(_Const_Link_type __x) + { return _KeyOfValue()(_S_value(__x)); } + + static _Link_type + _S_left(_Base_ptr __x) _GLIBCXX_NOEXCEPT + { return static_cast<_Link_type>(__x->_M_left); } + + static _Const_Link_type + _S_left(_Const_Base_ptr __x) _GLIBCXX_NOEXCEPT + { return static_cast<_Const_Link_type>(__x->_M_left); } + + static _Link_type + _S_right(_Base_ptr __x) _GLIBCXX_NOEXCEPT + { return static_cast<_Link_type>(__x->_M_right); } + + static _Const_Link_type + _S_right(_Const_Base_ptr __x) _GLIBCXX_NOEXCEPT + { return static_cast<_Const_Link_type>(__x->_M_right); } + + static const_reference + _S_value(_Const_Base_ptr __x) + { return *static_cast<_Const_Link_type>(__x)->_M_valptr(); } + + static const _Key& + _S_key(_Const_Base_ptr __x) + { return _KeyOfValue()(_S_value(__x)); } + + static _Base_ptr + _S_minimum(_Base_ptr __x) _GLIBCXX_NOEXCEPT + { return _Rb_tree_node_base::_S_minimum(__x); } + + static _Const_Base_ptr + _S_minimum(_Const_Base_ptr __x) _GLIBCXX_NOEXCEPT + { return _Rb_tree_node_base::_S_minimum(__x); } + + static _Base_ptr + _S_maximum(_Base_ptr __x) _GLIBCXX_NOEXCEPT + { return _Rb_tree_node_base::_S_maximum(__x); } + + static _Const_Base_ptr + _S_maximum(_Const_Base_ptr __x) _GLIBCXX_NOEXCEPT + { return _Rb_tree_node_base::_S_maximum(__x); } + + public: + typedef _Rb_tree_iterator iterator; + typedef _Rb_tree_const_iterator const_iterator; + + typedef std::reverse_iterator reverse_iterator; + typedef std::reverse_iterator const_reverse_iterator; + + private: + pair<_Base_ptr, _Base_ptr> + _M_get_insert_unique_pos(const key_type& __k); + + pair<_Base_ptr, _Base_ptr> + _M_get_insert_equal_pos(const key_type& __k); + + pair<_Base_ptr, _Base_ptr> + _M_get_insert_hint_unique_pos(const_iterator __pos, + const key_type& __k); + + pair<_Base_ptr, _Base_ptr> + _M_get_insert_hint_equal_pos(const_iterator __pos, + const key_type& __k); + +#if __cplusplus >= 201103L + template + iterator + _M_insert_(_Base_ptr __x, _Base_ptr __y, _Arg&& __v); + + iterator + _M_insert_node(_Base_ptr __x, _Base_ptr __y, _Link_type __z); + + template + iterator + _M_insert_lower(_Base_ptr __y, _Arg&& __v); + + template + iterator + _M_insert_equal_lower(_Arg&& __x); + + iterator + _M_insert_lower_node(_Base_ptr __p, _Link_type __z); + + iterator + _M_insert_equal_lower_node(_Link_type __z); +#else + iterator + _M_insert_(_Base_ptr __x, _Base_ptr __y, + const value_type& __v); + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 233. Insertion hints in associative containers. + iterator + _M_insert_lower(_Base_ptr __y, const value_type& __v); + + iterator + _M_insert_equal_lower(const value_type& __x); +#endif + + _Link_type + _M_copy(_Const_Link_type __x, _Link_type __p); + + void + _M_erase(_Link_type __x); + + iterator + _M_lower_bound(_Link_type __x, _Link_type __y, + const _Key& __k); + + const_iterator + _M_lower_bound(_Const_Link_type __x, _Const_Link_type __y, + const _Key& __k) const; + + iterator + _M_upper_bound(_Link_type __x, _Link_type __y, + const _Key& __k); + + const_iterator + _M_upper_bound(_Const_Link_type __x, _Const_Link_type __y, + const _Key& __k) const; + + public: + // allocation/deallocation + _Rb_tree() { } + + _Rb_tree(const _Compare& __comp, + const allocator_type& __a = allocator_type()) + : _M_impl(__comp, _Node_allocator(__a)) { } + + _Rb_tree(const _Rb_tree& __x) + : _M_impl(__x._M_impl._M_key_compare, + _Alloc_traits::_S_select_on_copy(__x._M_get_Node_allocator())) + { + if (__x._M_root() != 0) + { + _M_root() = _M_copy(__x._M_begin(), _M_end()); + _M_leftmost() = _S_minimum(_M_root()); + _M_rightmost() = _S_maximum(_M_root()); + _M_impl._M_node_count = __x._M_impl._M_node_count; + } + } + +#if __cplusplus >= 201103L + _Rb_tree(const allocator_type& __a) + : _M_impl(_Compare(), _Node_allocator(__a)) + { } + + _Rb_tree(const _Rb_tree& __x, const allocator_type& __a) + : _M_impl(__x._M_impl._M_key_compare, _Node_allocator(__a)) + { + if (__x._M_root() != 0) + { + _M_root() = _M_copy(__x._M_begin(), _M_end()); + _M_leftmost() = _S_minimum(_M_root()); + _M_rightmost() = _S_maximum(_M_root()); + _M_impl._M_node_count = __x._M_impl._M_node_count; + } + } + + _Rb_tree(_Rb_tree&& __x) + : _M_impl(__x._M_impl._M_key_compare, __x._M_get_Node_allocator()) + { + if (__x._M_root() != 0) + _M_move_data(__x, std::true_type()); + } + + _Rb_tree(_Rb_tree&& __x, const allocator_type& __a) + : _Rb_tree(std::move(__x), _Node_allocator(__a)) + { } + + _Rb_tree(_Rb_tree&& __x, _Node_allocator&& __a); +#endif + + ~_Rb_tree() _GLIBCXX_NOEXCEPT + { _M_erase(_M_begin()); } + + _Rb_tree& + operator=(const _Rb_tree& __x); + + // Accessors. + _Compare + key_comp() const + { return _M_impl._M_key_compare; } + + iterator + begin() _GLIBCXX_NOEXCEPT + { + return iterator(static_cast<_Link_type> + (this->_M_impl._M_header._M_left)); + } + + const_iterator + begin() const _GLIBCXX_NOEXCEPT + { + return const_iterator(static_cast<_Const_Link_type> + (this->_M_impl._M_header._M_left)); + } + + iterator + end() _GLIBCXX_NOEXCEPT + { return iterator(static_cast<_Link_type>(&this->_M_impl._M_header)); } + + const_iterator + end() const _GLIBCXX_NOEXCEPT + { + return const_iterator(static_cast<_Const_Link_type> + (&this->_M_impl._M_header)); + } + + reverse_iterator + rbegin() _GLIBCXX_NOEXCEPT + { return reverse_iterator(end()); } + + const_reverse_iterator + rbegin() const _GLIBCXX_NOEXCEPT + { return const_reverse_iterator(end()); } + + reverse_iterator + rend() _GLIBCXX_NOEXCEPT + { return reverse_iterator(begin()); } + + const_reverse_iterator + rend() const _GLIBCXX_NOEXCEPT + { return const_reverse_iterator(begin()); } + + bool + empty() const _GLIBCXX_NOEXCEPT + { return _M_impl._M_node_count == 0; } + + size_type + size() const _GLIBCXX_NOEXCEPT + { return _M_impl._M_node_count; } + + size_type + max_size() const _GLIBCXX_NOEXCEPT + { return _Alloc_traits::max_size(_M_get_Node_allocator()); } + + void +#if __cplusplus >= 201103L + swap(_Rb_tree& __t) noexcept(_Alloc_traits::_S_nothrow_swap()); +#else + swap(_Rb_tree& __t); +#endif + + // Insert/erase. +#if __cplusplus >= 201103L + template + pair + _M_insert_unique(_Arg&& __x); + + template + iterator + _M_insert_equal(_Arg&& __x); + + template + iterator + _M_insert_unique_(const_iterator __position, _Arg&& __x); + + template + iterator + _M_insert_equal_(const_iterator __position, _Arg&& __x); + + template + pair + _M_emplace_unique(_Args&&... __args); + + template + iterator + _M_emplace_equal(_Args&&... __args); + + template + iterator + _M_emplace_hint_unique(const_iterator __pos, _Args&&... __args); + + template + iterator + _M_emplace_hint_equal(const_iterator __pos, _Args&&... __args); +#else + pair + _M_insert_unique(const value_type& __x); + + iterator + _M_insert_equal(const value_type& __x); + + iterator + _M_insert_unique_(const_iterator __position, const value_type& __x); + + iterator + _M_insert_equal_(const_iterator __position, const value_type& __x); +#endif + + template + void + _M_insert_unique(_InputIterator __first, _InputIterator __last); + + template + void + _M_insert_equal(_InputIterator __first, _InputIterator __last); + + private: + void + _M_erase_aux(const_iterator __position); + + void + _M_erase_aux(const_iterator __first, const_iterator __last); + + public: +#if __cplusplus >= 201103L + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR 130. Associative erase should return an iterator. + _GLIBCXX_ABI_TAG_CXX11 + iterator + erase(const_iterator __position) + { + const_iterator __result = __position; + ++__result; + _M_erase_aux(__position); + return __result._M_const_cast(); + } + + // LWG 2059. + _GLIBCXX_ABI_TAG_CXX11 + iterator + erase(iterator __position) + { + iterator __result = __position; + ++__result; + _M_erase_aux(__position); + return __result; + } +#else + void + erase(iterator __position) + { _M_erase_aux(__position); } + + void + erase(const_iterator __position) + { _M_erase_aux(__position); } +#endif + size_type + erase(const key_type& __x); + +#if __cplusplus >= 201103L + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR 130. Associative erase should return an iterator. + _GLIBCXX_ABI_TAG_CXX11 + iterator + erase(const_iterator __first, const_iterator __last) + { + _M_erase_aux(__first, __last); + return __last._M_const_cast(); + } +#else + void + erase(iterator __first, iterator __last) + { _M_erase_aux(__first, __last); } + + void + erase(const_iterator __first, const_iterator __last) + { _M_erase_aux(__first, __last); } +#endif + void + erase(const key_type* __first, const key_type* __last); + + void + clear() _GLIBCXX_NOEXCEPT + { + _M_erase(_M_begin()); + _M_leftmost() = _M_end(); + _M_root() = 0; + _M_rightmost() = _M_end(); + _M_impl._M_node_count = 0; + } + + // Set operations. + iterator + find(const key_type& __k); + + const_iterator + find(const key_type& __k) const; + + size_type + count(const key_type& __k) const; + + iterator + lower_bound(const key_type& __k) + { return _M_lower_bound(_M_begin(), _M_end(), __k); } + + const_iterator + lower_bound(const key_type& __k) const + { return _M_lower_bound(_M_begin(), _M_end(), __k); } + + iterator + upper_bound(const key_type& __k) + { return _M_upper_bound(_M_begin(), _M_end(), __k); } + + const_iterator + upper_bound(const key_type& __k) const + { return _M_upper_bound(_M_begin(), _M_end(), __k); } + + pair + equal_range(const key_type& __k); + + pair + equal_range(const key_type& __k) const; + + // Debugging. + bool + __rb_verify() const; + +#if __cplusplus >= 201103L + bool + _M_move_assign(_Rb_tree&); + + private: + // Move elements from container with equal allocator. + void + _M_move_data(_Rb_tree&, std::true_type); + + // Move elements from container with possibly non-equal allocator, + // which might result in a copy not a move. + void + _M_move_data(_Rb_tree&, std::false_type); +#endif + }; + + template + inline bool + operator==(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x, + const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y) + { + return __x.size() == __y.size() + && std::equal(__x.begin(), __x.end(), __y.begin()); + } + + template + inline bool + operator<(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x, + const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y) + { + return std::lexicographical_compare(__x.begin(), __x.end(), + __y.begin(), __y.end()); + } + + template + inline bool + operator!=(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x, + const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y) + { return !(__x == __y); } + + template + inline bool + operator>(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x, + const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y) + { return __y < __x; } + + template + inline bool + operator<=(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x, + const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y) + { return !(__y < __x); } + + template + inline bool + operator>=(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x, + const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y) + { return !(__x < __y); } + + template + inline void + swap(_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x, + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y) + { __x.swap(__y); } + +#if __cplusplus >= 201103L + template + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + _Rb_tree(_Rb_tree&& __x, _Node_allocator&& __a) + : _M_impl(__x._M_impl._M_key_compare, std::move(__a)) + { + using __eq = integral_constant; + if (__x._M_root() != 0) + _M_move_data(__x, __eq()); + } + + template + void + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + _M_move_data(_Rb_tree& __x, std::true_type) + { + _M_root() = __x._M_root(); + _M_leftmost() = __x._M_leftmost(); + _M_rightmost() = __x._M_rightmost(); + _M_root()->_M_parent = _M_end(); + + __x._M_root() = 0; + __x._M_leftmost() = __x._M_end(); + __x._M_rightmost() = __x._M_end(); + + this->_M_impl._M_node_count = __x._M_impl._M_node_count; + __x._M_impl._M_node_count = 0; + } + + template + void + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + _M_move_data(_Rb_tree& __x, std::false_type) + { + if (_M_get_Node_allocator() == __x._M_get_Node_allocator()) + _M_move_data(__x, std::true_type()); + else + { + _M_root() = _M_copy(__x._M_begin(), _M_end()); + _M_leftmost() = _S_minimum(_M_root()); + _M_rightmost() = _S_maximum(_M_root()); + _M_impl._M_node_count = __x._M_impl._M_node_count; + } + } + + template + bool + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + _M_move_assign(_Rb_tree& __x) + { + _M_impl._M_key_compare = __x._M_impl._M_key_compare; + if (_Alloc_traits::_S_propagate_on_move_assign() + || _Alloc_traits::_S_always_equal() + || _M_get_Node_allocator() == __x._M_get_Node_allocator()) + { + clear(); + if (__x._M_root() != 0) + _M_move_data(__x, std::true_type()); + std::__alloc_on_move(_M_get_Node_allocator(), + __x._M_get_Node_allocator()); + return true; + } + return false; + } +#endif + + template + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + operator=(const _Rb_tree& __x) + { + if (this != &__x) + { + // Note that _Key may be a constant type. + clear(); +#if __cplusplus >= 201103L + if (_Alloc_traits::_S_propagate_on_copy_assign()) + { + auto& __this_alloc = this->_M_get_Node_allocator(); + auto& __that_alloc = __x._M_get_Node_allocator(); + if (!_Alloc_traits::_S_always_equal() + && __this_alloc != __that_alloc) + { + std::__alloc_on_copy(__this_alloc, __that_alloc); + } + } +#endif + _M_impl._M_key_compare = __x._M_impl._M_key_compare; + if (__x._M_root() != 0) + { + _M_root() = _M_copy(__x._M_begin(), _M_end()); + _M_leftmost() = _S_minimum(_M_root()); + _M_rightmost() = _S_maximum(_M_root()); + _M_impl._M_node_count = __x._M_impl._M_node_count; + } + } + return *this; + } + + template +#if __cplusplus >= 201103L + template +#endif + typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: +#if __cplusplus >= 201103L + _M_insert_(_Base_ptr __x, _Base_ptr __p, _Arg&& __v) +#else + _M_insert_(_Base_ptr __x, _Base_ptr __p, const _Val& __v) +#endif + { + bool __insert_left = (__x != 0 || __p == _M_end() + || _M_impl._M_key_compare(_KeyOfValue()(__v), + _S_key(__p))); + + _Link_type __z = _M_create_node(_GLIBCXX_FORWARD(_Arg, __v)); + + _Rb_tree_insert_and_rebalance(__insert_left, __z, __p, + this->_M_impl._M_header); + ++_M_impl._M_node_count; + return iterator(__z); + } + + template +#if __cplusplus >= 201103L + template +#endif + typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: +#if __cplusplus >= 201103L + _M_insert_lower(_Base_ptr __p, _Arg&& __v) +#else + _M_insert_lower(_Base_ptr __p, const _Val& __v) +#endif + { + bool __insert_left = (__p == _M_end() + || !_M_impl._M_key_compare(_S_key(__p), + _KeyOfValue()(__v))); + + _Link_type __z = _M_create_node(_GLIBCXX_FORWARD(_Arg, __v)); + + _Rb_tree_insert_and_rebalance(__insert_left, __z, __p, + this->_M_impl._M_header); + ++_M_impl._M_node_count; + return iterator(__z); + } + + template +#if __cplusplus >= 201103L + template +#endif + typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: +#if __cplusplus >= 201103L + _M_insert_equal_lower(_Arg&& __v) +#else + _M_insert_equal_lower(const _Val& __v) +#endif + { + _Link_type __x = _M_begin(); + _Link_type __y = _M_end(); + while (__x != 0) + { + __y = __x; + __x = !_M_impl._M_key_compare(_S_key(__x), _KeyOfValue()(__v)) ? + _S_left(__x) : _S_right(__x); + } + return _M_insert_lower(__y, _GLIBCXX_FORWARD(_Arg, __v)); + } + + template + typename _Rb_tree<_Key, _Val, _KoV, _Compare, _Alloc>::_Link_type + _Rb_tree<_Key, _Val, _KoV, _Compare, _Alloc>:: + _M_copy(_Const_Link_type __x, _Link_type __p) + { + // Structural copy. __x and __p must be non-null. + _Link_type __top = _M_clone_node(__x); + __top->_M_parent = __p; + + __try + { + if (__x->_M_right) + __top->_M_right = _M_copy(_S_right(__x), __top); + __p = __top; + __x = _S_left(__x); + + while (__x != 0) + { + _Link_type __y = _M_clone_node(__x); + __p->_M_left = __y; + __y->_M_parent = __p; + if (__x->_M_right) + __y->_M_right = _M_copy(_S_right(__x), __y); + __p = __y; + __x = _S_left(__x); + } + } + __catch(...) + { + _M_erase(__top); + __throw_exception_again; + } + return __top; + } + + template + void + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + _M_erase(_Link_type __x) + { + // Erase without rebalancing. + while (__x != 0) + { + _M_erase(_S_right(__x)); + _Link_type __y = _S_left(__x); + _M_destroy_node(__x); + __x = __y; + } + } + + template + typename _Rb_tree<_Key, _Val, _KeyOfValue, + _Compare, _Alloc>::iterator + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + _M_lower_bound(_Link_type __x, _Link_type __y, + const _Key& __k) + { + while (__x != 0) + if (!_M_impl._M_key_compare(_S_key(__x), __k)) + __y = __x, __x = _S_left(__x); + else + __x = _S_right(__x); + return iterator(__y); + } + + template + typename _Rb_tree<_Key, _Val, _KeyOfValue, + _Compare, _Alloc>::const_iterator + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + _M_lower_bound(_Const_Link_type __x, _Const_Link_type __y, + const _Key& __k) const + { + while (__x != 0) + if (!_M_impl._M_key_compare(_S_key(__x), __k)) + __y = __x, __x = _S_left(__x); + else + __x = _S_right(__x); + return const_iterator(__y); + } + + template + typename _Rb_tree<_Key, _Val, _KeyOfValue, + _Compare, _Alloc>::iterator + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + _M_upper_bound(_Link_type __x, _Link_type __y, + const _Key& __k) + { + while (__x != 0) + if (_M_impl._M_key_compare(__k, _S_key(__x))) + __y = __x, __x = _S_left(__x); + else + __x = _S_right(__x); + return iterator(__y); + } + + template + typename _Rb_tree<_Key, _Val, _KeyOfValue, + _Compare, _Alloc>::const_iterator + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + _M_upper_bound(_Const_Link_type __x, _Const_Link_type __y, + const _Key& __k) const + { + while (__x != 0) + if (_M_impl._M_key_compare(__k, _S_key(__x))) + __y = __x, __x = _S_left(__x); + else + __x = _S_right(__x); + return const_iterator(__y); + } + + template + pair::iterator, + typename _Rb_tree<_Key, _Val, _KeyOfValue, + _Compare, _Alloc>::iterator> + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + equal_range(const _Key& __k) + { + _Link_type __x = _M_begin(); + _Link_type __y = _M_end(); + while (__x != 0) + { + if (_M_impl._M_key_compare(_S_key(__x), __k)) + __x = _S_right(__x); + else if (_M_impl._M_key_compare(__k, _S_key(__x))) + __y = __x, __x = _S_left(__x); + else + { + _Link_type __xu(__x), __yu(__y); + __y = __x, __x = _S_left(__x); + __xu = _S_right(__xu); + return pair(_M_lower_bound(__x, __y, __k), + _M_upper_bound(__xu, __yu, __k)); + } + } + return pair(iterator(__y), + iterator(__y)); + } + + template + pair::const_iterator, + typename _Rb_tree<_Key, _Val, _KeyOfValue, + _Compare, _Alloc>::const_iterator> + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + equal_range(const _Key& __k) const + { + _Const_Link_type __x = _M_begin(); + _Const_Link_type __y = _M_end(); + while (__x != 0) + { + if (_M_impl._M_key_compare(_S_key(__x), __k)) + __x = _S_right(__x); + else if (_M_impl._M_key_compare(__k, _S_key(__x))) + __y = __x, __x = _S_left(__x); + else + { + _Const_Link_type __xu(__x), __yu(__y); + __y = __x, __x = _S_left(__x); + __xu = _S_right(__xu); + return pair(_M_lower_bound(__x, __y, __k), + _M_upper_bound(__xu, __yu, __k)); + } + } + return pair(const_iterator(__y), + const_iterator(__y)); + } + + template + void + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + swap(_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __t) +#if __cplusplus >= 201103L + noexcept(_Alloc_traits::_S_nothrow_swap()) +#endif + { + if (_M_root() == 0) + { + if (__t._M_root() != 0) + { + _M_root() = __t._M_root(); + _M_leftmost() = __t._M_leftmost(); + _M_rightmost() = __t._M_rightmost(); + _M_root()->_M_parent = _M_end(); + + __t._M_root() = 0; + __t._M_leftmost() = __t._M_end(); + __t._M_rightmost() = __t._M_end(); + } + } + else if (__t._M_root() == 0) + { + __t._M_root() = _M_root(); + __t._M_leftmost() = _M_leftmost(); + __t._M_rightmost() = _M_rightmost(); + __t._M_root()->_M_parent = __t._M_end(); + + _M_root() = 0; + _M_leftmost() = _M_end(); + _M_rightmost() = _M_end(); + } + else + { + std::swap(_M_root(),__t._M_root()); + std::swap(_M_leftmost(),__t._M_leftmost()); + std::swap(_M_rightmost(),__t._M_rightmost()); + + _M_root()->_M_parent = _M_end(); + __t._M_root()->_M_parent = __t._M_end(); + } + // No need to swap header's color as it does not change. + std::swap(this->_M_impl._M_node_count, __t._M_impl._M_node_count); + std::swap(this->_M_impl._M_key_compare, __t._M_impl._M_key_compare); + + _Alloc_traits::_S_on_swap(_M_get_Node_allocator(), + __t._M_get_Node_allocator()); + } + + template + pair::_Base_ptr, + typename _Rb_tree<_Key, _Val, _KeyOfValue, + _Compare, _Alloc>::_Base_ptr> + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + _M_get_insert_unique_pos(const key_type& __k) + { + typedef pair<_Base_ptr, _Base_ptr> _Res; + _Link_type __x = _M_begin(); + _Link_type __y = _M_end(); + bool __comp = true; + while (__x != 0) + { + __y = __x; + __comp = _M_impl._M_key_compare(__k, _S_key(__x)); + __x = __comp ? _S_left(__x) : _S_right(__x); + } + iterator __j = iterator(__y); + if (__comp) + { + if (__j == begin()) + return _Res(__x, __y); + else + --__j; + } + if (_M_impl._M_key_compare(_S_key(__j._M_node), __k)) + return _Res(__x, __y); + return _Res(__j._M_node, 0); + } + + template + pair::_Base_ptr, + typename _Rb_tree<_Key, _Val, _KeyOfValue, + _Compare, _Alloc>::_Base_ptr> + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + _M_get_insert_equal_pos(const key_type& __k) + { + typedef pair<_Base_ptr, _Base_ptr> _Res; + _Link_type __x = _M_begin(); + _Link_type __y = _M_end(); + while (__x != 0) + { + __y = __x; + __x = _M_impl._M_key_compare(__k, _S_key(__x)) ? + _S_left(__x) : _S_right(__x); + } + return _Res(__x, __y); + } + + template +#if __cplusplus >= 201103L + template +#endif + pair::iterator, bool> + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: +#if __cplusplus >= 201103L + _M_insert_unique(_Arg&& __v) +#else + _M_insert_unique(const _Val& __v) +#endif + { + typedef pair _Res; + pair<_Base_ptr, _Base_ptr> __res + = _M_get_insert_unique_pos(_KeyOfValue()(__v)); + + if (__res.second) + return _Res(_M_insert_(__res.first, __res.second, + _GLIBCXX_FORWARD(_Arg, __v)), + true); + + return _Res(iterator(static_cast<_Link_type>(__res.first)), false); + } + + template +#if __cplusplus >= 201103L + template +#endif + typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: +#if __cplusplus >= 201103L + _M_insert_equal(_Arg&& __v) +#else + _M_insert_equal(const _Val& __v) +#endif + { + pair<_Base_ptr, _Base_ptr> __res + = _M_get_insert_equal_pos(_KeyOfValue()(__v)); + return _M_insert_(__res.first, __res.second, _GLIBCXX_FORWARD(_Arg, __v)); + } + + template + pair::_Base_ptr, + typename _Rb_tree<_Key, _Val, _KeyOfValue, + _Compare, _Alloc>::_Base_ptr> + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + _M_get_insert_hint_unique_pos(const_iterator __position, + const key_type& __k) + { + iterator __pos = __position._M_const_cast(); + typedef pair<_Base_ptr, _Base_ptr> _Res; + + // end() + if (__pos._M_node == _M_end()) + { + if (size() > 0 + && _M_impl._M_key_compare(_S_key(_M_rightmost()), __k)) + return _Res(0, _M_rightmost()); + else + return _M_get_insert_unique_pos(__k); + } + else if (_M_impl._M_key_compare(__k, _S_key(__pos._M_node))) + { + // First, try before... + iterator __before = __pos; + if (__pos._M_node == _M_leftmost()) // begin() + return _Res(_M_leftmost(), _M_leftmost()); + else if (_M_impl._M_key_compare(_S_key((--__before)._M_node), __k)) + { + if (_S_right(__before._M_node) == 0) + return _Res(0, __before._M_node); + else + return _Res(__pos._M_node, __pos._M_node); + } + else + return _M_get_insert_unique_pos(__k); + } + else if (_M_impl._M_key_compare(_S_key(__pos._M_node), __k)) + { + // ... then try after. + iterator __after = __pos; + if (__pos._M_node == _M_rightmost()) + return _Res(0, _M_rightmost()); + else if (_M_impl._M_key_compare(__k, _S_key((++__after)._M_node))) + { + if (_S_right(__pos._M_node) == 0) + return _Res(0, __pos._M_node); + else + return _Res(__after._M_node, __after._M_node); + } + else + return _M_get_insert_unique_pos(__k); + } + else + // Equivalent keys. + return _Res(__pos._M_node, 0); + } + + template +#if __cplusplus >= 201103L + template +#endif + typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: +#if __cplusplus >= 201103L + _M_insert_unique_(const_iterator __position, _Arg&& __v) +#else + _M_insert_unique_(const_iterator __position, const _Val& __v) +#endif + { + pair<_Base_ptr, _Base_ptr> __res + = _M_get_insert_hint_unique_pos(__position, _KeyOfValue()(__v)); + + if (__res.second) + return _M_insert_(__res.first, __res.second, + _GLIBCXX_FORWARD(_Arg, __v)); + return iterator(static_cast<_Link_type>(__res.first)); + } + + template + pair::_Base_ptr, + typename _Rb_tree<_Key, _Val, _KeyOfValue, + _Compare, _Alloc>::_Base_ptr> + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + _M_get_insert_hint_equal_pos(const_iterator __position, const key_type& __k) + { + iterator __pos = __position._M_const_cast(); + typedef pair<_Base_ptr, _Base_ptr> _Res; + + // end() + if (__pos._M_node == _M_end()) + { + if (size() > 0 + && !_M_impl._M_key_compare(__k, _S_key(_M_rightmost()))) + return _Res(0, _M_rightmost()); + else + return _M_get_insert_equal_pos(__k); + } + else if (!_M_impl._M_key_compare(_S_key(__pos._M_node), __k)) + { + // First, try before... + iterator __before = __pos; + if (__pos._M_node == _M_leftmost()) // begin() + return _Res(_M_leftmost(), _M_leftmost()); + else if (!_M_impl._M_key_compare(__k, _S_key((--__before)._M_node))) + { + if (_S_right(__before._M_node) == 0) + return _Res(0, __before._M_node); + else + return _Res(__pos._M_node, __pos._M_node); + } + else + return _M_get_insert_equal_pos(__k); + } + else + { + // ... then try after. + iterator __after = __pos; + if (__pos._M_node == _M_rightmost()) + return _Res(0, _M_rightmost()); + else if (!_M_impl._M_key_compare(_S_key((++__after)._M_node), __k)) + { + if (_S_right(__pos._M_node) == 0) + return _Res(0, __pos._M_node); + else + return _Res(__after._M_node, __after._M_node); + } + else + return _Res(0, 0); + } + } + + template +#if __cplusplus >= 201103L + template +#endif + typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: +#if __cplusplus >= 201103L + _M_insert_equal_(const_iterator __position, _Arg&& __v) +#else + _M_insert_equal_(const_iterator __position, const _Val& __v) +#endif + { + pair<_Base_ptr, _Base_ptr> __res + = _M_get_insert_hint_equal_pos(__position, _KeyOfValue()(__v)); + + if (__res.second) + return _M_insert_(__res.first, __res.second, + _GLIBCXX_FORWARD(_Arg, __v)); + + return _M_insert_equal_lower(_GLIBCXX_FORWARD(_Arg, __v)); + } + +#if __cplusplus >= 201103L + template + typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + _M_insert_node(_Base_ptr __x, _Base_ptr __p, _Link_type __z) + { + bool __insert_left = (__x != 0 || __p == _M_end() + || _M_impl._M_key_compare(_S_key(__z), + _S_key(__p))); + + _Rb_tree_insert_and_rebalance(__insert_left, __z, __p, + this->_M_impl._M_header); + ++_M_impl._M_node_count; + return iterator(__z); + } + + template + typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + _M_insert_lower_node(_Base_ptr __p, _Link_type __z) + { + bool __insert_left = (__p == _M_end() + || !_M_impl._M_key_compare(_S_key(__p), + _S_key(__z))); + + _Rb_tree_insert_and_rebalance(__insert_left, __z, __p, + this->_M_impl._M_header); + ++_M_impl._M_node_count; + return iterator(__z); + } + + template + typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + _M_insert_equal_lower_node(_Link_type __z) + { + _Link_type __x = _M_begin(); + _Link_type __y = _M_end(); + while (__x != 0) + { + __y = __x; + __x = !_M_impl._M_key_compare(_S_key(__x), _S_key(__z)) ? + _S_left(__x) : _S_right(__x); + } + return _M_insert_lower_node(__y, __z); + } + + template + template + pair::iterator, bool> + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + _M_emplace_unique(_Args&&... __args) + { + _Link_type __z = _M_create_node(std::forward<_Args>(__args)...); + + __try + { + typedef pair _Res; + auto __res = _M_get_insert_unique_pos(_S_key(__z)); + if (__res.second) + return _Res(_M_insert_node(__res.first, __res.second, __z), true); + + _M_destroy_node(__z); + return _Res(iterator(static_cast<_Link_type>(__res.first)), false); + } + __catch(...) + { + _M_destroy_node(__z); + __throw_exception_again; + } + } + + template + template + typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + _M_emplace_equal(_Args&&... __args) + { + _Link_type __z = _M_create_node(std::forward<_Args>(__args)...); + + __try + { + auto __res = _M_get_insert_equal_pos(_S_key(__z)); + return _M_insert_node(__res.first, __res.second, __z); + } + __catch(...) + { + _M_destroy_node(__z); + __throw_exception_again; + } + } + + template + template + typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + _M_emplace_hint_unique(const_iterator __pos, _Args&&... __args) + { + _Link_type __z = _M_create_node(std::forward<_Args>(__args)...); + + __try + { + auto __res = _M_get_insert_hint_unique_pos(__pos, _S_key(__z)); + + if (__res.second) + return _M_insert_node(__res.first, __res.second, __z); + + _M_destroy_node(__z); + return iterator(static_cast<_Link_type>(__res.first)); + } + __catch(...) + { + _M_destroy_node(__z); + __throw_exception_again; + } + } + + template + template + typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + _M_emplace_hint_equal(const_iterator __pos, _Args&&... __args) + { + _Link_type __z = _M_create_node(std::forward<_Args>(__args)...); + + __try + { + auto __res = _M_get_insert_hint_equal_pos(__pos, _S_key(__z)); + + if (__res.second) + return _M_insert_node(__res.first, __res.second, __z); + + return _M_insert_equal_lower_node(__z); + } + __catch(...) + { + _M_destroy_node(__z); + __throw_exception_again; + } + } +#endif + + template + template + void + _Rb_tree<_Key, _Val, _KoV, _Cmp, _Alloc>:: + _M_insert_unique(_II __first, _II __last) + { + for (; __first != __last; ++__first) + _M_insert_unique_(end(), *__first); + } + + template + template + void + _Rb_tree<_Key, _Val, _KoV, _Cmp, _Alloc>:: + _M_insert_equal(_II __first, _II __last) + { + for (; __first != __last; ++__first) + _M_insert_equal_(end(), *__first); + } + + template + void + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + _M_erase_aux(const_iterator __position) + { + _Link_type __y = + static_cast<_Link_type>(_Rb_tree_rebalance_for_erase + (const_cast<_Base_ptr>(__position._M_node), + this->_M_impl._M_header)); + _M_destroy_node(__y); + --_M_impl._M_node_count; + } + + template + void + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + _M_erase_aux(const_iterator __first, const_iterator __last) + { + if (__first == begin() && __last == end()) + clear(); + else + while (__first != __last) + erase(__first++); + } + + template + typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::size_type + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + erase(const _Key& __x) + { + pair __p = equal_range(__x); + const size_type __old_size = size(); + erase(__p.first, __p.second); + return __old_size - size(); + } + + template + void + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + erase(const _Key* __first, const _Key* __last) + { + while (__first != __last) + erase(*__first++); + } + + template + typename _Rb_tree<_Key, _Val, _KeyOfValue, + _Compare, _Alloc>::iterator + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + find(const _Key& __k) + { + iterator __j = _M_lower_bound(_M_begin(), _M_end(), __k); + return (__j == end() + || _M_impl._M_key_compare(__k, + _S_key(__j._M_node))) ? end() : __j; + } + + template + typename _Rb_tree<_Key, _Val, _KeyOfValue, + _Compare, _Alloc>::const_iterator + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + find(const _Key& __k) const + { + const_iterator __j = _M_lower_bound(_M_begin(), _M_end(), __k); + return (__j == end() + || _M_impl._M_key_compare(__k, + _S_key(__j._M_node))) ? end() : __j; + } + + template + typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::size_type + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + count(const _Key& __k) const + { + pair __p = equal_range(__k); + const size_type __n = std::distance(__p.first, __p.second); + return __n; + } + + _GLIBCXX_PURE unsigned int + _Rb_tree_black_count(const _Rb_tree_node_base* __node, + const _Rb_tree_node_base* __root) throw (); + + template + bool + _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>::__rb_verify() const + { + if (_M_impl._M_node_count == 0 || begin() == end()) + return _M_impl._M_node_count == 0 && begin() == end() + && this->_M_impl._M_header._M_left == _M_end() + && this->_M_impl._M_header._M_right == _M_end(); + + unsigned int __len = _Rb_tree_black_count(_M_leftmost(), _M_root()); + for (const_iterator __it = begin(); __it != end(); ++__it) + { + _Const_Link_type __x = static_cast<_Const_Link_type>(__it._M_node); + _Const_Link_type __L = _S_left(__x); + _Const_Link_type __R = _S_right(__x); + + if (__x->_M_color == _S_red) + if ((__L && __L->_M_color == _S_red) + || (__R && __R->_M_color == _S_red)) + return false; + + if (__L && _M_impl._M_key_compare(_S_key(__x), _S_key(__L))) + return false; + if (__R && _M_impl._M_key_compare(_S_key(__R), _S_key(__x))) + return false; + + if (!__L && !__R && _Rb_tree_black_count(__x, _M_root()) != __len) + return false; + } + + if (_M_leftmost() != _Rb_tree_node_base::_S_minimum(_M_root())) + return false; + if (_M_rightmost() != _Rb_tree_node_base::_S_maximum(_M_root())) + return false; + return true; + } + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stl_uninitialized.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stl_uninitialized.h new file mode 100755 index 0000000..42b4026 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stl_uninitialized.h @@ -0,0 +1,683 @@ +// Raw memory manipulators -*- C++ -*- + +// Copyright (C) 2001-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/* + * + * Copyright (c) 1994 + * Hewlett-Packard Company + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Hewlett-Packard Company makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + * + * + * Copyright (c) 1996,1997 + * Silicon Graphics Computer Systems, Inc. + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Silicon Graphics makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + */ + +/** @file bits/stl_uninitialized.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{memory} + */ + +#ifndef _STL_UNINITIALIZED_H +#define _STL_UNINITIALIZED_H 1 + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + template + struct __uninitialized_copy + { + template + static _ForwardIterator + __uninit_copy(_InputIterator __first, _InputIterator __last, + _ForwardIterator __result) + { + _ForwardIterator __cur = __result; + __try + { + for (; __first != __last; ++__first, ++__cur) + std::_Construct(std::__addressof(*__cur), *__first); + return __cur; + } + __catch(...) + { + std::_Destroy(__result, __cur); + __throw_exception_again; + } + } + }; + + template<> + struct __uninitialized_copy + { + template + static _ForwardIterator + __uninit_copy(_InputIterator __first, _InputIterator __last, + _ForwardIterator __result) + { return std::copy(__first, __last, __result); } + }; + + /** + * @brief Copies the range [first,last) into result. + * @param __first An input iterator. + * @param __last An input iterator. + * @param __result An output iterator. + * @return __result + (__first - __last) + * + * Like copy(), but does not require an initialized output range. + */ + template + inline _ForwardIterator + uninitialized_copy(_InputIterator __first, _InputIterator __last, + _ForwardIterator __result) + { + typedef typename iterator_traits<_InputIterator>::value_type + _ValueType1; + typedef typename iterator_traits<_ForwardIterator>::value_type + _ValueType2; +#if __cplusplus < 201103L + const bool __assignable = true; +#else + // trivial types can have deleted assignment + typedef typename iterator_traits<_InputIterator>::reference _RefType1; + typedef typename iterator_traits<_ForwardIterator>::reference _RefType2; + const bool __assignable = is_assignable<_RefType2, _RefType1>::value; +#endif + + return std::__uninitialized_copy<__is_trivial(_ValueType1) + && __is_trivial(_ValueType2) + && __assignable>:: + __uninit_copy(__first, __last, __result); + } + + + template + struct __uninitialized_fill + { + template + static void + __uninit_fill(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __x) + { + _ForwardIterator __cur = __first; + __try + { + for (; __cur != __last; ++__cur) + std::_Construct(std::__addressof(*__cur), __x); + } + __catch(...) + { + std::_Destroy(__first, __cur); + __throw_exception_again; + } + } + }; + + template<> + struct __uninitialized_fill + { + template + static void + __uninit_fill(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __x) + { std::fill(__first, __last, __x); } + }; + + /** + * @brief Copies the value x into the range [first,last). + * @param __first An input iterator. + * @param __last An input iterator. + * @param __x The source value. + * @return Nothing. + * + * Like fill(), but does not require an initialized output range. + */ + template + inline void + uninitialized_fill(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __x) + { + typedef typename iterator_traits<_ForwardIterator>::value_type + _ValueType; +#if __cplusplus < 201103L + const bool __assignable = true; +#else + // trivial types can have deleted assignment + const bool __assignable = is_copy_assignable<_ValueType>::value; +#endif + + std::__uninitialized_fill<__is_trivial(_ValueType) && __assignable>:: + __uninit_fill(__first, __last, __x); + } + + + template + struct __uninitialized_fill_n + { + template + static void + __uninit_fill_n(_ForwardIterator __first, _Size __n, + const _Tp& __x) + { + _ForwardIterator __cur = __first; + __try + { + for (; __n > 0; --__n, ++__cur) + std::_Construct(std::__addressof(*__cur), __x); + } + __catch(...) + { + std::_Destroy(__first, __cur); + __throw_exception_again; + } + } + }; + + template<> + struct __uninitialized_fill_n + { + template + static void + __uninit_fill_n(_ForwardIterator __first, _Size __n, + const _Tp& __x) + { std::fill_n(__first, __n, __x); } + }; + + /** + * @brief Copies the value x into the range [first,first+n). + * @param __first An input iterator. + * @param __n The number of copies to make. + * @param __x The source value. + * @return Nothing. + * + * Like fill_n(), but does not require an initialized output range. + */ + template + inline void + uninitialized_fill_n(_ForwardIterator __first, _Size __n, const _Tp& __x) + { + typedef typename iterator_traits<_ForwardIterator>::value_type + _ValueType; +#if __cplusplus < 201103L + const bool __assignable = true; +#else + // trivial types can have deleted assignment + const bool __assignable = is_copy_assignable<_ValueType>::value; +#endif + + std::__uninitialized_fill_n<__is_trivial(_ValueType) && __assignable>:: + __uninit_fill_n(__first, __n, __x); + } + + // Extensions: versions of uninitialized_copy, uninitialized_fill, + // and uninitialized_fill_n that take an allocator parameter. + // We dispatch back to the standard versions when we're given the + // default allocator. For nondefault allocators we do not use + // any of the POD optimizations. + + template + _ForwardIterator + __uninitialized_copy_a(_InputIterator __first, _InputIterator __last, + _ForwardIterator __result, _Allocator& __alloc) + { + _ForwardIterator __cur = __result; + __try + { + typedef __gnu_cxx::__alloc_traits<_Allocator> __traits; + for (; __first != __last; ++__first, ++__cur) + __traits::construct(__alloc, std::__addressof(*__cur), *__first); + return __cur; + } + __catch(...) + { + std::_Destroy(__result, __cur, __alloc); + __throw_exception_again; + } + } + + template + inline _ForwardIterator + __uninitialized_copy_a(_InputIterator __first, _InputIterator __last, + _ForwardIterator __result, allocator<_Tp>&) + { return std::uninitialized_copy(__first, __last, __result); } + + template + inline _ForwardIterator + __uninitialized_move_a(_InputIterator __first, _InputIterator __last, + _ForwardIterator __result, _Allocator& __alloc) + { + return std::__uninitialized_copy_a(_GLIBCXX_MAKE_MOVE_ITERATOR(__first), + _GLIBCXX_MAKE_MOVE_ITERATOR(__last), + __result, __alloc); + } + + template + inline _ForwardIterator + __uninitialized_move_if_noexcept_a(_InputIterator __first, + _InputIterator __last, + _ForwardIterator __result, + _Allocator& __alloc) + { + return std::__uninitialized_copy_a + (_GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(__first), + _GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(__last), __result, __alloc); + } + + template + void + __uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __x, _Allocator& __alloc) + { + _ForwardIterator __cur = __first; + __try + { + typedef __gnu_cxx::__alloc_traits<_Allocator> __traits; + for (; __cur != __last; ++__cur) + __traits::construct(__alloc, std::__addressof(*__cur), __x); + } + __catch(...) + { + std::_Destroy(__first, __cur, __alloc); + __throw_exception_again; + } + } + + template + inline void + __uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __x, allocator<_Tp2>&) + { std::uninitialized_fill(__first, __last, __x); } + + template + void + __uninitialized_fill_n_a(_ForwardIterator __first, _Size __n, + const _Tp& __x, _Allocator& __alloc) + { + _ForwardIterator __cur = __first; + __try + { + typedef __gnu_cxx::__alloc_traits<_Allocator> __traits; + for (; __n > 0; --__n, ++__cur) + __traits::construct(__alloc, std::__addressof(*__cur), __x); + } + __catch(...) + { + std::_Destroy(__first, __cur, __alloc); + __throw_exception_again; + } + } + + template + inline void + __uninitialized_fill_n_a(_ForwardIterator __first, _Size __n, + const _Tp& __x, allocator<_Tp2>&) + { std::uninitialized_fill_n(__first, __n, __x); } + + + // Extensions: __uninitialized_copy_move, __uninitialized_move_copy, + // __uninitialized_fill_move, __uninitialized_move_fill. + // All of these algorithms take a user-supplied allocator, which is used + // for construction and destruction. + + // __uninitialized_copy_move + // Copies [first1, last1) into [result, result + (last1 - first1)), and + // move [first2, last2) into + // [result, result + (last1 - first1) + (last2 - first2)). + template + inline _ForwardIterator + __uninitialized_copy_move(_InputIterator1 __first1, + _InputIterator1 __last1, + _InputIterator2 __first2, + _InputIterator2 __last2, + _ForwardIterator __result, + _Allocator& __alloc) + { + _ForwardIterator __mid = std::__uninitialized_copy_a(__first1, __last1, + __result, + __alloc); + __try + { + return std::__uninitialized_move_a(__first2, __last2, __mid, __alloc); + } + __catch(...) + { + std::_Destroy(__result, __mid, __alloc); + __throw_exception_again; + } + } + + // __uninitialized_move_copy + // Moves [first1, last1) into [result, result + (last1 - first1)), and + // copies [first2, last2) into + // [result, result + (last1 - first1) + (last2 - first2)). + template + inline _ForwardIterator + __uninitialized_move_copy(_InputIterator1 __first1, + _InputIterator1 __last1, + _InputIterator2 __first2, + _InputIterator2 __last2, + _ForwardIterator __result, + _Allocator& __alloc) + { + _ForwardIterator __mid = std::__uninitialized_move_a(__first1, __last1, + __result, + __alloc); + __try + { + return std::__uninitialized_copy_a(__first2, __last2, __mid, __alloc); + } + __catch(...) + { + std::_Destroy(__result, __mid, __alloc); + __throw_exception_again; + } + } + + // __uninitialized_fill_move + // Fills [result, mid) with x, and moves [first, last) into + // [mid, mid + (last - first)). + template + inline _ForwardIterator + __uninitialized_fill_move(_ForwardIterator __result, _ForwardIterator __mid, + const _Tp& __x, _InputIterator __first, + _InputIterator __last, _Allocator& __alloc) + { + std::__uninitialized_fill_a(__result, __mid, __x, __alloc); + __try + { + return std::__uninitialized_move_a(__first, __last, __mid, __alloc); + } + __catch(...) + { + std::_Destroy(__result, __mid, __alloc); + __throw_exception_again; + } + } + + // __uninitialized_move_fill + // Moves [first1, last1) into [first2, first2 + (last1 - first1)), and + // fills [first2 + (last1 - first1), last2) with x. + template + inline void + __uninitialized_move_fill(_InputIterator __first1, _InputIterator __last1, + _ForwardIterator __first2, + _ForwardIterator __last2, const _Tp& __x, + _Allocator& __alloc) + { + _ForwardIterator __mid2 = std::__uninitialized_move_a(__first1, __last1, + __first2, + __alloc); + __try + { + std::__uninitialized_fill_a(__mid2, __last2, __x, __alloc); + } + __catch(...) + { + std::_Destroy(__first2, __mid2, __alloc); + __throw_exception_again; + } + } + +#if __cplusplus >= 201103L + // Extensions: __uninitialized_default, __uninitialized_default_n, + // __uninitialized_default_a, __uninitialized_default_n_a. + + template + struct __uninitialized_default_1 + { + template + static void + __uninit_default(_ForwardIterator __first, _ForwardIterator __last) + { + _ForwardIterator __cur = __first; + __try + { + for (; __cur != __last; ++__cur) + std::_Construct(std::__addressof(*__cur)); + } + __catch(...) + { + std::_Destroy(__first, __cur); + __throw_exception_again; + } + } + }; + + template<> + struct __uninitialized_default_1 + { + template + static void + __uninit_default(_ForwardIterator __first, _ForwardIterator __last) + { + typedef typename iterator_traits<_ForwardIterator>::value_type + _ValueType; + + std::fill(__first, __last, _ValueType()); + } + }; + + template + struct __uninitialized_default_n_1 + { + template + static void + __uninit_default_n(_ForwardIterator __first, _Size __n) + { + _ForwardIterator __cur = __first; + __try + { + for (; __n > 0; --__n, ++__cur) + std::_Construct(std::__addressof(*__cur)); + } + __catch(...) + { + std::_Destroy(__first, __cur); + __throw_exception_again; + } + } + }; + + template<> + struct __uninitialized_default_n_1 + { + template + static void + __uninit_default_n(_ForwardIterator __first, _Size __n) + { + typedef typename iterator_traits<_ForwardIterator>::value_type + _ValueType; + + std::fill_n(__first, __n, _ValueType()); + } + }; + + // __uninitialized_default + // Fills [first, last) with std::distance(first, last) default + // constructed value_types(s). + template + inline void + __uninitialized_default(_ForwardIterator __first, + _ForwardIterator __last) + { + typedef typename iterator_traits<_ForwardIterator>::value_type + _ValueType; + // trivial types can have deleted assignment + const bool __assignable = is_copy_assignable<_ValueType>::value; + + std::__uninitialized_default_1<__is_trivial(_ValueType) + && __assignable>:: + __uninit_default(__first, __last); + } + + // __uninitialized_default_n + // Fills [first, first + n) with n default constructed value_type(s). + template + inline void + __uninitialized_default_n(_ForwardIterator __first, _Size __n) + { + typedef typename iterator_traits<_ForwardIterator>::value_type + _ValueType; + // trivial types can have deleted assignment + const bool __assignable = is_copy_assignable<_ValueType>::value; + + std::__uninitialized_default_n_1<__is_trivial(_ValueType) + && __assignable>:: + __uninit_default_n(__first, __n); + } + + + // __uninitialized_default_a + // Fills [first, last) with std::distance(first, last) default + // constructed value_types(s), constructed with the allocator alloc. + template + void + __uninitialized_default_a(_ForwardIterator __first, + _ForwardIterator __last, + _Allocator& __alloc) + { + _ForwardIterator __cur = __first; + __try + { + typedef __gnu_cxx::__alloc_traits<_Allocator> __traits; + for (; __cur != __last; ++__cur) + __traits::construct(__alloc, std::__addressof(*__cur)); + } + __catch(...) + { + std::_Destroy(__first, __cur, __alloc); + __throw_exception_again; + } + } + + template + inline void + __uninitialized_default_a(_ForwardIterator __first, + _ForwardIterator __last, + allocator<_Tp>&) + { std::__uninitialized_default(__first, __last); } + + + // __uninitialized_default_n_a + // Fills [first, first + n) with n default constructed value_types(s), + // constructed with the allocator alloc. + template + void + __uninitialized_default_n_a(_ForwardIterator __first, _Size __n, + _Allocator& __alloc) + { + _ForwardIterator __cur = __first; + __try + { + typedef __gnu_cxx::__alloc_traits<_Allocator> __traits; + for (; __n > 0; --__n, ++__cur) + __traits::construct(__alloc, std::__addressof(*__cur)); + } + __catch(...) + { + std::_Destroy(__first, __cur, __alloc); + __throw_exception_again; + } + } + + template + inline void + __uninitialized_default_n_a(_ForwardIterator __first, _Size __n, + allocator<_Tp>&) + { std::__uninitialized_default_n(__first, __n); } + + + template + _ForwardIterator + __uninitialized_copy_n(_InputIterator __first, _Size __n, + _ForwardIterator __result, input_iterator_tag) + { + _ForwardIterator __cur = __result; + __try + { + for (; __n > 0; --__n, ++__first, ++__cur) + std::_Construct(std::__addressof(*__cur), *__first); + return __cur; + } + __catch(...) + { + std::_Destroy(__result, __cur); + __throw_exception_again; + } + } + + template + inline _ForwardIterator + __uninitialized_copy_n(_RandomAccessIterator __first, _Size __n, + _ForwardIterator __result, + random_access_iterator_tag) + { return std::uninitialized_copy(__first, __first + __n, __result); } + + /** + * @brief Copies the range [first,first+n) into result. + * @param __first An input iterator. + * @param __n The number of elements to copy. + * @param __result An output iterator. + * @return __result + __n + * + * Like copy_n(), but does not require an initialized output range. + */ + template + inline _ForwardIterator + uninitialized_copy_n(_InputIterator __first, _Size __n, + _ForwardIterator __result) + { return std::__uninitialized_copy_n(__first, __n, __result, + std::__iterator_category(__first)); } +#endif + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif /* _STL_UNINITIALIZED_H */ diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stl_vector.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stl_vector.h new file mode 100755 index 0000000..c33e2c6 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stl_vector.h @@ -0,0 +1,1565 @@ +// Vector implementation -*- C++ -*- + +// Copyright (C) 2001-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/* + * + * Copyright (c) 1994 + * Hewlett-Packard Company + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Hewlett-Packard Company makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + * + * + * Copyright (c) 1996 + * Silicon Graphics Computer Systems, Inc. + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Silicon Graphics makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + */ + +/** @file bits/stl_vector.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{vector} + */ + +#ifndef _STL_VECTOR_H +#define _STL_VECTOR_H 1 + +#include +#include +#include +#if __cplusplus >= 201103L +#include +#endif + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_CONTAINER + + /// See bits/stl_deque.h's _Deque_base for an explanation. + template + struct _Vector_base + { + typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template + rebind<_Tp>::other _Tp_alloc_type; + typedef typename __gnu_cxx::__alloc_traits<_Tp_alloc_type>::pointer + pointer; + + struct _Vector_impl + : public _Tp_alloc_type + { + pointer _M_start; + pointer _M_finish; + pointer _M_end_of_storage; + + _Vector_impl() + : _Tp_alloc_type(), _M_start(0), _M_finish(0), _M_end_of_storage(0) + { } + + _Vector_impl(_Tp_alloc_type const& __a) _GLIBCXX_NOEXCEPT + : _Tp_alloc_type(__a), _M_start(0), _M_finish(0), _M_end_of_storage(0) + { } + +#if __cplusplus >= 201103L + _Vector_impl(_Tp_alloc_type&& __a) noexcept + : _Tp_alloc_type(std::move(__a)), + _M_start(0), _M_finish(0), _M_end_of_storage(0) + { } +#endif + + void _M_swap_data(_Vector_impl& __x) _GLIBCXX_NOEXCEPT + { + std::swap(_M_start, __x._M_start); + std::swap(_M_finish, __x._M_finish); + std::swap(_M_end_of_storage, __x._M_end_of_storage); + } + }; + + public: + typedef _Alloc allocator_type; + + _Tp_alloc_type& + _M_get_Tp_allocator() _GLIBCXX_NOEXCEPT + { return *static_cast<_Tp_alloc_type*>(&this->_M_impl); } + + const _Tp_alloc_type& + _M_get_Tp_allocator() const _GLIBCXX_NOEXCEPT + { return *static_cast(&this->_M_impl); } + + allocator_type + get_allocator() const _GLIBCXX_NOEXCEPT + { return allocator_type(_M_get_Tp_allocator()); } + + _Vector_base() + : _M_impl() { } + + _Vector_base(const allocator_type& __a) _GLIBCXX_NOEXCEPT + : _M_impl(__a) { } + + _Vector_base(size_t __n) + : _M_impl() + { _M_create_storage(__n); } + + _Vector_base(size_t __n, const allocator_type& __a) + : _M_impl(__a) + { _M_create_storage(__n); } + +#if __cplusplus >= 201103L + _Vector_base(_Tp_alloc_type&& __a) noexcept + : _M_impl(std::move(__a)) { } + + _Vector_base(_Vector_base&& __x) noexcept + : _M_impl(std::move(__x._M_get_Tp_allocator())) + { this->_M_impl._M_swap_data(__x._M_impl); } + + _Vector_base(_Vector_base&& __x, const allocator_type& __a) + : _M_impl(__a) + { + if (__x.get_allocator() == __a) + this->_M_impl._M_swap_data(__x._M_impl); + else + { + size_t __n = __x._M_impl._M_finish - __x._M_impl._M_start; + _M_create_storage(__n); + } + } +#endif + + ~_Vector_base() _GLIBCXX_NOEXCEPT + { _M_deallocate(this->_M_impl._M_start, this->_M_impl._M_end_of_storage + - this->_M_impl._M_start); } + + public: + _Vector_impl _M_impl; + + pointer + _M_allocate(size_t __n) + { + typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Tr; + return __n != 0 ? _Tr::allocate(_M_impl, __n) : 0; + } + + void + _M_deallocate(pointer __p, size_t __n) + { + typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Tr; + if (__p) + _Tr::deallocate(_M_impl, __p, __n); + } + + private: + void + _M_create_storage(size_t __n) + { + this->_M_impl._M_start = this->_M_allocate(__n); + this->_M_impl._M_finish = this->_M_impl._M_start; + this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n; + } + }; + + + /** + * @brief A standard container which offers fixed time access to + * individual elements in any order. + * + * @ingroup sequences + * + * @tparam _Tp Type of element. + * @tparam _Alloc Allocator type, defaults to allocator<_Tp>. + * + * Meets the requirements of a container, a + * reversible container, and a + * sequence, including the + * optional sequence requirements with the + * %exception of @c push_front and @c pop_front. + * + * In some terminology a %vector can be described as a dynamic + * C-style array, it offers fast and efficient access to individual + * elements in any order and saves the user from worrying about + * memory and size allocation. Subscripting ( @c [] ) access is + * also provided as with C-style arrays. + */ + template > + class vector : protected _Vector_base<_Tp, _Alloc> + { + // Concept requirements. + typedef typename _Alloc::value_type _Alloc_value_type; + __glibcxx_class_requires(_Tp, _SGIAssignableConcept) + __glibcxx_class_requires2(_Tp, _Alloc_value_type, _SameTypeConcept) + + typedef _Vector_base<_Tp, _Alloc> _Base; + typedef typename _Base::_Tp_alloc_type _Tp_alloc_type; + typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Alloc_traits; + + public: + typedef _Tp value_type; + typedef typename _Base::pointer pointer; + typedef typename _Alloc_traits::const_pointer const_pointer; + typedef typename _Alloc_traits::reference reference; + typedef typename _Alloc_traits::const_reference const_reference; + typedef __gnu_cxx::__normal_iterator iterator; + typedef __gnu_cxx::__normal_iterator + const_iterator; + typedef std::reverse_iterator const_reverse_iterator; + typedef std::reverse_iterator reverse_iterator; + typedef size_t size_type; + typedef ptrdiff_t difference_type; + typedef _Alloc allocator_type; + + protected: + using _Base::_M_allocate; + using _Base::_M_deallocate; + using _Base::_M_impl; + using _Base::_M_get_Tp_allocator; + + public: + // [23.2.4.1] construct/copy/destroy + // (assign() and get_allocator() are also listed in this section) + + /** + * @brief Creates a %vector with no elements. + */ + vector() +#if __cplusplus >= 201103L + noexcept(is_nothrow_default_constructible<_Alloc>::value) +#endif + : _Base() { } + + /** + * @brief Creates a %vector with no elements. + * @param __a An allocator object. + */ + explicit + vector(const allocator_type& __a) _GLIBCXX_NOEXCEPT + : _Base(__a) { } + +#if __cplusplus >= 201103L + /** + * @brief Creates a %vector with default constructed elements. + * @param __n The number of elements to initially create. + * @param __a An allocator. + * + * This constructor fills the %vector with @a __n default + * constructed elements. + */ + explicit + vector(size_type __n, const allocator_type& __a = allocator_type()) + : _Base(__n, __a) + { _M_default_initialize(__n); } + + /** + * @brief Creates a %vector with copies of an exemplar element. + * @param __n The number of elements to initially create. + * @param __value An element to copy. + * @param __a An allocator. + * + * This constructor fills the %vector with @a __n copies of @a __value. + */ + vector(size_type __n, const value_type& __value, + const allocator_type& __a = allocator_type()) + : _Base(__n, __a) + { _M_fill_initialize(__n, __value); } +#else + /** + * @brief Creates a %vector with copies of an exemplar element. + * @param __n The number of elements to initially create. + * @param __value An element to copy. + * @param __a An allocator. + * + * This constructor fills the %vector with @a __n copies of @a __value. + */ + explicit + vector(size_type __n, const value_type& __value = value_type(), + const allocator_type& __a = allocator_type()) + : _Base(__n, __a) + { _M_fill_initialize(__n, __value); } +#endif + + /** + * @brief %Vector copy constructor. + * @param __x A %vector of identical element and allocator types. + * + * The newly-created %vector uses a copy of the allocation + * object used by @a __x. All the elements of @a __x are copied, + * but any extra memory in + * @a __x (for fast expansion) will not be copied. + */ + vector(const vector& __x) + : _Base(__x.size(), + _Alloc_traits::_S_select_on_copy(__x._M_get_Tp_allocator())) + { this->_M_impl._M_finish = + std::__uninitialized_copy_a(__x.begin(), __x.end(), + this->_M_impl._M_start, + _M_get_Tp_allocator()); + } + +#if __cplusplus >= 201103L + /** + * @brief %Vector move constructor. + * @param __x A %vector of identical element and allocator types. + * + * The newly-created %vector contains the exact contents of @a __x. + * The contents of @a __x are a valid, but unspecified %vector. + */ + vector(vector&& __x) noexcept + : _Base(std::move(__x)) { } + + /// Copy constructor with alternative allocator + vector(const vector& __x, const allocator_type& __a) + : _Base(__x.size(), __a) + { this->_M_impl._M_finish = + std::__uninitialized_copy_a(__x.begin(), __x.end(), + this->_M_impl._M_start, + _M_get_Tp_allocator()); + } + + /// Move constructor with alternative allocator + vector(vector&& __rv, const allocator_type& __m) + noexcept(_Alloc_traits::_S_always_equal()) + : _Base(std::move(__rv), __m) + { + if (__rv.get_allocator() != __m) + { + this->_M_impl._M_finish = + std::__uninitialized_move_a(__rv.begin(), __rv.end(), + this->_M_impl._M_start, + _M_get_Tp_allocator()); + __rv.clear(); + } + } + + /** + * @brief Builds a %vector from an initializer list. + * @param __l An initializer_list. + * @param __a An allocator. + * + * Create a %vector consisting of copies of the elements in the + * initializer_list @a __l. + * + * This will call the element type's copy constructor N times + * (where N is @a __l.size()) and do no memory reallocation. + */ + vector(initializer_list __l, + const allocator_type& __a = allocator_type()) + : _Base(__a) + { + _M_range_initialize(__l.begin(), __l.end(), + random_access_iterator_tag()); + } +#endif + + /** + * @brief Builds a %vector from a range. + * @param __first An input iterator. + * @param __last An input iterator. + * @param __a An allocator. + * + * Create a %vector consisting of copies of the elements from + * [first,last). + * + * If the iterators are forward, bidirectional, or + * random-access, then this will call the elements' copy + * constructor N times (where N is distance(first,last)) and do + * no memory reallocation. But if only input iterators are + * used, then this will do at most 2N calls to the copy + * constructor, and logN memory reallocations. + */ +#if __cplusplus >= 201103L + template> + vector(_InputIterator __first, _InputIterator __last, + const allocator_type& __a = allocator_type()) + : _Base(__a) + { _M_initialize_dispatch(__first, __last, __false_type()); } +#else + template + vector(_InputIterator __first, _InputIterator __last, + const allocator_type& __a = allocator_type()) + : _Base(__a) + { + // Check whether it's an integral type. If so, it's not an iterator. + typedef typename std::__is_integer<_InputIterator>::__type _Integral; + _M_initialize_dispatch(__first, __last, _Integral()); + } +#endif + + /** + * The dtor only erases the elements, and note that if the + * elements themselves are pointers, the pointed-to memory is + * not touched in any way. Managing the pointer is the user's + * responsibility. + */ + ~vector() _GLIBCXX_NOEXCEPT + { std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish, + _M_get_Tp_allocator()); } + + /** + * @brief %Vector assignment operator. + * @param __x A %vector of identical element and allocator types. + * + * All the elements of @a __x are copied, but any extra memory in + * @a __x (for fast expansion) will not be copied. Unlike the + * copy constructor, the allocator object is not copied. + */ + vector& + operator=(const vector& __x); + +#if __cplusplus >= 201103L + /** + * @brief %Vector move assignment operator. + * @param __x A %vector of identical element and allocator types. + * + * The contents of @a __x are moved into this %vector (without copying, + * if the allocators permit it). + * @a __x is a valid, but unspecified %vector. + */ + vector& + operator=(vector&& __x) noexcept(_Alloc_traits::_S_nothrow_move()) + { + constexpr bool __move_storage = + _Alloc_traits::_S_propagate_on_move_assign() + || _Alloc_traits::_S_always_equal(); + _M_move_assign(std::move(__x), + integral_constant()); + return *this; + } + + /** + * @brief %Vector list assignment operator. + * @param __l An initializer_list. + * + * This function fills a %vector with copies of the elements in the + * initializer list @a __l. + * + * Note that the assignment completely changes the %vector and + * that the resulting %vector's size is the same as the number + * of elements assigned. Old data may be lost. + */ + vector& + operator=(initializer_list __l) + { + this->assign(__l.begin(), __l.end()); + return *this; + } +#endif + + /** + * @brief Assigns a given value to a %vector. + * @param __n Number of elements to be assigned. + * @param __val Value to be assigned. + * + * This function fills a %vector with @a __n copies of the given + * value. Note that the assignment completely changes the + * %vector and that the resulting %vector's size is the same as + * the number of elements assigned. Old data may be lost. + */ + void + assign(size_type __n, const value_type& __val) + { _M_fill_assign(__n, __val); } + + /** + * @brief Assigns a range to a %vector. + * @param __first An input iterator. + * @param __last An input iterator. + * + * This function fills a %vector with copies of the elements in the + * range [__first,__last). + * + * Note that the assignment completely changes the %vector and + * that the resulting %vector's size is the same as the number + * of elements assigned. Old data may be lost. + */ +#if __cplusplus >= 201103L + template> + void + assign(_InputIterator __first, _InputIterator __last) + { _M_assign_dispatch(__first, __last, __false_type()); } +#else + template + void + assign(_InputIterator __first, _InputIterator __last) + { + // Check whether it's an integral type. If so, it's not an iterator. + typedef typename std::__is_integer<_InputIterator>::__type _Integral; + _M_assign_dispatch(__first, __last, _Integral()); + } +#endif + +#if __cplusplus >= 201103L + /** + * @brief Assigns an initializer list to a %vector. + * @param __l An initializer_list. + * + * This function fills a %vector with copies of the elements in the + * initializer list @a __l. + * + * Note that the assignment completely changes the %vector and + * that the resulting %vector's size is the same as the number + * of elements assigned. Old data may be lost. + */ + void + assign(initializer_list __l) + { this->assign(__l.begin(), __l.end()); } +#endif + + /// Get a copy of the memory allocation object. + using _Base::get_allocator; + + // iterators + /** + * Returns a read/write iterator that points to the first + * element in the %vector. Iteration is done in ordinary + * element order. + */ + iterator + begin() _GLIBCXX_NOEXCEPT + { return iterator(this->_M_impl._M_start); } + + /** + * Returns a read-only (constant) iterator that points to the + * first element in the %vector. Iteration is done in ordinary + * element order. + */ + const_iterator + begin() const _GLIBCXX_NOEXCEPT + { return const_iterator(this->_M_impl._M_start); } + + /** + * Returns a read/write iterator that points one past the last + * element in the %vector. Iteration is done in ordinary + * element order. + */ + iterator + end() _GLIBCXX_NOEXCEPT + { return iterator(this->_M_impl._M_finish); } + + /** + * Returns a read-only (constant) iterator that points one past + * the last element in the %vector. Iteration is done in + * ordinary element order. + */ + const_iterator + end() const _GLIBCXX_NOEXCEPT + { return const_iterator(this->_M_impl._M_finish); } + + /** + * Returns a read/write reverse iterator that points to the + * last element in the %vector. Iteration is done in reverse + * element order. + */ + reverse_iterator + rbegin() _GLIBCXX_NOEXCEPT + { return reverse_iterator(end()); } + + /** + * Returns a read-only (constant) reverse iterator that points + * to the last element in the %vector. Iteration is done in + * reverse element order. + */ + const_reverse_iterator + rbegin() const _GLIBCXX_NOEXCEPT + { return const_reverse_iterator(end()); } + + /** + * Returns a read/write reverse iterator that points to one + * before the first element in the %vector. Iteration is done + * in reverse element order. + */ + reverse_iterator + rend() _GLIBCXX_NOEXCEPT + { return reverse_iterator(begin()); } + + /** + * Returns a read-only (constant) reverse iterator that points + * to one before the first element in the %vector. Iteration + * is done in reverse element order. + */ + const_reverse_iterator + rend() const _GLIBCXX_NOEXCEPT + { return const_reverse_iterator(begin()); } + +#if __cplusplus >= 201103L + /** + * Returns a read-only (constant) iterator that points to the + * first element in the %vector. Iteration is done in ordinary + * element order. + */ + const_iterator + cbegin() const noexcept + { return const_iterator(this->_M_impl._M_start); } + + /** + * Returns a read-only (constant) iterator that points one past + * the last element in the %vector. Iteration is done in + * ordinary element order. + */ + const_iterator + cend() const noexcept + { return const_iterator(this->_M_impl._M_finish); } + + /** + * Returns a read-only (constant) reverse iterator that points + * to the last element in the %vector. Iteration is done in + * reverse element order. + */ + const_reverse_iterator + crbegin() const noexcept + { return const_reverse_iterator(end()); } + + /** + * Returns a read-only (constant) reverse iterator that points + * to one before the first element in the %vector. Iteration + * is done in reverse element order. + */ + const_reverse_iterator + crend() const noexcept + { return const_reverse_iterator(begin()); } +#endif + + // [23.2.4.2] capacity + /** Returns the number of elements in the %vector. */ + size_type + size() const _GLIBCXX_NOEXCEPT + { return size_type(this->_M_impl._M_finish - this->_M_impl._M_start); } + + /** Returns the size() of the largest possible %vector. */ + size_type + max_size() const _GLIBCXX_NOEXCEPT + { return _Alloc_traits::max_size(_M_get_Tp_allocator()); } + +#if __cplusplus >= 201103L + /** + * @brief Resizes the %vector to the specified number of elements. + * @param __new_size Number of elements the %vector should contain. + * + * This function will %resize the %vector to the specified + * number of elements. If the number is smaller than the + * %vector's current size the %vector is truncated, otherwise + * default constructed elements are appended. + */ + void + resize(size_type __new_size) + { + if (__new_size > size()) + _M_default_append(__new_size - size()); + else if (__new_size < size()) + _M_erase_at_end(this->_M_impl._M_start + __new_size); + } + + /** + * @brief Resizes the %vector to the specified number of elements. + * @param __new_size Number of elements the %vector should contain. + * @param __x Data with which new elements should be populated. + * + * This function will %resize the %vector to the specified + * number of elements. If the number is smaller than the + * %vector's current size the %vector is truncated, otherwise + * the %vector is extended and new elements are populated with + * given data. + */ + void + resize(size_type __new_size, const value_type& __x) + { + if (__new_size > size()) + insert(end(), __new_size - size(), __x); + else if (__new_size < size()) + _M_erase_at_end(this->_M_impl._M_start + __new_size); + } +#else + /** + * @brief Resizes the %vector to the specified number of elements. + * @param __new_size Number of elements the %vector should contain. + * @param __x Data with which new elements should be populated. + * + * This function will %resize the %vector to the specified + * number of elements. If the number is smaller than the + * %vector's current size the %vector is truncated, otherwise + * the %vector is extended and new elements are populated with + * given data. + */ + void + resize(size_type __new_size, value_type __x = value_type()) + { + if (__new_size > size()) + insert(end(), __new_size - size(), __x); + else if (__new_size < size()) + _M_erase_at_end(this->_M_impl._M_start + __new_size); + } +#endif + +#if __cplusplus >= 201103L + /** A non-binding request to reduce capacity() to size(). */ + void + shrink_to_fit() + { _M_shrink_to_fit(); } +#endif + + /** + * Returns the total number of elements that the %vector can + * hold before needing to allocate more memory. + */ + size_type + capacity() const _GLIBCXX_NOEXCEPT + { return size_type(this->_M_impl._M_end_of_storage + - this->_M_impl._M_start); } + + /** + * Returns true if the %vector is empty. (Thus begin() would + * equal end().) + */ + bool + empty() const _GLIBCXX_NOEXCEPT + { return begin() == end(); } + + /** + * @brief Attempt to preallocate enough memory for specified number of + * elements. + * @param __n Number of elements required. + * @throw std::length_error If @a n exceeds @c max_size(). + * + * This function attempts to reserve enough memory for the + * %vector to hold the specified number of elements. If the + * number requested is more than max_size(), length_error is + * thrown. + * + * The advantage of this function is that if optimal code is a + * necessity and the user can determine the number of elements + * that will be required, the user can reserve the memory in + * %advance, and thus prevent a possible reallocation of memory + * and copying of %vector data. + */ + void + reserve(size_type __n); + + // element access + /** + * @brief Subscript access to the data contained in the %vector. + * @param __n The index of the element for which data should be + * accessed. + * @return Read/write reference to data. + * + * This operator allows for easy, array-style, data access. + * Note that data access with this operator is unchecked and + * out_of_range lookups are not defined. (For checked lookups + * see at().) + */ + reference + operator[](size_type __n) _GLIBCXX_NOEXCEPT + { return *(this->_M_impl._M_start + __n); } + + /** + * @brief Subscript access to the data contained in the %vector. + * @param __n The index of the element for which data should be + * accessed. + * @return Read-only (constant) reference to data. + * + * This operator allows for easy, array-style, data access. + * Note that data access with this operator is unchecked and + * out_of_range lookups are not defined. (For checked lookups + * see at().) + */ + const_reference + operator[](size_type __n) const _GLIBCXX_NOEXCEPT + { return *(this->_M_impl._M_start + __n); } + + protected: + /// Safety check used only from at(). + void + _M_range_check(size_type __n) const + { + if (__n >= this->size()) + __throw_out_of_range_fmt(__N("vector::_M_range_check: __n " + "(which is %zu) >= this->size() " + "(which is %zu)"), + __n, this->size()); + } + + public: + /** + * @brief Provides access to the data contained in the %vector. + * @param __n The index of the element for which data should be + * accessed. + * @return Read/write reference to data. + * @throw std::out_of_range If @a __n is an invalid index. + * + * This function provides for safer data access. The parameter + * is first checked that it is in the range of the vector. The + * function throws out_of_range if the check fails. + */ + reference + at(size_type __n) + { + _M_range_check(__n); + return (*this)[__n]; + } + + /** + * @brief Provides access to the data contained in the %vector. + * @param __n The index of the element for which data should be + * accessed. + * @return Read-only (constant) reference to data. + * @throw std::out_of_range If @a __n is an invalid index. + * + * This function provides for safer data access. The parameter + * is first checked that it is in the range of the vector. The + * function throws out_of_range if the check fails. + */ + const_reference + at(size_type __n) const + { + _M_range_check(__n); + return (*this)[__n]; + } + + /** + * Returns a read/write reference to the data at the first + * element of the %vector. + */ + reference + front() _GLIBCXX_NOEXCEPT + { return *begin(); } + + /** + * Returns a read-only (constant) reference to the data at the first + * element of the %vector. + */ + const_reference + front() const _GLIBCXX_NOEXCEPT + { return *begin(); } + + /** + * Returns a read/write reference to the data at the last + * element of the %vector. + */ + reference + back() _GLIBCXX_NOEXCEPT + { return *(end() - 1); } + + /** + * Returns a read-only (constant) reference to the data at the + * last element of the %vector. + */ + const_reference + back() const _GLIBCXX_NOEXCEPT + { return *(end() - 1); } + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR 464. Suggestion for new member functions in standard containers. + // data access + /** + * Returns a pointer such that [data(), data() + size()) is a valid + * range. For a non-empty %vector, data() == &front(). + */ +#if __cplusplus >= 201103L + _Tp* +#else + pointer +#endif + data() _GLIBCXX_NOEXCEPT + { return _M_data_ptr(this->_M_impl._M_start); } + +#if __cplusplus >= 201103L + const _Tp* +#else + const_pointer +#endif + data() const _GLIBCXX_NOEXCEPT + { return _M_data_ptr(this->_M_impl._M_start); } + + // [23.2.4.3] modifiers + /** + * @brief Add data to the end of the %vector. + * @param __x Data to be added. + * + * This is a typical stack operation. The function creates an + * element at the end of the %vector and assigns the given data + * to it. Due to the nature of a %vector this operation can be + * done in constant time if the %vector has preallocated space + * available. + */ + void + push_back(const value_type& __x) + { + if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage) + { + _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish, + __x); + ++this->_M_impl._M_finish; + } + else +#if __cplusplus >= 201103L + _M_emplace_back_aux(__x); +#else + _M_insert_aux(end(), __x); +#endif + } + +#if __cplusplus >= 201103L + void + push_back(value_type&& __x) + { emplace_back(std::move(__x)); } + + template + void + emplace_back(_Args&&... __args); +#endif + + /** + * @brief Removes last element. + * + * This is a typical stack operation. It shrinks the %vector by one. + * + * Note that no data is returned, and if the last element's + * data is needed, it should be retrieved before pop_back() is + * called. + */ + void + pop_back() _GLIBCXX_NOEXCEPT + { + --this->_M_impl._M_finish; + _Alloc_traits::destroy(this->_M_impl, this->_M_impl._M_finish); + } + +#if __cplusplus >= 201103L + /** + * @brief Inserts an object in %vector before specified iterator. + * @param __position A const_iterator into the %vector. + * @param __args Arguments. + * @return An iterator that points to the inserted data. + * + * This function will insert an object of type T constructed + * with T(std::forward(args)...) before the specified location. + * Note that this kind of operation could be expensive for a %vector + * and if it is frequently used the user should consider using + * std::list. + */ + template + iterator + emplace(const_iterator __position, _Args&&... __args); + + /** + * @brief Inserts given value into %vector before specified iterator. + * @param __position A const_iterator into the %vector. + * @param __x Data to be inserted. + * @return An iterator that points to the inserted data. + * + * This function will insert a copy of the given value before + * the specified location. Note that this kind of operation + * could be expensive for a %vector and if it is frequently + * used the user should consider using std::list. + */ + iterator + insert(const_iterator __position, const value_type& __x); +#else + /** + * @brief Inserts given value into %vector before specified iterator. + * @param __position An iterator into the %vector. + * @param __x Data to be inserted. + * @return An iterator that points to the inserted data. + * + * This function will insert a copy of the given value before + * the specified location. Note that this kind of operation + * could be expensive for a %vector and if it is frequently + * used the user should consider using std::list. + */ + iterator + insert(iterator __position, const value_type& __x); +#endif + +#if __cplusplus >= 201103L + /** + * @brief Inserts given rvalue into %vector before specified iterator. + * @param __position A const_iterator into the %vector. + * @param __x Data to be inserted. + * @return An iterator that points to the inserted data. + * + * This function will insert a copy of the given rvalue before + * the specified location. Note that this kind of operation + * could be expensive for a %vector and if it is frequently + * used the user should consider using std::list. + */ + iterator + insert(const_iterator __position, value_type&& __x) + { return emplace(__position, std::move(__x)); } + + /** + * @brief Inserts an initializer_list into the %vector. + * @param __position An iterator into the %vector. + * @param __l An initializer_list. + * + * This function will insert copies of the data in the + * initializer_list @a l into the %vector before the location + * specified by @a position. + * + * Note that this kind of operation could be expensive for a + * %vector and if it is frequently used the user should + * consider using std::list. + */ + iterator + insert(const_iterator __position, initializer_list __l) + { return this->insert(__position, __l.begin(), __l.end()); } +#endif + +#if __cplusplus >= 201103L + /** + * @brief Inserts a number of copies of given data into the %vector. + * @param __position A const_iterator into the %vector. + * @param __n Number of elements to be inserted. + * @param __x Data to be inserted. + * @return An iterator that points to the inserted data. + * + * This function will insert a specified number of copies of + * the given data before the location specified by @a position. + * + * Note that this kind of operation could be expensive for a + * %vector and if it is frequently used the user should + * consider using std::list. + */ + iterator + insert(const_iterator __position, size_type __n, const value_type& __x) + { + difference_type __offset = __position - cbegin(); + _M_fill_insert(begin() + __offset, __n, __x); + return begin() + __offset; + } +#else + /** + * @brief Inserts a number of copies of given data into the %vector. + * @param __position An iterator into the %vector. + * @param __n Number of elements to be inserted. + * @param __x Data to be inserted. + * + * This function will insert a specified number of copies of + * the given data before the location specified by @a position. + * + * Note that this kind of operation could be expensive for a + * %vector and if it is frequently used the user should + * consider using std::list. + */ + void + insert(iterator __position, size_type __n, const value_type& __x) + { _M_fill_insert(__position, __n, __x); } +#endif + +#if __cplusplus >= 201103L + /** + * @brief Inserts a range into the %vector. + * @param __position A const_iterator into the %vector. + * @param __first An input iterator. + * @param __last An input iterator. + * @return An iterator that points to the inserted data. + * + * This function will insert copies of the data in the range + * [__first,__last) into the %vector before the location specified + * by @a pos. + * + * Note that this kind of operation could be expensive for a + * %vector and if it is frequently used the user should + * consider using std::list. + */ + template> + iterator + insert(const_iterator __position, _InputIterator __first, + _InputIterator __last) + { + difference_type __offset = __position - cbegin(); + _M_insert_dispatch(begin() + __offset, + __first, __last, __false_type()); + return begin() + __offset; + } +#else + /** + * @brief Inserts a range into the %vector. + * @param __position An iterator into the %vector. + * @param __first An input iterator. + * @param __last An input iterator. + * + * This function will insert copies of the data in the range + * [__first,__last) into the %vector before the location specified + * by @a pos. + * + * Note that this kind of operation could be expensive for a + * %vector and if it is frequently used the user should + * consider using std::list. + */ + template + void + insert(iterator __position, _InputIterator __first, + _InputIterator __last) + { + // Check whether it's an integral type. If so, it's not an iterator. + typedef typename std::__is_integer<_InputIterator>::__type _Integral; + _M_insert_dispatch(__position, __first, __last, _Integral()); + } +#endif + + /** + * @brief Remove element at given position. + * @param __position Iterator pointing to element to be erased. + * @return An iterator pointing to the next element (or end()). + * + * This function will erase the element at the given position and thus + * shorten the %vector by one. + * + * Note This operation could be expensive and if it is + * frequently used the user should consider using std::list. + * The user is also cautioned that this function only erases + * the element, and that if the element is itself a pointer, + * the pointed-to memory is not touched in any way. Managing + * the pointer is the user's responsibility. + */ + iterator +#if __cplusplus >= 201103L + erase(const_iterator __position) + { return _M_erase(begin() + (__position - cbegin())); } +#else + erase(iterator __position) + { return _M_erase(__position); } +#endif + + /** + * @brief Remove a range of elements. + * @param __first Iterator pointing to the first element to be erased. + * @param __last Iterator pointing to one past the last element to be + * erased. + * @return An iterator pointing to the element pointed to by @a __last + * prior to erasing (or end()). + * + * This function will erase the elements in the range + * [__first,__last) and shorten the %vector accordingly. + * + * Note This operation could be expensive and if it is + * frequently used the user should consider using std::list. + * The user is also cautioned that this function only erases + * the elements, and that if the elements themselves are + * pointers, the pointed-to memory is not touched in any way. + * Managing the pointer is the user's responsibility. + */ + iterator +#if __cplusplus >= 201103L + erase(const_iterator __first, const_iterator __last) + { + const auto __beg = begin(); + const auto __cbeg = cbegin(); + return _M_erase(__beg + (__first - __cbeg), __beg + (__last - __cbeg)); + } +#else + erase(iterator __first, iterator __last) + { return _M_erase(__first, __last); } +#endif + + /** + * @brief Swaps data with another %vector. + * @param __x A %vector of the same element and allocator types. + * + * This exchanges the elements between two vectors in constant time. + * (Three pointers, so it should be quite fast.) + * Note that the global std::swap() function is specialized such that + * std::swap(v1,v2) will feed to this function. + */ + void + swap(vector& __x) +#if __cplusplus >= 201103L + noexcept(_Alloc_traits::_S_nothrow_swap()) +#endif + { + this->_M_impl._M_swap_data(__x._M_impl); + _Alloc_traits::_S_on_swap(_M_get_Tp_allocator(), + __x._M_get_Tp_allocator()); + } + + /** + * Erases all the elements. Note that this function only erases the + * elements, and that if the elements themselves are pointers, the + * pointed-to memory is not touched in any way. Managing the pointer is + * the user's responsibility. + */ + void + clear() _GLIBCXX_NOEXCEPT + { _M_erase_at_end(this->_M_impl._M_start); } + + protected: + /** + * Memory expansion handler. Uses the member allocation function to + * obtain @a n bytes of memory, and then copies [first,last) into it. + */ + template + pointer + _M_allocate_and_copy(size_type __n, + _ForwardIterator __first, _ForwardIterator __last) + { + pointer __result = this->_M_allocate(__n); + __try + { + std::__uninitialized_copy_a(__first, __last, __result, + _M_get_Tp_allocator()); + return __result; + } + __catch(...) + { + _M_deallocate(__result, __n); + __throw_exception_again; + } + } + + + // Internal constructor functions follow. + + // Called by the range constructor to implement [23.1.1]/9 + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 438. Ambiguity in the "do the right thing" clause + template + void + _M_initialize_dispatch(_Integer __n, _Integer __value, __true_type) + { + this->_M_impl._M_start = _M_allocate(static_cast(__n)); + this->_M_impl._M_end_of_storage = + this->_M_impl._M_start + static_cast(__n); + _M_fill_initialize(static_cast(__n), __value); + } + + // Called by the range constructor to implement [23.1.1]/9 + template + void + _M_initialize_dispatch(_InputIterator __first, _InputIterator __last, + __false_type) + { + typedef typename std::iterator_traits<_InputIterator>:: + iterator_category _IterCategory; + _M_range_initialize(__first, __last, _IterCategory()); + } + + // Called by the second initialize_dispatch above + template + void + _M_range_initialize(_InputIterator __first, + _InputIterator __last, std::input_iterator_tag) + { + for (; __first != __last; ++__first) +#if __cplusplus >= 201103L + emplace_back(*__first); +#else + push_back(*__first); +#endif + } + + // Called by the second initialize_dispatch above + template + void + _M_range_initialize(_ForwardIterator __first, + _ForwardIterator __last, std::forward_iterator_tag) + { + const size_type __n = std::distance(__first, __last); + this->_M_impl._M_start = this->_M_allocate(__n); + this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n; + this->_M_impl._M_finish = + std::__uninitialized_copy_a(__first, __last, + this->_M_impl._M_start, + _M_get_Tp_allocator()); + } + + // Called by the first initialize_dispatch above and by the + // vector(n,value,a) constructor. + void + _M_fill_initialize(size_type __n, const value_type& __value) + { + std::__uninitialized_fill_n_a(this->_M_impl._M_start, __n, __value, + _M_get_Tp_allocator()); + this->_M_impl._M_finish = this->_M_impl._M_end_of_storage; + } + +#if __cplusplus >= 201103L + // Called by the vector(n) constructor. + void + _M_default_initialize(size_type __n) + { + std::__uninitialized_default_n_a(this->_M_impl._M_start, __n, + _M_get_Tp_allocator()); + this->_M_impl._M_finish = this->_M_impl._M_end_of_storage; + } +#endif + + // Internal assign functions follow. The *_aux functions do the actual + // assignment work for the range versions. + + // Called by the range assign to implement [23.1.1]/9 + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 438. Ambiguity in the "do the right thing" clause + template + void + _M_assign_dispatch(_Integer __n, _Integer __val, __true_type) + { _M_fill_assign(__n, __val); } + + // Called by the range assign to implement [23.1.1]/9 + template + void + _M_assign_dispatch(_InputIterator __first, _InputIterator __last, + __false_type) + { + typedef typename std::iterator_traits<_InputIterator>:: + iterator_category _IterCategory; + _M_assign_aux(__first, __last, _IterCategory()); + } + + // Called by the second assign_dispatch above + template + void + _M_assign_aux(_InputIterator __first, _InputIterator __last, + std::input_iterator_tag); + + // Called by the second assign_dispatch above + template + void + _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last, + std::forward_iterator_tag); + + // Called by assign(n,t), and the range assign when it turns out + // to be the same thing. + void + _M_fill_assign(size_type __n, const value_type& __val); + + + // Internal insert functions follow. + + // Called by the range insert to implement [23.1.1]/9 + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 438. Ambiguity in the "do the right thing" clause + template + void + _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __val, + __true_type) + { _M_fill_insert(__pos, __n, __val); } + + // Called by the range insert to implement [23.1.1]/9 + template + void + _M_insert_dispatch(iterator __pos, _InputIterator __first, + _InputIterator __last, __false_type) + { + typedef typename std::iterator_traits<_InputIterator>:: + iterator_category _IterCategory; + _M_range_insert(__pos, __first, __last, _IterCategory()); + } + + // Called by the second insert_dispatch above + template + void + _M_range_insert(iterator __pos, _InputIterator __first, + _InputIterator __last, std::input_iterator_tag); + + // Called by the second insert_dispatch above + template + void + _M_range_insert(iterator __pos, _ForwardIterator __first, + _ForwardIterator __last, std::forward_iterator_tag); + + // Called by insert(p,n,x), and the range insert when it turns out to be + // the same thing. + void + _M_fill_insert(iterator __pos, size_type __n, const value_type& __x); + +#if __cplusplus >= 201103L + // Called by resize(n). + void + _M_default_append(size_type __n); + + bool + _M_shrink_to_fit(); +#endif + + // Called by insert(p,x) +#if __cplusplus < 201103L + void + _M_insert_aux(iterator __position, const value_type& __x); +#else + template + void + _M_insert_aux(iterator __position, _Args&&... __args); + + template + void + _M_emplace_back_aux(_Args&&... __args); +#endif + + // Called by the latter. + size_type + _M_check_len(size_type __n, const char* __s) const + { + if (max_size() - size() < __n) + __throw_length_error(__N(__s)); + + const size_type __len = size() + std::max(size(), __n); + return (__len < size() || __len > max_size()) ? max_size() : __len; + } + + // Internal erase functions follow. + + // Called by erase(q1,q2), clear(), resize(), _M_fill_assign, + // _M_assign_aux. + void + _M_erase_at_end(pointer __pos) _GLIBCXX_NOEXCEPT + { + std::_Destroy(__pos, this->_M_impl._M_finish, _M_get_Tp_allocator()); + this->_M_impl._M_finish = __pos; + } + + iterator + _M_erase(iterator __position); + + iterator + _M_erase(iterator __first, iterator __last); + +#if __cplusplus >= 201103L + private: + // Constant-time move assignment when source object's memory can be + // moved, either because the source's allocator will move too + // or because the allocators are equal. + void + _M_move_assign(vector&& __x, std::true_type) noexcept + { + vector __tmp(get_allocator()); + this->_M_impl._M_swap_data(__tmp._M_impl); + this->_M_impl._M_swap_data(__x._M_impl); + std::__alloc_on_move(_M_get_Tp_allocator(), __x._M_get_Tp_allocator()); + } + + // Do move assignment when it might not be possible to move source + // object's memory, resulting in a linear-time operation. + void + _M_move_assign(vector&& __x, std::false_type) + { + if (__x._M_get_Tp_allocator() == this->_M_get_Tp_allocator()) + _M_move_assign(std::move(__x), std::true_type()); + else + { + // The rvalue's allocator cannot be moved and is not equal, + // so we need to individually move each element. + this->assign(std::__make_move_if_noexcept_iterator(__x.begin()), + std::__make_move_if_noexcept_iterator(__x.end())); + __x.clear(); + } + } +#endif + +#if __cplusplus >= 201103L + template + _Up* + _M_data_ptr(_Up* __ptr) const + { return __ptr; } + + template + typename std::pointer_traits<_Ptr>::element_type* + _M_data_ptr(_Ptr __ptr) const + { return empty() ? nullptr : std::__addressof(*__ptr); } +#else + template + _Ptr + _M_data_ptr(_Ptr __ptr) const + { return __ptr; } +#endif + }; + + + /** + * @brief Vector equality comparison. + * @param __x A %vector. + * @param __y A %vector of the same type as @a __x. + * @return True iff the size and elements of the vectors are equal. + * + * This is an equivalence relation. It is linear in the size of the + * vectors. Vectors are considered equivalent if their sizes are equal, + * and if corresponding elements compare equal. + */ + template + inline bool + operator==(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y) + { return (__x.size() == __y.size() + && std::equal(__x.begin(), __x.end(), __y.begin())); } + + /** + * @brief Vector ordering relation. + * @param __x A %vector. + * @param __y A %vector of the same type as @a __x. + * @return True iff @a __x is lexicographically less than @a __y. + * + * This is a total ordering relation. It is linear in the size of the + * vectors. The elements must be comparable with @c <. + * + * See std::lexicographical_compare() for how the determination is made. + */ + template + inline bool + operator<(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y) + { return std::lexicographical_compare(__x.begin(), __x.end(), + __y.begin(), __y.end()); } + + /// Based on operator== + template + inline bool + operator!=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y) + { return !(__x == __y); } + + /// Based on operator< + template + inline bool + operator>(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y) + { return __y < __x; } + + /// Based on operator< + template + inline bool + operator<=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y) + { return !(__y < __x); } + + /// Based on operator< + template + inline bool + operator>=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y) + { return !(__x < __y); } + + /// See std::vector::swap(). + template + inline void + swap(vector<_Tp, _Alloc>& __x, vector<_Tp, _Alloc>& __y) + { __x.swap(__y); } + +_GLIBCXX_END_NAMESPACE_CONTAINER +} // namespace std + +#endif /* _STL_VECTOR_H */ diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stream_iterator.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stream_iterator.h new file mode 100755 index 0000000..7db26df --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stream_iterator.h @@ -0,0 +1,221 @@ +// Stream iterators + +// Copyright (C) 2001-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file bits/stream_iterator.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{iterator} + */ + +#ifndef _STREAM_ITERATOR_H +#define _STREAM_ITERATOR_H 1 + +#pragma GCC system_header + +#include + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /** + * @addtogroup iterators + * @{ + */ + + /// Provides input iterator semantics for streams. + template, typename _Dist = ptrdiff_t> + class istream_iterator + : public iterator + { + public: + typedef _CharT char_type; + typedef _Traits traits_type; + typedef basic_istream<_CharT, _Traits> istream_type; + + private: + istream_type* _M_stream; + _Tp _M_value; + bool _M_ok; + + public: + /// Construct end of input stream iterator. + _GLIBCXX_CONSTEXPR istream_iterator() + : _M_stream(0), _M_value(), _M_ok(false) {} + + /// Construct start of input stream iterator. + istream_iterator(istream_type& __s) + : _M_stream(&__s) + { _M_read(); } + + istream_iterator(const istream_iterator& __obj) + : _M_stream(__obj._M_stream), _M_value(__obj._M_value), + _M_ok(__obj._M_ok) + { } + + const _Tp& + operator*() const + { + __glibcxx_requires_cond(_M_ok, + _M_message(__gnu_debug::__msg_deref_istream) + ._M_iterator(*this)); + return _M_value; + } + + const _Tp* + operator->() const { return &(operator*()); } + + istream_iterator& + operator++() + { + __glibcxx_requires_cond(_M_ok, + _M_message(__gnu_debug::__msg_inc_istream) + ._M_iterator(*this)); + _M_read(); + return *this; + } + + istream_iterator + operator++(int) + { + __glibcxx_requires_cond(_M_ok, + _M_message(__gnu_debug::__msg_inc_istream) + ._M_iterator(*this)); + istream_iterator __tmp = *this; + _M_read(); + return __tmp; + } + + bool + _M_equal(const istream_iterator& __x) const + { return (_M_ok == __x._M_ok) && (!_M_ok || _M_stream == __x._M_stream); } + + private: + void + _M_read() + { + _M_ok = (_M_stream && *_M_stream) ? true : false; + if (_M_ok) + { + *_M_stream >> _M_value; + _M_ok = *_M_stream ? true : false; + } + } + }; + + /// Return true if x and y are both end or not end, or x and y are the same. + template + inline bool + operator==(const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __x, + const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __y) + { return __x._M_equal(__y); } + + /// Return false if x and y are both end or not end, or x and y are the same. + template + inline bool + operator!=(const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __x, + const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __y) + { return !__x._M_equal(__y); } + + /** + * @brief Provides output iterator semantics for streams. + * + * This class provides an iterator to write to an ostream. The type Tp is + * the only type written by this iterator and there must be an + * operator<<(Tp) defined. + * + * @tparam _Tp The type to write to the ostream. + * @tparam _CharT The ostream char_type. + * @tparam _Traits The ostream char_traits. + */ + template > + class ostream_iterator + : public iterator + { + public: + //@{ + /// Public typedef + typedef _CharT char_type; + typedef _Traits traits_type; + typedef basic_ostream<_CharT, _Traits> ostream_type; + //@} + + private: + ostream_type* _M_stream; + const _CharT* _M_string; + + public: + /// Construct from an ostream. + ostream_iterator(ostream_type& __s) : _M_stream(&__s), _M_string(0) {} + + /** + * Construct from an ostream. + * + * The delimiter string @a c is written to the stream after every Tp + * written to the stream. The delimiter is not copied, and thus must + * not be destroyed while this iterator is in use. + * + * @param __s Underlying ostream to write to. + * @param __c CharT delimiter string to insert. + */ + ostream_iterator(ostream_type& __s, const _CharT* __c) + : _M_stream(&__s), _M_string(__c) { } + + /// Copy constructor. + ostream_iterator(const ostream_iterator& __obj) + : _M_stream(__obj._M_stream), _M_string(__obj._M_string) { } + + /// Writes @a value to underlying ostream using operator<<. If + /// constructed with delimiter string, writes delimiter to ostream. + ostream_iterator& + operator=(const _Tp& __value) + { + __glibcxx_requires_cond(_M_stream != 0, + _M_message(__gnu_debug::__msg_output_ostream) + ._M_iterator(*this)); + *_M_stream << __value; + if (_M_string) *_M_stream << _M_string; + return *this; + } + + ostream_iterator& + operator*() + { return *this; } + + ostream_iterator& + operator++() + { return *this; } + + ostream_iterator& + operator++(int) + { return *this; } + }; + + // @} group iterators + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/streambuf.tcc b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/streambuf.tcc new file mode 100755 index 0000000..b22e100 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/streambuf.tcc @@ -0,0 +1,175 @@ +// Stream buffer classes -*- C++ -*- + +// Copyright (C) 1997-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file bits/streambuf.tcc + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{streambuf} + */ + +// +// ISO C++ 14882: 27.5 Stream buffers +// + +#ifndef _STREAMBUF_TCC +#define _STREAMBUF_TCC 1 + +#pragma GCC system_header + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + template + streamsize + basic_streambuf<_CharT, _Traits>:: + xsgetn(char_type* __s, streamsize __n) + { + streamsize __ret = 0; + while (__ret < __n) + { + const streamsize __buf_len = this->egptr() - this->gptr(); + if (__buf_len) + { + const streamsize __remaining = __n - __ret; + const streamsize __len = std::min(__buf_len, __remaining); + traits_type::copy(__s, this->gptr(), __len); + __ret += __len; + __s += __len; + this->__safe_gbump(__len); + } + + if (__ret < __n) + { + const int_type __c = this->uflow(); + if (!traits_type::eq_int_type(__c, traits_type::eof())) + { + traits_type::assign(*__s++, traits_type::to_char_type(__c)); + ++__ret; + } + else + break; + } + } + return __ret; + } + + template + streamsize + basic_streambuf<_CharT, _Traits>:: + xsputn(const char_type* __s, streamsize __n) + { + streamsize __ret = 0; + while (__ret < __n) + { + const streamsize __buf_len = this->epptr() - this->pptr(); + if (__buf_len) + { + const streamsize __remaining = __n - __ret; + const streamsize __len = std::min(__buf_len, __remaining); + traits_type::copy(this->pptr(), __s, __len); + __ret += __len; + __s += __len; + this->__safe_pbump(__len); + } + + if (__ret < __n) + { + int_type __c = this->overflow(traits_type::to_int_type(*__s)); + if (!traits_type::eq_int_type(__c, traits_type::eof())) + { + ++__ret; + ++__s; + } + else + break; + } + } + return __ret; + } + + // Conceivably, this could be used to implement buffer-to-buffer + // copies, if this was ever desired in an un-ambiguous way by the + // standard. + template + streamsize + __copy_streambufs_eof(basic_streambuf<_CharT, _Traits>* __sbin, + basic_streambuf<_CharT, _Traits>* __sbout, + bool& __ineof) + { + streamsize __ret = 0; + __ineof = true; + typename _Traits::int_type __c = __sbin->sgetc(); + while (!_Traits::eq_int_type(__c, _Traits::eof())) + { + __c = __sbout->sputc(_Traits::to_char_type(__c)); + if (_Traits::eq_int_type(__c, _Traits::eof())) + { + __ineof = false; + break; + } + ++__ret; + __c = __sbin->snextc(); + } + return __ret; + } + + template + inline streamsize + __copy_streambufs(basic_streambuf<_CharT, _Traits>* __sbin, + basic_streambuf<_CharT, _Traits>* __sbout) + { + bool __ineof; + return __copy_streambufs_eof(__sbin, __sbout, __ineof); + } + + // Inhibit implicit instantiations for required instantiations, + // which are defined via explicit instantiations elsewhere. +#if _GLIBCXX_EXTERN_TEMPLATE + extern template class basic_streambuf; + extern template + streamsize + __copy_streambufs(basic_streambuf*, + basic_streambuf*); + extern template + streamsize + __copy_streambufs_eof(basic_streambuf*, + basic_streambuf*, bool&); + +#ifdef _GLIBCXX_USE_WCHAR_T + extern template class basic_streambuf; + extern template + streamsize + __copy_streambufs(basic_streambuf*, + basic_streambuf*); + extern template + streamsize + __copy_streambufs_eof(basic_streambuf*, + basic_streambuf*, bool&); +#endif +#endif + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace std + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/streambuf_iterator.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/streambuf_iterator.h new file mode 100755 index 0000000..74f6962 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/streambuf_iterator.h @@ -0,0 +1,412 @@ +// Streambuf iterators + +// Copyright (C) 1997-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file bits/streambuf_iterator.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{iterator} + */ + +#ifndef _STREAMBUF_ITERATOR_H +#define _STREAMBUF_ITERATOR_H 1 + +#pragma GCC system_header + +#include +#include + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /** + * @addtogroup iterators + * @{ + */ + + // 24.5.3 Template class istreambuf_iterator + /// Provides input iterator semantics for streambufs. + template + class istreambuf_iterator + : public iterator= 201103L + // LWG 445. + _CharT> +#else + _CharT&> +#endif + { + public: + // Types: + //@{ + /// Public typedefs + typedef _CharT char_type; + typedef _Traits traits_type; + typedef typename _Traits::int_type int_type; + typedef basic_streambuf<_CharT, _Traits> streambuf_type; + typedef basic_istream<_CharT, _Traits> istream_type; + //@} + + template + friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, + ostreambuf_iterator<_CharT2> >::__type + copy(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>, + ostreambuf_iterator<_CharT2>); + + template + friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, + _CharT2*>::__type + __copy_move_a2(istreambuf_iterator<_CharT2>, + istreambuf_iterator<_CharT2>, _CharT2*); + + template + friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, + istreambuf_iterator<_CharT2> >::__type + find(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>, + const _CharT2&); + + private: + // 24.5.3 istreambuf_iterator + // p 1 + // If the end of stream is reached (streambuf_type::sgetc() + // returns traits_type::eof()), the iterator becomes equal to + // the "end of stream" iterator value. + // NB: This implementation assumes the "end of stream" value + // is EOF, or -1. + mutable streambuf_type* _M_sbuf; + mutable int_type _M_c; + + public: + /// Construct end of input stream iterator. + _GLIBCXX_CONSTEXPR istreambuf_iterator() _GLIBCXX_USE_NOEXCEPT + : _M_sbuf(0), _M_c(traits_type::eof()) { } + +#if __cplusplus >= 201103L + istreambuf_iterator(const istreambuf_iterator&) noexcept = default; + + ~istreambuf_iterator() = default; +#endif + + /// Construct start of input stream iterator. + istreambuf_iterator(istream_type& __s) _GLIBCXX_USE_NOEXCEPT + : _M_sbuf(__s.rdbuf()), _M_c(traits_type::eof()) { } + + /// Construct start of streambuf iterator. + istreambuf_iterator(streambuf_type* __s) _GLIBCXX_USE_NOEXCEPT + : _M_sbuf(__s), _M_c(traits_type::eof()) { } + + /// Return the current character pointed to by iterator. This returns + /// streambuf.sgetc(). It cannot be assigned. NB: The result of + /// operator*() on an end of stream is undefined. + char_type + operator*() const + { +#ifdef _GLIBCXX_DEBUG_PEDANTIC + // Dereferencing a past-the-end istreambuf_iterator is a + // libstdc++ extension + __glibcxx_requires_cond(!_M_at_eof(), + _M_message(__gnu_debug::__msg_deref_istreambuf) + ._M_iterator(*this)); +#endif + return traits_type::to_char_type(_M_get()); + } + + /// Advance the iterator. Calls streambuf.sbumpc(). + istreambuf_iterator& + operator++() + { + __glibcxx_requires_cond(!_M_at_eof(), + _M_message(__gnu_debug::__msg_inc_istreambuf) + ._M_iterator(*this)); + if (_M_sbuf) + { + _M_sbuf->sbumpc(); + _M_c = traits_type::eof(); + } + return *this; + } + + /// Advance the iterator. Calls streambuf.sbumpc(). + istreambuf_iterator + operator++(int) + { + __glibcxx_requires_cond(!_M_at_eof(), + _M_message(__gnu_debug::__msg_inc_istreambuf) + ._M_iterator(*this)); + + istreambuf_iterator __old = *this; + if (_M_sbuf) + { + __old._M_c = _M_sbuf->sbumpc(); + _M_c = traits_type::eof(); + } + return __old; + } + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 110 istreambuf_iterator::equal not const + // NB: there is also number 111 (NAD, Future) pending on this function. + /// Return true both iterators are end or both are not end. + bool + equal(const istreambuf_iterator& __b) const + { return _M_at_eof() == __b._M_at_eof(); } + + private: + int_type + _M_get() const + { + const int_type __eof = traits_type::eof(); + int_type __ret = __eof; + if (_M_sbuf) + { + if (!traits_type::eq_int_type(_M_c, __eof)) + __ret = _M_c; + else if (!traits_type::eq_int_type((__ret = _M_sbuf->sgetc()), + __eof)) + _M_c = __ret; + else + _M_sbuf = 0; + } + return __ret; + } + + bool + _M_at_eof() const + { + const int_type __eof = traits_type::eof(); + return traits_type::eq_int_type(_M_get(), __eof); + } + }; + + template + inline bool + operator==(const istreambuf_iterator<_CharT, _Traits>& __a, + const istreambuf_iterator<_CharT, _Traits>& __b) + { return __a.equal(__b); } + + template + inline bool + operator!=(const istreambuf_iterator<_CharT, _Traits>& __a, + const istreambuf_iterator<_CharT, _Traits>& __b) + { return !__a.equal(__b); } + + /// Provides output iterator semantics for streambufs. + template + class ostreambuf_iterator + : public iterator + { + public: + // Types: + //@{ + /// Public typedefs + typedef _CharT char_type; + typedef _Traits traits_type; + typedef basic_streambuf<_CharT, _Traits> streambuf_type; + typedef basic_ostream<_CharT, _Traits> ostream_type; + //@} + + template + friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, + ostreambuf_iterator<_CharT2> >::__type + copy(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>, + ostreambuf_iterator<_CharT2>); + + private: + streambuf_type* _M_sbuf; + bool _M_failed; + + public: + /// Construct output iterator from ostream. + ostreambuf_iterator(ostream_type& __s) _GLIBCXX_USE_NOEXCEPT + : _M_sbuf(__s.rdbuf()), _M_failed(!_M_sbuf) { } + + /// Construct output iterator from streambuf. + ostreambuf_iterator(streambuf_type* __s) _GLIBCXX_USE_NOEXCEPT + : _M_sbuf(__s), _M_failed(!_M_sbuf) { } + + /// Write character to streambuf. Calls streambuf.sputc(). + ostreambuf_iterator& + operator=(_CharT __c) + { + if (!_M_failed && + _Traits::eq_int_type(_M_sbuf->sputc(__c), _Traits::eof())) + _M_failed = true; + return *this; + } + + /// Return *this. + ostreambuf_iterator& + operator*() + { return *this; } + + /// Return *this. + ostreambuf_iterator& + operator++(int) + { return *this; } + + /// Return *this. + ostreambuf_iterator& + operator++() + { return *this; } + + /// Return true if previous operator=() failed. + bool + failed() const _GLIBCXX_USE_NOEXCEPT + { return _M_failed; } + + ostreambuf_iterator& + _M_put(const _CharT* __ws, streamsize __len) + { + if (__builtin_expect(!_M_failed, true) + && __builtin_expect(this->_M_sbuf->sputn(__ws, __len) != __len, + false)) + _M_failed = true; + return *this; + } + }; + + // Overloads for streambuf iterators. + template + typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, + ostreambuf_iterator<_CharT> >::__type + copy(istreambuf_iterator<_CharT> __first, + istreambuf_iterator<_CharT> __last, + ostreambuf_iterator<_CharT> __result) + { + if (__first._M_sbuf && !__last._M_sbuf && !__result._M_failed) + { + bool __ineof; + __copy_streambufs_eof(__first._M_sbuf, __result._M_sbuf, __ineof); + if (!__ineof) + __result._M_failed = true; + } + return __result; + } + + template + typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, + ostreambuf_iterator<_CharT> >::__type + __copy_move_a2(_CharT* __first, _CharT* __last, + ostreambuf_iterator<_CharT> __result) + { + const streamsize __num = __last - __first; + if (__num > 0) + __result._M_put(__first, __num); + return __result; + } + + template + typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, + ostreambuf_iterator<_CharT> >::__type + __copy_move_a2(const _CharT* __first, const _CharT* __last, + ostreambuf_iterator<_CharT> __result) + { + const streamsize __num = __last - __first; + if (__num > 0) + __result._M_put(__first, __num); + return __result; + } + + template + typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, + _CharT*>::__type + __copy_move_a2(istreambuf_iterator<_CharT> __first, + istreambuf_iterator<_CharT> __last, _CharT* __result) + { + typedef istreambuf_iterator<_CharT> __is_iterator_type; + typedef typename __is_iterator_type::traits_type traits_type; + typedef typename __is_iterator_type::streambuf_type streambuf_type; + typedef typename traits_type::int_type int_type; + + if (__first._M_sbuf && !__last._M_sbuf) + { + streambuf_type* __sb = __first._M_sbuf; + int_type __c = __sb->sgetc(); + while (!traits_type::eq_int_type(__c, traits_type::eof())) + { + const streamsize __n = __sb->egptr() - __sb->gptr(); + if (__n > 1) + { + traits_type::copy(__result, __sb->gptr(), __n); + __sb->__safe_gbump(__n); + __result += __n; + __c = __sb->underflow(); + } + else + { + *__result++ = traits_type::to_char_type(__c); + __c = __sb->snextc(); + } + } + } + return __result; + } + + template + typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, + istreambuf_iterator<_CharT> >::__type + find(istreambuf_iterator<_CharT> __first, + istreambuf_iterator<_CharT> __last, const _CharT& __val) + { + typedef istreambuf_iterator<_CharT> __is_iterator_type; + typedef typename __is_iterator_type::traits_type traits_type; + typedef typename __is_iterator_type::streambuf_type streambuf_type; + typedef typename traits_type::int_type int_type; + + if (__first._M_sbuf && !__last._M_sbuf) + { + const int_type __ival = traits_type::to_int_type(__val); + streambuf_type* __sb = __first._M_sbuf; + int_type __c = __sb->sgetc(); + while (!traits_type::eq_int_type(__c, traits_type::eof()) + && !traits_type::eq_int_type(__c, __ival)) + { + streamsize __n = __sb->egptr() - __sb->gptr(); + if (__n > 1) + { + const _CharT* __p = traits_type::find(__sb->gptr(), + __n, __val); + if (__p) + __n = __p - __sb->gptr(); + __sb->__safe_gbump(__n); + __c = __sb->sgetc(); + } + else + __c = __sb->snextc(); + } + + if (!traits_type::eq_int_type(__c, traits_type::eof())) + __first._M_c = __c; + else + __first._M_sbuf = 0; + } + return __first; + } + +// @} group iterators + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stringfwd.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stringfwd.h new file mode 100755 index 0000000..132b88e --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/stringfwd.h @@ -0,0 +1,89 @@ +// Forward declarations -*- C++ -*- + +// Copyright (C) 2001-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file bits/stringfwd.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{string} + */ + +// +// ISO C++ 14882: 21 Strings library +// + +#ifndef _STRINGFWD_H +#define _STRINGFWD_H 1 + +#pragma GCC system_header + +#include +#include + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /** + * @defgroup strings Strings + * + * @{ + */ + + template + struct char_traits; + + template, + typename _Alloc = allocator<_CharT> > + class basic_string; + + template<> struct char_traits; + + /// A string of @c char + typedef basic_string string; + +#ifdef _GLIBCXX_USE_WCHAR_T + template<> struct char_traits; + + /// A string of @c wchar_t + typedef basic_string wstring; +#endif + +#if ((__cplusplus >= 201103L) \ + && defined(_GLIBCXX_USE_C99_STDINT_TR1)) + + template<> struct char_traits; + template<> struct char_traits; + + /// A string of @c char16_t + typedef basic_string u16string; + + /// A string of @c char32_t + typedef basic_string u32string; + +#endif + /** @} */ + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace std + +#endif // _STRINGFWD_H diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/unique_ptr.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/unique_ptr.h new file mode 100755 index 0000000..ce38c5a --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/unique_ptr.h @@ -0,0 +1,784 @@ +// unique_ptr implementation -*- C++ -*- + +// Copyright (C) 2008-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file bits/unique_ptr.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{memory} + */ + +#ifndef _UNIQUE_PTR_H +#define _UNIQUE_PTR_H 1 + +#include +#include +#include +#include +#include + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /** + * @addtogroup pointer_abstractions + * @{ + */ + +#if _GLIBCXX_USE_DEPRECATED + template class auto_ptr; +#endif + + /// Primary template of default_delete, used by unique_ptr + template + struct default_delete + { + /// Default constructor + constexpr default_delete() noexcept = default; + + /** @brief Converting constructor. + * + * Allows conversion from a deleter for arrays of another type, @p _Up, + * only if @p _Up* is convertible to @p _Tp*. + */ + template::value>::type> + default_delete(const default_delete<_Up>&) noexcept { } + + /// Calls @c delete @p __ptr + void + operator()(_Tp* __ptr) const + { + static_assert(!is_void<_Tp>::value, + "can't delete pointer to incomplete type"); + static_assert(sizeof(_Tp)>0, + "can't delete pointer to incomplete type"); + delete __ptr; + } + }; + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR 740 - omit specialization for array objects with a compile time length + /// Specialization for arrays, default_delete. + template + struct default_delete<_Tp[]> + { + private: + template + using __remove_cv = typename remove_cv<_Up>::type; + + // Like is_base_of<_Tp, _Up> but false if unqualified types are the same + template + using __is_derived_Tp + = __and_< is_base_of<_Tp, _Up>, + __not_, __remove_cv<_Up>>> >; + + public: + /// Default constructor + constexpr default_delete() noexcept = default; + + /** @brief Converting constructor. + * + * Allows conversion from a deleter for arrays of another type, such as + * a const-qualified version of @p _Tp. + * + * Conversions from types derived from @c _Tp are not allowed because + * it is unsafe to @c delete[] an array of derived types through a + * pointer to the base type. + */ + template::value>::type> + default_delete(const default_delete<_Up[]>&) noexcept { } + + /// Calls @c delete[] @p __ptr + void + operator()(_Tp* __ptr) const + { + static_assert(sizeof(_Tp)>0, + "can't delete pointer to incomplete type"); + delete [] __ptr; + } + + template + typename enable_if<__is_derived_Tp<_Up>::value>::type + operator()(_Up*) const = delete; + }; + + /// 20.7.1.2 unique_ptr for single objects. + template > + class unique_ptr + { + // use SFINAE to determine whether _Del::pointer exists + class _Pointer + { + template + static typename _Up::pointer __test(typename _Up::pointer*); + + template + static _Tp* __test(...); + + typedef typename remove_reference<_Dp>::type _Del; + + public: + typedef decltype(__test<_Del>(0)) type; + }; + + typedef std::tuple __tuple_type; + __tuple_type _M_t; + + public: + typedef typename _Pointer::type pointer; + typedef _Tp element_type; + typedef _Dp deleter_type; + + // Constructors. + + /// Default constructor, creates a unique_ptr that owns nothing. + constexpr unique_ptr() noexcept + : _M_t() + { static_assert(!is_pointer::value, + "constructed with null function pointer deleter"); } + + /** Takes ownership of a pointer. + * + * @param __p A pointer to an object of @c element_type + * + * The deleter will be value-initialized. + */ + explicit + unique_ptr(pointer __p) noexcept + : _M_t(__p, deleter_type()) + { static_assert(!is_pointer::value, + "constructed with null function pointer deleter"); } + + /** Takes ownership of a pointer. + * + * @param __p A pointer to an object of @c element_type + * @param __d A reference to a deleter. + * + * The deleter will be initialized with @p __d + */ + unique_ptr(pointer __p, + typename conditional::value, + deleter_type, const deleter_type&>::type __d) noexcept + : _M_t(__p, __d) { } + + /** Takes ownership of a pointer. + * + * @param __p A pointer to an object of @c element_type + * @param __d An rvalue reference to a deleter. + * + * The deleter will be initialized with @p std::move(__d) + */ + unique_ptr(pointer __p, + typename remove_reference::type&& __d) noexcept + : _M_t(std::move(__p), std::move(__d)) + { static_assert(!std::is_reference::value, + "rvalue deleter bound to reference"); } + + /// Creates a unique_ptr that owns nothing. + constexpr unique_ptr(nullptr_t) noexcept : unique_ptr() { } + + // Move constructors. + + /// Move constructor. + unique_ptr(unique_ptr&& __u) noexcept + : _M_t(__u.release(), std::forward(__u.get_deleter())) { } + + /** @brief Converting constructor from another type + * + * Requires that the pointer owned by @p __u is convertible to the + * type of pointer owned by this object, @p __u does not own an array, + * and @p __u has a compatible deleter type. + */ + template::pointer, pointer>, + __not_>, + typename conditional::value, + is_same<_Ep, _Dp>, + is_convertible<_Ep, _Dp>>::type>> + unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept + : _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter())) + { } + +#if _GLIBCXX_USE_DEPRECATED + /// Converting constructor from @c auto_ptr + template, is_same<_Dp, default_delete<_Tp>>>> + unique_ptr(auto_ptr<_Up>&& __u) noexcept; +#endif + + /// Destructor, invokes the deleter if the stored pointer is not null. + ~unique_ptr() noexcept + { + auto& __ptr = std::get<0>(_M_t); + if (__ptr != nullptr) + get_deleter()(__ptr); + __ptr = pointer(); + } + + // Assignment. + + /** @brief Move assignment operator. + * + * @param __u The object to transfer ownership from. + * + * Invokes the deleter first if this object owns a pointer. + */ + unique_ptr& + operator=(unique_ptr&& __u) noexcept + { + reset(__u.release()); + get_deleter() = std::forward(__u.get_deleter()); + return *this; + } + + /** @brief Assignment from another type. + * + * @param __u The object to transfer ownership from, which owns a + * convertible pointer to a non-array object. + * + * Invokes the deleter first if this object owns a pointer. + */ + template + typename enable_if< __and_< + is_convertible::pointer, pointer>, + __not_> + >::value, + unique_ptr&>::type + operator=(unique_ptr<_Up, _Ep>&& __u) noexcept + { + reset(__u.release()); + get_deleter() = std::forward<_Ep>(__u.get_deleter()); + return *this; + } + + /// Reset the %unique_ptr to empty, invoking the deleter if necessary. + unique_ptr& + operator=(nullptr_t) noexcept + { + reset(); + return *this; + } + + // Observers. + + /// Dereference the stored pointer. + typename add_lvalue_reference::type + operator*() const + { + _GLIBCXX_DEBUG_ASSERT(get() != pointer()); + return *get(); + } + + /// Return the stored pointer. + pointer + operator->() const noexcept + { + _GLIBCXX_DEBUG_ASSERT(get() != pointer()); + return get(); + } + + /// Return the stored pointer. + pointer + get() const noexcept + { return std::get<0>(_M_t); } + + /// Return a reference to the stored deleter. + deleter_type& + get_deleter() noexcept + { return std::get<1>(_M_t); } + + /// Return a reference to the stored deleter. + const deleter_type& + get_deleter() const noexcept + { return std::get<1>(_M_t); } + + /// Return @c true if the stored pointer is not null. + explicit operator bool() const noexcept + { return get() == pointer() ? false : true; } + + // Modifiers. + + /// Release ownership of any stored pointer. + pointer + release() noexcept + { + pointer __p = get(); + std::get<0>(_M_t) = pointer(); + return __p; + } + + /** @brief Replace the stored pointer. + * + * @param __p The new pointer to store. + * + * The deleter will be invoked if a pointer is already owned. + */ + void + reset(pointer __p = pointer()) noexcept + { + using std::swap; + swap(std::get<0>(_M_t), __p); + if (__p != pointer()) + get_deleter()(__p); + } + + /// Exchange the pointer and deleter with another object. + void + swap(unique_ptr& __u) noexcept + { + using std::swap; + swap(_M_t, __u._M_t); + } + + // Disable copy from lvalue. + unique_ptr(const unique_ptr&) = delete; + unique_ptr& operator=(const unique_ptr&) = delete; + }; + + /// 20.7.1.3 unique_ptr for array objects with a runtime length + // [unique.ptr.runtime] + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR 740 - omit specialization for array objects with a compile time length + template + class unique_ptr<_Tp[], _Dp> + { + // use SFINAE to determine whether _Del::pointer exists + class _Pointer + { + template + static typename _Up::pointer __test(typename _Up::pointer*); + + template + static _Tp* __test(...); + + typedef typename remove_reference<_Dp>::type _Del; + + public: + typedef decltype(__test<_Del>(0)) type; + }; + + typedef std::tuple __tuple_type; + __tuple_type _M_t; + + template + using __remove_cv = typename remove_cv<_Up>::type; + + // like is_base_of<_Tp, _Up> but false if unqualified types are the same + template + using __is_derived_Tp + = __and_< is_base_of<_Tp, _Up>, + __not_, __remove_cv<_Up>>> >; + + template::pointer> + using __safe_conversion = __and_< + is_convertible<_Up_pointer, _Tp_pointer>, + is_array<_Up>, + __or_<__not_>, + __not_>, + __not_<__is_derived_Tp::type>> + > + >; + + public: + typedef typename _Pointer::type pointer; + typedef _Tp element_type; + typedef _Dp deleter_type; + + // Constructors. + + /// Default constructor, creates a unique_ptr that owns nothing. + constexpr unique_ptr() noexcept + : _M_t() + { static_assert(!std::is_pointer::value, + "constructed with null function pointer deleter"); } + + /** Takes ownership of a pointer. + * + * @param __p A pointer to an array of @c element_type + * + * The deleter will be value-initialized. + */ + explicit + unique_ptr(pointer __p) noexcept + : _M_t(__p, deleter_type()) + { static_assert(!is_pointer::value, + "constructed with null function pointer deleter"); } + + // Disable construction from convertible pointer types. + template, + is_convertible<_Up*, pointer>, __is_derived_Tp<_Up>>> + explicit + unique_ptr(_Up* __p) = delete; + + /** Takes ownership of a pointer. + * + * @param __p A pointer to an array of @c element_type + * @param __d A reference to a deleter. + * + * The deleter will be initialized with @p __d + */ + unique_ptr(pointer __p, + typename conditional::value, + deleter_type, const deleter_type&>::type __d) noexcept + : _M_t(__p, __d) { } + + /** Takes ownership of a pointer. + * + * @param __p A pointer to an array of @c element_type + * @param __d A reference to a deleter. + * + * The deleter will be initialized with @p std::move(__d) + */ + unique_ptr(pointer __p, typename + remove_reference::type&& __d) noexcept + : _M_t(std::move(__p), std::move(__d)) + { static_assert(!is_reference::value, + "rvalue deleter bound to reference"); } + + /// Move constructor. + unique_ptr(unique_ptr&& __u) noexcept + : _M_t(__u.release(), std::forward(__u.get_deleter())) { } + + /// Creates a unique_ptr that owns nothing. + constexpr unique_ptr(nullptr_t) noexcept : unique_ptr() { } + + template, + typename conditional::value, + is_same<_Ep, _Dp>, + is_convertible<_Ep, _Dp>>::type + >> + unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept + : _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter())) + { } + + /// Destructor, invokes the deleter if the stored pointer is not null. + ~unique_ptr() + { + auto& __ptr = std::get<0>(_M_t); + if (__ptr != nullptr) + get_deleter()(__ptr); + __ptr = pointer(); + } + + // Assignment. + + /** @brief Move assignment operator. + * + * @param __u The object to transfer ownership from. + * + * Invokes the deleter first if this object owns a pointer. + */ + unique_ptr& + operator=(unique_ptr&& __u) noexcept + { + reset(__u.release()); + get_deleter() = std::forward(__u.get_deleter()); + return *this; + } + + /** @brief Assignment from another type. + * + * @param __u The object to transfer ownership from, which owns a + * convertible pointer to an array object. + * + * Invokes the deleter first if this object owns a pointer. + */ + template + typename + enable_if<__safe_conversion<_Up, _Ep>::value, unique_ptr&>::type + operator=(unique_ptr<_Up, _Ep>&& __u) noexcept + { + reset(__u.release()); + get_deleter() = std::forward<_Ep>(__u.get_deleter()); + return *this; + } + + /// Reset the %unique_ptr to empty, invoking the deleter if necessary. + unique_ptr& + operator=(nullptr_t) noexcept + { + reset(); + return *this; + } + + // Observers. + + /// Access an element of owned array. + typename std::add_lvalue_reference::type + operator[](size_t __i) const + { + _GLIBCXX_DEBUG_ASSERT(get() != pointer()); + return get()[__i]; + } + + /// Return the stored pointer. + pointer + get() const noexcept + { return std::get<0>(_M_t); } + + /// Return a reference to the stored deleter. + deleter_type& + get_deleter() noexcept + { return std::get<1>(_M_t); } + + /// Return a reference to the stored deleter. + const deleter_type& + get_deleter() const noexcept + { return std::get<1>(_M_t); } + + /// Return @c true if the stored pointer is not null. + explicit operator bool() const noexcept + { return get() == pointer() ? false : true; } + + // Modifiers. + + /// Release ownership of any stored pointer. + pointer + release() noexcept + { + pointer __p = get(); + std::get<0>(_M_t) = pointer(); + return __p; + } + + /** @brief Replace the stored pointer. + * + * @param __p The new pointer to store. + * + * The deleter will be invoked if a pointer is already owned. + */ + void + reset(pointer __p = pointer()) noexcept + { + using std::swap; + swap(std::get<0>(_M_t), __p); + if (__p != nullptr) + get_deleter()(__p); + } + + // Disable resetting from convertible pointer types. + template, + is_convertible<_Up*, pointer>, __is_derived_Tp<_Up>>> + void reset(_Up*) = delete; + + /// Exchange the pointer and deleter with another object. + void + swap(unique_ptr& __u) noexcept + { + using std::swap; + swap(_M_t, __u._M_t); + } + + // Disable copy from lvalue. + unique_ptr(const unique_ptr&) = delete; + unique_ptr& operator=(const unique_ptr&) = delete; + + // Disable construction from convertible pointer types. + template, + is_convertible<_Up*, pointer>, __is_derived_Tp<_Up>>> + unique_ptr(_Up*, typename + conditional::value, + deleter_type, const deleter_type&>::type) = delete; + + // Disable construction from convertible pointer types. + template, + is_convertible<_Up*, pointer>, __is_derived_Tp<_Up>>> + unique_ptr(_Up*, typename + remove_reference::type&&) = delete; + }; + + template + inline void + swap(unique_ptr<_Tp, _Dp>& __x, + unique_ptr<_Tp, _Dp>& __y) noexcept + { __x.swap(__y); } + + template + inline bool + operator==(const unique_ptr<_Tp, _Dp>& __x, + const unique_ptr<_Up, _Ep>& __y) + { return __x.get() == __y.get(); } + + template + inline bool + operator==(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) noexcept + { return !__x; } + + template + inline bool + operator==(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) noexcept + { return !__x; } + + template + inline bool + operator!=(const unique_ptr<_Tp, _Dp>& __x, + const unique_ptr<_Up, _Ep>& __y) + { return __x.get() != __y.get(); } + + template + inline bool + operator!=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) noexcept + { return (bool)__x; } + + template + inline bool + operator!=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) noexcept + { return (bool)__x; } + + template + inline bool + operator<(const unique_ptr<_Tp, _Dp>& __x, + const unique_ptr<_Up, _Ep>& __y) + { + typedef typename + std::common_type::pointer, + typename unique_ptr<_Up, _Ep>::pointer>::type _CT; + return std::less<_CT>()(__x.get(), __y.get()); + } + + template + inline bool + operator<(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) + { return std::less::pointer>()(__x.get(), + nullptr); } + + template + inline bool + operator<(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) + { return std::less::pointer>()(nullptr, + __x.get()); } + + template + inline bool + operator<=(const unique_ptr<_Tp, _Dp>& __x, + const unique_ptr<_Up, _Ep>& __y) + { return !(__y < __x); } + + template + inline bool + operator<=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) + { return !(nullptr < __x); } + + template + inline bool + operator<=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) + { return !(__x < nullptr); } + + template + inline bool + operator>(const unique_ptr<_Tp, _Dp>& __x, + const unique_ptr<_Up, _Ep>& __y) + { return (__y < __x); } + + template + inline bool + operator>(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) + { return std::less::pointer>()(nullptr, + __x.get()); } + + template + inline bool + operator>(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) + { return std::less::pointer>()(__x.get(), + nullptr); } + + template + inline bool + operator>=(const unique_ptr<_Tp, _Dp>& __x, + const unique_ptr<_Up, _Ep>& __y) + { return !(__x < __y); } + + template + inline bool + operator>=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) + { return !(__x < nullptr); } + + template + inline bool + operator>=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) + { return !(nullptr < __x); } + + /// std::hash specialization for unique_ptr. + template + struct hash> + : public __hash_base> + { + size_t + operator()(const unique_ptr<_Tp, _Dp>& __u) const noexcept + { + typedef unique_ptr<_Tp, _Dp> _UP; + return std::hash()(__u.get()); + } + }; + +#if __cplusplus > 201103L + +#define __cpp_lib_make_unique 201304 + + template + struct _MakeUniq + { typedef unique_ptr<_Tp> __single_object; }; + + template + struct _MakeUniq<_Tp[]> + { typedef unique_ptr<_Tp[]> __array; }; + + template + struct _MakeUniq<_Tp[_Bound]> + { struct __invalid_type { }; }; + + /// std::make_unique for single objects + template + inline typename _MakeUniq<_Tp>::__single_object + make_unique(_Args&&... __args) + { return unique_ptr<_Tp>(new _Tp(std::forward<_Args>(__args)...)); } + + /// std::make_unique for arrays of unknown bound + template + inline typename _MakeUniq<_Tp>::__array + make_unique(size_t __num) + { return unique_ptr<_Tp>(new typename remove_extent<_Tp>::type[__num]()); } + + /// Disable std::make_unique for arrays of known bound + template + inline typename _MakeUniq<_Tp>::__invalid_type + make_unique(_Args&&...) = delete; +#endif + + // @} group pointer_abstractions + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif /* _UNIQUE_PTR_H */ diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/unordered_map.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/unordered_map.h new file mode 100755 index 0000000..e93663c --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/unordered_map.h @@ -0,0 +1,1475 @@ +// unordered_map implementation -*- C++ -*- + +// Copyright (C) 2010-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file bits/unordered_map.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{unordered_map} + */ + +#ifndef _UNORDERED_MAP_H +#define _UNORDERED_MAP_H + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_CONTAINER + + /// Base types for unordered_map. + template + using __umap_traits = __detail::_Hashtable_traits<_Cache, false, true>; + + template, + typename _Pred = std::equal_to<_Key>, + typename _Alloc = std::allocator >, + typename _Tr = __umap_traits<__cache_default<_Key, _Hash>::value>> + using __umap_hashtable = _Hashtable<_Key, std::pair, + _Alloc, __detail::_Select1st, + _Pred, _Hash, + __detail::_Mod_range_hashing, + __detail::_Default_ranged_hash, + __detail::_Prime_rehash_policy, _Tr>; + + /// Base types for unordered_multimap. + template + using __ummap_traits = __detail::_Hashtable_traits<_Cache, false, false>; + + template, + typename _Pred = std::equal_to<_Key>, + typename _Alloc = std::allocator >, + typename _Tr = __ummap_traits<__cache_default<_Key, _Hash>::value>> + using __ummap_hashtable = _Hashtable<_Key, std::pair, + _Alloc, __detail::_Select1st, + _Pred, _Hash, + __detail::_Mod_range_hashing, + __detail::_Default_ranged_hash, + __detail::_Prime_rehash_policy, _Tr>; + + /** + * @brief A standard container composed of unique keys (containing + * at most one of each key value) that associates values of another type + * with the keys. + * + * @ingroup unordered_associative_containers + * + * @tparam _Key Type of key objects. + * @tparam _Tp Type of mapped objects. + * @tparam _Hash Hashing function object type, defaults to hash<_Value>. + * @tparam _Pred Predicate function object type, defaults + * to equal_to<_Value>. + * @tparam _Alloc Allocator type, defaults to + * std::allocator>. + * + * Meets the requirements of a container, and + * unordered associative container + * + * The resulting value type of the container is std::pair. + * + * Base is _Hashtable, dispatched at compile time via template + * alias __umap_hashtable. + */ + template, + class _Pred = std::equal_to<_Key>, + class _Alloc = std::allocator > > + class unordered_map + { + typedef __umap_hashtable<_Key, _Tp, _Hash, _Pred, _Alloc> _Hashtable; + _Hashtable _M_h; + + public: + // typedefs: + //@{ + /// Public typedefs. + typedef typename _Hashtable::key_type key_type; + typedef typename _Hashtable::value_type value_type; + typedef typename _Hashtable::mapped_type mapped_type; + typedef typename _Hashtable::hasher hasher; + typedef typename _Hashtable::key_equal key_equal; + typedef typename _Hashtable::allocator_type allocator_type; + //@} + + //@{ + /// Iterator-related typedefs. + typedef typename _Hashtable::pointer pointer; + typedef typename _Hashtable::const_pointer const_pointer; + typedef typename _Hashtable::reference reference; + typedef typename _Hashtable::const_reference const_reference; + typedef typename _Hashtable::iterator iterator; + typedef typename _Hashtable::const_iterator const_iterator; + typedef typename _Hashtable::local_iterator local_iterator; + typedef typename _Hashtable::const_local_iterator const_local_iterator; + typedef typename _Hashtable::size_type size_type; + typedef typename _Hashtable::difference_type difference_type; + //@} + + //construct/destroy/copy + + /** + * @brief Default constructor creates no elements. + * @param __n Initial number of buckets. + * @param __hf A hash functor. + * @param __eql A key equality functor. + * @param __a An allocator object. + */ + explicit + unordered_map(size_type __n = 10, + const hasher& __hf = hasher(), + const key_equal& __eql = key_equal(), + const allocator_type& __a = allocator_type()) + : _M_h(__n, __hf, __eql, __a) + { } + + /** + * @brief Builds an %unordered_map from a range. + * @param __first An input iterator. + * @param __last An input iterator. + * @param __n Minimal initial number of buckets. + * @param __hf A hash functor. + * @param __eql A key equality functor. + * @param __a An allocator object. + * + * Create an %unordered_map consisting of copies of the elements from + * [__first,__last). This is linear in N (where N is + * distance(__first,__last)). + */ + template + unordered_map(_InputIterator __f, _InputIterator __l, + size_type __n = 0, + const hasher& __hf = hasher(), + const key_equal& __eql = key_equal(), + const allocator_type& __a = allocator_type()) + : _M_h(__f, __l, __n, __hf, __eql, __a) + { } + + /// Copy constructor. + unordered_map(const unordered_map&) = default; + + /// Move constructor. + unordered_map(unordered_map&&) = default; + + /** + * @brief Creates an %unordered_map with no elements. + * @param __a An allocator object. + */ + explicit + unordered_map(const allocator_type& __a) + : _M_h(__a) + { } + + /* + * @brief Copy constructor with allocator argument. + * @param __uset Input %unordered_map to copy. + * @param __a An allocator object. + */ + unordered_map(const unordered_map& __umap, + const allocator_type& __a) + : _M_h(__umap._M_h, __a) + { } + + /* + * @brief Move constructor with allocator argument. + * @param __uset Input %unordered_map to move. + * @param __a An allocator object. + */ + unordered_map(unordered_map&& __umap, + const allocator_type& __a) + : _M_h(std::move(__umap._M_h), __a) + { } + + /** + * @brief Builds an %unordered_map from an initializer_list. + * @param __l An initializer_list. + * @param __n Minimal initial number of buckets. + * @param __hf A hash functor. + * @param __eql A key equality functor. + * @param __a An allocator object. + * + * Create an %unordered_map consisting of copies of the elements in the + * list. This is linear in N (where N is @a __l.size()). + */ + unordered_map(initializer_list __l, + size_type __n = 0, + const hasher& __hf = hasher(), + const key_equal& __eql = key_equal(), + const allocator_type& __a = allocator_type()) + : _M_h(__l, __n, __hf, __eql, __a) + { } + + /// Copy assignment operator. + unordered_map& + operator=(const unordered_map&) = default; + + /// Move assignment operator. + unordered_map& + operator=(unordered_map&&) = default; + + /** + * @brief %Unordered_map list assignment operator. + * @param __l An initializer_list. + * + * This function fills an %unordered_map with copies of the elements in + * the initializer list @a __l. + * + * Note that the assignment completely changes the %unordered_map and + * that the resulting %unordered_map's size is the same as the number + * of elements assigned. Old data may be lost. + */ + unordered_map& + operator=(initializer_list __l) + { + _M_h = __l; + return *this; + } + + /// Returns the allocator object with which the %unordered_map was + /// constructed. + allocator_type + get_allocator() const noexcept + { return _M_h.get_allocator(); } + + // size and capacity: + + /// Returns true if the %unordered_map is empty. + bool + empty() const noexcept + { return _M_h.empty(); } + + /// Returns the size of the %unordered_map. + size_type + size() const noexcept + { return _M_h.size(); } + + /// Returns the maximum size of the %unordered_map. + size_type + max_size() const noexcept + { return _M_h.max_size(); } + + // iterators. + + /** + * Returns a read/write iterator that points to the first element in the + * %unordered_map. + */ + iterator + begin() noexcept + { return _M_h.begin(); } + + //@{ + /** + * Returns a read-only (constant) iterator that points to the first + * element in the %unordered_map. + */ + const_iterator + begin() const noexcept + { return _M_h.begin(); } + + const_iterator + cbegin() const noexcept + { return _M_h.begin(); } + //@} + + /** + * Returns a read/write iterator that points one past the last element in + * the %unordered_map. + */ + iterator + end() noexcept + { return _M_h.end(); } + + //@{ + /** + * Returns a read-only (constant) iterator that points one past the last + * element in the %unordered_map. + */ + const_iterator + end() const noexcept + { return _M_h.end(); } + + const_iterator + cend() const noexcept + { return _M_h.end(); } + //@} + + // modifiers. + + /** + * @brief Attempts to build and insert a std::pair into the %unordered_map. + * + * @param __args Arguments used to generate a new pair instance (see + * std::piecewise_contruct for passing arguments to each + * part of the pair constructor). + * + * @return A pair, of which the first element is an iterator that points + * to the possibly inserted pair, and the second is a bool that + * is true if the pair was actually inserted. + * + * This function attempts to build and insert a (key, value) %pair into + * the %unordered_map. + * An %unordered_map relies on unique keys and thus a %pair is only + * inserted if its first element (the key) is not already present in the + * %unordered_map. + * + * Insertion requires amortized constant time. + */ + template + std::pair + emplace(_Args&&... __args) + { return _M_h.emplace(std::forward<_Args>(__args)...); } + + /** + * @brief Attempts to build and insert a std::pair into the %unordered_map. + * + * @param __pos An iterator that serves as a hint as to where the pair + * should be inserted. + * @param __args Arguments used to generate a new pair instance (see + * std::piecewise_contruct for passing arguments to each + * part of the pair constructor). + * @return An iterator that points to the element with key of the + * std::pair built from @a __args (may or may not be that + * std::pair). + * + * This function is not concerned about whether the insertion took place, + * and thus does not return a boolean like the single-argument emplace() + * does. + * Note that the first parameter is only a hint and can potentially + * improve the performance of the insertion process. A bad hint would + * cause no gains in efficiency. + * + * See + * http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt07ch17.html + * for more on @a hinting. + * + * Insertion requires amortized constant time. + */ + template + iterator + emplace_hint(const_iterator __pos, _Args&&... __args) + { return _M_h.emplace_hint(__pos, std::forward<_Args>(__args)...); } + + //@{ + /** + * @brief Attempts to insert a std::pair into the %unordered_map. + + * @param __x Pair to be inserted (see std::make_pair for easy + * creation of pairs). + * + * @return A pair, of which the first element is an iterator that + * points to the possibly inserted pair, and the second is + * a bool that is true if the pair was actually inserted. + * + * This function attempts to insert a (key, value) %pair into the + * %unordered_map. An %unordered_map relies on unique keys and thus a + * %pair is only inserted if its first element (the key) is not already + * present in the %unordered_map. + * + * Insertion requires amortized constant time. + */ + std::pair + insert(const value_type& __x) + { return _M_h.insert(__x); } + + template::value>::type> + std::pair + insert(_Pair&& __x) + { return _M_h.insert(std::forward<_Pair>(__x)); } + //@} + + //@{ + /** + * @brief Attempts to insert a std::pair into the %unordered_map. + * @param __hint An iterator that serves as a hint as to where the + * pair should be inserted. + * @param __x Pair to be inserted (see std::make_pair for easy creation + * of pairs). + * @return An iterator that points to the element with key of + * @a __x (may or may not be the %pair passed in). + * + * This function is not concerned about whether the insertion took place, + * and thus does not return a boolean like the single-argument insert() + * does. Note that the first parameter is only a hint and can + * potentially improve the performance of the insertion process. A bad + * hint would cause no gains in efficiency. + * + * See + * http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt07ch17.html + * for more on @a hinting. + * + * Insertion requires amortized constant time. + */ + iterator + insert(const_iterator __hint, const value_type& __x) + { return _M_h.insert(__hint, __x); } + + template::value>::type> + iterator + insert(const_iterator __hint, _Pair&& __x) + { return _M_h.insert(__hint, std::forward<_Pair>(__x)); } + //@} + + /** + * @brief A template function that attempts to insert a range of + * elements. + * @param __first Iterator pointing to the start of the range to be + * inserted. + * @param __last Iterator pointing to the end of the range. + * + * Complexity similar to that of the range constructor. + */ + template + void + insert(_InputIterator __first, _InputIterator __last) + { _M_h.insert(__first, __last); } + + /** + * @brief Attempts to insert a list of elements into the %unordered_map. + * @param __l A std::initializer_list of elements + * to be inserted. + * + * Complexity similar to that of the range constructor. + */ + void + insert(initializer_list __l) + { _M_h.insert(__l); } + + //@{ + /** + * @brief Erases an element from an %unordered_map. + * @param __position An iterator pointing to the element to be erased. + * @return An iterator pointing to the element immediately following + * @a __position prior to the element being erased. If no such + * element exists, end() is returned. + * + * This function erases an element, pointed to by the given iterator, + * from an %unordered_map. + * Note that this function only erases the element, and that if the + * element is itself a pointer, the pointed-to memory is not touched in + * any way. Managing the pointer is the user's responsibility. + */ + iterator + erase(const_iterator __position) + { return _M_h.erase(__position); } + + // LWG 2059. + iterator + erase(iterator __it) + { return _M_h.erase(__it); } + //@} + + /** + * @brief Erases elements according to the provided key. + * @param __x Key of element to be erased. + * @return The number of elements erased. + * + * This function erases all the elements located by the given key from + * an %unordered_map. For an %unordered_map the result of this function + * can only be 0 (not present) or 1 (present). + * Note that this function only erases the element, and that if the + * element is itself a pointer, the pointed-to memory is not touched in + * any way. Managing the pointer is the user's responsibility. + */ + size_type + erase(const key_type& __x) + { return _M_h.erase(__x); } + + /** + * @brief Erases a [__first,__last) range of elements from an + * %unordered_map. + * @param __first Iterator pointing to the start of the range to be + * erased. + * @param __last Iterator pointing to the end of the range to + * be erased. + * @return The iterator @a __last. + * + * This function erases a sequence of elements from an %unordered_map. + * Note that this function only erases the elements, and that if + * the element is itself a pointer, the pointed-to memory is not touched + * in any way. Managing the pointer is the user's responsibility. + */ + iterator + erase(const_iterator __first, const_iterator __last) + { return _M_h.erase(__first, __last); } + + /** + * Erases all elements in an %unordered_map. + * Note that this function only erases the elements, and that if the + * elements themselves are pointers, the pointed-to memory is not touched + * in any way. Managing the pointer is the user's responsibility. + */ + void + clear() noexcept + { _M_h.clear(); } + + /** + * @brief Swaps data with another %unordered_map. + * @param __x An %unordered_map of the same element and allocator + * types. + * + * This exchanges the elements between two %unordered_map in constant time. + * Note that the global std::swap() function is specialized such that + * std::swap(m1,m2) will feed to this function. + */ + void + swap(unordered_map& __x) + noexcept( noexcept(_M_h.swap(__x._M_h)) ) + { _M_h.swap(__x._M_h); } + + // observers. + + /// Returns the hash functor object with which the %unordered_map was + /// constructed. + hasher + hash_function() const + { return _M_h.hash_function(); } + + /// Returns the key comparison object with which the %unordered_map was + /// constructed. + key_equal + key_eq() const + { return _M_h.key_eq(); } + + // lookup. + + //@{ + /** + * @brief Tries to locate an element in an %unordered_map. + * @param __x Key to be located. + * @return Iterator pointing to sought-after element, or end() if not + * found. + * + * This function takes a key and tries to locate the element with which + * the key matches. If successful the function returns an iterator + * pointing to the sought after element. If unsuccessful it returns the + * past-the-end ( @c end() ) iterator. + */ + iterator + find(const key_type& __x) + { return _M_h.find(__x); } + + const_iterator + find(const key_type& __x) const + { return _M_h.find(__x); } + //@} + + /** + * @brief Finds the number of elements. + * @param __x Key to count. + * @return Number of elements with specified key. + * + * This function only makes sense for %unordered_multimap; for + * %unordered_map the result will either be 0 (not present) or 1 + * (present). + */ + size_type + count(const key_type& __x) const + { return _M_h.count(__x); } + + //@{ + /** + * @brief Finds a subsequence matching given key. + * @param __x Key to be located. + * @return Pair of iterators that possibly points to the subsequence + * matching given key. + * + * This function probably only makes sense for %unordered_multimap. + */ + std::pair + equal_range(const key_type& __x) + { return _M_h.equal_range(__x); } + + std::pair + equal_range(const key_type& __x) const + { return _M_h.equal_range(__x); } + //@} + + //@{ + /** + * @brief Subscript ( @c [] ) access to %unordered_map data. + * @param __k The key for which data should be retrieved. + * @return A reference to the data of the (key,data) %pair. + * + * Allows for easy lookup with the subscript ( @c [] )operator. Returns + * data associated with the key specified in subscript. If the key does + * not exist, a pair with that key is created using default values, which + * is then returned. + * + * Lookup requires constant time. + */ + mapped_type& + operator[](const key_type& __k) + { return _M_h[__k]; } + + mapped_type& + operator[](key_type&& __k) + { return _M_h[std::move(__k)]; } + //@} + + //@{ + /** + * @brief Access to %unordered_map data. + * @param __k The key for which data should be retrieved. + * @return A reference to the data whose key is equal to @a __k, if + * such a data is present in the %unordered_map. + * @throw std::out_of_range If no such data is present. + */ + mapped_type& + at(const key_type& __k) + { return _M_h.at(__k); } + + const mapped_type& + at(const key_type& __k) const + { return _M_h.at(__k); } + //@} + + // bucket interface. + + /// Returns the number of buckets of the %unordered_map. + size_type + bucket_count() const noexcept + { return _M_h.bucket_count(); } + + /// Returns the maximum number of buckets of the %unordered_map. + size_type + max_bucket_count() const noexcept + { return _M_h.max_bucket_count(); } + + /* + * @brief Returns the number of elements in a given bucket. + * @param __n A bucket index. + * @return The number of elements in the bucket. + */ + size_type + bucket_size(size_type __n) const + { return _M_h.bucket_size(__n); } + + /* + * @brief Returns the bucket index of a given element. + * @param __key A key instance. + * @return The key bucket index. + */ + size_type + bucket(const key_type& __key) const + { return _M_h.bucket(__key); } + + /** + * @brief Returns a read/write iterator pointing to the first bucket + * element. + * @param __n The bucket index. + * @return A read/write local iterator. + */ + local_iterator + begin(size_type __n) + { return _M_h.begin(__n); } + + //@{ + /** + * @brief Returns a read-only (constant) iterator pointing to the first + * bucket element. + * @param __n The bucket index. + * @return A read-only local iterator. + */ + const_local_iterator + begin(size_type __n) const + { return _M_h.begin(__n); } + + const_local_iterator + cbegin(size_type __n) const + { return _M_h.cbegin(__n); } + //@} + + /** + * @brief Returns a read/write iterator pointing to one past the last + * bucket elements. + * @param __n The bucket index. + * @return A read/write local iterator. + */ + local_iterator + end(size_type __n) + { return _M_h.end(__n); } + + //@{ + /** + * @brief Returns a read-only (constant) iterator pointing to one past + * the last bucket elements. + * @param __n The bucket index. + * @return A read-only local iterator. + */ + const_local_iterator + end(size_type __n) const + { return _M_h.end(__n); } + + const_local_iterator + cend(size_type __n) const + { return _M_h.cend(__n); } + //@} + + // hash policy. + + /// Returns the average number of elements per bucket. + float + load_factor() const noexcept + { return _M_h.load_factor(); } + + /// Returns a positive number that the %unordered_map tries to keep the + /// load factor less than or equal to. + float + max_load_factor() const noexcept + { return _M_h.max_load_factor(); } + + /** + * @brief Change the %unordered_map maximum load factor. + * @param __z The new maximum load factor. + */ + void + max_load_factor(float __z) + { _M_h.max_load_factor(__z); } + + /** + * @brief May rehash the %unordered_map. + * @param __n The new number of buckets. + * + * Rehash will occur only if the new number of buckets respect the + * %unordered_map maximum load factor. + */ + void + rehash(size_type __n) + { _M_h.rehash(__n); } + + /** + * @brief Prepare the %unordered_map for a specified number of + * elements. + * @param __n Number of elements required. + * + * Same as rehash(ceil(n / max_load_factor())). + */ + void + reserve(size_type __n) + { _M_h.reserve(__n); } + + template + friend bool + operator==(const unordered_map<_Key1, _Tp1, _Hash1, _Pred1, _Alloc1>&, + const unordered_map<_Key1, _Tp1, _Hash1, _Pred1, _Alloc1>&); + }; + + /** + * @brief A standard container composed of equivalent keys + * (possibly containing multiple of each key value) that associates + * values of another type with the keys. + * + * @ingroup unordered_associative_containers + * + * @tparam _Key Type of key objects. + * @tparam _Tp Type of mapped objects. + * @tparam _Hash Hashing function object type, defaults to hash<_Value>. + * @tparam _Pred Predicate function object type, defaults + * to equal_to<_Value>. + * @tparam _Alloc Allocator type, defaults to + * std::allocator>. + * + * Meets the requirements of a container, and + * unordered associative container + * + * The resulting value type of the container is std::pair. + * + * Base is _Hashtable, dispatched at compile time via template + * alias __ummap_hashtable. + */ + template, + class _Pred = std::equal_to<_Key>, + class _Alloc = std::allocator > > + class unordered_multimap + { + typedef __ummap_hashtable<_Key, _Tp, _Hash, _Pred, _Alloc> _Hashtable; + _Hashtable _M_h; + + public: + // typedefs: + //@{ + /// Public typedefs. + typedef typename _Hashtable::key_type key_type; + typedef typename _Hashtable::value_type value_type; + typedef typename _Hashtable::mapped_type mapped_type; + typedef typename _Hashtable::hasher hasher; + typedef typename _Hashtable::key_equal key_equal; + typedef typename _Hashtable::allocator_type allocator_type; + //@} + + //@{ + /// Iterator-related typedefs. + typedef typename _Hashtable::pointer pointer; + typedef typename _Hashtable::const_pointer const_pointer; + typedef typename _Hashtable::reference reference; + typedef typename _Hashtable::const_reference const_reference; + typedef typename _Hashtable::iterator iterator; + typedef typename _Hashtable::const_iterator const_iterator; + typedef typename _Hashtable::local_iterator local_iterator; + typedef typename _Hashtable::const_local_iterator const_local_iterator; + typedef typename _Hashtable::size_type size_type; + typedef typename _Hashtable::difference_type difference_type; + //@} + + //construct/destroy/copy + + /** + * @brief Default constructor creates no elements. + * @param __n Initial number of buckets. + * @param __hf A hash functor. + * @param __eql A key equality functor. + * @param __a An allocator object. + */ + explicit + unordered_multimap(size_type __n = 10, + const hasher& __hf = hasher(), + const key_equal& __eql = key_equal(), + const allocator_type& __a = allocator_type()) + : _M_h(__n, __hf, __eql, __a) + { } + + /** + * @brief Builds an %unordered_multimap from a range. + * @param __first An input iterator. + * @param __last An input iterator. + * @param __n Minimal initial number of buckets. + * @param __hf A hash functor. + * @param __eql A key equality functor. + * @param __a An allocator object. + * + * Create an %unordered_multimap consisting of copies of the elements + * from [__first,__last). This is linear in N (where N is + * distance(__first,__last)). + */ + template + unordered_multimap(_InputIterator __f, _InputIterator __l, + size_type __n = 0, + const hasher& __hf = hasher(), + const key_equal& __eql = key_equal(), + const allocator_type& __a = allocator_type()) + : _M_h(__f, __l, __n, __hf, __eql, __a) + { } + + /// Copy constructor. + unordered_multimap(const unordered_multimap&) = default; + + /// Move constructor. + unordered_multimap(unordered_multimap&&) = default; + + /** + * @brief Creates an %unordered_multimap with no elements. + * @param __a An allocator object. + */ + explicit + unordered_multimap(const allocator_type& __a) + : _M_h(__a) + { } + + /* + * @brief Copy constructor with allocator argument. + * @param __uset Input %unordered_multimap to copy. + * @param __a An allocator object. + */ + unordered_multimap(const unordered_multimap& __ummap, + const allocator_type& __a) + : _M_h(__ummap._M_h, __a) + { } + + /* + * @brief Move constructor with allocator argument. + * @param __uset Input %unordered_multimap to move. + * @param __a An allocator object. + */ + unordered_multimap(unordered_multimap&& __ummap, + const allocator_type& __a) + : _M_h(std::move(__ummap._M_h), __a) + { } + + /** + * @brief Builds an %unordered_multimap from an initializer_list. + * @param __l An initializer_list. + * @param __n Minimal initial number of buckets. + * @param __hf A hash functor. + * @param __eql A key equality functor. + * @param __a An allocator object. + * + * Create an %unordered_multimap consisting of copies of the elements in + * the list. This is linear in N (where N is @a __l.size()). + */ + unordered_multimap(initializer_list __l, + size_type __n = 0, + const hasher& __hf = hasher(), + const key_equal& __eql = key_equal(), + const allocator_type& __a = allocator_type()) + : _M_h(__l, __n, __hf, __eql, __a) + { } + + /// Copy assignment operator. + unordered_multimap& + operator=(const unordered_multimap&) = default; + + /// Move assignment operator. + unordered_multimap& + operator=(unordered_multimap&&) = default; + + /** + * @brief %Unordered_multimap list assignment operator. + * @param __l An initializer_list. + * + * This function fills an %unordered_multimap with copies of the elements + * in the initializer list @a __l. + * + * Note that the assignment completely changes the %unordered_multimap + * and that the resulting %unordered_multimap's size is the same as the + * number of elements assigned. Old data may be lost. + */ + unordered_multimap& + operator=(initializer_list __l) + { + _M_h = __l; + return *this; + } + + /// Returns the allocator object with which the %unordered_multimap was + /// constructed. + allocator_type + get_allocator() const noexcept + { return _M_h.get_allocator(); } + + // size and capacity: + + /// Returns true if the %unordered_multimap is empty. + bool + empty() const noexcept + { return _M_h.empty(); } + + /// Returns the size of the %unordered_multimap. + size_type + size() const noexcept + { return _M_h.size(); } + + /// Returns the maximum size of the %unordered_multimap. + size_type + max_size() const noexcept + { return _M_h.max_size(); } + + // iterators. + + /** + * Returns a read/write iterator that points to the first element in the + * %unordered_multimap. + */ + iterator + begin() noexcept + { return _M_h.begin(); } + + //@{ + /** + * Returns a read-only (constant) iterator that points to the first + * element in the %unordered_multimap. + */ + const_iterator + begin() const noexcept + { return _M_h.begin(); } + + const_iterator + cbegin() const noexcept + { return _M_h.begin(); } + //@} + + /** + * Returns a read/write iterator that points one past the last element in + * the %unordered_multimap. + */ + iterator + end() noexcept + { return _M_h.end(); } + + //@{ + /** + * Returns a read-only (constant) iterator that points one past the last + * element in the %unordered_multimap. + */ + const_iterator + end() const noexcept + { return _M_h.end(); } + + const_iterator + cend() const noexcept + { return _M_h.end(); } + //@} + + // modifiers. + + /** + * @brief Attempts to build and insert a std::pair into the + * %unordered_multimap. + * + * @param __args Arguments used to generate a new pair instance (see + * std::piecewise_contruct for passing arguments to each + * part of the pair constructor). + * + * @return An iterator that points to the inserted pair. + * + * This function attempts to build and insert a (key, value) %pair into + * the %unordered_multimap. + * + * Insertion requires amortized constant time. + */ + template + iterator + emplace(_Args&&... __args) + { return _M_h.emplace(std::forward<_Args>(__args)...); } + + /** + * @brief Attempts to build and insert a std::pair into the %unordered_multimap. + * + * @param __pos An iterator that serves as a hint as to where the pair + * should be inserted. + * @param __args Arguments used to generate a new pair instance (see + * std::piecewise_contruct for passing arguments to each + * part of the pair constructor). + * @return An iterator that points to the element with key of the + * std::pair built from @a __args. + * + * Note that the first parameter is only a hint and can potentially + * improve the performance of the insertion process. A bad hint would + * cause no gains in efficiency. + * + * See + * http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt07ch17.html + * for more on @a hinting. + * + * Insertion requires amortized constant time. + */ + template + iterator + emplace_hint(const_iterator __pos, _Args&&... __args) + { return _M_h.emplace_hint(__pos, std::forward<_Args>(__args)...); } + + //@{ + /** + * @brief Inserts a std::pair into the %unordered_multimap. + * @param __x Pair to be inserted (see std::make_pair for easy + * creation of pairs). + * + * @return An iterator that points to the inserted pair. + * + * Insertion requires amortized constant time. + */ + iterator + insert(const value_type& __x) + { return _M_h.insert(__x); } + + template::value>::type> + iterator + insert(_Pair&& __x) + { return _M_h.insert(std::forward<_Pair>(__x)); } + //@} + + //@{ + /** + * @brief Inserts a std::pair into the %unordered_multimap. + * @param __hint An iterator that serves as a hint as to where the + * pair should be inserted. + * @param __x Pair to be inserted (see std::make_pair for easy creation + * of pairs). + * @return An iterator that points to the element with key of + * @a __x (may or may not be the %pair passed in). + * + * Note that the first parameter is only a hint and can potentially + * improve the performance of the insertion process. A bad hint would + * cause no gains in efficiency. + * + * See + * http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt07ch17.html + * for more on @a hinting. + * + * Insertion requires amortized constant time. + */ + iterator + insert(const_iterator __hint, const value_type& __x) + { return _M_h.insert(__hint, __x); } + + template::value>::type> + iterator + insert(const_iterator __hint, _Pair&& __x) + { return _M_h.insert(__hint, std::forward<_Pair>(__x)); } + //@} + + /** + * @brief A template function that attempts to insert a range of + * elements. + * @param __first Iterator pointing to the start of the range to be + * inserted. + * @param __last Iterator pointing to the end of the range. + * + * Complexity similar to that of the range constructor. + */ + template + void + insert(_InputIterator __first, _InputIterator __last) + { _M_h.insert(__first, __last); } + + /** + * @brief Attempts to insert a list of elements into the + * %unordered_multimap. + * @param __l A std::initializer_list of elements + * to be inserted. + * + * Complexity similar to that of the range constructor. + */ + void + insert(initializer_list __l) + { _M_h.insert(__l); } + + //@{ + /** + * @brief Erases an element from an %unordered_multimap. + * @param __position An iterator pointing to the element to be erased. + * @return An iterator pointing to the element immediately following + * @a __position prior to the element being erased. If no such + * element exists, end() is returned. + * + * This function erases an element, pointed to by the given iterator, + * from an %unordered_multimap. + * Note that this function only erases the element, and that if the + * element is itself a pointer, the pointed-to memory is not touched in + * any way. Managing the pointer is the user's responsibility. + */ + iterator + erase(const_iterator __position) + { return _M_h.erase(__position); } + + // LWG 2059. + iterator + erase(iterator __it) + { return _M_h.erase(__it); } + //@} + + /** + * @brief Erases elements according to the provided key. + * @param __x Key of elements to be erased. + * @return The number of elements erased. + * + * This function erases all the elements located by the given key from + * an %unordered_multimap. + * Note that this function only erases the element, and that if the + * element is itself a pointer, the pointed-to memory is not touched in + * any way. Managing the pointer is the user's responsibility. + */ + size_type + erase(const key_type& __x) + { return _M_h.erase(__x); } + + /** + * @brief Erases a [__first,__last) range of elements from an + * %unordered_multimap. + * @param __first Iterator pointing to the start of the range to be + * erased. + * @param __last Iterator pointing to the end of the range to + * be erased. + * @return The iterator @a __last. + * + * This function erases a sequence of elements from an + * %unordered_multimap. + * Note that this function only erases the elements, and that if + * the element is itself a pointer, the pointed-to memory is not touched + * in any way. Managing the pointer is the user's responsibility. + */ + iterator + erase(const_iterator __first, const_iterator __last) + { return _M_h.erase(__first, __last); } + + /** + * Erases all elements in an %unordered_multimap. + * Note that this function only erases the elements, and that if the + * elements themselves are pointers, the pointed-to memory is not touched + * in any way. Managing the pointer is the user's responsibility. + */ + void + clear() noexcept + { _M_h.clear(); } + + /** + * @brief Swaps data with another %unordered_multimap. + * @param __x An %unordered_multimap of the same element and allocator + * types. + * + * This exchanges the elements between two %unordered_multimap in + * constant time. + * Note that the global std::swap() function is specialized such that + * std::swap(m1,m2) will feed to this function. + */ + void + swap(unordered_multimap& __x) + noexcept( noexcept(_M_h.swap(__x._M_h)) ) + { _M_h.swap(__x._M_h); } + + // observers. + + /// Returns the hash functor object with which the %unordered_multimap + /// was constructed. + hasher + hash_function() const + { return _M_h.hash_function(); } + + /// Returns the key comparison object with which the %unordered_multimap + /// was constructed. + key_equal + key_eq() const + { return _M_h.key_eq(); } + + // lookup. + + //@{ + /** + * @brief Tries to locate an element in an %unordered_multimap. + * @param __x Key to be located. + * @return Iterator pointing to sought-after element, or end() if not + * found. + * + * This function takes a key and tries to locate the element with which + * the key matches. If successful the function returns an iterator + * pointing to the sought after element. If unsuccessful it returns the + * past-the-end ( @c end() ) iterator. + */ + iterator + find(const key_type& __x) + { return _M_h.find(__x); } + + const_iterator + find(const key_type& __x) const + { return _M_h.find(__x); } + //@} + + /** + * @brief Finds the number of elements. + * @param __x Key to count. + * @return Number of elements with specified key. + */ + size_type + count(const key_type& __x) const + { return _M_h.count(__x); } + + //@{ + /** + * @brief Finds a subsequence matching given key. + * @param __x Key to be located. + * @return Pair of iterators that possibly points to the subsequence + * matching given key. + */ + std::pair + equal_range(const key_type& __x) + { return _M_h.equal_range(__x); } + + std::pair + equal_range(const key_type& __x) const + { return _M_h.equal_range(__x); } + //@} + + // bucket interface. + + /// Returns the number of buckets of the %unordered_multimap. + size_type + bucket_count() const noexcept + { return _M_h.bucket_count(); } + + /// Returns the maximum number of buckets of the %unordered_multimap. + size_type + max_bucket_count() const noexcept + { return _M_h.max_bucket_count(); } + + /* + * @brief Returns the number of elements in a given bucket. + * @param __n A bucket index. + * @return The number of elements in the bucket. + */ + size_type + bucket_size(size_type __n) const + { return _M_h.bucket_size(__n); } + + /* + * @brief Returns the bucket index of a given element. + * @param __key A key instance. + * @return The key bucket index. + */ + size_type + bucket(const key_type& __key) const + { return _M_h.bucket(__key); } + + /** + * @brief Returns a read/write iterator pointing to the first bucket + * element. + * @param __n The bucket index. + * @return A read/write local iterator. + */ + local_iterator + begin(size_type __n) + { return _M_h.begin(__n); } + + //@{ + /** + * @brief Returns a read-only (constant) iterator pointing to the first + * bucket element. + * @param __n The bucket index. + * @return A read-only local iterator. + */ + const_local_iterator + begin(size_type __n) const + { return _M_h.begin(__n); } + + const_local_iterator + cbegin(size_type __n) const + { return _M_h.cbegin(__n); } + //@} + + /** + * @brief Returns a read/write iterator pointing to one past the last + * bucket elements. + * @param __n The bucket index. + * @return A read/write local iterator. + */ + local_iterator + end(size_type __n) + { return _M_h.end(__n); } + + //@{ + /** + * @brief Returns a read-only (constant) iterator pointing to one past + * the last bucket elements. + * @param __n The bucket index. + * @return A read-only local iterator. + */ + const_local_iterator + end(size_type __n) const + { return _M_h.end(__n); } + + const_local_iterator + cend(size_type __n) const + { return _M_h.cend(__n); } + //@} + + // hash policy. + + /// Returns the average number of elements per bucket. + float + load_factor() const noexcept + { return _M_h.load_factor(); } + + /// Returns a positive number that the %unordered_multimap tries to keep + /// the load factor less than or equal to. + float + max_load_factor() const noexcept + { return _M_h.max_load_factor(); } + + /** + * @brief Change the %unordered_multimap maximum load factor. + * @param __z The new maximum load factor. + */ + void + max_load_factor(float __z) + { _M_h.max_load_factor(__z); } + + /** + * @brief May rehash the %unordered_multimap. + * @param __n The new number of buckets. + * + * Rehash will occur only if the new number of buckets respect the + * %unordered_multimap maximum load factor. + */ + void + rehash(size_type __n) + { _M_h.rehash(__n); } + + /** + * @brief Prepare the %unordered_multimap for a specified number of + * elements. + * @param __n Number of elements required. + * + * Same as rehash(ceil(n / max_load_factor())). + */ + void + reserve(size_type __n) + { _M_h.reserve(__n); } + + template + friend bool + operator==(const unordered_multimap<_Key1, _Tp1, + _Hash1, _Pred1, _Alloc1>&, + const unordered_multimap<_Key1, _Tp1, + _Hash1, _Pred1, _Alloc1>&); + }; + + template + inline void + swap(unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x, + unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y) + { __x.swap(__y); } + + template + inline void + swap(unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x, + unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y) + { __x.swap(__y); } + + template + inline bool + operator==(const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x, + const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y) + { return __x._M_h._M_equal(__y._M_h); } + + template + inline bool + operator!=(const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x, + const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y) + { return !(__x == __y); } + + template + inline bool + operator==(const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x, + const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y) + { return __x._M_h._M_equal(__y._M_h); } + + template + inline bool + operator!=(const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x, + const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y) + { return !(__x == __y); } + +_GLIBCXX_END_NAMESPACE_CONTAINER +} // namespace std + +#endif /* _UNORDERED_MAP_H */ diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/unordered_set.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/unordered_set.h new file mode 100755 index 0000000..e810f97 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/unordered_set.h @@ -0,0 +1,1356 @@ +// unordered_set implementation -*- C++ -*- + +// Copyright (C) 2010-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file bits/unordered_set.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{unordered_set} + */ + +#ifndef _UNORDERED_SET_H +#define _UNORDERED_SET_H + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_CONTAINER + + /// Base types for unordered_set. + template + using __uset_traits = __detail::_Hashtable_traits<_Cache, true, true>; + + template, + typename _Pred = std::equal_to<_Value>, + typename _Alloc = std::allocator<_Value>, + typename _Tr = __uset_traits<__cache_default<_Value, _Hash>::value>> + using __uset_hashtable = _Hashtable<_Value, _Value, _Alloc, + __detail::_Identity, _Pred, _Hash, + __detail::_Mod_range_hashing, + __detail::_Default_ranged_hash, + __detail::_Prime_rehash_policy, _Tr>; + + /// Base types for unordered_multiset. + template + using __umset_traits = __detail::_Hashtable_traits<_Cache, true, false>; + + template, + typename _Pred = std::equal_to<_Value>, + typename _Alloc = std::allocator<_Value>, + typename _Tr = __umset_traits<__cache_default<_Value, _Hash>::value>> + using __umset_hashtable = _Hashtable<_Value, _Value, _Alloc, + __detail::_Identity, + _Pred, _Hash, + __detail::_Mod_range_hashing, + __detail::_Default_ranged_hash, + __detail::_Prime_rehash_policy, _Tr>; + + /** + * @brief A standard container composed of unique keys (containing + * at most one of each key value) in which the elements' keys are + * the elements themselves. + * + * @ingroup unordered_associative_containers + * + * @tparam _Value Type of key objects. + * @tparam _Hash Hashing function object type, defaults to hash<_Value>. + + * @tparam _Pred Predicate function object type, defaults to + * equal_to<_Value>. + * + * @tparam _Alloc Allocator type, defaults to allocator<_Key>. + * + * Meets the requirements of a container, and + * unordered associative container + * + * Base is _Hashtable, dispatched at compile time via template + * alias __uset_hashtable. + */ + template, + class _Pred = std::equal_to<_Value>, + class _Alloc = std::allocator<_Value> > + class unordered_set + { + typedef __uset_hashtable<_Value, _Hash, _Pred, _Alloc> _Hashtable; + _Hashtable _M_h; + + public: + // typedefs: + //@{ + /// Public typedefs. + typedef typename _Hashtable::key_type key_type; + typedef typename _Hashtable::value_type value_type; + typedef typename _Hashtable::hasher hasher; + typedef typename _Hashtable::key_equal key_equal; + typedef typename _Hashtable::allocator_type allocator_type; + //@} + + //@{ + /// Iterator-related typedefs. + typedef typename _Hashtable::pointer pointer; + typedef typename _Hashtable::const_pointer const_pointer; + typedef typename _Hashtable::reference reference; + typedef typename _Hashtable::const_reference const_reference; + typedef typename _Hashtable::iterator iterator; + typedef typename _Hashtable::const_iterator const_iterator; + typedef typename _Hashtable::local_iterator local_iterator; + typedef typename _Hashtable::const_local_iterator const_local_iterator; + typedef typename _Hashtable::size_type size_type; + typedef typename _Hashtable::difference_type difference_type; + //@} + + // construct/destroy/copy + /** + * @brief Default constructor creates no elements. + * @param __n Initial number of buckets. + * @param __hf A hash functor. + * @param __eql A key equality functor. + * @param __a An allocator object. + */ + explicit + unordered_set(size_type __n = 10, + const hasher& __hf = hasher(), + const key_equal& __eql = key_equal(), + const allocator_type& __a = allocator_type()) + : _M_h(__n, __hf, __eql, __a) + { } + + /** + * @brief Builds an %unordered_set from a range. + * @param __first An input iterator. + * @param __last An input iterator. + * @param __n Minimal initial number of buckets. + * @param __hf A hash functor. + * @param __eql A key equality functor. + * @param __a An allocator object. + * + * Create an %unordered_set consisting of copies of the elements from + * [__first,__last). This is linear in N (where N is + * distance(__first,__last)). + */ + template + unordered_set(_InputIterator __f, _InputIterator __l, + size_type __n = 0, + const hasher& __hf = hasher(), + const key_equal& __eql = key_equal(), + const allocator_type& __a = allocator_type()) + : _M_h(__f, __l, __n, __hf, __eql, __a) + { } + + /// Copy constructor. + unordered_set(const unordered_set&) = default; + + /// Move constructor. + unordered_set(unordered_set&&) = default; + + /** + * @brief Creates an %unordered_set with no elements. + * @param __a An allocator object. + */ + explicit + unordered_set(const allocator_type& __a) + : _M_h(__a) + { } + + /* + * @brief Copy constructor with allocator argument. + * @param __uset Input %unordered_set to copy. + * @param __a An allocator object. + */ + unordered_set(const unordered_set& __uset, + const allocator_type& __a) + : _M_h(__uset._M_h, __a) + { } + + /* + * @brief Move constructor with allocator argument. + * @param __uset Input %unordered_set to move. + * @param __a An allocator object. + */ + unordered_set(unordered_set&& __uset, + const allocator_type& __a) + : _M_h(std::move(__uset._M_h), __a) + { } + + /** + * @brief Builds an %unordered_set from an initializer_list. + * @param __l An initializer_list. + * @param __n Minimal initial number of buckets. + * @param __hf A hash functor. + * @param __eql A key equality functor. + * @param __a An allocator object. + * + * Create an %unordered_set consisting of copies of the elements in the + * list. This is linear in N (where N is @a __l.size()). + */ + unordered_set(initializer_list __l, + size_type __n = 0, + const hasher& __hf = hasher(), + const key_equal& __eql = key_equal(), + const allocator_type& __a = allocator_type()) + : _M_h(__l, __n, __hf, __eql, __a) + { } + + /// Copy assignment operator. + unordered_set& + operator=(const unordered_set&) = default; + + /// Move assignment operator. + unordered_set& + operator=(unordered_set&&) = default; + + /** + * @brief %Unordered_set list assignment operator. + * @param __l An initializer_list. + * + * This function fills an %unordered_set with copies of the elements in + * the initializer list @a __l. + * + * Note that the assignment completely changes the %unordered_set and + * that the resulting %unordered_set's size is the same as the number + * of elements assigned. Old data may be lost. + */ + unordered_set& + operator=(initializer_list __l) + { + _M_h = __l; + return *this; + } + + /// Returns the allocator object with which the %unordered_set was + /// constructed. + allocator_type + get_allocator() const noexcept + { return _M_h.get_allocator(); } + + // size and capacity: + + /// Returns true if the %unordered_set is empty. + bool + empty() const noexcept + { return _M_h.empty(); } + + /// Returns the size of the %unordered_set. + size_type + size() const noexcept + { return _M_h.size(); } + + /// Returns the maximum size of the %unordered_set. + size_type + max_size() const noexcept + { return _M_h.max_size(); } + + // iterators. + + //@{ + /** + * Returns a read-only (constant) iterator that points to the first + * element in the %unordered_set. + */ + iterator + begin() noexcept + { return _M_h.begin(); } + + const_iterator + begin() const noexcept + { return _M_h.begin(); } + //@} + + //@{ + /** + * Returns a read-only (constant) iterator that points one past the last + * element in the %unordered_set. + */ + iterator + end() noexcept + { return _M_h.end(); } + + const_iterator + end() const noexcept + { return _M_h.end(); } + //@} + + /** + * Returns a read-only (constant) iterator that points to the first + * element in the %unordered_set. + */ + const_iterator + cbegin() const noexcept + { return _M_h.begin(); } + + /** + * Returns a read-only (constant) iterator that points one past the last + * element in the %unordered_set. + */ + const_iterator + cend() const noexcept + { return _M_h.end(); } + + // modifiers. + + /** + * @brief Attempts to build and insert an element into the + * %unordered_set. + * @param __args Arguments used to generate an element. + * @return A pair, of which the first element is an iterator that points + * to the possibly inserted element, and the second is a bool + * that is true if the element was actually inserted. + * + * This function attempts to build and insert an element into the + * %unordered_set. An %unordered_set relies on unique keys and thus an + * element is only inserted if it is not already present in the + * %unordered_set. + * + * Insertion requires amortized constant time. + */ + template + std::pair + emplace(_Args&&... __args) + { return _M_h.emplace(std::forward<_Args>(__args)...); } + + /** + * @brief Attempts to insert an element into the %unordered_set. + * @param __pos An iterator that serves as a hint as to where the + * element should be inserted. + * @param __args Arguments used to generate the element to be + * inserted. + * @return An iterator that points to the element with key equivalent to + * the one generated from @a __args (may or may not be the + * element itself). + * + * This function is not concerned about whether the insertion took place, + * and thus does not return a boolean like the single-argument emplace() + * does. Note that the first parameter is only a hint and can + * potentially improve the performance of the insertion process. A bad + * hint would cause no gains in efficiency. + * + * For more on @a hinting, see: + * http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt07ch17.html + * + * Insertion requires amortized constant time. + */ + template + iterator + emplace_hint(const_iterator __pos, _Args&&... __args) + { return _M_h.emplace_hint(__pos, std::forward<_Args>(__args)...); } + + //@{ + /** + * @brief Attempts to insert an element into the %unordered_set. + * @param __x Element to be inserted. + * @return A pair, of which the first element is an iterator that points + * to the possibly inserted element, and the second is a bool + * that is true if the element was actually inserted. + * + * This function attempts to insert an element into the %unordered_set. + * An %unordered_set relies on unique keys and thus an element is only + * inserted if it is not already present in the %unordered_set. + * + * Insertion requires amortized constant time. + */ + std::pair + insert(const value_type& __x) + { return _M_h.insert(__x); } + + std::pair + insert(value_type&& __x) + { return _M_h.insert(std::move(__x)); } + //@} + + //@{ + /** + * @brief Attempts to insert an element into the %unordered_set. + * @param __hint An iterator that serves as a hint as to where the + * element should be inserted. + * @param __x Element to be inserted. + * @return An iterator that points to the element with key of + * @a __x (may or may not be the element passed in). + * + * This function is not concerned about whether the insertion took place, + * and thus does not return a boolean like the single-argument insert() + * does. Note that the first parameter is only a hint and can + * potentially improve the performance of the insertion process. A bad + * hint would cause no gains in efficiency. + * + * For more on @a hinting, see: + * http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt07ch17.html + * + * Insertion requires amortized constant. + */ + iterator + insert(const_iterator __hint, const value_type& __x) + { return _M_h.insert(__hint, __x); } + + iterator + insert(const_iterator __hint, value_type&& __x) + { return _M_h.insert(__hint, std::move(__x)); } + //@} + + /** + * @brief A template function that attempts to insert a range of + * elements. + * @param __first Iterator pointing to the start of the range to be + * inserted. + * @param __last Iterator pointing to the end of the range. + * + * Complexity similar to that of the range constructor. + */ + template + void + insert(_InputIterator __first, _InputIterator __last) + { _M_h.insert(__first, __last); } + + /** + * @brief Attempts to insert a list of elements into the %unordered_set. + * @param __l A std::initializer_list of elements + * to be inserted. + * + * Complexity similar to that of the range constructor. + */ + void + insert(initializer_list __l) + { _M_h.insert(__l); } + + //@{ + /** + * @brief Erases an element from an %unordered_set. + * @param __position An iterator pointing to the element to be erased. + * @return An iterator pointing to the element immediately following + * @a __position prior to the element being erased. If no such + * element exists, end() is returned. + * + * This function erases an element, pointed to by the given iterator, + * from an %unordered_set. Note that this function only erases the + * element, and that if the element is itself a pointer, the pointed-to + * memory is not touched in any way. Managing the pointer is the user's + * responsibility. + */ + iterator + erase(const_iterator __position) + { return _M_h.erase(__position); } + + // LWG 2059. + iterator + erase(iterator __it) + { return _M_h.erase(__it); } + //@} + + /** + * @brief Erases elements according to the provided key. + * @param __x Key of element to be erased. + * @return The number of elements erased. + * + * This function erases all the elements located by the given key from + * an %unordered_set. For an %unordered_set the result of this function + * can only be 0 (not present) or 1 (present). + * Note that this function only erases the element, and that if + * the element is itself a pointer, the pointed-to memory is not touched + * in any way. Managing the pointer is the user's responsibility. + */ + size_type + erase(const key_type& __x) + { return _M_h.erase(__x); } + + /** + * @brief Erases a [__first,__last) range of elements from an + * %unordered_set. + * @param __first Iterator pointing to the start of the range to be + * erased. + * @param __last Iterator pointing to the end of the range to + * be erased. + * @return The iterator @a __last. + * + * This function erases a sequence of elements from an %unordered_set. + * Note that this function only erases the element, and that if + * the element is itself a pointer, the pointed-to memory is not touched + * in any way. Managing the pointer is the user's responsibility. + */ + iterator + erase(const_iterator __first, const_iterator __last) + { return _M_h.erase(__first, __last); } + + /** + * Erases all elements in an %unordered_set. Note that this function only + * erases the elements, and that if the elements themselves are pointers, + * the pointed-to memory is not touched in any way. Managing the pointer + * is the user's responsibility. + */ + void + clear() noexcept + { _M_h.clear(); } + + /** + * @brief Swaps data with another %unordered_set. + * @param __x An %unordered_set of the same element and allocator + * types. + * + * This exchanges the elements between two sets in constant time. + * Note that the global std::swap() function is specialized such that + * std::swap(s1,s2) will feed to this function. + */ + void + swap(unordered_set& __x) + noexcept( noexcept(_M_h.swap(__x._M_h)) ) + { _M_h.swap(__x._M_h); } + + // observers. + + /// Returns the hash functor object with which the %unordered_set was + /// constructed. + hasher + hash_function() const + { return _M_h.hash_function(); } + + /// Returns the key comparison object with which the %unordered_set was + /// constructed. + key_equal + key_eq() const + { return _M_h.key_eq(); } + + // lookup. + + //@{ + /** + * @brief Tries to locate an element in an %unordered_set. + * @param __x Element to be located. + * @return Iterator pointing to sought-after element, or end() if not + * found. + * + * This function takes a key and tries to locate the element with which + * the key matches. If successful the function returns an iterator + * pointing to the sought after element. If unsuccessful it returns the + * past-the-end ( @c end() ) iterator. + */ + iterator + find(const key_type& __x) + { return _M_h.find(__x); } + + const_iterator + find(const key_type& __x) const + { return _M_h.find(__x); } + //@} + + /** + * @brief Finds the number of elements. + * @param __x Element to located. + * @return Number of elements with specified key. + * + * This function only makes sense for unordered_multisets; for + * unordered_set the result will either be 0 (not present) or 1 + * (present). + */ + size_type + count(const key_type& __x) const + { return _M_h.count(__x); } + + //@{ + /** + * @brief Finds a subsequence matching given key. + * @param __x Key to be located. + * @return Pair of iterators that possibly points to the subsequence + * matching given key. + * + * This function probably only makes sense for multisets. + */ + std::pair + equal_range(const key_type& __x) + { return _M_h.equal_range(__x); } + + std::pair + equal_range(const key_type& __x) const + { return _M_h.equal_range(__x); } + //@} + + // bucket interface. + + /// Returns the number of buckets of the %unordered_set. + size_type + bucket_count() const noexcept + { return _M_h.bucket_count(); } + + /// Returns the maximum number of buckets of the %unordered_set. + size_type + max_bucket_count() const noexcept + { return _M_h.max_bucket_count(); } + + /* + * @brief Returns the number of elements in a given bucket. + * @param __n A bucket index. + * @return The number of elements in the bucket. + */ + size_type + bucket_size(size_type __n) const + { return _M_h.bucket_size(__n); } + + /* + * @brief Returns the bucket index of a given element. + * @param __key A key instance. + * @return The key bucket index. + */ + size_type + bucket(const key_type& __key) const + { return _M_h.bucket(__key); } + + //@{ + /** + * @brief Returns a read-only (constant) iterator pointing to the first + * bucket element. + * @param __n The bucket index. + * @return A read-only local iterator. + */ + local_iterator + begin(size_type __n) + { return _M_h.begin(__n); } + + const_local_iterator + begin(size_type __n) const + { return _M_h.begin(__n); } + + const_local_iterator + cbegin(size_type __n) const + { return _M_h.cbegin(__n); } + //@} + + //@{ + /** + * @brief Returns a read-only (constant) iterator pointing to one past + * the last bucket elements. + * @param __n The bucket index. + * @return A read-only local iterator. + */ + local_iterator + end(size_type __n) + { return _M_h.end(__n); } + + const_local_iterator + end(size_type __n) const + { return _M_h.end(__n); } + + const_local_iterator + cend(size_type __n) const + { return _M_h.cend(__n); } + //@} + + // hash policy. + + /// Returns the average number of elements per bucket. + float + load_factor() const noexcept + { return _M_h.load_factor(); } + + /// Returns a positive number that the %unordered_set tries to keep the + /// load factor less than or equal to. + float + max_load_factor() const noexcept + { return _M_h.max_load_factor(); } + + /** + * @brief Change the %unordered_set maximum load factor. + * @param __z The new maximum load factor. + */ + void + max_load_factor(float __z) + { _M_h.max_load_factor(__z); } + + /** + * @brief May rehash the %unordered_set. + * @param __n The new number of buckets. + * + * Rehash will occur only if the new number of buckets respect the + * %unordered_set maximum load factor. + */ + void + rehash(size_type __n) + { _M_h.rehash(__n); } + + /** + * @brief Prepare the %unordered_set for a specified number of + * elements. + * @param __n Number of elements required. + * + * Same as rehash(ceil(n / max_load_factor())). + */ + void + reserve(size_type __n) + { _M_h.reserve(__n); } + + template + friend bool + operator==(const unordered_set<_Value1, _Hash1, _Pred1, _Alloc1>&, + const unordered_set<_Value1, _Hash1, _Pred1, _Alloc1>&); + }; + + /** + * @brief A standard container composed of equivalent keys + * (possibly containing multiple of each key value) in which the + * elements' keys are the elements themselves. + * + * @ingroup unordered_associative_containers + * + * @tparam _Value Type of key objects. + * @tparam _Hash Hashing function object type, defaults to hash<_Value>. + * @tparam _Pred Predicate function object type, defaults + * to equal_to<_Value>. + * @tparam _Alloc Allocator type, defaults to allocator<_Key>. + * + * Meets the requirements of a container, and + * unordered associative container + * + * Base is _Hashtable, dispatched at compile time via template + * alias __umset_hashtable. + */ + template, + class _Pred = std::equal_to<_Value>, + class _Alloc = std::allocator<_Value> > + class unordered_multiset + { + typedef __umset_hashtable<_Value, _Hash, _Pred, _Alloc> _Hashtable; + _Hashtable _M_h; + + public: + // typedefs: + //@{ + /// Public typedefs. + typedef typename _Hashtable::key_type key_type; + typedef typename _Hashtable::value_type value_type; + typedef typename _Hashtable::hasher hasher; + typedef typename _Hashtable::key_equal key_equal; + typedef typename _Hashtable::allocator_type allocator_type; + //@} + + //@{ + /// Iterator-related typedefs. + typedef typename _Hashtable::pointer pointer; + typedef typename _Hashtable::const_pointer const_pointer; + typedef typename _Hashtable::reference reference; + typedef typename _Hashtable::const_reference const_reference; + typedef typename _Hashtable::iterator iterator; + typedef typename _Hashtable::const_iterator const_iterator; + typedef typename _Hashtable::local_iterator local_iterator; + typedef typename _Hashtable::const_local_iterator const_local_iterator; + typedef typename _Hashtable::size_type size_type; + typedef typename _Hashtable::difference_type difference_type; + //@} + + // construct/destroy/copy + /** + * @brief Default constructor creates no elements. + * @param __n Initial number of buckets. + * @param __hf A hash functor. + * @param __eql A key equality functor. + * @param __a An allocator object. + */ + explicit + unordered_multiset(size_type __n = 10, + const hasher& __hf = hasher(), + const key_equal& __eql = key_equal(), + const allocator_type& __a = allocator_type()) + : _M_h(__n, __hf, __eql, __a) + { } + + /** + * @brief Builds an %unordered_multiset from a range. + * @param __first An input iterator. + * @param __last An input iterator. + * @param __n Minimal initial number of buckets. + * @param __hf A hash functor. + * @param __eql A key equality functor. + * @param __a An allocator object. + * + * Create an %unordered_multiset consisting of copies of the elements + * from [__first,__last). This is linear in N (where N is + * distance(__first,__last)). + */ + template + unordered_multiset(_InputIterator __f, _InputIterator __l, + size_type __n = 0, + const hasher& __hf = hasher(), + const key_equal& __eql = key_equal(), + const allocator_type& __a = allocator_type()) + : _M_h(__f, __l, __n, __hf, __eql, __a) + { } + + /// Copy constructor. + unordered_multiset(const unordered_multiset&) = default; + + /// Move constructor. + unordered_multiset(unordered_multiset&&) = default; + + /** + * @brief Builds an %unordered_multiset from an initializer_list. + * @param __l An initializer_list. + * @param __n Minimal initial number of buckets. + * @param __hf A hash functor. + * @param __eql A key equality functor. + * @param __a An allocator object. + * + * Create an %unordered_multiset consisting of copies of the elements in + * the list. This is linear in N (where N is @a __l.size()). + */ + unordered_multiset(initializer_list __l, + size_type __n = 0, + const hasher& __hf = hasher(), + const key_equal& __eql = key_equal(), + const allocator_type& __a = allocator_type()) + : _M_h(__l, __n, __hf, __eql, __a) + { } + + /// Copy assignment operator. + unordered_multiset& + operator=(const unordered_multiset&) = default; + + /// Move assignment operator. + unordered_multiset& + operator=(unordered_multiset&&) = default; + + /** + * @brief Creates an %unordered_multiset with no elements. + * @param __a An allocator object. + */ + explicit + unordered_multiset(const allocator_type& __a) + : _M_h(__a) + { } + + /* + * @brief Copy constructor with allocator argument. + * @param __uset Input %unordered_multiset to copy. + * @param __a An allocator object. + */ + unordered_multiset(const unordered_multiset& __umset, + const allocator_type& __a) + : _M_h(__umset._M_h, __a) + { } + + /* + * @brief Move constructor with allocator argument. + * @param __umset Input %unordered_multiset to move. + * @param __a An allocator object. + */ + unordered_multiset(unordered_multiset&& __umset, + const allocator_type& __a) + : _M_h(std::move(__umset._M_h), __a) + { } + + /** + * @brief %Unordered_multiset list assignment operator. + * @param __l An initializer_list. + * + * This function fills an %unordered_multiset with copies of the elements + * in the initializer list @a __l. + * + * Note that the assignment completely changes the %unordered_multiset + * and that the resulting %unordered_set's size is the same as the number + * of elements assigned. Old data may be lost. + */ + unordered_multiset& + operator=(initializer_list __l) + { + _M_h = __l; + return *this; + } + + /// Returns the allocator object with which the %unordered_multiset was + /// constructed. + allocator_type + get_allocator() const noexcept + { return _M_h.get_allocator(); } + + // size and capacity: + + /// Returns true if the %unordered_multiset is empty. + bool + empty() const noexcept + { return _M_h.empty(); } + + /// Returns the size of the %unordered_multiset. + size_type + size() const noexcept + { return _M_h.size(); } + + /// Returns the maximum size of the %unordered_multiset. + size_type + max_size() const noexcept + { return _M_h.max_size(); } + + // iterators. + + //@{ + /** + * Returns a read-only (constant) iterator that points to the first + * element in the %unordered_multiset. + */ + iterator + begin() noexcept + { return _M_h.begin(); } + + const_iterator + begin() const noexcept + { return _M_h.begin(); } + //@} + + //@{ + /** + * Returns a read-only (constant) iterator that points one past the last + * element in the %unordered_multiset. + */ + iterator + end() noexcept + { return _M_h.end(); } + + const_iterator + end() const noexcept + { return _M_h.end(); } + //@} + + /** + * Returns a read-only (constant) iterator that points to the first + * element in the %unordered_multiset. + */ + const_iterator + cbegin() const noexcept + { return _M_h.begin(); } + + /** + * Returns a read-only (constant) iterator that points one past the last + * element in the %unordered_multiset. + */ + const_iterator + cend() const noexcept + { return _M_h.end(); } + + // modifiers. + + /** + * @brief Builds and insert an element into the %unordered_multiset. + * @param __args Arguments used to generate an element. + * @return An iterator that points to the inserted element. + * + * Insertion requires amortized constant time. + */ + template + iterator + emplace(_Args&&... __args) + { return _M_h.emplace(std::forward<_Args>(__args)...); } + + /** + * @brief Inserts an element into the %unordered_multiset. + * @param __pos An iterator that serves as a hint as to where the + * element should be inserted. + * @param __args Arguments used to generate the element to be + * inserted. + * @return An iterator that points to the inserted element. + * + * Note that the first parameter is only a hint and can potentially + * improve the performance of the insertion process. A bad hint would + * cause no gains in efficiency. + * + * For more on @a hinting, see: + * http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt07ch17.html + * + * Insertion requires amortized constant time. + */ + template + iterator + emplace_hint(const_iterator __pos, _Args&&... __args) + { return _M_h.emplace_hint(__pos, std::forward<_Args>(__args)...); } + + //@{ + /** + * @brief Inserts an element into the %unordered_multiset. + * @param __x Element to be inserted. + * @return An iterator that points to the inserted element. + * + * Insertion requires amortized constant time. + */ + iterator + insert(const value_type& __x) + { return _M_h.insert(__x); } + + iterator + insert(value_type&& __x) + { return _M_h.insert(std::move(__x)); } + //@} + + //@{ + /** + * @brief Inserts an element into the %unordered_multiset. + * @param __hint An iterator that serves as a hint as to where the + * element should be inserted. + * @param __x Element to be inserted. + * @return An iterator that points to the inserted element. + * + * Note that the first parameter is only a hint and can potentially + * improve the performance of the insertion process. A bad hint would + * cause no gains in efficiency. + * + * For more on @a hinting, see: + * http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt07ch17.html + * + * Insertion requires amortized constant. + */ + iterator + insert(const_iterator __hint, const value_type& __x) + { return _M_h.insert(__hint, __x); } + + iterator + insert(const_iterator __hint, value_type&& __x) + { return _M_h.insert(__hint, std::move(__x)); } + //@} + + /** + * @brief A template function that inserts a range of elements. + * @param __first Iterator pointing to the start of the range to be + * inserted. + * @param __last Iterator pointing to the end of the range. + * + * Complexity similar to that of the range constructor. + */ + template + void + insert(_InputIterator __first, _InputIterator __last) + { _M_h.insert(__first, __last); } + + /** + * @brief Inserts a list of elements into the %unordered_multiset. + * @param __l A std::initializer_list of elements to be + * inserted. + * + * Complexity similar to that of the range constructor. + */ + void + insert(initializer_list __l) + { _M_h.insert(__l); } + + //@{ + /** + * @brief Erases an element from an %unordered_multiset. + * @param __position An iterator pointing to the element to be erased. + * @return An iterator pointing to the element immediately following + * @a __position prior to the element being erased. If no such + * element exists, end() is returned. + * + * This function erases an element, pointed to by the given iterator, + * from an %unordered_multiset. + * + * Note that this function only erases the element, and that if the + * element is itself a pointer, the pointed-to memory is not touched in + * any way. Managing the pointer is the user's responsibility. + */ + iterator + erase(const_iterator __position) + { return _M_h.erase(__position); } + + // LWG 2059. + iterator + erase(iterator __it) + { return _M_h.erase(__it); } + //@} + + + /** + * @brief Erases elements according to the provided key. + * @param __x Key of element to be erased. + * @return The number of elements erased. + * + * This function erases all the elements located by the given key from + * an %unordered_multiset. + * + * Note that this function only erases the element, and that if the + * element is itself a pointer, the pointed-to memory is not touched in + * any way. Managing the pointer is the user's responsibility. + */ + size_type + erase(const key_type& __x) + { return _M_h.erase(__x); } + + /** + * @brief Erases a [__first,__last) range of elements from an + * %unordered_multiset. + * @param __first Iterator pointing to the start of the range to be + * erased. + * @param __last Iterator pointing to the end of the range to + * be erased. + * @return The iterator @a __last. + * + * This function erases a sequence of elements from an + * %unordered_multiset. + * + * Note that this function only erases the element, and that if + * the element is itself a pointer, the pointed-to memory is not touched + * in any way. Managing the pointer is the user's responsibility. + */ + iterator + erase(const_iterator __first, const_iterator __last) + { return _M_h.erase(__first, __last); } + + /** + * Erases all elements in an %unordered_multiset. + * + * Note that this function only erases the elements, and that if the + * elements themselves are pointers, the pointed-to memory is not touched + * in any way. Managing the pointer is the user's responsibility. + */ + void + clear() noexcept + { _M_h.clear(); } + + /** + * @brief Swaps data with another %unordered_multiset. + * @param __x An %unordered_multiset of the same element and allocator + * types. + * + * This exchanges the elements between two sets in constant time. + * Note that the global std::swap() function is specialized such that + * std::swap(s1,s2) will feed to this function. + */ + void + swap(unordered_multiset& __x) + noexcept( noexcept(_M_h.swap(__x._M_h)) ) + { _M_h.swap(__x._M_h); } + + // observers. + + /// Returns the hash functor object with which the %unordered_multiset + /// was constructed. + hasher + hash_function() const + { return _M_h.hash_function(); } + + /// Returns the key comparison object with which the %unordered_multiset + /// was constructed. + key_equal + key_eq() const + { return _M_h.key_eq(); } + + // lookup. + + //@{ + /** + * @brief Tries to locate an element in an %unordered_multiset. + * @param __x Element to be located. + * @return Iterator pointing to sought-after element, or end() if not + * found. + * + * This function takes a key and tries to locate the element with which + * the key matches. If successful the function returns an iterator + * pointing to the sought after element. If unsuccessful it returns the + * past-the-end ( @c end() ) iterator. + */ + iterator + find(const key_type& __x) + { return _M_h.find(__x); } + + const_iterator + find(const key_type& __x) const + { return _M_h.find(__x); } + //@} + + /** + * @brief Finds the number of elements. + * @param __x Element to located. + * @return Number of elements with specified key. + */ + size_type + count(const key_type& __x) const + { return _M_h.count(__x); } + + //@{ + /** + * @brief Finds a subsequence matching given key. + * @param __x Key to be located. + * @return Pair of iterators that possibly points to the subsequence + * matching given key. + */ + std::pair + equal_range(const key_type& __x) + { return _M_h.equal_range(__x); } + + std::pair + equal_range(const key_type& __x) const + { return _M_h.equal_range(__x); } + //@} + + // bucket interface. + + /// Returns the number of buckets of the %unordered_multiset. + size_type + bucket_count() const noexcept + { return _M_h.bucket_count(); } + + /// Returns the maximum number of buckets of the %unordered_multiset. + size_type + max_bucket_count() const noexcept + { return _M_h.max_bucket_count(); } + + /* + * @brief Returns the number of elements in a given bucket. + * @param __n A bucket index. + * @return The number of elements in the bucket. + */ + size_type + bucket_size(size_type __n) const + { return _M_h.bucket_size(__n); } + + /* + * @brief Returns the bucket index of a given element. + * @param __key A key instance. + * @return The key bucket index. + */ + size_type + bucket(const key_type& __key) const + { return _M_h.bucket(__key); } + + //@{ + /** + * @brief Returns a read-only (constant) iterator pointing to the first + * bucket element. + * @param __n The bucket index. + * @return A read-only local iterator. + */ + local_iterator + begin(size_type __n) + { return _M_h.begin(__n); } + + const_local_iterator + begin(size_type __n) const + { return _M_h.begin(__n); } + + const_local_iterator + cbegin(size_type __n) const + { return _M_h.cbegin(__n); } + //@} + + //@{ + /** + * @brief Returns a read-only (constant) iterator pointing to one past + * the last bucket elements. + * @param __n The bucket index. + * @return A read-only local iterator. + */ + local_iterator + end(size_type __n) + { return _M_h.end(__n); } + + const_local_iterator + end(size_type __n) const + { return _M_h.end(__n); } + + const_local_iterator + cend(size_type __n) const + { return _M_h.cend(__n); } + //@} + + // hash policy. + + /// Returns the average number of elements per bucket. + float + load_factor() const noexcept + { return _M_h.load_factor(); } + + /// Returns a positive number that the %unordered_multiset tries to keep the + /// load factor less than or equal to. + float + max_load_factor() const noexcept + { return _M_h.max_load_factor(); } + + /** + * @brief Change the %unordered_multiset maximum load factor. + * @param __z The new maximum load factor. + */ + void + max_load_factor(float __z) + { _M_h.max_load_factor(__z); } + + /** + * @brief May rehash the %unordered_multiset. + * @param __n The new number of buckets. + * + * Rehash will occur only if the new number of buckets respect the + * %unordered_multiset maximum load factor. + */ + void + rehash(size_type __n) + { _M_h.rehash(__n); } + + /** + * @brief Prepare the %unordered_multiset for a specified number of + * elements. + * @param __n Number of elements required. + * + * Same as rehash(ceil(n / max_load_factor())). + */ + void + reserve(size_type __n) + { _M_h.reserve(__n); } + + template + friend bool + operator==(const unordered_multiset<_Value1, _Hash1, _Pred1, _Alloc1>&, + const unordered_multiset<_Value1, _Hash1, _Pred1, _Alloc1>&); + }; + + template + inline void + swap(unordered_set<_Value, _Hash, _Pred, _Alloc>& __x, + unordered_set<_Value, _Hash, _Pred, _Alloc>& __y) + { __x.swap(__y); } + + template + inline void + swap(unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x, + unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y) + { __x.swap(__y); } + + template + inline bool + operator==(const unordered_set<_Value, _Hash, _Pred, _Alloc>& __x, + const unordered_set<_Value, _Hash, _Pred, _Alloc>& __y) + { return __x._M_h._M_equal(__y._M_h); } + + template + inline bool + operator!=(const unordered_set<_Value, _Hash, _Pred, _Alloc>& __x, + const unordered_set<_Value, _Hash, _Pred, _Alloc>& __y) + { return !(__x == __y); } + + template + inline bool + operator==(const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x, + const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y) + { return __x._M_h._M_equal(__y._M_h); } + + template + inline bool + operator!=(const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x, + const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y) + { return !(__x == __y); } + +_GLIBCXX_END_NAMESPACE_CONTAINER +} // namespace std + +#endif /* _UNORDERED_SET_H */ diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/uses_allocator.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/uses_allocator.h new file mode 100755 index 0000000..10131c0 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/uses_allocator.h @@ -0,0 +1,109 @@ +// Uses-allocator Construction -*- C++ -*- + +// Copyright (C) 2010-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +#ifndef _USES_ALLOCATOR_H +#define _USES_ALLOCATOR_H 1 + +#if __cplusplus < 201103L +# include +#else + +#include + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /// [allocator.tag] + struct allocator_arg_t { }; + + constexpr allocator_arg_t allocator_arg = allocator_arg_t(); + +_GLIBCXX_HAS_NESTED_TYPE(allocator_type) + + template::value> + struct __uses_allocator_helper + : public false_type { }; + + template + struct __uses_allocator_helper<_Tp, _Alloc, true> + : public integral_constant::value> + { }; + + /// [allocator.uses.trait] + template + struct uses_allocator + : public integral_constant::value> + { }; + + template + struct __uses_allocator_arg + : is_constructible<_Tp, _Alloc, _Args...> + { static_assert( uses_allocator<_Tp, _Alloc>::value, "uses allocator" ); }; + + struct __uses_alloc_base { }; + struct __uses_alloc0 : __uses_alloc_base + { struct _Anything { _Anything(...) { } } _M_a; }; + template + struct __uses_alloc1 : __uses_alloc_base { const _Alloc* _M_a; }; + template + struct __uses_alloc2 : __uses_alloc_base { const _Alloc* _M_a; }; + + template + struct __uses_alloc; + + template + struct __uses_alloc + : conditional< + is_constructible<_Tp, allocator_arg_t, _Alloc, _Args...>::value, + __uses_alloc1<_Alloc>, + __uses_alloc2<_Alloc>>::type + { }; + + template + struct __uses_alloc + : __uses_alloc0 { }; + + template + struct __uses_alloc_impl + : __uses_alloc::value, _Tp, _Alloc, _Args...> + { }; + + template + __uses_alloc_impl<_Tp, _Alloc, _Args...> + __use_alloc(const _Alloc& __a) + { + __uses_alloc_impl<_Tp, _Alloc, _Args...> __ret; + __ret._M_a = &__a; + return __ret; + } + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace std + +#endif +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/valarray_after.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/valarray_after.h new file mode 100755 index 0000000..2391dc5 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/valarray_after.h @@ -0,0 +1,551 @@ +// The template and inlines for the -*- C++ -*- internal _Meta class. + +// Copyright (C) 1997-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file bits/valarray_after.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{valarray} + */ + +// Written by Gabriel Dos Reis + +#ifndef _VALARRAY_AFTER_H +#define _VALARRAY_AFTER_H 1 + +#pragma GCC system_header + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + // + // gslice_array closure. + // + template + class _GBase + { + public: + typedef typename _Dom::value_type value_type; + + _GBase (const _Dom& __e, const valarray& __i) + : _M_expr (__e), _M_index(__i) {} + + value_type + operator[] (size_t __i) const + { return _M_expr[_M_index[__i]]; } + + size_t + size () const + { return _M_index.size(); } + + private: + const _Dom& _M_expr; + const valarray& _M_index; + }; + + template + class _GBase<_Array<_Tp> > + { + public: + typedef _Tp value_type; + + _GBase (_Array<_Tp> __a, const valarray& __i) + : _M_array (__a), _M_index(__i) {} + + value_type + operator[] (size_t __i) const + { return _M_array._M_data[_M_index[__i]]; } + + size_t + size () const + { return _M_index.size(); } + + private: + const _Array<_Tp> _M_array; + const valarray& _M_index; + }; + + template + struct _GClos<_Expr, _Dom> + : _GBase<_Dom> + { + typedef _GBase<_Dom> _Base; + typedef typename _Base::value_type value_type; + + _GClos (const _Dom& __e, const valarray& __i) + : _Base (__e, __i) {} + }; + + template + struct _GClos<_ValArray, _Tp> + : _GBase<_Array<_Tp> > + { + typedef _GBase<_Array<_Tp> > _Base; + typedef typename _Base::value_type value_type; + + _GClos (_Array<_Tp> __a, const valarray& __i) + : _Base (__a, __i) {} + }; + + // + // indirect_array closure + // + template + class _IBase + { + public: + typedef typename _Dom::value_type value_type; + + _IBase (const _Dom& __e, const valarray& __i) + : _M_expr (__e), _M_index (__i) {} + + value_type + operator[] (size_t __i) const + { return _M_expr[_M_index[__i]]; } + + size_t + size() const + { return _M_index.size(); } + + private: + const _Dom& _M_expr; + const valarray& _M_index; + }; + + template + struct _IClos<_Expr, _Dom> + : _IBase<_Dom> + { + typedef _IBase<_Dom> _Base; + typedef typename _Base::value_type value_type; + + _IClos (const _Dom& __e, const valarray& __i) + : _Base (__e, __i) {} + }; + + template + struct _IClos<_ValArray, _Tp> + : _IBase > + { + typedef _IBase > _Base; + typedef _Tp value_type; + + _IClos (const valarray<_Tp>& __a, const valarray& __i) + : _Base (__a, __i) {} + }; + + // + // class _Expr + // + template + class _Expr + { + public: + typedef _Tp value_type; + + _Expr(const _Clos&); + + const _Clos& operator()() const; + + value_type operator[](size_t) const; + valarray operator[](slice) const; + valarray operator[](const gslice&) const; + valarray operator[](const valarray&) const; + valarray operator[](const valarray&) const; + + _Expr<_UnClos<__unary_plus, std::_Expr, _Clos>, value_type> + operator+() const; + + _Expr<_UnClos<__negate, std::_Expr, _Clos>, value_type> + operator-() const; + + _Expr<_UnClos<__bitwise_not, std::_Expr, _Clos>, value_type> + operator~() const; + + _Expr<_UnClos<__logical_not, std::_Expr, _Clos>, bool> + operator!() const; + + size_t size() const; + value_type sum() const; + + valarray shift(int) const; + valarray cshift(int) const; + + value_type min() const; + value_type max() const; + + valarray apply(value_type (*)(const value_type&)) const; + valarray apply(value_type (*)(value_type)) const; + + private: + const _Clos _M_closure; + }; + + template + inline + _Expr<_Clos, _Tp>::_Expr(const _Clos& __c) : _M_closure(__c) {} + + template + inline const _Clos& + _Expr<_Clos, _Tp>::operator()() const + { return _M_closure; } + + template + inline _Tp + _Expr<_Clos, _Tp>::operator[](size_t __i) const + { return _M_closure[__i]; } + + template + inline valarray<_Tp> + _Expr<_Clos, _Tp>::operator[](slice __s) const + { + valarray<_Tp> __v = valarray<_Tp>(*this)[__s]; + return __v; + } + + template + inline valarray<_Tp> + _Expr<_Clos, _Tp>::operator[](const gslice& __gs) const + { + valarray<_Tp> __v = valarray<_Tp>(*this)[__gs]; + return __v; + } + + template + inline valarray<_Tp> + _Expr<_Clos, _Tp>::operator[](const valarray& __m) const + { + valarray<_Tp> __v = valarray<_Tp>(*this)[__m]; + return __v; + } + + template + inline valarray<_Tp> + _Expr<_Clos, _Tp>::operator[](const valarray& __i) const + { + valarray<_Tp> __v = valarray<_Tp>(*this)[__i]; + return __v; + } + + template + inline size_t + _Expr<_Clos, _Tp>::size() const + { return _M_closure.size(); } + + template + inline valarray<_Tp> + _Expr<_Clos, _Tp>::shift(int __n) const + { + valarray<_Tp> __v = valarray<_Tp>(*this).shift(__n); + return __v; + } + + template + inline valarray<_Tp> + _Expr<_Clos, _Tp>::cshift(int __n) const + { + valarray<_Tp> __v = valarray<_Tp>(*this).cshift(__n); + return __v; + } + + template + inline valarray<_Tp> + _Expr<_Clos, _Tp>::apply(_Tp __f(const _Tp&)) const + { + valarray<_Tp> __v = valarray<_Tp>(*this).apply(__f); + return __v; + } + + template + inline valarray<_Tp> + _Expr<_Clos, _Tp>::apply(_Tp __f(_Tp)) const + { + valarray<_Tp> __v = valarray<_Tp>(*this).apply(__f); + return __v; + } + + // XXX: replace this with a more robust summation algorithm. + template + inline _Tp + _Expr<_Clos, _Tp>::sum() const + { + size_t __n = _M_closure.size(); + if (__n == 0) + return _Tp(); + else + { + _Tp __s = _M_closure[--__n]; + while (__n != 0) + __s += _M_closure[--__n]; + return __s; + } + } + + template + inline _Tp + _Expr<_Clos, _Tp>::min() const + { return __valarray_min(_M_closure); } + + template + inline _Tp + _Expr<_Clos, _Tp>::max() const + { return __valarray_max(_M_closure); } + + template + inline _Expr<_UnClos<__logical_not, _Expr, _Dom>, bool> + _Expr<_Dom, _Tp>::operator!() const + { + typedef _UnClos<__logical_not, std::_Expr, _Dom> _Closure; + return _Expr<_Closure, bool>(_Closure(this->_M_closure)); + } + +#define _DEFINE_EXPR_UNARY_OPERATOR(_Op, _Name) \ + template \ + inline _Expr<_UnClos<_Name, std::_Expr, _Dom>, _Tp> \ + _Expr<_Dom, _Tp>::operator _Op() const \ + { \ + typedef _UnClos<_Name, std::_Expr, _Dom> _Closure; \ + return _Expr<_Closure, _Tp>(_Closure(this->_M_closure)); \ + } + + _DEFINE_EXPR_UNARY_OPERATOR(+, __unary_plus) + _DEFINE_EXPR_UNARY_OPERATOR(-, __negate) + _DEFINE_EXPR_UNARY_OPERATOR(~, __bitwise_not) + +#undef _DEFINE_EXPR_UNARY_OPERATOR + +#define _DEFINE_EXPR_BINARY_OPERATOR(_Op, _Name) \ + template \ + inline _Expr<_BinClos<_Name, _Expr, _Expr, _Dom1, _Dom2>, \ + typename __fun<_Name, typename _Dom1::value_type>::result_type> \ + operator _Op(const _Expr<_Dom1, typename _Dom1::value_type>& __v, \ + const _Expr<_Dom2, typename _Dom2::value_type>& __w) \ + { \ + typedef typename _Dom1::value_type _Arg; \ + typedef typename __fun<_Name, _Arg>::result_type _Value; \ + typedef _BinClos<_Name, _Expr, _Expr, _Dom1, _Dom2> _Closure; \ + return _Expr<_Closure, _Value>(_Closure(__v(), __w())); \ + } \ + \ + template \ + inline _Expr<_BinClos<_Name, _Expr, _Constant, _Dom, \ + typename _Dom::value_type>, \ + typename __fun<_Name, typename _Dom::value_type>::result_type> \ + operator _Op(const _Expr<_Dom, typename _Dom::value_type>& __v, \ + const typename _Dom::value_type& __t) \ + { \ + typedef typename _Dom::value_type _Arg; \ + typedef typename __fun<_Name, _Arg>::result_type _Value; \ + typedef _BinClos<_Name, _Expr, _Constant, _Dom, _Arg> _Closure; \ + return _Expr<_Closure, _Value>(_Closure(__v(), __t)); \ + } \ + \ + template \ + inline _Expr<_BinClos<_Name, _Constant, _Expr, \ + typename _Dom::value_type, _Dom>, \ + typename __fun<_Name, typename _Dom::value_type>::result_type> \ + operator _Op(const typename _Dom::value_type& __t, \ + const _Expr<_Dom, typename _Dom::value_type>& __v) \ + { \ + typedef typename _Dom::value_type _Arg; \ + typedef typename __fun<_Name, _Arg>::result_type _Value; \ + typedef _BinClos<_Name, _Constant, _Expr, _Arg, _Dom> _Closure; \ + return _Expr<_Closure, _Value>(_Closure(__t, __v())); \ + } \ + \ + template \ + inline _Expr<_BinClos<_Name, _Expr, _ValArray, \ + _Dom, typename _Dom::value_type>, \ + typename __fun<_Name, typename _Dom::value_type>::result_type> \ + operator _Op(const _Expr<_Dom,typename _Dom::value_type>& __e, \ + const valarray& __v) \ + { \ + typedef typename _Dom::value_type _Arg; \ + typedef typename __fun<_Name, _Arg>::result_type _Value; \ + typedef _BinClos<_Name, _Expr, _ValArray, _Dom, _Arg> _Closure; \ + return _Expr<_Closure, _Value>(_Closure(__e(), __v)); \ + } \ + \ + template \ + inline _Expr<_BinClos<_Name, _ValArray, _Expr, \ + typename _Dom::value_type, _Dom>, \ + typename __fun<_Name, typename _Dom::value_type>::result_type> \ + operator _Op(const valarray& __v, \ + const _Expr<_Dom, typename _Dom::value_type>& __e) \ + { \ + typedef typename _Dom::value_type _Tp; \ + typedef typename __fun<_Name, _Tp>::result_type _Value; \ + typedef _BinClos<_Name, _ValArray, _Expr, _Tp, _Dom> _Closure; \ + return _Expr<_Closure, _Value>(_Closure(__v, __e ())); \ + } + + _DEFINE_EXPR_BINARY_OPERATOR(+, __plus) + _DEFINE_EXPR_BINARY_OPERATOR(-, __minus) + _DEFINE_EXPR_BINARY_OPERATOR(*, __multiplies) + _DEFINE_EXPR_BINARY_OPERATOR(/, __divides) + _DEFINE_EXPR_BINARY_OPERATOR(%, __modulus) + _DEFINE_EXPR_BINARY_OPERATOR(^, __bitwise_xor) + _DEFINE_EXPR_BINARY_OPERATOR(&, __bitwise_and) + _DEFINE_EXPR_BINARY_OPERATOR(|, __bitwise_or) + _DEFINE_EXPR_BINARY_OPERATOR(<<, __shift_left) + _DEFINE_EXPR_BINARY_OPERATOR(>>, __shift_right) + _DEFINE_EXPR_BINARY_OPERATOR(&&, __logical_and) + _DEFINE_EXPR_BINARY_OPERATOR(||, __logical_or) + _DEFINE_EXPR_BINARY_OPERATOR(==, __equal_to) + _DEFINE_EXPR_BINARY_OPERATOR(!=, __not_equal_to) + _DEFINE_EXPR_BINARY_OPERATOR(<, __less) + _DEFINE_EXPR_BINARY_OPERATOR(>, __greater) + _DEFINE_EXPR_BINARY_OPERATOR(<=, __less_equal) + _DEFINE_EXPR_BINARY_OPERATOR(>=, __greater_equal) + +#undef _DEFINE_EXPR_BINARY_OPERATOR + +#define _DEFINE_EXPR_UNARY_FUNCTION(_Name, _UName) \ + template \ + inline _Expr<_UnClos<_UName, _Expr, _Dom>, \ + typename _Dom::value_type> \ + _Name(const _Expr<_Dom, typename _Dom::value_type>& __e) \ + { \ + typedef typename _Dom::value_type _Tp; \ + typedef _UnClos<_UName, _Expr, _Dom> _Closure; \ + return _Expr<_Closure, _Tp>(_Closure(__e())); \ + } \ + \ + template \ + inline _Expr<_UnClos<_UName, _ValArray, _Tp>, _Tp> \ + _Name(const valarray<_Tp>& __v) \ + { \ + typedef _UnClos<_UName, _ValArray, _Tp> _Closure; \ + return _Expr<_Closure, _Tp>(_Closure(__v)); \ + } + + _DEFINE_EXPR_UNARY_FUNCTION(abs, _Abs) + _DEFINE_EXPR_UNARY_FUNCTION(cos, _Cos) + _DEFINE_EXPR_UNARY_FUNCTION(acos, _Acos) + _DEFINE_EXPR_UNARY_FUNCTION(cosh, _Cosh) + _DEFINE_EXPR_UNARY_FUNCTION(sin, _Sin) + _DEFINE_EXPR_UNARY_FUNCTION(asin, _Asin) + _DEFINE_EXPR_UNARY_FUNCTION(sinh, _Sinh) + _DEFINE_EXPR_UNARY_FUNCTION(tan, _Tan) + _DEFINE_EXPR_UNARY_FUNCTION(tanh, _Tanh) + _DEFINE_EXPR_UNARY_FUNCTION(atan, _Atan) + _DEFINE_EXPR_UNARY_FUNCTION(exp, _Exp) + _DEFINE_EXPR_UNARY_FUNCTION(log, _Log) + _DEFINE_EXPR_UNARY_FUNCTION(log10, _Log10) + _DEFINE_EXPR_UNARY_FUNCTION(sqrt, _Sqrt) + +#undef _DEFINE_EXPR_UNARY_FUNCTION + +#define _DEFINE_EXPR_BINARY_FUNCTION(_Fun, _UFun) \ + template \ + inline _Expr<_BinClos<_UFun, _Expr, _Expr, _Dom1, _Dom2>, \ + typename _Dom1::value_type> \ + _Fun(const _Expr<_Dom1, typename _Dom1::value_type>& __e1, \ + const _Expr<_Dom2, typename _Dom2::value_type>& __e2) \ + { \ + typedef typename _Dom1::value_type _Tp; \ + typedef _BinClos<_UFun, _Expr, _Expr, _Dom1, _Dom2> _Closure; \ + return _Expr<_Closure, _Tp>(_Closure(__e1(), __e2())); \ + } \ + \ + template \ + inline _Expr<_BinClos<_UFun, _Expr, _ValArray, _Dom, \ + typename _Dom::value_type>, \ + typename _Dom::value_type> \ + _Fun(const _Expr<_Dom, typename _Dom::value_type>& __e, \ + const valarray& __v) \ + { \ + typedef typename _Dom::value_type _Tp; \ + typedef _BinClos<_UFun, _Expr, _ValArray, _Dom, _Tp> _Closure; \ + return _Expr<_Closure, _Tp>(_Closure(__e(), __v)); \ + } \ + \ + template \ + inline _Expr<_BinClos<_UFun, _ValArray, _Expr, \ + typename _Dom::value_type, _Dom>, \ + typename _Dom::value_type> \ + _Fun(const valarray& __v, \ + const _Expr<_Dom, typename _Dom::value_type>& __e) \ + { \ + typedef typename _Dom::value_type _Tp; \ + typedef _BinClos<_UFun, _ValArray, _Expr, _Tp, _Dom> _Closure; \ + return _Expr<_Closure, _Tp>(_Closure(__v, __e())); \ + } \ + \ + template \ + inline _Expr<_BinClos<_UFun, _Expr, _Constant, _Dom, \ + typename _Dom::value_type>, \ + typename _Dom::value_type> \ + _Fun(const _Expr<_Dom, typename _Dom::value_type>& __e, \ + const typename _Dom::value_type& __t) \ + { \ + typedef typename _Dom::value_type _Tp; \ + typedef _BinClos<_UFun, _Expr, _Constant, _Dom, _Tp> _Closure; \ + return _Expr<_Closure, _Tp>(_Closure(__e(), __t)); \ + } \ + \ + template \ + inline _Expr<_BinClos<_UFun, _Constant, _Expr, \ + typename _Dom::value_type, _Dom>, \ + typename _Dom::value_type> \ + _Fun(const typename _Dom::value_type& __t, \ + const _Expr<_Dom, typename _Dom::value_type>& __e) \ + { \ + typedef typename _Dom::value_type _Tp; \ + typedef _BinClos<_UFun, _Constant, _Expr, _Tp, _Dom> _Closure; \ + return _Expr<_Closure, _Tp>(_Closure(__t, __e())); \ + } \ + \ + template \ + inline _Expr<_BinClos<_UFun, _ValArray, _ValArray, _Tp, _Tp>, _Tp> \ + _Fun(const valarray<_Tp>& __v, const valarray<_Tp>& __w) \ + { \ + typedef _BinClos<_UFun, _ValArray, _ValArray, _Tp, _Tp> _Closure;\ + return _Expr<_Closure, _Tp>(_Closure(__v, __w)); \ + } \ + \ + template \ + inline _Expr<_BinClos<_UFun, _ValArray, _Constant, _Tp, _Tp>, _Tp> \ + _Fun(const valarray<_Tp>& __v, const _Tp& __t) \ + { \ + typedef _BinClos<_UFun, _ValArray, _Constant, _Tp, _Tp> _Closure;\ + return _Expr<_Closure, _Tp>(_Closure(__v, __t)); \ + } \ + \ + template \ + inline _Expr<_BinClos<_UFun, _Constant, _ValArray, _Tp, _Tp>, _Tp> \ + _Fun(const _Tp& __t, const valarray<_Tp>& __v) \ + { \ + typedef _BinClos<_UFun, _Constant, _ValArray, _Tp, _Tp> _Closure;\ + return _Expr<_Closure, _Tp>(_Closure(__t, __v)); \ + } + +_DEFINE_EXPR_BINARY_FUNCTION(atan2, _Atan2) +_DEFINE_EXPR_BINARY_FUNCTION(pow, _Pow) + +#undef _DEFINE_EXPR_BINARY_FUNCTION + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif /* _CPP_VALARRAY_AFTER_H */ diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/valarray_array.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/valarray_array.h new file mode 100755 index 0000000..8f5e047 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/valarray_array.h @@ -0,0 +1,693 @@ +// The template and inlines for the -*- C++ -*- internal _Array helper class. + +// Copyright (C) 1997-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file bits/valarray_array.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{valarray} + */ + +// Written by Gabriel Dos Reis + +#ifndef _VALARRAY_ARRAY_H +#define _VALARRAY_ARRAY_H 1 + +#pragma GCC system_header + +#include +#include +#include +#include + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + // + // Helper functions on raw pointers + // + + // We get memory by the old fashion way + inline void* + __valarray_get_memory(size_t __n) + { return operator new(__n); } + + template + inline _Tp*__restrict__ + __valarray_get_storage(size_t __n) + { + return static_cast<_Tp*__restrict__> + (std::__valarray_get_memory(__n * sizeof(_Tp))); + } + + // Return memory to the system + inline void + __valarray_release_memory(void* __p) + { operator delete(__p); } + + // Turn a raw-memory into an array of _Tp filled with _Tp() + // This is required in 'valarray v(n);' + template + struct _Array_default_ctor + { + // Please note that this isn't exception safe. But + // valarrays aren't required to be exception safe. + inline static void + _S_do_it(_Tp* __b, _Tp* __e) + { + while (__b != __e) + new(__b++) _Tp(); + } + }; + + template + struct _Array_default_ctor<_Tp, true> + { + // For fundamental types, it suffices to say 'memset()' + inline static void + _S_do_it(_Tp* __b, _Tp* __e) + { __builtin_memset(__b, 0, (__e - __b) * sizeof(_Tp)); } + }; + + template + inline void + __valarray_default_construct(_Tp* __b, _Tp* __e) + { + _Array_default_ctor<_Tp, __is_scalar<_Tp>::__value>::_S_do_it(__b, __e); + } + + // Turn a raw-memory into an array of _Tp filled with __t + // This is the required in valarray v(n, t). Also + // used in valarray<>::resize(). + template + struct _Array_init_ctor + { + // Please note that this isn't exception safe. But + // valarrays aren't required to be exception safe. + inline static void + _S_do_it(_Tp* __b, _Tp* __e, const _Tp __t) + { + while (__b != __e) + new(__b++) _Tp(__t); + } + }; + + template + struct _Array_init_ctor<_Tp, true> + { + inline static void + _S_do_it(_Tp* __b, _Tp* __e, const _Tp __t) + { + while (__b != __e) + *__b++ = __t; + } + }; + + template + inline void + __valarray_fill_construct(_Tp* __b, _Tp* __e, const _Tp __t) + { + _Array_init_ctor<_Tp, __is_trivial(_Tp)>::_S_do_it(__b, __e, __t); + } + + // + // copy-construct raw array [__o, *) from plain array [__b, __e) + // We can't just say 'memcpy()' + // + template + struct _Array_copy_ctor + { + // Please note that this isn't exception safe. But + // valarrays aren't required to be exception safe. + inline static void + _S_do_it(const _Tp* __b, const _Tp* __e, _Tp* __restrict__ __o) + { + while (__b != __e) + new(__o++) _Tp(*__b++); + } + }; + + template + struct _Array_copy_ctor<_Tp, true> + { + inline static void + _S_do_it(const _Tp* __b, const _Tp* __e, _Tp* __restrict__ __o) + { __builtin_memcpy(__o, __b, (__e - __b) * sizeof(_Tp)); } + }; + + template + inline void + __valarray_copy_construct(const _Tp* __b, const _Tp* __e, + _Tp* __restrict__ __o) + { + _Array_copy_ctor<_Tp, __is_trivial(_Tp)>::_S_do_it(__b, __e, __o); + } + + // copy-construct raw array [__o, *) from strided array __a[<__n : __s>] + template + inline void + __valarray_copy_construct (const _Tp* __restrict__ __a, size_t __n, + size_t __s, _Tp* __restrict__ __o) + { + if (__is_trivial(_Tp)) + while (__n--) + { + *__o++ = *__a; + __a += __s; + } + else + while (__n--) + { + new(__o++) _Tp(*__a); + __a += __s; + } + } + + // copy-construct raw array [__o, *) from indexed array __a[__i[<__n>]] + template + inline void + __valarray_copy_construct (const _Tp* __restrict__ __a, + const size_t* __restrict__ __i, + _Tp* __restrict__ __o, size_t __n) + { + if (__is_trivial(_Tp)) + while (__n--) + *__o++ = __a[*__i++]; + else + while (__n--) + new (__o++) _Tp(__a[*__i++]); + } + + // Do the necessary cleanup when we're done with arrays. + template + inline void + __valarray_destroy_elements(_Tp* __b, _Tp* __e) + { + if (!__is_trivial(_Tp)) + while (__b != __e) + { + __b->~_Tp(); + ++__b; + } + } + + // Fill a plain array __a[<__n>] with __t + template + inline void + __valarray_fill(_Tp* __restrict__ __a, size_t __n, const _Tp& __t) + { + while (__n--) + *__a++ = __t; + } + + // fill strided array __a[<__n-1 : __s>] with __t + template + inline void + __valarray_fill(_Tp* __restrict__ __a, size_t __n, + size_t __s, const _Tp& __t) + { + for (size_t __i = 0; __i < __n; ++__i, __a += __s) + *__a = __t; + } + + // fill indirect array __a[__i[<__n>]] with __i + template + inline void + __valarray_fill(_Tp* __restrict__ __a, const size_t* __restrict__ __i, + size_t __n, const _Tp& __t) + { + for (size_t __j = 0; __j < __n; ++__j, ++__i) + __a[*__i] = __t; + } + + // copy plain array __a[<__n>] in __b[<__n>] + // For non-fundamental types, it is wrong to say 'memcpy()' + template + struct _Array_copier + { + inline static void + _S_do_it(const _Tp* __restrict__ __a, size_t __n, _Tp* __restrict__ __b) + { + while(__n--) + *__b++ = *__a++; + } + }; + + template + struct _Array_copier<_Tp, true> + { + inline static void + _S_do_it(const _Tp* __restrict__ __a, size_t __n, _Tp* __restrict__ __b) + { __builtin_memcpy(__b, __a, __n * sizeof (_Tp)); } + }; + + // Copy a plain array __a[<__n>] into a play array __b[<>] + template + inline void + __valarray_copy(const _Tp* __restrict__ __a, size_t __n, + _Tp* __restrict__ __b) + { + _Array_copier<_Tp, __is_trivial(_Tp)>::_S_do_it(__a, __n, __b); + } + + // Copy strided array __a[<__n : __s>] in plain __b[<__n>] + template + inline void + __valarray_copy(const _Tp* __restrict__ __a, size_t __n, size_t __s, + _Tp* __restrict__ __b) + { + for (size_t __i = 0; __i < __n; ++__i, ++__b, __a += __s) + *__b = *__a; + } + + // Copy a plain array __a[<__n>] into a strided array __b[<__n : __s>] + template + inline void + __valarray_copy(const _Tp* __restrict__ __a, _Tp* __restrict__ __b, + size_t __n, size_t __s) + { + for (size_t __i = 0; __i < __n; ++__i, ++__a, __b += __s) + *__b = *__a; + } + + // Copy strided array __src[<__n : __s1>] into another + // strided array __dst[< : __s2>]. Their sizes must match. + template + inline void + __valarray_copy(const _Tp* __restrict__ __src, size_t __n, size_t __s1, + _Tp* __restrict__ __dst, size_t __s2) + { + for (size_t __i = 0; __i < __n; ++__i) + __dst[__i * __s2] = __src[__i * __s1]; + } + + // Copy an indexed array __a[__i[<__n>]] in plain array __b[<__n>] + template + inline void + __valarray_copy(const _Tp* __restrict__ __a, + const size_t* __restrict__ __i, + _Tp* __restrict__ __b, size_t __n) + { + for (size_t __j = 0; __j < __n; ++__j, ++__b, ++__i) + *__b = __a[*__i]; + } + + // Copy a plain array __a[<__n>] in an indexed array __b[__i[<__n>]] + template + inline void + __valarray_copy(const _Tp* __restrict__ __a, size_t __n, + _Tp* __restrict__ __b, const size_t* __restrict__ __i) + { + for (size_t __j = 0; __j < __n; ++__j, ++__a, ++__i) + __b[*__i] = *__a; + } + + // Copy the __n first elements of an indexed array __src[<__i>] into + // another indexed array __dst[<__j>]. + template + inline void + __valarray_copy(const _Tp* __restrict__ __src, size_t __n, + const size_t* __restrict__ __i, + _Tp* __restrict__ __dst, const size_t* __restrict__ __j) + { + for (size_t __k = 0; __k < __n; ++__k) + __dst[*__j++] = __src[*__i++]; + } + + // + // Compute the sum of elements in range [__f, __l) + // This is a naive algorithm. It suffers from cancelling. + // In the future try to specialize + // for _Tp = float, double, long double using a more accurate + // algorithm. + // + template + inline _Tp + __valarray_sum(const _Tp* __f, const _Tp* __l) + { + _Tp __r = _Tp(); + while (__f != __l) + __r += *__f++; + return __r; + } + + // Compute the product of all elements in range [__f, __l) + template + inline _Tp + __valarray_product(const _Tp* __f, const _Tp* __l) + { + _Tp __r = _Tp(1); + while (__f != __l) + __r = __r * *__f++; + return __r; + } + + // Compute the min/max of an array-expression + template + inline typename _Ta::value_type + __valarray_min(const _Ta& __a) + { + size_t __s = __a.size(); + typedef typename _Ta::value_type _Value_type; + _Value_type __r = __s == 0 ? _Value_type() : __a[0]; + for (size_t __i = 1; __i < __s; ++__i) + { + _Value_type __t = __a[__i]; + if (__t < __r) + __r = __t; + } + return __r; + } + + template + inline typename _Ta::value_type + __valarray_max(const _Ta& __a) + { + size_t __s = __a.size(); + typedef typename _Ta::value_type _Value_type; + _Value_type __r = __s == 0 ? _Value_type() : __a[0]; + for (size_t __i = 1; __i < __s; ++__i) + { + _Value_type __t = __a[__i]; + if (__t > __r) + __r = __t; + } + return __r; + } + + // + // Helper class _Array, first layer of valarray abstraction. + // All operations on valarray should be forwarded to this class + // whenever possible. -- gdr + // + + template + struct _Array + { + explicit _Array(size_t); + explicit _Array(_Tp* const __restrict__); + explicit _Array(const valarray<_Tp>&); + _Array(const _Tp* __restrict__, size_t); + + _Tp* begin() const; + + _Tp* const __restrict__ _M_data; + }; + + + // Copy-construct plain array __b[<__n>] from indexed array __a[__i[<__n>]] + template + inline void + __valarray_copy_construct(_Array<_Tp> __a, _Array __i, + _Array<_Tp> __b, size_t __n) + { std::__valarray_copy_construct(__a._M_data, __i._M_data, + __b._M_data, __n); } + + // Copy-construct plain array __b[<__n>] from strided array __a[<__n : __s>] + template + inline void + __valarray_copy_construct(_Array<_Tp> __a, size_t __n, size_t __s, + _Array<_Tp> __b) + { std::__valarray_copy_construct(__a._M_data, __n, __s, __b._M_data); } + + template + inline void + __valarray_fill (_Array<_Tp> __a, size_t __n, const _Tp& __t) + { std::__valarray_fill(__a._M_data, __n, __t); } + + template + inline void + __valarray_fill(_Array<_Tp> __a, size_t __n, size_t __s, const _Tp& __t) + { std::__valarray_fill(__a._M_data, __n, __s, __t); } + + template + inline void + __valarray_fill(_Array<_Tp> __a, _Array __i, + size_t __n, const _Tp& __t) + { std::__valarray_fill(__a._M_data, __i._M_data, __n, __t); } + + // Copy a plain array __a[<__n>] into a play array __b[<>] + template + inline void + __valarray_copy(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b) + { std::__valarray_copy(__a._M_data, __n, __b._M_data); } + + // Copy strided array __a[<__n : __s>] in plain __b[<__n>] + template + inline void + __valarray_copy(_Array<_Tp> __a, size_t __n, size_t __s, _Array<_Tp> __b) + { std::__valarray_copy(__a._M_data, __n, __s, __b._M_data); } + + // Copy a plain array __a[<__n>] into a strided array __b[<__n : __s>] + template + inline void + __valarray_copy(_Array<_Tp> __a, _Array<_Tp> __b, size_t __n, size_t __s) + { __valarray_copy(__a._M_data, __b._M_data, __n, __s); } + + // Copy strided array __src[<__n : __s1>] into another + // strided array __dst[< : __s2>]. Their sizes must match. + template + inline void + __valarray_copy(_Array<_Tp> __a, size_t __n, size_t __s1, + _Array<_Tp> __b, size_t __s2) + { std::__valarray_copy(__a._M_data, __n, __s1, __b._M_data, __s2); } + + // Copy an indexed array __a[__i[<__n>]] in plain array __b[<__n>] + template + inline void + __valarray_copy(_Array<_Tp> __a, _Array __i, + _Array<_Tp> __b, size_t __n) + { std::__valarray_copy(__a._M_data, __i._M_data, __b._M_data, __n); } + + // Copy a plain array __a[<__n>] in an indexed array __b[__i[<__n>]] + template + inline void + __valarray_copy(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b, + _Array __i) + { std::__valarray_copy(__a._M_data, __n, __b._M_data, __i._M_data); } + + // Copy the __n first elements of an indexed array __src[<__i>] into + // another indexed array __dst[<__j>]. + template + inline void + __valarray_copy(_Array<_Tp> __src, size_t __n, _Array __i, + _Array<_Tp> __dst, _Array __j) + { + std::__valarray_copy(__src._M_data, __n, __i._M_data, + __dst._M_data, __j._M_data); + } + + template + inline + _Array<_Tp>::_Array(size_t __n) + : _M_data(__valarray_get_storage<_Tp>(__n)) + { std::__valarray_default_construct(_M_data, _M_data + __n); } + + template + inline + _Array<_Tp>::_Array(_Tp* const __restrict__ __p) + : _M_data (__p) {} + + template + inline + _Array<_Tp>::_Array(const valarray<_Tp>& __v) + : _M_data (__v._M_data) {} + + template + inline + _Array<_Tp>::_Array(const _Tp* __restrict__ __b, size_t __s) + : _M_data(__valarray_get_storage<_Tp>(__s)) + { std::__valarray_copy_construct(__b, __s, _M_data); } + + template + inline _Tp* + _Array<_Tp>::begin () const + { return _M_data; } + +#define _DEFINE_ARRAY_FUNCTION(_Op, _Name) \ + template \ + inline void \ + _Array_augmented_##_Name(_Array<_Tp> __a, size_t __n, const _Tp& __t) \ + { \ + for (_Tp* __p = __a._M_data; __p < __a._M_data + __n; ++__p) \ + *__p _Op##= __t; \ + } \ + \ + template \ + inline void \ + _Array_augmented_##_Name(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b) \ + { \ + _Tp* __p = __a._M_data; \ + for (_Tp* __q = __b._M_data; __q < __b._M_data + __n; ++__p, ++__q) \ + *__p _Op##= *__q; \ + } \ + \ + template \ + void \ + _Array_augmented_##_Name(_Array<_Tp> __a, \ + const _Expr<_Dom, _Tp>& __e, size_t __n) \ + { \ + _Tp* __p(__a._M_data); \ + for (size_t __i = 0; __i < __n; ++__i, ++__p) \ + *__p _Op##= __e[__i]; \ + } \ + \ + template \ + inline void \ + _Array_augmented_##_Name(_Array<_Tp> __a, size_t __n, size_t __s, \ + _Array<_Tp> __b) \ + { \ + _Tp* __q(__b._M_data); \ + for (_Tp* __p = __a._M_data; __p < __a._M_data + __s * __n; \ + __p += __s, ++__q) \ + *__p _Op##= *__q; \ + } \ + \ + template \ + inline void \ + _Array_augmented_##_Name(_Array<_Tp> __a, _Array<_Tp> __b, \ + size_t __n, size_t __s) \ + { \ + _Tp* __q(__b._M_data); \ + for (_Tp* __p = __a._M_data; __p < __a._M_data + __n; \ + ++__p, __q += __s) \ + *__p _Op##= *__q; \ + } \ + \ + template \ + void \ + _Array_augmented_##_Name(_Array<_Tp> __a, size_t __s, \ + const _Expr<_Dom, _Tp>& __e, size_t __n) \ + { \ + _Tp* __p(__a._M_data); \ + for (size_t __i = 0; __i < __n; ++__i, __p += __s) \ + *__p _Op##= __e[__i]; \ + } \ + \ + template \ + inline void \ + _Array_augmented_##_Name(_Array<_Tp> __a, _Array __i, \ + _Array<_Tp> __b, size_t __n) \ + { \ + _Tp* __q(__b._M_data); \ + for (size_t* __j = __i._M_data; __j < __i._M_data + __n; \ + ++__j, ++__q) \ + __a._M_data[*__j] _Op##= *__q; \ + } \ + \ + template \ + inline void \ + _Array_augmented_##_Name(_Array<_Tp> __a, size_t __n, \ + _Array<_Tp> __b, _Array __i) \ + { \ + _Tp* __p(__a._M_data); \ + for (size_t* __j = __i._M_data; __j<__i._M_data + __n; \ + ++__j, ++__p) \ + *__p _Op##= __b._M_data[*__j]; \ + } \ + \ + template \ + void \ + _Array_augmented_##_Name(_Array<_Tp> __a, _Array __i, \ + const _Expr<_Dom, _Tp>& __e, size_t __n) \ + { \ + size_t* __j(__i._M_data); \ + for (size_t __k = 0; __k<__n; ++__k, ++__j) \ + __a._M_data[*__j] _Op##= __e[__k]; \ + } \ + \ + template \ + void \ + _Array_augmented_##_Name(_Array<_Tp> __a, _Array __m, \ + _Array<_Tp> __b, size_t __n) \ + { \ + bool* __ok(__m._M_data); \ + _Tp* __p(__a._M_data); \ + for (_Tp* __q = __b._M_data; __q < __b._M_data + __n; \ + ++__q, ++__ok, ++__p) \ + { \ + while (! *__ok) \ + { \ + ++__ok; \ + ++__p; \ + } \ + *__p _Op##= *__q; \ + } \ + } \ + \ + template \ + void \ + _Array_augmented_##_Name(_Array<_Tp> __a, size_t __n, \ + _Array<_Tp> __b, _Array __m) \ + { \ + bool* __ok(__m._M_data); \ + _Tp* __q(__b._M_data); \ + for (_Tp* __p = __a._M_data; __p < __a._M_data + __n; \ + ++__p, ++__ok, ++__q) \ + { \ + while (! *__ok) \ + { \ + ++__ok; \ + ++__q; \ + } \ + *__p _Op##= *__q; \ + } \ + } \ + \ + template \ + void \ + _Array_augmented_##_Name(_Array<_Tp> __a, _Array __m, \ + const _Expr<_Dom, _Tp>& __e, size_t __n) \ + { \ + bool* __ok(__m._M_data); \ + _Tp* __p(__a._M_data); \ + for (size_t __i = 0; __i < __n; ++__i, ++__ok, ++__p) \ + { \ + while (! *__ok) \ + { \ + ++__ok; \ + ++__p; \ + } \ + *__p _Op##= __e[__i]; \ + } \ + } + + _DEFINE_ARRAY_FUNCTION(+, __plus) + _DEFINE_ARRAY_FUNCTION(-, __minus) + _DEFINE_ARRAY_FUNCTION(*, __multiplies) + _DEFINE_ARRAY_FUNCTION(/, __divides) + _DEFINE_ARRAY_FUNCTION(%, __modulus) + _DEFINE_ARRAY_FUNCTION(^, __bitwise_xor) + _DEFINE_ARRAY_FUNCTION(|, __bitwise_or) + _DEFINE_ARRAY_FUNCTION(&, __bitwise_and) + _DEFINE_ARRAY_FUNCTION(<<, __shift_left) + _DEFINE_ARRAY_FUNCTION(>>, __shift_right) + +#undef _DEFINE_ARRAY_FUNCTION + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +# include + +#endif /* _ARRAY_H */ diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/valarray_array.tcc b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/valarray_array.tcc new file mode 100755 index 0000000..6f2f6e2 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/valarray_array.tcc @@ -0,0 +1,244 @@ +// The template and inlines for the -*- C++ -*- internal _Array helper class. + +// Copyright (C) 1997-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file bits/valarray_array.tcc + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{valarray} + */ + +// Written by Gabriel Dos Reis + +#ifndef _VALARRAY_ARRAY_TCC +#define _VALARRAY_ARRAY_TCC 1 + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + template + void + __valarray_fill(_Array<_Tp> __a, size_t __n, _Array __m, + const _Tp& __t) + { + _Tp* __p = __a._M_data; + bool* __ok (__m._M_data); + for (size_t __i=0; __i < __n; ++__i, ++__ok, ++__p) + { + while (!*__ok) + { + ++__ok; + ++__p; + } + *__p = __t; + } + } + + // Copy n elements of a into consecutive elements of b. When m is + // false, the corresponding element of a is skipped. m must contain + // at least n true elements. a must contain at least n elements and + // enough elements to match up with m through the nth true element + // of m. I.e. if n is 10, m has 15 elements with 5 false followed + // by 10 true, a must have 15 elements. + template + void + __valarray_copy(_Array<_Tp> __a, _Array __m, _Array<_Tp> __b, + size_t __n) + { + _Tp* __p (__a._M_data); + bool* __ok (__m._M_data); + for (_Tp* __q = __b._M_data; __q < __b._M_data + __n; + ++__q, ++__ok, ++__p) + { + while (! *__ok) + { + ++__ok; + ++__p; + } + *__q = *__p; + } + } + + // Copy n consecutive elements from a into elements of b. Elements + // of b are skipped if the corresponding element of m is false. m + // must contain at least n true elements. b must have at least as + // many elements as the index of the nth true element of m. I.e. if + // m has 15 elements with 5 false followed by 10 true, b must have + // at least 15 elements. + template + void + __valarray_copy(_Array<_Tp> __a, size_t __n, _Array<_Tp> __b, + _Array __m) + { + _Tp* __q (__b._M_data); + bool* __ok (__m._M_data); + for (_Tp* __p = __a._M_data; __p < __a._M_data+__n; + ++__p, ++__ok, ++__q) + { + while (! *__ok) + { + ++__ok; + ++__q; + } + *__q = *__p; + } + } + + // Copy n elements from a into elements of b. Elements of a are + // skipped if the corresponding element of m is false. Elements of + // b are skipped if the corresponding element of k is false. m and + // k must contain at least n true elements. a and b must have at + // least as many elements as the index of the nth true element of m. + template + void + __valarray_copy(_Array<_Tp> __a, _Array __m, size_t __n, + _Array<_Tp> __b, _Array __k) + { + _Tp* __p (__a._M_data); + _Tp* __q (__b._M_data); + bool* __srcok (__m._M_data); + bool* __dstok (__k._M_data); + for (size_t __i = 0; __i < __n; + ++__srcok, ++__p, ++__dstok, ++__q, ++__i) + { + while (! *__srcok) + { + ++__srcok; + ++__p; + } + while (! *__dstok) + { + ++__dstok; + ++__q; + } + *__q = *__p; + } + } + + // Copy n consecutive elements of e into consecutive elements of a. + // I.e. a[i] = e[i]. + template + void + __valarray_copy(const _Expr<_Dom, _Tp>& __e, size_t __n, _Array<_Tp> __a) + { + _Tp* __p (__a._M_data); + for (size_t __i = 0; __i < __n; ++__i, ++__p) + *__p = __e[__i]; + } + + // Copy n consecutive elements of e into elements of a using stride + // s. I.e., a[0] = e[0], a[s] = e[1], a[2*s] = e[2]. + template + void + __valarray_copy(const _Expr<_Dom, _Tp>& __e, size_t __n, + _Array<_Tp> __a, size_t __s) + { + _Tp* __p (__a._M_data); + for (size_t __i = 0; __i < __n; ++__i, __p += __s) + *__p = __e[__i]; + } + + // Copy n consecutive elements of e into elements of a indexed by + // contents of i. I.e., a[i[0]] = e[0]. + template + void + __valarray_copy(const _Expr<_Dom, _Tp>& __e, size_t __n, + _Array<_Tp> __a, _Array __i) + { + size_t* __j (__i._M_data); + for (size_t __k = 0; __k < __n; ++__k, ++__j) + __a._M_data[*__j] = __e[__k]; + } + + // Copy n elements of e indexed by contents of f into elements of a + // indexed by contents of i. I.e., a[i[0]] = e[f[0]]. + template + void + __valarray_copy(_Array<_Tp> __e, _Array __f, + size_t __n, + _Array<_Tp> __a, _Array __i) + { + size_t* __g (__f._M_data); + size_t* __j (__i._M_data); + for (size_t __k = 0; __k < __n; ++__k, ++__j, ++__g) + __a._M_data[*__j] = __e._M_data[*__g]; + } + + // Copy n consecutive elements of e into elements of a. Elements of + // a are skipped if the corresponding element of m is false. m must + // have at least n true elements and a must have at least as many + // elements as the index of the nth true element of m. I.e. if m + // has 5 false followed by 10 true elements and n == 10, a must have + // at least 15 elements. + template + void + __valarray_copy(const _Expr<_Dom, _Tp>& __e, size_t __n, + _Array<_Tp> __a, _Array __m) + { + bool* __ok (__m._M_data); + _Tp* __p (__a._M_data); + for (size_t __i = 0; __i < __n; ++__i, ++__ok, ++__p) + { + while (! *__ok) + { + ++__ok; + ++__p; + } + *__p = __e[__i]; + } + } + + + template + void + __valarray_copy_construct(const _Expr<_Dom, _Tp>& __e, size_t __n, + _Array<_Tp> __a) + { + _Tp* __p (__a._M_data); + for (size_t __i = 0; __i < __n; ++__i, ++__p) + new (__p) _Tp(__e[__i]); + } + + + template + void + __valarray_copy_construct(_Array<_Tp> __a, _Array __m, + _Array<_Tp> __b, size_t __n) + { + _Tp* __p (__a._M_data); + bool* __ok (__m._M_data); + for (_Tp* __q = __b._M_data; __q < __b._M_data+__n; ++__q, ++__ok, ++__p) + { + while (! *__ok) + { + ++__ok; + ++__p; + } + new (__q) _Tp(*__p); + } + } + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif /* _VALARRAY_ARRAY_TCC */ diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/valarray_before.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/valarray_before.h new file mode 100755 index 0000000..fb5ec74 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/valarray_before.h @@ -0,0 +1,733 @@ +// The template and inlines for the -*- C++ -*- internal _Meta class. + +// Copyright (C) 1997-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file bits/valarray_before.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{valarray} + */ + +// Written by Gabriel Dos Reis + +#ifndef _VALARRAY_BEFORE_H +#define _VALARRAY_BEFORE_H 1 + +#pragma GCC system_header + +#include + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + // + // Implementing a loosened valarray return value is tricky. + // First we need to meet 26.3.1/3: we should not add more than + // two levels of template nesting. Therefore we resort to template + // template to "flatten" loosened return value types. + // At some point we use partial specialization to remove one level + // template nesting due to _Expr<> + // + + // This class is NOT defined. It doesn't need to. + template class _Constant; + + // Implementations of unary functions applied to valarray<>s. + // I use hard-coded object functions here instead of a generic + // approach like pointers to function: + // 1) correctness: some functions take references, others values. + // we can't deduce the correct type afterwards. + // 2) efficiency -- object functions can be easily inlined + // 3) be Koenig-lookup-friendly + + struct _Abs + { + template + _Tp operator()(const _Tp& __t) const + { return abs(__t); } + }; + + struct _Cos + { + template + _Tp operator()(const _Tp& __t) const + { return cos(__t); } + }; + + struct _Acos + { + template + _Tp operator()(const _Tp& __t) const + { return acos(__t); } + }; + + struct _Cosh + { + template + _Tp operator()(const _Tp& __t) const + { return cosh(__t); } + }; + + struct _Sin + { + template + _Tp operator()(const _Tp& __t) const + { return sin(__t); } + }; + + struct _Asin + { + template + _Tp operator()(const _Tp& __t) const + { return asin(__t); } + }; + + struct _Sinh + { + template + _Tp operator()(const _Tp& __t) const + { return sinh(__t); } + }; + + struct _Tan + { + template + _Tp operator()(const _Tp& __t) const + { return tan(__t); } + }; + + struct _Atan + { + template + _Tp operator()(const _Tp& __t) const + { return atan(__t); } + }; + + struct _Tanh + { + template + _Tp operator()(const _Tp& __t) const + { return tanh(__t); } + }; + + struct _Exp + { + template + _Tp operator()(const _Tp& __t) const + { return exp(__t); } + }; + + struct _Log + { + template + _Tp operator()(const _Tp& __t) const + { return log(__t); } + }; + + struct _Log10 + { + template + _Tp operator()(const _Tp& __t) const + { return log10(__t); } + }; + + struct _Sqrt + { + template + _Tp operator()(const _Tp& __t) const + { return sqrt(__t); } + }; + + // In the past, we used to tailor operator applications semantics + // to the specialization of standard function objects (i.e. plus<>, etc.) + // That is incorrect. Therefore we provide our own surrogates. + + struct __unary_plus + { + template + _Tp operator()(const _Tp& __t) const + { return +__t; } + }; + + struct __negate + { + template + _Tp operator()(const _Tp& __t) const + { return -__t; } + }; + + struct __bitwise_not + { + template + _Tp operator()(const _Tp& __t) const + { return ~__t; } + }; + + struct __plus + { + template + _Tp operator()(const _Tp& __x, const _Tp& __y) const + { return __x + __y; } + }; + + struct __minus + { + template + _Tp operator()(const _Tp& __x, const _Tp& __y) const + { return __x - __y; } + }; + + struct __multiplies + { + template + _Tp operator()(const _Tp& __x, const _Tp& __y) const + { return __x * __y; } + }; + + struct __divides + { + template + _Tp operator()(const _Tp& __x, const _Tp& __y) const + { return __x / __y; } + }; + + struct __modulus + { + template + _Tp operator()(const _Tp& __x, const _Tp& __y) const + { return __x % __y; } + }; + + struct __bitwise_xor + { + template + _Tp operator()(const _Tp& __x, const _Tp& __y) const + { return __x ^ __y; } + }; + + struct __bitwise_and + { + template + _Tp operator()(const _Tp& __x, const _Tp& __y) const + { return __x & __y; } + }; + + struct __bitwise_or + { + template + _Tp operator()(const _Tp& __x, const _Tp& __y) const + { return __x | __y; } + }; + + struct __shift_left + { + template + _Tp operator()(const _Tp& __x, const _Tp& __y) const + { return __x << __y; } + }; + + struct __shift_right + { + template + _Tp operator()(const _Tp& __x, const _Tp& __y) const + { return __x >> __y; } + }; + + struct __logical_and + { + template + bool operator()(const _Tp& __x, const _Tp& __y) const + { return __x && __y; } + }; + + struct __logical_or + { + template + bool operator()(const _Tp& __x, const _Tp& __y) const + { return __x || __y; } + }; + + struct __logical_not + { + template + bool operator()(const _Tp& __x) const + { return !__x; } + }; + + struct __equal_to + { + template + bool operator()(const _Tp& __x, const _Tp& __y) const + { return __x == __y; } + }; + + struct __not_equal_to + { + template + bool operator()(const _Tp& __x, const _Tp& __y) const + { return __x != __y; } + }; + + struct __less + { + template + bool operator()(const _Tp& __x, const _Tp& __y) const + { return __x < __y; } + }; + + struct __greater + { + template + bool operator()(const _Tp& __x, const _Tp& __y) const + { return __x > __y; } + }; + + struct __less_equal + { + template + bool operator()(const _Tp& __x, const _Tp& __y) const + { return __x <= __y; } + }; + + struct __greater_equal + { + template + bool operator()(const _Tp& __x, const _Tp& __y) const + { return __x >= __y; } + }; + + // The few binary functions we miss. + struct _Atan2 + { + template + _Tp operator()(const _Tp& __x, const _Tp& __y) const + { return atan2(__x, __y); } + }; + + struct _Pow + { + template + _Tp operator()(const _Tp& __x, const _Tp& __y) const + { return pow(__x, __y); } + }; + + + // We need these bits in order to recover the return type of + // some functions/operators now that we're no longer using + // function templates. + template + struct __fun + { + typedef _Tp result_type; + }; + + // several specializations for relational operators. + template + struct __fun<__logical_not, _Tp> + { + typedef bool result_type; + }; + + template + struct __fun<__logical_and, _Tp> + { + typedef bool result_type; + }; + + template + struct __fun<__logical_or, _Tp> + { + typedef bool result_type; + }; + + template + struct __fun<__less, _Tp> + { + typedef bool result_type; + }; + + template + struct __fun<__greater, _Tp> + { + typedef bool result_type; + }; + + template + struct __fun<__less_equal, _Tp> + { + typedef bool result_type; + }; + + template + struct __fun<__greater_equal, _Tp> + { + typedef bool result_type; + }; + + template + struct __fun<__equal_to, _Tp> + { + typedef bool result_type; + }; + + template + struct __fun<__not_equal_to, _Tp> + { + typedef bool result_type; + }; + + // + // Apply function taking a value/const reference closure + // + + template + class _FunBase + { + public: + typedef typename _Dom::value_type value_type; + + _FunBase(const _Dom& __e, value_type __f(_Arg)) + : _M_expr(__e), _M_func(__f) {} + + value_type operator[](size_t __i) const + { return _M_func (_M_expr[__i]); } + + size_t size() const { return _M_expr.size ();} + + private: + const _Dom& _M_expr; + value_type (*_M_func)(_Arg); + }; + + template + struct _ValFunClos<_Expr,_Dom> : _FunBase<_Dom, typename _Dom::value_type> + { + typedef _FunBase<_Dom, typename _Dom::value_type> _Base; + typedef typename _Base::value_type value_type; + typedef value_type _Tp; + + _ValFunClos(const _Dom& __e, _Tp __f(_Tp)) : _Base(__e, __f) {} + }; + + template + struct _ValFunClos<_ValArray,_Tp> : _FunBase, _Tp> + { + typedef _FunBase, _Tp> _Base; + typedef _Tp value_type; + + _ValFunClos(const valarray<_Tp>& __v, _Tp __f(_Tp)) : _Base(__v, __f) {} + }; + + template + struct _RefFunClos<_Expr, _Dom> + : _FunBase<_Dom, const typename _Dom::value_type&> + { + typedef _FunBase<_Dom, const typename _Dom::value_type&> _Base; + typedef typename _Base::value_type value_type; + typedef value_type _Tp; + + _RefFunClos(const _Dom& __e, _Tp __f(const _Tp&)) + : _Base(__e, __f) {} + }; + + template + struct _RefFunClos<_ValArray, _Tp> + : _FunBase, const _Tp&> + { + typedef _FunBase, const _Tp&> _Base; + typedef _Tp value_type; + + _RefFunClos(const valarray<_Tp>& __v, _Tp __f(const _Tp&)) + : _Base(__v, __f) {} + }; + + // + // Unary expression closure. + // + + template + class _UnBase + { + public: + typedef typename _Arg::value_type _Vt; + typedef typename __fun<_Oper, _Vt>::result_type value_type; + + _UnBase(const _Arg& __e) : _M_expr(__e) {} + + value_type operator[](size_t __i) const + { return _Oper()(_M_expr[__i]); } + + size_t size() const { return _M_expr.size(); } + + private: + const _Arg& _M_expr; + }; + + template + struct _UnClos<_Oper, _Expr, _Dom> + : _UnBase<_Oper, _Dom> + { + typedef _Dom _Arg; + typedef _UnBase<_Oper, _Dom> _Base; + typedef typename _Base::value_type value_type; + + _UnClos(const _Arg& __e) : _Base(__e) {} + }; + + template + struct _UnClos<_Oper, _ValArray, _Tp> + : _UnBase<_Oper, valarray<_Tp> > + { + typedef valarray<_Tp> _Arg; + typedef _UnBase<_Oper, valarray<_Tp> > _Base; + typedef typename _Base::value_type value_type; + + _UnClos(const _Arg& __e) : _Base(__e) {} + }; + + + // + // Binary expression closure. + // + + template + class _BinBase + { + public: + typedef typename _FirstArg::value_type _Vt; + typedef typename __fun<_Oper, _Vt>::result_type value_type; + + _BinBase(const _FirstArg& __e1, const _SecondArg& __e2) + : _M_expr1(__e1), _M_expr2(__e2) {} + + value_type operator[](size_t __i) const + { return _Oper()(_M_expr1[__i], _M_expr2[__i]); } + + size_t size() const { return _M_expr1.size(); } + + private: + const _FirstArg& _M_expr1; + const _SecondArg& _M_expr2; + }; + + + template + class _BinBase2 + { + public: + typedef typename _Clos::value_type _Vt; + typedef typename __fun<_Oper, _Vt>::result_type value_type; + + _BinBase2(const _Clos& __e, const _Vt& __t) + : _M_expr1(__e), _M_expr2(__t) {} + + value_type operator[](size_t __i) const + { return _Oper()(_M_expr1[__i], _M_expr2); } + + size_t size() const { return _M_expr1.size(); } + + private: + const _Clos& _M_expr1; + const _Vt& _M_expr2; + }; + + template + class _BinBase1 + { + public: + typedef typename _Clos::value_type _Vt; + typedef typename __fun<_Oper, _Vt>::result_type value_type; + + _BinBase1(const _Vt& __t, const _Clos& __e) + : _M_expr1(__t), _M_expr2(__e) {} + + value_type operator[](size_t __i) const + { return _Oper()(_M_expr1, _M_expr2[__i]); } + + size_t size() const { return _M_expr2.size(); } + + private: + const _Vt& _M_expr1; + const _Clos& _M_expr2; + }; + + template + struct _BinClos<_Oper, _Expr, _Expr, _Dom1, _Dom2> + : _BinBase<_Oper, _Dom1, _Dom2> + { + typedef _BinBase<_Oper, _Dom1, _Dom2> _Base; + typedef typename _Base::value_type value_type; + + _BinClos(const _Dom1& __e1, const _Dom2& __e2) : _Base(__e1, __e2) {} + }; + + template + struct _BinClos<_Oper,_ValArray, _ValArray, _Tp, _Tp> + : _BinBase<_Oper, valarray<_Tp>, valarray<_Tp> > + { + typedef _BinBase<_Oper, valarray<_Tp>, valarray<_Tp> > _Base; + typedef typename _Base::value_type value_type; + + _BinClos(const valarray<_Tp>& __v, const valarray<_Tp>& __w) + : _Base(__v, __w) {} + }; + + template + struct _BinClos<_Oper, _Expr, _ValArray, _Dom, typename _Dom::value_type> + : _BinBase<_Oper, _Dom, valarray > + { + typedef typename _Dom::value_type _Tp; + typedef _BinBase<_Oper,_Dom,valarray<_Tp> > _Base; + typedef typename _Base::value_type value_type; + + _BinClos(const _Dom& __e1, const valarray<_Tp>& __e2) + : _Base(__e1, __e2) {} + }; + + template + struct _BinClos<_Oper, _ValArray, _Expr, typename _Dom::value_type, _Dom> + : _BinBase<_Oper, valarray,_Dom> + { + typedef typename _Dom::value_type _Tp; + typedef _BinBase<_Oper, valarray<_Tp>, _Dom> _Base; + typedef typename _Base::value_type value_type; + + _BinClos(const valarray<_Tp>& __e1, const _Dom& __e2) + : _Base(__e1, __e2) {} + }; + + template + struct _BinClos<_Oper, _Expr, _Constant, _Dom, typename _Dom::value_type> + : _BinBase2<_Oper, _Dom> + { + typedef typename _Dom::value_type _Tp; + typedef _BinBase2<_Oper,_Dom> _Base; + typedef typename _Base::value_type value_type; + + _BinClos(const _Dom& __e1, const _Tp& __e2) : _Base(__e1, __e2) {} + }; + + template + struct _BinClos<_Oper, _Constant, _Expr, typename _Dom::value_type, _Dom> + : _BinBase1<_Oper, _Dom> + { + typedef typename _Dom::value_type _Tp; + typedef _BinBase1<_Oper, _Dom> _Base; + typedef typename _Base::value_type value_type; + + _BinClos(const _Tp& __e1, const _Dom& __e2) : _Base(__e1, __e2) {} + }; + + template + struct _BinClos<_Oper, _ValArray, _Constant, _Tp, _Tp> + : _BinBase2<_Oper, valarray<_Tp> > + { + typedef _BinBase2<_Oper,valarray<_Tp> > _Base; + typedef typename _Base::value_type value_type; + + _BinClos(const valarray<_Tp>& __v, const _Tp& __t) : _Base(__v, __t) {} + }; + + template + struct _BinClos<_Oper, _Constant, _ValArray, _Tp, _Tp> + : _BinBase1<_Oper, valarray<_Tp> > + { + typedef _BinBase1<_Oper, valarray<_Tp> > _Base; + typedef typename _Base::value_type value_type; + + _BinClos(const _Tp& __t, const valarray<_Tp>& __v) : _Base(__t, __v) {} + }; + + // + // slice_array closure. + // + template + class _SBase + { + public: + typedef typename _Dom::value_type value_type; + + _SBase (const _Dom& __e, const slice& __s) + : _M_expr (__e), _M_slice (__s) {} + + value_type + operator[] (size_t __i) const + { return _M_expr[_M_slice.start () + __i * _M_slice.stride ()]; } + + size_t + size() const + { return _M_slice.size (); } + + private: + const _Dom& _M_expr; + const slice& _M_slice; + }; + + template + class _SBase<_Array<_Tp> > + { + public: + typedef _Tp value_type; + + _SBase (_Array<_Tp> __a, const slice& __s) + : _M_array (__a._M_data+__s.start()), _M_size (__s.size()), + _M_stride (__s.stride()) {} + + value_type + operator[] (size_t __i) const + { return _M_array._M_data[__i * _M_stride]; } + + size_t + size() const + { return _M_size; } + + private: + const _Array<_Tp> _M_array; + const size_t _M_size; + const size_t _M_stride; + }; + + template + struct _SClos<_Expr, _Dom> + : _SBase<_Dom> + { + typedef _SBase<_Dom> _Base; + typedef typename _Base::value_type value_type; + + _SClos (const _Dom& __e, const slice& __s) : _Base (__e, __s) {} + }; + + template + struct _SClos<_ValArray, _Tp> + : _SBase<_Array<_Tp> > + { + typedef _SBase<_Array<_Tp> > _Base; + typedef _Tp value_type; + + _SClos (_Array<_Tp> __a, const slice& __s) : _Base (__a, __s) {} + }; + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif /* _CPP_VALARRAY_BEFORE_H */ diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/vector.tcc b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/vector.tcc new file mode 100755 index 0000000..704a644 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bits/vector.tcc @@ -0,0 +1,887 @@ +// Vector implementation (out of line) -*- C++ -*- + +// Copyright (C) 2001-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/* + * + * Copyright (c) 1994 + * Hewlett-Packard Company + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Hewlett-Packard Company makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + * + * + * Copyright (c) 1996 + * Silicon Graphics Computer Systems, Inc. + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Silicon Graphics makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + */ + +/** @file bits/vector.tcc + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{vector} + */ + +#ifndef _VECTOR_TCC +#define _VECTOR_TCC 1 + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_CONTAINER + + template + void + vector<_Tp, _Alloc>:: + reserve(size_type __n) + { + if (__n > this->max_size()) + __throw_length_error(__N("vector::reserve")); + if (this->capacity() < __n) + { + const size_type __old_size = size(); + pointer __tmp = _M_allocate_and_copy(__n, + _GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(this->_M_impl._M_start), + _GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(this->_M_impl._M_finish)); + std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish, + _M_get_Tp_allocator()); + _M_deallocate(this->_M_impl._M_start, + this->_M_impl._M_end_of_storage + - this->_M_impl._M_start); + this->_M_impl._M_start = __tmp; + this->_M_impl._M_finish = __tmp + __old_size; + this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n; + } + } + +#if __cplusplus >= 201103L + template + template + void + vector<_Tp, _Alloc>:: + emplace_back(_Args&&... __args) + { + if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage) + { + _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish, + std::forward<_Args>(__args)...); + ++this->_M_impl._M_finish; + } + else + _M_emplace_back_aux(std::forward<_Args>(__args)...); + } +#endif + + template + typename vector<_Tp, _Alloc>::iterator + vector<_Tp, _Alloc>:: +#if __cplusplus >= 201103L + insert(const_iterator __position, const value_type& __x) +#else + insert(iterator __position, const value_type& __x) +#endif + { + const size_type __n = __position - begin(); + if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage + && __position == end()) + { + _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish, __x); + ++this->_M_impl._M_finish; + } + else + { +#if __cplusplus >= 201103L + const auto __pos = begin() + (__position - cbegin()); + if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage) + { + _Tp __x_copy = __x; + _M_insert_aux(__pos, std::move(__x_copy)); + } + else + _M_insert_aux(__pos, __x); +#else + _M_insert_aux(__position, __x); +#endif + } + return iterator(this->_M_impl._M_start + __n); + } + + template + typename vector<_Tp, _Alloc>::iterator + vector<_Tp, _Alloc>:: + _M_erase(iterator __position) + { + if (__position + 1 != end()) + _GLIBCXX_MOVE3(__position + 1, end(), __position); + --this->_M_impl._M_finish; + _Alloc_traits::destroy(this->_M_impl, this->_M_impl._M_finish); + return __position; + } + + template + typename vector<_Tp, _Alloc>::iterator + vector<_Tp, _Alloc>:: + _M_erase(iterator __first, iterator __last) + { + if (__first != __last) + { + if (__last != end()) + _GLIBCXX_MOVE3(__last, end(), __first); + _M_erase_at_end(__first.base() + (end() - __last)); + } + return __first; + } + + template + vector<_Tp, _Alloc>& + vector<_Tp, _Alloc>:: + operator=(const vector<_Tp, _Alloc>& __x) + { + if (&__x != this) + { +#if __cplusplus >= 201103L + if (_Alloc_traits::_S_propagate_on_copy_assign()) + { + if (!_Alloc_traits::_S_always_equal() + && _M_get_Tp_allocator() != __x._M_get_Tp_allocator()) + { + // replacement allocator cannot free existing storage + this->clear(); + _M_deallocate(this->_M_impl._M_start, + this->_M_impl._M_end_of_storage + - this->_M_impl._M_start); + this->_M_impl._M_start = nullptr; + this->_M_impl._M_finish = nullptr; + this->_M_impl._M_end_of_storage = nullptr; + } + std::__alloc_on_copy(_M_get_Tp_allocator(), + __x._M_get_Tp_allocator()); + } +#endif + const size_type __xlen = __x.size(); + if (__xlen > capacity()) + { + pointer __tmp = _M_allocate_and_copy(__xlen, __x.begin(), + __x.end()); + std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish, + _M_get_Tp_allocator()); + _M_deallocate(this->_M_impl._M_start, + this->_M_impl._M_end_of_storage + - this->_M_impl._M_start); + this->_M_impl._M_start = __tmp; + this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __xlen; + } + else if (size() >= __xlen) + { + std::_Destroy(std::copy(__x.begin(), __x.end(), begin()), + end(), _M_get_Tp_allocator()); + } + else + { + std::copy(__x._M_impl._M_start, __x._M_impl._M_start + size(), + this->_M_impl._M_start); + std::__uninitialized_copy_a(__x._M_impl._M_start + size(), + __x._M_impl._M_finish, + this->_M_impl._M_finish, + _M_get_Tp_allocator()); + } + this->_M_impl._M_finish = this->_M_impl._M_start + __xlen; + } + return *this; + } + + template + void + vector<_Tp, _Alloc>:: + _M_fill_assign(size_t __n, const value_type& __val) + { + if (__n > capacity()) + { + vector __tmp(__n, __val, _M_get_Tp_allocator()); + __tmp._M_impl._M_swap_data(this->_M_impl); + } + else if (__n > size()) + { + std::fill(begin(), end(), __val); + std::__uninitialized_fill_n_a(this->_M_impl._M_finish, + __n - size(), __val, + _M_get_Tp_allocator()); + this->_M_impl._M_finish += __n - size(); + } + else + _M_erase_at_end(std::fill_n(this->_M_impl._M_start, __n, __val)); + } + + template + template + void + vector<_Tp, _Alloc>:: + _M_assign_aux(_InputIterator __first, _InputIterator __last, + std::input_iterator_tag) + { + pointer __cur(this->_M_impl._M_start); + for (; __first != __last && __cur != this->_M_impl._M_finish; + ++__cur, ++__first) + *__cur = *__first; + if (__first == __last) + _M_erase_at_end(__cur); + else + insert(end(), __first, __last); + } + + template + template + void + vector<_Tp, _Alloc>:: + _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last, + std::forward_iterator_tag) + { + const size_type __len = std::distance(__first, __last); + + if (__len > capacity()) + { + pointer __tmp(_M_allocate_and_copy(__len, __first, __last)); + std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish, + _M_get_Tp_allocator()); + _M_deallocate(this->_M_impl._M_start, + this->_M_impl._M_end_of_storage + - this->_M_impl._M_start); + this->_M_impl._M_start = __tmp; + this->_M_impl._M_finish = this->_M_impl._M_start + __len; + this->_M_impl._M_end_of_storage = this->_M_impl._M_finish; + } + else if (size() >= __len) + _M_erase_at_end(std::copy(__first, __last, this->_M_impl._M_start)); + else + { + _ForwardIterator __mid = __first; + std::advance(__mid, size()); + std::copy(__first, __mid, this->_M_impl._M_start); + this->_M_impl._M_finish = + std::__uninitialized_copy_a(__mid, __last, + this->_M_impl._M_finish, + _M_get_Tp_allocator()); + } + } + +#if __cplusplus >= 201103L + template + template + typename vector<_Tp, _Alloc>::iterator + vector<_Tp, _Alloc>:: + emplace(const_iterator __position, _Args&&... __args) + { + const size_type __n = __position - begin(); + if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage + && __position == end()) + { + _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish, + std::forward<_Args>(__args)...); + ++this->_M_impl._M_finish; + } + else + _M_insert_aux(begin() + (__position - cbegin()), + std::forward<_Args>(__args)...); + return iterator(this->_M_impl._M_start + __n); + } + + template + template + void + vector<_Tp, _Alloc>:: + _M_insert_aux(iterator __position, _Args&&... __args) +#else + template + void + vector<_Tp, _Alloc>:: + _M_insert_aux(iterator __position, const _Tp& __x) +#endif + { + if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage) + { + _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish, + _GLIBCXX_MOVE(*(this->_M_impl._M_finish + - 1))); + ++this->_M_impl._M_finish; +#if __cplusplus < 201103L + _Tp __x_copy = __x; +#endif + _GLIBCXX_MOVE_BACKWARD3(__position.base(), + this->_M_impl._M_finish - 2, + this->_M_impl._M_finish - 1); +#if __cplusplus < 201103L + *__position = __x_copy; +#else + *__position = _Tp(std::forward<_Args>(__args)...); +#endif + } + else + { + const size_type __len = + _M_check_len(size_type(1), "vector::_M_insert_aux"); + const size_type __elems_before = __position - begin(); + pointer __new_start(this->_M_allocate(__len)); + pointer __new_finish(__new_start); + __try + { + // The order of the three operations is dictated by the C++0x + // case, where the moves could alter a new element belonging + // to the existing vector. This is an issue only for callers + // taking the element by const lvalue ref (see 23.1/13). + _Alloc_traits::construct(this->_M_impl, + __new_start + __elems_before, +#if __cplusplus >= 201103L + std::forward<_Args>(__args)...); +#else + __x); +#endif + __new_finish = 0; + + __new_finish + = std::__uninitialized_move_if_noexcept_a + (this->_M_impl._M_start, __position.base(), + __new_start, _M_get_Tp_allocator()); + + ++__new_finish; + + __new_finish + = std::__uninitialized_move_if_noexcept_a + (__position.base(), this->_M_impl._M_finish, + __new_finish, _M_get_Tp_allocator()); + } + __catch(...) + { + if (!__new_finish) + _Alloc_traits::destroy(this->_M_impl, + __new_start + __elems_before); + else + std::_Destroy(__new_start, __new_finish, _M_get_Tp_allocator()); + _M_deallocate(__new_start, __len); + __throw_exception_again; + } + std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish, + _M_get_Tp_allocator()); + _M_deallocate(this->_M_impl._M_start, + this->_M_impl._M_end_of_storage + - this->_M_impl._M_start); + this->_M_impl._M_start = __new_start; + this->_M_impl._M_finish = __new_finish; + this->_M_impl._M_end_of_storage = __new_start + __len; + } + } + +#if __cplusplus >= 201103L + template + template + void + vector<_Tp, _Alloc>:: + _M_emplace_back_aux(_Args&&... __args) + { + const size_type __len = + _M_check_len(size_type(1), "vector::_M_emplace_back_aux"); + pointer __new_start(this->_M_allocate(__len)); + pointer __new_finish(__new_start); + __try + { + _Alloc_traits::construct(this->_M_impl, __new_start + size(), + std::forward<_Args>(__args)...); + __new_finish = 0; + + __new_finish + = std::__uninitialized_move_if_noexcept_a + (this->_M_impl._M_start, this->_M_impl._M_finish, + __new_start, _M_get_Tp_allocator()); + + ++__new_finish; + } + __catch(...) + { + if (!__new_finish) + _Alloc_traits::destroy(this->_M_impl, __new_start + size()); + else + std::_Destroy(__new_start, __new_finish, _M_get_Tp_allocator()); + _M_deallocate(__new_start, __len); + __throw_exception_again; + } + std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish, + _M_get_Tp_allocator()); + _M_deallocate(this->_M_impl._M_start, + this->_M_impl._M_end_of_storage + - this->_M_impl._M_start); + this->_M_impl._M_start = __new_start; + this->_M_impl._M_finish = __new_finish; + this->_M_impl._M_end_of_storage = __new_start + __len; + } +#endif + + template + void + vector<_Tp, _Alloc>:: + _M_fill_insert(iterator __position, size_type __n, const value_type& __x) + { + if (__n != 0) + { + if (size_type(this->_M_impl._M_end_of_storage + - this->_M_impl._M_finish) >= __n) + { + value_type __x_copy = __x; + const size_type __elems_after = end() - __position; + pointer __old_finish(this->_M_impl._M_finish); + if (__elems_after > __n) + { + std::__uninitialized_move_a(this->_M_impl._M_finish - __n, + this->_M_impl._M_finish, + this->_M_impl._M_finish, + _M_get_Tp_allocator()); + this->_M_impl._M_finish += __n; + _GLIBCXX_MOVE_BACKWARD3(__position.base(), + __old_finish - __n, __old_finish); + std::fill(__position.base(), __position.base() + __n, + __x_copy); + } + else + { + std::__uninitialized_fill_n_a(this->_M_impl._M_finish, + __n - __elems_after, + __x_copy, + _M_get_Tp_allocator()); + this->_M_impl._M_finish += __n - __elems_after; + std::__uninitialized_move_a(__position.base(), __old_finish, + this->_M_impl._M_finish, + _M_get_Tp_allocator()); + this->_M_impl._M_finish += __elems_after; + std::fill(__position.base(), __old_finish, __x_copy); + } + } + else + { + const size_type __len = + _M_check_len(__n, "vector::_M_fill_insert"); + const size_type __elems_before = __position - begin(); + pointer __new_start(this->_M_allocate(__len)); + pointer __new_finish(__new_start); + __try + { + // See _M_insert_aux above. + std::__uninitialized_fill_n_a(__new_start + __elems_before, + __n, __x, + _M_get_Tp_allocator()); + __new_finish = 0; + + __new_finish + = std::__uninitialized_move_if_noexcept_a + (this->_M_impl._M_start, __position.base(), + __new_start, _M_get_Tp_allocator()); + + __new_finish += __n; + + __new_finish + = std::__uninitialized_move_if_noexcept_a + (__position.base(), this->_M_impl._M_finish, + __new_finish, _M_get_Tp_allocator()); + } + __catch(...) + { + if (!__new_finish) + std::_Destroy(__new_start + __elems_before, + __new_start + __elems_before + __n, + _M_get_Tp_allocator()); + else + std::_Destroy(__new_start, __new_finish, + _M_get_Tp_allocator()); + _M_deallocate(__new_start, __len); + __throw_exception_again; + } + std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish, + _M_get_Tp_allocator()); + _M_deallocate(this->_M_impl._M_start, + this->_M_impl._M_end_of_storage + - this->_M_impl._M_start); + this->_M_impl._M_start = __new_start; + this->_M_impl._M_finish = __new_finish; + this->_M_impl._M_end_of_storage = __new_start + __len; + } + } + } + +#if __cplusplus >= 201103L + template + void + vector<_Tp, _Alloc>:: + _M_default_append(size_type __n) + { + if (__n != 0) + { + if (size_type(this->_M_impl._M_end_of_storage + - this->_M_impl._M_finish) >= __n) + { + std::__uninitialized_default_n_a(this->_M_impl._M_finish, + __n, _M_get_Tp_allocator()); + this->_M_impl._M_finish += __n; + } + else + { + const size_type __len = + _M_check_len(__n, "vector::_M_default_append"); + const size_type __old_size = this->size(); + pointer __new_start(this->_M_allocate(__len)); + pointer __new_finish(__new_start); + __try + { + __new_finish + = std::__uninitialized_move_if_noexcept_a + (this->_M_impl._M_start, this->_M_impl._M_finish, + __new_start, _M_get_Tp_allocator()); + std::__uninitialized_default_n_a(__new_finish, __n, + _M_get_Tp_allocator()); + __new_finish += __n; + } + __catch(...) + { + std::_Destroy(__new_start, __new_finish, + _M_get_Tp_allocator()); + _M_deallocate(__new_start, __len); + __throw_exception_again; + } + std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish, + _M_get_Tp_allocator()); + _M_deallocate(this->_M_impl._M_start, + this->_M_impl._M_end_of_storage + - this->_M_impl._M_start); + this->_M_impl._M_start = __new_start; + this->_M_impl._M_finish = __new_finish; + this->_M_impl._M_end_of_storage = __new_start + __len; + } + } + } + + template + bool + vector<_Tp, _Alloc>:: + _M_shrink_to_fit() + { + if (capacity() == size()) + return false; + return std::__shrink_to_fit_aux::_S_do_it(*this); + } +#endif + + template + template + void + vector<_Tp, _Alloc>:: + _M_range_insert(iterator __pos, _InputIterator __first, + _InputIterator __last, std::input_iterator_tag) + { + for (; __first != __last; ++__first) + { + __pos = insert(__pos, *__first); + ++__pos; + } + } + + template + template + void + vector<_Tp, _Alloc>:: + _M_range_insert(iterator __position, _ForwardIterator __first, + _ForwardIterator __last, std::forward_iterator_tag) + { + if (__first != __last) + { + const size_type __n = std::distance(__first, __last); + if (size_type(this->_M_impl._M_end_of_storage + - this->_M_impl._M_finish) >= __n) + { + const size_type __elems_after = end() - __position; + pointer __old_finish(this->_M_impl._M_finish); + if (__elems_after > __n) + { + std::__uninitialized_move_a(this->_M_impl._M_finish - __n, + this->_M_impl._M_finish, + this->_M_impl._M_finish, + _M_get_Tp_allocator()); + this->_M_impl._M_finish += __n; + _GLIBCXX_MOVE_BACKWARD3(__position.base(), + __old_finish - __n, __old_finish); + std::copy(__first, __last, __position); + } + else + { + _ForwardIterator __mid = __first; + std::advance(__mid, __elems_after); + std::__uninitialized_copy_a(__mid, __last, + this->_M_impl._M_finish, + _M_get_Tp_allocator()); + this->_M_impl._M_finish += __n - __elems_after; + std::__uninitialized_move_a(__position.base(), + __old_finish, + this->_M_impl._M_finish, + _M_get_Tp_allocator()); + this->_M_impl._M_finish += __elems_after; + std::copy(__first, __mid, __position); + } + } + else + { + const size_type __len = + _M_check_len(__n, "vector::_M_range_insert"); + pointer __new_start(this->_M_allocate(__len)); + pointer __new_finish(__new_start); + __try + { + __new_finish + = std::__uninitialized_move_if_noexcept_a + (this->_M_impl._M_start, __position.base(), + __new_start, _M_get_Tp_allocator()); + __new_finish + = std::__uninitialized_copy_a(__first, __last, + __new_finish, + _M_get_Tp_allocator()); + __new_finish + = std::__uninitialized_move_if_noexcept_a + (__position.base(), this->_M_impl._M_finish, + __new_finish, _M_get_Tp_allocator()); + } + __catch(...) + { + std::_Destroy(__new_start, __new_finish, + _M_get_Tp_allocator()); + _M_deallocate(__new_start, __len); + __throw_exception_again; + } + std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish, + _M_get_Tp_allocator()); + _M_deallocate(this->_M_impl._M_start, + this->_M_impl._M_end_of_storage + - this->_M_impl._M_start); + this->_M_impl._M_start = __new_start; + this->_M_impl._M_finish = __new_finish; + this->_M_impl._M_end_of_storage = __new_start + __len; + } + } + } + + + // vector + template + void + vector:: + _M_reallocate(size_type __n) + { + _Bit_type* __q = this->_M_allocate(__n); + this->_M_impl._M_finish = _M_copy_aligned(begin(), end(), + iterator(__q, 0)); + this->_M_deallocate(); + this->_M_impl._M_start = iterator(__q, 0); + this->_M_impl._M_end_of_storage = __q + _S_nword(__n); + } + + template + void + vector:: + _M_fill_insert(iterator __position, size_type __n, bool __x) + { + if (__n == 0) + return; + if (capacity() - size() >= __n) + { + std::copy_backward(__position, end(), + this->_M_impl._M_finish + difference_type(__n)); + std::fill(__position, __position + difference_type(__n), __x); + this->_M_impl._M_finish += difference_type(__n); + } + else + { + const size_type __len = + _M_check_len(__n, "vector::_M_fill_insert"); + _Bit_type * __q = this->_M_allocate(__len); + iterator __i = _M_copy_aligned(begin(), __position, + iterator(__q, 0)); + std::fill(__i, __i + difference_type(__n), __x); + this->_M_impl._M_finish = std::copy(__position, end(), + __i + difference_type(__n)); + this->_M_deallocate(); + this->_M_impl._M_end_of_storage = __q + _S_nword(__len); + this->_M_impl._M_start = iterator(__q, 0); + } + } + + template + template + void + vector:: + _M_insert_range(iterator __position, _ForwardIterator __first, + _ForwardIterator __last, std::forward_iterator_tag) + { + if (__first != __last) + { + size_type __n = std::distance(__first, __last); + if (capacity() - size() >= __n) + { + std::copy_backward(__position, end(), + this->_M_impl._M_finish + + difference_type(__n)); + std::copy(__first, __last, __position); + this->_M_impl._M_finish += difference_type(__n); + } + else + { + const size_type __len = + _M_check_len(__n, "vector::_M_insert_range"); + _Bit_type * __q = this->_M_allocate(__len); + iterator __i = _M_copy_aligned(begin(), __position, + iterator(__q, 0)); + __i = std::copy(__first, __last, __i); + this->_M_impl._M_finish = std::copy(__position, end(), __i); + this->_M_deallocate(); + this->_M_impl._M_end_of_storage = __q + _S_nword(__len); + this->_M_impl._M_start = iterator(__q, 0); + } + } + } + + template + void + vector:: + _M_insert_aux(iterator __position, bool __x) + { + if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_of_storage) + { + std::copy_backward(__position, this->_M_impl._M_finish, + this->_M_impl._M_finish + 1); + *__position = __x; + ++this->_M_impl._M_finish; + } + else + { + const size_type __len = + _M_check_len(size_type(1), "vector::_M_insert_aux"); + _Bit_type * __q = this->_M_allocate(__len); + iterator __i = _M_copy_aligned(begin(), __position, + iterator(__q, 0)); + *__i++ = __x; + this->_M_impl._M_finish = std::copy(__position, end(), __i); + this->_M_deallocate(); + this->_M_impl._M_end_of_storage = __q + _S_nword(__len); + this->_M_impl._M_start = iterator(__q, 0); + } + } + + template + typename vector::iterator + vector:: + _M_erase(iterator __position) + { + if (__position + 1 != end()) + std::copy(__position + 1, end(), __position); + --this->_M_impl._M_finish; + return __position; + } + + template + typename vector::iterator + vector:: + _M_erase(iterator __first, iterator __last) + { + if (__first != __last) + _M_erase_at_end(std::copy(__last, end(), __first)); + return __first; + } + +#if __cplusplus >= 201103L + template + bool + vector:: + _M_shrink_to_fit() + { + if (capacity() - size() < int(_S_word_bit)) + return false; + __try + { + _M_reallocate(size()); + return true; + } + __catch(...) + { return false; } + } +#endif + +_GLIBCXX_END_NAMESPACE_CONTAINER +} // namespace std + +#if __cplusplus >= 201103L + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + template + size_t + hash<_GLIBCXX_STD_C::vector>:: + operator()(const _GLIBCXX_STD_C::vector& __b) const noexcept + { + size_t __hash = 0; + using _GLIBCXX_STD_C::_S_word_bit; + using _GLIBCXX_STD_C::_Bit_type; + + const size_t __words = __b.size() / _S_word_bit; + if (__words) + { + const size_t __clength = __words * sizeof(_Bit_type); + __hash = std::_Hash_impl::hash(__b._M_impl._M_start._M_p, __clength); + } + + const size_t __extrabits = __b.size() % _S_word_bit; + if (__extrabits) + { + _Bit_type __hiword = *__b._M_impl._M_finish._M_p; + __hiword &= ~((~static_cast<_Bit_type>(0)) << __extrabits); + + const size_t __clength + = (__extrabits + __CHAR_BIT__ - 1) / __CHAR_BIT__; + if (__words) + __hash = std::_Hash_impl::hash(&__hiword, __clength, __hash); + else + __hash = std::_Hash_impl::hash(&__hiword, __clength); + } + + return __hash; + } + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace std + +#endif // C++11 + +#endif /* _VECTOR_TCC */ diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bitset b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bitset new file mode 100755 index 0000000..d9d4f4d --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/bitset @@ -0,0 +1,1595 @@ +// -*- C++ -*- + +// Copyright (C) 2001-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/* + * Copyright (c) 1998 + * Silicon Graphics Computer Systems, Inc. + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Silicon Graphics makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + */ + +/** @file include/bitset + * This is a Standard C++ Library header. + */ + +#ifndef _GLIBCXX_BITSET +#define _GLIBCXX_BITSET 1 + +#pragma GCC system_header + +#include +#include // For invalid_argument, out_of_range, + // overflow_error +#include +#include + +#define _GLIBCXX_BITSET_BITS_PER_WORD (__CHAR_BIT__ * __SIZEOF_LONG__) +#define _GLIBCXX_BITSET_WORDS(__n) \ + ((__n) / _GLIBCXX_BITSET_BITS_PER_WORD + \ + ((__n) % _GLIBCXX_BITSET_BITS_PER_WORD == 0 ? 0 : 1)) + +#define _GLIBCXX_BITSET_BITS_PER_ULL (__CHAR_BIT__ * __SIZEOF_LONG_LONG__) + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_CONTAINER + + /** + * Base class, general case. It is a class invariant that _Nw will be + * nonnegative. + * + * See documentation for bitset. + */ + template + struct _Base_bitset + { + typedef unsigned long _WordT; + + /// 0 is the least significant word. + _WordT _M_w[_Nw]; + + _GLIBCXX_CONSTEXPR _Base_bitset() _GLIBCXX_NOEXCEPT + : _M_w() { } + +#if __cplusplus >= 201103L + constexpr _Base_bitset(unsigned long long __val) noexcept + : _M_w{ _WordT(__val) +#if __SIZEOF_LONG_LONG__ > __SIZEOF_LONG__ + , _WordT(__val >> _GLIBCXX_BITSET_BITS_PER_WORD) +#endif + } { } +#else + _Base_bitset(unsigned long __val) + : _M_w() + { _M_w[0] = __val; } +#endif + + static _GLIBCXX_CONSTEXPR size_t + _S_whichword(size_t __pos) _GLIBCXX_NOEXCEPT + { return __pos / _GLIBCXX_BITSET_BITS_PER_WORD; } + + static _GLIBCXX_CONSTEXPR size_t + _S_whichbyte(size_t __pos) _GLIBCXX_NOEXCEPT + { return (__pos % _GLIBCXX_BITSET_BITS_PER_WORD) / __CHAR_BIT__; } + + static _GLIBCXX_CONSTEXPR size_t + _S_whichbit(size_t __pos) _GLIBCXX_NOEXCEPT + { return __pos % _GLIBCXX_BITSET_BITS_PER_WORD; } + + static _GLIBCXX_CONSTEXPR _WordT + _S_maskbit(size_t __pos) _GLIBCXX_NOEXCEPT + { return (static_cast<_WordT>(1)) << _S_whichbit(__pos); } + + _WordT& + _M_getword(size_t __pos) _GLIBCXX_NOEXCEPT + { return _M_w[_S_whichword(__pos)]; } + + _GLIBCXX_CONSTEXPR _WordT + _M_getword(size_t __pos) const _GLIBCXX_NOEXCEPT + { return _M_w[_S_whichword(__pos)]; } + +#if __cplusplus >= 201103L + const _WordT* + _M_getdata() const noexcept + { return _M_w; } +#endif + + _WordT& + _M_hiword() _GLIBCXX_NOEXCEPT + { return _M_w[_Nw - 1]; } + + _GLIBCXX_CONSTEXPR _WordT + _M_hiword() const _GLIBCXX_NOEXCEPT + { return _M_w[_Nw - 1]; } + + void + _M_do_and(const _Base_bitset<_Nw>& __x) _GLIBCXX_NOEXCEPT + { + for (size_t __i = 0; __i < _Nw; __i++) + _M_w[__i] &= __x._M_w[__i]; + } + + void + _M_do_or(const _Base_bitset<_Nw>& __x) _GLIBCXX_NOEXCEPT + { + for (size_t __i = 0; __i < _Nw; __i++) + _M_w[__i] |= __x._M_w[__i]; + } + + void + _M_do_xor(const _Base_bitset<_Nw>& __x) _GLIBCXX_NOEXCEPT + { + for (size_t __i = 0; __i < _Nw; __i++) + _M_w[__i] ^= __x._M_w[__i]; + } + + void + _M_do_left_shift(size_t __shift) _GLIBCXX_NOEXCEPT; + + void + _M_do_right_shift(size_t __shift) _GLIBCXX_NOEXCEPT; + + void + _M_do_flip() _GLIBCXX_NOEXCEPT + { + for (size_t __i = 0; __i < _Nw; __i++) + _M_w[__i] = ~_M_w[__i]; + } + + void + _M_do_set() _GLIBCXX_NOEXCEPT + { + for (size_t __i = 0; __i < _Nw; __i++) + _M_w[__i] = ~static_cast<_WordT>(0); + } + + void + _M_do_reset() _GLIBCXX_NOEXCEPT + { __builtin_memset(_M_w, 0, _Nw * sizeof(_WordT)); } + + bool + _M_is_equal(const _Base_bitset<_Nw>& __x) const _GLIBCXX_NOEXCEPT + { + for (size_t __i = 0; __i < _Nw; ++__i) + if (_M_w[__i] != __x._M_w[__i]) + return false; + return true; + } + + template + bool + _M_are_all() const _GLIBCXX_NOEXCEPT + { + for (size_t __i = 0; __i < _Nw - 1; __i++) + if (_M_w[__i] != ~static_cast<_WordT>(0)) + return false; + return _M_hiword() == (~static_cast<_WordT>(0) + >> (_Nw * _GLIBCXX_BITSET_BITS_PER_WORD + - _Nb)); + } + + bool + _M_is_any() const _GLIBCXX_NOEXCEPT + { + for (size_t __i = 0; __i < _Nw; __i++) + if (_M_w[__i] != static_cast<_WordT>(0)) + return true; + return false; + } + + size_t + _M_do_count() const _GLIBCXX_NOEXCEPT + { + size_t __result = 0; + for (size_t __i = 0; __i < _Nw; __i++) + __result += __builtin_popcountl(_M_w[__i]); + return __result; + } + + unsigned long + _M_do_to_ulong() const; + +#if __cplusplus >= 201103L + unsigned long long + _M_do_to_ullong() const; +#endif + + // find first "on" bit + size_t + _M_do_find_first(size_t) const _GLIBCXX_NOEXCEPT; + + // find the next "on" bit that follows "prev" + size_t + _M_do_find_next(size_t, size_t) const _GLIBCXX_NOEXCEPT; + }; + + // Definitions of non-inline functions from _Base_bitset. + template + void + _Base_bitset<_Nw>::_M_do_left_shift(size_t __shift) _GLIBCXX_NOEXCEPT + { + if (__builtin_expect(__shift != 0, 1)) + { + const size_t __wshift = __shift / _GLIBCXX_BITSET_BITS_PER_WORD; + const size_t __offset = __shift % _GLIBCXX_BITSET_BITS_PER_WORD; + + if (__offset == 0) + for (size_t __n = _Nw - 1; __n >= __wshift; --__n) + _M_w[__n] = _M_w[__n - __wshift]; + else + { + const size_t __sub_offset = (_GLIBCXX_BITSET_BITS_PER_WORD + - __offset); + for (size_t __n = _Nw - 1; __n > __wshift; --__n) + _M_w[__n] = ((_M_w[__n - __wshift] << __offset) + | (_M_w[__n - __wshift - 1] >> __sub_offset)); + _M_w[__wshift] = _M_w[0] << __offset; + } + + std::fill(_M_w + 0, _M_w + __wshift, static_cast<_WordT>(0)); + } + } + + template + void + _Base_bitset<_Nw>::_M_do_right_shift(size_t __shift) _GLIBCXX_NOEXCEPT + { + if (__builtin_expect(__shift != 0, 1)) + { + const size_t __wshift = __shift / _GLIBCXX_BITSET_BITS_PER_WORD; + const size_t __offset = __shift % _GLIBCXX_BITSET_BITS_PER_WORD; + const size_t __limit = _Nw - __wshift - 1; + + if (__offset == 0) + for (size_t __n = 0; __n <= __limit; ++__n) + _M_w[__n] = _M_w[__n + __wshift]; + else + { + const size_t __sub_offset = (_GLIBCXX_BITSET_BITS_PER_WORD + - __offset); + for (size_t __n = 0; __n < __limit; ++__n) + _M_w[__n] = ((_M_w[__n + __wshift] >> __offset) + | (_M_w[__n + __wshift + 1] << __sub_offset)); + _M_w[__limit] = _M_w[_Nw-1] >> __offset; + } + + std::fill(_M_w + __limit + 1, _M_w + _Nw, static_cast<_WordT>(0)); + } + } + + template + unsigned long + _Base_bitset<_Nw>::_M_do_to_ulong() const + { + for (size_t __i = 1; __i < _Nw; ++__i) + if (_M_w[__i]) + __throw_overflow_error(__N("_Base_bitset::_M_do_to_ulong")); + return _M_w[0]; + } + +#if __cplusplus >= 201103L + template + unsigned long long + _Base_bitset<_Nw>::_M_do_to_ullong() const + { + const bool __dw = sizeof(unsigned long long) > sizeof(unsigned long); + for (size_t __i = 1 + __dw; __i < _Nw; ++__i) + if (_M_w[__i]) + __throw_overflow_error(__N("_Base_bitset::_M_do_to_ullong")); + + if (__dw) + return _M_w[0] + (static_cast(_M_w[1]) + << _GLIBCXX_BITSET_BITS_PER_WORD); + return _M_w[0]; + } +#endif + + template + size_t + _Base_bitset<_Nw>:: + _M_do_find_first(size_t __not_found) const _GLIBCXX_NOEXCEPT + { + for (size_t __i = 0; __i < _Nw; __i++) + { + _WordT __thisword = _M_w[__i]; + if (__thisword != static_cast<_WordT>(0)) + return (__i * _GLIBCXX_BITSET_BITS_PER_WORD + + __builtin_ctzl(__thisword)); + } + // not found, so return an indication of failure. + return __not_found; + } + + template + size_t + _Base_bitset<_Nw>:: + _M_do_find_next(size_t __prev, size_t __not_found) const _GLIBCXX_NOEXCEPT + { + // make bound inclusive + ++__prev; + + // check out of bounds + if (__prev >= _Nw * _GLIBCXX_BITSET_BITS_PER_WORD) + return __not_found; + + // search first word + size_t __i = _S_whichword(__prev); + _WordT __thisword = _M_w[__i]; + + // mask off bits below bound + __thisword &= (~static_cast<_WordT>(0)) << _S_whichbit(__prev); + + if (__thisword != static_cast<_WordT>(0)) + return (__i * _GLIBCXX_BITSET_BITS_PER_WORD + + __builtin_ctzl(__thisword)); + + // check subsequent words + __i++; + for (; __i < _Nw; __i++) + { + __thisword = _M_w[__i]; + if (__thisword != static_cast<_WordT>(0)) + return (__i * _GLIBCXX_BITSET_BITS_PER_WORD + + __builtin_ctzl(__thisword)); + } + // not found, so return an indication of failure. + return __not_found; + } // end _M_do_find_next + + /** + * Base class, specialization for a single word. + * + * See documentation for bitset. + */ + template<> + struct _Base_bitset<1> + { + typedef unsigned long _WordT; + _WordT _M_w; + + _GLIBCXX_CONSTEXPR _Base_bitset() _GLIBCXX_NOEXCEPT + : _M_w(0) + { } + +#if __cplusplus >= 201103L + constexpr _Base_bitset(unsigned long long __val) noexcept +#else + _Base_bitset(unsigned long __val) +#endif + : _M_w(__val) + { } + + static _GLIBCXX_CONSTEXPR size_t + _S_whichword(size_t __pos) _GLIBCXX_NOEXCEPT + { return __pos / _GLIBCXX_BITSET_BITS_PER_WORD; } + + static _GLIBCXX_CONSTEXPR size_t + _S_whichbyte(size_t __pos) _GLIBCXX_NOEXCEPT + { return (__pos % _GLIBCXX_BITSET_BITS_PER_WORD) / __CHAR_BIT__; } + + static _GLIBCXX_CONSTEXPR size_t + _S_whichbit(size_t __pos) _GLIBCXX_NOEXCEPT + { return __pos % _GLIBCXX_BITSET_BITS_PER_WORD; } + + static _GLIBCXX_CONSTEXPR _WordT + _S_maskbit(size_t __pos) _GLIBCXX_NOEXCEPT + { return (static_cast<_WordT>(1)) << _S_whichbit(__pos); } + + _WordT& + _M_getword(size_t) _GLIBCXX_NOEXCEPT + { return _M_w; } + + _GLIBCXX_CONSTEXPR _WordT + _M_getword(size_t) const _GLIBCXX_NOEXCEPT + { return _M_w; } + +#if __cplusplus >= 201103L + const _WordT* + _M_getdata() const noexcept + { return &_M_w; } +#endif + + _WordT& + _M_hiword() _GLIBCXX_NOEXCEPT + { return _M_w; } + + _GLIBCXX_CONSTEXPR _WordT + _M_hiword() const _GLIBCXX_NOEXCEPT + { return _M_w; } + + void + _M_do_and(const _Base_bitset<1>& __x) _GLIBCXX_NOEXCEPT + { _M_w &= __x._M_w; } + + void + _M_do_or(const _Base_bitset<1>& __x) _GLIBCXX_NOEXCEPT + { _M_w |= __x._M_w; } + + void + _M_do_xor(const _Base_bitset<1>& __x) _GLIBCXX_NOEXCEPT + { _M_w ^= __x._M_w; } + + void + _M_do_left_shift(size_t __shift) _GLIBCXX_NOEXCEPT + { _M_w <<= __shift; } + + void + _M_do_right_shift(size_t __shift) _GLIBCXX_NOEXCEPT + { _M_w >>= __shift; } + + void + _M_do_flip() _GLIBCXX_NOEXCEPT + { _M_w = ~_M_w; } + + void + _M_do_set() _GLIBCXX_NOEXCEPT + { _M_w = ~static_cast<_WordT>(0); } + + void + _M_do_reset() _GLIBCXX_NOEXCEPT + { _M_w = 0; } + + bool + _M_is_equal(const _Base_bitset<1>& __x) const _GLIBCXX_NOEXCEPT + { return _M_w == __x._M_w; } + + template + bool + _M_are_all() const _GLIBCXX_NOEXCEPT + { return _M_w == (~static_cast<_WordT>(0) + >> (_GLIBCXX_BITSET_BITS_PER_WORD - _Nb)); } + + bool + _M_is_any() const _GLIBCXX_NOEXCEPT + { return _M_w != 0; } + + size_t + _M_do_count() const _GLIBCXX_NOEXCEPT + { return __builtin_popcountl(_M_w); } + + unsigned long + _M_do_to_ulong() const _GLIBCXX_NOEXCEPT + { return _M_w; } + +#if __cplusplus >= 201103L + unsigned long long + _M_do_to_ullong() const noexcept + { return _M_w; } +#endif + + size_t + _M_do_find_first(size_t __not_found) const _GLIBCXX_NOEXCEPT + { + if (_M_w != 0) + return __builtin_ctzl(_M_w); + else + return __not_found; + } + + // find the next "on" bit that follows "prev" + size_t + _M_do_find_next(size_t __prev, size_t __not_found) const + _GLIBCXX_NOEXCEPT + { + ++__prev; + if (__prev >= ((size_t) _GLIBCXX_BITSET_BITS_PER_WORD)) + return __not_found; + + _WordT __x = _M_w >> __prev; + if (__x != 0) + return __builtin_ctzl(__x) + __prev; + else + return __not_found; + } + }; + + /** + * Base class, specialization for no storage (zero-length %bitset). + * + * See documentation for bitset. + */ + template<> + struct _Base_bitset<0> + { + typedef unsigned long _WordT; + + _GLIBCXX_CONSTEXPR _Base_bitset() _GLIBCXX_NOEXCEPT + { } + +#if __cplusplus >= 201103L + constexpr _Base_bitset(unsigned long long) noexcept +#else + _Base_bitset(unsigned long) +#endif + { } + + static _GLIBCXX_CONSTEXPR size_t + _S_whichword(size_t __pos) _GLIBCXX_NOEXCEPT + { return __pos / _GLIBCXX_BITSET_BITS_PER_WORD; } + + static _GLIBCXX_CONSTEXPR size_t + _S_whichbyte(size_t __pos) _GLIBCXX_NOEXCEPT + { return (__pos % _GLIBCXX_BITSET_BITS_PER_WORD) / __CHAR_BIT__; } + + static _GLIBCXX_CONSTEXPR size_t + _S_whichbit(size_t __pos) _GLIBCXX_NOEXCEPT + { return __pos % _GLIBCXX_BITSET_BITS_PER_WORD; } + + static _GLIBCXX_CONSTEXPR _WordT + _S_maskbit(size_t __pos) _GLIBCXX_NOEXCEPT + { return (static_cast<_WordT>(1)) << _S_whichbit(__pos); } + + // This would normally give access to the data. The bounds-checking + // in the bitset class will prevent the user from getting this far, + // but (1) it must still return an lvalue to compile, and (2) the + // user might call _Unchecked_set directly, in which case this /needs/ + // to fail. Let's not penalize zero-length users unless they actually + // make an unchecked call; all the memory ugliness is therefore + // localized to this single should-never-get-this-far function. + _WordT& + _M_getword(size_t) _GLIBCXX_NOEXCEPT + { + __throw_out_of_range(__N("_Base_bitset::_M_getword")); + return *new _WordT; + } + + _GLIBCXX_CONSTEXPR _WordT + _M_getword(size_t __pos) const _GLIBCXX_NOEXCEPT + { return 0; } + + _GLIBCXX_CONSTEXPR _WordT + _M_hiword() const _GLIBCXX_NOEXCEPT + { return 0; } + + void + _M_do_and(const _Base_bitset<0>&) _GLIBCXX_NOEXCEPT + { } + + void + _M_do_or(const _Base_bitset<0>&) _GLIBCXX_NOEXCEPT + { } + + void + _M_do_xor(const _Base_bitset<0>&) _GLIBCXX_NOEXCEPT + { } + + void + _M_do_left_shift(size_t) _GLIBCXX_NOEXCEPT + { } + + void + _M_do_right_shift(size_t) _GLIBCXX_NOEXCEPT + { } + + void + _M_do_flip() _GLIBCXX_NOEXCEPT + { } + + void + _M_do_set() _GLIBCXX_NOEXCEPT + { } + + void + _M_do_reset() _GLIBCXX_NOEXCEPT + { } + + // Are all empty bitsets equal to each other? Are they equal to + // themselves? How to compare a thing which has no state? What is + // the sound of one zero-length bitset clapping? + bool + _M_is_equal(const _Base_bitset<0>&) const _GLIBCXX_NOEXCEPT + { return true; } + + template + bool + _M_are_all() const _GLIBCXX_NOEXCEPT + { return true; } + + bool + _M_is_any() const _GLIBCXX_NOEXCEPT + { return false; } + + size_t + _M_do_count() const _GLIBCXX_NOEXCEPT + { return 0; } + + unsigned long + _M_do_to_ulong() const _GLIBCXX_NOEXCEPT + { return 0; } + +#if __cplusplus >= 201103L + unsigned long long + _M_do_to_ullong() const noexcept + { return 0; } +#endif + + // Normally "not found" is the size, but that could also be + // misinterpreted as an index in this corner case. Oh well. + size_t + _M_do_find_first(size_t) const _GLIBCXX_NOEXCEPT + { return 0; } + + size_t + _M_do_find_next(size_t, size_t) const _GLIBCXX_NOEXCEPT + { return 0; } + }; + + + // Helper class to zero out the unused high-order bits in the highest word. + template + struct _Sanitize + { + typedef unsigned long _WordT; + + static void + _S_do_sanitize(_WordT& __val) _GLIBCXX_NOEXCEPT + { __val &= ~((~static_cast<_WordT>(0)) << _Extrabits); } + }; + + template<> + struct _Sanitize<0> + { + typedef unsigned long _WordT; + + static void + _S_do_sanitize(_WordT) _GLIBCXX_NOEXCEPT { } + }; + +#if __cplusplus >= 201103L + template + struct _Sanitize_val + { + static constexpr unsigned long long + _S_do_sanitize_val(unsigned long long __val) + { return __val; } + }; + + template + struct _Sanitize_val<_Nb, true> + { + static constexpr unsigned long long + _S_do_sanitize_val(unsigned long long __val) + { return __val & ~((~static_cast(0)) << _Nb); } + }; +#endif + + /** + * The %bitset class represents a @e fixed-size sequence of bits. + * + * @ingroup containers + * + * (Note that %bitset does @e not meet the formal requirements of a + * container. Mainly, it lacks iterators.) + * + * The template argument, @a Nb, may be any non-negative number, + * specifying the number of bits (e.g., "0", "12", "1024*1024"). + * + * In the general unoptimized case, storage is allocated in word-sized + * blocks. Let B be the number of bits in a word, then (Nb+(B-1))/B + * words will be used for storage. B - Nb%B bits are unused. (They are + * the high-order bits in the highest word.) It is a class invariant + * that those unused bits are always zero. + * + * If you think of %bitset as a simple array of bits, be + * aware that your mental picture is reversed: a %bitset behaves + * the same way as bits in integers do, with the bit at index 0 in + * the least significant / right-hand position, and the bit at + * index Nb-1 in the most significant / left-hand position. + * Thus, unlike other containers, a %bitset's index counts from + * right to left, to put it very loosely. + * + * This behavior is preserved when translating to and from strings. For + * example, the first line of the following program probably prints + * b('a') is 0001100001 on a modern ASCII system. + * + * @code + * #include + * #include + * #include + * + * using namespace std; + * + * int main() + * { + * long a = 'a'; + * bitset<10> b(a); + * + * cout << "b('a') is " << b << endl; + * + * ostringstream s; + * s << b; + * string str = s.str(); + * cout << "index 3 in the string is " << str[3] << " but\n" + * << "index 3 in the bitset is " << b[3] << endl; + * } + * @endcode + * + * Also see: + * http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt12ch33s02.html + * for a description of extensions. + * + * Most of the actual code isn't contained in %bitset<> itself, but in the + * base class _Base_bitset. The base class works with whole words, not with + * individual bits. This allows us to specialize _Base_bitset for the + * important special case where the %bitset is only a single word. + * + * Extra confusion can result due to the fact that the storage for + * _Base_bitset @e is a regular array, and is indexed as such. This is + * carefully encapsulated. + */ + template + class bitset + : private _Base_bitset<_GLIBCXX_BITSET_WORDS(_Nb)> + { + private: + typedef _Base_bitset<_GLIBCXX_BITSET_WORDS(_Nb)> _Base; + typedef unsigned long _WordT; + + template + void + _M_check_initial_position(const std::basic_string<_CharT, _Traits, _Alloc>& __s, + size_t __position) const + { + if (__position > __s.size()) + __throw_out_of_range_fmt(__N("bitset::bitset: __position " + "(which is %zu) > __s.size() " + "(which is %zu)"), + __position, __s.size()); + } + + void _M_check(size_t __position, const char *__s) const + { + if (__position >= _Nb) + __throw_out_of_range_fmt(__N("%s: __position (which is %zu) " + ">= _Nb (which is %zu)"), + __s, __position, _Nb); + } + + void + _M_do_sanitize() _GLIBCXX_NOEXCEPT + { + typedef _Sanitize<_Nb % _GLIBCXX_BITSET_BITS_PER_WORD> __sanitize_type; + __sanitize_type::_S_do_sanitize(this->_M_hiword()); + } + +#if __cplusplus >= 201103L + template friend struct hash; +#endif + + public: + /** + * This encapsulates the concept of a single bit. An instance of this + * class is a proxy for an actual bit; this way the individual bit + * operations are done as faster word-size bitwise instructions. + * + * Most users will never need to use this class directly; conversions + * to and from bool are automatic and should be transparent. Overloaded + * operators help to preserve the illusion. + * + * (On a typical system, this bit %reference is 64 + * times the size of an actual bit. Ha.) + */ + class reference + { + friend class bitset; + + _WordT* _M_wp; + size_t _M_bpos; + + // left undefined + reference(); + + public: + reference(bitset& __b, size_t __pos) _GLIBCXX_NOEXCEPT + { + _M_wp = &__b._M_getword(__pos); + _M_bpos = _Base::_S_whichbit(__pos); + } + + ~reference() _GLIBCXX_NOEXCEPT + { } + + // For b[i] = __x; + reference& + operator=(bool __x) _GLIBCXX_NOEXCEPT + { + if (__x) + *_M_wp |= _Base::_S_maskbit(_M_bpos); + else + *_M_wp &= ~_Base::_S_maskbit(_M_bpos); + return *this; + } + + // For b[i] = b[__j]; + reference& + operator=(const reference& __j) _GLIBCXX_NOEXCEPT + { + if ((*(__j._M_wp) & _Base::_S_maskbit(__j._M_bpos))) + *_M_wp |= _Base::_S_maskbit(_M_bpos); + else + *_M_wp &= ~_Base::_S_maskbit(_M_bpos); + return *this; + } + + // Flips the bit + bool + operator~() const _GLIBCXX_NOEXCEPT + { return (*(_M_wp) & _Base::_S_maskbit(_M_bpos)) == 0; } + + // For __x = b[i]; + operator bool() const _GLIBCXX_NOEXCEPT + { return (*(_M_wp) & _Base::_S_maskbit(_M_bpos)) != 0; } + + // For b[i].flip(); + reference& + flip() _GLIBCXX_NOEXCEPT + { + *_M_wp ^= _Base::_S_maskbit(_M_bpos); + return *this; + } + }; + friend class reference; + + // 23.3.5.1 constructors: + /// All bits set to zero. + _GLIBCXX_CONSTEXPR bitset() _GLIBCXX_NOEXCEPT + { } + + /// Initial bits bitwise-copied from a single word (others set to zero). +#if __cplusplus >= 201103L + constexpr bitset(unsigned long long __val) noexcept + : _Base(_Sanitize_val<_Nb>::_S_do_sanitize_val(__val)) { } +#else + bitset(unsigned long __val) + : _Base(__val) + { _M_do_sanitize(); } +#endif + + /** + * Use a subset of a string. + * @param __s A string of @a 0 and @a 1 characters. + * @param __position Index of the first character in @a __s to use; + * defaults to zero. + * @throw std::out_of_range If @a pos is bigger the size of @a __s. + * @throw std::invalid_argument If a character appears in the string + * which is neither @a 0 nor @a 1. + */ + template + explicit + bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __s, + size_t __position = 0) + : _Base() + { + _M_check_initial_position(__s, __position); + _M_copy_from_string(__s, __position, + std::basic_string<_CharT, _Traits, _Alloc>::npos, + _CharT('0'), _CharT('1')); + } + + /** + * Use a subset of a string. + * @param __s A string of @a 0 and @a 1 characters. + * @param __position Index of the first character in @a __s to use. + * @param __n The number of characters to copy. + * @throw std::out_of_range If @a __position is bigger the size + * of @a __s. + * @throw std::invalid_argument If a character appears in the string + * which is neither @a 0 nor @a 1. + */ + template + bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __s, + size_t __position, size_t __n) + : _Base() + { + _M_check_initial_position(__s, __position); + _M_copy_from_string(__s, __position, __n, _CharT('0'), _CharT('1')); + } + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 396. what are characters zero and one. + template + bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __s, + size_t __position, size_t __n, + _CharT __zero, _CharT __one = _CharT('1')) + : _Base() + { + _M_check_initial_position(__s, __position); + _M_copy_from_string(__s, __position, __n, __zero, __one); + } + +#if __cplusplus >= 201103L + /** + * Construct from a character %array. + * @param __str An %array of characters @a zero and @a one. + * @param __n The number of characters to use. + * @param __zero The character corresponding to the value 0. + * @param __one The character corresponding to the value 1. + * @throw std::invalid_argument If a character appears in the string + * which is neither @a __zero nor @a __one. + */ + template + explicit + bitset(const _CharT* __str, + typename std::basic_string<_CharT>::size_type __n + = std::basic_string<_CharT>::npos, + _CharT __zero = _CharT('0'), _CharT __one = _CharT('1')) + : _Base() + { + if (!__str) + __throw_logic_error(__N("bitset::bitset(const _CharT*, ...)")); + + if (__n == std::basic_string<_CharT>::npos) + __n = std::char_traits<_CharT>::length(__str); + _M_copy_from_ptr<_CharT, std::char_traits<_CharT>>(__str, __n, 0, + __n, __zero, + __one); + } +#endif + + // 23.3.5.2 bitset operations: + //@{ + /** + * Operations on bitsets. + * @param __rhs A same-sized bitset. + * + * These should be self-explanatory. + */ + bitset<_Nb>& + operator&=(const bitset<_Nb>& __rhs) _GLIBCXX_NOEXCEPT + { + this->_M_do_and(__rhs); + return *this; + } + + bitset<_Nb>& + operator|=(const bitset<_Nb>& __rhs) _GLIBCXX_NOEXCEPT + { + this->_M_do_or(__rhs); + return *this; + } + + bitset<_Nb>& + operator^=(const bitset<_Nb>& __rhs) _GLIBCXX_NOEXCEPT + { + this->_M_do_xor(__rhs); + return *this; + } + //@} + + //@{ + /** + * Operations on bitsets. + * @param __position The number of places to shift. + * + * These should be self-explanatory. + */ + bitset<_Nb>& + operator<<=(size_t __position) _GLIBCXX_NOEXCEPT + { + if (__builtin_expect(__position < _Nb, 1)) + { + this->_M_do_left_shift(__position); + this->_M_do_sanitize(); + } + else + this->_M_do_reset(); + return *this; + } + + bitset<_Nb>& + operator>>=(size_t __position) _GLIBCXX_NOEXCEPT + { + if (__builtin_expect(__position < _Nb, 1)) + { + this->_M_do_right_shift(__position); + this->_M_do_sanitize(); + } + else + this->_M_do_reset(); + return *this; + } + //@} + + //@{ + /** + * These versions of single-bit set, reset, flip, and test are + * extensions from the SGI version. They do no range checking. + * @ingroup SGIextensions + */ + bitset<_Nb>& + _Unchecked_set(size_t __pos) _GLIBCXX_NOEXCEPT + { + this->_M_getword(__pos) |= _Base::_S_maskbit(__pos); + return *this; + } + + bitset<_Nb>& + _Unchecked_set(size_t __pos, int __val) _GLIBCXX_NOEXCEPT + { + if (__val) + this->_M_getword(__pos) |= _Base::_S_maskbit(__pos); + else + this->_M_getword(__pos) &= ~_Base::_S_maskbit(__pos); + return *this; + } + + bitset<_Nb>& + _Unchecked_reset(size_t __pos) _GLIBCXX_NOEXCEPT + { + this->_M_getword(__pos) &= ~_Base::_S_maskbit(__pos); + return *this; + } + + bitset<_Nb>& + _Unchecked_flip(size_t __pos) _GLIBCXX_NOEXCEPT + { + this->_M_getword(__pos) ^= _Base::_S_maskbit(__pos); + return *this; + } + + _GLIBCXX_CONSTEXPR bool + _Unchecked_test(size_t __pos) const _GLIBCXX_NOEXCEPT + { return ((this->_M_getword(__pos) & _Base::_S_maskbit(__pos)) + != static_cast<_WordT>(0)); } + //@} + + // Set, reset, and flip. + /** + * @brief Sets every bit to true. + */ + bitset<_Nb>& + set() _GLIBCXX_NOEXCEPT + { + this->_M_do_set(); + this->_M_do_sanitize(); + return *this; + } + + /** + * @brief Sets a given bit to a particular value. + * @param __position The index of the bit. + * @param __val Either true or false, defaults to true. + * @throw std::out_of_range If @a pos is bigger the size of the %set. + */ + bitset<_Nb>& + set(size_t __position, bool __val = true) + { + this->_M_check(__position, __N("bitset::set")); + return _Unchecked_set(__position, __val); + } + + /** + * @brief Sets every bit to false. + */ + bitset<_Nb>& + reset() _GLIBCXX_NOEXCEPT + { + this->_M_do_reset(); + return *this; + } + + /** + * @brief Sets a given bit to false. + * @param __position The index of the bit. + * @throw std::out_of_range If @a pos is bigger the size of the %set. + * + * Same as writing @c set(pos,false). + */ + bitset<_Nb>& + reset(size_t __position) + { + this->_M_check(__position, __N("bitset::reset")); + return _Unchecked_reset(__position); + } + + /** + * @brief Toggles every bit to its opposite value. + */ + bitset<_Nb>& + flip() _GLIBCXX_NOEXCEPT + { + this->_M_do_flip(); + this->_M_do_sanitize(); + return *this; + } + + /** + * @brief Toggles a given bit to its opposite value. + * @param __position The index of the bit. + * @throw std::out_of_range If @a pos is bigger the size of the %set. + */ + bitset<_Nb>& + flip(size_t __position) + { + this->_M_check(__position, __N("bitset::flip")); + return _Unchecked_flip(__position); + } + + /// See the no-argument flip(). + bitset<_Nb> + operator~() const _GLIBCXX_NOEXCEPT + { return bitset<_Nb>(*this).flip(); } + + //@{ + /** + * @brief Array-indexing support. + * @param __position Index into the %bitset. + * @return A bool for a const %bitset. For non-const + * bitsets, an instance of the reference proxy class. + * @note These operators do no range checking and throw no exceptions, + * as required by DR 11 to the standard. + * + * _GLIBCXX_RESOLVE_LIB_DEFECTS Note that this implementation already + * resolves DR 11 (items 1 and 2), but does not do the range-checking + * required by that DR's resolution. -pme + * The DR has since been changed: range-checking is a precondition + * (users' responsibility), and these functions must not throw. -pme + */ + reference + operator[](size_t __position) + { return reference(*this, __position); } + + _GLIBCXX_CONSTEXPR bool + operator[](size_t __position) const + { return _Unchecked_test(__position); } + //@} + + /** + * @brief Returns a numerical interpretation of the %bitset. + * @return The integral equivalent of the bits. + * @throw std::overflow_error If there are too many bits to be + * represented in an @c unsigned @c long. + */ + unsigned long + to_ulong() const + { return this->_M_do_to_ulong(); } + +#if __cplusplus >= 201103L + unsigned long long + to_ullong() const + { return this->_M_do_to_ullong(); } +#endif + + /** + * @brief Returns a character interpretation of the %bitset. + * @return The string equivalent of the bits. + * + * Note the ordering of the bits: decreasing character positions + * correspond to increasing bit positions (see the main class notes for + * an example). + */ + template + std::basic_string<_CharT, _Traits, _Alloc> + to_string() const + { + std::basic_string<_CharT, _Traits, _Alloc> __result; + _M_copy_to_string(__result, _CharT('0'), _CharT('1')); + return __result; + } + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 396. what are characters zero and one. + template + std::basic_string<_CharT, _Traits, _Alloc> + to_string(_CharT __zero, _CharT __one = _CharT('1')) const + { + std::basic_string<_CharT, _Traits, _Alloc> __result; + _M_copy_to_string(__result, __zero, __one); + return __result; + } + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 434. bitset::to_string() hard to use. + template + std::basic_string<_CharT, _Traits, std::allocator<_CharT> > + to_string() const + { return to_string<_CharT, _Traits, std::allocator<_CharT> >(); } + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 853. to_string needs updating with zero and one. + template + std::basic_string<_CharT, _Traits, std::allocator<_CharT> > + to_string(_CharT __zero, _CharT __one = _CharT('1')) const + { return to_string<_CharT, _Traits, + std::allocator<_CharT> >(__zero, __one); } + + template + std::basic_string<_CharT, std::char_traits<_CharT>, + std::allocator<_CharT> > + to_string() const + { + return to_string<_CharT, std::char_traits<_CharT>, + std::allocator<_CharT> >(); + } + + template + std::basic_string<_CharT, std::char_traits<_CharT>, + std::allocator<_CharT> > + to_string(_CharT __zero, _CharT __one = _CharT('1')) const + { + return to_string<_CharT, std::char_traits<_CharT>, + std::allocator<_CharT> >(__zero, __one); + } + + std::basic_string, std::allocator > + to_string() const + { + return to_string, + std::allocator >(); + } + + std::basic_string, std::allocator > + to_string(char __zero, char __one = '1') const + { + return to_string, + std::allocator >(__zero, __one); + } + + // Helper functions for string operations. + template + void + _M_copy_from_ptr(const _CharT*, size_t, size_t, size_t, + _CharT, _CharT); + + template + void + _M_copy_from_string(const std::basic_string<_CharT, + _Traits, _Alloc>& __s, size_t __pos, size_t __n, + _CharT __zero, _CharT __one) + { _M_copy_from_ptr<_CharT, _Traits>(__s.data(), __s.size(), __pos, __n, + __zero, __one); } + + template + void + _M_copy_to_string(std::basic_string<_CharT, _Traits, _Alloc>&, + _CharT, _CharT) const; + + // NB: Backward compat. + template + void + _M_copy_from_string(const std::basic_string<_CharT, + _Traits, _Alloc>& __s, size_t __pos, size_t __n) + { _M_copy_from_string(__s, __pos, __n, _CharT('0'), _CharT('1')); } + + template + void + _M_copy_to_string(std::basic_string<_CharT, _Traits,_Alloc>& __s) const + { _M_copy_to_string(__s, _CharT('0'), _CharT('1')); } + + /// Returns the number of bits which are set. + size_t + count() const _GLIBCXX_NOEXCEPT + { return this->_M_do_count(); } + + /// Returns the total number of bits. + _GLIBCXX_CONSTEXPR size_t + size() const _GLIBCXX_NOEXCEPT + { return _Nb; } + + //@{ + /// These comparisons for equality/inequality are, well, @e bitwise. + bool + operator==(const bitset<_Nb>& __rhs) const _GLIBCXX_NOEXCEPT + { return this->_M_is_equal(__rhs); } + + bool + operator!=(const bitset<_Nb>& __rhs) const _GLIBCXX_NOEXCEPT + { return !this->_M_is_equal(__rhs); } + //@} + + /** + * @brief Tests the value of a bit. + * @param __position The index of a bit. + * @return The value at @a pos. + * @throw std::out_of_range If @a pos is bigger the size of the %set. + */ + bool + test(size_t __position) const + { + this->_M_check(__position, __N("bitset::test")); + return _Unchecked_test(__position); + } + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR 693. std::bitset::all() missing. + /** + * @brief Tests whether all the bits are on. + * @return True if all the bits are set. + */ + bool + all() const _GLIBCXX_NOEXCEPT + { return this->template _M_are_all<_Nb>(); } + + /** + * @brief Tests whether any of the bits are on. + * @return True if at least one bit is set. + */ + bool + any() const _GLIBCXX_NOEXCEPT + { return this->_M_is_any(); } + + /** + * @brief Tests whether any of the bits are on. + * @return True if none of the bits are set. + */ + bool + none() const _GLIBCXX_NOEXCEPT + { return !this->_M_is_any(); } + + //@{ + /// Self-explanatory. + bitset<_Nb> + operator<<(size_t __position) const _GLIBCXX_NOEXCEPT + { return bitset<_Nb>(*this) <<= __position; } + + bitset<_Nb> + operator>>(size_t __position) const _GLIBCXX_NOEXCEPT + { return bitset<_Nb>(*this) >>= __position; } + //@} + + /** + * @brief Finds the index of the first "on" bit. + * @return The index of the first bit set, or size() if not found. + * @ingroup SGIextensions + * @sa _Find_next + */ + size_t + _Find_first() const _GLIBCXX_NOEXCEPT + { return this->_M_do_find_first(_Nb); } + + /** + * @brief Finds the index of the next "on" bit after prev. + * @return The index of the next bit set, or size() if not found. + * @param __prev Where to start searching. + * @ingroup SGIextensions + * @sa _Find_first + */ + size_t + _Find_next(size_t __prev) const _GLIBCXX_NOEXCEPT + { return this->_M_do_find_next(__prev, _Nb); } + }; + + // Definitions of non-inline member functions. + template + template + void + bitset<_Nb>:: + _M_copy_from_ptr(const _CharT* __s, size_t __len, + size_t __pos, size_t __n, _CharT __zero, _CharT __one) + { + reset(); + const size_t __nbits = std::min(_Nb, std::min(__n, size_t(__len - __pos))); + for (size_t __i = __nbits; __i > 0; --__i) + { + const _CharT __c = __s[__pos + __nbits - __i]; + if (_Traits::eq(__c, __zero)) + ; + else if (_Traits::eq(__c, __one)) + _Unchecked_set(__i - 1); + else + __throw_invalid_argument(__N("bitset::_M_copy_from_ptr")); + } + } + + template + template + void + bitset<_Nb>:: + _M_copy_to_string(std::basic_string<_CharT, _Traits, _Alloc>& __s, + _CharT __zero, _CharT __one) const + { + __s.assign(_Nb, __zero); + for (size_t __i = _Nb; __i > 0; --__i) + if (_Unchecked_test(__i - 1)) + _Traits::assign(__s[_Nb - __i], __one); + } + + // 23.3.5.3 bitset operations: + //@{ + /** + * @brief Global bitwise operations on bitsets. + * @param __x A bitset. + * @param __y A bitset of the same size as @a __x. + * @return A new bitset. + * + * These should be self-explanatory. + */ + template + inline bitset<_Nb> + operator&(const bitset<_Nb>& __x, const bitset<_Nb>& __y) _GLIBCXX_NOEXCEPT + { + bitset<_Nb> __result(__x); + __result &= __y; + return __result; + } + + template + inline bitset<_Nb> + operator|(const bitset<_Nb>& __x, const bitset<_Nb>& __y) _GLIBCXX_NOEXCEPT + { + bitset<_Nb> __result(__x); + __result |= __y; + return __result; + } + + template + inline bitset<_Nb> + operator^(const bitset<_Nb>& __x, const bitset<_Nb>& __y) _GLIBCXX_NOEXCEPT + { + bitset<_Nb> __result(__x); + __result ^= __y; + return __result; + } + //@} + + //@{ + /** + * @brief Global I/O operators for bitsets. + * + * Direct I/O between streams and bitsets is supported. Output is + * straightforward. Input will skip whitespace, only accept @a 0 and @a 1 + * characters, and will only extract as many digits as the %bitset will + * hold. + */ + template + std::basic_istream<_CharT, _Traits>& + operator>>(std::basic_istream<_CharT, _Traits>& __is, bitset<_Nb>& __x) + { + typedef typename _Traits::char_type char_type; + typedef std::basic_istream<_CharT, _Traits> __istream_type; + typedef typename __istream_type::ios_base __ios_base; + + std::basic_string<_CharT, _Traits> __tmp; + __tmp.reserve(_Nb); + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 303. Bitset input operator underspecified + const char_type __zero = __is.widen('0'); + const char_type __one = __is.widen('1'); + + typename __ios_base::iostate __state = __ios_base::goodbit; + typename __istream_type::sentry __sentry(__is); + if (__sentry) + { + __try + { + for (size_t __i = _Nb; __i > 0; --__i) + { + static typename _Traits::int_type __eof = _Traits::eof(); + + typename _Traits::int_type __c1 = __is.rdbuf()->sbumpc(); + if (_Traits::eq_int_type(__c1, __eof)) + { + __state |= __ios_base::eofbit; + break; + } + else + { + const char_type __c2 = _Traits::to_char_type(__c1); + if (_Traits::eq(__c2, __zero)) + __tmp.push_back(__zero); + else if (_Traits::eq(__c2, __one)) + __tmp.push_back(__one); + else if (_Traits:: + eq_int_type(__is.rdbuf()->sputbackc(__c2), + __eof)) + { + __state |= __ios_base::failbit; + break; + } + } + } + } + __catch(__cxxabiv1::__forced_unwind&) + { + __is._M_setstate(__ios_base::badbit); + __throw_exception_again; + } + __catch(...) + { __is._M_setstate(__ios_base::badbit); } + } + + if (__tmp.empty() && _Nb) + __state |= __ios_base::failbit; + else + __x._M_copy_from_string(__tmp, static_cast(0), _Nb, + __zero, __one); + if (__state) + __is.setstate(__state); + return __is; + } + + template + std::basic_ostream<_CharT, _Traits>& + operator<<(std::basic_ostream<_CharT, _Traits>& __os, + const bitset<_Nb>& __x) + { + std::basic_string<_CharT, _Traits> __tmp; + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 396. what are characters zero and one. + const ctype<_CharT>& __ct = use_facet >(__os.getloc()); + __x._M_copy_to_string(__tmp, __ct.widen('0'), __ct.widen('1')); + return __os << __tmp; + } + //@} + +_GLIBCXX_END_NAMESPACE_CONTAINER +} // namespace std + +#undef _GLIBCXX_BITSET_WORDS +#undef _GLIBCXX_BITSET_BITS_PER_WORD +#undef _GLIBCXX_BITSET_BITS_PER_ULL + +#if __cplusplus >= 201103L + +#include + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + // DR 1182. + /// std::hash specialization for bitset. + template + struct hash<_GLIBCXX_STD_C::bitset<_Nb>> + : public __hash_base> + { + size_t + operator()(const _GLIBCXX_STD_C::bitset<_Nb>& __b) const noexcept + { + const size_t __clength = (_Nb + __CHAR_BIT__ - 1) / __CHAR_BIT__; + return std::_Hash_impl::hash(__b._M_getdata(), __clength); + } + }; + + template<> + struct hash<_GLIBCXX_STD_C::bitset<0>> + : public __hash_base> + { + size_t + operator()(const _GLIBCXX_STD_C::bitset<0>&) const noexcept + { return 0; } + }; + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif // C++11 + +#ifdef _GLIBCXX_DEBUG +# include +#endif + +#ifdef _GLIBCXX_PROFILE +# include +#endif + +#endif /* _GLIBCXX_BITSET */ diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/cassert b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/cassert new file mode 100755 index 0000000..5cdfa81 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/cassert @@ -0,0 +1,43 @@ +// -*- C++ -*- forwarding header. + +// Copyright (C) 1997-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file cassert + * This is a Standard C++ Library file. You should @c \#include this file + * in your programs, rather than any of the @a *.h implementation files. + * + * This is the C++ version of the Standard C Library header @c assert.h, + * and its contents are (mostly) the same as that header, but are all + * contained in the namespace @c std (except for names which are defined + * as macros in C). + */ + +// +// ISO C++ 14882: 19.2 Assertions +// + +// No include guards on this header... + +#pragma GCC system_header + +#include diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/ccomplex b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/ccomplex new file mode 100755 index 0000000..2c48aaf --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/ccomplex @@ -0,0 +1,40 @@ +// -*- C++ -*- + +// Copyright (C) 2007-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file include/ccomplex + * This is a Standard C++ Library header. + */ + +#pragma GCC system_header + +#ifndef _GLIBCXX_CCOMPLEX +#define _GLIBCXX_CCOMPLEX 1 + +#if __cplusplus < 201103L +# include +#endif + +#include + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/cctype b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/cctype new file mode 100755 index 0000000..41bb54c --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/cctype @@ -0,0 +1,94 @@ +// -*- C++ -*- forwarding header. + +// Copyright (C) 1997-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file include/cctype + * This is a Standard C++ Library file. You should @c \#include this file + * in your programs, rather than any of the @a *.h implementation files. + * + * This is the C++ version of the Standard C Library header @c ctype.h, + * and its contents are (mostly) the same as that header, but are all + * contained in the namespace @c std (except for names which are defined + * as macros in C). + */ + +// +// ISO C++ 14882: +// + +#pragma GCC system_header + +#include +#include + +#ifndef _GLIBCXX_CCTYPE +#define _GLIBCXX_CCTYPE 1 + +// Get rid of those macros defined in in lieu of real functions. +#undef isalnum +#undef isalpha +#undef iscntrl +#undef isdigit +#undef isgraph +#undef islower +#undef isprint +#undef ispunct +#undef isspace +#undef isupper +#undef isxdigit +#undef tolower +#undef toupper + +namespace std +{ + using ::isalnum; + using ::isalpha; + using ::iscntrl; + using ::isdigit; + using ::isgraph; + using ::islower; + using ::isprint; + using ::ispunct; + using ::isspace; + using ::isupper; + using ::isxdigit; + using ::tolower; + using ::toupper; +} // namespace std + +#if __cplusplus >= 201103L + +#ifdef _GLIBCXX_USE_C99_CTYPE_TR1 + +#undef isblank + +namespace std +{ + using ::isblank; +} // namespace std + +#endif // _GLIBCXX_USE_C99_CTYPE_TR1 + +#endif // C++11 + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/cerrno b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/cerrno new file mode 100755 index 0000000..81a0da1 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/cerrno @@ -0,0 +1,51 @@ +// The -*- C++ -*- forwarding header. + +// Copyright (C) 1997-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file cerrno + * This is a Standard C++ Library file. You should @c \#include this file + * in your programs, rather than any of the @a *.h implementation files. + * + * This is the C++ version of the Standard C Library header @c errno.h, + * and its contents are (mostly) the same as that header, but are all + * contained in the namespace @c std (except for names which are defined + * as macros in C). + */ + +// +// ISO C++ 14882: 19.3 Error numbers +// + +#pragma GCC system_header + +#include + +#ifndef _GLIBCXX_CERRNO +#define _GLIBCXX_CERRNO 1 + +// Adhere to section 17.4.1.2 clause 5 of ISO 14882:1998 +#ifndef errno +#define errno errno +#endif + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/cfenv b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/cfenv new file mode 100755 index 0000000..a335878 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/cfenv @@ -0,0 +1,84 @@ +// -*- C++ -*- + +// Copyright (C) 2007-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file include/cfenv + * This is a Standard C++ Library header. + */ + +#ifndef _GLIBCXX_CFENV +#define _GLIBCXX_CFENV 1 + +#pragma GCC system_header + +#if __cplusplus < 201103L +# include +#else + +#include + +#if _GLIBCXX_HAVE_FENV_H +# include +#endif + +#ifdef _GLIBCXX_USE_C99_FENV_TR1 + +#undef feclearexcept +#undef fegetexceptflag +#undef feraiseexcept +#undef fesetexceptflag +#undef fetestexcept +#undef fegetround +#undef fesetround +#undef fegetenv +#undef feholdexcept +#undef fesetenv +#undef feupdateenv + +namespace std +{ + // types + using ::fenv_t; + using ::fexcept_t; + + // functions + using ::feclearexcept; + using ::fegetexceptflag; + using ::feraiseexcept; + using ::fesetexceptflag; + using ::fetestexcept; + + using ::fegetround; + using ::fesetround; + + using ::fegetenv; + using ::feholdexcept; + using ::fesetenv; + using ::feupdateenv; +} // namespace std + +#endif // _GLIBCXX_USE_C99_FENV_TR1 + +#endif // C++11 + +#endif // _GLIBCXX_CFENV diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/cfloat b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/cfloat new file mode 100755 index 0000000..2789400 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/cfloat @@ -0,0 +1,55 @@ +// -*- C++ -*- forwarding header. + +// Copyright (C) 1997-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file include/cfloat + * This is a Standard C++ Library file. You should @c \#include this file + * in your programs, rather than any of the @a *.h implementation files. + * + * This is the C++ version of the Standard C Library header @c float.h, + * and its contents are (mostly) the same as that header, but are all + * contained in the namespace @c std (except for names which are defined + * as macros in C). + */ + +// +// ISO C++ 14882: 18.2.2 Implementation properties: C library +// + +#pragma GCC system_header + +#include + +#ifndef _GLIBCXX_CFLOAT +#define _GLIBCXX_CFLOAT 1 + +#if __cplusplus >= 201103L +# ifndef DECIMAL_DIG +# define DECIMAL_DIG __DECIMAL_DIG__ +# endif +# ifndef FLT_EVAL_METHOD +# define FLT_EVAL_METHOD __FLT_EVAL_METHOD__ +# endif +#endif + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/chrono b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/chrono new file mode 100755 index 0000000..6e9c7dc --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/chrono @@ -0,0 +1,916 @@ +// -*- C++ -*- + +// Copyright (C) 2008-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file include/chrono + * This is a Standard C++ Library header. + */ + +#ifndef _GLIBCXX_CHRONO +#define _GLIBCXX_CHRONO 1 + +#pragma GCC system_header + +#if __cplusplus < 201103L +# include +#else + +#include +#include +#include +#include +#include // for literals support. + +#ifdef _GLIBCXX_USE_C99_STDINT_TR1 + +namespace std _GLIBCXX_VISIBILITY(default) +{ + /** + * @defgroup chrono Time + * @ingroup utilities + * + * Classes and functions for time. + * @{ + */ + + /** @namespace std::chrono + * @brief ISO C++ 2011 entities sub-namespace for time and date. + */ + namespace chrono + { + _GLIBCXX_BEGIN_NAMESPACE_VERSION + + template> + struct duration; + + template + struct time_point; + + _GLIBCXX_END_NAMESPACE_VERSION + } + +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + // 20.11.4.3 specialization of common_type (for duration, sfinae-friendly) + + template + struct __duration_common_type_wrapper + { + private: + typedef __static_gcd<_Period1::num, _Period2::num> __gcd_num; + typedef __static_gcd<_Period1::den, _Period2::den> __gcd_den; + typedef typename _CT::type __cr; + typedef ratio<__gcd_num::value, + (_Period1::den / __gcd_den::value) * _Period2::den> __r; + public: + typedef __success_type> type; + }; + + template + struct __duration_common_type_wrapper<__failure_type, _Period1, _Period2> + { typedef __failure_type type; }; + + template + struct common_type, + chrono::duration<_Rep2, _Period2>> + : public __duration_common_type_wrapper>::type, _Period1, _Period2>::type + { }; + + // 20.11.4.3 specialization of common_type (for time_point, sfinae-friendly) + + template + struct __timepoint_common_type_wrapper + { + typedef __success_type> + type; + }; + + template + struct __timepoint_common_type_wrapper<__failure_type, _Clock> + { typedef __failure_type type; }; + + template + struct common_type, + chrono::time_point<_Clock, _Duration2>> + : public __timepoint_common_type_wrapper>::type, _Clock>::type + { }; + +_GLIBCXX_END_NAMESPACE_VERSION + + namespace chrono + { + _GLIBCXX_BEGIN_NAMESPACE_VERSION + + // Primary template for duration_cast impl. + template + struct __duration_cast_impl + { + template + static constexpr _ToDur + __cast(const duration<_Rep, _Period>& __d) + { + typedef typename _ToDur::rep __to_rep; + return _ToDur(static_cast<__to_rep>(static_cast<_CR>(__d.count()) + * static_cast<_CR>(_CF::num) + / static_cast<_CR>(_CF::den))); + } + }; + + template + struct __duration_cast_impl<_ToDur, _CF, _CR, true, true> + { + template + static constexpr _ToDur + __cast(const duration<_Rep, _Period>& __d) + { + typedef typename _ToDur::rep __to_rep; + return _ToDur(static_cast<__to_rep>(__d.count())); + } + }; + + template + struct __duration_cast_impl<_ToDur, _CF, _CR, true, false> + { + template + static constexpr _ToDur + __cast(const duration<_Rep, _Period>& __d) + { + typedef typename _ToDur::rep __to_rep; + return _ToDur(static_cast<__to_rep>( + static_cast<_CR>(__d.count()) / static_cast<_CR>(_CF::den))); + } + }; + + template + struct __duration_cast_impl<_ToDur, _CF, _CR, false, true> + { + template + static constexpr _ToDur + __cast(const duration<_Rep, _Period>& __d) + { + typedef typename _ToDur::rep __to_rep; + return _ToDur(static_cast<__to_rep>( + static_cast<_CR>(__d.count()) * static_cast<_CR>(_CF::num))); + } + }; + + template + struct __is_duration + : std::false_type + { }; + + template + struct __is_duration> + : std::true_type + { }; + + /// duration_cast + template + constexpr typename enable_if<__is_duration<_ToDur>::value, + _ToDur>::type + duration_cast(const duration<_Rep, _Period>& __d) + { + typedef typename _ToDur::period __to_period; + typedef typename _ToDur::rep __to_rep; + typedef ratio_divide<_Period, __to_period> __cf; + typedef typename common_type<__to_rep, _Rep, intmax_t>::type + __cr; + typedef __duration_cast_impl<_ToDur, __cf, __cr, + __cf::num == 1, __cf::den == 1> __dc; + return __dc::__cast(__d); + } + + /// treat_as_floating_point + template + struct treat_as_floating_point + : is_floating_point<_Rep> + { }; + + /// duration_values + template + struct duration_values + { + static constexpr _Rep + zero() + { return _Rep(0); } + + static constexpr _Rep + max() + { return numeric_limits<_Rep>::max(); } + + static constexpr _Rep + min() + { return numeric_limits<_Rep>::lowest(); } + }; + + template + struct __is_ratio + : std::false_type + { }; + + template + struct __is_ratio> + : std::true_type + { }; + + /// duration + template + struct duration + { + typedef _Rep rep; + typedef _Period period; + + static_assert(!__is_duration<_Rep>::value, "rep cannot be a duration"); + static_assert(__is_ratio<_Period>::value, + "period must be a specialization of ratio"); + static_assert(_Period::num > 0, "period must be positive"); + + // 20.11.5.1 construction / copy / destroy + constexpr duration() = default; + + // NB: Make constexpr implicit. This cannot be explicitly + // constexpr, as any UDT that is not a literal type with a + // constexpr copy constructor will be ill-formed. + duration(const duration&) = default; + + template::value + && (treat_as_floating_point::value + || !treat_as_floating_point<_Rep2>::value)>::type> + constexpr explicit duration(const _Rep2& __rep) + : __r(static_cast(__rep)) { } + + template::value + || (ratio_divide<_Period2, period>::den == 1 + && !treat_as_floating_point<_Rep2>::value)>::type> + constexpr duration(const duration<_Rep2, _Period2>& __d) + : __r(duration_cast(__d).count()) { } + + ~duration() = default; + duration& operator=(const duration&) = default; + + // 20.11.5.2 observer + constexpr rep + count() const + { return __r; } + + // 20.11.5.3 arithmetic + constexpr duration + operator+() const + { return *this; } + + constexpr duration + operator-() const + { return duration(-__r); } + + duration& + operator++() + { + ++__r; + return *this; + } + + duration + operator++(int) + { return duration(__r++); } + + duration& + operator--() + { + --__r; + return *this; + } + + duration + operator--(int) + { return duration(__r--); } + + duration& + operator+=(const duration& __d) + { + __r += __d.count(); + return *this; + } + + duration& + operator-=(const duration& __d) + { + __r -= __d.count(); + return *this; + } + + duration& + operator*=(const rep& __rhs) + { + __r *= __rhs; + return *this; + } + + duration& + operator/=(const rep& __rhs) + { + __r /= __rhs; + return *this; + } + + // DR 934. + template + typename enable_if::value, + duration&>::type + operator%=(const rep& __rhs) + { + __r %= __rhs; + return *this; + } + + template + typename enable_if::value, + duration&>::type + operator%=(const duration& __d) + { + __r %= __d.count(); + return *this; + } + + // 20.11.5.4 special values + static constexpr duration + zero() + { return duration(duration_values::zero()); } + + static constexpr duration + min() + { return duration(duration_values::min()); } + + static constexpr duration + max() + { return duration(duration_values::max()); } + + private: + rep __r; + }; + + template + constexpr typename common_type, + duration<_Rep2, _Period2>>::type + operator+(const duration<_Rep1, _Period1>& __lhs, + const duration<_Rep2, _Period2>& __rhs) + { + typedef duration<_Rep1, _Period1> __dur1; + typedef duration<_Rep2, _Period2> __dur2; + typedef typename common_type<__dur1,__dur2>::type __cd; + return __cd(__cd(__lhs).count() + __cd(__rhs).count()); + } + + template + constexpr typename common_type, + duration<_Rep2, _Period2>>::type + operator-(const duration<_Rep1, _Period1>& __lhs, + const duration<_Rep2, _Period2>& __rhs) + { + typedef duration<_Rep1, _Period1> __dur1; + typedef duration<_Rep2, _Period2> __dur2; + typedef typename common_type<__dur1,__dur2>::type __cd; + return __cd(__cd(__lhs).count() - __cd(__rhs).count()); + } + + template::type>::value> + struct __common_rep_type { }; + + template + struct __common_rep_type<_Rep1, _Rep2, true> + { typedef typename common_type<_Rep1, _Rep2>::type type; }; + + template + constexpr + duration::type, _Period> + operator*(const duration<_Rep1, _Period>& __d, const _Rep2& __s) + { + typedef duration::type, _Period> + __cd; + return __cd(__cd(__d).count() * __s); + } + + template + constexpr + duration::type, _Period> + operator*(const _Rep1& __s, const duration<_Rep2, _Period>& __d) + { return __d * __s; } + + template + constexpr duration::value, _Rep2>::type>::type, _Period> + operator/(const duration<_Rep1, _Period>& __d, const _Rep2& __s) + { + typedef duration::type, _Period> + __cd; + return __cd(__cd(__d).count() / __s); + } + + template + constexpr typename common_type<_Rep1, _Rep2>::type + operator/(const duration<_Rep1, _Period1>& __lhs, + const duration<_Rep2, _Period2>& __rhs) + { + typedef duration<_Rep1, _Period1> __dur1; + typedef duration<_Rep2, _Period2> __dur2; + typedef typename common_type<__dur1,__dur2>::type __cd; + return __cd(__lhs).count() / __cd(__rhs).count(); + } + + // DR 934. + template + constexpr duration::value, _Rep2>::type>::type, _Period> + operator%(const duration<_Rep1, _Period>& __d, const _Rep2& __s) + { + typedef duration::type, _Period> + __cd; + return __cd(__cd(__d).count() % __s); + } + + template + constexpr typename common_type, + duration<_Rep2, _Period2>>::type + operator%(const duration<_Rep1, _Period1>& __lhs, + const duration<_Rep2, _Period2>& __rhs) + { + typedef duration<_Rep1, _Period1> __dur1; + typedef duration<_Rep2, _Period2> __dur2; + typedef typename common_type<__dur1,__dur2>::type __cd; + return __cd(__cd(__lhs).count() % __cd(__rhs).count()); + } + + // comparisons + template + constexpr bool + operator==(const duration<_Rep1, _Period1>& __lhs, + const duration<_Rep2, _Period2>& __rhs) + { + typedef duration<_Rep1, _Period1> __dur1; + typedef duration<_Rep2, _Period2> __dur2; + typedef typename common_type<__dur1,__dur2>::type __ct; + return __ct(__lhs).count() == __ct(__rhs).count(); + } + + template + constexpr bool + operator<(const duration<_Rep1, _Period1>& __lhs, + const duration<_Rep2, _Period2>& __rhs) + { + typedef duration<_Rep1, _Period1> __dur1; + typedef duration<_Rep2, _Period2> __dur2; + typedef typename common_type<__dur1,__dur2>::type __ct; + return __ct(__lhs).count() < __ct(__rhs).count(); + } + + template + constexpr bool + operator!=(const duration<_Rep1, _Period1>& __lhs, + const duration<_Rep2, _Period2>& __rhs) + { return !(__lhs == __rhs); } + + template + constexpr bool + operator<=(const duration<_Rep1, _Period1>& __lhs, + const duration<_Rep2, _Period2>& __rhs) + { return !(__rhs < __lhs); } + + template + constexpr bool + operator>(const duration<_Rep1, _Period1>& __lhs, + const duration<_Rep2, _Period2>& __rhs) + { return __rhs < __lhs; } + + template + constexpr bool + operator>=(const duration<_Rep1, _Period1>& __lhs, + const duration<_Rep2, _Period2>& __rhs) + { return !(__lhs < __rhs); } + + /// nanoseconds + typedef duration nanoseconds; + + /// microseconds + typedef duration microseconds; + + /// milliseconds + typedef duration milliseconds; + + /// seconds + typedef duration seconds; + + /// minutes + typedef duration> minutes; + + /// hours + typedef duration> hours; + + /// time_point + template + struct time_point + { + typedef _Clock clock; + typedef _Dur duration; + typedef typename duration::rep rep; + typedef typename duration::period period; + + constexpr time_point() : __d(duration::zero()) + { } + + constexpr explicit time_point(const duration& __dur) + : __d(__dur) + { } + + // conversions + template + constexpr time_point(const time_point& __t) + : __d(__t.time_since_epoch()) + { } + + // observer + constexpr duration + time_since_epoch() const + { return __d; } + + // arithmetic + time_point& + operator+=(const duration& __dur) + { + __d += __dur; + return *this; + } + + time_point& + operator-=(const duration& __dur) + { + __d -= __dur; + return *this; + } + + // special values + static constexpr time_point + min() + { return time_point(duration::min()); } + + static constexpr time_point + max() + { return time_point(duration::max()); } + + private: + duration __d; + }; + + /// time_point_cast + template + constexpr typename enable_if<__is_duration<_ToDur>::value, + time_point<_Clock, _ToDur>>::type + time_point_cast(const time_point<_Clock, _Dur>& __t) + { + typedef time_point<_Clock, _ToDur> __time_point; + return __time_point(duration_cast<_ToDur>(__t.time_since_epoch())); + } + + template + constexpr time_point<_Clock, + typename common_type<_Dur1, duration<_Rep2, _Period2>>::type> + operator+(const time_point<_Clock, _Dur1>& __lhs, + const duration<_Rep2, _Period2>& __rhs) + { + typedef duration<_Rep2, _Period2> __dur2; + typedef typename common_type<_Dur1,__dur2>::type __ct; + typedef time_point<_Clock, __ct> __time_point; + return __time_point(__lhs.time_since_epoch() + __rhs); + } + + template + constexpr time_point<_Clock, + typename common_type, _Dur2>::type> + operator+(const duration<_Rep1, _Period1>& __lhs, + const time_point<_Clock, _Dur2>& __rhs) + { + typedef duration<_Rep1, _Period1> __dur1; + typedef typename common_type<__dur1,_Dur2>::type __ct; + typedef time_point<_Clock, __ct> __time_point; + return __time_point(__rhs.time_since_epoch() + __lhs); + } + + template + constexpr time_point<_Clock, + typename common_type<_Dur1, duration<_Rep2, _Period2>>::type> + operator-(const time_point<_Clock, _Dur1>& __lhs, + const duration<_Rep2, _Period2>& __rhs) + { + typedef duration<_Rep2, _Period2> __dur2; + typedef typename common_type<_Dur1,__dur2>::type __ct; + typedef time_point<_Clock, __ct> __time_point; + return __time_point(__lhs.time_since_epoch() -__rhs); + } + + template + constexpr typename common_type<_Dur1, _Dur2>::type + operator-(const time_point<_Clock, _Dur1>& __lhs, + const time_point<_Clock, _Dur2>& __rhs) + { return __lhs.time_since_epoch() - __rhs.time_since_epoch(); } + + template + constexpr bool + operator==(const time_point<_Clock, _Dur1>& __lhs, + const time_point<_Clock, _Dur2>& __rhs) + { return __lhs.time_since_epoch() == __rhs.time_since_epoch(); } + + template + constexpr bool + operator!=(const time_point<_Clock, _Dur1>& __lhs, + const time_point<_Clock, _Dur2>& __rhs) + { return !(__lhs == __rhs); } + + template + constexpr bool + operator<(const time_point<_Clock, _Dur1>& __lhs, + const time_point<_Clock, _Dur2>& __rhs) + { return __lhs.time_since_epoch() < __rhs.time_since_epoch(); } + + template + constexpr bool + operator<=(const time_point<_Clock, _Dur1>& __lhs, + const time_point<_Clock, _Dur2>& __rhs) + { return !(__rhs < __lhs); } + + template + constexpr bool + operator>(const time_point<_Clock, _Dur1>& __lhs, + const time_point<_Clock, _Dur2>& __rhs) + { return __rhs < __lhs; } + + template + constexpr bool + operator>=(const time_point<_Clock, _Dur1>& __lhs, + const time_point<_Clock, _Dur2>& __rhs) + { return !(__lhs < __rhs); } + + + // Clocks. + + // Why nanosecond resolution as the default? + // Why have std::system_clock always count in the higest + // resolution (ie nanoseconds), even if on some OSes the low 3 + // or 9 decimal digits will be always zero? This allows later + // implementations to change the system_clock::now() + // implementation any time to provide better resolution without + // changing function signature or units. + + // To support the (forward) evolution of the library's defined + // clocks, wrap inside inline namespace so that the current + // defintions of system_clock, steady_clock, and + // high_resolution_clock types are uniquely mangled. This way, new + // code can use the latests clocks, while the library can contain + // compatibility definitions for previous versions. At some + // point, when these clocks settle down, the inlined namespaces + // can be removed. XXX GLIBCXX_ABI Deprecated + inline namespace _V2 { + + /** + * @brief System clock. + * + * Time returned represents wall time from the system-wide clock. + */ + struct system_clock + { + typedef chrono::nanoseconds duration; + typedef duration::rep rep; + typedef duration::period period; + typedef chrono::time_point time_point; + + static_assert(system_clock::duration::min() + < system_clock::duration::zero(), + "a clock's minimum duration cannot be less than its epoch"); + + static constexpr bool is_steady = false; + + static time_point + now() noexcept; + + // Map to C API + static std::time_t + to_time_t(const time_point& __t) noexcept + { + return std::time_t(duration_cast + (__t.time_since_epoch()).count()); + } + + static time_point + from_time_t(std::time_t __t) noexcept + { + typedef chrono::time_point __from; + return time_point_cast + (__from(chrono::seconds(__t))); + } + }; + + + /** + * @brief Monotonic clock + * + * Time returned has the property of only increasing at a uniform rate. + */ + struct steady_clock + { + typedef chrono::nanoseconds duration; + typedef duration::rep rep; + typedef duration::period period; + typedef chrono::time_point time_point; + + static constexpr bool is_steady = true; + + static time_point + now() noexcept; + }; + + + /** + * @brief Highest-resolution clock + * + * This is the clock "with the shortest tick period." Alias to + * std::system_clock until higher-than-nanosecond definitions + * become feasible. + */ + using high_resolution_clock = system_clock; + + } // end inline namespace _V2 + + _GLIBCXX_END_NAMESPACE_VERSION + } // namespace chrono + +#if __cplusplus > 201103L + +#define __cpp_lib_chrono_udls 201304 + + inline namespace literals + { + inline namespace chrono_literals + { + + namespace __select_type + { + + using namespace __parse_int; + + template + struct _Select_type + : conditional< + _Val <= static_cast + (numeric_limits::max()), + _Dur, void> + { + static constexpr typename _Select_type::type + value{static_cast(_Val)}; + }; + + template + constexpr typename _Select_type<_Val, _Dur>::type + _Select_type<_Val, _Dur>::value; + + } // __select_type + + constexpr chrono::duration> + operator""h(long double __hours) + { return chrono::duration>{__hours}; } + + template + constexpr typename + __select_type::_Select_type<__select_int::_Select_int<_Digits...>::value, + chrono::hours>::type + operator""h() + { + return __select_type::_Select_type< + __select_int::_Select_int<_Digits...>::value, + chrono::hours>::value; + } + + constexpr chrono::duration> + operator""min(long double __mins) + { return chrono::duration>{__mins}; } + + template + constexpr typename + __select_type::_Select_type<__select_int::_Select_int<_Digits...>::value, + chrono::minutes>::type + operator""min() + { + return __select_type::_Select_type< + __select_int::_Select_int<_Digits...>::value, + chrono::minutes>::value; + } + + constexpr chrono::duration + operator""s(long double __secs) + { return chrono::duration{__secs}; } + + template + constexpr typename + __select_type::_Select_type<__select_int::_Select_int<_Digits...>::value, + chrono::seconds>::type + operator""s() + { + return __select_type::_Select_type< + __select_int::_Select_int<_Digits...>::value, + chrono::seconds>::value; + } + + constexpr chrono::duration + operator""ms(long double __msecs) + { return chrono::duration{__msecs}; } + + template + constexpr typename + __select_type::_Select_type<__select_int::_Select_int<_Digits...>::value, + chrono::milliseconds>::type + operator""ms() + { + return __select_type::_Select_type< + __select_int::_Select_int<_Digits...>::value, + chrono::milliseconds>::value; + } + + constexpr chrono::duration + operator""us(long double __usecs) + { return chrono::duration{__usecs}; } + + template + constexpr typename + __select_type::_Select_type<__select_int::_Select_int<_Digits...>::value, + chrono::microseconds>::type + operator""us() + { + return __select_type::_Select_type< + __select_int::_Select_int<_Digits...>::value, + chrono::microseconds>::value; + } + + constexpr chrono::duration + operator""ns(long double __nsecs) + { return chrono::duration{__nsecs}; } + + template + constexpr typename + __select_type::_Select_type<__select_int::_Select_int<_Digits...>::value, + chrono::nanoseconds>::type + operator""ns() + { + return __select_type::_Select_type< + __select_int::_Select_int<_Digits...>::value, + chrono::nanoseconds>::value; + } + + } // inline namespace chrono_literals + } // inline namespace literals + +#endif // __cplusplus > 201103L + + // @} group chrono +} // namespace std + +#endif //_GLIBCXX_USE_C99_STDINT_TR1 + +#endif // C++11 + +#endif //_GLIBCXX_CHRONO diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/cinttypes b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/cinttypes new file mode 100755 index 0000000..3b74e5a --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/cinttypes @@ -0,0 +1,81 @@ +// -*- C++ -*- + +// Copyright (C) 2007-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file include/cinttypes + * This is a Standard C++ Library header. + */ + +#ifndef _GLIBCXX_CINTTYPES +#define _GLIBCXX_CINTTYPES 1 + +#pragma GCC system_header + +#if __cplusplus < 201103L +# include +#else + +#include + +// For 27.9.2/3 (see C99, Note 184) +#if _GLIBCXX_HAVE_INTTYPES_H +# ifndef __STDC_FORMAT_MACROS +# define _UNDEF__STDC_FORMAT_MACROS +# define __STDC_FORMAT_MACROS +# endif +# include +# ifdef _UNDEF__STDC_FORMAT_MACROS +# undef __STDC_FORMAT_MACROS +# undef _UNDEF__STDC_FORMAT_MACROS +# endif +#endif + +#ifdef _GLIBCXX_USE_C99_INTTYPES_TR1 + +namespace std +{ + // types + using ::imaxdiv_t; + + // functions + using ::imaxabs; + using ::imaxdiv; + + // GCC does not support extended integer types + // intmax_t abs(intmax_t) + // imaxdiv_t div(intmax_t, intmax_t) + + using ::strtoimax; + using ::strtoumax; + +#if defined(_GLIBCXX_USE_WCHAR_T) && _GLIBCXX_USE_C99_INTTYPES_WCHAR_T_TR1 + using ::wcstoimax; + using ::wcstoumax; +#endif +} // namespace std + +#endif // _GLIBCXX_USE_C99_INTTYPES_TR1 + +#endif // C++11 + +#endif // _GLIBCXX_CINTTYPES diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/ciso646 b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/ciso646 new file mode 100755 index 0000000..748ae01 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/ciso646 @@ -0,0 +1,33 @@ +// -*- C++ -*- forwarding header. + +// Copyright (C) 2001-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file ciso646 + * This is a Standard C++ Library file. You should @c \#include this file + * in your programs, rather than any of the @a *.h implementation files. + * + * This is the C++ version of the Standard C Library header @c iso646.h, + * and its contents are (mostly) the same as that header, but are all + * contained in the namespace @c std (except for names which are defined + * as macros in C). + */ diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/climits b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/climits new file mode 100755 index 0000000..2d57d7a --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/climits @@ -0,0 +1,58 @@ +// -*- C++ -*- forwarding header. + +// Copyright (C) 1997-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file include/climits + * This is a Standard C++ Library file. You should @c \#include this file + * in your programs, rather than any of the @a *.h implementation files. + * + * This is the C++ version of the Standard C Library header @c limits.h, + * and its contents are (mostly) the same as that header, but are all + * contained in the namespace @c std (except for names which are defined + * as macros in C). + */ + +// +// ISO C++ 14882: 18.2.2 Implementation properties: C library +// + +#pragma GCC system_header + +#include + +#ifndef _GLIBCXX_CLIMITS +#define _GLIBCXX_CLIMITS 1 + +#ifndef LLONG_MIN +#define LLONG_MIN (-__LONG_LONG_MAX__ - 1) +#endif + +#ifndef LLONG_MAX +#define LLONG_MAX __LONG_LONG_MAX__ +#endif + +#ifndef ULLONG_MAX +#define ULLONG_MAX (__LONG_LONG_MAX__ * 2ULL + 1) +#endif + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/clocale b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/clocale new file mode 100755 index 0000000..11fb674 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/clocale @@ -0,0 +1,58 @@ +// -*- C++ -*- forwarding header. + +// Copyright (C) 1997-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file clocale + * This is a Standard C++ Library file. You should @c \#include this file + * in your programs, rather than any of the @a *.h implementation files. + * + * This is the C++ version of the Standard C Library header @c locale.h, + * and its contents are (mostly) the same as that header, but are all + * contained in the namespace @c std (except for names which are defined + * as macros in C). + */ + +// +// ISO C++ 14882: 18.2.2 Implementation properties: C library +// + +#pragma GCC system_header + +#include +#include + +#ifndef _GLIBCXX_CLOCALE +#define _GLIBCXX_CLOCALE 1 + +// Get rid of those macros defined in in lieu of real functions. +#undef setlocale +#undef localeconv + +namespace std +{ + using ::lconv; + using ::setlocale; + using ::localeconv; +} // namespace std + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/cmath b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/cmath new file mode 100755 index 0000000..c534912 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/cmath @@ -0,0 +1,1686 @@ +// -*- C++ -*- C forwarding header. + +// Copyright (C) 1997-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file include/cmath + * This is a Standard C++ Library file. You should @c \#include this file + * in your programs, rather than any of the @a *.h implementation files. + * + * This is the C++ version of the Standard C Library header @c math.h, + * and its contents are (mostly) the same as that header, but are all + * contained in the namespace @c std (except for names which are defined + * as macros in C). + */ + +// +// ISO C++ 14882: 26.5 C library +// + +#pragma GCC system_header + +#include +#include +#include +#include + +#ifndef _GLIBCXX_CMATH +#define _GLIBCXX_CMATH 1 + +// Get rid of those macros defined in in lieu of real functions. +#undef abs +#undef div +#undef acos +#undef asin +#undef atan +#undef atan2 +#undef ceil +#undef cos +#undef cosh +#undef exp +#undef fabs +#undef floor +#undef fmod +#undef frexp +#undef ldexp +#undef log +#undef log10 +#undef modf +#undef pow +#undef sin +#undef sinh +#undef sqrt +#undef tan +#undef tanh + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + +#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO + inline _GLIBCXX_CONSTEXPR double + abs(double __x) + { return __builtin_fabs(__x); } +#endif + +#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO + inline _GLIBCXX_CONSTEXPR float + abs(float __x) + { return __builtin_fabsf(__x); } + + inline _GLIBCXX_CONSTEXPR long double + abs(long double __x) + { return __builtin_fabsl(__x); } +#endif + + template + inline _GLIBCXX_CONSTEXPR + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + abs(_Tp __x) + { return __builtin_fabs(__x); } + + using ::acos; + +#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO + inline _GLIBCXX_CONSTEXPR float + acos(float __x) + { return __builtin_acosf(__x); } + + inline _GLIBCXX_CONSTEXPR long double + acos(long double __x) + { return __builtin_acosl(__x); } +#endif + + template + inline _GLIBCXX_CONSTEXPR + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + acos(_Tp __x) + { return __builtin_acos(__x); } + + using ::asin; + +#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO + inline _GLIBCXX_CONSTEXPR float + asin(float __x) + { return __builtin_asinf(__x); } + + inline _GLIBCXX_CONSTEXPR long double + asin(long double __x) + { return __builtin_asinl(__x); } +#endif + + template + inline _GLIBCXX_CONSTEXPR + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + asin(_Tp __x) + { return __builtin_asin(__x); } + + using ::atan; + +#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO + inline _GLIBCXX_CONSTEXPR float + atan(float __x) + { return __builtin_atanf(__x); } + + inline _GLIBCXX_CONSTEXPR long double + atan(long double __x) + { return __builtin_atanl(__x); } +#endif + + template + inline _GLIBCXX_CONSTEXPR + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + atan(_Tp __x) + { return __builtin_atan(__x); } + + using ::atan2; + +#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO + inline _GLIBCXX_CONSTEXPR float + atan2(float __y, float __x) + { return __builtin_atan2f(__y, __x); } + + inline _GLIBCXX_CONSTEXPR long double + atan2(long double __y, long double __x) + { return __builtin_atan2l(__y, __x); } +#endif + + template + inline _GLIBCXX_CONSTEXPR + typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + atan2(_Tp __y, _Up __x) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return atan2(__type(__y), __type(__x)); + } + + using ::ceil; + +#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO + inline _GLIBCXX_CONSTEXPR float + ceil(float __x) + { return __builtin_ceilf(__x); } + + inline _GLIBCXX_CONSTEXPR long double + ceil(long double __x) + { return __builtin_ceill(__x); } +#endif + + template + inline _GLIBCXX_CONSTEXPR + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + ceil(_Tp __x) + { return __builtin_ceil(__x); } + + using ::cos; + +#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO + inline _GLIBCXX_CONSTEXPR float + cos(float __x) + { return __builtin_cosf(__x); } + + inline _GLIBCXX_CONSTEXPR long double + cos(long double __x) + { return __builtin_cosl(__x); } +#endif + + template + inline _GLIBCXX_CONSTEXPR + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + cos(_Tp __x) + { return __builtin_cos(__x); } + + using ::cosh; + +#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO + inline _GLIBCXX_CONSTEXPR float + cosh(float __x) + { return __builtin_coshf(__x); } + + inline _GLIBCXX_CONSTEXPR long double + cosh(long double __x) + { return __builtin_coshl(__x); } +#endif + + template + inline _GLIBCXX_CONSTEXPR + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + cosh(_Tp __x) + { return __builtin_cosh(__x); } + + using ::exp; + +#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO + inline _GLIBCXX_CONSTEXPR float + exp(float __x) + { return __builtin_expf(__x); } + + inline _GLIBCXX_CONSTEXPR long double + exp(long double __x) + { return __builtin_expl(__x); } +#endif + + template + inline _GLIBCXX_CONSTEXPR + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + exp(_Tp __x) + { return __builtin_exp(__x); } + + using ::fabs; + +#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO + inline _GLIBCXX_CONSTEXPR float + fabs(float __x) + { return __builtin_fabsf(__x); } + + inline _GLIBCXX_CONSTEXPR long double + fabs(long double __x) + { return __builtin_fabsl(__x); } +#endif + + template + inline _GLIBCXX_CONSTEXPR + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + fabs(_Tp __x) + { return __builtin_fabs(__x); } + + using ::floor; + +#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO + inline _GLIBCXX_CONSTEXPR float + floor(float __x) + { return __builtin_floorf(__x); } + + inline _GLIBCXX_CONSTEXPR long double + floor(long double __x) + { return __builtin_floorl(__x); } +#endif + + template + inline _GLIBCXX_CONSTEXPR + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + floor(_Tp __x) + { return __builtin_floor(__x); } + + using ::fmod; + +#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO + inline _GLIBCXX_CONSTEXPR float + fmod(float __x, float __y) + { return __builtin_fmodf(__x, __y); } + + inline _GLIBCXX_CONSTEXPR long double + fmod(long double __x, long double __y) + { return __builtin_fmodl(__x, __y); } +#endif + + template + inline _GLIBCXX_CONSTEXPR + typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + fmod(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return fmod(__type(__x), __type(__y)); + } + + using ::frexp; + +#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO + inline float + frexp(float __x, int* __exp) + { return __builtin_frexpf(__x, __exp); } + + inline long double + frexp(long double __x, int* __exp) + { return __builtin_frexpl(__x, __exp); } +#endif + + template + inline _GLIBCXX_CONSTEXPR + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + frexp(_Tp __x, int* __exp) + { return __builtin_frexp(__x, __exp); } + + using ::ldexp; + +#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO + inline _GLIBCXX_CONSTEXPR float + ldexp(float __x, int __exp) + { return __builtin_ldexpf(__x, __exp); } + + inline _GLIBCXX_CONSTEXPR long double + ldexp(long double __x, int __exp) + { return __builtin_ldexpl(__x, __exp); } +#endif + + template + inline _GLIBCXX_CONSTEXPR + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + ldexp(_Tp __x, int __exp) + { return __builtin_ldexp(__x, __exp); } + + using ::log; + +#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO + inline _GLIBCXX_CONSTEXPR float + log(float __x) + { return __builtin_logf(__x); } + + inline _GLIBCXX_CONSTEXPR long double + log(long double __x) + { return __builtin_logl(__x); } +#endif + + template + inline _GLIBCXX_CONSTEXPR + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + log(_Tp __x) + { return __builtin_log(__x); } + + using ::log10; + +#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO + inline _GLIBCXX_CONSTEXPR float + log10(float __x) + { return __builtin_log10f(__x); } + + inline _GLIBCXX_CONSTEXPR long double + log10(long double __x) + { return __builtin_log10l(__x); } +#endif + + template + inline _GLIBCXX_CONSTEXPR + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + log10(_Tp __x) + { return __builtin_log10(__x); } + + using ::modf; + +#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO + inline float + modf(float __x, float* __iptr) + { return __builtin_modff(__x, __iptr); } + + inline long double + modf(long double __x, long double* __iptr) + { return __builtin_modfl(__x, __iptr); } +#endif + + using ::pow; + +#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO + inline _GLIBCXX_CONSTEXPR float + pow(float __x, float __y) + { return __builtin_powf(__x, __y); } + + inline _GLIBCXX_CONSTEXPR long double + pow(long double __x, long double __y) + { return __builtin_powl(__x, __y); } + +#if __cplusplus < 201103L + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR 550. What should the return type of pow(float,int) be? + inline double + pow(double __x, int __i) + { return __builtin_powi(__x, __i); } + + inline float + pow(float __x, int __n) + { return __builtin_powif(__x, __n); } + + inline long double + pow(long double __x, int __n) + { return __builtin_powil(__x, __n); } +#endif +#endif + + template + inline _GLIBCXX_CONSTEXPR + typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + pow(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return pow(__type(__x), __type(__y)); + } + + using ::sin; + +#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO + inline _GLIBCXX_CONSTEXPR float + sin(float __x) + { return __builtin_sinf(__x); } + + inline _GLIBCXX_CONSTEXPR long double + sin(long double __x) + { return __builtin_sinl(__x); } +#endif + + template + inline _GLIBCXX_CONSTEXPR + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + sin(_Tp __x) + { return __builtin_sin(__x); } + + using ::sinh; + +#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO + inline _GLIBCXX_CONSTEXPR float + sinh(float __x) + { return __builtin_sinhf(__x); } + + inline _GLIBCXX_CONSTEXPR long double + sinh(long double __x) + { return __builtin_sinhl(__x); } +#endif + + template + inline _GLIBCXX_CONSTEXPR + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + sinh(_Tp __x) + { return __builtin_sinh(__x); } + + using ::sqrt; + +#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO + inline _GLIBCXX_CONSTEXPR float + sqrt(float __x) + { return __builtin_sqrtf(__x); } + + inline _GLIBCXX_CONSTEXPR long double + sqrt(long double __x) + { return __builtin_sqrtl(__x); } +#endif + + template + inline _GLIBCXX_CONSTEXPR + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + sqrt(_Tp __x) + { return __builtin_sqrt(__x); } + + using ::tan; + +#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO + inline _GLIBCXX_CONSTEXPR float + tan(float __x) + { return __builtin_tanf(__x); } + + inline _GLIBCXX_CONSTEXPR long double + tan(long double __x) + { return __builtin_tanl(__x); } +#endif + + template + inline _GLIBCXX_CONSTEXPR + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + tan(_Tp __x) + { return __builtin_tan(__x); } + + using ::tanh; + +#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO + inline _GLIBCXX_CONSTEXPR float + tanh(float __x) + { return __builtin_tanhf(__x); } + + inline _GLIBCXX_CONSTEXPR long double + tanh(long double __x) + { return __builtin_tanhl(__x); } +#endif + + template + inline _GLIBCXX_CONSTEXPR + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + tanh(_Tp __x) + { return __builtin_tanh(__x); } + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#if _GLIBCXX_USE_C99_MATH +#if !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC + +// These are possible macros imported from C99-land. +#undef fpclassify +#undef isfinite +#undef isinf +#undef isnan +#undef isnormal +#undef signbit +#undef isgreater +#undef isgreaterequal +#undef isless +#undef islessequal +#undef islessgreater +#undef isunordered + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + +#if __cplusplus >= 201103L + constexpr int + fpclassify(float __x) + { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL, + FP_SUBNORMAL, FP_ZERO, __x); } + + constexpr int + fpclassify(double __x) + { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL, + FP_SUBNORMAL, FP_ZERO, __x); } + + constexpr int + fpclassify(long double __x) + { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL, + FP_SUBNORMAL, FP_ZERO, __x); } + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + int>::__type + fpclassify(_Tp __x) + { return __x != 0 ? FP_NORMAL : FP_ZERO; } + + constexpr bool + isfinite(float __x) + { return __builtin_isfinite(__x); } + + constexpr bool + isfinite(double __x) + { return __builtin_isfinite(__x); } + + constexpr bool + isfinite(long double __x) + { return __builtin_isfinite(__x); } + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + bool>::__type + isfinite(_Tp __x) + { return true; } + + constexpr bool + isinf(float __x) + { return __builtin_isinf(__x); } + + constexpr bool + isinf(double __x) + { return __builtin_isinf(__x); } + + constexpr bool + isinf(long double __x) + { return __builtin_isinf(__x); } + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + bool>::__type + isinf(_Tp __x) + { return false; } + + constexpr bool + isnan(float __x) + { return __builtin_isnan(__x); } + + constexpr bool + isnan(double __x) + { return __builtin_isnan(__x); } + + constexpr bool + isnan(long double __x) + { return __builtin_isnan(__x); } + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + bool>::__type + isnan(_Tp __x) + { return false; } + + constexpr bool + isnormal(float __x) + { return __builtin_isnormal(__x); } + + constexpr bool + isnormal(double __x) + { return __builtin_isnormal(__x); } + + constexpr bool + isnormal(long double __x) + { return __builtin_isnormal(__x); } + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + bool>::__type + isnormal(_Tp __x) + { return __x != 0 ? true : false; } + + // The front-end doesn't provide a type generic builtin (libstdc++/58625). + constexpr bool + signbit(float __x) + { return __builtin_signbitf(__x); } + + constexpr bool + signbit(double __x) + { return __builtin_signbit(__x); } + + constexpr bool + signbit(long double __x) + { return __builtin_signbitl(__x); } + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + bool>::__type + signbit(_Tp __x) + { return __x < 0 ? true : false; } + + constexpr bool + isgreater(float __x, float __y) + { return __builtin_isgreater(__x, __y); } + + constexpr bool + isgreater(double __x, double __y) + { return __builtin_isgreater(__x, __y); } + + constexpr bool + isgreater(long double __x, long double __y) + { return __builtin_isgreater(__x, __y); } + + template + constexpr typename + __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value + && __is_arithmetic<_Up>::__value), bool>::__type + isgreater(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return __builtin_isgreater(__type(__x), __type(__y)); + } + + constexpr bool + isgreaterequal(float __x, float __y) + { return __builtin_isgreaterequal(__x, __y); } + + constexpr bool + isgreaterequal(double __x, double __y) + { return __builtin_isgreaterequal(__x, __y); } + + constexpr bool + isgreaterequal(long double __x, long double __y) + { return __builtin_isgreaterequal(__x, __y); } + + template + constexpr typename + __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value + && __is_arithmetic<_Up>::__value), bool>::__type + isgreaterequal(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return __builtin_isgreaterequal(__type(__x), __type(__y)); + } + + constexpr bool + isless(float __x, float __y) + { return __builtin_isless(__x, __y); } + + constexpr bool + isless(double __x, double __y) + { return __builtin_isless(__x, __y); } + + constexpr bool + isless(long double __x, long double __y) + { return __builtin_isless(__x, __y); } + + template + constexpr typename + __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value + && __is_arithmetic<_Up>::__value), bool>::__type + isless(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return __builtin_isless(__type(__x), __type(__y)); + } + + constexpr bool + islessequal(float __x, float __y) + { return __builtin_islessequal(__x, __y); } + + constexpr bool + islessequal(double __x, double __y) + { return __builtin_islessequal(__x, __y); } + + constexpr bool + islessequal(long double __x, long double __y) + { return __builtin_islessequal(__x, __y); } + + template + constexpr typename + __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value + && __is_arithmetic<_Up>::__value), bool>::__type + islessequal(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return __builtin_islessequal(__type(__x), __type(__y)); + } + + constexpr bool + islessgreater(float __x, float __y) + { return __builtin_islessgreater(__x, __y); } + + constexpr bool + islessgreater(double __x, double __y) + { return __builtin_islessgreater(__x, __y); } + + constexpr bool + islessgreater(long double __x, long double __y) + { return __builtin_islessgreater(__x, __y); } + + template + constexpr typename + __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value + && __is_arithmetic<_Up>::__value), bool>::__type + islessgreater(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return __builtin_islessgreater(__type(__x), __type(__y)); + } + + constexpr bool + isunordered(float __x, float __y) + { return __builtin_isunordered(__x, __y); } + + constexpr bool + isunordered(double __x, double __y) + { return __builtin_isunordered(__x, __y); } + + constexpr bool + isunordered(long double __x, long double __y) + { return __builtin_isunordered(__x, __y); } + + template + constexpr typename + __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value + && __is_arithmetic<_Up>::__value), bool>::__type + isunordered(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return __builtin_isunordered(__type(__x), __type(__y)); + } + +#else + + template + inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, + int>::__type + fpclassify(_Tp __f) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL, + FP_SUBNORMAL, FP_ZERO, __type(__f)); + } + + template + inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, + int>::__type + isfinite(_Tp __f) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __builtin_isfinite(__type(__f)); + } + + template + inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, + int>::__type + isinf(_Tp __f) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __builtin_isinf(__type(__f)); + } + + template + inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, + int>::__type + isnan(_Tp __f) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __builtin_isnan(__type(__f)); + } + + template + inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, + int>::__type + isnormal(_Tp __f) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __builtin_isnormal(__type(__f)); + } + + template + inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, + int>::__type + signbit(_Tp __f) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __builtin_signbit(__type(__f)); + } + + template + inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, + int>::__type + isgreater(_Tp __f1, _Tp __f2) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __builtin_isgreater(__type(__f1), __type(__f2)); + } + + template + inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, + int>::__type + isgreaterequal(_Tp __f1, _Tp __f2) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __builtin_isgreaterequal(__type(__f1), __type(__f2)); + } + + template + inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, + int>::__type + isless(_Tp __f1, _Tp __f2) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __builtin_isless(__type(__f1), __type(__f2)); + } + + template + inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, + int>::__type + islessequal(_Tp __f1, _Tp __f2) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __builtin_islessequal(__type(__f1), __type(__f2)); + } + + template + inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, + int>::__type + islessgreater(_Tp __f1, _Tp __f2) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __builtin_islessgreater(__type(__f1), __type(__f2)); + } + + template + inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, + int>::__type + isunordered(_Tp __f1, _Tp __f2) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __builtin_isunordered(__type(__f1), __type(__f2)); + } + +#endif + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif /* _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC */ +#endif + +#if __cplusplus >= 201103L + +#ifdef _GLIBCXX_USE_C99_MATH_TR1 + +#undef acosh +#undef acoshf +#undef acoshl +#undef asinh +#undef asinhf +#undef asinhl +#undef atanh +#undef atanhf +#undef atanhl +#undef cbrt +#undef cbrtf +#undef cbrtl +#undef copysign +#undef copysignf +#undef copysignl +#undef erf +#undef erff +#undef erfl +#undef erfc +#undef erfcf +#undef erfcl +#undef exp2 +#undef exp2f +#undef exp2l +#undef expm1 +#undef expm1f +#undef expm1l +#undef fdim +#undef fdimf +#undef fdiml +#undef fma +#undef fmaf +#undef fmal +#undef fmax +#undef fmaxf +#undef fmaxl +#undef fmin +#undef fminf +#undef fminl +#undef hypot +#undef hypotf +#undef hypotl +#undef ilogb +#undef ilogbf +#undef ilogbl +#undef lgamma +#undef lgammaf +#undef lgammal +#undef llrint +#undef llrintf +#undef llrintl +#undef llround +#undef llroundf +#undef llroundl +#undef log1p +#undef log1pf +#undef log1pl +#undef log2 +#undef log2f +#undef log2l +#undef logb +#undef logbf +#undef logbl +#undef lrint +#undef lrintf +#undef lrintl +#undef lround +#undef lroundf +#undef lroundl +#undef nan +#undef nanf +#undef nanl +#undef nearbyint +#undef nearbyintf +#undef nearbyintl +#undef nextafter +#undef nextafterf +#undef nextafterl +#undef nexttoward +#undef nexttowardf +#undef nexttowardl +#undef remainder +#undef remainderf +#undef remainderl +#undef remquo +#undef remquof +#undef remquol +#undef rint +#undef rintf +#undef rintl +#undef round +#undef roundf +#undef roundl +#undef scalbln +#undef scalblnf +#undef scalblnl +#undef scalbn +#undef scalbnf +#undef scalbnl +#undef tgamma +#undef tgammaf +#undef tgammal +#undef trunc +#undef truncf +#undef truncl + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + // types + using ::double_t; + using ::float_t; + + // functions + using ::acosh; + using ::acoshf; + using ::acoshl; + + using ::asinh; + using ::asinhf; + using ::asinhl; + + using ::atanh; + using ::atanhf; + using ::atanhl; + + using ::cbrt; + using ::cbrtf; + using ::cbrtl; + + using ::copysign; + using ::copysignf; + using ::copysignl; + + using ::erf; + using ::erff; + using ::erfl; + + using ::erfc; + using ::erfcf; + using ::erfcl; + + using ::exp2; + using ::exp2f; + using ::exp2l; + + using ::expm1; + using ::expm1f; + using ::expm1l; + + using ::fdim; + using ::fdimf; + using ::fdiml; + + using ::fma; + using ::fmaf; + using ::fmal; + + using ::fmax; + using ::fmaxf; + using ::fmaxl; + + using ::fmin; + using ::fminf; + using ::fminl; + + using ::hypot; + using ::hypotf; + using ::hypotl; + + using ::ilogb; + using ::ilogbf; + using ::ilogbl; + + using ::lgamma; + using ::lgammaf; + using ::lgammal; + + using ::llrint; + using ::llrintf; + using ::llrintl; + + using ::llround; + using ::llroundf; + using ::llroundl; + + using ::log1p; + using ::log1pf; + using ::log1pl; + + using ::log2; + using ::log2f; + using ::log2l; + + using ::logb; + using ::logbf; + using ::logbl; + + using ::lrint; + using ::lrintf; + using ::lrintl; + + using ::lround; + using ::lroundf; + using ::lroundl; + + using ::nan; + using ::nanf; + using ::nanl; + + using ::nearbyint; + using ::nearbyintf; + using ::nearbyintl; + + using ::nextafter; + using ::nextafterf; + using ::nextafterl; + + using ::nexttoward; + using ::nexttowardf; + using ::nexttowardl; + + using ::remainder; + using ::remainderf; + using ::remainderl; + + using ::remquo; + using ::remquof; + using ::remquol; + + using ::rint; + using ::rintf; + using ::rintl; + + using ::round; + using ::roundf; + using ::roundl; + + using ::scalbln; + using ::scalblnf; + using ::scalblnl; + + using ::scalbn; + using ::scalbnf; + using ::scalbnl; + + using ::tgamma; + using ::tgammaf; + using ::tgammal; + + using ::trunc; + using ::truncf; + using ::truncl; + + /// Additional overloads. + constexpr float + acosh(float __x) + { return __builtin_acoshf(__x); } + + constexpr long double + acosh(long double __x) + { return __builtin_acoshl(__x); } + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + acosh(_Tp __x) + { return __builtin_acosh(__x); } + + constexpr float + asinh(float __x) + { return __builtin_asinhf(__x); } + + constexpr long double + asinh(long double __x) + { return __builtin_asinhl(__x); } + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + asinh(_Tp __x) + { return __builtin_asinh(__x); } + + constexpr float + atanh(float __x) + { return __builtin_atanhf(__x); } + + constexpr long double + atanh(long double __x) + { return __builtin_atanhl(__x); } + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + atanh(_Tp __x) + { return __builtin_atanh(__x); } + + constexpr float + cbrt(float __x) + { return __builtin_cbrtf(__x); } + + constexpr long double + cbrt(long double __x) + { return __builtin_cbrtl(__x); } + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + cbrt(_Tp __x) + { return __builtin_cbrt(__x); } + + constexpr float + copysign(float __x, float __y) + { return __builtin_copysignf(__x, __y); } + + constexpr long double + copysign(long double __x, long double __y) + { return __builtin_copysignl(__x, __y); } + + template + constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + copysign(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return copysign(__type(__x), __type(__y)); + } + + constexpr float + erf(float __x) + { return __builtin_erff(__x); } + + constexpr long double + erf(long double __x) + { return __builtin_erfl(__x); } + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + erf(_Tp __x) + { return __builtin_erf(__x); } + + constexpr float + erfc(float __x) + { return __builtin_erfcf(__x); } + + constexpr long double + erfc(long double __x) + { return __builtin_erfcl(__x); } + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + erfc(_Tp __x) + { return __builtin_erfc(__x); } + + constexpr float + exp2(float __x) + { return __builtin_exp2f(__x); } + + constexpr long double + exp2(long double __x) + { return __builtin_exp2l(__x); } + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + exp2(_Tp __x) + { return __builtin_exp2(__x); } + + constexpr float + expm1(float __x) + { return __builtin_expm1f(__x); } + + constexpr long double + expm1(long double __x) + { return __builtin_expm1l(__x); } + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + expm1(_Tp __x) + { return __builtin_expm1(__x); } + + constexpr float + fdim(float __x, float __y) + { return __builtin_fdimf(__x, __y); } + + constexpr long double + fdim(long double __x, long double __y) + { return __builtin_fdiml(__x, __y); } + + template + constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + fdim(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return fdim(__type(__x), __type(__y)); + } + + constexpr float + fma(float __x, float __y, float __z) + { return __builtin_fmaf(__x, __y, __z); } + + constexpr long double + fma(long double __x, long double __y, long double __z) + { return __builtin_fmal(__x, __y, __z); } + + template + constexpr typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type + fma(_Tp __x, _Up __y, _Vp __z) + { + typedef typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type __type; + return fma(__type(__x), __type(__y), __type(__z)); + } + + constexpr float + fmax(float __x, float __y) + { return __builtin_fmaxf(__x, __y); } + + constexpr long double + fmax(long double __x, long double __y) + { return __builtin_fmaxl(__x, __y); } + + template + constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + fmax(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return fmax(__type(__x), __type(__y)); + } + + constexpr float + fmin(float __x, float __y) + { return __builtin_fminf(__x, __y); } + + constexpr long double + fmin(long double __x, long double __y) + { return __builtin_fminl(__x, __y); } + + template + constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + fmin(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return fmin(__type(__x), __type(__y)); + } + + constexpr float + hypot(float __x, float __y) + { return __builtin_hypotf(__x, __y); } + + constexpr long double + hypot(long double __x, long double __y) + { return __builtin_hypotl(__x, __y); } + + template + constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + hypot(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return hypot(__type(__x), __type(__y)); + } + + constexpr int + ilogb(float __x) + { return __builtin_ilogbf(__x); } + + constexpr int + ilogb(long double __x) + { return __builtin_ilogbl(__x); } + + template + constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + int>::__type + ilogb(_Tp __x) + { return __builtin_ilogb(__x); } + + constexpr float + lgamma(float __x) + { return __builtin_lgammaf(__x); } + + constexpr long double + lgamma(long double __x) + { return __builtin_lgammal(__x); } + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + lgamma(_Tp __x) + { return __builtin_lgamma(__x); } + + constexpr long long + llrint(float __x) + { return __builtin_llrintf(__x); } + + constexpr long long + llrint(long double __x) + { return __builtin_llrintl(__x); } + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + long long>::__type + llrint(_Tp __x) + { return __builtin_llrint(__x); } + + constexpr long long + llround(float __x) + { return __builtin_llroundf(__x); } + + constexpr long long + llround(long double __x) + { return __builtin_llroundl(__x); } + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + long long>::__type + llround(_Tp __x) + { return __builtin_llround(__x); } + + constexpr float + log1p(float __x) + { return __builtin_log1pf(__x); } + + constexpr long double + log1p(long double __x) + { return __builtin_log1pl(__x); } + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + log1p(_Tp __x) + { return __builtin_log1p(__x); } + + // DR 568. + constexpr float + log2(float __x) + { return __builtin_log2f(__x); } + + constexpr long double + log2(long double __x) + { return __builtin_log2l(__x); } + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + log2(_Tp __x) + { return __builtin_log2(__x); } + + constexpr float + logb(float __x) + { return __builtin_logbf(__x); } + + constexpr long double + logb(long double __x) + { return __builtin_logbl(__x); } + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + logb(_Tp __x) + { return __builtin_logb(__x); } + + constexpr long + lrint(float __x) + { return __builtin_lrintf(__x); } + + constexpr long + lrint(long double __x) + { return __builtin_lrintl(__x); } + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + long>::__type + lrint(_Tp __x) + { return __builtin_lrint(__x); } + + constexpr long + lround(float __x) + { return __builtin_lroundf(__x); } + + constexpr long + lround(long double __x) + { return __builtin_lroundl(__x); } + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + long>::__type + lround(_Tp __x) + { return __builtin_lround(__x); } + + constexpr float + nearbyint(float __x) + { return __builtin_nearbyintf(__x); } + + constexpr long double + nearbyint(long double __x) + { return __builtin_nearbyintl(__x); } + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + nearbyint(_Tp __x) + { return __builtin_nearbyint(__x); } + + constexpr float + nextafter(float __x, float __y) + { return __builtin_nextafterf(__x, __y); } + + constexpr long double + nextafter(long double __x, long double __y) + { return __builtin_nextafterl(__x, __y); } + + template + constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + nextafter(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return nextafter(__type(__x), __type(__y)); + } + + constexpr float + nexttoward(float __x, long double __y) + { return __builtin_nexttowardf(__x, __y); } + + constexpr long double + nexttoward(long double __x, long double __y) + { return __builtin_nexttowardl(__x, __y); } + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + nexttoward(_Tp __x, long double __y) + { return __builtin_nexttoward(__x, __y); } + + constexpr float + remainder(float __x, float __y) + { return __builtin_remainderf(__x, __y); } + + constexpr long double + remainder(long double __x, long double __y) + { return __builtin_remainderl(__x, __y); } + + template + constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + remainder(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return remainder(__type(__x), __type(__y)); + } + + inline float + remquo(float __x, float __y, int* __pquo) + { return __builtin_remquof(__x, __y, __pquo); } + + inline long double + remquo(long double __x, long double __y, int* __pquo) + { return __builtin_remquol(__x, __y, __pquo); } + + template + inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + remquo(_Tp __x, _Up __y, int* __pquo) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return remquo(__type(__x), __type(__y), __pquo); + } + + constexpr float + rint(float __x) + { return __builtin_rintf(__x); } + + constexpr long double + rint(long double __x) + { return __builtin_rintl(__x); } + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + rint(_Tp __x) + { return __builtin_rint(__x); } + + constexpr float + round(float __x) + { return __builtin_roundf(__x); } + + constexpr long double + round(long double __x) + { return __builtin_roundl(__x); } + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + round(_Tp __x) + { return __builtin_round(__x); } + + constexpr float + scalbln(float __x, long __ex) + { return __builtin_scalblnf(__x, __ex); } + + constexpr long double + scalbln(long double __x, long __ex) + { return __builtin_scalblnl(__x, __ex); } + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + scalbln(_Tp __x, long __ex) + { return __builtin_scalbln(__x, __ex); } + + constexpr float + scalbn(float __x, int __ex) + { return __builtin_scalbnf(__x, __ex); } + + constexpr long double + scalbn(long double __x, int __ex) + { return __builtin_scalbnl(__x, __ex); } + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + scalbn(_Tp __x, int __ex) + { return __builtin_scalbn(__x, __ex); } + + constexpr float + tgamma(float __x) + { return __builtin_tgammaf(__x); } + + constexpr long double + tgamma(long double __x) + { return __builtin_tgammal(__x); } + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + tgamma(_Tp __x) + { return __builtin_tgamma(__x); } + + constexpr float + trunc(float __x) + { return __builtin_truncf(__x); } + + constexpr long double + trunc(long double __x) + { return __builtin_truncl(__x); } + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + trunc(_Tp __x) + { return __builtin_trunc(__x); } + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif // _GLIBCXX_USE_C99_MATH_TR1 + +#endif // C++11 + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/complex b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/complex new file mode 100755 index 0000000..941e6b7 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/complex @@ -0,0 +1,1968 @@ +// The template and inlines for the -*- C++ -*- complex number classes. + +// Copyright (C) 1997-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file include/complex + * This is a Standard C++ Library header. + */ + +// +// ISO C++ 14882: 26.2 Complex Numbers +// Note: this is not a conforming implementation. +// Initially implemented by Ulrich Drepper +// Improved by Gabriel Dos Reis +// + +#ifndef _GLIBCXX_COMPLEX +#define _GLIBCXX_COMPLEX 1 + +#pragma GCC system_header + +#include +#include +#include +#include +#include + +// Get rid of a macro possibly defined in +#undef complex + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /** + * @defgroup complex_numbers Complex Numbers + * @ingroup numerics + * + * Classes and functions for complex numbers. + * @{ + */ + + // Forward declarations. + template class complex; + template<> class complex; + template<> class complex; + template<> class complex; + + /// Return magnitude of @a z. + template _Tp abs(const complex<_Tp>&); + /// Return phase angle of @a z. + template _Tp arg(const complex<_Tp>&); + /// Return @a z magnitude squared. + template _Tp norm(const complex<_Tp>&); + + /// Return complex conjugate of @a z. + template complex<_Tp> conj(const complex<_Tp>&); + /// Return complex with magnitude @a rho and angle @a theta. + template complex<_Tp> polar(const _Tp&, const _Tp& = 0); + + // Transcendentals: + /// Return complex cosine of @a z. + template complex<_Tp> cos(const complex<_Tp>&); + /// Return complex hyperbolic cosine of @a z. + template complex<_Tp> cosh(const complex<_Tp>&); + /// Return complex base e exponential of @a z. + template complex<_Tp> exp(const complex<_Tp>&); + /// Return complex natural logarithm of @a z. + template complex<_Tp> log(const complex<_Tp>&); + /// Return complex base 10 logarithm of @a z. + template complex<_Tp> log10(const complex<_Tp>&); + /// Return @a x to the @a y'th power. + template complex<_Tp> pow(const complex<_Tp>&, int); + /// Return @a x to the @a y'th power. + template complex<_Tp> pow(const complex<_Tp>&, const _Tp&); + /// Return @a x to the @a y'th power. + template complex<_Tp> pow(const complex<_Tp>&, + const complex<_Tp>&); + /// Return @a x to the @a y'th power. + template complex<_Tp> pow(const _Tp&, const complex<_Tp>&); + /// Return complex sine of @a z. + template complex<_Tp> sin(const complex<_Tp>&); + /// Return complex hyperbolic sine of @a z. + template complex<_Tp> sinh(const complex<_Tp>&); + /// Return complex square root of @a z. + template complex<_Tp> sqrt(const complex<_Tp>&); + /// Return complex tangent of @a z. + template complex<_Tp> tan(const complex<_Tp>&); + /// Return complex hyperbolic tangent of @a z. + template complex<_Tp> tanh(const complex<_Tp>&); + + + // 26.2.2 Primary template class complex + /** + * Template to represent complex numbers. + * + * Specializations for float, double, and long double are part of the + * library. Results with any other type are not guaranteed. + * + * @param Tp Type of real and imaginary values. + */ + template + struct complex + { + /// Value typedef. + typedef _Tp value_type; + + /// Default constructor. First parameter is x, second parameter is y. + /// Unspecified parameters default to 0. + _GLIBCXX_CONSTEXPR complex(const _Tp& __r = _Tp(), const _Tp& __i = _Tp()) + : _M_real(__r), _M_imag(__i) { } + + // Lets the compiler synthesize the copy constructor + // complex (const complex<_Tp>&); + /// Copy constructor. + template + _GLIBCXX_CONSTEXPR complex(const complex<_Up>& __z) + : _M_real(__z.real()), _M_imag(__z.imag()) { } + +#if __cplusplus >= 201103L + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR 387. std::complex over-encapsulated. + _GLIBCXX_ABI_TAG_CXX11 + constexpr _Tp + real() { return _M_real; } + + _GLIBCXX_ABI_TAG_CXX11 + constexpr _Tp + imag() { return _M_imag; } +#else + /// Return real part of complex number. + _Tp& + real() { return _M_real; } + + /// Return real part of complex number. + const _Tp& + real() const { return _M_real; } + + /// Return imaginary part of complex number. + _Tp& + imag() { return _M_imag; } + + /// Return imaginary part of complex number. + const _Tp& + imag() const { return _M_imag; } +#endif + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR 387. std::complex over-encapsulated. + void + real(_Tp __val) { _M_real = __val; } + + void + imag(_Tp __val) { _M_imag = __val; } + + /// Assign this complex number to scalar @a t. + complex<_Tp>& operator=(const _Tp&); + + /// Add @a t to this complex number. + // 26.2.5/1 + complex<_Tp>& + operator+=(const _Tp& __t) + { + _M_real += __t; + return *this; + } + + /// Subtract @a t from this complex number. + // 26.2.5/3 + complex<_Tp>& + operator-=(const _Tp& __t) + { + _M_real -= __t; + return *this; + } + + /// Multiply this complex number by @a t. + complex<_Tp>& operator*=(const _Tp&); + /// Divide this complex number by @a t. + complex<_Tp>& operator/=(const _Tp&); + + // Lets the compiler synthesize the + // copy and assignment operator + // complex<_Tp>& operator= (const complex<_Tp>&); + /// Assign this complex number to complex @a z. + template + complex<_Tp>& operator=(const complex<_Up>&); + /// Add @a z to this complex number. + template + complex<_Tp>& operator+=(const complex<_Up>&); + /// Subtract @a z from this complex number. + template + complex<_Tp>& operator-=(const complex<_Up>&); + /// Multiply this complex number by @a z. + template + complex<_Tp>& operator*=(const complex<_Up>&); + /// Divide this complex number by @a z. + template + complex<_Tp>& operator/=(const complex<_Up>&); + + _GLIBCXX_USE_CONSTEXPR complex __rep() const + { return *this; } + + private: + _Tp _M_real; + _Tp _M_imag; + }; + + template + complex<_Tp>& + complex<_Tp>::operator=(const _Tp& __t) + { + _M_real = __t; + _M_imag = _Tp(); + return *this; + } + + // 26.2.5/5 + template + complex<_Tp>& + complex<_Tp>::operator*=(const _Tp& __t) + { + _M_real *= __t; + _M_imag *= __t; + return *this; + } + + // 26.2.5/7 + template + complex<_Tp>& + complex<_Tp>::operator/=(const _Tp& __t) + { + _M_real /= __t; + _M_imag /= __t; + return *this; + } + + template + template + complex<_Tp>& + complex<_Tp>::operator=(const complex<_Up>& __z) + { + _M_real = __z.real(); + _M_imag = __z.imag(); + return *this; + } + + // 26.2.5/9 + template + template + complex<_Tp>& + complex<_Tp>::operator+=(const complex<_Up>& __z) + { + _M_real += __z.real(); + _M_imag += __z.imag(); + return *this; + } + + // 26.2.5/11 + template + template + complex<_Tp>& + complex<_Tp>::operator-=(const complex<_Up>& __z) + { + _M_real -= __z.real(); + _M_imag -= __z.imag(); + return *this; + } + + // 26.2.5/13 + // XXX: This is a grammar school implementation. + template + template + complex<_Tp>& + complex<_Tp>::operator*=(const complex<_Up>& __z) + { + const _Tp __r = _M_real * __z.real() - _M_imag * __z.imag(); + _M_imag = _M_real * __z.imag() + _M_imag * __z.real(); + _M_real = __r; + return *this; + } + + // 26.2.5/15 + // XXX: This is a grammar school implementation. + template + template + complex<_Tp>& + complex<_Tp>::operator/=(const complex<_Up>& __z) + { + const _Tp __r = _M_real * __z.real() + _M_imag * __z.imag(); + const _Tp __n = std::norm(__z); + _M_imag = (_M_imag * __z.real() - _M_real * __z.imag()) / __n; + _M_real = __r / __n; + return *this; + } + + // Operators: + //@{ + /// Return new complex value @a x plus @a y. + template + inline complex<_Tp> + operator+(const complex<_Tp>& __x, const complex<_Tp>& __y) + { + complex<_Tp> __r = __x; + __r += __y; + return __r; + } + + template + inline complex<_Tp> + operator+(const complex<_Tp>& __x, const _Tp& __y) + { + complex<_Tp> __r = __x; + __r += __y; + return __r; + } + + template + inline complex<_Tp> + operator+(const _Tp& __x, const complex<_Tp>& __y) + { + complex<_Tp> __r = __y; + __r += __x; + return __r; + } + //@} + + //@{ + /// Return new complex value @a x minus @a y. + template + inline complex<_Tp> + operator-(const complex<_Tp>& __x, const complex<_Tp>& __y) + { + complex<_Tp> __r = __x; + __r -= __y; + return __r; + } + + template + inline complex<_Tp> + operator-(const complex<_Tp>& __x, const _Tp& __y) + { + complex<_Tp> __r = __x; + __r -= __y; + return __r; + } + + template + inline complex<_Tp> + operator-(const _Tp& __x, const complex<_Tp>& __y) + { + complex<_Tp> __r(__x, -__y.imag()); + __r -= __y.real(); + return __r; + } + //@} + + //@{ + /// Return new complex value @a x times @a y. + template + inline complex<_Tp> + operator*(const complex<_Tp>& __x, const complex<_Tp>& __y) + { + complex<_Tp> __r = __x; + __r *= __y; + return __r; + } + + template + inline complex<_Tp> + operator*(const complex<_Tp>& __x, const _Tp& __y) + { + complex<_Tp> __r = __x; + __r *= __y; + return __r; + } + + template + inline complex<_Tp> + operator*(const _Tp& __x, const complex<_Tp>& __y) + { + complex<_Tp> __r = __y; + __r *= __x; + return __r; + } + //@} + + //@{ + /// Return new complex value @a x divided by @a y. + template + inline complex<_Tp> + operator/(const complex<_Tp>& __x, const complex<_Tp>& __y) + { + complex<_Tp> __r = __x; + __r /= __y; + return __r; + } + + template + inline complex<_Tp> + operator/(const complex<_Tp>& __x, const _Tp& __y) + { + complex<_Tp> __r = __x; + __r /= __y; + return __r; + } + + template + inline complex<_Tp> + operator/(const _Tp& __x, const complex<_Tp>& __y) + { + complex<_Tp> __r = __x; + __r /= __y; + return __r; + } + //@} + + /// Return @a x. + template + inline complex<_Tp> + operator+(const complex<_Tp>& __x) + { return __x; } + + /// Return complex negation of @a x. + template + inline complex<_Tp> + operator-(const complex<_Tp>& __x) + { return complex<_Tp>(-__x.real(), -__x.imag()); } + + //@{ + /// Return true if @a x is equal to @a y. + template + inline _GLIBCXX_CONSTEXPR bool + operator==(const complex<_Tp>& __x, const complex<_Tp>& __y) + { return __x.real() == __y.real() && __x.imag() == __y.imag(); } + + template + inline _GLIBCXX_CONSTEXPR bool + operator==(const complex<_Tp>& __x, const _Tp& __y) + { return __x.real() == __y && __x.imag() == _Tp(); } + + template + inline _GLIBCXX_CONSTEXPR bool + operator==(const _Tp& __x, const complex<_Tp>& __y) + { return __x == __y.real() && _Tp() == __y.imag(); } + //@} + + //@{ + /// Return false if @a x is equal to @a y. + template + inline _GLIBCXX_CONSTEXPR bool + operator!=(const complex<_Tp>& __x, const complex<_Tp>& __y) + { return __x.real() != __y.real() || __x.imag() != __y.imag(); } + + template + inline _GLIBCXX_CONSTEXPR bool + operator!=(const complex<_Tp>& __x, const _Tp& __y) + { return __x.real() != __y || __x.imag() != _Tp(); } + + template + inline _GLIBCXX_CONSTEXPR bool + operator!=(const _Tp& __x, const complex<_Tp>& __y) + { return __x != __y.real() || _Tp() != __y.imag(); } + //@} + + /// Extraction operator for complex values. + template + basic_istream<_CharT, _Traits>& + operator>>(basic_istream<_CharT, _Traits>& __is, complex<_Tp>& __x) + { + _Tp __re_x, __im_x; + _CharT __ch; + __is >> __ch; + if (__ch == '(') + { + __is >> __re_x >> __ch; + if (__ch == ',') + { + __is >> __im_x >> __ch; + if (__ch == ')') + __x = complex<_Tp>(__re_x, __im_x); + else + __is.setstate(ios_base::failbit); + } + else if (__ch == ')') + __x = __re_x; + else + __is.setstate(ios_base::failbit); + } + else + { + __is.putback(__ch); + __is >> __re_x; + __x = __re_x; + } + return __is; + } + + /// Insertion operator for complex values. + template + basic_ostream<_CharT, _Traits>& + operator<<(basic_ostream<_CharT, _Traits>& __os, const complex<_Tp>& __x) + { + basic_ostringstream<_CharT, _Traits> __s; + __s.flags(__os.flags()); + __s.imbue(__os.getloc()); + __s.precision(__os.precision()); + __s << '(' << __x.real() << ',' << __x.imag() << ')'; + return __os << __s.str(); + } + + // Values +#if __cplusplus >= 201103L + template + constexpr _Tp + real(const complex<_Tp>& __z) + { return __z.real(); } + + template + constexpr _Tp + imag(const complex<_Tp>& __z) + { return __z.imag(); } +#else + template + inline _Tp& + real(complex<_Tp>& __z) + { return __z.real(); } + + template + inline const _Tp& + real(const complex<_Tp>& __z) + { return __z.real(); } + + template + inline _Tp& + imag(complex<_Tp>& __z) + { return __z.imag(); } + + template + inline const _Tp& + imag(const complex<_Tp>& __z) + { return __z.imag(); } +#endif + + // 26.2.7/3 abs(__z): Returns the magnitude of __z. + template + inline _Tp + __complex_abs(const complex<_Tp>& __z) + { + _Tp __x = __z.real(); + _Tp __y = __z.imag(); + const _Tp __s = std::max(abs(__x), abs(__y)); + if (__s == _Tp()) // well ... + return __s; + __x /= __s; + __y /= __s; + return __s * sqrt(__x * __x + __y * __y); + } + +#if _GLIBCXX_USE_C99_COMPLEX + inline float + __complex_abs(__complex__ float __z) { return __builtin_cabsf(__z); } + + inline double + __complex_abs(__complex__ double __z) { return __builtin_cabs(__z); } + + inline long double + __complex_abs(const __complex__ long double& __z) + { return __builtin_cabsl(__z); } + + template + inline _Tp + abs(const complex<_Tp>& __z) { return __complex_abs(__z.__rep()); } +#else + template + inline _Tp + abs(const complex<_Tp>& __z) { return __complex_abs(__z); } +#endif + + + // 26.2.7/4: arg(__z): Returns the phase angle of __z. + template + inline _Tp + __complex_arg(const complex<_Tp>& __z) + { return atan2(__z.imag(), __z.real()); } + +#if _GLIBCXX_USE_C99_COMPLEX + inline float + __complex_arg(__complex__ float __z) { return __builtin_cargf(__z); } + + inline double + __complex_arg(__complex__ double __z) { return __builtin_carg(__z); } + + inline long double + __complex_arg(const __complex__ long double& __z) + { return __builtin_cargl(__z); } + + template + inline _Tp + arg(const complex<_Tp>& __z) { return __complex_arg(__z.__rep()); } +#else + template + inline _Tp + arg(const complex<_Tp>& __z) { return __complex_arg(__z); } +#endif + + // 26.2.7/5: norm(__z) returns the squared magnitude of __z. + // As defined, norm() is -not- a norm is the common mathematical + // sens used in numerics. The helper class _Norm_helper<> tries to + // distinguish between builtin floating point and the rest, so as + // to deliver an answer as close as possible to the real value. + template + struct _Norm_helper + { + template + static inline _Tp _S_do_it(const complex<_Tp>& __z) + { + const _Tp __x = __z.real(); + const _Tp __y = __z.imag(); + return __x * __x + __y * __y; + } + }; + + template<> + struct _Norm_helper + { + template + static inline _Tp _S_do_it(const complex<_Tp>& __z) + { + _Tp __res = std::abs(__z); + return __res * __res; + } + }; + + template + inline _Tp + norm(const complex<_Tp>& __z) + { + return _Norm_helper<__is_floating<_Tp>::__value + && !_GLIBCXX_FAST_MATH>::_S_do_it(__z); + } + + template + inline complex<_Tp> + polar(const _Tp& __rho, const _Tp& __theta) + { return complex<_Tp>(__rho * cos(__theta), __rho * sin(__theta)); } + + template + inline complex<_Tp> + conj(const complex<_Tp>& __z) + { return complex<_Tp>(__z.real(), -__z.imag()); } + + // Transcendentals + + // 26.2.8/1 cos(__z): Returns the cosine of __z. + template + inline complex<_Tp> + __complex_cos(const complex<_Tp>& __z) + { + const _Tp __x = __z.real(); + const _Tp __y = __z.imag(); + return complex<_Tp>(cos(__x) * cosh(__y), -sin(__x) * sinh(__y)); + } + +#if _GLIBCXX_USE_C99_COMPLEX + inline __complex__ float + __complex_cos(__complex__ float __z) { return __builtin_ccosf(__z); } + + inline __complex__ double + __complex_cos(__complex__ double __z) { return __builtin_ccos(__z); } + + inline __complex__ long double + __complex_cos(const __complex__ long double& __z) + { return __builtin_ccosl(__z); } + + template + inline complex<_Tp> + cos(const complex<_Tp>& __z) { return __complex_cos(__z.__rep()); } +#else + template + inline complex<_Tp> + cos(const complex<_Tp>& __z) { return __complex_cos(__z); } +#endif + + // 26.2.8/2 cosh(__z): Returns the hyperbolic cosine of __z. + template + inline complex<_Tp> + __complex_cosh(const complex<_Tp>& __z) + { + const _Tp __x = __z.real(); + const _Tp __y = __z.imag(); + return complex<_Tp>(cosh(__x) * cos(__y), sinh(__x) * sin(__y)); + } + +#if _GLIBCXX_USE_C99_COMPLEX + inline __complex__ float + __complex_cosh(__complex__ float __z) { return __builtin_ccoshf(__z); } + + inline __complex__ double + __complex_cosh(__complex__ double __z) { return __builtin_ccosh(__z); } + + inline __complex__ long double + __complex_cosh(const __complex__ long double& __z) + { return __builtin_ccoshl(__z); } + + template + inline complex<_Tp> + cosh(const complex<_Tp>& __z) { return __complex_cosh(__z.__rep()); } +#else + template + inline complex<_Tp> + cosh(const complex<_Tp>& __z) { return __complex_cosh(__z); } +#endif + + // 26.2.8/3 exp(__z): Returns the complex base e exponential of x + template + inline complex<_Tp> + __complex_exp(const complex<_Tp>& __z) + { return std::polar(exp(__z.real()), __z.imag()); } + +#if _GLIBCXX_USE_C99_COMPLEX + inline __complex__ float + __complex_exp(__complex__ float __z) { return __builtin_cexpf(__z); } + + inline __complex__ double + __complex_exp(__complex__ double __z) { return __builtin_cexp(__z); } + + inline __complex__ long double + __complex_exp(const __complex__ long double& __z) + { return __builtin_cexpl(__z); } + + template + inline complex<_Tp> + exp(const complex<_Tp>& __z) { return __complex_exp(__z.__rep()); } +#else + template + inline complex<_Tp> + exp(const complex<_Tp>& __z) { return __complex_exp(__z); } +#endif + + // 26.2.8/5 log(__z): Returns the natural complex logarithm of __z. + // The branch cut is along the negative axis. + template + inline complex<_Tp> + __complex_log(const complex<_Tp>& __z) + { return complex<_Tp>(log(std::abs(__z)), std::arg(__z)); } + +#if _GLIBCXX_USE_C99_COMPLEX + inline __complex__ float + __complex_log(__complex__ float __z) { return __builtin_clogf(__z); } + + inline __complex__ double + __complex_log(__complex__ double __z) { return __builtin_clog(__z); } + + inline __complex__ long double + __complex_log(const __complex__ long double& __z) + { return __builtin_clogl(__z); } + + template + inline complex<_Tp> + log(const complex<_Tp>& __z) { return __complex_log(__z.__rep()); } +#else + template + inline complex<_Tp> + log(const complex<_Tp>& __z) { return __complex_log(__z); } +#endif + + template + inline complex<_Tp> + log10(const complex<_Tp>& __z) + { return std::log(__z) / log(_Tp(10.0)); } + + // 26.2.8/10 sin(__z): Returns the sine of __z. + template + inline complex<_Tp> + __complex_sin(const complex<_Tp>& __z) + { + const _Tp __x = __z.real(); + const _Tp __y = __z.imag(); + return complex<_Tp>(sin(__x) * cosh(__y), cos(__x) * sinh(__y)); + } + +#if _GLIBCXX_USE_C99_COMPLEX + inline __complex__ float + __complex_sin(__complex__ float __z) { return __builtin_csinf(__z); } + + inline __complex__ double + __complex_sin(__complex__ double __z) { return __builtin_csin(__z); } + + inline __complex__ long double + __complex_sin(const __complex__ long double& __z) + { return __builtin_csinl(__z); } + + template + inline complex<_Tp> + sin(const complex<_Tp>& __z) { return __complex_sin(__z.__rep()); } +#else + template + inline complex<_Tp> + sin(const complex<_Tp>& __z) { return __complex_sin(__z); } +#endif + + // 26.2.8/11 sinh(__z): Returns the hyperbolic sine of __z. + template + inline complex<_Tp> + __complex_sinh(const complex<_Tp>& __z) + { + const _Tp __x = __z.real(); + const _Tp __y = __z.imag(); + return complex<_Tp>(sinh(__x) * cos(__y), cosh(__x) * sin(__y)); + } + +#if _GLIBCXX_USE_C99_COMPLEX + inline __complex__ float + __complex_sinh(__complex__ float __z) { return __builtin_csinhf(__z); } + + inline __complex__ double + __complex_sinh(__complex__ double __z) { return __builtin_csinh(__z); } + + inline __complex__ long double + __complex_sinh(const __complex__ long double& __z) + { return __builtin_csinhl(__z); } + + template + inline complex<_Tp> + sinh(const complex<_Tp>& __z) { return __complex_sinh(__z.__rep()); } +#else + template + inline complex<_Tp> + sinh(const complex<_Tp>& __z) { return __complex_sinh(__z); } +#endif + + // 26.2.8/13 sqrt(__z): Returns the complex square root of __z. + // The branch cut is on the negative axis. + template + complex<_Tp> + __complex_sqrt(const complex<_Tp>& __z) + { + _Tp __x = __z.real(); + _Tp __y = __z.imag(); + + if (__x == _Tp()) + { + _Tp __t = sqrt(abs(__y) / 2); + return complex<_Tp>(__t, __y < _Tp() ? -__t : __t); + } + else + { + _Tp __t = sqrt(2 * (std::abs(__z) + abs(__x))); + _Tp __u = __t / 2; + return __x > _Tp() + ? complex<_Tp>(__u, __y / __t) + : complex<_Tp>(abs(__y) / __t, __y < _Tp() ? -__u : __u); + } + } + +#if _GLIBCXX_USE_C99_COMPLEX + inline __complex__ float + __complex_sqrt(__complex__ float __z) { return __builtin_csqrtf(__z); } + + inline __complex__ double + __complex_sqrt(__complex__ double __z) { return __builtin_csqrt(__z); } + + inline __complex__ long double + __complex_sqrt(const __complex__ long double& __z) + { return __builtin_csqrtl(__z); } + + template + inline complex<_Tp> + sqrt(const complex<_Tp>& __z) { return __complex_sqrt(__z.__rep()); } +#else + template + inline complex<_Tp> + sqrt(const complex<_Tp>& __z) { return __complex_sqrt(__z); } +#endif + + // 26.2.8/14 tan(__z): Return the complex tangent of __z. + + template + inline complex<_Tp> + __complex_tan(const complex<_Tp>& __z) + { return std::sin(__z) / std::cos(__z); } + +#if _GLIBCXX_USE_C99_COMPLEX + inline __complex__ float + __complex_tan(__complex__ float __z) { return __builtin_ctanf(__z); } + + inline __complex__ double + __complex_tan(__complex__ double __z) { return __builtin_ctan(__z); } + + inline __complex__ long double + __complex_tan(const __complex__ long double& __z) + { return __builtin_ctanl(__z); } + + template + inline complex<_Tp> + tan(const complex<_Tp>& __z) { return __complex_tan(__z.__rep()); } +#else + template + inline complex<_Tp> + tan(const complex<_Tp>& __z) { return __complex_tan(__z); } +#endif + + + // 26.2.8/15 tanh(__z): Returns the hyperbolic tangent of __z. + + template + inline complex<_Tp> + __complex_tanh(const complex<_Tp>& __z) + { return std::sinh(__z) / std::cosh(__z); } + +#if _GLIBCXX_USE_C99_COMPLEX + inline __complex__ float + __complex_tanh(__complex__ float __z) { return __builtin_ctanhf(__z); } + + inline __complex__ double + __complex_tanh(__complex__ double __z) { return __builtin_ctanh(__z); } + + inline __complex__ long double + __complex_tanh(const __complex__ long double& __z) + { return __builtin_ctanhl(__z); } + + template + inline complex<_Tp> + tanh(const complex<_Tp>& __z) { return __complex_tanh(__z.__rep()); } +#else + template + inline complex<_Tp> + tanh(const complex<_Tp>& __z) { return __complex_tanh(__z); } +#endif + + + // 26.2.8/9 pow(__x, __y): Returns the complex power base of __x + // raised to the __y-th power. The branch + // cut is on the negative axis. + template + complex<_Tp> + __complex_pow_unsigned(complex<_Tp> __x, unsigned __n) + { + complex<_Tp> __y = __n % 2 ? __x : complex<_Tp>(1); + + while (__n >>= 1) + { + __x *= __x; + if (__n % 2) + __y *= __x; + } + + return __y; + } + + // In C++11 mode we used to implement the resolution of + // DR 844. complex pow return type is ambiguous. + // thus the following overload was disabled in that mode. However, doing + // that causes all sorts of issues, see, for example: + // http://gcc.gnu.org/ml/libstdc++/2013-01/msg00058.html + // and also PR57974. + template + inline complex<_Tp> + pow(const complex<_Tp>& __z, int __n) + { + return __n < 0 + ? complex<_Tp>(1) / std::__complex_pow_unsigned(__z, -(unsigned)__n) + : std::__complex_pow_unsigned(__z, __n); + } + + template + complex<_Tp> + pow(const complex<_Tp>& __x, const _Tp& __y) + { +#ifndef _GLIBCXX_USE_C99_COMPLEX + if (__x == _Tp()) + return _Tp(); +#endif + if (__x.imag() == _Tp() && __x.real() > _Tp()) + return pow(__x.real(), __y); + + complex<_Tp> __t = std::log(__x); + return std::polar(exp(__y * __t.real()), __y * __t.imag()); + } + + template + inline complex<_Tp> + __complex_pow(const complex<_Tp>& __x, const complex<_Tp>& __y) + { return __x == _Tp() ? _Tp() : std::exp(__y * std::log(__x)); } + +#if _GLIBCXX_USE_C99_COMPLEX + inline __complex__ float + __complex_pow(__complex__ float __x, __complex__ float __y) + { return __builtin_cpowf(__x, __y); } + + inline __complex__ double + __complex_pow(__complex__ double __x, __complex__ double __y) + { return __builtin_cpow(__x, __y); } + + inline __complex__ long double + __complex_pow(const __complex__ long double& __x, + const __complex__ long double& __y) + { return __builtin_cpowl(__x, __y); } + + template + inline complex<_Tp> + pow(const complex<_Tp>& __x, const complex<_Tp>& __y) + { return __complex_pow(__x.__rep(), __y.__rep()); } +#else + template + inline complex<_Tp> + pow(const complex<_Tp>& __x, const complex<_Tp>& __y) + { return __complex_pow(__x, __y); } +#endif + + template + inline complex<_Tp> + pow(const _Tp& __x, const complex<_Tp>& __y) + { + return __x > _Tp() ? std::polar(pow(__x, __y.real()), + __y.imag() * log(__x)) + : std::pow(complex<_Tp>(__x), __y); + } + + /// 26.2.3 complex specializations + /// complex specialization + template<> + struct complex + { + typedef float value_type; + typedef __complex__ float _ComplexT; + + _GLIBCXX_CONSTEXPR complex(_ComplexT __z) : _M_value(__z) { } + + _GLIBCXX_CONSTEXPR complex(float __r = 0.0f, float __i = 0.0f) +#if __cplusplus >= 201103L + : _M_value{ __r, __i } { } +#else + { + __real__ _M_value = __r; + __imag__ _M_value = __i; + } +#endif + + explicit _GLIBCXX_CONSTEXPR complex(const complex&); + explicit _GLIBCXX_CONSTEXPR complex(const complex&); + +#if __cplusplus >= 201103L + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR 387. std::complex over-encapsulated. + __attribute ((__abi_tag__ ("cxx11"))) + constexpr float + real() const { return __real__ _M_value; } + + __attribute ((__abi_tag__ ("cxx11"))) + constexpr float + imag() const { return __imag__ _M_value; } +#else + float& + real() { return __real__ _M_value; } + + const float& + real() const { return __real__ _M_value; } + + float& + imag() { return __imag__ _M_value; } + + const float& + imag() const { return __imag__ _M_value; } +#endif + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR 387. std::complex over-encapsulated. + void + real(float __val) { __real__ _M_value = __val; } + + void + imag(float __val) { __imag__ _M_value = __val; } + + complex& + operator=(float __f) + { + _M_value = __f; + return *this; + } + + complex& + operator+=(float __f) + { + _M_value += __f; + return *this; + } + + complex& + operator-=(float __f) + { + _M_value -= __f; + return *this; + } + + complex& + operator*=(float __f) + { + _M_value *= __f; + return *this; + } + + complex& + operator/=(float __f) + { + _M_value /= __f; + return *this; + } + + // Let the compiler synthesize the copy and assignment + // operator. It always does a pretty good job. + // complex& operator=(const complex&); + + template + complex& + operator=(const complex<_Tp>& __z) + { + __real__ _M_value = __z.real(); + __imag__ _M_value = __z.imag(); + return *this; + } + + template + complex& + operator+=(const complex<_Tp>& __z) + { + __real__ _M_value += __z.real(); + __imag__ _M_value += __z.imag(); + return *this; + } + + template + complex& + operator-=(const complex<_Tp>& __z) + { + __real__ _M_value -= __z.real(); + __imag__ _M_value -= __z.imag(); + return *this; + } + + template + complex& + operator*=(const complex<_Tp>& __z) + { + _ComplexT __t; + __real__ __t = __z.real(); + __imag__ __t = __z.imag(); + _M_value *= __t; + return *this; + } + + template + complex& + operator/=(const complex<_Tp>& __z) + { + _ComplexT __t; + __real__ __t = __z.real(); + __imag__ __t = __z.imag(); + _M_value /= __t; + return *this; + } + + _GLIBCXX_USE_CONSTEXPR _ComplexT __rep() const { return _M_value; } + + private: + _ComplexT _M_value; + }; + + /// 26.2.3 complex specializations + /// complex specialization + template<> + struct complex + { + typedef double value_type; + typedef __complex__ double _ComplexT; + + _GLIBCXX_CONSTEXPR complex(_ComplexT __z) : _M_value(__z) { } + + _GLIBCXX_CONSTEXPR complex(double __r = 0.0, double __i = 0.0) +#if __cplusplus >= 201103L + : _M_value{ __r, __i } { } +#else + { + __real__ _M_value = __r; + __imag__ _M_value = __i; + } +#endif + + _GLIBCXX_CONSTEXPR complex(const complex& __z) + : _M_value(__z.__rep()) { } + + explicit _GLIBCXX_CONSTEXPR complex(const complex&); + +#if __cplusplus >= 201103L + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR 387. std::complex over-encapsulated. + __attribute ((__abi_tag__ ("cxx11"))) + constexpr double + real() const { return __real__ _M_value; } + + __attribute ((__abi_tag__ ("cxx11"))) + constexpr double + imag() const { return __imag__ _M_value; } +#else + double& + real() { return __real__ _M_value; } + + const double& + real() const { return __real__ _M_value; } + + double& + imag() { return __imag__ _M_value; } + + const double& + imag() const { return __imag__ _M_value; } +#endif + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR 387. std::complex over-encapsulated. + void + real(double __val) { __real__ _M_value = __val; } + + void + imag(double __val) { __imag__ _M_value = __val; } + + complex& + operator=(double __d) + { + _M_value = __d; + return *this; + } + + complex& + operator+=(double __d) + { + _M_value += __d; + return *this; + } + + complex& + operator-=(double __d) + { + _M_value -= __d; + return *this; + } + + complex& + operator*=(double __d) + { + _M_value *= __d; + return *this; + } + + complex& + operator/=(double __d) + { + _M_value /= __d; + return *this; + } + + // The compiler will synthesize this, efficiently. + // complex& operator=(const complex&); + + template + complex& + operator=(const complex<_Tp>& __z) + { + __real__ _M_value = __z.real(); + __imag__ _M_value = __z.imag(); + return *this; + } + + template + complex& + operator+=(const complex<_Tp>& __z) + { + __real__ _M_value += __z.real(); + __imag__ _M_value += __z.imag(); + return *this; + } + + template + complex& + operator-=(const complex<_Tp>& __z) + { + __real__ _M_value -= __z.real(); + __imag__ _M_value -= __z.imag(); + return *this; + } + + template + complex& + operator*=(const complex<_Tp>& __z) + { + _ComplexT __t; + __real__ __t = __z.real(); + __imag__ __t = __z.imag(); + _M_value *= __t; + return *this; + } + + template + complex& + operator/=(const complex<_Tp>& __z) + { + _ComplexT __t; + __real__ __t = __z.real(); + __imag__ __t = __z.imag(); + _M_value /= __t; + return *this; + } + + _GLIBCXX_USE_CONSTEXPR _ComplexT __rep() const { return _M_value; } + + private: + _ComplexT _M_value; + }; + + /// 26.2.3 complex specializations + /// complex specialization + template<> + struct complex + { + typedef long double value_type; + typedef __complex__ long double _ComplexT; + + _GLIBCXX_CONSTEXPR complex(_ComplexT __z) : _M_value(__z) { } + + _GLIBCXX_CONSTEXPR complex(long double __r = 0.0L, + long double __i = 0.0L) +#if __cplusplus >= 201103L + : _M_value{ __r, __i } { } +#else + { + __real__ _M_value = __r; + __imag__ _M_value = __i; + } +#endif + + _GLIBCXX_CONSTEXPR complex(const complex& __z) + : _M_value(__z.__rep()) { } + + _GLIBCXX_CONSTEXPR complex(const complex& __z) + : _M_value(__z.__rep()) { } + +#if __cplusplus >= 201103L + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR 387. std::complex over-encapsulated. + __attribute ((__abi_tag__ ("cxx11"))) + constexpr long double + real() const { return __real__ _M_value; } + + __attribute ((__abi_tag__ ("cxx11"))) + constexpr long double + imag() const { return __imag__ _M_value; } +#else + long double& + real() { return __real__ _M_value; } + + const long double& + real() const { return __real__ _M_value; } + + long double& + imag() { return __imag__ _M_value; } + + const long double& + imag() const { return __imag__ _M_value; } +#endif + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR 387. std::complex over-encapsulated. + void + real(long double __val) { __real__ _M_value = __val; } + + void + imag(long double __val) { __imag__ _M_value = __val; } + + complex& + operator=(long double __r) + { + _M_value = __r; + return *this; + } + + complex& + operator+=(long double __r) + { + _M_value += __r; + return *this; + } + + complex& + operator-=(long double __r) + { + _M_value -= __r; + return *this; + } + + complex& + operator*=(long double __r) + { + _M_value *= __r; + return *this; + } + + complex& + operator/=(long double __r) + { + _M_value /= __r; + return *this; + } + + // The compiler knows how to do this efficiently + // complex& operator=(const complex&); + + template + complex& + operator=(const complex<_Tp>& __z) + { + __real__ _M_value = __z.real(); + __imag__ _M_value = __z.imag(); + return *this; + } + + template + complex& + operator+=(const complex<_Tp>& __z) + { + __real__ _M_value += __z.real(); + __imag__ _M_value += __z.imag(); + return *this; + } + + template + complex& + operator-=(const complex<_Tp>& __z) + { + __real__ _M_value -= __z.real(); + __imag__ _M_value -= __z.imag(); + return *this; + } + + template + complex& + operator*=(const complex<_Tp>& __z) + { + _ComplexT __t; + __real__ __t = __z.real(); + __imag__ __t = __z.imag(); + _M_value *= __t; + return *this; + } + + template + complex& + operator/=(const complex<_Tp>& __z) + { + _ComplexT __t; + __real__ __t = __z.real(); + __imag__ __t = __z.imag(); + _M_value /= __t; + return *this; + } + + _GLIBCXX_USE_CONSTEXPR _ComplexT __rep() const { return _M_value; } + + private: + _ComplexT _M_value; + }; + + // These bits have to be at the end of this file, so that the + // specializations have all been defined. + inline _GLIBCXX_CONSTEXPR + complex::complex(const complex& __z) + : _M_value(__z.__rep()) { } + + inline _GLIBCXX_CONSTEXPR + complex::complex(const complex& __z) + : _M_value(__z.__rep()) { } + + inline _GLIBCXX_CONSTEXPR + complex::complex(const complex& __z) + : _M_value(__z.__rep()) { } + + // Inhibit implicit instantiations for required instantiations, + // which are defined via explicit instantiations elsewhere. + // NB: This syntax is a GNU extension. +#if _GLIBCXX_EXTERN_TEMPLATE + extern template istream& operator>>(istream&, complex&); + extern template ostream& operator<<(ostream&, const complex&); + extern template istream& operator>>(istream&, complex&); + extern template ostream& operator<<(ostream&, const complex&); + extern template istream& operator>>(istream&, complex&); + extern template ostream& operator<<(ostream&, const complex&); + +#ifdef _GLIBCXX_USE_WCHAR_T + extern template wistream& operator>>(wistream&, complex&); + extern template wostream& operator<<(wostream&, const complex&); + extern template wistream& operator>>(wistream&, complex&); + extern template wostream& operator<<(wostream&, const complex&); + extern template wistream& operator>>(wistream&, complex&); + extern template wostream& operator<<(wostream&, const complex&); +#endif +#endif + + // @} group complex_numbers + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +namespace __gnu_cxx _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + // See ext/type_traits.h for the primary template. + template + struct __promote_2, _Up> + { + public: + typedef std::complex::__type> __type; + }; + + template + struct __promote_2<_Tp, std::complex<_Up> > + { + public: + typedef std::complex::__type> __type; + }; + + template + struct __promote_2, std::complex<_Up> > + { + public: + typedef std::complex::__type> __type; + }; + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#if __cplusplus >= 201103L + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + // Forward declarations. + template std::complex<_Tp> acos(const std::complex<_Tp>&); + template std::complex<_Tp> asin(const std::complex<_Tp>&); + template std::complex<_Tp> atan(const std::complex<_Tp>&); + + template std::complex<_Tp> acosh(const std::complex<_Tp>&); + template std::complex<_Tp> asinh(const std::complex<_Tp>&); + template std::complex<_Tp> atanh(const std::complex<_Tp>&); + // DR 595. + template _Tp fabs(const std::complex<_Tp>&); + + template + inline std::complex<_Tp> + __complex_acos(const std::complex<_Tp>& __z) + { + const std::complex<_Tp> __t = std::asin(__z); + const _Tp __pi_2 = 1.5707963267948966192313216916397514L; + return std::complex<_Tp>(__pi_2 - __t.real(), -__t.imag()); + } + +#if _GLIBCXX_USE_C99_COMPLEX_TR1 + inline __complex__ float + __complex_acos(__complex__ float __z) + { return __builtin_cacosf(__z); } + + inline __complex__ double + __complex_acos(__complex__ double __z) + { return __builtin_cacos(__z); } + + inline __complex__ long double + __complex_acos(const __complex__ long double& __z) + { return __builtin_cacosl(__z); } + + template + inline std::complex<_Tp> + acos(const std::complex<_Tp>& __z) + { return __complex_acos(__z.__rep()); } +#else + /// acos(__z) [8.1.2]. + // Effects: Behaves the same as C99 function cacos, defined + // in subclause 7.3.5.1. + template + inline std::complex<_Tp> + acos(const std::complex<_Tp>& __z) + { return __complex_acos(__z); } +#endif + + template + inline std::complex<_Tp> + __complex_asin(const std::complex<_Tp>& __z) + { + std::complex<_Tp> __t(-__z.imag(), __z.real()); + __t = std::asinh(__t); + return std::complex<_Tp>(__t.imag(), -__t.real()); + } + +#if _GLIBCXX_USE_C99_COMPLEX_TR1 + inline __complex__ float + __complex_asin(__complex__ float __z) + { return __builtin_casinf(__z); } + + inline __complex__ double + __complex_asin(__complex__ double __z) + { return __builtin_casin(__z); } + + inline __complex__ long double + __complex_asin(const __complex__ long double& __z) + { return __builtin_casinl(__z); } + + template + inline std::complex<_Tp> + asin(const std::complex<_Tp>& __z) + { return __complex_asin(__z.__rep()); } +#else + /// asin(__z) [8.1.3]. + // Effects: Behaves the same as C99 function casin, defined + // in subclause 7.3.5.2. + template + inline std::complex<_Tp> + asin(const std::complex<_Tp>& __z) + { return __complex_asin(__z); } +#endif + + template + std::complex<_Tp> + __complex_atan(const std::complex<_Tp>& __z) + { + const _Tp __r2 = __z.real() * __z.real(); + const _Tp __x = _Tp(1.0) - __r2 - __z.imag() * __z.imag(); + + _Tp __num = __z.imag() + _Tp(1.0); + _Tp __den = __z.imag() - _Tp(1.0); + + __num = __r2 + __num * __num; + __den = __r2 + __den * __den; + + return std::complex<_Tp>(_Tp(0.5) * atan2(_Tp(2.0) * __z.real(), __x), + _Tp(0.25) * log(__num / __den)); + } + +#if _GLIBCXX_USE_C99_COMPLEX_TR1 + inline __complex__ float + __complex_atan(__complex__ float __z) + { return __builtin_catanf(__z); } + + inline __complex__ double + __complex_atan(__complex__ double __z) + { return __builtin_catan(__z); } + + inline __complex__ long double + __complex_atan(const __complex__ long double& __z) + { return __builtin_catanl(__z); } + + template + inline std::complex<_Tp> + atan(const std::complex<_Tp>& __z) + { return __complex_atan(__z.__rep()); } +#else + /// atan(__z) [8.1.4]. + // Effects: Behaves the same as C99 function catan, defined + // in subclause 7.3.5.3. + template + inline std::complex<_Tp> + atan(const std::complex<_Tp>& __z) + { return __complex_atan(__z); } +#endif + + template + std::complex<_Tp> + __complex_acosh(const std::complex<_Tp>& __z) + { + // Kahan's formula. + return _Tp(2.0) * std::log(std::sqrt(_Tp(0.5) * (__z + _Tp(1.0))) + + std::sqrt(_Tp(0.5) * (__z - _Tp(1.0)))); + } + +#if _GLIBCXX_USE_C99_COMPLEX_TR1 + inline __complex__ float + __complex_acosh(__complex__ float __z) + { return __builtin_cacoshf(__z); } + + inline __complex__ double + __complex_acosh(__complex__ double __z) + { return __builtin_cacosh(__z); } + + inline __complex__ long double + __complex_acosh(const __complex__ long double& __z) + { return __builtin_cacoshl(__z); } + + template + inline std::complex<_Tp> + acosh(const std::complex<_Tp>& __z) + { return __complex_acosh(__z.__rep()); } +#else + /// acosh(__z) [8.1.5]. + // Effects: Behaves the same as C99 function cacosh, defined + // in subclause 7.3.6.1. + template + inline std::complex<_Tp> + acosh(const std::complex<_Tp>& __z) + { return __complex_acosh(__z); } +#endif + + template + std::complex<_Tp> + __complex_asinh(const std::complex<_Tp>& __z) + { + std::complex<_Tp> __t((__z.real() - __z.imag()) + * (__z.real() + __z.imag()) + _Tp(1.0), + _Tp(2.0) * __z.real() * __z.imag()); + __t = std::sqrt(__t); + + return std::log(__t + __z); + } + +#if _GLIBCXX_USE_C99_COMPLEX_TR1 + inline __complex__ float + __complex_asinh(__complex__ float __z) + { return __builtin_casinhf(__z); } + + inline __complex__ double + __complex_asinh(__complex__ double __z) + { return __builtin_casinh(__z); } + + inline __complex__ long double + __complex_asinh(const __complex__ long double& __z) + { return __builtin_casinhl(__z); } + + template + inline std::complex<_Tp> + asinh(const std::complex<_Tp>& __z) + { return __complex_asinh(__z.__rep()); } +#else + /// asinh(__z) [8.1.6]. + // Effects: Behaves the same as C99 function casin, defined + // in subclause 7.3.6.2. + template + inline std::complex<_Tp> + asinh(const std::complex<_Tp>& __z) + { return __complex_asinh(__z); } +#endif + + template + std::complex<_Tp> + __complex_atanh(const std::complex<_Tp>& __z) + { + const _Tp __i2 = __z.imag() * __z.imag(); + const _Tp __x = _Tp(1.0) - __i2 - __z.real() * __z.real(); + + _Tp __num = _Tp(1.0) + __z.real(); + _Tp __den = _Tp(1.0) - __z.real(); + + __num = __i2 + __num * __num; + __den = __i2 + __den * __den; + + return std::complex<_Tp>(_Tp(0.25) * (log(__num) - log(__den)), + _Tp(0.5) * atan2(_Tp(2.0) * __z.imag(), __x)); + } + +#if _GLIBCXX_USE_C99_COMPLEX_TR1 + inline __complex__ float + __complex_atanh(__complex__ float __z) + { return __builtin_catanhf(__z); } + + inline __complex__ double + __complex_atanh(__complex__ double __z) + { return __builtin_catanh(__z); } + + inline __complex__ long double + __complex_atanh(const __complex__ long double& __z) + { return __builtin_catanhl(__z); } + + template + inline std::complex<_Tp> + atanh(const std::complex<_Tp>& __z) + { return __complex_atanh(__z.__rep()); } +#else + /// atanh(__z) [8.1.7]. + // Effects: Behaves the same as C99 function catanh, defined + // in subclause 7.3.6.3. + template + inline std::complex<_Tp> + atanh(const std::complex<_Tp>& __z) + { return __complex_atanh(__z); } +#endif + + template + inline _Tp + /// fabs(__z) [8.1.8]. + // Effects: Behaves the same as C99 function cabs, defined + // in subclause 7.3.8.1. + fabs(const std::complex<_Tp>& __z) + { return std::abs(__z); } + + /// Additional overloads [8.1.9]. + template + inline typename __gnu_cxx::__promote<_Tp>::__type + arg(_Tp __x) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; +#if (_GLIBCXX_USE_C99_MATH && !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC) + return std::signbit(__x) ? __type(3.1415926535897932384626433832795029L) + : __type(); +#else + return std::arg(std::complex<__type>(__x)); +#endif + } + + template + inline typename __gnu_cxx::__promote<_Tp>::__type + imag(_Tp) + { return _Tp(); } + + template + inline typename __gnu_cxx::__promote<_Tp>::__type + norm(_Tp __x) + { + typedef typename __gnu_cxx::__promote<_Tp>::__type __type; + return __type(__x) * __type(__x); + } + + template + inline typename __gnu_cxx::__promote<_Tp>::__type + real(_Tp __x) + { return __x; } + + template + inline std::complex::__type> + pow(const std::complex<_Tp>& __x, const _Up& __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return std::pow(std::complex<__type>(__x), __type(__y)); + } + + template + inline std::complex::__type> + pow(const _Tp& __x, const std::complex<_Up>& __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return std::pow(__type(__x), std::complex<__type>(__y)); + } + + template + inline std::complex::__type> + pow(const std::complex<_Tp>& __x, const std::complex<_Up>& __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return std::pow(std::complex<__type>(__x), + std::complex<__type>(__y)); + } + + // Forward declarations. + // DR 781. + template std::complex<_Tp> proj(const std::complex<_Tp>&); + + template + std::complex<_Tp> + __complex_proj(const std::complex<_Tp>& __z) + { + const _Tp __den = (__z.real() * __z.real() + + __z.imag() * __z.imag() + _Tp(1.0)); + + return std::complex<_Tp>((_Tp(2.0) * __z.real()) / __den, + (_Tp(2.0) * __z.imag()) / __den); + } + +#if _GLIBCXX_USE_C99_COMPLEX + inline __complex__ float + __complex_proj(__complex__ float __z) + { return __builtin_cprojf(__z); } + + inline __complex__ double + __complex_proj(__complex__ double __z) + { return __builtin_cproj(__z); } + + inline __complex__ long double + __complex_proj(const __complex__ long double& __z) + { return __builtin_cprojl(__z); } + + template + inline std::complex<_Tp> + proj(const std::complex<_Tp>& __z) + { return __complex_proj(__z.__rep()); } +#else + template + inline std::complex<_Tp> + proj(const std::complex<_Tp>& __z) + { return __complex_proj(__z); } +#endif + + // DR 1137. + template + inline typename __gnu_cxx::__promote<_Tp>::__type + proj(_Tp __x) + { return __x; } + + template + inline typename __gnu_cxx::__promote<_Tp>::__type + conj(_Tp __x) + { return __x; } + +#if __cplusplus > 201103L + +inline namespace literals { +inline namespace complex_literals { + +#define __cpp_lib_complex_udls 201309 + + constexpr std::complex + operator""if(long double __num) + { return std::complex{0.0F, static_cast(__num)}; } + + constexpr std::complex + operator""if(unsigned long long __num) + { return std::complex{0.0F, static_cast(__num)}; } + + constexpr std::complex + operator""i(long double __num) + { return std::complex{0.0, static_cast(__num)}; } + + constexpr std::complex + operator""i(unsigned long long __num) + { return std::complex{0.0, static_cast(__num)}; } + + constexpr std::complex + operator""il(long double __num) + { return std::complex{0.0L, __num}; } + + constexpr std::complex + operator""il(unsigned long long __num) + { return std::complex{0.0L, static_cast(__num)}; } + +} // inline namespace complex_literals +} // inline namespace literals + +#endif // C++14 + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif // C++11 + +#endif /* _GLIBCXX_COMPLEX */ diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/complex.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/complex.h new file mode 100755 index 0000000..d072b68 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/complex.h @@ -0,0 +1,46 @@ +// -*- C++ -*- compatibility header. + +// Copyright (C) 2007-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file complex.h + * This is a Standard C++ Library header. + */ + +#include + +#if __cplusplus >= 201103L +# include +#endif + +#if _GLIBCXX_HAVE_COMPLEX_H +# include_next +# ifdef _GLIBCXX_COMPLEX +// See PR56111, keep the macro in C++03 if possible. +# undef complex +# endif +#endif + +#ifndef _GLIBCXX_COMPLEX_H +#define _GLIBCXX_COMPLEX_H 1 + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/condition_variable b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/condition_variable new file mode 100755 index 0000000..921cb83 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/condition_variable @@ -0,0 +1,303 @@ +// -*- C++ -*- + +// Copyright (C) 2008-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file include/condition_variable + * This is a Standard C++ Library header. + */ + +#ifndef _GLIBCXX_CONDITION_VARIABLE +#define _GLIBCXX_CONDITION_VARIABLE 1 + +#pragma GCC system_header + +#if __cplusplus < 201103L +# include +#else + +#include +#include +#include +#include +#include +#include +#include + +#if defined(_GLIBCXX_HAS_GTHREADS) && defined(_GLIBCXX_USE_C99_STDINT_TR1) + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /** + * @defgroup condition_variables Condition Variables + * @ingroup concurrency + * + * Classes for condition_variable support. + * @{ + */ + + /// cv_status + enum class cv_status { no_timeout, timeout }; + + /// condition_variable + class condition_variable + { + typedef chrono::system_clock __clock_t; + typedef __gthread_cond_t __native_type; + +#ifdef __GTHREAD_COND_INIT + __native_type _M_cond = __GTHREAD_COND_INIT; +#else + __native_type _M_cond; +#endif + + public: + typedef __native_type* native_handle_type; + + condition_variable() noexcept; + ~condition_variable() noexcept; + + condition_variable(const condition_variable&) = delete; + condition_variable& operator=(const condition_variable&) = delete; + + void + notify_one() noexcept; + + void + notify_all() noexcept; + + void + wait(unique_lock& __lock); + + template + void + wait(unique_lock& __lock, _Predicate __p) + { + while (!__p()) + wait(__lock); + } + + template + cv_status + wait_until(unique_lock& __lock, + const chrono::time_point<__clock_t, _Duration>& __atime) + { return __wait_until_impl(__lock, __atime); } + + template + cv_status + wait_until(unique_lock& __lock, + const chrono::time_point<_Clock, _Duration>& __atime) + { + // DR 887 - Sync unknown clock to known clock. + const typename _Clock::time_point __c_entry = _Clock::now(); + const __clock_t::time_point __s_entry = __clock_t::now(); + const auto __delta = __atime - __c_entry; + const auto __s_atime = __s_entry + __delta; + + return __wait_until_impl(__lock, __s_atime); + } + + template + bool + wait_until(unique_lock& __lock, + const chrono::time_point<_Clock, _Duration>& __atime, + _Predicate __p) + { + while (!__p()) + if (wait_until(__lock, __atime) == cv_status::timeout) + return __p(); + return true; + } + + template + cv_status + wait_for(unique_lock& __lock, + const chrono::duration<_Rep, _Period>& __rtime) + { return wait_until(__lock, __clock_t::now() + __rtime); } + + template + bool + wait_for(unique_lock& __lock, + const chrono::duration<_Rep, _Period>& __rtime, + _Predicate __p) + { return wait_until(__lock, __clock_t::now() + __rtime, std::move(__p)); } + + native_handle_type + native_handle() + { return &_M_cond; } + + private: + template + cv_status + __wait_until_impl(unique_lock& __lock, + const chrono::time_point<__clock_t, _Dur>& __atime) + { + auto __s = chrono::time_point_cast(__atime); + auto __ns = chrono::duration_cast(__atime - __s); + + __gthread_time_t __ts = + { + static_cast(__s.time_since_epoch().count()), + static_cast(__ns.count()) + }; + + __gthread_cond_timedwait(&_M_cond, __lock.mutex()->native_handle(), + &__ts); + + return (__clock_t::now() < __atime + ? cv_status::no_timeout : cv_status::timeout); + } + }; + + inline namespace _V2 { + + /// condition_variable_any + // Like above, but mutex is not required to have try_lock. + class condition_variable_any + { + typedef chrono::system_clock __clock_t; + condition_variable _M_cond; + shared_ptr _M_mutex; + + // scoped unlock - unlocks in ctor, re-locks in dtor + template + struct _Unlock + { + explicit _Unlock(_Lock& __lk) : _M_lock(__lk) { __lk.unlock(); } + + ~_Unlock() noexcept(false) + { + if (uncaught_exception()) + { + __try + { _M_lock.lock(); } + __catch(const __cxxabiv1::__forced_unwind&) + { __throw_exception_again; } + __catch(...) + { } + } + else + _M_lock.lock(); + } + + _Unlock(const _Unlock&) = delete; + _Unlock& operator=(const _Unlock&) = delete; + + _Lock& _M_lock; + }; + + public: + condition_variable_any() : _M_mutex(std::make_shared()) { } + ~condition_variable_any() = default; + + condition_variable_any(const condition_variable_any&) = delete; + condition_variable_any& operator=(const condition_variable_any&) = delete; + + void + notify_one() noexcept + { + lock_guard __lock(*_M_mutex); + _M_cond.notify_one(); + } + + void + notify_all() noexcept + { + lock_guard __lock(*_M_mutex); + _M_cond.notify_all(); + } + + template + void + wait(_Lock& __lock) + { + shared_ptr __mutex = _M_mutex; + unique_lock __my_lock(*__mutex); + _Unlock<_Lock> __unlock(__lock); + // *__mutex must be unlocked before re-locking __lock so move + // ownership of *__mutex lock to an object with shorter lifetime. + unique_lock __my_lock2(std::move(__my_lock)); + _M_cond.wait(__my_lock2); + } + + + template + void + wait(_Lock& __lock, _Predicate __p) + { + while (!__p()) + wait(__lock); + } + + template + cv_status + wait_until(_Lock& __lock, + const chrono::time_point<_Clock, _Duration>& __atime) + { + shared_ptr __mutex = _M_mutex; + unique_lock __my_lock(*__mutex); + _Unlock<_Lock> __unlock(__lock); + // *__mutex must be unlocked before re-locking __lock so move + // ownership of *__mutex lock to an object with shorter lifetime. + unique_lock __my_lock2(std::move(__my_lock)); + return _M_cond.wait_until(__my_lock2, __atime); + } + + template + bool + wait_until(_Lock& __lock, + const chrono::time_point<_Clock, _Duration>& __atime, + _Predicate __p) + { + while (!__p()) + if (wait_until(__lock, __atime) == cv_status::timeout) + return __p(); + return true; + } + + template + cv_status + wait_for(_Lock& __lock, const chrono::duration<_Rep, _Period>& __rtime) + { return wait_until(__lock, __clock_t::now() + __rtime); } + + template + bool + wait_for(_Lock& __lock, + const chrono::duration<_Rep, _Period>& __rtime, _Predicate __p) + { return wait_until(__lock, __clock_t::now() + __rtime, std::move(__p)); } + }; + + } // end inline namespace + + // @} group condition_variables +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif // _GLIBCXX_HAS_GTHREADS && _GLIBCXX_USE_C99_STDINT_TR1 + +#endif // C++11 + +#endif // _GLIBCXX_CONDITION_VARIABLE diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/csetjmp b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/csetjmp new file mode 100755 index 0000000..f36d068 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/csetjmp @@ -0,0 +1,61 @@ +// -*- C++ -*- forwarding header. + +// Copyright (C) 1997-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file csetjmp + * This is a Standard C++ Library file. You should @c \#include this file + * in your programs, rather than any of the @a *.h implementation files. + * + * This is the C++ version of the Standard C Library header @c setjmp.h, + * and its contents are (mostly) the same as that header, but are all + * contained in the namespace @c std (except for names which are defined + * as macros in C). + */ + +// +// ISO C++ 14882: 20.4.6 C library +// + +#pragma GCC system_header + +#include +#include + +#ifndef _GLIBCXX_CSETJMP +#define _GLIBCXX_CSETJMP 1 + +// Get rid of those macros defined in in lieu of real functions. +#undef longjmp + +// Adhere to section 17.4.1.2 clause 5 of ISO 14882:1998 +#ifndef setjmp +#define setjmp(env) setjmp (env) +#endif + +namespace std +{ + using ::jmp_buf; + using ::longjmp; +} // namespace std + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/csignal b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/csignal new file mode 100755 index 0000000..f05a210 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/csignal @@ -0,0 +1,57 @@ +// -*- C++ -*- forwarding header. + +// Copyright (C) 1997-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file csignal + * This is a Standard C++ Library file. You should @c \#include this file + * in your programs, rather than any of the @a *.h implementation files. + * + * This is the C++ version of the Standard C Library header @c signal.h, + * and its contents are (mostly) the same as that header, but are all + * contained in the namespace @c std (except for names which are defined + * as macros in C). + */ + +// +// ISO C++ 14882: 20.4.6 C library +// + +#pragma GCC system_header + +#include +#include + +#ifndef _GLIBCXX_CSIGNAL +#define _GLIBCXX_CSIGNAL 1 + +// Get rid of those macros defined in in lieu of real functions. +#undef raise + +namespace std +{ + using ::sig_atomic_t; + using ::signal; + using ::raise; +} // namespace std + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/cstdalign b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/cstdalign new file mode 100755 index 0000000..d2fff63 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/cstdalign @@ -0,0 +1,44 @@ +// -*- C++ -*- + +// Copyright (C) 2011-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file include/cstdalign + * This is a Standard C++ Library header. + */ + +#pragma GCC system_header + +#ifndef _GLIBCXX_CSTDALIGN +#define _GLIBCXX_CSTDALIGN 1 + +#if __cplusplus < 201103L +# include +#else +# include +# if _GLIBCXX_HAVE_STDALIGN_H +# include +# endif +#endif + +#endif + diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/cstdarg b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/cstdarg new file mode 100755 index 0000000..d2c69b3 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/cstdarg @@ -0,0 +1,57 @@ +// -*- C++ -*- forwarding header. + +// Copyright (C) 1997-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file include/cstdarg + * This is a Standard C++ Library file. You should @c \#include this file + * in your programs, rather than any of the @a *.h implementation files. + * + * This is the C++ version of the Standard C Library header @c stdarg.h, + * and its contents are (mostly) the same as that header, but are all + * contained in the namespace @c std (except for names which are defined + * as macros in C). + */ + +// +// ISO C++ 14882: 20.4.6 C library +// + +#pragma GCC system_header + +#include +#include + +#ifndef _GLIBCXX_CSTDARG +#define _GLIBCXX_CSTDARG 1 + +// Adhere to section 17.4.1.2 clause 5 of ISO 14882:1998 +#ifndef va_end +#define va_end(ap) va_end (ap) +#endif + +namespace std +{ + using ::va_list; +} // namespace std + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/cstdbool b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/cstdbool new file mode 100755 index 0000000..1b06435 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/cstdbool @@ -0,0 +1,44 @@ +// -*- C++ -*- + +// Copyright (C) 2007-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file include/cstdbool + * This is a Standard C++ Library header. + */ + +#pragma GCC system_header + +#ifndef _GLIBCXX_CSTDBOOL +#define _GLIBCXX_CSTDBOOL 1 + +#if __cplusplus < 201103L +# include +#else +# include +# if _GLIBCXX_HAVE_STDBOOL_H +# include +# endif +#endif + +#endif + diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/cstddef b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/cstddef new file mode 100755 index 0000000..1a87dd6 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/cstddef @@ -0,0 +1,55 @@ +// -*- C++ -*- forwarding header. + +// Copyright (C) 1997-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file cstddef + * This is a Standard C++ Library file. You should @c \#include this file + * in your programs, rather than any of the @a *.h implementation files. + * + * This is the C++ version of the Standard C Library header @c stddef.h, + * and its contents are (mostly) the same as that header, but are all + * contained in the namespace @c std (except for names which are defined + * as macros in C). + */ + +// +// ISO C++ 14882: 18.1 Types +// + +#ifndef _GLIBCXX_CSTDDEF +#define _GLIBCXX_CSTDDEF 1 + +#pragma GCC system_header + +#include +#include + +#if __cplusplus >= 201103L +namespace std +{ + // We handle size_t, ptrdiff_t, and nullptr_t in c++config.h. + using ::max_align_t; +} +#endif + +#endif // _GLIBCXX_CSTDDEF diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/cstdint b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/cstdint new file mode 100755 index 0000000..7fa0d1b --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/cstdint @@ -0,0 +1,89 @@ +// -*- C++ -*- + +// Copyright (C) 2007-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file include/cstdint + * This is a Standard C++ Library header. + */ + +#ifndef _GLIBCXX_CSTDINT +#define _GLIBCXX_CSTDINT 1 + +#pragma GCC system_header + +#if __cplusplus < 201103L +# include +#else + +#include + +#if _GLIBCXX_HAVE_STDINT_H +# include +#endif + +#ifdef _GLIBCXX_USE_C99_STDINT_TR1 + +namespace std +{ + using ::int8_t; + using ::int16_t; + using ::int32_t; + using ::int64_t; + + using ::int_fast8_t; + using ::int_fast16_t; + using ::int_fast32_t; + using ::int_fast64_t; + + using ::int_least8_t; + using ::int_least16_t; + using ::int_least32_t; + using ::int_least64_t; + + using ::intmax_t; + using ::intptr_t; + + using ::uint8_t; + using ::uint16_t; + using ::uint32_t; + using ::uint64_t; + + using ::uint_fast8_t; + using ::uint_fast16_t; + using ::uint_fast32_t; + using ::uint_fast64_t; + + using ::uint_least8_t; + using ::uint_least16_t; + using ::uint_least32_t; + using ::uint_least64_t; + + using ::uintmax_t; + using ::uintptr_t; +} // namespace std + +#endif // _GLIBCXX_USE_C99_STDINT_TR1 + +#endif // C++11 + +#endif // _GLIBCXX_CSTDINT diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/cstdio b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/cstdio new file mode 100755 index 0000000..6043b3d --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/cstdio @@ -0,0 +1,194 @@ +// -*- C++ -*- forwarding header. + +// Copyright (C) 1997-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file include/cstdio + * This is a Standard C++ Library file. You should @c \#include this file + * in your programs, rather than any of the @a *.h implementation files. + * + * This is the C++ version of the Standard C Library header @c stdio.h, + * and its contents are (mostly) the same as that header, but are all + * contained in the namespace @c std (except for names which are defined + * as macros in C). + */ + +// +// ISO C++ 14882: 27.8.2 C Library files +// + +#pragma GCC system_header + +#include +#include + +#ifndef _GLIBCXX_CSTDIO +#define _GLIBCXX_CSTDIO 1 + +#ifndef _GLIBCXX_HAVE_GETS +extern "C" char* gets (char* __s) __attribute__((deprecated)); +#endif + +// Get rid of those macros defined in in lieu of real functions. +#undef clearerr +#undef fclose +#undef feof +#undef ferror +#undef fflush +#undef fgetc +#undef fgetpos +#undef fgets +#undef fopen +#undef fprintf +#undef fputc +#undef fputs +#undef fread +#undef freopen +#undef fscanf +#undef fseek +#undef fsetpos +#undef ftell +#undef fwrite +#undef getc +#undef getchar +#if __cplusplus <= 201103L +# undef gets +#endif +#undef perror +#undef printf +#undef putc +#undef putchar +#undef puts +#undef remove +#undef rename +#undef rewind +#undef scanf +#undef setbuf +#undef setvbuf +#undef sprintf +#undef sscanf +#undef tmpfile +#undef tmpnam +#undef ungetc +#undef vfprintf +#undef vprintf +#undef vsprintf + +namespace std +{ + using ::FILE; + using ::fpos_t; + + using ::clearerr; + using ::fclose; + using ::feof; + using ::ferror; + using ::fflush; + using ::fgetc; + using ::fgetpos; + using ::fgets; + using ::fopen; + using ::fprintf; + using ::fputc; + using ::fputs; + using ::fread; + using ::freopen; + using ::fscanf; + using ::fseek; + using ::fsetpos; + using ::ftell; + using ::fwrite; + using ::getc; + using ::getchar; +#if __cplusplus <= 201103L + // LWG 2249 + using ::gets; +#endif + using ::perror; + using ::printf; + using ::putc; + using ::putchar; + using ::puts; + using ::remove; + using ::rename; + using ::rewind; + using ::scanf; + using ::setbuf; + using ::setvbuf; + using ::sprintf; + using ::sscanf; + using ::tmpfile; +#if _GLIBCXX_USE_TMPNAM + using ::tmpnam; +#endif + using ::ungetc; + using ::vfprintf; + using ::vprintf; + using ::vsprintf; +} // namespace + +#if _GLIBCXX_USE_C99 + +#undef snprintf +#undef vfscanf +#undef vscanf +#undef vsnprintf +#undef vsscanf + +namespace __gnu_cxx +{ +#if _GLIBCXX_USE_C99_CHECK || _GLIBCXX_USE_C99_DYNAMIC + extern "C" int + (snprintf)(char * __restrict, std::size_t, const char * __restrict, ...) + throw (); + extern "C" int + (vfscanf)(FILE * __restrict, const char * __restrict, __gnuc_va_list); + extern "C" int (vscanf)(const char * __restrict, __gnuc_va_list); + extern "C" int + (vsnprintf)(char * __restrict, std::size_t, const char * __restrict, + __gnuc_va_list) throw (); + extern "C" int + (vsscanf)(const char * __restrict, const char * __restrict, __gnuc_va_list) + throw (); +#endif + +#if !_GLIBCXX_USE_C99_DYNAMIC + using ::snprintf; + using ::vfscanf; + using ::vscanf; + using ::vsnprintf; + using ::vsscanf; +#endif +} // namespace __gnu_cxx + +namespace std +{ + using ::__gnu_cxx::snprintf; + using ::__gnu_cxx::vfscanf; + using ::__gnu_cxx::vscanf; + using ::__gnu_cxx::vsnprintf; + using ::__gnu_cxx::vsscanf; +} // namespace std + +#endif // _GLIBCXX_USE_C99 + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/cstdlib b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/cstdlib new file mode 100755 index 0000000..e98a726 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/cstdlib @@ -0,0 +1,260 @@ +// -*- C++ -*- forwarding header. + +// Copyright (C) 1997-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file include/cstdlib + * This is a Standard C++ Library file. You should @c \#include this file + * in your programs, rather than any of the @a *.h implementation files. + * + * This is the C++ version of the Standard C Library header @c stdlib.h, + * and its contents are (mostly) the same as that header, but are all + * contained in the namespace @c std (except for names which are defined + * as macros in C). + */ + +// +// ISO C++ 14882: 20.4.6 C library +// + +#pragma GCC system_header + +#include + +#ifndef _GLIBCXX_CSTDLIB +#define _GLIBCXX_CSTDLIB 1 + +#if !_GLIBCXX_HOSTED +// The C standard does not require a freestanding implementation to +// provide . However, the C++ standard does still require +// -- but only the functionality mentioned in +// [lib.support.start.term]. + +#define EXIT_SUCCESS 0 +#define EXIT_FAILURE 1 + +namespace std +{ + extern "C" void abort(void) throw () _GLIBCXX_NORETURN; + extern "C" int atexit(void (*)(void)) throw (); + extern "C" void exit(int) throw () _GLIBCXX_NORETURN; +#if __cplusplus >= 201103L +# ifdef _GLIBCXX_HAVE_AT_QUICK_EXIT + extern "C" int at_quick_exit(void (*)(void)) throw (); +# endif +# ifdef _GLIBCXX_HAVE_QUICK_EXIT + extern "C" void quick_exit(int) throw() _GLIBCXX_NORETURN; +# endif +#endif +} // namespace std + +#else + +#include + +// Get rid of those macros defined in in lieu of real functions. +#undef abort +#undef abs +#undef atexit +#if __cplusplus >= 201103L +# ifdef _GLIBCXX_HAVE_AT_QUICK_EXIT +# undef at_quick_exit +# endif +#endif +#undef atof +#undef atoi +#undef atol +#undef bsearch +#undef calloc +#undef div +#undef exit +#undef free +#undef getenv +#undef labs +#undef ldiv +#undef malloc +#undef mblen +#undef mbstowcs +#undef mbtowc +#undef qsort +#if __cplusplus >= 201103L +# ifdef _GLIBCXX_HAVE_QUICK_EXIT +# undef quick_exit +# endif +#endif +#undef rand +#undef realloc +#undef srand +#undef strtod +#undef strtol +#undef strtoul +#undef system +#undef wcstombs +#undef wctomb + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + using ::div_t; + using ::ldiv_t; + + using ::abort; + using ::abs; + using ::atexit; +#if __cplusplus >= 201103L +# ifdef _GLIBCXX_HAVE_AT_QUICK_EXIT + using ::at_quick_exit; +# endif +#endif + using ::atof; + using ::atoi; + using ::atol; + using ::bsearch; + using ::calloc; + using ::div; + using ::exit; + using ::free; + using ::getenv; + using ::labs; + using ::ldiv; + using ::malloc; +#ifdef _GLIBCXX_HAVE_MBSTATE_T + using ::mblen; + using ::mbstowcs; + using ::mbtowc; +#endif // _GLIBCXX_HAVE_MBSTATE_T + using ::qsort; +#if __cplusplus >= 201103L +# ifdef _GLIBCXX_HAVE_QUICK_EXIT + using ::quick_exit; +# endif +#endif + using ::rand; + using ::realloc; + using ::srand; + using ::strtod; + using ::strtol; + using ::strtoul; + using ::system; +#ifdef _GLIBCXX_USE_WCHAR_T + using ::wcstombs; + using ::wctomb; +#endif // _GLIBCXX_USE_WCHAR_T + +#ifndef __CORRECT_ISO_CPP_STDLIB_H_PROTO + inline long + abs(long __i) { return __builtin_labs(__i); } + + inline ldiv_t + div(long __i, long __j) { return ldiv(__i, __j); } +#endif + +#ifdef _GLIBCXX_USE_LONG_LONG + inline long long + abs(long long __x) { return __builtin_llabs (__x); } +#endif + +#if !defined(__STRICT_ANSI__) && defined(_GLIBCXX_USE_INT128) + inline __int128 + abs(__int128 __x) { return __x >= 0 ? __x : -__x; } +#endif + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#if _GLIBCXX_USE_C99 + +#undef _Exit +#undef llabs +#undef lldiv +#undef atoll +#undef strtoll +#undef strtoull +#undef strtof +#undef strtold + +namespace __gnu_cxx _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + +#if !_GLIBCXX_USE_C99_LONG_LONG_DYNAMIC + using ::lldiv_t; +#endif +#if _GLIBCXX_USE_C99_CHECK || _GLIBCXX_USE_C99_DYNAMIC + extern "C" void (_Exit)(int) throw () _GLIBCXX_NORETURN; +#endif +#if !_GLIBCXX_USE_C99_DYNAMIC + using ::_Exit; +#endif + +#if !_GLIBCXX_USE_C99_LONG_LONG_DYNAMIC + using ::llabs; + + inline lldiv_t + div(long long __n, long long __d) + { lldiv_t __q; __q.quot = __n / __d; __q.rem = __n % __d; return __q; } + + using ::lldiv; +#endif + +#if _GLIBCXX_USE_C99_LONG_LONG_CHECK || _GLIBCXX_USE_C99_LONG_LONG_DYNAMIC + extern "C" long long int (atoll)(const char *) throw (); + extern "C" long long int + (strtoll)(const char * __restrict, char ** __restrict, int) throw (); + extern "C" unsigned long long int + (strtoull)(const char * __restrict, char ** __restrict, int) throw (); +#endif +#if !_GLIBCXX_USE_C99_LONG_LONG_DYNAMIC + using ::atoll; + using ::strtoll; + using ::strtoull; +#endif + using ::strtof; + using ::strtold; + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace __gnu_cxx + +namespace std +{ +#if !_GLIBCXX_USE_C99_LONG_LONG_DYNAMIC + using ::__gnu_cxx::lldiv_t; +#endif + using ::__gnu_cxx::_Exit; +#if !_GLIBCXX_USE_C99_LONG_LONG_DYNAMIC + using ::__gnu_cxx::llabs; + using ::__gnu_cxx::div; + using ::__gnu_cxx::lldiv; +#endif + using ::__gnu_cxx::atoll; + using ::__gnu_cxx::strtof; + using ::__gnu_cxx::strtoll; + using ::__gnu_cxx::strtoull; + using ::__gnu_cxx::strtold; +} // namespace std + +#endif // _GLIBCXX_USE_C99 + +#endif // !_GLIBCXX_HOSTED + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/cstring b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/cstring new file mode 100755 index 0000000..7974273 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/cstring @@ -0,0 +1,123 @@ +// -*- C++ -*- forwarding header. + +// Copyright (C) 1997-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file cstring + * This is a Standard C++ Library file. You should @c \#include this file + * in your programs, rather than any of the @a *.h implementation files. + * + * This is the C++ version of the Standard C Library header @c string.h, + * and its contents are (mostly) the same as that header, but are all + * contained in the namespace @c std (except for names which are defined + * as macros in C). + */ + +// +// ISO C++ 14882: 20.4.6 C library +// + +#pragma GCC system_header + +#include +#include + +#ifndef _GLIBCXX_CSTRING +#define _GLIBCXX_CSTRING 1 + +// Get rid of those macros defined in in lieu of real functions. +#undef memchr +#undef memcmp +#undef memcpy +#undef memmove +#undef memset +#undef strcat +#undef strchr +#undef strcmp +#undef strcoll +#undef strcpy +#undef strcspn +#undef strerror +#undef strlen +#undef strncat +#undef strncmp +#undef strncpy +#undef strpbrk +#undef strrchr +#undef strspn +#undef strstr +#undef strtok +#undef strxfrm + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + using ::memchr; + using ::memcmp; + using ::memcpy; + using ::memmove; + using ::memset; + using ::strcat; + using ::strcmp; + using ::strcoll; + using ::strcpy; + using ::strcspn; + using ::strerror; + using ::strlen; + using ::strncat; + using ::strncmp; + using ::strncpy; + using ::strspn; + using ::strtok; + using ::strxfrm; + using ::strchr; + using ::strpbrk; + using ::strrchr; + using ::strstr; + +#ifndef __CORRECT_ISO_CPP_STRING_H_PROTO + inline void* + memchr(void* __s, int __c, size_t __n) + { return __builtin_memchr(__s, __c, __n); } + + inline char* + strchr(char* __s, int __n) + { return __builtin_strchr(__s, __n); } + + inline char* + strpbrk(char* __s1, const char* __s2) + { return __builtin_strpbrk(__s1, __s2); } + + inline char* + strrchr(char* __s, int __n) + { return __builtin_strrchr(__s, __n); } + + inline char* + strstr(char* __s1, const char* __s2) + { return __builtin_strstr(__s1, __s2); } +#endif + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/ctgmath b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/ctgmath new file mode 100755 index 0000000..df36263 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/ctgmath @@ -0,0 +1,41 @@ +// -*- C++ -*- + +// Copyright (C) 2007-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file include/ctgmath + * This is a Standard C++ Library header. + */ + +#pragma GCC system_header + +#ifndef _GLIBCXX_CTGMATH +#define _GLIBCXX_CTGMATH 1 + +#if __cplusplus < 201103L +# include +#else +# include +#endif + +#endif + diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/ctime b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/ctime new file mode 100755 index 0000000..29ac896 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/ctime @@ -0,0 +1,75 @@ +// -*- C++ -*- forwarding header. + +// Copyright (C) 1997-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file include/ctime + * This is a Standard C++ Library file. You should @c \#include this file + * in your programs, rather than any of the @a *.h implementation files. + * + * This is the C++ version of the Standard C Library header @c time.h, + * and its contents are (mostly) the same as that header, but are all + * contained in the namespace @c std (except for names which are defined + * as macros in C). + */ + +// +// ISO C++ 14882: 20.5 Date and time +// + +#pragma GCC system_header + +#include +#include + +#ifndef _GLIBCXX_CTIME +#define _GLIBCXX_CTIME 1 + +// Get rid of those macros defined in in lieu of real functions. +#undef clock +#undef difftime +#undef mktime +#undef time +#undef asctime +#undef ctime +#undef gmtime +#undef localtime +#undef strftime + +namespace std +{ + using ::clock_t; + using ::time_t; + using ::tm; + + using ::clock; + using ::difftime; + using ::mktime; + using ::time; + using ::asctime; + using ::ctime; + using ::gmtime; + using ::localtime; + using ::strftime; +} // namespace + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/cwchar b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/cwchar new file mode 100755 index 0000000..c2ff50d --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/cwchar @@ -0,0 +1,303 @@ +// -*- C++ -*- forwarding header. + +// Copyright (C) 1997-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file include/cwchar + * This is a Standard C++ Library file. You should @c \#include this file + * in your programs, rather than any of the @a *.h implementation files. + * + * This is the C++ version of the Standard C Library header @c wchar.h, + * and its contents are (mostly) the same as that header, but are all + * contained in the namespace @c std (except for names which are defined + * as macros in C). + */ + +// +// ISO C++ 14882: 21.4 +// + +#pragma GCC system_header + +#include + +#if _GLIBCXX_HAVE_WCHAR_H +#include +#endif + +#ifndef _GLIBCXX_CWCHAR +#define _GLIBCXX_CWCHAR 1 + +// Need to do a bit of trickery here with mbstate_t as char_traits +// assumes it is in wchar.h, regardless of wchar_t specializations. +#ifndef _GLIBCXX_HAVE_MBSTATE_T +extern "C" +{ + typedef struct + { + int __fill[6]; + } mbstate_t; +} +#endif + +namespace std +{ + using ::mbstate_t; +} // namespace std + +// Get rid of those macros defined in in lieu of real functions. +#undef btowc +#undef fgetwc +#undef fgetws +#undef fputwc +#undef fputws +#undef fwide +#undef fwprintf +#undef fwscanf +#undef getwc +#undef getwchar +#undef mbrlen +#undef mbrtowc +#undef mbsinit +#undef mbsrtowcs +#undef putwc +#undef putwchar +#undef swprintf +#undef swscanf +#undef ungetwc +#undef vfwprintf +#if _GLIBCXX_HAVE_VFWSCANF +# undef vfwscanf +#endif +#undef vswprintf +#if _GLIBCXX_HAVE_VSWSCANF +# undef vswscanf +#endif +#undef vwprintf +#if _GLIBCXX_HAVE_VWSCANF +# undef vwscanf +#endif +#undef wcrtomb +#undef wcscat +#undef wcschr +#undef wcscmp +#undef wcscoll +#undef wcscpy +#undef wcscspn +#undef wcsftime +#undef wcslen +#undef wcsncat +#undef wcsncmp +#undef wcsncpy +#undef wcspbrk +#undef wcsrchr +#undef wcsrtombs +#undef wcsspn +#undef wcsstr +#undef wcstod +#if _GLIBCXX_HAVE_WCSTOF +# undef wcstof +#endif +#undef wcstok +#undef wcstol +#undef wcstoul +#undef wcsxfrm +#undef wctob +#undef wmemchr +#undef wmemcmp +#undef wmemcpy +#undef wmemmove +#undef wmemset +#undef wprintf +#undef wscanf + +#if _GLIBCXX_USE_WCHAR_T + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + using ::wint_t; + + using ::btowc; + using ::fgetwc; + using ::fgetws; + using ::fputwc; + using ::fputws; + using ::fwide; + using ::fwprintf; + using ::fwscanf; + using ::getwc; + using ::getwchar; + using ::mbrlen; + using ::mbrtowc; + using ::mbsinit; + using ::mbsrtowcs; + using ::putwc; + using ::putwchar; +#ifndef _GLIBCXX_HAVE_BROKEN_VSWPRINTF + using ::swprintf; +#endif + using ::swscanf; + using ::ungetwc; + using ::vfwprintf; +#if _GLIBCXX_HAVE_VFWSCANF + using ::vfwscanf; +#endif +#ifndef _GLIBCXX_HAVE_BROKEN_VSWPRINTF + using ::vswprintf; +#endif +#if _GLIBCXX_HAVE_VSWSCANF + using ::vswscanf; +#endif + using ::vwprintf; +#if _GLIBCXX_HAVE_VWSCANF + using ::vwscanf; +#endif + using ::wcrtomb; + using ::wcscat; + using ::wcscmp; + using ::wcscoll; + using ::wcscpy; + using ::wcscspn; + using ::wcsftime; + using ::wcslen; + using ::wcsncat; + using ::wcsncmp; + using ::wcsncpy; + using ::wcsrtombs; + using ::wcsspn; + using ::wcstod; +#if _GLIBCXX_HAVE_WCSTOF + using ::wcstof; +#endif + using ::wcstok; + using ::wcstol; + using ::wcstoul; + using ::wcsxfrm; + using ::wctob; + using ::wmemcmp; + using ::wmemcpy; + using ::wmemmove; + using ::wmemset; + using ::wprintf; + using ::wscanf; + using ::wcschr; + using ::wcspbrk; + using ::wcsrchr; + using ::wcsstr; + using ::wmemchr; + +#ifndef __CORRECT_ISO_CPP_WCHAR_H_PROTO + inline wchar_t* + wcschr(wchar_t* __p, wchar_t __c) + { return wcschr(const_cast(__p), __c); } + + inline wchar_t* + wcspbrk(wchar_t* __s1, const wchar_t* __s2) + { return wcspbrk(const_cast(__s1), __s2); } + + inline wchar_t* + wcsrchr(wchar_t* __p, wchar_t __c) + { return wcsrchr(const_cast(__p), __c); } + + inline wchar_t* + wcsstr(wchar_t* __s1, const wchar_t* __s2) + { return wcsstr(const_cast(__s1), __s2); } + + inline wchar_t* + wmemchr(wchar_t* __p, wchar_t __c, size_t __n) + { return wmemchr(const_cast(__p), __c, __n); } +#endif + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#if _GLIBCXX_USE_C99 + +#undef wcstold +#undef wcstoll +#undef wcstoull + +namespace __gnu_cxx +{ +#if _GLIBCXX_USE_C99_CHECK || _GLIBCXX_USE_C99_DYNAMIC + extern "C" long double + (wcstold)(const wchar_t * __restrict, wchar_t ** __restrict) throw (); +#endif +#if !_GLIBCXX_USE_C99_DYNAMIC + using ::wcstold; +#endif +#if _GLIBCXX_USE_C99_LONG_LONG_CHECK || _GLIBCXX_USE_C99_LONG_LONG_DYNAMIC + extern "C" long long int + (wcstoll)(const wchar_t * __restrict, wchar_t ** __restrict, int) throw (); + extern "C" unsigned long long int + (wcstoull)(const wchar_t * __restrict, wchar_t ** __restrict, int) throw (); +#endif +#if !_GLIBCXX_USE_C99_LONG_LONG_DYNAMIC + using ::wcstoll; + using ::wcstoull; +#endif +} // namespace __gnu_cxx + +namespace std +{ + using ::__gnu_cxx::wcstold; + using ::__gnu_cxx::wcstoll; + using ::__gnu_cxx::wcstoull; +} // namespace + +#endif + +#endif //_GLIBCXX_USE_WCHAR_T + +#if __cplusplus >= 201103L + +#ifdef _GLIBCXX_USE_WCHAR_T + +namespace std +{ +#if _GLIBCXX_HAVE_WCSTOF + using std::wcstof; +#endif +#if _GLIBCXX_HAVE_VFWSCANF + using std::vfwscanf; +#endif +#if _GLIBCXX_HAVE_VSWSCANF + using std::vswscanf; +#endif +#if _GLIBCXX_HAVE_VWSCANF + using std::vwscanf; +#endif + +#if _GLIBCXX_USE_C99 + using std::wcstold; + using std::wcstoll; + using std::wcstoull; +#endif +} // namespace + +#endif // _GLIBCXX_USE_WCHAR_T + +#endif // C++11 + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/cwctype b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/cwctype new file mode 100755 index 0000000..817e80b --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/cwctype @@ -0,0 +1,110 @@ +// -*- C++ -*- forwarding header. + +// Copyright (C) 1997-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file include/cwctype + * This is a Standard C++ Library file. You should @c \#include this file + * in your programs, rather than any of the @a *.h implementation files. + * + * This is the C++ version of the Standard C Library header @c wctype.h, + * and its contents are (mostly) the same as that header, but are all + * contained in the namespace @c std (except for names which are defined + * as macros in C). + */ + +// +// ISO C++ 14882: +// + +#pragma GCC system_header + +#include + +#if _GLIBCXX_HAVE_WCTYPE_H + +#if __GLIBC__ == 2 && __GLIBC_MINOR__ < 10 +// Work around glibc BZ 9694 +#include +#endif + +#include +#endif // _GLIBCXX_HAVE_WCTYPE_H + +#ifndef _GLIBCXX_CWCTYPE +#define _GLIBCXX_CWCTYPE 1 + +// Get rid of those macros defined in in lieu of real functions. +#undef iswalnum +#undef iswalpha +#if _GLIBCXX_HAVE_ISWBLANK +# undef iswblank +#endif +#undef iswcntrl +#undef iswctype +#undef iswdigit +#undef iswgraph +#undef iswlower +#undef iswprint +#undef iswpunct +#undef iswspace +#undef iswupper +#undef iswxdigit +#undef towctrans +#undef towlower +#undef towupper +#undef wctrans +#undef wctype + +#if _GLIBCXX_USE_WCHAR_T + +namespace std +{ + using ::wctrans_t; + using ::wctype_t; + using ::wint_t; + + using ::iswalnum; + using ::iswalpha; +#if _GLIBCXX_HAVE_ISWBLANK + using ::iswblank; +#endif + using ::iswcntrl; + using ::iswctype; + using ::iswdigit; + using ::iswgraph; + using ::iswlower; + using ::iswprint; + using ::iswpunct; + using ::iswspace; + using ::iswupper; + using ::iswxdigit; + using ::towctrans; + using ::towlower; + using ::towupper; + using ::wctrans; + using ::wctype; +} // namespace + +#endif //_GLIBCXX_USE_WCHAR_T + +#endif // _GLIBCXX_CWCTYPE diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/cxxabi.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/cxxabi.h new file mode 100755 index 0000000..ab87321 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/cxxabi.h @@ -0,0 +1,705 @@ +// ABI Support -*- C++ -*- + +// Copyright (C) 2000-2014 Free Software Foundation, Inc. +// +// This file is part of GCC. +// +// GCC is free software; you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation; either version 3, or (at your option) +// any later version. +// +// GCC is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +// Written by Nathan Sidwell, Codesourcery LLC, + +/* This file declares the new abi entry points into the runtime. It is not + normally necessary for user programs to include this header, or use the + entry points directly. However, this header is available should that be + needed. + + Some of the entry points are intended for both C and C++, thus this header + is includable from both C and C++. Though the C++ specific parts are not + available in C, naturally enough. */ + +/** @file cxxabi.h + * The header provides an interface to the C++ ABI. + */ + +#ifndef _CXXABI_H +#define _CXXABI_H 1 + +#pragma GCC system_header + +#pragma GCC visibility push(default) + +#include +#include +#include +#include + +#ifndef _GLIBCXX_CDTOR_CALLABI +#define _GLIBCXX_CDTOR_CALLABI +#endif + +#ifdef __cplusplus +namespace __cxxabiv1 +{ + extern "C" + { +#endif + + typedef __cxa_cdtor_return_type (*__cxa_cdtor_type)(void *); + + // Allocate array. + void* + __cxa_vec_new(size_t __element_count, size_t __element_size, + size_t __padding_size, __cxa_cdtor_type __constructor, + __cxa_cdtor_type __destructor); + + void* + __cxa_vec_new2(size_t __element_count, size_t __element_size, + size_t __padding_size, __cxa_cdtor_type __constructor, + __cxa_cdtor_type __destructor, void *(*__alloc) (size_t), + void (*__dealloc) (void*)); + + void* + __cxa_vec_new3(size_t __element_count, size_t __element_size, + size_t __padding_size, __cxa_cdtor_type __constructor, + __cxa_cdtor_type __destructor, void *(*__alloc) (size_t), + void (*__dealloc) (void*, size_t)); + + // Construct array. + __cxa_vec_ctor_return_type + __cxa_vec_ctor(void* __array_address, size_t __element_count, + size_t __element_size, __cxa_cdtor_type __constructor, + __cxa_cdtor_type __destructor); + + __cxa_vec_ctor_return_type + __cxa_vec_cctor(void* __dest_array, void* __src_array, + size_t __element_count, size_t __element_size, + __cxa_cdtor_return_type (*__constructor) (void*, void*), + __cxa_cdtor_type __destructor); + + // Destruct array. + void + __cxa_vec_dtor(void* __array_address, size_t __element_count, + size_t __element_size, __cxa_cdtor_type __destructor); + + void + __cxa_vec_cleanup(void* __array_address, size_t __element_count, size_t __s, + __cxa_cdtor_type __destructor) _GLIBCXX_NOTHROW; + + // Destruct and release array. + void + __cxa_vec_delete(void* __array_address, size_t __element_size, + size_t __padding_size, __cxa_cdtor_type __destructor); + + void + __cxa_vec_delete2(void* __array_address, size_t __element_size, + size_t __padding_size, __cxa_cdtor_type __destructor, + void (*__dealloc) (void*)); + + void + __cxa_vec_delete3(void* __array_address, size_t __element_size, + size_t __padding_size, __cxa_cdtor_type __destructor, + void (*__dealloc) (void*, size_t)); + + int + __cxa_guard_acquire(__guard*); + + void + __cxa_guard_release(__guard*) _GLIBCXX_NOTHROW; + + void + __cxa_guard_abort(__guard*) _GLIBCXX_NOTHROW; + + // DSO destruction. + int + __cxa_atexit(void (*)(void*), void*, void*) _GLIBCXX_NOTHROW; + + int + __cxa_finalize(void*); + + // TLS destruction. + int + __cxa_thread_atexit(void (*)(void*), void*, void *) _GLIBCXX_NOTHROW; + + // Pure virtual functions. + void + __cxa_pure_virtual(void) __attribute__ ((__noreturn__)); + + void + __cxa_deleted_virtual(void) __attribute__ ((__noreturn__)); + + // Exception handling auxiliary. + void + __cxa_bad_cast() __attribute__((__noreturn__)); + + void + __cxa_bad_typeid() __attribute__((__noreturn__)); + + void + __cxa_throw_bad_array_new_length() __attribute__((__noreturn__)); + + void + __cxa_throw_bad_array_length() __attribute__((__noreturn__)); + + /** + * @brief Demangling routine. + * ABI-mandated entry point in the C++ runtime library for demangling. + * + * @param __mangled_name A NUL-terminated character string + * containing the name to be demangled. + * + * @param __output_buffer A region of memory, allocated with + * malloc, of @a *__length bytes, into which the demangled name is + * stored. If @a __output_buffer is not long enough, it is + * expanded using realloc. @a __output_buffer may instead be NULL; + * in that case, the demangled name is placed in a region of memory + * allocated with malloc. + * + * @param __length If @a __length is non-NULL, the length of the + * buffer containing the demangled name is placed in @a *__length. + * + * @param __status @a *__status is set to one of the following values: + * 0: The demangling operation succeeded. + * -1: A memory allocation failure occurred. + * -2: @a mangled_name is not a valid name under the C++ ABI mangling rules. + * -3: One of the arguments is invalid. + * + * @return A pointer to the start of the NUL-terminated demangled + * name, or NULL if the demangling fails. The caller is + * responsible for deallocating this memory using @c free. + * + * The demangling is performed using the C++ ABI mangling rules, + * with GNU extensions. For example, this function is used in + * __gnu_cxx::__verbose_terminate_handler. + * + * See http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt12ch39.html + * for other examples of use. + * + * @note The same demangling functionality is available via + * libiberty (@c and @c libiberty.a) in GCC + * 3.1 and later, but that requires explicit installation (@c + * --enable-install-libiberty) and uses a different API, although + * the ABI is unchanged. + */ + char* + __cxa_demangle(const char* __mangled_name, char* __output_buffer, + size_t* __length, int* __status); + +#ifdef __cplusplus + } +} // namespace __cxxabiv1 +#endif + +#ifdef __cplusplus + +#include + +namespace __cxxabiv1 +{ + // Type information for int, float etc. + class __fundamental_type_info : public std::type_info + { + public: + explicit + __fundamental_type_info(const char* __n) : std::type_info(__n) { } + + virtual + ~__fundamental_type_info(); + }; + + // Type information for array objects. + class __array_type_info : public std::type_info + { + public: + explicit + __array_type_info(const char* __n) : std::type_info(__n) { } + + virtual + ~__array_type_info(); + }; + + // Type information for functions (both member and non-member). + class __function_type_info : public std::type_info + { + public: + explicit + __function_type_info(const char* __n) : std::type_info(__n) { } + + virtual + ~__function_type_info(); + + protected: + // Implementation defined member function. + virtual bool + __is_function_p() const; + }; + + // Type information for enumerations. + class __enum_type_info : public std::type_info + { + public: + explicit + __enum_type_info(const char* __n) : std::type_info(__n) { } + + virtual + ~__enum_type_info(); + }; + + // Common type information for simple pointers and pointers to member. + class __pbase_type_info : public std::type_info + { + public: + unsigned int __flags; // Qualification of the target object. + const std::type_info* __pointee; // Type of pointed to object. + + explicit + __pbase_type_info(const char* __n, int __quals, + const std::type_info* __type) + : std::type_info(__n), __flags(__quals), __pointee(__type) + { } + + virtual + ~__pbase_type_info(); + + // Implementation defined type. + enum __masks + { + __const_mask = 0x1, + __volatile_mask = 0x2, + __restrict_mask = 0x4, + __incomplete_mask = 0x8, + __incomplete_class_mask = 0x10 + }; + + protected: + __pbase_type_info(const __pbase_type_info&); + + __pbase_type_info& + operator=(const __pbase_type_info&); + + // Implementation defined member functions. + virtual bool + __do_catch(const std::type_info* __thr_type, void** __thr_obj, + unsigned int __outer) const; + + inline virtual bool + __pointer_catch(const __pbase_type_info* __thr_type, void** __thr_obj, + unsigned __outer) const; + }; + + // Type information for simple pointers. + class __pointer_type_info : public __pbase_type_info + { + public: + explicit + __pointer_type_info(const char* __n, int __quals, + const std::type_info* __type) + : __pbase_type_info (__n, __quals, __type) { } + + + virtual + ~__pointer_type_info(); + + protected: + // Implementation defined member functions. + virtual bool + __is_pointer_p() const; + + virtual bool + __pointer_catch(const __pbase_type_info* __thr_type, void** __thr_obj, + unsigned __outer) const; + }; + + class __class_type_info; + + // Type information for a pointer to member variable. + class __pointer_to_member_type_info : public __pbase_type_info + { + public: + __class_type_info* __context; // Class of the member. + + explicit + __pointer_to_member_type_info(const char* __n, int __quals, + const std::type_info* __type, + __class_type_info* __klass) + : __pbase_type_info(__n, __quals, __type), __context(__klass) { } + + virtual + ~__pointer_to_member_type_info(); + + protected: + __pointer_to_member_type_info(const __pointer_to_member_type_info&); + + __pointer_to_member_type_info& + operator=(const __pointer_to_member_type_info&); + + // Implementation defined member function. + virtual bool + __pointer_catch(const __pbase_type_info* __thr_type, void** __thr_obj, + unsigned __outer) const; + }; + + // Helper class for __vmi_class_type. + class __base_class_type_info + { + public: + const __class_type_info* __base_type; // Base class type. +#ifdef _GLIBCXX_LLP64 + long long __offset_flags; // Offset and info. +#else + long __offset_flags; // Offset and info. +#endif + + enum __offset_flags_masks + { + __virtual_mask = 0x1, + __public_mask = 0x2, + __hwm_bit = 2, + __offset_shift = 8 // Bits to shift offset. + }; + + // Implementation defined member functions. + bool + __is_virtual_p() const + { return __offset_flags & __virtual_mask; } + + bool + __is_public_p() const + { return __offset_flags & __public_mask; } + + ptrdiff_t + __offset() const + { + // This shift, being of a signed type, is implementation + // defined. GCC implements such shifts as arithmetic, which is + // what we want. + return static_cast(__offset_flags) >> __offset_shift; + } + }; + + // Type information for a class. + class __class_type_info : public std::type_info + { + public: + explicit + __class_type_info (const char *__n) : type_info(__n) { } + + virtual + ~__class_type_info (); + + // Implementation defined types. + // The type sub_kind tells us about how a base object is contained + // within a derived object. We often do this lazily, hence the + // UNKNOWN value. At other times we may use NOT_CONTAINED to mean + // not publicly contained. + enum __sub_kind + { + // We have no idea. + __unknown = 0, + + // Not contained within us (in some circumstances this might + // mean not contained publicly) + __not_contained, + + // Contained ambiguously. + __contained_ambig, + + // Via a virtual path. + __contained_virtual_mask = __base_class_type_info::__virtual_mask, + + // Via a public path. + __contained_public_mask = __base_class_type_info::__public_mask, + + // Contained within us. + __contained_mask = 1 << __base_class_type_info::__hwm_bit, + + __contained_private = __contained_mask, + __contained_public = __contained_mask | __contained_public_mask + }; + + struct __upcast_result; + struct __dyncast_result; + + protected: + // Implementation defined member functions. + virtual bool + __do_upcast(const __class_type_info* __dst_type, void**__obj_ptr) const; + + virtual bool + __do_catch(const type_info* __thr_type, void** __thr_obj, + unsigned __outer) const; + + public: + // Helper for upcast. See if DST is us, or one of our bases. + // Return false if not found, true if found. + virtual bool + __do_upcast(const __class_type_info* __dst, const void* __obj, + __upcast_result& __restrict __result) const; + + // Indicate whether SRC_PTR of type SRC_TYPE is contained publicly + // within OBJ_PTR. OBJ_PTR points to a base object of our type, + // which is the destination type. SRC2DST indicates how SRC + // objects might be contained within this type. If SRC_PTR is one + // of our SRC_TYPE bases, indicate the virtuality. Returns + // not_contained for non containment or private containment. + inline __sub_kind + __find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr, + const __class_type_info* __src_type, + const void* __src_ptr) const; + + // Helper for dynamic cast. ACCESS_PATH gives the access from the + // most derived object to this base. DST_TYPE indicates the + // desired type we want. OBJ_PTR points to a base of our type + // within the complete object. SRC_TYPE indicates the static type + // started from and SRC_PTR points to that base within the most + // derived object. Fill in RESULT with what we find. Return true + // if we have located an ambiguous match. + virtual bool + __do_dyncast(ptrdiff_t __src2dst, __sub_kind __access_path, + const __class_type_info* __dst_type, const void* __obj_ptr, + const __class_type_info* __src_type, const void* __src_ptr, + __dyncast_result& __result) const; + + // Helper for find_public_subobj. SRC2DST indicates how SRC_TYPE + // bases are inherited by the type started from -- which is not + // necessarily the current type. The current type will be a base + // of the destination type. OBJ_PTR points to the current base. + virtual __sub_kind + __do_find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr, + const __class_type_info* __src_type, + const void* __src_ptr) const; + }; + + // Type information for a class with a single non-virtual base. + class __si_class_type_info : public __class_type_info + { + public: + const __class_type_info* __base_type; + + explicit + __si_class_type_info(const char *__n, const __class_type_info *__base) + : __class_type_info(__n), __base_type(__base) { } + + virtual + ~__si_class_type_info(); + + protected: + __si_class_type_info(const __si_class_type_info&); + + __si_class_type_info& + operator=(const __si_class_type_info&); + + // Implementation defined member functions. + virtual bool + __do_dyncast(ptrdiff_t __src2dst, __sub_kind __access_path, + const __class_type_info* __dst_type, const void* __obj_ptr, + const __class_type_info* __src_type, const void* __src_ptr, + __dyncast_result& __result) const; + + virtual __sub_kind + __do_find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr, + const __class_type_info* __src_type, + const void* __sub_ptr) const; + + virtual bool + __do_upcast(const __class_type_info*__dst, const void*__obj, + __upcast_result& __restrict __result) const; + }; + + // Type information for a class with multiple and/or virtual bases. + class __vmi_class_type_info : public __class_type_info + { + public: + unsigned int __flags; // Details about the class hierarchy. + unsigned int __base_count; // Number of direct bases. + + // The array of bases uses the trailing array struct hack so this + // class is not constructable with a normal constructor. It is + // internally generated by the compiler. + __base_class_type_info __base_info[1]; // Array of bases. + + explicit + __vmi_class_type_info(const char* __n, int ___flags) + : __class_type_info(__n), __flags(___flags), __base_count(0) { } + + virtual + ~__vmi_class_type_info(); + + // Implementation defined types. + enum __flags_masks + { + __non_diamond_repeat_mask = 0x1, // Distinct instance of repeated base. + __diamond_shaped_mask = 0x2, // Diamond shaped multiple inheritance. + __flags_unknown_mask = 0x10 + }; + + protected: + // Implementation defined member functions. + virtual bool + __do_dyncast(ptrdiff_t __src2dst, __sub_kind __access_path, + const __class_type_info* __dst_type, const void* __obj_ptr, + const __class_type_info* __src_type, const void* __src_ptr, + __dyncast_result& __result) const; + + virtual __sub_kind + __do_find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr, + const __class_type_info* __src_type, + const void* __src_ptr) const; + + virtual bool + __do_upcast(const __class_type_info* __dst, const void* __obj, + __upcast_result& __restrict __result) const; + }; + + // Exception handling forward declarations. + struct __cxa_exception; + struct __cxa_refcounted_exception; + struct __cxa_dependent_exception; + struct __cxa_eh_globals; + + extern "C" + { + // Dynamic cast runtime. + + // src2dst has the following possible values + // >-1: src_type is a unique public non-virtual base of dst_type + // dst_ptr + src2dst == src_ptr + // -1: unspecified relationship + // -2: src_type is not a public base of dst_type + // -3: src_type is a multiple public non-virtual base of dst_type + void* + __dynamic_cast(const void* __src_ptr, // Starting object. + const __class_type_info* __src_type, // Static type of object. + const __class_type_info* __dst_type, // Desired target type. + ptrdiff_t __src2dst); // How src and dst are related. + + + // Exception handling runtime. + + // The __cxa_eh_globals for the current thread can be obtained by using + // either of the following functions. The "fast" version assumes at least + // one prior call of __cxa_get_globals has been made from the current + // thread, so no initialization is necessary. + __cxa_eh_globals* + __cxa_get_globals() _GLIBCXX_NOTHROW __attribute__ ((__const__)); + + __cxa_eh_globals* + __cxa_get_globals_fast() _GLIBCXX_NOTHROW __attribute__ ((__const__)); + + // Allocate memory for the primary exception plus the thrown object. + void* + __cxa_allocate_exception(size_t) _GLIBCXX_NOTHROW; + + // Free the space allocated for the primary exception. + void + __cxa_free_exception(void*) _GLIBCXX_NOTHROW; + + // Throw the exception. + void + __cxa_throw(void*, std::type_info*, void (_GLIBCXX_CDTOR_CALLABI *) (void *)) + __attribute__((__noreturn__)); + + // Used to implement exception handlers. + void* + __cxa_get_exception_ptr(void*) _GLIBCXX_NOTHROW __attribute__ ((__pure__)); + + void* + __cxa_begin_catch(void*) _GLIBCXX_NOTHROW; + + void + __cxa_end_catch(); + + void + __cxa_rethrow() __attribute__((__noreturn__)); + + // Returns the type_info for the currently handled exception [15.3/8], or + // null if there is none. + std::type_info* + __cxa_current_exception_type() _GLIBCXX_NOTHROW __attribute__ ((__pure__)); + + // GNU Extensions. + + // Allocate memory for a dependent exception. + __cxa_dependent_exception* + __cxa_allocate_dependent_exception() _GLIBCXX_NOTHROW; + + // Free the space allocated for the dependent exception. + void + __cxa_free_dependent_exception(__cxa_dependent_exception*) _GLIBCXX_NOTHROW; + + } // extern "C" + + // A magic placeholder class that can be caught by reference + // to recognize foreign exceptions. + class __foreign_exception + { + virtual ~__foreign_exception() throw(); + virtual void __pure_dummy() = 0; // prevent catch by value + }; + +} // namespace __cxxabiv1 + +/** @namespace abi + * @brief The cross-vendor C++ Application Binary Interface. A + * namespace alias to __cxxabiv1, but user programs should use the + * alias 'abi'. + * + * A brief overview of an ABI is given in the libstdc++ FAQ, question + * 5.8 (you may have a copy of the FAQ locally, or you can view the online + * version at http://gcc.gnu.org/onlinedocs/libstdc++/faq.html#5_8 ). + * + * GCC subscribes to a cross-vendor ABI for C++, sometimes + * called the IA64 ABI because it happens to be the native ABI for that + * platform. It is summarized at http://www.codesourcery.com/cxx-abi/ + * along with the current specification. + * + * For users of GCC greater than or equal to 3.x, entry points are + * available in , which notes, 'It is not normally + * necessary for user programs to include this header, or use the + * entry points directly. However, this header is available should + * that be needed.' +*/ +namespace abi = __cxxabiv1; + +namespace __gnu_cxx +{ + /** + * @brief Exception thrown by __cxa_guard_acquire. + * @ingroup exceptions + * + * 6.7[stmt.dcl]/4: If control re-enters the declaration (recursively) + * while the object is being initialized, the behavior is undefined. + * + * Since we already have a library function to handle locking, we might + * as well check for this situation and throw an exception. + * We use the second byte of the guard variable to remember that we're + * in the middle of an initialization. + */ + class recursive_init_error: public std::exception + { + public: + recursive_init_error() throw() { } + virtual ~recursive_init_error() throw (); + }; +} +#endif // __cplusplus + +#pragma GCC visibility pop + +#endif // __CXXABI_H diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/array b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/array new file mode 100755 index 0000000..ef01c98 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/array @@ -0,0 +1,310 @@ +// Debugging array implementation -*- C++ -*- + +// Copyright (C) 2012-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file debug/array + * This is a Standard C++ Library header. + */ + +#ifndef _GLIBCXX_DEBUG_ARRAY +#define _GLIBCXX_DEBUG_ARRAY 1 + +#pragma GCC system_header + +#include + +namespace std _GLIBCXX_VISIBILITY(default) +{ +namespace __debug +{ + template + struct array + { + typedef _Tp value_type; + typedef value_type* pointer; + typedef const value_type* const_pointer; + typedef value_type& reference; + typedef const value_type& const_reference; + typedef value_type* iterator; + typedef const value_type* const_iterator; + typedef std::size_t size_type; + typedef std::ptrdiff_t difference_type; + typedef std::reverse_iterator reverse_iterator; + typedef std::reverse_iterator const_reverse_iterator; + + // Support for zero-sized arrays mandatory. + typedef _GLIBCXX_STD_C::__array_traits<_Tp, _Nm> _AT_Type; + typename _AT_Type::_Type _M_elems; + + template + struct _Array_check_subscript + { + std::size_t size() { return _Size; } + + _Array_check_subscript(std::size_t __index) + { __glibcxx_check_subscript(__index); } + }; + + template + struct _Array_check_nonempty + { + bool empty() { return _Size == 0; } + + _Array_check_nonempty() + { __glibcxx_check_nonempty(); } + }; + + // No explicit construct/copy/destroy for aggregate type. + + // DR 776. + void + fill(const value_type& __u) + { std::fill_n(begin(), size(), __u); } + + void + swap(array& __other) + noexcept(noexcept(swap(std::declval<_Tp&>(), std::declval<_Tp&>()))) + { std::swap_ranges(begin(), end(), __other.begin()); } + + // Iterators. + iterator + begin() noexcept + { return iterator(data()); } + + const_iterator + begin() const noexcept + { return const_iterator(data()); } + + iterator + end() noexcept + { return iterator(data() + _Nm); } + + const_iterator + end() const noexcept + { return const_iterator(data() + _Nm); } + + reverse_iterator + rbegin() noexcept + { return reverse_iterator(end()); } + + const_reverse_iterator + rbegin() const noexcept + { return const_reverse_iterator(end()); } + + reverse_iterator + rend() noexcept + { return reverse_iterator(begin()); } + + const_reverse_iterator + rend() const noexcept + { return const_reverse_iterator(begin()); } + + const_iterator + cbegin() const noexcept + { return const_iterator(data()); } + + const_iterator + cend() const noexcept + { return const_iterator(data() + _Nm); } + + const_reverse_iterator + crbegin() const noexcept + { return const_reverse_iterator(end()); } + + const_reverse_iterator + crend() const noexcept + { return const_reverse_iterator(begin()); } + + // Capacity. + constexpr size_type + size() const noexcept { return _Nm; } + + constexpr size_type + max_size() const noexcept { return _Nm; } + + constexpr bool + empty() const noexcept { return size() == 0; } + + // Element access. + reference + operator[](size_type __n) noexcept + { + __glibcxx_check_subscript(__n); + return _AT_Type::_S_ref(_M_elems, __n); + } + + constexpr const_reference + operator[](size_type __n) const noexcept + { + return __n < _Nm ? _AT_Type::_S_ref(_M_elems, __n) + : (_GLIBCXX_THROW_OR_ABORT(_Array_check_subscript<_Nm>(__n)), + _AT_Type::_S_ref(_M_elems, 0)); + } + + reference + at(size_type __n) + { + if (__n >= _Nm) + std::__throw_out_of_range_fmt(__N("array::at: __n " + "(which is %zu) >= _Nm " + "(which is %zu)"), + __n, _Nm); + return _AT_Type::_S_ref(_M_elems, __n); + } + + constexpr const_reference + at(size_type __n) const + { + // Result of conditional expression must be an lvalue so use + // boolean ? lvalue : (throw-expr, lvalue) + return __n < _Nm ? _AT_Type::_S_ref(_M_elems, __n) + : (std::__throw_out_of_range_fmt(__N("array::at: __n (which is %zu) " + ">= _Nm (which is %zu)"), + __n, _Nm), + _AT_Type::_S_ref(_M_elems, 0)); + } + + reference + front() noexcept + { + __glibcxx_check_nonempty(); + return *begin(); + } + + constexpr const_reference + front() const noexcept + { + return _Nm ? _AT_Type::_S_ref(_M_elems, 0) + : (_GLIBCXX_THROW_OR_ABORT(_Array_check_nonempty<_Nm>()), + _AT_Type::_S_ref(_M_elems, 0)); + } + + reference + back() noexcept + { + __glibcxx_check_nonempty(); + return _Nm ? *(end() - 1) : *end(); + } + + constexpr const_reference + back() const noexcept + { + return _Nm ? _AT_Type::_S_ref(_M_elems, _Nm - 1) + : (_GLIBCXX_THROW_OR_ABORT(_Array_check_nonempty<_Nm>()), + _AT_Type::_S_ref(_M_elems, 0)); + } + + pointer + data() noexcept + { return std::__addressof(_AT_Type::_S_ref(_M_elems, 0)); } + + const_pointer + data() const noexcept + { return std::__addressof(_AT_Type::_S_ref(_M_elems, 0)); } + }; + + // Array comparisons. + template + inline bool + operator==(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two) + { return std::equal(__one.begin(), __one.end(), __two.begin()); } + + template + inline bool + operator!=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two) + { return !(__one == __two); } + + template + inline bool + operator<(const array<_Tp, _Nm>& __a, const array<_Tp, _Nm>& __b) + { + return std::lexicographical_compare(__a.begin(), __a.end(), + __b.begin(), __b.end()); + } + + template + inline bool + operator>(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two) + { return __two < __one; } + + template + inline bool + operator<=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two) + { return !(__one > __two); } + + template + inline bool + operator>=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two) + { return !(__one < __two); } + + // Specialized algorithms. + template + inline void + swap(array<_Tp, _Nm>& __one, array<_Tp, _Nm>& __two) + noexcept(noexcept(__one.swap(__two))) + { __one.swap(__two); } + + template + constexpr _Tp& + get(array<_Tp, _Nm>& __arr) noexcept + { + static_assert(_Int < _Nm, "index is out of bounds"); + return _GLIBCXX_STD_C::__array_traits<_Tp, _Nm>:: + _S_ref(__arr._M_elems, _Int); + } + + template + constexpr _Tp&& + get(array<_Tp, _Nm>&& __arr) noexcept + { + static_assert(_Int < _Nm, "index is out of bounds"); + return std::move(get<_Int>(__arr)); + } + + template + constexpr const _Tp& + get(const array<_Tp, _Nm>& __arr) noexcept + { + static_assert(_Int < _Nm, "index is out of bounds"); + return _GLIBCXX_STD_C::__array_traits<_Tp, _Nm>:: + _S_ref(__arr._M_elems, _Int); + } +} // namespace __debug + + // Tuple interface to class template array. + + /// tuple_size + template + struct tuple_size<__debug::array<_Tp, _Nm>> + : public integral_constant { }; + + /// tuple_element + template + struct tuple_element<_Int, __debug::array<_Tp, _Nm>> + { + static_assert(_Int < _Nm, "index is out of bounds"); + typedef _Tp type; + }; +} // namespace std + +#endif // _GLIBCXX_DEBUG_ARRAY diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/bitset b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/bitset new file mode 100755 index 0000000..9530399 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/bitset @@ -0,0 +1,426 @@ +// Debugging bitset implementation -*- C++ -*- + +// Copyright (C) 2003-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file debug/bitset + * This file is a GNU debug extension to the Standard C++ Library. + */ + +#ifndef _GLIBCXX_DEBUG_BITSET +#define _GLIBCXX_DEBUG_BITSET + +#include +#include +#include + +namespace std _GLIBCXX_VISIBILITY(default) +{ +namespace __debug +{ + /// Class std::bitset with additional safety/checking/debug instrumentation. + template + class bitset + : public _GLIBCXX_STD_C::bitset<_Nb> +#if __cplusplus < 201103L + , public __gnu_debug::_Safe_sequence_base +#endif + { + typedef _GLIBCXX_STD_C::bitset<_Nb> _Base; + + public: + // In C++0x we rely on normal reference type to preserve the property + // of bitset to be use as a literal. + // TODO: Find another solution. +#if __cplusplus >= 201103L + typedef typename _Base::reference reference; +#else + // bit reference: + class reference + : private _Base::reference + , public __gnu_debug::_Safe_iterator_base + { + typedef typename _Base::reference _Base_ref; + + friend class bitset; + reference(); + + reference(const _Base_ref& __base, + bitset* __seq __attribute__((__unused__))) _GLIBCXX_NOEXCEPT + : _Base_ref(__base) + , _Safe_iterator_base(__seq, false) + { } + + public: + reference(const reference& __x) _GLIBCXX_NOEXCEPT + : _Base_ref(__x) + , _Safe_iterator_base(__x, false) + { } + + reference& + operator=(bool __x) _GLIBCXX_NOEXCEPT + { + _GLIBCXX_DEBUG_VERIFY(! this->_M_singular(), + _M_message(__gnu_debug::__msg_bad_bitset_write) + ._M_iterator(*this)); + *static_cast<_Base_ref*>(this) = __x; + return *this; + } + + reference& + operator=(const reference& __x) _GLIBCXX_NOEXCEPT + { + _GLIBCXX_DEBUG_VERIFY(! __x._M_singular(), + _M_message(__gnu_debug::__msg_bad_bitset_read) + ._M_iterator(__x)); + _GLIBCXX_DEBUG_VERIFY(! this->_M_singular(), + _M_message(__gnu_debug::__msg_bad_bitset_write) + ._M_iterator(*this)); + *static_cast<_Base_ref*>(this) = __x; + return *this; + } + + bool + operator~() const _GLIBCXX_NOEXCEPT + { + _GLIBCXX_DEBUG_VERIFY(! this->_M_singular(), + _M_message(__gnu_debug::__msg_bad_bitset_read) + ._M_iterator(*this)); + return ~(*static_cast(this)); + } + + operator bool() const _GLIBCXX_NOEXCEPT + { + _GLIBCXX_DEBUG_VERIFY(! this->_M_singular(), + _M_message(__gnu_debug::__msg_bad_bitset_read) + ._M_iterator(*this)); + return *static_cast(this); + } + + reference& + flip() _GLIBCXX_NOEXCEPT + { + _GLIBCXX_DEBUG_VERIFY(! this->_M_singular(), + _M_message(__gnu_debug::__msg_bad_bitset_flip) + ._M_iterator(*this)); + _Base_ref::flip(); + return *this; + } + }; +#endif + + // 23.3.5.1 constructors: + _GLIBCXX_CONSTEXPR bitset() _GLIBCXX_NOEXCEPT + : _Base() { } + +#if __cplusplus >= 201103L + constexpr bitset(unsigned long long __val) noexcept +#else + bitset(unsigned long __val) +#endif + : _Base(__val) { } + + template + explicit + bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __str, + typename std::basic_string<_CharT, _Traits, _Alloc>::size_type + __pos = 0, + typename std::basic_string<_CharT, _Traits, _Alloc>::size_type + __n = (std::basic_string<_CharT, _Traits, _Alloc>::npos)) + : _Base(__str, __pos, __n) { } + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 396. what are characters zero and one. + template + bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __str, + typename std::basic_string<_CharT, _Traits, _Alloc>::size_type + __pos, + typename std::basic_string<_CharT, _Traits, _Alloc>::size_type + __n, + _CharT __zero, _CharT __one = _CharT('1')) + : _Base(__str, __pos, __n, __zero, __one) { } + + bitset(const _Base& __x) : _Base(__x) { } + +#if __cplusplus >= 201103L + template + explicit + bitset(const _CharT* __str, + typename std::basic_string<_CharT>::size_type __n + = std::basic_string<_CharT>::npos, + _CharT __zero = _CharT('0'), _CharT __one = _CharT('1')) + : _Base(__str, __n, __zero, __one) { } +#endif + + // 23.3.5.2 bitset operations: + bitset<_Nb>& + operator&=(const bitset<_Nb>& __rhs) _GLIBCXX_NOEXCEPT + { + _M_base() &= __rhs; + return *this; + } + + bitset<_Nb>& + operator|=(const bitset<_Nb>& __rhs) _GLIBCXX_NOEXCEPT + { + _M_base() |= __rhs; + return *this; + } + + bitset<_Nb>& + operator^=(const bitset<_Nb>& __rhs) _GLIBCXX_NOEXCEPT + { + _M_base() ^= __rhs; + return *this; + } + + bitset<_Nb>& + operator<<=(size_t __pos) _GLIBCXX_NOEXCEPT + { + _M_base() <<= __pos; + return *this; + } + + bitset<_Nb>& + operator>>=(size_t __pos) _GLIBCXX_NOEXCEPT + { + _M_base() >>= __pos; + return *this; + } + + bitset<_Nb>& + set() _GLIBCXX_NOEXCEPT + { + _Base::set(); + return *this; + } + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 186. bitset::set() second parameter should be bool + bitset<_Nb>& + set(size_t __pos, bool __val = true) + { + _Base::set(__pos, __val); + return *this; + } + + bitset<_Nb>& + reset() _GLIBCXX_NOEXCEPT + { + _Base::reset(); + return *this; + } + + bitset<_Nb>& + reset(size_t __pos) + { + _Base::reset(__pos); + return *this; + } + + bitset<_Nb> + operator~() const _GLIBCXX_NOEXCEPT + { return bitset(~_M_base()); } + + bitset<_Nb>& + flip() _GLIBCXX_NOEXCEPT + { + _Base::flip(); + return *this; + } + + bitset<_Nb>& + flip(size_t __pos) + { + _Base::flip(__pos); + return *this; + } + + // element access: + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 11. Bitset minor problems + reference + operator[](size_t __pos) + { + __glibcxx_check_subscript(__pos); +#if __cplusplus >= 201103L + return _M_base()[__pos]; +#else + return reference(_M_base()[__pos], this); +#endif + } + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 11. Bitset minor problems + _GLIBCXX_CONSTEXPR bool + operator[](size_t __pos) const + { +#if __cplusplus < 201103L + // TODO: Check in debug-mode too. + __glibcxx_check_subscript(__pos); +#endif + return _Base::operator[](__pos); + } + + using _Base::to_ulong; +#if __cplusplus >= 201103L + using _Base::to_ullong; +#endif + + template + std::basic_string<_CharT, _Traits, _Alloc> + to_string() const + { return _M_base().template to_string<_CharT, _Traits, _Alloc>(); } + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 396. what are characters zero and one. + template + std::basic_string<_CharT, _Traits, _Alloc> + to_string(_CharT __zero, _CharT __one = _CharT('1')) const + { + return _M_base().template + to_string<_CharT, _Traits, _Alloc>(__zero, __one); + } + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 434. bitset::to_string() hard to use. + template + std::basic_string<_CharT, _Traits, std::allocator<_CharT> > + to_string() const + { return to_string<_CharT, _Traits, std::allocator<_CharT> >(); } + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 853. to_string needs updating with zero and one. + template + std::basic_string<_CharT, _Traits, std::allocator<_CharT> > + to_string(_CharT __zero, _CharT __one = _CharT('1')) const + { return to_string<_CharT, _Traits, + std::allocator<_CharT> >(__zero, __one); } + + template + std::basic_string<_CharT, std::char_traits<_CharT>, + std::allocator<_CharT> > + to_string() const + { + return to_string<_CharT, std::char_traits<_CharT>, + std::allocator<_CharT> >(); + } + + template + std::basic_string<_CharT, std::char_traits<_CharT>, + std::allocator<_CharT> > + to_string(_CharT __zero, _CharT __one = _CharT('1')) const + { + return to_string<_CharT, std::char_traits<_CharT>, + std::allocator<_CharT> >(__zero, __one); + } + + std::basic_string, std::allocator > + to_string() const + { + return to_string,std::allocator >(); + } + + std::basic_string, std::allocator > + to_string(char __zero, char __one = '1') const + { + return to_string, + std::allocator >(__zero, __one); + } + + using _Base::count; + using _Base::size; + + bool + operator==(const bitset<_Nb>& __rhs) const _GLIBCXX_NOEXCEPT + { return _M_base() == __rhs; } + + bool + operator!=(const bitset<_Nb>& __rhs) const _GLIBCXX_NOEXCEPT + { return _M_base() != __rhs; } + + using _Base::test; + using _Base::all; + using _Base::any; + using _Base::none; + + bitset<_Nb> + operator<<(size_t __pos) const _GLIBCXX_NOEXCEPT + { return bitset<_Nb>(_M_base() << __pos); } + + bitset<_Nb> + operator>>(size_t __pos) const _GLIBCXX_NOEXCEPT + { return bitset<_Nb>(_M_base() >> __pos); } + + _Base& + _M_base() _GLIBCXX_NOEXCEPT + { return *this; } + + const _Base& + _M_base() const _GLIBCXX_NOEXCEPT + { return *this; } + }; + + template + bitset<_Nb> + operator&(const bitset<_Nb>& __x, const bitset<_Nb>& __y) _GLIBCXX_NOEXCEPT + { return bitset<_Nb>(__x) &= __y; } + + template + bitset<_Nb> + operator|(const bitset<_Nb>& __x, const bitset<_Nb>& __y) _GLIBCXX_NOEXCEPT + { return bitset<_Nb>(__x) |= __y; } + + template + bitset<_Nb> + operator^(const bitset<_Nb>& __x, const bitset<_Nb>& __y) _GLIBCXX_NOEXCEPT + { return bitset<_Nb>(__x) ^= __y; } + + template + std::basic_istream<_CharT, _Traits>& + operator>>(std::basic_istream<_CharT, _Traits>& __is, bitset<_Nb>& __x) + { return __is >> __x._M_base(); } + + template + std::basic_ostream<_CharT, _Traits>& + operator<<(std::basic_ostream<_CharT, _Traits>& __os, + const bitset<_Nb>& __x) + { return __os << __x._M_base(); } + +} // namespace __debug + +#if __cplusplus >= 201103L + // DR 1182. + /// std::hash specialization for bitset. + template + struct hash<__debug::bitset<_Nb>> + : public __hash_base> + { + size_t + operator()(const __debug::bitset<_Nb>& __b) const noexcept + { return std::hash<_GLIBCXX_STD_C::bitset<_Nb>>()(__b._M_base()); } + }; +#endif + +} // namespace std + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/debug.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/debug.h new file mode 100755 index 0000000..1b37471 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/debug.h @@ -0,0 +1,131 @@ +// Debugging support implementation -*- C++ -*- + +// Copyright (C) 2003-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file debug/debug.h + * This file is a GNU debug extension to the Standard C++ Library. + */ + +#ifndef _GLIBCXX_DEBUG_MACRO_SWITCH_H +#define _GLIBCXX_DEBUG_MACRO_SWITCH_H 1 + +/** Macros and namespaces used by the implementation outside of debug + * wrappers to verify certain properties. The __glibcxx_requires_xxx + * macros are merely wrappers around the __glibcxx_check_xxx wrappers + * when we are compiling with debug mode, but disappear when we are + * in release mode so that there is no checking performed in, e.g., + * the standard library algorithms. +*/ + +// Debug mode namespaces. + +/** + * @namespace std::__debug + * @brief GNU debug code, replaces standard behavior with debug behavior. + */ +namespace std +{ + namespace __debug { } +} + +/** @namespace __gnu_debug + * @brief GNU debug classes for public use. +*/ +namespace __gnu_debug +{ + using namespace std::__debug; +} + +#ifndef _GLIBCXX_DEBUG + +# define _GLIBCXX_DEBUG_ASSERT(_Condition) +# define _GLIBCXX_DEBUG_PEDASSERT(_Condition) +# define _GLIBCXX_DEBUG_ONLY(_Statement) ; +# define __glibcxx_requires_cond(_Cond,_Msg) +# define __glibcxx_requires_valid_range(_First,_Last) +# define __glibcxx_requires_non_empty_range(_First,_Last) +# define __glibcxx_requires_sorted(_First,_Last) +# define __glibcxx_requires_sorted_pred(_First,_Last,_Pred) +# define __glibcxx_requires_sorted_set(_First1,_Last1,_First2) +# define __glibcxx_requires_sorted_set_pred(_First1,_Last1,_First2,_Pred) +# define __glibcxx_requires_partitioned_lower(_First,_Last,_Value) +# define __glibcxx_requires_partitioned_upper(_First,_Last,_Value) +# define __glibcxx_requires_partitioned_lower_pred(_First,_Last,_Value,_Pred) +# define __glibcxx_requires_partitioned_upper_pred(_First,_Last,_Value,_Pred) +# define __glibcxx_requires_heap(_First,_Last) +# define __glibcxx_requires_heap_pred(_First,_Last,_Pred) +# define __glibcxx_requires_nonempty() +# define __glibcxx_requires_string(_String) +# define __glibcxx_requires_string_len(_String,_Len) +# define __glibcxx_requires_subscript(_N) + +#else + +# include + +#define _GLIBCXX_DEBUG_ASSERT(_Condition) __glibcxx_assert(_Condition) + +#ifdef _GLIBCXX_DEBUG_PEDANTIC +# define _GLIBCXX_DEBUG_PEDASSERT(_Condition) _GLIBCXX_DEBUG_ASSERT(_Condition) +#else +# define _GLIBCXX_DEBUG_PEDASSERT(_Condition) +#endif + +# define _GLIBCXX_DEBUG_ONLY(_Statement) _Statement + +# define __glibcxx_requires_cond(_Cond,_Msg) _GLIBCXX_DEBUG_VERIFY(_Cond,_Msg) +# define __glibcxx_requires_valid_range(_First,_Last) \ + __glibcxx_check_valid_range(_First,_Last) +# define __glibcxx_requires_non_empty_range(_First,_Last) \ + __glibcxx_check_non_empty_range(_First,_Last) +# define __glibcxx_requires_sorted(_First,_Last) \ + __glibcxx_check_sorted(_First,_Last) +# define __glibcxx_requires_sorted_pred(_First,_Last,_Pred) \ + __glibcxx_check_sorted_pred(_First,_Last,_Pred) +# define __glibcxx_requires_sorted_set(_First1,_Last1,_First2) \ + __glibcxx_check_sorted_set(_First1,_Last1,_First2) +# define __glibcxx_requires_sorted_set_pred(_First1,_Last1,_First2,_Pred) \ + __glibcxx_check_sorted_set_pred(_First1,_Last1,_First2,_Pred) +# define __glibcxx_requires_partitioned_lower(_First,_Last,_Value) \ + __glibcxx_check_partitioned_lower(_First,_Last,_Value) +# define __glibcxx_requires_partitioned_upper(_First,_Last,_Value) \ + __glibcxx_check_partitioned_upper(_First,_Last,_Value) +# define __glibcxx_requires_partitioned_lower_pred(_First,_Last,_Value,_Pred) \ + __glibcxx_check_partitioned_lower_pred(_First,_Last,_Value,_Pred) +# define __glibcxx_requires_partitioned_upper_pred(_First,_Last,_Value,_Pred) \ + __glibcxx_check_partitioned_upper_pred(_First,_Last,_Value,_Pred) +# define __glibcxx_requires_heap(_First,_Last) \ + __glibcxx_check_heap(_First,_Last) +# define __glibcxx_requires_heap_pred(_First,_Last,_Pred) \ + __glibcxx_check_heap_pred(_First,_Last,_Pred) +# define __glibcxx_requires_nonempty() __glibcxx_check_nonempty() +# define __glibcxx_requires_string(_String) __glibcxx_check_string(_String) +# define __glibcxx_requires_string_len(_String,_Len) \ + __glibcxx_check_string_len(_String,_Len) +# define __glibcxx_requires_subscript(_N) __glibcxx_check_subscript(_N) + +# include + +#endif + +#endif // _GLIBCXX_DEBUG_MACRO_SWITCH_H diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/deque b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/deque new file mode 100755 index 0000000..225d06c --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/deque @@ -0,0 +1,626 @@ +// Debugging deque implementation -*- C++ -*- + +// Copyright (C) 2003-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file debug/deque + * This file is a GNU debug extension to the Standard C++ Library. + */ + +#ifndef _GLIBCXX_DEBUG_DEQUE +#define _GLIBCXX_DEBUG_DEQUE 1 + +#include +#include +#include + +namespace std _GLIBCXX_VISIBILITY(default) +{ +namespace __debug +{ + /// Class std::deque with safety/checking/debug instrumentation. + template > + class deque + : public _GLIBCXX_STD_C::deque<_Tp, _Allocator>, + public __gnu_debug::_Safe_sequence > + { + typedef _GLIBCXX_STD_C::deque<_Tp, _Allocator> _Base; + + typedef typename _Base::const_iterator _Base_const_iterator; + typedef typename _Base::iterator _Base_iterator; + typedef __gnu_debug::_Equal_to<_Base_const_iterator> _Equal; + public: + typedef typename _Base::reference reference; + typedef typename _Base::const_reference const_reference; + + typedef __gnu_debug::_Safe_iterator<_Base_iterator,deque> + iterator; + typedef __gnu_debug::_Safe_iterator<_Base_const_iterator,deque> + const_iterator; + + typedef typename _Base::size_type size_type; + typedef typename _Base::difference_type difference_type; + + typedef _Tp value_type; + typedef _Allocator allocator_type; + typedef typename _Base::pointer pointer; + typedef typename _Base::const_pointer const_pointer; + typedef std::reverse_iterator reverse_iterator; + typedef std::reverse_iterator const_reverse_iterator; + + // 23.2.1.1 construct/copy/destroy: + + deque() : _Base() { } + + explicit + deque(const _Allocator& __a) + : _Base(__a) { } + +#if __cplusplus >= 201103L + explicit + deque(size_type __n) + : _Base(__n) { } + + deque(size_type __n, const _Tp& __value, + const _Allocator& __a = _Allocator()) + : _Base(__n, __value, __a) { } +#else + explicit + deque(size_type __n, const _Tp& __value = _Tp(), + const _Allocator& __a = _Allocator()) + : _Base(__n, __value, __a) { } +#endif + +#if __cplusplus >= 201103L + template> +#else + template +#endif + deque(_InputIterator __first, _InputIterator __last, + const _Allocator& __a = _Allocator()) + : _Base(__gnu_debug::__base(__gnu_debug::__check_valid_range(__first, + __last)), + __gnu_debug::__base(__last), __a) + { } + + deque(const deque& __x) + : _Base(__x) { } + + deque(const _Base& __x) + : _Base(__x) { } + +#if __cplusplus >= 201103L + deque(deque&& __x) + : _Base(std::move(__x)) + { this->_M_swap(__x); } + + deque(initializer_list __l, + const allocator_type& __a = allocator_type()) + : _Base(__l, __a) { } +#endif + + ~deque() _GLIBCXX_NOEXCEPT { } + + deque& + operator=(const deque& __x) + { + *static_cast<_Base*>(this) = __x; + this->_M_invalidate_all(); + return *this; + } + +#if __cplusplus >= 201103L + deque& + operator=(deque&& __x) noexcept + { + // NB: DR 1204. + // NB: DR 675. + __glibcxx_check_self_move_assign(__x); + clear(); + swap(__x); + return *this; + } + + deque& + operator=(initializer_list __l) + { + *static_cast<_Base*>(this) = __l; + this->_M_invalidate_all(); + return *this; + } +#endif + +#if __cplusplus >= 201103L + template> +#else + template +#endif + void + assign(_InputIterator __first, _InputIterator __last) + { + __glibcxx_check_valid_range(__first, __last); + _Base::assign(__gnu_debug::__base(__first), + __gnu_debug::__base(__last)); + this->_M_invalidate_all(); + } + + void + assign(size_type __n, const _Tp& __t) + { + _Base::assign(__n, __t); + this->_M_invalidate_all(); + } + +#if __cplusplus >= 201103L + void + assign(initializer_list __l) + { + _Base::assign(__l); + this->_M_invalidate_all(); + } +#endif + + using _Base::get_allocator; + + // iterators: + iterator + begin() _GLIBCXX_NOEXCEPT + { return iterator(_Base::begin(), this); } + + const_iterator + begin() const _GLIBCXX_NOEXCEPT + { return const_iterator(_Base::begin(), this); } + + iterator + end() _GLIBCXX_NOEXCEPT + { return iterator(_Base::end(), this); } + + const_iterator + end() const _GLIBCXX_NOEXCEPT + { return const_iterator(_Base::end(), this); } + + reverse_iterator + rbegin() _GLIBCXX_NOEXCEPT + { return reverse_iterator(end()); } + + const_reverse_iterator + rbegin() const _GLIBCXX_NOEXCEPT + { return const_reverse_iterator(end()); } + + reverse_iterator + rend() _GLIBCXX_NOEXCEPT + { return reverse_iterator(begin()); } + + const_reverse_iterator + rend() const _GLIBCXX_NOEXCEPT + { return const_reverse_iterator(begin()); } + +#if __cplusplus >= 201103L + const_iterator + cbegin() const noexcept + { return const_iterator(_Base::begin(), this); } + + const_iterator + cend() const noexcept + { return const_iterator(_Base::end(), this); } + + const_reverse_iterator + crbegin() const noexcept + { return const_reverse_iterator(end()); } + + const_reverse_iterator + crend() const noexcept + { return const_reverse_iterator(begin()); } +#endif + + private: + void + _M_invalidate_after_nth(difference_type __n) + { + typedef __gnu_debug::_After_nth_from<_Base_const_iterator> _After_nth; + this->_M_invalidate_if(_After_nth(__n, _Base::begin())); + } + + public: + // 23.2.1.2 capacity: + using _Base::size; + using _Base::max_size; + +#if __cplusplus >= 201103L + void + resize(size_type __sz) + { + bool __invalidate_all = __sz > this->size(); + if (__sz < this->size()) + this->_M_invalidate_after_nth(__sz); + + _Base::resize(__sz); + + if (__invalidate_all) + this->_M_invalidate_all(); + } + + void + resize(size_type __sz, const _Tp& __c) + { + bool __invalidate_all = __sz > this->size(); + if (__sz < this->size()) + this->_M_invalidate_after_nth(__sz); + + _Base::resize(__sz, __c); + + if (__invalidate_all) + this->_M_invalidate_all(); + } +#else + void + resize(size_type __sz, _Tp __c = _Tp()) + { + bool __invalidate_all = __sz > this->size(); + if (__sz < this->size()) + this->_M_invalidate_after_nth(__sz); + + _Base::resize(__sz, __c); + + if (__invalidate_all) + this->_M_invalidate_all(); + } +#endif + +#if __cplusplus >= 201103L + void + shrink_to_fit() noexcept + { + if (_Base::_M_shrink_to_fit()) + this->_M_invalidate_all(); + } +#endif + + using _Base::empty; + + // element access: + reference + operator[](size_type __n) _GLIBCXX_NOEXCEPT + { + __glibcxx_check_subscript(__n); + return _M_base()[__n]; + } + + const_reference + operator[](size_type __n) const _GLIBCXX_NOEXCEPT + { + __glibcxx_check_subscript(__n); + return _M_base()[__n]; + } + + using _Base::at; + + reference + front() _GLIBCXX_NOEXCEPT + { + __glibcxx_check_nonempty(); + return _Base::front(); + } + + const_reference + front() const _GLIBCXX_NOEXCEPT + { + __glibcxx_check_nonempty(); + return _Base::front(); + } + + reference + back() _GLIBCXX_NOEXCEPT + { + __glibcxx_check_nonempty(); + return _Base::back(); + } + + const_reference + back() const _GLIBCXX_NOEXCEPT + { + __glibcxx_check_nonempty(); + return _Base::back(); + } + + // 23.2.1.3 modifiers: + void + push_front(const _Tp& __x) + { + _Base::push_front(__x); + this->_M_invalidate_all(); + } + + void + push_back(const _Tp& __x) + { + _Base::push_back(__x); + this->_M_invalidate_all(); + } + +#if __cplusplus >= 201103L + void + push_front(_Tp&& __x) + { emplace_front(std::move(__x)); } + + void + push_back(_Tp&& __x) + { emplace_back(std::move(__x)); } + + template + void + emplace_front(_Args&&... __args) + { + _Base::emplace_front(std::forward<_Args>(__args)...); + this->_M_invalidate_all(); + } + + template + void + emplace_back(_Args&&... __args) + { + _Base::emplace_back(std::forward<_Args>(__args)...); + this->_M_invalidate_all(); + } + + template + iterator + emplace(const_iterator __position, _Args&&... __args) + { + __glibcxx_check_insert(__position); + _Base_iterator __res = _Base::emplace(__position.base(), + std::forward<_Args>(__args)...); + this->_M_invalidate_all(); + return iterator(__res, this); + } +#endif + + iterator +#if __cplusplus >= 201103L + insert(const_iterator __position, const _Tp& __x) +#else + insert(iterator __position, const _Tp& __x) +#endif + { + __glibcxx_check_insert(__position); + _Base_iterator __res = _Base::insert(__position.base(), __x); + this->_M_invalidate_all(); + return iterator(__res, this); + } + +#if __cplusplus >= 201103L + iterator + insert(const_iterator __position, _Tp&& __x) + { return emplace(__position, std::move(__x)); } + + iterator + insert(const_iterator __position, initializer_list __l) + { + __glibcxx_check_insert(__position); + _Base_iterator __res = _Base::insert(__position.base(), __l); + this->_M_invalidate_all(); + return iterator(__res, this); + } +#endif + +#if __cplusplus >= 201103L + iterator + insert(const_iterator __position, size_type __n, const _Tp& __x) + { + __glibcxx_check_insert(__position); + _Base_iterator __res = _Base::insert(__position.base(), __n, __x); + this->_M_invalidate_all(); + return iterator(__res, this); + } +#else + void + insert(iterator __position, size_type __n, const _Tp& __x) + { + __glibcxx_check_insert(__position); + _Base::insert(__position.base(), __n, __x); + this->_M_invalidate_all(); + } +#endif + +#if __cplusplus >= 201103L + template> + iterator + insert(const_iterator __position, + _InputIterator __first, _InputIterator __last) + { + __glibcxx_check_insert_range(__position, __first, __last); + _Base_iterator __res = _Base::insert(__position.base(), + __gnu_debug::__base(__first), + __gnu_debug::__base(__last)); + this->_M_invalidate_all(); + return iterator(__res, this); + } +#else + template + void + insert(iterator __position, + _InputIterator __first, _InputIterator __last) + { + __glibcxx_check_insert_range(__position, __first, __last); + _Base::insert(__position.base(), __gnu_debug::__base(__first), + __gnu_debug::__base(__last)); + this->_M_invalidate_all(); + } +#endif + + void + pop_front() _GLIBCXX_NOEXCEPT + { + __glibcxx_check_nonempty(); + this->_M_invalidate_if(_Equal(_Base::begin())); + _Base::pop_front(); + } + + void + pop_back() _GLIBCXX_NOEXCEPT + { + __glibcxx_check_nonempty(); + this->_M_invalidate_if(_Equal(--_Base::end())); + _Base::pop_back(); + } + + iterator +#if __cplusplus >= 201103L + erase(const_iterator __position) +#else + erase(iterator __position) +#endif + { + __glibcxx_check_erase(__position); +#if __cplusplus >= 201103L + _Base_const_iterator __victim = __position.base(); +#else + _Base_iterator __victim = __position.base(); +#endif + if (__victim == _Base::begin() || __victim == _Base::end() - 1) + { + this->_M_invalidate_if(_Equal(__victim)); + return iterator(_Base::erase(__victim), this); + } + else + { + _Base_iterator __res = _Base::erase(__victim); + this->_M_invalidate_all(); + return iterator(__res, this); + } + } + + iterator +#if __cplusplus >= 201103L + erase(const_iterator __first, const_iterator __last) +#else + erase(iterator __first, iterator __last) +#endif + { + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 151. can't currently clear() empty container + __glibcxx_check_erase_range(__first, __last); + + if (__first.base() == __last.base()) +#if __cplusplus >= 201103L + return iterator(__first.base()._M_const_cast(), this); +#else + return __first; +#endif + else if (__first.base() == _Base::begin() + || __last.base() == _Base::end()) + { + this->_M_detach_singular(); + for (_Base_const_iterator __position = __first.base(); + __position != __last.base(); ++__position) + { + this->_M_invalidate_if(_Equal(__position)); + } + __try + { + return iterator(_Base::erase(__first.base(), __last.base()), + this); + } + __catch(...) + { + this->_M_revalidate_singular(); + __throw_exception_again; + } + } + else + { + _Base_iterator __res = _Base::erase(__first.base(), + __last.base()); + this->_M_invalidate_all(); + return iterator(__res, this); + } + } + + void + swap(deque& __x) _GLIBCXX_NOEXCEPT + { + _Base::swap(__x); + this->_M_swap(__x); + } + + void + clear() _GLIBCXX_NOEXCEPT + { + _Base::clear(); + this->_M_invalidate_all(); + } + + _Base& + _M_base() _GLIBCXX_NOEXCEPT { return *this; } + + const _Base& + _M_base() const _GLIBCXX_NOEXCEPT { return *this; } + }; + + template + inline bool + operator==(const deque<_Tp, _Alloc>& __lhs, + const deque<_Tp, _Alloc>& __rhs) + { return __lhs._M_base() == __rhs._M_base(); } + + template + inline bool + operator!=(const deque<_Tp, _Alloc>& __lhs, + const deque<_Tp, _Alloc>& __rhs) + { return __lhs._M_base() != __rhs._M_base(); } + + template + inline bool + operator<(const deque<_Tp, _Alloc>& __lhs, + const deque<_Tp, _Alloc>& __rhs) + { return __lhs._M_base() < __rhs._M_base(); } + + template + inline bool + operator<=(const deque<_Tp, _Alloc>& __lhs, + const deque<_Tp, _Alloc>& __rhs) + { return __lhs._M_base() <= __rhs._M_base(); } + + template + inline bool + operator>=(const deque<_Tp, _Alloc>& __lhs, + const deque<_Tp, _Alloc>& __rhs) + { return __lhs._M_base() >= __rhs._M_base(); } + + template + inline bool + operator>(const deque<_Tp, _Alloc>& __lhs, + const deque<_Tp, _Alloc>& __rhs) + { return __lhs._M_base() > __rhs._M_base(); } + + template + inline void + swap(deque<_Tp, _Alloc>& __lhs, deque<_Tp, _Alloc>& __rhs) + { __lhs.swap(__rhs); } + +} // namespace __debug +} // namespace std + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/formatter.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/formatter.h new file mode 100755 index 0000000..e8ab724 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/formatter.h @@ -0,0 +1,464 @@ +// Debug-mode error formatting implementation -*- C++ -*- + +// Copyright (C) 2003-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file debug/formatter.h + * This file is a GNU debug extension to the Standard C++ Library. + */ + +#ifndef _GLIBCXX_DEBUG_FORMATTER_H +#define _GLIBCXX_DEBUG_FORMATTER_H 1 + +#include +#include +#include + +namespace __gnu_debug +{ + using std::type_info; + + template + bool __check_singular(const _Iterator&); + + class _Safe_sequence_base; + + template + class _Safe_iterator; + + template + class _Safe_local_iterator; + + template + class _Safe_sequence; + + enum _Debug_msg_id + { + // General checks + __msg_valid_range, + __msg_insert_singular, + __msg_insert_different, + __msg_erase_bad, + __msg_erase_different, + __msg_subscript_oob, + __msg_empty, + __msg_unpartitioned, + __msg_unpartitioned_pred, + __msg_unsorted, + __msg_unsorted_pred, + __msg_not_heap, + __msg_not_heap_pred, + // std::bitset checks + __msg_bad_bitset_write, + __msg_bad_bitset_read, + __msg_bad_bitset_flip, + // std::list checks + __msg_self_splice, + __msg_splice_alloc, + __msg_splice_bad, + __msg_splice_other, + __msg_splice_overlap, + // iterator checks + __msg_init_singular, + __msg_init_copy_singular, + __msg_init_const_singular, + __msg_copy_singular, + __msg_bad_deref, + __msg_bad_inc, + __msg_bad_dec, + __msg_iter_subscript_oob, + __msg_advance_oob, + __msg_retreat_oob, + __msg_iter_compare_bad, + __msg_compare_different, + __msg_iter_order_bad, + __msg_order_different, + __msg_distance_bad, + __msg_distance_different, + // istream_iterator + __msg_deref_istream, + __msg_inc_istream, + // ostream_iterator + __msg_output_ostream, + // istreambuf_iterator + __msg_deref_istreambuf, + __msg_inc_istreambuf, + // forward_list + __msg_insert_after_end, + __msg_erase_after_bad, + __msg_valid_range2, + // unordered container local iterators + __msg_local_iter_compare_bad, + __msg_non_empty_range, + // self move assign + __msg_self_move_assign, + // unordered container buckets + __msg_bucket_index_oob, + __msg_valid_load_factor, + // others + __msg_equal_allocs, + __msg_insert_range_from_self + }; + + class _Error_formatter + { + /// Whether an iterator is constant, mutable, or unknown + enum _Constness + { + __unknown_constness, + __const_iterator, + __mutable_iterator, + __last_constness + }; + + // The state of the iterator (fine-grained), if we know it. + enum _Iterator_state + { + __unknown_state, + __singular, // singular, may still be attached to a sequence + __begin, // dereferenceable, and at the beginning + __middle, // dereferenceable, not at the beginning + __end, // past-the-end, may be at beginning if sequence empty + __before_begin, // before begin + __last_state + }; + + // Tags denoting the type of parameter for construction + struct _Is_iterator { }; + struct _Is_sequence { }; + + // A parameter that may be referenced by an error message + struct _Parameter + { + enum + { + __unused_param, + __iterator, + __sequence, + __integer, + __string + } _M_kind; + + union + { + // When _M_kind == __iterator + struct + { + const char* _M_name; + const void* _M_address; + const type_info* _M_type; + _Constness _M_constness; + _Iterator_state _M_state; + const void* _M_sequence; + const type_info* _M_seq_type; + } _M_iterator; + + // When _M_kind == __sequence + struct + { + const char* _M_name; + const void* _M_address; + const type_info* _M_type; + } _M_sequence; + + // When _M_kind == __integer + struct + { + const char* _M_name; + long _M_value; + } _M_integer; + + // When _M_kind == __string + struct + { + const char* _M_name; + const char* _M_value; + } _M_string; + } _M_variant; + + _Parameter() : _M_kind(__unused_param), _M_variant() { } + + _Parameter(long __value, const char* __name) + : _M_kind(__integer), _M_variant() + { + _M_variant._M_integer._M_name = __name; + _M_variant._M_integer._M_value = __value; + } + + _Parameter(const char* __value, const char* __name) + : _M_kind(__string), _M_variant() + { + _M_variant._M_string._M_name = __name; + _M_variant._M_string._M_value = __value; + } + + template + _Parameter(const _Safe_iterator<_Iterator, _Sequence>& __it, + const char* __name, _Is_iterator) + : _M_kind(__iterator), _M_variant() + { + _M_variant._M_iterator._M_name = __name; + _M_variant._M_iterator._M_address = &__it; +#ifdef __GXX_RTTI + _M_variant._M_iterator._M_type = &typeid(__it); +#else + _M_variant._M_iterator._M_type = 0; +#endif + _M_variant._M_iterator._M_constness = + std::__are_same<_Safe_iterator<_Iterator, _Sequence>, + typename _Sequence::iterator>:: + __value ? __mutable_iterator : __const_iterator; + _M_variant._M_iterator._M_sequence = __it._M_get_sequence(); +#ifdef __GXX_RTTI + _M_variant._M_iterator._M_seq_type = &typeid(_Sequence); +#else + _M_variant._M_iterator._M_seq_type = 0; +#endif + + if (__it._M_singular()) + _M_variant._M_iterator._M_state = __singular; + else + { + if (__it._M_is_before_begin()) + _M_variant._M_iterator._M_state = __before_begin; + else if (__it._M_is_end()) + _M_variant._M_iterator._M_state = __end; + else if (__it._M_is_begin()) + _M_variant._M_iterator._M_state = __begin; + else + _M_variant._M_iterator._M_state = __middle; + } + } + + template + _Parameter(const _Safe_local_iterator<_Iterator, _Sequence>& __it, + const char* __name, _Is_iterator) + : _M_kind(__iterator), _M_variant() + { + _M_variant._M_iterator._M_name = __name; + _M_variant._M_iterator._M_address = &__it; +#ifdef __GXX_RTTI + _M_variant._M_iterator._M_type = &typeid(__it); +#else + _M_variant._M_iterator._M_type = 0; +#endif + _M_variant._M_iterator._M_constness = + std::__are_same<_Safe_local_iterator<_Iterator, _Sequence>, + typename _Sequence::local_iterator>:: + __value ? __mutable_iterator : __const_iterator; + _M_variant._M_iterator._M_sequence = __it._M_get_sequence(); +#ifdef __GXX_RTTI + _M_variant._M_iterator._M_seq_type = &typeid(_Sequence); +#else + _M_variant._M_iterator._M_seq_type = 0; +#endif + + if (__it._M_singular()) + _M_variant._M_iterator._M_state = __singular; + else + { + if (__it._M_is_end()) + _M_variant._M_iterator._M_state = __end; + else if (__it._M_is_begin()) + _M_variant._M_iterator._M_state = __begin; + else + _M_variant._M_iterator._M_state = __middle; + } + } + + template + _Parameter(const _Type*& __it, const char* __name, _Is_iterator) + : _M_kind(__iterator), _M_variant() + { + _M_variant._M_iterator._M_name = __name; + _M_variant._M_iterator._M_address = &__it; +#ifdef __GXX_RTTI + _M_variant._M_iterator._M_type = &typeid(__it); +#else + _M_variant._M_iterator._M_type = 0; +#endif + _M_variant._M_iterator._M_constness = __mutable_iterator; + _M_variant._M_iterator._M_state = __it? __unknown_state : __singular; + _M_variant._M_iterator._M_sequence = 0; + _M_variant._M_iterator._M_seq_type = 0; + } + + template + _Parameter(_Type*& __it, const char* __name, _Is_iterator) + : _M_kind(__iterator), _M_variant() + { + _M_variant._M_iterator._M_name = __name; + _M_variant._M_iterator._M_address = &__it; +#ifdef __GXX_RTTI + _M_variant._M_iterator._M_type = &typeid(__it); +#else + _M_variant._M_iterator._M_type = 0; +#endif + _M_variant._M_iterator._M_constness = __const_iterator; + _M_variant._M_iterator._M_state = __it? __unknown_state : __singular; + _M_variant._M_iterator._M_sequence = 0; + _M_variant._M_iterator._M_seq_type = 0; + } + + template + _Parameter(const _Iterator& __it, const char* __name, _Is_iterator) + : _M_kind(__iterator), _M_variant() + { + _M_variant._M_iterator._M_name = __name; + _M_variant._M_iterator._M_address = &__it; +#ifdef __GXX_RTTI + _M_variant._M_iterator._M_type = &typeid(__it); +#else + _M_variant._M_iterator._M_type = 0; +#endif + _M_variant._M_iterator._M_constness = __unknown_constness; + _M_variant._M_iterator._M_state = + __gnu_debug::__check_singular(__it)? __singular : __unknown_state; + _M_variant._M_iterator._M_sequence = 0; + _M_variant._M_iterator._M_seq_type = 0; + } + + template + _Parameter(const _Safe_sequence<_Sequence>& __seq, + const char* __name, _Is_sequence) + : _M_kind(__sequence), _M_variant() + { + _M_variant._M_sequence._M_name = __name; + _M_variant._M_sequence._M_address = + static_cast(&__seq); +#ifdef __GXX_RTTI + _M_variant._M_sequence._M_type = &typeid(_Sequence); +#else + _M_variant._M_sequence._M_type = 0; +#endif + } + + template + _Parameter(const _Sequence& __seq, const char* __name, _Is_sequence) + : _M_kind(__sequence), _M_variant() + { + _M_variant._M_sequence._M_name = __name; + _M_variant._M_sequence._M_address = &__seq; +#ifdef __GXX_RTTI + _M_variant._M_sequence._M_type = &typeid(_Sequence); +#else + _M_variant._M_sequence._M_type = 0; +#endif + } + + void + _M_print_field(const _Error_formatter* __formatter, + const char* __name) const; + + void + _M_print_description(const _Error_formatter* __formatter) const; + }; + + friend struct _Parameter; + + public: + template + const _Error_formatter& + _M_iterator(const _Iterator& __it, const char* __name = 0) const + { + if (_M_num_parameters < std::size_t(__max_parameters)) + _M_parameters[_M_num_parameters++] = _Parameter(__it, __name, + _Is_iterator()); + return *this; + } + + const _Error_formatter& + _M_integer(long __value, const char* __name = 0) const + { + if (_M_num_parameters < std::size_t(__max_parameters)) + _M_parameters[_M_num_parameters++] = _Parameter(__value, __name); + return *this; + } + + const _Error_formatter& + _M_string(const char* __value, const char* __name = 0) const + { + if (_M_num_parameters < std::size_t(__max_parameters)) + _M_parameters[_M_num_parameters++] = _Parameter(__value, __name); + return *this; + } + + template + const _Error_formatter& + _M_sequence(const _Sequence& __seq, const char* __name = 0) const + { + if (_M_num_parameters < std::size_t(__max_parameters)) + _M_parameters[_M_num_parameters++] = _Parameter(__seq, __name, + _Is_sequence()); + return *this; + } + + const _Error_formatter& + _M_message(const char* __text) const + { _M_text = __text; return *this; } + + const _Error_formatter& + _M_message(_Debug_msg_id __id) const throw (); + + _GLIBCXX_NORETURN void + _M_error() const; + + private: + _Error_formatter(const char* __file, std::size_t __line) + : _M_file(__file), _M_line(__line), _M_num_parameters(0), _M_text(0), + _M_max_length(78), _M_column(1), _M_first_line(true), _M_wordwrap(false) + { _M_get_max_length(); } + + template + void + _M_format_word(char*, int, const char*, _Tp) const throw (); + + void + _M_print_word(const char* __word) const; + + void + _M_print_string(const char* __string) const; + + void + _M_get_max_length() const throw (); + + enum { __max_parameters = 9 }; + + const char* _M_file; + std::size_t _M_line; + mutable _Parameter _M_parameters[__max_parameters]; + mutable std::size_t _M_num_parameters; + mutable const char* _M_text; + mutable std::size_t _M_max_length; + enum { _M_indent = 4 } ; + mutable std::size_t _M_column; + mutable bool _M_first_line; + mutable bool _M_wordwrap; + + public: + static _Error_formatter + _M_at(const char* __file, std::size_t __line) + { return _Error_formatter(__file, __line); } + }; +} // namespace __gnu_debug + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/forward_list b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/forward_list new file mode 100755 index 0000000..12f6d7f --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/forward_list @@ -0,0 +1,811 @@ +// -*- C++ -*- + +// Copyright (C) 2010-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file debug/forward_list + * This file is a GNU debug extension to the Standard C++ Library. + */ + +#ifndef _GLIBCXX_DEBUG_FORWARD_LIST +#define _GLIBCXX_DEBUG_FORWARD_LIST 1 + +#pragma GCC system_header + +#include +#include +#include + +namespace std _GLIBCXX_VISIBILITY(default) +{ +namespace __debug +{ + /// Class std::forward_list with safety/checking/debug instrumentation. + template > + class forward_list + : public _GLIBCXX_STD_C::forward_list<_Tp, _Alloc>, + public __gnu_debug::_Safe_sequence > + { + typedef _GLIBCXX_STD_C::forward_list<_Tp, _Alloc> _Base; + + typedef typename _Base::iterator _Base_iterator; + typedef typename _Base::const_iterator _Base_const_iterator; + + typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template + rebind<_GLIBCXX_STD_C::_Fwd_list_node<_Tp>>::other _Node_alloc_type; + + typedef __gnu_cxx::__alloc_traits<_Node_alloc_type> _Node_alloc_traits; + + public: + typedef typename _Base::reference reference; + typedef typename _Base::const_reference const_reference; + + typedef __gnu_debug::_Safe_iterator<_Base_iterator, + forward_list> iterator; + typedef __gnu_debug::_Safe_iterator<_Base_const_iterator, + forward_list> const_iterator; + + typedef typename _Base::size_type size_type; + typedef typename _Base::difference_type difference_type; + + typedef _Tp value_type; + typedef _Alloc allocator_type; + typedef typename _Base::pointer pointer; + typedef typename _Base::const_pointer const_pointer; + + // 23.2.3.1 construct/copy/destroy: + explicit + forward_list(const _Alloc& __al = _Alloc()) + : _Base(__al) { } + + forward_list(const forward_list& __list, const _Alloc& __al) + : _Base(__list, __al) + { } + + forward_list(forward_list&& __list, const _Alloc& __al) + : _Base(std::move(__list._M_base()), __al) + { + if (__list.get_allocator() == __al) + this->_M_swap(__list); + else + __list._M_invalidate_all(); + } + + explicit + forward_list(size_type __n, const _Alloc& __al = _Alloc()) + : _Base(__n, __al) + { } + + forward_list(size_type __n, const _Tp& __value, + const _Alloc& __al = _Alloc()) + : _Base(__n, __value, __al) + { } + + template> + forward_list(_InputIterator __first, _InputIterator __last, + const _Alloc& __al = _Alloc()) + : _Base(__gnu_debug::__base(__gnu_debug::__check_valid_range(__first, + __last)), + __gnu_debug::__base(__last), __al) + { } + + forward_list(const forward_list& __list) + : _Base(__list) + { } + + forward_list(forward_list&& __list) noexcept + : _Base(std::move(__list._M_base())) + { + this->_M_swap(__list); + } + + forward_list(std::initializer_list<_Tp> __il, + const _Alloc& __al = _Alloc()) + : _Base(__il, __al) + { } + + ~forward_list() noexcept + { } + + forward_list& + operator=(const forward_list& __list) + { + static_cast<_Base&>(*this) = __list; + this->_M_invalidate_all(); + return *this; + } + + forward_list& + operator=(forward_list&& __list) + noexcept(_Node_alloc_traits::_S_nothrow_move()) + { + __glibcxx_check_self_move_assign(__list); + bool __xfer_memory = _Node_alloc_traits::_S_propagate_on_move_assign() + || __list.get_allocator() == this->get_allocator(); + static_cast<_Base&>(*this) = std::move(__list); + if (__xfer_memory) + this->_M_swap(__list); + else + this->_M_invalidate_all(); + __list._M_invalidate_all(); + return *this; + } + + forward_list& + operator=(std::initializer_list<_Tp> __il) + { + static_cast<_Base&>(*this) = __il; + this->_M_invalidate_all(); + return *this; + } + + template> + void + assign(_InputIterator __first, _InputIterator __last) + { + __glibcxx_check_valid_range(__first, __last); + _Base::assign(__gnu_debug::__base(__first), + __gnu_debug::__base(__last)); + this->_M_invalidate_all(); + } + + void + assign(size_type __n, const _Tp& __val) + { + _Base::assign(__n, __val); + this->_M_invalidate_all(); + } + + void + assign(std::initializer_list<_Tp> __il) + { + _Base::assign(__il); + this->_M_invalidate_all(); + } + + using _Base::get_allocator; + + // iterators: + + iterator + before_begin() noexcept + { return iterator(_Base::before_begin(), this); } + + const_iterator + before_begin() const noexcept + { return const_iterator(_Base::before_begin(), this); } + + iterator + begin() noexcept + { return iterator(_Base::begin(), this); } + + const_iterator + begin() const noexcept + { return const_iterator(_Base::begin(), this); } + + iterator + end() noexcept + { return iterator(_Base::end(), this); } + + const_iterator + end() const noexcept + { return const_iterator(_Base::end(), this); } + + const_iterator + cbegin() const noexcept + { return const_iterator(_Base::cbegin(), this); } + + const_iterator + cbefore_begin() const noexcept + { return const_iterator(_Base::cbefore_begin(), this); } + + const_iterator + cend() const noexcept + { return const_iterator(_Base::cend(), this); } + + using _Base::empty; + using _Base::max_size; + + // element access: + + reference + front() + { + __glibcxx_check_nonempty(); + return _Base::front(); + } + + const_reference + front() const + { + __glibcxx_check_nonempty(); + return _Base::front(); + } + + // modiï¬ers: + + using _Base::emplace_front; + using _Base::push_front; + + void + pop_front() + { + __glibcxx_check_nonempty(); + this->_M_invalidate_if([this](_Base_const_iterator __it) + { return __it == this->_M_base().cbegin(); }); + _Base::pop_front(); + } + + template + iterator + emplace_after(const_iterator __pos, _Args&&... __args) + { + __glibcxx_check_insert_after(__pos); + return iterator(_Base::emplace_after(__pos.base(), + std::forward<_Args>(__args)...), + this); + } + + iterator + insert_after(const_iterator __pos, const _Tp& __val) + { + __glibcxx_check_insert_after(__pos); + return iterator(_Base::insert_after(__pos.base(), __val), this); + } + + iterator + insert_after(const_iterator __pos, _Tp&& __val) + { + __glibcxx_check_insert_after(__pos); + return iterator(_Base::insert_after(__pos.base(), std::move(__val)), + this); + } + + iterator + insert_after(const_iterator __pos, size_type __n, const _Tp& __val) + { + __glibcxx_check_insert_after(__pos); + return iterator(_Base::insert_after(__pos.base(), __n, __val), + this); + } + + template> + iterator + insert_after(const_iterator __pos, + _InputIterator __first, _InputIterator __last) + { + __glibcxx_check_insert_range_after(__pos, __first, __last); + return iterator(_Base::insert_after(__pos.base(), + __gnu_debug::__base(__first), + __gnu_debug::__base(__last)), + this); + } + + iterator + insert_after(const_iterator __pos, std::initializer_list<_Tp> __il) + { + __glibcxx_check_insert_after(__pos); + return iterator(_Base::insert_after(__pos.base(), __il), this); + } + + private: + _Base_iterator + _M_erase_after(_Base_const_iterator __pos) + { + _Base_const_iterator __next = std::next(__pos); + this->_M_invalidate_if([__next](_Base_const_iterator __it) + { return __it == __next; }); + return _Base::erase_after(__pos); + } + public: + iterator + erase_after(const_iterator __pos) + { + __glibcxx_check_erase_after(__pos); + return iterator(_M_erase_after(__pos.base()), this); + } + + iterator + erase_after(const_iterator __pos, const_iterator __last) + { + __glibcxx_check_erase_range_after(__pos, __last); + for (_Base_const_iterator __victim = std::next(__pos.base()); + __victim != __last.base(); ++__victim) + { + _GLIBCXX_DEBUG_VERIFY(__victim != _Base::end(), + _M_message(__gnu_debug::__msg_valid_range2) + ._M_sequence(*this, "this") + ._M_iterator(__pos, "pos") + ._M_iterator(__last, "last")); + this->_M_invalidate_if([__victim](_Base_const_iterator __it) + { return __it == __victim; }); + } + return iterator(_Base::erase_after(__pos.base(), __last.base()), this); + } + + void + swap(forward_list& __list) + noexcept(_Node_alloc_traits::_S_nothrow_swap()) + { + if (!_Node_alloc_traits::_S_propagate_on_swap()) + __glibcxx_check_equal_allocs(__list); + _Base::swap(__list); + this->_M_swap(__list); + } + + void + resize(size_type __sz) + { + this->_M_detach_singular(); + + // if __sz < size(), invalidate all iterators in [begin+__sz, end() + _Base_iterator __victim = _Base::begin(); + _Base_iterator __end = _Base::end(); + for (size_type __i = __sz; __victim != __end && __i > 0; --__i) + ++__victim; + + for (; __victim != __end; ++__victim) + { + this->_M_invalidate_if([__victim](_Base_const_iterator __it) + { return __it == __victim; }); + } + + __try + { + _Base::resize(__sz); + } + __catch(...) + { + this->_M_revalidate_singular(); + __throw_exception_again; + } + } + + void + resize(size_type __sz, const value_type& __val) + { + this->_M_detach_singular(); + + // if __sz < size(), invalidate all iterators in [begin+__sz, end()) + _Base_iterator __victim = _Base::begin(); + _Base_iterator __end = _Base::end(); + for (size_type __i = __sz; __victim != __end && __i > 0; --__i) + ++__victim; + + for (; __victim != __end; ++__victim) + { + this->_M_invalidate_if([__victim](_Base_const_iterator __it) + { return __it == __victim; }); + } + + __try + { + _Base::resize(__sz, __val); + } + __catch(...) + { + this->_M_revalidate_singular(); + __throw_exception_again; + } + } + + void + clear() noexcept + { + _Base::clear(); + this->_M_invalidate_all(); + } + + // 23.2.3.5 forward_list operations: + void + splice_after(const_iterator __pos, forward_list&& __list) + { + __glibcxx_check_insert_after(__pos); + _GLIBCXX_DEBUG_VERIFY(&__list != this, + _M_message(__gnu_debug::__msg_self_splice) + ._M_sequence(*this, "this")); + _GLIBCXX_DEBUG_VERIFY(__list.get_allocator() == this->get_allocator(), + _M_message(__gnu_debug::__msg_splice_alloc) + ._M_sequence(*this) + ._M_sequence(__list, "__list")); + this->_M_transfer_from_if(__list, [&__list](_Base_const_iterator __it) + { + return __it != __list._M_base().cbefore_begin() + && __it != __list._M_base().end(); + }); + _Base::splice_after(__pos.base(), std::move(__list._M_base())); + } + + void + splice_after(const_iterator __pos, forward_list& __list) + { splice_after(__pos, std::move(__list)); } + + void + splice_after(const_iterator __pos, forward_list&& __list, + const_iterator __i) + { + __glibcxx_check_insert_after(__pos); + _GLIBCXX_DEBUG_VERIFY(__i._M_before_dereferenceable(), + _M_message(__gnu_debug::__msg_splice_bad) + ._M_iterator(__i, "__i")); + _GLIBCXX_DEBUG_VERIFY(__i._M_attached_to(&__list), + _M_message(__gnu_debug::__msg_splice_other) + ._M_iterator(__i, "__i") + ._M_sequence(__list, "__list")); + _GLIBCXX_DEBUG_VERIFY(__list.get_allocator() == this->get_allocator(), + _M_message(__gnu_debug::__msg_splice_alloc) + ._M_sequence(*this) + ._M_sequence(__list, "__list")); + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 250. splicing invalidates iterators + _Base_const_iterator __next = std::next(__i.base()); + this->_M_transfer_from_if(__list, [__next](_Base_const_iterator __it) + { return __it == __next; }); + _Base::splice_after(__pos.base(), std::move(__list._M_base()), + __i.base()); + } + + void + splice_after(const_iterator __pos, forward_list& __list, + const_iterator __i) + { splice_after(__pos, std::move(__list), __i); } + + void + splice_after(const_iterator __pos, forward_list&& __list, + const_iterator __before, const_iterator __last) + { + __glibcxx_check_insert_after(__pos); + __glibcxx_check_valid_range(__before, __last); + _GLIBCXX_DEBUG_VERIFY(__before._M_attached_to(&__list), + _M_message(__gnu_debug::__msg_splice_other) + ._M_sequence(__list, "list") + ._M_iterator(__before, "before")); + _GLIBCXX_DEBUG_VERIFY(__before._M_dereferenceable() + || __before._M_is_before_begin(), + _M_message(__gnu_debug::__msg_valid_range2) + ._M_sequence(__list, "list") + ._M_iterator(__before, "before") + ._M_iterator(__last, "last")); + _GLIBCXX_DEBUG_VERIFY(__before != __last, + _M_message(__gnu_debug::__msg_valid_range2) + ._M_sequence(__list, "list") + ._M_iterator(__before, "before") + ._M_iterator(__last, "last")); + _GLIBCXX_DEBUG_VERIFY(__list.get_allocator() == this->get_allocator(), + _M_message(__gnu_debug::__msg_splice_alloc) + ._M_sequence(*this) + ._M_sequence(__list, "__list")); + + for (_Base_const_iterator __tmp = std::next(__before.base()); + __tmp != __last.base(); ++__tmp) + { + _GLIBCXX_DEBUG_VERIFY(__tmp != __list._M_base().end(), + _M_message(__gnu_debug::__msg_valid_range2) + ._M_sequence(__list, "list") + ._M_iterator(__before, "before") + ._M_iterator(__last, "last")); + _GLIBCXX_DEBUG_VERIFY(&__list != this || __tmp != __pos.base(), + _M_message(__gnu_debug::__msg_splice_overlap) + ._M_iterator(__tmp, "position") + ._M_iterator(__before, "before") + ._M_iterator(__last, "last")); + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 250. splicing invalidates iterators + this->_M_transfer_from_if(__list, [__tmp](_Base_const_iterator __it) + { return __it == __tmp; }); + } + + _Base::splice_after(__pos.base(), std::move(__list._M_base()), + __before.base(), __last.base()); + } + + void + splice_after(const_iterator __pos, forward_list& __list, + const_iterator __before, const_iterator __last) + { splice_after(__pos, std::move(__list), __before, __last); } + + void + remove(const _Tp& __val) + { + _Base_iterator __x = _Base::before_begin(); + _Base_iterator __old = __x++; + while (__x != _Base::end()) + { + if (*__x == __val) + __x = _M_erase_after(__old); + else + __old = __x++; + } + } + + template + void + remove_if(_Pred __pred) + { + _Base_iterator __x = _Base::before_begin(); + _Base_iterator __old = __x++; + while (__x != _Base::end()) + { + if (__pred(*__x)) + __x = _M_erase_after(__old); + else + __old = __x++; + } + } + + void + unique() + { + _Base_iterator __first = _Base::begin(); + _Base_iterator __last = _Base::end(); + if (__first == __last) + return; + _Base_iterator __next = std::next(__first); + while (__next != __last) + { + if (*__first == *__next) + __next = _M_erase_after(__first); + else + __first = __next++; + } + } + + template + void + unique(_BinPred __binary_pred) + { + _Base_iterator __first = _Base::begin(); + _Base_iterator __last = _Base::end(); + if (__first == __last) + return; + _Base_iterator __next = std::next(__first); + while (__next != __last) + { + if (__binary_pred(*__first, *__next)) + __next = _M_erase_after(__first); + else + __first = __next++; + } + } + + void + merge(forward_list&& __list) + { + if (this != &__list) + { + __glibcxx_check_sorted(_Base::begin(), _Base::end()); + __glibcxx_check_sorted(__list._M_base().begin(), + __list._M_base().end()); + this->_M_transfer_from_if(__list, [&__list](_Base_const_iterator __it) + { + return __it != __list._M_base().cbefore_begin() + && __it != __list._M_base().cend(); + }); + _Base::merge(std::move(__list._M_base())); + } + } + + void + merge(forward_list& __list) + { merge(std::move(__list)); } + + template + void + merge(forward_list&& __list, _Comp __comp) + { + if (this != &__list) + { + __glibcxx_check_sorted_pred(_Base::begin(), _Base::end(), __comp); + __glibcxx_check_sorted_pred(__list._M_base().begin(), + __list._M_base().end(), __comp); + this->_M_transfer_from_if(__list, + [&__list](_Base_const_iterator __it) + { + return __it != __list._M_base().cbefore_begin() + && __it != __list._M_base().cend(); + }); + _Base::merge(std::move(__list._M_base()), __comp); + } + } + + template + void + merge(forward_list& __list, _Comp __comp) + { merge(std::move(__list), __comp); } + + using _Base::sort; + using _Base::reverse; + + _Base& + _M_base() noexcept { return *this; } + + const _Base& + _M_base() const noexcept { return *this; } + + private: + void + _M_invalidate_all() + { + this->_M_invalidate_if([this](_Base_const_iterator __it) + { + return __it != this->_M_base().cbefore_begin() + && __it != this->_M_base().cend(); + }); + } + typedef __gnu_debug::_Safe_iterator_base _Safe_iterator_base; + static void + _M_swap_aux(forward_list& __lhs, + _Safe_iterator_base*& __lhs_iterators, + forward_list& __rhs, + _Safe_iterator_base*& __rhs_iterators); + void _M_swap(forward_list& __list); + }; + + template + void + forward_list<_Tp, _Alloc>:: + _M_swap_aux(forward_list<_Tp, _Alloc>& __lhs, + __gnu_debug::_Safe_iterator_base*& __lhs_iterators, + forward_list<_Tp, _Alloc>& __rhs, + __gnu_debug::_Safe_iterator_base*& __rhs_iterators) + { + using __gnu_debug::_Safe_iterator_base; + _Safe_iterator_base* __bbegin_its = 0; + _Safe_iterator_base* __last_bbegin = 0; + for (_Safe_iterator_base* __iter = __lhs_iterators; __iter;) + { + // Even iterator are casted to const_iterator, not a problem. + const_iterator* __victim = static_cast(__iter); + __iter = __iter->_M_next; + if (__victim->base() == __rhs._M_base().cbefore_begin()) + { + __victim->_M_unlink(); + if (__lhs_iterators == __victim) + __lhs_iterators = __victim->_M_next; + if (__bbegin_its) + { + __victim->_M_next = __bbegin_its; + __bbegin_its->_M_prior = __victim; + } + else + __last_bbegin = __victim; + __bbegin_its = __victim; + } + else + __victim->_M_sequence = &__lhs; + } + + if (__bbegin_its) + { + if (__rhs_iterators) + { + __rhs_iterators->_M_prior = __last_bbegin; + __last_bbegin->_M_next = __rhs_iterators; + } + __rhs_iterators = __bbegin_its; + } + } + + /* Special forward_list _M_swap version that do not swap the + * before-begin ownership.*/ + template + void + forward_list<_Tp, _Alloc>:: + _M_swap(forward_list<_Tp, _Alloc>& __list) + { + __gnu_cxx::__scoped_lock sentry(this->_M_get_mutex()); + std::swap(this->_M_iterators, __list._M_iterators); + std::swap(this->_M_const_iterators, __list._M_const_iterators); + // Useless, always 1 on forward_list + //std::swap(this->_M_version, __list._M_version); + _Safe_iterator_base* __this_its = this->_M_iterators; + _M_swap_aux(__list, __list._M_iterators, *this, this->_M_iterators); + _Safe_iterator_base* __this_const_its = this->_M_const_iterators; + _M_swap_aux(__list, __list._M_const_iterators, *this, + this->_M_const_iterators); + _M_swap_aux(*this, __this_its, __list, __list._M_iterators); + _M_swap_aux(*this, __this_const_its, __list, __list._M_const_iterators); + } + + template + bool + operator==(const forward_list<_Tp, _Alloc>& __lx, + const forward_list<_Tp, _Alloc>& __ly) + { return __lx._M_base() == __ly._M_base(); } + + template + inline bool + operator<(const forward_list<_Tp, _Alloc>& __lx, + const forward_list<_Tp, _Alloc>& __ly) + { return __lx._M_base() < __ly._M_base(); } + + template + inline bool + operator!=(const forward_list<_Tp, _Alloc>& __lx, + const forward_list<_Tp, _Alloc>& __ly) + { return !(__lx == __ly); } + + /// Based on operator< + template + inline bool + operator>(const forward_list<_Tp, _Alloc>& __lx, + const forward_list<_Tp, _Alloc>& __ly) + { return (__ly < __lx); } + + /// Based on operator< + template + inline bool + operator>=(const forward_list<_Tp, _Alloc>& __lx, + const forward_list<_Tp, _Alloc>& __ly) + { return !(__lx < __ly); } + + /// Based on operator< + template + inline bool + operator<=(const forward_list<_Tp, _Alloc>& __lx, + const forward_list<_Tp, _Alloc>& __ly) + { return !(__ly < __lx); } + + /// See std::forward_list::swap(). + template + inline void + swap(forward_list<_Tp, _Alloc>& __lx, + forward_list<_Tp, _Alloc>& __ly) + { __lx.swap(__ly); } + +} // namespace __debug +} // namespace std + +namespace __gnu_debug +{ + template + struct _BeforeBeginHelper > + { + typedef std::__debug::forward_list<_Tp, _Alloc> _Sequence; + + template + static bool + _S_Is(const _Safe_iterator<_Iterator, _Sequence>& __it) + { + return + __it.base() == __it._M_get_sequence()->_M_base().before_begin(); + } + + template + static bool + _S_Is_Beginnest(const _Safe_iterator<_Iterator, _Sequence>& __it) + { return _S_Is(__it); } + }; + +#ifndef _GLIBCXX_DEBUG_PEDANTIC + template + struct _Insert_range_from_self_is_safe< + std::__debug::forward_list<_Tp, _Alloc> > + { enum { __value = 1 }; }; +#endif +} + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/functions.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/functions.h new file mode 100755 index 0000000..0e7f1b7 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/functions.h @@ -0,0 +1,562 @@ +// Debugging support implementation -*- C++ -*- + +// Copyright (C) 2003-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file debug/functions.h + * This file is a GNU debug extension to the Standard C++ Library. + */ + +#ifndef _GLIBCXX_DEBUG_FUNCTIONS_H +#define _GLIBCXX_DEBUG_FUNCTIONS_H 1 + +#include +#include // for iterator_traits, categories and + // _Iter_base +#include // for __is_integer +#include // for __addressof and addressof +#include // for less +#if __cplusplus >= 201103L +# include // for is_lvalue_reference and __and_ +#endif +#include + +namespace __gnu_debug +{ + template + class _Safe_iterator; + + template + class _Safe_local_iterator; + + template + struct _Insert_range_from_self_is_safe + { enum { __value = 0 }; }; + + template + struct _Is_contiguous_sequence : std::__false_type { }; + + // An arbitrary iterator pointer is not singular. + inline bool + __check_singular_aux(const void*) { return false; } + + // We may have an iterator that derives from _Safe_iterator_base but isn't + // a _Safe_iterator. + template + inline bool + __check_singular(const _Iterator& __x) + { return __check_singular_aux(&__x); } + + /** Non-NULL pointers are nonsingular. */ + template + inline bool + __check_singular(const _Tp* __ptr) + { return __ptr == 0; } + + /** Assume that some arbitrary iterator is dereferenceable, because we + can't prove that it isn't. */ + template + inline bool + __check_dereferenceable(const _Iterator&) + { return true; } + + /** Non-NULL pointers are dereferenceable. */ + template + inline bool + __check_dereferenceable(const _Tp* __ptr) + { return __ptr; } + + /** Safe iterators know if they are dereferenceable. */ + template + inline bool + __check_dereferenceable(const _Safe_iterator<_Iterator, _Sequence>& __x) + { return __x._M_dereferenceable(); } + + /** Safe local iterators know if they are dereferenceable. */ + template + inline bool + __check_dereferenceable(const _Safe_local_iterator<_Iterator, + _Sequence>& __x) + { return __x._M_dereferenceable(); } + + /** If the distance between two random access iterators is + * nonnegative, assume the range is valid. + */ + template + inline bool + __valid_range_aux2(const _RandomAccessIterator& __first, + const _RandomAccessIterator& __last, + std::random_access_iterator_tag) + { return __last - __first >= 0; } + + /** Can't test for a valid range with input iterators, because + * iteration may be destructive. So we just assume that the range + * is valid. + */ + template + inline bool + __valid_range_aux2(const _InputIterator&, const _InputIterator&, + std::input_iterator_tag) + { return true; } + + /** We say that integral types for a valid range, and defer to other + * routines to realize what to do with integral types instead of + * iterators. + */ + template + inline bool + __valid_range_aux(const _Integral&, const _Integral&, std::__true_type) + { return true; } + + /** We have iterators, so figure out what kind of iterators that are + * to see if we can check the range ahead of time. + */ + template + inline bool + __valid_range_aux(const _InputIterator& __first, + const _InputIterator& __last, std::__false_type) + { return __valid_range_aux2(__first, __last, + std::__iterator_category(__first)); } + + /** Don't know what these iterators are, or if they are even + * iterators (we may get an integral type for InputIterator), so + * see if they are integral and pass them on to the next phase + * otherwise. + */ + template + inline bool + __valid_range(const _InputIterator& __first, const _InputIterator& __last) + { + typedef typename std::__is_integer<_InputIterator>::__type _Integral; + return __valid_range_aux(__first, __last, _Integral()); + } + + /** Safe iterators know how to check if they form a valid range. */ + template + inline bool + __valid_range(const _Safe_iterator<_Iterator, _Sequence>& __first, + const _Safe_iterator<_Iterator, _Sequence>& __last) + { return __first._M_valid_range(__last); } + + /** Safe local iterators know how to check if they form a valid range. */ + template + inline bool + __valid_range(const _Safe_local_iterator<_Iterator, _Sequence>& __first, + const _Safe_local_iterator<_Iterator, _Sequence>& __last) + { return __first._M_valid_range(__last); } + + /* Checks that [first, last) is a valid range, and then returns + * __first. This routine is useful when we can't use a separate + * assertion statement because, e.g., we are in a constructor. + */ + template + inline _InputIterator + __check_valid_range(const _InputIterator& __first, + const _InputIterator& __last + __attribute__((__unused__))) + { + __glibcxx_check_valid_range(__first, __last); + return __first; + } + + /* Handle the case where __other is a pointer to _Sequence::value_type. */ + template + inline bool + __foreign_iterator_aux4(const _Safe_iterator<_Iterator, _Sequence>& __it, + const typename _Sequence::value_type* __other) + { + typedef const typename _Sequence::value_type* _PointerType; + typedef std::less<_PointerType> _Less; +#if __cplusplus >= 201103L + constexpr _Less __l{}; +#else + const _Less __l = _Less(); +#endif + const _Sequence* __seq = __it._M_get_sequence(); + const _PointerType __begin = std::__addressof(*__seq->_M_base().begin()); + const _PointerType __end = std::__addressof(*(__seq->_M_base().end()-1)); + + // Check whether __other points within the contiguous storage. + return __l(__other, __begin) || __l(__end, __other); + } + + /* Fallback overload for when we can't tell, assume it is valid. */ + template + inline bool + __foreign_iterator_aux4(const _Safe_iterator<_Iterator, _Sequence>&, ...) + { return true; } + + /* Handle sequences with contiguous storage */ + template + inline bool + __foreign_iterator_aux3(const _Safe_iterator<_Iterator, _Sequence>& __it, + const _InputIterator& __other, + const _InputIterator& __other_end, + std::__true_type) + { + if (__other == __other_end) + return true; // inserting nothing is safe even if not foreign iters + if (__it._M_get_sequence()->begin() == __it._M_get_sequence()->end()) + return true; // can't be self-inserting if self is empty + return __foreign_iterator_aux4(__it, std::__addressof(*__other)); + } + + /* Handle non-contiguous containers, assume it is valid. */ + template + inline bool + __foreign_iterator_aux3(const _Safe_iterator<_Iterator, _Sequence>&, + const _InputIterator&, const _InputIterator&, + std::__false_type) + { return true; } + + /** Handle debug iterators from the same type of container. */ + template + inline bool + __foreign_iterator_aux2(const _Safe_iterator<_Iterator, _Sequence>& __it, + const _Safe_iterator<_OtherIterator, _Sequence>& __other, + const _Safe_iterator<_OtherIterator, _Sequence>&) + { return __it._M_get_sequence() != __other._M_get_sequence(); } + + /** Handle debug iterators from different types of container. */ + template + inline bool + __foreign_iterator_aux2(const _Safe_iterator<_Iterator, _Sequence>& __it, + const _Safe_iterator<_OtherIterator, _OtherSequence>&, + const _Safe_iterator<_OtherIterator, _OtherSequence>&) + { return true; } + + /* Handle non-debug iterators. */ + template + inline bool + __foreign_iterator_aux2(const _Safe_iterator<_Iterator, _Sequence>& __it, + const _InputIterator& __other, + const _InputIterator& __other_end) + { +#if __cplusplus < 201103L + typedef _Is_contiguous_sequence<_Sequence> __tag; +#else + using __lvalref = std::is_lvalue_reference< + typename std::iterator_traits<_InputIterator>::reference>; + using __contiguous = _Is_contiguous_sequence<_Sequence>; + using __tag = typename std::conditional<__lvalref::value, __contiguous, + std::__false_type>::type; +#endif + return __foreign_iterator_aux3(__it, __other, __other_end, __tag()); + } + + /* Handle the case where we aren't really inserting a range after all */ + template + inline bool + __foreign_iterator_aux(const _Safe_iterator<_Iterator, _Sequence>&, + _Integral, _Integral, + std::__true_type) + { return true; } + + /* Handle all iterators. */ + template + inline bool + __foreign_iterator_aux(const _Safe_iterator<_Iterator, _Sequence>& __it, + _InputIterator __other, _InputIterator __other_end, + std::__false_type) + { + return _Insert_range_from_self_is_safe<_Sequence>::__value + || __foreign_iterator_aux2(__it, __other, __other_end); + } + + template + inline bool + __foreign_iterator(const _Safe_iterator<_Iterator, _Sequence>& __it, + _InputIterator __other, _InputIterator __other_end) + { + typedef typename std::__is_integer<_InputIterator>::__type _Integral; + return __foreign_iterator_aux(__it, __other, __other_end, _Integral()); + } + + /** Checks that __s is non-NULL or __n == 0, and then returns __s. */ + template + inline const _CharT* + __check_string(const _CharT* __s, + const _Integer& __n __attribute__((__unused__))) + { +#ifdef _GLIBCXX_DEBUG_PEDANTIC + __glibcxx_assert(__s != 0 || __n == 0); +#endif + return __s; + } + + /** Checks that __s is non-NULL and then returns __s. */ + template + inline const _CharT* + __check_string(const _CharT* __s) + { +#ifdef _GLIBCXX_DEBUG_PEDANTIC + __glibcxx_assert(__s != 0); +#endif + return __s; + } + + // Can't check if an input iterator sequence is sorted, because we + // can't step through the sequence. + template + inline bool + __check_sorted_aux(const _InputIterator&, const _InputIterator&, + std::input_iterator_tag) + { return true; } + + // Can verify if a forward iterator sequence is in fact sorted using + // std::__is_sorted + template + inline bool + __check_sorted_aux(_ForwardIterator __first, _ForwardIterator __last, + std::forward_iterator_tag) + { + if (__first == __last) + return true; + + _ForwardIterator __next = __first; + for (++__next; __next != __last; __first = __next, ++__next) + if (*__next < *__first) + return false; + + return true; + } + + // Can't check if an input iterator sequence is sorted, because we can't step + // through the sequence. + template + inline bool + __check_sorted_aux(const _InputIterator&, const _InputIterator&, + _Predicate, std::input_iterator_tag) + { return true; } + + // Can verify if a forward iterator sequence is in fact sorted using + // std::__is_sorted + template + inline bool + __check_sorted_aux(_ForwardIterator __first, _ForwardIterator __last, + _Predicate __pred, std::forward_iterator_tag) + { + if (__first == __last) + return true; + + _ForwardIterator __next = __first; + for (++__next; __next != __last; __first = __next, ++__next) + if (__pred(*__next, *__first)) + return false; + + return true; + } + + // Determine if a sequence is sorted. + template + inline bool + __check_sorted(const _InputIterator& __first, const _InputIterator& __last) + { + // Verify that the < operator for elements in the sequence is a + // StrictWeakOrdering by checking that it is irreflexive. + __glibcxx_assert(__first == __last || !(*__first < *__first)); + + return __check_sorted_aux(__first, __last, + std::__iterator_category(__first)); + } + + template + inline bool + __check_sorted(const _InputIterator& __first, const _InputIterator& __last, + _Predicate __pred) + { + // Verify that the predicate is StrictWeakOrdering by checking that it + // is irreflexive. + __glibcxx_assert(__first == __last || !__pred(*__first, *__first)); + + return __check_sorted_aux(__first, __last, __pred, + std::__iterator_category(__first)); + } + + template + inline bool + __check_sorted_set_aux(const _InputIterator& __first, + const _InputIterator& __last, + std::__true_type) + { return __check_sorted(__first, __last); } + + template + inline bool + __check_sorted_set_aux(const _InputIterator&, + const _InputIterator&, + std::__false_type) + { return true; } + + template + inline bool + __check_sorted_set_aux(const _InputIterator& __first, + const _InputIterator& __last, + _Predicate __pred, std::__true_type) + { return __check_sorted(__first, __last, __pred); } + + template + inline bool + __check_sorted_set_aux(const _InputIterator&, + const _InputIterator&, _Predicate, + std::__false_type) + { return true; } + + // ... special variant used in std::merge, std::includes, std::set_*. + template + inline bool + __check_sorted_set(const _InputIterator1& __first, + const _InputIterator1& __last, + const _InputIterator2&) + { + typedef typename std::iterator_traits<_InputIterator1>::value_type + _ValueType1; + typedef typename std::iterator_traits<_InputIterator2>::value_type + _ValueType2; + + typedef typename std::__are_same<_ValueType1, _ValueType2>::__type + _SameType; + return __check_sorted_set_aux(__first, __last, _SameType()); + } + + template + inline bool + __check_sorted_set(const _InputIterator1& __first, + const _InputIterator1& __last, + const _InputIterator2&, _Predicate __pred) + { + typedef typename std::iterator_traits<_InputIterator1>::value_type + _ValueType1; + typedef typename std::iterator_traits<_InputIterator2>::value_type + _ValueType2; + + typedef typename std::__are_same<_ValueType1, _ValueType2>::__type + _SameType; + return __check_sorted_set_aux(__first, __last, __pred, _SameType()); + } + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 270. Binary search requirements overly strict + // Determine if a sequence is partitioned w.r.t. this element. + template + inline bool + __check_partitioned_lower(_ForwardIterator __first, + _ForwardIterator __last, const _Tp& __value) + { + while (__first != __last && *__first < __value) + ++__first; + if (__first != __last) + { + ++__first; + while (__first != __last && !(*__first < __value)) + ++__first; + } + return __first == __last; + } + + template + inline bool + __check_partitioned_upper(_ForwardIterator __first, + _ForwardIterator __last, const _Tp& __value) + { + while (__first != __last && !(__value < *__first)) + ++__first; + if (__first != __last) + { + ++__first; + while (__first != __last && __value < *__first) + ++__first; + } + return __first == __last; + } + + // Determine if a sequence is partitioned w.r.t. this element. + template + inline bool + __check_partitioned_lower(_ForwardIterator __first, + _ForwardIterator __last, const _Tp& __value, + _Pred __pred) + { + while (__first != __last && bool(__pred(*__first, __value))) + ++__first; + if (__first != __last) + { + ++__first; + while (__first != __last && !bool(__pred(*__first, __value))) + ++__first; + } + return __first == __last; + } + + template + inline bool + __check_partitioned_upper(_ForwardIterator __first, + _ForwardIterator __last, const _Tp& __value, + _Pred __pred) + { + while (__first != __last && !bool(__pred(__value, *__first))) + ++__first; + if (__first != __last) + { + ++__first; + while (__first != __last && bool(__pred(__value, *__first))) + ++__first; + } + return __first == __last; + } + + // Helper struct to detect random access safe iterators. + template + struct __is_safe_random_iterator + { + enum { __value = 0 }; + typedef std::__false_type __type; + }; + + template + struct __is_safe_random_iterator<_Safe_iterator<_Iterator, _Sequence> > + : std::__are_same:: + iterator_category> + { }; + + template + struct _Siter_base + : std::_Iter_base<_Iterator, __is_safe_random_iterator<_Iterator>::__value> + { }; + + /** Helper function to extract base iterator of random access safe iterator + in order to reduce performance impact of debug mode. Limited to random + access iterator because it is the only category for which it is possible + to check for correct iterators order in the __valid_range function + thanks to the < operator. + */ + template + inline typename _Siter_base<_Iterator>::iterator_type + __base(_Iterator __it) + { return _Siter_base<_Iterator>::_S_base(__it); } +} // namespace __gnu_debug + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/list b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/list new file mode 100755 index 0000000..9918bc5 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/list @@ -0,0 +1,807 @@ +// Debugging list implementation -*- C++ -*- + +// Copyright (C) 2003-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file debug/list + * This file is a GNU debug extension to the Standard C++ Library. + */ + +#ifndef _GLIBCXX_DEBUG_LIST +#define _GLIBCXX_DEBUG_LIST 1 + +#include +#include +#include + +namespace std _GLIBCXX_VISIBILITY(default) +{ +namespace __debug +{ + /// Class std::list with safety/checking/debug instrumentation. + template > + class list + : public _GLIBCXX_STD_C::list<_Tp, _Allocator>, + public __gnu_debug::_Safe_sequence > + { + typedef _GLIBCXX_STD_C::list<_Tp, _Allocator> _Base; + + typedef typename _Base::iterator _Base_iterator; + typedef typename _Base::const_iterator _Base_const_iterator; + typedef __gnu_debug::_Equal_to<_Base_const_iterator> _Equal; + typedef __gnu_debug::_Not_equal_to<_Base_const_iterator> _Not_equal; + public: + typedef typename _Base::reference reference; + typedef typename _Base::const_reference const_reference; + + typedef __gnu_debug::_Safe_iterator<_Base_iterator, list> + iterator; + typedef __gnu_debug::_Safe_iterator<_Base_const_iterator, list> + const_iterator; + + typedef typename _Base::size_type size_type; + typedef typename _Base::difference_type difference_type; + + typedef _Tp value_type; + typedef _Allocator allocator_type; + typedef typename _Base::pointer pointer; + typedef typename _Base::const_pointer const_pointer; + typedef std::reverse_iterator reverse_iterator; + typedef std::reverse_iterator const_reverse_iterator; + + // 23.2.2.1 construct/copy/destroy: + + list() _GLIBCXX_NOEXCEPT + : _Base() { } + + explicit + list(const _Allocator& __a) _GLIBCXX_NOEXCEPT + : _Base(__a) { } + +#if __cplusplus >= 201103L + explicit + list(size_type __n) + : _Base(__n) { } + + list(size_type __n, const _Tp& __value, + const _Allocator& __a = _Allocator()) + : _Base(__n, __value, __a) { } +#else + explicit + list(size_type __n, const _Tp& __value = _Tp(), + const _Allocator& __a = _Allocator()) + : _Base(__n, __value, __a) { } +#endif + +#if __cplusplus >= 201103L + template> +#else + template +#endif + list(_InputIterator __first, _InputIterator __last, + const _Allocator& __a = _Allocator()) + : _Base(__gnu_debug::__base(__gnu_debug::__check_valid_range(__first, + __last)), + __gnu_debug::__base(__last), __a) + { } + + list(const list& __x) + : _Base(__x) { } + + list(const _Base& __x) + : _Base(__x) { } + +#if __cplusplus >= 201103L + list(list&& __x) noexcept + : _Base(std::move(__x)) + { this->_M_swap(__x); } + + list(initializer_list __l, + const allocator_type& __a = allocator_type()) + : _Base(__l, __a) { } +#endif + + ~list() _GLIBCXX_NOEXCEPT { } + + list& + operator=(const list& __x) + { + static_cast<_Base&>(*this) = __x; + this->_M_invalidate_all(); + return *this; + } + +#if __cplusplus >= 201103L + list& + operator=(list&& __x) + { + // NB: DR 1204. + // NB: DR 675. + __glibcxx_check_self_move_assign(__x); + clear(); + swap(__x); + return *this; + } + + list& + operator=(initializer_list __l) + { + static_cast<_Base&>(*this) = __l; + this->_M_invalidate_all(); + return *this; + } + + void + assign(initializer_list __l) + { + _Base::assign(__l); + this->_M_invalidate_all(); + } +#endif + +#if __cplusplus >= 201103L + template> +#else + template +#endif + void + assign(_InputIterator __first, _InputIterator __last) + { + __glibcxx_check_valid_range(__first, __last); + _Base::assign(__gnu_debug::__base(__first), + __gnu_debug::__base(__last)); + this->_M_invalidate_all(); + } + + void + assign(size_type __n, const _Tp& __t) + { + _Base::assign(__n, __t); + this->_M_invalidate_all(); + } + + using _Base::get_allocator; + + // iterators: + iterator + begin() _GLIBCXX_NOEXCEPT + { return iterator(_Base::begin(), this); } + + const_iterator + begin() const _GLIBCXX_NOEXCEPT + { return const_iterator(_Base::begin(), this); } + + iterator + end() _GLIBCXX_NOEXCEPT + { return iterator(_Base::end(), this); } + + const_iterator + end() const _GLIBCXX_NOEXCEPT + { return const_iterator(_Base::end(), this); } + + reverse_iterator + rbegin() _GLIBCXX_NOEXCEPT + { return reverse_iterator(end()); } + + const_reverse_iterator + rbegin() const _GLIBCXX_NOEXCEPT + { return const_reverse_iterator(end()); } + + reverse_iterator + rend() _GLIBCXX_NOEXCEPT + { return reverse_iterator(begin()); } + + const_reverse_iterator + rend() const _GLIBCXX_NOEXCEPT + { return const_reverse_iterator(begin()); } + +#if __cplusplus >= 201103L + const_iterator + cbegin() const noexcept + { return const_iterator(_Base::begin(), this); } + + const_iterator + cend() const noexcept + { return const_iterator(_Base::end(), this); } + + const_reverse_iterator + crbegin() const noexcept + { return const_reverse_iterator(end()); } + + const_reverse_iterator + crend() const noexcept + { return const_reverse_iterator(begin()); } +#endif + + // 23.2.2.2 capacity: + using _Base::empty; + using _Base::size; + using _Base::max_size; + +#if __cplusplus >= 201103L + void + resize(size_type __sz) + { + this->_M_detach_singular(); + + // if __sz < size(), invalidate all iterators in [begin+__sz, end()) + _Base_iterator __victim = _Base::begin(); + _Base_iterator __end = _Base::end(); + for (size_type __i = __sz; __victim != __end && __i > 0; --__i) + ++__victim; + + for (; __victim != __end; ++__victim) + { + this->_M_invalidate_if(_Equal(__victim)); + } + + __try + { + _Base::resize(__sz); + } + __catch(...) + { + this->_M_revalidate_singular(); + __throw_exception_again; + } + } + + void + resize(size_type __sz, const _Tp& __c) + { + this->_M_detach_singular(); + + // if __sz < size(), invalidate all iterators in [begin+__sz, end()) + _Base_iterator __victim = _Base::begin(); + _Base_iterator __end = _Base::end(); + for (size_type __i = __sz; __victim != __end && __i > 0; --__i) + ++__victim; + + for (; __victim != __end; ++__victim) + { + this->_M_invalidate_if(_Equal(__victim)); + } + + __try + { + _Base::resize(__sz, __c); + } + __catch(...) + { + this->_M_revalidate_singular(); + __throw_exception_again; + } + } +#else + void + resize(size_type __sz, _Tp __c = _Tp()) + { + this->_M_detach_singular(); + + // if __sz < size(), invalidate all iterators in [begin+__sz, end()) + _Base_iterator __victim = _Base::begin(); + _Base_iterator __end = _Base::end(); + for (size_type __i = __sz; __victim != __end && __i > 0; --__i) + ++__victim; + + for (; __victim != __end; ++__victim) + { + this->_M_invalidate_if(_Equal(__victim)); + } + + __try + { + _Base::resize(__sz, __c); + } + __catch(...) + { + this->_M_revalidate_singular(); + __throw_exception_again; + } + } +#endif + + // element access: + reference + front() _GLIBCXX_NOEXCEPT + { + __glibcxx_check_nonempty(); + return _Base::front(); + } + + const_reference + front() const _GLIBCXX_NOEXCEPT + { + __glibcxx_check_nonempty(); + return _Base::front(); + } + + reference + back() _GLIBCXX_NOEXCEPT + { + __glibcxx_check_nonempty(); + return _Base::back(); + } + + const_reference + back() const _GLIBCXX_NOEXCEPT + { + __glibcxx_check_nonempty(); + return _Base::back(); + } + + // 23.2.2.3 modifiers: + using _Base::push_front; + +#if __cplusplus >= 201103L + using _Base::emplace_front; +#endif + + void + pop_front() _GLIBCXX_NOEXCEPT + { + __glibcxx_check_nonempty(); + this->_M_invalidate_if(_Equal(_Base::begin())); + _Base::pop_front(); + } + + using _Base::push_back; + +#if __cplusplus >= 201103L + using _Base::emplace_back; +#endif + + void + pop_back() _GLIBCXX_NOEXCEPT + { + __glibcxx_check_nonempty(); + this->_M_invalidate_if(_Equal(--_Base::end())); + _Base::pop_back(); + } + +#if __cplusplus >= 201103L + template + iterator + emplace(const_iterator __position, _Args&&... __args) + { + __glibcxx_check_insert(__position); + return iterator(_Base::emplace(__position.base(), + std::forward<_Args>(__args)...), this); + } +#endif + + iterator +#if __cplusplus >= 201103L + insert(const_iterator __position, const _Tp& __x) +#else + insert(iterator __position, const _Tp& __x) +#endif + { + __glibcxx_check_insert(__position); + return iterator(_Base::insert(__position.base(), __x), this); + } + +#if __cplusplus >= 201103L + iterator + insert(const_iterator __position, _Tp&& __x) + { return emplace(__position, std::move(__x)); } + + iterator + insert(const_iterator __p, initializer_list __l) + { + __glibcxx_check_insert(__p); + return iterator(_Base::insert(__p.base(), __l), this); + } +#endif + +#if __cplusplus >= 201103L + iterator + insert(const_iterator __position, size_type __n, const _Tp& __x) + { + __glibcxx_check_insert(__position); + return iterator(_Base::insert(__position.base(), __n, __x), this); + } +#else + void + insert(iterator __position, size_type __n, const _Tp& __x) + { + __glibcxx_check_insert(__position); + _Base::insert(__position.base(), __n, __x); + } +#endif + +#if __cplusplus >= 201103L + template> + iterator + insert(const_iterator __position, _InputIterator __first, + _InputIterator __last) + { + __glibcxx_check_insert_range(__position, __first, __last); + return iterator(_Base::insert(__position.base(), + __gnu_debug::__base(__first), + __gnu_debug::__base(__last)), + this); + } +#else + template + void + insert(iterator __position, _InputIterator __first, + _InputIterator __last) + { + __glibcxx_check_insert_range(__position, __first, __last); + _Base::insert(__position.base(), __gnu_debug::__base(__first), + __gnu_debug::__base(__last)); + } +#endif + + private: + _Base_iterator +#if __cplusplus >= 201103L + _M_erase(_Base_const_iterator __position) noexcept +#else + _M_erase(_Base_iterator __position) +#endif + { + this->_M_invalidate_if(_Equal(__position)); + return _Base::erase(__position); + } + + public: + iterator +#if __cplusplus >= 201103L + erase(const_iterator __position) noexcept +#else + erase(iterator __position) +#endif + { + __glibcxx_check_erase(__position); + return iterator(_M_erase(__position.base()), this); + } + + iterator +#if __cplusplus >= 201103L + erase(const_iterator __first, const_iterator __last) noexcept +#else + erase(iterator __first, iterator __last) +#endif + { + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 151. can't currently clear() empty container + __glibcxx_check_erase_range(__first, __last); + for (_Base_const_iterator __victim = __first.base(); + __victim != __last.base(); ++__victim) + { + _GLIBCXX_DEBUG_VERIFY(__victim != _Base::end(), + _M_message(__gnu_debug::__msg_valid_range) + ._M_iterator(__first, "position") + ._M_iterator(__last, "last")); + this->_M_invalidate_if(_Equal(__victim)); + } + return iterator(_Base::erase(__first.base(), __last.base()), this); + } + + void + swap(list& __x) + { + _Base::swap(__x); + this->_M_swap(__x); + } + + void + clear() _GLIBCXX_NOEXCEPT + { + _Base::clear(); + this->_M_invalidate_all(); + } + + // 23.2.2.4 list operations: + void +#if __cplusplus >= 201103L + splice(const_iterator __position, list&& __x) noexcept +#else + splice(iterator __position, list& __x) +#endif + { + _GLIBCXX_DEBUG_VERIFY(&__x != this, + _M_message(__gnu_debug::__msg_self_splice) + ._M_sequence(*this, "this")); + this->_M_transfer_from_if(__x, _Not_equal(__x._M_base().end())); + _Base::splice(__position.base(), _GLIBCXX_MOVE(__x._M_base())); + } + +#if __cplusplus >= 201103L + void + splice(const_iterator __position, list& __x) noexcept + { splice(__position, std::move(__x)); } +#endif + + void +#if __cplusplus >= 201103L + splice(const_iterator __position, list&& __x, const_iterator __i) noexcept +#else + splice(iterator __position, list& __x, iterator __i) +#endif + { + __glibcxx_check_insert(__position); + + // We used to perform the splice_alloc check: not anymore, redundant + // after implementing the relevant bits of N1599. + + _GLIBCXX_DEBUG_VERIFY(__i._M_dereferenceable(), + _M_message(__gnu_debug::__msg_splice_bad) + ._M_iterator(__i, "__i")); + _GLIBCXX_DEBUG_VERIFY(__i._M_attached_to(&__x), + _M_message(__gnu_debug::__msg_splice_other) + ._M_iterator(__i, "__i")._M_sequence(__x, "__x")); + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 250. splicing invalidates iterators + this->_M_transfer_from_if(__x, _Equal(__i.base())); + _Base::splice(__position.base(), _GLIBCXX_MOVE(__x._M_base()), + __i.base()); + } + +#if __cplusplus >= 201103L + void + splice(const_iterator __position, list& __x, const_iterator __i) noexcept + { splice(__position, std::move(__x), __i); } +#endif + + void +#if __cplusplus >= 201103L + splice(const_iterator __position, list&& __x, const_iterator __first, + const_iterator __last) noexcept +#else + splice(iterator __position, list& __x, iterator __first, + iterator __last) +#endif + { + __glibcxx_check_insert(__position); + __glibcxx_check_valid_range(__first, __last); + _GLIBCXX_DEBUG_VERIFY(__first._M_attached_to(&__x), + _M_message(__gnu_debug::__msg_splice_other) + ._M_sequence(__x, "x") + ._M_iterator(__first, "first")); + + // We used to perform the splice_alloc check: not anymore, redundant + // after implementing the relevant bits of N1599. + + for (_Base_const_iterator __tmp = __first.base(); + __tmp != __last.base(); ++__tmp) + { + _GLIBCXX_DEBUG_VERIFY(__tmp != _Base::end(), + _M_message(__gnu_debug::__msg_valid_range) + ._M_iterator(__first, "first") + ._M_iterator(__last, "last")); + _GLIBCXX_DEBUG_VERIFY(&__x != this || __tmp != __position.base(), + _M_message(__gnu_debug::__msg_splice_overlap) + ._M_iterator(__tmp, "position") + ._M_iterator(__first, "first") + ._M_iterator(__last, "last")); + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 250. splicing invalidates iterators + this->_M_transfer_from_if(__x, _Equal(__tmp)); + } + + _Base::splice(__position.base(), _GLIBCXX_MOVE(__x._M_base()), + __first.base(), __last.base()); + } + +#if __cplusplus >= 201103L + void + splice(const_iterator __position, list& __x, + const_iterator __first, const_iterator __last) noexcept + { splice(__position, std::move(__x), __first, __last); } +#endif + + void + remove(const _Tp& __value) + { + for (_Base_iterator __x = _Base::begin(); __x != _Base::end(); ) + { + if (*__x == __value) + __x = _M_erase(__x); + else + ++__x; + } + } + + template + void + remove_if(_Predicate __pred) + { + for (_Base_iterator __x = _Base::begin(); __x != _Base::end(); ) + { + if (__pred(*__x)) + __x = _M_erase(__x); + else + ++__x; + } + } + + void + unique() + { + _Base_iterator __first = _Base::begin(); + _Base_iterator __last = _Base::end(); + if (__first == __last) + return; + _Base_iterator __next = __first; ++__next; + while (__next != __last) + { + if (*__first == *__next) + __next = _M_erase(__next); + else + __first = __next++; + } + } + + template + void + unique(_BinaryPredicate __binary_pred) + { + _Base_iterator __first = _Base::begin(); + _Base_iterator __last = _Base::end(); + if (__first == __last) + return; + _Base_iterator __next = __first; ++__next; + while (__next != __last) + { + if (__binary_pred(*__first, *__next)) + __next = _M_erase(__next); + else + __first = __next++; + } + } + + void +#if __cplusplus >= 201103L + merge(list&& __x) +#else + merge(list& __x) +#endif + { + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 300. list::merge() specification incomplete + if (this != &__x) + { + __glibcxx_check_sorted(_Base::begin(), _Base::end()); + __glibcxx_check_sorted(__x.begin().base(), __x.end().base()); + this->_M_transfer_from_if(__x, _Not_equal(__x._M_base().end())); + _Base::merge(_GLIBCXX_MOVE(__x._M_base())); + } + } + +#if __cplusplus >= 201103L + void + merge(list& __x) + { merge(std::move(__x)); } +#endif + + template + void +#if __cplusplus >= 201103L + merge(list&& __x, _Compare __comp) +#else + merge(list& __x, _Compare __comp) +#endif + { + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 300. list::merge() specification incomplete + if (this != &__x) + { + __glibcxx_check_sorted_pred(_Base::begin(), _Base::end(), + __comp); + __glibcxx_check_sorted_pred(__x.begin().base(), __x.end().base(), + __comp); + this->_M_transfer_from_if(__x, _Not_equal(__x._M_base().end())); + _Base::merge(_GLIBCXX_MOVE(__x._M_base()), __comp); + } + } + +#if __cplusplus >= 201103L + template + void + merge(list& __x, _Compare __comp) + { merge(std::move(__x), __comp); } +#endif + + void + sort() { _Base::sort(); } + + template + void + sort(_StrictWeakOrdering __pred) { _Base::sort(__pred); } + + using _Base::reverse; + + _Base& + _M_base() _GLIBCXX_NOEXCEPT { return *this; } + + const _Base& + _M_base() const _GLIBCXX_NOEXCEPT { return *this; } + + private: + void + _M_invalidate_all() + { + this->_M_invalidate_if(_Not_equal(_Base::end())); + } + }; + + template + inline bool + operator==(const list<_Tp, _Alloc>& __lhs, + const list<_Tp, _Alloc>& __rhs) + { return __lhs._M_base() == __rhs._M_base(); } + + template + inline bool + operator!=(const list<_Tp, _Alloc>& __lhs, + const list<_Tp, _Alloc>& __rhs) + { return __lhs._M_base() != __rhs._M_base(); } + + template + inline bool + operator<(const list<_Tp, _Alloc>& __lhs, + const list<_Tp, _Alloc>& __rhs) + { return __lhs._M_base() < __rhs._M_base(); } + + template + inline bool + operator<=(const list<_Tp, _Alloc>& __lhs, + const list<_Tp, _Alloc>& __rhs) + { return __lhs._M_base() <= __rhs._M_base(); } + + template + inline bool + operator>=(const list<_Tp, _Alloc>& __lhs, + const list<_Tp, _Alloc>& __rhs) + { return __lhs._M_base() >= __rhs._M_base(); } + + template + inline bool + operator>(const list<_Tp, _Alloc>& __lhs, + const list<_Tp, _Alloc>& __rhs) + { return __lhs._M_base() > __rhs._M_base(); } + + template + inline void + swap(list<_Tp, _Alloc>& __lhs, list<_Tp, _Alloc>& __rhs) + { __lhs.swap(__rhs); } + +} // namespace __debug +} // namespace std + +#ifndef _GLIBCXX_DEBUG_PEDANTIC +namespace __gnu_debug +{ + template + struct _Insert_range_from_self_is_safe > + { enum { __value = 1 }; }; +} +#endif + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/macros.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/macros.h new file mode 100755 index 0000000..7ce374c --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/macros.h @@ -0,0 +1,364 @@ +// Debugging support implementation -*- C++ -*- + +// Copyright (C) 2003-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file debug/macros.h + * This file is a GNU debug extension to the Standard C++ Library. + */ + +#ifndef _GLIBCXX_DEBUG_MACROS_H +#define _GLIBCXX_DEBUG_MACROS_H 1 + +/** + * Macros used by the implementation to verify certain + * properties. These macros may only be used directly by the debug + * wrappers. Note that these are macros (instead of the more obviously + * @a correct choice of making them functions) because we need line and + * file information at the call site, to minimize the distance between + * the user error and where the error is reported. + * + */ +#define _GLIBCXX_DEBUG_VERIFY_AT(_Condition,_ErrorMessage,_File,_Line) \ + do \ + { \ + if (! (_Condition)) \ + __gnu_debug::_Error_formatter::_M_at(_File, _Line) \ + ._ErrorMessage._M_error(); \ + } while (false) + +#define _GLIBCXX_DEBUG_VERIFY(_Condition,_ErrorMessage) \ + _GLIBCXX_DEBUG_VERIFY_AT(_Condition,_ErrorMessage,__FILE__,__LINE__) + +// Verify that [_First, _Last) forms a valid iterator range. +#define __glibcxx_check_valid_range(_First,_Last) \ +_GLIBCXX_DEBUG_VERIFY(__gnu_debug::__valid_range(_First, _Last), \ + _M_message(__gnu_debug::__msg_valid_range) \ + ._M_iterator(_First, #_First) \ + ._M_iterator(_Last, #_Last)) + +// Verify that [_First, _Last) forms a non-empty iterator range. +#define __glibcxx_check_non_empty_range(_First,_Last) \ +_GLIBCXX_DEBUG_VERIFY(_First != _Last, \ + _M_message(__gnu_debug::__msg_non_empty_range) \ + ._M_iterator(_First, #_First) \ + ._M_iterator(_Last, #_Last)) + +/** Verify that we can insert into *this with the iterator _Position. + * Insertion into a container at a specific position requires that + * the iterator be nonsingular, either dereferenceable or past-the-end, + * and that it reference the sequence we are inserting into. Note that + * this macro is only valid when the container is a_Safe_sequence and + * the iterator is a _Safe_iterator. +*/ +#define __glibcxx_check_insert(_Position) \ +_GLIBCXX_DEBUG_VERIFY(!_Position._M_singular(), \ + _M_message(__gnu_debug::__msg_insert_singular) \ + ._M_sequence(*this, "this") \ + ._M_iterator(_Position, #_Position)); \ +_GLIBCXX_DEBUG_VERIFY(_Position._M_attached_to(this), \ + _M_message(__gnu_debug::__msg_insert_different) \ + ._M_sequence(*this, "this") \ + ._M_iterator(_Position, #_Position)) + +/** Verify that we can insert into *this after the iterator _Position. + * Insertion into a container after a specific position requires that + * the iterator be nonsingular, either dereferenceable or before-begin, + * and that it reference the sequence we are inserting into. Note that + * this macro is only valid when the container is a_Safe_sequence and + * the iterator is a _Safe_iterator. +*/ +#define __glibcxx_check_insert_after(_Position) \ +__glibcxx_check_insert(_Position); \ +_GLIBCXX_DEBUG_VERIFY(!_Position._M_is_end(), \ + _M_message(__gnu_debug::__msg_insert_after_end) \ + ._M_sequence(*this, "this") \ + ._M_iterator(_Position, #_Position)) + +/** Verify that we can insert the values in the iterator range + * [_First, _Last) into *this with the iterator _Position. Insertion + * into a container at a specific position requires that the iterator + * be nonsingular (i.e., either dereferenceable or past-the-end), + * that it reference the sequence we are inserting into, and that the + * iterator range [_First, _Last) is a valid (possibly empty) + * range which does not reference the sequence we are inserting into. + * Note that this macro is only valid when the container is a + * _Safe_sequence and the _Position iterator is a _Safe_iterator. +*/ +#define __glibcxx_check_insert_range(_Position,_First,_Last) \ +__glibcxx_check_valid_range(_First,_Last); \ +__glibcxx_check_insert(_Position); \ +_GLIBCXX_DEBUG_VERIFY(__gnu_debug::__foreign_iterator(_Position,_First,_Last),\ + _M_message(__gnu_debug::__msg_insert_range_from_self)\ + ._M_iterator(_First, #_First) \ + ._M_iterator(_Last, #_Last) \ + ._M_sequence(*this, "this")) + +/** Verify that we can insert the values in the iterator range + * [_First, _Last) into *this after the iterator _Position. Insertion + * into a container after a specific position requires that the iterator + * be nonsingular (i.e., either dereferenceable or past-the-end), + * that it reference the sequence we are inserting into, and that the + * iterator range [_First, _Last) is a valid (possibly empty) + * range which does not reference the sequence we are inserting into. + * Note that this macro is only valid when the container is a + * _Safe_sequence and the _Position iterator is a _Safe_iterator. +*/ +#define __glibcxx_check_insert_range_after(_Position,_First,_Last) \ +__glibcxx_check_valid_range(_First,_Last); \ +__glibcxx_check_insert_after(_Position); \ +_GLIBCXX_DEBUG_VERIFY(__gnu_debug::__foreign_iterator(_Position,_First,_Last),\ + _M_message(__gnu_debug::__msg_insert_range_from_self)\ + ._M_iterator(_First, #_First) \ + ._M_iterator(_Last, #_Last) \ + ._M_sequence(*this, "this")) + +/** Verify that we can erase the element referenced by the iterator + * _Position. We can erase the element if the _Position iterator is + * dereferenceable and references this sequence. +*/ +#define __glibcxx_check_erase(_Position) \ +_GLIBCXX_DEBUG_VERIFY(_Position._M_dereferenceable(), \ + _M_message(__gnu_debug::__msg_erase_bad) \ + ._M_sequence(*this, "this") \ + ._M_iterator(_Position, #_Position)); \ +_GLIBCXX_DEBUG_VERIFY(_Position._M_attached_to(this), \ + _M_message(__gnu_debug::__msg_erase_different) \ + ._M_sequence(*this, "this") \ + ._M_iterator(_Position, #_Position)) + +/** Verify that we can erase the element after the iterator + * _Position. We can erase the element if the _Position iterator is + * before a dereferenceable one and references this sequence. +*/ +#define __glibcxx_check_erase_after(_Position) \ +_GLIBCXX_DEBUG_VERIFY(_Position._M_before_dereferenceable(), \ + _M_message(__gnu_debug::__msg_erase_after_bad) \ + ._M_sequence(*this, "this") \ + ._M_iterator(_Position, #_Position)); \ +_GLIBCXX_DEBUG_VERIFY(_Position._M_attached_to(this), \ + _M_message(__gnu_debug::__msg_erase_different) \ + ._M_sequence(*this, "this") \ + ._M_iterator(_Position, #_Position)) + +/** Verify that we can erase the elements in the iterator range + * [_First, _Last). We can erase the elements if [_First, _Last) is a + * valid iterator range within this sequence. +*/ +#define __glibcxx_check_erase_range(_First,_Last) \ +__glibcxx_check_valid_range(_First,_Last); \ +_GLIBCXX_DEBUG_VERIFY(_First._M_attached_to(this), \ + _M_message(__gnu_debug::__msg_erase_different) \ + ._M_sequence(*this, "this") \ + ._M_iterator(_First, #_First) \ + ._M_iterator(_Last, #_Last)) + +/** Verify that we can erase the elements in the iterator range + * (_First, _Last). We can erase the elements if (_First, _Last) is a + * valid iterator range within this sequence. +*/ +#define __glibcxx_check_erase_range_after(_First,_Last) \ +_GLIBCXX_DEBUG_VERIFY(_First._M_can_compare(_Last), \ + _M_message(__gnu_debug::__msg_erase_different) \ + ._M_sequence(*this, "this") \ + ._M_iterator(_First, #_First) \ + ._M_iterator(_Last, #_Last)); \ +_GLIBCXX_DEBUG_VERIFY(_First._M_attached_to(this), \ + _M_message(__gnu_debug::__msg_erase_different) \ + ._M_sequence(*this, "this") \ + ._M_iterator(_First, #_First)); \ +_GLIBCXX_DEBUG_VERIFY(_First != _Last, \ + _M_message(__gnu_debug::__msg_valid_range2) \ + ._M_sequence(*this, "this") \ + ._M_iterator(_First, #_First) \ + ._M_iterator(_Last, #_Last)); \ +_GLIBCXX_DEBUG_VERIFY(_First._M_incrementable(), \ + _M_message(__gnu_debug::__msg_valid_range2) \ + ._M_sequence(*this, "this") \ + ._M_iterator(_First, #_First) \ + ._M_iterator(_Last, #_Last)); \ +_GLIBCXX_DEBUG_VERIFY(!_Last._M_is_before_begin(), \ + _M_message(__gnu_debug::__msg_valid_range2) \ + ._M_sequence(*this, "this") \ + ._M_iterator(_First, #_First) \ + ._M_iterator(_Last, #_Last)) \ + +// Verify that the subscript _N is less than the container's size. +#define __glibcxx_check_subscript(_N) \ +_GLIBCXX_DEBUG_VERIFY(_N < this->size(), \ + _M_message(__gnu_debug::__msg_subscript_oob) \ + ._M_sequence(*this, "this") \ + ._M_integer(_N, #_N) \ + ._M_integer(this->size(), "size")) + +// Verify that the bucket _N is less than the container's buckets count. +#define __glibcxx_check_bucket_index(_N) \ +_GLIBCXX_DEBUG_VERIFY(_N < this->bucket_count(), \ + _M_message(__gnu_debug::__msg_bucket_index_oob) \ + ._M_sequence(*this, "this") \ + ._M_integer(_N, #_N) \ + ._M_integer(this->bucket_count(), "size")) + +// Verify that the container is nonempty +#define __glibcxx_check_nonempty() \ +_GLIBCXX_DEBUG_VERIFY(! this->empty(), \ + _M_message(__gnu_debug::__msg_empty) \ + ._M_sequence(*this, "this")) + +// Verify that the iterator range [_First, _Last) is sorted +#define __glibcxx_check_sorted(_First,_Last) \ +__glibcxx_check_valid_range(_First,_Last); \ + _GLIBCXX_DEBUG_VERIFY(__gnu_debug::__check_sorted( \ + __gnu_debug::__base(_First), \ + __gnu_debug::__base(_Last)), \ + _M_message(__gnu_debug::__msg_unsorted) \ + ._M_iterator(_First, #_First) \ + ._M_iterator(_Last, #_Last)) + +/** Verify that the iterator range [_First, _Last) is sorted by the + predicate _Pred. */ +#define __glibcxx_check_sorted_pred(_First,_Last,_Pred) \ +__glibcxx_check_valid_range(_First,_Last); \ +_GLIBCXX_DEBUG_VERIFY(__gnu_debug::__check_sorted( \ + __gnu_debug::__base(_First), \ + __gnu_debug::__base(_Last), _Pred), \ + _M_message(__gnu_debug::__msg_unsorted_pred) \ + ._M_iterator(_First, #_First) \ + ._M_iterator(_Last, #_Last) \ + ._M_string(#_Pred)) + +// Special variant for std::merge, std::includes, std::set_* +#define __glibcxx_check_sorted_set(_First1,_Last1,_First2) \ +__glibcxx_check_valid_range(_First1,_Last1); \ +_GLIBCXX_DEBUG_VERIFY( \ + __gnu_debug::__check_sorted_set(__gnu_debug::__base(_First1), \ + __gnu_debug::__base(_Last1), _First2),\ + _M_message(__gnu_debug::__msg_unsorted) \ + ._M_iterator(_First1, #_First1) \ + ._M_iterator(_Last1, #_Last1)) + +// Likewise with a _Pred. +#define __glibcxx_check_sorted_set_pred(_First1,_Last1,_First2,_Pred) \ +__glibcxx_check_valid_range(_First1,_Last1); \ +_GLIBCXX_DEBUG_VERIFY( \ + __gnu_debug::__check_sorted_set(__gnu_debug::__base(_First1), \ + __gnu_debug::__base(_Last1), \ + _First2, _Pred), \ + _M_message(__gnu_debug::__msg_unsorted_pred) \ + ._M_iterator(_First1, #_First1) \ + ._M_iterator(_Last1, #_Last1) \ + ._M_string(#_Pred)) + +/** Verify that the iterator range [_First, _Last) is partitioned + w.r.t. the value _Value. */ +#define __glibcxx_check_partitioned_lower(_First,_Last,_Value) \ +__glibcxx_check_valid_range(_First,_Last); \ +_GLIBCXX_DEBUG_VERIFY(__gnu_debug::__check_partitioned_lower( \ + __gnu_debug::__base(_First), \ + __gnu_debug::__base(_Last), _Value), \ + _M_message(__gnu_debug::__msg_unpartitioned) \ + ._M_iterator(_First, #_First) \ + ._M_iterator(_Last, #_Last) \ + ._M_string(#_Value)) + +#define __glibcxx_check_partitioned_upper(_First,_Last,_Value) \ +__glibcxx_check_valid_range(_First,_Last); \ +_GLIBCXX_DEBUG_VERIFY(__gnu_debug::__check_partitioned_upper( \ + __gnu_debug::__base(_First), \ + __gnu_debug::__base(_Last), _Value), \ + _M_message(__gnu_debug::__msg_unpartitioned) \ + ._M_iterator(_First, #_First) \ + ._M_iterator(_Last, #_Last) \ + ._M_string(#_Value)) + +/** Verify that the iterator range [_First, _Last) is partitioned + w.r.t. the value _Value and predicate _Pred. */ +#define __glibcxx_check_partitioned_lower_pred(_First,_Last,_Value,_Pred) \ +__glibcxx_check_valid_range(_First,_Last); \ +_GLIBCXX_DEBUG_VERIFY(__gnu_debug::__check_partitioned_lower( \ + __gnu_debug::__base(_First), \ + __gnu_debug::__base(_Last), _Value, _Pred), \ + _M_message(__gnu_debug::__msg_unpartitioned_pred) \ + ._M_iterator(_First, #_First) \ + ._M_iterator(_Last, #_Last) \ + ._M_string(#_Pred) \ + ._M_string(#_Value)) + +/** Verify that the iterator range [_First, _Last) is partitioned + w.r.t. the value _Value and predicate _Pred. */ +#define __glibcxx_check_partitioned_upper_pred(_First,_Last,_Value,_Pred) \ +__glibcxx_check_valid_range(_First,_Last); \ +_GLIBCXX_DEBUG_VERIFY(__gnu_debug::__check_partitioned_upper( \ + __gnu_debug::__base(_First), \ + __gnu_debug::__base(_Last), _Value, _Pred), \ + _M_message(__gnu_debug::__msg_unpartitioned_pred) \ + ._M_iterator(_First, #_First) \ + ._M_iterator(_Last, #_Last) \ + ._M_string(#_Pred) \ + ._M_string(#_Value)) + +// Verify that the iterator range [_First, _Last) is a heap +#define __glibcxx_check_heap(_First,_Last) \ + _GLIBCXX_DEBUG_VERIFY(std::__is_heap(__gnu_debug::__base(_First), \ + __gnu_debug::__base(_Last)), \ + _M_message(__gnu_debug::__msg_not_heap) \ + ._M_iterator(_First, #_First) \ + ._M_iterator(_Last, #_Last)) + +/** Verify that the iterator range [_First, _Last) is a heap + w.r.t. the predicate _Pred. */ +#define __glibcxx_check_heap_pred(_First,_Last,_Pred) \ + _GLIBCXX_DEBUG_VERIFY(std::__is_heap(__gnu_debug::__base(_First), \ + __gnu_debug::__base(_Last), \ + _Pred), \ + _M_message(__gnu_debug::__msg_not_heap_pred) \ + ._M_iterator(_First, #_First) \ + ._M_iterator(_Last, #_Last) \ + ._M_string(#_Pred)) + +// Verify that the container is not self move assigned +#define __glibcxx_check_self_move_assign(_Other) \ +_GLIBCXX_DEBUG_VERIFY(this != &_Other, \ + _M_message(__gnu_debug::__msg_self_move_assign) \ + ._M_sequence(*this, "this")) + +// Verify that load factor is positive +#define __glibcxx_check_max_load_factor(_F) \ +_GLIBCXX_DEBUG_VERIFY(_F > 0.0f, \ + _M_message(__gnu_debug::__msg_valid_load_factor) \ + ._M_sequence(*this, "this")) + +#define __glibcxx_check_equal_allocs(_Other) \ +_GLIBCXX_DEBUG_VERIFY(this->get_allocator() == _Other.get_allocator(), \ + _M_message(__gnu_debug::__msg_equal_allocs) \ + ._M_sequence(*this, "this")) + +#ifdef _GLIBCXX_DEBUG_PEDANTIC +# define __glibcxx_check_string(_String) _GLIBCXX_DEBUG_ASSERT(_String != 0) +# define __glibcxx_check_string_len(_String,_Len) \ + _GLIBCXX_DEBUG_ASSERT(_String != 0 || _Len == 0) +#else +# define __glibcxx_check_string(_String) +# define __glibcxx_check_string_len(_String,_Len) +#endif + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/map b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/map new file mode 100755 index 0000000..bacb0d3 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/map @@ -0,0 +1,36 @@ +// Debugging map/multimap implementation -*- C++ -*- + +// Copyright (C) 2003-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file debug/map + * This file is a GNU debug extension to the Standard C++ Library. + */ + +#ifndef _GLIBCXX_DEBUG_MAP +#define _GLIBCXX_DEBUG_MAP 1 + +#include +#include +#include + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/map.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/map.h new file mode 100755 index 0000000..fda6ac1 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/map.h @@ -0,0 +1,532 @@ +// Debugging map implementation -*- C++ -*- + +// Copyright (C) 2003-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file debug/map.h + * This file is a GNU debug extension to the Standard C++ Library. + */ + +#ifndef _GLIBCXX_DEBUG_MAP_H +#define _GLIBCXX_DEBUG_MAP_H 1 + +#include +#include +#include + +namespace std _GLIBCXX_VISIBILITY(default) +{ +namespace __debug +{ + /// Class std::map with safety/checking/debug instrumentation. + template, + typename _Allocator = std::allocator > > + class map + : public _GLIBCXX_STD_C::map<_Key, _Tp, _Compare, _Allocator>, + public __gnu_debug::_Safe_sequence > + { + typedef _GLIBCXX_STD_C::map<_Key, _Tp, _Compare, _Allocator> _Base; + + typedef typename _Base::const_iterator _Base_const_iterator; + typedef typename _Base::iterator _Base_iterator; + typedef __gnu_debug::_Equal_to<_Base_const_iterator> _Equal; + +#if __cplusplus >= 201103L + typedef __gnu_cxx::__alloc_traits _Alloc_traits; +#endif + public: + // types: + typedef _Key key_type; + typedef _Tp mapped_type; + typedef std::pair value_type; + typedef _Compare key_compare; + typedef _Allocator allocator_type; + typedef typename _Base::reference reference; + typedef typename _Base::const_reference const_reference; + + typedef __gnu_debug::_Safe_iterator<_Base_iterator, map> + iterator; + typedef __gnu_debug::_Safe_iterator<_Base_const_iterator, map> + const_iterator; + + typedef typename _Base::size_type size_type; + typedef typename _Base::difference_type difference_type; + typedef typename _Base::pointer pointer; + typedef typename _Base::const_pointer const_pointer; + typedef std::reverse_iterator reverse_iterator; + typedef std::reverse_iterator const_reverse_iterator; + + // 23.3.1.1 construct/copy/destroy: + + map() : _Base() { } + + explicit map(const _Compare& __comp, + const _Allocator& __a = _Allocator()) + : _Base(__comp, __a) { } + + template + map(_InputIterator __first, _InputIterator __last, + const _Compare& __comp = _Compare(), + const _Allocator& __a = _Allocator()) + : _Base(__gnu_debug::__base(__gnu_debug::__check_valid_range(__first, + __last)), + __gnu_debug::__base(__last), + __comp, __a) { } + + map(const map& __x) + : _Base(__x) { } + + map(const _Base& __x) + : _Base(__x) { } + +#if __cplusplus >= 201103L + map(map&& __x) + noexcept(is_nothrow_copy_constructible<_Compare>::value) + : _Base(std::move(__x)) + { this->_M_swap(__x); } + + map(initializer_list __l, + const _Compare& __c = _Compare(), + const allocator_type& __a = allocator_type()) + : _Base(__l, __c, __a) { } + + explicit + map(const allocator_type& __a) + : _Base(__a) { } + + map(const map& __m, const allocator_type& __a) + : _Base(__m, __a) { } + + map(map&& __m, const allocator_type& __a) + : _Base(std::move(__m._M_base()), __a) { } + + map(initializer_list __l, const allocator_type& __a) + : _Base(__l, __a) { } + + template + map(_InputIterator __first, _InputIterator __last, + const allocator_type& __a) + : _Base(__gnu_debug::__base(__gnu_debug::__check_valid_range(__first, + __last)), + __gnu_debug::__base(__last), __a) + { } +#endif + + ~map() _GLIBCXX_NOEXCEPT { } + + map& + operator=(const map& __x) + { + _M_base() = __x; + this->_M_invalidate_all(); + return *this; + } + +#if __cplusplus >= 201103L + map& + operator=(map&& __x) + noexcept(_Alloc_traits::_S_nothrow_move()) + { + __glibcxx_check_self_move_assign(__x); + bool __xfer_memory = _Alloc_traits::_S_propagate_on_move_assign() + || __x.get_allocator() == this->get_allocator(); + _M_base() = std::move(__x._M_base()); + if (__xfer_memory) + this->_M_swap(__x); + else + this->_M_invalidate_all(); + __x._M_invalidate_all(); + return *this; + } + + map& + operator=(initializer_list __l) + { + _M_base() = __l; + this->_M_invalidate_all(); + return *this; + } +#endif + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 133. map missing get_allocator() + using _Base::get_allocator; + + // iterators: + iterator + begin() _GLIBCXX_NOEXCEPT + { return iterator(_Base::begin(), this); } + + const_iterator + begin() const _GLIBCXX_NOEXCEPT + { return const_iterator(_Base::begin(), this); } + + iterator + end() _GLIBCXX_NOEXCEPT + { return iterator(_Base::end(), this); } + + const_iterator + end() const _GLIBCXX_NOEXCEPT + { return const_iterator(_Base::end(), this); } + + reverse_iterator + rbegin() _GLIBCXX_NOEXCEPT + { return reverse_iterator(end()); } + + const_reverse_iterator + rbegin() const _GLIBCXX_NOEXCEPT + { return const_reverse_iterator(end()); } + + reverse_iterator + rend() _GLIBCXX_NOEXCEPT + { return reverse_iterator(begin()); } + + const_reverse_iterator + rend() const _GLIBCXX_NOEXCEPT + { return const_reverse_iterator(begin()); } + +#if __cplusplus >= 201103L + const_iterator + cbegin() const noexcept + { return const_iterator(_Base::begin(), this); } + + const_iterator + cend() const noexcept + { return const_iterator(_Base::end(), this); } + + const_reverse_iterator + crbegin() const noexcept + { return const_reverse_iterator(end()); } + + const_reverse_iterator + crend() const noexcept + { return const_reverse_iterator(begin()); } +#endif + + // capacity: + using _Base::empty; + using _Base::size; + using _Base::max_size; + + // 23.3.1.2 element access: + using _Base::operator[]; + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR 464. Suggestion for new member functions in standard containers. + using _Base::at; + + // modifiers: +#if __cplusplus >= 201103L + template + std::pair + emplace(_Args&&... __args) + { + auto __res = _Base::emplace(std::forward<_Args>(__args)...); + return std::pair(iterator(__res.first, this), + __res.second); + } + + template + iterator + emplace_hint(const_iterator __pos, _Args&&... __args) + { + __glibcxx_check_insert(__pos); + return iterator(_Base::emplace_hint(__pos.base(), + std::forward<_Args>(__args)...), + this); + } +#endif + + std::pair + insert(const value_type& __x) + { + std::pair<_Base_iterator, bool> __res = _Base::insert(__x); + return std::pair(iterator(__res.first, this), + __res.second); + } + +#if __cplusplus >= 201103L + template::value>::type> + std::pair + insert(_Pair&& __x) + { + std::pair<_Base_iterator, bool> __res + = _Base::insert(std::forward<_Pair>(__x)); + return std::pair(iterator(__res.first, this), + __res.second); + } +#endif + +#if __cplusplus >= 201103L + void + insert(std::initializer_list __list) + { _Base::insert(__list); } +#endif + + iterator +#if __cplusplus >= 201103L + insert(const_iterator __position, const value_type& __x) +#else + insert(iterator __position, const value_type& __x) +#endif + { + __glibcxx_check_insert(__position); + return iterator(_Base::insert(__position.base(), __x), this); + } + +#if __cplusplus >= 201103L + template::value>::type> + iterator + insert(const_iterator __position, _Pair&& __x) + { + __glibcxx_check_insert(__position); + return iterator(_Base::insert(__position.base(), + std::forward<_Pair>(__x)), this); + } +#endif + + template + void + insert(_InputIterator __first, _InputIterator __last) + { + __glibcxx_check_valid_range(__first, __last); + _Base::insert(__gnu_debug::__base(__first), + __gnu_debug::__base(__last)); + } + +#if __cplusplus >= 201103L + iterator + erase(const_iterator __position) + { + __glibcxx_check_erase(__position); + this->_M_invalidate_if(_Equal(__position.base())); + return iterator(_Base::erase(__position.base()), this); + } + + iterator + erase(iterator __position) + { return erase(const_iterator(__position)); } +#else + void + erase(iterator __position) + { + __glibcxx_check_erase(__position); + this->_M_invalidate_if(_Equal(__position.base())); + _Base::erase(__position.base()); + } +#endif + + size_type + erase(const key_type& __x) + { + _Base_iterator __victim = _Base::find(__x); + if (__victim == _Base::end()) + return 0; + else + { + this->_M_invalidate_if(_Equal(__victim)); + _Base::erase(__victim); + return 1; + } + } + +#if __cplusplus >= 201103L + iterator + erase(const_iterator __first, const_iterator __last) + { + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 151. can't currently clear() empty container + __glibcxx_check_erase_range(__first, __last); + for (_Base_const_iterator __victim = __first.base(); + __victim != __last.base(); ++__victim) + { + _GLIBCXX_DEBUG_VERIFY(__victim != _Base::end(), + _M_message(__gnu_debug::__msg_valid_range) + ._M_iterator(__first, "first") + ._M_iterator(__last, "last")); + this->_M_invalidate_if(_Equal(__victim)); + } + return iterator(_Base::erase(__first.base(), __last.base()), this); + } +#else + void + erase(iterator __first, iterator __last) + { + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 151. can't currently clear() empty container + __glibcxx_check_erase_range(__first, __last); + for (_Base_iterator __victim = __first.base(); + __victim != __last.base(); ++__victim) + { + _GLIBCXX_DEBUG_VERIFY(__victim != _Base::end(), + _M_message(__gnu_debug::__msg_valid_range) + ._M_iterator(__first, "first") + ._M_iterator(__last, "last")); + this->_M_invalidate_if(_Equal(__victim)); + } + _Base::erase(__first.base(), __last.base()); + } +#endif + + void + swap(map& __x) +#if __cplusplus >= 201103L + noexcept(_Alloc_traits::_S_nothrow_swap()) +#endif + { +#if __cplusplus >= 201103L + if (!_Alloc_traits::_S_propagate_on_swap()) + __glibcxx_check_equal_allocs(__x); +#endif + _Base::swap(__x); + this->_M_swap(__x); + } + + void + clear() _GLIBCXX_NOEXCEPT + { + this->_M_invalidate_all(); + _Base::clear(); + } + + // observers: + using _Base::key_comp; + using _Base::value_comp; + + // 23.3.1.3 map operations: + iterator + find(const key_type& __x) + { return iterator(_Base::find(__x), this); } + + const_iterator + find(const key_type& __x) const + { return const_iterator(_Base::find(__x), this); } + + using _Base::count; + + iterator + lower_bound(const key_type& __x) + { return iterator(_Base::lower_bound(__x), this); } + + const_iterator + lower_bound(const key_type& __x) const + { return const_iterator(_Base::lower_bound(__x), this); } + + iterator + upper_bound(const key_type& __x) + { return iterator(_Base::upper_bound(__x), this); } + + const_iterator + upper_bound(const key_type& __x) const + { return const_iterator(_Base::upper_bound(__x), this); } + + std::pair + equal_range(const key_type& __x) + { + std::pair<_Base_iterator, _Base_iterator> __res = + _Base::equal_range(__x); + return std::make_pair(iterator(__res.first, this), + iterator(__res.second, this)); + } + + std::pair + equal_range(const key_type& __x) const + { + std::pair<_Base_const_iterator, _Base_const_iterator> __res = + _Base::equal_range(__x); + return std::make_pair(const_iterator(__res.first, this), + const_iterator(__res.second, this)); + } + + _Base& + _M_base() _GLIBCXX_NOEXCEPT { return *this; } + + const _Base& + _M_base() const _GLIBCXX_NOEXCEPT { return *this; } + + private: + void + _M_invalidate_all() + { + typedef __gnu_debug::_Not_equal_to<_Base_const_iterator> _Not_equal; + this->_M_invalidate_if(_Not_equal(_M_base().end())); + } + }; + + template + inline bool + operator==(const map<_Key, _Tp, _Compare, _Allocator>& __lhs, + const map<_Key, _Tp, _Compare, _Allocator>& __rhs) + { return __lhs._M_base() == __rhs._M_base(); } + + template + inline bool + operator!=(const map<_Key, _Tp, _Compare, _Allocator>& __lhs, + const map<_Key, _Tp, _Compare, _Allocator>& __rhs) + { return __lhs._M_base() != __rhs._M_base(); } + + template + inline bool + operator<(const map<_Key, _Tp, _Compare, _Allocator>& __lhs, + const map<_Key, _Tp, _Compare, _Allocator>& __rhs) + { return __lhs._M_base() < __rhs._M_base(); } + + template + inline bool + operator<=(const map<_Key, _Tp, _Compare, _Allocator>& __lhs, + const map<_Key, _Tp, _Compare, _Allocator>& __rhs) + { return __lhs._M_base() <= __rhs._M_base(); } + + template + inline bool + operator>=(const map<_Key, _Tp, _Compare, _Allocator>& __lhs, + const map<_Key, _Tp, _Compare, _Allocator>& __rhs) + { return __lhs._M_base() >= __rhs._M_base(); } + + template + inline bool + operator>(const map<_Key, _Tp, _Compare, _Allocator>& __lhs, + const map<_Key, _Tp, _Compare, _Allocator>& __rhs) + { return __lhs._M_base() > __rhs._M_base(); } + + template + inline void + swap(map<_Key, _Tp, _Compare, _Allocator>& __lhs, + map<_Key, _Tp, _Compare, _Allocator>& __rhs) + { __lhs.swap(__rhs); } + +} // namespace __debug +} // namespace std + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/multimap.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/multimap.h new file mode 100755 index 0000000..4c3a3eb --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/multimap.h @@ -0,0 +1,516 @@ +// Debugging multimap implementation -*- C++ -*- + +// Copyright (C) 2003-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file debug/multimap.h + * This file is a GNU debug extension to the Standard C++ Library. + */ + +#ifndef _GLIBCXX_DEBUG_MULTIMAP_H +#define _GLIBCXX_DEBUG_MULTIMAP_H 1 + +#include +#include +#include + +namespace std _GLIBCXX_VISIBILITY(default) +{ +namespace __debug +{ + /// Class std::multimap with safety/checking/debug instrumentation. + template, + typename _Allocator = std::allocator > > + class multimap + : public _GLIBCXX_STD_C::multimap<_Key, _Tp, _Compare, _Allocator>, + public __gnu_debug::_Safe_sequence > + { + typedef _GLIBCXX_STD_C::multimap<_Key, _Tp, _Compare, _Allocator> _Base; + + typedef typename _Base::const_iterator _Base_const_iterator; + typedef typename _Base::iterator _Base_iterator; + typedef __gnu_debug::_Equal_to<_Base_const_iterator> _Equal; + +#if __cplusplus >= 201103L + typedef __gnu_cxx::__alloc_traits _Alloc_traits; +#endif + public: + // types: + typedef _Key key_type; + typedef _Tp mapped_type; + typedef std::pair value_type; + typedef _Compare key_compare; + typedef _Allocator allocator_type; + typedef typename _Base::reference reference; + typedef typename _Base::const_reference const_reference; + + typedef __gnu_debug::_Safe_iterator<_Base_iterator, multimap> + iterator; + typedef __gnu_debug::_Safe_iterator<_Base_const_iterator, + multimap> const_iterator; + + typedef typename _Base::size_type size_type; + typedef typename _Base::difference_type difference_type; + typedef typename _Base::pointer pointer; + typedef typename _Base::const_pointer const_pointer; + typedef std::reverse_iterator reverse_iterator; + typedef std::reverse_iterator const_reverse_iterator; + + // 23.3.1.1 construct/copy/destroy: + + multimap() : _Base() { } + + explicit multimap(const _Compare& __comp, + const _Allocator& __a = _Allocator()) + : _Base(__comp, __a) { } + + template + multimap(_InputIterator __first, _InputIterator __last, + const _Compare& __comp = _Compare(), + const _Allocator& __a = _Allocator()) + : _Base(__gnu_debug::__base(__gnu_debug::__check_valid_range(__first, + __last)), + __gnu_debug::__base(__last), + __comp, __a) { } + + multimap(const multimap& __x) + : _Base(__x) { } + + multimap(const _Base& __x) + : _Base(__x) { } + +#if __cplusplus >= 201103L + multimap(multimap&& __x) + noexcept(is_nothrow_copy_constructible<_Compare>::value) + : _Base(std::move(__x)) + { this->_M_swap(__x); } + + multimap(initializer_list __l, + const _Compare& __c = _Compare(), + const allocator_type& __a = allocator_type()) + : _Base(__l, __c, __a) { } + + explicit + multimap(const allocator_type& __a) + : _Base(__a) { } + + multimap(const multimap& __m, const allocator_type& __a) + : _Base(__m, __a) { } + + multimap(multimap&& __m, const allocator_type& __a) + : _Base(std::move(__m._M_base()), __a) { } + + multimap(initializer_list __l, const allocator_type& __a) + : _Base(__l, __a) + { } + + template + multimap(_InputIterator __first, _InputIterator __last, + const allocator_type& __a) + : _Base(__gnu_debug::__base(__gnu_debug::__check_valid_range(__first, + __last)), + __gnu_debug::__base(__last), __a) + { } +#endif + + ~multimap() _GLIBCXX_NOEXCEPT { } + + multimap& + operator=(const multimap& __x) + { + _M_base() = __x; + this->_M_invalidate_all(); + return *this; + } + +#if __cplusplus >= 201103L + multimap& + operator=(multimap&& __x) + noexcept(_Alloc_traits::_S_nothrow_move()) + { + __glibcxx_check_self_move_assign(__x); + bool __xfer_memory = _Alloc_traits::_S_propagate_on_move_assign() + || __x.get_allocator() == this->get_allocator(); + _M_base() = std::move(__x._M_base()); + if (__xfer_memory) + this->_M_swap(__x); + else + this->_M_invalidate_all(); + __x._M_invalidate_all(); + return *this; + } + + multimap& + operator=(initializer_list __l) + { + _M_base() = __l; + this->_M_invalidate_all(); + return *this; + } +#endif + + using _Base::get_allocator; + + // iterators: + iterator + begin() _GLIBCXX_NOEXCEPT + { return iterator(_Base::begin(), this); } + + const_iterator + begin() const _GLIBCXX_NOEXCEPT + { return const_iterator(_Base::begin(), this); } + + iterator + end() _GLIBCXX_NOEXCEPT + { return iterator(_Base::end(), this); } + + const_iterator + end() const _GLIBCXX_NOEXCEPT + { return const_iterator(_Base::end(), this); } + + reverse_iterator + rbegin() _GLIBCXX_NOEXCEPT + { return reverse_iterator(end()); } + + const_reverse_iterator + rbegin() const _GLIBCXX_NOEXCEPT + { return const_reverse_iterator(end()); } + + reverse_iterator + rend() _GLIBCXX_NOEXCEPT + { return reverse_iterator(begin()); } + + const_reverse_iterator + rend() const _GLIBCXX_NOEXCEPT + { return const_reverse_iterator(begin()); } + +#if __cplusplus >= 201103L + const_iterator + cbegin() const noexcept + { return const_iterator(_Base::begin(), this); } + + const_iterator + cend() const noexcept + { return const_iterator(_Base::end(), this); } + + const_reverse_iterator + crbegin() const noexcept + { return const_reverse_iterator(end()); } + + const_reverse_iterator + crend() const noexcept + { return const_reverse_iterator(begin()); } +#endif + + // capacity: + using _Base::empty; + using _Base::size; + using _Base::max_size; + + // modifiers: +#if __cplusplus >= 201103L + template + iterator + emplace(_Args&&... __args) + { + return iterator(_Base::emplace(std::forward<_Args>(__args)...), this); + } + + template + iterator + emplace_hint(const_iterator __pos, _Args&&... __args) + { + __glibcxx_check_insert(__pos); + return iterator(_Base::emplace_hint(__pos.base(), + std::forward<_Args>(__args)...), + this); + } +#endif + + iterator + insert(const value_type& __x) + { return iterator(_Base::insert(__x), this); } + +#if __cplusplus >= 201103L + template::value>::type> + iterator + insert(_Pair&& __x) + { return iterator(_Base::insert(std::forward<_Pair>(__x)), this); } +#endif + +#if __cplusplus >= 201103L + void + insert(std::initializer_list __list) + { _Base::insert(__list); } +#endif + + iterator +#if __cplusplus >= 201103L + insert(const_iterator __position, const value_type& __x) +#else + insert(iterator __position, const value_type& __x) +#endif + { + __glibcxx_check_insert(__position); + return iterator(_Base::insert(__position.base(), __x), this); + } + +#if __cplusplus >= 201103L + template::value>::type> + iterator + insert(const_iterator __position, _Pair&& __x) + { + __glibcxx_check_insert(__position); + return iterator(_Base::insert(__position.base(), + std::forward<_Pair>(__x)), this); + } +#endif + + template + void + insert(_InputIterator __first, _InputIterator __last) + { + __glibcxx_check_valid_range(__first, __last); + _Base::insert(__gnu_debug::__base(__first), + __gnu_debug::__base(__last)); + } + +#if __cplusplus >= 201103L + iterator + erase(const_iterator __position) + { + __glibcxx_check_erase(__position); + this->_M_invalidate_if(_Equal(__position.base())); + return iterator(_Base::erase(__position.base()), this); + } + + iterator + erase(iterator __position) + { return erase(const_iterator(__position)); } +#else + void + erase(iterator __position) + { + __glibcxx_check_erase(__position); + this->_M_invalidate_if(_Equal(__position.base())); + _Base::erase(__position.base()); + } +#endif + + size_type + erase(const key_type& __x) + { + std::pair<_Base_iterator, _Base_iterator> __victims = + _Base::equal_range(__x); + size_type __count = 0; + _Base_iterator __victim = __victims.first; + while (__victim != __victims.second) + { + this->_M_invalidate_if(_Equal(__victim)); + _Base::erase(__victim++); + ++__count; + } + return __count; + } + +#if __cplusplus >= 201103L + iterator + erase(const_iterator __first, const_iterator __last) + { + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 151. can't currently clear() empty container + __glibcxx_check_erase_range(__first, __last); + for (_Base_const_iterator __victim = __first.base(); + __victim != __last.base(); ++__victim) + { + _GLIBCXX_DEBUG_VERIFY(__victim != _Base::end(), + _M_message(__gnu_debug::__msg_valid_range) + ._M_iterator(__first, "first") + ._M_iterator(__last, "last")); + this->_M_invalidate_if(_Equal(__victim)); + } + return iterator(_Base::erase(__first.base(), __last.base()), this); + } +#else + void + erase(iterator __first, iterator __last) + { + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 151. can't currently clear() empty container + __glibcxx_check_erase_range(__first, __last); + for (_Base_iterator __victim = __first.base(); + __victim != __last.base(); ++__victim) + { + _GLIBCXX_DEBUG_VERIFY(__victim != _Base::end(), + _M_message(__gnu_debug::__msg_valid_range) + ._M_iterator(__first, "first") + ._M_iterator(__last, "last")); + this->_M_invalidate_if(_Equal(__victim)); + } + _Base::erase(__first.base(), __last.base()); + } +#endif + + void + swap(multimap& __x) +#if __cplusplus >= 201103L + noexcept(_Alloc_traits::_S_nothrow_swap()) +#endif + { +#if __cplusplus >= 201103L + if (!_Alloc_traits::_S_propagate_on_swap()) + __glibcxx_check_equal_allocs(__x); +#endif + _Base::swap(__x); + this->_M_swap(__x); + } + + void + clear() _GLIBCXX_NOEXCEPT + { + this->_M_invalidate_all(); + _Base::clear(); + } + + // observers: + using _Base::key_comp; + using _Base::value_comp; + + // 23.3.1.3 multimap operations: + iterator + find(const key_type& __x) + { return iterator(_Base::find(__x), this); } + + const_iterator + find(const key_type& __x) const + { return const_iterator(_Base::find(__x), this); } + + using _Base::count; + + iterator + lower_bound(const key_type& __x) + { return iterator(_Base::lower_bound(__x), this); } + + const_iterator + lower_bound(const key_type& __x) const + { return const_iterator(_Base::lower_bound(__x), this); } + + iterator + upper_bound(const key_type& __x) + { return iterator(_Base::upper_bound(__x), this); } + + const_iterator + upper_bound(const key_type& __x) const + { return const_iterator(_Base::upper_bound(__x), this); } + + std::pair + equal_range(const key_type& __x) + { + std::pair<_Base_iterator, _Base_iterator> __res = + _Base::equal_range(__x); + return std::make_pair(iterator(__res.first, this), + iterator(__res.second, this)); + } + + std::pair + equal_range(const key_type& __x) const + { + std::pair<_Base_const_iterator, _Base_const_iterator> __res = + _Base::equal_range(__x); + return std::make_pair(const_iterator(__res.first, this), + const_iterator(__res.second, this)); + } + + _Base& + _M_base() _GLIBCXX_NOEXCEPT { return *this; } + + const _Base& + _M_base() const _GLIBCXX_NOEXCEPT { return *this; } + + private: + void + _M_invalidate_all() + { + typedef __gnu_debug::_Not_equal_to<_Base_const_iterator> _Not_equal; + this->_M_invalidate_if(_Not_equal(_Base::end())); + } + }; + + template + inline bool + operator==(const multimap<_Key, _Tp, _Compare, _Allocator>& __lhs, + const multimap<_Key, _Tp, _Compare, _Allocator>& __rhs) + { return __lhs._M_base() == __rhs._M_base(); } + + template + inline bool + operator!=(const multimap<_Key, _Tp, _Compare, _Allocator>& __lhs, + const multimap<_Key, _Tp, _Compare, _Allocator>& __rhs) + { return __lhs._M_base() != __rhs._M_base(); } + + template + inline bool + operator<(const multimap<_Key, _Tp, _Compare, _Allocator>& __lhs, + const multimap<_Key, _Tp, _Compare, _Allocator>& __rhs) + { return __lhs._M_base() < __rhs._M_base(); } + + template + inline bool + operator<=(const multimap<_Key, _Tp, _Compare, _Allocator>& __lhs, + const multimap<_Key, _Tp, _Compare, _Allocator>& __rhs) + { return __lhs._M_base() <= __rhs._M_base(); } + + template + inline bool + operator>=(const multimap<_Key, _Tp, _Compare, _Allocator>& __lhs, + const multimap<_Key, _Tp, _Compare, _Allocator>& __rhs) + { return __lhs._M_base() >= __rhs._M_base(); } + + template + inline bool + operator>(const multimap<_Key, _Tp, _Compare, _Allocator>& __lhs, + const multimap<_Key, _Tp, _Compare, _Allocator>& __rhs) + { return __lhs._M_base() > __rhs._M_base(); } + + template + inline void + swap(multimap<_Key, _Tp, _Compare, _Allocator>& __lhs, + multimap<_Key, _Tp, _Compare, _Allocator>& __rhs) + { __lhs.swap(__rhs); } + +} // namespace __debug +} // namespace std + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/multiset.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/multiset.h new file mode 100755 index 0000000..ae62bf8 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/multiset.h @@ -0,0 +1,502 @@ +// Debugging multiset implementation -*- C++ -*- + +// Copyright (C) 2003-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file debug/multiset.h + * This file is a GNU debug extension to the Standard C++ Library. + */ + +#ifndef _GLIBCXX_DEBUG_MULTISET_H +#define _GLIBCXX_DEBUG_MULTISET_H 1 + +#include +#include +#include + +namespace std _GLIBCXX_VISIBILITY(default) +{ +namespace __debug +{ + /// Class std::multiset with safety/checking/debug instrumentation. + template, + typename _Allocator = std::allocator<_Key> > + class multiset + : public _GLIBCXX_STD_C::multiset<_Key, _Compare, _Allocator>, + public __gnu_debug::_Safe_sequence > + { + typedef _GLIBCXX_STD_C::multiset<_Key, _Compare, _Allocator> _Base; + + typedef typename _Base::const_iterator _Base_const_iterator; + typedef typename _Base::iterator _Base_iterator; + typedef __gnu_debug::_Equal_to<_Base_const_iterator> _Equal; + +#if __cplusplus >= 201103L + typedef __gnu_cxx::__alloc_traits _Alloc_traits; +#endif + public: + // types: + typedef _Key key_type; + typedef _Key value_type; + typedef _Compare key_compare; + typedef _Compare value_compare; + typedef _Allocator allocator_type; + typedef typename _Base::reference reference; + typedef typename _Base::const_reference const_reference; + + typedef __gnu_debug::_Safe_iterator<_Base_iterator, multiset> + iterator; + typedef __gnu_debug::_Safe_iterator<_Base_const_iterator, + multiset> const_iterator; + + typedef typename _Base::size_type size_type; + typedef typename _Base::difference_type difference_type; + typedef typename _Base::pointer pointer; + typedef typename _Base::const_pointer const_pointer; + typedef std::reverse_iterator reverse_iterator; + typedef std::reverse_iterator const_reverse_iterator; + + // 23.3.3.1 construct/copy/destroy: + + multiset() : _Base() { } + + explicit multiset(const _Compare& __comp, + const _Allocator& __a = _Allocator()) + : _Base(__comp, __a) { } + + template + multiset(_InputIterator __first, _InputIterator __last, + const _Compare& __comp = _Compare(), + const _Allocator& __a = _Allocator()) + : _Base(__gnu_debug::__base(__gnu_debug::__check_valid_range(__first, + __last)), + __gnu_debug::__base(__last), + __comp, __a) { } + + multiset(const multiset& __x) + : _Base(__x) { } + + multiset(const _Base& __x) + : _Base(__x) { } + +#if __cplusplus >= 201103L + multiset(multiset&& __x) + noexcept(is_nothrow_copy_constructible<_Compare>::value) + : _Base(std::move(__x)) + { this->_M_swap(__x); } + + multiset(initializer_list __l, + const _Compare& __comp = _Compare(), + const allocator_type& __a = allocator_type()) + : _Base(__l, __comp, __a) { } + + explicit + multiset(const allocator_type& __a) + : _Base(__a) { } + + multiset(const multiset& __m, const allocator_type& __a) + : _Base(__m, __a) { } + + multiset(multiset&& __m, const allocator_type& __a) + : _Base(std::move(__m._M_base()), __a) { } + + multiset(initializer_list __l, const allocator_type& __a) + : _Base(__l, __a) + { } + + template + multiset(_InputIterator __first, _InputIterator __last, + const allocator_type& __a) + : _Base(__gnu_debug::__base(__gnu_debug::__check_valid_range(__first, + __last)), + __gnu_debug::__base(__last), __a) + { } +#endif + + ~multiset() _GLIBCXX_NOEXCEPT { } + + multiset& + operator=(const multiset& __x) + { + _M_base() = __x; + this->_M_invalidate_all(); + return *this; + } + +#if __cplusplus >= 201103L + multiset& + operator=(multiset&& __x) + noexcept(_Alloc_traits::_S_nothrow_move()) + { + __glibcxx_check_self_move_assign(__x); + bool __xfer_memory = _Alloc_traits::_S_propagate_on_move_assign() + || __x.get_allocator() == this->get_allocator(); + _M_base() = std::move(__x._M_base()); + if (__xfer_memory) + this->_M_swap(__x); + else + this->_M_invalidate_all(); + __x._M_invalidate_all(); + return *this; + } + + multiset& + operator=(initializer_list __l) + { + _M_base() = __l; + this->_M_invalidate_all(); + return *this; + } +#endif + + using _Base::get_allocator; + + // iterators: + iterator + begin() _GLIBCXX_NOEXCEPT + { return iterator(_Base::begin(), this); } + + const_iterator + begin() const _GLIBCXX_NOEXCEPT + { return const_iterator(_Base::begin(), this); } + + iterator + end() _GLIBCXX_NOEXCEPT + { return iterator(_Base::end(), this); } + + const_iterator + end() const _GLIBCXX_NOEXCEPT + { return const_iterator(_Base::end(), this); } + + reverse_iterator + rbegin() _GLIBCXX_NOEXCEPT + { return reverse_iterator(end()); } + + const_reverse_iterator + rbegin() const _GLIBCXX_NOEXCEPT + { return const_reverse_iterator(end()); } + + reverse_iterator + rend() _GLIBCXX_NOEXCEPT + { return reverse_iterator(begin()); } + + const_reverse_iterator + rend() const _GLIBCXX_NOEXCEPT + { return const_reverse_iterator(begin()); } + +#if __cplusplus >= 201103L + const_iterator + cbegin() const noexcept + { return const_iterator(_Base::begin(), this); } + + const_iterator + cend() const noexcept + { return const_iterator(_Base::end(), this); } + + const_reverse_iterator + crbegin() const noexcept + { return const_reverse_iterator(end()); } + + const_reverse_iterator + crend() const noexcept + { return const_reverse_iterator(begin()); } +#endif + + // capacity: + using _Base::empty; + using _Base::size; + using _Base::max_size; + + // modifiers: +#if __cplusplus >= 201103L + template + iterator + emplace(_Args&&... __args) + { + return iterator(_Base::emplace(std::forward<_Args>(__args)...), this); + } + + template + iterator + emplace_hint(const_iterator __pos, _Args&&... __args) + { + __glibcxx_check_insert(__pos); + return iterator(_Base::emplace_hint(__pos.base(), + std::forward<_Args>(__args)...), + this); + } +#endif + + iterator + insert(const value_type& __x) + { return iterator(_Base::insert(__x), this); } + +#if __cplusplus >= 201103L + iterator + insert(value_type&& __x) + { return iterator(_Base::insert(std::move(__x)), this); } +#endif + + iterator + insert(const_iterator __position, const value_type& __x) + { + __glibcxx_check_insert(__position); + return iterator(_Base::insert(__position.base(), __x), this); + } + +#if __cplusplus >= 201103L + iterator + insert(const_iterator __position, value_type&& __x) + { + __glibcxx_check_insert(__position); + return iterator(_Base::insert(__position.base(), std::move(__x)), + this); + } +#endif + + template + void + insert(_InputIterator __first, _InputIterator __last) + { + __glibcxx_check_valid_range(__first, __last); + _Base::insert(__gnu_debug::__base(__first), + __gnu_debug::__base(__last)); + } + +#if __cplusplus >= 201103L + void + insert(initializer_list __l) + { _Base::insert(__l); } +#endif + +#if __cplusplus >= 201103L + iterator + erase(const_iterator __position) + { + __glibcxx_check_erase(__position); + this->_M_invalidate_if(_Equal(__position.base())); + return iterator(_Base::erase(__position.base()), this); + } +#else + void + erase(iterator __position) + { + __glibcxx_check_erase(__position); + this->_M_invalidate_if(_Equal(__position.base())); + _Base::erase(__position.base()); + } +#endif + + size_type + erase(const key_type& __x) + { + std::pair<_Base_iterator, _Base_iterator> __victims = + _Base::equal_range(__x); + size_type __count = 0; + _Base_iterator __victim = __victims.first; + while (__victim != __victims.second) + { + this->_M_invalidate_if(_Equal(__victim)); + _Base::erase(__victim++); + ++__count; + } + return __count; + } + +#if __cplusplus >= 201103L + iterator + erase(const_iterator __first, const_iterator __last) + { + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 151. can't currently clear() empty container + __glibcxx_check_erase_range(__first, __last); + for (_Base_const_iterator __victim = __first.base(); + __victim != __last.base(); ++__victim) + { + _GLIBCXX_DEBUG_VERIFY(__victim != _Base::end(), + _M_message(__gnu_debug::__msg_valid_range) + ._M_iterator(__first, "first") + ._M_iterator(__last, "last")); + this->_M_invalidate_if(_Equal(__victim)); + } + return iterator(_Base::erase(__first.base(), __last.base()), this); + } +#else + void + erase(iterator __first, iterator __last) + { + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 151. can't currently clear() empty container + __glibcxx_check_erase_range(__first, __last); + for (_Base_iterator __victim = __first.base(); + __victim != __last.base(); ++__victim) + { + _GLIBCXX_DEBUG_VERIFY(__victim != _Base::end(), + _M_message(__gnu_debug::__msg_valid_range) + ._M_iterator(__first, "first") + ._M_iterator(__last, "last")); + this->_M_invalidate_if(_Equal(__victim)); + } + _Base::erase(__first.base(), __last.base()); + } +#endif + + void + swap(multiset& __x) +#if __cplusplus >= 201103L + noexcept(_Alloc_traits::_S_nothrow_swap()) +#endif + { +#if __cplusplus >= 201103L + if (!_Alloc_traits::_S_propagate_on_swap()) + __glibcxx_check_equal_allocs(__x); +#endif + _Base::swap(__x); + this->_M_swap(__x); + } + + void + clear() _GLIBCXX_NOEXCEPT + { + this->_M_invalidate_all(); + _Base::clear(); + } + + // observers: + using _Base::key_comp; + using _Base::value_comp; + + // multiset operations: + iterator + find(const key_type& __x) + { return iterator(_Base::find(__x), this); } + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 214. set::find() missing const overload + const_iterator + find(const key_type& __x) const + { return const_iterator(_Base::find(__x), this); } + + using _Base::count; + + iterator + lower_bound(const key_type& __x) + { return iterator(_Base::lower_bound(__x), this); } + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 214. set::find() missing const overload + const_iterator + lower_bound(const key_type& __x) const + { return const_iterator(_Base::lower_bound(__x), this); } + + iterator + upper_bound(const key_type& __x) + { return iterator(_Base::upper_bound(__x), this); } + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 214. set::find() missing const overload + const_iterator + upper_bound(const key_type& __x) const + { return const_iterator(_Base::upper_bound(__x), this); } + + std::pair + equal_range(const key_type& __x) + { + std::pair<_Base_iterator, _Base_iterator> __res = + _Base::equal_range(__x); + return std::make_pair(iterator(__res.first, this), + iterator(__res.second, this)); + } + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 214. set::find() missing const overload + std::pair + equal_range(const key_type& __x) const + { + std::pair<_Base_const_iterator, _Base_const_iterator> __res = + _Base::equal_range(__x); + return std::make_pair(const_iterator(__res.first, this), + const_iterator(__res.second, this)); + } + + _Base& + _M_base() _GLIBCXX_NOEXCEPT { return *this; } + + const _Base& + _M_base() const _GLIBCXX_NOEXCEPT { return *this; } + + private: + void + _M_invalidate_all() + { + typedef __gnu_debug::_Not_equal_to<_Base_const_iterator> _Not_equal; + this->_M_invalidate_if(_Not_equal(_Base::end())); + } + }; + + template + inline bool + operator==(const multiset<_Key, _Compare, _Allocator>& __lhs, + const multiset<_Key, _Compare, _Allocator>& __rhs) + { return __lhs._M_base() == __rhs._M_base(); } + + template + inline bool + operator!=(const multiset<_Key, _Compare, _Allocator>& __lhs, + const multiset<_Key, _Compare, _Allocator>& __rhs) + { return __lhs._M_base() != __rhs._M_base(); } + + template + inline bool + operator<(const multiset<_Key, _Compare, _Allocator>& __lhs, + const multiset<_Key, _Compare, _Allocator>& __rhs) + { return __lhs._M_base() < __rhs._M_base(); } + + template + inline bool + operator<=(const multiset<_Key, _Compare, _Allocator>& __lhs, + const multiset<_Key, _Compare, _Allocator>& __rhs) + { return __lhs._M_base() <= __rhs._M_base(); } + + template + inline bool + operator>=(const multiset<_Key, _Compare, _Allocator>& __lhs, + const multiset<_Key, _Compare, _Allocator>& __rhs) + { return __lhs._M_base() >= __rhs._M_base(); } + + template + inline bool + operator>(const multiset<_Key, _Compare, _Allocator>& __lhs, + const multiset<_Key, _Compare, _Allocator>& __rhs) + { return __lhs._M_base() > __rhs._M_base(); } + + template + void + swap(multiset<_Key, _Compare, _Allocator>& __x, + multiset<_Key, _Compare, _Allocator>& __y) + { return __x.swap(__y); } + +} // namespace __debug +} // namespace std + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/safe_base.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/safe_base.h new file mode 100755 index 0000000..631ac77 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/safe_base.h @@ -0,0 +1,263 @@ +// Safe sequence/iterator base implementation -*- C++ -*- + +// Copyright (C) 2003-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file debug/safe_base.h + * This file is a GNU debug extension to the Standard C++ Library. + */ + +#ifndef _GLIBCXX_DEBUG_SAFE_BASE_H +#define _GLIBCXX_DEBUG_SAFE_BASE_H 1 + +#include + +namespace __gnu_debug +{ + class _Safe_sequence_base; + + /** \brief Basic functionality for a @a safe iterator. + * + * The %_Safe_iterator_base base class implements the functionality + * of a safe iterator that is not specific to a particular iterator + * type. It contains a pointer back to the sequence it references + * along with iterator version information and pointers to form a + * doubly-linked list of iterators referenced by the container. + * + * This class must not perform any operations that can throw an + * exception, or the exception guarantees of derived iterators will + * be broken. + */ + class _Safe_iterator_base + { + public: + /** The sequence this iterator references; may be NULL to indicate + a singular iterator. */ + _Safe_sequence_base* _M_sequence; + + /** The version number of this iterator. The sentinel value 0 is + * used to indicate an invalidated iterator (i.e., one that is + * singular because of an operation on the container). This + * version number must equal the version number in the sequence + * referenced by _M_sequence for the iterator to be + * non-singular. + */ + unsigned int _M_version; + + /** Pointer to the previous iterator in the sequence's list of + iterators. Only valid when _M_sequence != NULL. */ + _Safe_iterator_base* _M_prior; + + /** Pointer to the next iterator in the sequence's list of + iterators. Only valid when _M_sequence != NULL. */ + _Safe_iterator_base* _M_next; + + protected: + /** Initializes the iterator and makes it singular. */ + _Safe_iterator_base() + : _M_sequence(0), _M_version(0), _M_prior(0), _M_next(0) + { } + + /** Initialize the iterator to reference the sequence pointed to + * by @p __seq. @p __constant is true when we are initializing a + * constant iterator, and false if it is a mutable iterator. Note + * that @p __seq may be NULL, in which case the iterator will be + * singular. Otherwise, the iterator will reference @p __seq and + * be nonsingular. + */ + _Safe_iterator_base(const _Safe_sequence_base* __seq, bool __constant) + : _M_sequence(0), _M_version(0), _M_prior(0), _M_next(0) + { this->_M_attach(const_cast<_Safe_sequence_base*>(__seq), __constant); } + + /** Initializes the iterator to reference the same sequence that + @p __x does. @p __constant is true if this is a constant + iterator, and false if it is mutable. */ + _Safe_iterator_base(const _Safe_iterator_base& __x, bool __constant) + : _M_sequence(0), _M_version(0), _M_prior(0), _M_next(0) + { this->_M_attach(__x._M_sequence, __constant); } + + _Safe_iterator_base& + operator=(const _Safe_iterator_base&); + + explicit + _Safe_iterator_base(const _Safe_iterator_base&); + + ~_Safe_iterator_base() { this->_M_detach(); } + + /** For use in _Safe_iterator. */ + __gnu_cxx::__mutex& _M_get_mutex() throw (); + + public: + /** Attaches this iterator to the given sequence, detaching it + * from whatever sequence it was attached to originally. If the + * new sequence is the NULL pointer, the iterator is left + * unattached. + */ + void _M_attach(_Safe_sequence_base* __seq, bool __constant); + + /** Likewise, but not thread-safe. */ + void _M_attach_single(_Safe_sequence_base* __seq, bool __constant) throw (); + + /** Detach the iterator for whatever sequence it is attached to, + * if any. + */ + void _M_detach(); + + /** Likewise, but not thread-safe. */ + void _M_detach_single() throw (); + + /** Determines if we are attached to the given sequence. */ + bool _M_attached_to(const _Safe_sequence_base* __seq) const + { return _M_sequence == __seq; } + + /** Is this iterator singular? */ + _GLIBCXX_PURE bool _M_singular() const throw (); + + /** Can we compare this iterator to the given iterator @p __x? + Returns true if both iterators are nonsingular and reference + the same sequence. */ + _GLIBCXX_PURE bool _M_can_compare(const _Safe_iterator_base& __x) const throw (); + + /** Invalidate the iterator, making it singular. */ + void + _M_invalidate() + { _M_version = 0; } + + /** Reset all member variables */ + void + _M_reset() throw (); + + /** Unlink itself */ + void + _M_unlink() throw () + { + if (_M_prior) + _M_prior->_M_next = _M_next; + if (_M_next) + _M_next->_M_prior = _M_prior; + } + }; + + /** + * @brief Base class that supports tracking of iterators that + * reference a sequence. + * + * The %_Safe_sequence_base class provides basic support for + * tracking iterators into a sequence. Sequences that track + * iterators must derived from %_Safe_sequence_base publicly, so + * that safe iterators (which inherit _Safe_iterator_base) can + * attach to them. This class contains two linked lists of + * iterators, one for constant iterators and one for mutable + * iterators, and a version number that allows very fast + * invalidation of all iterators that reference the container. + * + * This class must ensure that no operation on it may throw an + * exception, otherwise @a safe sequences may fail to provide the + * exception-safety guarantees required by the C++ standard. + */ + class _Safe_sequence_base + { + public: + /// The list of mutable iterators that reference this container + _Safe_iterator_base* _M_iterators; + + /// The list of constant iterators that reference this container + _Safe_iterator_base* _M_const_iterators; + + /// The container version number. This number may never be 0. + mutable unsigned int _M_version; + + protected: + // Initialize with a version number of 1 and no iterators + _Safe_sequence_base() + : _M_iterators(0), _M_const_iterators(0), _M_version(1) + { } + +#if __cplusplus >= 201103L + _Safe_sequence_base(const _Safe_sequence_base&) noexcept + : _Safe_sequence_base() { } + + _Safe_sequence_base(_Safe_sequence_base&& __x) noexcept + : _Safe_sequence_base() + { _M_swap(__x); } +#endif + + /** Notify all iterators that reference this sequence that the + sequence is being destroyed. */ + ~_Safe_sequence_base() + { this->_M_detach_all(); } + + /** Detach all iterators, leaving them singular. */ + void + _M_detach_all(); + + /** Detach all singular iterators. + * @post for all iterators i attached to this sequence, + * i->_M_version == _M_version. + */ + void + _M_detach_singular(); + + /** Revalidates all attached singular iterators. This method may + * be used to validate iterators that were invalidated before + * (but for some reason, such as an exception, need to become + * valid again). + */ + void + _M_revalidate_singular(); + + /** Swap this sequence with the given sequence. This operation + * also swaps ownership of the iterators, so that when the + * operation is complete all iterators that originally referenced + * one container now reference the other container. + */ + void + _M_swap(_Safe_sequence_base& __x); + + /** For use in _Safe_sequence. */ + __gnu_cxx::__mutex& _M_get_mutex() throw (); + + public: + /** Invalidates all iterators. */ + void + _M_invalidate_all() const + { if (++_M_version == 0) _M_version = 1; } + + /** Attach an iterator to this sequence. */ + void + _M_attach(_Safe_iterator_base* __it, bool __constant); + + /** Likewise but not thread safe. */ + void + _M_attach_single(_Safe_iterator_base* __it, bool __constant) throw (); + + /** Detach an iterator from this sequence */ + void + _M_detach(_Safe_iterator_base* __it); + + /** Likewise but not thread safe. */ + void + _M_detach_single(_Safe_iterator_base* __it) throw (); + }; +} // namespace __gnu_debug + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/safe_iterator.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/safe_iterator.h new file mode 100755 index 0000000..d563db0 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/safe_iterator.h @@ -0,0 +1,731 @@ +// Safe iterator implementation -*- C++ -*- + +// Copyright (C) 2003-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file debug/safe_iterator.h + * This file is a GNU debug extension to the Standard C++ Library. + */ + +#ifndef _GLIBCXX_DEBUG_SAFE_ITERATOR_H +#define _GLIBCXX_DEBUG_SAFE_ITERATOR_H 1 + +#include +#include +#include +#include +#include +#include + +namespace __gnu_debug +{ + /** Helper struct to deal with sequence offering a before_begin + * iterator. + **/ + template + struct _BeforeBeginHelper + { + template + static bool + _S_Is(const _Safe_iterator<_Iterator, _Sequence>&) + { return false; } + + template + static bool + _S_Is_Beginnest(const _Safe_iterator<_Iterator, _Sequence>& __it) + { return __it.base() == __it._M_get_sequence()->_M_base().begin(); } + }; + + /** Iterators that derive from _Safe_iterator_base can be determined singular + * or non-singular. + **/ + inline bool + __check_singular_aux(const _Safe_iterator_base* __x) + { return __x->_M_singular(); } + + /** The precision to which we can calculate the distance between + * two iterators. + */ + enum _Distance_precision + { + __dp_equality, //< Can compare iterator equality, only + __dp_sign, //< Can determine equality and ordering + __dp_exact //< Can determine distance precisely + }; + + /** Determine the distance between two iterators with some known + * precision. + */ + template + inline std::pair::difference_type, + _Distance_precision> + __get_distance(const _Iterator& __lhs, const _Iterator& __rhs, + std::random_access_iterator_tag) + { return std::make_pair(__rhs - __lhs, __dp_exact); } + + template + inline std::pair::difference_type, + _Distance_precision> + __get_distance(const _Iterator& __lhs, const _Iterator& __rhs, + std::forward_iterator_tag) + { return std::make_pair(__lhs == __rhs? 0 : 1, __dp_equality); } + + template + inline std::pair::difference_type, + _Distance_precision> + __get_distance(const _Iterator& __lhs, const _Iterator& __rhs) + { + typedef typename std::iterator_traits<_Iterator>::iterator_category + _Category; + return __get_distance(__lhs, __rhs, _Category()); + } + + /** \brief Safe iterator wrapper. + * + * The class template %_Safe_iterator is a wrapper around an + * iterator that tracks the iterator's movement among sequences and + * checks that operations performed on the "safe" iterator are + * legal. In additional to the basic iterator operations (which are + * validated, and then passed to the underlying iterator), + * %_Safe_iterator has member functions for iterator invalidation, + * attaching/detaching the iterator from sequences, and querying + * the iterator's state. + */ + template + class _Safe_iterator : public _Safe_iterator_base + { + typedef _Safe_iterator _Self; + typedef typename _Sequence::const_iterator _Const_iterator; + + /// The underlying iterator + _Iterator _M_current; + + /// Determine if this is a constant iterator. + bool + _M_constant() const + { return std::__are_same<_Const_iterator, _Safe_iterator>::__value; } + + typedef std::iterator_traits<_Iterator> _Traits; + + public: + typedef _Iterator iterator_type; + typedef typename _Traits::iterator_category iterator_category; + typedef typename _Traits::value_type value_type; + typedef typename _Traits::difference_type difference_type; + typedef typename _Traits::reference reference; + typedef typename _Traits::pointer pointer; + + /// @post the iterator is singular and unattached + _Safe_iterator() _GLIBCXX_NOEXCEPT : _M_current() { } + + /** + * @brief Safe iterator construction from an unsafe iterator and + * its sequence. + * + * @pre @p seq is not NULL + * @post this is not singular + */ + _Safe_iterator(const _Iterator& __i, const _Sequence* __seq) + _GLIBCXX_NOEXCEPT + : _Safe_iterator_base(__seq, _M_constant()), _M_current(__i) + { + _GLIBCXX_DEBUG_VERIFY(! this->_M_singular(), + _M_message(__msg_init_singular) + ._M_iterator(*this, "this")); + } + + /** + * @brief Copy construction. + */ + _Safe_iterator(const _Safe_iterator& __x) _GLIBCXX_NOEXCEPT + : _Safe_iterator_base(__x, _M_constant()), _M_current(__x._M_current) + { + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR 408. Is vector > forbidden? + _GLIBCXX_DEBUG_VERIFY(!__x._M_singular() + || __x._M_current == _Iterator(), + _M_message(__msg_init_copy_singular) + ._M_iterator(*this, "this") + ._M_iterator(__x, "other")); + } + +#if __cplusplus >= 201103L + /** + * @brief Move construction. + * @post __x is singular and unattached + */ + _Safe_iterator(_Safe_iterator&& __x) noexcept : _M_current() + { + _GLIBCXX_DEBUG_VERIFY(!__x._M_singular() + || __x._M_current == _Iterator(), + _M_message(__msg_init_copy_singular) + ._M_iterator(*this, "this") + ._M_iterator(__x, "other")); + std::swap(_M_current, __x._M_current); + this->_M_attach(__x._M_sequence); + __x._M_detach(); + } +#endif + + /** + * @brief Converting constructor from a mutable iterator to a + * constant iterator. + */ + template + _Safe_iterator( + const _Safe_iterator<_MutableIterator, + typename __gnu_cxx::__enable_if<(std::__are_same<_MutableIterator, + typename _Sequence::iterator::iterator_type>::__value), + _Sequence>::__type>& __x) _GLIBCXX_NOEXCEPT + : _Safe_iterator_base(__x, _M_constant()), _M_current(__x.base()) + { + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR 408. Is vector > forbidden? + _GLIBCXX_DEBUG_VERIFY(!__x._M_singular() + || __x.base() == _Iterator(), + _M_message(__msg_init_const_singular) + ._M_iterator(*this, "this") + ._M_iterator(__x, "other")); + } + + /** + * @brief Copy assignment. + */ + _Safe_iterator& + operator=(const _Safe_iterator& __x) _GLIBCXX_NOEXCEPT + { + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR 408. Is vector > forbidden? + _GLIBCXX_DEBUG_VERIFY(!__x._M_singular() + || __x._M_current == _Iterator(), + _M_message(__msg_copy_singular) + ._M_iterator(*this, "this") + ._M_iterator(__x, "other")); + _M_current = __x._M_current; + this->_M_attach(__x._M_sequence); + return *this; + } + +#if __cplusplus >= 201103L + /** + * @brief Move assignment. + * @post __x is singular and unattached + */ + _Safe_iterator& + operator=(_Safe_iterator&& __x) noexcept + { + _GLIBCXX_DEBUG_VERIFY(this != &__x, + _M_message(__msg_self_move_assign) + ._M_iterator(*this, "this")); + _GLIBCXX_DEBUG_VERIFY(!__x._M_singular() + || __x._M_current == _Iterator(), + _M_message(__msg_copy_singular) + ._M_iterator(*this, "this") + ._M_iterator(__x, "other")); + _M_current = __x._M_current; + _M_attach(__x._M_sequence); + __x._M_detach(); + __x._M_current = _Iterator(); + return *this; + } +#endif + + /** + * @brief Iterator dereference. + * @pre iterator is dereferenceable + */ + reference + operator*() const _GLIBCXX_NOEXCEPT + { + _GLIBCXX_DEBUG_VERIFY(this->_M_dereferenceable(), + _M_message(__msg_bad_deref) + ._M_iterator(*this, "this")); + return *_M_current; + } + + /** + * @brief Iterator dereference. + * @pre iterator is dereferenceable + * @todo Make this correct w.r.t. iterators that return proxies + */ + pointer + operator->() const _GLIBCXX_NOEXCEPT + { + _GLIBCXX_DEBUG_VERIFY(this->_M_dereferenceable(), + _M_message(__msg_bad_deref) + ._M_iterator(*this, "this")); + return std::__addressof(*_M_current); + } + + // ------ Input iterator requirements ------ + /** + * @brief Iterator preincrement + * @pre iterator is incrementable + */ + _Safe_iterator& + operator++() _GLIBCXX_NOEXCEPT + { + _GLIBCXX_DEBUG_VERIFY(this->_M_incrementable(), + _M_message(__msg_bad_inc) + ._M_iterator(*this, "this")); + ++_M_current; + return *this; + } + + /** + * @brief Iterator postincrement + * @pre iterator is incrementable + */ + _Safe_iterator + operator++(int) _GLIBCXX_NOEXCEPT + { + _GLIBCXX_DEBUG_VERIFY(this->_M_incrementable(), + _M_message(__msg_bad_inc) + ._M_iterator(*this, "this")); + _Safe_iterator __tmp(*this); + ++_M_current; + return __tmp; + } + + // ------ Bidirectional iterator requirements ------ + /** + * @brief Iterator predecrement + * @pre iterator is decrementable + */ + _Safe_iterator& + operator--() _GLIBCXX_NOEXCEPT + { + _GLIBCXX_DEBUG_VERIFY(this->_M_decrementable(), + _M_message(__msg_bad_dec) + ._M_iterator(*this, "this")); + --_M_current; + return *this; + } + + /** + * @brief Iterator postdecrement + * @pre iterator is decrementable + */ + _Safe_iterator + operator--(int) _GLIBCXX_NOEXCEPT + { + _GLIBCXX_DEBUG_VERIFY(this->_M_decrementable(), + _M_message(__msg_bad_dec) + ._M_iterator(*this, "this")); + _Safe_iterator __tmp(*this); + --_M_current; + return __tmp; + } + + // ------ Random access iterator requirements ------ + reference + operator[](const difference_type& __n) const _GLIBCXX_NOEXCEPT + { + _GLIBCXX_DEBUG_VERIFY(this->_M_can_advance(__n) + && this->_M_can_advance(__n+1), + _M_message(__msg_iter_subscript_oob) + ._M_iterator(*this)._M_integer(__n)); + + return _M_current[__n]; + } + + _Safe_iterator& + operator+=(const difference_type& __n) _GLIBCXX_NOEXCEPT + { + _GLIBCXX_DEBUG_VERIFY(this->_M_can_advance(__n), + _M_message(__msg_advance_oob) + ._M_iterator(*this)._M_integer(__n)); + _M_current += __n; + return *this; + } + + _Safe_iterator + operator+(const difference_type& __n) const _GLIBCXX_NOEXCEPT + { + _Safe_iterator __tmp(*this); + __tmp += __n; + return __tmp; + } + + _Safe_iterator& + operator-=(const difference_type& __n) _GLIBCXX_NOEXCEPT + { + _GLIBCXX_DEBUG_VERIFY(this->_M_can_advance(-__n), + _M_message(__msg_retreat_oob) + ._M_iterator(*this)._M_integer(__n)); + _M_current += -__n; + return *this; + } + + _Safe_iterator + operator-(const difference_type& __n) const _GLIBCXX_NOEXCEPT + { + _Safe_iterator __tmp(*this); + __tmp -= __n; + return __tmp; + } + + // ------ Utilities ------ + /** + * @brief Return the underlying iterator + */ + _Iterator + base() const _GLIBCXX_NOEXCEPT { return _M_current; } + + /** + * @brief Conversion to underlying non-debug iterator to allow + * better interaction with non-debug containers. + */ + operator _Iterator() const _GLIBCXX_NOEXCEPT { return _M_current; } + + /** Attach iterator to the given sequence. */ + void + _M_attach(_Safe_sequence_base* __seq) + { + _Safe_iterator_base::_M_attach(__seq, _M_constant()); + } + + /** Likewise, but not thread-safe. */ + void + _M_attach_single(_Safe_sequence_base* __seq) + { + _Safe_iterator_base::_M_attach_single(__seq, _M_constant()); + } + + /// Is the iterator dereferenceable? + bool + _M_dereferenceable() const + { return !this->_M_singular() && !_M_is_end() && !_M_is_before_begin(); } + + /// Is the iterator before a dereferenceable one? + bool + _M_before_dereferenceable() const + { + if (this->_M_incrementable()) + { + _Iterator __base = base(); + return ++__base != _M_get_sequence()->_M_base().end(); + } + return false; + } + + /// Is the iterator incrementable? + bool + _M_incrementable() const + { return !this->_M_singular() && !_M_is_end(); } + + // Is the iterator decrementable? + bool + _M_decrementable() const { return !_M_singular() && !_M_is_begin(); } + + // Can we advance the iterator @p __n steps (@p __n may be negative) + bool + _M_can_advance(const difference_type& __n) const; + + // Is the iterator range [*this, __rhs) valid? + bool + _M_valid_range(const _Safe_iterator& __rhs) const; + + // The sequence this iterator references. + typename + __gnu_cxx::__conditional_type::__value, + const _Sequence*, + _Sequence*>::__type + _M_get_sequence() const + { return static_cast<_Sequence*>(_M_sequence); } + + /// Is this iterator equal to the sequence's begin() iterator? + bool + _M_is_begin() const + { return base() == _M_get_sequence()->_M_base().begin(); } + + /// Is this iterator equal to the sequence's end() iterator? + bool + _M_is_end() const + { return base() == _M_get_sequence()->_M_base().end(); } + + /// Is this iterator equal to the sequence's before_begin() iterator if + /// any? + bool + _M_is_before_begin() const + { return _BeforeBeginHelper<_Sequence>::_S_Is(*this); } + + /// Is this iterator equal to the sequence's before_begin() iterator if + /// any or begin() otherwise? + bool + _M_is_beginnest() const + { return _BeforeBeginHelper<_Sequence>::_S_Is_Beginnest(*this); } + }; + + template + inline bool + operator==(const _Safe_iterator<_IteratorL, _Sequence>& __lhs, + const _Safe_iterator<_IteratorR, _Sequence>& __rhs) + _GLIBCXX_NOEXCEPT + { + _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(), + _M_message(__msg_iter_compare_bad) + ._M_iterator(__lhs, "lhs") + ._M_iterator(__rhs, "rhs")); + _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs), + _M_message(__msg_compare_different) + ._M_iterator(__lhs, "lhs") + ._M_iterator(__rhs, "rhs")); + return __lhs.base() == __rhs.base(); + } + + template + inline bool + operator==(const _Safe_iterator<_Iterator, _Sequence>& __lhs, + const _Safe_iterator<_Iterator, _Sequence>& __rhs) + _GLIBCXX_NOEXCEPT + { + _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(), + _M_message(__msg_iter_compare_bad) + ._M_iterator(__lhs, "lhs") + ._M_iterator(__rhs, "rhs")); + _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs), + _M_message(__msg_compare_different) + ._M_iterator(__lhs, "lhs") + ._M_iterator(__rhs, "rhs")); + return __lhs.base() == __rhs.base(); + } + + template + inline bool + operator!=(const _Safe_iterator<_IteratorL, _Sequence>& __lhs, + const _Safe_iterator<_IteratorR, _Sequence>& __rhs) + _GLIBCXX_NOEXCEPT + { + _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(), + _M_message(__msg_iter_compare_bad) + ._M_iterator(__lhs, "lhs") + ._M_iterator(__rhs, "rhs")); + _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs), + _M_message(__msg_compare_different) + ._M_iterator(__lhs, "lhs") + ._M_iterator(__rhs, "rhs")); + return __lhs.base() != __rhs.base(); + } + + template + inline bool + operator!=(const _Safe_iterator<_Iterator, _Sequence>& __lhs, + const _Safe_iterator<_Iterator, _Sequence>& __rhs) + _GLIBCXX_NOEXCEPT + { + _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(), + _M_message(__msg_iter_compare_bad) + ._M_iterator(__lhs, "lhs") + ._M_iterator(__rhs, "rhs")); + _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs), + _M_message(__msg_compare_different) + ._M_iterator(__lhs, "lhs") + ._M_iterator(__rhs, "rhs")); + return __lhs.base() != __rhs.base(); + } + + template + inline bool + operator<(const _Safe_iterator<_IteratorL, _Sequence>& __lhs, + const _Safe_iterator<_IteratorR, _Sequence>& __rhs) + _GLIBCXX_NOEXCEPT + { + _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(), + _M_message(__msg_iter_order_bad) + ._M_iterator(__lhs, "lhs") + ._M_iterator(__rhs, "rhs")); + _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs), + _M_message(__msg_order_different) + ._M_iterator(__lhs, "lhs") + ._M_iterator(__rhs, "rhs")); + return __lhs.base() < __rhs.base(); + } + + template + inline bool + operator<(const _Safe_iterator<_Iterator, _Sequence>& __lhs, + const _Safe_iterator<_Iterator, _Sequence>& __rhs) + _GLIBCXX_NOEXCEPT + { + _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(), + _M_message(__msg_iter_order_bad) + ._M_iterator(__lhs, "lhs") + ._M_iterator(__rhs, "rhs")); + _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs), + _M_message(__msg_order_different) + ._M_iterator(__lhs, "lhs") + ._M_iterator(__rhs, "rhs")); + return __lhs.base() < __rhs.base(); + } + + template + inline bool + operator<=(const _Safe_iterator<_IteratorL, _Sequence>& __lhs, + const _Safe_iterator<_IteratorR, _Sequence>& __rhs) + _GLIBCXX_NOEXCEPT + { + _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(), + _M_message(__msg_iter_order_bad) + ._M_iterator(__lhs, "lhs") + ._M_iterator(__rhs, "rhs")); + _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs), + _M_message(__msg_order_different) + ._M_iterator(__lhs, "lhs") + ._M_iterator(__rhs, "rhs")); + return __lhs.base() <= __rhs.base(); + } + + template + inline bool + operator<=(const _Safe_iterator<_Iterator, _Sequence>& __lhs, + const _Safe_iterator<_Iterator, _Sequence>& __rhs) + _GLIBCXX_NOEXCEPT + { + _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(), + _M_message(__msg_iter_order_bad) + ._M_iterator(__lhs, "lhs") + ._M_iterator(__rhs, "rhs")); + _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs), + _M_message(__msg_order_different) + ._M_iterator(__lhs, "lhs") + ._M_iterator(__rhs, "rhs")); + return __lhs.base() <= __rhs.base(); + } + + template + inline bool + operator>(const _Safe_iterator<_IteratorL, _Sequence>& __lhs, + const _Safe_iterator<_IteratorR, _Sequence>& __rhs) + _GLIBCXX_NOEXCEPT + { + _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(), + _M_message(__msg_iter_order_bad) + ._M_iterator(__lhs, "lhs") + ._M_iterator(__rhs, "rhs")); + _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs), + _M_message(__msg_order_different) + ._M_iterator(__lhs, "lhs") + ._M_iterator(__rhs, "rhs")); + return __lhs.base() > __rhs.base(); + } + + template + inline bool + operator>(const _Safe_iterator<_Iterator, _Sequence>& __lhs, + const _Safe_iterator<_Iterator, _Sequence>& __rhs) + _GLIBCXX_NOEXCEPT + { + _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(), + _M_message(__msg_iter_order_bad) + ._M_iterator(__lhs, "lhs") + ._M_iterator(__rhs, "rhs")); + _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs), + _M_message(__msg_order_different) + ._M_iterator(__lhs, "lhs") + ._M_iterator(__rhs, "rhs")); + return __lhs.base() > __rhs.base(); + } + + template + inline bool + operator>=(const _Safe_iterator<_IteratorL, _Sequence>& __lhs, + const _Safe_iterator<_IteratorR, _Sequence>& __rhs) + _GLIBCXX_NOEXCEPT + { + _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(), + _M_message(__msg_iter_order_bad) + ._M_iterator(__lhs, "lhs") + ._M_iterator(__rhs, "rhs")); + _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs), + _M_message(__msg_order_different) + ._M_iterator(__lhs, "lhs") + ._M_iterator(__rhs, "rhs")); + return __lhs.base() >= __rhs.base(); + } + + template + inline bool + operator>=(const _Safe_iterator<_Iterator, _Sequence>& __lhs, + const _Safe_iterator<_Iterator, _Sequence>& __rhs) + _GLIBCXX_NOEXCEPT + { + _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(), + _M_message(__msg_iter_order_bad) + ._M_iterator(__lhs, "lhs") + ._M_iterator(__rhs, "rhs")); + _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs), + _M_message(__msg_order_different) + ._M_iterator(__lhs, "lhs") + ._M_iterator(__rhs, "rhs")); + return __lhs.base() >= __rhs.base(); + } + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // According to the resolution of DR179 not only the various comparison + // operators but also operator- must accept mixed iterator/const_iterator + // parameters. + template + inline typename _Safe_iterator<_IteratorL, _Sequence>::difference_type + operator-(const _Safe_iterator<_IteratorL, _Sequence>& __lhs, + const _Safe_iterator<_IteratorR, _Sequence>& __rhs) + _GLIBCXX_NOEXCEPT + { + _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(), + _M_message(__msg_distance_bad) + ._M_iterator(__lhs, "lhs") + ._M_iterator(__rhs, "rhs")); + _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs), + _M_message(__msg_distance_different) + ._M_iterator(__lhs, "lhs") + ._M_iterator(__rhs, "rhs")); + return __lhs.base() - __rhs.base(); + } + + template + inline typename _Safe_iterator<_Iterator, _Sequence>::difference_type + operator-(const _Safe_iterator<_Iterator, _Sequence>& __lhs, + const _Safe_iterator<_Iterator, _Sequence>& __rhs) + _GLIBCXX_NOEXCEPT + { + _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(), + _M_message(__msg_distance_bad) + ._M_iterator(__lhs, "lhs") + ._M_iterator(__rhs, "rhs")); + _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs), + _M_message(__msg_distance_different) + ._M_iterator(__lhs, "lhs") + ._M_iterator(__rhs, "rhs")); + return __lhs.base() - __rhs.base(); + } + + template + inline _Safe_iterator<_Iterator, _Sequence> + operator+(typename _Safe_iterator<_Iterator,_Sequence>::difference_type __n, + const _Safe_iterator<_Iterator, _Sequence>& __i) _GLIBCXX_NOEXCEPT + { return __i + __n; } +} // namespace __gnu_debug + +#include + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/safe_iterator.tcc b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/safe_iterator.tcc new file mode 100755 index 0000000..0402d7e --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/safe_iterator.tcc @@ -0,0 +1,100 @@ +// Debugging iterator implementation (out of line) -*- C++ -*- + +// Copyright (C) 2003-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file debug/safe_iterator.tcc + * This file is a GNU debug extension to the Standard C++ Library. + */ + +#ifndef _GLIBCXX_DEBUG_SAFE_ITERATOR_TCC +#define _GLIBCXX_DEBUG_SAFE_ITERATOR_TCC 1 + +namespace __gnu_debug +{ + template + bool + _Safe_iterator<_Iterator, _Sequence>:: + _M_can_advance(const difference_type& __n) const + { + if (this->_M_singular()) + return false; + if (__n == 0) + return true; + if (__n < 0) + { + std::pair __dist = + __get_distance(_M_get_sequence()->_M_base().begin(), base()); + bool __ok = ((__dist.second == __dp_exact && __dist.first >= -__n) + || (__dist.second != __dp_exact && __dist.first > 0)); + return __ok; + } + else + { + std::pair __dist = + __get_distance(base(), _M_get_sequence()->_M_base().end()); + bool __ok = ((__dist.second == __dp_exact && __dist.first >= __n) + || (__dist.second != __dp_exact && __dist.first > 0)); + return __ok; + } + } + + template + bool + _Safe_iterator<_Iterator, _Sequence>:: + _M_valid_range(const _Safe_iterator& __rhs) const + { + if (!_M_can_compare(__rhs)) + return false; + + /* Determine if we can order the iterators without the help of + the container */ + std::pair __dist = + __get_distance(base(), __rhs.base()); + switch (__dist.second) { + case __dp_equality: + if (__dist.first == 0) + return true; + break; + + case __dp_sign: + case __dp_exact: + return __dist.first >= 0; + } + + /* We can only test for equality, but check if one of the + iterators is at an extreme. */ + /* Optim for classic [begin, it) or [it, end) ranges, limit checks + * when code is valid. Note, for the special case of forward_list, + * before_begin replaces the role of begin. */ + if (_M_is_beginnest() || __rhs._M_is_end()) + return true; + if (_M_is_end() || __rhs._M_is_beginnest()) + return false; + + // Assume that this is a valid range; we can't check anything else + return true; + } +} // namespace __gnu_debug + +#endif + diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/safe_local_iterator.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/safe_local_iterator.h new file mode 100755 index 0000000..77552ce --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/safe_local_iterator.h @@ -0,0 +1,362 @@ +// Safe iterator implementation -*- C++ -*- + +// Copyright (C) 2011-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file debug/safe_local_iterator.h + * This file is a GNU debug extension to the Standard C++ Library. + */ + +#ifndef _GLIBCXX_DEBUG_SAFE_LOCAL_ITERATOR_H +#define _GLIBCXX_DEBUG_SAFE_LOCAL_ITERATOR_H 1 + +#include +#include +#include +#include +#include + +namespace __gnu_debug +{ + /** \brief Safe iterator wrapper. + * + * The class template %_Safe_local_iterator is a wrapper around an + * iterator that tracks the iterator's movement among sequences and + * checks that operations performed on the "safe" iterator are + * legal. In additional to the basic iterator operations (which are + * validated, and then passed to the underlying iterator), + * %_Safe_local_iterator has member functions for iterator invalidation, + * attaching/detaching the iterator from sequences, and querying + * the iterator's state. + */ + template + class _Safe_local_iterator : public _Safe_local_iterator_base + { + typedef _Safe_local_iterator _Self; + typedef typename _Sequence::const_local_iterator _Const_local_iterator; + typedef typename _Sequence::size_type size_type; + + /// The underlying iterator + _Iterator _M_current; + + /// Determine if this is a constant iterator. + bool + _M_constant() const + { + return std::__are_same<_Const_local_iterator, + _Safe_local_iterator>::__value; + } + + typedef std::iterator_traits<_Iterator> _Traits; + + public: + typedef _Iterator iterator_type; + typedef typename _Traits::iterator_category iterator_category; + typedef typename _Traits::value_type value_type; + typedef typename _Traits::difference_type difference_type; + typedef typename _Traits::reference reference; + typedef typename _Traits::pointer pointer; + + /// @post the iterator is singular and unattached + _Safe_local_iterator() : _M_current() { } + + /** + * @brief Safe iterator construction from an unsafe iterator and + * its sequence. + * + * @pre @p seq is not NULL + * @post this is not singular + */ + _Safe_local_iterator(const _Iterator& __i, const _Sequence* __seq) + : _Safe_local_iterator_base(__seq, _M_constant()), _M_current(__i) + { + _GLIBCXX_DEBUG_VERIFY(!this->_M_singular(), + _M_message(__msg_init_singular) + ._M_iterator(*this, "this")); + } + + /** + * @brief Copy construction. + */ + _Safe_local_iterator(const _Safe_local_iterator& __x) + : _Safe_local_iterator_base(__x, _M_constant()), + _M_current(__x._M_current) + { + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR 408. Is vector > forbidden? + _GLIBCXX_DEBUG_VERIFY(!__x._M_singular() + || __x.base() == _Iterator(), + _M_message(__msg_init_copy_singular) + ._M_iterator(*this, "this") + ._M_iterator(__x, "other")); + } + + /** + * @brief Converting constructor from a mutable iterator to a + * constant iterator. + */ + template + _Safe_local_iterator( + const _Safe_local_iterator<_MutableIterator, + typename __gnu_cxx::__enable_if::__value, + _Sequence>::__type>& __x) + : _Safe_local_iterator_base(__x, _M_constant()), + _M_current(__x.base()) + { + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR 408. Is vector > forbidden? + _GLIBCXX_DEBUG_VERIFY(!__x._M_singular() + || __x.base() == _Iterator(), + _M_message(__msg_init_const_singular) + ._M_iterator(*this, "this") + ._M_iterator(__x, "other")); + } + + /** + * @brief Copy assignment. + */ + _Safe_local_iterator& + operator=(const _Safe_local_iterator& __x) + { + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR 408. Is vector > forbidden? + _GLIBCXX_DEBUG_VERIFY(!__x._M_singular() + || __x.base() == _Iterator(), + _M_message(__msg_copy_singular) + ._M_iterator(*this, "this") + ._M_iterator(__x, "other")); + _M_current = __x._M_current; + this->_M_attach(__x._M_sequence); + return *this; + } + + /** + * @brief Iterator dereference. + * @pre iterator is dereferenceable + */ + reference + operator*() const + { + _GLIBCXX_DEBUG_VERIFY(this->_M_dereferenceable(), + _M_message(__msg_bad_deref) + ._M_iterator(*this, "this")); + return *_M_current; + } + + /** + * @brief Iterator dereference. + * @pre iterator is dereferenceable + * @todo Make this correct w.r.t. iterators that return proxies + */ + pointer + operator->() const + { + _GLIBCXX_DEBUG_VERIFY(this->_M_dereferenceable(), + _M_message(__msg_bad_deref) + ._M_iterator(*this, "this")); + return std::__addressof(*_M_current); + } + + // ------ Input iterator requirements ------ + /** + * @brief Iterator preincrement + * @pre iterator is incrementable + */ + _Safe_local_iterator& + operator++() + { + _GLIBCXX_DEBUG_VERIFY(this->_M_incrementable(), + _M_message(__msg_bad_inc) + ._M_iterator(*this, "this")); + ++_M_current; + return *this; + } + + /** + * @brief Iterator postincrement + * @pre iterator is incrementable + */ + _Safe_local_iterator + operator++(int) + { + _GLIBCXX_DEBUG_VERIFY(this->_M_incrementable(), + _M_message(__msg_bad_inc) + ._M_iterator(*this, "this")); + _Safe_local_iterator __tmp(*this); + ++_M_current; + return __tmp; + } + + // ------ Utilities ------ + /** + * @brief Return the underlying iterator + */ + _Iterator + base() const { return _M_current; } + + /** + * @brief Return the bucket + */ + size_type + bucket() const { return _M_current._M_get_bucket(); } + + /** + * @brief Conversion to underlying non-debug iterator to allow + * better interaction with non-debug containers. + */ + operator _Iterator() const { return _M_current; } + + /** Attach iterator to the given sequence. */ + void + _M_attach(_Safe_sequence_base* __seq) + { _Safe_iterator_base::_M_attach(__seq, _M_constant()); } + + /** Likewise, but not thread-safe. */ + void + _M_attach_single(_Safe_sequence_base* __seq) + { _Safe_iterator_base::_M_attach_single(__seq, _M_constant()); } + + /// Is the iterator dereferenceable? + bool + _M_dereferenceable() const + { return !this->_M_singular() && !_M_is_end(); } + + /// Is the iterator incrementable? + bool + _M_incrementable() const + { return !this->_M_singular() && !_M_is_end(); } + + // Is the iterator range [*this, __rhs) valid? + bool + _M_valid_range(const _Safe_local_iterator& __rhs) const; + + // The sequence this iterator references. + typename + __gnu_cxx::__conditional_type::__value, + const _Sequence*, + _Sequence*>::__type + _M_get_sequence() const + { return static_cast<_Sequence*>(_M_sequence); } + + /// Is this iterator equal to the sequence's begin(bucket) iterator? + bool _M_is_begin() const + { return base() == _M_get_sequence()->_M_base().begin(bucket()); } + + /// Is this iterator equal to the sequence's end(bucket) iterator? + bool _M_is_end() const + { return base() == _M_get_sequence()->_M_base().end(bucket()); } + + /// Is this iterator part of the same bucket as the other one? + template + bool + _M_in_same_bucket(const _Safe_local_iterator<_Other, + _Sequence>& __other) const + { return bucket() == __other.bucket(); } + }; + + template + inline bool + operator==(const _Safe_local_iterator<_IteratorL, _Sequence>& __lhs, + const _Safe_local_iterator<_IteratorR, _Sequence>& __rhs) + { + _GLIBCXX_DEBUG_VERIFY(!__lhs._M_singular() && !__rhs._M_singular(), + _M_message(__msg_iter_compare_bad) + ._M_iterator(__lhs, "lhs") + ._M_iterator(__rhs, "rhs")); + _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs), + _M_message(__msg_compare_different) + ._M_iterator(__lhs, "lhs") + ._M_iterator(__rhs, "rhs")); + _GLIBCXX_DEBUG_VERIFY(__lhs._M_in_same_bucket(__rhs), + _M_message(__msg_local_iter_compare_bad) + ._M_iterator(__lhs, "lhs") + ._M_iterator(__rhs, "rhs")); + return __lhs.base() == __rhs.base(); + } + + template + inline bool + operator==(const _Safe_local_iterator<_Iterator, _Sequence>& __lhs, + const _Safe_local_iterator<_Iterator, _Sequence>& __rhs) + { + _GLIBCXX_DEBUG_VERIFY(!__lhs._M_singular() && !__rhs._M_singular(), + _M_message(__msg_iter_compare_bad) + ._M_iterator(__lhs, "lhs") + ._M_iterator(__rhs, "rhs")); + _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs), + _M_message(__msg_compare_different) + ._M_iterator(__lhs, "lhs") + ._M_iterator(__rhs, "rhs")); + _GLIBCXX_DEBUG_VERIFY(__lhs._M_in_same_bucket(__rhs), + _M_message(__msg_local_iter_compare_bad) + ._M_iterator(__lhs, "lhs") + ._M_iterator(__rhs, "rhs")); + return __lhs.base() == __rhs.base(); + } + + template + inline bool + operator!=(const _Safe_local_iterator<_IteratorL, _Sequence>& __lhs, + const _Safe_local_iterator<_IteratorR, _Sequence>& __rhs) + { + _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(), + _M_message(__msg_iter_compare_bad) + ._M_iterator(__lhs, "lhs") + ._M_iterator(__rhs, "rhs")); + _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs), + _M_message(__msg_compare_different) + ._M_iterator(__lhs, "lhs") + ._M_iterator(__rhs, "rhs")); + _GLIBCXX_DEBUG_VERIFY(__lhs._M_in_same_bucket(__rhs), + _M_message(__msg_local_iter_compare_bad) + ._M_iterator(__lhs, "lhs") + ._M_iterator(__rhs, "rhs")); + return __lhs.base() != __rhs.base(); + } + + template + inline bool + operator!=(const _Safe_local_iterator<_Iterator, _Sequence>& __lhs, + const _Safe_local_iterator<_Iterator, _Sequence>& __rhs) + { + _GLIBCXX_DEBUG_VERIFY(!__lhs._M_singular() && !__rhs._M_singular(), + _M_message(__msg_iter_compare_bad) + ._M_iterator(__lhs, "lhs") + ._M_iterator(__rhs, "rhs")); + _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs), + _M_message(__msg_compare_different) + ._M_iterator(__lhs, "lhs") + ._M_iterator(__rhs, "rhs")); + _GLIBCXX_DEBUG_VERIFY(__lhs._M_in_same_bucket(__rhs), + _M_message(__msg_local_iter_compare_bad) + ._M_iterator(__lhs, "lhs") + ._M_iterator(__rhs, "rhs")); + return __lhs.base() != __rhs.base(); + } +} // namespace __gnu_debug + +#include + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/safe_local_iterator.tcc b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/safe_local_iterator.tcc new file mode 100755 index 0000000..3f65f69 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/safe_local_iterator.tcc @@ -0,0 +1,74 @@ +// Debugging iterator implementation (out of line) -*- C++ -*- + +// Copyright (C) 2011-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file debug/safe_local_iterator.tcc + * This file is a GNU debug extension to the Standard C++ Library. + */ + +#ifndef _GLIBCXX_DEBUG_SAFE_LOCAL_ITERATOR_TCC +#define _GLIBCXX_DEBUG_SAFE_LOCAL_ITERATOR_TCC 1 + +namespace __gnu_debug +{ + template + bool + _Safe_local_iterator<_Iterator, _Sequence>:: + _M_valid_range(const _Safe_local_iterator& __rhs) const + { + if (!_M_can_compare(__rhs)) + return false; + if (bucket() != __rhs.bucket()) + return false; + + /* Determine if we can order the iterators without the help of + the container */ + std::pair __dist = + __get_distance(base(), __rhs.base()); + switch (__dist.second) + { + case __dp_equality: + if (__dist.first == 0) + return true; + break; + + case __dp_sign: + case __dp_exact: + return __dist.first >= 0; + } + + /* We can only test for equality, but check if one of the + iterators is at an extreme. */ + /* Optim for classic [begin, it) or [it, end) ranges, limit checks + * when code is valid. */ + if (_M_is_begin() || __rhs._M_is_end()) + return true; + if (_M_is_end() || __rhs._M_is_begin()) + return false; + + // Assume that this is a valid range; we can't check anything else + return true; + } +} // namespace __gnu_debug + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/safe_sequence.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/safe_sequence.h new file mode 100755 index 0000000..245d851 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/safe_sequence.h @@ -0,0 +1,134 @@ +// Safe sequence implementation -*- C++ -*- + +// Copyright (C) 2003-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file debug/safe_sequence.h + * This file is a GNU debug extension to the Standard C++ Library. + */ + +#ifndef _GLIBCXX_DEBUG_SAFE_SEQUENCE_H +#define _GLIBCXX_DEBUG_SAFE_SEQUENCE_H 1 + +#include +#include +#include +#include + +namespace __gnu_debug +{ + template + class _Safe_iterator; + + /** A simple function object that returns true if the passed-in + * value is not equal to the stored value. It saves typing over + * using both bind1st and not_equal. + */ + template + class _Not_equal_to + { + _Type __value; + + public: + explicit _Not_equal_to(const _Type& __v) : __value(__v) { } + + bool + operator()(const _Type& __x) const + { return __value != __x; } + }; + + /** A simple function object that returns true if the passed-in + * value is equal to the stored value. */ + template + class _Equal_to + { + _Type __value; + + public: + explicit _Equal_to(const _Type& __v) : __value(__v) { } + + bool + operator()(const _Type& __x) const + { return __value == __x; } + }; + + /** A function object that returns true when the given random access + iterator is at least @c n steps away from the given iterator. */ + template + class _After_nth_from + { + typedef typename std::iterator_traits<_Iterator>::difference_type + difference_type; + + _Iterator _M_base; + difference_type _M_n; + + public: + _After_nth_from(const difference_type& __n, const _Iterator& __base) + : _M_base(__base), _M_n(__n) { } + + bool + operator()(const _Iterator& __x) const + { return __x - _M_base >= _M_n; } + }; + + /** + * @brief Base class for constructing a @a safe sequence type that + * tracks iterators that reference it. + * + * The class template %_Safe_sequence simplifies the construction of + * @a safe sequences that track the iterators that reference the + * sequence, so that the iterators are notified of changes in the + * sequence that may affect their operation, e.g., if the container + * invalidates its iterators or is destructed. This class template + * may only be used by deriving from it and passing the name of the + * derived class as its template parameter via the curiously + * recurring template pattern. The derived class must have @c + * iterator and @c const_iterator types that are instantiations of + * class template _Safe_iterator for this sequence. Iterators will + * then be tracked automatically. + */ + template + class _Safe_sequence : public _Safe_sequence_base + { + public: + /** Invalidates all iterators @c x that reference this sequence, + are not singular, and for which @c __pred(x) returns @c + true. @c __pred will be invoked with the normal iterators nested + in the safe ones. */ + template + void + _M_invalidate_if(_Predicate __pred); + + /** Transfers all iterators @c x that reference @c from sequence, + are not singular, and for which @c __pred(x) returns @c + true. @c __pred will be invoked with the normal iterators nested + in the safe ones. */ + template + void + _M_transfer_from_if(_Safe_sequence& __from, _Predicate __pred); + }; +} // namespace __gnu_debug + +#include + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/safe_sequence.tcc b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/safe_sequence.tcc new file mode 100755 index 0000000..fad779c --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/safe_sequence.tcc @@ -0,0 +1,150 @@ +// Safe sequence implementation -*- C++ -*- + +// Copyright (C) 2010-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file debug/safe_sequence.tcc + * This file is a GNU debug extension to the Standard C++ Library. + */ + +#ifndef _GLIBCXX_DEBUG_SAFE_SEQUENCE_TCC +#define _GLIBCXX_DEBUG_SAFE_SEQUENCE_TCC 1 + +namespace __gnu_debug +{ + template + template + void + _Safe_sequence<_Sequence>:: + _M_invalidate_if(_Predicate __pred) + { + typedef typename _Sequence::iterator iterator; + typedef typename _Sequence::const_iterator const_iterator; + + __gnu_cxx::__scoped_lock sentry(this->_M_get_mutex()); + for (_Safe_iterator_base* __iter = _M_iterators; __iter;) + { + iterator* __victim = static_cast(__iter); + __iter = __iter->_M_next; + if (!__victim->_M_singular() && __pred(__victim->base())) + { + __victim->_M_invalidate(); + } + } + + for (_Safe_iterator_base* __iter2 = _M_const_iterators; __iter2;) + { + const_iterator* __victim = static_cast(__iter2); + __iter2 = __iter2->_M_next; + if (!__victim->_M_singular() && __pred(__victim->base())) + { + __victim->_M_invalidate(); + } + } + } + + template + template + void + _Safe_sequence<_Sequence>:: + _M_transfer_from_if(_Safe_sequence& __from, _Predicate __pred) + { + typedef typename _Sequence::iterator iterator; + typedef typename _Sequence::const_iterator const_iterator; + + _Safe_iterator_base* __transfered_iterators = 0; + _Safe_iterator_base* __transfered_const_iterators = 0; + _Safe_iterator_base* __last_iterator = 0; + _Safe_iterator_base* __last_const_iterator = 0; + { + // We lock __from first and detach iterator(s) to transfer + __gnu_cxx::__scoped_lock sentry(__from._M_get_mutex()); + + for (_Safe_iterator_base* __iter = __from._M_iterators; __iter;) + { + iterator* __victim = static_cast(__iter); + __iter = __iter->_M_next; + if (!__victim->_M_singular() && __pred(__victim->base())) + { + __victim->_M_detach_single(); + if (__transfered_iterators) + { + __victim->_M_next = __transfered_iterators; + __transfered_iterators->_M_prior = __victim; + } + else + __last_iterator = __victim; + __victim->_M_sequence = this; + __victim->_M_version = this->_M_version; + __transfered_iterators = __victim; + } + } + + for (_Safe_iterator_base* __iter2 = __from._M_const_iterators; + __iter2;) + { + const_iterator* __victim = static_cast(__iter2); + __iter2 = __iter2->_M_next; + if (!__victim->_M_singular() && __pred(__victim->base())) + { + __victim->_M_detach_single(); + if (__transfered_const_iterators) + { + __victim->_M_next = __transfered_const_iterators; + __transfered_const_iterators->_M_prior = __victim; + } + else + __last_const_iterator = __victim; + __victim->_M_sequence = this; + __victim->_M_version = this->_M_version; + __transfered_const_iterators = __victim; + } + } + } + + // Now we can lock *this and add the transfered iterators if any + if (__last_iterator || __last_const_iterator) + { + __gnu_cxx::__scoped_lock sentry(this->_M_get_mutex()); + if (__last_iterator) + { + if (this->_M_iterators) + { + this->_M_iterators->_M_prior = __last_iterator; + __last_iterator->_M_next = this->_M_iterators; + } + this->_M_iterators = __transfered_iterators; + } + if (__last_const_iterator) + { + if (this->_M_const_iterators) + { + this->_M_const_iterators->_M_prior = __last_const_iterator; + __last_const_iterator->_M_next = this->_M_const_iterators; + } + this->_M_const_iterators = __transfered_const_iterators; + } + } + } +} // namespace __gnu_debug + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/safe_unordered_base.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/safe_unordered_base.h new file mode 100755 index 0000000..bbb274f --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/safe_unordered_base.h @@ -0,0 +1,185 @@ +// Safe container/iterator base implementation -*- C++ -*- + +// Copyright (C) 2011-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file debug/safe_unordered_base.h + * This file is a GNU debug extension to the Standard C++ Library. + */ + +#ifndef _GLIBCXX_DEBUG_SAFE_UNORDERED_BASE_H +#define _GLIBCXX_DEBUG_SAFE_UNORDERED_BASE_H 1 + +#include + +namespace __gnu_debug +{ + class _Safe_unordered_container_base; + + /** \brief Basic functionality for a @a safe iterator. + * + * The %_Safe_local_iterator_base base class implements the functionality + * of a safe local iterator that is not specific to a particular iterator + * type. It contains a pointer back to the container it references + * along with iterator version information and pointers to form a + * doubly-linked list of local iterators referenced by the container. + * + * This class must not perform any operations that can throw an + * exception, or the exception guarantees of derived iterators will + * be broken. + */ + class _Safe_local_iterator_base : public _Safe_iterator_base + { + protected: + /** Initializes the iterator and makes it singular. */ + _Safe_local_iterator_base() + { } + + /** Initialize the iterator to reference the container pointed to + * by @p __seq. @p __constant is true when we are initializing a + * constant local iterator, and false if it is a mutable local iterator. + * Note that @p __seq may be NULL, in which case the iterator will be + * singular. Otherwise, the iterator will reference @p __seq and + * be nonsingular. + */ + _Safe_local_iterator_base(const _Safe_sequence_base* __seq, bool __constant) + { this->_M_attach(const_cast<_Safe_sequence_base*>(__seq), __constant); } + + /** Initializes the iterator to reference the same container that + @p __x does. @p __constant is true if this is a constant + iterator, and false if it is mutable. */ + _Safe_local_iterator_base(const _Safe_local_iterator_base& __x, + bool __constant) + { this->_M_attach(__x._M_sequence, __constant); } + + _Safe_local_iterator_base& + operator=(const _Safe_local_iterator_base&); + + explicit + _Safe_local_iterator_base(const _Safe_local_iterator_base&); + + ~_Safe_local_iterator_base() { this->_M_detach(); } + + _Safe_unordered_container_base* + _M_get_container() const _GLIBCXX_NOEXCEPT; + + public: + /** Attaches this iterator to the given container, detaching it + * from whatever container it was attached to originally. If the + * new container is the NULL pointer, the iterator is left + * unattached. + */ + void _M_attach(_Safe_sequence_base* __seq, bool __constant); + + /** Likewise, but not thread-safe. */ + void _M_attach_single(_Safe_sequence_base* __seq, bool __constant) throw (); + + /** Detach the iterator for whatever container it is attached to, + * if any. + */ + void _M_detach(); + + /** Likewise, but not thread-safe. */ + void _M_detach_single() throw (); + }; + + /** + * @brief Base class that supports tracking of local iterators that + * reference an unordered container. + * + * The %_Safe_unordered_container_base class provides basic support for + * tracking iterators into an unordered container. Containers that track + * iterators must derived from %_Safe_unordered_container_base publicly, so + * that safe iterators (which inherit _Safe_iterator_base) can + * attach to them. This class contains four linked lists of + * iterators, one for constant iterators, one for mutable + * iterators, one for constant local iterators, one for mutable local + * iterators and a version number that allows very fast + * invalidation of all iterators that reference the container. + * + * This class must ensure that no operation on it may throw an + * exception, otherwise @a safe containers may fail to provide the + * exception-safety guarantees required by the C++ standard. + */ + class _Safe_unordered_container_base : public _Safe_sequence_base + { + typedef _Safe_sequence_base _Base; + public: + /// The list of mutable local iterators that reference this container + _Safe_iterator_base* _M_local_iterators; + + /// The list of constant local iterators that reference this container + _Safe_iterator_base* _M_const_local_iterators; + + protected: + // Initialize with a version number of 1 and no iterators + _Safe_unordered_container_base() + : _M_local_iterators(nullptr), _M_const_local_iterators(nullptr) + { } + + // Initialize with a version number of 1 and no iterators + _Safe_unordered_container_base(const _Safe_unordered_container_base&) + noexcept + : _Safe_unordered_container_base() { } + + _Safe_unordered_container_base(_Safe_unordered_container_base&& __x) + noexcept + : _Safe_unordered_container_base() + { this->_M_swap(__x); } + + /** Notify all iterators that reference this container that the + container is being destroyed. */ + ~_Safe_unordered_container_base() + { this->_M_detach_all(); } + + /** Detach all iterators, leaving them singular. */ + void + _M_detach_all(); + + /** Swap this container with the given container. This operation + * also swaps ownership of the iterators, so that when the + * operation is complete all iterators that originally referenced + * one container now reference the other container. + */ + void + _M_swap(_Safe_unordered_container_base& __x); + + public: + /** Attach an iterator to this container. */ + void + _M_attach_local(_Safe_iterator_base* __it, bool __constant); + + /** Likewise but not thread safe. */ + void + _M_attach_local_single(_Safe_iterator_base* __it, bool __constant) throw (); + + /** Detach an iterator from this container */ + void + _M_detach_local(_Safe_iterator_base* __it); + + /** Likewise but not thread safe. */ + void + _M_detach_local_single(_Safe_iterator_base* __it) throw (); + }; +} // namespace __gnu_debug + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/safe_unordered_container.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/safe_unordered_container.h new file mode 100755 index 0000000..825dee9 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/safe_unordered_container.h @@ -0,0 +1,81 @@ +// Safe container implementation -*- C++ -*- + +// Copyright (C) 2011-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file debug/safe_unordered_container.h + * This file is a GNU debug extension to the Standard C++ Library. + */ + +#ifndef _GLIBCXX_DEBUG_SAFE_UNORDERED_CONTAINER_H +#define _GLIBCXX_DEBUG_SAFE_UNORDERED_CONTAINER_H 1 + +#include +#include +#include +#include + +namespace __gnu_debug +{ + /** + * @brief Base class for constructing a @a safe unordered container type + * that tracks iterators that reference it. + * + * The class template %_Safe_unordered_container simplifies the + * construction of @a safe unordered containers that track the iterators + * that reference the container, so that the iterators are notified of + * changes in the container that may affect their operation, e.g., if + * the container invalidates its iterators or is destructed. This class + * template may only be used by deriving from it and passing the name + * of the derived class as its template parameter via the curiously + * recurring template pattern. The derived class must have @c + * iterator and @c const_iterator types that are instantiations of + * class template _Safe_iterator for this container and @c local_iterator + * and @c const_local_iterator types that are instantiations of class + * template _Safe_local_iterator for this container. Iterators will + * then be tracked automatically. + */ + template + class _Safe_unordered_container : public _Safe_unordered_container_base + { + public: + /** Invalidates all iterators @c x that reference this container, + are not singular, and for which @c __pred(x) returns @c + true. @c __pred will be invoked with the normal iterators nested + in the safe ones. */ + template + void + _M_invalidate_if(_Predicate __pred); + + /** Invalidates all local iterators @c x that reference this container, + are not singular, and for which @c __pred(x) returns @c + true. @c __pred will be invoked with the normal ilocal iterators + nested in the safe ones. */ + template + void + _M_invalidate_local_if(_Predicate __pred); + }; +} // namespace __gnu_debug + +#include + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/safe_unordered_container.tcc b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/safe_unordered_container.tcc new file mode 100755 index 0000000..e2c237a --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/safe_unordered_container.tcc @@ -0,0 +1,100 @@ +// Safe container implementation -*- C++ -*- + +// Copyright (C) 2011-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file debug/safe_unordered_container.tcc + * This file is a GNU debug extension to the Standard C++ Library. + */ + +#ifndef _GLIBCXX_DEBUG_SAFE_UNORDERED_CONTAINER_TCC +#define _GLIBCXX_DEBUG_SAFE_UNORDERED_CONTAINER_TCC 1 + +namespace __gnu_debug +{ + template + template + void + _Safe_unordered_container<_Container>:: + _M_invalidate_if(_Predicate __pred) + { + typedef typename _Container::iterator iterator; + typedef typename _Container::const_iterator const_iterator; + + __gnu_cxx::__scoped_lock sentry(this->_M_get_mutex()); + for (_Safe_iterator_base* __iter = _M_iterators; __iter;) + { + iterator* __victim = static_cast(__iter); + __iter = __iter->_M_next; + if (!__victim->_M_singular() && __pred(__victim->base())) + { + __victim->_M_invalidate(); + } + } + + for (_Safe_iterator_base* __iter2 = _M_const_iterators; __iter2;) + { + const_iterator* __victim = static_cast(__iter2); + __iter2 = __iter2->_M_next; + if (!__victim->_M_singular() && __pred(__victim->base())) + { + __victim->_M_invalidate(); + } + } + } + + + template + template + void + _Safe_unordered_container<_Container>:: + _M_invalidate_local_if(_Predicate __pred) + { + typedef typename _Container::local_iterator local_iterator; + typedef typename _Container::const_local_iterator const_local_iterator; + + __gnu_cxx::__scoped_lock sentry(this->_M_get_mutex()); + for (_Safe_iterator_base* __iter = _M_local_iterators; __iter;) + { + local_iterator* __victim = static_cast(__iter); + __iter = __iter->_M_next; + if (!__victim->_M_singular() && __pred(__victim->base())) + { + __victim->_M_invalidate(); + } + } + + for (_Safe_iterator_base* __iter2 = _M_const_local_iterators; __iter2;) + { + const_local_iterator* __victim = + static_cast(__iter2); + __iter2 = __iter2->_M_next; + if (!__victim->_M_singular() && __pred(__victim->base())) + { + __victim->_M_invalidate(); + } + } + } + +} // namespace __gnu_debug + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/set b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/set new file mode 100755 index 0000000..d178b94 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/set @@ -0,0 +1,36 @@ +// Debugging set/multiset implementation -*- C++ -*- + +// Copyright (C) 2003-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file debug/set + * This file is a GNU debug extension to the Standard C++ Library. + */ + +#ifndef _GLIBCXX_DEBUG_SET +#define _GLIBCXX_DEBUG_SET 1 + +#include +#include +#include + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/set.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/set.h new file mode 100755 index 0000000..c83e2af --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/set.h @@ -0,0 +1,510 @@ +// Debugging set implementation -*- C++ -*- + +// Copyright (C) 2003-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file debug/set.h + * This file is a GNU debug extension to the Standard C++ Library. + */ + +#ifndef _GLIBCXX_DEBUG_SET_H +#define _GLIBCXX_DEBUG_SET_H 1 + +#include +#include +#include + +namespace std _GLIBCXX_VISIBILITY(default) +{ +namespace __debug +{ + /// Class std::set with safety/checking/debug instrumentation. + template, + typename _Allocator = std::allocator<_Key> > + class set + : public _GLIBCXX_STD_C::set<_Key,_Compare,_Allocator>, + public __gnu_debug::_Safe_sequence > + { + typedef _GLIBCXX_STD_C::set<_Key, _Compare, _Allocator> _Base; + + typedef typename _Base::const_iterator _Base_const_iterator; + typedef typename _Base::iterator _Base_iterator; + typedef __gnu_debug::_Equal_to<_Base_const_iterator> _Equal; +#if __cplusplus >= 201103L + typedef __gnu_cxx::__alloc_traits _Alloc_traits; +#endif + public: + // types: + typedef _Key key_type; + typedef _Key value_type; + typedef _Compare key_compare; + typedef _Compare value_compare; + typedef _Allocator allocator_type; + typedef typename _Base::reference reference; + typedef typename _Base::const_reference const_reference; + + typedef __gnu_debug::_Safe_iterator<_Base_iterator, set> + iterator; + typedef __gnu_debug::_Safe_iterator<_Base_const_iterator, set> + const_iterator; + + typedef typename _Base::size_type size_type; + typedef typename _Base::difference_type difference_type; + typedef typename _Base::pointer pointer; + typedef typename _Base::const_pointer const_pointer; + typedef std::reverse_iterator reverse_iterator; + typedef std::reverse_iterator const_reverse_iterator; + + // 23.3.3.1 construct/copy/destroy: + + set() : _Base() { } + + explicit set(const _Compare& __comp, + const _Allocator& __a = _Allocator()) + : _Base(__comp, __a) { } + + template + set(_InputIterator __first, _InputIterator __last, + const _Compare& __comp = _Compare(), + const _Allocator& __a = _Allocator()) + : _Base(__gnu_debug::__base(__gnu_debug::__check_valid_range(__first, + __last)), + __gnu_debug::__base(__last), + __comp, __a) { } + + set(const set& __x) + : _Base(__x) { } + + set(const _Base& __x) + : _Base(__x) { } + +#if __cplusplus >= 201103L + set(set&& __x) + noexcept(is_nothrow_copy_constructible<_Compare>::value) + : _Base(std::move(__x)) + { this->_M_swap(__x); } + + set(initializer_list __l, + const _Compare& __comp = _Compare(), + const allocator_type& __a = allocator_type()) + : _Base(__l, __comp, __a) { } + + explicit + set(const allocator_type& __a) + : _Base(__a) { } + + set(const set& __x, const allocator_type& __a) + : _Base(__x, __a) { } + + set(set&& __x, const allocator_type& __a) + : _Base(std::move(__x._M_base()), __a) { } + + set(initializer_list __l, const allocator_type& __a) + : _Base(__l, __a) + { } + + template + set(_InputIterator __first, _InputIterator __last, + const allocator_type& __a) + : _Base(__gnu_debug::__base(__gnu_debug::__check_valid_range(__first, + __last)), + __gnu_debug::__base(__last), __a) + { } +#endif + + ~set() _GLIBCXX_NOEXCEPT { } + + set& + operator=(const set& __x) + { + _M_base() = __x; + this->_M_invalidate_all(); + return *this; + } + +#if __cplusplus >= 201103L + set& + operator=(set&& __x) + noexcept(_Alloc_traits::_S_nothrow_move()) + { + __glibcxx_check_self_move_assign(__x); + bool __xfer_memory = _Alloc_traits::_S_propagate_on_move_assign() + || __x.get_allocator() == this->get_allocator(); + _M_base() = std::move(__x._M_base()); + if (__xfer_memory) + this->_M_swap(__x); + else + this->_M_invalidate_all(); + __x._M_invalidate_all(); + return *this; + } + + set& + operator=(initializer_list __l) + { + _M_base() = __l; + this->_M_invalidate_all(); + return *this; + } +#endif + + using _Base::get_allocator; + + // iterators: + iterator + begin() _GLIBCXX_NOEXCEPT + { return iterator(_Base::begin(), this); } + + const_iterator + begin() const _GLIBCXX_NOEXCEPT + { return const_iterator(_Base::begin(), this); } + + iterator + end() _GLIBCXX_NOEXCEPT + { return iterator(_Base::end(), this); } + + const_iterator + end() const _GLIBCXX_NOEXCEPT + { return const_iterator(_Base::end(), this); } + + reverse_iterator + rbegin() _GLIBCXX_NOEXCEPT + { return reverse_iterator(end()); } + + const_reverse_iterator + rbegin() const _GLIBCXX_NOEXCEPT + { return const_reverse_iterator(end()); } + + reverse_iterator + rend() _GLIBCXX_NOEXCEPT + { return reverse_iterator(begin()); } + + const_reverse_iterator + rend() const _GLIBCXX_NOEXCEPT + { return const_reverse_iterator(begin()); } + +#if __cplusplus >= 201103L + const_iterator + cbegin() const noexcept + { return const_iterator(_Base::begin(), this); } + + const_iterator + cend() const noexcept + { return const_iterator(_Base::end(), this); } + + const_reverse_iterator + crbegin() const noexcept + { return const_reverse_iterator(end()); } + + const_reverse_iterator + crend() const noexcept + { return const_reverse_iterator(begin()); } +#endif + + // capacity: + using _Base::empty; + using _Base::size; + using _Base::max_size; + + // modifiers: +#if __cplusplus >= 201103L + template + std::pair + emplace(_Args&&... __args) + { + auto __res = _Base::emplace(std::forward<_Args>(__args)...); + return std::pair(iterator(__res.first, this), + __res.second); + } + + template + iterator + emplace_hint(const_iterator __pos, _Args&&... __args) + { + __glibcxx_check_insert(__pos); + return iterator(_Base::emplace_hint(__pos.base(), + std::forward<_Args>(__args)...), + this); + } +#endif + + std::pair + insert(const value_type& __x) + { + std::pair<_Base_iterator, bool> __res = _Base::insert(__x); + return std::pair(iterator(__res.first, this), + __res.second); + } + +#if __cplusplus >= 201103L + std::pair + insert(value_type&& __x) + { + std::pair<_Base_iterator, bool> __res + = _Base::insert(std::move(__x)); + return std::pair(iterator(__res.first, this), + __res.second); + } +#endif + + iterator + insert(const_iterator __position, const value_type& __x) + { + __glibcxx_check_insert(__position); + return iterator(_Base::insert(__position.base(), __x), this); + } + +#if __cplusplus >= 201103L + iterator + insert(const_iterator __position, value_type&& __x) + { + __glibcxx_check_insert(__position); + return iterator(_Base::insert(__position.base(), std::move(__x)), + this); + } +#endif + + template + void + insert(_InputIterator __first, _InputIterator __last) + { + __glibcxx_check_valid_range(__first, __last); + _Base::insert(__gnu_debug::__base(__first), + __gnu_debug::__base(__last)); + } + +#if __cplusplus >= 201103L + void + insert(initializer_list __l) + { _Base::insert(__l); } +#endif + +#if __cplusplus >= 201103L + iterator + erase(const_iterator __position) + { + __glibcxx_check_erase(__position); + this->_M_invalidate_if(_Equal(__position.base())); + return iterator(_Base::erase(__position.base()), this); + } +#else + void + erase(iterator __position) + { + __glibcxx_check_erase(__position); + this->_M_invalidate_if(_Equal(__position.base())); + _Base::erase(__position.base()); + } +#endif + + size_type + erase(const key_type& __x) + { + _Base_iterator __victim = _Base::find(__x); + if (__victim == _Base::end()) + return 0; + else + { + this->_M_invalidate_if(_Equal(__victim)); + _Base::erase(__victim); + return 1; + } + } + +#if __cplusplus >= 201103L + iterator + erase(const_iterator __first, const_iterator __last) + { + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 151. can't currently clear() empty container + __glibcxx_check_erase_range(__first, __last); + for (_Base_const_iterator __victim = __first.base(); + __victim != __last.base(); ++__victim) + { + _GLIBCXX_DEBUG_VERIFY(__victim != _Base::end(), + _M_message(__gnu_debug::__msg_valid_range) + ._M_iterator(__first, "first") + ._M_iterator(__last, "last")); + this->_M_invalidate_if(_Equal(__victim)); + } + return iterator(_Base::erase(__first.base(), __last.base()), this); + } +#else + void + erase(iterator __first, iterator __last) + { + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 151. can't currently clear() empty container + __glibcxx_check_erase_range(__first, __last); + for (_Base_iterator __victim = __first.base(); + __victim != __last.base(); ++__victim) + { + _GLIBCXX_DEBUG_VERIFY(__victim != _Base::end(), + _M_message(__gnu_debug::__msg_valid_range) + ._M_iterator(__first, "first") + ._M_iterator(__last, "last")); + this->_M_invalidate_if(_Equal(__victim)); + } + _Base::erase(__first.base(), __last.base()); + } +#endif + + void + swap(set& __x) +#if __cplusplus >= 201103L + noexcept(_Alloc_traits::_S_nothrow_swap()) +#endif + { +#if __cplusplus >= 201103L + if (!_Alloc_traits::_S_propagate_on_swap()) + __glibcxx_check_equal_allocs(__x); +#endif + _Base::swap(__x); + this->_M_swap(__x); + } + + void + clear() _GLIBCXX_NOEXCEPT + { + this->_M_invalidate_all(); + _Base::clear(); + } + + // observers: + using _Base::key_comp; + using _Base::value_comp; + + // set operations: + iterator + find(const key_type& __x) + { return iterator(_Base::find(__x), this); } + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 214. set::find() missing const overload + const_iterator + find(const key_type& __x) const + { return const_iterator(_Base::find(__x), this); } + + using _Base::count; + + iterator + lower_bound(const key_type& __x) + { return iterator(_Base::lower_bound(__x), this); } + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 214. set::find() missing const overload + const_iterator + lower_bound(const key_type& __x) const + { return const_iterator(_Base::lower_bound(__x), this); } + + iterator + upper_bound(const key_type& __x) + { return iterator(_Base::upper_bound(__x), this); } + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 214. set::find() missing const overload + const_iterator + upper_bound(const key_type& __x) const + { return const_iterator(_Base::upper_bound(__x), this); } + + std::pair + equal_range(const key_type& __x) + { + std::pair<_Base_iterator, _Base_iterator> __res = + _Base::equal_range(__x); + return std::make_pair(iterator(__res.first, this), + iterator(__res.second, this)); + } + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 214. set::find() missing const overload + std::pair + equal_range(const key_type& __x) const + { + std::pair<_Base_iterator, _Base_iterator> __res = + _Base::equal_range(__x); + return std::make_pair(const_iterator(__res.first, this), + const_iterator(__res.second, this)); + } + + _Base& + _M_base() _GLIBCXX_NOEXCEPT { return *this; } + + const _Base& + _M_base() const _GLIBCXX_NOEXCEPT { return *this; } + + private: + void + _M_invalidate_all() + { + typedef __gnu_debug::_Not_equal_to<_Base_const_iterator> _Not_equal; + this->_M_invalidate_if(_Not_equal(_M_base().end())); + } + }; + + template + inline bool + operator==(const set<_Key, _Compare, _Allocator>& __lhs, + const set<_Key, _Compare, _Allocator>& __rhs) + { return __lhs._M_base() == __rhs._M_base(); } + + template + inline bool + operator!=(const set<_Key, _Compare, _Allocator>& __lhs, + const set<_Key, _Compare, _Allocator>& __rhs) + { return __lhs._M_base() != __rhs._M_base(); } + + template + inline bool + operator<(const set<_Key, _Compare, _Allocator>& __lhs, + const set<_Key, _Compare, _Allocator>& __rhs) + { return __lhs._M_base() < __rhs._M_base(); } + + template + inline bool + operator<=(const set<_Key, _Compare, _Allocator>& __lhs, + const set<_Key, _Compare, _Allocator>& __rhs) + { return __lhs._M_base() <= __rhs._M_base(); } + + template + inline bool + operator>=(const set<_Key, _Compare, _Allocator>& __lhs, + const set<_Key, _Compare, _Allocator>& __rhs) + { return __lhs._M_base() >= __rhs._M_base(); } + + template + inline bool + operator>(const set<_Key, _Compare, _Allocator>& __lhs, + const set<_Key, _Compare, _Allocator>& __rhs) + { return __lhs._M_base() > __rhs._M_base(); } + + template + void + swap(set<_Key, _Compare, _Allocator>& __x, + set<_Key, _Compare, _Allocator>& __y) + { return __x.swap(__y); } + +} // namespace __debug +} // namespace std + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/string b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/string new file mode 100755 index 0000000..8edc9c4 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/string @@ -0,0 +1,1167 @@ +// Debugging string implementation -*- C++ -*- + +// Copyright (C) 2003-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file debug/string + * This file is a GNU debug extension to the Standard C++ Library. + */ + +#ifndef _GLIBCXX_DEBUG_STRING +#define _GLIBCXX_DEBUG_STRING 1 + +#include +#include +#include + +namespace __gnu_debug +{ + /// Class std::basic_string with safety/checking/debug instrumentation. + template, + typename _Allocator = std::allocator<_CharT> > + class basic_string + : public std::basic_string<_CharT, _Traits, _Allocator>, + public __gnu_debug::_Safe_sequence > + { + typedef std::basic_string<_CharT, _Traits, _Allocator> _Base; + typedef __gnu_debug::_Safe_sequence _Safe_base; + + public: + // types: + typedef _Traits traits_type; + typedef typename _Traits::char_type value_type; + typedef _Allocator allocator_type; + typedef typename _Base::size_type size_type; + typedef typename _Base::difference_type difference_type; + typedef typename _Base::reference reference; + typedef typename _Base::const_reference const_reference; + typedef typename _Base::pointer pointer; + typedef typename _Base::const_pointer const_pointer; + + typedef __gnu_debug::_Safe_iterator + iterator; + typedef __gnu_debug::_Safe_iterator const_iterator; + + typedef std::reverse_iterator reverse_iterator; + typedef std::reverse_iterator const_reverse_iterator; + + using _Base::npos; + + // 21.3.1 construct/copy/destroy: + explicit basic_string(const _Allocator& __a = _Allocator()) + // _GLIBCXX_NOEXCEPT + : _Base(__a) + { } + + // Provides conversion from a release-mode string to a debug-mode string + basic_string(const _Base& __base) : _Base(__base) { } + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 42. string ctors specify wrong default allocator + basic_string(const basic_string& __str) + : _Base(__str, 0, _Base::npos, __str.get_allocator()) + { } + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 42. string ctors specify wrong default allocator + basic_string(const basic_string& __str, size_type __pos, + size_type __n = _Base::npos, + const _Allocator& __a = _Allocator()) + : _Base(__str, __pos, __n, __a) + { } + + basic_string(const _CharT* __s, size_type __n, + const _Allocator& __a = _Allocator()) + : _Base(__gnu_debug::__check_string(__s, __n), __n, __a) + { } + + basic_string(const _CharT* __s, const _Allocator& __a = _Allocator()) + : _Base(__gnu_debug::__check_string(__s), __a) + { this->assign(__s); } + + basic_string(size_type __n, _CharT __c, + const _Allocator& __a = _Allocator()) + : _Base(__n, __c, __a) + { } + + template + basic_string(_InputIterator __begin, _InputIterator __end, + const _Allocator& __a = _Allocator()) + : _Base(__gnu_debug::__base(__gnu_debug::__check_valid_range(__begin, + __end)), + __gnu_debug::__base(__end), __a) + { } + +#if __cplusplus >= 201103L + basic_string(basic_string&& __str) // noexcept + : _Base(std::move(__str)) + { } + + basic_string(std::initializer_list<_CharT> __l, + const _Allocator& __a = _Allocator()) + : _Base(__l, __a) + { } +#endif // C++11 + + ~basic_string() _GLIBCXX_NOEXCEPT { } + + basic_string& + operator=(const basic_string& __str) + { + *static_cast<_Base*>(this) = __str; + this->_M_invalidate_all(); + return *this; + } + + basic_string& + operator=(const _CharT* __s) + { + __glibcxx_check_string(__s); + *static_cast<_Base*>(this) = __s; + this->_M_invalidate_all(); + return *this; + } + + basic_string& + operator=(_CharT __c) + { + *static_cast<_Base*>(this) = __c; + this->_M_invalidate_all(); + return *this; + } + +#if __cplusplus >= 201103L + basic_string& + operator=(basic_string&& __str) + { + __glibcxx_check_self_move_assign(__str); + *static_cast<_Base*>(this) = std::move(__str); + this->_M_invalidate_all(); + return *this; + } + + basic_string& + operator=(std::initializer_list<_CharT> __l) + { + *static_cast<_Base*>(this) = __l; + this->_M_invalidate_all(); + return *this; + } +#endif // C++11 + + // 21.3.2 iterators: + iterator + begin() // _GLIBCXX_NOEXCEPT + { return iterator(_Base::begin(), this); } + + const_iterator + begin() const _GLIBCXX_NOEXCEPT + { return const_iterator(_Base::begin(), this); } + + iterator + end() // _GLIBCXX_NOEXCEPT + { return iterator(_Base::end(), this); } + + const_iterator + end() const _GLIBCXX_NOEXCEPT + { return const_iterator(_Base::end(), this); } + + reverse_iterator + rbegin() // _GLIBCXX_NOEXCEPT + { return reverse_iterator(end()); } + + const_reverse_iterator + rbegin() const _GLIBCXX_NOEXCEPT + { return const_reverse_iterator(end()); } + + reverse_iterator + rend() // _GLIBCXX_NOEXCEPT + { return reverse_iterator(begin()); } + + const_reverse_iterator + rend() const _GLIBCXX_NOEXCEPT + { return const_reverse_iterator(begin()); } + +#if __cplusplus >= 201103L + const_iterator + cbegin() const noexcept + { return const_iterator(_Base::begin(), this); } + + const_iterator + cend() const noexcept + { return const_iterator(_Base::end(), this); } + + const_reverse_iterator + crbegin() const noexcept + { return const_reverse_iterator(end()); } + + const_reverse_iterator + crend() const noexcept + { return const_reverse_iterator(begin()); } +#endif + + // 21.3.3 capacity: + using _Base::size; + using _Base::length; + using _Base::max_size; + + void + resize(size_type __n, _CharT __c) + { + _Base::resize(__n, __c); + this->_M_invalidate_all(); + } + + void + resize(size_type __n) + { this->resize(__n, _CharT()); } + +#if __cplusplus >= 201103L + void + shrink_to_fit() noexcept + { + if (capacity() > size()) + { + __try + { + reserve(0); + this->_M_invalidate_all(); + } + __catch(...) + { } + } + } +#endif + + using _Base::capacity; + using _Base::reserve; + + void + clear() // _GLIBCXX_NOEXCEPT + { + _Base::clear(); + this->_M_invalidate_all(); + } + + using _Base::empty; + + // 21.3.4 element access: + const_reference + operator[](size_type __pos) const _GLIBCXX_NOEXCEPT + { + _GLIBCXX_DEBUG_VERIFY(__pos <= this->size(), + _M_message(__gnu_debug::__msg_subscript_oob) + ._M_sequence(*this, "this") + ._M_integer(__pos, "__pos") + ._M_integer(this->size(), "size")); + return _M_base()[__pos]; + } + + reference + operator[](size_type __pos) // _GLIBCXX_NOEXCEPT + { +#ifdef _GLIBCXX_DEBUG_PEDANTIC + __glibcxx_check_subscript(__pos); +#else + // as an extension v3 allows s[s.size()] when s is non-const. + _GLIBCXX_DEBUG_VERIFY(__pos <= this->size(), + _M_message(__gnu_debug::__msg_subscript_oob) + ._M_sequence(*this, "this") + ._M_integer(__pos, "__pos") + ._M_integer(this->size(), "size")); +#endif + return _M_base()[__pos]; + } + + using _Base::at; + +#if __cplusplus >= 201103L + using _Base::front; + using _Base::back; +#endif + + // 21.3.5 modifiers: + basic_string& + operator+=(const basic_string& __str) + { + _M_base() += __str; + this->_M_invalidate_all(); + return *this; + } + + basic_string& + operator+=(const _CharT* __s) + { + __glibcxx_check_string(__s); + _M_base() += __s; + this->_M_invalidate_all(); + return *this; + } + + basic_string& + operator+=(_CharT __c) + { + _M_base() += __c; + this->_M_invalidate_all(); + return *this; + } + +#if __cplusplus >= 201103L + basic_string& + operator+=(std::initializer_list<_CharT> __l) + { + _M_base() += __l; + this->_M_invalidate_all(); + return *this; + } +#endif // C++11 + + basic_string& + append(const basic_string& __str) + { + _Base::append(__str); + this->_M_invalidate_all(); + return *this; + } + + basic_string& + append(const basic_string& __str, size_type __pos, size_type __n) + { + _Base::append(__str, __pos, __n); + this->_M_invalidate_all(); + return *this; + } + + basic_string& + append(const _CharT* __s, size_type __n) + { + __glibcxx_check_string_len(__s, __n); + _Base::append(__s, __n); + this->_M_invalidate_all(); + return *this; + } + + basic_string& + append(const _CharT* __s) + { + __glibcxx_check_string(__s); + _Base::append(__s); + this->_M_invalidate_all(); + return *this; + } + + basic_string& + append(size_type __n, _CharT __c) + { + _Base::append(__n, __c); + this->_M_invalidate_all(); + return *this; + } + + template + basic_string& + append(_InputIterator __first, _InputIterator __last) + { + __glibcxx_check_valid_range(__first, __last); + _Base::append(__gnu_debug::__base(__first), + __gnu_debug::__base(__last)); + this->_M_invalidate_all(); + return *this; + } + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 7. string clause minor problems + void + push_back(_CharT __c) + { + _Base::push_back(__c); + this->_M_invalidate_all(); + } + + basic_string& + assign(const basic_string& __x) + { + _Base::assign(__x); + this->_M_invalidate_all(); + return *this; + } + +#if __cplusplus >= 201103L + basic_string& + assign(basic_string&& __x) + { + _Base::assign(std::move(__x)); + this->_M_invalidate_all(); + return *this; + } +#endif // C++11 + + basic_string& + assign(const basic_string& __str, size_type __pos, size_type __n) + { + _Base::assign(__str, __pos, __n); + this->_M_invalidate_all(); + return *this; + } + + basic_string& + assign(const _CharT* __s, size_type __n) + { + __glibcxx_check_string_len(__s, __n); + _Base::assign(__s, __n); + this->_M_invalidate_all(); + return *this; + } + + basic_string& + assign(const _CharT* __s) + { + __glibcxx_check_string(__s); + _Base::assign(__s); + this->_M_invalidate_all(); + return *this; + } + + basic_string& + assign(size_type __n, _CharT __c) + { + _Base::assign(__n, __c); + this->_M_invalidate_all(); + return *this; + } + + template + basic_string& + assign(_InputIterator __first, _InputIterator __last) + { + __glibcxx_check_valid_range(__first, __last); + _Base::assign(__gnu_debug::__base(__first), + __gnu_debug::__base(__last)); + this->_M_invalidate_all(); + return *this; + } + +#if __cplusplus >= 201103L + basic_string& + assign(std::initializer_list<_CharT> __l) + { + _Base::assign(__l); + this->_M_invalidate_all(); + return *this; + } +#endif // C++11 + + basic_string& + insert(size_type __pos1, const basic_string& __str) + { + _Base::insert(__pos1, __str); + this->_M_invalidate_all(); + return *this; + } + + basic_string& + insert(size_type __pos1, const basic_string& __str, + size_type __pos2, size_type __n) + { + _Base::insert(__pos1, __str, __pos2, __n); + this->_M_invalidate_all(); + return *this; + } + + basic_string& + insert(size_type __pos, const _CharT* __s, size_type __n) + { + __glibcxx_check_string(__s); + _Base::insert(__pos, __s, __n); + this->_M_invalidate_all(); + return *this; + } + + basic_string& + insert(size_type __pos, const _CharT* __s) + { + __glibcxx_check_string(__s); + _Base::insert(__pos, __s); + this->_M_invalidate_all(); + return *this; + } + + basic_string& + insert(size_type __pos, size_type __n, _CharT __c) + { + _Base::insert(__pos, __n, __c); + this->_M_invalidate_all(); + return *this; + } + + iterator + insert(iterator __p, _CharT __c) + { + __glibcxx_check_insert(__p); + typename _Base::iterator __res = _Base::insert(__p.base(), __c); + this->_M_invalidate_all(); + return iterator(__res, this); + } + + void + insert(iterator __p, size_type __n, _CharT __c) + { + __glibcxx_check_insert(__p); + _Base::insert(__p.base(), __n, __c); + this->_M_invalidate_all(); + } + + template + void + insert(iterator __p, _InputIterator __first, _InputIterator __last) + { + __glibcxx_check_insert_range(__p, __first, __last); + _Base::insert(__p.base(), __gnu_debug::__base(__first), + __gnu_debug::__base(__last)); + this->_M_invalidate_all(); + } + +#if __cplusplus >= 201103L + void + insert(iterator __p, std::initializer_list<_CharT> __l) + { + __glibcxx_check_insert(__p); + _Base::insert(__p.base(), __l); + this->_M_invalidate_all(); + } +#endif // C++11 + + basic_string& + erase(size_type __pos = 0, size_type __n = _Base::npos) + { + _Base::erase(__pos, __n); + this->_M_invalidate_all(); + return *this; + } + + iterator + erase(iterator __position) + { + __glibcxx_check_erase(__position); + typename _Base::iterator __res = _Base::erase(__position.base()); + this->_M_invalidate_all(); + return iterator(__res, this); + } + + iterator + erase(iterator __first, iterator __last) + { + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 151. can't currently clear() empty container + __glibcxx_check_erase_range(__first, __last); + typename _Base::iterator __res = _Base::erase(__first.base(), + __last.base()); + this->_M_invalidate_all(); + return iterator(__res, this); + } + +#if __cplusplus >= 201103L + void + pop_back() // noexcept + { + __glibcxx_check_nonempty(); + _Base::pop_back(); + this->_M_invalidate_all(); + } +#endif // C++11 + + basic_string& + replace(size_type __pos1, size_type __n1, const basic_string& __str) + { + _Base::replace(__pos1, __n1, __str); + this->_M_invalidate_all(); + return *this; + } + + basic_string& + replace(size_type __pos1, size_type __n1, const basic_string& __str, + size_type __pos2, size_type __n2) + { + _Base::replace(__pos1, __n1, __str, __pos2, __n2); + this->_M_invalidate_all(); + return *this; + } + + basic_string& + replace(size_type __pos, size_type __n1, const _CharT* __s, + size_type __n2) + { + __glibcxx_check_string_len(__s, __n2); + _Base::replace(__pos, __n1, __s, __n2); + this->_M_invalidate_all(); + return *this; + } + + basic_string& + replace(size_type __pos, size_type __n1, const _CharT* __s) + { + __glibcxx_check_string(__s); + _Base::replace(__pos, __n1, __s); + this->_M_invalidate_all(); + return *this; + } + + basic_string& + replace(size_type __pos, size_type __n1, size_type __n2, _CharT __c) + { + _Base::replace(__pos, __n1, __n2, __c); + this->_M_invalidate_all(); + return *this; + } + + basic_string& + replace(iterator __i1, iterator __i2, const basic_string& __str) + { + __glibcxx_check_erase_range(__i1, __i2); + _Base::replace(__i1.base(), __i2.base(), __str); + this->_M_invalidate_all(); + return *this; + } + + basic_string& + replace(iterator __i1, iterator __i2, const _CharT* __s, size_type __n) + { + __glibcxx_check_erase_range(__i1, __i2); + __glibcxx_check_string_len(__s, __n); + _Base::replace(__i1.base(), __i2.base(), __s, __n); + this->_M_invalidate_all(); + return *this; + } + + basic_string& + replace(iterator __i1, iterator __i2, const _CharT* __s) + { + __glibcxx_check_erase_range(__i1, __i2); + __glibcxx_check_string(__s); + _Base::replace(__i1.base(), __i2.base(), __s); + this->_M_invalidate_all(); + return *this; + } + + basic_string& + replace(iterator __i1, iterator __i2, size_type __n, _CharT __c) + { + __glibcxx_check_erase_range(__i1, __i2); + _Base::replace(__i1.base(), __i2.base(), __n, __c); + this->_M_invalidate_all(); + return *this; + } + + template + basic_string& + replace(iterator __i1, iterator __i2, + _InputIterator __j1, _InputIterator __j2) + { + __glibcxx_check_erase_range(__i1, __i2); + __glibcxx_check_valid_range(__j1, __j2); + _Base::replace(__i1.base(), __i2.base(), __j1, __j2); + this->_M_invalidate_all(); + return *this; + } + +#if __cplusplus >= 201103L + basic_string& replace(iterator __i1, iterator __i2, + std::initializer_list<_CharT> __l) + { + __glibcxx_check_erase_range(__i1, __i2); + _Base::replace(__i1.base(), __i2.base(), __l); + this->_M_invalidate_all(); + return *this; + } +#endif // C++11 + + size_type + copy(_CharT* __s, size_type __n, size_type __pos = 0) const + { + __glibcxx_check_string_len(__s, __n); + return _Base::copy(__s, __n, __pos); + } + + void + swap(basic_string<_CharT,_Traits,_Allocator>& __x) + { + _Base::swap(__x); + this->_M_swap(__x); + this->_M_invalidate_all(); + __x._M_invalidate_all(); + } + + // 21.3.6 string operations: + const _CharT* + c_str() const _GLIBCXX_NOEXCEPT + { + const _CharT* __res = _Base::c_str(); + this->_M_invalidate_all(); + return __res; + } + + const _CharT* + data() const _GLIBCXX_NOEXCEPT + { + const _CharT* __res = _Base::data(); + this->_M_invalidate_all(); + return __res; + } + + using _Base::get_allocator; + + size_type + find(const basic_string& __str, size_type __pos = 0) const + _GLIBCXX_NOEXCEPT + { return _Base::find(__str, __pos); } + + size_type + find(const _CharT* __s, size_type __pos, size_type __n) const + { + __glibcxx_check_string(__s); + return _Base::find(__s, __pos, __n); + } + + size_type + find(const _CharT* __s, size_type __pos = 0) const + { + __glibcxx_check_string(__s); + return _Base::find(__s, __pos); + } + + size_type + find(_CharT __c, size_type __pos = 0) const _GLIBCXX_NOEXCEPT + { return _Base::find(__c, __pos); } + + size_type + rfind(const basic_string& __str, size_type __pos = _Base::npos) const + _GLIBCXX_NOEXCEPT + { return _Base::rfind(__str, __pos); } + + size_type + rfind(const _CharT* __s, size_type __pos, size_type __n) const + { + __glibcxx_check_string_len(__s, __n); + return _Base::rfind(__s, __pos, __n); + } + + size_type + rfind(const _CharT* __s, size_type __pos = _Base::npos) const + { + __glibcxx_check_string(__s); + return _Base::rfind(__s, __pos); + } + + size_type + rfind(_CharT __c, size_type __pos = _Base::npos) const _GLIBCXX_NOEXCEPT + { return _Base::rfind(__c, __pos); } + + size_type + find_first_of(const basic_string& __str, size_type __pos = 0) const + _GLIBCXX_NOEXCEPT + { return _Base::find_first_of(__str, __pos); } + + size_type + find_first_of(const _CharT* __s, size_type __pos, size_type __n) const + { + __glibcxx_check_string(__s); + return _Base::find_first_of(__s, __pos, __n); + } + + size_type + find_first_of(const _CharT* __s, size_type __pos = 0) const + { + __glibcxx_check_string(__s); + return _Base::find_first_of(__s, __pos); + } + + size_type + find_first_of(_CharT __c, size_type __pos = 0) const _GLIBCXX_NOEXCEPT + { return _Base::find_first_of(__c, __pos); } + + size_type + find_last_of(const basic_string& __str, + size_type __pos = _Base::npos) const _GLIBCXX_NOEXCEPT + { return _Base::find_last_of(__str, __pos); } + + size_type + find_last_of(const _CharT* __s, size_type __pos, size_type __n) const + { + __glibcxx_check_string(__s); + return _Base::find_last_of(__s, __pos, __n); + } + + size_type + find_last_of(const _CharT* __s, size_type __pos = _Base::npos) const + { + __glibcxx_check_string(__s); + return _Base::find_last_of(__s, __pos); + } + + size_type + find_last_of(_CharT __c, size_type __pos = _Base::npos) const + _GLIBCXX_NOEXCEPT + { return _Base::find_last_of(__c, __pos); } + + size_type + find_first_not_of(const basic_string& __str, size_type __pos = 0) const + _GLIBCXX_NOEXCEPT + { return _Base::find_first_not_of(__str, __pos); } + + size_type + find_first_not_of(const _CharT* __s, size_type __pos, size_type __n) const + { + __glibcxx_check_string_len(__s, __n); + return _Base::find_first_not_of(__s, __pos, __n); + } + + size_type + find_first_not_of(const _CharT* __s, size_type __pos = 0) const + { + __glibcxx_check_string(__s); + return _Base::find_first_not_of(__s, __pos); + } + + size_type + find_first_not_of(_CharT __c, size_type __pos = 0) const _GLIBCXX_NOEXCEPT + { return _Base::find_first_not_of(__c, __pos); } + + size_type + find_last_not_of(const basic_string& __str, + size_type __pos = _Base::npos) const + _GLIBCXX_NOEXCEPT + { return _Base::find_last_not_of(__str, __pos); } + + size_type + find_last_not_of(const _CharT* __s, size_type __pos, size_type __n) const + { + __glibcxx_check_string(__s); + return _Base::find_last_not_of(__s, __pos, __n); + } + + size_type + find_last_not_of(const _CharT* __s, size_type __pos = _Base::npos) const + { + __glibcxx_check_string(__s); + return _Base::find_last_not_of(__s, __pos); + } + + size_type + find_last_not_of(_CharT __c, size_type __pos = _Base::npos) const + _GLIBCXX_NOEXCEPT + { return _Base::find_last_not_of(__c, __pos); } + + basic_string + substr(size_type __pos = 0, size_type __n = _Base::npos) const + { return basic_string(_Base::substr(__pos, __n)); } + + int + compare(const basic_string& __str) const + { return _Base::compare(__str); } + + int + compare(size_type __pos1, size_type __n1, + const basic_string& __str) const + { return _Base::compare(__pos1, __n1, __str); } + + int + compare(size_type __pos1, size_type __n1, const basic_string& __str, + size_type __pos2, size_type __n2) const + { return _Base::compare(__pos1, __n1, __str, __pos2, __n2); } + + int + compare(const _CharT* __s) const + { + __glibcxx_check_string(__s); + return _Base::compare(__s); + } + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 5. string::compare specification questionable + int + compare(size_type __pos1, size_type __n1, const _CharT* __s) const + { + __glibcxx_check_string(__s); + return _Base::compare(__pos1, __n1, __s); + } + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 5. string::compare specification questionable + int + compare(size_type __pos1, size_type __n1,const _CharT* __s, + size_type __n2) const + { + __glibcxx_check_string_len(__s, __n2); + return _Base::compare(__pos1, __n1, __s, __n2); + } + + _Base& + _M_base() _GLIBCXX_NOEXCEPT { return *this; } + + const _Base& + _M_base() const _GLIBCXX_NOEXCEPT { return *this; } + + using _Safe_base::_M_invalidate_all; + }; + + template + inline basic_string<_CharT,_Traits,_Allocator> + operator+(const basic_string<_CharT,_Traits,_Allocator>& __lhs, + const basic_string<_CharT,_Traits,_Allocator>& __rhs) + { return basic_string<_CharT,_Traits,_Allocator>(__lhs) += __rhs; } + + template + inline basic_string<_CharT,_Traits,_Allocator> + operator+(const _CharT* __lhs, + const basic_string<_CharT,_Traits,_Allocator>& __rhs) + { + __glibcxx_check_string(__lhs); + return basic_string<_CharT,_Traits,_Allocator>(__lhs) += __rhs; + } + + template + inline basic_string<_CharT,_Traits,_Allocator> + operator+(_CharT __lhs, + const basic_string<_CharT,_Traits,_Allocator>& __rhs) + { return basic_string<_CharT,_Traits,_Allocator>(1, __lhs) += __rhs; } + + template + inline basic_string<_CharT,_Traits,_Allocator> + operator+(const basic_string<_CharT,_Traits,_Allocator>& __lhs, + const _CharT* __rhs) + { + __glibcxx_check_string(__rhs); + return basic_string<_CharT,_Traits,_Allocator>(__lhs) += __rhs; + } + + template + inline basic_string<_CharT,_Traits,_Allocator> + operator+(const basic_string<_CharT,_Traits,_Allocator>& __lhs, + _CharT __rhs) + { return basic_string<_CharT,_Traits,_Allocator>(__lhs) += __rhs; } + + template + inline bool + operator==(const basic_string<_CharT,_Traits,_Allocator>& __lhs, + const basic_string<_CharT,_Traits,_Allocator>& __rhs) + { return __lhs._M_base() == __rhs._M_base(); } + + template + inline bool + operator==(const _CharT* __lhs, + const basic_string<_CharT,_Traits,_Allocator>& __rhs) + { + __glibcxx_check_string(__lhs); + return __lhs == __rhs._M_base(); + } + + template + inline bool + operator==(const basic_string<_CharT,_Traits,_Allocator>& __lhs, + const _CharT* __rhs) + { + __glibcxx_check_string(__rhs); + return __lhs._M_base() == __rhs; + } + + template + inline bool + operator!=(const basic_string<_CharT,_Traits,_Allocator>& __lhs, + const basic_string<_CharT,_Traits,_Allocator>& __rhs) + { return __lhs._M_base() != __rhs._M_base(); } + + template + inline bool + operator!=(const _CharT* __lhs, + const basic_string<_CharT,_Traits,_Allocator>& __rhs) + { + __glibcxx_check_string(__lhs); + return __lhs != __rhs._M_base(); + } + + template + inline bool + operator!=(const basic_string<_CharT,_Traits,_Allocator>& __lhs, + const _CharT* __rhs) + { + __glibcxx_check_string(__rhs); + return __lhs._M_base() != __rhs; + } + + template + inline bool + operator<(const basic_string<_CharT,_Traits,_Allocator>& __lhs, + const basic_string<_CharT,_Traits,_Allocator>& __rhs) + { return __lhs._M_base() < __rhs._M_base(); } + + template + inline bool + operator<(const _CharT* __lhs, + const basic_string<_CharT,_Traits,_Allocator>& __rhs) + { + __glibcxx_check_string(__lhs); + return __lhs < __rhs._M_base(); + } + + template + inline bool + operator<(const basic_string<_CharT,_Traits,_Allocator>& __lhs, + const _CharT* __rhs) + { + __glibcxx_check_string(__rhs); + return __lhs._M_base() < __rhs; + } + + template + inline bool + operator<=(const basic_string<_CharT,_Traits,_Allocator>& __lhs, + const basic_string<_CharT,_Traits,_Allocator>& __rhs) + { return __lhs._M_base() <= __rhs._M_base(); } + + template + inline bool + operator<=(const _CharT* __lhs, + const basic_string<_CharT,_Traits,_Allocator>& __rhs) + { + __glibcxx_check_string(__lhs); + return __lhs <= __rhs._M_base(); + } + + template + inline bool + operator<=(const basic_string<_CharT,_Traits,_Allocator>& __lhs, + const _CharT* __rhs) + { + __glibcxx_check_string(__rhs); + return __lhs._M_base() <= __rhs; + } + + template + inline bool + operator>=(const basic_string<_CharT,_Traits,_Allocator>& __lhs, + const basic_string<_CharT,_Traits,_Allocator>& __rhs) + { return __lhs._M_base() >= __rhs._M_base(); } + + template + inline bool + operator>=(const _CharT* __lhs, + const basic_string<_CharT,_Traits,_Allocator>& __rhs) + { + __glibcxx_check_string(__lhs); + return __lhs >= __rhs._M_base(); + } + + template + inline bool + operator>=(const basic_string<_CharT,_Traits,_Allocator>& __lhs, + const _CharT* __rhs) + { + __glibcxx_check_string(__rhs); + return __lhs._M_base() >= __rhs; + } + + template + inline bool + operator>(const basic_string<_CharT,_Traits,_Allocator>& __lhs, + const basic_string<_CharT,_Traits,_Allocator>& __rhs) + { return __lhs._M_base() > __rhs._M_base(); } + + template + inline bool + operator>(const _CharT* __lhs, + const basic_string<_CharT,_Traits,_Allocator>& __rhs) + { + __glibcxx_check_string(__lhs); + return __lhs > __rhs._M_base(); + } + + template + inline bool + operator>(const basic_string<_CharT,_Traits,_Allocator>& __lhs, + const _CharT* __rhs) + { + __glibcxx_check_string(__rhs); + return __lhs._M_base() > __rhs; + } + + // 21.3.7.8: + template + inline void + swap(basic_string<_CharT,_Traits,_Allocator>& __lhs, + basic_string<_CharT,_Traits,_Allocator>& __rhs) + { __lhs.swap(__rhs); } + + template + std::basic_ostream<_CharT, _Traits>& + operator<<(std::basic_ostream<_CharT, _Traits>& __os, + const basic_string<_CharT, _Traits, _Allocator>& __str) + { return __os << __str._M_base(); } + + template + std::basic_istream<_CharT,_Traits>& + operator>>(std::basic_istream<_CharT,_Traits>& __is, + basic_string<_CharT,_Traits,_Allocator>& __str) + { + std::basic_istream<_CharT,_Traits>& __res = __is >> __str._M_base(); + __str._M_invalidate_all(); + return __res; + } + + template + std::basic_istream<_CharT,_Traits>& + getline(std::basic_istream<_CharT,_Traits>& __is, + basic_string<_CharT,_Traits,_Allocator>& __str, _CharT __delim) + { + std::basic_istream<_CharT,_Traits>& __res = getline(__is, + __str._M_base(), + __delim); + __str._M_invalidate_all(); + return __res; + } + + template + std::basic_istream<_CharT,_Traits>& + getline(std::basic_istream<_CharT,_Traits>& __is, + basic_string<_CharT,_Traits,_Allocator>& __str) + { + std::basic_istream<_CharT,_Traits>& __res = getline(__is, + __str._M_base()); + __str._M_invalidate_all(); + return __res; + } + + typedef basic_string string; + +#ifdef _GLIBCXX_USE_WCHAR_T + typedef basic_string wstring; +#endif + + template + struct _Insert_range_from_self_is_safe< + __gnu_debug::basic_string<_CharT, _Traits, _Allocator> > + { enum { __value = 1 }; }; + +} // namespace __gnu_debug + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/unordered_map b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/unordered_map new file mode 100755 index 0000000..626beba --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/unordered_map @@ -0,0 +1,955 @@ +// Debugging unordered_map/unordered_multimap implementation -*- C++ -*- + +// Copyright (C) 2003-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file debug/unordered_map + * This file is a GNU debug extension to the Standard C++ Library. + */ + +#ifndef _GLIBCXX_DEBUG_UNORDERED_MAP +#define _GLIBCXX_DEBUG_UNORDERED_MAP 1 + +#if __cplusplus < 201103L +# include +#else +# include + +#include +#include +#include + +namespace std _GLIBCXX_VISIBILITY(default) +{ +namespace __debug +{ + /// Class std::unordered_map with safety/checking/debug instrumentation. + template, + typename _Pred = std::equal_to<_Key>, + typename _Alloc = std::allocator > > + class unordered_map + : public _GLIBCXX_STD_C::unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>, + public __gnu_debug::_Safe_unordered_container > + { + typedef _GLIBCXX_STD_C::unordered_map<_Key, _Tp, _Hash, + _Pred, _Alloc> _Base; + typedef __gnu_debug::_Safe_unordered_container _Safe_base; + typedef typename _Base::const_iterator _Base_const_iterator; + typedef typename _Base::iterator _Base_iterator; + typedef typename _Base::const_local_iterator _Base_const_local_iterator; + typedef typename _Base::local_iterator _Base_local_iterator; + + typedef __gnu_cxx::__alloc_traits _Alloc_traits; + + public: + typedef typename _Base::size_type size_type; + typedef typename _Base::hasher hasher; + typedef typename _Base::key_equal key_equal; + typedef typename _Base::allocator_type allocator_type; + + typedef typename _Base::key_type key_type; + typedef typename _Base::value_type value_type; + + typedef __gnu_debug::_Safe_iterator<_Base_iterator, + unordered_map> iterator; + typedef __gnu_debug::_Safe_iterator<_Base_const_iterator, + unordered_map> const_iterator; + typedef __gnu_debug::_Safe_local_iterator<_Base_local_iterator, + unordered_map> local_iterator; + typedef __gnu_debug::_Safe_local_iterator<_Base_const_local_iterator, + unordered_map> const_local_iterator; + + explicit + unordered_map(size_type __n = 10, + const hasher& __hf = hasher(), + const key_equal& __eql = key_equal(), + const allocator_type& __a = allocator_type()) + : _Base(__n, __hf, __eql, __a) { } + + template + unordered_map(_InputIterator __first, _InputIterator __last, + size_type __n = 0, + const hasher& __hf = hasher(), + const key_equal& __eql = key_equal(), + const allocator_type& __a = allocator_type()) + : _Base(__gnu_debug::__base(__gnu_debug::__check_valid_range(__first, + __last)), + __gnu_debug::__base(__last), __n, + __hf, __eql, __a) { } + + unordered_map(const unordered_map&) = default; + + unordered_map(const _Base& __x) + : _Base(__x) { } + + unordered_map(unordered_map&&) = default; + + explicit + unordered_map(const allocator_type& __a) + : _Base(__a) + { } + + unordered_map(const unordered_map& __umap, + const allocator_type& __a) + : _Base(__umap._M_base(), __a) + { } + + unordered_map(unordered_map&& __umap, + const allocator_type& __a) + : _Base(std::move(__umap._M_base()), __a) + { } + + unordered_map(initializer_list __l, + size_type __n = 0, + const hasher& __hf = hasher(), + const key_equal& __eql = key_equal(), + const allocator_type& __a = allocator_type()) + : _Base(__l, __n, __hf, __eql, __a) { } + + ~unordered_map() noexcept { } + + unordered_map& + operator=(const unordered_map& __x) + { + _M_base() = __x._M_base(); + this->_M_invalidate_all(); + return *this; + } + + unordered_map& + operator=(unordered_map&& __x) + noexcept(_Alloc_traits::_S_nothrow_move()) + { + __glibcxx_check_self_move_assign(__x); + bool __xfer_memory = _Alloc_traits::_S_propagate_on_move_assign() + || __x.get_allocator() == this->get_allocator(); + _M_base() = std::move(__x._M_base()); + if (__xfer_memory) + this->_M_swap(__x); + else + this->_M_invalidate_all(); + __x._M_invalidate_all(); + return *this; + } + + unordered_map& + operator=(initializer_list __l) + { + _M_base() = __l; + this->_M_invalidate_all(); + return *this; + } + + void + swap(unordered_map& __x) + noexcept(_Alloc_traits::_S_nothrow_swap()) + { + if (!_Alloc_traits::_S_propagate_on_swap()) + __glibcxx_check_equal_allocs(__x); + _Base::swap(__x); + _Safe_base::_M_swap(__x); + } + + void + clear() noexcept + { + _Base::clear(); + this->_M_invalidate_all(); + } + + iterator + begin() noexcept + { return iterator(_Base::begin(), this); } + + const_iterator + begin() const noexcept + { return const_iterator(_Base::begin(), this); } + + iterator + end() noexcept + { return iterator(_Base::end(), this); } + + const_iterator + end() const noexcept + { return const_iterator(_Base::end(), this); } + + const_iterator + cbegin() const noexcept + { return const_iterator(_Base::begin(), this); } + + const_iterator + cend() const noexcept + { return const_iterator(_Base::end(), this); } + + // local versions + local_iterator + begin(size_type __b) + { + __glibcxx_check_bucket_index(__b); + return local_iterator(_Base::begin(__b), this); + } + + local_iterator + end(size_type __b) + { + __glibcxx_check_bucket_index(__b); + return local_iterator(_Base::end(__b), this); + } + + const_local_iterator + begin(size_type __b) const + { + __glibcxx_check_bucket_index(__b); + return const_local_iterator(_Base::begin(__b), this); + } + + const_local_iterator + end(size_type __b) const + { + __glibcxx_check_bucket_index(__b); + return const_local_iterator(_Base::end(__b), this); + } + + const_local_iterator + cbegin(size_type __b) const + { + __glibcxx_check_bucket_index(__b); + return const_local_iterator(_Base::cbegin(__b), this); + } + + const_local_iterator + cend(size_type __b) const + { + __glibcxx_check_bucket_index(__b); + return const_local_iterator(_Base::cend(__b), this); + } + + size_type + bucket_size(size_type __b) const + { + __glibcxx_check_bucket_index(__b); + return _Base::bucket_size(__b); + } + + float + max_load_factor() const noexcept + { return _Base::max_load_factor(); } + + void + max_load_factor(float __f) + { + __glibcxx_check_max_load_factor(__f); + _Base::max_load_factor(__f); + } + + template + std::pair + emplace(_Args&&... __args) + { + size_type __bucket_count = this->bucket_count(); + std::pair<_Base_iterator, bool> __res + = _Base::emplace(std::forward<_Args>(__args)...); + _M_check_rehashed(__bucket_count); + return std::make_pair(iterator(__res.first, this), __res.second); + } + + template + iterator + emplace_hint(const_iterator __hint, _Args&&... __args) + { + __glibcxx_check_insert(__hint); + size_type __bucket_count = this->bucket_count(); + _Base_iterator __it = _Base::emplace_hint(__hint.base(), + std::forward<_Args>(__args)...); + _M_check_rehashed(__bucket_count); + return iterator(__it, this); + } + + std::pair + insert(const value_type& __obj) + { + size_type __bucket_count = this->bucket_count(); + std::pair<_Base_iterator, bool> __res = _Base::insert(__obj); + _M_check_rehashed(__bucket_count); + return std::make_pair(iterator(__res.first, this), __res.second); + } + + iterator + insert(const_iterator __hint, const value_type& __obj) + { + __glibcxx_check_insert(__hint); + size_type __bucket_count = this->bucket_count(); + _Base_iterator __it = _Base::insert(__hint.base(), __obj); + _M_check_rehashed(__bucket_count); + return iterator(__it, this); + } + + template::value>::type> + std::pair + insert(_Pair&& __obj) + { + size_type __bucket_count = this->bucket_count(); + std::pair<_Base_iterator, bool> __res = + _Base::insert(std::forward<_Pair>(__obj)); + _M_check_rehashed(__bucket_count); + return std::make_pair(iterator(__res.first, this), __res.second); + } + + template::value>::type> + iterator + insert(const_iterator __hint, _Pair&& __obj) + { + __glibcxx_check_insert(__hint); + size_type __bucket_count = this->bucket_count(); + _Base_iterator __it = + _Base::insert(__hint.base(), std::forward<_Pair>(__obj)); + _M_check_rehashed(__bucket_count); + return iterator(__it, this); + } + + void + insert(std::initializer_list __l) + { + size_type __bucket_count = this->bucket_count(); + _Base::insert(__l); + _M_check_rehashed(__bucket_count); + } + + template + void + insert(_InputIterator __first, _InputIterator __last) + { + __glibcxx_check_valid_range(__first, __last); + size_type __bucket_count = this->bucket_count(); + _Base::insert(__gnu_debug::__base(__first), + __gnu_debug::__base(__last)); + _M_check_rehashed(__bucket_count); + } + + iterator + find(const key_type& __key) + { return iterator(_Base::find(__key), this); } + + const_iterator + find(const key_type& __key) const + { return const_iterator(_Base::find(__key), this); } + + std::pair + equal_range(const key_type& __key) + { + std::pair<_Base_iterator, _Base_iterator> __res = + _Base::equal_range(__key); + return std::make_pair(iterator(__res.first, this), + iterator(__res.second, this)); + } + + std::pair + equal_range(const key_type& __key) const + { + std::pair<_Base_const_iterator, _Base_const_iterator> __res = + _Base::equal_range(__key); + return std::make_pair(const_iterator(__res.first, this), + const_iterator(__res.second, this)); + } + + size_type + erase(const key_type& __key) + { + size_type __ret(0); + _Base_iterator __victim(_Base::find(__key)); + if (__victim != _Base::end()) + { + this->_M_invalidate_if([__victim](_Base_const_iterator __it) + { return __it == __victim; }); + this->_M_invalidate_local_if( + [__victim](_Base_const_local_iterator __it) + { return __it._M_curr() == __victim._M_cur; }); + size_type __bucket_count = this->bucket_count(); + _Base::erase(__victim); + _M_check_rehashed(__bucket_count); + __ret = 1; + } + return __ret; + } + + iterator + erase(const_iterator __it) + { + __glibcxx_check_erase(__it); + _Base_const_iterator __victim = __it.base(); + this->_M_invalidate_if([__victim](_Base_const_iterator __it) + { return __it == __victim; }); + this->_M_invalidate_local_if( + [__victim](_Base_const_local_iterator __it) + { return __it._M_curr() == __victim._M_cur; }); + size_type __bucket_count = this->bucket_count(); + _Base_iterator __next = _Base::erase(__it.base()); + _M_check_rehashed(__bucket_count); + return iterator(__next, this); + } + + iterator + erase(iterator __it) + { return erase(const_iterator(__it)); } + + iterator + erase(const_iterator __first, const_iterator __last) + { + __glibcxx_check_erase_range(__first, __last); + for (_Base_const_iterator __tmp = __first.base(); + __tmp != __last.base(); ++__tmp) + { + _GLIBCXX_DEBUG_VERIFY(__tmp != _Base::end(), + _M_message(__gnu_debug::__msg_valid_range) + ._M_iterator(__first, "first") + ._M_iterator(__last, "last")); + this->_M_invalidate_if([__tmp](_Base_const_iterator __it) + { return __it == __tmp; }); + this->_M_invalidate_local_if( + [__tmp](_Base_const_local_iterator __it) + { return __it._M_curr() == __tmp._M_cur; }); + } + size_type __bucket_count = this->bucket_count(); + _Base_iterator __next = _Base::erase(__first.base(), __last.base()); + _M_check_rehashed(__bucket_count); + return iterator(__next, this); + } + + _Base& + _M_base() noexcept { return *this; } + + const _Base& + _M_base() const noexcept { return *this; } + + private: + void + _M_invalidate_locals() + { + _Base_local_iterator __local_end = _Base::end(0); + this->_M_invalidate_local_if( + [__local_end](_Base_const_local_iterator __it) + { return __it != __local_end; }); + } + + void + _M_invalidate_all() + { + _Base_iterator __end = _Base::end(); + this->_M_invalidate_if([__end](_Base_const_iterator __it) + { return __it != __end; }); + _M_invalidate_locals(); + } + + void + _M_check_rehashed(size_type __prev_count) + { + if (__prev_count != this->bucket_count()) + _M_invalidate_locals(); + } + }; + + template + inline void + swap(unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x, + unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y) + { __x.swap(__y); } + + template + inline bool + operator==(const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x, + const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y) + { return __x._M_base() == __y._M_base(); } + + template + inline bool + operator!=(const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x, + const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y) + { return !(__x == __y); } + + + /// Class std::unordered_multimap with safety/checking/debug instrumentation. + template, + typename _Pred = std::equal_to<_Key>, + typename _Alloc = std::allocator > > + class unordered_multimap + : public _GLIBCXX_STD_C::unordered_multimap<_Key, _Tp, _Hash, + _Pred, _Alloc>, + public __gnu_debug::_Safe_unordered_container > + { + typedef _GLIBCXX_STD_C::unordered_multimap<_Key, _Tp, _Hash, + _Pred, _Alloc> _Base; + typedef __gnu_debug::_Safe_unordered_container + _Safe_base; + typedef typename _Base::const_iterator _Base_const_iterator; + typedef typename _Base::iterator _Base_iterator; + typedef typename _Base::const_local_iterator _Base_const_local_iterator; + typedef typename _Base::local_iterator _Base_local_iterator; + + typedef __gnu_cxx::__alloc_traits _Alloc_traits; + + public: + typedef typename _Base::size_type size_type; + typedef typename _Base::hasher hasher; + typedef typename _Base::key_equal key_equal; + typedef typename _Base::allocator_type allocator_type; + + typedef typename _Base::key_type key_type; + typedef typename _Base::value_type value_type; + + typedef __gnu_debug::_Safe_iterator<_Base_iterator, + unordered_multimap> iterator; + typedef __gnu_debug::_Safe_iterator<_Base_const_iterator, + unordered_multimap> const_iterator; + typedef __gnu_debug::_Safe_local_iterator< + _Base_local_iterator, unordered_multimap> local_iterator; + typedef __gnu_debug::_Safe_local_iterator< + _Base_const_local_iterator, unordered_multimap> const_local_iterator; + + explicit + unordered_multimap(size_type __n = 10, + const hasher& __hf = hasher(), + const key_equal& __eql = key_equal(), + const allocator_type& __a = allocator_type()) + : _Base(__n, __hf, __eql, __a) { } + + template + unordered_multimap(_InputIterator __first, _InputIterator __last, + size_type __n = 0, + const hasher& __hf = hasher(), + const key_equal& __eql = key_equal(), + const allocator_type& __a = allocator_type()) + : _Base(__gnu_debug::__base(__gnu_debug::__check_valid_range(__first, + __last)), + __gnu_debug::__base(__last), __n, + __hf, __eql, __a) { } + + unordered_multimap(const unordered_multimap&) = default; + + unordered_multimap(const _Base& __x) + : _Base(__x) { } + + unordered_multimap(unordered_multimap&&) = default; + + explicit + unordered_multimap(const allocator_type& __a) + : _Base(__a) + { } + + unordered_multimap(const unordered_multimap& __umap, + const allocator_type& __a) + : _Base(__umap._M_base(), __a) + { } + + unordered_multimap(unordered_multimap&& __umap, + const allocator_type& __a) + : _Base(std::move(__umap._M_base()), __a) + { } + + unordered_multimap(initializer_list __l, + size_type __n = 0, + const hasher& __hf = hasher(), + const key_equal& __eql = key_equal(), + const allocator_type& __a = allocator_type()) + : _Base(__l, __n, __hf, __eql, __a) { } + + ~unordered_multimap() noexcept { } + + unordered_multimap& + operator=(const unordered_multimap& __x) + { + _M_base() = __x._M_base(); + this->_M_invalidate_all(); + return *this; + } + + unordered_multimap& + operator=(unordered_multimap&& __x) + noexcept(_Alloc_traits::_S_nothrow_move()) + { + __glibcxx_check_self_move_assign(__x); + bool __xfer_memory = _Alloc_traits::_S_propagate_on_move_assign() + || __x.get_allocator() == this->get_allocator(); + _M_base() = std::move(__x._M_base()); + if (__xfer_memory) + this->_M_swap(__x); + else + this->_M_invalidate_all(); + __x._M_invalidate_all(); + return *this; + } + + unordered_multimap& + operator=(initializer_list __l) + { + _M_base() = __l; + this->_M_invalidate_all(); + return *this; + } + + void + swap(unordered_multimap& __x) + noexcept(_Alloc_traits::_S_nothrow_swap()) + { + if (!_Alloc_traits::_S_propagate_on_swap()) + __glibcxx_check_equal_allocs(__x); + _Base::swap(__x); + _Safe_base::_M_swap(__x); + } + + void + clear() noexcept + { + _Base::clear(); + this->_M_invalidate_all(); + } + + iterator + begin() noexcept + { return iterator(_Base::begin(), this); } + + const_iterator + begin() const noexcept + { return const_iterator(_Base::begin(), this); } + + iterator + end() noexcept + { return iterator(_Base::end(), this); } + + const_iterator + end() const noexcept + { return const_iterator(_Base::end(), this); } + + const_iterator + cbegin() const noexcept + { return const_iterator(_Base::begin(), this); } + + const_iterator + cend() const noexcept + { return const_iterator(_Base::end(), this); } + + // local versions + local_iterator + begin(size_type __b) + { + __glibcxx_check_bucket_index(__b); + return local_iterator(_Base::begin(__b), this); + } + + local_iterator + end(size_type __b) + { + __glibcxx_check_bucket_index(__b); + return local_iterator(_Base::end(__b), this); + } + + const_local_iterator + begin(size_type __b) const + { + __glibcxx_check_bucket_index(__b); + return const_local_iterator(_Base::begin(__b), this); + } + + const_local_iterator + end(size_type __b) const + { + __glibcxx_check_bucket_index(__b); + return const_local_iterator(_Base::end(__b), this); + } + + const_local_iterator + cbegin(size_type __b) const + { + __glibcxx_check_bucket_index(__b); + return const_local_iterator(_Base::cbegin(__b), this); + } + + const_local_iterator + cend(size_type __b) const + { + __glibcxx_check_bucket_index(__b); + return const_local_iterator(_Base::cend(__b), this); + } + + size_type + bucket_size(size_type __b) const + { + __glibcxx_check_bucket_index(__b); + return _Base::bucket_size(__b); + } + + float + max_load_factor() const noexcept + { return _Base::max_load_factor(); } + + void + max_load_factor(float __f) + { + __glibcxx_check_max_load_factor(__f); + _Base::max_load_factor(__f); + } + + template + iterator + emplace(_Args&&... __args) + { + size_type __bucket_count = this->bucket_count(); + _Base_iterator __it + = _Base::emplace(std::forward<_Args>(__args)...); + _M_check_rehashed(__bucket_count); + return iterator(__it, this); + } + + template + iterator + emplace_hint(const_iterator __hint, _Args&&... __args) + { + __glibcxx_check_insert(__hint); + size_type __bucket_count = this->bucket_count(); + _Base_iterator __it = _Base::emplace_hint(__hint.base(), + std::forward<_Args>(__args)...); + _M_check_rehashed(__bucket_count); + return iterator(__it, this); + } + + iterator + insert(const value_type& __obj) + { + size_type __bucket_count = this->bucket_count(); + _Base_iterator __it = _Base::insert(__obj); + _M_check_rehashed(__bucket_count); + return iterator(__it, this); + } + + iterator + insert(const_iterator __hint, const value_type& __obj) + { + __glibcxx_check_insert(__hint); + size_type __bucket_count = this->bucket_count(); + _Base_iterator __it = _Base::insert(__hint.base(), __obj); + _M_check_rehashed(__bucket_count); + return iterator(__it, this); + } + + template::value>::type> + iterator + insert(_Pair&& __obj) + { + size_type __bucket_count = this->bucket_count(); + _Base_iterator __it = _Base::insert(std::forward<_Pair>(__obj)); + _M_check_rehashed(__bucket_count); + return iterator(__it, this); + } + + template::value>::type> + iterator + insert(const_iterator __hint, _Pair&& __obj) + { + __glibcxx_check_insert(__hint); + size_type __bucket_count = this->bucket_count(); + _Base_iterator __it = + _Base::insert(__hint.base(), std::forward<_Pair>(__obj)); + _M_check_rehashed(__bucket_count); + return iterator(__it, this); + } + + void + insert(std::initializer_list __l) + { _Base::insert(__l); } + + template + void + insert(_InputIterator __first, _InputIterator __last) + { + __glibcxx_check_valid_range(__first, __last); + size_type __bucket_count = this->bucket_count(); + _Base::insert(__gnu_debug::__base(__first), + __gnu_debug::__base(__last)); + _M_check_rehashed(__bucket_count); + } + + iterator + find(const key_type& __key) + { return iterator(_Base::find(__key), this); } + + const_iterator + find(const key_type& __key) const + { return const_iterator(_Base::find(__key), this); } + + std::pair + equal_range(const key_type& __key) + { + std::pair<_Base_iterator, _Base_iterator> __res = + _Base::equal_range(__key); + return std::make_pair(iterator(__res.first, this), + iterator(__res.second, this)); + } + + std::pair + equal_range(const key_type& __key) const + { + std::pair<_Base_const_iterator, _Base_const_iterator> __res = + _Base::equal_range(__key); + return std::make_pair(const_iterator(__res.first, this), + const_iterator(__res.second, this)); + } + + size_type + erase(const key_type& __key) + { + size_type __ret(0); + size_type __bucket_count = this->bucket_count(); + std::pair<_Base_iterator, _Base_iterator> __pair = + _Base::equal_range(__key); + for (_Base_iterator __victim = __pair.first; __victim != __pair.second;) + { + this->_M_invalidate_if([__victim](_Base_const_iterator __it) + { return __it == __victim; }); + this->_M_invalidate_local_if( + [__victim](_Base_const_local_iterator __it) + { return __it._M_curr() == __victim._M_cur; }); + _Base::erase(__victim++); + ++__ret; + } + _M_check_rehashed(__bucket_count); + return __ret; + } + + iterator + erase(const_iterator __it) + { + __glibcxx_check_erase(__it); + _Base_const_iterator __victim = __it.base(); + this->_M_invalidate_if([__victim](_Base_const_iterator __it) + { return __it == __victim; }); + this->_M_invalidate_local_if( + [__victim](_Base_const_local_iterator __it) + { return __it._M_curr() == __victim._M_cur; }); + size_type __bucket_count = this->bucket_count(); + _Base_iterator __next = _Base::erase(__it.base()); + _M_check_rehashed(__bucket_count); + return iterator(__next, this); + } + + iterator + erase(iterator __it) + { return erase(const_iterator(__it)); } + + iterator + erase(const_iterator __first, const_iterator __last) + { + __glibcxx_check_erase_range(__first, __last); + for (_Base_const_iterator __tmp = __first.base(); + __tmp != __last.base(); ++__tmp) + { + _GLIBCXX_DEBUG_VERIFY(__tmp != _Base::end(), + _M_message(__gnu_debug::__msg_valid_range) + ._M_iterator(__first, "first") + ._M_iterator(__last, "last")); + this->_M_invalidate_if([__tmp](_Base_const_iterator __it) + { return __it == __tmp; }); + this->_M_invalidate_local_if( + [__tmp](_Base_const_local_iterator __it) + { return __it._M_curr() == __tmp._M_cur; }); + } + size_type __bucket_count = this->bucket_count(); + _Base_iterator __next = _Base::erase(__first.base(), __last.base()); + _M_check_rehashed(__bucket_count); + return iterator(__next, this); + } + + _Base& + _M_base() noexcept { return *this; } + + const _Base& + _M_base() const noexcept { return *this; } + + private: + void + _M_invalidate_locals() + { + _Base_local_iterator __local_end = _Base::end(0); + this->_M_invalidate_local_if( + [__local_end](_Base_const_local_iterator __it) + { return __it != __local_end; }); + } + + void + _M_invalidate_all() + { + _Base_iterator __end = _Base::end(); + this->_M_invalidate_if([__end](_Base_const_iterator __it) + { return __it != __end; }); + _M_invalidate_locals(); + } + + void + _M_check_rehashed(size_type __prev_count) + { + if (__prev_count != this->bucket_count()) + _M_invalidate_locals(); + } + }; + + template + inline void + swap(unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x, + unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y) + { __x.swap(__y); } + + template + inline bool + operator==(const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x, + const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y) + { return __x._M_base() == __y._M_base(); } + + template + inline bool + operator!=(const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x, + const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y) + { return !(__x == __y); } + +} // namespace __debug +} // namespace std + +#endif // C++11 + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/unordered_set b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/unordered_set new file mode 100755 index 0000000..a17efd0 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/unordered_set @@ -0,0 +1,936 @@ +// Debugging unordered_set/unordered_multiset implementation -*- C++ -*- + +// Copyright (C) 2003-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file debug/unordered_set + * This file is a GNU debug extension to the Standard C++ Library. + */ + +#ifndef _GLIBCXX_DEBUG_UNORDERED_SET +#define _GLIBCXX_DEBUG_UNORDERED_SET 1 + +#if __cplusplus < 201103L +# include +#else +# include + +#include +#include +#include + +namespace std _GLIBCXX_VISIBILITY(default) +{ +namespace __debug +{ + /// Class std::unordered_set with safety/checking/debug instrumentation. + template, + typename _Pred = std::equal_to<_Value>, + typename _Alloc = std::allocator<_Value> > + class unordered_set + : public _GLIBCXX_STD_C::unordered_set<_Value, _Hash, _Pred, _Alloc>, + public __gnu_debug::_Safe_unordered_container > + { + typedef _GLIBCXX_STD_C::unordered_set<_Value, _Hash, + _Pred, _Alloc> _Base; + typedef __gnu_debug::_Safe_unordered_container _Safe_base; + typedef typename _Base::const_iterator _Base_const_iterator; + typedef typename _Base::iterator _Base_iterator; + typedef typename _Base::const_local_iterator _Base_const_local_iterator; + typedef typename _Base::local_iterator _Base_local_iterator; + + typedef __gnu_cxx::__alloc_traits _Alloc_traits; + public: + typedef typename _Base::size_type size_type; + typedef typename _Base::hasher hasher; + typedef typename _Base::key_equal key_equal; + typedef typename _Base::allocator_type allocator_type; + + typedef typename _Base::key_type key_type; + typedef typename _Base::value_type value_type; + + typedef __gnu_debug::_Safe_iterator<_Base_iterator, + unordered_set> iterator; + typedef __gnu_debug::_Safe_iterator<_Base_const_iterator, + unordered_set> const_iterator; + typedef __gnu_debug::_Safe_local_iterator<_Base_local_iterator, + unordered_set> local_iterator; + typedef __gnu_debug::_Safe_local_iterator<_Base_const_local_iterator, + unordered_set> const_local_iterator; + + explicit + unordered_set(size_type __n = 10, + const hasher& __hf = hasher(), + const key_equal& __eql = key_equal(), + const allocator_type& __a = allocator_type()) + : _Base(__n, __hf, __eql, __a) { } + + template + unordered_set(_InputIterator __first, _InputIterator __last, + size_type __n = 0, + const hasher& __hf = hasher(), + const key_equal& __eql = key_equal(), + const allocator_type& __a = allocator_type()) + : _Base(__gnu_debug::__base(__gnu_debug::__check_valid_range(__first, + __last)), + __gnu_debug::__base(__last), __n, + __hf, __eql, __a) { } + + unordered_set(const unordered_set&) = default; + + unordered_set(const _Base& __x) + : _Base(__x) { } + + unordered_set(unordered_set&&) = default; + + explicit + unordered_set(const allocator_type& __a) + : _Base(__a) + { } + + unordered_set(const unordered_set& __uset, + const allocator_type& __a) + : _Base(__uset._M_base(), __a) + { } + + unordered_set(unordered_set&& __uset, + const allocator_type& __a) + : _Base(std::move(__uset._M_base()), __a) + { } + + unordered_set(initializer_list __l, + size_type __n = 0, + const hasher& __hf = hasher(), + const key_equal& __eql = key_equal(), + const allocator_type& __a = allocator_type()) + : _Base(__l, __n, __hf, __eql, __a) { } + + ~unordered_set() noexcept { } + + unordered_set& + operator=(const unordered_set& __x) + { + _M_base() = __x._M_base(); + this->_M_invalidate_all(); + return *this; + } + + unordered_set& + operator=(unordered_set&& __x) + noexcept(_Alloc_traits::_S_nothrow_move()) + { + __glibcxx_check_self_move_assign(__x); + bool __xfer_memory = _Alloc_traits::_S_propagate_on_move_assign() + || __x.get_allocator() == this->get_allocator(); + _M_base() = std::move(__x._M_base()); + if (__xfer_memory) + this->_M_swap(__x); + else + this->_M_invalidate_all(); + __x._M_invalidate_all(); + return *this; + } + + unordered_set& + operator=(initializer_list __l) + { + _M_base() = __l; + this->_M_invalidate_all(); + return *this; + } + + void + swap(unordered_set& __x) + noexcept(_Alloc_traits::_S_nothrow_swap()) + { + if (!_Alloc_traits::_S_propagate_on_swap()) + __glibcxx_check_equal_allocs(__x); + _Base::swap(__x); + _Safe_base::_M_swap(__x); + } + + void + clear() noexcept + { + _Base::clear(); + this->_M_invalidate_all(); + } + + iterator + begin() noexcept + { return iterator(_Base::begin(), this); } + + const_iterator + begin() const noexcept + { return const_iterator(_Base::begin(), this); } + + iterator + end() noexcept + { return iterator(_Base::end(), this); } + + const_iterator + end() const noexcept + { return const_iterator(_Base::end(), this); } + + const_iterator + cbegin() const noexcept + { return const_iterator(_Base::begin(), this); } + + const_iterator + cend() const noexcept + { return const_iterator(_Base::end(), this); } + + // local versions + local_iterator + begin(size_type __b) + { + __glibcxx_check_bucket_index(__b); + return local_iterator(_Base::begin(__b), this); + } + + local_iterator + end(size_type __b) + { + __glibcxx_check_bucket_index(__b); + return local_iterator(_Base::end(__b), this); + } + + const_local_iterator + begin(size_type __b) const + { + __glibcxx_check_bucket_index(__b); + return const_local_iterator(_Base::begin(__b), this); + } + + const_local_iterator + end(size_type __b) const + { + __glibcxx_check_bucket_index(__b); + return const_local_iterator(_Base::end(__b), this); + } + + const_local_iterator + cbegin(size_type __b) const + { + __glibcxx_check_bucket_index(__b); + return const_local_iterator(_Base::cbegin(__b), this); + } + + const_local_iterator + cend(size_type __b) const + { + __glibcxx_check_bucket_index(__b); + return const_local_iterator(_Base::cend(__b), this); + } + + size_type + bucket_size(size_type __b) const + { + __glibcxx_check_bucket_index(__b); + return _Base::bucket_size(__b); + } + + float + max_load_factor() const noexcept + { return _Base::max_load_factor(); } + + void + max_load_factor(float __f) + { + __glibcxx_check_max_load_factor(__f); + _Base::max_load_factor(__f); + } + + template + std::pair + emplace(_Args&&... __args) + { + size_type __bucket_count = this->bucket_count(); + std::pair<_Base_iterator, bool> __res + = _Base::emplace(std::forward<_Args>(__args)...); + _M_check_rehashed(__bucket_count); + return std::make_pair(iterator(__res.first, this), __res.second); + } + + template + iterator + emplace_hint(const_iterator __hint, _Args&&... __args) + { + __glibcxx_check_insert(__hint); + size_type __bucket_count = this->bucket_count(); + _Base_iterator __it = _Base::emplace_hint(__hint.base(), + std::forward<_Args>(__args)...); + _M_check_rehashed(__bucket_count); + return iterator(__it, this); + } + + std::pair + insert(const value_type& __obj) + { + size_type __bucket_count = this->bucket_count(); + typedef std::pair<_Base_iterator, bool> __pair_type; + __pair_type __res = _Base::insert(__obj); + _M_check_rehashed(__bucket_count); + return std::make_pair(iterator(__res.first, this), __res.second); + } + + iterator + insert(const_iterator __hint, const value_type& __obj) + { + __glibcxx_check_insert(__hint); + size_type __bucket_count = this->bucket_count(); + _Base_iterator __it = _Base::insert(__hint.base(), __obj); + _M_check_rehashed(__bucket_count); + return iterator(__it, this); + } + + std::pair + insert(value_type&& __obj) + { + size_type __bucket_count = this->bucket_count(); + typedef std::pair __pair_type; + __pair_type __res = _Base::insert(std::move(__obj)); + _M_check_rehashed(__bucket_count); + return std::make_pair(iterator(__res.first, this), __res.second); + } + + iterator + insert(const_iterator __hint, value_type&& __obj) + { + __glibcxx_check_insert(__hint); + size_type __bucket_count = this->bucket_count(); + _Base_iterator __it = _Base::insert(__hint.base(), std::move(__obj)); + _M_check_rehashed(__bucket_count); + return iterator(__it, this); + } + + void + insert(std::initializer_list __l) + { + size_type __bucket_count = this->bucket_count(); + _Base::insert(__l); + _M_check_rehashed(__bucket_count); + } + + template + void + insert(_InputIterator __first, _InputIterator __last) + { + __glibcxx_check_valid_range(__first, __last); + size_type __bucket_count = this->bucket_count(); + _Base::insert(__gnu_debug::__base(__first), + __gnu_debug::__base(__last)); + _M_check_rehashed(__bucket_count); + } + + iterator + find(const key_type& __key) + { return iterator(_Base::find(__key), this); } + + const_iterator + find(const key_type& __key) const + { return const_iterator(_Base::find(__key), this); } + + std::pair + equal_range(const key_type& __key) + { + typedef std::pair<_Base_iterator, _Base_iterator> __pair_type; + __pair_type __res = _Base::equal_range(__key); + return std::make_pair(iterator(__res.first, this), + iterator(__res.second, this)); + } + + std::pair + equal_range(const key_type& __key) const + { + std::pair<_Base_const_iterator, _Base_const_iterator> + __res = _Base::equal_range(__key); + return std::make_pair(const_iterator(__res.first, this), + const_iterator(__res.second, this)); + } + + size_type + erase(const key_type& __key) + { + size_type __ret(0); + _Base_iterator __victim(_Base::find(__key)); + if (__victim != _Base::end()) + { + this->_M_invalidate_if( + [__victim](_Base_const_iterator __it) + { return __it == __victim; }); + this->_M_invalidate_local_if( + [__victim](_Base_const_local_iterator __it) + { return __it._M_curr() == __victim._M_cur; }); + size_type __bucket_count = this->bucket_count(); + _Base::erase(__victim); + _M_check_rehashed(__bucket_count); + __ret = 1; + } + return __ret; + } + + iterator + erase(const_iterator __it) + { + __glibcxx_check_erase(__it); + _Base_const_iterator __victim = __it.base(); + this->_M_invalidate_if( + [__victim](_Base_const_iterator __it) + { return __it == __victim; }); + this->_M_invalidate_local_if( + [__victim](_Base_const_local_iterator __it) + { return __it._M_curr() == __victim._M_cur; }); + size_type __bucket_count = this->bucket_count(); + _Base_iterator __next = _Base::erase(__it.base()); + _M_check_rehashed(__bucket_count); + return iterator(__next, this); + } + + iterator + erase(iterator __it) + { return erase(const_iterator(__it)); } + + iterator + erase(const_iterator __first, const_iterator __last) + { + __glibcxx_check_erase_range(__first, __last); + for (_Base_const_iterator __tmp = __first.base(); + __tmp != __last.base(); ++__tmp) + { + _GLIBCXX_DEBUG_VERIFY(__tmp != _Base::end(), + _M_message(__gnu_debug::__msg_valid_range) + ._M_iterator(__first, "first") + ._M_iterator(__last, "last")); + this->_M_invalidate_if( + [__tmp](_Base_const_iterator __it) + { return __it == __tmp; }); + this->_M_invalidate_local_if( + [__tmp](_Base_const_local_iterator __it) + { return __it._M_curr() == __tmp._M_cur; }); + } + size_type __bucket_count = this->bucket_count(); + _Base_iterator __next = _Base::erase(__first.base(), + __last.base()); + _M_check_rehashed(__bucket_count); + return iterator(__next, this); + } + + _Base& + _M_base() noexcept { return *this; } + + const _Base& + _M_base() const noexcept { return *this; } + + private: + void + _M_invalidate_locals() + { + _Base_local_iterator __local_end = _Base::end(0); + this->_M_invalidate_local_if( + [__local_end](_Base_const_local_iterator __it) + { return __it != __local_end; }); + } + + void + _M_invalidate_all() + { + _Base_iterator __end = _Base::end(); + this->_M_invalidate_if( + [__end](_Base_const_iterator __it) + { return __it != __end; }); + _M_invalidate_locals(); + } + + void + _M_check_rehashed(size_type __prev_count) + { + if (__prev_count != this->bucket_count()) + _M_invalidate_locals(); + } + }; + + template + inline void + swap(unordered_set<_Value, _Hash, _Pred, _Alloc>& __x, + unordered_set<_Value, _Hash, _Pred, _Alloc>& __y) + { __x.swap(__y); } + + template + inline bool + operator==(const unordered_set<_Value, _Hash, _Pred, _Alloc>& __x, + const unordered_set<_Value, _Hash, _Pred, _Alloc>& __y) + { return __x._M_base() == __y._M_base(); } + + template + inline bool + operator!=(const unordered_set<_Value, _Hash, _Pred, _Alloc>& __x, + const unordered_set<_Value, _Hash, _Pred, _Alloc>& __y) + { return !(__x == __y); } + + + /// Class std::unordered_multiset with safety/checking/debug instrumentation. + template, + typename _Pred = std::equal_to<_Value>, + typename _Alloc = std::allocator<_Value> > + class unordered_multiset + : public _GLIBCXX_STD_C::unordered_multiset<_Value, _Hash, _Pred, _Alloc>, + public __gnu_debug::_Safe_unordered_container< + unordered_multiset<_Value, _Hash, _Pred, _Alloc> > + { + typedef _GLIBCXX_STD_C::unordered_multiset<_Value, _Hash, + _Pred, _Alloc> _Base; + typedef __gnu_debug::_Safe_unordered_container + _Safe_base; + typedef typename _Base::const_iterator _Base_const_iterator; + typedef typename _Base::iterator _Base_iterator; + typedef typename _Base::const_local_iterator _Base_const_local_iterator; + typedef typename _Base::local_iterator _Base_local_iterator; + + typedef __gnu_cxx::__alloc_traits _Alloc_traits; + + public: + typedef typename _Base::size_type size_type; + typedef typename _Base::hasher hasher; + typedef typename _Base::key_equal key_equal; + typedef typename _Base::allocator_type allocator_type; + + typedef typename _Base::key_type key_type; + typedef typename _Base::value_type value_type; + + typedef __gnu_debug::_Safe_iterator<_Base_iterator, + unordered_multiset> iterator; + typedef __gnu_debug::_Safe_iterator<_Base_const_iterator, + unordered_multiset> const_iterator; + typedef __gnu_debug::_Safe_local_iterator< + _Base_local_iterator, unordered_multiset> local_iterator; + typedef __gnu_debug::_Safe_local_iterator< + _Base_const_local_iterator, unordered_multiset> const_local_iterator; + + explicit + unordered_multiset(size_type __n = 10, + const hasher& __hf = hasher(), + const key_equal& __eql = key_equal(), + const allocator_type& __a = allocator_type()) + : _Base(__n, __hf, __eql, __a) { } + + template + unordered_multiset(_InputIterator __first, _InputIterator __last, + size_type __n = 0, + const hasher& __hf = hasher(), + const key_equal& __eql = key_equal(), + const allocator_type& __a = allocator_type()) + : _Base(__gnu_debug::__base(__gnu_debug::__check_valid_range(__first, + __last)), + __gnu_debug::__base(__last), __n, + __hf, __eql, __a) { } + + unordered_multiset(const unordered_multiset&) = default; + + unordered_multiset(const _Base& __x) + : _Base(__x) { } + + unordered_multiset(unordered_multiset&&) = default; + + explicit + unordered_multiset(const allocator_type& __a) + : _Base(__a) + { } + + unordered_multiset(const unordered_multiset& __uset, + const allocator_type& __a) + : _Base(__uset._M_base(), __a) + { } + + unordered_multiset(unordered_multiset&& __uset, + const allocator_type& __a) + : _Base(std::move(__uset._M_base()), __a) + { } + + unordered_multiset(initializer_list __l, + size_type __n = 0, + const hasher& __hf = hasher(), + const key_equal& __eql = key_equal(), + const allocator_type& __a = allocator_type()) + : _Base(__l, __n, __hf, __eql, __a) { } + + ~unordered_multiset() noexcept { } + + unordered_multiset& + operator=(const unordered_multiset& __x) + { + _M_base() = __x._M_base(); + this->_M_invalidate_all(); + return *this; + } + + unordered_multiset& + operator=(unordered_multiset&& __x) + noexcept(_Alloc_traits::_S_nothrow_move()) + { + __glibcxx_check_self_move_assign(__x); + bool __xfer_memory = _Alloc_traits::_S_propagate_on_move_assign() + || __x.get_allocator() == this->get_allocator(); + _M_base() = std::move(__x._M_base()); + if (__xfer_memory) + this->_M_swap(__x); + else + this->_M_invalidate_all(); + __x._M_invalidate_all(); + return *this; + } + + unordered_multiset& + operator=(initializer_list __l) + { + _M_base() = __l; + this->_M_invalidate_all(); + return *this; + } + + void + swap(unordered_multiset& __x) + noexcept(_Alloc_traits::_S_nothrow_swap()) + { + if (!_Alloc_traits::_S_propagate_on_swap()) + __glibcxx_check_equal_allocs(__x); + _Base::swap(__x); + _Safe_base::_M_swap(__x); + } + + void + clear() noexcept + { + _Base::clear(); + this->_M_invalidate_all(); + } + + iterator + begin() noexcept + { return iterator(_Base::begin(), this); } + + const_iterator + begin() const noexcept + { return const_iterator(_Base::begin(), this); } + + iterator + end() noexcept + { return iterator(_Base::end(), this); } + + const_iterator + end() const noexcept + { return const_iterator(_Base::end(), this); } + + const_iterator + cbegin() const noexcept + { return const_iterator(_Base::begin(), this); } + + const_iterator + cend() const noexcept + { return const_iterator(_Base::end(), this); } + + // local versions + local_iterator + begin(size_type __b) + { + __glibcxx_check_bucket_index(__b); + return local_iterator(_Base::begin(__b), this); + } + + local_iterator + end(size_type __b) + { + __glibcxx_check_bucket_index(__b); + return local_iterator(_Base::end(__b), this); + } + + const_local_iterator + begin(size_type __b) const + { + __glibcxx_check_bucket_index(__b); + return const_local_iterator(_Base::begin(__b), this); + } + + const_local_iterator + end(size_type __b) const + { + __glibcxx_check_bucket_index(__b); + return const_local_iterator(_Base::end(__b), this); + } + + const_local_iterator + cbegin(size_type __b) const + { + __glibcxx_check_bucket_index(__b); + return const_local_iterator(_Base::cbegin(__b), this); + } + + const_local_iterator + cend(size_type __b) const + { + __glibcxx_check_bucket_index(__b); + return const_local_iterator(_Base::cend(__b), this); + } + + size_type + bucket_size(size_type __b) const + { + __glibcxx_check_bucket_index(__b); + return _Base::bucket_size(__b); + } + + float + max_load_factor() const noexcept + { return _Base::max_load_factor(); } + + void + max_load_factor(float __f) + { + __glibcxx_check_max_load_factor(__f); + _Base::max_load_factor(__f); + } + + template + iterator + emplace(_Args&&... __args) + { + size_type __bucket_count = this->bucket_count(); + _Base_iterator __it + = _Base::emplace(std::forward<_Args>(__args)...); + _M_check_rehashed(__bucket_count); + return iterator(__it, this); + } + + template + iterator + emplace_hint(const_iterator __hint, _Args&&... __args) + { + __glibcxx_check_insert(__hint); + size_type __bucket_count = this->bucket_count(); + _Base_iterator __it = _Base::emplace_hint(__hint.base(), + std::forward<_Args>(__args)...); + _M_check_rehashed(__bucket_count); + return iterator(__it, this); + } + + iterator + insert(const value_type& __obj) + { + size_type __bucket_count = this->bucket_count(); + _Base_iterator __it = _Base::insert(__obj); + _M_check_rehashed(__bucket_count); + return iterator(__it, this); + } + + iterator + insert(const_iterator __hint, const value_type& __obj) + { + __glibcxx_check_insert(__hint); + size_type __bucket_count = this->bucket_count(); + _Base_iterator __it = _Base::insert(__hint.base(), __obj); + _M_check_rehashed(__bucket_count); + return iterator(__it, this); + } + + iterator + insert(value_type&& __obj) + { + size_type __bucket_count = this->bucket_count(); + _Base_iterator __it = _Base::insert(std::move(__obj)); + _M_check_rehashed(__bucket_count); + return iterator(__it, this); + } + + iterator + insert(const_iterator __hint, value_type&& __obj) + { + __glibcxx_check_insert(__hint); + size_type __bucket_count = this->bucket_count(); + _Base_iterator __it = _Base::insert(__hint.base(), std::move(__obj)); + _M_check_rehashed(__bucket_count); + return iterator(__it, this); + } + + void + insert(std::initializer_list __l) + { + size_type __bucket_count = this->bucket_count(); + _Base::insert(__l); + _M_check_rehashed(__bucket_count); + } + + template + void + insert(_InputIterator __first, _InputIterator __last) + { + __glibcxx_check_valid_range(__first, __last); + size_type __bucket_count = this->bucket_count(); + _Base::insert(__gnu_debug::__base(__first), + __gnu_debug::__base(__last)); + _M_check_rehashed(__bucket_count); + } + + iterator + find(const key_type& __key) + { return iterator(_Base::find(__key), this); } + + const_iterator + find(const key_type& __key) const + { return const_iterator(_Base::find(__key), this); } + + std::pair + equal_range(const key_type& __key) + { + typedef std::pair<_Base_iterator, _Base_iterator> __pair_type; + __pair_type __res = _Base::equal_range(__key); + return std::make_pair(iterator(__res.first, this), + iterator(__res.second, this)); + } + + std::pair + equal_range(const key_type& __key) const + { + std::pair<_Base_const_iterator, _Base_const_iterator> + __res = _Base::equal_range(__key); + return std::make_pair(const_iterator(__res.first, this), + const_iterator(__res.second, this)); + } + + size_type + erase(const key_type& __key) + { + size_type __ret(0); + std::pair<_Base_iterator, _Base_iterator> __pair = + _Base::equal_range(__key); + for (_Base_iterator __victim = __pair.first; __victim != __pair.second;) + { + this->_M_invalidate_if([__victim](_Base_const_iterator __it) + { return __it == __victim; }); + this->_M_invalidate_local_if( + [__victim](_Base_const_local_iterator __it) + { return __it._M_curr() == __victim._M_cur; }); + _Base::erase(__victim++); + ++__ret; + } + return __ret; + } + + iterator + erase(const_iterator __it) + { + __glibcxx_check_erase(__it); + _Base_const_iterator __victim = __it.base(); + this->_M_invalidate_if([__victim](_Base_const_iterator __it) + { return __it == __victim; }); + this->_M_invalidate_local_if( + [__victim](_Base_const_local_iterator __it) + { return __it._M_curr() == __victim._M_cur; }); + return iterator(_Base::erase(__it.base()), this); + } + + iterator + erase(iterator __it) + { return erase(const_iterator(__it)); } + + iterator + erase(const_iterator __first, const_iterator __last) + { + __glibcxx_check_erase_range(__first, __last); + for (_Base_const_iterator __tmp = __first.base(); + __tmp != __last.base(); ++__tmp) + { + _GLIBCXX_DEBUG_VERIFY(__tmp != _Base::end(), + _M_message(__gnu_debug::__msg_valid_range) + ._M_iterator(__first, "first") + ._M_iterator(__last, "last")); + this->_M_invalidate_if([__tmp](_Base_const_iterator __it) + { return __it == __tmp; }); + this->_M_invalidate_local_if( + [__tmp](_Base_const_local_iterator __it) + { return __it._M_curr() == __tmp._M_cur; }); + } + return iterator(_Base::erase(__first.base(), + __last.base()), this); + } + + _Base& + _M_base() noexcept { return *this; } + + const _Base& + _M_base() const noexcept { return *this; } + + private: + void + _M_invalidate_locals() + { + _Base_local_iterator __local_end = _Base::end(0); + this->_M_invalidate_local_if( + [__local_end](_Base_const_local_iterator __it) + { return __it != __local_end; }); + } + + void + _M_invalidate_all() + { + _Base_iterator __end = _Base::end(); + this->_M_invalidate_if([__end](_Base_const_iterator __it) + { return __it != __end; }); + _M_invalidate_locals(); + } + + void + _M_check_rehashed(size_type __prev_count) + { + if (__prev_count != this->bucket_count()) + _M_invalidate_locals(); + } + }; + + template + inline void + swap(unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x, + unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y) + { __x.swap(__y); } + + template + inline bool + operator==(const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x, + const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y) + { return __x._M_base() == __y._M_base(); } + + template + inline bool + operator!=(const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x, + const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y) + { return !(__x == __y); } + +} // namespace __debug +} // namespace std + +#endif // C++11 + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/vector b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/vector new file mode 100755 index 0000000..f7f54ee --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/debug/vector @@ -0,0 +1,734 @@ +// Debugging vector implementation -*- C++ -*- + +// Copyright (C) 2003-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file debug/vector + * This file is a GNU debug extension to the Standard C++ Library. + */ + +#ifndef _GLIBCXX_DEBUG_VECTOR +#define _GLIBCXX_DEBUG_VECTOR 1 + +#include +#include +#include +#include + +namespace std _GLIBCXX_VISIBILITY(default) +{ +namespace __debug +{ + /// Class std::vector with safety/checking/debug instrumentation. + template > + class vector + : public _GLIBCXX_STD_C::vector<_Tp, _Allocator>, + public __gnu_debug::_Safe_sequence > + { + typedef _GLIBCXX_STD_C::vector<_Tp, _Allocator> _Base; + + typedef typename _Base::iterator _Base_iterator; + typedef typename _Base::const_iterator _Base_const_iterator; + typedef __gnu_debug::_Equal_to<_Base_const_iterator> _Equal; + +#if __cplusplus >= 201103L + typedef __gnu_debug::_Safe_sequence > _Safe_base; + typedef __gnu_cxx::__alloc_traits<_Allocator> _Alloc_traits; +#endif + + public: + typedef typename _Base::reference reference; + typedef typename _Base::const_reference const_reference; + + typedef __gnu_debug::_Safe_iterator<_Base_iterator,vector> + iterator; + typedef __gnu_debug::_Safe_iterator<_Base_const_iterator,vector> + const_iterator; + + typedef typename _Base::size_type size_type; + typedef typename _Base::difference_type difference_type; + + typedef _Tp value_type; + typedef _Allocator allocator_type; + typedef typename _Base::pointer pointer; + typedef typename _Base::const_pointer const_pointer; + typedef std::reverse_iterator reverse_iterator; + typedef std::reverse_iterator const_reverse_iterator; + + // 23.2.4.1 construct/copy/destroy: + + vector() _GLIBCXX_NOEXCEPT + : _Base(), _M_guaranteed_capacity(0) { } + + explicit + vector(const _Allocator& __a) _GLIBCXX_NOEXCEPT + : _Base(__a), _M_guaranteed_capacity(0) { } + +#if __cplusplus >= 201103L + explicit + vector(size_type __n, const _Allocator& __a = _Allocator()) + : _Base(__n, __a), _M_guaranteed_capacity(__n) { } + + vector(size_type __n, const _Tp& __value, + const _Allocator& __a = _Allocator()) + : _Base(__n, __value, __a), _M_guaranteed_capacity(__n) { } +#else + explicit + vector(size_type __n, const _Tp& __value = _Tp(), + const _Allocator& __a = _Allocator()) + : _Base(__n, __value, __a), _M_guaranteed_capacity(__n) { } +#endif + +#if __cplusplus >= 201103L + template> +#else + template +#endif + vector(_InputIterator __first, _InputIterator __last, + const _Allocator& __a = _Allocator()) + : _Base(__gnu_debug::__base(__gnu_debug::__check_valid_range(__first, + __last)), + __gnu_debug::__base(__last), __a), + _M_guaranteed_capacity(0) + { _M_update_guaranteed_capacity(); } + + vector(const vector& __x) + : _Base(__x), _M_guaranteed_capacity(__x.size()) { } + + /// Construction from a normal-mode vector + vector(const _Base& __x) + : _Base(__x), _M_guaranteed_capacity(__x.size()) { } + +#if __cplusplus >= 201103L + vector(vector&& __x) noexcept + : _Base(std::move(__x)), + _Safe_base(std::move(__x)), + _M_guaranteed_capacity(this->size()) + { __x._M_guaranteed_capacity = 0; } + + vector(const vector& __x, const allocator_type& __a) + : _Base(__x, __a), _M_guaranteed_capacity(__x.size()) { } + + vector(vector&& __x, const allocator_type& __a) + : _Base(std::move(__x), __a), + _M_guaranteed_capacity(this->size()) + { + if (__x.get_allocator() == __a) + this->_M_swap(__x); + else + __x._M_invalidate_all(); + __x._M_guaranteed_capacity = 0; + } + + vector(initializer_list __l, + const allocator_type& __a = allocator_type()) + : _Base(__l, __a), + _M_guaranteed_capacity(__l.size()) { } +#endif + + ~vector() _GLIBCXX_NOEXCEPT { } + + vector& + operator=(const vector& __x) + { + _M_base() = __x; + this->_M_invalidate_all(); + _M_update_guaranteed_capacity(); + return *this; + } + +#if __cplusplus >= 201103L + vector& + operator=(vector&& __x) noexcept(_Alloc_traits::_S_nothrow_move()) + { + __glibcxx_check_self_move_assign(__x); + bool __xfer_memory = _Alloc_traits::_S_propagate_on_move_assign() + || __x.get_allocator() == this->get_allocator(); + _M_base() = std::move(__x._M_base()); + if (__xfer_memory) + this->_M_swap(__x); + else + this->_M_invalidate_all(); + _M_update_guaranteed_capacity(); + __x._M_invalidate_all(); + __x._M_guaranteed_capacity = 0; + return *this; + } + + vector& + operator=(initializer_list __l) + { + _M_base() = __l; + this->_M_invalidate_all(); + _M_update_guaranteed_capacity(); + return *this; + } +#endif + +#if __cplusplus >= 201103L + template> +#else + template +#endif + void + assign(_InputIterator __first, _InputIterator __last) + { + __glibcxx_check_valid_range(__first, __last); + _Base::assign(__gnu_debug::__base(__first), + __gnu_debug::__base(__last)); + this->_M_invalidate_all(); + _M_update_guaranteed_capacity(); + } + + void + assign(size_type __n, const _Tp& __u) + { + _Base::assign(__n, __u); + this->_M_invalidate_all(); + _M_update_guaranteed_capacity(); + } + +#if __cplusplus >= 201103L + void + assign(initializer_list __l) + { + _Base::assign(__l); + this->_M_invalidate_all(); + _M_update_guaranteed_capacity(); + } +#endif + + using _Base::get_allocator; + + // iterators: + iterator + begin() _GLIBCXX_NOEXCEPT + { return iterator(_Base::begin(), this); } + + const_iterator + begin() const _GLIBCXX_NOEXCEPT + { return const_iterator(_Base::begin(), this); } + + iterator + end() _GLIBCXX_NOEXCEPT + { return iterator(_Base::end(), this); } + + const_iterator + end() const _GLIBCXX_NOEXCEPT + { return const_iterator(_Base::end(), this); } + + reverse_iterator + rbegin() _GLIBCXX_NOEXCEPT + { return reverse_iterator(end()); } + + const_reverse_iterator + rbegin() const _GLIBCXX_NOEXCEPT + { return const_reverse_iterator(end()); } + + reverse_iterator + rend() _GLIBCXX_NOEXCEPT + { return reverse_iterator(begin()); } + + const_reverse_iterator + rend() const _GLIBCXX_NOEXCEPT + { return const_reverse_iterator(begin()); } + +#if __cplusplus >= 201103L + const_iterator + cbegin() const noexcept + { return const_iterator(_Base::begin(), this); } + + const_iterator + cend() const noexcept + { return const_iterator(_Base::end(), this); } + + const_reverse_iterator + crbegin() const noexcept + { return const_reverse_iterator(end()); } + + const_reverse_iterator + crend() const noexcept + { return const_reverse_iterator(begin()); } +#endif + + // 23.2.4.2 capacity: + using _Base::size; + using _Base::max_size; + +#if __cplusplus >= 201103L + void + resize(size_type __sz) + { + bool __realloc = _M_requires_reallocation(__sz); + if (__sz < this->size()) + this->_M_invalidate_after_nth(__sz); + _Base::resize(__sz); + if (__realloc) + this->_M_invalidate_all(); + _M_update_guaranteed_capacity(); + } + + void + resize(size_type __sz, const _Tp& __c) + { + bool __realloc = _M_requires_reallocation(__sz); + if (__sz < this->size()) + this->_M_invalidate_after_nth(__sz); + _Base::resize(__sz, __c); + if (__realloc) + this->_M_invalidate_all(); + _M_update_guaranteed_capacity(); + } +#else + void + resize(size_type __sz, _Tp __c = _Tp()) + { + bool __realloc = _M_requires_reallocation(__sz); + if (__sz < this->size()) + this->_M_invalidate_after_nth(__sz); + _Base::resize(__sz, __c); + if (__realloc) + this->_M_invalidate_all(); + _M_update_guaranteed_capacity(); + } +#endif + +#if __cplusplus >= 201103L + void + shrink_to_fit() + { + if (_Base::_M_shrink_to_fit()) + { + _M_guaranteed_capacity = _Base::capacity(); + this->_M_invalidate_all(); + } + } +#endif + + size_type + capacity() const _GLIBCXX_NOEXCEPT + { +#ifdef _GLIBCXX_DEBUG_PEDANTIC + return _M_guaranteed_capacity; +#else + return _Base::capacity(); +#endif + } + + using _Base::empty; + + void + reserve(size_type __n) + { + bool __realloc = _M_requires_reallocation(__n); + _Base::reserve(__n); + if (__n > _M_guaranteed_capacity) + _M_guaranteed_capacity = __n; + if (__realloc) + this->_M_invalidate_all(); + } + + // element access: + reference + operator[](size_type __n) _GLIBCXX_NOEXCEPT + { + __glibcxx_check_subscript(__n); + return _M_base()[__n]; + } + + const_reference + operator[](size_type __n) const _GLIBCXX_NOEXCEPT + { + __glibcxx_check_subscript(__n); + return _M_base()[__n]; + } + + using _Base::at; + + reference + front() _GLIBCXX_NOEXCEPT + { + __glibcxx_check_nonempty(); + return _Base::front(); + } + + const_reference + front() const _GLIBCXX_NOEXCEPT + { + __glibcxx_check_nonempty(); + return _Base::front(); + } + + reference + back() _GLIBCXX_NOEXCEPT + { + __glibcxx_check_nonempty(); + return _Base::back(); + } + + const_reference + back() const _GLIBCXX_NOEXCEPT + { + __glibcxx_check_nonempty(); + return _Base::back(); + } + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // DR 464. Suggestion for new member functions in standard containers. + using _Base::data; + + // 23.2.4.3 modifiers: + void + push_back(const _Tp& __x) + { + bool __realloc = _M_requires_reallocation(this->size() + 1); + _Base::push_back(__x); + if (__realloc) + this->_M_invalidate_all(); + _M_update_guaranteed_capacity(); + } + +#if __cplusplus >= 201103L + template + typename __gnu_cxx::__enable_if::__value, + void>::__type + push_back(_Tp&& __x) + { emplace_back(std::move(__x)); } + + template + void + emplace_back(_Args&&... __args) + { + bool __realloc = _M_requires_reallocation(this->size() + 1); + _Base::emplace_back(std::forward<_Args>(__args)...); + if (__realloc) + this->_M_invalidate_all(); + _M_update_guaranteed_capacity(); + } +#endif + + void + pop_back() _GLIBCXX_NOEXCEPT + { + __glibcxx_check_nonempty(); + this->_M_invalidate_if(_Equal(--_Base::end())); + _Base::pop_back(); + } + +#if __cplusplus >= 201103L + template + iterator + emplace(const_iterator __position, _Args&&... __args) + { + __glibcxx_check_insert(__position); + bool __realloc = _M_requires_reallocation(this->size() + 1); + difference_type __offset = __position.base() - _Base::begin(); + _Base_iterator __res = _Base::emplace(__position.base(), + std::forward<_Args>(__args)...); + if (__realloc) + this->_M_invalidate_all(); + else + this->_M_invalidate_after_nth(__offset); + _M_update_guaranteed_capacity(); + return iterator(__res, this); + } +#endif + + iterator +#if __cplusplus >= 201103L + insert(const_iterator __position, const _Tp& __x) +#else + insert(iterator __position, const _Tp& __x) +#endif + { + __glibcxx_check_insert(__position); + bool __realloc = _M_requires_reallocation(this->size() + 1); + difference_type __offset = __position.base() - _Base::begin(); + _Base_iterator __res = _Base::insert(__position.base(), __x); + if (__realloc) + this->_M_invalidate_all(); + else + this->_M_invalidate_after_nth(__offset); + _M_update_guaranteed_capacity(); + return iterator(__res, this); + } + +#if __cplusplus >= 201103L + template + typename __gnu_cxx::__enable_if::__value, + iterator>::__type + insert(const_iterator __position, _Tp&& __x) + { return emplace(__position, std::move(__x)); } + + iterator + insert(const_iterator __position, initializer_list __l) + { return this->insert(__position, __l.begin(), __l.end()); } +#endif + +#if __cplusplus >= 201103L + iterator + insert(const_iterator __position, size_type __n, const _Tp& __x) + { + __glibcxx_check_insert(__position); + bool __realloc = _M_requires_reallocation(this->size() + __n); + difference_type __offset = __position.base() - _Base::cbegin(); + _Base_iterator __res = _Base::insert(__position.base(), __n, __x); + if (__realloc) + this->_M_invalidate_all(); + else + this->_M_invalidate_after_nth(__offset); + _M_update_guaranteed_capacity(); + return iterator(__res, this); + } +#else + void + insert(iterator __position, size_type __n, const _Tp& __x) + { + __glibcxx_check_insert(__position); + bool __realloc = _M_requires_reallocation(this->size() + __n); + difference_type __offset = __position.base() - _Base::begin(); + _Base::insert(__position.base(), __n, __x); + if (__realloc) + this->_M_invalidate_all(); + else + this->_M_invalidate_after_nth(__offset); + _M_update_guaranteed_capacity(); + } +#endif + +#if __cplusplus >= 201103L + template> + iterator + insert(const_iterator __position, + _InputIterator __first, _InputIterator __last) + { + __glibcxx_check_insert_range(__position, __first, __last); + + /* Hard to guess if invalidation will occur, because __last + - __first can't be calculated in all cases, so we just + punt here by checking if it did occur. */ + _Base_iterator __old_begin = _M_base().begin(); + difference_type __offset = __position.base() - _Base::cbegin(); + _Base_iterator __res = _Base::insert(__position.base(), + __gnu_debug::__base(__first), + __gnu_debug::__base(__last)); + + if (_M_base().begin() != __old_begin) + this->_M_invalidate_all(); + else + this->_M_invalidate_after_nth(__offset); + _M_update_guaranteed_capacity(); + return iterator(__res, this); + } +#else + template + void + insert(iterator __position, + _InputIterator __first, _InputIterator __last) + { + __glibcxx_check_insert_range(__position, __first, __last); + + /* Hard to guess if invalidation will occur, because __last + - __first can't be calculated in all cases, so we just + punt here by checking if it did occur. */ + _Base_iterator __old_begin = _M_base().begin(); + difference_type __offset = __position.base() - _Base::begin(); + _Base::insert(__position.base(), __gnu_debug::__base(__first), + __gnu_debug::__base(__last)); + + if (_M_base().begin() != __old_begin) + this->_M_invalidate_all(); + else + this->_M_invalidate_after_nth(__offset); + _M_update_guaranteed_capacity(); + } +#endif + + iterator +#if __cplusplus >= 201103L + erase(const_iterator __position) +#else + erase(iterator __position) +#endif + { + __glibcxx_check_erase(__position); + difference_type __offset = __position.base() - _Base::begin(); + _Base_iterator __res = _Base::erase(__position.base()); + this->_M_invalidate_after_nth(__offset); + return iterator(__res, this); + } + + iterator +#if __cplusplus >= 201103L + erase(const_iterator __first, const_iterator __last) +#else + erase(iterator __first, iterator __last) +#endif + { + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 151. can't currently clear() empty container + __glibcxx_check_erase_range(__first, __last); + + if (__first.base() != __last.base()) + { + difference_type __offset = __first.base() - _Base::begin(); + _Base_iterator __res = _Base::erase(__first.base(), + __last.base()); + this->_M_invalidate_after_nth(__offset); + return iterator(__res, this); + } + else +#if __cplusplus >= 201103L + return begin() + (__first.base() - cbegin().base()); +#else + return __first; +#endif + } + + void + swap(vector& __x) +#if __cplusplus >= 201103L + noexcept(_Alloc_traits::_S_nothrow_swap()) +#endif + { +#if __cplusplus >= 201103L + if (!_Alloc_traits::_S_propagate_on_swap()) + __glibcxx_check_equal_allocs(__x); +#endif + _Base::swap(__x); + this->_M_swap(__x); + std::swap(_M_guaranteed_capacity, __x._M_guaranteed_capacity); + } + + void + clear() _GLIBCXX_NOEXCEPT + { + _Base::clear(); + this->_M_invalidate_all(); + _M_guaranteed_capacity = 0; + } + + _Base& + _M_base() _GLIBCXX_NOEXCEPT { return *this; } + + const _Base& + _M_base() const _GLIBCXX_NOEXCEPT { return *this; } + + private: + size_type _M_guaranteed_capacity; + + bool + _M_requires_reallocation(size_type __elements) _GLIBCXX_NOEXCEPT + { return __elements > this->capacity(); } + + void + _M_update_guaranteed_capacity() _GLIBCXX_NOEXCEPT + { + if (this->size() > _M_guaranteed_capacity) + _M_guaranteed_capacity = this->size(); + } + + void + _M_invalidate_after_nth(difference_type __n) _GLIBCXX_NOEXCEPT + { + typedef __gnu_debug::_After_nth_from<_Base_const_iterator> _After_nth; + this->_M_invalidate_if(_After_nth(__n, _Base::begin())); + } + }; + + template + inline bool + operator==(const vector<_Tp, _Alloc>& __lhs, + const vector<_Tp, _Alloc>& __rhs) + { return __lhs._M_base() == __rhs._M_base(); } + + template + inline bool + operator!=(const vector<_Tp, _Alloc>& __lhs, + const vector<_Tp, _Alloc>& __rhs) + { return __lhs._M_base() != __rhs._M_base(); } + + template + inline bool + operator<(const vector<_Tp, _Alloc>& __lhs, + const vector<_Tp, _Alloc>& __rhs) + { return __lhs._M_base() < __rhs._M_base(); } + + template + inline bool + operator<=(const vector<_Tp, _Alloc>& __lhs, + const vector<_Tp, _Alloc>& __rhs) + { return __lhs._M_base() <= __rhs._M_base(); } + + template + inline bool + operator>=(const vector<_Tp, _Alloc>& __lhs, + const vector<_Tp, _Alloc>& __rhs) + { return __lhs._M_base() >= __rhs._M_base(); } + + template + inline bool + operator>(const vector<_Tp, _Alloc>& __lhs, + const vector<_Tp, _Alloc>& __rhs) + { return __lhs._M_base() > __rhs._M_base(); } + + template + inline void + swap(vector<_Tp, _Alloc>& __lhs, vector<_Tp, _Alloc>& __rhs) + { __lhs.swap(__rhs); } + +} // namespace __debug + +#if __cplusplus >= 201103L + // DR 1182. + /// std::hash specialization for vector. + template + struct hash<__debug::vector> + : public __hash_base> + { + size_t + operator()(const __debug::vector& __b) const noexcept + { return std::hash<_GLIBCXX_STD_C::vector>() + (__b._M_base()); } + }; +#endif + +} // namespace std + +namespace __gnu_debug +{ + template + struct _Is_contiguous_sequence > + : std::__true_type + { }; + + template + struct _Is_contiguous_sequence > + : std::__false_type + { }; +} + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/decimal/decimal b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/decimal/decimal new file mode 100755 index 0000000..d60790e --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/decimal/decimal @@ -0,0 +1,494 @@ +// -*- C++ -*- + +// Copyright (C) 2009-2014 Free Software Foundation, Inc. +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file decimal/decimal + * This is a Standard C++ Library header. + */ + +// ISO/IEC TR 24733 +// Written by Janis Johnson + +#ifndef _GLIBCXX_DECIMAL +#define _GLIBCXX_DECIMAL 1 + +#pragma GCC system_header + +#include + +#ifndef _GLIBCXX_USE_DECIMAL_FLOAT +#error This file requires compiler and library support for ISO/IEC TR 24733 \ +that is currently not available. +#endif + +namespace std _GLIBCXX_VISIBILITY(default) +{ + /** + * @defgroup decimal Decimal Floating-Point Arithmetic + * @ingroup numerics + * + * Classes and functions for decimal floating-point arithmetic. + * @{ + */ + + /** @namespace std::decimal + * @brief ISO/IEC TR 24733 Decimal floating-point arithmetic. + */ +namespace decimal +{ + _GLIBCXX_BEGIN_NAMESPACE_VERSION + + class decimal32; + class decimal64; + class decimal128; + + // 3.2.5 Initialization from coefficient and exponent. + static decimal32 make_decimal32(long long __coeff, int __exp); + static decimal32 make_decimal32(unsigned long long __coeff, int __exp); + static decimal64 make_decimal64(long long __coeff, int __exp); + static decimal64 make_decimal64(unsigned long long __coeff, int __exp); + static decimal128 make_decimal128(long long __coeff, int __exp); + static decimal128 make_decimal128(unsigned long long __coeff, int __exp); + + /// Non-conforming extension: Conversion to integral type. + long long decimal32_to_long_long(decimal32 __d); + long long decimal64_to_long_long(decimal64 __d); + long long decimal128_to_long_long(decimal128 __d); + long long decimal_to_long_long(decimal32 __d); + long long decimal_to_long_long(decimal64 __d); + long long decimal_to_long_long(decimal128 __d); + + // 3.2.6 Conversion to generic floating-point type. + float decimal32_to_float(decimal32 __d); + float decimal64_to_float(decimal64 __d); + float decimal128_to_float(decimal128 __d); + float decimal_to_float(decimal32 __d); + float decimal_to_float(decimal64 __d); + float decimal_to_float(decimal128 __d); + + double decimal32_to_double(decimal32 __d); + double decimal64_to_double(decimal64 __d); + double decimal128_to_double(decimal128 __d); + double decimal_to_double(decimal32 __d); + double decimal_to_double(decimal64 __d); + double decimal_to_double(decimal128 __d); + + long double decimal32_to_long_double(decimal32 __d); + long double decimal64_to_long_double(decimal64 __d); + long double decimal128_to_long_double(decimal128 __d); + long double decimal_to_long_double(decimal32 __d); + long double decimal_to_long_double(decimal64 __d); + long double decimal_to_long_double(decimal128 __d); + + // 3.2.7 Unary arithmetic operators. + decimal32 operator+(decimal32 __rhs); + decimal64 operator+(decimal64 __rhs); + decimal128 operator+(decimal128 __rhs); + decimal32 operator-(decimal32 __rhs); + decimal64 operator-(decimal64 __rhs); + decimal128 operator-(decimal128 __rhs); + + // 3.2.8 Binary arithmetic operators. +#define _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(_Op, _T1, _T2, _T3) \ + _T1 operator _Op(_T2 __lhs, _T3 __rhs); +#define _DECLARE_DECIMAL_BINARY_OP_WITH_INT(_Op, _Tp) \ + _Tp operator _Op(_Tp __lhs, int __rhs); \ + _Tp operator _Op(_Tp __lhs, unsigned int __rhs); \ + _Tp operator _Op(_Tp __lhs, long __rhs); \ + _Tp operator _Op(_Tp __lhs, unsigned long __rhs); \ + _Tp operator _Op(_Tp __lhs, long long __rhs); \ + _Tp operator _Op(_Tp __lhs, unsigned long long __rhs); \ + _Tp operator _Op(int __lhs, _Tp __rhs); \ + _Tp operator _Op(unsigned int __lhs, _Tp __rhs); \ + _Tp operator _Op(long __lhs, _Tp __rhs); \ + _Tp operator _Op(unsigned long __lhs, _Tp __rhs); \ + _Tp operator _Op(long long __lhs, _Tp __rhs); \ + _Tp operator _Op(unsigned long long __lhs, _Tp __rhs); + + _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(+, decimal32, decimal32, decimal32) + _DECLARE_DECIMAL_BINARY_OP_WITH_INT(+, decimal32) + _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(+, decimal64, decimal32, decimal64) + _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(+, decimal64, decimal64, decimal32) + _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(+, decimal64, decimal64, decimal64) + _DECLARE_DECIMAL_BINARY_OP_WITH_INT(+, decimal64) + _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(+, decimal128, decimal32, decimal128) + _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(+, decimal128, decimal64, decimal128) + _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(+, decimal128, decimal128, decimal32) + _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(+, decimal128, decimal128, decimal64) + _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(+, decimal128, decimal128, decimal128) + _DECLARE_DECIMAL_BINARY_OP_WITH_INT(+, decimal128) + + _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(-, decimal32, decimal32, decimal32) + _DECLARE_DECIMAL_BINARY_OP_WITH_INT(-, decimal32) + _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(-, decimal64, decimal32, decimal64) + _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(-, decimal64, decimal64, decimal32) + _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(-, decimal64, decimal64, decimal64) + _DECLARE_DECIMAL_BINARY_OP_WITH_INT(-, decimal64) + _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(-, decimal128, decimal32, decimal128) + _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(-, decimal128, decimal64, decimal128) + _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(-, decimal128, decimal128, decimal32) + _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(-, decimal128, decimal128, decimal64) + _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(-, decimal128, decimal128, decimal128) + _DECLARE_DECIMAL_BINARY_OP_WITH_INT(-, decimal128) + + _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(*, decimal32, decimal32, decimal32) + _DECLARE_DECIMAL_BINARY_OP_WITH_INT(*, decimal32) + _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(*, decimal64, decimal32, decimal64) + _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(*, decimal64, decimal64, decimal32) + _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(*, decimal64, decimal64, decimal64) + _DECLARE_DECIMAL_BINARY_OP_WITH_INT(*, decimal64) + _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(*, decimal128, decimal32, decimal128) + _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(*, decimal128, decimal64, decimal128) + _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(*, decimal128, decimal128, decimal32) + _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(*, decimal128, decimal128, decimal64) + _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(*, decimal128, decimal128, decimal128) + _DECLARE_DECIMAL_BINARY_OP_WITH_INT(*, decimal128) + + _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(/, decimal32, decimal32, decimal32) + _DECLARE_DECIMAL_BINARY_OP_WITH_INT(/, decimal32) + _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(/, decimal64, decimal32, decimal64) + _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(/, decimal64, decimal64, decimal32) + _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(/, decimal64, decimal64, decimal64) + _DECLARE_DECIMAL_BINARY_OP_WITH_INT(/, decimal64) + _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(/, decimal128, decimal32, decimal128) + _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(/, decimal128, decimal64, decimal128) + _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(/, decimal128, decimal128, decimal32) + _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(/, decimal128, decimal128, decimal64) + _DECLARE_DECIMAL_BINARY_OP_WITH_DEC(/, decimal128, decimal128, decimal128) + _DECLARE_DECIMAL_BINARY_OP_WITH_INT(/, decimal128) + +#undef _DECLARE_DECIMAL_BINARY_OP_WITH_DEC +#undef _DECLARE_DECIMAL_BINARY_OP_WITH_INT + + // 3.2.9 Comparison operators. +#define _DECLARE_DECIMAL_COMPARISON(_Op, _Tp) \ + bool operator _Op(_Tp __lhs, decimal32 __rhs); \ + bool operator _Op(_Tp __lhs, decimal64 __rhs); \ + bool operator _Op(_Tp __lhs, decimal128 __rhs); \ + bool operator _Op(_Tp __lhs, int __rhs); \ + bool operator _Op(_Tp __lhs, unsigned int __rhs); \ + bool operator _Op(_Tp __lhs, long __rhs); \ + bool operator _Op(_Tp __lhs, unsigned long __rhs); \ + bool operator _Op(_Tp __lhs, long long __rhs); \ + bool operator _Op(_Tp __lhs, unsigned long long __rhs); \ + bool operator _Op(int __lhs, _Tp __rhs); \ + bool operator _Op(unsigned int __lhs, _Tp __rhs); \ + bool operator _Op(long __lhs, _Tp __rhs); \ + bool operator _Op(unsigned long __lhs, _Tp __rhs); \ + bool operator _Op(long long __lhs, _Tp __rhs); \ + bool operator _Op(unsigned long long __lhs, _Tp __rhs); + + _DECLARE_DECIMAL_COMPARISON(==, decimal32) + _DECLARE_DECIMAL_COMPARISON(==, decimal64) + _DECLARE_DECIMAL_COMPARISON(==, decimal128) + + _DECLARE_DECIMAL_COMPARISON(!=, decimal32) + _DECLARE_DECIMAL_COMPARISON(!=, decimal64) + _DECLARE_DECIMAL_COMPARISON(!=, decimal128) + + _DECLARE_DECIMAL_COMPARISON(<, decimal32) + _DECLARE_DECIMAL_COMPARISON(<, decimal64) + _DECLARE_DECIMAL_COMPARISON(<, decimal128) + + _DECLARE_DECIMAL_COMPARISON(>=, decimal32) + _DECLARE_DECIMAL_COMPARISON(>=, decimal64) + _DECLARE_DECIMAL_COMPARISON(>=, decimal128) + + _DECLARE_DECIMAL_COMPARISON(>, decimal32) + _DECLARE_DECIMAL_COMPARISON(>, decimal64) + _DECLARE_DECIMAL_COMPARISON(>, decimal128) + + _DECLARE_DECIMAL_COMPARISON(>=, decimal32) + _DECLARE_DECIMAL_COMPARISON(>=, decimal64) + _DECLARE_DECIMAL_COMPARISON(>=, decimal128) + +#undef _DECLARE_DECIMAL_COMPARISON + + /// 3.2.2 Class decimal32. + class decimal32 + { + public: + typedef float __decfloat32 __attribute__((mode(SD))); + + // 3.2.2.2 Construct/copy/destroy. + decimal32() : __val(0.e-101DF) {} + + // 3.2.2.3 Conversion from floating-point type. + explicit decimal32(decimal64 __d64); + explicit decimal32(decimal128 __d128); + explicit decimal32(float __r) : __val(__r) {} + explicit decimal32(double __r) : __val(__r) {} + explicit decimal32(long double __r) : __val(__r) {} + + // 3.2.2.4 Conversion from integral type. + decimal32(int __z) : __val(__z) {} + decimal32(unsigned int __z) : __val(__z) {} + decimal32(long __z) : __val(__z) {} + decimal32(unsigned long __z) : __val(__z) {} + decimal32(long long __z) : __val(__z) {} + decimal32(unsigned long long __z) : __val(__z) {} + + /// Conforming extension: Conversion from scalar decimal type. + decimal32(__decfloat32 __z) : __val(__z) {} + +#if __cplusplus >= 201103L + // 3.2.2.5 Conversion to integral type. + // Note: explicit per n3407. + explicit operator long long() const { return (long long)__val; } +#endif + + // 3.2.2.6 Increment and decrement operators. + decimal32& operator++() + { + __val += 1; + return *this; + } + + decimal32 operator++(int) + { + decimal32 __tmp = *this; + __val += 1; + return __tmp; + } + + decimal32& operator--() + { + __val -= 1; + return *this; + } + + decimal32 operator--(int) + { + decimal32 __tmp = *this; + __val -= 1; + return __tmp; + } + + // 3.2.2.7 Compound assignment. +#define _DECLARE_DECIMAL32_COMPOUND_ASSIGNMENT(_Op) \ + decimal32& operator _Op(decimal32 __rhs); \ + decimal32& operator _Op(decimal64 __rhs); \ + decimal32& operator _Op(decimal128 __rhs); \ + decimal32& operator _Op(int __rhs); \ + decimal32& operator _Op(unsigned int __rhs); \ + decimal32& operator _Op(long __rhs); \ + decimal32& operator _Op(unsigned long __rhs); \ + decimal32& operator _Op(long long __rhs); \ + decimal32& operator _Op(unsigned long long __rhs); + + _DECLARE_DECIMAL32_COMPOUND_ASSIGNMENT(+=) + _DECLARE_DECIMAL32_COMPOUND_ASSIGNMENT(-=) + _DECLARE_DECIMAL32_COMPOUND_ASSIGNMENT(*=) + _DECLARE_DECIMAL32_COMPOUND_ASSIGNMENT(/=) +#undef _DECLARE_DECIMAL32_COMPOUND_ASSIGNMENT + + private: + __decfloat32 __val; + + public: + __decfloat32 __getval(void) { return __val; } + void __setval(__decfloat32 __x) { __val = __x; } + }; + + /// 3.2.3 Class decimal64. + class decimal64 + { + public: + typedef float __decfloat64 __attribute__((mode(DD))); + + // 3.2.3.2 Construct/copy/destroy. + decimal64() : __val(0.e-398dd) {} + + // 3.2.3.3 Conversion from floating-point type. + decimal64(decimal32 d32); + explicit decimal64(decimal128 d128); + explicit decimal64(float __r) : __val(__r) {} + explicit decimal64(double __r) : __val(__r) {} + explicit decimal64(long double __r) : __val(__r) {} + + // 3.2.3.4 Conversion from integral type. + decimal64(int __z) : __val(__z) {} + decimal64(unsigned int __z) : __val(__z) {} + decimal64(long __z) : __val(__z) {} + decimal64(unsigned long __z) : __val(__z) {} + decimal64(long long __z) : __val(__z) {} + decimal64(unsigned long long __z) : __val(__z) {} + + /// Conforming extension: Conversion from scalar decimal type. + decimal64(__decfloat64 __z) : __val(__z) {} + +#if __cplusplus >= 201103L + // 3.2.3.5 Conversion to integral type. + // Note: explicit per n3407. + explicit operator long long() const { return (long long)__val; } +#endif + + // 3.2.3.6 Increment and decrement operators. + decimal64& operator++() + { + __val += 1; + return *this; + } + + decimal64 operator++(int) + { + decimal64 __tmp = *this; + __val += 1; + return __tmp; + } + + decimal64& operator--() + { + __val -= 1; + return *this; + } + + decimal64 operator--(int) + { + decimal64 __tmp = *this; + __val -= 1; + return __tmp; + } + + // 3.2.3.7 Compound assignment. +#define _DECLARE_DECIMAL64_COMPOUND_ASSIGNMENT(_Op) \ + decimal64& operator _Op(decimal32 __rhs); \ + decimal64& operator _Op(decimal64 __rhs); \ + decimal64& operator _Op(decimal128 __rhs); \ + decimal64& operator _Op(int __rhs); \ + decimal64& operator _Op(unsigned int __rhs); \ + decimal64& operator _Op(long __rhs); \ + decimal64& operator _Op(unsigned long __rhs); \ + decimal64& operator _Op(long long __rhs); \ + decimal64& operator _Op(unsigned long long __rhs); + + _DECLARE_DECIMAL64_COMPOUND_ASSIGNMENT(+=) + _DECLARE_DECIMAL64_COMPOUND_ASSIGNMENT(-=) + _DECLARE_DECIMAL64_COMPOUND_ASSIGNMENT(*=) + _DECLARE_DECIMAL64_COMPOUND_ASSIGNMENT(/=) +#undef _DECLARE_DECIMAL64_COMPOUND_ASSIGNMENT + + private: + __decfloat64 __val; + + public: + __decfloat64 __getval(void) { return __val; } + void __setval(__decfloat64 __x) { __val = __x; } + }; + + /// 3.2.4 Class decimal128. + class decimal128 + { + public: + typedef float __decfloat128 __attribute__((mode(TD))); + + // 3.2.4.2 Construct/copy/destroy. + decimal128() : __val(0.e-6176DL) {} + + // 3.2.4.3 Conversion from floating-point type. + decimal128(decimal32 d32); + decimal128(decimal64 d64); + explicit decimal128(float __r) : __val(__r) {} + explicit decimal128(double __r) : __val(__r) {} + explicit decimal128(long double __r) : __val(__r) {} + + + // 3.2.4.4 Conversion from integral type. + decimal128(int __z) : __val(__z) {} + decimal128(unsigned int __z) : __val(__z) {} + decimal128(long __z) : __val(__z) {} + decimal128(unsigned long __z) : __val(__z) {} + decimal128(long long __z) : __val(__z) {} + decimal128(unsigned long long __z) : __val(__z) {} + + /// Conforming extension: Conversion from scalar decimal type. + decimal128(__decfloat128 __z) : __val(__z) {} + +#if __cplusplus >= 201103L + // 3.2.4.5 Conversion to integral type. + // Note: explicit per n3407. + explicit operator long long() const { return (long long)__val; } +#endif + + // 3.2.4.6 Increment and decrement operators. + decimal128& operator++() + { + __val += 1; + return *this; + } + + decimal128 operator++(int) + { + decimal128 __tmp = *this; + __val += 1; + return __tmp; + } + + decimal128& operator--() + { + __val -= 1; + return *this; + } + + decimal128 operator--(int) + { + decimal128 __tmp = *this; + __val -= 1; + return __tmp; + } + + // 3.2.4.7 Compound assignment. +#define _DECLARE_DECIMAL128_COMPOUND_ASSIGNMENT(_Op) \ + decimal128& operator _Op(decimal32 __rhs); \ + decimal128& operator _Op(decimal64 __rhs); \ + decimal128& operator _Op(decimal128 __rhs); \ + decimal128& operator _Op(int __rhs); \ + decimal128& operator _Op(unsigned int __rhs); \ + decimal128& operator _Op(long __rhs); \ + decimal128& operator _Op(unsigned long __rhs); \ + decimal128& operator _Op(long long __rhs); \ + decimal128& operator _Op(unsigned long long __rhs); + + _DECLARE_DECIMAL128_COMPOUND_ASSIGNMENT(+=) + _DECLARE_DECIMAL128_COMPOUND_ASSIGNMENT(-=) + _DECLARE_DECIMAL128_COMPOUND_ASSIGNMENT(*=) + _DECLARE_DECIMAL128_COMPOUND_ASSIGNMENT(/=) +#undef _DECLARE_DECIMAL128_COMPOUND_ASSIGNMENT + + private: + __decfloat128 __val; + + public: + __decfloat128 __getval(void) { return __val; } + void __setval(__decfloat128 __x) { __val = __x; } + }; + +#define _GLIBCXX_USE_DECIMAL_ 1 + + _GLIBCXX_END_NAMESPACE_VERSION +} // namespace decimal + // @} group decimal +} // namespace std + +#include + +#endif /* _GLIBCXX_DECIMAL */ diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/decimal/decimal.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/decimal/decimal.h new file mode 100755 index 0000000..969962c --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/decimal/decimal.h @@ -0,0 +1,468 @@ +// decimal classes -*- C++ -*- + +// Copyright (C) 2009-2014 Free Software Foundation, Inc. + +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file decimal/decimal.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{decimal} + */ + +// ISO/IEC TR 24733 +// Written by Janis Johnson + +#ifndef _GLIBCXX_DECIMAL_IMPL +#define _GLIBCXX_DECIMAL_IMPL 1 + +#pragma GCC system_header + +namespace std _GLIBCXX_VISIBILITY(default) +{ +namespace decimal +{ + _GLIBCXX_BEGIN_NAMESPACE_VERSION + + // ISO/IEC TR 24733 3.2.[234].1 Construct/copy/destroy. + + inline decimal32::decimal32(decimal64 __r) : __val(__r.__getval()) {} + inline decimal32::decimal32(decimal128 __r) : __val(__r.__getval()) {} + inline decimal64::decimal64(decimal32 __r) : __val(__r.__getval()) {} + inline decimal64::decimal64(decimal128 __r) : __val(__r.__getval()) {} + inline decimal128::decimal128(decimal32 __r) : __val(__r.__getval()) {} + inline decimal128::decimal128(decimal64 __r) : __val(__r.__getval()) {} + + // ISO/IEC TR 24733 3.2.[234].6 Compound assignment. + +#define _DEFINE_DECIMAL_COMPOUND_ASSIGNMENT_DEC(_Op1, _Op2, _T1, _T2) \ + inline _T1& _T1::operator _Op1(_T2 __rhs) \ + { \ + __setval(__getval() _Op2 __rhs.__getval()); \ + return *this; \ + } + +#define _DEFINE_DECIMAL_COMPOUND_ASSIGNMENT_INT(_Op1, _Op2, _T1, _T2) \ + inline _T1& _T1::operator _Op1(_T2 __rhs) \ + { \ + __setval(__getval() _Op2 __rhs); \ + return *this; \ + } + +#define _DEFINE_DECIMAL_COMPOUND_ASSIGNMENTS(_Op1, _Op2, _T1) \ + _DEFINE_DECIMAL_COMPOUND_ASSIGNMENT_DEC(_Op1, _Op2, _T1, decimal32) \ + _DEFINE_DECIMAL_COMPOUND_ASSIGNMENT_DEC(_Op1, _Op2, _T1, decimal64) \ + _DEFINE_DECIMAL_COMPOUND_ASSIGNMENT_DEC(_Op1, _Op2, _T1, decimal128) \ + _DEFINE_DECIMAL_COMPOUND_ASSIGNMENT_INT(_Op1, _Op2, _T1, int) \ + _DEFINE_DECIMAL_COMPOUND_ASSIGNMENT_INT(_Op1, _Op2, _T1, unsigned int) \ + _DEFINE_DECIMAL_COMPOUND_ASSIGNMENT_INT(_Op1, _Op2, _T1, long) \ + _DEFINE_DECIMAL_COMPOUND_ASSIGNMENT_INT(_Op1, _Op2, _T1, unsigned long)\ + _DEFINE_DECIMAL_COMPOUND_ASSIGNMENT_INT(_Op1, _Op2, _T1, long long) \ + _DEFINE_DECIMAL_COMPOUND_ASSIGNMENT_INT(_Op1, _Op2, _T1, unsigned long long) + + _DEFINE_DECIMAL_COMPOUND_ASSIGNMENTS(+=, +, decimal32) + _DEFINE_DECIMAL_COMPOUND_ASSIGNMENTS(-=, -, decimal32) + _DEFINE_DECIMAL_COMPOUND_ASSIGNMENTS(*=, *, decimal32) + _DEFINE_DECIMAL_COMPOUND_ASSIGNMENTS(/=, /, decimal32) + + _DEFINE_DECIMAL_COMPOUND_ASSIGNMENTS(+=, +, decimal64) + _DEFINE_DECIMAL_COMPOUND_ASSIGNMENTS(-=, -, decimal64) + _DEFINE_DECIMAL_COMPOUND_ASSIGNMENTS(*=, *, decimal64) + _DEFINE_DECIMAL_COMPOUND_ASSIGNMENTS(/=, /, decimal64) + + _DEFINE_DECIMAL_COMPOUND_ASSIGNMENTS(+=, +, decimal128) + _DEFINE_DECIMAL_COMPOUND_ASSIGNMENTS(-=, -, decimal128) + _DEFINE_DECIMAL_COMPOUND_ASSIGNMENTS(*=, *, decimal128) + _DEFINE_DECIMAL_COMPOUND_ASSIGNMENTS(/=, /, decimal128) + +#undef _DEFINE_DECIMAL_COMPOUND_ASSIGNMENT_DEC +#undef _DEFINE_DECIMAL_COMPOUND_ASSIGNMENT_INT +#undef _DEFINE_DECIMAL_COMPOUND_ASSIGNMENTS + + // Extension: Conversion to integral type. + + inline long long decimal32_to_long_long(decimal32 __d) + { return (long long)__d.__getval(); } + + inline long long decimal64_to_long_long(decimal64 __d) + { return (long long)__d.__getval(); } + + inline long long decimal128_to_long_long(decimal128 __d) + { return (long long)__d.__getval(); } + + inline long long decimal_to_long_long(decimal32 __d) + { return (long long)__d.__getval(); } + + inline long long decimal_to_long_long(decimal64 __d) + { return (long long)__d.__getval(); } + + inline long long decimal_to_long_long(decimal128 __d) + { return (long long)__d.__getval(); } + + // ISO/IEC TR 24733 3.2.5 Initialization from coefficient and exponent. + + static decimal32 make_decimal32(long long __coeff, int __exponent) + { + decimal32 __decexp = 1, __multiplier; + + if (__exponent < 0) + { + __multiplier = 1.E-1DF; + __exponent = -__exponent; + } + else + __multiplier = 1.E1DF; + + for (int __i = 0; __i < __exponent; ++__i) + __decexp *= __multiplier; + + return __coeff * __decexp; + } + + static decimal32 make_decimal32(unsigned long long __coeff, int __exponent) + { + decimal32 __decexp = 1, __multiplier; + + if (__exponent < 0) + { + __multiplier = 1.E-1DF; + __exponent = -__exponent; + } + else + __multiplier = 1.E1DF; + + for (int __i = 0; __i < __exponent; ++__i) + __decexp *= __multiplier; + + return __coeff * __decexp; + } + + static decimal64 make_decimal64(long long __coeff, int __exponent) + { + decimal64 __decexp = 1, __multiplier; + + if (__exponent < 0) + { + __multiplier = 1.E-1DD; + __exponent = -__exponent; + } + else + __multiplier = 1.E1DD; + + for (int __i = 0; __i < __exponent; ++__i) + __decexp *= __multiplier; + + return __coeff * __decexp; + } + + static decimal64 make_decimal64(unsigned long long __coeff, int __exponent) + { + decimal64 __decexp = 1, __multiplier; + + if (__exponent < 0) + { + __multiplier = 1.E-1DD; + __exponent = -__exponent; + } + else + __multiplier = 1.E1DD; + + for (int __i = 0; __i < __exponent; ++__i) + __decexp *= __multiplier; + + return __coeff * __decexp; + } + + static decimal128 make_decimal128(long long __coeff, int __exponent) + { + decimal128 __decexp = 1, __multiplier; + + if (__exponent < 0) + { + __multiplier = 1.E-1DL; + __exponent = -__exponent; + } + else + __multiplier = 1.E1DL; + + for (int __i = 0; __i < __exponent; ++__i) + __decexp *= __multiplier; + + return __coeff * __decexp; + } + + static decimal128 make_decimal128(unsigned long long __coeff, int __exponent) + { + decimal128 __decexp = 1, __multiplier; + + if (__exponent < 0) + { + __multiplier = 1.E-1DL; + __exponent = -__exponent; + } + else + __multiplier = 1.E1DL; + + for (int __i = 0; __i < __exponent; ++__i) + __decexp *= __multiplier; + + return __coeff * __decexp; + } + + // ISO/IEC TR 24733 3.2.6 Conversion to generic floating-point type. + + inline float decimal32_to_float(decimal32 __d) + { return (float)__d.__getval(); } + + inline float decimal64_to_float(decimal64 __d) + { return (float)__d.__getval(); } + + inline float decimal128_to_float(decimal128 __d) + { return (float)__d.__getval(); } + + inline float decimal_to_float(decimal32 __d) + { return (float)__d.__getval(); } + + inline float decimal_to_float(decimal64 __d) + { return (float)__d.__getval(); } + + inline float decimal_to_float(decimal128 __d) + { return (float)__d.__getval(); } + + inline double decimal32_to_double(decimal32 __d) + { return (double)__d.__getval(); } + + inline double decimal64_to_double(decimal64 __d) + { return (double)__d.__getval(); } + + inline double decimal128_to_double(decimal128 __d) + { return (double)__d.__getval(); } + + inline double decimal_to_double(decimal32 __d) + { return (double)__d.__getval(); } + + inline double decimal_to_double(decimal64 __d) + { return (double)__d.__getval(); } + + inline double decimal_to_double(decimal128 __d) + { return (double)__d.__getval(); } + + inline long double decimal32_to_long_double(decimal32 __d) + { return (long double)__d.__getval(); } + + inline long double decimal64_to_long_double(decimal64 __d) + { return (long double)__d.__getval(); } + + inline long double decimal128_to_long_double(decimal128 __d) + { return (long double)__d.__getval(); } + + inline long double decimal_to_long_double(decimal32 __d) + { return (long double)__d.__getval(); } + + inline long double decimal_to_long_double(decimal64 __d) + { return (long double)__d.__getval(); } + + inline long double decimal_to_long_double(decimal128 __d) + { return (long double)__d.__getval(); } + + // ISO/IEC TR 24733 3.2.7 Unary arithmetic operators. + +#define _DEFINE_DECIMAL_UNARY_OP(_Op, _Tp) \ + inline _Tp operator _Op(_Tp __rhs) \ + { \ + _Tp __tmp; \ + __tmp.__setval(_Op __rhs.__getval()); \ + return __tmp; \ + } + + _DEFINE_DECIMAL_UNARY_OP(+, decimal32) + _DEFINE_DECIMAL_UNARY_OP(+, decimal64) + _DEFINE_DECIMAL_UNARY_OP(+, decimal128) + _DEFINE_DECIMAL_UNARY_OP(-, decimal32) + _DEFINE_DECIMAL_UNARY_OP(-, decimal64) + _DEFINE_DECIMAL_UNARY_OP(-, decimal128) + +#undef _DEFINE_DECIMAL_UNARY_OP + + // ISO/IEC TR 24733 3.2.8 Binary arithmetic operators. + +#define _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(_Op, _T1, _T2, _T3) \ + inline _T1 operator _Op(_T2 __lhs, _T3 __rhs) \ + { \ + _T1 __retval; \ + __retval.__setval(__lhs.__getval() _Op __rhs.__getval()); \ + return __retval; \ + } + +#define _DEFINE_DECIMAL_BINARY_OP_BOTH(_Op, _T1, _T2, _T3) \ + inline _T1 operator _Op(_T2 __lhs, _T3 __rhs) \ + { \ + _T1 __retval; \ + __retval.__setval(__lhs.__getval() _Op __rhs.__getval()); \ + return __retval; \ + } + +#define _DEFINE_DECIMAL_BINARY_OP_LHS(_Op, _T1, _T2) \ + inline _T1 operator _Op(_T1 __lhs, _T2 __rhs) \ + { \ + _T1 __retval; \ + __retval.__setval(__lhs.__getval() _Op __rhs); \ + return __retval; \ + } + +#define _DEFINE_DECIMAL_BINARY_OP_RHS(_Op, _T1, _T2) \ + inline _T1 operator _Op(_T2 __lhs, _T1 __rhs) \ + { \ + _T1 __retval; \ + __retval.__setval(__lhs _Op __rhs.__getval()); \ + return __retval; \ + } + +#define _DEFINE_DECIMAL_BINARY_OP_WITH_INT(_Op, _T1) \ + _DEFINE_DECIMAL_BINARY_OP_LHS(_Op, _T1, int); \ + _DEFINE_DECIMAL_BINARY_OP_LHS(_Op, _T1, unsigned int); \ + _DEFINE_DECIMAL_BINARY_OP_LHS(_Op, _T1, long); \ + _DEFINE_DECIMAL_BINARY_OP_LHS(_Op, _T1, unsigned long); \ + _DEFINE_DECIMAL_BINARY_OP_LHS(_Op, _T1, long long); \ + _DEFINE_DECIMAL_BINARY_OP_LHS(_Op, _T1, unsigned long long); \ + _DEFINE_DECIMAL_BINARY_OP_RHS(_Op, _T1, int); \ + _DEFINE_DECIMAL_BINARY_OP_RHS(_Op, _T1, unsigned int); \ + _DEFINE_DECIMAL_BINARY_OP_RHS(_Op, _T1, long); \ + _DEFINE_DECIMAL_BINARY_OP_RHS(_Op, _T1, unsigned long); \ + _DEFINE_DECIMAL_BINARY_OP_RHS(_Op, _T1, long long); \ + _DEFINE_DECIMAL_BINARY_OP_RHS(_Op, _T1, unsigned long long); \ + + _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(+, decimal32, decimal32, decimal32) + _DEFINE_DECIMAL_BINARY_OP_WITH_INT(+, decimal32) + _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(+, decimal64, decimal32, decimal64) + _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(+, decimal64, decimal64, decimal32) + _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(+, decimal64, decimal64, decimal64) + _DEFINE_DECIMAL_BINARY_OP_WITH_INT(+, decimal64) + _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(+, decimal128, decimal32, decimal128) + _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(+, decimal128, decimal64, decimal128) + _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(+, decimal128, decimal128, decimal32) + _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(+, decimal128, decimal128, decimal64) + _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(+, decimal128, decimal128, decimal128) + _DEFINE_DECIMAL_BINARY_OP_WITH_INT(+, decimal128) + + _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(-, decimal32, decimal32, decimal32) + _DEFINE_DECIMAL_BINARY_OP_WITH_INT(-, decimal32) + _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(-, decimal64, decimal32, decimal64) + _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(-, decimal64, decimal64, decimal32) + _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(-, decimal64, decimal64, decimal64) + _DEFINE_DECIMAL_BINARY_OP_WITH_INT(-, decimal64) + _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(-, decimal128, decimal32, decimal128) + _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(-, decimal128, decimal64, decimal128) + _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(-, decimal128, decimal128, decimal32) + _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(-, decimal128, decimal128, decimal64) + _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(-, decimal128, decimal128, decimal128) + _DEFINE_DECIMAL_BINARY_OP_WITH_INT(-, decimal128) + + _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(*, decimal32, decimal32, decimal32) + _DEFINE_DECIMAL_BINARY_OP_WITH_INT(*, decimal32) + _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(*, decimal64, decimal32, decimal64) + _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(*, decimal64, decimal64, decimal32) + _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(*, decimal64, decimal64, decimal64) + _DEFINE_DECIMAL_BINARY_OP_WITH_INT(*, decimal64) + _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(*, decimal128, decimal32, decimal128) + _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(*, decimal128, decimal64, decimal128) + _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(*, decimal128, decimal128, decimal32) + _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(*, decimal128, decimal128, decimal64) + _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(*, decimal128, decimal128, decimal128) + _DEFINE_DECIMAL_BINARY_OP_WITH_INT(*, decimal128) + + _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(/, decimal32, decimal32, decimal32) + _DEFINE_DECIMAL_BINARY_OP_WITH_INT(/, decimal32) + _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(/, decimal64, decimal32, decimal64) + _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(/, decimal64, decimal64, decimal32) + _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(/, decimal64, decimal64, decimal64) + _DEFINE_DECIMAL_BINARY_OP_WITH_INT(/, decimal64) + _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(/, decimal128, decimal32, decimal128) + _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(/, decimal128, decimal64, decimal128) + _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(/, decimal128, decimal128, decimal32) + _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(/, decimal128, decimal128, decimal64) + _DEFINE_DECIMAL_BINARY_OP_WITH_DEC(/, decimal128, decimal128, decimal128) + _DEFINE_DECIMAL_BINARY_OP_WITH_INT(/, decimal128) + +#undef _DEFINE_DECIMAL_BINARY_OP_WITH_DEC +#undef _DEFINE_DECIMAL_BINARY_OP_BOTH +#undef _DEFINE_DECIMAL_BINARY_OP_LHS +#undef _DEFINE_DECIMAL_BINARY_OP_RHS +#undef _DEFINE_DECIMAL_BINARY_OP_WITH_INT + + // ISO/IEC TR 24733 3.2.9 Comparison operators. + +#define _DEFINE_DECIMAL_COMPARISON_BOTH(_Op, _T1, _T2) \ + inline bool operator _Op(_T1 __lhs, _T2 __rhs) \ + { return __lhs.__getval() _Op __rhs.__getval(); } + +#define _DEFINE_DECIMAL_COMPARISON_LHS(_Op, _T1, _T2) \ + inline bool operator _Op(_T1 __lhs, _T2 __rhs) \ + { return __lhs.__getval() _Op __rhs; } + +#define _DEFINE_DECIMAL_COMPARISON_RHS(_Op, _T1, _T2) \ + inline bool operator _Op(_T1 __lhs, _T2 __rhs) \ + { return __lhs _Op __rhs.__getval(); } + +#define _DEFINE_DECIMAL_COMPARISONS(_Op, _Tp) \ + _DEFINE_DECIMAL_COMPARISON_BOTH(_Op, _Tp, decimal32) \ + _DEFINE_DECIMAL_COMPARISON_BOTH(_Op, _Tp, decimal64) \ + _DEFINE_DECIMAL_COMPARISON_BOTH(_Op, _Tp, decimal128) \ + _DEFINE_DECIMAL_COMPARISON_LHS(_Op, _Tp, int) \ + _DEFINE_DECIMAL_COMPARISON_LHS(_Op, _Tp, unsigned int) \ + _DEFINE_DECIMAL_COMPARISON_LHS(_Op, _Tp, long) \ + _DEFINE_DECIMAL_COMPARISON_LHS(_Op, _Tp, unsigned long) \ + _DEFINE_DECIMAL_COMPARISON_LHS(_Op, _Tp, long long) \ + _DEFINE_DECIMAL_COMPARISON_LHS(_Op, _Tp, unsigned long long) \ + _DEFINE_DECIMAL_COMPARISON_RHS(_Op, int, _Tp) \ + _DEFINE_DECIMAL_COMPARISON_RHS(_Op, unsigned int, _Tp) \ + _DEFINE_DECIMAL_COMPARISON_RHS(_Op, long, _Tp) \ + _DEFINE_DECIMAL_COMPARISON_RHS(_Op, unsigned long, _Tp) \ + _DEFINE_DECIMAL_COMPARISON_RHS(_Op, long long, _Tp) \ + _DEFINE_DECIMAL_COMPARISON_RHS(_Op, unsigned long long, _Tp) + + _DEFINE_DECIMAL_COMPARISONS(==, decimal32) + _DEFINE_DECIMAL_COMPARISONS(==, decimal64) + _DEFINE_DECIMAL_COMPARISONS(==, decimal128) + _DEFINE_DECIMAL_COMPARISONS(!=, decimal32) + _DEFINE_DECIMAL_COMPARISONS(!=, decimal64) + _DEFINE_DECIMAL_COMPARISONS(!=, decimal128) + _DEFINE_DECIMAL_COMPARISONS(<, decimal32) + _DEFINE_DECIMAL_COMPARISONS(<, decimal64) + _DEFINE_DECIMAL_COMPARISONS(<, decimal128) + _DEFINE_DECIMAL_COMPARISONS(<=, decimal32) + _DEFINE_DECIMAL_COMPARISONS(<=, decimal64) + _DEFINE_DECIMAL_COMPARISONS(<=, decimal128) + _DEFINE_DECIMAL_COMPARISONS(>, decimal32) + _DEFINE_DECIMAL_COMPARISONS(>, decimal64) + _DEFINE_DECIMAL_COMPARISONS(>, decimal128) + _DEFINE_DECIMAL_COMPARISONS(>=, decimal32) + _DEFINE_DECIMAL_COMPARISONS(>=, decimal64) + _DEFINE_DECIMAL_COMPARISONS(>=, decimal128) + +#undef _DEFINE_DECIMAL_COMPARISON_BOTH +#undef _DEFINE_DECIMAL_COMPARISON_LHS +#undef _DEFINE_DECIMAL_COMPARISON_RHS +#undef _DEFINE_DECIMAL_COMPARISONS + _GLIBCXX_END_NAMESPACE_VERSION +} // namespace decimal +} // namespace std + +#endif /* _GLIBCXX_DECIMAL_IMPL */ diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/deque b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/deque new file mode 100755 index 0000000..816c873 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/deque @@ -0,0 +1,76 @@ +// -*- C++ -*- + +// Copyright (C) 2001-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/* + * + * Copyright (c) 1994 + * Hewlett-Packard Company + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Hewlett-Packard Company makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + * + * + * Copyright (c) 1997 + * Silicon Graphics Computer Systems, Inc. + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Silicon Graphics makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + */ + +/** @file include/deque + * This is a Standard C++ Library header. + */ + +#ifndef _GLIBCXX_DEQUE +#define _GLIBCXX_DEQUE 1 + +#pragma GCC system_header + +#include +#include +#include +#include +#include +#include +#include + +#ifdef _GLIBCXX_DEBUG +# include +#endif + +#ifdef _GLIBCXX_PROFILE +# include +#endif + +#endif /* _GLIBCXX_DEQUE */ diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/exception b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/exception new file mode 100755 index 0000000..2d787d0 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/exception @@ -0,0 +1,166 @@ +// Exception Handling support header for -*- C++ -*- + +// Copyright (C) 1995-2014 Free Software Foundation, Inc. +// +// This file is part of GCC. +// +// GCC is free software; you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation; either version 3, or (at your option) +// any later version. +// +// GCC is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file exception + * This is a Standard C++ Library header. + */ + +#ifndef __EXCEPTION__ +#define __EXCEPTION__ + +#pragma GCC system_header + +#pragma GCC visibility push(default) + +#include +#include + +extern "C++" { + +namespace std +{ + /** + * @defgroup exceptions Exceptions + * @ingroup diagnostics + * + * Classes and functions for reporting errors via exception classes. + * @{ + */ + + /** + * @brief Base class for all library exceptions. + * + * This is the base class for all exceptions thrown by the standard + * library, and by certain language expressions. You are free to derive + * your own %exception classes, or use a different hierarchy, or to + * throw non-class data (e.g., fundamental types). + */ + class exception + { + public: + exception() _GLIBCXX_USE_NOEXCEPT { } + virtual ~exception() _GLIBCXX_USE_NOEXCEPT; + + /** Returns a C-style character string describing the general cause + * of the current error. */ + virtual const char* what() const _GLIBCXX_USE_NOEXCEPT; + }; + + /** If an %exception is thrown which is not listed in a function's + * %exception specification, one of these may be thrown. */ + class bad_exception : public exception + { + public: + bad_exception() _GLIBCXX_USE_NOEXCEPT { } + + // This declaration is not useless: + // http://gcc.gnu.org/onlinedocs/gcc-3.0.2/gcc_6.html#SEC118 + virtual ~bad_exception() _GLIBCXX_USE_NOEXCEPT; + + // See comment in eh_exception.cc. + virtual const char* what() const _GLIBCXX_USE_NOEXCEPT; + }; + + /// If you write a replacement %terminate handler, it must be of this type. + typedef void (*terminate_handler) (); + + /// If you write a replacement %unexpected handler, it must be of this type. + typedef void (*unexpected_handler) (); + + /// Takes a new handler function as an argument, returns the old function. + terminate_handler set_terminate(terminate_handler) _GLIBCXX_USE_NOEXCEPT; + +#if __cplusplus >= 201103L + /// Return the current terminate handler. + terminate_handler get_terminate() noexcept; +#endif + + /** The runtime will call this function if %exception handling must be + * abandoned for any reason. It can also be called by the user. */ + void terminate() _GLIBCXX_USE_NOEXCEPT __attribute__ ((__noreturn__)); + + /// Takes a new handler function as an argument, returns the old function. + unexpected_handler set_unexpected(unexpected_handler) _GLIBCXX_USE_NOEXCEPT; + +#if __cplusplus >= 201103L + /// Return the current unexpected handler. + unexpected_handler get_unexpected() noexcept; +#endif + + /** The runtime will call this function if an %exception is thrown which + * violates the function's %exception specification. */ + void unexpected() __attribute__ ((__noreturn__)); + + /** [18.6.4]/1: 'Returns true after completing evaluation of a + * throw-expression until either completing initialization of the + * exception-declaration in the matching handler or entering @c unexpected() + * due to the throw; or after entering @c terminate() for any reason + * other than an explicit call to @c terminate(). [Note: This includes + * stack unwinding [15.2]. end note]' + * + * 2: 'When @c uncaught_exception() is true, throwing an + * %exception can result in a call of @c terminate() + * (15.5.1).' + */ + bool uncaught_exception() _GLIBCXX_USE_NOEXCEPT __attribute__ ((__pure__)); + + // @} group exceptions +} // namespace std + +namespace __gnu_cxx +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /** + * @brief A replacement for the standard terminate_handler which + * prints more information about the terminating exception (if any) + * on stderr. + * + * @ingroup exceptions + * + * Call + * @code + * std::set_terminate(__gnu_cxx::__verbose_terminate_handler) + * @endcode + * to use. For more info, see + * http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt02ch06s02.html + * + * In 3.4 and later, this is on by default. + */ + void __verbose_terminate_handler(); + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +} // extern "C++" + +#pragma GCC visibility pop + +#if (__cplusplus >= 201103L) && (ATOMIC_INT_LOCK_FREE > 1) +#include +#include +#endif + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/experimental/optional b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/experimental/optional new file mode 100755 index 0000000..2a3f29d --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/experimental/optional @@ -0,0 +1,823 @@ +// -*- C++ -*- + +// Copyright (C) 2013-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file experimental/optional + * This is a TS C++ Library header. + */ + +#ifndef _GLIBCXX_EXPERIMENTAL_OPTIONAL +#define _GLIBCXX_EXPERIMENTAL_OPTIONAL 1 + +/** + * @defgroup experimental Experimental + * + * Components specified by various Technical Specifications. + */ + +#if __cplusplus <= 201103L +# include +#else + +#include +#include +#include +#include +#include +#include +#include +#include + +namespace std _GLIBCXX_VISIBILITY(default) +{ +namespace experimental +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /** + * @defgroup optional Optional values + * @ingroup experimental + * + * Class template for optional values and surrounding facilities, as + * described in n3793 "A proposal to add a utility class to represent + * optional objects (Revision 5)". + * + * @{ + */ + + // All subsequent [X.Y.n] references are against n3793. + + // [X.Y.4] + template + class optional; + + // [X.Y.5] + /// Tag type for in-place construction. + struct in_place_t { }; + + /// Tag for in-place construction. + constexpr in_place_t in_place { }; + + // [X.Y.6] + /// Tag type to disengage optional objects. + struct nullopt_t + { + // Do not user-declare default constructor at all for + // optional_value = {} syntax to work. + // nullopt_t() = delete; + + // Used for constructing nullopt. + enum class _Construct { _Token }; + + // Must be constexpr for nullopt_t to be literal. + explicit constexpr nullopt_t(_Construct) { } + }; + + // [X.Y.6] + /// Tag to disengage optional objects. + constexpr nullopt_t nullopt { nullopt_t::_Construct::_Token }; + + // [X.Y.7] + /** + * @brief Exception class thrown when a disengaged optional object is + * dereferenced. + * @ingroup exceptions + */ + class bad_optional_access : public logic_error + { + public: + // XXX Should not be inline + explicit bad_optional_access(const string& __arg) : logic_error(__arg) { } + + explicit bad_optional_access(const char* __arg) : logic_error(__arg) { } + + virtual ~bad_optional_access() noexcept = default; + }; + + void + __throw_bad_optional_access(const char*) + __attribute__((__noreturn__)); + + // XXX Does not belong here. + inline void + __throw_bad_optional_access(const char* __s) + { _GLIBCXX_THROW_OR_ABORT(bad_optional_access(__s)); } + + template + struct _Has_addressof_impl : std::false_type { }; + + template + struct _Has_addressof_impl<_Tp, + decltype( std::declval().operator&(), void() )> + : std::true_type { }; + + /** + * @brief Trait that detects the presence of an overloaded unary operator&. + * + * Practically speaking this detects the presence of such an operator when + * called on a const-qualified lvalue (i.e. + * declval<_Tp * const&>().operator&()). + */ + template + struct _Has_addressof : _Has_addressof_impl<_Tp>::type { }; + + /** + * @brief An overload that attempts to take the address of an lvalue as a + * constant expression. Falls back to __addressof in the presence of an + * overloaded addressof operator (unary operator&), in which case the call + * will not be a constant expression. + */ + template::value, + int>::type...> + constexpr _Tp* __constexpr_addressof(_Tp& __t) + { return &__t; } + + /** + * @brief Fallback overload that defers to __addressof. + */ + template::value, + int>::type...> + inline _Tp* __constexpr_addressof(_Tp& __t) + { return std::__addressof(__t); } + + /** + * @brief Class template that holds the necessary state for @ref optional + * and that has the responsibility for construction and the special members. + * + * Such a separate base class template is necessary in order to + * conditionally enable the special members (e.g. copy/move constructors). + * Note that this means that @ref _Optional_base implements the + * functionality for copy and move assignment, but not for converting + * assignment. + * + * @see optional, _Enable_special_members + */ + template::value> + class _Optional_base + { + private: + // Remove const to avoid prohibition of reusing object storage for + // const-qualified types in [3.8/9]. This is strictly internal + // and even optional itself is oblivious to it. + using _Stored_type = typename remove_const<_Tp>::type; + + public: + // [X.Y.4.1] Constructors. + + // Constructors for disengaged optionals. + constexpr _Optional_base() noexcept + : _M_empty{} { } + + constexpr _Optional_base(nullopt_t) noexcept + : _Optional_base{} { } + + // Constructors for engaged optionals. + constexpr _Optional_base(const _Tp& __t) + : _M_payload(__t), _M_engaged(true) { } + + constexpr _Optional_base(_Tp&& __t) + : _M_payload(std::move(__t)), _M_engaged(true) { } + + template + constexpr explicit _Optional_base(in_place_t, _Args&&... __args) + : _M_payload(std::forward<_Args>(__args)...), _M_engaged(true) { } + + template&, + _Args&&...>::value, + int>::type...> + constexpr explicit _Optional_base(in_place_t, + initializer_list<_Up> __il, + _Args&&... __args) + : _M_payload(__il, std::forward<_Args>(__args)...), + _M_engaged(true) { } + + // Copy and move constructors. + _Optional_base(const _Optional_base& __other) + { + if (__other._M_engaged) + this->_M_construct(__other._M_get()); + } + + _Optional_base(_Optional_base&& __other) + noexcept(is_nothrow_move_constructible<_Tp>()) + { + if (__other._M_engaged) + this->_M_construct(std::move(__other._M_get())); + } + + // [X.Y.4.3] (partly) Assignment. + _Optional_base& + operator=(const _Optional_base& __other) + { + if (this->_M_engaged && __other._M_engaged) + this->_M_get() = __other._M_get(); + else + { + if (__other._M_engaged) + this->_M_construct(__other._M_get()); + else + this->_M_reset(); + } + + return *this; + } + + _Optional_base& + operator=(_Optional_base&& __other) + noexcept(__and_, + is_nothrow_move_assignable<_Tp>>()) + { + if (this->_M_engaged && __other._M_engaged) + this->_M_get() = std::move(__other._M_get()); + else + { + if (__other._M_engaged) + this->_M_construct(std::move(__other._M_get())); + else + this->_M_reset(); + } + return *this; + } + + // [X.Y.4.2] Destructor. + ~_Optional_base() + { + if (this->_M_engaged) + this->_M_payload.~_Stored_type(); + } + + // The following functionality is also needed by optional, hence the + // protected accessibility. + protected: + constexpr bool _M_is_engaged() const noexcept + { return this->_M_engaged; } + + // The _M_get operations have _M_engaged as a precondition. + _Tp& + _M_get() noexcept + { return _M_payload; } + + constexpr const _Tp& + _M_get() const noexcept + { return _M_payload; } + + // The _M_construct operation has !_M_engaged as a precondition + // while _M_destruct has _M_engaged as a precondition. + template + void + _M_construct(_Args&&... __args) + noexcept(is_nothrow_constructible<_Stored_type, _Args...>()) + { + ::new (std::__addressof(this->_M_payload)) + _Stored_type(std::forward<_Args>(__args)...); + this->_M_engaged = true; + } + + void + _M_destruct() + { + this->_M_engaged = false; + this->_M_payload.~_Stored_type(); + } + + // _M_reset is a 'safe' operation with no precondition. + void + _M_reset() + { + if (this->_M_engaged) + this->_M_destruct(); + } + + private: + struct _Empty_byte { }; + union { + _Empty_byte _M_empty; + _Stored_type _M_payload; + }; + bool _M_engaged = false; + }; + + /// Partial specialization that is exactly identical to the primary template + /// save for not providing a destructor, to fulfill triviality requirements. + template + class _Optional_base<_Tp, false> + { + private: + using _Stored_type = typename remove_const<_Tp>::type; + + public: + constexpr _Optional_base() noexcept + : _M_empty{} { } + + constexpr _Optional_base(nullopt_t) noexcept + : _Optional_base{} { } + + constexpr _Optional_base(const _Tp& __t) + : _M_payload(__t), _M_engaged(true) { } + + constexpr _Optional_base(_Tp&& __t) + : _M_payload(std::move(__t)), _M_engaged(true) { } + + template + constexpr explicit _Optional_base(in_place_t, _Args&&... __args) + : _M_payload(std::forward<_Args>(__args)...), _M_engaged(true) { } + + template&, + _Args&&...>::value, + int>::type...> + constexpr explicit _Optional_base(in_place_t, + initializer_list<_Up> __il, + _Args&&... __args) + : _M_payload(__il, std::forward<_Args>(__args)...), + _M_engaged(true) { } + + _Optional_base(const _Optional_base& __other) + { + if (__other._M_engaged) + this->_M_construct(__other._M_get()); + } + + _Optional_base(_Optional_base&& __other) + noexcept(is_nothrow_move_constructible<_Tp>()) + { + if (__other._M_engaged) + this->_M_construct(std::move(__other._M_get())); + } + + _Optional_base& + operator=(const _Optional_base& __other) + { + if (this->_M_engaged && __other._M_engaged) + this->_M_get() = __other._M_get(); + else + { + if (__other._M_engaged) + this->_M_construct(__other._M_get()); + else + this->_M_reset(); + } + return *this; + } + + _Optional_base& + operator=(_Optional_base&& __other) + noexcept(__and_, + is_nothrow_move_assignable<_Tp>>()) + { + if (this->_M_engaged && __other._M_engaged) + this->_M_get() = std::move(__other._M_get()); + else + { + if (__other._M_engaged) + this->_M_construct(std::move(__other._M_get())); + else + this->_M_reset(); + } + return *this; + } + + // Sole difference + // ~_Optional_base() noexcept = default; + + protected: + constexpr bool _M_is_engaged() const noexcept + { return this->_M_engaged; } + + _Tp& + _M_get() noexcept + { return _M_payload; } + + constexpr const _Tp& + _M_get() const noexcept + { return _M_payload; } + + template + void + _M_construct(_Args&&... __args) + noexcept(is_nothrow_constructible<_Stored_type, _Args...>()) + { + ::new (std::__addressof(this->_M_payload)) + _Stored_type(std::forward<_Args>(__args)...); + this->_M_engaged = true; + } + + void + _M_destruct() + { + this->_M_engaged = false; + this->_M_payload.~_Stored_type(); + } + + void + _M_reset() + { + if (this->_M_engaged) + this->_M_destruct(); + } + + private: + struct _Empty_byte { }; + union + { + _Empty_byte _M_empty; + _Stored_type _M_payload; + }; + bool _M_engaged = false; + }; + + /** + * @brief Class template for optional values. + */ + template + class optional + : private _Optional_base<_Tp>, + private _Enable_copy_move< + // Copy constructor. + is_copy_constructible<_Tp>::value, + // Copy assignment. + __and_, is_copy_assignable<_Tp>>::value, + // Move constructor. + is_move_constructible<_Tp>::value, + // Move assignment. + __and_, is_move_assignable<_Tp>>::value, + // Unique tag type. + optional<_Tp>> + { + static_assert(__and_<__not_::type, + nullopt_t>>, + __not_::type, + in_place_t>>, + __not_>>(), + "Invalid instantiation of optional"); + + private: + using _Base = _Optional_base<_Tp>; + + public: + using value_type = _Tp; + + // _Optional_base has the responsibility for construction. + using _Base::_Base; + + // [X.Y.4.3] (partly) Assignment. + optional& + operator=(nullopt_t) noexcept + { + this->_M_reset(); + return *this; + } + + template + typename enable_if< + is_same<_Tp, typename decay<_Up>::type>::value, + optional& + >::type + operator=(_Up&& __u) + { + static_assert(__and_, + is_assignable<_Tp&, _Up>>(), + "Cannot assign to value type from argument"); + + if (this->_M_is_engaged()) + this->_M_get() = std::forward<_Up>(__u); + else + this->_M_construct(std::forward<_Up>(__u)); + + return *this; + } + + template + void + emplace(_Args&&... __args) + { + static_assert(is_constructible<_Tp, _Args&&...>(), + "Cannot emplace value type from arguments"); + + this->_M_reset(); + this->_M_construct(std::forward<_Args>(__args)...); + } + + template + typename enable_if< + is_constructible<_Tp, + initializer_list<_Up>&, + _Args&&...>::value + >::type + emplace(initializer_list<_Up> __il, _Args&&... __args) + { + this->_M_reset(); + this->_M_construct(__il, std::forward<_Args>(__args)...); + } + + // [X.Y.4.2] Destructor is implicit, implemented in _Optional_base. + + // [X.Y.4.4] Swap. + void + swap(optional& __other) + noexcept(is_nothrow_move_constructible<_Tp>() + && noexcept(swap(declval<_Tp&>(), declval<_Tp&>()))) + { + using std::swap; + + if (this->_M_is_engaged() && __other._M_is_engaged()) + swap(this->_M_get(), __other._M_get()); + else if (this->_M_is_engaged()) + { + __other._M_construct(std::move(this->_M_get())); + this->_M_destruct(); + } + else if (__other._M_is_engaged()) + { + this->_M_construct(std::move(__other._M_get())); + __other._M_destruct(); + } + } + + // [X.Y.4.5] Observers. + constexpr const _Tp* + operator->() const + { return __constexpr_addressof(this->_M_get()); } + + _Tp* + operator->() + { return std::__addressof(this->_M_get()); } + + constexpr const _Tp& + operator*() const + { return this->_M_get(); } + + _Tp& + operator*() + { return this->_M_get(); } + + constexpr explicit operator bool() const noexcept + { return this->_M_is_engaged(); } + + constexpr const _Tp& + value() const + { + return this->_M_is_engaged() + ? this->_M_get() + : (__throw_bad_optional_access("Attempt to access value of a " + "disengaged optional object"), + this->_M_get()); + } + + _Tp& + value() + { + if (this->_M_is_engaged()) + return this->_M_get(); + + __throw_bad_optional_access("Attempt to access value of a " + "disengaged optional object"); + } + + template + constexpr _Tp + value_or(_Up&& __u) const& + { + static_assert(__and_, + is_convertible<_Up&&, _Tp>>(), + "Cannot return value"); + + return this->_M_is_engaged() + ? this->_M_get() + : static_cast<_Tp>(std::forward<_Up>(__u)); + } + + template + _Tp + value_or(_Up&& __u) && + { + static_assert(__and_, + is_convertible<_Up&&, _Tp>>(), + "Cannot return value" ); + + return this->_M_is_engaged() + ? std::move(this->_M_get()) + : static_cast<_Tp>(std::forward<_Up>(__u)); + } + }; + + // [X.Y.8] Comparisons between optional values. + template + constexpr bool + operator==(const optional<_Tp>& __lhs, const optional<_Tp>& __rhs) + { + return static_cast(__lhs) == static_cast(__rhs) + && (!__lhs || *__lhs == *__rhs); + } + + template + constexpr bool + operator!=(const optional<_Tp>& __lhs, const optional<_Tp>& __rhs) + { return !(__lhs == __rhs); } + + template + constexpr bool + operator<(const optional<_Tp>& __lhs, const optional<_Tp>& __rhs) + { + return static_cast(__rhs) && (!__lhs || *__lhs < *__rhs); + } + + template + constexpr bool + operator>(const optional<_Tp>& __lhs, const optional<_Tp>& __rhs) + { return __rhs < __lhs; } + + template + constexpr bool + operator<=(const optional<_Tp>& __lhs, const optional<_Tp>& __rhs) + { return !(__rhs < __lhs); } + + template + constexpr bool + operator>=(const optional<_Tp>& __lhs, const optional<_Tp>& __rhs) + { return !(__lhs < __rhs); } + + // [X.Y.9] Comparisons with nullopt. + template + constexpr bool + operator==(const optional<_Tp>& __lhs, nullopt_t) noexcept + { return !__lhs; } + + template + constexpr bool + operator==(nullopt_t, const optional<_Tp>& __rhs) noexcept + { return !__rhs; } + + template + constexpr bool + operator!=(const optional<_Tp>& __lhs, nullopt_t) noexcept + { return static_cast(__lhs); } + + template + constexpr bool + operator!=(nullopt_t, const optional<_Tp>& __rhs) noexcept + { return static_cast(__rhs); } + + template + constexpr bool + operator<(const optional<_Tp>& /* __lhs */, nullopt_t) noexcept + { return false; } + + template + constexpr bool + operator<(nullopt_t, const optional<_Tp>& __rhs) noexcept + { return static_cast(__rhs); } + + template + constexpr bool + operator>(const optional<_Tp>& __lhs, nullopt_t) noexcept + { return static_cast(__lhs); } + + template + constexpr bool + operator>(nullopt_t, const optional<_Tp>& /* __rhs */) noexcept + { return false; } + + template + constexpr bool + operator<=(const optional<_Tp>& __lhs, nullopt_t) noexcept + { return !__lhs; } + + template + constexpr bool + operator<=(nullopt_t, const optional<_Tp>& /* __rhs */) noexcept + { return true; } + + template + constexpr bool + operator>=(const optional<_Tp>& /* __lhs */, nullopt_t) noexcept + { return true; } + + template + constexpr bool + operator>=(nullopt_t, const optional<_Tp>& __rhs) noexcept + { return !__rhs; } + + // [X.Y.10] Comparisons with value type. + template + constexpr bool + operator==(const optional<_Tp>& __lhs, const _Tp& __rhs) + { return __lhs && *__lhs == __rhs; } + + template + constexpr bool + operator==(const _Tp& __lhs, const optional<_Tp>& __rhs) + { return __rhs && __lhs == *__rhs; } + + template + constexpr bool + operator!=(const optional<_Tp>& __lhs, _Tp const& __rhs) + { return !__lhs || !(*__lhs == __rhs); } + + template + constexpr bool + operator!=(const _Tp& __lhs, const optional<_Tp>& __rhs) + { return !__rhs || !(__lhs == *__rhs); } + + template + constexpr bool + operator<(const optional<_Tp>& __lhs, const _Tp& __rhs) + { return !__lhs || *__lhs < __rhs; } + + template + constexpr bool + operator<(const _Tp& __lhs, const optional<_Tp>& __rhs) + { return __rhs && __lhs < *__rhs; } + + template + constexpr bool + operator>(const optional<_Tp>& __lhs, const _Tp& __rhs) + { return __lhs && __rhs < *__lhs; } + + template + constexpr bool + operator>(const _Tp& __lhs, const optional<_Tp>& __rhs) + { return !__rhs || *__rhs < __lhs; } + + template + constexpr bool + operator<=(const optional<_Tp>& __lhs, const _Tp& __rhs) + { return !__lhs || !(__rhs < *__lhs); } + + template + constexpr bool + operator<=(const _Tp& __lhs, const optional<_Tp>& __rhs) + { return __rhs && !(*__rhs < __lhs); } + + template + constexpr bool + operator>=(const optional<_Tp>& __lhs, const _Tp& __rhs) + { return __lhs && !(*__lhs < __rhs); } + + template + constexpr bool + operator>=(const _Tp& __lhs, const optional<_Tp>& __rhs) + { return !__rhs || !(__lhs < *__rhs); } + + // [X.Y.11] + template + inline void + swap(optional<_Tp>& __lhs, optional<_Tp>& __rhs) + noexcept(noexcept(__lhs.swap(__rhs))) + { __lhs.swap(__rhs); } + + template + constexpr optional::type> + make_optional(_Tp&& __t) + { return optional::type> { std::forward<_Tp>(__t) }; } + + // @} group optional +_GLIBCXX_END_NAMESPACE_VERSION +} + + // [X.Y.12] + template + struct hash> + { + using result_type = size_t; + using argument_type = experimental::optional<_Tp>; + + size_t + operator()(const experimental::optional<_Tp>& __t) const + noexcept(noexcept(hash<_Tp> {}(*__t))) + { + // We pick an arbitrary hash for disengaged optionals which hopefully + // usual values of _Tp won't typically hash to. + constexpr size_t __magic_disengaged_hash = static_cast(-3333); + return __t ? hash<_Tp> {}(*__t) : __magic_disengaged_hash; + } + }; +} + +#endif // C++14 + +#endif // _GLIBCXX_EXPERIMENTAL_OPTIONAL diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/experimental/string_view b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/experimental/string_view new file mode 100755 index 0000000..49f46af --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/experimental/string_view @@ -0,0 +1,694 @@ +// Components for manipulating non-owning sequences of characters -*- C++ -*- + +// Copyright (C) 2013-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file experimental/string_view + * This is a Standard C++ Library header. + */ + +// +// N3762 basic_string_view library +// + +#ifndef _GLIBCXX_EXPERIMENTAL_STRING_VIEW +#define _GLIBCXX_EXPERIMENTAL_STRING_VIEW 1 + +#pragma GCC system_header + +#if __cplusplus <= 201103L +# include +#else + +#include +#include + +namespace std _GLIBCXX_VISIBILITY(default) +{ +namespace experimental +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /** + * @class basic_string_view + * @brief A non-owning reference to a string. + * + * @ingroup strings + * @ingroup sequences + * + * @tparam _CharT Type of character + * @tparam _Traits Traits for character type, defaults to + * char_traits<_CharT>. + * + * A basic_string_view looks like this: + * + * @code + * _CharT* _M_str + * size_t _M_len + * @endcode + */ + template> + class basic_string_view + { + public: + + // types + using traits_type = _Traits; + using value_type = _CharT; + using pointer = const _CharT*; + using const_pointer = const _CharT*; + using reference = const _CharT&; + using const_reference = const _CharT&; + using const_iterator = const _CharT*; + using iterator = const_iterator; + using const_reverse_iterator = std::reverse_iterator; + using reverse_iterator = const_reverse_iterator; + using size_type = size_t; + using difference_type = ptrdiff_t; + static constexpr size_type npos = size_type(-1); + + // [string.view.cons], construct/copy + + constexpr + basic_string_view() noexcept + : _M_len{0}, _M_str{nullptr} + { } + + constexpr basic_string_view(const basic_string_view&) noexcept = default; + + template + basic_string_view(const basic_string<_CharT, _Traits, + _Allocator>& __str) noexcept + : _M_len{__str.length()}, _M_str{__str.data()} + { } + + constexpr basic_string_view(const _CharT* __str) + : _M_len{__str == nullptr ? 0 : traits_type::length(__str)}, + _M_str{__str} + { } + + constexpr basic_string_view(const _CharT* __str, size_type __len) + : _M_len{__len}, + _M_str{__str} + { } + + basic_string_view& + operator=(const basic_string_view&) noexcept = default; + + // [string.view.iterators], iterators + + constexpr const_iterator + begin() const noexcept + { return this->_M_str; } + + constexpr const_iterator + end() const noexcept + { return this->_M_str + this->_M_len; } + + constexpr const_iterator + cbegin() const noexcept + { return this->_M_str; } + + constexpr const_iterator + cend() const noexcept + { return this->_M_str + this->_M_len; } + + const_reverse_iterator + rbegin() const noexcept + { return const_reverse_iterator(this->end()); } + + const_reverse_iterator + rend() const noexcept + { return const_reverse_iterator(this->begin()); } + + const_reverse_iterator + crbegin() const noexcept + { return const_reverse_iterator(this->end()); } + + const_reverse_iterator + crend() const noexcept + { return const_reverse_iterator(this->begin()); } + + // [string.view.capacity], capacity + + constexpr size_type + size() const noexcept + { return this->_M_len; } + + constexpr size_type + length() const noexcept + { return _M_len; } + + constexpr size_type + max_size() const noexcept + { + return (npos - sizeof(size_type) - sizeof(void*)) + / sizeof(value_type) / 4; + } + + constexpr bool + empty() const noexcept + { return this->_M_len == 0; } + + // [string.view.access], element access + + constexpr const _CharT& + operator[](size_type __pos) const + { + // TODO: Assert to restore in a way compatible with the constexpr. + // _GLIBCXX_DEBUG_ASSERT(__pos < this->_M_len); + return *(this->_M_str + __pos); + } + + constexpr const _CharT& + at(size_type __pos) const + { + return __pos < this->_M_len + ? *(this->_M_str + __pos) + : (__throw_out_of_range_fmt(__N("basic_string_view::at: __pos " + "(which is %zu) >= this->size() " + "(which is %zu)"), + __pos, this->size()), + *this->_M_str); + } + + constexpr const _CharT& + front() const + { + // TODO: Assert to restore in a way compatible with the constexpr. + // _GLIBCXX_DEBUG_ASSERT(this->_M_len > 0); + return *this->_M_str; + } + + constexpr const _CharT& + back() const + { + // TODO: Assert to restore in a way compatible with the constexpr. + // _GLIBCXX_DEBUG_ASSERT(this->_M_len > 0); + return *(this->_M_str + this->_M_len - 1); + } + + constexpr const _CharT* + data() const noexcept + { return this->_M_str; } + + // [string.view.modifiers], modifiers: + + void + clear() noexcept + { + this->_M_len = 0; + this->_M_str = nullptr; + } + + void + remove_prefix(size_type __n) + { + _GLIBCXX_DEBUG_ASSERT(this->_M_len >= __n); + this->_M_str += __n; + this->_M_len -= __n; + } + + void + remove_suffix(size_type __n) + { this->_M_len -= __n; } + + void + swap(basic_string_view& __sv) noexcept + { + std::swap(this->_M_len, __sv._M_len); + std::swap(this->_M_str, __sv._M_str); + } + + + // [string.view.ops], string operations: + + template + explicit operator basic_string<_CharT, _Traits, _Allocator>() const + { + return { this->_M_str, this->_M_len }; + } + + template> + basic_string<_CharT, _Traits, _Allocator> + to_string(const _Allocator& __alloc = _Allocator()) const + { + return { this->_M_str, this->_M_len, __alloc }; + } + + size_type + copy(_CharT* __str, size_type __n, size_type __pos = 0) const + { + __glibcxx_requires_string_len(__str, __n); + if (__pos > this->_M_len) + __throw_out_of_range_fmt(__N("basic_string_view::copy: __pos " + "(which is %zu) > this->size() " + "(which is %zu)"), + __pos, this->size()); + size_type __rlen{std::min(__n, size_type{this->_M_len - __pos})}; + for (auto __begin = this->_M_str + __pos, + __end = __begin + __rlen; __begin != __end;) + *__str++ = *__begin++; + return __rlen; + } + + + // [string.view.ops], string operations: + + constexpr basic_string_view + substr(size_type __pos, size_type __n=npos) const + { + return __pos <= this->_M_len + ? basic_string_view{this->_M_str + __pos, + std::min(__n, size_type{this->_M_len - __pos})} + : (__throw_out_of_range_fmt(__N("basic_string_view::substr: __pos " + "(which is %zu) > this->size() " + "(which is %zu)"), + __pos, this->size()), basic_string_view{}); + } + + int + compare(basic_string_view __str) const noexcept + { + int __ret = traits_type::compare(this->_M_str, __str._M_str, + std::min(this->_M_len, __str._M_len)); + if (__ret == 0) + __ret = _S_compare(this->_M_len, __str._M_len); + return __ret; + } + + int + compare(size_type __pos1, size_type __n1, basic_string_view __str) const + { return this->substr(__pos1, __n1).compare(__str); } + + int + compare(size_type __pos1, size_type __n1, + basic_string_view __str, size_type __pos2, size_type __n2) const + { return this->substr(__pos1, __n1).compare(__str.substr(__pos2, __n2)); } + + int + compare(const _CharT* __str) const noexcept + { return this->compare(basic_string_view{__str}); } + + int + compare(size_type __pos1, size_type __n1, const _CharT* __str) const + { return this->substr(__pos1, __n1).compare(basic_string_view{__str}); } + + int + compare(size_type __pos1, size_type __n1, + const _CharT* __str, size_type __n2) const + { + return this->substr(__pos1, __n1) + .compare(basic_string_view(__str, __n2)); + } + + size_type + find(basic_string_view __str, size_type __pos = 0) const noexcept + { return this->find(__str._M_str, __pos, __str._M_len); } + + size_type + find(_CharT __c, size_type __pos=0) const noexcept; + + size_type + find(const _CharT* __str, size_type __pos, size_type __n) const noexcept; + + size_type + find(const _CharT* __str, size_type __pos=0) const noexcept + { return this->find(__str, __pos, traits_type::length(__str)); } + + size_type + rfind(basic_string_view __str, size_type __pos = npos) const noexcept + { return this->rfind(__str._M_str, __pos, __str._M_len); } + + size_type + rfind(_CharT __c, size_type __pos = npos) const noexcept; + + size_type + rfind(const _CharT* __str, size_type __pos, size_type __n) const noexcept; + + size_type + rfind(const _CharT* __str, size_type __pos = npos) const noexcept + { return this->rfind(__str, __pos, traits_type::length(__str)); } + + size_type + find_first_of(basic_string_view __str, size_type __pos = 0) const noexcept + { return this->find_first_of(__str._M_str, __pos, __str._M_len); } + + size_type + find_first_of(_CharT __c, size_type __pos = 0) const noexcept + { return this->find(__c, __pos); } + + size_type + find_first_of(const _CharT* __str, size_type __pos, size_type __n) const; + + size_type + find_first_of(const _CharT* __str, size_type __pos = 0) const noexcept + { return this->find_first_of(__str, __pos, traits_type::length(__str)); } + + size_type + find_last_of(basic_string_view __str, + size_type __pos = npos) const noexcept + { return this->find_last_of(__str._M_str, __pos, __str._M_len); } + + size_type + find_last_of(_CharT __c, size_type __pos=npos) const noexcept + { return this->rfind(__c, __pos); } + + size_type + find_last_of(const _CharT* __str, size_type __pos, size_type __n) const; + + size_type + find_last_of(const _CharT* __str, size_type __pos = npos) const noexcept + { return this->find_last_of(__str, __pos, traits_type::length(__str)); } + + size_type + find_first_not_of(basic_string_view __str, + size_type __pos = 0) const noexcept + { return this->find_first_not_of(__str._M_str, __pos, __str._M_len); } + + size_type + find_first_not_of(_CharT __c, size_type __pos = 0) const noexcept; + + size_type + find_first_not_of(const _CharT* __str, + size_type __pos, size_type __n) const; + + size_type + find_first_not_of(const _CharT* __str, size_type __pos = 0) const noexcept + { + return this->find_first_not_of(__str, __pos, + traits_type::length(__str)); + } + + size_type + find_last_not_of(basic_string_view __str, + size_type __pos = npos) const noexcept + { return this->find_last_not_of(__str._M_str, __pos, __str._M_len); } + + size_type + find_last_not_of(_CharT __c, size_type __pos = npos) const noexcept; + + size_type + find_last_not_of(const _CharT* __str, + size_type __pos, size_type __n) const; + + size_type + find_last_not_of(const _CharT* __str, + size_type __pos = npos) const noexcept + { + return this->find_last_not_of(__str, __pos, + traits_type::length(__str)); + } + + private: + + static constexpr const int + _S_compare(size_type __n1, size_type __n2) noexcept + { + return difference_type{__n1 - __n2} > std::numeric_limits::max() + ? std::numeric_limits::max() + : difference_type{__n1 - __n2} < std::numeric_limits::min() + ? std::numeric_limits::min() + : static_cast(difference_type{__n1 - __n2}); + } + + size_t _M_len; + const _CharT* _M_str; + }; + + + // [string.view.comparison], non-member basic_string_view comparison functions + + namespace __detail + { + // Identity transform to make ADL work with just one argument. + // See n3766.html. + template + struct __identity + { typedef _Tp type; }; + + template<> + struct __identity; + + template + using __idt = typename __identity<_Tp>::type; + } + + template + inline bool + operator==(basic_string_view<_CharT, _Traits> __x, + basic_string_view<_CharT, _Traits> __y) noexcept + { return __x.compare(__y) == 0; } + + template + inline bool + operator==(basic_string_view<_CharT, _Traits> __x, + __detail::__idt> __y) noexcept + { return __x.compare(__y) == 0; } + + template + inline bool + operator==(__detail::__idt> __x, + basic_string_view<_CharT, _Traits> __y) noexcept + { return __x.compare(__y) == 0; } + + template + inline bool + operator!=(basic_string_view<_CharT, _Traits> __x, + basic_string_view<_CharT, _Traits> __y) noexcept + { return !(__x == __y); } + + template + inline bool + operator!=(basic_string_view<_CharT, _Traits> __x, + __detail::__idt> __y) noexcept + { return !(__x == __y); } + + template + inline bool + operator!=(__detail::__idt> __x, + basic_string_view<_CharT, _Traits> __y) noexcept + { return !(__x == __y); } + + template + inline bool + operator< (basic_string_view<_CharT, _Traits> __x, + basic_string_view<_CharT, _Traits> __y) noexcept + { return __x.compare(__y) < 0; } + + template + inline bool + operator< (basic_string_view<_CharT, _Traits> __x, + __detail::__idt> __y) noexcept + { return __x.compare(__y) < 0; } + + template + inline bool + operator< (__detail::__idt> __x, + basic_string_view<_CharT, _Traits> __y) noexcept + { return __x.compare(__y) < 0; } + + template + inline bool + operator> (basic_string_view<_CharT, _Traits> __x, + basic_string_view<_CharT, _Traits> __y) noexcept + { return __x.compare(__y) > 0; } + + template + inline bool + operator> (basic_string_view<_CharT, _Traits> __x, + __detail::__idt> __y) noexcept + { return __x.compare(__y) > 0; } + + template + inline bool + operator> (__detail::__idt> __x, + basic_string_view<_CharT, _Traits> __y) noexcept + { return __x.compare(__y) > 0; } + + template + inline bool + operator<=(basic_string_view<_CharT, _Traits> __x, + basic_string_view<_CharT, _Traits> __y) noexcept + { return __x.compare(__y) <= 0; } + + template + inline bool + operator<=(basic_string_view<_CharT, _Traits> __x, + __detail::__idt> __y) noexcept + { return __x.compare(__y) <= 0; } + + template + inline bool + operator<=(__detail::__idt> __x, + basic_string_view<_CharT, _Traits> __y) noexcept + { return __x.compare(__y) <= 0; } + + template + inline bool + operator>=(basic_string_view<_CharT, _Traits> __x, + basic_string_view<_CharT, _Traits> __y) noexcept + { return __x.compare(__y) >= 0; } + + template + inline bool + operator>=(basic_string_view<_CharT, _Traits> __x, + __detail::__idt> __y) noexcept + { return __x.compare(__y) >= 0; } + + template + inline bool + operator>=(__detail::__idt> __x, + basic_string_view<_CharT, _Traits> __y) noexcept + { return __x.compare(__y) >= 0; } + + // [string.view.io], Inserters and extractors + template + inline basic_ostream<_CharT, _Traits>& + operator<<(basic_ostream<_CharT, _Traits>& __os, + basic_string_view<_CharT,_Traits> __str) + { return __ostream_insert(__os, __str.data(), __str.size()); } + + + // basic_string_view typedef names + + using string_view = basic_string_view; +#ifdef _GLIBCXX_USE_WCHAR_T + using wstring_view = basic_string_view; +#endif +#ifdef _GLIBCXX_USE_C99_STDINT_TR1 + using u16string_view = basic_string_view; + using u32string_view = basic_string_view; +#endif + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace experimental + + + // [string.view.hash], hash support: + +_GLIBCXX_BEGIN_NAMESPACE_VERSION + template + struct hash; + + template<> + struct hash + : public __hash_base + { + size_t + operator()(const experimental::string_view& __str) const noexcept + { return std::_Hash_impl::hash(__str.data(), __str.length()); } + }; + + template<> + struct __is_fast_hash> : std::false_type + { }; + +#ifdef _GLIBCXX_USE_WCHAR_T + template<> + struct hash + : public __hash_base + { + size_t + operator()(const experimental::wstring_view& __s) const noexcept + { return std::_Hash_impl::hash(__s.data(), + __s.length() * sizeof(wchar_t)); } + }; + + template<> + struct __is_fast_hash> : std::false_type + { }; +#endif + +#ifdef _GLIBCXX_USE_C99_STDINT_TR1 + template<> + struct hash + : public __hash_base + { + size_t + operator()(const experimental::u16string_view& __s) const noexcept + { return std::_Hash_impl::hash(__s.data(), + __s.length() * sizeof(char16_t)); } + }; + + template<> + struct __is_fast_hash> : std::false_type + { }; + + template<> + struct hash + : public __hash_base + { + size_t + operator()(const experimental::u32string_view& __s) const noexcept + { return std::_Hash_impl::hash(__s.data(), + __s.length() * sizeof(char32_t)); } + }; + + template<> + struct __is_fast_hash> : std::false_type + { }; +#endif +_GLIBCXX_END_NAMESPACE_VERSION + +namespace experimental +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + // I added these EMSR. + inline namespace literals + { + inline namespace string_view_literals + { + + inline basic_string_view + operator""sv(const char* __str, size_t __len) + { return basic_string_view{__str, __len}; } + +#ifdef _GLIBCXX_USE_WCHAR_T + inline basic_string_view + operator""sv(const wchar_t* __str, size_t __len) + { return basic_string_view{__str, __len}; } +#endif + +#ifdef _GLIBCXX_USE_C99_STDINT_TR1 + inline basic_string_view + operator""sv(const char16_t* __str, size_t __len) + { return basic_string_view{__str, __len}; } + + inline basic_string_view + operator""sv(const char32_t* __str, size_t __len) + { return basic_string_view{__str, __len}; } +#endif + + } + } + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace experimental +} // namespace std + +#include + +#endif // __cplusplus <= 201103L + +#endif // _GLIBCXX_EXPERIMENTAL_STRING_VIEW diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/experimental/string_view.tcc b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/experimental/string_view.tcc new file mode 100755 index 0000000..4456266 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/experimental/string_view.tcc @@ -0,0 +1,230 @@ +// Components for manipulating non-owning sequences of characters -*- C++ -*- + +// Copyright (C) 2013-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file experimental/string_view.tcc + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{string_view} + */ + +// +// N3762 basic_string_view library +// + +#ifndef _GLIBCXX_EXPERIMENTAL_STRING_VIEW_TCC +#define _GLIBCXX_EXPERIMENTAL_STRING_VIEW_TCC 1 + +#pragma GCC system_header + +#if __cplusplus <= 201103L +# include +#else + +namespace std _GLIBCXX_VISIBILITY(default) +{ +namespace experimental +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + template + typename basic_string_view<_CharT, _Traits>::size_type + basic_string_view<_CharT, _Traits>:: + find(const _CharT* __str, size_type __pos, size_type __n) const noexcept + { + __glibcxx_requires_string_len(__str, __n); + + if (__n == 0) + return __pos <= this->_M_len ? __pos : npos; + + if (__n <= this->_M_len) + { + for (; __pos <= this->_M_len - __n; ++__pos) + if (traits_type::eq(this->_M_str[__pos], __str[0]) + && traits_type::compare(this->_M_str + __pos + 1, + __str + 1, __n - 1) == 0) + return __pos; + } + return npos; + } + + template + typename basic_string_view<_CharT, _Traits>::size_type + basic_string_view<_CharT, _Traits>:: + find(_CharT __c, size_type __pos) const noexcept + { + size_type __ret = npos; + if (__pos < this->_M_len) + { + const size_type __n = this->_M_len - __pos; + const _CharT* __p = traits_type::find(this->_M_str + __pos, __n, __c); + if (__p) + __ret = __p - this->_M_str; + } + return __ret; + } + + template + typename basic_string_view<_CharT, _Traits>::size_type + basic_string_view<_CharT, _Traits>:: + rfind(const _CharT* __str, size_type __pos, size_type __n) const noexcept + { + __glibcxx_requires_string_len(__str, __n); + + if (__n <= this->_M_len) + { + __pos = std::min(size_type(this->_M_len - __n), __pos); + do + { + if (traits_type::compare(this->_M_str + __pos, __str, __n) == 0) + return __pos; + } + while (__pos-- > 0); + } + return npos; + } + + template + typename basic_string_view<_CharT, _Traits>::size_type + basic_string_view<_CharT, _Traits>:: + rfind(_CharT __c, size_type __pos) const noexcept + { + size_type __size = this->_M_len; + if (__size > 0) + { + if (--__size > __pos) + __size = __pos; + for (++__size; __size-- > 0; ) + if (traits_type::eq(this->_M_str[__size], __c)) + return __size; + } + return npos; + } + + template + typename basic_string_view<_CharT, _Traits>::size_type + basic_string_view<_CharT, _Traits>:: + find_first_of(const _CharT* __str, size_type __pos, size_type __n) const + { + __glibcxx_requires_string_len(__str, __n); + for (; __n && __pos < this->_M_len; ++__pos) + { + const _CharT* __p = traits_type::find(__str, __n, + this->_M_str[__pos]); + if (__p) + return __pos; + } + return npos; + } + + template + typename basic_string_view<_CharT, _Traits>::size_type + basic_string_view<_CharT, _Traits>:: + find_last_of(const _CharT* __str, size_type __pos, size_type __n) const + { + __glibcxx_requires_string_len(__str, __n); + size_type __size = this->size(); + if (__size && __n) + { + if (--__size > __pos) + __size = __pos; + do + { + if (traits_type::find(__str, __n, this->_M_str[__size])) + return __size; + } + while (__size-- != 0); + } + return npos; + } + + template + typename basic_string_view<_CharT, _Traits>::size_type + basic_string_view<_CharT, _Traits>:: + find_first_not_of(const _CharT* __str, size_type __pos, size_type __n) const + { + __glibcxx_requires_string_len(__str, __n); + for (; __pos < this->_M_len; ++__pos) + if (!traits_type::find(__str, __n, this->_M_str[__pos])) + return __pos; + return npos; + } + + template + typename basic_string_view<_CharT, _Traits>::size_type + basic_string_view<_CharT, _Traits>:: + find_first_not_of(_CharT __c, size_type __pos) const noexcept + { + for (; __pos < this->_M_len; ++__pos) + if (!traits_type::eq(this->_M_str[__pos], __c)) + return __pos; + return npos; + } + + template + typename basic_string_view<_CharT, _Traits>::size_type + basic_string_view<_CharT, _Traits>:: + find_last_not_of(const _CharT* __str, size_type __pos, size_type __n) const + { + __glibcxx_requires_string_len(__str, __n); + size_type __size = this->_M_len; + if (__size) + { + if (--__size > __pos) + __size = __pos; + do + { + if (!traits_type::find(__str, __n, this->_M_str[__size])) + return __size; + } + while (__size--); + } + return npos; + } + + template + typename basic_string_view<_CharT, _Traits>::size_type + basic_string_view<_CharT, _Traits>:: + find_last_not_of(_CharT __c, size_type __pos) const noexcept + { + size_type __size = this->_M_len; + if (__size) + { + if (--__size > __pos) + __size = __pos; + do + { + if (!traits_type::eq(this->_M_str[__size], __c)) + return __size; + } + while (__size--); + } + return npos; + } + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace experimental +} // namespace std + +#endif // __cplusplus <= 201103L + +#endif // _GLIBCXX_EXPERIMENTAL_STRING_VIEW_TCC diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/ext/algorithm b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/ext/algorithm new file mode 100755 index 0000000..2731e67 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/ext/algorithm @@ -0,0 +1,603 @@ +// Algorithm extensions -*- C++ -*- + +// Copyright (C) 2001-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/* + * + * Copyright (c) 1994 + * Hewlett-Packard Company + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Hewlett-Packard Company makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + * + * + * Copyright (c) 1996 + * Silicon Graphics Computer Systems, Inc. + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Silicon Graphics makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + */ + +/** @file ext/algorithm + * This file is a GNU extension to the Standard C++ Library (possibly + * containing extensions from the HP/SGI STL subset). + */ + +#ifndef _EXT_ALGORITHM +#define _EXT_ALGORITHM 1 + +#pragma GCC system_header + +#include + +namespace __gnu_cxx _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + using std::ptrdiff_t; + using std::min; + using std::pair; + using std::input_iterator_tag; + using std::random_access_iterator_tag; + using std::iterator_traits; + + //-------------------------------------------------- + // copy_n (not part of the C++ standard) + + template + pair<_InputIterator, _OutputIterator> + __copy_n(_InputIterator __first, _Size __count, + _OutputIterator __result, + input_iterator_tag) + { + for ( ; __count > 0; --__count) + { + *__result = *__first; + ++__first; + ++__result; + } + return pair<_InputIterator, _OutputIterator>(__first, __result); + } + + template + inline pair<_RAIterator, _OutputIterator> + __copy_n(_RAIterator __first, _Size __count, + _OutputIterator __result, + random_access_iterator_tag) + { + _RAIterator __last = __first + __count; + return pair<_RAIterator, _OutputIterator>(__last, std::copy(__first, + __last, + __result)); + } + + /** + * @brief Copies the range [first,first+count) into [result,result+count). + * @param __first An input iterator. + * @param __count The number of elements to copy. + * @param __result An output iterator. + * @return A std::pair composed of first+count and result+count. + * + * This is an SGI extension. + * This inline function will boil down to a call to @c memmove whenever + * possible. Failing that, if random access iterators are passed, then the + * loop count will be known (and therefore a candidate for compiler + * optimizations such as unrolling). + * @ingroup SGIextensions + */ + template + inline pair<_InputIterator, _OutputIterator> + copy_n(_InputIterator __first, _Size __count, _OutputIterator __result) + { + // concept requirements + __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>) + __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator, + typename iterator_traits<_InputIterator>::value_type>) + + return __gnu_cxx::__copy_n(__first, __count, __result, + std::__iterator_category(__first)); + } + + template + int + __lexicographical_compare_3way(_InputIterator1 __first1, + _InputIterator1 __last1, + _InputIterator2 __first2, + _InputIterator2 __last2) + { + while (__first1 != __last1 && __first2 != __last2) + { + if (*__first1 < *__first2) + return -1; + if (*__first2 < *__first1) + return 1; + ++__first1; + ++__first2; + } + if (__first2 == __last2) + return !(__first1 == __last1); + else + return -1; + } + + inline int + __lexicographical_compare_3way(const unsigned char* __first1, + const unsigned char* __last1, + const unsigned char* __first2, + const unsigned char* __last2) + { + const ptrdiff_t __len1 = __last1 - __first1; + const ptrdiff_t __len2 = __last2 - __first2; + const int __result = __builtin_memcmp(__first1, __first2, + min(__len1, __len2)); + return __result != 0 ? __result + : (__len1 == __len2 ? 0 : (__len1 < __len2 ? -1 : 1)); + } + + inline int + __lexicographical_compare_3way(const char* __first1, const char* __last1, + const char* __first2, const char* __last2) + { +#if CHAR_MAX == SCHAR_MAX + return __lexicographical_compare_3way((const signed char*) __first1, + (const signed char*) __last1, + (const signed char*) __first2, + (const signed char*) __last2); +#else + return __lexicographical_compare_3way((const unsigned char*) __first1, + (const unsigned char*) __last1, + (const unsigned char*) __first2, + (const unsigned char*) __last2); +#endif + } + + /** + * @brief @c memcmp on steroids. + * @param __first1 An input iterator. + * @param __last1 An input iterator. + * @param __first2 An input iterator. + * @param __last2 An input iterator. + * @return An int, as with @c memcmp. + * + * The return value will be less than zero if the first range is + * lexigraphically less than the second, greater than zero + * if the second range is lexigraphically less than the + * first, and zero otherwise. + * This is an SGI extension. + * @ingroup SGIextensions + */ + template + int + lexicographical_compare_3way(_InputIterator1 __first1, + _InputIterator1 __last1, + _InputIterator2 __first2, + _InputIterator2 __last2) + { + // concept requirements + __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>) + __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>) + __glibcxx_function_requires(_LessThanComparableConcept< + typename iterator_traits<_InputIterator1>::value_type>) + __glibcxx_function_requires(_LessThanComparableConcept< + typename iterator_traits<_InputIterator2>::value_type>) + __glibcxx_requires_valid_range(__first1, __last1); + __glibcxx_requires_valid_range(__first2, __last2); + + return __lexicographical_compare_3way(__first1, __last1, __first2, + __last2); + } + + // count and count_if: this version, whose return type is void, was present + // in the HP STL, and is retained as an extension for backward compatibility. + template + void + count(_InputIterator __first, _InputIterator __last, + const _Tp& __value, + _Size& __n) + { + // concept requirements + __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>) + __glibcxx_function_requires(_EqualityComparableConcept< + typename iterator_traits<_InputIterator>::value_type >) + __glibcxx_function_requires(_EqualityComparableConcept<_Tp>) + __glibcxx_requires_valid_range(__first, __last); + + for ( ; __first != __last; ++__first) + if (*__first == __value) + ++__n; + } + + template + void + count_if(_InputIterator __first, _InputIterator __last, + _Predicate __pred, + _Size& __n) + { + // concept requirements + __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>) + __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate, + typename iterator_traits<_InputIterator>::value_type>) + __glibcxx_requires_valid_range(__first, __last); + + for ( ; __first != __last; ++__first) + if (__pred(*__first)) + ++__n; + } + + // random_sample and random_sample_n (extensions, not part of the standard). + + /** + * This is an SGI extension. + * @ingroup SGIextensions + * @doctodo + */ + template + _OutputIterator + random_sample_n(_ForwardIterator __first, _ForwardIterator __last, + _OutputIterator __out, const _Distance __n) + { + // concept requirements + __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>) + __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator, + typename iterator_traits<_ForwardIterator>::value_type>) + __glibcxx_requires_valid_range(__first, __last); + + _Distance __remaining = std::distance(__first, __last); + _Distance __m = min(__n, __remaining); + + while (__m > 0) + { + if ((std::rand() % __remaining) < __m) + { + *__out = *__first; + ++__out; + --__m; + } + --__remaining; + ++__first; + } + return __out; + } + + /** + * This is an SGI extension. + * @ingroup SGIextensions + * @doctodo + */ + template + _OutputIterator + random_sample_n(_ForwardIterator __first, _ForwardIterator __last, + _OutputIterator __out, const _Distance __n, + _RandomNumberGenerator& __rand) + { + // concept requirements + __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>) + __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator, + typename iterator_traits<_ForwardIterator>::value_type>) + __glibcxx_function_requires(_UnaryFunctionConcept< + _RandomNumberGenerator, _Distance, _Distance>) + __glibcxx_requires_valid_range(__first, __last); + + _Distance __remaining = std::distance(__first, __last); + _Distance __m = min(__n, __remaining); + + while (__m > 0) + { + if (__rand(__remaining) < __m) + { + *__out = *__first; + ++__out; + --__m; + } + --__remaining; + ++__first; + } + return __out; + } + + template + _RandomAccessIterator + __random_sample(_InputIterator __first, _InputIterator __last, + _RandomAccessIterator __out, + const _Distance __n) + { + _Distance __m = 0; + _Distance __t = __n; + for ( ; __first != __last && __m < __n; ++__m, ++__first) + __out[__m] = *__first; + + while (__first != __last) + { + ++__t; + _Distance __M = std::rand() % (__t); + if (__M < __n) + __out[__M] = *__first; + ++__first; + } + return __out + __m; + } + + template + _RandomAccessIterator + __random_sample(_InputIterator __first, _InputIterator __last, + _RandomAccessIterator __out, + _RandomNumberGenerator& __rand, + const _Distance __n) + { + // concept requirements + __glibcxx_function_requires(_UnaryFunctionConcept< + _RandomNumberGenerator, _Distance, _Distance>) + + _Distance __m = 0; + _Distance __t = __n; + for ( ; __first != __last && __m < __n; ++__m, ++__first) + __out[__m] = *__first; + + while (__first != __last) + { + ++__t; + _Distance __M = __rand(__t); + if (__M < __n) + __out[__M] = *__first; + ++__first; + } + return __out + __m; + } + + /** + * This is an SGI extension. + * @ingroup SGIextensions + * @doctodo + */ + template + inline _RandomAccessIterator + random_sample(_InputIterator __first, _InputIterator __last, + _RandomAccessIterator __out_first, + _RandomAccessIterator __out_last) + { + // concept requirements + __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>) + __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept< + _RandomAccessIterator>) + __glibcxx_requires_valid_range(__first, __last); + __glibcxx_requires_valid_range(__out_first, __out_last); + + return __random_sample(__first, __last, + __out_first, __out_last - __out_first); + } + + /** + * This is an SGI extension. + * @ingroup SGIextensions + * @doctodo + */ + template + inline _RandomAccessIterator + random_sample(_InputIterator __first, _InputIterator __last, + _RandomAccessIterator __out_first, + _RandomAccessIterator __out_last, + _RandomNumberGenerator& __rand) + { + // concept requirements + __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>) + __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept< + _RandomAccessIterator>) + __glibcxx_requires_valid_range(__first, __last); + __glibcxx_requires_valid_range(__out_first, __out_last); + + return __random_sample(__first, __last, + __out_first, __rand, + __out_last - __out_first); + } + +#if __cplusplus >= 201103L + using std::is_heap; +#else + /** + * This is an SGI extension. + * @ingroup SGIextensions + * @doctodo + */ + template + inline bool + is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) + { + // concept requirements + __glibcxx_function_requires(_RandomAccessIteratorConcept< + _RandomAccessIterator>) + __glibcxx_function_requires(_LessThanComparableConcept< + typename iterator_traits<_RandomAccessIterator>::value_type>) + __glibcxx_requires_valid_range(__first, __last); + + return std::__is_heap(__first, __last - __first); + } + + /** + * This is an SGI extension. + * @ingroup SGIextensions + * @doctodo + */ + template + inline bool + is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, + _StrictWeakOrdering __comp) + { + // concept requirements + __glibcxx_function_requires(_RandomAccessIteratorConcept< + _RandomAccessIterator>) + __glibcxx_function_requires(_BinaryPredicateConcept<_StrictWeakOrdering, + typename iterator_traits<_RandomAccessIterator>::value_type, + typename iterator_traits<_RandomAccessIterator>::value_type>) + __glibcxx_requires_valid_range(__first, __last); + + return std::__is_heap(__first, __comp, __last - __first); + } +#endif + +#if __cplusplus >= 201103L + using std::is_sorted; +#else + // is_sorted, a predicated testing whether a range is sorted in + // nondescending order. This is an extension, not part of the C++ + // standard. + + /** + * This is an SGI extension. + * @ingroup SGIextensions + * @doctodo + */ + template + bool + is_sorted(_ForwardIterator __first, _ForwardIterator __last) + { + // concept requirements + __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>) + __glibcxx_function_requires(_LessThanComparableConcept< + typename iterator_traits<_ForwardIterator>::value_type>) + __glibcxx_requires_valid_range(__first, __last); + + if (__first == __last) + return true; + + _ForwardIterator __next = __first; + for (++__next; __next != __last; __first = __next, ++__next) + if (*__next < *__first) + return false; + return true; + } + + /** + * This is an SGI extension. + * @ingroup SGIextensions + * @doctodo + */ + template + bool + is_sorted(_ForwardIterator __first, _ForwardIterator __last, + _StrictWeakOrdering __comp) + { + // concept requirements + __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>) + __glibcxx_function_requires(_BinaryPredicateConcept<_StrictWeakOrdering, + typename iterator_traits<_ForwardIterator>::value_type, + typename iterator_traits<_ForwardIterator>::value_type>) + __glibcxx_requires_valid_range(__first, __last); + + if (__first == __last) + return true; + + _ForwardIterator __next = __first; + for (++__next; __next != __last; __first = __next, ++__next) + if (__comp(*__next, *__first)) + return false; + return true; + } +#endif // C++11 + + /** + * @brief Find the median of three values. + * @param __a A value. + * @param __b A value. + * @param __c A value. + * @return One of @p a, @p b or @p c. + * + * If @c {l,m,n} is some convolution of @p {a,b,c} such that @c l<=m<=n + * then the value returned will be @c m. + * This is an SGI extension. + * @ingroup SGIextensions + */ + template + const _Tp& + __median(const _Tp& __a, const _Tp& __b, const _Tp& __c) + { + // concept requirements + __glibcxx_function_requires(_LessThanComparableConcept<_Tp>) + if (__a < __b) + if (__b < __c) + return __b; + else if (__a < __c) + return __c; + else + return __a; + else if (__a < __c) + return __a; + else if (__b < __c) + return __c; + else + return __b; + } + + /** + * @brief Find the median of three values using a predicate for comparison. + * @param __a A value. + * @param __b A value. + * @param __c A value. + * @param __comp A binary predicate. + * @return One of @p a, @p b or @p c. + * + * If @c {l,m,n} is some convolution of @p {a,b,c} such that @p comp(l,m) + * and @p comp(m,n) are both true then the value returned will be @c m. + * This is an SGI extension. + * @ingroup SGIextensions + */ + template + const _Tp& + __median(const _Tp& __a, const _Tp& __b, const _Tp& __c, _Compare __comp) + { + // concept requirements + __glibcxx_function_requires(_BinaryFunctionConcept<_Compare, bool, + _Tp, _Tp>) + if (__comp(__a, __b)) + if (__comp(__b, __c)) + return __b; + else if (__comp(__a, __c)) + return __c; + else + return __a; + else if (__comp(__a, __c)) + return __a; + else if (__comp(__b, __c)) + return __c; + else + return __b; + } + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif /* _EXT_ALGORITHM */ diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/ext/aligned_buffer.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/ext/aligned_buffer.h new file mode 100755 index 0000000..861de5b --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/ext/aligned_buffer.h @@ -0,0 +1,73 @@ +// Aligned memory buffer -*- C++ -*- + +// Copyright (C) 2013-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file ext/aligned_buffer.h + * This file is a GNU extension to the Standard C++ Library. + */ + +#ifndef _ALIGNED_BUFFER_H +#define _ALIGNED_BUFFER_H 1 + +#pragma GCC system_header + +#if __cplusplus >= 201103L +# include +#else +# include +#endif + +namespace __gnu_cxx +{ + template + struct __aligned_buffer + : std::aligned_storage::value> + { + typename + std::aligned_storage::value>::type + _M_storage; + + void* + _M_addr() noexcept + { + return static_cast(&_M_storage); + } + + const void* + _M_addr() const noexcept + { + return static_cast(&_M_storage); + } + + _Tp* + _M_ptr() noexcept + { return static_cast<_Tp*>(_M_addr()); } + + const _Tp* + _M_ptr() const noexcept + { return static_cast(_M_addr()); } + }; + +} // namespace + +#endif /* _ALIGNED_BUFFER_H */ diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/ext/alloc_traits.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/ext/alloc_traits.h new file mode 100755 index 0000000..14fbc43 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/ext/alloc_traits.h @@ -0,0 +1,215 @@ +// Allocator traits -*- C++ -*- + +// Copyright (C) 2011-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file ext/alloc_traits.h + * This file is a GNU extension to the Standard C++ Library. + */ + +#ifndef _EXT_ALLOC_TRAITS_H +#define _EXT_ALLOC_TRAITS_H 1 + +#pragma GCC system_header + +#if __cplusplus >= 201103L +# include +# include +#else +# include // for __alloc_swap +#endif + +namespace __gnu_cxx _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + +#if __cplusplus >= 201103L + template + struct __allocator_always_compares_equal : std::false_type { }; + + template + struct __allocator_always_compares_equal> + : std::true_type { }; + + template struct array_allocator; + + template + struct __allocator_always_compares_equal> + : std::true_type { }; + + template struct bitmap_allocator; + + template + struct __allocator_always_compares_equal> + : std::true_type { }; + + template struct malloc_allocator; + + template + struct __allocator_always_compares_equal> + : std::true_type { }; + + template struct mt_allocator; + + template + struct __allocator_always_compares_equal> + : std::true_type { }; + + template struct new_allocator; + + template + struct __allocator_always_compares_equal> + : std::true_type { }; + + template struct pool_allocator; + + template + struct __allocator_always_compares_equal> + : std::true_type { }; +#endif + +/** + * @brief Uniform interface to C++98 and C++0x allocators. + * @ingroup allocators +*/ +template + struct __alloc_traits +#if __cplusplus >= 201103L + : std::allocator_traits<_Alloc> +#endif + { + typedef _Alloc allocator_type; +#if __cplusplus >= 201103L + typedef std::allocator_traits<_Alloc> _Base_type; + typedef typename _Base_type::value_type value_type; + typedef typename _Base_type::pointer pointer; + typedef typename _Base_type::const_pointer const_pointer; + typedef typename _Base_type::size_type size_type; + typedef typename _Base_type::difference_type difference_type; + // C++11 allocators do not define reference or const_reference + typedef value_type& reference; + typedef const value_type& const_reference; + using _Base_type::allocate; + using _Base_type::deallocate; + using _Base_type::construct; + using _Base_type::destroy; + using _Base_type::max_size; + + private: + template + using __is_custom_pointer + = std::__and_, + std::__not_>>; + + public: + // overload construct for non-standard pointer types + template + static typename std::enable_if<__is_custom_pointer<_Ptr>::value>::type + construct(_Alloc& __a, _Ptr __p, _Args&&... __args) + { + _Base_type::construct(__a, std::addressof(*__p), + std::forward<_Args>(__args)...); + } + + // overload destroy for non-standard pointer types + template + static typename std::enable_if<__is_custom_pointer<_Ptr>::value>::type + destroy(_Alloc& __a, _Ptr __p) + { _Base_type::destroy(__a, std::addressof(*__p)); } + + static _Alloc _S_select_on_copy(const _Alloc& __a) + { return _Base_type::select_on_container_copy_construction(__a); } + + static void _S_on_swap(_Alloc& __a, _Alloc& __b) + { std::__alloc_on_swap(__a, __b); } + + static constexpr bool _S_propagate_on_copy_assign() + { return _Base_type::propagate_on_container_copy_assignment::value; } + + static constexpr bool _S_propagate_on_move_assign() + { return _Base_type::propagate_on_container_move_assignment::value; } + + static constexpr bool _S_propagate_on_swap() + { return _Base_type::propagate_on_container_swap::value; } + + static constexpr bool _S_always_equal() + { return __allocator_always_compares_equal<_Alloc>::value; } + + static constexpr bool _S_nothrow_move() + { return _S_propagate_on_move_assign() || _S_always_equal(); } + + static constexpr bool _S_nothrow_swap() + { + using std::swap; + return !_S_propagate_on_swap() + || noexcept(swap(std::declval<_Alloc&>(), std::declval<_Alloc&>())); + } + + template + struct rebind + { typedef typename _Base_type::template rebind_alloc<_Tp> other; }; +#else + + typedef typename _Alloc::pointer pointer; + typedef typename _Alloc::const_pointer const_pointer; + typedef typename _Alloc::value_type value_type; + typedef typename _Alloc::reference reference; + typedef typename _Alloc::const_reference const_reference; + typedef typename _Alloc::size_type size_type; + typedef typename _Alloc::difference_type difference_type; + + static pointer + allocate(_Alloc& __a, size_type __n) + { return __a.allocate(__n); } + + static void deallocate(_Alloc& __a, pointer __p, size_type __n) + { __a.deallocate(__p, __n); } + + template + static void construct(_Alloc& __a, pointer __p, const _Tp& __arg) + { __a.construct(__p, __arg); } + + static void destroy(_Alloc& __a, pointer __p) + { __a.destroy(__p); } + + static size_type max_size(const _Alloc& __a) + { return __a.max_size(); } + + static const _Alloc& _S_select_on_copy(const _Alloc& __a) { return __a; } + + static void _S_on_swap(_Alloc& __a, _Alloc& __b) + { + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 431. Swapping containers with unequal allocators. + std::__alloc_swap<_Alloc>::_S_do_it(__a, __b); + } + + template + struct rebind + { typedef typename _Alloc::template rebind<_Tp>::other other; }; +#endif + }; + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace std + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/ext/array_allocator.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/ext/array_allocator.h new file mode 100755 index 0000000..f807495 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/ext/array_allocator.h @@ -0,0 +1,174 @@ +// array allocator -*- C++ -*- + +// Copyright (C) 2004-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file ext/array_allocator.h + * This file is a GNU extension to the Standard C++ Library. + */ + +#ifndef _ARRAY_ALLOCATOR_H +#define _ARRAY_ALLOCATOR_H 1 + +#include +#include +#include +#include +#include +#if __cplusplus >= 201103L +#include +#endif + +namespace __gnu_cxx _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + using std::size_t; + using std::ptrdiff_t; + + /// Base class. + template + class array_allocator_base + { + public: + typedef size_t size_type; + typedef ptrdiff_t difference_type; + typedef _Tp* pointer; + typedef const _Tp* const_pointer; + typedef _Tp& reference; + typedef const _Tp& const_reference; + typedef _Tp value_type; + + pointer + address(reference __x) const _GLIBCXX_NOEXCEPT + { return std::__addressof(__x); } + + const_pointer + address(const_reference __x) const _GLIBCXX_NOEXCEPT + { return std::__addressof(__x); } + + void + deallocate(pointer, size_type) + { + // Does nothing. + } + + size_type + max_size() const _GLIBCXX_USE_NOEXCEPT + { return size_t(-1) / sizeof(_Tp); } + +#if __cplusplus >= 201103L + template + void + construct(_Up* __p, _Args&&... __args) + { ::new((void *)__p) _Up(std::forward<_Args>(__args)...); } + + template + void + destroy(_Up* __p) { __p->~_Up(); } +#else + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 402. wrong new expression in [some_] allocator::construct + void + construct(pointer __p, const _Tp& __val) + { ::new((void *)__p) value_type(__val); } + + void + destroy(pointer __p) { __p->~_Tp(); } +#endif + } _GLIBCXX_DEPRECATED; + + /** + * @brief An allocator that uses previously allocated memory. + * This memory can be externally, globally, or otherwise allocated. + * @ingroup allocators + */ + template > + class array_allocator : public array_allocator_base<_Tp> + { + public: + typedef size_t size_type; + typedef ptrdiff_t difference_type; + typedef _Tp* pointer; + typedef const _Tp* const_pointer; + typedef _Tp& reference; + typedef const _Tp& const_reference; + typedef _Tp value_type; + typedef _Array array_type; + +#if __cplusplus >= 201103L + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 2103. std::allocator propagate_on_container_move_assignment + typedef std::true_type propagate_on_container_move_assignment; +#endif + + private: + array_type* _M_array; + size_type _M_used; + + public: + template + struct rebind + { + typedef array_allocator<_Tp1, _Array1> other _GLIBCXX_DEPRECATED; + } _GLIBCXX_DEPRECATED; + + array_allocator(array_type* __array = 0) _GLIBCXX_USE_NOEXCEPT + : _M_array(__array), _M_used(size_type()) { } + + array_allocator(const array_allocator& __o) _GLIBCXX_USE_NOEXCEPT + : _M_array(__o._M_array), _M_used(__o._M_used) { } + + template + array_allocator(const array_allocator<_Tp1, _Array1>&) + _GLIBCXX_USE_NOEXCEPT + : _M_array(0), _M_used(size_type()) { } + + ~array_allocator() _GLIBCXX_USE_NOEXCEPT { } + + pointer + allocate(size_type __n, const void* = 0) + { + if (_M_array == 0 || _M_used + __n > _M_array->size()) + std::__throw_bad_alloc(); + pointer __ret = _M_array->begin() + _M_used; + _M_used += __n; + return __ret; + } + } _GLIBCXX_DEPRECATED; + + template + inline bool + operator==(const array_allocator<_Tp, _Array>&, + const array_allocator<_Tp, _Array>&) + { return true; } + + template + inline bool + operator!=(const array_allocator<_Tp, _Array>&, + const array_allocator<_Tp, _Array>&) + { return false; } + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/ext/atomicity.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/ext/atomicity.h new file mode 100755 index 0000000..bada709 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/ext/atomicity.h @@ -0,0 +1,117 @@ +// Support for atomic operations -*- C++ -*- + +// Copyright (C) 2004-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file ext/atomicity.h + * This file is a GNU extension to the Standard C++ Library. + */ + +#ifndef _GLIBCXX_ATOMICITY_H +#define _GLIBCXX_ATOMICITY_H 1 + +#pragma GCC system_header + +#include +#include +#include + +namespace __gnu_cxx _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + // Functions for portable atomic access. + // To abstract locking primitives across all thread policies, use: + // __exchange_and_add_dispatch + // __atomic_add_dispatch +#ifdef _GLIBCXX_ATOMIC_BUILTINS + static inline _Atomic_word + __exchange_and_add(volatile _Atomic_word* __mem, int __val) + { return __atomic_fetch_add(__mem, __val, __ATOMIC_ACQ_REL); } + + static inline void + __atomic_add(volatile _Atomic_word* __mem, int __val) + { __atomic_fetch_add(__mem, __val, __ATOMIC_ACQ_REL); } +#else + _Atomic_word + __attribute__ ((__unused__)) + __exchange_and_add(volatile _Atomic_word*, int) throw (); + + void + __attribute__ ((__unused__)) + __atomic_add(volatile _Atomic_word*, int) throw (); +#endif + + static inline _Atomic_word + __exchange_and_add_single(_Atomic_word* __mem, int __val) + { + _Atomic_word __result = *__mem; + *__mem += __val; + return __result; + } + + static inline void + __atomic_add_single(_Atomic_word* __mem, int __val) + { *__mem += __val; } + + static inline _Atomic_word + __attribute__ ((__unused__)) + __exchange_and_add_dispatch(_Atomic_word* __mem, int __val) + { +#ifdef __GTHREADS + if (__gthread_active_p()) + return __exchange_and_add(__mem, __val); + else + return __exchange_and_add_single(__mem, __val); +#else + return __exchange_and_add_single(__mem, __val); +#endif + } + + static inline void + __attribute__ ((__unused__)) + __atomic_add_dispatch(_Atomic_word* __mem, int __val) + { +#ifdef __GTHREADS + if (__gthread_active_p()) + __atomic_add(__mem, __val); + else + __atomic_add_single(__mem, __val); +#else + __atomic_add_single(__mem, __val); +#endif + } + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +// Even if the CPU doesn't need a memory barrier, we need to ensure +// that the compiler doesn't reorder memory accesses across the +// barriers. +#ifndef _GLIBCXX_READ_MEM_BARRIER +#define _GLIBCXX_READ_MEM_BARRIER __asm __volatile ("":::"memory") +#endif +#ifndef _GLIBCXX_WRITE_MEM_BARRIER +#define _GLIBCXX_WRITE_MEM_BARRIER __asm __volatile ("":::"memory") +#endif + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/ext/bitmap_allocator.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/ext/bitmap_allocator.h new file mode 100755 index 0000000..2bfbbf5 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/ext/bitmap_allocator.h @@ -0,0 +1,1119 @@ +// Bitmap Allocator. -*- C++ -*- + +// Copyright (C) 2004-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file ext/bitmap_allocator.h + * This file is a GNU extension to the Standard C++ Library. + */ + +#ifndef _BITMAP_ALLOCATOR_H +#define _BITMAP_ALLOCATOR_H 1 + +#include // For std::pair. +#include // For __throw_bad_alloc(). +#include // For greater_equal, and less_equal. +#include // For operator new. +#include // _GLIBCXX_DEBUG_ASSERT +#include +#include + +/** @brief The constant in the expression below is the alignment + * required in bytes. + */ +#define _BALLOC_ALIGN_BYTES 8 + +namespace __gnu_cxx _GLIBCXX_VISIBILITY(default) +{ + using std::size_t; + using std::ptrdiff_t; + + namespace __detail + { + _GLIBCXX_BEGIN_NAMESPACE_VERSION + /** @class __mini_vector bitmap_allocator.h bitmap_allocator.h + * + * @brief __mini_vector<> is a stripped down version of the + * full-fledged std::vector<>. + * + * It is to be used only for built-in types or PODs. Notable + * differences are: + * + * 1. Not all accessor functions are present. + * 2. Used ONLY for PODs. + * 3. No Allocator template argument. Uses ::operator new() to get + * memory, and ::operator delete() to free it. + * Caveat: The dtor does NOT free the memory allocated, so this a + * memory-leaking vector! + */ + template + class __mini_vector + { + __mini_vector(const __mini_vector&); + __mini_vector& operator=(const __mini_vector&); + + public: + typedef _Tp value_type; + typedef _Tp* pointer; + typedef _Tp& reference; + typedef const _Tp& const_reference; + typedef size_t size_type; + typedef ptrdiff_t difference_type; + typedef pointer iterator; + + private: + pointer _M_start; + pointer _M_finish; + pointer _M_end_of_storage; + + size_type + _M_space_left() const throw() + { return _M_end_of_storage - _M_finish; } + + pointer + allocate(size_type __n) + { return static_cast(::operator new(__n * sizeof(_Tp))); } + + void + deallocate(pointer __p, size_type) + { ::operator delete(__p); } + + public: + // Members used: size(), push_back(), pop_back(), + // insert(iterator, const_reference), erase(iterator), + // begin(), end(), back(), operator[]. + + __mini_vector() + : _M_start(0), _M_finish(0), _M_end_of_storage(0) { } + + size_type + size() const throw() + { return _M_finish - _M_start; } + + iterator + begin() const throw() + { return this->_M_start; } + + iterator + end() const throw() + { return this->_M_finish; } + + reference + back() const throw() + { return *(this->end() - 1); } + + reference + operator[](const size_type __pos) const throw() + { return this->_M_start[__pos]; } + + void + insert(iterator __pos, const_reference __x); + + void + push_back(const_reference __x) + { + if (this->_M_space_left()) + { + *this->end() = __x; + ++this->_M_finish; + } + else + this->insert(this->end(), __x); + } + + void + pop_back() throw() + { --this->_M_finish; } + + void + erase(iterator __pos) throw(); + + void + clear() throw() + { this->_M_finish = this->_M_start; } + }; + + // Out of line function definitions. + template + void __mini_vector<_Tp>:: + insert(iterator __pos, const_reference __x) + { + if (this->_M_space_left()) + { + size_type __to_move = this->_M_finish - __pos; + iterator __dest = this->end(); + iterator __src = this->end() - 1; + + ++this->_M_finish; + while (__to_move) + { + *__dest = *__src; + --__dest; --__src; --__to_move; + } + *__pos = __x; + } + else + { + size_type __new_size = this->size() ? this->size() * 2 : 1; + iterator __new_start = this->allocate(__new_size); + iterator __first = this->begin(); + iterator __start = __new_start; + while (__first != __pos) + { + *__start = *__first; + ++__start; ++__first; + } + *__start = __x; + ++__start; + while (__first != this->end()) + { + *__start = *__first; + ++__start; ++__first; + } + if (this->_M_start) + this->deallocate(this->_M_start, this->size()); + + this->_M_start = __new_start; + this->_M_finish = __start; + this->_M_end_of_storage = this->_M_start + __new_size; + } + } + + template + void __mini_vector<_Tp>:: + erase(iterator __pos) throw() + { + while (__pos + 1 != this->end()) + { + *__pos = __pos[1]; + ++__pos; + } + --this->_M_finish; + } + + + template + struct __mv_iter_traits + { + typedef typename _Tp::value_type value_type; + typedef typename _Tp::difference_type difference_type; + }; + + template + struct __mv_iter_traits<_Tp*> + { + typedef _Tp value_type; + typedef ptrdiff_t difference_type; + }; + + enum + { + bits_per_byte = 8, + bits_per_block = sizeof(size_t) * size_t(bits_per_byte) + }; + + template + _ForwardIterator + __lower_bound(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __val, _Compare __comp) + { + typedef typename __mv_iter_traits<_ForwardIterator>::difference_type + _DistanceType; + + _DistanceType __len = __last - __first; + _DistanceType __half; + _ForwardIterator __middle; + + while (__len > 0) + { + __half = __len >> 1; + __middle = __first; + __middle += __half; + if (__comp(*__middle, __val)) + { + __first = __middle; + ++__first; + __len = __len - __half - 1; + } + else + __len = __half; + } + return __first; + } + + /** @brief The number of Blocks pointed to by the address pair + * passed to the function. + */ + template + inline size_t + __num_blocks(_AddrPair __ap) + { return (__ap.second - __ap.first) + 1; } + + /** @brief The number of Bit-maps pointed to by the address pair + * passed to the function. + */ + template + inline size_t + __num_bitmaps(_AddrPair __ap) + { return __num_blocks(__ap) / size_t(bits_per_block); } + + // _Tp should be a pointer type. + template + class _Inclusive_between + : public std::unary_function, bool> + { + typedef _Tp pointer; + pointer _M_ptr_value; + typedef typename std::pair<_Tp, _Tp> _Block_pair; + + public: + _Inclusive_between(pointer __ptr) : _M_ptr_value(__ptr) + { } + + bool + operator()(_Block_pair __bp) const throw() + { + if (std::less_equal()(_M_ptr_value, __bp.second) + && std::greater_equal()(_M_ptr_value, __bp.first)) + return true; + else + return false; + } + }; + + // Used to pass a Functor to functions by reference. + template + class _Functor_Ref + : public std::unary_function + { + _Functor& _M_fref; + + public: + typedef typename _Functor::argument_type argument_type; + typedef typename _Functor::result_type result_type; + + _Functor_Ref(_Functor& __fref) : _M_fref(__fref) + { } + + result_type + operator()(argument_type __arg) + { return _M_fref(__arg); } + }; + + /** @class _Ffit_finder bitmap_allocator.h bitmap_allocator.h + * + * @brief The class which acts as a predicate for applying the + * first-fit memory allocation policy for the bitmap allocator. + */ + // _Tp should be a pointer type, and _Alloc is the Allocator for + // the vector. + template + class _Ffit_finder + : public std::unary_function, bool> + { + typedef typename std::pair<_Tp, _Tp> _Block_pair; + typedef typename __detail::__mini_vector<_Block_pair> _BPVector; + typedef typename _BPVector::difference_type _Counter_type; + + size_t* _M_pbitmap; + _Counter_type _M_data_offset; + + public: + _Ffit_finder() : _M_pbitmap(0), _M_data_offset(0) + { } + + bool + operator()(_Block_pair __bp) throw() + { + // Set the _rover to the last physical location bitmap, + // which is the bitmap which belongs to the first free + // block. Thus, the bitmaps are in exact reverse order of + // the actual memory layout. So, we count down the bitmaps, + // which is the same as moving up the memory. + + // If the used count stored at the start of the Bit Map headers + // is equal to the number of Objects that the current Block can + // store, then there is definitely no space for another single + // object, so just return false. + _Counter_type __diff = __detail::__num_bitmaps(__bp); + + if (*(reinterpret_cast + (__bp.first) - (__diff + 1)) == __detail::__num_blocks(__bp)) + return false; + + size_t* __rover = reinterpret_cast(__bp.first) - 1; + + for (_Counter_type __i = 0; __i < __diff; ++__i) + { + _M_data_offset = __i; + if (*__rover) + { + _M_pbitmap = __rover; + return true; + } + --__rover; + } + return false; + } + + size_t* + _M_get() const throw() + { return _M_pbitmap; } + + _Counter_type + _M_offset() const throw() + { return _M_data_offset * size_t(bits_per_block); } + }; + + /** @class _Bitmap_counter bitmap_allocator.h bitmap_allocator.h + * + * @brief The bitmap counter which acts as the bitmap + * manipulator, and manages the bit-manipulation functions and + * the searching and identification functions on the bit-map. + */ + // _Tp should be a pointer type. + template + class _Bitmap_counter + { + typedef typename + __detail::__mini_vector > _BPVector; + typedef typename _BPVector::size_type _Index_type; + typedef _Tp pointer; + + _BPVector& _M_vbp; + size_t* _M_curr_bmap; + size_t* _M_last_bmap_in_block; + _Index_type _M_curr_index; + + public: + // Use the 2nd parameter with care. Make sure that such an + // entry exists in the vector before passing that particular + // index to this ctor. + _Bitmap_counter(_BPVector& Rvbp, long __index = -1) : _M_vbp(Rvbp) + { this->_M_reset(__index); } + + void + _M_reset(long __index = -1) throw() + { + if (__index == -1) + { + _M_curr_bmap = 0; + _M_curr_index = static_cast<_Index_type>(-1); + return; + } + + _M_curr_index = __index; + _M_curr_bmap = reinterpret_cast + (_M_vbp[_M_curr_index].first) - 1; + + _GLIBCXX_DEBUG_ASSERT(__index <= (long)_M_vbp.size() - 1); + + _M_last_bmap_in_block = _M_curr_bmap + - ((_M_vbp[_M_curr_index].second + - _M_vbp[_M_curr_index].first + 1) + / size_t(bits_per_block) - 1); + } + + // Dangerous Function! Use with extreme care. Pass to this + // function ONLY those values that are known to be correct, + // otherwise this will mess up big time. + void + _M_set_internal_bitmap(size_t* __new_internal_marker) throw() + { _M_curr_bmap = __new_internal_marker; } + + bool + _M_finished() const throw() + { return(_M_curr_bmap == 0); } + + _Bitmap_counter& + operator++() throw() + { + if (_M_curr_bmap == _M_last_bmap_in_block) + { + if (++_M_curr_index == _M_vbp.size()) + _M_curr_bmap = 0; + else + this->_M_reset(_M_curr_index); + } + else + --_M_curr_bmap; + return *this; + } + + size_t* + _M_get() const throw() + { return _M_curr_bmap; } + + pointer + _M_base() const throw() + { return _M_vbp[_M_curr_index].first; } + + _Index_type + _M_offset() const throw() + { + return size_t(bits_per_block) + * ((reinterpret_cast(this->_M_base()) + - _M_curr_bmap) - 1); + } + + _Index_type + _M_where() const throw() + { return _M_curr_index; } + }; + + /** @brief Mark a memory address as allocated by re-setting the + * corresponding bit in the bit-map. + */ + inline void + __bit_allocate(size_t* __pbmap, size_t __pos) throw() + { + size_t __mask = 1 << __pos; + __mask = ~__mask; + *__pbmap &= __mask; + } + + /** @brief Mark a memory address as free by setting the + * corresponding bit in the bit-map. + */ + inline void + __bit_free(size_t* __pbmap, size_t __pos) throw() + { + size_t __mask = 1 << __pos; + *__pbmap |= __mask; + } + + _GLIBCXX_END_NAMESPACE_VERSION + } // namespace __detail + +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /** @brief Generic Version of the bsf instruction. + */ + inline size_t + _Bit_scan_forward(size_t __num) + { return static_cast(__builtin_ctzl(__num)); } + + /** @class free_list bitmap_allocator.h bitmap_allocator.h + * + * @brief The free list class for managing chunks of memory to be + * given to and returned by the bitmap_allocator. + */ + class free_list + { + public: + typedef size_t* value_type; + typedef __detail::__mini_vector vector_type; + typedef vector_type::iterator iterator; + typedef __mutex __mutex_type; + + private: + struct _LT_pointer_compare + { + bool + operator()(const size_t* __pui, + const size_t __cui) const throw() + { return *__pui < __cui; } + }; + +#if defined __GTHREADS + __mutex_type& + _M_get_mutex() + { + static __mutex_type _S_mutex; + return _S_mutex; + } +#endif + + vector_type& + _M_get_free_list() + { + static vector_type _S_free_list; + return _S_free_list; + } + + /** @brief Performs validation of memory based on their size. + * + * @param __addr The pointer to the memory block to be + * validated. + * + * Validates the memory block passed to this function and + * appropriately performs the action of managing the free list of + * blocks by adding this block to the free list or deleting this + * or larger blocks from the free list. + */ + void + _M_validate(size_t* __addr) throw() + { + vector_type& __free_list = _M_get_free_list(); + const vector_type::size_type __max_size = 64; + if (__free_list.size() >= __max_size) + { + // Ok, the threshold value has been reached. We determine + // which block to remove from the list of free blocks. + if (*__addr >= *__free_list.back()) + { + // Ok, the new block is greater than or equal to the + // last block in the list of free blocks. We just free + // the new block. + ::operator delete(static_cast(__addr)); + return; + } + else + { + // Deallocate the last block in the list of free lists, + // and insert the new one in its correct position. + ::operator delete(static_cast(__free_list.back())); + __free_list.pop_back(); + } + } + + // Just add the block to the list of free lists unconditionally. + iterator __temp = __detail::__lower_bound + (__free_list.begin(), __free_list.end(), + *__addr, _LT_pointer_compare()); + + // We may insert the new free list before _temp; + __free_list.insert(__temp, __addr); + } + + /** @brief Decides whether the wastage of memory is acceptable for + * the current memory request and returns accordingly. + * + * @param __block_size The size of the block available in the free + * list. + * + * @param __required_size The required size of the memory block. + * + * @return true if the wastage incurred is acceptable, else returns + * false. + */ + bool + _M_should_i_give(size_t __block_size, + size_t __required_size) throw() + { + const size_t __max_wastage_percentage = 36; + if (__block_size >= __required_size && + (((__block_size - __required_size) * 100 / __block_size) + < __max_wastage_percentage)) + return true; + else + return false; + } + + public: + /** @brief This function returns the block of memory to the + * internal free list. + * + * @param __addr The pointer to the memory block that was given + * by a call to the _M_get function. + */ + inline void + _M_insert(size_t* __addr) throw() + { +#if defined __GTHREADS + __scoped_lock __bfl_lock(_M_get_mutex()); +#endif + // Call _M_validate to decide what should be done with + // this particular free list. + this->_M_validate(reinterpret_cast(__addr) - 1); + // See discussion as to why this is 1! + } + + /** @brief This function gets a block of memory of the specified + * size from the free list. + * + * @param __sz The size in bytes of the memory required. + * + * @return A pointer to the new memory block of size at least + * equal to that requested. + */ + size_t* + _M_get(size_t __sz) throw(std::bad_alloc); + + /** @brief This function just clears the internal Free List, and + * gives back all the memory to the OS. + */ + void + _M_clear(); + }; + + + // Forward declare the class. + template + class bitmap_allocator; + + // Specialize for void: + template<> + class bitmap_allocator + { + public: + typedef void* pointer; + typedef const void* const_pointer; + + // Reference-to-void members are impossible. + typedef void value_type; + template + struct rebind + { + typedef bitmap_allocator<_Tp1> other; + }; + }; + + /** + * @brief Bitmap Allocator, primary template. + * @ingroup allocators + */ + template + class bitmap_allocator : private free_list + { + public: + typedef size_t size_type; + typedef ptrdiff_t difference_type; + typedef _Tp* pointer; + typedef const _Tp* const_pointer; + typedef _Tp& reference; + typedef const _Tp& const_reference; + typedef _Tp value_type; + typedef free_list::__mutex_type __mutex_type; + + template + struct rebind + { + typedef bitmap_allocator<_Tp1> other; + }; + +#if __cplusplus >= 201103L + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 2103. propagate_on_container_move_assignment + typedef std::true_type propagate_on_container_move_assignment; +#endif + + private: + template + struct aligned_size + { + enum + { + modulus = _BSize % _AlignSize, + value = _BSize + (modulus ? _AlignSize - (modulus) : 0) + }; + }; + + struct _Alloc_block + { + char __M_unused[aligned_size::value]; + }; + + + typedef typename std::pair<_Alloc_block*, _Alloc_block*> _Block_pair; + + typedef typename __detail::__mini_vector<_Block_pair> _BPVector; + typedef typename _BPVector::iterator _BPiter; + + template + static _BPiter + _S_find(_Predicate __p) + { + _BPiter __first = _S_mem_blocks.begin(); + while (__first != _S_mem_blocks.end() && !__p(*__first)) + ++__first; + return __first; + } + +#if defined _GLIBCXX_DEBUG + // Complexity: O(lg(N)). Where, N is the number of block of size + // sizeof(value_type). + void + _S_check_for_free_blocks() throw() + { + typedef typename __detail::_Ffit_finder<_Alloc_block*> _FFF; + _BPiter __bpi = _S_find(_FFF()); + + _GLIBCXX_DEBUG_ASSERT(__bpi == _S_mem_blocks.end()); + } +#endif + + /** @brief Responsible for exponentially growing the internal + * memory pool. + * + * @throw std::bad_alloc. If memory can not be allocated. + * + * Complexity: O(1), but internally depends upon the + * complexity of the function free_list::_M_get. The part where + * the bitmap headers are written has complexity: O(X),where X + * is the number of blocks of size sizeof(value_type) within + * the newly acquired block. Having a tight bound. + */ + void + _S_refill_pool() throw(std::bad_alloc) + { +#if defined _GLIBCXX_DEBUG + _S_check_for_free_blocks(); +#endif + + const size_t __num_bitmaps = (_S_block_size + / size_t(__detail::bits_per_block)); + const size_t __size_to_allocate = sizeof(size_t) + + _S_block_size * sizeof(_Alloc_block) + + __num_bitmaps * sizeof(size_t); + + size_t* __temp = + reinterpret_cast(this->_M_get(__size_to_allocate)); + *__temp = 0; + ++__temp; + + // The Header information goes at the Beginning of the Block. + _Block_pair __bp = + std::make_pair(reinterpret_cast<_Alloc_block*> + (__temp + __num_bitmaps), + reinterpret_cast<_Alloc_block*> + (__temp + __num_bitmaps) + + _S_block_size - 1); + + // Fill the Vector with this information. + _S_mem_blocks.push_back(__bp); + + for (size_t __i = 0; __i < __num_bitmaps; ++__i) + __temp[__i] = ~static_cast(0); // 1 Indicates all Free. + + _S_block_size *= 2; + } + + static _BPVector _S_mem_blocks; + static size_t _S_block_size; + static __detail::_Bitmap_counter<_Alloc_block*> _S_last_request; + static typename _BPVector::size_type _S_last_dealloc_index; +#if defined __GTHREADS + static __mutex_type _S_mut; +#endif + + public: + + /** @brief Allocates memory for a single object of size + * sizeof(_Tp). + * + * @throw std::bad_alloc. If memory can not be allocated. + * + * Complexity: Worst case complexity is O(N), but that + * is hardly ever hit. If and when this particular case is + * encountered, the next few cases are guaranteed to have a + * worst case complexity of O(1)! That's why this function + * performs very well on average. You can consider this + * function to have a complexity referred to commonly as: + * Amortized Constant time. + */ + pointer + _M_allocate_single_object() throw(std::bad_alloc) + { +#if defined __GTHREADS + __scoped_lock __bit_lock(_S_mut); +#endif + + // The algorithm is something like this: The last_request + // variable points to the last accessed Bit Map. When such a + // condition occurs, we try to find a free block in the + // current bitmap, or succeeding bitmaps until the last bitmap + // is reached. If no free block turns up, we resort to First + // Fit method. + + // WARNING: Do not re-order the condition in the while + // statement below, because it relies on C++'s short-circuit + // evaluation. The return from _S_last_request->_M_get() will + // NOT be dereference able if _S_last_request->_M_finished() + // returns true. This would inevitably lead to a NULL pointer + // dereference if tinkered with. + while (_S_last_request._M_finished() == false + && (*(_S_last_request._M_get()) == 0)) + _S_last_request.operator++(); + + if (__builtin_expect(_S_last_request._M_finished() == true, false)) + { + // Fall Back to First Fit algorithm. + typedef typename __detail::_Ffit_finder<_Alloc_block*> _FFF; + _FFF __fff; + _BPiter __bpi = _S_find(__detail::_Functor_Ref<_FFF>(__fff)); + + if (__bpi != _S_mem_blocks.end()) + { + // Search was successful. Ok, now mark the first bit from + // the right as 0, meaning Allocated. This bit is obtained + // by calling _M_get() on __fff. + size_t __nz_bit = _Bit_scan_forward(*__fff._M_get()); + __detail::__bit_allocate(__fff._M_get(), __nz_bit); + + _S_last_request._M_reset(__bpi - _S_mem_blocks.begin()); + + // Now, get the address of the bit we marked as allocated. + pointer __ret = reinterpret_cast + (__bpi->first + __fff._M_offset() + __nz_bit); + size_t* __puse_count = + reinterpret_cast + (__bpi->first) - (__detail::__num_bitmaps(*__bpi) + 1); + + ++(*__puse_count); + return __ret; + } + else + { + // Search was unsuccessful. We Add more memory to the + // pool by calling _S_refill_pool(). + _S_refill_pool(); + + // _M_Reset the _S_last_request structure to the first + // free block's bit map. + _S_last_request._M_reset(_S_mem_blocks.size() - 1); + + // Now, mark that bit as allocated. + } + } + + // _S_last_request holds a pointer to a valid bit map, that + // points to a free block in memory. + size_t __nz_bit = _Bit_scan_forward(*_S_last_request._M_get()); + __detail::__bit_allocate(_S_last_request._M_get(), __nz_bit); + + pointer __ret = reinterpret_cast + (_S_last_request._M_base() + _S_last_request._M_offset() + __nz_bit); + + size_t* __puse_count = reinterpret_cast + (_S_mem_blocks[_S_last_request._M_where()].first) + - (__detail:: + __num_bitmaps(_S_mem_blocks[_S_last_request._M_where()]) + 1); + + ++(*__puse_count); + return __ret; + } + + /** @brief Deallocates memory that belongs to a single object of + * size sizeof(_Tp). + * + * Complexity: O(lg(N)), but the worst case is not hit + * often! This is because containers usually deallocate memory + * close to each other and this case is handled in O(1) time by + * the deallocate function. + */ + void + _M_deallocate_single_object(pointer __p) throw() + { +#if defined __GTHREADS + __scoped_lock __bit_lock(_S_mut); +#endif + _Alloc_block* __real_p = reinterpret_cast<_Alloc_block*>(__p); + + typedef typename _BPVector::iterator _Iterator; + typedef typename _BPVector::difference_type _Difference_type; + + _Difference_type __diff; + long __displacement; + + _GLIBCXX_DEBUG_ASSERT(_S_last_dealloc_index >= 0); + + __detail::_Inclusive_between<_Alloc_block*> __ibt(__real_p); + if (__ibt(_S_mem_blocks[_S_last_dealloc_index])) + { + _GLIBCXX_DEBUG_ASSERT(_S_last_dealloc_index + <= _S_mem_blocks.size() - 1); + + // Initial Assumption was correct! + __diff = _S_last_dealloc_index; + __displacement = __real_p - _S_mem_blocks[__diff].first; + } + else + { + _Iterator _iter = _S_find(__ibt); + + _GLIBCXX_DEBUG_ASSERT(_iter != _S_mem_blocks.end()); + + __diff = _iter - _S_mem_blocks.begin(); + __displacement = __real_p - _S_mem_blocks[__diff].first; + _S_last_dealloc_index = __diff; + } + + // Get the position of the iterator that has been found. + const size_t __rotate = (__displacement + % size_t(__detail::bits_per_block)); + size_t* __bitmapC = + reinterpret_cast + (_S_mem_blocks[__diff].first) - 1; + __bitmapC -= (__displacement / size_t(__detail::bits_per_block)); + + __detail::__bit_free(__bitmapC, __rotate); + size_t* __puse_count = reinterpret_cast + (_S_mem_blocks[__diff].first) + - (__detail::__num_bitmaps(_S_mem_blocks[__diff]) + 1); + + _GLIBCXX_DEBUG_ASSERT(*__puse_count != 0); + + --(*__puse_count); + + if (__builtin_expect(*__puse_count == 0, false)) + { + _S_block_size /= 2; + + // We can safely remove this block. + // _Block_pair __bp = _S_mem_blocks[__diff]; + this->_M_insert(__puse_count); + _S_mem_blocks.erase(_S_mem_blocks.begin() + __diff); + + // Reset the _S_last_request variable to reflect the + // erased block. We do this to protect future requests + // after the last block has been removed from a particular + // memory Chunk, which in turn has been returned to the + // free list, and hence had been erased from the vector, + // so the size of the vector gets reduced by 1. + if ((_Difference_type)_S_last_request._M_where() >= __diff--) + _S_last_request._M_reset(__diff); + + // If the Index into the vector of the region of memory + // that might hold the next address that will be passed to + // deallocated may have been invalidated due to the above + // erase procedure being called on the vector, hence we + // try to restore this invariant too. + if (_S_last_dealloc_index >= _S_mem_blocks.size()) + { + _S_last_dealloc_index =(__diff != -1 ? __diff : 0); + _GLIBCXX_DEBUG_ASSERT(_S_last_dealloc_index >= 0); + } + } + } + + public: + bitmap_allocator() _GLIBCXX_USE_NOEXCEPT + { } + + bitmap_allocator(const bitmap_allocator&) _GLIBCXX_USE_NOEXCEPT + { } + + template + bitmap_allocator(const bitmap_allocator<_Tp1>&) _GLIBCXX_USE_NOEXCEPT + { } + + ~bitmap_allocator() _GLIBCXX_USE_NOEXCEPT + { } + + pointer + allocate(size_type __n) + { + if (__n > this->max_size()) + std::__throw_bad_alloc(); + + if (__builtin_expect(__n == 1, true)) + return this->_M_allocate_single_object(); + else + { + const size_type __b = __n * sizeof(value_type); + return reinterpret_cast(::operator new(__b)); + } + } + + pointer + allocate(size_type __n, typename bitmap_allocator::const_pointer) + { return allocate(__n); } + + void + deallocate(pointer __p, size_type __n) throw() + { + if (__builtin_expect(__p != 0, true)) + { + if (__builtin_expect(__n == 1, true)) + this->_M_deallocate_single_object(__p); + else + ::operator delete(__p); + } + } + + pointer + address(reference __r) const _GLIBCXX_NOEXCEPT + { return std::__addressof(__r); } + + const_pointer + address(const_reference __r) const _GLIBCXX_NOEXCEPT + { return std::__addressof(__r); } + + size_type + max_size() const _GLIBCXX_USE_NOEXCEPT + { return size_type(-1) / sizeof(value_type); } + +#if __cplusplus >= 201103L + template + void + construct(_Up* __p, _Args&&... __args) + { ::new((void *)__p) _Up(std::forward<_Args>(__args)...); } + + template + void + destroy(_Up* __p) + { __p->~_Up(); } +#else + void + construct(pointer __p, const_reference __data) + { ::new((void *)__p) value_type(__data); } + + void + destroy(pointer __p) + { __p->~value_type(); } +#endif + }; + + template + bool + operator==(const bitmap_allocator<_Tp1>&, + const bitmap_allocator<_Tp2>&) throw() + { return true; } + + template + bool + operator!=(const bitmap_allocator<_Tp1>&, + const bitmap_allocator<_Tp2>&) throw() + { return false; } + + // Static member definitions. + template + typename bitmap_allocator<_Tp>::_BPVector + bitmap_allocator<_Tp>::_S_mem_blocks; + + template + size_t bitmap_allocator<_Tp>::_S_block_size = + 2 * size_t(__detail::bits_per_block); + + template + typename bitmap_allocator<_Tp>::_BPVector::size_type + bitmap_allocator<_Tp>::_S_last_dealloc_index = 0; + + template + __detail::_Bitmap_counter + ::_Alloc_block*> + bitmap_allocator<_Tp>::_S_last_request(_S_mem_blocks); + +#if defined __GTHREADS + template + typename bitmap_allocator<_Tp>::__mutex_type + bitmap_allocator<_Tp>::_S_mut; +#endif + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace __gnu_cxx + +#endif + diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/ext/cast.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/ext/cast.h new file mode 100755 index 0000000..655ca06 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/ext/cast.h @@ -0,0 +1,121 @@ +// -*- C++ -*- + +// Copyright (C) 2008-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file ext/cast.h + * This is an internal header file, included by other library headers. + * Do not attempt to use it directly. @headername{ext/pointer.h} + */ + +#ifndef _GLIBCXX_CAST_H +#define _GLIBCXX_CAST_H 1 + +namespace __gnu_cxx _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /** + * These functions are here to allow containers to support non standard + * pointer types. For normal pointers, these resolve to the use of the + * standard cast operation. For other types the functions will perform + * the appropriate cast to/from the custom pointer class so long as that + * class meets the following conditions: + * 1) has a typedef element_type which names tehe type it points to. + * 2) has a get() const method which returns element_type*. + * 3) has a constructor which can take one element_type* argument. + */ + + /** + * This type supports the semantics of the pointer cast operators (below.) + */ + template + struct _Caster + { typedef typename _ToType::element_type* type; }; + + template + struct _Caster<_ToType*> + { typedef _ToType* type; }; + + /** + * Casting operations for cases where _FromType is not a standard pointer. + * _ToType can be a standard or non-standard pointer. Given that _FromType + * is not a pointer, it must have a get() method that returns the standard + * pointer equivalent of the address it points to, and must have an + * element_type typedef which names the type it points to. + */ + template + inline _ToType + __static_pointer_cast(const _FromType& __arg) + { return _ToType(static_cast:: + type>(__arg.get())); } + + template + inline _ToType + __dynamic_pointer_cast(const _FromType& __arg) + { return _ToType(dynamic_cast:: + type>(__arg.get())); } + + template + inline _ToType + __const_pointer_cast(const _FromType& __arg) + { return _ToType(const_cast:: + type>(__arg.get())); } + + template + inline _ToType + __reinterpret_pointer_cast(const _FromType& __arg) + { return _ToType(reinterpret_cast:: + type>(__arg.get())); } + + /** + * Casting operations for cases where _FromType is a standard pointer. + * _ToType can be a standard or non-standard pointer. + */ + template + inline _ToType + __static_pointer_cast(_FromType* __arg) + { return _ToType(static_cast:: + type>(__arg)); } + + template + inline _ToType + __dynamic_pointer_cast(_FromType* __arg) + { return _ToType(dynamic_cast:: + type>(__arg)); } + + template + inline _ToType + __const_pointer_cast(_FromType* __arg) + { return _ToType(const_cast:: + type>(__arg)); } + + template + inline _ToType + __reinterpret_pointer_cast(_FromType* __arg) + { return _ToType(reinterpret_cast:: + type>(__arg)); } + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif // _GLIBCXX_CAST_H diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/ext/cmath b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/ext/cmath new file mode 100755 index 0000000..91434d3 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/ext/cmath @@ -0,0 +1,152 @@ +// Math extensions -*- C++ -*- + +// Copyright (C) 2013-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file ext/cmath + * This file is a GNU extension to the Standard C++ Library. + */ + +#ifndef _EXT_CMATH +#define _EXT_CMATH 1 + +#pragma GCC system_header + +#if __cplusplus < 201103L +# include +#else + +#include +#include + +namespace __gnu_cxx _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + // A class for math constants. + template + struct __math_constants + { + static_assert(std::is_floating_point<_RealType>::value, + "template argument not a floating point type"); + + // Constant @f$ \pi @f$. + static constexpr _RealType __pi = 3.1415926535897932384626433832795029L; + // Constant @f$ \pi / 2 @f$. + static constexpr _RealType __pi_half = 1.5707963267948966192313216916397514L; + // Constant @f$ \pi / 3 @f$. + static constexpr _RealType __pi_third = 1.0471975511965977461542144610931676L; + // Constant @f$ \pi / 4 @f$. + static constexpr _RealType __pi_quarter = 0.7853981633974483096156608458198757L; + // Constant @f$ \sqrt(\pi / 2) @f$. + static constexpr _RealType __root_pi_div_2 = 1.2533141373155002512078826424055226L; + // Constant @f$ 1 / \pi @f$. + static constexpr _RealType __one_div_pi = 0.3183098861837906715377675267450287L; + // Constant @f$ 2 / \pi @f$. + static constexpr _RealType __two_div_pi = 0.6366197723675813430755350534900574L; + // Constant @f$ 2 / \sqrt(\pi) @f$. + static constexpr _RealType __two_div_root_pi = 1.1283791670955125738961589031215452L; + + // Constant Euler's number @f$ e @f$. + static constexpr _RealType __e = 2.7182818284590452353602874713526625L; + // Constant @f$ 1 / e @f$. + static constexpr _RealType __one_div_e = 0.36787944117144232159552377016146087L; + // Constant @f$ \log_2(e) @f$. + static constexpr _RealType __log2_e = 1.4426950408889634073599246810018921L; + // Constant @f$ \log_10(e) @f$. + static constexpr _RealType __log10_e = 0.4342944819032518276511289189166051L; + // Constant @f$ \ln(2) @f$. + static constexpr _RealType __ln_2 = 0.6931471805599453094172321214581766L; + // Constant @f$ \ln(3) @f$. + static constexpr _RealType __ln_3 = 1.0986122886681096913952452369225257L; + // Constant @f$ \ln(10) @f$. + static constexpr _RealType __ln_10 = 2.3025850929940456840179914546843642L; + + // Constant Euler-Mascheroni @f$ \gamma_E @f$. + static constexpr _RealType __gamma_e = 0.5772156649015328606065120900824024L; + // Constant Golden Ratio @f$ \phi @f$. + static constexpr _RealType __phi = 1.6180339887498948482045868343656381L; + + // Constant @f$ \sqrt(2) @f$. + static constexpr _RealType __root_2 = 1.4142135623730950488016887242096981L; + // Constant @f$ \sqrt(3) @f$. + static constexpr _RealType __root_3 = 1.7320508075688772935274463415058724L; + // Constant @f$ \sqrt(5) @f$. + static constexpr _RealType __root_5 = 2.2360679774997896964091736687312762L; + // Constant @f$ \sqrt(7) @f$. + static constexpr _RealType __root_7 = 2.6457513110645905905016157536392604L; + // Constant @f$ 1 / \sqrt(2) @f$. + static constexpr _RealType __one_div_root_2 = 0.7071067811865475244008443621048490L; + }; + + // And the template definitions for the constants. + template + constexpr _RealType __math_constants<_RealType>::__pi; + template + constexpr _RealType __math_constants<_RealType>::__pi_half; + template + constexpr _RealType __math_constants<_RealType>::__pi_third; + template + constexpr _RealType __math_constants<_RealType>::__pi_quarter; + template + constexpr _RealType __math_constants<_RealType>::__root_pi_div_2; + template + constexpr _RealType __math_constants<_RealType>::__one_div_pi; + template + constexpr _RealType __math_constants<_RealType>::__two_div_pi; + template + constexpr _RealType __math_constants<_RealType>::__two_div_root_pi; + template + constexpr _RealType __math_constants<_RealType>::__e; + template + constexpr _RealType __math_constants<_RealType>::__one_div_e; + template + constexpr _RealType __math_constants<_RealType>::__log2_e; + template + constexpr _RealType __math_constants<_RealType>::__log10_e; + template + constexpr _RealType __math_constants<_RealType>::__ln_2; + template + constexpr _RealType __math_constants<_RealType>::__ln_3; + template + constexpr _RealType __math_constants<_RealType>::__ln_10; + template + constexpr _RealType __math_constants<_RealType>::__gamma_e; + template + constexpr _RealType __math_constants<_RealType>::__phi; + template + constexpr _RealType __math_constants<_RealType>::__root_2; + template + constexpr _RealType __math_constants<_RealType>::__root_3; + template + constexpr _RealType __math_constants<_RealType>::__root_5; + template + constexpr _RealType __math_constants<_RealType>::__root_7; + template + constexpr _RealType __math_constants<_RealType>::__one_div_root_2; + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace __gnu_cxx + +#endif // C++11 + +#endif // _EXT_CMATH diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/ext/codecvt_specializations.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/ext/codecvt_specializations.h new file mode 100755 index 0000000..9a4c6e0 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/ext/codecvt_specializations.h @@ -0,0 +1,512 @@ +// Locale support (codecvt) -*- C++ -*- + +// Copyright (C) 2000-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +// +// ISO C++ 14882: 22.2.1.5 Template class codecvt +// + +// Written by Benjamin Kosnik + +/** @file ext/codecvt_specializations.h + * This file is a GNU extension to the Standard C++ Library. + */ + +#ifndef _EXT_CODECVT_SPECIALIZATIONS_H +#define _EXT_CODECVT_SPECIALIZATIONS_H 1 + +#include +#include +#include + +namespace __gnu_cxx _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /// Extension to use iconv for dealing with character encodings. + // This includes conversions and comparisons between various character + // sets. This object encapsulates data that may need to be shared between + // char_traits, codecvt and ctype. + class encoding_state + { + public: + // Types: + // NB: A conversion descriptor subsumes and enhances the + // functionality of a simple state type such as mbstate_t. + typedef iconv_t descriptor_type; + + protected: + // Name of internal character set encoding. + std::string _M_int_enc; + + // Name of external character set encoding. + std::string _M_ext_enc; + + // Conversion descriptor between external encoding to internal encoding. + descriptor_type _M_in_desc; + + // Conversion descriptor between internal encoding to external encoding. + descriptor_type _M_out_desc; + + // The byte-order marker for the external encoding, if necessary. + int _M_ext_bom; + + // The byte-order marker for the internal encoding, if necessary. + int _M_int_bom; + + // Number of external bytes needed to construct one complete + // character in the internal encoding. + // NB: -1 indicates variable, or stateful, encodings. + int _M_bytes; + + public: + explicit + encoding_state() + : _M_in_desc(0), _M_out_desc(0), _M_ext_bom(0), _M_int_bom(0), _M_bytes(0) + { } + + explicit + encoding_state(const char* __int, const char* __ext, + int __ibom = 0, int __ebom = 0, int __bytes = 1) + : _M_int_enc(__int), _M_ext_enc(__ext), _M_in_desc(0), _M_out_desc(0), + _M_ext_bom(__ebom), _M_int_bom(__ibom), _M_bytes(__bytes) + { init(); } + + // 21.1.2 traits typedefs + // p4 + // typedef STATE_T state_type + // requires: state_type shall meet the requirements of + // CopyConstructible types (20.1.3) + // NB: This does not preserve the actual state of the conversion + // descriptor member, but it does duplicate the encoding + // information. + encoding_state(const encoding_state& __obj) : _M_in_desc(0), _M_out_desc(0) + { construct(__obj); } + + // Need assignment operator as well. + encoding_state& + operator=(const encoding_state& __obj) + { + construct(__obj); + return *this; + } + + ~encoding_state() + { destroy(); } + + bool + good() const throw() + { + const descriptor_type __err = (iconv_t)(-1); + bool __test = _M_in_desc && _M_in_desc != __err; + __test &= _M_out_desc && _M_out_desc != __err; + return __test; + } + + int + character_ratio() const + { return _M_bytes; } + + const std::string + internal_encoding() const + { return _M_int_enc; } + + int + internal_bom() const + { return _M_int_bom; } + + const std::string + external_encoding() const + { return _M_ext_enc; } + + int + external_bom() const + { return _M_ext_bom; } + + const descriptor_type& + in_descriptor() const + { return _M_in_desc; } + + const descriptor_type& + out_descriptor() const + { return _M_out_desc; } + + protected: + void + init() + { + const descriptor_type __err = (iconv_t)(-1); + const bool __have_encodings = _M_int_enc.size() && _M_ext_enc.size(); + if (!_M_in_desc && __have_encodings) + { + _M_in_desc = iconv_open(_M_int_enc.c_str(), _M_ext_enc.c_str()); + if (_M_in_desc == __err) + std::__throw_runtime_error(__N("encoding_state::_M_init " + "creating iconv input descriptor failed")); + } + if (!_M_out_desc && __have_encodings) + { + _M_out_desc = iconv_open(_M_ext_enc.c_str(), _M_int_enc.c_str()); + if (_M_out_desc == __err) + std::__throw_runtime_error(__N("encoding_state::_M_init " + "creating iconv output descriptor failed")); + } + } + + void + construct(const encoding_state& __obj) + { + destroy(); + _M_int_enc = __obj._M_int_enc; + _M_ext_enc = __obj._M_ext_enc; + _M_ext_bom = __obj._M_ext_bom; + _M_int_bom = __obj._M_int_bom; + _M_bytes = __obj._M_bytes; + init(); + } + + void + destroy() throw() + { + const descriptor_type __err = (iconv_t)(-1); + if (_M_in_desc && _M_in_desc != __err) + { + iconv_close(_M_in_desc); + _M_in_desc = 0; + } + if (_M_out_desc && _M_out_desc != __err) + { + iconv_close(_M_out_desc); + _M_out_desc = 0; + } + } + }; + + /// encoding_char_traits + // Custom traits type with encoding_state for the state type, and the + // associated fpos for the position type, all other + // bits equivalent to the required char_traits instantiations. + template + struct encoding_char_traits : public std::char_traits<_CharT> + { + typedef encoding_state state_type; + typedef typename std::fpos pos_type; + }; + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + using __gnu_cxx::encoding_state; + + /// codecvt specialization. + // This partial specialization takes advantage of iconv to provide + // code conversions between a large number of character encodings. + template + class codecvt<_InternT, _ExternT, encoding_state> + : public __codecvt_abstract_base<_InternT, _ExternT, encoding_state> + { + public: + // Types: + typedef codecvt_base::result result; + typedef _InternT intern_type; + typedef _ExternT extern_type; + typedef __gnu_cxx::encoding_state state_type; + typedef state_type::descriptor_type descriptor_type; + + // Data Members: + static locale::id id; + + explicit + codecvt(size_t __refs = 0) + : __codecvt_abstract_base(__refs) + { } + + explicit + codecvt(state_type& __enc, size_t __refs = 0) + : __codecvt_abstract_base(__refs) + { } + + protected: + virtual + ~codecvt() { } + + virtual result + do_out(state_type& __state, const intern_type* __from, + const intern_type* __from_end, const intern_type*& __from_next, + extern_type* __to, extern_type* __to_end, + extern_type*& __to_next) const; + + virtual result + do_unshift(state_type& __state, extern_type* __to, + extern_type* __to_end, extern_type*& __to_next) const; + + virtual result + do_in(state_type& __state, const extern_type* __from, + const extern_type* __from_end, const extern_type*& __from_next, + intern_type* __to, intern_type* __to_end, + intern_type*& __to_next) const; + + virtual int + do_encoding() const throw(); + + virtual bool + do_always_noconv() const throw(); + + virtual int + do_length(state_type&, const extern_type* __from, + const extern_type* __end, size_t __max) const; + + virtual int + do_max_length() const throw(); + }; + + template + locale::id + codecvt<_InternT, _ExternT, encoding_state>::id; + + // This adaptor works around the signature problems of the second + // argument to iconv(): SUSv2 and others use 'const char**', but glibc 2.2 + // uses 'char**', which matches the POSIX 1003.1-2001 standard. + // Using this adaptor, g++ will do the work for us. + template + inline size_t + __iconv_adaptor(size_t(*__func)(iconv_t, _Tp, size_t*, char**, size_t*), + iconv_t __cd, char** __inbuf, size_t* __inbytes, + char** __outbuf, size_t* __outbytes) + { return __func(__cd, (_Tp)__inbuf, __inbytes, __outbuf, __outbytes); } + + template + codecvt_base::result + codecvt<_InternT, _ExternT, encoding_state>:: + do_out(state_type& __state, const intern_type* __from, + const intern_type* __from_end, const intern_type*& __from_next, + extern_type* __to, extern_type* __to_end, + extern_type*& __to_next) const + { + result __ret = codecvt_base::error; + if (__state.good()) + { + const descriptor_type& __desc = __state.out_descriptor(); + const size_t __fmultiple = sizeof(intern_type); + size_t __fbytes = __fmultiple * (__from_end - __from); + const size_t __tmultiple = sizeof(extern_type); + size_t __tbytes = __tmultiple * (__to_end - __to); + + // Argument list for iconv specifies a byte sequence. Thus, + // all to/from arrays must be brutally casted to char*. + char* __cto = reinterpret_cast(__to); + char* __cfrom; + size_t __conv; + + // Some encodings need a byte order marker as the first item + // in the byte stream, to designate endian-ness. The default + // value for the byte order marker is NULL, so if this is + // the case, it's not necessary and we can just go on our + // merry way. + int __int_bom = __state.internal_bom(); + if (__int_bom) + { + size_t __size = __from_end - __from; + intern_type* __cfixed = static_cast + (__builtin_alloca(sizeof(intern_type) * (__size + 1))); + __cfixed[0] = static_cast(__int_bom); + char_traits::copy(__cfixed + 1, __from, __size); + __cfrom = reinterpret_cast(__cfixed); + __conv = __iconv_adaptor(iconv, __desc, &__cfrom, + &__fbytes, &__cto, &__tbytes); + } + else + { + intern_type* __cfixed = const_cast(__from); + __cfrom = reinterpret_cast(__cfixed); + __conv = __iconv_adaptor(iconv, __desc, &__cfrom, &__fbytes, + &__cto, &__tbytes); + } + + if (__conv != size_t(-1)) + { + __from_next = reinterpret_cast(__cfrom); + __to_next = reinterpret_cast(__cto); + __ret = codecvt_base::ok; + } + else + { + if (__fbytes < __fmultiple * (__from_end - __from)) + { + __from_next = reinterpret_cast(__cfrom); + __to_next = reinterpret_cast(__cto); + __ret = codecvt_base::partial; + } + else + __ret = codecvt_base::error; + } + } + return __ret; + } + + template + codecvt_base::result + codecvt<_InternT, _ExternT, encoding_state>:: + do_unshift(state_type& __state, extern_type* __to, + extern_type* __to_end, extern_type*& __to_next) const + { + result __ret = codecvt_base::error; + if (__state.good()) + { + const descriptor_type& __desc = __state.in_descriptor(); + const size_t __tmultiple = sizeof(intern_type); + size_t __tlen = __tmultiple * (__to_end - __to); + + // Argument list for iconv specifies a byte sequence. Thus, + // all to/from arrays must be brutally casted to char*. + char* __cto = reinterpret_cast(__to); + size_t __conv = __iconv_adaptor(iconv,__desc, 0, 0, + &__cto, &__tlen); + + if (__conv != size_t(-1)) + { + __to_next = reinterpret_cast(__cto); + if (__tlen == __tmultiple * (__to_end - __to)) + __ret = codecvt_base::noconv; + else if (__tlen == 0) + __ret = codecvt_base::ok; + else + __ret = codecvt_base::partial; + } + else + __ret = codecvt_base::error; + } + return __ret; + } + + template + codecvt_base::result + codecvt<_InternT, _ExternT, encoding_state>:: + do_in(state_type& __state, const extern_type* __from, + const extern_type* __from_end, const extern_type*& __from_next, + intern_type* __to, intern_type* __to_end, + intern_type*& __to_next) const + { + result __ret = codecvt_base::error; + if (__state.good()) + { + const descriptor_type& __desc = __state.in_descriptor(); + const size_t __fmultiple = sizeof(extern_type); + size_t __flen = __fmultiple * (__from_end - __from); + const size_t __tmultiple = sizeof(intern_type); + size_t __tlen = __tmultiple * (__to_end - __to); + + // Argument list for iconv specifies a byte sequence. Thus, + // all to/from arrays must be brutally casted to char*. + char* __cto = reinterpret_cast(__to); + char* __cfrom; + size_t __conv; + + // Some encodings need a byte order marker as the first item + // in the byte stream, to designate endian-ness. The default + // value for the byte order marker is NULL, so if this is + // the case, it's not necessary and we can just go on our + // merry way. + int __ext_bom = __state.external_bom(); + if (__ext_bom) + { + size_t __size = __from_end - __from; + extern_type* __cfixed = static_cast + (__builtin_alloca(sizeof(extern_type) * (__size + 1))); + __cfixed[0] = static_cast(__ext_bom); + char_traits::copy(__cfixed + 1, __from, __size); + __cfrom = reinterpret_cast(__cfixed); + __conv = __iconv_adaptor(iconv, __desc, &__cfrom, + &__flen, &__cto, &__tlen); + } + else + { + extern_type* __cfixed = const_cast(__from); + __cfrom = reinterpret_cast(__cfixed); + __conv = __iconv_adaptor(iconv, __desc, &__cfrom, + &__flen, &__cto, &__tlen); + } + + + if (__conv != size_t(-1)) + { + __from_next = reinterpret_cast(__cfrom); + __to_next = reinterpret_cast(__cto); + __ret = codecvt_base::ok; + } + else + { + if (__flen < static_cast(__from_end - __from)) + { + __from_next = reinterpret_cast(__cfrom); + __to_next = reinterpret_cast(__cto); + __ret = codecvt_base::partial; + } + else + __ret = codecvt_base::error; + } + } + return __ret; + } + + template + int + codecvt<_InternT, _ExternT, encoding_state>:: + do_encoding() const throw() + { + int __ret = 0; + if (sizeof(_ExternT) <= sizeof(_InternT)) + __ret = sizeof(_InternT) / sizeof(_ExternT); + return __ret; + } + + template + bool + codecvt<_InternT, _ExternT, encoding_state>:: + do_always_noconv() const throw() + { return false; } + + template + int + codecvt<_InternT, _ExternT, encoding_state>:: + do_length(state_type&, const extern_type* __from, + const extern_type* __end, size_t __max) const + { return std::min(__max, static_cast(__end - __from)); } + + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 74. Garbled text for codecvt::do_max_length + template + int + codecvt<_InternT, _ExternT, encoding_state>:: + do_max_length() const throw() + { return 1; } + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/ext/concurrence.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/ext/concurrence.h new file mode 100755 index 0000000..1d39661 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/ext/concurrence.h @@ -0,0 +1,318 @@ +// Support for concurrent programing -*- C++ -*- + +// Copyright (C) 2003-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file ext/concurrence.h + * This file is a GNU extension to the Standard C++ Library. + */ + +#ifndef _CONCURRENCE_H +#define _CONCURRENCE_H 1 + +#pragma GCC system_header + +#include +#include +#include +#include +#include + +namespace __gnu_cxx _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + // Available locking policies: + // _S_single single-threaded code that doesn't need to be locked. + // _S_mutex multi-threaded code that requires additional support + // from gthr.h or abstraction layers in concurrence.h. + // _S_atomic multi-threaded code using atomic operations. + enum _Lock_policy { _S_single, _S_mutex, _S_atomic }; + + // Compile time constant that indicates prefered locking policy in + // the current configuration. + static const _Lock_policy __default_lock_policy = +#ifdef __GTHREADS +#if (defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2) \ + && defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4)) + _S_atomic; +#else + _S_mutex; +#endif +#else + _S_single; +#endif + + // NB: As this is used in libsupc++, need to only depend on + // exception. No stdexception classes, no use of std::string. + class __concurrence_lock_error : public std::exception + { + public: + virtual char const* + what() const throw() + { return "__gnu_cxx::__concurrence_lock_error"; } + }; + + class __concurrence_unlock_error : public std::exception + { + public: + virtual char const* + what() const throw() + { return "__gnu_cxx::__concurrence_unlock_error"; } + }; + + class __concurrence_broadcast_error : public std::exception + { + public: + virtual char const* + what() const throw() + { return "__gnu_cxx::__concurrence_broadcast_error"; } + }; + + class __concurrence_wait_error : public std::exception + { + public: + virtual char const* + what() const throw() + { return "__gnu_cxx::__concurrence_wait_error"; } + }; + + // Substitute for concurrence_error object in the case of -fno-exceptions. + inline void + __throw_concurrence_lock_error() + { _GLIBCXX_THROW_OR_ABORT(__concurrence_lock_error()); } + + inline void + __throw_concurrence_unlock_error() + { _GLIBCXX_THROW_OR_ABORT(__concurrence_unlock_error()); } + +#ifdef __GTHREAD_HAS_COND + inline void + __throw_concurrence_broadcast_error() + { _GLIBCXX_THROW_OR_ABORT(__concurrence_broadcast_error()); } + + inline void + __throw_concurrence_wait_error() + { _GLIBCXX_THROW_OR_ABORT(__concurrence_wait_error()); } +#endif + + class __mutex + { + private: +#if __GTHREADS && defined __GTHREAD_MUTEX_INIT + __gthread_mutex_t _M_mutex = __GTHREAD_MUTEX_INIT; +#else + __gthread_mutex_t _M_mutex; +#endif + + __mutex(const __mutex&); + __mutex& operator=(const __mutex&); + + public: + __mutex() + { +#if __GTHREADS && ! defined __GTHREAD_MUTEX_INIT + if (__gthread_active_p()) + __GTHREAD_MUTEX_INIT_FUNCTION(&_M_mutex); +#endif + } + +#if __GTHREADS && ! defined __GTHREAD_MUTEX_INIT + ~__mutex() + { + if (__gthread_active_p()) + __gthread_mutex_destroy(&_M_mutex); + } +#endif + + void lock() + { +#if __GTHREADS + if (__gthread_active_p()) + { + if (__gthread_mutex_lock(&_M_mutex) != 0) + __throw_concurrence_lock_error(); + } +#endif + } + + void unlock() + { +#if __GTHREADS + if (__gthread_active_p()) + { + if (__gthread_mutex_unlock(&_M_mutex) != 0) + __throw_concurrence_unlock_error(); + } +#endif + } + + __gthread_mutex_t* gthread_mutex(void) + { return &_M_mutex; } + }; + + class __recursive_mutex + { + private: +#if __GTHREADS && defined __GTHREAD_RECURSIVE_MUTEX_INIT + __gthread_recursive_mutex_t _M_mutex = __GTHREAD_RECURSIVE_MUTEX_INIT; +#else + __gthread_recursive_mutex_t _M_mutex; +#endif + + __recursive_mutex(const __recursive_mutex&); + __recursive_mutex& operator=(const __recursive_mutex&); + + public: + __recursive_mutex() + { +#if __GTHREADS && ! defined __GTHREAD_RECURSIVE_MUTEX_INIT + if (__gthread_active_p()) + __GTHREAD_RECURSIVE_MUTEX_INIT_FUNCTION(&_M_mutex); +#endif + } + +#if __GTHREADS && ! defined __GTHREAD_RECURSIVE_MUTEX_INIT + ~__recursive_mutex() + { + if (__gthread_active_p()) + __gthread_recursive_mutex_destroy(&_M_mutex); + } +#endif + + void lock() + { +#if __GTHREADS + if (__gthread_active_p()) + { + if (__gthread_recursive_mutex_lock(&_M_mutex) != 0) + __throw_concurrence_lock_error(); + } +#endif + } + + void unlock() + { +#if __GTHREADS + if (__gthread_active_p()) + { + if (__gthread_recursive_mutex_unlock(&_M_mutex) != 0) + __throw_concurrence_unlock_error(); + } +#endif + } + + __gthread_recursive_mutex_t* gthread_recursive_mutex(void) + { return &_M_mutex; } + }; + + /// Scoped lock idiom. + // Acquire the mutex here with a constructor call, then release with + // the destructor call in accordance with RAII style. + class __scoped_lock + { + public: + typedef __mutex __mutex_type; + + private: + __mutex_type& _M_device; + + __scoped_lock(const __scoped_lock&); + __scoped_lock& operator=(const __scoped_lock&); + + public: + explicit __scoped_lock(__mutex_type& __name) : _M_device(__name) + { _M_device.lock(); } + + ~__scoped_lock() throw() + { _M_device.unlock(); } + }; + +#ifdef __GTHREAD_HAS_COND + class __cond + { + private: +#if __GTHREADS && defined __GTHREAD_COND_INIT + __gthread_cond_t _M_cond = __GTHREAD_COND_INIT; +#else + __gthread_cond_t _M_cond; +#endif + + __cond(const __cond&); + __cond& operator=(const __cond&); + + public: + __cond() + { +#if __GTHREADS && ! defined __GTHREAD_COND_INIT + if (__gthread_active_p()) + __GTHREAD_COND_INIT_FUNCTION(&_M_cond); +#endif + } + +#if __GTHREADS && ! defined __GTHREAD_COND_INIT + ~__cond() + { + if (__gthread_active_p()) + __gthread_cond_destroy(&_M_cond); + } +#endif + + void broadcast() + { +#if __GTHREADS + if (__gthread_active_p()) + { + if (__gthread_cond_broadcast(&_M_cond) != 0) + __throw_concurrence_broadcast_error(); + } +#endif + } + + void wait(__mutex *mutex) + { +#if __GTHREADS + { + if (__gthread_cond_wait(&_M_cond, mutex->gthread_mutex()) != 0) + __throw_concurrence_wait_error(); + } +#endif + } + + void wait_recursive(__recursive_mutex *mutex) + { +#if __GTHREADS + { + if (__gthread_cond_wait_recursive(&_M_cond, + mutex->gthread_recursive_mutex()) + != 0) + __throw_concurrence_wait_error(); + } +#endif + } + }; +#endif + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/ext/debug_allocator.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/ext/debug_allocator.h new file mode 100755 index 0000000..ffdfee6 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/ext/debug_allocator.h @@ -0,0 +1,191 @@ +// Allocators -*- C++ -*- + +// Copyright (C) 2001-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/* + * Copyright (c) 1996-1997 + * Silicon Graphics Computer Systems, Inc. + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Silicon Graphics makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + */ + +/** @file ext/debug_allocator.h + * This file is a GNU extension to the Standard C++ Library. + */ + +#ifndef _DEBUG_ALLOCATOR_H +#define _DEBUG_ALLOCATOR_H 1 + +#include +#include +#include + +namespace __gnu_cxx _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + using std::size_t; + + /** + * @brief A meta-allocator with debugging bits. + * @ingroup allocators + * + * This is precisely the allocator defined in the C++03 Standard. + */ + template + class debug_allocator + { + template friend class debug_allocator; + + typedef __alloc_traits<_Alloc> _Traits; + + public: + typedef typename _Traits::size_type size_type; + typedef typename _Traits::difference_type difference_type; + typedef typename _Traits::pointer pointer; + typedef typename _Traits::const_pointer const_pointer; + typedef typename _Traits::reference reference; + typedef typename _Traits::const_reference const_reference; + typedef typename _Traits::value_type value_type; + + template + class rebind + { + typedef typename _Traits::template rebind<_Up>::other __other; + + public: + typedef debug_allocator<__other> other; + }; + + private: + // _M_extra is the number of objects that correspond to the + // extra space where debug information is stored. + size_type _M_extra; + + _Alloc _M_allocator; + + template::other> + struct __convertible + { }; + + template + struct __convertible<_Alloc2, _Alloc> + { + typedef void* __type; + }; + + size_type _S_extra() + { + const size_t __obj_size = sizeof(value_type); + return (sizeof(size_type) + __obj_size - 1) / __obj_size; + } + + public: + debug_allocator() : _M_extra(_S_extra()) { } + + template + debug_allocator(const debug_allocator<_Alloc2>& __a2, + typename __convertible<_Alloc2>::__type = 0) + : _M_allocator(__a2._M_allocator), _M_extra(_S_extra()) { } + + debug_allocator(const _Alloc& __a) + : _M_allocator(__a), _M_extra(_S_extra()) { } + + pointer + allocate(size_type __n) + { + pointer __res = _M_allocator.allocate(__n + _M_extra); + size_type* __ps = reinterpret_cast(__res); + *__ps = __n; + return __res + _M_extra; + } + + pointer + allocate(size_type __n, const void* __hint) + { + pointer __res = _M_allocator.allocate(__n + _M_extra, __hint); + size_type* __ps = reinterpret_cast(__res); + *__ps = __n; + return __res + _M_extra; + } + + void + deallocate(pointer __p, size_type __n) + { + using std::__throw_runtime_error; + if (__p) + { + pointer __real_p = __p - _M_extra; + if (*reinterpret_cast(__real_p) != __n) + __throw_runtime_error("debug_allocator::deallocate wrong size"); + _M_allocator.deallocate(__real_p, __n + _M_extra); + } + else + __throw_runtime_error("debug_allocator::deallocate null pointer"); + } + + void + construct(pointer __p, const value_type& __val) + { _Traits::construct(_M_allocator, __p, __val); } + +#if __cplusplus >= 201103L + template + void + construct(_Tp* __p, _Args&&... __args) + { + _Traits::construct(_M_allocator, __p, + std::forward<_Args>(__args)...); + } +#endif + + template + void + destroy(_Tp* __p) + { _Traits::destroy(_M_allocator, __p); } + + size_type + max_size() const throw() + { return _Traits::max_size(_M_allocator) - _M_extra; } + + friend bool + operator==(const debug_allocator& __lhs, const debug_allocator& __rhs) + { return __lhs._M_allocator == __rhs._M_allocator; } + }; + + template + inline bool + operator!=(const debug_allocator<_Alloc>& __lhs, + const debug_allocator<_Alloc>& __rhs) + { return !(__lhs == __rhs); } + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/ext/enc_filebuf.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/ext/enc_filebuf.h new file mode 100755 index 0000000..2a181fc --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/ext/enc_filebuf.h @@ -0,0 +1,65 @@ +// filebuf with encoding state type -*- C++ -*- + +// Copyright (C) 2002-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file ext/enc_filebuf.h + * This file is a GNU extension to the Standard C++ Library. + */ + +#ifndef _EXT_ENC_FILEBUF_H +#define _EXT_ENC_FILEBUF_H 1 + +#include +#include +#include + +namespace __gnu_cxx _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /// class enc_filebuf. + template + class enc_filebuf + : public std::basic_filebuf<_CharT, encoding_char_traits<_CharT> > + { + public: + typedef encoding_char_traits<_CharT> traits_type; + typedef typename traits_type::state_type state_type; + typedef typename traits_type::pos_type pos_type; + + enc_filebuf(state_type& __state) + : std::basic_filebuf<_CharT, encoding_char_traits<_CharT> >() + { this->_M_state_beg = __state; } + + private: + // concept requirements: + // Set state type to something useful. + // Something more than copyconstructible is needed here, so + // require default and copy constructible + assignment operator. + __glibcxx_class_requires(state_type, _SGIAssignableConcept) + }; + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/ext/extptr_allocator.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/ext/extptr_allocator.h new file mode 100755 index 0000000..1b8bdc7 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/ext/extptr_allocator.h @@ -0,0 +1,197 @@ +// -*- C++ -*- + +// Copyright (C) 2008-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** + * @file ext/extptr_allocator.h + * This file is a GNU extension to the Standard C++ Library. + * + * @author Bob Walters + * + * An example allocator which uses an alternative pointer type from + * bits/pointer.h. Supports test cases which confirm container support + * for alternative pointers. + */ + +#ifndef _EXTPTR_ALLOCATOR_H +#define _EXTPTR_ALLOCATOR_H 1 + +#include +#include +#include + +namespace __gnu_cxx _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + /** + * @brief An example allocator which uses a non-standard pointer type. + * @ingroup allocators + * + * This allocator specifies that containers use a 'relative pointer' as it's + * pointer type. (See ext/pointer.h) Memory allocation in this example + * is still performed using std::allocator. + */ + template + class _ExtPtr_allocator + { + public: + typedef std::size_t size_type; + typedef std::ptrdiff_t difference_type; + + // Note the non-standard pointer types. + typedef _Pointer_adapter<_Relative_pointer_impl<_Tp> > pointer; + typedef _Pointer_adapter<_Relative_pointer_impl > + const_pointer; + + typedef _Tp& reference; + typedef const _Tp& const_reference; + typedef _Tp value_type; + + template + struct rebind + { typedef _ExtPtr_allocator<_Up> other; }; + + _ExtPtr_allocator() _GLIBCXX_USE_NOEXCEPT + : _M_real_alloc() { } + + _ExtPtr_allocator(const _ExtPtr_allocator& __rarg) _GLIBCXX_USE_NOEXCEPT + : _M_real_alloc(__rarg._M_real_alloc) { } + + template + _ExtPtr_allocator(const _ExtPtr_allocator<_Up>& __rarg) + _GLIBCXX_USE_NOEXCEPT + : _M_real_alloc(__rarg._M_getUnderlyingImp()) { } + + ~_ExtPtr_allocator() _GLIBCXX_USE_NOEXCEPT + { } + + pointer address(reference __x) const _GLIBCXX_NOEXCEPT + { return std::__addressof(__x); } + + const_pointer address(const_reference __x) const _GLIBCXX_NOEXCEPT + { return std::__addressof(__x); } + + pointer allocate(size_type __n, void* __hint = 0) + { return _M_real_alloc.allocate(__n,__hint); } + + void deallocate(pointer __p, size_type __n) + { _M_real_alloc.deallocate(__p.get(), __n); } + + size_type max_size() const _GLIBCXX_USE_NOEXCEPT + { return __numeric_traits::__max / sizeof(_Tp); } + +#if __cplusplus >= 201103L + template + void + construct(_Up* __p, _Args&&... __args) + { ::new((void *)__p) _Up(std::forward<_Args>(__args)...); } + + template + void + construct(pointer __p, _Args&&... __args) + { construct(__p.get(), std::forward<_Args>(__args)...); } + + template + void + destroy(_Up* __p) + { __p->~_Up(); } + + void destroy(pointer __p) + { destroy(__p.get()); } + +#else + + void construct(pointer __p, const _Tp& __val) + { ::new(__p.get()) _Tp(__val); } + + void destroy(pointer __p) + { __p->~_Tp(); } +#endif + + template + inline bool + operator==(const _ExtPtr_allocator<_Up>& __rarg) + { return _M_real_alloc == __rarg._M_getUnderlyingImp(); } + + inline bool + operator==(const _ExtPtr_allocator& __rarg) + { return _M_real_alloc == __rarg._M_real_alloc; } + + template + inline bool + operator!=(const _ExtPtr_allocator<_Up>& __rarg) + { return _M_real_alloc != __rarg._M_getUnderlyingImp(); } + + inline bool + operator!=(const _ExtPtr_allocator& __rarg) + { return _M_real_alloc != __rarg._M_real_alloc; } + + template + inline friend void + swap(_ExtPtr_allocator<_Up>&, _ExtPtr_allocator<_Up>&); + + // A method specific to this implementation. + const std::allocator<_Tp>& + _M_getUnderlyingImp() const + { return _M_real_alloc; } + + private: + std::allocator<_Tp> _M_real_alloc; + }; + + // _ExtPtr_allocator specialization. + template<> + class _ExtPtr_allocator + { + public: + typedef std::size_t size_type; + typedef std::ptrdiff_t difference_type; + typedef void value_type; + + // Note the non-standard pointer types + typedef _Pointer_adapter<_Relative_pointer_impl > pointer; + typedef _Pointer_adapter<_Relative_pointer_impl > + const_pointer; + + template + struct rebind + { typedef _ExtPtr_allocator<_Up> other; }; + + private: + std::allocator _M_real_alloc; + }; + + template + inline void + swap(_ExtPtr_allocator<_Tp>& __larg, _ExtPtr_allocator<_Tp>& __rarg) + { + std::allocator<_Tp> __tmp( __rarg._M_real_alloc ); + __rarg._M_real_alloc = __larg._M_real_alloc; + __larg._M_real_alloc = __tmp; + } + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif /* _EXTPTR_ALLOCATOR_H */ diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/ext/functional b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/ext/functional new file mode 100755 index 0000000..ccdc85a --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/ext/functional @@ -0,0 +1,430 @@ +// Functional extensions -*- C++ -*- + +// Copyright (C) 2002-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/* + * + * Copyright (c) 1994 + * Hewlett-Packard Company + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Hewlett-Packard Company makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + * + * + * Copyright (c) 1996 + * Silicon Graphics Computer Systems, Inc. + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Silicon Graphics makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + */ + +/** @file ext/functional + * This file is a GNU extension to the Standard C++ Library (possibly + * containing extensions from the HP/SGI STL subset). + */ + +#ifndef _EXT_FUNCTIONAL +#define _EXT_FUNCTIONAL 1 + +#pragma GCC system_header + +#include + +namespace __gnu_cxx _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + using std::size_t; + using std::unary_function; + using std::binary_function; + using std::mem_fun1_t; + using std::const_mem_fun1_t; + using std::mem_fun1_ref_t; + using std::const_mem_fun1_ref_t; + + /** The @c identity_element functions are not part of the C++ + * standard; SGI provided them as an extension. Its argument is an + * operation, and its return value is the identity element for that + * operation. It is overloaded for addition and multiplication, + * and you can overload it for your own nefarious operations. + * + * @addtogroup SGIextensions + * @{ + */ + /// An \link SGIextensions SGI extension \endlink. + template + inline _Tp + identity_element(std::plus<_Tp>) + { return _Tp(0); } + + /// An \link SGIextensions SGI extension \endlink. + template + inline _Tp + identity_element(std::multiplies<_Tp>) + { return _Tp(1); } + /** @} */ + + /** As an extension to the binders, SGI provided composition functors and + * wrapper functions to aid in their creation. The @c unary_compose + * functor is constructed from two functions/functors, @c f and @c g. + * Calling @c operator() with a single argument @c x returns @c f(g(x)). + * The function @c compose1 takes the two functions and constructs a + * @c unary_compose variable for you. + * + * @c binary_compose is constructed from three functors, @c f, @c g1, + * and @c g2. Its @c operator() returns @c f(g1(x),g2(x)). The function + * compose2 takes f, g1, and g2, and constructs the @c binary_compose + * instance for you. For example, if @c f returns an int, then + * \code + * int answer = (compose2(f,g1,g2))(x); + * \endcode + * is equivalent to + * \code + * int temp1 = g1(x); + * int temp2 = g2(x); + * int answer = f(temp1,temp2); + * \endcode + * But the first form is more compact, and can be passed around as a + * functor to other algorithms. + * + * @addtogroup SGIextensions + * @{ + */ + /// An \link SGIextensions SGI extension \endlink. + template + class unary_compose + : public unary_function + { + protected: + _Operation1 _M_fn1; + _Operation2 _M_fn2; + + public: + unary_compose(const _Operation1& __x, const _Operation2& __y) + : _M_fn1(__x), _M_fn2(__y) {} + + typename _Operation1::result_type + operator()(const typename _Operation2::argument_type& __x) const + { return _M_fn1(_M_fn2(__x)); } + }; + + /// An \link SGIextensions SGI extension \endlink. + template + inline unary_compose<_Operation1, _Operation2> + compose1(const _Operation1& __fn1, const _Operation2& __fn2) + { return unary_compose<_Operation1,_Operation2>(__fn1, __fn2); } + + /// An \link SGIextensions SGI extension \endlink. + template + class binary_compose + : public unary_function + { + protected: + _Operation1 _M_fn1; + _Operation2 _M_fn2; + _Operation3 _M_fn3; + + public: + binary_compose(const _Operation1& __x, const _Operation2& __y, + const _Operation3& __z) + : _M_fn1(__x), _M_fn2(__y), _M_fn3(__z) { } + + typename _Operation1::result_type + operator()(const typename _Operation2::argument_type& __x) const + { return _M_fn1(_M_fn2(__x), _M_fn3(__x)); } + }; + + /// An \link SGIextensions SGI extension \endlink. + template + inline binary_compose<_Operation1, _Operation2, _Operation3> + compose2(const _Operation1& __fn1, const _Operation2& __fn2, + const _Operation3& __fn3) + { return binary_compose<_Operation1, _Operation2, _Operation3> + (__fn1, __fn2, __fn3); } + /** @} */ + + /** As an extension, SGI provided a functor called @c identity. When a + * functor is required but no operations are desired, this can be used as a + * pass-through. Its @c operator() returns its argument unchanged. + * + * @addtogroup SGIextensions + */ + template + struct identity + : public std::_Identity<_Tp> {}; + + /** @c select1st and @c select2nd are extensions provided by SGI. Their + * @c operator()s + * take a @c std::pair as an argument, and return either the first member + * or the second member, respectively. They can be used (especially with + * the composition functors) to @a strip data from a sequence before + * performing the remainder of an algorithm. + * + * @addtogroup SGIextensions + * @{ + */ + /// An \link SGIextensions SGI extension \endlink. + template + struct select1st + : public std::_Select1st<_Pair> {}; + + /// An \link SGIextensions SGI extension \endlink. + template + struct select2nd + : public std::_Select2nd<_Pair> {}; + + /** @} */ + + // extension documented next + template + struct _Project1st : public binary_function<_Arg1, _Arg2, _Arg1> + { + _Arg1 + operator()(const _Arg1& __x, const _Arg2&) const + { return __x; } + }; + + template + struct _Project2nd : public binary_function<_Arg1, _Arg2, _Arg2> + { + _Arg2 + operator()(const _Arg1&, const _Arg2& __y) const + { return __y; } + }; + + /** The @c operator() of the @c project1st functor takes two arbitrary + * arguments and returns the first one, while @c project2nd returns the + * second one. They are extensions provided by SGI. + * + * @addtogroup SGIextensions + * @{ + */ + + /// An \link SGIextensions SGI extension \endlink. + template + struct project1st : public _Project1st<_Arg1, _Arg2> {}; + + /// An \link SGIextensions SGI extension \endlink. + template + struct project2nd : public _Project2nd<_Arg1, _Arg2> {}; + /** @} */ + + // extension documented next + template + struct _Constant_void_fun + { + typedef _Result result_type; + result_type _M_val; + + _Constant_void_fun(const result_type& __v) : _M_val(__v) {} + + const result_type& + operator()() const + { return _M_val; } + }; + + template + struct _Constant_unary_fun + { + typedef _Argument argument_type; + typedef _Result result_type; + result_type _M_val; + + _Constant_unary_fun(const result_type& __v) : _M_val(__v) {} + + const result_type& + operator()(const _Argument&) const + { return _M_val; } + }; + + template + struct _Constant_binary_fun + { + typedef _Arg1 first_argument_type; + typedef _Arg2 second_argument_type; + typedef _Result result_type; + _Result _M_val; + + _Constant_binary_fun(const _Result& __v) : _M_val(__v) {} + + const result_type& + operator()(const _Arg1&, const _Arg2&) const + { return _M_val; } + }; + + /** These three functors are each constructed from a single arbitrary + * variable/value. Later, their @c operator()s completely ignore any + * arguments passed, and return the stored value. + * - @c constant_void_fun's @c operator() takes no arguments + * - @c constant_unary_fun's @c operator() takes one argument (ignored) + * - @c constant_binary_fun's @c operator() takes two arguments (ignored) + * + * The helper creator functions @c constant0, @c constant1, and + * @c constant2 each take a @a result argument and construct variables of + * the appropriate functor type. + * + * @addtogroup SGIextensions + * @{ + */ + /// An \link SGIextensions SGI extension \endlink. + template + struct constant_void_fun + : public _Constant_void_fun<_Result> + { + constant_void_fun(const _Result& __v) + : _Constant_void_fun<_Result>(__v) {} + }; + + /// An \link SGIextensions SGI extension \endlink. + template + struct constant_unary_fun : public _Constant_unary_fun<_Result, _Argument> + { + constant_unary_fun(const _Result& __v) + : _Constant_unary_fun<_Result, _Argument>(__v) {} + }; + + /// An \link SGIextensions SGI extension \endlink. + template + struct constant_binary_fun + : public _Constant_binary_fun<_Result, _Arg1, _Arg2> + { + constant_binary_fun(const _Result& __v) + : _Constant_binary_fun<_Result, _Arg1, _Arg2>(__v) {} + }; + + /// An \link SGIextensions SGI extension \endlink. + template + inline constant_void_fun<_Result> + constant0(const _Result& __val) + { return constant_void_fun<_Result>(__val); } + + /// An \link SGIextensions SGI extension \endlink. + template + inline constant_unary_fun<_Result, _Result> + constant1(const _Result& __val) + { return constant_unary_fun<_Result, _Result>(__val); } + + /// An \link SGIextensions SGI extension \endlink. + template + inline constant_binary_fun<_Result,_Result,_Result> + constant2(const _Result& __val) + { return constant_binary_fun<_Result, _Result, _Result>(__val); } + /** @} */ + + /** The @c subtractive_rng class is documented on + * SGI's site. + * Note that this code assumes that @c int is 32 bits. + * + * @ingroup SGIextensions + */ + class subtractive_rng + : public unary_function + { + private: + unsigned int _M_table[55]; + size_t _M_index1; + size_t _M_index2; + + public: + /// Returns a number less than the argument. + unsigned int + operator()(unsigned int __limit) + { + _M_index1 = (_M_index1 + 1) % 55; + _M_index2 = (_M_index2 + 1) % 55; + _M_table[_M_index1] = _M_table[_M_index1] - _M_table[_M_index2]; + return _M_table[_M_index1] % __limit; + } + + void + _M_initialize(unsigned int __seed) + { + unsigned int __k = 1; + _M_table[54] = __seed; + size_t __i; + for (__i = 0; __i < 54; __i++) + { + size_t __ii = (21 * (__i + 1) % 55) - 1; + _M_table[__ii] = __k; + __k = __seed - __k; + __seed = _M_table[__ii]; + } + for (int __loop = 0; __loop < 4; __loop++) + { + for (__i = 0; __i < 55; __i++) + _M_table[__i] = _M_table[__i] - _M_table[(1 + __i + 30) % 55]; + } + _M_index1 = 0; + _M_index2 = 31; + } + + /// Ctor allowing you to initialize the seed. + subtractive_rng(unsigned int __seed) + { _M_initialize(__seed); } + + /// Default ctor; initializes its state with some number you don't see. + subtractive_rng() + { _M_initialize(161803398u); } + }; + + // Mem_fun adaptor helper functions mem_fun1 and mem_fun1_ref, + // provided for backward compatibility, they are no longer part of + // the C++ standard. + + template + inline mem_fun1_t<_Ret, _Tp, _Arg> + mem_fun1(_Ret (_Tp::*__f)(_Arg)) + { return mem_fun1_t<_Ret, _Tp, _Arg>(__f); } + + template + inline const_mem_fun1_t<_Ret, _Tp, _Arg> + mem_fun1(_Ret (_Tp::*__f)(_Arg) const) + { return const_mem_fun1_t<_Ret, _Tp, _Arg>(__f); } + + template + inline mem_fun1_ref_t<_Ret, _Tp, _Arg> + mem_fun1_ref(_Ret (_Tp::*__f)(_Arg)) + { return mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); } + + template + inline const_mem_fun1_ref_t<_Ret, _Tp, _Arg> + mem_fun1_ref(_Ret (_Tp::*__f)(_Arg) const) + { return const_mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); } + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif + diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/ext/hash_map b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/ext/hash_map new file mode 100755 index 0000000..90019cf --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/ext/hash_map @@ -0,0 +1,599 @@ +// Hashing map implementation -*- C++ -*- + +// Copyright (C) 2001-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/* + * Copyright (c) 1996 + * Silicon Graphics Computer Systems, Inc. + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Silicon Graphics makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + * + * + * Copyright (c) 1994 + * Hewlett-Packard Company + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Hewlett-Packard Company makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + * + */ + +/** @file backward/hash_map + * This file is a GNU extension to the Standard C++ Library (possibly + * containing extensions from the HP/SGI STL subset). + */ + +#ifndef _BACKWARD_HASH_MAP +#define _BACKWARD_HASH_MAP 1 + +#ifndef _GLIBCXX_PERMIT_BACKWARD_HASH +#include "backward_warning.h" +#endif + +#include +#include +#include + +namespace __gnu_cxx _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + using std::equal_to; + using std::allocator; + using std::pair; + using std::_Select1st; + + /** + * This is an SGI extension. + * @ingroup SGIextensions + * @doctodo + */ + template, + class _EqualKey = equal_to<_Key>, class _Alloc = allocator<_Tp> > + class hash_map + { + private: + typedef hashtable,_Key, _HashFn, + _Select1st >, + _EqualKey, _Alloc> _Ht; + + _Ht _M_ht; + + public: + typedef typename _Ht::key_type key_type; + typedef _Tp data_type; + typedef _Tp mapped_type; + typedef typename _Ht::value_type value_type; + typedef typename _Ht::hasher hasher; + typedef typename _Ht::key_equal key_equal; + + typedef typename _Ht::size_type size_type; + typedef typename _Ht::difference_type difference_type; + typedef typename _Ht::pointer pointer; + typedef typename _Ht::const_pointer const_pointer; + typedef typename _Ht::reference reference; + typedef typename _Ht::const_reference const_reference; + + typedef typename _Ht::iterator iterator; + typedef typename _Ht::const_iterator const_iterator; + + typedef typename _Ht::allocator_type allocator_type; + + hasher + hash_funct() const + { return _M_ht.hash_funct(); } + + key_equal + key_eq() const + { return _M_ht.key_eq(); } + + allocator_type + get_allocator() const + { return _M_ht.get_allocator(); } + + hash_map() + : _M_ht(100, hasher(), key_equal(), allocator_type()) {} + + explicit + hash_map(size_type __n) + : _M_ht(__n, hasher(), key_equal(), allocator_type()) {} + + hash_map(size_type __n, const hasher& __hf) + : _M_ht(__n, __hf, key_equal(), allocator_type()) {} + + hash_map(size_type __n, const hasher& __hf, const key_equal& __eql, + const allocator_type& __a = allocator_type()) + : _M_ht(__n, __hf, __eql, __a) {} + + template + hash_map(_InputIterator __f, _InputIterator __l) + : _M_ht(100, hasher(), key_equal(), allocator_type()) + { _M_ht.insert_unique(__f, __l); } + + template + hash_map(_InputIterator __f, _InputIterator __l, size_type __n) + : _M_ht(__n, hasher(), key_equal(), allocator_type()) + { _M_ht.insert_unique(__f, __l); } + + template + hash_map(_InputIterator __f, _InputIterator __l, size_type __n, + const hasher& __hf) + : _M_ht(__n, __hf, key_equal(), allocator_type()) + { _M_ht.insert_unique(__f, __l); } + + template + hash_map(_InputIterator __f, _InputIterator __l, size_type __n, + const hasher& __hf, const key_equal& __eql, + const allocator_type& __a = allocator_type()) + : _M_ht(__n, __hf, __eql, __a) + { _M_ht.insert_unique(__f, __l); } + + size_type + size() const + { return _M_ht.size(); } + + size_type + max_size() const + { return _M_ht.max_size(); } + + bool + empty() const + { return _M_ht.empty(); } + + void + swap(hash_map& __hs) + { _M_ht.swap(__hs._M_ht); } + + template + friend bool + operator== (const hash_map<_K1, _T1, _HF, _EqK, _Al>&, + const hash_map<_K1, _T1, _HF, _EqK, _Al>&); + + iterator + begin() + { return _M_ht.begin(); } + + iterator + end() + { return _M_ht.end(); } + + const_iterator + begin() const + { return _M_ht.begin(); } + + const_iterator + end() const + { return _M_ht.end(); } + + pair + insert(const value_type& __obj) + { return _M_ht.insert_unique(__obj); } + + template + void + insert(_InputIterator __f, _InputIterator __l) + { _M_ht.insert_unique(__f, __l); } + + pair + insert_noresize(const value_type& __obj) + { return _M_ht.insert_unique_noresize(__obj); } + + iterator + find(const key_type& __key) + { return _M_ht.find(__key); } + + const_iterator + find(const key_type& __key) const + { return _M_ht.find(__key); } + + _Tp& + operator[](const key_type& __key) + { return _M_ht.find_or_insert(value_type(__key, _Tp())).second; } + + size_type + count(const key_type& __key) const + { return _M_ht.count(__key); } + + pair + equal_range(const key_type& __key) + { return _M_ht.equal_range(__key); } + + pair + equal_range(const key_type& __key) const + { return _M_ht.equal_range(__key); } + + size_type + erase(const key_type& __key) + {return _M_ht.erase(__key); } + + void + erase(iterator __it) + { _M_ht.erase(__it); } + + void + erase(iterator __f, iterator __l) + { _M_ht.erase(__f, __l); } + + void + clear() + { _M_ht.clear(); } + + void + resize(size_type __hint) + { _M_ht.resize(__hint); } + + size_type + bucket_count() const + { return _M_ht.bucket_count(); } + + size_type + max_bucket_count() const + { return _M_ht.max_bucket_count(); } + + size_type + elems_in_bucket(size_type __n) const + { return _M_ht.elems_in_bucket(__n); } + }; + + template + inline bool + operator==(const hash_map<_Key, _Tp, _HashFn, _EqlKey, _Alloc>& __hm1, + const hash_map<_Key, _Tp, _HashFn, _EqlKey, _Alloc>& __hm2) + { return __hm1._M_ht == __hm2._M_ht; } + + template + inline bool + operator!=(const hash_map<_Key, _Tp, _HashFn, _EqlKey, _Alloc>& __hm1, + const hash_map<_Key, _Tp, _HashFn, _EqlKey, _Alloc>& __hm2) + { return !(__hm1 == __hm2); } + + template + inline void + swap(hash_map<_Key, _Tp, _HashFn, _EqlKey, _Alloc>& __hm1, + hash_map<_Key, _Tp, _HashFn, _EqlKey, _Alloc>& __hm2) + { __hm1.swap(__hm2); } + + + /** + * This is an SGI extension. + * @ingroup SGIextensions + * @doctodo + */ + template, + class _EqualKey = equal_to<_Key>, + class _Alloc = allocator<_Tp> > + class hash_multimap + { + // concept requirements + __glibcxx_class_requires(_Key, _SGIAssignableConcept) + __glibcxx_class_requires(_Tp, _SGIAssignableConcept) + __glibcxx_class_requires3(_HashFn, size_t, _Key, _UnaryFunctionConcept) + __glibcxx_class_requires3(_EqualKey, _Key, _Key, _BinaryPredicateConcept) + + private: + typedef hashtable, _Key, _HashFn, + _Select1st >, _EqualKey, _Alloc> + _Ht; + + _Ht _M_ht; + + public: + typedef typename _Ht::key_type key_type; + typedef _Tp data_type; + typedef _Tp mapped_type; + typedef typename _Ht::value_type value_type; + typedef typename _Ht::hasher hasher; + typedef typename _Ht::key_equal key_equal; + + typedef typename _Ht::size_type size_type; + typedef typename _Ht::difference_type difference_type; + typedef typename _Ht::pointer pointer; + typedef typename _Ht::const_pointer const_pointer; + typedef typename _Ht::reference reference; + typedef typename _Ht::const_reference const_reference; + + typedef typename _Ht::iterator iterator; + typedef typename _Ht::const_iterator const_iterator; + + typedef typename _Ht::allocator_type allocator_type; + + hasher + hash_funct() const + { return _M_ht.hash_funct(); } + + key_equal + key_eq() const + { return _M_ht.key_eq(); } + + allocator_type + get_allocator() const + { return _M_ht.get_allocator(); } + + hash_multimap() + : _M_ht(100, hasher(), key_equal(), allocator_type()) {} + + explicit + hash_multimap(size_type __n) + : _M_ht(__n, hasher(), key_equal(), allocator_type()) {} + + hash_multimap(size_type __n, const hasher& __hf) + : _M_ht(__n, __hf, key_equal(), allocator_type()) {} + + hash_multimap(size_type __n, const hasher& __hf, const key_equal& __eql, + const allocator_type& __a = allocator_type()) + : _M_ht(__n, __hf, __eql, __a) {} + + template + hash_multimap(_InputIterator __f, _InputIterator __l) + : _M_ht(100, hasher(), key_equal(), allocator_type()) + { _M_ht.insert_equal(__f, __l); } + + template + hash_multimap(_InputIterator __f, _InputIterator __l, size_type __n) + : _M_ht(__n, hasher(), key_equal(), allocator_type()) + { _M_ht.insert_equal(__f, __l); } + + template + hash_multimap(_InputIterator __f, _InputIterator __l, size_type __n, + const hasher& __hf) + : _M_ht(__n, __hf, key_equal(), allocator_type()) + { _M_ht.insert_equal(__f, __l); } + + template + hash_multimap(_InputIterator __f, _InputIterator __l, size_type __n, + const hasher& __hf, const key_equal& __eql, + const allocator_type& __a = allocator_type()) + : _M_ht(__n, __hf, __eql, __a) + { _M_ht.insert_equal(__f, __l); } + + size_type + size() const + { return _M_ht.size(); } + + size_type + max_size() const + { return _M_ht.max_size(); } + + bool + empty() const + { return _M_ht.empty(); } + + void + swap(hash_multimap& __hs) + { _M_ht.swap(__hs._M_ht); } + + template + friend bool + operator==(const hash_multimap<_K1, _T1, _HF, _EqK, _Al>&, + const hash_multimap<_K1, _T1, _HF, _EqK, _Al>&); + + iterator + begin() + { return _M_ht.begin(); } + + iterator + end() + { return _M_ht.end(); } + + const_iterator + begin() const + { return _M_ht.begin(); } + + const_iterator + end() const + { return _M_ht.end(); } + + iterator + insert(const value_type& __obj) + { return _M_ht.insert_equal(__obj); } + + template + void + insert(_InputIterator __f, _InputIterator __l) + { _M_ht.insert_equal(__f,__l); } + + iterator + insert_noresize(const value_type& __obj) + { return _M_ht.insert_equal_noresize(__obj); } + + iterator + find(const key_type& __key) + { return _M_ht.find(__key); } + + const_iterator + find(const key_type& __key) const + { return _M_ht.find(__key); } + + size_type + count(const key_type& __key) const + { return _M_ht.count(__key); } + + pair + equal_range(const key_type& __key) + { return _M_ht.equal_range(__key); } + + pair + equal_range(const key_type& __key) const + { return _M_ht.equal_range(__key); } + + size_type + erase(const key_type& __key) + { return _M_ht.erase(__key); } + + void + erase(iterator __it) + { _M_ht.erase(__it); } + + void + erase(iterator __f, iterator __l) + { _M_ht.erase(__f, __l); } + + void + clear() + { _M_ht.clear(); } + + void + resize(size_type __hint) + { _M_ht.resize(__hint); } + + size_type + bucket_count() const + { return _M_ht.bucket_count(); } + + size_type + max_bucket_count() const + { return _M_ht.max_bucket_count(); } + + size_type + elems_in_bucket(size_type __n) const + { return _M_ht.elems_in_bucket(__n); } + }; + + template + inline bool + operator==(const hash_multimap<_Key, _Tp, _HF, _EqKey, _Alloc>& __hm1, + const hash_multimap<_Key, _Tp, _HF, _EqKey, _Alloc>& __hm2) + { return __hm1._M_ht == __hm2._M_ht; } + + template + inline bool + operator!=(const hash_multimap<_Key, _Tp, _HF, _EqKey, _Alloc>& __hm1, + const hash_multimap<_Key, _Tp, _HF, _EqKey, _Alloc>& __hm2) + { return !(__hm1 == __hm2); } + + template + inline void + swap(hash_multimap<_Key, _Tp, _HashFn, _EqlKey, _Alloc>& __hm1, + hash_multimap<_Key, _Tp, _HashFn, _EqlKey, _Alloc>& __hm2) + { __hm1.swap(__hm2); } + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + // Specialization of insert_iterator so that it will work for hash_map + // and hash_multimap. + template + class insert_iterator<__gnu_cxx::hash_map<_Key, _Tp, _HashFn, + _EqKey, _Alloc> > + { + protected: + typedef __gnu_cxx::hash_map<_Key, _Tp, _HashFn, _EqKey, _Alloc> + _Container; + _Container* container; + + public: + typedef _Container container_type; + typedef output_iterator_tag iterator_category; + typedef void value_type; + typedef void difference_type; + typedef void pointer; + typedef void reference; + + insert_iterator(_Container& __x) + : container(&__x) {} + + insert_iterator(_Container& __x, typename _Container::iterator) + : container(&__x) {} + + insert_iterator<_Container>& + operator=(const typename _Container::value_type& __value) + { + container->insert(__value); + return *this; + } + + insert_iterator<_Container>& + operator*() + { return *this; } + + insert_iterator<_Container>& + operator++() { return *this; } + + insert_iterator<_Container>& + operator++(int) + { return *this; } + }; + + template + class insert_iterator<__gnu_cxx::hash_multimap<_Key, _Tp, _HashFn, + _EqKey, _Alloc> > + { + protected: + typedef __gnu_cxx::hash_multimap<_Key, _Tp, _HashFn, _EqKey, _Alloc> + _Container; + _Container* container; + typename _Container::iterator iter; + + public: + typedef _Container container_type; + typedef output_iterator_tag iterator_category; + typedef void value_type; + typedef void difference_type; + typedef void pointer; + typedef void reference; + + insert_iterator(_Container& __x) + : container(&__x) {} + + insert_iterator(_Container& __x, typename _Container::iterator) + : container(&__x) {} + + insert_iterator<_Container>& + operator=(const typename _Container::value_type& __value) + { + container->insert(__value); + return *this; + } + + insert_iterator<_Container>& + operator*() + { return *this; } + + insert_iterator<_Container>& + operator++() + { return *this; } + + insert_iterator<_Container>& + operator++(int) + { return *this; } + }; + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/ext/hash_set b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/ext/hash_set new file mode 100755 index 0000000..3e834db --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/ext/hash_set @@ -0,0 +1,567 @@ +// Hashing set implementation -*- C++ -*- + +// Copyright (C) 2001-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/* + * Copyright (c) 1996 + * Silicon Graphics Computer Systems, Inc. + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Silicon Graphics makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + * + * + * Copyright (c) 1994 + * Hewlett-Packard Company + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Hewlett-Packard Company makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + * + */ + +/** @file backward/hash_set + * This file is a GNU extension to the Standard C++ Library (possibly + * containing extensions from the HP/SGI STL subset). + */ + +#ifndef _BACKWARD_HASH_SET +#define _BACKWARD_HASH_SET 1 + +#ifndef _GLIBCXX_PERMIT_BACKWARD_HASH +#include "backward_warning.h" +#endif + +#include +#include +#include + +namespace __gnu_cxx _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + using std::equal_to; + using std::allocator; + using std::pair; + using std::_Identity; + + /** + * This is an SGI extension. + * @ingroup SGIextensions + * @doctodo + */ + template, + class _EqualKey = equal_to<_Value>, + class _Alloc = allocator<_Value> > + class hash_set + { + // concept requirements + __glibcxx_class_requires(_Value, _SGIAssignableConcept) + __glibcxx_class_requires3(_HashFcn, size_t, _Value, _UnaryFunctionConcept) + __glibcxx_class_requires3(_EqualKey, _Value, _Value, _BinaryPredicateConcept) + + private: + typedef hashtable<_Value, _Value, _HashFcn, _Identity<_Value>, + _EqualKey, _Alloc> _Ht; + _Ht _M_ht; + + public: + typedef typename _Ht::key_type key_type; + typedef typename _Ht::value_type value_type; + typedef typename _Ht::hasher hasher; + typedef typename _Ht::key_equal key_equal; + + typedef typename _Ht::size_type size_type; + typedef typename _Ht::difference_type difference_type; + typedef typename _Alloc::pointer pointer; + typedef typename _Alloc::const_pointer const_pointer; + typedef typename _Alloc::reference reference; + typedef typename _Alloc::const_reference const_reference; + + typedef typename _Ht::const_iterator iterator; + typedef typename _Ht::const_iterator const_iterator; + + typedef typename _Ht::allocator_type allocator_type; + + hasher + hash_funct() const + { return _M_ht.hash_funct(); } + + key_equal + key_eq() const + { return _M_ht.key_eq(); } + + allocator_type + get_allocator() const + { return _M_ht.get_allocator(); } + + hash_set() + : _M_ht(100, hasher(), key_equal(), allocator_type()) {} + + explicit + hash_set(size_type __n) + : _M_ht(__n, hasher(), key_equal(), allocator_type()) {} + + hash_set(size_type __n, const hasher& __hf) + : _M_ht(__n, __hf, key_equal(), allocator_type()) {} + + hash_set(size_type __n, const hasher& __hf, const key_equal& __eql, + const allocator_type& __a = allocator_type()) + : _M_ht(__n, __hf, __eql, __a) {} + + template + hash_set(_InputIterator __f, _InputIterator __l) + : _M_ht(100, hasher(), key_equal(), allocator_type()) + { _M_ht.insert_unique(__f, __l); } + + template + hash_set(_InputIterator __f, _InputIterator __l, size_type __n) + : _M_ht(__n, hasher(), key_equal(), allocator_type()) + { _M_ht.insert_unique(__f, __l); } + + template + hash_set(_InputIterator __f, _InputIterator __l, size_type __n, + const hasher& __hf) + : _M_ht(__n, __hf, key_equal(), allocator_type()) + { _M_ht.insert_unique(__f, __l); } + + template + hash_set(_InputIterator __f, _InputIterator __l, size_type __n, + const hasher& __hf, const key_equal& __eql, + const allocator_type& __a = allocator_type()) + : _M_ht(__n, __hf, __eql, __a) + { _M_ht.insert_unique(__f, __l); } + + size_type + size() const + { return _M_ht.size(); } + + size_type + max_size() const + { return _M_ht.max_size(); } + + bool + empty() const + { return _M_ht.empty(); } + + void + swap(hash_set& __hs) + { _M_ht.swap(__hs._M_ht); } + + template + friend bool + operator==(const hash_set<_Val, _HF, _EqK, _Al>&, + const hash_set<_Val, _HF, _EqK, _Al>&); + + iterator + begin() const + { return _M_ht.begin(); } + + iterator + end() const + { return _M_ht.end(); } + + pair + insert(const value_type& __obj) + { + pair __p = _M_ht.insert_unique(__obj); + return pair(__p.first, __p.second); + } + + template + void + insert(_InputIterator __f, _InputIterator __l) + { _M_ht.insert_unique(__f, __l); } + + pair + insert_noresize(const value_type& __obj) + { + pair __p + = _M_ht.insert_unique_noresize(__obj); + return pair(__p.first, __p.second); + } + + iterator + find(const key_type& __key) const + { return _M_ht.find(__key); } + + size_type + count(const key_type& __key) const + { return _M_ht.count(__key); } + + pair + equal_range(const key_type& __key) const + { return _M_ht.equal_range(__key); } + + size_type + erase(const key_type& __key) + {return _M_ht.erase(__key); } + + void + erase(iterator __it) + { _M_ht.erase(__it); } + + void + erase(iterator __f, iterator __l) + { _M_ht.erase(__f, __l); } + + void + clear() + { _M_ht.clear(); } + + void + resize(size_type __hint) + { _M_ht.resize(__hint); } + + size_type + bucket_count() const + { return _M_ht.bucket_count(); } + + size_type + max_bucket_count() const + { return _M_ht.max_bucket_count(); } + + size_type + elems_in_bucket(size_type __n) const + { return _M_ht.elems_in_bucket(__n); } + }; + + template + inline bool + operator==(const hash_set<_Value, _HashFcn, _EqualKey, _Alloc>& __hs1, + const hash_set<_Value, _HashFcn, _EqualKey, _Alloc>& __hs2) + { return __hs1._M_ht == __hs2._M_ht; } + + template + inline bool + operator!=(const hash_set<_Value, _HashFcn, _EqualKey, _Alloc>& __hs1, + const hash_set<_Value, _HashFcn, _EqualKey, _Alloc>& __hs2) + { return !(__hs1 == __hs2); } + + template + inline void + swap(hash_set<_Val, _HashFcn, _EqualKey, _Alloc>& __hs1, + hash_set<_Val, _HashFcn, _EqualKey, _Alloc>& __hs2) + { __hs1.swap(__hs2); } + + + /** + * This is an SGI extension. + * @ingroup SGIextensions + * @doctodo + */ + template, + class _EqualKey = equal_to<_Value>, + class _Alloc = allocator<_Value> > + class hash_multiset + { + // concept requirements + __glibcxx_class_requires(_Value, _SGIAssignableConcept) + __glibcxx_class_requires3(_HashFcn, size_t, _Value, _UnaryFunctionConcept) + __glibcxx_class_requires3(_EqualKey, _Value, _Value, _BinaryPredicateConcept) + + private: + typedef hashtable<_Value, _Value, _HashFcn, _Identity<_Value>, + _EqualKey, _Alloc> _Ht; + _Ht _M_ht; + + public: + typedef typename _Ht::key_type key_type; + typedef typename _Ht::value_type value_type; + typedef typename _Ht::hasher hasher; + typedef typename _Ht::key_equal key_equal; + + typedef typename _Ht::size_type size_type; + typedef typename _Ht::difference_type difference_type; + typedef typename _Alloc::pointer pointer; + typedef typename _Alloc::const_pointer const_pointer; + typedef typename _Alloc::reference reference; + typedef typename _Alloc::const_reference const_reference; + + typedef typename _Ht::const_iterator iterator; + typedef typename _Ht::const_iterator const_iterator; + + typedef typename _Ht::allocator_type allocator_type; + + hasher + hash_funct() const + { return _M_ht.hash_funct(); } + + key_equal + key_eq() const + { return _M_ht.key_eq(); } + + allocator_type + get_allocator() const + { return _M_ht.get_allocator(); } + + hash_multiset() + : _M_ht(100, hasher(), key_equal(), allocator_type()) {} + + explicit + hash_multiset(size_type __n) + : _M_ht(__n, hasher(), key_equal(), allocator_type()) {} + + hash_multiset(size_type __n, const hasher& __hf) + : _M_ht(__n, __hf, key_equal(), allocator_type()) {} + + hash_multiset(size_type __n, const hasher& __hf, const key_equal& __eql, + const allocator_type& __a = allocator_type()) + : _M_ht(__n, __hf, __eql, __a) {} + + template + hash_multiset(_InputIterator __f, _InputIterator __l) + : _M_ht(100, hasher(), key_equal(), allocator_type()) + { _M_ht.insert_equal(__f, __l); } + + template + hash_multiset(_InputIterator __f, _InputIterator __l, size_type __n) + : _M_ht(__n, hasher(), key_equal(), allocator_type()) + { _M_ht.insert_equal(__f, __l); } + + template + hash_multiset(_InputIterator __f, _InputIterator __l, size_type __n, + const hasher& __hf) + : _M_ht(__n, __hf, key_equal(), allocator_type()) + { _M_ht.insert_equal(__f, __l); } + + template + hash_multiset(_InputIterator __f, _InputIterator __l, size_type __n, + const hasher& __hf, const key_equal& __eql, + const allocator_type& __a = allocator_type()) + : _M_ht(__n, __hf, __eql, __a) + { _M_ht.insert_equal(__f, __l); } + + size_type + size() const + { return _M_ht.size(); } + + size_type + max_size() const + { return _M_ht.max_size(); } + + bool + empty() const + { return _M_ht.empty(); } + + void + swap(hash_multiset& hs) + { _M_ht.swap(hs._M_ht); } + + template + friend bool + operator==(const hash_multiset<_Val, _HF, _EqK, _Al>&, + const hash_multiset<_Val, _HF, _EqK, _Al>&); + + iterator + begin() const + { return _M_ht.begin(); } + + iterator + end() const + { return _M_ht.end(); } + + iterator + insert(const value_type& __obj) + { return _M_ht.insert_equal(__obj); } + + template + void + insert(_InputIterator __f, _InputIterator __l) + { _M_ht.insert_equal(__f,__l); } + + iterator + insert_noresize(const value_type& __obj) + { return _M_ht.insert_equal_noresize(__obj); } + + iterator + find(const key_type& __key) const + { return _M_ht.find(__key); } + + size_type + count(const key_type& __key) const + { return _M_ht.count(__key); } + + pair + equal_range(const key_type& __key) const + { return _M_ht.equal_range(__key); } + + size_type + erase(const key_type& __key) + { return _M_ht.erase(__key); } + + void + erase(iterator __it) + { _M_ht.erase(__it); } + + void + erase(iterator __f, iterator __l) + { _M_ht.erase(__f, __l); } + + void + clear() + { _M_ht.clear(); } + + void + resize(size_type __hint) + { _M_ht.resize(__hint); } + + size_type + bucket_count() const + { return _M_ht.bucket_count(); } + + size_type + max_bucket_count() const + { return _M_ht.max_bucket_count(); } + + size_type + elems_in_bucket(size_type __n) const + { return _M_ht.elems_in_bucket(__n); } + }; + + template + inline bool + operator==(const hash_multiset<_Val, _HashFcn, _EqualKey, _Alloc>& __hs1, + const hash_multiset<_Val, _HashFcn, _EqualKey, _Alloc>& __hs2) + { return __hs1._M_ht == __hs2._M_ht; } + + template + inline bool + operator!=(const hash_multiset<_Val, _HashFcn, _EqualKey, _Alloc>& __hs1, + const hash_multiset<_Val, _HashFcn, _EqualKey, _Alloc>& __hs2) + { return !(__hs1 == __hs2); } + + template + inline void + swap(hash_multiset<_Val, _HashFcn, _EqualKey, _Alloc>& __hs1, + hash_multiset<_Val, _HashFcn, _EqualKey, _Alloc>& __hs2) + { __hs1.swap(__hs2); } + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +namespace std _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + // Specialization of insert_iterator so that it will work for hash_set + // and hash_multiset. + template + class insert_iterator<__gnu_cxx::hash_set<_Value, _HashFcn, + _EqualKey, _Alloc> > + { + protected: + typedef __gnu_cxx::hash_set<_Value, _HashFcn, _EqualKey, _Alloc> + _Container; + _Container* container; + + public: + typedef _Container container_type; + typedef output_iterator_tag iterator_category; + typedef void value_type; + typedef void difference_type; + typedef void pointer; + typedef void reference; + + insert_iterator(_Container& __x) + : container(&__x) {} + + insert_iterator(_Container& __x, typename _Container::iterator) + : container(&__x) {} + + insert_iterator<_Container>& + operator=(const typename _Container::value_type& __value) + { + container->insert(__value); + return *this; + } + + insert_iterator<_Container>& + operator*() + { return *this; } + + insert_iterator<_Container>& + operator++() + { return *this; } + + insert_iterator<_Container>& + operator++(int) + { return *this; } + }; + + template + class insert_iterator<__gnu_cxx::hash_multiset<_Value, _HashFcn, + _EqualKey, _Alloc> > + { + protected: + typedef __gnu_cxx::hash_multiset<_Value, _HashFcn, _EqualKey, _Alloc> + _Container; + _Container* container; + typename _Container::iterator iter; + + public: + typedef _Container container_type; + typedef output_iterator_tag iterator_category; + typedef void value_type; + typedef void difference_type; + typedef void pointer; + typedef void reference; + + insert_iterator(_Container& __x) + : container(&__x) {} + + insert_iterator(_Container& __x, typename _Container::iterator) + : container(&__x) {} + + insert_iterator<_Container>& + operator=(const typename _Container::value_type& __value) + { + container->insert(__value); + return *this; + } + + insert_iterator<_Container>& + operator*() + { return *this; } + + insert_iterator<_Container>& + operator++() + { return *this; } + + insert_iterator<_Container>& + operator++(int) { return *this; } + }; + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/ext/iterator b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/ext/iterator new file mode 100755 index 0000000..c751e49 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/ext/iterator @@ -0,0 +1,116 @@ +// HP/SGI iterator extensions -*- C++ -*- + +// Copyright (C) 2001-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/* + * + * Copyright (c) 1994 + * Hewlett-Packard Company + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Hewlett-Packard Company makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + * + * + * Copyright (c) 1996-1998 + * Silicon Graphics Computer Systems, Inc. + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Silicon Graphics makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + */ + +/** @file ext/iterator + * This file is a GNU extension to the Standard C++ Library (possibly + * containing extensions from the HP/SGI STL subset). + */ + +#ifndef _EXT_ITERATOR +#define _EXT_ITERATOR 1 + +#pragma GCC system_header + +#include +#include + +namespace __gnu_cxx _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + // There are two signatures for distance. In addition to the one + // taking two iterators and returning a result, there is another + // taking two iterators and a reference-to-result variable, and + // returning nothing. The latter seems to be an SGI extension. + // -- pedwards + template + inline void + __distance(_InputIterator __first, _InputIterator __last, + _Distance& __n, std::input_iterator_tag) + { + // concept requirements + __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>) + while (__first != __last) + { + ++__first; + ++__n; + } + } + + template + inline void + __distance(_RandomAccessIterator __first, _RandomAccessIterator __last, + _Distance& __n, std::random_access_iterator_tag) + { + // concept requirements + __glibcxx_function_requires(_RandomAccessIteratorConcept< + _RandomAccessIterator>) + __n += __last - __first; + } + + /** + * This is an SGI extension. + * @ingroup SGIextensions + * @doctodo + */ + template + inline void + distance(_InputIterator __first, _InputIterator __last, + _Distance& __n) + { + // concept requirements -- taken care of in __distance + __distance(__first, __last, __n, std::__iterator_category(__first)); + } + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif + diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/ext/malloc_allocator.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/ext/malloc_allocator.h new file mode 100755 index 0000000..83b65f1 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/ext/malloc_allocator.h @@ -0,0 +1,152 @@ +// Allocator that wraps "C" malloc -*- C++ -*- + +// Copyright (C) 2001-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file ext/malloc_allocator.h + * This file is a GNU extension to the Standard C++ Library. + */ + +#ifndef _MALLOC_ALLOCATOR_H +#define _MALLOC_ALLOCATOR_H 1 + +#include +#include +#include +#include +#if __cplusplus >= 201103L +#include +#endif + +namespace __gnu_cxx _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + using std::size_t; + using std::ptrdiff_t; + + /** + * @brief An allocator that uses malloc. + * @ingroup allocators + * + * This is precisely the allocator defined in the C++ Standard. + * - all allocation calls malloc + * - all deallocation calls free + */ + template + class malloc_allocator + { + public: + typedef size_t size_type; + typedef ptrdiff_t difference_type; + typedef _Tp* pointer; + typedef const _Tp* const_pointer; + typedef _Tp& reference; + typedef const _Tp& const_reference; + typedef _Tp value_type; + + template + struct rebind + { typedef malloc_allocator<_Tp1> other; }; + +#if __cplusplus >= 201103L + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 2103. propagate_on_container_move_assignment + typedef std::true_type propagate_on_container_move_assignment; +#endif + + malloc_allocator() _GLIBCXX_USE_NOEXCEPT { } + + malloc_allocator(const malloc_allocator&) _GLIBCXX_USE_NOEXCEPT { } + + template + malloc_allocator(const malloc_allocator<_Tp1>&) + _GLIBCXX_USE_NOEXCEPT { } + + ~malloc_allocator() _GLIBCXX_USE_NOEXCEPT { } + + pointer + address(reference __x) const _GLIBCXX_NOEXCEPT + { return std::__addressof(__x); } + + const_pointer + address(const_reference __x) const _GLIBCXX_NOEXCEPT + { return std::__addressof(__x); } + + // NB: __n is permitted to be 0. The C++ standard says nothing + // about what the return value is when __n == 0. + pointer + allocate(size_type __n, const void* = 0) + { + if (__n > this->max_size()) + std::__throw_bad_alloc(); + + pointer __ret = static_cast<_Tp*>(std::malloc(__n * sizeof(_Tp))); + if (!__ret) + std::__throw_bad_alloc(); + return __ret; + } + + // __p is not permitted to be a null pointer. + void + deallocate(pointer __p, size_type) + { std::free(static_cast(__p)); } + + size_type + max_size() const _GLIBCXX_USE_NOEXCEPT + { return size_t(-1) / sizeof(_Tp); } + +#if __cplusplus >= 201103L + template + void + construct(_Up* __p, _Args&&... __args) + { ::new((void *)__p) _Up(std::forward<_Args>(__args)...); } + + template + void + destroy(_Up* __p) { __p->~_Up(); } +#else + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 402. wrong new expression in [some_] allocator::construct + void + construct(pointer __p, const _Tp& __val) + { ::new((void *)__p) value_type(__val); } + + void + destroy(pointer __p) { __p->~_Tp(); } +#endif + }; + + template + inline bool + operator==(const malloc_allocator<_Tp>&, const malloc_allocator<_Tp>&) + { return true; } + + template + inline bool + operator!=(const malloc_allocator<_Tp>&, const malloc_allocator<_Tp>&) + { return false; } + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/ext/memory b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/ext/memory new file mode 100755 index 0000000..d36a5b4 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/ext/memory @@ -0,0 +1,197 @@ +// Memory extensions -*- C++ -*- + +// Copyright (C) 2002-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/* + * + * Copyright (c) 1994 + * Hewlett-Packard Company + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Hewlett-Packard Company makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + * + * + * Copyright (c) 1996 + * Silicon Graphics Computer Systems, Inc. + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Silicon Graphics makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + */ + +/** @file ext/memory + * This file is a GNU extension to the Standard C++ Library (possibly + * containing extensions from the HP/SGI STL subset). + */ + +#ifndef _EXT_MEMORY +#define _EXT_MEMORY 1 + +#pragma GCC system_header + +#include +#include + +namespace __gnu_cxx _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + using std::ptrdiff_t; + using std::pair; + using std::__iterator_category; + using std::_Temporary_buffer; + + template + pair<_InputIter, _ForwardIter> + __uninitialized_copy_n(_InputIter __first, _Size __count, + _ForwardIter __result, std::input_iterator_tag) + { + _ForwardIter __cur = __result; + __try + { + for (; __count > 0 ; --__count, ++__first, ++__cur) + std::_Construct(&*__cur, *__first); + return pair<_InputIter, _ForwardIter>(__first, __cur); + } + __catch(...) + { + std::_Destroy(__result, __cur); + __throw_exception_again; + } + } + + template + inline pair<_RandomAccessIter, _ForwardIter> + __uninitialized_copy_n(_RandomAccessIter __first, _Size __count, + _ForwardIter __result, + std::random_access_iterator_tag) + { + _RandomAccessIter __last = __first + __count; + return (pair<_RandomAccessIter, _ForwardIter> + (__last, std::uninitialized_copy(__first, __last, __result))); + } + + template + inline pair<_InputIter, _ForwardIter> + __uninitialized_copy_n(_InputIter __first, _Size __count, + _ForwardIter __result) + { return __gnu_cxx::__uninitialized_copy_n(__first, __count, __result, + __iterator_category(__first)); } + + /** + * @brief Copies the range [first,last) into result. + * @param __first An input iterator. + * @param __count Length + * @param __result An output iterator. + * @return __result + (__first + __count) + * @ingroup SGIextensions + * + * Like copy(), but does not require an initialized output range. + */ + template + inline pair<_InputIter, _ForwardIter> + uninitialized_copy_n(_InputIter __first, _Size __count, + _ForwardIter __result) + { return __gnu_cxx::__uninitialized_copy_n(__first, __count, __result, + __iterator_category(__first)); } + + + // An alternative version of uninitialized_copy_n that constructs + // and destroys objects with a user-provided allocator. + template + pair<_InputIter, _ForwardIter> + __uninitialized_copy_n_a(_InputIter __first, _Size __count, + _ForwardIter __result, + _Allocator __alloc) + { + _ForwardIter __cur = __result; + __try + { + for (; __count > 0 ; --__count, ++__first, ++__cur) + __alloc.construct(&*__cur, *__first); + return pair<_InputIter, _ForwardIter>(__first, __cur); + } + __catch(...) + { + std::_Destroy(__result, __cur, __alloc); + __throw_exception_again; + } + } + + template + inline pair<_InputIter, _ForwardIter> + __uninitialized_copy_n_a(_InputIter __first, _Size __count, + _ForwardIter __result, + std::allocator<_Tp>) + { + return __gnu_cxx::uninitialized_copy_n(__first, __count, __result); + } + + /** + * This class provides similar behavior and semantics of the standard + * functions get_temporary_buffer() and return_temporary_buffer(), but + * encapsulated in a type vaguely resembling a standard container. + * + * By default, a temporary_buffer stores space for objects of + * whatever type the Iter iterator points to. It is constructed from a + * typical [first,last) range, and provides the begin(), end(), size() + * functions, as well as requested_size(). For non-trivial types, copies + * of *first will be used to initialize the storage. + * + * @c malloc is used to obtain underlying storage. + * + * Like get_temporary_buffer(), not all the requested memory may be + * available. Ideally, the created buffer will be large enough to hold a + * copy of [first,last), but if size() is less than requested_size(), + * then this didn't happen. + * + * @ingroup SGIextensions + */ + template ::value_type > + struct temporary_buffer : public _Temporary_buffer<_ForwardIterator, _Tp> + { + /// Requests storage large enough to hold a copy of [first,last). + temporary_buffer(_ForwardIterator __first, _ForwardIterator __last) + : _Temporary_buffer<_ForwardIterator, _Tp>(__first, __last) { } + + /// Destroys objects and frees storage. + ~temporary_buffer() { } + }; + +_GLIBCXX_END_NAMESPACE_VERSION +} // namespace + +#endif + diff --git a/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/ext/mt_allocator.h b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/ext/mt_allocator.h new file mode 100755 index 0000000..0e6cfd9 --- /dev/null +++ b/third-party/odb/odb-2.4.0-x86_64-linux-gnu/lib/odb/x86_64-linux-gnu/include/c++/4.9.3/ext/mt_allocator.h @@ -0,0 +1,766 @@ +// MT-optimized allocator -*- C++ -*- + +// Copyright (C) 2003-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file ext/mt_allocator.h + * This file is a GNU extension to the Standard C++ Library. + */ + +#ifndef _MT_ALLOCATOR_H +#define _MT_ALLOCATOR_H 1 + +#include +#include +#include +#include +#include +#if __cplusplus >= 201103L +#include +#endif + +namespace __gnu_cxx _GLIBCXX_VISIBILITY(default) +{ +_GLIBCXX_BEGIN_NAMESPACE_VERSION + + using std::size_t; + using std::ptrdiff_t; + + typedef void (*__destroy_handler)(void*); + + /// Base class for pool object. + struct __pool_base + { + // Using short int as type for the binmap implies we are never + // caching blocks larger than 32768 with this allocator. + typedef unsigned short int _Binmap_type; + + // Variables used to configure the behavior of the allocator, + // assigned and explained in detail below. + struct _Tune + { + // Compile time constants for the default _Tune values. + enum { _S_align = 8 }; + enum { _S_max_bytes = 128 }; + enum { _S_min_bin = 8 }; + enum { _S_chunk_size = 4096 - 4 * sizeof(void*) }; + enum { _S_max_threads = 4096 }; + enum { _S_freelist_headroom = 10 }; + + // Alignment needed. + // NB: In any case must be >= sizeof(_Block_record), that + // is 4 on 32 bit machines and 8 on 64 bit machines. + size_t _M_align; + + // Allocation requests (after round-up to power of 2) below + // this value will be handled by the allocator. A raw new/ + // call will be used for requests larger than this value. + // NB: Must be much smaller than _M_chunk_size and in any + // case <= 32768. + size_t _M_max_bytes; + + // Size in bytes of the smallest bin. + // NB: Must be a power of 2 and >= _M_align (and of course + // much smaller than _M_max_bytes). + size_t _M_min_bin; + + // In order to avoid fragmenting and minimize the number of + // new() calls we always request new memory using this + // value. Based on previous discussions on the libstdc++ + // mailing list we have chosen the value below. + // See http://gcc.gnu.org/ml/libstdc++/2001-07/msg00077.html + // NB: At least one order of magnitude > _M_max_bytes. + size_t _M_chunk_size; + + // The maximum number of supported threads. For + // single-threaded operation, use one. Maximum values will + // vary depending on details of the underlying system. (For + // instance, Linux 2.4.18 reports 4070 in + // /proc/sys/kernel/threads-max, while Linux 2.6.6 reports + // 65534) + size_t _M_max_threads; + + // Each time a deallocation occurs in a threaded application + // we make sure that there are no more than + // _M_freelist_headroom % of used memory on the freelist. If + // the number of additional records is more than + // _M_freelist_headroom % of the freelist, we move these + // records back to the global pool. + size_t _M_freelist_headroom; + + // Set to true forces all allocations to use new(). + bool _M_force_new; + + explicit + _Tune() + : _M_align(_S_align), _M_max_bytes(_S_max_bytes), _M_min_bin(_S_min_bin), + _M_chunk_size(_S_chunk_size), _M_max_threads(_S_max_threads), + _M_freelist_headroom(_S_freelist_headroom), + _M_force_new(std::getenv("GLIBCXX_FORCE_NEW") ? true : false) + { } + + explicit + _Tune(size_t __align, size_t __maxb, size_t __minbin, size_t __chunk, + size_t __maxthreads, size_t __headroom, bool __force) + : _M_align(__align), _M_max_bytes(__maxb), _M_min_bin(__minbin), + _M_chunk_size(__chunk), _M_max_threads(__maxthreads), + _M_freelist_headroom(__headroom), _M_force_new(__force) + { } + }; + + struct _Block_address + { + void* _M_initial; + _Block_address* _M_next; + }; + + const _Tune& + _M_get_options() const + { return _M_options; } + + void + _M_set_options(_Tune __t) + { + if (!_M_init) + _M_options = __t; + } + + bool + _M_check_threshold(size_t __bytes) + { return __bytes > _M_options._M_max_bytes || _M_options._M_force_new; } + + size_t + _M_get_binmap(size_t __bytes) + { return _M_binmap[__bytes]; } + + size_t + _M_get_align() + { return _M_options._M_align; } + + explicit + __pool_base() + : _M_options(_Tune()), _M_binmap(0), _M_init(false) { } + + explicit + __pool_base(const _Tune& __options) + : _M_options(__options), _M_binmap(0), _M_init(false) { } + + private: + explicit + __pool_base(const __pool_base&); + + __pool_base& + operator=(const __pool_base&); + + protected: + // Configuration options. + _Tune _M_options; + + _Binmap_type* _M_binmap; + + // Configuration of the pool object via _M_options can happen + // after construction but before initialization. After + // initialization is complete, this variable is set to true. + bool _M_init; + }; + + + /** + * @brief Data describing the underlying memory pool, parameterized on + * threading support. + */ + template + class __pool; + + /// Specialization for single thread. + template<> + class __pool : public __pool_base + { + public: + union _Block_record + { + // Points to the block_record of the next free block. + _Block_record* _M_next; + }; + + struct _Bin_record + { + // An "array" of pointers to the first free block. + _Block_record** _M_first; + + // A list of the initial addresses of all allocated blocks. + _Block_address* _M_address; + }; + + void + _M_initialize_once() + { + if (__builtin_expect(_M_init == false, false)) + _M_initialize(); + } + + void + _M_destroy() throw(); + + char* + _M_reserve_block(size_t __bytes, const size_t __thread_id); + + void + _M_reclaim_block(char* __p, size_t __bytes) throw (); + + size_t + _M_get_thread_id() { return 0; } + + const _Bin_record& + _M_get_bin(size_t __which) + { return _M_bin[__which]; } + + void + _M_adjust_freelist(const _Bin_record&, _Block_record*, size_t) + { } + + explicit __pool() + : _M_bin(0), _M_bin_size(1) { } + + explicit __pool(const __pool_base::_Tune& __tune) + : __pool_base(__tune), _M_bin(0), _M_bin_size(1) { } + + private: + // An "array" of bin_records each of which represents a specific + // power of 2 size. Memory to this "array" is allocated in + // _M_initialize(). + _Bin_record* _M_bin; + + // Actual value calculated in _M_initialize(). + size_t _M_bin_size; + + void + _M_initialize(); + }; + +#ifdef __GTHREADS + /// Specialization for thread enabled, via gthreads.h. + template<> + class __pool : public __pool_base + { + public: + // Each requesting thread is assigned an id ranging from 1 to + // _S_max_threads. Thread id 0 is used as a global memory pool. + // In order to get constant performance on the thread assignment + // routine, we keep a list of free ids. When a thread first + // requests memory we remove the first record in this list and + // stores the address in a __gthread_key. When initializing the + // __gthread_key we specify a destructor. When this destructor + // (i.e. the thread dies) is called, we return the thread id to + // the front of this list. + struct _Thread_record + { + // Points to next free thread id record. NULL if last record in list. + _Thread_record* _M_next; + + // Thread id ranging from 1 to _S_max_threads. + size_t _M_id; + }; + + union _Block_record + { + // Points to the block_record of the next free block. + _Block_record* _M_next; + + // The thread id of the thread which has requested this block. + size_t _M_thread_id; + }; + + struct _Bin_record + { + // An "array" of pointers to the first free block for each + // thread id. Memory to this "array" is allocated in + // _S_initialize() for _S_max_threads + global pool 0. + _Block_record** _M_first; + + // A list of the initial addresses of all allocated blocks. + _Block_address* _M_address; + + // An "array" of counters used to keep track of the amount of + // blocks that are on the freelist/used for each thread id. + // - Note that the second part of the allocated _M_used "array" + // actually hosts (atomic) counters of reclaimed blocks: in + // _M_reserve_block and in _M_reclaim_block those numbers are + // subtracted from the first ones to obtain the actual size + // of the "working set" of the given thread. + // - Memory to these "arrays" is allocated in _S_initialize() + // for _S_max_threads + global pool 0. + size_t* _M_free; + size_t* _M_used; + + // Each bin has its own mutex which is used to ensure data + // integrity while changing "ownership" on a block. The mutex + // is initialized in _S_initialize(). + __gthread_mutex_t* _M_mutex; + }; + + // XXX GLIBCXX_ABI Deprecated + void + _M_initialize(__destroy_handler); + + void + _M_initialize_once() + { + if (__builtin_expect(_M_init == false, false)) + _M_initialize(); + } + + void + _M_destroy() throw(); + + char* + _M_reserve_block(size_t __bytes, const size_t __thread_id); + + void + _M_reclaim_block(char* __p, size_t __bytes) throw (); + + const _Bin_record& + _M_get_bin(size_t __which) + { return _M_bin[__which]; } + + void + _M_adjust_freelist(const _Bin_record& __bin, _Block_record* __block, + size_t __thread_id) + { + if (__gthread_active_p()) + { + __block->_M_thread_id = __thread_id; + --__bin._M_free[__thread_id]; + ++__bin._M_used[__thread_id]; + } + } + + // XXX GLIBCXX_ABI Deprecated + _GLIBCXX_CONST void + _M_destroy_thread_key(void*) throw (); + + size_t + _M_get_thread_id(); + + explicit __pool() + : _M_bin(0), _M_bin_size(1), _M_thread_freelist(0) + { } + + explicit __pool(const __pool_base::_Tune& __tune) + : __pool_base(__tune), _M_bin(0), _M_bin_size(1), + _M_thread_freelist(0) + { } + + private: + // An "array" of bin_records each of which represents a specific + // power of 2 size. Memory to this "array" is allocated in + // _M_initialize(). + _Bin_record* _M_bin; + + // Actual value calculated in _M_initialize(). + size_t _M_bin_size; + + _Thread_record* _M_thread_freelist; + void* _M_thread_freelist_initial; + + void + _M_initialize(); + }; +#endif + + template